Initial Space

.gitattributes

@@ -33,5 +33,8 @@ 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
+backend/histopathology_trained_model.keras filter=lfs diff=lfs merge=lfs -text
+frontend/public/cyto/*.jpg filter=lfs diff=lfs merge=lfs -text
+frontend/public/cyto/*.png filter=lfs diff=lfs merge=lfs -text
 backend/outputs/** filter=lfs diff=lfs merge=lfs -text
 frontend/public/cyto/** filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,43 @@
+# -----------------------------
+# 1️⃣ Build Frontend
+# -----------------------------
+FROM node:18-bullseye AS frontend-builder
+WORKDIR /app/frontend
+COPY frontend/package*.json ./
+RUN npm install
+COPY frontend/ .
+RUN npm run build
+
+# -----------------------------
+# 2️⃣ Build Backend
+# -----------------------------
+FROM python:3.10-slim-bullseye
+
+WORKDIR /app
+
+# Install essential system libraries for OpenCV, YOLO, and Ultralytics
+RUN apt-get update && apt-get install -y \
+    libgl1 \
+    libglib2.0-0 \
+    libgomp1 \
+ && apt-get clean && rm -rf /var/lib/apt/lists/*
+
+# Copy backend source code
+COPY backend/ .
+
+# Copy built frontend into the right folder for FastAPI
+# ✅ this must match your app.mount() path in app.py
+COPY --from=frontend-builder /app/frontend/dist ./frontend/dist
+
+# Install Python dependencies
+RUN pip install --upgrade pip
+RUN pip install -r requirements.txt || pip install -r backend/requirements.txt || true
+
+# Install runtime dependencies explicitly
+RUN pip install --no-cache-dir fastapi uvicorn python-multipart ultralytics opencv-python-headless pillow numpy scikit-learn tensorflow keras
+
+# Hugging Face Spaces expect port 7860
+EXPOSE 7860
+
+# Run FastAPI app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,11 +1,10 @@
 ---
-title: Pathora
-emoji: 🐨
-colorFrom: red
+title: Proj Demo
+emoji: 🚀
+colorFrom: purple
 colorTo: green
 sdk: docker
 pinned: false
-short_description: Manalife's AI Pathology Assistant
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

backend/MWTclass2.pth

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

backend/app.py

@@ -0,0 +1,241 @@
+from fastapi import FastAPI, File, UploadFile, Form
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from fastapi.staticfiles import StaticFiles
+from ultralytics import YOLO
+from io import BytesIO
+from PIL import Image
+import uvicorn
+import json, os, uuid, numpy as np, torch, cv2, joblib, io, tensorflow as tf
+import torch.nn as nn
+import torchvision.transforms as transforms
+import torchvision.models as models
+from sklearn.preprocessing import MinMaxScaler
+from model import MWT as create_model
+from augmentations import Augmentations
+from model_histo import BreastCancerClassifier  # TensorFlow model
+
+from huggingface_hub import login
+import os
+
+hf_token = os.getenv("HF_TOKEN")
+if hf_token:
+    login(token=hf_token)
+
+
+# =====================================================
+# App setup
+# =====================================================
+app = FastAPI(title="Unified Cervical & Breast Cancer Analysis API")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+OUTPUT_DIR = "outputs"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+app.mount("/outputs", StaticFiles(directory=OUTPUT_DIR), name="outputs")
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# =====================================================
+# Model 1: YOLO (Colposcopy Detection)
+# =====================================================
+print("🔹 Loading YOLO model...")
+yolo_model = YOLO("best2.pt")
+
+# =====================================================
+# Model 2: MWT Classifier
+# =====================================================
+print("🔹 Loading MWT model...")
+mwt_model = create_model(num_classes=2).to(device)
+mwt_model.load_state_dict(torch.load("MWTclass2.pth", map_location=device))
+mwt_model.eval()
+mwt_class_names = ['neg', 'pos']
+
+# =====================================================
+# Model 3: CIN Classifier
+# =====================================================
+print("🔹 Loading CIN model...")
+clf = joblib.load("logistic_regression_model.pkl")
+yolo_colposcopy = YOLO("yolo_colposcopy.pt")
+
+def build_resnet(model_name="resnet50"):
+    if model_name == "resnet50":
+        model = models.resnet50(weights=models.ResNet50_Weights.DEFAULT)
+    elif model_name == "resnet101":
+        model = models.resnet101(weights=models.ResNet101_Weights.DEFAULT)
+    elif model_name == "resnet152":
+        model = models.resnet152(weights=models.ResNet152_Weights.DEFAULT)
+    model.eval().to(device)
+    return (
+        nn.Sequential(model.conv1, model.bn1, model.relu, model.maxpool),
+        model.layer1, model.layer2, model.layer3, model.layer4,
+    )
+
+gap = nn.AdaptiveAvgPool2d((1, 1))
+gmp = nn.AdaptiveMaxPool2d((1, 1))
+resnet50_blocks = build_resnet("resnet50")
+resnet101_blocks = build_resnet("resnet101")
+resnet152_blocks = build_resnet("resnet152")
+
+transform = transforms.Compose([
+    transforms.ToPILImage(),
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                         std=[0.229, 0.224, 0.225]),
+])
+
+# =====================================================
+# Model 4: Histopathology Classifier (TensorFlow)
+# =====================================================
+print("🔹 Loading Breast Cancer Histopathology model...")
+classifier = BreastCancerClassifier(fine_tune=False)
+if not classifier.authenticate_huggingface():
+    raise RuntimeError("HuggingFace authentication failed.")
+if not classifier.load_path_foundation():
+    raise RuntimeError("Failed to load Path Foundation model.")
+model_path = "histopathology_trained_model.keras"
+classifier.model = tf.keras.models.load_model(model_path)
+print(f"✅ Loaded model from {model_path}")
+
+# =====================================================
+# Helper functions
+# =====================================================
+def preprocess_for_mwt(image_np):
+    img = cv2.resize(image_np, (224, 224))
+    img = Augmentations.Normalization((0, 1))(img)
+    img = np.array(img, np.float32)
+    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+    img = img.transpose(2, 0, 1)
+    img = np.expand_dims(img, axis=0)
+    return torch.Tensor(img)
+
+def extract_cbf_features(blocks, img_t):
+    block1, block2, block3, block4, block5 = blocks
+    with torch.no_grad():
+        f1 = block1(img_t)
+        f2 = block2(f1)
+        f3 = block3(f2)
+        f4 = block4(f3)
+        f5 = block5(f4)
+        p1 = gmp(f1).view(-1)
+        p2 = gmp(f2).view(-1)
+        p3 = gap(f3).view(-1)
+        p4 = gap(f4).view(-1)
+        p5 = gap(f5).view(-1)
+        cbf_feature = torch.cat([p1, p2, p3, p4, p5], dim=0)
+    return cbf_feature.cpu().numpy()
+
+def predict_histopathology(image: Image.Image):
+    if image.mode != "RGB":
+        image = image.convert("RGB")
+    image = image.resize((224, 224))
+    img_array = np.expand_dims(np.array(image).astype("float32") / 255.0, axis=0)
+    embeddings = classifier.extract_embeddings(img_array)
+    prediction_proba = classifier.model.predict(embeddings, verbose=0)[0]
+    predicted_class = int(np.argmax(prediction_proba))
+    class_names = ["Benign", "Malignant"]
+    return {
+        "model_used": "Breast Cancer Histopathology Classifier",
+        "prediction": class_names[predicted_class],
+        "confidence": float(np.max(prediction_proba)),
+        "probabilities": {
+            "Benign": float(prediction_proba[0]),
+            "Malignant": float(prediction_proba[1])
+        }
+    }
+
+# =====================================================
+# Main endpoint
+# =====================================================
+@app.post("/predict/")
+async def predict(model_name: str = Form(...), file: UploadFile = File(...)):
+    contents = await file.read()
+    image = Image.open(BytesIO(contents)).convert("RGB")
+    image_np = np.array(image)
+
+    if model_name == "yolo":
+        results = yolo_model(image)
+        detections_json = results[0].to_json()
+        detections = json.loads(detections_json)
+        output_filename = f"detected_{uuid.uuid4().hex[:8]}.jpg"
+        output_path = os.path.join(OUTPUT_DIR, output_filename)
+        results[0].save(filename=output_path)
+        return {
+            "model_used": "YOLO Detection",
+            "detections": detections,
+            "annotated_image_url": f"/outputs/{output_filename}"
+        }
+
+    elif model_name == "mwt":
+        tensor = preprocess_for_mwt(image_np)
+        with torch.no_grad():
+            output = mwt_model(tensor.to(device)).cpu()
+            probs = torch.softmax(output, dim=1)[0]
+        confidences = {mwt_class_names[i]: float(probs[i]) for i in range(2)}
+        predicted_label = mwt_class_names[torch.argmax(probs)]
+        return {"model_used": "MWT Classifier", "prediction": predicted_label, "confidence": confidences}
+
+    elif model_name == "cin":
+        nparr = np.frombuffer(contents, np.uint8)
+        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        results = yolo_colposcopy.predict(source=img, conf=0.7, save=False, verbose=False)
+        if len(results[0].boxes) == 0:
+            return {"error": "No cervix detected"}
+        x1, y1, x2, y2 = map(int, results[0].boxes.xyxy[0].cpu().numpy())
+        crop = img[y1:y2, x1:x2]
+        crop = cv2.resize(crop, (224, 224))
+        img_t = transform(crop).unsqueeze(0).to(device)
+        f50 = extract_cbf_features(resnet50_blocks, img_t)
+        f101 = extract_cbf_features(resnet101_blocks, img_t)
+        f152 = extract_cbf_features(resnet152_blocks, img_t)
+        features = np.concatenate([f50, f101, f152]).reshape(1, -1)
+        X_scaled = MinMaxScaler().fit_transform(features)
+        pred = clf.predict(X_scaled)[0]
+        proba = clf.predict_proba(X_scaled)[0]
+        classes = ["CIN1", "CIN2", "CIN3"]
+        return {
+            "model_used": "CIN Classifier",
+            "prediction": classes[pred],
+            "probabilities": dict(zip(classes, map(float, proba)))
+        }
+
+    elif model_name == "histopathology":
+        result = predict_histopathology(image)
+        return result
+
+    else:
+        return JSONResponse(content={"error": "Invalid model name"}, status_code=400)
+
+
+@app.get("/models")
+def get_models():
+    return {"available_models": ["yolo", "mwt", "cin", "histopathology"]}
+
+
+@app.get("/health")
+def health():
+    return {"message": "Unified Cervical & Breast Cancer API is running!"}
+
+# After other app.mount()s
+app.mount("/outputs", StaticFiles(directory=OUTPUT_DIR), name="outputs")
+app.mount("/assets", StaticFiles(directory="frontend/dist/assets"), name="assets")
+from fastapi.staticfiles import StaticFiles
+
+app.mount("/", StaticFiles(directory="frontend/dist", html=True), name="static")
+
+
+@app.get("/")
+async def serve_frontend():
+    index_path = os.path.join("frontend", "dist", "index.html")
+    return FileResponse(index_path)
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)
+    

backend/augmentations.py

@@ -0,0 +1,328 @@
+# -*- coding: utf-8 -*-
+"""
+This file is a part of project "Aided-Diagnosis-System-for-Cervical-Cancer-Screening".
+See https://github.com/ShenghuaCheng/Aided-Diagnosis-System-for-Cervical-Cancer-Screening for more information.
+File name: augmentations.py
+Description: augmentation functions.
+"""
+
+import functools
+import random
+import cv2
+import numpy as np
+from skimage.exposure import adjust_gamma
+from loguru import logger
+
+__all__ = [
+    "Augmentations",
+    "StylisticTrans",
+    "SpatialTrans",
+]
+
+
+class Augmentations:
+    """
+    All parameters in each augmentations have been fixed to a suitable range.
+    img = [size, size, ch]
+    ch = 3: only img
+    ch = 4: img with mask at 4th dim
+    """
+
+    @staticmethod
+    def Compose(*funcs):
+        funcs = list(funcs)
+        func_names = [f.__name__ for f in funcs]
+        # ensure the norm opt is the last opt
+        if 'norm' in func_names:
+            idx = func_names.index('norm')
+            funcs = funcs[:idx] + funcs[idx:] + [funcs[idx]]
+
+        def compose(img: np.ndarray):
+            return functools.reduce(lambda f, g: lambda x: g(f(x)), funcs)(img)
+
+        return compose
+
+    """
+    # ===========================================================================================================
+    # random stylistic augmentations
+    """
+
+    @staticmethod
+    def RandomGamma(p: float = 0.5):
+        def random_gamma(img: np.ndarray):
+            if random.random() < p:
+                gamma = 0.6 + random.random() * 0.6
+                img[..., :3] = StylisticTrans.gamma_adjust(img[..., :3], gamma)
+            return img
+
+        return random_gamma
+
+    @staticmethod
+    def RandomSharp(p: float = 0.5):
+        def random_sharp(img: np.ndarray):
+            if random.random() < p:
+                sigma = 8.3 + random.random() * 0.4
+                img[..., :3] = StylisticTrans.sharp(img[..., :3], sigma)
+            return img
+
+        return random_sharp
+
+    @staticmethod
+    def RandomGaussainBlur(p: float = 0.5):
+        def random_gaussian_blur(img: np.ndarray):
+            if random.random() < p:
+                sigma = 0.1 + random.random() * 1
+                img[..., :3] = StylisticTrans.gaussian_blur(img[..., :3], sigma)
+            return img
+
+        return random_gaussian_blur
+
+    @staticmethod
+    def RandomHSVDisturb(p: float = 0.5):
+        def random_hsv_disturb(img: np.ndarray):
+            if random.random() < p:
+                k = np.random.random(3) * [0.1, 0.8, 0.45] + [0.95, 0.7, 0.75]
+                b = np.random.random(3) * [6, 20, 18] + [-3, -10, -10]
+                img[..., :3] = StylisticTrans.hsv_disturb(img[..., :3], k.tolist(), b.tolist())
+            return img
+
+        return random_hsv_disturb
+
+    @staticmethod
+    def RandomRGBSwitch(p: float = 0.5):
+        def random_rgb_switch(img: np.ndarray):
+            if random.random() < p:
+                bgr_seq = list(range(3))
+                random.shuffle(bgr_seq)
+                img[..., :3] = StylisticTrans.bgr_switch(img[..., :3], bgr_seq)
+            return img
+
+        return random_rgb_switch
+
+    """
+    # ===========================================================================================================
+    # random spatial augmentations, funcs can be implement to tiles and their masks.  
+    """
+
+    @staticmethod
+    def RandomRotate90(p: float = 0.5):
+        def random_rotate90(img: np.ndarray):
+            if random.random() < p:
+                angle = 90 * random.randint(1, 3)
+                img = SpatialTrans.rotate(img, angle)
+            return img
+
+        return random_rotate90
+
+    @staticmethod
+    def RandomHorizontalFlip(p: float = 0.5):
+        def random_horizontal_flip(img: np.ndarray):
+            if random.random() < p:
+                img = SpatialTrans.flip(img, 0)
+            return img
+
+        return random_horizontal_flip
+
+    @staticmethod
+    def RandomVerticalFlip(p: float = 0.5):
+        def random_vertical_flip(img: np.ndarray):
+            if random.random() < p:
+                img = SpatialTrans.flip(img, 1)
+            return img
+
+        return random_vertical_flip
+
+    @staticmethod
+    def RandomScale(p: float = 0.5):
+        def random_scale(img: np.ndarray):
+            if random.random() < p:
+                ratio = 0.8 + random.random() * 0.4
+                img = SpatialTrans.scale(img, ratio, True)
+            return img
+
+        return random_scale
+
+    @staticmethod
+    def RandomCrop(p: float = 1., size: tuple = (512, 512)):
+        def random_crop(img: np.ndarray):
+            if random.random() < p:
+                # for a large FOV, control the translate range
+                new_shape = list(img.shape[:2][::-1])
+                if img.shape[0] > size[1] * 1.5:
+                    new_shape[1] = int(size[1] * 1.5)
+                if img.shape[1] > size[0] * 1.5:
+                    new_shape[0] = int(size[0] * 1.5)
+                img = SpatialTrans.center_crop(img.copy(), tuple(new_shape))
+                # do translate
+                xy = np.random.random(2) * (np.array(img.shape[:2]) - list(size))
+                bbox = tuple(xy.astype(np.int).tolist() + list(size))
+                img = SpatialTrans.crop(img, bbox)
+            else:
+                img = SpatialTrans.center_crop(img, size)
+            return img
+
+        return random_crop
+
+    @staticmethod
+    def Normalization(rng: list = [-1, 1]):
+        def norm(img: np.ndarray):
+            img = StylisticTrans.normalization(img, rng)
+            return img
+
+        return norm
+
+    @staticmethod
+    def CenterCrop(size: tuple = (512, 512)):
+        def center_crop(img: np.ndarray):
+            img = SpatialTrans.center_crop(img, size)
+            return img
+
+        return center_crop
+
+
+class StylisticTrans:
+    # TODO Some implementations of augmentation need a efficient way
+    """
+    set of augmentations applied to the content of image
+    """
+
+    @staticmethod
+    def gamma_adjust(img: np.ndarray, gamma: float):
+        """ adjust gamma
+        :param img: a ndarray, better a BGR
+        :param gamma: gamma, recommended value 0.6, range [0.6, 1.2]
+        :return: a ndarray
+        """
+        return adjust_gamma(img.copy(), gamma)
+
+    @staticmethod
+    def sharp(img: np.ndarray, sigma: float):
+        """sharp image
+        :param img: a ndarray, better a BGR
+        :param sigma: sharp degree, recommended range [8.3, 8.7]
+        :return: a ndarray
+        """
+        kernel = np.array([[-1, -1, -1], [-1, sigma, -1], [-1, -1, -1]], np.float32) / (sigma - 8)  # 锐化
+        return cv2.filter2D(img.copy(), -1, kernel=kernel)
+
+    @staticmethod
+    def gaussian_blur(img: np.ndarray, sigma: float):
+        """blurring image
+        :param img: a ndarray, better a BGR
+        :param sigma: blurring degree, recommended range [0.1, 1.1]
+        :return: a ndarray
+        """
+        return cv2.GaussianBlur(img.copy(), (int(6 * np.ceil(sigma) + 1), int(6 * np.ceil(sigma) + 1)), sigma)
+
+    @staticmethod
+    def hsv_disturb(img: np.ndarray, k: list, b: list):
+        """ disturb the hsv value
+        :param img: a BGR ndarray
+        :param k: low_b = [0.95, 0.7, 0.75] ,upper_b = [1.05, 1.5, 1.2]
+        :param b: low_b = [-3, -10, -10] ,upper_b = [3, 10, 8]
+        :return: a BGR ndarray
+        """
+        img = cv2.cvtColor(img.copy(), cv2.COLOR_BGR2HSV)
+        img = img.astype(np.float)
+        for ch in range(3):
+            img[..., ch] = k[ch] * img[..., ch] + b[ch]
+        img = np.uint8(np.clip(img, np.array([0, 1, 1]), np.array([180, 255, 255])))
+        return cv2.cvtColor(img, cv2.COLOR_HSV2BGR)
+
+    @staticmethod
+    def bgr_switch(img: np.ndarray, bgr_seq: list):
+        """ switch bgr
+        :param img: a ndarray, better a BGR
+        :param bgr_seq: new ch seq
+        :return: a ndarray
+        """
+        return img.copy()[..., bgr_seq]
+
+    @staticmethod
+    def normalization(img: np.ndarray, rng: list):
+        """normalize image according to min and max
+        :param img: a ndarray
+        :param rng: normalize image value to range[min, max]
+        :return: a ndarray
+        """
+        lb, ub = rng
+        delta = ub - lb
+        return (img.copy().astype(np.float64) / 255.) * delta + lb#yjx
+
+
+class SpatialTrans:
+    """
+    set of augmentations applied to the spatial space of image
+    """
+
+    @staticmethod
+    def rotate(img: np.ndarray, angle: int):
+        """ rotate image
+        # todo Square image and central rotate only, a universal version is needed
+        :param img: a ndarray
+        :param angle: rotate angle
+        :return: a ndarray has same size as input, padding zero or cut out region out of picture
+        """
+        assert img.shape[0] == img.shape[1], "Square image needed."
+        center = (img.shape[0]/2, img.shape[1]/2)
+        mat = cv2.getRotationMatrix2D(center, angle, scale=1)
+        # mat = cv2.getRotationMatrix2D(tuple(np.array(img.shape[:2]) // 2), angle, scale=1)
+        return cv2.warpAffine(img.copy(), mat, img.shape[:2])
+
+    @staticmethod
+    def flip(img: np.ndarray, flip_axis: int):
+        """flip image horizontal or vertical
+        :param img: a ndarray
+        :param flip_axis: 0 for horizontal, 1 for vertical
+        :return:  a flipped image
+        """
+        return cv2.flip(img.copy(), flip_axis)
+
+    @staticmethod
+    def scale(img: np.ndarray, ratio: float, fix_size: bool = False):
+        """scale image
+        :param img: a ndarray
+        :param ratio: scale ratio
+        :param fix_size: return the center area of scaled image, size of area is same as the image before scaling
+        :return:  a scaled image
+        """
+        shape = img.shape[:2][::-1]
+        img = cv2.resize(img.copy(), None, fx=ratio, fy=ratio)
+        if fix_size:
+            img = SpatialTrans.center_crop(img, shape)
+        return img
+
+    @staticmethod
+    def crop(img: np.ndarray, bbox: tuple):
+        """crop image according to given bbox
+        :param img: a ndarray
+        :param bbox: bbox of cropping area (x, y, w, h)
+        :return: cropped image,padding with zeros
+        """
+        ch = [] if len(img.shape) == 2 else [img.shape[-1]]
+        template = np.zeros(list(bbox[-2:])[::-1] + ch)
+
+        if (bbox[1] >= img.shape[0] or bbox[1] >= img.shape[1]) or (bbox[0] + bbox[2] <= 0 or bbox[1] + bbox[3] <= 0):
+            logger.warning("Crop area contains nothing, return a zeros array {}".format(template.shape))
+            return template
+
+        foreground = img[
+                     np.maximum(bbox[1], 0): np.minimum(bbox[1] + bbox[3], img.shape[0]),
+                     np.maximum(bbox[0], 0): np.minimum(bbox[0] + bbox[2], img.shape[1]), :]
+
+        template[
+        np.maximum(-bbox[1], 0): np.minimum(-bbox[1] + img.shape[0], bbox[3]),
+        np.maximum(-bbox[0], 0): np.minimum(-bbox[0] + img.shape[1], bbox[2]), :] = foreground
+        return template.astype(np.uint8)
+
+    @staticmethod
+    def center_crop(img: np.ndarray, shape: tuple):
+        """return the center area in shape
+        :param img: a ndarray
+        :param shape: center crop shape (w, h)
+        :return:
+        """
+        center = np.array(img.shape[:2]) // 2
+        init = center[::-1] - np.array(shape) // 2
+        bbox = tuple(init.tolist() + list(shape))
+        return SpatialTrans.crop(img, bbox)

backend/best2.pt

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

backend/histopathology_trained_model.keras

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

backend/logistic_regression_model.pkl

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

backend/model.py

@@ -0,0 +1,521 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as checkpoint
+import numpy as np
+from typing import Optional
+from thop import profile
+
+class IRB(nn.Module):
+    def __init__(self, in_features, hidden_features=None, out_features=None, ksize=3, act_layer=nn.Hardswish, drop=0.):
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+        self.fc1 = nn.Conv2d(in_features, hidden_features, 1, 1, 0)
+        self.act = act_layer()
+        self.conv = nn.Conv2d(hidden_features, hidden_features, kernel_size=ksize, padding=ksize // 2, stride=1,
+                              groups=hidden_features)
+        self.fc2 = nn.Conv2d(hidden_features, out_features, 1, 1, 0)
+        self.drop = nn.Dropout(drop)
+
+    def forward(self, x, H, W):
+        B, N, C = x.shape
+        x = x.permute(0, 2, 1).reshape(B, C, H, W)
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.conv(x)
+        x = self.act(x)
+        x = self.fc2(x)
+        return x.reshape(B, C, -1).permute(0, 2, 1)
+
+
+def drop_path_f(x, drop_prob: float = 0., training: bool = False):
+
+    if drop_prob == 0. or not training:
+        return x
+    keep_prob = 1 - drop_prob
+    shape = (x.shape[0],) + (1,) * (x.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
+    random_tensor = keep_prob + torch.rand(shape, dtype=x.dtype, device=x.device)
+    random_tensor.floor_()  # binarize
+    output = x.div(keep_prob) * random_tensor
+    return output
+
+
+class DropPath(nn.Module):
+
+    def __init__(self, drop_prob=None):
+        super(DropPath, self).__init__()
+        self.drop_prob = drop_prob
+
+    def forward(self, x):
+        return drop_path_f(x, self.drop_prob, self.training)
+
+
+def window_partition(x, window_size: int):
+    B, H, W, C = x.shape
+    x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
+    windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
+    return windows
+
+
+def window_reverse(windows, window_size: int, H: int, W: int):
+
+    B = int(windows.shape[0] / (H * W / window_size / window_size))
+    x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
+    x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
+    return x
+
+
+class PatchEmbed2(nn.Module):
+    def __init__(self, dim:int, patch_size=2, in_c=3, norm_layer=None):
+        super().__init__()
+        patch_size = (patch_size, patch_size)
+        self.patch_size = patch_size
+        self.in_chans = in_c
+        self.embed_dim = dim
+        self.proj = nn.Conv2d(dim, 2*dim, kernel_size=patch_size, stride=patch_size)
+        self.norm = norm_layer(2*dim) if norm_layer else nn.Identity()
+
+    def forward(self, x, H, W):
+        B, L, C = x.shape
+        assert L == H * W, "input feature has wrong size"
+
+        x = x.view(B, H, W, C)
+        pad_input = (H % self.patch_size[0] != 0) or (W % self.patch_size[1] != 0)
+        if pad_input:
+            x = F.pad(x, (0, self.patch_size[1] - W % self.patch_size[1],
+                          0, self.patch_size[0] - H % self.patch_size[0],
+                          0, 0))
+        x = x.reshape(B, H, W, -1).permute(0, 3, 1, 2)
+        x = self.proj(x)
+        _, _, H, W = x.shape
+        x = x.flatten(2).transpose(1, 2)
+        x = self.norm(x)
+        return x
+
+
+class PatchEmbed(nn.Module):
+    def __init__(self, patch_size=4, in_c=3, embed_dim=96, norm_layer=None):
+        super().__init__()
+        patch_size = (patch_size, patch_size)
+        self.patch_size = patch_size
+        self.in_chans = in_c
+        self.embed_dim = embed_dim
+        self.proj = nn.Conv2d(in_c, embed_dim, kernel_size=patch_size, stride=patch_size)
+        self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()
+
+    def forward(self, x):
+        _, _, H, W = x.shape
+
+        # padding
+        # 如果输入图片的H，W不是patch_size的整数倍，需要进行padding
+        pad_input = (H % self.patch_size[0] != 0) or (W % self.patch_size[1] != 0)
+        if pad_input:
+            x = F.pad(x, (0, self.patch_size[1] - W % self.patch_size[1],
+                          0, self.patch_size[0] - H % self.patch_size[0],
+                          0, 0))
+
+        # 下采样patch_size倍
+        x = self.proj(x)
+        _, _, H, W = x.shape
+        x = x.flatten(2).transpose(1, 2)
+        x = self.norm(x)
+        return x, H, W
+
+
+class PatchMerging(nn.Module):
+
+    def __init__(self, dim, norm_layer=nn.LayerNorm):
+        super().__init__()
+        self.dim = dim
+        self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
+        self.norm = norm_layer(4 * dim)
+
+    def forward(self, x, H, W):
+        B, L, C = x.shape
+        assert L == H * W, "input feature has wrong size"
+
+        x = x.view(B, H, W, C)
+
+        pad_input = (H % 2 == 1) or (W % 2 == 1)
+        if pad_input:
+            x = F.pad(x, (0, 0, 0, W % 2, 0, H % 2))
+
+        x0 = x[:, 0::2, 0::2, :]  # [B, H/2, W/2, C]
+        x1 = x[:, 1::2, 0::2, :]  # [B, H/2, W/2, C]
+        x2 = x[:, 0::2, 1::2, :]  # [B, H/2, W/2, C]
+        x3 = x[:, 1::2, 1::2, :]  # [B, H/2, W/2, C]
+        x = torch.cat([x0, x1, x2, x3], -1)  # [B, H/2, W/2, 4*C]
+        x = x.view(B, -1, 4 * C)  # [B, H/2*W/2, 4*C]
+
+        x = self.norm(x)
+        x = self.reduction(x)  # [B, H/2*W/2, 2*C]
+
+        return x
+
+
+class Mlp(nn.Module):
+
+    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
+        super().__init__()
+        out_features = out_features or in_features
+        hidden_features = hidden_features or in_features
+
+        self.fc1 = nn.Linear(in_features, hidden_features)
+        self.act = act_layer()
+        self.drop1 = nn.Dropout(drop)
+        self.fc2 = nn.Linear(hidden_features, out_features)
+        self.drop2 = nn.Dropout(drop)
+
+    def forward(self, x):
+        x = self.fc1(x)
+        x = self.act(x)
+        x = self.drop1(x)
+        x = self.fc2(x)
+        x = self.drop2(x)
+        return x
+
+
+class WindowAttention(nn.Module):
+
+    def __init__(self, dim, window_size, num_heads, qkv_bias=True, attn_drop=0., proj_drop=0.):
+
+        super().__init__()
+        self.dim = dim
+        self.window_size = window_size  # [Mh, Mw]
+        self.num_heads = num_heads
+        head_dim = dim // num_heads
+        self.scale = head_dim ** -0.5
+
+        # define a parameter table of relative position bias
+        self.relative_position_bias_table = nn.Parameter(
+            torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads))  # [2*Mh-1 * 2*Mw-1, nH]
+
+        # get pair-wise relative position index for each token inside the window
+        coords_h = torch.arange(self.window_size[0])
+        coords_w = torch.arange(self.window_size[1])
+        coords = torch.stack(torch.meshgrid([coords_h, coords_w]))
+        coords_flatten = torch.flatten(coords, 1)  # [2, Mh*Mw]
+        # [2, Mh*Mw, 1] - [2, 1, Mh*Mw]
+        relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]  # [2, Mh*Mw, Mh*Mw]
+        relative_coords = relative_coords.permute(1, 2, 0).contiguous()  # [Mh*Mw, Mh*Mw, 2]
+        relative_coords[:, :, 0] += self.window_size[0] - 1  # shift to start from 0
+        relative_coords[:, :, 1] += self.window_size[1] - 1
+        relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
+        relative_position_index = relative_coords.sum(-1)  # [Mh*Mw, Mh*Mw]
+        self.register_buffer("relative_position_index", relative_position_index)
+
+        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
+        self.attn_drop = nn.Dropout(attn_drop)
+        self.proj = nn.Linear(dim, dim)
+        self.proj_drop = nn.Dropout(proj_drop)
+
+        nn.init.trunc_normal_(self.relative_position_bias_table, std=.02)
+        self.softmax = nn.Softmax(dim=-1)
+
+    def forward(self, x, mask: Optional[torch.Tensor] = None):
+        B_, N, C = x.shape
+        qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
+        # [batch_size*num_windows, num_heads, Mh*Mw, embed_dim_per_head]
+        q, k, v = qkv.unbind(0)  # make torchscript happy (cannot use tensor as tuple)
+
+        # transpose: -> [batch_size*num_windows, num_heads, embed_dim_per_head, Mh*Mw]
+        # @: multiply -> [batch_size*num_windows, num_heads, Mh*Mw, Mh*Mw]
+        q = q * self.scale
+        attn = (q @ k.transpose(-2, -1))
+
+        relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
+            self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)
+        relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  # [nH, Mh*Mw, Mh*Mw]
+        attn = attn + relative_position_bias.unsqueeze(0)
+
+        if mask is not None:
+            nW = mask.shape[0]  # num_windows
+            attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
+            attn = attn.view(-1, self.num_heads, N, N)
+            attn = self.softmax(attn)
+        else:
+            attn = self.softmax(attn)
+
+        attn = self.attn_drop(attn)
+
+        x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
+        x = self.proj(x)
+        x = self.proj_drop(x)
+        return x
+
+
+class TransformerBlock(nn.Module):
+    def __init__(self, dim, num_heads, window_sizes=(7,4,2), branch_num=3,
+                 mlp_ratio=4., qkv_bias=True, drop=0., attn_drop=0., drop_path=0.,
+                 act_layer=nn.GELU, norm_layer=nn.LayerNorm):
+        super().__init__()
+        self.dim = dim
+        self.num_heads = num_heads
+        self.window_sizes = window_sizes
+        self.branch_num = branch_num
+        self.mlp_ratio = mlp_ratio
+
+        self.norm1 = norm_layer(dim)
+        self.attn = WindowAttention(
+            dim//branch_num, window_size=(self.window_sizes[0], self.window_sizes[0]), num_heads=num_heads//branch_num, qkv_bias=qkv_bias,
+            attn_drop=attn_drop, proj_drop=drop)
+        self.attn1 = WindowAttention(
+            dim//branch_num, window_size=(self.window_sizes[1], self.window_sizes[1]), num_heads=num_heads//branch_num, qkv_bias=qkv_bias,
+            attn_drop=attn_drop, proj_drop=drop)
+        self.attn2 = WindowAttention(
+            dim//branch_num, window_size=(self.window_sizes[2], self.window_sizes[2]), num_heads=num_heads//branch_num, qkv_bias=qkv_bias,
+            attn_drop=attn_drop, proj_drop=drop)
+
+        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
+        self.norm2 = norm_layer(dim)
+        mlp_hidden_dim = int(dim * mlp_ratio)
+        self.mlp = IRB(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
+
+    def forward(self, x, attn_mask):
+        H, W = self.H, self.W
+        B, L, C = x.shape
+        assert L == H * W, "input feature has wrong size"
+
+        shortcut = x
+        x = self.norm1(x)
+        x = x.view(B, H, W, C)
+        x0 = x[:,:,:,:(C//self.branch_num)]
+        x1 = x[:,:,:,(C//self.branch_num):(2*C//self.branch_num)]
+        x2 = x[:,:,:,(2*C//self.branch_num):]
+        # ----------------------------------------------------------------------------------------------
+        pad_l = pad_t = 0
+        pad_r = (self.window_sizes[0] - W % self.window_sizes[0]) % self.window_sizes[0]
+        pad_b = (self.window_sizes[0] - H % self.window_sizes[0]) % self.window_sizes[0]
+        x0 = F.pad(x0, (0, 0, pad_l, pad_r, pad_t, pad_b))
+        _, Hp, Wp, _ = x0.shape
+        attn_mask = None
+
+        # partition windows
+        x_windows = window_partition(x0, self.window_sizes[0])  # [nW*B, Mh, Mw, C]
+        x_windows = x_windows.view(-1, self.window_sizes[0] * self.window_sizes[0], C//self.branch_num)  # [nW*B, Mh*Mw, C]
+
+        # W-MSA/SW-MSA
+        attn_windows = self.attn(x_windows, mask=attn_mask)  # [nW*B, Mh*Mw, C]
+
+        # merge windows
+        attn_windows = attn_windows.view(-1, self.window_sizes[0], self.window_sizes[0], C//self.branch_num)  # [nW*B, Mh, Mw, C]
+        x0 = window_reverse(attn_windows, self.window_sizes[0], Hp, Wp)  # [B, H', W', C]
+
+        if pad_r > 0 or pad_b > 0:
+            # 把前面pad的数据移除掉
+            x0 = x0[:, :H, :W, :].contiguous()
+
+        x0 = x0.view(B, H * W, C//self.branch_num)
+        # ----------------------------------------------------------------------------------------------
+        pad_l = pad_t = 0
+        pad_r = (self.window_sizes[1] - W % self.window_sizes[1]) % self.window_sizes[1]
+        pad_b = (self.window_sizes[1] - H % self.window_sizes[1]) % self.window_sizes[1]
+        x1 = F.pad(x1, (0, 0, pad_l, pad_r, pad_t, pad_b))
+        _, Hp, Wp, _ = x1.shape
+        attn_mask = None
+
+        # partition windows
+        x_windows = window_partition(x1, self.window_sizes[1])  # [nW*B, Mh, Mw, C]
+        x_windows = x_windows.view(-1, self.window_sizes[1] * self.window_sizes[1],
+                                   C // self.branch_num)  # [nW*B, Mh*Mw, C]
+
+        # W-MSA/SW-MSA
+        attn_windows = self.attn1(x_windows, mask=attn_mask)  # [nW*B, Mh*Mw, C]
+
+        # merge windows
+        attn_windows = attn_windows.view(-1, self.window_sizes[1], self.window_sizes[1],
+                                         C // self.branch_num)  # [nW*B, Mh, Mw, C]
+        x1 = window_reverse(attn_windows, self.window_sizes[1], Hp, Wp)  # [B, H', W', C]
+
+        if pad_r > 0 or pad_b > 0:
+            # 把前面pad的数据移除掉
+            x1 = x1[:, :H, :W, :].contiguous()
+        x1 = x1.view(B, H * W, C // self.branch_num)
+        # ----------------------------------------------------------------------------------------------
+        pad_l = pad_t = 0
+        pad_r = (self.window_sizes[2] - W % self.window_sizes[2]) % self.window_sizes[2]
+        pad_b = (self.window_sizes[2] - H % self.window_sizes[2]) % self.window_sizes[2]
+        x2 = F.pad(x2, (0, 0, pad_l, pad_r, pad_t, pad_b))
+        _, Hp, Wp, _ = x2.shape
+        attn_mask = None
+        x_windows = window_partition(x2, self.window_sizes[2])  # [nW*B, Mh, Mw, C]
+        x_windows = x_windows.view(-1, self.window_sizes[2] * self.window_sizes[2],
+                                   C // self.branch_num)  # [nW*B, Mh*Mw, C]
+
+        attn_windows = self.attn2(x_windows, mask=attn_mask)  # [nW*B, Mh*Mw, C]
+
+        attn_windows = attn_windows.view(-1, self.window_sizes[2], self.window_sizes[2],
+                                         C // self.branch_num)  # [nW*B, Mh, Mw, C]
+        x2 = window_reverse(attn_windows, self.window_sizes[2], Hp, Wp)  # [B, H', W', C]
+
+        if pad_r > 0 or pad_b > 0:
+            x2 = x2[:, :H, :W, :].contiguous()
+
+        x2 = x2.view(B, H * W, C // self.branch_num)
+
+        x = torch.cat([x0, x1, x2], -1)
+        # FFN
+        x = shortcut + self.drop_path(x)
+        x = x + self.drop_path(self.mlp(self.norm2(x), H, W))
+
+        return x
+
+
+class BasicLayer(nn.Module):
+    def __init__(self, dim, depth, num_heads, window_size,
+                 mlp_ratio=4., qkv_bias=True, drop=0., attn_drop=0.,
+                 drop_path=0., norm_layer=nn.LayerNorm, downsample=None, use_checkpoint=False):
+        super().__init__()
+        self.dim = dim
+        self.depth = depth
+        self.window_size = window_size
+        self.use_checkpoint = use_checkpoint
+        self.shift_size = window_size // 2
+
+        # build blocks
+        self.blocks = nn.ModuleList([
+            TransformerBlock(
+                dim=dim,
+                num_heads=num_heads,
+                window_sizes=(7,4,2),
+                mlp_ratio=mlp_ratio,
+                qkv_bias=qkv_bias,
+                drop=drop,
+                attn_drop=attn_drop,
+                drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
+                norm_layer=norm_layer)
+            for i in range(depth)])
+
+        # patch merging layer
+        if downsample is not None:
+            self.downsample = downsample(dim=dim, norm_layer=norm_layer)
+        else:
+            self.downsample = None
+
+    def create_mask(self, x, H, W):
+        Hp = int(np.ceil(H / self.window_size)) * self.window_size
+        Wp = int(np.ceil(W / self.window_size)) * self.window_size
+        img_mask = torch.zeros((1, Hp, Wp, 1), device=x.device)  # [1, Hp, Wp, 1]
+        h_slices = (slice(0, -self.window_size),
+                    slice(-self.window_size, -self.shift_size),
+                    slice(-self.shift_size, None))
+        w_slices = (slice(0, -self.window_size),
+                    slice(-self.window_size, -self.shift_size),
+                    slice(-self.shift_size, None))
+        cnt = 0
+        for h in h_slices:
+            for w in w_slices:
+                img_mask[:, h, w, :] = cnt
+                cnt += 1
+
+        mask_windows = window_partition(img_mask, self.window_size)  # [nW, Mh, Mw, 1]
+        mask_windows = mask_windows.view(-1, self.window_size * self.window_size)  # [nW, Mh*Mw]
+        attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)  # [nW, 1, Mh*Mw] - [nW, Mh*Mw, 1]
+        attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
+        return attn_mask
+
+    def forward(self, x, H, W):
+        attn_mask = self.create_mask(x, H, W)  # [nW, Mh*Mw, Mh*Mw]
+        for blk in self.blocks:
+            blk.H, blk.W = H, W
+            if not torch.jit.is_scripting() and self.use_checkpoint:
+                x = checkpoint.checkpoint(blk, x, attn_mask)
+            else:
+                x = blk(x, attn_mask)
+        if self.downsample is not None:
+            x = self.downsample(x, H, W)
+            H, W = (H + 1) // 2, (W + 1) // 2
+
+        return x, H, W
+
+
+class Transformer(nn.Module):
+    def __init__(self, patch_size=4, in_chans=3, num_classes=1000,
+                 embed_dim=96, depths=(2, 2, 6, 2), num_heads=(3, 6, 12, 24),
+                 window_size=7, mlp_ratio=4., qkv_bias=True,
+                 drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1,
+                 norm_layer=nn.LayerNorm, patch_norm=True,
+                 use_checkpoint=False, **kwargs):
+        super().__init__()
+
+        self.num_classes = num_classes
+        self.num_layers = len(depths)
+        self.embed_dim = embed_dim
+        self.patch_norm = patch_norm
+        # stage4输出特征矩阵的channels
+        self.num_features = int(embed_dim * 2 ** (self.num_layers - 1))
+        self.mlp_ratio = mlp_ratio
+
+        self.patch_embed = PatchEmbed(
+            patch_size=patch_size, in_c=in_chans, embed_dim=embed_dim,
+            norm_layer=norm_layer if self.patch_norm else None)
+        self.pos_drop = nn.Dropout(p=drop_rate)
+
+        # stochastic depth
+        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]  # stochastic depth decay rule
+
+        self.layers = nn.ModuleList()
+        for i_layer in range(self.num_layers):
+            layers = BasicLayer(dim=int(embed_dim * 2 ** i_layer),
+                                depth=depths[i_layer],
+                                num_heads=num_heads[i_layer],
+                                window_size=window_size,
+                                mlp_ratio=self.mlp_ratio,
+                                qkv_bias=qkv_bias,
+                                drop=drop_rate,
+                                attn_drop=attn_drop_rate,
+                                drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],
+                                norm_layer=norm_layer,
+                                downsample=PatchEmbed2 if (i_layer < self.num_layers - 1) else None,
+                                use_checkpoint=use_checkpoint)
+            self.layers.append(layers)
+
+        self.norm = norm_layer(self.num_features)
+        self.avgpool = nn.AdaptiveAvgPool1d(1)
+        self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()
+
+        self.apply(self._init_weights)
+
+    def _init_weights(self, m):
+        if isinstance(m, nn.Linear):
+            nn.init.trunc_normal_(m.weight, std=.02)
+            if isinstance(m, nn.Linear) and m.bias is not None:
+                nn.init.constant_(m.bias, 0)
+        elif isinstance(m, nn.LayerNorm):
+            nn.init.constant_(m.bias, 0)
+            nn.init.constant_(m.weight, 1.0)
+
+    def forward(self, x):
+        # x: [B, L, C]
+        x, H, W = self.patch_embed(x)
+        x = self.pos_drop(x)
+
+        for layer in self.layers:
+            x, H, W = layer(x, H, W)
+
+        x = self.norm(x)  # [B, L, C]
+        x = self.avgpool(x.transpose(1, 2))  # [B, C, 1]
+        x = torch.flatten(x, 1)
+        x = self.head(x)
+        return x
+
+
+def MWT(num_classes: int = 1000, **kwargs):
+    model = Transformer(in_chans=3,
+                        patch_size=4,
+                        # window_sizes=(7,4,2),
+                        embed_dim=96,
+                        depths=(2, 4, 4, 2),
+                        num_heads=(3, 6, 12, 24),
+                        num_classes=num_classes,
+                        **kwargs)
+    return model
+
+if __name__ == '__main__':
+    model = MWT(num_classes=2)
+    input = torch.randn(1, 3, 224, 224)
+    flops, params = profile(model, inputs=(input,))
+    print(flops)
+    print(params)
+

backend/model_histo.py

@@ -0,0 +1,1495 @@
+"""
+Breast Cancer Histopathology Classification using Path Foundation Model
+
+This module implements a comprehensive deep learning pipeline for breast cancer classification 
+from histopathology images using Google's Path Foundation model as a feature extractor. The 
+system supports multiple datasets including BreakHis, PatchCamelyon (PCam), and BACH, employing 
+transfer learning to achieve high classification accuracy.
+
+**Overview:**
+This system leverages Google's Path Foundation model, which is pre-trained on a large corpus 
+of pathology images, to extract meaningful features from breast cancer histopathology images. 
+The approach uses transfer learning where the foundation model serves as a frozen feature 
+extractor, followed by a trainable classification head for binary classification (benign vs malignant).
+
+**Model Architecture:**
+- Foundation Model: Google's Path Foundation (pre-trained on pathology images)
+- Transfer Learning Approach: Feature extraction with frozen foundation model + trainable classifier head
+- Classification Head: Multi-layer dense network with regularisation and dropout
+- Optimisation: AdamW optimiser with learning rate scheduling and early stopping
+
+**Workflow:**
+1. Authentication & Model Loading: Authenticate with Hugging Face and load Path Foundation
+2. Data Loading: Load and preprocess histopathology datasets
+3. Feature Extraction: Extract embeddings using frozen foundation model
+4. Classifier Training: Train dense neural network on extracted features
+5. Evaluation: Comprehensive performance analysis with multiple metrics and visualisations
+
+**Supported Datasets:**
+- BreakHis: Breast cancer histopathology images at multiple magnifications
+- PatchCamelyon (PCam): Lymph node metastasis detection patches
+- BACH: ICIAR 2018 Breast Cancer Histology Challenge dataset
+- Combined: Ensemble of all three datasets for robust training
+
+**Key Features:**
+- Multiple dataset support with consistent pre-processing
+- Robust error handling and fallback mechanisms
+- Comprehensive evaluation metrics and visualisation
+- Memory-efficient batch processing
+- Data augmentation capabilities
+- Model persistence and deployment support
+
+Author: Research Team
+Date: 2024
+License: MIT
+"""
+
+# Import required libraries and configure environment
+import os
+import tensorflow as tf
+import numpy as np
+from PIL import Image
+from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, precision_score, recall_score, f1_score
+from pathlib import Path
+import h5py
+from sklearn.model_selection import train_test_split
+from sklearn.utils.class_weight import compute_class_weight
+from tensorflow.keras import regularizers
+import matplotlib
+# Use a non-interactive backend to prevent blocking on plt.show()
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# Suppress TensorFlow logging for cleaner output
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+
+# Configure TensorFlow logging for cleaner output
+try:
+    tf.get_logger().setLevel('ERROR')
+except AttributeError:
+    import logging
+    logging.getLogger('tensorflow').setLevel(logging.ERROR)
+
+# Configure Hugging Face Hub integration with fallback mechanisms
+# This section handles the loading of Google's Path Foundation model from Hugging Face Hub
+# with multiple fallback methods to ensure compatibility across different environments
+try:
+    from huggingface_hub import login, hf_hub_download, snapshot_download
+    
+    # Try different methods for loading Keras models from HF Hub
+    # Method 1: Direct Keras loading (preferred)
+    try:
+        from huggingface_hub import from_pretrained_keras
+        KERAS_METHOD = "from_pretrained_keras"
+    except ImportError:
+        # Method 2: Transformers library fallback
+        try:
+            from transformers import TFAutoModel
+            KERAS_METHOD = "transformers"
+        except ImportError:
+            # Method 3: Manual download and TFSMLayer
+            KERAS_METHOD = "manual"
+    
+    HF_AVAILABLE = True
+    print(f"Hugging Face Hub loaded successfully (method: {KERAS_METHOD})")
+except ImportError as e:
+    print(f"Hugging Face Hub unavailable: {e}")
+    print("Please install required packages: pip install huggingface_hub transformers")
+    HF_AVAILABLE = False
+    KERAS_METHOD = None
+
+class BreastCancerClassifier:
+    """
+    A comprehensive breast cancer classification system using Path Foundation model.
+    
+    This class implements a transfer learning approach where Google's Path Foundation
+    model serves as a feature extractor, followed by a trainable classification head.
+    The system supports both feature extraction (frozen foundation model) and 
+    fine-tuning approaches for maximum flexibility.
+    
+    The classifier can work with multiple histopathology datasets and provides
+    comprehensive evaluation capabilities including confusion matrices, classification
+    reports, and performance metrics.
+    
+    Attributes:
+        fine_tune (bool): Whether to fine-tune the foundation model or use it frozen
+        model (tf.keras.Model): The complete classification model
+        path_foundation: The loaded Path Foundation model from Hugging Face Hub
+        history: Training history from model.fit() containing loss and accuracy curves
+        embedding_dim (int): Dimensionality of extracted embeddings from foundation model
+        num_classes (int): Number of output classes (default: 2 for binary classification)
+        
+    Example:
+        >>> classifier = BreastCancerClassifier(fine_tune=False)
+        >>> classifier.authenticate_huggingface()
+        >>> classifier.load_path_foundation()
+        >>> # Load data and train...
+    """
+    
+    def __init__(self, fine_tune=False):
+        """
+        Initialise the breast cancer classifier.
+        
+        Args:
+            fine_tune (bool): If True, allows fine-tuning of foundation model.
+                             If False, uses foundation model as frozen feature extractor.
+                             
+                             Note: Fine-tuning requires more computational resources and
+                             may lead to overfitting on smaller datasets. Feature extraction
+                             (fine_tune=False) is recommended for most use-cases.
+        """
+        self.fine_tune = fine_tune
+        self.model = None
+        self.path_foundation = None
+        self.history = None
+        self.embedding_dim = None
+        self.num_classes = 2  # Binary classification: benign vs malignant
+        
+    def authenticate_huggingface(self, token=None):
+        """
+        Authenticate with Hugging Face Hub to access Path Foundation model.
+        
+        This method handles authentication with Hugging Face Hub, which is required
+        to download and use Google's Path Foundation model. It supports multiple
+        token sources and provides fallback mechanisms.
+        
+        Args:
+            token (str, optional): Hugging Face access token. If None, the method
+                                 will attempt to use environment variables:
+                                 - HF_TOKEN
+                                 - HUGGINGFACE_HUB_TOKEN
+                                 
+        Returns:
+            bool: True if authentication successful, False otherwise
+            
+        Note:
+            You can obtain a Hugging Face token by:
+            1. Creating an account at https://huggingface.co
+            2. Going to Settings > Access Tokens
+            3. Creating a new token with read permissions
+            
+        Example:
+            >>> classifier = BreastCancerClassifier()
+            >>> success = classifier.authenticate_huggingface("hf_xxxxxxxxxxxx")
+            >>> if success:
+            ...     print("Authentication successful")
+        """
+        if not HF_AVAILABLE:
+            print("Cannot authenticate - Hugging Face Hub not available")
+            return False
+            
+        try:
+            # Try multiple token sources: parameter, environment variables
+            final_token = token or os.environ.get("HF_TOKEN") or os.environ.get("HUGGINGFACE_HUB_TOKEN")
+            
+            if final_token:
+                login(token=final_token, add_to_git_credential=False)
+                print("Hugging Face authentication successful")
+                return True
+            else:
+                print("No token provided, attempting to use cached login")
+                return True
+        except Exception as e:
+            print(f"Authentication failed: {e}")
+            return False
+            
+    def load_path_foundation(self):
+        """
+        Load Google's Path Foundation model with multiple fallback mechanisms.
+        
+        This method attempts to load the Path Foundation model using three different
+        approaches to ensure maximum compatibility across different environments:
+        
+        1. Direct Keras loading via huggingface_hub (preferred)
+        2. Transformers library loading (fallback)
+        3. Manual download and TFSMLayer loading (last resort)
+        
+        The method also configures the model's training behavior based on the
+        fine_tune parameter set during initialization.
+        
+        Returns:
+            bool: True if model loaded successfully, False otherwise
+            
+        Raises:
+            Various exceptions may be raised during the loading process, but they
+            are caught and handled gracefully with informative error messages.
+            
+        Note:
+            The Path Foundation model is a large pre-trained model (~1GB) that will
+            be downloaded on first use. Subsequent runs will use the cached version.
+            
+        Example:
+            >>> classifier = BreastCancerClassifier(fine_tune=False)
+            >>> if classifier.load_path_foundation():
+            ...     print("Model loaded successfully")
+            ... else:
+            ...     print("Failed to load model")
+        """
+        if not HF_AVAILABLE:
+            print("Cannot load model - Hugging Face Hub unavailable")
+            return False
+            
+        try:
+            print("Loading Path Foundation model...")
+            loaded = False
+            
+            # Method 1: Direct Keras loading (preferred method)
+            if KERAS_METHOD == "from_pretrained_keras":
+                try:
+                    self.path_foundation = from_pretrained_keras("google/path-foundation")
+                    loaded = True
+                    print("Successfully loaded via from_pretrained_keras")
+                except Exception as e:
+                    print(f"Keras loading failed: {e}")
+            
+            # Method 2: Transformers library fallback
+            if not loaded and KERAS_METHOD == "transformers":
+                try:
+                    print("Attempting transformers fallback...")
+                    self.path_foundation = TFAutoModel.from_pretrained("google/path-foundation")
+                    loaded = True
+                    print("Successfully loaded via transformers")
+                except Exception as e:
+                    print(f"Transformers loading failed: {e}")
+            
+            # Method 3: Manual download and TFSMLayer (last resort)
+            if not loaded:
+                try:
+                    try:
+                        import keras as _standalone_keras
+                    except ImportError as _e:
+                        print(f"Keras 3 not installed: {_e}")
+                        return False
+                    
+                    print("Attempting manual download and TFSMLayer loading...")
+                    local_dir = snapshot_download(repo_id="google/path-foundation")
+                    self.path_foundation = _standalone_keras.layers.TFSMLayer(
+                        local_dir, call_endpoint="serving_default"
+                    )
+                    loaded = True
+                    print("Successfully loaded via TFSMLayer")
+                except Exception as e:
+                    print(f"TFSMLayer loading failed: {e}")
+                    return False
+            
+            # Configure training behavior based on fine_tune setting
+            if self.fine_tune:
+                self.path_foundation.trainable = True
+                try:
+                    # Only fine-tune the last 3 layers for stability
+                    for layer in self.path_foundation.layers[:-3]:
+                        layer.trainable = False
+                    print("Fine-tuning enabled: last 3 layers trainable")
+                except:
+                    print("Fine-tuning enabled: full model trainable")
+            else:
+                self.path_foundation.trainable = False
+                print("Model frozen for feature extraction")
+                
+            return True
+            
+        except Exception as e:
+            print(f"Failed to load Path Foundation model: {e}")
+            return False
+    
+    def preprocess_image_batch(self, images):
+        """
+        Pre-process a batch of images for Path Foundation model input.
+        
+        This method handles multiple input formats and ensures all images are properly
+        formatted for the Path Foundation model. It performs the following operations:
+        - Resizes all images to 224x224 pixels (required by Path Foundation)
+        - Converts images to RGB format
+        - Normalises pixel values to [0, 1] range
+        - Handles both file paths and numpy arrays
+        
+        Args:
+            images: List or array of images in various formats:
+                   - File paths (strings) pointing to image files
+                   - PIL Images
+                   - NumPy arrays (various shapes and value ranges)
+                   
+        Returns:
+            np.ndarray: Preprocessed batch of shape (batch_size, 224, 224, 3)
+                       with pixel values normalized to [0, 1] range
+                       
+        Note:
+            The method automatically handles different input formats and value ranges.
+            Images are resized using PIL's resize method with default interpolation.
+            
+        Example:
+            >>> # Process file paths
+            >>> image_paths = ['image1.jpg', 'image2.png']
+            >>> processed = classifier.preprocess_image_batch(image_paths)
+            >>> print(processed.shape)  # (2, 224, 224, 3)
+            
+            >>> # Process numpy arrays
+            >>> image_arrays = [np.random.rand(100, 100, 3) for _ in range(5)]
+            >>> processed = classifier.preprocess_image_batch(image_arrays)
+            >>> print(processed.shape)  # (5, 224, 224, 3)
+        """
+        processed = []
+        
+        for img in images:
+            if isinstance(img, str):
+                # Handle file paths
+                img = Image.open(img).convert('RGB')
+                img = img.resize((224, 224))
+                img_array = np.array(img) / 255.0
+            else:
+                # Handle numpy arrays
+                if img.shape[:2] != (224, 224):
+                    # Resize if necessary
+                    if img.max() <= 1:
+                        img_pil = Image.fromarray((img * 255).astype('uint8'))
+                    else:
+                        img_pil = Image.fromarray(img.astype('uint8'))
+                    img_pil = img_pil.resize((224, 224))
+                    img_array = np.array(img_pil) / 255.0
+                else:
+                    img_array = img.astype('float32')
+                    if img_array.max() > 1:
+                        img_array = img_array / 255.0
+                        
+            processed.append(img_array)
+            
+        return np.array(processed)
+    
+    def extract_embeddings(self, images, batch_size=16):
+        """
+        Extract feature embeddings from images using Path Foundation model.
+        
+        This method processes images in batches to extract high-level feature representations
+        using the pre-trained Path Foundation model. The embeddings capture semantic information
+        about the histopathology images that can be used for classification.
+        
+        The method handles different model interface types and provides progress tracking
+        for large datasets. It automatically determines the embedding dimension on first use.
+        
+        Args:
+            images: Array of preprocessed images or list of image paths
+            batch_size (int): Number of images to process per batch. Smaller batches
+                             use less memory but may be slower. Default: 16
+                             
+        Returns:
+            np.ndarray: Extracted embeddings of shape (num_images, embedding_dim)
+                       where embedding_dim is determined by the Path Foundation model
+                       
+        Raises:
+            ValueError: If no embeddings are successfully extracted
+            RuntimeError: If the Path Foundation model is not loaded
+            
+        Note:
+            The embedding dimension is automatically determined from the first successful
+            batch and stored in self.embedding_dim for use in classifier construction.
+            
+        Example:
+            >>> # Extract embeddings from a dataset
+            >>> embeddings = classifier.extract_embeddings(images, batch_size=32)
+            >>> print(f"Extracted {embeddings.shape[0]} embeddings of dimension {embeddings.shape[1]}")
+            
+            >>> # Process with smaller batch size for memory-constrained environments
+            >>> embeddings = classifier.extract_embeddings(images, batch_size=8)
+        """
+        print(f"Extracting embeddings from {len(images)} images...")
+        
+        embeddings = []
+        num_batches = (len(images) + batch_size - 1) // batch_size
+        
+        for i in range(0, len(images), batch_size):
+            batch = images[i:i + batch_size]
+            processed_batch = self.preprocess_image_batch(batch)
+            
+            try:
+                # Handle different model interface types
+                if hasattr(self.path_foundation, 'signatures') and "serving_default" in self.path_foundation.signatures:
+                    # TensorFlow SavedModel format
+                    infer = self.path_foundation.signatures["serving_default"]
+                    batch_embeddings = infer(tf.constant(processed_batch))
+                elif hasattr(self.path_foundation, 'predict'):
+                    # Standard Keras model
+                    batch_embeddings = self.path_foundation.predict(processed_batch, verbose=0)
+                else:
+                    # Direct callable
+                    batch_embeddings = self.path_foundation(processed_batch)
+                
+                # Handle different output formats
+                if isinstance(batch_embeddings, dict):
+                    key = list(batch_embeddings.keys())[0]
+                    if hasattr(batch_embeddings[key], 'numpy'):
+                        batch_embeddings = batch_embeddings[key].numpy()
+                    else:
+                        batch_embeddings = batch_embeddings[key]
+                elif hasattr(batch_embeddings, 'numpy'):
+                    batch_embeddings = batch_embeddings.numpy()
+                
+                embeddings.append(batch_embeddings)
+                
+                # Progress reporting
+                batch_num = i // batch_size + 1
+                if batch_num % 10 == 0:
+                    print(f"Processed batch {batch_num}/{num_batches}")
+                    
+            except Exception as e:
+                print(f"Error processing batch {batch_num}: {e}")
+                continue
+        
+        if not embeddings:
+            raise ValueError("No embeddings extracted successfully")
+            
+        final_embeddings = np.vstack(embeddings)
+        
+        # Set embedding dimension for classifier head
+        if self.embedding_dim is None:
+            self.embedding_dim = final_embeddings.shape[1]
+            print(f"Embedding dimension: {self.embedding_dim}")
+            
+        print(f"Final embeddings shape: {final_embeddings.shape}")
+        return final_embeddings
+    
+    def build_classifier(self):
+        """
+        Build the classification head architecture.
+        
+        This method constructs the neural network architecture for breast cancer classification.
+        It creates different architectures based on the fine_tune setting:
+        
+        1. End-to-end model (fine_tune=True): Input -> Path Foundation -> Classifier -> Output
+        2. Feature-based model (fine_tune=False): Embeddings -> Classifier -> Output
+        
+        The architecture includes:
+        - Progressive dimensionality reduction (768 -> 384 -> 192 -> 2)
+        - L2 regularisation for weight decay and overfitting prevention
+        - Batch normalisation for training stability and faster convergence
+        - Dropout layers for regularization
+        - AdamW optimizer with appropriate learning rates
+        
+        Returns:
+            None: The model is stored in self.model and compiled
+            
+        Raises:
+            ValueError: If embedding dimension is not set (run extract_embeddings first)
+            
+        Note:
+            The method automatically selects appropriate learning rates:
+            - Lower learning rate (1e-5) for fine-tuning to preserve pre-trained features
+            - Higher learning rate (0.001) for training from scratch on embeddings
+            
+        Architecture Details:
+            - Input: Either raw images (224x224x3) or embeddings (embedding_dim,)
+            - Hidden layers: 768 -> 384 -> 192 neurons with ReLU activation
+            - Output: 2 neurons with softmax activation (benign/malignant)
+            - Regularisation: L2 weight decay (1e-4), Dropout (0.5, 0.3, 0.2)
+            - Normalisation: Batch normalisation after each dense layer
+            
+        Example:
+            >>> classifier = BreastCancerClassifier(fine_tune=False)
+            >>> classifier.load_path_foundation()
+            >>> embeddings = classifier.extract_embeddings(images)
+            >>> classifier.build_classifier()
+            >>> print(f"Model has {classifier.model.count_params():,} parameters")
+        """
+        if self.embedding_dim is None:
+            raise ValueError("Embedding dimension not set - run extract_embeddings first")
+            
+        if self.fine_tune:
+            # End-to-end fine-tuning architecture
+            inputs = tf.keras.Input(shape=(224, 224, 3))
+            x = self.path_foundation(inputs)
+
+            # Classification head with regularization
+            x = tf.keras.layers.Dense(768, activation='relu',
+                                       kernel_regularizer=regularizers.l2(1e-4))(x)
+            x = tf.keras.layers.BatchNormalization()(x)
+            x = tf.keras.layers.Dropout(0.5)(x)
+
+            x = tf.keras.layers.Dense(384, activation='relu',
+                                       kernel_regularizer=regularizers.l2(1e-4))(x)
+            x = tf.keras.layers.BatchNormalization()(x)
+            x = tf.keras.layers.Dropout(0.3)(x)
+
+            x = tf.keras.layers.Dense(192, activation='relu',
+                                       kernel_regularizer=regularizers.l2(1e-4))(x)
+            x = tf.keras.layers.Dropout(0.2)(x)
+            
+            outputs = tf.keras.layers.Dense(self.num_classes, activation='softmax')(x)
+            self.model = tf.keras.Model(inputs, outputs)
+            
+            # Lower learning rate for fine-tuning to preserve pre-trained features
+            optimizer = tf.keras.optimizers.AdamW(learning_rate=1e-5, weight_decay=1e-5)
+            
+        else:
+            # Feature extraction architecture (recommended approach)
+            self.model = tf.keras.Sequential([
+                tf.keras.layers.Input(shape=(self.embedding_dim,)),
+                
+                # First dense block
+                tf.keras.layers.Dense(768, activation='relu',
+                                       kernel_regularizer=regularizers.l2(1e-4)),
+                tf.keras.layers.BatchNormalization(),
+                tf.keras.layers.Dropout(0.5),
+
+                # Second dense block
+                tf.keras.layers.Dense(384, activation='relu',
+                                       kernel_regularizer=regularizers.l2(1e-4)),
+                tf.keras.layers.BatchNormalization(),
+                tf.keras.layers.Dropout(0.3),
+
+                # Third dense block
+                tf.keras.layers.Dense(192, activation='relu',
+                                       kernel_regularizer=regularizers.l2(1e-4)),
+                tf.keras.layers.Dropout(0.2),
+                
+                # Output layer
+                tf.keras.layers.Dense(self.num_classes, activation='softmax')
+            ])
+            
+            # Higher learning rate for training from scratch
+            optimizer = tf.keras.optimizers.AdamW(learning_rate=0.001, weight_decay=1e-5)
+        
+        # Compile model with sparse categorical crossentropy for integer labels
+        self.model.compile(
+            optimizer=optimizer,
+            loss=tf.keras.losses.SparseCategoricalCrossentropy(),
+            metrics=['accuracy']
+        )
+        
+        print(f"Model architecture built - Fine-tuning: {self.fine_tune}")
+        print(f"Total parameters: {self.model.count_params():,}")
+    
+    def train_model(self, X_train, y_train, X_val, y_val, epochs=50):
+        """
+        Train the classification model with advanced techniques and callbacks.
+        
+        This method implements a comprehensive training pipeline with:
+        - Class balancing to handle imbalanced datasets
+        - Early stopping to prevent overfitting
+        - Learning rate reduction on plateau
+        - Model checkpointing to save best weights
+        - Adaptive batch sizing based on training mode
+        
+        Args:
+            X_train: Training features (embeddings or images)
+            y_train: Training labels (0 for benign, 1 for malignant)
+            X_val: Validation features
+            y_val: Validation labels
+            epochs (int): Maximum number of training epochs. Default: 50
+            
+        Returns:
+            tf.keras.callbacks.History: Training history containing loss and accuracy curves
+            
+        Note:
+            The method automatically handles class imbalance by computing balanced weights.
+            Training uses different batch sizes: 32 for fine-tuning, 64 for feature extraction.
+            
+        Callbacks Used:
+            - EarlyStopping: Stops training if validation accuracy doesn't improve for 10 epochs
+            - ReduceLROnPlateau: Reduces learning rate by 50% if validation loss plateaus
+            - ModelCheckpoint: Saves the best model based on validation accuracy
+            
+        Example:
+            >>> # Train the model
+            >>> history = classifier.train_model(X_train, y_train, X_val, y_val, epochs=30)
+            >>> 
+            >>> # Access training metrics
+            >>> print(f"Final training accuracy: {history.history['accuracy'][-1]:.4f}")
+            >>> print(f"Final validation accuracy: {history.history['val_accuracy'][-1]:.4f}")
+        """
+        # Compute class weights to handle imbalanced datasets
+        try:
+            classes = np.unique(y_train)
+            weights = compute_class_weight(class_weight='balanced', classes=classes, y=y_train)
+            class_weight = {int(c): float(w) for c, w in zip(classes, weights)}
+            print(f"Class weights computed: {class_weight}")
+        except Exception:
+            class_weight = None
+            print("Using uniform class weights")
+            
+        # Define training callbacks for robust training
+        callbacks = [
+            tf.keras.callbacks.EarlyStopping(
+                monitor='val_accuracy',
+                patience=10,
+                restore_best_weights=True,
+                verbose=1
+            ),
+            tf.keras.callbacks.ReduceLROnPlateau(
+                monitor='val_loss',
+                factor=0.5,
+                patience=5,
+                min_lr=1e-7,
+                verbose=1
+            ),
+            tf.keras.callbacks.ModelCheckpoint(
+                'best_model.keras',
+                monitor='val_accuracy',
+                save_best_only=True,
+                verbose=0
+            )
+        ]
+        
+        print("Starting model training...")
+        print(f"Training samples: {len(X_train)}, Validation samples: {len(X_val)}")
+        
+        # Adaptive batch sizing based on training mode
+        batch_size = 32 if self.fine_tune else 64
+        print(f"Using batch size: {batch_size}")
+        
+        # Train the model
+        self.history = self.model.fit(
+            X_train, y_train,
+            validation_data=(X_val, y_val),
+            epochs=epochs,
+            batch_size=batch_size,
+            callbacks=callbacks,
+            verbose=1,
+            class_weight=class_weight
+        )
+        
+        print("Training completed successfully!")
+        return self.history
+    
+    def evaluate_model(self, X_test, y_test):
+        """
+        Comprehensive model evaluation with multiple performance metrics and visualisations.
+        
+        This method provides a thorough evaluation of the trained model including:
+        - Accuracy, Precision, Recall, and F1-score calculations
+        - Detailed classification report with per-class metrics
+        - Confusion matrix visualisation and analysis
+        - Model predictions and probabilities for further analysis
+        
+        Args:
+            X_test: Test features (embeddings or images)
+            y_test: True test labels (0 for benign, 1 for malignant)
+            
+        Returns:
+            dict: Dictionary containing comprehensive evaluation results:
+                - 'accuracy': Overall accuracy score
+                - 'precision': Weighted average precision
+                - 'recall': Weighted average recall
+                - 'f1': Weighted average F1-score
+                - 'predictions': Predicted class labels
+                - 'probabilities': Prediction probabilities for each class
+                - 'confusion_matrix': 2x2 confusion matrix
+                
+        Note:
+            The method generates and saves a confusion matrix plot as 'confusion_matrix.png'
+            and displays it using matplotlib. The plot uses a blue color scheme for clarity.
+            
+        Metrics Explanation:
+            - Accuracy: Overall correctness of predictions
+            - Precision: True positives / (True positives + False positives)
+            - Recall: True positives / (True positives + False negatives)
+            - F1-score: Harmonic mean of precision and recall
+            
+        Example:
+            >>> # Evaluate the trained model
+            >>> results = classifier.evaluate_model(X_test, y_test)
+            >>> 
+            >>> # Access specific metrics
+            >>> print(f"Test Accuracy: {results['accuracy']:.4f}")
+            >>> print(f"F1-Score: {results['f1']:.4f}")
+            >>> 
+            >>> # Analyze predictions
+            >>> predictions = results['predictions']
+            >>> probabilities = results['probabilities']
+        """
+        print("Evaluating model performance...")
+        
+        # Generate predictions and probabilities
+        y_pred_proba = self.model.predict(X_test)
+        y_pred = np.argmax(y_pred_proba, axis=1)
+        
+        # Calculate comprehensive metrics
+        accuracy = accuracy_score(y_test, y_pred)
+        precision = precision_score(y_test, y_pred, average='weighted')
+        recall = recall_score(y_test, y_pred, average='weighted')
+        f1 = f1_score(y_test, y_pred, average='weighted')
+        
+        # Display results
+        print(f"Accuracy: {accuracy:.4f} ({accuracy*100:.2f}%)")
+        print(f"Precision: {precision:.4f}")
+        print(f"Recall: {recall:.4f}")
+        print(f"F1-Score: {f1:.4f}")
+        
+        # Detailed classification report
+        class_names = ['Benign', 'Malignant']
+        print("\nDetailed Classification Report:")
+        print(classification_report(y_test, y_pred, target_names=class_names))
+        
+        # Generate and display confusion matrix
+        cm = confusion_matrix(y_test, y_pred)
+        
+        # Create confusion matrix visualization
+        plt.figure(figsize=(8, 6))
+        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
+                   xticklabels=class_names, yticklabels=class_names)
+        plt.title('Confusion Matrix - Breast Cancer Classification')
+        plt.xlabel('Predicted Label')
+        plt.ylabel('True Label')
+        plt.tight_layout()
+        plt.savefig('confusion_matrix.png', dpi=300, bbox_inches='tight')
+        # Close the figure to free resources and avoid blocking
+        plt.close()
+        
+        # Print confusion matrix in text format
+        print("\nConfusion Matrix:")
+        print(f"                 Predicted")
+        print(f"                 {class_names[0]:>8} {class_names[1]:>8}")
+        print(f"Actual {class_names[0]:>6} {cm[0,0]:>8} {cm[0,1]:>8}")
+        print(f"       {class_names[1]:>6} {cm[1,0]:>8} {cm[1,1]:>8}")
+        
+        return {
+            'accuracy': accuracy,
+            'precision': precision,
+            'recall': recall,
+            'f1': f1,
+            'predictions': y_pred,
+            'probabilities': y_pred_proba,
+            'confusion_matrix': cm
+        }
+
+def load_breakhis_data(data_dir="datasets/breakhis/histology_slides/breast", max_samples_per_class=2000, magnification="40X"):
+    """
+    Load and preprocess the BreakHis breast cancer histopathology dataset.
+    
+    The BreakHis dataset contains microscopic images of breast tumor tissue
+    collected from clinical studies. Images are organized by:
+    - Tumor type (benign/malignant)
+    - Specific histological type (adenosis, fibroadenoma, etc.)
+    - Patient ID
+    - Magnification level (40X, 100X, 200X, 400X)
+    
+    This function loads images from the specified magnification level and
+    preprocesses them for use with the Path Foundation model.
+    
+    Args:
+        data_dir (str): Path to BreakHis dataset root directory. Default structure:
+                       datasets/breakhis/histology_slides/breast/
+        max_samples_per_class (int): Maximum images to load per class (benign/malignant).
+                                   Helps manage memory usage for large datasets.
+        magnification (str): Magnification level to use. Options: "40X", "100X", "200X", "400X".
+                           Higher magnifications provide more detail but larger file sizes.
+                           
+    Returns:
+        tuple: (images, labels) as numpy arrays
+            - images: Array of shape (num_images, 224, 224, 3) with normalized pixel values
+            - labels: Array of shape (num_images,) with 0 for benign, 1 for malignant
+            
+    Dataset Structure:
+        The function expects the following directory structure:
+        data_dir/
+        ├── benign/SOB/
+        │   ├── adenosis/
+        │   ├── fibroadenoma/
+        │   ├── phyllodes_tumor/
+        │   └── tubular_adenoma/
+        └── malignant/SOB/
+            ├── ductal_carcinoma/
+            ├── lobular_carcinoma/
+            ├── mucinous_carcinoma/
+            └── papillary_carcinoma/
+            
+    Note:
+        Images are automatically resized to 224x224 pixels and normalized to [0,1] range.
+        The function handles various image formats (PNG, JPG, JPEG, TIF, TIFF).
+        
+    Example:
+        >>> # Load BreakHis dataset with 40X magnification
+        >>> images, labels = load_breakhis_data(
+        ...     data_dir="datasets/breakhis/histology_slides/breast",
+        ...     max_samples_per_class=1000,
+        ...     magnification="40X"
+        ... )
+        >>> print(f"Loaded {len(images)} images")
+        >>> print(f"Benign: {np.sum(labels == 0)}, Malignant: {np.sum(labels == 1)}")
+    """
+    print(f"Loading BreakHis dataset (magnification: {magnification})...")
+    
+    benign_dir = os.path.join(data_dir, "benign", "SOB")
+    malignant_dir = os.path.join(data_dir, "malignant", "SOB")
+    
+    images = []
+    labels = []
+    
+    def load_images_from_category(base_dir, label, max_count):
+        """
+        Helper function to load images from a specific category (benign/malignant).
+        
+        Traverses the directory structure: base_dir/tumor_type/patient_id/magnification/images
+        and loads images with progress reporting.
+        """
+        if not os.path.exists(base_dir):
+            print(f"Warning: Directory {base_dir} not found")
+            return 0
+            
+        count = 0
+        
+        # Traverse: base_dir/tumor_type/patient_id/magnification/images
+        for tumor_type in os.listdir(base_dir):
+            tumor_dir = os.path.join(base_dir, tumor_type)
+            if not os.path.isdir(tumor_dir):
+                continue
+                
+            for patient_id in os.listdir(tumor_dir):
+                patient_dir = os.path.join(tumor_dir, patient_id)
+                if not os.path.isdir(patient_dir):
+                    continue
+                    
+                mag_dir = os.path.join(patient_dir, magnification)
+                if not os.path.exists(mag_dir):
+                    continue
+                    
+                for filename in os.listdir(mag_dir):
+                    if count >= max_count:
+                        return count
+                        
+                    if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.tif', '.tiff')):
+                        try:
+                            img_path = os.path.join(mag_dir, filename)
+                            img = Image.open(img_path).convert('RGB')
+                            img = img.resize((224, 224))
+                            img_array = np.array(img).astype('float32') / 255.0
+                            images.append(img_array)
+                            labels.append(label)
+                            count += 1
+                            
+                            if count % 100 == 0:
+                                category = 'benign' if label == 0 else 'malignant'
+                                print(f"Loaded {count} {category} images")
+                                
+                        except Exception as e:
+                            print(f"Error loading {filename}: {e}")
+                            continue
+        return count
+
+    # Load both categories
+    benign_count = load_images_from_category(benign_dir, 0, max_samples_per_class)
+    malignant_count = load_images_from_category(malignant_dir, 1, max_samples_per_class)
+    
+    print(f"BreakHis dataset loaded: {benign_count} benign, {malignant_count} malignant images")
+    
+    return np.array(images), np.array(labels)
+
+def load_pcam_data(data_dir="datasets/pcam", label_dir="datasets/Labels", max_samples=3000, augment=True):
+    """
+    Load and preprocess the PatchCamelyon (PCam) dataset.
+    
+    PCam contains 96x96 pixel patches extracted from histopathologic scans
+    of lymph node sections. Each patch is labeled with the presence of
+    metastatic tissue. This function includes data augmentation capabilities
+    to improve model generalization.
+    
+    The dataset is stored in HDF5 format with separate files for images and labels,
+    and comes pre-split into training, validation, and test sets.
+    
+    Args:
+        data_dir (str): Path to PCam image data directory containing:
+                       - training_split.h5
+                       - validation_split.h5
+                       - test_split.h5
+        label_dir (str): Path to PCam label files directory containing:
+                        - camelyonpatch_level_2_split_train_y.h5
+                        - camelyonpatch_level_2_split_valid_y.h5
+                        - camelyonpatch_level_2_split_test_y.h5
+        max_samples (int): Maximum total samples to load across all splits.
+                          Distributed as: train=50%, val=25%, test=25%
+        augment (bool): Whether to apply data augmentation to training set.
+                       Augmentation includes: horizontal flip, rotation, brightness adjustment
+                       
+    Returns:
+        dict: Dictionary with 'train', 'valid', 'test' keys containing (images, labels) tuples
+            - 'train': (train_images, train_labels) - Training data with optional augmentation
+            - 'valid': (val_images, val_labels) - Validation data
+            - 'test': (test_images, test_labels) - Test data
+            
+    Dataset Details:
+        - Original patch size: 96x96 pixels
+        - Resized to: 224x224 pixels for Path Foundation compatibility
+        - Labels: 0 (normal tissue), 1 (metastatic tissue)
+        - Format: HDF5 files with 'x' key for images, 'y' key for labels
+        
+    Data Augmentation (if enabled):
+        - Horizontal flip: 50% probability
+        - Rotation: Random 0°, 90°, 180°, or 270° rotation
+        - Brightness adjustment: 30% probability, factor between 0.9-1.1
+        
+    Note:
+        The function automatically handles HDF5 file loading and memory management.
+        Images are resized from 96x96 to 224x224 pixels and normalized to [0,1] range.
+        
+    Example:
+        >>> # Load PCam dataset with augmentation
+        >>> pcam_data = load_pcam_data(
+        ...     data_dir="datasets/pcam",
+        ...     label_dir="datasets/Labels",
+        ...     max_samples=2000,
+        ...     augment=True
+        ... )
+        >>> 
+        >>> # Access training data
+        >>> train_images, train_labels = pcam_data['train']
+        >>> print(f"Training samples: {len(train_images)}")
+        >>> print(f"Image shape: {train_images[0].shape}")
+    """
+    print("Loading PatchCamelyon (PCam) dataset...")
+    
+    # Define file paths
+    train_file = os.path.join(data_dir, "training_split.h5")
+    val_file = os.path.join(data_dir, "validation_split.h5")
+    test_file = os.path.join(data_dir, "test_split.h5")
+    train_label_file = os.path.join(label_dir, "camelyonpatch_level_2_split_train_y.h5")
+    val_label_file = os.path.join(label_dir, "camelyonpatch_level_2_split_valid_y.h5")
+    test_label_file = os.path.join(label_dir, "camelyonpatch_level_2_split_test_y.h5")
+
+    def preprocess(images):
+        """Resize and normalize images from 96x96 to 224x224 pixels."""
+        processed = []
+        for img in images:
+            im = Image.fromarray(img)
+            im = im.resize((224, 224))  # Resize to match Path Foundation input
+            arr = np.array(im).astype('float32') / 255.0
+            processed.append(arr)
+        return np.array(processed)
+
+    def safe_load(img_file, label_file, limit):
+        """Safely load data from HDF5 files with memory management."""
+        with h5py.File(img_file, 'r') as f_img, h5py.File(label_file, 'r') as f_lbl:
+            x = f_img['x'][:limit]
+            y = f_lbl['y'][:limit]
+            y = y.reshape(-1)  # Ensure 1D label array
+            return x, y
+
+    # Load data splits with sample limits
+    train_images, train_labels = safe_load(train_file, train_label_file, max_samples//2)
+    val_images, val_labels = safe_load(val_file, val_label_file, max_samples//4)
+    test_images, test_labels = safe_load(test_file, test_label_file, max_samples//4)
+
+    # Preprocess all splits
+    train_images = preprocess(train_images)
+    val_images = preprocess(val_images)
+    test_images = preprocess(test_images)
+
+    # Apply data augmentation to training set
+    if augment:
+        print("Applying data augmentation to training set...")
+        for i in range(len(train_images)):
+            # Random horizontal flip
+            if np.random.rand() > 0.5:
+                train_images[i] = np.fliplr(train_images[i])
+            
+            # Random rotation (0, 90, 180, 270 degrees)
+            k = np.random.randint(0, 4)
+            if k:
+                train_images[i] = np.rot90(train_images[i], k)
+            
+            # Random brightness adjustment
+            if np.random.rand() > 0.7:
+                im = Image.fromarray((train_images[i] * 255).astype('uint8'))
+                brightness_factor = 0.9 + 0.2 * np.random.rand()
+                im = Image.fromarray(
+                    np.clip(np.array(im, dtype=np.float32) * brightness_factor, 0, 255).astype('uint8')
+                )
+                train_images[i] = np.array(im).astype('float32') / 255.0
+
+    print(f"PCam dataset loaded - Train: {len(train_images)}, Val: {len(val_images)}, Test: {len(test_images)}")
+
+    return {
+        'train': (train_images, train_labels),
+        'valid': (val_images, val_labels),
+        'test': (test_images, test_labels)
+    }
+
+def load_bach_data(data_dir="datasets/BACH/ICIAR2018_BACH_Challenge/Photos", max_samples=400, augment=True):
+    """
+    Load and preprocess the BACH (ICIAR 2018) breast cancer histology dataset.
+    
+    BACH contains microscopy images classified into four categories:
+    - Normal tissue
+    - Benign lesions
+    - In situ carcinoma
+    - Invasive carcinoma
+    
+    For binary classification, this function maps:
+    - Normal + Benign → Benign (label 0)
+    - In situ + Invasive → Malignant (label 1)
+    
+    Args:
+        data_dir (str): Path to BACH dataset directory containing class subdirectories:
+                       - Normal/
+                       - Benign/
+                       - InSitu/
+                       - Invasive/
+        max_samples (int): Maximum total samples to load across all classes.
+                          Distributed evenly across the 4 classes.
+        augment (bool): Whether to apply data augmentation (currently not implemented
+                       for BACH dataset but parameter kept for consistency)
+                       
+    Returns:
+        dict: Dictionary with 'train', 'valid', 'test' keys containing (images, labels) tuples
+            - 'train': (train_images, train_labels) - Training data
+            - 'valid': (val_images, val_labels) - Validation data  
+            - 'test': (test_images, test_labels) - Test data
+            
+    Dataset Details:
+        - Original categories: 4 classes (Normal, Benign, InSitu, Invasive)
+        - Binary mapping: Normal(0), Benign(1) → Benign(0); InSitu(2), Invasive(3) → Malignant(1)
+        - Image format: TIF, TIFF, PNG, JPG, JPEG
+        - Resized to: 224x224 pixels for Path Foundation compatibility
+        - Normalized to: [0, 1] range
+        
+    Data Splitting:
+        - Test set: 20% of total data
+        - Training set: 60% of total data (75% of remaining after test split)
+        - Validation set: 20% of total data (25% of remaining after test split)
+        - Stratified splitting to maintain class distribution
+        
+    Note:
+        The function automatically handles the 4-class to binary classification mapping.
+        Images are resized to 224x224 pixels and normalized to [0,1] range.
+        The augment parameter is kept for API consistency but augmentation is not
+        currently implemented for the BACH dataset.
+        
+    Example:
+        >>> # Load BACH dataset
+        >>> bach_data = load_bach_data(
+        ...     data_dir="datasets/BACH/ICIAR2018_BACH_Challenge/Photos",
+        ...     max_samples=400,
+        ...     augment=True
+        ... )
+        >>> 
+        >>> # Access training data
+        >>> train_images, train_labels = bach_data['train']
+        >>> print(f"Training samples: {len(train_images)}")
+        >>> print(f"Class distribution: Benign={np.sum(train_labels==0)}, Malignant={np.sum(train_labels==1)}")
+    """
+    print("Loading BACH (ICIAR 2018) dataset...")
+    
+    # Original BACH categories mapped to binary classification
+    class_dirs = {
+        'Normal': 0,    # Normal tissue → Benign
+        'Benign': 1,    # Benign lesions → Benign  
+        'InSitu': 2,    # In situ carcinoma → Malignant
+        'Invasive': 3,  # Invasive carcinoma → Malignant
+    }
+    
+    images = []
+    labels = []
+    per_class_limit = None if not max_samples else max_samples // 4
+    counters = {0: 0, 1: 0, 2: 0, 3: 0}
+    
+    # Load images from each category
+    for cls_name, cls_label in class_dirs.items():
+        cls_path = os.path.join(data_dir, cls_name)
+        if not os.path.isdir(cls_path):
+            print(f"Warning: Directory {cls_path} not found")
+            continue
+            
+        for fname in os.listdir(cls_path):
+            if per_class_limit and counters[cls_label] >= per_class_limit:
+                break
+            if not fname.lower().endswith((".tif", ".tiff", ".png", ".jpg", ".jpeg")):
+                continue
+                
+            fpath = os.path.join(cls_path, fname)
+            try:
+                im = Image.open(fpath).convert('RGB')
+                im = im.resize((224, 224))
+                arr = np.array(im).astype('float32') / 255.0
+                images.append(arr)
+                labels.append(cls_label)
+                counters[cls_label] += 1
+            except Exception as e:
+                print(f"Error loading {fname}: {e}")
+                continue
+    
+    images = np.array(images)
+    labels = np.array(labels)
+    
+    # Convert 4-class to binary classification
+    if labels.size > 0:
+        # Map: Normal(0), Benign(1) → Benign(0); InSitu(2), Invasive(3) → Malignant(1)
+        labels = np.where(np.isin(labels, [0, 1]), 0, 1)
+
+    print(f"BACH dataset loaded: {len(images)} images")
+    print(f"Class distribution - Benign: {np.sum(labels == 0)}, Malignant: {np.sum(labels == 1)}")
+    
+    # Split into train/validation/test sets
+    X_temp, X_test, y_temp, y_test = train_test_split(
+        images, labels, test_size=0.2, 
+        stratify=labels if len(set(labels)) > 1 else None, 
+        random_state=42
+    )
+    X_train, X_val, y_train, y_val = train_test_split(
+        X_temp, y_temp, test_size=0.25, 
+        stratify=y_temp if len(set(y_temp)) > 1 else None, 
+        random_state=42
+    )
+    
+    return {
+        'train': (X_train, y_train),
+        'valid': (X_val, y_val),
+        'test': (X_test, y_test)
+    }
+
+def load_combined_data(dataset_choice="breakhis", max_samples=5000):
+    """
+    Unified data loading function supporting multiple datasets and combinations.
+    
+    This function serves as the main entry point for data loading, supporting:
+    - Individual datasets (BreakHis, PCam, BACH)
+    - Combined dataset training for improved generalization
+    - Consistent data splitting and preprocessing across all datasets
+    
+    The combined dataset approach leverages multiple histopathology datasets to
+    create a more robust and generalizable model by training on diverse data sources.
+    
+    Args:
+        dataset_choice (str): Dataset to load. Options:
+            - "breakhis": BreakHis breast cancer histopathology dataset
+            - "pcam": PatchCamelyon lymph node metastasis dataset
+            - "bach": BACH ICIAR 2018 breast cancer histology dataset
+            - "combined": Ensemble of all three datasets for robust training
+        max_samples (int): Maximum total samples to load. For individual datasets,
+                          this is the total limit. For combined datasets, this is
+                          distributed across the constituent datasets.
+                          
+    Returns:
+        dict: Dictionary with 'train', 'valid', 'test' keys containing (images, labels) tuples
+            - 'train': (train_images, train_labels) - Training data
+            - 'valid': (val_images, val_labels) - Validation data
+            - 'test': (test_images, test_labels) - Test data
+            
+    Dataset Combinations:
+        When dataset_choice="combined", the function:
+        1. Loads BreakHis, PCam, and BACH datasets
+        2. Combines their training data
+        3. Shuffles the combined dataset
+        4. Splits into train/validation/test sets
+        5. Maintains class balance through stratified splitting
+        
+    Sample Distribution (for combined datasets):
+        - BreakHis: max_samples // 6 (per-class limit)
+        - PCam: max_samples // 3 (total limit)
+        - BACH: max_samples // 3 (total limit)
+        
+    Data Splitting:
+        - Test set: 20% of total data
+        - Training set: 60% of total data (75% of remaining after test split)
+        - Validation set: 20% of total data (25% of remaining after test split)
+        - Stratified splitting to maintain class distribution
+        
+    Note:
+        All datasets are automatically preprocessed to 224x224 pixels and normalized
+        to [0,1] range for compatibility with the Path Foundation model.
+        
+    Example:
+        >>> # Load individual dataset
+        >>> data = load_combined_data("breakhis", max_samples=2000)
+        >>> 
+        >>> # Load combined dataset for robust training
+        >>> combined_data = load_combined_data("combined", max_samples=6000)
+        >>> 
+        >>> # Access training data
+        >>> train_images, train_labels = combined_data['train']
+        >>> print(f"Combined training samples: {len(train_images)}")
+    """
+    
+    if dataset_choice.lower() == "breakhis":
+        print("Loading BreakHis dataset only...")
+        images, labels = load_breakhis_data(max_samples_per_class=max_samples//2)
+        
+        # Split into train/validation/test
+        X_temp, X_test, y_temp, y_test = train_test_split(
+            images, labels, test_size=0.2, stratify=labels, random_state=42
+        )
+        
+        X_train, X_val, y_train, y_val = train_test_split(
+            X_temp, y_temp, test_size=0.25, stratify=y_temp, random_state=42
+        )
+        
+        return {
+            'train': (X_train, y_train),
+            'valid': (X_val, y_val),
+            'test': (X_test, y_test)
+        }
+    
+    elif dataset_choice.lower() == "pcam":
+        return load_pcam_data(max_samples=max_samples)
+        
+    elif dataset_choice.lower() == "bach":
+        return load_bach_data(max_samples=max_samples)
+        
+    elif dataset_choice.lower() == "combined":
+        print("Loading combined datasets for enhanced generalization...")
+        
+        # Distribute samples across datasets
+        if max_samples is None:
+            per_bh = None
+            per_pc = None
+            per_ba = None
+        else:
+            per_dataset = max(1, max_samples // 3)
+            per_bh = per_dataset // 2  # BreakHis uses per-class limit
+            per_pc = per_dataset
+            per_ba = per_dataset
+        
+        # Load individual datasets
+        print("Loading BreakHis component...")
+        bh_images, bh_labels = load_breakhis_data(
+            max_samples_per_class=per_bh if per_bh else 10**9
+        )
+        
+        print("Loading PCam component...")
+        pcam = load_pcam_data(max_samples=per_pc, augment=True)
+        pc_train_images, pc_train_labels = pcam["train"]
+        
+        print("Loading BACH component...")
+        bach = load_bach_data(max_samples=per_ba, augment=True)
+        b_train_images, b_train_labels = bach["train"]
+        
+        # Combine all datasets
+        images = np.concatenate([bh_images, pc_train_images, b_train_images], axis=0)
+        labels = np.concatenate([bh_labels, pc_train_labels, b_train_labels], axis=0)
+        
+        print(f"Combined dataset: {len(images)} total images")
+        print(f"Final distribution - Benign: {np.sum(labels == 0)}, Malignant: {np.sum(labels == 1)}")
+        
+        # Shuffle combined data
+        idx = np.arange(len(images))
+        np.random.shuffle(idx)
+        images, labels = images[idx], labels[idx]
+        
+        # Split combined data
+        X_temp, X_test, y_temp, y_test = train_test_split(
+            images, labels, test_size=0.2, 
+            stratify=labels if len(set(labels)) > 1 else None, 
+            random_state=42
+        )
+        X_train, X_val, y_train, y_val = train_test_split(
+            X_temp, y_temp, test_size=0.25, 
+            stratify=y_temp if len(set(y_temp)) > 1 else None, 
+            random_state=42
+        )
+        
+        return {
+            'train': (X_train, y_train),
+            'valid': (X_val, y_val),
+            'test': (X_test, y_test)
+        }
+    
+    else:
+        raise ValueError(f"Unknown dataset choice: {dataset_choice}. "
+                        f"Choose from: 'breakhis', 'pcam', 'bach', 'combined'")
+
+def main():
+    """
+    Execute the complete breast cancer classification pipeline.
+    
+    This function coordinates all components of the machine learning workflow:
+    1. Environment validation and setup
+    2. Model authentication and loading
+    3. Dataset loading and preprocessing
+    4. Feature extraction using Path Foundation
+    5. Classifier training with advanced techniques
+    6. Comprehensive model evaluation
+    7. Model persistence for future use
+    
+    The pipeline implements a robust transfer learning approach using Google's
+    Path Foundation model as a feature extractor, followed by a trainable
+    classification head for binary breast cancer classification.
+    
+    Returns:
+        tuple: (classifier_instance, evaluation_results) or (None, None) if failed
+            - classifier_instance: Trained BreastCancerClassifier object
+            - evaluation_results: Dictionary containing performance metrics and predictions
+            
+    Configuration:
+        The function uses global variables for configuration (can be modified):
+        - DATASET_CHOICE: Dataset to use ("breakhis", "pcam", "bach", "combined")
+        - MAX_SAMPLES: Maximum samples to load (adjust based on available memory)
+        - EPOCHS: Number of training epochs (default: 50)
+        - HF_TOKEN: Hugging Face authentication token (optional)
+        
+    Pipeline Steps:
+        1. Prerequisites Check: Validates required packages and dependencies
+        2. Authentication: Authenticates with Hugging Face Hub
+        3. Model Loading: Downloads and loads Path Foundation model
+        4. Data Loading: Loads and preprocesses histopathology dataset
+        5. Feature Extraction: Extracts embeddings using frozen foundation model
+        6. Classifier Building: Constructs trainable classification head
+        7. Training: Trains classifier with callbacks and monitoring
+        8. Evaluation: Comprehensive performance assessment
+        9. Model Saving: Persists trained model for future use
+        
+    Error Handling:
+        The function includes comprehensive error handling with detailed error messages
+        and stack traces to aid in debugging and troubleshooting.
+        
+    Example:
+        >>> # Run the complete pipeline
+        >>> classifier, results = main()
+        >>> 
+        >>> if results:
+        ...     print(f"Pipeline successful! Accuracy: {results['accuracy']:.4f}")
+        ...     # Use the trained classifier for inference
+        ... else:
+        ...     print("Pipeline failed - check error messages")
+        
+    Note:
+        This function is designed to be run as a standalone script or imported
+        and called from other modules. It provides a complete end-to-end
+        machine learning pipeline for breast cancer classification.
+    """
+    print("="*60)
+    print("BREAST CANCER CLASSIFICATION WITH PATH FOUNDATION")
+    print("="*60)
+    
+    # Validate prerequisites
+    if not HF_AVAILABLE:
+        print("ERROR: Prerequisites not met")
+        print("Required installations: pip install tensorflow huggingface_hub transformers")
+        return None, None
+    
+    # Configuration parameters
+    EPOCHS = 50
+    HF_TOKEN = None  # Set your Hugging Face token here if needed
+    
+    # Global configuration (can be modified in notebook)
+    if 'DATASET_CHOICE' not in globals():
+        DATASET_CHOICE = 'combined'  # Options: 'breakhis', 'pcam', 'bach', 'combined'
+    if 'MAX_SAMPLES' not in globals():
+        MAX_SAMPLES = 4000
+        
+    print(f"Configuration:")
+    print(f"  - Epochs: {EPOCHS}")
+    print(f"  - Dataset: {DATASET_CHOICE}")
+    print(f"  - Max samples: {MAX_SAMPLES}")
+    print(f"  - Method: Feature extraction (frozen foundation model)")
+    
+    try:
+        # Initialize classifier in feature extraction mode
+        classifier = BreastCancerClassifier(fine_tune=False)
+        
+        print("\n" + "="*40)
+        print("STEP 1: HUGGING FACE AUTHENTICATION")
+        print("="*40)
+        if not classifier.authenticate_huggingface(HF_TOKEN):
+            raise Exception("Authentication failed - check your HF token")
+        
+        print("\n" + "="*40)
+        print("STEP 2: LOADING PATH FOUNDATION MODEL")
+        print("="*40)
+        if not classifier.load_path_foundation():
+            raise Exception("Model loading failed - check network connection")
+        
+        print("\n" + "="*40)
+        print(f"STEP 3: LOADING {DATASET_CHOICE.upper()} DATASET")
+        print("="*40)
+        data = load_combined_data(DATASET_CHOICE, MAX_SAMPLES)
+        
+        X_train, y_train = data['train']
+        X_val, y_val = data['valid']
+        X_test, y_test = data['test']
+        
+        print(f"Dataset splits:")
+        print(f"  - Training: {len(X_train)} samples")
+        print(f"  - Validation: {len(X_val)} samples")
+        print(f"  - Test: {len(X_test)} samples")
+        
+        print("\n" + "="*40)
+        print("STEP 4: EXTRACTING FEATURE EMBEDDINGS")
+        print("="*40)
+        print("Extracting training embeddings...")
+        X_train = classifier.extract_embeddings(X_train)
+        print("Extracting validation embeddings...")
+        X_val = classifier.extract_embeddings(X_val)
+        print("Extracting test embeddings...")
+        X_test = classifier.extract_embeddings(X_test)
+        
+        print("\n" + "="*40)
+        print("STEP 5: BUILDING CLASSIFICATION HEAD")
+        print("="*40)
+        classifier.num_classes = 2
+        classifier.build_classifier()
+        
+        print("\n" + "="*40)
+        print("STEP 6: TRAINING CLASSIFIER")
+        print("="*40)
+        classifier.train_model(X_train, y_train, X_val, y_val, EPOCHS)
+        
+        print("\n" + "="*40)
+        print("STEP 7: MODEL EVALUATION")
+        print("="*40)
+        results = classifier.evaluate_model(X_test, y_test)
+        
+        # Save trained model
+        model_name = f"{DATASET_CHOICE}_breast_cancer_classifier.keras"
+        classifier.model.save(model_name)
+        print(f"\nModel saved as: {model_name}")
+        
+        print("\n" + "="*60)
+        print("PIPELINE COMPLETED SUCCESSFULLY")
+        print("="*60)
+        print(f"Final Performance Metrics:")
+        print(f"  - Accuracy: {results['accuracy']:.4f} ({results['accuracy']*100:.2f}%)")
+        print(f"  - F1-Score: {results['f1']:.4f}")
+        print(f"  - Precision: {results['precision']:.4f}")
+        print(f"  - Recall: {results['recall']:.4f}")
+        
+        return classifier, results
+        
+    except Exception as e:
+        print(f"\nERROR: Pipeline failed - {e}")
+        import traceback
+        traceback.print_exc()
+        return None, None
+
+# Script execution section
+if __name__ == "__main__":
+    """
+    Main execution block for running the breast cancer classification pipeline.
+    
+    This section is executed when the script is run directly (not imported).
+    It provides a simple interface to run the complete machine learning pipeline
+    and displays the final results.
+    
+    Usage:
+        python model2.py
+    
+    The script will:
+    1. Initialize and run the complete pipeline
+    2. Display progress and intermediate results
+    3. Show final performance metrics
+    4. Save the trained model for future use
+    """
+    print("Starting Breast Cancer Classification Pipeline...")
+    print("This may take several minutes depending on your hardware and dataset size.")
+    print("="*60)
+    
+    # Execute the complete pipeline
+    classifier, results = main()
+    
+    # Display final results
+    if results:
+        print("\n" + "="*60)
+        print("🎉 PIPELINE EXECUTION SUCCESSFUL! 🎉")
+        print("="*60)
+        print(f"Final Accuracy: {results['accuracy']:.4f} ({results['accuracy']*100:.2f}%)")
+        print(f"F1-Score: {results['f1']:.4f}")
+        print(f"Precision: {results['precision']:.4f}")
+        print(f"Recall: {results['recall']:.4f}")
+        print("\nThe trained model has been saved and is ready for inference!")
+        print("You can now use the classifier for breast cancer classification tasks.")
+    else:
+        print("\n" + "="*60)
+        print("❌ PIPELINE EXECUTION FAILED ❌")
+        print("="*60)
+        print("Please check the error messages above for troubleshooting.")
+        print("Common issues:")
+        print("- Missing dependencies (install with: pip install tensorflow huggingface_hub transformers)")
+        print("- Network connectivity issues (for downloading Path Foundation model)")
+        print("- Insufficient memory (reduce MAX_SAMPLES parameter)")
+        print("- Invalid dataset paths (check dataset directory structure)")

backend/requirements.txt

@@ -0,0 +1,14 @@
+fastapi
+uvicorn
+pillow
+ultralytics
+tensorflow
+numpy
+huggingface_hub
+joblib  
+scikit-learn
+scikit-image
+loguru
+thop
+seaborn
+python-multipart

backend/yolo_colposcopy.pt

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

frontend/.eslintrc.cjs

@@ -0,0 +1,18 @@
+module.exports = {
+  root: true,
+  env: { browser: true, es2020: true },
+  extends: [
+    'eslint:recommended',
+    'plugin:@typescript-eslint/recommended',
+    'plugin:react-hooks/recommended',
+  ],
+  ignorePatterns: ['dist', '.eslintrc.cjs'],
+  parser: '@typescript-eslint/parser',
+  plugins: ['react-refresh'],
+  rules: {
+    'react-refresh/only-export-components': [
+      'warn',
+      { allowConstantExport: true },
+    ],
+  },
+}

frontend/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

frontend/README.md

@@ -0,0 +1,8 @@
+# Magic Patterns - Vite Template
+
+This code was generated by [Magic Patterns](https://magicpatterns.com) for this design: [Source Design](https://www.magicpatterns.com/c/jitk86q9nv1at6tcwj7cxr)
+
+## Getting Started
+
+1. Run `npm install`
+2. Run `npm run dev`

frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Manalife AI Pathology Assistant</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/index.tsx"></script>
+  </body>
+</html>

frontend/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "magic-patterns-vite-template",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "npx vite",
+    "build": "npx vite build",
+    "lint": "eslint . --ext .js,.jsx,.ts,.tsx",
+    "preview": "npx vite preview"
+  },
+  "dependencies": {
+    "axios": "^1.12.2",
+    "lucide-react": "0.522.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-dom": "^6.26.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.18",
+    "@types/react": "^18.3.1",
+    "@types/react-dom": "^18.3.1",
+    "@typescript-eslint/eslint-plugin": "^5.54.0",
+    "@typescript-eslint/parser": "^5.54.0",
+    "@vitejs/plugin-react": "^4.2.1",
+    "autoprefixer": "latest",
+    "eslint": "^8.50.0",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-react-refresh": "^0.4.1",
+    "postcss": "latest",
+    "tailwindcss": "3.4.17",
+    "typescript": "^5.5.4",
+    "vite": "^5.2.0"
+  }
+}

frontend/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

frontend/src/App.tsx

@@ -0,0 +1,125 @@
+import { useState, useEffect } from "react";
+import axios from "axios";
+import { Header } from "./components/Header";
+import { Sidebar } from "./components/Sidebar";
+import { UploadSection } from "./components/UploadSection";
+import { ResultsPanel } from "./components/ResultsPanel";
+import { Footer } from "./components/Footer";
+import { ProgressBar } from "./components/progressbar";
+
+export function App() {
+// ----------------------------
+// State Management
+// ----------------------------
+const [selectedTest, setSelectedTest] = useState("cytology");
+const [uploadedImage, setUploadedImage] = useState<string | null>(null);
+const [selectedModel, setSelectedModel] = useState("");
+const [apiResult, setApiResult] = useState<any>(null);
+const [showResults, setShowResults] = useState(false);
+const [currentStep, setCurrentStep] = useState(0);
+const [loading, setLoading] = useState(false);
+
+// ----------------------------
+// Progress bar logic
+// ----------------------------
+useEffect(() => {
+if (showResults) setCurrentStep(2);
+else if (uploadedImage) setCurrentStep(1);
+else setCurrentStep(0);
+}, [uploadedImage, showResults]);
+
+// ----------------------------
+// Reset logic — new test
+// ----------------------------
+useEffect(() => {
+setCurrentStep(0);
+setShowResults(false);
+setUploadedImage(null);
+setSelectedModel("");
+setApiResult(null);
+}, [selectedTest]);
+
+// ----------------------------
+// Analyze handler (Backend call)
+// ----------------------------
+const handleAnalyze = async () => {
+if (!uploadedImage || !selectedModel) {
+alert("Please select a model and upload an image first!");
+return;
+}
+
+
+setLoading(true);
+setShowResults(false);
+setApiResult(null);
+
+try {
+  // Convert Base64 → File
+  const blob = await fetch(uploadedImage).then((r) => r.blob());
+  const file = new File([blob], "input.jpg", { type: blob.type });
+
+  const formData = new FormData();
+  formData.append("file", file);
+  formData.append("analysis_type", selectedTest);
+  formData.append("model_name", selectedModel);
+
+  // POST to backend
+const baseURL =
+      import.meta.env.MODE === "development"
+        ? "http://127.0.0.1:8000"
+        : window.location.origin;
+
+    const res = await axios.post(`${baseURL}/predict/`, formData, {
+      headers: { "Content-Type": "multipart/form-data" },
+    });
+
+    setApiResult(res.data);
+    setShowResults(true);
+  } catch (err) {
+    console.error("❌ Error during inference:", err);
+    alert("Error analyzing the image. Check backend logs.");
+  } finally {
+    setLoading(false);
+  }
+};
+// ----------------------------
+// Layout
+// ----------------------------
+return ( <div className="flex flex-col min-h-screen w-full bg-gray-50"> <Header /> <ProgressBar currentStep={currentStep} />
+
+
+  <div className="flex flex-1">
+    <Sidebar selectedTest={selectedTest} onTestChange={setSelectedTest} />
+
+    <main className="flex-1 p-6">
+      <div className="max-w-7xl mx-auto grid grid-cols-1 lg:grid-cols-2 gap-6">
+        {/* Upload & Model Selection */}
+        <UploadSection
+          selectedTest={selectedTest}
+          uploadedImage={uploadedImage}
+          setUploadedImage={setUploadedImage}
+          selectedModel={selectedModel}
+          setSelectedModel={setSelectedModel}
+          onAnalyze={handleAnalyze}
+        />
+
+        {/* Results Panel */}
+        {showResults && (
+          <ResultsPanel
+            uploadedImage={
+              apiResult?.annotated_image_url || uploadedImage
+            }
+            result={apiResult}
+            loading={loading}
+          />
+        )}
+      </div>
+    </main>
+  </div>
+
+  <Footer />
+</div>
+
+
+);
+}

