Q-learning e DQN: imparare il valore delle azioni, dalla tabella alla rete neurale

Apprendimento per differenza temporale, Q-learning e SARSA sulla camminata sul precipizio, esplorazione ε-greedy, on-policy e off-policy, DQN con memoria delle esperienze e rete target sul pendolo inverso su un carrello scritto da zero, e perché l’apprendimento di DQN crolla così facilmente.

12 minuti Matěj Žalmánek 2026-10-16

Serie Basi di IA Parte 48 di 52

1. Mappa dell’intelligenza artificiale: che cos’è ciascuna cosa e come si incastra tutto
2. Breve storia dell’intelligenza artificiale: da Turing ai modelli linguistici
3. Dati, modello, addestramento, inferenza: i concetti di base su un unico esempio
4. Come leggere la notazione matematica: simboli, indici, sommatorie e quantificatori
5. Insiemi e relazioni: i mattoncini con cui si costruiscono le definizioni nell’IA
6. Funzioni e applicazioni: perché ogni modello di IA è una funzione
7. Logica e dimostrazioni: le regole con cui si ragiona nell’IA
8. Grafi e alberi: la struttura su cui poggiano la ricerca e le reti neurali
9. Algebra lineare per l’apprendimento automatico: vettori, matrici e perché l’IA soprattutto moltiplica
10. Derivate, gradiente e regola della catena: come un modello capisce in quale direzione imparare
11. Discesa del gradiente: come impara un modello
12. Che cos’è la probabilità: dal lancio di un dado agli assiomi di Kolmogorov
13. Probabilità condizionata e teorema di Bayes: come cambiare una stima quando scopri qualcosa di nuovo
14. Variabile aleatoria e funzione di ripartizione: una sola funzione che dice tutto sulla distribuzione
15. Funzione di densità e funzione di massa: perché una variabile continua ha probabilità zero in un punto
16. Valore atteso, varianza e covarianza: dove si trova una distribuzione, quanto è larga e che cosa è legato a che cosa
17. Panoramica delle distribuzioni di probabilità: Bernoulli, binomiale, Poisson, uniforme, normale ed esponenziale
18. Legge dei grandi numeri e teorema del limite centrale: perché le medie si comportano in modo così prevedibile
19. Statistica e stima dei parametri: massima verosimiglianza, MAP e intervalli di confidenza
20. Teoria dell’informazione: entropia, entropia incrociata e divergenza KL — da dove vengono le funzioni di perdita
21. Ricerca nello spazio degli stati: BFS, DFS, UCS e A* con animazioni
22. Giochi e avversari: minimax, potatura alfa-beta e Monte Carlo tree search
23. Soddisfacimento di vincoli: backtracking, propagazione dei vincoli e AC-3 su un sudoku e una mappa delle regioni ceche
24. Logica e sistemi basati sulla conoscenza: concatenazione in avanti e all’indietro, risoluzione e sistemi esperti
25. Pianificazione: STRIPS, il mondo dei blocchi, euristiche dal rilassamento e pianificazione negli agenti IA
26. Ricerca locale e ricottura simulata: un commesso viaggiatore tra i capoluoghi di regione cechi
27. Algoritmi genetici: popolazione, incrocio, mutazione e selezione su uno zaino per l’escursione
28. Strategie evolutive e programmazione genetica: dalla regola di un quinto alla legge di Keplero
29. Ottimizzazione con colonie di formiche: come una traccia di feromone trova un percorso breve
30. Ottimizzazione a sciame di particelle: inerzia, esperienza propria ed esperienza dello sciame
31. Neuroevoluzione: evoluzione dei pesi e della forma delle reti neurali e l’algoritmo NEAT
32. Insiemi fuzzy e funzioni di appartenenza: come scrivere «un po’ caldo»
33. Logica fuzzy e probabilità: perché «un po’ caldo» non significa «probabilmente caldo»
34. Logica fuzzy: t-norme, implicazioni e regole SE–ALLORA
35. Controllo fuzzy: Mamdani e Sugeno, dal ventilatore al pendolo inverso su un carrello
36. Clustering fuzzy: l’algoritmo fuzzy c-means e i punti tra i cluster
37. Sistemi neuro-fuzzy (ANFIS): regole fuzzy che imparano dai dati
38. Catene di Markov: matrice di transizione, distribuzione stazionaria e PageRank
39. Modelli di Markov nascosti: l’algoritmo di Viterbi e il casinò disonesto
40. Reti bayesiane: perché l’erba è bagnata e che cosa significa per l’irrigatore
41. Filtro di Kalman: come stimare da misure imprecise dove si trova un’auto e a che velocità va
42. Tipi di apprendimento automatico: supervisionato, non supervisionato, semi-supervisionato e altri
43. Prompt, contesto e RAG: come dare a un modello le informazioni giuste
44. Autoencoder variazionali (VAE): immagini nuove da uno spazio latente continuo
45. Reti generative avversarie (GAN): il falsario contro il detective
46. Modelli di diffusione: come il rumore puro diventa un’immagine
47. Processi decisionali di Markov: stati, azioni, ricompense ed equazioni di Bellman
48. Q-learning e DQN: imparare il valore delle azioni, dalla tabella alla rete neurale
49. Policy gradient e PPO: imparare direttamente la politica
50. Come funziona un agente IA: un modello linguistico in un ciclo con strumenti
51. Programmare con agenti IA: incarico, test e controllo
52. Valutazione e sicurezza dei sistemi di IA: come misurare e come sorvegliare

