Positionele encodering uitgelegd: zo krijgen transformers gevoel voor volgorde

Wat is positionele encodering?

Positionele encodering is een techniek waarmee neurale netwerken de sequentiële volgorde van invoergegevens begrijpen. Het fungeert als een set coördinaten die de relatieve of absolute positie van een token weergeeft en wordt samengevoegd met je standaard gegevensrepresentatie.

Voordat tekst een neuraal netwerk ingaat, worden woorden omgezet in continue numerieke formaten, zogeheten embeddings. Standaardembeddings vangen echter alleen semantische betekenis: ze vertellen je niets over de positie van een woord in een tekst. Je kunt precies leren hoe dit proces werkt in onze cursus Introduction to Embeddings with the OpenAI API.

Een positionele encodering is een extra wiskundige laag die direct aan deze token-embeddings wordt toegevoegd. Door de semantische representatie te combineren met een positionele stempel kan het transformermodel identieke woorden onderscheiden die op verschillende plekken in een zin voorkomen.

Het probleem van permutatie-invariantie

Sequentiële data is sterk afhankelijk van volgorde. In natuurlijke taal betekent de zin "the dog bit the man" iets totaal anders dan "the man bit the dog".

Historisch gezien handelden Recurrent Neural Networks (RNN’s) en Long Short-Term Memory-netwerken (LSTM’s) dit van nature af. Ze verwerkten tokens sequentieel, wat betekent dat het netwerk het tweede woord pas wiskundig opnam nadat het eerste woord klaar was. Op dezelfde manier verwerken Convolutional Neural Networks (CNN’s) data met lokale schuivende vensters die de ruimtelijke ordening van pixels of naburige woorden vastleggen.

Transformers laten sequentiële verwerking volledig los. Ze verwerken alle tokens parallel. De kernmotor van een transformer is het self-attentionmechanisme, dat paarsgewijze relatie-scores berekent tussen elk token in de sequentie op exact hetzelfde moment. Wiskundig gezien is self-attention permutatie-invariant. Als je de invoersequentie door elkaar husselt, levert het self-attentionmechanisme precies dezelfde attention-scores op voor de woordparen.

Zonder een mechanisme om volgorde te behouden, verliest het model alle sequentiële informatie. Semantische betekenis stort in tot een ongesorteerde zak met woorden. Positionele encodering lost het probleem van permutatie-invariantie op door de invoervectoren dwingend te wijzigen, zodat het self-attentionmechanisme tokens op positie 1 anders registreert dan tokens op positie 10.

Hoe werkt positionele encodering?

Positionele encodering werkt door de invoertokenvectoren wiskundig te wijzigen voordat ze de self-attentionlagen bereiken. Zo berekent het model relaties op basis van zowel betekenis als positie.

Laten we wat intuïtie opbouwen bij wat dit betekent. Stel je standaard token-embeddings voor als naambadges op een conferentie. De badge vertelt wie iemand is, maar waar die persoon zich op de conferentie bevindt, verandert niet wie ze zijn of hun relaties met anderen. Positionele encodering is als het toevoegen van een stoelnummertje aan die badge. Gecombineerd weet je wie iemand is en waar die zit. Dat voegt context toe aan mogelijke interacties die deze persoon op de conferentie kan hebben.

In een transformer wordt deze combinatie meestal bereikt via simpele elementgewijze optelling. Het model neemt de semantische embeddingvector van een woord en telt er een positionele encoderingvector van exact dezelfde grootte bij op. De resulterende vector bevat een subtiele modulatie die de volgende lagen leren interpreteren als ruimtelijke coördinaten.

Voorbeeldberekening

Kijk naar een vereenvoudigd voorbeeld. Stel dat we een piepkleine embeddingsruimte hebben met een dimensie van 4. We willen het woord "DataCamp" verwerken dat op positie 0 in onze sequentie staat.

1. Semantische embedding: Het neurale netwerk haalt de embedding op voor "DataCamp", die er bijvoorbeeld uitziet als [0.51, -0.22, 0.88, 0.14].
2. Positionele encodering: De positionele formule genereert een coördinatenvector voor positie 0. Voor dit voorbeeld nemen we aan dat dit [0.00, 1.00, 0.00, 1.00] oplevert.
3. Combinatie: We tellen de twee vectoren elementgewijs bij elkaar op.
4. Definitieve invoer: De forward pass ontvangt [0.51, 0.78, 0.88, 1.14].

