Approfondimento facoltativo: la matematica dei modelli linguistici
Da qui in poi il modello lavora solo su vettori di numeri, come la rete dei laboratori.
DenseLayer senza bias: se \(\mathbf{e}_t\) è il vettore one-hot del token (tutti zeri, un 1 in posizione \(t\)), allora \(\mathbf{x} = E^\mathsf{T} \mathbf{e}_t\), con \(W = E^\mathsf{T}\) di dimensione \(d \times M\). Per un quadrato d’immagine con pixel \(\mathbf{u}\), allo stesso modo \(\mathbf{x} = W \mathbf{u}\).I vettori, uno per riga, formano la matrice \(X\) di dimensione \(n \times d\): la riga \(i\) è \(\mathbf{x}_i^\mathsf{T}\), il token \(i\). In GPT-3, \(d = 12\,288\).
\(L\) blocchi uguali, ciascuno con i suoi pesi, trasformano \(X\) senza cambiarne la forma. In GPT-3: \(M = 50\,257\), \(d = 12\,288\), \(L = 96\), fino a \(n = 2048\) token. Il pezzo nuovo è l’attenzione.
In «la pila del telecomando è scarica», pila è una batteria; in «una pila di libri», no. Il significato di un token dipende dagli altri token della sequenza.
Un DenseLayer applicato a ogni token separatamente non può saperlo: vede un vettore alla volta. Nella rete MNIST ogni immagine è un esempio a sé; qui gli ingressi di una sequenza sono legati fra loro.
Serve un’operazione che mescoli i token: per ogni token, una media pesata dei vettori degli altri, con pesi calcolati dai token stessi. È l’attenzione.
Per ogni token \(i\), tre DenseLayer senza bias danno tre vettori di dimensione \(d_k\): \[
\mathbf{q}_i = W_Q\, \mathbf{x}_i \ \ (\textit{query}), \qquad \mathbf{k}_i = W_K\, \mathbf{x}_i \ \ (\textit{key}), \qquad \mathbf{v}_i = W_V\, \mathbf{x}_i \ \ (\textit{value}),
\] con \(W_Q\), \(W_K\), \(W_V\) di dimensione \(d_k \times d\). Per ogni coppia di token \((i, j)\): \[
s_{ij} = \frac{\mathbf{q}_i \cdot \mathbf{k}_j}{\sqrt{d_k}}, \qquad
a_{ij} = \frac{e^{s_{ij}}}{\sum_{j'} e^{s_{ij'}}}, \qquad
\mathbf{y}_i = \sum_j a_{ij}\, \mathbf{v}_j .
\]
Anche un DenseLayer sui token messi in fila, \(n \cdot d\) numeri, mescola i token: \[\text{MLP:}\quad \mathbf{y}_i = \sum_j W_{ij}\, \mathbf{x}_j \qquad\qquad \text{attenzione:}\quad \mathbf{y}_i = \sum_j a_{ij}(\mathbf{x}_i, \mathbf{x}_j)\; W_V\, \mathbf{x}_j\]
Sulle cifre, con la media dei token, l’attenzione non serve (slide «Cosa aspettarsi»): serve quando un token deve raccogliere l’informazione degli altri.
Con \(X\) che ha per righe i token, la riga \(i\) di \(X W_Q^\mathsf{T}\) è \((W_Q \mathbf{x}_i)^\mathsf{T} = \mathbf{q}_i^\mathsf{T}\); quindi \[ Q = X W_Q^\mathsf{T}, \quad K = X W_K^\mathsf{T}, \quad V = X W_V^\mathsf{T} \ \ (n \times d_k), \qquad S = \frac{Q K^\mathsf{T}}{\sqrt{d_k}} \ \ (n \times n), \qquad Y = A\, V, \] con \(A\) la softmax di \(S\) riga per riga: l’elemento \((i, j)\) di \(Q K^\mathsf{T}\) è proprio \(\mathbf{q}_i \cdot \mathbf{k}_j\).
Se le componenti \(q_c\) di \(\mathbf{q}_i\) e \(k_c\) di \(\mathbf{k}_j\) sono indipendenti, con media 0 e varianza 1 (come all’inizio, con pesi ben inizializzati), \(\mathbf{q}_i \cdot \mathbf{k}_j = \sum_c q_c\, k_c\) ha media 0 e \[ \mathrm{Var}(\mathbf{q}_i \cdot \mathbf{k}_j) = \sum_{c=1}^{d_k} \mathrm{Var}(q_c\, k_c) = \sum_{c=1}^{d_k} \langle q_c^2 \rangle \langle k_c^2 \rangle = d_k . \]

