Upload 5 files

DEPLOY-GUIDE.md

@@ -0,0 +1,210 @@
+# Deploy to Hugging Face Space
+
+## Step 1: Create the Space
+
+1. Go to **https://huggingface.co/spaces**
+2. Click **Create new Space**
+3. Fill in:
+   - **Space name**: `sleep-stage-classifier`
+   - **License**: MIT
+   - **SDK**: **Gradio**
+   - **Visibility**: Public
+4. Click **Create Space**
+
+---
+
+## Step 2: Upload Files
+
+In your new Space, go to the **Files** tab → **Add file** → **Upload files**.
+
+Upload these **3 files** from the `hf-space/` folder:
+
+| File | Purpose |
+|------|---------|
+| `requirements.txt` | Python dependencies |
+| `app.py` | Gradio web app + model inference |
+| `sleep_stage_cnn.pth` | Your trained model weights |
+
+> ⚠️ Make sure you upload **all 3 files**. The Space won't work without the `.pth` model file.
+
+---
+
+## Step 3: Wait for Build
+
+The Space will automatically build. You'll see a **Building** status, then a green ✅ when ready.
+
+This takes ~2-5 minutes (downloading PyTorch + other deps).
+
+---
+
+## Step 4: Test It
+
+Once the green checkmark appears, the Space URL is:
+
+```
+https://<your-username>-sleep-stage-classifier.hf.space
+```
+
+Upload a CSV file with EEG data to test classification.
+
+---
+
+# Integrate with Lovable
+
+## Method 1: Gradio Client (Recommended)
+
+In your Lovable project, install the Gradio JS client:
+
+```bash
+npm install @gradio/client
+```
+
+Then add this code to your component:
+
+```tsx
+import { Client } from "@gradio/client";
+
+// Replace with your actual Space URL
+const SPACE_URL = "https://<your-username>-sleep-stage-classifier.hf.space";
+
+async function classifyEEG(file: File) {
+  const client = await Client.connect(SPACE_URL);
+  const result = await client.predict("/predict", { file });
+  return result.data; // [textOutput, jsonOutput]
+}
+```
+
+### Full Example Component
+
+```tsx
+import { useState } from "react";
+import { Client } from "@gradio/client";
+
+const SPACE_URL = "https://<your-username>-sleep-stage-classifier.hf.space";
+
+export default function SleepClassifier() {
+  const [loading, setLoading] = useState(false);
+  const [results, setResults] = useState<any>(null);
+
+  const handleUpload = async (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0];
+    if (!file) return;
+
+    setLoading(true);
+    try {
+      const client = await Client.connect(SPACE_URL);
+      const [textOutput, jsonOutput] = await client.predict("/predict", { file });
+      setResults(jsonOutput);
+    } catch (err) {
+      console.error("Classification failed:", err);
+    }
+    setLoading(false);
+  };
+
+  return (
+    <div className="p-6 max-w-2xl mx-auto">
+      <h1 className="text-2xl font-bold mb-4">😴 Sleep Stage Classifier</h1>
+
+      <input type="file" accept=".csv,.txt,.npy" onChange={handleUpload} />
+
+      {loading && <p className="mt-4">Classifying...</p>}
+
+      {results && (
+        <div className="mt-4">
+          <h2 className="text-lg font-semibold">Results</h2>
+          <p>{results.epochs.length} epochs classified</p>
+
+          <div className="mt-2 space-y-1">
+            {Object.entries(results.summary).map(([stage, stats]: [string, any]) => (
+              <div key={stage} className="flex items-center gap-2">
+                <span className="w-12">{stage}</span>
+                <span>{stats.count} ({stats.percentage}%)</span>
+                <div className="flex-1 bg-gray-200 rounded h-4">
+                  <div
+                    className="bg-blue-500 h-4 rounded"
+                    style={{ width: `${stats.percentage}%` }}
+                  />
+                </div>
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}
+```
+
+---
+
+## Method 2: Direct HTTP Fetch
+
+If you prefer not to install `@gradio/client`:
+
+```typescript
+async function classifyEEG(file: File) {
+  const formData = new FormData();
+  formData.append("files", file);
+
+  const res = await fetch(
+    `${SPACE_URL}/gradio_api/call/predict`,
+    {
+      method: "POST",
+      body: formData,
+    }
+  );
+
+  const result = await res.json();
+  return result;
+}
+```
+
+---
+
+## Expected JSON Response Format
+
+```json
+{
+  "epochs": [
+    {
+      "epoch": 1,
+      "stage": "Wake",
+      "confidence": 0.92,
+      "probabilities": {
+        "Wake": 0.92,
+        "N1": 0.03,
+        "N2": 0.02,
+        "N3": 0.01,
+        "N4": 0.01,
+        "REM": 0.01
+      }
+    }
+  ],
+  "summary": {
+    "Wake":    { "count": 50, "percentage": 45.5 },
+    "N1":      { "count": 10, "percentage": 9.1 },
+    "N2":      { "count": 25, "percentage": 22.7 },
+    "N3":      { "count": 15, "percentage": 13.6 },
+    "N4":      { "count": 5,  "percentage": 4.5 },
+    "REM":     { "count": 5,  "percentage": 4.5 }
+  }
+}
+```
+
+---
+
+## File Format
+
+Your input file should be:
+- **CSV/TXT**: Single column of numbers (EEG amplitude values), no header needed
+- **NPY**: NumPy array, 1D
+- **Sampling rate**: Assumed 100 Hz
+- **Minimum length**: 3000 samples (30 seconds)
+
+Example CSV:
+```csv
+0.023
+-0.015
+0.042
+...
+```