Zelfs als exact hetzelfde token "DataCamp" later op positie 5 verschijnt, is de positionele encoderingvector anders. Daardoor ziet de uiteindelijke invoervector er voor het self-attentionmechanisme volledig anders uit.

Sinusvormige positionele encodering

De oorspronkelijke "Attention Is All You Need"-paper introduceerde een brilliante methode om positionele vectoren te genereren met basis-trigonometrie. Deze aanpak vereist geen machinelearning-gewichten en is volledig gebaseerd op vaste wiskundige functies.

Wiskundige basis

Sinusvormige positionele encodering gebruikt sinus- en cosinusfuncties op verschillende frequenties om positionele informatie te encoderen. De oorspronkelijke formule bepaalt dat voor een gegeven positie (pos) en een specifieke dimensie-index (i) binnen de embeddingvector, de encodering als volgt wordt berekend:

• Voor even dimensies (2i): PE(pos, 2i) = sin(pos / 10000^(2i/dmodel))

• Voor oneven dimensies (2i+1): PE(pos, 2i+1) = cos(pos / 10000^(2i/dmodel))

In deze formule is dmodel de totale grootte van de embeddingvector. Als je langs de dimensies van de vector beweegt van index 0 tot dmodel, neemt de golflengte van de sinusfuncties geometrisch toe.

Voordelen en eigenschappen

Deze geometrische progressie van frequenties biedt verschillende duidelijke voordelen. 

1. De uitkomsten van sinus en cosinus zijn strikt begrensd tussen -1 en 1. Deze begrenzing zorgt ervoor dat de positionele encoderingen de semantische embeddings numeriek niet overheersen.
2. De functies zijn periodiek. Door trigonometrische somformules kan een lineaire transformatie eenvoudig de positionele encodering van een toekomstige positie (pos + k) representeren als functie van de huidige positie (pos). Deze eigenschap maakt het model van nature in staat om relatieve positie-encodering te leren.
3. Sinusvormige encodering gebruikt vaste parameters. Er zijn nul leerbare gewichten nodig, wat het geheugenverbruik sterk vermindert. Omdat het op een continue wiskundige functie werkt, heeft het model een theoretische extrapolatiecapaciteit: het kan positionele coördinaten mappen voor sequenties die langer zijn dan tijdens training gezien.

Visualisatie

Om sinusvormige encodering te begrijpen, helpt het om het als een heatmap te visualiseren.

De x-as van de visualisatie staat voor de embeddingdimensiegrootte, terwijl de y-as de positie van het token aangeeft. 

De lagere dimensies links oscilleren snel tussen negatieve en positieve waarden, waardoor ze nabije tokenposities kunnen onderscheiden. Naarmate de dimensie-index toeneemt, wordt de golflengte langer en verandert de encodering geleidelijker. Deze dimensies vatten positionele verschillen over grotere afstanden.

Voor de 50 posities die hier worden weergegeven, lijken veel hogere dimensies bijna uniforme verticale strepen. Dat komt doordat hun golflengten zo lang zijn dat de sinuswaarden dicht bij 0 en de cosinuswaarden dicht bij 1 blijven binnen deze korte sequentie, respectievelijk niet 0 en 1. De afwisselende strepen weerspiegelen dus aangrenzende sinus–cosinusdimensies, niet een simpele binaire encodering. Over een langere sequentie zouden ook deze dimensies merkbaar gaan variëren.

De kernboodschap is dat de verschillende frequenties het model positionele informatie op meerdere schalen geven: snel veranderende dimensies vangen fijne verschillen tussen nabije tokens, terwijl langzaam veranderende dimensies de globale positie binnen langere sequenties volgen.

Geleerde positionele encodering

Hoewel vaste wiskundige formules elegant zijn, vertrouwen moderne deep-learningarchitecturen vaak op data om optimale representaties te leren. Bij geleerde positionele embeddings verschuift de last van de lay-out volledig naar de trainingsfase.

Concept en implementatie

In plaats van positionele waarden hard te coderen met sinus- en cosinusfuncties, behandelen geleerde positionele embeddings de positiecoördinaten als standaard leerbare parameters. 

Het model initialiseert een volledig lege embeddingmatrix waarbij elke rij overeenkomt met een specifieke sequentiepositie. Tijdens de standaard backpropagation-trainingslus werkt het netwerk deze positionele gewichten bij, samen met de semantische token-embeddings, om de algehele verliesfunctie te minimaliseren.

Vergelijkende voordelen

