Programma Lezione 107 di 250 · Intuizione sulle reti neurali, LLM e progetto finale di IA
Intuizione sulle reti neurali, LLM e progetto finale di IA

Self-attention da zero

Hai costruito un neurone e una passata in avanti. Ora costruirai l'unica idea che ha trasformato le semplici reti neurali nei transformer e, da lì, negli LLM dietro ogni assistente di chat: la self-attention. Sono una manciata di moltiplicazioni tra matrici, e puoi fare tutto con numpy.

L'intuizione

Immagina che ogni parola di una frase voglia raccogliere informazioni dalle altre parole. La self-attention dà a ogni posizione tre vettori:

  • Una query (Q): ciò che questa posizione sta cercando.
  • Una key (K): ciò che ogni posizione offre, usata per l'abbinamento.
  • Un value (V): l'informazione vera e propria che porta ogni posizione.

Una posizione confronta la sua query con ogni key per decidere quanto ascoltare ciascuna delle altre posizioni, poi prende una miscela pesata dei value usando quelle quantità. Abbinamento forte -> peso grande -> quel value contribuisce di più. Questo è tutto il meccanismo: le query prestano attenzione alle key, e la risposta è una miscela pesata dei value.

La matematica: attenzione scaled dot-product

Il punteggio di abbinamento tra una query e una key è il loro prodotto scalare (più grande quando puntano nella stessa direzione). Impila tutte le query in una matrice Q e tutte le key in K, e tutti i punteggi in un colpo sono Q @ K.T. Dividiamo per sqrt(d_k) (la dimensione delle key) così i punteggi non esplodono quando i vettori si allungano:

scores = Q @ K.T / np.sqrt(d_k)

Perché dividere? Un prodotto scalare cresce con la dimensione. Se d_k vale 64 e gli elementi sono intorno a 1, i punteggi grezzi finiscono vicino a 64, e numeri così grandi spingono la softmax su una sola key e appiattiscono il gradiente. Dividere per sqrt(d_k), qui sqrt(64) = 8, riporta i punteggi in un intervallo ragionevole così l'attenzione resta morbida e addestrabile. Nel minuscolo esempio con d_k = 1 che esegui qui sotto il divisore è solo 1, quindi non lo vedrai mordere, ma alle dimensioni dei modelli reali è essenziale.

Ogni riga di scores contiene i punteggi di una query contro ogni key. Trasformiamo ogni riga in pesi positivi la cui somma è 1 con una softmax sull'ultimo asse:

weights = softmax(scores, axis=-1)   # each row sums to 1

La softmax eleva a esponenziale e normalizza. Fatta in modo ingenuo, np.exp di un punteggio grande va in overflow a inf e i pesi escono come nan. La soluzione è il trucco standard numericamente stabile: sottrai il massimo di ogni riga prima di elevare a esponenziale. Matematicamente non cambia il risultato (la stessa costante si cancella sopra e sotto), ma tiene ogni esponente <= 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)

Infine, l'uscita di ogni query sono i suoi pesi applicati ai value, cioè un'altra moltiplicazione tra matrici:

output = weights @ V

Messa insieme, la famosa formula è solo softmax(Q @ K.T / sqrt(d_k)) @ V. Se Q è (n, d_k), K è (m, d_k), e V è (m, d_v), allora weights è (n, m) e output è (n, d_v): un vettore di uscita per query, ognuno una miscela delle righe dei value.

Questo è tutto il trucco del transformer

Un vero transformer non si ferma a un solo calcolo di attenzione. La multi-head attention ne esegue diversi in parallelo (ogni testa impara le proprie proiezioni Q, K, V, quindi teste diverse prestano attenzione a cose diverse) e concatena i risultati. Un blocco transformer poi impila l'attenzione con una piccola rete feed-forward e una connessione residua, e un modello impila decine di quei blocchi. Ma il cuore che batte in ognuno di loro è esattamente la funzione che stai per scrivere: punteggi, softmax stabile, somma pesata dei value. Costruisci questo e capisci l'operazione centrale che un LLM ripete quando "presta attenzione" al prompt.

Un'avvertenza onesta: qui Q, K e V ti vengono dati come array fissi. In un modello reale non vengono dati, vengono prodotti moltiplicando l'embedding di ogni token per tre matrici di pesi apprese, W_q, W_k e W_v. Quelle matrici, e quelle di ogni blocco, sono esattamente ciò che l'addestramento regola usando la discesa del gradiente dell'ultima lezione. Quindi ciò che costruisci qui è il nucleo fisso dell'attenzione che è identico in ogni transformer; l'apprendimento vive nelle proiezioni che lo alimentano.

Premi Run per vedere l'attenzione trasformare un minuscolo Q/K/V in un'uscita e stampare la matrice dei pesi così puoi leggere chi ha prestato attenzione a chi.

Tocca a te

Implementa l'attenzione scaled dot-product in numpy. Scrivi attention(Q, K, V) che restituisce una tupla (output, weights). Calcola scores = Q @ K.T / np.sqrt(d_k) dove d_k è l'ultima dimensione di Q; applica una softmax numericamente stabile sull'ultimo asse (sottrai il massimo di ogni riga prima di np.exp) per ottenere weights le cui righe sommano a 1; poi output = weights @ V. Restituisci prima output, poi la matrice weights. Poi assegna out, w = attention(Q, K, V) per gli array forniti.

Hai notato un problema in questa lezione? Segnalalo · Chiedi qualcosa su questa lezione

Questo esercizio si apre presto

Finisci la lezione precedente e questa si sblocca. L'intero corso è gratuito, senza account, e puoi leggere questa lezione subito.