In ogni blocco l’attenzione si calcola \(H\) volte in parallelo (teste), ciascuna con le sue matrici \(W_Q^{(h)}\), \(W_K^{(h)}\), \(W_V^{(h)}\) di dimensione \(d_k \times d\), con \(d_k = d / H\): \[
Y^{(h)} = \mathrm{softmax}\!\left( \frac{Q^{(h)} K^{(h)\mathsf{T}}}{\sqrt{d_k}} \right) V^{(h)} \quad (n \times d_k), \qquad h = 1, \dots, H .
\] Le \(H\) uscite si affiancano in una matrice \(n \times d\), che passa in un DenseLayer senza bias \(W_O\), \(d \times d\): \[
\mathrm{Attenzione}(X) = \big[\, Y^{(1)} \,\big|\, Y^{(2)} \,\big|\, \cdots \,\big|\, Y^{(H)} \,\big]\; W_O^\mathsf{T} \qquad (n \times d).
\]
Ogni testa impara relazioni diverse: nei modelli addestrati si trovano, per esempio, teste che guardano il token precedente, o il nome a cui si riferisce un articolo. In GPT-3, \(H = 96\) teste da \(d_k = 128\): \(96 \cdot 128 = 12\,288 = d\).
Le formule con Eigen (Laboratori 01 e 05): tre token, \(d = d_k = 2\), pesi scelti a mano.
attenzione.cpp (prima parte)
#include <cmath>
#include <iostream>
#include <Eigen/Dense>
// softmax di ogni riga di S
Eigen::MatrixXd softmax_righe(const Eigen::MatrixXd& S) {
Eigen::MatrixXd A(S.rows(), S.cols());
for (int i = 0; i < S.rows(); ++i) {
A.row(i) = (S.row(i).array()
- S.row(i).maxCoeff()).exp();
A.row(i) /= A.row(i).sum();
}
return A;
}Il massimo \(m\) sottratto si semplifica (\(e^{-m}\)): evita solo che exp() dia numeri enormi.
mainattenzione.cpp (seconda parte)
int main() {
Eigen::MatrixXd X(3, 2); // 3 token, d = 2: una riga per token
X << 1.0, 0.0, 0.0, 1.0, 1.0, 1.0;
Eigen::MatrixXd WQ(2, 2), WK(2, 2), WV(2, 2);
WQ << 1.0, 0.0, 0.0, 2.0;
WK << 2.0, 0.0, 0.0, 1.0;
WV << 1.0, 1.0, 0.0, 1.0;
Eigen::MatrixXd Q = X * WQ.transpose(); // riga i: q_i = W_Q x_i
Eigen::MatrixXd K = X * WK.transpose(); // riga i: k_i
Eigen::MatrixXd V = X * WV.transpose(); // riga i: v_i
Eigen::MatrixXd S = Q * K.transpose() / std::sqrt(2.0); // s_ij = q_i . k_j / sqrt(d_k)
Eigen::MatrixXd A = softmax_righe(S); // i pesi a_ij
Eigen::MatrixXd Y = A * V; // riga i: y_i
std::cout << "A =\n" << A << "\n\nY =\n" << Y << "\n";
return 0;
}A =
0.445808 0.108383 0.445808
0.108383 0.445808 0.445808
0.163579 0.163579 0.672842
Y =
1.44581 0.554192
1.44581 0.891617
1.67284 0.836421
A mano, il primo token: \(\mathbf{q}_1 = (1, 0)\), \(\mathbf{k}_j = (2, 0), (0, 1), (2, 1)\), quindi \(s_{1j} = (\sqrt2, 0, \sqrt2)\) e \(a_{1j} = (e^{\sqrt2}, 1, e^{\sqrt2}) / (2 e^{\sqrt2} + 1) = (0.446, 0.108, 0.446)\), la prima riga di A. Con \(\mathbf{v}_j = (1, 0), (1, 1), (2, 1)\): \[
\mathbf{y}_1 = 0.446\,(1, 0) + 0.108\,(1, 1) + 0.446\,(2, 1) = (1.446,\ 0.554).
\]
Provate: prima della softmax, negli elementi di S sopra la diagonale mettete -INFINITY (da <cmath>). Cosa diventa la prima riga di A?
1 0 0: il primo token guarda solo se stesso. La seconda riga diventa 0.19557 0.80443 0, la terza non cambia.
\[ X \leftarrow X + \mathrm{Attenzione}\big(\mathrm{Norm}(X)\big), \qquad X \leftarrow X + \mathrm{MLP}\big(\mathrm{Norm}(X)\big) \]
Un blocco fa due passi, ciascuno con una somma elemento per elemento fra matrici \(n \times d\): \[X' = X + \mathrm{Attenzione}\big(\mathrm{Norm}(X)\big), \qquad X'' = X' + \mathrm{MLP}\big(\mathrm{Norm}(X')\big)\] Ogni passo ha la forma \(X_{\ell+1} = X_\ell + F_\ell(X_\ell)\). Dopo tutti i passi l’uscita è l’ingresso più la somma delle correzioni: \[X_{\text{fine}} = X_0 + \sum_\ell F_\ell(X_\ell)\] Ogni blocco aggiunge qualcosa a \(X\) senza cancellare ciò che c’era: l’informazione dei token arriva fino all’uscita anche attraverso 96 blocchi.
Per una sola componente \(x_\ell\), con \(x_{\ell+1} = x_\ell + f_\ell(x_\ell)\), la regola della catena dà: \[\frac{\partial E}{\partial x_\ell} = \frac{\partial E}{\partial x_{\ell+1}}\,\big(1 + f_\ell'(x_\ell)\big) \quad\Rightarrow\quad \frac{\partial E}{\partial x_0} = \frac{\partial E}{\partial x_{\text{fine}}} \prod_\ell \big(1 + f_\ell'\big)\] Sviluppando il prodotto, \(1 + \sum_\ell f_\ell' + \dots\), c’è il termine 1: l’errore dell’uscita arriva intatto anche al primo blocco.
Senza le somme resterebbe solo \(\prod_\ell f_\ell'\), come i fattori \(\sigma'\) della Lezione 03: con fattori di 0,25, dieci passi danno \(0{,}25^{10} \approx 10^{-6}\).
Con le matrici, 1 diventa l’identità \(I\) e \(f_\ell'\) la jacobiana \(\partial F_\ell / \partial X_\ell\). Sono le stesse somme delle ResNet (approfondimento sulle CNN).
Norm (LayerNorm), su ogni riga \(\mathbf{x}\) di \(X\) separatamente, con \(\mu\) e \(\sigma^2\) media e varianza delle sue \(d\) componenti: \[ \mathrm{Norm}(\mathbf{x}) = \boldsymbol{\gamma} \odot \frac{\mathbf{x} - \mu}{\sqrt{\sigma^2 + \varepsilon}} + \boldsymbol{\beta}, \] con \(\boldsymbol{\gamma}, \boldsymbol{\beta} \in \mathbb{R}^d\) parametri, \(\odot\) il prodotto elemento per elemento, \(\varepsilon \approx 10^{-5}\). Tiene le componenti dell’ordine di 1.
MLP, su ogni riga separatamente: la rete dei laboratori, con due DenseLayer \(d \to 4d \to d\), \[
\mathrm{MLP}(\mathbf{x}) = W_2\, \mathrm{GELU}(W_1 \mathbf{x} + \mathbf{b}_1) + \mathbf{b}_2, \qquad
\mathrm{GELU}(z) = z\, \Phi(z),
\] con \(W_1\): \(4d \times d\), \(W_2\): \(d \times 4d\) e \(\Phi\) la funzione di ripartizione della gaussiana standard. La GELU è una ReLU smussata: circa \(z\) per \(z \gg 0\), circa 0 per \(z \ll 0\).
DenseLayer \(d \to M\) che in GPT-2 usa la stessa \(E\) dei token.In un blocco, trascurando bias e Norm (\(13 d\) numeri):
| parte | matrici | parametri |
|---|---|---|
| attenzione | \(W_Q\), \(W_K\), \(W_V\) di tutte le teste insieme, e \(W_O\): quattro matrici \(d \times d\) | \(4d^2\) |
| MLP | \(W_1\), \(4d \times d\), e \(W_2\), \(d \times 4d\) | \(8d^2\) |
| blocco | \(12 d^2\) |
Per GPT-3, \(d = 12\,288\) e \(L = 96\): \(96 \cdot 12 \cdot 12\,288^2 \approx 173{,}9\) miliardi. La matrice \(E\) ne aggiunge \(50\,257 \cdot 12\,288 \approx 0{,}6\) miliardi, le posizioni \(2048 \cdot 12\,288 \approx 0{,}03\): in totale circa 175 miliardi.
forward dà tutte le \(\mathbf{p}^{(i)}\).Con \(N\) parametri, ogni parametro entra in una moltiplicazione e una somma per ogni token:
forward e \(4N\) nella backpropagation, che per ogni DenseLayer calcola due prodotti, il gradiente rispetto ai pesi e quello rispetto all’ingresso.Addestrato sui testi, il modello li continua: a una domanda può rispondere con altre domande. Seguono due fasi (InstructGPT, 2022):
DenseLayer li porta a dimensione \(d\), si sommano le posizioni, poi lo stesso transformer, senza maschera; come costruirne uno per le cifre, nelle slide seguenti.Il quadrato \(k = 4P + Q\) (\(P, Q = 0, \dots, 3\)) ha i pixel \(u_k[7r + c] = \mathrm{img}[7P + r,\ 7Q + c]\), con \(r, c = 0, \dots, 6\): un vettore \(\mathbf{u}_k\) di 49 numeri, che diventa un token come in «Dagli interi ai vettori»: \[\mathbf{x}_k = W \mathbf{u}_k + \mathbf{r}_k \qquad (W:\ d \times 49 \text{ senza bias},\ \ \mathbf{r}_k \in \mathbb{R}^d \text{ parametri})\] Con un token per riga, \(X = U W^\mathsf{T} + R\), di dimensione \(16 \times d\). Il framework lavora per colonne: lì conviene una colonna per token, e tutte le formule di questa sezione si traspongono.
| passo | formula | dimensione |
|---|---|---|
| token | \(X = U W^\mathsf{T} + R\) | \(16 \times d\) |
| attenzione | \(X_1 = X + A\, V\, W_O^\mathsf{T}\) | \(16 \times d\) |
| MLP | \(X_2 = X_1 + f(Z_1)\, W_2^\mathsf{T} + \mathbf{1}\mathbf{b}_2^\mathsf{T}\) | \(16 \times d\) |
| media | \(\mathbf{h} = \frac{1}{16}\sum_k\) (riga \(k\) di \(X_2\)) | \(d\) |
| testa | \(\mathbf{p} = \mathrm{softmax}(W_h \mathbf{h} + \mathbf{b}_h)\), \(\ E = -\ln p_y\) | \(10\) |
Qui \(Q = X W_Q^\mathsf{T}\), \(K = X W_K^\mathsf{T}\), \(V = X W_V^\mathsf{T}\) (\(16 \times d_k\)), \(A = \mathrm{softmax}(Q K^\mathsf{T}/\sqrt{d_k})\) riga per riga, \(Z_1 = X_1 W_1^\mathsf{T} + \mathbf{1}\mathbf{b}_1^\mathsf{T}\), \(f\) la ReLU o la GELU, \(\mathbf{1}\) un vettore di 16 uni, \(y\) la cifra giusta.
Senza maschera: ogni quadrato guarda tutti gli altri. Chi vuole le Norm le mette prima dell’attenzione e dell’MLP, come in «Il blocco transformer».
Notazione: \(dM = \partial E / \partial M\), della forma di \(M\). Per una matrice applicata a tutti i token, \(Z = X W^\mathsf{T}\): \(dW = dZ^\mathsf{T} X\) (somma sui token) e \(dX = dZ\, W\).
Da \(dX_1\), con \(Y = AV\) e \(S = QK^\mathsf{T}/\sqrt{d_k}\): \[dW_O = dX_1^\mathsf{T}\, Y, \qquad dY = dX_1 W_O, \qquad dV = A^\mathsf{T} dY, \qquad dA = dY\, V^\mathsf{T}\] La softmax di ogni riga ha \(\partial a_{ij} / \partial s_{ik} = a_{ij}\,(\delta_{jk} - a_{ik})\), quindi \[dS_{ij} = a_{ij}\Big(dA_{ij} - \sum_k a_{ik}\, dA_{ik}\Big), \qquad dQ = \frac{dS\, K}{\sqrt{d_k}}, \qquad dK = \frac{dS^\mathsf{T} Q}{\sqrt{d_k}}\] con \(dW_Q = dQ^\mathsf{T} X\), \(dW_K = dK^\mathsf{T} X\), \(dW_V = dV^\mathsf{T} X\). Verso i token, con la somma residua, \(dX = dX_1 + dQ\, W_Q + dK\, W_K + dV\, W_V\).
Prima di addestrare, ogni backward si controlla con le differenze finite: per ogni parametro \(\theta\) \[\frac{\partial E}{\partial \theta} \approx \frac{E(\theta + \varepsilon) - E(\theta - \varepsilon)}{2\varepsilon}, \qquad \varepsilon = 10^{-6}\] in double, su una sola immagine e con dimensioni piccole (per esempio \(d = d_k = 8\)). Si confronta con il gradiente calcolato dal backward attraverso l’errore relativo \(\max |g_\text{num} - g| / \max |g_\text{num}|\).
Con le formule di queste slide l’errore relativo è circa \(10^{-8}\), con e senza Norm, con la ReLU e con la GELU. Un errore di \(10^{-2}\) o più indica uno sbaglio; di solito una trasposta o un \(\sqrt{d_k}\) dimenticato.
Con \(d = d_k = 32\), un MLP \(32 \to 64 \to 32\) e la ReLU i parametri sono 10 698: \(W\) 1568, \(R\) 512, \(W_Q, W_K, W_V, W_O\) 4096, MLP 4192, testa 330. Sul test di MNIST:
| rete | parametri | sul test |
|---|---|---|
| ViT, AdamW con passo a coseno, 30 epoche | 10 698 | 97,7% |
| ViT, SGD con un’immagine per passo, passo a coseno | 10 698 | 97,6% |
| ViT senza posizioni \(\mathbf{r}_k\) | 10 186 | 92,5% |
| MLP 784 → 13 → 10 | 10 345 | 95,0% |
Senza le posizioni il modello non sa da quale quadrato viene un token. Con la media dei token l’attenzione non aiuta: senza, a pari parametri, l’MLP per token arriva al 97,8%. Si vede quando l’uscita legge un solo token: da un quadrato d’angolo 93,5% con l’attenzione e 13,7% senza, da uno centrale 95,9% e 71,1%.
Il modello non naviga e non vede: riceve sequenze di vettori e produce probabilità sul token successivo. Il resto lo fanno i programmi intorno.
Fra i due token speciali il modello scrive la richiesta in un formato strutturato, di solito JSON. Il programma la legge e chiama il codice dello strumento:
«inizio richiesta» {"strumento": "cerca", "testo": "previsioni meteo Roma domani"} «fine richiesta»
clicca(412, 230) o scrivi("Roma"), tradotte in comandi per il browser (per esempio con Playwright); dopo ogni azione uno screenshot torna nella sequenza come token d’immagine.Il modello produce solo testo: se e come eseguirlo lo decide il programma, con i suoi controlli di sicurezza.
Per metterlo in pratica: la traccia 14 dei progetti finali (Laboratorio 15), un piccolo transformer in C++ dentro BASIC_NEURAL++.