Pre-to-Post-2/scaling_law_fitting_data

Scaling-law fitting data (chess, pretraining → SFT → RL)

These are the tables we use to fit the RL scaling law in our chess pre-to-post-training project. Each language model is pretrained on chess games, fine-tuned (SFT) on puzzle solutions with reasoning traces, and then trained with RL on chess puzzles.

File	Rows	One row per
rl_curve_points.csv	2,226	(RL run, RL evaluation step), for 38 RL runs
pretraining_properties.csv	81	pretrained model in the isoflop grid (loss, pass@1, pass@16)

Join the two tables with pretraining_properties.rl_run_id == rl_curve_points.run_id. Of the 81 pretrained models, 34 have an RL run in this release.

Setup and naming

• Compute budget. Each model belongs to a compute class C_total ∈ {6.5e18, 6.5e19} FLOPs. A run named C6p5e18_50m_alpha1.000_beta0.023 has C_total = 6.5e18, a model of about 50M parameters, alpha = 1.0 and beta = 0.023.
  • alpha is the pretraining share: pretraining compute is alpha · C_total = 6 · N · T.
  • beta is the SFT share.
• Benchmarks. Every score is a macro-average over four held-out chess-puzzle benchmarks, test_B1–test_B4, with 308 / 298 / 267 / 287 puzzles.
• What counts as solved. A puzzle counts as solved only when every one of the solver's moves is correct; the opponent's replies are scripted.
• pass@k. We use the unbiased estimator per puzzle, average it within each benchmark, then average the four benchmarks equally.
• Evaluation settings:
  • RL checkpoints: temperature 1, 16 samples per puzzle, at most 2,560 generated tokens. The model writes one reasoning block and then plays its moves.
  • Pretrained models: temperature 1, 16 or 32 samples per puzzle (eval_samples_per_prompt), at most 100 generated tokens, moves only.

rl_curve_points.csv

Column	Meaning
run_id, model_name	RL run (C{compute}_{size}_alpha{α}_beta{β})
rl_step	RL training step of the evaluated checkpoint
pretrain_compute_class, size_str, alpha_pretrain, beta_sft	run configuration
N_exact	model parameters
T, T_source	pretraining tokens. isoflop_derived means T = α · C_total / (6N); config means it was read from the training config
pretrain_loss_eval, pretrain_loss_train	final pretraining loss (definitions under pretraining_properties.csv)
sft_train_files, sft_train_tokens_seen, sft_train_tokens_response	SFT data files used, and SFT tokens processed (all tokens / response tokens)
rl_train_batch_size, rl_rollout_n, rl_ppo_epochs, rl_max_prompt_length	RL setup: 256 prompts per step, 8 samples per prompt, 1 epoch
rl_max_response_length	measured mean response length at this step, used for the FLOP count. Despite the name, it is not the generation cap
rl_per_step_flops, rl_per_step_tokens	FLOPs and tokens of one RL step at this point: N · bs · g · L · (4 + 6E) and bs · g · L, where L = prompt length + mean response length
rl_flops, rl_tokens	cumulative RL FLOPs and tokens up to rl_step. This is the x-axis of the law
rl_train_config_source	where the RL settings came from (mlflow run config, or default)
rl_reward_mean, rl_reward_se	B1–B4 mean score (equal to pass@1, since scores are 0/1) and its standard error
rl_pass_at_1, rl_pass_at_4, rl_pass_at_8, rl_pass_at_16	B1–B4 pass@k
rl_eval_subdir, rl_eval_response_max_len, rl_n_benchmarks_all, rl_n_benchmarks_canonical, rl_n_rows	evaluation bookkeeping: run folder, generation cap, benchmarks in the file / used (4), number of samples
pretrain_reward_mean, sft_reward_mean	B1–B4 pass@1 of the pretrained model and of the SFT model
R0, R0_se, r0_source	RL starting point: B1–B4 pass@1 of the SFT model the run started from

Reproducing our fit. Our per-run fit is weighted least squares of rl_reward_mean = A + B · (log10 rl_flops − log10 C_ref), where:

• the weights are 1 / rl_reward_se², with the standard error floored at 1e-3;
• C_ref is the median rl_flops of the run.

pretraining_properties.csv

This is the data behind our pretraining isoflop plots. Values are copied unchanged from our central table.

Column	Meaning
compute_class, compute_total, size_str, alpha	model configuration
N_exact	model parameters
T	pretraining tokens, α · C_total / (6N)
pretrain_compute_flops	α · C_total
pretrain_loss_eval	held-out next-token loss at the last logged evaluation of the pretraining run
pretrain_loss_train	training loss: mean of the last 10 logged values (the last value alone if fewer than 100 were logged)
pretrain_pass_at_1, pretrain_pass_at_16	B1–B4 pass@1 and pass@16 of the pretrained model
eval_samples_per_prompt	samples per puzzle in that evaluation (16 or 32)
rl_run_id	the RL run started from this model, if any