app.py

import gradio as gr
import pandas as pd
import numpy as np
from scipy.sparse.linalg import svds
from sklearn.metrics.pairwise import cosine_similarity
import plotly.express as px
import plotly.graph_objects as go
from collections import Counter

# Global variables for models
movies = None
ratings = None
users = None
train_user_item_matrix = None
user_similarity_df = None
svd_predicted_ratings = None
alpha = 0.6
models_loaded = False

def load_datasets():
    """Load CSV datasets with multiple encoding support"""
    global movies, ratings, users
    
    try:
        encodings = ['utf-8', 'latin-1', 'iso-8859-1', 'cp1252']
        delimiters = [',', '::', '\t', '|', ';']
        
        movies = None
        ratings = None
        users = None
        
        # Load movies
        for enc in encodings:
            for delim in delimiters:
                try:
                    movies = pd.read_csv('movies.csv', encoding=enc, sep=delim,
                                       engine='python', on_bad_lines='skip')
                    if len(movies.columns) >= 2:
                        break
                except:
                    continue
            if movies is not None and len(movies.columns) >= 2:
                break
        
        # Load ratings
        for delim in delimiters:
            try:
                ratings = pd.read_csv('ratings.csv', sep=delim, engine='python',
                                    on_bad_lines='skip')
                if len(ratings.columns) >= 3:
                    break
            except:
                continue
        
        # Load users
        for delim in delimiters:
            try:
                users = pd.read_csv('users.csv', sep=delim, engine='python',
                                  on_bad_lines='skip')
                if len(users.columns) >= 2:
                    break
            except:
                continue
        
        if movies is None or ratings is None or users is None:
            return "Failed to load datasets. Check file formats."
        
        # Normalize column names
        movies.columns = movies.columns.str.strip().str.lower()
        ratings.columns = ratings.columns.str.strip().str.lower()
        users.columns = users.columns.str.strip().str.lower()
        
        if 'genres' in movies.columns:
            movies['genres'] = movies['genres'].fillna('Unknown')
        
        return f"Loaded: {len(movies)} movies, {len(ratings)} ratings, {len(users)} users"
    
    except Exception as e:
        return f"Error: {str(e)}"

def train_models():
    """Train recommendation models"""
    global train_user_item_matrix, user_similarity_df, svd_predicted_ratings, models_loaded
    
    if movies is None or ratings is None:
        return "Please load datasets first!"
    
    try:
        # Create train split
        train_data = []
        for user_id in ratings['userid'].unique():
            user_ratings = ratings[ratings['userid'] == user_id]
            if 'timestamp' in ratings.columns:
                user_ratings = user_ratings.sort_values('timestamp')
            n_ratings = len(user_ratings)
            if n_ratings >= 5:
                split_idx = int(n_ratings * 0.8)
                train_data.append(user_ratings.iloc[:split_idx])
        
        train_ratings = pd.concat(train_data, ignore_index=True)
        
        # Create user-item matrix
        train_user_item_matrix = train_ratings.pivot_table(
            index='userid',
            columns='movieid',
            values='rating'
        ).fillna(0)
        
        # Train User-Based CF
        user_similarity = cosine_similarity(train_user_item_matrix)
        user_similarity_df = pd.DataFrame(
            user_similarity,
            index=train_user_item_matrix.index,
            columns=train_user_item_matrix.index
        )
        
        # Train SVD
        n_factors = min(100, min(train_user_item_matrix.shape) - 1)
        R = train_user_item_matrix.values
        user_ratings_mean = np.mean(R, axis=1)
        R_demeaned = R - user_ratings_mean.reshape(-1, 1)
        
        U, sigma, Vt = svds(R_demeaned, k=n_factors)
        sigma = np.diag(sigma)
        predicted_ratings = np.dot(np.dot(U, sigma), Vt) + user_ratings_mean.reshape(-1, 1)
        
        svd_predicted_ratings = pd.DataFrame(
            predicted_ratings,
            index=train_user_item_matrix.index,
            columns=train_user_item_matrix.columns
        )
        
        models_loaded = True
        return "Models trained successfully!"
    
    except Exception as e:
        return f"Error training models: {str(e)}"

