Positionskodning förklarad: Ge transformatorer en känsla för ordning

Vad är positionskodning?

Positionskodning är en teknik som hjälper neurala nätverk att förstå den sekventiella ordningen i indata. Den fungerar som en uppsättning koordinater som representerar en tokens relativa eller absoluta position och slås samman med din vanliga datarepresentation.

Innan text går in i ett neuralt nätverk omvandlas ord till kontinuerliga numeriska format som kallas inbäddningar. Standardinbäddningar fångar dock bara semantisk betydelse: de säger inget om ett ords position i en given text. Du kan lära dig exakt hur denna process fungerar genom att gå vår kurs Introduction to Embeddings with the OpenAI API.

En positionskodning är ett ytterligare matematiskt lager som läggs direkt till dessa token-inbäddningar. Genom att kombinera den semantiska representationen med en positionsstämpel kan transformatorn särskilja identiska ord som förekommer i olika delar av en mening.

Problemet med permutationsinvarians

Sekventiell data är starkt beroende av ordning. I naturligt språk har meningen ”the dog bit the man” en helt annan betydelse än ”the man bit the dog”.

Historiskt sett hanterade rekurrenta neurala nätverk (RNN:er) och Long Short-Term Memory-nätverk (LSTM:er) detta inneboende. De bearbetade token sekventiellt, vilket betyder att nätverket matematiskt tog in det andra ordet först efter att ha bearbetat det första. På liknande sätt bearbetar konvolutionella neurala nätverk (CNN:er) data med lokala glidande fönster som fångar den rumsliga arrangemanget av pixlar eller närliggande ord.

Transformatorer överger sekventiell bearbetning helt. De bearbetar alla token parallellt. Kärnan i en transformator är självuppmärksamhetsmekanismen, som beräknar parvisa relationspoäng mellan varje enskild token i sekvensen samtidigt. Matematiskt är självuppmärksamhet permutationsinvariant. Om du blandar om indatasekvensen kommer självuppmärksamheten att ge exakt samma uppmärksamhetspoäng för ordparen.

Utan en mekanism som bevarar ordning uppstår ett totalt bortfall av sekventiell information i modellen. Semantisk betydelse kollapsar till en oordnad påse med ord. Positionskodning löser problemet med permutationsinvarians genom att medvetet ändra indata-vektorerna så att självuppmärksamheten registrerar token på position 1 annorlunda än token på position 10.

Hur fungerar positionskodning?

Positionskodning fungerar genom att matematiskt modifiera token-vektorerna innan de når självuppmärksamhetslagren. Detta säkerställer att modellen beräknar relationer baserat på både betydelse och position.

Låt oss bygga lite intuition kring vad detta betyder. Föreställ dig standardinbäddningar som namnskyltar på en konferens. Namnskylten berättar vem personen är, men var de befinner sig på konferensen ändrar inte vem de är eller deras relationer till andra. Positionskodning är som att lägga till ett sätesnummer på namnskylten. När du kombinerar dem vet du både vem personen är och var hen sitter. Detta tillför kontext till möjliga interaktioner som personen kan ha på konferensen.

I en transformator uppnås denna kombination vanligtvis genom enkel elementvis addition. Modellen tar ordets semantiska inbäddningsvektor och adderar en positionskodningsvektor av exakt samma storlek. Den resulterande vektorn innehåller en subtil modulering som de efterföljande lagren lär sig tolka som rumsliga koordinater.

Exempelberäkning

Låt oss titta på ett förenklat exempel. Anta att vi har ett litet inbäddningsutrymme med dimensionen 4. Vi vill bearbeta ordet ”DataCamp” som finns på position 0 i vår sekvens.

1. Semantisk inbäddning: Det neurala nätverket hämtar inbäddningen för ”DataCamp”, som kan se ut som [0.51, -0.22, 0.88, 0.14].
2. Positionskodning: Positionsformeln genererar en koordinatvektor för position 0. I det här exemplet antar vi att den beräknar [0.00, 1.00, 0.00, 1.00].
3. Kombination: Vi adderar de två vektorerna elementvis.
4. Slutlig indata: Framåtpassningen tar emot [0.51, 0.78, 0.88, 1.14].

