Una comparación cuantitativa del motor de evaluación Open Sage — el que impulsa Backgammon Sage Pro — frente al motor de eXtreme Gammon (XG).
Comparamos el motor Open Sage con eXtreme Gammon (XG) en niveles de evaluación equivalentes: evaluación directa de la red neuronal, búsqueda multi-ply y rollouts truncados. Como XG no expone ninguna interfaz programática, lo puntuamos mediante su función Batch Analysis. Usamos tres métodos complementarios. El primero construye un conjunto por capas de evaluaciones de referencia — confiando en las evaluaciones rápidas cuando la elección es clara y escalando los casos ajustados a rollouts completos — y puntúa cada motor con un Performance Rating (PR) frente a esa referencia, en 500 partidas ilimitadas (17.535 decisiones) y 130 partidos a cinco puntos (18.292 decisiones). Para las partidas ilimitadas reconstruimos después toda la comparación tomando como referencia el propio análisis escalonado de XG — el espejo exacto. El segundo aísla las posiciones ilimitadas en las que Sage 3T y XG Roller++ discrepan realmente y juzga cada una frente a los rollouts completos de ambos motores. El mismo método de referencia y puntuación se aplica a trece benchmarks de backgames, partidas de contención y snake: las posiciones que los motores han jugado peor históricamente. En los estudios de fuerza los dos motores están próximos: con la referencia de Sage, Sage va por delante en los niveles de rollout truncado en los que se apoya la mayoría de los usuarios; con la de XG, XG va por delante o empata. El tercer método invierte la pregunta: en 290 partidos reales de torneo ya analizados en XG, reanalizamos cada uno en Sage y comparamos el Performance Rating que los dos motores asignan a cada jugador. Los dos índices van de la mano: en 580 índices de jugadores tienen una correlación del 98 %, y la diferencia media entre ellos es de +0,002 PR — estadísticamente indistinguible de cero.
eXtreme Gammon (XG) es la referencia habitual del análisis computacional del backgammon, y su motor de evaluación se considera ampliamente uno de los más fuertes que existen. Cualquier motor nuevo que aspire a tomarse en serio tiene que responder a una pregunta sencilla: ¿cómo se compara con XG? Este estudio se propone responderla cuantitativamente para Open Sage, el motor de redes neuronales que hay detrás de Backgammon Sage Pro.
Nuestro objetivo era comparar las evaluaciones de Open Sage con las de XG a niveles de esfuerzo comparables. El experimento natural — hacer que los motores jueguen muchos millones de partidas entre sí y contar el resultado — no es práctico: la aplicación de escritorio de XG no expone ninguna interfaz programática, así que pasar posiciones y jugadas de un motor al otro es un proceso manual, a golpe de clic. Alcanzar una muestra lo bastante grande para resolver las pequeñas diferencias entre dos motores fuertes llevaría demasiado tiempo.
En su lugar usamos la función Batch Analysis (análisis por lotes) de XG, capaz de puntuar cientos de partidas transcritas en una sola pasada desatendida. Open Sage juega ambos lados de muchas partidas; cada partida se exporta en un formato de texto estándar que XG puede importar; XG analiza el conjunto; y nosotros extraemos sus veredictos. Sobre esa base común aplicamos dos métodos distintos, descritos en la sección 3 y la sección 4.
Un tercer estudio (sección 5) deja de lado las simulaciones por completo y parte de matches reales de torneo analizados en XG. Su propósito es distinto: en lugar de preguntar qué motor es más fuerte, pregunta si un jugador que analiza un match en Sage obtiene el mismo Performance Rating que le daría XG, de modo que años de intuición sobre lo que significa un PR en XG se trasladen directamente a Sage.
Ambos motores pueden evaluar una posición a distintas profundidades, cambiando precisión por velocidad. Entender estos niveles es esencial para leer los resultados, porque la comparación se hace siempre entre niveles equiparados de los dos motores.
Evaluación directa (1-ply). La salida en bruto de la red neuronal para una posición, sin búsqueda hacia delante. Es el ajuste más rápido y la base sobre la que se construye cada nivel más profundo. (Seguimos la convención de XG, en la que 1-ply designa la evaluación en bruto de la red.)
Búsqueda multi-ply (2-, 3-, 4-ply). El motor mira varios turnos hacia delante, considerando las respuestas del oponente y promediando sobre las posibles tiradas en cada paso, con una evaluación en bruto de la red al final de cada línea. Cada ply adicional es más preciso y bastante más costoso.
Rollouts truncados (1T, 2T, 3T). En lugar de buscar hasta una profundidad fija, el motor juega muchas partidas simuladas cortas, las trunca tras unos pocos turnos y evalúa la posición resultante con búsqueda multi-ply. La reducción de varianza cancela buena parte de la suerte de los dados muestreados. Son los ajustes “Roller” de XG, y son más fuertes que la búsqueda a profundidad fija sin dejar de ser mucho más baratos que un rollout completo.
Rollout completo. Muchas partidas simuladas jugadas hasta el final. Ejecutado con suficiente volumen y reducción de varianza, un rollout completo es lo más parecido a la verdad que un motor de backgammon puede producir, y lo usamos como estándar de referencia a lo largo de todo este estudio.
| Familia | Sage | Equivalente en XG | Qué hace |
|---|---|---|---|
| Directa | 1-ply | 1-ply (evaluación en bruto) | Una única evaluación de la posición con la red neuronal, sin búsqueda hacia delante. |
| Multi-ply | 2P · 3P · 4P | 2-ply · 3-ply · 4-ply | Explora las respuestas del oponente varios turnos en profundidad, promediando sobre los dados. |
| Rollout truncado | 1T · 2T · 3T | Roller · Roller+ · Roller++ | Muchas partidas simuladas cortas, truncadas tras 5–7 turnos y evaluadas con multi-ply, con reducción de varianza. 3T/Roller++ usan decisiones a 3-ply; 2T/Roller+ a 2-ply; 1T/Roller a 1-ply. |
| Rollout completo | Rollout | Rollout | Partidas simuladas jugadas hasta el final: la “verdad” de referencia en este estudio. |
El primer método puntúa cada motor frente a un conjunto fijo de decisiones cuya “verdadera” mejor jugada hemos establecido con la mayor precisión posible. Sigue el mismo enfoque del conocido estudio de XG de 2012 que comparó XG con varios otros bots.
Empezamos simulando 500 partidas ilimitadas de Sage 3P jugando contra sí mismo. Un nivel moderadamente fuerte como 3P produce una distribución realista de posiciones en todos los planes de juego — carrera, ataque, bloqueo, anclaje — que es exactamente la variedad contra la que queremos probar. Después repetimos el estudio completo con 130 matches a cinco puntos, donde el marcador cambia el valor de cada decisión; los resultados de ambos aparecen más abajo.
Establecer la verdadera mejor jugada de cada decisión mediante rollout completo sería enormemente costoso — e innecesario, porque la mayoría de las decisiones no son ajustadas. Por eso construimos la referencia en tres pasadas escalonadas, gastando esfuerzo de rollout solo donde la elección está realmente en duda. La misma receta se aplica a los dos conjuntos de datos; cada pasada resuelve las decisiones que puede zanjar con confianza y pasa el resto a la siguiente:
Cada decisión se evalúa a 3-ply. Cuando la mejor jugada supera a la siguiente por más de 0,05 de equidad, el veredicto de 3P se acepta como verdad y la decisión queda resuelta.
Las decisiones restantes se reevalúan a 3T. Cuando el margen supera ahora 0,02 de equidad, el veredicto de 3T se acepta como verdad.
Todo lo que sigue dentro de 0,02 se resuelve con un rollout completo de Sage: decisiones a 3P tanto para el juego de fichas como para las acciones del cubo, ejecutado en lotes de 1296 caminos hasta que la banda de confianza del 95 % sobre la equidad baja de 0,005 — o se alcanza un tope de 20 736 caminos (16 × 1296). Las posiciones de backgame más lentas tardaron bastante más de una hora cada una.
El resultado es una referencia escalonada en la que cada decisión se resuelve exactamente a la profundidad que su dificultad exige. Aplicamos esta misma receta de tres pasadas a los dos conjuntos de datos — las 500 partidas ilimitadas y los 130 matches a cinco puntos — y la composición de niveles resultante se muestra junto a los resultados de cada conjunto más abajo.
Con un conjunto escalonado de evaluaciones fiables en la mano, puntuar cualquier motor es sencillo: le presentamos cada decisión del benchmark, registramos el error de equidad de la jugada o acción del cubo que elige respecto a la verdad, e informamos el error medio × 500 como PR. El mismo total se desglosa en PR de fichas y PR de cubo, y además por plan de juego.
Puntuar a XG exigió el paso adicional descrito en la introducción. Como XG no tiene API, ejecutamos su Batch Analysis sobre las transcripciones de las 500 partidas ilimitadas y los 130 matches con un nivel personalizado — decisiones a 3-ply, subiendo al nivel bajo prueba allí donde discrepaba — y extrajimos la decisión preferida de XG para cada posición de los archivos
.xg
que produce, puntuándolas frente a las mismas equidades de referencia.
En las 500 partidas ilimitadas, las tres pasadas resolvieron 16 889 posiciones (17 535 decisiones) así:
Los cinco niveles equiparados, puntuados sobre esas 17 535 decisiones. Cuanto más bajo el PR, mejor; en cada pareja se resalta el motor más fuerte.
PR de cada motor y nivel probado, desglosado por tipo de decisión y plan de juego. Cuanto más bajo, mejor.
| Motor | PR | Fichas | Cubo | Carrera pura | Carrera | Ataque | Bloqueo | Anclaje |
|---|---|---|---|---|---|---|---|---|
| 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 |
Todos los números anteriores califican a los motores frente a la referencia escalonada de Sage. La objeción obvia es que Sage juega en casa: se le está midiendo contra sus propios rollouts. Así que construimos el espejo exacto: las mismas 500 partidas y las mismas decisiones, pero con el propio análisis de XG como verdad en cada nivel. XG 3-ply resuelve las decisiones del nivel 3P, XG Roller++ las del nivel 3T y el rollout completo del propio XG las decisiones con rollout — el análogo nivel a nivel, en XG, de la referencia de Sage. Después se vuelve a puntuar cada motor frente a ella.
| Motor | PR | Fichas | Cubo | Carrera pura | Carrera | Ataque | Bloqueo | Anclaje |
|---|---|---|---|---|---|---|---|---|
| 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 |
El conjunto de matches ejecuta las mismas tres pasadas, con un añadido: el marcador away de cada jugador y la marca de Crawford se propagan por todas las evaluaciones, de modo que la verdad se calcula en el espacio de equidad de match (MWC) frente al marcador correcto. En los 130 matches a cinco puntos, las pasadas resolvieron 17 892 posiciones (18 292 decisiones) así:
Los cinco niveles equiparados, puntuados sobre esas 18 292 decisiones. Cuanto más bajo el PR, mejor; en cada pareja se resalta el motor más fuerte.
PR de cada motor y nivel probado en el conjunto de matches a 5 puntos, desglosado por tipo de decisión y plan de juego. Cuanto más bajo, mejor.
| Motor | PR | Fichas | Cubo | Carrera pura | Carrera | Ataque | Bloqueo | Anclaje |
|---|---|---|---|---|---|---|---|---|
| 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 |
Las partidas corrientes de juego contra sí mismo rara vez producen un backgame profundo, un juego de contención o un prime en la mitad lejana que retenga una sola ficha rezagada, así que los conjuntos de partidas ilimitadas y de matches dicen poco sobre cómo los juega un motor — y son las posiciones en las que los motores han sido históricamente más débiles. Trece benchmarks de familias de posiciones los miden directamente, cada uno construido como el benchmark de partidas ilimitadas — decisiones reales, cada una con una referencia de calidad rollout — pero con las decisiones extraídas del interior de la familia:
Cada familia parte de un pequeño conjunto de posiciones semilla. Sage juega partidas ilimitadas desde esas semillas contra sí mismo a 3-ply, se registra cada decisión que surge mientras la posición sigue perteneciendo a la familia, y cada decisión registrada se somete a rollout para producir su referencia — 5184 caminos jugados hasta el final, con decisiones de fichas y de cubo a 3-ply en los tres primeros medios movimientos y a 2-ply a partir de ahí, con reducción de varianza activada. Pasadas de completado de candidatas sometieron a rollout cada jugada que un motor bajo prueba eligió efectivamente, de modo que cada puntuación de abajo se calcula frente a una candidata de calidad rollout. Una posición de cubo en la que el oponente posee el cubo no es una decisión para el jugador en turno y no se puntúa.
| Benchmark | Decisiones | 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 |
| Contención | 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 masivo | 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 exportaciones (véase el Apéndice).
El método del PR de rollout puntúa a ambos motores frente a una referencia compartida. Una pregunta más aguda y directa es esta: en juego realista, ¿dónde discrepan realmente los dos motores sobre la mejor jugada — y, cuando lo hacen, cuál tiene razón?
La respondemos sobre las decisiones más difíciles de partidas ilimitadas del método uno — las posiciones con rollout, cada una de las cuales lleva ahora tanto un rollout completo de Sage como un rollout completo de XG. Entre ellas buscamos cada decisión en la que Sage 3T y XG Roller++ eligieron distinto, y preguntamos qué elección prefirió cada rollout. Tener ambos rollouts es la clave: cada discrepancia se juzga frente al rollout de Sage y al del propio XG, de modo que la respuesta nunca depende de confiar en la verdad de un solo motor.
En las posiciones de partidas ilimitadas con rollout — las decisiones más difíciles del estudio — los dos motores discrepan en 1286 jugadas de fichas y 80 decisiones de cubo. Cada panel muestra con qué frecuencia cada motor coincidió con la mejor decisión del rollout — puntuado frente al propio rollout de XG y frente al rollout de Sage, por turno.
Los dos primeros métodos preguntan qué motor es más fuerte. Una tercera pregunta es igual de importante para quien usa un motor para estudiar su propio juego: si analizas un match real en XG, anotas tu Performance Rating y luego analizas exactamente el mismo match en Sage, ¿cuánto se parecen los dos índices? Un jugador que ha pasado años construyendo una intuición de lo que significa un PR dado en XG debería obtener esencialmente el mismo número de Sage.
Para comprobarlo directamente, tomamos una gran colección de matches reales de torneo que ya habían sido analizados en XG, volvimos a analizar cada uno desde cero en Sage y comparamos el Performance Rating que cada motor asignó a cada jugador.
Los archivos de los matches proceden de tres torneos de 2026, todos matches a 7 puntos, cedidos generosamente por Máté Fehér — ya analizados en eXtreme Gammon, exactamente como un jugador de competición estudiaría sus propias partidas.
290 matches y 580 índices individuales de jugador en total. Un match más se dejó fuera por tratarse de una transcripción corrupta.
Agrupando los 580 índices de jugador, los dos motores coinciden casi exactamente. La diferencia media es estadísticamente indistinguible de cero, y la dispersión de esa diferencia es pequeña frente a la dispersión del propio PR.
| Performance Rating por jugador | XG | Sage | DiferenciaSage − XG |
|---|---|---|---|
| Media | 4.36 | 4.36 | +0.002 |
| Desviación estándar | 2.08 | 2.10 | 0.37 |
| Rango del 95 % | 1.52 – 9.36 | 1.44 – 9.67 | −0.76 – +0.74 |
En los estudios de fuerza, Open Sage 3T y XG Roller++ son dos de las evaluaciones de backgammon más fuertes disponibles, y están próximas entre sí. El estudio del PR frente a rollouts — realizado tanto para juego ilimitado como para partidos a 5 puntos — encuentra a Sage más fuerte en todos los niveles equivalentes salvo 3-ply, donde los dos motores están dentro del ruido, con la ventaja más clara en los niveles de rollout truncado. Si se reconstruye para las partidas ilimitadas con el propio análisis de XG como referencia, la clasificación se invierte: XG va por delante en todos los niveles equivalentes salvo 2T, donde los dos empatan. El estudio de posiciones en disputa, que toma las posiciones en las que los dos motores discrepan al nivel de evaluación más fuerte y las puntúa frente a los rollouts de ambos, queda igualado en juego de fichas — cada rollout favorece al motor que lo ejecutó — y los desacuerdos de cubo son demasiado escasos y repartidos para decidir.
El resumen honesto, entonces, es que los dos motores juegan a un nivel muy similar y muy alto, y que cada uno puntúa mejor frente a su propio análisis: con la referencia de Sage, sus rollouts truncados aciertan decisiones que los niveles Roller de XG fallan; con la de XG ocurre lo contrario; y en las posiciones donde los dos motores discrepan abiertamente, el rollout de ninguno deja al otro claramente por detrás. Es en los benchmarks de familia — backgames, partidas de contención y el snake — donde los dos motores se separan: medidos con el mismo criterio y en todos los niveles equivalentes, Sage va por delante en las trece, y por un factor de tres o más en las partidas de contención y el snake.
Y el tercer estudio responde a la pregunta que un usuario de Sage se plantea de verdad: en 290 matches reales de torneo ya calificados por XG, Sage produce esencialmente el mismo Performance Rating — la diferencia media entre el índice de Sage y el de XG para un jugador es estadísticamente indistinguible de cero, y la dispersión de esa diferencia es pequeña frente a la dispersión del propio PR. Ya sea la prueba la fuerza frente a una verdad obtenida por rollout o el simple acuerdo sobre cómo se jugó una partida real, Open Sage y XG llegan al mismo sitio.
Open Sage se publica como código abierto, y el pipeline completo detrás de ambos métodos se incluye en el repositorio del motor. Todo lo que sigue se ejecuta únicamente con el paquete
bgsage y una compilación local de su motor — no se requieren servicios externos, conjuntos de datos ni infraestructura. La única dependencia manual es el propio eXtreme Gammon, usado para regenerar las columnas de XG, ya que XG no tiene interfaz programática.
bgbot_cpp ) siguiendo las instrucciones del repositorio para tu plataforma. Reproducir cualquier columna de XG requiere además eXtreme Gammon (Windows) para su paso de Batch Analysis. Cada script resuelve sus rutas dentro del repositorio, así que ejecútalos desde la raíz de bgsage/ .
No hace falta que manejes el pipeline a mano. Claude Code — la herramienta agéntica de programación en línea de comandos de Anthropic — puede compilar el motor y ejecutar los benchmarks por ti. Apúntala a una copia del repositorio y describe lo que quieres; recorre los mismos pasos que se detallan a continuación:
data/money_benchmark/benchmark.json.gz e imprímela como una tabla que pueda comparar con el estudio.”./mybot — para cada decisión del benchmark incluido, evalúala con mi bot y calcula su PR frente a las equidades de referencia.”
El benchmark — el conjunto escalonado de evaluaciones fiables — se construye y se puntúa con un único script, scripts/benchmark_money.py. Hay dos formas de entrar.
El repositorio incluye el benchmark ensamblado como
data/money_benchmark/benchmark.json.gz (el JSON sin comprimir supera el límite de tamaño de archivo de GitHub; los scripts leen el gzip de forma transparente). Puntuar cualquier nivel de Sage reproduce su fila de la tabla de la sección 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
Para puntuar un motor completamente distinto, aplica la misma regla que el script usa internamente: para cada decisión del conjunto de datos, toma la elección de tu motor y compara su equidad con la equidad de referencia (“rollout”) almacenada — el error medio × 500 es su PR.
Tres pasadas adaptativas recrean el conjunto de datos. Las partidas llevan semilla (500 partidas desde la semilla 1), así que las decisiones y las equidades de referencia salen iguales:
# 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 pasada 3 escribe data/money_benchmark/benchmark.json
(y su .gz); puntúalo exactamente como en la opción A. Omitir --stages ejecuta las tres pasadas en orden.
XG no tiene API, así que sus resultados salen del Batch Analysis de XG. La pasada 1 escribe transcripciones importables en XG en data/money_benchmark/xg/ — no se incluyen, así que regenéralas con la pasada 1 si partiste solo del conjunto de datos.
xg/ con un nivel personalizado — decisiones a 3-ply, subiendo al nivel bajo prueba en las discrepancias — con Save Games after analyze marcado. XG escribe un
.xg por partida.
python scripts/benchmark_pr_xg_levels_all.py --benchmark money, que lee la decisión principal de XG por posición a cada nivel analizado de los archivos
.xg y la puntúa frente a las mismas equidades de referencia, imprimiendo el mismo desglose de PR y registrando junto a él las elecciones de XG.
La tabla de partidas ilimitadas con la referencia de XG de la Sección 3 — y el estudio de posiciones en disputa — necesitan en cambio los rollouts de XG de las posiciones más difíciles. Ejecuta el Batch Rollout de XG sobre esas posiciones (con Save Games marcado); python scripts/xg_benchmark_report.py los analiza. La tabla con la referencia de XG vuelve a puntuar después cada nivel a partir de las elecciones que registró cada script de puntuación. Véase el Método Dos más abajo.
# 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
El estudio de matches a 5 puntos se reproduce del mismo modo con
scripts/benchmark_match.py, el gemelo para matches de
benchmark_money.py — la longitud del match y el número de matches son argumentos, y el marcador del match se propaga por todas las evaluaciones. Su verdad de referencia se incluye como 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
El estudio de discrepancias parte del mismo benchmark de partidas ilimitadas construido para el método uno, cruzado con el rollout completo del propio XG de las posiciones más difíciles. La única dependencia manual es el Batch Rollout de XG; un único script hace el resto.
data/money_benchmark/xg/.
.xg correspondientes.
python scripts/xg_benchmark_report.py python scripts/xg_dispute_analysis.py --sage-picks data/money_benchmark/scores/sage_truncated3.picks.jsonl
El primero convierte los rollouts de XG en
data/money_benchmark/xg_results/rollout.jsonl; el segundo imprime el informe de posiciones en disputa — cada discrepancia puntuada frente a los rollouts de Sage y XG por turno — a partir de las elecciones registradas de Sage 3T.
La modalidad match aún no está cubierta por este método: requiere un rollout completo de XG de las posiciones de los matches, que no hemos ejecutado. La fuerza en matches queda cubierta, en cambio, por el estudio de PR de rollout (sección 3) y el estudio de acuerdo en matches reales (sección 5).
Sage y XG también pueden jugar directamente entre sí, tomando las jugadas de XG de su propio análisis. Sage juega ambos lados de una partida ilimitada; la transcripción se analiza por lotes en XG; la primera decisión del oponente que difiere de la mejor opción de XG se sustituye por la jugada de XG y la partida se repite desde ahí con dados nuevos, hasta que cada jugada del oponente es la que XG habría hecho. El ejecutor juega una serie de esas partidas (las semillas continúan desde logs/sage_vs_xg.txt) e imprime los puntos medios por partida con su error estándar:
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 debe estar en ejecución en el escritorio de Windows: cada iteración controla su cuadro de diálogo Batch Analyze mediante scripts/xg_batch_analyze.py, un agente Anthropic Computer Use (define ANTHROPIC_API_KEY), que toma el control del ratón y el teclado durante aproximadamente un minuto por iteración. Una partida converge en unas pocas iteraciones; el veredicto "too good to double" de XG cuenta como no doblar.
Los trece benchmarks de familias viven bajo
backgame_ref_positions/benchmark/ — un archivo
<family> starting.txt de posiciones semilla y un
<family> rollout.jsonl de referencia cada uno — y los puntúa
scripts/score_backgame_pr.py, que informa del PR junto con la proporción de elecciones de calidad 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 correspondientes.