Une comparaison quantitative du moteur d’évaluation Open Sage — qui propulse Backgammon Sage Pro — avec le moteur du bot d’eXtreme Gammon (XG).
Nous comparons le moteur Open Sage à eXtreme Gammon (XG) à niveaux d’évaluation équivalents — évaluation directe par le réseau de neurones, recherche multi-ply et rollouts tronqués. XG n’offrant aucune interface programmatique, nous le notons via sa fonction Batch Analysis. Nous employons trois méthodes complémentaires. La première construit un jeu d’évaluations de référence par paliers — en faisant confiance aux évaluations rapides lorsque le choix est net et en escaladant les cas serrés jusqu’au rollout complet — puis note chaque moteur par un Performance Rating (PR) contre cette référence, sur 500 parties illimitées (17,535 décisions) comme sur 130 matchs en 5 points (18,292 décisions). Pour les parties illimitées, nous reconstruisons ensuite toute la comparaison en prenant pour référence l’analyse par paliers de XG lui-même — le miroir exact — et le rollout tronqué de Sage reste devant, même jugé sur les chiffres de XG. La deuxième méthode isole les positions illimitées sur lesquelles Sage 3T et XG Roller++ sont en réel désaccord et tranche chacune d’elles à l’aune des rollouts complets des deux moteurs. Sur ces deux méthodes, les deux moteurs sont proches, Sage étant légèrement devant aux niveaux de rollout tronqué équivalents, ceux qu’utilisent la plupart des utilisateurs. La troisième méthode retourne la question : sur 290 matchs de tournoi réels déjà analysés dans XG, nous réanalysons chacun dans Sage et comparons le Performance Rating que les deux moteurs attribuent à chaque joueur — et constatons que l’écart moyen est statistiquement indiscernable de zéro.
eXtreme Gammon (XG) est une référence de l’analyse informatique du backgammon, et son moteur d’évaluation est largement considéré comme l’un des plus forts qui existent. Tout nouveau moteur qui entend être pris au sérieux doit répondre à une question simple : comment se situe-t-il par rapport à XG ? Cette étude entreprend d’y répondre de façon quantitative pour Open Sage, le moteur à réseau de neurones qui anime Backgammon Sage Pro.
Notre objectif était de comparer les évaluations d’Open Sage à celles de XG à effort de calcul comparable. L’expérience naturelle — faire s’affronter les deux moteurs sur plusieurs milliers de parties et compter les points — n’est pas praticable : l’application XG n’expose aucune interface programmatique, si bien que transmettre positions et coups d’un moteur à l’autre est un processus manuel, clic après clic. Atteindre un échantillon assez grand pour résoudre les petits écarts entre deux moteurs forts prendrait beaucoup trop de temps.
Nous utilisons plutôt la fonction Batch Analysis de XG, capable de noter des centaines de parties transcrites en une seule passe sans intervention. Open Sage joue les deux camps de nombreuses parties ; chaque partie est exportée dans un format texte standard que XG sait importer ; XG analyse le tout ; et nous relisons ses verdicts. Sur ce socle commun, nous appliquons deux méthodes distinctes, décrites dans la section 3 et la section 4. Une troisième étude (section 5) laisse entièrement de côté les simulations et part de matchs de tournoi réels analysés dans XG.
Les deux moteurs peuvent évaluer une position à différentes profondeurs, en échangeant de la précision contre de la vitesse. Comprendre ces niveaux est indispensable pour lire les résultats, car la comparaison porte toujours sur des niveaux équivalents des deux moteurs.
Évaluation directe (1-ply). La sortie brute du réseau de neurones pour une position, sans aucune recherche. C’est le réglage le plus rapide et le socle sur lequel tous les niveaux plus profonds sont construits. (Nous suivons la convention de XG, où 1-ply désigne l’évaluation brute du réseau.)
Recherche multi-ply (2-, 3-, 4-ply). Le moteur regarde plusieurs tours en avant, en considérant les réponses de l’adversaire et en moyennant sur les lancers possibles à chaque étape, avec une évaluation brute du réseau au bout de chaque variante. Chaque ply supplémentaire est plus précis et nettement plus coûteux.
Rollouts tronqués (1T, 2T, 3T). Plutôt que de chercher à profondeur fixe, le moteur joue un grand nombre de courtes parties simulées, les tronque après quelques tours et évalue la position obtenue par une recherche multi-ply. La réduction de variance annule une bonne part de la chance des dés tirés. Ce sont les réglages « Roller » de XG : plus forts que la recherche à profondeur fixe, tout en restant bien moins coûteux qu’un rollout complet.
Rollout complet. Un grand nombre de parties simulées jouées jusqu’au bout. Mené en volume suffisant avec réduction de variance, un rollout complet est ce qui se rapproche le plus d’une vérité de référence qu’un moteur de backgammon puisse produire, et nous l’utilisons comme étalon tout au long de cette étude.
| Famille | Sage | Équivalent XG | Principe |
|---|---|---|---|
| Directe | 1-ply | 1-ply (évaluation brute) | Une seule évaluation de la position par le réseau de neurones — sans recherche. |
| Multi-ply | 2P · 3P · 4P | 2-ply · 3-ply · 4-ply | Explore les réponses de l’adversaire sur plusieurs tours, en moyennant sur les dés. |
| Rollout tronqué | 1T · 2T · 3T | Roller · Roller+ · Roller++ | De nombreuses courtes parties simulées, tronquées après 5–7 tours et évaluées en multi-ply, avec réduction de variance. 3T/Roller++ décident en 3-ply ; 2T/Roller+ en 2-ply ; 1T/Roller en 1-ply. |
| Rollout complet | Rollout | Rollout | Parties simulées jouées jusqu’au bout — la « vérité » de référence de cette étude. |
La première méthode note chaque moteur contre un ensemble fixe de décisions dont nous avons établi le « vrai » meilleur coup aussi précisément que possible. Elle reprend l’approche de la célèbre étude XG de 2012 qui comparait XG à plusieurs autres bots.
Nous avons commencé par simuler 500 parties illimitées de Sage 3P jouant contre lui-même. Un niveau moyennement fort comme 3P produit une distribution réaliste de positions couvrant tous les plans de jeu — course, attaque, prime, ancrage — exactement la variété que nous voulons tester. Nous avons ensuite refait toute l’étude une seconde fois sur 130 matchs en 5 points, où le score modifie la valeur de chaque décision ; les résultats des deux jeux de données figurent ci-dessous.
Établir le vrai meilleur coup de chaque décision par rollout complet serait extrêmement coûteux — et inutile, car la plupart des décisions ne sont pas serrées. Nous construisons donc la référence en trois passes successives, en ne dépensant l’effort de rollout que là où le choix est réellement incertain. La même recette s’applique aux deux jeux de données ; chaque passe tranche les décisions qu’elle peut résoudre avec confiance et transmet le reste à la suivante :
Chaque décision est évaluée en 3-ply. Lorsque le meilleur coup devance le suivant de plus de 0.05 d’équité, le verdict 3P est accepté comme vérité et la décision est tranchée.
Les décisions restantes sont réévaluées en 3T. Lorsque la marge dépasse désormais 0.02 d’équité, le verdict 3T est accepté comme vérité.
Tout ce qui reste sous 0.02 est tranché par un rollout complet de Sage : décisions en 3P pour le jeu de pions comme pour les actions de videau, par lots de 1,296 parties simulées jusqu’à ce que l’intervalle de confiance à 95% sur l’équité passe sous 0.005 — ou qu’un plafond de 20,736 parties (16 × 1,296) soit atteint. Les positions de back game les plus lentes ont demandé bien plus d’une heure chacune.
Le résultat est une référence par paliers où chaque décision est résolue exactement à la profondeur que sa difficulté exige. Nous avons appliqué cette même recette en trois passes aux deux jeux de données — les 500 parties illimitées et les 130 matchs en 5 points — et la composition des paliers obtenue est présentée ci-dessous à côté des résultats de chaque jeu.
Une fois ce jeu d’évaluations fiables par paliers en main, noter un moteur est simple : on lui soumet chaque décision du benchmark, on relève l’erreur d’équité du coup ou de l’action de videau qu’il choisit par rapport à la vérité, et on rapporte l’erreur moyenne × 500 sous forme de PR. Ce total est ensuite ventilé en PR de jeu de pions et PR de videau, puis par plan de jeu.
Noter XG a demandé l’étape supplémentaire décrite dans l’introduction. XG n’ayant pas d’API, nous avons lancé sa Batch Analysis sur les transcriptions des 500 parties illimitées et des 130 matchs avec un niveau personnalisé — décisions en 3-ply, relevées au niveau testé en cas de désaccord — puis extrait la décision préférée de XG pour chaque position des fichiers
.xg
qu’il produit, pour les noter contre les mêmes équités de référence.
Sur les 500 parties illimitées, les trois passes ont résolu 16,889 positions (17,535 décisions) comme suit :
Les cinq niveaux équivalents, notés sur ces 17,535 décisions. Un PR plus bas est meilleur ; le moteur le plus fort de chaque paire est mis en évidence.
PR de chaque moteur et niveau testé, ventilé par type de décision et par plan de jeu. Plus bas est meilleur.
| Moteur | PR | Pions | Videau | Course pure | Course | Attaque | Prime | Ancrage |
|---|---|---|---|---|---|---|---|---|
| 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 |
Tous les chiffres ci-dessus notent les moteurs contre la référence par paliers de Sage. L’objection évidente est celle de l’avantage du terrain — Sage est mesuré contre ses propres rollouts. Nous avons donc construit le miroir exact : les mêmes 500 parties et les mêmes décisions, mais avec l’analyse de XG lui-même comme vérité à chaque palier. XG 3-ply tranche les décisions du palier 3P, XG Roller++ celles du palier 3T, et le rollout complet de XG les décisions passées au rollout — l’analogue palier par palier, côté XG, de la référence Sage. Chaque moteur est ensuite renoté contre elle.
| Moteur | PR | Pions | Videau | Course pure | Course | Attaque | Prime | Ancrage |
|---|---|---|---|---|---|---|---|---|
| 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 |
Le jeu de données en match suit les trois mêmes passes, avec un ajout : le score away de chaque joueur et l’indicateur Crawford sont transmis à chaque évaluation, de sorte que la vérité est calculée en espace d’équité de match (MWC) au score exact. Sur les 130 matchs en 5 points, les passes ont résolu 17,892 positions (18,292 décisions) comme suit :
Les cinq niveaux équivalents, notés sur ces 18,292 décisions. Un PR plus bas est meilleur ; le moteur le plus fort de chaque paire est mis en évidence.
PR de chaque moteur et niveau testé sur le jeu de matchs en 5 points, ventilé par type de décision et par plan de jeu. Plus bas est meilleur.
| Moteur | PR | Pions | Videau | Course pure | Course | Attaque | Prime | Ancrage |
|---|---|---|---|---|---|---|---|---|
| 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 |
La méthode du PR rollout note les deux moteurs contre une référence commune. Une question plus tranchée et plus directe est celle-ci : en jeu réaliste, où les deux moteurs sont-ils réellement en désaccord sur le meilleur coup — et, quand c’est le cas, lequel a raison ?
Nous y répondons sur les décisions illimitées les plus difficiles de la méthode 1 — les positions passées au rollout, dont chacune porte désormais à la fois un rollout complet de Sage et un rollout complet de XG. Parmi elles, nous relevons chaque décision où Sage 3T et XG Roller++ ont choisi différemment, et regardons quel choix chaque rollout a préféré. Disposer des deux rollouts est tout l’intérêt : chaque désaccord est jugé contre le rollout de Sage et celui de XG, si bien que la réponse ne repose jamais sur la vérité d’un seul moteur.
Sur les positions illimitées passées au rollout — les décisions les plus difficiles de l’étude — les deux moteurs divergent sur 1,488 coups de pions et 69 décisions de videau. Chaque panneau montre à quelle fréquence chaque moteur a trouvé la meilleure décision du rollout — notée tour à tour contre le rollout de XG lui-même et contre celui de Sage.
Les deux premières méthodes demandent quel moteur est le plus fort. Une troisième question compte tout autant pour quiconque utilise un moteur pour étudier son propre jeu : si vous analysez un match réel dans XG, notez votre Performance Rating, puis analysez exactement le même match dans Sage — à quel point les deux notes sont-elles proches ? Un joueur qui a passé des années à se forger une intuition de ce que signifie tel PR dans XG doit obtenir pour l’essentiel le même chiffre avec Sage.
Pour le tester directement, nous avons pris une grande collection de matchs de tournoi réels déjà analysés dans XG, réanalysé chacun d’eux de zéro dans Sage, et comparé le Performance Rating que chaque moteur attribue à chaque joueur.
Les fichiers de match proviennent de trois tournois de 2026, tous en matchs de 7 points, généreusement fournis par Máté Fehér — déjà analysés dans eXtreme Gammon, exactement comme un joueur de compétition étudierait ses propres parties.
290 matchs et 580 notes individuelles de joueurs en tout. Un match supplémentaire a été écarté pour transcription corrompue.
En regroupant les 580 notes de joueurs, les deux moteurs s’accordent presque exactement. L’écart moyen est statistiquement indiscernable de zéro, et la dispersion de cet écart est faible au regard de la dispersion du PR lui-même.
| Performance Rating par joueur | XG | Sage | ÉcartSage − XG |
|---|---|---|---|
| Moyenne | 4.36 | 4.36 | +0.002 |
| Écart-type | 2.08 | 2.10 | 0.37 |
| Intervalle à 95% | 1.52 – 9.36 | 1.44 – 9.67 | −0.76 – +0.74 |
Sur les deux études de force, Open Sage 3T et XG Roller++ sont à peu près comparables — deux des évaluations de backgammon les plus fortes qui existent, et proches l’une de l’autre. L’étude du PR rollout — menée en partie illimitée comme en matchs de 5 points — trouve Sage plus fort à chaque niveau équivalent sauf en 3-ply, où les deux moteurs sont dans le bruit l’un de l’autre ; et en partie illimitée, le constat tient même lorsque la référence devient l’analyse par paliers de XG lui-même. L’étude des positions litigieuses, qui examine les positions où les deux moteurs divergent au niveau d’évaluation le plus fort (Sage 3T et XG Roller++) et les note contre les rollouts des deux moteurs, trouve Sage 3T plus proche sur les désaccords de pions quel que soit le rollout, les désaccords de videau étant trop rares et trop partagés pour trancher.
Il y a donc quelques éléments indiquant que Sage 3T est légèrement plus fort que XG Roller++. L’objection la plus naturelle — que cet avantage serait un artefact de la notation de Sage contre ses propres rollouts — trouve réponse là où nous pouvons la tester : notés contre la référence de XG lui-même, les niveaux tronqués de Sage restent devant. Les écarts n’en demeurent pas moins faibles, et le résumé honnête est que les deux moteurs jouent à un niveau très similaire et très élevé — précisément la barre que nous nous étions fixée.
Et la troisième étude répond à la question que se pose réellement un utilisateur de Sage : sur 290 matchs de tournoi réels déjà notés par XG, Sage produit pour l’essentiel le même Performance Rating — l’écart moyen entre la note Sage et la note XG d’un joueur est statistiquement indiscernable de zéro, et la dispersion de cet écart est faible au regard de la dispersion du PR lui-même. Que le test porte sur la force face à une vérité établie par rollout ou sur la simple concordance quant à la qualité de jeu d’une partie réelle, Open Sage et XG arrivent au même endroit.
Open Sage est publié en open source, et la chaîne de traitement complète derrière les deux méthodes est livrée dans le dépôt du moteur. Tout ce qui suit s’exécute avec le seul paquet
bgsage et une compilation locale de son moteur — aucun service externe, jeu de données ou infrastructure n’est requis. La seule dépendance manuelle est eXtreme Gammon lui-même, utilisé pour régénérer les colonnes XG, puisque XG n’a pas d’interface programmatique.
bgbot_cpp ) en suivant les instructions du dépôt pour votre plateforme. Reproduire une colonne XG exige en plus eXtreme Gammon (Windows) pour son étape de Batch Analysis. Chaque script résout ses chemins à l’intérieur du dépôt ; lancez-les donc depuis la racine bgsage/ .
Vous n’avez pas à piloter la chaîne à la main. Claude Code — l’outil de programmation agentique en ligne de commande d’Anthropic — peut compiler le moteur et lancer les benchmarks pour vous. Pointez-le vers une copie du dépôt et décrivez ce que vous voulez ; il déroule les mêmes étapes que celles détaillées ci-dessous :
data/money_benchmark/benchmark.json.gz et affiche-le sous forme de tableau que je puisse comparer à l’étude. »./mybot — pour chaque décision du benchmark livré, évalue-la avec mon bot et calcule son PR contre les équités de référence. »
Le benchmark — le jeu d’évaluations fiables par paliers — est construit et noté par un seul script, scripts/benchmark_money.py. Il y a deux façons d’y entrer.
Le dépôt livre le benchmark assemblé sous
data/money_benchmark/benchmark.json.gz (le JSON non compressé dépasse la limite de taille de fichier de GitHub ; les scripts lisent le gzip de façon transparente). Noter n’importe quel niveau Sage reproduit sa ligne du tableau de la section 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
Pour noter un tout autre moteur, appliquez la règle que le script utilise en interne : pour chaque décision du jeu de données, prenez le choix de votre moteur et comparez son équité à l’équité de référence (« rollout ») stockée — l’erreur moyenne × 500 est son PR.
Trois passes adaptatives recréent le jeu de données. Les parties sont générées avec une graine fixe (500 parties à partir de la graine 1), de sorte que les décisions et les équités de référence ressortent identiques :
# 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 passe 3 écrit data/money_benchmark/benchmark.json
(et son .gz) ; notez-le exactement comme dans l’option A. Omettre --stages lance les trois passes dans l’ordre.
XG n’a pas d’API : ses résultats viennent de sa Batch Analysis. La passe 1 écrit des transcriptions importables dans XG dans data/money_benchmark/xg/ — elles ne sont pas livrées, régénérez-les donc avec la passe 1 si vous êtes parti du seul jeu de données.
xg/ avec un niveau personnalisé — décisions en 3-ply, relevées au niveau testé en cas de désaccord — en cochant Save Games after analyze. XG écrit un fichier
.xg par partie.
python scripts/benchmark_pr_xg.py, qui lit la décision préférée de XG pour chaque position dans les fichiers .xg et la note contre les mêmes équités de référence, en imprimant la même ventilation du PR.
Le tableau illimité à référence XG de la section 3 — et l’étude des positions litigieuses — demandent en revanche les rollouts XG des positions les plus difficiles. Lancez le Batch Rollout de XG sur ces positions (Save Games coché), puis python scripts/xg_benchmark_report.py les analyse et imprime à la fois le tableau des niveaux à référence XG et le rapport des positions litigieuses. Voir la méthode 2 ci-dessous.
L’étude des matchs en 5 points se reproduit de la même façon avec
scripts/benchmark_match.py, le jumeau en match de
benchmark_money.py — la longueur et le nombre de matchs sont des arguments, et le score du match est transmis à chaque évaluation. Sa vérité de référence est livrée sous 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
L’étude des désaccords puise dans le même benchmark illimité construit pour la méthode 1, croisé avec le rollout complet de XG lui-même sur les positions les plus difficiles. La seule dépendance manuelle est le Batch Rollout de XG ; un seul script fait le reste.
data/money_benchmark/xg/.
.xg correspondants.
python scripts/xg_benchmark_report.py
Il analyse les rollouts de XG vers
data/money_benchmark/xg_results/rollout.jsonl, puis imprime à la fois le PR par niveau d’évaluation contre le rollout XG (la seconde référence de la section 3) et le rapport des positions litigieuses — chaque désaccord noté tour à tour contre les rollouts de Sage et de XG.
Le jeu en match n’est pas encore couvert par cette méthode : il faudrait un rollout complet XG des positions de match, que nous n’avons pas lancé. La force en match est couverte par l’étude du PR rollout (section 3) et par l’étude de concordance sur matchs réels (section 5).
.xg correspondants.