Self-Attention vanaf nul
Je hebt een neuron en een forward pass gebouwd. Nu bouw je het ene idee dat gewone neurale netten veranderde in transformers en vandaar in de LLM's achter elke chatassistent: self-attention. Het is een handvol matrixvermenigvuldigingen, en je kunt het hele ding in numpy doen.
De intuïtie
Stel je voor dat elk woord in een zin informatie wil verzamelen van de andere woorden. Self-attention geeft elke positie drie vectoren:
- Een query (Q): waar deze positie naar zoekt.
- Een key (K): wat elke positie aanbiedt, gebruikt om te matchen.
- Een value (V): de eigenlijke informatie die elke positie draagt.
Een positie vergelijkt haar query met elke key om te beslissen hoeveel ze naar elke andere positie luistert, en neemt dan met die hoeveelheden een gewogen mengsel van de values. Sterke match -> groot gewicht -> die value draagt meer bij. Dat is het hele mechanisme: queries letten op keys, en het antwoord is een gewogen mengsel van values.
De wiskunde: geschaalde dot-product-attention
De matchscore tussen een query en een key is hun inwendig product (groter als ze dezelfde kant op wijzen). Stapel alle queries in een matrix Q en alle keys in K, en alle scores tegelijk zijn Q @ K.T. We delen door sqrt(d_k) (de dimensie van de keys), zodat de scores niet ontploffen als de vectoren langer worden:
scores = Q @ K.T / np.sqrt(d_k)Waarom überhaupt delen? Een inwendig product groeit met de dimensie. Is d_k 64 en liggen de waarden rond 1, dan komen de ruwe scores rond 64 uit, en zulke grote getallen duwen de softmax naar één key en maken de gradiënt plat. Delen door sqrt(d_k), hier sqrt(64) = 8, trekt de scores terug naar een normaal bereik, zodat attention soepel en trainbaar blijft. In het piepkleine voorbeeld met d_k = 1 dat je hieronder draait, is de deler gewoon 1, dus je ziet het effect niet, maar bij echte modelgroottes is het essentieel.
Elke rij van scores bevat de scores van één query tegen elke key. We maken van elke rij gewichten die positief zijn en optellen tot 1, met een softmax over de laatste as:
weights = softmax(scores, axis=-1) # each row sums to 1Softmax neemt de exponent en normaliseert. Naïef gedaan loopt np.exp van een grote score over naar inf en komen de gewichten uit als nan. De oplossing is de standaardtruc voor numerieke stabiliteit: trek vóór de exponent het maximum van elke rij af. Wiskundig verandert het resultaat niet (dezelfde constante valt boven en onder weg), maar elke exponent blijft <= 0:
def softmax(x):
x = x - x.max(axis=-1, keepdims=True) # stability: largest exponent is now 0
e = np.exp(x)
return e / e.sum(axis=-1, keepdims=True)Tot slot is de uitvoer van elke query haar gewichten toegepast op de values, nog één matrixvermenigvuldiging:
output = weights @ VSamen is de beroemde formule gewoon softmax(Q @ K.T / sqrt(d_k)) @ V. Als Q (n, d_k) is, K (m, d_k) en V (m, d_v), dan is weights (n, m) en output (n, d_v): één uitvoervector per query, elk een mengsel van de rijen van de values.
Dit is de hele transformertruc
Een echte transformer stopt niet bij één attentionberekening. Multi-head attention draait er meerdere tegelijk (elke head leert zijn eigen projecties voor Q, K en V, zodat verschillende heads op verschillende dingen letten) en plakt de resultaten aan elkaar. Een transformerblok stapelt dan attention met een klein feedforward-netwerk en een residuele verbinding, en een model stapelt tientallen van die blokken. Maar het kloppende hart van elk ervan is precies de functie die je zo gaat schrijven: scores, stabiele softmax, gewogen som van values. Bouw dit en je begrijpt de kernbewerking die een LLM herhaalt als het "let op" de prompt.
Eén eerlijke kanttekening: hier krijg je Q, K en V als vaste arrays aangereikt. In een echt model worden ze niet gegeven, ze worden gemaakt door de embedding van elk token te vermenigvuldigen met drie geleerde gewichtsmatrices, W_q, W_k en W_v. Die matrices, en die in elk blok, zijn precies wat de training bijstelt met de gradient descent uit de vorige les. Wat je hier bouwt, is dus de vaste kern van attention die in elke transformer hetzelfde is; het leren zit in de projecties die haar voeden.
Druk op Run om te zien hoe attention een piepkleine Q/K/V omzet in een uitvoer, en hoe de gewichtsmatrix wordt afgedrukt, zodat je kunt aflezen wie op wie lette.
Implementeer scaled dot-product attention in numpy. Schrijf attention(Q, K, V) dat een tuple (output, weights) teruggeeft. Bereken scores = Q @ K.T / np.sqrt(d_k) waar d_k de laatste dimensie van Q is; pas een numerically stable softmax toe over de laatste as (trek de max van elke rij af voor np.exp) om weights te krijgen waarvan de rijen optellen tot 1; dan output = weights @ V. Geef output eerst terug, dan de weights matrix. Stel daarna out, w = attention(Q, K, V) in voor de gegeven arrays.
Een probleem ontdekt in deze les? Meld het · Vraag naar deze les
Deze oefening opent binnenkort
Maak de les ervoor af voordat deze wordt ontgrendeld. De hele cursus is gratis, geen account nodig, en je kunt deze les nu lezen.
Deze browser blokkeert cookies voor learn.floati.life, dus lessen die je hier hebt afgerond kunnen niet in de juiste volgorde worden geopend. Sta cookies toe voor deze site en laad de pagina opnieuw.