Rotary Position Embedding en de verwerking van lange teksten

Door Ivo Donker — samengesteld met AI-ondersteuning (Claude & Gemini) · Laatst bijgewerkt: 7 augustus 2026

Rotary Position Embedding, kortweg RoPE, is de techniek waarmee veel moderne taalmodellen de volgorde van tokens verwerken. Dit artikel hoort bij module 5 van het leerpad, onder de motorkap: het legt uit hoe RoPE werkt en waarom het juist bij lange teksten beter presteert dan oudere manieren van positiecodering. De bredere uitleg over positionele codering staat in het artikel over positional encoding; hier duiken we in de roterende variant.

Wat je hiervoor moet weten

Om de verwerking van positie-informatie in transformer-architecturen goed te begrijpen, is het handig als je vertrouwd bent met een aantal basisconcepten uit eerdere modules:

• In de uitleg over attention-mechanismen lees je hoe tokens onderling gewichten uitwisselen en waarom deze operatie van zichzelf geen besef heeft van woordvolgorde.
• Het overzichtsartikel over positional encoding geeft de historische context en de vergelijking tussen absolute, relatieve en roterende positiemethoden.
• In de handleiding over de opbouw van KV-caching zie je hoe sleutels en waarden in het geheugen worden opgeslagen, wat direct aansluit op de manier waarop positiematrices tijdens het genereren worden toegepast.

1. Het probleem van positie in transformer-architecturen

Een standaard transformer-netwerk verwerkt alle tokens in een invoerreeks parallel. In tegenstelling tot klassieke rekurrente netwerken (zoals RNN's of LSTM's), die tekst token voor token van links naar rechts doorlopen, voert het attention-mechanisme in een transformer matrixvermenigvuldigingen uit over alle tokens tegelijkertijd. Dit levert een enorm snelheidsvoordeel op tijdens de training, maar brengt een fundamenteel probleem met zich mee: de berekening is van nature permutatie-invariant. Voor het netwerk maakt de volgorde van de invoervectoren zonder aanvullende informatie niets uit. De reeks "de hond bijt de man" levert voor de onbewerkte attention-operatie exact dezelfde interne toestanden op als "de man bijt de hond". Zonder expliciete positie-informatie degradeert een geavanceerd taalmodel tot een verzameling losse woorden zonder grammaticale samenhang.

Om dit op te lossen moet de positie van elk token in de reeks expliciet aan het model worden doorgegeven. In de eerste generaties transformers gebeurde dit door middel van absolute positiecoderingen. Hierbij werd aan de representatievector van elk token een unieke positievector toegevoegd. Deze positievector werd ingeleerd als een vaste parametermatrix per positie, of berekend met behulp van vaststaande sinus- en cosinusfuncties van verschillende frequenties. Het token op positie 1 kreeg zo een vaste verhoging of rotatie mee, token 2 eveneens, enzovoort.

Hoewel absolute positiecoderingen werken voor korte tot middellange teksten, kleurt er een duidelijke theoretische en praktische beperking aan deze aanpak wanneer de tekstlengte toeneemt:

• Koppeling aan een vaste index: Bij een absolute codering leert het model wat een token betekent op positie 5, positie 100 of positie 500. Het leert echter niet automatisch dat de relatieve afstand tussen positie 5 en 8 identiek is aan de relatieve afstand tussen positie 505 en 508. De ruimtelijke relatie tussen twee woorden moet voor elke willekeurige plek in de tekst opnieuw worden herleid.
• Beperkte extrapolatie naar langere invoer: Als een model getraind is op een maximale context van 2048 tokens, heeft het nooit positie-embeddings gezien voor positie 2049 en hoger. Bij geleerde absolute posities bestaan er simpelweg geen gewichten voor deze hogere indexen. Bij sinus-gebaseerde absolute posities bestaan de wiskundige functies wel voor hogere waarden, maar heeft het model tijdens de training nooit geleerd hoe de attention-gewichten moeten reageren op deze onbekende positievectoren. Het model raakt daardoor stelselmatig van slag zodra de invoer langer wordt dan de trainingslengte.
• Slechte verplaatsbaarheid van taalpatronen: Een syntactische structuur, zoals een bijvoeglijk naamwoord dat direct voor een zelfstandig naamwoord staat, verschijnt op positie 3 net zo goed als op positie 4000. Bij absolute coderingen moet het model via gespecialiseerde attention-koppen op elke positie afzonderlijk leren herpinnen dat deze twee tokens bij elkaar horen, in plaats van één generiek relatief patroon te hanteren.

