Attention 2014: il decoder smette di guardare un solo vettore

Su frasi corte, seq2seq vanilla e Bahdanau attention sono pari. Su frasi oltre le quaranta parole, vanilla crolla, Bahdanau resta competitivo. La differenza, dentro il codice, sta in poche righe: a ogni passo del decoder, calcola dei pesi su tutti gli stati dell’encoder e somma. Una modifica architetturale piccola, una conseguenza enorme: scompare il bottleneck del thought vector e nasce il vocabolario tecnico che reggera la traduzione neurale, e poi i transformer, per il decennio successivo.

Perché questo capitolo

C’e un dettaglio aneddotico che Dzmitry Bahdanau ricorda in più di un’intervista. Nell’estate del 2014, ancora dottorando al MILA di Montreal sotto Yoshua Bengio, fa uno stage breve all’Università Jacobs di Brema, nel laboratorio di Jurgen Schmidhuber. Lavora su seq2seq alla Cho et al. — l’encoder-decoder con GRU che il gruppo di Bengio aveva pubblicato a giugno — e si scontra con il problema visibile a chiunque guardasse i numeri: per frasi lunghe la qualità crolla. Tornato a Montreal, prova soluzioni varie. Riassunti lineari, proiezioni multiple, bottleneck di forme diverse. Niente funziona pulito. Poi prova un’idea diversa: invece di comprimere tutto in un vettore, dare al decoder accesso a tutti gli stati dell’encoder e lasciare che a ogni passo scelga su quali “guardare”. Il risultato lo stupisce. Il bottleneck scompare, le frasi lunghe smettono di essere un problema, le matrici di pesi che il modello apprende rivelano allineamenti tra parole sorgente e parole target che ricordano da vicino quelli prodotti da decenni di linguistica computazionale. Il paper esce su arXiv il 1 settembre 2014, viene pubblicato a ICLR 2015 come “Neural Machine Translation by Jointly Learning to Align and Translate”. Diventera uno dei lavori più citati del decennio in machine learning.

Il primo motivo per cui questo capitolo conta e operativo. Il bottleneck di seq2seq-2014 era un limite strutturale: tutta la frase sorgente, qualunque la sua lunghezza, doveva passare attraverso un singolo vettore di poche migliaia di dimensioni. Sutskever et al. lo aggiravano con il trick di input reversal, un workaround empirico. Bahdanau, Cho e Bengio lo eliminano con una modifica architetturale: il decoder, a ogni passo, costruisce dinamicamente un context vector come somma pesata di tutti gli stati dell’encoder. Niente più compressione forzata. La curva BLEU in funzione della lunghezza della frase sorgente, che per seq2seq vanilla degradava monotonicamente, diventa quasi piatta.

Il secondo motivo e di lunga gittata. Il termine “attention” entra nel vocabolario tecnico nello stesso anno e diventera, nei tre anni successivi, il nome del meccanismo che sostituisce ricorrenza e convoluzione come componente principale delle reti per sequenze. La filiazione che parte da qui — Luong 2015 con la versione moltiplicativa, Cheng et al. 2016 con la self-attention, Vaswani et al. 2017 con il transformer multi-head — e una linea diretta. Ogni transformer moderno, ogni LLM, ogni modello vision-language, eredità il meccanismo formalizzato per la prima volta in questo paper. Capire come Bahdanau imposto la cosa nel 2014 non e solo cultura storica: e capire da dove arriva il pezzo centrale dell’architettura che si studiera in attention-intuizione (in preparazione) (in preparazione, Parte IX) e in qkv-da-zero (in preparazione) (in preparazione, Parte IX).

C’e infine un terzo motivo, di metodo. Decadi di linguistica computazionale avevano insegnato che la traduzione richiedeva allineamenti espliciti tra parole della sorgente e parole della target. Modelli IBM, phrase-based MT, tabelle di allineamento erano l’infrastruttura indispensabile. Il modello di Bahdanau non riceve mai allineamenti come supervisione: impara a tradurre ottimizzando la sola log-likelihood della frase target. Eppure, ispezionando i pesi di attention dopo l’addestramento, si vedono mappe che corrispondono molto da vicino agli allineamenti che SMT calcolava esplicitamente. Una struttura linguistica nota emerge come effetto collaterale di una pressione di ottimizzazione su un task più generale. E un caso istruttivo di scoperta induttiva: il modello scopre ciò che doveva essere programmato.

Contesto

Il filo arriva da tre direzioni. La prima e seq2seq vanilla. A settembre 2014, Ilya Sutskever, Oriol Vinyals e Quoc V. Le pubblicano “Sequence to Sequence Learning with Neural Networks” (NIPS 2014, arXiv:1409.3215). Due LSTM impilate, encoder e decoder, vettore di stato finale come unica interfaccia. Il modello batte SMT su WMT’14 English-French (BLEU 34.81 contro 33.30 del miglior sistema statistico) ma la curva di qualità per lunghezza della frase sorgente degrada visibilmente oltre le 30 parole. Il paper Sutskever lo riconosce esplicitamente. Il bottleneck è il problema strutturale che resta aperto.

La seconda direzione viene dal MILA stesso. A giugno 2014, Kyunghyun Cho, Bart van Merrienboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk e Yoshua Bengio pubblicano “Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation” (EMNLP 2014, arXiv:1406.1078). Il paper introduce la GRU (Gated Recurrent Unit), una variante semplificata dell’LSTM con due gate invece di tre, e propone un’architettura encoder-decoder ricorrente che produce score di traduzione di phrase pair, integrati come feature aggiuntiva dentro la pipeline Moses. Lo stesso bottleneck di seq2seq vanilla affligge anche questo modello: il gruppo di Bengio lo vede chiaramente prima ancora del paper di Sutskever, e comincia a cercare soluzioni.

La terza direzione viene da lavori paralleli su attention applicata fuori da NMT. Alex Graves, allora a DeepMind, pubblica nel 2013 “Generating Sequences with Recurrent Neural Networks” (arXiv:1308.0850), dove introduce una forma di soft attention per generazione di handwriting. La rete impara a focalizzarsi su porzioni di testo input mentre genera tracce di scrittura: è uno dei primi esempi documentati di un meccanismo continuo, differenziabile, di selezione pesata su input variabili. Nello stesso periodo, Volodymyr Mnih, Nicolas Heess, Alex Graves e Koray Kavukcuoglu pubblicano “Recurrent Models of Visual Attention” (NIPS 2014), che applica attention a task di visione computazionale. Qui pero l’attention è hard e la selezione è addestrata con REINFORCE, non differenziabile end-to-end. La distinzione tra hard attention (campionamento discreto, RL) e soft attention (somma pesata, gradiente diretto) è importante: Bahdanau adotta la versione soft, che è quella che permettera la diffusione massiva del meccanismo.

Il paper di Bahdanau, Cho e Bengio appare su arXiv il 1 settembre 2014, praticamente nello stesso giorno in cui il paper di Sutskever appare su arXiv (10 settembre 2014). Le due idee — encoder-decoder end-to-end e attention sopra encoder-decoder — nascono in due gruppi diversi (Google Brain a Mountain View, MILA a Montreal con stage di Bahdanau a Brema), in modo indipendente, e si incrociano nelle settimane successive. Il paper Bahdanau et al. viene pubblicato a ICLR 2015 con il titolo finale “Neural Machine Translation by Jointly Learning to Align and Translate”. Verra citato decine di migliaia di volte nei dieci anni successivi.

