Upload 7 files

README.md

@@ -1,13 +1,39 @@
 ---
-title: LCVC Ensemble
-emoji: 🐠
-colorFrom: yellow
-colorTo: pink
+title: LCVC-Ensemble Brain Tumor MRI Classifier
 sdk: gradio
-sdk_version: 6.14.0
-python_version: '3.13'
 app_file: app.py
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# LCVC-Ensemble Brain Tumor MRI Classifier
+
+This Space contains a research demonstration of **LCVC-Ensemble**
+(**Leakage-Controlled Validation-Calibrated Multi-Backbone Ensemble**) for four-class brain tumor MRI classification.
+
+## Classes
+
+glioma, meningioma, notumor, pituitary
+
+## Test metrics from the leakage-aware evaluation protocol
+
+- Accuracy: 0.9887640449438202
+- Macro-F1: 0.9887621278421996
+- Balanced accuracy: 0.9887638076313365
+- Macro-AUC OVR: 0.9997131229291261
+
+## Ensemble
+
+The app loads `5` selected checkpoints and performs weighted averaging of temperature-scaled softmax probabilities.
+
+## Intended use
+
+Research and educational demonstration only.
+
+## Medical disclaimer
+
+This is **not a medical device**. It must not be used for diagnosis, treatment, triage, or clinical decision-making.
+
+## Reproducibility note
+
+The ensemble was selected using validation Macro-F1 only. Test labels were used only for final reporting after model selection.

app.py