def load_and_train():
    """Load datasets and train models"""
    msg1 = load_datasets()
    if "Loaded:" not in msg1:
        return msg1, None, None
    
    msg2 = train_models()
    
    # Get dataset stats
    stats_html = f"""
    <div style='background: #f0f2f6; padding: 20px; border-radius: 10px; margin: 10px 0;'>
        <h3 style='color: #FF4B4B; margin-bottom: 15px;'>Dataset Statistics</h3>
        <div style='display: grid; grid-template-columns: repeat(4, 1fr); gap: 15px;'>
            <div style='background: white; padding: 15px; border-radius: 8px; text-align: center;'>
                <div style='font-size: 24px; font-weight: bold; color: #FF4B4B;'>{len(movies):,}</div>
                <div style='color: #666; font-size: 14px;'>Movies</div>
            </div>
            <div style='background: white; padding: 15px; border-radius: 8px; text-align: center;'>
                <div style='font-size: 24px; font-weight: bold; color: #FF4B4B;'>{len(users):,}</div>
                <div style='color: #666; font-size: 14px;'>Users</div>
            </div>
            <div style='background: white; padding: 15px; border-radius: 8px; text-align: center;'>
                <div style='font-size: 24px; font-weight: bold; color: #FF4B4B;'>{len(ratings):,}</div>
                <div style='color: #666; font-size: 14px;'>Ratings</div>
            </div>
            <div style='background: white; padding: 15px; border-radius: 8px; text-align: center;'>
                <div style='font-size: 24px; font-weight: bold; color: #FF4B4B;'>{ratings['rating'].mean():.2f}</div>
                <div style='color: #666; font-size: 14px;'>Avg Rating</div>
            </div>
        </div>
    </div>
    """
    
    # Create rating distribution chart
    rating_dist = ratings['rating'].value_counts().sort_index()
    fig = px.bar(x=rating_dist.index, y=rating_dist.values,
                labels={'x': 'Rating', 'y': 'Count'},
                title='Rating Distribution',
                color=rating_dist.values,
                color_continuous_scale='Viridis')
    
    return f"{msg1}\n{msg2}", stats_html, fig

