"""CSV → jsonl splits + axiom rewrite + coverage report. No model imports.""" from __future__ import annotations import argparse import csv import json import random import sys from collections import Counter from pathlib import Path from .axioms import match_cot, rewrite_cot_assistant TEXT_CSV = Path("Physics_Dataset/Physics_Dataset_no_image.csv") IMAGE_CSV = Path("Physics_Dataset/Physics_dataset_with_image.csv") IMAGE_DIR = Path("Physics_Dataset/Image") DEFAULT_OUT = Path("data/physics_sft") SPLIT_SEED = 42 TRAIN_RATIO = 0.90 VAL_RATIO = 0.05 def repo_root_from_here() -> Path: here = Path(__file__).resolve() for parent in here.parents: if (parent / "Physics_Dataset").is_dir() and (parent / "CLAUDE.md").exists(): return parent return Path.cwd() def load_csv(path: Path) -> list[dict[str, str]]: with path.open(newline="", encoding="utf-8") as handle: return list(csv.DictReader(handle)) def is_empty_answer(value: str | None) -> bool: return not (value or "").strip() def resolve_image_path(id_image: str, image_dir: Path) -> Path: candidate = image_dir / id_image if candidate.is_file(): return candidate raise FileNotFoundError(f"Missing diagram for id_image={id_image!r}: {candidate}") def split_keys(keys: list[str], seed: int) -> dict[str, str]: rng = random.Random(seed) ordered = list(keys) rng.shuffle(ordered) n = len(ordered) n_val = max(1, int(round(n * VAL_RATIO))) if n >= 3 else (1 if n >= 2 else 0) n_test = max(1, int(round(n * VAL_RATIO))) if n >= 3 else (1 if n >= 3 else 0) if n_val + n_test >= n: n_val = 1 if n >= 3 else 0 n_test = 1 if n >= 3 else 0 n_train = n - n_val - n_test assignment: dict[str, str] = {} for i, key in enumerate(ordered): if i < n_train: assignment[key] = "train" elif i < n_train + n_val: assignment[key] = "val" else: assignment[key] = "test" return assignment def record_from_row( row: dict[str, str], *, has_image: bool, image_path: str | None, ) -> dict: assistant, axiom_ids = rewrite_cot_assistant(row.get("cot") or "", row.get("answer") or "", row.get("unit") or "") return { "id": row["id"], "has_image": has_image, "image_path": image_path, "question": row.get("question") or "", "axiom_ids": axiom_ids, "assistant": assistant, } def write_jsonl(path: Path, rows: list[dict]) -> None: path.parent.mkdir(parents=True, exist_ok=True) with path.open("w", encoding="utf-8") as handle: for row in rows: handle.write(json.dumps(row, ensure_ascii=False) + "\n") def coverage_report(records: list[dict]) -> dict: hist: Counter[str] = Counter() n_with = 0 for rec in records: ids = rec.get("axiom_ids") or [] if ids: n_with += 1 for axiom_id in ids: hist[axiom_id] += 1 n = len(records) n_zero = n - n_with return { "n_rows": n, "n_with_axiom": n_with, "n_without_axiom": n_zero, "pct_with_axiom": round(100.0 * n_with / n, 2) if n else 0.0, "pct_without_axiom": round(100.0 * n_zero / n, 2) if n else 0.0, "axiom_histogram": dict(hist.most_common()), } def print_coverage(report: dict) -> None: print("=== axiom matcher coverage ===") print(f"rows {report['n_rows']}") print(f">=1 axiom {report['n_with_axiom']} ({report['pct_with_axiom']}%)") print(f"0 axioms {report['n_without_axiom']} ({report['pct_without_axiom']}%)") print("histogram:") for axiom_id, count in report["axiom_histogram"].items(): print(f" {axiom_id:8} {count}") def build_records(root: Path) -> tuple[list[dict], list[str], dict]: text_rows = load_csv(root / TEXT_CSV) image_rows = load_csv(root / IMAGE_CSV) image_dir = root / IMAGE_DIR dropped: list[str] = [] records: list[dict] = [] for row in text_rows: if is_empty_answer(row.get("answer")): dropped.append(row["id"]) continue rec = record_from_row(row, has_image=False, image_path=None) rec["_split_key"] = row["id"] rec["_split_kind"] = "text" records.append(rec) for row in image_rows: if is_empty_answer(row.get("answer")): dropped.append(row["id"]) continue resolved = resolve_image_path(row["id_image"], image_dir) rel = resolved.relative_to(root).as_posix() rec = record_from_row(row, has_image=True, image_path=rel) rec["_id_image"] = row["id_image"] rec["_split_key"] = row["id_image"] rec["_split_kind"] = "image" records.append(rec) return records, dropped, { "n_text_csv": len(text_rows), "n_image_csv": len(image_rows), } def assign_splits(records: list[dict], seed: int) -> dict: text_keys = sorted({r["_split_key"] for r in records if r["_split_kind"] == "text"}) image_keys = sorted({r["_split_key"] for r in records if r["_split_kind"] == "image"}) text_map = split_keys(text_keys, seed) image_map = split_keys(image_keys, seed + 1) manifest = {"seed": seed, "text": {"train": [], "val": [], "test": []}, "image": {"train": [], "val": [], "test": []}} for rec in records: if rec["_split_kind"] == "text": split = text_map[rec["_split_key"]] rec["split"] = split manifest["text"][split].append(rec["id"]) else: split = image_map[rec["_split_key"]] rec["split"] = split manifest["image"][split].append({"id": rec["id"], "id_image": rec["_id_image"]}) return manifest def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser(description="Prepare physics SFT jsonl splits.") parser.add_argument("--root", type=Path, default=None) parser.add_argument("--out", type=Path, default=DEFAULT_OUT) parser.add_argument("--seed", type=int, default=SPLIT_SEED) args = parser.parse_args(argv) root = (args.root or repo_root_from_here()).resolve() out = args.out if args.out.is_absolute() else root / args.out out.mkdir(parents=True, exist_ok=True) records, dropped, counts = build_records(root) print(f"dropped empty-answer ids ({len(dropped)}): {dropped}") print(f"csv text={counts['n_text_csv']} image={counts['n_image_csv']}") manifest = assign_splits(records, args.seed) splits: dict[str, list[dict]] = {"train": [], "val": [], "test": []} for rec in records: splits[rec["split"]].append(rec) clean_splits: dict[str, list[dict]] = {} for name, rows in splits.items(): cleaned = [] for rec in rows: cleaned.append( { "id": rec["id"], "has_image": rec["has_image"], "image_path": rec["image_path"], "question": rec["question"], "axiom_ids": rec["axiom_ids"], "assistant": rec["assistant"], } ) clean_splits[name] = cleaned write_jsonl(out / f"{name}.jsonl", cleaned) report = coverage_report([rec for recs in clean_splits.values() for rec in recs]) (out / "coverage.json").write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") (out / "split_manifest.json").write_text(json.dumps(manifest, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") (out / "dropped_ids.json").write_text(json.dumps(dropped, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") print_coverage(report) print("=== split sizes ===") for name, rows in clean_splits.items(): n_img = sum(1 for r in rows if r["has_image"]) n_txt = len(rows) - n_img max_chars = max((len(r["assistant"]) for r in rows), default=0) print(f"{name:5} n={len(rows):5} text={n_txt:4} image={n_img:4} max_assistant_chars={max_chars}") if report["pct_with_axiom"] < 25.0: print("WARNING: >=1 axiom coverage is under 25%. Loosen matcher rules before training.", file=sys.stderr) return 2 return 0 if __name__ == "__main__": raise SystemExit(main())