Upload inspect-detections.py with huggingface_hub

inspect-detections.py

@@ -0,0 +1,237 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = ["datasets>=4.0.0", "huggingface-hub", "pillow", "matplotlib"]
+# ///
+"""
+Local visual inspection for the output of qwen3vl-detect.py.
+
+Given an output dataset (produced by qwen3vl-detect.py) and optionally its
+source dataset (with ground-truth bboxes), renders side-by-side PNGs of
+predicted detections vs ground truth, one per row.
+
+Output: a /tmp/<slug>-viz/ directory of PNGs and a per-row text summary
+(detection counts, label histograms, bbox value ranges).
+
+Usage:
+    uv run inspect-detections.py OUTPUT_DATASET [--split SPLIT] [--source SOURCE_DATASET]
+
+If --source is provided, the script will also load the source dataset, pull
+ground-truth `objects` (bbox + category), auto-discover class names from the
+ClassLabel feature, and overlay GT boxes on a second panel for comparison.
+"""
+
+import argparse
+import json
+import os
+from collections import Counter
+
+import matplotlib.patches as mpatches
+import matplotlib.pyplot as plt
+from datasets import load_dataset
+
+
+def render_box(ax, x1, y1, x2, y2, color, lw=1.2, label=None, fontsize=7):
+    rect = mpatches.Rectangle(
+        (x1, y1), x2 - x1, y2 - y1, fill=False, edgecolor=color, linewidth=lw
+    )
+    ax.add_patch(rect)
+    if label:
+        ax.text(
+            x1,
+            y1,
+            label,
+            fontsize=fontsize,
+            color="white",
+            bbox=dict(
+                boxstyle="round,pad=0.15",
+                facecolor=color,
+                alpha=0.75,
+                edgecolor="none",
+            ),
+            va="bottom",
+            ha="left",
+        )
+
+
+def discover_class_names(ds) -> list[str]:
+    """Pull class names from an `objects.category` or `objects.category_id`
+    ClassLabel feature on a HF dataset. Returns [] if not found."""
+    feats = ds.features
+    if "objects" not in feats:
+        return []
+    obj_feat = feats["objects"]
+    # objects may be List[Dict[...]] or Sequence(Dict[...]) — both expose `feature`
+    inner = getattr(obj_feat, "feature", None) or obj_feat
+    if not hasattr(inner, "keys"):
+        return []
+    for key in ("category", "category_id"):
+        if key in inner:
+            cat_feat = inner[key]
+            # Sequence(ClassLabel) or ClassLabel
+            cl = getattr(cat_feat, "feature", None) or cat_feat
+            names = getattr(cl, "names", None)
+            if names:
+                return list(names)
+    return []
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Render Qwen3-VL detection output side-by-side with ground truth."
+    )
+    parser.add_argument("output_dataset", help="HF dataset ID with detections column")
+    parser.add_argument(
+        "--split", default="train", help="Split of output_dataset (default: train)"
+    )
+    parser.add_argument(
+        "--source",
+        default=None,
+        help="Optional source dataset with ground-truth `objects` for GT overlay panel.",
+    )
+    parser.add_argument(
+        "--source-split", default=None, help="Split of source dataset (default: same as --split)"
+    )
+    parser.add_argument(
+        "--max-rows", type=int, default=None, help="Render only the first N rows"
+    )
+    parser.add_argument(
+        "--out-dir",
+        default=None,
+        help="Output directory (default: /tmp/<output-slug>-viz/)",
+    )
+    args = parser.parse_args()
+
+    slug = args.output_dataset.split("/")[-1]
+    out_dir = args.out_dir or f"/tmp/{slug}-viz"
+    os.makedirs(out_dir, exist_ok=True)
+
+    print(f"Loading {args.output_dataset} split={args.split}…")
+    ds = load_dataset(args.output_dataset, split=args.split)
+    if args.max_rows:
+        ds = ds.select(range(min(args.max_rows, len(ds))))
+    print(f"rows={len(ds)}  cols={ds.column_names}")
+
+    # qwen3vl-detect preserves the source `objects` column on each output row,
+    # so GT is co-located with detections (no shuffled-index join needed).
+    # The source dataset (if provided) is used only to recover ClassLabel names
+    # since push_to_hub strips the ClassLabel typing on round-trip.
+    gt_names: list[str] = []
+    if args.source:
+        gt_split = args.source_split or args.split
+        print(f"Loading source {args.source} split={gt_split} for class names…")
+        gt_src = load_dataset(args.source, split=gt_split)
+        gt_names = discover_class_names(gt_src)
+        print(f"GT classes ({len(gt_names)}): {gt_names}")
+    elif "objects" in ds.column_names:
+        gt_names = discover_class_names(ds)
+        if gt_names:
+            print(f"GT classes from output features: {gt_names}")
+
+    for i in range(len(ds)):
+        row = ds[i]
+        img = row["image"]
+        W, H = img.size
+        info = json.loads(row["inference_info"])
+        dets = row["detections"]
+
+        # GT extraction from the output row itself (qwen3vl-detect preserves
+        # all input columns including `objects`). Handles both list-of-dicts
+        # and dict-of-lists shapes.
+        gt_cats, gt_bbox = [], []
+        if "objects" in row and row["objects"] is not None:
+            objs = row["objects"]
+            if isinstance(objs, dict):
+                gt_cats = objs.get("category", objs.get("category_id", []))
+                gt_bbox = objs.get("bbox", [])
+            else:  # list of dicts
+                for o in objs:
+                    if "category" in o:
+                        gt_cats.append(o["category"])
+                    elif "category_id" in o:
+                        gt_cats.append(o["category_id"])
+                    gt_bbox.append(o["bbox"])
+
+        bbox_vals = [v for d in dets for v in d["bbox"]]
+        bbox_max = max(bbox_vals) if bbox_vals else 0
+        bbox_min = min(bbox_vals) if bbox_vals else 0
+        qwen_hist = Counter(d["label"] for d in dets)
+        gt_hist = Counter(
+            gt_names[c] if 0 <= c < len(gt_names) else f"#{c}" for c in gt_cats
+        ) if gt_names else Counter()
+
+        print(
+            f"\n=== row {i}  image_id={row.get('image_id', '?')}  orig={W}x{H}  "
+            f"inference_image_size={info['image_size']} ==="
+        )
+        if gt_cats:
+            print(f"  GT: {len(gt_cats)} objects  {dict(gt_hist)}")
+        print(f"  Qwen: {len(dets)} detections  {dict(qwen_hist)}")
+        print(f"  Qwen bbox range: [{bbox_min:.0f}, {bbox_max:.0f}]  (image {W}x{H})")
+
+        # Render
+        n_panels = 2 if gt_cats else 1
+        fig, axes = plt.subplots(1, n_panels, figsize=(10 * n_panels, 12))
+        if n_panels == 1:
+            axes = [axes]
+        for ax in axes:
+            ax.imshow(img)
+            ax.set_xlim(0, W)
+            ax.set_ylim(H, 0)
+            ax.set_aspect("equal")
+            ax.axis("off")
+
+        # v1.1+ output stores bbox in pixel coords; v1 stored 0-1000 normalised.
+        needs_denorm = bbox_max <= 1001 and max(W, H) > 1001
+        sx = (W / 1000.0) if needs_denorm else 1.0
+        sy = (H / 1000.0) if needs_denorm else 1.0
+        title_extra = "(0-1000 → pixels)" if needs_denorm else "(pixel coords)"
+
+        axes[0].set_title(
+            f"Detections (n={len(dets)}) {title_extra}  range [{bbox_min:.0f}, {bbox_max:.0f}]",
+            fontsize=11,
+        )
+        for d in dets:
+            b = d["bbox"]
+            if len(b) == 4:
+                render_box(axes[0], b[0] * sx, b[1] * sy, b[2] * sx, b[3] * sy, "#E03030", lw=1.0)
+        for d in dets[:10]:
+            b = d["bbox"]
+            if len(b) == 4:
+                render_box(
+                    axes[0],
+                    b[0] * sx,
+                    b[1] * sy,
+                    b[2] * sx,
+                    b[3] * sy,
+                    "#E03030",
+                    lw=1.4,
+                    label=d["label"][:18],
+                    fontsize=8,
+                )
+
+        if gt_cats and len(axes) > 1:
+            palette = [
+                "#1f78b4", "#33a02c", "#ff7f00", "#6a3d9a", "#b15928",
+                "#e31a1c", "#fb9a99", "#a6cee3", "#b2df8a", "#fdbf6f",
+                "#cab2d6", "#ffff99",
+            ]
+            color_by_name: dict[str, str] = {}
+            axes[1].set_title(f"Ground truth (n={len(gt_cats)})", fontsize=11)
+            for c, b in zip(gt_cats, gt_bbox):
+                if len(b) != 4:
+                    continue
+                name = gt_names[c] if 0 <= c < len(gt_names) else f"#{c}"
+                color = color_by_name.setdefault(name, palette[len(color_by_name) % len(palette)])
+                x, y, w_, h_ = b  # COCO xywh
+                render_box(axes[1], x, y, x + w_, y + h_, color, lw=2.0, label=name[:18], fontsize=8)
+
+        plt.tight_layout()
+        path = f"{out_dir}/row{i}_id{row.get('image_id', i)}.png"
+        plt.savefig(path, dpi=70, bbox_inches="tight")
+        plt.close()
+
+    print(f"\nDone. {len(ds)} rows. Open: {out_dir}")
+
+
+if __name__ == "__main__":
+    main()