NewModeladded

backend/Colpo/inference.py

@@ -0,0 +1,277 @@
+# ============================================================
+# Colposcopy Inference Backend
+# Production-ready | VS Code | Hugging Face compatible
+# ============================================================
+
+import os
+import cv2
+import numpy as np
+import torch
+import torch.nn as nn
+import joblib
+from torchvision import transforms, models
+from PIL import Image
+
+# ------------------------------------------------------------
+# DEVICE
+# ------------------------------------------------------------
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# ------------------------------------------------------------
+# PATHS (RELATIVE — REQUIRED FOR DEPLOYMENT)
+# ------------------------------------------------------------
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+MODEL_DIR = os.path.join(BASE_DIR, "models")
+OUTPUT_DIR = os.path.join(BASE_DIR, "outputs")
+
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+SEG_MODEL_PATH = os.path.join(MODEL_DIR, "seg_yolov8n_best.pt")
+FUSION_MODEL_PATH = os.path.join(MODEL_DIR, "fusion_model.pth")
+CLF_PATH = os.path.join(MODEL_DIR, "logreg_classifier.joblib")
+
+# ------------------------------------------------------------
+# LOAD MODELS (ONCE)
+# ------------------------------------------------------------
+from ultralytics import YOLO
+
+seg_model = YOLO(SEG_MODEL_PATH)
+clf = joblib.load(CLF_PATH)
+
+# ------------------------------------------------------------
+# FUSION MODEL DEFINITION
+# ------------------------------------------------------------
+class ImageEncoder(nn.Module):
+    def __init__(self):
+        super().__init__()
+        base = models.resnet18(pretrained=False)
+        self.backbone = nn.Sequential(*list(base.children())[:-1])
+        self.fc = nn.Linear(512, 512)
+
+    def forward(self, x):
+        x = self.backbone(x)
+        return self.fc(x.view(x.size(0), -1))
+
+
+class FeatureEncoder(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(7, 64),
+            nn.ReLU(),
+            nn.Linear(64, 64)
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+
+class FusionModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.img_enc = ImageEncoder()
+        self.feat_enc = FeatureEncoder()
+        self.norm = nn.BatchNorm1d(576)
+
+    def forward(self, img, feat):
+        img_emb = self.img_enc(img)
+        feat_emb = self.feat_enc(feat)
+        return self.norm(torch.cat([img_emb, feat_emb], dim=1))
+
+
+fusion_model = FusionModel().to(device)
+fusion_model.load_state_dict(torch.load(FUSION_MODEL_PATH, map_location=device))
+fusion_model.eval()
+
+# ------------------------------------------------------------
+# IMAGE TRANSFORM
+# ------------------------------------------------------------
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor()
+])
+
+# ------------------------------------------------------------
+# CONSTANTS
+# ------------------------------------------------------------
+CERVIX_ID = 0
+SCJ_ID = 1
+ACET_ID = 3
+MIN_ACET_RATIO = 0.01
+
+# ------------------------------------------------------------
+# GEOMETRY UTILITIES
+# ------------------------------------------------------------
+def polygon_to_mask(polygon, H, W):
+    pts = np.array([[int(x * W), int(y * H)] for x, y in polygon], np.int32)
+    mask = np.zeros((H, W), dtype=np.uint8)
+    cv2.fillPoly(mask, [pts], 1)
+    return mask
+
+
+def mask_area(mask):
+    return mask.sum() / mask.size
+
+
+def centroid_distance(mask1, mask2):
+    if mask2 is None:
+        return 1.0
+
+    ys1, xs1 = np.where(mask1 == 1)
+    ys2, xs2 = np.where(mask2 == 1)
+
+    if len(xs1) == 0 or len(xs2) == 0:
+        return 1.0
+
+    c1 = np.array([xs1.mean(), ys1.mean()])
+    c2 = np.array([xs2.mean(), ys2.mean()])
+
+    return np.linalg.norm(c1 - c2) / max(mask1.shape)
+
+
+def overlap_ratio(mask1, mask2):
+    if mask2 is None:
+        return 0.0
+    inter = np.logical_and(mask1, mask2).sum()
+    return inter / mask1.sum() if mask1.sum() > 0 else 0.0
+
+# ------------------------------------------------------------
+# LOAD YOLO POLYGONS
+# ------------------------------------------------------------
+def load_yolo_segmentation(label_path):
+    objects = []
+    if not os.path.exists(label_path):
+        return objects
+
+    with open(label_path) as f:
+        for line in f:
+            parts = list(map(float, line.strip().split()))
+            cls = int(parts[0])
+            coords = parts[1:]
+            polygon = [(coords[i], coords[i + 1]) for i in range(0, len(coords), 2)]
+            objects.append({"cls": cls, "polygon": polygon})
+    return objects
+
+# ------------------------------------------------------------
+# FEATURE EXTRACTION
+# ------------------------------------------------------------
+def extract_features_from_label(label_path, H, W):
+    objects = load_yolo_segmentation(label_path)
+
+    cervix_masks, scj_masks, acet_masks = [], [], []
+
+    for obj in objects:
+        m = polygon_to_mask(obj["polygon"], H, W)
+        if obj["cls"] == CERVIX_ID:
+            cervix_masks.append(m)
+        elif obj["cls"] == SCJ_ID:
+            scj_masks.append(m)
+        elif obj["cls"] == ACET_ID:
+            acet_masks.append(m)
+
+    cervix = max(cervix_masks, key=lambda m: m.sum()) if cervix_masks else np.zeros((H, W))
+    scj = max(scj_masks, key=lambda m: m.sum()) if scj_masks else None
+
+    cervix_area = mask_area(cervix)
+
+    acet_union = np.zeros((H, W), dtype=np.uint8)
+    for m in acet_masks:
+        acet_union = np.maximum(acet_union, m)
+
+    acet_union = acet_union * cervix
+
+    if acet_union.sum() > 0:
+        acet_union = cv2.morphologyEx(
+            acet_union, cv2.MORPH_CLOSE, np.ones((5, 5), np.uint8)
+        )
+
+    acet_area = mask_area(acet_union)
+    acet_present = int(cervix_area > 0 and acet_area / cervix_area >= MIN_ACET_RATIO)
+
+    if acet_present:
+        dist_acet_scj = centroid_distance(acet_union, scj)
+        lesion_center_dist = centroid_distance(acet_union, cervix)
+        overlap_lesion_scj = overlap_ratio(acet_union, scj)
+    else:
+        dist_acet_scj = lesion_center_dist = 1.0
+        overlap_lesion_scj = 0.0
+
+    return torch.tensor([
+        acet_present,
+        1 if acet_present else 0,
+        acet_area if acet_present else 0.0,
+        acet_area / cervix_area if acet_present else 0.0,
+        dist_acet_scj,
+        lesion_center_dist,
+        overlap_lesion_scj
+    ], dtype=torch.float32)
+
+# ------------------------------------------------------------
+# SAVE VISUALIZATION FOR UI
+# ------------------------------------------------------------
+def save_overlay(image_path, label_path, out_path):
+    image = np.array(Image.open(image_path).convert("RGB"))
+    H, W, _ = image.shape
+
+    objects = load_yolo_segmentation(label_path)
+
+    cervix = np.zeros((H, W))
+    scj = np.zeros((H, W))
+    acet = np.zeros((H, W))
+
+    for obj in objects:
+        m = polygon_to_mask(obj["polygon"], H, W)
+        if obj["cls"] == CERVIX_ID:
+            cervix = np.maximum(cervix, m)
+        elif obj["cls"] == SCJ_ID:
+            scj = np.maximum(scj, m)
+        elif obj["cls"] == ACET_ID:
+            acet = np.maximum(acet, m)
+
+    overlay = image.copy()
+    overlay[cervix == 1] = 0.7 * overlay[cervix == 1] + 0.3 * np.array([0, 0, 255])
+    overlay[scj == 1]    = 0.7 * overlay[scj == 1]    + 0.3 * np.array([0, 255, 0])
+    overlay[acet == 1]   = 0.7 * overlay[acet == 1]   + 0.3 * np.array([255, 0, 0])
+
+    Image.fromarray(overlay.astype(np.uint8)).save(out_path)
+
+# ------------------------------------------------------------
+# PUBLIC API — UI CALLS THIS
+# ------------------------------------------------------------
+def run_inference(image_path: str) -> dict:
+    results = seg_model(image_path, conf=0.15, save_txt=True, save=False)
+
+    save_dir = results[0].save_dir
+    name = os.path.splitext(os.path.basename(image_path))[0]
+    label_path = os.path.join(save_dir, "labels", f"{name}.txt")
+
+    if not os.path.exists(label_path):
+        return {"decision": "Segmentation failed"}
+
+    image = Image.open(image_path).convert("RGB")
+    W, H = image.size
+
+    img_tensor = transform(image).unsqueeze(0).to(device)
+    feat = extract_features_from_label(label_path, H, W)
+    feat_tensor = feat.unsqueeze(0).to(device)
+
+    with torch.no_grad():
+        embedding = fusion_model(img_tensor, feat_tensor)
+
+    prob = clf.predict_proba(embedding.cpu().numpy())[0, 1]
+    acet_present = int(feat[0].item())
+
+    if acet_present == 0:
+        decision = "Low-confidence normal (no acet detected)" if prob < 0.2 else "Uncertain – lesion may be subtle"
+    else:
+        decision = "Likely Normal" if prob < 0.2 else "Borderline – Review" if prob < 0.5 else "Likely Abnormal"
+
+    overlay_path = os.path.join(OUTPUT_DIR, f"{name}_overlay.png")
+    save_overlay(image_path, label_path, overlay_path)
+
+    return {
+        "decision": decision,
+        "probability_abnormal": float(prob),
+        "acet_present": acet_present,
+        "overlay_image": overlay_path
+    }