Även om exakt samma token ”DataCamp” dyker upp senare på position 5, kommer positionskodningsvektorn att vara annorlunda. Följaktligen kommer den slutliga indatavektorn att se helt annorlunda ut för självuppmärksamhetsmekanismen.

Sinusformad positionskodning

Den ursprungliga ”Attention Is All You Need”-artikeln introducerade en briljant metod för att generera positionsvektorer med grundläggande trigonometri. Denna metod kräver inga maskininlärningsvikter och bygger helt på fasta matematiska funktioner.

Matematisk grund

Sinusformad positionskodning använder sinus- och cosinusfunktioner vid olika frekvenser för att koda positionsinformation. Den ursprungliga formeln anger att för en given position (pos) och ett specifikt dimensionsindex (i) i inbäddningsvektorn beräknas kodningen enligt följande:

• För jämna dimensioner (2i): PE(pos, 2i) = sin(pos / 10000^(2i/dmodel))

• För udda dimensioner (2i+1): PE(pos, 2i+1) = cos(pos / 10000^(2i/dmodel))

I denna formel är dmodel den totala storleken på inbäddningsvektorn. När du rör dig längs vektorns dimensioner från index 0 upp till dmodel ökar våglängden hos de sinusformade funktionerna geometriskt.

Fördelar och egenskaper

Denna geometriska progression av frekvenser ger flera tydliga fördelar. 

1. Sinus- och cosinusutgångarna är strikt begränsade mellan -1 och 1. Denna begränsning säkerställer att positionskodningarna inte numeriskt överröstar de semantiska inbäddningarna.
2. Funktionerna är periodiska. På grund av trigonometriska additionsformler kan en linjär transformation enkelt representera positionskodningen för en framtida position (pos + k) som en funktion av den aktuella positionen (pos). Denna egenskap gör att modellen naturligt kan lära sig relativ positionskodning.
3. Sinusformad kodning använder fasta parametrar. Den kräver noll lärbara vikter, vilket minskar minneskostnaden avsevärt. Eftersom den verkar på en kontinuerlig matematisk funktion har modellen en teoretisk förmåga till extrapolation, vilket innebär att den kan mappa positionskoordinater för sekvenser längre än dem som sågs under träning.

Visualisering

För att underlätta förståelsen av sinusformad kodning kan det vara hjälpsamt att visualisera den som en värmekarta.

X-axeln i visualiseringen representerar inbäddningens dimensionsstorlek, medan y-axeln anger tokenens position. 

De lägre dimensionerna till vänster oscillerar snabbt mellan negativa och positiva värden, vilket gör att de kan särskilja närliggande tokenpositioner. När dimensionsindexet ökar blir våglängden längre och kodningen ändras mer gradvis. Dessa dimensioner fångar positionsskillnader över större avstånd.

För de 50 positioner som visas här framstår många högre dimensioner som nästan enhetliga vertikala ränder. Detta händer eftersom deras våglängder är så långa att sinusvärdena förblir nära 0 och cosinusvärdena nära 1 inom denna korta sekvens, inte 0 respektive 1. De alternerande ränderna återspeglar alltså intilliggande sinus–cosinus-dimensioner, inte en enkel binär kodning. Över en längre sekvens skulle även dessa dimensioner börja variera märkbart.

Slutsatsen är att de olika frekvenserna ger modellen positionsinformation i flera skalor: snabbt föränderliga dimensioner fångar finkorniga skillnader mellan närliggande token, medan långsamt föränderliga dimensioner spårar övergripande position inom längre sekvenser.

Inlärd positionskodning

Även om fasta matematiska formler är eleganta, förlitar sig moderna djupinlärningsarkitekturer ofta på data för att lära sig optimala representationer. Inlärda positionsinbäddningar flyttar hela bördan av layouten till träningsfasen.

Koncept och implementation

I stället för att hårdkoda positionsvärden med sinus- och cosinusfunktioner behandlar inlärda positionsinbäddningar positionskoordinater som vanliga lärbara parametrar. 

