scorevision: push artifact

miner.py

@@ -1,24 +1,19 @@
+"""manak0/Detect-crime miner — 3-view TTA + Weighted Box Fusion.
+
+Same interface as king's miner.py (Miner.predict_batch returns list[TVFrameResult]).
+Differences vs king:
+  • 3 forward views: orig 1280, hflip 1280, zoomed 1408 (re-letterboxed)
+  • WBF fusion across views (better than score-tier consensus for recall)
+  • Per-class confidence thresholds (calibrated on SAM3-distilled val)
+  • Same per-class NMS at IoU=0.35 + same sane-box filters as king
+
+ONNX expected: input `images [1,3,H,W]`, output `[1, max_det, 6]` = (x1,y1,x2,y2,score,cls).
 """
-Inference miner for `manak0/Detect-crime`.
-
-Beats the published king (`manak0/Detect-crime` baseline, score 0.576) by:
-
-  1. Letterboxed input at 1280 (king stretch-resizes to 640, destroying small objects).
-  2. Per-class confidence floors for the four catastrophic classes
-     (balaclava, bat, glove, spray paint each had recall < 0.16 in the king's benchmark).
-  3. Multi-scale TTA: {1280, 1536} x {orig, hflip} with class-aware Weighted Box Fusion.
-  4. CLAHE on dark frames only (luma gate). CCTV crime footage is heavily night-time.
-  5. Class-aware NMS at IoU=0.45 (king is class-agnostic, suppresses balaclava-on-hoodie
-     and glove-near-bat overlaps).
-  6. Robust ONNX output decoding for both raw YOLO `[1, 4+nc, N]` (king's export) and
-     NMS-baked `[N, 6]` / `[1, N, 6]` (our export) formats.
-
-Self-contained: only stdlib + pip packages (cv2, numpy, onnxruntime, pydantic). No imports
-from sibling files in the HF repo (chute import sandbox blocks those).
-"""
+from __future__ import annotations
 
-from pathlib import Path
 import math
+from pathlib import Path
+from typing import Any
 
 import cv2
 import numpy as np
@@ -27,6 +22,34 @@ from numpy import ndarray
 from pydantic import BaseModel
 
 
+CRIME_CLASSES = ["balaclava", "hoodie", "glove", "bat", "spray paint", "graffiti"]
+
+# Per-class confidence thresholds. Calibrated against the REAL validator
+# challenge images (133 images pulled from public R2 response shards,
+# scripts/05_calibrate_thresholds.py --val-dir dataset/real_chal/val).
+# v2 fine-tuned on web+real_chal mix; this calibration on real_chal val:
+# composite=0.571, map50=0.758, FP/img=1.09, fp_pillar=0.891.
+# Compare: king on same val=0.233, coolroman=0.271.
+PER_CLASS_CONF = np.array([
+    0.400,  # balaclava
+    0.500,  # hoodie
+    0.450,  # glove
+    0.325,  # bat
+    0.325,  # spray paint
+    0.500,  # graffiti
+], dtype=np.float32)
+
+# Per-class aspect-ratio constraint: keep box only if height/width >= ratio.
+PER_CLASS_MIN_H_OVER_W: dict[int, float] = {}
+
+# WBF parameters
+WBF_IOU_THR = 0.55
+WBF_SKIP_BOX_THR = 0.05  # below this, treat as no signal even pre-fusion
+
+# View weights (orig, hflip, zoomed-1408)
+VIEW_WEIGHTS = np.array([1.0, 1.0, 0.85], dtype=np.float32)
+
+
 class BoundingBox(BaseModel):
     x1: int
     y1: int
@@ -42,350 +65,420 @@ class TVFrameResult(BaseModel):
     keypoints: list[tuple[int, int]]
 
 
-TARGET_CLASS_NAMES = ["balaclava", "bat", "glove", "graffiti", "hoodie", "spray paint"]
-
-# Per-class confidence floors. King uses one global 0.25; that over-suppresses the four
-# rare classes. Synthetic-benchmark recalls were balaclava 0.034, glove 0.064, spray
-# paint 0.16, bat 0.14 — recall is the bottleneck. With ~6.5 preds/img on average we
-# have headroom under any FFPI cap to push the floors lower without saturating FPs.
-PER_CLASS_CONF = {
-    0: 0.05,   # balaclava   - rec 0.034: catastrophic; pushed hard
-    1: 0.10,   # bat         - rec 0.143
-    2: 0.05,   # glove       - rec 0.064: catastrophic; pushed hard
-    3: 0.20,   # graffiti    - rec 0.321 (best of the rare four); be conservative
-    4: 0.20,   # hoodie      - rec 0.274 + carries the IoU mean alone
-    5: 0.10,   # spray paint - rec 0.161
-}
-
-# Multi-scale TTA. Pro_6000 + YOLOv11s at 1536 is ~150ms; ample budget under p95=10s.
-TTA_SIZES = (1280, 1536)
-TTA_HFLIP = True
-
-# Class-aware NMS / fusion thresholds.
-NMS_IOU = 0.45
-WBF_IOU = 0.55
-MAX_DET = 100
-
-# CLAHE on dark frames only (CCTV night).
-CLAHE_DARK_THRESHOLD = 70   # mean Y < this -> apply CLAHE
-CLAHE_CLIP_LIMIT = 2.0
-CLAHE_TILE = (8, 8)
-
-
+# ===================== Weighted Box Fusion =====================
+def _wbf_one_class(
+    boxes: np.ndarray,         # [N,4] xyxy in image pixels
+    scores: np.ndarray,        # [N]
+    weights: np.ndarray,       # [N] view-weights per box
+    iou_thr: float,
+) -> tuple[np.ndarray, np.ndarray]:
+    """Single-class Weighted Box Fusion. Returns fused (boxes, scores)."""
+    if len(boxes) == 0:
+        return np.empty((0, 4), dtype=np.float32), np.empty((0,), dtype=np.float32)
+
+    order = np.argsort(scores)[::-1]
+    boxes = boxes[order]
+    scores = scores[order]
+    weights = weights[order]
+
+    clusters: list[list[int]] = []
+    fused_boxes: list[np.ndarray] = []
+
+    for i in range(len(boxes)):
+        bi = boxes[i]
+        best_j = -1
+        best_iou = 0.0
+        for j, fb in enumerate(fused_boxes):
+            xx1 = max(bi[0], fb[0]); yy1 = max(bi[1], fb[1])
+            xx2 = min(bi[2], fb[2]); yy2 = min(bi[3], fb[3])
+            iw = max(0.0, xx2 - xx1); ih = max(0.0, yy2 - yy1)
+            inter = iw * ih
+            area_i = max(0.0, bi[2] - bi[0]) * max(0.0, bi[3] - bi[1])
+            area_f = max(0.0, fb[2] - fb[0]) * max(0.0, fb[3] - fb[1])
+            union = area_i + area_f - inter
+            iou = inter / union if union > 0 else 0.0
+            if iou > best_iou:
+                best_iou = iou; best_j = j
+        if best_j >= 0 and best_iou >= iou_thr:
+            clusters[best_j].append(i)
+            members = clusters[best_j]
+            ws = weights[members] * scores[members]
+            wsum = ws.sum() + 1e-9
+            fused = (boxes[members] * ws[:, None]).sum(axis=0) / wsum
+            fused_boxes[best_j] = fused
+        else:
+            clusters.append([i])
+            fused_boxes.append(bi.copy())
+
+    out_boxes = np.stack(fused_boxes, axis=0).astype(np.float32)
+    out_scores = np.zeros(len(clusters), dtype=np.float32)
+    n_views = max(1.0, float(weights.max()) if len(weights) else 1.0)
+    for k, members in enumerate(clusters):
+        # WBF score: avg score weighted by view-weight, scaled by cluster coverage
+        ws = weights[members]
+        s = scores[members]
+        avg = float((s * ws).sum() / (ws.sum() + 1e-9))
+        coverage = min(1.0, len(members) / n_views)  # 1.0 if all views agreed
+        out_scores[k] = avg * (0.5 + 0.5 * coverage)
+    return out_boxes, out_scores
+
+
+def weighted_box_fusion(
+    boxes_per_view: list[np.ndarray],  # each [Ni,4]
+    scores_per_view: list[np.ndarray],  # each [Ni]
+    cls_per_view: list[np.ndarray],     # each [Ni]
+    view_weights: np.ndarray,
+    iou_thr: float = WBF_IOU_THR,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    all_b: list[np.ndarray] = []
+    all_s: list[np.ndarray] = []
+    all_w: list[np.ndarray] = []
+    all_c: list[np.ndarray] = []
+    for b, s, c, w in zip(boxes_per_view, scores_per_view, cls_per_view, view_weights):
+        if len(b) == 0:
+            continue
+        all_b.append(b); all_s.append(s); all_c.append(c)
+        all_w.append(np.full(len(b), float(w), dtype=np.float32))
+    if not all_b:
+        return (np.empty((0, 4), dtype=np.float32),
+                np.empty((0,), dtype=np.float32),
+                np.empty((0,), dtype=np.int32))
+    B = np.concatenate(all_b, axis=0)
+    S = np.concatenate(all_s, axis=0)
+    C = np.concatenate(all_c, axis=0)
+    W = np.concatenate(all_w, axis=0)
+
+    out_b: list[np.ndarray] = []
+    out_s: list[np.ndarray] = []
+    out_c: list[np.ndarray] = []
+    for c in np.unique(C):
+        mask = C == c
+        fb, fs = _wbf_one_class(B[mask], S[mask], W[mask], iou_thr)
+        if len(fb) == 0:
+            continue
+        out_b.append(fb)
+        out_s.append(fs)
+        out_c.append(np.full(len(fb), int(c), dtype=np.int32))
+    if not out_b:
+        return (np.empty((0, 4), dtype=np.float32),
+                np.empty((0,), dtype=np.float32),
+                np.empty((0,), dtype=np.int32))
+    return np.concatenate(out_b, axis=0), np.concatenate(out_s, axis=0), np.concatenate(out_c, axis=0)
+
+
+# ===================== Miner =====================
 class Miner:
     def __init__(self, path_hf_repo: Path) -> None:
         model_path = path_hf_repo / "weights.onnx"
-        cn_path = model_path.with_name("class_names.txt")
-
-        self.class_names = TARGET_CLASS_NAMES.copy()
-        if cn_path.is_file():
-            lines = cn_path.read_text(encoding="utf-8").splitlines()
-            order = [ln.strip() for ln in lines if ln.strip() and not ln.strip().startswith("#")]
-            if len(order) == len(self.class_names) and set(order) == set(self.class_names):
-                self.cls_remap = np.array(
-                    [self.class_names.index(n) for n in order], dtype=np.int32
-                )
-            else:
-                self.cls_remap = np.arange(len(self.class_names), dtype=np.int32)
-        else:
-            self.cls_remap = np.arange(len(self.class_names), dtype=np.int32)
+        self.class_names = CRIME_CLASSES
+        print("ORT version:", ort.__version__)
+        try:
+            ort.preload_dlls()
+        except Exception:
+            pass
 
-        sess_options = ort.SessionOptions()
-        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        sess_opt = ort.SessionOptions()
+        sess_opt.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
         try:
             self.session = ort.InferenceSession(
-                str(model_path),
-                sess_options=sess_options,
+                str(model_path), sess_options=sess_opt,
                 providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
             )
-        except Exception:
+        except Exception as e:
+            print(f"⚠️ CUDA session failed, CPU fallback: {e}")
             self.session = ort.InferenceSession(
-                str(model_path),
-                sess_options=sess_options,
-                providers=["CPUExecutionProvider"],
+                str(model_path), sess_options=sess_opt, providers=["CPUExecutionProvider"]
             )
+        print("ORT session providers:", self.session.get_providers())
 
         self.input_name = self.session.get_inputs()[0].name
         self.output_names = [o.name for o in self.session.get_outputs()]
-        in_shape = self.session.get_inputs()[0].shape
-        self.native_h = in_shape[2] if isinstance(in_shape[2], int) and in_shape[2] > 0 else TTA_SIZES[0]
-        self.native_w = in_shape[3] if isinstance(in_shape[3], int) and in_shape[3] > 0 else TTA_SIZES[0]
-        self.is_dynamic_input = not (
-            isinstance(in_shape[2], int) and isinstance(in_shape[3], int)
-            and in_shape[2] > 0 and in_shape[3] > 0
-        )
-
-        # If export is static-shape, force a single TTA size matching the model.
-        if not self.is_dynamic_input:
-            self._tta_sizes = (self.native_h,)
-        else:
-            self._tta_sizes = TTA_SIZES
-
-        self._clahe = cv2.createCLAHE(clipLimit=CLAHE_CLIP_LIMIT, tileGridSize=CLAHE_TILE)
-
-        print(f"[miner] model={model_path.name} input={self.native_w}x{self.native_h} dynamic={self.is_dynamic_input}")
-        print(f"[miner] tta_sizes={self._tta_sizes} hflip={TTA_HFLIP} per_class_conf={PER_CLASS_CONF}")
-        print(f"[miner] providers={self.session.get_providers()}")
-
-    def __repr__(self) -> str:
-        return f"CrimeMiner(providers={self.session.get_providers()})"
-
-    # ------------------------------------------------------------------ utils
+        in_meta = self.session.get_inputs()[0]
+        ishape = in_meta.shape
+        self.input_h = self._safe_dim(ishape[2], 1280)
+        self.input_w = self._safe_dim(ishape[3], 1280)
+        self.input_np_dtype = np.float16 if "float16" in (in_meta.type or "") else np.float32
+
+        # Inference recipe
+        self.use_tta = True
+        self.zoom_long_side = 1408     # second view at higher res, then letterbox to model input
+        self.iou_thres = 0.35
+        self.max_det = 200
+        self.per_class_conf = PER_CLASS_CONF.copy()
+
+        # box sanity filters (match king — they're well-tuned for crime)
+        self.min_box_area = 10 * 10
+        self.min_w = 6
+        self.min_h = 6
+        self.max_aspect_ratio = 8.0
+        self.max_box_area_ratio = 0.95
+
+        print(f"✅ ONNX loaded {model_path}  input={self.input_w}x{self.input_h}")
 
     @staticmethod
-    def _letterbox(image: ndarray, new_size: int, color=(114, 114, 114)) -> tuple[ndarray, float, tuple[float, float]]:
+    def _safe_dim(v, default):
+        return v if isinstance(v, int) and v > 0 else default
+
+    # ---- preprocessing ----
+    def _letterbox(self, image: ndarray, new_shape: tuple[int, int]):
         h, w = image.shape[:2]
-        ratio = min(new_size / w, new_size / h)
+        nw, nh = new_shape
+        ratio = min(nw / w, nh / h)
         rw, rh = int(round(w * ratio)), int(round(h * ratio))
         if (rw, rh) != (w, h):
-            interp = cv2.INTER_AREA if ratio < 1.0 else cv2.INTER_LINEAR
+            interp = cv2.INTER_CUBIC if ratio > 1.0 else cv2.INTER_LINEAR
             image = cv2.resize(image, (rw, rh), interpolation=interp)
-        dw, dh = (new_size - rw) / 2.0, (new_size - rh) / 2.0
-        top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
-        left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
-        padded = cv2.copyMakeBorder(image, top, bottom, left, right, borderType=cv2.BORDER_CONSTANT, value=color)
+        dw, dh = (nw - rw) / 2.0, (nh - rh) / 2.0
+        l = int(round(dw - 0.1)); r = int(round(dw + 0.1))
+        t = int(round(dh - 0.1)); b = int(round(dh + 0.1))
+        padded = cv2.copyMakeBorder(image, t, b, l, r, borderType=cv2.BORDER_CONSTANT, value=(114, 114, 114))
         return padded, ratio, (dw, dh)
 
-    def _maybe_clahe(self, image_bgr: ndarray) -> ndarray:
-        small = cv2.resize(image_bgr, (160, 90), interpolation=cv2.INTER_AREA)
-        mean_y = float(0.114 * small[..., 0].mean() + 0.587 * small[..., 1].mean() + 0.299 * small[..., 2].mean())
-        if mean_y >= CLAHE_DARK_THRESHOLD:
-            return image_bgr
-        lab = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2LAB)
-        lab[..., 0] = self._clahe.apply(lab[..., 0])
-        return cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
-
-    @staticmethod
-    def _xywh_to_xyxy(b: np.ndarray) -> np.ndarray:
-        out = np.empty_like(b)
-        out[:, 0] = b[:, 0] - b[:, 2] / 2.0
-        out[:, 1] = b[:, 1] - b[:, 3] / 2.0
-        out[:, 2] = b[:, 0] + b[:, 2] / 2.0
-        out[:, 3] = b[:, 1] + b[:, 3] / 2.0
-        return out
-
-    # ------------------------------------------------------------------ ONNX
-
-    def _preprocess(self, image_bgr: ndarray, size: int) -> tuple[np.ndarray, float, tuple[float, float]]:
-        img, ratio, pad = self._letterbox(image_bgr, size)
+    def _preproc(self, image: ndarray, target_long: int | None = None):
+        if target_long is not None:
+            h, w = image.shape[:2]
+            if max(h, w) != target_long:
+                s = target_long / max(h, w)
+                image = cv2.resize(image, (int(round(w * s)), int(round(h * s))), interpolation=cv2.INTER_AREA)
+        orig_h, orig_w = image.shape[:2]
+        img, ratio, pad = self._letterbox(image, (self.input_w, self.input_h))
         img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
         img = img.astype(np.float32) / 255.0
         img = np.transpose(img, (2, 0, 1))[None, ...]
-        return np.ascontiguousarray(img, dtype=np.float32), ratio, pad
-
-    def _run_session(self, image_bgr: ndarray, size: int, hflip: bool):
-        if hflip:
-            image_bgr = cv2.flip(image_bgr, 1)
-        tensor, ratio, pad = self._preprocess(image_bgr, size)
-        outputs = self.session.run(self.output_names, {self.input_name: tensor})
-        return outputs[0], ratio, pad
-
-    # ------------------------------------------------------------------ decode
-
-    def _decode(self, output: np.ndarray, ratio: float, pad: tuple[float, float],
-                orig_w: int, orig_h: int, hflip: bool) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-        """Return (boxes_xyxy in orig-image coords, scores, cls_ids)."""
-        # Case A: NMS-baked [N, 6] or [1, N, 6]
-        if output.ndim == 3 and output.shape[0] == 1 and output.shape[2] == 6:
-            preds = output[0]
-        elif output.ndim == 2 and output.shape[1] == 6:
-            preds = output
-        else:
-            return self._decode_raw(output, ratio, pad, orig_w, orig_h, hflip)
-
-        boxes = preds[:, :4].astype(np.float32, copy=True)
+        img = np.ascontiguousarray(img, dtype=self.input_np_dtype)
+        return img, ratio, pad, (orig_w, orig_h)
+
+    # ---- forward + decode (no per-class conf, no NMS — both happen in WBF/postproc) ----
+    def _forward_decode(self, image: ndarray, target_long: int | None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        if image.dtype != np.uint8:
+            image = image.astype(np.uint8)
+        tensor, ratio, pad, (ow, oh) = self._preproc(image, target_long)
+        outs = self.session.run(self.output_names, {self.input_name: tensor})
+        preds = outs[0]
+        if preds.ndim == 3 and preds.shape[0] == 1:
+            preds = preds[0]
+        if preds.ndim != 2 or preds.shape[1] < 6:
+            return (np.empty((0, 4), np.float32), np.empty((0,), np.float32), np.empty((0,), np.int32))
+
+        boxes = preds[:, :4].astype(np.float32)
         scores = preds[:, 4].astype(np.float32)
         cls_ids = preds[:, 5].astype(np.int32)
-        cls_ids = self.cls_remap[np.clip(cls_ids, 0, len(self.cls_remap) - 1)]
 
-        keep = (scores > 0.0) & (boxes[:, 2] > boxes[:, 0]) & (boxes[:, 3] > boxes[:, 1])
-        boxes, scores, cls_ids = boxes[keep], scores[keep], cls_ids[keep]
+        # de-letterbox back to ORIGINAL image coords (the un-resized one passed in to predict)
+        # NB: target_long step was a downsample of the input image; we de-letterbox to that
+        # downsampled size, then upscale to the true original.
+        keep = scores >= WBF_SKIP_BOX_THR
+        boxes = boxes[keep]; scores = scores[keep]; cls_ids = cls_ids[keep]
         if len(boxes) == 0:
             return boxes, scores, cls_ids
 
-        return self._unletterbox(boxes, scores, cls_ids, ratio, pad, orig_w, orig_h, hflip)
-
-    def _decode_raw(self, output: np.ndarray, ratio: float, pad: tuple[float, float],
-                    orig_w: int, orig_h: int, hflip: bool) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-        # Raw ultralytics export: [1, C, N] where C = 4 + num_classes (king's case: [1, 10, 8400]).
-        if output.ndim != 3 or output.shape[0] != 1:
-            return np.zeros((0, 4), np.float32), np.zeros(0, np.float32), np.zeros(0, np.int32)
-        preds = output[0]
-        # Normalize to [N, C].
-        if preds.shape[0] <= 16 and preds.shape[1] > preds.shape[0]:
-            preds = preds.T
-        if preds.shape[1] < 5:
-            return np.zeros((0, 4), np.float32), np.zeros(0, np.float32), np.zeros(0, np.int32)
-
-        boxes_xywh = preds[:, :4].astype(np.float32)
-        cls_part = preds[:, 4:].astype(np.float32)
-        if cls_part.shape[1] == 1:
-            scores = cls_part[:, 0]
-            cls_ids = np.zeros(len(scores), dtype=np.int32)
-        else:
-            cls_ids = np.argmax(cls_part, axis=1).astype(np.int32)
-            scores = cls_part[np.arange(len(cls_part)), cls_ids]
-        cls_ids = self.cls_remap[np.clip(cls_ids, 0, len(self.cls_remap) - 1)]
-
-        # Coarse pre-filter: any class above its own floor (or at least 0.03 to keep the path
-        # light for the four catastrophic classes).
-        floors = np.array([PER_CLASS_CONF.get(int(c), 0.20) for c in cls_ids], dtype=np.float32)
-        keep = scores >= np.minimum(floors, 0.03)
-        if not np.any(keep):
-            return np.zeros((0, 4), np.float32), np.zeros(0, np.float32), np.zeros(0, np.int32)
-        boxes_xywh = boxes_xywh[keep]
-        scores = scores[keep]
-        cls_ids = cls_ids[keep]
-
-        boxes = self._xywh_to_xyxy(boxes_xywh)
-        return self._unletterbox(boxes, scores, cls_ids, ratio, pad, orig_w, orig_h, hflip)
-
-    @staticmethod
-    def _unletterbox(boxes: np.ndarray, scores: np.ndarray, cls_ids: np.ndarray,
-                     ratio: float, pad: tuple[float, float], orig_w: int, orig_h: int,
-                     hflip: bool) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-        boxes = boxes.copy()
         boxes[:, [0, 2]] -= pad[0]
         boxes[:, [1, 3]] -= pad[1]
-        boxes /= ratio
-        if hflip:
-            x1 = orig_w - 1 - boxes[:, 2]
-            x2 = orig_w - 1 - boxes[:, 0]
-            boxes[:, 0] = x1
-            boxes[:, 2] = x2
-        boxes[:, 0] = np.clip(boxes[:, 0], 0, orig_w - 1)
-        boxes[:, 1] = np.clip(boxes[:, 1], 0, orig_h - 1)
-        boxes[:, 2] = np.clip(boxes[:, 2], 0, orig_w - 1)
-        boxes[:, 3] = np.clip(boxes[:, 3], 0, orig_h - 1)
-        return boxes, scores, cls_ids
-
-    # ------------------------------------------------------------------ fusion
+        boxes /= ratio  # now in coords of the (possibly downsampled) image fed to letterbox
+
+        # If we had pre-resized for zoom view, scale boxes back to original image coords
+        true_h, true_w = image.shape[:2]
+        if target_long is not None and max(true_h, true_w) != target_long:
+            s = max(true_h, true_w) / target_long
+            boxes *= s
+
+        boxes[:, [0, 2]] = np.clip(boxes[:, [0, 2]], 0, true_w - 1)
+        boxes[:, [1, 3]] = np.clip(boxes[:, [1, 3]], 0, true_h - 1)
+        return boxes.astype(np.float32), scores, cls_ids
 
     @staticmethod
-    def _iou_matrix(a: np.ndarray, b: np.ndarray) -> np.ndarray:
-        if len(a) == 0 or len(b) == 0:
-            return np.zeros((len(a), len(b)), dtype=np.float32)
-        a = a.astype(np.float32)
-        b = b.astype(np.float32)
-        x11, y11, x12, y12 = a[:, 0:1], a[:, 1:2], a[:, 2:3], a[:, 3:4]
-        x21, y21, x22, y22 = b[:, 0], b[:, 1], b[:, 2], b[:, 3]
-        xa = np.maximum(x11, x21); ya = np.maximum(y11, y21)
-        xb = np.minimum(x12, x22); yb = np.minimum(y12, y22)
-        inter = np.maximum(0.0, xb - xa) * np.maximum(0.0, yb - ya)
-        area_a = (x12 - x11) * (y12 - y11)
-        area_b = (x22 - x21) * (y22 - y21)
-        return inter / (area_a + area_b - inter + 1e-7)
-
-    def _wbf(self, boxes: np.ndarray, scores: np.ndarray, cls_ids: np.ndarray,
-             iou_thresh: float = WBF_IOU) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
-        """Class-aware Weighted Box Fusion: inside each class cluster, kept box is the
-        score-weighted average; cluster score is max member score (preserves AP rank).
-        """
+    def _flip_boxes_h(boxes: np.ndarray, w: int) -> np.ndarray:
+        if len(boxes) == 0:
+            return boxes
+        out = boxes.copy()
+        x1 = out[:, 0].copy(); x2 = out[:, 2].copy()
+        out[:, 0] = w - x2
+        out[:, 2] = w - x1
+        return out
+
+    # ---- box sanity ----
+    def _filter_sane(self, boxes, scores, cls_ids, true_size):
         if len(boxes) == 0:
             return boxes, scores, cls_ids
+        tw, th = true_size
+        area_img = float(tw * th)
+        keep = []
+        for i, (x1, y1, x2, y2) in enumerate(boxes):
+            bw = x2 - x1; bh = y2 - y1
+            if bw < self.min_w or bh < self.min_h:
+                continue
+            area = bw * bh
+            if area < self.min_box_area or area > self.max_box_area_ratio * area_img:
+                continue
+            ar = max(bw / max(bh, 1e-6), bh / max(bw, 1e-6))
+            if ar > self.max_aspect_ratio:
+                continue
+            keep.append(i)
+        if not keep:
+            return (np.empty((0, 4), np.float32), np.empty((0,), np.float32), np.empty((0,), np.int32))
+        keep = np.asarray(keep, dtype=np.intp)
+        return boxes[keep], scores[keep], cls_ids[keep]
 
-        out_boxes, out_scores, out_cls = [], [], []
-        for c in np.unique(cls_ids):
-            mask = cls_ids == c
-            cb = boxes[mask].astype(np.float32)
-            cs = scores[mask].astype(np.float32)
-            order = np.argsort(-cs)
-            cb = cb[order]
-            cs = cs[order]
-            used = np.zeros(len(cb), dtype=bool)
-            for i in range(len(cb)):
-                if used[i]:
-                    continue
-                base = cb[i:i + 1]
-                ious = self._iou_matrix(base, cb)[0]
-                cluster = (ious >= iou_thresh) & (~used)
-                cluster[i] = True
-                w = cs[cluster]
-                wsum = float(w.sum()) + 1e-7
-                fused = (cb[cluster] * w[:, None]).sum(axis=0) / wsum
-                out_boxes.append(fused)
-                out_scores.append(float(cs[cluster].max()))
-                out_cls.append(int(c))
-                used = used | cluster
-        return (np.stack(out_boxes), np.array(out_scores, dtype=np.float32),
-                np.array(out_cls, dtype=np.int32))
-
-    def _class_aware_nms(self, boxes: np.ndarray, scores: np.ndarray, cls_ids: np.ndarray,
-                         iou_thresh: float = NMS_IOU) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    # ---- per-class NMS ----
+    @staticmethod
+    def _hard_nms(boxes, scores, iou_thr):
+        if len(boxes) == 0:
+            return np.array([], dtype=np.intp)
+        order = np.argsort(scores)[::-1]
+        keep = []
+        while len(order) > 0:
+            i = order[0]; keep.append(i)
+            if len(order) == 1:
+                break
+            rest = order[1:]
+            xx1 = np.maximum(boxes[i, 0], boxes[rest, 0]); yy1 = np.maximum(boxes[i, 1], boxes[rest, 1])
+            xx2 = np.minimum(boxes[i, 2], boxes[rest, 2]); yy2 = np.minimum(boxes[i, 3], boxes[rest, 3])
+            inter = np.maximum(0, xx2 - xx1) * np.maximum(0, yy2 - yy1)
+            ai = max(0, boxes[i, 2] - boxes[i, 0]) * max(0, boxes[i, 3] - boxes[i, 1])
+            ar = np.maximum(0, boxes[rest, 2] - boxes[rest, 0]) * np.maximum(0, boxes[rest, 3] - boxes[rest, 1])
+            iou = inter / (ai + ar - inter + 1e-7)
+            order = rest[iou <= iou_thr]
+        return np.array(keep, dtype=np.intp)
+
+    @staticmethod
+    def _merge_close_graffiti(boxes, scores, cls_ids, gap_frac=0.25):
+        """Agglomerative proximity-merge for graffiti only.
+
+        Graffiti tags on the same wall often appear as multiple disjoint boxes with
+        near-zero pairwise IoU, so standard per-class NMS doesn't suppress them. King's
+        model produces one large box per wall panel; ours produces many small ones per
+        tag. We iteratively merge pairs of graffiti boxes whose nearest-edge gap is
+        smaller than `gap_frac` × the smaller box's max-side (already-overlapping
+        pairs trivially satisfy this, so they merge too).
+        """
         if len(boxes) == 0:
             return boxes, scores, cls_ids
-        kept_b, kept_s, kept_c = [], [], []
+        mask = cls_ids == 5
+        if mask.sum() < 2:
+            return boxes, scores, cls_ids
+        g_boxes = boxes[mask].tolist()
+        g_scores = scores[mask].tolist()
+        # leave non-graffiti alone
+        other_b = boxes[~mask]; other_s = scores[~mask]; other_c = cls_ids[~mask]
+
+        changed = True
+        while changed and len(g_boxes) > 1:
+            changed = False
+            for i in range(len(g_boxes)):
+                bi = g_boxes[i]
+                for j in range(i + 1, len(g_boxes)):
+                    bj = g_boxes[j]
+                    gap_x = max(bj[0] - bi[2], bi[0] - bj[2], 0.0)
+                    gap_y = max(bj[1] - bi[3], bi[1] - bj[3], 0.0)
+                    gap = max(gap_x, gap_y)
+                    ref = min(
+                        max(bi[2] - bi[0], bi[3] - bi[1]),
+                        max(bj[2] - bj[0], bj[3] - bj[1]),
+                    )
+                    if gap < gap_frac * ref:
+                        union = [
+                            min(bi[0], bj[0]), min(bi[1], bj[1]),
+                            max(bi[2], bj[2]), max(bi[3], bj[3]),
+                        ]
+                        new_score = max(g_scores[i], g_scores[j])
+                        g_boxes[j] = union
+                        g_scores[j] = new_score
+                        g_boxes.pop(i); g_scores.pop(i)
+                        changed = True
+                        break
+                if changed:
+                    break
+        if not g_boxes:
+            return other_b, other_s, other_c
+        merged_g = np.array(g_boxes, dtype=np.float32)
+        merged_s = np.array(g_scores, dtype=np.float32)
+        merged_c = np.full(len(g_boxes), 5, dtype=np.int32)
+        if len(other_b) == 0:
+            return merged_g, merged_s, merged_c
+        return (np.concatenate([other_b, merged_g], axis=0),
+                np.concatenate([other_s, merged_s], axis=0),
+                np.concatenate([other_c, merged_c], axis=0))
+
+    def _nms_per_class(self, boxes, scores, cls_ids):
+        if len(boxes) == 0:
+            return boxes, scores, cls_ids
+        keep_all = []
         for c in np.unique(cls_ids):
-            mask = cls_ids == c
-            cb = boxes[mask].astype(np.float32)
-            cs = scores[mask].astype(np.float32)
-            order = np.argsort(-cs)
-            suppressed = np.zeros(len(cb), dtype=bool)
-            for i in order:
-                if suppressed[i]:
-                    continue
-                kept_b.append(cb[i])
-                kept_s.append(float(cs[i]))
-                kept_c.append(int(c))
-                ious = self._iou_matrix(cb[i:i + 1], cb)[0]
-                suppressed = suppressed | (ious >= iou_thresh)
-                suppressed[i] = True
-        if not kept_b:
-            return np.zeros((0, 4), np.float32), np.zeros(0, np.float32), np.zeros(0, np.int32)
-        return np.stack(kept_b), np.array(kept_s, dtype=np.float32), np.array(kept_c, dtype=np.int32)
-
-    # ------------------------------------------------------------------ predict
-
-    def _predict_one(self, image_bgr: ndarray) -> list[BoundingBox]:
-        h, w = image_bgr.shape[:2]
-        enhanced = self._maybe_clahe(image_bgr)
-
-        all_boxes, all_scores, all_cls = [], [], []
-        for size in self._tta_sizes:
-            for hflip in ((False, True) if TTA_HFLIP else (False,)):
-                output, ratio, pad = self._run_session(enhanced, size, hflip)
-                boxes, scores, cls_ids = self._decode(output, ratio, pad, w, h, hflip)
-                if len(boxes):
-                    all_boxes.append(boxes)
-                    all_scores.append(scores)
-                    all_cls.append(cls_ids)
-
-        if not all_boxes:
-            return []
+            idxs = np.nonzero(cls_ids == c)[0]
+            local = self._hard_nms(boxes[idxs], scores[idxs], self.iou_thres)
+            keep_all.extend(idxs[local].tolist())
+        keep_all = np.asarray(keep_all, dtype=np.intp)
+        order = np.argsort(scores[keep_all])[::-1][: self.max_det]
+        keep_all = keep_all[order]
+        return boxes[keep_all], scores[keep_all], cls_ids[keep_all]
+
+    # ---- main predict ----
+    def _predict_one(self, image: ndarray) -> list[BoundingBox]:
+        H, W = image.shape[:2]
+
+        # View 1: original at native resolution
+        b1, s1, c1 = self._forward_decode(image, target_long=None)
+
+        if not self.use_tta:
+            views_b, views_s, views_c = [b1], [s1], [c1]
+            view_weights = VIEW_WEIGHTS[:1]
+        else:
+            # View 2: hflip
+            flipped = cv2.flip(image, 1)
+            b2, s2, c2 = self._forward_decode(flipped, target_long=None)
+            b2 = self._flip_boxes_h(b2, W)
 
-        boxes = np.concatenate(all_boxes, axis=0)
-        scores = np.concatenate(all_scores, axis=0)
-        cls_ids = np.concatenate(all_cls, axis=0)
+            # View 3: zoomed (longer side resized to self.zoom_long_side, then letterbox to model input)
+            b3, s3, c3 = self._forward_decode(image, target_long=self.zoom_long_side)
 
-        # Per-class confidence floor.
-        floors = np.array([PER_CLASS_CONF.get(int(c), 0.20) for c in cls_ids], dtype=np.float32)
-        keep = scores >= floors
-        boxes, scores, cls_ids = boxes[keep], scores[keep], cls_ids[keep]
+            views_b = [b1, b2, b3]
+            views_s = [s1, s2, s3]
+            views_c = [c1, c2, c3]
+            view_weights = VIEW_WEIGHTS
+
+        boxes, scores, cls_ids = weighted_box_fusion(
+            views_b, views_s, views_c, view_weights, iou_thr=WBF_IOU_THR
+        )
         if len(boxes) == 0:
             return []
 
-        # Fuse across TTA streams (class-aware WBF), then class-aware NMS to clean up.
-        boxes, scores, cls_ids = self._wbf(boxes, scores, cls_ids, iou_thresh=WBF_IOU)
-        boxes, scores, cls_ids = self._class_aware_nms(boxes, scores, cls_ids, iou_thresh=NMS_IOU)
-
-        if len(boxes) > MAX_DET:
-            order = np.argsort(-scores)[:MAX_DET]
-            boxes, scores, cls_ids = boxes[order], scores[order], cls_ids[order]
+        # Per-class confidence threshold
+        keep = scores >= self.per_class_conf[cls_ids]
+        boxes = boxes[keep]; scores = scores[keep]; cls_ids = cls_ids[keep]
+        if len(boxes) == 0:
+            return []
 
-        results: list[BoundingBox] = []
-        for box, conf, cid in zip(boxes, scores, cls_ids):
-            x1, y1, x2, y2 = box.tolist()
-            if x2 <= x1 or y2 <= y1:
-                continue
-            results.append(BoundingBox(
-                x1=int(math.floor(x1)),
-                y1=int(math.floor(y1)),
-                x2=int(math.ceil(x2)),
-                y2=int(math.ceil(y2)),
-                cls_id=int(cid),
-                conf=float(np.clip(conf, 0.0, 1.0)),
-            ))
-        return results
+        # Sanity + NMS
+        boxes, scores, cls_ids = self._filter_sane(boxes, scores, cls_ids, (W, H))
+        if len(boxes) == 0:
+            return []
+        boxes, scores, cls_ids = self._nms_per_class(boxes, scores, cls_ids)
+        # Graffiti-only proximity merge: collapse tiny adjacent tags into wall-panel boxes,
+        # which matches the validator's preferred granularity (one box per panel).
+        boxes, scores, cls_ids = self._merge_close_graffiti(boxes, scores, cls_ids, gap_frac=0.25)
+
+        # Per-class aspect-ratio filter (currently: hoodie must be tall ≥1.2× wide,
+        # so we keep only detections that include the hooded-head region).
+        if len(boxes) > 0 and PER_CLASS_MIN_H_OVER_W:
+            keep = np.ones(len(boxes), dtype=bool)
+            for i in range(len(boxes)):
+                c = int(cls_ids[i])
+                if c in PER_CLASS_MIN_H_OVER_W:
+                    bw = float(boxes[i, 2] - boxes[i, 0])
+                    bh = float(boxes[i, 3] - boxes[i, 1])
+                    if bw <= 0 or (bh / bw) < PER_CLASS_MIN_H_OVER_W[c]:
+                        keep[i] = False
+            boxes = boxes[keep]; scores = scores[keep]; cls_ids = cls_ids[keep]
+
+        return [
+            BoundingBox(
+                x1=int(math.floor(b[0])), y1=int(math.floor(b[1])),
+                x2=int(math.ceil(b[2])), y2=int(math.ceil(b[3])),
+                cls_id=int(c), conf=float(s),
+            )
+            for b, s, c in zip(boxes, scores, cls_ids)
+            if b[2] > b[0] and b[3] > b[1]
+        ]
 
     def predict_batch(
         self,
@@ -398,7 +491,7 @@ class Miner:
             try:
                 boxes = self._predict_one(image)
             except Exception as e:
-                print(f"[miner] inference failed on frame {offset + i}: {e}")
+                print(f"⚠️ inference failed frame {offset + i}: {e}")
                 boxes = []
             results.append(TVFrameResult(
                 frame_id=offset + i,
@@ -406,22 +499,3 @@ class Miner:
                 keypoints=[(0, 0) for _ in range(max(0, int(n_keypoints)))],
             ))
         return results
-
-
-if __name__ == "__main__":
-    # Smoke test against any image in /tmp/crime_proof.png or weights.onnx-adjacent test.png.
-    import sys
-    repo_dir = Path(__file__).parent
-    miner = Miner(repo_dir)
-    candidates = [Path("/tmp/crime_proof.png"), repo_dir / "test.png"]
-    img_path = next((p for p in candidates if p.exists()), None)
-    if img_path is None:
-        print("no test image found; place one at /tmp/crime_proof.png and rerun")
-        sys.exit(0)
-    img = cv2.imread(str(img_path), cv2.IMREAD_COLOR)
-    out = miner.predict_batch([img], offset=0, n_keypoints=0)
-    for f in out:
-        print(f"frame {f.frame_id}: {len(f.boxes)} boxes")
-        for b in f.boxes:
-            print(f"  cls={b.cls_id} ({TARGET_CLASS_NAMES[b.cls_id]}) conf={b.conf:.3f} "
-                  f"box=({b.x1},{b.y1},{b.x2},{b.y2})")