DQN su Atari (2013-2015): il deep reinforcement learning impara dai pixel

Quarantanove giochi Atari, una sola architettura, zero feature engineering. In ventinove di essi un singolo agente supera il punteggio di un tester umano professionista. Nel 2013 questo non era stato fatto, e per molti ricercatori non era nemmeno chiaro che si potesse fare.

Perché questo capitolo

Nel dicembre 2013, una piccola startup londinese chiamata DeepMind carica su arXiv un paper di nove pagine intitolato “Playing Atari with Deep Reinforcement Learning”. Gli autori sono sette: Volodymyr Mnih (informatico ucraino-canadese, ex postdoc al laboratorio di Geoffrey Hinton a Toronto, da pochi mesi a DeepMind), Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra e Martin Riedmiller (informatico tedesco, professore a Friburgo, autore di Neural Fitted Q-Iteration nel 2005). Il paper è una versione preliminare per il Deep Learning Workshop di NIPS, ed è breve e tecnico al punto da sembrare modesto. Sette giochi Atari testati, sei migliorati rispetto allo stato dell’arte precedente. Nessun comunicato stampa.

Quattordici mesi dopo, nel febbraio 2015, lo stesso gruppo (con coautori aggiuntivi e Demis Hassabis come ultimo nome) pubblica su Nature vol. 518 alle pagine 529-533 la versione estesa, intitolata “Human-level control through deep reinforcement learning”. Ora i giochi sono quarantanove, l’architettura è la stessa per tutti, e ventinove dei quarantanove vedono il sistema raggiungere o superare il livello di un tester umano professionista. La copertina di Nature è dedicata al lavoro. Da quel momento la sigla DQN (Deep Q-Network) entra nel vocabolario standard del machine learning.

Questo capitolo conta per tre ragioni distinte. La prima è di filiazione: DQN è il primo lavoro che mostra in modo plateale che reinforcement learning con reti neurali profonde può scalare a un set ampio e eterogeneo di task percettivi, partendo dai pixel grezzi e senza alcuna feature scritta a mano. Sale sulle spalle di td-gammon-1992 (RL+rete neurale su un singolo dominio), eredita le CNN profonde dalla rivoluzione imagenet-alexnet-2012, e prepara il terreno per AlphaGo del 2016. È un anello esplicito di una catena documentata, non un’analogia retrospettiva. La seconda ragione è industriale: nel gennaio 2014, dopo aver visto i risultati preliminari di DQN, Google acquista DeepMind per una cifra comunemente riportata intorno ai 500 milioni di dollari, mai confermata nei dettagli. Il paper DQN, ancora non pubblicato, è uno degli artefatti chiave nei dossier di valutazione. La terza è culturale: i video di un agente che impara da solo a giocare a Breakout, scoprendo dopo poche ore di addestramento la strategia del tunnel sul lato del muro, circolano nei media tecnologici nel 2014-2015 e diventano l’immagine pubblica più memorabile del deep reinforcement learning.

C’è una ragione narrativa in più. Il paradigma di DQN è esattamente l’opposto di quello che otto anni prima aveva portato Deep Blue alla vittoria contro Kasparov (vedi deep-blue-1997). Deep Blue era hardware custom, knowledge engineering scacchistico, ricerca minimax massiva: una vetrina del paradigma simbolico-search. DQN è una sola GPU consumer, nessuna conoscenza specifica del gioco, una rete che impara da pixel grezzi: una vetrina del paradigma learning-based puro. Lo stesso problema generale (“una macchina che gioca meglio di un umano”) riceve due risposte radicalmente diverse, a otto anni di distanza, e la seconda è incommensurabilmente più generale della prima.

Contesto

Il capitolo prende il filo da td-gammon-1992, che racconta il primo successo plateale di reinforcement learning combinato a reti neurali, e da imagenet-alexnet-2012, che racconta il momento spartiacque della computer vision. DQN sta letteralmente alla congiunzione di queste due linee: usa l’idea di TD-Gammon (apprendere una funzione valore via temporal difference su una rete neurale, addestrata da self-play o da esperienza diretta) e la combina con l’architettura di AlexNet (CNN profonde che imparano feature visive direttamente dai pixel).

Reinforcement learning come framework

Prima di entrare nei predecessori specifici di DQN, vale la pena fissare la cornice generale del reinforcement learning. Un agente RL interagisce con un ambiente in cicli discreti. A ogni passo $t$ , l’agente osserva uno stato $s_t \in \mathcal{S}$ , sceglie un’azione $a_t \in \mathcal{A}$ , riceve un reward $r_{t+1} \in \mathbb{R}$ e si trova in un nuovo stato $s_{t+1}$ . Il ciclo si ripete fino a terminazione (game over) o all’infinito. L’obiettivo dell’agente è massimizzare il return atteso, definito come somma scontata dei reward futuri: $G_t = \sum_{k=0}^{\infty} \gamma^k r_{t+k+1}$ , dove $\gamma \in [0, 1)$ è il fattore di sconto.

