Tokenization und NLP-Grundlagen: BPE, SentencePiece und WordPiece

Tokenization ist der Prozess, Text in Untereinheiten (Tokens) aufzuteilen, die von einem Modell verarbeitet werden können. Dieser Prozess, der die Grundlage moderner LLMs bildet, beeinflusst die Modellleistung direkt.

Was ist Tokenization?

Tokenization ist der erste Schritt, um Rohtext in numerische Repräsentationen umzuwandeln:

"Hello world!" → ["Hello", "world", "!"] → [1234, 5678, 99]

Tokenization-Ebenen

1. Zeichenebene: Jedes Zeichen ist ein Token.
2. Wortebene: Jedes Wort ist ein Token.
3. Subword-Ebene: Wörter werden in kleinere Untereinheiten aufgeteilt (der moderne Ansatz).

Wortbasierte Tokenization

Einfacher Ansatz

1def word_tokenize(text):
2    return text.split()
3
4# Example
5text = "Artificial intelligence is shaping the future"
6tokens = word_tokenize(text)
7# ['Artificial', 'intelligence', 'is', 'shaping', 'the', 'future']

Probleme

1. OOV (Out of Vocabulary): Auftreten von Wörtern, die während des Trainings nicht gesehen wurden.
2. Großer Wortschatz: Verwaltung von Hunderttausenden Wörtern ist ineffizient.
3. Morphologischer Reichtum: In Sprachen wie Türkisch ist die Anzahl der Wortvarianten durch Suffixe enorm.
4. Komposita: Schwierigkeit zu bestimmen, ob „Artificial intelligence“ ein oder zwei Konzepte sein soll.

Zeichenbasierte Tokenization

1def char_tokenize(text):
2    return list(text)
3
4# Example
5text = "Hello"
6tokens = char_tokenize(text)
7# ['H', 'e', 'l', 'l', 'o']

Vorteile

• Kein OOV-Problem.
• Kleiner Wortschatz (~100 Zeichen).

Nachteile

• Sehr lange resultierende Sequenzen.
• Verlust von kontextueller Bedeutung auf Token-Ebene.
• Höhere Rechenkosten für das Modell.

Subword-Tokenization

Die Wahl moderner LLMs: ein Gleichgewicht zwischen Wort- und Zeichenebene.

"tokenization" → ["token", "ization"]
"unhappiness" → ["un", "happiness"] or ["un", "happy", "ness"]

BPE (Byte Pair Encoding)

Der am weitesten verbreitete Subword-Tokenization-Algorithmus.

BPE-Algorithmus

1. Text in einzelne Zeichen aufteilen.
2. Das häufigste Paar benachbarter Zeichen finden.
3. Dieses Paar zu einem neuen einzelnen Token zusammenführen.
4. Den Prozess wiederholen, bis die gewünschte Vokabulargröße erreicht ist.

BPE-Beispiel

1Starting vocabulary: ['l', 'o', 'w', 'e', 'r', 'n', 's', 't', 'i', 'd']
2Corpus: "low lower newest lowest widest"
3
4Step 1: Most frequent pair 'e' + 's' → 'es'
5Step 2: Most frequent pair 'es' + 't' → 'est'
6Step 3: Most frequent pair 'l' + 'o' → 'lo'
7Step 4: Most frequent pair 'lo' + 'w' → 'low'
8...
9
10Final Result: ['low', 'est', 'er', 'new', 'wid', ...]

BPE-Implementierung

1def get_stats(vocab):
2    pairs = {}
3    for word, freq in vocab.items():
4        symbols = word.split()
5        for i in range(len(symbols) - 1):
6            pair = (symbols[i], symbols[i + 1])
7            pairs[pair] = pairs.get(pair, 0) + freq
8    return pairs
9
10def merge_vocab(pair, vocab):
11    new_vocab = {}
12    bigram = ' '.join(pair)
13    replacement = ''.join(pair)
14    for word in vocab:
15        new_word = word.replace(bigram, replacement)
16        new_vocab[new_word] = vocab[word]
17    return new_vocab
18
19def train_bpe(corpus, num_merges):
20    vocab = get_initial_vocab(corpus)
21    
22    for i in range(num_merges):
23        pairs = get_stats(vocab)
24        if not pairs:
25            break
26        best_pair = max(pairs, key=pairs.get)
27        vocab = merge_vocab(best_pair, vocab)
28    
29    return vocab

WordPiece

Ein von Google entwickelter Algorithmus, der in Modellen wie BERT verwendet wird.

BPE vs WordPiece

WordPiece-Beispiel

