scorevision: push artifact

training/build_dataset.py

@@ -0,0 +1,860 @@
+"""
+End-to-end dataset builder for Detect-crime.
+
+Sources (each toggleable via flags; pipeline tolerates missing sources):
+  1. manako latestAnnotatedChallenge (--manako): king-labeled in-domain frames.
+  2. Roboflow Universe (--roboflow PER_CLASS_SLUGS): per-class detection datasets.
+  3. COCO 2017 'baseball bat' subset (--coco-bat): high-quality bat boxes.
+  4. Extra dir (--extra-dir): pre-collected images you've curated locally.
+
+Each Roboflow / COCO source is mapped to our 6-class target via an explicit class table.
+Empty-label images are dropped unless --keep-empty (we keep them as negative-bg supervision
+during silver pretrain).
+
+Pipeline:
+  - Pull each enabled source into a working dir.
+  - Auto-relabel: re-emit YOLO label files with cls ids remapped to our target order.
+    For sources that come *unlabeled* (e.g. manako frames without preds), run the king's
+    ONNX over them to get silver labels.
+  - Manako frames go to val (real-domain eval); rest is 90/10 train/val.
+
+Usage:
+  python build_dataset.py \
+      --out ../data \
+      --king-onnx /root/turbovision_crime/king_models/Detect-crime/weights.onnx \
+      --manako --manako-polls 30 \
+      --roboflow balaclava=brainster/balaclava-detection-v3 \
+      --roboflow glove=ppe-detection/gloves-v1 \
+      --coco-bat /path/to/coco/annotations/instances_train2017.json /path/to/coco/train2017 \
+      --extra-dir ../data_extra --keep-empty
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import io
+import json
+import os
+import random
+import shutil
+import sys
+import time
+from pathlib import Path
+from urllib.parse import quote
+from urllib.request import Request, urlopen
+
+import numpy as np
+
+
+TARGET_CLASS_NAMES = ["balaclava", "bat", "glove", "graffiti", "hoodie", "spray paint"]
+CLASS_TO_ID = {name: i for i, name in enumerate(TARGET_CLASS_NAMES)}
+ELEMENT_ID = "manak0/Detect-crime"
+CONSOLE_API = "https://console.scorevision.io/api/v2"
+
+# The current king (`alfred8995/crime001`) emits class ids in their own order:
+#   0 balaclava, 1 hoodie, 2 glove, 3 bat, 4 spray paint, 5 graffiti
+# When we use their ONNX as a silver labeler OR ingest manako API predictions, we
+# remap from alfred's order -> our target (manak0-baseline) order.
+KING_CLASS_ORDER = ["balaclava", "hoodie", "glove", "bat", "spray paint", "graffiti"]
+KING_TO_TARGET_REMAP = np.array(
+    [TARGET_CLASS_NAMES.index(n) for n in KING_CLASS_ORDER], dtype=np.int32
+)
+# Sanity: KING_TO_TARGET_REMAP == [0, 4, 2, 1, 5, 3]
+
+
+# --------------------------------------------------------------------- utils
+
+def http_get(url: str, timeout: int = 60, retries: int = 4, headers: dict | None = None) -> bytes:
+    last = None
+    base_headers = {"User-Agent": "build_dataset/1.0"}
+    if headers:
+        base_headers.update(headers)
+    for i in range(retries):
+        try:
+            req = Request(url, headers=base_headers)
+            with urlopen(req, timeout=timeout) as r:
+                return r.read()
+        except Exception as e:
+            last = e
+            if i < retries - 1:
+                time.sleep(1.5 * (i + 1))
+    raise last  # type: ignore
+
+
+def sha16(b: bytes) -> str:
+    return hashlib.sha256(b).hexdigest()[:16]
+
+
+def image_size(buf: bytes) -> tuple[int, int]:
+    if buf[:8] == b"\x89PNG\r\n\x1a\n":
+        return int.from_bytes(buf[16:20], "big"), int.from_bytes(buf[20:24], "big")
+    if buf[:2] == b"\xff\xd8":
+        from PIL import Image
+        return Image.open(io.BytesIO(buf)).size
+    from PIL import Image
+    return Image.open(io.BytesIO(buf)).size
+
+
+# --------------------------------------------------------------------- sources
+
+def fetch_manako(work: Path, log, polls: int = 1, delay_s: int = 180) -> list[tuple[Path, str, dict | None]]:
+    """Pull rotating latestAnnotatedChallenge frames + king predictions."""
+    out: list[tuple[Path, str, dict | None]] = []
+    img_dir = work / "manako_images"
+    img_dir.mkdir(parents=True, exist_ok=True)
+    seen_paths: set[str] = set()
+
+    for attempt in range(max(1, polls)):
+        try:
+            raw = http_get(f"{CONSOLE_API}/elements/{quote(ELEMENT_ID, safe='')}?lookback_days=30")
+        except Exception as e:
+            log(f"[manako] API call failed (attempt {attempt + 1}/{polls}): {e}")
+            if attempt < polls - 1:
+                time.sleep(delay_s)
+            continue
+        elt = json.loads(raw)
+        lac = elt.get("latestAnnotatedChallenge")
+        if not lac:
+            log(f"[manako] no latestAnnotatedChallenge (attempt {attempt + 1}/{polls})")
+            if attempt < polls - 1:
+                time.sleep(delay_s)
+            continue
+
+        frames = (lac.get("response") or {}).get("frames") or []
+        preds = ((lac.get("response") or {}).get("predictions") or {}).get("frames") or []
+        preds_by_id = {p.get("frame_id"): p for p in preds}
+
+        new_count = 0
+        for f in frames:
+            url = f.get("url")
+            fid = f.get("frame_id")
+            if not url:
+                continue
+            try:
+                data = http_get(url)
+            except Exception as e:
+                log(f"[manako] image fetch failed {url}: {e}")
+                continue
+            digest = sha16(data)
+            path = img_dir / f"manako_ch{lac.get('challenge_id')}_f{fid}_{digest}.png"
+            if str(path) in seen_paths:
+                continue
+            seen_paths.add(str(path))
+            path.write_bytes(data)
+            out.append((path, "manako", preds_by_id.get(fid)))
+            new_count += 1
+
+        log(f"[manako] poll {attempt + 1}/{polls}: +{new_count} (total {len(out)}, "
+            f"challenge_id={lac.get('challenge_id')})")
+        if attempt < polls - 1:
+            time.sleep(delay_s)
+
+    log(f"[manako] pulled {len(out)} unique image(s) across {polls} poll(s)")
+    return out
+
+
+def fetch_roboflow(slug: str, target_class: str, work: Path, log,
+                   api_key: str | None = None) -> list[tuple[Path, str, list[str]]]:
+    """Download a Roboflow Universe dataset in YOLO format and remap to target class id.
+
+    `slug` is the workspace/project[/version] path on universe.roboflow.com.
+    Without API key, only public/free datasets work; many crime-relevant ones are public.
+    """
+    target_id = CLASS_TO_ID.get(target_class)
+    if target_id is None:
+        log(f"[roboflow] unknown target class: {target_class}")
+        return []
+
+    out_dir = work / "roboflow" / slug.replace("/", "_")
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out: list[tuple[Path, str, list[str]]] = []
+
+    try:
+        from roboflow import Roboflow  # type: ignore
+    except ImportError:
+        log("[roboflow] roboflow SDK not installed; pip install roboflow")
+        return []
+
+    if api_key is None:
+        api_key = os.environ.get("ROBOFLOW_API_KEY", "")
+    if not api_key:
+        log(f"[roboflow] no ROBOFLOW_API_KEY set; skipping {slug}")
+        return []
+
+    parts = slug.split("/")
+    if len(parts) < 2:
+        log(f"[roboflow] malformed slug: {slug}")
+        return []
+    ws, project = parts[0], parts[1]
+    version = int(parts[2]) if len(parts) >= 3 and parts[2].isdigit() else 1
+
+    rf = Roboflow(api_key=api_key)
+    ds = rf.workspace(ws).project(project).version(version).download("yolov8", location=str(out_dir))
+    log(f"[roboflow] downloaded {slug} -> {ds.location}")
+
+    # Roboflow YOLO export: {ds.location}/{train,valid,test}/images/*, labels/*.txt with their own data.yaml
+    rf_yaml = Path(ds.location) / "data.yaml"
+    if not rf_yaml.exists():
+        log(f"[roboflow] no data.yaml in {ds.location}; skipping")
+        return []
+
+    # Parse names from data.yaml (we accept either yaml or simple key:value).
+    try:
+        import yaml
+        rf_cfg = yaml.safe_load(rf_yaml.read_text())
+    except Exception as e:
+        log(f"[roboflow] yaml parse failed for {rf_yaml}: {e}")
+        return []
+    rf_names = rf_cfg.get("names") or []
+    if isinstance(rf_names, dict):
+        rf_names = [rf_names[k] for k in sorted(rf_names.keys())]
+
+    for split in ("train", "valid", "test"):
+        img_dir = Path(ds.location) / split / "images"
+        lbl_dir = Path(ds.location) / split / "labels"
+        if not img_dir.exists() or not lbl_dir.exists():
+            continue
+        for img_path in img_dir.iterdir():
+            if not img_path.is_file():
+                continue
+            lbl_path = lbl_dir / (img_path.stem + ".txt")
+            if not lbl_path.exists():
+                continue
+            try:
+                rows = lbl_path.read_text().strip().splitlines()
+            except Exception:
+                continue
+            mapped: list[str] = []
+            for r in rows:
+                parts = r.split()
+                if len(parts) != 5:
+                    continue
+                src_cls = int(parts[0])
+                # Single-class roboflow datasets: any positive box -> target class
+                if len(rf_names) == 1 or src_cls >= len(rf_names):
+                    mapped.append(f"{target_id} {parts[1]} {parts[2]} {parts[3]} {parts[4]}")
+                    continue
+                # Multi-class: keep only boxes whose name matches the target (loose match).
+                src_name = str(rf_names[src_cls]).lower().replace("_", " ")
+                if target_class.lower() in src_name or src_name in target_class.lower():
+                    mapped.append(f"{target_id} {parts[1]} {parts[2]} {parts[3]} {parts[4]}")
+            if not mapped:
+                continue
+            out.append((img_path, f"roboflow_{slug.replace('/', '_')}", mapped))
+
+    log(f"[roboflow] {slug}: kept {len(out)} labeled images")
+    return out
+
+
+def fetch_coco_bat(coco_ann_json: Path, coco_img_dir: Path, log) -> list[tuple[Path, str, list[str]]]:
+    """Extract baseball-bat images from a COCO 2017 annotations file."""
+    target_id = CLASS_TO_ID["bat"]
+    out: list[tuple[Path, str, list[str]]] = []
+    if not coco_ann_json.exists() or not coco_img_dir.exists():
+        log(f"[coco-bat] paths missing: {coco_ann_json}, {coco_img_dir}")
+        return out
+
+    log(f"[coco-bat] reading {coco_ann_json} (this is large; ~30s)...")
+    with coco_ann_json.open() as f:
+        coco = json.load(f)
+
+    # COCO category id 39 = "baseball bat" in the 80-class set.
+    bat_ids = {c["id"] for c in coco.get("categories", []) if c.get("name", "").lower() == "baseball bat"}
+    if not bat_ids:
+        log("[coco-bat] no 'baseball bat' category found; aborting")
+        return out
+
+    # Group annotations by image_id.
+    images = {im["id"]: im for im in coco.get("images", [])}
+    by_img: dict[int, list[dict]] = {}
+    for ann in coco.get("annotations", []):
+        if ann.get("category_id") in bat_ids:
+            by_img.setdefault(ann["image_id"], []).append(ann)
+
+    for img_id, anns in by_img.items():
+        info = images.get(img_id)
+        if not info:
+            continue
+        fname = info["file_name"]
+        w, h = info["width"], info["height"]
+        img_path = coco_img_dir / fname
+        if not img_path.exists():
+            continue
+        rows = []
+        for a in anns:
+            x, y, bw, bh = a["bbox"]  # COCO xywh top-left
+            cx = (x + bw / 2.0) / w
+            cy = (y + bh / 2.0) / h
+            rows.append(f"{target_id} {cx:.6f} {cy:.6f} {bw / w:.6f} {bh / h:.6f}")
+        if rows:
+            out.append((img_path, "coco_bat", rows))
+    log(f"[coco-bat] kept {len(out)} bat-positive images")
+    return out
+
+
+def fetch_hf_parquet_coco(repo_id: str, filename: str, target_class: str,
+                          work: Path, log,
+                          limit: int = 0) -> list[tuple[bytes, str, list[str]]]:
+    """Pull a HuggingFace `datasets`-style parquet whose rows have
+    `image: {bytes}`, `width`, `height`, `objects: [{bbox: [x,y,w,h], ...}]`
+    (graffiti dataset format). Maps every box to TARGET_CLASS_NAMES[target_class].
+
+    Returns list of (image_bytes, source_tag, yolo_label_rows).
+    """
+    target_id = CLASS_TO_ID.get(target_class)
+    if target_id is None:
+        log(f"[hf-parquet-coco] unknown target class: {target_class}")
+        return []
+    try:
+        from huggingface_hub import hf_hub_download
+        import pyarrow.parquet as pq
+    except ImportError:
+        log("[hf-parquet-coco] missing deps; pip install huggingface_hub pyarrow")
+        return []
+    try:
+        local = hf_hub_download(
+            repo_id=repo_id, filename=filename,
+            repo_type="dataset", cache_dir=str(work / "_hf_cache"),
+        )
+    except Exception as e:
+        log(f"[hf-parquet-coco] download failed {repo_id}/{filename}: {e}")
+        return []
+    log(f"[hf-parquet-coco] downloaded {repo_id}/{filename}")
+    out: list[tuple[bytes, str, list[str]]] = []
+    table = pq.read_table(local, columns=["image", "width", "height", "objects"])
+    rows = table.to_pylist()
+    for row in rows:
+        img_dict = row.get("image") or {}
+        data = img_dict.get("bytes") if isinstance(img_dict, dict) else None
+        if not data:
+            continue
+        w = int(row.get("width") or 0)
+        h = int(row.get("height") or 0)
+        if w <= 0 or h <= 0:
+            try:
+                w, h = image_size(data)
+            except Exception:
+                continue
+        labels: list[str] = []
+        for obj in row.get("objects") or []:
+            bbox = obj.get("bbox") or []
+            if len(bbox) != 4:
+                continue
+            bx, by, bw, bh = (float(bbox[0]), float(bbox[1]), float(bbox[2]), float(bbox[3]))
+            if bw <= 1 or bh <= 1:
+                continue
+            cx = (bx + bw / 2.0) / w
+            cy = (by + bh / 2.0) / h
+            labels.append(f"{target_id} {cx:.6f} {cy:.6f} {bw / w:.6f} {bh / h:.6f}")
+        if labels:
+            out.append((data, f"hf_{repo_id.replace('/', '_')}", labels))
+        if limit and len(out) >= limit:
+            break
+    log(f"[hf-parquet-coco] {repo_id}: kept {len(out)} labeled images")
+    return out
+
+
+def fetch_hf_parquet_cls(repo_id: str, filename: str, target_class: str,
+                         work: Path, log,
+                         limit: int = 0) -> list[tuple[bytes, str, None]]:
+    """Pull a HuggingFace classification-synset parquet (rows have just
+    `image: {bytes}` with optional `label`). Boxes will be filled in later by
+    the king's ONNX silver labeler — this fn just extracts the image bytes.
+
+    `target_class` is purely a tag for downstream filtering; the king labels
+    every detection regardless.
+    """
+    try:
+        from huggingface_hub import hf_hub_download
+        import pyarrow.parquet as pq
+    except ImportError:
+        log("[hf-parquet-cls] missing deps; pip install huggingface_hub pyarrow")
+        return []
+    try:
+        local = hf_hub_download(
+            repo_id=repo_id, filename=filename,
+            repo_type="dataset", cache_dir=str(work / "_hf_cache"),
+        )
+    except Exception as e:
+        log(f"[hf-parquet-cls] download failed {repo_id}/{filename}: {e}")
+        return []
+    log(f"[hf-parquet-cls] downloaded {repo_id}/{filename}")
+    out: list[tuple[bytes, str, None]] = []
+    table = pq.read_table(local, columns=["image"])
+    for row in table.to_pylist():
+        img_dict = row.get("image") or {}
+        data = img_dict.get("bytes") if isinstance(img_dict, dict) else None
+        if not data:
+            continue
+        out.append((data, f"hf_{repo_id.replace('/', '_')}_{target_class}", None))
+        if limit and len(out) >= limit:
+            break
+    log(f"[hf-parquet-cls] {repo_id}: extracted {len(out)} images (king will label)")
+    return out
+
+
+def fetch_extra(extra_dir: Path | None, log) -> list[tuple[Path, str, None]]:
+    if extra_dir is None or not extra_dir.exists():
+        return []
+    out: list[tuple[Path, str, None]] = []
+    for ext in ("*.jpg", "*.jpeg", "*.png", "*.bmp", "*.webp"):
+        for p in extra_dir.rglob(ext):
+            out.append((p, "extra", None))
+    log(f"[extra] picked up {len(out)} images from {extra_dir}")
+    return out
+
+
+# --------------------------------------------------------------------- king labeler
+
+class KingLabeler:
+    """Run the king's ONNX over an unlabeled image to produce YOLO-format silver labels.
+
+    Mirrors alfred8995/crime001's preprocessing: letterbox to native input H/W, RGB / 255,
+    NCHW float32. Decodes both [N,6] / [1,N,6] (NMS-baked) and raw [1, C, N] formats with
+    proper letterbox-reverse back to original image coords.
+    """
+
+    def __init__(self, onnx_path: Path, conf_floor: float = 0.15, intra_threads: int = 0) -> None:
+        import onnxruntime as ort
+        sess_options = ort.SessionOptions()
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        if intra_threads > 0:
+            sess_options.intra_op_num_threads = int(intra_threads)
+        try:
+            self.session = ort.InferenceSession(
+                str(onnx_path), sess_options=sess_options,
+                providers=["CUDAExecutionProvider", "CPUExecutionProvider"],
+            )
+        except Exception:
+            self.session = ort.InferenceSession(
+                str(onnx_path), 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()]
+        in_shape = self.session.get_inputs()[0].shape
+        self.in_h = int(in_shape[2]) if isinstance(in_shape[2], int) and in_shape[2] > 0 else 640
+        self.in_w = int(in_shape[3]) if isinstance(in_shape[3], int) and in_shape[3] > 0 else 640
+        self.conf_floor = float(conf_floor)
+        self.iou_thresh = 0.45
+
+    @staticmethod
+    def _letterbox(image: np.ndarray, new_size: tuple[int, int],
+                   color: tuple[int, int, int] = (114, 114, 114)
+                   ) -> tuple[np.ndarray, float, tuple[float, float]]:
+        import cv2
+        h, w = image.shape[:2]
+        new_w, new_h = new_size
+        ratio = min(new_w / w, new_h / h)
+        rw, rh = int(round(w * ratio)), int(round(h * ratio))
+        if (rw, rh) != (w, h):
+            interp = cv2.INTER_CUBIC if ratio > 1.0 else cv2.INTER_LINEAR
+            image = cv2.resize(image, (rw, rh), interpolation=interp)
+        dw = (new_w - rw) / 2.0
+        dh = (new_h - 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)
+        return padded, ratio, (dw, dh)
+
+    def label(self, image_bytes: bytes) -> list[str]:
+        import cv2
+        arr = np.frombuffer(image_bytes, dtype=np.uint8)
+        bgr = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+        if bgr is None:
+            return []
+        orig_h, orig_w = bgr.shape[:2]
+
+        padded, ratio, (dw, dh) = self._letterbox(bgr, (self.in_w, self.in_h))
+        rgb = cv2.cvtColor(padded, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
+        x = np.transpose(rgb, (2, 0, 1))[None, ...]
+        x = np.ascontiguousarray(x, dtype=np.float32)
+
+        out = self.session.run(self.output_names, {self.input_name: x})[0]
+        return self._decode(out, ratio, dw, dh, orig_w, orig_h)
+
+    def _decode(self, output: np.ndarray, ratio: float, dw: float, dh: float,
+                orig_w: int, orig_h: int) -> list[str]:
+        """Decode + reverse-letterbox to original image coords."""
+        # 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, dw, dh, orig_w, orig_h)
+
+        boxes = preds[:, :4].astype(np.float32, copy=True)
+        scores = preds[:, 4].astype(np.float32)
+        cls = preds[:, 5].astype(np.int32)
+
+        keep = (scores >= self.conf_floor) & (boxes[:, 2] > boxes[:, 0]) & (boxes[:, 3] > boxes[:, 1])
+        boxes, scores, cls = boxes[keep], scores[keep], cls[keep]
+        if len(boxes) == 0:
+            return []
+
+        # reverse letterbox (input-letterboxed coords -> orig image coords)
+        boxes[:, [0, 2]] -= dw
+        boxes[:, [1, 3]] -= dh
+        boxes /= ratio
+        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 self._to_yolo_rows(boxes, cls, orig_w, orig_h)
+
+    def _decode_raw(self, output: np.ndarray, ratio: float, dw: float, dh: float,
+                    orig_w: int, orig_h: int) -> list[str]:
+        """Fallback for raw [1, C, N] / [1, N, C] YOLO output (e.g. manak0 baseline)."""
+        if output.ndim != 3 or output.shape[0] != 1:
+            return []
+        p = output[0]
+        if p.shape[0] <= 16 and p.shape[1] > p.shape[0]:
+            p = p.T
+        if p.shape[1] < 5:
+            return []
+        boxes_xywh = p[:, :4].astype(np.float32)
+        cls_part = p[:, 4:].astype(np.float32)
+        cls = np.argmax(cls_part, axis=1).astype(np.int32)
+        scores = cls_part[np.arange(len(cls_part)), cls]
+        keep = scores >= self.conf_floor
+        if not np.any(keep):
+            return []
+        boxes_xywh = boxes_xywh[keep]
+        scores = scores[keep]
+        cls = cls[keep]
+        # xywh (input-letterboxed coords) -> xyxy (input coords)
+        xyxy = np.empty((len(boxes_xywh), 4), dtype=np.float32)
+        xyxy[:, 0] = boxes_xywh[:, 0] - boxes_xywh[:, 2] / 2.0
+        xyxy[:, 1] = boxes_xywh[:, 1] - boxes_xywh[:, 3] / 2.0
+        xyxy[:, 2] = boxes_xywh[:, 0] + boxes_xywh[:, 2] / 2.0
+        xyxy[:, 3] = boxes_xywh[:, 1] + boxes_xywh[:, 3] / 2.0
+        xyxy, scores, cls = self._nms(xyxy, scores, cls, self.iou_thresh)
+        if len(xyxy) == 0:
+            return []
+        # reverse letterbox
+        xyxy[:, [0, 2]] -= dw
+        xyxy[:, [1, 3]] -= dh
+        xyxy /= ratio
+        xyxy[:, 0] = np.clip(xyxy[:, 0], 0, orig_w - 1)
+        xyxy[:, 1] = np.clip(xyxy[:, 1], 0, orig_h - 1)
+        xyxy[:, 2] = np.clip(xyxy[:, 2], 0, orig_w - 1)
+        xyxy[:, 3] = np.clip(xyxy[:, 3], 0, orig_h - 1)
+        return self._to_yolo_rows(xyxy, cls, orig_w, orig_h)
+
+    @staticmethod
+    def _nms(boxes: np.ndarray, scores: np.ndarray, cls: np.ndarray,
+             iou_thresh: float) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        if len(boxes) == 0:
+            return boxes, scores, cls
+        order = np.argsort(-scores)
+        boxes = boxes[order]; scores = scores[order]; cls = cls[order]
+        keep = []
+        suppressed = np.zeros(len(boxes), dtype=bool)
+        for i in range(len(boxes)):
+            if suppressed[i]:
+                continue
+            keep.append(i)
+            xa = np.maximum(boxes[i, 0], boxes[i + 1:, 0])
+            ya = np.maximum(boxes[i, 1], boxes[i + 1:, 1])
+            xb = np.minimum(boxes[i, 2], boxes[i + 1:, 2])
+            yb = np.minimum(boxes[i, 3], boxes[i + 1:, 3])
+            inter = np.maximum(0.0, xb - xa) * np.maximum(0.0, yb - ya)
+            area_i = (boxes[i, 2] - boxes[i, 0]) * (boxes[i, 3] - boxes[i, 1])
+            area_r = (boxes[i + 1:, 2] - boxes[i + 1:, 0]) * (boxes[i + 1:, 3] - boxes[i + 1:, 1])
+            ious = inter / (area_i + area_r - inter + 1e-7)
+            for k, ok in enumerate(ious >= iou_thresh):
+                if ok:
+                    suppressed[i + 1 + k] = True
+        return boxes[keep], scores[keep], cls[keep]
+
+    @staticmethod
+    def _to_yolo_rows(boxes: np.ndarray, cls: np.ndarray, w: int, h: int) -> list[str]:
+        # Remap king's class order -> our target order before emitting.
+        rows = []
+        for (x1, y1, x2, y2), c in zip(boxes, cls):
+            if c < 0 or c >= len(KING_TO_TARGET_REMAP):
+                continue
+            tgt = int(KING_TO_TARGET_REMAP[int(c)])
+            bw = float(x2 - x1)
+            bh = float(y2 - y1)
+            if bw <= 1 or bh <= 1:
+                continue
+            cx = (float(x1) + float(x2)) / 2.0 / w
+            cy = (float(y1) + float(y2)) / 2.0 / h
+            rows.append(f"{tgt} {cx:.6f} {cy:.6f} {bw / w:.6f} {bh / h:.6f}")
+        return rows
+
+
+def king_preds_to_yolo(preds: dict, img_w: int, img_h: int) -> list[str]:
+    """Manako preds use absolute pixel xyxy + cls_id (in alfred8995's class order).
+    Remap to our target order before emitting YOLO rows.
+    """
+    rows: list[str] = []
+    for box in preds.get("boxes") or []:
+        try:
+            x1, y1, x2, y2 = float(box["x1"]), float(box["y1"]), float(box["x2"]), float(box["y2"])
+            c = int(box["cls_id"])
+        except Exception:
+            continue
+        if c < 0 or c >= len(KING_TO_TARGET_REMAP):
+            continue
+        tgt = int(KING_TO_TARGET_REMAP[c])
+        bw = x2 - x1
+        bh = y2 - y1
+        if bw <= 1 or bh <= 1:
+            continue
+        cx = (x1 + x2) / 2.0 / img_w
+        cy = (y1 + y2) / 2.0 / img_h
+        rows.append(f"{tgt} {cx:.6f} {cy:.6f} {bw / img_w:.6f} {bh / img_h:.6f}")
+    return rows
+
+
+# --------------------------------------------------------------------- writer
+
+def write_yolo_pair(out_root: Path, split: str, name: str, image_bytes: bytes,
+                    label_lines: list[str], ext: str) -> None:
+    img_dir = out_root / "images" / split
+    lbl_dir = out_root / "labels" / split
+    img_dir.mkdir(parents=True, exist_ok=True)
+    lbl_dir.mkdir(parents=True, exist_ok=True)
+    (img_dir / f"{name}.{ext}").write_bytes(image_bytes)
+    (lbl_dir / f"{name}.txt").write_text("\n".join(label_lines), encoding="utf-8")
+
+
+def write_data_yaml(out_root: Path) -> Path:
+    data_yaml = out_root / "data.yaml"
+    data_yaml.write_text(
+        "# YOLO dataset for manak0/Detect-crime\n"
+        f"path: {out_root.resolve()}\n"
+        "train: images/train\n"
+        "val: images/val\n"
+        "names:\n"
+        + "".join(f"  {i}: {n}\n" for i, n in enumerate(TARGET_CLASS_NAMES)),
+        encoding="utf-8",
+    )
+    return data_yaml
+
+
+# --------------------------------------------------------------------- main
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--out", required=True, help="dataset output root (YOLO format)")
+    ap.add_argument("--king-onnx", required=True,
+                    help="path to king's ONNX (used as silver labeler for unlabeled frames)")
+    ap.add_argument("--manako", action="store_true", help="poll manako latestAnnotatedChallenge")
+    ap.add_argument("--manako-polls", type=int, default=1)
+    ap.add_argument("--manako-poll-delay", type=int, default=180)
+    ap.add_argument("--roboflow", action="append", default=[],
+                    help="repeatable: TARGETCLASS=workspace/project[/version]; "
+                         "e.g. balaclava=brainster/balaclava-detection-v3")
+    ap.add_argument("--coco-bat", nargs=2, metavar=("ANN_JSON", "IMG_DIR"),
+                    help="paths to COCO instances_train2017.json and train2017/")
+    ap.add_argument("--extra-dir", type=Path, default=None,
+                    help="optional dir of pre-collected images (auto-labeled by king)")
+    ap.add_argument("--hf-parquet-coco", action="append", default=[],
+                    help="repeatable: TARGETCLASS=repo_id::filename (COCO-bbox parquet); "
+                         "e.g. graffiti=junaidfayazlone/GraffitiDetection::Train-00000-of-00001-graffiti.parquet")
+    ap.add_argument("--hf-parquet-cls", action="append", default=[],
+                    help="repeatable: TARGETCLASS=repo_id::filename (classification parquet, "
+                         "king-labeled); e.g. balaclava=mlnomad/imnet1k_ski_mask::data/train-00000-of-00001.parquet")
+    ap.add_argument("--hf-limit", type=int, default=0,
+                    help="cap rows pulled from each HF parquet (0 = all)")
+    ap.add_argument("--min-conf", type=float, default=0.15,
+                    help="confidence floor for the silver labeler (lower = more labels, more noise)")
+    ap.add_argument("--workdir", type=Path, default=Path("/tmp/crime_dataset_work"))
+    ap.add_argument("--val-frac", type=float, default=0.10)
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--limit", type=int, default=0,
+                    help="cap images per source (0 = no cap)")
+    ap.add_argument("--intra-threads", type=int, default=0)
+    ap.add_argument("--keep-empty", action="store_true",
+                    help="keep images with no detected boxes (negative-bg supervision)")
+    args = ap.parse_args()
+
+    out_root = Path(args.out).resolve()
+    work = args.workdir.resolve()
+    work.mkdir(parents=True, exist_ok=True)
+
+    def log(msg: str) -> None:
+        print(msg, file=sys.stderr, flush=True)
+
+    # Sources collected as (path_or_bytes, src_tag, labels_or_preds_or_None).
+    # labels can be: list[str] YOLO rows (already mapped), dict (king preds), or None (needs labeling).
+    sources: list[tuple[Path, str, list[str] | dict | None]] = []
+
+    if args.manako:
+        for img_path, src, preds in fetch_manako(work, log,
+                                                  polls=args.manako_polls,
+                                                  delay_s=args.manako_poll_delay):
+            sources.append((img_path, src, preds))
+
+    for spec in args.roboflow:
+        if "=" not in spec:
+            log(f"[roboflow] malformed --roboflow {spec}; expected TARGETCLASS=slug")
+            continue
+        target, slug = spec.split("=", 1)
+        for img_path, src, labels in fetch_roboflow(slug.strip(), target.strip(), work, log):
+            sources.append((img_path, src, labels))
+
+    if args.coco_bat:
+        coco_ann, coco_img = Path(args.coco_bat[0]), Path(args.coco_bat[1])
+        for img_path, src, labels in fetch_coco_bat(coco_ann, coco_img, log):
+            sources.append((img_path, src, labels))
+
+    # HF parquet sources land as (bytes, src, labels). Persist to disk under work
+    # so the rest of the pipeline (which expects file paths) can pick them up.
+    hf_dir = work / "hf_images"
+    hf_dir.mkdir(parents=True, exist_ok=True)
+
+    for spec in args.hf_parquet_coco:
+        if "=" not in spec or "::" not in spec:
+            log(f"[hf-parquet-coco] malformed {spec}; expected TARGETCLASS=repo::filename")
+            continue
+        target, rest = spec.split("=", 1)
+        repo_id, filename = rest.split("::", 1)
+        for data, src, labels in fetch_hf_parquet_coco(repo_id.strip(), filename.strip(),
+                                                       target.strip(), work, log,
+                                                       limit=args.hf_limit):
+            digest = sha16(data)
+            ext = "jpg" if data[:2] == b"\xff\xd8" else "png"
+            p = hf_dir / f"{src}_{digest}.{ext}"
+            if not p.exists():
+                p.write_bytes(data)
+            sources.append((p, src, labels))
+
+    for spec in args.hf_parquet_cls:
+        if "=" not in spec or "::" not in spec:
+            log(f"[hf-parquet-cls] malformed {spec}; expected TARGETCLASS=repo::filename")
+            continue
+        target, rest = spec.split("=", 1)
+        repo_id, filename = rest.split("::", 1)
+        for data, src, _ in fetch_hf_parquet_cls(repo_id.strip(), filename.strip(),
+                                                  target.strip(), work, log,
+                                                  limit=args.hf_limit):
+            digest = sha16(data)
+            ext = "jpg" if data[:2] == b"\xff\xd8" else "png"
+            p = hf_dir / f"{src}_{digest}.{ext}"
+            if not p.exists():
+                p.write_bytes(data)
+            sources.append((p, src, None))
+
+    if args.extra_dir:
+        for img_path, src, _ in fetch_extra(args.extra_dir, log):
+            sources.append((img_path, src, None))
+
+    if not sources:
+        log("[!] no sources; pass at least --manako / --roboflow / --coco-bat / --extra-dir")
+        return 1
+
+    if args.limit:
+        sources = sources[: args.limit * 8]  # rough cap; we'll dedupe below
+    log(f"[build] total candidate sources: {len(sources)}")
+
+    # Auto-labeler for sources that come unlabeled.
+    labeler = KingLabeler(Path(args.king_onnx), conf_floor=args.min_conf,
+                          intra_threads=args.intra_threads)
+    log(f"[label] king onnx input={labeler.in_w}x{labeler.in_h} "
+        f"providers={labeler.session.get_providers()}")
+
+    samples: list[tuple[str, bytes, list[str], str]] = []
+    seen_hashes: set[str] = set()
+    n_labeled = 0
+    for i, (path, src, payload) in enumerate(sources):
+        try:
+            data = path.read_bytes()
+        except Exception as e:
+            log(f"[skip] read failed {path}: {e}")
+            continue
+        digest = sha16(data)
+        if digest in seen_hashes:
+            continue
+        seen_hashes.add(digest)
+        ext = "jpg" if data[:2] == b"\xff\xd8" else "png"
+
+        labels: list[str]
+        if isinstance(payload, list):
+            labels = payload                   # already remapped YOLO rows
+        elif isinstance(payload, dict):
+            try:
+                w, h = image_size(data)
+                labels = king_preds_to_yolo(payload, w, h)
+            except Exception as e:
+                log(f"[label] manako preds parse failed {path}: {e}; falling back to ONNX")
+                labels = labeler.label(data)
+        else:
+            try:
+                labels = labeler.label(data)
+            except Exception as e:
+                log(f"[label] ONNX labeling failed {path}: {e}")
+                continue
+
+        if not labels and not args.keep_empty:
+            continue
+        if labels:
+            n_labeled += 1
+        name = f"{src}_{digest}"
+        samples.append((name, data, labels, src))
+        if (i + 1) % 200 == 0:
+            log(f"  labeled {i + 1}/{len(sources)} (kept {len(samples)})")
+
+    log(f"[build] labeled {n_labeled}/{len(sources)} unique images (others were empty)")
+
+    if not samples:
+        log("[!] zero labeled samples; lower --min-conf and retry")
+        return 1
+
+    rng = random.Random(args.seed)
+    manako_samples = [s for s in samples if s[3] == "manako"]
+    other_samples = [s for s in samples if s[3] != "manako"]
+    rng.shuffle(other_samples)
+
+    n_val_target = max(1, int(round(len(samples) * args.val_frac)))
+    val: list = list(manako_samples)
+    if len(val) < n_val_target:
+        val.extend(other_samples[: n_val_target - len(val)])
+        train = other_samples[n_val_target - len(manako_samples):]
+    else:
+        train = other_samples
+    log(f"[split] train={len(train)}  val={len(val)}  (manako-in-val={len(manako_samples)})")
+
+    if out_root.exists():
+        for sub in ("images/train", "images/val", "labels/train", "labels/val"):
+            d = out_root / sub
+            if d.exists():
+                shutil.rmtree(d)
+    out_root.mkdir(parents=True, exist_ok=True)
+
+    for name, data, labels, _src in train:
+        ext = "jpg" if data[:2] == b"\xff\xd8" else "png"
+        write_yolo_pair(out_root, "train", name, data, labels, ext)
+    for name, data, labels, _src in val:
+        ext = "jpg" if data[:2] == b"\xff\xd8" else "png"
+        write_yolo_pair(out_root, "val", name, data, labels, ext)
+
+    yaml_path = write_data_yaml(out_root)
+    log(f"[done] wrote dataset to {out_root}")
+    log(f"       data.yaml: {yaml_path}")
+    log(f"       train images: {len(train)}, val images: {len(val)}")
+
+    cls_train = [0] * len(TARGET_CLASS_NAMES)
+    cls_val = [0] * len(TARGET_CLASS_NAMES)
+    for _n, _b, labs, _s in train:
+        for line in labs:
+            cls_train[int(line.split()[0])] += 1
+    for _n, _b, labs, _s in val:
+        for line in labs:
+            cls_val[int(line.split()[0])] += 1
+    log("[stats] per-class instance counts")
+    for i, n in enumerate(TARGET_CLASS_NAMES):
+        log(f"        {i} {n:13s}  train={cls_train[i]:6d}  val={cls_val[i]:6d}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())