def recommend_movies(user_id, num_recommendations):
    """Generate movie recommendations"""
    if not models_loaded:
        return "Please load and train models first!", None, None
    
    try:
        user_id = int(user_id)
        num_recommendations = int(num_recommendations)
        
        if user_id not in train_user_item_matrix.index:
            return f"User {user_id} not found in training data", None, None
        
        # CF recommendations
        similar_users = user_similarity_df[user_id].sort_values(ascending=False)[1:51]
        user_ratings = train_user_item_matrix.loc[user_id]
        watched_movies = user_ratings[user_ratings > 0].index
        
        cf_recommendations = {}
        for sim_user, similarity in similar_users.items():
            sim_user_ratings = train_user_item_matrix.loc[sim_user]
            for movie_id, rating in sim_user_ratings.items():
                if rating > 0 and movie_id not in watched_movies:
                    if movie_id not in cf_recommendations:
                        cf_recommendations[movie_id] = 0
                    cf_recommendations[movie_id] += similarity * rating
        
        cf_top = sorted(cf_recommendations.items(), key=lambda x: x[1], reverse=True)[:num_recommendations*2]
        cf_movies = [movie_id for movie_id, _ in cf_top]
        
        # SVD recommendations
        user_pred_ratings = svd_predicted_ratings.loc[user_id]
        unwatched_predictions = user_pred_ratings.drop(watched_movies)
        svd_movies = unwatched_predictions.sort_values(ascending=False).head(num_recommendations*2).index.tolist()
        
        # Combine
        combined_scores = {}
        for i, movie_id in enumerate(cf_movies):
            combined_scores[movie_id] = combined_scores.get(movie_id, 0) + alpha * (len(cf_movies) - i)
        
        for i, movie_id in enumerate(svd_movies):
            combined_scores[movie_id] = combined_scores.get(movie_id, 0) + (1 - alpha) * (len(svd_movies) - i)
        
        top_movies = sorted(combined_scores.items(), key=lambda x: x[1], reverse=True)[:num_recommendations]
        movie_ids = [movie_id for movie_id, _ in top_movies]
        
        # Get movie details
        recommendations = []
        for i, movie_id in enumerate(movie_ids, 1):
            movie_info = movies[movies['movieid'] == movie_id]
            if not movie_info.empty:
                title = movie_info.iloc[0]['title']
                genres = movie_info.iloc[0].get('genres', 'Unknown')
                recommendations.append({
                    'Rank': i,
                    'Title': title,
                    'Genres': genres
                })
        
        # Create HTML output
        html_output = f"""
        <div style='background: #f8f9fa; padding: 20px; border-radius: 10px;'>
            <h2 style='color: #FF4B4B; margin-bottom: 20px;'>Top {num_recommendations} Recommendations for User {user_id}</h2>
        """
        
        for rec in recommendations:
            html_output += f"""
            <div style='background: white; padding: 15px; margin: 10px 0; border-radius: 8px; border-left: 4px solid #FF4B4B;'>
                <h3 style='color: #1f1f1f; margin: 0 0 10px 0;'>{rec['Rank']}. {rec['Title']}</h3>
                <p style='color: #666; margin: 0;'><strong>Genres:</strong> {rec['Genres']}</p>
            </div>
            """
        
        html_output += "</div>"
        
        # Create visualizations
        user_ratings_data = ratings[ratings['userid'] == user_id]
        
        # Rating distribution
        rating_dist = user_ratings_data['rating'].value_counts().sort_index()
        fig1 = px.bar(x=rating_dist.index, y=rating_dist.values,
                     labels={'x': 'Rating', 'y': 'Count'},
                     title=f'User {user_id} Rating Distribution',
                     color=rating_dist.values,
                     color_continuous_scale='Blues')
        
        # Genre preferences
        user_movies = user_ratings_data.merge(movies[['movieid', 'genres']], on='movieid')
        genres_list = []
        for genres in user_movies['genres']:
            if pd.notna(genres) and genres != 'Unknown':
                genres_list.extend(genres.split('|'))
        
        if genres_list:
            genre_counts = Counter(genres_list)
            top_genres = dict(sorted(genre_counts.items(), key=lambda x: x[1], reverse=True)[:8])
            fig2 = px.pie(values=list(top_genres.values()), names=list(top_genres.keys()),
                         title=f'User {user_id} Genre Preferences',
                         color_discrete_sequence=px.colors.qualitative.Set3)
        else:
            fig2 = None
        
        return html_output, fig1, fig2
    
    except Exception as e:
        return f"Error: {str(e)}", None, None

def get_dataset_insights():
    """Generate dataset insights"""
    if movies is None or ratings is None:
        return "Please load datasets first!", None, None
    
    # Genre analysis
    all_genres = []
    for genres in movies['genres']:
        if pd.notna(genres) and genres != 'Unknown':
            all_genres.extend(genres.split('|'))
    
    genre_counts = Counter(all_genres)
    top_genres = dict(sorted(genre_counts.items(), key=lambda x: x[1], reverse=True)[:15])
    
    fig1 = px.bar(x=list(top_genres.values()), y=list(top_genres.keys()),
                 orientation='h',
                 labels={'x': 'Number of Movies', 'y': 'Genre'},
                 title='Top 15 Genres by Movie Count',
                 color=list(top_genres.values()),
                 color_continuous_scale='Teal')
    
    # User activity
    user_activity = ratings.groupby('userid').size()
    fig2 = px.histogram(user_activity, nbins=50,
                       labels={'value': 'Number of Ratings', 'count': 'Number of Users'},
                       title='User Activity Distribution',
                       color_discrete_sequence=['coral'])
    
    stats = f"""
    <div style='background: #f0f2f6; padding: 20px; border-radius: 10px;'>
        <h3 style='color: #FF4B4B;'>Insights</h3>
        <p><strong>Most Popular Genre:</strong> {list(top_genres.keys())[0]}</p>
        <p><strong>Average User Activity:</strong> {user_activity.mean():.1f} ratings</p>
        <p><strong>Most Active User:</strong> {user_activity.max()} ratings</p>
        <p><strong>Total Unique Movies Rated:</strong> {ratings['movieid'].nunique()}</p>
    </div>
    """
    
    return stats, fig1, fig2

