update: improving the face search system

Dockerfile

@@ -18,40 +18,41 @@ COPY . .
 
 RUN mkdir -p temp_uploads saved_images && chmod -R 777 temp_uploads saved_images
 
-# ── Pre-download ALL AI models at BUILD time ─────────────────────
-# Bakes weights into Docker image layer → cold start ~10 sec not 5 min
+# ── Pre-download ALL models at build time ───────────────────────
+# V3: Added InsightFace buffalo_sc (YuNet + ArcFace)
+# Replaces DeepFace + RetinaFace + GhostFaceNet entirely
 RUN python - <<'EOF'
-from transformers import AutoProcessor, AutoModel, AutoImageProcessor
-from ultralytics import YOLO
-from deepface import DeepFace
-import numpy as np
+import os
+os.environ["TRANSFORMERS_VERBOSITY"] = "error"
 
-print("Pre-downloading SigLIP …")
+print("Pre-downloading SigLIP...")
+from transformers import AutoProcessor, AutoModel
 AutoProcessor.from_pretrained("google/siglip-base-patch16-224", use_fast=True)
 AutoModel.from_pretrained("google/siglip-base-patch16-224")
+print("SigLIP done")
 
-print("Pre-downloading DINOv2 …")
+print("Pre-downloading DINOv2...")
+from transformers import AutoImageProcessor
 AutoImageProcessor.from_pretrained("facebook/dinov2-base")
 AutoModel.from_pretrained("facebook/dinov2-base")
+print("DINOv2 done")
 
-print("Pre-downloading YOLO (seg model) …")
-YOLO("yolo11n-seg.pt")   # ← FIXED: was yolo11n.pt, now yolo11n-seg.pt
+print("Pre-downloading YOLO seg...")
+from ultralytics import YOLO
+YOLO("yolo11n-seg.pt")
+print("YOLO done")
 
-print("Pre-downloading GhostFaceNet + RetinaFace …")
-dummy = np.zeros((112, 112, 3), dtype=np.uint8)
-try:
-    DeepFace.represent(img_path=dummy, model_name="GhostFaceNet",
-                       detector_backend="retinaface", enforce_detection=False)
-except Exception:
-    pass  # first run just downloads weights; inference error is fine
+print("Pre-downloading InsightFace buffalo_sc (YuNet + ArcFace)...")
+from insightface.app import FaceAnalysis
+app = FaceAnalysis(name="buffalo_sc", providers=["CPUExecutionProvider"])
+app.prepare(ctx_id=-1, det_size=(640, 640))
+print("InsightFace buffalo_sc done")
 
-print("✅ All models cached in image layer")
+print("All V3 models cached!")
 EOF
 
 EXPOSE 7860
 
-# ── Single worker — models are already in memory, no need for 2 ──
-# 2 workers was causing both to re-download yolo11n-seg.pt simultaneously
 ENV WEB_CONCURRENCY=1
 
 CMD uvicorn main:app \

main.py

@@ -327,9 +327,20 @@ async def upload_new_images(
             face_upserts, object_upserts = [], []
             for v in vectors:
                 vec_list = v["vector"].tolist() if hasattr(v["vector"], "tolist") else v["vector"]
-                record   = {"id": str(uuid.uuid4()), "values": vec_list,
-                            "metadata": {"url": image_url, "folder": folder}}
-                (face_upserts if v["type"] == "face" else object_upserts).append(record)
+                if v["type"] == "face":
+                    # V3: store per-face metadata including crop thumbnail + bbox
+                    metadata = {
+                        "url":        image_url,
+                        "folder":     folder,
+                        "face_idx":   v.get("face_idx", 0),
+                        "bbox":       str(v.get("bbox", [])),
+                        "face_crop":  v.get("face_crop", ""),  # base64 thumbnail
+                        "det_score":  v.get("det_score", 1.0),
+                    }
+                    face_upserts.append({"id": str(uuid.uuid4()), "values": vec_list, "metadata": metadata})
+                else:
+                    object_upserts.append({"id": str(uuid.uuid4()), "values": vec_list,
+                                           "metadata": {"url": image_url, "folder": folder}})
 
             face_vec_total   += len(face_upserts)
             object_vec_total += len(object_upserts)
@@ -436,22 +447,89 @@ async def search_database(
                             "caption": "👤 Verified Identity" if is_face else match["metadata"].get("folder", "🎯 Object Match")})
             return out
 
