Ricerca e sviluppo — l'avversario della Bora hardcore

La Sfida della Bora è l'ultima prova della demo: tre allenatori di fila nella stessa sala, generati dal seme della corsa, ognuno con sei Pokémon. Fra uno stadio e l'altro non si passa dal Centro e non si usano strumenti dallo zaino: curano solo i Pokémon stessi, e con questa patch l'abilità Raccoglipolline e la mossa Aroma di Cirmolo rimettono in forze anche chi aspetta in panchina. Uscire dalla porta vuol dire perdere. La variante hardcore cambia due cose: l'avversario dev'essere una politica addestrata, e il giocatore sceglie un bonus +N, da 0 a 5 (prima di questa patch arrivava a 30), che alza di N il livello di tutti e tre gli allenatori, oggi a 16+N. Le classifiche sono separate per modo e per difficoltà.

Al modello si chiedono due cose diverse, e la valutazione le tiene separate:

1. rendere la sfida più difficile per il giocatore di quanto la renda l'IA a regole che il gioco usa per gli altri allenatori, a parità di tutto il resto;
2. essere un giocatore migliore dell'IA a regole e di un avversario «greedy» (che sceglie sempre il danno atteso più alto) a parità di squadre, così da essere sicuri che la difficoltà venga dal gioco e non solo dal vantaggio di partenza che la Bora dà all'avversario.

Un'IA a regole va riscritta a mano ogni volta che cambia il bilanciamento. In questo gioco statistiche, mosse e specie sono dati di patch e cambiano spesso: il requisito era un processo riaddestrabile senza cambiare codice, in cui un modello nato su dati vecchi viene rifiutato, mai usato in silenzio.

• Il motore è quello vero. Nessuna seconda implementazione delle regole: l'agente si allena sullo stesso simulatore che gioca le lotte dei giocatori.
• Informazione legittima. In partita l'agente vede solo ciò che vedrebbe il giocatore al suo posto: la stessa vista censurata che il server manda a un client umano.
• Runtime leggero. Una scelta per turno sotto i 5 ms al 99° percentile, con 50 lotte vive insieme.
• Una macchina sola. Un AMD Ryzen 5 3600X (6 core, 12 thread) con 32 GB di RAM; la scheda grafica non è utilizzabile per l'addestramento, quindi tutto gira su CPU.
• Riproducibilità. Ogni modello porta stampato su quali dati, con quale motore e con quali «occhi» è nato; le valutazioni usano semi fissi; nessuna corsa e nessun checkpoint si cancellano.

L'ambiente è il motore di lotta del gioco, generato dalla stessa fonte di dati da cui nascono il server e il client. L'addestramento lo importa e non lo modifica. Misura di partenza (23 agosto): lotte 6 contro 6, casuale contro casuale, livello 50, un core: 15,0 lotte al secondo, 60 turni per lotta in media.

Dal 17 settembre il gioco calcola i colpi critici dalla velocità, come nella prima generazione, con tre modifiche: niente difetto di Focus Energy, contano i gradini di velocità, conta la paralisi. La soglia si calcola così: velocità base → gradino → ×0,25 se paralizzato → ÷2 → ×4 con Focus Energy → ×8 per una mossa ad alto tasso di critico → ×2 per ogni altro livello, con tetto 255 e una sola estrazione su 256 per mossa.

Il modo di calcolo (quello di Cristallo o quello dalla velocità) usa lo stesso motore, ma una politica non si trasferisce da un modo all'altro. Il modo è quindi un dato a sé: dichiarato in ogni configurazione, stampato in ogni checkpoint e controllato in più punti che non si fidano l'uno dell'altro.

