Upload folder using huggingface_hub

.gitignore

@@ -2,3 +2,8 @@
 *.pyc
 gradio_cached_examples/*
 gradio_queue.db*
+
+# Model weights live in the private DeepNAPSI/DeepNAPSI-model HF Hub repo.
+# They are downloaded at runtime via hf_hub_download (xet-backed).
+# Never commit the ONNX file to this Space repo.
+model/

.ruff_cache/.gitignore

@@ -0,0 +1,2 @@
+# Automatically created by ruff.
+*

.ruff_cache/CACHEDIR.TAG

@@ -0,0 +1 @@
+Signature: 8a477f597d28d172789f06886806bc55

README.md

@@ -4,8 +4,13 @@ emoji: 🤚
 colorFrom: blue
 colorTo: purple
 sdk: gradio
-sdk_version: 5.47.2
-python_version: 3.12
-app_file: entrypoint.py
+sdk_version: 6.9.0
+python_version: "3.12"
+app_file: app.py
 pinned: false
+secrets:
+  - name: DEEPNAPSI_HF_TOKEN
+    description: >
+      Read token for the private DeepNAPSI/DeepNAPSI-model repo.
+      The model is downloaded once on startup via huggingface_hub (xet-backed).
 ---

app.py

@@ -1,77 +1,128 @@
+"""
+DeepNAPSI – automated NAPSI scoring from a hand photo.
+
+Gradio 6.x Blocks UI.  Model: BEiT-base-384 quantised to INT8 ONNX.
+"""
+
+from __future__ import annotations
+
+import numpy as np
 import gradio as gr
 
-from backend import Infer
-
-
-DEBUG = False
-
-infer = Infer(DEBUG)
-example_image_path = [
-    "assets/example_1.jpg",
-    "assets/example_2.jpg",
-    "assets/example_3.jpg",
-]
-
-outputs = [
-    gr.Image(label="Thumb"),
-    gr.Number(label="DeepNAPSI Thumb", precision=0),
-    gr.Image(label="Index"),
-    gr.Number(label="DeepNAPSI Index", precision=0),
-    gr.Image(label="Middle"),
-    gr.Number(label="DeepNAPSI Middle", precision=0),
-    gr.Image(label="Ring"),
-    gr.Number(label="DeepNAPSI Ring", precision=0),
-    gr.Image(label="Pinky"),
-    gr.Number(label="DeepNAPSI Pinky", precision=0),
-    gr.Number(label="DeepNAPSI Sum", precision=0),
-]
-
-with gr.Blocks(analytics_enabled=False, title="DeepNAPSI") as demo:
-    with gr.Column():
-        gr.Markdown("## Welcome to the DeepNAPSI application!")
-        gr.Markdown(
-            "Upload an image of the one hand and click **Predict NAPSI** to see the output."
-        )
-        gr.Markdown(
-            "*Note*: Make sure there are no identifying information present in the image. The prediction can take up to 4.5 minutes."
-        )
-        gr.Markdown(
-            "*Note*: This is not a medical product and cannot be used for a patient diagnosis in any way."
-        )
-        with gr.Column():
-            with gr.Row():
-                with gr.Column():
-                    with gr.Row():
-                        image_input = gr.Image()
-                        example_images = gr.Examples(
-                            example_image_path,
-                            image_input,
-                            outputs,
-                            fn=infer.predict,
-                            cache_examples=True,
-                        )
-                    with gr.Row():
-                        image_button = gr.Button("Predict NAPSI")
-                    with gr.Row():
-                        with gr.Column():
-                            outputs[0].render()
-                            outputs[1].render()
-                        with gr.Column():
-                            outputs[2].render()
-                            outputs[3].render()
-                        with gr.Column():
-                            outputs[4].render()
-                            outputs[5].render()
-                        with gr.Column():
-                            outputs[6].render()
-                            outputs[7].render()
-                        with gr.Column():
-                            outputs[8].render()
-                            outputs[9].render()
-                        outputs[10].render()
-        image_button.click(infer.predict, inputs=image_input, outputs=outputs)
-
-demo.launch(
-    share=True if DEBUG else False,
-    favicon_path="assets/favicon-32x32.png",
+from backend import Backend, FINGER_NAMES
+
+# ---------------------------------------------------------------------------
+# Load model once at startup
+# ---------------------------------------------------------------------------
+
+backend = Backend()
+
+NAPSI_DESC = (
+    "**NAPSI (Nail Psoriasis Severity Index)** scores each nail 0–4 based "
+    "on nail-bed and nail-matrix changes. The total score across all 10 nails "
+    "ranges from 0 (no disease) to 40 (maximum disease)."
+)
+
+DISCLAIMER = (
+    "⚠️ **Not a medical product.** This tool is for research purposes only and "
+    "must not be used for patient diagnosis or treatment decisions."
 )
+
+# ---------------------------------------------------------------------------
+# Predict function
+# ---------------------------------------------------------------------------
+
+def predict(image: np.ndarray):
+    """Called by Gradio on button click or example selection."""
+    if image is None:
+        empty = np.zeros((64, 64, 3), dtype=np.uint8)
+        return (
+            empty,                     # annotated image
+            *([empty, "–"] * 5),       # 5× (nail crop, score label)
+            "–",                       # total
+            "Please upload an image.",
+        )
+
+    result = backend.predict(image)
+
+    outputs = [result["annotated_image"]]
+    for nail_img, score in zip(result["nails"], result["napsi_scores"]):
+        outputs.append(nail_img)
+        outputs.append(str(score) if score >= 0 else "–")
+
+    total = result["napsi_sum"]
+    outputs.append(str(total) if total >= 0 else "–")
+    outputs.append(result["error"] or "")
+    return tuple(outputs)
+
+
+# ---------------------------------------------------------------------------
+# UI
+# ---------------------------------------------------------------------------
+
+with gr.Blocks(
+    title="DeepNAPSI",
+    analytics_enabled=False,
+) as demo:
+    gr.Markdown("# 🤚 DeepNAPSI")
+    gr.Markdown(NAPSI_DESC)
+    gr.Markdown(DISCLAIMER)
+
+    # ── Top row: input + annotated hand at equal size ─────────────────────
+    with gr.Row():
+        with gr.Column(scale=1):
+            image_input = gr.Image(
+                label="Hand photo",
+                type="numpy",
+                sources=["upload", "clipboard", "webcam"],
+            )
+            predict_btn = gr.Button("Predict NAPSI", variant="primary")
+
+            gr.Examples(
+                examples=[
+                    ["assets/example_1.jpg"],
+                    ["assets/example_2.jpg"],
+                    ["assets/example_3.jpg"],
+                ],
+                inputs=image_input,
+                label="Example images",
+            )
+
+        with gr.Column(scale=1):
+            annotated_out = gr.Image(
+                label="Detected hand",
+                type="numpy",
+                interactive=False,
+            )
+
+    # ── Bottom rows: nail crops + scores ──────────────────────────────────
+    with gr.Row():
+        nail_images = [gr.Image(label=f, type="numpy", interactive=False, height=160) for f in FINGER_NAMES]
+    with gr.Row():
+        nail_scores = [gr.Textbox(label=f"NAPSI {f}", interactive=False) for f in FINGER_NAMES]
+
+    with gr.Row():
+        total_score = gr.Textbox(label="DeepNAPSI Total (one hand, 0–20)", interactive=False)
+
+    error_box = gr.Textbox(label="Status", interactive=False, visible=True)
+
+    # Wire outputs into a flat list matching predict() return order
+    all_outputs = (
+        [annotated_out]
+        + [x for pair in zip(nail_images, nail_scores) for x in pair]
+        + [total_score, error_box]
+    )
+
+    predict_btn.click(fn=predict, inputs=image_input, outputs=all_outputs)
+
+# ---------------------------------------------------------------------------
+# Launch
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    demo.launch(
+        server_name="0.0.0.0",
+        favicon_path="assets/favicon-32x32.png",
+        theme=gr.themes.Soft(),
+    )
+

backend.py

@@ -1,31 +1,184 @@
-import torch
+"""
+ONNX Runtime inference backend for DeepNAPSI.
+
+Uses the dynamically-quantised INT8 BEiT model for fast CPU inference.
+The model is expected at model/model_int8.onnx (committed to the repo via
+Git LFS). If that file is absent it is downloaded from the HF Hub.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import List
+
 import cv2
 import numpy as np
-from nail_detection.main import get_nails
-
-from Model import Model
-
-
-class Infer:
-    def __init__(self, DEBUG):
-        # self.model = load_dummy_model(DEBUG)
-        self.model = Model(DEBUG)
-
-    def predict(self, data):
-        nails = get_nails(cv2.cvtColor(data, cv2.COLOR_RGB2BGR))
-        predictions = []
-        if nails is None:
-            for _ in range(5):
-                predictions.append(np.zeros((64, 64, 3)))
-                predictions.append(-1)
-            predictions.append("-1")
-        else:
-            model_prediction, _ = self.model(nails)
-            model_prediction = model_prediction[0]
-            napsi_predictions = torch.argmax(model_prediction, 1)
-            napsi_sum = int(napsi_predictions.sum().detach().cpu())
-            for napsi_prediction, nail in zip(napsi_predictions, nails):
-                predictions.append(nail)
-                predictions.append(int(napsi_prediction.detach().cpu()))
-        predictions.append(napsi_sum)
-        return predictions
+import onnxruntime as ort
+from PIL import Image
+
+from nail_detection import get_nails_and_landmarks, draw_hand
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+
+MODEL_LOCAL = Path(os.environ.get("DEEPNAPSI_MODEL_PATH", "")) or Path(__file__).parent / "model" / "model_int8.onnx"
+HF_REPO_ID  = os.environ.get("DEEPNAPSI_HF_REPO", "lfolle/DeepNAPSIModel")
+HF_FILENAME = "model_int8.onnx"
+
+# BEiT preprocessing parameters (from timm resolve_data_config)
+INPUT_SIZE  = 384
+MEAN        = np.array([0.5, 0.5, 0.5], dtype=np.float32)
+STD         = np.array([0.5, 0.5, 0.5], dtype=np.float32)
+
+FINGER_NAMES = ["Thumb", "Index", "Middle", "Ring", "Pinky"]
+NUM_CLASSES  = 5
+NUM_THREADS  = int(os.environ.get("ORT_NUM_THREADS", "16"))
+
+
+# ---------------------------------------------------------------------------
+# Model loading
+# ---------------------------------------------------------------------------
+
+def _get_model_path() -> Path:
+    # Env-var override (useful for local dev pointing at hf_space/model/)
+    env_path = os.environ.get("DEEPNAPSI_MODEL_PATH", "")
+    if env_path and Path(env_path).exists():
+        return Path(env_path)
+    # Default local path (committed to Space via Git LFS, or pre-downloaded)
+    if MODEL_LOCAL.exists():
+        return MODEL_LOCAL
+    # Fallback: download from private HF Hub model repo.
+    # Requires DEEPNAPSI_HF_TOKEN env var (set as a Space secret).
+    from huggingface_hub import hf_hub_download
+    token = os.environ.get("DEEPNAPSI_HF_TOKEN")
+    if not token:
+        raise FileNotFoundError(
+            f"Model not found at {MODEL_LOCAL} and DEEPNAPSI_HF_TOKEN is not set. "
+            "Either commit the model file to the Space or set the secret."
+        )
+    print(f"[backend] Downloading model from private repo {HF_REPO_ID} …")
+    path = hf_hub_download(HF_REPO_ID, HF_FILENAME, token=token)
+    return Path(path)
+
+
+def _build_session(model_path: Path) -> ort.InferenceSession:
+    opts = ort.SessionOptions()
+    opts.intra_op_num_threads = NUM_THREADS
+    opts.inter_op_num_threads = NUM_THREADS
+    opts.execution_mode = ort.ExecutionMode.ORT_PARALLEL
+    opts.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+    return ort.InferenceSession(
+        str(model_path),
+        sess_options=opts,
+        providers=["CPUExecutionProvider"],
+    )
+
+
+# ---------------------------------------------------------------------------
+# Preprocessing (replaces timm transforms, no heavy ML dependency at serve time)
+# ---------------------------------------------------------------------------
+
+def _preprocess(nail_rgb: np.ndarray) -> np.ndarray:
+    """
+    Resize → CenterCrop → ToTensor → Normalize, matching BEiT training config.
+    Returns float32 array [1, 3, 384, 384].
+    """
+    img = Image.fromarray(nail_rgb).convert("RGB")
+    # Resize shortest side to INPUT_SIZE with bicubic
+    w, h = img.size
+    scale = INPUT_SIZE / min(w, h)
+    new_w, new_h = max(INPUT_SIZE, round(w * scale)), max(INPUT_SIZE, round(h * scale))
+    img = img.resize((new_w, new_h), Image.BICUBIC)
+    # CenterCrop
+    left = (new_w - INPUT_SIZE) // 2
+    top  = (new_h - INPUT_SIZE) // 2
+    img  = img.crop((left, top, left + INPUT_SIZE, top + INPUT_SIZE))
+    # To float [0,1], normalise
+    arr = np.asarray(img, dtype=np.float32) / 255.0
+    arr = (arr - MEAN) / STD
+    return arr.transpose(2, 0, 1)[None]  # [1, C, H, W]
+
+
+# ---------------------------------------------------------------------------
+# Inference with 3-view TTA
+# ---------------------------------------------------------------------------
+
+def _tta_logits(session: ort.InferenceSession, pixel_values: np.ndarray) -> np.ndarray:
+    """Average logits over original + hflip + vflip views."""
+    views = [
+        pixel_values,
+        pixel_values[:, :, :, ::-1].copy(),  # horizontal flip
+        pixel_values[:, :, ::-1, :].copy(),  # vertical flip
+    ]
+    logits = np.stack(
+        [session.run(None, {"pixel_values": v})[0] for v in views]
+    ).mean(axis=0)
+    return logits  # [B, 5]
+
+
+# ---------------------------------------------------------------------------
+# Top-level backend class
+# ---------------------------------------------------------------------------
+
+class Backend:
+    def __init__(self) -> None:
+        model_path = _get_model_path()
+        self._session = _build_session(model_path)
+        print(f"[backend] Loaded model from {model_path} with {NUM_THREADS} ORT threads.")
+
+    def predict(self, image_rgb: np.ndarray) -> dict:
+        """
+        Run the full DeepNAPSI pipeline on a hand image.
+
+        Args:
+            image_rgb: HxWx3 uint8 RGB array (Gradio default).
+
+        Returns:
+            dict with keys:
+              annotated_image  – RGB image with hand skeleton drawn
+              nails            – list of 5 RGB nail crop arrays
+              napsi_scores     – list of 5 int NAPSI predictions (0-4)
+              napsi_sum        – int, sum of all 5 scores
+              error            – str | None
+        """
+        image_bgr = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2BGR)
+        nails, landmarks = get_nails_and_landmarks(image_bgr)
+
+        if nails is None or landmarks is None:
+            return {
+                "annotated_image": image_rgb,
+                "nails":           [np.zeros((64, 64, 3), dtype=np.uint8)] * 5,
+                "napsi_scores":    [-1] * 5,
+                "napsi_sum":       -1,
+                "error":           "No hand detected. Please upload a clear photo of one hand.",
+            }
+
+        # Draw skeleton on a copy
+        annotated = image_bgr.copy()
+        draw_hand(annotated, landmarks)
+        annotated_rgb = cv2.cvtColor(annotated, cv2.COLOR_BGR2RGB)
+
+        # Run classification on all 5 nails
+        napsi_scores: List[int] = []
+        nail_rgbs:    List[np.ndarray] = []
+
+        for nail_bgr in nails:
+            # Nail crops come out as RGB from extract_nails (already BGR→RGB swapped inside)
+            nail_rgb = nail_bgr  # already RGB after the ::-1 flip in extract_nails
+            nail_rgbs.append(nail_rgb)
+
+            pixel_values = _preprocess(nail_rgb)
+            logits = _tta_logits(self._session, pixel_values)  # [1, 5]
+            pred   = int(np.argmax(logits, axis=-1)[0])
+            napsi_scores.append(pred)
+
+        return {
+            "annotated_image": annotated_rgb,
+            "nails":           nail_rgbs,
+            "napsi_scores":    napsi_scores,
+            "napsi_sum":       sum(napsi_scores),
+            "error":           None,
+        }
+

entrypoint.py

@@ -1,18 +1,3 @@
-import os
-import sys
-import subprocess
-import git
-
-repo_url = (
-    f"https://oauth2:{os.getenv('HANDKIGIT5')}@git5.cs.fau.de/folle/hand-ki-model.git"
-)
-repo_path = "repos/hand-ki-model"
-if not os.path.exists(repo_path):
-    git.Repo.clone_from(repo_url, repo_path)
-
-subprocess.check_call([sys.executable, "-m", "pip", "install", "repos/hand-ki-model/"])
-subprocess.check_call(
-    [sys.executable, "-m", "pip", "install", "mediapipe==0.10.14", "numpy<2.0"]
-)
-
-import app  # noqa: E402, F401
+# entrypoint.py is kept for backward compatibility only.
+# The Space now uses app_file: app.py directly (see README.md).
+import app  # noqa: F401

nail_detection.py

@@ -0,0 +1,180 @@
+"""
+Self-contained nail detection pipeline.
+
+Inlined from hand-ki-model so that the HF Space has no git-clone dependency.
+Source: nail_detection/{main,hand_detection,extract_nails}.py + utils/{rotate,polygon,angle,valid_crop,draw_hand}.py
+"""
+
+from __future__ import annotations
+
+import math
+from typing import List
+
+import cv2
+import mediapipe as mp
+import numpy as np
+from PIL import Image, ImageDraw
+from scipy import ndimage
+
+
+# ---------------------------------------------------------------------------
+# Geometry helpers (from utils/)
+# ---------------------------------------------------------------------------
+
+def _rotate(origin, point, angle: float):
+    """Rotate *point* counter-clockwise by *angle* (radians) around *origin*."""
+    ox, oy = origin
+    px, py = point
+    qx = ox + math.cos(angle) * (px - ox) - math.sin(angle) * (py - oy)
+    qy = oy + math.sin(angle) * (px - ox) + math.cos(angle) * (py - oy)
+    return qx, qy
+
+
+def _unit_vector(v):
+    return v / np.linalg.norm(v)
+
+
+def _angle_between(v1, v2) -> float:
+    return float(np.arccos(np.clip(np.dot(_unit_vector(v1), _unit_vector(v2)), -1.0, 1.0)))
+
+
+def _get_polygon_mask(width: int, height: int, polygon_idx) -> np.ndarray:
+    polygon_idx = [tuple(xy) for xy in polygon_idx]
+    img = Image.new("L", (width, height), 0)
+    ImageDraw.Draw(img).polygon(polygon_idx, outline=1, fill=1)
+    return np.array(img)
+
+
+def _valid_crop(image: np.ndarray, mask: np.ndarray, offset: int = 10):
+    true_points = np.argwhere(mask)
+    top_left = true_points.min(axis=0)
+    bottom_right = true_points.max(axis=0)
+    x_low = max(top_left[0] - offset, 0)
+    x_high = min(bottom_right[0] + offset, image.shape[0])
+    y_low = max(top_left[1] - offset, 0)
+    y_high = min(bottom_right[1] + offset + 1, image.shape[1])
+    return image[x_low:x_high, y_low:y_high], mask[x_low:x_high, y_low:y_high]
+
+
+# ---------------------------------------------------------------------------
+# Hand detection (from nail_detection/hand_detection.py)
+# ---------------------------------------------------------------------------
+
+def detect_hand(image: np.ndarray):
+    """Return MediaPipe hand landmarks for the first detected hand, or None."""
+    mp_hands = mp.solutions.hands
+    with mp_hands.Hands(
+        static_image_mode=True, max_num_hands=1, min_detection_confidence=0.0
+    ) as hands:
+        results = hands.process(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+        if results.multi_handedness is None:
+            return None
+        return results.multi_hand_landmarks[0]
+
+
+# ---------------------------------------------------------------------------
+# Nail extraction (from nail_detection/extract_nails.py)
+# ---------------------------------------------------------------------------
+
+def extract_nails(image: np.ndarray, hand_landmarks) -> List[np.ndarray]:
+    """Return list of 5 nail crop arrays (thumb → pinky), BGR."""
+    mp_hands = mp.solutions.hands
+    image_height, image_width, _ = image.shape
+    nails: List[np.ndarray] = []
+
+    for tip in [
+        mp_hands.HandLandmark.THUMB_TIP,
+        mp_hands.HandLandmark.INDEX_FINGER_TIP,
+        mp_hands.HandLandmark.MIDDLE_FINGER_TIP,
+        mp_hands.HandLandmark.RING_FINGER_TIP,
+        mp_hands.HandLandmark.PINKY_TIP,
+    ]:
+        tip_coords = np.array([
+            hand_landmarks.landmark[tip].x * image_width,
+            hand_landmarks.landmark[tip].y * image_height,
+        ])
+        dip_coords = np.array([
+            hand_landmarks.landmark[tip - 1].x * image_width,
+            hand_landmarks.landmark[tip - 1].y * image_height,
+        ])
+        dt = tip_coords - dip_coords
+        ext = np.array([tip_coords + 3 / 4 * dt, tip_coords - 3 / 4 * dt])
+
+        origin = 0.5 * (ext[0] - ext[1]) + ext[1]
+        orth_p1 = _rotate(origin, ext[0], np.deg2rad(90))
+        orth_p2 = _rotate(origin, ext[1], np.deg2rad(90))
+        orth = np.array([orth_p1, orth_p2])
+
+        half = 0.5 * (ext[0] - ext[1])
+        p1 = orth[0] + half
+        p2 = orth[0] - half
+        p3 = orth[1] + half
+        p4 = orth[1] - half
+
+        angle = 90 - np.rad2deg(_angle_between(ext[0] - ext[1], [1, 0]))
+
+        mask = _get_polygon_mask(image_width, image_height, [p2, p1, p3, p4])
+        mask3 = np.tile(mask[:, :, None], (1, 1, 3))
+        masked = mask3 * image[:, :, ::-1]
+
+        masked, mask3 = _valid_crop(masked, mask3)
+        masked = ndimage.rotate(masked, angle)
+        mask3 = ndimage.rotate(mask3, angle)
+        masked, mask3 = _valid_crop(masked, mask3, offset=0)
+        masked = masked[5:-5, 5:-5]
+        masked = np.ascontiguousarray(masked)
+        nails.append(masked)
+
+    return nails
+
+
+# ---------------------------------------------------------------------------
+# Draw hand skeleton (from utils/draw_hand.py)
+# ---------------------------------------------------------------------------
+
+def draw_hand(annotated_image: np.ndarray, hand_landmarks) -> None:
+    mp_drawing = mp.solutions.drawing_utils
+    mp_drawing_styles = mp.solutions.drawing_styles
+    mp_hands = mp.solutions.hands
+    mp_drawing.draw_landmarks(
+        annotated_image,
+        hand_landmarks,
+        mp_hands.HAND_CONNECTIONS,
+        mp_drawing_styles.get_default_hand_landmarks_style(),
+        mp_drawing_styles.get_default_hand_connections_style(),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Top-level entry point
+# ---------------------------------------------------------------------------
+
+def get_nails_and_landmarks(image_bgr: np.ndarray):
+    """
+    Detect hand and extract all 5 nail crops.
+
+    Args:
+        image_bgr: BGR image as numpy array (as returned by cv2.imread or
+                   cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)).
+
+    Returns:
+        (nails, hand_landmarks) or (None, None) if no hand detected.
+    """
+    if image_bgr.shape[0] < image_bgr.shape[1]:  # landscape → rotate
+        image_bgr = cv2.rotate(image_bgr, cv2.ROTATE_90_CLOCKWISE)
+
+    landmarks = detect_hand(image_bgr)
+    if landmarks is None:
+        return None, None
+
+    # Flip upside-down images
+    mp_hands = mp.solutions.hands
+    if (
+        landmarks.landmark[mp_hands.HandLandmark.MIDDLE_FINGER_PIP].y
+        < landmarks.landmark[mp_hands.HandLandmark.MIDDLE_FINGER_TIP].y
+    ):
+        image_bgr = cv2.rotate(image_bgr, cv2.ROTATE_180)
+        landmarks = detect_hand(image_bgr)
+
+    nails = extract_nails(image_bgr, landmarks)
+    return nails, landmarks

requirements.txt

@@ -1,9 +1,22 @@
-gitpython==3.1.45
-gradio
-httpx
-huggingface_hub
-pingouin
-pyheif
-seaborn
-setuptools<50
-timm==0.6.7
+# Pinned for reproducibility – generated 2026-03-15
+# Re-pin with: pip-compile or manually after testing
+
+# Inference runtime (CPU)
+onnxruntime==1.24.3
+
+# Image processing & nail detection
+mediapipe==0.10.14
+opencv-python==4.11.0.86
+Pillow==11.3.0
+scipy==1.16.2
+numpy==1.26.4
+
+# HuggingFace ecosystem
+# hf_xet is a dependency of huggingface-hub; listed explicitly so the Space
+# runner picks it up and hf_hub_download can use xet chunked downloads from
+# the private model repo automatically.
+huggingface-hub==0.34.4
+hf-xet==1.1.10
+
+# UI
+gradio==6.9.0