frontend/src/AppRouter.tsx

@@ -0,0 +1,10 @@
+import React from "react";
+import { BrowserRouter, Routes, Route } from "react-router-dom";
+import { App } from "./App";
+export function AppRouter() {
+  return <BrowserRouter>
+        <Routes>
+          <Route path="/" element={<App />} />
+        </Routes>
+    </BrowserRouter>;
+}

frontend/src/components/Footer.tsx

@@ -0,0 +1,50 @@
+import React from 'react';
+
+export function Footer() {
+  return (
+    <footer
+      className="relative w-full text-white py-10 mt-auto bg-cover bg-center"
+      style={{
+        backgroundImage:
+          "url('banner.jpeg')",
+      }}
+    >
+      {/* Overlay for readability */}
+      <div className="absolute inset-0 bg-gradient-to-t from-slate-900/95 via-slate-900/70 to-transparent" />
+
+      {/* Main footer content */}
+      <div className="relative max-w-7xl mx-auto px-8">
+        <div className="flex justify-center gap-8 mb-4">
+          <a
+            href="#"
+            className="relative text-blue-300 hover:text-blue-100 transition-all duration-300 after:content-[''] after:absolute after:left-0 after:bottom-0 after:w-0 hover:after:w-full after:h-[1px] after:bg-blue-300 after:transition-all after:duration-300"
+          >
+            Help Center
+          </a>
+          <a
+            href="#"
+            className="relative text-blue-300 hover:text-blue-100 transition-all duration-300 after:content-[''] after:absolute after:left-0 after:bottom-0 after:w-0 hover:after:w-full after:h-[1px] after:bg-blue-300 after:transition-all after:duration-300"
+          >
+            Contact Support
+          </a>
+        </div>
+
+        <div className="text-center">
+          <p className="font-semibold mb-2">© 2025 Manalife. All rights reserved.</p>
+          <p className="text-gray-300 text-sm">
+            Advancing innovation in women's health and digital pathology.
+          </p>
+        </div>
+      </div>
+
+      {/* Logo at bottom-right corner */}
+      <div className="absolute bottom-4 right-8">
+        <img
+          src="/white_logo.png"
+          alt="Manalife Logo"
+          className="h-12 w-auto opacity-90 hover:opacity-100 transition-opacity duration-300"
+        />
+      </div>
+    </footer>
+  );
+}

