Update app.py

app.py

@@ -8,43 +8,36 @@ import os
 from scipy.sparse import csr_matrix
 
 class ItemBasedCF:
-    def __init__(self):
+    def __init__(self, n_neighbors=20):
+        self.n_neighbors = n_neighbors
+        self.item_similarity = None
         self.user_item_matrix = None
-        self.similarity_matrix = None
-    
-    def predict(self, user_idx, movie_idx):
-        if self.user_item_matrix is None or self.similarity_matrix is None:
-            return 3.0
         
+    def predict(self, user_idx, movie_idx):
         user_ratings = self.user_item_matrix[user_idx].toarray().flatten()
-        rated_items = np.where(user_ratings > 0)[0]
+        rated_mask = user_ratings > 0
         
-        if len(rated_items) == 0:
-            return 3.0
+        if not rated_mask.any():
+            return 2.5
         
-        similarities = self.similarity_matrix[movie_idx, rated_items].toarray().flatten()
-        ratings = user_ratings[rated_items]
+        similarities = self.item_similarity[movie_idx].toarray().flatten()
         
-        if similarities.sum() == 0:
-            return 3.0
+        weights = similarities * rated_mask
+        if weights.sum() == 0:
+            return 2.5
         
-        prediction = np.dot(similarities, ratings) / similarities.sum()
+        prediction = (weights * user_ratings).sum() / weights.sum()
         return np.clip(prediction, 1, 5)
 
 
 class SVDRecommender:
-    def __init__(self):
+    def __init__(self, n_factors=50):
+        self.n_factors = n_factors
         self.user_factors = None
         self.item_factors = None
         self.global_mean = 3.5
     
     def predict(self, user_idx, movie_idx):
-        if self.user_factors is None or self.item_factors is None:
-            return self.global_mean
-        
-        if user_idx >= len(self.user_factors) or movie_idx >= len(self.item_factors):
-            return self.global_mean
-        
         prediction = self.global_mean + np.dot(self.user_factors[user_idx], self.item_factors[movie_idx])
         return np.clip(prediction, 1, 5)
 
@@ -82,71 +75,71 @@ class NeuralCF(nn.Module):
 
 
 class HybridRecommender:
-    def __init__(self):
+    def __init__(self, n_users, n_movies):
+        self.n_users = n_users
+        self.n_movies = n_movies
         self.item_cf = None
         self.svd = None
         self.ncf = None
-        self.weights = [0.33, 0.33, 0.34]
-        self.device = 'cpu'
+        self.weights = {
+            'item_cf': 0.3,
+            'svd': 0.4,
+            'ncf': 0.3
+        }
     
     def predict(self, user_idx, movie_idx):
-        predictions = []
-        
-        if self.item_cf is not None:
-            predictions.append(self.item_cf.predict(user_idx, movie_idx))
-        
-        if self.svd is not None:
-            predictions.append(self.svd.predict(user_idx, movie_idx))
-        
-        if self.ncf is not None:
-            predictions.append(self.ncf.predict(user_idx, movie_idx, self.device))
-        
-        if not predictions:
-            return 3.5
-        
-        weights = self.weights[:len(predictions)]
-        weight_sum = sum(weights)
-        weighted_pred = sum(p * w for p, w in zip(predictions, weights)) / weight_sum
+        cf_pred = self.item_cf.predict(user_idx, movie_idx)
+        svd_pred = self.svd.predict(user_idx, movie_idx)
+        ncf_pred = self.ncf.predict(user_idx, movie_idx)
+        
+        prediction = (
+            self.weights['item_cf'] * cf_pred +
+            self.weights['svd'] * svd_pred +
+            self.weights['ncf'] * ncf_pred
+        )
         
-        return np.clip(weighted_pred, 1, 5)
+        return np.clip(prediction, 1, 5)
     
-    def recommend_movies(self, user_id, N, user_id_map, reverse_movie_map, movies_df):
-        if user_id not in user_id_map:
-            return []
-        
-        user_idx = user_id_map[user_id]
-        
-        if self.item_cf is None or self.item_cf.user_item_matrix is None:
-            return []
+    def recommend_movies(self, user_id, N=10, user_id_map=None, reverse_movie_map=None, movies_df=None):
+        if user_id_map is not None:
+            if user_id not in user_id_map:
+                return []
+            user_idx = user_id_map[user_id]
+        else:
+            user_idx = user_id
         
-        user_ratings = self.item_cf.user_item_matrix[user_idx].toarray().flatten()
-        unrated_indices = np.where(user_ratings == 0)[0]
+        rated_movies = set(np.where(self.item_cf.user_item_matrix[user_idx].toarray().flatten() > 0)[0])
         
-        if len(unrated_indices) == 0:
-            return []
+        scores = []
+        for movie_idx in range(self.n_movies):
+            if movie_idx not in rated_movies:
+                score = self.predict(user_idx, movie_idx)
+                scores.append((movie_idx, score))
         
-        predictions = []
-        for movie_idx in unrated_indices:
-            pred_rating = self.predict(user_idx, movie_idx)
-            predictions.append((movie_idx, pred_rating))
-        
-        predictions.sort(key=lambda x: x[1], reverse=True)
-        top_predictions = predictions[:N]
+        scores.sort(key=lambda x: x[1], reverse=True)
+        top_recommendations = scores[:N]
         
         recommendations = []
-        for movie_idx, pred_rating in top_predictions:
-            original_movie_id = reverse_movie_map[movie_idx]
-            movie_info = movies_df[movies_df['movie_id'] == original_movie_id]
+        for movie_idx, score in top_recommendations:
+            if reverse_movie_map is not None:
+                original_movie_id = reverse_movie_map[movie_idx]
+            else:
+                original_movie_id = movie_idx
+            
+            if movies_df is not None:
+                title = movies_df[movies_df['movie_id'] == original_movie_id]['title'].values[0]
+            else:
+                title = f"Movie {original_movie_id}"
             
-            if not movie_info.empty:
-                title = movie_info['title'].values[0]
-                recommendations.append((original_movie_id, title, pred_rating))
+            recommendations.append((original_movie_id, title, score))
         
         return recommendations
 
 
 class MovieLensDataLoader:
-    def __init__(self):
+    def __init__(self, ratings_path=None, movies_path=None):
+        self.ratings_path = ratings_path
+        self.movies_path = movies_path
         self.user_id_map = {}
         self.movie_id_map = {}
         self.reverse_user_map = {}