AlphaGo 2016: deep RL e Monte Carlo Tree Search al vertice del Go

10 marzo 2016, hotel Four Seasons di Seoul, seconda partita del match Lee Sedol contro AlphaGo. A metà del medio gioco, il programma di DeepMind appoggia una pietra in posizione 5-quinta linea sul lato destro: una shoulder hit. Nei sette secoli di teoria moderna del Go, la quinta linea in apertura di metà gioco non si gioca. Si entra di terza o quarta, perché la quinta cede troppo influenza sui propri pezzi e non guadagna abbastanza territorio. Fan Hui, campione europeo battuto cinque mesi prima dalla stessa macchina e ora consulente DeepMind, guarda lo schermo e dice una parola sola: “Apollo.” Nello studio di commento accanto, Michael Redmond, unico Grandmaster occidentale 9-dan, esita: “I’m not sure that’s a good move”. Cinquanta mosse dopo, la pietra alla quinta linea è il fulcro di una struttura che decide la partita. È la mossa 37 di AlphaGo. Diventerà l’icona di un cambiamento di paradigma.

Perché questo capitolo

Tra il gennaio 2016 e il dicembre 2018 un gruppo di DeepMind (laboratorio londinese di ricerca AI fondato nel 2010 da Demis Hassabis, Shane Legg e Mustafa Suleyman, acquisito da Google nel gennaio 2014 per circa 500 milioni di dollari) pubblica una sequenza di tre paper su Nature e Science che riscrivono lo stato dell’arte nei giochi di scacchiera. Il primo (gennaio 2016) descrive AlphaGo, un sistema che combina deep neural networks, Monte Carlo Tree Search e self-play. Il secondo (ottobre 2017) descrive AlphaGo Zero, una versione che impara senza vedere una sola partita umana. Il terzo (dicembre 2018) descrive AlphaZero, lo stesso framework esteso a scacchi e shogi. Tra il primo e il secondo paper, in mezzo, il match dei sei giorni di marzo 2016 a Seoul: AlphaGo batte Lee Sedol (giocatore di Go sudcoreano, 1983-, 9-dan professionista, considerato uno dei più forti giocatori del decennio 2000-2010, vincitore di 18 titoli internazionali) per 4 partite a 1.

Questo capitolo conta per tre ragioni diverse. La prima è di portata tecnica: AlphaGo è il primo sistema in cui la combinazione di tre ingredienti — reti neurali profonde per policy e value, Monte Carlo Tree Search guidato da quelle reti, training tramite self-play partendo da pre-training supervisionato — viene fatta funzionare a scala sufficiente per dominare un dominio considerato la frontiera ultima dei giochi a informazione perfetta. Il Go aveva resistito quarant’anni di tentativi; lo aveva fatto perché, a differenza degli scacchi, non si presta né alla brute force (lo spazio degli stati è troppo grande) né a una funzione di valutazione esplicita scritta a mano (la posizione si valuta per influenza, struttura, tempo, concetti che gli umani percepiscono come pattern visivi e che nessuno è riuscito a codificare in modo sistematico). AlphaGo dimostra che entrambi i muri si abbattono insieme: la rete neurale fornisce la valutazione, la rete neurale guida la ricerca, la ricerca compensa l’imprecisione locale della rete. Nessuno dei tre ingredienti, preso da solo, era nuovo. La novità è la fusione.

La seconda ragione è di portata storica. Tra il td-gammon-1992, che dimostra “rete neurale + RL + self-play” su backgammon ma resta un risultato isolato per ventiquattro anni, e dqn-atari-2013, che porta deep RL al video gaming ma con risultati che variano da super-umani a mediocri secondo il gioco, AlphaGo chiude il filone con un’evidenza che la comunità non può più ignorare: deep reinforcement learning combinato a search funziona, su un dominio dove la posta in gioco è massima e l’esito è pubblico e non discutibile. Da qui in avanti la filiazione è documentata in modo esplicito: AlphaGo (2016) → AlphaGo Zero (2017, niente dati umani) → AlphaZero (2017, multi-game) → MuZero (2020, impara anche le regole del gioco) → AlphaFold (2020, struttura delle proteine) → AlphaCode (2022, programmazione competitiva) → AlphaTensor (2022, scoperta di algoritmi). Una catena di lavori dello stesso gruppo che applica lo stesso schema concettuale — modello profondo + ricerca + auto-miglioramento — a problemi sempre più aperti.

La terza ragione è culturale. Il Game 1 del match Lee Sedol viene visto in diretta da circa 280 milioni di spettatori cinesi, secondo le stime della China Central Television. Il documentario AlphaGo di Greg Kohs (2017) cattura l’evento e lo distribuisce a un pubblico globale. Lee Sedol annuncerà nel novembre 2019 il proprio ritiro dal Go professionistico, citando in interviste pubbliche l’esistenza di un’AI imbattibile come motivo principale della decisione: “Anche se diventassi numero uno al mondo, ci sarebbe sempre un’entità che non potrei battere”. Il match di Seoul entra nella memoria pubblica come “il giorno in cui l’AI ha battuto un campione di Go”, una formula che fa il paio con il “il giorno in cui il computer ha battuto Kasparov a scacchi” del 1997 (vedi deep-blue-1997). Ma a differenza di Deep Blue, dietro AlphaGo c’è un paradigma — deep learning + RL + search — che non resta confinato a un dominio ma diventa una ricetta esportabile. Il filone “AlphaX” che ne segue è la testimonianza diretta.

Contesto

Il Go come problema di calcolo

Il Go (cinese weiqi, giapponese igo, coreano baduk) è un gioco di scacchiera per due giocatori, di origine cinese, attestato da almeno 2500 anni. Si gioca su una griglia di 19x19 intersezioni con pietre bianche e nere. A turno, ogni giocatore appoggia una pietra su un’intersezione vuota; le pietre non si muovono più una volta posate. Una pietra (o un gruppo di pietre connesse) si cattura quando tutte le sue intersezioni adiacenti vuote (le “libertà”) vengono occupate dall’avversario. Lo scopo è circondare territorio e catturare pietre nemiche; vince chi alla fine controlla più territorio (somma di intersezioni vuote circondate, più pietre catturate). Le regole occupano una pagina; la teoria del gioco copre biblioteche.

Per chi pensa in termini di intelligenza artificiale, il Go ha tre proprietà che lo rendono brutalmente più difficile degli scacchi.

Vale la pena dare prima qualche regola in più, perché chi non ha mai giocato a Go fa fatica a capire perché una rete neurale 19x19 sia un problema così difficile rispetto a un tavoliere 8x8 di scacchi. Le pietre, una volta posate, non si muovono: si possono solo aggiungere altre pietre o subire la cattura. Questo significa che la complessità non viene dalla mobilità (come negli scacchi, dove la donna fa molti danni perché si muove in molti modi), ma dalla costruzione progressiva di una struttura. Una pietra isolata vale poco; due pietre vicine ne valgono molto di più; un gruppo di dieci pietre disposte male può essere distrutto in due mosse. Il valore di una pietra non è locale: dipende da come si combina con le altre, presenti e future. Inoltre la regola del ko (non si può ripetere immediatamente la posizione precedente) introduce sottigliezze tattiche che cambiano il computo locale. E la regola del seki (situazioni di vita reciproca in cui due gruppi nemici sono entrambi vivi senza territorio) genera posizioni dove le euristiche statiche cedono. Il giocatore deve riconoscere “vita” e “morte” dei gruppi, concetti che richiedono ricerca tattica non banale ma che sono percepiti dagli umani come pattern visivi quasi istantanei. Un programma deve fare questa ricerca esplicitamente, e farla per ogni gruppo a ogni mossa è proibitivo.

La prima è la dimensione dello spazio degli stati. Una stima conservativa attribuisce al Go circa $10^{170}$ posizioni legali raggiungibili (Tromp, 2016), contro circa $10^{46}$ degli scacchi. La differenza è di 124 ordini di grandezza. Per dare scala: il numero di atomi nell’universo osservabile è stimato in circa $10^{80}$. Il Go ha più posizioni di quanti atomi esistano, elevato a due. Brute force totale: impossibile per definizione.

La seconda è il branching factor. A ogni turno, una posizione tipica di Go ha circa 250 mosse legali (contro circa 35 negli scacchi). Esplorare in alpha-beta minimax (vedi deep-blue-1997) anche solo a profondità 4 significa visitare $250^4 \approx 4$ miliardi di nodi, contro i $35^4 \approx 1.5$ milioni degli scacchi. La differenza per ply esplorato è di tre ordini di grandezza.

La terza, e la più subdola, è la mancanza di una funzione di valutazione naturale. Negli scacchi, una valutazione di partenza ragionevole esiste: si conta il valore dei pezzi (pedone 1, cavallo 3, alfiere 3, torre 5, donna 9), si aggiunge un termine per la posizione, e si ha già un giocatore di livello amatoriale forte. Nel Go non esiste niente di analogo. Le pietre non hanno valore intrinseco; valgono per il loro ruolo nella struttura globale della posizione. Un gruppo isolato di tre pietre può essere debole e destinato alla cattura (valore: zero o negativo); lo stesso gruppo collegato a un muro vicino può essere il fulcro di un’invasione decisiva (valore: enorme). La valutazione richiede di “vedere” la posizione come un tutto, riconoscere influenza, struttura, tempo, ko, sente, gote — concetti che i forti giocatori usano per spiegare le proprie mosse ma che nessun ingegnere è riuscito a codificare in regole esplicite. Il Go è il dominio della pattern recognition visiva applicata a un tavoliere.

Nel 1997, all’indomani della vittoria di Deep Blue su Kasparov, diversi commentatori e ricercatori AI avevano predetto che il Go avrebbe richiesto “almeno cento anni” prima che un programma battesse un campione del mondo. Astro Teller, in un’intervista del 1998 ripresa più volte negli anni successivi, parlava di sistemi “fondamentalmente più sofisticati di qualsiasi cosa esista oggi”. La predizione si è sbagliata di 81 anni.

