Download app.py from Janesh1/Movie_recommendation: direct link, hf CLI and curl.
- Browser
- Download file 5.99 kB
-
https://huggingface.co/Janesh1/Movie_recommendation/resolve/main/app.py
- Command line
-
hf download hf://Janesh1/Movie_recommendation/app.py
-
curl -L -o app.py https://huggingface.co/Janesh1/Movie_recommendation/resolve/main/app.py
5.99 kB
| import streamlit as st | |
| import pandas as pd | |
| import numpy as np | |
| from sklearn.feature_extraction.text import TfidfVectorizer | |
| from sklearn.metrics.pairwise import cosine_similarity | |
| from sklearn.model_selection import train_test_split | |
| from sklearn.metrics import mean_squared_error | |
| # Cache data loading to make it faster | |
| def load_data(): | |
| movies = pd.read_csv('movies_metadata.csv', low_memory=False) | |
| movies = movies.sample(n=15000, random_state=42) | |
| ratings = pd.read_csv('ratings_small.csv') | |
| movies['overview'] = movies['overview'].fillna('') | |
| movies['id'] = pd.to_numeric(movies['id'], errors='coerce').astype('Int64') | |
| return movies, ratings | |
| # Cache TF-IDF and similarity matrix for content-based | |
| def compute_content_based_matrix(movies): | |
| movies['genres_str'] = movies['genres'].apply(lambda x: ' '.join(x.split('|'))) | |
| vectorizer = TfidfVectorizer() | |
| tfidf_matrix = vectorizer.fit_transform(movies['genres_str']) | |
| similarity_matrix = cosine_similarity(tfidf_matrix) | |
| title_to_index = pd.Series(movies.index, index=movies['title']) | |
| return tfidf_matrix, similarity_matrix, title_to_index | |
| # Cache user profiles for user-based | |
| def compute_user_profiles(ratings, movies): | |
| train_ratings, test_ratings = train_test_split(ratings, test_size=0.2, random_state=42) | |
| tfidf = TfidfVectorizer(stop_words='english') | |
| tfidf_matrix = tfidf.fit_transform(movies['genres'].fillna('')) | |
| movie_id_to_idx = {mid: idx for idx, mid in enumerate(movies['id'])} | |
| def build_user_profile(ratings_df, tfidf_matrix, movie_id_to_idx): | |
| user_profiles = {} | |
| for user_id, group in ratings_df.groupby('userId'): | |
| rated_movies = group['movieId'].values | |
| ratings = group['rating'].values | |
| movie_indices = [movie_id_to_idx[m] for m in rated_movies if m in movie_id_to_idx] | |
| if not movie_indices: | |
| continue | |
| weighted_vectors = np.sum([ratings[i] * tfidf_matrix[movie_indices[i]].toarray().flatten() | |
| for i in range(len(movie_indices))], axis=0) | |
| rating_sum = np.sum(ratings) | |
| user_profiles[user_id] = weighted_vectors / rating_sum if rating_sum > 0 else weighted_vectors | |
| return user_profiles, train_ratings, test_ratings | |
| user_profiles, train_ratings, test_ratings = build_user_profile(train_ratings, tfidf_matrix, movie_id_to_idx) | |
| return user_profiles, tfidf_matrix, movie_id_to_idx, train_ratings, test_ratings | |
| # Content-based recommendation function | |
| def get_similar_movies(title, similarity_matrix, title_to_index, movies, N=5): | |
| try: | |
| index = title_to_index[title] | |
| similarity_scores = similarity_matrix[index] | |
| similar_indices = similarity_scores.argsort()[::-1][1:N+1] | |
| similar_movies = movies['title'].iloc[similar_indices] | |
| similar_scores = similarity_scores[similar_indices] | |
| return list(zip(similar_movies, similar_scores)) | |
| except KeyError: | |
| return None | |
| # User profile-based recommendation function | |
| def get_top_n_recommendations(user_id, user_profiles, tfidf_matrix, movie_id_to_idx, movies, train_ratings, n=5): | |
| if user_id not in user_profiles: | |
| return None | |
| user_profile = user_profiles[user_id] | |
| similarities = cosine_similarity(user_profile.reshape(1, -1), tfidf_matrix).flatten() | |
| movie_indices = np.argsort(similarities)[::-1] | |
| rated_movies = set(train_ratings[train_ratings['userId'] == user_id]['movieId'].values) | |
| top_n_indices = [idx for idx in movie_indices if movies['id'].iloc[idx] not in rated_movies][:n] | |
| return [(movies['title'].iloc[idx], 1 + 4 * similarities[idx]) for idx in top_n_indices] | |
| # Streamlit app | |
| st.title("🎥 Movie Recommender System") | |
| st.write("Pick a way to find awesome movies! Either choose a movie you like or enter your user ID for personalized picks.") | |
| # Load data | |
| movies, ratings = load_data() | |
| # Sidebar for selecting recommendation type | |
| recommendation_type = st.sidebar.selectbox("Choose Recommendation Type", ["Content-Based", "User Profile-Based"]) | |
| if recommendation_type == "Content-Based": | |
| st.header("Content-Based Movie Recommendations") | |
| st.write("Enter a movie title to find similar movies based on genres.") | |
| # Compute content-based matrices | |
| tfidf_matrix, similarity_matrix, title_to_index = compute_content_based_matrix(movies) | |
| # Movie title input | |
| movie_title = st.selectbox("Select a Movie", options=[""] + list(movies['title'].dropna().unique())) | |
| if movie_title: | |
| recommendations = get_similar_movies(movie_title, similarity_matrix, title_to_index, movies, N=5) | |
| if recommendations: | |
| st.write(f"**Movies similar to '{movie_title}':**") | |
| for i, (movie, score) in enumerate(recommendations, 1): | |
| st.write(f"{i}. {movie} (Similarity Score: {score:.2f})") | |
| else: | |
| st.error(f"Oops! Movie '{movie_title}' not found. Try another title!") | |
| else: | |
| st.header("User Profile-Based Movie Recommendations") | |
| st.write("Enter your user ID to get personalized movie picks based on your ratings.") | |
| # Compute user profiles | |
| user_profiles, tfidf_matrix, movie_id_to_idx, train_ratings, test_ratings = compute_user_profiles(ratings, movies) | |
| # User ID input | |
| user_id = st.number_input("Enter User ID", min_value=1, step=1, value=1) | |
| if st.button("Get Recommendations"): | |
| recommendations = get_top_n_recommendations(user_id, user_profiles, tfidf_matrix, movie_id_to_idx, movies, train_ratings, n=5) | |
| if recommendations: | |
| st.write(f"**Top 5 recommendations for User {user_id}:**") | |
| for i, (movie, pred_rating) in enumerate(recommendations, 1): | |
| st.write(f"{i}. {movie} (Predicted Rating: {pred_rating:.2f})") | |
| else: | |
| st.error(f"Oops! User ID {user_id} not found or hasn't rated enough movies. Try another ID!") |