Update app.py

app.py

@@ -1,517 +1,185 @@
 
-#!/usr/bin/env python3
-"""
-Social Media Addiction Analysis - Gradio App
-A comprehensive web application for analyzing student social media usage patterns
-"""
-
 import gradio as gr
 import pandas as pd
 import numpy as np
-import matplotlib.pyplot as plt
-import seaborn as sns
-from sklearn.preprocessing import StandardScaler
-from sklearn.cluster import KMeans
-from sklearn.metrics import silhouette_score
 import plotly.express as px
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
+from sklearn.cluster import KMeans
+from sklearn.preprocessing import StandardScaler
 import warnings
 warnings.filterwarnings('ignore')
 
-# Set style
-plt.style.use('seaborn-v0_8')
-sns.set_palette("husl")
-
-class SocialMediaAnalyzer:
+class SimpleSocialMediaAnalyzer:
     def __init__(self):
-        """Initialize the analyzer with pre-trained models and data"""
-        self.df = None
-        self.scaler = StandardScaler()
-        self.kmeans_model = None
-        self.feature_names = None
-        self.load_data()
-        self.train_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()
+        self.df = self.create_sample_data()
+        self.train_model()
     
     def create_sample_data(self):
         """Create sample data for demonstration"""
         np.random.seed(42)
-        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)
+        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)
         })
-        
-        # Apply the same feature engineering
-        self.load_data()
     
-    def train_models(self):
-        """Train clustering models"""
-        try:
-            # Select numerical features for clustering
-            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)
-            
-            # Train K-Means model
-            self.kmeans_model = KMeans(n_clusters=4, random_state=42, n_init=10)
-            self.kmeans_model.fit(X_scaled)
-            
-            # Add cluster labels to dataframe
-            self.df['Cluster'] = self.kmeans_model.labels_
-            
-            print("✅ Models trained successfully!")
-            
-        except Exception as e:
-            print(f"❌ Error training models: {e}")
+    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 analyze_individual(self, age, gender, academic_level, relationship_status, 
-                         platform, daily_usage, sleep_hours, mental_health, 
-                         conflicts, addiction_score, affects_academic):
-        """Analyze an individual student's social media usage patterns"""
-        
-        # 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
-        
+    def analyze_individual(self, age, daily_usage, sleep_hours, mental_health, conflicts, addiction_score, gender, platform):
+        """Analyze individual user"""
         # Create feature vector
-        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])
-        
-        # Predict cluster
-        cluster = self.kmeans_model.predict(features_scaled)[0]
+        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]
         
-        # Get cluster characteristics
-        cluster_data = self.df[self.df['Cluster'] == cluster]
+        # Get cluster stats
+        cluster_data = self.df[self.df['cluster'] == cluster]
         
-        # 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)")
+        # 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)")
         
         # Generate recommendations
         recommendations = []
-        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 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 not recommendations:
-            recommendations.append("Maintain healthy social media habits")
-        
-        # Create analysis results
-        analysis_results = {
-            "cluster": cluster,
-            "cluster_size": len(cluster_data),
-            "avg_usage_cluster": cluster_data['Avg_Daily_Usage_Hours'].mean(),
-            "avg_mental_health_cluster": cluster_data['Mental_Health_Score'].mean(),
-            "avg_sleep_cluster": cluster_data['Sleep_Hours_Per_Night'].mean(),
-            "avg_addiction_cluster": cluster_data['Addicted_Score'].mean(),
-            "risk_factors": risk_factors,
-            "recommendations": recommendations
-        }
-        
-        return analysis_results
-    
-    def create_dashboard_plots(self):
-        """Create comprehensive dashboard plots"""
-        
-        # 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')
+            recommendations.append("Maintain healthy habits")
         
