deploy BE ke huggingface

.python-version

@@ -0,0 +1 @@
+3.12

build.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -o errexit
+set -o pipefail
+
+uv sync --frozen

dockerfile

@@ -0,0 +1,14 @@
+FROM python:3.10-slim
+
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+COPY --chown=user . .
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

features.py

@@ -0,0 +1,159 @@
+"""
+features.py — 120-dimensional handcrafted CV feature extraction.
+
+Pipeline (matches training notebook exactly):
+  preprocess(img) → get_mask(img) → extract_features(img, mask)
+
+Feature vector layout:
+  [0:24]   GLCM texture      (6 props × 4 angles)
+  [24:50]  LBP texture       (26-bin uniform histogram, P=24 R=3)
+  [50:74]  Gabor texture     (4 freqs × 3 orientations, mean+std)
+  [74:106] Colour histogram  (16H + 8S + 8V, normalised, within mask)
+  [106:115] Colour moments   (mean, std, skewness per HSV channel)
+  [115:120] ABCD morphology  (asymmetry, compactness, cvar, diam, elong)
+Total: 120 dimensions
+"""
+
+import numpy as np
+import cv2
+from skimage.feature import graycomatrix, graycoprops, local_binary_pattern
+
+
+# ── Preprocessing ──────────────────────────────────────────────────────────────
+
+def preprocess(img_bgr: np.ndarray, size: tuple = (256, 256)) -> np.ndarray:
+    """Hair removal (black-hat) → Gaussian blur → CLAHE → resize."""
+    gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
+    kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (17, 17))
+    bhat = cv2.morphologyEx(gray, cv2.MORPH_BLACKHAT, kernel)
+    _, hmask = cv2.threshold(bhat, 10, 255, cv2.THRESH_BINARY)
+    img_bgr = cv2.inpaint(img_bgr, hmask, 3, cv2.INPAINT_TELEA)
+    img_bgr = cv2.GaussianBlur(img_bgr, (5, 5), 0)
+    lab = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2LAB)
+    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    lab[:, :, 0] = clahe.apply(lab[:, :, 0])
+    img_bgr = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
+    return cv2.resize(img_bgr, size, interpolation=cv2.INTER_AREA)
+
+
+def get_mask(img_bgr: np.ndarray) -> np.ndarray:
+    """Otsu thresholding + morphological refinement to isolate lesion."""
+    gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
+    blur = cv2.GaussianBlur(gray, (7, 7), 0)
+    _, mask = cv2.threshold(blur, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
+    k = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (15, 15))
+    mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, k)
+    mask = cv2.morphologyEx(
+        mask, cv2.MORPH_OPEN,
+        cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5, 5))
+    )
+    return mask
+
+
+# ── Feature groups ─────────────────────────────────────────────────────────────
+
+def feat_glcm(gray: np.ndarray) -> np.ndarray:
+    """24-dim GLCM at 4 angles × 6 properties."""
+    glcm = graycomatrix(
+        gray, distances=[1],
+        angles=[0, np.pi / 4, np.pi / 2, 3 * np.pi / 4],
+        levels=256, symmetric=True, normed=True
+    )
+    props = ["contrast", "correlation", "energy", "homogeneity", "dissimilarity", "ASM"]
+    return np.concatenate([graycoprops(glcm, p).flatten() for p in props])
+
+
+def feat_lbp(gray: np.ndarray) -> np.ndarray:
+    """26-dim LBP histogram — rotation-invariant uniform, P=24 R=3."""
+    lbp = local_binary_pattern(gray, P=24, R=3, method="uniform")
+    hist, _ = np.histogram(lbp.ravel(), bins=26, range=(0, 26), density=True)
+    return hist.astype(np.float32)
+
+
+def feat_gabor(gray: np.ndarray) -> np.ndarray:
+    """24-dim Gabor responses at 4 scales × 3 orientations (mean + std each)."""
+    feats = []
+    for freq in [0.1, 0.2, 0.3, 0.4]:
+        for theta in [0, np.pi / 3, 2 * np.pi / 3]:
+            kernel = cv2.getGaborKernel(
+                (21, 21), sigma=4.0, theta=theta,
+                lambd=1.0 / freq, gamma=0.5, psi=0
+            )
+            resp = cv2.filter2D(gray.astype(np.float32), cv2.CV_32F, kernel)
+            feats.extend([resp.mean(), resp.std()])
+    return np.array(feats, dtype=np.float32)
+
+
+def feat_colour(img_bgr: np.ndarray, mask: np.ndarray) -> np.ndarray:
+    """32-dim normalised HSV histogram within lesion mask (16H + 8S + 8V)."""
+    hsv = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2HSV)
+    m = (mask > 0).astype(np.uint8) * 255
+    h = cv2.calcHist([hsv], [0], m, [16], [0, 180]).flatten()
+    s = cv2.calcHist([hsv], [1], m, [8], [0, 256]).flatten()
+    v = cv2.calcHist([hsv], [2], m, [8], [0, 256]).flatten()
+    norm = lambda x: x / (x.sum() + 1e-8)
+    return np.concatenate([norm(h), norm(s), norm(v)]).astype(np.float32)
+
+
+def feat_colour_moments(img_bgr: np.ndarray, mask: np.ndarray) -> np.ndarray:
+    """9-dim colour moments (mean, std, skewness) per HSV channel."""
+    hsv = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2HSV)
+    feats = []
+    for ch in range(3):
+        pixels = hsv[:, :, ch][mask > 0].astype(float)
+        if pixels.size == 0:
+            feats.extend([0.0, 0.0, 0.0])
+            continue
+        mu = pixels.mean()
+        sigma = pixels.std() + 1e-8
+        skew = float(np.mean(((pixels - mu) / sigma) ** 3))
+        feats.extend([mu, sigma, skew])
+    return np.array(feats, dtype=np.float32)
+
+
+def feat_abcd(mask: np.ndarray, hsv: np.ndarray) -> np.ndarray:
+    """5-dim ABCD dermoscopy features (asymmetry, compactness, cvar, diam, elong)."""
+    cnts, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    if not cnts:
+        return np.zeros(5, dtype=np.float32)
+    cnt = max(cnts, key=cv2.contourArea)
+    area = cv2.contourArea(cnt) + 1e-6
+    perim = cv2.arcLength(cnt, True) + 1e-6
+    if len(cnt) >= 5:
+        axes_sorted = sorted(cv2.fitEllipse(cnt)[1])
+        asym = axes_sorted[0] / (axes_sorted[1] + 1e-6)
+    else:
+        asym = 1.0
+    comp = (4 * np.pi * area) / (perim ** 2)
+    hue_pixels = hsv[:, :, 0][mask > 0]
+    cvar = float(hue_pixels.std()) if hue_pixels.size else 0.0
+    diam = np.sqrt(4 * area / np.pi)
+    elong = perim / (2 * np.sqrt(np.pi * area) + 1e-6)
+    return np.array([asym, comp, cvar, diam, elong], dtype=np.float32)
+
+
+# ── Full 120D extraction ───────────────────────────────────────────────────────
+
+def extract_features(img_bgr: np.ndarray) -> np.ndarray:
+    """
+    Full pipeline: preprocess → mask → 120D feature vector.
+
+    Input : BGR image (any size)
+    Output: float32 ndarray of shape (120,)
+    """
+    proc = preprocess(img_bgr)                         # 256×256 BGR
+    mask = get_mask(proc)                              # binary mask
+    gray = cv2.cvtColor(proc, cv2.COLOR_BGR2GRAY)
+    hsv  = cv2.cvtColor(proc, cv2.COLOR_BGR2HSV)
+
+    vec = np.concatenate([
+        feat_glcm(gray),                               # 24
+        feat_lbp(gray),                                # 26
+        feat_gabor(gray),                              # 24
+        feat_colour(proc, mask),                       # 32
+        feat_colour_moments(proc, mask),               # 9
+        feat_abcd(mask, hsv),                          # 5
+    ]).astype(np.float32)
+
+    assert vec.shape == (120,), f"Expected 120 dims, got {vec.shape}"
+    return vec

