app.py

import sys
import pandas as pd
import streamlit as st
from anime_recommender.content_filtering_models import ContentBasedRecommender
from anime_recommender.collaborative_filtering_models import CollaborativeAnimeRecommender
from anime_recommender.popularity_based_filtering import PopularityBasedFiltering
import joblib
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("krishnaveni76/Animes", split=None)
    mergeddataset = load_dataset("krishnaveni76/Anime_UserRatings", 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"]) 

    
# 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)
 
st.write("Anime User Ratings Data:")
st.dataframe(anime_user_ratings)

# Define your repository name
repo_name = "krishnaveni76/anime-recommendation-models"

# Load models
cosine_similarity_model_path = hf_hub_download(repo_name, "cosine_similarity.pkl")
item_based_knn_model_path = hf_hub_download(repo_name, "itembasedknn.pkl")
user_based_knn_model_path = hf_hub_download(repo_name, "userbasedknn.pkl")
svd_model_path = hf_hub_download(repo_name, "svd.pkl")

with open(item_based_knn_model_path, "rb") as f:
    item_based_knn_model = joblib.load(f)

with open(user_based_knn_model_path, "rb") as f:
    user_based_knn_model = joblib.load(f)

with open(svd_model_path, "rb") as f:
    svd_model = joblib.load(f)

# Now you can use these models for recommendations
print("Models loaded successfully!")
    
# 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 Recommender System") 
    try:
        
        anime_list = anime_data["name"].tolist()
        anime_name = st.selectbox("Select an Anime", 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()  # Get unique user IDs
            user_id = st.selectbox("Select a user ID ", 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()  # Ensure no NaN values in anime names
            anime_name = st.selectbox("Select an Anime", 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) 
                # st.write(recommendations.head())
            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"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=50, value=10)
        
        if st.button("Get Top Anime"):
            # Load the popularity-based recommender
            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 {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}")