De overstap van absolute volgnummers naar een dynamische, relatieve benadering bleek daarom noodzakelijk om taalmodellen schaalbaar te maken naar grotere contextvensters.

2. Het mechanisme van Rotary Position Embedding (RoPE)

Rotary Position Embedding kiest een fundamenteel andere wiskundige insteek om positie-informatie te verankeren. In plaats van een positievector op te tellen bij de token-embedding, transformeert RoPE de query- en key-vectoren in de attention-laag door ze te roteren in een meerdimensionale ruimte. De mate van rotatie is rechtstreeks gekoppeld aan de absolute positie van het token in de tekst.

Om te begrijpen hoe deze rotatie in de praktijk werkt, kijken we naar een verborgen representatieruimte. Een token-embedding bestaat uit een vector van honderden of duizenden getallen (dimensies). RoPE splitst deze hoogdimensionale vector op in opeenvolgende paren van twee dimensies. Elk paar van twee getallen vormt een punt in een tweedimensionaal coördinatenstelsel (een 2D-vlak). RoPE roteert dit punt over een bepaalde hoek rond de oorsprong van het vlak.

De grootte van de rotatiehoek $ \theta $ wordt bepaald door twee factoren: de positie index $ m $ van het token in de zin, en de specifieke dimensie-index van het paar. Voor de eerste dimensieparen is de rotatiesnelheid hoog; voor latere dimensieparen is de rotatiesnelheid heel laag. Dit betekent dat bij elk opeenvolgend token in de tekst de vector op sommige dimensies heel snel ronddraait, en op andere dimensies slechts een minuscuul fractie van een graad opschuift. Door deze variatie in frequenties ontstaat een uniek, meerdimensionaal rotatiepatroon voor elke positie.

De cruciale eigenschap van deze rotatieoperatie is dat de lengte (de norm) van de vector volledig behouden blijft. Rotatie verandert alleen de richting van de vector, niet de absolute grootte. Dit voorkomt dat positievectoren de inhoudelijke betekenis van een token overstemmen of numerieke instabiliteit veroorzaken in diepere lagen van het netwerk.

Onderstaand getallenvoorbeeld illustreert hoe twee opeenvolgende tokens op basis van een fictieve, vereenvoudigde tweedimensionale weergave een verschillende rotatiehoek ontvangen. Dit voorbeeld gebruikt afgeronde hoeken om het mechanisme inzichtelijk te maken:

====================================================================
ILLUSTRATIEF GETALLENVOORBEELD: ROPE-ROTATIE IN EEN 2D-VLAK
(Let op: Fictieve getallen ter illustratie van het rotatieprincipe)
====================================================================

Invoertekst: "De wet werkt goed"
Basis-frequentie hoek per positie (fictief): 30 graden per stap

TOKEN 1: "De" (Positie index m = 1)
--------------------------------------------------------------------
- Inhoudelijke Query-vector (onbewerkt) : [1.00, 0.00]
- Toegepaste rotatiehoek (1 * 30°)       : 30 graden
- Gerooteerde Query-vector               : [cos(30°), sin(30°)]
                                         = [0.87, 0.50]

TOKEN 2: "wet" (Positie index m = 2)
--------------------------------------------------------------------
- Inhoudelijke Key-vector (onbewerkt)   : [1.00, 0.00]
- Toegepaste rotatiehoek (2 * 30°)       : 60 graden
- Gerooteerde Key-vector                 : [cos(60°), sin(60°)]
                                         = [0.50, 0.87]

