Sync from GitHub via hub-sync

README.md

@@ -39,6 +39,10 @@ That's it! The script will:
 | `stats-hf-dataset.py` | Compute statistics (counts, label histogram, area, co-occurrence) |
 | `diff-hf-datasets.py` | Compare two datasets semantically (IoU-based annotation matching) |
 | `sample-hf-dataset.py` | Create subsets (random or stratified) and push to Hub |
+| `embed-bucket-images.py` | Join image bytes back into a bucket teacher pass — gold excluded + asserted, one final-schema write |
+| `materialize-coco.py` | Generate a canonical COCO 2017 directory tree from the parquet, in-job, on ephemeral disk |
+| `render-detections.py` | Render box/mask overlays and pixel-verify they actually drew (blank renders exit nonzero) |
+| `smoke-test.py` | Free local check (~30 s) that the plumbing chain (`embed-bucket-images.py` → `materialize-coco.py` → `render-detections.py`) still produces correct output — run before any job depends on it |
 
 ## Supported Bbox Formats
 

SKILL.md

@@ -10,17 +10,38 @@ Every step is a self-contained UV script from
 [`uv-scripts/object-detection`](https://huggingface.co/datasets/uv-scripts/object-detection) on the
 Hugging Face Hub, or a `hf jobs` command. `--help` works on every script.
 
+## Pick your path
+
+Five decisions cover most runs; each routes into the numbered steps below.
+
+1. **Where are the images?** Dataset repo → `falcon-perception.py`. Bucket → `falcon-perception-bucket.py`
+   (reads `.jpg`/`.jpeg`/`.png` only — convert JPEG 2000 / TIFF first).
+2. **Transport to the trainer**: build canonical `train.parquet` / `validation.parquet` with
+   `embed-bucket-images.py` (images embedded, gold excluded and asserted). Trainers that take HF
+   datasets read the parquet directly — including straight off a bucket; trainers that want a COCO
+   directory tree get one **generated in-job** with `materialize-coco.py` — onto a bucket mount if
+   more than one job will train on it (a complete tree is reused, not rebuilt). Never hand-assemble
+   or upload directory trees: a tree generated from the parquet cannot have missing-image
+   mismatches. Run `smoke-test.py` first (free, local, ~30 s): it proves these plumbing scripts
+   still produce correct output before a paid job depends on them.
+3. **Boxes or masks?** Boxes → the D-FINE default in step 5. Masks → an RF-DETR-Seg-style trainer via
+   `materialize-coco.py` (RLE masks carried through and resized from the teacher's inference frame to the
+   image frame).
+4. **Human available?** Show step-1 previews and do the step-6 gold slice. Headless → numeric proxies
+   and say **unreviewed**.
+5. **After the first student**: run the step-6 loop — student over the teacher-empty pages at a low
+   threshold, VLM pre-triage, retrain on the corrections.
+
 ## Check if a human in the loop
 
 You can use the approach outlined in this skill with or without a human in the loop.
 
 - **With a human in the loop** (better models): show them the step-1 previews — "is the teacher boxing
-  the right things?" is the highest-value question, and its fix is the cheapest (a better query, about $2 to
-  re-run the teacher). Then train on a small slice first (500–1k images, about $1) and show 20 rendered
+  the right things?" is the highest-value question, and its fix is the cheapest (a better query and a re-run of the teacher). Then train on a small slice first (500–1k images) and show 20 rendered
   predictions before spending on the full corpus. If corrections are worth collecting at volume, run a
   review pass with `review-detections.py` (keyboard accept/reject in the browser — quick mode for
   whole-image verdicts in random order with quotable rates, boxes mode for per-box rejects; pushes a
-  `review` column), fold corrections in and retrain (about $1). Diff the corrected set against the first pass (`diff-hf-datasets.py`) to measure how
+  `review` column), fold corrections in and retrain. Diff the corrected set against the first pass (`diff-hf-datasets.py`) to measure how
   good the zero-shot pass actually was.
 - **Autonomously** (headless): don't pause for review — use the numeric proxies, and say **unreviewed**
   in the final report and model card.
@@ -49,7 +70,9 @@ hf jobs uv run --flavor l4x1 --secrets HF_TOKEN \
 
 Judge the result before scaling up:
 - **If you can view images**, look at the rendered previews (or the pushed check dataset) — are the
-  right things boxed?
+  right things boxed? `render-detections.py` renders any dataset in this schema and **pixel-verifies
+  its own output** (a page with instances whose render equals the source exits nonzero — silent
+  blank-overlay bugs are real and have been shown to humans as "done").
 - **If you can't**, compare instance counts across candidate queries (`stats-hf-dataset.py` below works
   on a pushed check dataset): near-zero instances/image means the class name is wrong for this material —
   try a synonym (`photograph` / `illustration` / `figure` / `cartoon`). Suspiciously many (more than about 10/image)
@@ -77,6 +100,9 @@ hf jobs uv run --flavor a10g-large --secrets HF_TOKEN --timeout 2h \
   --dataset <USER>/<IMAGES> --query photograph --out <USER>/<NAME>-photograph --private
 ```
 
+- Sizing: expect a few images per second, not tens — the pass is decode-bound, so a bigger GPU
+  changes little; to go faster, shard the file list across several jobs writing to the same output
+  bucket. `--limit` on either script caps a run.
 - Flavor rule (all three failures measured): the engine needs a **24 GB-VRAM GPU** (16 GB T4s
   CUDA-OOM during prefill) and **more than 15 GB host RAM** (the engine sizes itself from the GPU
   and ignores host RAM, so `t4-small` and `a10g-small` are OOMKilled before the first image).
@@ -121,7 +147,8 @@ hf jobs uv run --flavor a10g-large --secrets HF_TOKEN --timeout 2h \
   switch (`hf jobs hardware` for alternatives), cancel the queued copy first (`hf jobs cancel <id>`).
 - For images in a [storage bucket](https://huggingface.co/docs/hub/storage-buckets) instead of a
   dataset, use `falcon-perception-bucket.py` — it writes resumable parquet parts back to a bucket
-  (kill and re-run the same command; done keys are skipped):
+  (kill and re-run the same command; done keys are skipped). It reads `.jpg` / `.jpeg` / `.png` only —
+  convert JPEG 2000 or TIFF scans first, or it will silently find zero images:
 
   ```
   hf jobs uv run --flavor a10g-large --secrets HF_TOKEN --timeout 2h --detach \
@@ -134,14 +161,26 @@ hf jobs uv run --flavor a10g-large --secrets HF_TOKEN --timeout 2h \
   bare ints; the cast attaches the class name):
 
   ```python
-  from datasets import ClassLabel, Sequence, load_dataset
+  from datasets import ClassLabel, Image, Sequence, load_dataset
   ds = load_dataset("parquet", data_files="hf://buckets/<namespace>/<out-bucket>/part-*.parquet",
                     split="train")
   feats = ds.features.copy()
   feats["objects"]["category"] = Sequence(ClassLabel(names=[ds[0]["query"]]))
+  if "image" in feats:  # parts written with --embed-images: make the bytes a decodable Image column
+      feats["image"] = Image()
   ds.cast(feats).push_to_hub("<namespace>/<dataset>")
   ```
 
+  The bucket path's output is **annotations-only** by default — there is no `image` column, and the
+  step-5 trainer and `review-detections.py` both need embedded images. `embed-bucket-images.py` (same
+  repo) joins the bytes back in, drops the teacher's error rows, excludes and asserts the gold slice,
+  splits train/validation, and writes the final schema exactly once — to a dataset repo, or as `train.parquet`/`validation.parquet`
+  in a bucket. (`--embed-images` on the teacher pass writes the bytes into the parts instead — storage
+  is cheap, and the join step then skips its re-fetch; the cost is a copy of the corpus in the output
+  bucket.) Trainers that want a COCO directory tree get one generated from that parquet by
+  `materialize-coco.py` — once, onto a bucket mount if several jobs will train on it — never
+  hand-assemble or upload directory trees.
+
 ## 3. Validate the labels (free, local)
 
 ```
@@ -151,8 +190,10 @@ uv run https://huggingface.co/datasets/uv-scripts/object-detection/raw/main/stat
   <USER>/<NAME>-photograph --bbox-format yolo
 ```
 