Het grootste voordeel van geleerde positionele embeddings is extreme flexibiliteit. Het heeft volledige vrijheid om precies die positionele representaties te leren die het beste werken voor een specifieke dataset. Architecturen zoals BERT en GPT-2 hebben deze aanpak succesvol gepopulariseerd vanwege de hoge aanpasbaarheid en sterke prestaties op downstream-taken.

Beperkingen en uitdagingen

De grootste beperking van geleerde positionele embeddings is een harde grens op sequentielengte. Als een model is getraind met maximaal 2.048 geleerde positievectoren, kan het fysiek geen document van 2.049 tokens verwerken. 

Deze beperking hindert extrapolatie van lengte ernstig en vereist vaak kostbare hertraining om het contextvenster te vergroten.

Relatieve positionele encodering

Naarmate modellen langere documenten gingen verwerken, beseften ingenieurs dat de absolute positie van een woord vaak minder belangrijk is dan de relatieve afstand tot andere woorden.

Conceptuele verschuiving naar relatieve posities

Neem de uitdrukking "the rapid advancement of AI." De grammaticale relatie tussen "advancement" en "AI" blijft identiek, of de frase nu helemaal aan het begin of helemaal aan het einde van een document staat. Relatieve positionele encodering laat absolute rastercoördinaten los. In plaats daarvan richt het zich volledig op de afstandsverschillen tussen interacterende tokens.

Implementatie in attentionmechanismen

Om relatieve encoderingen te implementeren, passen ingenieurs de berekening van attentionscores direct aan in plaats van de invoer-embeddings helemaal aan het begin van het netwerk te wijzigen. 

Bij het berekenen van de attentionscore tussen een "query"-matrix en een "key"-matrix bevat de operatie een extra geleerde bias-term die de relatieve afstand vertegenwoordigt. Deze aanpassing garandeert verschuivingsinvariantie binnen de tekst. Voor een diepere duik in hoe deze matrices werken, lees onze gids over het attentionmechanisme in LLM’s.

Praktische afwegingen

Deze aanpak levert een zeer nauwkeurige contextuele interpretatie op, maar introduceert forse rekentechnische overhead. Het berekenen van unieke relatieve afstandsmatrices voor elk afzonderlijk attention-hoofd verhoogt het geheugengebruik drastisch. Het bemoeilijkt ook de interne cachingmechanismen die worden gebruikt om tekstgeneratie te versnellen.

Absolute versus relatieve positionele informatie

De keuze tussen absolute en relatieve encodering hangt af van de specifieke taak. 

• Absolute encodering werkt uitstekend wanneer de exacte ruimtelijke lay-out rigide is en snelle uitvoering prioriteit heeft. 
• Relatieve encodering is veel beter voor natuurlijke taal in lange vorm, waar de grammaticale structuur volledig afhangt van lokale contextafstanden in plaats van absolute documentcoördinaten.

Rotary Position Embedding (RoPE)

In de voortdurende zoektocht naar de perfecte transformerarchitectuur introduceerden onderzoekers Rotary Position Embedding (RoPE). Het combineert de beste eigenschappen van absolute en relatieve positionele encoderingen en is snel een industriestandaard geworden.

Innovatieve aanpak

RoPE verenigt absolute plaatsing en relatieve afstanden via rotatietransformaties. In plaats van een vector bij de embeddings op te tellen of zware biases aan attentionscores toe te voegen, projecteert RoPE de embeddingvector op een complexe vlak en roteert deze met een specifieke hoek. De grootte van deze hoek wordt strikt bepaald door de absolute positie van het token in de sequentie.

Wiskundige inzichten

In 2D wordt de rotatie toegepast met een standaard 2D-rotatiematrix. Voor hogere dimensies groepeert RoPE simpelweg de embeddingdimensies in paren en past het unieke 2D-rotaties toe op elk deel, gebaseerd op de absolute positie-index.

Door de geometrische eigenschappen van rotatiematrices hangt het inwendig product van een geroteerde queryvector en een geroteerde keyvector uiteindelijk alleen af van de relatieve hoek ertussen. Zo gebruikt RoPE een absolute positiemapping om de relatieve afstand tussen tokens op natuurlijke wijze te encoderen.

RoPE vs sinusvormige encodering

Zoals de bovenstaande afbeelding laat zien, verandert sinusvormige encodering de grootte en richting van de oorspronkelijke vector. RoPE bewaart juist de grootte-informatie en heeft alleen de hoek tussen twee verschillende posities nodig om hun relatieve afstand te begrijpen.