RELATIEVE INTERACTIE (Attention Dot-Product):
--------------------------------------------------------------------
- Inproduct tussen Token 1 en Token 2:
  (0.87 * 0.50) + (0.50 * 0.87) = 0.435 + 0.435 = 0.87
- Dit resultaat is wiskundig exact gelijk aan cosinus van het
  HOEKSVERSCHIL tussen positie 1 en 2 (60° - 30° = 30° -> cos(30°) = 0.87).
====================================================================

In de werkelijke architectuur wordt deze rotatie niet toegepast op de invoer-embeddings bij de basis van het model, maar pas dieper in het netwerk op het moment dat de Query- (Q) en Key- (K) vectoren worden gegenereerd binnen elke attention-laag. De Value- (V) vectoren worden niet gerooteerd, omdat zij enkel de inhoudelijke informatie transporteren nadat de attention-gewichten tussen Q en K zijn berekend.

3. Relatief in plaats van absoluut: de wiskundige elegantie

Het grote theoretische voordeel van RoPE komt aan het licht bij het berekenen van de attention-score. Zoals uitgelegd in de analyse van het attention-mechanisme, wordt de verwantschap tussen twee tokens bepaald door het inproduct (dot product) te nemen van de Query-vector van het ene token en de Key-vector van het andere token. Wanneer twee vectoren over hun respectievelijke hoeken zijn gerooteerd, gebeurt er iets bijzonders bij dit inproduct.

Wanneer we het inproduct berekenen tussen een Query op positie $ m $ (gerooteerd over hoek $ m \cdot \theta $) en een Key op positie $ n $ (gerooteerd over hoek $ n \cdot \theta $), zorgt de trigonometrische identiteit van de cosinus ervoor dat het eindresultaat rechtstreeks afhangt van het hoeksverschil $ (m - n) \cdot \theta $. De absolute posities $ m $ en $ n $ vallen uit de vergelijking weg; wat overblijft is puur de relatieve afstand $ (m - n) $ tussen de twee tokens.

Dit wiskundige verschijnsel levert een aantal cruciale voordelen op voor taalverwerking:

• Translational Invariance (Verschuivingsinvariantie): Een syntactische relatie tussen twee woorden op positie 10 en positie 12 heeft precies dezelfde hoeksverhouding als diezelfde relatie tussen twee woorden op positie 1500 en positie 1502. In beide gevallen is de relatieve afstand 2 stappen, wat leidt tot exact hetzelfde hoeksverschil in het inproduct. Het model hoeft taalregels dus niet op elke positie opnieuw te leren.
• Geleidelijke afname van verwantschap met afstand: Omdat de toegepaste hoeken over verschillende dimensies sterk variëren in frequentie, zorgt het inproduct van gerooteerde vectoren er op natuurlijke wijze voor dat de verwantschaps-score tussen twee tokens gemiddeld afneemt naarmate ze verder uit elkaar staan. Dit simuleert een natuurlijke geografische 'vervalcurve' zonder dat er harde grenzen worden ingesteld.
• Geen extra parameters: RoPE vereist geen aanpasbare gewichtenmatrices die getraind moeten worden. De rotatiematrices worden analytisch berekend op basis van vaste formules. Dit bespaart geheugen en voorkomt dat het model overfit op specifieke posities.

Door positie-informatie te coderen als een relatief hoeksverschil in de innerlijke producten van de attention-lagen, leert het taalmodel patronen die universeel toepasbaar zijn door de gehele tekst heen, ongeacht waar de specifieke passage zich bevindt.

4. Waarom RoPE lange teksten beter aankan: voordelen en grenzen

In moderne toepassingen worden taalmodellen geconfronteerd met documenten van tientallen tot honderden pagina's. Oudere positiemethoden liepen bij dergelijke lengtes vast omdat de verdeling van absolute posities drastisch veranderde ten opzichte van wat het model tijdens de training had gezien. RoPE biedt door zijn periodieke en relatieve opzet een veel steviger fundament voor het verwerken van lange invoerreeksen.