backend/Colpo/models/fusion_model.pth

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

backend/Colpo/models/logreg_classifier.joblib

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

backend/Colpo/models/seg_yolov8n_best.pt

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

backend/app.py

@@ -11,6 +11,7 @@ os.environ["MPLCONFIGDIR"] = "/tmp/matplotlib"
 os.environ["YOLO_CONFIG_DIR"] = "/tmp/Ultralytics"
 
 import json
+import importlib.util
 import uuid
 import datetime
 import numpy as np
@@ -279,6 +280,22 @@ except Exception as e:
 
 yolo_colposcopy = YOLO("yolo_colposcopy.pt")
 
+# Load the Manalife Pathora colposcopy fusion pipeline
+COLPO_INFERENCE_PATH = os.path.join(os.path.dirname(__file__), "Colpo", "inference.py")
+colpo_inference = None
+
+try:
+    spec = importlib.util.spec_from_file_location("colpo_inference", COLPO_INFERENCE_PATH)
+    if spec and spec.loader:
+        colpo_inference = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(colpo_inference)
+        print("✅ Loaded Manalife Pathora colposcopy inference module.")
+    else:
+        raise ImportError("Invalid import spec for Colpo inference module")
+except Exception as e:
+    colpo_inference = None
+    print(f"⚠️ Could not load Manalife Pathora colposcopy inference: {e}")
+
 # =====================================================
 
 # RESNET FEATURE EXTRACTORS FOR CIN
