Multi-Head Attention uitgelegd: Queries, Keys en Values eenvoudig gemaakt

Inleiding

Multi-head attentie is een fundamenteel concept achter op Transformer gebaseerde modellen zoals BERT, GPT en Vision Transformers. Het stelt een model in staat om een invoersequentie te verwerken door tegelijkertijd op meerdere aspecten van de gegevens te focussen. In plaats van inputs sequentieel te lezen, maakt multi-head attentie parallel begrip van de relaties tussen tokens mogelijk, waardoor modellen zowel sneller als effectiever worden in het vastleggen van context. Dit mechanisme is een belangrijke reden waarom op aandacht gebaseerde architecturen de moderne deep learning domineren.

Belangrijkste punten

• Multi-head attention maakt het modellen mogelijk om tegelijkertijd op verschillende onderdelen van de input te letten.
• Het gebruikt meerdere aandachtshoofden om diverse relaties binnen dezelfde reeks te vast te leggen.
• Elke aandachtshoofd opereert in een andere aangeleerde representatie-subruimte.
• Het schalen van attentiescores verbetert de trainingsstabiliteit.
• Multi-head attention is centraal in Transformer-architecturen voor NLP, visuele en multimodale taken.

Handige Concepten in Multi-Head Attention

• Embeddings vormen de basis van hoe transformers tekst begrijpen. In plaats van woorden als gewone tekenreeksen te verwerken, zetten modellen elk token om in een dicht numeriek vector, een zogenaamde embedding. Deze vectoren bevatten semantische en syntactische informatie, wat betekent dat woorden met vergelijkbare betekenissen vaak vergelijkbare embeddings hebben. Bijvoorbeeld, de embeddings voor „kat” en „hond” zullen dichter bij elkaar liggen in de vectorruimte dan die voor „kat” en „tafel.” In dit stadium vertegenwoordigen embeddings tokens, zonder bewustzijn van de omliggende context.

• Aandachtslagen zijn verantwoordelijk voor het toevoegen van context aan deze embeddings. Een aandachtslaag stelt elk token in een reeks in staat om naar elk ander token te kijken en te bepalen welke het meest relevant zijn. In plaats van tekst stap voor stap te verwerken zoals traditionele recurrente modellen, analyseren aandachtslagen de hele reeks parallel. Dit helpt het model om langeafstandafhankelijke relaties te begrijpen, zoals hoe het begin van een zin gerelateerd is aan het einde ervan, en maakt transformer-modellen zowel sneller als effectiever.
• Wanneer embeddings door een attention-laag gaan, worden ze omgezet in verbeterde contextuele embeddings. Deze bijgewerkte embeddings vertegenwoordigen niet langer alleen het token zelf, maar bevatten ook informatie van de omringende tokens. Dit is wat het een model mogelijk maakt te begrijpen dat een woord zoals "bank" verschillende betekenissen kan hebben, afhankelijk van of het voorkomt in de buurt van woorden zoals "rivier" of "rekening". De representatie van elk token wordt verrijkt met contextuele informatie, waardoor het veel expressiever en nuttiger is voor taken verderop in het proces.
• Om aandacht te berekenen, wordt elke input-embedding geprojecteerd op drie afzonderlijke vectoren die bekendstaan als de query, key en value. De query-vector vertegenwoordigt waar een token naar op zoek is, de key-vector vertegenwoordigt wat een token aanbiedt, en de value-vector bevat de informatie die gedeeld zal worden als het token relevant wordt bevonden. Deze scheiding stelt het model in staat om tokens efficiënt te vergelijken en te beslissen hoe informatie tussen hen moet stromen.
• Query-, key- en value-vectoren worden gegenereerd met behulp van leerbare gewichtsmatrices. Deze matrices transformeren de originele embeddings naar verschillende representatieruimtes die geschikt zijn voor attentieberekeningen. Omdat deze gewichten tijdens het trainen worden geleerd, ontdekt het model geleidelijk hoe het embeddings het beste kan projecteren zodat betekenisvolle relaties ontstaan. In multi-head attention heeft elke attention-head zijn eigen set van query-, key- en value-gewichten, waardoor verschillende heads zich op verschillende linguïstische patronen kunnen richten, zoals syntaxis, semantiek of positionele relaties.
• De gewichtsmatrices die door het hele attention-mechanisme worden gebruikt, zijn voorbeelden van leerbare matrixparameters. Transformers zijn sterk afhankelijk van grote matrixvermenigvuldigingen, en de waarden in deze matrices zijn wat het model daadwerkelijk leert. Deze parameters bepalen hoe informatie wordt getransformeerd, vergeleken en gecombineerd tussen tokens. Moderne transformermodellen bevatten miljoenen of zelfs miljarden van dergelijke parameters, wat de reden is dat ze in staat zijn complexe patronen in taal vast te leggen.
• Aandachtscores kwantificeren hoe sterk een token op een ander token moet letten. Deze scores worden berekend door het inwendig product te nemen tussen een queryvector en sleutelvectoren van alle tokens in de reeks. De resulterende waarden geven gelijkenis en relevantie aan, en ze worden geschaald en door een softmaxfunctie gehaald om genormaliseerde aandachtsgewichten te produceren. Tokens met hogere aandachtscores dragen sterker bij aan de uiteindelijke representatie, terwijl minder relevante tokens zeer weinig bijdragen.