README.md

@@ -1,13 +1,46 @@
 ---
-title: EEG Sleep
-emoji: 📚
-colorFrom: indigo
-colorTo: blue
+title: Sleep Stage Classifier
+emoji: 😴
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.12.0
+sdk_version: 5.0.0
 app_file: app.py
 pinned: false
 license: mit
+short_description: Classify sleep stages from raw EEG signals
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 😴 Sleep Stage Classification
+
+Upload a CSV, TXT, or NPY file containing raw EEG signal data (100 Hz sampling rate).
+The model classifies the signal into 30-second epochs across 6 sleep stages: **Wake, N1, N2, N3, N4, REM**.
+
+## Model Architecture
+
+- **Type**: 1D Convolutional Neural Network
+- **Framework**: PyTorch
+- **Input**: Single-channel EEG, 3000 samples per epoch (30s at 100 Hz)
+- **Output**: 6-class classification logits → softmax probabilities
+
+## API Usage
+
+```python
+from gradio_client import Client
+
+client = Client("<your-username>/sleep-stage-classifier")
+result = client.predict(file="path/to/eeg.csv")
+print(result)
+```
+
+## Lovable / Frontend Integration
+
+```javascript
+import { Client } from "@gradio/client";
+
+const client = await Client.connect(
+  "https://<your-username>-sleep-stage-classifier.hf.space"
+);
+const result = await client.predict("/predict", { file: yourFile });
+console.log(result.data);
+```

app.py

