scorevision: push artifact

chute_config.yml

@@ -7,10 +7,16 @@ Image:
 NodeSelector:
   gpu_count: 1
   min_vram_gb_per_gpu: 16
+  max_hourly_price_per_gpu: 0.50
+  exclude:
+    - 5090
+    - b200
+    - h200
+    - mi300x
 
 Chute:
-  timeout_seconds: 300
+  timeout_seconds: 900
   concurrency: 4
   max_instances: 5
   scaling_threshold: 0.5
-  shutdown_after_seconds: 600
+  shutdown_after_seconds: 288000

miner.py

@@ -1,7 +1,8 @@
 """
-Score Vision SN44 — Unified miner v2 (2026-03-28).
-Dual-model: vehicle (YOLO11s) + person (YOLO11s).
-Optimized for latency: parallel threading + configurable TTA.
+Score Vision SN44 — Unified miner v3 (2026-03-31).
+Dual-model: vehicle (YOLO11m INT8 1280) + person (YOLO11s INT8 640).
+Vehicle weights loaded from secondary HF repo (meaculpitt/ScoreVision-Vehicle).
+Person weights loaded from primary HF repo (template downloads automatically).
 
 Vehicle model (vehicle_weights.onnx):
   Trained classes: 0=car, 1=bus, 2=truck, 3=motorcycle
@@ -36,10 +37,8 @@ def _preload_cuda_libs():
                 pass
         if not lib_dirs:
             return
-        # Set LD_LIBRARY_PATH for subprocesses
         existing = os.environ.get('LD_LIBRARY_PATH', '')
         os.environ['LD_LIBRARY_PATH'] = ':'.join(lib_dirs + ([existing] if existing else []))
-        # Pre-load .so files with RTLD_GLOBAL so dlopen() finds them
         for lib_dir in lib_dirs:
             for so in sorted(_glob.glob(os.path.join(lib_dir, 'lib*.so*'))):
                 try:
@@ -60,7 +59,6 @@ def _try_gpu_ort():
     import time as _t
     _t0 = _t.time()
 
-    # Diagnostic: torch + CUDA
     try:
         import torch
         print(f"[GPU_SETUP] torch={torch.__version__} cuda={torch.cuda.is_available()} "
@@ -70,7 +68,6 @@ def _try_gpu_ort():
     except Exception as e:
         print(f"[GPU_SETUP] torch check failed: {e}", flush=True)
 
-    # Check current ORT providers
     try:
         import onnxruntime as _ort
         providers = _ort.get_available_providers()
@@ -82,7 +79,6 @@ def _try_gpu_ort():
         print("[GPU_SETUP] onnxruntime not importable", flush=True)
         return
 
-    # List key packages for diagnostics
     result = _subprocess.run(
         [_sys.executable, '-m', 'pip', 'list', '--format=columns'],
         capture_output=True, text=True, timeout=15
@@ -94,14 +90,12 @@ def _try_gpu_ort():
 
     print("[GPU_SETUP] Attempting onnxruntime-gpu install...", flush=True)
     try:
-        # Uninstall CPU onnxruntime
         r1 = _subprocess.run(
             [_sys.executable, '-m', 'pip', 'uninstall', 'onnxruntime', '-y'],
             capture_output=True, text=True, timeout=30
         )
         print(f"[GPU_SETUP] uninstall rc={r1.returncode}", flush=True)
 
-        # Install GPU version (no-deps to avoid reinstalling torch etc)
         r2 = _subprocess.run(
             [_sys.executable, '-m', 'pip', 'install', 'onnxruntime-gpu', '--no-deps'],
             capture_output=True, text=True, timeout=180
@@ -122,12 +116,10 @@ def _try_gpu_ort():
             )
             return
 
-        # Clear cached onnxruntime modules
         for key in list(_sys.modules.keys()):
             if 'onnxruntime' in key:
                 del _sys.modules[key]
 
-        # Reimport and check
         import onnxruntime as _ort2
         new_providers = _ort2.get_available_providers()
         _dt = _t.time() - _t0
@@ -135,7 +127,6 @@ def _try_gpu_ort():
 
     except Exception as e:
         print(f"[GPU_SETUP] EXCEPTION: {e}", flush=True)
-        # Try to restore CPU onnxruntime
         try:
             for key in list(_sys.modules.keys()):
                 if 'onnxruntime' in key:
@@ -172,31 +163,33 @@ logger = logging.getLogger(__name__)
 # ── Vehicle config ──────────────────────────────────────────────────────────
 VEH_MODEL_TO_OUT: dict[int, int] = {0: 1, 1: 0, 2: 2, 3: 3}
 VEH_NUM_CLASSES = 4
-# VEH_IMG_SIZE: now read dynamically from model input shape in __init__
 VEH_CONF_PER_CLASS = {0: 0.15, 1: 0.30, 2: 0.20, 3: 0.15}
 VEH_CONF_DEFAULT = 0.35
 VEH_TTA_CONF = 0.10
 VEH_WBF_IOU = 0.40
 
 # ── Person config (TTA consensus) ───────────────────────────────────────────
-PER_CONF_LOW = 0.32          # Detection threshold (both passes)
-PER_CONF_HIGH = 0.55         # Above this = unconditionally kept
-PER_CONSENSUS_IOU = 0.50     # Cross-view IoU to confirm low-conf box
-PER_WBF_IOU = 0.40           # Final WBF dedup (unchanged)
-PER_RTF_BUDGET = 8.0         # Conservative RTF budget (gate is 10s)
-
-# ── Person box sanity filters (matching top scorers) ────────────────────────
-PER_MIN_WH = 8               # Minimum box width or height (pixels)
-PER_MIN_AREA = 14 * 14       # Minimum box area (pixels^2)
-PER_MAX_ASPECT = 8.0         # Maximum aspect ratio
-PER_MAX_AREA_RATIO = 0.80    # Maximum box area / image area
+PER_CONF_LOW = 0.32
+PER_CONF_HIGH = 0.55
+PER_CONSENSUS_IOU = 0.50
+PER_WBF_IOU = 0.40
+PER_RTF_BUDGET = 8.0
+
+# ── Person box sanity filters ──────────────────────────────────────────────
+PER_MIN_WH = 8
+PER_MIN_AREA = 14 * 14
+PER_MAX_ASPECT = 8.0
+PER_MAX_AREA_RATIO = 0.80
 
 # ── Shared ──────────────���───────────────────────────────────────────────────
 WBF_SKIP_THR = 0.0001
 
 # ── Speed config ────────────────────────────────────────────────────────────
-ENABLE_TTA = False          # Set True to re-enable 2-pass TTA (doubles inference time)
-ENABLE_PARALLEL = True      # Run vehicle + person in parallel threads
+ENABLE_TTA = False
+ENABLE_PARALLEL = True
+
+# ── Secondary HF repo for vehicle weights ───────────────────────────────────
+VEHICLE_HF_REPO = "meaculpitt/ScoreVision-Vehicle"
 
 
 def _wbf_multi(boxes_list, scores_list, labels_list, iou_thr=0.55, skip_thr=0.0001):
@@ -335,9 +328,22 @@ class Miner:
     def __init__(self, path_hf_repo: Path) -> None:
         self.path_hf_repo = path_hf_repo
 
-        # Vehicle model (YOLO11s, 4 classes)
+        # Vehicle model — download from secondary HF repo with safety guard
+        t0 = time.monotonic()
+        try:
+            from huggingface_hub import snapshot_download as _sd
+            veh_path = Path(_sd(VEHICLE_HF_REPO))
+            veh_weights = str(veh_path / "vehicle_weights.onnx")
+            logger.info(f"[init] Vehicle weights from {VEHICLE_HF_REPO} in {time.monotonic()-t0:.1f}s")
+        except Exception as e:
+            # Fallback: try loading from primary repo (backward compat)
+            logger.warning(f"[init] Vehicle secondary repo failed ({e}), trying primary repo")
+            veh_weights = str(path_hf_repo / "vehicle_weights.onnx")
+            if not Path(veh_weights).exists():
+                raise FileNotFoundError(f"vehicle_weights.onnx not found in primary or secondary repo") from e
+
         self.veh_session = ort.InferenceSession(
-            str(path_hf_repo / "vehicle_weights.onnx"),
+            veh_weights,
             providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
         )
         self.veh_input_name = self.veh_session.get_inputs()[0].name
@@ -345,7 +351,7 @@ class Miner:
         self.veh_h = int(veh_shape[2])
         self.veh_w = int(veh_shape[3])
 
-        # Person model (YOLO11s, 1 class)
+        # Person model — from primary HF repo (template downloads automatically)
         self.per_session = ort.InferenceSession(
             str(path_hf_repo / "person_weights.onnx"),
             providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
@@ -366,7 +372,7 @@ class Miner:
         logger.info(f"TTA={ENABLE_TTA} PARALLEL={ENABLE_PARALLEL}")
 
     def __repr__(self) -> str:
-        return "Unified Miner v2 — dual-model vehicle+person (parallel, TTA-configurable)"
+        return "Unified Miner v3 — dual-model vehicle+person (repo-split, parallel, TTA-configurable)"
 
     # ── Vehicle preprocessing (letterbox) ───────────────────────────────────
 
@@ -431,23 +437,19 @@ class Miner:
             all_l.append(out_cls)
 
         if ENABLE_TTA:
-            # Pass 1: original
             _collect(*self._veh_run_pass(image_bgr, VEH_TTA_CONF))
-            # Pass 2: hflip
             flipped = cv2.flip(image_bgr, 1)
             bx, sc, cl = self._veh_run_pass(flipped, VEH_TTA_CONF)
             if len(bx):
                 bx[:, 0], bx[:, 2] = ow - bx[:, 2], ow - bx[:, 0]
             _collect(bx, sc, cl)
         else:
-            # Single pass — use per-class conf thresholds directly
             bx, confs, cls_ids = self._veh_run_pass(image_bgr, VEH_TTA_CONF)
             _collect(bx, confs, cls_ids)
 
         if not all_b:
             return []
 
-        # Always apply WBF — deduplicates overlapping anchors from raw ONNX output
         fb, fs, fl = _wbf_multi(all_b, all_s, all_l, iou_thr=VEH_WBF_IOU, skip_thr=WBF_SKIP_THR)
 
         if len(fb) == 0:
@@ -517,12 +519,10 @@ class Miner:
     def _infer_person(self, image_bgr):
         oh, ow = image_bgr.shape[:2]
 
-        # Pass 1: original
         t_start = time.monotonic()
         boxes_orig, confs_orig = self._per_run_pass(image_bgr, PER_CONF_LOW)
         elapsed = time.monotonic() - t_start
 
-        # Pass 2: hflip — only if RTF budget allows
         has_flip = False
         if elapsed < PER_RTF_BUDGET / 2:
             flipped = cv2.flip(image_bgr, 1)
@@ -533,21 +533,16 @@ class Miner:
         else:
             logger.warning(f"[person TTA] skipping flip — pass1 took {elapsed*1000:.0f}ms")
 
-        # ── Consensus filtering (v2 — original-primary, flip supplements) ──
         kept_b, kept_s = [], []
 
-        # Always keep ALL original boxes at conf >= PER_CONF_LOW
         for i in range(len(boxes_orig)):
             kept_b.append(boxes_orig[i])
             kept_s.append(confs_orig[i])
 
         if has_flip:
-            # From flip view: only add HIGH-conf boxes that original MISSED
-            # (IoU < 0.3 with all original boxes = truly new detection)
             for i in range(len(boxes_flip)):
                 if confs_flip[i] < PER_CONF_HIGH:
                     continue
-                # Check if this flip box overlaps any original box
                 if len(boxes_orig) > 0:
                     xx1 = np.maximum(boxes_flip[i, 0], boxes_orig[:, 0])
                     yy1 = np.maximum(boxes_flip[i, 1], boxes_orig[:, 1])
@@ -558,15 +553,13 @@ class Miner:
                     a2 = (boxes_orig[:, 2] - boxes_orig[:, 0]) * (boxes_orig[:, 3] - boxes_orig[:, 1])
                     iou = inter / (a1 + a2 - inter + 1e-9)
                     if np.max(iou) >= 0.3:
-                        continue  # Already detected by original — skip
-                # Truly new high-conf detection from flip
+                        continue
                 kept_b.append(boxes_flip[i])
                 kept_s.append(confs_flip[i])
 
         if not kept_b:
             return []
 
-        # ── WBF dedup (merges near-duplicate detections) ────────────────
         kept_b = np.array(kept_b)
         kept_s = np.array(kept_s)
         norm = kept_b.copy()
@@ -582,7 +575,6 @@ class Miner:
         fb[:, [0, 2]] *= ow
         fb[:, [1, 3]] *= oh
 
-        # ── Sanity filter (remove degenerate boxes) ─────────────────────
         img_area = float(oh * ow)
         sane = []
         for i in range(len(fb)):
@@ -617,12 +609,10 @@ class Miner:
             ))
         return out
 
-    
     # ── Unified inference ───────────────────────────────────────────────────
 
     def _infer_single(self, image_bgr: ndarray) -> list[BoundingBox]:
         if ENABLE_PARALLEL:
-            # Run both models in parallel threads
             veh_future = self._executor.submit(self._infer_vehicle, image_bgr)
             per_future = self._executor.submit(self._infer_person, image_bgr)
             vehicle_boxes = veh_future.result()
@@ -637,7 +627,6 @@ class Miner:
     REPLAY_MAX = 100
 
     def _replay_save(self, batch_images, results):
-        """Save validator query images + our predictions to replay buffer (background)."""
         try:
             ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S_%f")
             query_dir = self.REPLAY_DIR / ts
@@ -665,7 +654,6 @@ class Miner:
             pass
 
     def _replay_prune(self):
-        """Keep only the most recent REPLAY_MAX queries."""
         try:
             dirs = sorted(
                 [d for d in self.REPLAY_DIR.iterdir() if d.is_dir()],
@@ -702,7 +690,6 @@ class Miner:
         logger.info(f"[miner] predict_batch: {len(batch_images)} images, "
                     f"{sum(len(r.boxes) for r in results)} total boxes, {dt_total:.0f}ms")
 
-        # Save to replay buffer (background thread)
         threading.Thread(
             target=self._replay_save,
             args=(batch_images, results),
@@ -710,5 +697,4 @@ class Miner:
         ).start()
 
         return results
-# GPU runtime installer v1 — 20260328_184247
-# redeploy 20260330_012200_wbf_fix
+# Miner v3 — repo-split deploy 20260331