Bij multi-head attention wordt dit hele aandachtproces meerdere keren parallel herhaald met verschillende sets leerbare parameters. Elke 'head' leert zich te concentreren op verschillende aspecten van de invoersequentie, zoals grammaticale structuur, semantische betekenis of langeafstandrelaties. De outputs van alle heads worden vervolgens gecombineerd om een uiteindelijke representatie te vormen die rijker en informatiever is dan wat een enkel aandachtmechanisme zou kunnen produceren. Deze paralleliteit is wat multi-head attention zijn kracht en flexibiliteit geeft in moderne transformer-architecturen.

Begrip van aandacht in eenvoudige termen

Aandacht helpt een model beslissen welke onderdelen van de invoer het belangrijkst zijn bij het verwerken van een bepaald token. Wanneer een model een zin leest, hangt het belang van een woord af van de context. Bijvoorbeeld, de betekenis van het woord "bank" hangt af van de omliggende woorden zoals "rivier" of "geld." Aandacht stelt het model in staat om dynamisch belang toe te kennen op basis van de context in plaats van alleen op positie.

Dit mechanisme is opgebouwd uit drie componenten die queries, keys en values worden genoemd. Een query vertegenwoordigt waar het huidige token naar op zoek is. Keys geven aan welke informatie elk token bevat. Values dragen de werkelijke informatie die gecombineerd moet worden. Het model vergelijkt de query met alle keys om relevantie te bepalen en gebruikt vervolgens de values om een contextbewuste representatie op te bouwen.

Laten we een heel kleine zin nemen: “Kat zat op de mat.”

Wanneer deze zin een transformermodel binnengaat, is het eerste wat gebeurt tokenisatie en embedding. Elk woord “Cat, sat, on en mat” wordt omgezet in een numerieke vector. Deze vectoren worden embeddings genoemd. In dit stadium vertegenwoordigt elke embedding het woord op zichzelf, zonder het volledige begrip van de zin. Bijvoorbeeld, de embedding voor cat weet dat het verwijst naar een dier, maar weet nog niet wat de kat aan het doen is of waar hij zich bevindt.

In echte modellen kunnen embeddings honderden of duizenden dimensies hebben, maar om het te begrijpen gebruiken we kleine 4-dimensionale vectoren.

Vervolgens gaan deze embeddings een attentielaag in, waar het model probeert de relaties tussen woorden te begrijpen. Om dit te doen, wordt elke embedding getransformeerd in drie verschillende vectoren: een query, een key en een value. Deze vectoren worden gecreëerd met matrixvermenigvuldiging met leerbare gewichtsmatrices. Hoewel dit wiskundig klinkt, is de intuïtie eenvoudig. De query vertegenwoordigt wat een woord zoekt, de key vertegenwoordigt wat een woord biedt, en de value vertegenwoordigt de informatie die het woord draagt.

Deze embeddings worden vervolgens samen gestapeld om een embeddingmatrix voor de zin te vormen:

Deze matrix wordt de input voor de attentielaag. Vanaf hier gebruikt het model matrixvermenigvuldigingen om query-, key- en value-vectoren te genereren, woorden met elkaar te vergelijken en contextuele embeddings te maken waarbij kat weet dat zat, en mat weet dat er iets op ligt.

Vervolgens gaan deze embeddings naar een attentionlaag, waar het model probeert de relaties tussen woorden te begrijpen. Hiervoor wordt elke embedding getransformeerd in drie verschillende vectoren: een query, een key en een value. Deze vectoren worden gemaakt door matrixvermenigvuldiging met leerbare gewichtsmatrices. Hoewel dit wiskundig klinkt, is de intuïtie eenvoudig. De query vertegenwoordigt waar een woord naar op zoek is, de key vertegenwoordigt wat een woord biedt, en de value vertegenwoordigt de informatie die het woord draagt.

