Tokenisatie en NLP‑Fundamentals: BPE, SentencePiece en WordPiece

Tokenisatie is het proces waarbij tekst wordt opgesplitst in sub-eenheden (tokens) die door een model verwerkt kunnen worden. Dit proces, dat de basis vormt van moderne LLM’s, heeft direct invloed op de modelprestaties.

Wat is Tokenisatie?

Tokenisatie is de eerste stap bij het omzetten van rauwe tekst naar numerieke representaties:

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

Niveaus van Tokenisatie

1. Karakterniveau: Elk karakter is een token.
2. Woordniveau: Elk woord is een token.
3. Subwoordniveau: Woorden worden opgesplitst in kleinere sub-eenheden (de moderne aanpak).

Tokenisatie op Woordniveau

Eenvoudige aanpak

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']

Problemen

1. OOV (Out of Vocabulary): Woorden tegenkomen die tijdens training niet zijn gezien.
2. Grote Woordenschat: Het beheren van honderdduizenden woorden is inefficiënt.
3. Morfologische Rijkdom: In talen zoals Turks is het aantal woordvarianten door achtervoegsels enorm.
4. Samenstellingen: Bepalen of "Artificial intelligence" één concept of twee is.

Tokenisatie op Karakterniveau

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

Voordelen

• Geen OOV‑probleem.
• Kleine woordenschat (~100 karakters).

Nadelen

• Resulterende sequenties zijn erg lang.
• Verlies van contextuele betekenis op tokenniveau.
• Hogere rekencapaciteit vereist door het model.

Subwoordtokenisatie

De keuze van moderne LLM’s: een balans tussen woord- en karakterniveau.

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

BPE (Byte Pair Encoding)

Het meest gebruikte subwoordtokenisatie-algoritme.

BPE‑algoritme

1. Splits tekst in individuele karakters.
2. Zoek het meest voorkomende paar aangrenzende karakters.
3. Voeg dit paar samen tot één nieuw token.
4. Herhaal dit proces totdat de gewenste woordenschatgrootte is bereikt.

BPE‑voorbeeld

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‑implementatie

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

Een algoritme ontwikkeld door Google en gebruikt in modellen zoals BERT.

BPE vs WordPiece

WordPiece‑voorbeeld

1"tokenization" → ["token", "##ization"]
2"playing" → ["play", "##ing"]
3## SentencePiece
4
5Een taalagnostische tokenizer die ook door Google is ontwikkeld.
6
7### Features
8
9- **Taalonafhankelijk:** Gaat er niet van uit dat witruimte een woordgrens is.
10- **Byte-level:** Werkt direct op ruwe tekst.
11- **BPE + Unigram:** Ondersteunt meerdere algoritmes.
12- **Reversibel:** Perfecte detokenisatie is mogelijk.
13
14### SentencePiece Gebruik
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'

▁ (Underscore) Symbool

SentencePiece markeert het begin van woorden met ▁:

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

Tiktoken (OpenAI)

De gespecialiseerde BPE-implementatie die door OpenAI wordt gebruikt.

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 Koppelingen

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', '!']

Snelle 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")

Speciale Tokens

Algemene Speciale 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 Uitdagingen in het Turks

Morfologische Rijkdom

1"gelebileceklermiş" (they were said to be able to come) → Eén woord maar complexe structuur
2gel (come) + ebil (can) + ecek (will) + ler (they) + miş (reportedly)
3
4Tokenization:
5- Poor: ["gelebileceklermiş"] (Single token, very rare)
6- Good: ["gel", "ebil", "ecek", "ler", "miş"]

Oplossingen

1. Turks-geoptimaliseerde tokenizer training.
2. Integratie van morfologische analyse.
3. Suffix-bewuste BPE-toepassing.

Tokenlimieten en -beheer

Contextvenster

Schatting van het aantal tokens

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))

Conclusie

Tokenisatie vormt de fundamentele bouwsteen van NLP en LLM’s. Subwoordmethoden zoals BPE, WordPiece en SentencePiece spelen een cruciale rol in het succes van moderne taalmodellen. Het kiezen en configureren van de juiste tokenizer heeft directe invloed op de uiteindelijke prestaties van het model.

Bij Veni AI bieden we tokenisatiestrategieën die gespecialiseerd zijn in Turkse NLP-oplossingen.