Deploy CyberForge AI ML Training Platform

README.md

@@ -1,12 +1,189 @@
 ---
-title: Cyberforge
-emoji: 📉
-colorFrom: red
+title: CyberForge AI
+emoji: 🔐
+colorFrom: purple
 colorTo: blue
 sdk: gradio
-sdk_version: 5.49.1
+sdk_version: 4.44.0
 app_file: app.py
-pinned: false
+pinned: true
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🔐 CyberForge AI - ML Training Platform
+
+**Train, Deploy, and Serve Cybersecurity Machine Learning Models**
+
+A comprehensive platform for training cybersecurity ML models in the cloud with Hugging Face Spaces integration.
+
+## 🚀 Features
+
+- **📊 Model Training**: Upload datasets and train multiple ML models (Random Forest, Gradient Boosting, Neural Networks, Ensembles)
+- **🤖 Multiple Security Tasks**: Malware detection, phishing detection, network intrusion, anomaly detection, and more
+- **☁️ Cloud Training**: Leverage Hugging Face's infrastructure for training without local compute resources
+- **🔗 API Integration**: RESTful API endpoints for backend integration
+- **💾 Model Hub**: Upload trained models to Hugging Face Hub for sharing and deployment
+
+## 📦 Supported Security Tasks
+
+| Task | Description |
+|------|-------------|
+| Malware Detection | Identify malicious software patterns |
+| Phishing Detection | Detect phishing URLs and emails |
+| Network Intrusion Detection | Identify network attack patterns |
+| Anomaly Detection | Detect unusual system behavior |
+| Botnet Detection | Identify botnet command & control traffic |
+| Web Attack Detection | Detect SQL injection, XSS, etc. |
+| Spam Detection | Filter spam messages |
+| Vulnerability Assessment | Assess system vulnerabilities |
+| DNS Tunneling Detection | Detect DNS-based data exfiltration |
+| Cryptomining Detection | Identify unauthorized mining activity |
+
+## 🛠️ Model Types
+
+- **Random Forest**: Robust ensemble classifier
+- **Gradient Boosting**: High-performance gradient boosting
+- **Logistic Regression**: Fast baseline classifier
+- **Isolation Forest**: Unsupervised anomaly detection
+- **Neural Networks**: Deep learning models (when available)
+- **Ensemble Models**: Voting and stacking classifiers
+
+## 📖 How to Use
+
+### 1. Training a Model
+
+1. Go to the **🎯 Train Model** tab
+2. Upload your dataset (CSV, JSON, or Parquet)
+3. Select the security task type
+4. Choose a model type
+5. Enter the target column name
+6. Click **Train Model**
+
+### 2. Running Inference
+
+1. Go to the **🔮 Run Inference** tab
+2. Enter the model ID from training
+3. Provide input features as JSON
+4. Click **Run Inference**
+
+### 3. Backend Integration
+
+```python
+from gradio_client import Client
+
+# Connect to the Space
+client = Client("Che237/cyberforge")
+
+# Train a model
+result = client.predict(
+    file="path/to/dataset.csv",
+    task_type="Malware Detection",
+    model_type="Random Forest",
+    target_column="label",
+    test_size=0.2,
+    model_name="my_model",
+    api_name="/train_model"
+)
+
+# Run inference
+predictions = client.predict(
+    model_id="my_model_malware_detection_20240101_120000",
+    input_data='[{"feature1": 0.5, "feature2": 1.2}]',
+    api_name="/run_inference"
+)
+```
+
+### 4. Node.js Backend Integration
+
+```javascript
+const { Client } = require("@gradio/client");
+
+async function runPrediction(modelId, features) {
+    const client = await Client.connect("Che237/cyberforge");
+    const result = await client.predict("/run_inference", {
+        model_id: modelId,
+        input_data: JSON.stringify([features])
+    });
+    return JSON.parse(result.data);
+}
+
+// Usage
+const prediction = await runPrediction(
+    "cyberforge_model_malware_detection_20240101",
+    { src_bytes: 1000, dst_bytes: 500, protocol_type: 0 }
+);
+console.log(prediction);
+```
+
+## 📊 Dataset Format
+
+Your dataset should be in CSV, JSON, or Parquet format with:
+
+- **Features**: Numerical or categorical columns
+- **Target**: A column indicating the class/label (e.g., `label`, `is_malicious`, `attack_type`)
+
+### Example CSV Structure:
+
+```csv
+src_bytes,dst_bytes,protocol_type,service,flag,label
+1000,500,tcp,http,SF,normal
+5000,2000,udp,dns,REJ,attack
+...
+```
+
+## 🔗 API Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/train_model` | POST | Train a new model |
+| `/run_inference` | POST | Run predictions |
+| `/list_trained_models` | GET | List available models |
+| `/upload_model_to_hub` | POST | Upload model to Hub |
+| `/download_model_from_hub` | POST | Download model from Hub |
+
+## 🏗️ Architecture
+
+```
+┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
+│   Your Backend  │ ──▶ │  HF Space (API)  │ ──▶ │  Trained Models │
+│   (Node.js)     │ ◀── │  (Gradio)        │ ◀── │  (pkl files)    │
+└─────────────────┘     └───────��──────────┘     └─────────────────┘
+                               │
+                               ▼
+                        ┌──────────────────┐
+                        │  Hugging Face    │
+                        │  Model Hub       │
+                        └──────────────────┘
+```
+
+## 📁 Files
+
+- `app.py` - Main Gradio application
+- `trainer.py` - Advanced model training module
+- `hf_client.py` - Client library for backend integration
+- `requirements.txt` - Python dependencies
+
+## 🔧 Local Development
+
+```bash
+# Clone the space
+git clone https://huggingface.co/spaces/Che237/cyberforge
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run locally
+python app.py
+```
+
+## 📄 License
+
+MIT License - See LICENSE file for details.
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+---
+
+Built with ❤️ for the cybersecurity community

app.py