inference.py

@@ -0,0 +1,99 @@
+"""
+inference.py — ONNX Runtime wrapper for the Random Forest model.
+
+Expected model: final_model_Random_Forest.onnx
+  Input  : float_input  [None, 120]  float32  (raw features — no scaling needed)
+  Outputs: label        [None]       int64
+           probabilities [None, 3]   float32
+"""
+
+from pathlib import Path
+from threading import Lock
+
+import numpy as np
+import onnxruntime as rt
+
+MODEL_PATH = Path(__file__).parent / "model" / "final_model_Random_Forest.onnx"
+
+CLASS_NAMES = {
+    0: "Common / Benign Nevi",
+    1: "Atypical / Other Benign",
+    2: "Melanoma (Suspected)",
+}
+
+CLASS_RISK = {
+    0: "healthy",
+    1: "watch",
+    2: "danger",
+}
+
+CLASS_WHAT = {
+    0: "A common benign mole. Melanocytic nevi are very common — most adults have 10–40. Almost always completely harmless.",
+    1: "This category includes atypical or other benign lesions such as seborrhoeic keratosis, actinic keratosis, dermatofibroma, or vascular lesions. While many are harmless, some may need treatment.",
+    2: "Melanoma is the most serious type of skin cancer. It develops from pigment-producing cells. Early detection is critical — when caught early, treatment is highly effective.",
+}
+
+CLASS_ACTION = {
+    0: "No action needed. Monitor for changes in shape, colour, size, or bleeding.",
+    1: "Recommended: book a consultation with a dermatologist for professional evaluation.",
+    2: "Please see a dermatologist or doctor as soon as possible. Do not delay.",
+}
+
+_session = None
+_session_lock = Lock()
+
+def load_model() -> rt.InferenceSession:
+    """Load ONNX model (cached after first call)."""
+    global _session
+    if _session is None:
+        with _session_lock:
+            if _session is None:
+                if not MODEL_PATH.exists():
+                    raise FileNotFoundError(
+                        f"ONNX model not found at {MODEL_PATH}. "
+                        "Please copy final_model_Random_Forest.onnx into backend/models/"
+                    )
+                opts = rt.SessionOptions()
+                opts.intra_op_num_threads = 4
+                _session = rt.InferenceSession(str(MODEL_PATH), sess_options=opts)
+    return _session
+
+
+def predict(features: np.ndarray) -> dict:
+    """
+    Run ONNX inference on a (120,) or (1, 120) feature vector.
+
+    Returns:
+        {
+            "label":         int,          # 0, 1, or 2
+            "class_name":    str,
+            "risk":          str,          # healthy / watch / danger
+            "probabilities": [p0, p1, p2], # float list, sums to 1
+            "confidence":    float,        # max probability
+            "what":          str,          # plain-language explanation
+            "action":        str,          # recommended next step
+        }
+    """
+    sess = load_model()
+    if features.ndim == 1:
+        features = features.reshape(1, -1)
+    features = features.astype(np.float32)
+
+    label_arr, prob_arr = sess.run(
+        ["label", "probabilities"],
+        {"float_input": features}
+    )
+    label = int(label_arr[0])
+    probs = prob_arr[0].tolist()
+    if label not in CLASS_NAMES:
+        raise ValueError(f"Model returned unexpected label {label}; probabilities={probs}")
+
+    return {
+        "label":         label,
+        "class_name":    CLASS_NAMES[label],
+        "risk":          CLASS_RISK[label],
+        "probabilities": probs,
+        "confidence":    float(max(probs)),
+        "what":          CLASS_WHAT[label],
+        "action":        CLASS_ACTION[label],
+    }

