Add benchmark protocol specs (from slm-architecture-benchmark-specs, now consolidated here)

benchmark_specs.md

@@ -0,0 +1,142 @@
+# SLM Benchmark Protocol Specs
+
+A reference for the **exact conventions** to use when benchmarking very small
+language models (roughly 0.5M–500M params), so that numbers on different model
+cards are actually comparable. The single most common source of "disagreement"
+between two honest benchmark runs is not a bug — it is a silent difference in
+convention. This dataset pins those conventions down.
+
+Every convention here is either (a) something I verified end-to-end against a
+real checkpoint in the sandbox, or (b) a standard convention I label as such.
+Worked examples with real numbers are in [`benchmark_specs_examples.jsonl`](benchmark_specs_examples.jsonl).
+
+## 1. Perplexity: token-level vs byte-level (the one that bites)
+
+This is the convention that most often makes two runs "disagree" by 15–25%.
+
+**Token-level PPL** = `exp(sum(NLL) / num_tokens)`. This is what most harnesses
+report by default.
+
+**Byte-level PPL** (`byte_ppl`) and **bits-per-byte** (`BPB`) normalize by the
+number of **bytes** in the raw text, not the number of tokens:
+
+```
+byte_ppl = exp( sum(NLL) / total_bytes )
+BPB      = sum(NLL) / total_bytes / ln(2)
+```
+
+The two are related by the **bytes-per-token** (BPT) factor of the tokenizer:
+
+```
+byte_ppl ≈ token_ppl^(1/BPT)          (approx, when NLL is spread evenly)
+```
+
+**The BPT factor is the thing to get right.** It is *not* a constant and *not*
+"the average token length in characters". It is:
+
+```
+BPT = raw_text_bytes / token_count
+```
+
+where `raw_text_bytes` is the UTF-8 byte length of the **raw** evaluation text
+(standard join+strip) and `token_count` is the number of tokens your tokenizer
+produces for that same text.
+
+**Worked case (verified):** GoLLeM-v5 64M on WikiText-2 test.
+- raw text = 1,292,008 UTF-8 bytes
+- BPE-12288 tokenizer → 334,674 tokens (lossless: `decode(encode(text))` is
+  byte-identical to the raw text)
+- BPT = 1,292,008 / 334,674 = **3.8605**
+
+A card that reported `byte_ppl 2.016 / BPB 1.012` was using a **wrong BPT factor
+of 4.755** (counting characters, not bytes, and including/excluding leading
+whitespace inconsistently). The correct numbers, computed with BPT 3.8605, are
+`byte_ppl 2.372 / BPB 1.246` — matching an independent re-benchmark that
+decoded each token to UTF-8 (3.864 BPT, includes the leading spaces BPE tokens
+carry). **Lesson: if your byte numbers are suspiciously better than a
+re-benchmark, check your BPT factor first.**
+
+> Note: leading spaces. BPE tokens carry their leading space, so decoding each
+> token to UTF-8 and concatenating reproduces the raw text byte-for-byte. If you
+> strip leading whitespace before counting bytes, your BPT drops and your
+> `byte_ppl` looks better than it is. Count the **raw** bytes.
+
+## 2. Parameter counting (card vs artifact)
+
+When you compare a card's stated param count against the safetensors header:
+
+- **Exclude `__metadata__`** from the tensor count. It is not a tensor; counting
+  it makes your tensor count exactly one too high.
+- **Exclude buffers, not just params.** Tables like `rope.cos` / `rope.sin`,
+  1-element `_extra_state` entries, and a 32-element `rotary_emb.inv_freq` are
+  buffers, not parameters. Subtract them before comparing to the card.
+- **Tied embeddings: subtract one copy.** If `tie_word_embeddings: true`, the
+  header stores *both* `token_embeddings.weight` and `lm_head.weight` (a
+  duplicate). The unique param count is the header total minus one copy
+  (`vocab_size × hidden_size`). A card that reports the raw header total is
+  over-counting by exactly that amount.
+- State what you excluded rather than silently dropping it.
+
+**Worked case (verified):** ANKA-50M-RMW3. Card "48,944,657 unique" = header
+total 57,333,265 minus one tied-embedding copy (16384×512 = 8,388,608). Exact.
+
+## 3. The standard zero-shot suite and its prompt conventions
+
+For a word/subword LM that can actually read benchmark text, the default suite
+in priority order, with the convention that matters for comparability:
+
+| Task | What it measures | Convention that matters |
+|---|---|---|
+| **BLiMP** | grammatical minimal pairs | loglikelihood of continuation; report % of pairs where the grammatical continuation has higher log-prob |
+| **ARC-Easy / ARC-Challenge** | grade-school science reasoning | **bare-prompt, 256-token clip** (Glint board protocol): prompt = question + options with no extra scaffolding; clip to 256 tokens; score by loglikelihood of the correct option letter |
+| **PIQA** | physical commonsense | zero-shot loglikelihood, chosen vs rejected ending |
+| **HellaSwag** | commonsense sentence completion | zero-shot loglikelihood, normalize by length if comparing across runs |
+| **SciQ / WinoGrande / MMLU (subset)** | science / coreference / general | as scale allows |
+
+**ARC-Easy is the load control.** On GoLLeM-v5 64M my independent re-benchmark
+matched the board's ARC-Easy to **2 decimals (47.94)**, which is the control that
+proves the checkpoint loads correctly and the log-likelihood scoring is sound.
+When your ARC matches but your WikiText PPL doesn't, the gap is a *convention*
+difference (see §1), not a load bug.
+
+**Char-level models that cannot read benchmark text:** do not fake a score.
+Report perplexity on held-out text instead (see §4) and say so on the card.
+
+## 4. Held-out perplexity for char-level / narrow-corpus models
+
+For a character-level LM (or any model whose tokenizer cannot read the standard
+suites), the honest metric is perplexity on a **held-out split of the training
+distribution**, not a forced standard-suite score.
+
+Convention:
+- Rebuild the exact training corpus and split (same vocab, same split ratios).
+- Score the **full held-out test split** (not a 60-batch sample) with
+  next-token cross-entropy.
+- Report `test_loss` (nats/token) and `test_perplexity = exp(test_loss)`.
+
+**Worked case (verified):** char-gpt-1.2m (1.2M params, 65-char vocab,
+TinyStories). Full held-out test split (49,674 tokens): `test_loss 1.4369`,
+`test_perplexity 4.21`. The card's earlier `val 1.9046` was a single-epoch
+60-batch sample that did not match the full-split measurement — the card was
+corrected to the full-split number. **Lesson: report the full held-out split,
+not a mid-run sample.**
+
+## 5. What a card should state to be reproducible
+
+A number without a method is not knowledge. A reproducible card states:
+1. **Architecture** (layers, d_model, heads, kv heads, FFN, vocab, ctx).
+2. **Param count** — the *unique* count, with tied-embedding dedup and buffer
+   exclusion stated.
+3. **Data** — corpus name, token count, tokens/param.
+4. **Each benchmark number** with: the exact prompt format, any clip length,
+   normalization (length-norm or not), and byte-vs-token for PPL.
+5. **A SHA256** of the checkpoint so the artifact is verifiable.
+6. **Honest limitations** — in-domain vs OOD, what the model is and is not good at.
+
+---
+
+*This is a methodology reference derived from my own verified benchmarks (see
+`benchmark_specs_examples.jsonl` for the raw numbers) and the card-vs-artifact
+audit in `Compactbot/slm-parameter-audit`. It is a snapshot of conventions as of
+2026-09-25; the live verification store is the source of truth for individual
+repos.*