Modellen initierar en helt tom inbäddningsmatris där varje rad motsvarar en specifik sekvensposition. Under den vanliga backpropagation-träningsslingan uppdaterar nätverket dessa positionsvikter tillsammans med de semantiska token-inbäddningarna för att minimera den övergripande förlustfunktionen.

Jämförande fördelar

Den primära fördelen med inlärda positionsinbäddningar är extrem flexibilitet. De har full frihet att lära sig exakt de positionsrepresentationer som fungerar bäst för ett specifikt dataset. Arkitekturer som BERT och GPT-2 populariserade detta tillvägagångssätt tack vare dess höga anpassningsförmåga och starka prestanda på nedströmsuppgifter.

Begränsningar och utmaningar

Den mest betydande begränsningen med inlärda positionsinbäddningar är en hård gräns för sekvenslängd. Om en modell är tränad med maximalt 2 048 inlärda positionsvektorer kan den fysiskt inte bearbeta ett dokument med 2 049 token. 

Denna begränsning hämmar kraftigt längdsextrapolering och kräver ofta kostsam omträning för att utöka kontextfönstret.

Relativ positionskodning

När modeller utvecklades för att hantera längre dokument insåg ingenjörer att ett ords absoluta position ofta är mindre viktig än dess relativa avstånd till andra ord.

Konceptuell förskjutning till relativa positioner

Betrakta frasen ”the rapid advancement of AI.” Den grammatiska relationen mellan ”advancement” och ”AI” förblir identisk oavsett om frasen står i början av ett dokument eller i slutet. Relativ positionskodning överger absoluta rutnätskoordinater. I stället fokuserar den helt på avståndsförskjutningarna mellan interagerande token.

Implementation i uppmärksamhetsmekanismer

För att implementera relativa kodningar modifierar ingenjörer själva beräkningen av uppmärksamhetspoäng i stället för att ändra inbäddningarna i början av nätverket. 

När uppmärksamhetspoängen beräknas mellan en ”query”-matris och en ”key”-matris inkluderas en ytterligare inlärd bias-term som representerar det relativa avståndet. Denna modifiering garanterar skiftinvarians i texten. För en djupare genomgång av hur dessa matriser fungerar, läs vår guide om uppmärksamhetsmekanismen i LLM:er.

Praktiska avvägningar

Detta tillvägagångssätt ger mycket exakt kontextförståelse, men introducerar betydande beräkningsmässig overhead. Att beräkna unika matriser för relativa avstånd för varje enskilt uppmärksamhetshuvud ökar minnesförbrukningen drastiskt. Det komplicerar också de interna cache-mekanismer som används för att snabba upp textgenerering.

Absolut kontra relativ positionsinformation

Valet mellan absolut och relativ kodning beror på den specifika uppgiften. 

• Absolut kodning fungerar utmärkt när den exakta rumsliga layouten är rigid och snabb exekvering prioriteras. 
• Relativ kodning är överlägsen för längre naturlig språkbehandling, där den grammatiska strukturen helt beror på lokala kontextavstånd snarare än absoluta dokumentkoordinater.

Rotary Position Embedding (RoPE)

I den pågående jakten på att förfina transformatorarkitekturer introducerade forskare Rotary Position Embedding (RoPE). Det kombinerar de bästa egenskaperna hos absoluta och relativa positionskodningar och har snabbt blivit en industristandard.

Innovativt angreppssätt

RoPE förenar absolut placering och relativa avstånd med rotationsomvandlingar. I stället för att addera en vektor till inbäddningarna eller lägga till tunga bias-termer i uppmärksamhetspoängen, kartlägger RoPE inbäddningsvektorn till ett komplext plan och roterar den med en specifik vinkel. Storleken på denna vinkel bestäms strikt av tokenens absoluta position i sekvensen.

Matematiska insikter

I ett 2D-utrymme tillämpas rotationen med en standard 2D-rotationsmatris. För högre dimensioner grupperar RoPE helt enkelt inbäddningens dimensioner i par och tillämpar unika 2D-rotationer på varje del baserat på det absoluta positionsindexet.

