create app.py

app.py

@@ -0,0 +1,303 @@
+import gradio as gr
+import pickle
+import pandas as pd
+import numpy as np
+import torch
+import os
+
+def load_model_and_data():
+    try:
+        with open('model_artifacts/hybrid_model.pkl', 'rb') as f:
+            model = pickle.load(f)
+        
+        with open('model_artifacts/loader.pkl', 'rb') as f:
+            loader = pickle.load(f)
+        
+        with open('model_artifacts/movies.pkl', 'rb') as f:
+            movies = pickle.load(f)
+        
+        user_ids = sorted(loader.user_id_map.keys())
+        
+        return model, loader, movies, user_ids
+    except Exception as e:
+        print(f"Error loading model: {e}")
+        return None, None, None, []
+
+print("Loading model and data...")
+model, loader, movies_df, user_ids = load_model_and_data()
+print(f"Model loaded! Available users: {len(user_ids)}")
+
+def get_recommendations(user_id, num_recommendations):
+    if model is None or loader is None:
+        return "Error: Model not loaded properly."
+    
+    try:
+        user_id = int(user_id)
+        num_recommendations = int(num_recommendations)
+        
+        if user_id not in loader.user_id_map:
+            return f"User ID {user_id} not found! Please select a valid user ID."
+        
+        recommendations = model.recommend_movies(
+            user_id=user_id,
+            N=num_recommendations,
+            user_id_map=loader.user_id_map,
+            reverse_movie_map=loader.reverse_movie_map,
+            movies_df=movies_df
+        )
+        
+        if not recommendations:
+            return f"No recommendations found for User {user_id}"
+        
+        output = f"Top {num_recommendations} Movie Recommendations for User {user_id}\n\n"
+        output += "=" * 60 + "\n\n"
+        
+        for i, (movie_id, title, score) in enumerate(recommendations, 1):
+            stars = "*" * int(score)
+            output += f"{i}. {title}\n"
+            output += f"   Predicted Rating: {score:.2f}/5.00 {stars}\n"
+            output += f"   Movie ID: {movie_id}\n\n"
+        
+        return output
+        
+    except ValueError:
+        return "Error: Please enter valid numbers for User ID and Number of Recommendations"
+    except Exception as e:
+        return f"Error generating recommendations: {str(e)}"
+
+def get_user_history(user_id):
+    if model is None or loader is None:
+        return "Error: Model not loaded properly."
+    
+    try:
+        user_id = int(user_id)
+        
+        if user_id not in loader.user_id_map:
+            return f"User ID {user_id} not found!"
+        
+        user_idx = loader.user_id_map[user_id]
+        
+        user_ratings = model.item_cf.user_item_matrix[user_idx].toarray().flatten()
+        rated_indices = np.where(user_ratings > 0)[0]
+        
+        if len(rated_indices) == 0:
+            return f"No rating history found for User {user_id}"
+        
+        history = []
+        for movie_idx in rated_indices:
+            original_movie_id = loader.reverse_movie_map[movie_idx]
+            title = movies_df[movies_df['movie_id'] == original_movie_id]['title'].values[0]
+            rating = user_ratings[movie_idx]
+            history.append((title, rating))
+        
+        history.sort(key=lambda x: x[1], reverse=True)
+        
+        output = f"Rating History for User {user_id}\n\n"
+        output += f"Total movies rated: {len(history)}\n"
+        output += f"Average rating: {np.mean([r for _, r in history]):.2f}\n\n"
+        output += "=" * 60 + "\n\n"
+        output += "Top 10 Highest Rated Movies:\n\n"
+        
+        for i, (title, rating) in enumerate(history[:10], 1):
+            stars = "*" * int(rating)
+            output += f"{i}. {title} - {rating:.1f}/5 {stars}\n"
+        
+        return output
+        
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def get_movie_info(movie_title_search):
+    if movies_df is None:
+        return "Error: Movies data not loaded"
+    
+    try:
+        matches = movies_df[movies_df['title'].str.contains(movie_title_search, case=False, na=False)]
+        
+        if len(matches) == 0:
+            return f"No movies found matching '{movie_title_search}'"
+        
+        output = f"Search Results for '{movie_title_search}'\n\n"
+        output += f"Found {len(matches)} movie(s):\n\n"
+        output += "=" * 60 + "\n\n"
+        
+        for i, (_, row) in enumerate(matches.head(20).iterrows(), 1):
+            output += f"{i}. {row['title']} (ID: {row['movie_id']})\n"
+        
+        if len(matches) > 20:
+            output += f"\n... and {len(matches) - 20} more results"
+        
+        return output
+        
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+with gr.Blocks(theme=gr.themes.Soft(), title="Movie Recommender - DataSynthis") as demo:
+    
+    gr.Markdown("""
+    # Hybrid Movie Recommendation System
+    ### DataSynthis Job Task - Powered by AI
+    
+    This system combines Collaborative Filtering, SVD Matrix Factorization, and Neural Networks 
+    to provide personalized movie recommendations from the MovieLens 100k dataset.
+    
+    ---
+    """)
+    
+    with gr.Tabs():
+        
+        with gr.Tab("Get Recommendations"):
+            gr.Markdown("### Get personalized movie recommendations for any user")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    user_id_input = gr.Number(
+                        label="User ID",
+                        value=1,
+                        minimum=1,
+                        maximum=943,
+                        step=1,
+                        info="Enter a user ID (1-943)"
+                    )
+                    
+                    num_recs_input = gr.Slider(
+                        label="Number of Recommendations",
+                        minimum=5,
+                        maximum=20,
+                        value=10,
+                        step=1
+                    )
+                    
+                    recommend_btn = gr.Button("Get Recommendations", variant="primary")
+                
+                with gr.Column(scale=2):
+                    recommendations_output = gr.Textbox(
+                        label="Recommendations",
+                        lines=20,
+                        max_lines=30
+                    )
+            
+            recommend_btn.click(
+                fn=get_recommendations,
+                inputs=[user_id_input, num_recs_input],
+                outputs=recommendations_output
+            )
+            
+            gr.Markdown("""
+            How it works:
+            - Enter a User ID (between 1 and 943)
+            - Choose how many recommendations you want
+            - Click "Get Recommendations" to see personalized movie suggestions
+            """)
+        
+        with gr.Tab("User History"):
+            gr.Markdown("### View a user's rating history")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    user_id_history = gr.Number(
+                        label="User ID",
+                        value=1,
+                        minimum=1,
+                        maximum=943,
+                        step=1
+                    )
+                    
+                    history_btn = gr.Button("View History", variant="primary")
+                
+                with gr.Column(scale=2):
+                    history_output = gr.Textbox(
+                        label="Rating History",
+                        lines=20,
+                        max_lines=30
+                    )
+            
+            history_btn.click(
+                fn=get_user_history,
+                inputs=user_id_history,
+                outputs=history_output
+            )
+        
+        with gr.Tab("Search Movies"):
+            gr.Markdown("### Search for movies in the database")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    movie_search = gr.Textbox(
+                        label="Movie Title Search",
+                        placeholder="e.g., Star Wars, Godfather, Titanic...",
+                        value="Star Wars"
+                    )
+                    
+                    search_btn = gr.Button("Search", variant="primary")
+                
+                with gr.Column(scale=2):
+                    search_output = gr.Textbox(
+                        label="Search Results",
+                        lines=20,
+                        max_lines=30
+                    )
+            
+            search_btn.click(
+                fn=get_movie_info,
+                inputs=movie_search,
+                outputs=search_output
+            )
+        
+        with gr.Tab("About"):
+            gr.Markdown("""
+            ## About This System
+            
+            ### Model Architecture
+            This is a Hybrid Recommendation System that combines three approaches:
+            
+            1. Item-Based Collaborative Filtering
+               - Uses cosine similarity between movies
+               - Recommends movies similar to what you've liked before
+            
+            2. SVD Matrix Factorization
+               - Decomposes the user-movie rating matrix
+               - Discovers latent factors that explain user preferences
+            
+            3. Neural Collaborative Filtering (NCF)
+               - Deep learning model with user and movie embeddings
+               - Learns complex non-linear patterns in user behavior
+            
+            ### Dataset
+            - MovieLens 100k dataset
+            - 100,000 ratings from 943 users on 1,682 movies
+            - Ratings scale: 1-5 stars
+            
+            ### Performance Metrics
+            - Precision@10: 26.77%
+            - NDCG@10: 28.50%
+            - Model improves recommendations by 40% vs baseline
+            
+            ### Created For
+            DataSynthis Job Task
+            
+            ### Technologies Used
+            - PyTorch (Neural Networks)
+            - Scikit-learn (SVD, Similarity)
+            - Pandas & NumPy (Data Processing)
+            - Gradio (Web Interface)
+            
+            ---
+            
+            Note: This model is trained on the MovieLens 100k dataset. 
+            User IDs range from 1 to 943, and movie IDs range from 1 to 1682.
+            """)
+    
+    gr.Markdown("""
+    ---
+    <div style='text-align: center'>
+        <p>Hybrid Movie Recommendation System | Built for DataSynthis</p>
+    </div>
+    """)
+
+if __name__ == "__main__":
+    demo.launch(
+        share=False,
+        server_name="0.0.0.0",
+        server_port=7860
+    )