Update app.py

app.py

@@ -1,7 +1,10 @@
+# ============================================================================
+# MOVIELENS RECOMMENDATION SYSTEM - PURE IMPLEMENTATION
+# ============================================================================
+
 import numpy as np
 import pandas as pd
 from scipy.sparse.linalg import svds
-from scipy.sparse import csr_matrix
 from sklearn.metrics.pairwise import cosine_similarity
 from sklearn.model_selection import train_test_split
 import pickle
@@ -9,12 +12,22 @@ import os
 import warnings
 warnings.filterwarnings('ignore')
 
+# ============================================================================
 # DATA LOADING & PREPROCESSING
+# ============================================================================
 
 def load_movielens_data(ratings_path='ratings.csv', movies_path='movies.csv'):
-    """Load and prepare MovieLens data"""
+    """Load MovieLens data"""
     ratings = pd.read_csv(ratings_path)
     movies = pd.read_csv(movies_path)
+    
+    print(f"Loaded {len(ratings)} ratings")
+    print(f"Loaded {len(movies)} movies")
+    print(f"Users: {ratings['userId'].nunique()}")
+    print(f"Rating distribution:\n{ratings['rating'].value_counts().sort_index()}")
+    print(f"Mean rating: {ratings['rating'].mean():.3f}")
+    print(f"Median rating: {ratings['rating'].median():.3f}")
+    
     return ratings, movies
 
 def create_user_item_matrix(ratings):
@@ -24,163 +37,253 @@ def create_user_item_matrix(ratings):
         columns='movieId', 
         values='rating'
     ).fillna(0)
+    
+    sparsity = 100 * (1 - (user_item_matrix > 0).sum().sum() / (user_item_matrix.shape[0] * user_item_matrix.shape[1]))
+    print(f"Matrix shape: {user_item_matrix.shape}")
+    print(f"Sparsity: {sparsity:.2f}%")
+    
     return user_item_matrix
 
-# COLLABORATIVE FILTERING - USER BASED
+# ============================================================================
+# USER-BASED COLLABORATIVE FILTERING
+# ============================================================================
 
 class UserBasedCF:
+    """User-based collaborative filtering using cosine similarity"""
+    
     def __init__(self, user_item_matrix):
         self.matrix = user_item_matrix
         self.user_similarity = None
         
     def fit(self):
-        """Compute user similarity matrix"""
+        """Compute user-user similarity matrix"""
+        print("Computing user similarity matrix...")
         self.user_similarity = cosine_similarity(self.matrix)
         np.fill_diagonal(self.user_similarity, 0)
+        print("User similarity matrix computed")
         
     def predict(self, user_id, k=50):
-        """Predict ratings for user"""
+        """Predict ratings for a user based on similar users"""
         if user_id not in self.matrix.index:
-            return pd.Series()
+            return pd.Series(dtype=float)
         
         user_idx = self.matrix.index.get_loc(user_id)
-        similar_users_idx = np.argsort(self.user_similarity[user_idx])[::-1][:k]
+        user_similarities = self.user_similarity[user_idx]
+        
+        # Get top-k similar users
+        top_k_indices = np.argsort(user_similarities)[::-1][:k]
+        top_k_similarities = user_similarities[top_k_indices]
+        
+        # Filter out negative similarities
+        positive_mask = top_k_similarities > 0
+        top_k_indices = top_k_indices[positive_mask]
+        top_k_similarities = top_k_similarities[positive_mask]
+        
+        if len(top_k_indices) == 0:
+            return pd.Series(0, index=self.matrix.columns, dtype=float)
+        
+        # Get ratings from similar users
+        similar_users_ratings = self.matrix.iloc[top_k_indices]
         
-        similar_users_ratings = self.matrix.iloc[similar_users_idx]
-        weights = self.user_similarity[user_idx][similar_users_idx]
+        # Weighted sum of ratings
+        weighted_ratings = similar_users_ratings.T.dot(top_k_similarities)
+        sum_of_weights = np.sum(top_k_similarities)
         
-        weighted_sum = (similar_users_ratings.T * weights).sum(axis=1)
-        weight_sum = np.abs(weights).sum()
+        # Calculate predicted ratings
+        predicted_ratings = weighted_ratings / (sum_of_weights + 1e-10)
         
-        predictions = weighted_sum / (weight_sum + 1e-10)
+        # Exclude already rated items
         user_ratings = self.matrix.loc[user_id]
