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) a niveles de evaluación equiparados: evaluación directa de la red neuronal, búsqueda multi-ply y rollouts truncados. Como XG no expone ninguna interfaz programática, lo puntuamos a través de su función de análisis por lotes (Batch Analysis). Empleamos tres métodos complementarios. El primero construye un conjunto escalonado de evaluaciones de referencia — confiando en las evaluaciones rápidas cuando la elección es clara y escalando las decisiones ajustadas hasta rollouts completos — y puntúa cada motor como un Performance Rating (PR, índice de rendimiento) frente a esa referencia, tanto en 500 partidas ilimitadas (17 535 decisiones) como en 130 matches 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 — y el rollout truncado de Sage sigue por delante incluso juzgado con los números del propio XG. El segundo método aísla las posiciones de partidas ilimitadas en las que Sage 3T y XG Roller++ discrepan de verdad y adjudica cada una frente a los rollouts completos de ambos motores. En los dos métodos los motores quedan muy cerca, con Sage modestamente por delante en los niveles de rollout truncado equiparados que la mayoría de los usuarios utiliza. El tercer método invierte la pregunta: sobre 290 matches reales de torneo ya analizados en XG, volvemos a analizar cada uno en Sage y comparamos el Performance Rating que los dos motores asignan a cada jugador — y la diferencia media resulta 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 dos motores jueguen muchos miles 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.
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 back game 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.21 | 0.18 | 0.36 | 0.02 | 0.24 | 0.17 | 0.31 | 0.28 |
| XG Roller++ | 0.32 | 0.31 | 0.38 | 0.04 | 0.40 | 0.24 | 0.41 | 0.44 |
| Sage 2T | 0.26 | 0.23 | 0.44 | 0.02 | 0.32 | 0.21 | 0.39 | 0.30 |
| XG Roller+ | 0.41 | 0.41 | 0.39 | 0.05 | 0.59 | 0.31 | 0.47 | 0.54 |
| Sage 1T | 0.50 | 0.52 | 0.40 | 0.04 | 0.57 | 0.43 | 0.59 | 0.73 |
| XG Roller | 0.53 | 0.54 | 0.48 | 0.05 | 0.63 | 0.44 | 0.71 | 0.66 |
| Sage 4P | 0.41 | 0.39 | 0.50 | 0.07 | 0.51 | 0.37 | 0.45 | 0.53 |
| XG 4-ply | 0.46 | 0.45 | 0.52 | 0.06 | 0.58 | 0.40 | 0.57 | 0.58 |
| Sage 3P | 0.58 | 0.58 | 0.57 | 0.14 | 0.72 | 0.52 | 0.63 | 0.74 |
| XG 3-ply | 0.57 | 0.57 | 0.58 | 0.05 | 0.71 | 0.48 | 0.73 | 0.71 |
| Sage 2P | 1.64 | 1.39 | 2.88 | 0.40 | 1.77 | 1.83 | 1.86 | 1.71 |
| Sage 1P | 2.59 | 2.48 | 3.20 | 0.78 | 2.60 | 2.79 | 3.10 | 2.89 |
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.26 | 0.25 | 0.33 | 0.02 | 0.37 | 0.20 | 0.30 | 0.36 |
| XG Roller++ | 0.33 | 0.35 | 0.23 | 0.04 | 0.50 | 0.20 | 0.39 | 0.47 |
| Sage 2T | 0.31 | 0.30 | 0.35 | 0.02 | 0.41 | 0.27 | 0.36 | 0.37 |
| XG Roller+ | 0.38 | 0.40 | 0.23 | 0.04 | 0.58 | 0.26 | 0.39 | 0.54 |
| Sage 1T | 0.46 | 0.48 | 0.37 | 0.03 | 0.58 | 0.40 | 0.50 | 0.64 |
| XG Roller | 0.47 | 0.49 | 0.35 | 0.12 | 0.61 | 0.35 | 0.54 | 0.62 |
| Sage 4P | 0.37 | 0.36 | 0.42 | 0.06 | 0.53 | 0.34 | 0.40 | 0.39 |
| XG 4-ply | 0.45 | 0.46 | 0.40 | 0.13 | 0.60 | 0.36 | 0.48 | 0.59 |
| Sage 3P | 0.49 | 0.48 | 0.52 | 0.08 | 0.66 | 0.46 | 0.54 | 0.55 |
| XG 3-ply | 0.47 | 0.49 | 0.40 | 0.12 | 0.63 | 0.37 | 0.54 | 0.61 |
| Sage 2P | 1.35 | 1.14 | 2.40 | 0.31 | 1.50 | 1.48 | 1.52 | 1.41 |
| Sage 1P | 2.24 | 2.14 | 2.76 | 0.74 | 2.21 | 2.44 | 2.69 | 2.39 |
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.19 | 0.16 | 0.40 | 0.01 | 0.17 | 0.18 | 0.25 | 0.26 |
| XG Roller++ | 0.35 | 0.35 | 0.41 | 0.08 | 0.44 | 0.32 | 0.33 | 0.45 |
| Sage 2T | 0.26 | 0.24 | 0.44 | 0.02 | 0.36 | 0.18 | 0.34 | 0.33 |
| XG Roller+ | 0.44 | 0.44 | 0.41 | 0.09 | 0.55 | 0.44 | 0.40 | 0.52 |
| Sage 1T | 0.49 | 0.49 | 0.52 | 0.05 | 0.57 | 0.44 | 0.57 | 0.63 |
| XG Roller | 0.51 | 0.51 | 0.54 | 0.09 | 0.64 | 0.50 | 0.51 | 0.62 |
| Sage 4P | 0.42 | 0.42 | 0.48 | 0.05 | 0.52 | 0.38 | 0.45 | 0.55 |
| XG 4-ply | 0.46 | 0.45 | 0.56 | 0.09 | 0.60 | 0.44 | 0.42 | 0.56 |
| Sage 3P | 0.57 | 0.56 | 0.67 | 0.05 | 0.74 | 0.56 | 0.58 | 0.68 |
| XG 3-ply | 0.54 | 0.53 | 0.61 | 0.09 | 0.69 | 0.53 | 0.52 | 0.65 |
| Sage 2P | 1.30 | 1.26 | 1.60 | 0.39 | 1.59 | 1.23 | 1.50 | 1.41 |
| Sage 1P | 2.30 | 2.29 | 2.31 | 0.69 | 2.48 | 2.43 | 2.47 | 2.56 |
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 1488 jugadas de fichas y 69 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 dos estudios de fuerza, Open Sage 3T y XG Roller++ son aproximadamente comparables — dos de las evaluaciones de backgammon más fuertes que existen, y muy cercanas entre sí. El estudio de PR de rollout — realizado tanto en modalidad ilimitada como en matches a 5 puntos — encuentra a Sage más fuerte en todos los niveles equiparados salvo 3-ply, donde los dos motores están dentro del ruido el uno del otro; y en las partidas ilimitadas se sostiene incluso cuando la referencia se cambia por el propio análisis escalonado de XG. El estudio de posiciones en disputa, que examina las posiciones en las que los dos motores discrepan al nivel de evaluación más fuerte (Sage 3T y XG Roller++) y las puntúa frente a los rollouts de ambos motores, encuentra a Sage 3T como el motor más cercano en las discrepancias de fichas frente a cualquiera de los dos rollouts, mientras que las discrepancias de cubo son demasiado raras y están demasiado repartidas para decidir.
Hay, por tanto, cierta evidencia de que Sage 3T es ligeramente más fuerte que XG Roller++. La objeción más natural — que la ventaja es un artefacto de calificar a Sage frente a sus propios rollouts — queda respondida allí donde podemos comprobarlo: puntuados frente a la propia referencia de XG, los niveles truncados de Sage siguen por delante. Las diferencias son, en cualquier caso, pequeñas, y el resumen honesto es que los dos motores juegan a un nivel muy similar y muy alto — que es precisamente el listón que nos propusimos alcanzar.
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.py, que lee la decisión principal de XG por posición de los archivos .xg y la puntúa frente a las mismas equidades de referencia, imprimiendo el mismo desglose de PR.
La tabla de partidas ilimitadas con referencia 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) y después python scripts/xg_benchmark_report.py los analiza e imprime tanto la tabla de niveles con referencia XG como el informe de posiciones en disputa. Ver el método dos más abajo.
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/, then python scripts/benchmark_pr_xg_match.py --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
Convierte los rollouts de XG en
data/money_benchmark/xg_results/rollout.jsonl, luego imprime tanto el PR por nivel de evaluación frente al rollout de XG (la segunda referencia de la sección 3) como el informe de posiciones en disputa — cada discrepancia puntuada frente a los rollouts de Sage y XG por turno.
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).
.xg correspondientes.