quintic/rig-logs

rig training logs

Complete training logs for every GPT pretraining run in honglu2875/rig — 505 archived runs across twenty-two 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
    metrics.json         compact final metrics
    validation.csv       held-out loss
    fuzzy_sparsity.rigvec        optional full per-feature vector history
    fuzzy_sparsity_lossy.rigvec  optional full-feature, widened-time companion
  records.jsonl          one ledger line per run
  lossy_records.jsonl    optional companion hashes and retained steps
  snapshot.json.gz       compact selected curves, for lightweight consumers
  full.json.gz           every recorded point, loaded explicitly by the browser

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
moe-no-bias	TPU v4 — 4 processes, 16 chips
moe-router-aux-125M	TPU v4 — 4 processes, 16 chips
moe-expert-load-scaling-125M	TPU v4 — 4 processes, 16 chips
moe-weight-decay	TPU v4 — 4 processes, 16 chips
moe-gumbel-local-125M	TPU v4 — 4 processes, 16 chips
sparse-autoencoder-eqflop-60M	TPU v4 — 4 processes, 16 chips
fuzzy-topk-three-arm-ladder	TPU v4 — 4 processes, 16 chips
fuzzy-topk-sparsity-diagnostics-ladder	TPU v4 — 4 processes, 16 chips
fuzzy-topk-balance-homeostasis-rejected	TPU v4 — 4 processes, 16 chips
fuzzy-topk-ghost-auxk-rejected	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.

.rigvec is the dense companion for metrics with a feature axis too large for the scalar column table. Its fixed records are step int32 + float32[metric, layer, feature]; the header records permanent metric ids, shape, group size, tokens per step, and FLOPs per token. It is memory-mapped by rig.vectorlog.read_vector_log, so multi-gigabyte histories can be reduced one capture at a time.

---

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 — 505 runs across twenty-two 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
moe-ablations	480 bins	—	0.07 MB
expert-load-scaling	exact endpoints	—	0.02 MB
moe-weight-decay	exact endpoints	—	0.04 MB
gumbel-local-moe	exact endpoints + mechanism reductions	—	0.03 MB
sparse-autoencoder-eqflop	exact endpoints + compute derivation	—	0.02 MB
fuzzy-topk-three-arm-ladder	exact endpoints + paired-seed/compute tables	—	0.03 MB
fuzzy-topk-sparsity-diagnostics	exact mechanism reductions + 40.19 GiB raw vectors	—	0.02 MB
fuzzy-topk-dead-latent-rejected-paths	exact endpoints + mechanism decisions	—	0.01 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.

The MoE ablation report is likewise kept on GitHub rather than duplicated here. Its exact endpoints and late-window summaries are derived from the logs in the two new studies; its only reduced trajectories are clean LM loss averaged into 480 FLOP bins. The 72 KiB page is static inline SVG with no runtime fetch.

The expert-load scaling report is also kept on GitHub. It uses exact validation endpoints and permutation-invariant reductions of the per-expert diagnostics. The 19 KiB page is static inline SVG with no runtime fetch; this dataset retains the full diagnostic trajectories.

The MoE weight-decay report is a 40 KiB static findings page with exact endpoints, three-seed sample-SD whiskers, and paired differences. This dataset retains the full trajectories for all 36 runs and both browser payloads.

The Gumbel-local MoE report is a prose-led 27 KiB mechanism study. Its three figures use exact endpoints, recorded cost multipliers, permutation-invariant router reductions, and the first identical update diagnostic. This dataset retains all eight runs, every block-local metric, and both browser payloads; the browser overview plots the four local metrics after averaging across blocks.

The sparse TopK MLP report is a 22 KiB static algorithmic study over one dense anchor and twelve sparse treatments. It derives the forward/backward contraction budget and the depth/whole-step equalization rule, then reports exact validation endpoints. This dataset retains all full-resolution trajectories and both browser payloads. Throughput is shown only to expose the present kernel limitation.

The fuzzy TopK three-arm report is a static paired-seed study over 24 complete runs. It compares dense GELU, fixed-group fuzzy TopK, and a doubly-fuzzy input-plus-hidden selector at matched total active matrix FLOPs. This dataset retains every complete trajectory, both browser payloads, exact source/config/data provenance, and the explicit incomplete-250M evidence boundary.

