Update app.py

app.py

@@ -1,9 +1,75 @@
+"""
+Gradio App for Hybrid Movie Recommendation System
+Deploy to Hugging Face Spaces as 'DataSynthis_Job_task'
+
+File: app.py
+"""
+
 import gradio as gr
 import pickle
 import pandas as pd
 import numpy as np
 import torch
+import torch.nn as nn
 import os
+from scipy.sparse import csr_matrix
+
+#==============================================================================
+# MODEL CLASS DEFINITIONS (Required for unpickling)
+#==============================================================================
+
+class ItemBasedCF:
+    """Item-Based Collaborative Filtering"""
+    pass
+
+class SVDRecommender:
+    """SVD Recommender"""
+    pass
+
+class NeuralCF(nn.Module):
+    """Neural Collaborative Filtering Model"""
+    
+    def __init__(self, n_users, n_movies, embedding_dim=50, hidden_layers=[64, 32, 16]):
+        super(NeuralCF, self).__init__()
+        self.user_embedding = nn.Embedding(n_users, embedding_dim)
+        self.movie_embedding = nn.Embedding(n_movies, embedding_dim)
+        
+        layers = []
+        input_dim = embedding_dim * 2
+        for hidden_dim in hidden_layers:
+            layers.append(nn.Linear(input_dim, hidden_dim))
+            layers.append(nn.ReLU())
+            layers.append(nn.Dropout(0.2))
+            input_dim = hidden_dim
+        layers.append(nn.Linear(input_dim, 1))
+        self.mlp = nn.Sequential(*layers)
+        
+    def forward(self, user_ids, movie_ids):
+        user_emb = self.user_embedding(user_ids)
+        movie_emb = self.movie_embedding(movie_ids)
+        x = torch.cat([user_emb, movie_emb], dim=1)
+        output = self.mlp(x)
+        return output.squeeze()
+    
+    def predict(self, user_idx, movie_idx, device='cpu'):
+        self.eval()
+        with torch.no_grad():
+            user_tensor = torch.LongTensor([user_idx]).to(device)
+            movie_tensor = torch.LongTensor([movie_idx]).to(device)
+            prediction = self.forward(user_tensor, movie_tensor)
+            return torch.clamp(prediction, 1, 5).item()
+
+class HybridRecommender:
+    """Hybrid Recommendation System"""
+    pass
+
+class MovieLensDataLoader:
+    """Data Loader"""
+    pass
+
+#==============================================================================
+# LOAD MODEL AND DATA
+#==============================================================================
 
 def load_model_and_data():
     """Load the trained model and necessary data"""
@@ -62,22 +128,500 @@ def load_model_and_data():
         traceback.print_exc()
         return None, None, None, []
 
