Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+models/best_eeg_model_200.keras filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1 libglib2.0-0 && rm -rf /var/lib/apt/lists/*
+
+COPY requirements-cloud.txt requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY eeg_server.py .
+COPY models/ models/
+
+ENV MODEL_DIR=/app/models
+ENV PORT=7860
+ENV TRANSFORMERS_CACHE=/app/.cache
+ENV HF_HOME=/app/.cache
+
+EXPOSE 7860
+
+CMD ["uvicorn", "eeg_server:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,8 @@
----
-title: Neuroguard
-emoji: 📈
-colorFrom: green
-colorTo: red
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: NeuroGuard Inference Server
+emoji: "\U0001F9E0"
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+---

eeg_server.py

@@ -0,0 +1,697 @@
+"""
+NeuroGuard Inference Server — EEG + MRI
+
+Loads trained models and serves predictions via HTTP.
+Run with:  python eeg_server.py
+
+EEG: Keras CNN for motor imagery classification from band-power data.
+MRI: ViT classifier from Hugging Face Hub + GradCAM tumor localization.
+"""
+
+import base64
+import io
+import os
+from contextlib import asynccontextmanager
+
+import cv2
+import numpy as np
+from fastapi import FastAPI, File, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from PIL import Image
+from pydantic import BaseModel
+from sklearn.preprocessing import StandardScaler
+
+# ── Path / port configuration ────────────────────────────────────
+# Environment variables let the same code run locally and in Docker.
+# Locally the defaults resolve to the original paths; in the cloud
+# container MODEL_DIR points to /app/models and PORT to 7860.
+MODEL_DIR = os.environ.get("MODEL_DIR", "")
+PORT = int(os.environ.get("PORT", "5000"))
+
+# ── EEG config ──────────────────────────────────────────────────
+EEG_MODEL_PATH = os.environ.get(
+    "EEG_MODEL_PATH",
+    os.path.join("Brain", "best_eeg_model_200.keras") if not MODEL_DIR
+    else os.path.join(MODEL_DIR, "best_eeg_model_200.keras"),
+)
+WINDOW_SIZE = 512
+STRIDE = 32
+NUM_FEATURES = 20
+NUM_CLASSES = 3
+CLASS_LABELS = {0: "Left Motor Imagery", 1: "Right Motor Imagery", 2: "Relaxed State"}
+CHANNEL_NAMES = ["TP9", "AF7", "AF8", "TP10"]
+BAND_NAMES = ["delta", "theta", "alpha", "beta", "gamma"]
+
+# ── MRI config ──────────────────────────────────────────────────
+MRI_HF_MODEL = os.environ.get(
+    "MRI_HF_MODEL", "itistamtran/vit_brain_tumor_multiclass_v2"
+)
+_HF_LABEL_MAP = {
+    "Glioma": "glioma",
+    "Meningioma": "meningioma",
+    "Pituitary Tumor": "pituitary",
+    "No Tumor": "noTumor",
+    "Unknown": "unknown",
+    "glioma": "glioma",
+    "meningioma": "meningioma",
+    "pituitary": "pituitary",
+    "no_tumor": "noTumor",
+    "noTumor": "noTumor",
+    "unknown": "unknown",
+}
+
+# ── Global model handles ───────────────────────────────────────
+eeg_model = None
+mri_classifier = None  # dict: {"model", "processor", "cam", "labels"}
+
+
+def load_eeg_model():
+    global eeg_model
+    if eeg_model is not None:
+        return
+    import tensorflow as tf
+    print(f"Loading EEG Keras model from {EEG_MODEL_PATH}...")
+    eeg_model = tf.keras.models.load_model(EEG_MODEL_PATH)
+    print(f"EEG model loaded. Input: {eeg_model.input_shape}, Output: {eeg_model.output_shape}")
+
+
+def load_mri_classifier():
+    """Lazy-load the HF ViT classifier + GradCAM on first MRI request.
+    Deferring PyTorch import avoids the Windows paging-file crash that
+    occurs when TensorFlow and PyTorch both load at startup."""
+    global mri_classifier
+    if mri_classifier is not None:
+        return
+
+    import torch
+    from transformers import AutoImageProcessor, AutoModelForImageClassification
+    from pytorch_grad_cam import GradCAM
+
+    print(f"[MRI] Downloading/loading ViT classifier from {MRI_HF_MODEL}...")
+    model = AutoModelForImageClassification.from_pretrained(MRI_HF_MODEL)
+    processor = AutoImageProcessor.from_pretrained(MRI_HF_MODEL)
+    model.eval()
+
+    id2label = model.config.id2label
+    labels = {int(k): _HF_LABEL_MAP.get(v, v) for k, v in id2label.items()}
+    print(f"[MRI] Label mapping: {labels}")
+
+    target_layers = [model.vit.encoder.layer[-1].layernorm_before]
+
+    def reshape_transform(tensor, height=14, width=14):
+        result = tensor[:, 1:, :].reshape(
+            tensor.size(0), height, width, tensor.size(2)
+        )
+        return result.permute(0, 3, 1, 2)
+
+    cam = GradCAM(
+        model=model,
+        target_layers=target_layers,
+        reshape_transform=reshape_transform,
+    )
+
+    mri_classifier = {
+        "model": model,
+        "processor": processor,
+        "cam": cam,
+        "labels": labels,
+        "torch": torch,
+    }
+    print(f"[MRI] ViT classifier + GradCAM ready ({sum(p.numel() for p in model.parameters())/1e6:.1f}M params)")
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    load_eeg_model()
+    # MRI classifier lazy-loads on first request (avoids TF+PyTorch startup crash)
+    yield
+
+
+app = FastAPI(title="NeuroGuard Inference Server", version="2.0.0", lifespan=lifespan)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+class EegRequest(BaseModel):
+    channels: list[list[float]]
+    sampling_rate: int = 256
+    channel_names: list[str] | None = None
+
+
+class PredictionItem(BaseModel):
+    window_index: int
+    predicted_class: int
+    label: str
+    confidence: float
+
+
+class EegResponse(BaseModel):
+    predictions: list[PredictionItem]
+    band_powers: dict[str, float]
+    channel_band_powers: dict[str, dict[str, float]]
+    cognitive_metrics: dict[str, float]
+    anomaly_score: float
+    anomalies: list[dict]
+    summary: str
+    details: str
+    is_placeholder: bool = False
+    model_name: str = "NeuroGuard EEG CNN v2.0"
+
+
+@app.get("/health")
+def health():
+    return {
+        "status": "ok",
+        "model_loaded": eeg_model is not None,
+        "eeg_model_loaded": eeg_model is not None,
+        "mri_model_loaded": True,  # always available (auto-downloads from HF Hub)
+    }
+
+
+@app.post("/api/eeg/analyze", response_model=EegResponse)
+def analyze_eeg(req: EegRequest):
+    load_eeg_model()
+
+    num_cols = len(req.channels)
+    num_rows = len(req.channels[0]) if num_cols > 0 else 0
+
+    print(f"[analyze] Received {num_cols} columns x {num_rows} time windows")
+
+    if num_cols != 20:
+        return _empty_response(f"Expected 20 band-power columns, got {num_cols}")
+
+    # Data arrives as 20 columns (band-power time series), transpose to (time, features)
+    data = np.array(req.channels, dtype=np.float32).T  # shape: (num_rows, 20)
+    print(f"[analyze] Data shape after transpose: {data.shape}")
+    print(f"[analyze] Data stats — min: {data.min():.6f}, max: {data.max():.6f}, "
+          f"mean: {data.mean():.6f}, std: {data.std():.6f}")
+
+    # --- Step 1: Compute band powers BEFORE normalization ---
+    band_powers = _compute_band_powers_from_columns(data)
+    channel_band_powers = _compute_channel_band_powers_from_columns(data)
+
+    print(f"[analyze] Band powers: {band_powers}")
+
+    # --- Step 2: Clean NaN/Inf ---
+    col_means = np.nanmean(data, axis=0)
+    col_means = np.where(np.isfinite(col_means), col_means, 0.0)
+    for c in range(data.shape[1]):
+        mask = ~np.isfinite(data[:, c])
+        if mask.any():
+            data[mask, c] = col_means[c]
+
+    # --- Step 3: Z-score normalize (matches training pipeline) ---
+    scaler = StandardScaler()
+    data_normalized = scaler.fit_transform(data)
+
+    print(f"[analyze] Post-normalization stats — min: {data_normalized.min():.4f}, "
+          f"max: {data_normalized.max():.4f}, mean: {data_normalized.mean():.4f}")
+
+    # --- Step 3b: Repeat-pad if we have some data but less than 512 rows ---
+    if 64 <= data_normalized.shape[0] < WINDOW_SIZE:
+        original_len = data_normalized.shape[0]
+        reps = (WINDOW_SIZE // original_len) + 1
+        data_normalized = np.tile(data_normalized, (reps, 1))[:WINDOW_SIZE]
+        print(f"[analyze] Padded {original_len} rows to {data_normalized.shape[0]} via repeat-tiling")
+
+    # --- Step 4: Segment into windows of 512 ---
+    windows = []
+    for start in range(0, data_normalized.shape[0] - WINDOW_SIZE + 1, STRIDE):
+        windows.append(data_normalized[start:start + WINDOW_SIZE])
+
+    print(f"[analyze] Created {len(windows)} windows of size {WINDOW_SIZE}")
+
+    if not windows:
+        return _empty_response(
+            f"Not enough time windows ({num_rows}) for model. "
+            f"Need at least 64 band-power windows (~30s recording). Got {num_rows}."
+        )
+
+    # --- Step 5: Reshape for model: (batch, 512, 20, 1) ---
+    X = np.array(windows, dtype=np.float32).reshape(len(windows), WINDOW_SIZE, NUM_FEATURES, 1)
+    print(f"[analyze] Model input shape: {X.shape}")
+
+    # --- Step 6: Run inference ---
+    raw_preds = eeg_model.predict(X, verbose=0)
+    pred_classes = np.argmax(raw_preds, axis=1)
+    pred_confs = np.max(raw_preds, axis=1)
+
+    print(f"[analyze] Predictions — classes: {np.unique(pred_classes, return_counts=True)}")
+    print(f"[analyze] Mean confidence: {pred_confs.mean():.4f}")
+
+    predictions = []
+    for i in range(len(pred_classes)):
+        predictions.append(PredictionItem(
+            window_index=i,
+            predicted_class=int(pred_classes[i]),
+            label=CLASS_LABELS.get(int(pred_classes[i]), "Unknown"),
+            confidence=float(pred_confs[i]),
+        ))
+
+    # --- Step 7: Compute cognitive metrics from real band powers ---
+    cognitive = _compute_cognitive_metrics(band_powers, channel_band_powers, predictions)
+    anomalies = _detect_anomalies(band_powers, channel_band_powers, cognitive)
+    anomaly_score = _compute_anomaly_score(anomalies, cognitive)
+    summary = _build_summary(predictions, cognitive, anomaly_score)
+    details = _build_details(predictions, cognitive, band_powers)
+
+    return EegResponse(
+        predictions=predictions,
+        band_powers=band_powers,
+        channel_band_powers=channel_band_powers,
+        cognitive_metrics=cognitive,
+        anomaly_score=anomaly_score,
+        anomalies=anomalies,
+        summary=summary,
+        details=details,
+    )
+
+
+def _empty_response(msg: str) -> EegResponse:
+    return EegResponse(
+        predictions=[],
+        band_powers={"delta": 0, "theta": 0, "alpha": 0, "beta": 0, "gamma": 0},
+        channel_band_powers={},
+        cognitive_metrics={
+            "relaxation_index": 50, "cognitive_engagement": 50,
+            "hemispheric_balance": 0, "signal_stability": 100, "focus_level": 50,
+        },
+        anomaly_score=0,
+        anomalies=[],
+        summary=msg,
+        details=msg,
+    )
+
+
+def _compute_band_powers_from_columns(data):
+    """
+    Compute average band power across all channels from the 20-column layout.
+    Columns: [Delta_TP9..TP10, Theta_TP9..TP10, Alpha_TP9..TP10, Beta_TP9..TP10, Gamma_TP9..TP10]
+    """
+    result = {}
+    for band_idx, band_name in enumerate(BAND_NAMES):
+        cols = data[:, band_idx * 4: band_idx * 4 + 4]  # 4 channels for this band
+        result[band_name] = float(np.mean(cols))
+    return result
+
+
+def _compute_channel_band_powers_from_columns(data):
+    """
+    Compute per-channel band powers from the 20-column layout.
+    """
+    result = {}
+    for ch_idx, ch_name in enumerate(CHANNEL_NAMES):
+        ch_powers = {}
+        for band_idx, band_name in enumerate(BAND_NAMES):
+            col_idx = band_idx * 4 + ch_idx
+            ch_powers[band_name] = float(np.mean(data[:, col_idx]))
+        result[ch_name] = ch_powers
+    return result
+
+
+def _compute_cognitive_metrics(bands, ch_bands, predictions):
+    delta = bands.get("delta", 0)
+    theta = bands.get("theta", 0)
+    alpha = bands.get("alpha", 0)
+    beta = bands.get("beta", 0)
+    gamma = bands.get("gamma", 0)
+    total = delta + theta + alpha + beta + gamma
+
+    # Relaxation: alpha dominance relative to total
+    relaxation = (alpha / total * 100) if total > 0 else 50
+
+    # Cognitive engagement: beta / (alpha + theta) ratio
+    eng_den = alpha + theta
+    engagement = min(100, (beta / eng_den * 100)) if eng_den > 0 else 50
+
+    # Focus: (beta + gamma) dominance
+    focus = ((beta + gamma) / total * 100) if total > 0 else 50
+
+    # Hemispheric balance from per-channel alpha + beta
+    left_power = sum(
+        ch_bands.get(c, {}).get("alpha", 0) + ch_bands.get(c, {}).get("beta", 0)
+        for c in ["TP9", "AF7"]
+    )
+    right_power = sum(
+        ch_bands.get(c, {}).get("alpha", 0) + ch_bands.get(c, {}).get("beta", 0)
+        for c in ["AF8", "TP10"]
+    )
+    total_lr = left_power + right_power
+    balance = (right_power - left_power) / total_lr if total_lr > 0 else 0
+
+    # Signal stability: how consistent are the model predictions?
+    transitions = 0
+    for i in range(1, len(predictions)):
+        if predictions[i].predicted_class != predictions[i - 1].predicted_class:
+            transitions += 1
+    stability = (1 - transitions / max(1, len(predictions) - 1)) * 100 if len(predictions) > 1 else 100
+
+    return {
+        "relaxation_index": max(0, min(100, relaxation)),
+        "cognitive_engagement": max(0, min(100, engagement)),
+        "hemispheric_balance": max(-1, min(1, balance)),
+        "signal_stability": max(0, min(100, stability)),
+        "focus_level": max(0, min(100, focus)),
+    }
+
+
+def _detect_anomalies(bands, ch_bands, metrics):
+    anomalies = []
+    total = sum(bands.values())
+    if total <= 0:
+        return anomalies
+
+    delta_r = bands["delta"] / total
+    theta_r = bands["theta"] / total
+    alpha_r = bands["alpha"] / total
+    beta_r = bands["beta"] / total
+    gamma_r = bands["gamma"] / total
+
+    # Thresholds calibrated for consumer-grade EEG (Muse 2 dry electrodes).
+    # Clinical EEG uses tighter thresholds; Muse data inherently has more
+    # delta/theta due to electrode impedance and limited spatial resolution.
+
+    if delta_r > 0.55:
+        anomalies.append({
+            "type": "abnormalSlowing",
+            "description": f"Elevated delta power ({delta_r * 100:.1f}% of total). "
+                           "May indicate drowsiness, fatigue, or poor electrode contact.",
+            "severity": min(1.0, (delta_r - 0.50) * 2.5),
+            "channel": "Global",
+        })
+
+    if alpha_r < 0.03:
+        anomalies.append({
+            "type": "reducedAlpha",
+            "description": f"Reduced alpha power ({alpha_r * 100:.1f}% of total). "
+                           "Low alpha may indicate high alertness, anxiety, or "
+                           "difficulty achieving a relaxed state.",
+            "severity": min(1.0, (0.05 - alpha_r) * 10),
+            "channel": "Global",
+        })
+
+    if beta_r > 0.45:
+        anomalies.append({
+            "type": "excessiveBeta",
+            "description": f"Elevated beta power ({beta_r * 100:.1f}% of total). "
+                           "May indicate anxiety, stress, or excessive cognitive load.",
+            "severity": min(1.0, (beta_r - 0.40) * 2.5),
+            "channel": "Global",
+        })
+
+    if theta_r > 0.40:
+        anomalies.append({
+            "type": "abnormalSlowing",
+            "description": f"Elevated theta power ({theta_r * 100:.1f}% of total). "
+                           "May indicate drowsiness, inattention, or emotional processing.",
+            "severity": min(1.0, (theta_r - 0.35) * 2.5),
+            "channel": "Global",
+        })
+
+    # Hemispheric asymmetry — Muse has limited spatial resolution,
+    # so mild asymmetry is common and not clinically significant.
+    bal = abs(metrics["hemispheric_balance"])
+    if bal > 0.35:
+        side = "left" if metrics["hemispheric_balance"] < 0 else "right"
+        anomalies.append({
+            "type": "asymmetry",
+            "description": f"Notable {side} hemispheric asymmetry (balance: "
+                           f"{metrics['hemispheric_balance']:.2f}). With consumer EEG, "
+                           "this may reflect electrode fit rather than a clinical finding.",
+            "severity": min(1.0, (bal - 0.30) * 2),
+            "channel": f"{'TP9/AF7' if side == 'left' else 'AF8/TP10'}",
+        })
+
+    # Per-channel anomalies — raised threshold for dry-electrode noise
+    for ch_name, ch_bp in ch_bands.items():
+        ch_total = sum(ch_bp.values())
+        if ch_total <= 0:
+            continue
+        ch_delta_r = ch_bp["delta"] / ch_total
+        if ch_delta_r > 0.70:
+            anomalies.append({
+                "type": "abnormalSlowing",
+                "description": f"Focal delta excess on {ch_name} ({ch_delta_r * 100:.1f}%). "
+                               "May indicate poor electrode contact on this channel.",
+                "severity": min(1.0, (ch_delta_r - 0.65) * 3),
+                "channel": ch_name,
+            })
+
+    return anomalies
+
+
+def _compute_anomaly_score(anomalies, metrics):
+    if not anomalies:
+        base = 5.0
+    else:
+        base = sum(a["severity"] * 15 for a in anomalies)
+    base += (100 - metrics["signal_stability"]) * 0.15
+    return max(0, min(100, base))
+
+
+def _build_summary(predictions, metrics, anomaly_score):
+    if not predictions:
+        return "Insufficient data for classification."
+
+    class_counts = {}
+    for p in predictions:
+        class_counts[p.label] = class_counts.get(p.label, 0) + 1
+    dominant = max(class_counts, key=class_counts.get)
+    pct = class_counts[dominant] / len(predictions) * 100
+    avg_conf = sum(p.confidence for p in predictions) / len(predictions) * 100
+
+    parts = [f"Dominant state: {dominant} ({pct:.0f}% of recording, "
+             f"avg confidence {avg_conf:.0f}%)."]
+
+    relax = metrics["relaxation_index"]
+    engage = metrics["cognitive_engagement"]
+    focus = metrics["focus_level"]
+
+    if relax > 30:
+        parts.append(f"Alpha activity indicates moderate relaxation ({relax:.0f}/100).")
+    if engage > 40:
+        parts.append(f"Beta/theta ratio shows cognitive engagement ({engage:.0f}/100).")
+    if focus > 30:
+        parts.append(f"High-frequency activity suggests attentional focus ({focus:.0f}/100).")
+
+    if anomaly_score > 40:
+        parts.append(f"Some patterns warrant clinical attention (score: {anomaly_score:.0f}/100).")
+    elif anomaly_score > 15:
+        parts.append(f"Minor irregularities noted (score: {anomaly_score:.0f}/100).")
+    else:
+        parts.append(f"Brain activity appears within normal range (score: {anomaly_score:.0f}/100).")
+
+    return " ".join(parts)
+
+
+def _build_details(predictions, metrics, bands):
+    lines = ["=== Motor Imagery Classification ==="]
+    lines.append(f"Total windows analyzed: {len(predictions)}")
+
+    if predictions:
+        avg_conf = sum(p.confidence for p in predictions) / len(predictions)
+        lines.append(f"Average confidence: {avg_conf * 100:.1f}%")
+
+    transitions = 0
+    for i in range(1, len(predictions)):
+        if predictions[i].predicted_class != predictions[i - 1].predicted_class:
+            transitions += 1
+    lines.append(f"State transitions: {transitions}")
+
+    class_counts = {}
+    for p in predictions:
+        class_counts[p.label] = class_counts.get(p.label, 0) + 1
+    lines.append("")
+    lines.append("=== State Distribution ===")
+    total = len(predictions) or 1
+    for label, count in sorted(class_counts.items(), key=lambda x: -x[1]):
+        lines.append(f"  {label}: {count} windows ({count / total * 100:.1f}%)")
+
+    lines.append("")
+    lines.append("=== Band Power Distribution ===")
+    bp_total = sum(bands.values())
+    if bp_total > 0:
+        for band in BAND_NAMES:
+            pct = bands[band] / bp_total * 100
+            lines.append(f"  {band.capitalize():8s}: {bands[band]:.6f} ({pct:.1f}%)")
+
+    lines.append("")
+    lines.append("=== Cognitive Metrics ===")
+    lines.append(f"  Relaxation Index:      {metrics['relaxation_index']:.1f}/100")
+    lines.append(f"  Cognitive Engagement:  {metrics['cognitive_engagement']:.1f}/100")
+    lines.append(f"  Focus Level:           {metrics['focus_level']:.1f}/100")
+    lines.append(f"  Signal Stability:      {metrics['signal_stability']:.1f}/100")
+    lines.append(f"  Hemispheric Balance:   {metrics['hemispheric_balance']:.3f}")
+
+    return "\n".join(lines)
+
+
+# ═══════════════════════════════════════════════════════════════
+# MRI Brain Tumor Analysis
+# ═══════════════════════════════════════════════════════════════
+
+class MriResponse(BaseModel):
+    classification: str
+    confidence: float
+    segmentation_image_base64: str | None = None
+    tumor_area_percent: float | None = None
+    region_scores: dict[str, float]
+    summary: str
+    details: str
+    is_placeholder: bool = False
+    model_name: str = "NeuroGuard MRI ViT + GradCAM (HF Hub)"
+
+
+@app.post("/api/mri/analyze")
+async def analyze_mri(image: UploadFile = File(...)):
+    from pytorch_grad_cam.utils.model_targets import ClassifierOutputTarget
+
+    try:
+        load_mri_classifier()
+    except Exception as e:
+        print(f"[MRI] Failed to load classifier: {e}")
+        return MriResponse(
+            classification="unknown",
+            confidence=0,
+            region_scores={},
+            summary="MRI model could not be loaded. Check server logs.",
+            details=str(e),
+            is_placeholder=True,
+        )
+
+    clf = mri_classifier
+    model = clf["model"]
+    processor = clf["processor"]
+    cam = clf["cam"]
+    labels = clf["labels"]
+    torch = clf["torch"]
+
+    contents = await image.read()
+    print(f"[MRI] Received image: {image.filename}, {len(contents)} bytes")
+
+    nparr = np.frombuffer(contents, np.uint8)
+    img_bgr = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+    if img_bgr is None:
+        return MriResponse(
+            classification="unknown",
+            confidence=0,
+            region_scores={},
+            summary="Could not decode image.",
+            details="The uploaded file could not be read as an image.",
+        )
+
+    img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+    pil_img = Image.fromarray(img_rgb)
+    print(f"[MRI] Image decoded: {pil_img.size[0]}x{pil_img.size[1]}")
+
+    # ── ViT Classification ───────────────────────────────────────
+    inputs = processor(images=pil_img, return_tensors="pt")
+
+    with torch.no_grad():
+        outputs = model(**inputs)
+    logits = outputs.logits
+    probs = torch.nn.functional.softmax(logits, dim=1)[0]
+
+    class_idx = int(probs.argmax().item())
+    confidence = float(probs[class_idx].item())
+    classification = labels.get(class_idx, "unknown")
+
+    print(f"[MRI] ViT prediction: {classification} (class {class_idx}, conf {confidence:.3f})")
+    print(f"[MRI] Softmax: {probs.tolist()}")
+
+    region_scores = {}
+    for idx, prob_val in enumerate(probs.tolist()):
+        label = labels.get(idx, f"class_{idx}")
+        region_scores[label] = round(prob_val, 4)
+
+    # ── GradCAM Heatmap ──────────────────────────────────────────
+    seg_image_b64 = None
+    tumor_area_pct = None
+
+    try:
+        targets = [ClassifierOutputTarget(class_idx)]
+        grayscale_cam = cam(input_tensor=inputs["pixel_values"], targets=targets)
+        heatmap = grayscale_cam[0, :]
+
+        img_resized = cv2.resize(img_rgb, (224, 224))
+        rgb_normalized = np.float32(img_resized) / 255.0
+
+        heatmap_color = cv2.applyColorMap(
+            np.uint8(255 * heatmap), cv2.COLORMAP_JET
+        )
+        heatmap_color = cv2.cvtColor(heatmap_color, cv2.COLOR_BGR2RGB)
+        overlay = np.uint8(rgb_normalized * 255 * 0.5 + heatmap_color * 0.5)
+
+        pil_overlay = Image.fromarray(overlay)
+        buf = io.BytesIO()
+        pil_overlay.save(buf, format="PNG")
+        seg_image_b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
+
+        if classification != "noTumor":
+            tumor_mask = heatmap > 0.5
+            tumor_area_pct = round(float(tumor_mask.sum()) / tumor_mask.size * 100, 2)
+        else:
+            tumor_area_pct = 0.0
+
+        print(f"[MRI] GradCAM generated, tumor area estimate: {tumor_area_pct}%")
+    except Exception as e:
+        print(f"[MRI] GradCAM error: {e}")
+
+    summary = _build_mri_summary(classification, confidence, tumor_area_pct)
+    details = _build_mri_details(classification, confidence, region_scores, tumor_area_pct)
+
+    return MriResponse(
+        classification=classification,
+        confidence=confidence,
+        segmentation_image_base64=seg_image_b64,
+        tumor_area_percent=tumor_area_pct,
+        region_scores=region_scores,
+        summary=summary,
+        details=details,
+    )
+
+
+def _build_mri_summary(classification: str, confidence: float, tumor_area: float | None) -> str:
+    pct = f"{confidence * 100:.1f}"
+    labels_map = {
+        "noTumor": f"No tumor detected with {pct}% confidence.",
+        "glioma": f"Glioma detected with {pct}% confidence.",
+        "meningioma": f"Meningioma detected with {pct}% confidence.",
+        "pituitary": f"Pituitary tumor detected with {pct}% confidence.",
+        "unknown": f"Scan inconclusive ({pct}% confidence). Image may not be a standard brain MRI.",
+    }
+    text = labels_map.get(classification, f"Classification: {classification} ({pct}% confidence).")
+
+    if tumor_area is not None and tumor_area > 0:
+        text += f" Tumor region covers approximately {tumor_area:.1f}% of the scan area."
+
+    return text
+
+
+def _build_mri_details(classification: str, confidence: float,
+                       scores: dict, tumor_area: float | None) -> str:
+    lines = ["=== Brain Tumor Classification ==="]
+    lines.append(f"Predicted class: {classification}")
+    lines.append(f"Confidence: {confidence * 100:.1f}%")
+    lines.append("")
+    lines.append("=== Class Probabilities ===")
+    for label, prob in sorted(scores.items(), key=lambda x: -x[1]):
+        lines.append(f"  {label:15s}: {prob * 100:.1f}%")
+    if tumor_area is not None:
+        lines.append("")
+        lines.append("=== Segmentation ===")
+        if tumor_area > 0:
+            lines.append(f"  Tumor area: {tumor_area:.1f}% of scan")
+        else:
+            lines.append("  No tumor region segmented")
+    return "\n".join(lines)
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=PORT, timeout_keep_alive=300)

models/best_eeg_model_200.keras

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

requirements-cloud.txt

@@ -0,0 +1,12 @@
+--extra-index-url https://download.pytorch.org/whl/cpu
+fastapi
+uvicorn
+numpy
+scikit-learn
+tensorflow-cpu
+transformers
+torch
+grad-cam
+opencv-python-headless
+Pillow
+python-multipart