The fuzzy TopK sparsity report is a static mechanism study over twelve fuzzy-only runs from 60M through 500M. This dataset retains 40.19 GiB of cadence-10 full-neuron vectors, 0.891 GiB of exact widening-step companions, and the one-off interactive dead-layer, ridgeline, histogram, and positive-quantile views.

The fuzzy TopK dead-latent rejected-paths report is a static decision study over 42 new runs. The data is split into a 33-run balance/homeostasis path and a nine-run zero-forward ghost-AuxK path. Exact parent controls remain in the earlier sparsity archive and are referenced by run ID rather than copied. Both new folders escrow the intentionally unmerged source history, launch scripts, and full-neuron evidence.

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. Ordinary metrics remain lines against time or layer. The fuzzy sparsity study is the one explicit exception: zero-aware log-frequency histograms and positive quantiles render as dedicated histogram, ridgeline, and heatmap views rather than as scalar timelines.

The study browser

study-browser.html carries no run data at all — about 80 KB. It lists the studies, renders each one's card from the dataset, and fetches only that study's overview (0.05–1.1 MB) when you pick one. A separately labelled action loads full.json.gz, containing every recorded point, and states its size before it starts: 6.4 MB for the 8k sweep, 138 MB for the 500M one. Nothing downloads on load. Raw .riglog files remain separately browsable and exportable.

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
moe-ablations	23	60M/125M/250M	learned biases; router auxiliary-loss coefficient	moe-no-bias, moe-router-aux-125M
expert-load-scaling	5	125M	per-expert gradient/update scaling by current load	moe-expert-load-scaling-125M
moe-weight-decay	36	60M/125M	base AdamW weight decay × seed	moe-weight-decay
gumbel-local-moe	8	125M	Gumbel-routed local MoE steps × seed	moe-gumbel-local-125M
sparse-autoencoder-eqflop	13	60M geometry	dictionary width × retained width at equal algorithmic FLOPs	sparse-autoencoder-eqflop-60M
fuzzy-topk-three-arm-ladder	24	60M/125M/250M	dense vs fuzzy TopK vs double-fuzzy at matched active FLOPs	fuzzy-topk-three-arm-ladder
fuzzy-topk-sparsity-diagnostics	12	60M/125M/250M/500M	per-feature fuzzy TopK activity over training	fuzzy-topk-sparsity-diagnostics-ladder
fuzzy-topk-dead-latent-rejected-paths	42	60M/125M/250M	balance/homeostasis and zero-forward ghost-AuxK	fuzzy-topk-balance-homeostasis-rejected, fuzzy-topk-ghost-auxk-rejected
transfer-charts	—	—	derived figures, not a run dashboard	—

Each study also carries a compact snapshot.json.gz (0.05–1.1 MB of thinned curves) and a full-resolution full.json.gz for the study browser's explicit full-view action. Some studies carry a separate diagnostic snapshot. Compact snapshots are what the browser and derived visualizations load first.

---

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.

moe-ablations.html

Two post-AdamW-fix MoE studies, combined in the GitHub findings report:

• moe-no-bias has 18 paired runs: reference versus every learned bias removed, at 60M, 125M, and 250M with seeds 1337–1339. The paired mean no-bias penalties are +0.01429, +0.00107, and +0.00508 nats. No tier improves on average; all three 250M pairs favor the reference.
• moe-router-aux-125M holds seed 1350 fixed while sweeping coefficient 0, 0.001, 0.01, 0.03, and 0.1. Zero and 0.001 under-regularize and lose 0.06856 and 0.01863 nats against 0.01. Coefficients 0.01 and 0.1 are within 0.00057 nats despite the latter producing almost perfectly uniform loads in every layer.

The working recipe therefore keeps learned biases and coefficient 0.01. The coefficient sweep is single-seed; a refinement should replicate only 0.01 and 0.1. Same-index expert loads are not compared across runs because expert identities are permutation-symmetric. Each study card above contains its exact source hashes, reproduction command, tables, interpretation, and limitations.

expert-load-scaling.html

Five matched seed-1350 runs at 125M and 5 TPP compare the unchanged coefficient-0.01 MoE baseline with a load factor applied either before Adam's moments or to the normalized update. The factor for an expert is 1 + c * (sqrt(8 * current_load) - 1) at strengths 0.5 and 1.