Vale la pena spendere un altro paragrafo sull’aspetto cognitivo, perché spiega perché la valutazione di posizione non era un problema risolvibile con knowledge engineering. Studi degli anni 70-80 sul Go di alto livello, in particolare i lavori di Yasuki Saito e altri psicologi cognitivi giapponesi, hanno mostrato che i forti giocatori di Go usano massicciamente la percezione visiva del tavoliere: riconoscono pattern globali in tempi nell’ordine di centinaia di millisecondi, prima di iniziare il calcolo tattico locale. Un master umano “vede” che un gruppo è in pericolo o in salute prima di leggere le sequenze esatte; questo riconoscimento globale guida poi la ricerca selettiva. Il knowledge engineering classico — codificare regole tipo “un gruppo con due occhi è vivo”, “un gruppo con una sola libertà è atari” — copriva i pattern triviali ma non scalava ai pattern complessi. Le CNN risolveranno esattamente questo: imparare a riconoscere pattern visivi globali nel tavoliere senza dover codificare regole esplicite. Era il problema giusto per il deep learning, e la coincidenza temporale (CNN profonde 2012, batch normalization 2015, ResNet 2015) è quella che rende possibile AlphaGo nel 2016 e non dieci anni prima.

Predecessori: dal knowledge engineering a MCTS

Dagli anni 70 fino ai primi 2000, i programmi di Go erano dominati dal paradigma simbolico. GNU Go (progetto open source iniziato nel 1989) e Many Faces of Go (David Fotland, anni 80) erano costruiti su euristiche scritte a mano: regole per riconoscere occhi, gruppi vivi e morti, pattern locali (joseki memorizzati nell’angolo), valutazione di territorio per influenza calcolata con propagazione numerica. Il livello massimo raggiunto era circa 5-8 kyu amatoriale, l’equivalente di un giocatore di club ma molto distante dai professionisti.

Il primo cambiamento sostanziale arriva nel 2006 con il Monte Carlo Tree Search. Rémi Coulom (informatico francese, allora professore associato all’Université Lille 3) pubblica nel 2006 al congresso Computers and Games a Torino il paper “Efficient Selectivity and Backup Operators in Monte-Carlo Tree Search”, che descrive il programma Crazy Stone. L’idea di MCTS, in versione moderna, era stata germinata indipendentemente da Coulom e da Levente Kocsis e Csaba Szepesvári (che pubblicano “Bandit based Monte-Carlo Planning” all’ECML 2006 introducendo la formula UCT). La ricetta è semplice nel principio: anziché valutare le posizioni con una funzione esplicita, si stimano i valori giocando moltissime partite casuali fino in fondo dalla posizione corrente (i “rollouts”), e si usa la frazione di vittorie come stima di valore. La ricerca ad albero seleziona le mosse da espandere in modo adattivo, bilanciando esplorazione di mosse poco visitate (per ridurre l’incertezza) e sfruttamento di mosse promettenti (per concentrare il calcolo dove serve).

MCTS rompe il muro perché non richiede una funzione di valutazione costruita a mano. Le partite casuali producono un segnale rumoroso ma non distorto: in media, le mosse buone portano più frequentemente a vittoria. Aggregando milioni di rollout, l’errore stocastico diminuisce. Tra il 2006 e il 2012 i programmi MCTS dominano il computer Go: Crazy Stone, MoGo (Sylvain Gelly e collaboratori a Inria), Pachi (Petr Baudiš, open source, attivo dal 2007), Zen (Yoji Ojima, in commercio in Giappone). Il livello massimo sale a circa 1-2 dan amatoriale forte; con handicap di 4 pietre, alcuni programmi battono giocatori professionisti. Senza handicap, restano ancora sotto il livello pro.

Vale la pena ricordare anche un primo tentativo, fallito, di applicare reti neurali al Go. Nicol Schraudolph, Peter Dayan e Terrence Sejnowski pubblicano nel 1994 al congresso NIPS “Temporal Difference Learning of Position Evaluation in the Game of Go”, in cui addestrano una piccola rete neurale a stimare il valore delle posizioni di Go con TD-learning, sulla scia di TD-Gammon. Il sistema raggiunge un livello rudimentale (circa 25 kyu, il livello di un principiante che ha imparato le regole da poche settimane), molto al di sotto del livello dei programmi simbolici dell’epoca. Il fallimento si spiega in retrospettiva con tre fattori: la rete era troppo piccola (poche centinaia di neuroni invece dei milioni di parametri di una CNN profonda moderna), l’architettura non sfruttava la struttura 2D del tavoliere (era una rete fully-connected, non convoluzionale), e il dataset di training (partite di self-play di un sistema debole) non aveva qualità sufficiente. Tutti e tre i problemi vengono risolti contemporaneamente vent’anni dopo. Il fatto che TD-learning su Go fallisse nel 1994 non era un argomento contro il paradigma; era un argomento contro applicarlo prima che gli ingredienti tecnologici fossero pronti. La storia del Schraudolph 1994 è un caso istruttivo per chi vuole capire la differenza tra “idea sbagliata” e “idea giusta nel momento sbagliato”.

Nel 2008 David Silver stesso, da dottorando ad Alberta sotto Sutton, pubblica con Sutton e Müller “Sample-based Learning and Search with Permanent and Transient Memories” (ICML 2008), e poco dopo “Move Prediction in Computer Go” (NIPS 2008 workshop), in cui addestra reti neurali a predire la mossa di un giocatore esperto a partire da pattern locali. È un risultato di nicchia ma getta le fondamenta tecniche del lavoro che farà a DeepMind otto anni dopo.

L’idea di combinare reti neurali a MCTS circola dai primi anni 2010. Christopher Maddison, Aja Huang, Ilya Sutskever e David Silver pubblicano nel dicembre 2014 “Move Evaluation in Go Using Deep Convolutional Neural Networks” (arXiv:1412.6564), il primo lavoro in cui una CNN viene addestrata in modo supervisionato su milioni di posizioni etichettate con la mossa scelta da un giocatore esperto, e raggiunge accuratezza top-1 del 55% nel predire la mossa umana — un valore impressionante. Nel marzo 2015 Christopher Clark e Amos Storkey (Edinburgh, “Training Deep Convolutional Neural Networks to Play Go”) replicano e raffinano il risultato. Nel novembre 2015 il gruppo di Yuandong Tian a Facebook AI Research pubblica “Better Computer Go Player with Neural Network and Long-term Prediction” (DarkForest), che combina CNN per move prediction e MCTS rudimentale, raggiungendo livello 5d KGS. Sono tutti passi nella stessa direzione, ma nessuno integra le reti in MCTS a sufficienza per battere un professionista.

DeepMind, Silver, Hassabis

DeepMind nasce a Londra nel 2010. Demis Hassabis (informatico, neuroscienziato e imprenditore britannico, 1976-, ex enfant prodige degli scacchi, creatore di videogame negli anni 90 con Bullfrog Productions, PhD in cognitive neuroscience all’University College London nel 2009 sotto Eleanor Maguire) cofonda l’azienda con Shane Legg (matematico-informatico neozelandese, PhD su definizioni formali di intelligenza con Marcus Hutter) e Mustafa Suleyman (imprenditore britannico). L’azienda viene acquisita da Google nel gennaio 2014; cifra ufficialmente non confermata, stime nell’intervallo 400-650 milioni di dollari. Una delle condizioni dell’acquisizione, secondo dichiarazioni successive di Hassabis, è la creazione di un comitato etico sull’AI presso Google: un dettaglio storicamente rilevante, ma rimasto poco trasparente nei suoi esiti effettivi.

David Silver (informatico britannico, 1976-) è il primo autore del paper AlphaGo. Compagno di studi a Cambridge proprio di Hassabis nei primi anni 90, Silver lavora prima nell’industria (cofondatore di Elixir Studios, azienda di videogame fondata con Hassabis) e poi torna in accademia, completando il PhD all’Università dell’Alberta nel 2009 sotto la supervisione di Richard Sutton, padre del reinforcement learning. La sua tesi, “Reinforcement Learning and Simulation-Based Search in the Game of Go”, anticipa i temi che maturerà a DeepMind. Silver entra in DeepMind al momento della fondazione e diventa il leader tecnico del filone “deep RL applicato a giochi”. Diventerà poi professore allo University College London, mantenendo l’affiliazione DeepMind. Dopo AlphaGo guiderà i lavori su AlphaZero, MuZero, e parte di AlphaFold.

Aja Huang (informatico taiwanese), co-primo autore del paper, era già esperto di Go computazionale prima di entrare in DeepMind: aveva contribuito al programma Erica, un MCTS Go classico, e aveva un dottorato sull’argomento all’Università Nazionale di Taiwan Normale. È la figura di raccordo tra la comunità computer Go pre-deep-learning e DeepMind. Sarà Huang ad appoggiare fisicamente le pietre sulla scacchiera durante il match Lee Sedol, eseguendo le mosse decise dal computer remoto.

Il team AlphaGo nel paper Nature del 2016 conta 20 autori. Tra di loro vale la pena segnalare anche Julian Schrittwieser (futuro autore principale di MuZero), Ioannis Antonoglou, Karen Simonyan (co-autore della VGG, vedi resnet-2015), e Thore Graepel.

Il match Fan Hui, ottobre 2015

Prima del match pubblico contro Lee Sedol, AlphaGo gioca un match privato nell’ottobre 2015 a Londra contro Fan Hui (giocatore di Go cinese-francese, 1981-, professionista 2-dan, all’epoca campione europeo per tre anni consecutivi). Cinque partite a tempo standard di torneo, condizioni formali, arbitri ufficiali. AlphaGo vince 5-0. È la prima volta che un programma batte un giocatore professionista di Go in un match a tempo normale, senza handicap. Il match resta segreto fino alla pubblicazione del paper Nature il 27 gennaio 2016, quando viene rivelato simultaneamente alla descrizione tecnica del sistema. Fan Hui rimane in contatto con DeepMind e diventa consulente del team in vista del match Lee Sedol.

