fix: build issues

src/models.py

@@ -44,18 +44,9 @@ except ImportError:
     print("         pip install insightface onnxruntime          (linux/win)")
 
 # ── AdaFace ──────────────────────────────────────────────────────
-# AdaFace IR-50 MS1MV2 (CVPR 2022) — quality-adaptive margin loss
-# Repo   : minchul/cvlface_adaface_ir50_ms1mv2 (HuggingFace)
-# Loaded : AutoModel + trust_remote_code=True (custom_code repo)
-# Needs  : HF_TOKEN env var set in HF Space secrets
-try:
-    import shutil as _shutil
-    from huggingface_hub import hf_hub_download
-    from transformers import AutoModel as _HF_AutoModel
-    ADAFACE_WEIGHTS_AVAILABLE = True
-except ImportError:
-    ADAFACE_WEIGHTS_AVAILABLE = False
-    print("⚠️  huggingface_hub / transformers not installed — AdaFace fusion disabled")
+# Disabled by default — enable by setting ENABLE_ADAFACE=1 env var.
+# When disabled: ArcFace(512) + zeros(512) = 1024-D (fully functional).
+ADAFACE_WEIGHTS_AVAILABLE = False  # controlled by ENABLE_ADAFACE env var
 
 # ── Constants ─────────────────────────────────────────────────────
 YOLO_PERSON_CLASS_ID  = 0
@@ -230,97 +221,58 @@ class AIModelManager:
 
     def _load_adaface(self):
         """
-        Load AdaFace IR-50 MS1MV2 from HuggingFace.
-        Repo    : minchul/cvlface_adaface_ir50_ms1mv2
-        Method  : AutoModel + trust_remote_code (repo has custom_code)
-        Token   : HF_TOKEN env var (required for custom_code repos)
-        Output  : 512-D L2-normalised embedding per face crop
+        AdaFace IR-50 MS1MV2 — disabled for now.
+        Face vectors use ArcFace(512) + zeros(512) = 1024-D.
+        This is fully functional — cosine similarity works correctly.
+        Re-enable by setting ENABLE_ADAFACE=1 env var when HF token
+        injection into Docker build is confirmed working.
         """
-        if not ADAFACE_WEIGHTS_AVAILABLE:
-            print("⚠️  AdaFace skipped — huggingface_hub / transformers not installed")
+        enable = os.getenv("ENABLE_ADAFACE", "0").strip() == "1"
+        if not enable:
+            print("⚠️  AdaFace disabled (ENABLE_ADAFACE != 1) — using ArcFace zero-padded 1024-D")
+            self.adaface_model = None
             return
 
-        import os, sys
-
-        REPO_ID    = "minchul/cvlface_adaface_ir50_ms1mv2"
+        # Full loading code kept here for when AdaFace is re-enabled
+        import sys
         HF_TOKEN   = os.getenv("HF_TOKEN", None)
+        REPO_ID    = "minchul/cvlface_adaface_ir50_ms1mv2"
         CACHE_PATH = os.path.expanduser("~/.cvlface_cache/minchul/cvlface_adaface_ir50_ms1mv2")
-
         try:
-            print("📦 Loading AdaFace IR-50 MS1MV2 from HuggingFace...")
-            if HF_TOKEN:
-                print("   HF_TOKEN found ✅")
-            else:
-                print("   ⚠️  HF_TOKEN not set — may fail on gated/custom_code repos")
-
-            # ── Step 1: Download all repo files ──────────────────
+            from huggingface_hub import hf_hub_download
+            print("📦 Loading AdaFace IR-50 MS1MV2...")
             os.makedirs(CACHE_PATH, exist_ok=True)
-
-            # Download files.txt manifest first
-            files_txt = os.path.join(CACHE_PATH, "files.txt")
-            if not os.path.exists(files_txt):
-                hf_hub_download(
-                    repo_id=REPO_ID, filename="files.txt",
-                    token=HF_TOKEN, local_dir=CACHE_PATH,
-                    local_dir_use_symlinks=False,
-                )
-
-            # Read manifest and download each listed file
-            with open(files_txt, "r") as f:
-                extra_files = [x.strip() for x in f.read().split("\n") if x.strip()]
-
-            for fname in extra_files + ["config.json", "wrapper.py", "model.safetensors"]:
+            hf_hub_download(repo_id=REPO_ID, filename="files.txt",
+                token=HF_TOKEN, local_dir=CACHE_PATH, local_dir_use_symlinks=False)
+            with open(os.path.join(CACHE_PATH, "files.txt")) as f:
+                extra = [x.strip() for x in f.read().split("\n") if x.strip()]
+            for fname in extra + ["config.json", "wrapper.py", "model.safetensors"]:
                 fpath = os.path.join(CACHE_PATH, fname)
                 if not os.path.exists(fpath):