-        predictions[user_ratings > 0] = 0
+        predicted_ratings[user_ratings > 0] = 0
         
-        return predictions
+        return predicted_ratings
 
-# COLLABORATIVE FILTERING - ITEM BASED
+# ============================================================================
+# ITEM-BASED COLLABORATIVE FILTERING
+# ============================================================================
 
 class ItemBasedCF:
+    """Item-based collaborative filtering using cosine similarity"""
+    
     def __init__(self, user_item_matrix):
         self.matrix = user_item_matrix
         self.item_similarity = None
         
     def fit(self):
-        """Compute item similarity matrix"""
+        """Compute item-item similarity matrix"""
+        print("Computing item similarity matrix...")
         self.item_similarity = cosine_similarity(self.matrix.T)
         np.fill_diagonal(self.item_similarity, 0)
+        print("Item similarity matrix computed")
         
     def predict(self, user_id, k=50):
-        """Predict ratings for user"""
+        """Predict ratings for a user based on similar items"""
         if user_id not in self.matrix.index:
-            return pd.Series()
+            return pd.Series(dtype=float)
         
         user_ratings = self.matrix.loc[user_id]
         rated_items = user_ratings[user_ratings > 0]
         
-        predictions = pd.Series(0, index=self.matrix.columns)
+        if len(rated_items) == 0:
+            return pd.Series(0, index=self.matrix.columns, dtype=float)
+        
+        predicted_ratings = pd.Series(0.0, index=self.matrix.columns)
         
-        for item_id in rated_items.index:
+        for item_id, rating in rated_items.items():
             item_idx = self.matrix.columns.get_loc(item_id)
-            similar_items_idx = np.argsort(self.item_similarity[item_idx])[::-1][:k]
+            item_similarities = self.item_similarity[item_idx]
+            
+            # Get top-k similar items
+            top_k_indices = np.argsort(item_similarities)[::-1][:k]
             
-            for sim_idx in similar_items_idx:
-                sim_item_id = self.matrix.columns[sim_idx]
-                if user_ratings[sim_item_id] == 0:
-                    predictions[sim_item_id] += (
-                        self.item_similarity[item_idx][sim_idx] * rated_items[item_id]
-                    )
+            for similar_idx in top_k_indices:
+                similar_item_id = self.matrix.columns[similar_idx]
+                similarity = item_similarities[similar_idx]
+                
+                if similarity > 0 and user_ratings[similar_item_id] == 0:
+                    predicted_ratings[similar_item_id] += similarity * rating
         
-        predictions[user_ratings > 0] = 0
-        return predictions
+        # Exclude already rated items
+        predicted_ratings[user_ratings > 0] = 0
+        
+        return predicted_ratings
 
-# MATRIX FACTORIZATION - SVD
+# ============================================================================
+# SINGULAR VALUE DECOMPOSITION (SVD)
+# ============================================================================
 
 class SVDRecommender:
+    """Matrix factorization using SVD"""
+    
     def __init__(self, user_item_matrix, n_factors=50):
         self.matrix = user_item_matrix
         self.n_factors = n_factors
-        self.user_factors = None
-        self.item_factors = None
-        self.mean_rating = None
+        self.predictions = None
         
     def fit(self):
         """Perform SVD decomposition"""
-        matrix_centered = self.matrix.values - self.matrix.values.mean()
+        print(f"Performing SVD with {self.n_factors} factors...")
+        
+        # Mean center the matrix
+        matrix_mean = np.mean(self.matrix.values[np.where(self.matrix.values != 0)])
+        matrix_centered = self.matrix.values.copy()
+        matrix_centered[matrix_centered != 0] -= matrix_mean
+        
+        # Perform SVD
         U, sigma, Vt = svds(matrix_centered, k=self.n_factors)
+        sigma = np.diag(sigma)
         
-        self.user_factors = U
-        self.item_factors = Vt.T
-        self.sigma = np.diag(sigma)
-        self.mean_rating = self.matrix.values.mean()
+        # Reconstruct the matrix
+        predicted_ratings = np.dot(np.dot(U, sigma), Vt) + matrix_mean
         
-        predicted = np.dot(np.dot(U, self.sigma), Vt) + self.mean_rating
         self.predictions = pd.DataFrame(
-            predicted,
+            predicted_ratings,
             index=self.matrix.index,
             columns=self.matrix.columns
         )
         
+        print("SVD decomposition complete")
+        
     def predict(self, user_id):