@@ -0,0 +1,205 @@
+
+import json
+from pathlib import Path
+
+import gradio as gr
+import numpy as np
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from PIL import Image
+from torchvision import models, transforms
+
+
+ROOT = Path(__file__).resolve().parent
+CONFIG_PATH = ROOT / "ensemble_config.json"
+
+with open(CONFIG_PATH, "r") as f:
+    CFG = json.load(f)
+
+CLASS_NAMES = CFG["classes"]
+NUM_CLASSES = int(CFG["num_classes"])
+IMAGE_SIZE = int(CFG["image_size"])
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+
+def replace_classifier(model, model_name, num_classes):
+    if model_name == "vgg16_bn":
+        in_features = model.classifier[-1].in_features
+        model.classifier[-1] = nn.Linear(in_features, num_classes)
+
+    elif model_name == "densenet121":
+        in_features = model.classifier.in_features
+        model.classifier = nn.Linear(in_features, num_classes)
+
+    elif model_name == "efficientnet_b0":
+        in_features = model.classifier[-1].in_features
+        model.classifier[-1] = nn.Linear(in_features, num_classes)
+
+    elif model_name == "mobilenet_v3_small":
+        in_features = model.classifier[-1].in_features
+        model.classifier[-1] = nn.Linear(in_features, num_classes)
+
+    elif model_name == "convnext_tiny":
+        in_features = model.classifier[-1].in_features
+        model.classifier[-1] = nn.Linear(in_features, num_classes)
+
+    else:
+        raise ValueError(f"Unknown model name: {model_name}")
+
+    return model
+
+
+def build_model(model_name, num_classes):
+    if model_name == "vgg16_bn":
+        model = models.vgg16_bn(weights=None)
+
+    elif model_name == "densenet121":
+        model = models.densenet121(weights=None)
+
+    elif model_name == "efficientnet_b0":
+        model = models.efficientnet_b0(weights=None)
+
+    elif model_name == "mobilenet_v3_small":
+        model = models.mobilenet_v3_small(weights=None)
+
+    elif model_name == "convnext_tiny":
+        model = models.convnext_tiny(weights=None)
+
+    else:
+        raise ValueError(f"Unknown model name: {model_name}")
+
+    return replace_classifier(model, model_name, num_classes)
+
+
+def load_state_dict_safely(path):
+    try:
+        ckpt = torch.load(path, map_location="cpu", weights_only=True)
+    except TypeError:
+        ckpt = torch.load(path, map_location="cpu")
+
+    if isinstance(ckpt, dict):
+        for key in ["model_state_dict", "state_dict", "model"]:
+            if key in ckpt and isinstance(ckpt[key], dict):
+                ckpt = ckpt[key]
+                break
+
+    cleaned = {}
+
+    for k, v in ckpt.items():
+        nk = k[7:] if str(k).startswith("module.") else k
+        cleaned[nk] = v
+
+    return cleaned
+
+
+def load_ensemble():
+    loaded = []
+
+    for member in CFG["members"]:
+        model_name = member["model"]
+        ckpt_path = ROOT / member["checkpoint_file"]
+
+        model = build_model(model_name, NUM_CLASSES)
+        state = load_state_dict_safely(ckpt_path)
+        model.load_state_dict(state, strict=True)
+        model.to(DEVICE)
+        model.eval()
+
+        loaded.append({
+            "model": model,
+            "display_name": member.get("display_name", model_name),
+            "seed": member.get("seed"),
+            "weight": float(member["weight"]),
+            "temperature": max(float(member["temperature"]), 1e-8),
+        })
+
+    weight_sum = sum(m["weight"] for m in loaded)
+
+    if weight_sum <= 0:
+        for m in loaded:
+            m["weight"] = 1.0 / len(loaded)
+    else:
+        for m in loaded:
+            m["weight"] /= weight_sum
+
+    return loaded
+
+
+ENSEMBLE = load_ensemble()
+
+PREPROCESS = transforms.Compose([
+    transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),
+    transforms.ToTensor(),
+    transforms.Normalize(
+        mean=CFG["preprocessing"]["normalization_mean"],
+        std=CFG["preprocessing"]["normalization_std"],
+    ),
+])
+
+
+@torch.no_grad()
+def predict(image):
+    if image is None:
+        return None, "Please upload an MRI image."
+
+    if not isinstance(image, Image.Image):
+        image = Image.fromarray(image)
+
+    image = image.convert("RGB")
+    x = PREPROCESS(image).unsqueeze(0).to(DEVICE)
+
+    final_probs = torch.zeros((1, NUM_CLASSES), dtype=torch.float32, device=DEVICE)
+    member_lines = []
+
+    for member in ENSEMBLE:
+        logits = member["model"](x)
+        probs = F.softmax(logits / member["temperature"], dim=1)
+        final_probs += member["weight"] * probs
+
+        top_prob, top_idx = torch.max(probs, dim=1)
+
+        member_lines.append(
+            f"{member['display_name']} seed {member['seed']}: "
+            f"{CLASS_NAMES[int(top_idx.item())]} ({float(top_prob.item()):.4f})"
+        )
+
+    final_probs_np = final_probs.squeeze(0).detach().cpu().numpy()
+    pred_idx = int(np.argmax(final_probs_np))
+    pred_class = CLASS_NAMES[pred_idx]
+    pred_conf = float(final_probs_np[pred_idx])
+
+    label_scores = {
+        CLASS_NAMES[i]: float(final_probs_np[i])
+        for i in range(NUM_CLASSES)
+    }
+
+    details = (
+        f"Predicted class: {pred_class}\n"
+        f"Calibrated ensemble confidence: {pred_conf:.4f}\n\n"
+        "Member predictions:\n"
+        + "\n".join(member_lines)
+        + "\n\nDisclaimer: This tool is for research and educational demonstration only. "
+          "It is not a medical device and must not be used for diagnosis or treatment."
+    )
+
+    return label_scores, details
+
+
+demo = gr.Interface(
+    fn=predict,
+    inputs=gr.Image(type="pil", label="Upload MRI image"),
+    outputs=[
+        gr.Label(num_top_classes=NUM_CLASSES, label="Calibrated ensemble probabilities"),
+        gr.Textbox(label="Prediction details"),
+    ],
+    title="LCVC-Ensemble Brain Tumor MRI Classifier",
+    description=(
+        "Leakage-Controlled Validation-Calibrated Multi-Backbone Ensemble. "
+        "Research demonstration only; not for clinical use."
+    ),
+    flagging_mode="never",
+)
+
+if __name__ == "__main__":
+    demo.launch()

ensemble_config.json