# Create Gradio Interface
with gr.Blocks(title="DataSynthis Movie Recommender", theme=gr.themes.Soft()) as app:
    
    gr.Markdown("""
    # DataSynthis Movie Recommendation System
    ### Powered by Hybrid Collaborative Filtering & Matrix Factorization
    """)
    
    with gr.Tabs():
        
        # Tab 1: Setup
        with gr.Tab("Setup & Load Data"):
            gr.Markdown("### Step 1: Load Datasets and Train Models")
            gr.Markdown("Click the button below to load your CSV files and train the recommendation models.")
            
            load_btn = gr.Button("Load Datasets & Train Models", variant="primary", size="lg")
            status_output = gr.Textbox(label="Status", lines=2)
            stats_output = gr.HTML(label="Dataset Statistics")
            chart_output = gr.Plot(label="Rating Distribution")
            
            load_btn.click(
                fn=load_and_train,
                outputs=[status_output, stats_output, chart_output]
            )
        
        # Tab 2: Recommendations
        with gr.Tab("Get Recommendations"):
            gr.Markdown("### Generate Personalized Movie Recommendations")
            
            with gr.Row():
                with gr.Column(scale=2):
                    user_id_input = gr.Number(label="Enter User ID", value=1, precision=0)
                with gr.Column(scale=1):
                    num_recs_input = gr.Slider(minimum=5, maximum=20, value=10, step=1, 
                                               label="Number of Recommendations")
            
            recommend_btn = gr.Button("Generate Recommendations", variant="primary", size="lg")
            
            recommendations_output = gr.HTML(label="Recommendations")
            
            with gr.Row():
                rating_chart = gr.Plot(label="User Rating Distribution")
                genre_chart = gr.Plot(label="Genre Preferences")
            
            recommend_btn.click(
                fn=recommend_movies,
                inputs=[user_id_input, num_recs_input],
                outputs=[recommendations_output, rating_chart, genre_chart]
            )
        
        # Tab 3: Insights
        with gr.Tab("Dataset Insights"):
            gr.Markdown("### Explore Dataset Analytics")
            
            insights_btn = gr.Button("Generate Insights", variant="primary")
            insights_stats = gr.HTML(label="Statistics")
            
            with gr.Row():
                genre_plot = gr.Plot(label="Popular Genres")
                activity_plot = gr.Plot(label="User Activity")
            
            insights_btn.click(
                fn=get_dataset_insights,
                outputs=[insights_stats, genre_plot, activity_plot]
            )
        
        # Tab 4: About
        with gr.Tab("About"):
            gr.Markdown("""
            ## DataSynthis Movie Recommendation System
            
            This intelligent recommendation system uses advanced machine learning algorithms to provide
            personalized movie suggestions based on user preferences and viewing history.
            
            ### Features:
            - **Hybrid Approach**: Combines User-Based Collaborative Filtering and SVD Matrix Factorization
            - **High Accuracy**: Trained on comprehensive movie rating datasets
            - **Real-Time Predictions**: Instant recommendations for any user
            - **Interactive Visualizations**: Understand user behavior and preferences
            
            ### Algorithms Used:
            1. **User-Based Collaborative Filtering**: Finds similar users and recommends movies they enjoyed
            2. **SVD Matrix Factorization**: Discovers latent patterns in rating data
            3. **Hybrid Ensemble**: Weighted combination (60% CF, 40% SVD) for optimal results
            
            ### Technology Stack:
            - Python, Gradio, Scikit-learn, Pandas, NumPy, Plotly
            
            ---
            
            **Developed for DataSynthis ML Job Task**
            """)
    
    gr.Markdown("""
    ---
    <div style='text-align: center; color: #666;'>
        <p>DataSynthis Movie Recommendation System | Deployed on Hugging Face Spaces</p>
        <p>Built with Gradio</p>
    </div>
    """)

# Launch the app
if __name__ == "__main__":
    app.launch()