| """Make the example predictions: the ground truth of the first N images of a split and |
| predictions built from it, each showing what one kind of error costs. |
| |
| python make_examples.py <variant>/val examples/ [--n 300] |
| |
| Writes ``examples/gt.jsonl``, ``examples/prompts.jsonl`` (the ground truth as prompt text) and |
| one ``examples/pred/<name>.jsonl`` per kind (seed 0): |
| |
| - ``same``: the ground truth, vertex ids renamed and vertices shuffled. |
| - ``no_text``: ``same`` with every text removed (names, descriptions). |
| - ``jitter_05`` / ``jitter_15``: every box shifted by a normal 5% / 15% of its size. |
| - ``flat``: every vertex hung directly off the image (relations kept). |
| - ``no_relations``: every relation removed. |
| - ``prompt_roundtrip``: the ground truth written as prompt text and read back |
| (``prompt_to_graph.py --types infer``), the best a prompt-text model can reach. |
| - ``other_image``: each image given another image's graph. |
| - ``half_missing``: predictions for every other image only. |
| """ |
|
|
| import argparse |
| import copy |
| import json |
| import random |
| from pathlib import Path |
|
|
| from kohakugbc_data import PromptDag |
| from kohakugbc_data.dataset import GbcDataset |
|
|
| from prompt_to_graph import to_graph |
|
|
|
|
| def rename(g: dict, rnd: random.Random, text: bool) -> dict: |
| """``g`` with new vertex ids, shuffled vertices, and its texts kept or dropped.""" |
| names = {v["vertex_id"]: f"v{k}" for k, v in enumerate(g["vertices"])} |
| out = [] |
| for v in g["vertices"]: |
| edges = [{"target": names[e["target"]], **({"text": e["text"]} if text else {})} |
| for e in v["out_edges"]] |
| out.append({"vertex_id": names[v["vertex_id"]], "label": v["label"], "bbox": v["bbox"], |
| "descs": v["descs"] if text else [], "out_edges": edges}) |
| rnd.shuffle(out) |
| return {"vertices": out} |
|
|
|
|
| def jitter(g: dict, rnd: random.Random, sigma: float) -> dict: |
| g = copy.deepcopy(g) |
| for v in g["vertices"]: |
| if v["label"] in ("entity", "composition"): |
| b = v["bbox"] |
| w, h = b["right"] - b["left"], b["bottom"] - b["top"] |
| dx, dy = rnd.gauss(0, sigma) * w, rnd.gauss(0, sigma) * h |
| v["bbox"] = {"left": b["left"] + dx, "top": b["top"] + dy, "right": b["right"] + dx, |
| "bottom": b["bottom"] + dy, "confidence": None} |
| return g |
|
|
|
|
| def flat(g: dict) -> dict: |
| g = copy.deepcopy(g) |
| by = {v["vertex_id"]: v for v in g["vertices"]} |
| plain = [v["vertex_id"] for v in g["vertices"] if v["label"] in ("entity", "composition")] |
| name = {} |
| for v in g["vertices"]: |
| for e in v["out_edges"]: |
| if e.get("text"): |
| name.setdefault(e["target"], e["text"]) |
| for v in g["vertices"]: |
| if v["label"] == "relation": |
| continue |
| keep = [e for e in v["out_edges"] if by[e["target"]]["label"] == "relation"] |
| if v["label"] == "image": |
| keep += [{"target": t, "text": name.get(t, "")} for t in plain] |
| v["out_edges"] = keep |
| return g |
|
|
|
|
| def no_relations(g: dict) -> dict: |
| g = copy.deepcopy(g) |
| rel = {v["vertex_id"] for v in g["vertices"] if v["label"] == "relation"} |
| g["vertices"] = [v for v in g["vertices"] if v["vertex_id"] not in rel] |
| for v in g["vertices"]: |
| v["out_edges"] = [e for e in v["out_edges"] if e["target"] not in rel] |
| return g |
|
|
|
|
| def write(path: Path, rows: list) -> None: |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with open(path, "w", encoding="utf-8") as f: |
| f.writelines(json.dumps(r, ensure_ascii=False) + "\n" for r in rows) |
|
|
|
|
| def main() -> None: |
| ap = argparse.ArgumentParser() |
| ap.add_argument("split_dir") |
| ap.add_argument("out") |
| ap.add_argument("--n", type=int, default=300) |
| a = ap.parse_args() |
| out = Path(a.out) |
| ds = GbcDataset(a.split_dir, image=None, meta=False) |
| samples = [ds[i] for i in range(min(a.n, len(ds)))] |
| keys = [s.key for s in samples] |
| gts = [json.loads(s.graph.to_json()) for s in samples] |
| prompts = [s.graph.prompt(width=s.w, height=s.h) for s in samples] |
| write(out / "gt.jsonl", [{"key": k, "graph": g} for k, g in zip(keys, gts, strict=True)]) |
| write(out / "prompts.jsonl", |
| [{"key": k, "prompt": p} for k, p in zip(keys, prompts, strict=True)]) |
|
|
| rnd = random.Random(0) |
| preds = { |
| "same": [rename(g, rnd, True) for g in gts], |
| "no_text": [rename(g, rnd, False) for g in gts], |
| "jitter_05": [rename(jitter(g, rnd, 0.05), rnd, True) for g in gts], |
| "jitter_15": [rename(jitter(g, rnd, 0.15), rnd, True) for g in gts], |
| "flat": [rename(flat(g), rnd, True) for g in gts], |
| "no_relations": [rename(no_relations(g), rnd, True) for g in gts], |
| "prompt_roundtrip": [to_graph(PromptDag.parse(p).to_dict(), "infer") for p in prompts], |
| "other_image": [rename(gts[(k + 1) % len(gts)], rnd, True) for k in range(len(gts))], |
| } |
| for name, graphs in preds.items(): |
| write(out / "pred" / f"{name}.jsonl", |
| [{"key": k, "graph": g} for k, g in zip(keys, graphs, strict=True)]) |
| half = list(zip(keys, preds["same"], strict=True))[::2] |
| write(out / "pred" / "half_missing.jsonl", [{"key": k, "graph": g} for k, g in half]) |
| print(f"{len(keys)} images, {len(preds) + 1} predictions -> {out}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