Programma completo della serie 52 di 83 argomenti pubblicati

Nella parte precedente abbiamo calcolato esattamente la politica migliore, perché conoscevamo le regole del mondo: dove porta ogni azione e con quale probabilità, e che cosa riceve l’agente in cambio. Un agente reale non le conosce. Un robot non sa con precisione quanto gli slitterà la ruota, un programma che gioca a un videogioco non ne conosce l’interno. Deve provare e imparare da ciò che è successo. In questa parte scriveremo due algoritmi di questo tipo: Q-learning con una tabella e DQN, in cui la tabella viene sostituita da una rete neurale — proprio la combinazione con cui nel 2015 DeepMind ha insegnato a un computer a giocare a decine di giochi Atari guardando lo schermo.

Riprende le parti Processi decisionali di Markov e Una rete neurale da zero.

1. Imparare dall’esperienza

Definizione — apprendimento per differenza temporale (TD)

Invece della media su tutti i possibili stati successivi (come nell’equazione di Bellman) si usa una sola transizione effettivamente vissuta (s, a, r, s′). La stima si sposta di un pezzetto verso il target TD r + γ · (stima del valore di s′): stima ← stima + α (target − stima). La differenza target − stima si chiama errore TD, α è il tasso di apprendimento. La stima viene quindi corretta in base a un’altra stima (bootstrapping).

V(s) ← V(s) + α [r + γ V(s′) − V(s)]

V(s)

la stima finora del valore dello stato da cui siamo partiti — è quella che correggiamo; dentro la parentesi viene sottratta, perché la correzione sia proporzionale all’errore, non all’intero valore

α

tasso di apprendimento, 0 < α ≤ 1 — quanta parte dell’errore accettiamo; una singola transizione è un campione casuale, quindi non ci fidiamo del tutto

r

la ricompensa effettivamente ricevuta — l’unica parte del target che è misurata, non stimata

γ

fattore di sconto — il valore dello stato successivo arriva un passo più tardi, proprio come nell’equazione di Bellman

V(s′)

la stima del valore dello stato in cui siamo effettivamente arrivati — rappresenta tutto il futuro che resta e che non abbiamo ancora vissuto (bootstrapping); al posto della media ∑ P(s′ | …) un singolo campione

Esempio — il tragitto per il lavoro in numeri

La stima da casa è V(casa) = 30 minuti. Dopo r = 10 minuti di viaggio sei in coda e la stima da lì è V(coda) = 35. Il tempo non viene scontato (γ = 1) e al posto delle ricompense sommiamo minuti, quindi il target TD è 10 + 35 = 45 e l’errore TD 45 − 30 = 15.

• con α = 0,5: nuova stima 30 + 0,5 · 15 = 37,5 minuti,
• con α = 0,1: 30 + 0,1 · 15 = 31,5 minuti,
• con α = 1: direttamente 45 — l’ultima esperienza sovrascriverebbe completamente tutte quelle precedenti.

Teorema — con α fisso la stima è una media mobile dei target

Se la stima parte da Q₀ e riceve i target c₁, c₂, …, c_n, dopo n correzioni vale Q_n = (1 − α)ⁿ Q₀ + ∑_k=1ⁿ α (1 − α)^n−k c_k.

Dimostrazione. La regola si può riscrivere come Q_n = (1 − α) Q_n−1 + α c_n e sostituire ripetutamente. ∎

