docs: README reflects 4-shard shuffled layout and per-D running stats

README.md

@@ -17,24 +17,31 @@ Per-cell layer-{5,7,10} hidden states from the two scGPT checkpoints in
 and [matthewshu/scgpt-replogle-esm-ft](https://huggingface.co/matthewshu/scgpt-replogle-esm-ft),
 captured over the same 72,100-cell balanced sample of the
 [State-Replogle-Filtered](https://huggingface.co/datasets/arcinstitute/State-Replogle-Filtered)
-dataset (4 cell lines: K562, RPE1, Jurkat, HepG2). Intended for crosscoder
-diffing and other mechanistic-interpretability analyses comparing the two
-models on identical inputs.
+dataset. Sample is balanced over `(cell_line, gene)` buckets at 25 cells per
+bucket. Intended for crosscoder diffing and other mechanistic-interpretability
+analyses comparing the two models on identical inputs.
 
 ## Layout
 
 ```
 matthewshu/scgpt-replogle-activations/
 ├── README.md
-├── base/                                    ← scGPT-base capture (~293 GB)
-│   ├── shard-00000.h5 … shard-00022.h5     (23 shards × 14 GB, 50 batches/shard)
-│   ├── stats.h5                            (Welford running mean/M2 per capture)
+├── base/                                   ← scGPT-base capture (~313 GB)
+│   ├── shard-00000.h5 … shard-00003.h5     (4 shards, 50 batches × batch 384)
+│   ├── stats.h5                            (per-D Welford running mean/M2 per capture)
 │   ├── predictions.h5ad                    (3.78 GB, .X = pred, .layers["truth"] = real)
 │   └── training_stats.json                 (epochs, wandb URL, best val pearson_delta)
-└── esm/                                     ← scGPT+ESM capture (~292 GB), same layout
+└── esm/                                    ← scGPT+ESM capture (~312 GB), same layout
 ```
 
-Total: ~600 GB across 50 files.
+Total: ~625 GB across 14 data files (7 per side).
+
+| shard | cells | layout |
+|---|---|---|
+| 0 | 19,200 | full (50 × 384) |
+| 1 | 19,200 | full |
+| 2 | 19,200 | full |
+| 3 | 14,500 | partial (last batch trims to 72,100 total) |
 
 ## Capture configuration
 
@@ -42,12 +49,13 @@ Both runs share:
 
 | | |
 |---|---|
-| Source code commit | [`44805af`](https://github.com/mattshu0410/sc-interp/tree/44805af) |
+| Source code commit | [`7384c03`](https://github.com/mattshu0410/sc-interp/tree/7384c03) |
 | Runner | `python -m scripts.run scgpt --dataset replogle --split sample` |
 | Sample | `--sample-by cell_line,gene --sample-n-per-bucket 25 --seed 42` → 72,100 cells across 2,884 buckets |
+| Sample order | `rng.permutation`-shuffled at sample build time, so each shard interleaves cell lines and perturbations |
 | Capture layers | `transformer_encoder.layers.{5,7,10}` |
 | Capture dtype | fp16 |
-| Shard size | 50 batches × batch 64 = 3,200 cells/shard |
+| Shard size | 50 batches × batch 384 = 19,200 cells/shard |
 | Compression | gzip-4 (lossless) |
 | Hardware | NVIDIA H100 PCIe (80 GB) |
 
@@ -56,13 +64,34 @@ The two captures differ **only** in the model: base loads
 `replogle_esm_ft/best_model.pt` after constructing the model with the frozen
 ESM2-15B per-gene prior (`scgpt_esm_prior.safetensors`, 5120 → 512 linear).
 
-## Determinism
+## Sample order: shuffled, not sorted
+
+Earlier versions of this dataset stored cells in obs-frame index order, which
+left each shard 100% one cell-line (K562 in early shards, RPE1 in later
+shards). Downstream SAE/crosscoder training therefore needed an explicit
+global shuffle to avoid mid-epoch distribution shift.
+
+The current capture seeds `rng.permutation` over the concatenated bucket
+indices (commit
+[`7384c03`](https://github.com/mattshu0410/sc-interp/commit/7384c03)), so
+each shard contains a mix close to the global proportion (empirically ~52/48
+K562/RPE1 per shard since the sample over-weights shared perts). Sequential
+`iter_chunks(chunk_rows=256)` plus chunk-local shuffle is now sufficient for
+IID-style training batches; no global-shuffle dataloader is needed downstream.
+
+## Determinism and base/esm alignment
 
 Same `--seed 42`, same dataset preprocessing, same balanced-sample bucket
-indices, same per-cell-line basal pairings. Train/val/test pair counts also
-match between runs (180,021 / 8,569 / 109,207). The 72,100-row sample is
+indices (and the same `rng.permutation` order from a single seeded RNG),
+same per-cell-line basal pairings. Train/val/test pair counts also match
+between runs (180,021 / 8,569 / 109,207). The 72,100-row sample is
 bit-identical at the cell-id level — only the captured activations differ.
 
+For every shard, `cell_id` arrays compare element-wise equal between
+`base/shard-NNNNN.h5` and `esm/shard-NNNNN.h5`, so position N in the base
+shard pairs with position N in the matching esm shard. This is the
+load-bearing invariant for crosscoder pairing.
+
 `obs.index` of `predictions.h5ad` matches `meta/cell_id` in each shard h5,
 so joining cells across files is by string key, not row index. CUDA RNG and
 hardware-level non-determinism mean the captured activations themselves are
@@ -70,17 +99,23 @@ not bit-reproducible across runs.
 
 ## Files
 
-- `shard-NNNNN.h5` — per-batch h5 layout from `H5ActivationSink` v3 (see
-  `scripts/interp/hook_sinks.py:181` in the source repo for the schema and
-  reader). Each shard contains the captured tensors keyed by capture name,
-  per-cell metadata (`cell_id`, `pert`, etc.), and Welford accumulators
-  under `<capture>/<tags>/running_stats/{count, mean, M2}`.
-- `stats.h5` — global Welford accumulators across all shards in this run,
-  flushed at sink close.
+- `shard-NNNNN.h5` — per-batch h5 layout from `H5ActivationSink` (see
+  `scripts/interp/hook_sinks.py` in the source repo for the schema and
+  reader). Each shard contains:
+  - the captured fp16 BTD tensor at
+    `<capture>/<tags>/activation` with shape `(B, T=1536, D=512)`,
+  - per-cell labels under `<capture>/<tags>/labels/{cell_id, pert,
+    cell_index, gene_dataset_ids}`,
+  - per-shard Welford accumulators at
+    `<capture>/<tags>/running_stats/{count, mean, M2}`.
+- `stats.h5` — global per-D Welford accumulators across all shards in this
+  run, flushed at sink close. Shape `(D,)` (token axis collapsed at write
+  time, suitable as the normalizer for crosscoder training without further
+  backfill).
 - `predictions.h5ad` — self-contained predictions (`.X` = predicted log-norm
-  expression, `.layers["truth"]` = ground truth). 0 control cells appended
-  (the sample loader already includes balanced controls as their own buckets,
-  unlike train/val/test where bulk controls get appended for cell-eval).
+  expression, `.layers["truth"]` = ground truth). 0 control cells appended:
+  the sample loader already includes balanced controls as their own buckets,
+  unlike train/val/test where bulk controls get appended for cell-eval.
 - `training_stats.json` — provenance for the underlying model: wandb run
   URL, epoch count, best validation `pearson_delta`, total training cells.