Upload folder using huggingface_hub

chute_config.yml

@@ -2,8 +2,8 @@ Image:
   from_base: parachutes/python:3.12
   run_command:
     - pip install --upgrade setuptools wheel
-    - pip install 'numpy>=1.23' 'onnxruntime-gpu[cuda,cudnn]>=1.16' 'opencv-python>=4.7' 'pillow>=9.5' 'huggingface_hub>=0.19.4' 'pydantic>=2.0' 'pyyaml>=6.0' 'aiohttp>=3.9'
-    - pip install torch torchvision
+    - pip install 'numpy>=1.23' 'onnxruntime-gpu>=1.16' 'opencv-python>=4.7' 'pillow>=9.5' 'huggingface_hub>=0.19.4' 'pydantic>=2.0' 'pyyaml>=6.0' 'aiohttp>=3.9'
+    - pip install torch==2.8.0 torchvision==0.23.0 torchaudio==2.8.0 --index-url https://download.pytorch.org/whl/cu128
 
 NodeSelector:
   gpu_count: 1
@@ -18,4 +18,4 @@ Chute:
   max_instances: 5
   scaling_threshold: 0.5
   shutdown_after_seconds: 288000
-  tee: true
+  tee: true

miner.py

@@ -1,36 +1,12 @@
-"""
-TurboVision miner for element `manak0/Detect-road-signs` — ONNX / CPU-safe.
-
-Single class: cls_id 0 == "road sign". Element scoring:
-  composite = max(0.6*map50 + 0.4*false_positive - 0.37, 0.01), per-challenge ceiling 0.63.
-
-Pure onnxruntime, deterministic, sandbox-safe (only cv2/numpy/onnxruntime/os imports;
-no network or dynamic-exec calls), requires a `.onnx` in the repo. Runs on a GPU chute,
-but ALSO passes the 2-vCPU CPU compliance loop (100ms gate): imgsz 512, no TTA -> ~58ms.
-"""
 from pathlib import Path
-import os
+import math
 
-import numpy as np
 import cv2
+import numpy as np
 import onnxruntime as ort
+from numpy import ndarray
 from pydantic import BaseModel
 
-CLASSES = ["road sign"]
-
-# RECALL-FIRST config (v2r @576). Live challenges have small/distant signs; the fp
-# pillar is forgiving (÷10), so low conf + NO min-size filters maximizes map50.
-# Sanity min_side/min_area OFF (they dropped small live signs); keep a loose aspect cap.
-CONF = float(os.environ.get("RS_CONF", "0.13"))          # single-class conf floor (recall)
-IOU_NMS = float(os.environ.get("RS_IOU", "0.50"))        # hard NMS IoU
-MAX_DET = int(os.environ.get("RS_MAX_DET", "300"))
-MAX_ASPECT = float(os.environ.get("RS_MAX_ASPECT", "8.0"))  # drop only extreme slivers (never real signs)
-MIN_SIDE = float(os.environ.get("RS_MIN_SIDE", "0"))        # OFF — keep small/distant signs
-MIN_AREA = float(os.environ.get("RS_MIN_AREA", "0"))        # OFF — keep small/distant signs
-USE_TTA = os.environ.get("RS_TTA", "0") not in ("0", "", "false")  # OFF for 100ms compliance
-FALLBACK = os.environ.get("RS_FALLBACK", "1") not in ("0", "", "false")  # emit top candidate if frame empty
-MODEL_FILE = os.environ.get("RS_MODEL", "weights.onnx")
-
 
 class BoundingBox(BaseModel):
     x1: int
@@ -41,158 +17,486 @@ class BoundingBox(BaseModel):
     conf: float
 
 
-class Polygon(BaseModel):
-    cls_id: int
-    conf: float
-    points: list[tuple[int, int]]
-
-
 class TVFrameResult(BaseModel):
     frame_id: int