-                    print(f"   Downloading {fname}...")
-                    hf_hub_download(
-                        repo_id=REPO_ID, filename=fname,
-                        token=HF_TOKEN, local_dir=CACHE_PATH,
-                        local_dir_use_symlinks=False,
-                    )
-
-            # ── Step 2: Load model from local cache ──────────────
-            # Must chdir + add to sys.path because the repo uses
-            # trust_remote_code with relative imports in wrapper.py
+                    hf_hub_download(repo_id=REPO_ID, filename=fname,
+                        token=HF_TOKEN, local_dir=CACHE_PATH, local_dir_use_symlinks=False)
             cwd = os.getcwd()
             os.chdir(CACHE_PATH)
             sys.path.insert(0, CACHE_PATH)
             try:
+                from transformers import AutoModel as _HF_AutoModel
                 model = _HF_AutoModel.from_pretrained(
-                    CACHE_PATH,
-                    trust_remote_code=True,
-                    token=HF_TOKEN,
-                )
+                    CACHE_PATH, trust_remote_code=True, token=HF_TOKEN)
             finally:
                 os.chdir(cwd)
-                if CACHE_PATH in sys.path:
-                    sys.path.remove(CACHE_PATH)
-
+                if CACHE_PATH in sys.path: sys.path.remove(CACHE_PATH)
             model = model.to(self.device).eval()
-            if self.device == "cuda":
-                model = model.half()
-
-            # ── Step 3: Verify output shape ───────────────────────
             with torch.no_grad():
-                dummy = torch.zeros(1, 3, 112, 112).to(self.device)
-                out   = model(dummy)
-            # Model may return tensor directly or an object with .embedding
-            out_vec = out if isinstance(out, torch.Tensor) else out.embedding
-            out_dim = out_vec.shape[-1]
-            if out_dim != ADAFACE_DIM:
-                raise ValueError(
-                    f"AdaFace output dim={out_dim}, expected {ADAFACE_DIM}")
-
+                out = model(torch.zeros(1, 3, 112, 112).to(self.device))
+            emb = out if isinstance(out, torch.Tensor) else out.embedding
+            assert emb.shape[-1] == ADAFACE_DIM
             self.adaface_model = model
-            print(f"✅ AdaFace IR-50 MS1MV2 loaded — output dim={out_dim} — 1024-D fusion ACTIVE")
-
+            print(f"✅ AdaFace IR-50 loaded — 1024-D FULL FUSION active")
         except Exception as e:
-            print(f"⚠️  AdaFace load failed: {e}")
-            print(f"   Detail: {traceback.format_exc()[-500:]}")
-            print("   Falling back to ArcFace-only (zero-padded to 1024-D)")
+            print(f"⚠️  AdaFace load failed: {e} — falling back to zero-padded 1024-D")
             self.adaface_model = None
 
-    # ── Object Lane: batched SigLIP + DINOv2 embedding ───────────
+        # ── Object Lane: batched SigLIP + DINOv2 embedding ───────────
     def _embed_crops_batch(self, crops: list) -> list:
         """Embed a list of PIL images → list of 1536-D numpy arrays."""
         if not crops:
@@ -333,8 +285,18 @@ class AIModelManager:
                 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]
+            # Handle all output types across transformers versions
+            if hasattr(sig_out, "image_embeds"):
+                sig_out = sig_out.image_embeds
+            elif hasattr(sig_out, "pooler_output"):
+                sig_out = sig_out.pooler_output
+            elif hasattr(sig_out, "last_hidden_state"):
+                sig_out = sig_out.last_hidden_state[:, 0, :]
+            elif isinstance(sig_out, tuple):
+                sig_out = sig_out[0]
+            # sig_out is now a tensor
+            if not isinstance(sig_out, torch.Tensor):
+                sig_out = sig_out[0]
             sig_vecs = F.normalize(sig_out.float(), p=2, dim=1).cpu()
 
             # DINOv2