Omdat de rotaties gebaseerd zijn op een continue cosinus- en sinusgolf, blijft de relatieve wiskundige structuur stabiel wanneer de reeks groeit. Een afstand van 500 tokens veroorzaakt een consistent hoeksverschil, of die 500 tokens zich nu bevinden aan het begin van een kort artikel of halverwege een omvangrijk boek. Modellen die met RoPE zijn getraind, behouden daardoor hun vermogen om grammatica en semantiek correct te interpreteren, zelfs wanneer de invoer de oorspronkelijke trainingslengte naderd of licht overschrijdt.

De theoretische en praktische grenzen van extrapolatie

Hoewel RoPE van nature beter schaalt dan absolute posities, is onbeperkte extrapolatie (het verwerken van reeksen die vele malen langer zijn dan het maximale trainingsvenster) wiskundig gezien geen vanzelfsprekendheid. Als een model getraind is op een contextlengte van bijvoorbeeld 4096 tokens, ondervindt het fysieke problemen wanneer het opeens 32.000 tokens moet verwerken:

• Fase-verschuiving op hoge frequenties: De snel roterende dimensies in RoPE leggen bij zeer grote afstanden zoveel volledige cirkels af dat kleine afrondingsfouten en niet-geziene hoekscombinaties optreden. Het model herkent de relatieve positie op die specifieke frequenties niet meer goed.
• Concentratie van attention-gewichten: Omdat de attention-softmax wordt berekend over een veel groter aantal tokens, verdunt de aandachtsverdeling. De som van alle attention-scores moet altijd 1.0 blijven. Bij honderdduizend tokens kan de individuele signaalwaarde van relevante informatie ondersneeuwen in de ruis van duizenden achtergrondtokens.
• Incompleet getrainde lage frequenties: De langzaamst roterende dimensies in RoPE hebben honderden of duizenden tokens nodig om zelfs maar een kwart rotatie te maken. Als het model tijdens de training nooit documenten van die lengte heeft doorgegeven gekregen, zijn de gewichten van de attention-koppen die op deze lage frequenties vertrouwen nooit goed afgesteld.

Technieken voor het oprekken van de context

Om deze fysieke grenzen te doorbreken zonder het hele model vanaf nul te hoeven trainen op extreem lange teksten, maakt men gebruik van geavanceerde schalingstechnieken. Een belangrijk principe hierbij is positionele interpolatie. In plaats van de positie-indexen na 4096 gewoon door te laten tellen tot 32.000 (extrapolatie), schaalt men de positie-indexen met een constante factor terug zodat alle 32.000 tokens binnen het oorspronkelijke rotatiebereik van 0 tot 4096 vallen (interpolatie).

Aanvullend past men vaak frequentieschaling toe. Hierbij worden de hoge rotatiefrequenties (die de nabije context coderen) grotendeels intact gelaten om de precisie op korte afstand te behouden, terwijl de lage rotatiefrequenties (die de globale context coderen) worden aangepast om grotere afstanden te overbruggen. Door deze wiskundige correcties kan een bestaand model via een hele korte vervolgtraining (fine-tuning) worden aangepast om contextvensters te verwerken die een meervoud zijn van de oorspronkelijke capaciteit.

5. Praktische betekenis voor lange Nederlandse teksten

Voor het verwerken van complexe documenten in de Nederlandse taal—zoals juridische contracten, polisvoorwaarden, uitgebreide beleidsnota's of technische jaarverslagen—heeft de relatieve precisie van RoPE directe inhoudelijke consequenties. Nederlands bevat vaak lange, samengestelde zinnen met een rijke werkwoordstructuur en verwijzingen die ver uit elkaar kunnen staan.

In traditionele absolute modellen kon de afstand tussen een onderwerp en de bijbehorende persoonsvorm achteraan een bijzin, of de verwijzing naar een gedefinieerd begrip tientallen alinea's eerder, vervagen. RoPE zorgt ervoor dat het model de onderlinge afstanden tussen sleutelbegrippen scherp blijft registreren, ongeacht de absolute locatie in het dossier.

Een concrete Nederlandse casus: Juridische en temporele samenhang