I pesi decrescono geometricamente: con α = 0,5 l’ultimo target ha peso 0,5, il penultimo 0,25, quello prima 0,125… Le esperienze più vecchie vengono quindi dimenticate a poco a poco — il che aiuta quando i target cambiano (e nell’apprendimento TD cambiano, perché sono calcolati da stime che a loro volta stanno imparando), ma in un mondo casuale la stima oscilla. Per questo la teoria, per garantire la convergenza, richiede di ridurre α gradualmente.

2. Q-learning

Definizione — Q-learning e SARSA

Il Q-learning (Christopher Watkins, 1989) tiene una tabella Q(s, a) e dopo ogni passo la corregge:

Q(s, a) ← Q(s, a) + α [r + γ · max_a′ Q(s′, a′) − Q(s, a)].

In condizioni ragionevoli (ogni coppia stato–azione viene provata infinite volte, α decresce in modo adeguato) converge al Q* ottimo. SARSA differisce solo nel target: invece del massimo usa Q(s′, a′) per l’azione a′ che l’agente compie davvero. Il Q-learning impara quindi il valore del comportamento migliore, SARSA il valore di come l’agente si comporta davvero, esplorazione compresa.

Q(s, a) ← Q(s, a) + α [r + γ · max_a′ Q(s′, a′) − Q(s, a)]

Q(s, a)

la casella della tabella per l’azione appena provata — si corregge solo quella; le altre azioni in s non sono cambiate, perché questo passo non ha detto nulla su di esse

α

tasso di apprendimento — da noi 0,5: il mondo del precipizio è deterministico, quindi non dobbiamo temere il nuovo target

r

ricompensa per il passo: −1, oppure −100 per una caduta

γ

fattore di sconto — sul precipizio γ = 1, perché l’episodio finisce sempre e ogni passo costa −1, quindi il percorso più breve è migliore anche senza sconto

max_a′ Q(s′, a′)

il valore della migliore azione nel nuovo stato — il Q-learning presume che da lì in poi giocherà al meglio, anche se in realtà ogni tanto prova un’azione casuale; nei grafici qui sotto il Q-learning è color ambra

# Q-learning (e SARSA) sulla camminata sul precipizio
Q(s, a) = 0 per tutti gli stati e le azioni
per ogni episodio:
    s = partenza
    a = azione ε-greedy secondo Q in s
    finché s non è l’arrivo:
        esegui a, osserva r e s′          # caduta: r = −100, s′ = partenza
        a′ = azione ε-greedy secondo Q in s′
        target = max su b di Q(s′, b)    # Q-learning
        target = Q(s′, a′)               # SARSA (al posto della riga sopra)
        if s′ è l’arrivo: target = 0
        Q(s, a) = Q(s, a) + α · (r + γ · target − Q(s, a))
        s = s′;  a = a′

Esempio — le prime cadute (α = 0,5, γ = 1, la tabella parte da zeri)

Subito alla partenza l’agente prova un passo a destra e cade: r = −100, s′ = partenza, dove per ora tutti i valori sono 0. Il nuovo valore è Q(partenza, →) = 0 + 0,5 · (−100 + 1 · 0 − 0) = −50.

Poi prova un passo in su: r = −1, la nuova casella ha solo zeri, Q(partenza, ↑) = 0 + 0,5 · (−1 + 0 − 0) = −0,5.

Quando cade alla partenza per la seconda volta, il valore più alto alla partenza è ancora 0 (le azioni ↓ e ← non le ha ancora provate), e così Q(partenza, →) = −50 + 0,5 · (−100 + 0 − (−50)) = −75. A ogni caduta successiva si avvicina sempre più a −100.

Nota un effetto collaterale: tutte le ricompense reali sono negative, quindi le azioni non provate, con zero, sembrano migliori di quelle provate. Una tabella che parte da zeri spinge da sola l’agente a provare cose nuove (il cosiddetto ottimismo verso l’ignoto) — nella scelta greedy, prima ancora che entri in gioco il caso ε.

Definizione — politica ε-greedy

Con probabilità 1 − ε scegli l’azione con il Q(s, a) più alto, con probabilità ε un’azione casuale. Senza azioni casuali l’agente non proverebbe mai nulla che per ora non gli sembri il meglio, e potrebbe restare bloccato sul primo percorso decente che trova. È la soluzione più semplice al dilemma esplorazione o sfruttamento.

