BPE Tokenization

BPE builds a tokenizer's vocabulary by repeatedly merging the most frequent adjacent symbol pair. It starts from raw characters and learns, from the training corpus, which chunks deserve to be a single token. The visual steps through those merges one at a time.

Where you meet it

The tokenizers behind GPT, RoBERTa, BART and most modern LLMs.
Subword segmentation for machine translation — where BPE was introduced.
Any spot where a fixed word list would choke on names, typos or new slang.

What it does

It turns a giant, open-ended set of words into a fixed-size vocabulary of subwords. Frequent words end up as one token; rare words fall back to a few pieces; nothing is ever truly unknown. The model trains and runs on these token IDs, not on raw text.

The tokenizer is nothing but its ordered merge list — encoding any word, seen or unseen, just replays those rules in order. Same rules, same split, forever.

How it works

Training has two artefacts: a vocabulary and an ordered list of merge rules.

Split every word into single characters (plus an end-of-word marker). That's the base vocabulary.
Count every adjacent pair across the whole corpus, weighted by word frequency.
Merge the most frequent pair into one new symbol, and record that merge as a rule.
Repeat steps 2–3 until you hit the target vocabulary size.

Tiny corpus — low ×5, lower ×2, newest ×6, widest ×3. The pair e·s appears in newest and widest (9 times), so it merges first → es. Then es·t (9) → est. That fresh est next merges with the end-of-word mark · — also 9 times — into est·, since the marker counts as a symbol too. Only then comes the rarer l·o (7) → lo: BPE always takes the most frequent pair first. The learned rules, in order:

merges = [('e','s'), ('es','t'), ('est','·'), ('l','o'), ('lo','w'), ...]
# "newest" → n e w e s t → n e w es t → n e w est  (after rule 2)
# "lowest" (unseen) → encode with the same rules → low est

Encoding a new word just replays these rules in the order they were learned: split into characters, then apply each merge that still matches. Same rules, same result, every time.

Watch out

Vocabulary size is a trade-off. Bigger vocab → shorter token sequences but a larger embedding table; smaller vocab → the opposite. It's a hyperparameter you choose.
It's learned on a corpus. Merges reflect that training data — a tokenizer trained on English handles code or other languages less efficiently.
Byte-level BPE (GPT-2 onward) runs over raw bytes instead of Unicode characters, so the base vocabulary is just 256 symbols and nothing is out-of-vocabulary, ever.
The merges are greedy — picking the locally most frequent pair each step. The resulting segmentation is good, not provably optimal.

Go deeper

BPE baut das Vokabular eines Tokenizers, indem es wiederholt das häufigste benachbarte Symbol-Paar verschmilzt. Es startet bei einzelnen Zeichen und lernt aus dem Trainingskorpus, welche Bausteine ein eigenes Token verdienen. Das Visual geht diese Merges Schritt für Schritt durch.

Wo es vorkommt

Die Tokenizer hinter GPT, RoBERTa, BART und den meisten modernen LLMs.
Subwort-Segmentierung in der maschinellen Übersetzung — dort wurde BPE eingeführt.
Überall, wo eine feste Wortliste an Namen, Tippfehlern oder neuem Slang scheitert.

Was es tut

Es verwandelt eine riesige, offene Wortmenge in ein Vokabular fester Größe aus Subwörtern. Häufige Wörter werden ein Token, seltene zerfallen in wenige Teile, nichts ist je wirklich unbekannt. Das Modell trainiert und läuft auf diesen Token-IDs, nicht auf rohem Text.

Der Tokenizer ist nichts als seine geordnete Merge-Liste — jedes Wort, ob gesehen oder nicht, kodiert man, indem man diese Regeln der Reihe nach abspielt. Gleiche Regeln, gleicher Split, für immer.

Wie es funktioniert

Das Training erzeugt zwei Artefakte: ein Vokabular und eine geordnete Liste von Merge-Regeln.

Zerlege jedes Wort in einzelne Zeichen (plus Endmarker). Das ist das Basis-Vokabular.
Zähle jedes Nachbarpaar im ganzen Korpus, gewichtet nach Worthäufigkeit.
Verschmelze das häufigste Paar zu einem neuen Symbol und halte den Merge als Regel fest.
Wiederhole Schritt 2–3, bis die Ziel-Vokabulargröße erreicht ist.

Mini-Korpus — low ×5, lower ×2, newest ×6, widest ×3. Das Paar e·s kommt in newest und widest vor (9-mal), wird also zuerst verschmolzen → es. Dann es·t (9) → est. Dieses frische est verschmilzt als Nächstes mit dem Wortende-Zeichen · — ebenfalls 9-mal — zu est·, denn der Marker zählt als eigenes Symbol. Erst dann kommt das seltenere l·o (7) → lo: BPE nimmt immer zuerst das häufigste Paar. Die gelernten Regeln, der Reihe nach:

merges = [('e','s'), ('es','t'), ('est','·'), ('l','o'), ('lo','w'), ...]
# "newest" → n e w e s t → n e w es t → n e w est  (nach Regel 2)
# "lowest" (ungesehen) → mit denselben Regeln kodieren → low est

Encoding eines neuen Wortes spielt diese Regeln einfach in der gelernten Reihenfolge ab: in Zeichen zerlegen, dann jeden noch passenden Merge anwenden. Gleiche Regeln, gleiches Ergebnis, jedes Mal.

Worauf achten

Die Vokabulargröße ist ein Trade-off. Größeres Vokabular → kürzere Token-Sequenzen, aber größere Embedding-Tabelle; kleineres → umgekehrt. Ein Hyperparameter, den du wählst.
Es wird auf einem Korpus gelernt. Die Merges spiegeln diese Trainingsdaten — ein auf Englisch trainierter Tokenizer verarbeitet Code oder andere Sprachen weniger effizient.
Byte-Level-BPE (ab GPT-2) arbeitet auf rohen Bytes statt auf Unicode-Zeichen, das Basis-Vokabular sind also nur 256 Symbole — und nichts ist je out-of-vocabulary.
Die Merges sind greedy — jeder Schritt nimmt das lokal häufigste Paar. Die Segmentierung ist gut, aber nicht beweisbar optimal.