| """Write the phase 1 data report: what was fetched and verified, what is inside,
|
| and how that compares with what the reference engines trained on.
|
|
|
| usage: python data/report.py
|
|
|
| Reads data/manifests/phase1/*.json (fetch.py) and
|
| data/reports/phase1/profile/*.json (profile.py); writes
|
| data/reports/phase1/REPORT.md and summary.json.
|
| """
|
| import json
|
| from datetime import datetime, timezone
|
| from pathlib import Path
|
|
|
| from sources import SOURCES
|
|
|
| HERE = Path(__file__).resolve().parent
|
| MANIFESTS = HERE / "manifests" / "phase1"
|
| PROFILES = HERE / "reports" / "phase1" / "profile"
|
| OUT = HERE / "reports" / "phase1"
|
|
|
|
|
| REFERENCES = {
|
| "synthetic text": [
|
| ("Tesseract 4/5", "about 400 k rendered lines in about 4,500 fonts (Latin)",
|
| "https://tesseract-ocr.github.io/tessdoc/tess4/TrainingTesseract-4.00.html"),
|
| ("PP-OCRv3", "11.5 M synthetic recognition lines (of 18.5 M)", "https://arxiv.org/abs/2206.03001"),
|
| ("TrOCR", "17.9 M synthetic handwritten lines in 5,427 fonts; MJ + ST", "https://arxiv.org/abs/2109.10282"),
|
| ("Nemotron OCR v2", "about 11 M synthetic pages in 6 languages",
|
| "https://huggingface.co/nvidia/nemotron-ocr-v2"),
|
| ],
|
| "born-digital PDFs": [
|
| ("TrOCR", "684 M printed lines from 2 M digital-born PDF pages", "https://arxiv.org/abs/2109.10282"),
|
| ("PP-OCRv5", "labels parsed from PDFs and e-books", "https://arxiv.org/abs/2507.05595"),
|
| ("olmOCR 2", "268 k PDF pages with VLM transcriptions", "https://arxiv.org/abs/2510.19817"),
|
| ],
|
| "real text in images": [
|
| ("PARSeq", "3.3 M real scene-text crops", "https://arxiv.org/abs/2207.06966"),
|
| ("PP-OCRv3", "7 M real recognition lines; 68 k real detection images", "https://arxiv.org/abs/2206.03001"),
|
| ("Nemotron OCR v2", "about 680 k real images", "https://huggingface.co/nvidia/nemotron-ocr-v2"),
|
| ],
|
| "layout and reading order": [
|
| ("PP-DocLayout", "30 k images, 23 classes (incl. DocLayNet, PubLayNet)", "https://arxiv.org/abs/2503.17213"),
|
| ("Nemotron OCR v2", "a reading-order graph on its synthetic pages",
|
| "https://huggingface.co/datasets/nvidia/OCR-Synthetic-Multilingual-v1"),
|
| ],
|
| "handwriting": [
|
| ("TrOCR", "17.9 M synthetic lines, then IAM (6,161 lines)", "https://arxiv.org/abs/2109.10282"),
|
| ("PP-OCRv5", "handwriting auto-labelled with ERNIE-4.5-VL", "https://arxiv.org/abs/2507.05595"),
|
| ],
|
| }
|
|
|
|
|
| def load(dirpath):
|
| out = {}
|
| for p in sorted(dirpath.glob("*.json")):
|
| out[p.stem] = json.loads(p.read_text(encoding="utf-8"))
|
| return out
|
|
|
|
|
| def gb(n):
|
| return f"{n / 2 ** 30:.1f}"
|
|
|
|
|
| def fmt(n):
|
| if n is None:
|
| return "?"
|
| if n >= 1e9:
|
| return f"{n / 1e9:.2f} B"
|
| if n >= 1e6:
|
| return f"{n / 1e6:.1f} M"
|
| if n >= 1e3:
|
| return f"{n / 1e3:.1f} k"
|
| return str(n)
|
|
|
|
|
| def get(d, *keys, default=None):
|
| for k in keys:
|
| if not isinstance(d, dict) or k not in d:
|
| return default
|
| d = d[k]
|
| return d
|
|
|
|
|
| def measured(prof):
|
| """The handful of numbers the comparison needs, from the profiles."""
|
| p = {k: v.get("profile", {}) for k, v in prof.items()}
|
| m = {}
|
| nv = p.get("nvidia-ocr-synthetic", {})
|
| m["nvidia_pages"] = sum(v.get("samples", 0) for v in nv.values())
|
| m["nvidia_lines"] = sum(v.get("lines_total", 0) for v in nv.values())
|
| m["nvidia_order_share"] = min((v.get("with_reading_order_share", 0) for v in nv.values()), default=None)
|
| g = p.get("fonts-google", {})
|
| m["google_families"] = g.get("families")
|
| m["google_by_category"] = g.get("by_category")
|
| m["latin_cov"] = g.get("latin_full_coverage_share")
|
| m["noto_families"] = get(p, "fonts-noto", "families")
|
| m["text_chars"] = sum(get(p, k, "characters", default=0) or 0 for k in ("wikipedia", "fineweb-2", "finepdfs"))
|
| m["text_docs"] = sum(get(p, k, "documents", default=0) or 0 for k in ("wikipedia", "fineweb-2", "finepdfs"))
|
| m["doclaynet_pages"] = get(p, "doclaynet", "pages")
|
| m["doclaynet_cells"] = get(p, "doclaynet", "text_cells")
|
| m["hiertext_lines"] = sum(get(p, "hiertext", s, "lines", default=0) or 0 for s in ("train", "validation"))
|
| m["hiertext_words"] = sum(get(p, "hiertext", s, "words", default=0) or 0 for s in ("train", "validation"))
|
| m["textocr_words"] = sum((get(p, "textocr", s, "words", default=0) or 0) - (get(p, "textocr", s, "illegible",
|
| default=0) or 0) for s in ("train", "val"))
|
| m["gt4_lines"] = get(p, "gt4histocr", "lines")
|
| m["gnhk_pages"] = get(p, "gnhk", "rows")
|
| pdf_pages = 0
|
| for k in ("pmc-oa", "arxiv"):
|
| pdf_pages += get(p, k, "pages_total_in_read_docs", default=0) or 0
|
| m["pdfa_pages"] = get(p, "pdfa-eng", "pages_total")
|
| m["pdfa_docs"] = get(p, "pdfa-eng", "documents")
|
| m["pmc_pdfs"] = get(p, "pmc-oa", "pdfs")
|
| m["arxiv_pdfs"] = get(p, "arxiv", "pdfs")
|
| m["govdocs_files"] = get(p, "govdocs1", "files_in_piece")
|
| m["sampled_pdf_pages"] = pdf_pages
|
| return m
|
|
|
|
|
| def main():
|
| man, prof = load(MANIFESTS), load(PROFILES)
|
|
|
| rows, total_plan, total_got, files, verified, unverified, failed = [], 0, 0, 0, 0, 0, []
|
| for s in SOURCES:
|
| mf = man.get(s["name"])
|
| total_plan += s["expected_bytes"]
|
| if not mf:
|
| rows.append(f"| `{s['name']}` | {s['group']} | {s['use']} | {gb(s['expected_bytes'])} | not fetched | | | |")
|
| continue
|
| total_got += mf["bytes"]
|
| files += mf["file_count"]
|
| verified += mf["verified_files"]
|
| unverified += mf["unverified_files"]
|
| failed += [(s["name"], f) for f in mf["failed_files"]]
|
| checks = sorted({next(iter(f.get("upstream") or {"none": 0})) for f in mf["files"]} - {"none"}) or \
|
| sorted({f.get("check", "") for f in mf["files"]})
|
| state = "error: " + mf["error"][:60] if mf.get("error") else \
|
| f"{mf['verified_files']}/{mf['file_count']} verified" + (
|
| f", {mf['unverified_files']} slices" if mf["unverified_files"] else "")
|
| rows.append(f"| `{s['name']}` | {s['group']} | {s['use']} | {gb(s['expected_bytes'])} | {gb(mf['bytes'])} | "
|
| f"{mf['file_count']:,} | {state} | {', '.join(checks)} |")
|
|
|
| m = measured(prof)
|
| summary = dict(generated_at=datetime.now(timezone.utc).isoformat(timespec="seconds"),
|
| sources=len(SOURCES), fetched=len(man), planned_bytes=total_plan, fetched_bytes=total_got,
|
| files=files, verified_files=verified, unverified_files=unverified, failed_checks=failed,
|
| measured=m)
|
| (OUT / "summary.json").write_text(json.dumps(summary, indent=1), encoding="utf-8")
|
|
|
| cov = m.get("latin_cov") or {}
|
| cats = m.get("google_by_category") or {}
|
| L = []
|
| L.append("# Phase 1 data: verification and profile\n")
|
| L.append(f"Generated {summary['generated_at']} by `scripts/report.py` from the manifests "
|
| f"(`manifests/phase1/`) and profiles (`reports/phase1/profile/`). "
|
| "The manifest lists every file's URL, size and SHA-256, so the set can be fetched again and "
|
| "checked byte for byte.\n")
|
| L.append("## 1. What was fetched\n")
|
| L.append(f"- **Sources:** {len(man)} of {len(SOURCES)}")
|
| L.append(f"- **Size:** {gb(total_got)} GB fetched, against {gb(total_plan)} GB planned")
|
| L.append(f"- **Files:** {files:,} in all")
|
| L.append(f" - {verified:,} match the checksum or size their source publishes")
|
| L.append(f" - {unverified:,} are re-encoded slices of larger files, with no upstream checksum to compare")
|
| L.append(f" - {len(failed)} failed a check" + (": " + ", ".join(f"{a}/{b}" for a, b in failed[:10]) if failed else ""))
|
| L.append("\n| source | kind | use | planned GB | fetched GB | files | state | checked against |")
|
| L.append("|---|---|---|---|---|---|---|---|")
|
| L += rows
|
| L.append("\nUse: T trains shipped weights, E evaluation only (never trained or tuned on), "
|
| "check licence to be confirmed before training.\n")
|
|
|
| L.append("## 2. What is inside\n")
|
| L.append("| kind | measured |")
|
| L.append("|---|---|")
|
| L.append(f"| fonts | {fmt(m['google_families'])} Google Fonts families "
|
| f"({', '.join(f'{k.lower()} {v}' for k, v in sorted(cats.items(), key=lambda x: -x[1]))}); "
|
| f"{fmt(m['noto_families'])} Noto families |")
|
| if cov:
|
| L.append(f"| Latin glyph coverage (Google Fonts with Latin) | full Latin-1 {cov.get('latin1', 0):.0%}, "
|
| f"Latin Extended-A {cov.get('latin_ext_a', 0):.0%}, Vietnamese {cov.get('vietnamese', 0):.0%}, "
|
| f"Yoruba {cov.get('yoruba', 0):.0%} of families |")
|
| L.append(f"| text corpora | {fmt(m['text_docs'])} documents, {fmt(m['text_chars'])} characters |")
|
| L.append(f"| NVIDIA synthetic (en, ru) | {fmt(m['nvidia_pages'])} pages, {fmt(m['nvidia_lines'])} lines with boxes |")
|
| L.append(f"| DocLayNet | {fmt(m['doclaynet_pages'])} pages with layout labels; {fmt(m['doclaynet_cells'])} PDF text cells "
|
| f"inside the boxes |")
|
| L.append(f"| HierText | {fmt(m['hiertext_lines'])} lines, {fmt(m['hiertext_words'])} words |")
|
| L.append(f"| TextOCR | {fmt(m['textocr_words'])} legible words |")
|
| L.append(f"| GT4HistOCR | {fmt(m['gt4_lines'])} historical print lines |")
|
| L.append(f"| GNHK | {fmt(m['gnhk_pages'])} handwritten pages |")
|
| L.append(f"| born-digital PDFs | PDFA {fmt(m['pdfa_docs'])} documents ({fmt(m['pdfa_pages'])} pages); "
|
| f"PMC {fmt(m['pmc_pdfs'])} PDFs; arXiv {fmt(m['arxiv_pdfs'])} PDFs; govdocs1 {fmt(m['govdocs_files'])} "
|
| "files in the first piece |")
|
| L.append("\nPer-source detail (character sets, scripts, line geometry, text-layer coverage) is in "
|
| "`profile/<source>.json`.\n")
|
|
|
| L.append("## 3. Against what the reference engines trained on\n")
|
| ours = {
|
| "synthetic text": f"{fmt(m['nvidia_pages'])} synthetic pages with {fmt(m['nvidia_lines'])} lines (NVIDIA, en "
|
| f"and ru); {fmt(m['google_families'])} + {fmt(m['noto_families'])} font families and "
|
| f"{fmt(m['text_chars'])} characters of text to render without limit",
|
| "born-digital PDFs": f"{fmt(m['pdfa_pages'])} PDFA pages with text-layer boxes; {fmt(m['pmc_pdfs'])} PMC and "
|
| f"{fmt(m['arxiv_pdfs'])} arXiv PDFs; govdocs1",
|
| "real text in images": f"{fmt(m['hiertext_words'])} HierText and {fmt(m['textocr_words'])} TextOCR words",
|
| "layout and reading order": f"{fmt(m['doclaynet_pages'])} DocLayNet pages; reading-order graphs on "
|
| f"{(m['nvidia_order_share'] or 0):.0%} of the NVIDIA pages",
|
| "handwriting": f"{fmt(m['gnhk_pages'])} GNHK pages (IAM is evaluation only)",
|
| }
|
| L.append("| data kind | reference engines | Fullerene's training data (measured) |")
|
| L.append("|---|---|---|")
|
| for kind, refs in REFERENCES.items():
|
| L.append(f"| {kind} | " + "<br>".join(f"{n}: {d}" for n, d, _ in refs) + f" | {ours[kind]} |")
|
| L.append("")
|
| L.append("## 4. Gaps and what to do about them\n")
|
| L.append("- **Handwriting is the thinnest kind.** GNHK alone is hundreds of pages, against TrOCR's 17.9 M synthetic "
|
| "lines and the real handwritten sets the other engines name. What closes the gap: handwriting-style "
|
| "fonts for pretraining, permissively licensed handwriting sets, VLM transcription with alignment, and "
|
| "hand labels.")
|
| L.append("- **Synthetic lines are unlimited.** The fonts and text fetched here are rendered into as many lines as training needs, 10 to 20 M, so those lines need no download.")
|
| L.append("- **Born-digital pages are plentiful.** One PDFA shard holds thousands of documents, and the 1,800 shards "
|
| "reach millions of pages, the same kind of data that gave TrOCR its 684 M lines.")
|
| L.append("- **Real text in images is close to PARSeq's real set in kind, smaller in count.** HierText and TextOCR "
|
| "together give the real words the detector and recognizer need for photographed pages.")
|
| L.append("- **Reading order** comes from NVIDIA's graphs, the PDF text layer and DocLayNet's layout. Human-labelled "
|
| "order (ReadingBank) needs its license checked first.")
|
| (OUT / "REPORT.md").write_text("\n".join(L) + "\n", encoding="utf-8")
|
| print(f"wrote {OUT / 'REPORT.md'}")
|
| print(json.dumps({k: v for k, v in summary.items() if k != "measured"}, indent=1))
|
|
|
|
|
| if __name__ == "__main__":
|
| main()
|
|
|
