Upload app.py

app.py

@@ -0,0 +1,179 @@
+
+import gradio as gr
+import pickle
+import pandas as pd
+import numpy as np
+from surprise import SVD
+import warnings
+warnings.filterwarnings('ignore')
+
+# Load models and data
+print("Loading models...")
+with open('svd_model.pkl', 'rb') as f:
+    svd_model = pickle.load(f)
+
+with open('movies.pkl', 'rb') as f:
+    movies = pickle.load(f)
+
+with open('ratings.pkl', 'rb') as f:
+    ratings = pickle.load(f)
+
+print("Models loaded successfully!")
+
+def recommend_movies(user_id, num_recommendations, min_rating):
+    """
+    Generate movie recommendations for a user
+    """
+    try:
+        user_id = int(user_id)
+        num_recommendations = int(num_recommendations)
+        min_rating = float(min_rating)
+        
+        # Check if user exists
+        if user_id not in ratings['userId'].values:
+            return f"⚠️ User ID {user_id} not found in database. Please try a different user ID (1-{ratings['userId'].max()})."
+        
+        # Get all movies
+        all_movie_ids = movies['movieId'].unique()
+        
+        # Get movies the user has already rated
+        rated_movies = ratings[ratings['userId'] == user_id]['movieId'].values
+        
+        # Get movies the user hasn't rated
+        movies_to_predict = [mid for mid in all_movie_ids if mid not in rated_movies]
+        
+        # Predict ratings
+        predictions = []
+        for movie_id in movies_to_predict:
+            pred = svd_model.predict(user_id, movie_id)
+            if pred.est >= min_rating:
+                predictions.append({
+                    'movieId': movie_id,
+                    'predicted_rating': pred.est
+                })
+        
+        if not predictions:
+            return f"No movies found with predicted rating >= {min_rating}. Try lowering the minimum rating."
+        
+        # Sort and get top N
+        predictions_df = pd.DataFrame(predictions)
+        predictions_df = predictions_df.sort_values('predicted_rating', ascending=False)
+        top_recommendations = predictions_df.head(num_recommendations)
+        
+        # Merge with movie details
+        recommendations = top_recommendations.merge(movies, on='movieId')
+        recommendations['predicted_rating'] = recommendations['predicted_rating'].round(2)
+        
+        # Format output
+        output = f"🎬 Top {len(recommendations)} Movie Recommendations for User {user_id}\n\n"
+        
+        for idx, row in recommendations.iterrows():
+            output += f"{idx + 1}. **{row['title']}**\n"
+            output += f"   ⭐ Predicted Rating: {row['predicted_rating']}/5.0\n"
+            output += f"   🎭 Genres: {row['genres']}\n\n"
+        
+        return output
+    
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+def get_user_history(user_id):
+    """
+    Get user's rating history
+    """
+    try:
+        user_id = int(user_id)
+        
+        if user_id not in ratings['userId'].values:
+            return f"⚠️ User ID {user_id} not found."
+        
+        user_ratings = ratings[ratings['userId'] == user_id].merge(movies, on='movieId')
+        user_ratings = user_ratings.sort_values('rating', ascending=False).head(10)
+        
+        output = f"📊 User {user_id}'s Top Rated Movies:\n\n"
+        
+        for idx, row in user_ratings.iterrows():
+            output += f"• **{row['title']}** - ⭐ {row['rating']}/5.0\n"
+            output += f"  Genres: {row['genres']}\n\n"
+        
+        return output
+    
+    except Exception as e:
+        return f"❌ Error: {str(e)}"
+
+# Create Gradio interface
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 🎬 MovieLens Recommendation System
+        ### Powered by SVD Matrix Factorization
+        
+        Get personalized movie recommendations based on collaborative filtering!
+        """
+    )
+    
+    with gr.Tab("🎯 Get Recommendations"):
+        with gr.Row():
+            with gr.Column():
+                user_id_input = gr.Number(
+                    label="User ID",
+                    value=1,
+                    info=f"Enter a user ID (1 to {ratings['userId'].max()})"
+                )
+                num_rec_input = gr.Slider(
+                    minimum=5,
+                    maximum=20,
+                    value=10,
+                    step=1,
+                    label="Number of Recommendations"
+                )
+                min_rating_input = gr.Slider(
+                    minimum=1.0,
+                    maximum=5.0,
+                    value=3.5,
+                    step=0.5,
+                    label="Minimum Predicted Rating"
+                )
+                recommend_btn = gr.Button("🎬 Get Recommendations", variant="primary")
+            
+            with gr.Column():
+                recommendations_output = gr.Markdown(label="Recommendations")
+        
+        recommend_btn.click(
+            fn=recommend_movies,
+            inputs=[user_id_input, num_rec_input, min_rating_input],
+            outputs=recommendations_output
+        )
+    
+    with gr.Tab("📊 User History"):
+        with gr.Row():
+            with gr.Column():
+                history_user_id = gr.Number(
+                    label="User ID",
+                    value=1,
+                    info="Enter a user ID to see their rating history"
+                )
+                history_btn = gr.Button("📊 View History", variant="primary")
+            
+            with gr.Column():
+                history_output = gr.Markdown(label="User History")
+        
+        history_btn.click(
+            fn=get_user_history,
+            inputs=history_user_id,
+            outputs=history_output
+        )
+    
+    gr.Markdown(
+        """
+        ---
+        ### 📈 Model Information
+        - **Algorithm**: SVD (Singular Value Decomposition)
+        - **Dataset**: MovieLens Small (100K ratings)
+        - **Evaluation Metrics**: RMSE, Precision@K, Recall@K, NDCG@K
+        - **Best Performance**: Lowest RMSE and Highest NDCG among tested models
+        """
+    )
+
+if __name__ == "__main__":
+    demo.launch()