Lee Sedol, contattato dopo l’annuncio, accetta la sfida con relativa sicurezza. In una conferenza stampa a Seoul nel febbraio 2016 dichiara di aspettarsi una vittoria 5-0 o 4-1. La sua valutazione è basata in parte sulle partite di Fan Hui pubblicate con il paper, che mostrano un AlphaGo forte ma con errori che un giocatore di livello pro avrebbe punito.

Figura in preparazione

Computer Go timeline 1989-2017. Horizontal axis with markers and brief annotations: GNU Go (1989, ~5 kyu), Many Faces of Go (1990s, ~3 kyu), Crazy Stone first version (2006, MCTS pure, 1d), MoGo (2007), Pachi (2008), DarkForest (Nov 2015, FAIR, ~5d KGS), AlphaGo Fan (Oct 2015 vs Fan Hui, won 5-0), AlphaGo Lee (Mar 2016 vs Lee Sedol, won 4-1), AlphaGo Master (Jan 2017, 60-0 online), AlphaGo Zero (Oct 2017, no human data), AlphaZero (Dec 2017). Above the line: red horizontal band representing “amateur dan ceiling”, “professional ceiling”, “top human ceiling” rising from ~5 kyu through ~5 amateur dan to professional 9 dan. Clean editorial style, English labels

L’intuizione

Angolo architetturale: due reti che parlano a un albero

La prima intuizione di AlphaGo è strutturale. Il problema con MCTS puro è che, in un gioco con branching 250 e profondità tipica di 150-200 mosse a partita, il numero di rollout necessari per una stima ragionevole di una posizione è enorme. Ogni rollout costa tempo, e il numero di simulazioni effettuabili nel budget di pochi secondi per mossa è limitato. Senza guida, MCTS spreca calcolo esplorando mosse che un esperto scarterebbe a vista, e fa rollout casuali che non somigliano a partite vere e quindi forniscono stime distorte.

L’intuizione di AlphaGo è inserire due reti neurali nel ciclo di MCTS, ciascuna con un ruolo distinto.

La prima è la policy network, una CNN che data una posizione produce una distribuzione di probabilità sulle mosse legali, indicando quali sono le più “umanamente plausibili”. Inserita in MCTS, la policy network agisce come prior: l’algoritmo di selezione dei nodi da espandere preferisce le mosse con prior alto, e dedica meno tempo a quelle con prior basso. In pratica, la rete riduce il branching factor effettivo da 250 a poche decine di mosse plausibili. L’effetto è quello di tagliare via gli interi rami che un giocatore esperto non considererebbe nemmeno.

La seconda è la value network, una CNN che data una posizione produce una stima scalare della probabilità di vittoria per il giocatore di turno. Inserita in MCTS, la value network sostituisce (o integra) i rollout casuali al momento di valutare una posizione. Anziché simulare migliaia di partite casuali fino in fondo, basta interrogare la rete: la stima è immediata e, se la rete è abbastanza accurata, è migliore di quella prodotta da rollout casuali — perché i rollout casuali non somigliano a partite umane forti, e quindi il loro esito non è rappresentativo della vera probabilità di vittoria.

Le due reti riducono separatamente le due dimensioni dell’esplosione combinatoria di MCTS: la policy riduce il branching (quante mosse considerare a ogni nodo), la value riduce la profondità (quanto in giù scendere prima di poter valutare una posizione). Senza nessuna delle due, MCTS è limitato a giocatori amatoriali forti. Con entrambe, opportunamente integrate, si arriva al livello del campione del mondo. Il punto chiave è che nessuna delle due reti, da sola, sostituisce il search: la policy network suggerisce mosse plausibili ma può sbagliare le valutazioni tattiche locali; la value network stima la posizione ma può sbagliare in punti tattici stretti dove poche mosse cambiano radicalmente l’esito. MCTS compensa entrambe verificando le suggestioni con simulazioni e backup. Le tre componenti — policy, value, search — sono in equilibrio.

Angolo dell’apprendimento: imitazione, poi auto-superamento

La seconda intuizione riguarda come addestrare quelle due reti. AlphaGo usa una pipeline a tre fasi che combina supervised learning, reinforcement learning e auto-generazione di dati. È una struttura che diventerà uno schema ricorrente nel deep RL successivo.

La prima fase è supervised learning sulla mossa umana. Si raccoglie un dataset enorme — circa 30 milioni di posizioni provenienti dal server di Go online KGS, ciascuna etichettata con la mossa giocata in quella posizione da un giocatore di livello dan amatoriale forte (KGS 6-9 dan) — e si addestra una CNN a predire la mossa scelta dal giocatore. Il segnale di training è classificazione: 361 classi possibili (le intersezioni del 19x19), una sola corretta per ogni esempio. Dopo il training, la rete predice correttamente la mossa umana il 57% delle volte (top-1 accuracy). È la policy SL, $p_{\sigma}$.

La seconda fase è reinforcement learning con self-play. Si parte dalla policy SL, si crea una copia della rete, e si fanno giocare le due copie l’una contro l’altra in milioni di partite. Il segnale di reward è binario: +1 per la vittoria, -1 per la sconfitta, niente reward intermedio. L’aggiornamento usa policy gradient (vedi policy-gradient, in preparazione, in Parte V): aumentare la probabilità delle mosse giocate nelle partite vinte, diminuirla nelle partite perse. Per evitare di restare incastrati su un singolo avversario e generare il fenomeno del “rock-paper-scissors” (cicli di battiti reciproci), si tiene un pool di versioni precedenti della rete e si gioca contro versioni casualmente scelte dal pool. Il risultato è la policy RL, $p_{\rho}$, che batte la policy SL nell’80% delle partite e batte Pachi (il miglior MCTS open source dell’epoca) nell’85% delle partite, senza usare alcun search.

La terza fase è l’addestramento della value network. Si genera un nuovo dataset auto-prodotto: 30 milioni di posizioni estratte da partite di self-play della policy RL, ciascuna etichettata con il risultato finale (+1 o -1). Si addestra una CNN a predire il risultato dalla posizione, in modalità regressione (output scalare in [-1, 1]). È la value network, $v_{\theta}$. Per evitare overfitting (la rete potrebbe imparare a riconoscere posizioni specifiche del set di training), si genera ogni posizione da una partita diversa, sampling un singolo timestep per partita. La rete impara a generalizzare la valutazione.

L’intuizione di alto livello è: la rete bootstrap dal pattern umano (fase 1), poi si raffina attraverso self-play (fase 2), poi genera i dati per addestrare il proprio valutatore (fase 3). Niente in questa pipeline richiede di scrivere a mano una funzione di valutazione del Go. Tutta la conoscenza del dominio è nelle 30 milioni di posizioni KGS iniziali; il resto emerge dal gioco. È una versione moderna e a scala di td-gammon-1992, aggiornata con CNN profonde e MCTS.

C’è un dettaglio sottile sulla scelta del bootstrap supervisionato. In linea di principio, uno potrebbe partire da pesi casuali e fare solo self-play sin dall’inizio. Il problema, per AlphaGo nel 2016, era che il self-play da pesi casuali parte da partite completamente assurde (mosse a caso), e la value network che ne nasce è praticamente inutile come prior per MCTS. Servirebbe un numero enorme di partite di self-play per arrivare a un livello decente. Il bootstrap supervisionato sui dati umani accelera enormemente questa fase iniziale: la policy SL parte già a livello dan amatoriale forte, e da lì il self-play può raffinare invece di costruire da zero. Solo nel 2017, con Zero, DeepMind dimostrerà che a sufficiente compute il bootstrap umano si può eliminare. Questo è importante per chi legge la storia in retrospettiva: la scelta del 2016 era pragmatica, non ideologica. Si partiva da dati umani perché era la via più rapida verso un risultato pubblicabile, non perché si credesse che i dati umani fossero indispensabili.

Figura in preparazione

Two intuitions side by side. Left panel “Policy and value networks reduce MCTS explosion”: diagram showing MCTS tree with branching 250, then a “policy network” arrow narrowing it to top-k candidates (~10), then a “value network” arrow truncating depth from full rollout to a single evaluation. Caption “policy reduces breadth, value reduces depth”. Right panel “Three-phase training pipeline”: three boxes left to right — “30M KGS positions → supervised → policy SL”, “self-play of policy SL copies → policy gradient → policy RL”, “self-play of policy RL → outcome labels → value network”. Caption “imitate, then self-play, then auto-evaluate”. Clean editorial style, English labels

La meccanica

Le quattro reti

Il paper Nature di gennaio 2016 descrive in realtà quattro reti distinte, non due. Le ulteriori due servono dentro MCTS per accelerare i rollout.

• Policy SL ($p_{\sigma}$): CNN profonda con 13 layer convoluzionali, kernel 3x3 o 5x5, 192 filtri per layer, ReLU come non-linearità. Input: la posizione di Go rappresentata come tensore 19x19x48 (48 canali che codificano colore, libertà del gruppo, possibili catture, mosse di ko, eccetera, calcolati a partire dalla posizione bruta). Output: distribuzione softmax sulle 361 intersezioni. Addestrata su 30 milioni di posizioni KGS, raggiunge 57% top-1 accuracy. Tempo di forward pass: circa 3 millisecondi su una GPU del 2015.

• Policy Rollout ($p_{\pi}$): una rete molto più piccola, lineare con poche feature handcrafted (pattern locali 3x3, distanza dalla mossa precedente, eccetera). Accuracy: 24% (molto inferiore alla policy SL), ma tempo di forward pass: 2 microsecondi. È mille volte più veloce della policy SL. Serve per i rollout simulati dentro MCTS, dove la velocità conta più dell’accuratezza.

• Policy RL ($p_{\rho}$): stessa architettura della policy SL, inizializzata dai suoi pesi e raffinata con self-play e policy gradient. Batte la policy SL nell’80% delle partite. Sorprendentemente, non viene usata direttamente nel sistema finale al momento del match: i dati di self-play della policy RL servono solo per generare il training set della value network. Per la selezione delle mosse in MCTS si usa la policy SL, perché — come gli autori notano nel paper — la policy SL produce una distribuzione più “esplorativa” (entropia più alta), mentre la policy RL converge su poche mosse dominanti, riducendo l’esplorazione di MCTS in modi controproducenti.

