Un confronto quantitativo tra il motore di valutazione Open Sage — il motore di Backgammon Sage Pro — e il motore del bot di eXtreme Gammon (XG).
Confrontiamo il motore Open Sage con eXtreme Gammon (XG) a livelli di valutazione equivalenti — valutazione diretta della rete neurale, ricerca multi-ply e rollout troncati. Poiché XG non espone alcuna interfaccia programmatica, lo valutiamo tramite la sua funzione Batch Analysis. Usiamo tre metodi complementari. Il primo costruisce un insieme stratificato di valutazioni di riferimento — fidandosi delle valutazioni rapide dove la scelta è chiara e portando i casi incerti a rollout completi — e assegna a ciascun motore un Performance Rating (PR) rispetto a quel riferimento, su 500 partite illimitate (17.535 decisioni) e 130 match da cinque punti (18.292 decisioni). Per le partite illimitate ricostruiamo poi l’intero confronto usando come riferimento l’analisi stratificata di XG stesso — lo specchio esatto. Il secondo isola le posizioni illimitate su cui Sage 3T e XG Roller++ sono realmente in disaccordo e giudica ciascuna rispetto ai rollout completi di entrambi i motori. Lo stesso metodo di riferimento e punteggio è applicato a tredici benchmark di backgame, partite di contenimento e snake — le posizioni che i motori hanno storicamente giocato peggio. Negli studi di forza i due motori sono vicini: con il riferimento di Sage, Sage è in vantaggio ai livelli di rollout troncato su cui fa affidamento la maggior parte degli utenti; con quello di XG, XG è in vantaggio o alla pari. Il terzo metodo ribalta la domanda: su 290 match reali di torneo già analizzati in XG, rianalizziamo ciascuno in Sage e confrontiamo il Performance Rating che i due motori assegnano a ogni giocatore. I due rating vanno di pari passo: su 580 rating di giocatori hanno una correlazione del 98%, e la differenza media tra loro è di +0.002 PR — statisticamente indistinguibile da zero.
eXtreme Gammon (XG) è un riferimento standard per l’analisi computerizzata del backgammon, e il suo motore di valutazione è generalmente considerato uno dei più forti disponibili. Qualsiasi nuovo motore che voglia essere preso sul serio deve rispondere a una domanda semplice: come si colloca rispetto a XG? Questo studio si propone di rispondere in modo quantitativo per Open Sage, il motore a rete neurale dietro Backgammon Sage Pro.
Il nostro obiettivo era confrontare le valutazioni di Open Sage con quelle di XG a livelli di sforzo comparabili. L’esperimento naturale — far giocare i motori l’uno contro l’altro per molti milioni di partite e contare il risultato — non è praticabile: l’app desktop di XG non espone alcuna interfaccia programmatica, quindi passare posizioni e mosse da un motore all’altro è un processo manuale, a colpi di clic. Raggiungere un campione abbastanza grande da risolvere le piccole differenze tra due motori forti richiederebbe troppo tempo.
Usiamo invece la funzione Batch Analysis di XG, che può valutare centinaia di partite trascritte in un’unica passata non presidiata. Open Sage gioca entrambi i lati di molte partite; ogni partita viene esportata in un formato di testo standard che XG può importare; XG analizza il tutto; e noi ne estraiamo i verdetti. Su questa base comune applichiamo due metodi distinti, descritti nella Sezione 3 e nella Sezione 4.
Un terzo studio (Sezione 5) mette del tutto da parte le simulazioni e lavora su match di torneo reali analizzati in XG. Il suo scopo è diverso: invece di chiedersi quale motore sia più forte, verifica se un giocatore che analizza un match in Sage ottiene lo stesso Performance Rating che gli darebbe XG — così che anni di intuizione su cosa significhi un PR in XG si trasferiscano direttamente a Sage.
Entrambi i motori possono valutare una posizione a diverse profondità, scambiando precisione con velocità. Capire questi livelli è essenziale per leggere i risultati, perché il confronto è sempre tra livelli equivalenti dei due motori.
Valutazione diretta (1-ply). L’output grezzo della rete neurale per una posizione, senza ricerca in avanti. È l’impostazione più veloce e la base su cui è costruito ogni livello più profondo. (Seguiamo la convenzione di XG, in cui 1-ply indica la valutazione grezza della rete.)
Ricerca multi-ply (2, 3, 4-ply). Il motore guarda diversi turni avanti, considerando le risposte dell’avversario e facendo la media sui possibili tiri di dadi a ogni passo, con una valutazione grezza della rete alla fine di ogni variante. Ogni ply in più è più preciso e sensibilmente più costoso.
Rollout troncati (1T, 2T, 3T). Invece di cercare fino a una profondità fissa, il motore gioca molte brevi partite simulate, le tronca dopo pochi turni e valuta la posizione risultante con una ricerca multi-ply. La riduzione della varianza elimina gran parte della fortuna nei dadi campionati. Sono le impostazioni “Roller” di XG: sono più forti della ricerca a profondità fissa e restano molto più economiche di un rollout completo.
Rollout completo. Molte partite simulate giocate fino alla fine. Eseguito con un volume sufficiente e con riduzione della varianza, un rollout completo è quanto di più vicino alla verità un motore di backgammon possa produrre, e in tutto questo studio lo usiamo come standard di riferimento.
| Famiglia | Sage | Equivalente XG | Cosa fa |
|---|---|---|---|
| Diretta | 1-ply | 1-ply (valutazione grezza) | Una singola valutazione della posizione da parte della rete neurale — nessuna ricerca in avanti. |
| Multi-ply | 2P · 3P · 4P | 2-ply · 3-ply · 4-ply | Esplora le risposte dell’avversario per diversi turni di profondità, facendo la media sui dadi. |
| Rollout troncato | 1T · 2T · 3T | Roller · Roller+ · Roller++ | Molte brevi partite simulate, troncate dopo 5–7 turni e valutate in multi-ply, con riduzione della varianza. 3T/Roller++ usano decisioni a 3-ply; 2T/Roller+ a 2-ply; 1T/Roller a 1-ply. |
| Rollout completo | Rollout | Rollout | Partite simulate giocate fino alla fine — la “verità” di riferimento in questo studio. |
Il primo metodo valuta ogni motore su un insieme fisso di decisioni di cui abbiamo stabilito la “vera” giocata migliore nel modo più accurato possibile. Segue lo stesso approccio del noto studio XG del 2012 che confrontava XG con diversi altri bot.
Abbiamo iniziato simulando 500 partite illimitate di Sage 3P contro se stesso. Un livello moderatamente forte come il 3P produce una distribuzione realistica di posizioni in ogni piano di gioco — corsa, attacco, prime, ancoraggio — che è esattamente la varietà su cui vogliamo fare il test. Abbiamo poi ripetuto l’intero studio una seconda volta su 130 match a cinque punti, dove il punteggio cambia il valore di ogni decisione; i risultati di entrambi sono riportati sotto.
Stabilire la vera giocata migliore per ogni decisione con un rollout completo sarebbe enormemente costoso — e inutile, perché la maggior parte delle decisioni non è serrata. Costruiamo quindi il riferimento in tre passate successive, spendendo lo sforzo del rollout solo dove la scelta è davvero in dubbio. La stessa ricetta si applica a entrambi gli insiemi di dati; ogni passata risolve le decisioni che può decidere con sicurezza e passa le altre a quella successiva:
Ogni decisione viene valutata a 3-ply. Dove la mossa migliore supera la seconda di più di 0.05 di equity, il verdetto del 3P è accettato come verità e la decisione è risolta.
Le decisioni rimaste vengono rivalutate a 3T. Dove il margine è ora più ampio di 0.02 di equity, il verdetto del 3T è accettato come verità.
Tutto ciò che resta entro 0.02 viene risolto con un rollout completo di Sage: decisioni a 3P sia per il gioco delle pedine sia per le azioni del cubo, eseguito in lotti da 1,296 partite simulate finché l’intervallo di confidenza al 95% sull’equity scende sotto 0.005 — o fino a un tetto di 20,736 partite simulate (16 × 1,296). Le posizioni di backgame più lente hanno richiesto ben oltre un’ora ciascuna.
Il risultato è un riferimento stratificato in cui ogni decisione è risolta esattamente alla profondità che la sua difficoltà richiede. Abbiamo eseguito questa stessa ricetta in tre passate su entrambi gli insiemi di dati — le 500 partite illimitate e i 130 match a cinque punti — e la composizione dei livelli risultante è mostrata accanto ai risultati di ciascun insieme qui sotto.
Con in mano un insieme stratificato di valutazioni affidabili, valutare un motore qualsiasi è semplice: gli presentiamo ogni decisione del benchmark, registriamo l’errore di equity della mossa o dell’azione del cubo che sceglie rispetto alla verità, e riportiamo l’errore medio × 500 come PR. Lo stesso totale è suddiviso in PR del gioco delle pedine e PR del cubo, e ulteriormente per piano di gioco.
Valutare XG ha richiesto il passaggio in più descritto nell’introduzione. Poiché XG non ha API, abbiamo eseguito la sua Batch Analysis sulle trascrizioni delle 500 partite illimitate e dei 130 match con un livello personalizzato — decisioni a 3-ply, con passaggio al livello in esame ovunque ci fosse disaccordo — e abbiamo estratto la decisione preferita da XG per ogni posizione dai file
.xg
che produce, valutandole rispetto alle stesse equity di riferimento.
Sulle 500 partite illimitate, le tre passate hanno risolto 16,889 posizioni (17,535 decisioni) come segue:
I cinque livelli equivalenti, valutati su quelle 17,535 decisioni. Un PR più basso è meglio; il motore più forte di ogni coppia è evidenziato.
PR di ogni motore e livello testato, suddiviso per tipo di decisione e piano di gioco. Più basso è meglio.
| Motore | PR | Pedine | Cubo | Corsa pura | Corsa | Attacco | Prime | Ancoraggio |
|---|---|---|---|---|---|---|---|---|
| Sage 3T | 0.23 | 0.20 | 0.41 | 0.02 | 0.25 | 0.20 | 0.32 | 0.32 |
| XG Roller++ | 0.34 | 0.33 | 0.38 | 0.04 | 0.44 | 0.25 | 0.41 | 0.48 |
| Sage 2T | 0.27 | 0.24 | 0.43 | 0.02 | 0.32 | 0.20 | 0.40 | 0.36 |
| XG Roller+ | 0.41 | 0.41 | 0.39 | 0.05 | 0.60 | 0.31 | 0.47 | 0.54 |
| Sage 1T | 0.49 | 0.50 | 0.43 | 0.04 | 0.58 | 0.43 | 0.62 | 0.64 |
| XG Roller | 0.53 | 0.54 | 0.48 | 0.05 | 0.64 | 0.45 | 0.71 | 0.67 |
| Sage 4P | 0.43 | 0.42 | 0.52 | 0.08 | 0.54 | 0.39 | 0.45 | 0.60 |
| XG 4-ply | 0.47 | 0.46 | 0.52 | 0.06 | 0.59 | 0.40 | 0.57 | 0.59 |
| Sage 3P | 0.60 | 0.60 | 0.61 | 0.13 | 0.78 | 0.53 | 0.67 | 0.75 |
| XG 3-ply | 0.57 | 0.57 | 0.58 | 0.05 | 0.72 | 0.48 | 0.73 | 0.72 |
| Sage 2P | 1.68 | 1.44 | 2.91 | 0.40 | 1.84 | 1.86 | 1.87 | 1.77 |
| Sage 1P | 2.55 | 2.42 | 3.24 | 0.42 | 2.71 | 2.79 | 3.13 | 2.74 |
Tutti i numeri qui sopra valutano i motori rispetto al riferimento stratificato di Sage. L’obiezione ovvia è il vantaggio di giocare in casa — Sage viene misurato contro i propri rollout. Abbiamo quindi costruito lo specchio esatto: le stesse 500 partite e le stesse decisioni, ma con l’analisi di XG stesso come verità a ogni livello. XG 3-ply risolve le decisioni del livello 3P, XG Roller++ quelle del livello 3T e il rollout completo di XG quelle sottoposte a rollout — l’analogo livello per livello, in XG, del riferimento Sage. Ogni motore viene poi rivalutato rispetto a quello.
| Motore | PR | Pedine | Cubo | Corsa pura | Corsa | Attacco | Prime | Ancoraggio |
|---|---|---|---|---|---|---|---|---|
| Sage 3T | 0.28 | 0.26 | 0.41 | 0.02 | 0.40 | 0.23 | 0.31 | 0.37 |
| XG Roller++ | 0.21 | 0.20 | 0.23 | 0.01 | 0.30 | 0.18 | 0.22 | 0.25 |
| Sage 2T | 0.30 | 0.29 | 0.36 | 0.02 | 0.39 | 0.28 | 0.36 | 0.38 |
| XG Roller+ | 0.30 | 0.32 | 0.23 | 0.01 | 0.48 | 0.25 | 0.26 | 0.40 |
| Sage 1T | 0.46 | 0.47 | 0.42 | 0.03 | 0.61 | 0.42 | 0.50 | 0.57 |
| XG Roller | 0.40 | 0.41 | 0.35 | 0.03 | 0.53 | 0.34 | 0.53 | 0.45 |
| Sage 4P | 0.39 | 0.38 | 0.43 | 0.06 | 0.55 | 0.36 | 0.42 | 0.42 |
| XG 4-ply | 0.34 | 0.33 | 0.40 | 0.03 | 0.46 | 0.33 | 0.41 | 0.36 |
| Sage 3P | 0.50 | 0.49 | 0.56 | 0.08 | 0.67 | 0.47 | 0.56 | 0.56 |
| XG 3-ply | 0.41 | 0.41 | 0.40 | 0.03 | 0.54 | 0.36 | 0.52 | 0.46 |
| Sage 2P | 1.38 | 1.17 | 2.44 | 0.30 | 1.57 | 1.50 | 1.55 | 1.45 |
| Sage 1P | 2.19 | 2.07 | 2.81 | 0.36 | 2.27 | 2.44 | 2.71 | 2.30 |
L’insieme dei match esegue le stesse tre passate, con un’aggiunta: il punteggio away di ciascun giocatore e il flag Crawford vengono propagati in ogni valutazione, così la verità è calcolata nello spazio delle match equity (MWC) rispetto al punteggio corretto. Sui 130 match a cinque punti, le passate hanno risolto 17,892 posizioni (18,292 decisioni) come segue:
I cinque livelli equivalenti, valutati su quelle 18,292 decisioni. Un PR più basso è meglio; il motore più forte di ogni coppia è evidenziato.
PR di ogni motore e livello testato sull’insieme dei match a 5 punti, suddiviso per tipo di decisione e piano di gioco. Più basso è meglio.
| Motore | PR | Pedine | Cubo | Corsa pura | Corsa | Attacco | Prime | Ancoraggio |
|---|---|---|---|---|---|---|---|---|
| Sage 3T | 0.23 | 0.20 | 0.46 | 0.07 | 0.22 | 0.20 | 0.28 | 0.31 |
| XG Roller++ | 0.36 | 0.35 | 0.44 | 0.08 | 0.44 | 0.32 | 0.33 | 0.49 |
| Sage 2T | 0.26 | 0.24 | 0.40 | 0.02 | 0.35 | 0.18 | 0.31 | 0.35 |
| XG Roller+ | 0.44 | 0.44 | 0.44 | 0.09 | 0.54 | 0.44 | 0.39 | 0.55 |
| Sage 1T | 0.47 | 0.47 | 0.47 | 0.06 | 0.55 | 0.45 | 0.55 | 0.56 |
| XG Roller | 0.51 | 0.51 | 0.56 | 0.09 | 0.63 | 0.49 | 0.50 | 0.65 |
| Sage 4P | 0.41 | 0.41 | 0.47 | 0.05 | 0.50 | 0.37 | 0.44 | 0.53 |
| XG 4-ply | 0.46 | 0.45 | 0.58 | 0.09 | 0.59 | 0.44 | 0.42 | 0.60 |
| Sage 3P | 0.56 | 0.54 | 0.71 | 0.05 | 0.73 | 0.55 | 0.59 | 0.63 |
| XG 3-ply | 0.54 | 0.53 | 0.62 | 0.09 | 0.68 | 0.53 | 0.52 | 0.68 |
| Sage 2P | 1.27 | 1.23 | 1.58 | 0.39 | 1.46 | 1.24 | 1.49 | 1.39 |
| Sage 1P | 2.22 | 2.21 | 2.35 | 0.38 | 2.43 | 2.41 | 2.44 | 2.47 |
Le partite ordinarie giocate dal motore contro se stesso producono raramente un backgame profondo, un gioco di contenimento o un prime nella metà lontana che trattiene una sola pedina attardata, quindi gli insiemi delle partite illimitate e dei match dicono poco su come un motore li gioca — e sono le posizioni in cui i motori sono stati storicamente più deboli. Tredici benchmark di famiglie di posizioni li misurano direttamente, ciascuno costruito come il benchmark illimitato — decisioni reali, ognuna con un riferimento di qualità rollout — ma con le decisioni tratte dall’interno della famiglia:
Ogni famiglia parte da un piccolo insieme di posizioni seme. Sage gioca da quei semi partite illimitate contro se stesso a 3-ply, ogni decisione che si presenta mentre la posizione appartiene ancora alla famiglia viene registrata, e ogni decisione registrata viene sottoposta a rollout per produrre il suo riferimento — 5,184 partite simulate giocate 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. Passaggi di completamento delle candidate hanno sottoposto a rollout ogni mossa effettivamente scelta da un motore in esame, così che ogni punteggio qui sotto sia calcolato rispetto a una candidata di qualità rollout. Una posizione di cubo in cui l’avversario possiede il cubo non è una decisione per il giocatore al tiro e non viene valutata.
| Benchmark | Decisioni | 2-ply | 3-ply | 4-ply | 1T / Roller | 2T / Roller+ | 3T / Roller++ | ||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Sage | XG | Sage | XG | Sage | XG | Sage | XG | Sage | XG | Sage | XG | ||
| 2-1 backgame | 1,000 | 2.26 | 2.84 | 1.01 | 1.64 | 1.03 | 1.22 | 0.61 | 1.67 | 0.41 | 0.98 | 0.38 | 0.93 |
| 3-1 backgame | 1,001 | 2.22 | 2.22 | 0.88 | 0.95 | 0.67 | 0.72 | 0.66 | 0.91 | 0.34 | 0.59 | 0.32 | 0.48 |
| 3-2 backgame | 1,008 | 2.07 | 2.39 | 0.91 | 1.31 | 0.78 | 0.99 | 0.65 | 0.95 | 0.44 | 0.61 | 0.25 | 0.51 |
| 4-1 backgame | 1,001 | 1.77 | 1.83 | 0.78 | 0.82 | 0.60 | 0.53 | 0.55 | 0.69 | 0.24 | 0.47 | 0.19 | 0.45 |
| 4-2 backgame | 1,000 | 2.16 | 1.96 | 0.73 | 1.05 | 0.69 | 0.55 | 0.63 | 0.79 | 0.36 | 0.61 | 0.27 | 0.43 |
| 5-1 backgame | 1,003 | 1.32 | 1.77 | 0.66 | 0.76 | 0.46 | 0.64 | 0.49 | 0.60 | 0.26 | 0.41 | 0.23 | 0.32 |
| 5-2 backgame | 1,002 | 1.53 | 1.60 | 0.49 | 0.82 | 0.48 | 0.63 | 0.53 | 0.63 | 0.33 | 0.41 | 0.24 | 0.30 |
| 4-3 backgame | 1,002 | 1.69 | 2.13 | 0.74 | 0.80 | 0.55 | 0.58 | 0.52 | 0.76 | 0.24 | 0.55 | 0.19 | 0.44 |
| 5-3 backgame | 1,003 | 1.86 | 2.13 | 1.02 | 0.89 | 0.58 | 0.63 | 0.68 | 0.81 | 0.35 | 0.46 | 0.21 | 0.44 |
| 5-4 backgame | 1,001 | 2.45 | 2.74 | 0.93 | 1.15 | 0.73 | 0.78 | 0.76 | 0.97 | 0.47 | 0.55 | 0.30 | 0.49 |
| Contenimento | 3,270 | 4.73 | 14.62 | 2.54 | 11.25 | 2.05 | 10.37 | 2.29 | 7.76 | 1.30 | 7.85 | 1.05 | 6.16 |
| Snake | 978 | 21.00 | 39.92 | 21.42 | 36.64 | 23.53 | 36.17 | 11.19 | 32.99 | 8.42 | 32.38 | 5.85 | 32.24 |
| Backgame massiccio | 2,103 | 4.33 | 5.76 | 2.56 | 4.44 | 2.17 | 3.68 | 1.91 | 3.14 | 1.39 | 2.75 | 1.09 | 2.64 |
.xg esportazioni (vedi l'Appendice).
Il metodo del PR da rollout valuta entrambi i motori rispetto a un riferimento comune. Una domanda più netta e più diretta è questa: nel gioco reale, dove i due motori sono davvero in disaccordo sulla mossa migliore — e quando lo sono, chi ha ragione?
Rispondiamo sulle decisioni illimitate più difficili del Metodo uno — le posizioni sottoposte a rollout, ognuna delle quali ora porta con sé entrambi i rollout completi, quello di Sage e quello di XG. Tra queste individuiamo ogni decisione in cui Sage 3T e XG Roller++ hanno scelto diversamente, e chiediamo quale scelta preferisse ciascun rollout. Avere entrambi i rollout è il punto essenziale: ogni disaccordo è giudicato con il rollout di Sage e con quello di XG, così la risposta non dipende mai dal fidarsi della verità di un solo motore.
Sulle posizioni illimitate sottoposte a rollout — le decisioni più difficili dello studio — i due motori sono in disaccordo su 1,286 mosse e 80 decisioni sul cubo. Ogni pannello mostra quanto spesso ciascun motore ha indovinato la decisione migliore secondo il rollout — valutata rispetto al rollout di XG e a quello di Sage, a turno.
I primi due metodi chiedono quale motore sia più forte. Una terza domanda è altrettanto importante per chiunque usi un motore per studiare il proprio gioco: se analizzi un match reale in XG, annoti il tuo Performance Rating, e poi analizzi lo stesso identico match in Sage — quanto sono vicini i due rating? Un giocatore che ha passato anni a costruirsi un’intuizione di cosa significhi un certo PR in XG dovrebbe ottenere sostanzialmente lo stesso numero da Sage.
Per verificarlo direttamente, abbiamo preso un’ampia raccolta di match di torneo reali già analizzati in XG, li abbiamo rianalizzati tutti da zero in Sage e abbiamo confrontato il Performance Rating che ciascun motore ha assegnato a ciascun giocatore.
I file dei match provengono da tre tornei del 2026, tutti match a 7 punti, gentilmente forniti da Máté Fehér — già analizzati in eXtreme Gammon, esattamente come un giocatore agonista studierebbe le proprie partite.
290 match e 580 rating individuali in tutto. Un ulteriore match è stato scartato perché la trascrizione era corrotta.
Mettendo insieme tutti i 580 rating, i due motori concordano quasi esattamente. La differenza media è statisticamente indistinguibile da zero, e la dispersione di quella differenza è piccola rispetto alla dispersione del PR stesso.
| Performance Rating per giocatore | XG | Sage | DifferenzaSage − XG |
|---|---|---|---|
| Media | 4.36 | 4.36 | +0.002 |
| Deviazione standard | 2.08 | 2.10 | 0.37 |
| Intervallo al 95% | 1.52 – 9.36 | 1.44 – 9.67 | −0.76 – +0.74 |
Negli studi di forza, Open Sage 3T e XG Roller++ sono due delle valutazioni di backgammon più forti disponibili, e vicine tra loro. Lo studio del PR su rollout — condotto sia per il gioco illimitato sia per match da 5 punti — trova Sage più forte a ogni livello equivalente tranne 3-ply, dove i due motori sono entro il rumore statistico, con il vantaggio più netto ai livelli di rollout troncato. Se lo si ricostruisce per le partite illimitate con l'analisi di XG stesso come riferimento, la classifica si capovolge: XG è avanti a ogni livello equivalente tranne il 2T, dove i due sono alla pari. Lo studio delle posizioni contese, che considera le posizioni su cui i due motori sono in disaccordo al livello di valutazione più forte e le valuta rispetto ai rollout di entrambi, è in parità sul gioco di pedine — ciascun rollout favorisce il motore che lo ha eseguito — mentre i disaccordi sul cubo sono troppo rari e troppo divisi per pronunciarsi.
Il riassunto onesto, quindi, è che i due motori giocano a un livello molto simile e molto alto, e che ciascuno ottiene il punteggio migliore rispetto alla propria analisi: con il riferimento di Sage i suoi rollout troncati azzeccano decisioni che i livelli Roller di XG sbagliano, con quello di XG vale il contrario, e sulle posizioni in cui i due motori sono apertamente in disaccordo il rollout di nessuno dei due mette l'altro chiaramente indietro. È sui benchmark di famiglia — backgame, partite di contenimento e snake — che i due motori si separano: misurati con lo stesso metro e a ogni livello equivalente, Sage è in testa in tutte e tredici, e di un fattore tre o più sulle partite di contenimento e sullo snake.
E il terzo studio risponde alla domanda che un utente di Sage si pone davvero: su 290 match di torneo reali già valutati da XG, Sage produce sostanzialmente lo stesso Performance Rating — la differenza media tra il rating Sage e il rating XG di un giocatore è statisticamente indistinguibile da zero, e la dispersione di quella differenza è piccola rispetto alla dispersione del PR stesso. Che il test sia la forza rispetto a una verità ottenuta tramite rollout o il semplice accordo su come è stata giocata una partita reale, Open Sage e XG arrivano allo stesso punto.
Open Sage è rilasciato come open source, e l’intera pipeline dietro entrambi i metodi è inclusa nel repository del motore. Tutto ciò che segue gira con il solo pacchetto
bgsage e una build locale del suo motore — non servono servizi esterni, dataset o infrastruttura. L’unica dipendenza manuale è eXtreme Gammon stesso, usato per rigenerare le colonne XG, dato che XG non ha un’interfaccia programmatica.
bgbot_cpp ) seguendo le istruzioni del repository per la tua piattaforma. Per riprodurre una qualsiasi colonna XG serve inoltre eXtreme Gammon (Windows) per il passaggio di Batch Analysis. Ogni script risolve i propri percorsi all’interno del repository, quindi eseguili dalla cartella bgsage/ , la radice del repository.
Non sei obbligato a guidare la pipeline a mano. Claude Code — lo strumento agentico di programmazione da riga di comando di Anthropic — può compilare il motore ed eseguire i benchmark per te. Puntalo su un checkout del repository e descrivi cosa vuoi; esegue gli stessi passaggi descritti qui sotto:
data/money_benchmark/benchmark.json.gz e stampala come una tabella che io possa confrontare con lo studio.”./mybot — per ogni decisione del benchmark incluso, valutala con il mio bot e calcola il suo PR rispetto alle equity di riferimento.”
Il benchmark — l’insieme stratificato di valutazioni affidabili — viene costruito e valutato da un unico script, scripts/benchmark_money.py. Ci sono due modi per iniziare.
Il repository include il benchmark assemblato come
data/money_benchmark/benchmark.json.gz (il JSON non compresso supera il limite di dimensione dei file di GitHub; gli script leggono il gzip in modo trasparente). Valutare un qualsiasi livello Sage riproduce la sua riga nella tabella della Sezione 3:
# lower PR is better python scripts/benchmark_money.py score --level 3ply # Sage 3P python scripts/benchmark_money.py score --level truncated3 # Sage 3T # --level: 1ply 2ply 3ply 4ply | truncated1/2/3 | rollout
Per valutare un motore completamente diverso, applica la stessa regola che lo script usa internamente: per ogni decisione del dataset, prendi la scelta del tuo motore e confronta la sua equity con l’equity di riferimento (“rollout”) memorizzata — l’errore medio × 500 è il suo PR.
Tre passate adattive ricreano il dataset. Le partite hanno un seme fisso (500 partite dal seme 1), quindi le decisioni e le equity di riferimento risultano identiche:
# 1. simulate 500 Sage-3P self-play games (+ XG transcripts) python scripts/benchmark_money.py build --stages pass1 --n-games 500 --workers 6 # 2. re-evaluate every decision within 0.05 at 3T python scripts/benchmark_money.py build --stages pass2 --n-threads 16 # 3. roll out every decision still within 0.02 python scripts/benchmark_money.py build --stages pass3 --n-threads 16
La passata 3 scrive data/money_benchmark/benchmark.json
(e il relativo .gz); valutalo esattamente come nell’opzione A. Omettendo --stages vengono eseguite tutte e tre le passate in ordine.
XG non ha API, quindi i suoi risultati provengono dalla Batch Analysis di XG. La passata 1 scrive le trascrizioni importabili in XG in data/money_benchmark/xg/ — non sono incluse nel repository, quindi rigenerale con la passata 1 se sei partito dal solo dataset.
xg/ con un livello personalizzato — decisioni a 3-ply, con passaggio al livello in esame in caso di disaccordo — e con Save Games after analyze attivato. XG scrive un file
.xg per partita.
python scripts/benchmark_pr_xg_levels_all.py --benchmark money, che legge la decisione preferita da XG per ogni posizione a ogni livello analizzato dai file
.xg e la valuta rispetto alle stesse equity di riferimento, stampando la stessa suddivisione del PR e registrando accanto le scelte di XG.
La tabella delle partite illimitate con il riferimento di XG nella Sezione 3 — e lo studio delle posizioni contese — richiedono invece i rollout di XG delle posizioni più difficili. Esegui il Batch Rollout di XG su quelle posizioni (con Save Games selezionato); python scripts/xg_benchmark_report.py le analizza. La tabella con il riferimento di XG rivaluta poi ogni livello a partire dalle scelte registrate da ciascuno script di punteggio. Vedi il Metodo Due qui sotto.
# XG-reference table: harvest XG Roller++ (the 3T tier), then re-score every level; # Sage's picks come from benchmark_money.py score --level <level> --model stage11 python scripts/xg_harvest_results.py --benchmark money --set rollerpp python scripts/benchmark_pr_xg_reference_all.py --sage-suffix stage11
Lo studio sui match a 5 punti si riproduce allo stesso modo con
scripts/benchmark_match.py, il gemello per il gioco a match di
benchmark_money.py — la lunghezza del match e il numero di match sono argomenti, e il punteggio del match viene propagato in ogni valutazione. La sua verità di riferimento è inclusa come data/match_benchmark/5pt/benchmark.json.gz.
# score against the shipped match dataset (no rebuild) python scripts/benchmark_match.py score --match-length 5 --level truncated3 # or rebuild: 130 seeded 5-pt matches, three adaptive passes python scripts/benchmark_match.py build --match-length 5 --n-matches 130 --stages pass1 --workers 6 python scripts/benchmark_match.py build --match-length 5 --n-matches 130 --stages pass2 --n-threads 16 python scripts/benchmark_match.py build --match-length 5 --n-matches 130 --stages pass3 --n-threads 16 # XG columns: batch-analyze data/match_benchmark/5pt/xg/ per level, then python scripts/benchmark_pr_xg_levels_all.py --benchmark match --match-length 5
Lo studio sui disaccordi attinge allo stesso benchmark illimitato costruito per il Metodo uno, incrociato con il rollout completo di XG delle posizioni più difficili. L’unica dipendenza manuale è il Batch Rollout di XG; un singolo script fa il resto.
data/money_benchmark/xg/.
.xg corrispondenti.
python scripts/xg_benchmark_report.py python scripts/xg_dispute_analysis.py --sage-picks data/money_benchmark/scores/sage_truncated3.picks.jsonl
Il primo converte i rollout di XG in
data/money_benchmark/xg_results/rollout.jsonl; il secondo stampa il report sulle posizioni contese — ogni disaccordo valutato rispetto al rollout di Sage e a quello di XG, a turno — dalle scelte registrate di Sage 3T.
Il gioco a match non è ancora coperto da questo metodo: richiede un rollout completo di XG delle posizioni dei match, che non abbiamo eseguito. La forza nel gioco a match è coperta invece dallo studio del PR da rollout (Sezione 3) e dallo studio sull’accordo nei match reali (Sezione 5).
Sage e XG possono anche giocare direttamente l'uno contro l'altro, con le mosse di XG prese dalla sua stessa analisi. Sage gioca entrambi i lati di una partita illimitata; la trascrizione viene analizzata in batch in XG; la prima decisione dell'avversario che differisce dalla scelta migliore di XG viene sostituita con la mossa di XG e la partita viene rigiocata da lì con nuovi dadi, finché ogni mossa dell'avversario è quella che XG avrebbe fatto. Il runner gioca una serie di tali partite (i seed continuano da logs/sage_vs_xg.txt) e stampa i punti medi per partita con il relativo errore standard:
python scripts/run_sage_vs_xg_games.py 100 --level 3P # Sage 3P vs XG; levels 1P-4P, 1T-3T python scripts/play_sage_vs_xg.py 3P --seed 7 # one game, iterations under logs/play_sage_vs_xg/
XG deve essere in esecuzione sul desktop Windows: ogni iterazione pilota la sua finestra Batch Analyze tramite scripts/xg_batch_analyze.py, un agente Anthropic Computer Use (imposta ANTHROPIC_API_KEY), che prende il controllo di mouse e tastiera per circa un minuto per iterazione. Una partita converge in poche iterazioni; il verdetto "too good to double" di XG conta come nessun raddoppio.
I tredici benchmark di famiglia si trovano sotto
backgame_ref_positions/benchmark/ — un file
<family> starting.txt di posizioni seme e un file
<family> rollout.jsonl di riferimento ciascuno — e sono valutati da
scripts/score_backgame_pr.py, che riporta il PR insieme alla quota di scelte di qualità rollout.
python scripts/score_backgame_pr.py --category "21 backgame" --level truncated3 python scripts/score_backgame_pr.py --category containment --level 3ply # XG: export every decision as a one-decision native .xg game, then per level (XG running): analyse, wait, score python scripts/export_folder_benchmark_xg.py generate python scripts/xg_folder_batch.py stamp python scripts/xg_folder_batch.py analyze --level xg3ply # drives XG's Batch Analyze dialog (pywinauto) python scripts/xg_folder_batch.py wait --level xg3ply python scripts/xg_folder_batch.py score --level xg3ply
.xg corrispondenti.