Create main.py

main.py

@@ -0,0 +1,825 @@
+"""
+ATAR Prediction System with ML Ensemble
+All-in-one Gradio app with training, inference, and HF Model Repo integration
+Optimized for ZeroGPU (no persistent storage needed)
+
+Author: Victor Academy
+"""
+
+import gradio as gr
+import numpy as np
+import pandas as pd
+import json
+import os
+from typing import List, Dict, Any, Tuple
+import warnings
+warnings.filterwarnings('ignore')
+
+# ZeroGPU support for Hugging Face Spaces
+try:
+    import spaces
+    ZEROGPU_AVAILABLE = True
+    print("✅ ZeroGPU support enabled")
+except ImportError:
+    ZEROGPU_AVAILABLE = False
+    print("ℹ️ Running without ZeroGPU (local mode)")
+
+# ML Libraries
+try:
+    from sklearn.ensemble import GradientBoostingRegressor, RandomForestRegressor
+    from sklearn.linear_model import Ridge
+    from sklearn.preprocessing import StandardScaler
+    from sklearn.model_selection import train_test_split
+    import joblib
+except ImportError:
+    print("⚠️ Installing scikit-learn...")
+    os.system("pip install scikit-learn joblib")
+    from sklearn.ensemble import GradientBoostingRegressor, RandomForestRegressor
+    from sklearn.linear_model import Ridge
+    from sklearn.preprocessing import StandardScaler
+    from sklearn.model_test_split import train_test_split
+    import joblib
+
+# Hugging Face Hub for model storage
+try:
+    from huggingface_hub import HfApi, login, hf_hub_download
+except ImportError:
+    print("⚠️ Installing huggingface_hub...")
+    os.system("pip install huggingface_hub")
+    from huggingface_hub import HfApi, login, hf_hub_download
+
+# ============================================
+# CONFIGURATION
+# ============================================
+
+HF_MODEL_REPO = "Spestly/VAML-ATAR"  # Your HF model repo
+FEATURE_COUNT = 18
+MODEL_VERSION = "v1.0.0"  # Semantic versioning: major.minor.patch
+
+# HF Token - REQUIRED for training (set as environment variable in HF Space settings)
+# Get from: https://huggingface.co/settings/tokens (write access needed)
+# In HF Space: Settings → Variables and secrets → Add: HF_TOKEN = hf_xxxxx
+HF_TOKEN = os.environ.get('HF_TOKEN', None)
+
+if not HF_TOKEN:
+    print("⚠️ Warning: HF_TOKEN not set! Training will fail.")
+    print("   Set HF_TOKEN environment variable in Space settings.")
+else:
+    print("✅ HF_TOKEN found")
+
+# Subject scaling data (2024 HSC data)
+SUBJECT_SCALING_DATA = {
+    'Mathematics Extension 2': {'scaling_factor': 1.1943, 'mean': 71.2, 'std': 12.5, 'difficulty': 'very_hard'},
+    'Mathematics Extension 1': {'scaling_factor': 1.1547, 'mean': 69.8, 'std': 13.1, 'difficulty': 'hard'},
+    'Mathematics Advanced': {'scaling_factor': 1.0821, 'mean': 72.5, 'std': 11.8, 'difficulty': 'medium'},
+    'Physics': {'scaling_factor': 1.1037, 'mean': 70.3, 'std': 12.2, 'difficulty': 'hard'},
+    'Chemistry': {'scaling_factor': 1.0956, 'mean': 71.1, 'std': 11.9, 'difficulty': 'hard'},
+    'Biology': {'scaling_factor': 1.0234, 'mean': 73.8, 'std': 10.5, 'difficulty': 'medium'},
+    'English Advanced': {'scaling_factor': 1.0000, 'mean': 75.2, 'std': 9.8, 'difficulty': 'medium'},
+    'English Standard': {'scaling_factor': 0.9234, 'mean': 68.5, 'std': 11.2, 'difficulty': 'easy'},
+    'Economics': {'scaling_factor': 1.0645, 'mean': 72.8, 'std': 11.3, 'difficulty': 'medium'},
+    'Business Studies': {'scaling_factor': 0.9856, 'mean': 71.2, 'std': 10.8, 'difficulty': 'medium'},
+    'Legal Studies': {'scaling_factor': 0.9923, 'mean': 72.5, 'std': 10.2, 'difficulty': 'medium'},
+    'Modern History': {'scaling_factor': 1.0112, 'mean': 73.1, 'std': 10.6, 'difficulty': 'medium'},
+    'Ancient History': {'scaling_factor': 1.0089, 'mean': 72.9, 'std': 10.4, 'difficulty': 'medium'},
+    'PDHPE': {'scaling_factor': 0.9639, 'mean': 70.8, 'std': 11.5, 'difficulty': 'easy'},
+    'Software Design & Development': {'scaling_factor': 1.0423, 'mean': 71.6, 'std': 12.1, 'difficulty': 'medium'},
+    'Visual Arts': {'scaling_factor': 0.9734, 'mean': 76.2, 'std': 8.9, 'difficulty': 'easy'},
+    'Music 2': {'scaling_factor': 1.0567, 'mean': 77.5, 'std': 9.2, 'difficulty': 'medium'},
+    'Geography': {'scaling_factor': 0.9912, 'mean': 72.3, 'std': 10.7, 'difficulty': 'medium'},
+    'Industrial Technology': {'scaling_factor': 0.9523, 'mean': 69.7, 'std': 11.8, 'difficulty': 'easy'},
+}
+
+# ============================================
+# FEATURE ENGINEERING
+# ============================================
+
+def extract_features(subjects: List[Dict]) -> np.ndarray:
+    """
+    Extract 18 features from subject data
+    
+    Features:
+    - 10 subject marks (padded with 0 if fewer subjects)
+    - Average mark
+    - Standard deviation
+    - High-scaling subject count
+    - Overall trend score
+    - Assessment count score
+    - Top mark quality
+    - Bottom mark quality
+    - Has good English flag
+    """
+    # Get top 10 subjects by mark
+    sorted_subjects = sorted(subjects, key=lambda x: x.get('raw_mark', 0), reverse=True)[:10]
+    
+    # Extract marks
+    marks = [s.get('raw_mark', 0) for s in sorted_subjects]
+    while len(marks) < 10:
+        marks.append(0)
+    
+    # Normalize to 0-1
+    marks_normalized = [m / 100.0 for m in marks[:10]]
+    
+    # Calculate derived features
+    valid_marks = [m for m in marks if m > 0]
+    avg_mark = np.mean(valid_marks) if valid_marks else 0
+    std_dev = np.std(valid_marks) if len(valid_marks) > 1 else 0
+    
+    # Count high-scaling subjects (factor > 1.05)
+    high_scaling_count = sum(1 for s in sorted_subjects 
+                            if SUBJECT_SCALING_DATA.get(s.get('subject_name', ''), {}).get('scaling_factor', 1.0) > 1.05)
+    
+    # Trend score (0-1)
+    trend_map = {'improving': 1.0, 'stable': 0.5, 'declining': 0.0}
+    trends = [trend_map.get(s.get('trend', 'stable'), 0.5) for s in sorted_subjects]
+    trend_score = np.mean(trends) if trends else 0.5
+    
+    # Assessment count score (normalized)
+    assessment_counts = [s.get('assessment_count', 1) for s in sorted_subjects]
+    assessment_score = min(np.mean(assessment_counts) / 10.0, 1.0)
+    
+    # Quality metrics
+    top_mark_quality = marks[0] / 90.0 if marks[0] > 0 else 0
+    bottom_mark_quality = marks[-1] / 90.0 if marks[-1] > 0 else 0
+    
+    # English quality flag
+    english_subjects = [s for s in sorted_subjects if 'English' in s.get('subject_name', '')]
+    has_good_english = 1.0 if english_subjects and english_subjects[0].get('raw_mark', 0) >= 80 else 0.0
+    
+    # Combine features
+    features = marks_normalized + [
+        avg_mark / 100.0,
+        min(std_dev / 20.0, 1.0),
+        high_scaling_count / 10.0,
+        trend_score,
+        assessment_score,
+        top_mark_quality,
+        bottom_mark_quality,
+        has_good_english
+    ]
+    
+    return np.array(features, dtype=np.float32)
+
+# ============================================
+# DATA GENERATION (for training)
+# ============================================
+
+def generate_synthetic_data(n_samples: int = 10000) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Generate synthetic ATAR training data using UAC formula
+    """
+    np.random.seed(42)
+    
+    X = []
+    y = []
+    
+    for _ in range(n_samples):
+        # Generate 10 subject marks
+        subject_marks = np.random.normal(73, 10, 10)
+        subject_marks = np.clip(subject_marks, 40, 100)
+        subject_marks = np.sort(subject_marks)[::-1]  # Sort descending
+        
+        # Derived features
+        avg_mark = np.mean(subject_marks)
+        std_dev = np.std(subject_marks)
+        high_scaling_count = np.random.randint(0, 6)
+        trend_score = np.random.uniform(0, 1)
+        assessment_count = np.random.uniform(0, 1)
+        top_mark_quality = min(subject_marks[0] / 90, 1)
+        bottom_mark_quality = min(subject_marks[-1] / 90, 1)
+        has_good_english = 1 if subject_marks[0] >= 80 else 0
+        
+        # Calculate ATAR using UAC formula
+        # Aggregate scaled marks (simplified)
+        aggregate = sum([m * 2 / 50.0 for m in subject_marks])
+        
+        # Base ATAR calculation
+        base_atar = 99.95 * (aggregate / 500) ** 0.85
+        
+        # Adjustments
+        atar = base_atar + (high_scaling_count - 2.5) * 0.5
+        atar += (trend_score - 0.5) * 2
+        atar += np.random.normal(0, 0.5)  # Add noise
+        atar = np.clip(atar, 30, 99.95)
+        
+        # Features (normalized)
+        features = list(subject_marks / 100) + [
+            avg_mark / 100,
+            min(std_dev / 20, 1),
+            high_scaling_count / 10,
+            trend_score,
+            assessment_count,
+            top_mark_quality,
+            bottom_mark_quality,
+            has_good_english
+        ]
+        
+        X.append(features)
+        y.append(atar)
+    
+    return np.array(X), np.array(y)
+
+# ============================================
+# MODEL TRAINING
+# ============================================
+
+class ATARMLEnsemble:
+    """
+    ML Ensemble for ATAR prediction
+    Uses Gradient Boosting + Random Forest + Ridge Regression
+    """
+    def __init__(self):
+        self.scaler = StandardScaler()
+        self.models = {
+            'gb': GradientBoostingRegressor(n_estimators=200, max_depth=5, learning_rate=0.1, random_state=42),
+            'rf': RandomForestRegressor(n_estimators=200, max_depth=10, random_state=42),
+            'ridge': Ridge(alpha=1.0, random_state=42)
+        }
+        self.weights = {'gb': 0.5, 'rf': 0.3, 'ridge': 0.2}  # Ensemble weights
+        self.is_trained = False
+    
+    def train(self, X, y, X_test=None, y_test=None):
+        """Train all models in the ensemble"""
+        print(f"🚀 Training on {len(X)} samples...")
+        
+        # Scale features
+        X_scaled = self.scaler.fit_transform(X)
+        
+        # Train each model
+        for name, model in self.models.items():
+            print(f"Training {name}...")
+            model.fit(X_scaled, y)
+        
+        self.is_trained = True
+        self.training_samples = len(X)
+        
+        # Store metrics for versioning
+        train_pred = self.predict(X)
+        self.train_mae = np.mean(np.abs(train_pred - y))
+        
+        if X_test is not None and y_test is not None:
+            test_pred = self.predict(X_test)
+            self.test_mae = np.mean(np.abs(test_pred - y_test))
+        else:
+            self.test_mae = None
+        
+        print("✅ Ensemble training complete!")
+    
+    def predict(self, X):
+        """Predict using weighted ensemble"""
+        if not self.is_trained:
+            raise ValueError("Model not trained! Train first or load from HF.")
+        
+        X_scaled = self.scaler.transform(X)
+        
+        # Get predictions from each model
+        predictions = {}
+        for name, model in self.models.items():
+            predictions[name] = model.predict(X_scaled)
+        
+        # Weighted average
+        final_pred = sum(predictions[name] * self.weights[name] for name in self.models.keys())
+        
+        return final_pred
+    
+    def save_local(self, path='models'):
+        """Save models locally"""
+        os.makedirs(path, exist_ok=True)
+        joblib.dump(self.scaler, f'{path}/scaler.pkl')
+        for name, model in self.models.items():
+            joblib.dump(model, f'{path}/{name}.pkl')
+        joblib.dump(self.weights, f'{path}/weights.pkl')
+        print(f"✅ Models saved to {path}/")
+    
+    def load_local(self, path='models'):
+        """Load models from local path"""
+        self.scaler = joblib.load(f'{path}/scaler.pkl')
+        for name in self.models.keys():
+            self.models[name] = joblib.load(f'{path}/{name}.pkl')
+        self.weights = joblib.load(f'{path}/weights.pkl')
+        self.is_trained = True
+        print(f"✅ Models loaded from {path}/")
+
+# Global model instance
+ensemble = ATARMLEnsemble()
+
+# ============================================
+# HUGGING FACE INTEGRATION
+# ============================================
+
+def upload_to_hf(version: str = None, repo_name: str = HF_MODEL_REPO):
+    """
+    Upload trained models to HF Model Repo with versioning
+    
+    Versioning strategy:
+    - models/{version}/  → Specific version (e.g., models/v1.0.0/)
+    - models/latest/     → Always points to newest version
+    - metadata.json      → Tracks all versions and metrics
+    """
+    try:
+        # Check if HF_TOKEN is set
+        if not HF_TOKEN:
+            return "❌ HF_TOKEN not set! Please set it as environment variable in Space settings."
+        
+        # Login to HF
+        login(token=HF_TOKEN)
+        api = HfApi()
+        
+        # Use provided version or generate from timestamp
+        if version is None:
+            from datetime import datetime
+            version = datetime.now().strftime("v%Y%m%d_%H%M%S")
+        
+        # Create repo if doesn't exist
+        try:
+            api.create_repo(repo_id=repo_name, repo_type="model", private=False)
+            print(f"✅ Created repo: {repo_name}")
+        except:
+            print(f"ℹ️ Repo {repo_name} already exists")
+        
+        # Upload model files to versioned folder
+        files = ['scaler.pkl', 'gb.pkl', 'rf.pkl', 'ridge.pkl', 'weights.pkl']
+        
+        print(f"📤 Uploading version: {version}")
+        
+        # Upload to specific version folder
+        for file in files:
+            api.upload_file(
+                path_or_fileobj=f'models/{file}',
+                path_in_repo=f'models/{version}/{file}',
+                repo_id=repo_name,
+                repo_type="model"
+            )
+        
+        # Also upload to 'latest' folder (for easy access)
+        for file in files:
+            api.upload_file(
+                path_or_fileobj=f'models/{file}',
+                path_in_repo=f'models/latest/{file}',
+                repo_id=repo_name,
+                repo_type="model"
+            )
+        
+        # Download existing metadata if it exists
+        try:
+            import tempfile
+            temp_dir = tempfile.mkdtemp()
+            metadata_path = hf_hub_download(
+                repo_id=repo_name,
+                filename="metadata.json",
+                repo_type="model",
+                cache_dir=temp_dir
+            )
+            with open(metadata_path, 'r') as f:
+                metadata = json.load(f)
+        except:
+            metadata = {
+                "versions": [],
+                "latest_version": None,
+                "model_type": "ML Ensemble (Gradient Boosting + Random Forest + Ridge)",
+                "feature_count": FEATURE_COUNT
+            }
+        
+        # Add new version to metadata
+        from datetime import datetime
+        new_version_info = {
+            "version": version,
+            "timestamp": datetime.now().isoformat(),
+            "training_samples": getattr(ensemble, 'training_samples', "unknown"),
+            "train_mae": getattr(ensemble, 'train_mae', None),
+            "test_mae": getattr(ensemble, 'test_mae', None),
+            "model_files": files
+        }
+        
+        metadata["versions"].append(new_version_info)
+        metadata["latest_version"] = version
+        metadata["total_versions"] = len(metadata["versions"])
+        
+        # Save updated metadata locally
+        with open('models/metadata.json', 'w') as f:
+            json.dump(metadata, f, indent=2)
+        
+        # Upload metadata
+        api.upload_file(
+            path_or_fileobj='models/metadata.json',
+            path_in_repo='metadata.json',
+            repo_id=repo_name,
+            repo_type="model"
+        )
+        
+        return f"""✅ Models uploaded successfully!
+
+📦 Version: {version}
+🔗 Repo: https://huggingface.co/{repo_name}
+📊 Total versions: {len(metadata['versions'])}
+
+Access:
+- Latest: models/latest/
+- This version: models/{version}/
+- All versions: See metadata.json
+"""
+    except Exception as e:
+        return f"❌ Upload failed: {str(e)}"
+
+def download_from_hf(version: str = "latest", repo_name: str = HF_MODEL_REPO, token: str = None):
+    """
+    Download models from HF Model Repo
+    
+    Args:
+        version: Version to load ('latest', 'v1.0.0', etc.)
+        repo_name: HF model repo name
+        token: HF token (optional - only needed for private repos)
+    """
+    try:
+        os.makedirs('models', exist_ok=True)
+        
+        # Use provided token, or environment variable, or None (for public repos)
+        auth_token = token or HF_TOKEN
+        
+        # Determine path based on version
+        path_prefix = f"models/{version}/"
+        
+        files = ['scaler.pkl', 'gb.pkl', 'rf.pkl', 'ridge.pkl', 'weights.pkl']
+        
+        print(f"📥 Downloading version: {version}")
+        if auth_token:
+            print("🔒 Using authentication (private repo)")
+        else:
+            print("🌐 No token - assuming public repo")
+        
+        for file in files:
+            local_path = hf_hub_download(
+                repo_id=repo_name,
+                filename=f"{path_prefix}{file}",
+                repo_type="model",
+                cache_dir='models',
+                token=auth_token  # ← Added token support
+            )
+            # Copy to models/ directory
+            import shutil
+            shutil.copy(local_path, f'models/{file}')
+        
+        # Load into ensemble
+        ensemble.load_local('models')
+        
+        # Try to get version info from metadata
+        try:
+            metadata_path = hf_hub_download(
+                repo_id=repo_name,
+                filename="metadata.json",
+                repo_type="model",
+                cache_dir='models',
+                token=auth_token  # ← Added token support
+            )
+            with open(metadata_path, 'r') as f:
+                metadata = json.load(f)
+            
+            version_info = next((v for v in metadata["versions"] if v["version"] == version), None)
+            
+            info_str = f"""✅ Models loaded successfully!
+
+📦 Version: {version}
+📅 Trained: {version_info.get('timestamp', 'Unknown') if version_info else 'Unknown'}
+📊 Train MAE: {version_info.get('train_mae', 'N/A') if version_info else 'N/A'} ATAR points
+📊 Test MAE: {version_info.get('test_mae', 'N/A') if version_info else 'N/A'} ATAR points
+🔗 Repo: https://huggingface.co/{repo_name}
+"""
+            return info_str
+        except:
+            return f"✅ Models loaded from https://huggingface.co/{repo_name} ({version})"
+        
+    except Exception as e:
+        return f"❌ Download failed: {str(e)}\nTrain the model first or check version name!"
+
+# ============================================
+# PREDICTION LOGIC
+# ============================================
+
+def predict_atar(subjects: List[Dict]) -> Dict[str, Any]:
+    """
+    Predict ATAR using ML ensemble
+    Auto-loads model from HF if not loaded
+    """
+    # Auto-load model if not trained
+    if not ensemble.is_trained:
+        result = download_from_hf()
+        if "❌" in result:
+            return {
+                'error': 'Model not trained or available. Please train first!',
+                'predicted_atar': 0,
+                'confidence': 0
+            }
+    
+    # Extract features
+    features = extract_features(subjects)
+    X = features.reshape(1, -1)
+    
+    # Predict
+    predicted_atar = ensemble.predict(X)[0]
+    predicted_atar = np.clip(predicted_atar, 30, 99.95)
+    
+    # Calculate confidence (based on data quality)
+    confidence = calculate_confidence(subjects)
+    
+    # Generate insights
+    insights = generate_insights(subjects, predicted_atar)
+    recommendations = generate_recommendations(subjects, predicted_atar)
+    
+    return {
+        'predicted_atar': round(predicted_atar, 2),
+        'confidence': round(confidence, 2),
+        'insights': insights,
+        'recommendations': recommendations
+    }
+
+def calculate_confidence(subjects: List[Dict]) -> float:
+    """Calculate prediction confidence based on data quality"""
+    if not subjects:
+        return 0.0
+    
+    # Factors affecting confidence
+    assessment_completeness = min(sum(s.get('assessment_count', 0) for s in subjects) / (len(subjects) * 5), 1.0)
+    subject_count_factor = min(len(subjects) / 10, 1.0)
+    has_trends = sum(1 for s in subjects if 'trend' in s) / len(subjects)
+    
+    confidence = 0.4 * assessment_completeness + 0.3 * subject_count_factor + 0.3 * has_trends
+    return confidence
+
+def generate_insights(subjects: List[Dict], predicted_atar: float) -> List[str]:
+    """Generate insights based on subject performance"""
+    insights = []
+    
+    # Performance level
+    if predicted_atar >= 95:
+        insights.append("🎯 Excellent performance! You're on track for elite universities.")
+    elif predicted_atar >= 85:
+        insights.append("📈 Strong performance! Many competitive courses within reach.")
+    elif predicted_atar >= 75:
+        insights.append("✅ Solid foundation! Focus on improvement areas for better outcomes.")
+    else:
+        insights.append("💪 Room for growth! Strategic improvement can boost your ATAR significantly.")
+    
+    # Subject mix analysis
+    high_scaling = [s for s in subjects if SUBJECT_SCALING_DATA.get(s.get('subject_name', ''), {}).get('scaling_factor', 1.0) > 1.05]
+    if len(high_scaling) >= 3:
+        insights.append(f"⭐ Your {len(high_scaling)} high-scaling subjects will boost your ATAR!")
+    
+    return insights
+
+def generate_recommendations(subjects: List[Dict], predicted_atar: float) -> List[str]:
+    """Generate improvement recommendations"""
+    recommendations = []
+    
+    # Find weakest subjects
+    sorted_subjects = sorted(subjects, key=lambda x: x.get('raw_mark', 0))
+    if sorted_subjects:
+        weakest = sorted_subjects[0]
+        recommendations.append(f"🎯 Focus on {weakest.get('subject_name', 'weakest subject')} - raising this by 5 marks could add ~1 ATAR point")
+    
+    # Suggest high-scaling subjects
+    low_scaling = [s for s in subjects if SUBJECT_SCALING_DATA.get(s.get('subject_name', ''), {}).get('scaling_factor', 1.0) < 0.98]
+    if low_scaling:
+        recommendations.append(f"⚖️ Consider if {low_scaling[0].get('subject_name')} is in your best 10 units")
+    
+    return recommendations
+
+# ============================================
+# GRADIO INTERFACE
+# ============================================
+
+@spaces.GPU(duration=120) if ZEROGPU_AVAILABLE else lambda x: x
+def train_model_interface(n_samples: int, version: str = None):
+    """Train model and upload to HF with versioning"""
+    try:
+        # Generate data
+        yield "📊 Generating synthetic training data..."
+        X, y = generate_synthetic_data(n_samples)
+        
+        # Split
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+        
+        # Train
+        yield "🚀 Training ML ensemble (Gradient Boosting + Random Forest + Ridge)..."
+        ensemble.train(X_train, y_train, X_test, y_test)
+        
+        # Evaluate
+        train_pred = ensemble.predict(X_train)
+        test_pred = ensemble.predict(X_test)
+        
+        train_mae = np.mean(np.abs(train_pred - y_train))
+        test_mae = np.mean(np.abs(test_pred - y_test))
+        
+        yield f"✅ Training complete!\n\n📊 Results:\n- Train MAE: {train_mae:.2f} ATAR points\n- Test MAE: {test_mae:.2f} ATAR points\n- Training samples: {len(X_train):,}\n\n💾 Saving models locally..."
+        
+        # Save locally
+        ensemble.save_local('models')
+        
+        # Upload to HF with versioning
+        yield f"✅ Models saved!\n\n☁️ Uploading to Hugging Face with versioning..."
+        
+        # Auto-generate version if not provided
+        if not version or version.strip() == "":
+            from datetime import datetime
+            version = datetime.now().strftime("v%Y%m%d_%H%M%S")
+        
+        result = upload_to_hf(version=version)
+        yield f"✅ Training complete!\n\n📊 Results:\n- Train MAE: {train_mae:.2f} ATAR points\n- Test MAE: {test_mae:.2f} ATAR points\n- Training samples: {len(X_train):,}\n\n{result}\n\n🎉 Model ready for inference!"
+    
+    except Exception as e:
+        yield f"❌ Training failed: {str(e)}"
+
+@spaces.GPU(duration=5) if ZEROGPU_AVAILABLE else lambda x: x
+def predict_interface(subjects_json: str):
+    """Predict ATAR from JSON input"""
+    try:
+        subjects = json.loads(subjects_json)
+        result = predict_atar(subjects)
+        return json.dumps(result, indent=2)
+    except Exception as e:
+        return json.dumps({'error': str(e)})
+
+# ============================================
+# GRADIO APP
+# ============================================
+
+with gr.Blocks(title="ATAR Prediction ML Ensemble", theme=gr.themes.Soft()) as app:
+    gr.Markdown("""
+    # 🎓 ATAR Prediction System (ML Ensemble)
+    **Powered by Gradient Boosting + Random Forest + Ridge Regression**
+    
+    ### Features:
+    - 🚀 Train on ZeroGPU with automatic HF Model Repo upload
+    - 🔮 Predict ATAR from subject marks (auto-loads model from HF)
+    - ☁️ No persistent storage needed - models live in HF Model Repo
+    """)
+    
+    with gr.Tabs():
+        # Tab 1: Training
+        with gr.Tab("🏋️ Train Model"):
+            gr.Markdown("### Train ML Ensemble & Upload to Hugging Face")
+            
+            with gr.Row():
+                n_samples_input = gr.Slider(1000, 50000, value=10000, step=1000, label="Training Samples")
+                version_input = gr.Textbox(
+                    label="Version (optional - auto-generated if empty)", 
+                    placeholder="v1.0.0 or leave empty for timestamp",
+                    value=""
+                )
+            
+            train_btn = gr.Button("🚀 Train & Upload to HF", variant="primary", size="lg")
+            train_output = gr.Textbox(label="Training Progress", lines=12)
+            
+            train_btn.click(
+                fn=train_model_interface,
+                inputs=[n_samples_input, version_input],
+                outputs=train_output
+            )
+            
+            gr.Markdown("""
+            **Instructions:**
+            1. Set `HF_TOKEN` environment variable in Space settings (write access)
+               - Go to Space Settings → Variables and secrets
+               - Add secret: `HF_TOKEN` = your token from https://huggingface.co/settings/tokens
+            2. (Optional) Specify version like `v1.0.0`, `v1.1.0`, etc. or leave empty for auto timestamp
+            3. Click "Train & Upload to HF"
+            4. Model will be uploaded to `victor-academy/atar-predictor-ensemble`
+            5. Each training creates a new version - no overwrites!
+            
+            **Versioning:**
+            - `models/latest/` - Always the newest model
+            - `models/v1.0.0/` - Specific version you can roll back to
+            - `metadata.json` - Tracks all versions with metrics
+            
+            **ZeroGPU:**
+            - Training uses GPU for 120 seconds (free tier)
+            - Inference uses GPU for 5 seconds per request
+            - All model storage handled via HF Model Repo
+            """)
+        
+        # Tab 2: JSON API
+        with gr.Tab("🔌 JSON API"):
+            gr.Markdown("### Predict ATAR (JSON API)")
+            
+            with gr.Row():
+                load_version_input = gr.Textbox(
+                    label="Model Version to Load (optional)",
+                    placeholder="latest (default), v1.0.0, v20241007_143022, etc.",
+                    value="latest"
+                )
+                load_btn = gr.Button("📥 Load Model", variant="secondary")
+            
+            load_status = gr.Textbox(label="Load Status", lines=3)
+            
+            def load_model_interface(version):
+                return download_from_hf(version=version)
+            
+            load_btn.click(
+                fn=load_model_interface,
+                inputs=load_version_input,
+                outputs=load_status
+            )
+            
+            gr.Markdown("---")
+            
+            subjects_input = gr.Code(
+                label="Input: Subjects JSON",
+                language="json",
+                value=json.dumps([
+                    {"subject_name": "Mathematics Extension 2", "raw_mark": 88.5, "trend": "improving", "assessment_count": 4},
+                    {"subject_name": "Physics", "raw_mark": 85.0, "trend": "stable", "assessment_count": 5},
+                    {"subject_name": "Chemistry", "raw_mark": 84.0, "trend": "stable", "assessment_count": 5},
+                    {"subject_name": "English Advanced", "raw_mark": 82.0, "trend": "improving", "assessment_count": 4},
+                    {"subject_name": "Software Design & Development", "raw_mark": 86.0, "trend": "improving", "assessment_count": 3}
+                ], indent=2)
+            )
+            
+            predict_btn = gr.Button("🔮 Predict ATAR", variant="primary")
+            prediction_output = gr.Code(label="Output: Prediction JSON", language="json")
+            
+            predict_btn.click(
+                fn=predict_interface,
+                inputs=subjects_input,
+                outputs=prediction_output
+            )
+            
+            gr.Markdown("""
+            **Note:** 
+            - Model auto-loads `latest` version on first API call if not manually loaded
+            - Manually load a specific version to test different models
+            - All versions are preserved in HF Model Repo
+            - **Public repos**: No token needed for downloads
+            - **Private repos**: Set `HF_TOKEN` environment variable in Space settings
+            """)
+        
+        # Tab 3: Simple Calculator
+        with gr.Tab("📝 Simple Calculator"):
+            gr.Markdown("### Quick ATAR Estimate")
+            
+            with gr.Row():
+                with gr.Column():
+                    subj1 = gr.Dropdown(choices=list(SUBJECT_SCALING_DATA.keys()), label="Subject 1")
+                    mark1 = gr.Slider(0, 100, 85, label="Mark")
+                with gr.Column():
+                    subj2 = gr.Dropdown(choices=list(SUBJECT_SCALING_DATA.keys()), label="Subject 2")
+                    mark2 = gr.Slider(0, 100, 85, label="Mark")
+            
+            with gr.Row():
+                with gr.Column():
+                    subj3 = gr.Dropdown(choices=list(SUBJECT_SCALING_DATA.keys()), label="Subject 3")
+                    mark3 = gr.Slider(0, 100, 85, label="Mark")
+                with gr.Column():
+                    subj4 = gr.Dropdown(choices=list(SUBJECT_SCALING_DATA.keys()), label="Subject 4")
+                    mark4 = gr.Slider(0, 100, 85, label="Mark")
+            
+            calc_btn = gr.Button("Calculate ATAR", variant="primary")
+            calc_output = gr.Textbox(label="Result", lines=8)
+            
+            def simple_calc(s1, m1, s2, m2, s3, m3, s4, m4):
+                subjects = []
+                for s, m in [(s1, m1), (s2, m2), (s3, m3), (s4, m4)]:
+                    if s:
+                        subjects.append({"subject_name": s, "raw_mark": m, "trend": "stable", "assessment_count": 3})
+                
+                if not subjects:
+                    return "⚠️ Please select at least one subject"
+                
+                result = predict_atar(subjects)
+                
+                if 'error' in result:
+                    return f"❌ {result['error']}"
+                
+                output = f"🎯 Predicted ATAR: {result['predicted_atar']}\n"
+                output += f"📊 Confidence: {result['confidence']*100:.0f}%\n\n"
+                output += "💡 Insights:\n" + "\n".join(result['insights'])
+                return output
+            
+            calc_btn.click(
+                fn=simple_calc,
+                inputs=[subj1, mark1, subj2, mark2, subj3, mark3, subj4, mark4],
+                outputs=calc_output
+            )
+        
+        # Tab 4: Scaling Reference
+        with gr.Tab("📊 Scaling Reference"):
+            gr.Markdown("### 2024 HSC Subject Scaling Data")
+            
+            scaling_df = pd.DataFrame([
+                {
+                    'Subject': name,
+                    'Scaling Factor': f"{data['scaling_factor']:.4f}",
+                    'Mean Mark': data['mean'],
+                    'Difficulty': data['difficulty']
+                }
+                for name, data in sorted(SUBJECT_SCALING_DATA.items(), 
+                                        key=lambda x: x[1]['scaling_factor'], 
+                                        reverse=True)
+            ])
+            
+            gr.Dataframe(scaling_df, label="Subject Scaling Factors (sorted by scaling)")
+
+# ============================================
+# LAUNCH
+# ============================================
+
+if __name__ == "__main__":
+    app.launch(share=True, server_name="0.0.0.0", server_port=7860)