quintic/rig-logs

rig training logs

Complete training logs for every GPT pretraining run in honglu2875/rig — 342 runs across twelve studies, at full recorded resolution. Loss and learning-rate curves at every optimizer step; per-layer parameter, gradient, and update statistics at every diagnostic step. The raw logs themselves are not downsampled.

The dashboards in the GitHub repository are thinned summaries of these files. What follows mirrors that repository's audit, with report links pointing to their canonical GitHub locations.

Layout

<study>/
  <run-name>/
    training.riglog      loss, learning rate, gradient norm, per step
    diagnostics.riglog   per-scope statistics, per diagnostic step
    result.json          configuration, final metrics, provenance
    validation.csv       held-out loss
  records.jsonl          one ledger line per run
  snapshot.json.gz       compact selected curves, for lightweight consumers

Run names state what varies: 500m-20tpp-bs128-lr2e-8-s1337 is the 500M tier at 20 tokens per parameter, batch 128, base learning rate 2^-8, seed 1337.

A seed does not identify a run on its own

The training stream is invariant under the process count. The global batch sequence is fixed by the seed alone, and each rank takes a slice of it: _prepare_epoch mixes only the seed and the epoch, and next_batch advances a global cursor by the whole global batch. Verified directly — 1, 4, and 8 processes produce byte-identical global batches.

Results still differ across topologies. The same configuration and seed on 8 chips versus 16 lands 0.004 to 0.023 nats apart, which is the same size as the seed effect itself. The data is identical and so is the attention tile plan; both were checked. What differs is floating point: gradients are reduced across a different number of devices, so the sum is accumulated in a different order, and each chip holds a different number of sequences, which changes the shapes XLA compiles for. Neither is addressable by seeding, and both are the same non-associativity that makes any reduction order-dependent.

So --seed N plus the configuration does not pin a number; the topology is part of it. Every run records chip, data_processes and devices in its study's records.jsonl, alongside the full system block in result.json, and the dashboards show them beside each run.

study	hardware
batch-sweep-60M	TPU v4 — 4 processes, 16 chips
lr-batch-sweep-125M	TPU v4 — 4 processes, 16 chips
batch-sweep-250M	TPU v4 — 4 processes, 16 chips
batch-sweep-500M	mixed: 6 runs TPU v4 (4 proc, 16 chips), 6 runs TPU v6 lite (1 proc, 8 chips)
lr-transfer-250M	TPU v4 — 4 processes, 16 chips
lr-sweep-8k-60M	TPU v4 — 4 processes, 16 chips
moe-lr-sweep-8k	TPU v4 — 4 processes, 16 chips
batch-size-grid-8k	TPU v4 — 4 processes, 16 chips
seed-variance-60M	TPU v6 lite — 1 process, 8 chips
seed-variance-125M	TPU v4 — 4 processes, 16 chips
duration-ablation-60M	TPU v4 — 4 processes, 16 chips
duration-ablation-125M	TPU v4 — 4 processes, 16 chips

batch-sweep-500M is the only study spanning two chip types, and the split follows its 5- against 20-tokens-per-parameter arms. Those are separate experiments whose losses were never comparable, so the topology change does not cross a comparison that was being made.

The format

.riglog is a packed binary log: an 8-byte magic, a fixed header, a column table addressing each series by permanent integer ids, then fixed-width records. About 21x smaller than the long-form CSV it replaced, and it reads with one memory copy.

from huggingface_hub import hf_hub_download
from rig import logpack

path = hf_hub_download("quintic/rig-logs",
    "batch-sweep-60M/60m-5tpp-bs128-lr2e-8-s1337/training.riglog",
    repo_type="dataset")
log = logpack.read_log(path)
log.series("train_loss")                       # every optimizer step
log.series("grad.l2_norm", "block", 7)         # per-layer, from diagnostics

logpack.layout_descriptor() returns every offset and element type, derived from the definitions the writer uses, so a reader in another language can be built without reading the Python.

---

Every dashboard here, the runs behind it, and the command that reproduces it. Commands are demonstrative: they use the current CLI and reproduce the design, not the exact invocation from the time. Seeds, tiers, and grids are exact.

The logs live on HuggingFace

huggingface.co/datasets/quintic/rig-logs — 342 runs across twelve studies, laid out as <study>/<run-name>/, at full recorded resolution. That is the archive of record; its dataset card mirrors the GitHub report catalog and adds archive and reproduction metadata.