-Expect **VALID** with 0 out-of-bounds and 0 zero-area boxes. `W001` warnings on empty images are normal —
-they are true negatives (pages with no instance), and they are useful training signal; keep them.
+Expect **VALID** with 0 out-of-bounds and 0 zero-area boxes. `W001` warnings on empty images are normal
+and worth keeping as training signal — but treat them as **unverified negatives**: zero-shot teachers
+miss real instances on a meaningful fraction of "empty" pages (a third, on one measured corpus). The
+step-6 loop is how you find and flip them.
 Drop obvious junk before training: degenerate slivers (extreme aspect ratio + tiny area) and near-duplicate
 boxes (IoU > 0.9 within one image).
 
@@ -170,7 +211,7 @@ uv run https://huggingface.co/datasets/uv-scripts/object-detection/raw/main/conv
 A known-good default: fine-tune
 [`ustc-community/dfine-small-coco`](https://huggingface.co/ustc-community/dfine-small-coco)
 (D-FINE small, 10.4M params, Apache-2.0, in `transformers`) on the step-4 COCO dataset —
-800 images, 30 epochs, `t4-medium`, about 48 min and $0.35. Training needs only a T4:
+800 images, 30 epochs, `t4-medium`, about 48 minutes (`hf jobs hardware` shows current prices). Training needs only a T4:
 step 2's 24 GB-VRAM rule is the teacher's engine, not the student's.
 
 The [**`huggingface-vision-trainer`**](https://github.com/huggingface/skills/tree/main/skills/huggingface-vision-trainer)
@@ -178,7 +219,9 @@ skill runs the training end to end (dataset validation,
 augmentation, mAP eval, Hub persistence) — install it with `hf skills add huggingface-vision-trainer`
 if you don't have it, and follow its object-detection path with the `<USER>/<NAME>-coco` dataset and
 the settings above. Hold out the validation split — and the step-6 gold slice — BEFORE training,
-and never train on either.
+and never train on either. Write checkpoints **continuously to the synced `/data` mount**, not `/tmp`
+or a local output dir: Jobs can be SIGTERM'd at any time (node reclaim, requeue), anything outside the
+mount dies with the job, and durable checkpoints are also what make stopping at a plateau safe.
 
 Other trainers work — the dataset is plain COCO. [RT-DETRv2](https://huggingface.co/PekingU/rtdetr_v2_r18vd)
 is a comparable compact Apache-2.0 pick; [RF-DETR](https://github.com/roboflow/rf-detr) (Apache-2.0,
@@ -207,7 +250,10 @@ for rle in json.loads(row["masks_rle"]):
 - Report mAP on the held-out slice. Be clear about what it measures: **agreement with the teacher**,
   not accuracy against human truth — no human labels exist in this loop unless you make some (next
   bullet).
-- **Gold slice** (with a human in the loop): hold out about 100 random images BEFORE training, and have
+- **Gold slice** (with a human in the loop): hold out about 100 random images BEFORE training — keyed
+  on a **stable image id** that is identical in every dataset you build (path prefixes from different
+  runs silently break the match) — and **assert the exclusion** before submitting any training job:
+  train count = total − gold, overlap = 0. Then have
   the human verify every box on them with `review-detections.py --mode boxes --order random`, then
   correct any misses (the tool flags them with M; drawing the missing boxes is manual for now).
   Then report TWO numbers: mAP vs teacher labels AND mAP vs the human gold. They
@@ -226,12 +272,19 @@ for rle in json.loads(row["masks_rle"]):
   cannot view images, state prominently in the report that the model is **unreviewed**.
 - It can make sense to run this process in a loop: predict → review (a human, or a vision-capable
   agent, via `review-detections.py`) → retrain on the corrections → review again, until the acceptance
-  rate stops improving.
+  rate stops improving. Two things make the loop cheap: point the student at the **teacher-empty pages
+  at a low threshold** first (that is where the teacher's false negatives concentrate, and flipping
+  them from negative to positive is the biggest training-signal win), and **pre-triage candidates with
+  a VLM judge** (one crop per instance, mask highlighted) so the human only reviews the uncertain
+  residue rather than every candidate.
 
 ## 7. Publish with honest provenance
 
 Push the model and dataset — ask the user whether public or private; if you can't ask, default to
-private and say so. The cards must state: labels are **zero-shot weak labels** from Falcon-Perception
+private and say so. Build each dataset's **final schema in memory and push once** — never stage an
+intermediate push to the repo you will publish. A second push with different columns leaves the repo's
+stored features stale and `load_dataset` fails with a cast error; if the schema must change, push to a
+new repo id. The cards must state: labels are **zero-shot weak labels** from Falcon-Perception
 (name the script + date), which filters ran, and that **recall is unmeasured** unless you measured it
 against an independent source. Say what the model is for and what it was trained on. A model trained
 this way is a first pass. The review loop above is how it gets better.

embed-bucket-images.py

@@ -0,0 +1,233 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#   "datasets>=4.0",
+#   "huggingface_hub>=1.27",  # hf://buckets in HfFileSystem (1.6) + prefix-collision fix (1.27)
+#   "pillow",  # datasets encodes Image examples through PIL in the generator path
+#   "pyarrow>=18",
+# ]
+# ///
+"""Build the canonical training parquet from a bucket teacher pass -> ONE final-schema push.
+
+Takes the parquet parts that falcon-perception-bucket.py wrote, joins the image bytes back in
+from the source bucket (skipped when the parts already carry an `image` column, i.e. the teacher
+ran with --embed-images), excludes (and ASSERTS the exclusion of) a gold slice, splits
+train/validation, and writes everything in a single final-schema write -- either to a dataset
+repo (one push_to_hub, never a second) or as train.parquet / validation.parquet in a bucket for
+`materialize-coco.py` / direct `load_dataset` use.
+
+Image bytes are fetched in chunks through a dataset generator, so RAM stays bounded to one
+chunk (--chunk, default 256 images) however large the corpus is; the Arrow cache on disk holds
+the rest.
+
+    uv run embed-bucket-images.py \\
+      --parts "hf://buckets/<ns>/<teacher-out>/part-*.parquet" \\
+      --src <ns>/<source-bucket> \\
+      --gold <ns>/<gold-dataset> \\
+      --out <ns>/<training-dataset> --private
+
+    # bucket output instead of a dataset repo:
+    ... --out hf://buckets/<ns>/<training-bucket>/dataset
+
+    # local everything (smoke tests, a laptop-sized corpus): --src is a directory holding the
+    # keys as relative paths, --out an absolute or ./relative directory
+    ... --parts "./parts/part-*.parquet" --src ./pages --gold ./gold.parquet --out ./dataset
+
+Why this exists (both failure modes measured): the bucket path's output has no image column
+by default, so every agent hand-writes this join; and staging an intermediate push then
+re-pushing a different schema to the same repo id leaves stale repo features ->
+load_dataset CastError. This script builds the final schema in memory and writes exactly once.
+"""
+
+import argparse
+import subprocess
+import tempfile
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+import fsspec
+from datasets import ClassLabel, Dataset, DatasetDict, Image, Sequence, load_dataset
+
+
+def is_local_path(s):
+    # explicit prefixes only: a repo id like ns/name must never be mistaken for a directory
+    # that happens to exist in the cwd
+    return s.startswith(("/", "./", "../", "~"))
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    p.add_argument(
+        "--parts",
+        required=True,
+        help='parquet glob, e.g. "hf://buckets/ns/out/part-*.parquet" (or a local glob)',
+    )
+    p.add_argument(
+        "--src",
+        default=None,
+        help="source image bucket, e.g. ns/pages (keys = __source_key), or a local directory; "
+        "not needed when the parts already carry an image column",
+    )
+    p.add_argument(
+        "--out",
+        required=True,
+        help="dataset repo id, hf://buckets/... prefix, or a local directory for parquet files",
+    )
+    p.add_argument(
+        "--gold",
+        default=None,
+        help="gold dataset repo id (or parquet glob / local path) to exclude, by image_id",
+    )
+    p.add_argument("--val-frac", type=float, default=0.1)
+    p.add_argument("--seed", type=int, default=42)
+    p.add_argument(
+        "--limit", type=int, default=None, help="debug: cap rows AFTER gold exclusion"
+    )
+    p.add_argument(
+        "--keep-errors",
+        action="store_true",
+        help="keep rows whose teacher pass errored (dropped by default: they have no usable image)",
+    )
+    p.add_argument(
+        "--allow-gold-disjoint",
+        action="store_true",
+        help="permit a gold set that shares no image_id with this corpus (a genuinely different corpus)",
+    )
+    p.add_argument("--workers", type=int, default=16)
+    p.add_argument(
+        "--chunk", type=int, default=256, help="images fetched per generator chunk"
+    )
+    p.add_argument("--private", action="store_true")
+    args = p.parse_args()
+
+    try:
+        ds = load_dataset("parquet", data_files=args.parts, split="train")
+    except FileNotFoundError:
+        raise SystemExit(
+            f"no parquet files match {args.parts!r} — check the glob and bucket path"
+        )
+    total = len(ds)
+    if total == 0:
+        raise SystemExit(f"{args.parts!r} matched files but they contain 0 rows")
+    if args.src and args.src.startswith("hf://buckets/"):
+        args.src = args.src[len("hf://buckets/") :]
+    if (
+        not (args.out.startswith("hf://buckets/") or is_local_path(args.out))
+        and "/" not in args.out
+    ):
+        raise SystemExit(
+            f"--out {args.out!r}: a dataset repo id needs a namespace (ns/name)"
+        )
+    if "error" in ds.column_names and not args.keep_errors:
+        n_err = sum(1 for e in ds["error"] if e)
+        if n_err:
+            ds = ds.filter(lambda r: not r["error"])
+            print(f"dropped {n_err} teacher error rows (--keep-errors to keep them)")
+    if not isinstance(ds.features["objects"]["category"].feature, ClassLabel):
+        feats = ds.features.copy()
+        feats["objects"]["category"] = Sequence(ClassLabel(names=[ds[0]["query"]]))
+        ds = ds.cast(feats)
+
+    # ---- gold exclusion, asserted on the stable image_id (never on path-shaped keys) ----
+    if args.gold:
+        if "://" in args.gold or is_local_path(args.gold):
+            gold = load_dataset("parquet", data_files=args.gold, split="train")
+        else:
+            gold = load_dataset(args.gold, split="train")
+        gold_ids = set(gold["image_id"])
+        before = len(ds)
+        ds = ds.filter(lambda r: r["image_id"] not in gold_ids)
+        removed = before - len(ds)
+        overlap = gold_ids & set(ds["image_id"])
+        assert not overlap, (
+            f"gold exclusion FAILED: {len(overlap)} gold ids remain, e.g. {sorted(overlap)[:3]}"
+        )
+        if removed == 0 and gold_ids and not args.allow_gold_disjoint:
+            raise SystemExit(
+                "gold exclusion matched 0 rows — the gold set and this corpus share no image_id. "
+                "That usually means the ids were built from different key prefixes. If this corpus "
+                "really is disjoint from the gold set, pass --allow-gold-disjoint."
+            )
+        print(f"gold: excluded {removed} rows; {len(gold_ids)} gold ids, overlap now 0")
+
+    if args.limit:
+        ds = ds.select(range(min(args.limit, len(ds))))
+
+    # ---- join image bytes back in from the source (unless the parts already carry them) ----
+    if "image" in ds.column_names:
+        print(
+            "parts already carry an image column (teacher ran with --embed-images) — no fetch"
+        )
+        ds = ds.cast_column("image", Image())
+    else:
+        if not args.src:
+            raise SystemExit(
+                "parts have no image column — pass --src <bucket or local dir>"
+            )
+        src_dir = Path(args.src).expanduser() if is_local_path(args.src) else None
+
+        def fetch(key):
+            if src_dir is not None:
+                return (src_dir / key).read_bytes()
+            with fsspec.open(f"hf://buckets/{args.src}/{key}", "rb") as f:
+                return f.read()
+
+        plain = ds.with_format(None)
+        features = plain.features.copy()
+        features["image"] = Image()
+
+        def rows_with_images():
+            # one chunk of bytes in RAM at a time; datasets streams the yielded rows to
+            # its Arrow cache on disk, so corpus size never sets the RAM ceiling
+            for start in range(0, len(plain), args.chunk):
+                chunk = plain[start : start + args.chunk]  # dict of column -> list
+                keys = chunk["__source_key"]
+                with ThreadPoolExecutor(args.workers) as ex:
+                    blobs = list(ex.map(fetch, keys))
+                bad = [k for k, b in zip(keys, blobs) if not b]
+                assert not bad, f"{len(bad)} images fetched empty, e.g. {bad[:3]}"
+                for i, blob in enumerate(blobs):
+                    row = {col: chunk[col][i] for col in chunk}
+                    row["image"] = {"bytes": blob, "path": None}
+                    yield row
+
+        ds = Dataset.from_generator(rows_with_images, features=features)
+
+    # ---- split, then ONE write ----
+    if args.val_frac <= 0 or len(ds) < 2:
+        out = DatasetDict({"train": ds})
+        print(
+            f"rows: {total} read -> {len(ds)} kept -> train only (no validation split; "
+            "materialize-coco.py then needs --splits train)"
+        )
+    else:
+        parts = ds.train_test_split(test_size=args.val_frac, seed=args.seed)
+        out = DatasetDict({"train": parts["train"], "validation": parts["test"]})
+        print(
+            f"rows: {total} read -> {len(ds)} kept -> train {len(out['train'])} / validation {len(out['validation'])}"
+        )
+
+    if args.out.startswith("hf://buckets/"):
+        with tempfile.TemporaryDirectory() as td:
+            for split, d in out.items():
+                local = Path(td) / f"{split}.parquet"
+                d.to_parquet(local)
+                subprocess.run(
+                    ["hf", "cp", str(local), f"{args.out.rstrip('/')}/{split}.parquet"],
+                    check=True,
+                )
+        print(f"wrote {' + '.join(f'{s}.parquet' for s in out)} -> {args.out}")
+    elif is_local_path(args.out):
+        out_dir = Path(args.out).expanduser()
+        out_dir.mkdir(parents=True, exist_ok=True)
+        for split, d in out.items():
+            d.to_parquet(out_dir / f"{split}.parquet")
+        print(f"wrote {' + '.join(f'{s}.parquet' for s in out)} -> {out_dir}")
+    else:
+        out.push_to_hub(args.out, private=args.private)
+        print(f"pushed -> https://huggingface.co/datasets/{args.out}")
+
+
+if __name__ == "__main__":
+    main()

falcon-perception-bucket.py

@@ -4,7 +4,7 @@
 # dependencies = [
 #   "falcon-perception>=1.0.0",
 #   # tarball not git+: some GPU images have no `git` for uv to shell out to
-#   "bucketbag @ https://github.com/davanstrien/bucketbag/archive/refs/tags/v0.3.0.tar.gz",
+#   "bucketbag @ https://github.com/davanstrien/bucketbag/archive/refs/tags/v0.3.1.tar.gz",
 #   "pyarrow>=18",
 #   "pycocotools>=2.0.11",
 # ]
@@ -26,18 +26,22 @@ Output is parquet parts in a BUCKET, not a dataset repo — that is what makes t
 run resumable (`completed_keys` reads the done-set back from `__source_key`).
 To hand the result to the rest of this directory, publish it once at the end:
 
-    from datasets import ClassLabel, Sequence, load_dataset
+    from datasets import ClassLabel, Image, Sequence, load_dataset
     ds = load_dataset("parquet", data_files="hf://buckets/<namespace>/<bucket>/part-*.parquet",
                       split="train")
     feats = ds.features.copy()  # parquet stores category as bare ints; name the class
     feats["objects"]["category"] = Sequence(ClassLabel(names=[ds[0]["query"]]))
+    if "image" in feats:  # --embed-images parts: make the bytes a decodable Image column
+        feats["image"] = Image()
     ds.cast(feats).push_to_hub("<namespace>/<dataset>")  # a dataset repo, distinct from the bucket
 
     uv run validate-hf-dataset.py <namespace>/<dataset> --bbox-format yolo
 
-Note the parts carry `width`/`height` but no `image` column (the images stay in
-the source bucket), so pass --image-column accordingly if a downstream script
-wants to decode them.
+By default the parts carry `width`/`height` but no `image` column: the images stay in
+the source bucket, the parts stay small and resumable, and `embed-bucket-images.py`
+joins the bytes back in. Pass --embed-images to write the source bytes into each part
+instead (an `image` column datasets decodes directly) -- storage is cheap and it saves
+the join's re-fetch of every image; the cost is a copy of the corpus in the output bucket.
 
 GOTCHAS (all measured, none in the model card):
   * --query is a CLASS NAME. "illustration" works; "the illustration, excluding
@@ -56,6 +60,7 @@ import io
 import json
 import time
 
+import fsspec
 import pyarrow as pa
 import pyarrow.parquet as pq
 from bucketbag import batched_files, boost, completed_keys, iter_keys, put_files
@@ -102,11 +107,11 @@ def pair_bboxes(raw):
     return boxes
 
 
-def serialise(rows, fmt):
+def serialise(rows, fmt, schema=SCHEMA):
     if fmt == "jsonl":
         return "\n".join(json.dumps(r) for r in rows) + "\n"
     buf = io.BytesIO()
-    pq.write_table(pa.Table.from_pylist(rows, schema=SCHEMA), buf, compression="zstd")
+    pq.write_table(pa.Table.from_pylist(rows, schema=schema), buf, compression="zstd")
     return buf.getvalue()
 
 
@@ -121,11 +126,22 @@ def main():
     p.add_argument("--max-dim", type=int, default=1024)
     p.add_argument("--max-new-tokens", type=int, default=200)
     p.add_argument("--batch-n", type=int, default=32, help="files per bucketbag batch")
-    p.add_argument("--max-bytes", type=int, default=2 * 2**30)
+    p.add_argument("--max-bytes", type=int, default=None,
+                   help="scratch bytes per batch (RAM tmpfs). Default 2 GiB; 256 MiB with --embed-images, "
+                        "whose bytes are also held ~4x in host RAM while a part is serialised")
     p.add_argument("--cudagraph", action="store_true", help="opt IN; off by default (host OOM)")
     p.add_argument("--format", default="parquet", choices=["parquet", "jsonl"])
     p.add_argument("--no-resume", action="store_true")
+    p.add_argument("--embed-images", action="store_true",
+                   help="also write the source image bytes into each part (see docstring)")
     args = p.parse_args()
+    if args.embed_images and args.format == "jsonl":
+        raise SystemExit("--embed-images writes raw image bytes, which jsonl cannot carry; use --format parquet.")
+    if args.max_bytes is None:
+        args.max_bytes = 256 * 2**20 if args.embed_images else 2 * 2**30
+    schema = SCHEMA
+    if args.embed_images:
+        schema = SCHEMA.append(pa.field("image", pa.struct([("bytes", pa.binary()), ("path", pa.string())])))
 
     if args.format == "jsonl" and not args.no_resume:
         # completed_keys only reads the done-set back from .parquet parts, so jsonl
@@ -154,6 +170,20 @@ def main():
 
     done = set() if args.no_resume else completed_keys(args.out)
     print(f"{len(done)} keys already done", flush=True)
+    if done and args.format == "parquet":
+        # a resume must not mix part schemas: half the parts with an image column and half
+        # without loads as nulls downstream, and the null rows crash the trainer's tree build
+        first_part = next((f for f in iter_keys(args.out, prefix="part-", objects=True)
+                           if f.path.endswith(".parquet")), None)
+        if first_part is not None:
+            with fsspec.open(f"hf://buckets/{args.out}/{first_part.path}", "rb") as fh:
+                existing = pq.read_schema(fh)
+            if ("image" in existing.names) != args.embed_images:
+                raise SystemExit(
+                    f"existing parts in {args.out} were written "
+                    f"{'with' if 'image' in existing.names else 'without'} --embed-images; "
+                    "resume with the same flag, or write to a fresh --out bucket."
+                )
 
     # objects=True yields BucketFile (with .size), so max_bytes is honoured.
     # Needs bucketbag >= 0.3.0: before that, string keys made batched_files drop
@@ -166,7 +196,11 @@ def main():
         keys = keys[: args.limit]
     print(f"{len(keys)} keys to process", flush=True)
     if not keys:
-        return
+        raise SystemExit(
+            f"0 keys matched under {args.src}/{args.prefix or ''} — this script reads only "
+            ".jpg/.jpeg/.png (convert JPEG 2000 / TIFF first), and already-done keys are skipped "
+            "(pass --no-resume to redo)."
+        )
 
     from falcon_perception import PERCEPTION_MODEL_ID, build_prompt_for_task, load_and_prepare_model, setup_torch_config
     from falcon_perception.data import ImageProcessor
@@ -204,15 +238,16 @@ def main():
                 orig_size = img.size  # SOURCE dims -- the images downstream tools decode
                 if max(img.size) > args.max_dim * 2:
                     img.thumbnail((args.max_dim * 2, args.max_dim * 2))
-                pairs.append((str(it.key), img, orig_size))
+                raw = it.bytes if args.embed_images else None  # read before the batch is deleted
+                pairs.append((str(it.key), img, orig_size, raw))
             except Exception as e:
-                pairs.append((str(it.key), e, None))
+                pairs.append((str(it.key), e, None, None))
 
-        good = [(k, im, sz) for k, im, sz in pairs if not isinstance(im, Exception)]
+        good = [(k, im, sz, raw) for k, im, sz, raw in pairs if not isinstance(im, Exception)]
         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(good)
+            for i, (_, im, _, _) in enumerate(good)
         ]
         t0 = time.perf_counter()
         if seqs:
@@ -221,7 +256,7 @@ def main():
         gen_total += dt
 
         rows = []
-        for (key, im, orig_size), seq in zip(good, seqs):
+        for (key, im, orig_size, raw), seq in zip(good, seqs):
             aux = seq.output_aux
             boxes = pair_bboxes(aux.bboxes_raw)
             masks = list(aux.masks_rle)
@@ -249,14 +284,17 @@ def main():
                     except Exception:
                         r = 0.0
                 rect.append(r)
-            rows.append({
+            row = {
                 "__source_key": key, "image_id": stable_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(masks),
                 "query": args.query, "gen_seconds": dt / max(len(seqs), 1), "error": None,
-            })
-        for key, err, _ in [(k, v, s) for k, v, s in pairs if isinstance(v, Exception)]:
+            }
+            if args.embed_images:
+                row["image"] = {"bytes": raw, "path": None}
+            rows.append(row)
+        for key, err, _, _ in [t for t in pairs if isinstance(t[1], Exception)]:
             # a durable error row, never a gap — and it counts as done so it is
             # not retried forever on every re-run. objects is EMPTY, not null:
             # a null struct crashes validate-hf-dataset.py after publish.
@@ -271,9 +309,11 @@ def main():
         # counter restarts at 0 and put_files overwrites, silently destroying the first
         # run's parts. A content-derived name is stable per batch and collision-free
         # across resumes (a re-run of the same batch overwrites its own part, idempotent).
+        if not rows:  # bucketbag drops files that vanished between listing and download
+            continue
         ext = "jsonl" if args.format == "jsonl" else "parquet"
         part = hashlib.blake2b(rows[0]["__source_key"].encode(), digest_size=6).hexdigest()
-        put_files([(f"part-{part}.{ext}", serialise(rows, args.format))], args.out)
+        put_files([(f"part-{part}.{ext}", serialise(rows, args.format, schema))], args.out)
         n += len(rows); batch_i += 1
         rate = n / (time.perf_counter() - t_all)
         print(f"batch {batch_i}: {len(rows)} rows ({dt / max(len(seqs), 1):.2f}s/img)  "

materialize-coco.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#   "datasets>=4.0",
+#   "huggingface_hub>=1.27",  # hf://buckets in HfFileSystem (1.6) + prefix-collision fix (1.27)
+#   "pillow",
+#   "numpy",
+#   "pycocotools>=2.0.11",
+# ]
+# ///
+"""Materialize a COCO directory tree FROM the canonical parquet, in-job, on ephemeral disk.
+
+Some trainers (RF-DETR and friends) refuse HF datasets and demand the canonical COCO 2017
+layout: annotations/instances_train2017.json + train2017/*.jpg. Never hand-assemble or
+upload that tree -- generate it from the parquet with this script instead. A generated
+tree cannot reference images that are not there, which kills the referenced-vs-uploaded
+mismatch class outright (it caused three paid job failures in one measured run).
+
+    # inside the training job, before the trainer starts:
+    uv run materialize-coco.py --data hf://buckets/<ns>/<training-bucket>/dataset --out /tmp/coco
+
+    # or from a dataset repo produced by embed-bucket-images.py:
+    uv run materialize-coco.py --data <ns>/<training-dataset> --out /tmp/coco
+
+    # training more than once? generate ONCE onto a bucket mount and let later jobs reuse it:
+    #   hf jobs run ... -v hf://buckets/<ns>/<training-bucket>:/data ...
+    uv run materialize-coco.py --data /data/dataset --out /data/coco
+
+A split is reused, not regenerated, when its tree is complete AND was built from the same
+labels: the annotations file carries a fingerprint of (image ids, boxes), so a corrected
+dataset -- the step-6 loop, same images, new labels -- rebuilds automatically. --force rebuilds
+regardless. Rows whose image cannot be decoded (teacher error rows, truncated files) are skipped
+and counted, never allowed to kill the job.
+
+Boxes are converted yolo-normalized -> COCO xywh pixels (pass --bbox-format coco_xywh if your
+parquet already stores pixels). masks_rle, when present, is carried through as COCO RLE
+segmentation (RF-DETR-class trainers accept RLE natively).
+"""
+
+import argparse
+import hashlib
+import io
+import json
+import shutil
+from pathlib import Path
+
+import numpy as np
+from datasets import Image as HFImage
+from datasets import load_dataset
+from PIL import Image as PILImage
+from pycocotools import mask as mask_utils
+
+SPLIT_DIR = {"train": "train2017", "validation": "val2017"}
+
+
+def to_xywh(bbox, w, h, fmt):
+    if fmt == "coco_xywh":
+        return [float(v) for v in bbox]
+    cx, cy, bw, bh = bbox  # yolo normalised
+    return [(cx - bw / 2) * w, (cy - bh / 2) * h, bw * w, bh * h]
+
+
+def label_fingerprint(ds):
+    """Hash of (image_id, boxes) for every row -- changes when labels change, not when bytes do."""
+    labels = ds.select_columns(["image_id", "objects"]).with_format(None)
+    items = sorted(
+        (
+            int(row["image_id"]),
+            [[round(float(v), 6) for v in b] for b in row["objects"]["bbox"]],
+        )
+        for row in labels
+    )
+    return hashlib.sha1(json.dumps(items).encode()).hexdigest()
+
+
+def load_split(data, split):
+    if data.startswith("hf://"):
+        return load_dataset(
+            "parquet", data_files=f"{data.rstrip('/')}/{split}.parquet", split="train"
+        )
+    return load_dataset(data, split=split)
+
+
+def tree_is_reusable(jpath, img_dir, fingerprint):
+    if not jpath.exists():
+        return False, "no tree yet"
+    coco = json.loads(jpath.read_text())
+    stamped = coco.get("provenance", {}).get("fingerprint")
+    if stamped != fingerprint:
+        return False, "labels changed since the tree was built"
+    referenced = len(coco["images"])
+    present = len(list(img_dir.glob("*.jpg")))
+    if not referenced or referenced != present:
+        return False, f"tree incomplete ({present} files vs {referenced} referenced)"
+    return True, f"complete tree ({present} images), same labels"
+
+
+def decode_image(raw):
+    """raw is the undecoded {bytes, path} struct (or None for error rows)."""
+    if not raw or not raw.get("bytes"):
+        return None
+    try:
+        im = PILImage.open(io.BytesIO(raw["bytes"]))
+        im.load()
+        return im.convert("RGB")
+    except Exception:  # noqa: BLE001 -- any decode failure means "skip this row"
+        return None
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    p.add_argument(
+        "--data",
+        required=True,
+        help="dataset repo id, hf://buckets/... prefix, or local directory holding <split>.parquet",
+    )
+    p.add_argument(
+        "--out",
+        required=True,
+        help="output dir (ephemeral disk, or a bucket mount to reuse across jobs)",
+    )
+    p.add_argument("--bbox-format", default="yolo", choices=["yolo", "coco_xywh"])
+    p.add_argument("--splits", nargs="+", default=["train", "validation"])
+    p.add_argument(
+        "--force",
+        action="store_true",
+        help="rebuild a split even if its tree is complete",
+    )
+    args = p.parse_args()
+
+    out = Path(args.out)
+    (out / "annotations").mkdir(parents=True, exist_ok=True)
+
+    for split in args.splits:
+        ds = load_split(args.data, split)
+        assert "image" in ds.column_names, (
+            "no image column — run embed-bucket-images.py first"
+        )
+        img_dir = out / SPLIT_DIR.get(split, split)
+        jpath = out / "annotations" / f"instances_{SPLIT_DIR.get(split, split)}.json"
+
+        fingerprint = label_fingerprint(ds)
+        reusable, why = tree_is_reusable(jpath, img_dir, fingerprint)
+        if reusable and not args.force:
+            print(f"{split}: reusing {why} at {img_dir} — pass --force to rebuild")
+            continue
+        print(f"{split}: building ({'--force' if args.force else why})")
+        # a rebuild starts from nothing: stale JPEGs from an older tree would fail the
+        # files == referenced assert below after all the decode work
+        shutil.rmtree(img_dir, ignore_errors=True)
+        jpath.unlink(missing_ok=True)
+        img_dir.mkdir()
+
+        cat_feature = ds.features["objects"]["category"].feature
+        names = getattr(cat_feature, "names", None) or ["object"]
+
+        # undecoded bytes so a corrupt image is OUR decision to skip, not a crash inside datasets
+        rows = ds.cast_column("image", HFImage(decode=False)).with_format(None)
+        images, annotations, ann_id, skipped = [], [], 1, []
+        for row in rows:
+            iid = int(row["image_id"])
+            im = None if row.get("error") else decode_image(row["image"])
+            if im is None:
+                skipped.append(iid)
+                continue
+            fname = f"{iid}.jpg"
+            im.save(img_dir / fname, "JPEG", quality=95)
+            # dims from the DECODED image, never metadata columns: error rows carry
+            # width/height=None, and the saved JPEG is the frame everything must match
+            w, h = im.size
+            images.append({"id": iid, "file_name": fname, "width": w, "height": h})
+            rles = json.loads(row["masks_rle"]) if row.get("masks_rle") else []
+            for i, bbox in enumerate(row["objects"]["bbox"]):
+                x, y, bw, bh = to_xywh(bbox, w, h, args.bbox_format)
+                ann = {
+                    "id": ann_id,
+                    "image_id": iid,
+                    "category_id": int(row["objects"]["category"][i]) + 1,
+                    "bbox": [x, y, bw, bh],
+                    "area": bw * bh,
+                    "iscrowd": 0,
+                }
+                if i < len(rles):
+                    rle = rles[i]
+                    # masks live in the INFERENCE frame, which diverges from the image
+                    # frame whenever the teacher thumbnailed -- resize before writing
+                    if rle["size"] != [h, w]:
+                        seg = mask_utils.decode(
+                            {**rle, "counts": rle["counts"].encode()}
+                        )
+                        seg = np.asarray(
+                            PILImage.fromarray(seg).resize((w, h), PILImage.NEAREST)
+                        )
+                        enc = mask_utils.encode(np.asfortranarray(seg))
+                        rle = {"size": [h, w], "counts": enc["counts"].decode("ascii")}
+                    ann["segmentation"] = rle
+                annotations.append(ann)
+                ann_id += 1
+
+        coco = {
+            "images": images,
+            "annotations": annotations,
+            "categories": [{"id": i + 1, "name": n} for i, n in enumerate(names)],
+            "provenance": {
+                "source": args.data,
+                "fingerprint": fingerprint,
+                "skipped_image_ids": skipped,
+            },
+        }
+        jpath.write_text(json.dumps(coco))
+
+        n_files = len(list(img_dir.glob("*.jpg")))
+        assert n_files == len(images), (
+            f"{split}: {n_files} files != {len(images)} referenced"
+        )
+        note = (
+            f" (skipped {len(skipped)} undecodable/error rows, e.g. {skipped[:3]})"
+            if skipped
+            else ""
+        )
+        print(
+            f"{split}: {len(images)} images / {len(annotations)} annotations -> {img_dir} + {jpath.name}{note}"
+        )
+
+
+if __name__ == "__main__":
+    main()

render-detections.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#   "datasets>=4.0",
+#   "huggingface_hub>=1.27",  # hf://buckets in HfFileSystem (1.6) + prefix-collision fix (1.27)
+#   "pillow",
+#   "numpy",
+#   "pycocotools>=2.0.11",
+# ]
+# ///
+"""Render detection overlays from a dataset in this directory's schema -- and PROVE they rendered.
+
+Draws boxes (and masks, when masks_rle is present) over the embedded images and writes PNGs.
+Before reporting success it pixel-diffs every render against its source image: a page with
+instances whose render is identical to the source means the overlay silently failed (alpha
+bugs, empty mask lists, wrong-column reads -- all observed in real runs, twice shown to a
+human as "done"). Any blank render exits nonzero and names the file.
+
+    uv run render-detections.py <ns>/<teacher-or-training-dataset> --limit 10 --out previews/
+    uv run render-detections.py "hf://buckets/<ns>/<bucket>/dataset/train.parquet" --out previews/
+"""
+
+import argparse
+import io
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+from datasets import Image as HFImage
+from datasets import load_dataset
+from PIL import Image, ImageDraw
+
+COLORS = [
+    (255, 210, 0),
+    (80, 200, 120),
+    (90, 160, 255),
+    (230, 90, 80),
+    (200, 120, 220),
+    (255, 150, 50),
+]
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    p.add_argument(
+        "data", help="dataset repo id, or a parquet path/glob (hf:// or local)"
+    )
+    p.add_argument("--split", default="train")
+    p.add_argument("--limit", type=int, default=10)
+    p.add_argument("--out", default="previews")
+    p.add_argument("--bbox-format", default="yolo", choices=["yolo", "coco_xywh"])
+    p.add_argument("--no-masks", action="store_true")
+    p.add_argument(
+        "--min-pixels",
+        type=int,
+        default=1,
+        help="a page with instances whose render changed fewer pixels than this is BLANK "
+        "(default 1: any drawn pixel proves the overlay; a 50x50 box on a 3000px scan is real)",
+    )
+    args = p.parse_args()
+
+    if "://" in args.data or args.data.endswith(".parquet"):
+        ds = load_dataset("parquet", data_files=args.data, split="train")
+    else:
+        ds = load_dataset(args.data, split=args.split)
+    assert "image" in ds.column_names, (
+        "no image column in this dataset — nothing to render over"
+    )
+    ds = ds.select(range(min(args.limit, len(ds))))
+
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+    blank, rendered, skipped = [], 0, []
+    # undecoded bytes: a corrupt image or an error row is skipped, not a crash inside datasets
+    for row in ds.cast_column("image", HFImage(decode=False)).with_format(None):
+        raw = row["image"]
+        try:
+            src = (
+                Image.open(io.BytesIO(raw["bytes"])).convert("RGB")
+                if raw and raw.get("bytes")
+                else None
+            )
+        except Exception:  # noqa: BLE001 -- any decode failure means "skip this row"
+            src = None
+        if src is None or row.get("error"):
+            skipped.append(row["image_id"])
+            continue
+        im = src.copy()
+        w, h = im.size
+        n = len(row["objects"]["bbox"])
+
+        if not args.no_masks and row.get("masks_rle"):
+            from pycocotools import mask as mask_utils
+
+            overlay = Image.new("RGBA", im.size, (0, 0, 0, 0))
+            for i, rle in enumerate(json.loads(row["masks_rle"])):
+                seg = mask_utils.decode({**rle, "counts": rle["counts"].encode()})
+                if seg.shape != (h, w):
+                    seg = np.asarray(Image.fromarray(seg).resize((w, h), Image.NEAREST))
+                r, g, b = COLORS[i % len(COLORS)]
+                tint = np.zeros((h, w, 4), np.uint8)
+                tint[seg > 0] = (r, g, b, 110)
+                overlay = Image.alpha_composite(overlay, Image.fromarray(tint))
+            im = Image.alpha_composite(im.convert("RGBA"), overlay).convert("RGB")
+
+        draw = ImageDraw.Draw(im)
+        for i, bbox in enumerate(row["objects"]["bbox"]):
+            if args.bbox_format == "yolo":
+                cx, cy, bw, bh = bbox
+                box = [
+                    (cx - bw / 2) * w,
+                    (cy - bh / 2) * h,
+                    (cx + bw / 2) * w,
+                    (cy + bh / 2) * h,
+                ]
+            else:
+                x, y, bw, bh = bbox
+                box = [x, y, x + bw, y + bh]
+            draw.rectangle(box, outline=COLORS[i % len(COLORS)], width=max(3, w // 400))
+
+        name = f"{row['image_id']}_{n}inst.png"
+        im.save(out / name)
+
+        # ---- the point of this script: prove the overlay exists ----
+        changed = int(np.any(np.asarray(src) != np.asarray(im), axis=-1).sum())
+        if n > 0 and changed < args.min_pixels:
+            blank.append(name)
+        elif n > 0:
+            rendered += 1
+        print(
+            f"{name}: {n} instances, {changed} pixels changed ({changed / (w * h):.2%})"
+        )
+
+    if blank:
+        sys.exit(
+            f"BLANK RENDERS ({len(blank)}): {blank} — overlays did not draw; do not show these to a human."
+        )
+    if skipped:
+        print(f"skipped {len(skipped)} undecodable/error rows, e.g. {skipped[:3]}")
+    if rendered == 0:
+        sys.exit(
+            "No page with instances was rendered — nothing verified; increase --limit."
+        )
+    print(f"OK: {rendered} non-empty renders verified against source pixels -> {out}/")
+
+
+if __name__ == "__main__":
+    main()

smoke-test.py

@@ -0,0 +1,475 @@
+#!/usr/bin/env -S uv run --script
+# /// script
+# requires-python = ">=3.10"
+# dependencies = [
+#   "datasets>=4.0",
+#   "pillow",
+#   "numpy",
+#   "pyarrow>=18",
+#   "pycocotools>=2.0.11",
+# ]
+# ///
+"""Free, local, ~30 s: prove the plumbing scripts still work BEFORE a paid job depends on them.
+
+Builds what a teacher pass leaves behind -- annotations-only parquet parts in the
+falcon-perception-bucket.py schema, a source directory of page images, a gold slice -- for four
+pages: one with two instances whose masks are stored in a 2x-thumbnailed inference frame (the
+frame-mismatch bug seen in a real run), one with a box and no mask, one empty, one teacher ERROR
+row whose file is not a decodable image. Then it runs the plumbing chain on it and checks the
+OUTPUT of each step, not just the exit code:
+
+    embed-bucket-images.py   error row dropped, gold page excluded (and asserted), images joined
+                             in, one write of train.parquet + validation.parquet; also the
+                             --embed-images path (parts already carry the bytes -> no --src) and
+                             --keep-errors (the undecodable row must survive to the next step)
+    materialize-coco.py      COCO tree: file count == referenced count, masks resized to the
+                             image frame, every mask's pixel extent agrees with its box, the
+                             undecodable row skipped not crashed; a second run reuses the tree;
+                             the same images with CORRECTED labels rebuild it (fingerprint);
+                             --force over a tree holding a stale JPEG rebuilds clean
+    render-detections.py     overlays drawn (pixel-verified), the empty page not flagged as
+                             blank, the undecodable row skipped
+
+Run it after cloning, after bumping a dependency, and before submitting any job that uses these
+scripts. Exit 0 = green. Anything else names the failing check.
+
+    uv run smoke-test.py
+
+Not covered: the teacher pass itself (falcon-perception-bucket.py needs a GPU); run it on a
+--limit slice of your own bucket.
+"""
+
+import json
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import numpy as np
+import pyarrow as pa
+import pyarrow.parquet as pq
+from datasets import load_dataset
+from PIL import Image
+from pycocotools import mask as mask_utils
+
+HERE = Path(__file__).resolve().parent
+IMAGE_W, IMAGE_H = 800, 1000  # the image frame
+INFER_W, INFER_H = 400, 500  # the teacher's inference frame (thumbnailed 2x)
+
+# Ground truth in image-frame pixels: (x0, y0, x1, y1). Masks are the same rectangles, but
+# stored at half resolution so the scripts must resize them.
+PAGE1_BOXES = [(100, 100, 300, 400), (450, 600, 750, 900)]
+PAGE2_BOXES = [(200, 200, 600, 500)]
+PAGE2_CORRECTED = [
+    (200, 200, 600, 500),
+    (50, 700, 250, 950),
+]  # the step-6 loop found one more
+GOLD_IMAGE_ID = 3  # the empty page is held out as "gold" and must never reach train/val
+ERROR_IMAGE_ID = 4  # the teacher could not open this file; its bytes are not an image
+
+# mirrors SCHEMA in falcon-perception-bucket.py
+PARTS_SCHEMA = pa.schema(
+    [
+        ("__source_key", pa.string()),
+        ("image_id", pa.int64()),
+        ("width", pa.int32()),
+        ("height", pa.int32()),
+        (
+            "objects",
+            pa.struct(
+                [
+                    ("bbox", pa.list_(pa.list_(pa.float32()))),
+                    ("category", pa.list_(pa.int64())),
+                    ("area", pa.list_(pa.float32())),
+                    ("rectangularity", pa.list_(pa.float32())),
+                ]
+            ),
+        ),
+        ("n_instances", pa.int32()),
+        ("masks_rle", pa.string()),
+        ("query", pa.string()),
+        ("gen_seconds", pa.float32()),
+        ("error", pa.string()),
+    ]
+)
+IMAGE_FIELD = pa.field(
+    "image", pa.struct([("bytes", pa.binary()), ("path", pa.string())])
+)
+
+
+def synthetic_page(seed):
+    rng = np.random.default_rng(seed)
+    noise = rng.integers(0, 10, (IMAGE_H, IMAGE_W, 1), dtype=np.uint8)
+    arr = np.full((IMAGE_H, IMAGE_W, 3), 245, np.uint8) - noise
+    return Image.fromarray(arr)
+
+
+def rle_in_inference_frame(x0, y0, x1, y1):
+    m = np.zeros((INFER_H, INFER_W), np.uint8)
+    m[y0:y1, x0:x1] = 1
+    encoded = mask_utils.encode(np.asfortranarray(m))
+    return {"size": [INFER_H, INFER_W], "counts": encoded["counts"].decode("ascii")}
+
+
+def yolo_box(x0, y0, x1, y1):
+    """Pixel corners in the IMAGE frame -> yolo-normalised [cx, cy, w, h]."""
+    return [
+        (x0 + x1) / 2 / IMAGE_W,
+        (y0 + y1) / 2 / IMAGE_H,
+        (x1 - x0) / IMAGE_W,
+        (y1 - y0) / IMAGE_H,
+    ]
+
+
+def teacher_row(image_id, boxes, with_masks, error=None):
+    bbox = [yolo_box(*b) for b in boxes]
+    masks = (
+        [rle_in_inference_frame(*[v // 2 for v in b]) for b in boxes]
+        if with_masks
+        else []
+    )
+    return {
+        "__source_key": f"pages/{image_id}.jpg",
+        "image_id": image_id,
+        "width": None if error else IMAGE_W,
+        "height": None if error else IMAGE_H,
+        "objects": {
+            "bbox": bbox,
+            "category": [0] * len(bbox),
+            "area": [b[2] * b[3] for b in bbox],
+            "rectangularity": [1.0] * len(bbox),
+        },
+        "n_instances": len(bbox),
+        "masks_rle": json.dumps(masks),
+        "query": "illustration",
+        "gen_seconds": 0.1,
+        "error": error,
+    }
+
+
+def build_teacher_output(root):
+    """parts/ (annotations-only), parts-corrected/, parts-embedded/ (with bytes), pages/, gold.parquet"""
+    pages = root / "pages" / "pages"
+    pages.mkdir(parents=True)
+    rows = [
+        teacher_row(1, PAGE1_BOXES, with_masks=True),
+        teacher_row(2, PAGE2_BOXES, with_masks=False),
+        teacher_row(GOLD_IMAGE_ID, [], with_masks=False),
+        teacher_row(
+            ERROR_IMAGE_ID, [], with_masks=False, error="OSError: truncated file"
+        ),
+    ]
+    blobs = {}
+    for row in rows:
+        path = pages / f"{row['image_id']}.jpg"
+        if row["error"]:
+            path.write_bytes(b"this is not a jpeg")
+        else:
+            synthetic_page(row["image_id"]).save(path, "JPEG", quality=95)
+        blobs[row["image_id"]] = path.read_bytes()
+
+    (root / "parts").mkdir()
+    pq.write_table(
+        pa.Table.from_pylist(rows, schema=PARTS_SCHEMA),
+        root / "parts" / "part-a.parquet",
+    )
+
+    corrected = [
+        teacher_row(2, PAGE2_CORRECTED, with_masks=False) if r["image_id"] == 2 else r
+        for r in rows
+    ]
+    (root / "parts-corrected").mkdir()
+    pq.write_table(
+        pa.Table.from_pylist(corrected, schema=PARTS_SCHEMA),
+        root / "parts-corrected" / "part-a.parquet",
+    )
+
+    # --embed-images parts: the error row carries image=None (the teacher never read its bytes)
+    embedded = [
+        {
+            **r,
+            "image": None
+            if r["error"]
+            else {"bytes": blobs[r["image_id"]], "path": None},
+        }
+        for r in rows
+    ]
+    (root / "parts-embedded").mkdir()
+    pq.write_table(
+        pa.Table.from_pylist(embedded, schema=PARTS_SCHEMA.append(IMAGE_FIELD)),
+        root / "parts-embedded" / "part-a.parquet",
+    )
+
+    gold = pa.table({"image_id": pa.array([GOLD_IMAGE_ID], pa.int64())})
+    pq.write_table(gold, root / "gold.parquet")
+
+
+def run(script, *argv):
+    # `uv run` so each script resolves its OWN PEP 723 header -- a bad dependency line in a
+    # child script is exactly the kind of breakage this test exists to catch
+    cmd = ["uv", "run", "--quiet", str(HERE / script), *map(str, argv)]
+    proc = subprocess.run(cmd, capture_output=True, text=True, check=False)
+    if proc.returncode != 0:
+        print(proc.stdout)
+        print(proc.stderr)
+        sys.exit(f"FAIL: {script} exited {proc.returncode}")
+    return proc.stdout
+
+
+def check(condition, message):
+    if not condition:
+        sys.exit(f"FAIL: {message}")
+
+
+def check_embedded(out_dir, label, expect_ids=(1, 2)):
+    files = sorted(p.name for p in out_dir.glob("*.parquet"))
+    check(files == ["train.parquet", "validation.parquet"], f"{label}: wrote {files}")
+    ds = load_dataset("parquet", data_files=str(out_dir / "*.parquet"), split="train")
+    ids = sorted(ds["image_id"])
+    check(
+        ids == list(expect_ids),
+        f"{label}: expected pages {list(expect_ids)}, got {ids}",
+    )
+    check("image" in ds.column_names, f"{label}: no image column")
+    check(
+        type(ds.features["image"]).__name__ == "Image",
+        f"{label}: image column is not an Image feature",
+    )
+    names = ds.features["objects"]["category"].feature.names
+    check(names == ["illustration"], f"{label}: category names {names}")
+    print(f"OK embed-bucket-images ({label}): pages {ids}, Image column, one write")
+
+
+def load_tree(coco_dir):
+    """All splits merged: which page lands in train vs val depends on the shuffle, the checks don't."""
+    images, anns, files, skipped = {}, [], 0, set()
+    for split_dir in ("train2017", "val2017"):
+        ann_path = coco_dir / "annotations" / f"instances_{split_dir}.json"
+        coco = json.loads(ann_path.read_text())
+        n_files = len(list((coco_dir / split_dir).glob("*.jpg")))
+        check(
+            n_files == len(coco["images"]),
+            f"{split_dir}: {n_files} files != {len(coco['images'])} referenced",
+        )
+        check(
+            coco["categories"] == [{"id": 1, "name": "illustration"}],
+            "categories wrong",
+        )
+        files += n_files
+        images.update({im["id"]: im for im in coco["images"]})
+        anns.extend(coco["annotations"])
+        skipped |= set(coco["provenance"]["skipped_image_ids"])
+    return images, anns, files, skipped
+
+
+def check_coco(coco_dir, page2_boxes=PAGE2_BOXES, expect_skipped=()):
+    images, annotations, n_files, skipped = load_tree(coco_dir)
+    check(
+        sorted(images) == [1, 2], f"tree holds pages {sorted(images)}, expected [1, 2]"
+    )
+    check(n_files == 2, f"{n_files} JPEGs in the tree, expected 2")
+    check(
+        skipped == set(expect_skipped),
+        f"skipped ids {skipped}, expected {set(expect_skipped)}",
+    )
+    by_image = {}
+    for ann in annotations:
+        by_image.setdefault(ann["image_id"], []).append(ann)
+    check(GOLD_IMAGE_ID not in by_image, "gold page leaked into the COCO tree")
+    check(ERROR_IMAGE_ID not in by_image, "error page leaked into the COCO tree")
+    for image_id, boxes in ((1, PAGE1_BOXES), (2, page2_boxes)):
+        anns = by_image.get(image_id, [])
+        check(
+            len(anns) == len(boxes),
+            f"page {image_id}: {len(anns)} annotations, expected {len(boxes)}",
+        )
+        for ann, (x0, y0, x1, y1) in zip(anns, boxes):
+            bx, by, bw, bh = [round(v) for v in ann["bbox"]]
+            check(
+                (bx, by, bw, bh) == (x0, y0, x1 - x0, y1 - y0),
+                f"bbox mismatch: {ann['bbox']}",
+            )
+            if image_id == 1:
+                seg = ann.get("segmentation")
+                check(seg is not None, "page 1 annotation lost its mask")
+                check(
+                    seg["size"] == [IMAGE_H, IMAGE_W],
+                    f"mask not resized to image frame: {seg['size']}",
+                )
+                m = mask_utils.decode({**seg, "counts": seg["counts"].encode()})
+                ys, xs = np.where(m)
+                extent = (xs.min(), ys.min(), xs.max() + 1, ys.max() + 1)
+                check(
+                    extent == (x0, y0, x1, y1),
+                    f"mask extent {extent} != box {(x0, y0, x1, y1)}",
+                )
+            else:
+                check(
+                    "segmentation" not in ann,
+                    "page 2 has no mask but got a segmentation",
+                )
+    print(
+        "OK materialize-coco: files == referenced, masks resized 500x400 -> 1000x800 and aligned to boxes, "
+        f"page 2 has {len(page2_boxes)} box(es)"
+    )
+
+
+def check_render(stdout, previews):
+    names = sorted(p.name for p in previews.glob("*.png"))
+    check(
+        names == ["1_2inst.png", "2_1inst.png", "3_0inst.png"],
+        f"unexpected previews: {names}",
+    )
+    check("OK: 2 non-empty renders verified" in stdout, "render did not verify 2 pages")
+    check(
+        "skipped 1 undecodable/error rows" in stdout,
+        "render did not skip the undecodable page",
+    )
+    print(
+        "OK render-detections: 2 overlays pixel-verified, empty page not flagged, undecodable page skipped"
+    )
+
+
+def main():
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        build_teacher_output(tmp)
+        print(f"fixture: 4 pages of teacher output -> {tmp}")
+
+        # 1. annotations-only parts + local source dir (the default teacher output):
+        #    error row dropped by default, gold page excluded
+        run(
+            "embed-bucket-images.py",
+            "--parts",
+            tmp / "parts" / "part-*.parquet",
+            "--src",
+            tmp / "pages",
+            "--gold",
+            tmp / "gold.parquet",
+            "--out",
+            tmp / "dataset",
+            "--val-frac",
+            "0.5",
+            "--chunk",
+            "1",
+        )
+        check_embedded(tmp / "dataset", "annotations-only parts + --src")
+
+        # 2. parts that already carry the bytes (teacher ran with --embed-images): no --src
+        run(
+            "embed-bucket-images.py",
+            "--parts",
+            tmp / "parts-embedded" / "part-*.parquet",
+            "--gold",
+            tmp / "gold.parquet",
+            "--out",
+            tmp / "dataset-embedded",
+            "--val-frac",
+            "0.5",
+        )
+        check_embedded(tmp / "dataset-embedded", "--embed-images parts, no --src")
+
+        # 3. --keep-errors: the undecodable page must reach the next step, which must survive it
+        run(
+            "embed-bucket-images.py",
+            "--parts",
+            tmp / "parts" / "part-*.parquet",
+            "--src",
+            tmp / "pages",
+            "--gold",
+            tmp / "gold.parquet",
+            "--out",
+            tmp / "dataset-kept",
+            "--val-frac",
+            "0.34",
+            "--keep-errors",
+        )
+        check_embedded(
+            tmp / "dataset-kept", "--keep-errors", expect_ids=(1, 2, ERROR_IMAGE_ID)
+        )
+
+        # 4. COCO tree (undecodable row skipped, not crashed), then a second run must reuse it
+        run(
+            "materialize-coco.py", "--data", tmp / "dataset-kept", "--out", tmp / "coco"
+        )
+        check_coco(tmp / "coco", expect_skipped=(ERROR_IMAGE_ID,))
+        again = run(
+            "materialize-coco.py", "--data", tmp / "dataset-kept", "--out", tmp / "coco"
+        )
+        check(
+            again.count("reusing complete tree") == 2,
+            f"second run rebuilt instead of reusing:\n{again}",
+        )
+        print("OK materialize-coco: second run reused both complete trees")
+
+        # 5. same images, CORRECTED labels (the step-6 loop) -> the tree must rebuild, not reuse
+        run(
+            "embed-bucket-images.py",
+            "--parts",
+            tmp / "parts-corrected" / "part-*.parquet",
+            "--src",
+            tmp / "pages",
+            "--gold",
+            tmp / "gold.parquet",
+            "--out",
+            tmp / "dataset-corrected",
+            "--val-frac",
+            "0.5",
+        )
+        rebuilt = run(
+            "materialize-coco.py",
+            "--data",
+            tmp / "dataset-corrected",
+            "--out",
+            tmp / "coco",
+        )
+        # the fingerprint is per split: only the split holding page 2 must rebuild, the other may reuse
+        check(
+            "labels changed" in rebuilt,
+            f"corrected labels did not trigger a rebuild:\n{rebuilt}",
+        )
+        check_coco(tmp / "coco", page2_boxes=PAGE2_CORRECTED)
+        print(
+            "OK materialize-coco: corrected labels rebuilt the tree (fingerprint), new box present"
+        )
+
+        # 6. --force over a tree holding a stale JPEG must come back clean
+        (tmp / "coco" / "train2017" / "999.jpg").write_bytes(b"stale")
+        run(
+            "materialize-coco.py",
+            "--data",
+            tmp / "dataset-corrected",
+            "--out",
+            tmp / "coco",
+            "--force",
+        )
+        check(
+            not (tmp / "coco" / "train2017" / "999.jpg").exists(),
+            "--force left a stale JPEG in the tree",
+        )
+        check_coco(tmp / "coco", page2_boxes=PAGE2_CORRECTED)
+        print("OK materialize-coco: --force cleared the stale file and rebuilt clean")
+
+        # 7. overlays over the raw teacher pages (all 4, incl. the empty and the undecodable one)
+        run(
+            "embed-bucket-images.py",
+            "--parts",
+            tmp / "parts" / "part-*.parquet",
+            "--src",
+            tmp / "pages",
+            "--out",
+            tmp / "all",
+            "--val-frac",
+            "0.25",
+            "--keep-errors",
+        )
+        out = run(
+            "render-detections.py", tmp / "all" / "*.parquet", "--out", tmp / "previews"
+        )
+        check_render(out, tmp / "previews")
+
+    print("SMOKE TEST GREEN")
+
+
+if __name__ == "__main__":
+    main()