Upload 5 files

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy app code
+COPY . .
+
+# HuggingFace Spaces runs on port 7860
+EXPOSE 7860
+
+CMD ["python", "main.py"]

README.md

@@ -1,10 +1,28 @@
 ---
-title: MedScan API
-emoji: 📉
+title: MediScan AI
+emoji: 🏥
 colorFrom: red
-colorTo: purple
+colorTo: blue
 sdk: docker
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# MediScan AI — Medical Diagnostic API
+
+FastAPI backend serving skin cancer and pneumonia predictions.
+
+## Endpoints
+
+| Method | URL | Description |
+|--------|-----|-------------|
+| GET | `/` | Status |
+| GET | `/health` | Health check |
+| GET | `/docs` | Swagger UI |
+| POST | `/predict/pneumonia` | Chest X-ray analysis |
+| POST | `/predict/skin` | Skin lesion classification |
+
+## Models
+- **Pneumonia**: Custom CNN (`SaswatML123/PneuModel`)
+- **Skin Cancer**: EfficientNetV2M + EfficientNetV2S + ConvNeXt ensemble (`SaswatML123/Skin_cancer_detection`)
+
+> For research use only. Not a medical device.

main.py

@@ -0,0 +1,94 @@
+"""
+MediScan AI — HuggingFace Space Backend
+Port 7860 (required by HuggingFace Spaces)
+"""
+
+import uvicorn
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+from PIL import Image
+import io
+
+from model_loader import (
+    load_pneumo_model, load_skin_models,
+    predict_pneumonia, predict_skin
+)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    print("=" * 50)
+    print("  MediScan AI Space — Loading models...")
+    print("=" * 50)
+    load_pneumo_model()
+    load_skin_models()
+    print("=" * 50)
+    print("  All models ready!")
+    print("=" * 50)
+    yield
+
+
+app = FastAPI(
+    title="MediScan AI",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/")
+def root():
+    return {
+        "status": "ok",
+        "endpoints": {
+            "pneumonia": "POST /predict/pneumonia",
+            "skin":      "POST /predict/skin",
+            "docs":      "/docs",
+        }
+    }
+
+
+@app.get("/health")
+def health():
+    return {"status": "healthy"}
+
+
+@app.post("/predict/pneumonia")
+async def pneumonia_endpoint(file: UploadFile = File(...)):
+    if not file.content_type.startswith("image/"):
+        raise HTTPException(400, "Must be an image file.")
+    data = await file.read()
+    try:
+        image = Image.open(io.BytesIO(data))
+    except Exception:
+        raise HTTPException(400, "Could not read image.")
+    try:
+        return predict_pneumonia(image)
+    except Exception as e:
+        raise HTTPException(500, f"Inference error: {e}")
+
+
+@app.post("/predict/skin")
+async def skin_endpoint(file: UploadFile = File(...)):
+    if not file.content_type.startswith("image/"):
+        raise HTTPException(400, "Must be an image file.")
+    data = await file.read()
+    try:
+        image = Image.open(io.BytesIO(data))
+    except Exception:
+        raise HTTPException(400, "Could not read image.")
+    try:
+        return predict_skin(image)
+    except Exception as e:
+        raise HTTPException(500, f"Inference error: {e}")
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

model_loader.py

@@ -0,0 +1,152 @@
+"""
+model_loader.py
+Downloads models from HuggingFace repos, caches them, runs inference.
+"""
+
+import os
+import numpy as np
+from PIL import Image
+from huggingface_hub import hf_hub_download
+
+CACHE_DIR = "/app/model_cache"
+os.makedirs(CACHE_DIR, exist_ok=True)
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  PNEUMONIA — Keras .h5
+# ══════════════════════════════════════════════════════════════════════════════
+
+PNEUMO_REPO    = "SaswatML123/PneuModel"
+PNEUMO_FILE    = "pneumodel.h5"
+PNEUMO_SIZE    = (224, 224)
+_pneumo_model  = None
+
+
+def _download(repo, filename):
+    local = os.path.join(CACHE_DIR, filename)
+    if os.path.exists(local):
+        print(f"[Cache] {filename}")
+        return local
+    print(f"[HuggingFace] Downloading {filename}...")
+    return hf_hub_download(repo_id=repo, filename=filename, local_dir=CACHE_DIR)
+
+
+def load_pneumo_model():
+    global _pneumo_model
+    if _pneumo_model is not None:
+        return
+    import tensorflow as tf
+    path = _download(PNEUMO_REPO, PNEUMO_FILE)
+    print("[Pneumonia] Loading...")
+    _pneumo_model = tf.keras.models.load_model(path)
+    print("[Pneumonia] ✓ Ready")
+
+
+def predict_pneumonia(image: Image.Image) -> dict:
+    load_pneumo_model()
+    img = image.convert("RGB").resize(PNEUMO_SIZE)
+    arr = np.array(img, dtype=np.float32) / 255.0
+    arr = np.expand_dims(arr, axis=0)
+    preds = _pneumo_model.predict(arr, verbose=0)
+
+    if preds.shape[-1] == 1:
+        pneumonia_prob = float(preds[0][0])
+        normal_prob = 1.0 - pneumonia_prob
+    else:
+        normal_prob = float(preds[0][0])
+        pneumonia_prob = float(preds[0][1])
+
+    if pneumonia_prob >= 0.5:
+        label, confidence = "PNEUMONIA", pneumonia_prob
+    else:
+        label, confidence = "NORMAL", normal_prob
+
+    return {
+        "label": label,
+        "confidence": round(confidence, 4),
+        "probabilities": {
+            "NORMAL": round(normal_prob, 4),
+            "PNEUMONIA": round(pneumonia_prob, 4),
+        },
+    }
+
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  SKIN CANCER — PyTorch ensemble
+# ══════════════════════════════════════════════════════════════════════════════
+
+SKIN_REPO  = "SaswatML123/Skin_cancer_detection"
+SKIN_FILES = {
+    "efficientnetv2m": "model1_efficientnetv2m.pth",
+    "efficientnetv2s": "model2_efficientnetv2s.pth",
+    "convnext":        "model3_convnext.pth",
+}
+SKIN_CLASSES = [
+    "Melanocytic nevi",
+    "Melanoma",
+    "Benign keratosis",
+    "Basal cell carcinoma",
+    "Actinic keratosis",
+    "Vascular lesions",
+    "Dermatofibroma",
+]
+NUM_SKIN_CLASSES = len(SKIN_CLASSES)
+_skin_models = []
+SKIN_TRANSFORM = None
+
+
+def load_skin_models():
+    global _skin_models, SKIN_TRANSFORM
+    if _skin_models:
+        return
+    import torch
+    import timm
+    from torchvision import transforms
+
+    SKIN_TRANSFORM = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
+    ])
+
+    arch_map = {
+        "efficientnetv2m": "tf_efficientnetv2_m",
+        "efficientnetv2s": "tf_efficientnetv2_s",
+        "convnext":        "convnext_base",
+    }
+    device = torch.device("cpu")  # Space free tier is CPU only
+
+    for arch, filename in SKIN_FILES.items():
+        path = _download(SKIN_REPO, filename)
+        model = timm.create_model(arch_map[arch], pretrained=False, num_classes=NUM_SKIN_CLASSES)
+        state = torch.load(path, map_location=device)
+        if isinstance(state, dict):
+            for key in ("model_state_dict", "state_dict", "model"):
+                if key in state:
+                    state = state[key]
+                    break
+        model.load_state_dict(state, strict=False)
+        model.eval()
+        _skin_models.append(model)
+        print(f"[Skin] ✓ {arch}")
+
+    print(f"[Skin] Ensemble ready — {len(_skin_models)} models")
+
+
+def predict_skin(image: Image.Image) -> dict:
+    import torch
+    load_skin_models()
+    img_t = SKIN_TRANSFORM(image.convert("RGB")).unsqueeze(0)
+    all_probs = []
+    with torch.no_grad():
+        for model in _skin_models:
+            probs = torch.softmax(model(img_t), dim=1).squeeze().numpy()
+            all_probs.append(probs)
+    avg = np.mean(all_probs, axis=0)
+    top = int(np.argmax(avg))
+    return {
+        "label": SKIN_CLASSES[top],
+        "confidence": round(float(avg[top]), 4),
+        "probabilities": {c: round(float(p), 4) for c, p in zip(SKIN_CLASSES, avg)},
+        "model_count": len(_skin_models),
+    }

requirements.txt

@@ -0,0 +1,10 @@
+fastapi
+uvicorn[standard]
+python-multipart
+torch
+torchvision
+timm
+tensorflow
+Pillow
+numpy
+huggingface_hub