frontend/src/components/Header.tsx

@@ -0,0 +1,40 @@
+export function Header() {
+  return (
+    <div className="w-full bg-white">
+      {/* Banner */}
+      <div
+        className="w-full h-24 bg-cover bg-center"
+        style={{
+          backgroundImage:
+            "url('/banner.jpeg')",
+        }}
+      >
+        <div className="w-full h-full bg-gradient-to-r from-blue-900/80 to-teal-900/80 flex items-center px-8">
+          {/* Logo + Title */}
+          <div className="flex items-center gap-4">
+            <img
+              src="/white_logo.png"
+              alt="Manalife Logo"
+              className="h-16 w-auto"
+            />
+            <h1 className="text-white text-2xl font-semibold tracking-wide">
+              Manalife AI Pathology Assistant
+            </h1>
+          </div>
+        </div>
+      </div>
+
+      {/* Disclaimer */}
+      <div className="bg-blue-50 border-b border-blue-200 px-8 py-3">
+        <h3 className="font-semibold text-blue-900 mb-1">Public Disclaimer</h3>
+        <p className="text-sm text-blue-800">
+          Manalife AI models are research prototypes developed to advance
+          innovation in women's health and digital pathology. They are not
+          certified medical devices and are not intended for direct diagnosis or
+          treatment. Clinical validation and regulatory approval are required
+          before any medical use.
+        </p>
+      </div>
+    </div>
+  );
+}

