Update app.py

app.py

@@ -1,7 +1,7 @@
 import pandas as pd
 import numpy as np
 from scipy.sparse import csr_matrix
-from sklearn.neighbors import NearestNeighbors
+from sklearn.metrics.pairwise import cosine_similarity
 import gradio as gr
 import zipfile
 import random
@@ -16,58 +16,56 @@ with zipfile.ZipFile('ml-latest-small.zip') as z:
     with z.open('ml-latest-small/ratings.csv') as f:
         ratings = pd.read_csv(f)
 
-# Create a user-item matrix
-user_item_matrix = ratings.pivot(index='userId', columns='movieId', values='rating').fillna(0)
+# Create a movie-user matrix
+movie_user_matrix = ratings.pivot(index='movieId', columns='userId', values='rating').fillna(0)
 
-# Create a sparse matrix
-user_item_matrix_sparse = csr_matrix(user_item_matrix.values)
+# Compute the cosine similarity between movies
+movie_similarity = cosine_similarity(movie_user_matrix)
 
-# Fit the NearestNeighbors model
-model_knn = NearestNeighbors(metric='cosine', algorithm='brute', n_neighbors=20, n_jobs=-1)
-model_knn.fit(user_item_matrix_sparse)
+# Create a DataFrame with movie similarities
+movie_similarity_df = pd.DataFrame(movie_similarity, index=movie_user_matrix.index, columns=movie_user_matrix.index)
 
-# Function to get movie recommendations using collaborative filtering
-def get_cf_recommendations(user_id, user_item_matrix=user_item_matrix, model_knn=model_knn, movies=movies):
-    if user_id not in user_item_matrix.index:
+# Function to get movie recommendations using item-based collaborative filtering
+def get_cf_recommendations(movie_title, movie_similarity_df=movie_similarity_df, movies=movies, n=result_count):
+    # Get the movieId for the input movie title
+    movie_id = movies[movies['title'] == movie_title]['movieId'].values[0]
+    
+    # Check if the movie is in our similarity matrix
+    if movie_id not in movie_similarity_df.index:
         return []
-
-    user_vector = user_item_matrix.loc[user_id].values.reshape(1, -1)
-    distances, indices = model_knn.kneighbors(user_vector, n_neighbors=result_count)
     
-    similar_users = user_item_matrix.index[indices.flatten()]
-    similar_users_df = pd.DataFrame({'userId': similar_users, 'distance': distances.flatten()})
+    # Get the row of similarity scores for this movie
+    similar_scores = movie_similarity_df.loc[movie_id]
+    
+    # Sort the scores in descending order
+    similar_scores = similar_scores.sort_values(ascending=False)
     
-    user_seen_movies = set(user_item_matrix.columns[user_item_matrix.loc[user_id] > 0])
+    # Get the indices of the top-n most similar movies (excluding the input movie itself)
+    similar_movie_indices = similar_scores.index[1:n+1]
     
+    # Get the titles and similarity scores of the recommended movies
     recommendations = []
-    for _, row in similar_users_df.iterrows():
-        similar_user_id = row['userId']
-        similar_user_movies = set(user_item_matrix.columns[user_item_matrix.loc[similar_user_id] > 0])
-        new_movies = similar_user_movies - user_seen_movies
-        
-        for movie_id in new_movies:
-            movie_title = movies.loc[movies['movieId'] == movie_id, 'title'].values[0]
-            score = 1 - row['distance']  # Convert distance to similarity score
-            recommendations.append((movie_title, score))
+    for idx in similar_movie_indices:
+        title = movies.loc[movies['movieId'] == idx, 'title'].values[0]
+        score = similar_scores[idx]
+        recommendations.append((title, score))
     
-    recommendations.sort(key=lambda x: x[1], reverse=True)
-    return recommendations[:result_count]
+    return recommendations
 
-# Gradio interface for collaborative filtering
-def recommend_movies_cf(user_id):
-    try:
-        user_id = int(user_id)
-    except ValueError:
-        return "Please enter a valid user ID (integer)."
+# Function for Gradio interface
+def recommend_movies_cf(movie_title):
+    if movie_title not in movies['title'].values:
+        return f"Movie '{movie_title}' not found in the dataset."
     
-    if user_id not in user_item_matrix.index:
-        return f"User ID {user_id} not found in the dataset."
-    
-    recommendations = get_cf_recommendations(user_id)
+    recommendations = get_cf_recommendations(movie_title)
     format_string = "{:>5.2f}       {:<20}"
     return "Score     Title\n" + "\n".join([format_string.format(score, title) for title, score in recommendations])
 
-# Update the existing Gradio interface
+# Create a list of movie titles for the dropdown
+movie_list = random.sample(movies['title'].tolist(), input_count)
+total_movies = len(movies)
+
+# Update the Gradio interface
 with gr.Blocks() as iface:
     with gr.Tab("Content-Based Filtering"):
         # gr.Interface(fn=recommend_movies, 
@@ -75,15 +73,13 @@ with gr.Blocks() as iface:
         #              outputs=[gr.Textbox(label="Recommended Movies:")],
         #              title="Movie Recommender - Content-Based Filtering", 
         #              description="Select a movie to get recommendations based on content filtering.")
-        gr.Markdown("## Recommendation - Content-Based Filtering")
-        gr.Markdown("### In construction")
     
     with gr.Tab("Collaborative Filtering"):
         gr.Interface(fn=recommend_movies_cf,
-                     inputs=gr.Number(label="Enter User ID"),
+                     inputs=gr.Dropdown(movie_list, label=f"Select a Movie (Total movies: {total_movies}, randomly list {input_count} for demo purpose.)"),
                      outputs=[gr.Textbox(label="Recommended Movies:")],
-                     title="Movie Recommender - Collaborative Filtering",
-                     description="Enter a user ID to get movie recommendations based on collaborative filtering.")
+                     title="Movie Recommender - Item-Based Collaborative Filtering",
+                     description="Select a movie to get recommendations based on collaborative filtering.")
 
 # Launch the app
 iface.launch()