Om te zien waarom de relatieve afstand en volgorde cruciaal zijn voor een correct begrip, bekijken we de volgende passage die rust op een temporele keten binnen een juridisch document van 50 pagina's:

"In 2023 werd de wet gewijzigd ten aanzien van het stikstofbeleid voor agrarische bedrijven. [ ... 40 pagina's met technische bijlagen, tabellen en meetvoorschriften ... ] Na drie jaar bleek de wet niet te werken zoals de wetgever oorspronkelijk had beoogd."

Om deze twee zinnen correct met elkaar te verbinden en de logische conclusie te trekken dat het evaluatiemoment plaatsvindt in het jaar 2026, moet het taalmodel meerdere lagen van relatieve structuur verwerken:

1. Anaphoor-resolutie (Verwijzingsherkenning): In de tweede zin spreekt de tekst over "de wet". Het model moet vaststellen dat "de wet" hier verwijst naar de specifieke wetswijziging rond het stikstofbeleid uit de eerste zin, en niet naar een willekeurige andere wet die in de tussenliggende 40 pagina's wordt aangehaald.
2. Relatieve tijdsberekening: De bepaling "Na drie jaar" krijgt pas betekenis als deze relatief wordt gekoppeld aan de exacte verankeringsdatum "2023" uit de eerste passage. De relatieve rotatie van RoPE zorgt ervoor dat de afstand tussen het tijdsanker (2023) en de vervolgbepaling (na drie jaar) als een stabiel signaal doorkomt in het inproduct van de attention-koppen.
3. Oorzaak-gevolgrelatie over lange afstand: De conclusie "bleek niet te werken" slaat op de effectiviteit van de specifieke maatregel. Als het model de relatieve positie zou kwijtraken, bestaat het risico dat de feitelijke evaluatie wordt gekoppeld aan een tussenliggende paragraaf (bijvoorbeeld een bijlage over milieumetingen uit 2024), wat zou leiden tot een foute interpretatie van het document.

Dankzij RoPE blijft het verschil in rotatiehoeken tussen de Query-vector van "Na drie jaar" en de Key-vector van "In 2023" een exact gedefinieerd signaal. Het model behoudt de grammaticale en temporele grip op de tekst, zelfs wanneer er tienduizenden tokens tussen beide uitspraken in staan.

6. De wisselwerking tussen RoPE, geheugen en KV-caching

Er bestaat in de praktijk soms het misverstand dat een model met RoPE 'automatisch' oneindig lange teksten kan verwerken zonder extra hardwarekosten. Het is belangrijk om onderscheid te maken tussen de representatie van positie (wat RoPE verzorgt) en de fysieke opslag van tokens (wat door het geheugen van de hardware wordt begrensd).

RoPE lost het positieprobleem wiskundig elegant op, maar verandert niets aan de geheugenvereisten van het attention-mechanisme zelf. Bij het genereren van tekst moet voor elk eerder verwerkt token de Key- en Value-vector worden bewaard in het geheugen van de grafische kaart (GPU) om te voorkomen dat deze bij elke nieuwe gegenereerde letter opnieuw moeten worden berekend.

Zoals in detail wordt uitgelegd in de gids over de opbouw en werking van KV-caching, groeit het geheugengebruik van deze cache lineair met de lengte van de invoer en het aantal lagen en attention-koppen van het model. Bij een contextvenster van 32.000 of 128.000 tokens neemt de KV-cache vele gigabytes aan VRAM in beslag. RoPE zorgt er dus voor dat de wiskunde achter de attention-scores correct blijft werken op die afstand, maar de developer moet er alsnog voor zorgen dat de GPU voldoende fysiek geheugen heeft om al die gerooteerde Key- en Value-vectoren op te slaan.

Wanneer de fysieke grenzen van het GPU-geheugen bereikt worden of de verwerkingskosten te hoog oplopen, volstaat een slimme positiestructuur alleen niet meer. In die gevallen moeten aanvullende strategieën worden ingezet om de tekstinvoer te comprimeren, te filteren of in opgedeelde blokken aan te bieden. In het overzichtsartikel over het toepassen van context-engineering vind je praktische methoden om grote hoeveelheden informatie efficiënt te structureren voordat deze aan het model worden aangeboden.

