pages/recommendation_system.py

import streamlit as st
import numpy as np
import pandas as pd
import requests
import pickle
import os
import altair as alt
import plotly.express as px

from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics.pairwise import cosine_similarity
from annotated_text import annotated_text
from utils import load_model_pickle, load_data_csv, check_password
from st_pages import add_indentation

#add_indentation()


st.set_page_config(layout="wide")

if check_password():
    st.markdown("# Recommendation systems 🛒")
    st.markdown("### What is a Recommendation System ?")

    st.info("""**Recommendation systems** are algorithms built to **suggest** or **recommend** **products** to consumers.
            They are very common in social media platforms such as TikTok, Youtube or Instagram or e-commerce websites as they help improve and personalize a consumer's experience.""")

    st.markdown("""There are two main types of recommendation systems:
- **Content-based filtering**: Recommendations are made based on the user's own preferences
- **Collaborative filtering**: Recommendations are made based on the preferences and behavior of similar users""", unsafe_allow_html=True)
                
    # st.markdown("""Here is an example of **Content-based filtering versus Collaborative filtering** for movie recommendations.""")
    st.markdown(" ")
    st.markdown(" ")

    # _, col_img, _ = st.columns(spec=[0.2,0.6,0.2])
    # with col_img:
    #     st.image("images/rs.png")

    st.image("images/rs.png")

    st.markdown(" ")

    st.markdown("""Common applications of Recommendation systems include:
- **E-Commerce Platforms** 🛍️: Suggest products to users based on their browsing history, purchase patterns, and preferences. 
- **Streaming Services** 📽️: Recommend movies, TV shows, or songs based on users' viewing/listening history and preferences. 
- **Social Media Platforms** 📱: Suggest friends, groups, or content based on users' connections, interests, and engagement history.
- **Automotive and Navigation Systems** 🗺️: Suggest optimal routes based on real-time traffic conditions, historical data, and user preferences.   
    """)

    st.markdown(" ")

    select_usecase = st.selectbox("**Choose a use case**", 
                                ["Movie recommendation system 📽️", 
                                "Hotel recommendation system 🛎️"])

    st.divider()



    #####################################################################################################
    #                                       MOVIE RECOMMENDATION SYSTEM                                 #
    #####################################################################################################

    # Recommendation function
    def recommend(movie_name, nb):
        n_movies_to_recommend = nb
        idx = movies[movies['title'] == movie_name].index[0]

        distances, indices = model.kneighbors(csr_data[idx], n_neighbors=n_movies_to_recommend + 1)
        idx = list(indices.squeeze())
        df = np.take(movies, idx, axis=0)

        movies_list = list(df.title[1:])

        recommend_movies_names = []
        recommend_posters = []
        movie_ids = []
        for i in movies_list:
            temp_movie_id = (movies[movies.title ==i].movie_id).values[0]
            movie_ids.append(temp_movie_id)

            poster = fetch_poster(temp_movie_id)
            recommend_posters.append(poster)
            
            # fetch poster
            try:
                poster = fetch_poster(temp_movie_id)
                recommend_posters.append(poster)
            except:
                recommend_posters.append(None)
            
            recommend_movies_names.append(i)
        return recommend_movies_names, recommend_posters, movie_ids

    # Get poster
    def fetch_poster(movie_id):
        response = requests.get(f'https://api.themoviedb.org/3/movie/{movie_id}?api_key={api_key}')
        data = response.json()
        return "https://image.tmdb.org/t/p/w500/" + data["poster_path"]



    if select_usecase == "Movie recommendation system 📽️":

        colors = ["#8ef", "#faa", "#afa", "#fea", "#8ef","#afa"]
        #api_key = st.secrets["recommendation_system"]["key"]
        api_key = os.environ["MOVIE_RECOM_API"]

        # Load data 
        path_data = r"data/movies"
        path_models = r"pretrained_models/recommendation_system"

        movies_dict = pickle.load(open(os.path.join(path_data,"movies_dict2.pkl"),"rb"))
        movies = pd.DataFrame(movies_dict)
        movies.drop_duplicates(inplace=True)

        vote_info = pickle.load(open(os.path.join(path_data,"vote_info.pkl"),"rb"))
        vote = pd.DataFrame(vote_info)

        # Load model
        model = load_model_pickle(path_models,"model.pkl")
        with open(os.path.join(path_data,'csr_data_tf.pkl'), 'rb') as file:
            csr_data = pickle.load(file)


        # Description of the use case
        st.markdown("""# Movie Recommendation System 📽️""")

        #st.info(""" """)

        st.markdown("""This use case showcases the use of recommender systems for **movie recommendations** using **collaborative filtering**. <br>
                    The model recommends and ranks movies based on what users, who have also watched the chosen movie, have watched else on the platform. <br> 
        """, unsafe_allow_html=True)
        st.markdown(" ")

        
        # User selection
        selected_movie = st.selectbox("**Select a movie**", movies["title"].values[:-3])
        selected_nb_movies = st.selectbox("**Select a number of movies to recommend**", np.arange(2,7), index=3)

        # Show user selection on the app
        c1, c2 = st.columns([0.7,0.3], gap="medium")
        with c1:
            new_movies = movies.rename({"movie_id":"id"},axis=1).merge(vote, on="id", how="left")
            description = new_movies.loc[new_movies["title"]==selected_movie,"description"].to_list()[0]
            genre = new_movies.loc[new_movies["title"]==selected_movie,"genre"].to_list()[0]
            vote_ = new_movies.loc[new_movies["title"]==selected_movie,"vote_average"].to_list()[0]
            vote_count = new_movies.loc[new_movies["title"]==selected_movie,"vote_count"].to_list()[0]
            
            list_genres = [(g.strip(),"",color) for color,g in zip(colors, genre.split(", "))]
            
            st.header(selected_movie, divider="grey")
            st.markdown(f"**Synopsis**: {description}")
            annotated_text(["**Genre(s)**: ", list_genres])
            st.markdown(f"**Rating**: {vote_}:star:")
            st.markdown(f"**Votes**: {vote_count}")

            st.info(f"You've selected {selected_nb_movies} movies to recommend")
            st.markdown(" ")
            
            recommend_button = st.button("**Recommend movies**")

        with c2:
            try:
                poster = fetch_poster(movies.loc[movies["title"]==selected_movie,"movie_id"].to_list()[0])
                st.image(poster, width=300)
            except:
                pass


        # Run model and show results
        if recommend_button:
            st.text("Here are few Recommendations..")
            names,posters,movie_ids = recommend(selected_movie, selected_nb_movies)
            tab1, tab2 = st.tabs(["View movies", "View genres"])

            with tab1:
                cols=st.columns(int(selected_nb_movies))
                #cols=[col1,col2,col3,col4,col5]
                for i in range(0,selected_nb_movies):
                    with cols[i]:
                        expander = st.expander("See movie details")
                        
                        # if posters[i] == None:
                        #     pass
                        # else:
                        #     st.image(posters[i])
                        
                        st.markdown(f"##### **{i+1}. {names[i]}**")
                        id = movie_ids[i]

                        genre = movies.loc[movies["movie_id"]==id,"genre"].to_list()[0]
                        list_genres = [(g.strip(),"",color) for color,g in zip(colors, genre.split(", "))]

                        synopsis = movies.loc[movies['movie_id']==id, "description"].to_list()[0]
                        st.markdown(synopsis)

                        vote_avg, vote_count = vote[vote["id"] == id].vote_average , vote[vote["id"] == id].vote_count
                        annotated_text(["**Genre(s)**: ", list_genres])
                        st.markdown(f"""**Rating**: {list(vote_avg.values)[0]}:star:""")
                        st.markdown(f"**Votes**: {list(vote_count.values)[0]}")
            
            
            with tab2:
                recommended_genres = movies.loc[movies["movie_id"].isin(movie_ids[:5]),"genre"].to_list()
                list_recom_genres = [genre for list_genres in recommended_genres for genre in list_genres.split(", ")]
                df_recom_genres = pd.Series(list_recom_genres).value_counts().to_frame().reset_index(names="genre")
                df_recom_genres["proportion (%)"] = (100*df_recom_genres["count"]/df_recom_genres["count"].sum())

                fig = px.bar(df_recom_genres, x='count', y='genre', color="genre", title='Most recommended genres', orientation="h")
                st.plotly_chart(fig, use_container_width=True)







    #####################################################################################################
    #                                       HOTEL RECOMMENDATION SYSTEM                                 #
    #####################################################################################################
                

    # Load scaler with caching
        
        
            
    if select_usecase == "Hotel recommendation system 🛎️":

        @st.cache_data(ttl=3600)
        def get_scaler(df):
            scaler = MinMaxScaler()
            scaler.fit(df[['Rating', 'Price']])
            return scaler

        def recommend_hotels_with_location_and_beds(df, preferences, max_recommendations=5):
            # Start with the full dataset
            filtered_df = df.copy()
            
            # Filter by Location if specified (either city or country)
            if 'Location' in preferences and preferences['Location']:
                filtered_df = filtered_df[(filtered_df['City'].str.contains(preferences['Location'], case=False, na=False)) |
                                        (filtered_df['Country'].str.contains(preferences['Location'], case=False, na=False))]

            # Filter by Number of beds if specified
            if 'Number of beds' in preferences:
                filtered_df = filtered_df[filtered_df['Number of bed'] == preferences['Number of beds']]
            
            # Filter by Rating if specified
            if 'Rating' in preferences:
                min_rating, max_rating = preferences['Rating']
                filtered_df = filtered_df[filtered_df['Rating'].between(min_rating, max_rating)]
            
            # Filter by Price range if specified
            if 'Price' in preferences:
                min_price, max_price = preferences['Price']
                filtered_df = filtered_df[filtered_df['Price'].between(min_price, max_price)]

            # Ensure there are still hotels after filtering
            if filtered_df.empty:
                # Send a notification if no hotels match the criteria
                send_notification("No hotels were found matching the specified criteria.")
                return pd.DataFrame(), "No hotels were found matching the specified criteria."
            
            preferences["Rating"] = np.mean(np.array(preferences["Rating"]))
            preferences["Price"] = np.mean(np.array(preferences["Price"]))

            # Normalize the preferences vector (excluding location and number of beds for similarity calculation)
            preferences_vector = np.array([[preferences.get('Rating', 0),
                                            preferences.get('Price', 0)]])
            preferences_vector_normalized = scaler.transform(preferences_vector)

            # Calculate similarity scores for the filtered hotels
            filtered_numerical_features = filtered_df[['Rating', 'Price']]
            filtered_numerical_features_normalized = scaler.transform(filtered_numerical_features)
            similarity_scores = cosine_similarity(preferences_vector_normalized, filtered_numerical_features_normalized)[0]

            # Get the indices of top_n similar hotels
            top_indices = similarity_scores.argsort()[-max_recommendations:][::-1]
            recommended_indices = filtered_df.iloc[top_indices].index

            # Return the recommended hotels with relevant details (including specified columns)
            return df.loc[recommended_indices], None


        def send_notification(message):
            """
            Placeholder function to send a notification.
            This function can be replaced with the actual notification mechanism (e.g., email, SMS).
            """
            print("Notification:", message)


        def country_info(country):
            if country == "Thailand":
                image = "images/thailand.jpeg"
                emoji = "🏝️"
                description = """**Description**: 
    Thailand seamlessly fuses ancient traditions with modern dynamism, creating an unparalleled tapestry for travelers. 
    Renowned for its warm hospitality, vibrant culture, and delectable cuisine, Thailand offers an unforgettable experience for every adventurer."""
                top_places = """
- **Bangkok**: Immerse yourself in the hustle and bustle of Bangkok's streets, adorned with glittering temples and bustling markets. The Grand Palace and Khao San Road showcase the city's unique blend of tradition and modernity.
- **Chiang Mai**: Nestled in the misty mountains of Northern Thailand, Chiang Mai captivates with ancient temples, lush landscapes, and vibrant night markets. The Old City exudes a unique atmosphere, while the surrounding hills offer tranquility.
- **Phuket**: Thailand's largest island, Phuket, beckons beach lovers with its stunning white sands, vibrant nightlife, and water activities. It's a perfect blend of relaxation and excitement."""

            if country == "France":
                image = "images/france.jpeg"
                emoji = "⚜️"
                description ="""**Description**:
    Indulge in the countries rich tapestry of art, culture, and gastronomy. 
    From the romantic allure of Paris to the sun-kissed vineyards of Provence, every corner of this diverse country tells a unique story, promising an unforgettable journey for every traveler."""
                top_places = """ 
- **Paris**: Dive into the city's iconic landmarks such as the Eiffel Tower, Louvre Museum, and Notre-Dame Cathedral grace the skyline.
- **Provence**: Visit the stunning Palais des Papes in Avignon, explore the colorful markets of Aix-en-Provence, and unwind in the serene beauty of the Luberon region.
- **Côte d'Azur**: This stunning stretch of the French coastline is a captivating blend of azure waters, picturesque landscapes and charming villages.
    """

            if country == "Spain":
                image = "images/spain-banner.jpg"
                emoji = "☀️"
                description = """**Description**:
    Embark on an unforgettable journey where tradition and modernity coexist in harmony. 
    From the lively streets of Barcelona to the sun-soaked beaches of Andalusia, Spain offers a captivating blend of history, culture, and natural beauty.            
    """
                top_places = """
- **Barcelona**: Explore the iconic Sagrada Familia, stroll down the vibrant La Rambla, and soak in the Mediterranean ambiance at Barceloneta Beach.
- **Seville**: Visit the awe-inspiring Alcázar, marvel at the Giralda Tower, and wander through the enchanting alleys of the Santa Cruz neighborhood.
- **Granada**: Explore the Generalife Gardens, stroll through the Albayzín quarter with its narrow streets and white houses, and savor the views of the city from the Mirador de San Nicolás.
    """

            if country == "Singapore":
                image = "images/singapore.jpg"
                emoji = "🏙️"
                description = """**Description**:
    From gleaming skyscrapers to vibrant neighborhoods, this cosmopolitan gem in Southeast Asia promises an immersive journey into a world where tradition meets cutting-edge technology."""

                top_places = """
- **Marina Bay Sands**: Enjoy panoramic views from the SkyPark, take a dip in the infinity pool, and explore The Shoppes for luxury shopping and entertainment. At night, witness the mesmerizing light and water show at the Marina Bay Sands Skypark.
- **Gardens by the Bay**: Explore the Flower Dome and Cloud Forest conservatories, and stroll through the scenic OCBC Skyway for breathtaking views of the gardens and city.
- **Sentosa Island**: Escape to Sentosa Island, a resort destination offering a myriad of attractions. Relax on pristine beaches, visit Universal Studios Singapore for thrilling rides, and explore S.E.A. Aquarium for an underwater adventure.

    """

            ###### STREAMLIT MARKDOWN ######
            st.header(f"{country} {emoji}", divider="grey")
            st.image(image)
            st.markdown(description)

            see_top_places = st.checkbox("**Top places to visit**", key={country})
            if see_top_places:
                st.markdown(top_places)

        
        
        
        st.markdown("""# Hotel Recommendation System 🛎️""")

        st.info("""This use case shows how you can create personalized hotel recommendations using a recommendation system with **content-based Filtering**. 
                    Analyzing location, amenities, price, and reviews, the model suggests tailored hotel recommendation based on the user's preference.
        """)
        st.markdown(" ")


        path_hotels_data = r"data/hotels"

        # Load hotel data
        df = load_data_csv(path_hotels_data,"booking_df.csv")

        # clean data
        df.drop_duplicates(inplace=True)
        df["Country"] = df["Country"].apply(lambda x: "Spain" if x=="Espagne" else x)
        list_cities = df["City"].value_counts().to_frame().reset_index()
        list_cities = list_cities.loc[list_cities["count"]>=5,"City"].to_numpy()
        df = df.loc[(df["City"].isin(list_cities)) & (df["Number of bed"]<=6)]
        df["Price"] = df["Price"].astype(int)
        df.loc[(df["Number of bed"]==0) & (df["Price"]<1000),"Number of bed"] = 1
        df.loc[(df["Number of bed"]==0) & (df["Price"].between(1000,2000)),"Number of bed"] = 2
        df.loc[(df["Number of bed"]==0) & (df["Price"]>2000),"Number of bed"] = 3

        df["Rating"] = df["Rating"].apply(lambda x: np.nan if x==0 else x)
        df["Rating"].fillna(np.round(df["Rating"].mean(), 1), inplace=True)

        scaler = get_scaler(df)


        col1, col2 = st.columns([0.3,0.7], gap="large")

        with col1:
            # Collect user preferences
            st.markdown(" ")
            st.markdown(" ")
            st.markdown("")
            #st.markdown("#### Filter preferences")
            list_countries = df["Country"].unique()
            location = st.selectbox("Select a Country",list_countries, index=0)

            list_nb_beds = df["Number of bed"].unique()
            num_beds = st.selectbox("Number of beds", list_nb_beds, index=0)
            #if num_beds == "No information"

            min_rating, max_rating = st.slider("Range of ratings", min_value=df["Rating"].min(), max_value=df["Rating"].max(), step=0.1, value=(5.0, df["Rating"].max()))
            min_price, max_price = st.slider("Range of room prices", min_value=df["Price"].min(), max_value=df["Price"].max(), step=10, value=(df["Price"].min(), 10000))

            # Convert price range sliders to integer values
            min_price = int(min_price)
            max_price = int(max_price)

        with col2:
            country_info(location)


        preferences = {
            'Location': location,
            'Number of beds': num_beds,
            'Rating': [min_rating, max_rating],
            'Price': [min_price, max_price],
        }
                

        if st.button("Recommend Hotels"):
            st.info("Hotels were recommended based on how similar they were to the users preferences.")
            
            # Default number of recommendations to show
            max_recommendations = 5
            
            # Call the recommendation function
            recommended_hotels, message = recommend_hotels_with_location_and_beds(df, preferences, max_recommendations)
            
            # If no recommendations, reduce the maximum number of recommendations and try again
            if recommended_hotels.empty:
                max_recommendations -= 1
                recommended_hotels, message = recommend_hotels_with_location_and_beds(df, preferences, max_recommendations)
                if recommended_hotels.empty:
                    st.error(message)
                # else:
                #     st.write(recommended_hotels)
            else:
                st.markdown(" ")
                for i in range(len(recommended_hotels)):
                    #st.dataframe(recommended_hotels)
                    df_result = recommended_hotels.iloc[i,:]                    
                    col1_, col2_ = st.columns([0.4,0.6], gap="medium")

                    with col1_:
                        st.image("images/room.jpg",width=100)
                        st.markdown(f"### {i+1}: {df_result['Hotel Name']}")
                        st.markdown(f"""**{df_result['Room Type']}** <br>
                                    with {df_result['Bed Type']}
                                    """, unsafe_allow_html=True)
                    with col2_:
                        st.markdown(" ")
                        st.markdown(" ")
                        annotated_text("**Number of beds :** ",(f"{df_result['Number of bed']}","","#faa"))
                        #st.markdown(f"**Bed type**: {df_result['Bed Type']}")
                        annotated_text("**City:** ",(f"{df_result['City']}","","#afa"))
                        annotated_text("**Rating:** ",(f"{df_result['Rating']}","","#8ef"))
                        annotated_text("**Price:** ",(f"{df_result['Price']}$","","#fea"))
                    
                    st.divider()