Esempio — le probabilità delle azioni con ε = 0,1

L’azione casuale si sceglie fra tutte le |A| = 4 azioni, quindi anche fra la migliore. Perciò

π(a | s) = 1 − ε + ε/|A| = 1 − 0,1 + 0,025 = 0,925 per l’azione migliore e ε/|A| = 0,1/4 = 0,025 per ciascuna delle altre tre.

Ogni singola azione «sbagliata» — per esempio un passo in giù nel precipizio — capita quindi in un passo su 40.

3. Camminata sul precipizio: Q-learning contro SARSA

Un esperimento classico dal manuale di Richard Sutton e Andrew Barto (cliff walking). Una griglia 12 × 4, partenza in basso a sinistra, arrivo in basso a destra e in mezzo un precipizio. Ogni passo costa −1, la caduta nel precipizio −100 e il ritorno alla partenza. Senza sconto. Il percorso più breve corre rasente al precipizio (13 passi). Entrambi gli algoritmi imparano per 500 episodi con ε = 0,1 e α = 0,5, ciascuno in 50 esecuzioni indipendenti.

Il Q-learning ha imparato il percorso più breve lungo il precipizio in tutte le 50 esecuzioni su 50. SARSA in 41 esecuzioni ha scelto il percorso lungo il bordo superiore della griglia, il più lontano possibile dal precipizio (17 passi), in una un percorso ancora più lungo di due passi e in 8 esecuzioni la politica greedy dopo 500 episodi non arriva ancora all’arrivo — gira in tondo nei punti che l’agente durante l’apprendimento non ha quasi mai raggiunto.

E ora il paradosso: durante l’apprendimento se la cava meglio SARSA. Negli ultimi cento episodi ottiene in media −25,1, il Q-learning −51,1. Il Q-learning cammina sul bordo del precipizio e, siccome un passo su dieci è casuale, cade in media 0,34 volte per episodio; SARSA solo 0,04 volte. Il Q-learning ha imparato che cosa è meglio senza esplorare; SARSA che cosa è meglio esplorando. Quale dei due vogliamo dipende dal fatto che l’agente continui a esplorare anche in produzione — un robot che impara su una macchina vera dovrebbe ragionare come SARSA.

Esempio — quante volte cade il Q-learning (stima semplificata)

Il percorso appreso dal Q-learning va dalla partenza in su e poi per dieci caselle proprio sopra il precipizio. Alla partenza e su ciascuna di quelle dieci caselle nel precipizio porta un passo in giù (alla partenza un passo a destra), cioè una sola azione precisa — con ε = 0,1 con probabilità 0,025. Attraversare 11 caselle così senza cadere:

0,975¹¹ = 0,757, quindi una caduta durante un attraversamento ha probabilità q = 1 − 0,757 = 0,243.

Dopo una caduta l’agente ricomincia dalla partenza, quindi il numero di cadute fino a un attraversamento riuscito ha distribuzione geometrica con valore atteso q / (1 − q) = 0,243 / 0,757 = 0,32 cadute per episodio. Misurato: 0,34 — un po’ di più, perché la stima trascura i passi casuali a sinistra, dopo i quali l’agente passa ancora altri passi sopra il precipizio. SARSA cammina lungo il bordo superiore, tre righe sopra il precipizio: lì la porterebbero nel precipizio solo diversi passi casuali in giù di fila. Rischia soprattutto alla partenza, e già questo dà 0,025 / 0,975 = 0,026 cadute per episodio; misurato: 0,04.

Definizione — apprendimento secondo la propria politica o secondo un’altra (on-policy / off-policy)

Un metodo è on-policy quando impara il valore della stessa politica secondo cui sta agendo (SARSA). È off-policy quando agisce secondo una politica (per esempio ε-greedy), ma impara il valore di un’altra (il Q-learning impara quella greedy). I metodi off-policy possono imparare anche da esperienze raccolte in precedenza o da qualcun altro.

4. Quando la tabella non basta: DQN

Una tabella ha bisogno di una riga per ogni stato. Il pendolo inverso su un carrello della parte sulla neuroevoluzione ha uno stato fatto di quattro numeri reali (posizione e velocità del carrello, angolo e velocità angolare dell’asta); un gioco Atari ha uno stato fatto di uno schermo di 210 × 160 pixel. Nessuna tabella basta. Al suo posto Q(s, a) viene stimato da una rete neurale.

Definizione — Deep Q-Network (DQN)

