| |
| """Join teacher labels with the exact s10-mini context the teacher saw. |
| |
| Output rows: {key, month, row_idx, side, labeler, system, user, labels}. |
| Split is by game (hash of month|row_idx), so both sides of a game land in the |
| same split. Selection is a deterministic hash bucket, not the file order |
| (the labels file is player-ordered and starts with a long apertus-only run). |
| """ |
| from __future__ import annotations |
|
|
| import argparse |
| import gzip |
| import hashlib |
| import json |
| import sys |
| from collections import defaultdict |
| from multiprocessing import Pool |
| from pathlib import Path |
|
|
| ROOT = Path(__file__).resolve().parents[2] |
| sys.path.insert(0, str(ROOT / "prompt-ablation")) |
| sys.path.insert(0, str(ROOT / "src")) |
|
|
| import types |
|
|
| |
| |
| sys.modules.setdefault("autolabel.providers", types.ModuleType("autolabel.providers")) |
| import production_label as P |
| from autolabel import corpus |
|
|
| DATA_ROOTS = [ROOT / "data/2b", Path("/iopsstor/scratch/cscs/ibadanin/projects/llm_chess/data/2b")] |
|
|
|
|
| def data_root(month: str) -> Path: |
| return next((r for r in DATA_ROOTS if (r / month / "_SUCCESS").exists()), DATA_ROOTS[0]) |
|
|
|
|
| def bucket(month: str, row_idx: int) -> int: |
| h = hashlib.blake2b(f"{month}|{row_idx}".encode(), digest_size=8).digest() |
| return int.from_bytes(h, "little") % 10000 |
|
|
|
|
| def split_of(b: int, n_val: int, n_train: int) -> str | None: |
| if b < n_val: |
| return "val" |
| if b < 2 * n_val: |
| return "test" |
| if b < 2 * n_val + n_train: |
| return "train" |
| return None |
|
|
|
|
| def build_month(args): |
| month, rows = args |
| P.DATA_2B = data_root(month) |
| cache = P.MonthCache() |
| out = [] |
| for r in sorted(rows, key=lambda r: r["row_idx"]): |
| try: |
| meta, moves, local = cache.get(month, r["row_idx"]) |
| g = P.decode_game(meta, moves, local, month, r["side"]) |
| ctx = corpus.build_context(g, r["side"], card=P.VARIANT.card, moves=P.VARIANT.moves, |
| anonymise=P.VARIANT.anonymise, reveal_result=P.VARIANT.reveal_result) |
| except Exception as e: |
| out.append({"error": f"{type(e).__name__}: {e}", "key": r["key"]}) |
| continue |
| msgs = P.VARIANT.messages(ctx) |
| out.append({"key": r["key"], "split": r["split"], "month": month, "row_idx": r["row_idx"], |
| "side": r["side"], "labeler": r["labeler"], "elo": r.get("elo"), |
| "system": msgs[0]["content"], "user": msgs[1]["content"], "labels": r["labels"]}) |
| return out |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--labels", default=str(ROOT / "labels/labels_clean_2026-09-29.jsonl.gz")) |
| ap.add_argument("--out", default=str(ROOT / "data/labeler")) |
| ap.add_argument("--val-buckets", type=int, default=5) |
| ap.add_argument("--train-buckets", type=int, default=600) |
| ap.add_argument("--workers", type=int, default=64) |
| ap.add_argument("--labeler", default="", help="keep only this teacher (e.g. gemma)") |
| a = ap.parse_args() |
|
|
| by_month = defaultdict(list) |
| with gzip.open(a.labels, "rt") as f: |
| for line in f: |
| d = json.loads(line) |
| if a.labeler and d.get("labeler") != a.labeler: |
| continue |
| s = split_of(bucket(d["month"], d["row_idx"]), a.val_buckets, a.train_buckets) |
| if s is None: |
| continue |
| d["split"] = s |
| d["key"] = f"{d['month']}:{d['row_idx']}:{d['side']}" |
| by_month[d["month"]].append(d) |
| print("selected", sum(map(len, by_month.values())), "records over", len(by_month), "months", flush=True) |
|
|
| out_dir = Path(a.out) |
| out_dir.mkdir(parents=True, exist_ok=True) |
| files = {s: open(out_dir / f"{s}.jsonl", "w") for s in ("train", "val", "test")} |
| counts, errors = defaultdict(int), 0 |
| with Pool(a.workers) as pool: |
| for rows in pool.imap_unordered(build_month, sorted(by_month.items(), key=lambda kv: -len(kv[1]))): |
| for r in rows: |
| if "error" in r: |
| errors += 1 |
| continue |
| files[r["split"]].write(json.dumps(r) + "\n") |
| counts[(r["split"], r["labeler"])] += 1 |
| for f in files.values(): |
| f.close() |
| print("counts", dict(counts), "errors", errors, flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
