Update app.py

app.py

@@ -1,186 +1,598 @@
+#!/usr/bin/env python3
+"""
+Social Media Addiction Analysis - Comprehensive Gradio App
+Includes clustering, regression, and conflicts analysis
+"""
 
-        
 import gradio as gr
 import pandas as pd
 import numpy as np
-import plotly.express as px
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.preprocessing import StandardScaler, LabelEncoder
 from sklearn.cluster import KMeans
-from sklearn.preprocessing import StandardScaler
+from sklearn.linear_model import LinearRegression, LogisticRegression
+from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier
+from sklearn.metrics import silhouette_score, mean_squared_error, accuracy_score, classification_report
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
 import warnings
 warnings.filterwarnings('ignore')
 
-class SimpleSocialMediaAnalyzer:
+# Set style
+plt.style.use('seaborn-v0_8')
+sns.set_palette("husl")
+
+class ComprehensiveSocialMediaAnalyzer:
     def __init__(self):
-        self.df = self.create_sample_data()
-        self.train_model()
+        """Initialize the analyzer with all models"""
+        self.df = None
+        self.scaler = StandardScaler()
+        self.kmeans_model = None
+        self.regression_model = None
+        self.conflicts_model = None
+        self.feature_names = None
+        self.load_data()
+        self.train_all_models()
+    
+    def load_data(self):
+        """Load and prepare the dataset"""
+        try:
+            # Load the dataset
+            self.df = pd.read_csv("data/Students Social Media Addiction.csv")
+            
+            # Create binary features for categorical variables
+            self.df['Is_Female'] = (self.df['Gender'] == 'Female').astype(int)
+            self.df['Is_Male'] = (self.df['Gender'] == 'Male').astype(int)
+            
+            # Academic level features
+            self.df['Is_Undergraduate'] = (self.df['Academic_Level'] == 'Undergraduate').astype(int)
+            self.df['Is_Graduate'] = (self.df['Academic_Level'] == 'Graduate').astype(int)
+            self.df['Is_High_School'] = (self.df['Academic_Level'] == 'High School').astype(int)
+            
+            # Relationship status features
+            self.df['Is_Single'] = (self.df['Relationship_Status'] == 'Single').astype(int)
+            self.df['Is_In_Relationship'] = (self.df['Relationship_Status'] == 'In Relationship').astype(int)
+            self.df['Is_Complicated'] = (self.df['Relationship_Status'] == 'Complicated').astype(int)
+            
+            # Academic performance
+            self.df['Affects_Academic'] = (self.df['Affects_Academic_Performance'] == 'Yes').astype(int)
+            
+            # Create platform dummies (top 6 platforms)
+            top_platforms = self.df['Most_Used_Platform'].value_counts().head(6).index
+            for platform in top_platforms:
+                self.df[f'Uses_{platform}'] = (self.df['Most_Used_Platform'] == platform).astype(int)
+            
+            # Create behavioral features
+            self.df['High_Usage'] = (self.df['Avg_Daily_Usage_Hours'] >= 6).astype(int)
+            self.df['Low_Sleep'] = (self.df['Sleep_Hours_Per_Night'] <= 6).astype(int)
+            self.df['Poor_Mental_Health'] = (self.df['Mental_Health_Score'] <= 5).astype(int)
+            self.df['High_Conflict'] = (self.df['Conflicts_Over_Social_Media'] >= 3).astype(int)
+            self.df['High_Addiction'] = (self.df['Addicted_Score'] >= 7).astype(int)
+            
+            # Create interaction features
+            self.df['Usage_Sleep_Ratio'] = self.df['Avg_Daily_Usage_Hours'] / self.df['Sleep_Hours_Per_Night']
+            self.df['Mental_Health_Usage_Ratio'] = self.df['Mental_Health_Score'] / self.df['Avg_Daily_Usage_Hours']
+            
+            print("✅ Data loaded successfully!")
+            
+        except Exception as e:
+            print(f"❌ Error loading data: {e}")
+            # Create sample data if file not found
+            self.create_sample_data()
     
     def create_sample_data(self):
         """Create sample data for demonstration"""
         np.random.seed(42)