-        """Get predictions for user"""
+        """Get predicted ratings for a user"""
         if user_id not in self.predictions.index:
-            return pd.Series()
+            return pd.Series(dtype=float)
         
-        user_predictions = self.predictions.loc[user_id]
+        user_predictions = self.predictions.loc[user_id].copy()
         user_ratings = self.matrix.loc[user_id]
+        
+        # Exclude already rated items
         user_predictions[user_ratings > 0] = 0
         
         return user_predictions
 
+# ============================================================================
 # EVALUATION METRICS
+# ============================================================================
 
 def precision_at_k(recommended, relevant, k):
-    """Calculate Precision@K"""
+    """Precision@K: fraction of recommended items that are relevant"""
     recommended_k = set(recommended[:k])
     relevant_set = set(relevant)
-    return len(recommended_k & relevant_set) / k if k > 0 else 0
+    
+    if k == 0:
+        return 0.0
+    
+    return len(recommended_k & relevant_set) / k
 
 def recall_at_k(recommended, relevant, k):
-    """Calculate Recall@K"""
+    """Recall@K: fraction of relevant items that are recommended"""
     recommended_k = set(recommended[:k])
     relevant_set = set(relevant)
-    return len(recommended_k & relevant_set) / len(relevant_set) if len(relevant_set) > 0 else 0
+    
+    if len(relevant_set) == 0:
+        return 0.0
+    
+    return len(recommended_k & relevant_set) / len(relevant_set)
 
 def ndcg_at_k(recommended, relevant, k):
-    """Calculate NDCG@K"""
-    dcg = 0
+    """NDCG@K: Normalized Discounted Cumulative Gain"""
+    dcg = 0.0
     for i, item in enumerate(recommended[:k]):
         if item in relevant:
-            dcg += 1 / np.log2(i + 2)
+            dcg += 1.0 / np.log2(i + 2)
+    
+    idcg = sum([1.0 / np.log2(i + 2) for i in range(min(len(relevant), k))])
+    
+    if idcg == 0:
+        return 0.0
     
-    idcg = sum([1 / np.log2(i + 2) for i in range(min(len(relevant), k))])
-    return dcg / idcg if idcg > 0 else 0
+    return dcg / idcg
 
 def evaluate_model(model, test_data, user_item_matrix, k=10, threshold=4.0):
-    """Evaluate model on test set"""
-    precisions, recalls, ndcgs = [], [], []
+    """Evaluate recommendation model"""
+    precisions = []
+    recalls = []
+    ndcgs = []
     
-    test_users = test_data['userId'].unique()[:100]
+    test_users = test_data['userId'].unique()
     
+    print(f"Evaluating on {len(test_users)} test users...")
+    
+    evaluated_count = 0
     for user_id in test_users:
         if user_id not in user_item_matrix.index:
             continue
-            
-        user_test = test_data[test_data['userId'] == user_id]
-        relevant_items = user_test[user_test['rating'] >= threshold]['movieId'].tolist()
+        
+        # Get relevant items for this user (rated >= threshold)
+        user_test_data = test_data[test_data['userId'] == user_id]
+        relevant_items = user_test_data[user_test_data['rating'] >= threshold]['movieId'].tolist()
         
         if len(relevant_items) == 0:
             continue
         
+        # Get predictions
         predictions = model.predict(user_id)
-        if len(predictions) == 0:
+        
+        if len(predictions) == 0 or predictions.sum() == 0:
             continue
-            
-        recommended = predictions.sort_values(ascending=False).index[:k].tolist()
         
-        precisions.append(precision_at_k(recommended, relevant_items, k))
-        recalls.append(recall_at_k(recommended, relevant_items, k))
-        ndcgs.append(ndcg_at_k(recommended, relevant_items, k))
+        # Get top-k recommendations
+        top_k_items = predictions.nlargest(k).index.tolist()
+        
+        # Calculate metrics
+        precisions.append(precision_at_k(top_k_items, relevant_items, k))
+        recalls.append(recall_at_k(top_k_items, relevant_items, k))
+        ndcgs.append(ndcg_at_k(top_k_items, relevant_items, k))
+        
+        evaluated_count += 1
+        
+        if evaluated_count >= 100:  # Limit for computational efficiency
+            break
+    
+    print(f"Evaluated {evaluated_count} users")
+    
+    if len(precisions) == 0:
+        return {
+            'Precision@K': 0.0,
+            'Recall@K': 0.0,
+            'NDCG@K': 0.0
+        }
     
     return {
         'Precision@K': np.mean(precisions),
@@ -188,80 +291,113 @@ def evaluate_model(model, test_data, user_item_matrix, k=10, threshold=4.0):
         'NDCG@K': np.mean(ndcgs)
     }
 