-        # 2. Mental Health vs Usage
-        fig2 = px.scatter(self.df, x='Avg_Daily_Usage_Hours', y='Mental_Health_Score',
-                          color='Cluster', title='Mental Health vs Daily Usage',
-                          color_discrete_sequence=px.colors.qualitative.Set1)
-        fig2.update_layout(xaxis_title='Daily Usage (Hours)', yaxis_title='Mental Health Score')
-        
-        # 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. Platform Usage
-        platform_counts = self.df['Most_Used_Platform'].value_counts()
-        fig4 = px.pie(values=platform_counts.values, names=platform_counts.index,
-                      title='Most Used Social Media Platforms')
-        
-        # 5. Cluster Characteristics
-        cluster_stats = self.df.groupby('Cluster').agg({
-            'Avg_Daily_Usage_Hours': 'mean',
-            'Mental_Health_Score': 'mean',
-            'Sleep_Hours_Per_Night': 'mean',
-            'Addicted_Score': 'mean'
-        }).round(2)
-        
-        fig5 = px.imshow(cluster_stats.T, 
-                         title='Cluster Characteristics Heatmap',
-                         color_continuous_scale='RdYlBu_r',
-                         aspect='auto')
-        fig5.update_layout(xaxis_title='Cluster', yaxis_title='Metrics')
-        
-        return fig1, fig2, fig3, fig4, fig5
-    
-    def get_summary_stats(self):
-        """Get 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(),
-            "high_risk_students": len(self.df[self.df['Addicted_Score'] >= 7]),
-            "most_used_platform": self.df['Most_Used_Platform'].mode()[0]
-        }
-        return stats
+        # Format results
+        result = f"""
+## 📊 Your Analysis Results
 
-# Initialize the analyzer
-analyzer = SocialMediaAnalyzer()
+**Cluster:** {cluster} (Similar to {len(cluster_data)} other students)
 
-def individual_analysis(age, gender, academic_level, relationship_status, 
-                      platform, daily_usage, sleep_hours, mental_health, 
-                      conflicts, addiction_score, affects_academic):
-    """Gradio interface for 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
-        )
-        
-        # Format the results
-        output = f"""
-## 📊 Individual Analysis Results
+**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 Assignment
-**Cluster {results['cluster']}** - You belong to a group with {results['cluster_size']} similar students
+**Risk Factors:**
+{chr(10).join(f"- {risk}" for risk in risks) if risks else "- No significant risks identified"}
 
-### 📈 Cluster Characteristics (Average)
-- **Daily Usage**: {results['avg_usage_cluster']:.1f} hours
-- **Mental Health Score**: {results['avg_mental_health_cluster']:.1f}/10
-- **Sleep Hours**: {results['avg_sleep_cluster']:.1f} hours/night
-- **Addiction Score**: {results['avg_addiction_cluster']:.1f}/10
-
-### ⚠️ Risk Factors Identified
-"""
-        
-        if results['risk_factors']:
-            for factor in results['risk_factors']:
-                output += f"- {factor}\n"
-        else:
-            output += "- No significant risk factors identified\n"
-        
-        output += "\n### 💡 Recommendations\n"
-        for rec in results['recommendations']:
-            output += f"- {rec}\n"
-        
-        return output
-        
-    except Exception as e:
-        return f"❌ Error in analysis: {str(e)}"
-
-def dashboard():
-    """Create dashboard with plots"""
-    try:
-        fig1, fig2, fig3, fig4, fig5 = analyzer.create_dashboard_plots()
-        stats = analyzer.get_summary_stats()
-        
-        # Create summary text
-        summary = f"""
-## 📊 Dataset Overview
-
-- **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
-- **High Risk Students**: {stats['high_risk_students']} ({stats['high_risk_students']/stats['total_students']*100:.1f}%)
-- **Most Used Platform**: {stats['most_used_platform']}
+**Recommendations:**
+{chr(10).join(f"- {rec}" for rec in recommendations)}
         """
         
-        return summary, fig1, fig2, fig3, fig4, fig5
+        return result
+    
+    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}%)
+        """
         