• Il modello gioca l'allenatore della Bora, con la squadra presa dal corpus: le corse vere generate dal server, sei Pokémon al livello 16+N con talento alto. Nel corpus il bonus N andava da 0 a 30, con peso doppio fino a +10: era la scala della hardcore quando il corpus è nato.
• L'avversario fa il sostituto del giocatore, che arriva dopo due stadi già combattuti: sei Pokémon con talento, allenamento e mosse a caso, PS fra il 25 % e il 100 %, PP fra metà e pieni, uno o due Pokémon già esausti.
• Il corpus. 400 semi × 31 bonus = 12 400 corse (51,4 MB), con 49 specie di base, 53 contando le evoluzioni. Il 18 settembre la hardcore ha portato tutti e tre gli stadi a 16+N e il corpus è stato rigenerato in una cartella nuova: il terzo stadio è identico byte per byte al precedente in 12 400 corse su 12 400, quindi le misure restano confrontabili.

È una scelta deliberata: si allena il modello nella situazione che incontrerà. Ma ha una conseguenza che più avanti si misura: l'avversario del modello parte svantaggiato.

+1 alla vittoria, −1 alla sconfitta, 0 al pareggio. Nessuna ricompensa intermedia per i PS tolti o i KO: si è scelto di non scolpire la ricompensa, perché la politica non impari a massimizzare un surrogato.

Proprietà, non identità. Se l'osservazione avesse una casella per ogni specie, passare da 151 a 251 specie renderebbe illeggibile ogni modello. Si descrivono quindi le proprietà: statistiche, efficacia calcolata, velocità relativa. L'identità residua entra in un numero fisso di contenitori di hash. Un test con un Pokédex finto da 300 specie e un tipo inventato vieta alla dimensione di crescere.

La censura. Dell'avversario si vede solo ciò che è stato rivelato in lotta, e i suoi PS solo in percentuale: è la stessa censura che il server applica al giocatore umano.

Le azioni sono nove: le quattro mosse e i cambi verso i cinque Pokémon in panchina. La maschera viene dalla richiesta del motore: con un cambio forzato restano solo i cambi verso Pokémon vivi, da intrappolati nessun cambio, le mosse disabilitate o senza PP escono.

Il modello cambia Pokémon da sé: il cambio fa parte dello spazio d'azione, non è una regola scritta a mano. Il Pokémon premio lo sceglie il generatore; l'ordine di uscita lo decide la politica.

Una MLP con due strati nascosti da 256 unità, una testa di politica (9 logit mascherati) e una testa di valore.

In partita la rete si esporta e si esegue in JavaScript puro, dentro il servizio che gioca le lotte, senza dipendenze di calcolo numerico. Se non risponde entro 1500 ms gioca l'IA a regole, e il ripiego si conta.

Parità numerica a tre vie. La stessa rete si esporta anche in ONNX, e prima di ogni promozione si confrontano le tre esecuzioni — PyTorch, ONNX Runtime e il runtime JavaScript — su oltre mille casi: scarto massimo ammesso sui logit 1e-4, misurato 1,144e-5.

Campionamento, non argmax. In partita la politica campiona a una temperatura data: la variabilità fa parte dell'esperienza. La valutazione campiona alla stessa temperatura, e un referto misurato a un'altra temperatura viene rifiutato.