The dashboards committed here are summaries of those logs, thinned so they stay portable. Nothing in them is a substitute for the logs: they are one rendering at one fidelity, and a thinned curve is indistinguishable on screen from a complete one. When a number matters, read it from the .riglog.

from huggingface_hub import hf_hub_download
from rig import logpack

path = hf_hub_download(
    "quintic/rig-logs",
    "batch-sweep-60M/60m-5tpp-bs128-lr2e-8-s1337/training.riglog",
    repo_type="dataset",
)
log = logpack.read_log(path)
log.series("train_loss")          # every optimizer step

What "summary" means here

Every series is thinned to at most 1,440 points. Per-layer diagnostic charts additionally keep a bounded number of step frames — 8 for most studies, and more for the two where the per-layer behaviour is the subject rather than a by-product:

report	curve points	layer frames	size
batch-size-sweep-60M	1,440	400	44.3 MB
batch-size-sweep-500M	1,440	1,440	44.3 MB
batch-size-sweep-250M	1,440	8	15.4 MB
lr-batch-sweep-125M	1,440	8	8.2 MB
3-seed-gradient-spike	1,440	8	6.6 MB
8k-lr-sweep-60M	1,440	8	2.4 MB
moe-lr-sweep-8k	1,440	8	7.2 MB

The two large ones carry layer detail because gradient spikes are visible in it, and studying them is the point. This is deliberate discretion, not a default: keep it to a couple of files so the repository stays clonable.

Charts resample against the visible span as you zoom, keeping each pixel bucket's minimum and maximum rather than one representative point — so a spike inside the embedded data stays visible at every zoom level. It cannot recover a sample that thinning already dropped.

Charts are per-metric, and a metric no selected run recorded is not drawn at all — the panel is hidden rather than left as an empty frame. Routed runs record routing series a dense run never will, so most reports carry charts that do not apply to part of the selection, and a grid of empty frames would bury the ones that do.

The seed-variance report lives in the GitHub repository, not in this dataset. It first computes the across-seed mean and sample standard deviation at each exact step, then jointly thins against both statistics to at most 1,440 points. It excludes expert-indexed loads because expert identity is permutation-symmetric across seeds. This dataset keeps its full-resolution inputs and compact curve snapshots, not another copy of the HTML.

Which metrics get charted is a declared list in rig/report.py, separate from the metric registry, because how a quantity should be drawn is a judgement the registry cannot make. Everything so far is a line against the time axis; a distribution rather than a scalar — a routing histogram, say — wants bars against expert index and would arrive as a new chart kind rather than being bent into a timeline.

The study browser

study-browser.html carries no run data at all — about 56 KB. It lists the studies, renders each one's card from the dataset, and fetches only that study's overview (0.05–1.0 MB) when you pick one. The full logs are a second, separately labelled click that states the size before it starts: 6.4 MB for the 8k sweep, 138 MB for the 500M one. Nothing downloads on load.

Everything it fetches is an ordinary report payload, so the page never needs to understand the packed log format — the two only have to agree about JSON.

Hardware is part of a result

The same configuration and seed lands 0.004–0.023 nats apart on a 16-chip v4 slice versus an 8-chip v6e — the same size as the seed effect. The data is identical (the stream is invariant under process count, verified) and so is the attention tile plan; what differs is that gradients reduce across a different number of devices and each chip holds a different share of the batch.

Every dashboard therefore shows chip kind, chip count, and process count beside each run, and the run filter matches on chip. The 60M seed cohort is entirely TPU v6 lite at 1 process and 8 chips; the 125M cohort is entirely TPU v4 at 4 processes and 16 chips. batch-size-sweep-500M remains the only individual study that mixes the two topologies.

Contents

report	runs	tier(s)	what varies	logs
batch-size-sweep-60M	75	60M	batch × LR × seed	batch-sweep-60M
lr-batch-sweep-125M	27	125M	batch × LR × seed	lr-batch-sweep-125M
batch-size-sweep-250M	36	250M	batch × LR × seed	batch-sweep-250M
batch-size-sweep-500M	12	500M	batch × LR × seed, 5 and 20 TPP	batch-sweep-500M
3-seed-gradient-spike	12	250M	LR × seed	lr-transfer-250M
8k-lr-sweep-60M	15	60M	LR × seed at 8k context	lr-sweep-8k-60M
moe-lr-sweep-8k	18	60M/125M	LR × seed, top-2 of 8 experts	moe-lr-sweep-8k
batch-size-grid-8k	42	60M/125M	batch × LR × seed at 8k, dense and routed	batch-size-grid-8k
seed-variance	63	60M/125M	seed at a fixed MoE recipe	seed-variance-60M, seed-variance-125M
duration-ablation	42	60M/125M	fixed-TPP reference vs cross-horizon duration scaling	duration-ablation-60M, duration-ablation-125M
transfer-charts	—	—	derived figures, not a run dashboard	—