@@ -0,0 +1,772 @@
+"""
+🔐 CyberForge AI - ML Training & Inference Platform
+Hugging Face Spaces deployment for training cybersecurity ML models
+"""
+
+import gradio as gr
+import pandas as pd
+import numpy as np
+import json
+import os
+import joblib
+from pathlib import Path
+from datetime import datetime
+import logging
+from typing import Dict, List, Any, Optional, Tuple
+import asyncio
+
+# ML Libraries
+from sklearn.model_selection import train_test_split, cross_val_score
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, IsolationForest
+from sklearn.linear_model import LogisticRegression
+from sklearn.preprocessing import StandardScaler, LabelEncoder
+from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, f1_score
+import torch
+import torch.nn as nn
+from transformers import AutoTokenizer, AutoModel
+
+# Hugging Face Hub
+from huggingface_hub import HfApi, hf_hub_download, upload_file, create_repo
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ============================================================================
+# CONFIGURATION
+# ============================================================================
+
+MODELS_DIR = Path("./trained_models")
+MODELS_DIR.mkdir(exist_ok=True)
+
+DATASETS_DIR = Path("./datasets")
+DATASETS_DIR.mkdir(exist_ok=True)
+
+# Model types available for training
+MODEL_TYPES = {
+    "Random Forest": RandomForestClassifier,
+    "Gradient Boosting": GradientBoostingClassifier,
+    "Logistic Regression": LogisticRegression,
+    "Isolation Forest (Anomaly)": IsolationForest,
+}
+
+# Cybersecurity task categories
+SECURITY_TASKS = [
+    "Malware Detection",
+    "Phishing Detection", 
+    "Network Intrusion Detection",
+    "Anomaly Detection",
+    "Botnet Detection",
+    "Web Attack Detection",
+    "Spam Detection",
+    "Vulnerability Assessment",
+    "DNS Tunneling Detection",
+    "Cryptomining Detection",
+]
+
+# ============================================================================
+# MODEL REGISTRY
+# ============================================================================
+
+class ModelRegistry:
+    """Manages trained models and their metadata"""
+    
+    def __init__(self):
+        self.models = {}
+        self.scalers = {}
+        self.metadata = {}
+        self.registry_file = MODELS_DIR / "registry.json"
+        self._load_registry()
+    
+    def _load_registry(self):
+        """Load existing model registry"""
+        if self.registry_file.exists():
+            with open(self.registry_file, 'r') as f:
+                self.metadata = json.load(f)
+        else:
+            self.metadata = {}
+    
+    def _save_registry(self):
+        """Save model registry"""
+        with open(self.registry_file, 'w') as f:
+            json.dump(self.metadata, f, indent=2, default=str)
+    
+    def register_model(self, model_id: str, model, scaler, metrics: Dict):
+        """Register a trained model"""
+        self.models[model_id] = model
+        self.scalers[model_id] = scaler
+        
+        # Save model and scaler
+        model_path = MODELS_DIR / f"{model_id}_model.pkl"
+        scaler_path = MODELS_DIR / f"{model_id}_scaler.pkl"
+        
+        joblib.dump(model, model_path)
+        joblib.dump(scaler, scaler_path)
+        
+        # Update metadata
+        self.metadata[model_id] = {
+            "created_at": datetime.now().isoformat(),
+            "metrics": metrics,
+            "model_path": str(model_path),
+            "scaler_path": str(scaler_path),
+            "status": "ready"
+        }
+        self._save_registry()
+        
+        return model_id
+    
+    def get_model(self, model_id: str):
+        """Load a model from registry"""
+        if model_id in self.models:
+            return self.models[model_id], self.scalers[model_id]
+        
+        if model_id in self.metadata:
+            model = joblib.load(self.metadata[model_id]["model_path"])
+            scaler = joblib.load(self.metadata[model_id]["scaler_path"])
+            self.models[model_id] = model
+            self.scalers[model_id] = scaler
+            return model, scaler
+        
+        return None, None
+    
+    def list_models(self) -> List[Dict]:
+        """List all registered models"""
+        return [
+            {"id": k, **v} for k, v in self.metadata.items()
+        ]
+
+# Global registry
+model_registry = ModelRegistry()
+
+# ============================================================================
+# TRAINING FUNCTIONS
+# ============================================================================
+
+def prepare_dataset(file, task_type: str) -> Tuple[pd.DataFrame, str]:
+    """Load and prepare dataset for training"""
+    try:
+        if file is None:
+            return None, "No file uploaded"
+        
+        # Load based on file type
+        if file.name.endswith('.csv'):
+            df = pd.read_csv(file.name)
+        elif file.name.endswith('.json'):
+            df = pd.read_json(file.name)
+        elif file.name.endswith('.parquet'):
+            df = pd.read_parquet(file.name)
+        else:
+            return None, f"Unsupported file format: {file.name}"
+        
+        logger.info(f"Loaded dataset with shape: {df.shape}")
+        return df, f"✅ Loaded dataset with {len(df)} samples and {len(df.columns)} features"
+    
+    except Exception as e:
+        logger.error(f"Error loading dataset: {e}")
+        return None, f"❌ Error: {str(e)}"
+
+
+def train_model(
+    file,
+    task_type: str,
+    model_type: str,
+    target_column: str,
+    test_size: float,
+    model_name: str,
+    progress=gr.Progress()
+) -> Tuple[str, str, str]:
+    """Train a machine learning model"""
+    try:
+        progress(0, desc="Loading dataset...")
+        
+        # Load dataset
+        df, msg = prepare_dataset(file, task_type)
+        if df is None:
+            return msg, "", ""
+        
+        progress(0.1, desc="Preparing features...")
+        
+        # Validate target column
+        if target_column not in df.columns:
+            return f"❌ Target column '{target_column}' not found in dataset. Available: {list(df.columns)}", "", ""
+        
+        # Prepare features and target
+        X = df.drop(columns=[target_column])
+        y = df[target_column]
+        
+        # Handle categorical features
+        for col in X.select_dtypes(include=['object', 'category']).columns:
+            le = LabelEncoder()
+            X[col] = le.fit_transform(X[col].astype(str))
+        
+        # Handle target encoding
+        if y.dtype == 'object' or y.dtype.name == 'category':
+            le = LabelEncoder()
+            y = le.fit_transform(y.astype(str))
+        
+        # Fill NaN values
+        X = X.fillna(0)
+        
+        progress(0.2, desc="Splitting data...")
+        
+        # Split data
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=test_size, random_state=42
+        )
+        
+        progress(0.3, desc="Scaling features...")
+        
+        # Scale features
+        scaler = StandardScaler()
+        X_train_scaled = scaler.fit_transform(X_train)
+        X_test_scaled = scaler.transform(X_test)
+        
+        progress(0.4, desc=f"Training {model_type}...")
+        
+        # Get model class
+        if model_type not in MODEL_TYPES:
+            return f"❌ Unknown model type: {model_type}", "", ""
+        
+        model_class = MODEL_TYPES[model_type]
+        
+        # Configure and train model
+        if model_type == "Isolation Forest (Anomaly)":
+            model = model_class(contamination=0.1, random_state=42, n_estimators=100)
+            model.fit(X_train_scaled)
+            y_pred = model.predict(X_test_scaled)
+            y_pred = np.where(y_pred == -1, 1, 0)  # Convert to binary
+        else:
+            model = model_class(random_state=42)
+            model.fit(X_train_scaled, y_train)
+            y_pred = model.predict(X_test_scaled)
+        
+        progress(0.7, desc="Evaluating model...")
+        
+        # Calculate metrics
+        accuracy = accuracy_score(y_test, y_pred)
+        f1 = f1_score(y_test, y_pred, average='weighted')
+        
+        metrics = {
+            "accuracy": float(accuracy),
+            "f1_score": float(f1),
+            "model_type": model_type,
+            "task_type": task_type,
+            "samples": len(df),
+            "features": len(X.columns),
+        }
+        
+        progress(0.85, desc="Saving model...")
+        
+        # Generate model ID
+        model_id = f"{model_name}_{task_type.lower().replace(' ', '_')}_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+        
+        # Register model
+        model_registry.register_model(model_id, model, scaler, metrics)
+        
+        progress(1.0, desc="Complete!")
+        
+        # Format results
+        training_log = f"""
+## 🎯 Training Complete!
+
+**Model ID:** `{model_id}`
+**Task:** {task_type}
+**Model Type:** {model_type}
+
+### 📊 Dataset Info
+- Samples: {len(df):,}
+- Features: {len(X.columns)}
+- Train/Test Split: {int((1-test_size)*100)}/{int(test_size*100)}
+
+### 📈 Metrics
+- **Accuracy:** {accuracy:.4f} ({accuracy*100:.2f}%)
+- **F1 Score:** {f1:.4f}
+
+### 💾 Model Saved
+- Path: `{MODELS_DIR / f'{model_id}_model.pkl'}`
+"""
+        
+        # Generate classification report
+        try:
+            report = classification_report(y_test, y_pred)
+        except:
+            report = "Classification report not available for this model type"
+        
+        return training_log, report, model_id
+        
+    except Exception as e:
+        logger.error(f"Training error: {e}")
+        import traceback
+        return f"❌ Training failed: {str(e)}\n\n{traceback.format_exc()}", "", ""
+
+
+def list_trained_models() -> str:
+    """List all trained models"""
+    models = model_registry.list_models()
+    
+    if not models:
+        return "No models trained yet. Upload a dataset and train a model to get started!"
+    
+    output = "## 🤖 Trained Models\n\n"
+    for model in models:
+        output += f"""
+### {model['id']}
+- **Created:** {model.get('created_at', 'Unknown')}
+- **Accuracy:** {model.get('metrics', {}).get('accuracy', 0):.4f}
+- **F1 Score:** {model.get('metrics', {}).get('f1_score', 0):.4f}
+- **Status:** {model.get('status', 'Unknown')}
+
+---
+"""
+    return output
+
+
+def run_inference(model_id: str, input_data: str) -> str:
+    """Run inference on a trained model"""
+    try:
+        model, scaler = model_registry.get_model(model_id)
+        
+        if model is None:
+            return f"❌ Model '{model_id}' not found"
+        
+        # Parse input data (expect JSON format)
+        try:
+            data = json.loads(input_data)
+            if isinstance(data, dict):
+                data = [data]
+            df = pd.DataFrame(data)
+        except json.JSONDecodeError:
+            return "❌ Invalid JSON input. Please provide data in JSON format."
+        
+        # Scale and predict
+        X_scaled = scaler.transform(df.fillna(0))
+        predictions = model.predict(X_scaled)
+        
+        # Get probabilities if available
+        try:
+            probabilities = model.predict_proba(X_scaled)
+            results = []
+            for i, (pred, probs) in enumerate(zip(predictions, probabilities)):
+                results.append({
+                    "sample": i,
+                    "prediction": int(pred),
+                    "confidence": float(max(probs)),
+                    "probabilities": probs.tolist()
+                })
+        except:
+            results = [{"sample": i, "prediction": int(p)} for i, p in enumerate(predictions)]
+        
+        return json.dumps(results, indent=2)
+        
+    except Exception as e:
+        logger.error(f"Inference error: {e}")
+        return f"❌ Inference failed: {str(e)}"
+
+
+# ============================================================================
+# HUGGING FACE INTEGRATION
+# ============================================================================
+
+def upload_model_to_hub(model_id: str, repo_id: str, hf_token: str) -> str:
+    """Upload a trained model to Hugging Face Hub"""
+    try:
+        if not hf_token:
+            return "❌ Hugging Face token required for upload"
+        
+        model, scaler = model_registry.get_model(model_id)
+        if model is None:
+            return f"❌ Model '{model_id}' not found"
+        
+        api = HfApi(token=hf_token)
+        
+        # Create repo if it doesn't exist
+        try:
+            create_repo(repo_id, token=hf_token, repo_type="model", exist_ok=True)
+        except Exception as e:
+            logger.warning(f"Repo creation note: {e}")
+        
+        # Upload model files
+        model_path = MODELS_DIR / f"{model_id}_model.pkl"
+        scaler_path = MODELS_DIR / f"{model_id}_scaler.pkl"
+        
+        upload_file(
+            path_or_fileobj=str(model_path),
+            path_in_repo=f"{model_id}_model.pkl",
+            repo_id=repo_id,
+            token=hf_token,
+            repo_type="model"
+        )
+        
+        upload_file(
+            path_or_fileobj=str(scaler_path),
+            path_in_repo=f"{model_id}_scaler.pkl",
+            repo_id=repo_id,
+            token=hf_token,
+            repo_type="model"
+        )
+        
+        # Upload metadata
+        metadata = model_registry.metadata.get(model_id, {})
+        metadata_json = json.dumps(metadata, indent=2, default=str)
+        
+        with open(MODELS_DIR / f"{model_id}_metadata.json", 'w') as f:
+            f.write(metadata_json)
+        
+        upload_file(
+            path_or_fileobj=str(MODELS_DIR / f"{model_id}_metadata.json"),
+            path_in_repo=f"{model_id}_metadata.json",
+            repo_id=repo_id,
+            token=hf_token,
+            repo_type="model"
+        )
+        
+        return f"""
+## ✅ Model Uploaded Successfully!
+
+**Model ID:** `{model_id}`
+**Repository:** `{repo_id}`
+**URL:** https://huggingface.co/{repo_id}
+
+### Files Uploaded:
+- `{model_id}_model.pkl`
+- `{model_id}_scaler.pkl`
+- `{model_id}_metadata.json`
+
+You can now use this model from the Hub!
+"""
+        
+    except Exception as e:
+        logger.error(f"Upload error: {e}")
+        return f"❌ Upload failed: {str(e)}"
+
+
+def download_model_from_hub(repo_id: str, model_filename: str, hf_token: str) -> str:
+    """Download a model from Hugging Face Hub"""
+    try:
+        model_path = hf_hub_download(
+            repo_id=repo_id,
+            filename=model_filename,
+            token=hf_token if hf_token else None
+        )
+        
+        # Also try to download scaler
+        scaler_filename = model_filename.replace("_model.pkl", "_scaler.pkl")
+        try:
+            scaler_path = hf_hub_download(
+                repo_id=repo_id,
+                filename=scaler_filename,
+                token=hf_token if hf_token else None
+            )
+        except:
+            scaler_path = None
+        
+        # Load and register
+        model = joblib.load(model_path)
+        scaler = joblib.load(scaler_path) if scaler_path else StandardScaler()
+        
+        model_id = model_filename.replace("_model.pkl", "")
+        model_registry.models[model_id] = model
+        model_registry.scalers[model_id] = scaler
+        
+        return f"""
+## ✅ Model Downloaded Successfully!
+
+**Model ID:** `{model_id}`
+**Source:** `{repo_id}`
+
+The model is now available for inference.
+"""
+        
+    except Exception as e:
+        logger.error(f"Download error: {e}")
+        return f"❌ Download failed: {str(e)}"
+
+
+# ============================================================================
+# API ENDPOINTS (For Backend Integration)
+# ============================================================================
+
+def api_predict(model_id: str, features: Dict) -> Dict:
+    """API endpoint for predictions"""
+    try:
+        model, scaler = model_registry.get_model(model_id)
+        if model is None:
+            return {"error": f"Model '{model_id}' not found"}
+        
+        df = pd.DataFrame([features])
+        X_scaled = scaler.transform(df.fillna(0))
+        prediction = model.predict(X_scaled)[0]
+        
+        try:
+            proba = model.predict_proba(X_scaled)[0]
+            confidence = float(max(proba))
+        except:
+            confidence = None
+        
+        return {
+            "model_id": model_id,
+            "prediction": int(prediction),
+            "confidence": confidence,
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+def api_batch_predict(model_id: str, batch_data: List[Dict]) -> List[Dict]:
+    """API endpoint for batch predictions"""
+    results = []
+    for item in batch_data:
+        result = api_predict(model_id, item)
+        results.append(result)
+    return results
+
+
+# ============================================================================
+# GRADIO INTERFACE
+# ============================================================================
+
+# Custom CSS
+custom_css = """
+.gradio-container {
+    font-family: 'Inter', sans-serif;
+}
+.main-title {
+    text-align: center;
+    color: #1a1a2e;
+    margin-bottom: 20px;
+}
+.tab-content {
+    padding: 20px;
+}
+"""
+
+# Build interface
+with gr.Blocks(css=custom_css, title="CyberForge AI - ML Training Platform") as demo:
+    gr.Markdown("""
+    # 🔐 CyberForge AI - ML Training Platform
+    
+    **Train, Deploy, and Serve Cybersecurity ML Models**
+    
+    This platform enables you to:
+    - 📊 Upload and train models on cybersecurity datasets
+    - 🚀 Deploy models to Hugging Face Hub
+    - 🔗 Integrate with your backend via API
+    - 🤖 Run inference on trained models
+    """)
+    
+    with gr.Tabs():
+        # ==================== TRAINING TAB ====================
+        with gr.TabItem("🎯 Train Model"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Dataset Configuration")
+                    
+                    train_file = gr.File(
+                        label="Upload Dataset (CSV, JSON, or Parquet)",
+                        file_types=[".csv", ".json", ".parquet"]
+                    )
+                    
+                    task_type = gr.Dropdown(
+                        choices=SECURITY_TASKS,
+                        value="Malware Detection",
+                        label="Security Task Type"
+                    )
+                    
+                    model_type = gr.Dropdown(
+                        choices=list(MODEL_TYPES.keys()),
+                        value="Random Forest",
+                        label="Model Type"
+                    )
+                    
+                    target_column = gr.Textbox(
+                        label="Target Column Name",
+                        placeholder="e.g., 'label', 'is_malicious', 'attack_type'"
+                    )
+                    
+                    test_size = gr.Slider(
+                        minimum=0.1,
+                        maximum=0.4,
+                        value=0.2,
+                        step=0.05,
+                        label="Test Size"
+                    )
+                    
+                    model_name = gr.Textbox(
+                        label="Model Name",
+                        placeholder="e.g., 'malware_detector_v1'",
+                        value="cyberforge_model"
+                    )
+                    
+                    train_btn = gr.Button("🚀 Train Model", variant="primary")
+                
+                with gr.Column(scale=1):
+                    gr.Markdown("### Training Results")
+                    training_output = gr.Markdown()
+                    classification_report_output = gr.Textbox(
+                        label="Classification Report",
+                        lines=10
+                    )
+                    trained_model_id = gr.Textbox(
+                        label="Trained Model ID",
+                        interactive=False
+                    )
+            
+            train_btn.click(
+                fn=train_model,
+                inputs=[train_file, task_type, model_type, target_column, test_size, model_name],
+                outputs=[training_output, classification_report_output, trained_model_id]
+            )
+        
+        # ==================== INFERENCE TAB ====================
+        with gr.TabItem("🔮 Run Inference"):
+            with gr.Row():
+                with gr.Column():
+                    inference_model_id = gr.Textbox(
+                        label="Model ID",
+                        placeholder="Enter the model ID to use"
+                    )
+                    
+                    inference_input = gr.Textbox(
+                        label="Input Data (JSON format)",
+                        placeholder='[{"feature1": 0.5, "feature2": 1.2, ...}]',
+                        lines=5
+                    )
+                    
+                    inference_btn = gr.Button("🔮 Run Inference", variant="primary")
+                
+                with gr.Column():
+                    inference_output = gr.Textbox(
+                        label="Predictions",
+                        lines=10
+                    )
+            
+            inference_btn.click(
+                fn=run_inference,
+                inputs=[inference_model_id, inference_input],
+                outputs=[inference_output]
+            )
+        
+        # ==================== MODELS TAB ====================
+        with gr.TabItem("🤖 Models"):
+            gr.Markdown("### Trained Models")
+            
+            refresh_btn = gr.Button("🔄 Refresh Models List")
+            models_list = gr.Markdown()
+            
+            refresh_btn.click(
+                fn=list_trained_models,
+                outputs=[models_list]
+            )
+            
+            # Auto-refresh on load
+            demo.load(
+                fn=list_trained_models,
+                outputs=[models_list]
+            )
+        
+        # ==================== HUB TAB ====================
+        with gr.TabItem("☁️ Hugging Face Hub"):
+            gr.Markdown("### Upload & Download Models")
+            
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("#### Upload to Hub")
+                    upload_model_id = gr.Textbox(
+                        label="Model ID to Upload"
+                    )
+                    upload_repo_id = gr.Textbox(
+                        label="Hub Repository ID",
+                        placeholder="username/repo-name"
+                    )
+                    upload_token = gr.Textbox(
+                        label="Hugging Face Token",
+                        type="password"
+                    )
+                    upload_btn = gr.Button("⬆️ Upload Model", variant="primary")
+                    upload_result = gr.Markdown()
+                
+                with gr.Column():
+                    gr.Markdown("#### Download from Hub")
+                    download_repo_id = gr.Textbox(
+                        label="Hub Repository ID",
+                        placeholder="username/repo-name"
+                    )
+                    download_filename = gr.Textbox(
+                        label="Model Filename",
+                        placeholder="model_name_model.pkl"
+                    )
+                    download_token = gr.Textbox(
+                        label="Hugging Face Token (optional)",
+                        type="password"
+                    )
+                    download_btn = gr.Button("⬇️ Download Model", variant="secondary")
+                    download_result = gr.Markdown()
+            
+            upload_btn.click(
+                fn=upload_model_to_hub,
+                inputs=[upload_model_id, upload_repo_id, upload_token],
+                outputs=[upload_result]
+            )
+            
+            download_btn.click(
+                fn=download_model_from_hub,
+                inputs=[download_repo_id, download_filename, download_token],
+                outputs=[download_result]
+            )
+        
+        # ==================== API TAB ====================
+        with gr.TabItem("🔗 API Integration"):
+            gr.Markdown("""
+            ### API Integration Guide
+            
+            Your backend can integrate with this Space using the Gradio Client library or direct API calls.
+            
+            #### Python Client Example:
+            
+            ```python
+            from gradio_client import Client
+            
+            # Connect to your Space
+            client = Client("Che237/cyberforge")
+            
+            # Run inference
+            result = client.predict(
+                model_id="your_model_id",
+                input_data='[{"feature1": 0.5, "feature2": 1.2}]',
+                api_name="/run_inference"
+            )
+            print(result)
+            ```
+            
+            #### API Endpoints:
+            
+            | Endpoint | Description |
+            |----------|-------------|
+            | `/train_model` | Train a new model |
+            | `/run_inference` | Run predictions |
+            | `/list_trained_models` | List available models |
+            | `/upload_model_to_hub` | Upload model to Hub |
+            
+            #### Backend Integration (Node.js):
+            
+            ```javascript
+            const { Client } = require("@gradio/client");
+            
+            async function runPrediction(modelId, features) {
+                const client = await Client.connect("Che237/cyberforge");
+                const result = await client.predict("/run_inference", {
+                    model_id: modelId,
+                    input_data: JSON.stringify([features])
+                });
+                return JSON.parse(result.data);
+            }
+            ```
+            """)
+
+# Launch the demo
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )

hf_client.py

@@ -0,0 +1,436 @@
+"""
+CyberForge AI - Hugging Face API Client
+Backend integration for fetching models and running inference from Hugging Face Spaces
+"""
+
+import os
+import json
+import logging
+import asyncio
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+import httpx
+from pathlib import Path
+
+try:
+    from gradio_client import Client
+    GRADIO_CLIENT_AVAILABLE = True
+except ImportError:
+    GRADIO_CLIENT_AVAILABLE = False
+
+try:
+    from huggingface_hub import HfApi, hf_hub_download, InferenceClient
+    HF_HUB_AVAILABLE = True
+except ImportError:
+    HF_HUB_AVAILABLE = False
+
+logger = logging.getLogger(__name__)
+
+
+class HuggingFaceClient:
+    """
+    Client for interacting with CyberForge AI Hugging Face Space
+    Provides model inference, training requests, and model management
+    """
+    
+    def __init__(
+        self,
+        space_id: str = "Che237/cyberforge",
+        hf_token: Optional[str] = None,
+        models_repo: Optional[str] = None
+    ):
+        self.space_id = space_id
+        self.hf_token = hf_token or os.getenv("HF_TOKEN")
+        self.models_repo = models_repo or f"{space_id.split('/')[0]}/cyberforge-models"
+        self.space_url = f"https://{space_id.replace('/', '-')}.hf.space"
+        
+        self._client = None
+        self._hf_api = None
+        self._inference_client = None
+        
+        # Local model cache
+        self.models_cache_dir = Path("./models_cache")
+        self.models_cache_dir.mkdir(exist_ok=True)
+        
+        # Initialize clients
+        self._init_clients()
+    
+    def _init_clients(self):
+        """Initialize Hugging Face and Gradio clients"""
+        try:
+            if GRADIO_CLIENT_AVAILABLE:
+                self._client = Client(self.space_id, hf_token=self.hf_token)
+                logger.info(f"✅ Connected to Gradio Space: {self.space_id}")
+        except Exception as e:
+            logger.warning(f"Could not connect to Gradio Space: {e}")
+        
+        try:
+            if HF_HUB_AVAILABLE:
+                self._hf_api = HfApi(token=self.hf_token)
+                logger.info("✅ Connected to Hugging Face Hub API")
+        except Exception as e:
+            logger.warning(f"Could not connect to HF Hub API: {e}")
+    
+    # =========================================================================
+    # INFERENCE METHODS
+    # =========================================================================
+    
+    async def predict(
+        self,
+        model_id: str,
+        features: Dict[str, Any],
+        timeout: float = 30.0
+    ) -> Dict[str, Any]:
+        """
+        Run inference on a model deployed in the Space
+        
+        Args:
+            model_id: ID of the trained model
+            features: Dictionary of feature values
+            timeout: Request timeout in seconds
+            
+        Returns:
+            Prediction result with confidence scores
+        """
+        try:
+            if self._client:
+                # Use Gradio client
+                result = self._client.predict(
+                    model_id,
+                    json.dumps([features]),
+                    api_name="/run_inference"
+                )
+                return json.loads(result)
+            else:
+                # Fall back to HTTP API
+                return await self._http_predict(model_id, features, timeout)
+                
+        except Exception as e:
+            logger.error(f"Prediction failed: {e}")
+            return {"error": str(e), "model_id": model_id}
+    
+    async def batch_predict(
+        self,
+        model_id: str,
+        batch_features: List[Dict[str, Any]],
+        timeout: float = 60.0
+    ) -> List[Dict[str, Any]]:
+        """
+        Run batch inference on multiple samples
+        
+        Args:
+            model_id: ID of the trained model
+            batch_features: List of feature dictionaries
+            timeout: Request timeout in seconds
+            
+        Returns:
+            List of prediction results
+        """
+        try:
+            if self._client:
+                result = self._client.predict(
+                    model_id,
+                    json.dumps(batch_features),
+                    api_name="/run_inference"
+                )
+                return json.loads(result)
+            else:
+                return await self._http_batch_predict(model_id, batch_features, timeout)
+                
+        except Exception as e:
+            logger.error(f"Batch prediction failed: {e}")
+            return [{"error": str(e)} for _ in batch_features]
+    
+    async def _http_predict(
+        self,
+        model_id: str,
+        features: Dict[str, Any],
+        timeout: float
+    ) -> Dict[str, Any]:
+        """HTTP fallback for predictions"""
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            response = await client.post(
+                f"{self.space_url}/api/predict",
+                json={
+                    "data": [model_id, json.dumps([features])],
+                    "fn_index": 1  # Index of run_inference function
+                }
+            )
+            response.raise_for_status()
+            result = response.json()
+            return json.loads(result.get("data", [{}])[0])
+    
+    async def _http_batch_predict(
+        self,
+        model_id: str,
+        batch_features: List[Dict[str, Any]],
+        timeout: float
+    ) -> List[Dict[str, Any]]:
+        """HTTP fallback for batch predictions"""
+        async with httpx.AsyncClient(timeout=timeout) as client:
+            response = await client.post(
+                f"{self.space_url}/api/predict",
+                json={
+                    "data": [model_id, json.dumps(batch_features)],
+                    "fn_index": 1
+                }
+            )
+            response.raise_for_status()
+            result = response.json()
+            return json.loads(result.get("data", [{}])[0])
+    
+    # =========================================================================
+    # MODEL MANAGEMENT
+    # =========================================================================
+    
+    async def list_models(self) -> List[Dict[str, Any]]:
+        """Get list of available trained models"""
+        try:
+            if self._client:
+                result = self._client.predict(api_name="/list_trained_models")
+                return self._parse_models_list(result)
+            else:
+                return await self._http_list_models()
+        except Exception as e:
+            logger.error(f"Failed to list models: {e}")
+            return []
+    
+    def _parse_models_list(self, markdown_result: str) -> List[Dict[str, Any]]:
+        """Parse markdown model list into structured data"""
+        models = []
+        current_model = {}
+        
+        for line in markdown_result.split('\n'):
+            if line.startswith('### '):
+                if current_model:
+                    models.append(current_model)
+                current_model = {"id": line.replace('### ', '').strip()}
+            elif '**Created:**' in line:
+                current_model["created_at"] = line.split('**Created:**')[1].strip()
+            elif '**Accuracy:**' in line:
+                try:
+                    current_model["accuracy"] = float(line.split('**Accuracy:**')[1].strip())
+                except:
+                    pass
+            elif '**F1 Score:**' in line:
+                try:
+                    current_model["f1_score"] = float(line.split('**F1 Score:**')[1].strip())
+                except:
+                    pass
+            elif '**Status:**' in line:
+                current_model["status"] = line.split('**Status:**')[1].strip()
+        
+        if current_model:
+            models.append(current_model)
+        
+        return models
+    
+    async def _http_list_models(self) -> List[Dict[str, Any]]:
+        """HTTP fallback for listing models"""
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.post(
+                f"{self.space_url}/api/predict",
+                json={"fn_index": 2}  # Index of list_trained_models
+            )
+            response.raise_for_status()
+            result = response.json()
+            return self._parse_models_list(result.get("data", [""])[0])
+    
+    async def download_model(
+        self,
+        model_id: str,
+        local_path: Optional[str] = None
+    ) -> str:
+        """
+        Download a trained model from Hugging Face Hub
+        
+        Args:
+            model_id: Model identifier
+            local_path: Optional local path to save model
+            
+        Returns:
+            Path to downloaded model
+        """
+        try:
+            if not HF_HUB_AVAILABLE:
+                raise ImportError("huggingface_hub not installed")
+            
+            model_filename = f"{model_id}_model.pkl"
+            scaler_filename = f"{model_id}_scaler.pkl"
+            
+            model_path = hf_hub_download(
+                repo_id=self.models_repo,
+                filename=model_filename,
+                token=self.hf_token,
+                cache_dir=str(self.models_cache_dir)
+            )
+            
+            try:
+                scaler_path = hf_hub_download(
+                    repo_id=self.models_repo,
+                    filename=scaler_filename,
+                    token=self.hf_token,
+                    cache_dir=str(self.models_cache_dir)
+                )
+            except:
+                scaler_path = None
+            
+            logger.info(f"✅ Downloaded model: {model_id}")
+            return model_path
+            
+        except Exception as e:
+            logger.error(f"Failed to download model: {e}")
+            raise
+    
+    # =========================================================================
+    # TRAINING REQUESTS
+    # =========================================================================
+    
+    async def request_training(
+        self,
+        dataset_url: str,
+        task_type: str,
+        model_type: str,
+        target_column: str,
+        model_name: str,
+        test_size: float = 0.2,
+        callback_url: Optional[str] = None
+    ) -> Dict[str, Any]:
+        """
+        Request model training on the Space
+        
+        Args:
+            dataset_url: URL to download dataset
+            task_type: Type of security task
+            model_type: ML model type
+            target_column: Target column name
+            model_name: Name for trained model
+            test_size: Test split ratio
+            callback_url: Optional webhook for training completion
+            
+        Returns:
+            Training job status
+        """
+        try:
+            # Note: This would need custom implementation in the Space
+            # to support remote dataset URLs and callbacks
+            logger.info(f"Requesting training for {model_name}")
+            
+            return {
+                "status": "submitted",
+                "model_name": model_name,
+                "task_type": task_type,
+                "message": "Training request submitted. Check Space for status."
+            }
+            
+        except Exception as e:
+            logger.error(f"Training request failed: {e}")
+            return {"error": str(e)}
+    
+    # =========================================================================
+    # HEALTH & STATUS
+    # =========================================================================
+    
+    async def health_check(self) -> Dict[str, Any]:
+        """Check if the Space is healthy and responsive"""
+        try:
+            async with httpx.AsyncClient(timeout=10.0) as client:
+                response = await client.get(f"{self.space_url}")
+                
+                return {
+                    "status": "healthy" if response.status_code == 200 else "unhealthy",
+                    "space_id": self.space_id,
+                    "url": self.space_url,
+                    "response_code": response.status_code,
+                    "timestamp": datetime.now().isoformat()
+                }
+        except Exception as e:
+            return {
+                "status": "error",
+                "error": str(e),
+                "space_id": self.space_id,
+                "timestamp": datetime.now().isoformat()
+            }
+    
+    async def get_space_info(self) -> Dict[str, Any]:
+        """Get information about the Space"""
+        try:
+            if HF_HUB_AVAILABLE and self._hf_api:
+                info = self._hf_api.space_info(self.space_id)
+                return {
+                    "id": info.id,
+                    "author": info.author,
+                    "sdk": info.sdk,
+                    "status": info.runtime.stage if info.runtime else "unknown",
+                    "hardware": info.runtime.hardware if info.runtime else "unknown",
+                }
+            return {"space_id": self.space_id}
+        except Exception as e:
+            return {"error": str(e)}
+
+
+# ============================================================================
+# CONVENIENCE FUNCTIONS FOR BACKEND
+# ============================================================================
+
+# Global client instance
+_hf_client: Optional[HuggingFaceClient] = None
+
+
+def get_hf_client() -> HuggingFaceClient:
+    """Get or create the global HF client"""
+    global _hf_client
+    if _hf_client is None:
+        _hf_client = HuggingFaceClient()
+    return _hf_client
+
+
+async def predict_threat(model_id: str, features: Dict[str, Any]) -> Dict[str, Any]:
+    """Convenience function for threat prediction"""
+    client = get_hf_client()
+    return await client.predict(model_id, features)
+
+
+async def batch_predict_threats(
+    model_id: str, 
+    batch_features: List[Dict[str, Any]]
+) -> List[Dict[str, Any]]:
+    """Convenience function for batch threat prediction"""
+    client = get_hf_client()
+    return await client.batch_predict(model_id, batch_features)
+
+
+async def get_available_models() -> List[Dict[str, Any]]:
+    """Get list of available models"""
+    client = get_hf_client()
+    return await client.list_models()
+
+
+# ============================================================================
+# EXAMPLE USAGE
+# ============================================================================
+
+if __name__ == "__main__":
+    async def main():
+        # Initialize client
+        client = HuggingFaceClient(
+            space_id="Che237/cyberforge",
+            hf_token=os.getenv("HF_TOKEN")
+        )
+        
+        # Health check
+        health = await client.health_check()
+        print(f"Health: {health}")
+        
+        # List models
+        models = await client.list_models()
+        print(f"Available models: {models}")
+        
+        # Example prediction
+        if models:
+            model_id = models[0]["id"]
+            features = {"feature1": 0.5, "feature2": 1.2, "feature3": 0.8}
+            result = await client.predict(model_id, features)
+            print(f"Prediction: {result}")
+    
+    asyncio.run(main())

requirements.txt

@@ -0,0 +1,31 @@
+# CyberForge AI - Hugging Face Space Requirements
+# Core Gradio and web dependencies
+gradio>=4.0.0
+gradio_client>=0.7.0
+
+# ML and Data Science
+scikit-learn>=1.3.0
+pandas>=2.1.0
+numpy>=1.26.0
+joblib>=1.3.0
+
+# Deep Learning
+torch>=2.0.0
+transformers>=4.30.0
+
+# Hugging Face Hub
+huggingface_hub>=0.19.0
+
+# Additional ML
+xgboost>=1.7.0
+imbalanced-learn>=0.11.0
+
+# Visualization (optional)
+matplotlib>=3.7.0
+seaborn>=0.12.0
+plotly>=5.15.0
+
+# Utilities
+python-dotenv>=1.0.0
+aiofiles>=23.2.1
+httpx>=0.25.0

trainer.py

@@ -0,0 +1,459 @@
+"""
+Advanced Cybersecurity Model Trainer
+Comprehensive training module for security ML models
+"""
+
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader, TensorDataset
+from sklearn.model_selection import train_test_split, cross_val_score, StratifiedKFold
+from sklearn.ensemble import (
+    RandomForestClassifier, 
+    GradientBoostingClassifier, 
+    AdaBoostClassifier,
+    ExtraTreesClassifier,
+    VotingClassifier,
+    StackingClassifier
+)
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import SVC
+from sklearn.neural_network import MLPClassifier
+from sklearn.preprocessing import StandardScaler, LabelEncoder, MinMaxScaler
+from sklearn.metrics import (
+    classification_report, 
+    confusion_matrix, 
+    roc_auc_score,
+    precision_recall_curve,
+    f1_score,
+    accuracy_score
+)
+from sklearn.feature_selection import SelectKBest, f_classif, mutual_info_classif
+from sklearn.decomposition import PCA
+import joblib
+import json
+from datetime import datetime
+from pathlib import Path
+import logging
+from typing import Dict, List, Any, Optional, Tuple
+import warnings
+warnings.filterwarnings('ignore')
+
+logger = logging.getLogger(__name__)
+
+
+class CyberSecurityNeuralNet(nn.Module):
+    """Deep Neural Network for Cybersecurity Classification"""
+    
+    def __init__(self, input_size: int, hidden_sizes: List[int], num_classes: int, dropout: float = 0.3):
+        super().__init__()
+        
+        layers = []
+        prev_size = input_size
+        
+        for hidden_size in hidden_sizes:
+            layers.extend([
+                nn.Linear(prev_size, hidden_size),
+                nn.BatchNorm1d(hidden_size),
+                nn.ReLU(),
+                nn.Dropout(dropout)
+            ])
+            prev_size = hidden_size
+        
+        layers.append(nn.Linear(prev_size, num_classes))
+        
+        self.network = nn.Sequential(*layers)
+    
+    def forward(self, x):
+        return self.network(x)
+
+
+class AdvancedSecurityTrainer:
+    """Advanced trainer for cybersecurity models with multiple algorithms"""
+    
+    def __init__(self, models_dir: str = "./trained_models"):
+        self.models_dir = Path(models_dir)
+        self.models_dir.mkdir(exist_ok=True)
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.trained_models = {}
+        self.training_history = []
+        
+    def preprocess_security_data(
+        self, 
+        df: pd.DataFrame, 
+        target_col: str,
+        feature_selection: bool = True,
+        n_features: int = 50
+    ) -> Tuple[np.ndarray, np.ndarray, StandardScaler, LabelEncoder, List[str]]:
+        """Preprocess security data with advanced feature engineering"""
+        
+        # Separate features and target
+        X = df.drop(columns=[target_col])
+        y = df[target_col]
+        
+        # Store original feature names
+        feature_names = list(X.columns)
+        
+        # Handle categorical features
+        categorical_cols = X.select_dtypes(include=['object', 'category']).columns
+        for col in categorical_cols:
+            le = LabelEncoder()
+            X[col] = le.fit_transform(X[col].astype(str))
+        
+        # Handle missing values
+        X = X.fillna(X.median())
+        
+        # Encode target if categorical
+        label_encoder = LabelEncoder()
+        if y.dtype == 'object' or y.dtype.name == 'category':
+            y = label_encoder.fit_transform(y)
+        else:
+            y = y.values
+        
+        # Scale features
+        scaler = StandardScaler()
+        X_scaled = scaler.fit_transform(X)
+        
+        # Feature selection
+        if feature_selection and X_scaled.shape[1] > n_features:
+            selector = SelectKBest(mutual_info_classif, k=min(n_features, X_scaled.shape[1]))
+            X_scaled = selector.fit_transform(X_scaled, y)
+            selected_indices = selector.get_support(indices=True)
+            feature_names = [feature_names[i] for i in selected_indices]
+        
+        return X_scaled, y, scaler, label_encoder, feature_names
+    
+    def train_ensemble_model(
+        self,
+        X_train: np.ndarray,
+        y_train: np.ndarray,
+        X_test: np.ndarray,
+        y_test: np.ndarray,
+        model_name: str = "ensemble"
+    ) -> Tuple[Any, Dict[str, float]]:
+        """Train an ensemble of classifiers"""
+        
+        logger.info("Training ensemble model...")
+        
+        # Base estimators
+        estimators = [
+            ('rf', RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1)),
+            ('gb', GradientBoostingClassifier(n_estimators=100, random_state=42)),
+            ('et', ExtraTreesClassifier(n_estimators=100, random_state=42, n_jobs=-1)),
+        ]
+        
+        # Voting classifier
+        voting_clf = VotingClassifier(estimators=estimators, voting='soft')
+        voting_clf.fit(X_train, y_train)
+        
+        # Evaluate
+        y_pred = voting_clf.predict(X_test)
+        y_proba = voting_clf.predict_proba(X_test)
+        
+        metrics = self._calculate_metrics(y_test, y_pred, y_proba)
+        
+        # Save model
+        model_path = self.models_dir / f"{model_name}_ensemble.pkl"
+        joblib.dump(voting_clf, model_path)
+        
+        logger.info(f"Ensemble model trained with accuracy: {metrics['accuracy']:.4f}")
+        
+        return voting_clf, metrics
+    
+    def train_stacking_model(
+        self,
+        X_train: np.ndarray,
+        y_train: np.ndarray,
+        X_test: np.ndarray,
+        y_test: np.ndarray,
+        model_name: str = "stacking"
+    ) -> Tuple[Any, Dict[str, float]]:
+        """Train a stacking classifier"""
+        
+        logger.info("Training stacking model...")
+        
+        # Base estimators
+        estimators = [
+            ('rf', RandomForestClassifier(n_estimators=50, random_state=42)),
+            ('gb', GradientBoostingClassifier(n_estimators=50, random_state=42)),
+            ('svm', SVC(probability=True, random_state=42)),
+        ]
+        
+        # Stacking classifier with logistic regression meta-learner
+        stacking_clf = StackingClassifier(
+            estimators=estimators,
+            final_estimator=LogisticRegression(random_state=42),
+            cv=3
+        )
+        stacking_clf.fit(X_train, y_train)
+        
+        # Evaluate
+        y_pred = stacking_clf.predict(X_test)
+        y_proba = stacking_clf.predict_proba(X_test)
+        
+        metrics = self._calculate_metrics(y_test, y_pred, y_proba)
+        
+        # Save model
+        model_path = self.models_dir / f"{model_name}_stacking.pkl"
+        joblib.dump(stacking_clf, model_path)
+        
+        logger.info(f"Stacking model trained with accuracy: {metrics['accuracy']:.4f}")
+        
+        return stacking_clf, metrics
+    
+    def train_neural_network(
+        self,
+        X_train: np.ndarray,
+        y_train: np.ndarray,
+        X_test: np.ndarray,
+        y_test: np.ndarray,
+        hidden_sizes: List[int] = [256, 128, 64],
+        epochs: int = 100,
+        batch_size: int = 32,
+        learning_rate: float = 0.001,
+        model_name: str = "neural_net"
+    ) -> Tuple[nn.Module, Dict[str, float]]:
+        """Train a deep neural network"""
+        
+        logger.info(f"Training neural network on {self.device}...")
+        
+        # Convert to tensors
+        X_train_tensor = torch.FloatTensor(X_train).to(self.device)
+        y_train_tensor = torch.LongTensor(y_train).to(self.device)
+        X_test_tensor = torch.FloatTensor(X_test).to(self.device)
+        y_test_tensor = torch.LongTensor(y_test).to(self.device)
+        
+        # Create data loader
+        train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
+        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+        
+        # Initialize model
+        num_classes = len(np.unique(y_train))
+        model = CyberSecurityNeuralNet(
+            input_size=X_train.shape[1],
+            hidden_sizes=hidden_sizes,
+            num_classes=num_classes
+        ).to(self.device)
+        
+        # Loss and optimizer
+        criterion = nn.CrossEntropyLoss()
+        optimizer = optim.Adam(model.parameters(), lr=learning_rate)
+        scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=10)
+        
+        # Training loop
+        best_accuracy = 0
+        for epoch in range(epochs):
+            model.train()
+            total_loss = 0
+            
+            for batch_X, batch_y in train_loader:
+                optimizer.zero_grad()
+                outputs = model(batch_X)
+                loss = criterion(outputs, batch_y)
+                loss.backward()
+                optimizer.step()
+                total_loss += loss.item()
+            
+            # Validation
+            model.eval()
+            with torch.no_grad():
+                test_outputs = model(X_test_tensor)
+                test_loss = criterion(test_outputs, y_test_tensor)
+                _, predicted = torch.max(test_outputs, 1)
+                accuracy = (predicted == y_test_tensor).float().mean().item()
+            
+            scheduler.step(test_loss)
+            
+            if accuracy > best_accuracy:
+                best_accuracy = accuracy
+                torch.save(model.state_dict(), self.models_dir / f"{model_name}_nn_best.pt")
+            
+            if (epoch + 1) % 20 == 0:
+                logger.info(f"Epoch [{epoch+1}/{epochs}], Loss: {total_loss/len(train_loader):.4f}, Accuracy: {accuracy:.4f}")
+        
+        # Final evaluation
+        model.eval()
+        with torch.no_grad():
+            outputs = model(X_test_tensor)
+            _, y_pred = torch.max(outputs, 1)
+            y_pred = y_pred.cpu().numpy()
+            y_proba = torch.softmax(outputs, dim=1).cpu().numpy()
+        
+        metrics = self._calculate_metrics(y_test, y_pred, y_proba)
+        
+        logger.info(f"Neural network trained with accuracy: {metrics['accuracy']:.4f}")
+        
+        return model, metrics
+    
+    def train_all_models(
+        self,
+        df: pd.DataFrame,
+        target_col: str,
+        model_name: str,
+        test_size: float = 0.2
+    ) -> Dict[str, Any]:
+        """Train all available model types and return best performing"""
+        
+        logger.info(f"Starting comprehensive training for {model_name}...")
+        
+        # Preprocess data
+        X, y, scaler, label_encoder, feature_names = self.preprocess_security_data(df, target_col)
+        
+        # Split data
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=test_size, random_state=42, stratify=y
+        )
+        
+        results = {}
+        
+        # Train individual models
+        models_to_train = [
+            ("random_forest", RandomForestClassifier(n_estimators=100, random_state=42, n_jobs=-1)),
+            ("gradient_boosting", GradientBoostingClassifier(n_estimators=100, random_state=42)),
+            ("extra_trees", ExtraTreesClassifier(n_estimators=100, random_state=42, n_jobs=-1)),
+            ("logistic_regression", LogisticRegression(random_state=42, max_iter=1000)),
+            ("mlp", MLPClassifier(hidden_layer_sizes=(128, 64), random_state=42, max_iter=500)),
+        ]
+        
+        for name, model in models_to_train:
+            try:
+                logger.info(f"Training {name}...")
+                model.fit(X_train, y_train)
+                y_pred = model.predict(X_test)
+                y_proba = model.predict_proba(X_test) if hasattr(model, 'predict_proba') else None
+                
+                metrics = self._calculate_metrics(y_test, y_pred, y_proba)
+                results[name] = {
+                    "model": model,
+                    "metrics": metrics
+                }
+                
+                # Save model
+                model_path = self.models_dir / f"{model_name}_{name}.pkl"
+                joblib.dump(model, model_path)
+                
+            except Exception as e:
+                logger.error(f"Failed to train {name}: {e}")
+                results[name] = {"error": str(e)}
+        
+        # Train ensemble
+        try:
+            ensemble_model, ensemble_metrics = self.train_ensemble_model(
+                X_train, y_train, X_test, y_test, model_name
+            )
+            results["ensemble"] = {
+                "model": ensemble_model,
+                "metrics": ensemble_metrics
+            }
+        except Exception as e:
+            logger.error(f"Failed to train ensemble: {e}")
+        
+        # Train stacking
+        try:
+            stacking_model, stacking_metrics = self.train_stacking_model(
+                X_train, y_train, X_test, y_test, model_name
+            )
+            results["stacking"] = {
+                "model": stacking_model,
+                "metrics": stacking_metrics
+            }
+        except Exception as e:
+            logger.error(f"Failed to train stacking: {e}")
+        
+        # Find best model
+        best_model_name = None
+        best_accuracy = 0
+        for name, result in results.items():
+            if "metrics" in result and result["metrics"]["accuracy"] > best_accuracy:
+                best_accuracy = result["metrics"]["accuracy"]
+                best_model_name = name
+        
+        # Save preprocessing artifacts
+        joblib.dump(scaler, self.models_dir / f"{model_name}_scaler.pkl")
+        joblib.dump(label_encoder, self.models_dir / f"{model_name}_label_encoder.pkl")
+        
+        # Save metadata
+        metadata = {
+            "model_name": model_name,
+            "target_column": target_col,
+            "feature_names": feature_names,
+            "num_features": len(feature_names),
+            "num_samples": len(df),
+            "num_classes": len(np.unique(y)),
+            "best_model": best_model_name,
+            "best_accuracy": best_accuracy,
+            "all_results": {
+                name: result.get("metrics", {"error": result.get("error")})
+                for name, result in results.items()
+            },
+            "created_at": datetime.now().isoformat()
+        }
+        
+        with open(self.models_dir / f"{model_name}_metadata.json", 'w') as f:
+            json.dump(metadata, f, indent=2)
+        
+        logger.info(f"Training complete. Best model: {best_model_name} with accuracy: {best_accuracy:.4f}")
+        
+        return {
+            "results": results,
+            "metadata": metadata,
+            "scaler": scaler,
+            "label_encoder": label_encoder,
+            "feature_names": feature_names
+        }
+    
+    def _calculate_metrics(
+        self, 
+        y_true: np.ndarray, 
+        y_pred: np.ndarray, 
+        y_proba: Optional[np.ndarray] = None
+    ) -> Dict[str, float]:
+        """Calculate comprehensive metrics"""
+        
+        metrics = {
+            "accuracy": float(accuracy_score(y_true, y_pred)),
+            "f1_weighted": float(f1_score(y_true, y_pred, average='weighted')),
+            "f1_macro": float(f1_score(y_true, y_pred, average='macro')),
+        }
+        
+        # ROC AUC for binary or multi-class
+        if y_proba is not None:
+            try:
+                if len(np.unique(y_true)) == 2:
+                    metrics["roc_auc"] = float(roc_auc_score(y_true, y_proba[:, 1]))
+                else:
+                    metrics["roc_auc"] = float(roc_auc_score(y_true, y_proba, multi_class='ovr'))
+            except:
+                pass
+        
+        return metrics
+
+
+# Convenience function for Gradio interface
+def train_comprehensive_model(
+    file_path: str,
+    target_column: str,
+    model_name: str,
+    test_size: float = 0.2
+) -> Dict[str, Any]:
+    """Train comprehensive models from file path"""
+    
+    # Load dataset
+    if file_path.endswith('.csv'):
+        df = pd.read_csv(file_path)
+    elif file_path.endswith('.json'):
+        df = pd.read_json(file_path)
+    elif file_path.endswith('.parquet'):
+        df = pd.read_parquet(file_path)
+    else:
+        raise ValueError(f"Unsupported file format: {file_path}")
+    
+    # Initialize trainer
+    trainer = AdvancedSecurityTrainer()
+    
+    # Train all models
+    results = trainer.train_all_models(df, target_column, model_name, test_size)
+    
+    return results