Vale la pena un ritratto rapido degli autori. Dzmitry Bahdanau (informatico bielorusso, ~1990-) era allora dottorando al MILA, il Montreal Institute for Learning Algorithms, sotto Yoshua Bengio. Nello stage estivo del 2014 a Brema, sotto Schmidhuber, ha prime ispirazioni sull’idea di attention. Ottiene il PhD a Montreal nel 2017. Successivamente lavora a Element AI, poi ServiceNow Research, poi torna stabilmente a Mila come scientist. Kyunghyun Cho (informatico sudcoreano, 1981-) era postdoc al MILA dopo PhD ad Aalto, già co-autore del paper su GRU di tre mesi prima. Diventera professore alla New York University, poi anche affiliato a Genentech AI per applicazioni biomediche. Yoshua Bengio (informatico canadese, 1964-) è una delle figure fondanti del deep learning moderno, vincitore del Turing Award 2018 insieme a Geoffrey Hinton e Yann LeCun. Direttore del MILA dal 1993, formera generazioni di ricercatori del campo, e dopo il 2018 si esporra pubblicamente sulle questioni di safety dell’AI generale.

Tre nomi, tre generazioni, un laboratorio. Il MILA di Montreal nei primi anni 2010 era uno dei pochi posti al mondo dove la fede nelle reti neurali profonde non era mai venuta meno durante l’inverno post-2000, e il lavoro di Bengio sui language model neurali e sugli embedding (Bengio et al. 2003, “A Neural Probabilistic Language Model”) aveva costruito le basi su cui il neural MT del 2014 si appoggia. Bahdanau e Cho sono parte di una generazione che eredità quella tradizione e la porta ai task più difficili della NLP applicata.

L’intuizione

Angolo cognitivo: come traduciamo, nei limiti dell’analogia

C’e una scena familiare per chi ha tradotto un testo a mano. Hai davanti la frase sorgente, magari complessa: “L’accord sur la zone economique europeenne a ete signe en aout 1992”. Devi produrla in inglese. Non leggi tutto, memorizzi tutto, chiudi gli occhi e riproduci. Leggi e scrivi a oscillazioni: mentre stai per scrivere “agreement”, il tuo sguardo torna a “accord”; mentre stai per scrivere “european economic area”, lo sguardo si sposta su “zone economique europeenne”, e magari salta avanti per controllare se “economique” è aggettivo di “zone” o sostantivo proprio. Ad ogni parola che produci, una porzione diversa della sorgente torna in primo piano.

L’attention di Bahdanau, presa come metafora, fa esattamente questo: a ogni passo di generazione di una parola della target, calcola una distribuzione di pesi su tutte le posizioni della sorgente, e somma le rappresentazioni di quelle posizioni in modo proporzionale ai pesi. La parola corrente da generare condiziona dove il modello “guarda”.

Marcatura di classe necessaria: questa è analogia, non filiazione e non equivalenza. Il meccanismo di Bahdanau non e stato derivato da modelli psicologici dell’attenzione umana. La parola “attention” è suggestiva — e anzi, come vedremo, era stata controversa proprio per questa ragione, con alcuni nel team che preferivano “alignment” — ma la scelta del nome non implica che il meccanismo computazionale corrisponda al fenomeno cognitivo. La psicologia dell’attenzione (modelli di Broadbent, Treisman, spotlight, filtri) è un’altra storia, raccontata in attenzione-psicologia (in preparazione, Parte III). Il legame tra il nome attention nei transformer e il fenomeno psicologico viene discusso esplicitamente in ponte-attenzione-transformer (in preparazione, Parte III). Per ora, l’analogia serve solo come ponte didattico: non come affermazione storica o teorica.

Angolo architetturale: rimuovere il bottleneck

Il secondo angolo è direttamente architetturale. In seq2seq vanilla, l’encoder produce, dopo aver letto l’ultima parola della sorgente, un vettore di stato $h_T$ di dimensione fissa (alcune migliaia di numeri reali). Quel vettore è tutto ciò che il decoder riceve. Per ricostruire la traduzione, il decoder deve estrarre ogni informazione utile da quel singolo punto in spazio. Per frasi corte funziona; per frasi lunghe l’informazione che entra nel vettore è sovraccarica e diluita. Sutskever lo aggira con input reversal: avvicina almeno l’inizio della sorgente al primo token del decoder, mitigando il problema di gradient flow ma non risolvendo il problema strutturale.

Bahdanau cambia la geometria del problema. L’encoder produce non un solo vettore ma una sequenza di vettori, uno per ogni posizione della sorgente: $h_1, h_2, \ldots, h_T$ . Tutti sono memorizzati e accessibili al decoder. A ogni passo $t$ di generazione, il decoder calcola dei pesi $\alpha_{t,1}, \alpha_{t,2}, \ldots, \alpha_{t,T}$ — uno per ogni posizione sorgente — che sommano a uno (sono il risultato di una softmax). Il context vector che il decoder usa per generare la parola al passo $t$ è la combinazione lineare:

$c_t = \sum_{i=1}^{T} \alpha_{t,i} h_i$

Se $\alpha_{t,3}$ è grande e gli altri sono piccoli, $c_t$ è essenzialmente $h_3$ : il decoder sta “guardando” la terza parola sorgente. Se invece tre o quattro pesi sono uniformi, il context è una mescola. La distribuzione $\alpha_t$ varia a ogni passo: dipende dallo stato corrente del decoder $s_{t-1}$ e dagli stati encoder $h_i$ .

Il punto chiave: il context vector $c_t$ ha la stessa dimensione di un singolo $h_i$ , ma il suo contenuto cambia a ogni passo, ed è costruito guardando tutti gli $h_i$ in parallelo. Non c’e più un singolo vettore che porta il peso dell’intera sorgente. Il bottleneck è eliminato per costruzione.

Questa è la mossa centrale. Il resto del paper — l’encoder bidirezionale, il modello di scoring, il particolare modo di combinare $c_t$ con lo stato del decoder — sono dettagli implementativi che varieranno nelle versioni successive (Luong 2015 cambia lo scoring, GNMT cambia la profondità, transformer cambia tutto tranne la mossa centrale del context dinamico via pesi softmax).

Bottleneck illustration. Top panel: vanilla seq2seq. Source tokens “the cat sat on the mat” feed into encoder LSTM, all encoder hidden states drawn faintly, only the final state h_T highlighted, drawn as a single thick vertical bar. From h_T, an arrow into a decoder LSTM that emits target tokens. Caption “all source meaning compressed in one fixed vector”. Bottom panel: Bahdanau attention. Same source tokens feed into encoder, but now ALL hidden states h_1, h_2, …, h_T are drawn as separate boxes, all kept available. The decoder, generating each target token, draws weighted arrows back to each h_i with thickness proportional to alpha weights, sums into a context vector c_t that varies per step. Caption “decoder queries all source positions, builds context per step”. Clean editorial style, English labels

La meccanica

Encoder bidirezionale

Il paper Bahdanau et al. usa un encoder bidirezionale invece di un encoder unidirezionale come in seq2seq vanilla. Il motivo è diretto: per ogni posizione $i$ della sorgente, vogliamo che $h_i$ catturi non solo ciò che precede $x_i$ (la parola corrente) ma anche ciò che segue. In una RNN unidirezionale, $h_i$ vede $x_1, x_2, \ldots, x_i$ ma non vede $x_{i+1}, \ldots, x_T$ . Per i pesi di attention, vogliamo che ogni $h_i$ sia una rappresentazione “locale” della posizione $i$ nel contesto di tutta la frase, non solo della sua meta sinistra.

L’encoder bidirezionale processa la sorgente con due RNN distinte: una forward che legge da sinistra a destra producendo stati $\overrightarrow{h}_1, \overrightarrow{h}_2, \ldots, \overrightarrow{h}_T$ , e una backward che legge da destra a sinistra producendo stati $\overleftarrow{h}_1, \overleftarrow{h}_2, \ldots, \overleftarrow{h}_T$ . L’hidden state finale alla posizione $i$ è la concatenazione:

$h_i = [\overrightarrow{h}_i ; \overleftarrow{h}_i]$

In parole povere, $h_i$ è un vettore “ampio” che contiene la sintesi del contesto sinistro fino a $x_i$ e la sintesi del contesto destro a partire da $x_i$ . Se la dimensione di ciascuna RNN è 1000, $h_i$ ha dimensione 2000. Ogni posizione della sorgente è descritta da un vettore che vede tutto il contesto, sebbene mediato dalla dinamica ricorrente.

