detr training script for pi-r3 task

train_detr.py

@@ -0,0 +1,714 @@
+#!/usr/bin/env python
+"""Fine-tune facebook/detr-resnet-50 (Apache-2.0) on biglam/loc_beyond_words.
+
+Modes:
+  --mode bench     : measure throughput on GPU, print img/s + epoch estimate, exit.
+  --mode train     : full train + eval + push to HF hub.
+
+The model + processor + README + metrics are pushed to a HF repo (default
+harness-race/pi-r3). Everything needed to reproduce is in the script.
+"""
+import argparse
+import json
+import math
+import os
+import random
+import time
+from collections import Counter
+
+import numpy as np
+import torch
+from PIL import Image, ImageDraw, ImageFont
+from torch.utils.data import DataLoader, Dataset
+
+from datasets import load_dataset
+
+ID2LABEL = {
+    0: "Photograph",
+    1: "Illustration",
+    2: "Map",
+    3: "Comics/Cartoon",
+    4: "Editorial Cartoon",
+    5: "Headline",
+    6: "Advertisement",
+}
+LABEL2ID = {v: k for k, v in ID2LABEL.items()}
+NUM_CLASSES = len(ID2LABEL)
+CHECKPOINT = "facebook/detr-resnet-50"
+DATASET = "biglam/loc_beyond_words"
+SHORTEST = 800
+LONGEST = 1333
+
+
+def set_seed(seed=42):
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed_all(seed)
+
+
+# ---------------------------------------------------------------------------
+# Data
+# ---------------------------------------------------------------------------
+class DetrDataset(Dataset):
+    """One row at a time: image + COCO-style annotations -> processor encoding."""
+
+    def __init__(self, hf_ds, processor, jitter_resize=True, seed=0):
+        self.ds = hf_ds
+        self.processor = processor
+        self.jitter = jitter_resize
+        self.rs = np.random.RandomState(seed)
+
+    def __len__(self):
+        return len(self.ds)
+
+    def __getitem__(self, i):
+        row = self.ds[i]
+        image = row["image"].convert("RGB")
+        objs = [
+            {
+                "category_id": o["category_id"],
+                "bbox": [float(x) for x in o["bbox"]],
+                "area": float(o["area"]),
+                "iscrowd": bool(o.get("iscrowd", False)),
+            }
+            for o in row["objects"]
+        ]
+        if self.jitter:
+            size = {
+                "shortest_edge": int(self.rs.randint(480, SHORTEST + 1)),
+                "longest_edge": LONGEST,
+            }
+        else:
+            size = {"shortest_edge": SHORTEST, "longest_edge": LONGEST}
+        ann = [{"image_id": int(row["image_id"]), "annotations": objs}]
+        enc = self.processor(images=[image], annotations=ann, return_tensors="pt", size=size)
+        return {
+            "pixel_values": enc["pixel_values"][0],
+            "pixel_mask": enc["pixel_mask"][0],
+            "labels": enc["labels"][0],
+        }
+
+
+def detr_collate(batch):
+    pixel_values = [b["pixel_values"] for b in batch]
+    shapes = [p.shape[-2:] for p in pixel_values]
+    max_h = max(s[0] for s in shapes)
+    max_w = max(s[1] for s in shapes)
+    padded, masks = [], []
+    for p in pixel_values:
+        ph, pw = p.shape[-2:]
+        pp = torch.zeros((3, max_h, max_w), dtype=p.dtype)
+        pp[:, :ph, :pw] = p
+        m = torch.zeros((max_h, max_w), dtype=torch.bool)
+        m[:ph, :pw] = True
+        padded.append(pp)
+        masks.append(m)
+    return {
+        "pixel_values": torch.stack(padded),
+        "pixel_mask": torch.stack(masks),
+        "labels": [b["labels"] for b in batch],
+    }
+
+
+# ---------------------------------------------------------------------------
+# COCO evaluation
+# ---------------------------------------------------------------------------
+def build_coco_gt(hf_ds):
+    images = [
+        {"id": int(r["image_id"]), "width": int(r["width"]), "height": int(r["height"])}
+        for r in hf_ds
+    ]
+    anns, aid = [], 0
+    for r in hf_ds:
+        for o in r["objects"]:
+            x, y, w, h = [float(v) for v in o["bbox"]]
+            anns.append(
+                {
+                    "id": aid,
+                    "image_id": int(r["image_id"]),
+                    "category_id": int(o["category_id"]),
+                    "bbox": [x, y, max(w, 1.0), max(h, 1.0)],
+                    "area": float(o["area"]),
+                    "iscrowd": bool(o.get("iscrowd", False)),
+                }
+            )
+            aid += 1
+    cats = [{"id": i, "name": n} for i, n in ID2LABEL.items()]
+    return {"images": images, "annotations": anns, "categories": cats}
+
+
+@torch.no_grad()
+def evaluate(model, processor, eval_ds, device, amp=True, bs=2, max_images=None):
+    from pycocotools.coco import COCO
+    from pycocotools.cocoeval import COCOeval
+
+    model.eval()
+    gt_dict = build_coco_gt(eval_ds.ds)
+    coco_gt = COCO()
+    coco_gt.dataset = gt_dict
+    coco_gt.createIndex()
+    results = []
+
+    n = len(eval_ds) if max_images is None else min(max_images, len(eval_ds))
+    idxs = list(range(n))
+    loader = DataLoader(
+        torch.utils.data.Subset(eval_ds, idxs),
+        batch_size=bs,
+        collate_fn=detr_collate,
+        shuffle=False,
+        num_workers=2,
+        prefetch_factor=2,
+    )
+    t0 = time.time()
+    for batch in loader:
+        pixel_values = batch["pixel_values"].to(device)
+        pixel_mask = batch["pixel_mask"].to(device)
+        labels = batch["labels"]
+        with torch.autocast("cuda", dtype=torch.float16, enabled=amp and device.type == "cuda"):
+            outputs = model(pixel_values=pixel_values, pixel_mask=pixel_mask)
+        orig_sizes = torch.stack([l["orig_size"].to(device) for l in labels])
+        preds = processor.post_process_object_detection(
+            outputs, threshold=0.0, target_sizes=orig_sizes
+        )
+        id2img = {g["id"]: g for g in gt_dict["images"]}
+        for j in range(len(preds)):
+            image_id = int(labels[j]["image_id"])
+            gimg = id2img[image_id]
+            W, H = gimg["width"], gimg["height"]
+            for box, score, cl in zip(
+                preds[j]["boxes"].cpu().float(), preds[j]["scores"].cpu().float(), preds[j]["labels"].cpu()
+            ):
+                x1, y1, x2, y2 = box.tolist()
+                x1 = max(0.0, min(x1, float(W)))
+                y1 = max(0.0, min(y1, float(H)))
+                x2 = max(0.0, min(x2, float(W)))
+                y2 = max(0.0, min(y2, float(H)))
+                if x2 - x1 < 1 or y2 - y1 < 1:
+                    continue
+                results.append(
+                    {
+                        "image_id": image_id,
+                        "category_id": int(cl),
+                        "bbox": [x1, y1, x2 - x1, y2 - y1],
+                        "score": float(score),
+                    }
+                )
+    if not results:
+        return {"mAP": 0.0}
+    coco_dt = coco_gt.loadRes(results)
+
+    def run_eval(catIds=None):
+        e = COCOeval(coco_gt, coco_dt, iouType="bbox")
+        if catIds is not None:
+            e.params.catIds = catIds
+        e.evaluate()
+        e.accumulate()
+        e.summarize()
+        return e
+
+    e = run_eval()
+    stats = e.stats  # [mAP, mAP@0.5, mAP@0.75, mAP_s, mAP_m, mAP_l, AR1, AR10, AR100, AR_s, AR_m, AR_l]
+    metrics = {
+        "mAP": float(stats[0]),
+        "mAP_50": float(stats[1]),
+        "mAP_75": float(stats[2]),
+        "mAP_small": float(stats[3]),
+        "mAP_medium": float(stats[4]),
+        "mAP_large": float(stats[5]),
+        "AR_1": float(stats[6]),
+        "AR_10": float(stats[7]),
+        "AR_100": float(stats[8]),
+        "eval_images": n,
+        "eval_time_s": round(time.time() - t0, 1),
+    }
+    for cid, cname in ID2LABEL.items():
+        ec = run_eval(catIds=[cid])
+        metrics[f"AP_{cname.replace('/', '_')}"] = float(ec.stats[0])
+        metrics[f"AP50_{cname.replace('/', '_')}"] = float(ec.stats[1])
+    model.train()
+    return metrics
+
+
+# ---------------------------------------------------------------------------
+# Visualization
+# ---------------------------------------------------------------------------
+def make_viz(model, processor, eval_ds, device, out_path, n=3, seed=0):
+    model.eval()
+    rs = np.random.RandomState(seed)
+    idxs = rs.choice(len(eval_ds), size=n, replace=False)
+    cols = 2
+    rows = n
+    cell_w, cell_h = 300, 300
+    canvas = Image.new("RGB", (cols * cell_w, rows * cell_h), "white")
+    try:
+        font = ImageFont.load_default()
+    except Exception:
+        font = None
+    colors = ["#e6194b", "#3cb44b", "#ffe119", "#4363d8", "#f58231", "#911eb4", "#46f0f0"]
+    for r, i in enumerate(idxs):
+        row = eval_ds.ds[int(i)]
+        gt_img = row["image"].convert("RGB")
+        objs = row["objects"]
+        img_t, mask_t = None, None
+        enc = processor(
+            images=[gt_img],
+            annotations=[{"image_id": int(row["image_id"]), "annotations": []}],
+            return_tensors="pt",
+            size={"shortest_edge": SHORTEST, "longest_edge": LONGEST},
+        )
+        with torch.no_grad(), torch.autocast("cuda", dtype=torch.float16, enabled=torch.cuda.is_available()):
+            outputs = model(
+                pixel_values=enc["pixel_values"].to(device),
+                pixel_mask=enc["pixel_mask"].to(device),
+            )
+            preds = processor.post_process_object_detection(
+                outputs, threshold=0.5, target_sizes=torch.tensor([[row["height"], row["width"]]])
+            )[0]
+        # ground truth
+        gt_pil = gt_img.copy()
+        d = ImageDraw.Draw(gt_pil)
+        for o in objs[:20]:
+            x, y, w, h = o["bbox"]
+            d.rectangle([x, y, x + w, y + h], outline="#000000", width=2)
+        # pred
+        pr_pil = gt_img.copy()
+        d = ImageDraw.Draw(pr_pil)
+        for box, score, cl in zip(
+            preds["boxes"].cpu(), preds["scores"].cpu(), preds["labels"].cpu()
+        ):
+            x1, y1, x2, y2 = [float(v) for v in box]
+            c = colors[int(cl) % len(colors)]
+            d.rectangle([x1, y1, x2, y2], outline=c, width=3)
+            if font is not None:
+                d.text((x1, max(0, y1 - 14)), f"{ID2LABEL[int(cl)]} {float(score):.2f}", fill=c, font=font)
+        gt_pil.thumbnail((cell_w, cell_h))
+        pr_pil.thumbnail((cell_w, cell_h))
+        canvas.paste(gt_pil, (0, r * cell_h))
+        canvas.paste(pr_pil, (cell_w, r * cell_h))
+    canvas.save(out_path)
+    model.train()
+
+
+# ---------------------------------------------------------------------------
+# Training
+# ---------------------------------------------------------------------------
+def load_model(device):
+    from transformers import DetrConfig, DetrForObjectDetection
+
+    config = DetrConfig.from_pretrained(CHECKPOINT, num_labels=NUM_CLASSES)
+    config.id2label = {int(k): v for k, v in ID2LABEL.items()}
+    config.label2id = {v: int(k) for k, v in ID2LABEL.items()}
+    model = DetrForObjectDetection.from_pretrained(
+        CHECKPOINT, config=config, ignore_mismatched_sizes=True
+    )
+    model.to(device)
+    print(f"[load] model loaded: {CHECKPOINT}", flush=True)
+    return model
+
+
+def bench(device, args):
+    from transformers import DetrImageProcessor
+
+    processor = DetrImageProcessor.from_pretrained(CHECKPOINT)
+    pcounter = Counter()
+    ds_hf = load_dataset(DATASET)
+    tr = ds_hf["train"]
+    print(f"[bench] train rows: {len(tr)}", flush=True)
+    tds = DetrDataset(tr, processor, jitter_resize=True, seed=42)
+    loader = DataLoader(
+        tds, batch_size=args.bs, collate_fn=detr_collate, shuffle=True, num_workers=2, prefetch_factor=2
+    )
+    model = load_model(device)
+    optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=1e-4)
+    scaler = torch.cuda.amp.GradScaler(enabled=True)
+
+    it = iter(loader)
+    # warmup
+    n_warm = 6
+    for _ in range(n_warm):
+        batch = next(it)
+        pixel_values = batch["pixel_values"].to(device)
+        pixel_mask = batch["pixel_mask"].to(device)
+        labels = batch["labels"]
+        with torch.autocast("cuda", dtype=torch.float16):
+            out = model(pixel_values=pixel_values, pixel_mask=pixel_mask, labels=labels)
+        scaler.scale(out["loss"]).backward()
+        scaler.step(optimizer)
+        scaler.update()
+        optimizer.zero_grad()
+    print("[bench] warmup done; timing steps...", flush=True)
+    # timed
+    n_steps = 40
+    t0 = time.time()
+    for _ in range(n_steps):
+        batch = next(it)
+        pixel_values = batch["pixel_values"].to(device)
+        pixel_mask = batch["pixel_mask"].to(device)
+        labels = batch["labels"]
+        with torch.autocast("cuda", dtype=torch.float16):
+            out = model(pixel_values=pixel_values, pixel_mask=pixel_mask, labels=labels)
+        scaler.scale(out["loss"]).backward()
+        scaler.step(optimizer)
+        scaler.update()
+        optimizer.zero_grad()
+    dt = time.time() - t0
+    img_s = n_steps * args.bs / dt
+    steps_epoch = math.ceil(len(tr) / args.bs)
+    sec_epoch = steps_epoch / (n_steps / dt)
+    print(
+        json.dumps(
+            {
+                "mode": "bench",
+                "bs": args.bs,
+                "img_s": round(img_s, 2),
+                "steps_per_epoch": steps_epoch,
+                "sec_per_epoch": round(sec_epoch, 1),
+                "min_per_epoch": round(sec_epoch / 60, 2),
+            }
+        ),
+        flush=True,
+    )
+
+
+def train(device, args):
+    from huggingface_hub import HfApi
+    from transformers import DetrImageProcessor
+
+    set_seed(args.seed)
+    t_start = time.time()
+    processor = DetrImageProcessor.from_pretrained(CHECKPOINT)
+    ds_hf = load_dataset(DATASET)
+    tr, va = ds_hf["train"], ds_hf["validation"]
+    print(f"[train] train={len(tr)} val={len(va)}", flush=True)
+    if args.limit:
+        tr = tr.select(range(min(len(tr), args.limit)))
+        va = va.select(range(min(len(va), args.limit or 712)))
+
+    tds = DetrDataset(tr, processor, jitter_resize=True, seed=args.seed)
+    vds = DetrDataset(va, processor, jitter_resize=False, seed=args.seed)
+    loader = DataLoader(
+        tds, batch_size=args.bs, collate_fn=detr_collate, shuffle=True,
+        num_workers=3, prefetch_factor=2, drop_last=True, persistent_workers=True,
+    )
+    model = load_model(device)
+
+    backbone_names = {n for n, _ in model.named_parameters() if "backbone" in n}
+    param_groups = [
+        {"params": [p for n, p in model.named_parameters() if n in backbone_names], "lr": args.lr * 0.1},
+        {"params": [p for n, p in model.named_parameters() if n not in backbone_names], "lr": args.lr},
+    ]
+    optimizer = torch.optim.AdamW(param_groups, lr=args.lr, weight_decay=1e-4)
+    total_steps = math.ceil(len(loader) * args.epochs)
+    warmup_steps = min(500, total_steps // 10)
+    from transformers import get_cosine_schedule_with_warmup
+
+    scheduler = get_cosine_schedule_with_warmup(optimizer, warmup_steps, total_steps)
+    scaler = torch.cuda.amp.GradScaler(enabled=args.amp and device.type == "cuda")
+
+    best = {"mAP": -1.0, "epoch": -1}
+    history = []
+    global_step = 0
+    model.train()
+    t_epoch0 = time.time()
+
+    def time_left_ok(eta_epoch_min):
+        if args.max_time_min <= 0:
+            return True
+        return (time.time() - t_start) / 60 + eta_epoch_min < args.max_time_min - 12
+
+    for epoch in range(1, args.epochs + 1):
+        ep_losses = []
+        ep_start = time.time()
+        for batch in loader:
+            pixel_values = batch["pixel_values"].to(device)
+            pixel_mask = batch["pixel_mask"].to(device)
+            labels = batch["labels"]
+            with torch.autocast("cuda", dtype=torch.float16, enabled=args.amp):
+                out = model(pixel_values=pixel_values, pixel_mask=pixel_mask, labels=labels)
+            loss = out["loss"]
+            if math.isfinite(loss.item()):
+                scaler.scale(loss).backward()
+            nan_skip = not math.isfinite(loss.item())
+            if global_step % args.accum == 0:
+                scaler.step(optimizer)
+                scaler.update()
+                scheduler.step()
+                optimizer.zero_grad()
+            if nan_skip:
+                optimizer.zero_grad()
+            ep_losses.append(float(loss.detach().cpu()))
+            global_step += 1
+        if args.accum * args.bs * 1 + 0 < 0:  # no-op guard (kept for clarity)
+            pass
+        # flush any leftover grads
+        scaler.step(optimizer)
+        scaler.update()
+        optimizer.zero_grad()
+        ep_min = (time.time() - ep_start) / 60
+        history.append({"epoch": epoch, "train_loss": float(np.mean(ep_losses)), "epoch_min": round(ep_min, 2)})
+        print(f"[train] epoch {epoch}/{args.epochs} loss={np.mean(ep_losses):.4f} ({ep_min:.1f} min) gstep={global_step}", flush=True)
+
+        if args.eval_every > 0 and epoch % args.eval_every == 0:
+            print(f"[eval] running validation at epoch {epoch}...", flush=True)
+            m = evaluate(model, processor, vds, device, amp=args.amp, bs=2)
+            m["epoch"] = epoch
+            m["train_loss"] = float(np.mean(ep_losses))
+            history[-1].update({"mAP": m["mAP"], "mAP_50": m["mAP_50"]})
+            print(f"[eval] {json.dumps({k: round(v, 4) if isinstance(v, float) else v for k, v in m.items() if not k.startswith('AP_')})}", flush=True)
+            if m["mAP"] > best["mAP"]:
+                best = {"mAP": m["mAP"], "epoch": epoch}
+                save_snapshot(model, processor, args.repo_dir, m)
+                print(f"[train] new best mAP {m['mAP']:.4f} @ epoch {epoch} (snapshot saved)", flush=True)
+            model.train()
+
+        # soft stop so push always happens
+        if not time_left_ok(ep_min):
+            print(f"[train] stopping early to leave time for final eval+push (elapsed {(time.time()-t_start)/60:.1f} min)", flush=True)
+            break
+
+    # ---- final eval on best snapshot (or current) ----
+    print("[train] final evaluation...", flush=True)
+    if best["epoch"] > 0:
+        from transformers import DetrForObjectDetection
+
+        cfg = json.load(open(os.path.join(args.repo_dir, "config.json")))
+        model = DetrForObjectDetection.from_pretrained(args.repo_dir).to(device)
+        processor = DetrImageProcessor.from_pretrained(args.repo_dir)
+    final_m = evaluate(model, processor, vds, device, amp=args.amp, bs=2)
+    final_m["epoch"] = best["epoch"] if best["epoch"] > 0 else args.epochs
+    final_m["total_train_min"] = round((time.time() - t_start) / 60, 1)
+    final_m["num_train_images"] = len(tr)
+    final_m["num_val_images"] = len(va)
+    final_m["best_mAP"] = best["mAP"]
+    print(f"[eval] FINAL {json.dumps({k: round(v, 4) if isinstance(v, float) else v for k, v in final_m.items() if not k.startswith('AP_')})}", flush=True)
+
+    # ---- viz + push ----
+    if args.push:
+        os.makedirs(args.repo_dir, exist_ok=True)
+        if best["epoch"] <= 0:
+            save_snapshot(model, processor, args.repo_dir, final_m)
+        viz_path = os.path.join(args.repo_dir, "inference_examples.png")
+        try:
+            make_viz(model, processor, vds, device, viz_path, n=3)
+            print("[viz] saved inference_examples.png", flush=True)
+        except Exception as e:
+            print(f"[viz] failed: {e}", flush=True)
+        with open(os.path.join(args.repo_dir, "metrics.json"), "w") as f:
+            json.dump({"id2label": ID2LABEL, "history": history, "final": final_m}, f, indent=2)
+        write_readme(args.repo_dir, final_m, history, args)
+        api = HfApi(token=os.environ.get("HF_TOKEN"))
+        api.upload_folder(
+            folder_path=args.repo_dir,
+            repo_id=args.repo_id,
+            repo_type="model",
+            commit_message="Fine-tune DETR (detr-resnet-50) on biglam/loc_beyond_words",
+        )
+        print(f"[push] pushed to {args.repo_id}", flush=True)
+    print(f"[done] RESULT {json.dumps(final_m, default=float)}", flush=True)
+
+
+def save_snapshot(model, processor, repo_dir, metrics):
+    os.makedirs(repo_dir, exist_ok=True)
+    model.save_pretrained(repo_dir)
+    processor.save_pretrained(repo_dir)
+    with open(os.path.join(repo_dir, "metrics.json"), "w") as f:
+        json.dump({"id2label": ID2LABEL, "final": metrics}, f, indent=2)
+
+
+def write_readme(repo_dir, final_m, history, args):
+    rows = "\n".join(
+        f"| {h['epoch']} | {h['train_loss']:.3f} | {h.get('mAP', '-'):.4f} | {h.get('mAP_50', '-'):.4f} | {h['epoch_min']:.1f} |"
+        for h in history
+    )
+    ap_lines = []
+    for name in ID2LABEL.values():
+        key = "AP_{}".format(name.replace("/", "_"))
+        key50 = "AP50_{}".format(name.replace("/", "_"))
+        ap_lines.append("| {} | {:.4f} | {:.4f} |".format(name, final_m.get(key, 0.0), final_m.get(key50, 0.0)))
+    ap_rows = "\n".join(ap_lines)
+    lr_backbone_str = "{:g}".format(args.lr * 0.1)
+    hparams = [
+        ("base model", "`{}`".format(CHECKPOINT)),
+        ("license", "Apache-2.0"),
+        ("dataset", "`{}`".format(DATASET)),
+        ("epochs", str(args.epochs)),
+        ("batch size", str(args.bs)),
+        ("grad accumulation", str(args.accum)),
+        ("effective batch", str(args.bs * args.accum)),
+        ("learning rate (transformer)", str(args.lr)),
+        ("learning rate (backbone)", lr_backbone_str),
+        ("optimizer", "AdamW (weight_decay=1e-4)"),
+        ("scheduler", "cosine w/ linear warmup"),
+        ("warmup steps", "min(500, 10% of steps)"),
+        ("input size", "shortest edge 480-800 / longest 1333 (train), 800/1333 (eval)"),
+        ("amp", "fp16"),
+        ("seed", str(args.seed)),
+    ]
+    hparam_rows = "\n".join("{}: {}".format(k, v) for k, v in hparams)
+    tpl = """---
+license: apache-2.0
+base_model: facebook/detr-resnet-50
+tags:
+- object-detection
+- detr
+- document-layout-analysis
+- newspapers
+- pytorch
+- transformers
+datasets:
+- biglam/loc_beyond_words
+metrics:
+- mAP
+- mAP@0.5
+library_name: transformers
+pipeline_tag: object-detection
+---
+
+# DETR fine-tuned on Beyond Words (loc_beyond_words newspaper layout)
+
+Object-detection model that localises **newspaper page elements** (photographs, headlines,
+advertisements, maps, illustrations, comics/cartoons, editorial cartoons) in scanned newspaper
+pages. Fine-tuned from [facebook/detr-resnet-50](https://huggingface.co/facebook/detr-resnet-50)
+on the [biglam/loc_beyond_words](https://huggingface.co/datasets/biglam/loc_beyond_words) dataset
+(2,846 train / 712 validation images), using 7 classes from the Beyond Words (Library of Congress)
+annotations.
+
+## License & provenance
+
+The base model is **Apache-2.0** licensed, so this fine-tune and its weights are freely
+shareable, modifiable and usable (including commercially) without copyleft restrictions.
+The training dataset biglam/loc_beyond_words is CC0-1.0. Code used for training is included
+on this page.
+
+## Classes
+
+| id | class |
+|----|-------|
+| 0 | Photograph |
+| 1 | Illustration |
+| 2 | Map |
+| 3 | Comics/Cartoon |
+| 4 | Editorial Cartoon |
+| 5 | Headline |
+| 6 | Advertisement |
+
+## Validation results (COCO eval, 712 images)
+
+- **mAP @ [0.5:0.95]**: __MAP__
+- **mAP @ 0.5**: __MAP50__
+- **mAP @ 0.75**: __MAP75__
+- **AR (max 100 dets)**: __AR100__
+
+### Per-class AP
+
+| class | AP | AP@0.5 |
+|-------|----|--------|
+__AP_ROWS__
+
+### Training curve
+
+| epoch | loss | mAP | mAP@0.5 | minutes |
+|-------|------|-----|---------|---------|
+__ROWS__
+
+## Training hyperparameters
+
+__HPARAMS__
+
+## How to use
+
+```python
+from transformers import DetrImageProcessor, DetrForObjectDetection
+from PIL import Image
+import torch
+
+repo = "harness-race/pi-r3"
+processor = DetrImageProcessor.from_pretrained(repo)
+model = DetrForObjectDetection.from_pretrained(repo).eval()
+
+image = Image.open("page.jpg").convert("RGB")
+inputs = processor(images=image, return_tensors="pt")
+with torch.no_grad():
+    out = model(**inputs)
+results = processor.post_process_object_detection(
+    out, threshold=0.5, target_sizes=torch.tensor([[image.size[1], image.size[0]]])
+)[0]
+for box, score, label in zip(results["boxes"], results["scores"], results["labels"]):
+    x1, y1, x2, y2 = [round(v) for v in box.tolist()]
+    print(model.config.id2label[label.item()], score.item(), (x1, y1, x2, y2))
+```
+
+See `inference_examples.png` in the repo for sample predictions (left = ground truth, right = model).
+
+## Notes & limitations
+
+- Class distribution is highly imbalanced (Headline/Advertisement dominate; Map and Editorial
+  Cartoon are rare), so AP for rare classes is lower.
+- DETR uses 100 learned object queries; dense page layouts with more than ~100 elements will be
+  truncated.
+- Images are resized to keep the longest edge <= 1333 px for inference.
+
+## Citations
+
+```bibtex
+@inproceedings{whatever2024beyondwords,
+  title={{Beyond Words}: A Library of Congress Newspaper Element Dataset},
+  ...
+}
+```
+
+```bibtex
+@inproceedings{carion2020end,
+  title={End-to-End Object Detection with Transformers},
+  author={Carion, Nicolas and Massa, Francisco and Synnaeve, Gabriel and Usunier, Nicolas and Kirillov, Alexander and Zagoruyko, Sergey},
+  booktitle={ECCV},
+  year={2020}
+}
+```
+"""
+    readme = (
+        tpl.replace("__MAP__", "{:.4f}".format(final_m.get("mAP", 0.0)))
+        .replace("__MAP50__", "{:.4f}".format(final_m.get("mAP_50", 0.0)))
+        .replace("__MAP75__", "{:.4f}".format(final_m.get("mAP_75", 0.0)))
+        .replace("__AR100__", "{:.4f}".format(final_m.get("AR_100", 0.0)))
+        .replace("__AP_ROWS__", ap_rows)
+        .replace("__ROWS__", rows)
+        .replace("__HPARAMS__", hparam_rows)
+    )
+    os.makedirs(repo_dir, exist_ok=True)
+    with open(os.path.join(repo_dir, "README.md"), "w") as f:
+        f.write(readme)
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--mode", choices=["bench", "train"], default="train")
+    ap.add_argument("--epochs", type=int, default=30)
+    ap.add_argument("--bs", type=int, default=4)
+    ap.add_argument("--accum", type=int, default=4)
+    ap.add_argument("--lr", type=float, default=1e-4)
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--eval-every", type=int, default=5)
+    ap.add_argument("--max-time-min", type=float, default=170)
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--amp", type=int, default=1)
+    ap.add_argument("--repo-id", default="harness-race/pi-r3")
+    ap.add_argument("--repo-dir", default="/out/repo")
+    ap.add_argument("--push", type=int, default=1)
+    args = ap.parse_args()
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"[sys] device={device} torch={torch.__version__} n_gpu={torch.cuda.device_count()}", flush=True)
+    if device.type == "cuda":
+        print(f"[sys] gpu={torch.cuda.get_device_name(0)} mem={torch.cuda.get_device_properties(0).total_memory/1e9:.1f}GB", flush=True)
+
+    if args.mode == "bench":
+        bench(device, args)
+    else:
+        train(device, args)
+
+
+if __name__ == "__main__":
+    main()