• Value Network ($v_{\theta}$): CNN profonda di 13 layer (architettura simile alla policy ma con un solo output scalare invece di 361). Input: stessa rappresentazione della policy. Output: stima scalare in $[-1, 1]$ della probabilità di vittoria. Addestrata su 30 milioni di posizioni di self-play (una per partita per evitare correlazione) etichettate con l’esito.

L’osservazione che la policy SL funzioni meglio della policy RL come prior dentro MCTS è interessante e contro-intuitiva. La spiegazione fornita nel paper è che la policy SL eredita la varianza naturale del gioco umano, mentre la policy RL la riduce convergendo su uno stile specifico. Per un sistema che fa search, la varianza nelle alternative considerate è una risorsa: aiuta a non perdere mosse buone solo perché la rete principale le ignora.

MCTS guidato da reti

Il cuore di AlphaGo è una variante di MCTS in cui ogni nodo dell’albero conserva quattro statistiche per ogni mossa $a$:

• $N(s, a)$: numero di volte che la mossa $a$ è stata visitata da quel nodo $s$.
• $W(s, a)$: somma dei valori ottenuti nelle simulazioni passanti da $(s, a)$.
• $Q(s, a) = W(s, a) / N(s, a)$: valore medio.
• $P(s, a)$: prior, la probabilità assegnata alla mossa dalla policy SL al momento dell’espansione.

Ogni iterazione di MCTS si svolge in quattro passi.

Selezione: dalla radice, si discende nell’albero scegliendo a ogni nodo la mossa che massimizza una formula tipo UCT modificata:

$a^* = \arg\max_a \left[ Q(s, a) + c \cdot P(s, a) \cdot \frac{\sqrt{\sum_b N(s, b)}}{1 + N(s, a)} \right]$

Il primo termine è il valore stimato (sfruttamento), il secondo è un bonus di esplorazione che cresce con il prior della mossa e decresce con il numero di visite. La costante $c$ regola il bilanciamento. Si scende fino a raggiungere un nodo foglia (un nodo non ancora espanso).

Espansione: al nodo foglia, si interroga la policy SL per ottenere i prior $P(s, a)$ per tutte le mosse legali, e si crea l’entry corrispondente nell’albero.

Valutazione: la posizione del nodo foglia viene valutata in due modi indipendenti, poi combinati con peso $\lambda$:

• Si interroga la value network $v_{\theta}(s)$ per una stima neurale.
• Si gioca un rollout casuale veloce dalla posizione, usando la policy rollout $p_{\pi}$ a entrambi i lati, fino a fine partita; il risultato $z \in \{-1, +1\}$ è il valore Monte Carlo.

Il valore composito è $V(s) = (1 - \lambda) \cdot v_{\theta}(s) + \lambda \cdot z$, con $\lambda = 0.5$ nei setting standard.

Backup: il valore $V$ viene propagato all’indietro lungo il percorso seguito durante la selezione. Per ogni $(s, a)$ visitato, $N(s, a) \mathrel{+}= 1$ e $W(s, a) \mathrel{+}= V$. Questo aggiorna le statistiche del nodo per le future iterazioni.

Si itera questo processo per il budget di tempo (tipicamente alcuni secondi per mossa nel match Lee Sedol, corrispondenti a decine di migliaia di simulazioni). Quando il tempo finisce, la mossa scelta dalla radice è quella più visitata (non quella con valore Q più alto). L’argomento per scegliere il nodo più visitato anziché quello a Q massimo è di robustezza: il numero di visite è meno volatile del Q medio, soprattutto per mosse poco esplorate.

Figura in preparazione

One MCTS iteration step in AlphaGo. Tree visualization with root at top. Four panels left to right showing the four phases: 1) Selection: arrow descending the tree, choosing children according to UCT-with-prior formula displayed as a small box. 2) Expansion: leaf node expanded, policy SL queried to populate prior values P(s,a) for legal moves. 3) Evaluation: leaf position evaluated by value network v_theta in parallel with a fast rollout using policy_pi until terminal, combined value V = 0.5 * v_theta + 0.5 * z. 4) Backup: V propagated up the path, updating N(s,a) and W(s,a) at each visited edge. Clean editorial style, English labels

La pipeline di training in dettaglio

Il pipeline di training è descritto nei Methods del paper Nature con notevole dettaglio implementativo. Riassumendo i numeri principali:

• Dataset KGS: 28.4 milioni di posizioni, da 160.000 partite di giocatori KGS 6-9 dan amatoriali. Per ogni posizione, viene calcolato il tensore di input 19x19x48.
• Training policy SL: stochastic gradient descent con momentum, mini-batch size 16, learning rate 0.003 con decadimento. 340 milioni di update step su 50 GPU per circa 3 settimane. Risultato: 57.0% top-1 accuracy nel predire la mossa esperta.
• Self-play policy RL: 10.000 mini-batch di 128 partite ciascuno. Le partite si svolgono tra la versione corrente $\rho$ e una versione $\rho'$ scelta casualmente da un pool di precedenti checkpoint. Update via REINFORCE con baseline. 50 GPU per 1 giorno. Risultato: $p_{\rho}$ batte $p_{\sigma}$ nell’80% delle partite.
• Generazione dataset value: 30 milioni di partite di self-play di $p_{\rho}$, una posizione campionata per partita, etichettata con l’esito finale. Crucialmente, posizioni dalla stessa partita non vengono mai messe insieme nel training: questo evita correlazione e overfitting.
• Training value network: SGD su 30 milioni di esempi, 50 GPU per 1 settimana. Risultato: la value network ha accuratezza superiore ai rollout casuali (Monte Carlo basato sulla policy rollout) e comparabile a rollout fatti con la policy SL completa, ma a costo computazionale 15.000 volte minore.

L’infrastruttura di training totale è dell’ordine di 50 GPU per alcune settimane. L’infrastruttura di inference durante il match è significativamente più grande: la versione di AlphaGo contro Lee Sedol gira su un cluster distribuito con 1.920 CPU e 280 GPU, comunicando via rete con il client di gioco. Il cluster esegue MCTS in parallelo, con threads multipli che esplorano l’albero contemporaneamente e sincronizzano le statistiche (usando lock-free data structures e una variante chiamata virtual loss per evitare che threads diversi convergano sullo stesso ramo). La latenza per mossa è di pochi secondi nel match a tempo standard.

Figura in preparazione

Training pipeline block diagram. Top-left input box “30M KGS positions, dan amateur level”. Arrow to first stage “Supervised training (3 weeks, 50 GPUs)” producing “Policy SL (p_sigma), 57% accuracy, used as MCTS prior”. Arrow down to “Self-play of policy SL copies + policy gradient” stage producing “Policy RL (p_rho), beats p_sigma 80%”. Arrow to “Generate 30M self-play positions, label with outcome” producing dataset. Arrow to “Supervised training of value network (1 week)” producing “Value network (v_theta)”. Bottom: composite box “AlphaGo runtime: MCTS using p_sigma as prior, p_pi for fast rollouts, v_theta for evaluations”. Note the surprising fact: p_rho is used only to generate value training data, NOT directly in MCTS. Clean editorial style, English labels

Il match Lee Sedol, mossa per mossa essenziale

Vale la pena segnalare anche un dettaglio sull’organizzazione del match che cattura il momento storico. Il match è organizzato in collaborazione con la Korean Baduk Association (federazione coreana di Go) e con Google DeepMind come sponsor principale. Il governo coreano lo classifica come evento culturale di interesse nazionale; le scuole superiori dedicano lezioni allo studio delle partite; il presidente coreano dell’epoca, Park Geun-hye, in interviste pubbliche cita il match come occasione per “investire massicciamente in intelligenza artificiale”. L’effetto Sputnik è palese: il governo coreano annuncia nel marzo 2016 un piano da 1 trilione di won (circa 850 milioni di dollari) di investimenti in AI nei cinque anni successivi. La Cina, dove il match è stato visto da centinaia di milioni di spettatori, lancia il proprio piano nazionale AI nel luglio 2017. Il match Lee Sedol, in retrospettiva, è uno dei catalizzatori delle politiche industriali AI dell’Asia orientale post-2016.

Il match si svolge a Seoul dal 9 al 15 marzo 2016, al Four Seasons Hotel. Cinque partite, una al giorno tranne il giorno di pausa tra Game 3 e Game 4. Premio: 1 milione di dollari, donato alla beneficenza dopo la sconfitta. Tempo standard: 2 ore per giocatore più 3 byo-yomi da 60 secondi (overtime). Arbitri ufficiali. Trasmissione in diretta online con commento in inglese (Michael Redmond 9p e Chris Garlock) e in coreano (commentatori locali).

Game 1, 9 marzo, AlphaGo nero. Lee Sedol gioca un’apertura non ortodossa. AlphaGo risponde solidamente. La partita si stabilizza, e nel medio gioco AlphaGo guadagna progressivamente vantaggio. Lee abbandona alla mossa 186, riconoscendo posizione persa. Conferenza stampa post-partita: Lee, visibilmente sorpreso, dice: “Sono molto sorpreso. Pensavo che AlphaGo si basasse su calcoli probabilistici, che sarebbe stato solo un programma. Ma quando ho visto questa partita, ho cambiato idea. Sicuramente AlphaGo è molto intelligente. Anche le sue mosse erano piene di significato. Ho perso. Ho preso una buona lezione.”

Game 2, 10 marzo, AlphaGo bianco. È la partita della mossa 37. Dopo un’apertura standard, AlphaGo gioca a metà gioco una shoulder hit alla quinta linea sul lato destro: una mossa che la teoria classica del Go scarta come “troppo alta”. Fan Hui, presente nello studio di commento, esclama “Apollo. Astronave.” (la trascrizione esatta è “It’s a beautiful move. It’s a beautiful move. I would say… Apollo, astronave”; la traduzione standardizzata è “una mossa bellissima”). Michael Redmond nel commento inglese inizialmente esita: “I’m not sure that’s a good move”. Lee Sedol esce dalla sala, prende un caffè, torna 15 minuti dopo, gioca la propria risposta. Cinquanta mosse dopo, la pietra alla mossa 37 è il fulcro di una struttura che decide la partita. Lee abbandona alla mossa 211. La community Go internazionale, nei mesi successivi, analizzerà la mossa 37 come “ispirata” e “creativa”: una mossa che umani non avrebbero giocato per stile, ma che a posteriori si rivela strategicamente forte. Diventa l’icona del match.

