Sync from GitHub via hub-sync

README.md

@@ -19,12 +19,14 @@ Instruction-prompted object detection with vision-language models via vLLM. Desi
 |---|---|---|---|
 | `sam3/` | Class names | bbox + score | Known categories, scale |
 | `vlm-object-detection/` | Free-form instruction | bbox + label + sub_label | Exploratory labelling, structured per-element labels |
+| `vlm-object-detection/wevisone-detect.py` | Class names | bbox + label + alt_labels | Known categories with a grounding VLM: small objects, dense pages |
 
 ## Scripts
 
 | Script | Status | Use |
 |---|---|---|
 | `qwen3vl-detect.py` | **Stable** | Standard zero-shot detection |
+| `wevisone-detect.py` | **New** | Class-list detection with [WeVisOne-VL](https://huggingface.co/tencent/WeVisOne-VL-4B), a 4B grounding model. Same output schema. See [Class-list detection](#class-list-detection-with-wevisone-vl) |
 | `qwen3vl-detect-fewshot.py` | **Experimental** | One-shot in-context example — pass an example image + its labelled output to demonstrate the task |
 | `inspect-detections.py` | **Utility** | Render a side-by-side PNG of model detections vs ground truth (when source has GT) for each row of an output dataset. Used to generate all visual comparisons in this README. |
 
@@ -200,6 +202,49 @@ Or skip the dataset repo and mount a local folder directly — `-v ./example:/ex
 
 Pick an example that looks similar to your typical target page — the model anchors heavily to "what a page should look like."
 
+## Class-list detection with WeVisOne-VL
+
+`wevisone-detect.py` runs [`tencent/WeVisOne-VL-4B`](https://huggingface.co/tencent/WeVisOne-VL-4B) (or `-2B`), a Qwen3-VL model that WeChat Vision trained for grounding: open-vocabulary detection, referring, counting and pointing. You pass class names, not an instruction. It loads in stock vLLM, fits a 24 GB GPU, and writes the same `detections` column as `qwen3vl-detect.py`, so `inspect-detections.py` works on its output.
+
+Use it when you know your classes and care about finding every instance, including small objects and dense pages. Use `qwen3vl-detect.py` when you need a free-form instruction, descriptive `sub_label`s, or fine-grained labels.
+
+```bash
+hf jobs uv run \
+  https://huggingface.co/datasets/uv-scripts/vlm-object-detection/raw/main/wevisone-detect.py \
+  rishitdagli/cppe-5 your-username/cppe5-wevisone \
+  --classes "Coverall,Face_Shield,Gloves,Goggles,Mask" \
+  --split test --max-samples 20 --shuffle
+```
+
+The script header supplies the image (`vllm/vllm-openai:v0.32.0`), the flavor (`a10g-small`) and the `HF_TOKEN` secret. A 20-image run takes about 4 minutes end to end, almost all of it model load; generating the 20 answers takes a few seconds.
+
+**Smoke results** (about 20 images per dataset, a box counts when IoU ≥ 0.5 with a ground-truth box, one-to-one matching). Qwen3.6 is `qwen3vl-detect.py` with `Qwen/Qwen3.6-35B-A3B` and a prompt listing the same classes.
+
+| Dataset (images, GT boxes) | Qwen3.6 box P / R | WeVisOne box P / R | WeVisOne `--merge-duplicates` box P / R | Label recall: Qwen3.6 / WeVisOne / merged |
+|---|---|---|---|---|
+| [Beyond Words](https://huggingface.co/datasets/biglam/loc_beyond_words) newspaper pages (20, 284) | 0.15 / 0.15 | 0.18 / **0.26** | 0.30 / 0.26 | 0.13 / **0.24** / 0.22 |
+| [CPPE-5](https://huggingface.co/datasets/rishitdagli/cppe-5) medical PPE (20, 111) | **0.85** / 0.93 | 0.79 / 0.93 | 0.84 / 0.93 | 0.91 / **0.92** / 0.86 |
+| [ENA24](https://huggingface.co/datasets/davanstrien/ena24-detection) camera traps, 23 species (20, 20) | **1.00 / 1.00** | 0.47 / 0.90 | 0.90 / 0.90 | **0.80** / 0.75 / 0.30 |
+| [Cigarette litter](https://huggingface.co/datasets/lojony/cigarette-litter-street-photos) street photos, validation (19, 43) | 1.00 / 0.79 | 1.00 / **0.88** | 1.00 / 0.88 | 0.79 / **0.88** / 0.88 |
+| [Mixed-traffic dashcam](https://huggingface.co/datasets/jasleen2737/vehicle-mixed-traffic-detection) frames, val (20, 71) | **0.57 / 0.70** | 0.28 / 0.68 | 0.37 / 0.68 | **0.66** / 0.55 / 0.49 |
+
+Box P / R ignore the label; label recall also requires the right class. The cigarette set's `maybe` boxes are ignored (not scored either way). With 20 images and 20–284 ground-truth boxes, a change of one to three boxes moves a number by up to 15 points, so treat small gaps as noise. Two identical ENA24 runs gave WeVisOne label recall of 0.65 and 0.75 (vLLM output is not bit-for-bit reproducible across runs).
+
+- The **cigarette litter** and **dashcam traffic** datasets were uploaded to the Hub in November 2026, after WeVisOne-VL's release (22 October), so they are unlikely to be in its training data.
+- The traffic and Beyond Words ground truth is incomplete: both models find road users and pictures that annotators did not box, so precision is understated for both.
+
+**Behaviour to know about**
+
+- **One object, several classes.** The model answers each class on its own, so a fox can come back as Red Fox, Grey Fox and Coyote. Every box is kept, and each box's `alt_labels` lists the other classes given to the same region (IoU ≥ `--duplicate-iou`, default 0.8). A reviewer sees the ambiguity; nothing is thrown away. The cost is box precision on multi-class lists: each extra class name is an extra box (ENA24 0.47, dashcam 0.28 in the table).
+- **`--merge-duplicates`** folds overlapping boxes of different classes into one box, labelled with the class that comes first in `--classes`. There are no scores to choose by, so this only helps when your class order is a real priority. With an arbitrary order it hurts labels: ENA24 species recall fell from 0.75 to 0.30. Before using the output as training data, merge here or dedupe downstream after review.
+- **No confidence scores.** Absent classes come back as `<box>none</box>` and are skipped.
+- **Whole-page boxes.** On some newspaper pages the model adds one box around the entire page. Filter by box area if that matters for your data.
+- **Image size.** Images are resized to at most about 2 MP (`--max-image-tokens 2025`, the release default). Tiny objects in large photos still came through (cigarette ends in 4000×1800 street photos).
+- **Class names** go into the prompt as plain phrases (`Face_Shield` is sent as "Face Shield"); the output `label` is the name exactly as you passed it. The prompt separates classes with ". ", so names cannot contain `.` or `,` (the script stops early if they do). Plain names work better than coded group names: for the traffic set, ask for "motorcycle, scooter, bicycle" and map them to "2-wheeler" afterwards.
+- **Licence.** The WeVisOne-VL weights and code are Apache-2.0.
+
 ## Acknowledgements
 
 Adapted from the [`Qwen/Object-Detection-with-Qwen`](https://modelscope.cn/studios/Qwen/Object-Detection-with-Qwen) demo on ModelScope. The Qwen-VL family is from Alibaba's Qwen team; weights are available on Hugging Face under apache-2.0.
+
+`wevisone-detect.py` uses [WeVisOne-VL](https://github.com/Tencent/WeVisOne-VL) from WeChat Vision, Tencent (Apache-2.0); its prompt template and answer parser follow that repository.

wevisone-detect.py

@@ -0,0 +1,704 @@
+# /// script
+# requires-python = ">=3.11"
+# dependencies = [
+#     "datasets>=4.0.0",
+#     "huggingface-hub",
+#     "pillow",
+#     "toolz",
+#     "tqdm",
+# ]
+#
+# [tool.hf-jobs]
+# # vllm, torch and transformers come from the image (PYTHONPATH). Do not list them above: uv
+# # would install the newest PyPI vllm deps next to the image's vllm and break it.
+# image = "vllm/vllm-openai:v0.32.0"
+# python = "/usr/bin/python3"
+# env = { PYTHONPATH = "/usr/local/lib/python3.12/dist-packages" }
+# flavor = "a10g-small"
+# secrets = ["HF_TOKEN"]
+# timeout = "1h"
+# ///
+
+"""
+Class-list object detection with WeVisOne-VL via vLLM.
+
+Give it an image dataset and a list of class names; it returns boxes for every
+instance of every class and pushes the dataset back to the Hub with a
+`detections` column in the same shape as qwen3vl-detect.py, so
+inspect-detections.py and the downstream labelling steps work unchanged.
+
+WeVisOne-VL (tencent/WeVisOne-VL-4B and -2B, Apache-2.0) is a Qwen3-VL model
+trained for grounding: open-vocabulary detection, referring, counting and
+pointing. It loads in stock vLLM. Use it when you know your classes; use
+qwen3vl-detect.py when you want a free-form instruction and descriptive
+sub-labels.
+
+Example (Hugging Face Jobs; the header above supplies image, flavor and secrets):
+
+    hf jobs uv run \\
+        https://huggingface.co/datasets/uv-scripts/vlm-object-detection/raw/main/wevisone-detect.py \\
+        rishitdagli/cppe-5 your-username/cppe5-wevisone \\
+        --classes "Coverall,Face_Shield,Gloves,Goggles,Mask" \\
+        --split test --max-samples 20 --shuffle
+
+Measured behaviour (20-image smokes, IoU >= 0.5 against ground truth):
+
+  * The model answers each class on its own, so one object can come back under
+    several classes (a fox as Red Fox, Grey Fox and Coyote). Every box is kept;
+    each box's `alt_labels` lists the other classes given to the same region
+    (IoU >= --duplicate-iou), so a reviewer sees the ambiguity.
+  * Keeping every box costs box precision on multi-class lists: each extra class
+    name on the same object is an extra box (ENA24: 0.47 vs 0.90 merged).
+    --merge-duplicates folds overlapping boxes of different classes into one box,
+    labelled with the class listed first in --classes (there are no scores to
+    choose by). Labels get worse when that order is arbitrary: ENA24 species
+    recall fell from 0.75 to 0.30. Merge for coarse or priority-ordered classes,
+    or dedupe downstream before using the boxes as training data.
+  * Class names go into the prompt as plain phrases ("Face_Shield" is sent as
+    "Face Shield"); the output label is the name exactly as you passed it. The
+    prompt separates classes with ". ", so names cannot contain "." or ",".
+  * There are no confidence scores.
+  * Compared with qwen3vl-detect.py on Qwen3.6-35B-A3B: higher box recall on small
+    objects and dense pages (cigarette ends 0.88 vs 0.79, newspaper pages 0.26 vs
+    0.15), similar box recall elsewhere, lower box precision by default (see
+    above), and slightly weaker fine-grained labels (ENA24 species recall 0.75 vs 0.80).
+"""
+
+import argparse
+import io
+import json
+import logging
+import os
+import re
+import shlex
+import sys
+from datetime import datetime
+from typing import Any
+
+from datasets import Dataset, Features, List, Value, concatenate_datasets, load_dataset
+from datasets import Image as ImageFeature
+from huggingface_hub import DatasetCard, login
+from PIL import Image
+from toolz import partition_all
+from tqdm.auto import tqdm
+
+logging.basicConfig(
+    level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+DEFAULT_MODEL = "tencent/WeVisOne-VL-4B"
+SCRIPT_URL = "https://huggingface.co/datasets/uv-scripts/vlm-object-detection/raw/main/wevisone-detect.py"
+# The released checkpoint's own system prompt and detection template
+# (wevisone_vl/engine.py and wevisone_vl/prompts.py in Tencent/WeVisOne-VL).
+SYSTEM_PROMPT = "You are a helpful assistant."
+# Answers look like <ref>cat</ref><box><12><40><380><990>,<500><42><880><991></box>; coordinates
+# are bins on a 0-1000 grid. A truncated answer may lose its closing tag. Absent classes come back
+# as <box>none</box>, which yields no boxes. Follows evaluation/utils/parser.py in the same repo,
+# except that the next <ref> is a lookahead, so an answer missing a closing tag does not swallow
+# the following class.
+REF_RE = re.compile(
+    r"<ref>(.*?)</ref>\s*<(box|point|polygon)>(.*?)(?:</(?:box|point|polygon)>|(?=<ref>)|$)",
+    re.DOTALL,
+)
+BIN_RE = re.compile(r"<(\d+)>")
+
+DETECTION_FEATURES = Features(
+    {
+        "detections": List(
+            {
+                "bbox": List(Value("int64")),
+                "label": Value("string"),
+                "sub_label": Value("string"),
+                "alt_labels": List(Value("string")),
+            }
+        ),
+        "raw_response": Value("string"),
+        "inference_info": Value("string"),
+    }
+)
+
+
+def build_prompt(prompt_names: list[str]) -> str:
+    """WeVisOne's detection instruction: class phrases joined by '. '."""
+    return (
+        "Locate all the instances that match the following description: "
+        + ". ".join(prompt_names)
+        + "."
+    )
+
+
+def to_pil(image: Image.Image | dict | str | None) -> Image.Image | None:
+    """Convert HF dataset image entries (PIL / dict-with-bytes / path) to PIL; None stays None."""
+    if image is None:
+        return None
+    if isinstance(image, Image.Image):
+        return image
+    if isinstance(image, dict) and image.get("bytes"):
+        return Image.open(io.BytesIO(image["bytes"]))
+    if isinstance(image, dict) and image.get("path"):
+        return Image.open(image["path"])
+    if isinstance(image, str):
+        return Image.open(image)
+    raise ValueError(f"Unsupported image type: {type(image)}")
+
+
+def parse_detections(
+    text: str, width: int, height: int, label_for: dict[str, str]
+) -> list[dict]:
+    """Parse <ref>label</ref><box>...</box> answers into pixel-space xyxy boxes."""
+    text = text.split("<|im_end|>")[0]
+    detections = []
+    for phrase, shape, body in REF_RE.findall(text):
+        if shape != "box":
+            continue
+        phrase = phrase.strip().rstrip(".").strip()
+        label = label_for.get(phrase.lower(), phrase)
+        for segment in body.strip().rstrip(",").split(","):
+            values = [int(v) for v in BIN_RE.findall(segment)]
+            for k in range(0, len(values) - 3, 4):
+                x1, y1, x2, y2 = values[k : k + 4]
+                if x2 <= x1 or y2 <= y1:
+                    continue
+                box = [
+                    max(0, min(width, round(x1 / 1000 * width))),
+                    max(0, min(height, round(y1 / 1000 * height))),
+                    max(0, min(width, round(x2 / 1000 * width))),
+                    max(0, min(height, round(y2 / 1000 * height))),
+                ]
+                if box[2] <= box[0] or box[3] <= box[1]:
+                    continue  # collapsed to zero width or height after scaling/clamping
+                detections.append(
+                    {"bbox": box, "label": label, "sub_label": "", "alt_labels": []}
+                )
+    return detections
+
+
+def box_iou(a: list[int], b: list[int]) -> float:
+    inter_w = max(0, min(a[2], b[2]) - max(a[0], b[0]))
+    inter_h = max(0, min(a[3], b[3]) - max(a[1], b[1]))
+    inter = inter_w * inter_h
+    union = (a[2] - a[0]) * (a[3] - a[1]) + (b[2] - b[0]) * (b[3] - b[1]) - inter
+    return inter / union if union > 0 else 0.0
+
+
+def annotate_cross_class_duplicates(detections: list[dict], threshold: float) -> int:
+    """Fill each box's `alt_labels` with the other classes the model gave the same region.
+
+    Two boxes are the same region when their IoU is >= threshold. Every box is kept.
+    Returns the number of boxes with at least one alternative label.
+    """
+    if threshold <= 0:
+        return 0
+    for box in detections:
+        for other in detections:
+            if (
+                other is not box
+                and other["label"] != box["label"]
+                and other["label"] not in box["alt_labels"]
+                and box_iou(box["bbox"], other["bbox"]) >= threshold
+            ):
+                box["alt_labels"].append(other["label"])
+    return sum(1 for box in detections if box["alt_labels"])
+
+
+def merge_cross_class_duplicates(
+    detections: list[dict], class_rank: dict[str, int], threshold: float
+) -> tuple[list[dict], int]:
+    """Merge boxes of different classes that overlap at IoU >= threshold.
+
+    The class that comes first in --classes keeps the box; the other labels are
+    recorded in `alt_labels`. Boxes of the same class are left alone.
+    Returns the kept detections and the number of boxes merged away.
+    """
+    if threshold <= 0:
+        return detections, 0
+    ordered = sorted(
+        detections, key=lambda d: class_rank.get(d["label"], len(class_rank))
+    )
+    kept: list[dict] = []
+    merged = 0
+    for detection in ordered:
+        duplicate = next(
+            (
+                k
+                for k in kept
+                if k["label"] != detection["label"]
+                and detection["label"] not in k["alt_labels"]
+                and box_iou(k["bbox"], detection["bbox"]) >= threshold
+            ),
+            None,
+        )
+        if duplicate is None:
+            kept.append(detection)
+        else:
+            duplicate["alt_labels"].append(detection["label"])
+            merged += 1
+    return kept, merged
+
+
+def jobs_flavor() -> str:
+    """Return the HF Jobs hardware flavor this run is on, or "" when it cannot be told.
+
+    HF Jobs sets ACCELERATOR to "cpu" or "gpu", not the flavor name, so the flavor is looked up
+    in the public Jobs hardware list: first by GPU model and count, then by the CPU_CORES and
+    MEMORY values that Jobs sets in the container (to tell a10g-small from a10g-large, or
+    cpu-basic from cpu-upgrade). Any failure (no network, older huggingface_hub) returns "".
+    """
+    hardware = os.environ.get("ACCELERATOR") or ""
+    if "-" in hardware or any(character.isdigit() for character in hardware):
+        return hardware  # already a flavor name
+    try:
+        from huggingface_hub import HfApi
+
+        gpu_name, gpu_count = "", 0
+        try:
+            import torch
+
+            if torch.cuda.is_available():
+                gpu_name = torch.cuda.get_device_name(0)
+                gpu_count = torch.cuda.device_count()
+        except ImportError:
+            pass
+        if gpu_count == 0 and hardware == "gpu":
+            return ""  # a GPU run whose GPU cannot be identified: do not guess a CPU flavor
+
+        # Whole-word match, so "L4" does not match "NVIDIA L40S" ("NVIDIA A100-SXM4-80GB" -> A100).
+        gpu_words = gpu_name.upper().replace("-", " ").split()
+        candidates = []
+        for flavor in HfApi(token=False).list_jobs_hardware():
+            accelerator = flavor.accelerator
+            if gpu_count == 0 and accelerator is None:
+                candidates.append(flavor)
+            elif (
+                gpu_count > 0
+                and accelerator is not None
+                and accelerator.model.upper() in gpu_words
+                and int(accelerator.quantity) == gpu_count
+            ):
+                candidates.append(flavor)
+        if not candidates:
+            return ""
+
+        cores = float(os.environ.get("CPU_CORES") or 0)
+        memory_gb = float((os.environ.get("MEMORY") or "0").upper().rstrip("GIB ") or 0)
+
+        def distance(flavor) -> float:
+            # Relative gap to the listed vCPUs and RAM; Jobs reports slightly different numbers.
+            listed_cores = float(flavor.cpu.split()[0])
+            listed_memory = float(flavor.ram.split()[0])
+            return (
+                abs(listed_cores - cores) / listed_cores
+                + abs(listed_memory - memory_gb) / listed_memory
+            )
+
+        return min(candidates, key=distance).name
+    except Exception:
+        return ""
+
+
+def push_card(
+    args: argparse.Namespace, classes: list[str], stats: dict[str, Any]
+) -> None:
+    """Replace the card body with one carrying the repo's canonical provenance stamp (AGENTS.md).
+
+    The README that push_to_hub wrote is loaded first so its dataset_info/configs metadata
+    is kept; only the tags are extended and the body replaced.
+    """
+    on_jobs = os.environ.get("JOB_ID") is not None  # set by HF Jobs in-container
+    hw = jobs_flavor()  # flavor name, e.g. "l4x1"; "" on CPU
+    origin = (
+        (
+            "Produced on [Hugging Face Jobs](https://huggingface.co/docs/huggingface_hub/guides/jobs)"
+            + (f" (`{hw}`)" if hw else "")
+        )
+        if on_jobs
+        else "Generated"
+    )
+    tags = (
+        ["uv-script", "hf-jobs", "object-detection"]
+        if on_jobs
+        else ["uv-script", "object-detection"]
+    )
+    card = DatasetCard.load(args.output_dataset, repo_type="dataset")
+    card.data["tags"] = sorted(set(card.data.get("tags") or []) | set(tags))
+    card.text = build_card_body(args, classes, stats, origin, hw)
+    card.push_to_hub(args.output_dataset)
+
+
+def build_reproduce_args(args: argparse.Namespace) -> str:
+    """Script arguments for the card's reproduce command. Never includes --hf-token."""
+    parts = [shlex.quote(args.input_dataset), "<output-dataset>"]
+    parts += ["--classes", shlex.quote(args.classes)]
+    if args.split != "train":
+        parts += ["--split", shlex.quote(args.split)]
+    if args.model != DEFAULT_MODEL:
+        parts += ["--model", shlex.quote(args.model)]
+    if args.image_column != "image":
+        parts += ["--image-column", shlex.quote(args.image_column)]
+    if args.max_samples:
+        parts += ["--max-samples", str(args.max_samples)]
+    if args.shuffle:
+        parts += ["--shuffle", "--seed", str(args.seed)]
+    if args.duplicate_iou != 0.8:
+        parts += ["--duplicate-iou", str(args.duplicate_iou)]
+    if args.merge_duplicates:
+        parts.append("--merge-duplicates")
+    if args.max_image_tokens != 2025:
+        parts += ["--max-image-tokens", str(args.max_image_tokens)]
+    if args.max_model_len != 8192:
+        parts += ["--max-model-len", str(args.max_model_len)]
+    if args.max_tokens != 4096:
+        parts += ["--max-tokens", str(args.max_tokens)]
+    if args.private:
+        parts.append("--private")
+    return " ".join(parts)
+
+
+def build_card_body(
+    args: argparse.Namespace,
+    classes: list[str],
+    stats: dict[str, Any],
+    origin: str,
+    hw: str,
+) -> str:
+    class_list = ", ".join(f"`{c}`" for c in classes)
+    if args.merge_duplicates:
+        duplicate_note = (
+            f"{stats['merged']} boxes were merged into a box of another class at IoU >= "
+            f"{args.duplicate_iou} (`--merge-duplicates`; the class listed first was kept)."
+        )
+    else:
+        duplicate_note = (
+            f"{stats['with_alt_labels']} boxes share their region with a box of another class "
+            "(see `alt_labels`)."
+        )
+    reproduce_args = build_reproduce_args(args)
+    return f"""
+# Class-list detection with WeVisOne-VL
+
+Boxes for {class_list} on `{args.input_dataset}` (split `{args.split}`), from
+[{args.model}](https://huggingface.co/{args.model}).
+{stats["rows"]} images, {stats["rows_with_detections"]} with at least one detection,
+{stats["detections"]} detections. {duplicate_note}
+
+These are **zero-shot labels**: no human checked them. Treat them as a first pass for review.
+
+## Columns added
+
+- `detections`: list of `{{bbox: [x1, y1, x2, y2], label, sub_label, alt_labels}}`. `bbox` is in
+  original-image pixels. `sub_label` is always empty (WeVisOne gives class labels only); it is
+  there so the schema matches `qwen3vl-detect.py`. `alt_labels` lists other classes the model
+  gave the same region (IoU >= {args.duplicate_iou}); WeVisOne answers each class on its own,
+  so one object can carry several class names.
+- `raw_response`: the model's raw answer, for re-parsing.
+- `inference_info`: JSON with the model, prompt, classes, image size and settings.
+
+## Reproduction
+
+{origin} with the [`wevisone-detect.py`]({SCRIPT_URL}) recipe from [uv-scripts](https://huggingface.co/uv-scripts). Run it yourself:
+
+```bash
+hf jobs uv run {f"--flavor {hw} " if hw else ""}{SCRIPT_URL} \\
+    {reproduce_args}
+```
+"""
+
+
+def main(args: argparse.Namespace) -> None:
+    classes = [c.strip() for c in args.classes.split(",") if c.strip()]
+    if not classes:
+        sys.exit(
+            "--classes is empty. Pass a comma-separated list, e.g. --classes 'cat,dog'."
+        )
+    with_period = [c for c in classes if "." in c]
+    if with_period:
+        sys.exit(
+            f"Class names cannot contain '.', which the prompt uses to separate classes: "
+            f"{with_period}. Rename them (e.g. 'St Bernard')."
+        )
+    if args.max_image_tokens + args.max_tokens + 256 > args.max_model_len:
+        sys.exit(
+            f"--max-image-tokens ({args.max_image_tokens}) + --max-tokens ({args.max_tokens}) "
+            f"does not fit in --max-model-len ({args.max_model_len}). Raise --max-model-len."
+        )
+    # A split slice such as 'train[:100]' loads fine but is not a valid name to push to.
+    output_split = args.split.split("[")[0]
+
+    import torch
+
+    if not torch.cuda.is_available():
+        sys.exit(
+            "CUDA is not available. This script needs a GPU (e.g. --flavor a10g-small)."
+        )
+    logger.info("GPU: %s", torch.cuda.get_device_name(0))
+    # The CUDA check above touches the driver in this process, so vLLM's engine process
+    # must be spawned, not forked ("Cannot re-initialize CUDA in forked subprocess").
+    os.environ.setdefault("VLLM_WORKER_MULTIPROC_METHOD", "spawn")
+
+    from transformers import AutoProcessor
+    from vllm import LLM, SamplingParams
+
+    if args.hf_token:  # HF_TOKEN in the environment is picked up without a login call
+        login(token=args.hf_token)
+
+    prompt_names = [c.replace("_", " ") for c in classes]
+    label_for = {p.lower(): c for p, c in zip(prompt_names, classes, strict=True)}
+    class_rank = {c: i for i, c in enumerate(classes)}
+    prompt = build_prompt(prompt_names)
+    logger.info("Prompt: %s", prompt)
+
+    logger.info("Loading dataset: %s (split=%s)", args.input_dataset, args.split)
+    dataset = load_dataset(args.input_dataset, split=args.split)
+    if args.image_column not in dataset.column_names:
+        sys.exit(
+            f"Column '{args.image_column}' not found. Columns: {dataset.column_names}"
+        )
+    if not isinstance(dataset.features[args.image_column], ImageFeature):
+        # Paths or URLs would be uploaded as plain strings and the pixels lost after the Job.
+        logger.info("Casting column '%s' to Image", args.image_column)
+        dataset = dataset.cast_column(args.image_column, ImageFeature())
+    clashes = {"detections", "raw_response", "inference_info"} & set(
+        dataset.column_names
+    )
+    if clashes:
+        logger.warning("Replacing existing column(s): %s", sorted(clashes))
+        dataset = dataset.remove_columns(sorted(clashes))
+    if args.shuffle:
+        dataset = dataset.shuffle(seed=args.seed)
+    if args.max_samples:
+        dataset = dataset.select(range(min(args.max_samples, len(dataset))))
+    logger.info("Rows to process: %d", len(dataset))
+
+    min_pixels = args.min_image_tokens * 32 * 32
+    max_pixels = args.max_image_tokens * 32 * 32
+    llm = LLM(
+        model=args.model,
+        limit_mm_per_prompt={"image": 1},
+        mm_processor_kwargs={"min_pixels": min_pixels, "max_pixels": max_pixels},
+        max_model_len=args.max_model_len,
+        max_num_seqs=args.batch_size,
+        gpu_memory_utilization=args.gpu_memory_utilization,
+    )
+    processor = AutoProcessor.from_pretrained(args.model)
+    # skip_special_tokens=False keeps the <ref>/<box>/<N> coordinate tokens in the text.
+    sampling_params = SamplingParams(
+        temperature=0.0,
+        max_tokens=args.max_tokens,
+        repetition_penalty=args.repetition_penalty,
+        skip_special_tokens=False,
+        stop=["<|im_end|>"],
+    )
+    chat_prompt = processor.apply_chat_template(
+        [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {
+                "role": "user",
+                "content": [{"type": "image"}, {"type": "text", "text": prompt}],
+            },
+        ],
+        tokenize=False,
+        add_generation_prompt=True,
+    )
+
+    all_detections: list[list[dict]] = []
+    all_raw: list[str] = []
+    all_info: list[str] = []
+    merged_total = 0
+    with_alt_total = 0
+    started = datetime.now()
+    for batch_indices in tqdm(
+        list(partition_all(args.batch_size, range(len(dataset)))),
+        desc="WeVisOne detection",
+    ):
+        images = []
+        for i in batch_indices:
+            image = to_pil(dataset[i][args.image_column])
+            images.append(image.convert("RGB") if image is not None else None)
+        requests = [
+            {"prompt": chat_prompt, "multi_modal_data": {"image": im}}
+            for im in images
+            if im is not None
+        ]
+        generated = iter(llm.generate(requests, sampling_params, use_tqdm=False))
+        for image in images:
+            if image is None:  # empty image cell: keep the row, with no detections
+                all_detections.append([])
+                all_raw.append("")
+                all_info.append(
+                    json.dumps(
+                        {
+                            "model_id": args.model,
+                            "image_size": None,
+                            "error": "missing image",
+                        }
+                    )
+                )
+                continue
+            output = next(generated)
+            text = output.outputs[0].text if output.outputs else ""
+            detections = parse_detections(text, image.width, image.height, label_for)
+            merged = 0
+            if args.merge_duplicates:
+                detections, merged = merge_cross_class_duplicates(
+                    detections, class_rank, args.duplicate_iou
+                )
+            with_alt = annotate_cross_class_duplicates(detections, args.duplicate_iou)
+            merged_total += merged
+            with_alt_total += with_alt
+            all_detections.append(detections)
+            all_raw.append(text)
+            all_info.append(
+                json.dumps(
+                    {
+                        "model_id": args.model,
+                        "prompt": prompt,
+                        "classes": classes,
+                        "image_size": [image.width, image.height],
+                        "min_pixels": min_pixels,
+                        "max_pixels": max_pixels,
+                        "duplicate_iou": args.duplicate_iou,
+                        "merge_duplicates": args.merge_duplicates,
+                        "merged_boxes": merged,
+                        "boxes_with_alt_labels": with_alt,
+                        "script": "wevisone-detect.py",
+                        "timestamp": datetime.now().isoformat(timespec="seconds"),
+                    }
+                )
+            )
+    elapsed_min = (datetime.now() - started).total_seconds() / 60
+    logger.info("Processed %d images in %.1f min", len(dataset), elapsed_min)
+
+    new_columns = Dataset.from_dict(
+        {
+            "detections": all_detections,
+            "raw_response": all_raw,
+            "inference_info": all_info,
+        },
+        features=DETECTION_FEATURES,
+    )
+    dataset = concatenate_datasets([dataset, new_columns], axis=1)
+
+    stats = {
+        "rows": len(all_detections),
+        "rows_with_detections": sum(1 for d in all_detections if d),
+        "detections": sum(len(d) for d in all_detections),
+        "merged": merged_total,
+        "with_alt_labels": with_alt_total,
+    }
+    logger.info("Pushing to %s", args.output_dataset)
+    dataset.push_to_hub(
+        args.output_dataset,
+        split=output_split,
+        private=args.private,
+        create_pr=args.create_pr,
+        commit_message=f"WeVisOne detection: {args.model} on {len(dataset)} rows",
+    )
+    if not args.create_pr:  # with --create-pr the card would land on main, not the PR
+        try:
+            push_card(args, classes, stats)
+        except Exception as e:
+            logger.warning("Could not push dataset card: %s", e)
+
+    logger.info(
+        "Done. Rows with >=1 detection: %d / %d. Detections: %d. "
+        "With alt_labels: %d. Merged: %d.",
+        stats["rows_with_detections"],
+        stats["rows"],
+        stats["detections"],
+        stats["with_alt_labels"],
+        stats["merged"],
+    )
+    logger.info("Output: https://huggingface.co/datasets/%s", args.output_dataset)
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Class-list object detection with WeVisOne-VL via vLLM.",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=__doc__,
+    )
+    parser.add_argument("input_dataset", help="Input dataset ID on the Hub")
+    parser.add_argument("output_dataset", help="Output dataset ID on the Hub")
+    parser.add_argument(
+        "--classes",
+        required=True,
+        help="Comma-separated class names (e.g. 'Coverall,Gloves,Mask'); names cannot contain ',' or '.'. "
+        "Order sets priority for --merge-duplicates",
+    )
+    parser.add_argument(
+        "--model", default=DEFAULT_MODEL, help=f"Model (default: {DEFAULT_MODEL})"
+    )
+    parser.add_argument(
+        "--image-column", default="image", help="Image column (default: image)"
+    )
+    parser.add_argument(
+        "--split", default="train", help="Dataset split (default: train)"
+    )
+    parser.add_argument(
+        "--max-samples", type=int, default=None, help="Cap rows processed"
+    )
+    parser.add_argument(
+        "--shuffle", action="store_true", help="Shuffle before --max-samples"
+    )
+    parser.add_argument(
+        "--seed", type=int, default=42, help="Shuffle seed (default: 42)"
+    )
+    parser.add_argument(
+        "--batch-size", type=int, default=32, help="Images per vLLM call (default: 32)"
+    )
+    parser.add_argument(
+        "--duplicate-iou",
+        type=float,
+        default=0.8,
+        help="IoU at which boxes of different classes count as one region; 0 disables "
+        "alt_labels and merging (default: 0.8)",
+    )
+    parser.add_argument(
+        "--merge-duplicates",
+        action="store_true",
+        help="Fold overlapping boxes of different classes into one box, labelled with the class "
+        "listed first in --classes (default: keep every box and fill alt_labels)",
+    )
+    parser.add_argument(
+        "--max-tokens", type=int, default=4096, help="Output cap (default: 4096)"
+    )
+    parser.add_argument(
+        "--max-model-len", type=int, default=8192, help="Context (default: 8192)"
+    )
+    parser.add_argument(
+        "--min-image-tokens",
+        type=int,
+        default=16,
+        help="Lower image-size bound in 32x32 patches (default: 16, the release default)",
+    )
+    parser.add_argument(
+        "--max-image-tokens",
+        type=int,
+        default=2025,
+        help="Upper image-size bound in 32x32 patches (default: 2025, about 2 MP, the release default)",
+    )
+    parser.add_argument(
+        "--gpu-memory-utilization",
+        type=float,
+        default=0.85,
+        help="vLLM GPU memory share (default: 0.85)",
+    )
+    parser.add_argument(
+        "--repetition-penalty",
+        type=float,
+        default=1.05,
+        help="Repetition penalty (default: 1.05)",
+    )
+    parser.add_argument("--hf-token", default=None, help="HF token (or set HF_TOKEN)")
+    parser.add_argument(
+        "--private", action="store_true", help="Make the output dataset private"
+    )
+    parser.add_argument(
+        "--create-pr", action="store_true", help="Push as a PR to the output repo"
+    )
+    return parser
+
+
+if __name__ == "__main__":
+    main(build_parser().parse_args())