matthewshu/scgpt-replogle-activations

scGPT activation captures on Replogle (base vs ESM)

Per-cell layer-{5,7,10} hidden states from the two scGPT checkpoints in matthewshu/scgpt-replogle-base-ft and matthewshu/scgpt-replogle-esm-ft, captured over the same 72,100-cell balanced sample of the State-Replogle-Filtered 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 (~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 (~312 GB), same layout

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

Both runs share:

Source code commit	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 384 = 19,200 cells/shard
Compression	gzip-4 (lossless)
Hardware	NVIDIA H100 PCIe (80 GB)

The two captures differ only in the model: base loads replogle_base_ft/best_model.pt directly; ESM 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).

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), 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 (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 not bit-reproducible across runs.

Files

• 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.
• training_stats.json — provenance for the underlying model: wandb run URL, epoch count, best validation pearson_delta, total training cells.

Source

mattshu0410/sc-interp — the runner and HookManager/H5ActivationSink that produced these captures.