På grund av rotationsmatrisers geometriska egenskaper beror skalärprodukten av en roterad frågevektor och en roterad nyckelvektor i slutändan endast på den relativa vinkeln mellan dem. Således använder RoPE en absolut positionsavbildning för att naturligt koda det relativa avståndet mellan token.

RoPE kontra sinusformad kodning

Som grafiken ovan visar ändrar sinusformad kodning både storlek och riktning hos den ursprungliga vektorn. RoPE bevarar i stället storleksinformationen och behöver bara vinkeln mellan två olika positioner för att förstå deras relativa avstånd.

Attention With Linear Biases (ALiBi)

Medan RoPE bygger på komplex rotationsmatematik tar en annan teknik, Attention with Linear Biases (ALiBi), en helt annan väg.

Enkelhet och effektivitet

ALiBi överger helt idén om att lägga till positionsinformation i de initiala token-inbäddningarna. Wordinbäddningarna går in i transformatorn helt orörda. 

I stället ingriper ALiBi i det allra sista steget av uppmärksamhetsberäkningen. Precis innan uppmärksamhetslogiterna passerar genom softmax-funktionen subtraherar ALiBi en statisk straffterm proportionell mot avståndet mellan de två token. Ju längre ifrån varandra två ord är, desto större straff dras från deras uppmärksamhetspoäng.

Prestanda

Metoden är enkel att implementera och mycket effektiv. Dess största fördel är extrem effektivitet vid längdsextrapolering. En modell som tränats med ALiBi på sekvenser om 1 024 token kan enkelt generera sammanhängande text på sekvenser som är dubbelt så långa utan att krascha. 

För praktiker som vill utforska andra avancerade tekniker för snabb textgenerering och inferensuppgifter, se vår guide om spekulativ avkodning.

När du ska använda vilken positionskodning

Börja utifrån vad du bygger och välj sedan metoden som passar — ibland en, ibland flera.

• Du vill ha en enkel baseline utan parametrar: Sinusformad (fasta formler, inget att träna).
• Din sekvenslängd är fast och du vill ha maximal prestanda på ett specifikt dataset: Inlärd.
• Du behöver hantera längre sekvenser än dem du tränade på: RoPE är det starkaste valet bland tekniker som kan extrapolera.
• Grammatik beror på avståndet mellan token, inte deras absoluta position: Relativ eller RoPE.
• Du bygger en modern, allmän LLM: RoPE.
• Längdsextrapolering är din absoluta topp-prioritet och du vill ha enklast möjliga implementation: ALiBi.
• Du vill ha fördelarna med relativa positioner utan minnes- och cache-overhead: RoPE (relativa kodningar ger fördelen men är dyrare).

Praktisk implementation och arkitektoniska överväganden

Att överbrygga klyftan mellan teori och praktik kräver förståelse för hur man integrerar positionskodningar i verkliga kodbaser och hanterar arkitektoniska begränsningar.

Implementera positionskodning i transformatorer

För att lägga till positionskodningar i en transformator i ramverk som PyTorch skapar utvecklare vanligtvis en dedikerad modul. Denna modul genererar kodningsmatrisen en gång och registrerar den som en buffer så att den inte av misstag uppdateras under backpropagation. 

Nedan följer en standardmässig praktisk implementation av en framåtpassage som inkluderar sinusformade kodningar. Kodningarna beräknas en gång från sinus- och cosinusformler och förändras aldrig under träning, vilket är anledningen till att de lagras i en buffer i stället för som lärbara parametrar (och varför de inte tillför någon träningskostnad).

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

I __init__ förberäknar modulen kodningstabellen upp till max_len positioner: position är en kolumn med index (0, 1, 2, …) och div_term är frekvenserna, vilket blir 1 / 10000^(2i/d_model), så lägre dimensioner får snabba vågor och högre långsamma. 

Att applicera sin på jämna dimensioner (0::2) och cos på udda (1::2) fyller tabellen. Sedan gör forward det enda arbetet vid körning: den skär tabellen till indatans sekvenslängd och adderar den elementvis till token-inbäddningarna. Notera att modulen antar en batch-först-form [batch, seq_len, d_model], vilket är varför forward skär på dimension 1.

Positionsbias och ”lost-in-the-middle”-fenomenet