@@ -0,0 +1,106 @@
+{
+  "proposed_model": "LCVC-Ensemble",
+  "full_name": "Leakage-Controlled Validation-Calibrated Multi-Backbone Ensemble",
+  "task": "Brain tumor MRI four-class classification",
+  "classes": [
+    "glioma",
+    "meningioma",
+    "notumor",
+    "pituitary"
+  ],
+  "num_classes": 4,
+  "image_size": 224,
+  "preprocessing": {
+    "input_mode": "RGB",
+    "resize": [
+      224,
+      224
+    ],
+    "normalization_mean": [
+      0.485,
+      0.456,
+      0.406
+    ],
+    "normalization_std": [
+      0.229,
+      0.224,
+      0.225
+    ]
+  },
+  "ensemble_rule": "weighted_average_of_temperature_scaled_softmax_probabilities",
+  "selection_rule": "highest validation Macro-F1 among predeclared ensembles; no test labels used for selection",
+  "strategy": "top5_by_checkpoint_val_macro_f1",
+  "calibrated_probs": true,
+  "weight_mode": "uniform",
+  "num_members": 5,
+  "members": [
+    {
+      "member_order": 0,
+      "model": "convnext_tiny",
+      "display_name": "ConvNeXt-Tiny",
+      "seed": 123,
+      "weight": 0.2,
+      "temperature": 1.3677136307807327,
+      "checkpoint_file": "checkpoints/best_convnext_tiny_seed123.pt",
+      "checkpoint_val_macro_f1": 0.9870486143666763,
+      "test_cal_macro_f1": 0.9747367912288595
+    },
+    {
+      "member_order": 1,
+      "model": "efficientnet_b0",
+      "display_name": "EfficientNet-B0",
+      "seed": 123,
+      "weight": 0.2,
+      "temperature": 1.3258544405019956,
+      "checkpoint_file": "checkpoints/best_efficientnet_b0_seed123.pt",
+      "checkpoint_val_macro_f1": 0.9842404596100688,
+      "test_cal_macro_f1": 0.984111907683999
+    },
+    {
+      "member_order": 2,
+      "model": "efficientnet_b0",
+      "display_name": "EfficientNet-B0",
+      "seed": 2026,
+      "weight": 0.2,
+      "temperature": 1.2086706764615134,
+      "checkpoint_file": "checkpoints/best_efficientnet_b0_seed2026.pt",
+      "checkpoint_val_macro_f1": 0.9842174297345077,
+      "test_cal_macro_f1": 0.9802870622455948
+    },
+    {
+      "member_order": 3,
+      "model": "efficientnet_b0",
+      "display_name": "EfficientNet-B0",
+      "seed": 42,
+      "weight": 0.2,
+      "temperature": 1.4470591581130952,
+      "checkpoint_file": "checkpoints/best_efficientnet_b0_seed42.pt",
+      "checkpoint_val_macro_f1": 0.9835034785528444,
+      "test_cal_macro_f1": 0.9859513817770005
+    },
+    {
+      "member_order": 4,
+      "model": "convnext_tiny",
+      "display_name": "ConvNeXt-Tiny",
+      "seed": 42,
+      "weight": 0.2,
+      "temperature": 1.0611162444290951,
+      "checkpoint_file": "checkpoints/best_convnext_tiny_seed42.pt",
+      "checkpoint_val_macro_f1": 0.9824939017733962,
+      "test_cal_macro_f1": 0.9831484695235262
+    }
+  ],
+  "validation_metrics": {
+    "accuracy": 0.9916201117318436,
+    "macro_f1": 0.9917075605938603,
+    "balanced_accuracy": 0.9916862142328199,
+    "macro_auc_ovr": 0.9997306138031021
+  },
+  "test_metrics": {
+    "accuracy": 0.9887640449438202,
+    "macro_f1": 0.9887621278421996,
+    "balanced_accuracy": 0.9887638076313365,
+    "macro_auc_ovr": 0.9997131229291261
+  },
+  "medical_disclaimer": "This app is for research and educational demonstration only. It is not a medical device and must not be used for diagnosis, treatment, or clinical decision-making."
+}