Il paper usa GRU per le due RNN (l’unità ricorrente introdotta da Cho et al. EMNLP 2014, più semplice della LSTM ma con simile capacità di catturare dipendenze lunghe). Le dimensioni effettive nel paper: 1000 unità per direzione, dunque $h_i$ in $\mathbb{R}^{2000}$ . Lunghezza tipica della sorgente: tra 10 e 60 parole, ma il modello scala fino a frasi più lunghe.

Lo scoring: additive attention

Il decoder mantiene il proprio stato $s_{t-1}$ ricorrente. Al passo $t$ , per generare la prossima parola target $y_t$ , il decoder deve calcolare il context vector $c_t$ che useremo come input ausiliario. Il primo passo è calcolare un score di allineamento tra $s_{t-1}$ e ciascun $h_i$ , che misura quanto la posizione sorgente $i$ è rilevante per generare la parola target $t$ :

$e_{t,i} = a(s_{t-1}, h_i)$

La funzione $a$ è una piccola rete neurale, una MLP a un layer nascosto. Bahdanau la sceglie nella forma:

$a(s, h) = v_a^\top \tanh(W_s s + W_h h)$

Dove $W_s$ e $W_h$ sono matrici dei pesi (dimensioni: $d \times \dim(s)$ e $d \times \dim(h)$ , dove $d$ è una dimensione interna scelta come iperparametro, tipicamente 1000), $v_a$ è un vettore di pesi della dimensione $d$ , $\tanh$ è la non-linearita applicata elemento per elemento, e il prodotto $v_a^\top$ riduce il vettore intermedio a uno scalare. In parole povere, lo score $e_{t,i}$ è un singolo numero reale che dice quanto $s_{t-1}$ e $h_i$ “vanno d’accordo”.

Questa forma di scoring viene chiamata additive attention o Bahdanau attention per distinguerla dalla versione multiplicative (o dot-product) introdotta da Luong et al. 2015, che calcola lo score come $a(s, h) = s^\top h$ (o variazioni con una matrice intermedia: $s^\top W h$ ). Le due formulazioni sono funzionalmente equivalenti per molti task pratici, ma la dot-product è computazionalmente più efficiente sui hardware moderni perché è una semplice moltiplicazione di matrici, mentre l’additive richiede applicazione di una non-linearita per ogni coppia $(s, h)$ . Nella forma scaled dot-product, sara la versione adottata dal transformer del 2017.

Softmax sui pesi

Una volta calcolati gli score $e_{t,i}$ per tutte le posizioni $i = 1, \ldots, T$ , il modello li trasforma in una distribuzione di probabilita applicando la softmax:

$\alpha_{t,i} = \frac{\exp(e_{t,i})}{\sum_{j=1}^{T} \exp(e_{t,j})}$

I pesi $\alpha_{t,i}$ sono numeri positivi che sommano a uno. La softmax garantisce che il context vector sara una combinazione convessa degli stati encoder, e che il più grande $\alpha_{t,i}$ corrisponda al più grande $e_{t,i}$ (la softmax preserva l’ordine). In parole povere, le posizioni sorgenti con score più alto ricevono peso maggiore; le posizioni a score basso quasi non contribuiscono.

È utile notare che la softmax è differenziabile rispetto agli $e_{t,i}$ , e quindi rispetto ai pesi $W_s, W_h, v_a$ del modello di scoring. Tutto il meccanismo di attention si addestra end-to-end via gradient descent, senza alcuna supervisione esplicita sugli allineamenti. Questo è il punto chiave che separa l’attention soft di Bahdanau dall’attention hard di Mnih et al. 2014: la prima ammette gradiente diretto, la seconda richiede REINFORCE o trick equivalenti perché la selezione è discreta.

Context vector e aggiornamento del decoder

Una volta calcolati i pesi $\alpha_{t,i}$ , il context vector è la somma pesata degli stati encoder:

$c_t = \sum_{i=1}^{T} \alpha_{t,i} h_i$

Il vettore $c_t$ vive nello stesso spazio degli $h_i$ (dimensione 2000 nel paper), ed è una rappresentazione contestuale dinamica della sorgente filtrata attraverso la prospettiva del decoder al passo $t$ . Lo stato del decoder viene poi aggiornato usando $c_t$ come input addizionale:

$s_t = f(s_{t-1}, y_{t-1}, c_t)$

Dove $f$ è una cella ricorrente (GRU nel paper), $y_{t-1}$ è l’embedding della parola target generata al passo precedente, e $s_t$ è il nuovo stato del decoder. La generazione del prossimo token target e’:

$P(y_t | y_{<t}, x) = g(y_{t-1}, s_t, c_t)$

Dove $g$ è una funzione che combina $y_{t-1}$ , $s_t$ e $c_t$ tipicamente attraverso una piccola MLP con softmax finale sul vocabolario target. In parole povere, la distribuzione di probabilita sulla prossima parola dipende dalla parola precedente, dallo stato del decoder, e dal context appena calcolato dall’attention.

Da soft a operazione differenziabile

Vale la pena fermarsi un attimo sulla scelta progettuale che rende tutto il meccanismo addestrabile via backpropagation senza tecniche speciali. Il risultato finale è una catena di operazioni differenziabili rispetto a tutti i pesi del modello: la MLP di scoring è differenziabile, la softmax è differenziabile, la somma pesata è differenziabile, l’aggiornamento ricorrente del decoder è differenziabile (come ogni RNN). Quindi il gradiente della loss di traduzione (cross-entropy sulle parole target) può essere propagato indietro attraverso il decoder, attraverso l’attention, attraverso la softmax, fino ai pesi $W_s, W_h, v_a$ del modello di scoring, e da li indietro fino agli stati encoder e ai pesi dell’encoder bidirezionale.

Niente di quanto descritto richiede algoritmi RL, gradient estimator stocastici, o trucchi di reparametrizzazione. È tutto gradient descent standard, applicato a una rete che ha leggermente più strati e una topologia più complessa rispetto al seq2seq vanilla. Questa proprietà — addestrabilità end-to-end via backprop — è il motivo principale per cui la soft attention di Bahdanau si diffonde rapidamente, mentre la hard attention di Mnih et al. resta in nicchia. Un meccanismo che si addestra “come una rete normale” abbassa la barriera all’adozione: chiunque sappia addestrare reti neurali con un framework standard può aggiungere attention al proprio modello senza imparare nuovo machinery.

È anche un esempio di un principio progettuale ricorrente in deep learning: quando puoi rendere un’operazione discreta in una sua versione continua (campionamento -> somma pesata; argmax -> softmax; selezione -> attenzione), fai così. Lo paghi in qualche modo (calcoli “su tutto” anche dove pesi un peso è zero), ma in cambio ottieni gradienti puliti e training stabile. Questo principio reggera anche scelte successive (il Gumbel-softmax per categoriali differenziabili, il straight-through estimator per quantizzazione, le architetture con soft routing nei MoE).

Allineamento implicito: cosa rivelano le matrici di attention

Una conseguenza non banale del meccanismo: se per ogni passo $t$ del decoder registriamo i pesi $\alpha_{t,i}$ per ogni posizione $i$ sorgente, otteniamo una matrice di attention di dimensione $T' \times T$ (lunghezza target per lunghezza sorgente). Visualizzata come heatmap, questa matrice rivela quale parola sorgente il modello “guarda” mentre genera ogni parola target.

Bahdanau et al. presentano nel paper alcune matrici di attention catturate dal modello addestrato, e mostrano che corrispondono in modo sorprendente agli allineamenti che SMT calcolava esplicitamente. Per coppie inglese-francese, parole con traduzione diretta hanno picchi di attention diagonali. Per coppie con riordinamento sintattico (es. aggettivo-nome in inglese diventa nome-aggettivo in francese), la matrice mostra incroci espliciti. L’esempio classico riportato nel paper: la traduzione di “European Economic Area” verso “zone economique europeenne” mostra un pattern non-monotonico, con il modello che “guarda” parole sorgente in ordine diverso da quello in cui le scrive nella target.

