Come il motore Stage 11 alla base di Backgammon Sage Pro è stato costruito per gestire le posizioni che ogni bot gioca peggio — backgame, giochi di contenimento e lo snake — e che cosa dicono i benchmark al riguardo.
I motori di backgammon sono sempre stati più deboli nei giochi lenti e strutturali: i backgame, in cui un giocatore tiene due o più ancore in profondità nella tavola avversaria e aspetta un tiro; i giochi di contenimento, in cui un giocatore con la corsa persa cerca di tenere intrappolate una o due pedine colpite; e lo snake, un prime nella metà lontana della tavola che trattiene una sola pedina attardata mentre il resto dell'esercito avversario si sbriciola. Queste posizioni sono rare nel gioco ordinario e insolitamente lunghe quando si presentano, quindi sono appena rappresentate nei dati di gioco contro se stesso da cui un motore impara, e un motore che le ha viste a malapena le valuta estrapolando da posizioni che sembrano soltanto simili. Il motore Open Sage Stage 9 è stato addestrato su posizioni di backgame e a livelli di valutazione equivalenti ottiene punteggi migliori di eXtreme Gammon, ma in questi giochi il suo tasso di errore resta parecchie volte superiore a quello che ha altrove. Stage 11 affronta il problema di petto. Prima abbiamo costruito benchmark fatti di backgame, giochi di contenimento e snake, ciascuno valutato come Performance Rating rispetto a riferimenti di qualità rollout; poi abbiamo aggiunto al motore sei reti neurali, selezionate da un piccolo insieme di regole strutturali; poi abbiamo generato obiettivi di rollout per ognuna di esse; e infine abbiamo valutato il risultato su tutti i benchmark di cui disponiamo. Sul benchmark di contenimento Stage 11 riduce il PR a 3 ply da 6,89 a 3,58 e il numero di blunder da 156 a 53; sui dieci benchmark classici di backgame il suo PR a 1 ply scende da 4,75 a 2,98; e il suo gioco nelle partite illimitate e a Paskogammon — una variante giocata da una posizione iniziale personalizzata che porta a molti più backgame — è invariato o migliore.
I motori di backgammon a reti neurali imparano da milioni di partite giocate contro se stessi, e imparano ciò che quelle partite contengono. Backgame, giochi di contenimento e prime che trattengono una sola pedina attardata sono rari nel gioco ordinario e insolitamente lunghi quando si presentano, così un motore generalista ne vede pochi e li valuta estrapolando da posizioni che sembrano simili ma non lo sono. Il risultato è una debolezza ben nota: un motore che in una partita normale commette un errore ogni venti decisioni può commetterne uno ogni tre in un backgame profondo, e tende a sbagliare le stesse cose che sbaglia un giocatore umano di livello intermedio — quando tenere un'ancora e quando correre, quanto timing ha una posizione, e quando un prime va sciolto.
Il motore Open Sage Stage 9, che alimenta Backgammon Sage Pro, include già due reti addestrate specificamente su posizioni di backgame, e il nostro studio sulle prestazioni del bot mostra che a ogni livello equivalente valuta almeno quanto eXtreme Gammon. Ma essere forti rispetto agli altri bot non equivale a essere forti in termini assoluti. Misurato rispetto ai rollout, il tasso di errore di Stage 9 nei backgame è due o tre volte quello delle partite ordinarie, e nei giochi di contenimento e negli snake è peggiore ancora: sul benchmark snake qui sotto il suo Performance Rating a 1 ply supera 60, contro un valore di 2,6 nelle partite illimitate.
Stage 11 è progettato per eliminare queste debolezze senza toccare nient'altro. Il lavoro si è svolto in quattro passi. Primo, abbiamo costruito una famiglia di benchmark che misurano il gioco di backgame e di contenimento in diversi tipi di posizione — dieci tipi classici di backgame, una famiglia di contenimento, una famiglia di backgame massicci e una famiglia snake — ognuno un insieme di decisioni reali valutate rispetto a riferimenti di qualità rollout, così che Stage 9, Stage 11 e XG possano essere misurati sullo stesso piano. Secondo, abbiamo progettato il modello Stage 11: le diciassette reti di Stage 9 riprese senza modifiche, più sei nuove reti per le famiglie di backgame, e un algoritmo di instradamento che decide dalla struttura di una posizione quale rete la valuta. Terzo, abbiamo generato i dati di addestramento per ogni nuova rete — una miscela di posizioni raccolte dal gioco contro se stesso, posizioni sintetiche e corpora di rollout esistenti, tutte sottoposte a rollout per produrre gli obiettivi. Quarto, abbiamo addestrato le reti e valutato il motore finito su ogni benchmark di backgame e sui nostri benchmark di rollout PR per partite illimitate, match a 5 punti e Paskogammon (una variante giocata da una posizione iniziale personalizzata scelta per produrre molti backgame), per assicurarci che i guadagni nei backgame non costassero nulla altrove.
La versione breve dei risultati: Stage 11 è nettamente più forte ovunque le nuove reti entrino in gioco e identico a Stage 9 ovunque non lo facciano. Il suo PR a 3 ply sul benchmark di contenimento è circa la metà di quello di Stage 9, i suoi blunder lì calano di due terzi, il suo PR a 1 ply aggregato sui dieci backgame classici scende del 37%, ed è il primo motore Open Sage a fare progressi reali sullo snake. Il gioco nelle partite illimitate è invariato e quello a Paskogammon migliora. Il resto di questa pagina fornisce i dettagli.
Ogni benchmark qui segue la stessa ricetta del nostro benchmark di rollout PR per partite illimitate: un insieme di decisioni reali, ciascuna con una valutazione di riferimento di qualità rollout, rispetto alla quale un motore è valutato come Performance Rating — il suo errore medio di equity per decisione, moltiplicato per 500, la convenzione usata da XG. Un PR di 2 significa che il motore cede in media 0,004 punti per decisione; un PR di 60 significa 0,12 per decisione, cioè il territorio di un principiante.
Ciò che cambia è da dove vengono le decisioni. Ogni benchmark di backgame parte da un piccolo insieme di posizioni seme che definiscono la sua famiglia — le posizioni di riferimento mostrate nei caroselli qui sotto. Il motore gioca poi da quei semi partite illimitate contro se stesso, con il cubo, con Jacoby e beaver attivi, a 3 ply, e ogni decisione che si presenta mentre la posizione appartiene ancora alla famiglia viene registrata: una mossa di pedine conta quando ci sono almeno due mosse legali e una differenza di equity significativa tra loro, e una posizione di cubo conta quando la decisione di chi raddoppia non è banale o quando un raddoppio viene effettivamente offerto. I semi sono usati in un ciclo mescolato, chi muove per primo è deciso da una moneta, e tutto è una funzione pura di un unico seme casuale, così ogni benchmark si rigenera in modo identico.
Ogni decisione registrata viene poi sottoposta a rollout per produrre il suo riferimento: 5.184 percorsi per posizione giocati fino alla fine, con decisioni di pedine e di cubo a 3 ply per le prime tre semimosse e a 2 ply da lì in avanti, riduzione della varianza attiva, distribuiti su una flotta di worker nel cloud. Il riferimento di una decisione di pedine contiene l'equity da rollout di ogni candidata tenuta dal filtro del giocatore di riferimento; quello di una decisione di cubo contiene le equity di non raddoppio, raddoppio/take e raddoppio/pass. Una sottigliezza conta nel confronto tra motori: una candidata fuori dall'insieme del filtro del giocatore di riferimento è valutata solo alla precisione del filtro, il che penalizza in eccesso un motore le cui scelte differiscono da quelle del giocatore di riferimento. Abbiamo quindi eseguito passaggi di completamento delle candidate — sottoponendo a rollout, con la stessa convenzione, ogni mossa effettivamente scelta da Stage 9 o da Stage 11 a 1, 2 o 3 ply — così che ogni punteggio qui sotto sia calcolato rispetto a candidate di qualità rollout.
Un backgame prende il nome dai due punti che il suo proprietario tiene nella tavola interna avversaria: il backgame 2‑1 tiene il 2-punto e l'1-punto dell'avversario, il 5‑4 tiene il 5-punto e il 4-punto, e così via. Dieci tipi coprono le combinazioni utili. I semi di ogni cartella sono posizioni selezionate a mano da file di riferimento XG, e il suo benchmark contiene circa 1.000 decisioni — registrate solo finché le due ancore indicate sono ancora tenute e chi le tiene è indietro nella corsa — per un totale aggregato di 10.021 decisioni. Anche le posizioni seme di ogni cartella sono posizioni del benchmark, come decisioni di cubo. Seleziona un tipo per scorrere le sue posizioni seme; ogni scheda mostra l'analisi del cubo da rollout della posizione accanto alla tavola.
Un gioco di contenimento è definito da chi fugge, non da chi contiene: una parte ha portato fuori un certo numero di pedine e ha da una a tre pedine che sono state colpite e devono percorrere tutta la tavola per tornare a casa, mentre l'altra parte, con la corsa persa, dispone ciò che le resta — ancore, blot, un prime spezzato — per continuare a colpirle, giocando per salvare il gammon o, a volte, per vincere. Nulla è richiesto alla struttura di chi contiene. I 201 semi del benchmark provengono da posizioni che il motore aveva già incontrato (decisioni dei benchmark per partite illimitate e Paskogammon con il loro cubo, e righe delle pile di addestramento dei backgame), filtrate con quella regola, e le sue 3.197 posizioni — tra cui le decisioni di cubo dei semi stessi — sono registrate finché chi fugge ha ancora pedine intrappolate. Un secondo riferimento per un campione di 300 posizioni è stato sottoposto a rollout con Stage 11, anziché Stage 9, a giocare le prove, per verificare che la scelta del giocatore di prova non decida il confronto.
Un backgame massiccio tiene tre o più ancore nella tavola interna avversaria, oppure due ancore con sette o più pedine indietro: le posizioni profonde, guidate dal timing, in cui il giocatore di backgame ha impegnato gran parte dell'esercito. I 200 semi provengono dalle stesse fonti dei semi di contenimento, filtrati con quella regola e tenuti disgiunti dalle famiglie di contenimento e snake, e il benchmark contiene 2.199 posizioni.
Lo snake è un prime nella metà lontana della tavola che trattiene una sola pedina attardata: una sequenza di quattro o più punti consecutivi, ciascuno fatto con due o più pedine, interamente nella metà avversaria della tavola, che intrappola una pedina sulla barra o nella tavola interna di chi tiene il prime mentre le altre dieci o più pedine avversarie sono già ammassate a casa. È un gioco di prime più che un backgame, e una delle forme più difficili da giocare nel backgammon: chi tiene il prime deve farlo rotolare verso casa senza liberare la pedina attardata, e il momento in cui la libera decide la partita. Poiché la posizione è rara nel gioco, i 74 semi includono varianti sintetiche della forma classica (lunghezza e posizione del prime, posizione della pedina attardata, ripartizione dell'ammasso) accanto alle poche trovate nei dati esistenti; il benchmark contiene 1.073 posizioni.
Tre benchmark misurano partite intere anziché una famiglia di posizioni, ed esistono per dimostrare che nulla è andato perduto: il rollout PR per partite illimitate (500 partite, 17.535 decisioni), il rollout PR per match a 5 punti (130 match, 18.292 decisioni, con il punteggio del match che attraversa ogni decisione di cubo) e il rollout PR per Paskogammon (2.556 decisioni, giocate dalla posizione di apertura sparpagliata del Paskogammon, che produce molti più backgame e giochi di contenimento del backgammon standard). Tutti e tre costruiscono i riferimenti in modo adattivo — 3 ply per le decisioni chiare, rollout troncati per quelle più vicine, rollout completi a 1.296 percorsi per le più vicine in assoluto — come descritto nello studio sulle prestazioni del bot.
Anche XG è stato valutato su questi benchmark. Non espone alcuna interfaccia programmatica, quindi ogni decisione del benchmark viene scritta come partita di una sola decisione e ripercorsa tramite la sua funzione Batch Analysis, una passata per livello di valutazione, esattamente come per i benchmark di partita illimitata e di match. Quei risultati si trovano sulla pagina prestazioni del bot, che confronta il motore con XG; le tabelle qui confrontano Stage 11 con lo Stage 9 che sostituisce.
Stage 9 è un comitato di diciannove reti neurali: una per le corse pure, sedici selezionate dalla coppia di piani di gioco che le due parti stanno perseguendo (corsa, attacco, prime, ancoraggio), e due reti di backgame — una per il giocatore che tiene un backgame e una per l'avversario — usate quando la coppia di piani è ancoraggio contro corsa, la parte che ancora è indietro nella corsa e tiene due o più ancore nella tavola interna avversaria. Ogni rete è un singolo strato nascosto di 400 unità su 244 ingressi (100 unità su 196 ingressi per la rete di corsa), che produce cinque uscite: le probabilità di vincere, vincere un gammon, vincere un backgammon, perdere un gammon e perdere un backgammon.
Stage 11 mantiene le diciassette reti standard byte per byte e sostituisce le due reti di backgame con sei, per un comitato di ventitré:
| # | Rete | Regione che valuta |
|---|---|---|
| 0–16 | Le reti di corsa e di coppie di piani di Stage 9 | Tutto il resto, esattamente come in Stage 9 |
| 17 | Backgame profondo | I backgame 2‑1, 3‑1 e 3‑2: entrambe le ancore sull'1-, 2- o 3-punto avversario |
| 18 | Backgame intermedio | I backgame 4‑1, 4‑2, 5‑1 e 5‑2: un'ancora sull'1- o 2-punto, una più in alto |
| 19 | Doppia ancora | I backgame 4‑3, 5‑3 e 5‑4: due ancore, nessuna più profonda del 3-punto |
| 20 | Contenimento iniziale | Un giocatore di backgame che ha colpito un tiro mentre chi corre ha ancora al massimo due pedine fuori, in posizioni che il filtro delle coppie di piani affiderebbe altrimenti a una rete standard |
| 21 | Contenimento | Qualsiasi gioco di contenimento, qualunque cosa tenga chi contiene |
| 22 | Snake | Un prime nella metà lontana che trattiene una pedina attardata contro una tavola ammassata |
Due scelte progettuali contano più del numero. Le reti di backgame sono scelte dalla categoria del backgame — la stessa rete a prescindere da chi lo tiene — e non da chi lo tiene, così ognuna impara una sola struttura da entrambe le prospettive. E la rete per una mossa di pedine è scelta dalla posizione prima della mossa, così una sola rete valuta ogni candidata, comprese quelle che lasciano la sua regione (la mossa che rinuncia a un'ancora, o che scioglie il prime); è questo che rende coerenti le decisioni tra tenere e correre, ed è anche il motivo per cui i dati di addestramento di ogni rete devono includere le posizioni a cui quelle mosse di rilascio conducono.
L'algoritmo di instradamento è un breve elenco ordinato di test strutturali sulla posizione, in cui vince il primo che corrisponde:
Poiché i test sono strutturali, la loro impronta può essere misurata su qualsiasi insieme di posizioni, ed è quell'impronta a limitare il rischio: sul benchmark per partite illimitate la regola di contenimento scatta sull'1,3% delle posizioni, la regola di contenimento iniziale sullo 0,6% e le regole di backgame sul 2,4%, mentre la regola snake non scatta mai; sul benchmark Paskogammon le cifre sono 2,6%, 20% e 25%. Il 95% di posizioni ordinarie che Stage 11 valuta in modo identico a Stage 9 è, per costruzione, invariato.
Ogni nuova rete è stata addestrata come le reti di backgame di Stage 9: apprendimento supervisionato sulla GPU rispetto a obiettivi da rollout — le cinque probabilità che un rollout completo assegna a una posizione — con partenza a caldo da una rete esistente, conservando il checkpoint che ottiene il punteggio migliore su un decimo dei dati tenuto da parte. Ciò che cambia per ogni rete è da dove vengono le sue posizioni, e ogni risposta ci ha insegnato qualcosa.
Stage 9 e Stage 10 avevano già accumulato posizioni di backgame sottoposte a rollout — partite standard e partite di Paskogammon, circa 640.000 righe in tutto. Dividerle per categoria ha dato 245.000 righe di addestramento profonde, 167.000 intermedie e 94.000 a doppia ancora, con righe di benchmark tenute da parte e deduplicate rispetto a esse. Addestrato solo su quelle, il trio era migliore di Stage 9 dentro la sua regione e peggiore ai suoi margini: una rete che ha visto solo posizioni con entrambe le ancore tenute non ha idea di quanto valga la posizione una volta ceduta un'ancora, e poiché valuta ogni candidata di una decisione di backgame, tirava a indovinare — circa 0,3 punti troppo ottimista, il che spiegava più della metà del suo errore sui benchmark profondi. Il rimedio è stato raccogliere i discendenti di uscita: per ogni posizione di addestramento, le mosse legali che lasciano la categoria, sottoposte a rollout nell'orientamento in cui l'instradatore le valuta. Quarantamila per categoria, aggiunte all'insieme di addestramento, hanno eliminato quella modalità di errore. La partenza a caldo dalla rete di backgame di Stage 9 ha battuto sia una partenza casuale sia un avvio per differenze temporali.
Analizzare dove stava l'errore residuo del trio ha mostrato che era guidato dalla fase della partita più che dalle ancore tenute: cresceva man mano che chi corre rientrava, ed era peggiore subito dopo che chi tiene il backgame aveva colpito un tiro. Specialisti di fase addestrati sulle fette corrispondenti degli stessi dati non hanno battuto il trio dentro la sua regione — ma sulle posizioni di contenimento che il filtro delle coppie di piani rifiuta (il blocco residuo di chi corre viene letto come un prime, così Stage 9 affida la posizione a una rete standard), uno specialista di contenimento iniziale ha ridotto il PR a 1 ply da 4,90 a 3,69 e dimezzato i blunder. È addestrato a partire dalla rete profonda sulle righe di contenimento iniziale dei dati del trio e usato solo lì.
La regola di contenimento è nuova, quindi la sua regione non aveva quasi dati da rollout: circa l'1% delle pile esistenti. Abbiamo giocato 3.000 partite dai semi di contenimento con Stage 11 stesso, escludendo ogni posizione e candidata del benchmark in entrambi gli orientamenti, e tenuto le posizioni che soddisfacevano la regola — 35.266 tavole nuove, più 9.734 righe già sottoposte a rollout — e le abbiamo sottoposte a rollout a 1.296 percorsi con gioco a 3 ply. Una rete addestrata su quelle 45.000 righe era eccellente sul benchmark di contenimento e peggiore di Stage 9 sulle 237 posizioni di partite illimitate che la regola le instrada: sono posizioni di contenimento di partite ordinarie (un colpo tardivo durante il bear-off, una chiusura) che non comparivano mai nei dati della famiglia. Aggiungere le 291.000 righe del corpus generale di addestramento che soddisfano la stessa regola, con le righe della famiglia pesate quattro volte, ha riportato la fetta delle partite illimitate al livello di Stage 9 e ha reso la rete migliore anche sul benchmark della famiglia. È la lezione generale di questo lavoro: una rete specialista va addestrata sulla sua intera regione, mai sull'angolo di essa che il benchmark occupa.
Lo snake non aveva dati da nessuna parte — un centinaio di righe in un corpus di 1,8 milioni — e non poteva essere raccolto dal gioco contro se stesso: in queste posizioni il modello giocava così male da spezzare il prime o correre nel giro di una o due mosse, e 900 partite hanno prodotto a malapena due decisioni snake ciascuna. Così la regione è stata campionata direttamente. Cinquemila snake sintetici (lunghezza e posizione del prime, pedine di riserva distribuite dalla metà lontana fino a casa, un avversario ammassato con fino a cinque pedine fuori e da una a tre pedine attardate) hanno fatto da seme a brevi partite a 2 ply in cui chi tiene il prime preferiva le mosse che conservano la struttura, e ogni decisione ha contribuito con la sua posizione, le sue cinque migliori candidate e fino a tre candidate di rilascio — le mosse che la rete deve valutare correttamente per sapere quando lasciar andare. Ne sono uscite 98.000 tavole distinte, di cui 22.000 sottoposte a rollout a 648 percorsi con gioco a 3 ply; le partite snake sono così lunghe che un rollout costa sei volte quello di un contenimento. La rete si addestra in pochi minuti su quell'insieme, ed è la prima rete Open Sage con una qualche competenza nella regione: il suo errore a 1 ply rispetto agli obiettivi di addestramento è sceso da 0,30 a 0,054 punti.
| Rete | Righe di addestramento | Fonte | Partenza a caldo |
|---|---|---|---|
| Backgame profondo | 245.000 + 40.000 uscite | Pile da rollout di Stage 9/10, divise per categoria; discendenti di uscita a un passo | Rete di backgame di Stage 9 |
| Backgame intermedio | 167.000 + 40.000 uscite | come sopra | Rete di backgame di Stage 9 |
| Doppia ancora | 94.000 + 40.000 uscite | come sopra | Rete di backgame di Stage 9 |
| Contenimento iniziale | fetta di fase di quanto sopra | righe di contenimento iniziale dei dati del trio | Rete di backgame profondo |
| Contenimento | 45.000 della famiglia + 291.000 generali | Gioco contro se stesso dai semi di contenimento, sottoposto a rollout; le righe della regola nel corpus generale | Rete prime-contro-corsa di Stage 9 |
| Snake | 22,000 | Semi sintetici + gioco contro se stesso che conserva la struttura, sottoposti a rollout | Rete prime-contro-corsa di Stage 9 |
Ogni valore è un Performance Rating — più basso è meglio — alla valutazione 1-ply, 2-ply e 3-ply del motore stesso e ai suoi tre livelli di rollout troncato, 1T, 2T e 3T (le controparti di Roller, Roller+ e Roller++ di XG). Entrambi i motori sono valutati rispetto agli stessi riferimenti, con ogni scelta di ciascun motore valutata su rollout. XG è confrontato con il motore sulla pagina prestazioni del bot; su Paskogammon, dove entrambi i motori sono stati eseguiti a ogni livello, il confronto è qui sotto.
| Benchmark | Decisioni | 1-ply | 2-ply | 3-ply | 1T · Roller | 2T · Roller+ | 3T · Roller++ | ||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | ||
| Partita illimitata | 17,535 | 2.59 | 2.55 | — | 1.66 | 1.68 | — | 0.60 | 0.60 | 0.57 | 0.50 | 0.49 | 0.53 | 0.26 | 0.27 | 0.41 | 0.23 | 0.23 | 0.34 |
| Match a 5 punti | 18,292 | 2.26 | 2.22 | — | 1.30 | 1.27 | — | 0.57 | 0.56 | 0.54 | 0.49 | 0.47 | 0.51 | 0.26 | 0.26 | 0.44 | 0.22 | 0.23 | 0.36 |
| Paskogammon | 2,556 | 7.74 | 6.14 | — | 5.42 | 4.57 | 4.38 | 3.46 | 2.28 | 2.97 | 2.67 | 1.65 | 2.63 | 2.21 | 1.46 | 2.44 | 1.47 | 0.88 | 1.92 |
| Backgame | Decisioni | 1-ply | 2-ply | 3-ply | 1T · Roller | 2T · Roller+ | 3T · Roller++ | ||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | ||
| 2‑1 | 1,000 | 6.59 | 3.57 | — | 4.51 | 2.26 | 2.84 | 2.70 | 1.01 | 1.64 | 2.03 | 0.61 | 1.67 | 1.72 | 0.41 | 0.98 | 1.08 | 0.38 | 0.93 |
| 3‑1 | 1,001 | 4.44 | 3.28 | — | 2.77 | 2.22 | 2.22 | 0.93 | 0.88 | 0.95 | 0.92 | 0.66 | 0.91 | 0.66 | 0.34 | 0.59 | 0.53 | 0.32 | 0.48 |
| 3‑2 | 1,008 | 4.22 | 3.31 | — | 2.47 | 2.07 | 2.39 | 1.09 | 0.91 | 1.31 | 1.40 | 0.65 | 0.95 | 0.75 | 0.44 | 0.61 | 0.74 | 0.25 | 0.51 |
| 4‑1 | 1,001 | 3.70 | 2.74 | — | 1.76 | 1.77 | 1.83 | 0.85 | 0.78 | 0.82 | 1.18 | 0.55 | 0.69 | 0.52 | 0.24 | 0.47 | 0.56 | 0.19 | 0.45 |
| 4‑2 | 1,000 | 4.16 | 3.25 | — | 2.20 | 2.16 | 1.96 | 1.04 | 0.73 | 1.05 | 1.27 | 0.63 | 0.79 | 0.55 | 0.36 | 0.61 | 0.51 | 0.27 | 0.43 |
| 5‑1 | 1,003 | 3.36 | 2.56 | — | 1.69 | 1.32 | 1.77 | 0.95 | 0.66 | 0.76 | 1.20 | 0.49 | 0.60 | 0.62 | 0.26 | 0.41 | 0.57 | 0.23 | 0.32 |
| 5‑2 | 1,002 | 3.88 | 2.61 | — | 1.74 | 1.53 | 1.60 | 0.57 | 0.49 | 0.82 | 1.37 | 0.53 | 0.63 | 0.52 | 0.33 | 0.41 | 0.52 | 0.24 | 0.30 |
| 4‑3 | 1,002 | 4.56 | 3.24 | — | 2.04 | 1.69 | 2.13 | 0.81 | 0.74 | 0.80 | 1.23 | 0.52 | 0.76 | 0.72 | 0.24 | 0.55 | 0.54 | 0.19 | 0.44 |
| 5‑3 | 1,003 | 3.79 | 2.80 | — | 1.79 | 1.86 | 2.13 | 0.96 | 1.02 | 0.89 | 1.27 | 0.68 | 0.81 | 0.69 | 0.35 | 0.46 | 0.50 | 0.21 | 0.44 |
| 5‑4 | 1,001 | 5.97 | 3.10 | — | 2.84 | 2.45 | 2.74 | 1.42 | 0.93 | 1.15 | 1.53 | 0.76 | 0.97 | 0.70 | 0.47 | 0.55 | 0.63 | 0.30 | 0.49 |
| Aggregato | 10,021 | 4.47 | 3.05 | — | 2.38 | 1.93 | 2.16 | 1.13 | 0.82 | 1.02 | 1.34 | 0.61 | 0.88 | 0.75 | 0.34 | 0.56 | 0.62 | 0.26 | 0.48 |
| Benchmark | Decisioni | 1-ply | 2-ply | 3-ply | 1T · Roller | 2T · Roller+ | 3T · Roller++ | ||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | ||
| Contenimento | 3,270 | 9.65 | 6.82 | — | 9.63 | 4.73 | 14.62 | 5.09 | 2.54 | 11.25 | 3.78 | 2.29 | 7.76 | 3.20 | 1.30 | 7.85 | 2.53 | 1.05 | 6.16 |
| Backgame massiccio | 2,103 | 9.78 | 5.71 | — | 7.88 | 4.33 | 5.76 | 4.89 | 2.56 | 4.44 | 3.85 | 1.91 | 3.14 | 3.21 | 1.39 | 2.75 | 2.80 | 1.09 | 2.64 |
| Snake | 978 | 64.87 | 21.08 | — | 39.17 | 21.00 | 39.92 | 26.51 | 21.42 | 36.64 | 28.25 | 11.19 | 32.99 | 20.96 | 8.42 | 32.38 | 14.79 | 5.85 | 32.24 |
Paskogammon è dove il lavoro sui backgame si manifesta in partite intere: giocato dalla sua posizione di apertura sparpagliata, produce molti più backgame e giochi di contenimento del backgammon standard, quindi è l'unico benchmark su partite complete in cui queste reti entrano in gioco abbastanza spesso da spostare la cifra complessiva. È anche l'unico su cui XG è stato eseguito a ogni livello che offre, dal 2 ply a Roller++ — le partite sono esportate in XG come archivi
.xg archivi, che portano esplicitamente la posizione iniziale non standard, e analizzati in batch una volta per livello. La tabella valuta Stage 9, Stage 11 e XG rispetto allo stesso riferimento di rollout sulle 2.556 decisioni del benchmark, raggruppate per livello equivalente; il migliore di ogni gruppo è evidenziato.
| Motore | PR | Pedine | Cubo | Corsa pura | Corsa | Attacco | Prime | Ancoraggio |
|---|---|---|---|---|---|---|---|---|
| Stage 9 3T | 1.47 | 1.36 | 2.21 | 0.08 | 1.46 | 1.11 | 0.80 | 2.45 |
| Stage 11 3T | 0.88 | 0.85 | 1.07 | 0.08 | 0.59 | 0.96 | 0.44 | 1.71 |
| XG Roller++ | 1.92 | 1.99 | 1.37 | 0.01 | 1.36 | 2.35 | 1.10 | 3.39 |
| Stage 9 2T | 2.21 | 2.27 | 1.80 | 0.03 | 2.21 | 2.25 | 0.90 | 3.54 |
| Stage 11 2T | 1.46 | 1.51 | 1.08 | 0.03 | 1.36 | 1.79 | 0.51 | 2.35 |
| XG Roller+ | 2.44 | 2.59 | 1.45 | 0.02 | 1.97 | 2.48 | 1.54 | 4.19 |
| Stage 9 1T | 2.67 | 2.60 | 3.16 | 0.08 | 2.55 | 1.74 | 2.17 | 4.24 |
| Stage 11 1T | 1.65 | 1.64 | 1.76 | 0.08 | 1.14 | 1.37 | 1.02 | 3.31 |
| XG Roller | 2.63 | 2.69 | 2.23 | 0.05 | 2.36 | 2.86 | 1.54 | 4.15 |
| Stage 9 4P | 2.68 | 2.75 | 2.20 | 0.14 | 2.51 | 2.46 | 1.52 | 4.37 |
| Stage 11 4P | 1.90 | 1.92 | 1.72 | 0.14 | 1.64 | 2.43 | 1.04 | 2.88 |
| XG 4-ply | 2.62 | 2.66 | 2.32 | 0.05 | 2.22 | 2.76 | 1.58 | 4.32 |
| Stage 9 3P | 3.46 | 3.53 | 2.98 | 0.03 | 3.50 | 3.62 | 2.20 | 4.84 |
| Stage 11 3P | 2.28 | 2.35 | 1.78 | 0.03 | 1.64 | 3.69 | 1.21 | 3.53 |
| XG 3-ply | 2.97 | 2.96 | 3.04 | 0.05 | 2.55 | 3.21 | 1.77 | 4.81 |
| Stage 9 2P | 5.42 | 5.39 | 5.57 | 0.16 | 5.02 | 5.19 | 4.11 | 8.02 |
| Stage 11 2P | 4.57 | 4.37 | 5.93 | 0.16 | 3.97 | 5.16 | 3.95 | 6.30 |
| XG 2-ply | 4.38 | 4.50 | 3.58 | 0.23 | 3.52 | 5.83 | 2.98 | 6.50 |
| Stage 9 1P | 7.74 | 7.67 | 8.21 | 0.26 | 6.94 | 8.51 | 6.56 | 10.61 |
| Stage 11 1P | 6.14 | 5.93 | 7.58 | 0.26 | 5.18 | 8.55 | 4.70 | 8.18 |
Il motore, i benchmark, le posizioni seme, i riferimenti e ogni script di addestramento sono nel repository open source bgsage (MPL-2.0). I benchmark di backgame si trovano sotto
backgame_ref_positions/benchmark/ — un file starting.txt di semi, un file
benchmark.txt di decisioni e un riferimento rollout.jsonl per cartella — e sono generati da scripts/backgame_benchmark.py, con i semi delle tre famiglie prodotti da scripts/build_family_seeds.py, e valutati da
scripts/score_backgame_pr.py, che riporta il PR insieme alla quota di scelte di qualità rollout. Le regole di instradamento sono in cpp/src/neural_net.cpp
con implementazioni di riferimento in Python in scripts/containment_rule.py e
scripts/snake_rule.py, e il modello stesso è la voce stage11s del registro dei pesi. Gli script dei dati di addestramento sono indicati nella tabella qui sopra in base alla loro fonte; i rollout di cui hanno bisogno sono distribuiti da orchestratori che non fanno parte del repository pubblico, ma ogni file di posizioni e ogni obiettivo da rollout lo è.
| Cubeless | Vittoria | Gammon | Backgammon |
|---|---|---|---|
| Giocatore | |||
| Avversario |
| Azione di cubo | Equity |
|---|---|
| Nessun raddoppio | |
| Raddoppio / Take | |
| Raddoppio / Pass |