deploy push for crime (deploy)

miner.py

@@ -1,18 +1,25 @@
-# build-marker: v1-yolo26s-1280-tta
-"""SN44 crime detection miner — single-element chute for manak0/Detect-crime.
-
-Adapted from beverage v5 miner.py with these crime-specific changes:
-  - class_names = ["balaclava","hoodie","glove","bat","spray paint","graffiti"]
-  - cls_remap = identity (model trained natively in validator class order, no remap needed)
-  - conf_threshold = 0.52 (alfred-aligned, slightly looser than beverage's 0.55)
-  - iou_thresh = 0.4 (slightly tighter than beverage's 0.5)
-  - min_box_area = 196 (14x14 px², larger than beverage's 100; kills tiny FPs aggressively)
-  - weights.onnx is yolo26s e2e at 1280x1280 input
-
-Pipeline:
-  preprocess (letterbox 1280, cubic upscale) -> ONNX (e2e [1,300,6])
-  -> conf filter -> per-class hard NMS -> cross-class dedup -> geometry filter
-  -> TTA (h-flip + conf-boost on consensus) -> BoundingBox list
+# build-marker: v2-ensemble-alfred-rfdetr
+"""SN44 crime detection miner — ENSEMBLE of alfred yolo26n + RF-DETR base.
+
+Composes two internal miners with different preprocess/inference pipelines:
+  _AlfredMiner: yolo26n e2e ONNX, letterbox 1280 + /255, TTA (h-flip + conf boost)
+  _RFDETRMiner: rfdetr base e2e ONNX, stretch 1288 + ImageNet normalize, no TTA
+
+Class routing (final union after per-class NMS@IoU=0.5, alfred wins conflicts):
+  cls0 balaclava  : BOTH (alfred priority on conflicts)
+  cls1 hoodie     : BOTH (alfred priority on conflicts)
+  cls2 glove      : RF-DETR only
+  cls3 bat        : RF-DETR only
+  cls4 spray paint: RF-DETR only
+  cls5 graffiti   : alfred only
+
+Conf threshold 0.52 is applied INSIDE each internal miner; the union is the
+already-thresholded boxes from each. This matches alfred's existing per-class
+calibration (TTA conf-boost happens against the 0.52 threshold).
+
+ONNX file names expected in path_hf_repo:
+  weights.onnx        - alfred yolo26n e2e [1,300,6] in input-pixel coords (1280)
+  weights_rfdetr.onnx - RF-DETR base e2e [1,300,6] in input-pixel coords (1288)
 """
 import math
 from pathlib import Path
@@ -39,78 +46,47 @@ class TVFrameResult(BaseModel):
     keypoints: list[tuple[int, int]]
 
 
-class Miner:
-    """yolo26s e2e ONNX miner for manak0/Detect-crime.
-    Chute platform calls predict_batch(batch_images, offset, n_keypoints).
-    """
+_IMAGENET_MEAN = np.array([0.485, 0.456, 0.406], dtype=np.float32)
+_IMAGENET_STD  = np.array([0.229, 0.224, 0.225], dtype=np.float32)
 
-    def __init__(self, path_hf_repo) -> None:
-        self.path_hf_repo = Path(path_hf_repo)
 
-        # Validator class order — model trained natively in this order so identity remap.
+# ============================================================ ALFRED PATH
+# Verbatim alfred-style pipeline (letterbox + TTA). Returns list[BoundingBox]
+# already conf-filtered at 0.52, geometry-filtered, NMS'd, cross-class deduped.
+class _AlfredMiner:
+    def __init__(self, path_hf_repo: Path):
+        self.path_hf_repo = path_hf_repo
         self.class_names = ["balaclava", "hoodie", "glove", "bat", "spray paint", "graffiti"]
-        self.cls_remap = np.arange(len(self.class_names), dtype=np.int32)
-
-        try:
-            ort.preload_dlls()
-        except Exception:
-            pass
+        self.cls_remap = np.arange(6, dtype=np.int32)
 
         sess_options = ort.SessionOptions()
         sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
-
         try:
             self.session = ort.InferenceSession(
-                str(self.path_hf_repo / "weights.onnx"),
+                str(path_hf_repo / "weights.onnx"),
                 sess_options=sess_options,
                 providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
             )
         except Exception:
             self.session = ort.InferenceSession(
-                str(self.path_hf_repo / "weights.onnx"),
+                str(path_hf_repo / "weights.onnx"),
                 sess_options=sess_options,
                 providers=["CPUExecutionProvider"],
             )
-
         self.input_name = self.session.get_inputs()[0].name
         self.output_names = [o.name for o in self.session.get_outputs()]
-
-        # Match exported ONNX resolution.
         self.input_h = 1280
         self.input_w = 1280
-
-        # alfred-aligned crime thresholds.
         self.conf_threshold = 0.52
-        self.iou_thresh = 0.4              # per-class hard NMS
-        self.cross_iou_thresh = 0.7        # cross-class dedup
+        self.iou_thresh = 0.4
+        self.cross_iou_thresh = 0.7
         self.max_det = 150
         self.use_tta = True
-
-        # Geometry filters (alfred crime values).
-        self.min_box_area = 196            # 14x14 px²
+        self.min_box_area = 196
         self.min_side = 8
         self.max_aspect_ratio = 8.0
 
-        # GPU warmup.
-        warm = np.zeros((self.input_h, self.input_w, 3), dtype=np.uint8)
-        for _ in range(5):
-            try:
-                self._infer_single(warm)
-            except Exception:
-                break
-
-    def __repr__(self) -> str:
-        return (
-            f"CrimeMiner v1 input={self.input_h}x{self.input_w} "
-            f"classes={len(self.class_names)} use_tta={self.use_tta} "
-            f"providers={self.session.get_providers()}"
-        )
-
-    # ---------------------------------------------------------------- preproc
-    def _letterbox(self, image: ndarray) -> tuple[ndarray, float, tuple[float, float]]:
-        """Aspect-preserving resize + 114-grey pad to (input_h, input_w).
-        Cubic when upscaling (small-object fidelity), linear when downscaling.
-        """
+    def _letterbox(self, image):
         h, w = image.shape[:2]
         ratio = min(self.input_w / w, self.input_h / h)
         nw, nh = int(round(w * ratio)), int(round(h * ratio))
@@ -122,51 +98,41 @@ class Miner:
         canvas = np.full((self.input_h, self.input_w, 3), 114, dtype=np.uint8)
         dy = (self.input_h - nh) // 2
         dx = (self.input_w - nw) // 2
-        canvas[dy:dy + nh, dx:dx + nw] = resized
+        canvas[dy:dy+nh, dx:dx+nw] = resized
         return canvas, ratio, (float(dx), float(dy))
 
-    def _preprocess(self, image_bgr: ndarray):
+    def _preprocess(self, image_bgr):
         canvas, ratio, pad = self._letterbox(image_bgr)
         rgb = cv2.cvtColor(canvas, cv2.COLOR_BGR2RGB)
         x = (rgb.astype(np.float32) / 255.0).transpose(2, 0, 1)[None, ...]
         return np.ascontiguousarray(x, dtype=np.float32), ratio, pad
 
-    # ---------------------------------------------------------------- nms helpers
     @staticmethod
-    def _hard_nms(boxes: ndarray, scores: ndarray, iou_thresh: float) -> ndarray:
+    def _hard_nms(boxes, scores, iou_thresh):
         n = len(boxes)
-        if n == 0:
-            return np.array([], dtype=np.intp)
+        if n == 0: return np.array([], dtype=np.intp)
         order = np.argsort(scores)[::-1]
-        keep: list[int] = []
-        suppressed = np.zeros(n, dtype=bool)
+        keep, suppressed = [], np.zeros(n, dtype=bool)
         for i in range(n):
             idx = order[i]
-            if suppressed[idx]:
-                continue
+            if suppressed[idx]: continue
             keep.append(int(idx))
             bi = boxes[idx]
             for k in range(i + 1, n):
                 jdx = order[k]
-                if suppressed[jdx]:
-                    continue
+                if suppressed[jdx]: continue
                 bj = boxes[jdx]
-                xx1 = max(bi[0], bj[0]); yy1 = max(bi[1], bj[1])
-                xx2 = min(bi[2], bj[2]); yy2 = min(bi[3], bj[3])
-                inter = max(0.0, xx2 - xx1) * max(0.0, yy2 - yy1)
-                ai = (bi[2] - bi[0]) * (bi[3] - bi[1])
-                aj = (bj[2] - bj[0]) * (bj[3] - bj[1])
+                xx1, yy1 = max(bi[0], bj[0]), max(bi[1], bj[1])
+                xx2, yy2 = min(bi[2], bj[2]), min(bi[3], bj[3])
+                inter = max(0.0, xx2-xx1) * max(0.0, yy2-yy1)
+                ai = (bi[2]-bi[0])*(bi[3]-bi[1]); aj = (bj[2]-bj[0])*(bj[3]-bj[1])
                 iou = inter / (ai + aj - inter + 1e-7)
-                if iou > iou_thresh:
-                    suppressed[jdx] = True
+                if iou > iou_thresh: suppressed[jdx] = True
         return np.array(keep, dtype=np.intp)
 
-    def _per_class_hard_nms(
-        self, boxes: ndarray, scores: ndarray, cls_ids: ndarray, iou_thresh: float
-    ) -> ndarray:
-        if len(boxes) == 0:
-            return np.array([], dtype=np.intp)
-        all_keep: list[int] = []
+    def _per_class_hard_nms(self, boxes, scores, cls_ids, iou_thresh):
+        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]
@@ -176,168 +142,236 @@ class Miner:
         return np.array(all_keep, dtype=np.intp)
 
     @staticmethod
-    def _cross_class_dedup(
-        boxes: ndarray, scores: ndarray, cls_ids: ndarray, iou_thresh: float
-    ) -> tuple[ndarray, ndarray, ndarray]:
-        """Suppress high-overlap duplicates across classes (FP reducer)."""
+    def _cross_class_dedup(boxes, scores, cls_ids, iou_thresh):
         n = len(boxes)
-        if n <= 1:
-            return boxes, scores, cls_ids
-        areas = np.maximum(0.0, boxes[:, 2] - boxes[:, 0]) * np.maximum(0.0, boxes[:, 3] - boxes[:, 1])
+        if n <= 1: return boxes, scores, cls_ids
+        areas = np.maximum(0.0, boxes[:, 2]-boxes[:, 0]) * np.maximum(0.0, boxes[:, 3]-boxes[:, 1])
         order = np.lexsort((-scores, -areas))
-        suppressed = np.zeros(n, dtype=bool)
-        keep: list[int] = []
+        suppressed = np.zeros(n, dtype=bool); keep = []
         for i in order:
-            if suppressed[i]:
-                continue
+            if suppressed[i]: continue
             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)
-            ai = max(1e-7, float((bi[2] - bi[0]) * (bi[3] - bi[1])))
+            inter = np.maximum(0.0, xx2-xx1) * np.maximum(0.0, yy2-yy1)
+            ai = max(1e-7, float((bi[2]-bi[0])*(bi[3]-bi[1])))
             iou = inter / (ai + areas - inter + 1e-7)
-            dup = iou > iou_thresh
-            dup[i] = False
+            dup = iou > iou_thresh; dup[i] = False
             suppressed |= dup
         kept = np.array(keep, dtype=np.intp)
         return boxes[kept], scores[kept], cls_ids[kept]
 
     @staticmethod
-    def _max_score_per_cluster(
-        coords: ndarray, scores: ndarray, keep_idx: ndarray, iou_thresh: float
-    ) -> ndarray:
-        """For each kept box, return max original score among any overlapping cluster member."""
-        if len(keep_idx) == 0:
-            return np.array([], dtype=np.float32)
+    def _max_score_per_cluster(coords, scores, keep_idx, iou_thresh):
+        if len(keep_idx) == 0: return np.array([], dtype=np.float32)
         out = np.empty(len(keep_idx), dtype=np.float32)
         for j, idx in enumerate(keep_idx):
             bi = coords[idx]
             xx1 = np.maximum(bi[0], coords[:, 0]); yy1 = np.maximum(bi[1], coords[:, 1])
             xx2 = np.minimum(bi[2], coords[:, 2]); yy2 = np.minimum(bi[3], coords[:, 3])
-            inter = np.maximum(0.0, xx2 - xx1) * np.maximum(0.0, yy2 - yy1)
-            ai = (bi[2] - bi[0]) * (bi[3] - bi[1])
-            aj = (coords[:, 2] - coords[:, 0]) * (coords[:, 3] - coords[:, 1])
+            inter = np.maximum(0.0, xx2-xx1) * np.maximum(0.0, yy2-yy1)
+            ai = (bi[2]-bi[0])*(bi[3]-bi[1])
+            aj = (coords[:, 2]-coords[:, 0]) * (coords[:, 3]-coords[:, 1])
             iou = inter / (ai + aj - inter + 1e-7)
             out[j] = float(np.max(scores[iou >= iou_thresh]))
         return out
 
-    # ---------------------------------------------------------------- inference
-    def _infer_single(self, image_bgr: ndarray) -> list[BoundingBox]:
+    def _infer_single(self, image_bgr):
         inp, ratio, (dx, dy) = self._preprocess(image_bgr)
         out = self.session.run(self.output_names, {self.input_name: inp})[0]
-        if out.ndim == 3:
-            out = out[0]
-
+        if out.ndim == 3: out = out[0]
         confs = out[:, 4].astype(np.float32)
         keep = confs >= self.conf_threshold
-        if not keep.any():
-            return []
+        if not keep.any(): return []
         out = out[keep]
-
         boxes = out[:, :4].astype(np.float32).copy()
         confs = out[:, 4].astype(np.float32)
         cls_ids = self.cls_remap[out[:, 5].astype(np.int32)]
-
-        # Reverse letterbox: model-space xyxy -> original-image xyxy
         boxes[:, [0, 2]] = (boxes[:, [0, 2]] - dx) / ratio
         boxes[:, [1, 3]] = (boxes[:, [1, 3]] - dy) / ratio
-
-        orig_h, orig_w = image_bgr.shape[:2]
-        boxes[:, [0, 2]] = np.clip(boxes[:, [0, 2]], 0, orig_w - 1)
-        boxes[:, [1, 3]] = np.clip(boxes[:, [1, 3]], 0, orig_h - 1)
-
+        oh, ow = image_bgr.shape[:2]
+        boxes[:, [0, 2]] = np.clip(boxes[:, [0, 2]], 0, ow - 1)
+        boxes[:, [1, 3]] = np.clip(boxes[:, [1, 3]], 0, oh - 1)
         if len(boxes) > 1:
             keep_idx = self._per_class_hard_nms(boxes, confs, cls_ids, self.iou_thresh)
             keep_idx = keep_idx[: self.max_det]
-            boxes = boxes[keep_idx]
-            confs = confs[keep_idx]
-            cls_ids = cls_ids[keep_idx]
-            boxes, confs, cls_ids = self._cross_class_dedup(
-                boxes, confs, cls_ids, self.cross_iou_thresh
-            )
-
-        return self._to_boundingboxes(boxes, confs, cls_ids, orig_w, orig_h)
+            boxes, confs, cls_ids = boxes[keep_idx], confs[keep_idx], cls_ids[keep_idx]
+            boxes, confs, cls_ids = self._cross_class_dedup(boxes, confs, cls_ids, self.cross_iou_thresh)
+        return self._to_boundingboxes(boxes, confs, cls_ids, ow, oh)
 
-    def _infer_tta(self, image_bgr: ndarray) -> list[BoundingBox]:
-        """H-flip TTA: union(orig, flipped) -> per-class NMS -> conf-boost."""
+    def _infer_tta(self, image_bgr):
         boxes_orig = self._infer_single(image_bgr)
-
         h, w = image_bgr.shape[:2]
         flipped = cv2.flip(image_bgr, 1)
         boxes_flip_raw = self._infer_single(flipped)
-        boxes_flip = [
-            BoundingBox(x1=w - b.x2, y1=b.y1, x2=w - b.x1, y2=b.y2,
-                        cls_id=b.cls_id, conf=b.conf)
-            for b in boxes_flip_raw
-        ]
-
+        boxes_flip = [BoundingBox(x1=w-b.x2, y1=b.y1, x2=w-b.x1, y2=b.y2, cls_id=b.cls_id, conf=b.conf)
+                      for b in boxes_flip_raw]
         all_boxes = boxes_orig + boxes_flip
-        if not all_boxes:
-            return []
-
+        if not all_boxes: return []
         coords = np.array([[b.x1, b.y1, b.x2, b.y2] for b in all_boxes], dtype=np.float32)
         scores = np.array([b.conf for b in all_boxes], dtype=np.float32)
         cls_ids = np.array([b.cls_id for b in all_boxes], dtype=np.int32)
-
         keep_idx = self._per_class_hard_nms(coords, scores, cls_ids, self.iou_thresh)
-        if len(keep_idx) == 0:
-            return []
+        if len(keep_idx) == 0: return []
         keep_idx = keep_idx[: self.max_det]
         boosted = self._max_score_per_cluster(coords, scores, keep_idx, self.iou_thresh)
-
-        out_boxes: list[BoundingBox] = []
+        out = []
         for j, idx in enumerate(keep_idx):
             b = all_boxes[idx]
-            out_boxes.append(BoundingBox(
-                x1=b.x1, y1=b.y1, x2=b.x2, y2=b.y2,
-                cls_id=b.cls_id,
-                conf=max(0.0, min(1.0, float(boosted[j]))),
-            ))
-        return out_boxes
+            out.append(BoundingBox(x1=b.x1, y1=b.y1, x2=b.x2, y2=b.y2, cls_id=b.cls_id,
+                                   conf=max(0.0, min(1.0, float(boosted[j])))))
+        return out
 
-    def _to_boundingboxes(
-        self, boxes: ndarray, confs: ndarray, cls_ids: ndarray,
-        orig_w: int, orig_h: int,
-    ) -> list[BoundingBox]:
-        out: list[BoundingBox] = []
+    def _to_boundingboxes(self, boxes, confs, cls_ids, orig_w, orig_h):
+        out = []
         for i in range(len(boxes)):
             x1, y1, x2, y2 = boxes[i]
             ix1 = max(0, min(orig_w, math.floor(x1)))
             iy1 = max(0, min(orig_h, math.floor(y1)))
             ix2 = max(0, min(orig_w, math.ceil(x2)))
             iy2 = max(0, min(orig_h, math.ceil(y2)))
-            if ix2 <= ix1 or iy2 <= iy1:
-                continue
+            if ix2 <= ix1 or iy2 <= iy1: continue
             bw, bh = ix2 - ix1, iy2 - iy1
-            if bw * bh < self.min_box_area:
-                continue
-            if min(bw, bh) < self.min_side:
-                continue
+            if bw * bh < self.min_box_area: continue
+            if min(bw, bh) < self.min_side: continue
             ar = max(bw / max(bh, 1), bh / max(bw, 1))
-            if ar > self.max_aspect_ratio:
-                continue
-            out.append(BoundingBox(
-                x1=ix1, y1=iy1, x2=ix2, y2=iy2,
-                cls_id=int(cls_ids[i]),
-                conf=max(0.0, min(1.0, float(confs[i]))),
-            ))
+            if ar > self.max_aspect_ratio: continue
+            out.append(BoundingBox(x1=ix1, y1=iy1, x2=ix2, y2=iy2, cls_id=int(cls_ids[i]),
+                                   conf=max(0.0, min(1.0, float(confs[i])))))
         return out
 
-    # ---------------------------------------------------------------- entry
-    def predict_batch(
-        self,
-        batch_images: list[ndarray],
-        offset: int,
-        n_keypoints: int,
-    ) -> list[TVFrameResult]:
-        infer = self._infer_tta if self.use_tta else self._infer_single
-        results: list[TVFrameResult] = []
+    def predict_one(self, image_bgr):
+        return self._infer_tta(image_bgr) if self.use_tta else self._infer_single(image_bgr)
+
+
+# ============================================================ RFDETR PATH
+class _RFDETRMiner:
+    def __init__(self, path_hf_repo: Path):
+        sess_options = ort.SessionOptions()
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        try:
+            self.session = ort.InferenceSession(
+                str(path_hf_repo / "weights_rfdetr.onnx"),
+                sess_options=sess_options,
+                providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
+            )
+        except Exception:
+            self.session = ort.InferenceSession(
+                str(path_hf_repo / "weights_rfdetr.onnx"),
+                sess_options=sess_options,
+                providers=["CPUExecutionProvider"],
+            )
+        self.input_name = self.session.get_inputs()[0].name
+        self.output_names = [o.name for o in self.session.get_outputs()]
+        self.input_h = 1288
+        self.input_w = 1288
+        self.conf_threshold = 0.52
+        self.min_box_area = 196
+        self.min_side = 8
+        self.max_aspect_ratio = 8.0
+
+    def predict_one(self, image_bgr):
+        oh, ow = image_bgr.shape[:2]
+        rgb = cv2.cvtColor(image_bgr, cv2.COLOR_BGR2RGB)
+        resized = cv2.resize(rgb, (self.input_w, self.input_h), interpolation=cv2.INTER_LINEAR)
+        x = resized.astype(np.float32) / 255.0
+        x = (x - _IMAGENET_MEAN) / _IMAGENET_STD
+        x = np.ascontiguousarray(np.transpose(x, (2, 0, 1))[None, ...].astype(np.float32))
+        out = self.session.run(self.output_names, {self.input_name: x})[0]
+        if out.ndim == 3: out = out[0]
+        confs = out[:, 4].astype(np.float32)
+        keep = confs >= self.conf_threshold
+        if not keep.any(): return []
+        out = out[keep]
+        boxes = out[:, :4].astype(np.float32).copy()
+        confs = out[:, 4].astype(np.float32)
+        cls_ids = out[:, 5].astype(np.int32)
+        sx = ow / float(self.input_w); sy = oh / float(self.input_h)
+        boxes[:, [0, 2]] *= sx; boxes[:, [1, 3]] *= sy
+        boxes[:, [0, 2]] = np.clip(boxes[:, [0, 2]], 0, ow - 1)
+        boxes[:, [1, 3]] = np.clip(boxes[:, [1, 3]], 0, oh - 1)
+        out_boxes = []
+        for i in range(len(boxes)):
+            x1, y1, x2, y2 = boxes[i]
+            ix1 = max(0, min(ow, math.floor(x1))); iy1 = max(0, min(oh, math.floor(y1)))
+            ix2 = max(0, min(ow, math.ceil(x2))); iy2 = max(0, min(oh, math.ceil(y2)))
+            if ix2 <= ix1 or iy2 <= iy1: continue
+            bw, bh = ix2 - ix1, iy2 - iy1
+            if bw * bh < self.min_box_area: continue
+            if min(bw, bh) < self.min_side: continue
+            ar = max(bw / max(bh, 1), bh / max(bw, 1))
+            if ar > self.max_aspect_ratio: continue
+            out_boxes.append(BoundingBox(x1=ix1, y1=iy1, x2=ix2, y2=iy2,
+                                         cls_id=int(cls_ids[i]),
+                                         conf=max(0.0, min(1.0, float(confs[i])))))
+        return out_boxes
+
+
+# ============================================================ ENSEMBLE PUBLIC
+class Miner:
+    """Public ensemble miner — chute calls predict_batch(...)."""
+
+    def __init__(self, path_hf_repo) -> None:
+        self.path_hf_repo = Path(path_hf_repo)
+        self.class_names = ["balaclava", "hoodie", "glove", "bat", "spray paint", "graffiti"]
+        try:
+            ort.preload_dlls()
+        except Exception:
+            pass
+        self.alfred = _AlfredMiner(self.path_hf_repo)
+        self.rfdetr = _RFDETRMiner(self.path_hf_repo)
+        self.alfred_classes = {0, 1, 5}
+        self.rfdetr_classes = {0, 1, 2, 3, 4}
+        self.merge_iou = 0.5
+        # Warmup
+        warm = np.zeros((1280, 1280, 3), dtype=np.uint8)
+        for _ in range(2):
+            try: self.alfred.predict_one(warm)
+            except Exception: break
+        for _ in range(2):
+            try: self.rfdetr.predict_one(warm)
+            except Exception: break
+
+    def __repr__(self):
+        return (f"CrimeEnsembleMiner v2  alfred(yolo26n@1280, TTA) + "
+                f"rfdetr(base@1288)  conf>=0.52  merge_iou={self.merge_iou}")
+
+    @staticmethod
+    def _box_iou(a: BoundingBox, b: BoundingBox) -> float:
+        xx1 = max(a.x1, b.x1); yy1 = max(a.y1, b.y1)
+        xx2 = min(a.x2, b.x2); yy2 = min(a.y2, b.y2)
+        inter = max(0, xx2 - xx1) * max(0, yy2 - yy1)
+        ai = (a.x2 - a.x1) * (a.y2 - a.y1)
+        bi = (b.x2 - b.x1) * (b.y2 - b.y1)
+        return inter / (ai + bi - inter + 1e-7)
+
+    def _merge(self, alfred_boxes: list, rfdetr_boxes: list) -> list:
+        """Per-class union: alfred always kept; rfdetr kept ONLY if not overlapping
+        an alfred same-class box at IoU >= merge_iou. cls 2/3/4 are rfdetr-only
+        (no alfred boxes there); cls 5 is alfred-only (no rfdetr boxes there);
+        cls 0/1 see both — alfred priority."""
+        kept = list(alfred_boxes)
+        for rb in rfdetr_boxes:
+            collide = False
+            for ab in alfred_boxes:
+                if ab.cls_id == rb.cls_id and self._box_iou(ab, rb) >= self.merge_iou:
+                    collide = True; break
+            if not collide:
+                kept.append(rb)
+        return kept
+
+    def predict_batch(self, batch_images, offset, n_keypoints):
+        results = []
         for idx, image in enumerate(batch_images):
-            boxes = infer(image)
+            a_all = self.alfred.predict_one(image)
+            r_all = self.rfdetr.predict_one(image)
+            a_keep = [b for b in a_all if b.cls_id in self.alfred_classes]
+            r_keep = [b for b in r_all if b.cls_id in self.rfdetr_classes]
+            merged = self._merge(a_keep, r_keep)
             results.append(TVFrameResult(
                 frame_id=offset + idx,
-                boxes=boxes,
+                boxes=merged,
                 keypoints=[(0, 0) for _ in range(max(0, int(n_keypoints)))],
             ))
         return results

weights_rfdetr.onnx

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