| """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 |
| import render |
| from specs import FORMS, OTHER_TAX_FORMS, UNKNOWN_KINDS |
|
|
| VERSION = "1.1.0" |
| BASE_REV = "cad7079" |
| 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"} |
| 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() |
|
|