Attention With Linear Biases (ALiBi)

Waar RoPE steunt op complexe rotatiewiskunde, kiest een andere techniek, Attention with Linear Biases (ALiBi), een totaal andere benadering.

Eenvoud en efficiëntie

ALiBi laat het idee om positionele informatie toe te voegen aan de initiële token-embeddings volledig varen. De woordembeddings gaan de transformer volledig onaangeroerd binnen. 

In plaats daarvan grijpt ALiBi in bij de allerlaatste stap van de attentionberekening. Vlak voordat de attention-logits door de softmaxfunctie gaan, trekt ALiBi een statische straf af die evenredig is met de afstand tussen de twee tokens. Hoe verder twee woorden uit elkaar liggen, hoe groter de straf die van hun attentionscore wordt afgetrokken.

Prestaties

Deze methode is heel eenvoudig te implementeren en zeer efficiënt. Het grootste voordeel is de extreme effectiviteit bij taken met lengte-extrapolatie. Een model dat met ALiBi is getraind op sequenties van 1.024 tokens kan moeiteloos samenhangende tekst genereren op sequenties die twee keer zo lang zijn, zonder te crashen. 

Voor praktijkmensen die andere geavanceerde technieken voor snelle tekstgeneratie en inferentietaken willen verkennen, bekijk onze gids over speculative decoding.

Wanneer welke positionele encodering gebruiken

Begin bij wat je bouwt en kies dan de methode die past — soms één, soms meerdere.

• Je wilt een eenvoudige baseline zonder parameters: Sinusvormig (vaste formules, niets te trainen).
• Je sequentielengte is vast en je wilt maximale prestatie op een specifieke dataset: Geleerd.
• Je moet langere sequenties aan dan waarop je hebt getraind: RoPE is de sterkste keuze onder de technieken die kunnen extrapoleren.
• Grammatica hangt af van de afstand tussen tokens, niet hun absolute positie: Relatief of RoPE.
• Je bouwt een moderne LLM voor algemeen gebruik: RoPE.
• Lengte-extrapolatie is je absolute topprioriteit en je wilt de simpelste implementatie: ALiBi.
• Je wilt voordelen van relatieve posities zonder de geheugen- en cachingoverhead: RoPE (relatieve encoderingen geven het voordeel maar zijn duurder).

Praktische implementatie en architecturale overwegingen

De kloof tussen theorie en praktijk overbruggen vereist begrip van hoe je positionele encoderingen in echte codebases integreert en architecturale beperkingen beheert.

Positionele encodering implementeren in transformers

Om positionele encoderingen toe te voegen aan een transformer in frameworks zoals PyTorch, maken developers meestal een dedicated module. Deze module genereert de encoderingmatrix één keer en registreert die als buffer, zodat deze niet per ongeluk wordt bijgewerkt tijdens backpropagation. 

Hieronder staat een gangbare praktische implementatie van een forward pass met sinusvormige encoderingen. De encoderingen worden één keer berekend met sinus- en cosinusformules en veranderen nooit tijdens training; daarom worden ze in een buffer opgeslagen in plaats van als leerbare parameters (en voegen ze niets toe aan de trainingskosten).

import torch
import torch.nn as nn
import math

class PositionalEncoding(nn.Module):
    def __init__(self, d_model: int, max_len: int = 5000):
        super().__init__()
        
        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        
        # Calculate the division term for frequencies
        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
        
        # Apply sine to even indices and cosine to odd indices
        pe[:, 0::2] = torch.sin(position * div_term)
        pe[:, 1::2] = torch.cos(position * div_term)
        
        pe = pe.unsqueeze(0)
        
        # Register as a buffer
        self.register_buffer('pe', pe)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # Add positional encoding directly to the input embeddings
        seq_len = x.size(1)
        x = x + self.pe[:, :seq_len, :]
        return x

In __init__ berekent de module de encoderingstabel vooraf tot max_len posities: position is een kolom met indexen (0, 1, 2, …) en div_term zijn de frequenties, neerkomend op 1 / 10000^(2i/d_model), zodat lagere dimensies snelle golven krijgen en hogere trage. 

Door sin toe te passen op even dimensies (0::2) en cos op oneven (1::2) wordt de tabel gevuld. Vervolgens doet forward het enige werk tijdens runtime: het snijdt de tabel bij tot de sequentielengte van de invoer en telt die elementgewijs op bij de token-embeddings. Merk op dat de module uitgaat van een batch-first vorm [batch, seq_len, d_model], daarom snijdt forward op dimensie 1.