hf_bundle_manifest.json

@@ -0,0 +1,14 @@
+{
+  "bundle_type": "huggingface_space_upload",
+  "contains_checkpoints": true,
+  "num_checkpoints": 5,
+  "files": [
+    "app.py",
+    "requirements.txt",
+    "README.md",
+    "ensemble_config.json",
+    "selected_lcvc_ensemble_members.csv",
+    "proposed_lcvc_ensemble_summary.json",
+    "checkpoints/*.pt"
+  ]
+}

proposed_lcvc_ensemble_summary.json

@@ -0,0 +1,34 @@
+{
+  "proposed_model": "LCVC_Ensemble",
+  "selection_rule": "highest validation Macro-F1 among predeclared ensembles; no test labels used for selection",
+  "strategy": "top5_by_checkpoint_val_macro_f1",
+  "calibrated_probs": true,
+  "weight_mode": "uniform",
+  "num_members": 5,
+  "class_names": [
+    "glioma",
+    "meningioma",
+    "notumor",
+    "pituitary"
+  ],
+  "validation_metrics": {
+    "accuracy": 0.9916201117318436,
+    "macro_f1": 0.9917075605938603,
+    "balanced_accuracy": 0.9916862142328199,
+    "macro_auc_ovr": 0.9997306138031021
+  },
+  "test_metrics": {
+    "accuracy": 0.9887640449438202,
+    "macro_f1": 0.9887621278421996,
+    "balanced_accuracy": 0.9887638076313365,
+    "macro_auc_ovr": 0.9997131229291261
+  },
+  "cm_csv_path": "/kaggle/working/lcvc_ensemble_outputs/cm_LCVC_Ensemble.csv",
+  "report_path": "/kaggle/working/lcvc_ensemble_outputs/classification_report_LCVC_Ensemble.json",
+  "selected_members_path": "/kaggle/working/lcvc_ensemble_outputs/selected_lcvc_ensemble_members.csv",
+  "auc_fix": {
+    "fixed": true,
+    "method": "manual one-vs-rest macro-AUC from saved probabilities",
+    "note": "Model selection remains validation-only. Test labels are used only for final reporting."
+  }
+}

requirements.txt

@@ -0,0 +1,6 @@
+torch
+torchvision
+numpy
+pandas
+Pillow
+gradio>=5.0

selected_lcvc_ensemble_members.csv

@@ -0,0 +1,6 @@
+member_order,model,display_name,seed,weight,temperature,checkpoint_path,checkpoint_val_macro_f1,test_cal_macro_f1
+0,convnext_tiny,ConvNeXt-Tiny,123,0.2,1.3677136307807327,/kaggle/input/datasets/sayemahmedshayeed/baseline-cnn-result/mri_backbone_baselines_outputs/best_convnext_tiny_seed123.pt,0.9870486143666763,0.9747367912288595
+1,efficientnet_b0,EfficientNet-B0,123,0.2,1.3258544405019956,/kaggle/input/datasets/sayemahmedshayeed/baseline-cnn-result/mri_backbone_baselines_outputs/best_efficientnet_b0_seed123.pt,0.9842404596100688,0.984111907683999
+2,efficientnet_b0,EfficientNet-B0,2026,0.2,1.2086706764615134,/kaggle/input/datasets/sayemahmedshayeed/baseline-cnn-result/mri_backbone_baselines_outputs/best_efficientnet_b0_seed2026.pt,0.9842174297345077,0.9802870622455948
+3,efficientnet_b0,EfficientNet-B0,42,0.2,1.4470591581130952,/kaggle/input/datasets/sayemahmedshayeed/baseline-cnn-result/mri_backbone_baselines_outputs/best_efficientnet_b0_seed42.pt,0.9835034785528444,0.9859513817770005
+4,convnext_tiny,ConvNeXt-Tiny,42,0.2,1.0611162444290951,/kaggle/input/datasets/sayemahmedshayeed/baseline-cnn-result/mri_backbone_baselines_outputs/best_convnext_tiny_seed42.pt,0.9824939017733962,0.9831484695235262