Il punto storico: questi allineamenti non sono mai imposti durante il training. Il modello è addestrato unicamente a massimizzare la log-likelihood della frase target. Eppure, come effetto collaterale, scopre da solo i pattern di allineamento che decadi di linguistica statistica avevano formalizzato esplicitamente (modelli IBM 1-5, allineamenti HMM, ecc.). È un esempio paradigmatico di emergenza nel deep learning: una struttura nota emerge come sottoprodotto di un’ottimizzazione su un task più generale.

Numeri WMT’14 English-French

Il paper riporta risultati su WMT’14 English-French, lo stesso benchmark di Sutskever. Il modello è addestrato su un sottoinsieme di circa 348 milioni di parole francesi, con vocabolario di 30000 parole sorgente e 30000 parole target (subword non ancora introdotto, parole fuori vocabolario sostituite da UNK). Dimensioni: encoder bidirezionale GRU con 1000 unità per direzione, decoder GRU con 1000 unità, dimensione interna dello scoring $d = 1000$ , embedding di dimensione 620.

I numeri principali del paper:

RNNencdec-30 (Cho et al. seq2seq vanilla, addestrato su frasi di lunghezza fino a 30 parole): BLEU 13.93.
RNNsearch-30 (modello con attention, stessa lunghezza massima): BLEU 21.50.
RNNencdec-50 (vanilla, frasi fino a 50 parole): BLEU 17.82.
RNNsearch-50 (attention, frasi fino a 50 parole): BLEU 26.75.

I numeri di Bahdanau sono inferiori a quelli di Sutskever (34.81) per ragioni che riguardano la scala (vocabolario, profondità, ensemble): Sutskever usava un vocabolario molto più grande, 4 layer LSTM, ensemble di 5 modelli. Il paper di Bahdanau è un proof-of-concept architetturale, non un’ottimizzazione di sistema. Il punto del paper non è il numero massimo di BLEU raggiunto, ma il gap interno tra il modello con attention e il modello senza, a parita di tutto il resto, e l’andamento di quel gap in funzione della lunghezza della frase.

Il dato che fa storia non è tanto il singolo BLEU, ma la curva. Il paper riporta una figura (figura 2 dell’articolo) che mostra BLEU in funzione della lunghezza della frase sorgente, separatamente per RNNencdec e RNNsearch. RNNencdec degrada visibilmente: passa da BLEU intorno a 25 per frasi sotto le 20 parole, a BLEU intorno a 5 per frasi sopra le 50 parole. RNNsearch resta quasi piatto: BLEU intorno a 25-27 per tutte le lunghezze fino a 60+ parole. Il gap aumenta drammaticamente con la lunghezza, e questo è il segnale visivo che il bottleneck strutturale di seq2seq vanilla è stato eliminato.

Esempi

Esempio operativo a scala ridotta: tradurre “I love cats”

Per fissare la meccanica, immaginiamo una versione miniaturizzata. Sorgente inglese: “I love cats” (3 token). Target italiano desiderato: “Adoro i gatti” (3 token). L’encoder bidirezionale produce tre stati $h_1, h_2, h_3$ , uno per ciascuna parola sorgente. Per semplicita, immaginiamo che ogni $h_i$ sia un vettore di 4 numeri reali; il decoder produce stati $s_t$ della stessa dimensione.

Il decoder parte con lo stato iniziale $s_0$ (inizializzato da una proiezione lineare di $\overleftarrow{h}_1$ ) e un token speciale di start. Calcola gli score iniziali $e_{1,1}, e_{1,2}, e_{1,3}$ tra $s_0$ e $h_1, h_2, h_3$ . Supponiamo che lo scoring produca rispettivamente -1.2, 2.5, 0.3. Applicando softmax:

$\alpha_{1,1} = \exp(-1.2) / Z \approx 0.024$
$\alpha_{1,2} = \exp(2.5) / Z \approx 0.926$
$\alpha_{1,3} = \exp(0.3) / Z \approx 0.050$

Dove $Z$ è la somma degli esponenziali. Il context vector $c_1 \approx 0.926 \cdot h_2$ , dominato da “love”. Il decoder, condizionato su $c_1$ , produce alta probabilita per “Adoro” (la traduzione naturale di “love”). Al passo successivo, lo stato $s_1$ riflette il fatto che “Adoro” è stato generato; il decoder calcola nuovi score, supponiamo concentrati su $h_3$ (“cats”), genera “i” (articolo determinativo) con alta probabilita. Al terzo passo, l’attention torna su $h_3$ per generare “gatti”.

La matrice di attention finale è una 3x3 con concentrazioni:

              I    love   cats
   Adoro    0.02  0.93   0.05
   i        0.10  0.20   0.70
   gatti    0.05  0.10   0.85

L’interpretazione: “Adoro” allinea con “love”, “i” e “gatti” allineano entrambe con “cats” (perché in inglese il sostantivo plurale “cats” porta sia il significato lessicale che il marcatore di pluralità che in italiano si esprime sia nell’articolo “i” che nel sostantivo “gatti”). Questo allineamento “uno-a-molti” emerge dal training. Nessuno l’ha mai indicato esplicitamente: il modello lo scopre.

Pseudocodice del decoder step

Per chi vuole vedere il flusso completo di una singola iterazione di decoder con attention, ecco uno pseudocodice essenziale:

# Encoder ha già prodotto encoder_states: lista di T vettori h_i di dim 2000
# decoder_state s_prev di dim 1000
# embedding y_prev della parola target precedente

def attention_step(s_prev, encoder_states, y_prev,
                   W_s, W_h, v_a, W_decoder, W_output):
    # 1. Calcola score per ogni posizione sorgente
    scores = []
    for h_i in encoder_states:
        u = tanh(matmul(W_s, s_prev) + matmul(W_h, h_i))
        e_i = dot(v_a, u)            # scalare
        scores.append(e_i)

    # 2. Softmax per ottenere pesi alpha
    alphas = softmax(scores)         # lista di T pesi normalizzati

    # 3. Context vector come somma pesata
    c = zeros_like(encoder_states[0])
    for i, h_i in enumerate(encoder_states):
        c = c + alphas[i] * h_i

    # 4. Aggiorna stato decoder con (s_prev, y_prev, c)
    s_new = gru_step(s_prev, concat(y_prev, c), W_decoder)

    # 5. Distribuzione sulla prossima parola target
    logits = matmul(W_output, concat(s_new, y_prev, c))
    probs = softmax(logits)

    return probs, s_new, alphas

Note. Il loop sulle posizioni sorgenti per il calcolo degli score è didattico: nelle implementazioni efficienti, $W_h h_i$ viene precomputato una volta sola per tutta la sorgente (non dipende da $s_{t-1}$ ), e gli score vengono calcolati come operazioni su matrici. La dimensione del calcolo per un passo del decoder cresce lineare in $T$ (la lunghezza della sorgente): per ogni token target, devi fare un’operazione su tutti i $T$ token sorgenti. Questo è il primo accenno del costo $O(n \cdot m)$ dell’attention, che diventera $O(n^2)$ nel transformer (dove sorgente e target coincidono nella self-attention).

Il vettore alphas ritornato dalla funzione è la “riga $t$ ” della matrice di attention: lo si può loggare per ispezione, e visualizzarlo come distribuzione è la base per le heatmap di interpretabilità.

Esempio di matrice attention reale

Il paper riporta diverse matrici reali. Una che vale la pena raccontare è la traduzione “The agreement on the European Economic Area was signed in August 1992 .” verso il francese “L’ accord sur la zone economique europeenne a ete signe en aout 1992 .”. La matrice di attention mostra:

Pattern diagonali per parole con corrispondenza monotonica: “agreement” -> “accord”, “on” -> “sur”, “August” -> “aout”, “1992” -> “1992”.
Pattern incrociati (non-monotonici) per “European Economic Area” -> “zone economique europeenne”: il sostantivo “Area” sorgente appare prima nella sorgente, ma viene tradotto come “zone” che appare prima nella target. Il modello mostra un’attivazione su “Area” durante la generazione di “zone”, e poi torna indietro a “Economic” per generare “economique” e a “European” per generare “europeenne”. L’attention “incrocia” graficamente, formando una struttura a X visibile nella heatmap.
Pattern diffusi (uno-a-molti o molti-a-uno) per articoli, preposizioni, ausiliari: “was signed” -> “a ete signe” coinvolge attention spalmata su entrambe le parole inglesi.

Questo esempio fa storia perché è la prima volta che si vede un modello neurale produrre, come effetto collaterale del training, qualcosa che ricorda un allineamento linguistico. Per la comunità di NLP statistica, il messaggio era duplice: da un lato, il modello “non programmava” gli allineamenti ma li scopriva (un punto di orgoglio per il deep learning); dall’altro, i pattern emersi non erano alieni — assomigliavano a quelli che SMT calcolava esplicitamente, suggerendo che certi fenomeni linguistici sono robusti rispetto all’architettura di base che li scopre.

Esempio numerico passo-passo dello scoring

Per fissare ulteriormente la meccanica, ecco un esempio numerico ridotto. Supponiamo dimensioni piccole: $h_i \in \mathbb{R}^2$ per ogni posizione sorgente, $s_{t-1} \in \mathbb{R}^2$ , dimensione interna dello scoring $d = 2$ . Tre posizioni sorgente con stati:

$h_1 = [1.0, 0.0]$ (rappresenta “I”)
$h_2 = [0.0, 1.0]$ (rappresenta “love”)
$h_3 = [0.5, 0.5]$ (rappresenta “cats”)

Stato decoder corrente: $s_{t-1} = [0.1, 0.9]$ (il decoder sta per generare una parola legata a “love”). Pesi del modello (esempio): $W_s = I$ (matrice identità 2x2), $W_h = I$ , $v_a = [1, 1]$ .

Calcoliamo gli score:

Per $i = 1$ : $W_s s + W_h h_1 = [0.1, 0.9] + [1.0, 0.0] = [1.1, 0.9]$ . $\tanh = [0.80, 0.72]$ . $e_{t,1} = v_a^\top \tanh = 0.80 + 0.72 = 1.52$ .
Per $i = 2$ : $W_s s + W_h h_2 = [0.1, 1.9]$ . $\tanh = [0.10, 0.96]$ . $e_{t,2} = 0.10 + 0.96 = 1.06$ .
Per $i = 3$ : $W_s s + W_h h_3 = [0.6, 1.4]$ . $\tanh = [0.54, 0.89]$ . $e_{t,3} = 1.43$ .

Softmax sui tre score $[1.52, 1.06, 1.43]$ :

$\exp$ normalizzato: pesi $\alpha_t \approx [0.40, 0.25, 0.35]$ .

Context vector: $c_t = 0.40 \cdot h_1 + 0.25 \cdot h_2 + 0.35 \cdot h_3 = [0.40 + 0 + 0.175, 0 + 0.25 + 0.175] = [0.575, 0.425]$ .

In questo esempio i pesi del modello sono inizializzati senza addestramento, quindi la distribuzione di attention non è molto concentrata. Dopo il training su dodici milioni di coppie, i pesi $W_s, W_h, v_a$ si calibrano in modo che, per stati $s$ che codificano “sto per generare la traduzione di love”, lo score con $h_2$ (“love”) diventi molto più alto degli altri, e la softmax produca un peso vicino a 0.9-0.95 su $h_2$ e quasi zero sugli altri. È l’addestramento che rende l’attention “intelligente”: senza training, la softmax produrrebbe distribuzioni quasi uniformi.

Variante: attention come puntatore

Una variazione che merita una nota è l’uso dei pesi $\alpha$ come puntatore invece che come moltiplicatori di stati. In Pointer Networks (Vinyals, Fortunato, Jaitly 2015), il decoder restituisce direttamente l’indice $i$ della posizione sorgente con $\alpha_{t,i}$ massimo, invece di generare un token da un vocabolario fisso. Questo è utile per task come l’ordinamento di sequenze, la copia di parti dell’input, la combinatorial optimization, dove l’output naturale è “punta a queste posizioni dell’input in quest’ordine”.

È un esempio di come l’idea base di Bahdanau — calcolare pesi softmax su stati encoder — abbia generato derivazioni che vanno ben oltre il task originale di traduzione. Il meccanismo di attention si rivela una primitiva più generale di quanto il paper originale immaginasse.

Eredità oggi

[DATATO 2026-04]

Filiazione documentata: dalla Bahdanau attention al transformer

La linea di filiazione che parte dal paper Bahdanau-Cho-Bengio è una delle più nette nella storia recente del deep learning. I passi principali, in sequenza cronologica:

2014 settembre: Bahdanau, Cho, Bengio introducono la soft attention additiva sopra encoder-decoder ricorrente. Cross-attention dal decoder verso encoder. Allineamento implicito che emerge dal training.
2015 settembre: Minh-Thang Luong, Hieu Pham e Christopher Manning a Stanford pubblicano “Effective Approaches to Attention-based Neural Machine Translation” (EMNLP 2015, arXiv:1508.04025). Introducono varianti di scoring più efficienti: dot-product e general (con matrice intermedia). Distinguono global attention (su tutto l’encoder) e local attention (su una finestra ristretta intorno a una posizione predetta). Le formulazioni dot-product di Luong saranno il template diretto per il transformer.
2016 giugno: Jianpeng Cheng, Li Dong e Mirella Lapata pubblicano “Long Short-Term Memory-Networks for Machine Reading” (EMNLP 2016, arXiv:1601.06733). Introducono una forma di self-attention dentro la stessa sequenza: invece di attention solo dal decoder verso encoder, ogni posizione di una sequenza calcola attention sulle altre posizioni della stessa sequenza. È il primo passo verso l’architettura del transformer.
2017 giugno: Ashish Vaswani e sette co-autori a Google Brain pubblicano “Attention Is All You Need” (NIPS 2017, arXiv:1706.03762). Introducono il transformer: niente più ricorrenza, niente convoluzione, solo blocchi di attention. Multi-head attention (N teste in parallelo, ognuna con sue proiezioni Q, K, V), scaled dot-product attention, encoder e decoder costituiti da pile di blocchi attention + feed-forward, positional encoding per iniettare l’informazione di ordine. Il transformer eredità esplicitamente la mossa centrale di Bahdanau (context dinamico via softmax di score), ma generalizza tutto: self-attention dentro encoder, self-attention dentro decoder (causale), cross-attention tra decoder ed encoder.

Quattro paper, tre anni, una linea. Ogni transformer moderno discende da questa catena. BERT (Devlin et al. 2018) usa la pila encoder. GPT (Radford et al. 2018-2019) usa la pila decoder. T5 (Raffel et al. 2020) usa la struttura encoder-decoder completa. Ogni LLM in produzione nel 2026 — Claude, GPT-4, Gemini, Llama, Mistral, DeepSeek — eredità il meccanismo formalizzato per la prima volta nel paper Bahdanau et al.

Una distinzione importante: attention non è “transformer veloce”

Una tentazione comune è raccontare il transformer come “una versione efficiente di Bahdanau”. È un errore di classe da evitare. Marcatura: la relazione tra Bahdanau attention e transformer è filiazione concettuale, non equivalenza.

Le differenze sostanziali:

Bahdanau usa attention solo come componente sopra una struttura ricorrente: l’encoder e il decoder restano RNN bidirezionale e RNN unidirezionale. La sequenzialità temporale non è eliminata, e la rete deve ancora processare token per token nel forward pass.
Transformer elimina completamente la ricorrenza: encoder e decoder sono pile di blocchi attention puri, senza dipendenza temporale interna. Il forward pass dell’encoder è completamente parallelizzabile sulla dimensione temporale (tutti i token vengono processati insieme via matrici).
Bahdanau usa solo cross-attention (dal decoder verso encoder): ogni token sorgente non ha modo di “vedere” altri token sorgenti se non attraverso la dinamica ricorrente dell’encoder bidirezionale.
Transformer aggiunge self-attention (ogni token vede tutti gli altri token nella stessa sequenza, sia nell’encoder che nel decoder): ogni layer di self-attention permette comunicazione diretta tra qualunque coppia di posizioni, indipendentemente dalla loro distanza temporale.

