Comment le moteur Stage 11 derrière Backgammon Sage Pro a été construit pour maîtriser les positions que tous les bots jouent le plus mal — backgames, jeux de contention et le snake — et ce que les benchmarks en disent.
Les moteurs de backgammon ont toujours été les plus faibles dans les parties lentes et structurelles : les backgames, où un joueur tient deux ancres ou plus au fond du jan adverse et attend un tir ; les jeux de contention, où un joueur qui a perdu la course tente de garder prisonniers un ou deux pions frappés ; et le snake, un prime dans la moitié éloignée du tableau qui retient un unique pion retardataire pendant que le reste de l'armée adverse s'effondre. Ces positions sont rares dans le jeu ordinaire et inhabituellement longues lorsqu'elles surviennent, si bien qu'elles sont à peine représentées dans les données d'auto-jeu dont un moteur apprend, et un moteur qui ne les a presque jamais vues les évalue en extrapolant à partir de positions qui se ressemblent seulement. Le moteur Open Sage Stage 9 a été entraîné sur des positions de backgame et obtient de meilleurs scores qu'eXtreme Gammon à niveaux d'évaluation comparables, mais son taux d'erreur dans ces parties reste plusieurs fois supérieur à son taux d'erreur ailleurs. Stage 11 s'attaque au problème de front. Nous avons d'abord construit des benchmarks faits de backgames, de jeux de contention et de snakes, chacun noté en Performance Rating face à des références de qualité rollout ; puis ajouté six réseaux de neurones au moteur, sélectionnés par un petit ensemble de règles structurelles ; puis généré des cibles de rollout pour chacun d'eux ; et enfin noté le résultat sur tous les benchmarks dont nous disposons. Sur le benchmark de contention, Stage 11 fait passer le PR à 3 plis de 6,89 à 3,58 et le nombre de blunders de 156 à 53 ; sur les dix benchmarks classiques de backgame, son PR à 1 pli passe de 4,75 à 2,98 ; et son jeu en partie illimitée et au Paskogammon — une variante jouée depuis une position de départ personnalisée qui mène à bien plus de backgames — est inchangé ou meilleur.
Les moteurs de backgammon à réseaux de neurones apprennent de millions de parties jouées contre eux-mêmes, et ils apprennent ce que ces parties contiennent. Les backgames, les jeux de contention et les primes retenant un unique retardataire sont rares dans le jeu ordinaire et inhabituellement longs quand ils surviennent, si bien qu'un moteur généraliste en voit peu et les évalue en extrapolant à partir de positions qui se ressemblent sans l'être. Il en résulte une faiblesse bien connue : un moteur qui commet une erreur toutes les vingt décisions dans une partie normale peut en commettre une toutes les trois dans un backgame profond, et il tend à mal juger les mêmes choses qu'un joueur humain intermédiaire — quand tenir une ancre et quand courir, combien de timing possède une position, et quand relâcher un prime.
Le moteur Open Sage Stage 9, qui propulse Backgammon Sage Pro, comprend déjà deux réseaux entraînés spécifiquement sur des positions de backgame, et notre étude des performances du bot montre qu'il évalue au moins aussi bien qu'eXtreme Gammon à chaque niveau comparable. Mais une force relative aux autres bots n'est pas une force dans l'absolu. Mesuré face à des rollouts, le taux d'erreur de Stage 9 dans les backgames vaut deux à trois fois celui des parties ordinaires, et dans les jeux de contention et les snakes c'est pire encore : sur le benchmark snake ci-dessous, son Performance Rating à 1 pli dépasse 60, contre 2,6 en partie illimitée.
Stage 11 est conçu pour supprimer ces faiblesses sans toucher à rien d'autre. Le travail s'est fait en quatre étapes. D'abord, nous avons construit une famille de benchmarks qui notent le jeu de backgame et de contention dans différents types de position — dix types classiques de backgame, une famille contention, une famille backgame massif et une famille snake — chacun un ensemble de décisions réelles notées face à des références de qualité rollout, de sorte que Stage 9, Stage 11 et XG puissent tous être mesurés sur le même pied. Ensuite, nous avons conçu le modèle Stage 11 : les dix-sept réseaux de Stage 9 repris tels quels, plus six nouveaux réseaux pour les familles de backgame, et un algorithme d'aiguillage qui décide, d'après la structure d'une position, quel réseau l'évalue. Puis nous avons généré des données d'entraînement pour chaque nouveau réseau — un mélange de positions récoltées en auto-jeu, de positions synthétiques et de corpus de rollouts existants, toutes passées au rollout pour produire les cibles. Enfin, nous avons entraîné les réseaux et noté le moteur fini sur chaque benchmark de backgame et sur nos benchmarks de rollout PR en partie illimitée, en match en 5 points et au Paskogammon (une variante jouée depuis une position de départ personnalisée choisie pour produire beaucoup de backgames), pour vérifier que les gains en backgame ne coûtaient rien ailleurs.
La version courte des résultats : Stage 11 est nettement plus fort partout où les nouveaux réseaux interviennent et identique à Stage 9 partout ailleurs. Son PR à 3 plis sur le benchmark de contention est à peine la moitié de celui de Stage 9, ses blunders y reculent des deux tiers, son PR à 1 pli cumulé sur les dix backgames classiques baisse de 37 %, et il est le premier moteur Open Sage à progresser réellement sur le snake. Le jeu en partie illimitée est inchangé et le jeu au Paskogammon s'améliore. Le reste de cette page en donne le détail.
Chaque benchmark ici suit la même recette que notre benchmark de rollout PR en partie illimitée : un ensemble de décisions réelles, chacune munie d'une évaluation de référence de qualité rollout, face auquel un moteur est noté en Performance Rating — son erreur d'equity moyenne par décision, multipliée par 500, la convention qu'utilise XG. Un PR de 2 signifie que le moteur cède en moyenne 0,004 point par décision ; un PR de 60 signifie 0,12 par décision, ce qui relève du débutant.
Ce qui diffère, c'est l'origine des décisions. Chaque benchmark de backgame part d'un petit ensemble de positions germes qui définissent sa famille — les positions de référence montrées dans les carrousels ci-dessous. Le moteur joue ensuite, à partir de ces germes, des parties illimitées contre lui-même, avec videau, Jacoby et beaver activés, à 3 plis, et chaque décision qui survient tant que la position appartient encore à la famille est enregistrée : un jeu de pions compte lorsqu'il existe au moins deux coups légaux et un écart d'equity significatif entre eux, et une position de videau compte lorsque la décision du doubleur n'est pas trivialement évidente ou lorsqu'un double est effectivement proposé. Les germes sont utilisés dans un cycle mélangé, le côté qui joue en premier est tiré à pile ou face, et tout est une fonction pure d'une seule graine aléatoire, si bien que n'importe quel benchmark se régénère à l'identique.
Chaque décision enregistrée est ensuite passée au rollout pour produire sa référence : 5 184 trajectoires par position jouées jusqu'au bout, avec des décisions de pions et de videau à 3 plis pendant les trois premiers demi-coups et à 2 plis ensuite, réduction de variance activée, réparties sur une flotte de workers dans le cloud. La référence d'une décision de pions porte l'equity rolloutée de chaque candidat conservé par le filtre du joueur de référence ; celle d'une décision de videau porte les equities de non-double, double/prise et double/passe. Une subtilité compte lorsqu'on compare des moteurs : un candidat hors de l'ensemble filtré du joueur de référence n'est jamais évalué qu'à la précision du filtre, ce qui pénalise à l'excès un moteur dont les choix diffèrent de ceux du joueur de référence. Nous avons donc exécuté des passes de complétion des candidats — en passant au rollout, avec la même convention, chaque coup effectivement choisi par Stage 9 ou Stage 11 à 1, 2 ou 3 plis — de sorte que chaque score ci-dessous est calculé face à un candidat de qualité rollout.
Un backgame tire son nom des deux points que son détenteur tient dans le jan intérieur adverse : le backgame 2‑1 tient les points 2 et 1 de l'adversaire, le 5‑4 tient les points 5 et 4, et ainsi de suite. Dix types couvrent les combinaisons utiles. Les germes de chaque dossier sont des positions sélectionnées à la main dans des fichiers de référence XG, et son benchmark contient environ 1 000 décisions — enregistrées seulement tant que les deux ancres nommées sont tenues et que leur détenteur est en retard dans la course — pour un total cumulé de 10 021 décisions. Les positions germes de chaque dossier sont aussi des positions du benchmark, en tant que décisions de videau. Sélectionnez un type pour parcourir ses positions germes ; chaque carte montre l'analyse de videau rolloutée de la position à côté du tableau.
Un jeu de contention est défini par celui qui s'échappe, non par celui qui contient : un camp a sorti un certain nombre de pions et possède un à trois pions qui ont été frappés et doivent parcourir tout le tableau pour rentrer, tandis que l'autre camp, la course perdue, dispose ce qui lui reste — ancres, blots, prime brisé — pour continuer à les frapper, en jouant pour sauver le gammon ou parfois pour gagner. Rien n'est exigé de la structure de celui qui contient. Les 201 germes du benchmark proviennent de positions que le moteur avait déjà rencontrées (décisions des benchmarks partie illimitée et Paskogammon avec leur videau, et lignes des piles d'entraînement de backgame), filtrées par cette règle, et ses 3 197 positions — dont les décisions de videau des germes eux-mêmes — sont enregistrées tant que celui qui s'échappe a encore des pions prisonniers. Une seconde référence, pour un échantillon de 300 positions, a été rolloutée avec Stage 11 plutôt que Stage 9 jouant les essais, afin de vérifier que le choix du joueur d'essai ne décide pas de la comparaison.
Un backgame massif tient trois ancres ou plus dans le jan intérieur adverse, ou deux ancres avec sept pions ou plus à l'arrière : les positions profondes, dictées par le timing, où le joueur de backgame a engagé l'essentiel de son armée. Les 200 germes sont tirés des mêmes sources que les germes de contention, filtrés par cette règle et maintenus disjoints des familles contention et snake, et le benchmark contient 2 199 positions.
Le snake est un prime dans la moitié éloignée du tableau qui retient un unique retardataire : une suite de quatre points consécutifs ou plus, chacun fait avec deux pions ou plus, entièrement dans la moitié adverse du tableau, emprisonnant un pion sur la barre ou dans le jan intérieur du détenteur pendant que les dix autres pions adverses ou plus sont déjà entassés à la maison. C'est un jeu de prime plutôt qu'un backgame, et l'une des formes les plus difficiles à jouer au backgammon : le détenteur doit faire rouler le prime jusqu'à la maison sans relâcher le retardataire, et le moment du relâchement décide de la partie. La position étant rare en pratique, les 74 germes comprennent des variantes synthétiques de la forme classique (longueur et emplacement du prime, position du retardataire, répartition de l'entassement) à côté des rares trouvées dans les données existantes ; le benchmark contient 1 073 positions.
Trois benchmarks mesurent des parties entières plutôt qu'une famille de positions, et existent pour prouver que rien n'a été perdu : le rollout PR en partie illimitée (500 parties, 17 535 décisions), le rollout PR en match en 5 points (130 matchs, 18 292 décisions, le score du match traversant chaque décision de videau) et le rollout PR au Paskogammon (2 556 décisions, jouées depuis la position de départ dispersée du Paskogammon, qui produit bien plus de backgames et de jeux de contention que le backgammon standard). Tous trois construisent leurs références de façon adaptative — 3 plis pour les décisions nettes, rollouts tronqués pour les plus serrées, rollouts complets à 1 296 trajectoires pour les plus serrées de toutes — comme décrit dans l'étude des performances du bot.
XG a également été noté sur ces benchmarks. Il n'expose aucune interface programmatique : chaque décision du benchmark est donc écrite comme une partie à une seule décision et rejouée via sa fonction Batch Analysis, une passe par niveau d'évaluation, exactement comme pour les benchmarks de partie illimitée et de match. Ces résultats figurent sur la page performances du bot, qui compare le moteur à XG ; les tableaux ici comparent Stage 11 au Stage 9 qu'il remplace.
Stage 9 est un comité de dix-neuf réseaux de neurones : un pour les courses pures, seize sélectionnés par la paire de plans de jeu que poursuivent les deux camps (course, attaque, prime, ancrage), et deux réseaux de backgame — un pour le joueur qui tient un backgame et un pour l'adversaire — utilisés lorsque la paire de plans est ancrage contre course, que le camp qui s'ancre est en retard dans la course et tient deux ancres ou plus dans le jan intérieur adverse. Chaque réseau est une unique couche cachée de 400 unités sur 244 entrées (100 unités sur 196 entrées pour le réseau de course), produisant cinq sorties : les probabilités de gagner, de gagner un gammon, de gagner un backgammon, de perdre un gammon et de perdre un backgammon.
Stage 11 conserve les dix-sept réseaux standard octet pour octet et remplace les deux réseaux de backgame par six, soit un comité de vingt-trois :
| # | Réseau | Région qu'il évalue |
|---|---|---|
| 0–16 | Les réseaux de course et de paires de plans de Stage 9 | Tout le reste, exactement comme dans Stage 9 |
| 17 | Backgame profond | Les backgames 2‑1, 3‑1 et 3‑2 : les deux ancres sur les points 1, 2 ou 3 de l'adversaire |
| 18 | Backgame intermédiaire | Les backgames 4‑1, 4‑2, 5‑1 et 5‑2 : une ancre sur le point 1 ou 2, une plus haute |
| 19 | Double ancre | Les backgames 4‑3, 5‑3 et 5‑4 : deux ancres, aucune plus profonde que le point 3 |
| 20 | Contention précoce | Un détenteur de backgame qui a touché un tir alors que le coureur a encore au plus deux pions sortis, dans des positions que le filtre des paires de plans confierait sinon à un réseau standard |
| 21 | Contention | N'importe quel jeu de contention, quoi que tienne celui qui contient |
| 22 | Snake | Un prime dans la moitié éloignée retenant un retardataire face à un tableau entassé |
Deux choix de conception comptent plus que le nombre. Les réseaux de backgame sont choisis d'après la catégorie du backgame — le même réseau quel que soit le camp qui le tient — plutôt que d'après le camp qui le tient, si bien que chacun apprend une seule structure sous les deux perspectives. Et le réseau d'un jeu de pions est choisi d'après la position avant le coup, si bien qu'un seul réseau évalue tous les candidats, y compris ceux qui quittent sa région (le coup qui abandonne une ancre, ou qui relâche le prime) ; c'est ce qui rend cohérentes les décisions tenir-ou-courir, et c'est aussi pourquoi les données d'entraînement de chaque réseau doivent inclure les positions auxquelles mènent ces coups de relâchement.
L'algorithme d'aiguillage est une courte liste ordonnée de tests structurels sur la position, le premier qui correspond l'emportant :
Les tests étant structurels, leur empreinte peut être mesurée sur n'importe quel ensemble de positions, et c'est cette empreinte qui borne le risque : sur le benchmark partie illimitée, la règle de contention s'applique à 1,3 % des positions, la règle de contention précoce à 0,6 % et les règles de backgame à 2,4 %, tandis que la règle snake ne s'applique à aucune ; sur le benchmark Paskogammon, les chiffres sont 2,6 %, 20 % et 25 %. Les 95 % de positions ordinaires que Stage 11 évalue à l'identique de Stage 9 sont, par construction, inchangées.
Chaque nouveau réseau a été entraîné comme l'ont été les réseaux de backgame de Stage 9 : apprentissage supervisé sur GPU face à des cibles rolloutées — les cinq probabilités qu'un rollout complet attribue à une position — avec un démarrage à chaud depuis un réseau existant, en conservant le point de contrôle qui obtient le meilleur score sur un dixième des données mis de côté. Ce qui diffère d'un réseau à l'autre, c'est l'origine de ses positions, et chaque réponse nous a appris quelque chose.
Stage 9 et Stage 10 avaient déjà accumulé des positions de backgame rolloutées — parties standard et parties de Paskogammon, environ 640 000 lignes en tout. Les répartir par catégorie a donné 245 000 lignes d'entraînement profondes, 167 000 intermédiaires et 94 000 double ancre, avec des lignes de benchmark mises de côté et dédupliquées par rapport à elles. Entraîné sur celles-là seulement, le trio était meilleur que Stage 9 à l'intérieur de sa région et pire à sa frontière : un réseau qui n'a jamais vu que des positions où les deux ancres sont tenues n'a aucune idée de ce que vaut la position une fois une ancre abandonnée, et comme il évalue tous les candidats d'une décision de backgame, il devinait — environ 0,3 point trop optimiste, ce qui expliquait plus de la moitié de son erreur sur les benchmarks profonds. Le remède a été de récolter les descendants de sortie : pour chaque position d'entraînement, les coups légaux qui quittent la catégorie, rolloutés dans l'orientation où l'aiguilleur les évalue. Quarante mille par catégorie, ajoutés à l'ensemble d'entraînement, ont supprimé ce mode d'erreur. Le démarrage à chaud depuis le réseau de backgame de Stage 9 lui-même a battu à la fois un départ aléatoire et une amorce par différences temporelles.
L'analyse de l'erreur résiduelle du trio a montré qu'elle dépendait de la phase de la partie plutôt que des ancres tenues : elle grimpait à mesure que le coureur rentrait, et culminait juste après que le détenteur avait touché un tir. Des spécialistes de phase entraînés sur les tranches correspondantes des mêmes données n'ont pas battu le trio à l'intérieur de sa région — mais sur les positions de contention que le filtre des paires de plans rejette (le bloc restant du coureur se lisant comme un prime, Stage 9 confie la position à un réseau standard), un spécialiste de contention précoce a fait passer le PR à 1 pli de 4,90 à 3,69 et divisé les blunders par deux. Il est entraîné à partir du réseau profond sur les lignes de contention précoce des données du trio et utilisé uniquement là.
La règle de contention est nouvelle, si bien que sa région n'avait presque aucune donnée rolloutée : environ 1 % des piles existantes. Nous avons joué 3 000 parties depuis les germes de contention avec Stage 11 lui-même, en excluant chaque position et candidat du benchmark dans les deux orientations, et conservé les positions satisfaisant la règle — 35 266 tableaux nouveaux, plus 9 734 lignes déjà rolloutées — puis les avons rolloutées à 1 296 trajectoires avec un jeu à 3 plis. Un réseau entraîné sur ces 45 000 lignes était excellent sur le benchmark de contention et pire que Stage 9 sur les 237 positions de partie illimitée que la règle lui aiguille : ce sont des positions de contention de parties ordinaires (une frappe tardive pendant la sortie, une fermeture) qui n'apparaissaient jamais dans les données de la famille. Ajouter les 291 000 lignes du corpus général d'entraînement satisfaisant la même règle, les lignes de la famille pesant quatre fois plus, a ramené la tranche partie illimitée au niveau de Stage 9 et a aussi rendu le réseau meilleur sur le benchmark de la famille. C'est la leçon générale de ce travail : un réseau spécialiste doit être entraîné sur sa région entière, jamais sur le coin qu'en occupe le benchmark.
Le snake n'avait de données nulle part — une centaine de lignes dans un corpus de 1,8 million — et ne pouvait pas être récolté en auto-jeu : le modèle jouait si mal ces positions qu'il brisait le prime ou courait en un ou deux coups, et 900 parties n'ont livré qu'à peine deux décisions de snake chacune. La région a donc été échantillonnée directement. Cinq mille snakes synthétiques (longueur et emplacement du prime, pions de réserve répartis de la moitié éloignée jusqu'à la maison, un adversaire entassé avec jusqu'à cinq pions sortis et un à trois retardataires) ont servi de germes à de courtes parties à 2 plis où le détenteur préférait les coups qui conservent la structure, et chaque décision a apporté sa position, ses cinq meilleurs candidats et jusqu'à trois candidats de relâchement — les coups que le réseau doit évaluer correctement pour savoir quand lâcher. Cela a produit 98 000 tableaux distincts, dont 22 000 rolloutés à 648 trajectoires avec un jeu à 3 plis ; les parties de snake sont si longues qu'un rollout coûte six fois celui d'une contention. Le réseau s'entraîne en quelques minutes sur cet ensemble, et c'est le premier réseau Open Sage doté d'une quelconque compétence dans la région : son erreur à 1 pli face aux cibles d'entraînement est passée de 0,30 à 0,054 point.
| Réseau | Lignes d'entraînement | Source | Démarrage à chaud |
|---|---|---|---|
| Backgame profond | 245 000 + 40 000 sorties | Piles rolloutées de Stage 9/10, réparties par catégorie ; descendants de sortie à un coup | Réseau de backgame de Stage 9 |
| Backgame intermédiaire | 167 000 + 40 000 sorties | comme ci-dessus | Réseau de backgame de Stage 9 |
| Double ancre | 94 000 + 40 000 sorties | comme ci-dessus | Réseau de backgame de Stage 9 |
| Contention précoce | tranche de phase de ce qui précède | lignes de contention précoce des données du trio | Réseau de backgame profond |
| Contention | 45 000 de la famille + 291 000 générales | Auto-jeu depuis les germes de contention, rollouté ; les lignes de la règle dans le corpus général | Réseau prime-contre-course de Stage 9 |
| Snake | 22,000 | Germes synthétiques + auto-jeu conservant la structure, rolloutés | Réseau prime-contre-course de Stage 9 |
Chaque chiffre est un Performance Rating — plus bas est meilleur — à l'évaluation 1-ply, 2-ply et 3-ply du moteur lui-même et à ses trois niveaux de rollout tronqué, 1T, 2T et 3T (les équivalents de Roller, Roller+ et Roller++ de XG). Les deux moteurs sont notés face aux mêmes références, chaque choix de l'un comme de l'autre étant évalué sur rollout. XG est comparé au moteur sur la page performances du bot ; sur Paskogammon, où les deux moteurs ont été exécutés à tous les niveaux, la comparaison est ci-dessous.
| Benchmark | Décisions | 1-ply | 2-ply | 3-ply | 1T · Roller | 2T · Roller+ | 3T · Roller++ | ||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | ||
| Partie illimitée | 17,535 | 2.59 | 2.55 | — | 1.66 | 1.68 | — | 0.60 | 0.60 | 0.57 | 0.50 | 0.49 | 0.53 | 0.26 | 0.27 | 0.41 | 0.23 | 0.23 | 0.34 |
| Match en 5 points | 18,292 | 2.26 | 2.22 | — | 1.30 | 1.27 | — | 0.57 | 0.56 | 0.54 | 0.49 | 0.47 | 0.51 | 0.26 | 0.26 | 0.44 | 0.22 | 0.23 | 0.36 |
| Paskogammon | 2,556 | 7.74 | 6.14 | — | 5.42 | 4.57 | 4.38 | 3.46 | 2.28 | 2.97 | 2.67 | 1.65 | 2.63 | 2.21 | 1.46 | 2.44 | 1.47 | 0.88 | 1.92 |
| Backgame | Décisions | 1-ply | 2-ply | 3-ply | 1T · Roller | 2T · Roller+ | 3T · Roller++ | ||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | ||
| 2‑1 | 1,000 | 6.59 | 3.57 | — | 4.51 | 2.26 | 2.84 | 2.70 | 1.01 | 1.64 | 2.03 | 0.61 | 1.67 | 1.72 | 0.41 | 0.98 | 1.08 | 0.38 | 0.93 |
| 3‑1 | 1,001 | 4.44 | 3.28 | — | 2.77 | 2.22 | 2.22 | 0.93 | 0.88 | 0.95 | 0.92 | 0.66 | 0.91 | 0.66 | 0.34 | 0.59 | 0.53 | 0.32 | 0.48 |
| 3‑2 | 1,008 | 4.22 | 3.31 | — | 2.47 | 2.07 | 2.39 | 1.09 | 0.91 | 1.31 | 1.40 | 0.65 | 0.95 | 0.75 | 0.44 | 0.61 | 0.74 | 0.25 | 0.51 |
| 4‑1 | 1,001 | 3.70 | 2.74 | — | 1.76 | 1.77 | 1.83 | 0.85 | 0.78 | 0.82 | 1.18 | 0.55 | 0.69 | 0.52 | 0.24 | 0.47 | 0.56 | 0.19 | 0.45 |
| 4‑2 | 1,000 | 4.16 | 3.25 | — | 2.20 | 2.16 | 1.96 | 1.04 | 0.73 | 1.05 | 1.27 | 0.63 | 0.79 | 0.55 | 0.36 | 0.61 | 0.51 | 0.27 | 0.43 |
| 5‑1 | 1,003 | 3.36 | 2.56 | — | 1.69 | 1.32 | 1.77 | 0.95 | 0.66 | 0.76 | 1.20 | 0.49 | 0.60 | 0.62 | 0.26 | 0.41 | 0.57 | 0.23 | 0.32 |
| 5‑2 | 1,002 | 3.88 | 2.61 | — | 1.74 | 1.53 | 1.60 | 0.57 | 0.49 | 0.82 | 1.37 | 0.53 | 0.63 | 0.52 | 0.33 | 0.41 | 0.52 | 0.24 | 0.30 |
| 4‑3 | 1,002 | 4.56 | 3.24 | — | 2.04 | 1.69 | 2.13 | 0.81 | 0.74 | 0.80 | 1.23 | 0.52 | 0.76 | 0.72 | 0.24 | 0.55 | 0.54 | 0.19 | 0.44 |
| 5‑3 | 1,003 | 3.79 | 2.80 | — | 1.79 | 1.86 | 2.13 | 0.96 | 1.02 | 0.89 | 1.27 | 0.68 | 0.81 | 0.69 | 0.35 | 0.46 | 0.50 | 0.21 | 0.44 |
| 5‑4 | 1,001 | 5.97 | 3.10 | — | 2.84 | 2.45 | 2.74 | 1.42 | 0.93 | 1.15 | 1.53 | 0.76 | 0.97 | 0.70 | 0.47 | 0.55 | 0.63 | 0.30 | 0.49 |
| Cumulé | 10,021 | 4.47 | 3.05 | — | 2.38 | 1.93 | 2.16 | 1.13 | 0.82 | 1.02 | 1.34 | 0.61 | 0.88 | 0.75 | 0.34 | 0.56 | 0.62 | 0.26 | 0.48 |
| Benchmark | Décisions | 1-ply | 2-ply | 3-ply | 1T · Roller | 2T · Roller+ | 3T · Roller++ | ||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | S9 | S11 | XG | ||
| Contention | 3,270 | 9.65 | 6.82 | — | 9.63 | 4.73 | 14.62 | 5.09 | 2.54 | 11.25 | 3.78 | 2.29 | 7.76 | 3.20 | 1.30 | 7.85 | 2.53 | 1.05 | 6.16 |
| Backgame massif | 2,103 | 9.78 | 5.71 | — | 7.88 | 4.33 | 5.76 | 4.89 | 2.56 | 4.44 | 3.85 | 1.91 | 3.14 | 3.21 | 1.39 | 2.75 | 2.80 | 1.09 | 2.64 |
| Snake | 978 | 64.87 | 21.08 | — | 39.17 | 21.00 | 39.92 | 26.51 | 21.42 | 36.64 | 28.25 | 11.19 | 32.99 | 20.96 | 8.42 | 32.38 | 14.79 | 5.85 | 32.24 |
Le Paskogammon est là où le travail sur les backgames se voit dans des parties entières : joué depuis sa position de départ dispersée, il produit bien plus de backgames et de jeux de contention que le backgammon standard, si bien qu'il est le seul benchmark sur parties complètes où ces réseaux interviennent assez souvent pour faire bouger le chiffre global. C'est aussi le seul sur lequel XG a été exécuté à chaque niveau qu'il propose, de 2 plis à Roller++ — les parties sont exportées vers XG sous forme d'archives
.xg archives, qui portent explicitement la position de départ non standard, et analysées en lot une fois par niveau. Le tableau note Stage 9, Stage 11 et XG face à la même référence de rollout sur les 2 556 décisions du benchmark, regroupées par niveau équivalent ; le meilleur de chaque groupe est mis en évidence.
| Moteur | PR | Pions | Videau | Course pure | Course | Attaque | Prime | Ancrage |
|---|---|---|---|---|---|---|---|---|
| Stage 9 3T | 1.47 | 1.36 | 2.21 | 0.08 | 1.46 | 1.11 | 0.80 | 2.45 |
| Stage 11 3T | 0.88 | 0.85 | 1.07 | 0.08 | 0.59 | 0.96 | 0.44 | 1.71 |
| XG Roller++ | 1.92 | 1.99 | 1.37 | 0.01 | 1.36 | 2.35 | 1.10 | 3.39 |
| Stage 9 2T | 2.21 | 2.27 | 1.80 | 0.03 | 2.21 | 2.25 | 0.90 | 3.54 |
| Stage 11 2T | 1.46 | 1.51 | 1.08 | 0.03 | 1.36 | 1.79 | 0.51 | 2.35 |
| XG Roller+ | 2.44 | 2.59 | 1.45 | 0.02 | 1.97 | 2.48 | 1.54 | 4.19 |
| Stage 9 1T | 2.67 | 2.60 | 3.16 | 0.08 | 2.55 | 1.74 | 2.17 | 4.24 |
| Stage 11 1T | 1.65 | 1.64 | 1.76 | 0.08 | 1.14 | 1.37 | 1.02 | 3.31 |
| XG Roller | 2.63 | 2.69 | 2.23 | 0.05 | 2.36 | 2.86 | 1.54 | 4.15 |
| Stage 9 4P | 2.68 | 2.75 | 2.20 | 0.14 | 2.51 | 2.46 | 1.52 | 4.37 |
| Stage 11 4P | 1.90 | 1.92 | 1.72 | 0.14 | 1.64 | 2.43 | 1.04 | 2.88 |
| XG 4-ply | 2.62 | 2.66 | 2.32 | 0.05 | 2.22 | 2.76 | 1.58 | 4.32 |
| Stage 9 3P | 3.46 | 3.53 | 2.98 | 0.03 | 3.50 | 3.62 | 2.20 | 4.84 |
| Stage 11 3P | 2.28 | 2.35 | 1.78 | 0.03 | 1.64 | 3.69 | 1.21 | 3.53 |
| XG 3-ply | 2.97 | 2.96 | 3.04 | 0.05 | 2.55 | 3.21 | 1.77 | 4.81 |
| Stage 9 2P | 5.42 | 5.39 | 5.57 | 0.16 | 5.02 | 5.19 | 4.11 | 8.02 |
| Stage 11 2P | 4.57 | 4.37 | 5.93 | 0.16 | 3.97 | 5.16 | 3.95 | 6.30 |
| XG 2-ply | 4.38 | 4.50 | 3.58 | 0.23 | 3.52 | 5.83 | 2.98 | 6.50 |
| Stage 9 1P | 7.74 | 7.67 | 8.21 | 0.26 | 6.94 | 8.51 | 6.56 | 10.61 |
| Stage 11 1P | 6.14 | 5.93 | 7.58 | 0.26 | 5.18 | 8.55 | 4.70 | 8.18 |
Le moteur, les benchmarks, les positions germes, les références et chaque script d'entraînement sont dans le dépôt open source bgsage (MPL-2.0). Les benchmarks de backgame vivent sous
backgame_ref_positions/benchmark/ — un fichier starting.txt de germes, un fichier
benchmark.txt de décisions et une référence rollout.jsonl par dossier — et sont générés par scripts/backgame_benchmark.py, les germes des trois familles étant produits par scripts/build_family_seeds.py, et notés par
scripts/score_backgame_pr.py, qui rapporte le PR à côté de la part des choix de qualité rollout. Les règles d'aiguillage sont dans cpp/src/neural_net.cpp
avec des implémentations de référence en Python dans scripts/containment_rule.py et
scripts/snake_rule.py, et le modèle lui-même est l'entrée stage11s du registre des poids. Les scripts de données d'entraînement sont nommés dans le tableau ci-dessus par leur source ; les rollouts dont ils ont besoin sont distribués par des orchestrateurs qui ne font pas partie du dépôt public, mais chaque fichier de positions et chaque cible rolloutée en font partie.
| Sans videau | Gain | Gammon | Backgammon |
|---|---|---|---|
| Joueur | |||
| Adversaire |
| Action de videau | Equity |
|---|---|
| Pas de double | |
| Double / Prise | |
| Double / Passe |