-        nested     = await asyncio.gather(*[_query_one(v) for v in vectors])
-        all_results = [r for sub in nested for r in sub]
-        seen = {}
-        for r in all_results:
-            url = r["url"]
-            if url not in seen or r["score"] > seen[url]["score"]:
-                seen[url] = r
-        final = sorted(seen.values(), key=lambda x: x["score"], reverse=True)[:10]
+        # ── V3: separate face vectors from object vectors ────────
+        face_vectors   = [v for v in vectors if v["type"] == "face"]
+        object_vectors = [v for v in vectors if v["type"] == "object"]
 
-        log("INFO", "search.complete",
-            user_id=user_id or "anonymous", ip=ip, mode=mode,
-            lanes=lanes_used, detect_faces=detect_faces,
-            results_count=len(final), top_score=final[0]["score"] if final else 0,
-            duration_ms=round((time.perf_counter()-start)*1000))
+        if detect_faces and face_vectors:
+            # ── FACE MODE: return grouped results per detected face ──
+            async def _query_face_group(face_vec: dict) -> dict:
+                vec_list = face_vec["vector"].tolist() if hasattr(face_vec["vector"], "tolist") else face_vec["vector"]
+                try:
+                    res = await asyncio.to_thread(idx_face.query,
+                        vector=vec_list, top_k=10, include_metadata=True)
+                except Exception as e:
+                    if "404" in str(e):
+                        raise HTTPException(404, "Pinecone index not found. Go to Settings → Verify & Save.")
+                    raise e
+
+                matches = []
+                seen_urls = set()
+                for match in res.get("matches", []):
+                    score = match["score"]
+                    # ArcFace cosine — threshold 0.35 same as before
+                    if score < 0.35:
+                        continue
+                    url = match["metadata"].get("url", "")
+                    if url in seen_urls:
+                        continue
+                    seen_urls.add(url)
+                    # Remap score to 75-99% for UI
+                    ui_score = min(0.99, 0.75 + ((score - 0.35) / 0.65) * 0.24)
+                    matches.append({
+                        "url":        url,
+                        "score":      round(ui_score, 4),
+                        "face_crop":  match["metadata"].get("face_crop", ""),
+                        "bbox":       match["metadata"].get("bbox", ""),
+                        "folder":     match["metadata"].get("folder", ""),
+                        "caption":    "👤 Verified Identity",
+                    })
+
+                return {
+                    "query_face_idx":  face_vec.get("face_idx", 0),
+                    "query_face_crop": face_vec.get("face_crop", ""),
+                    "det_score":       face_vec.get("det_score", 1.0),
+                    "matches":         sorted(matches, key=lambda x: x["score"], reverse=True)[:10],
+                }
+
+            face_groups = await asyncio.gather(*[_query_face_group(fv) for fv in face_vectors])
+            # Filter out groups with 0 matches
+            face_groups = [g for g in face_groups if g["matches"]]
+
+            duration_ms = round((time.perf_counter() - start) * 1000)
+            total_matches = sum(len(g["matches"]) for g in face_groups)
+            log("INFO", "search.complete",
+                user_id=user_id or "anonymous", ip=ip, mode=mode,
+                lanes=["face"], detect_faces=detect_faces,
+                face_groups=len(face_groups), results_count=total_matches,
+                top_score=face_groups[0]["matches"][0]["score"] if face_groups and face_groups[0]["matches"] else 0,
+                duration_ms=duration_ms)
+
+            return {
+                "mode":        "face",
+                "face_groups": list(face_groups),
+                "results":     [],  # empty for backward compat
+            }
+
+        else:
+            # ── OBJECT MODE: original flat results ──────────────
+            nested     = await asyncio.gather(*[_query_one(v) for v in vectors])
+            all_results = [r for sub in nested for r in sub]
+            seen = {}
+            for r in all_results:
+                url = r["url"]
+                if url not in seen or r["score"] > seen[url]["score"]:
+                    seen[url] = r
+            final = sorted(seen.values(), key=lambda x: x["score"], reverse=True)[:10]
+
+            duration_ms = round((time.perf_counter() - start) * 1000)
+            log("INFO", "search.complete",
+                user_id=user_id or "anonymous", ip=ip, mode=mode,
+                lanes=lanes_used, detect_faces=detect_faces,
+                results_count=len(final), top_score=final[0]["score"] if final else 0,
+                duration_ms=duration_ms)
 