main.py

@@ -0,0 +1,157 @@
+"""
+main.py — DermaAI FastAPI backend.
+
+Endpoints:
+  GET  /api/health   — health check + model status
+  POST /api/analyze  — upload image → 120D features → ONNX → JSON result
+"""
+
+import io
+import logging
+import time
+from contextlib import asynccontextmanager
+
+import cv2
+import numpy as np
+from fastapi import FastAPI, File, HTTPException, UploadFile
+from fastapi.middleware.cors import CORSMiddleware
+from PIL import Image, UnidentifiedImageError
+
+from features import extract_features
+from inference import load_model, predict
+
+logger = logging.getLogger(__name__)
+
+
+# ── Lifespan: pre-load model on startup ───────────────────────────────────────
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    try:
+        load_model()
+        print("✅ Random Forest ONNX model loaded successfully.")
+    except FileNotFoundError as e:
+        print(f"⚠️  {e}")
+    yield
+
+
+# ── App ───────────────────────────────────────────────────────────────────────
+
+app = FastAPI(
+    title="DermaAI API",
+    description="Skin disease detection using Random Forest ONNX + 120D CV features",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["https://comvisproject.vercel.app/"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+ALLOWED_IMAGE_FORMATS = {"JPEG", "PNG", "BMP", "WEBP"}
+MAX_SIZE_MB = 10
+MAX_SIZE_BYTES = MAX_SIZE_MB * 1024 * 1024
+UPLOAD_CHUNK_SIZE = 1024 * 1024
+
+
+class InvalidImageError(ValueError):
+    """Raised when uploaded bytes are not a supported image."""
+
+
+def decode_image(data: bytes) -> np.ndarray:
+    """Decode uploaded bytes → BGR ndarray."""
+    try:
+        with Image.open(io.BytesIO(data)) as pil:
+            if pil.format not in ALLOWED_IMAGE_FORMATS:
+                raise InvalidImageError("Unsupported image format. Use JPEG, PNG, BMP, or WEBP.")
+            rgb = pil.convert("RGB")
+    except InvalidImageError:
+        raise
+    except (Image.DecompressionBombError, OSError, UnidentifiedImageError) as exc:
+        raise InvalidImageError("Invalid image data. Upload a valid image file.") from exc
+
+    bgr = cv2.cvtColor(np.array(rgb), cv2.COLOR_RGB2BGR)
+    return bgr
+
+
+async def read_limited_upload(file: UploadFile) -> bytes:
+    """Read an upload while enforcing the configured byte limit."""
+    data = bytearray()
+    while chunk := await file.read(UPLOAD_CHUNK_SIZE):
+        if len(data) + len(chunk) > MAX_SIZE_BYTES:
+            raise HTTPException(status_code=400, detail=f"File too large (max {MAX_SIZE_MB} MB).")
+        data.extend(chunk)
+    return bytes(data)
+
+
+# ── Routes ────────────────────────────────────────────────────────────────────
+
+@app.get("/api/health")
+def health():
+    """Health check — confirms API and model status."""
+    try:
+        load_model()
+        model_ok = True
+    except Exception:
+        model_ok = False
+    return {
+        "status": "ok",
+        "model_loaded": model_ok,
+        "model": "final_model_Random_Forest.onnx",
+        "features": "120D (GLCM 24 + LBP 26 + Gabor 24 + ColourHist 32 + ColourMoments 9 + ABCD 5)",
+    }
+
+
+@app.post("/api/analyze")
+async def analyze(file: UploadFile = File(...)):
+    """
+    Upload a skin image and receive classification results.
+
+    Pipeline:
+      1. Decode image
+      2. Preprocess: hair removal → Gaussian blur → CLAHE → resize 256×256
+      3. Otsu segmentation mask
+      4. 120D feature extraction
+      5. ONNX Random Forest inference
+      6. Return label, probabilities, plain-language explanation
+    """
+    raw = await read_limited_upload(file)
+
+    try:
+        t0 = time.perf_counter()
+
+        # Decode
+        img_bgr = decode_image(raw)
+
+        # Feature extraction (preprocess + mask + 120D)
+        features = extract_features(img_bgr)
+
+        # ONNX inference
+        result = predict(features)
+
+        elapsed_ms = round((time.perf_counter() - t0) * 1000)
+
+        return {
+            **result,
+            "filename":    file.filename,
+            "elapsed_ms":  elapsed_ms,
+            "feature_dims": 120,
+        }
+
+    except FileNotFoundError as e:
+        raise HTTPException(status_code=503, detail=str(e))
+    except InvalidImageError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except Exception as e:
+        logger.exception("Feature extraction or inference failed")
+        raise HTTPException(
+            status_code=500,
+            detail="Feature extraction or inference failed."
+        ) from e

model/final_model_Random_Forest.onnx

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

pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "backend"
+version = "0.1.0"
+description = "FastAPI backend for dermoscopic lesion classification with CV features and ONNX inference"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "fastapi~=0.136.1",
+    "numpy>=2.4,<3.0",
+    "onnxruntime~=1.26.0",
+    "opencv-python-headless~=4.13.0.92",
+    "pillow~=12.2.0",
+    "python-multipart~=0.0.29",
+    "scikit-image~=0.26.0",
+    "uvicorn[standard]>=0.47,<0.48",
+]

requirements.txt

@@ -0,0 +1,8 @@
+fastapi~=0.136.1
+uvicorn[standard]>=0.47,<0.48
+python-multipart~=0.0.29
+onnxruntime~=1.26.0
+opencv-python-headless~=4.13.0.92
+scikit-image~=0.26.0
+numpy>=2.4,<3.0
+Pillow~=12.2.0