@@ -0,0 +1,330 @@
+"""
+Hugging Face Space — Sleep Stage Classification
+================================================
+Gradio app that serves the pre-trained CNN model for inference.
+Callable from any frontend via the Gradio API.
+
+Space URL: https://<your-username>-sleep-stage-classifier.hf.space
+"""
+
+import io
+import os
+import json
+import numpy as np
+import pandas as pd
+import gradio as gr
+import torch
+import torch.nn as nn
+from collections import Counter
+
+# ────────────────────────────────────────────────────────────────
+# Constants
+# ────────────────────────────────────────────────────────────────
+SFREQ = 100
+EPOCH_SAMPLES = 3000  # 30 seconds × 100 Hz
+STAGES = ["Wake", "N1", "N2", "N3", "N4", "REM"]
+MODEL_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "sleep_stage_cnn.pth")
+
+
+# ────────────────────────────────────────────────────────────────
+# Model Definition (must match training architecture exactly)
+# ────────────────────────────────────────────────────────────────
+
+class SleepStageCNN(nn.Module):
+    """
+    1D Convolutional Neural Network for Sleep Stage Classification.
+    Architecture matches the training notebook.
+    """
+
+    def __init__(self, n_channels=1, n_classes=6):
+        super().__init__()
+        self.network = nn.Sequential(
+            # Block 1: large receptive field for slow-wave features
+            nn.Conv1d(n_channels, 32, kernel_size=50, stride=6),
+            nn.BatchNorm1d(32),
+            nn.ReLU(),
+            nn.MaxPool1d(8),
+
+            # Block 2: finer feature extraction
+            nn.Conv1d(32, 64, kernel_size=8),
+            nn.BatchNorm1d(64),
+            nn.ReLU(),
+            nn.MaxPool1d(8),
+
+            # Classifier head
+            nn.Flatten(),
+            nn.Linear(64 * 6, 128),
+            nn.ReLU(),
+            nn.Dropout(0.5),
+            nn.Linear(128, n_classes),
+        )
+
+    def forward(self, x):
+        return self.network(x)
+
+
+# ────────────────────────────────────────────────────────────────
+# Load Model at startup
+# ────────────────────────────────────────────────────────────────
+
+device = torch.device("cpu")
+model = SleepStageCNN(n_channels=1, n_classes=6)
+
+if os.path.exists(MODEL_PATH):
+    checkpoint = torch.load(
+        MODEL_PATH, map_location=device, weights_only=False
+    )
+    if isinstance(checkpoint, dict) and "model_state_dict" in checkpoint:
+        model.load_state_dict(checkpoint["model_state_dict"])
+    else:
+        model.load_state_dict(checkpoint)
+    model.eval().to(device)
+    print(f"✅ Model loaded from {MODEL_PATH}")
+else:
+    raise FileNotFoundError(
+        f"Model file not found at {MODEL_PATH}. "
+        "Upload sleep_stage_cnn.pth to this Space."
+    )
+
+
+# ────────────────────────────────────────────────────────────────
+# Inference Function
+# ────────────────────────────────────────────────────────────────
+
+def classify_eeg(signal: np.ndarray) -> dict:
+    """
+    Run inference on a 1D EEG signal.
+
+    Parameters
+    ----------
+    signal : np.ndarray
+        Raw EEG data (1D array, assumed 100 Hz sampling rate).
+
+    Returns
+    -------
+    dict with keys:
+        - epochs: list of {epoch, stage, confidence}
+        - summary: dict of stage → "count (percentage%)"
+    """
+    if len(signal) < EPOCH_SAMPLES:
+        return {
+            "error": (
+                f"Signal too short. Need at least {EPOCH_SAMPLES} samples "
+                f"(30s at 100 Hz), got {len(signal)}."
+            )
+        }
+
+    predictions = []
+    for i in range(0, len(signal) - EPOCH_SAMPLES + 1, EPOCH_SAMPLES):
+        epoch = signal[i: i + EPOCH_SAMPLES]
+
+        # Z-score normalize
+        mean = epoch.mean()
+        std = epoch.std()
+        if std == 0:
+            std = 1.0
+        epoch_norm = (epoch - mean) / std
+
+        # Forward pass
+        x = torch.tensor(
+            epoch_norm, dtype=torch.float32
+        ).unsqueeze(0).unsqueeze(0).to(device)
+
+        with torch.no_grad():
+            logits = model(x)
+            probs = torch.softmax(logits, dim=1).cpu().numpy()[0]
+            pred_idx = int(logits.argmax().item())
+
+        predictions.append({
+            "epoch": len(predictions) + 1,
+            "stage": STAGES[pred_idx],
+            "confidence": round(float(max(probs)), 4),
+            "probabilities": {
+                STAGES[j]: round(float(probs[j]), 4)
+                for j in range(len(STAGES))
+            },
+        })
+
+    # Summary statistics
+    counts = Counter(p["stage"] for p in predictions)
+    total = len(predictions)
+
+    return {
+        "epochs": predictions,
+        "summary": {
+            stage: {
+                "count": counts.get(stage, 0),
+                "percentage": round(counts.get(stage, 0) / total * 100, 1)
+            }
+            for stage in STAGES
+        },
+    }
+
+
+# ────────────────────────────────────────────────────────────────
+# File Processor (called by Gradio UI)
+# ────────────────────────────────────────────────────────────────
+
+def process_file(file) -> tuple:
+    """
+    Process uploaded EEG file and return readable results + raw JSON.
+
+    Parameters
+    ----------
+    file : file-like or str path
+        Uploaded CSV / TXT / NPY file.
+
+    Returns
+    -------
+    (text_output, json_output)
+    """
+    if file is None:
+        return "⚠️ Please upload a file.", None
+
+    try:
+        # Determine file type and load signal
+        name = file.name.lower() if hasattr(file, "name") else str(file).lower()
+
+        if name.endswith(".npy"):
+            signal = np.load(file)
+            if signal.ndim > 1:
+                signal = signal.flatten()
+        else:
+            # CSV or TXT — first column
+            df = pd.read_csv(file, header=None, sep=None, engine="python")
+            signal = df.iloc[:, 0].values.astype(np.float64)
+
+        # Run inference
+        result = classify_eeg(signal)
+
+        if "error" in result:
+            return f"❌ {result['error']}", None
+
+        # Build readable text output
+        lines = []
+        lines.append(f"📊 Total epochs classified: {len(result['epochs'])}")
+        lines.append("")
+        lines.append("📋 Stage Distribution:")
+        lines.append("-" * 40)
+        for stage, stats in result["summary"].items():
+            bar = "█" * int(stats["percentage"] / 2)
+            lines.append(f"  {stage:6s}: {stats['count']:4d} ({stats['percentage']:5.1f}%) {bar}")
+
+        lines.append("")
+        lines.append("📝 Epoch Details (first 20):")
+        lines.append("-" * 40)
+        for ep in result["epochs"][:20]:
+            lines.append(
+                f"  Epoch {ep['epoch']:>3d}: {ep['stage']:5s}  "
+                f"confidence {ep['confidence']*100:.1f}%"
+            )
+
+        text_output = "\n".join(lines)
+        json_output = result  # Gradio will auto-serialize to JSON
+
+        return text_output, json_output
+
+    except Exception as e:
+        return f"❌ Error: {str(e)}", None
+
+
+# ────────────────────────────────────────────────────────────────
+# Gradio Interface
+# ────────────────────────────────────────────────────────────────
+
+with gr.Blocks(
+    title="Sleep Stage Classifier",
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="slate",
+    ),
+) as demo:
+
+    gr.Markdown(
+        """
+        # 😴 Sleep Stage Classification
+
+        Upload a **CSV**, **TXT**, or **NPY** file containing raw EEG signal data.
+        The model assumes a **100 Hz sampling rate** and classifies the signal
+        into 30-second epochs.
+
+        | Stage | Description |
+        |-------|-------------|
+        | **Wake** | Awake, eyes open/closed |
+        | **N1** | Light sleep, transition |
+        | **N2** | Deeper sleep, spindles + K-complexes |
+        | **N3** | Slow-wave sleep (deep) |
+        | **N4** | Very deep slow-wave sleep |
+        | **REM** | Rapid eye movement (dreaming) |
+        """
+    )
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            file_input = gr.File(
+                label="Upload EEG file",
+                file_types=[".csv", ".txt", ".npy"],
+            )
+            btn = gr.Button("🔍 Classify", variant="primary", size="lg")
+
+            gr.Examples(
+                label="Tip",
+                examples=["Upload a single-column CSV with EEG amplitude values"],
+                inputs=[],
+            )
+
+        with gr.Column(scale=2):
+            text_output = gr.Textbox(
+                label="Results",
+                lines=20,
+                interactive=False,
+            )
+            json_output = gr.JSON(
+                label="Raw JSON (for API integration)",
+            )
+
+    btn.click(
+        fn=process_file,
+        inputs=[file_input],
+        outputs=[text_output, json_output],
+    )
+
+    gr.Markdown(
+        """
+        ---
+        ### 🔌 API Access
+
+        You can call this Space programmatically from any frontend:
+
+        ```bash
+        pip install gradio_client
+        ```
+
+        ```python
+        from gradio_client import Client
+
+        client = Client("<your-username>/sleep-stage-classifier")
+        result = client.predict(file="path/to/eeg.csv")
+        print(result)
+        ```
+
+        Or from JavaScript in your Lovable app:
+
+        ```javascript
+        import { Client } from "@gradio/client";
+
+        const client = await Client.connect(
+          "https://<your-username>-sleep-stage-classifier.hf.space"
+        );
+        const result = await client.predict("/predict", { file: yourFile });
+        ```
+        """
+    )
+
+
+# ────────────────────────────────────────────────────────────────
+# Launch
+# ────────────────────────────────────────────────────────────────
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,5 @@
+torch
+numpy
+scipy
+pandas
+gradio

sleep_stage_cnn.pth

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