frontend/src/components/ResultsPanel.tsx

@@ -0,0 +1,143 @@
+import { DownloadIcon, InfoIcon, Loader2Icon } from "lucide-react";
+
+interface ResultsPanelProps {
+uploadedImage: string | null;
+result?: any;
+loading?: boolean;
+}
+
+export function ResultsPanel({ uploadedImage, result, loading }: ResultsPanelProps) {
+if (loading) {
+return ( <div className="bg-white rounded-lg shadow-sm p-6 flex flex-col items-center justify-center"> <Loader2Icon className="w-10 h-10 text-blue-600 animate-spin mb-3" /> <p className="text-gray-600 font-medium">Analyzing image...</p> </div>
+);
+}
+
+if (!result) {
+return ( <div className="bg-white rounded-lg shadow-sm p-6 text-center text-gray-500">
+No analysis result available yet. </div>
+);
+}
+
+const {
+prediction,
+confidence,
+probabilities,
+detections,
+summary,
+annotated_image_url,
+model_name,
+analysis_type,
+} = result;
+
+const handleDownload = () => {
+if (annotated_image_url) {
+const link = document.createElement("a");
+link.href = annotated_image_url;
+link.download = "analysis_result.jpg";
+link.click();
+}
+};
+
+return ( <div className="bg-white rounded-lg shadow-sm p-6">
+{/* Header */} <div className="flex items-center justify-between mb-6"> <div> <h2 className="text-2xl font-bold text-gray-800">
+{model_name ? model_name.toUpperCase() : "Analysis Result"} </h2> <p className="text-sm text-gray-500 capitalize">
+{analysis_type || "Test Type"} </p> </div>
+{annotated_image_url && ( <button
+         onClick={handleDownload}
+         className="flex items-center gap-2 bg-green-600 text-white px-4 py-2 rounded-lg hover:bg-green-700 transition-colors"
+       > <DownloadIcon className="w-4 h-4" />
+Download Image </button>
+)} </div>
+
+
+  {/* Image */}
+  <div className="relative mb-6 rounded-lg overflow-hidden border border-gray-200">
+    <img
+      src={annotated_image_url || uploadedImage || "/ui.jpg"}
+      alt="Analysis Result"
+      className="w-full h-64 object-cover"
+    />
+  </div>
+
+  {/* Results Summary */}
+  <div className="mb-6">
+    {prediction && (
+      <h3
+        className={`text-3xl font-bold ${
+          prediction.toLowerCase().includes("malignant") ||
+          prediction.toLowerCase().includes("abnormal")
+            ? "text-red-600"
+            : "text-green-600"
+        }`}
+      >
+        {prediction}
+      </h3>
+    )}
+
+    {confidence && (
+      <div className="mt-2">
+        <div className="flex items-center justify-between mb-1">
+          <span className="font-semibold text-gray-900">
+            Confidence: {(confidence * 100).toFixed(2)}%
+          </span>
+          <InfoIcon className="w-4 h-4 text-gray-400" />
+        </div>
+        <div className="w-full h-3 bg-gray-200 rounded-full overflow-hidden">
+          <div
+            className={`h-full ${
+              confidence > 0.7
+                ? "bg-green-500"
+                : confidence > 0.4
+                ? "bg-yellow-500"
+                : "bg-red-500"
+            }`}
+            style={{ width: `${confidence * 100}%` }}
+          />
+        </div>
+      </div>
+    )}
+
+    {summary && (
+      <p className="mt-4 text-gray-700 text-sm leading-relaxed">
+        {summary}
+      </p>
+    )}
+  </div>
+
+  {/* Detections / Probabilities */}
+  {detections && detections.length > 0 && (
+    <div className="mb-6">
+      <h4 className="font-semibold text-gray-900 mb-3">
+        Detected Regions:
+      </h4>
+      <ul className="text-sm text-gray-700 list-disc list-inside space-y-1">
+        {detections.map((det: any, i: number) => (
+          <li key={i}>
+            {det.name || "object"} – {(det.confidence * 100).toFixed(1)}%
+          </li>
+        ))}
+      </ul>
+    </div>
+  )}
+
+  {probabilities && (
+    <div className="mb-6">
+      <h4 className="font-semibold text-gray-900 mb-3">
+        Class Probabilities:
+      </h4>
+      <pre className="bg-gray-100 rounded-lg p-3 text-sm">
+        {JSON.stringify(probabilities, null, 2)}
+      </pre>
+    </div>
+  )}
+
+  {/* Report Button */}
+  <button className="w-full bg-blue-600 text-white py-3 rounded-lg font-medium hover:bg-blue-700 transition-colors flex items-center justify-center gap-2">
+    <DownloadIcon className="w-5 h-5" />
+    Generate Report
+  </button>
+</div>
+
+
+);
+}