En oavsiktlig konsekvens av att mappa långa sekvenslängder är positionsbias. Detta yttrar sig ofta som ”lost-in-the-middle”-fenomenet. När de bearbetar massiva dokument tenderar språkmodeller att minnas fakta från allra början eller allra slutet av en prompt mycket bättre än dem däremellan. Det kan kännas bekant, eftersom mänskligt minne fungerar liknande (åtminstone för mig; säg inte att jag är den enda som minns början och slutet av böcker bättre än resten!).

Teorin är att detta sker eftersom uppmärksamhetsmekanismen överväldigas av irrelevant kontext och naturligt förankrar sig vid de tidiga token (som sätter instruktionen) och de senaste token (som är färskast i minnet). För att mildra denna bias använder utvecklare avancerade chunking-strategier och semantiska hämtningssystem.

Positionskodning för specialiserade domäner

Transformatorer är inte längre strikt begränsade till text. Konceptet med positionskodning anpassas snabbt för att hantera olika datatyper över flera domäner.

För visionstransformatorer delas bilder upp i rutnät av patchar. En enkel 1D-sekvenskodning misslyckas med att fånga rumslig närhet i 2D-utrymme. Därför använder visionsmodeller ofta tvådimensionella inlärda positionskodningar som tar hänsyn till både X- och Y-koordinaterna för bildpatchen. 

Liknande anpassningar finns för kontinuerliga tidsseriemodeller, där specialiserade kodningar spårar tidsavstånd, säsongsvariationer och tidsstämplar.

Fortsatt forskning om positionskodning

Allt eftersom racet mot större kontextfönster accelererar, förblir förfining av hur modeller förstår position ett mycket aktivt och kritiskt forskningsområde inom maskininlärning.

Längdsextrapolering och kontextutökning

Dagens användare kräver enorma kontextfönster för att bearbeta hela kodbaser eller romanserier på en gång. Eftersom det är för dyrt att träna modeller från grunden på massiva sekvenslängder förlitar sig forskare på tekniker för kontextutökning. 

Metoder som positionsinterpolering komprimerar matematiskt positionskoordinaterna för en mycket längre sekvens inom gränserna för den ursprungliga träningslängden. Adaptiva metoder som YaRN justerar dynamiskt den rotationsfrekvens som används av RoPE-parametrar för att sömlöst tänja ut modellens förståelse av avstånd.

Transformatorer utan explicit positionskodning

Förvånansvärt nog tyder viss forskning på att explicit positionskodning inte alltid är strikt nödvändig. I dekoder-endast kausala språkmodeller läcker den standardiserade kausala maskningen (en mekanism som tvingar token att bara titta bakåt) inneboende tidsordningsinformation. 

Detta innebär att det kan vara möjligt att implicit lära sig positionsregler enbart från den kausala masken genom strategisk temperaturjustering och arkitektoniska anpassningar.

Utmaningar och framtida riktningar

Den yttersta frontlinjen belyser en ihållande avvägning mellan strikt anpassning (optimering av prestanda för en specifik sekvenslängd) och felfri extrapolering (att låta modellen generalisera oändligt). 

Framväxande forskningsområden fokuserar starkt på multimodal kodning. Att skapa universella positionsrepresentationer som sammanfogar 3D-videokoordinater med text- och ljudströmmar är ett mål för nästa generation av artificiella intelligensmodeller.

Slutsats

Positionskodning överbryggar klyftan mellan parallell bearbetning och sekventiell förståelse och gör det möjligt att skapa modeller som kan bearbeta stora mängder data i ordning. Vi har utforskat hur inlärda och relativa inbäddningar erbjuder extrem flexibilitet och hur moderna innovationer som RoPE och ALiBi optimerar både matematisk elegans och beräkningseffektivitet. 

När kontextfönster utökas från några tusen token till miljoner kommer den enkla matematiska handlingen att tala om för ett neuralt nätverk exakt var saker och ting är att förbli en kärna i modelldesign. 

Om du vill gå djupare och få praktisk erfarenhet rekommenderar jag att du anmäler dig till vår Developing Large Language Models-kompetensväg.