1"tokenization" → ["token", "##ization"]
2"playing" → ["play", "##ing"]
3## SentencePiece
4
5Ein sprachunabhängiger Tokenizer, ebenfalls von Google entwickelt.
6
7### Features
8
9- **Sprachunabhängig:** Geht nicht davon aus, dass Leerzeichen Worttrenner sind.
10- **Byte-Level:** Arbeitet direkt auf Rohtext.
11- **BPE + Unigram:** Unterstützt mehrere Algorithmen.
12- **Reversibel:** Perfekte Detokenisierung ist möglich.
13
14### SentencePiece Usage
15
16```python
17import sentencepiece as spm
18
19# Training the model
20spm.SentencePieceTrainer.train(
21    input='corpus.txt',
22    model_prefix='tokenizer',
23    vocab_size=32000,
24    model_type='bpe'  # or 'unigram'
25)
26
27# Loading and using the model
28sp = spm.SentencePieceProcessor()
29sp.load('tokenizer.model')
30
31# Encode
32tokens = sp.encode('Hello world', out_type=str)
33# ['▁Hello', '▁world']
34
35ids = sp.encode('Hello world', out_type=int)
36# [1234, 5678, 9012]
37
38# Decode
39text = sp.decode(ids)
40# 'Hello world'

▁ (Unterstrich) Symbol

SentencePiece markiert den Beginn von Wörtern mit ▁:

"Hello world" → ["▁Hello", "▁world"]
"New York" → ["▁New", "▁York"]

Tiktoken (OpenAI)

Die spezialisierte BPE-Implementierung, die von OpenAI verwendet wird.

1import tiktoken
2
3# Loading the encoder
4enc = tiktoken.encoding_for_model("gpt-4")
5
6# Encode
7tokens = enc.encode("Hello world!")
8# [12345, 67890, 999]
9
10# Decode
11text = enc.decode(tokens)
12# "Hello world!"
13
14# Check token count
15print(len(tokens))  # 3

Model-Encoder Mappings

Hugging Face Tokenizers

1from transformers import AutoTokenizer
2
3# Loading the tokenizer
4tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
5
6# Encode
7encoded = tokenizer("Hello, world!", return_tensors="pt")
8# {
9#   'input_ids': tensor([[101, 7592, 1010, 2088, 999, 102]]),
10#   'attention_mask': tensor([[1, 1, 1, 1, 1, 1]])
11# }
12
13# Decode
14text = tokenizer.decode(encoded['input_ids'][0])
15# "[CLS] hello, world! [SEP]"
16
17# Token List
18tokens = tokenizer.tokenize("Hello, world!")
19# ['hello', ',', 'world', '!']

Fast Tokenizers

1from tokenizers import Tokenizer, models, trainers, pre_tokenizers
2
3# Creating a new tokenizer
4tokenizer = Tokenizer(models.BPE())
5tokenizer.pre_tokenizer = pre_tokenizers.Whitespace()
6
7trainer = trainers.BpeTrainer(
8    vocab_size=30000,
9    special_tokens=["[PAD]", "[UNK]", "[CLS]", "[SEP]", "[MASK]"]
10)
11
12tokenizer.train(files=["corpus.txt"], trainer=trainer)
13tokenizer.save("my_tokenizer.json")

Special Tokens

Common Special Tokens

Chat Tokens

1<|system|>You are a helpful assistant<|end|>
2<|user|>Hello!<|end|>
3<|assistant|>Hello! How can I help you today?<|end|>

Tokenization Challenges in Turkish

Morphological Richness

1"gelebileceklermiş" (they were said to be able to come) → Ein einzelnes Wort, aber komplexe Struktur
2gel (come) + ebil (can) + ecek (will) + ler (they) + miş (reportedly)
3
4Tokenization:
5- Poor: ["gelebileceklermiş"] (Ein einzelnes, sehr seltenes Token)
6- Good: ["gel", "ebil", "ecek", "ler", "miş"]

Solutions

1. Türkisch-optimiertes Tokenizer-Training.
2. Integration morphologischer Analyse.
3. Suffix-bewusste BPE-Anwendung.

Tokenlimits und -verwaltung

Kontextfenster

Schätzung der Tokenanzahl

1def estimate_tokens(text):
2    # Rough estimate: 1 token ≈ 4 characters (English)
3    # For Turkish: 1 token ≈ 3 characters
4    return len(text) // 3
5
6# More accurate calculation
7def count_tokens(text, model="gpt-4"):
8    enc = tiktoken.encoding_for_model(model)
9    return len(enc.encode(text))

Fazit

Tokenisierung ist der grundlegende Baustein von NLP und LLMs. Subword-Methoden wie BPE, WordPiece und SentencePiece spielen eine entscheidende Rolle für den Erfolg moderner Sprachmodelle. Die Wahl und Konfiguration des richtigen Tokenizers hat direkten Einfluss auf die endgültige Leistung des Modells.

Bei Veni AI bieten wir Tokenisierungsstrategien an, die auf türkische NLP-Lösungen spezialisiert sind.