frontend/src/components/Sidebar.tsx

@@ -0,0 +1,54 @@
+import React, { useState } from 'react';
+import { ChevronDownIcon, FileTextIcon, HelpCircleIcon } from 'lucide-react';
+interface SidebarProps {
+  selectedTest: string;
+  onTestChange: (test: string) => void;
+}
+export function Sidebar({
+  selectedTest,
+  onTestChange
+}: SidebarProps) {
+  const [isDropdownOpen, setIsDropdownOpen] = useState(false);
+  const testTypes = [{
+    value: 'cytology',
+    label: 'Cytology Analysis'
+  }, {
+    value: 'colposcopy',
+    label: 'Colposcopy Analysis'
+  }, {
+    value: 'histopathology',
+    label: 'Histopathology Analysis'
+  }];
+  return <aside className="w-64 bg-white border-r border-gray-200 p-4">
+      <div className="space-y-2">
+        {/* New Test Dropdown */}
+        <div className="relative">
+          <button onClick={() => setIsDropdownOpen(!isDropdownOpen)} className="w-full bg-blue-600 text-white rounded-lg px-4 py-3 flex items-center justify-between hover:bg-blue-700 transition-colors">
+            <div className="flex items-center gap-2">
+              <div className="w-2 h-2 bg-white rounded-full" />
+              <span className="font-medium">New Test</span>
+            </div>
+            <ChevronDownIcon className={`w-5 h-5 transition-transform ${isDropdownOpen ? 'rotate-180' : ''}`} />
+          </button>
+          {isDropdownOpen && <div className="absolute top-full left-0 right-0 mt-2 bg-white border border-gray-200 rounded-lg shadow-lg z-10">
+              {testTypes.map(test => <button key={test.value} onClick={() => {
+            onTestChange(test.value);
+            setIsDropdownOpen(false);
+          }} className={`w-full text-left px-4 py-3 hover:bg-gray-50 transition-colors ${selectedTest === test.value ? 'bg-blue-50 text-blue-600' : 'text-gray-700'}`}>
+                  {test.label}
+                </button>)}
+            </div>}
+        </div>
+        {/* History */}
+        <button className="w-full flex items-center gap-3 px-4 py-3 text-gray-700 hover:bg-gray-50 rounded-lg transition-colors">
+          <FileTextIcon className="w-5 h-5" />
+          <span>History</span>
+        </button>
+        {/* Help */}
+        <button className="w-full flex items-center gap-3 px-4 py-3 text-gray-700 hover:bg-gray-50 rounded-lg transition-colors">
+          <HelpCircleIcon className="w-5 h-5" />
+          <span>Help</span>
+        </button>
+      </div>
+    </aside>;
+}