Game 3, 12 marzo, AlphaGo nero. AlphaGo gioca con grande controllo. Lee Sedol prova un’invasione complessa nell’angolo basso destro; AlphaGo difende perfettamente, neutralizzando l’attacco e mantenendo il vantaggio. Lee abbandona alla mossa 176. Il match è 3-0 per AlphaGo; il match è formalmente vinto dal programma con due partite ancora da giocare.

Game 4, 13 marzo, AlphaGo bianco. Questa è la partita della mossa 78 di Lee Sedol. Dopo aver perso le prime tre partite, Lee è descritto come scuro in volto ma determinato. Durante una fase complessa al centro del tavoliere, gioca una mossa di “wedge” — un’inserzione tra due gruppi di pietre bianche di AlphaGo — alla mossa 78. La mossa è notevolmente difficile da analizzare; in successive analisi, sia umane che con programmi successivi, viene riconosciuta come tatticamente sottile, una “mossa unica” (la community la chiamerà “hand of God”, in riferimento alla qualità divina). AlphaGo, che fino a quel momento aveva mostrato valori di vincita tra l’80 e il 90%, comincia a giocare mosse anomale: la sua stima di probabilità di vincita crolla rapidamente, ma le sue risposte alla mossa 78 sono sub-ottimali. L’analisi ex post mostra che il sistema di MCTS è entrato in una zona dello spazio degli stati molto poco esplorata durante self-play, dove la value network produce stime imprecise. Lee Sedol vince. AlphaGo abbandona alla mossa 180. È l’unica vittoria umana del match e l’ultima partita persa pubblicamente da una versione AlphaGo contro un giocatore professionista. Conferenza stampa: Lee è emozionato, applausi dalla sala. Hassabis ammette: “questa è una sconfitta per AlphaGo. Useremo questa partita per migliorare il sistema.”

Game 5, 15 marzo, AlphaGo bianco. Partita complessa, combattuta fino alle ultime mosse. AlphaGo vince per piccolo margine. Lee abbandona alla mossa 280. Il match si chiude 4-1.

Il premio di 1 milione di dollari viene donato dal team DeepMind a tre organizzazioni: UNICEF, organizzazioni STEM e organizzazioni Go. Lee Sedol riceve 150.000 dollari per la partecipazione e 20.000 dollari aggiuntivi per la vittoria del Game 4.

Va detto qualcosa anche sulla copertura dell’evento e sulla sua ricezione di lungo termine. La Korea Baduk Association, dopo il match, conferisce a AlphaGo il rango onorario di 9-dan professionale, il massimo grado del Go (gesto simbolico, pensato come riconoscimento ufficiale). In Cina, le associazioni Go nazionali avviano nei mesi successivi programmi di studio sistematico delle partite di AlphaGo. In Giappone, dove il Go ha tradizionalmente uno status simile alla scacchi nei paesi occidentali, le partite vengono trasmesse in TV con commento approfondito. La penetrazione culturale dell’evento nell’Asia orientale è di un ordine di grandezza superiore a quella in Europa o Nord America. Hassabis, in interviste successive, sottolinea che il match Lee Sedol è stato pensato fin dall’inizio come “un evento culturale nell’Asia orientale, non solo un esperimento scientifico”.

Il documentario di Greg Kohs (2017), uscito dopo nove mesi di montaggio, cattura aspetti che le sole partite non mostrano: la tensione del team DeepMind tra una partita e l’altra (debuggare AlphaGo dopo la sconfitta del Game 4 per evitare ripetizioni del problema), la solitudine di Lee Sedol nel preparare le partite (analizzava ogni notte le mosse di AlphaGo del giorno prima), il ruolo silenzioso di Aja Huang come braccio fisico del programma. La scena più ricordata del film è quella in cui Lee, dopo la vittoria del Game 4, sorride per la prima volta in giorni e dice: “Ho sentito il battito del mio cuore. Non avevo mai sentito così forte il piacere del gioco”.

Figura in preparazione

Go board with AlphaGo Move 37 from Game 2 highlighted. The 19x19 board shows the position just before move 37, with all stones placed numbered in order. Move 37 (white, 5-line shoulder hit on the right side) is highlighted with a colored circle and an arrow. Caption “Move 37, Game 2, March 10 2016 — the 5-line shoulder hit that defied classical theory and decided the game”. Annotate the right-side corner formation that emerged 50 moves later. Clean editorial style, English labels

Cosa hanno aggiunto Master, Zero, AlphaZero, MuZero

Tra il 2016 e il 2020 il filone “AlphaX” produce una sequenza di sistemi che semplificano e generalizzano l’idea originale.

AlphaGo Master appare alla fine del 2016 sotto pseudonimo. Tra dicembre 2016 e gennaio 2017, un account chiamato “Master” (e poi “Magister”) gioca contro i top professionisti mondiali sui server online Tygem e FoxGo. Vince 60 partite consecutive contro un parterre che include Ke Jie (giocatore di Go cinese, 1997-, all’epoca numero uno mondiale del ranking), Park Junghwan, Iyama Yuta, e altri. Le partite vengono giocate a tempo molto rapido (pochi secondi per mossa) e Master non perde mai. Solo dopo le 60 vittorie DeepMind rivela ufficialmente che Master è una nuova versione di AlphaGo. Nel maggio 2017 Master gioca un match formale a Wuzhen contro Ke Jie e vince 3-0.

Tecnicamente Master è una versione raffinata di AlphaGo Lee con architettura semplificata: usa una sola rete unificata che produce sia policy che value, addestrata in modo più integrato. I dettagli architetturali non sono stati documentati con la stessa granularità di AlphaGo Zero, ma la direzione è chiara: semplificazione dell’architettura e integrazione più stretta fra policy e value.

AlphaGo Zero, ottobre 2017, paper Nature “Mastering the game of Go without human knowledge” (Silver et al., Nature 550, 354-359). È il salto concettuale. Zero non usa nessun dato umano. Parte da pesi inizializzati casualmente e impara solo attraverso self-play. L’architettura è semplificata: una sola rete neurale (policy e value condivise, due “teste” in cima a una backbone comune) con residual blocks in stile ResNet (vedi resnet-2015). Il training procede in cicli: la rete corrente fa self-play guidando MCTS; le partite generate diventano dati di training per la rete; quando la nuova rete batte la vecchia in valutazione, diventa la nuova rete corrente. Niente policy SL, niente policy rollout, niente value training separato — un singolo loop chiuso.

I risultati di Zero sono impressionanti. Dopo 3 giorni di training su 4 TPU (Tensor Processing Units, gli acceleratori AI proprietari di Google), Zero batte la versione “AlphaGo Lee” (quella del match contro Lee Sedol, 1.920 CPU + 280 GPU) per 100-0. Dopo 40 giorni di training, batte la versione “AlphaGo Master” per 89-11. Il training di Zero è anche più stabile: non c’è il rischio di “rock-paper-scissors” tipico di self-play puro perché la rete viene aggiornata solo quando supera la versione precedente in valutazione, garantendo monotonicità.

Zero è importante per due motivi che vanno oltre il Go. Primo, dimostra empiricamente che il pre-training su dati umani non è necessario per raggiungere super-umanità in Go. La conoscenza umana, in questo dominio, era un’accelerazione iniziale ma non un ingrediente essenziale. Secondo, semplifica drasticamente il sistema: una rete invece di quattro, un solo loop di training invece di tre fasi. La semplificazione paga in performance.

AlphaZero, dicembre 2017 (preprint), paper Science del dicembre 2018 “A general reinforcement learning algorithm that masters chess, shogi, and Go through self-play” (Silver et al., Science 362, 1140-1144). AlphaZero generalizza Zero a domini diversi, in particolare scacchi e shogi. L’algoritmo è essenzialmente identico a Zero; cambiano la rappresentazione dell’input (specifica per gioco) e le regole del gioco (ovviamente). Nessuna conoscenza umana del gioco è iniettata, solo le regole. Dopo 4 ore di training, AlphaZero batte Stockfish 8 (motore scacchistico open source, all’epoca campione del mondo computer chess) in un match a tempo standard 28-72-0 (28 vittorie, 72 patte, 0 sconfitte) — un risultato che nei mesi successivi suscita controversie (le condizioni del match favorivano AlphaZero in vari modi: hardware ineguale, niente opening book, niente endgame tablebase per Stockfish), ma rimane indubbiamente significativo. Su shogi, batte Elmo, il campione mondiale di computer shogi.

MuZero, novembre 2019 (preprint), paper Nature del dicembre 2020 “Mastering Atari, Go, chess and shogi by planning with a learned model” (Schrittwieser et al., Nature 588, 604-609). MuZero fa l’ulteriore passo di imparare anche le regole del gioco dal solo segnale di reward, senza simulatore. Il modello impara una rappresentazione interna degli stati e una funzione di transizione appresa, su cui poi fa MCTS. Funziona su Go, scacchi, shogi e Atari (vedi dqn-atari-2013). È il completamento concettuale del filone: non solo niente conoscenza umana, ma neanche conoscenza esplicita delle regole.

Sistema	Anno	Dati umani	Reti	Hardware match	ELO stimato (Go)
Crazy Stone	2006-2014	no	0	CPU singola	~1900
Pachi	2008+	no	0	CPU singola	~2000
AlphaGo Fan	2015	si	4 (policy SL/rollout/RL + value)	176 GPU	~3144
AlphaGo Lee	2016	si	4	1920 CPU + 280 GPU	~3739
AlphaGo Master	2016-2017	si (parzialmente)	1 unificata	4 TPU	~4858
AlphaGo Zero	2017	no	1 unificata, residual	4 TPU	~5185
Lee Sedol (umano)	2016	—	—	—	~3526
Ke Jie (umano)	2017	—	—	—	~3624