L’ambiente è formalizzato come un Markov Decision Process (MDP): una tupla $(\mathcal{S}, \mathcal{A}, P, R, \gamma)$ dove $P(s' | s, a)$ è la probabilità di transizione e $R(s, a)$ è la funzione reward. La proprietà di Markov dice che il futuro dipende dal solo stato corrente, non dalla storia. Per i giochi Atari la proprietà è (quasi) verificata se lo stato include abbastanza frame per catturare il movimento; per questo DQN impila quattro frame.

L’agente cerca una policy $\pi(a | s)$ , una distribuzione sulle azioni dato lo stato, che massimizzi il return atteso. RL si divide storicamente in tre famiglie: value-based (impara una funzione di valore e deriva la policy come greedy rispetto a essa: Q-learning, DQN), policy-based (impara direttamente $\pi$ via gradient ascent sul return: REINFORCE, policy gradient), e actor-critic (combina i due: A2C, A3C, PPO, SAC). DQN è il rappresentante archetipico della famiglia value-based applicata al deep learning. Vedi q-learning, policy-gradient, actor-critic (in preparazione, Parte V) per dettagli su ciascuna famiglia.

Q-learning di Watkins (1989)

L’algoritmo di base è Q-learning, formalizzato da Christopher Watkins (informatico britannico) nella sua tesi di dottorato a Cambridge nel 1989, “Learning from Delayed Rewards”, e poi nel paper Watkins-Dayan del 1992 su Machine Learning con la prova di convergenza nel caso tabulare. Watkins generalizza la temporal-difference learning di Sutton 1988 introducendo la nozione di action-value function $Q(s,a)$ : il valore atteso del reward totale futuro se nello stato $s$ si esegue l’azione $a$ e poi si segue la policy ottima. La regola di update è semplice e off-policy:

$Q(s, a) \leftarrow Q(s, a) + \alpha \big[r + \gamma \max_{a'} Q(s', a') - Q(s, a)\big]$

Dove $\alpha$ è il learning rate, $r$ è il reward immediato, $\gamma \in [0,1]$ è il fattore di sconto temporale, e $\max_{a'} Q(s', a')$ è la stima del valore del prossimo stato sotto la policy ottima. In parole povere: aggiorna la stima corrente verso il reward osservato più la migliore stima futura. Il termine “off-policy” significa che la regola converge al valore della policy ottima anche se le azioni eseguite sono scelte da una policy diversa (tipicamente epsilon-greedy per esplorare). Watkins-Dayan dimostrano che la procedura converge alla $Q^*$ ottima nel caso tabulare, sotto condizioni di esplorazione sufficiente e learning rate decrescente.

Il problema, fino a DQN, è che il caso tabulare richiede di mantenere una entry per ogni coppia $(s, a)$ . Per un gioco Atari, lo spazio degli stati osservabili (circa $84 \times 84 \times 256^4$ se si guardano quattro frame in scala di grigi) è astronomico: una tabella è impensabile. Serve function approximation: una rete che, dato lo stato, restituisca le stime $Q(s, a)$ per tutte le azioni.

Neural Fitted Q-Iteration (Riedmiller 2005)

Il primo tentativo serio di combinare Q-learning con reti neurali è NFQ, Neural Fitted Q-Iteration, di Martin Riedmiller (poi co-autore del paper DQN). Nel paper ECML 2005 “Neural Fitted Q Iteration — First Experiences with a Data Efficient Neural Reinforcement Learning Method”, Riedmiller mostra che si può addestrare una rete neurale come approssimatore di $Q$ usando una procedura batch: collezioni un grande insieme di transizioni $(s, a, r, s')$ , calcoli i target $r + \gamma \max Q(s', \cdot)$ usando la rete corrente, e fai una passata di gradient descent completa per allinearli. Ripeti.

NFQ funziona su problemi di controllo a bassa dimensionalità (carrello con pendolo invertito, stabilizzazione di sistemi dinamici semplici), ma non scala a input ad alta dimensionalità come pixel. L’intuizione che il batch training stabilizzi il bootstrap è però fondamentale: il problema del Q-learning naive con reti neurali — divergenza, oscillazioni, dimenticanza catastrofica — è noto da anni. Sutton e Barto la chiamano la deadly triad: function approximation, bootstrapping, off-policy data. Tre proprietà desiderabili che combinate possono far divergere l’apprendimento. Risolvere la deadly triad in pratica, su input visivo, è uno dei contributi tecnici di DQN.

Arcade Learning Environment (Bellemare et al. 2013)

C’è un terzo predecessore senza il quale DQN non sarebbe stato possibile: l’Arcade Learning Environment, ALE, presentato da Marc Bellemare, Yavar Naddaf, Joel Veness e Michael Bowling in un paper JAIR del 2013 (volume 47, pagine 253-279). ALE è un framework software che incapsula un emulatore Atari 2600 e fornisce un’interfaccia standard per agenti di reinforcement learning. Per ogni gioco, l’agente riceve a ogni passo l’immagine raster (160x210 pixel, palette a 128 colori), il punteggio, e un flag “game over”; può inviare in risposta una delle 18 possibili azioni del joystick (nove direzioni più nove con il bottone di fuoco premuto).

ALE fa per il reinforcement learning ciò che ImageNet aveva fatto per la computer vision: standardizza il benchmark. Prima di ALE, ogni gruppo testava su domini diversi e i risultati erano difficilmente comparabili. Dopo ALE, “performance media su N giochi Atari” diventa una metrica condivisa. Il paper di Bellemare et al. include risultati di baseline con tecniche RL classiche (SARSA, contingency-aware features, perceptron lineari sopra feature di pixel) per dare una scala. Quegli stessi numeri di baseline, due anni dopo, saranno il termine di confronto contro cui DQN brillera.

DeepMind: la startup che diventa laboratorio

DeepMind Technologies è fondata a Londra nel settembre 2010 da tre persone: Demis Hassabis (scienziato britannico nato nel 1976, ex prodigio degli scacchi, ex game designer alla Bullfrog di Peter Molyneux dove aveva contribuito a Theme Park nel 1994, fondatore di Elixir Studios nel 1998, con un PhD in neuroscienze cognitive ottenuto allo University College London nel 2009 con tesi sulla memoria episodica e l’ippocampo), Shane Legg (informatico neozelandese, dottorato in machine learning all’IDSIA con Marcus Hutter, autore di una tesi sulla definizione formale di intelligenza generale e in particolare sulla nozione di “universal intelligence” come somma pesata di performance su tutti gli ambienti computabili), e Mustafa Suleyman (imprenditore britannico, background in attivismo e telefono di crisi, poi cofondatore di Inflection AI nel 2022 e successivamente CEO di Microsoft AI). La missione dichiarata è “solve intelligence”, una formulazione tanto ambiziosa da risultare insolita per una startup del 2010.

La traiettoria personale di Hassabis è particolarmente rilevante per capire il taglio scientifico di DeepMind. Dopo aver chiuso Elixir Studios nel 2005 (lo studio aveva pubblicato Republic: The Revolution e Evil Genius con risultati commerciali modesti), Hassabis decide di tornare all’università per studiare il cervello, con l’obiettivo dichiarato di estrarre principi computazionali da applicare poi alla costruzione di sistemi intelligenti. Il suo PhD all’UCL è supervisionato da Eleanor Maguire e si concentra sull’amnesia ippocampale e la simulazione mentale di scene future. La pubblicazione su PNAS del 2007 (“Patients with hippocampal amnesia cannot imagine new experiences”) è uno dei lavori più citati nel campo. Questa formazione neuroscientifica, combinata con il background da game designer e da giocatore di livello competitivo, è il filtro attraverso cui DeepMind sceglie i propri problemi: giochi, prima di tutto, perché sono ambienti chiusi con metrica oggettiva e con paralleli neurobiologici diretti.

I primi anni sono di self-funding e investimenti angel (Peter Thiel, Founders Fund, Horizons Ventures di Li Ka-shing). Il gruppo iniziale è piccolo, una decina di ricercatori, divisi tra reinforcement learning, neuroscienza computazionale e teoria dell’apprendimento. La cultura interna è dichiaratamente accademica: i ricercatori pubblicano, presentano a conferenze, e l’agenda di ricerca è guidata da curiosità a lungo termine, non da prodotto. Quando Mnih si unisce a DeepMind nel 2013, dopo il postdoc a Toronto, porta con sé l’esperienza con le reti neurali profonde di Hinton e l’idea di applicarle a RL.

Nel gennaio 2014 Google annuncia l’acquisizione di DeepMind. Il prezzo non viene comunicato ufficialmente; le stime di stampa oscillano tra 400 e 650 milioni di dollari, con il valore mediano riportato intorno ai 500 milioni. Per il capitolo basta questo ordine di grandezza: il dato importante non è il numero preciso, ma il fatto che Google tratti DeepMind come asset strategico di prima fascia. L’acquisizione è la più grande mai effettuata da Google in Europa fino a quel momento, e include una clausola insolita: la creazione di un comitato etico interno indipendente sull’uso dell’AI dei laboratori DeepMind. Il comitato non ha mai prodotto report pubblici e la sua composizione effettiva non è mai stata divulgata in modo trasparente — un dettaglio che diventerà materia di critica negli anni successivi.

Per quanto riguarda DQN: il paper preliminare di dicembre 2013 era già pronto al momento dei colloqui di acquisizione, e i video dei primi risultati su Breakout circolavano internamente in DeepMind dall’autunno 2013. Diversi resoconti giornalistici (in particolare The Information e Bloomberg, 2014) attribuiscono al paper DQN un peso significativo nella decisione di Google. Si tratta di ricostruzioni indirette, non di conferme ufficiali, ma la cronologia (dicembre 2013 paper su arXiv, gennaio 2014 acquisizione) è suggestiva.

L’intuizione

Angolo algoritmico: $Q(s,a)$ come tabella che vorresti avere

Il punto di partenza intuitivo è semplice. Immagina di poter compilare, per ogni gioco, una tabella gigantesca con due colonne. La prima colonna elenca tutti i possibili stati del gioco — ogni configurazione di pixel sullo schermo, ogni posizione possibile della pallina e dei mattoncini in Breakout. La seconda colonna, per ciascuno stato e per ciascuna azione possibile (joystick a sinistra, a destra, fermo, fuoco), riporta un numero: quanti punti ti aspetti di accumulare in totale, da qui alla fine della partita, se esegui quell’azione e poi giochi nel modo migliore possibile. Questa tabella è $Q^*(s, a)$ , la funzione Q ottima.

Se avessi questa tabella, giocare sarebbe banale: a ogni passo, guardi lo stato corrente, leggi la riga, e scegli l’azione con il valore Q più alto. Questa è la policy greedy: $\pi^*(s) = \arg\max_a Q^*(s, a)$ . La policy ottima emerge automaticamente dalla tabella ottima. Non devi pianificare, non devi simulare il futuro, devi solo guardare la tabella.

Il problema è che la tabella ha tante righe quanti sono gli stati possibili. In Breakout, anche solo considerando 84x84 pixel in scala di grigi a 256 livelli, lo spazio degli stati è $256^{7056}$ , un numero che non ha senso fisico. Non puoi compilarla, e non puoi nemmeno indirizzarla. Serve un’approssimazione: una funzione che, dato uno stato, calcoli al volo i valori Q per tutte le azioni. Quella funzione, in DQN, è una rete neurale convoluzionale.

L’idea è quindi: $Q(s, a; \theta)$ , una rete con parametri $\theta$ che riceve in input lo stato (i pixel) e restituisce in output un vettore di stime Q, una per azione. Addestrare la rete significa trovare i $\theta$ tali che $Q(s, a; \theta) \approx Q^*(s, a)$ . Per addestrarla servono target. I target li produce la rete stessa, attraverso bootstrap: il target per la coppia $(s, a)$ è $r + \gamma \max_{a'} Q(s', a'; \theta)$ , dove $s'$ è lo stato successivo osservato. Questa è la stessa formula di Watkins, applicata a una rete neurale.

In parole povere: la rete impara a predire un bersaglio che lei stessa produce. È bootstrap, ed è instabile per costruzione. La parte ingegneristica di DQN sta tutta nel rendere stabile questa procedura.

Angolo architetturale: pixel a Q-values, una sola pipeline per tutti

Il secondo angolo è la radicalità della semplificazione. Negli anni 2000, lo stato dell’arte su Atari richiedeva feature scritte a mano per ogni gioco: “posizione della pallina”, “distanza dal nemico più vicino”, “numero di mattoncini rimasti”. Ogni gioco aveva il suo set di feature. ALE includeva feature contingency-aware come baseline.

DQN spezza questa tradizione. L’input è lo schermo Atari preprocessato (84x84 pixel, grayscale, stack di quattro frame consecutivi per catturare movimento). L’output sono i Q-value per ogni azione. In mezzo c’è una rete neurale convoluzionale identica per tutti i giochi, addestrata indipendentemente per ciascuno ma con la stessa architettura, gli stessi iperparametri, lo stesso codice. Stessa ricetta, 49 esecuzioni separate, 49 reti finali distinte.

Questa scelta è ideologicamente vicina ad AlexNet (vedi imagenet-alexnet-2012). AlexNet aveva mostrato che una CNN profonda addestrata su pixel grezzi poteva imparare feature visive utili senza che nessuno le specificasse. DQN estende l’idea al setting RL: la stessa CNN, invece di classificare immagini, predice valori d’azione. Il feature engineering svanisce dal pipeline. Resta solo la coppia “rete + algoritmo di apprendimento”.

Filiazione, non analogia

Vale la pena marcare le classi di affermazioni. DQN discende da Q-learning di Watkins (filiazione documentata: il paper DQN cita Watkins esplicitamente nei riferimenti, e l’algoritmo è Q-learning con $Q$ rappresentata da una rete). DQN discende da NFQ di Riedmiller (filiazione: Riedmiller è co-autore del paper DQN, NFQ è citato come precedente diretto del batch training stile DQN). DQN eredita l’architettura CNN da AlexNet (filiazione: stesso schema convoluzioni-pooling-FC, stessi tipi di attivazioni, stesso paradigma di pixel-to-output). DQN ha invece una relazione di analogia con TD-Gammon: entrambi combinano RL e reti neurali per imparare un gioco, ma TD-Gammon usa TD( $\lambda$ ) su V(s) con self-play, mentre DQN usa Q-learning su Q(s,a) con experience replay. La somiglianza è di paradigma, non di algoritmo. Tesauro è citato nel paper Nature 2015 come precedente concettuale; non c’è continuità tecnica diretta sul codice.

La meccanica

Q-learning, in formule

L’aggiornamento Q-learning di Watkins, riscritto per chiarezza:

$Q_{t+1}(s_t, a_t) = Q_t(s_t, a_t) + \alpha \big[ r_{t+1} + \gamma \max_{a'} Q_t(s_{t+1}, a') - Q_t(s_t, a_t) \big]$

Le grandezze: $s_t$ è lo stato all’istante $t$ , $a_t$ l’azione scelta, $r_{t+1}$ il reward ricevuto, $s_{t+1}$ il prossimo stato. $\alpha \in (0, 1]$ è il learning rate. $\gamma \in [0, 1)$ è il fattore di sconto: misura quanto “il futuro lontano” pesa rispetto al “futuro vicino”. Per Atari, $\gamma = 0.99$ è il valore standard: vicino a 1, ma non 1, per garantire stabilità matematica della serie geometrica.

Il termine tra parentesi quadre è il TD error: differenza tra il “target” ( $r_{t+1} + \gamma \max Q$ ) e la stima corrente ( $Q(s_t, a_t)$ ). Se il target è più alto della stima, alza la stima. Se è più basso, abbassala. Il learning rate dosa quanto.

La proprietà off-policy di Q-learning sta nel $\max$ . Indipendentemente da quale azione tu abbia effettivamente eseguito (magari un’azione esplorativa subottima), il target che usi per l’update assume che da $s_{t+1}$ in poi tu segua la policy ottima. Per questo Q-learning converge a $Q^*$ anche con esplorazione epsilon-greedy: l’esplorazione serve a coprire lo spazio, non a definire il target.

Il problema con le reti neurali: la deadly triad

Sostituire la tabella $Q$ con una rete neurale $Q(s, a; \theta)$ sembra una mossa innocua. Non lo è. Tre problemi emergono:

Primo, correlazione degli esempi. Un agente RL osserva una sequenza di stati molto correlati: in Breakout, due frame consecutivi differiscono per pochi pixel. Se aggiorni la rete su esempi sequenziali presi in ordine, il gradient descent vede una serie di esempi quasi identici e overfitta sulla regione locale dello spazio di stati. La distribuzione degli esempi durante il training non è i.i.d. (independent and identically distributed), e i metodi standard di gradient descent assumono che lo sia.

Secondo, target non stazionario. Il target $r + \gamma \max_{a'} Q(s', a'; \theta)$ dipende da $\theta$ , gli stessi pesi che stai aggiornando. Sposti la stima e contemporaneamente sposti il bersaglio. È come tirare a una bersaglio che si muove ogni volta che spari. In condizioni patologiche, questo causa oscillazioni o divergenza.

Terzo, drift catastrofico. Una piccola variazione dei pesi può spostare drasticamente i valori Q in regioni dello spazio di stati che la rete non ha visto recentemente. La rete dimentica ciò che aveva imparato in precedenza ogni volta che si concentra su una nuova regione (catastrophic forgetting). Senza un meccanismo che forzi il ripasso, la performance può crollare invece di crescere.

Tutti tre i problemi sono noti dagli anni 90. La combinazione “function approximation + bootstrapping + off-policy” è quella che Sutton e Barto chiamano deadly triad nel loro libro del 2018: tre proprietà che, prese singolarmente sono utili, prese insieme possono divergere. NFQ aveva mostrato che il problema è risolubile in batch su domini piccoli. DQN mostra che è risolubile in pratica anche su input visivo, con due trick chiave.

Trick 1: experience replay buffer

L’experience replay buffer è una memoria circolare di transizioni passate. Ogni volta che l’agente compie un passo nel mondo, registra una tupla $(s, a, r, s', \text{done})$ in un buffer di dimensione $N$ (tipicamente $10^6$ in DQN). Quando arriva il momento di un passo di gradient descent, la rete non si addestra sull’ultima transizione osservata, ma su un mini-batch random estratto dal buffer (tipicamente 32 transizioni).

Due benefici. Primo, decorrelazione. Le transizioni nel mini-batch sono campionate uniformemente da centinaia di migliaia di passi diversi: la distribuzione vista dal gradient descent è molto più vicina a i.i.d. di quanto sarebbe usando l’ultima sequenza di transizioni. Secondo, data efficiency. Ogni transizione viene riutilizzata molte volte (in media, $N_{\text{train}} / N$ volte se le transizioni nuove arrivano allo stesso ritmo dei mini-batch). Il sistema spreme più informazione da ogni interazione con il mondo.

Il replay buffer è anche un fix elegante per il drift catastrofico: dato che ogni mini-batch contiene transizioni vecchie, la rete è costretta a non dimenticare le regioni di spazio di stati che ha visitato in passato. È un meccanismo di ripasso automatico.

L’idea di replay non è invenzione di DQN: il termine compare in Lin (1992, “Self-improving reactive agents based on reinforcement learning, planning and teaching”), tesi PhD di Long-Ji Lin alla Carnegie Mellon. DQN la riapplica nel contesto di reti profonde su input visivo, ed è la combinazione che funziona.

Trick 2: target network

Il secondo trick affronta il target non stazionario. DQN mantiene due copie della rete Q: la online network $Q(s, a; \theta)$ , che viene aggiornata a ogni passo di gradient descent, e la target network $Q(s, a; \theta^-)$ , una copia “congelata” dei pesi. Il target per il TD update si calcola usando la target network:

$y = r + \gamma \max_{a'} Q(s', a'; \theta^-)$

E la loss diventa:

$L(\theta) = \mathbb{E}_{(s, a, r, s') \sim \mathcal{D}} \big[ \big( y - Q(s, a; \theta) \big)^2 \big]$

Dove $\mathcal{D}$ è la distribuzione del replay buffer. La target network $\theta^-$ viene copiata da $\theta$ ogni $C$ passi (in DQN Nature 2015, $C = 10000$ ). Tra una sincronizzazione e l’altra, $\theta^-$ resta fisso, e i target sono stazionari. Questo trasforma un problema di bersaglio mobile in una sequenza di problemi a bersaglio fisso, ciascuno breve abbastanza da non far divergere il learning ma lungo abbastanza da consentire al $\theta$ di avvicinarsi al bersaglio prima che venga aggiornato.

Senza la target network, DQN diverge frequentemente: la documentazione del paper Nature 2015 include esperimenti di ablation che mostrano collassi della performance quando si rimuove il trick. Con la target network, l’addestramento è stabile su tutti i 49 giochi.

Architettura della rete

L’architettura usata nel paper Nature 2015 è una CNN classica post-AlexNet, ma molto più piccola. Input: 84x84x4 (quattro frame consecutivi, scala di grigi, ridimensionati). Tre strati convoluzionali:

Conv1: 32 filtri 8x8 stride 4, attivazione ReLU. Output: 20x20x32.
Conv2: 64 filtri 4x4 stride 2, attivazione ReLU. Output: 9x9x64.
Conv3: 64 filtri 3x3 stride 1, attivazione ReLU. Output: 7x7x64.

Poi un fully connected layer da 512 unità con ReLU, e infine un output layer fully connected con $|\mathcal{A}|$ unità lineari, una per azione possibile (4-18 a seconda del gioco). Nessun pooling esplicito: lo stride nelle convoluzioni gestisce la riduzione di risoluzione.

Va notato che la versione preliminare del 2013 usava una rete più piccola (16-32-32 filtri, FC da 256). Il paper Nature 2015 ingrandisce la rete e ottiene risultati migliori. La cifra “circa 1.7 milioni di parametri” appare nel supplementary del paper Nature; a confronto, AlexNet aveva 60 milioni di parametri. La rete DQN è piccola perché l’input è piccolo (84x84 contro 224x224 di AlexNet) e il task è semplice in termini di output (poche azioni discrete contro 1000 classi).

Preprocessing dei frame

Lo schermo Atari originale è 210x160 pixel a 128 colori palette. Inviare questo direttamente alla CNN sarebbe inefficiente. DQN preprocessa: converte in scala di grigi (riduce il canale da 3 a 1), riduce a 84x84 con interpolazione, e impila quattro frame consecutivi sull’asse del canale. Lo stack di quattro frame è essenziale: un singolo frame non contiene informazione sul movimento (non puoi distinguere una pallina che sale da una che scende), e Atari è un dominio dove il movimento è cruciale. Quattro frame catturano una storia abbastanza lunga da disambiguare la maggior parte delle situazioni.

C’è anche una sottigliezza: alcuni giochi Atari fanno flicker degli sprite (li mostrano in frame alterni, una pratica comune sull’hardware del 2600 per aggirare limiti di sprite simultanei). Il preprocessing prende il massimo pixel a pixel tra ogni frame e il successivo, per evitare che gli sprite scompaiano durante lo stack.

Reward clipping

Atari ha 49 giochi con scale di reward eterogenee: in Pong il reward è $\pm 1$ per punto (massimo $\pm 21$ per partita), in Q*bert centinaia di punti per blocco, in Breakout punti che variano da 1 a 7 per mattoncino. Addestrare una rete unica con la stessa architettura e gli stessi iperparametri su tutti i giochi richiede di normalizzare la scala dei reward, altrimenti la magnitudine del gradiente esplode o evapora a seconda del gioco.

Il fix di DQN è brutalmente semplice: reward clipping. Tutti i reward positivi vengono clippati a $+1$ , tutti i negativi a $-1$ , lo zero resta zero. Si perde informazione sull’entità relativa dei reward (vincere un punto da 1000 conta come uno da 1), ma si ottiene stabilità di training tra giochi diversi.

C’è una conseguenza concettuale: la policy appresa massimizza il numero di eventi reward, non la somma del punteggio reale. In quasi tutti i giochi i due obiettivi coincidono o sono molto correlati, ma in alcuni (es. Bowling, dove gli strike valgono molto più degli spare) la perdita di informazione causa policy subottime. Il paper Nature 2015 documenta questa limitazione e i lavori successivi (ad esempio il transformed Bellman operator del 2018) la affronteranno.

Frame skipping

Atari gira a 60 frame al secondo. Inferire ed agire 60 volte al secondo è costoso e ridondante: l’agente non può cambiare strategia ogni 16 millisecondi in modo significativo. DQN usa frame skipping: l’agente sceglie un’azione, la mantiene per 4 frame consecutivi, poi sceglie di nuovo. Riduce il costo di inferenza di un fattore 4 e accelera l’addestramento. Il prezzo è che la latenza tra cambi di azione è di 67 ms, comparabile a quella di un giocatore umano competente.

La loss completa

Mettendo insieme tutti i pezzi, la loss di DQN per un mini-batch $\mathcal{B}$ campionato dal replay buffer è:

$L(\theta) = \frac{1}{|\mathcal{B}|} \sum_{(s, a, r, s', d) \in \mathcal{B}} \Big( r_{\text{clip}} + \gamma (1 - d) \max_{a'} Q(s', a'; \theta^-) - Q(s, a; \theta) \Big)^2$

Dove $d$ è il flag “done” (1 se $s'$ è terminale, 0 altrimenti) e $r_{\text{clip}} \in \{-1, 0, +1\}$ è il reward dopo clipping. Il moltiplicatore $(1 - d)$ azzera il termine di valore futuro se la partita è finita: dopo game over, non c’è più nulla da valorizzare. L’ottimizzatore originale è RMSProp con learning rate $0.00025$ , momentum $0.95$ , gradient norm clipping a 10.

L’algoritmo completo

In pseudocodice essenziale:

inizializza replay buffer D di capacità N = 1M
inizializza Q con pesi theta random
inizializza target Q-hat con pesi theta-minus = theta

per ogni episodio:
    s = stato iniziale (4 frame iniziali pre-processati)
    per ogni passo t fino a game over:
        con prob epsilon: a = azione random
        altrimenti:        a = argmax_a Q(s, a; theta)

        esegui a, osserva r, s', done
        clip r in [-1, +1]
        memorizza (s, a, r, s', done) in D

        campiona mini-batch B di 32 transizioni da D
        per ogni (s_j, a_j, r_j, s'_j, d_j) in B:
            y_j = r_j + (1 - d_j) * gamma * max_a' Q-hat(s'_j, a'; theta-minus)
            loss_j = (y_j - Q(s_j, a_j; theta))^2
        gradient step su mean(loss) rispetto a theta

        ogni C passi: theta-minus = theta
        s = s'

    decadi epsilon (es. da 1.0 a 0.1 lineare nei primi 1M frame)

L’epsilon-greedy è il meccanismo di esplorazione. All’inizio epsilon è alto (azioni quasi totalmente random), poi decresce linearmente per favorire il greedy man mano che la policy migliora. Il paper Nature usa decadimento da 1.0 a 0.1 nei primi un milione di frame, poi epsilon resta a 0.1 per tutto il resto del training (50 milioni di frame totali per gioco).

Va notato un dettaglio implementativo importante: i primi $K$ passi (tipicamente 50000) servono solo a popolare il replay buffer, e durante questi passi non si fa gradient descent. Si chiama warm-up: senza un buffer pieno, i primi mini-batch sarebbero campionati da troppo poche transizioni e troppo correlate, con il rischio di gradient steps che spingono la rete verso minimi locali patologici. Il warm-up è una piccola accortezza ingegneristica che fa molta differenza in pratica e che non sempre è documentata in modo evidente nei paper.

C’è anche il problema della scelta del primo frame: Atari rilascia il controllo all’agente solo dopo qualche frame di animazione iniziale. DQN aspetta un numero random tra 1 e 30 di NOOP (azione “non far nulla”) prima di iniziare ogni episodio, per evitare che la rete impari pattern che dipendono dal sincronizzarsi perfettamente con il timer dell’emulatore. È una forma di data augmentation temporale.

Risultati Nature 2015: i numeri

Su 49 giochi Atari, l’agente con architettura, iperparametri e algoritmo identici raggiunge la performance riportata nel paper:

In 29 giochi su 49, lo score finale è almeno il 75% del livello di un tester umano professionista (la cui performance era stata misurata in sessioni dedicate da DeepMind).
In alcuni giochi (Breakout, Pong, Boxing, Star Gunner, Atlantis, Crazy Climber, …) DQN supera il tester umano di più di un ordine di grandezza.
In 6 giochi (Montezuma’s Revenge, Private Eye, Asteroids, Solaris, Skiing, Bowling) DQN ottiene punteggi al di sotto di una baseline random o pari a essa: fallimenti netti.

La cifra “29 su 49” è stata letta in modi diversi. Ottimisti: è la prima volta che un singolo algoritmo con singolo set di iperparametri raggiunge performance umana su un set ampio di task percettivi. Pessimisti: 20 fallimenti su 49 sono il 41% dei giochi, e in particolare Montezuma’s Revenge sarebbe rimasto un benchmark aperto per cinque anni (fino ad Agent57 nel 2020), perché richiede esplorazione strategica con reward sparsi che DQN non sa gestire.

Entrambe le letture sono corrette. DQN dimostra che il paradigma è valido; mostra anche che è incompleto.

Esempi

Esempio 1: il loop di training in pratica

Per fissare il flusso di esecuzione, ecco una traccia di pochi minuti di training su Breakout. L’agente parte con epsilon = 1.0 (azioni totalmente random); il replay buffer è vuoto. La rete è inizializzata a caso e produce Q-values quasi uniformi.

Primo episodio: l’agente colpisce la pallina per puro caso un paio di volte, segna 2 punti (clippati a +1 ciascuno), poi la pallina cade e l’episodio termina dopo circa 200 frame. Nel frattempo 200 transizioni sono state memorizzate nel buffer.

Secondo episodio: stesse condizioni. Il buffer ora contiene 400 transizioni. La rete inizia a fare gradient steps ogni 4 frame su mini-batch di 32 transizioni casuali. I primi gradient steps non hanno ancora abbastanza segnale per imparare nulla di significativo: le Q-stime sono ancora rumorose.

Dopo circa 50000 frame (un paio di centinaia di episodi), la rete inizia a “vedere” che muovere il paddle verso la pallina porta a reward, e i Q-values per le azioni “muovi nella direzione della pallina” diventano più alti delle altre. La policy greedy inizia a giocare in modo non casuale; epsilon è ancora alto (~0.95) ma il segnale è già rilevabile.

Dopo 1 milione di frame (qualche ora su una GPU del 2014), epsilon è sceso a 0.1, la policy è quasi completamente greedy, e il punteggio per episodio sale costantemente. Dopo 10 milioni, l’agente colpisce la pallina con buona consistenza e mantiene il gioco vivo per minuti.

Dopo 50 milioni di frame (il budget standard di DQN, equivalente a circa 38 giorni di gameplay continuo a 60 fps), l’agente ha appreso strategie sofisticate. In particolare, ha scoperto la strategia del tunnel.

Esempio 2: la scoperta del tunnel in Breakout

Breakout ha sei file di mattoncini in alto, un paddle in basso, e una pallina che rimbalza. Ogni mattoncino colpito dà punti e scompare; le file in alto valgono di più. Le file vengono colpite normalmente di sotto, mano a mano che la pallina sale, perde mattoncini sul percorso e ritorna. La strategia “naive” è muovere il paddle a inseguire la pallina e accumulare punti file dopo file.

C’è una strategia migliore, conosciuta nei tornei umani da decenni: scavare un tunnel verticale su un lato del muro (di solito il sinistro). Una volta che la pallina riesce a passare attraverso il tunnel, finisce intrappolata sopra il muro, dove rimbalza tra il soffitto e il lato superiore dei mattoncini, distruggendone molti in pochi secondi senza che il paddle debba intervenire. È la strategia ottimale, ma richiede di pianificare il sacrificio iniziale di alcuni colpi per costruire il tunnel.

DQN scopre questa strategia da solo, senza che nessuno la programmi o la suggerisca. Non c’è nessun premio esplicito per “scavare un tunnel”; il segnale di reward è solo “+1 per ogni mattoncino colpito”. La rete impara, attraverso l’esperienza accumulata in milioni di partite, che muovere il paddle verso il lato sinistro nelle fasi iniziali porta a uno stato in cui la pallina, una volta passata sopra il muro, accumula molti reward in rapida successione. La $\max_{a'}$ del Bellman backup propaga questa informazione all’indietro, fino ai primi colpi del gioco.

I video di DQN che esegue la strategia del tunnel sono stati una delle ragioni del clamore intorno al paper. Mostrano qualcosa che assomiglia a comportamento intenzionale, “strategico”, emergente da un sistema che vede solo pixel e reward. Nei colloqui successivi, Mnih ha ripetuto che il tunnel “non era stato programmato; è stato scoperto”. La frase è semplice e accurata, ed è il messaggio chiave del paper.

Esempio 2-bis: il “killer move” in Pong

Pong è il gioco minimalista per eccellenza. Due paddle verticali, una pallina che rimbalza, un punto a chi fa passare la pallina dietro l’avversario. La policy umana naive consiste nell’inseguire la pallina con il proprio paddle. La policy ottima è più sottile: se rimbalzi la pallina sul bordo del tuo paddle, il rimbalzo cambia angolo in modo difficile da intercettare per l’avversario. DQN scopre questa proprietà rapidamente. Inoltre, dopo qualche milione di frame, l’agente impara una strategia ricorrente: aspetta che la pallina rimbalzi sul proprio paddle in modo da farla passare sopra il centro dell’avversario CPU, lasciando l’avversario poco tempo per reagire. Il pattern emerge in modo consistente in più sessioni di training indipendenti, segno che è una soluzione locale stabile dell’ottimizzazione, non un artefatto di una singola run.

Una volta scoperta la strategia, l’agente vince 21-0 in modo praticamente sistematico contro l’AI built-in di Pong. Su Pong il paper Nature 2015 riporta uno score medio di +20.7 contro un tester umano professionista a +9.3: l’agente è più di due volte sopra l’umano. Pong è uno dei giochi dove il margine di superiorità di DQN è più netto. Lo stesso pattern si vede in Boxing (DQN +99.6, umano +4.3), Atlantis e Star Gunner.

Esempio 3: il fallimento di Montezuma’s Revenge

Montezuma’s Revenge è un platform Atari del 1984, ambientato in una piramide. Il giocatore (Panama Joe) deve esplorare stanze, raccogliere chiavi, evitare nemici e trabocchetti, aprire porte. La struttura del reward è punitiva: nessun punto per molti frame, poi un singolo +100 per una chiave raccolta o una porta aperta, poi di nuovo niente per molti frame. La prima ricompensa arriva spesso dopo decine o centinaia di azioni “esplorative” che non danno feedback intermedio.

Per DQN questo è un disastro. Il TD-update ha bisogno di un segnale di reward per propagarsi all’indietro. Senza reward, $r + \gamma \max Q(s', \cdot)$ è semplicemente $\gamma \max Q(s', \cdot)$ , e la rete non ha nulla da imparare se non un’estrapolazione del proprio bias iniziale. L’esplorazione epsilon-greedy non aiuta: la probabilità di trovare la chiave per puro caso è bassissima. L’agente vaga senza scoprire nulla.

Su Montezuma’s Revenge il paper Nature 2015 riporta uno score di 0 punti dopo 50 milioni di frame: l’agente non raccoglie mai la prima chiave. La random policy ottiene a sua volta uno score molto basso. Il problema non è risolto fino al 2018-2020 con tecniche come intrinsic motivation (il sistema premia sé stesso per visitare stati nuovi, prima ancora di ricevere reward esterno) e hierarchical RL (decomporre il task in sotto-obiettivi). Agent57 nel 2020 risolve finalmente Montezuma e tutti gli altri 56 giochi del benchmark esteso.

Il fallimento di Montezuma è importante perché mostra che il paradigma DQN non è universale. Funziona sui giochi con reward denso e ben distribuito; fallisce sui giochi che richiedono pianificazione a lungo termine o esplorazione strategica. È una lezione che si trasferisce a qualunque applicazione di RL al di fuori dei giochi: se il segnale di reward è sparso, DQN nudo non basta.

Una nota sull’hardware del 2013-2015

L’addestramento di DQN nel 2013-2015 girava su una singola GPU NVIDIA, tipicamente una GTX 580 o una Tesla K20/K40 a seconda dell’epoca. Cinquanta milioni di frame per gioco corrispondono a circa 7-10 giorni di calcolo continuo per gioco. Per riprodurre i risultati su 49 giochi serviva quindi un cluster di GPU per circa un mese. Si tratta di un budget computazionale modesto rispetto a quello degli LLM moderni (dove i runs di pretraining si misurano in mesi su migliaia di GPU), ma significativo per un laboratorio accademico nel 2014. DeepMind, post acquisizione Google, aveva accesso a infrastruttura interna Google e questo ha contribuito alla rapidità con cui sono state esplorate le varianti di DQN nei tre anni successivi. Il dettaglio è rilevante: DQN è stato il primo lavoro di “deep RL su scala industriale”, non solo per l’algoritmo ma anche per l’infrastruttura che lo supportava.

A riprova di questo fatto: replicare DQN nel 2026 con framework moderni (Stable-Baselines3, CleanRL, RLlib) richiede poche ore di lavoro di setup e poche ore di training su una GPU consumer. La barriera ingegneristica che nel 2013 era significativa è oggi azzerata. Quello che resta significativo è la sample inefficiency: anche con hardware moderno, per imparare un gioco serve sempre l’equivalente di milioni di frame di interazione, perché il problema è dell’algoritmo, non del compute.

Eredita oggi

[DATATO 2026-04]

Filiazione documentata

C’è una linea diretta che parte da Q-learning di Watkins 1989 e arriva a MuZero del 2020, passando per DQN. È una filiazione documentata, non un’analogia retrospettiva: ogni paper della catena cita esplicitamente il precedente. Le tappe principali:

Q-learning (Watkins 1989): introduce la nozione di action-value function e il TD-update off-policy.
NFQ (Riedmiller 2005): mostra che function approximation con reti neurali e batch training è praticabile.
DQN (Mnih 2013, Mnih 2015): scala a input visivo con experience replay e target network.
Double DQN (van Hasselt, Guez, Silver 2016): risolve l’overestimation bias di Q-learning con un trick di disaccoppiamento tra azione selezionata e azione valutata.
Dueling DQN (Wang et al. 2016): separa l’output in $V(s)$ e advantage $A(s, a)$ , migliorando l’apprendimento quando il valore della mossa specifica conta meno del valore dello stato.
Prioritized Experience Replay (Schaul et al. 2016): sostituisce il sampling uniforme dal buffer con sampling pesato per TD-error magnitude, accelerando l’apprendimento sulle transizioni più informative.
Rainbow DQN (Hessel et al. 2018, AAAI): combina sei estensioni di DQN in un singolo agente. Stato dell’arte su Atari per il periodo 2018-2019.
AlphaGo (Silver et al. 2016): combina deep RL con Monte Carlo Tree Search per battere Lee Sedol al Go. La componente “policy network” e “value network” eredita direttamente l’idea di rete come approssimatore di funzione, e i Methods del paper Nature citano DQN come precedente diretto.
AlphaZero (Silver et al. 2017): rimuove la dipendenza da partite umane, addestra solo via self-play, generalizza a scacchi, shogi e Go con la stessa architettura.
MuZero (Schrittwieser et al. 2020): apprende anche le dinamiche del modello dell’ambiente, oltre a policy e value, ottenendo performance comparabili senza accesso esplicito alle regole del gioco.

In parallelo, dal lato policy gradient: A3C/A2C (Mnih et al. 2016, lo stesso primo autore di DQN), PPO (Schulman et al. 2017, OpenAI), SAC (Haarnoja et al. 2018) sviluppano un filone alternativo a Q-learning, on-policy o stochastic-policy, che oggi è dominante nelle applicazioni continuous-control e RLHF. Vedi policy-gradient e actor-critic (in preparazione, Parte V).

Rainbow DQN (2018) come consolidamento

Tra il 2015 e il 2017, vari gruppi (principalmente DeepMind e Google Brain) sviluppano singole estensioni di DQN, ciascuna con il proprio paper e il proprio set di iperparametri. Double DQN, Dueling, Prioritized Replay, Multi-step targets, Distributional RL (Bellemare-Dabney-Munos 2017), Noisy Nets (Fortunato et al. 2017). Ogni estensione migliora la performance su Atari, ma fino al 2018 nessuno aveva integrato tutte queste innovazioni in un singolo agente coeso.

Rainbow (Hessel et al. 2018, AAAI) è il consolidamento. Mette insieme sei estensioni in un unico framework, usa gli stessi iperparametri su tutti i giochi, e supera ogni singola estensione presa da sola. Lo studio di ablation di Rainbow è particolarmente illuminante: rimuovere distributional RL e prioritized replay ha gli effetti più grandi sulla performance media; rimuovere noisy nets ha l’effetto minore. Questo suggerisce che il vero salto rispetto a DQN del 2015 sta nella rappresentazione distribuzionale del valore (predire una distribuzione su return invece del valore atteso) e nel sampling pesato dal buffer.

Rainbow è stato il riferimento “stato dell’arte” per il valore-based deep RL su Atari per il periodo 2018-2019, prima di essere superato da R2D2 (recurrent replay distributed DQN, Kapturowski et al. 2019) e Agent57. Per il praticante che vuole implementare un agente RL competitivo nel 2026, Rainbow è ancora un baseline rispettabile e didatticamente più chiaro di Agent57.

Influenza su RLHF

Una connessione meno ovvia: l’idea di addestrare un modello con reward come segnale di apprendimento, insieme alla nozione che il segnale di reward può venire da una funzione appresa (reward model), è centrale in RLHF (Reinforcement Learning from Human Feedback), il paradigma che addestra modelli linguistici come ChatGPT e Claude. Il primo lavoro maturo è Christiano et al. 2017 (“Deep reinforcement learning from human preferences”, NeurIPS), pubblicato da OpenAI e DeepMind congiuntamente. Christiano et al. usano una variante di policy gradient (TRPO/PPO), non DQN, ma il framework concettuale di “agente che ottimizza un reward function appreso” eredita direttamente da deep RL, di cui DQN è il rappresentante più visibile.

Il pipeline di InstructGPT (Ouyang et al. 2022) e dei successori chat-tuned standardizza questa pratica: pretraining + supervised fine-tuning + RLHF con PPO. La componente RL è la più tecnicamente impegnativa e quella che storicamente discende dal corpo di tecniche maturate in deep RL post-DQN. Gli LLM moderni non usano DQN, ma l’infrastruttura intellettuale e ingegneristica che permette di addestrare RLHF affidabilmente è figlia diretta degli anni 2014-2018 di lavoro su deep RL.

Robotic learning e sim-to-real

Un’altra applicazione moderna del paradigma post-DQN è il robotic learning in simulazione. Pipeline tipica: simula un compito robotico (manipolazione, locomozione) in un motore fisico (MuJoCo, Isaac Gym), addestra una policy in simulazione con PPO o SAC, trasferisci la policy a un robot reale (sim-to-real). Il ciclo “interagisci col mondo, raccogli transizioni, ottimizza una policy via gradient descent” è strutturalmente identico a DQN, anche se gli algoritmi specifici sono diversi e i task sono di controllo continuo. Gruppi come Boston Dynamics, OpenAI (su Rubik’s cube nel 2019), Tesla (su Optimus) e più in generale i laboratori di embodied AI usano varianti di questo schema.

Limiti che persistono

Vale la pena marcare anche cosa è rimasto irrisolto. Tre limiti di DQN sono ancora aperti nelle versioni moderne, sebbene mitigati:

Sample inefficiency: DQN richiede 50 milioni di frame per convergere in un gioco. Un essere umano impara Atari a livello giocabile in due ore. La differenza è di tre o quattro ordini di grandezza. Le architetture moderne (Rainbow, MuZero) la riducono ma non l’azzerano. La sample inefficiency è una delle barriere principali al deployment di RL in domini reali costosi (robotica, healthcare, dove ogni interazione ha un costo).
Reward sparsity: il problema Montezuma resta strutturale. Tecniche come intrinsic motivation, count-based exploration, hierarchical RL aiutano, ma nessuna è una soluzione generale. Su domini reali con reward sparso (assistenti che devono completare task lunghi multi-step), il problema riemerge in forme nuove.
Transfer: una rete DQN addestrata su Breakout non gioca a Pong. Una addestrata su Pong non gioca a Space Invaders. Nessun transfer cross-task in DQN nudo. AlphaZero migliora su questo (stessa architettura su tre giochi diversi), ma sempre con addestramento separato. Il transfer learning in RL è un’area di ricerca aperta, e una delle motivazioni dietro i recenti tentativi di “generalist agent” come GATO (Reed et al. 2022, DeepMind).

Dove si rompe

Oltre ai limiti già discussi, vale la pena fissare alcune fragilità specifiche di DQN che spesso sorprendono chi lo implementa per la prima volta.

Brittleness rispetto a modifiche dell’ambiente

DQN è brittle: piccoli cambiamenti nelle condizioni di test rispetto alle condizioni di training degradano drasticamente la performance. Se cambi la palette di colori del gioco, l’agente fallisce. Se modifichi il frame rate o il timing degli sprite, la performance crolla. Se aggiungi rumore visivo (ad esempio sovrapponendo qualche pixel random), l’agente perde la sua policy. Questa brittleness non è un problema specifico di DQN; è una proprietà generale degli agenti RL trained-from-pixels, ed è uno dei motivi per cui il transfer reale a domini fisici (dove le condizioni cambiano sempre) è difficile.

Studi successivi (in particolare i lavori di Cobbe et al. 2019-2020 su ProcGen, un benchmark con generazione procedurale di livelli) hanno quantificato la brittleness e mostrato che agenti RL “memorizzano” molto del training set in modo simile a una rete supervised che overfitta. La risposta è stata l’introduzione di domain randomization, data augmentation visiva, e benchmark dedicati alla generalizzazione.

Overestimation bias di Q-learning con NN

Il $\max_{a'} Q(s', a')$ nell’update introduce un bias positivo sistematico nelle stime di Q. In presenza di rumore (e con reti neurali ce n’è sempre), il max sovrastima il valore atteso reale. Questa è una proprietà nota di Q-learning e non specifica delle reti neurali, ma con function approximation profonda l’effetto è amplificato e può portare a divergenze locali della policy. Double DQN (Hado van Hasselt, Arthur Guez, David Silver, 2016) lo affronta usando una rete per selezionare l’azione e l’altra per valutarla:

$y = r + \gamma Q(s', \arg\max_{a'} Q(s', a'; \theta); \theta^-)$

In parole povere: scegli l’azione con la online network, valuta con la target network. Il disaccoppiamento riduce il bias e migliora la performance su molti giochi. Double DQN è oggi considerata il default minimo per qualunque applicazione seria di Q-learning con reti neurali.

Il mito “DQN ha risolto Atari”

Nel discorso pubblico post-2015, è circolata la narrazione che DQN avesse “risolto Atari” o “raggiunto livello umano sui giochi Atari”. Questa narrazione è imprecisa. DQN ha raggiunto o superato livello umano in 29 giochi su 49, ma è fallita in 6 in modo netto (score random o sotto), e in 14 ha ottenuto performance subottime (tra 25% e 75% del livello umano). L’affermazione “Atari risolto” diventa difendibile solo nel 2020 con Agent57, e anche allora “risolto” significa “performance umana superata in tutti i 57 giochi del benchmark esteso”, non “agente generalista che gioca a tutti come un umano”.

L’imprecisione è significativa perché ha contribuito a creare un’aspettativa eccessiva: se il deep RL “risolve” i videogiochi, perché non risolve la guida autonoma, la robotica generale, gli assistenti AGI? La risposta tecnica è che DQN ha risolto un sottoinsieme di problemi RL caratterizzati da observation visiva, azione discreta, reward denso e ambiente stazionario. Pochi domini reali hanno tutte queste proprietà simultaneamente, e quando manca anche solo una (reward sparso, azione continua, ambiente non stazionario), servono tecniche aggiuntive.

Catastrophic forgetting tra giochi

DQN può imparare un gioco alla volta. Se prendi una rete addestrata su Breakout e continui ad addestrarla su Pong, dimentica Breakout completamente in poche centinaia di migliaia di passi. Non c’è memoria persistente cross-task. Tecniche come Elastic Weight Consolidation (Kirkpatrick et al. 2017, di nuovo DeepMind) provano a mitigare il problema introducendo regolarizzazione che protegge i pesi importanti per task precedenti, ma il problema generale del continual learning in RL resta aperto. Agent57 e GATO dimostrano che agenti generalisti sono possibili con architetture grandi e training congiunto, ma non con la procedura DQN standard.

Sensibilità agli iperparametri e riproducibilità

Una fragilità meno spesso discussa, ma molto rilevante per chi tenta di replicare i risultati, è la sensibilità agli iperparametri. DQN ha più di una dozzina di iperparametri non banali: dimensione del replay buffer, frequenza di update della target network ( $C$ ), schedule di decadimento di epsilon, learning rate, batch size, frame-skip, gradient clipping. Piccole variazioni di alcuni di questi possono cambiare drasticamente il risultato. Henderson et al. nel 2018 (“Deep Reinforcement Learning that Matters”, AAAI) hanno mostrato che la varianza tra run con seed diversi e implementazioni leggermente diverse di DQN è enorme: lo stesso algoritmo, sullo stesso gioco, può variare di un fattore 2-3 nella performance finale a seconda di dettagli implementativi che il paper originale non documenta in modo esauriente. La riproducibilità dei risultati DQN è quindi più fragile di quella, ad esempio, di una rete supervised su ImageNet, e questo è un problema generale del deep RL che persiste nel 2026.

Stato non-Markoviano e POMDP

Le quattro frame impilate sono una soluzione pragmatica al fatto che lo stato vero del gioco non è osservabile dall’agente: l’emulatore Atari conosce posizioni, velocità, contatori interni, ma all’agente arrivano solo i pixel. Questo trasforma il problema da MDP a POMDP (Partially Observable MDP). In molti giochi quattro frame bastano per ricostruire lo stato rilevante (posizione e velocità di pallina e paddle). In altri (specialmente giochi che richiedono memoria a lungo termine, come navigazione in labirinti) quattro frame sono insufficienti, e DQN nudo fallisce. R2D2 e Agent57 affrontano questa limitazione introducendo una rete ricorrente (LSTM) sopra la CNN, in modo da mantenere stato interno tra timestep. Questa è una delle ragioni tecniche per cui Agent57 risolve giochi che DQN non risolve.

Bias di reward clipping

Il reward clipping a $\{-1, 0, +1\}$ semplifica il training ma introduce un bias. In Bowling, dove gli strike valgono 30 punti contro i 9 di un buon spare, l’agente DQN tratta strike e spare allo stesso modo (entrambi $+1$ ). La policy ottima nel mondo reale dovrebbe massimizzare gli strike; la policy ottima sotto reward clipping massimizza il numero di strike-o-spare, indipendentemente dal valore. Su Bowling DQN ottiene punteggi mediocri proprio per questo. Il transformed Bellman operator di Pohlen et al. 2018 e l’inverse-transformed reward di Ape-X DQN affrontano il problema preservando la non-stazionarietà del segnale; entrambi sono modifiche tecniche che hanno permesso a R2D2 (Kapturowski et al. 2019) e Agent57 di superare DQN proprio sui giochi dove il clipping era penalizzante.

Collegamenti

td-gammon-1992: il “nonno” concettuale di DQN. Tesauro mostra nel 1992 che RL+rete neurale può raggiungere livello umano in un gioco (backgammon); DQN generalizza l’idea a 49 giochi visivi. Filiazione esplicita citata nel paper Nature.
imagenet-alexnet-2012: la rivoluzione CNN di cui DQN è l’applicazione naturale al setting RL. Stesso paradigma “pixel-to-output” senza feature engineering, stesso tipo di architettura convoluzionale, stessa finestra storica (2012-2013).
deep-blue-1997: paradigma opposto. Deep Blue è hardware custom + ricerca minimax + knowledge engineering scacchistico; DQN è hardware commodity + apprendimento + zero conoscenza specifica. Confrontare i due aiuta a misurare quanto è cambiato il senso comune di “AI che gioca” tra 1997 e 2015.
reti-neurali-80-90: la traversata del filone connessionista che precede DQN. Contesto necessario per capire perché negli anni 90 nessuno aveva provato a combinare deep CNN con RL: le CNN profonde non esistevano ancora.
alphago-2016 (in preparazione, Parte I): l’erede diretto di DQN su un dominio molto più complesso (Go invece di Atari). Stessa filiazione: rete neurale + RL + self-play, qui combinati con MCTS.
q-learning (in preparazione, Parte V): il capitolo dedicato all’algoritmo formale Q-learning, sue varianti, sue prove di convergenza. DQN è il caso applicativo più noto.
markov-decision-process (in preparazione, Parte V): il framework formale degli MDP che sottende tutto il reinforcement learning. DQN risolve un MDP con osservazioni parziali (lo stato vero del Atari è noto solo all’emulatore, l’agente vede solo i pixel).
policy-gradient (in preparazione, Parte V): il filone alternativo a Q-learning. PPO, SAC, A3C sono i discendenti dominanti per applicazioni moderne (RLHF, robotica).
actor-critic (in preparazione, Parte V): l’architettura intermedia che combina value-based e policy-based. A3C (Mnih 2016) è il punto di riferimento per il DRL on-policy.
cnn-architetture (in preparazione, Parte VIII): il capitolo sulle architetture CNN classiche. La rete di DQN è una piccola CNN post-AlexNet; capire le scelte architetturali aiuta a capire DQN.
rlhf-ppo (in preparazione, Parte XI): l’applicazione moderna di RL agli LLM. Eredita il framework concettuale e l’infrastruttura ingegneristica di deep RL post-DQN.

Lineage tree completo

Per chi vuole una mappa visiva della discendenza di DQN nel panorama deep RL del decennio 2013-2023, il diagramma seguente raccoglie le ramificazioni principali:

Una nota didattica

Nei corsi moderni di reinforcement learning (Berkeley CS285, Stanford CS234, DeepMind RL Lecture Series su YouTube) DQN occupa due o tre lezioni. È il primo esempio “applicato” che gli studenti incontrano dopo aver visto Q-learning tabulare e dopo l’introduzione delle reti neurali. La progressione canonica è: tabular Q-learning su gridworld → linear function approximation → deep Q-learning su CartPole → DQN su Atari. Implementare DQN è un esercizio standard del secondo o terzo anno di un PhD ML, e le code rilasciate dal team DeepMind originale (poi consolidato in dopamine di Google nel 2018, e ora nei vari framework open come Stable-Baselines3) sono diventate riferimento didattico oltre che applicativo.

Per andare oltre

Mnih V., Kavukcuoglu K., Silver D., Graves A., Antonoglou I., Wierstra D., Riedmiller M., “Playing Atari with Deep Reinforcement Learning”, arXiv:1312.5602, NIPS Deep Learning Workshop 2013. La versione preliminare. Nove pagine, lettura veloce, cattura l’essenziale. Buon punto di partenza per chi vuole vedere l’idea nuda.
Mnih V. et al., “Human-level control through deep reinforcement learning”, Nature vol. 518, pp. 529-533, febbraio 2015. La versione estesa, con ablation study, dettagli su tutti gli iperparametri, e i risultati sui 49 giochi. Lettura obbligatoria per chi vuole implementare DQN o capirne i dettagli.
Sutton R.S., Barto A.G., Reinforcement Learning: An Introduction, 2nd edition, MIT Press 2018. Il libro di riferimento per RL classico. Capitoli 6 (Temporal-Difference Learning), 7 (n-step TD), e 11 (Off-policy Methods with Approximation, dove discutono la deadly triad in dettaglio) sono il prerequisito teorico per capire DQN.
Bellemare M.G., Naddaf Y., Veness J., Bowling M., “The Arcade Learning Environment: An Evaluation Platform for General Agents”, Journal of Artificial Intelligence Research 47:253-279, 2013. Il paper che definisce ALE. Senza ALE non ci sarebbe stato DQN come è. Chiarisce le scelte di design del benchmark e le baseline pre-deep.
Hessel M., Modayil J., van Hasselt H., Schaul T., Ostrovski G., Dabney W., Horgan D., Piot B., Azar M., Silver D., “Rainbow: Combining Improvements in Deep Reinforcement Learning”, AAAI 2018. La sintesi delle estensioni di DQN sviluppate tra 2015 e 2018. Mostra come ogni miglioramento (Double, Dueling, Prioritized Replay, Multi-step learning, Distributional RL, Noisy Nets) contribuisce in modo additivo al risultato finale. Buon riferimento per chi vuole implementare lo stato dell’arte 2018 di valore-based deep RL.
Badia A.P., Piot B., Kapturowski S., Sprechmann P., Vitvitskyi A., Guo D., Blundell C., “Agent57: Outperforming the Atari Human Benchmark”, ICML 2020. Il lavoro che finalmente “risolve” Atari, superando il tester umano in tutti i 57 giochi del benchmark esteso. Combina deep RL distribuito, intrinsic motivation, e meta-controllo per gestire il trade-off esplorazione-sfruttamento gioco per gioco. Lettura conclusiva per la storia DQN-Atari.
Henderson P., Islam R., Bachman P., Pineau J., Precup D., Meger D., “Deep Reinforcement Learning that Matters”, AAAI 2018. Lo studio empirico sulla riproducibilità di DQN e di altri agenti deep RL. Documenta la varianza estrema tra run, l’effetto degli iperparametri non documentati, e i pattern di reporting selettivo che hanno gonfiato risultati pubblicati. Lettura essenziale per chi si avvicina al deep RL con aspettative di solidità ingegneristica simili a quelle del supervised learning.
Christiano P., Leike J., Brown T.B., Martic M., Legg S., Amodei D., “Deep Reinforcement Learning from Human Preferences”, NeurIPS 2017. Il ponte tra deep RL classico (di cui DQN è il rappresentante più noto) e l’applicazione moderna agli LLM (RLHF). Christiano et al. usano TRPO/PPO, non DQN, ma il framework concettuale e tecnico discende direttamente dall’infrastruttura deep RL maturata nel periodo 2014-2017.