"""Training proof: do Shortlist's verdicts predict which environments GRPO can improve a small model on? For each Reasoning Gym family (the tasks behind OpenEnv's reasoning_gym_env, whose reward is the family's own `score_answer`), in two separate runs: python grpo_proof.py --predict-only --out results # 1. write predictions.json (and its SHA-256) first python grpo_proof.py --out results # 2. train, then compare with the predictions 1. Predict with Shortlist's rule (shortlist/trainee.py, the same rule the shortlist uses for the small model) from the trainee's own samples, drawn exactly as GRPO draws them (same prompt, temperature and length). 2. Score 200 held-out tasks before training (greedy), train with GRPO + LoRA on the environment's reward, score the same 200 tasks after. "Improved" means a paired bootstrap on those 200 tasks puts the gain above zero (p <= 0.05). Full precision (fp32): a T4 has no bf16, and fp16 can give NaN losses with Qwen3. """ from __future__ import annotations import argparse import json import random import time from pathlib import Path import hashlib import os import sys # TRL's GRPO trainer can't use nn.DataParallel, which Trainer picks when several GPUs are visible (Kaggle's T4 x2). os.environ.setdefault("CUDA_VISIBLE_DEVICES", "0") import numpy as np import reasoning_gym import torch from datasets import Dataset from peft import LoraConfig from transformers import AutoModelForCausalLM, AutoTokenizer from trl import GRPOConfig, GRPOTrainer # The trainee's prompt, sampling and Shortlist's rule live in shortlist/trainee.py; on Kaggle or Colab the # notebook writes that file next to this one. sys.path.insert(0, str(Path(__file__).resolve().parent.parent)) sys.path.insert(0, str(Path(__file__).resolve().parent)) try: from shortlist import trainee except ImportError: import trainee # type: ignore messages, clean = trainee.messages, trainee.clean def tasks(family: str, seeds: range) -> list[dict]: out = [] for seed in seeds: entry = reasoning_gym.create_dataset(family, seed=seed, size=1)[0] out.append({"family": family, "seed": seed, "question": entry["question"], "entry": json.dumps(entry, default=str)}) return out def score(family: str, seed: int, answer: str) -> float: ds = reasoning_gym.create_dataset(family, seed=seed, size=1) try: return float(ds.score_answer(answer=answer, entry=ds[0])) except Exception: # a malformed answer earns nothing, as in the environment return 0.0 @torch.no_grad() def sample(model, tok, rows: list[dict], n: int, greedy: bool, max_new: int, batch: int = 16) -> list[list[str]]: """n completions per row, generated in batches of rows (left-padded).""" tok.padding_side = "left" if tok.pad_token is None: tok.pad_token = tok.eos_token outs: list[list[str]] = [] batch = max(1, 32 // n) # at most 32 sequences in memory at once for i in range(0, len(rows), batch): chunk = rows[i:i + batch] prompts = [tok.apply_chat_template(messages(r["question"]), tokenize=False, add_generation_prompt=True, enable_thinking=False) for r in chunk] enc = tok(prompts, return_tensors="pt", padding=True).to(model.device) gen = model.generate(**enc, max_new_tokens=max_new, do_sample=not greedy, temperature=trainee.TEMPERATURE if not greedy else None, top_p=1.0 if not greedy else None, num_return_sequences=n, pad_token_id=tok.pad_token_id) texts = [clean(tok.decode(g[enc["input_ids"].shape[1]:], skip_special_tokens=True)) for g in gen] outs += [texts[j * n:(j + 1) * n] for j in range(len(chunk))] return outs def predict(model, tok, family: str, k: int, n_tasks: int, max_new: int) -> dict: rows = tasks(family, range(500, 500 + n_tasks)) groups = sample(model, tok, rows, k, greedy=False, max_new=max_new) scores = [[score(family, r["seed"], a) for a in g] for r, g in zip(rows, groups)] flat = [s for g in scores for s in g] pass1 = sum(s >= 1.0 for s in flat) / len(flat) passk = sum(any(s >= 1.0 for s in g) for g in scores) / len(scores) mean = sum(flat) / len(flat) disagree = sum(max(g) - min(g) > 1e-9 for g in scores) / len(scores) verdict = trainee.rule(pass1, mean, disagree) return {"family": family, "pass@1": pass1, f"pass@{k}": passk, "mean_score": mean, "grpo_signal": disagree, "shortlist_verdict": verdict, "prediction": "improves" if verdict == "improves" else "no change"} def evaluate(model, tok, family: str, n: int, max_new: int) -> dict: rows = tasks(family, range(100_000, 100_000 + n)) answers = [g[0] for g in sample(model, tok, rows, 1, greedy=True, max_new=max_new)] scores = [score(family, r["seed"], a) for r, a in zip(rows, answers)] return {"accuracy": sum(s >= 1.0 for s in scores) / n, "mean_score": sum(scores) / n, "scores": scores, "examples": [{"seed": r["seed"], "answer": a, "score": s} for r, a, s in list(zip(rows, answers, scores))[:5]], "answers": answers} # every answer, in seed order, so the result can be re-scored later def paired_gain(before: list[float], after: list[float], n: int = 10000) -> dict: """Mean gain on the same tasks, with a paired bootstrap p-value for 'gain <= 0'.""" d = np.asarray(after) - np.asarray(before) rng = np.random.default_rng(0) boots = rng.choice(d, (n, len(d))).mean(1) return {"gain": float(d.mean()), "ci95": [float(np.percentile(boots, 2.5)), float(np.percentile(boots, 97.5))], "p": float(np.mean(boots <= 0))} def main() -> None: ap = argparse.ArgumentParser() ap.add_argument("--families", default="basic_arithmetic,propositional_logic,word_sorting,leg_counting,letter_counting,chain_sum") ap.add_argument("--model", default=trainee.MODEL) ap.add_argument("--steps", type=int, default=100) ap.add_argument("--group", type=int, default=8) ap.add_argument("--prompts-per-step", type=int, default=4) ap.add_argument("--max-new", type=int, default=trainee.MAX_NEW_TOKENS) ap.add_argument("--eval-n", type=int, default=200) ap.add_argument("--predict-only", action="store_true", help="write predictions.json and stop") ap.add_argument("--predict-tasks", type=int, default=24) ap.add_argument("--lr", type=float, default=5e-5) ap.add_argument("--out", default="results") ap.add_argument("--predictions", help="a prediction file written in advance (default: /predictions.json)") args = ap.parse_args() out = Path(args.out) out.mkdir(parents=True, exist_ok=True) device = "cuda" if torch.cuda.is_available() else "cpu" dtype = torch.float32 tok = AutoTokenizer.from_pretrained(args.model) families = args.families.split(",") pred_path = Path(args.predictions) if args.predictions and not args.predict_only else out / "predictions.json" # 1. Predictions, as a separate run, written down before any training. if args.predict_only: base = AutoModelForCausalLM.from_pretrained(args.model, dtype=dtype).to(device) predictions = [predict(base, tok, f, args.group, args.predict_tasks, args.max_new) for f in families] body = json.dumps({"written_at": time.strftime("%Y-%m-%d %H:%M:%S %Z"), "model": args.model, "rule": f"shortlist/trainee.py: improves if mean score > {trainee.PASS_MIN}, pass@1 < {trainee.PASS_MAX}, " f"GRPO signal >= {trainee.GRPO_SIGNAL_MIN}", "settings": vars(args), "predictions": predictions}, indent=2) pred_path.write_text(body) digest = hashlib.sha256(body.encode()).hexdigest() (out / "predictions.sha256").write_text(digest + " predictions.json\n") print(body, f"\nSHA-256 {digest}", flush=True) return if not pred_path.exists(): raise SystemExit("Run with --predict-only first, so the predictions exist before any training.") predictions = json.loads(pred_path.read_text())["predictions"] results = [] for pred in predictions: family = pred["family"] model = AutoModelForCausalLM.from_pretrained(args.model, dtype=dtype).to(device) before = evaluate(model, tok, family, args.eval_n, args.max_new) train_rows = tasks(family, range(0, args.steps * args.prompts_per_step)) random.Random(0).shuffle(train_rows) ds = Dataset.from_list([{"prompt": messages(r["question"]), "seed": r["seed"]} for r in train_rows]) def reward(prompts, completions, seed, **_): texts = [c[0]["content"] if isinstance(c, list) else c for c in completions] return [score(family, s, clean(t)) for s, t in zip(seed, texts)] cfg = GRPOConfig( output_dir=str(out / f"ckpt-{family}"), max_steps=args.steps, learning_rate=args.lr, per_device_train_batch_size=4, gradient_accumulation_steps=args.group * args.prompts_per_step // 4, num_generations=args.group, max_completion_length=args.max_new, temperature=1.0, logging_steps=5, save_strategy="no", report_to=[], fp16=False, bf16=False, gradient_checkpointing=False, seed=0, ) trainer = GRPOTrainer(model=model, reward_funcs=[reward], args=cfg, train_dataset=ds, peft_config=LoraConfig(r=16, lora_alpha=32, target_modules="all-linear", task_type="CAUSAL_LM")) started = time.time() trainer.train() trained = trainer.model.merge_and_unload() if hasattr(trainer.model, "merge_and_unload") else trainer.model after = evaluate(trained, tok, family, args.eval_n, args.max_new) curve = [{"step": h.get("step"), "reward": h.get("reward")} for h in trainer.state.log_history if "reward" in h] gain = paired_gain(before["scores"], after["scores"]) improved = gain["p"] <= 0.05 and gain["gain"] > 0 res = {**pred, "before": {k: v for k, v in before.items() if k != "scores"}, "after": {k: v for k, v in after.items() if k != "scores"}, "gain": gain, "improved": improved, "held": improved == (pred["prediction"] == "improves"), "reward_curve": curve, "minutes": round((time.time() - started) / 60, 1)} results.append(res) (out / "results.json").write_text(json.dumps(results, indent=2)) print(f"{family}: predicted {pred['prediction']}; mean score {before['mean_score']:.3f} -> {after['mean_score']:.3f} " f"(gain {gain['gain']:+.3f}, p={gain['p']:.3f}); prediction held: {res['held']}", flush=True) del model, trainer, trained if device == "cuda": torch.cuda.empty_cache() if __name__ == "__main__": main()