The GitHub findings report shows that gradient scaling is nearly canceled by Adam: the busiest/idlest actual-update ratio stays at 1.00 and c=0.5 ties baseline within 0.00030 nats. Direct update scaling survives (ratio 1.19–1.43) but finishes 0.011–0.021 nats worse. This is one seed, so it rejects the current rule rather than estimating a precise effect size. The study card contains exact commits, hashes, commands, mechanism definitions, and the editor-swap provenance note.

moe-weight-decay.html

Thirty-six verified MoE runs sweep the base AdamW weight-decay coefficient at 60M and 125M, with seeds 1337–1339 at every cell. The larger tier extends the initial {0, 0.03, 0.1, 0.3} bracket through 0.4, 0.5, 0.6, and 0.8.

At 125M, base coefficient 0.3 wins all three paired seeds and improves the three-seed mean by 0.015184 nats over the 0.1 default. The minimum is broad through 0.5, turns upward at 0.6, and reaches the no-decay mean again at 0.8. At 60M, the raw mean selects 0.1, but the apparent reversal is dominated by one 0.3 run with an early gradient-norm spike of 20.41. The evidence supports 0.3 as a 125M-specific working choice; it does not yet establish either a cross-tier default or clean non-transfer.

The 40 KiB GitHub findings report contains exact endpoint and paired-seed plots plus the recipe's CompleteP/Complete(d)P scaling interpretation. This study's card contains the full tables, exact commits, recorded tree hashes, reproduction command, and the more detailed limitation.

gumbel-local-moe.html

Eight verified 125M runs test K={0,1,2,4} extra optimization steps inside every routed block. K=0 and K=2 have matched seeds 1350, 1369, and 1388; K=1 and K=4 are seed-1350 shape probes. Every inner step draws a fresh hard Gumbel top-2 route, retains clean mixture weights, and applies raw stateless SGD to a single activation/output-gradient-normalized objective. The normal outer AdamW update still happens exactly once.

K=2 changes the three-seed validation mean by +0.000021 nats while costing 1.344× traced FLOPs and 1.971× training time. Router balance improves modestly, but clean entropy falls and logit RMS rises, consistent with the router building margins against the perturbation. The first identical actual-update L2 norm changes by only 4.9 parts per million for K=2, showing that the local raw-SGD vector is tiny beside the outer AdamW update.

This rejects the tested realization, not all extra-compute MoE exploration. A follow-up should normalize the local delta against the observed outer MoE delta or its predicted output displacement, then log both contributions separately. Parameter/gradient/update diagnostics here are block-scoped only; per-expert router loads remain complete. The GitHub findings report contains the full interpretation, and this study's card contains exact tables, source/config/data hashes, limitations, and the reproduction grid.

sparse-autoencoder-eqflop.html

Thirteen verified seed-1350 runs compare the 60M dense GELU reference with a 3 × 4 grid of overcomplete TopK-ReLU MLPs at 8k context. Stored dictionary width is H/D ∈ {4,8,16} and retained width is K/D ∈ {4,2,1,1/4}. Every point targets the same 221.03-PFLOP full-model algorithmic training budget.

The sparse MLP charges 2DH for scoring all dictionary features, 2KD for the selected decoder, and 8KD for four active-width backward contractions: 2DH + 10KD per token and layer. The ordinary 4× dense MLP costs 48D². Selection, gathers/scatters, padding, memory traffic, and dense AdamW state are real costs but lie outside this matrix-contraction comparison.

One- and two-layer traces identify each coordinate's affine full-model cost F(L)=A+BL. The nearest integer depth is chosen first; whole schedule steps then match the dense total budget. The resulting grid uses 11–14 layers and 2,218–2,354 steps, with less than 0.02% total-compute mismatch. Parameter count and TPP vary intentionally, so this is an explicit-step equal-FLOP study rather than a fixed-TPP duration ladder.

H=16D,K=D,L=12 is best at 3.910170 validation loss, 0.090275 nats below the 4.000445 dense anchor. Moderate activity is consistently strongest at H=16D; K=D/4 gives much of the gain back. The H=4D,K=4D dense-ReLU control is 0.016506 nats worse than GELU, ruling out activation choice alone.

The evidence is one seed at one model geometry. The gathered implementation is also roughly 5–57× slower than dense across the grid, and the tested Pallas prototype is slower still on TPU v4. This is therefore a positive algorithmic signal and a negative result for the current kernel—not a wall-clock efficiency claim. The GitHub report contains the full derivation; the study card contains exact endpoints, source, config and data hashes, reproduction commands, and limitations.

