#!/usr/bin/env -S uv run --script # /// script # requires-python = ">=3.10" # dependencies = [ # "falcon-perception>=1.0.0", # "datasets>=4.5.0", # "huggingface-hub>=1.12.0", # "pillow", # ] # /// """Zero-shot object detection + instance segmentation -> a YOLO detection dataset. Falcon-Perception finds every instance of a class you name, with no training and no label set. Output is a detection dataset in `yolo` format, so it feeds the other recipes in this directory directly: validate-hf-dataset.py you/first-pass --bbox-format yolo stats-hf-dataset.py you/first-pass --bbox-format yolo convert-hf-dataset.py you/first-pass you/for-review --from yolo --to label_studio # ... a human corrects the first pass in Label Studio ... diff-hf-datasets.py you/first-pass you/corrected # IoU -> zero-shot accuracy RUNS ON YOUR LAPTOP TOO. Unusually for this repo no CUDA GPU is required: on Apple Silicon it selects the MLX backend automatically. Slower (~6 s/img vs ~0.4 on an A10G), which is fine for the step that matters locally -- checking your class name works on your images before spending GPU hours on the corpus. # 1. does the model do the thing? uv run falcon-perception.py --image page.jpg --query illustration --preview # 2. does it work on MY data? (first rows of the real corpus) uv run falcon-perception.py --dataset biglam/british-library-book-images \ --config plates --limit 3 --preview # 3. the whole corpus, on a GPU hf jobs uv run --flavor a10g-large --secrets HF_TOKEN \ https://huggingface.co/datasets/uv-scripts/object-detection/raw/main/falcon-perception.py \ --dataset biglam/british-library-book-images --config plates \ --id-col fname --query illustration --out you/plates-illustrations Output goes wherever --out points: --out you/plates-illustrations a Hub dataset (yolo format, feeds the scripts above) --out results.json a local JSON file -- no Hub push --out results.jsonl a local JSONL file -- one record per line --out results.parquet a local parquet file --json also print the records on stdout, for piping (omit --out) print a summary and, with --preview, annotated JPEGs For images in a bucket rather than a dataset, see falcon-perception-bucket.py. MEASURED LIMITS -- not guesses; each one cost a failed run: * --query takes a CLASS NAME, never an instruction. "illustration" works; "the illustration, excluding captions" returns nothing at all. * ONE class per run. A combined query ("illustration, map, portrait") returned 6 instances where three single-class passes found 24, and emitted <|absence|> on the richest image. The output vocabulary has no class token either, so instances could not be attributed even if the counts held. N classes = N runs. * NO confidence scores -- the model has no score token. Two triage proxies are emitted instead: `rectangularity` (mask area / bbox area; measured 0.34-1.00, low = irregular, 1.00 = clean rectangular plate) and `area`. Sort review by rectangularity ascending and apply an area floor; the smallest box seen was 941 px^2 and was spurious. * torch.compile is OFF. Per-image dynamic shapes break Inductor ("ValueError: Exponent must be non-negative" after symbolic-shape recursion). * CUDA graphs are OFF by default. engine_config_for_gpu() sizes itself from the GPU and ignores host RAM; on the 15 GB-host-RAM flavors (t4-small, a10g-small -- both measured) the container is OOMKilled (exit 137) before one image is processed. Pick a flavor with >15 GB `ram` from `hf jobs hardware --json`, or pass --cudagraph knowingly. """ import argparse import glob as globlib import hashlib import io import itertools import json import os import pathlib import platform import sys import time def stable_id(key): """Deterministic int64 image_id from the source key. COCO-style consumers (transformers RT-DETR / D-FINE annotation prep) require an INTEGER image_id -- a string crashes them with "ValueError: too many dimensions 'str'". A content hash (not a running index) keeps ids identical across separate runs over the same source, so per-class runs merge on image_id cleanly. """ return int.from_bytes(hashlib.blake2b(str(key).encode(), digest_size=8).digest(), "big") >> 1 # ── backend / engine selection ────────────────────────────────────────────── # The MLX and torch APIs match parameter-for-parameter, but are NOT drop-in: # torch also needs setup_torch_config(), a compile= kwarg, and every batch tensor # moved with .to(device). Omitting the last fails deep inside # flex_attention.create_block_mask, nowhere near the actual cause. def pick_backend(requested): if requested != "auto": return requested return "mlx" if (sys.platform == "darwin" and platform.machine() == "arm64") else "torch" def guard_mlx_memory(frac=0.55): """MLX allocates from unified memory with NO default cap. An oversized image through the AnyUp upsampler exhausts system RAM and hangs the whole machine -- the process is never OOM-killed, because there is no separate GPU pool for the kernel to reclaim. Measured: 0.22 MP ran fine; 5.4 MP took down a 32 GiB Mac whose MLX default ceiling was 30.4 GiB. """ try: import mlx.core as mx total = os.sysconf("SC_PAGE_SIZE") * os.sysconf("SC_PHYS_PAGES") mx.set_memory_limit(int(total * frac)) print(f"mlx memory capped at {total * frac / 2**30:.1f} GiB", flush=True) except Exception as e: print(f"WARNING: could not cap MLX memory ({e}) -- a large image may hang this machine", flush=True) # ── sources: every source yields (key, PIL image) ─────────────────────────── def src_images(spec): from falcon_perception.data import load_image from PIL import Image if spec.startswith(("http://", "https://")): from urllib.parse import unquote yield unquote(spec.rsplit("/", 1)[-1])[:120], load_image(spec).convert("RGB") return paths = sorted(globlib.glob(spec)) if any(c in spec for c in "*?[") else [spec] if not paths: raise SystemExit(f"no files matched {spec!r}") for p in paths: yield os.path.basename(p), Image.open(p).convert("RGB") def src_dataset(repo, config, split, image_col, id_col): from datasets import load_dataset from PIL import Image ds = load_dataset(repo, config, split=split, streaming=True) for idx, row in enumerate(ds): im = row[image_col] if isinstance(im, dict) and "bytes" in im: im = Image.open(io.BytesIO(im["bytes"])) yield (str(row.get(id_col)) if id_col else str(idx)), im.convert("RGB") # ── helpers ───────────────────────────────────────────────────────────────── def pair_bboxes(raw): """[{x,y}, {h,w}, ...] -> [{x,y,h,w}, ...]. xy is the normalised CENTRE. Centre-not-corner is why the output is natively `yolo` -- and why a corner reading would put every box out of bounds. """ boxes, cur = [], {} for e in raw: if not isinstance(e, dict): continue cur.update(e) if all(k in cur for k in ("x", "y", "h", "w")): boxes.append(dict(cur)) cur = {} return boxes def fit(im, max_dim, backend): """Downscale BEFORE the preprocessor sees it -- on MLX the full-size intermediate is what exhausts memory.""" budget = max_dim if backend == "mlx" else max_dim * 2 if max(im.size) > budget: im = im.copy() im.thumbnail((budget, budget)) return im def save_preview(key, im, boxes, rles, out_dir): import numpy as np from PIL import Image, ImageDraw from pycocotools import mask as mask_utils os.makedirs(out_dir, exist_ok=True) W, H = im.size canvas = np.array(im.convert("RGB"), dtype=np.float32) for i, rle in enumerate(rles): m = rle if isinstance(rle.get("counts"), bytes) else {**rle, "counts": str(rle["counts"]).encode()} try: dec = mask_utils.decode(m).astype("uint8") except Exception: continue if dec.shape != (H, W): # mask is at model resolution -- NEAREST only dec = np.array(Image.fromarray(dec).resize((W, H), Image.NEAREST)) col = np.array([(255, 60, 60), (60, 160, 255), (80, 200, 120)][i % 3], dtype=np.float32) sel = dec > 0 canvas[sel] = canvas[sel] * 0.65 + col * 0.35 out = Image.fromarray(canvas.clip(0, 255).astype("uint8")) pen = ImageDraw.Draw(out) for b in boxes: cx, cy, bw, bh = b["x"] * W, b["y"] * H, b["w"] * W, b["h"] * H pen.rectangle([cx - bw / 2, cy - bh / 2, cx + bw / 2, cy + bh / 2], outline=(255, 220, 0), width=3) safe = "".join(c if c.isalnum() or c in "._-" else "_" for c in key)[:80] path = os.path.join(out_dir, f"{safe}.jpg") out.save(path) return path def batched(it, n): buf = [] for x in it: buf.append(x) if len(buf) == n: yield buf buf = [] if buf: yield buf SCRIPT_URL = "https://huggingface.co/datasets/uv-scripts/object-detection/raw/main/falcon-perception.py" def push_card(repo_id, query, counters): """Dataset card with the repo's canonical provenance stamp (see AGENTS.md).""" from huggingface_hub import DatasetCard on_jobs = os.environ.get("JOB_ID") is not None # set by HF Jobs in-container hw = os.environ.get("ACCELERATOR") or "" # e.g. "a10g-large"; empty on CPU origin = ( f"Produced on [Hugging Face Jobs](https://huggingface.co/docs/huggingface_hub/guides/jobs)" + (f" (`{hw}`)" if hw else "") ) if on_jobs else "Generated" tags = "\n".join(f"- {t}" for t in (["uv-script", "hf-jobs"] if on_jobs else ["uv-script"])) args_summary = " ".join(sys.argv[1:]) card = DatasetCard(f"""--- tags: {tags} --- # Zero-shot detection: `{query}` {counters["images"]} images, {counters["instances"]} instances. Labels are **zero-shot weak labels** from [Falcon-Perception](https://huggingface.co/tiiuae/Falcon-Perception) -- no human annotated anything, and recall against human truth is unmeasured. `objects.bbox` is `yolo` format (normalised centre x, y, w, h); `objects.category` is a `ClassLabel` named `{query}`; `objects.rectangularity` (mask area / box area) is the triage proxy -- the model emits no confidence scores. ## Reproduction {origin} with the [`falcon-perception.py`]({SCRIPT_URL}) recipe from [uv-scripts](https://huggingface.co/uv-scripts). Run it yourself: ```bash hf jobs uv run --flavor a10g-large --secrets HF_TOKEN \\ {SCRIPT_URL} \\ {args_summary} ``` """) try: card.push_to_hub(repo_id) except Exception as e: print(f"WARNING: could not push dataset card ({e})", flush=True) # ── the two generation paths ──────────────────────────────────────────────── def run_paged(model, tokenizer, items, prompt, args): """CUDA: TII's continuous-batching engine. ~0.4 s/img on an A10G.""" from falcon_perception.data import ImageProcessor from falcon_perception.paged_inference import ( PagedInferenceEngine, SamplingParams, Sequence, engine_config_for_gpu, ) cfg = engine_config_for_gpu(max_image_size=args.max_dim, dtype=model.dtype) print(f"paged config: {cfg}", flush=True) engine = PagedInferenceEngine( model, tokenizer, ImageProcessor(patch_size=16, merge_size=1), max_seq_length=8192, capture_cudagraph=args.cudagraph, **cfg, ) sp = SamplingParams( args.max_new_tokens, stop_token_ids=[tokenizer.eos_token_id, tokenizer.end_of_query_token_id], coord_dedup_threshold=0.01, ) for chunk in batched(items, args.chunk): chunk = [(k, fit(im, args.max_dim, "torch")) for k, im in chunk] seqs = [ Sequence(text=prompt, image=im, min_image_size=256, max_image_size=args.max_dim, request_idx=i, task=args.task) for i, (_, im) in enumerate(chunk) ] t0 = time.perf_counter() engine.generate(seqs, sampling_params=sp) dt = (time.perf_counter() - t0) / len(seqs) for (k, im), s in zip(chunk, seqs): yield k, im, s.output_aux, dt def run_batch(model, tokenizer, items, prompt, args, backend, max_seq_len): """MLX (and a torch fallback): the readable reference engine. ~6 s/img on an M1 Pro.""" if backend == "mlx": from falcon_perception.mlx.batch_inference import BatchInferenceEngine, process_batch_and_generate else: from falcon_perception.batch_inference import BatchInferenceEngine, process_batch_and_generate engine = BatchInferenceEngine(model, tokenizer) for chunk in batched(items, 1 if backend == "mlx" else args.chunk): chunk = [(k, fit(im, args.max_dim, backend)) for k, im in chunk] b = process_batch_and_generate( tokenizer, [(im, prompt) for _, im in chunk], max_length=max_seq_len, min_dimension=256, max_dimension=args.max_dim, ) if backend != "mlx": # torch needs every tensor on the model's device import torch b = {k2: (v.to(model.device) if torch.is_tensor(v) else v) for k2, v in b.items()} t0 = time.perf_counter() _, auxes = engine.generate( tokens=b["tokens"], pos_t=b["pos_t"], pos_hw=b["pos_hw"], pixel_values=b["pixel_values"], pixel_mask=b["pixel_mask"], max_new_tokens=args.max_new_tokens, temperature=0.0, task=args.task, ) dt = (time.perf_counter() - t0) / len(chunk) for (k, im), aux in zip(chunk, auxes): yield k, im, aux, dt # ── main ──────────────────────────────────────────────────────────────────── def main(): p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) s = p.add_mutually_exclusive_group(required=True) s.add_argument("--image", help="path, URL, or glob ('scans/*.jpg')") s.add_argument("--dataset", help="Hub dataset repo id (streamed)") p.add_argument("--config") p.add_argument("--split", default="train") p.add_argument("--image-col", default="image") p.add_argument("--id-col", default=None, help="stable id column; falls back to row index") p.add_argument("--query", required=True, help="a CLASS NAME, not an instruction") p.add_argument("--task", default="segmentation", choices=["segmentation", "detection"]) p.add_argument("--out", default=None, help="where results go. A path ending .json/.jsonl/.parquet writes that file " "locally; anything else is treated as a Hub dataset repo id. Omit for " "stdout + previews only.") p.add_argument("--json", action="store_true", help="also print the records as JSON on stdout (for piping / agents)") p.add_argument("--private", action="store_true") p.add_argument("--limit", type=int, default=None, help="3 for a sense check") p.add_argument("--preview", action="store_true", help="save annotated JPEGs") p.add_argument("--preview-dir", default="./falcon-preview") p.add_argument("--max-dim", type=int, default=1024) p.add_argument("--max-new-tokens", type=int, default=200) p.add_argument("--chunk", type=int, default=16) p.add_argument("--backend", default="auto", choices=["auto", "mlx", "torch"]) p.add_argument("--engine", default="auto", choices=["auto", "batch", "paged"]) p.add_argument("--cudagraph", action="store_true", help="opt IN -- can OOM the host on small flavors") p.add_argument("--mlx-mem-fraction", type=float, default=0.55) args = p.parse_args() backend = pick_backend(args.backend) if backend == "mlx": guard_mlx_memory(args.mlx_mem_fraction) use_paged = args.engine == "paged" or (args.engine == "auto" and backend == "torch") if use_paged and backend == "mlx": print("paged engine is CUDA-only -- using batch", flush=True) use_paged = False print(f"backend={backend} engine={'paged' if use_paged else 'batch'} query={args.query!r}", flush=True) from falcon_perception import PERCEPTION_MODEL_ID, build_prompt_for_task, load_and_prepare_model from pycocotools import mask as mask_utils kw = {} if backend == "torch": from falcon_perception import setup_torch_config setup_torch_config() kw = {"compile": False} # dynamic image shapes break Inductor t = time.perf_counter() model, tokenizer, model_args = load_and_prepare_model( hf_model_id=PERCEPTION_MODEL_ID, dtype="float16" if backend == "mlx" else "bfloat16", backend=backend, **kw, ) print(f"model loaded in {time.perf_counter() - t:.1f}s", flush=True) prompt = build_prompt_for_task(args.query, args.task) items = src_images(args.image) if args.image else src_dataset( args.dataset, args.config, args.split, args.image_col, args.id_col) if args.limit: # islice STOPS the iterator; a filter would keep streaming the whole corpus. items = itertools.islice(items, args.limit) gen = (run_paged(model, tokenizer, items, prompt, args) if use_paged else run_batch(model, tokenizer, items, prompt, args, backend, model_args.max_seq_len)) # Records are STREAMED, never accumulated: a whole-corpus run used to hold every # decoded PIL image in a list until the final push (~3-12 MB each -> tens of GB # RSS -> OOM-killed before anything was pushed). counters = {"images": 0, "instances": 0} json_rows = [] # populated only when --json; records here are image-free t0 = time.perf_counter() def iter_records(): for key, im, aux, dt in gen: W, H = im.size boxes = pair_bboxes(aux.bboxes_raw) rles = list(aux.masks_rle) bbox, area, rect = [], [], [] for i, b in enumerate(boxes): bbox.append([b["x"], b["y"], b["w"], b["h"]]) # yolo: cx, cy, w, h normalised a = b["w"] * b["h"] area.append(a) r = 0.0 if i < len(rles): # rectangularity -- the only triage signal available try: m = rles[i] if isinstance(m.get("counts"), str): m = {**m, "counts": m["counts"].encode()} # measure box area in the MASK's own frame (rle size), not the # fitted image's -- the two never match, and mixing frames skews r mh, mw = (m.get("size") or [H, W])[:2] r = min(float(mask_utils.area(m)) / max(a * mw * mh, 1.0), 1.0) except Exception: r = 0.0 rect.append(r) counters["images"] += 1 counters["instances"] += len(bbox) print(f"[{counters['images']}] {key[:55]:55s} {len(bbox):2d} inst {dt:.2f}s", flush=True) if args.preview: print(f" -> {save_preview(key, im, boxes, rles, args.preview_dir)}", flush=True) rec = { "image": im, "image_id": stable_id(key), "source_id": key, "width": W, "height": H, "objects": {"bbox": bbox, "category": [0] * len(bbox), "area": area, "rectangularity": rect}, "n_instances": len(bbox), "masks_rle": json.dumps([ {**m, "counts": m["counts"].decode() if isinstance(m.get("counts"), bytes) else m.get("counts")} for m in rles ]), } if args.json: json_rows.append(plain(rec)) yield rec def plain(r): # everything except the PIL image, which is not serialisable return {k: v for k, v in r.items() if k != "image"} hub_out = args.out and not args.out.endswith((".json", ".jsonl", ".parquet")) if hub_out: from datasets import ClassLabel, Dataset, Features, Image as ImageFeat, Sequence as SeqFeat, Value feats = Features({ "image": ImageFeat(), "image_id": Value("int64"), "source_id": Value("string"), "width": Value("int32"), "height": Value("int32"), # category is a ClassLabel named after the query, so the class name travels # with the dataset (viewer, trainers, id2label) instead of a bare 0. "objects": {"bbox": SeqFeat(SeqFeat(Value("float32"))), "category": SeqFeat(ClassLabel(names=[args.query])), "area": SeqFeat(Value("float32")), "rectangularity": SeqFeat(Value("float32"))}, "n_instances": Value("int32"), "masks_rle": Value("string"), }) # Stream through an ArrowWriter: accumulating records in RAM OOMs whole-corpus # runs, and the from_generator APIs pickle their callable, which this closure # (live generator, loaded model) cannot survive. The writer flushes to disk per # batch; from_file memory-maps the result back for the push. import tempfile from datasets.arrow_writer import ArrowWriter arrow_path = os.path.join(tempfile.mkdtemp(prefix="falcon-out-"), "data.arrow") with ArrowWriter(features=feats, path=arrow_path, writer_batch_size=100) as writer: for rec in iter_records(): writer.write(feats.encode_example(rec)) writer.finalize() ds = Dataset.from_file(arrow_path) ds.push_to_hub(args.out, private=args.private) push_card(args.out, args.query, counters) if args.json: print(json.dumps(json_rows, indent=2), flush=True) else: rows = [plain(r) for r in iter_records()] if args.json: print(json.dumps(rows, indent=2), flush=True) if args.out and args.out.endswith(".json"): pathlib.Path(args.out).write_text(json.dumps(rows, indent=2)) elif args.out and args.out.endswith(".jsonl"): pathlib.Path(args.out).write_text("".join(json.dumps(r) + "\n" for r in rows)) elif args.out: import pyarrow as pa import pyarrow.parquet as pq pq.write_table(pa.Table.from_pylist(rows), args.out, compression="zstd") wall = time.perf_counter() - t0 n = counters["images"] print(f"\n{n} images in {wall:.1f}s ({n / max(wall, 1e-9):.2f} img/s)", flush=True) if args.out: print(f"{counters['instances']} instances -> {args.out}", flush=True) if hub_out: print(f"\nNEXT: validate-hf-dataset.py {args.out} --bbox-format yolo", flush=True) main()