La tabella ELO è approssimata e basata sulle stime pubblicate da DeepMind nel paper Zero (Figura 4); va presa come ordine di grandezza relativo, non come misura assoluta cross-system. Il salto da AlphaGo Lee a Zero (circa 1500 punti ELO) corrisponde a una probabilità di vittoria nel match testa a testa attorno al 99%.

Esempi

Esempio 1: pseudocodice di una iterazione MCTS in AlphaGo

Per concretezza, un’iterazione singola di MCTS come implementata in AlphaGo, in pseudocodice Python-ish:

def mcts_iteration(root, policy_net, rollout_net, value_net):
    # Phase 1: selection
    node = root
    path = []
    while node.is_expanded():
        action = select_action_uct_with_prior(node)  # the formula above
        path.append((node, action))
        node = node.child(action)

    # Phase 2: expansion
    if not node.is_terminal():
        priors, _ = policy_net.predict(node.position)
        node.expand(priors)

    # Phase 3: evaluation
    if node.is_terminal():
        value = node.terminal_value()
    else:
        v_neural = value_net.predict(node.position)
        z_rollout = fast_rollout(node.position, rollout_net)
        value = 0.5 * v_neural + 0.5 * z_rollout

    # Phase 4: backup
    for parent, action in reversed(path):
        parent.N[action] += 1
        parent.W[action] += value
        parent.Q[action] = parent.W[action] / parent.N[action]
        value = -value  # alternate perspective at each ply

Da notare l’ultimo dettaglio: value = -value a ogni passo del backup. Il valore viene negato perché in un gioco a due giocatori a somma zero, una posizione vincente per il giocatore che muove è perdente per l’avversario. Il backup propaga il valore alternando il segno mentre risale l’albero, in modo che ciascun nodo aggiorni la propria statistica $Q(s, a)$ rispetto al giocatore di turno in $s$. Questo è il pattern standard di MCTS in giochi a due giocatori.

Esempio 2: un calcolo numerico della formula UCT con prior

Per chi vuole vedere concretamente come funziona la selezione delle mosse in MCTS, considerare un nodo con tre mosse candidate $a_1$, $a_2$, $a_3$, con le seguenti statistiche dopo un certo numero di iterazioni:

• $a_1$: $N = 100$, $Q = 0.55$, $P = 0.40$.
• $a_2$: $N = 50$, $Q = 0.62$, $P = 0.30$.
• $a_3$: $N = 5$, $Q = 0.45$, $P = 0.25$.

Sia $\sum_b N(s, b) = 155$, e prendiamo $c = 1$ per il bilanciamento esplorazione/sfruttamento. Calcoliamo il termine UCT-con-prior per ciascuna mossa:

• $a_1$: $0.55 + 1 \cdot 0.40 \cdot \sqrt{155} / (1 + 100) = 0.55 + 0.40 \cdot 12.45 / 101 \approx 0.55 + 0.049 = 0.599$.
• $a_2$: $0.62 + 1 \cdot 0.30 \cdot 12.45 / 51 \approx 0.62 + 0.073 = 0.693$.
• $a_3$: $0.45 + 1 \cdot 0.25 \cdot 12.45 / 6 \approx 0.45 + 0.519 = 0.969$.

La mossa scelta è $a_3$, nonostante abbia il valore $Q$ più basso. Il motivo è che $a_3$ è stata visitata pochissimo (solo 5 volte) e ha un prior decente (0.25), quindi il termine di esplorazione la favorisce per ridurre l’incertezza sulla sua valutazione. Dopo qualche iterazione su $a_3$, il suo $N$ aumenterà e il termine di esplorazione diminuirà, riportando il bilanciamento. Questo è il meccanismo chiave per cui MCTS non resta bloccato sulla mossa che sembra migliore al momento, ma esplora abbastanza alternative da scoprirne di migliori.

Quando il budget di tempo finisce e si sceglie la mossa “definitiva” da giocare, si sceglie invece quella con $N$ massimo, non quella con $Q$ massimo né quella con UCT massimo. Nel nostro esempio, dopo molte iterazioni, $a_1$ con $N = 100$ sarebbe la scelta di gioco. La logica: il numero di visite riflette l’integrazione di esplorazione e sfruttamento attraverso tutta la search; è più stabile della Q stimata in un singolo punto.

Esempio 3: la mossa 37 commentata

La posizione prima della mossa 37 di Game 2 è stata pubblicata e analizzata estesamente. Dopo 36 mosse, AlphaGo (bianco) ha consolidato l’angolo basso sinistro e ha iniziato a contrastare l’apertura sul lato destro di Lee. La teoria classica del Go suggerirebbe per AlphaGo una mossa di “approach” alla terza o quarta linea sul lato destro: la terza linea dà territorio, la quarta dà influenza. La quinta linea cede entrambe le cose: troppo lontana dal bordo per fare territorio diretto, troppo isolata per costruire muro.

AlphaGo gioca alla quinta linea. La lettura di Fan Hui ex post: la pietra alta della mossa 37 funziona perché tra 30-40 mosse dopo, quando la posizione si concretizza, quella pietra svolgerà il ruolo di “ladder breaker” rispetto a una potenziale invasione bianca dal centro, e simultaneamente metterà sotto pressione la struttura nera centrale. La rete value di AlphaGo “vedeva” questo orizzonte temporale; la teoria scritta a mano del Go umano non lo “vedeva” perché nessun pattern memorizzato copriva quella configurazione esatta.

Nel commento del documentario AlphaGo (2017), Aja Huang stima che la probabilità che un giocatore professionista umano scegliesse la mossa 37 in quella posizione fosse circa 1/10.000. AlphaGo l’ha scelta perché la sua policy network, allenata su milioni di partite di self-play, aveva visto pattern in posizioni analoghe in cui la quinta linea funzionava. La mossa 37 non è “creativa” in senso umano (la rete non ragiona per analogia esplicita); è statisticamente forte rispetto a una distribuzione di posizioni che il dataset umano non copriva.

Marcatura di classe: “AlphaGo è creativo” è un’analogia debole — la rete non ha intenzionalità creativa. “AlphaGo ha trovato mosse che la teoria umana del Go non aveva codificato” è una descrizione fattuale. La distinzione conta: i giornali del 2016 hanno raccontato la mossa 37 come “creatività della macchina”, il che è un’antropomorfizzazione utile per la divulgazione ma fuorviante per la comprensione tecnica.

Esempio 4: confronto numerico delle versioni

Per dare scala al progresso interno al filone, considerare i seguenti numeri provenienti dal paper Zero (Silver et al., Nature 2017):

• AlphaGo Lee vs AlphaGo Fan: in match 100-0 di self-play, AlphaGo Lee batte la versione Fan al 100%. Il salto è dovuto principalmente all’aumento di compute (1920 CPU + 280 GPU vs 176 GPU) e a raffinamenti del training.
• AlphaGo Master vs AlphaGo Lee: 60-40 a favore di Master in match interni dichiarati. Il salto è architetturale (rete unificata) e di pipeline (training più integrato).
• AlphaGo Zero (3 giorni) vs AlphaGo Lee: 100-0 a favore di Zero, sorprendentemente rapido. Zero impara “da zero” più velocemente di Lee anche dopo aver buttato via tutta la conoscenza umana.
• AlphaGo Zero (40 giorni) vs AlphaGo Master: 89-11 a favore di Zero. Zero, allenato più a lungo, supera anche la versione fortemente raffinata che usava ancora dati umani.
• AlphaZero (4 ore di training su scacchi) vs Stockfish 8: 28-72-0 (28 vittorie AlphaZero, 72 patte, 0 sconfitte) in 100 partite. Risultato controverso per le condizioni di gioco, ma significativo.

Il pattern è netto: ogni iterazione del filone produce un sistema più semplice e più forte del precedente. La semplificazione architetturale (da 4 reti a 1 rete unificata, da 3 fasi di training a 1 loop) e l’eliminazione progressiva di componenti hand-engineered (rollout policy, knowledge umana iniziale, infine anche il simulatore in MuZero) coincidono con un aumento di prestazioni.

Figura in preparazione

Lineage diagram of the AlphaX family. A vertical or horizontal flow with boxes connected by arrows: TD-Gammon (1992, NN+RL+self-play, backgammon) → DQN (2013, deep RL on pixels, Atari) → AlphaGo (2016, NN+MCTS+self-play, Go, beats Lee Sedol) → AlphaGo Zero (2017, no human data, single unified residual network) → AlphaZero (2017, multi-game: Go, chess, shogi) → MuZero (2020, learns the model itself, also Atari) → AlphaFold (2020, protein structure, Hassabis Nobel 2024) → AlphaCode (2022, competitive programming, first open-ended domain) → AlphaTensor (2022, algorithm discovery, matrix multiplication) → AlphaProof / AlphaGeometry (2024, mathematical theorem proving, IMO silver medal). Annotate each transition with what was added or removed (e.g. “removes human data”, “adds learned dynamics model”, “extends to open-ended domain”). Clean editorial style, English labels

La controversia AlphaZero vs Stockfish

Vale la pena spendere un paragrafo sulla controversia tecnica più nota del filone. Il match AlphaZero vs Stockfish 8 del dicembre 2017 ha suscitato critiche pesanti dalla comunità computer chess, sintetizzate poi nel paper di Tomáš Romstad e altri sviluppatori di Stockfish. Le accuse principali: Stockfish girava con 64 thread su CPU mentre AlphaZero usava 4 TPU di prima generazione (asimmetria hardware difficile da quantificare), Stockfish non aveva accesso al suo opening book standard né alle endgame tablebase Syzygy (due dei suoi punti di forza), il controllo del tempo era un minuto fisso a mossa (formato in cui Stockfish tipicamente fa peggio rispetto a controlli di tempo standard). Il paper Science del 2018 risponde almeno in parte: ripete il match con un range di controlli di tempo (da 1 secondo a 3 minuti per mossa) e con Stockfish moderno, mostrando che AlphaZero vince in tutte le configurazioni. La controversia si è progressivamente spenta nel 2019-2020, quando lo stesso gruppo Stockfish ha incorporato reti neurali nella propria valutazione (NNUE, Efficiently Updatable Neural Networks, 2020) e ha superato la performance di AlphaZero, dimostrando che la combinazione di alpha-beta tradizionale + NN era più efficace del MCTS+NN puro per gli scacchi specificamente. Il pattern emerso dalla controversia è interessante: in scacchi, MCTS+NN funziona bene ma non è dominante; alpha-beta+NN domina. In Go, MCTS+NN domina e alpha-beta non si applica per via del branching factor. Questo conferma che la scelta dell’algoritmo di search dipende dal dominio, anche dentro la famiglia AlphaX.

