r"""Synthetic document pages with structure annotations -> page-level Markdown training records. Input: parquet files with an `image` column and a `json` column holding the page annotation (`page_information`, `element_bboxes` in reading order with types such as heading, paragraph, list, table with cells, formula with LaTeX, caption, figure, header, footer, page_number, watermark). The target is written in the parsing model's own output style (OvisOCR-style document Markdown): - paragraphs separated by a blank line; headings as Markdown headings (`#` per level); - tables as compact HTML `
| .. |
` on a 0-1000 grid;
- running headers, footers and page numbers kept as plain text lines (as the model writes them);
watermarks dropped.
A target is only as good as its match to the model's style: check it with `--validate` first (the base
model's reading of clean pages should agree with the converted target).
python -m common.synth_convert --input "data/raw/synth_OCR/data/*/*.parquet" --out data/prepared/synth \
--per-subset 400 --seed 0
"""
import argparse
import glob
import io
import json
import random
import re
from collections import Counter
from pathlib import Path
from .vlm_utils import write_jsonl
SKIP = {"watermark"}
TEXT_TYPES = {"paragraph", "caption", "footnote", "quote", "stat", "header", "footer", "page_number", "title"}
NUM = re.compile(r"^\s*\d+[.)]\s*")
BULLET = re.compile(r"^\s*[-•·*]\s*")
REPEAT = re.compile(r"(.)\1{40,}|(.{2,12}?)\2{15,}", re.S) # degenerate runs: never train on them
def _cells_html(el):
"""HTML for a table element; cells of each row in visual left-to-right order."""
cells = el.get("cells") or []
if not cells:
return None
rows = {}
for c in cells:
rows.setdefault(c["row"], []).append(c)
head, body = [], []
for r in sorted(rows):
ordered = sorted(rows[r], key=lambda c: c["bbox"][0]) # left edge, left to right
tds = []
for c in ordered:
attrs = ""
if c.get("rowspan", 1) > 1:
attrs += f' rowspan="{c["rowspan"]}"'
if c.get("colspan", 1) > 1:
attrs += f' colspan="{c["colspan"]}"'
tds.append(f"
'
if t == "heading":
return "#" * max(1, min(6, int(el.get("level") or 2))) + " " + _inline(el.get("text"))
if t == "list":
return _list(el)
text = (el.get("text") or "").strip()
return text or None
def page_markdown(ann):
pi = ann["page_information"]
w, h = pi.get("image_width") or pi["width"], pi.get("image_height") or pi["height"]
parts = [element_md(e, w, h) for e in ann["element_bboxes"]]
return "\n\n".join(p for p in parts if p)
GT_CATEGORY = {"paragraph": "text_block", "list": "text_block", "quote": "text_block", "stat": "text_block",
"footnote": "text_block", "heading": "title", "title": "title", "header": "header", "footer": "footer",
"page_number": "page_number", "table": "table", "formula": "equation_isolated", "figure": "figure"}
LANG_NAME = {"ar": "Arabic", "en": "English", "zh": "Chinese"}
IGNORED = {"header", "footer", "page_number"} # no reading-order index, as in the benchmark's own ground truth
def page_gt(ann, image_name):
"""The page in OmniDocBench / MDPBench ground-truth form, so the official scorer can grade readings of it."""
els, dets, order = ann["element_bboxes"], [], 0
for i, e in enumerate(els):
t = e["type"]
if t == "caption":
tgt = e.get("target")
cat = "table_caption" if isinstance(tgt, int) and 0 <= tgt < len(els) and els[tgt]["type"] == "table" \
else "figure_caption"
else:
cat = GT_CATEGORY.get(t)
if cat is None:
continue
x, y, w, h = e["bbox"]
d = {"category_type": cat, "poly": [x, y, x + w, y, x + w, y + h, x, y + h],
"order": None if cat in IGNORED else order, "anno_id": i,
"attribute": {"text_language": LANG_NAME.get((e.get("lang") or ["und"])[0], "Other")},
"text": "", "html": "", "latex": ""}
if cat == "table":
d["html"] = _cells_html(e) or ""
elif cat == "equation_isolated":
d["latex"] = (e.get("latex") or "").strip()
elif cat != "figure":
d["text"] = (e.get("text") or "").strip() if t != "heading" else _inline(e.get("text"))
if cat not in IGNORED:
order += 1
dets.append(d)
lang = page_language(ann)
return {"layout_dets": dets, "extra": {"relation": []},
"page_info": {"image_path": image_name, "page_attribute": {"language": LANG_NAME.get(lang, "Other")}}}
def page_language(ann):
c = Counter(l for e in ann["element_bboxes"] for l in e.get("lang", []))
return c.most_common(1)[0][0] if c else "und"
def line_height(ann):
"""Median text-line height in image pixels: below ~16 px Arabic dots and diacritics are barely resolved,
and training on text the model cannot see teaches it to guess."""
hs = sorted(l["bbox"][3] for l in ann.get("line_bboxes", []) if l.get("bbox") and l["bbox"][3] > 0)
return hs[len(hs) // 2] if hs else 0.0
def page_id(subset, parquet_file, ann, fallback):
"""Unique per page: subset, shard number (train-00002-of-00008 -> 00002) and the page id in the shard."""
stem = Path(parquet_file).stem
m = re.match(r".*?-(\d+)-of-\d+$", stem)
shard = m.group(1) if m else stem
return f"synth_{subset}_{shard}_{ann['page_information'].get('id', fallback)}"
def effects(ann):
pi = ann["page_information"]
return "photo" if pi.get("photo") else "scan" if pi.get("scan") else "clean"
def main(argv=None):
ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
ap.add_argument("--input", required=True, help="glob of parquet files (subset = parent folder name)")
ap.add_argument("--out", required=True, help="folder for images/ and synth.jsonl")
ap.add_argument("--per-subset", type=int, default=0, help="pages per subset (0 = all)")
ap.add_argument("--only-clean", action="store_true", help="no photo / scan effects (for --validate sets)")
ap.add_argument("--languages", nargs="*", help="keep pages whose main language is one of these")
ap.add_argument("--min-line-px", type=float, default=0.0,
help="drop pages whose median text-line height is below this many image pixels (e.g. 16)")
ap.add_argument("--skip-subsets", nargs="*", default=[],
help="subset folders to leave out (e.g. receipts, whose key-value blocks are labelled as tables)")
ap.add_argument("--seed", type=int, default=0)
ap.add_argument("--bench", help="also write a benchmark subset of this name (gt.json + items.jsonl) for "
"`python -m common.mdpbench score`; page ids get a language prefix (ar_...)")
a = ap.parse_args(argv)
import pyarrow.parquet as pq
out = Path(a.out)
(out / "images").mkdir(parents=True, exist_ok=True)
by_subset = {}
for f in sorted(glob.glob(a.input)):
if Path(f).parent.name not in a.skip_subsets:
by_subset.setdefault(Path(f).parent.name, []).append(f)
rng = random.Random(a.seed)
records, dropped, gts, seen = [], Counter(), [], set()
for sub, files in sorted(by_subset.items()):
kept = 0
files = files[:]
rng.shuffle(files)
for f in files:
pf = pq.ParquetFile(f)
for batch in pf.iter_batches(batch_size=32):
for row in batch.to_pylist():
if a.per_subset and kept >= a.per_subset:
break
ann = json.loads(row["json"])
if a.only_clean and effects(ann) != "clean":
continue
lang = page_language(ann)
if a.languages and lang not in a.languages:
continue
lh = line_height(ann)
if lh < a.min_line_px:
dropped["text too small"] += 1
continue
text = page_markdown(ann)
if not text.strip():
dropped["empty"] += 1
continue
if REPEAT.search(text):
dropped["repetition"] += 1
continue
pid = page_id(sub, f, ann, kept)
if pid in seen:
raise SystemExit(f"duplicate page id {pid}: ids must be unique across shards")
seen.add(pid)
img = out / "images" / f"{pid}.png"
if not img.exists():
img.write_bytes(row["image"]["bytes"])
records.append({"id": pid, "image": str(img.resolve()), "text": text, "source": f"synth_OCR/{sub}",
"license": "see dataset card", "language": lang, "level": "page", "split": "train",
"effects": effects(ann), "template": ann["page_information"].get("template"),
"line_px": round(lh, 1)})
if a.bench:
gts.append(page_gt(ann, f"{lang}_{pid}.png"))
kept += 1
if a.per_subset and kept >= a.per_subset:
break
if a.per_subset and kept >= a.per_subset:
break
print(f"{sub}: {kept} pages", flush=True)
write_jsonl(out / "synth.jsonl", records)
if a.bench:
from .mdpbench import BENCH_DIR
d = BENCH_DIR / "subsets" / a.bench
d.mkdir(parents=True, exist_ok=True)
(d / "gt.json").write_text(json.dumps(gts, ensure_ascii=False), encoding="utf-8")
write_jsonl(d / "items.jsonl", [{"id": f"{r['language']}_{r['id']}", "image": r["image"], "text": "",
"level": "page", "language": r["language"]} for r in records])
print(f"benchmark subset {a.bench}: {len(gts)} pages -> {d}")
langs = Counter(r["language"] for r in records)
print(f"{len(records)} records -> {out / 'synth.jsonl'} | languages {dict(langs)} | dropped {dict(dropped)}")
if __name__ == "__main__":
main()