| |
| """Compute pretraining validation loss L(N,T) for pre2post-chess checkpoints. |
| |
| The paper's Fig. 3a relates post-RL pass@1 to the *pretraining validation |
| loss* on held-out human games. The authors' val split is not released, so we |
| reconstruct a proxy: a held-out sample of Lichess standard rated games from |
| 2023-01 (adjacent period to their 2022 corpus; same generator, properly held |
| out), filtered like their corpus (Elo 800-3000, >=10 plies, blitz/rapid-like |
| time controls). Games are scored with each checkpoint's own LAN tokenizer, |
| mean NLL per token over 1024-token windows. |
| |
| Downloads only a partial slice of the public .pgn.zst dump via HTTP Range. |
| Uploads one JSON per checkpoint to the results repo. |
| |
| No-arg invocation = sweep over the 20M/50M/200M/680M pretrain checkpoints. |
| """ |
| import argparse |
| import io |
| import json |
| import os |
| import re |
| import urllib.request |
|
|
| import torch |
| import chess |
| import chess.pgn |
| from huggingface_hub import HfApi, snapshot_download |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
|
|
| URL = "https://database.lichess.org/standard/lichess_db_standard_rated_2023-01.pgn.zst" |
| RANGE_BYTES = 80 * 1024 * 1024 |
| RESULTS_REPO = "ML-Intern-lab/pre2post-chess-replication" |
| PRETRAIN_REPO = "pavelslab-nyu/Chess-Pretrain-Models" |
| FAMILIES = ["20m", "50m", "200m", "680m"] |
|
|
|
|
| def fetch_partial_games(cache_path, range_bytes=RANGE_BYTES): |
| if os.path.exists(cache_path): |
| return open(cache_path).read() |
| import zstandard |
| req = urllib.request.Request(URL, headers={"Range": f"bytes=0-{range_bytes - 1}"}) |
| with urllib.request.urlopen(req, timeout=180) as resp: |
| dctx = zstandard.ZstdDecompressor().stream_reader(resp) |
| text = dctx.read().decode("utf-8", errors="ignore") |
| starts = [m for m in range(len(text)) if text.startswith("[Event ", m)] |
| text = text[: starts[4000]] if len(starts) > 4000 else text |
| os.makedirs(os.path.dirname(cache_path), exist_ok=True) |
| open(cache_path, "w").write(text) |
| return text |
|
|
|
|
| def filter_games(raw, max_games=3000): |
| out = [] |
| stream = io.StringIO(raw) |
| while len(out) < max_games: |
| game = chess.pgn.read_game(stream) |
| if game is None: |
| break |
| tc = game.headers.get("TimeControl", "") |
| base = tc.split("+")[0] |
| if base and base.isdigit() and int(base) not in (60, 120, 180, 240, 300, 600): |
| continue |
| try: |
| we, be = int(game.headers.get("WhiteElo", 0)), int(game.headers.get("BlackElo", 0)) |
| except ValueError: |
| continue |
| if not (800 <= we <= 3000 and 800 <= be <= 3000): |
| continue |
| b = game.board() |
| sans = [] |
| for mv in game.mainline_moves(): |
| sans.append(b.san(mv)) |
| b.push(mv) |
| if len(sans) < 10: |
| continue |
| out.append(" ".join(sans)) |
| return out |
|
|
|
|
| def windows_from_games(custom_tok, vocab, games, ctx=1024, min_tokens=64): |
| ids_all = [] |
| for g in games: |
| toks = custom_tok._pgn_to_tokens(g) |
| if not toks: |
| continue |
| ids = [vocab[t] for t in toks if t in vocab] |
| ids = [vocab["<bos>"]] + ids |
| for i in range(0, len(ids) - 1 - min_tokens, ctx): |
| w = ids[i:i + ctx] |
| if len(w) > min_tokens: |
| ids_all.append(w) |
| return ids_all |
|
|
|
|
| @torch.no_grad() |
| def eval_loss(model, vocab, windows, device, batch_size=16): |
| pad = vocab["<bos>"] |
| total, ntok = 0.0, 0 |
| for i in range(0, len(windows), batch_size): |
| batch = windows[i:i + batch_size] |
| maxlen = max(len(w) for w in batch) |
| input_ids = torch.full((len(batch), maxlen), pad, dtype=torch.long) |
| attn = torch.zeros((len(batch), maxlen), dtype=torch.long) |
| for j, w in enumerate(batch): |
| input_ids[j, :len(w)] = torch.tensor(w) |
| attn[j, :len(w)] = 1 |
| input_ids, attn = input_ids.to(device), attn.to(device) |
| logits = model(input_ids=input_ids, attention_mask=attn).logits |
| targets = input_ids[:, 1:] |
| mask = attn[:, 1:].bool() |
| ll = torch.nn.functional.cross_entropy( |
| logits[:, :-1].reshape(-1, logits[:, :-1].size(-1)).float(), |
| targets.reshape(-1), reduction="none").view(targets.shape) |
| sel = ll[mask] |
| total += sel.sum().item() |
| ntok += int(mask.sum().item()) |
| return total / ntok, ntok |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--n-games", type=int, default=3000) |
| ap.add_argument("--max-windows", type=int, default=2048) |
| ap.add_argument("--cache", default="/work/data/lichess_2023_01_head.pgn") |
| ap.add_argument("--families", nargs="+", default=FAMILIES) |
| ap.add_argument("--out-dir", default="/work/results/loss") |
| args = ap.parse_args() |
|
|
| raw = fetch_partial_games(args.cache) |
| games = filter_games(raw, args.n_games) |
| print(f"held-out games: {len(games)}", flush=True) |
|
|
| api = HfApi() |
| files = api.list_repo_files(PRETRAIN_REPO, repo_type="model") |
| runs = sorted(set(f.split("/")[0] for f in files |
| if f.startswith("model_") and "/" in f)) |
| runs = [r for r in runs if any(r.startswith(f"model_{fam}_") for fam in args.families)] |
| print(f"{len(runs)} checkpoints: {runs}", flush=True) |
|
|
| for run in runs: |
| out_path = os.path.join(args.out_dir, f"loss_{run}.json") |
| if os.path.exists(out_path): |
| print(f"[skip] {run} done", flush=True) |
| continue |
| try: |
| local = snapshot_download(PRETRAIN_REPO, allow_patterns=f"{run}/*") |
| path = os.path.join(local, run) |
| device = "cuda" if torch.cuda.is_available() else "cpu" |
| model = AutoModelForCausalLM.from_pretrained(path, trust_remote_code=True).to(device).eval() |
| tok = AutoTokenizer.from_pretrained(path, trust_remote_code=True) |
| custom, vocab = tok.custom_tokenizer, tok.custom_tokenizer._tok2id |
| windows = windows_from_games(custom, vocab, games)[: args.max_windows] |
| loss, ntok = eval_loss(model, vocab, windows, device) |
| |
| m = re.match(r"model_(\d+)m_([\d.]+)B", run) |
| size_m, tokens_b = (m.group(1), m.group(2)) if m else ("?", "?") |
| rec = {"run": run, "val_loss": loss, "n_tokens": ntok, |
| "n_windows": len(windows), "n_games": len(games), |
| "size_millions": int(size_m) if size_m != "?" else None, |
| "pretrain_tokens": float(tokens_b) * 1e9 if tokens_b != "?" else None} |
| os.makedirs(args.out_dir, exist_ok=True) |
| with open(out_path, "w") as f: |
| json.dump(rec, f) |
| del model |
| torch.cuda.empty_cache() |
| print(f"[loss] {run}: {loss:.4f} ({ntok} tokens)", flush=True) |
| try: |
| api.upload_file(path_or_fileobj=out_path, |
| path_in_repo=f"results/loss/loss_{run}.json", |
| repo_id=RESULTS_REPO, repo_type="dataset") |
| print(f"[upload] loss_{run}", flush=True) |
| except Exception as e: |
| print(f"[upload] FAILED {run}: {e}", flush=True) |
| except Exception as e: |
| print(f"[loss] {run} FAILED: {e}", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