DQN (Volodymyr Mnih e altri, DeepMind, 2015) stima Q(s, ·) con una rete di parametri θ e minimizza (r + γ max_a′ Q(s′, a′; θ⁻) − Q(s, a; θ))². Due modifiche sono fondamentali: la memoria delle esperienze (replay buffer) — le transizioni vengono salvate e si impara da mini-batch casuali, non dagli ultimi passi uno dopo l’altro; e la rete target θ⁻ (target network) — una copia della rete che viene aggiornata solo ogni tanto, perché il target non si sposti a ogni passo di apprendimento.

L(θ) = E_{(s, a, r, s′) ~ D} [(r + γ max_a′ Q(s′, a′; θ⁻) − Q(s, a; θ))²]

E_{… ~ D}

media su transizioni casuali dalla memoria delle esperienze D — mescola esperienze vecchie e nuove, così i passi consecutivi, molto simili tra loro, non trascinano la rete in un’unica direzione

r

ricompensa — sul carrello +1 per ogni passo in cui l’asta sta in piedi

γ

fattore di sconto 0,99 — la rete «vede» circa 1/(1 − γ) = 100 passi avanti

max Q(s′, a′; θ⁻)

il target dalla rete target con i parametri congelati θ⁻ — lo stesso massimo del Q-learning tabellare, solo che durante il passo di apprendimento non si muove; quando lo stato s′ significa caduta, questo termine è 0

Q(s, a; θ)

la stima della rete in addestramento per l’azione compiuta davvero — l’unica cosa che cambia durante il passo di apprendimento (il gradiente passa solo per θ)

Definizione — perdita di Huber

Invece del quadrato dell’errore d = Q(s, a; θ) − target, il nostro DQN usa (come l’articolo originale, che tronca l’errore a ±1) la perdita di Huber H(d) = d²/2 per |d| ≤ 1 e |d| − 1/2 altrimenti. La sua derivata è d al centro e ±1 fuori: gli errori piccoli si correggono come con il quadrato, un errore grande (per esempio quando il target salta dopo la copia della rete target) dà al massimo un gradiente unitario e una sola transizione strana non manda la rete fuori strada.

# DQN sul pendolo inverso su un carrello
rete Q(·; θ) 4 → 64 → 64 → 2, rete target θ⁻ = θ, memoria D vuota
s = partenza casuale
per t = 1 … 30 000:
    ε = max(0,05; 1 − 0,95 · t / 10 000)
    a = azione casuale con probabilità ε, altrimenti argmax Q(s, ·; θ)
    esegui a, osserva s′ e se l’asta è caduta
    salva (s, a, r = 1, s′, caduta) in D      # oltre 20 000 esce la più vecchia
    s = nuova partenza se l’asta è caduta o ha resistito 500 passi, altrimenti s′
    da D estrai un mini-batch casuale di 32 transizioni, per ciascuna:
        target = r,                          se è caduta
        target = r + γ · max Q(s′, ·; θ⁻),   altrimenti
    un passo di Adam sulla perdita di Huber media (Q(s, a; θ) − target)
    ogni 500 passi: θ⁻ = θ

Esempio — l’esplorazione e la grandezza dei valori

L’esplorazione cala linearmente: ε₀ = 1 (solo azioni casuali), al passo 5 000 è ε = 1 − 0,95 · 0,5 = 0,525 e dal passo 10 000 resta 0,05.

Quanto sono grandi i valori che la rete deve imparare? Se l’asta restasse in piedi per sempre, il valore sarebbe 1 + 0,99 + 0,99² + … = 1/(1 − 0,99) = 100; per un episodio limitato a 500 passi è (1 − 0,99⁵⁰⁰)/(1 − 0,99) = 99,3. All’inizio la rete restituisce numeri vicini allo zero, quindi i target durante l’apprendimento devono crescere di due ordini di grandezza — e con loro continuano a spostarsi.

Il nostro DQN: rete 4 → 64 → 64 → 2 (due azioni: spingere a sinistra o a destra), ricompensa +1 per ogni passo in cui l’asta sta in piedi, γ = 0,99, memoria da 20 000 transizioni, mini-batch da 32, la rete target viene copiata ogni 500 passi, ε cala da 1 a 0,05 nei primi 10 000 passi. In tutto 30 000 passi. Ogni 2 500 passi misuriamo per quanti passi resiste la politica greedy (media su quattro partenze, al massimo 500, cioè 10 secondi).