-    boxes: list[BoundingBox] | None = None
-    polygons: list[Polygon] | None = None
-    keypoints: list[tuple[int, int]] | None = None
-
-
-def _letterbox(img: np.ndarray, new_shape: tuple[int, int]):
-    h, w = img.shape[:2]
-    nh, nw = new_shape
-    r = min(nh / h, nw / w)
-    uw, uh = int(round(w * r)), int(round(h * r))
-    resized = cv2.resize(img, (uw, uh), interpolation=cv2.INTER_LINEAR)
-    pad_w, pad_h = (nw - uw) / 2, (nh - uh) / 2
-    top, bottom = int(round(pad_h - 0.1)), int(round(pad_h + 0.1))
-    left, right = int(round(pad_w - 0.1)), int(round(pad_w + 0.1))
-    out = cv2.copyMakeBorder(resized, top, bottom, left, right, cv2.BORDER_CONSTANT, value=(114, 114, 114))
-    return out, r, left, top
-
-
-def _nms(boxes: np.ndarray, scores: np.ndarray, iou_thr: float) -> list[int]:
-    if len(boxes) == 0:
-        return []
-    x1, y1, x2, y2 = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
-    areas = np.maximum(0, x2 - x1) * np.maximum(0, y2 - y1)
-    order = scores.argsort()[::-1]
-    keep = []
-    while order.size > 0:
-        i = order[0]
-        keep.append(int(i))
-        if order.size == 1:
-            break
-        xx1 = np.maximum(x1[i], x1[order[1:]])
-        yy1 = np.maximum(y1[i], y1[order[1:]])
-        xx2 = np.minimum(x2[i], x2[order[1:]])
-        yy2 = np.minimum(y2[i], y2[order[1:]])
-        inter = np.maximum(0, xx2 - xx1) * np.maximum(0, yy2 - yy1)
-        iou = inter / (areas[i] + areas[order[1:]] - inter + 1e-9)
-        order = order[1:][iou <= iou_thr]
-    return keep
+    boxes: list[BoundingBox]
+    keypoints: list[tuple[int, int]]
 
 
 class Miner:
+    """
+    YOLO ONNX miner for car wash detection. Single forward pass per frame (no TTA).
+
+    Classes: broom, drainage gate, nozzle, track
+
+    Pipeline per frame: preprocess -> ONNX -> decode -> per-class conf threshold
+    (+ rescue bonus) -> un-letterbox -> sanity filter -> per-class NMS ->
+    cross-class dedup -> same-class cluster score boost -> results.
+
+    Speed characteristics:
+      - The detection pipeline runs exactly ONCE per frame.
+      - `_max_score_per_cluster` (the cluster boost) is a single vectorized IoU
+        matrix, so cost stays flat as the number of detected objects grows
+        instead of scaling like a Python loop.
+      - `_hard_nms` precomputes box areas once; `pre_nms_topk` bounds NMS cost
+        on pathologically crowded frames.
+    """
+
+    class_names = ['broom', 'drainage gate', 'nozzle', 'track']
+    input_size = 640
+    cross_iou_thresh = 0.9
+    max_det = 300
+    # NMS is O(n^2). If a frame yields a huge candidate list, keep only the
+    # top-K by score before NMS. Set high enough to never touch real detections.
+    pre_nms_topk = 1000
+    #overlap_suppress_threshold = 0.85
+
+    # Per-class confidence thresholds
+    _conf_thres_array = np.array([0.35, 0.7, 0.4, 0.7], dtype=np.float32)
+    _extra_conf_thres_array = np.array([0.32, 0.3, 0.36, 0.3], dtype=np.float32)
+
+    # Per-class IoU thresholds for same-class NMS
+    _iou_thres_array = np.array([0.6, 0.7, 0.5, 0.7], dtype=np.float32)
+
+    # Per-class rescue bonus
+    _bonus_array = np.array([0.2, 0.2, 0.0, 0.2], dtype=np.float32)
+
+    # Per-class minimum box area  (0=broom, 1=drainage gate, 2=nozzle, 3=track)
+    _min_box_area_array = np.array([144.0, 144.0, 4.0, 64.0], dtype=np.float32)
+
     def __init__(self, path_hf_repo: Path) -> None:
-        model_path = str(Path(path_hf_repo) / MODEL_FILE)
-        providers = os.environ.get("RS_PROVIDERS", "CPUExecutionProvider").split(",")
-        avail = ort.get_available_providers()
-        providers = [p for p in providers if p in avail] or ["CPUExecutionProvider"]
-        so = ort.SessionOptions()
-        so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
-        so.intra_op_num_threads = int(os.environ.get("RS_THREADS", "0"))
-        self.sess = ort.InferenceSession(model_path, sess_options=so, providers=providers)
-        self.inp = self.sess.get_inputs()[0]
-        shape = self.inp.shape  # [1,3,H,W]
-        self.H = int(shape[2]) if isinstance(shape[2], int) else 1024
-        self.W = int(shape[3]) if isinstance(shape[3], int) else 1024
-        self.nc = len(CLASSES)
-        dummy = np.zeros((1, 3, self.H, self.W), dtype=np.float32)
-        self.sess.run(None, {self.inp.name: dummy})
-        print(f"RoadSign ONNX loaded {MODEL_FILE} input={self.H}x{self.W} providers={providers} conf={CONF}")
+        self.path_hf_repo = path_hf_repo
+
+        print("ORT version:", ort.__version__)
+
+        try:
+            ort.preload_dlls()
+            print("preload_dlls success")
+        except Exception as e:
+            print(f"preload_dlls failed: {e}")
+
+        print("ORT available providers BEFORE session:", ort.get_available_providers())
+
+        sess_options = ort.SessionOptions()
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+
+        self.session = ort.InferenceSession(
+            str(path_hf_repo / "weights.onnx"),
+            sess_options=sess_options,
+            providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
+        )
+        print("Created ORT session with preferred CUDA provider list")
+        print("ORT session providers:", self.session.get_providers())
+        # If CUDAExecutionProvider is NOT listed above, you are running on CPU.
+
+        self.input_name = self.session.get_inputs()[0].name
+        input_shape = self.session.get_inputs()[0].shape
+
+        self.input_h = self._safe_dim(input_shape[2], default=self.input_size)
+        self.input_w = self._safe_dim(input_shape[3], default=self.input_size)
+
+        # Same-class cluster score boost. Raises the confidence of overlapping
+        # same-class survivors to their cluster max. Part of the current tuned
+        # behaviour; set False to disable (slightly faster, changes confidences).
+        self.use_cluster_boost = True
+        self._avg_iou = float(np.mean(self._iou_thres_array))
+
+        self._warmup()
+
+    def _warmup(self, iters: int = 3) -> None:
+        try:
+            dummy = np.zeros((720, 1280, 3), dtype=np.uint8)
+            for _ in range(max(1, iters)):
+                self.predict_batch(batch_images=[dummy], offset=0, n_keypoints=0)
+            print(f"warmup: {iters} dummy predict_batch call(s) done")
+        except Exception as e:
+            print(f"warmup skipped: {e}")
 
     def __repr__(self) -> str:
-        return f"RoadSign ONNX ({MODEL_FILE}) {self.H}x{self.W} conf={CONF} tta={USE_TTA}"
-
-    def _preprocess(self, img_bgr: np.ndarray):
-        lb, r, pad_w, pad_h = _letterbox(img_bgr, (self.H, self.W))
-        rgb = lb[:, :, ::-1].astype(np.float32) / 255.0  # BGR->RGB, 0-1 (manifest norm rgb-01)
-        chw = np.transpose(rgb, (2, 0, 1))
-        return chw, r, pad_w, pad_h
-
-    def _decode(self, out: np.ndarray, r: float, pad_w: float, pad_h: float,
-                orig_w: int, orig_h: int, flipped: bool, thresh: float = None):
-        if thresh is None:
-            thresh = CONF
-        pred = out[0]
-        if pred.shape[0] == (4 + self.nc):
-            pred = pred.transpose(1, 0)
-        boxes_xywh = pred[:, :4]
-        cls_scores = pred[:, 4:4 + self.nc]
-        conf = cls_scores.max(1)
-        m = conf >= thresh
-        if not m.any():
-            return np.zeros((0, 4), np.float32), np.zeros((0,), np.float32)
-        boxes_xywh, conf = boxes_xywh[m], conf[m]
-        cx, cy, w, h = boxes_xywh[:, 0], boxes_xywh[:, 1], boxes_xywh[:, 2], boxes_xywh[:, 3]
-        x1 = (cx - w / 2 - pad_w) / r
-        y1 = (cy - h / 2 - pad_h) / r
-        x2 = (cx + w / 2 - pad_w) / r
-        y2 = (cy + h / 2 - pad_h) / r
-        if flipped:
-            nx1 = orig_w - x2
-            nx2 = orig_w - x1
-            x1, x2 = nx1, nx2
-        xyxy = np.stack([x1, y1, x2, y2], 1)
-        xyxy[:, [0, 2]] = xyxy[:, [0, 2]].clip(0, orig_w)
-        xyxy[:, [1, 3]] = xyxy[:, [1, 3]].clip(0, orig_h)
-        return xyxy, conf
-
-    def _finalize(self, xyxy, conf) -> list[BoundingBox]:
-        if len(xyxy) == 0:
-            return []
-        keep = _nms(xyxy, conf, IOU_NMS)[:MAX_DET]
-        out = []
-        for j in keep:
-            w = max(1e-6, xyxy[j, 2] - xyxy[j, 0])
-            h = max(1e-6, xyxy[j, 3] - xyxy[j, 1])
-            if MIN_SIDE > 0 and min(w, h) < MIN_SIDE:              # sanity: tiny side
+        return f"Car Wash Miner classes={len(self.class_names)}"
+
+    @staticmethod
+    def _safe_dim(value, default: int) -> int:
+        return value if isinstance(value, int) and value > 0 else default
+
+    # ─── Preprocessing ────────────────────────────────────────────
+
+    def _letterbox(
+        self, image: ndarray, new_shape: tuple[int, int],
+        color: tuple[int, int, int] = (114, 114, 114),
+    ) -> tuple[ndarray, float, float, float]:
+        orig_h, orig_w = image.shape[:2]
+        target_w, target_h = new_shape
+
+        r = min(target_w / orig_w, target_h / orig_h)
+        new_unpad_w = int(round(orig_w * r))
+        new_unpad_h = int(round(orig_h * r))
+
+        resized = cv2.resize(image, (new_unpad_w, new_unpad_h), interpolation=cv2.INTER_LINEAR)
+
+        dw = target_w - new_unpad_w
+        dh = target_h - new_unpad_h
+        pad_w = dw / 2.0
+        pad_h = dh / 2.0
+
+        left = int(round(pad_w - 0.1))
+        right = int(round(pad_w + 0.1))
+        top = int(round(pad_h - 0.1))
+        bottom = int(round(pad_h + 0.1))
+
+        out = cv2.copyMakeBorder(
+            resized, top, bottom, left, right,
+            cv2.BORDER_CONSTANT, value=color,
+        )
+        return out, r, pad_w, pad_h
+
+    def _preprocess(self, image_bgr: np.ndarray,
+                   allow_pad: bool = True) -> tuple[np.ndarray, dict]:
+        orig_h, orig_w = image_bgr.shape[:2]
+        extra_left = 0
+        extra_right = 0
+        if allow_pad and orig_w == orig_h:          # only pad when allowed
+            target_w = int(orig_w * 1.05)
+            if target_w > orig_w:
+                total_extra = target_w - orig_w
+                extra_left = total_extra // 2
+                extra_right = total_extra - extra_left
+                image_bgr = cv2.copyMakeBorder(
+                    image_bgr, 0, 0, extra_left, extra_right,
+                    cv2.BORDER_CONSTANT, value=(114, 114, 114),
+                )
+        rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
+        img, ratio, pad_w, pad_h = self._letterbox(rgb, (self.input_w, self.input_h))
+        x = img.astype(np.float32) / 255.0
+        x = np.transpose(x, (2, 0, 1))[None, ...]
+        x = np.ascontiguousarray(x)
+        return x, {
+            "orig_h": orig_h, "orig_w": orig_w,
+            "ratio": ratio, "pad_w": pad_w, "pad_h": pad_h,
+            "extra_left": extra_left, "extra_right": extra_right,
+        }
+
+    # ─── Vectorized box operations ───────────────────────────────
+
+    @staticmethod
+    def _clip_boxes(boxes: np.ndarray, image_size: tuple[int, int]) -> np.ndarray:
+        w, h = image_size
+        boxes[:, 0] = np.clip(boxes[:, 0], 0, w - 1)
+        boxes[:, 1] = np.clip(boxes[:, 1], 0, h - 1)
+        boxes[:, 2] = np.clip(boxes[:, 2], 0, w - 1)
+        boxes[:, 3] = np.clip(boxes[:, 3], 0, h - 1)
+        return boxes
+
+    @staticmethod
+    def _hard_nms(boxes: np.ndarray, scores: np.ndarray,
+                  iou_thresh: float) -> np.ndarray:
+        """Vectorized greedy NMS. Areas precomputed once. Returns indices to keep."""
+        n = len(boxes)
+        if n == 0:
+            return np.array([], dtype=np.intp)
+        x1, y1 = boxes[:, 0], boxes[:, 1]
+        x2, y2 = boxes[:, 2], boxes[:, 3]
+        areas = np.maximum(0.0, x2 - x1) * np.maximum(0.0, y2 - y1)
+        order = np.argsort(-scores)
+        keep = []
+        while order.size > 0:
+            i = int(order[0])
+            keep.append(i)
+            if order.size == 1:
+                break
+            rest = order[1:]
+            xx1 = np.maximum(x1[i], x1[rest])
+            yy1 = np.maximum(y1[i], y1[rest])
+            xx2 = np.minimum(x2[i], x2[rest])
+            yy2 = np.minimum(y2[i], y2[rest])
+            inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
+            iou = inter / (areas[i] + areas[rest] - inter + 1e-7)
+            order = rest[iou <= iou_thresh]
+        return np.array(keep, dtype=np.intp)
+
+    def _per_class_hard_nms(self, boxes: np.ndarray, scores: np.ndarray,
+                            cls_ids: np.ndarray) -> np.ndarray:
+        """Per-class NMS using per-class IoU thresholds."""
+        if len(boxes) == 0:
+            return np.array([], dtype=np.intp)
+        all_keep = []
+        for c in np.unique(cls_ids):
+            mask = cls_ids == c
+            indices = np.where(mask)[0]
+            cls_iou = float(self._iou_thres_array[c])  # per-class IoU threshold
+            keep = self._hard_nms(boxes[mask], scores[mask], cls_iou)
+            all_keep.extend(indices[keep].tolist())
+        all_keep.sort()
+        return np.array(all_keep, dtype=np.intp)
+
+    def _cross_class_dedup_op(self, boxes: np.ndarray, scores: np.ndarray,
+                              cls_ids: np.ndarray, iou_thresh: float
+                              ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        n = len(boxes)
+        if n <= 1:
+            return boxes, scores, cls_ids
+        boxes = np.asarray(boxes, dtype=np.float32)
+        scores = np.asarray(scores, dtype=np.float32)
+        cls_ids = np.asarray(cls_ids, dtype=np.int32)
+        areas = (np.maximum(0.0, boxes[:, 2] - boxes[:, 0]) *
+                 np.maximum(0.0, boxes[:, 3] - boxes[:, 1]))
+        margins = scores - self._conf_thres_array[cls_ids]
+        order = np.lexsort((-areas, -margins))
+        suppressed = np.zeros(n, dtype=bool)
+        keep = []
+        for i in order:
+            if suppressed[i]:
                 continue
-            if MIN_AREA > 0 and (w * h) < MIN_AREA:                # sanity: tiny area
+            keep.append(int(i))
+            bi = boxes[i]
+            xx1 = np.maximum(bi[0], boxes[:, 0])
+            yy1 = np.maximum(bi[1], boxes[:, 1])
+            xx2 = np.minimum(bi[2], boxes[:, 2])
+            yy2 = np.minimum(bi[3], boxes[:, 3])
+            inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
+            a_i = max(1e-7, float((bi[2] - bi[0]) * (bi[3] - bi[1])))
+            iou = inter / (a_i + areas - inter + 1e-7)
+            dup = iou > iou_thresh
+            dup[i] = False
+            suppressed |= dup
+        keep_idx = np.array(keep, dtype=np.intp)
+        return boxes[keep_idx], scores[keep_idx], cls_ids[keep_idx]
+
+    def _filter_sane_boxes(self, boxes: np.ndarray, scores: np.ndarray,
+                       cls_ids: np.ndarray, orig_size: tuple[int, int]
+                       ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """Filter by per-class min area and max area ratio."""
+        if len(boxes) == 0:
+            return boxes, scores, cls_ids
+
+        orig_w, orig_h = orig_size
+        image_area = float(orig_w * orig_h)
+        bw = np.maximum(0.0, boxes[:, 2] - boxes[:, 0])
+        bh = np.maximum(0.0, boxes[:, 3] - boxes[:, 1])
+        area = bw * bh
+
+        class_min_area = self._min_box_area_array[cls_ids]
+
+        keep = (
+            (area >= class_min_area) &
+            (area <= 0.95 * image_area)
+        )
+        return boxes[keep], scores[keep], cls_ids[keep]
+
+    def _max_score_per_cluster(self, post_boxes: np.ndarray,
+                               post_cls: np.ndarray,
+                               full_boxes: np.ndarray,
+                               full_scores: np.ndarray,
+                               full_cls: np.ndarray,
+                               iou_thresh: float) -> np.ndarray:
+        """For each kept box, confidence = max score in its SAME-CLASS IoU cluster.
+        Vectorized: single (n_post x n_full) IoU matrix, no per-box Python loop."""
+        n = len(post_boxes)
+        if n == 0:
+            return np.empty(0, dtype=np.float32)
+        m = len(full_boxes)
+        if m == 0:
+            return np.zeros(n, dtype=np.float32)
+        pa = (np.maximum(0.0, post_boxes[:, 2] - post_boxes[:, 0]) *
+              np.maximum(0.0, post_boxes[:, 3] - post_boxes[:, 1]))
+        fa = (np.maximum(0.0, full_boxes[:, 2] - full_boxes[:, 0]) *
+              np.maximum(0.0, full_boxes[:, 3] - full_boxes[:, 1]))
+        xx1 = np.maximum(post_boxes[:, 0][:, None], full_boxes[:, 0][None, :])
+        yy1 = np.maximum(post_boxes[:, 1][:, None], full_boxes[:, 1][None, :])
+        xx2 = np.minimum(post_boxes[:, 2][:, None], full_boxes[:, 2][None, :])
+        yy2 = np.minimum(post_boxes[:, 3][:, None], full_boxes[:, 3][None, :])
+        inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
+        iou = inter / (pa[:, None] + fa[None, :] - inter + 1e-7)
+        mask = (iou >= iou_thresh) & (post_cls[:, None] == full_cls[None, :])
+        tiled = np.where(mask, full_scores[None, :], -np.inf)
+        out = tiled.max(axis=1)
+        out[~np.isfinite(out)] = 0.0
+        return out.astype(np.float32)
+
+    def _conf_filter_mask(self, scores: np.ndarray,
+                          cls_ids: np.ndarray, extra_left: int) -> np.ndarray:
+        """Per-class threshold with rescue bonus for missed classes."""
+        if len(scores) == 0:
+            return np.zeros(0, dtype=bool)
+        thr = 0
+        if extra_left > 0:
+            thr = self._extra_conf_thres_array[cls_ids]
+        else:
+            thr = self._conf_thres_array[cls_ids]
+        keep = scores >= thr
+        for c in np.unique(cls_ids):
+            b = float(self._bonus_array[c])
+            if b <= 0.0:
+                continue
+            cm = cls_ids == c
+            if keep[cm].any():
                 continue
-            if MAX_ASPECT > 0 and max(w / h, h / w) > MAX_ASPECT:  # sanity: extreme aspect
+            idx = np.where(cm)[0]
+            top = int(idx[int(np.argmax(scores[idx]))])
+            if scores[top] >= self._conf_thres_array[c] - b:
+                keep[top] = True
+        return keep
+
+    def _per_view_pipeline(self, boxes: np.ndarray, scores: np.ndarray,
+                           cls_ids: np.ndarray, orig_size: tuple[int, int]
+                           ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """Sanity filter -> (top-k cap) -> per-class NMS -> cap -> cross-class dedup."""
+        boxes, scores, cls_ids = self._filter_sane_boxes(
+            boxes, scores, cls_ids, orig_size
+        )
+        if len(boxes) == 0:
+            return boxes, scores, cls_ids
+        if len(scores) > self.pre_nms_topk:
+            top = np.argpartition(-scores, self.pre_nms_topk)[: self.pre_nms_topk]
+            boxes, scores, cls_ids = boxes[top], scores[top], cls_ids[top]
+        if len(boxes) > 1:
+            keep = self._per_class_hard_nms(boxes, scores, cls_ids)
+            boxes, scores, cls_ids = boxes[keep], scores[keep], cls_ids[keep]
+        if len(scores) > self.max_det:
+            top = np.argsort(-scores)[: self.max_det]
+            boxes, scores, cls_ids = boxes[top], scores[top], cls_ids[top]
+        if len(boxes) > 1:
+            boxes, scores, cls_ids = self._cross_class_dedup_op(
+                boxes, scores, cls_ids, self.cross_iou_thresh
+            )
+        return boxes, scores, cls_ids
+
+    # ─── Decoding ─────────────────────────────────────────────────
+
+    def _decode_yolo_output(self, preds: np.ndarray, ratio: float,
+                           pad: tuple[float, float],
+                           orig_size: tuple[int, int],
+                           extra: tuple[int, int] = (0, 0)
+                           ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """Decode -> conf filter -> un-letterbox -> sanity+NMS+dedup.
+        Returns (boxes, scores, cls_ids) in ORIGINAL image coords."""
+        empty = (np.empty((0, 4), np.float32), np.empty(0, np.float32),
+                 np.empty(0, np.int32))
+        if preds.ndim == 3 and preds.shape[0] == 1:
+            preds = preds[0]
+        if preds.ndim != 2 or preds.shape[1] < 6:
+            print(f"Warning: Unexpected output shape: {preds.shape}")
+            return empty
+
+        boxes = preds[:, :4].astype(np.float32)
+        scores = preds[:, 4].astype(np.float32)
+        cls_ids = preds[:, 5].astype(np.int32)
+
+        n_cls = len(self.class_names)
+        valid = (cls_ids >= 0) & (cls_ids < n_cls)
+        boxes, scores, cls_ids = boxes[valid], scores[valid], cls_ids[valid]
+        if len(boxes) == 0:
+            return empty
+
+        extra_left, _extra_right = extra
+
+        keep = self._conf_filter_mask(scores, cls_ids, extra_left)
+        boxes, scores, cls_ids = boxes[keep], scores[keep], cls_ids[keep]
+        if len(boxes) == 0:
+            return empty
+
+        # 1) undo letterbox -> coords in the PADDED (widened) image
+        pad_w, pad_h = pad
+        boxes[:, [0, 2]] -= pad_w
+        boxes[:, [1, 3]] -= pad_h
+        boxes /= ratio
+
+        # 2) undo left/right pre-padding -> original-image coords
+        if extra_left:
+            boxes[:, [0, 2]] -= extra_left
+
+        # 2b) drop boxes whose CENTER falls in the black padding bars
+        if extra_left or _extra_right:
+            orig_w, orig_h = orig_size
+            cx = (boxes[:, 0] + boxes[:, 2]) * 0.5
+            inside = (cx >= 0) & (cx <= orig_w)
+            boxes, scores, cls_ids = boxes[inside], scores[inside], cls_ids[inside]
+            if len(boxes) == 0:
+                return empty
+
+        # 3) clip to ORIGINAL image bounds
+        boxes = self._clip_boxes(boxes, orig_size)
+
+        return self._per_view_pipeline(boxes, scores, cls_ids, orig_size)
+
+    @staticmethod
+    def _build_results(boxes: np.ndarray, scores: np.ndarray,
+                       cls_ids: np.ndarray,
+                       orig_size: tuple[int, int]) -> list[BoundingBox]:
+        results = []
+        orig_w, orig_h = orig_size
+        for box, conf, cls_id in zip(boxes, scores, cls_ids):
+            x1, y1, x2, y2 = box.tolist() if hasattr(box, "tolist") else box
+            if x2 <= x1 or y2 <= y1:
                 continue
-            out.append(BoundingBox(x1=int(xyxy[j, 0]), y1=int(xyxy[j, 1]),
-                                   x2=int(xyxy[j, 2]), y2=int(xyxy[j, 3]),
-                                   cls_id=0, conf=float(conf[j])))
-        return out
-
-    def _infer(self, img, flipped: bool, thresh: float = None):
-        src = img[:, ::-1, :] if flipped else img
-        chw, r, pw, ph = self._preprocess(src)
-        inp = np.ascontiguousarray(chw[None], dtype=np.float32)
-        out = self.sess.run(None, {self.inp.name: inp})[0]
-        return self._decode(out, r, pw, ph, img.shape[1], img.shape[0], flipped, thresh)
-
-    def _fallback_box(self, img) -> list[BoundingBox]:
-        """Road-sign challenges always contain >=1 sign, so an empty frame is a
-        guaranteed 0. Emit the single highest-confidence raw candidate (below the
-        conf floor, sanity filters bypassed) so the frame is never empty."""
-        xyxy, conf = self._infer(img, flipped=False, thresh=0.0)
-        if len(conf) == 0:
+            results.append(
+                BoundingBox(
+                    x1=max(0, min(orig_w, int(math.floor(x1)))),
+                    y1=max(0, min(orig_h, int(math.floor(y1)))),
+                    x2=max(0, min(orig_w, int(math.ceil(x2)))),
+                    y2=max(0, min(orig_h, int(math.ceil(y2)))),
+                    cls_id=int(cls_id),
+                    conf=float(max(0.0, min(1.0, conf))),
+                )
+            )
+        return results
+
+    # ─── Inference ────────────────────────────────────────────────
+
+    def _predict_single(self, image_bgr: np.ndarray, allow_pad: bool = True
+                        ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """One forward pass -> decoded (boxes, scores, cls_ids) in original coords."""
+        if image_bgr is None or not isinstance(image_bgr, np.ndarray):
+            raise ValueError("Invalid image input")
+        if image_bgr.dtype != np.uint8:
+            image_bgr = image_bgr.astype(np.uint8)
+
+        inp, meta = self._preprocess(image_bgr, allow_pad=allow_pad)
+        outputs = self.session.run(None, {self.input_name: inp})
+
+        ratio = float(meta["ratio"])
+        pad = (float(meta["pad_w"]), float(meta["pad_h"]))
+        orig_size = (int(meta["orig_w"]), int(meta["orig_h"]))
+        extra = (int(meta["extra_left"]), int(meta["extra_right"]))
+
+        return self._decode_yolo_output(outputs[0], ratio, pad, orig_size, extra)
+
+    def _infer_single(self, image_bgr: ndarray) -> list[BoundingBox]:
+        """Single-view inference (no TTA)."""
+        orig_h, orig_w = image_bgr.shape[:2]
+        orig_size = (orig_w, orig_h)
+
+        boxes, scores, cls_ids = self._predict_single(image_bgr, allow_pad=True)
+        if len(boxes) == 0:
             return []
-        j = int(conf.argmax())
-        return [BoundingBox(x1=int(xyxy[j, 0]), y1=int(xyxy[j, 1]),
-                            x2=int(xyxy[j, 2]), y2=int(xyxy[j, 3]),
-                            cls_id=0, conf=float(conf[j]))]
 
-    def predict_batch(self, batch_images, offset: int, n_keypoints: int) -> list[TVFrameResult]:
+        if self.use_cluster_boost and len(boxes) > 1:
+            scores = self._max_score_per_cluster(
+                boxes, cls_ids, boxes, scores, cls_ids, self._avg_iou)
+
+        return self._build_results(boxes, scores, cls_ids, orig_size)
+
+    # ─── Public API ───────────────────────────────────────────────
+
+    def predict_batch(
+        self,
+        batch_images: list[ndarray],
+        offset: int,
+        n_keypoints: int,
+    ) -> list[TVFrameResult]:
         results: list[TVFrameResult] = []
-        for i, img in enumerate(batch_images):
-            xyxy, conf = self._infer(img, flipped=False)
-            if USE_TTA:
-                fx, fs = self._infer(img, flipped=True)
-                xyxy = np.concatenate([xyxy, fx], 0)
-                conf = np.concatenate([conf, fs], 0)
-            boxes = self._finalize(xyxy, conf)
-            if not boxes and FALLBACK:            # never return an empty frame -> avoid a guaranteed 0
-                boxes = self._fallback_box(img)
-            results.append(TVFrameResult(frame_id=offset + i, boxes=boxes, polygons=[], keypoints=[]))
-        return results
+        for idx, image in enumerate(batch_images):
+            try:
+                boxes = self._infer_single(image)
+            except Exception as e:
+                print(f"Inference failed for frame {offset + idx}: {e}")
+                boxes = []
+            keypoints = [(0, 0) for _ in range(max(0, int(n_keypoints)))]
+            results.append(
+                TVFrameResult(
+                    frame_id=offset + idx,
+                    boxes=boxes,
+                    keypoints=keypoints,
+                )
+            )
+        return results

weights.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:320f568d4ba8079dba59acd32bf697ce1567b6b740f7e3972d5ee00b8a67c27e
-size 10572128
+oid sha256:17f8cd5cf9253b555a05bd6ac874bcbe2a892298f008d2f01a0fd4e4c6c0a867
+size 9760190