Il transformer non è un’ottimizzazione di Bahdanau: è un cambio di paradigma che mantiene la primitiva centrale (context dinamico via softmax) ma cambia tutto il resto dell’architettura. Confondere i due livelli — primitiva e architettura — porta a raccontare la storia in modo sbagliato. Il transformer è una sintesi che aggrega Bahdanau (attention come primitiva), Cheng (self-attention come pattern), Luong (dot-product come scoring efficiente), e una serie di scelte indipendenti (multi-head, positional encoding, layer normalization in posizioni precise). Ognuna di queste mosse ha la sua storia.

Attention oltre NLP

Il meccanismo introdotto da Bahdanau, una volta formalizzato, si rivela talmente generale da migrare fuori dal task linguistico in cui era nato. Alcune diffusioni notevoli:

Vision Transformer (Dosovitskiy et al. 2020): un’immagine viene divisa in patch (16x16 pixel ciascuna), ogni patch viene linearmente proiettata in un vettore, e poi una pila di blocchi self-attention puro la processa come fosse una sequenza di token. ViT batte le CNN su molti benchmark di image classification, mostrando che attention pura può competere con convoluzione anche nella visione.
Graph Attention Networks (Velickovic et al. 2018): attention applicata a nodi di un grafo, con i pesi $\alpha_{ij}$ che rappresentano l’importanza del nodo $j$ per il nodo $i$ . Permette reti neurali su grafi che non richiedono normalizzazione fissa della matrice di adiacenza.
Decision Transformer (Chen et al. 2021): un transformer applicato a sequenze (stato, azione, ricompensa) per fare reinforcement learning come sequence modeling.

In tutti questi casi, la mossa centrale è la stessa di Bahdanau: dato un punto di interesse (uno stato del decoder, una patch dell’immagine, un nodo del grafo, un timestep di una traiettoria), calcola pesi softmax su tutti gli altri punti, somma in maniera pesata, ottieni una rappresentazione contestuale dinamica.

Il limite quadratico e i tentativi di mitigarlo

C’e un costo computazionale dell’attention che era già presente in Bahdanau ed è diventato critico nel transformer. Per una sorgente di lunghezza $T$ e una target di lunghezza $T'$ , il calcolo di tutti i pesi $\alpha_{t,i}$ richiede $T \cdot T'$ score. Per Bahdanau, dove sorgente e target sono separate, il costo è lineare in entrambe (ma quadratico nel prodotto). Per il transformer, dove la self-attention si calcola dentro la stessa sequenza di lunghezza $n$ , il costo è $O(n^2)$ in tempo e memoria.

Per $n$ piccolo (sotto 1000) il costo è trascurabile. Per $n = 10000$ o più, diventa proibitivo. Il problema è centrale per applicazioni come long-context LLM, dove $n$ vuole arrivare a 100000, 1000000 o oltre. Negli anni 2020 si sono proposte molte soluzioni: FlashAttention (Dao et al. 2022) ottimizza l’IO con la memoria GPU mantenendo il costo asintotico ma migliorando enormemente la costante; sliding window attention (Beltagy et al. 2020 in Longformer, Mistral 2023) riduce ogni query a una finestra locale; ring attention (Liu et al. 2023) distribuisce il calcolo su più acceleratori. Approcci più radicali come state space models (Mamba, S4) cercano di sostituire del tutto l’attention per recuperare costo lineare.

Il limite quadratico è un’eredità che parte già dal paper Bahdanau, anche se nel 2014 non era visibile come problema serio (le frasi sorgente erano corte). Il fatto che il transformer ne abbia ereditato la struttura — con la self-attention che peggiora il costo dal lineare al quadratico nella stessa sequenza — ha generato un sotto-campo di ricerca interamente dedicato a renderlo gestibile. La discussione tecnica si trova in flash-attention (in preparazione) (in preparazione, Parte IX) e in long-context-tecniche (in preparazione) (in preparazione, Parte X).

Interpretabilita: attention come lente

Una delle proprietà più apprezzate dell’attention nei primi anni è la sua interpretabilità: i pesi $\alpha_{t,i}$ sono ispezionabili, visualizzabili, e raccontano qualcosa su cosa il modello “guarda”. Questa proprietà è diventata un cavallo di battaglia per giustificare l’attention rispetto ad altri meccanismi (RNN gating, ad esempio).

La storia successiva è stata più sfumata. Alcuni lavori (Jain & Wallace 2019, “Attention is not Explanation”) hanno mostrato che le mappe di attention non sempre corrispondono a spiegazioni causali del comportamento del modello: si possono produrre attention diverse che danno lo stesso output, e la mappa di attention non è necessariamente una spiegazione fedele del processo decisionale. Altri lavori (Wiegreffe & Pinter 2019, “Attention is not not Explanation”) hanno parzialmente difeso l’utilita interpretativa delle mappe. Il dibattito resta aperto.

Ciò che conta storicamente: la disponibilita di mappe di attention come oggetto ispezionabile ha aperto un filone di mechanistic interpretability che continua a essere centrale nello studio dei transformer. Il fatto che il modello esponga “dove guarda” come parte del proprio calcolo è una proprietà architetturale di Bahdanau, eredità poi dal transformer, e ancora oggi una delle finestre principali sul comportamento interno dei modelli. Vedi attention-heads-circuits (in preparazione) (in preparazione, Parte IX) per la versione moderna di questa indagine.

Dove si rompe

Ricorrenza ancora presente: lentezza in training

Il paper Bahdanau et al. risolve il bottleneck del vettore di stato fisso, ma mantiene la struttura ricorrente di seq2seq. L’encoder bidirezionale è due GRU, che processano la sorgente token per token; il decoder è una GRU unidirezionale, che processa la target token per token. La parallelizzazione del training è limitata: dentro la singola sequenza, ogni passo dipende dal precedente. Il training è costoso sui benchmark grandi.

Questo è il primo limite strutturale che il transformer del 2017 risolvera: rimuovere completamente la ricorrenza, sostituendola con self-attention permette di parallelizzare il forward pass dell’encoder su tutti i token contemporaneamente (è una serie di moltiplicazioni di matrici, non un loop temporale). Per sequenze di lunghezza $n$ e batch grandi, il transformer addestra molto più rapidamente del modello Bahdanau a parita di parametri.

Va detto che il paper Bahdanau era leggibile e implementabile relativamente facilmente nel 2014, mentre un transformer puro avrebbe richiesto strumenti software (frameworks come TensorFlow o PyTorch) che ancora non erano maturi. La ricorrenza era anche un compromesso pragmatico con l’infrastruttura disponibile.

Cross-attention solo, no self-attention dentro encoder

Il paper Bahdanau introduce attention solo nella forma cross: il decoder calcola attention sugli stati encoder. Dentro l’encoder, le posizioni sorgenti comunicano tra loro solo attraverso la dinamica ricorrente bidirezionale: ogni $h_i$ “vede” $h_{i-1}$ e $h_{i+1}$ direttamente, ma per “vedere” $h_j$ con $|i-j|$ grande deve passare attraverso la catena di stati intermedi. Il segnale può affievolirsi su grandi distanze, anche con LSTM/GRU.

L’introduzione di self-attention dentro l’encoder (Cheng et al. 2016, poi sistematizzata da Vaswani 2017) permette comunicazione diretta tra qualunque coppia di posizioni della sorgente, indipendentemente dalla loro distanza. Questo è uno dei vantaggi più evidenti del transformer: ogni token, in ogni layer, può “guardare” qualunque altro token in un singolo passo di attention.

Beam search ancora dominante