Il DQN completo impara a tenere in piedi l’asta per tutti i 500 passi — nell’esecuzione con seme 1 per la prima volta al passo 17 500. Ma subito dopo lo dimentica: alla fine dell’apprendimento la tiene solo per 110 passi. La seconda esecuzione oscilla in modo simile. Senza memoria delle esperienze (impara solo dagli ultimi 32 passi) la rete non supera 192. E senza rete target l’apprendimento crolla del tutto: la politica resiste per tutto il tempo solo 9 passi — esattamente quanto resiste un carrello che spingi sempre a destra. La rete ha «imparato» una sola azione.

5. Perché DQN è così capriccioso

Definizione — triade mortale (deadly triad)

Sutton e Barto chiamano così la combinazione di tre elementi: approssimazione di funzione (una rete al posto della tabella), bootstrapping (il target si calcola dalla propria stima) e apprendimento off-policy. Ciascuno da solo è sicuro; insieme possono far oscillare o divergere l’apprendimento. DQN li contiene tutti e tre — la memoria delle esperienze e la rete target si limitano ad attenuare il pericolo.

In pratica si aggiunge quindi tutta una serie di modifiche: Double DQN (Hado van Hasselt e altri, 2015) separa la scelta dell’azione migliore dalla sua valutazione e attenua la sovrastima sistematica che il massimo nel target porta con sé; poi la memoria con priorità, la separazione tra valore e vantaggio (dueling) e altre ancora — la loro combinazione si chiama Rainbow (2017). E un consiglio del tutto pratico: durante l’apprendimento salva la rete della misura migliore, non l’ultima.

y = r + γ Q(s′, argmax_a′ Q(s′, a′; θ); θ⁻)

r

ricompensa, invariata

γ

fattore di sconto, invariato

argmax Q(s′, a′; θ)

scelta dell’azione da parte della rete in addestramento — quale azione sceglieremmo in s′

Q(s′, …; θ⁻)

valutazione di quell’azione da parte della rete target — un’altra stima con altri errori, così un’azione che la rete in addestramento ha sopravvalutato per caso non riceve automaticamente anche un valore sopravvalutato

Esempio — perché il massimo sovrastima (in modo semplificato)

Due azioni hanno valore reale 0, ma la stima di ciascuna è affetta da un errore indipendente di +1 oppure −1 (entrambi con probabilità 1/2). Le quattro possibilità ugualmente probabili danno come massimo delle stime 1, 1, 1 e −1, quindi

E[max(Q̂₁, Q̂₂)] = (1 + 1 + 1 − 1)/4 = 0,5 > 0 = max(Q₁, Q₂).

Il massimo su stime rumorose è in media più grande del massimo dei valori reali, e poiché il target con il massimo viene sostituito ancora e ancora, la sovrastima si propaga. Se l’azione la sceglie una stima e la valuta un’altra, indipendente, il valore atteso della valutazione è 0 — l’errore della seconda stima non ha più nulla a che fare con la scelta.

I metodi basati sul valore come DQN funzionano bene quando le azioni sono poche (spingere a sinistra o a destra; i tasti di un controller). Per le azioni continue — con quanta forza ruotare un giunto del robot — conviene imparare direttamente la politica. È il tema della prossima parte, sul policy gradient e su PPO.

6. Riepilogo

• Senza conoscere le regole del mondo, i valori si imparano dalle transizioni vissute: la stima si sposta verso il target r + γ · stima dello stato successivo.
• Il Q-learning impara il valore del comportamento migliore (off-policy), SARSA il valore del comportamento con l’esplorazione (on-policy).
• Sul precipizio: il Q-learning trova il percorso più breve (13 passi), ma con ε = 0,1 cade 0,34 volte per episodio; SARSA va più sul sicuro e durante l’apprendimento ottiene di più (−25,1 contro −51,1).
• DQN sostituisce la tabella con una rete; senza memoria delle esperienze e senza rete target non impara (al massimo 192 e 9 passi rispettivamente).
• Anche il DQN completo oscilla: tiene l’asta per 500 passi e poi lo dimentica di nuovo — la triade mortale.

Vuoi metterci le mani? Chiedi a un agente IA di addestrare un DQN sull’ambiente CartPole della libreria Gymnasium e di disegnare la curva di apprendimento per cinque semi. Poi fagli aggiungere Double DQN e confrontare.

La vedi diversamente? Scrivi a support@coden-app.com.