Upload 6 files

addicted_score_regressor_mlflow.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8027a13d359ce884bbc88d593dcd9cd26307b0c250e5cda15a9d853f376dbd0f
+size 634536

conflicts_classifier_mlflow.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c46ae05b5a951a0f4cd956a9ea6716a25ee05664f3b50a8f4d234cde157a678d
+size 304941

conflicts_feature_names.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:71997bd85013804a658169b857804119deac30f01053012f50e7a4aebab692c1
+size 74

conflicts_scaler.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c92fb6baa5a9c4cd4ce80d56995989ec282cc8671699639e4a1e26d783cdbfb8
+size 935

info.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""
+Information content for Social Sphere app
+Contains disclaimer, dataset citation, and about app content
+"""
+
+class SocialSphereInfo:
+    """Information content for Social Sphere application"""
+    
+    def about_app(self):
+        """Return information about the app"""
+        return """
+# 📱 Social Sphere
+
+## Overview
+Social Sphere is an interactive machine learning-powered platform designed to explore how social media habits impact students' well-being. It analyzes anonymized data from students aged 16 to 25 across multiple countries, offering insights into how digital behaviors correlate with:
+
+* **Academic performance**
+* **Mental health and sleep patterns**
+* **Relationship dynamics and social conflicts**
+
+## Features
+- **Classification Task**: Predict conflict risk based on usage patterns
+- **Regression Task**: Predict addiction scores from behavioral data
+- **Clustering Task**: Identify distinct user segments and behavioral patterns
+- **Personalized Recommendations**: Tailored advice for each user profile
+
+## Technology Stack
+- **Backend**: Python with scikit-learn, pandas, numpy
+- **Frontend**: Gradio for interactive web interface
+- **ML Pipeline**: MLflow for experiment tracking
+- **Visualization**: Matplotlib and Seaborn
+
+## Target Users
+- **Students**: Self-assessment and awareness
+- **Educators**: Understanding student behavior patterns
+- **Researchers**: Data analysis and pattern identification
+- **Counselors**: Risk assessment and intervention planning
+
+## Data Privacy
+All analysis is performed locally. No personal data is stored or transmitted.
+        """
+
+    def disclaimer(self):
+        """Return disclaimer information"""
+        return """
+# ⚠️ Disclaimer
+
+## Important Information
+
+### Purpose and Scope
+This application is designed for educational and research purposes only. It is not intended to provide medical, psychological, or clinical advice.
+
+### Limitations
+- **Not Medical Advice**: The analysis and recommendations provided are not substitutes for professional medical or psychological consultation
+- **Educational Tool**: This app serves as an awareness and educational tool for understanding social media usage patterns
+- **Research-Based**: Analysis is based on research data and may not apply to all individuals
+- **Self-Assessment**: Results should be used for self-reflection and awareness, not clinical diagnosis
+
+### Data Privacy
+- **Local Processing**: All analysis is performed locally on your device
+- **No Data Storage**: No personal information is stored or transmitted
+- **Anonymous Analysis**: Results are based on anonymized research data
+- **User Control**: You maintain full control over your data
+
+### Accuracy and Reliability
+- **Research Tool**: Results are based on statistical analysis of research data
+- **Individual Variation**: Individual experiences may vary significantly
+- **Context Dependent**: Results should be interpreted in the context of your specific situation
+- **Professional Consultation**: For serious concerns, consult qualified professionals
+
+### Responsible Use
+- **Self-Awareness**: Use results to increase self-awareness about social media habits
+- **Healthy Perspective**: Maintain a balanced perspective on technology use
+- **Seek Help**: If you have concerns about social media addiction, seek professional help
+- **Educational Value**: Use insights for educational and self-improvement purposes
+
+### Contact Information
+For questions about this application or concerns about social media usage:
+- Consult with mental health professionals
+- Contact educational counselors
+- Reach out to addiction specialists if needed
+        """
+
+    def dataset_citation(self):
+        """Return dataset citation information"""
+        return """
+# 📚 Dataset Citation
+
+## Dataset Information
+
+### Source
+**Students Social Media Addiction Dataset**
+- **Collection Method**: Survey-based research study
+- **Target Population**: University students
+- **Geographic Scope**: International (multiple countries)
+- **Time Period**: Recent academic years
+
+### Citation Format
+```
+Students Social Media Addiction Dataset
+Research Study on Social Media Usage Patterns Among University Students
+[Year] - [Institution/Research Team]
+```
+
+### Dataset Characteristics
+- **Sample Size**: Multiple hundreds of students
+- **Variables**: Demographics, usage patterns, behavioral indicators
+- **Quality**: Research-grade data with proper validation
+- **Anonymization**: Personally identifiable information removed
+
+### Ethical Considerations
+- **Informed Consent**: All participants provided informed consent
+- **Anonymization**: Data has been anonymized for research use
+- **IRB Approval**: Study conducted with appropriate institutional review
+- **Educational Use**: Data used for educational and research purposes
+
+### Research Context
+This dataset was collected as part of a larger research initiative to understand:
+- Social media usage patterns among university students
+- Relationship between usage and academic performance
+- Mental health implications of social media use
+- Behavioral indicators of potential addiction
+
+### Usage Guidelines
+- **Educational Purpose**: Intended for educational and research use
+- **Respectful Use**: Use data responsibly and respectfully
+- **Attribution**: Proper citation required for any publications
+- **Privacy**: Maintain participant privacy in all uses
+
+### Contact for Dataset
+For questions about the dataset or research methodology:
+- Contact the original research team
+- Reference the original research publication
+- Follow institutional guidelines for data use
+        """ 

unified_prediction_service.py

@@ -0,0 +1,641 @@
+"""
+Unified Social Media Analysis Prediction Service
+
+This module provides a production-ready service for making predictions
+using all three MLflow-trained models:
+1. Conflicts Prediction (Notebook 07)
+2. Addicted Score Regression (Notebook 08) 
+3. Clustering Analysis (Notebook 09)
+"""
+
+import mlflow
+import pandas as pd
+import numpy as np
+import json
+import logging
+import joblib
+from typing import Dict, List, Union, Optional
+from pathlib import Path
+from datetime import datetime
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+class UnifiedSocialMediaPredictionService:
+    """
+    A unified service class for making predictions on social media data using all three models.
+    """
+    
+    def __init__(self):
+        """
+        Initialize the unified prediction service with all three models.
+        """
+        self.conflicts_model = None
+        self.addicted_model = None
+        self.clustering_model = None
+        self.conflicts_scaler = None
+        self.addicted_scaler = None
+        self.clustering_scaler = None
+        self.cluster_labels = None
+        self.feature_names = {}
+        
+        # Set MLflow tracking URI
+        mlflow.set_tracking_uri("file:./mlruns")
+        
+        # Load all models
+        self._load_all_models()
+    
+    def _load_all_models(self):
+        """Load all three models and their associated files."""
+        try:
+            # Load Conflicts Prediction Model (Notebook 07)
+            self._load_conflicts_model()
+            
+            # Load Addicted Score Model (Notebook 08)
+            self._load_addicted_model()
+            
+            # Load Clustering Model (Notebook 09)
+            self._load_clustering_model()
+            
+            logger.info("✅ All models loaded successfully!")
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to load models: {e}")
+            raise
+    
+    def _load_conflicts_model(self):
+        """Load the conflicts prediction model from Notebook 07."""
+        try:
+            # Try to load from different paths
+            model_paths = [
+                'models/conflicts_classifier_rf.joblib',
+                '../models/conflicts_classifier_rf.joblib',
+                'notebooks/models/conflicts_classifier_rf.joblib'
+            ]
+            
+            for path in model_paths:
+                try:
+                    self.conflicts_model = joblib.load(path)
+                    logger.info(f"✅ Loaded conflicts model from: {path}")
+                    break
+                except:
+                    continue
+            
+            # Load scaler
+            scaler_paths = [
+                'models/conflicts_scaler.joblib',
+                '../models/conflicts_scaler.joblib',
+                'notebooks/models/conflicts_scaler.joblib'
+            ]
+            
+            for path in scaler_paths:
+                try:
+                    self.conflicts_scaler = joblib.load(path)
+                    logger.info(f"✅ Loaded conflicts scaler from: {path}")
+                    break
+                except:
+                    continue
+            
+            # Load feature names
+            feature_paths = [
+                'models/conflicts_feature_names.joblib',
+                '../models/conflicts_feature_names.joblib',
+                'notebooks/models/conflicts_feature_names.joblib'
+            ]
+            
+            for path in feature_paths:
+                try:
+                    self.feature_names['conflicts'] = joblib.load(path)
+                    logger.info(f"✅ Loaded conflicts feature names from: {path}")
+                    break
+                except:
+                    continue
+                    
+        except Exception as e:
+            logger.warning(f"⚠️ Could not load conflicts model: {e}")
+    
+    def _load_addicted_model(self):
+        """Load the addicted score regression model from Notebook 08."""
+        try:
+            # Try to load from MLflow first
+            try:
+                model_uri = "models:/addicted_score_regressor/latest"
+                self.addicted_model = mlflow.sklearn.load_model(model_uri)
+                logger.info(f"✅ Loaded addicted model from MLflow: {model_uri}")
+            except:
+                # Try local paths
+                model_paths = [
+                    'models/addicted_score_model.joblib',
+                    '../models/addicted_score_model.joblib',
+                    'notebooks/models/addicted_score_model.joblib'
+                ]
+                
+                for path in model_paths:
+                    try:
+                        self.addicted_model = joblib.load(path)
+                        logger.info(f"✅ Loaded addicted model from: {path}")
+                        break
+                    except:
+                        continue
+            
+            # Load scaler
+            scaler_paths = [
+                'models/addicted_score_scaler.joblib',
+                '../models/addicted_score_scaler.joblib',
+                'notebooks/models/addicted_score_scaler.joblib'
+            ]
+            
+            for path in scaler_paths:
+                try:
+                    self.addicted_scaler = joblib.load(path)
+                    logger.info(f"✅ Loaded addicted scaler from: {path}")
+                    break
+                except:
+                    continue
+                    
+        except Exception as e:
+            logger.warning(f"⚠️ Could not load addicted model: {e}")
+    
+    def _load_clustering_model(self):
+        """Load the clustering model from Notebook 09."""
+        try:
+            # Try to load from different paths
+            model_paths = [
+                'models/clustering_model.joblib',
+                '../models/clustering_model.joblib',
+                'notebooks/models/clustering_model.joblib'
+            ]
+            
+            for path in model_paths:
+                try:
+                    self.clustering_model = joblib.load(path)
+                    logger.info(f"✅ Loaded clustering model from: {path}")
+                    break
+                except:
+                    continue
+            
+            # Load scaler
+            scaler_paths = [
+                'models/clustering_scaler.joblib',
+                '../models/clustering_scaler.joblib',
+                'notebooks/models/clustering_scaler.joblib'
+            ]
+            
+            for path in scaler_paths:
+                try:
+                    self.clustering_scaler = joblib.load(path)
+                    logger.info(f"✅ Loaded clustering scaler from: {path}")
+                    break
+                except:
+                    continue
+            
+            # Load cluster labels
+            labels_paths = [
+                'models/cluster_labels.joblib',
+                '../models/cluster_labels.joblib',
+                'notebooks/models/cluster_labels.joblib'
+            ]
+            
+            for path in labels_paths:
+                try:
+                    self.cluster_labels = joblib.load(path)
+                    logger.info(f"✅ Loaded cluster labels from: {path}")
+                    break
+                except:
+                    continue
+            
+            # Load feature names
+            feature_paths = [
+                'models/clustering_feature_names.joblib',
+                '../models/clustering_feature_names.joblib',
+                'notebooks/models/clustering_feature_names.joblib'
+            ]
+            
+            for path in feature_paths:
+                try:
+                    self.feature_names['clustering'] = joblib.load(path)
+                    logger.info(f"✅ Loaded clustering feature names from: {path}")
+                    break
+                except:
+                    continue
+                    
+        except Exception as e:
+            logger.warning(f"⚠️ Could not load clustering model: {e}")
+    
+    def predict_conflicts(self, data: Dict) -> Dict:
+        """
+        Predict conflicts over social media using Notebook 07 model.
+        
+        Args:
+            data: Dictionary containing student data
+            
+        Returns:
+            Dictionary containing conflicts prediction results
+        """
+        if self.conflicts_model is None or self.conflicts_scaler is None:
+            return {
+                "error": "Conflicts model not loaded. Please run notebook 07 first.",
+                "timestamp": datetime.now().isoformat()
+            }
+        
+        try:
+            # Prepare features for conflicts model (only 4 features needed)
+            features = {}
+            
+            # Extract required features for conflicts model
+            if 'Mental_Health_Score' in data:
+                features['Mental_Health_Score'] = float(data['Mental_Health_Score'])
+            if 'Age' in data:
+                features['Age'] = float(data['Age'])
+            
+            # Handle gender encoding
+            if 'Gender' in data:
+                gender = data['Gender'].lower()
+                if gender in ['male', 'm']:
+                    features['Gender_Male'] = 1
+                    features['Gender_Female'] = 0
+                elif gender in ['female', 'f']:
+                    features['Gender_Male'] = 0
+                    features['Gender_Female'] = 1
+                else:
+                    features['Gender_Male'] = 0
+                    features['Gender_Female'] = 0
+            
+            # Create feature vector for scaler (2 features)
+            scaler_features = ['Mental_Health_Score', 'Age']
+            feature_vector = []
+            for feature in scaler_features:
+                if feature in features:
+                    feature_vector.append(features[feature])
+                else:
+                    feature_vector.append(0)
+            
+            # Scale the features
+            feature_vector_scaled = self.conflicts_scaler.transform([feature_vector])
+            
+            # Create full feature vector for model (4 features)
+            model_features = ['Mental_Health_Score', 'Age', 'Gender_Female', 'Gender_Male']
+            full_feature_vector = []
+            for feature in model_features:
+                if feature in features:
+                    full_feature_vector.append(features[feature])
+                else:
+                    full_feature_vector.append(0)
+            
+            # Combine scaled features with categorical features
+            final_vector = list(feature_vector_scaled[0]) + full_feature_vector[2:]  # Use scaled first 2, raw last 2
+            
+            # Make prediction
+            prediction = self.conflicts_model.predict([final_vector])[0]
+            probability = self.conflicts_model.predict_proba([final_vector])[0]
+            
+            # Determine conflict level
+            if prediction == 1:
+                conflict_level = 'High Risk'
+                recommendation = 'Immediate intervention needed: Conflict resolution training, communication skills'
+            else:
+                conflict_level = 'Low Risk'
+                recommendation = 'Monitor and provide resources: Healthy communication guidelines'
+            
+            # Calculate confidence
+            confidence = max(probability)
+            
+            return {
+                'predicted_conflicts': int(prediction),
+                'conflict_level': conflict_level,
+                'recommendation': recommendation,
+                'confidence': float(confidence),
+                'timestamp': datetime.now().isoformat(),
+                'model_type': 'conflicts_prediction'
+            }
+            
+        except Exception as e:
+            return {
+                'error': str(e),
+                'timestamp': datetime.now().isoformat()
+            }
+    
+    def predict_addicted_score(self, data: Dict) -> Dict:
+        """
+        Predict addicted score using Notebook 08 model.
+        
+        Args:
+            data: Dictionary containing student data
+            
+        Returns:
+            Dictionary containing addicted score prediction results
+        """
+        if self.addicted_model is None or self.addicted_scaler is None:
+            return {
+                "error": "Addicted score model not loaded. Please run notebook 08 first.",
+                "timestamp": datetime.now().isoformat()
+            }
+        
+        try:
+            # Prepare features for addicted score model (3 features needed)
+            features = {}
+            
+            # Extract required features for addicted score model
+            if 'Age' in data:
+                features['Age'] = float(data['Age'])
+            if 'Mental_Health_Score' in data:
+                features['Mental_Health_Score'] = float(data['Mental_Health_Score'])
+                # Add squared feature
+                features['mental_health_squared'] = features['Mental_Health_Score'] ** 2
+            if 'Conflicts_Over_Social_Media' in data:
+                features['Conflicts_Over_Social_Media'] = float(data['Conflicts_Over_Social_Media'])
+            
+            # Handle gender encoding
+            if 'Gender' in data:
+                gender = data['Gender'].lower()
+                if gender in ['male', 'm']:
+                    features['Gender_Male'] = 1
+                    features['Gender_Female'] = 0
+                elif gender in ['female', 'f']:
+                    features['Gender_Male'] = 0
+                    features['Gender_Female'] = 1
+                else:
+                    features['Gender_Male'] = 0
+                    features['Gender_Female'] = 0
+            
+            # Create feature vector for scaler (3 features)
+            scaler_features = ['Mental_Health_Score', 'Age', 'Conflicts_Over_Social_Media']
+            feature_vector = []
+            for feature in scaler_features:
+                if feature in features:
+                    feature_vector.append(features[feature])
+                else:
+                    feature_vector.append(0)
+            
+            # Scale the features
+            feature_vector_scaled = self.addicted_scaler.transform([feature_vector])
+            
+            # Create full feature vector for model (6 features)
+            model_features = ['Mental_Health_Score', 'Age', 'Conflicts_Over_Social_Media', 'mental_health_squared', 'Gender_Female', 'Gender_Male']
+            full_feature_vector = []
+            for feature in model_features:
+                if feature in features:
+                    full_feature_vector.append(features[feature])
+                else:
+                    full_feature_vector.append(0)
+            
+            # Combine scaled features with additional features
+            final_vector = list(feature_vector_scaled[0]) + full_feature_vector[3:]  # Use scaled first 3, raw last 3
+            
+            # Make prediction
+            prediction = self.addicted_model.predict([final_vector])[0]
+            
+            # Determine addiction level
+            if prediction >= 8:
+                addiction_level = 'Very High'
+            elif prediction >= 6:
+                addiction_level = 'High'
+            elif prediction >= 4:
+                addiction_level = 'Moderate'
+            else:
+                addiction_level = 'Low'
+            
+            # Calculate confidence (simplified)
+            confidence = 0.8  # Default confidence
+            
+            return {
+                'predicted_score': float(prediction),
+                'addiction_level': addiction_level,
+                'confidence': float(confidence),
+                'timestamp': datetime.now().isoformat(),
+                'model_type': 'addicted_score_regression'
+            }
+            
+        except Exception as e:
+            return {
+                'error': str(e),
+                'timestamp': datetime.now().isoformat()
+            }
+    
+    def predict_cluster(self, data: Dict) -> Dict:
+        """
+        Predict cluster assignment using Notebook 09 model.
+        
+        Args:
+            data: Dictionary containing student data
+            
+        Returns:
+            Dictionary containing cluster prediction results
+        """
+        if self.clustering_model is None or self.clustering_scaler is None:
+            return {
+                "error": "Clustering model not loaded. Please run notebook 09 first.",
+                "timestamp": datetime.now().isoformat()
+            }
+        
+        try:
+            # Prepare features
+            features = {}
+            
+            # Extract numeric features
+            if 'Age' in data:
+                features['Age'] = float(data['Age'])
+            if 'Avg_Daily_Usage_Hours' in data:
+                features['Avg_Daily_Usage_Hours'] = float(data['Avg_Daily_Usage_Hours'])
+            if 'Sleep_Hours_Per_Night' in data:
+                features['Sleep_Hours_Per_Night'] = float(data['Sleep_Hours_Per_Night'])
+            if 'Mental_Health_Score' in data:
+                features['Mental_Health_Score'] = float(data['Mental_Health_Score'])
+            if 'Conflicts_Over_Social_Media' in data:
+                features['Conflicts_Over_Social_Media'] = float(data['Conflicts_Over_Social_Media'])
+            if 'Addicted_Score' in data:
+                features['Addicted_Score'] = float(data['Addicted_Score'])
+            
+            # Handle categorical features
+            if 'Gender' in data:
+                gender = data['Gender'].lower()
+                if gender in ['male', 'm']:
+                    features['Is_Female'] = 0
+                elif gender in ['female', 'f']:
+                    features['Is_Female'] = 1
+                else:
+                    features['Is_Female'] = 0
+            
+            if 'Academic_Level' in data:
+                level = data['Academic_Level'].lower()
+                if 'undergraduate' in level:
+                    features['Is_Undergraduate'] = 1
+                    features['Is_Graduate'] = 0
+                    features['Is_High_School'] = 0
+                elif 'graduate' in level:
+                    features['Is_Undergraduate'] = 0
+                    features['Is_Graduate'] = 1
+                    features['Is_High_School'] = 0
+                elif 'high school' in level:
+                    features['Is_Undergraduate'] = 0
+                    features['Is_Graduate'] = 0
+                    features['Is_High_School'] = 1
+                else:
+                    features['Is_Undergraduate'] = 0
+                    features['Is_Graduate'] = 0
+                    features['Is_High_School'] = 0
+            
+            # Create behavioral features
+            if 'Avg_Daily_Usage_Hours' in features:
+                features['High_Usage'] = 1 if features['Avg_Daily_Usage_Hours'] >= 6 else 0
+            if 'Sleep_Hours_Per_Night' in features:
+                features['Low_Sleep'] = 1 if features['Sleep_Hours_Per_Night'] <= 6 else 0
+            if 'Mental_Health_Score' in features:
+                features['Poor_Mental_Health'] = 1 if features['Mental_Health_Score'] <= 5 else 0
+            if 'Conflicts_Over_Social_Media' in features:
+                features['High_Conflict'] = 1 if features['Conflicts_Over_Social_Media'] >= 3 else 0
+            if 'Addicted_Score' in features:
+                features['High_Addiction'] = 1 if features['Addicted_Score'] >= 7 else 0
+            
+            # Create interaction features
+            if 'Avg_Daily_Usage_Hours' in features and 'Sleep_Hours_Per_Night' in features:
+                features['Usage_Sleep_Ratio'] = features['Avg_Daily_Usage_Hours'] / features['Sleep_Hours_Per_Night']
+            if 'Mental_Health_Score' in features and 'Avg_Daily_Usage_Hours' in features:
+                features['Mental_Health_Usage_Ratio'] = features['Mental_Health_Score'] / features['Avg_Daily_Usage_Hours']
+            
+            # Create feature vector in the correct order
+            feature_vector = []
+            for feature in self.feature_names.get('clustering', []):
+                if feature in features:
+                    feature_vector.append(features[feature])
+                else:
+                    feature_vector.append(0)
+            
+            # Scale the features
+            feature_vector_scaled = self.clustering_scaler.transform([feature_vector])
+            
+            # Make prediction
+            cluster_prediction = self.clustering_model.predict(feature_vector_scaled)[0]
+            
+            # Get cluster label
+            cluster_label = self.cluster_labels.get(cluster_prediction, f'Cluster_{cluster_prediction}') if self.cluster_labels else f'Cluster_{cluster_prediction}'
+            
+            # Determine risk level based on cluster characteristics
+            if 'High-Usage' in cluster_label and 'High-Addiction' in cluster_label:
+                risk_level = 'High Risk'
+                recommendation = 'Intensive intervention needed: Digital detox programs, counseling, parental monitoring'
+            elif 'High-Usage' in cluster_label or 'Poor-Health' in cluster_label:
+                risk_level = 'Moderate Risk'
+                recommendation = 'Targeted intervention recommended: Screen time limits, mental health support, sleep hygiene'
+            else:
+                risk_level = 'Low Risk'
+                recommendation = 'Monitor and provide resources: Educational materials, healthy usage guidelines'
+            
+            # Calculate confidence based on distance to cluster center
+            try:
+                cluster_center = self.clustering_model.cluster_centers_[cluster_prediction]
+                distance = np.linalg.norm(feature_vector_scaled[0] - cluster_center)
+                confidence = max(0.1, 1 - distance/10)  # Normalize distance to confidence
+            except:
+                confidence = 0.8  # Default confidence
+            
+            return {
+                'cluster_id': int(cluster_prediction),
+                'cluster_label': cluster_label,
+                'risk_level': risk_level,
+                'recommendation': recommendation,
+                'confidence': float(confidence),
+                'timestamp': datetime.now().isoformat(),
+                'model_type': 'clustering_analysis'
+            }
+            
+        except Exception as e:
+            return {
+                'error': str(e),
+                'timestamp': datetime.now().isoformat()
+            }
+    
+    def predict_all(self, data: Dict) -> Dict:
+        """
+        Make predictions using all three models.
+        
+        Args:
+            data: Dictionary containing student data
+            
+        Returns:
+            Dictionary containing all prediction results
+        """
+        results = {
+            'conflicts_prediction': self.predict_conflicts(data),
+            'addicted_score_prediction': self.predict_addicted_score(data),
+            'clustering_prediction': self.predict_cluster(data),
+            'timestamp': datetime.now().isoformat(),
+            'student_data': data
+        }
+        
+        return results
+    
+    def get_model_status(self) -> Dict:
+        """
+        Get status of all models.
+        
+        Returns:
+            Dictionary containing model status information
+        """
+        return {
+            'conflicts_model_loaded': self.conflicts_model is not None,
+            'addicted_model_loaded': self.addicted_model is not None,
+            'clustering_model_loaded': self.clustering_model is not None,
+            'conflicts_scaler_loaded': self.conflicts_scaler is not None,
+            'addicted_scaler_loaded': self.addicted_scaler is not None,
+            'clustering_scaler_loaded': self.clustering_scaler is not None,
+            'cluster_labels_loaded': self.cluster_labels is not None,
+            'feature_names_loaded': len(self.feature_names) > 0,
+            'timestamp': datetime.now().isoformat()
+        }
+
+
+def create_unified_prediction_service() -> UnifiedSocialMediaPredictionService:
+    """
+    Factory function to create a unified prediction service.
+    
+    Returns:
+        Initialized unified prediction service
+    """
+    return UnifiedSocialMediaPredictionService()
+
+
+# Example usage and testing functions
+def test_unified_prediction_service():
+    """Test the unified prediction service with sample data."""
+    try:
+        # Create prediction service
+        service = create_unified_prediction_service()
+        
+        # Get model status
+        status = service.get_model_status()
+        print("📊 Model Status:")
+        print(json.dumps(status, indent=2))
+        
+        # Test with sample data
+        sample_data = {
+            'Age': 20,
+            'Gender': 'Female',
+            'Academic_Level': 'Undergraduate',
+            'Avg_Daily_Usage_Hours': 6.5,
+            'Sleep_Hours_Per_Night': 7.0,
+            'Mental_Health_Score': 7,
+            'Conflicts_Over_Social_Media': 2,
+            'Addicted_Score': 6,
+            'Relationship_Status': 'Single',
+            'Affects_Academic_Performance': 'Yes',
+            'Most_Used_Platform': 'Instagram'
+        }
+        
+        # Make all predictions
+        results = service.predict_all(sample_data)
+        
+        print("\n📊 Unified Prediction Results:")
+        print(json.dumps(results, indent=2))
+        
+        return results
+        
+    except Exception as e:
+        print(f"❌ Test failed: {e}")
+        return None
+
+
+if __name__ == "__main__":
+    test_unified_prediction_service()