-    except Exception as e:
-        return f"❌ Error creating dashboard: {str(e)}", None, None, None, None, None
+        return stats, fig1, fig2, fig3, fig4
+
+# Initialize analyzer
+analyzer = SimpleSocialMediaAnalyzer()
 
 # Create Gradio interface
-with gr.Blocks(title="Social Media Addiction Analysis", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(title="Social Media Analysis - Simplified", theme=gr.themes.Soft()) as demo:
     
-    gr.Markdown("""
-    # 📱 Social Media Addiction Analysis
-    
-    ## Overview
-    This application analyzes student social media usage patterns to identify risk factors and provide personalized recommendations for healthy digital habits.
-    
-    ### Features:
-    - **Individual Analysis**: Get personalized insights based on your social media usage
-    - **Dashboard**: Explore overall patterns and cluster characteristics
-    - **Risk Assessment**: Identify potential addiction and mental health concerns
-    - **Recommendations**: Receive actionable advice for healthier social media use
-    """)
+    gr.Markdown("# 📱 Social Media Usage Analysis (Simplified)")
     
     with gr.Tabs():
-        
-        # Individual Analysis Tab
         with gr.Tab("🔍 Individual Analysis"):
-            gr.Markdown("### Enter your social media usage information for personalized analysis")
-            
             with gr.Row():
                 with gr.Column():
-                    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():
-                    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)")
+                    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)")
                 
                 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")
+                    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")
             
-            analyze_btn = gr.Button("🔍 Analyze My Usage", variant="primary")
-            analysis_output = gr.Markdown(label="Analysis Results")
+            analyze_btn = gr.Button("🔍 Analyze", variant="primary")
+            result_output = gr.Markdown()
             
             analyze_btn.click(
-                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
+                analyzer.analyze_individual,
+                [age, daily_usage, sleep_hours, mental_health, conflicts, addiction_score, gender, platform],
+                result_output
             )
         
-        # Dashboard Tab
         with gr.Tab("📊 Dashboard"):
-            gr.Markdown("### Explore overall patterns and cluster characteristics")
-            
             dashboard_btn = gr.Button("📊 Generate Dashboard", variant="primary")
             
             with gr.Row():
-                summary_output = gr.Markdown(label="Summary Statistics")
+                summary_text = gr.Markdown()
             
             with gr.Row():
-                plot1 = gr.Plot(label="Usage Distribution")
-                plot2 = gr.Plot(label="Mental Health vs Usage")
+                plot1 = gr.Plot()
+                plot2 = gr.Plot()
             
             with gr.Row():
-                plot3 = gr.Plot(label="Cluster Distribution")
-                plot4 = gr.Plot(label="Platform Usage")
-            
-            with gr.Row():
-                plot5 = gr.Plot(label="Cluster Characteristics")
+                plot3 = gr.Plot()
+                plot4 = gr.Plot()
             
             dashboard_btn.click(
-                fn=dashboard,
-                outputs=[summary_output, plot1, plot2, plot3, plot4, plot5]
+                analyzer.create_dashboard,
+                outputs=[summary_text, plot1, plot2, plot3, plot4]
             )
-        
-        # About Tab
-        with gr.Tab("ℹ️ About"):
-            gr.Markdown("""
-            ## About This Application
-            
-            ### Purpose
-            This application helps students and educators understand social media usage patterns and identify potential addiction risks.
-            
-            ### Methodology
-            - **Clustering Analysis**: Uses K-Means clustering to identify distinct user segments
-            - **Risk Assessment**: Evaluates multiple factors including usage time, mental health, and conflicts
-            - **Personalized Recommendations**: Provides actionable advice based on individual patterns
-            
-            ### 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
-            
-            ### Recommendations
-            - Set daily usage limits
-            - Improve sleep hygiene
-            - Seek mental health support when needed
-            - Develop healthy digital boundaries
-            
-            ### Data Source
-            Analysis based on 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 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) 
+    demo.launch(share=True)