Positiebias en het lost-in-the-middle-fenomeen

Een onbedoeld gevolg van het in kaart brengen van lange sequenties is positiebias. Dit uit zich vaak als het "lost-in-the-middle"-fenomeen. Bij het verwerken van enorme documenten onthouden taalmodellen feiten van helemaal aan het begin of helemaal aan het einde van een prompt veel beter dan die ertussenin. Dat komt je misschien bekend voor, want het menselijk geheugen werkt vergelijkbaar (althans bij mij; zeg me niet dat ik de enige ben die het begin en einde van boeken beter onthoud dan de rest!).

De theorie is dat dit gebeurt omdat het attentionmechanisme overweldigd raakt door irrelevante context en zich van nature vastklampt aan de eerste tokens (die de instructie zetten) en de meest recente tokens (die nog vers in het geheugen zitten). Om deze bias te beperken, grijpen ontwikkelaars naar geavanceerde chunkingstrategieën en semantische retrievalsystemen.

Positionele encodering voor gespecialiseerde domeinen

Transformers zijn niet langer strikt beperkt tot tekst. Het concept van positionele encodering past zich snel aan om verschillende datatypen in meerdere domeinen te verwerken.

Voor vision transformers worden afbeeldingen opgedeeld in rasters van patches. Een eenvoudige 1D-sequentie-encodering kan nabijheid in 2D-ruimte niet vastleggen. Daarom gebruiken visionmodellen vaak 2D geleerde positionele encoderingen die zowel met de X- als Y-coördinaten van de beeldpatch rekening houden. 

Vergelijkbare aanpassingen bestaan voor continue tijdreeksmodellen, waar gespecialiseerde encoderingen temporele afstanden, seizoenspatronen en tijdstempels volgen.

Vervolgonderzoek naar positionele encodering

Nu de race naar grotere contextvensters versnelt, blijft het verfijnen van hoe modellen positie begrijpen een zeer actief en cruciaal onderzoeksgebied binnen machine learning.

Lengte-extrapolatie en contextuitbreiding

Gebruikers van vandaag vragen om enorme contextvensters om in één keer complete codebases of romans te verwerken. Omdat modellen vanaf nul trainen op gigantische sequentielengtes te duur is, vertrouwen onderzoekers op contextuitbreidingstechnieken. 

Methoden zoals positionele interpolatie comprimeren de positionele coördinaten van een veel langere sequentie wiskundig binnen de grenzen van de oorspronkelijke trainingslengte. Adaptieve methoden zoals YaRN passen de rotatiefrequentie van RoPE-parameters dynamisch aan om het afstandsbegrip van het model naadloos op te rekken.

Transformers zonder expliciete positionele encodering

Opvallend genoeg suggereert onderzoek dat expliciete positionele encodering niet altijd strikt noodzakelijk is. In decoder-only causale taalmodellen lekt de standaard causale masking (een mechanisme dat tokens dwingt alleen terug te kijken) inherent temporele ordeningsinformatie. 

Dit betekent dat het mogelijk is om positionele regels impliciet te leren enkel uit de causale maskering via strategische temperatuurafstemming en architecturale aanpassingen.

Uitdagingen en toekomstperspectieven

De ultieme grens benadrukt een hardnekkige afweging tussen strikte aanpassing (prestaties optimaliseren voor een specifieke sequentielengte) en perfecte extrapolatie (het model oneindig laten generaliseren). 

Opkomende onderzoeksgebieden richten zich sterk op multimodale encodering. Een doel voor de volgende generatie AI-modellen is het creëren van universele positionele representaties die 3D-videocoördinaten samenbrengen met tekst- en audiostreams.

Conclusie

Positionele encodering overbrugt de kloof tussen parallelle verwerking en sequentieel begrip, en stelt ons in staat modellen te bouwen die grote hoeveelheden data in volgorde kunnen verwerken. We hebben bekeken hoe geleerde en relatieve embeddings extreme flexibiliteit bieden, en hoe moderne innovaties zoals RoPE en ALiBi zowel wiskundige elegantie als computationele efficiëntie optimaliseren. 

Naarmate contextvensters groeien van enkele duizenden tokens tot miljoenen, blijft de eenvoudige wiskundige handeling om een neuraal netwerk exact te vertellen waar dingen zich bevinden, het hart van modelontwerp. 

Wil je dieper gaan en hands-on ervaring opdoen, schrijf je dan in voor onze Developing Large Language Models-skilltrack.