-        return {"results": final}
+            return {"mode": "object", "results": final, "face_groups": []}
 
     except HTTPException: raise
     except Exception as e:
@@ -488,9 +566,12 @@ async def get_categories(
         log("ERROR", "categories.error", user_id=user_id or "anonymous", ip=ip, error=str(e))
         return {"categories": []}
 
+
 @app.get("/")
 async def root():
     return {"status": "ok"}
+
+
 @app.get("/api/health")
 async def health():
     return {"status": "ok", "timestamp": datetime.now(timezone.utc).isoformat()}

requirements.txt

@@ -18,4 +18,33 @@ ultralytics
 tf-keras
 opencv-python-headless
 aiohttp
-loguru
+loguru
+# Enterprise Lens V3 — requirements.txt
+# Face Lane: InsightFace (replaces DeepFace + RetinaFace + GhostFaceNet)
+
+# ── Core API ──────────────────────────────────────────────────────
+fastapi
+uvicorn[standard]
+python-multipart
+aiohttp
+loguru
+
+# ── AI / ML ───────────────────────────────────────────────────────
+torch
+torchvision
+transformers
+ultralytics
+
+# ── V3 Face Engine (replaces deepface) ───────────────────────────
+insightface
+onnxruntime          # CPU inference for InsightFace
+opencv-python-headless
+
+# ── Vector DB ────────────────────────────────────────────────────
+pinecone
+
+# ── Image / Cloud ────────────────────────────────────────────────
+cloudinary
+Pillow
+numpy
+inflect

src/models.py

@@ -1,26 +1,47 @@
-# src/models.py
+# src/models.py  —  Enterprise Lens V3
+# ════════════════════════════════════════════════════════════════════
+# Face Lane  : InsightFace (YuNet detection + ArcFace 512-D encoding)
+#              • Replaces DeepFace + RetinaFace + GhostFaceNet entirely
+#              • 3-5x faster on CPU, handles small faces (≥20×20 px)
+#              • Stores one 512-D vector PER face (not per image)
+#              • Each vector carries a base64 face-crop thumbnail
+# Object Lane: SigLIP + DINOv2 fused 1536-D (unchanged from V2)
+# ════════════════════════════════════════════════════════════════════
+
 import os
-# FIX 1: Force Legacy Keras to prevent DeepFace/RetinaFace crash in TF 2.16+
-os.environ["TF_USE_LEGACY_KERAS"] = "1"
-os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"  # Hides the annoying CUDA/cuInit warnings
+os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
 
 import asyncio
-import hashlib
+import base64
 import functools
+import hashlib
+import io
 
-import torch
 import cv2
 import numpy as np
+import torch
+import torch.nn.functional as F
 from PIL import Image
-from transformers import AutoProcessor, AutoModel, AutoImageProcessor
+from transformers import AutoImageProcessor, AutoModel, AutoProcessor
 from ultralytics import YOLO
-import torch.nn.functional as F
-from deepface import DeepFace
 
+# ── InsightFace ───────────────────────────────────────────────────
+try:
+    import insightface
+    from insightface.app import FaceAnalysis
+    INSIGHTFACE_AVAILABLE = True
+except ImportError:
+    INSIGHTFACE_AVAILABLE = False
+    print("⚠️  insightface not installed — face lane disabled")
+
+# ── Constants ─────────────────────────────────────────────────────
 YOLO_PERSON_CLASS_ID = 0
-MIN_FACE_AREA        = 3000   # ~55×55 px minimum face
-MAX_CROPS            = 6      # max YOLO crops + 1 full-image crop per request
-MAX_IMAGE_SIZE       = 512    # resize longest edge before any inference
+MIN_FACE_SIZE        = 20     # minimum face width/height in pixels
+MAX_FACES_PER_IMAGE  = 10     # cap faces per image for upload
+MAX_CROPS            = 6      # max YOLO object crops per image
+MAX_IMAGE_SIZE       = 640    # resize longest edge before inference (V3: 640 vs V2: 512)
+FACE_CROP_THUMB_SIZE = 112    # face thumbnail size stored in Pinecone metadata
+FACE_CROP_QUALITY    = 75     # JPEG quality for stored thumbnails
 
 
 def _resize_pil(img: Image.Image, max_side: int = MAX_IMAGE_SIZE) -> Image.Image:
@@ -30,12 +51,36 @@ def _resize_pil(img: Image.Image, max_side: int = MAX_IMAGE_SIZE) -> Image.Image
     scale = max_side / max(w, h)
     return img.resize((int(w * scale), int(h * scale)), Image.LANCZOS)
 
+
 def _img_hash(image_path: str) -> str:
     h = hashlib.md5()
     with open(image_path, "rb") as f:
         h.update(f.read(65536))
     return h.hexdigest()
 
+
+def _crop_to_b64(img_np: np.ndarray, bbox: list, thumb_size: int = FACE_CROP_THUMB_SIZE) -> str:
+    """Crop face from image, resize to thumbnail, return as base64 JPEG string."""
+    x, y, w, h = bbox
+    x, y = max(0, x), max(0, y)
+    # Add 20% padding for more natural face crop
+    pad_x = int(w * 0.2)
+    pad_y = int(h * 0.2)
+    x1 = max(0, x - pad_x)
+    y1 = max(0, y - pad_y)
+    x2 = min(img_np.shape[1], x + w + pad_x)
+    y2 = min(img_np.shape[0], y + h + pad_y)
+    face_crop = img_np[y1:y2, x1:x2]
+    if face_crop.size == 0:
+        return ""
+    # Resize to thumbnail
+    face_pil  = Image.fromarray(face_crop[..., ::-1])  # BGR → RGB
+    face_pil  = face_pil.resize((thumb_size, thumb_size), Image.LANCZOS)
+    buf = io.BytesIO()
+    face_pil.save(buf, format="JPEG", quality=FACE_CROP_QUALITY)
+    return base64.b64encode(buf.getvalue()).decode()
+
+
 class AIModelManager:
     def __init__(self):
         self.device = (
@@ -44,105 +89,207 @@ class AIModelManager:
         )
         print(f"Loading models onto: {self.device.upper()}...")
 
-        self.siglip_processor = AutoProcessor.from_pretrained("google/siglip-base-patch16-224", use_fast=False)
-        self.siglip_model = AutoModel.from_pretrained("google/siglip-base-patch16-224").to(self.device).eval()
+        # ── Object Lane: SigLIP + DINOv2 (unchanged) ─────────────
+        self.siglip_processor = AutoProcessor.from_pretrained(
+            "google/siglip-base-patch16-224", use_fast=True)
+        self.siglip_model = AutoModel.from_pretrained(
+            "google/siglip-base-patch16-224").to(self.device).eval()
 
         self.dinov2_processor = AutoImageProcessor.from_pretrained("facebook/dinov2-base")
-        self.dinov2_model = AutoModel.from_pretrained("facebook/dinov2-base").to(self.device).eval()
+        self.dinov2_model = AutoModel.from_pretrained(
+            "facebook/dinov2-base").to(self.device).eval()
 
         if self.device == "cuda":
             self.siglip_model = self.siglip_model.half()
             self.dinov2_model = self.dinov2_model.half()
 
-        # FIX 2: Removed torch.compile() because HF Spaces do not have the g++ compiler installed by default.
-        # This fixes the "InvalidCxxCompiler" Search crash.
-        
-        self.yolo = YOLO("yolo11n-seg.pt")   # seg model → pixel masks → accurate crops
+        # ── YOLO for object segmentation ─────────────────────────
+        self.yolo = YOLO("yolo11n-seg.pt")
 
-        self._cache = {}
-        self._cache_maxsize = 256
+        # ── Face Lane: InsightFace (YuNet + ArcFace) ─────────────
+        self.face_app = None
+        if INSIGHTFACE_AVAILABLE:
+            try:
+                # buffalo_sc = small+fast model (CPU optimised)
+                # buffalo_l  = large+accurate (use if GPU available)
+                model_name = "buffalo_l" if self.device == "cuda" else "buffalo_sc"
+                self.face_app = FaceAnalysis(
+                    name=model_name,
+                    providers=["CUDAExecutionProvider"] if self.device == "cuda"
+                              else ["CPUExecutionProvider"],
+                )
+                # det_size controls detection resolution — larger = finds smaller faces
+                self.face_app.prepare(ctx_id=0 if self.device == "cuda" else -1,
+                                      det_size=(640, 640))
+                print(f"✅ InsightFace ({model_name}) loaded — ArcFace face lane active")
+            except Exception as e:
+                print(f"⚠️  InsightFace init failed: {e} — face lane disabled")
+                self.face_app = None
+        else:
+            print("⚠️  InsightFace not available — install: pip install insightface onnxruntime")
 
+        self._cache          = {}
+        self._cache_maxsize  = 128
         print("✅ Models ready!")
 
-    def _embed_crops_batch(self, crops: list[Image.Image]) -> list[np.ndarray]:
+    # ── Object Lane batched embedding ────────────────────────────
+    def _embed_crops_batch(self, crops: list) -> list:
         if not crops:
             return []
-
         with torch.no_grad():
-            sig_inputs = self.siglip_processor(images=crops, return_tensors="pt", padding=True)
-            sig_inputs = {k: v.to(self.device) for k, v in sig_inputs.items()}
+            sig_in = self.siglip_processor(images=crops, return_tensors="pt", padding=True)
+            sig_in = {k: v.to(self.device) for k, v in sig_in.items()}
             if self.device == "cuda":
-                sig_inputs = {k: v.half() if v.dtype == torch.float32 else v for k, v in sig_inputs.items()}
-
-            sig_out = self.siglip_model.get_image_features(**sig_inputs)
-            if hasattr(sig_out, "image_embeds"):
-                sig_out = sig_out.image_embeds
-            elif isinstance(sig_out, tuple):
-                sig_out = sig_out[0]
+                sig_in = {k: v.half() if v.dtype == torch.float32 else v
+                          for k, v in sig_in.items()}
+            sig_out = self.siglip_model.get_image_features(**sig_in)
+            if hasattr(sig_out, "image_embeds"): sig_out = sig_out.image_embeds
+            elif isinstance(sig_out, tuple):      sig_out = sig_out[0]
             sig_vecs = F.normalize(sig_out.float(), p=2, dim=1).cpu()
 
-            dino_inputs = self.dinov2_processor(images=crops, return_tensors="pt")
-            dino_inputs = {k: v.to(self.device) for k, v in dino_inputs.items()}
+            dino_in   = self.dinov2_processor(images=crops, return_tensors="pt")
+            dino_in   = {k: v.to(self.device) for k, v in dino_in.items()}
             if self.device == "cuda":
-                dino_inputs = {k: v.half() if v.dtype == torch.float32 else v for k, v in dino_inputs.items()}
-
-            dino_out  = self.dinov2_model(**dino_inputs)
-            dino_vecs = dino_out.last_hidden_state[:, 0, :]
-            dino_vecs = F.normalize(dino_vecs.float(), p=2, dim=1).cpu()
+                dino_in = {k: v.half() if v.dtype == torch.float32 else v
+                           for k, v in dino_in.items()}
+            dino_out  = self.dinov2_model(**dino_in)
+            dino_vecs = F.normalize(
+                dino_out.last_hidden_state[:, 0, :].float(), p=2, dim=1).cpu()
 
             fused = F.normalize(torch.cat([sig_vecs, dino_vecs], dim=1), p=2, dim=1)
-
         return [fused[i].numpy() for i in range(len(crops))]
 
-    def process_image(self, image_path: str, is_query: bool = False, detect_faces: bool = True) -> list[dict]:
-        cache_key = _img_hash(image_path)
+    # ── V3 Face detection + encoding ──────────���──────────────────
+    def _detect_and_encode_faces(self, img_np: np.ndarray) -> list:
+        """
+        Detect ALL faces in image using InsightFace (YuNet + ArcFace).
+        Returns list of dicts:
+        {
+          "type":       "face",
+          "vector":     np.ndarray (512-D ArcFace embedding),
+          "face_idx":   int,
+          "bbox":       [x, y, w, h],
+          "face_crop":  str (base64 JPEG thumbnail),
+          "det_score":  float (detection confidence)
+        }
+        """
+        if self.face_app is None:
+            return []
+
+        try:
+            # InsightFace expects BGR numpy array
+            if img_np.shape[2] == 3 and img_np.dtype == np.uint8:
+                bgr = img_np[..., ::-1].copy()  # RGB → BGR
+            else:
+                bgr = img_np.copy()
+
+            faces = self.face_app.get(bgr)
+            results = []
+
+            for idx, face in enumerate(faces):
+                if idx >= MAX_FACES_PER_IMAGE:
+                    break
+
+                # Get bounding box
+                bbox = face.bbox.astype(int)  # [x1, y1, x2, y2]
+                x1, y1, x2, y2 = bbox
+                w, h = x2 - x1, y2 - y1
+
+                # Skip tiny faces
+                if w < MIN_FACE_SIZE or h < MIN_FACE_SIZE:
+                    continue
+
+                # Get ArcFace embedding (already L2-normalised by InsightFace)
+                if face.embedding is None:
+                    continue
+                vec = face.embedding.astype(np.float32)
+                # Re-normalise just to be safe
+                norm = np.linalg.norm(vec)
+                if norm > 0:
+                    vec = vec / norm
+
+                # Generate face crop thumbnail for UI
+                face_crop_b64 = _crop_to_b64(
+                    bgr, [x1, y1, w, h], FACE_CROP_THUMB_SIZE)
+
+                results.append({
+                    "type":      "face",
+                    "vector":    vec,
+                    "face_idx":  idx,
+                    "bbox":      [int(x1), int(y1), int(w), int(h)],
+                    "face_crop": face_crop_b64,
+                    "det_score": float(face.det_score) if hasattr(face, "det_score") else 1.0,
+                })
+
+            print(f"👤 Detected {len(results)} face(s) via InsightFace ArcFace")
+            return results
+
+        except Exception as e:
+            print(f"🟠 InsightFace error: {e} — falling back to object lane")
+            return []
+
+    # ── Main process_image ────────────────────────────────────────
+    def process_image(
+        self,
+        image_path: str,
+        is_query: bool = False,
+        detect_faces: bool = True,
+    ) -> list:
+        """
+        Returns list of vector dicts for upload or search.
+
+        Upload mode (is_query=False):
+          - Face vectors include bbox + face_crop for Pinecone metadata
+          - Object vectors include full-image + YOLO crops
+
+        Query mode (is_query=True):
+          - Same structure — main.py handles grouping for search response
+        """
+        cache_key = f"{_img_hash(image_path)}_{detect_faces}_{is_query}"
         if cache_key in self._cache:
             print("⚡ Cache hit — skipping inference")
             return self._cache[cache_key]
 
-        extracted = []
+        extracted    = []
         original_pil = Image.open(image_path).convert("RGB")
-        small_pil    = _resize_pil(original_pil, MAX_IMAGE_SIZE)
-        img_np       = np.array(small_pil)
+        img_np       = np.array(original_pil)  # RGB, uint8
         faces_found  = False
 
+        # ── FACE LANE ────────────────────────────────────────────
         if detect_faces:
-            try:
-                print("🔍 Face detection …")
-                face_objs = DeepFace.represent(
-                    img_path=img_np,
-                    model_name="GhostFaceNet",
-                    detector_backend="retinaface",
-                    enforce_detection=False,
-                    align=True,
-                )
-                for face in (face_objs or []):
-                    fa = face.get("facial_area", {})
-                    if fa.get("w", 0) * fa.get("h", 0) < MIN_FACE_AREA:
-                        continue
-                    vec = torch.tensor([face["embedding"]])
-                    vec = F.normalize(vec, p=2, dim=1)
-                    extracted.append({"type": "face", "vector": vec.flatten().numpy()})
-                    faces_found = True
-
-            except Exception as e:
-                print(f"🟠 Face lane error: {e} — falling back to object lane")
-
-        # Full-res PIL for crops — YOLO returns coordinates in full-res pixel space.
-        # We crop from original_pil then resize each crop before embedding.
-        # BUG FIX: old optimised code cropped from small_pil (512px) using
-        # full-res YOLO coordinates → completely wrong crop regions.
-        crops_pil = [original_pil]   # full-image always included for global context
-
+            # Resize for face detection (640px for small face detection)
+            detect_pil = _resize_pil(original_pil, 640)
+            detect_np  = np.array(detect_pil)
+
+            face_results = self._detect_and_encode_faces(detect_np)
+
+            if face_results:
+                faces_found = True
+                # Scale bbox back to original image size if resized
+                scale_x = original_pil.width  / detect_pil.width
+                scale_y = original_pil.height / detect_pil.height
+                for fr in face_results:
+                    if scale_x != 1.0 or scale_y != 1.0:
+                        bx, by, bw, bh = fr["bbox"]
+                        fr["bbox"] = [
+                            int(bx * scale_x), int(by * scale_y),
+                            int(bw * scale_x), int(bh * scale_y),
+                        ]
+                    extracted.append(fr)
+
+        # ── OBJECT LANE ──────────────────────────────────────────
+        # Always run object lane — even if faces found
+        # (image may contain both people and objects)
+        crops_pil    = [_resize_pil(original_pil, MAX_IMAGE_SIZE)]  # full-image always
         yolo_results = self.yolo(image_path, conf=0.5, verbose=False)
 
         for r in yolo_results:
-            # Use segmentation masks when available (yolo11n-seg.pt)
             if r.masks is not None:
                 for seg_idx, mask_xy in enumerate(r.masks.xy):
                     cls_id = int(r.boxes.cls[seg_idx].item())
+                    # Skip person crops if face lane already handled them
                     if faces_found and cls_id == YOLO_PERSON_CLASS_ID:
-                        print("🔵 PERSON crop skipped — face lane already active")
+                        print("🔵 PERSON crop skipped — face lane active")
                         continue
                     polygon = np.array(mask_xy, dtype=np.int32)
                     if len(polygon) < 3:
@@ -155,7 +302,6 @@ class AIModelManager:
                     if len(crops_pil) >= MAX_CROPS + 1:
                         break
             elif r.boxes is not None:
-                # Fallback: plain bounding boxes (shouldn't happen with seg model)
                 for box in r.boxes:
                     cls_id = int(box.cls.item())
                     if faces_found and cls_id == YOLO_PERSON_CLASS_ID:
@@ -168,15 +314,13 @@ class AIModelManager:
             if len(crops_pil) >= MAX_CROPS + 1:
                 break
 
-        # Resize each crop to MAX_IMAGE_SIZE before batched embedding
-        # (models expect ~224px anyway; no quality loss, big speed gain)
         crops = [_resize_pil(c, MAX_IMAGE_SIZE) for c in crops_pil]
-
-        print(f"🧠 Embedding {len(crops)} crop(s) in one batch …")
-        vecs = self._embed_crops_batch(crops)
-        for vec in vecs:
+        print(f"🧠 Embedding {len(crops)} object crop(s) in one batch …")
+        obj_vecs = self._embed_crops_batch(crops)
+        for vec in obj_vecs:
             extracted.append({"type": "object", "vector": vec})
 
+        # Cache result
         if len(self._cache) >= self._cache_maxsize:
             oldest = next(iter(self._cache))
             del self._cache[oldest]
@@ -184,6 +328,14 @@ class AIModelManager:
 
         return extracted
 
-    async def process_image_async(self, image_path: str, is_query: bool = False, detect_faces: bool = True) -> list[dict]:
+    async def process_image_async(
+        self,
+        image_path: str,
+        is_query: bool = False,
+        detect_faces: bool = True,
+    ) -> list:
         loop = asyncio.get_event_loop()
-        return await loop.run_in_executor(None, functools.partial(self.process_image, image_path, is_query, detect_faces))
+        return await loop.run_in_executor(
+            None,
+            functools.partial(self.process_image, image_path, is_query, detect_faces),
+        )