@@ -431,10 +448,10 @@ async def predict(model_name: str = Form(...), file: UploadFile = File(...)):
     print(f"Received prediction request - model: {model_name}, file: {file.filename}")
     
     # Validate model name
-    if model_name not in ["yolo", "mwt", "cin", "histopathology"]:
+    if model_name not in ["yolo", "mwt", "cin", "histopathology", "manalife_pathora_model"]:
         return JSONResponse(
             content={
-                "error": f"Invalid model_name: {model_name}. Must be one of: yolo, mwt, cin, histopathology"
+                "error": f"Invalid model_name: {model_name}. Must be one of: yolo, mwt, cin, histopathology, manalife_pathora_model"
             },
             status_code=400
         )
@@ -620,9 +637,63 @@ async def predict(model_name: str = Form(...), file: UploadFile = File(...)):
             )
 
         return response
+    elif model_name == "manalife_pathora_model":
+        if colpo_inference is None or not hasattr(colpo_inference, "run_inference"):
+            return JSONResponse(
+                content={"error": "Pathora colposcopy model not available on server."},
+                status_code=503,
+            )
+
+        # Save the incoming image to disk for the fusion pipeline
+        input_name = f"colpo_input_{uuid.uuid4().hex[:8]}.png"
+        input_path = os.path.join(IMAGES_DIR, input_name)
+        with open(input_path, "wb") as f:
+            f.write(contents)
+
+        try:
+            fusion_result = colpo_inference.run_inference(input_path)
+        except Exception as e:
+            return JSONResponse(
+                content={"error": f"Colposcopy fusion inference failed: {e}"},
+                status_code=500,
+            )
+
+        prob_abn = float(fusion_result.get("probability_abnormal", 0.0))
+        acet_present = int(fusion_result.get("acet_present", 0))
+        decision_text = fusion_result.get("decision", "Decision unavailable")
+
+        overlay_src = fusion_result.get("overlay_image")
+        overlay_url = None
+        if overlay_src and os.path.isfile(overlay_src):
+            overlay_name = f"colpo_overlay_{uuid.uuid4().hex[:8]}.png"
+            overlay_dst = os.path.join(IMAGES_DIR, overlay_name)
+            try:
+                shutil.copy(overlay_src, overlay_dst)
+                overlay_url = f"/outputs/images/{overlay_name}"
+            except Exception as copy_err:
+                print(f"⚠️ Failed to copy overlay image: {copy_err}")
+
+        # Fallback: expose the raw input if overlay is missing
+        if not overlay_url:
+            overlay_url = f"/outputs/images/{input_name}"
+
+        return {
+            "model_used": "Manalife_Pathora_model",
+            "decision": decision_text,
+            "probability_abnormal": round(prob_abn, 3),
+            "acet_present": acet_present,
+            "annotated_image_url": overlay_url,
+            "summary": {
+                "model_used": "Manalife_Pathora_model",
+                "decision": decision_text,
+                "probability_abnormal": round(prob_abn, 3),
+                "acet_present": "Yes" if acet_present else "No",
+                "ai_interpretation": decision_text,
+            },
+        }
     elif model_name == "histopathology":
