Download OCR_INDRA/tools/indra_eval/make_docx.py from prosperious/ocr-projects-archive: direct link, hf CLI and curl.
- Browser
- Download file 32 kB
-
https://huggingface.co/prosperious/ocr-projects-archive/resolve/main/OCR_INDRA/tools/indra_eval/make_docx.py
- Command line
-
hf download hf://prosperious/ocr-projects-archive/OCR_INDRA/tools/indra_eval/make_docx.py
-
curl -L -o make_docx.py https://huggingface.co/prosperious/ocr-projects-archive/resolve/main/OCR_INDRA/tools/indra_eval/make_docx.py
32 kB
| """Build the complete Indra-OCR x Nepali investigation report as a .docx. | |
| Assembles: cover + executive summary (fresh), the full contents of | |
| docs/INDRA_INVESTIGATION.md, docs/INDRA_EXPERIMENTS.md, logs/investigation.md, | |
| auto-generated smoke-results tables (results/smoke/*.json + GT records), and | |
| an appendix (artifact inventory, dependency versions, reproduce commands). | |
| Run: PYTHONPATH=/tmp/opencode/indra-lib python3 tools/indra_eval/make_docx.py | |
| Out: INDRA_OCR_NEPALI_COMPLETE_REPORT.docx (workspace root) | |
| """ | |
| from __future__ import annotations | |
| import json | |
| import os | |
| import re | |
| import sys | |
| import unicodedata | |
| from pathlib import Path | |
| ROOT = Path(__file__).resolve().parents[2] | |
| sys.path.insert(0, "/tmp/opencode/indra-lib") | |
| from docx import Document # noqa: E402 | |
| from docx.enum.text import WD_ALIGN_PARAGRAPH # noqa: E402 | |
| from docx.oxml import OxmlElement # noqa: E402 | |
| from docx.oxml.ns import qn # noqa: E402 | |
| from docx.shared import Pt, RGBColor, Cm # noqa: E402 | |
| OUT = ROOT / "INDRA_OCR_NEPALI_COMPLETE_REPORT.docx" | |
| # ---------------------------------------------------------------- md parser -- | |
| def parse_md(md: str): | |
| """Yield blocks: ('h',lvl,'..') | ('p','..') | ('li',kind,bool_nested,'..') | |
| | ('code',[lines]) | ('table',[rows]) | ('hr',)""" | |
| lines = md.splitlines() | |
| i, out = 0, [] | |
| while i < len(lines): | |
| ln = lines[i] | |
| if ln.startswith("```"): | |
| j, code = i + 1, [] | |
| while j < len(lines) and not lines[j].startswith("```"): | |
| code.append(lines[j]) | |
| j += 1 | |
| out.append(("code", code)) | |
| i = j + 1 | |
| continue | |
| if ln.strip() == "": | |
| i += 1 | |
| continue | |
| if ln.strip() == "---": | |
| out.append(("hr",)) | |
| i += 1 | |
| continue | |
| m = re.match(r"^(#{1,4})\s+(.*)$", ln) | |
| if m: | |
| out.append(("h", len(m.group(1)), m.group(2))) | |
| i += 1 | |
| continue | |
| if ln.lstrip().startswith("|"): | |
| rows = [] | |
| while i < len(lines) and lines[i].lstrip().startswith("|"): | |
| rows.append(lines[i].strip()) | |
| i += 1 | |
| out.append(("table", rows)) | |
| continue | |
| m = re.match(r"^(\s*)([-*])\s+(.*)$", ln) | |
| if m: | |
| out.append(("li", "bullet", len(m.group(1)) >= 2, m.group(3))) | |
| i += 1 | |
| continue | |
| m = re.match(r"^(\s*)(\d+)\.\s+(.*)$", ln) | |
| if m: | |
| out.append(("li", "number", len(m.group(1)) >= 2, m.group(3))) | |
| i += 1 | |
| continue | |
| if ln.startswith(" ") and out and out[-1][0] in ("li", "p") and len(ln) - len(ln.lstrip()) >= 2 and ln.lstrip()[:2] != "- ": | |
| # continuation of a list item / hanging paragraph | |
| out.append(("cont", ln.strip())) | |
| i += 1 | |
| continue | |
| out.append(("p", ln)) | |
| i += 1 | |
| return out | |
| # --------------------------------------------------------------- docx glue -- | |
| def cs_font(run): | |
| """Complex-script font so Devanagari renders consistently in Word.""" | |
| rpr = run._element.get_or_add_rPr() | |
| rf = rpr.find(qn("w:rFonts")) | |
| if rf is None: | |
| rf = OxmlElement("w:rFonts") | |
| rpr.append(rf) | |
| rf.set(qn("w:cs"), "Nirmala UI") | |
| def shade(par, fill="F4F4F4"): | |
| ppr = par._p.get_or_add_pPr() | |
| shd = OxmlElement("w:shd") | |
| shd.set(qn("w:val"), "clear") | |
| shd.set(qn("w:color"), "auto") | |
| shd.set(qn("w:fill"), fill) | |
| ppr.append(shd) | |
| TOK = re.compile(r"(\*\*[^*]+\*\*|`[^`]+`|\*[^*]+\*)") | |
| def add_runs(par, text, size=None, base_bold=False): | |
| for tok in TOK.split(text): | |
| if not tok: | |
| continue | |
| if tok.startswith("**") and tok.endswith("**") and len(tok) > 4: | |
| r = par.add_run(tok[2:-2]) | |
| r.bold = True | |
| cs_font(r) | |
| elif tok.startswith("`") and tok.endswith("`") and len(tok) > 2: | |
| r = par.add_run(tok[1:-1]) | |
| r.font.name = "Consolas" | |
| r.font.size = Pt((size or 10.5) - 1) | |
| cs_font(r) | |
| elif tok.startswith("*") and tok.endswith("*") and len(tok) > 2: | |
| r = par.add_run(tok[1:-1]) | |
| r.italic = True | |
| cs_font(r) | |
| else: | |
| r = par.add_run(tok) | |
| r.bold = base_bold or None | |
| cs_font(r) | |
| if size: | |
| for r in par.runs: | |
| pass | |
| # normalize size on all runs of this paragraph if requested | |
| if size: | |
| for r in par.runs: | |
| if r.font.size is None: | |
| r.font.size = Pt(size) | |
| def add_table(doc, rows, size=9): | |
| vals = [] | |
| for r in rows: | |
| if isinstance(r, str): # raw markdown row "| a | b |" | |
| if re.match(r"^\|[\s:|-]+\|$", r.replace(" ", "")): | |
| continue # separator row | |
| cells = [c.strip() for c in r.strip().strip("|").split("|")] | |
| else: | |
| cells = [str(c) for c in r] | |
| vals.append(cells) | |
| if not vals: | |
| return | |
| ncol = max(len(v) for v in vals) | |
| t = doc.add_table(rows=len(vals), cols=ncol) | |
| t.style = "Table Grid" | |
| for ri, row in enumerate(vals): | |
| for ci in range(ncol): | |
| cell = t.cell(ri, ci) | |
| text = row[ci] if ci < len(row) else "" | |
| par = cell.paragraphs[0] | |
| add_runs(par, text, size=size, base_bold=(ri == 0)) | |
| par.paragraph_format.space_after = Pt(2) | |
| def render_md(doc, md, first_h1_prefix=""): | |
| """Render markdown under the doc, # (first) -> Heading 1 (with prefix).""" | |
| blocks = parse_md(md) | |
| seen_h1 = False | |
| for b in blocks: | |
| kind = b[0] | |
| if kind == "h": | |
| lvl, text = b[1], b[2] | |
| if lvl == 1: | |
| if seen_h1: | |
| continue # only one H1 per part | |
| seen_h1 = True | |
| text = first_h1_prefix + text | |
| h = doc.add_heading(text, level=1) # used only for Part titles | |
| for r in h.runs: | |
| r.font.color.rgb = RGBColor(0x1F, 0x3B, 0x63) | |
| continue | |
| h = doc.add_heading("", level=lvl) | |
| add_runs(h, text) | |
| for r in h.runs: | |
| r.font.color.rgb = RGBColor(0x22, 0x35, 0x52) | |
| elif kind == "p": | |
| par = doc.add_paragraph() | |
| par.paragraph_format.space_after = Pt(4) | |
| add_runs(par, b[1]) | |
| elif kind == "cont": | |
| par = doc.paragraphs[-1] | |
| par.add_run("\n" + b[1]) | |
| elif kind == "li": | |
| _, lk, nested, text = b | |
| style = "List Bullet" if lk == "bullet" else "List Number" | |
| if nested: | |
| style += " 2" if lk == "bullet" else "" | |
| par = doc.add_paragraph(style=style) | |
| par.paragraph_format.space_after = Pt(2) | |
| add_runs(par, text) | |
| elif kind == "code": | |
| for ln in b[1]: | |
| par = doc.add_paragraph() | |
| par.paragraph_format.space_after = Pt(0) | |
| par.paragraph_format.space_before = Pt(0) | |
| r = par.add_run(ln if ln else " ") | |
| r.font.name = "Consolas" | |
| r.font.size = Pt(8.5) | |
| cs_font(r) | |
| shade(par) | |
| doc.add_paragraph().paragraph_format.space_after = Pt(4) | |
| elif kind == "table": | |
| add_table(doc, b[1]) | |
| doc.add_paragraph().paragraph_format.space_after = Pt(4) | |
| elif kind == "hr": | |
| continue | |
| def lev(a: str, b: str) -> int: | |
| if a == b: | |
| return 0 | |
| prev = list(range(len(b) + 1)) | |
| for i, ca in enumerate(a, 1): | |
| cur = [i] + [0] * len(b) | |
| for j, cb in enumerate(b, 1): | |
| cur[j] = min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (ca != cb)) | |
| prev = cur | |
| return prev[-1] | |
| # ------------------------------------------------------------------ report -- | |
| def main(): | |
| doc = Document() | |
| for sec in doc.sections: | |
| sec.top_margin = sec.bottom_margin = Cm(2.0) | |
| sec.left_margin = sec.right_margin = Cm(2.2) | |
| st = doc.styles["Normal"] | |
| st.font.name = "Calibri" | |
| st.font.size = Pt(10.5) | |
| cp = doc.core_properties | |
| cp.title = "Indra OCR Γ Nepali (Devanagari) β Complete Engineering Investigation" | |
| cp.author = "OCR_INDRA investigation" | |
| cp.subject = "datalab-to/indra v0.3.2 / model revision v3.1.1 β evidence-based feasibility, adaptation and evaluation" | |
| cp.comments = "All claims verified from source (commit 3d773ae) and model artifacts (ONNX + safetensors), not from README." | |
| # ---- cover ---- | |
| doc.add_heading("Indra OCR Γ Nepali (Devanagari)", level=0) | |
| p = doc.add_paragraph() | |
| r = p.add_run("Complete Engineering Investigation Report") | |
| r.font.size = Pt(16) | |
| r.font.color.rgb = RGBColor(0x33, 0x33, 0x33) | |
| meta = doc.add_paragraph() | |
| add_runs( | |
| meta, | |
| "Package: `datalab-to/indra` v0.3.2 (commit `3d773ae`) Β· Model set: " | |
| "HF revision `v3.1.1` Β· Workspace: `OCR_INDRA/` Β· Date: 2026-10-17 " | |
| "(rev. 2026-10-20: fine-tune toolkit verified offline; bundle rebuilt)", | |
| size=10, | |
| ) | |
| doc.add_paragraph() | |
| add_runs( | |
| doc.add_paragraph(), | |
| "Method: every architecture claim in this report is verified against the " | |
| "actual artifacts β the cloned source (all 17 files of `indra/indra_ocr/`), " | |
| "the 201-node ONNX graph of `rec.onnx`, the graph I/O of all 5 models, and " | |
| "the shipped `model.safetensors` (108 F32 tensors) β never from README " | |
| "marketing. Verification scripts are included and re-runnable " | |
| "(Appendix B). Blocked items are marked [B]; verified items [V]; " | |
| "refuted prior claims [X].", | |
| ) | |
| doc.add_page_break() | |
| # ---- Part I: executive summary ---- | |
| doc.add_heading("Part I β Executive summary", level=1) | |
| h = doc.add_heading("Question", level=3) | |
| add_runs( | |
| doc.add_paragraph(), | |
| "Can Datalab's Indra OCR be evaluated, adapted or fine-tuned for a " | |
| "Nepali/Devanagari OCR use case β and could it beat the deployed " | |
| "PaddleOCR PP-OCRv5 Mobile Devanagari pipeline? Decisions had to be " | |
| "based on the actual source code and ONNX graphs, not the README.", | |
| ) | |
| doc.add_heading("Seven key findings (all verified)", level=2) | |
| add_runs( | |
| doc.add_paragraph(style="List Number"), | |
| "**The ~1 M-param recognizer is a padding-masked MobileNetV3-style 1-D " | |
| "CNN with a flat CTC head β no RNN, no attention.** Exactly " | |
| "**1,236,366 parameters** (safetensors β ONNX initializer cross-check). " | |
| "Stem Conv 1β128 (kernel 32Γ4, stride 32Γ4) collapses the line height " | |
| "entirely; then 10 identical residual blocks [depthwise 1Γ9 β expand " | |
| "1Γ1 128β256 β HardSwish β SE (padding-aware) β project 1Γ1 256β128 " | |
| "β +residual]; then a 1,678-class head.", | |
| ) | |
| add_runs( | |
| doc.add_paragraph(style="List Number"), | |
| "**Time stride is 4, not 8** (the `WIDTH_MULTIPLE=8` comment in " | |
| "`rec_preproc.py:24` is inaccurate as written). The graph computes " | |
| "`lengths = ceil(widths/4)`, clipped to `W/4` (measured table, " | |
| "e.g. widths 65 β 17). The graph outputs `ids [B,T]`, `conf [B,T]`, " | |
| "`lengths [B]`; padded timesteps are NOT special-cased (head-on-zeros " | |
| "β blank, conf β 0.78), so callers must truncate by `lengths` β as " | |
| "`pipeline.py:297` does.", | |
| ) | |
| add_runs( | |
| doc.add_paragraph(style="List Number"), | |
| "**Dynamic padding mask is functional, not cosmetic.** " | |
| "`Cast_4 = (arange(W/4) < lengths).float()` zeroes the padded region " | |
| "post-stem, after every block's residual (proven: final-trunk features " | |
| "at padded t are exactly 0.0 even with ink present), and normalizes " | |
| "every SE pooling over valid timesteps only.", | |
| ) | |
| add_runs( | |
| doc.add_paragraph(style="List Number"), | |
| "**Vocabulary already covers 100% of Devanagari.** 1,677 tokens + " | |
| "blank class 0 (head 1,678); all 128 assigned codepoints in " | |
| "U+0900βU+097F verified present (letters, matras, nukta, danda ΰ₯€ ΰ₯₯, " | |
| "Devanagari digits ΰ₯¦βΰ₯―, βΉ, ΰ₯). **No head surgery is needed for " | |
| "Nepali** β the only adaptation question is training-data distribution.", | |
| ) | |
| add_runs( | |
| doc.add_paragraph(style="List Number"), | |
| "**Fine-tuning is a reimplementation project, but legally and " | |
| "architecturally allowed.** No training code exists in the repo " | |
| "(grep-verified; `pyproject.toml` has no torch) and the artifacts " | |
| "ship trainable weights ONLY for the recognizer (`model.safetensors`, " | |
| "`rec/` prefix). det/order/orient/everything else exist as frozen " | |
| "ONNX only. The weights license β AI PUBS Open RAIL-M (modified) β " | |
| "explicitly permits fine-tuning (Β§II ΒΆ36); the inference code is " | |
| "Apache-2.0.", | |
| ) | |
| add_runs( | |
| doc.add_paragraph(style="List Number"), | |
| "**The evaluation harness is built and smoke-proven on real shaped " | |
| "Devanagari.** Zero-shot full-pipeline run on a synthetic Nepali " | |
| "page (raqm-shaped, OFL Noto Sans Devanagari): 10/10 lines detected, " | |
| "reading order correct, micro CER **2.62%**; recognizer-only on the " | |
| "identical GT crops: CER **3.49%**. Observed failure modes (nukta " | |
| "ΰ€°ΰ€Όβΰ€° dropped, βΉβΰ€°, ΰ₯βΰ€, conjunct matras `ΰ€Έΰ€ΰ₯ΰ€ΰ₯ΰ€€βΰ€Έΰ€ΰ₯ΰ€ΰ₯ΰ€€`) are exactly " | |
| "the distribution gaps that fine-tuning (Experiment B) targets.", | |
| ) | |
| add_runs( | |
| doc.add_paragraph(style="List Number"), | |
| "**The fine-tune toolkit is built and verified offline (2026-10-20).** " | |
| "`tools/exp/` reconstructs the recognizer in PyTorch from the shipped " | |
| "safetensors, fine-tunes with CTC, and re-exports ONNX: the zero-shot " | |
| "export matches the shipped `rec.onnx` with 0 id mismatches and max " | |
| "|Ξconf| 7.1e-6 (gate 1e-3); a mechanics training run (loss 8.1β1.65, " | |
| "val CER 0.97β0.58 on an overfit probe) passes the post-train gate " | |
| "(torch `.pt` vs its own ONNX, Ξconf 1.3e-5) and `run_rec.py` reproduces " | |
| "the recorded smoke CER (3.49 %) bit-for-bit. `verify_bundle.sh` pins " | |
| "all of this in one data-free command, and the rebuilt " | |
| "`indra_nepali_exp.bundle` carries it to the remote.", | |
| ) | |
| doc.add_heading("Verdict", level=2) | |
| add_runs( | |
| doc.add_paragraph(), | |
| "**Zero-shot evaluation (Experiment A) is ready today** β the adapter " | |
| "(`tools/indra_eval/eval_indra.py`) runs Indra end-to-end on CPU and " | |
| "scores CER/WER, and the Experiment B toolchain is verified offline " | |
| "(`tools/exp/verify_bundle.sh`); only the frozen Nepali eval sets on the " | |
| "remote machine are missing (`khalti-t4` β SSH still rejected for the " | |
| "presented key on 2026-10-20: authorize it or hand over the bundle). " | |
| "**The recognizer is the only component worth adapting**, via the " | |
| "shipped safetensors init; a re-export must reproduce the padding " | |
| "mask + per-block re-zeroing + SE valid-means + the " | |
| "`ids/conf/lengths` decode tail. Detector/order fine-tuning is " | |
| "out of scope until the zero-shot full-pipeline run shows detection " | |
| "as the bottleneck (Experiment A). Recommended order: **A β D (hybrid " | |
| "PP-det + Indra-rec, zero training) β B (rec fine-tune) β E (int8 " | |
| "deploy)**.", | |
| ) | |
| doc.add_page_break() | |
| # ---- Part II: full investigation doc ---- | |
| doc.add_heading("Part II β Architecture investigation (full evidence)", level=1) | |
| md = (ROOT / "docs" / "INDRA_INVESTIGATION.md").read_text(encoding="utf-8") | |
| # drop the md's own title + status legend line (already on cover) | |
| parts = re.split(r"^## 0\. Verdict", md, maxsplit=1, flags=re.M) | |
| md = "## 0. Verdict" + parts[1] | |
| render_md(doc, md, first_h1_prefix="") | |
| doc.add_page_break() | |
| # ---- Part III: experiments doc ---- | |
| doc.add_heading("Part III β Experiment plan (AβE) and governance", level=1) | |
| md = (ROOT / "docs" / "INDRA_EXPERIMENTS.md").read_text(encoding="utf-8") | |
| render_md(doc, md, first_h1_prefix="") | |
| doc.add_page_break() | |
| # ---- Part IV: log ---- | |
| doc.add_heading("Part IV β Investigation log", level=1) | |
| md = (ROOT / "logs" / "investigation.md").read_text(encoding="utf-8") | |
| render_md(doc, md, first_h1_prefix="") | |
| doc.add_page_break() | |
| # ---- Part V: smoke results (generated from artifacts) ---- | |
| doc.add_heading("Part V β Smoke-test results (generated from result files)", level=1) | |
| gt = json.loads((ROOT / "results/smoke/synth_nepali_record.jsonl").read_text(encoding="utf-8").splitlines()[0]) | |
| rec_only = json.loads((ROOT / "results/smoke/rec_only.jsonl").read_text().splitlines()[0]) | |
| full = json.loads((ROOT / "results/smoke/full_run.jsonl").read_text().splitlines()[0]) | |
| summary = { | |
| "mode": { | |
| "rec-only": rec_only, | |
| "full pipeline": full, | |
| } | |
| } | |
| doc.add_heading("V.1 Setup", level=2) | |
| add_runs( | |
| doc.add_paragraph(), | |
| "Synthetic A4-ratio page (1240Γ1754 px), 10 Nepali lines rendered at " | |
| "32 px with raqm shaping (conjuncts, nukta, digits, ΰ₯, βΉ, danda). " | |
| "Ground truth is exact by construction. Weights: Indra v3.1.1 " | |
| "official, CPU (onnxruntime 1.31.0). **Numbers are an environment " | |
| "smoke test, not a benchmark** β the frozen remote eval sets are " | |
| "needed for the real comparison (Experiment A).", | |
| ) | |
| doc.add_heading("V.2 Headline numbers", level=2) | |
| rows = [] | |
| for mode, rec in summary["mode"].items(): | |
| cer = lev_text_stats(rec, gt) | |
| rows.append([mode, str(len(rec["lines"])), f"{rec['mean_conf']:.3f}", f"{cer['cer']:.4f}", f"{cer['wer']:.4f}"]) | |
| add_table( | |
| doc, | |
| [["mode", "lines found", "mean conf", "micro CER", "micro WER"]] | |
| + rows, | |
| ) | |
| doc.add_paragraph() | |
| doc.add_heading("V.3 Per-line comparison (recognizer-only, GT crops)", level=2) | |
| rows = [] | |
| for i, (gl, pl) in enumerate(zip(gt["lines"], rec_only["lines"])): | |
| g = unicodedata.normalize("NFC", gl["text"]) | |
| p = unicodedata.normalize("NFC", pl["text"]) | |
| d = lev(g, p) | |
| mark = "β" if g == p else f"{d} edits" | |
| rows.append([str(i), g, p, f"{pl['conf']:.3f}", mark]) | |
| add_table(doc, [["#", "ground truth", "prediction", "conf", "Ξ"], *rows], size=9) | |
| doc.add_paragraph() | |
| doc.add_heading("V.4 Per-line comparison (full pipeline, detector crops)", level=2) | |
| rows = [] | |
| for i, (gl, pl) in enumerate(zip(gt["lines"], full["lines"])): | |
| g = unicodedata.normalize("NFC", gl["text"]) | |
| p = unicodedata.normalize("NFC", pl["text"]) | |
| d = lev(g, p) | |
| mark = "β" if g == p else f"{d} edits" | |
| rows.append([str(i), g, p, f"{pl['conf']:.3f}", mark]) | |
| add_table(doc, [["#", "ground truth", "prediction", "conf", "Ξ"], *rows], size=9) | |
| doc.add_paragraph() | |
| doc.add_heading("V.5 Interpretation", level=2) | |
| add_runs( | |
| doc.add_paragraph(), | |
| "Both runs read the page almost perfectly; the remaining errors are " | |
| "print-size artifacts (32 px) of exactly the classes a Nepali corpus " | |
| "would reinforce: the nukta dot (ΰ€°ΰ€Ό), the rarely-trained βΉ and ΰ₯, and " | |
| "conjunct vmatras. The rec-only vs full discrepancy on line 2 " | |
| "(ΰ₯ β ΰ€ vs S) and line 3/5/7 flips demonstrates crop-offset " | |
| "sensitivity β which is why the fair design compares recognizers on " | |
| "**identical crops** (rec-lines mode) and pipelines on page text. " | |
| "Timings on this WSL box are not representative (CPU/IO-starved; det " | |
| "β 18.6 min on one page) β benchmark on the T4.", | |
| ) | |
| doc.add_page_break() | |
| # ---- Part VI: appendix ---- | |
| doc.add_heading("Part VI β Appendix", level=1) | |
| doc.add_heading("A. Artifact inventory", level=2) | |
| rows = [] | |
| for rel, why in [ | |
| ("docs/INDRA_INVESTIGATION.md", "architecture + evidence + [U] closure"), | |
| ("docs/INDRA_EXPERIMENTS.md", "experiments AβE, leakage, licensing, decision tree"), | |
| ("logs/investigation.md", "command/evidence log"), | |
| ("tools/indra_eval/inspect_vocab.py", "vocab + Devanagari coverage verification"), | |
| ("tools/indra_eval/inspect_models.py", "graph I/O + param-count cross-check"), | |
| ("tools/indra_eval/inspect_rec_nodes.py", "full rec.onnx node dump + numeric run"), | |
| ("tools/indra_eval/inspect_rec_mask.py", "mask semantics + lengths table proof"), | |
| ("tools/indra_eval/make_synth_page.py", "shaped Devanagari test page + GT"), | |
| ("tools/indra_eval/eval_indra.py", "predict (full / rec-lines) + CER scorer"), | |
| ("tools/exp/torch_rec.py", "PyTorch re-implementation of rec.onnx + weight map"), | |
| ("tools/exp/train_rec.py", "CTC fine-tune loop (safetensors init, width-bucketed batches)"), | |
| ("tools/exp/export_rec_onnx.py", "torch -> ONNX with the exact ids/conf/lengths contract"), | |
| ("tools/exp/exactness_check.py", "gate: export vs rec.onnx / torch (ids, lengths, conf)"), | |
| ("tools/exp/run_rec.py", "batch rec-lines runner (ONNX or --torch backends)"), | |
| ("tools/exp/verify_bundle.sh", "one-command offline verification gate (no data needed)"), | |
| ("tools/exp/e_int8_quantize.py", "Experiment E: static (QDQ) / dynamic int8 quantization"), | |
| ("tools/exp/run_a.sh", "Experiment A orchestration (rec-lines + GT records + CER)"), | |
| ("tools/exp/run_b.sh", "Experiment B orchestration (train -> export -> gate -> re-score)"), | |
| ("tools/exp/data_prep.py", "corpus -> manifests, page-hash split, leakage exclude"), | |
| ("tools/exp/a_export_gt_boxes.py", "GT boxes adapters (validate/normalize/merge)"), | |
| ("tools/exp/a_ppocr_baseline.py", "identical-crop baseline materials (engine = remote plug)"), | |
| ("tools/exp/remote_setup.sh", "remote deps + probe + verification gate"), | |
| ("tools/exp/make_bundle.sh", "builds indra_nepali_exp.bundle for the remote"), | |
| ("tools/indra_eval/testdata/NotoSansDevanagari.ttf", "OFL font (test rendering only)"), | |
| ("models/indra-ocr-v3.1.1/", "downloaded official weights (16 files, ~46 MB)"), | |
| ("results/smoke/", "smoke artifacts (pages, records, CER JSON)"), | |
| ("results/verify/", "offline verification evidence (exactness + smoke re-run)"), | |
| ]: | |
| pth = ROOT / rel | |
| n = ( | |
| sum(f.stat().st_size for f in pth.rglob("*") if f.is_file()) | |
| if pth.is_dir() | |
| else (pth.stat().st_size if pth.exists() else 0) | |
| ) | |
| rows.append([rel, why, f"{n / 1024:.0f} KiB" if n else "β"]) | |
| add_table(doc, [["path", "purpose", "size"], *rows], size=9) | |
| doc.add_paragraph() | |
| doc.add_heading("B. Reproduce everything", level=2) | |
| code = '\n'.join( | |
| [ | |
| "cd /mnt/c/Users/Dell/Desktop/OCR_INDRA # or wherever this workspace is", | |
| "PY=/tmp/opencode/indra-lib # pip --target deps", | |
| "export PYTHONPATH=\"$PWD/indra:$PY\"", | |
| "", | |
| "python3 tools/indra_eval/inspect_vocab.py # vocab + Devanagari coverage", | |
| "python3 tools/indra_eval/inspect_models.py # graph I/O + param count", | |
| "python3 tools/indra_eval/inspect_rec_nodes.py # full node dump + numeric run", | |
| "python3 tools/indra_eval/inspect_rec_mask.py # mask semantics + lengths table", | |
| "", | |
| "python3 tools/indra_eval/make_synth_page.py results/smoke # synth page + GT", | |
| "python3 tools/indra_eval/eval_indra.py predict results/smoke/synth_nepali_page.png \\", | |
| " --boxes results/smoke/synth_nepali_gt.jsonl --jsonl results/smoke/rec_only.jsonl", | |
| "python3 tools/indra_eval/eval_indra.py predict results/smoke/synth_nepali_page.png \\", | |
| " --jsonl results/smoke/full_run.jsonl --print-text", | |
| "python3 tools/indra_eval/eval_indra.py cer results/smoke/synth_nepali_record.jsonl \\", | |
| " results/smoke/rec_only.jsonl --detail results/smoke/cer_rec_only.json --rec-only", | |
| "python3 tools/indra_eval/eval_indra.py cer results/smoke/synth_nepali_record.jsonl \\", | |
| " results/smoke/full_run.jsonl --detail results/smoke/cer_full.json", | |
| "", | |
| "# fine-tune toolkit: one-command offline verification (no data needed)", | |
| "bash tools/exp/verify_bundle.sh # -> results/verify/summary.json {pass: true}", | |
| "", | |
| "python3 tools/indra_eval/make_docx.py # regenerate THIS report", | |
| "", | |
| "# remote (after SSH/bundle access): docs/REMOTE_RUN_SHEET.md", | |
| "# bash tools/exp/remote_setup.sh # deps + probe + same verify gate", | |
| "# bash tools/exp/run_a.sh # zero-shot A on the frozen sets", | |
| "# bash tools/exp/run_b.sh # fine-tune B (train -> export -> gate -> re-score)", | |
| ] | |
| ) | |
| for ln in code.split("\n"): | |
| par = doc.add_paragraph() | |
| par.paragraph_format.space_after = Pt(0) | |
| r = par.add_run(ln if ln else " ") | |
| r.font.name = "Consolas" | |
| r.font.size = Pt(8.5) | |
| cs_font(r) | |
| shade(par) | |
| doc.add_paragraph() | |
| doc.add_heading("C. Environment & dependencies", level=2) | |
| add_table( | |
| doc, | |
| [ | |
| ["component", "version / note"], | |
| ["OS / box", "Linux (WSL-backed /mnt/c), 8 cores, 3 GB RAM β timings NOT representative"], | |
| ["Python", "3.12.3 system; deps via pip --target /tmp/opencode/indra-lib"], | |
| ["torch", "2.14.1+cpu β export forced to the legacy TorchScript tracer (see run sheet Β§0)"], | |
| ["onnxruntime", "1.31.0 (CPU provider)"], | |
| ["Pillow", "13.0.0 β raqm available (Devanagari shaping verified)"], | |
| ["opencv / onnx / pypdfium2 / hf-hub / safetensors / numpy", "installed in the same target dir"], | |
| ["python-docx", "1.2.0 (this report's generator)"], | |
| ["Remote machine", "khalti-t4 (202.51.0.7) β SSH key still rejected 2026-10-20 (port 22 open); all dataset-side work blocked"], | |
| ], | |
| ) | |
| doc.add_paragraph() | |
| doc.add_heading("D. Licensing (verified from files)", level=2) | |
| add_table( | |
| doc, | |
| [ | |
| ["item", "license", "fine-tune", "deploy / notes"], | |
| ["Indra v3.1.1 model weights", "AI PUBS Open RAIL-M (modified) v0.1", | |
| "**explicitly allowed** (Β§II ΒΆ36); Attachment A use restrictions attach", | |
| "redistribution keeps license + usage notice; derivatives inherit it"], | |
| ["indra inference code", "Apache-2.0", "β", "standard reuse rights"], | |
| ["PaddleOCR (baseline, remote)", "Apache-2.0", "already fine-tuned", "deployed today"], | |
| ["Noto Sans Devanagari (test font)", "SIL OFL 1.1", "β", "rendering only"], | |
| ["Nepali datasets / frozen eval sets", "docs/DATA_LICENSING.md [B]", | |
| "[B] review pending SSH", "no datasets leave the remote machine"], | |
| ], | |
| ) | |
| doc.add_page_break() | |
| # ---- Part VII: toolkit status + remote readiness (2026-10-20) ---- | |
| doc.add_heading("Part VII β Fine-tune toolkit & remote readiness (2026-10-20)", level=1) | |
| add_runs( | |
| doc.add_paragraph(), | |
| "The Experiment A/B toolchain in `tools/exp/` was completed and verified " | |
| "offline this revision; the rebuilt single-file bundle " | |
| "`indra_nepali_exp.bundle` carries it to `khalti-t4`. No dataset was " | |
| "touched (none is reachable).", | |
| ) | |
| doc.add_heading("Verified offline", level=2) | |
| add_table( | |
| doc, | |
| [ | |
| ["check", "command", "result"], | |
| ["bundle integrity", "`git bundle verify` + fresh clone + byte-compare", "OK β complete history, 16 model files byte-identical"], | |
| ["param invariant", "`train_rec.py --selfcheck`", "1,236,366 tensors (parameters 1,236,110 + BN buffers 256)"], | |
| ["zero-shot export parity", "`export_rec_onnx.py --safetensors` vs `rec.onnx`", "**pass** β 0 id mismatches, 0 lengths mismatches, max |Ξconf| 7.1e-6"], | |
| ["training mechanics", "`train_rec.py` 120 steps, overfit probe", "loss 8.1 β 1.65; val CER 0.97 β 0.58; checkpoints + `best.safetensors` written"], | |
| ["post-train gate", "`exactness_check.py --against torch`", "**pass** β 0 id mismatches, Ξconf 1.3e-5"], | |
| ["backend parity", "`run_rec.py` ONNX vs `--torch`", "identical texts on the smoke page"], | |
| ["A orchestration", "`run_a.sh` on a local stand-in set", "GT records β rec-lines β CER 0.0349 (matches smoke exactly)"], | |
| ["B orchestration", "`run_b.sh` (train β export β gate β re-score)", "complete; findings written under `results/`"], | |
| ["data adapters", "`a_export_gt_boxes.py`, `a_ppocr_baseline.py`, `data_prep.py`", "all subcommands exercised OK"], | |
| ], | |
| size=9, | |
| ) | |
| doc.add_paragraph() | |
| doc.add_heading("Fixed this revision (each would have broken the remote run)", level=2) | |
| add_runs( | |
| doc.add_paragraph(style="List Bullet"), | |
| "torch β₯ 2.6 `torch.onnx.export` defaults to the torch.export exporter " | |
| "(needs `onnxscript`); the export now pins the verified legacy tracer " | |
| "(`dynamo=False`) with a fallback for older torch.", | |
| ) | |
| add_runs( | |
| doc.add_paragraph(style="List Bullet"), | |
| "`run_a.sh` / `run_b.sh` crashed on unset `PYTHONPATH` under `set -u`.", | |
| ) | |
| add_runs( | |
| doc.add_paragraph(style="List Bullet"), | |
| "`a_ppocr_baseline.py` rejected the `\"file\"` GT schema and did not " | |
| "resolve page paths relative to the boxes file.", | |
| ) | |
| add_runs( | |
| doc.add_paragraph(style="List Bullet"), | |
| "`remote_setup.sh` wrote `probe.json` relative to the caller's cwd and " | |
| "ignored combined flags; it now also runs the full verification gate.", | |
| ) | |
| add_runs( | |
| doc.add_paragraph(style="List Bullet"), | |
| "`data_prep.py` hash-split could leave val empty on small corpora.", | |
| ) | |
| doc.add_heading("Remote status", level=2) | |
| add_runs( | |
| doc.add_paragraph(), | |
| "SSH to `khalti-t4` (202.51.0.7) is still rejected for key " | |
| "`khalti-t4-ocr-team` (`Permission denied (publickey,password)`; port 22 " | |
| "open, 2026-10-20). To proceed: authorize the key's public half on the " | |
| "box (or transfer the bundle to someone with access), then follow " | |
| "`docs/REMOTE_RUN_SHEET.md` β `remote_setup.sh` (deps + probe + gate) β " | |
| "probe inventory (Β§1) β `run_a.sh` β `run_b.sh`. Only `results/`, " | |
| "`runs/rec_ft/*` and `results/probe.json` travel back; datasets never " | |
| "leave the machine.", | |
| ) | |
| doc.save(OUT) | |
| print(f"written: {OUT} ({OUT.stat().st_size / 1024:.0f} KiB)") | |
| def lev_text_stats(rec, gt): | |
| gt_text = [unicodedata.normalize("NFC", l["text"]) for l in gt["lines"]] | |
| pr_text = [unicodedata.normalize("NFC", l["text"]) for l in rec["lines"]] | |
| ce = sum(lev(a, b) for a, b in zip(gt_text, pr_text)) | |
| cn = sum(len(a) for a in gt_text) | |
| gw = " ".join(gt_text).split() | |
| pw = " ".join(pr_text).split() | |
| prev = list(range(len(pw) + 1)) | |
| for i, w in enumerate(gw, 1): | |
| cur = [i] + [0] * len(pw) | |
| for j, v in enumerate(pw, 1): | |
| cur[j] = min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (w != v)) | |
| prev = cur | |
| return {"cer": ce / max(1, cn), "wer": prev[-1] / max(1, len(gw))} | |
| if __name__ == "__main__": | |
| main() | |