💬 NLP

Are you going to finish that? A Practical Study of the Partial Token Problem

Dit artikel onderzoekt het "gedeeltelijke tokenprobleem" en toont aan dat realistische prompts die halverwege een token eindigen — met name in talen zonder spaties, samengestelde talen en code — ernstige waarschijnlijkheidsverstoringen veroorzaken in grote taalmodellen die niet verbeteren met schaalvergroting, terwijl de effectiviteit van exacte oplossingen tijdens de inferentie wordt gevalideerd.

Oorspronkelijke auteurs: Hao Xu, Alisa Liu, Jonathan Hayase, Yejin Choi, Noah A. Smith

Gepubliceerd 2026-02-04

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Hao Xu, Alisa Liu, Jonathan Hayase, Yejin Choi, Noah A. Smith

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Stel je voor dat je een spelletje "Maak de zin af" speelt met een zeer slimme, maar ietwat rigide robot. Je typt een zin en de robot moet het volgende woord raden.

Normaal gesproken werkt dit perfect. Maar dit artikel ontdekt een specifieke glitch waarbij de robot in de war raakt, niet omdat hij de woorden niet kent, maar omdat hij ze niet goed telt.

Hier is de onderverdeling van het probleem, het bewijs en de oplossing, met behulp van eenvoudige analogieën.

1. Het kernproblek: De "Half-Baksteen" Glitch

Denk aan de hersenen van de robot als een bibliotheek waar elk boek is gemaakt van bakstenen (tokens).

Jouw perspectief: Jij ziet woorden (zoals "appel" of "is").
Het perspectief van de robot: Hij ziet bakstenen. Somserkt één baksteen één heel woord. Soms dekt één baksteen twee woorden. Soms is een baksteen doormidden gesneden.

Het Partiële Token Probleem gebeurt wanneer je stopt met typen midden in een van deze bakstenen.

De analogie: Stel je voor dat de robot verwacht dat het woord "verwerken" één enkele, solide baksteen is.
De fout: Je typt "verwerk" en stopt.
De verwarring: De robot ziet "verwerk" en denkt: "Wacht, ik ken de baksteen 'verwerken'. Maar ik ken ook de baksteen 'verwerk'. Als ik nu gewoon de letters 'en' toevoeg, overtreed ik mijn eigen regels, want 'verwerken' hoort één onbreekbare baksteen te zijn!"

Omdat de robot getraind is om alleen hele bakstenen te zien, wordt hij doodsbang om het woord op de manier te voltooien die jij verwacht. Hij denkt: "Als je stopte bij 'verwerk', dan wil je waarschijnlijk niet dat er 'en' achter komt; je wilt waarschijnlijk iets totaal anders."

2. Waar gebeurt dit? (De Drie Vallen)

Het artikel ontdekte dat dit niet slechts een zeldzame Engelse glitch is. Het gebeurt vaak in drie specifieke situaties waarin "woorden" en "bakstenen" niet op één lijn liggen:

Talen zonder spaties (zoals Chinees): In het Engels vertellen spaties de robot waar een woord eindigt. In het Chinees zijn geen spaties. De robot moet raden waar één woord eindt en het volgende begint.
- Voorbeeld: De frase "is een" kan één enkele baksteen zijn. Als je "is" typt en stopt, heb je die baksteen doormidden gesneden. De robot raakt in paniek.
Talen die woorden aan elkaar plakken (zoals Duits): Duits combineert vaak twee woorden tot één groot woord (zoals "Eigelb" voor eigeel).
- Voorbeeld: Als de robot "Ei" ziet en je stopt daar, maar de robot denkt dat "Eigelb" één baksteen is, raakt hij in de war over wat er daarna komt.
Computercode: Code gebruikt symbolen zoals () of :. Vaak is een heel blok symbolen één baksteen.
- Voorbeeld: Als je def main() typt en stopt, maar de robot denkt dat (): één enkele baksteen is, loopt hij vast in de poging te raden wat het volgende symbool is.

3. Hoe erg is het? (De "Stille Crash")

De onderzoekers testten dit met veel verschillende robots (AI-modellen). De resultaten waren schokkend:

De daling in waarschijnlijkheid: Wanneer de robot gedwongen wordt te raden na een "half-baksteen", wordt hij 1.000 tot 10.000 keer minder zelfverzekerd dat hij het juiste antwoord moet geven. Het is als een student die het antwoord weet, maar zo bang is voor de beoordelingsregels van de leraar dat hij weigert het op te schrijven.
De daling in nauwkeurigheid: De robot geeft niet meer in 60% tot 95% van de gevallen het juiste antwoord. Hij slaat een letter over, voegt een vreemde spatie toe of geeft een volkomen verkeerd woord.
Groter is niet beter: Je zou kunnen denken: "Als we de robot slimmer maken (groter model), zal dat het probleem oplossen." Nee. Het artikel vond dat grotere, slimmere robots er juist slechter in zijn. Ze zijn zo getraind op hun specifieke "baksteen"-regels dat ze nog koppiger zijn om die regels niet te breken.

4. De Oplossingen: Hoe de glitch te repareren

Het artikel testte twee manieren om dit te repareren tijdens de "denkfase" (inferentie):

Methode A: "Token Healing" (De Terugtocht):
- Hoe het werkt: Als je "verwerk" typt en de robot is in de war, zegt deze methode tegen de robot: "Oké, vergeet het laatste deel. Doe alsof je alleen 'ver' zag."
- Het resultaat: Het helpt soms, maar het is een kwestie van geluk en pech. Het is alsof je een gebroken vaas probeert te repareren door de bovenkant eraf te snijden; het past misschien, maar het is niet perfect.
Methode B: "ByteSampler" (De Kaart):
- Hoe het werkt: In plaats van te gokken, tekent deze methode een kaart van elke mogelijke manier waarop de robot jouw zin had kunnen lezen. Het vindt het pad dat exact overeenkomt met jouw tekst en gaat van daaruit verder.
- Het resultaat: Het werkt perfect. In de tests zorgde deze methode ervoor dat de robot 100% van de tijd het juiste antwoord gaf, zelfs wanneer de prompt midden in een baksteen werd afgekapt. Het is alsof je een GPS hebt die direct de route herberekenen als je een verkeerde afslag neemt, zodat je toch je bestemming bereikt.

De Kernboodschap

Het artikel concludeert dat hoewel AI-modellen geweldig zijn in het begrijpen van taal, ze ook slaven zijn aan de specifieke manier waarop ze geleerd hebben om woorden te tellen (tokenisatie). Als een gebruiker stopt met typen op een manier die niet overeenkomt met de interne telregels van de robot, stort het zelfvertrouwen van de robot in.

Het goede nieuws? We hoeven de robots niet opnieuw te bouwen. We hoeven alleen maar een slimmere "GPS" (zoals ByteSampler) te gebruiken terwijl ze nadenken, om ervoor te zorgen dat ze niet struikelen over hun eigen telregels.

Technische Samenvatting: "Are you going to finish that? A Practical Study of the Partial Token Problem"

