Bouw en bewaar je eigen Nederlandse tokenizer

import json
import matplotlib.pyplot as plt

train_documents=[
    'De kleine robot leert kijken. De robot ziet een kat en een fiets. De kat ligt naast de fiets. Een leerling verandert de invoer en bekijkt de uitvoer. De leerling schrijft Python en controleert de berekening.\n',
    'Een model leert patronen uit voorbeelden. Een goed voorbeeld heeft een duidelijke invoer en een controleerbaar doel. We bewaren de testset apart. We bekijken het verlies tijdens het leren en kiezen een model met validatie.\n',
    'In de werkplaats bouwen we een tokenizer. De tokenizer bewaart alle spaties, leestekens en nieuwe regels. Ook café, ideeën en een vrolijke 🙂 blijven dezelfde tekst na coderen en teruglezen.\n'
]
heldout='De leerling ziet een vrolijke kat bij het café.\nEen onbekend woord: wolkenfiets! 🙂'

def pair_counts(sequences):
    counts={}
    for tokens in sequences:
        for pair in zip(tokens,tokens[1:]):
            counts[pair]=counts.get(pair,0)+1
    return counts

def merge_pair(tokens,pair,new_id):
    result=[]
    i=0
    while i<len(tokens):
        if i+1<len(tokens) and (tokens[i],tokens[i+1])==pair:
            result.append(new_id)
            i+=2
        else:
            result.append(tokens[i])
            i+=1
    return result

def train_bpe(documents,budget=20):
    if type(budget) is not int or not 0<=budget<=128:
        raise ValueError('Gebruik 0 tot 128 merges')
    if not isinstance(documents,list) or len(documents)>64 or any(not isinstance(text,str) or len(text.encode('utf-8'))>4096 for text in documents):
        raise ValueError('Gebruik maximaal 64 teksten van elk 4096 UTF-8-bytes')
    sequences=[list(text.encode('utf-8')) for text in documents]
    merges=[]
    lengths=[sum(map(len,sequences))]
    for rank in range(budget):
        counts=pair_counts(sequences)
        if not counts:
            break
        pair=min(counts,key=lambda p:(-counts[p],p))
        new_id=256+rank
        sequences=[merge_pair(tokens,pair,new_id) for tokens in sequences]
        merges.append((pair[0],pair[1],new_id))
        lengths.append(sum(map(len,sequences)))
    return {'merges':merges,'lengths':lengths}

def vocabulary(merges):
    if not isinstance(merges,list) or len(merges)>128:
        raise ValueError('Ongeldige mergelijst')
    vocab={i:bytes([i]) for i in range(256)}
    seen=set()
    for rank,rule in enumerate(merges):
        if not isinstance(rule,(list,tuple)) or len(rule)!=3 or any(type(n) is not int for n in rule):
            raise ValueError('Ongeldige mergeregel')
        a,b,new_id=rule
        if a not in vocab or b not in vocab or new_id!=256+rank or (a,b) in seen:
            raise ValueError('Onbekende of dubbele merge')
        if len(vocab[a])+len(vocab[b])>4096:
            raise ValueError('Tokenstuk groter dan 4096 bytes')
        vocab[new_id]=vocab[a]+vocab[b]
        seen.add((a,b))
    return vocab

def encode(text,merges):
    vocabulary(merges)
    ranks={(a,b):(rank,new_id) for rank,(a,b,new_id) in enumerate(merges)}
    tokens=list(text.encode('utf-8'))
    while len(tokens)>1:
        candidates={pair for pair in zip(tokens,tokens[1:]) if pair in ranks}
        if not candidates:
            break
        pair=min(candidates,key=lambda p:ranks[p][0])
        tokens=merge_pair(tokens,pair,ranks[pair][1])
    return tokens

def decode(tokens,merges):
    vocab=vocabulary(merges)
    if any(type(t) is not int or t not in vocab for t in tokens):
        raise ValueError('Onbekend token-ID')
    return b''.join(vocab[t] for t in tokens).decode('utf-8')

def save_tokenizer(merges):
    vocabulary(merges)
    return json.dumps({'version':1,'merges':merges},separators=(',',':'))

def load_tokenizer(text):
    if not isinstance(text,str) or len(text)>32768:
        raise ValueError('Ongeldig bestand')
    try:
        data=json.loads(text)
    except RecursionError as error:
        raise ValueError('Ongeldig JSON-bestand') from error
    if not isinstance(data,dict) or set(data)!={'version','merges'} or type(data['version']) is not int or data['version']!=1:
        raise ValueError('Ongeldig modelcontract')
    vocabulary(data['merges'])
    return [tuple(rule) for rule in data['merges']]

def experiment(documents,unseen,budget):
    model=train_bpe(documents,budget)
    serialized=save_tokenizer(model['merges'])
    restored=load_tokenizer(serialized)
    samples=documents+[unseen,'','e\u0301 é 中文 🙂\n  <|end|>']
    roundtrips=all(decode(encode(text,restored),restored)==text for text in samples)
    return {'model':model,'serialized':serialized,'restored':restored,'roundtrips':roundtrips,
            'train_bytes':sum(len(t.encode('utf-8')) for t in documents),
            'train_tokens':sum(len(encode(t,restored)) for t in documents),
            'heldout_bytes':len(unseen.encode('utf-8')),'heldout_tokens':len(encode(unseen,restored))}

result=experiment(train_documents,heldout,32)
if result is not None:
    print('Geleerde merges:',len(result['restored']))
    print('Training: bytes → tokens',result['train_bytes'],'→',result['train_tokens'])
    print('Ongeziene tekst: bytes → tokens',result['heldout_bytes'],'→',result['heldout_tokens'])
    print('Exacte tekst-roundtrips:',result['roundtrips'])
    print('Tokenizer als JSON:',len(result['serialized'].encode('utf-8')),'bytes')
    fig,axes=plt.subplots(2,1,figsize=(5,5.8))
    lengths=result['model']['lengths']
    axes[0].plot(range(len(lengths)),lengths,marker='.',color='#278b74')
    axes[0].set(xlabel='Aantal geleerde merges',ylabel='Trainingtokens',title='Echte BPE-training')
    axes[1].bar(['UTF-8','BPE'],[result['heldout_bytes'],result['heldout_tokens']],color=['#d48e4c','#278b74'])
    axes[1].set(ylabel='Aantal eenheden',title='Apart gehouden tekst')
    for ax in axes:
        ax.tick_params(labelsize=12)
        ax.xaxis.label.set_size(13)
        ax.yaxis.label.set_size(13)
        ax.title.set_size(14)
    fig.tight_layout()