Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import pandas as pd | |
| import numpy as np | |
| import pickle | |
| import os | |
| from comprehensive_recommendation_system import ComprehensiveRecommendationSystem | |
| import warnings | |
| warnings.filterwarnings('ignore') | |
| rec_system = None | |
| def load_recommendation_system(): | |
| """Load the trained recommendation system""" | |
| global rec_system | |
| if rec_system is None: | |
| print("Loading comprehensive recommendation system...") | |
| rec_system = ComprehensiveRecommendationSystem() | |
| rec_system.load_data("u.data", "u.item") | |
| if os.path.exists("comprehensive_recommendation_model.pkl"): | |
| print("Loading pre-trained model...") | |
| rec_system.load_model("comprehensive_recommendation_model.pkl") | |
| else: | |
| print("Training models...") | |
| rec_system.train_all_models() | |
| rec_system.save_model("comprehensive_recommendation_model.pkl") | |
| print("Recommendation system loaded successfully!") | |
| return rec_system | |
| def get_available_users(): | |
| """Get list of available users""" | |
| if rec_system is None: | |
| return [] | |
| return sorted(rec_system.ratings['user_id'].unique().tolist()) | |
| def get_user_stats(): | |
| """Get user statistics""" | |
| if rec_system is None: | |
| return "System not loaded" | |
| total_users = rec_system.ratings['user_id'].nunique() | |
| total_movies = rec_system.movies['movie_id'].nunique() | |
| total_ratings = len(rec_system.ratings) | |
| avg_rating = rec_system.ratings['rating'].mean() | |
| return f""" | |
| **Dataset Statistics:** | |
| - **Users:** {total_users:,} | |
| - **Movies:** {total_movies:,} | |
| - **Ratings:** {total_ratings:,} | |
| - **Average Rating:** {avg_rating:.2f}/5.0 | |
| - **Sparsity:** 93.70% | |
| """ | |
| def get_user_info(user_id): | |
| """Get detailed information about a user""" | |
| if rec_system is None: | |
| return "System not loaded" | |
| if user_id is None: | |
| return "Please select a user" | |
| user_ratings = rec_system.ratings[rec_system.ratings['user_id'] == user_id] | |
| if len(user_ratings) == 0: | |
| return f"User {user_id} not found in dataset" | |
| # Get user's rating statistics | |
| avg_rating = user_ratings['rating'].mean() | |
| num_ratings = len(user_ratings) | |
| rating_range = f"{user_ratings['rating'].min()} - {user_ratings['rating'].max()}" | |
| # Get rating distribution | |
| rating_dist = user_ratings['rating'].value_counts().sort_index() | |
| # Get user's top-rated movies | |
| top_movies = user_ratings.merge( | |
| rec_system.movies[['movie_id', 'title']], | |
| on='movie_id' | |
| ).sort_values('rating', ascending=False).head(10) | |
| info = f""" | |
| ## 👤 User {user_id} Profile | |
| ### 📊 Rating Statistics | |
| - **Total Ratings:** {num_ratings:,} | |
| - **Average Rating:** {avg_rating:.2f}/5.0 | |
| - **Rating Range:** {rating_range} | |
| ### 📈 Rating Distribution | |
| """ | |
| for rating, count in rating_dist.items(): | |
| percentage = (count / num_ratings) * 100 | |
| info += f"- **{rating} stars:** {count} ratings ({percentage:.1f}%)\n" | |
| info += f""" | |
| ### 🎬 Top 10 Rated Movies | |
| """ | |
| for i, (_, movie) in enumerate(top_movies.iterrows(), 1): | |
| stars = "⭐" * int(movie['rating']) | |
| info += f"{i:2d}. {movie['title']} {stars} ({movie['rating']})\n" | |
| return info | |
| def recommend_movies(user_id, num_recommendations, method): | |
| """Generate movie recommendations""" | |
| if rec_system is None: | |
| return "Error: Recommendation system not loaded" | |
| if user_id is None: | |
| return "Please select a user" | |
| try: | |
| recommendations = rec_system.recommend_movies( | |
| user_id=int(user_id), | |
| N=int(num_recommendations), | |
| method=method | |
| ) | |
| if len(recommendations) == 0: | |
| return "No recommendations available for this user" | |
| method_names = { | |
| "user_based": "👥 User-based Collaborative Filtering", | |
| "item_based": "🎬 Item-based Collaborative Filtering", | |
| "svd": "📊 SVD Matrix Factorization", | |
| "neural": "🧠 Neural Embeddings", | |
| "ensemble": "🎯 Ensemble Method" | |
| } | |
| result = f"## 🎬 Top {len(recommendations)} Movie Recommendations\n\n" | |
| result += f"**Method:** {method_names.get(method, method.upper())}\n" | |
| result += f"**User:** {user_id}\n\n" | |
| for i, (_, rec) in enumerate(recommendations.iterrows(), 1): | |
| rating_emoji = "⭐" * int(round(rec['predicted_rating'])) | |
| result += f"**{i:2d}.** {rec['title']}\n" | |
| result += f" {rating_emoji} Predicted Rating: {rec['predicted_rating']:.3f}\n\n" | |
| return result | |
| except Exception as e: | |
| return f"❌ Error generating recommendations: {str(e)}" | |
| def compare_all_methods(user_id, num_recommendations): | |
| """Compare all recommendation methods""" | |
| if rec_system is None: | |
| return "Error: Recommendation system not loaded" | |
| if user_id is None: | |
| return "Please select a user" | |
| methods = ["user_based", "item_based", "svd", "neural", "ensemble"] | |
| results = {} | |
| try: | |
| for method in methods: | |
| recommendations = rec_system.recommend_movies( | |
| user_id=int(user_id), | |
| N=int(num_recommendations), | |
| method=method | |
| ) | |
| results[method] = recommendations | |
| result = f"## ⚖️ Method Comparison for User {user_id}\n\n" | |
| result += f"**Number of recommendations:** {num_recommendations}\n\n" | |
| method_names = { | |
| "user_based": "👥 User-based CF", | |
| "item_based": "🎬 Item-based CF", | |
| "svd": "📊 SVD", | |
| "neural": "🧠 Neural", | |
| "ensemble": "🎯 Ensemble" | |
| } | |
| for method, recs in results.items(): | |
| result += f"### {method_names[method]}\n" | |
| if len(recs) == 0: | |
| result += "No recommendations available\n\n" | |
| else: | |
| for i, (_, rec) in enumerate(recs.iterrows(), 1): | |
| rating_emoji = "⭐" * int(round(rec['predicted_rating'])) | |
| result += f"{i:2d}. {rec['title']} {rating_emoji} ({rec['predicted_rating']:.3f})\n" | |
| result += "\n" | |
| return result | |
| except Exception as e: | |
| return f"❌ Error comparing methods: {str(e)}" | |
| def evaluate_system_performance(): | |
| """Evaluate the recommendation system performance""" | |
| if rec_system is None: | |
| return "Error: Recommendation system not loaded" | |
| try: | |
| all_users = rec_system.ratings['user_id'].unique() | |
| test_users = np.random.choice(all_users, min(15, len(all_users)), replace=False) | |
| methods = ["user_based", "item_based", "svd", "neural", "ensemble"] | |
| results = {} | |
| for method in methods: | |
| eval_results = rec_system.evaluate_model(test_users, method=method, N=10) | |
| results[method] = eval_results | |
| result = "## 📊 System Performance Evaluation\n\n" | |
| result += f"**Evaluated on:** {len(test_users)} users\n" | |
| result += f"**Recommendations per user:** 10\n\n" | |
| result += "| Method | Precision@10 | Recall@10 | NDCG@10 |\n" | |
| result += "|--------|--------------|-----------|----------|\n" | |
| for method, eval_results in results.items(): | |
| method_emoji = {"user_based": "👥", "item_based": "🎬", "svd": "📊", "neural": "🧠", "ensemble": "🎯"} | |
| emoji = method_emoji.get(method, "📈") | |
| result += f"| {emoji} {method:12} | {eval_results['precision']:.4f} | {eval_results['recall']:.4f} | {eval_results['ndcg']:.4f} |\n" | |
| best_method = max(results.keys(), key=lambda x: results[x]['ndcg']) | |
| best_emoji = {"user_based": "👥", "item_based": "🎬", "svd": "📊", "neural": "🧠", "ensemble": "🎯"}.get(best_method, "📈") | |
| result += f"\n### 🏆 Best Performing Method\n" | |
| result += f"**{best_emoji} {best_method.upper()}** with NDCG@10: {results[best_method]['ndcg']:.4f}\n\n" | |
| result += "### 📈 Metric Explanations\n" | |
| result += "- **Precision@10:** Fraction of recommended items that are relevant\n" | |
| result += "- **Recall@10:** Fraction of relevant items that are recommended\n" | |
| result += "- **NDCG@10:** Normalized Discounted Cumulative Gain (ranking quality)\n" | |
| return result | |
| except Exception as e: | |
| return f"❌ Error evaluating system: {str(e)}" | |
| def get_method_explanations(): | |
| """Get detailed explanations of each recommendation method""" | |
| return """ | |
| ## 🔬 Recommendation Methods Explained | |
| ### 👥 User-based Collaborative Filtering | |
| **How it works:** Finds users with similar rating patterns and recommends movies they liked. | |
| **Strengths:** | |
| - Intuitive approach that mimics human behavior | |
| - Good for finding diverse recommendations | |
| - Effective when user base is large | |
| **Best for:** Users who want to discover new genres and diverse content | |
| --- | |
| ### 🎬 Item-based Collaborative Filtering | |
| **How it works:** Finds movies with similar rating patterns and recommends items similar to those a user has liked. | |
| **Strengths:** | |
| - More stable than user-based approach | |
| - Computationally efficient | |
| - Good for popular items | |
| **Best for:** Users who want recommendations similar to movies they already like | |
| --- | |
| ### 📊 SVD Matrix Factorization | |
| **How it works:** Decomposes the user-item matrix into latent factors representing user preferences and item characteristics. | |
| **Strengths:** | |
| - Handles sparsity well | |
| - Captures implicit relationships | |
| - Computationally efficient | |
| **Best for:** Balanced performance with good generalization | |
| --- | |
| ### 🧠 Neural Embeddings | |
| **How it works:** Uses deep learning to learn complex non-linear relationships between users and items. | |
| **Strengths:** | |
| - Can capture complex patterns | |
| - Flexible architecture | |
| - Good for non-linear relationships | |
| **Best for:** Advanced pattern recognition and complex user behaviors | |
| --- | |
| ### 🎯 Ensemble Method | |
| **How it works:** Combines predictions from all four approaches by averaging their recommendation scores. | |
| **Strengths:** | |
| - Reduces individual method biases | |
| - More robust predictions | |
| - Better coverage of different patterns | |
| **Best for:** Optimal overall performance and reliability | |
| """ | |
| def create_interface(): | |
| """Create the enhanced Gradio interface""" | |
| load_recommendation_system() | |
| with gr.Blocks( | |
| title="🎬 Comprehensive Movie Recommendation System", | |
| theme=gr.themes.Soft( | |
| primary_hue="blue", | |
| secondary_hue="purple", | |
| neutral_hue="slate" | |
| ), | |
| css=""" | |
| .main-header { | |
| text-align: center; | |
| background: linear-gradient(90deg, #667eea 0%, #764ba2 100%); | |
| -webkit-background-clip: text; | |
| -webkit-text-fill-color: transparent; | |
| font-size: 2.5em; | |
| font-weight: bold; | |
| margin-bottom: 20px; | |
| } | |
| .method-card { | |
| border: 2px solid #333333; | |
| border-radius: 12px; | |
| padding: 20px; | |
| margin: 15px 0; | |
| background: linear-gradient(135deg, #1a1a1a 0%, #2d2d2d 100%); | |
| box-shadow: 0 4px 6px rgba(0, 0, 0, 0.3); | |
| color: white; | |
| } | |
| .stats-card { | |
| background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); | |
| color: white; | |
| padding: 20px; | |
| border-radius: 12px; | |
| margin: 10px 0; | |
| } | |
| .footer-text { | |
| color: white !important; | |
| } | |
| .footer-text h2, .footer-text h3 { | |
| color: white !important; | |
| } | |
| .footer-text p, .footer-text li { | |
| color: #e0e0e0 !important; | |
| } | |
| """ | |
| ) as app: | |
| gr.Markdown( | |
| """ | |
| # 🎬 Comprehensive Movie Recommendation System | |
| **Advanced ML Approaches for Personalized Recommendations** | |
| This system implements multiple state-of-the-art recommendation approaches including collaborative filtering, | |
| matrix factorization, and neural embeddings using the MovieLens 100K dataset. | |
| """, | |
| elem_classes="main-header" | |
| ) | |
| # Stats overview | |
| with gr.Row(): | |
| with gr.Column(): | |
| stats_display = gr.Markdown( | |
| get_user_stats(), | |
| elem_classes="stats-card" | |
| ) | |
| # Main tabs | |
| with gr.Tabs(): | |
| # Recommendation Tab | |
| with gr.Tab("🎯 Get Recommendations", id="recommendations"): | |
| gr.Markdown("### Generate personalized movie recommendations using different ML approaches") | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| user_dropdown = gr.Dropdown( | |
| choices=get_available_users(), | |
| label="👤 Select User ID", | |
| value=get_available_users()[0] if get_available_users() else None, | |
| info="Choose from 943 available users" | |
| ) | |
| num_recommendations = gr.Slider( | |
| minimum=5, | |
| maximum=20, | |
| value=10, | |
| step=1, | |
| label="📊 Number of Recommendations", | |
| info="How many movies to recommend" | |
| ) | |
| method_dropdown = gr.Dropdown( | |
| choices=[ | |
| ("🎯 Ensemble Method (Recommended)", "ensemble"), | |
| ("👥 User-based Collaborative Filtering", "user_based"), | |
| ("🎬 Item-based Collaborative Filtering", "item_based"), | |
| ("📊 SVD Matrix Factorization", "svd"), | |
| ("🧠 Neural Embeddings", "neural") | |
| ], | |
| value="ensemble", | |
| label="🔬 Recommendation Method", | |
| info="Choose the ML approach for recommendations" | |
| ) | |
| recommend_btn = gr.Button("🚀 Get Recommendations", variant="primary", size="lg") | |
| with gr.Column(scale=2): | |
| recommendations_output = gr.Markdown( | |
| "👆 Select a user and method to get personalized movie recommendations...", | |
| label="🎬 Recommendations" | |
| ) | |
| recommend_btn.click( | |
| fn=recommend_movies, | |
| inputs=[user_dropdown, num_recommendations, method_dropdown], | |
| outputs=recommendations_output | |
| ) | |
| # User Analysis Tab | |
| with gr.Tab("👤 User Analysis", id="analysis"): | |
| gr.Markdown("### Analyze user preferences, rating patterns, and movie tastes") | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| user_analysis_dropdown = gr.Dropdown( | |
| choices=get_available_users(), | |
| label="👤 Select User ID", | |
| value=get_available_users()[0] if get_available_users() else None, | |
| info="Choose a user to analyze" | |
| ) | |
| analyze_user_btn = gr.Button("🔍 Analyze User", variant="primary", size="lg") | |
| with gr.Column(scale=2): | |
| user_info_output = gr.Markdown( | |
| "👆 Select a user to analyze their preferences and rating patterns...", | |
| label="📊 User Profile" | |
| ) | |
| analyze_user_btn.click( | |
| fn=get_user_info, | |
| inputs=[user_analysis_dropdown], | |
| outputs=user_info_output | |
| ) | |
| # Method Comparison Tab | |
| with gr.Tab("⚖️ Compare Methods", id="comparison"): | |
| gr.Markdown("### Compare all recommendation methods side-by-side for a user") | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| compare_user_dropdown = gr.Dropdown( | |
| choices=get_available_users(), | |
| label="👤 Select User ID", | |
| value=get_available_users()[0] if get_available_users() else None, | |
| info="Choose a user to compare methods for" | |
| ) | |
| compare_num_recs = gr.Slider( | |
| minimum=5, | |
| maximum=15, | |
| value=10, | |
| step=1, | |
| label="📊 Number of Recommendations", | |
| info="How many recommendations per method" | |
| ) | |
| compare_btn = gr.Button("⚖️ Compare All Methods", variant="primary", size="lg") | |
| with gr.Column(scale=2): | |
| comparison_output = gr.Markdown( | |
| "👆 Select a user to compare all recommendation methods...", | |
| label="📈 Method Comparison" | |
| ) | |
| compare_btn.click( | |
| fn=compare_all_methods, | |
| inputs=[compare_user_dropdown, compare_num_recs], | |
| outputs=comparison_output | |
| ) | |
| with gr.Tab("📊 System Evaluation", id="evaluation"): | |
| gr.Markdown("### Evaluate system performance with comprehensive metrics") | |
| with gr.Row(): | |
| with gr.Column(scale=1): | |
| evaluate_btn = gr.Button("📊 Evaluate System Performance", variant="primary", size="lg") | |
| with gr.Column(scale=2): | |
| evaluation_output = gr.Markdown( | |
| "👆 Click 'Evaluate System Performance' to see detailed metrics...", | |
| label="📈 Performance Results" | |
| ) | |
| evaluate_btn.click( | |
| fn=evaluate_system_performance, | |
| inputs=[], | |
| outputs=evaluation_output | |
| ) | |
| # Method Explanations Tab | |
| with gr.Tab("🔬 Method Explanations", id="explanations"): | |
| gr.Markdown("### Learn about each recommendation method and when to use them") | |
| explanations_output = gr.Markdown( | |
| get_method_explanations(), | |
| label="📚 Method Details" | |
| ) | |
| gr.Markdown( | |
| """ | |
| --- | |
| ## 🚀 About This System | |
| This comprehensive recommendation system demonstrates multiple state-of-the-art approaches: | |
| - **👥 Collaborative Filtering**: Both user-based and item-based methods | |
| - **📊 Matrix Factorization**: SVD for dimensionality reduction | |
| - **🧠 Neural Networks**: Deep learning embeddings for complex patterns | |
| - **🎯 Ensemble Methods**: Combining multiple approaches for optimal performance | |
| ### 📈 Evaluation Metrics | |
| - **Precision@K**: Fraction of recommended items that are relevant | |
| - **Recall@K**: Fraction of relevant items that are recommended | |
| - **NDCG@K**: Normalized Discounted Cumulative Gain for ranking quality | |
| ### 🎓 Educational Value | |
| Perfect for learning about recommendation systems, machine learning approaches, | |
| and interactive web application development. | |
| """, | |
| elem_classes="method-card footer-text" | |
| ) | |
| return app | |
| if __name__ == "__main__": | |
| app = create_interface() | |
| app.launch( | |
| server_name="0.0.0.0", | |
| server_port=7860, | |
| share=True, | |
| show_error=True | |
| ) | |