Upload 3 files

Dockerfile

@@ -2,21 +2,29 @@ FROM python:3.10-slim
 
 WORKDIR /app
 
-# Install system dependencies required for OpenCV
+# System dependencies for OpenCV
 RUN apt-get update && apt-get install -y \
     libgl1 \
     libglib2.0-0 \
+    git \
     && rm -rf /var/lib/apt/lists/*
 
-# Install python dependencies
+# Clone the MiVOLO repository
+RUN git clone https://github.com/WildChlamydia/MiVOLO.git /app/mivolo_repo
+
+# Install PyTorch CPU-only (much lighter than full GPU build)
+RUN pip install --no-cache-dir torch torchvision --index-url https://download.pytorch.org/whl/cpu
+
+# Install remaining API dependencies
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-# Copy app code
+# Copy our API entrypoint
 COPY app.py .
 
-# Hugging Face Spaces expose port 7860
+# Hugging Face Spaces use port 7860
 EXPOSE 7860
 
-# Run the API
+# NOTE: We do NOT pre-load models here to avoid OOM during build.
+# Models download on the first API request at runtime (16GB RAM available).
 CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,15 +1,21 @@
-from fastapi import FastAPI, File, UploadFile, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from deepface import DeepFace
+import sys
+import os
 import cv2
 import numpy as np
 import tempfile
-import os
 import logging
+import argparse
+
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
 
-logging.getLogger('tf_keras').setLevel(logging.ERROR)
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-app = FastAPI(title="DeepFace Age Detection API — Hybrid Model")
+# Add the cloned MiVOLO repo to Python path
+sys.path.insert(0, '/app/mivolo_repo')
+
+app = FastAPI(title="MiVOLO Age & Gender Detection API")
 
 app.add_middleware(
     CORSMiddleware,
@@ -18,84 +24,111 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# --- HYBRID LOGIC ---
-# DeepFace/VGG-Face is unreliable for children under 15.
-# We remap those raw predictions to the nearest Adience bracket.
-CHILD_BRACKETS = [
-    (0, 2,  "0 - 2 yrs",  0.82),
-    (3, 6,  "4 - 6 yrs",  0.80),
-    (7, 14, "8 - 12 yrs", 0.72),
-]
+# Global predictor — loaded lazily on first request to avoid OOM during build
+predictor = None
+
+
+def get_predictor():
+    """
+    Lazy-loads the MiVOLO predictor on the first request.
+    Downloads model weights from Hugging Face Hub automatically.
+    """
+    global predictor
+    if predictor is not None:
+        return predictor
+
+    logger.info("Loading MiVOLO predictor for the first time...")
 
-def apply_hybrid_age_logic(deepface_age: int):
-    if deepface_age < 15:
-        for low, high, label, conf in CHILD_BRACKETS:
-            if low <= deepface_age <= high:
-                return label, conf, True
-        return "8 - 12 yrs", 0.68, True
+    from huggingface_hub import hf_hub_download
+    from mivolo.predictor import Predictor
 
-    # For adults (15+), trust DeepFace's exact regression number
-    corrected_age = deepface_age
-    if 15 <= deepface_age <= 25:
-        corrected_age = deepface_age + 1
-    elif deepface_age > 50:
-        corrected_age = deepface_age - 1
+    # Download the YOLOv8 person+face detector weights
+    detector_weights = hf_hub_download(
+        repo_id="WildChlamydia/MiVOLO_D1",
+        filename="yolov8x_person_face.pt"
+    )
 
-    return str(corrected_age), 0.92, False
+    # Download the MiVOLO age+gender estimator weights
+    checkpoint = hf_hub_download(
+        repo_id="WildChlamydia/MiVOLO_D1",
+        filename="mivolo_d1_age_gender.pth.tar"
+    )
+
+    # Build MiVOLO config
+    config = argparse.Namespace(
+        detector_weights=detector_weights,
+        checkpoint=checkpoint,
+        device="cpu",
+        with_persons=True,     # Use full-body context for better accuracy
+        disable_faces=False,   # Also use face features
+        draw=False
+    )
+
+    predictor = Predictor(config, verbose=False)
+    logger.info("MiVOLO predictor loaded successfully.")
+    return predictor
 
 
 @app.get("/")
-def read_root():
-    return {"status": "Hybrid DeepFace API is running!", "model": "VGG-Face + Adience Hybrid"}
+def health_check():
+    return {
+        "status": "MiVOLO API is running!",
+        "model": "MiVOLO D1 — State-of-the-Art Age & Gender Estimation"
+    }
 
 
 @app.post("/predict")
 async def predict_age_gender(file: UploadFile = File(...)):
     tmp_path = None
     try:
+        # Read and decode image
         contents = await file.read()
         nparr = np.frombuffer(contents, np.uint8)
         img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
 
         if img is None:
-            raise HTTPException(status_code=400, detail="Invalid image file uploaded.")
+            raise HTTPException(status_code=400, detail="Invalid or unreadable image file.")
 
-        # Write to a temp file so DeepFace receives a stable file path
+        # Write to temp file so MiVOLO can read it from disk
         with tempfile.NamedTemporaryFile(suffix=".jpg", delete=False) as tmp:
             tmp_path = tmp.name
             cv2.imwrite(tmp_path, img)
 
-        results = DeepFace.analyze(
-            img_path=tmp_path,
-            actions=['age', 'gender'],
-            enforce_detection=False,
-            detector_backend='opencv',
-            silent=True
-        )
+        # Run MiVOLO prediction
+        pred = get_predictor()
+        detected_objects, _ = pred.recognize(tmp_path)
+
+        if detected_objects is None or not detected_objects.ages:
+            raise HTTPException(
+                status_code=422,
+                detail="No face detected. Please use a clear, well-lit photo."
+            )
 
-        if isinstance(results, list):
-            result = results[0]
-        else:
-            result = results
+        # Take the primary (highest-confidence) detection
+        age = round(float(detected_objects.ages[0]))
+        gender_raw = detected_objects.genders[0]        # "male" or "female"
+        gender_score = float(detected_objects.gender_scores[0])
 
-        raw_age = result.get("age", 0)
-        gender = result.get("dominant_gender", "Unknown")
+        # Format gender to match dashboard expectations
+        gender = "Man" if gender_raw == "male" else "Woman"
 
-        display_age, confidence, is_child = apply_hybrid_age_logic(raw_age)
+        logger.info(f"MiVOLO Result — Age: {age}, Gender: {gender} ({gender_score:.2f})")
 
         return {
             "success": True,
-            "age": display_age,
+            "age": age,
             "gender": gender,
-            "confidence": confidence,
-            "model_used": "Adience Bracket (Child)" if is_child else "DeepFace VGG-Face (Adult)",
-            "raw_age": raw_age
+            "confidence": round(gender_score, 2),
+            "model_used": "MiVOLO D1"
         }
 
+    except HTTPException:
+        raise
     except Exception as e:
+        logger.error(f"Prediction error: {str(e)}")
         raise HTTPException(status_code=500, detail=str(e))
 
     finally:
-        # Always clean up the temp file
+        # Always clean up temp file
         if tmp_path and os.path.exists(tmp_path):
             os.remove(tmp_path)

requirements.txt

@@ -1,6 +1,8 @@
 fastapi==0.104.1
 uvicorn==0.24.0
 python-multipart==0.0.6
-deepface==0.0.79
-tensorflow==2.15.0
 opencv-python-headless==4.8.1.78
+timm>=0.9.2
+ultralytics>=8.0.0
+huggingface_hub>=0.19.0
+numpy<2.0