7. Praktische instellingen en netwerkintegratie

Voor ontwikkelaars en beheerders die zelf modellen draaien of integreren in toepassingen, vertaalt het RoPE-mechanisme zich naar concrete configuratieparameters in software frameworks zoals vLLM, Ollama of llama.cpp.

Wanneer je een model lokaal of op eigen serverinfrastructuur uitrolt, kun je het gedrag van RoPE direct beïnvloeden via instellingen zoals de RoPE base frequency (vaak aangeduid als `rope_freq_base`) en de scaling factor (`rope_freq_scale`). Door de basisfrequentie te verhogen (bijvoorbeeld van de standaardwaarde 10.000 naar 500.000 of meer), worden de rotatiehoeken voor lange afstanden kleiner ingesteld, waardoor het model in staat is om langere reeksen te verwerken zonder dat de hoeken 'overlopen'.

De praktische uitwerking hiervan op je hardware en de exacte manieren om dit lokaal in te stellen, lees je in het stappenplan voor het lokaal optimaliseren van je contextvenster op het Gids-platform. Hierin wordt uitgelegd hoe je de balans zoekt tussen maximale contextlengte en het beschikbare GPU-geheugen.

Aan de kant van de toepassingsarchitectuur (bij het selecteren van de juiste API-modellen voor een specifiek bedrijfsproces) is het belangrijk te begrijpen welke impact de gekozen contextgrootte heeft op de verwerkingssnelheid en de nauwkeurigheid van de antwoorden. Een uitgebreide toelichting op het selecteren van het geschikte venster per toepassing vind je in het artikel over het kiezen en begrijpen van contextvensters op het Hub-platform.

8. Afbakening: Wat RoPE wel en niet oplost

Om een realistisch beeld te houden van de mogelijkheden van een taalmodel, is het nuttig om de grenzen van Rotary Position Embedding scherp af te bakenen. RoPE is een zeer specifieke architectuuraanpassing met heldere taken.

Wat RoPE wel doet:

• Het biedt een analytische, relatieve codering van tokenposities via rotaties in de complex-vectorruimte.
• Het zorgt voor behoud van de vectornorm (lengte) van Query's en Keys, wat bijdraagt aan stabiele trainingsprocessen.
• Het stelt attention-koppen in staat om afstandsonafhankelijke syntactische en semantische patronen te herkennen.
• Het maakt het mogelijk om met wiskundige aanpassingen (zoals interpolatie en frequentieschaling) het bruikbare contextvenster van een model uit te breiden.

Wat RoPE niet doet:

• Geen geheugenreductie: RoPE vermindert de kwadratische berekeningscomplexiteit van standaard attention ($O(N^2)$) of de lineaire geheugengroei van de KV-cache ($O(N)$) op geen enkele wijze.
• Geen automatische samenvatting: RoPE helpt het model om te 'weten' waar een token staat ten opzichte van een ander, maar garandeert niet dat het model relevante details in een zee van 100.000 tokens niet over het hoofd ziet (het zogenaamde 'needle in a haystack'-probleem).
• Geen versnelling van verwerking: De trigonometrische rotaties vereisen extra element-gewijze berekeningen tijdens de forward pass. Dit introduceert een minimale rekenoverhead, hoewel deze in de praktijk verwaarloosbaar is vergeleken met de grote matrixvermenigvuldigingen.

Hierna verder met

Nu je weet hoe de volgorde van tokens via roterende embeddings verankerd zit in moderne transformer-architecturen, kun je je kennis verder verdiepen in de volgende onderwerpen binnen het leerpad:

• Lees in de gids over KV-caching hoe de gerooteerde Key-vectoren efficiënt in het geheugen worden georganiseerd om de generatiesnelheid van lange teksten te optimaliseren.
• Bekijk de technieken in context-engineering om te leren hoe je grote documenten het beste kunt structureren en filteren voordat je ze aan een model met een RoPE-architectuur voedt.