fuzzy-topk-three-arm-ladder.html

Twenty-four verified paired-seed runs compare dense GELU, fixed-group fuzzy TopK, and a doubly-fuzzy input-plus-hidden selector at 8k context. Every explicit schedule matches its dense tier's total active matrix-FLOP budget within 0.02%; stored parameters and backend-issued FLOPs are not equated.

Fuzzy beats dense in all nine paired seeds, with mean improvements of 0.078033, 0.069399, and 0.076030 nats at 60M, 125M, and 250M. Double-fuzzy is worse than fuzzy in all six completed pairs by 0.076437 and 0.062993 nats at 60M and 125M, returning approximately to dense quality despite storing more parameters. The added inner selector restricts only the normalized input to the MLP update; the full pre-norm residual bypass remains unchanged.

The first double-fuzzy 250M run exceeded the 3,600-second development-harness timeout at step 5,970/9,296 and has no final result or canonical validation. The remaining two seeds were not launched. That partial curve and every short timing gate are excluded from this 24-run study, so no three-arm 250M quality claim is made.

Exact clean commits are fe2bd0f28888103fb473d0d8f70cca144a5488e9 (dense), 5d014ccdef84e179f9dc015e0e5f05871800fceb (fuzzy), and fd1d2542bc9d2735902a963a4eb24233526ac4fc (double-fuzzy). The GitHub findings report contains every endpoint, design/throughput table, interpretation, and limitation. This study's own card contains the source/config/data hashes, canonical manifest links, exclusion, and reproduction command.

fuzzy-topk-sparsity-diagnostics.html

Twelve verified fuzzy-only runs record full per-feature winner and positive activation behavior from 60M through 500M. Every block's H=16D stored features are observed on a 131,072-token global batch at step 1, every ten steps, and final. The raw .rigvec files total 40.19 GiB. Exact full-feature companions keep every capture through step 200, then 300, 500, 900, 1700, and doubled gaps plus final, totaling 0.891 GiB.

The observer is trajectory-neutral: all nine 60M–250M training.riglog files are byte-identical to the same-tier, same-seed uninstrumented fuzzy runs in the three-arm study. Almost every feature activates by step 1 and all do by step 10, but persistent inactivity is created later. At final, the fraction absent from ten consecutive sampled batches averages 34.33%, 35.76%, 33.87%, and 36.34% over layers and seeds at 60M, 125M, 250M, and 500M.

The effect is layer-structured. Block 1's dead fraction rises from 69.69% to 85.62% across the ladder while its normalized within-group winner entropy falls from 0.424 to 0.103; later blocks recover activity. The static report summarizes these reductions. The study browser carries the one-off tier/seed/ layer selectors, dead heatmap, activation-frequency ridgeline, draggable-step histogram, and positive-frequency quantiles.

“Dead” is defined on sampled observer batches and is not proof that a feature never fires elsewhere in the corpus. The study measures under-use; it does not test a revival, pruning, or reallocation intervention. records.jsonl retains the final 500M seed's notebook-dependency-only pyproject.toml/uv.lock dirt; trainer, shared Python tree, config, data, runtime, and topology identities are unchanged. The study card inside the folder gives exact endpoints, hashes, commands, metric definitions, limitations, and loading examples.

fuzzy-topk-dead-latent-rejected-paths.html

Forty-two verified runs preserve two attempted responses to late feature death without duplicating the nine parent controls already present in fuzzy-topk-sparsity-diagnostics-ladder.

The 33-run balance/homeostasis path includes 24 one-seed development and gate runs plus nine full frequency-floor treatments over 60M, 125M, and 250M. The selected bias-only floor reduces persistent death substantially at 60M and 125M. At 250M, the gain shrinks to 13.78%, dead groups rise from 8.31% to 8.80%, and validation worsens by 0.01133. It is rejected as a scale-general solution.

The nine-run ghost-AuxK path contains five systems gates and four 60M step-900 mechanism screens. Relative to tied initialization, the admitted zero-forward ghost coefficients reduce persistent death by only 0.29--0.57 percentage points, worsen validation by 0.0058--0.0102, and add 11--16% training time. It is rejected before laddering. This surrogate has no reconstruction decoder or target and does not test literal SAE AuxK.

The balance study card, ghost study card, and static report record the exact objectives, aligned endpoints, source histories, launchers, limitations, and restore procedures.

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.