card for benchmark eba8e0f953ffead6

README.md

@@ -1,60 +1,118 @@
 ---
 license: cc-by-4.0
-pretty_name: PLM speedrun, AFDB v6
+pretty_name: SpeedrunningPLMs
+task_categories:
+- fill-mask
 tags:
 - protein
+- protein-language-model
 - masked-language-modeling
 - benchmark
+- speedrun
+- alphafold
+- foldseek
+size_categories:
+- 1M<n<10M
 ---
 
-# PLM speedrun, AFDB v6
+# SpeedrunningPLMs: the benchmark data
 
-The fixed data of the SpeedrunningPLMs ten-minute protein masked language model benchmark
-([code](https://github.com/Synthyra/SpeedrunningPLMs)): AlphaFold DB proteins from the family-disjoint split of the
-Alignment Atlas (`Synthyra/alignment_atlas_families_afdb_v6` at `83737fa33e72`), tokenized once in the ESM2 alphabet, with the
-held-out splits' 15 percent masks materialized so every model is scored on the same hidden residues. No held-out
-protein has a training relative at 30 percent identity over 80 percent coverage by sequence (MMseqs2) or by structure
-(Foldseek). Benchmark id `eba8e0f953ffead6`: the SHA-256 of this manifest, carried by every run's result.
+**Train a protein language model in ten minutes on one GPU, and know exactly how good it is.** This is the fixed data
+of [SpeedrunningPLMs](https://github.com/Synthyra/SpeedrunningPLMs), a masked language model speedrun on proteins: 1,754,034 training
+proteins from the AlphaFold Database as one token stream, and held-out splits whose masks are drawn once, so every
+run, every seed and every reference model is scored on the same hidden residues. No held-out protein has a training
+relative at 30 percent sequence identity over 80 percent coverage, by sequence (MMseqs2) or by structure (Foldseek), so
+a lower loss means a model that generalizes across protein families, not one that remembers them.
 
-## Objective
+The benchmark id `eba8e0f953ffead6` is the SHA-256 of `manifest.json`; every result carries it, and two results
+compare only when it agrees.
 
-A model reads a protein (CLS, residues, EOS) with 15 percent of the standard residues replaced by MASK and nothing
-else, and predicts the hidden residues; the loss is the cross entropy over the 20 standard residues on the masked
-positions. `val_select` (one protein per validation family, truncated to 1,024 tokens) selects weights in a
-run; validation and test are scored at full length (up to 2,048 tokens). The train stream is one
-uint8 token stream of 1,754,034 proteins (392,592,221 tokens, 333,143 families) in a seeded
-shuffled order, with document offsets and the Foldseek 3Di state of every residue beside it; the 3Di states are never
-an input, only the target of a reported structure probe on a fixed 20,000-protein subset.
+## What a run does with it
+
+| Step | Rule |
+|---|---|
+| Corruption | 15 percent of the standard residues are replaced by MASK, nothing else; CLS, EOS and padding are never masked. Training uses the same corruption. |
+| Loss | Cross entropy over the 20 standard residues at the masked positions, in nats per masked residue. A model with a larger vocabulary (ESM2 has 33 tokens, ESMC 64) is scored on its 20 residue columns, so every model faces the same 20-way problem. |
+| Clock | Ten minutes of applied training steps on one GPU. Compile warmup and in-run validation are outside the clock and capped. |
+| Selection | The weights with the lowest loss on `val_select` (one protein per validation family, at most 1,024 tokens) are scored once on the full validation and test splits at full length (at most 2,048 tokens). The headline is the test loss. |
+| Structure probe | A linear probe from the hidden states to the 20 Foldseek 3Di states, trained on the fixed 20,000-protein subset and scored on validation and test. Reported beside the loss, never used for selection. |
 
 ## Splits
 
-| Split | Proteins | Families | Residues | Scored (masked) residues | Width |
+| Split | Proteins | Families | Residues | Scored (masked) residues | Max tokens |
 |---|---|---|---|---|---|
-| test | 25,778 | 4,807 | 6,098,489 | 915,208 | 1,927 |
+| train | 1,754,034 | 333,143 | 389,084,153 | drawn each step | free |
+| test | 25,778 | 4,807 | 6,098,489 | 915,208 | 2,048 |
 | val_select | 4,751 | 4,751 | 1,066,372 | 156,231 | 1,024 |
-| validation | 25,459 | 4,751 | 5,919,918 | 889,145 | 1,978 |
+| validation | 25,459 | 4,751 | 5,919,918 | 889,145 | 2,048 |
+
+Families are disjoint across the three splits, inherited from the Alignment Atlas family split of the AlphaFold
+Database (`Synthyra/alignment_atlas_families_afdb_v6` at `83737fa33e72`). `val_select` is a subset of validation: each
+family's longest representative, truncated, for the in-run selection; the full splits are scored once at the end.
+Lengths run from 50 to 2,046 residues, and every result reports the loss by length bin (50 to 99, 100 to 249, 250 to
+499, 500 to 999, 1,000 and more).
+
+## Where models stand
+
+Test loss on this data, every model scored by the same evaluator on the same masked residues. The reference models
+trained for days on UniRef, which shares sequences with these proteins, so their rows are a comparator rather than
+a fair baseline; the ten-minute record and the full table live in the [code repository](https://github.com/Synthyra/SpeedrunningPLMs).
+
+| Model | Trained on | Test loss |
+|---|---|---|
+| unigram residue frequencies | the floor | 2.8933 |
+| ESM2 8M | UniRef50, days | 2.6253 |
+| ESM2 35M | UniRef50, days | 2.4992 |
+| ESM2 150M | UniRef50, days | 2.3303 |
+| ESM2 650M | UniRef50, days | 2.0710 |
+| ESM2 3B | UniRef50, days | 1.8705 |
+| ESMC 300M | UniRef and more, days | 2.1269 |
+| ESMC 600M | UniRef and more, days | 2.0510 |
+| ESMC 6B | UniRef and more, days | 1.6891 |
+
+## Loading
+
+```bash
+pip install git+https://github.com/Synthyra/SpeedrunningPLMs
+```
+
+```python
+from pathlib import Path
+
+from huggingface_hub import snapshot_download
+from speedrunning_plms import benchmark
+
+data_dir = Path(snapshot_download("Synthyra/SpeedrunningPLMs", repo_type="dataset"))
+stream = benchmark.load_train(data_dir)                 # memory-mapped tokens, offsets, 3Di states, probe subset
+protein = stream.protein(0)                            # (length + 2,) uint8: CLS, residues, EOS
+test = benchmark.load_held_out(data_dir, "test")       # tensors sorted by descending length, digests verified
+metrics = benchmark.evaluate_split(model, test, device)  # any model exposing logits and its 20 residue columns
+```
+
+The files need no library to read: the streams are flat NumPy arrays (`np.memmap("train_tokens.u8", dtype=np.uint8)`)
+and the held-out files are `torch.load` dictionaries. Token ids are ESM2's: CLS 0, PAD 1, EOS 2, MASK 32, and the
+residues A 5, C 23, D 13, E 9, F 18, G 6, H 21, I 12, K 15, L 4, M 20, N 17, P 14, Q 16, R 10, S 8, T 11, V 7, W 22, Y 19. The 3Di classes index Foldseek's alphabet `ACDEFGHIKLMNPQRSTVWY` in order, with
+255 at positions that are not residues.
 
 ## Files
 
-| File | Bytes |
-|---|---|
-| `probe_subset.i64` | 160,000 |
-| `test.pt` | 149,531,512 |
-| `train_families.json` | 23,938,324 |
-| `train_offsets.i64` | 14,032,280 |
-| `train_three_di.u8` | 392,592,221 |
-| `train_tokens.u8` | 392,592,221 |
-| `val_select.pt` | 14,766,458 |
-| `validation.pt` | 151,576,442 |
-
-Every file's SHA-256 is in `manifest.json`; the loaders verify them.
-
-`train_tokens.u8` and `train_three_di.u8` are flat uint8 streams, `train_offsets.i64` the int64 start of every
-protein, `probe_subset.i64` the probe subset's indices, `train_families.json` the family of every training protein;
-`val_select.pt`, `validation.pt` and `test.pt` hold padded `input_ids`, `masked`, `three_di`, `family` and `lengths`
-tensors and the list of `families`. `speedrunning_plms.benchmark.load_train` and `load_held_out` read them and verify the digests.
+| File | Size | What it holds |
+|---|---|---|
+| `train_tokens.u8` | 374 MB | one uint8 ESM2 token stream of every training protein, CLS, residues, EOS, in a seed-0 shuffled order |
+| `train_offsets.i64` | 13 MB | int64: where each protein starts in the stream, plus the stream's end |
+| `train_three_di.u8` | 374 MB | uint8: the Foldseek 3Di class of every stream position, 255 at CLS and EOS |
+| `train_families.json` | 23 MB | the family of each training protein, in stream order |
+| `probe_subset.i64` | 156 KB | int64: the stream indices of the structure probe's 20,000 training proteins, one per family |
+| `val_select.pt` | 14 MB | the selection split: `input_ids`, `masked`, `three_di`, `lengths`, `family`, `families` |
+| `validation.pt` | 145 MB | the full validation split, the same tensors at full length |
+| `test.pt` | 143 MB | the full test split, the same tensors at full length |
+| `manifest.json` | small | the source, the objective, the seeds, every count and every file's SHA-256 |
+
+Every file's SHA-256 is in `manifest.json` and the loaders verify it, so a run cannot read altered data unnoticed.
 
 ## Source and terms
 
-AlphaFold DB sequences (CC-BY-4.0) and Foldseek 3Di states, through the Alignment Atlas family split; the source
-dataset's taxonomy is not audited here (see the workspace record).
+AlphaFold Database sequences (CC BY 4.0) and their Foldseek 3Di states, grouped into families by sequence and
+structure and split by family in Synthyra's Alignment Atlas. This release carries the tokens, the 3Di states and the
+family index of each protein, no coordinates. The dataset is CC BY 4.0; cite the [code repository](https://github.com/Synthyra/SpeedrunningPLMs) and the
+AlphaFold Database.