Each study also carries a compact snapshot.json.gz (0.05–1.0 MB of thinned curves). Some studies carry a separate diagnostic snapshot. These are what the study browser and derived visualizations load before anything larger.

---

batch-size-sweep-60M.html

75 runs: 5 batches × 5 learning rates × 3 seeds at 60M, 5 tokens per parameter, 1,024 context. The widest grid here, and what study 2 leans on.

for bs in 32 64 128 256 512; do
  for lr in 0.015625 0.0078125 0.00390625 0.001953125 0.0009765625; do
    for seed in 1337 1338 1339; do
      rig run reference --context 1k --cluster v4-32 --profile dev \
        --tier 60m --tokens-per-parameter 5 \
        --batch-size "$bs" --base-learning-rate "$lr" --seed "$seed" \
        --name "60m-bs${bs}-lr${lr}-s${seed}"
    done
  done
done
rig report --runs <batch-sweep-60M> --max-points 1440 --layer-snapshots 400 \
  --output docs/reports/batch-size-sweep-60M.html

lr-batch-sweep-125M.html

27 runs: 3 batches (64/128/256) × 3 learning rates (2^-7/2^-8/2^-9) × 3 seeds at 125M, 5 TPP, 1,024 context.

The grid is a batch × LR product, so either axis can be read as the subject. This replaces the former batch-size-sweep-125M.html and lr-sweep-125M.html, which were two renderings of these same 27 runs.

for bs in 64 128 256; do
  for lr in 0.0078125 0.00390625 0.001953125; do
    for seed in 1337 1338 1339; do
      rig run reference --context 1k --cluster v4-32 --profile dev \
        --tier 125m --tokens-per-parameter 5 \
        --batch-size "$bs" --base-learning-rate "$lr" --seed "$seed" \
        --name "125m-bs${bs}-lr${lr}-s${seed}"
    done
  done
done

batch-size-sweep-250M.html

36 runs: 4 batches (64/128/256/512) × 3 learning rates × 3 seeds at 250M, 5 TPP, 1,024 context.

Three runs — 250m-5tpp-bs512-lr2e-7, all three seeds — recorded diagnostics only from step 1920 onward. A report refuses a diagnostics log that does not start at step 1, because its axes would not line up with the training curve, so those three carry their partial series as diagnostics-partial.riglog: kept beside the run, not declared, read by nothing automatically. The runs still plot from their training curves rather than being dropped over it.

for bs in 64 128 256 512; do
  for lr in 0.0078125 0.00390625 0.001953125; do
    for seed in 1337 1338 1339; do
      rig run reference --context 1k --cluster v4-32 --profile dev \
        --tier 250m --tokens-per-parameter 5 \
        --batch-size "$bs" --base-learning-rate "$lr" --seed "$seed" \
        --name "250m-bs${bs}-lr${lr}-s${seed}"
    done
  done
done

batch-size-sweep-500M.html

12 runs at two token budgets. Run names carry the budget (500m-5tpp-… against 500m-20tpp-…) because the two are different experiments whose losses are not comparable to each other.

This is study 3's dashboard. It replaces both the former 500M-20tpp-v6e.html (three of these twelve) and 500M-20tpp-diagnostics.html, which existed only because those three were once the only 500M runs whose diagnostics could be read. All twelve can now.

# 5 TPP arm, batch bracket at the optimal LR
for bs in 128 256; do
  for seed in 1337 1338 1339; do
    rig run reference --context 1k --cluster v4-32 --profile dev \
      --tier 500m --tokens-per-parameter 5 \
      --batch-size "$bs" --base-learning-rate 0.00390625 --seed "$seed" \
      --name "500m-5tpp-bs${bs}-s${seed}"
  done
done

# 20 TPP arm on the v6e-8: batch bracket, then the LR bracket at batch 128
for bs in 64 128 256; do
  rig run reference --context 1k --cluster v6e-8 --profile dev \
    --tier 500m --tokens-per-parameter 20 --checkpoint-policy none \
    --batch-size "$bs" --base-learning-rate 0.00390625 --seed 1337 \
    --name "500m-20tpp-bs${bs}-s1337"