frontend/src/components/UploadSection.tsx

@@ -0,0 +1,194 @@
+import React, { useRef } from 'react';
+import { UploadIcon } from 'lucide-react';
+
+interface UploadSectionProps {
+  selectedTest: string;
+  uploadedImage: string | null;
+  setUploadedImage: (image: string | null) => void;
+  selectedModel: string;
+  setSelectedModel: (model: string) => void;
+  onAnalyze: () => void;
+}
+
+
+
+export function UploadSection({
+  selectedTest,
+  uploadedImage,
+  setUploadedImage,
+  selectedModel,
+  setSelectedModel,
+  onAnalyze,
+}: UploadSectionProps) {
+  const fileInputRef = useRef<HTMLInputElement>(null);
+
+  const modelOptions = {
+    cytology: [
+      { value: 'mwt', label: 'MWT' },
+      { value: 'yolo', label: 'YOLOv8' },
+    ],
+    colposcopy: [
+      { value: 'cin', label: 'Logistic-Colpo' },
+  
+    ],
+    histopathology: [
+      { value: 'histopathology', label: 'Path Foundation Model' },
+  
+    ],
+  };
+
+
+  const sampleImages = {
+    cytology: [
+      "/cyto/cyt1.jpg",
+      "/cyto/cyt2.png",
+      "/cyto/cyt3.png",
+    ],
+    colposcopy: [
+      "/colpo/colp1.jpg",
+      "/colpo/colp2.jpg",
+      "/colpo/colp3.jpg",
+    ],
+    histopathology: [
+      "/histo/hist1.png",
+      "/histo/hist2.png",
+      "/histo/hist3.jpg",
+    ],
+  };
+
+  const currentModels =
+    modelOptions[selectedTest as keyof typeof modelOptions] || [];
+
+  const handleFileChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const file = e.target.files?.[0];
+    if (file) {
+      const reader = new FileReader();
+      reader.onload = (event) => {
+        setUploadedImage(event.target?.result as string);
+      };
+      reader.readAsDataURL(file);
+    }
+  };
+
+  const handleDrop = (e: React.DragEvent) => {
+    e.preventDefault();
+    const file = e.dataTransfer.files[0];
+    if (file) {
+      const reader = new FileReader();
+      reader.onload = (event) => {
+        setUploadedImage(event.target?.result as string);
+      };
+      reader.readAsDataURL(file);
+    }
+  };
+
+  // Handle click on sample image
+  const handleSampleClick = (imgUrl: string) => {
+    setUploadedImage(imgUrl);
+  };
+
+  return (
+    <div className="bg-white rounded-lg shadow-sm p-6">
+      <h2 className="text-2xl font-semibold text-gray-900 mb-6">
+        Upload an image of a tissue sample
+      </h2>
+
+      {/* Upload Area */}
+      <div
+        onDrop={handleDrop}
+        onDragOver={(e) => e.preventDefault()}
+        onClick={() => fileInputRef.current?.click()}
+        className="border-2 border-dashed border-gray-300 rounded-lg p-8 text-center cursor-pointer hover:border-blue-400 transition-colors"
+      >
+        <input
+          ref={fileInputRef}
+          type="file"
+          accept="image/*"
+          onChange={handleFileChange}
+          className="hidden"
+        />
+        <div className="flex flex-col items-center">
+          <div className="w-16 h-16 bg-gray-100 rounded-full flex items-center justify-center mb-4">
+            <UploadIcon className="w-8 h-8 text-gray-400" />
+          </div>
+          {uploadedImage ? (
+            <>
+              <p className="text-green-600 font-medium mb-2">
+                Image uploaded successfully!
+              </p>
+              <p className="text-sm text-gray-500 mb-4">
+                Click to upload a different image
+              </p>
+              <div className="w-32 h-32 rounded-lg overflow-hidden border border-gray-200">
+                <img
+                  src={uploadedImage}
+                  alt="Uploaded sample"
+                  className="w-full h-full object-cover"
+                />
+              </div>
+            </>
+          ) : (
+            <p className="text-gray-600">Drag and drop or click to upload</p>
+          )}
+        </div>
+      </div>
+
+      {/* Model Selection */}
+      <div className="mt-6">
+        <label className="block text-sm font-medium text-gray-700 mb-2">
+          Select Analysis Model:
+        </label>
+        <select
+          value={selectedModel}
+          onChange={(e) => setSelectedModel(e.target.value)}
+          className="w-full px-4 py-3 border border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500 focus:border-transparent"
+        >
+          <option value="">Choose a model...</option>
+          {currentModels.map((model) => (
+            <option key={model.value} value={model.value}>
+              {model.label}
+            </option>
+          ))}
+        </select>
+      </div>
+
+      {/* Analyze Button */}
+      <button
+        onClick={onAnalyze}
+        disabled={!uploadedImage || !selectedModel}
+        className="w-full mt-6 bg-blue-600 text-white py-3 rounded-lg font-medium hover:bg-blue-700 disabled:bg-gray-300 disabled:cursor-not-allowed transition-colors"
+      >
+        Analyze
+      </button>
+
+      {/* Separator */}
+      <hr className="my-8 border-gray-200" />
+
+      {/* Sample Images Section */}
+      <div>
+        <h3 className="text-lg font-semibold text-gray-800 mb-4">
+          Samples Images
+        </h3>
+        <div className="flex flex-wrap gap-4">
+          {(sampleImages[selectedTest as keyof typeof sampleImages] || []).map(
+            (img, index) => (
+              <div
+                key={index}
+                className={`w-20 h-20 rounded-lg border-2 cursor-pointer transition-transform hover:scale-105 hover:border-blue-500 overflow-hidden ${
+                  uploadedImage === img ? 'border-blue-600' : 'border-gray-300'
+                }`}
+                onClick={() => handleSampleClick(img)}
+              >
+                <img
+                  src={img}
+                  alt={`Sample ${index + 1}`}
+                  className="w-full h-full object-cover"
+                />
+              </div>
+            )
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/components/progressbar.tsx

@@ -0,0 +1,61 @@
+import { Fragment } from "react";
+import { CheckIcon, FileTextIcon } from "lucide-react";
+
+interface ProgressBarProps {
+  currentStep: number;
+}
+
+export function ProgressBar({ currentStep }: ProgressBarProps) {
+  const steps = [
+    { label: "Upload", index: 0 },
+    { label: "Analyze", index: 1 },
+    { label: "Report", index: 2 },
+  ];
+
+  return (
+    <div className="bg-white px-8 py-6 border-b border-gray-200">
+      <div className="max-w-2xl mx-auto flex items-center justify-center">
+        {steps.map((step, index) => (
+          <Fragment key={step.label}>
+            <div className="flex flex-col items-center">
+              {/* Step circle */}
+              <div
+                className={`w-12 h-12 rounded-full flex items-center justify-center text-white font-semibold transition-all duration-300 ${
+                  currentStep > step.index
+                    ? "bg-gradient-to-r from-blue-800 to-teal-600"
+                    : currentStep === step.index
+                    ? "bg-gradient-to-r from-blue-600 to-teal-500"
+                    : "bg-gray-300 text-gray-600"
+                }`}
+              >
+                {currentStep > step.index ? (
+                  <CheckIcon className="w-6 h-6" />
+                ) : step.index === 2 ? (
+                  <FileTextIcon className="w-6 h-6" />
+                ) : (
+                  <span>{index + 1}</span>
+                )}
+              </div>
+
+              {/* Label */}
+              <span className="mt-2 text-sm font-medium text-gray-700">
+                {step.label}
+              </span>
+            </div>
+
+            {/* Connecting line */}
+            {index < steps.length - 1 && (
+              <div
+                className={`h-1 w-32 mx-4 rounded-full transition-all duration-300 ${
+                  currentStep > step.index
+                    ? "bg-gradient-to-r from-blue-800 to-teal-600"
+                    : "bg-gray-300"
+                }`}
+              />
+            )}
+          </Fragment>
+        ))}
+      </div>
+    </div>
+  );
+}

frontend/src/index.css

@@ -0,0 +1,5 @@
+/* PLEASE NOTE: THESE TAILWIND IMPORTS SHOULD NEVER BE DELETED */
+@import 'tailwindcss/base';
+@import 'tailwindcss/components';
+@import 'tailwindcss/utilities';
+/* DO NOT DELETE THESE TAILWIND IMPORTS, OTHERWISE THE STYLING WILL NOT RENDER AT ALL */

frontend/src/index.tsx

@@ -0,0 +1,5 @@
+import './index.css';
+import React from "react";
+import { render } from "react-dom";
+import { App } from "./App";
+render(<App />, document.getElementById("root"));