Probleemdefinitie
Het Partial Token Problem (PTP) ontstaat door een fundamentele mismatch tussen hoe gebruikers met taalmodellen (LM's) interageren en hoe LM's tekst verwerken. Gebruikers leveren prompts aan als reeksen tekens, terwijl LM's opereren op sequenties van tokens gegenereerd door een tokenizer. Het PTP treedt op wanneer de prompt van een gebruiker halverwege een geldige token eindigt (een "partiële token"). Omdat LM's uitsluitend zijn getraind op geldige tokensequenties, kennen ze onverwacht lage waarschijnlijkheden toe aan continuaties die dergelijke partiële tokens voltooien. Hoewel dit probleem goed gedocumenteerd is in de literatuur (bijv. Lundberg, 2023; Ribeiro, 2023), heeft eerder werk grotendeels vertrouwd op willekeurige karakterprefixes om het fenomeen te illustreren. Bijgevolg is de prevalentie en ernst van PTP in realistische prompts die natuurlijke woord- of syntactische grenzen respecteren, onderbelicht gebleven.

Methodologie
De auteurs onderzoeken systematisch het PTP in realistische scenario's door domeinen te identificeren waar token-grenzen frequent niet samenvallen met semantische of syntactische grenzen:

Logografische systemen (Chinees): Woorden worden niet gescheiden door witruimte, waardoor tokenizers woorden over grenzen heen kunnen samenvoegen.
Taal met veel samenstellingen (Duits): Samengestelde woorden worden vaak door tokenizers gesegmenteerd op manieren die morfologische grenzen negeren.
Code: Identificatoren en opeenvolgende leestekens worden frequent samengevoegd tot enkele tokens.

Om het probleem te kwantificeren, construeerden de auteurs een "herhaal-na-mij"-taak. Ze segmenteerden natuurlijke zinnen in prefixes en continuaties zodanig dat:

De prefix eindigt bij een volledige woordgrens (semantisch natuurlijk).
De prefix eindigt bij een partiële token-grens ten opzichte van de tokenizer (overtreding van de conditie dat encode(prompt) + encode(continuation) == encode(prompt + continuation)).
De continuatie eenduidig is (het model moet exact de verstrekte tekst herhalen).

De studie evalueerde een diverse suite van frontier-modellen (inclusief QWEN3, HUNYUAN, LLAMA, OLMO, GEMMA, en MISTRAL) over deze domeinen. Prestaties werden gemeten met twee metrieken:

$\Delta$ Logprob: Het verschil in log-waarschijnlijkheid toegewezen aan de correcte volgende token tussen de woord-gealigneerde (partiële token) prompt en de token-gealigneerde (back-off) prompt.
$\Delta$ Acc: Het verschil in nauwkeurigheid bij het greedily decoderen van de correcte continuatie.

Belangrijkste Resultaten

Hoge prevalentie van misalignement: Standaard tokenizers vertonen significante misalignement-percentages. In het Chinees vallen 14%–25% van de woordgrenzen niet samen met token-grenzen. In code liggen leesteken-grenzen bij de meeste modellen in meer dan 50% van de gevallen binnenin tokens.
Ernstige waarschijnlijkheidsdistorsie: Wanneer zij geconfronteerd worden met een PTP, kennen modellen drastisch lagere waarschijnlijkheden toe aan de correcte continuatie. In het Chinees daalt de waarschijnlijkheid met wel vier ordes van grootte vergeleken met token-gealigneerde prompts.
Nauwkeurigheidscollaps: Modellen voorspellen de correcte continuatie 60%–95% minder vaak wanneer de prompt eindigt met een partiële token. Bijvoorbeeld: de nauwkeurigheid van QWEN3-32B in het Chinees daalde van 93,92% (token-gealigneerd) naar 15,36% (woord-gealigneerd).
Opschaling helpt niet: De degradatie neemt niet af met de schaal van het model; in veel gevallen lijden grotere modellen aan een gelijke of zelfs grotere daling in prestaties. De auteurs hypothetiseren dat grotere modellen beter zijn aangepast aan hun specifieke trainings-tokenizers, waardoor ze er meer van overtuigd zijn dat een sequentie van tokens (bijv. process + in) niet gevolgd kan worden door een karakter (bijv. g) dat een enkele token (processing) zou vormen.
Mitigatie tijdens inferentie:
- Token Healing: Een heuristische benadering waarbij de laatste token(s) uit de prompt worden verwijderd en de generatie wordt beperkt om de verwijderde tekst te matchen. Dit toonde gemengde resultaten: het verbeterde de nauwkeurigheid in sommige gevallen, maar faalde in andere (bijv. Duits).
- ByteSampler: Een exacte oplossing (Hayase et al., 2025) die een boom van alle geldige tokensequenties construeert die de prompt-prefix dekken en een pad selecteert. Deze methode bereikte 100% nauwkeurigheid over alle drie de domeinen (Chinees, Duits, Code) met een lage computationele overhead (0,12–1,17 extra forward passes).

Betekenis en Bijdragen
Het artikel demonstreert dat het Partial Token Problem niet louter een artefact is van willekeurige tekstafkorting, maar een ernstige foutmodus in realistische, semantisch natuurlijke gebruiksscenario's. De auteurs stellen dat:

Real-world impact: Het probleem is wijdverspreid in niet-Engelse talen en code, en beïnvloedt zelfs prompts die eindigen met volledige woorden.
Beperkingen van schaling: Het vergroten van de modelgrootte lost het probleem niet op, aangezien modellen strikter gebonden raken aan hun tokenisatie-schema's.
Praktische aanbevelingen: De studie valideert de effectiviteit van exacte oplossingen tijdens inferentie, zoals ByteSampler, die het probleem volledig kunnen mitigeren zonder dat hertraining van het model vereist is.

Het werk benadrukt dat LM's niet alleen taal modelleren, maar ook de specifieke tokenizer waarmee ze zijn getraind, en dat deze interactie voorspelbare biases creëert wanneer prompt-grenzen niet samenvallen met token-grenzen. De auteurs bieden praktische aanbevelingen voor inference-providers om exacte oplossingen te adopteren om betrouwbaarheid in diverse linguïstische en coderingscontexten te garanderen.