+# Load everything at startup
+print("Loading model and data...")
+model, loader, movies_df, user_ids = load_model_and_data()
+print(f"Model loaded! Available users: {len(user_ids)}")
+
+#==============================================================================
+# RECOMMENDATION FUNCTION
+#==============================================================================
+
+def get_recommendations(user_id, num_recommendations):
+    """
+    Get movie recommendations for a user
+    
+    Args:
+        user_id: User ID (int)
+        num_recommendations: Number of recommendations to return
+        
+    Returns:
+        Formatted string with recommendations
+    """
+    if model is None or loader is None:
+        return "❌ Error: Model not loaded properly. Please check the model files."
+    
+    try:
+        user_id = int(user_id)
+        num_recommendations = int(num_recommendations)
+        
+        # Check if user exists
+        if user_id not in loader.user_id_map:
+            return f"❌ User ID {user_id} not found! Please select a valid user ID."
+        
+        # Get recommendations
+        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}"
+        
+        # Format output
+        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):
+    """
+    Show user's rating history
+    
+    Args:
+        user_id: User ID
+        
+    Returns:
+        Formatted string with user's past ratings
+    """
+    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]
+        
+        # Get user's ratings from the training data
+        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}"
+        
+        # Get movie details
+        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))
+        
+        # Sort by rating (highest first)
+        history.sort(key=lambda x: x[1], reverse=True)
+        
+        # Format output
+        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):
+    """
+    Search for movies by title
+    
+    Args:
+        movie_title_search: Search query
+        
+    Returns:
+        Formatted string with matching movies
+    """
+    if movies_df is None:
+        return "❌ Error: Movies data not loaded"
+    
+    try:
+        # Search for movies
+        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)}"
+
+
+#==============================================================================
+# GRADIO INTERFACE
+#==============================================================================
+
+# Create Gradio interface with tabs
+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():
+        
+        # TAB 1: Get Recommendations
+        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=f"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
+            """)
+        
+        # TAB 2: User History
+        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
+            )
+        
+        # TAB 3: Search Movies
+        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
+            )
+        
+        # TAB 4: About
+        with gr.Tab("ℹ️ About"):
+            gr.Markdown("""
+            ## About This System
+            
+            ### 🎯 Model Architecture
+            This is a **Hybrid Recommendation System** that combines three powerful 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.
+            """)
+    
+    # Footer
+    gr.Markdown("""
+    ---
+    <div style='text-align: center'>
+        <p>🎬 <strong>Hybrid Movie Recommendation System</strong> | Built with ❤️ for DataSynthis</p>
+    </div>
+    """)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(
+        share=False,
+        server_name="0.0.0.0",
+        server_port=7860
+    )"""
+Gradio App for Hybrid Movie Recommendation System
+Deploy to Hugging Face Spaces as 'DataSynthis_Job_task'
+
+File: app.py
+"""
+
+import gradio as gr
+import pickle
+import pandas as pd
+import numpy as np
+import torch
+import torch.nn as nn
+import os
+from scipy.sparse import csr_matrix
+
+#==============================================================================
+# MODEL CLASS DEFINITIONS (Required for unpickling)
+#==============================================================================
+
+class ItemBasedCF:
+    """Item-Based Collaborative Filtering"""
+    pass
+
+class SVDRecommender:
+    """SVD Recommender"""
+    pass
+
+class NeuralCF(nn.Module):
+    """Neural Collaborative Filtering Model"""
+    
+    def __init__(self, n_users, n_movies, embedding_dim=50, hidden_layers=[64, 32, 16]):
+        super(NeuralCF, self).__init__()
+        self.user_embedding = nn.Embedding(n_users, embedding_dim)
+        self.movie_embedding = nn.Embedding(n_movies, embedding_dim)
+        
+        layers = []
+        input_dim = embedding_dim * 2
+        for hidden_dim in hidden_layers:
+            layers.append(nn.Linear(input_dim, hidden_dim))
+            layers.append(nn.ReLU())
+            layers.append(nn.Dropout(0.2))
+            input_dim = hidden_dim
+        layers.append(nn.Linear(input_dim, 1))
+        self.mlp = nn.Sequential(*layers)
+        
+    def forward(self, user_ids, movie_ids):
+        user_emb = self.user_embedding(user_ids)
+        movie_emb = self.movie_embedding(movie_ids)
+        x = torch.cat([user_emb, movie_emb], dim=1)
+        output = self.mlp(x)
+        return output.squeeze()
+    
+    def predict(self, user_idx, movie_idx, device='cpu'):
+        self.eval()
+        with torch.no_grad():
+            user_tensor = torch.LongTensor([user_idx]).to(device)
+            movie_tensor = torch.LongTensor([movie_idx]).to(device)
+            prediction = self.forward(user_tensor, movie_tensor)
+            return torch.clamp(prediction, 1, 5).item()
+
+class HybridRecommender:
+    """Hybrid Recommendation System"""
+    pass
+
+class MovieLensDataLoader:
+    """Data Loader"""
+    pass
+
+#==============================================================================
+# LOAD MODEL AND DATA
+#==============================================================================
+
+def load_model_and_data():
+    """Load the trained model and necessary data"""
+    import os
+    
+    # Debug: Check what files exist
+    print("Checking for files...")
+    print(f"Current directory: {os.getcwd()}")
+    print(f"Files in current directory: {os.listdir('.')}")
+    
+    if os.path.exists('model_artifacts'):
+        print(f"Files in model_artifacts/: {os.listdir('model_artifacts')}")
+    else:
+        print("ERROR: model_artifacts/ folder does not exist!")
+    
+    try:
+        # Check each file individually
+        files_to_check = [
+            'model_artifacts/hybrid_model.pkl',
+            'model_artifacts/loader.pkl',
+            'model_artifacts/movies.pkl'
+        ]
+        
+        for file_path in files_to_check:
+            if not os.path.exists(file_path):
+                print(f"ERROR: Missing file: {file_path}")
+            else:
+                file_size = os.path.getsize(file_path) / (1024*1024)  # MB
+                print(f"Found: {file_path} ({file_size:.2f} MB)")
+        
+        # Load files
+        with open('model_artifacts/hybrid_model.pkl', 'rb') as f:
+            model = pickle.load(f)
+        print("✓ Loaded hybrid_model.pkl")
+        
+        with open('model_artifacts/loader.pkl', 'rb') as f:
+            loader = pickle.load(f)
+        print("✓ Loaded loader.pkl")
+        
+        with open('model_artifacts/movies.pkl', 'rb') as f:
+            movies = pickle.load(f)
+        print("✓ Loaded movies.pkl")
+        
+        # Get list of users
+        user_ids = sorted(loader.user_id_map.keys())
+        print(f"✓ Model loaded successfully! {len(user_ids)} users available")
+        
+        return model, loader, movies, user_ids
+    except FileNotFoundError as e:
+        print(f"ERROR: File not found - {e}")
+        print("Make sure all pkl files are in the model_artifacts/ folder")
+        return None, None, None, []
+    except Exception as e:
+        print(f"ERROR loading model: {type(e).__name__}: {e}")
+        import traceback
+        traceback.print_exc()
+        return None, None, None, []
+
+# Load everything at startup
 print("Loading model and data...")
 model, loader, movies_df, user_ids = load_model_and_data()
 print(f"Model loaded! Available users: {len(user_ids)}")
 
+#==============================================================================
+# RECOMMENDATION FUNCTION
+#==============================================================================
+
 def get_recommendations(user_id, num_recommendations):
+    """
+    Get movie recommendations for a user
+    
+    Args:
+        user_id: User ID (int)
+        num_recommendations: Number of recommendations to return
+        
+    Returns:
+        Formatted string with recommendations
+    """
     if model is None or loader is None:
-        return "Error: Model not loaded properly."
+        return "❌ Error: Model not loaded properly. Please check the model files."
     
     try:
         user_id = int(user_id)
         num_recommendations = int(num_recommendations)
         
+        # Check if user exists
         if user_id not in loader.user_id_map:
-            return f"User ID {user_id} not found! Please select a valid user ID."
+            return f"❌ User ID {user_id} not found! Please select a valid user ID."
         
+        # Get recommendations
         recommendations = model.recommend_movies(
             user_id=user_id,
             N=num_recommendations,
@@ -87,42 +631,55 @@ def get_recommendations(user_id, num_recommendations):
         )
         
         if not recommendations:
-            return f"No recommendations found for User {user_id}"
+            return f"❌ No recommendations found for User {user_id}"
         
-        output = f"Top {num_recommendations} Movie Recommendations for User {user_id}\n\n"
+        # Format output
+        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"
+            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"
+        return "❌ Error: Please enter valid numbers for User ID and Number of Recommendations"
     except Exception as e:
-        return f"Error generating recommendations: {str(e)}"
+        return f"❌ Error generating recommendations: {str(e)}"
+
 
 def get_user_history(user_id):
+    """
+    Show user's rating history
+    
+    Args:
+        user_id: User ID
+        
+    Returns:
+        Formatted string with user's past ratings
+    """
     if model is None or loader is None:
-        return "Error: Model not loaded properly."
+        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!"
+            return f"❌ User ID {user_id} not found!"
         
         user_idx = loader.user_id_map[user_id]
         
+        # Get user's ratings from the training data
         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}"
         
+        # Get movie details
         history = []
         for movie_idx in rated_indices:
             original_movie_id = loader.reverse_movie_map[movie_idx]
@@ -130,39 +687,52 @@ def get_user_history(user_id):
             rating = user_ratings[movie_idx]
             history.append((title, rating))
         
+        # Sort by rating (highest first)
         history.sort(key=lambda x: x[1], reverse=True)
         
-        output = f"Rating History for User {user_id}\n\n"
+        # Format output
+        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"
+        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"
+            stars = "⭐" * int(rating)
+            output += f"{i}. **{title}** - {rating:.1f}/5 {stars}\n"
         
         return output
         
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"❌ Error: {str(e)}"
+
 
 def get_movie_info(movie_title_search):
+    """
+    Search for movies by title
+    
+    Args:
+        movie_title_search: Search query
+        
+    Returns:
+        Formatted string with matching movies
+    """
     if movies_df is None:
-        return "Error: Movies data not loaded"
+        return "❌ Error: Movies data not loaded"
     
     try:
+        # Search for movies
         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}'"
+            return f"❌ No movies found matching '{movie_title_search}'"
         
-        output = f"Search Results for '{movie_title_search}'\n\n"
+        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"
+            output += f"{i}. **{row['title']}** (ID: {row['movie_id']})\n"
         
         if len(matches) > 20:
             output += f"\n... and {len(matches) - 20} more results"
@@ -170,15 +740,21 @@ def get_movie_info(movie_title_search):
         return output
         
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"❌ Error: {str(e)}"
+
+
+#==============================================================================
+# GRADIO INTERFACE
+#==============================================================================
 
+# Create Gradio interface with tabs
 with gr.Blocks(theme=gr.themes.Soft(), title="Movie Recommender - DataSynthis") as demo:
     
     gr.Markdown("""