-            result = predict_histopathology(image)
-            return result
+        result = predict_histopathology(image)
+        return result
 
 
     else:

frontend/src/components/ResultsPanel.tsx

@@ -80,6 +80,10 @@ export function ResultsPanel({ uploadedImage, result, loading }: ResultsPanelPro
     confidence,
   } = (result || {}) as any;
 
+  const decisionText = String(result?.decision ?? summary?.decision ?? "").trim();
+  const probabilityAbnormal = (result?.probability_abnormal ?? summary?.probability_abnormal) as any;
+  const acetPresentFlag = result?.acet_present ?? summary?.acet_present;
+
   const handleDownload = () => {
     if (annotated_image_url) {
       const link = document.createElement("a");
@@ -145,7 +149,7 @@ export function ResultsPanel({ uploadedImage, result, loading }: ResultsPanelPro
     {/* Summary Section - model-specific rendering (colposcopy, cytology, histopathology) */}
     {summary && (() => {
       const model = (model_used || "").toString();
-      const isColpo = /colpo|colposcopy/i.test(model);
+      const isColpo = /colpo|colposcopy|pathora/i.test(model);
       const isCyto = /cyto|cytology/i.test(model);
       const isHistoLike = /mwt|cin|histopath/i.test(model);
 
@@ -154,13 +158,31 @@ export function ResultsPanel({ uploadedImage, result, loading }: ResultsPanelPro
       const pred = (summary.prediction || summary.result || "").toString().toLowerCase();
       const isAbnormal = abnormalCount > 0 || /abnormal|positive|high-grade|malignant/.test(pred);
 
-      // Colposcopy: show only Abnormal / Normal (based on abnormal_cells count or prediction)
+      // Colposcopy: render decision + probability + acet status
       if (isColpo) {
+        const probVal =
+          probabilityAbnormal === null || typeof probabilityAbnormal === "undefined"
+            ? null
+            : Number(probabilityAbnormal);
+        const probText = probVal === null || Number.isNaN(probVal) ? null : probVal.toFixed(3);
+        const acetLabel =
+          typeof acetPresentFlag === "undefined" || acetPresentFlag === null
+            ? "Unknown"
+            : Number(acetPresentFlag) ? "Yes" : "No";
+        const decision = decisionText || (isAbnormal ? "Abnormal" : "Normal");
         return (
           <div className="bg-gray-50 p-4 rounded-lg mb-6">
             <h3 className="text-lg font-semibold text-gray-800 mb-2">AI Summary</h3>
             <p className="text-gray-700 text-sm">
-              <strong>Result:</strong> {isAbnormal ? "Abnormal" : "Normal"}
+              <strong>Decision:</strong> {decision}
+              {probText && (
+                <>
+                  <br />
+                  <strong>Probability of abnormality:</strong> {probText}
+                </>
+              )}
+              <br />
+              <strong>Acet present:</strong> {acetLabel}
             </p>
             <div className="mt-3 text-gray-800 text-sm italic border-t pt-2">
               {summary.ai_interpretation || "No AI interpretation available."}

frontend/src/components/UploadSection.tsx

@@ -29,6 +29,7 @@ export function UploadSection({
     ],
     colposcopy: [
       { value: 'cin', label: 'Manalife_MaANIA_Colpo' },
+      { value: 'manalife_pathora_model', label: 'Manalife_Pathora_model' },
 
     ],
     histopathology: [