-# RECOMMENDATION FUNCTION (REQUIRED DELIVERABLE)
+# ============================================================================
+# RECOMMENDATION FUNCTION
+# ============================================================================
 
 def recommend_movies(user_id, N, model, movies_df):
     """
-    Recommend top N movies for user
+    Recommend top N movies for a user
     
     Parameters:
-    - user_id: target user ID
-    - N: number of recommendations
-    - model: trained recommendation model
-    - movies_df: movies dataframe with titles
+    - user_id: User ID
+    - N: Number of recommendations
+    - model: Trained recommendation model
+    - movies_df: DataFrame with movie information
     
     Returns:
-    - DataFrame with movie recommendations
+    - DataFrame with recommended movies
     """
     predictions = model.predict(user_id)
     
     if len(predictions) == 0:
         return pd.DataFrame(columns=['movieId', 'title', 'predicted_rating'])
     
-    top_n = predictions.sort_values(ascending=False).head(N)
+    # Get top N predictions
+    top_n = predictions.nlargest(N)
+    
     recommendations = pd.DataFrame({
         'movieId': top_n.index,
         'predicted_rating': top_n.values
     })
     
-    recommendations = recommendations.merge(movies_df[['movieId', 'title']], on='movieId')
+    # Merge with movie titles
+    recommendations = recommendations.merge(
+        movies_df[['movieId', 'title']], 
+        on='movieId', 
+        how='left'
+    )
+    
     return recommendations[['movieId', 'title', 'predicted_rating']]
 
-# MAIN EXECUTION PIPELINE
+# ============================================================================
+# MAIN EXECUTION
+# ============================================================================
 
 def main():
-    print("Loading data...")
+    print("="*70)
+    print("MOVIELENS RECOMMENDATION SYSTEM")
+    print("="*70)
+    
+    # Load data
+    print("\n[1/6] Loading data...")
     ratings, movies = load_movielens_data()
     
-    # Train-test split
+    # Split data
+    print("\n[2/6] Splitting data (80% train, 20% test)...")
     train_data, test_data = train_test_split(ratings, test_size=0.2, random_state=42)
+    print(f"Training set: {len(train_data)} ratings")
+    print(f"Test set: {len(test_data)} ratings")
     
-    print("Creating user-item matrix...")
+    # Create user-item matrix
+    print("\n[3/6] Creating user-item matrix...")
     user_item_matrix = create_user_item_matrix(train_data)
     
-    # Train models
-    print("\n1. Training User-Based CF...")
+    # Train User-Based CF
+    print("\n[4/6] Training User-Based Collaborative Filtering...")
     user_cf = UserBasedCF(user_item_matrix)
     user_cf.fit()
+    print("Evaluating User-Based CF...")
     metrics_user_cf = evaluate_model(user_cf, test_data, user_item_matrix)
-    print(f"User-Based CF Metrics: {metrics_user_cf}")
+    print(f"User-Based CF Results:")
+    for metric, value in metrics_user_cf.items():
+        print(f"  {metric}: {value:.4f}")
     
-    print("\n2. Training Item-Based CF...")
+    # Train Item-Based CF
+    print("\n[5/6] Training Item-Based Collaborative Filtering...")
     item_cf = ItemBasedCF(user_item_matrix)
     item_cf.fit()
+    print("Evaluating Item-Based CF...")
     metrics_item_cf = evaluate_model(item_cf, test_data, user_item_matrix)
-    print(f"Item-Based CF Metrics: {metrics_item_cf}")
+    print(f"Item-Based CF Results:")
+    for metric, value in metrics_item_cf.items():
+        print(f"  {metric}: {value:.4f}")
     
-    print("\n3. Training SVD...")
+    # Train SVD
+    print("\n[6/6] Training SVD (Matrix Factorization)...")
     svd = SVDRecommender(user_item_matrix, n_factors=50)
     svd.fit()
+    print("Evaluating SVD...")
     metrics_svd = evaluate_model(svd, test_data, user_item_matrix)
-    print(f"SVD Metrics: {metrics_svd}")
+    print(f"SVD Results:")
+    for metric, value in metrics_svd.items():
+        print(f"  {metric}: {value:.4f}")
     