-    # Hybrid Movie Recommendation System
+    # 🎬 Hybrid Movie Recommendation System
     ### DataSynthis Job Task - Powered by AI
     
-    This system combines Collaborative Filtering, SVD Matrix Factorization, and Neural Networks 
+    This system combines **Collaborative Filtering**, **SVD Matrix Factorization**, and **Neural Networks** 
     to provide personalized movie recommendations from the MovieLens 100k dataset.
     
     ---
@@ -186,7 +762,8 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Movie Recommender - DataSynthis")
     
     with gr.Tabs():
         
-        with gr.Tab("Get Recommendations"):
+        # TAB 1: Get Recommendations
+        with gr.Tab("🎯 Get Recommendations"):
             gr.Markdown("### Get personalized movie recommendations for any user")
             
             with gr.Row():
@@ -197,7 +774,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Movie Recommender - DataSynthis")
                         minimum=1,
                         maximum=943,
                         step=1,
-                        info="Enter a user ID (1-943)"
+                        info=f"Enter a user ID (1-943)"
                     )
                     
                     num_recs_input = gr.Slider(
@@ -208,7 +785,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Movie Recommender - DataSynthis")
                         step=1
                     )
                     
-                    recommend_btn = gr.Button("Get Recommendations", variant="primary")
+                    recommend_btn = gr.Button("🎬 Get Recommendations", variant="primary")
                 
                 with gr.Column(scale=2):
                     recommendations_output = gr.Textbox(
@@ -224,13 +801,14 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Movie Recommender - DataSynthis")
             )
             
             gr.Markdown("""
-            How it works:
+            **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"):
+        # TAB 2: User History
+        with gr.Tab("📊 User History"):
             gr.Markdown("### View a user's rating history")
             
             with gr.Row():
@@ -243,7 +821,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Movie Recommender - DataSynthis")
                         step=1
                     )
                     
-                    history_btn = gr.Button("View History", variant="primary")
+                    history_btn = gr.Button("📊 View History", variant="primary")
                 
                 with gr.Column(scale=2):
                     history_output = gr.Textbox(
@@ -258,7 +836,8 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Movie Recommender - DataSynthis")
                 outputs=history_output
             )
         
-        with gr.Tab("Search Movies"):
+        # TAB 3: Search Movies
+        with gr.Tab("🔍 Search Movies"):
             gr.Markdown("### Search for movies in the database")
             
             with gr.Row():
@@ -269,7 +848,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Movie Recommender - DataSynthis")
                         value="Star Wars"
                     )
                     
-                    search_btn = gr.Button("Search", variant="primary")
+                    search_btn = gr.Button("🔍 Search", variant="primary")
                 
                 with gr.Column(scale=2):
                     search_output = gr.Textbox(
@@ -284,39 +863,40 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Movie Recommender - DataSynthis")
                 outputs=search_output
             )
         
-        with gr.Tab("About"):
+        # TAB 4: About
+        with gr.Tab("ℹ️ About"):
             gr.Markdown("""
             ## About This System
             
-            ### Model Architecture
-            This is a Hybrid Recommendation System that combines three approaches:
+            ### 🎯 Model Architecture
+            This is a **Hybrid Recommendation System** that combines three powerful approaches:
             
-            1. Item-Based Collaborative Filtering
+            1. **Item-Based Collaborative Filtering**
                - Uses cosine similarity between movies
                - Recommends movies similar to what you've liked before
             
-            2. SVD Matrix Factorization
+            2. **SVD Matrix Factorization**
                - Decomposes the user-movie rating matrix
                - Discovers latent factors that explain user preferences
             
-            3. Neural Collaborative Filtering (NCF)
+            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
+            ### 📊 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
+            ### 🎯 Performance Metrics
+            - **Precision@10**: 26.77%
+            - **NDCG@10**: 28.50%
+            - **Model improves recommendations by 40% vs baseline**
             
-            ### Created For
-            DataSynthis Job Task
+            ### 👨‍💻 Created For
+            **DataSynthis Job Task**
             
-            ### Technologies Used
+            ### 🔗 Technologies Used
             - PyTorch (Neural Networks)
             - Scikit-learn (SVD, Similarity)
             - Pandas & NumPy (Data Processing)
@@ -324,17 +904,19 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Movie Recommender - DataSynthis")
             
             ---
             
-            Note: This model is trained on the MovieLens 100k dataset. 
+            **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.
             """)
     
+    # Footer
     gr.Markdown("""
     ---
     <div style='text-align: center'>
-        <p>Hybrid Movie Recommendation System | Built for DataSynthis</p>
+        <p>🎬 <strong>Hybrid Movie Recommendation System</strong> | Built with ❤️ for DataSynthis</p>
     </div>
     """)
 
+# Launch the app
 if __name__ == "__main__":
     demo.launch(
         share=False,