done
for lr in 0.0078125 0.001953125; do
  rig run reference --context 1k --cluster v6e-8 --profile dev \
    --tier 500m --tokens-per-parameter 20 --checkpoint-policy none \
    --batch-size 128 --base-learning-rate "$lr" --seed 1337 \
    --name "500m-20tpp-bs128-lr${lr}-s1337"
done

3-seed-gradient-spike.html

12 runs: 4 learning rates × 3 seeds at 250M, batch 128, 5 TPP. Built to settle the 250M reseed in study 1, and the evidence base for GRADIENT_SPIKES.md.

Its diagnostics were unreadable long-form CSV until they were converted, so for a while the dashboard about gradient spikes contained no gradient statistics at all.

for lr in 0.015625 0.0078125 0.00390625 0.001953125; do
  for seed in 1337 1338 1339; do
    rig run reference --context 1k --cluster v4-32 --profile dev \
      --tier 250m --tokens-per-parameter 5 \
      --batch-size 128 --base-learning-rate "$lr" --seed "$seed" \
      --name "250m-lr${lr}-s${seed}"
  done
done

8k-lr-sweep-60M.html

15 runs: 5 learning rates × 3 seeds of reference --context 8k — 60M at 8,192 context with document masking, batch 16 so tokens per step and step count match the 1,024-context ladder exactly. This is study 4.

for lr in 0.015625 0.0078125 0.00390625 0.001953125 0.0009765625; do
  for seed in 1337 1338 1339; do
    rig run reference --context 8k --cluster v4-32 --profile dev \
      --tier 60m --tokens-per-parameter 5 \
      --base-learning-rate "$lr" --seed "$seed" --checkpoint-policy none \
      --name "60m-bs16-lr${lr}-s${seed}"
  done
done

Historical MoE optimizer note

Every archived reference_moe run in moe-lr-sweep-8k, every routed arm in batch-size-grid-8k, and both seed-variance cohorts predate commit 102a264672c8453700a02e321495a14c585e58ea. The old AdamW mask inferred decay from array rank, so stacked rank-2 expert_up_b and expert_down_b bias tensors incorrectly received weight decay. We expect the numerical difference to be minor, but the corrected recipe cannot reproduce those runs bit-for-bit. The archived metrics remain observations of the pre-fix recipe; the commands below reproduce the study design with the corrected policy.

moe-lr-sweep-8k.html

18 runs of reference_moe — top-2 of 8 experts at 8,192 context, forked from the dense 8k ladder. 60M at five learning rates × three seeds, plus 125M spot runs at three learning rates.

The routed ladder peaks at 2^-8, the same learning rate the dense one does, and beats it at every learning rate by 0.07–0.12 nats at equal active parameters and matched compute, for about 1.7x the memory. No expert in any of the 12 layers finished below 1% of assignments in any of the 18 runs.

This report carries six routing series the dense reports do not have: balance loss, busiest and idlest expert share, routing entropy, mean top-1 gate, and router logit RMS. They are recorded model-wide and per layer, with per-expert load for all 8 experts in all 12 layers, at every step.

for lr in 0.015625 0.0078125 0.00390625 0.001953125 0.0009765625; do
  for seed in 1337 1338 1339; do
    rig run reference_moe --context 8k --cluster v4-32 --profile dev \
      --tier 60m --tokens-per-parameter 5 \
      --base-learning-rate "$lr" --seed "$seed" --checkpoint-policy none \
      --name "60m-moe-lr${lr}-s${seed}"
  done
done

batch-size-grid-8k.html

42 runs extending the two 8k ladders to batch 32 and 64 — reference --context 8k and reference_moe at 60M with three seeds per cell, reference_moe at 125M with one. Three learning rates at every batch, so no batch is judged at a rate picked for another. The batch-16 arm is not in this study: it is the ladder each family already had, in lr-sweep-8k-60M and moe-lr-sweep-8k.

The token budget is held fixed across batches, so doubling the batch halves the optimizer steps — 2,286 down to 571 at 60M. Batch 16 wins everywhere. The best batch-32 run costs 0.39 nats at 60M dense, 0.27 routed, 0.05 at 125M; the best batch-64 run costs 1.30, 1.15, and 0.31. Throughput is flat across the grid (1,041 → 1,100 → 1,093 TFLOP/s at 60M dense), so nothing is bought back in wall-clock. This reverses the 1,024-context ladder, where batch 128 was optimal and larger batches finished sooner on the same budget; at 8k a single sequence is eight times longer, so batch 16 already saturates the chips.