PPO (Proximal Policy Optimization) con clip e vantaggio GAE, in PyTorch. La giuntura fra le due metà è un protocollo a righe fra processi: JavaScript possiede tutto ciò che sa di Pokémon (i lavoratori d'ambiente, il tracciatore dello stato, il codificatore, il generatore di squadre, gli avversari di riferimento), Python possiede solo i tensori. Così il codificatore nasce già nella lingua in cui girerà in partita.

L'avversario si ricampiona ogni 64 lotte da cinque candidati. I pesi del campionato sono stati il primo iperparametro a cambiare fra le corse.

• Sé stessa (self-play): la rete corrente.
• Le istantanee: copie congelate della rete, una ogni 50 aggiornamenti, fino a 20 in memoria. Attenuano i cicli sasso-carta-forbice.
• L'IA a regole del gioco.
• Il greedy: sempre la mossa col danno atteso più alto.
• Il caso: il pavimento, e la copertura delle mosse rare.

Ogni corsa riparte dai soli pesi di un checkpoint precedente: nessun metadato passa ai nuovi e l'ottimizzatore riparte da zero. I checkpoint nuovi portano le impronte e le regole di oggi, più il percorso e l'impronta sha256 del file di partenza. Ne esce una catena di pesi che si risale fino alla prima corsa, e nessun anello si cancella.

Dall'esperimento B una quota delle partite si gioca a squadre speculari: stessa squadra per i due lati, livello 16, ogni coppia giocata due volte con i lati invertiti. È la condizione in cui si giudica la bravura.

• La quota è in corse, non in decisioni. Una partita speculare dura quasi il doppio (29,72 decisioni contro 16,26 nella Bora), quindi il 30 % delle corse è stato il 43,9 % delle decisioni.
• Le squadre speculari dell'addestramento non sono quelle del test: stessa regola, semi diversi a ogni corsa e mosse estratte a caso. Nessuna squadra del test entra nell'addestramento.

Ogni serie è di 1000 lotte, con semi fissi e intervalli di Wilson al 95 %. Un modello si promuove solo se passa tutti i cancelli; quando si dice che un cancello «passa» si parla del limite inferiore dell'intervallo, non del tasso grezzo.

• Cancelli: i semi di sempre, per la promozione e il confronto con tutta la storia.
• Scelta: semi mai guardati prima, su cui si prende ogni decisione di progetto.
• Conferma: si usano una volta sola, sul candidato finale, dopo che ogni scelta è chiusa. Finché quella misura non c'è, i numeri di scelta si citano come misure, non come risultati.

Una differenza fra due varianti non si riporta mai come differenza di due tassi. Si giocano le stesse lotte con le due politiche e si confrontano esito per esito: l'unità è la coppia speculare (punteggio 0, 1 o 2) per G2 e G3, la lotta per G4; il test è il test del segno esatto sulle unità discordanti (McNemar esatto), e l'intervallo al 95 % viene da un bootstrap appaiato a blocchi con 10 000 ricampionamenti.

La ragione è la maledizione del vincitore: una variante scelta guardando gli stessi semi su cui la si giudica sembra sempre un po' migliore di quanto sia.

G2 e G3 come tasso grezzo e, fra parentesi, il limite inferiore di Wilson che decide il cancello. Tutte le valutazioni sono sui semi dei cancelli, alla temperatura 1,0.

La valutazione di gen2/gen2r è quella del suo checkpoint migliore; una seconda valutazione più avanti nella stessa corsa non ha mostrato nessun progresso, e la corsa è stata fermata a mano.

Prima di spendere ore di calcolo si è provata la leva più economica: rivalutare gen1 a temperatura più bassa. A 0,4 G3 sale da 0,481 a 0,494 e G2 da 0,673 a 0,703: 2-3 punti, non basta. Il difetto sta nella politica, non nel modo in cui la si campiona.

Tre corse di fila avevano lasciato G3 fermo intorno a 0,52. Prima di scrivere un'altra configurazione si è misurato dove la rete perde, con la sola informazione legittima.

Il banco di prova gioca le serie dei cancelli sostituendo alla rete agenti ibridi, cioè la rete con una classe di decisioni rimpiazzata. La prima prova è la validazione: la rete dell'esperimento B giocata dal banco dà esattamente 0,524 e 0,716, i numeri del referto ufficiale.

Il «greedy a danno vero» stima il danno con la formula del gioco (statistiche proprie vere, quelle avversarie stimate da base e livello, precisione con i gradini, brutti colpi, colpi multipli) invece di potenza × STAB × efficacia × precisione. Queste righe sono un'esplorazione sui semi dei cancelli: ogni scelta è stata poi rimisurata sui semi di scelta.

1. La rete gioca come un greedy che sa fare i conti, non meglio: 0,524 contro 0,522.
2. Il suo valore sta nei cambi. Togliendoli perde 3,8 punti contro il greedy. I suoi cambi volontari sono l'8,3 % delle decisioni, contro l'1,1 % del greedy a danno vero.
3. Sceglie male l'attacco. Nel 12,6 % dei suoi attacchi rinuncia a più del 10 % dei PS avversari rispetto al migliore; sostituire solo quella scelta vale +4,6 punti contro il greedy.
4. Le sue mosse di stato non servono, in media, mentre il sonno usato da una regola vale circa 4 punti.
5. I limiti dell'osservazione spiegano perché. Il 38 % degli slot mossa è di stato, e la codifica ne vede solo potenza zero, precisione e tipo; il 70 % delle mosse di danno ha proprietà che non porta (colpi multipli, stati secondari, ricarica, critico alto); nel 28 % delle specie due mosse sono identiche per la codifica ma fanno cose diverse; la rete non vede le statistiche avversarie né chi muove per primo, e dovrebbe imparare la formula del danno da un ±1 a fine partita.

Conclusione. Iperparametri, temperatura e quote del campionato valgono 1-3 punti per corsa; un'osservazione che non vede la cosa da imparare è un tetto che nessuna corsa sfonda.

La regola H4 è diventata un modulo tattico deterministico, in JavaScript, che legge solo la vista legittima: la rete decide se attaccare, cambiare o usare una mossa di stato, e la tattica sceglie quale attacco e addormenta per primo un nemico sano. La parità col banco è esatta: 590 e 754 su 1000.

In un primo momento la tattica non guidava il modello in partita: era il maestro per la generazione successiva, un avversario forte nel campionato e il metro dei confronti. Misurata sui semi di scelta:

• con la tattica passano G2 e G3 tutti e quattro i modelli misurati; il limite inferiore di G3 va da 0,565 a 0,600, senza tattica da 0,493 a 0,521;
• appaiato, la tattica vale da +3,5 a +5,5 punti su G2 e da +5,8 a +9,2 su G3, con p < 0,006;
• G4 perde 2-3 punti (resta almeno +0,227), e la perdita viene dalla scelta dell'attacco, non dal sonno; il sonno da solo vale +4,3 punti di G3.

Una corsa di 10 milioni di decisioni con la tattica dentro l'ambiente (470 229 lotte) ha risposto a un'altra domanda: quanto valgono i cambi appresi quando gli attacchi sono già buoni? Poco: sui semi di scelta perde 3,3 punti di G3 contro la rete dell'esperimento B con la tattica (p 0,04), sui semi dei cancelli ne guadagna 3,3 di G2. Due segni opposti: la differenza è piccola e instabile, coerente con il tetto dell'osservazione.

Nella Bora hardcore l'utente ha notato mosse senza senso: mosse di stato una dopo l'altra, un Pokémon lasciato in piedi quando si poteva finirlo. La sua scelta è stata accendere la tattica in partita e abbassare la temperatura, lasciando al modello la possibilità di potenziarsi contro un avversario poco pericoloso.

Il 25 settembre si è scoperto che quelle mosse non erano del modello: in partita giocava ancora l'IA a regole (sezione 8). Le misure di v4 qui sotto restano valide, perché sono fatte fuori dal gioco, sui semi di scelta.

Nasce la versione v4: la tattica di prima più un filtro sull'azione finale. Una mossa di stato diventa l'attacco migliore quando:

• un attacco legale mette KO secondo la stima, con precisione almeno 0,8;
• la mossa dà solo uno stato a chi ne ha già uno o ne è immune;
• la mossa cambia solo statistiche già al limite.

Un potenziamento con margine, senza un KO subito, resta. Dieci test nuovi e quattordici mutazioni, tredici uccise; l'unica sopravvissuta è equivalente sui dati di oggi.

Misure sui semi di scelta, con la rete dell'esperimento C. Appaiato contro la stessa rete senza tattica, v4 a 0,5 vale +4,4 punti di G2 (p 0,001) e +5,7 di G3 (p < 0,001), mentre G4 perde 2,2 punti (p 0,094, non significativo). Contro v2 nessuna differenza significativa: v4 non cambia i cancelli, toglie le mosse senza senso che l'utente ha visto. E il potenziamento non sparisce: le mosse che alzano una propria statistica sono lo 0,95 % senza tattica e lo 0,88 % con v4, una differenza nel rumore.

Il modello scelto per l'avversario della Bora hardcore è la rete dell'esperimento C con la tattica v4, a temperatura 0,5. La rete decide se attaccare, cambiare o potenziarsi; la tattica sceglie quale attacco e toglie le mosse di stato a vuoto. Il servizio rifiuta di caricare il modello se la tattica con cui gioca non è, byte per byte, quella con cui è stato misurato.

G2, G3 e G4 sono sui semi dei cancelli. Nessuno di questi numeri è ancora una misura sui semi di conferma: quella si fa una volta sola, sul candidato finale della prossima generazione.

La tattica in partita è un ripiego misurato, non un traguardo. Dopo la diagnosi l'utente ha chiesto che l'avversario sia la rete, come un allenatore d'élite: che giochi con le informazioni della propria squadra e con ciò che ha visto dell'avversario, che conosca ogni specie e le sue abilità, e il valore di addormentare e degli altri stati. Il lavoro futuro è questo:

• Una nuova osservazione che veda ciò che la tattica sa e la rete no: gli effetti delle mosse, le statistiche avversarie stimate, chi muove per primo, le abilità possibili e gli stati.
• La conoscenza del Pokédex, cioè di ciò che ogni specie può essere e può fare, come la avrebbe un giocatore esperto — sempre senza vedere niente di nascosto.
• Una rete per Pokémon: lo stesso codificatore condiviso applicato a ogni membro delle due squadre, invece di un vettore piatto.
• Kickstarting: la rete di oggi più la tattica fa da maestro, e il suo termine nella perdita scende a zero man mano che l'allievo impara.
• Un cancello nuovo: la rete nuova senza tattica contro il maestro. E un vincolo: G4 non deve scendere sotto i modelli di oggi senza tattica, circa +0,27.

Restano aperte anche una ricompensa intermedia (da provare solo a parità di calcolo), una curva di apprendimento valutata a cancelli ogni pochi checkpoint e gli intervalli su più semi di addestramento. La scala della hardcore non è più una domanda aperta: oltre +5 la difficoltà veniva dai livelli e non dalla politica, e con questa patch il bonus si ferma a +5.

• Le impronte dei dati. La guardia ha fermato una corsa perché i dati del gioco erano cambiati mentre girava: un modello nato su dati spariti sarebbe stato rifiutato comunque, dopo ore buttate. Da allora i cambi ai dati si raggruppano prima di una corsa lunga, e durante la corsa sono congelati. Anche un commento nei dati cambia l'impronta.
• Processi legati alla sessione. Una corsa è morta a mezzanotte e 27 insieme alla sessione di lavoro che l'aveva lanciata. Le corse lunghe ora partono staccate, e una ripresa riparte dai soli pesi dell'ultimo checkpoint, in una cartella nuova.
• Metriche ingannevoli. I tassi del campionato (83-89 %) e quelli della valutazione (48-67 %) misurano due cose diverse: confonderli avrebbe fatto promuovere un modello non abbastanza forte.
• Il bilanciamento tocca tutto. Una mossa indebolita per l'addestramento ha cambiato l'esito di un test sui negozi del gioco: i test del gioco l'hanno presa.
• Prima la leva economica. La temperatura si prova in pochi minuti, e ha escluso un'ipotesi prima di spendere ore di calcolo.
• Il modello che non giocava. Il server gli chiedeva una mossa solo per le richieste del motore con un certo campo, facoltativo, che il motore di lotta non manda mai; le prove del server usavano un motore finto che quel campo lo scriveva, ed erano verdi per coincidenza. Un campo facoltativo non si usa come chiave prima di aver misurato che arriva, e un finto si scrive con la forma delle righe vere.
• Il commit registrato non era quello del lancio. I metadati leggevano la versione del codice a ogni salvataggio, non una volta all'avvio: per sapere con che codice è nata una corsa si legge il primo checkpoint, non l'ultimo.