Dataset card: add the 8k batch-size grid, refresh run counts

README.md

@@ -12,7 +12,7 @@ pretty_name: rig training logs
 # rig training logs
 
 Complete training logs for every GPT pretraining run in
-[honglu2875/rig](https://github.com/honglu2875/rig) — 177 runs across six
+[honglu2875/rig](https://github.com/honglu2875/rig) — 237 runs across eight
 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. Nothing here is downsampled.
@@ -68,6 +68,7 @@ and the dashboards show them beside each run.
 | `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 |
 
 `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
@@ -180,6 +181,19 @@ second, separately labelled click that states the size before it starts:
 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. Every study is TPU v4, 4
+processes, 16 chips, except `batch-size-sweep-500M`, which mixes that with 6
+runs on TPU v6 lite at 1 process and 8 chips — its 20-TPP arm.
+
 ## Contents
 
 | report | runs | tier(s) | what varies | logs |
@@ -191,6 +205,7 @@ understand the packed log format — the two only have to agree about JSON.
 | [3-seed-gradient-spike](3-seed-gradient-spike.html) | 12 | 250M | LR × seed | [`lr-transfer-250M`](https://huggingface.co/datasets/quintic/rig-logs/tree/main/lr-transfer-250M) |
 | [8k-lr-sweep-60M](8k-lr-sweep-60M.html) | 15 | 60M | LR × seed at 8k context | [`lr-sweep-8k-60M`](https://huggingface.co/datasets/quintic/rig-logs/tree/main/lr-sweep-8k-60M) |
 | [moe-lr-sweep-8k](moe-lr-sweep-8k.html) | 18 | 60M/125M | LR × seed, top-2 of 8 experts | [`moe-lr-sweep-8k`](https://huggingface.co/datasets/quintic/rig-logs/tree/main/moe-lr-sweep-8k) |
+| [batch-size-grid-8k](batch-size-grid-8k.html) | 42 | 60M/125M | batch × LR × seed at 8k, dense and routed | [`batch-size-grid-8k`](https://huggingface.co/datasets/quintic/rig-logs/tree/main/batch-size-grid-8k) |
 | [transfer-charts](transfer-charts.html) | — | — | derived figures, not a run dashboard | — |
 
 Each study also carries a `snapshot.json.gz` (loss curves only, 0.05–0.30 MB)
@@ -369,6 +384,45 @@ for lr in 0.015625 0.0078125 0.00390625 0.001953125 0.0009765625; do
 done
 ```
 
+## batch-size-grid-8k.html
+
+42 runs extending the two 8k ladders to batch 32 and 64 — `reference_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.
+
+```bash
+for recipe in reference_8k reference_moe; do
+  tag=$([ "$recipe" = reference_8k ] && 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" --cluster v4-32 --profile dev --track open \
+          --tier 60m --tokens-per-parameter 5 --study-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
+```
+
 ## transfer-charts.html
 
 Not a run dashboard. Derived figures built from recorded results by