Il decoding nei modelli con attention del 2014-2017 resta dominato da beam search. Il paper Bahdanau usa beam search standard. Le tecniche di sampling stocastico (top-k, top-p, temperature scaling) che nel 2026 sono il default per LLM generativi diventeranno comuni più tardi, prevalentemente con i decoder-only LLM dove l’output non è “la traduzione corretta” ma “una continuazione plausibile”. Per la traduzione, beam search resta competitivo a lungo, perché c’e una nozione di “risposta corretta” che si vuole approssimare.

Mito: “l’attention di Bahdanau è l’attenzione umana”

Vale la pena scriverla esplicitamente: la corrispondenza tra il meccanismo di attention nei modelli neurali e il fenomeno psicologico chiamato attenzione è analogia parziale, non filiazione e non equivalenza. La parola “attention” è stata scelta per la sua suggestivita didattica, ma il meccanismo computazionale non è stato derivato da modelli psicologici e non corrisponde direttamente ai filtri attentivi descritti da Broadbent, Treisman, o altri psicologi cognitivi.

Le differenze sostanziali. L’attention computazionale produce una distribuzione completa su tutte le posizioni input (anche se la maggior parte dei pesi è piccola); l’attenzione umana è tipicamente più binaria, focalizzata su poche cose alla volta con un costo significativo per spostare il fuoco. L’attention computazionale è puramente bottom-up: i pesi sono calcolati interamente dallo stato corrente e dagli stati input, senza alcun controllo top-down esplicito; l’attenzione umana è una mescola di processi bottom-up (cattura attentiva) e top-down (controllo esecutivo). L’attention computazionale non ha costi metabolici: si possono calcolare moltissimi pesi senza alcun overhead biologico.

Trattare la metafora come più di una metafora porta a errori di lettura: pretendere che il modello “capisca” ciò che “guarda”, trasferire risultati di psicologia cognitiva direttamente al modello, o viceversa. Il meccanismo computazionale è utile per il task di apprendimento di mappature input-output; non è un modello del fenomeno psicologico. La discussione completa di questo punto è rimandata a ponte-attenzione-transformer (in preparazione, Parte III).

Il nome “attention” era controverso

Una nota di colore storico. Bahdanau racconta in interviste successive che il nome “attention” non era ovvio nel 2014. Alcuni del team (incluso lui stesso, in alcune fasi) preferivano “alignment”, che era il termine tecnico ereditato da SMT per indicare i pesi che mettevano in corrispondenza parole sorgente e target. “Attention” sembrava troppo carico di connotazioni cognitive. Bengio sostenne il termine “attention” come più evocativo ed efficace per la comunicazione del lavoro. Vinse questa scelta. Oggi “attention” è il termine tecnico standard, e “alignment” è relegato al sotto-discorso storico di SMT.

Il punto interessante: la scelta del nome ha avuto effetti sulla ricezione. “Attention is all you need” (Vaswani 2017) è un titolo memorabile che ha amplificato l’identità culturale del meccanismo. Se il paper si fosse chiamato “Alignment is all you need”, la storia successiva avrebbe avuto un sapore diverso. La scelta di vocabolario nel 2014 ha implicazioni che si propagano per anni.

Vocabolario chiuso: stesso problema di seq2seq

Il modello Bahdanau usa un vocabolario chiuso (30000 parole sorgente, 30000 target nel paper, con UNK per fuori-vocabolario). Stesso limite di seq2seq vanilla, e stessa risoluzione successiva: subword tokenization (BPE 2016, SentencePiece 2018) elimina il problema strutturalmente. Vedi seq2seq-2014 per la discussione.

La curva BLEU non è lineare nelle prestazioni umane

Vale come sempre il caveat sui benchmark di traduzione. Il fatto che RNNsearch resti piatto a BLEU 25-27 per frasi lunghe non significa “qualità umana”: significa che la metrica BLEU non degrada drasticamente. Il modello continua a produrre traduzioni leggibili, con errori più subtle (sintassi infelice, scelte lessicali sbagliate, sfumature perse) che BLEU misura imperfettamente. La rivendicazione di “qualità human-parity” arrivera anni dopo, con caveat metodologici forti, su coppie di lingue specifiche e domini ristretti. Vale la pena, leggendo i numeri di Bahdanau, ricordare che misurano un’eliminazione di un fallimento catastrofico, non un raggiungimento di qualità perfetta.

Sensibilita all’inizializzazione e instabilita di training

Un punto operativo che chi reimplementa il paper scopre rapidamente: l’addestramento di Bahdanau attention dal 2014 non era robusto come lo sono i transformer odierni. Inizializzazioni sbagliate dei pesi $W_s, W_h, v_a$ producevano modelli che imparavano a ignorare l’attention (i pesi $\alpha_{t,i}$ restavano uniformi e il context vector diventava una semplice media degli stati encoder), oppure modelli che collassavano su una posizione fissa indipendentemente dal passo decoder. La diagnosi richiedeva di ispezionare le matrici di attention durante il training, non solo i numeri di loss.

L’introduzione di tecniche come layer normalization (Ba et al. 2016), gradient clipping sistematico, scheduled learning rate (warm-up + decay), e infine pre-norm vs post-norm nei transformer, ha progressivamente reso l’addestramento di reti basate su attention molto più robusto. Ma nel 2014-2015 ottenere un modello che funzionasse richiedeva esperienza. È un esempio di come molte architetture “semplici” sulla carta richiedano in realta significativa cura ingegneristica per funzionare a regime.

Coverage e ripetizioni

Lo stesso fenomeno di ripetizione e omissione che affligge seq2seq vanilla affligge anche Bahdanau, sebbene in misura minore. Il modello può “rimbalzare” tra due posizioni sorgenti generando ripetizioni della stessa parola target, o “saltare” intere clausole della sorgente perché la distribuzione di attention non visita mai certe posizioni. Tecniche di coverage (Tu et al. 2016, Wu et al. 2016 dentro GNMT) aggiungono un termine alla loss che penalizza l’attention concentrata troppe volte sulle stesse posizioni, o aggiungono un vettore di “coverage” che tiene traccia di quanto ogni posizione sorgente è stata già “coperta”. L’introduzione di coverage è un pezzo di engineering necessario per ottenere modelli production-grade da Bahdanau attention.

Modello di scoring fisso: una scelta limitata

Il paper Bahdanau usa un’unica forma di scoring (additive con MLP a un layer), e un’unica “testa” di attention. Negli anni successivi si scopre che entrambe le scelte sono limitanti. La forma additive è computazionalmente costosa rispetto al dot-product, e diversi tipi di relazione tra query e key richiedono modi diversi di pesare. La singola testa significa che a ogni passo decoder esiste una sola “lettura” della sorgente, una sola distribuzione di pesi $\alpha_t$ . Per generare la parola target $t$ , il modello deve compromesso: focalizzarsi su un aspetto o un altro della sorgente. Multi-head attention (transformer 2017) è la generalizzazione: $N$ teste in parallelo, ognuna con sue proiezioni e una sua softmax indipendente, permettono al modello di rappresentare $N$ relazioni diverse simultaneamente. Bahdanau ne aveva una sola; il transformer ne usa tipicamente 8, 12, 16 o più.

Questo limite del paper originale non è un difetto del 2014: è una semplicita coerente con la fase iniziale di scoperta del meccanismo. È utile pero notarlo, perché spiega una parte significativa del salto di prestazioni che il transformer realizzera nel 2017.

Hard vs soft: la scelta che ha fatto la storia

Il paper Bahdanau adotta soft attention (somma pesata, gradiente diretto) e non hard attention (campionamento discreto, REINFORCE). È una scelta tecnica con implicazioni profonde: la soft è addestrabile via backprop standard, la hard richiede tecniche di RL. Per molti task, la soft funziona benissimo. Per task dove l’output naturale è “punta a una posizione” (es. memoria esterna, copia), la hard ha vantaggi teorici. Negli anni 2015-2018 si esplora molto la hard attention (Xu et al. 2015 “Show, Attend and Tell”; differenziable hard attention via Gumbel-softmax). La pratica industriale, pero, ha favorito la soft per la sua trattabilità: è la versione che ha vinto la diffusione. La hard resta in nicchie specifiche.

