Update app.py

app.py

@@ -4,101 +4,52 @@ import numpy as np
 from sklearn.metrics.pairwise import cosine_similarity
 import joblib
 import os
-import glob
-import tempfile
-from huggingface_hub import hf_hub_download, HfApi
 
-# Force reinstall numpy to fix numpy._core issue
-try:
-    st.write("Ensuring NumPy is installed correctly...")
-    subprocess.check_call([sys.executable, "-m", "pip", "install", "--force-reinstall", "numpy==1.23.5"])
-    import numpy._core
-    st.write("NumPy imported successfully.")
-except ImportError as e:
-    st.error(f"Failed to import numpy._core after reinstall: {str(e)}. Contact support or try restarting the Space.")
-    st.stop()
-except subprocess.CalledProcessError as e:
-    st.error(f"Failed to reinstall numpy: {str(e)}. Check network or Space environment.")
-    st.stop()
-
-# Load weights from Hugging Face
+# Load precomputed weights
 @st.cache_data
 def load_weights():
     try:
-        temp_dir = tempfile.mkdtemp()
-        repo_id = "Janesh1/Movie_recommendation"  # Replace with your Hugging Face repo (e.g., jdoe/movie-recommender-weights)
-        weight_files = [
-            'content_tfidf_matrix.joblib',
-            'content_title_to_index.joblib',
-            'content_vectorizer.joblib',
-            'movies_data.joblib',
-            'user_profiles.joblib',
-            'user_tfidf_matrix.joblib',
-            'user_movie_id_to_idx.joblib',
-            'train_ratings.joblib',
-            'test_ratings.joblib'
-        ]
-        
-        reassembled_files = {}
-        api = HfApi()
-        for weight_file in weight_files:
-            # Check for chunked files
-            chunks = sorted([f for f in api.list_repo_files(repo_id=repo_id, repo_type="space") 
-                            if f.startswith('weights/' + weight_file + '.part')])
-            if chunks:
-                temp_path = os.path.join(temp_dir, weight_file)
-                with open(temp_path, 'wb') as outfile:
-                    for chunk in chunks:
-                        try:
-                            chunk_path = hf_hub_download(repo_id=repo_id, filename=chunk, repo_type="space")
-                            with open(chunk_path, 'rb') as infile:
-                                outfile.write(infile.read())
-                        except Exception as e:
-                            st.error(f"Failed to download chunk {chunk}: {str(e)}")
-                            raise
-                reassembled_files[weight_file] = temp_path
-            else:
-                # Download single file
-                try:
-                    temp_path = hf_hub_download(repo_id=repo_id, filename=f'weights/{weight_file}', repo_type="space")
-                    reassembled_files[weight_file] = temp_path
-                except Exception as e:
-                    st.error(f"Failed to download {weight_file}: {str(e)}")
-                    raise
-        
-        # Load weights
-        try:
-            content_tfidf_matrix = joblib.load(reassembled_files['content_tfidf_matrix.joblib'])
-            title_to_index = joblib.load(reassembled_files['content_title_to_index.joblib'])
-            movies = joblib.load(reassembled_files['movies_data.joblib'])
-            user_profiles = joblib.load(reassembled_files['user_profiles.joblib'])
-            user_tfidf_matrix = joblib.load(reassembled_files['user_tfidf_matrix.joblib'])
-            movie_id_to_idx = joblib.load(reassembled_files['user_movie_id_to_idx.joblib'])
-            train_ratings = joblib.load(reassembled_files['train_ratings.joblib'])
-        except Exception as e:
-            st.error(f"Error deserializing weights with joblib: {str(e)}. Possible numpy or joblib incompatibility.")
-            raise
-        
-        return (movies, content_tfidf_matrix, title_to_index,
-                user_profiles, user_tfidf_matrix, movie_id_to_idx, train_ratings)
+        weights_path = 'weights'
+        content_tfidf_matrix = joblib.load(f'{weights_path}/content_tfidf_matrix.joblib')
+        content_similarity_matrix = joblib.load(f'{weights_path}/content_similarity_matrix.joblib')
+        title_to_index = joblib.load(f'{weights_path}/content_title_to_index.joblib')
+        content_vectorizer = joblib.load(f'{weights_path}/content_vectorizer.joblib')
+        movies = joblib.load(f'{weights_path}/movies_data.joblib')
+        user_profiles = joblib.load(f'{weights_path}/user_profiles.joblib')
+        user_tfidf_matrix = joblib.load(f'{weights_path}/user_tfidf_matrix.joblib')
+        movie_id_to_idx = joblib.load(f'{weights_path}/user_movie_id_to_idx.joblib')
+        train_ratings = joblib.load(f'{weights_path}/train_ratings.joblib')
+        return {
+            "movies": movies,
+            "content_tfidf_matrix": content_tfidf_matrix,
+            "content_similarity_matrix": content_similarity_matrix,
+            "title_to_index": title_to_index,
+            "content_vectorizer": content_vectorizer,
+            "user_profiles": user_profiles,
+            "user_tfidf_matrix": user_tfidf_matrix,
+            "movie_id_to_idx": movie_id_to_idx,
+            "train_ratings": train_ratings
+        }
+    except FileNotFoundError as e:
+        st.error(f"Weight file missing: {e.filename}")
+        st.stop()
     except Exception as e:
-        st.error(f"Error loading weights from Hugging Face: {str(e)}")
+        st.error(f"An unexpected error occurred while loading weights: {str(e)}")
         st.stop()
 
-# Content-based recommendation function (on-the-fly similarity)
-def get_similar_movies(title, tfidf_matrix, title_to_index, movies, N=5):
+# Content-based recommendation
+def get_similar_movies(title, similarity_matrix, title_to_index, movies, N=5):
     try:
         index = title_to_index[title]
-        movie_vector = tfidf_matrix[index]
-        similarity_scores = cosine_similarity(movie_vector, tfidf_matrix).flatten()
+        similarity_scores = similarity_matrix[index]
         similar_indices = similarity_scores.argsort()[::-1][1:N+1]
-        similar_movies = movies['title'].iloc[similar_indices]
+        similar_movies = movies.iloc[similar_indices][['title', 'genres']]
         similar_scores = similarity_scores[similar_indices]
-        return list(zip(similar_movies, similar_scores))
+        return list(zip(similar_movies['title'], similar_scores))
     except KeyError:
         return None
 
-# User profile-based recommendation function
+# User profile-based recommendation
 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
@@ -109,47 +60,58 @@ def get_top_n_recommendations(user_id, user_profiles, tfidf_matrix, movie_id_to_
     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.")
+# --- Streamlit App ---
+st.set_page_config(page_title="Movie Recommender", page_icon="🎬")
+st.title("🎬 Movie Recommender System")
+
+st.markdown("""
+This app provides two types of movie recommendations:
+- **Content-Based Filtering**: Suggests movies similar to one you like.
+- **User Profile-Based Filtering**: Personalized recommendations based on your past ratings.
+""")
 
-# Load weights from Hugging Face
-try:
-    (movies, content_tfidf_matrix, title_to_index,
-     user_profiles, user_tfidf_matrix, movie_id_to_idx, train_ratings) = load_weights()
-except Exception as e:
-    st.error(f"Failed to initialize weights: {str(e)}")
-    st.stop()
+# Load all weights
+weights = load_weights()
 
-# Sidebar for selecting recommendation type
-recommendation_type = st.sidebar.selectbox("Choose Recommendation Type", ["Content-Based", "User Profile-Based"])
+recommendation_type = st.sidebar.radio("Choose Recommendation Type", ["Content-Based", "User Profile-Based"])
 
 if recommendation_type == "Content-Based":
-    st.header("Content-Based Movie Recommendations")
-    st.write("Select a movie title to find similar movies based on genres.")
-    
-    movie_title = st.selectbox("Select a Movie", options=[""] + sorted(movies['title'].dropna().unique()))
+    st.header("📽️ Content-Based Recommendations")
+    movie_title = st.selectbox("Choose a Movie Title", [""] + sorted(weights["movies"]['title'].dropna().unique()))
     
     if movie_title:
-        recommendations = get_similar_movies(movie_title, content_tfidf_matrix, title_to_index, movies, N=5)
+        recommendations = get_similar_movies(
+            title=movie_title,
+            similarity_matrix=weights["content_similarity_matrix"],
+            title_to_index=weights["title_to_index"],
+            movies=weights["movies"],
+            N=5
+        )
         if recommendations:
-            st.write(f"**Movies similar to '{movie_title}':**")
+            st.subheader(f"Because you liked **{movie_title}**, you might also enjoy:")
             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!")
+            st.warning(f"Could not find recommendations for **{movie_title}**.")
 
 else:
-    st.header("User Profile-Based Movie Recommendations")
-    st.write("Enter your user ID to get personalized movie picks based on your ratings.")
-    
-    user_id = st.number_input("Enter User ID", min_value=1, step=1, value=1)
+    st.header("👤 User Profile-Based Recommendations")
+    user_id = st.number_input("Enter your User ID", min_value=1, step=1, value=1)
     
     if st.button("Get Recommendations"):
-        recommendations = get_top_n_recommendations(user_id, user_profiles, user_tfidf_matrix, movie_id_to_idx, movies, train_ratings, n=5)
+        recommendations = get_top_n_recommendations(
+            user_id=user_id,
+            user_profiles=weights["user_profiles"],
+            tfidf_matrix=weights["user_tfidf_matrix"],
+            movie_id_to_idx=weights["movie_id_to_idx"],
+            movies=weights["movies"],
+            train_ratings=weights["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})")
+            st.subheader(f"Top picks for User ID {user_id}:")
+            for i, (movie, rating) in enumerate(recommendations, 1):
+                st.write(f"{i}. {movie} (Predicted Rating: {rating:.2f})")
         else:
-            st.error(f"Oops! User ID {user_id} not found or hasn't rated enough movies. Try another ID!")
+            st.warning(f"No recommendations available for User ID {user_id}. Try a different ID.")
+