Deze vergelijkingen produceren attentiescores, die het model vertellen hoeveel aandacht elke woord moet krijgen. Na het toepassen van een softmaxfunctie worden de scores gewichten die optellen tot één. De waardevectoren worden vervolgens vermenigvuldigd met deze gewichten en bij elkaar opgeteld. Dit creëert een nieuwe representatie voor zat die informatie bevat van kat en mat, en niet alleen van het woord zat zelf.

Na dit proces wordt de embedding voor sat een contextuele embedding. Het betekent niet langer 'zitten' in een algemene zin, maar nu betekent het de kat zit op de mat. Hetzelfde proces gebeurt voor cat, on en mat. Elk woord kijkt naar de anderen, beslist wat belangrijk is en past zijn representatie dienovereenkomstig aan.

Dit is het kernidee van aandacht: elk woord bepaalt welke andere woorden belangrijk zijn en hoeveel ze ertoe doen. Vectorvermenigvuldigingen en matrices zijn simpelweg de wiskundige hulpmiddelen die deze vergelijkingen efficiënt en leerbaar maken. Zelfs bij een klein zin van vier woorden stelt aandacht het model in staat om betekenis op te bouwen door woorden met elkaar te verbinden, in plaats van ze geïsoleerd te behandelen.

Geschaalde Dot-Product-Aandacht

De kernoperatie van aandacht wordt geschaalde dot-product aandacht genoemd en wordt als volgt gedefinieerd:

Hier zijn Q, K en V matrices van queries, keys en values, en dk is de dimensionaliteit van de key-vectoren.

Het inwendig product QKT meet de gelijkenis tussen een query en alle keys. Een hogere waarde betekent een sterkere relevantie. Delen door dk voorkomt dat deze gelijkenisscores te groot worden wanneer het aantal vector dimensies toeneemt. Zonder deze schaalverdeling zou de softmax-functie extreem scherpe verdelingen produceren, wat leidt tot zeer kleine gradiënten en instabiele training.

Na het schalen zet softmax de scores om in waarschijnlijkheden die samen één vormen. Deze waarschijnlijkheden bepalen hoeveel elke waarde bijdraagt aan de uiteindelijke output. De resulterende vector is een gewogen samenvatting van relevante informatie uit de hele reeks.

Waarom Single-Head Attention Beperkt Is

Single-head attention past dit proces één keer toe, waardoor er één perspectief op de input wordt geproduceerd. Hoewel effectief, dwingt deze aanpak het model om alle relaties in één representatie te comprimeren. Dit wordt een beperking wanneer de gegevens meerdere soorten afhankelijkheden bevatten, zoals grammatica, betekenis en langeafstandsrelaties.

In de praktijk vereist taal vaak het begrijpen van meerdere relaties tegelijk.

Bijvoorbeeld, een woord kan syntactisch afhankelijk zijn van een token terwijl het semantisch gerelateerd is aan een ander. Eén enkele aandachtkop heeft moeite om al deze patronen tegelijkertijd vast te leggen.

Multi-Head Attention in Transformers

In Transformer-encoders maakt multi-head self-attention het mogelijk dat elk token aandacht besteedt aan elk ander token in de invoer, wat resulteert in contextgebaseerde embeddings. In decoders zorgt masked self-attention ervoor dat tokens geen aandacht kunnen besteden aan toekomstige posities, wat essentieel is voor autoregressieve generatie. In encoder-decoder attention komen de queries uit de decoder, terwijl de keys en values uit de encoder komen, wat uitlijning tussen input- en outputreeksen mogelijk maakt.

Deze verschillende toepassingen van multi-head attention stellen Transformers in staat taken zoals vertalen, samenvatten en tekstgeneratie met hoge nauwkeurigheid uit te voeren.

Hoe Multi-Head Attention Werkt

Multi-head attention lost dit probleem aan door meerdere aandachtmechanismen parallel uit te voeren. In plaats van de aandacht direct toe te passen op de originele embeddings, projecteert het model ze eerst in meerdere lagere-dimensionale ruimtes met behulp van geleerde matrices.

Voor elk hoofd i worden de projecties berekend als:

Elk hoofd past vervolgens onafhankelijk geschaalde dot-product aandacht toe:

De outputs van alle hoofden worden samengevoegd en door een laatste lineaire laag geleid:

Intuïtief leert elk hoofd zich te concentreren op een ander aspect van de reeks. Het ene hoofd kan de woordvolgorde vastleggen, een ander kan zich richten op semantische overeenkomsten, terwijl weer een ander lange-afstand-afhankelijkheden bijhoudt. De uiteindelijke projectie combineert deze perspectieven tot één rijke representatie.

Multi-Head Attention in PyTorch (Met Tensor vormen)

Het volgende voorbeeld laat zien hoe multi-head attention intern werkt met PyTorch. We beginnen met een batch van tokenembeddings en doorlopen de belangrijkste stappen, waarbij we benadrukken hoe de vormen van de tensors gedurende het proces veranderen.

import torch
import torch.nn as nn

We nemen een batch van getokeniseerde reeksen aan, waarbij elk token wordt weergegeven door een embedvector.

batch_size = 2
sequence_length = 4
embedding_dim = 8
num_heads = 2
head_dim = embedding_dim // num_heads

Hier wordt embedding_dim gelijk verdeeld over de attentiehoofden. Elk hoofd werkt met vectors van grootte head_dim.

x = torch.randn(batch_size, sequence_length, embedding_dim)

In dit stadium is de vorm van de input-tensor:

Stap 1: Lineaire projecties voor queries, keys en values

Elke token-embedding wordt geprojecteerd naar queries, keys en values met behulp van geleerde lineaire lagen.

W_q = nn.Linear(embedding_dim, embedding_dim)
W_k = nn.Linear(embedding_dim, embedding_dim)
W_v = nn.Linear(embedding_dim, embedding_dim)

Q = W_q(x)
K = W_k(x)
V = W_v(x)

Na projectie hebben alle drie de tensoren dezelfde vorm:

Stap 2: Verdeel Embeddings in Meerdere Hoofden

Om meerdere attentiehoofden te creëren, vormen we de tensors opnieuw zodat elk hoofd op een kleinere subruimte werkt.

Q = Q.view(batch_size, sequence_length, num_heads, head_dim)
K = K.view(batch_size, sequence_length, num_heads, head_dim)
V = V.view(batch_size, sequence_length, num_heads, head_dim)

De nieuwe vorm wordt:

(2,4,2,4)

We transponeren vervolgens de tensors om de num_heads-dimensie naar voren te brengen.

Q = Q.transpose(1, 2)
K = K.transpose(1, 2)
V = V.transpose(1, 2)

Nu heeft elke tensor de vorm:

Stap 3: Schaalbare Dot-Product Aandacht

We berekenen attentiescores door het inwendig product van queries en keys te nemen.

scores = torch.matmul(Q, K.transpose(-2, -1))
scores = scores / (head_dim ** 0.5)

De tensor van de attentiescore heeft de vorm:

(2,2,4,4)

Dit geeft weer hoeveel elk token aandacht besteedt aan elk ander token binnen elk hoofd.

Stap 4: Softmax en Gewogen Som

We normaliseren de attentiescores met softmax en passen ze toe op de waarden.

attention_weights = torch.softmax(scores, dim=-1)
output = torch.matmul(attention_weights, V)

De output per hoofd heeft de vorm:

(2,2,4,4)

Elke token bevat nu een contextbewuste representatie op basis van aandacht.

Stap 5: Koppen Samenvoegen en Eindprojectie

We combineren alle aandachtshoofden weer tot één enkele embedding.

output = output.transpose(1, 2)
output = output.contiguous().view(batch_size, sequence_length, embedding_dim)

De samengevoegde uitvoervorm is:

(2,4,8)

Een laatste lineaire laag mengt informatie over de heads heen.

W_o = nn.Linear(embedding_dim, embedding_dim)
final_output = W_o(output)

De uiteindelijke uitvoer-tensor heeft de vorm:

(2,4,8)

Dit komt overeen met de oorspronkelijke embedded-dimensie en kan worden doorgegeven aan de volgende Transformer-laag.

Het gebruik van PyTorch's ingebouwde MultiHeadAttention

PyTorch biedt ook een ingebouwde implementatie die deze stappen intern afhandelt.

mha = nn.MultiheadAttention(
    embed_dim=embedding_dim,
    num_heads=num_heads,
    batch_first=True
)

output, attention_weights = mha(x, x, x)

Hier heeft output de vorm (2, 4, 8), en attention_weights heeft de vorm (2, 2, 4, 4) wanneer average_attn_weights=False.

Wat is Masked Multi-Head Attention?

Masked Multi-Head Attention is een speciale vorm van aandacht die wordt gebruikt wanneer een model toekomstige woorden niet mag zien.

In eenvoudige woorden:
Gemaskeerde Multi-Head Attention voorkomt dat een woord vooruit kijkt in de zin.

