"""Build finipher-us-tax-document-classifier v1.1.0 from v1.0.0 plus generated rows. Run from the dataset root: python scripts/v1_1/build.py Deterministic: every generated row is seeded from (label, group, index). v1.0.0 rows, label IDs and splits are kept unchanged. New fine labels and families are appended after the existing IDs so v1.0 checkpoints stay compatible with the first 83 type IDs and 42 family IDs. """ from __future__ import annotations import hashlib import json import math import random import re import subprocess import sys from collections import Counter, defaultdict from pathlib import Path import pandas as pd import pyarrow as pa import pyarrow.parquet as pq HERE = Path(__file__).resolve().parent ROOT = HERE.parents[1] sys.path.insert(0, str(HERE)) import docs # noqa: E402 import render # noqa: E402 from specs import FORMS, OTHER_TAX_FORMS, UNKNOWN_KINDS # noqa: E402 VERSION = "1.1.0" BASE_REV = "cad7079" # v1.0.0 commit; its rows, maps and provenance are the fixed base SPLITS = ["train", "validation", "test"] NEW_TYPES = { "MORTGAGE_STATEMENT": "LOAN_STATEMENT", "LOAN_STATEMENT": "LOAN_STATEMENT", "BROKERAGE_STATEMENT": "INVESTMENT_STATEMENT", "RETIREMENT_ACCOUNT_STATEMENT": "INVESTMENT_STATEMENT", "HSA_ACCOUNT_STATEMENT": "INVESTMENT_STATEMENT", "PAYSTUB": "PAYSTUB", "INSURANCE_DOCUMENT": "INSURANCE_DOCUMENT", "CRYPTO_TAX_REPORT": "CRYPTO_TAX_REPORT", "PROPERTY_TAX_BILL": "PROPERTY_TAX_BILL", "PROFIT_AND_LOSS_STATEMENT": "BUSINESS_RECORD", "CONSOLIDATED_1099": "1099", "OTHER_TAX_FORM": "OTHER_TAX_FORM", } NEW_FAMILIES = ["LOAN_STATEMENT", "INVESTMENT_STATEMENT", "PAYSTUB", "INSURANCE_DOCUMENT", "CRYPTO_TAX_REPORT", "PROPERTY_TAX_BILL", "OTHER_TAX_FORM"] DOUBLE = set(NEW_TYPES) - {"OTHER_TAX_FORM"} | {"BANK_STATEMENT", "CREDIT_CARD_STATEMENT"} KIND_SPLIT = {"UNKNOWN_DOCUMENT": len(UNKNOWN_KINDS), "OTHER_TAX_FORM": len(OTHER_TAX_FORMS)} PER_GROUP = 16 KIND_SPLIT_TOTAL = 16 * 6 * 3 STATUS = {"W-2C": "corrected", "TAX_INSTRUCTIONS": "instruction", "UNKNOWN_DOCUMENT": "unknown"} ORIGIN = "synthetic_programmatic_template" SOURCE = f"finipher-us-tax-document-classifier-generator-v{VERSION}" def _h(*parts: object) -> str: return hashlib.sha256("|".join(map(str, parts)).encode()).hexdigest() def _norm(text: str) -> str: """Digit- and whitespace-normalized text for leak checks.""" return re.sub(r"\s+", " ", re.sub(r"\d", "0", text)).strip().lower() def _base(path: str) -> str: """Read a v1.0.0 file from git so rebuilding never reads its own output.""" return subprocess.run(["git", "-C", str(ROOT), "show", f"{BASE_REV}:{path}"], check=True, capture_output=True, text=True).stdout def _read_v1() -> dict[str, list[dict]]: rows: dict[str, list[dict]] = {} for split in SPLITS: types = [json.loads(l) for l in _base(f"data/document_type/{split}.jsonl").splitlines()] fams = {r["record_id"]: r["label"] for r in map(json.loads, _base(f"data/document_family/{split}.jsonl").splitlines())} for r in types: r["family"] = fams[r["record_id"]] r.update(layout="v1_template", title_mode="top", ocr_noise=False, sub_kind=None, split=split) rows[split] = types return rows def _content(label: str, rng: random.Random, year: int, kind_index: int | None) -> tuple[list[tuple], str | None]: if label in FORMS: return render.form_items(rng, FORMS[label], year), None if label == "UNKNOWN_DOCUMENT": return docs.unknown_document(rng, year, kind_index) if label == "OTHER_TAX_FORM": return docs.other_tax_form(rng, year, kind_index) return docs.GENERATORS[label](rng, year) def make_row(label: str, group: str, index: int, layout: str, kind_index: int | None, force_title: str | None = None) -> dict: """Generate one row; the same arguments always produce the same text.""" rng = random.Random(int(_h(VERSION, label, group, index)[:16], 16)) year = rng.randint(2021, 2026) items, sub_kind = _content(label, rng, year, kind_index) roll = rng.random() title_mode = "top" if roll < 0.7 else ("bottom" if roll < 0.85 else "none") noisy = rng.random() < 0.2 text_rng = random.Random(rng.random()) text = render.render(text_rng, items, layout, force_title or title_mode) if noisy: text = render.ocr_noise(text_rng, text) return {"text": text, "label": label, "group_id": group, "tax_year": year, "layout": layout, "title_mode": force_title or title_mode, "ocr_noise": noisy, "sub_kind": sub_kind, "seed_key": f"{label}|{group}|{index}"} def plan() -> list[tuple[str, str, str, int, str, int | None]]: """List (split, label, group, index, layout, kind_index) for every generated row.""" labels = sorted(set(FORMS) | set(docs.GENERATORS) | set(KIND_SPLIT)) out = [] for li, label in enumerate(labels): layouts = render.FORM_LAYOUTS if label in FORMS else render.STATEMENT_LAYOUTS if label in KIND_SPLIT: n_kinds = KIND_SPLIT[label] per_kind = math.ceil(KIND_SPLIT_TOTAL / n_kinds) for k in range(n_kinds): split = "test" if k % 6 == 5 else ("validation" if k % 6 == 4 else "train") group = f"v11-{label}-kind{k:02d}" for i in range(per_kind): out.append((split, label, group, i, layouts[(i + k) % 6], k)) continue n = PER_GROUP * (2 if label in DOUBLE else 1) for g, layout in enumerate(layouts): split = "test" if g == li % 6 else ("validation" if g == (li + 1) % 6 else "train") group = f"v11-{label}-{layout}" for i in range(n): out.append((split, label, group, i, layout, None)) return out def generate() -> tuple[dict[str, list[dict]], dict]: """Generate, dedupe and leak-check the new rows.""" rows: dict[str, list[dict]] = {s: [] for s in SPLITS} seen: dict[str, str] = {} dropped = Counter() for split, label, group, i, layout, k in sorted(plan(), key=lambda p: SPLITS.index(p[0])): row = make_row(label, group, i, layout, k) key = _norm(row["text"]) if key in seen: dropped[label] += 1 continue seen[key] = split row.update(split=split, kind_index=k, index=i) rows[split].append(row) return rows, {"dropped_normalized_duplicates": dict(dropped)} def label_maps(v1_rows: dict[str, list[dict]]) -> tuple[dict, dict, dict]: t_old = json.loads(_base("label_maps/document_type.json"))["label2id"] f_old = json.loads(_base("label_maps/document_family.json"))["label2id"] t2f = json.loads(_base("label_maps/type_to_family.json")) if len(t_old) != 83 or len(f_old) != 42: raise SystemExit(f"{BASE_REV} does not hold the v1.0.0 label maps") types = dict(t_old) for name in NEW_TYPES: types[name] = len(types) fams = dict(f_old) for name in NEW_FAMILIES: fams[name] = len(fams) t2f = {**t2f, **NEW_TYPES} return types, fams, t2f def _features(names_type: list[str], names_fam: list[str], label_names: list[str] | None) -> bytes: value = lambda d: {"dtype": d, "_type": "Value"} # noqa: E731 feats = {"text": value("string"), "label": {"names": label_names, "_type": "ClassLabel"} if label_names else value("string"), "label_id": value("int64"), "label_name": value("string"), "record_id": value("string"), "group_id": value("string"), "document_status": value("string"), "tax_year": value("int64"), "source_record_id": value("string"), "origin": value("string"), "layout": value("string"), "title_mode": value("string"), "ocr_noise": value("bool"), "sub_kind": value("string")} return json.dumps({"info": {"features": feats}}).encode() COLUMNS = ["text", "label", "label_id", "label_name", "record_id", "group_id", "document_status", "tax_year", "source_record_id", "origin", "layout", "title_mode", "ocr_noise", "sub_kind"] def write_config(name: str, frame: pd.DataFrame, split: str, label_names: list[str] | None) -> None: out = ROOT / "data" / name out.mkdir(parents=True, exist_ok=True) frame = frame[COLUMNS] frame.to_json(out / f"{split}.jsonl", orient="records", lines=True, force_ascii=False) frame.to_csv(out / f"{split}.csv", index=False) table = pa.Table.from_pandas(frame, preserve_index=False) table = table.replace_schema_metadata({b"huggingface": _features([], [], label_names)}) pq.write_table(table, out / f"{split}.parquet") def main() -> None: v1 = _read_v1() types, fams, t2f = label_maps(v1) new, gen_report = generate() gen_sha = _h(*[(HERE / f).read_text() for f in ("specs.py", "render.py", "docs.py", "build.py")]) provenance = [json.loads(l) for l in _base("metadata/provenance.jsonl").splitlines()] frames: dict[str, pd.DataFrame] = {} for split in SPLITS: out = [] for r in v1[split]: out.append({**{c: r.get(c) for c in COLUMNS}, "family": r["family"]}) for r in new[split]: rid = "fdc-" + _h(VERSION, r["seed_key"])[:24] sid = "fgen-" + _h(SOURCE, r["seed_key"])[:24] out.append({"text": r["text"], "label": r["label"], "label_id": types[r["label"]], "label_name": r["label"], "record_id": rid, "group_id": r["group_id"], "document_status": STATUS.get(r["label"], "original"), "tax_year": r["tax_year"], "source_record_id": sid, "origin": ORIGIN, "layout": r["layout"], "title_mode": r["title_mode"], "ocr_noise": r["ocr_noise"], "sub_kind": r["sub_kind"], "family": t2f[r["label"]]}) provenance.append({"record_id": rid, "source_record_id": sid, "source_dataset": SOURCE, "source_text_sha256": _h(r["text"]), "generator_sha256": gen_sha, "seed_key": r["seed_key"], "label_method": "programmatic_template_ground_truth", "independent_human_review": False, "group_id": r["group_id"], "split": split}) frames[split] = pd.DataFrame(out) frames[split]["tax_year"] = frames[split]["tax_year"].astype("Int64") type_names = [n for n, _ in sorted(types.items(), key=lambda kv: kv[1])] fam_names = [n for n, _ in sorted(fams.items(), key=lambda kv: kv[1])] for split, frame in frames.items(): write_config("document_type", frame, split, None) write_config("document_type_ids", frame.assign(label=frame["label_id"]), split, type_names) fam = frame.assign(label=frame["family"], label_id=frame["family"].map(fams), label_name=frame["family"]) write_config("document_family", fam, split, None) write_config("document_family_ids", fam.assign(label=fam["label_id"]), split, fam_names) for target, f in (("document_type", frame), ("document_family", fam)): (ROOT / "simple_csv" / target).mkdir(parents=True, exist_ok=True) f[["text", "label"]].to_csv(ROOT / "simple_csv" / target / f"{split}.csv", index=False) lm = ROOT / "label_maps" for path, mapping in (("document_type.json", types), ("document_family.json", fams)): (lm / path).write_text(json.dumps({"version": VERSION, "label2id": mapping, "id2label": {str(v): k for k, v in mapping.items()}, "num_labels": len(mapping)}, indent=2) + "\n") (lm / "type_to_family.json").write_text(json.dumps(t2f, indent=2) + "\n") with (ROOT / "metadata/provenance.jsonl").open("w") as fh: for p in provenance: fh.write(json.dumps(p) + "\n") _write_masked_view(new["test"], types, t2f) _quality(frames, types, fams, gen_report) print(json.dumps({s: len(f) for s, f in frames.items()}), json.dumps(gen_report)) def _write_masked_view(test_rows: list[dict], types: dict, t2f: dict) -> None: """Re-render every generated test row with no title lines (same seed).""" out = [] for r in test_rows: masked = make_row(r["label"], r["group_id"], r["index"], r["layout"], r["kind_index"], force_title="none") out.append({"text": masked["text"], "label": r["label"], "label_id": types[r["label"]], "family": t2f[r["label"]], "record_id": "fdc-" + _h(VERSION, r["seed_key"])[:24], "layout": r["layout"], "ocr_noise": masked["ocr_noise"], "view": "header_masked_v1_1"}) frame = pd.DataFrame(out) pq.write_table(pa.Table.from_pandas(frame, preserve_index=False), ROOT / "robustness_views/test_header_masked_v1_1.parquet") frame.to_json(ROOT / "robustness_views/test_header_masked_v1_1.jsonl", orient="records", lines=True, force_ascii=False) def _quality(frames: dict[str, pd.DataFrame], types: dict, fams: dict, gen_report: dict) -> None: groups = {s: set(f["group_id"]) for s, f in frames.items()} texts = {s: set(f["text"]) for s, f in frames.items()} norms = {s: set(map(_norm, f["text"])) for s, f in frames.items()} pairs = [("train", "validation"), ("train", "test"), ("validation", "test")] per_class = {t: {s: dict(sorted(Counter(f[col]).items(), key=lambda kv: str(kv[0]))) for s, f in frames.items()} for t, col in (("document_type", "label"), ("document_family", "family"))} rt = {} for split in SPLITS: back = pq.read_table(ROOT / f"data/document_type/{split}.parquet").to_pandas() csv = pd.read_csv(ROOT / f"simple_csv/document_type/{split}.csv", keep_default_na=False) rt[split] = bool((back["text"] == frames[split]["text"]).all() and (csv["text"] == frames[split]["text"]).all() and (csv["label"] == frames[split]["label"]).all()) allf = pd.concat(frames.values()) words = allf["text"].str.split().str.len() report = { "version": VERSION, "unique_observations": int(len(allf)), "fine_document_type_labels": len(types), "coarse_family_labels": len(fams), "split_counts": {s: int(len(f)) for s, f in frames.items()}, "rows_by_origin": {k: int(v) for k, v in Counter(allf["origin"]).items()}, "configurations_are_alternative_views_not_additional_independent_records": True, "per_class_split_counts": per_class, "group_count": int(allf["group_id"].nunique()), "cross_split_group_leaks": sum(len(groups[a] & groups[b]) for a, b in pairs), "cross_split_exact_text_leaks": sum(len(texts[a] & texts[b]) for a, b in pairs), "cross_split_numeric_normalized_leaks": sum(len(norms[a] & norms[b]) for a, b in pairs), "generator": gen_report, "word_count": {"v1_0_rows_mean": round(float(words[allf["origin"] != ORIGIN].mean()), 1), "v1_1_rows_mean": round(float(words[allf["origin"] == ORIGIN].mean()), 1), "v1_1_rows_p90": int(words[allf["origin"] == ORIGIN].quantile(0.9))}, "v1_1_layout_counts": {k: int(v) for k, v in Counter(allf.loc[allf["origin"] == ORIGIN, "layout"]).items()}, "v1_1_title_mode_counts": {k: int(v) for k, v in Counter(allf.loc[allf["origin"] == ORIGIN, "title_mode"]).items()}, "v1_1_ocr_noise_rows": int(allf.loc[allf["origin"] == ORIGIN, "ocr_noise"].sum()), "parquet_round_trip": "passed" if all(rt.values()) else "failed", "CSV_text_and_label_round_trip": "passed" if all(rt.values()) else "failed", "all_labels_present_in_all_splits": all(set(types) <= set(f["label"]) for f in frames.values()), "held_out_design": { "per_label_layout": "for each generated label one of six layouts appears only in test and one only in validation", "OTHER_TAX_FORM": {"test_forms": [OTHER_TAX_FORMS[k][0] for k in range(len(OTHER_TAX_FORMS)) if k % 6 == 5], "validation_forms": [OTHER_TAX_FORMS[k][0] for k in range(len(OTHER_TAX_FORMS)) if k % 6 == 4]}, "UNKNOWN_DOCUMENT": {"test_kinds": [UNKNOWN_KINDS[k][0] for k in range(len(UNKNOWN_KINDS)) if k % 6 == 5], "validation_kinds": [UNKNOWN_KINDS[k][0] for k in range(len(UNKNOWN_KINDS)) if k % 6 == 4]}, }, "annotation": "v1.0 rows single_AI; v1.1 rows programmatic ground truth from the generator", "origin": "synthetic_only", "real_filled_taxpayer_documents": 0, "independent_expert_review": False, "production_ready": False, "paired_header_masked_view": "robustness_views/test_header_masked_v1_1.parquet re-renders generated test rows without title lines; shares records with test", "no_application_code_changes": True, } (ROOT / "reports/data-quality.json").write_text(json.dumps(report, indent=2) + "\n") if __name__ == "__main__": main()