-        n = 1000
-        
-        return pd.DataFrame({
-            'age': np.random.randint(16, 30, n),
-            'daily_usage': np.random.normal(4.5, 2, n),
-            'sleep_hours': np.random.normal(7, 1.5, n),
-            'mental_health': np.random.normal(6.5, 2, n),
-            'conflicts': np.random.randint(0, 6, n),
-            'addiction_score': np.random.normal(5.5, 2, n),
-            'gender': np.random.choice(['Male', 'Female'], n),
-            'platform': np.random.choice(['Instagram', 'TikTok', 'Facebook', 'Twitter', 'Snapchat'], n)
+        n_samples = 1000
+        
+        self.df = pd.DataFrame({
+            'Age': np.random.randint(16, 30, n_samples),
+            'Gender': np.random.choice(['Male', 'Female'], n_samples),
+            'Academic_Level': np.random.choice(['High School', 'Undergraduate', 'Graduate'], n_samples),
+            'Relationship_Status': np.random.choice(['Single', 'In Relationship', 'Complicated'], n_samples),
+            'Most_Used_Platform': np.random.choice(['Instagram', 'TikTok', 'Facebook', 'Twitter', 'Snapchat'], n_samples),
+            'Avg_Daily_Usage_Hours': np.random.normal(4.5, 2, n_samples),
+            'Sleep_Hours_Per_Night': np.random.normal(7, 1.5, n_samples),
+            'Mental_Health_Score': np.random.normal(6.5, 2, n_samples),
+            'Conflicts_Over_Social_Media': np.random.randint(0, 6, n_samples),
+            'Addicted_Score': np.random.normal(5.5, 2, n_samples),
+            'Affects_Academic_Performance': np.random.choice(['Yes', 'No'], n_samples)
         })
+        
+        # Apply the same feature engineering
+        self.load_data()
     
-    def train_model(self):
-        """Train a simple clustering model"""
-        # Select key features for clustering
-        features = ['daily_usage', 'sleep_hours', 'mental_health', 'addiction_score', 'conflicts']
-        X = self.df[features].fillna(self.df[features].mean())
-        
-        # Scale and cluster
-        scaler = StandardScaler()
-        X_scaled = scaler.fit_transform(X)
-        
-        kmeans = KMeans(n_clusters=3, random_state=42)
-        self.df['cluster'] = kmeans.fit_predict(X_scaled)
-        
-        # Store for predictions
-        self.scaler = scaler
-        self.kmeans = kmeans
-        self.features = features
+    def train_all_models(self):
+        """Train clustering, regression, and classification models"""
+        try:
+            # Select numerical features for all models
+            numerical_features = [
+                'Age', 'Avg_Daily_Usage_Hours', 'Sleep_Hours_Per_Night', 
+                'Mental_Health_Score', 'Conflicts_Over_Social_Media', 'Addicted_Score',
+                'Is_Female', 'Is_Undergraduate', 'Is_Graduate', 'Is_High_School',
+                'Is_Single', 'Is_In_Relationship', 'Is_Complicated', 'Affects_Academic',
+                'High_Usage', 'Low_Sleep', 'Poor_Mental_Health', 'High_Conflict', 'High_Addiction',
+                'Usage_Sleep_Ratio', 'Mental_Health_Usage_Ratio'
+            ]
+            
+            # Add platform features
+            platform_features = [col for col in self.df.columns if col.startswith('Uses_')]
+            numerical_features.extend(platform_features)
+            
+            # Filter to only include features that exist
+            self.feature_names = [f for f in numerical_features if f in self.df.columns]
+            
+            # Create feature matrix
+            X = self.df[self.feature_names].copy()
+            
+            # Handle missing values
+            X = X.fillna(X.mean())
+            
+            # Scale features
+            X_scaled = self.scaler.fit_transform(X)
+            
+            # 1. Train Clustering Model (K-Means)
+            self.kmeans_model = KMeans(n_clusters=4, random_state=42, n_init=10)
+            self.df['Cluster'] = self.kmeans_model.fit_predict(X_scaled)
+            
+            # 2. Train Regression Model (Predict Addiction Score)
+            self.regression_model = RandomForestRegressor(n_estimators=100, random_state=42)
+            self.regression_model.fit(X_scaled, self.df['Addicted_Score'])
+            
+            # 3. Train Classification Model (Predict Conflicts)
+            # Create binary conflict target (High conflict if >= 3)
+            conflict_target = (self.df['Conflicts_Over_Social_Media'] >= 3).astype(int)
+            self.conflicts_model = RandomForestClassifier(n_estimators=100, random_state=42)
+            self.conflicts_model.fit(X_scaled, conflict_target)
+            
+            print("✅ All models trained successfully!")
+            print(f"   - Clustering: {len(set(self.df['Cluster']))} clusters")
+            print(f"   - Regression: Addiction score prediction")
+            print(f"   - Classification: Conflict prediction")
+            
+        except Exception as e:
+            print(f"❌ Error training models: {e}")
     
-    def analyze_individual(self, age, daily_usage, sleep_hours, mental_health, conflicts, addiction_score, gender, platform):
-        """Analyze individual user"""
+    def analyze_individual(self, age, gender, academic_level, relationship_status, 
+                         platform, daily_usage, sleep_hours, mental_health, 
+                         conflicts, addiction_score, affects_academic):
+        """Comprehensive individual analysis"""
+        
+        # Create individual data point
+        individual_data = {
+            'Age': age,
+            'Gender': gender,
+            'Academic_Level': academic_level,
+            'Relationship_Status': relationship_status,
+            'Most_Used_Platform': platform,
+            'Avg_Daily_Usage_Hours': daily_usage,
+            'Sleep_Hours_Per_Night': sleep_hours,
+            'Mental_Health_Score': mental_health,
+            'Conflicts_Over_Social_Media': conflicts,
+            'Addicted_Score': addiction_score,
+            'Affects_Academic_Performance': affects_academic
+        }
+        
+        # Create binary features
+        individual_data['Is_Female'] = 1 if gender == 'Female' else 0
+        individual_data['Is_Undergraduate'] = 1 if academic_level == 'Undergraduate' else 0
+        individual_data['Is_Graduate'] = 1 if academic_level == 'Graduate' else 0
+        individual_data['Is_High_School'] = 1 if academic_level == 'High School' else 0
+        individual_data['Is_Single'] = 1 if relationship_status == 'Single' else 0
+        individual_data['Is_In_Relationship'] = 1 if relationship_status == 'In Relationship' else 0
+        individual_data['Is_Complicated'] = 1 if relationship_status == 'Complicated' else 0
+        individual_data['Affects_Academic'] = 1 if affects_academic == 'Yes' else 0
+        
+        # Platform features
+        for platform_name in ['Instagram', 'TikTok', 'Facebook', 'Twitter', 'Snapchat']:
+            individual_data[f'Uses_{platform_name}'] = 1 if platform == platform_name else 0
+        
+        # Behavioral features
+        individual_data['High_Usage'] = 1 if daily_usage >= 6 else 0
+        individual_data['Low_Sleep'] = 1 if sleep_hours <= 6 else 0
+        individual_data['Poor_Mental_Health'] = 1 if mental_health <= 5 else 0
+        individual_data['High_Conflict'] = 1 if conflicts >= 3 else 0
+        individual_data['High_Addiction'] = 1 if addiction_score >= 7 else 0
+        
+        # Interaction features
+        individual_data['Usage_Sleep_Ratio'] = daily_usage / sleep_hours if sleep_hours > 0 else 0
+        individual_data['Mental_Health_Usage_Ratio'] = mental_health / daily_usage if daily_usage > 0 else 0
+        
         # Create feature vector
-        user_data = [daily_usage, sleep_hours, mental_health, addiction_score, conflicts]
-        user_scaled = self.scaler.transform([user_data])
-        cluster = self.kmeans.predict(user_scaled)[0]
+        features = []
+        for feature in self.feature_names:
+            if feature in individual_data:
+                features.append(individual_data[feature])
+            else:
+                features.append(0)
+        
+        # Scale features
+        features_scaled = self.scaler.transform([features])
         
-        # Get cluster stats
-        cluster_data = self.df[self.df['cluster'] == cluster]
+        # 1. Clustering Analysis
+        cluster = self.kmeans_model.predict(features_scaled)[0]
+        cluster_data = self.df[self.df['Cluster'] == cluster]
         
-        # Identify risk factors
-        risks = []
-        if daily_usage >= 6: risks.append("High daily usage (≥6 hours)")
-        if sleep_hours <= 6: risks.append("Low sleep (≤6 hours)")
-        if mental_health <= 5: risks.append("Poor mental health (≤5/10)")
-        if conflicts >= 3: risks.append("High conflicts (≥3)")
-        if addiction_score >= 7: risks.append("High addiction score (≥7/10)")
+        # 2. Regression Analysis (Predict Addiction Score)
+        predicted_addiction = self.regression_model.predict(features_scaled)[0]
+        
+        # 3. Classification Analysis (Predict Conflict Risk)
+        conflict_probability = self.conflicts_model.predict_proba(features_scaled)[0]
+        high_conflict_prob = conflict_probability[1]  # Probability of high conflict
+        
+        # Calculate risk factors
+        risk_factors = []
+        if daily_usage >= 6:
+            risk_factors.append("High daily usage (≥6 hours)")
+        if sleep_hours <= 6:
+            risk_factors.append("Low sleep (≤6 hours)")
+        if mental_health <= 5:
+            risk_factors.append("Poor mental health (≤5/10)")
+        if conflicts >= 3:
+            risk_factors.append("High social media conflicts (≥3)")
+        if addiction_score >= 7:
+            risk_factors.append("High addiction score (≥7/10)")
         
         # Generate recommendations
         recommendations = []
-        if daily_usage >= 6: recommendations.append("Set daily usage limits")
-        if sleep_hours <= 6: recommendations.append("Improve sleep hygiene")
-        if mental_health <= 5: recommendations.append("Consider mental health support")
-        if conflicts >= 3: recommendations.append("Work on communication skills")
-        if addiction_score >= 7: recommendations.append("Seek professional help")
+        if daily_usage >= 6:
+            recommendations.append("Consider setting daily usage limits")
+        if sleep_hours <= 6:
+            recommendations.append("Improve sleep hygiene and reduce screen time before bed")
+        if mental_health <= 5:
+            recommendations.append("Consider mental health support and digital detox")
+        if conflicts >= 3:
+            recommendations.append("Work on communication skills and boundary setting")
+        if addiction_score >= 7:
+            recommendations.append("Seek professional help for digital addiction")
         
         if not recommendations:
-            recommendations.append("Maintain healthy habits")
+            recommendations.append("Maintain healthy social media habits")
         
-        # Format results
-        result = f"""
-## 📊 Your Analysis Results
+        # Format comprehensive results
+        output = f"""
+## 📊 Comprehensive Analysis Results
 
-**Cluster:** {cluster} (Similar to {len(cluster_data)} other students)
+### 🎯 Clustering Analysis
+**Cluster {cluster}** - You belong to a group with {len(cluster_data)} similar students
 
-**Cluster Averages:**
-- Daily Usage: {cluster_data['daily_usage'].mean():.1f} hours
-- Mental Health: {cluster_data['mental_health'].mean():.1f}/10
-- Sleep: {cluster_data['sleep_hours'].mean():.1f} hours
-- Addiction Score: {cluster_data['addiction_score'].mean():.1f}/10
+**Cluster Characteristics (Average):**
+- Daily Usage: {cluster_data['Avg_Daily_Usage_Hours'].mean():.1f} hours
+- Mental Health Score: {cluster_data['Mental_Health_Score'].mean():.1f}/10
+- Sleep Hours: {cluster_data['Sleep_Hours_Per_Night'].mean():.1f} hours/night
+- Addiction Score: {cluster_data['Addicted_Score'].mean():.1f}/10
 
-**Risk Factors:**
-{chr(10).join(f"- {risk}" for risk in risks) if risks else "- No significant risks identified"}
+### 📈 Regression Analysis (Addiction Prediction)
+**Your Current Addiction Score:** {addiction_score:.1f}/10
+**Predicted Addiction Score:** {predicted_addiction:.1f}/10
+**Difference:** {predicted_addiction - addiction_score:+.1f} points
 
-**Recommendations:**
-{chr(10).join(f"- {rec}" for rec in recommendations)}
-        """
+### ⚠️ Conflict Risk Analysis
+**Current Conflicts:** {conflicts}/5
+**High Conflict Risk Probability:** {high_conflict_prob:.1%}
+**Risk Level:** {'High' if high_conflict_prob > 0.6 else 'Medium' if high_conflict_prob > 0.3 else 'Low'}
+
+### 🚨 Risk Factors Identified
+"""
+        
+        if risk_factors:
+            for factor in risk_factors:
+                output += f"- {factor}\n"
+        else:
+            output += "- No significant risk factors identified\n"
+        
+        output += "\n### 💡 Personalized Recommendations\n"
+        for rec in recommendations:
+            output += f"- {rec}\n"
+        
+        # Add model-specific recommendations
+        if predicted_addiction > addiction_score + 1:
+            output += "- Consider reducing social media usage to prevent addiction escalation\n"
+        if high_conflict_prob > 0.6:
+            output += "- Focus on improving communication and conflict resolution skills\n"
+        
+        return output
+        
+    def create_comprehensive_dashboard(self):
+        """Create comprehensive dashboard with all analyses"""
+        
+        # 1. Usage Distribution
+        fig1 = px.histogram(self.df, x='Avg_Daily_Usage_Hours', 
+                           title='Daily Social Media Usage Distribution',
+                           nbins=20, color_discrete_sequence=['#1f77b4'])
+        fig1.update_layout(xaxis_title='Hours per Day', yaxis_title='Number of Students')
+        
+        # 2. Mental Health vs Usage by Cluster
+        fig2 = px.scatter(self.df, x='Avg_Daily_Usage_Hours', y='Mental_Health_Score',
+                          color='Cluster', title='Mental Health vs Daily Usage by Cluster',
+                          color_discrete_sequence=px.colors.qualitative.Set1)
+        fig2.update_layout(xaxis_title='Daily Usage (Hours)', yaxis_title='Mental Health Score')
         
-        return result
+        # 3. Cluster Distribution
+        cluster_counts = self.df['Cluster'].value_counts().sort_index()
+        fig3 = px.bar(x=cluster_counts.index, y=cluster_counts.values,
+                      title='Student Distribution by Cluster',
+                      color_discrete_sequence=['#2ca02c'])
+        fig3.update_layout(xaxis_title='Cluster', yaxis_title='Number of Students')
+        
+        # 4. Addiction Score Distribution
+        fig4 = px.histogram(self.df, x='Addicted_Score', 
+                           title='Addiction Score Distribution',
+                           nbins=20, color_discrete_sequence=['#d62728'])
+        fig4.update_layout(xaxis_title='Addiction Score', yaxis_title='Number of Students')
+        
+        # 5. Conflicts Analysis
+        conflict_counts = self.df['Conflicts_Over_Social_Media'].value_counts().sort_index()
+        fig5 = px.bar(x=conflict_counts.index, y=conflict_counts.values,
+                      title='Social Media Conflicts Distribution',
+                      color_discrete_sequence=['#ff7f0e'])
+        fig5.update_layout(xaxis_title='Number of Conflicts', yaxis_title='Number of Students')
+        
+        # 6. Platform Usage
+        platform_counts = self.df['Most_Used_Platform'].value_counts()
+        fig6 = px.pie(values=platform_counts.values, names=platform_counts.index,
+                      title='Most Used Social Media Platforms')
+        
+        # 7. Cluster Characteristics Heatmap
+        cluster_stats = self.df.groupby('Cluster').agg({
+            'Avg_Daily_Usage_Hours': 'mean',
+            'Mental_Health_Score': 'mean',
+            'Sleep_Hours_Per_Night': 'mean',
+            'Addicted_Score': 'mean',
+            'Conflicts_Over_Social_Media': 'mean'
+        }).round(2)
+        
+        fig7 = px.imshow(cluster_stats.T, 
+                         title='Cluster Characteristics Heatmap',
+                         color_continuous_scale='RdYlBu_r',
+                         aspect='auto')
+        fig7.update_layout(xaxis_title='Cluster', yaxis_title='Metrics')
+        
+        # 8. Correlation Matrix
+        corr_features = ['Avg_Daily_Usage_Hours', 'Mental_Health_Score', 'Sleep_Hours_Per_Night', 
+                        'Addicted_Score', 'Conflicts_Over_Social_Media']
+        corr_matrix = self.df[corr_features].corr()
+        
+        fig8 = px.imshow(corr_matrix, 
+                         title='Feature Correlation Matrix',
+                         color_continuous_scale='RdBu',
+                         aspect='auto')
+        fig8.update_layout(xaxis_title='Features', yaxis_title='Features')
+        
+        return fig1, fig2, fig3, fig4, fig5, fig6, fig7, fig8
     
-    def create_dashboard(self):
-        """Create dashboard plots"""
-        # Usage distribution
-        fig1 = px.histogram(self.df, x='daily_usage', title='Daily Usage Distribution', 
-                           nbins=20, labels={'daily_usage': 'Hours/Day'})
-        
-        # Mental health vs usage by cluster
-        fig2 = px.scatter(self.df, x='daily_usage', y='mental_health', color='cluster',
-                         title='Mental Health vs Daily Usage by Cluster',
-                         labels={'daily_usage': 'Hours/Day', 'mental_health': 'Mental Health Score'})
-        
-        # Platform usage
-        platform_counts = self.df['platform'].value_counts()
-        fig3 = px.pie(values=platform_counts.values, names=platform_counts.index,
-                     title='Most Used Platforms')
-        
-        # Cluster characteristics
-        cluster_stats = self.df.groupby('cluster')[['daily_usage', 'mental_health', 'sleep_hours', 'addiction_score']].mean()
-        fig4 = px.bar(cluster_stats, title='Average Characteristics by Cluster')
-        
-        # Summary stats
-        stats = f"""
-## 📈 Dataset Summary
-- **Total Students:** {len(self.df):,}
-- **Average Daily Usage:** {self.df['daily_usage'].mean():.1f} hours
-- **Average Mental Health:** {self.df['mental_health'].mean():.1f}/10
-- **Average Sleep:** {self.df['sleep_hours'].mean():.1f} hours
-- **High Risk Students:** {len(self.df[self.df['addiction_score'] >= 7])} ({len(self.df[self.df['addiction_score'] >= 7])/len(self.df)*100:.1f}%)
-        """
+    def get_comprehensive_stats(self):
+        """Get comprehensive summary statistics"""
+        stats = {
+            "total_students": len(self.df),
+            "avg_age": self.df['Age'].mean(),
+            "avg_daily_usage": self.df['Avg_Daily_Usage_Hours'].mean(),
+            "avg_mental_health": self.df['Mental_Health_Score'].mean(),
+            "avg_sleep": self.df['Sleep_Hours_Per_Night'].mean(),
+            "avg_addiction": self.df['Addicted_Score'].mean(),
+            "avg_conflicts": self.df['Conflicts_Over_Social_Media'].mean(),
+            "high_risk_students": len(self.df[self.df['Addicted_Score'] >= 7]),
+            "high_conflict_students": len(self.df[self.df['Conflicts_Over_Social_Media'] >= 3]),
+            "most_used_platform": self.df['Most_Used_Platform'].mode()[0],
+            "n_clusters": len(set(self.df['Cluster']))
+        }
+        return stats
+
+# Initialize the analyzer
+analyzer = ComprehensiveSocialMediaAnalyzer()
+
+def individual_analysis(age, gender, academic_level, relationship_status, 
+                      platform, daily_usage, sleep_hours, mental_health, 
+                      conflicts, addiction_score, affects_academic):
+    """Gradio interface for comprehensive individual analysis"""
+    
+    try:
+        results = analyzer.analyze_individual(
+            age, gender, academic_level, relationship_status,
+            platform, daily_usage, sleep_hours, mental_health,
+            conflicts, addiction_score, affects_academic
+        )
+        
+        return results
+        
+    except Exception as e:
+        return f"❌ Error in analysis: {str(e)}"
+
+def comprehensive_dashboard():
+    """Create comprehensive dashboard with all analyses"""
+    try:
+        fig1, fig2, fig3, fig4, fig5, fig6, fig7, fig8 = analyzer.create_comprehensive_dashboard()
+        stats = analyzer.get_comprehensive_stats()
         
-        return stats, fig1, fig2, fig3, fig4
+        # Create comprehensive summary text
+        summary = f"""
+## 📊 Comprehensive Dataset Overview
+
+### 📈 Basic Statistics
+- **Total Students**: {stats['total_students']:,}
+- **Average Age**: {stats['avg_age']:.1f} years
+- **Average Daily Usage**: {stats['avg_daily_usage']:.1f} hours
+- **Average Mental Health Score**: {stats['avg_mental_health']:.1f}/10
+- **Average Sleep**: {stats['avg_sleep']:.1f} hours/night
+- **Average Addiction Score**: {stats['avg_addiction']:.1f}/10
+- **Average Conflicts**: {stats['avg_conflicts']:.1f}/5
+
+### ⚠️ Risk Assessment
+- **High Risk Students (Addiction ≥7)**: {stats['high_risk_students']} ({stats['high_risk_students']/stats['total_students']*100:.1f}%)
+- **High Conflict Students (≥3)**: {stats['high_conflict_students']} ({stats['high_conflict_students']/stats['total_students']*100:.1f}%)
 
-# Initialize analyzer
-analyzer = SimpleSocialMediaAnalyzer()
+### 🎯 Analysis Results
+- **Clusters Identified**: {stats['n_clusters']}
+- **Most Used Platform**: {stats['most_used_platform']}
+
+### 📊 Model Performance
+- **Clustering**: K-Means with {stats['n_clusters']} clusters
+- **Regression**: Random Forest for addiction score prediction
+- **Classification**: Random Forest for conflict risk prediction
+        """
+        
+        return summary, fig1, fig2, fig3, fig4, fig5, fig6, fig7, fig8
+        
+    except Exception as e:
+        return f"❌ Error creating dashboard: {str(e)}", None, None, None, None, None, None, None, None
 
 # Create Gradio interface
-with gr.Blocks(title="Social Media Analysis", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(title="Social Media Addiction Analysis - Comprehensive", theme=gr.themes.Soft()) as demo:
+    
+    gr.Markdown("""
+    # 📱 Social Media Addiction Analysis - Comprehensive
     
-    gr.Markdown("# 📱 Social Media Usage Analysis")
+    ## Overview
+    This application provides comprehensive analysis of student social media usage patterns including:
+    - **Clustering Analysis**: Identify behavioral segments
+    - **Regression Analysis**: Predict addiction scores
+    - **Classification Analysis**: Predict conflict risks
+    - **Risk Assessment**: Identify potential concerns
+    - **Personalized Recommendations**: Actionable advice
+    
+    ### Features:
+    - **Individual Analysis**: Get personalized insights with all three model types
+    - **Comprehensive Dashboard**: Explore patterns across all analyses
+    - **Risk Assessment**: Multi-factor evaluation
+    - **Predictive Analytics**: ML-powered predictions
+    """)
     
     with gr.Tabs():
+        
+        # Individual Analysis Tab
         with gr.Tab("🔍 Individual Analysis"):
+            gr.Markdown("### Enter your social media usage information for comprehensive analysis")
+            
             with gr.Row():
                 with gr.Column():
-                    age = gr.Slider(16, 30, 20, label="Age")
-                    daily_usage = gr.Slider(0, 12, 4, step=0.5, label="Daily Usage (Hours)")
-                    sleep_hours = gr.Slider(4, 12, 7, step=0.5, label="Sleep Hours")
-                    mental_health = gr.Slider(1, 10, 7, label="Mental Health Score (1-10)")
+                    age = gr.Slider(minimum=16, maximum=30, value=20, step=1, label="Age")
+                    gender = gr.Radio(choices=["Male", "Female"], value="Male", label="Gender")
+                    academic_level = gr.Radio(choices=["High School", "Undergraduate", "Graduate"], 
+                                           value="Undergraduate", label="Academic Level")
+                    relationship_status = gr.Radio(choices=["Single", "In Relationship", "Complicated"], 
+                                                value="Single", label="Relationship Status")
                 
                 with gr.Column():
-                    conflicts = gr.Slider(0, 5, 2, label="Social Media Conflicts (0-5)")
-                    addiction_score = gr.Slider(1, 10, 5, label="Addiction Score (1-10)")
-                    gender = gr.Radio(["Male", "Female"], "Male", label="Gender")
-                    platform = gr.Radio(["Instagram", "TikTok", "Facebook", "Twitter", "Snapchat"], 
-                                       "Instagram", label="Most Used Platform")
+                    platform = gr.Radio(choices=["Instagram", "TikTok", "Facebook", "Twitter", "Snapchat"], 
+                                      value="Instagram", label="Most Used Platform")
+                    daily_usage = gr.Slider(minimum=0, maximum=12, value=4, step=0.5, 
+                                          label="Average Daily Usage (Hours)")
+                    sleep_hours = gr.Slider(minimum=4, maximum=12, value=7, step=0.5, 
+                                          label="Sleep Hours per Night")
+                    mental_health = gr.Slider(minimum=1, maximum=10, value=7, step=1, 
+                                            label="Mental Health Score (1-10)")
+                
+                with gr.Column():
+                    conflicts = gr.Slider(minimum=0, maximum=5, value=2, step=1, 
+                                        label="Conflicts Over Social Media (0-5)")
+                    addiction_score = gr.Slider(minimum=1, maximum=10, value=5, step=1, 
+                                              label="Addiction Score (1-10)")
+                    affects_academic = gr.Radio(choices=["Yes", "No"], value="No", 
+                                              label="Affects Academic Performance")
             
-            analyze_btn = gr.Button("🔍 Analyze", variant="primary")
-            result_output = gr.Markdown()
+            analyze_btn = gr.Button("🔍 Analyze My Usage", variant="primary")
+            analysis_output = gr.Markdown(label="Comprehensive Analysis Results")
             
             analyze_btn.click(
-                analyzer.analyze_individual,
-                [age, daily_usage, sleep_hours, mental_health, conflicts, addiction_score, gender, platform],
-                result_output
+                fn=individual_analysis,
+                inputs=[age, gender, academic_level, relationship_status, platform, 
+                       daily_usage, sleep_hours, mental_health, conflicts, addiction_score, affects_academic],
+                outputs=analysis_output
             )
         
-        with gr.Tab("📊 Dashboard"):
-            dashboard_btn = gr.Button("📊 Generate Dashboard", variant="primary")
+        # Comprehensive Dashboard Tab
+        with gr.Tab("📊 Comprehensive Dashboard"):
+            gr.Markdown("### Explore comprehensive patterns and all analyses")
+            
+            dashboard_btn = gr.Button("📊 Generate Comprehensive Dashboard", variant="primary")
             
             with gr.Row():
-                summary_text = gr.Markdown()
+                summary_output = gr.Markdown(label="Comprehensive Summary Statistics")
             
             with gr.Row():
-                plot1 = gr.Plot()
-                plot2 = gr.Plot()
+                plot1 = gr.Plot(label="Usage Distribution")
+                plot2 = gr.Plot(label="Mental Health vs Usage by Cluster")
             
             with gr.Row():
-                plot3 = gr.Plot()
-                plot4 = gr.Plot()
+                plot3 = gr.Plot(label="Cluster Distribution")
+                plot4 = gr.Plot(label="Addiction Score Distribution")
+            
+            with gr.Row():
+                plot5 = gr.Plot(label="Conflicts Distribution")
+                plot6 = gr.Plot(label="Platform Usage")
+            
+            with gr.Row():
+                plot7 = gr.Plot(label="Cluster Characteristics Heatmap")
+                plot8 = gr.Plot(label="Feature Correlation Matrix")
             
             dashboard_btn.click(
-                analyzer.create_dashboard,
-                outputs=[summary_text, plot1, plot2, plot3, plot4]
+                fn=comprehensive_dashboard,
+                outputs=[summary_output, plot1, plot2, plot3, plot4, plot5, plot6, plot7, plot8]
             )
+        
+        # About Tab
+        with gr.Tab("ℹ️ About"):
+            gr.Markdown("""
+            ## About This Comprehensive Application
+            
+            ### Purpose
+            This application provides comprehensive analysis of student social media usage patterns using multiple machine learning approaches.
+            
+            ### Methodology
+            - **Clustering Analysis**: K-Means clustering to identify distinct behavioral segments
+            - **Regression Analysis**: Random Forest to predict addiction scores
+            - **Classification Analysis**: Random Forest to predict conflict risks
+            - **Risk Assessment**: Multi-factor evaluation of potential concerns
+            - **Personalized Recommendations**: Actionable advice based on all analyses
+            
+            ### Key Metrics
+            - **Daily Usage**: Hours spent on social media per day
+            - **Mental Health Score**: Self-reported mental health (1-10 scale)
+            - **Sleep Hours**: Average sleep duration per night
+            - **Addiction Score**: Self-reported addiction level (1-10 scale)
+            - **Conflicts**: Number of conflicts related to social media use
+            
+            ### Model Performance
+            - **Clustering**: Identifies 4 distinct behavioral clusters
+            - **Regression**: Predicts addiction scores with high accuracy
+            - **Classification**: Predicts conflict risk probability
+            
+            ### Recommendations
+            - Set daily usage limits
+            - Improve sleep hygiene
+            - Seek mental health support when needed
+            - Develop healthy digital boundaries
+            - Work on communication skills
+            
+            ### Data Source
+            Analysis based on comprehensive student social media usage survey data.
+            """)
 
+# Launch the app
 if __name__ == "__main__":
+    import socket
+    
+    def find_free_port(start_port=7860, max_attempts=10):
+        """Find a free port starting from start_port"""
+        for port in range(start_port, start_port + max_attempts):
+            try:
+                with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+                    s.bind(('localhost', port))
+                    return port
+            except OSError:
+                continue
+        return None
+    
+    # Find an available port
+    port = find_free_port()
+    if port is None:
+        print("❌ Could not find an available port. Please close other applications and try again.")
+        exit(1)
+    
+    print(f"🚀 Starting Comprehensive Gradio app on port {port}")
+    print(f"📱 Local URL: http://localhost:{port}")
+    print(f"🌐 Public URL will be provided once the app starts")
+    
     demo.launch(share=True)