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 del bot 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 attraverso 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 passando ai rollout completi per le decisioni più serrate — e assegna a ciascun motore un Performance Rating (PR) rispetto a quel riferimento, sia su 500 partite illimitate (17,535 decisioni) sia su 130 match a 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 — e il rollout troncato di Sage resta in vantaggio anche quando è giudicato con i numeri di XG. Il secondo metodo isola le posizioni illimitate su cui Sage 3T e XG Roller++ sono davvero in disaccordo e giudica ciascuna con i rollout completi di entrambi i motori. Con entrambi i metodi i due motori risultano vicini, con Sage leggermente avanti ai livelli equivalenti di rollout troncato su cui si affida la maggior parte degli utenti. Il terzo metodo capovolge la domanda: su 290 match di torneo reali già analizzati in XG, rianalizziamo ciascuno in Sage e confrontiamo il Performance Rating che i due motori assegnano a ogni giocatore — e troviamo una differenza media 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 due motori l’uno contro l’altro per molte migliaia 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.
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 back game 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.21 | 0.18 | 0.36 | 0.02 | 0.24 | 0.17 | 0.31 | 0.28 |
| XG Roller++ | 0.32 | 0.31 | 0.38 | 0.04 | 0.40 | 0.24 | 0.41 | 0.44 |
| Sage 2T | 0.26 | 0.23 | 0.44 | 0.02 | 0.32 | 0.21 | 0.39 | 0.30 |
| XG Roller+ | 0.41 | 0.41 | 0.39 | 0.05 | 0.59 | 0.31 | 0.47 | 0.54 |
| Sage 1T | 0.50 | 0.52 | 0.40 | 0.04 | 0.57 | 0.43 | 0.59 | 0.73 |
| XG Roller | 0.53 | 0.54 | 0.48 | 0.05 | 0.63 | 0.44 | 0.71 | 0.66 |
| Sage 4P | 0.41 | 0.39 | 0.50 | 0.07 | 0.51 | 0.37 | 0.45 | 0.53 |
| XG 4-ply | 0.46 | 0.45 | 0.52 | 0.06 | 0.58 | 0.40 | 0.57 | 0.58 |
| Sage 3P | 0.58 | 0.58 | 0.57 | 0.14 | 0.72 | 0.52 | 0.63 | 0.74 |
| XG 3-ply | 0.57 | 0.57 | 0.58 | 0.05 | 0.71 | 0.48 | 0.73 | 0.71 |
| Sage 2P | 1.64 | 1.39 | 2.88 | 0.40 | 1.77 | 1.83 | 1.86 | 1.71 |
| Sage 1P | 2.59 | 2.48 | 3.20 | 0.78 | 2.60 | 2.79 | 3.10 | 2.89 |
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.26 | 0.25 | 0.33 | 0.02 | 0.37 | 0.20 | 0.30 | 0.36 |
| XG Roller++ | 0.33 | 0.35 | 0.23 | 0.04 | 0.50 | 0.20 | 0.39 | 0.47 |
| Sage 2T | 0.31 | 0.30 | 0.35 | 0.02 | 0.41 | 0.27 | 0.36 | 0.37 |
| XG Roller+ | 0.38 | 0.40 | 0.23 | 0.04 | 0.58 | 0.26 | 0.39 | 0.54 |
| Sage 1T | 0.46 | 0.48 | 0.37 | 0.03 | 0.58 | 0.40 | 0.50 | 0.64 |
| XG Roller | 0.47 | 0.49 | 0.35 | 0.12 | 0.61 | 0.35 | 0.54 | 0.62 |
| Sage 4P | 0.37 | 0.36 | 0.42 | 0.06 | 0.53 | 0.34 | 0.40 | 0.39 |
| XG 4-ply | 0.45 | 0.46 | 0.40 | 0.13 | 0.60 | 0.36 | 0.48 | 0.59 |
| Sage 3P | 0.49 | 0.48 | 0.52 | 0.08 | 0.66 | 0.46 | 0.54 | 0.55 |
| XG 3-ply | 0.47 | 0.49 | 0.40 | 0.12 | 0.63 | 0.37 | 0.54 | 0.61 |
| Sage 2P | 1.35 | 1.14 | 2.40 | 0.31 | 1.50 | 1.48 | 1.52 | 1.41 |
| Sage 1P | 2.24 | 2.14 | 2.76 | 0.74 | 2.21 | 2.44 | 2.69 | 2.39 |
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.19 | 0.16 | 0.40 | 0.01 | 0.17 | 0.18 | 0.25 | 0.26 |
| XG Roller++ | 0.35 | 0.35 | 0.41 | 0.08 | 0.44 | 0.32 | 0.33 | 0.45 |
| Sage 2T | 0.26 | 0.24 | 0.44 | 0.02 | 0.36 | 0.18 | 0.34 | 0.33 |
| XG Roller+ | 0.44 | 0.44 | 0.41 | 0.09 | 0.55 | 0.44 | 0.40 | 0.52 |
| Sage 1T | 0.49 | 0.49 | 0.52 | 0.05 | 0.57 | 0.44 | 0.57 | 0.63 |
| XG Roller | 0.51 | 0.51 | 0.54 | 0.09 | 0.64 | 0.50 | 0.51 | 0.62 |
| Sage 4P | 0.42 | 0.42 | 0.48 | 0.05 | 0.52 | 0.38 | 0.45 | 0.55 |
| XG 4-ply | 0.46 | 0.45 | 0.56 | 0.09 | 0.60 | 0.44 | 0.42 | 0.56 |
| Sage 3P | 0.57 | 0.56 | 0.67 | 0.05 | 0.74 | 0.56 | 0.58 | 0.68 |
| XG 3-ply | 0.54 | 0.53 | 0.61 | 0.09 | 0.69 | 0.53 | 0.52 | 0.65 |
| Sage 2P | 1.30 | 1.26 | 1.60 | 0.39 | 1.59 | 1.23 | 1.50 | 1.41 |
| Sage 1P | 2.30 | 2.29 | 2.31 | 0.69 | 2.48 | 2.43 | 2.47 | 2.56 |
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,488 mosse e 69 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 |
Nei due studi sulla forza, Open Sage 3T e XG Roller++ risultano grosso modo comparabili — due delle valutazioni di backgammon più forti disponibili, e vicine tra loro. Lo studio del PR da rollout — eseguito sia per il gioco illimitato sia per i match a 5 punti — trova Sage più forte a ogni livello equivalente tranne il 3-ply, dove i due motori sono dentro il rumore l’uno dell’altro; e sulle partite illimitate il risultato regge anche quando il riferimento passa all’analisi stratificata di XG stesso. Lo studio sulle posizioni contese, che guarda alle posizioni in cui i due motori sono in disaccordo al livello di valutazione più forte (Sage 3T e XG Roller++) e le valuta con i rollout di entrambi i motori, trova Sage 3T il motore più vicino sui disaccordi di pedine rispetto a entrambi i rollout, mentre i disaccordi sul cubo sono troppo rari e troppo divisi per trarne un verdetto.
C’è dunque qualche evidenza che Sage 3T sia leggermente più forte di XG Roller++. L’obiezione più naturale — che il vantaggio sia un artefatto del valutare Sage contro i propri rollout — trova risposta là dove possiamo verificarla: valutati rispetto al riferimento di XG stesso, i livelli troncati di Sage restano avanti. Le differenze sono comunque piccole, e la sintesi onesta è che i due motori giocano a un livello molto simile e molto alto — che è esattamente l’asticella che ci eravamo posti.
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.py, che legge la decisione preferita da XG per ogni posizione dai file .xg e la valuta rispetto alle stesse equity di riferimento, stampando la stessa suddivisione del PR.
La tabella illimitata con riferimento XG della Sezione 3 — e lo studio sulle posizioni contese — richiedono invece i rollout di XG delle posizioni più difficili. Esegui il Batch Rollout di XG su quelle posizioni (con Save Games attivato); poi python scripts/xg_benchmark_report.py li analizza e stampa sia la tabella dei livelli con riferimento XG sia il report sulle posizioni contese. Vedi Metodo due più sotto.
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/, then python scripts/benchmark_pr_xg_match.py --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
Converte i rollout di XG in
data/money_benchmark/xg_results/rollout.jsonl, poi stampa sia il PR per livello di valutazione rispetto al rollout di XG (il secondo riferimento della Sezione 3) sia il report sulle posizioni contese — ogni disaccordo valutato rispetto al rollout di Sage e a quello di XG, a turno.
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).
.xg corrispondenti.