Updated all files

.gitignore

@@ -1,4 +1,4 @@
-anime/ 
+anime/
 .env
 Artifacts/
 logs/

Dockerfile

@@ -1,6 +1,46 @@
+# # Use the official Python image as a base
+# FROM python:3.10-slim-buster
+
+# # Set the working directory in the container
+# WORKDIR /app
+
+# # Copy the app files into the container
+# COPY . .
+
+# # Install required packages
+# RUN pip install -r requirements.txt
+
+# # Expose the port that Streamlit uses
+# EXPOSE 8501
+
+# # Run the Streamlit app
+# CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+
+
+
+
+
+
+
+
+
+
+
+
 # Use the official Python image as a base
 FROM python:3.10-slim-buster
 
+# Install system dependencies required to build scikit-surprise
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    gcc \
+    python3-dev \
+    libxml2 \
+    libxmlsec1 \
+    libxslt1-dev \
+    libffi-dev \
+    && apt-get clean
+
 # Set the working directory in the container
 WORKDIR /app
 
@@ -8,10 +48,11 @@ WORKDIR /app
 COPY . .
 
 # Install required packages
+RUN pip install --upgrade pip
 RUN pip install -r requirements.txt
 
 # Expose the port that Streamlit uses
 EXPOSE 8501
 
 # Run the Streamlit app
-CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+CMD ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

README.md

@@ -8,8 +8,125 @@ sdk_version: 1.41.1
 app_file: app.py
 pinned: false
 license: apache-2.0