Dit is essentieel voor tekstgeneratiemodellen zoals GPT, waarbij het model het volgende woord stap voor stap voorspelt.

Bij het genereren van tekst moet het model zich gedragen alsof een mens een zin schrijft. Op elk moment mag je alleen vorige woorden gebruiken, niet toekomstige. Als het model tijdens het trainen toekomstige woorden zou kunnen zien, zou dat valsspelen zijn. Maskeren zorgt ervoor dat het model leert het volgende woord te voorspellen met alleen wat al is verschenen.

Multi-head attention betekent het gelijktijdig uitvoeren van meerdere attentie-mechanismen zodat het model verschillende soorten verbanden kan begrijpen, zoals grammatica, betekenis of nadruk. Masking betekent het verbergen van toekomstige woorden zodat het model niet kan valsspelen door informatie te zien die het nog niet zou moeten hebben.

Het masker is een driehoekige matrix:

Dit zorgt ervoor dat toekomstige posities worden geblokkeerd tijdens de berekening van de attentiescore.

Elk aandachtshoofd berekent eerst aandachtsscores met behulp van queries en keys. Voordat softmax wordt toegepast, wordt het masker aan deze scores toegevoegd. Het masker kent extreem grote negatieve waarden toe aan toekomstige posities, waardoor hun softmaxkans nul wordt.

Dit proces wordt onafhankelijk voor elke kop herhaald. Daarna worden alle uitvoerwaarden van de koppen samengevoegd en door een lineaire laag geleid om de uiteindelijke uitvoer te produceren.

Het belangrijkste idee is dat maskeren plaatsvindt voordat softmax wordt toegepast en onafhankelijk in elk hoofd.

Veelgestelde vragen

Waarom splitst multi-head attention embeddings in kleinere dimensies?

Het splitsen van embeddings stelt elke aandachtshoofd in staat om in een andere subruimte te werken. Dit voorkomt dat hoofddezelfde patronen leren en bevordert diversiteit in de relaties die elk hoofd vastlegt.

Waarom wordt softmax gebruikt in attention in plaats van een andere normalisatiemethode?

Softmax zet gelijkenheidsscores om in waarschijnlijkheden die optellen tot één, waardoor de aandachtgewichten interpreteerbaar en stabiel worden. Het zorgt ervoor dat relevantere tokens hogere gewichten krijgen, terwijl minder relevante tokens slechts minimaal bijdragen.

Wat gebeurt er als de schaalfactor uit de aandacht wordt verwijderd?

Zonder schaling kunnen de waarden van het dot-product groot worden naarmate de dimensionaliteit toeneemt. Dit duwt softmax in verzadigde gebieden waar de gradiënten zeer klein zijn, wat het leren vertraagt en de prestaties van het model schaadt.

Is multi-head aandacht interpreteerbaar?

Tot op zekere hoogte, ja. Aandachtsgewichten kunnen worden gevisualiseerd om te laten zien welke tokens andere beïnvloeden. Interpretatie wordt echter moeilijker naarmate modellen groter worden en de attentiehoofden op complexe manieren met elkaar omgaan.

Waarom schaalt multi-head attention slecht bij lange reeksen?

Attention berekent interacties tussen alle tokens in paren, wat resulteert in kwadratische tijd- en geheugengebruik. Dit maakt lange reeksen duur om te verwerken, wat efficiënte varianten zoals sparse attention en FlashAttention motiveert.

Conclusie

Multi-head attention breidt het basis aandachtmechanisme uit door modellen in staat te stellen zich gelijktijdig op meerdere aspecten van de input te richten. Door aparte aandachtshoofden vast te leggen, kan het diverse relaties vastleggen die een enkel aandachtmechanisme niet effectief kan representeren. Met stabiele schaalvergroting, parallelle berekeningen en rijke contextuele modellering is multi-head attention een hoeksteen geworden van moderne deep learning-architecturen. Het begrijpen van dit mechanisme biedt diepgaand inzicht in hoe de krachtigste AI-modellen van vandaag complexe data verwerken en analyseren.

Hulpbronnen

• Aandacht is alles wat je nodig hebt
• Een beginnersvriendelijke blik op Transformers
• Regressie vs Transformers: Belangrijkste Verschillen en Wanneer Elk Model te Gebruiken
• Vision Transformers (ViTs): Computer Vision met Transformer-modellen
• Een uitgebreide gids over de Byte Latent Transformer-architectuur

Bedankt dat je samen met de Linux-Console.net-community hebt geleerd.