Eredità oggi

[DATATO 2026-04] Le considerazioni in questa sezione riflettono lo stato del campo a metà del 2026.

L’eredità di AlphaGo si dispiega su due assi: una filiazione documentata dentro DeepMind, che produce la sequenza AlphaX, e un’influenza concettuale più diffusa sulla comunità AI in generale.

La filiazione AlphaX

Il filone interno a DeepMind è ben documentato: ogni paper successivo cita esplicitamente i precedenti come ispirazione e come sistema da superare. La catena è:

• AlphaGo (2016): deep RL + MCTS + self-play, applicato a Go, con bootstrap da dati umani.
• AlphaGo Zero (2017): stesso schema ma niente dati umani, architettura unificata, residual networks.
• AlphaZero (2017): stesso schema applicato a Go, scacchi, shogi.
• MuZero (2020): stesso schema con modello del mondo appreso, applicato anche a Atari (domini con regole non scritte).
• AlphaFold (2020): stesso schema (deep model + iterazione + auto-supervisione) applicato alla predizione della struttura tridimensionale delle proteine. La connessione architetturale con AlphaGo non è di copia diretta — AlphaFold non usa MCTS — ma il framework di “deep model + self-improvement loop” è lo stesso. Demis Hassabis riceverà il Nobel per la Chimica 2024 per AlphaFold, condiviso con John Jumper e David Baker.
• AlphaCode (2022): applicazione del paradigma a coding competitivo. Il sistema genera e filtra centinaia di migliaia di programmi candidati per problemi di programmazione, usando un modello + sampling + clustering. È la prima estensione di AlphaX a un dominio “open-ended” senza regole formali.
• AlphaTensor (2022): scoperta automatica di algoritmi per moltiplicazione di matrici. Il sistema cerca decomposizioni di tensori che corrispondono a algoritmi di moltiplicazione, trovando algoritmi nuovi più efficienti (ad esempio una variante per matrici 4x4 in $\mathbb{F}_2$ che usa 47 moltiplicazioni invece delle 49 dell’algoritmo di Strassen ricorsivo).
• AlphaProof e AlphaGeometry (2024): applicazioni a dimostrazioni matematiche e geometria olimpionica. Riportano risultati a livello di medaglia d’argento alle Olimpiadi Internazionali di Matematica 2024.

Il pattern della filiazione AlphaX è: “deep model + tree search + self-play o auto-validazione”, applicato a domini in cui esiste un modo ragionevolmente economico di validare un risultato (regole di un gioco, leggi della fisica per le proteine, esecuzione di un programma per il coding). Domini in cui la validazione è disponibile come oracle si prestano alla ricetta. Domini in cui la validazione richiede a sua volta un giudizio soggettivo (qualità di una poesia, eleganza di un’argomentazione) non si prestano direttamente.

Influenza al di fuori di DeepMind

Al di fuori del filone AlphaX, l’influenza di AlphaGo si manifesta in modi più indiretti.

Sul deep reinforcement learning, AlphaGo ha legittimato definitivamente la combinazione “deep nets + RL + search”. Tutti i lavori successivi su game playing (OpenAI Five su Dota 2, AlphaStar di DeepMind su StarCraft II, Cicero di Meta su Diplomacy) hanno ereditato il template, adattando l’algoritmo specifico (PPO, IMPALA) alle particolarità del dominio. Anche fuori dai giochi, l’idea di “policy network che propone azioni + value network che valuta + search per refinement” è un pattern ricorrente nel robot learning, nei sistemi di pianificazione automatica, e in alcuni lavori di reasoning per LLM.

Sui reasoning model dell’era 2024+ (o1 di OpenAI, DeepSeek-R1, Claude con extended thinking), l’eredità è di tipo concettuale, non di filiazione tecnica diretta. Il pattern “test-time compute via search” — generare molteplici tracce di ragionamento, valutarle, sceglierle — è ispirato in parte all’idea che il calcolo a tempo di inferenza vale tanto quanto il calcolo a tempo di training, idea che AlphaGo aveva esemplificato (un AlphaGo con MCTS a 1600 simulazioni gioca molto meglio di uno con 1 simulazione, a parità di rete). Marcatura di classe: questa è una analogia forte, non una filiazione tecnica diretta. I reasoning model attuali non usano MCTS in senso stretto su token; usano sampling guidato e a volte tree search, ma l’algoritmo specifico è diverso e la struttura del problema (sequenze di linguaggio naturale invece di mosse discrete su un tavoliere) richiede adattamenti sostanziali. Il legame da preservare è “l’idea che search a inference-time sia una leva, e che valga la pena spenderci compute”. Questo è di AlphaGo. La meccanica specifica è di altri.

Sulla cultura del Go, l’effetto è stato profondo e immediato. Nei mesi e anni successivi al match Lee Sedol, le aperture e le sequenze giocate da AlphaGo (Lee, Master, Zero) sono state analizzate intensivamente dalla comunità di Go professionale. Diverse mosse considerate “errori” dalla teoria classica sono state riabilitate, e nuove sequenze di apertura sono entrate nel repertorio comune. Programmi di analisi accessibili al grande pubblico (Leela Zero, KataGo, comunità open source che riproducono il pattern AlphaGo Zero su hardware consumer) sono diventati standard di studio per giocatori professionisti e amatoriali. Il livello medio dei top professionisti è aumentato significativamente nei sei anni successivi al 2016, attribuibile in parte all’effetto AlphaGo. Lee Sedol stesso, prima del ritiro nel 2019, ha dichiarato che “l’AI ha cambiato il modo in cui penso al gioco”.

Dove si rompe

I limiti di AlphaGo sono numerosi e importanti, soprattutto per evitare letture entusiastiche fuori scala.

Solo domini con regole formali, simulatore, e reward chiaro. AlphaGo funziona perché il Go ha regole completamente specificate (che permettono di simulare partite arbitrarie senza un avversario reale), un esito binario (vittoria o sconfitta) calcolabile a fine partita, e un dominio chiuso (19x19 intersezioni, niente più). Tutti e tre questi elementi sono prerequisiti del paradigma. Per domini in cui le regole non sono formalizzate (linguaggio naturale, decisioni etiche), o in cui il reward non è chiaro (qualità di una conversazione), o in cui il dominio è aperto (azioni nel mondo fisico), il paradigma non si applica direttamente. Va adattato — e gli adattamenti sono opera tutt’altro che banale, come dimostrano vari tentativi successivi su domini meno strutturati.

Computational cost massiccio. La versione AlphaGo Lee del match marzo 2016 girava su un cluster con 1920 CPU e 280 GPU, comunicanti in rete con un client di gioco. È un livello di compute per match che esclude in pratica chiunque non sia DeepMind (o Google) per replicare il setup. Le versioni successive (Master, Zero) hanno ridotto drasticamente il footprint di inference (4 TPU sono molte meno risorse di 1920 CPU + 280 GPU), ma il training di Zero richiedeva ancora migliaia di TPU-ore. Per domini più complessi del Go, i requisiti scalano. AlphaFold 2 ha richiesto cluster di centinaia di TPU per training; AlphaCode richiede ordini di grandezza simili. Il paradigma AlphaX è costoso.

Niente generalizzazione fuori distribuzione. AlphaGo gioca al Go. AlphaZero gioca a Go, scacchi e shogi (ognuno con un modello addestrato separatamente). MuZero generalizza il framework, ma il modello allenato su Go non sa giocare a scacchi, e viceversa. Questo non è un bug, è una caratteristica del paradigma supervised + RL: ogni dominio richiede dati specifici. La generalizzazione cross-domain è un problema aperto che AlphaGo non risolve.

Il mito della “comprensione”. Questa è la più importante avvertenza per un capitolo di registro storico. Dopo il match Lee Sedol, una buona parte del discorso pubblico ha presentato AlphaGo come un sistema che “comprende” il Go, che ha “intuizione”, che è “creativo”. È un linguaggio antropomorfizzato che, se preso alla lettera, è fuorviante. AlphaGo è un’aggregato di reti neurali e MCTS che statistica milioni di posizioni e propaga numeri lungo un albero di ricerca. Le sue mosse possono essere fortissime, possono essere “non umane”, possono essere strategicamente sottili — ma non sono il prodotto di comprensione nel senso che attribuiamo a un giocatore umano forte. La distinzione non è teologia: ha conseguenze pratiche. AlphaGo non sa spiegare perché ha giocato la mossa 37; non costruisce un’argomentazione comprensibile a un umano sulla strategia adottata; non “sa” che esiste un avversario o che ha vinto una partita. È un ottimizzatore statistico ad alta dimensione. Questa è la lettura corretta.

Il mito “AlphaGo è AGI”. No, AlphaGo non è AGI. È un sistema specializzato per Go (e successivamente per pochi altri giochi). Non sa fare nient’altro. Confondere “campione del mondo in un dominio specifico” con “intelligenza generale” è l’errore classico che la comunità AI ha commesso ricorrentemente — dopo Deep Blue, dopo Watson di IBM, dopo AlphaGo, dopo GPT-4. Nel filone AlphaX la generalizzazione è progressiva (Zero → AlphaZero → MuZero) ma resta confinata a giochi di scacchiera e Atari. La distanza dall’AGI è ancora misurabile in ordini di grandezza di capacità, e il paradigma “deep model + search” non è di per sé sufficiente. Si applica a domini ben strutturati. Il mondo reale non lo è.

