Updated app

app.py

@@ -1,242 +1,242 @@
-import pandas as pd
-import streamlit as st
-from anime_recommender.model_trainer.content_based_modelling import ContentBasedRecommender
-from anime_recommender.model_trainer.collaborative_modelling import CollaborativeAnimeRecommender
-from anime_recommender.model_trainer.top_anime_filtering import PopularityBasedFiltering
-import joblib
-from anime_recommender.constant import *
-from huggingface_hub import hf_hub_download
-from datasets import load_dataset
-
-def run_app():
-    """
-    Initializes the Streamlit app, loads necessary datasets and models, 
-    and provides a UI for anime recommendations based on three methods: 
-    Content-Based, Collaborative, and Popularity-Based Filtering. 🎬🎮
-    """
-
-    # Set page configuration
-    st.set_page_config(page_title="Anime Recommendation System", layout="wide")
-
-    # Load datasets if not present in session state
-    if "anime_data" not in st.session_state or "anime_user_ratings" not in st.session_state:
-        # Load datasets from Hugging Face (assuming no splits)
-        animedataset = load_dataset(ANIME_FILE_PATH, split=None)
-        mergeddataset = load_dataset(ANIMEUSERRATINGS_FILE_PATH, split=None)
-
-        # Convert the dataset to Pandas DataFrame
-        st.session_state.anime_data = pd.DataFrame(animedataset["train"])
-        st.session_state.anime_user_ratings = pd.DataFrame(mergeddataset["train"]) 
-
-    # Load models only once
-    if "models_loaded" not in st.session_state:
-        st.session_state.models_loaded = {} 
-        # Load models
-        st.session_state.models_loaded["cosine_similarity_model"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_COSINESIMILARITY_MODEL_NAME)
-        st.session_state.models_loaded["item_based_knn_model_path"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_ITEM_KNN_TRAINED_MODEL_NAME)
-        st.session_state.models_loaded["user_based_knn_model_path"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_USER_KNN_TRAINED_MODEL_NAME)
-        st.session_state.models_loaded["svd_model_path"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_SVD_TRAINED_MODEL_NAME)
-
-        # Load the models using joblib
-        with open(st.session_state.models_loaded["item_based_knn_model_path"], "rb") as f:
-            st.session_state.models_loaded["item_based_knn_model"] = joblib.load(f)
-
-        with open(st.session_state.models_loaded["user_based_knn_model_path"], "rb") as f:
-            st.session_state.models_loaded["user_based_knn_model"] = joblib.load(f)
-
-        with open(st.session_state.models_loaded["svd_model_path"], "rb") as f:
-            st.session_state.models_loaded["svd_model"] = joblib.load(f)
-
-        print("Models loaded successfully!")
-
-    # Access the data from session state
-    anime_data = st.session_state.anime_data 
-    anime_user_ratings = st.session_state.anime_user_ratings
-
-    # # Display dataset info
-    # st.write("Anime Data:")
-    # st.dataframe(anime_data.head())
-    
-    # st.write("Anime User Ratings Data:")
-    # st.dataframe(anime_user_ratings.head())
-    
-    # Access the models from session state
-    cosine_similarity_model_path = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_COSINESIMILARITY_MODEL_NAME)
-    item_based_knn_model = st.session_state.models_loaded["item_based_knn_model"]
-    user_based_knn_model = st.session_state.models_loaded["user_based_knn_model"]
-    svd_model = st.session_state.models_loaded["svd_model"] 
-    print("Models loaded successfully!")
-        
-    # Streamlit UI
-    app_selector = st.sidebar.radio(
-        "Select App", ("Content-Based Recommender", "Collaborative Recommender", "Top Anime Recommender")
-    )
-
-    # Content-Based Recommender App
-    if app_selector == "Content-Based Recommender":
-        st.title("Content-Based Recommendation System") 
-        try:
-            
-            anime_list = anime_data["name"].tolist()
-            anime_name = st.selectbox("Pick an anime..unlock similar anime recommendations..", anime_list) 
-
-            # Set number of recommendations
-            max_recommendations = min(len(anime_data), 100)
-            n_recommendations = st.slider("Number of Recommendations", 1, max_recommendations, 10)
-
-            # Inject custom CSS for anime name font size
-            st.markdown(
-                """
-                <style>
-                .anime-title {
-                    font-size: 14px !important;
-                    font-weight: bold;
-                    text-align: center;
-                    margin-top: 5px;
-                }
-                </style>
-                """,
-                unsafe_allow_html=True,
-            ) 
-            # Get Recommendations
-            if st.button("Get Recommendations"):
-                try:
-                    recommender = ContentBasedRecommender(anime_data)
-                    recommendations = recommender.get_rec_cosine(anime_name, n_recommendations=n_recommendations,model_path=cosine_similarity_model_path)
-
-                    if isinstance(recommendations, str):
-                        st.warning(recommendations)
-                    elif recommendations.empty:
-                        st.warning("No recommendations found.🧐")
-                    else:
-                        st.write(f"Here are the Content-based Recommendations for {anime_name}:") 
-                        cols = st.columns(5)
-                        for i, row in enumerate(recommendations.iterrows()):
-                            col = cols[i % 5]
-                            with col:
-                                st.image(row[1]['Image URL'], use_container_width=True)
-                                st.markdown(
-                                    f"<div class='anime-title'>{row[1]['Anime name']}</div>",
-                                    unsafe_allow_html=True,
-                                )
-                                st.caption(f"Genres: {row[1]['Genres']} | Rating: {row[1]['Rating']}") 
-                except Exception as e:
-                    st.error(f"Unexpected error: {str(e)}")
-    
-        except Exception as e:
-            st.error(f"Unexpected error: {str(e)}")
-
-    elif app_selector == "Collaborative Recommender":
-        st.title("Collaborative Recommender System 🧑‍🤝‍🧑💬")
-        
-        try:  
-            # Sidebar for choosing the collaborative filtering method
-            collaborative_method = st.sidebar.selectbox(
-                "Choose a collaborative filtering method:", 
-                ["SVD Collaborative Filtering", "User-Based Collaborative Filtering", "Anime-Based KNN Collaborative Filtering"]
-            )
-
-            # User input
-            if collaborative_method == "SVD Collaborative Filtering" or collaborative_method == "User-Based Collaborative Filtering": 
-                user_ids = anime_user_ratings['user_id'].unique()  
-                user_id = st.selectbox("Choose a user, and we'll show you animes they'd recommend", user_ids) 
-                n_recommendations = st.slider("Number of Recommendations:", min_value=1, max_value=50, value=10)
-            elif collaborative_method == "Anime-Based KNN Collaborative Filtering": 
-                anime_list = anime_user_ratings["name"].dropna().unique().tolist() 
-                anime_name = st.selectbox("Pick an anime, and we'll suggest more titles you'll love", anime_list)
-                n_recommendations = st.slider("Number of Recommendations:", min_value=1, max_value=50, value=10)
-    
-            # Get recommendations
-            if st.button("Get Recommendations"):
-                # Load the recommender
-                recommender = CollaborativeAnimeRecommender(anime_user_ratings) 
-                if collaborative_method == "SVD Collaborative Filtering": 
-                    recommendations = recommender.get_svd_recommendations(user_id, n=n_recommendations, svd_model=svd_model)  
-                elif collaborative_method == "User-Based Collaborative Filtering": 
-                    recommendations = recommender.get_user_based_recommendations(user_id, n_recommendations=n_recommendations, knn_user_model=user_based_knn_model)
-                elif collaborative_method == "Anime-Based KNN Collaborative Filtering":
-                    if anime_name: 
-                        recommendations = recommender.get_item_based_recommendations(anime_name, n_recommendations=n_recommendations, knn_item_model=item_based_knn_model)
-                    else:
-                        st.error("Invalid Anime Name. Please enter a valid anime title.")
-                
-                if isinstance(recommendations, pd.DataFrame) and not recommendations.empty:
-                    if len(recommendations) < n_recommendations:
-                        st.warning(f"Oops...Only {len(recommendations)} recommendations available, fewer than the requested {n_recommendations}.")
-                    st.write(f"Here are the {collaborative_method} Recommendations:") 
-                    cols = st.columns(5)
-                    for i, row in enumerate(recommendations.iterrows()):
-                        col = cols[i % 5]
-                        with col:
-                            st.image(row[1]['Image URL'], use_container_width=True)
-                            st.markdown(
-                                f"<div class='anime-title'>{row[1]['Anime Name']}</div>",
-                                unsafe_allow_html=True,
-                            ) 
-                            st.caption(f"Genres: {row[1]['Genres']} | Rating: {row[1]['Rating']}")
-                else:
-                    st.error("No recommendations found.")
-        except Exception as e:
-            st.error(f"An error occurred: {e}")
-
-    elif app_selector == "Top Anime Recommender":
-        st.title("Top Anime Recommender System 🌟🔥")
-        
-        try: 
-            popularity_method = st.sidebar.selectbox(
-                "Choose a Popularity-Based Filtering method:",
-                [
-                    "Popular Animes",
-                    "Top Ranked Animes",
-                    "Overall Top Rated Animes",
-                    "Favorite Animes",
-                    "Top Animes by Members",
-                    "Popular Anime Among Members",
-                    "Top Average Rated Animes",
-                ]
-            )
-            
-            n_recommendations = st.slider("Number of Recommendations:", min_value=1, max_value=500 , value=10)
-            
-            if st.button("Get Recommendations"): 
-                recommender = PopularityBasedFiltering(anime_data)
-                
-                # Get recommendations based on selected method
-                if popularity_method == "Popular Animes":
-                    recommendations = recommender.popular_animes(n=n_recommendations)
-                elif popularity_method == "Top Ranked Animes":
-                    recommendations = recommender.top_ranked_animes(n=n_recommendations)
-                elif popularity_method == "Overall Top Rated Animes":
-                    recommendations = recommender.overall_top_rated_animes(n=n_recommendations)
-                elif popularity_method == "Favorite Animes":
-                    recommendations = recommender.favorite_animes(n=n_recommendations)
-                elif popularity_method == "Top Animes by Members":
-                    recommendations = recommender.top_animes_members(n=n_recommendations)
-                elif popularity_method == "Popular Anime Among Members":
-                    recommendations = recommender.popular_anime_among_members(n=n_recommendations)
-                elif popularity_method == "Top Average Rated Animes":
-                    recommendations = recommender.top_avg_rated(n=n_recommendations)
-                else:
-                    st.error("Invalid selection. Please choose a valid method.")
-                    recommendations = None
-                
-                # Display recommendations
-                if isinstance(recommendations, pd.DataFrame) and not recommendations.empty:
-                    st.write(f" Here are the Recommendations:")
-                    cols = st.columns(5)
-                    for i, row in recommendations.iterrows():
-                        col = cols[i % 5]
-                        with col:
-                            st.image(row['Image URL'], use_container_width=True)
-                            st.markdown(
-                                f"<div class='anime-title'>{row['Anime name']}</div>",
-                                unsafe_allow_html=True,
-                            )
-                            st.caption(f"Genres: {row['Genres']} | Rating: {row['Rating']}")
-                else:
-                    st.error("No recommendations found.")
-        except Exception as e:
-            st.error(f"An error occurred: {e}")
-
-if __name__ == "__main__":
+import pandas as pd
+import streamlit as st
+from anime_recommender.model_trainer.content_based_modelling import ContentBasedRecommender
+from anime_recommender.model_trainer.collaborative_modelling import CollaborativeAnimeRecommender
+from anime_recommender.model_trainer.top_anime_filtering import PopularityBasedFiltering
+import joblib
+from anime_recommender.constant import *
+from huggingface_hub import hf_hub_download
+from datasets import load_dataset
+
+def run_app():
+    """
+    Initializes the Streamlit app, loads necessary datasets and models, 
+    and provides a UI for anime recommendations based on three methods: 
+    Content-Based, Collaborative, and Popularity-Based Filtering. 🎬🎮
+    """
+
+    # Set page configuration
+    st.set_page_config(page_title="Anime Recommendation System", layout="wide")
+
+    # Load datasets if not present in session state
+    if "anime_data" not in st.session_state or "anime_user_ratings" not in st.session_state:
+        # Load datasets from Hugging Face (assuming no splits)
+        animedataset = load_dataset(ANIME_FILE_PATH, split=None)
+        mergeddataset = load_dataset(ANIMEUSERRATINGS_FILE_PATH, split=None)
+
+        # Convert the dataset to Pandas DataFrame
+        st.session_state.anime_data = pd.DataFrame(animedataset["train"])
+        st.session_state.anime_user_ratings = pd.DataFrame(mergeddataset["train"]) 
+
+    # Load models only once
+    if "models_loaded" not in st.session_state:
+        st.session_state.models_loaded = {} 
+        # Load models
+        st.session_state.models_loaded["cosine_similarity_model"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_COSINESIMILARITY_MODEL_NAME)
+        st.session_state.models_loaded["item_based_knn_model_path"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_ITEM_KNN_TRAINED_MODEL_NAME)
+        st.session_state.models_loaded["user_based_knn_model_path"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_USER_KNN_TRAINED_MODEL_NAME)
+        st.session_state.models_loaded["svd_model_path"] = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_SVD_TRAINED_MODEL_NAME)
+
+        # Load the models using joblib
+        with open(st.session_state.models_loaded["item_based_knn_model_path"], "rb") as f:
+            st.session_state.models_loaded["item_based_knn_model"] = joblib.load(f)
+
+        with open(st.session_state.models_loaded["user_based_knn_model_path"], "rb") as f:
+            st.session_state.models_loaded["user_based_knn_model"] = joblib.load(f)
+
+        with open(st.session_state.models_loaded["svd_model_path"], "rb") as f:
+            st.session_state.models_loaded["svd_model"] = joblib.load(f)
+
+        print("Models loaded successfully!")
+
+    # Access the data from session state
+    anime_data = st.session_state.anime_data 
+    anime_user_ratings = st.session_state.anime_user_ratings
+
+    # # Display dataset info
+    # st.write("Anime Data:")
+    # st.dataframe(anime_data.head())
+    
+    # st.write("Anime User Ratings Data:")
+    # st.dataframe(anime_user_ratings.head())
+    
+    # Access the models from session state
+    cosine_similarity_model_path = hf_hub_download(MODELS_FILEPATH, MODEL_TRAINER_COSINESIMILARITY_MODEL_NAME)
+    item_based_knn_model = st.session_state.models_loaded["item_based_knn_model"]
+    user_based_knn_model = st.session_state.models_loaded["user_based_knn_model"]
+    svd_model = st.session_state.models_loaded["svd_model"] 
+    print("Models loaded successfully!")
+        
+    # Streamlit UI
+    app_selector = st.sidebar.radio(
+        "Select App", ("Content-Based Recommender", "Collaborative Recommender", "Top Anime Recommender")
+    )
+
+    # Content-Based Recommender App
+    if app_selector == "Content-Based Recommender":
+        st.title("Content-Based Recommendation System") 
+        try:
+            
+            anime_list = anime_data["name"].tolist()
+            anime_name = st.selectbox("Pick an anime..unlock similar anime recommendations..", anime_list) 
+
+            # Set number of recommendations
+            max_recommendations = min(len(anime_data), 100)
+            n_recommendations = st.slider("Number of Recommendations", 1, max_recommendations, 10)
+
+            # Inject custom CSS for anime name font size
+            st.markdown(
+                """
+                <style>
+                .anime-title {
+                    font-size: 14px !important;
+                    font-weight: bold;
+                    text-align: center;
+                    margin-top: 5px;
+                }
+                </style>
+                """,
+                unsafe_allow_html=True,
+            ) 
+            # Get Recommendations
+            if st.button("Get Recommendations"):
+                try:
+                    recommender = ContentBasedRecommender(anime_data)
+                    recommendations = recommender.get_rec_cosine(anime_name, n_recommendations=n_recommendations,model_path=cosine_similarity_model_path)
+
+                    if isinstance(recommendations, str):
+                        st.warning(recommendations)
+                    elif recommendations.empty:
+                        st.warning("No recommendations found.🧐")
+                    else:
+                        st.write(f"Here are the Content-based Recommendations for {anime_name}:") 
+                        cols = st.columns(5)
+                        for i, row in enumerate(recommendations.iterrows()):
+                            col = cols[i % 5]
+                            with col:
+                                st.image(row[1]['Image URL'], use_container_width=True)
+                                st.markdown(
+                                    f"<div class='anime-title'>{row[1]['Anime name']}</div>",
+                                    unsafe_allow_html=True,
+                                )
+                                st.caption(f"Genres: {row[1]['Genres']} | Rating: {row[1]['Rating']}") 
+                except Exception as e:
+                    st.error(f"Unexpected error: {str(e)}")
+    
+        except Exception as e:
+            st.error(f"Unexpected error: {str(e)}")
+
+    elif app_selector == "Collaborative Recommender":
+        st.title("Collaborative Recommender System 🧑‍🤝‍🧑💬")
+        
+        try:  
+            # Sidebar for choosing the collaborative filtering method
+            collaborative_method = st.sidebar.selectbox(
+                "Choose a collaborative filtering method:", 
+                ["SVD Collaborative Filtering", "User-Based Collaborative Filtering", "Anime-Based KNN Collaborative Filtering"]
+            )
+
+            # User input
+            if collaborative_method == "SVD Collaborative Filtering" or collaborative_method == "User-Based Collaborative Filtering": 
+                user_ids = anime_user_ratings['user_id'].unique()  
+                user_id = st.selectbox("Select your MyAnimeList user ID to get anime recommendations based on similar users", user_ids) 
+                n_recommendations = st.slider("Number of Recommendations:", min_value=1, max_value=50, value=10)
+            elif collaborative_method == "Anime-Based KNN Collaborative Filtering": 
+                anime_list = anime_user_ratings["name"].dropna().unique().tolist() 
+                anime_name = st.selectbox("Pick an anime, and we'll suggest more titles you'll love", anime_list)
+                n_recommendations = st.slider("Number of Recommendations:", min_value=1, max_value=50, value=10)
+    
+            # Get recommendations
+            if st.button("Get Recommendations"):
+                # Load the recommender
+                recommender = CollaborativeAnimeRecommender(anime_user_ratings) 
+                if collaborative_method == "SVD Collaborative Filtering": 
+                    recommendations = recommender.get_svd_recommendations(user_id, n=n_recommendations, svd_model=svd_model)  
+                elif collaborative_method == "User-Based Collaborative Filtering": 
+                    recommendations = recommender.get_user_based_recommendations(user_id, n_recommendations=n_recommendations, knn_user_model=user_based_knn_model)
+                elif collaborative_method == "Anime-Based KNN Collaborative Filtering":
+                    if anime_name: 
+                        recommendations = recommender.get_item_based_recommendations(anime_name, n_recommendations=n_recommendations, knn_item_model=item_based_knn_model)
+                    else:
+                        st.error("Invalid Anime Name. Please enter a valid anime title.")
+                
+                if isinstance(recommendations, pd.DataFrame) and not recommendations.empty:
+                    if len(recommendations) < n_recommendations:
+                        st.warning(f"Oops...Only {len(recommendations)} recommendations available, fewer than the requested {n_recommendations}.")
+                    st.write(f"Here are the {collaborative_method} Recommendations:") 
+                    cols = st.columns(5)
+                    for i, row in enumerate(recommendations.iterrows()):
+                        col = cols[i % 5]
+                        with col:
+                            st.image(row[1]['Image URL'], use_container_width=True)
+                            st.markdown(
+                                f"<div class='anime-title'>{row[1]['Anime Name']}</div>",
+                                unsafe_allow_html=True,
+                            ) 
+                            st.caption(f"Genres: {row[1]['Genres']} | Rating: {row[1]['Rating']}")
+                else:
+                    st.error("No recommendations found.")
+        except Exception as e:
+            st.error(f"An error occurred: {e}")
+
+    elif app_selector == "Top Anime Recommender":
+        st.title("Top Anime Recommender System 🔥")
+        
+        try: 
+            popularity_method = st.sidebar.selectbox(
+                "Choose a Popularity-Based Filtering method:",
+                [
+                    "Popular Animes",
+                    "Top Ranked Animes",
+                    "Overall Top Rated Animes",
+                    "Favorite Animes",
+                    "Top Animes by Members",
+                    "Popular Anime Among Members",
+                    "Top Average Rated Animes",
+                ]
+            )
+            
+            n_recommendations = st.slider("Number of Recommendations:", min_value=1, max_value=500 , value=10)
+            
+            if st.button("Get Recommendations"): 
+                recommender = PopularityBasedFiltering(anime_data)
+                
+                # Get recommendations based on selected method
+                if popularity_method == "Popular Animes":
+                    recommendations = recommender.popular_animes(n=n_recommendations)
+                elif popularity_method == "Top Ranked Animes":
+                    recommendations = recommender.top_ranked_animes(n=n_recommendations)
+                elif popularity_method == "Overall Top Rated Animes":
+                    recommendations = recommender.overall_top_rated_animes(n=n_recommendations)
+                elif popularity_method == "Favorite Animes":
+                    recommendations = recommender.favorite_animes(n=n_recommendations)
+                elif popularity_method == "Top Animes by Members":
+                    recommendations = recommender.top_animes_members(n=n_recommendations)
+                elif popularity_method == "Popular Anime Among Members":
+                    recommendations = recommender.popular_anime_among_members(n=n_recommendations)
+                elif popularity_method == "Top Average Rated Animes":
+                    recommendations = recommender.top_avg_rated(n=n_recommendations)
+                else:
+                    st.error("Invalid selection. Please choose a valid method.")
+                    recommendations = None
+                
+                # Display recommendations
+                if isinstance(recommendations, pd.DataFrame) and not recommendations.empty:
+                    st.write(f" Here are the Recommendations:")
+                    cols = st.columns(5)
+                    for i, row in recommendations.iterrows():
+                        col = cols[i % 5]
+                        with col:
+                            st.image(row['Image URL'], use_container_width=True)
+                            st.markdown(
+                                f"<div class='anime-title'>{row['Anime name']}</div>",
+                                unsafe_allow_html=True,
+                            )
+                            st.caption(f"Genres: {row['Genres']} | Rating: {row['Rating']}")
+                else:
+                    st.error("No recommendations found.")
+        except Exception as e:
+            st.error(f"An error occurred: {e}")
+
+if __name__ == "__main__":
     run_app()