Cómo se construyó el motor Stage 11 que impulsa Backgammon Sage Pro para manejar las posiciones que todos los bots juegan peor — backgames, juegos de contención y el snake — y qué dicen los benchmarks al respecto.
Los motores de backgammon siempre han sido más débiles en los juegos lentos y estructurales: los backgames, en los que un jugador mantiene dos o más anclas en lo profundo del tablero rival y espera un tiro; los juegos de contención, en los que un jugador con la carrera perdida intenta mantener atrapadas una o dos fichas golpeadas; y el snake, un prime en la mitad lejana del tablero que retiene una sola ficha rezagada mientras el resto del ejército rival se desmorona. Estas posiciones son raras en el juego corriente e inusualmente largas cuando surgen, así que apenas están representadas en los datos de juego contra sí mismo de los que aprende un motor, y un motor que apenas las ha visto las valora extrapolando desde posiciones que solo parecen similares. El motor Open Sage Stage 9 se entrenó con posiciones de backgame y obtiene mejores puntuaciones que eXtreme Gammon a niveles de evaluación equivalentes, pero su tasa de error en estos juegos sigue siendo varias veces mayor que en el resto. Stage 11 ataca el problema de frente. Primero construimos benchmarks hechos de backgames, juegos de contención y snakes, cada uno puntuado como Performance Rating frente a referencias de calidad rollout; después añadimos al motor seis redes neuronales, seleccionadas por un pequeño conjunto de reglas estructurales; luego generamos objetivos de rollout para cada una de ellas; y por último puntuamos el resultado frente a todos los benchmarks de que disponemos. En el benchmark de contención, Stage 11 reduce el PR a 3 plies de 6,89 a 3,58 y el número de blunders de 156 a 53; en los diez benchmarks clásicos de backgame su PR a 1 ply baja de 4,75 a 2,98; y su juego en partidas ilimitadas y en Paskogammon — una variante que se juega desde una posición inicial personalizada que conduce a muchos más backgames — no cambia o mejora.
Los motores de backgammon basados en redes neuronales aprenden de millones de partidas jugadas contra sí mismos, y aprenden lo que esas partidas contienen. Los backgames, los juegos de contención y los primes que retienen una sola ficha rezagada son raros en el juego corriente e inusualmente largos cuando se producen, de modo que un motor generalista ve pocos y los valora extrapolando desde posiciones que parecen similares pero no lo son. El resultado es una debilidad bien conocida: un motor que en una partida normal comete un error cada veinte decisiones puede cometer uno cada tres en un backgame profundo, y tiende a juzgar mal las mismas cosas que un jugador humano intermedio — cuándo mantener un ancla y cuándo correr, cuánto timing tiene una posición y cuándo debe soltarse un prime.
El motor Open Sage Stage 9, que impulsa Backgammon Sage Pro, ya incluye dos redes entrenadas específicamente con posiciones de backgame, y nuestro estudio de rendimiento del bot muestra que evalúa al menos tan bien como eXtreme Gammon en cada nivel equivalente. Pero ser fuerte respecto a otros bots no es lo mismo que ser fuerte en términos absolutos. Medida frente a rollouts, la tasa de error de Stage 9 en backgames es de dos a tres veces la de las partidas corrientes, y en los juegos de contención y los snakes es aún peor: en el benchmark de snake de más abajo su Performance Rating a 1 ply supera 60, frente a una cifra de 2,6 en partidas ilimitadas.
Stage 11 está diseñado para eliminar esas debilidades sin tocar nada más. El trabajo se hizo en cuatro pasos. Primero construimos una familia de benchmarks que puntúan el juego de backgame y de contención en distintos tipos de posición — diez tipos clásicos de backgame, una familia de contención, una familia de backgames masivos y una familia de snake — cada uno un conjunto de decisiones reales puntuadas frente a referencias de calidad rollout, de modo que Stage 9, Stage 11 y XG puedan medirse en igualdad de condiciones. Segundo, diseñamos el modelo Stage 11: las diecisiete redes de Stage 9 sin cambios, más seis redes nuevas para las familias de backgame, y un algoritmo de enrutamiento que decide a partir de la estructura de una posición qué red la evalúa. Tercero, generamos datos de entrenamiento para cada red nueva — una mezcla de posiciones cosechadas del juego contra sí mismo, posiciones sintéticas y corpus de rollout existentes, todas sometidas a rollout para producir los objetivos. Cuarto, entrenamos las redes y puntuamos el motor terminado frente a todos los benchmarks de backgame y frente a nuestros benchmarks de rollout PR de partidas ilimitadas, matches a 5 puntos y Paskogammon (una variante que se juega desde una posición inicial personalizada elegida para producir muchos backgames), para asegurarnos de que las ganancias en backgames no costaran nada en el resto.
La versión corta de los resultados: Stage 11 es notablemente más fuerte allí donde las redes nuevas intervienen e idéntico a Stage 9 allí donde no. Su PR a 3 plies en el benchmark de contención es apenas la mitad del de Stage 9, sus blunders allí caen dos tercios, su PR a 1 ply agregado en los diez backgames clásicos baja un 37 %, y es el primer motor Open Sage que progresa de verdad en el snake. El juego en partidas ilimitadas no cambia y el de Paskogammon mejora. El resto de esta página da los detalles.
Todos los benchmarks de aquí siguen la misma receta que nuestro benchmark de rollout PR de partidas ilimitadas: un conjunto de decisiones reales, cada una con una evaluación de referencia de calidad rollout, frente a la cual un motor se puntúa como Performance Rating — su error medio de equity por decisión, multiplicado por 500, la convención que usa XG. Un PR de 2 significa que el motor regala de media 0,004 puntos por decisión; un PR de 60 significa 0,12 por decisión, que es territorio de principiante.
Lo que difiere es de dónde vienen las decisiones. Cada benchmark de backgame parte de un pequeño conjunto de posiciones semilla que definen su familia — las posiciones de referencia que se muestran en los carruseles de abajo. El motor juega después partidas ilimitadas desde esas semillas contra sí mismo, con cubo, con Jacoby y beaver activos, a 3 plies, y se registra cada decisión que surge mientras la posición sigue perteneciendo a la familia: una jugada de fichas cuenta cuando hay al menos dos movimientos legales y una diferencia de equity significativa entre ellos, y una posición de cubo cuenta cuando la decisión del que dobla no es trivialmente obvia o cuando se ofrece efectivamente un doble. Las semillas se usan en un ciclo barajado, quién mueve primero se decide a cara o cruz, y todo es función pura de una única semilla aleatoria, de modo que cualquier benchmark se regenera de forma idéntica.
Cada decisión registrada se somete después a rollout para producir su referencia: 5.184 trayectorias por posición jugadas hasta el final, con decisiones de fichas y de cubo a 3 plies en los tres primeros medios movimientos y a 2 plies a partir de ahí, reducción de varianza activada, distribuidas en una flota de workers en la nube. La referencia de una decisión de fichas lleva la equity de rollout de cada candidata que conservó el filtro del jugador de referencia; la de una decisión de cubo lleva las equities de no doblar, doblar/aceptar y doblar/pasar. Hay una sutileza que importa al comparar motores: una candidata fuera del conjunto de filtro del jugador de referencia solo se valora con la precisión del filtro, lo que penaliza en exceso a un motor cuyas elecciones difieren de las del jugador de referencia. Por eso ejecutamos pasadas de completado de candidatas — sometiendo a rollout, con la misma convención, cada movimiento que Stage 9 o Stage 11 eligieron efectivamente a 1, 2 o 3 plies — de modo que todas las puntuaciones de abajo se calculan frente a candidatas de calidad rollout.
Un backgame se nombra por los dos puntos que su dueño mantiene en el tablero interior rival: el backgame 2‑1 mantiene los puntos 2 y 1 del rival, el 5‑4 mantiene los puntos 5 y 4, y así sucesivamente. Diez tipos cubren las combinaciones útiles. Las semillas de cada carpeta son posiciones seleccionadas a mano de archivos de referencia de XG, y su benchmark contiene unas 1.000 decisiones — registradas solo mientras las dos anclas indicadas siguen en pie y quien las mantiene va por detrás en la carrera — para un total agregado de 10.021 decisiones. Las posiciones semilla de cada carpeta son también posiciones del benchmark, como decisiones de cubo. Selecciona un tipo para recorrer sus posiciones semilla; cada tarjeta muestra el análisis de cubo por rollout de la posición junto al tablero.
Un juego de contención lo define el que escapa, no el que contiene: un bando ha sacado cierto número de fichas y tiene de una a tres fichas que fueron golpeadas y deben recorrer todo el tablero de vuelta a casa, mientras el otro bando, con la carrera perdida, dispone lo que le queda — anclas, blots, un prime roto — para seguir golpeándolas, jugando a salvar el gammon o, en ocasiones, a ganar. No se exige nada de la estructura del que contiene. Las 201 semillas del benchmark proceden de posiciones que el motor ya había encontrado (decisiones de los benchmarks de partidas ilimitadas y Paskogammon con su cubo, y filas de las pilas de entrenamiento de backgame), filtradas con esa regla, y sus 3.197 posiciones — entre ellas las decisiones de cubo de las propias semillas — se registran mientras el que escapa aún tiene fichas atrapadas. Una segunda referencia para una muestra de 300 posiciones se sometió a rollout con Stage 11 en lugar de Stage 9 jugando las pruebas, para comprobar que la elección del jugador de prueba no decide la comparación.
Un backgame masivo mantiene tres o más anclas en el tablero interior rival, o dos anclas con siete o más fichas atrás: las posiciones profundas, gobernadas por el timing, en las que el jugador de backgame ha comprometido la mayor parte del ejército. Las 200 semillas se extraen de las mismas fuentes que las semillas de contención, filtradas con esa regla y mantenidas disjuntas de las familias de contención y snake, y el benchmark contiene 2.199 posiciones.
El snake es un prime en la mitad lejana del tablero que retiene una sola ficha rezagada: una serie de cuatro o más puntos consecutivos, cada uno hecho con dos o más fichas, enteramente en la mitad rival del tablero, que atrapa una ficha en la barra o en el tablero interior de quien tiene el prime mientras las otras diez o más fichas rivales ya están amontonadas en casa. Es un juego de prime más que un backgame, y una de las formas más difíciles de jugar en el backgammon: quien tiene el prime debe hacerlo rodar hacia casa sin soltar la ficha rezagada, y el momento de soltarla decide la partida. Como la posición es rara en el juego, las 74 semillas incluyen variantes sintéticas de la forma clásica (longitud y colocación del prime, ubicación de la ficha rezagada, reparto del amontonamiento) junto a las pocas encontradas en los datos existentes; el benchmark contiene 1.073 posiciones.
Tres benchmarks miden partidas enteras en lugar de una familia de posiciones, y existen para demostrar que no se perdió nada: el rollout PR de partidas ilimitadas (500 partidas, 17.535 decisiones), el rollout PR de matches a 5 puntos (130 matches, 18.292 decisiones, con el marcador del match presente en cada decisión de cubo) y el rollout PR de Paskogammon (2.556 decisiones, jugadas desde la posición inicial dispersa del Paskogammon, que produce muchos más backgames y juegos de contención que el backgammon estándar). Los tres construyen sus referencias de forma adaptativa — 3 plies para las decisiones claras, rollouts truncados para las más ajustadas, rollouts completos de 1.296 trayectorias para las más ajustadas de todas — como se describe en el estudio de rendimiento del bot.
XG también ha sido puntuado en estos benchmarks. No expone ninguna interfaz programática, así que cada decisión del benchmark se escribe como una partida de una sola decisión y se reproduce mediante su función Batch Analysis, una pasada por nivel de evaluación, exactamente igual que los benchmarks de partida ilimitada y de partido. Esos resultados están en la página de rendimiento del bot, que compara el motor con XG; las tablas de aquí comparan Stage 11 con el Stage 9 al que sustituye.
Stage 9 es un comité de diecinueve redes neuronales: una para carreras puras, dieciséis seleccionadas por el par de planes de juego que siguen los dos bandos (carrera, ataque, prime, anclaje), y dos redes de backgame — una para el jugador que mantiene un backgame y otra para el rival — que se usan cuando el par de planes es anclaje contra carrera, el bando que ancla va por detrás en la carrera y mantiene dos o más anclas en el tablero interior rival. Cada red es una única capa oculta de 400 unidades sobre 244 entradas (100 unidades sobre 196 entradas en la red de carrera), que produce cinco salidas: las probabilidades de ganar, ganar un gammon, ganar un backgammon, perder un gammon y perder un backgammon.
Stage 11 conserva las diecisiete redes estándar byte a byte y sustituye las dos redes de backgame por seis, dando un comité de veintitrés:
| # | Red | Región que evalúa |
|---|---|---|
| 0–16 | Las redes de carrera y de pares de planes de Stage 9 | Todo lo demás, exactamente como en Stage 9 |
| 17 | Backgame profundo | Los backgames 2‑1, 3‑1 y 3‑2: ambas anclas en los puntos 1, 2 o 3 del rival |
| 18 | Backgame intermedio | Los backgames 4‑1, 4‑2, 5‑1 y 5‑2: un ancla en el punto 1 o 2, otra más alta |
| 19 | Doble ancla | Los backgames 4‑3, 5‑3 y 5‑4: dos anclas, ninguna más profunda que el punto 3 |
| 20 | Contención temprana | Un jugador de backgame que ha acertado un tiro mientras el que corre aún tiene como mucho dos fichas fuera, en posiciones que el filtro de pares de planes entregaría de otro modo a una red estándar |
| 21 | Contención | Cualquier juego de contención, sea cual sea lo que tenga el que contiene |
| 22 | Snake | Un prime en la mitad lejana que retiene una ficha rezagada contra un tablero amontonado |
Dos decisiones de diseño importan más que el número. Las redes de backgame se eligen por la categoría del backgame — la misma red sea quien sea el que lo mantiene — en lugar de por quién lo mantiene, de modo que cada una aprende una sola estructura desde ambas perspectivas. Y la red para una jugada de fichas se elige a partir de la posición anterior al movimiento, de modo que una sola red valora todas las candidatas, incluidas las que abandonan su región (el movimiento que cede un ancla, o que suelta el prime); eso es lo que hace coherentes las decisiones de mantener o correr, y también la razón por la que los datos de entrenamiento de cada red tienen que incluir las posiciones a las que conducen esos movimientos de liberación.
El algoritmo de enrutamiento es una breve lista ordenada de pruebas estructurales sobre la posición, en la que gana la primera que se cumple:
Como las pruebas son estructurales, su huella puede medirse en cualquier conjunto de posiciones, y esa huella es lo que acota el riesgo: en el benchmark de partidas ilimitadas la regla de contención se activa en el 1,3 % de las posiciones, la regla de contención temprana en el 0,6 % y las reglas de backgame en el 2,4 %, mientras que la regla de snake no se activa en ninguna; en el benchmark de Paskogammon las cifras son 2,6 %, 20 % y 25 %. El 95 % de posiciones corrientes que Stage 11 evalúa de forma idéntica a Stage 9 queda, por construcción, sin cambios.
Cada red nueva se entrenó como las redes de backgame de Stage 9: aprendizaje supervisado en la GPU frente a objetivos de rollout — las cinco probabilidades que un rollout completo asigna a una posición — partiendo en caliente de una red existente y conservando el checkpoint con mejor puntuación en una décima parte de los datos reservada. Lo que cambia en cada red es de dónde vienen sus posiciones, y cada respuesta nos enseñó algo.
Stage 9 y Stage 10 ya habían acumulado posiciones de backgame sometidas a rollout — partidas estándar y partidas de Paskogammon, unas 640.000 filas en total. Dividirlas por categoría dio 245.000 filas de entrenamiento profundas, 167.000 intermedias y 94.000 de doble ancla, con filas de benchmark reservadas y deduplicadas frente a ellas. Entrenado solo con esas, el trío era mejor que Stage 9 dentro de su región y peor en su borde: una red que solo ha visto posiciones con ambas anclas en pie no tiene idea de cuánto vale la posición una vez cedida un ancla, y como valora todas las candidatas de una decisión de backgame, adivinaba — unos 0,3 puntos demasiado optimista, lo que explicaba más de la mitad de su error en los benchmarks profundos. La solución fue cosechar descendientes de salida: para cada posición de entrenamiento, los movimientos legales que abandonan la categoría, sometidos a rollout en la orientación en la que el enrutador los evalúa. Cuarenta mil por categoría, añadidos al conjunto de entrenamiento, eliminaron ese modo de error. Partir en caliente de la propia red de backgame de Stage 9 superó tanto a un inicio aleatorio como a un arranque por diferencias temporales.
Analizar dónde quedaba el error restante del trío mostró que lo gobernaba la fase de la partida más que las anclas mantenidas: subía a medida que el que corre entraba en casa, y era peor justo después de que el que mantiene el backgame acertara un tiro. Especialistas de fase entrenados con los cortes correspondientes de los mismos datos no superaron al trío dentro de su región — pero en las posiciones de contención que el filtro de pares de planes rechaza (el bloque restante del que corre se lee como un prime, así que Stage 9 entrega la posición a una red estándar), un especialista en contención temprana redujo el PR a 1 ply de 4,90 a 3,69 y dejó los blunders a la mitad. Se entrena a partir de la red profunda con las filas de contención temprana de los datos del trío y se usa solo ahí.
La regla de contención es nueva, así que su región apenas tenía datos de rollout: alrededor del 1 % de las pilas existentes. Jugamos 3.000 partidas desde las semillas de contención con el propio Stage 11, excluyendo toda posición y candidata del benchmark en ambas orientaciones, y conservamos las posiciones que cumplían la regla — 35.266 tableros nuevos, más 9.734 filas ya sometidas a rollout — y las sometimos a rollout a 1.296 trayectorias con juego a 3 plies. Una red entrenada con esas 45.000 filas era excelente en el benchmark de contención y peor que Stage 9 en las 237 posiciones de partidas ilimitadas que la regla le enruta: son posiciones de contención de partidas corrientes (un golpe tardío durante la salida de fichas, un cierre) que nunca aparecían en los datos de la familia. Añadir las 291.000 filas del corpus general de entrenamiento que cumplen la misma regla, con las filas de la familia ponderadas por cuatro, devolvió el segmento de partidas ilimitadas al nivel de Stage 9 y también hizo la red mejor en el benchmark de la familia. Esa es la lección general de este trabajo: una red especialista debe entrenarse con su región completa, nunca con el rincón de ella que ocupa el benchmark.
El snake no tenía datos en ninguna parte — un centenar de filas en un corpus de 1,8 millones — y no podía cosecharse del juego contra sí mismo: el modelo jugaba tan mal estas posiciones que rompía el prime o corría en uno o dos movimientos, y 900 partidas rindieron apenas dos decisiones de snake cada una. Así que la región se muestreó directamente. Cinco mil snakes sintéticos (longitud y colocación del prime, fichas sobrantes repartidas desde la mitad lejana hasta casa, un rival amontonado con hasta cinco fichas fuera y de una a tres fichas rezagadas) sirvieron de semilla a partidas cortas a 2 plies en las que quien tiene el prime prefería los movimientos que conservan la estructura, y cada decisión aportó su posición, sus cinco mejores candidatas y hasta tres candidatas de liberación — los movimientos que la red debe valorar correctamente para saber cuándo soltar. Eso produjo 98.000 tableros distintos, de los que 22.000 se sometieron a rollout a 648 trayectorias con juego a 3 plies; las partidas de snake son tan largas que un rollout cuesta seis veces lo que uno de contención. La red se entrena en minutos con ese conjunto, y es la primera red Open Sage con alguna competencia en la región: su error a 1 ply frente a los objetivos de entrenamiento bajó de 0,30 a 0,054 puntos.
| Red | Filas de entrenamiento | Fuente | Inicio en caliente |
|---|---|---|---|
| Backgame profundo | 245.000 + 40.000 salidas | Pilas de rollout de Stage 9/10, divididas por categoría; descendientes de salida a un paso | Red de backgame de Stage 9 |
| Backgame intermedio | 167.000 + 40.000 salidas | como arriba | Red de backgame de Stage 9 |
| Doble ancla | 94.000 + 40.000 salidas | como arriba | Red de backgame de Stage 9 |
| Contención temprana | corte de fase de lo anterior | filas de contención temprana de los datos del trío | Red de backgame profundo |
| Contención | 45.000 de la familia + 291.000 generales | Juego contra sí mismo desde las semillas de contención, sometido a rollout; las filas de la regla en el corpus general | Red prime-contra-carrera de Stage 9 |
| Snake | 22,000 | Semillas sintéticas + juego contra sí mismo que conserva la estructura, sometidos a rollout | Red prime-contra-carrera de Stage 9 |
Cada cifra es un Performance Rating — cuanto más bajo, mejor — en la evaluación 1-ply, 2-ply y 3-ply del propio motor y en sus tres niveles de rollout truncado, 1T, 2T y 3T (las contrapartes de Roller, Roller+ y Roller++ de XG). Ambos motores se puntúan frente a las mismas referencias, con cada elección de cualquiera de ellos evaluada sobre rollouts. XG se compara con el motor en la página de rendimiento del bot; en Paskogammon, donde ambos motores se han ejecutado en todos los niveles, la comparación está más abajo.
| Benchmark | Decisiones | 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 | ||
| Partida ilimitada | 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 a 5 puntos | 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 | Decisiones | 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 |
| Agregado | 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 | Decisiones | 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 | ||
| Contención | 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 masivo | 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 |
Paskogammon es donde el trabajo de backgame se manifiesta en partidas completas: jugado desde su posición inicial dispersa, produce muchos más backgames y juegos de contención que el backgammon estándar, así que es el único benchmark de partidas completas en el que estas redes intervienen con la frecuencia suficiente para mover la cifra principal. Es también aquel en el que XG se ha ejecutado a todos los niveles que ofrece, de 2 plies a Roller++ — las partidas se exportan a XG como archivos nativos
.xg archivos, que llevan explícitamente la posición inicial no estándar, y analizados por lotes una vez por nivel. La tabla puntúa Stage 9, Stage 11 y XG frente a la misma referencia de rollout sobre las 2.556 decisiones del benchmark, agrupadas por nivel equivalente; se resalta el mejor de cada grupo.
| Motor | PR | Fichas | Cubo | Carrera pura | Carrera | Ataque | Bloqueo | Anclaje |
|---|---|---|---|---|---|---|---|---|
| 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 |
El motor, los benchmarks, las posiciones semilla, las referencias y todos los scripts de entrenamiento están en el repositorio de código abierto bgsage (MPL-2.0). Los benchmarks de backgame viven bajo
backgame_ref_positions/benchmark/ — un archivo starting.txt de semillas, un archivo
benchmark.txt de decisiones y una referencia rollout.jsonl por carpeta — y los genera scripts/backgame_benchmark.py, con las semillas de las tres familias producidas por scripts/build_family_seeds.py, y los puntúa
scripts/score_backgame_pr.py, que informa del PR junto con la proporción de elecciones de calidad rollout. Las reglas de enrutamiento están en cpp/src/neural_net.cpp
con implementaciones de referencia en Python en scripts/containment_rule.py y
scripts/snake_rule.py, y el propio modelo es la entrada stage11s del registro de pesos. Los scripts de datos de entrenamiento se nombran en la tabla de arriba por su fuente; los rollouts que necesitan los distribuyen orquestadores que no forman parte del repositorio público, pero sí lo hacen todos los archivos de posiciones y todos los objetivos de rollout.
| Sin cubo | Victoria | Gammon | Backgammon |
|---|---|---|---|
| Jugador | |||
| Rival |
| Acción de cubo | Equity |
|---|---|
| No doblar | |
| Doblar / Aceptar | |
| Doblar / Pasar |