scorevision: push artifact

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+person_weights_1280.onnx.bak filter=lfs diff=lfs merge=lfs -text
+vehicle_weights_1280.onnx.bak filter=lfs diff=lfs merge=lfs -text

miner.py

@@ -74,7 +74,7 @@ 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 = 1280
+# VEH_IMG_SIZE: now read dynamically from model input shape in __init__
 VEH_CONF_PER_CLASS = {0: 0.33, 1: 0.50, 2: 0.40, 3: 0.36}
 VEH_CONF_DEFAULT = 0.35
 VEH_TTA_CONF = 0.25
@@ -235,6 +235,9 @@ class Miner:
             providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
         )
         self.veh_input_name = self.veh_session.get_inputs()[0].name
+        veh_shape = self.veh_session.get_inputs()[0].shape
+        self.veh_h = int(veh_shape[2])
+        self.veh_w = int(veh_shape[3])
 
         # Person model (YOLO11s, 1 class)
         self.per_session = ort.InferenceSession(
@@ -263,10 +266,10 @@ class Miner:
 
     def _veh_letterbox(self, img):
         h, w = img.shape[:2]
-        r = min(VEH_IMG_SIZE / h, VEH_IMG_SIZE / w)
+        r = min(self.veh_h / h, self.veh_w / w)
         nw, nh = int(round(w * r)), int(round(h * r))
         img_r = cv2.resize(img, (nw, nh), interpolation=cv2.INTER_LINEAR)
-        dw, dh = VEH_IMG_SIZE - nw, VEH_IMG_SIZE - nh
+        dw, dh = self.veh_w - nw, self.veh_h - nh
         pl, pt = dw // 2, dh // 2
         img_p = cv2.copyMakeBorder(
             img_r, pt, dh - pt, pl, dw - pl,

miner.py.bak_1280

@@ -0,0 +1,562 @@
+"""
+Score Vision SN44 — Unified miner v2 (2026-03-28).
+Dual-model: vehicle (YOLO11s) + person (YOLO11s).
+Optimized for latency: parallel threading + configurable TTA.
+
+Vehicle model (vehicle_weights.onnx):
+  Trained classes: 0=car, 1=bus, 2=truck, 3=motorcycle
+  Remapped to manifest: 0=bus, 1=car, 2=truck, 3=motorcycle
+
+Person model (person_weights.onnx):
+  Single class: 0=person
+
+Both models run on every image. All detections merged.
+cls_id 0 is shared: "bus" for vehicle eval, "person" for person eval.
+Vehicle eval uses cls_id 0-3. Person eval uses cls_id 0 only.
+"""
+
+import os
+import ctypes
+import glob as _glob
+import logging as _logging
+
+_cuda_log = _logging.getLogger(__name__)
+
+def _preload_cuda_libs():
+    """Pre-load CUDA libs from pip nvidia packages so onnxruntime-gpu finds them."""
+    try:
+        lib_dirs = []
+        for mod_name in ['nvidia.cudnn', 'nvidia.cublas']:
+            try:
+                mod = __import__(mod_name, fromlist=['__file__'])
+                lib_dir = os.path.join(os.path.dirname(mod.__file__), 'lib')
+                if os.path.isdir(lib_dir):
+                    lib_dirs.append(lib_dir)
+            except ImportError:
+                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:
+                    ctypes.CDLL(so, mode=ctypes.RTLD_GLOBAL)
+                    _cuda_log.info(f'Preloaded CUDA lib: {os.path.basename(so)}')
+                except OSError:
+                    pass
+    except Exception as e:
+        _cuda_log.warning(f'CUDA preload error: {e}')
+
+_preload_cuda_libs()
+
+
+from pathlib import Path
+import math
+import time
+import logging
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+from numpy import ndarray
+from pydantic import BaseModel
+
+import json
+import threading
+from datetime import datetime, timezone
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+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 = 1280
+VEH_CONF_PER_CLASS = {0: 0.33, 1: 0.50, 2: 0.40, 3: 0.36}
+VEH_CONF_DEFAULT = 0.35
+VEH_TTA_CONF = 0.25
+VEH_WBF_IOU = 0.55
+
+# ── Person config ───────────────────────────────────────────────────────────
+PER_CONF = 0.35
+PER_TTA_CONF = 0.25
+PER_WBF_IOU = 0.45
+
+# ── 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
+
+
+def _wbf_multi(boxes_list, scores_list, labels_list, iou_thr=0.55, skip_thr=0.0001):
+    """Weighted Boxes Fusion (multi-class). Boxes in [0,1] normalized coords."""
+    if not boxes_list:
+        return np.empty((0, 4)), np.empty(0), np.empty(0)
+
+    all_b, all_s, all_l = [], [], []
+    for bx, sc, lb in zip(boxes_list, scores_list, labels_list):
+        for i in range(len(bx)):
+            if sc[i] < skip_thr:
+                continue
+            all_b.append(bx[i])
+            all_s.append(sc[i])
+            all_l.append(int(lb[i]))
+
+    if not all_b:
+        return np.empty((0, 4)), np.empty(0), np.empty(0)
+
+    all_b = np.array(all_b)
+    all_s = np.array(all_s)
+    all_l = np.array(all_l, dtype=int)
+
+    fused_b, fused_s, fused_l = [], [], []
+    for cls in np.unique(all_l):
+        m = all_l == cls
+        cb, cs = all_b[m], all_s[m]
+        order = cs.argsort()[::-1]
+        cb, cs = cb[order], cs[order]
+
+        clusters, cboxes = [], []
+        for i in range(len(cb)):
+            matched, best_iou = -1, iou_thr
+            for ci, cbox in enumerate(cboxes):
+                xx1 = max(cb[i, 0], cbox[0])
+                yy1 = max(cb[i, 1], cbox[1])
+                xx2 = min(cb[i, 2], cbox[2])
+                yy2 = min(cb[i, 3], cbox[3])
+                inter = max(0, xx2 - xx1) * max(0, yy2 - yy1)
+                a1 = (cb[i, 2] - cb[i, 0]) * (cb[i, 3] - cb[i, 1])
+                a2 = (cbox[2] - cbox[0]) * (cbox[3] - cbox[1])
+                iou = inter / (a1 + a2 - inter + 1e-9)
+                if iou > best_iou:
+                    best_iou = iou
+                    matched = ci
+            if matched >= 0:
+                clusters[matched].append(i)
+                idxs = clusters[matched]
+                w = cs[idxs]
+                cboxes[matched] = (cb[idxs] * w[:, None]).sum(0) / w.sum()
+            else:
+                clusters.append([i])
+                cboxes.append(cb[i].copy())
+
+        for ci, idxs in enumerate(clusters):
+            fused_b.append(cboxes[ci])
+            fused_s.append(cs[idxs].mean())
+            fused_l.append(cls)
+
+    if not fused_b:
+        return np.empty((0, 4)), np.empty(0), np.empty(0)
+    return np.array(fused_b), np.array(fused_s), np.array(fused_l)
+
+
+def _wbf_single(boxes_list, scores_list, iou_thr=0.45, skip_thr=0.0001):
+    """Weighted Boxes Fusion (single-class). Boxes in [0,1] normalized coords."""
+    if not boxes_list:
+        return np.empty((0, 4)), np.empty(0)
+
+    all_b, all_s = [], []
+    for bx, sc in zip(boxes_list, scores_list):
+        for i in range(len(bx)):
+            if sc[i] < skip_thr:
+                continue
+            all_b.append(bx[i])
+            all_s.append(sc[i])
+
+    if not all_b:
+        return np.empty((0, 4)), np.empty(0)
+
+    all_b = np.array(all_b)
+    all_s = np.array(all_s)
+    order = all_s.argsort()[::-1]
+    all_b, all_s = all_b[order], all_s[order]
+
+    clusters, cboxes = [], []
+    for i in range(len(all_b)):
+        matched, best_iou = -1, iou_thr
+        for ci, cbox in enumerate(cboxes):
+            xx1 = max(all_b[i, 0], cbox[0])
+            yy1 = max(all_b[i, 1], cbox[1])
+            xx2 = min(all_b[i, 2], cbox[2])
+            yy2 = min(all_b[i, 3], cbox[3])
+            inter = max(0, xx2 - xx1) * max(0, yy2 - yy1)
+            a1 = (all_b[i, 2] - all_b[i, 0]) * (all_b[i, 3] - all_b[i, 1])
+            a2 = (cbox[2] - cbox[0]) * (cbox[3] - cbox[1])
+            iou = inter / (a1 + a2 - inter + 1e-9)
+            if iou > best_iou:
+                best_iou = iou
+                matched = ci
+        if matched >= 0:
+            clusters[matched].append(i)
+            idxs = clusters[matched]
+            w = all_s[idxs]
+            cboxes[matched] = (all_b[idxs] * w[:, None]).sum(0) / w.sum()
+        else:
+            clusters.append([i])
+            cboxes.append(all_b[i].copy())
+
+    fused_b, fused_s = [], []
+    for ci, idxs in enumerate(clusters):
+        fused_b.append(cboxes[ci])
+        fused_s.append(all_s[idxs].mean())
+
+    if not fused_b:
+        return np.empty((0, 4)), np.empty(0)
+    return np.array(fused_b), np.array(fused_s)
+
+
+class BoundingBox(BaseModel):
+    x1: int
+    y1: int
+    x2: int
+    y2: int
+    cls_id: int
+    conf: float
+
+
+class TVFrameResult(BaseModel):
+    frame_id: int
+    boxes: list[BoundingBox]
+    keypoints: list[tuple[int, int]]
+
+
+class Miner:
+    def __init__(self, path_hf_repo: Path) -> None:
+        self.path_hf_repo = path_hf_repo
+
+        # Vehicle model (YOLO11s, 4 classes)
+        self.veh_session = ort.InferenceSession(
+            str(path_hf_repo / "vehicle_weights.onnx"),
+            providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
+        )
+        self.veh_input_name = self.veh_session.get_inputs()[0].name
+
+        # Person model (YOLO11s, 1 class)
+        self.per_session = ort.InferenceSession(
+            str(path_hf_repo / "person_weights.onnx"),
+            providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
+        )
+        self.per_input_name = self.per_session.get_inputs()[0].name
+        per_shape = self.per_session.get_inputs()[0].shape
+        self.per_h = int(per_shape[2])
+        self.per_w = int(per_shape[3])
+
+        # Thread pool for parallel inference
+        self._executor = ThreadPoolExecutor(max_workers=2)
+
+        # Log provider info
+        veh_prov = self.veh_session.get_providers()
+        per_prov = self.per_session.get_providers()
+        logger.info(f"Vehicle ORT providers: {veh_prov}")
+        logger.info(f"Person ORT providers: {per_prov}")
+        logger.info(f"TTA={ENABLE_TTA} PARALLEL={ENABLE_PARALLEL}")
+
+    def __repr__(self) -> str:
+        return "Unified Miner v2 — dual-model vehicle+person (parallel, TTA-configurable)"
+
+    # ── Vehicle preprocessing (letterbox) ───────────────────────────────────
+
+    def _veh_letterbox(self, img):
+        h, w = img.shape[:2]
+        r = min(VEH_IMG_SIZE / h, VEH_IMG_SIZE / w)
+        nw, nh = int(round(w * r)), int(round(h * r))
+        img_r = cv2.resize(img, (nw, nh), interpolation=cv2.INTER_LINEAR)
+        dw, dh = VEH_IMG_SIZE - nw, VEH_IMG_SIZE - nh
+        pl, pt = dw // 2, dh // 2
+        img_p = cv2.copyMakeBorder(
+            img_r, pt, dh - pt, pl, dw - pl,
+            cv2.BORDER_CONSTANT, value=(114, 114, 114),
+        )
+        return img_p, r, pl, pt
+
+    def _veh_preprocess(self, image_bgr):
+        img_p, ratio, pl, pt = self._veh_letterbox(image_bgr)
+        rgb = cv2.cvtColor(img_p, cv2.COLOR_BGR2RGB)
+        inp = rgb.astype(np.float32) / 255.0
+        inp = np.ascontiguousarray(inp.transpose(2, 0, 1)[np.newaxis])
+        return inp, ratio, pl, pt
+
+    def _veh_decode(self, raw, ratio, pl, pt, ow, oh, conf_thresh):
+        pred = raw[0]
+        if pred.shape[0] < pred.shape[1]:
+            pred = pred.T
+        cls_scores = pred[:, 4:]
+        cls_ids = np.argmax(cls_scores, axis=1)
+        confs = np.max(cls_scores, axis=1)
+        mask = confs >= conf_thresh
+        if not mask.any():
+            return np.empty((0, 4)), np.empty(0), np.empty(0, dtype=int)
+        bx, confs, cls_ids = pred[mask, :4], confs[mask], cls_ids[mask]
+        cx, cy, bw, bh = bx[:, 0], bx[:, 1], bx[:, 2], bx[:, 3]
+        x1 = np.clip((cx - bw / 2 - pl) / ratio, 0, ow)
+        y1 = np.clip((cy - bh / 2 - pt) / ratio, 0, oh)
+        x2 = np.clip((cx + bw / 2 - pl) / ratio, 0, ow)
+        y2 = np.clip((cy + bh / 2 - pt) / ratio, 0, oh)
+        return np.stack([x1, y1, x2, y2], axis=1), confs, cls_ids
+
+    def _veh_run_pass(self, image_bgr, conf_thresh):
+        oh, ow = image_bgr.shape[:2]
+        inp, ratio, pl, pt = self._veh_preprocess(image_bgr)
+        raw = self.veh_session.run(None, {self.veh_input_name: inp})[0]
+        return self._veh_decode(raw, ratio, pl, pt, ow, oh, conf_thresh)
+
+    def _infer_vehicle(self, image_bgr):
+        oh, ow = image_bgr.shape[:2]
+        all_b, all_s, all_l = [], [], []
+
+        def _collect(boxes, confs, cls_ids):
+            if len(boxes) == 0:
+                return
+            out_cls = np.array([VEH_MODEL_TO_OUT[int(c)] for c in cls_ids])
+            norm = boxes.copy()
+            norm[:, [0, 2]] /= ow
+            norm[:, [1, 3]] /= oh
+            norm = np.clip(norm, 0, 1)
+            all_b.append(norm)
+            all_s.append(confs)
+            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 []
+
+        if ENABLE_TTA:
+            fb, fs, fl = _wbf_multi(all_b, all_s, all_l, iou_thr=VEH_WBF_IOU, skip_thr=WBF_SKIP_THR)
+        else:
+            # No WBF needed for single pass, just concatenate
+            fb = np.concatenate(all_b, axis=0)
+            fs = np.concatenate(all_s, axis=0)
+            fl = np.concatenate(all_l, axis=0)
+
+        if len(fb) == 0:
+            return []
+
+        fb[:, [0, 2]] *= ow
+        fb[:, [1, 3]] *= oh
+
+        keep = np.array([
+            fs[i] >= VEH_CONF_PER_CLASS.get(int(fl[i]), VEH_CONF_DEFAULT)
+            for i in range(len(fs))
+        ])
+        if not keep.any():
+            return []
+        fb, fs, fl = fb[keep], fs[keep], fl[keep]
+
+        out = []
+        for i in range(len(fb)):
+            b = fb[i]
+            out.append(BoundingBox(
+                x1=max(0, min(ow, math.floor(b[0]))),
+                y1=max(0, min(oh, math.floor(b[1]))),
+                x2=max(0, min(ow, math.ceil(b[2]))),
+                y2=max(0, min(oh, math.ceil(b[3]))),
+                cls_id=int(fl[i]),
+                conf=max(0.0, min(1.0, float(fs[i]))),
+            ))
+        return out
+
+    # ── Person preprocessing (stretch resize) ──────────────────────────────
+
+    def _per_preprocess(self, image_bgr):
+        rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
+        resized = cv2.resize(rgb, (self.per_w, self.per_h))
+        x = resized.astype(np.float32) / 255.0
+        x = np.transpose(x, (2, 0, 1))[None, ...]
+        return x
+
+    def _per_decode(self, raw, oh, ow, conf_thresh):
+        pred = raw[0]
+        if pred.ndim != 2:
+            return np.empty((0, 4)), np.empty(0)
+        if pred.shape[0] < pred.shape[1]:
+            pred = pred.T
+        if pred.shape[1] < 5:
+            return np.empty((0, 4)), np.empty(0)
+        cls_scores = pred[:, 4:]
+        confs = np.max(cls_scores, axis=1)
+        keep = confs >= conf_thresh
+        boxes, confs = pred[keep, :4], confs[keep]
+        if len(boxes) == 0:
+            return np.empty((0, 4)), np.empty(0)
+        sx, sy = ow / float(self.per_w), oh / float(self.per_h)
+        cx, cy, bw, bh = boxes[:, 0], boxes[:, 1], boxes[:, 2], boxes[:, 3]
+        x1 = np.clip((cx - bw / 2) * sx, 0, ow)
+        y1 = np.clip((cy - bh / 2) * sy, 0, oh)
+        x2 = np.clip((cx + bw / 2) * sx, 0, ow)
+        y2 = np.clip((cy + bh / 2) * sy, 0, oh)
+        return np.stack([x1, y1, x2, y2], axis=1), confs
+
+    def _per_run_pass(self, image_bgr, conf_thresh):
+        oh, ow = image_bgr.shape[:2]
+        inp = self._per_preprocess(image_bgr)
+        raw = self.per_session.run(None, {self.per_input_name: inp})[0]
+        return self._per_decode(raw, oh, ow, conf_thresh)
+
+    def _infer_person(self, image_bgr):
+        oh, ow = image_bgr.shape[:2]
+        all_b, all_s = [], []
+
+        def _collect(boxes, confs):
+            if len(boxes) == 0:
+                return
+            norm = boxes.copy()
+            norm[:, [0, 2]] /= ow
+            norm[:, [1, 3]] /= oh
+            norm = np.clip(norm, 0, 1)
+            all_b.append(norm)
+            all_s.append(confs)
+
+        if ENABLE_TTA:
+            # Pass 1: original
+            _collect(*self._per_run_pass(image_bgr, PER_TTA_CONF))
+            # Pass 2: hflip
+            flipped = cv2.flip(image_bgr, 1)
+            bx, sc = self._per_run_pass(flipped, PER_TTA_CONF)
+            if len(bx):
+                bx[:, 0], bx[:, 2] = ow - bx[:, 2], ow - bx[:, 0]
+            _collect(bx, sc)
+        else:
+            # Single pass
+            _collect(*self._per_run_pass(image_bgr, PER_CONF))
+
+        if not all_b:
+            return []
+
+        if ENABLE_TTA:
+            fb, fs = _wbf_single(all_b, all_s, iou_thr=PER_WBF_IOU, skip_thr=WBF_SKIP_THR)
+        else:
+            fb = np.concatenate(all_b, axis=0)
+            fs = np.concatenate(all_s, axis=0)
+
+        if len(fb) == 0:
+            return []
+
+        fb[:, [0, 2]] *= ow
+        fb[:, [1, 3]] *= oh
+
+        keep = fs >= PER_CONF
+        fb, fs = fb[keep], fs[keep]
+
+        out = []
+        for i in range(len(fb)):
+            b = fb[i]
+            out.append(BoundingBox(
+                x1=max(0, min(ow, math.floor(b[0]))),
+                y1=max(0, min(oh, math.floor(b[1]))),
+                x2=max(0, min(ow, math.ceil(b[2]))),
+                y2=max(0, min(oh, math.ceil(b[3]))),
+                cls_id=0,
+                conf=max(0.0, min(1.0, float(fs[i]))),
+            ))
+        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()
+            person_boxes = per_future.result()
+        else:
+            vehicle_boxes = self._infer_vehicle(image_bgr)
+            person_boxes = self._infer_person(image_bgr)
+        return vehicle_boxes + person_boxes
+
+    # -- Replay buffer -------------------------------------------------------
+    REPLAY_DIR = Path("/home/miner/replay_buffer")
+    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
+            query_dir.mkdir(parents=True, exist_ok=True)
+
+            for i, img in enumerate(batch_images):
+                cv2.imwrite(str(query_dir / f"img_{i:03d}.jpg"), img,
+                            [cv2.IMWRITE_JPEG_QUALITY, 95])
+
+            preds = []
+            for r in results:
+                preds.append({
+                    "frame_id": r.frame_id,
+                    "boxes": [b.model_dump() for b in r.boxes],
+                })
+            meta = {
+                "timestamp": ts,
+                "num_images": len(batch_images),
+                "image_shapes": [list(img.shape) for img in batch_images],
+                "predictions": preds,
+            }
+            (query_dir / "meta.json").write_text(json.dumps(meta, indent=2))
+            self._replay_prune()
+        except Exception:
+            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()],
+                key=lambda d: d.name,
+            )
+            if len(dirs) > self.REPLAY_MAX:
+                import shutil
+                for old in dirs[: len(dirs) - self.REPLAY_MAX]:
+                    shutil.rmtree(old, ignore_errors=True)
+        except Exception:
+            pass
+
+    def predict_batch(
+        self,
+        batch_images: list[ndarray],
+        offset: int,
+        n_keypoints: int,
+    ) -> list[TVFrameResult]:
+        t_start = time.perf_counter()
+
+        results: list[TVFrameResult] = []
+        for idx, image in enumerate(batch_images):
+            t_img = time.perf_counter()
+            boxes = self._infer_single(image)
+            dt_img = (time.perf_counter() - t_img) * 1000
+            logger.info(f"[miner] image {idx}: {len(boxes)} boxes in {dt_img:.0f}ms "
+                        f"(shape={image.shape}, TTA={ENABLE_TTA}, PAR={ENABLE_PARALLEL})")
+            keypoints = [(0, 0) for _ in range(max(0, int(n_keypoints)))]
+            results.append(TVFrameResult(
+                frame_id=offset + idx, boxes=boxes, keypoints=keypoints,
+            ))
+
+        dt_total = (time.perf_counter() - t_start) * 1000
+        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),
+            daemon=True,
+        ).start()
+
+        return results

person_weights.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:95cd302649a2572cd20c92c3e3abf9dd0be61339c2a2be3665afc66d76efdcf3
-size 10546588
+oid sha256:aa6c46dca9dc995b8a641674e8f760b80d9af067bf2874e16a6addfd77a387bf
+size 10042378

person_weights_1280.onnx.bak

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:95cd302649a2572cd20c92c3e3abf9dd0be61339c2a2be3665afc66d76efdcf3
+size 10546588

vehicle_weights.onnx

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e3916408ec21f8c94358c18914f922814770b78557e52fe17ff7a9ee74339a5a
-size 19272252
+oid sha256:fc35148056138102db485555b48704e485fcc917046c783ed3c30d27b7840a89
+size 19019978

vehicle_weights_1280.onnx.bak

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e3916408ec21f8c94358c18914f922814770b78557e52fe17ff7a9ee74339a5a
+size 19272252