-    # Compare models
-    print("\n" + "="*60)
+    # Model comparison
+    print("\n" + "="*70)
     print("MODEL COMPARISON")
-    print("="*60)
-    comparison = pd.DataFrame({
+    print("="*70)
+    
+    comparison_df = pd.DataFrame({
         'User-Based CF': metrics_user_cf,
         'Item-Based CF': metrics_item_cf,
         'SVD': metrics_svd
     })
-    print(comparison)
+    print(comparison_df.to_string())
     
-    # Select best model
-    best_model_name = comparison.loc['NDCG@K'].idxmax()
-    print(f"\nBest Model: {best_model_name}")
+    # Determine best model
+    best_model_name = comparison_df.loc['NDCG@K'].idxmax()
+    print(f"\n*** Best Model (by NDCG@K): {best_model_name} ***")
     
     if best_model_name == 'User-Based CF':
         best_model = user_cf
@@ -270,53 +406,69 @@ def main():
     else:
         best_model = svd
     
-    # Example recommendation
-    print("\n" + "="*60)
+    # Example recommendations
+    print("\n" + "="*70)
     print("EXAMPLE RECOMMENDATIONS")
-    print("="*60)
-    sample_user = user_item_matrix.index[0]
-    recommendations = recommend_movies(sample_user, 10, best_model, movies)
-    print(f"\nTop 10 recommendations for User {sample_user}:")
+    print("="*70)
+    
+    sample_user_id = user_item_matrix.index[0]
+    print(f"\nTop 10 recommendations for User {sample_user_id} using {best_model_name}:")
+    
+    recommendations = recommend_movies(sample_user_id, 10, best_model, movies)
     print(recommendations.to_string(index=False))
     
-    # Save all models for deployment
-    save_all_for_deployment(user_cf, item_cf, svd, user_item_matrix, movies, 
-                           metrics_user_cf, metrics_item_cf, metrics_svd)
+    # Save models for deployment
+    print("\n" + "="*70)
+    print("SAVING MODELS FOR DEPLOYMENT")
+    print("="*70)
+    
+    save_models_for_deployment(
+        user_cf, item_cf, svd, 
+        user_item_matrix, movies,
+        metrics_user_cf, metrics_item_cf, metrics_svd
+    )
     
     return best_model, user_item_matrix, movies
 
-# SAVE MODELS FOR DEPLOYMENT
-
-def save_all_for_deployment(user_cf, item_cf, svd, user_item_matrix, movies, 
-                            metrics_user_cf, metrics_item_cf, metrics_svd):
-    """Save everything needed for Hugging Face deployment"""
+def save_models_for_deployment(user_cf, item_cf, svd, user_item_matrix, movies,
+                               metrics_user_cf, metrics_item_cf, metrics_svd):
+    """Save all models and data for Hugging Face deployment"""
     
     output_dir = 'deployment_files'
     os.makedirs(output_dir, exist_ok=True)
     
+    print(f"Saving models to {output_dir}/...")
+    
     with open(f'{output_dir}/user_cf_model.pkl', 'wb') as f:
         pickle.dump(user_cf, f)
+    print("  ✓ User-Based CF model saved")
     
     with open(f'{output_dir}/item_cf_model.pkl', 'wb') as f:
         pickle.dump(item_cf, f)
+    print("  ✓ Item-Based CF model saved")
     
     with open(f'{output_dir}/svd_model.pkl', 'wb') as f:
         pickle.dump(svd, f)
+    print("  ✓ SVD model saved")
     
     with open(f'{output_dir}/user_item_matrix.pkl', 'wb') as f:
         pickle.dump(user_item_matrix, f)
+    print("  ✓ User-item matrix saved")
+    
+    metrics = {
+        'User-Based CF': metrics_user_cf,
+        'Item-Based CF': metrics_item_cf,
+        'SVD': metrics_svd
+    }
     
     with open(f'{output_dir}/metrics.pkl', 'wb') as f:
-        pickle.dump({
-            'User-Based CF': metrics_user_cf,
-            'Item-Based CF': metrics_item_cf,
-            'SVD': metrics_svd
-        }, f)
+        pickle.dump(metrics, f)
+    print("  ✓ Metrics saved")
     
     movies.to_csv(f'{output_dir}/movies.csv', index=False)
+    print("  ✓ Movies data saved")
     
-    print(f"\nAll models and data saved to {output_dir}/")
-    print("Ready for Hugging Face deployment")
+    print("\nAll files ready for Hugging Face deployment!")
 
 if __name__ == "__main__":
     best_model, user_item_matrix, movies = main()
@@ -327,10 +479,11 @@ import pandas as pd
 import numpy as np
 import os
 
-# Define base directory
+# Determine file location
 BASE_DIR = 'deployment_files' if os.path.exists('deployment_files') else '.'
 
-# Load all models with correct paths
+# Load models and data
+print("Loading models...")
 with open(f'{BASE_DIR}/user_cf_model.pkl', 'rb') as f:
     user_cf = pickle.load(f)
 
@@ -354,56 +507,67 @@ MODELS = {
     'SVD': svd
 }
 
+print("Models loaded successfully!")
+
 def recommend_movies(user_id, N, model_name='SVD'):
-    """
-    Recommend top N movies for user
-    Required function signature matching specifications
-    """
+    """Generate movie recommendations"""
     try:
         user_id = int(user_id)
         N = int(N)
         
-        model = MODELS[model_name]
-        
         if user_id not in user_item_matrix.index:
-            return "User ID not found in system", ""
+            return pd.DataFrame({'Error': ['User ID not found in system']}), ""
         
+        model = MODELS[model_name]
         predictions = model.predict(user_id)
         
-        if len(predictions) == 0:
-            return "No predictions available for this user", ""
+        if len(predictions) == 0 or predictions.sum() == 0:
+            return pd.DataFrame({'Error': ['No predictions available for this user']}), ""
         
-        top_n = predictions.sort_values(ascending=False).head(N)
+        # Get top N recommendations
+        top_n = predictions.nlargest(N)
         
         recommendations = pd.DataFrame({
             'movieId': top_n.index,
             'predicted_rating': top_n.values
         })
         
-        recommendations = recommendations.merge(movies[['movieId', 'title']], on='movieId')
-        result_df = recommendations[['movieId', 'title', 'predicted_rating']]
+        # Add movie titles
+        recommendations = recommendations.merge(
+            movies[['movieId', 'title']], 
+            on='movieId', 
+            how='left'
+        )
+        
+        result = recommendations[['movieId', 'title', 'predicted_rating']]
         
-        # Model performance info
-        model_metrics = f"""
+        # Format metrics
+        metrics_text = f"""
 ### {model_name} Performance Metrics
 
 - **Precision@10**: {metrics[model_name]['Precision@K']:.4f}
 - **Recall@10**: {metrics[model_name]['Recall@K']:.4f}
 - **NDCG@10**: {metrics[model_name]['NDCG@K']:.4f}
+
+*Metrics evaluated on test set with relevance threshold = 4.0*
         """
         
-        return result_df, model_metrics
-    
+        return result, metrics_text
+        
     except Exception as e:
-        return f"Error: {str(e)}", ""
+        return pd.DataFrame({'Error': [f'Error: {str(e)}']}), ""
 
-def show_comparison():
-    """Display comprehensive model comparison report"""
+def show_model_comparison():
+    """Display model comparison report"""
+    
+    # Determine best model
+    ndcg_scores = {name: m['NDCG@K'] for name, m in metrics.items()}
+    best_model = max(ndcg_scores, key=ndcg_scores.get)
     
-    comparison_text = f"""
+    report = f"""
 # Model Comparison Report
 
-## Performance Metrics (Test Set Evaluation)
+## Performance Metrics
 
 | Model | Precision@10 | Recall@10 | NDCG@10 |
 |-------|--------------|-----------|---------|
@@ -411,165 +575,151 @@ def show_comparison():
 | Item-Based CF | {metrics['Item-Based CF']['Precision@K']:.4f} | {metrics['Item-Based CF']['Recall@K']:.4f} | {metrics['Item-Based CF']['NDCG@K']:.4f} |
 | SVD | {metrics['SVD']['Precision@K']:.4f} | {metrics['SVD']['Recall@K']:.4f} | {metrics['SVD']['NDCG@K']:.4f} |
 
----
-
-## Best Performing Model: SVD (Matrix Factorization)
-
-### Why SVD Outperforms Collaborative Filtering
-
-**1. Latent Factor Discovery**
-- SVD decomposes rating matrix into user and item latent factors
-- Captures hidden patterns beyond direct similarity
-- Identifies underlying preferences not visible in raw ratings
+## Best Model: {best_model}
 
-**2. Sparsity Handling**
-- MovieLens data is extremely sparse (most user-item pairs unrated)
-- SVD learns compressed representation that generalizes well
-- CF methods struggle with cold-start and sparse neighborhoods
+### Why {best_model} Performs Best
 
-**3. Computational Efficiency**
-- SVD complexity scales with number of factors (50), not users/items
-- CF requires computing full similarity matrices
-- Prediction time: O(k) for SVD vs O(n) for CF
+**Matrix Factorization (SVD) Advantages:**
+- Captures latent factors in user-movie interactions
+- Handles sparse data through dimensionality reduction
+- Generalizes better than similarity-based methods
+- Computationally efficient for prediction
 
-**4. Noise Reduction**
-- Dimensionality reduction filters rating noise
-- Focuses on strongest patterns in data
-- CF can propagate noise through similarity weights
-
-### Trade-offs Analysis
-
-**User-Based Collaborative Filtering**
-- ✓ Intuitive: "Users like you also liked..."
-- ✓ Explainable recommendations
-- ✗ Computationally expensive (O(n²) similarity matrix)
-- ✗ Poor performance with sparse data
-- ✗ Sensitive to rating scale differences
-
-**Item-Based Collaborative Filtering**
-- ✓ More stable than user-based (items change less than users)
-- ✓ Reasonably interpretable
-- ✗ Still requires full item similarity computation
-- ✗ Limited to items similar to already-rated items
-- ✗ Cannot discover cross-genre patterns
-
-**SVD (Matrix Factorization)**
-- ✓ Best accuracy across all metrics
-- ✓ Handles sparsity effectively
-- ✓ Discovers latent preference patterns
-- ✓ Scalable to large datasets
-- ✗ Less interpretable (latent factors abstract)
-- ✗ Requires full matrix retraining for updates
+**Collaborative Filtering Trade-offs:**
+- **User-Based**: Intuitive but computationally expensive, struggles with sparsity
+- **Item-Based**: More stable than user-based, but limited to similar items
+- **SVD**: Best balance of accuracy and efficiency
 
 ### Implementation Details
 
-- **SVD Configuration**: 50 latent factors
-- **CF Neighborhood Size**: k=50 nearest neighbors
-- **Similarity Metric**: Cosine similarity
+- **SVD**: 50 latent factors via Singular Value Decomposition
+- **CF**: Cosine similarity with k=50 neighbors
 - **Evaluation**: 80/20 train-test split, threshold=4.0 for relevance
-- **Metrics Computation**: Averaged over 100 test users
+- **Metrics**: Precision, Recall, and NDCG at K=10
 
 ### Conclusion
 
-SVD demonstrates superior performance due to its ability to learn compressed latent representations that capture complex user-item interaction patterns. While collaborative filtering methods offer better interpretability, the accuracy gains from matrix factorization make SVD the recommended approach for production deployment.
+SVD achieves the best performance by learning compressed representations of user preferences 
+and movie characteristics, making it the recommended approach for production deployment.
     """
     
-    return comparison_text
+    return report
 
-def get_user_info():
-    """Display available user range"""
+def get_dataset_info():
+    """Display dataset statistics"""
     min_user = int(user_item_matrix.index.min())
     max_user = int(user_item_matrix.index.max())
-    total_users = len(user_item_matrix.index)
-    total_movies = len(movies)
+    num_users = len(user_item_matrix.index)
+    num_movies = len(movies)
     
     info = f"""
 ### Dataset Information
 
-- **Total Users**: {total_users:,}
-- **Total Movies**: {total_movies:,}
+- **Total Users**: {num_users:,}
+- **Total Movies**: {num_movies:,}
 - **User ID Range**: {min_user} to {max_user}
-- **Rating Scale**: 1-5 stars
-- **Dataset**: MovieLens
+- **Rating Scale**: 0.5 to 5.0 stars
+- **Source**: MovieLens Dataset
     """
     return info
 
-# Gradio Interface
-with gr.Blocks(title="MovieLens Recommendation System - DataSynthis_ML_JobTask", theme=gr.themes.Soft()) as demo:
+# Build Gradio Interface
+with gr.Blocks(title="MovieLens Recommendation System", theme=gr.themes.Soft()) as demo:
     
     gr.Markdown("""
     # 🎬 MovieLens Recommendation System
     ## DataSynthis_ML_JobTask
     
-    Advanced movie recommendation engine using Collaborative Filtering and Matrix Factorization techniques.
+    Compare three recommendation algorithms: User-Based CF, Item-Based CF, and SVD Matrix Factorization
     """)
     
     with gr.Tab("🎯 Get Recommendations"):
-        gr.Markdown(get_user_info())
+        gr.Markdown(get_dataset_info())
         
         with gr.Row():
             with gr.Column():
-                user_input = gr.Number(label="User ID", value=1, precision=0)
-                n_input = gr.Number(label="Number of Recommendations (N)", value=10, precision=0)
-                model_input = gr.Dropdown(
+                user_id_input = gr.Number(
+                    label="User ID", 
+                    value=1, 
+                    precision=0,
+                    info="Enter a valid user ID from the dataset"
+                )
+                n_input = gr.Number(
+                    label="Number of Recommendations (N)", 
+                    value=10, 
+                    precision=0,
+                    info="How many movies to recommend (1-20)"
+                )
+                model_select = gr.Dropdown(
                     choices=['User-Based CF', 'Item-Based CF', 'SVD'],
                     value='SVD',
-                    label="Select Recommendation Model"
+                    label="Recommendation Algorithm",
+                    info="Select which model to use"
                 )
-                recommend_btn = gr.Button("🎬 Get Recommendations", variant="primary")
+                
+                recommend_btn = gr.Button("🎬 Get Recommendations", variant="primary", size="lg")
+        
+        recommendations_output = gr.Dataframe(
+            label="📋 Recommended Movies",
+            wrap=True
+        )
         
-        output_df = gr.Dataframe(label="📋 Recommended Movies", wrap=True)
         metrics_output = gr.Markdown(label="📊 Model Performance")
         
         recommend_btn.click(
             fn=recommend_movies,
-            inputs=[user_input, n_input, model_input],
-            outputs=[output_df, metrics_output]
+            inputs=[user_id_input, n_input, model_select],
+            outputs=[recommendations_output, metrics_output]
         )
     
     with gr.Tab("📊 Model Comparison"):
-        comparison_output = gr.Markdown(show_comparison())
+        gr.Markdown(show_model_comparison())
     
-    with gr.Tab("ℹ️ About"):
+    with gr.Tab("ℹ️ Documentation"):
         gr.Markdown("""
         ## Implementation Overview
         
-        ### Algorithms Implemented
+        ### Algorithms
         
         **1. User-Based Collaborative Filtering**
-        - Computes cosine similarity between users
+        - Finds users with similar rating patterns
         - Recommends items liked by similar users
-        - Neighborhood size: 50 users
+        - Uses cosine similarity with k=50 neighbors
         
         **2. Item-Based Collaborative Filtering**
-        - Computes cosine similarity between items
-        - Recommends items similar to user's rated items
-        - Neighborhood size: 50 items
+        - Finds items similar to those the user has rated
+        - Recommends items similar to user's preferences
+        - Uses cosine similarity with k=50 neighbors
         
         **3. Singular Value Decomposition (SVD)**
         - Matrix factorization with 50 latent factors
-        - Learns user and item embeddings
-        - Predicts ratings via dot product
+        - Learns low-dimensional representations of users and items
+        - Predicts ratings via reconstructed matrix
         
         ### Evaluation Metrics
         
-        - **Precision@K**: Proportion of recommended items that are relevant
-        - **Recall@K**: Proportion of relevant items that are recommended
-        - **NDCG@K**: Normalized discounted cumulative gain (position-aware metric)
+        - **Precision@K**: Fraction of recommended items that are relevant
+        - **Recall@K**: Fraction of relevant items that are recommended  
+        - **NDCG@K**: Normalized Discounted Cumulative Gain (considers ranking order)
+        
+        ### Technical Stack
+        
+        - Python 3.10+
+        - NumPy, Pandas for data processing
+        - SciPy for SVD computation
+        - Scikit-learn for similarity metrics
+        - Gradio for web interface
         
         ### Dataset
+        
         - Source: MovieLens
-        - Train/Test Split: 80/20
+        - Split: 80% training, 20% testing
         - Relevance Threshold: 4.0 stars
         
-        ### Technologies
-        - Python, NumPy, Pandas, SciPy
-        - Scikit-learn for similarity computation
-        - Gradio for web interface
-        
         ---
         
-        **Developed for DataSynthis ML Job Task**
+        **Project**: DataSynthis ML Job Task  
+        **Task**: Movie Recommendation System
         """)
 
 demo.launch()