Collegamenti

seq2seq-2014 — il capitolo immediato precedente. Bahdanau attention risolve il bottleneck strutturale del vettore di stato fisso che affligge seq2seq vanilla. I due paper escono praticamente in contemporanea, da gruppi diversi, e si combineranno presto in una sintesi.
reti-neurali-80-90 — le LSTM di Hochreiter-Schmidhuber 1997 e le GRU di Cho et al. 2014 sono i componenti ricorrenti su cui Bahdanau costruisce. La variante GRU bidirezionale dell’encoder è la scelta architetturale di base.
word2vec-2013 — gli embedding di parola usati come livello di input dell’encoder discendono dalla famiglia di tecniche di Mikolov et al. Sono un componente importante della rappresentazione iniziale dei token.
imagenet-alexnet-2012 — anno di partenza per il deep learning su task percettivi. Stesso messaggio metodologico: rimpiazzare ingegneria con apprendimento end-to-end su grandi dataset.
transformer-2017 (in preparazione) — il punto di arrivo della linea che parte qui. Il transformer eredità la primitiva centrale di Bahdanau (context dinamico via softmax) e generalizza tutto il resto: self-attention, multi-head, niente ricorrenza.
bert-gpt-2018-2019 (in preparazione) — la specializzazione del transformer in encoder-only (BERT) e decoder-only (GPT). Entrambi ereditano in ultima analisi il meccanismo di attention introdotto qui.
attention-intuizione (in preparazione, Parte IX) — la trattazione moderna di attention come componente di un LLM. Riprende la primitiva di Bahdanau e la spiega in chiave operativa per chi costruisce sistemi attuali.
qkv-da-zero (in preparazione, Parte IX) — la formalizzazione attuale di attention in termini di Query, Key, Value. La connessione con Bahdanau: lo score $a(s_{t-1}, h_i)$ corrisponde, in chiave moderna, al prodotto $Q \cdot K^\top$ con $Q$ derivato da $s_{t-1}$ e $K$ derivato da $h_i$ . Il context vector $c_t$ è la somma pesata dei $V$ derivati da $h_i$ .
multi-head (in preparazione, Parte IX) — la generalizzazione del transformer: $N$ teste di attention in parallelo, ognuna con sue proiezioni. Bahdanau aveva una sola “testa”.
flash-attention (in preparazione, Parte IX) — le ottimizzazioni moderne dell’attention per gestire sequenze lunghe. Affrontano il limite quadratico che Bahdanau già portava in se in forma latente.
ponte-attenzione-transformer (in preparazione, Parte III) — la discussione esplicita sul rapporto tra il termine “attention” nei modelli e il fenomeno psicologico dell’attenzione. Bahdanau scelse il nome consapevolmente, ma la corrispondenza è analogia parziale.
attenzione-psicologia (in preparazione, Parte III) — la trattazione del fenomeno psicologico dell’attenzione, indipendente dal meccanismo computazionale.
decoder-only-vs-enc-dec (in preparazione, Parte IX) — il confronto tra le due famiglie architetturali che ereditano da seq2seq + attention.

Vale anche un’ultima nota di lettura. Bahdanau attention non è solo un risultato tecnico, è uno spartiacque culturale per la NLP. Prima del 2014, la comunità di traduzione automatica era spaccata in due tribu poco comunicanti: linguistica statistica (allineamenti, phrase tables, decoder log-lineari) e reti neurali (encoder-decoder, embedding, end-to-end). Il paper di Bahdanau costruisce un ponte: usa il vocabolario delle reti neurali (encoder, decoder, gradient descent) ma riproduce, come effetto emergente, oggetti che la tribu statistica conosceva da anni (allineamenti tra parole). Il risultato è che entrambe le comunità potevano leggere il paper trovandoci qualcosa di familiare, e il dibattito che ne segue genera la sintesi che vinse il decennio. La storia tecnica del paper è importante; la storia sociologica del modo in cui il paper unifico due comunità è altrettanto.

Per andare oltre

Bahdanau D., Cho K., Bengio Y., “Neural Machine Translation by Jointly Learning to Align and Translate”, ICLR 2015, arXiv:1409.0473. Il paper originale. Quattordici pagine, leggibile in un paio d’ore. Conviene leggerlo subito dopo Sutskever et al. per capire come si chiude il bottleneck. La figura 3 con le matrici di attention è uno dei diagrammi più citati del decennio.
Luong M.-T., Pham H., Manning C.D., “Effective Approaches to Attention-based Neural Machine Translation”, EMNLP 2015, arXiv:1508.04025. La generalizzazione dello scoring (additivo, dot-product, general) e l’introduzione di global vs local attention. Da leggere come passaggio diretto verso la formulazione che il transformer ereditera.
Cho K., van Merrienboer B., Gulcehre C., Bahdanau D., Bougares F., Schwenk H., Bengio Y., “Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation”, EMNLP 2014, arXiv:1406.1078. Il paper precursore di tre mesi: GRU + encoder-decoder come componente di SMT. Il contesto immediato del lavoro Bahdanau.
Sutskever I., Vinyals O., Le Q.V., “Sequence to Sequence Learning with Neural Networks”, NIPS 2014, arXiv:1409.3215. Il paper compagno di Bahdanau. Encoder-decoder vanilla, senza attention. Da leggere insieme per capire il problema risolto.
Vaswani A. et al., “Attention Is All You Need”, NIPS 2017, arXiv:1706.03762. Il transformer. Da leggere come continuazione naturale: il punto di arrivo della linea che parte da Bahdanau.
Graves A., “Generating Sequences with Recurrent Neural Networks”, arXiv:1308.0850, 2013. Il prototipo storico di soft attention applicata a generazione di handwriting. Predecessore importante per inquadrare lo stato dell’arte pre-2014.
Mnih V., Heess N., Graves A., Kavukcuoglu K., “Recurrent Models of Visual Attention”, NIPS 2014. La versione hard di attention applicata a vision. Utile per capire la differenza tra hard e soft, e perché la soft di Bahdanau ha vinto la diffusione.
Wu Y. et al., “Google’s Neural Machine Translation System”, arXiv:1609.08144, 2016. Il paper di sistema di GNMT, l’evoluzione di Bahdanau a scala produttiva. Include coverage penalty, length normalization, deep stacks: l’engineering necessario per portare Bahdanau in produzione.
Cheng J., Dong L., Lapata M., “Long Short-Term Memory-Networks for Machine Reading”, EMNLP 2016, arXiv:1601.06733. Uno dei primi lavori su self-attention dentro la stessa sequenza. Passaggio chiave nella linea verso il transformer.
Bahdanau D., interviste e talk vari (es. talk al MILA, podcast con Lex Fridman). Per il colore aneddotico sulla genesi del paper, sullo stage a Brema, sul dibattito interno sul nome “attention”.
Xu K. et al., “Show, Attend and Tell: Neural Image Caption Generation with Visual Attention”, ICML 2015, arXiv:1502.03044. Trasferimento di attention al task di image captioning, con una variante hard addestrata via REINFORCE accanto alla soft. Utile per vedere come l’idea di Bahdanau migra immediatamente fuori dalla traduzione.
Vinyals O., Fortunato M., Jaitly N., “Pointer Networks”, NIPS 2015, arXiv:1506.03134. La variazione che usa attention come puntatore invece che come moltiplicatore. Ulteriore esempio di come la primitiva di Bahdanau si generalizza a famiglie di task diverse.
Jain S., Wallace B.C., “Attention is not Explanation”, NAACL 2019, arXiv:1902.10186. Lavoro critico che mette in discussione l’interpretabilità delle mappe di attention come spiegazione causale. Da leggere insieme alla replica di Wiegreffe-Pinter (“Attention is not not Explanation”, EMNLP 2019) per inquadrare il dibattito.