The apparent best learning rate moves between cells, but the seed spread grows with batch — median 0.011 at batch 16, 0.046 at 32, 0.068 at 64 — until it is as large as the gaps between rates. The drift is not resolvable at three seeds, and every large-batch cell is far worse than batch 16 at every rate tried, so it was not worth more machine time.

for recipe in reference reference_moe; do
  tag=$([ "$recipe" = reference ] && echo 8k || echo moe)
  for batch in 32 64; do
    for lr in 0.0078125 0.00390625 0.001953125; do
      for seed in 1337 1338 1339; do
        rig run "$recipe" --context 8k --cluster v4-32 --profile dev \
          --tier 60m --tokens-per-parameter 5 --batch-size "$batch" \
          --base-learning-rate "$lr" --seed "$seed" --checkpoint-policy none \
          --name "60m-${tag}-bs${batch}-lr${lr}-s${seed}"
      done
    done
  done
done

seed-variance.html (GitHub report)

Two incomplete but already substantial fixed-recipe cohorts: 41 of 64 planned seeds at 60M and 22 of 64 at 125M. The 60M seed-1369 artifact is excluded because it came from a dirty, different train.py; all 63 retained runs share the same recipe and config hashes. Final validation loss is 3.9357 ± 0.0167 at 60M and 3.5814 ± 0.0055 at 125M (mean ± sample SD).

The browser defaults to training loss against cumulative training FLOPs. Two panels plot the mean with a shaded ±1 sample-SD band and two plot the SD directly. It can switch among all retained training or diagnostic metrics; expert-indexed load curves are omitted because same-numbered experts do not correspond across seeds. Within a cohort, runs must share the exact step axis, columns, token accounting, and FLOP accounting or the builder refuses them. The 60M and 125M cohorts use different TPU topologies, so the paired display is not a controlled test of variance scaling across model size.

Because the seed controls both initialization and shuffled data order, raw training-loss and gradient SD also includes the composition of the current training batch. Fixed-set final validation is the cleaner endpoint model variance estimate.

The self-contained report is checked into docs/reports/seed-variance.html. This dataset deliberately contains only raw logs, provenance and reproduction information, plus compact curve snapshots used by derived visualizations. No bespoke seed-variance plotting script is retained. The study cards contain the current rig run commands; as the historical MoE note above explains, those commands reproduce the design with the corrected AdamW policy, not these pre-fix trajectories bit-for-bit.

duration-ablation.md

42 runs: two matching 21-run cohorts at 60M and 125M, all at 20 TPP. Each tier contains a three-point LR bracket for both the fixed-TPP reference and the cross-horizon duration treatment, plus the treatment's batch-512 iso-horizon point; every cell has seeds 1337–1339.

The reference keeps its 2^-8 base-LR optimum. The duration rule predicts that 2^-7 should compensate for its additional fourfold m_D, but that point is worse at both tiers and separated at 125M. Batch 512 is worse at 60M and tied with duration batch 128 at 125M, where both trail reference. The GitHub report contains the complete mean ± SD and statistical comparison tables.

The earlier batch-sweep-60M remains the separate 75-run batch × LR grid at 5 TPP. The new 60M cohort changes the horizon to 20 TPP and introduces the duration treatment; it does not duplicate that grid.

transfer-charts.html

Not a run dashboard. It is a self-contained derived visualization in the GitHub repository, built from the compact curve snapshots stored here. The HTML is retained; a bespoke plotting script is not.

---

Rebuilding

Download a study from the dataset and point rig report at it:

hf download quintic/rig-logs --repo-type dataset \
  --include 'batch-sweep-60M/*' --local-dir /tmp/rig-logs
rig report --runs /tmp/rig-logs/batch-sweep-60M \
  --max-points 1440 --layer-snapshots 400 \
  --output docs/reports/batch-size-sweep-60M.html

--max-points 0 --layer-snapshots 0 embeds every recorded sample. That is what the dataset holds; it makes a much larger file than anything committed here.

Two runs that are not in the dataset

• 20260816T213609.122328Z-…-37299d66 — a 500M run whose stdout.log was deleted while the process still held the descriptor, so no result.json was ever written. Its curves survive in the original archive but nothing records what it measured, so it cannot be placed on a chart.
• A studies directory inside the 60M archive, which is not a run.