Add model file with Git and updated app.py

app.py

@@ -1,68 +1,90 @@
 from fastapi import FastAPI, UploadFile
 from fastapi.middleware.cors import CORSMiddleware
 from PIL import Image
-import torch
-import io
+import torch, io
 from pathlib import Path
 from torchvision import transforms
 
 from model import MultiTaskResNet50
-from decision import final_decision
+from decision import final_decision                # v1
+from advanced_decision import *
+from gradcam import GradCAM
+from dino import *
 
-app = FastAPI(
-    title="Mold Detection API",
-    description="FastAPI backend for mold detection using multi-task ResNet50",
-    version="1.0.0"
-)
+app = FastAPI(title="Mold Detection API v2")
 
-# Add CORS middleware for frontend
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # In production, replace with specific frontend URL
-    allow_credentials=True,
+    allow_origins=["*"],
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
 device = "cuda" if torch.cuda.is_available() else "cpu"
+mold_idx = 4
 
-# Model path for HuggingFace Spaces (flat structure)
-model_path = Path("resnet50_multitask_mold.pth")
-
-print(f"Loading model from: {model_path.absolute()}")
-print(f"Model exists: {model_path.exists()}")
-
-model = MultiTaskResNet50()
-model.load_state_dict(torch.load(str(model_path), map_location=device))
-model.eval().to(device)
-print("✅ Model loaded successfully")
+# Load model
+model = MultiTaskResNet50().to(device)
+model.load_state_dict(torch.load("resnet50_multitask_bio.pth", map_location=device))
+model.eval()
 
+# Transforms
 transform = transforms.Compose([
     transforms.Resize((224,224)),
     transforms.ToTensor(),
-    transforms.Normalize(
-        mean=[0.485,0.456,0.406],
-        std=[0.229,0.224,0.225]
-    )
+    transforms.Normalize([0.485,0.456,0.406],[0.229,0.224,0.225])
 ])
 
-@app.get("/")
-async def root():
+# Grad-CAM
+gradcam = GradCAM(model, model.backbone.layer4[-1].conv3)
+
+# DINO
+dino = load_dino(device)
+mold_embs = build_embeddings(dino, transform, "mold_reference_images", device)
+
+@app.post("/predict/v1")
+async def predict_v1(file: UploadFile):
+    img = Image.open(io.BytesIO(await file.read())).convert("RGB")
+    img_t = transform(img).to(device)
+    return final_decision(model, img_t)
+
+@app.post("/predict/v2")
+async def predict_v2(file: UploadFile):
+    img = Image.open(io.BytesIO(await file.read())).convert("RGB")
+    img_t = transform(img).to(device)
+
+    with torch.no_grad():
+        out = model(img_t.unsqueeze(0))
+        cp = torch.softmax(out["class"],1)[0]
+        bp = torch.softmax(out["bio"],1)[0]
+
+    mold_p = cp[mold_idx].item()
+    bio_p  = bp[1].item()
+
+    mean_p, std_p = mc_uncertainty(model, img_t, mold_idx)
+    patch_ratio = patch_consistency(model, img, transform, mold_idx, device)
+    dino_sim = similarity(dino, mold_embs, img, transform, device)
+
+    decision = final_decision_v2(
+        mold_p, bio_p, std_p, patch_ratio, dino_sim
+    )
+
     return {
-        "status": "healthy",
-        "message": "Mold Detection API is running",
-        "endpoint": "/predict",
-        "method": "POST",
-        "docs": "/docs"
+        "decision": decision,
+        "model_outputs": {
+            "mold_probability": round(mold_p,3),
+            "biological_probability": round(bio_p,3)
+        },
+        "confidence_checks": {
+            "uncertainty": round(std_p,3),
+            "patch_ratio": round(patch_ratio,3),
+            "dino_similarity": round(dino_sim,3)
+        }
     }
 
-@app.get("/health")
-async def health():
-    return {"status": "healthy"}
-
-@app.post("/predict")
-async def predict(file: UploadFile):
-    image_bytes = await file.read()
-    img = Image.open(io.BytesIO(image_bytes)).convert("RGB")
-    img_tensor = transform(img).to(device)
-    return final_decision(model, img_tensor)
+@app.post("/explain/gradcam")
+async def explain_gradcam(file: UploadFile):
+    img = Image.open(io.BytesIO(await file.read())).convert("RGB")
+    img_t = transform(img).to(device)
+    cam = gradcam.generate(img_t, mold_idx)
+    return {"gradcam": cam.tolist()}