tokenizer_stats.md

Phase 01 — tokenizer results

Trained on 2,119,719 TinyStories documents (full train split); measured on 2,000 held-out validation documents.

Measured on the TinyStories validation split, which no tokenizer was trained on. Holding out by document rather than by offset matters: a random-offset split leaks the tail of a training document into validation.

The comparison

vocab	actual	fertility (tok/word)	bytes/token	tokens/doc	embedding params	% of 12.6M budget
2,048	2,048	1.399	3.67	217.3	786,432	6.2%
8,192	8,192	1.226	4.19	190.4	3,145,728	25.0%
32,768	32,768	1.214	4.23	188.5	12,582,912	99.9%

What the embedding column means

At d_model = 384 and a 12.6M parameter budget, a 32,768 vocabulary costs 12,582,912 parameters — 100% of the whole model, tied. Untie the output projection and it is double that. The model would be almost entirely vocabulary and almost no transformer, which is why small models use small vocabularies.

Sequence-length inflation

vocab	tokens/doc	vs 8k	consequence at fixed seq_len
2,048	217.3	1.14x	0.88x the documents per batch
8,192	190.4	1.00x	1.00x the documents per batch
32,768	188.5	0.99x	1.01x the documents per batch

This is the confound Ablation 1 has to control for. A 2k model at a fixed seq_len sees fewer documents per step than a 32k model, so a raw comparison of final loss is not a comparison of the vocabulary alone.

Dead vocabulary entries

Entries occurring fewer than 100 times in the held-out set:

vocab	never seen	seen < threshold	dead total	dead %	live
2,048	222	1,148	1,370	66.9%	678
8,192	2,266	5,482	7,748	94.6%	444
32,768	26,228	6,100	32,328	98.7%	440

LEARNING.md 1.6 cites a TinyStories reproduction finding roughly 42k of a ~50k vocabulary effectively dead. The table above is this project's own measurement; see the discussion in results/phase01.md for whether it confirms or refutes that.

Naive vs fast

The hand-written implementation from slm/tokenizer/bpe_naive.py, on 10.0MB:

• 256 merges in 730.1s (2852ms per merge)
• projected to 32,512 merges: ~25.8 hours (an upper bound — per-merge cost falls as the stream shortens)
• the Rust implementation trained the same 32,768 vocabulary on the full corpus in 1054s

The naive loop is O(corpus) per merge: it rescans and rewrites every sequence to apply one merge. Production implementations pre-tokenize on a regex and count over a word-frequency dictionary instead of the raw stream, so each merge touches unique words rather than every occurrence.