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) à des niveaux d'évaluation équivalents — évaluation directe du réseau de neurones, recherche multi-ply et rollouts tronqués. Comme XG n'expose aucune interface programmatique, nous l'évaluons via sa fonction Batch Analysis. Nous utilisons trois méthodes complémentaires. La première construit un ensemble stratifié d'évaluations de référence — en se fiant aux évaluations rapides lorsque le choix est net et en escaladant les cas serrés vers des rollouts complets — et attribue à chaque moteur un Performance Rating (PR) face à cette référence, sur 500 parties illimitées (17 535 décisions) et 130 matchs en cinq 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. La deuxième isole les positions illimitées sur lesquelles Sage 3T et XG Roller++ divergent réellement et arbitre chacune face aux rollouts complets des deux moteurs. La même méthode de référence et de notation est appliquée à treize benchmarks de backgames, de parties de containment et du snake — les positions que les moteurs ont historiquement le moins bien jouées. Dans les études de force, les deux moteurs sont proches : selon la référence de Sage, Sage est devant aux niveaux de rollout tronqué sur lesquels s'appuient la plupart des utilisateurs ; selon celle de XG, XG est devant ou à égalité. La troisième méthode renverse 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. Les deux notes se suivent de très près : sur 580 notes de joueurs, elles présentent une corrélation de 98%, et l'écart moyen entre elles est de +0.002 PR — 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 moteurs sur des millions 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. Son objet est différent : plutôt que de demander quel moteur est le plus fort, elle demande si un joueur qui analyse un match dans Sage obtient le même Performance Rating que celui que XG lui donnerait — afin que des années d’intuition sur ce que signifie un PR dans XG se transposent telles quelles à Sage.
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 backgame 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.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 |
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.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 |
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.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 |
Les parties ordinaires en auto-jeu produisent rarement un backgame profond, un jeu de contention ou une prime dans la moitié éloignée du tableau retenant un unique retardataire, si bien que les jeux de données en partie illimitée et en match en disent peu sur la façon dont un moteur les joue — et ce sont les positions où les moteurs ont historiquement été les plus faibles. Treize benchmarks par famille de positions les mesurent directement, chacun construit comme le benchmark illimité — des décisions réelles, chacune munie d’une référence de qualité rollout — mais avec des décisions tirées de l’intérieur de la famille :
Chaque famille part d’un petit ensemble de positions germes. Sage joue, à partir de ces germes, des parties illimitées contre lui-même en 3-ply ; chaque décision qui survient tant que la position appartient encore à la famille est enregistrée, et chaque décision enregistrée est passée au rollout pour produire sa référence — 5,184 parties simulées jouées jusqu’au bout, avec des décisions de pions et de videau en 3-ply pour les trois premiers demi-coups et en 2-ply ensuite, réduction de variance activée. Des passes de complétion des candidats ont passé au rollout chaque coup effectivement choisi par un moteur testé, si bien que chaque score ci-dessous est calculé contre un candidat de qualité rollout. Une position de videau où l’adversaire possède le videau n’est pas une décision pour le joueur au trait et n’est pas notée.
| Benchmark | Décisions | 2-ply | 3-ply | 4-ply | 1T / Roller | 2T / Roller+ | 3T / Roller++ | ||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Sage | XG | Sage | XG | Sage | XG | Sage | XG | Sage | XG | Sage | XG | ||
| Backgame 2-1 | 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 |
| Backgame 3-1 | 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 |
| Backgame 3-2 | 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 |
| Backgame 4-1 | 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 |
| Backgame 4-2 | 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 |
| Backgame 5-1 | 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 |
| Backgame 5-2 | 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 |
| Backgame 4-3 | 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 |
| Backgame 5-3 | 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 |
| Backgame 5-4 | 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 |
| Contention | 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 massif | 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 exports (voir l'Annexe).
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,286 coups de pions et 80 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 |
Dans les études de force, Open Sage 3T et XG Roller++ comptent parmi les évaluations de backgammon les plus fortes disponibles, et sont proches l'une de l'autre. L'étude du PR face aux rollouts — menée pour le jeu illimité comme pour les matchs en 5 points — trouve Sage plus fort à chaque niveau équivalent sauf en 3-ply, où les deux moteurs sont dans le bruit, l'avantage le plus net étant aux niveaux de rollout tronqué. Si on la reconstruit pour les parties illimitées avec l'analyse de XG lui-même comme référence, le classement s'inverse : XG est devant à chaque niveau équivalent sauf en 2T, où les deux sont à égalité. L'étude des positions litigieuses, qui retient les positions où les deux moteurs divergent au niveau d'évaluation le plus fort et les note face aux rollouts des deux, est à égalité sur le jeu de pions — chaque rollout favorisant le moteur qui l'a produit — les désaccords de videau étant trop rares et trop partagés pour trancher.
Le résumé honnête est donc que les deux moteurs jouent à un niveau très semblable et très élevé, et que chacun obtient son meilleur score face à sa propre analyse : selon la référence de Sage, ses rollouts tronqués réussissent des décisions que les niveaux Roller de XG manquent ; selon celle de XG, c'est l'inverse ; et sur les positions où les deux moteurs divergent franchement, le rollout d'aucun des deux ne place l'autre nettement derrière. C'est sur les benchmarks de familles — backgames, parties de containment et snake — que les deux moteurs se séparent : mesuré à la même aune et à chaque niveau équivalent, Sage devance sur les treize, et d'un facteur trois ou plus sur les parties de containment et le snake.
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_levels_all.py --benchmark money, qui lit la décision préférée de XG pour chaque position, à chaque niveau analysé, 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 et en enregistrant à côté les choix de XG.
Le tableau des parties illimitées notées contre la référence de XG (Section 3) — tout comme l'étude des positions litigieuses — requiert en revanche les rollouts de XG sur les positions les plus difficiles. Lancez le Batch Rollout de XG sur ces positions (Save Games coché) ; python scripts/xg_benchmark_report.py les analyse. Le tableau avec la référence de XG renote ensuite chaque niveau à partir des choix enregistrés par chaque script de notation. Voir la Méthode Deux ci-dessous.
# 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
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/ per level, then python scripts/benchmark_pr_xg_levels_all.py --benchmark match --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 python scripts/xg_dispute_analysis.py --sage-picks data/money_benchmark/scores/sage_truncated3.picks.jsonl
Le premier analyse les rollouts de XG vers
data/money_benchmark/xg_results/rollout.jsonl ; le second imprime le rapport des positions litigieuses — chaque désaccord noté tour à tour contre les rollouts de Sage et de XG — à partir des choix enregistrés de Sage 3T.
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).
Sage et XG peuvent aussi s'affronter directement, les coups de XG étant tirés de sa propre analyse. Sage joue les deux camps d'une partie illimitée ; la transcription est analysée en lot dans XG ; la première décision de l'adversaire qui diffère du meilleur choix de XG est remplacée par le coup de XG et la partie est rejouée à partir de là avec de nouveaux dés, jusqu'à ce que chaque coup de l'adversaire soit celui qu'aurait joué XG. Le programme joue une série de telles parties (les graines continuent depuis logs/sage_vs_xg.txt) et affiche les points moyens par partie avec son erreur type :
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 doit être lancé sur le bureau Windows : chaque itération pilote sa boîte de dialogue Batch Analyze via scripts/xg_batch_analyze.py, un agent Anthropic Computer Use (définissez ANTHROPIC_API_KEY), qui prend le contrôle de la souris et du clavier pendant environ une minute par itération. Une partie converge en quelques itérations ; le verdict « too good to double » de XG compte comme un non-doublement.
Les treize benchmarks par famille vivent sous
backgame_ref_positions/benchmark/ — un fichier
<family> starting.txt de positions germes et une référence
<family> rollout.jsonl chacun — et sont notés par
scripts/score_backgame_pr.py, qui rapporte le PR à côté de la part des choix de 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 correspondants.