Self-Aandag van Nouut
Jy het 'n neuron en 'n forward pass gebou. Nou gaan jy die een idee bou wat eenvoudige neurale netwerke in transformers verander het, en van daar af, in die LLMs agter elke kletskontak: self-attention. Dit is 'n handvol matrieksvermenigvuldigings, en jy kan die hele ding in numpy doen.
Die intuïsie
Verbeel jou elke woord in 'n sin wil inligting van die ander woorde versamel. Self-aandag gee elke posisie drie vektore:
- A query (Q): waarvoor hierdie posisie soek.
- A key (K): wat elke posisie bied, gebruik vir ooreenstemming.
- A value (V): die werklike inligting wat elke posisie dra.
A posisie vergelyk sy query teen elke sleutel om te besluit hoeveel dit na elke ander posisie moet luister, dan neem dit 'n gewigtesde mix van die waardes deur daardie hoeveelhede te gebruik. Sterk ooreenstemming -> groot gewig -> daardie waarde dra meer by. Dit is die hele meganisme: queries gee aandag aan sleutels, en die antwoord is 'n gewigtesde mengsel van waardes.
Die wiskunde: geskaalde kolproduk-aandag
Die ooreenstemmingstelling tussen 'n query en 'n key is hul dot product (groter wanneer hulle dieselfde pad wys). Stap alle queries in 'n matrix Q en alle keys in K, en elke telling gelyktydig is Q @ K.T. Ons deel deur sqrt(d_k) (die key dimensie) sodat die tellings nie ontplof wanneer vektore langer word nie:
scores = Q @ K.T / np.sqrt(d_k)Hoekom moet jy deel? 'n Dot product groei met die dimensie. As d_k 64 is en die entries rondom 1 is, land die raw scores naby 64. Getalle wat so groot is, druk softmax na 'n enkele sleutel en plat die gradient. Deel deur sqrt(d_k), hier sqrt(64) = 8, trek die scores terug na 'n sinvolle reeks sodat aandag glad bly en trainbaar is. In die klein d_k = 1 voorbeeld wat jy onderaan hardloop, is die deler net 1, so jy sal nie sien dat dit 'n probleem veroorsaak nie, maar by werklike modelgroottes is dit noodsaaklik.
Elke row van scores hou een query se tellinge teen elke sleutel. Ons verander elke ry in gewigte wat positief is en tot 1 optel met 'n softmax oor die laaste as:
weights = softmax(scores, axis=-1) # each row sums to 1Softmax exponentieer en normaliseer. As dit naïef gedoen word, np.exp van 'n groot telling vloei oor na inf en die gewigte kom uit as nan. Die regstelling is die standaard numerically stable truc: trek die maksimum van elke ry af voor jy exponentieer. Dit verander die resultaat nie wiskundig nie (dieselfde konstante kanselleer bo en onder), maar dit hou elke eksponent <= 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)Uiteindelik is elke query se uitset die gewigte wat op die waardes toegepas word, wat nog een matriksvermegvuldiging is:
output = weights @ VSaam gesien is die bekende formule net softmax(Q @ K.T / sqrt(d_k)) @ V. As Q is (n, d_k), K is (m, d_k), en V is (m, d_v), dan is weights is (n, m) en output is (n, d_v): een output vector per query, elk 'n mengsel van die waarde-rye.
Dit is die hele transformer-trukie
A regte transformer stop nie by een aandagberekening nie. Multi-head attention hardloop verskeie van hierdie parallel (elke kop leer sy eie Q, K, V projeksies, so verskillende koppe fokus op verskillende dinge) en voeg die resultate saam. 'n Transformer block stap dan aandag saam met 'n klein feed-forward netwerk en 'n residual connection, en 'n model stap tientalle van daardie blokke. Maar die hart van elkeen van hulle is presies die funksie wat jy nou gaan skryf: scores, stable softmax, weighted sum of values. Bou dit en jy verstaan die kernbedryf wat 'n LLM herhaal wanneer dit "aandag gee" aan die prompt.
Een eerlike voorbehoud: hier word Q, K en V aan jou gegee as vaste arrays. In 'n regte model word hulle nie gegee nie, hulle word geproduseer deur elke token se embedding met drie geleerde gewigmatrikse te vermenigvuldig, W_q, W_k en W_v. Daardie matrikse, en diegene in elke blok, is presies wat opleiding aanpas met die gradient descent van die vorige les. Wat jy hier bou is die vaste kern van attention wat identies is in elke transformer; die leerwerk is in die projeksies wat dit voed.
Druk Run om te sien hoe aandag 'n klein Q/K/V in 'n uitset verander en die weight matrix druk sodat jy kan lees wie na wie gekyk het.
Implementeer geskaalde stippuntproduk-aandag in numpy. Skryf attention(Q, K, V) wat 'n tuple (output, weights) teruggee. Bereken scores = Q @ K.T / np.sqrt(d_k) waar d_k die laaste dimensie van Q is; pas 'n numerically stable softmax oor die laaste as aan (trek die maksimum van elke ry af voor np.exp) om weights te kry waarvan die rye tot 1 optel; dan output = weights @ V. Gee output eerste terug, dan die weights matriks. Stel dan out, w = attention(Q, K, V) vir die verskafde arrays.
Sien jy 'n probleem in hierdie les? Rapporteer dit · Vra oor hierdie les
Hierdie oefening open binnekort
Voltooi die lesie voor dit en hierdie een sal ontvanklik wees. Die hele kursus is gratis, geen rekening nodig nie, en jy kan hierdie les nou lees.
Hierdie blutser blokkeer koekies vir learn.floati.life, so lesse wat jy hier voltooi het kan nie in volgorde oopgaan nie. Laat koekies vir hierdie webwerf toe en laai nuut.