----
+--- 
+
+# Welcome to Anime Recommendation system 
+
+This is an **Anime Recommendation System** that combines multiple recommendation techniques such as **Collaborative Filtering**, **Content-Based Filtering**, and **Popularity-Based Filtering**. The system is designed to continuously ingest and transform data and is **dockerized** for easier deployment.  
+
+The system is hosted on **Hugging Face Spaces** and fetches datasets and pre-trained models from **Hugging Face Hub** to generate **personalized anime recommendations** based on user preferences and anime features.
+
+## Tech Stacks 🛠️
+
+- **Python**: Main programming language used for building recommendation algorithms and Streamlit app.  
+- **Docker**: Containerizes the application to ensure a consistent environment across different platforms.  
+- **Streamlit**: For building and deploying the web app that serves the recommendations.  
+- **Hugging Face Spaces**: Hosts the Streamlit-based recommendation system.  
+- **Hugging Face Datasets**: Stores and retrieves anime datasets for processing.  
+- **Hugging Face Models**: Hosts the pre-trained recommendation models for inference.  
+
+## Pipeline 🚀 
+
+The pipeline follows a structured sequence of steps to build an **Anime Recommendation System**, including data ingestion, transformation, and multiple recommendation models.
+
+### 1. Data Ingestion 📥  
+- Initiates the **data ingestion process**, where anime data is loaded from Hugging Face datasets.  
+- The ingested data is saved as artifacts in a local folder for further processing.  
+
+### 2. Data Transformation 🔄  
+- Cleans, transforms, and processes the raw data into a structured format.  
+- Extracts important features required for **Content-Based Filtering** and prepares data for **Collaborative Filtering**.  
+
+### 3. Collaborative Filtering 🤝  
+- Implements **three collaborative filtering models** to recommend anime based on user preferences:  
+  - **Singular Value Decomposition (SVD)**: Factorizes the user-item interaction matrix to make personalized recommendations.  
+  - **Item-Based K-Nearest Neighbors (Item-KNN)**: Recommends anime similar to a given anime based on user ratings.  
+  - **User-Based K-Nearest Neighbors (User-KNN)**: Suggests anime that users with similar preferences have liked.  
+- The chosen model is trained using **transformed data**, and the final trained model is stored as an artifact.  
+- Once trained, it can generate recommendations for users or anime titles.  
+
+### 4. Content-Based Filtering 🎭  
+- Uses extracted anime features like genres to train a **Content-Based Recommendation Model**.  
+- This model recommends anime similar to those a user has watched or liked.  
+
+### 5. Popularity-Based Filtering ⭐  
+This recommendation system ranks anime based on various **popularity metrics**, making it ideal for users who want to discover trending or highly-rated shows **without needing personalized preferences**.  
+
+The system applies different filters to sort anime based on:  
+
+- **Most Popular** 🎭: Anime ranked by **popularity score**, highlighting the most widely recognized titles.  
+- **Top Ranked** 🏆: Highest-rated anime, based on **official ranking metrics**.  
+- **Overall Top Rated** ⭐: Best-rated anime, sorted by **average user ratings**.  
+- **Most Favorited** ❤️: Anime with the highest number of **favorites**, indicating strong fan appreciation.  
+- **Highest Member Count** 👥: Anime with the largest **viewer base**, showing widespread appeal.  
+- **Popular Among Members** 🔥: Anime with a **high number of members and strong ratings**, making them community favorites.  
+- **Highest Average Rating** 🎖️: Shows that have the **best average rating** after handling missing values.  
+
+## Artifacts Storage 📂  
+
+All intermediate and final outputs, including processed datasets and trained models, are first saved locally in the **Artifacts** folder. These artifacts are then uploaded to **Hugging Face** for efficient storage and easy access.  
+
+When building the **Streamlit** app, these datasets and trained models are retrieved directly from **Hugging Face**, ensuring seamless integration and scalability.  
+
+- The datasets used in this project are available at:  
+    - [Anime and User Ratings](https://www.kaggle.com/datasets/krishnaveniponna/anime-and-ratings-list-dataset-2023)  
+      
+- You can find the Artifacts of trained models here:  
+    - [Pre-trained Models](https://huggingface.co/krishnaveni76/anime-recommendation-models)  
+
+## 🚀 Deployment on Hugging Face Spaces  
+
+This project is deployed using **Hugging Face Spaces**, which provides a seamless way to host **Streamlit applications**. The application pulls the datasets and trained models from Hugging Face and runs inside a **Docker container**.
+
+### Pre-requisites  
+- Docker  
+- Hugging Face (for datasets and trained models)  
+- Python 3.8+  
+- Hugging Face Spaces account
+ 
+### Local step 🔧
+1. **Clone the repository**
+```bash
+   git clone https://huggingface.co/spaces/krishnaveni76/Anime-Recommendation-System
+   cd Anime-Recommendation-System
+``` 
+2. **Set Up a Virtual Environment**:
+```bash
+# For macOS and Linux:
+python3 -m venv venv 
+# For Windows:
+python -m venv venv
+``` 
+3. **Activate the Virtual Environment**:
+```bash
+# For macOS and Linux:
+source venv/bin/activate 
+# For Windows:
+.\venv\Scripts\activate
+``` 
+4. **Install Required Dependencies**:
+```bash
+pip install -r requirements.txt
+```
+
+### Running with Docker 🚀
+To run the application inside a Docker container, follow these steps:
+
+1. Build the Docker Image 
+```bash
+docker build -t anime-recommendation-system .
+```
+2. Run the Docker Container 
+```bash
+docker run -p 8501:8501 anime-recommendation-system
+``` 
+This will start the Streamlit application, which can be accessed at `http://localhost:8501`.
+
+### Contact 📫
+For any questions, suggestions, or collaboration opportunities, feel free to reach out:
+
+📧Email: [email protected] 
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+🌐 LinkedIn: [Krishnaveni Ponna](https://www.linkedin.com/in/krishnaveni-ponna-28ab93239)
 
-# Welcome to Anime Recommendation system
+🐦 Twitter: [@Krishnaveni076](https://x.com/Krishnaveni076)

app.py

@@ -8,226 +8,235 @@ from anime_recommender.constant import *
 from huggingface_hub import hf_hub_download
 from datasets import load_dataset
 
-st.set_page_config(page_title="Anime Recommendation System", layout="wide")
-
-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)
-
+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!")
-
-# 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)}")
     
-# Streamlit UI
-app_selector = st.sidebar.radio(
-    "Select App", ("Content-Based Recommender", "Collaborative Recommender", "Top Anime Recommender")
-)
-
-if app_selector == "Content-Based Recommender":
-    st.title("Content-Based Recommendation System") 
-    try:
+        except Exception as e:
+            st.error(f"Unexpected error: {str(e)}")
+
+    elif app_selector == "Collaborative Recommender":
+        st.title("Collaborative Recommender System 🧑‍🤝‍🧑💬")
         
-        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}:") 
+        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>",
+                                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)
+                            ) 
+                            st.caption(f"Genres: {row[1]['Genres']} | Rating: {row[1]['Rating']}")
                 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 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:
-        # Sidebar for choosing the popularity-based filtering method
-        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)
+                    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 🌟🔥")
         
-        if st.button("Get Recommendations"):
-            # Load the popularity-based recommender
-            recommender = PopularityBasedFiltering(anime_data)
+        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",
+                ]
+            )
             
-            # 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
+            n_recommendations = st.slider("Number of Recommendations:", min_value=1, max_value=500 , value=10)
             
-            # Display recommendations
-            if isinstance(recommendations, pd.DataFrame) and not recommendations.empty:
-                st.write(f"Here are the {popularity_method}:")
-                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 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()