Il mito “le mosse non umane di AlphaGo sono sempre migliori delle mosse umane”. Questa è una sfumatura più sottile. Le mosse non standard di AlphaGo (la mossa 37 ne è esempio, ma ce ne sono molte altre nel corpus delle sue partite) sono migliori per AlphaGo in posizioni di self-play o contro avversari specifici. Per un umano che le imitasse senza la stessa precisione di calcolo locale, potrebbero essere errori: la mossa 37 funziona perché le 50 mosse successive di AlphaGo difendono perfettamente la struttura che ne nasce. Un giocatore amatoriale che giocasse la mossa 37 senza capacità di follow-up perderebbe rovinosamente. Le mosse di AlphaGo sono coerenti con il suo profilo di forza (calcolo profondo + valutazione fine), non sono universalmente migliori in qualsiasi mano. Questa sfumatura è stata spesso persa nel discorso post-2016.

La sconfitta del Game 4. La singola partita persa da AlphaGo contro Lee Sedol mostra che il sistema non era invincibile e aveva regioni dello spazio degli stati mal coperte dal training. La mossa 78 di Lee Sedol porta AlphaGo in una zona dove la value network produce stime cattive e l’MCTS non riesce a recuperare in tempo. Questo è un limite reale del paradigma: la rete generalizza male su posizioni molto rare, e il search è limitato dal budget di tempo. Versioni successive (Master, Zero) hanno corretto questa specifica vulnerabilità, ma il pattern generale “AlphaGo può sbagliare in posizioni out-of-distribution” rimane vero per tutti i sistemi del filone, in misure variabili.

Vulnerabilità adversariali scoperte in retrospettiva. Nel 2022, Tony Wang e collaboratori (UC Berkeley, MIT) pubblicano “Adversarial Policies Beat Superhuman Go AIs” (arXiv:2211.00241), in cui mostrano che esistono strategie esplicitamente adversariali capaci di battere KataGo (il discendente open source più forte di AlphaGo Zero) anche da parte di umani amatoriali, una volta scoperte. Le strategie sfruttano configurazioni “out-of-distribution” che il sistema non ha mai visto in self-play e che valuta in modo catastroficamente sbagliato. È un risultato che chiarisce un limite del paradigma: il self-play converge su strategie “in-distribution” reciprocamente forti, ma può lasciare scoperti scenari rari che un avversario “alieno” può sfruttare. Lo stesso pattern è stato osservato in altri sistemi RL self-play. Per la lettura storica, è una nota che ridimensiona la narrativa di “AlphaGo invincibile”: invincibile contro avversari simili a sé stesso, vulnerabile contro avversari che cercano esplicitamente le sue debolezze.

Il costo ambientale. Spesso non discusso ma reale. Il training di AlphaGo Zero ha richiesto migliaia di ore di TPU, con consumi energetici stimati nell’ordine di MWh per il training completo. Per AlphaFold 2 i numeri sono ancora maggiori. Per AlphaCode, ordini di grandezza simili. Il paradigma “deep model + tree search + self-play su scala” è energivoro, e la sua sostenibilità su domini sempre più aperti pone domande non risolte. Va detto che le versioni successive dei modelli hanno spesso ridotto significativamente i requisiti di inference, ma il training resta costoso.

Collegamenti

• td-gammon-1992: l’antenato concettuale diretto. Stessa intuizione (rete neurale + RL + self-play), ma su backgammon, ventiquattro anni prima, su scala minuscola. AlphaGo è la versione matura, scalata, e con MCTS aggiunto, dello schema TD-Gammon. La filiazione concettuale è esplicita nel paper Nature 2016.

• deep-blue-1997: il paradigma opposto. Deep Blue vince agli scacchi con knowledge engineering pesante e alpha-beta search massivo. AlphaGo vince al Go con learning end-to-end e MCTS guidato da reti. Il contrasto definisce due epoche: simbolico-search (1997) e learning-search (2016).

• dqn-atari-2013: il predecessore deep RL diretto di DeepMind. DQN dimostra che reti neurali possono imparare a giocare ai videogame Atari da pixel. AlphaGo applica una logica simile (deep nets per imparare valutazione e azione) al dominio strutturato del Go, aggiungendo MCTS per il search.

• resnet-2015: l’architettura sfruttata da AlphaGo Zero. Le residual connections introdotte da He et al. nel dicembre 2015 sono il backbone della rete unificata di Zero (e di AlphaZero, MuZero). La filiazione architetturale è documentata.

• imagenet-alexnet-2012: l’origine pratica del paradigma deep learning. AlexNet dimostra che CNN profonde funzionano su task di pattern recognition; AlphaGo applica CNN profonde al pattern recognition del Go (la rete riceve la posizione come “immagine” 19x19).

• monte-carlo-tree-search (in preparazione, Parte VI): il capitolo dedicato a MCTS in dettaglio, dalla formulazione UCT originale (Kocsis-Szepesvári, Coulom 2006) alle varianti moderne. Quel capitolo entra nei dettagli matematici che qui sono solo richiamati a livello di intuizione.

• policy-gradient (in preparazione, Parte V): il capitolo che descrive REINFORCE e le sue varianti, di cui la fase RL di AlphaGo è un’applicazione classica. Per chi vuole capire cosa succede dietro l’update di $p_{\rho}$, quel capitolo è la fonte tecnica.

• q-learning (in preparazione, Parte V): l’altro grande pilastro del reinforcement learning, alternativo al policy gradient. AlphaGo non usa Q-learning direttamente, ma le idee di “valore di una azione in uno stato” sono parenti strette di quelle che la value network di AlphaGo apprende.

• markov-decision-process (in preparazione, Parte V): il framework formale che sottende tutto il reinforcement learning, AlphaGo incluso. Il Go è un MDP a due giocatori a informazione perfetta; capire MDP aiuta a vedere AlphaGo come un caso particolare di una struttura più generale.

• cnn-architetture (in preparazione, Parte VIII): la storia delle architetture convoluzionali, da LeNet a AlexNet, VGG, GoogLeNet, ResNet, EfficientNet. Le reti di AlphaGo sono CNN; quel capitolo le inquadra nella tradizione tecnica.

• test-time-scaling (in preparazione, Parte XII): il capitolo sui reasoning model post-2024 che usano compute a tempo di inferenza per migliorare le risposte. L’analogia con AlphaGo (search + valutazione a tempo di gioco) è concettuale e merita di essere esplicitata, pur con la marcatura di analogia non filiazione tecnica diretta.

• representation-learning (in preparazione, Parte VIII): le rappresentazioni interne apprese dalle reti di AlphaGo (in particolare la rete unificata di Zero) sono un caso paradigmatico di representation learning supervisionato dal segnale di RL. Cosa “vedono” le hidden unit di AlphaGo? Risposta: pattern di Go, riconoscibili e in parte interpretabili da esperti umani.

Per andare oltre

• Silver D., Huang A., Maddison C.J., et al., Mastering the game of Go with deep neural networks and tree search, Nature 529, 484-489, 28 gennaio 2016. Il paper originale di AlphaGo. La sezione Methods è densa ma chiarissima: vale la pena leggerla in parallelo a un’implementazione open source per capire i dettagli di scala e i trick implementativi.

• Silver D., Schrittwieser J., Simonyan K., et al., Mastering the game of Go without human knowledge, Nature 550, 354-359, 19 ottobre 2017. AlphaGo Zero. Più semplice e più chiaro del paper originale; l’idea della rete unificata e del loop di self-play puro è accessibile anche senza background tecnico profondo.

• Silver D., Hubert T., Schrittwieser J., et al., A general reinforcement learning algorithm that masters chess, shogi, and Go through self-play, Science 362, 1140-1144, 7 dicembre 2018. AlphaZero. Lettura veloce ma con tabelle e grafici che mostrano il salto multi-game.

• Schrittwieser J., Antonoglou I., Hubert T., et al., Mastering Atari, Go, chess and shogi by planning with a learned model, Nature 588, 604-609, dicembre 2020. MuZero. Più tecnico dei precedenti per via del modello del mondo appreso; richiede familiarità con dynamics models.

• Coulom R., Efficient Selectivity and Backup Operators in Monte-Carlo Tree Search, Computers and Games 2006, Torino, LNCS 4630, 72-83. Il paper seminale di MCTS moderno. Breve, leggibile, anche per chi non ha background in game playing.

• Documentario AlphaGo di Greg Kohs (2017), distribuito da Moxie Pictures, disponibile su YouTube e piattaforme streaming. 90 minuti che catturano il match di Seoul, le interviste con il team DeepMind e con Lee Sedol, e il contesto culturale. Per la portata umana dell’evento, è il riferimento principale.

• Müller M., Computer Go, Artificial Intelligence 134(1-2), 145-179, gennaio 2002. Survey storica del computer Go pre-MCTS. Utile per inquadrare lo stato dell’arte da cui MCTS e AlphaGo sono partiti.

• Coulom R., Whole-History Rating: A Bayesian Rating System for Players of Time-Varying Strength, Computers and Games 2008. Per chi vuole capire come si calcolano i rating ELO confrontabili tra umani e programmi nel tempo, in particolare per il sistema usato per ranking nel computer Go.

• Wang T.T., Gleave A., Tseng T., et al., Adversarial Policies Beat Superhuman Go AIs, ICML 2023, arXiv:2211.00241. Per chi vuole capire i limiti del paradigma self-play e quanto un’AI super-umana sia “robustamente super-umana” o solo “super-umana in distribuzione”. Lettura indispensabile per chiunque pensi che AlphaGo Zero abbia “risolto” il Go.

• Sutton R.S., Barto A.G., Reinforcement Learning: An Introduction, MIT Press, 2a edizione 2018. Il libro di riferimento per il reinforcement learning. I capitoli 16 (case studies) e 8 (planning + learning) sono direttamente rilevanti per inquadrare AlphaGo nella cornice teorica generale di RL.

• Lai M., Giraffe: Using Deep Reinforcement Learning to Play Chess, MSc thesis, Imperial College London, settembre 2015 (arXiv:1509.01549). Lavoro precedente di pochi mesi a AlphaGo che applica deep RL a scacchi raggiungendo livello International Master. Utile per inquadrare il clima tecnico dell’autunno 2015 in cui AlphaGo emerge.