Datasets:
File size: 4,255 Bytes
c427f62 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 | """Compile test.jsonl + sanity.jsonl from curation_pool.jsonl.
No hand-curation: the whole curation pool is promoted as the
evaluation corpus. A small stratified slice is carved out for
sanity.jsonl (training smoke-test); the remainder becomes test.jsonl.
Stratification is by category (method for teaching programs,
pattern_class for session interpretation) so both splits reflect the
pool's distribution.
Reads:
data/splits/curation_pool.jsonl
Writes:
data/splits/test.jsonl
data/splits/sanity.jsonl
Usage:
uv run python src/compile_curation.py
uv run python src/compile_curation.py --sanity-n 20 --seed 42
"""
import argparse
import json
import random
import sys
from collections import Counter, defaultdict
from pathlib import Path
REPO_ROOT = Path(__file__).resolve().parent.parent
POOL_PATH = REPO_ROOT / "data" / "splits" / "curation_pool.jsonl"
TEST_JSONL = REPO_ROOT / "data" / "splits" / "test.jsonl"
SANITY_JSONL = REPO_ROOT / "data" / "splits" / "sanity.jsonl"
def category_of(example: dict) -> str:
gl = example["meta"]["gold_labels"]
if example["meta"]["task_type"] == "teaching_program":
return gl.get("method", "?")
return gl.get("pattern_class", "?")
def stratified_sanity_sample(
pool: list[dict], sanity_n: int, rng: random.Random
) -> tuple[list[dict], list[dict]]:
"""Carve sanity_n stratified examples out of the pool; return (test, sanity)."""
by_cat: dict[str, list[dict]] = defaultdict(list)
for ex in pool:
by_cat[category_of(ex)].append(ex)
# Largest-remainder method: allocate sanity slots proportional to category size.
total = len(pool)
raw_quotas = {cat: sanity_n * len(exs) / total for cat, exs in by_cat.items()}
floor_quotas = {cat: int(q) for cat, q in raw_quotas.items()}
remainder = sanity_n - sum(floor_quotas.values())
# Distribute remaining slots by largest fractional part.
fractional = sorted(
raw_quotas.items(), key=lambda kv: kv[1] - int(kv[1]), reverse=True
)
for cat, _ in fractional[:remainder]:
floor_quotas[cat] += 1
sanity: list[dict] = []
for cat, quota in floor_quotas.items():
if quota <= 0:
continue
picks = rng.sample(by_cat[cat], min(quota, len(by_cat[cat])))
sanity.extend(picks)
sanity_ids = {ex["meta"]["example_id"] for ex in sanity}
test = [ex for ex in pool if ex["meta"]["example_id"] not in sanity_ids]
return test, sanity
def tag_split(example: dict, split_name: str) -> dict:
"""Deep-copy and stamp the curation split label into meta."""
out = json.loads(json.dumps(example))
out["meta"]["curation"] = {"target_split": split_name}
return out
def main() -> int:
parser = argparse.ArgumentParser()
parser.add_argument("--sanity-n", type=int, default=20)
parser.add_argument("--seed", type=int, default=42)
args = parser.parse_args()
if not POOL_PATH.exists():
print(f"Curation pool missing: {POOL_PATH}", file=sys.stderr)
print("Run `uv run python src/split_data.py` first.", file=sys.stderr)
return 1
pool: list[dict] = []
with open(POOL_PATH) as f:
for line in f:
pool.append(json.loads(line))
if args.sanity_n >= len(pool):
print(
f"sanity_n ({args.sanity_n}) must be smaller than pool size ({len(pool)}).",
file=sys.stderr,
)
return 1
rng = random.Random(args.seed)
test, sanity = stratified_sanity_sample(pool, args.sanity_n, rng)
TEST_JSONL.parent.mkdir(parents=True, exist_ok=True)
with open(TEST_JSONL, "w") as f:
for ex in test:
f.write(json.dumps(tag_split(ex, "test")) + "\n")
with open(SANITY_JSONL, "w") as f:
for ex in sanity:
f.write(json.dumps(tag_split(ex, "sanity")) + "\n")
def fmt_dist(rows: list[dict]) -> str:
c = Counter(category_of(r) for r in rows)
return ", ".join(f"{k}={v}" for k, v in sorted(c.items()))
print(f"Wrote:")
print(f" {TEST_JSONL} {len(test)} examples ({fmt_dist(test)})")
print(f" {SANITY_JSONL} {len(sanity)} examples ({fmt_dist(sanity)})")
return 0
if __name__ == "__main__":
raise SystemExit(main())
|