Ein quantitativer Vergleich der Analyse-Engine Open Sage — die Backgammon Sage Pro antreibt — mit der Bot-Engine von eXtreme Gammon (XG).
Wir vergleichen die Open-Sage-Engine mit eXtreme Gammon (XG) auf vergleichbaren Auswertungsstufen — direkte Auswertung des neuronalen Netzes, Multi-Ply-Suche und abgeschnittene Rollouts. Da XG keine programmatische Schnittstelle bietet, bewerten wir es über seine Funktion Batch Analysis. Wir verwenden drei einander ergänzende Methoden. Die erste erstellt einen geschichteten Satz von Referenzauswertungen — schnellen Auswertungen wird vertraut, wo die Wahl eindeutig ist, knappe Fälle werden zu vollständigen Rollouts eskaliert — und bewertet jede Engine mit einem Performance Rating (PR) gegen diese Referenz, über 500 unbegrenzte Partien (17.535 Entscheidungen) und 130 Fünf-Punkte-Matches (18.292 Entscheidungen). Die zweite isoliert die unbegrenzten Positionen, bei denen Sage 3T und XG Roller++ tatsächlich uneins sind, und beurteilt jede anhand der vollständigen Rollouts beider Engines. Dieselbe Referenz- und Bewertungsmethode wird auf dreizehn Benchmarks für Backgames, Containment-Partien und den Snake angewandt — die Positionen, die Engines historisch am schlechtesten gespielt haben. In den Stärkestudien liegen die beiden Engines nahe beieinander, wobei Sage auf den Stufen der abgeschnittenen Rollouts vorn liegt, auf die sich die meisten Nutzer stützen. Die dritte Methode dreht die Frage um: Bei 290 echten Turniermatches, die bereits in XG analysiert wurden, analysieren wir jedes erneut in Sage und vergleichen das Performance Rating, das die beiden Engines jedem Spieler zuweisen.
eXtreme Gammon (XG) ist eine Standardreferenz für computergestützte Backgammon-Analyse, und seine Analyse-Engine gilt weithin als eine der stärksten verfügbaren. Jede neue Engine, die ernst genommen werden will, muss eine einfache Frage beantworten: Wie schneidet sie gegen XG ab? Diese Studie beantwortet das quantitativ für Open Sage, die neuronale Netz-Engine hinter Backgammon Sage Pro.
Unser Ziel war es, die Bewertungen von Open Sage mit denen von XG bei vergleichbarem Aufwand zu vergleichen. Das naheliegende Experiment — beide Engines viele Tausend Partien gegeneinander spielen zu lassen und das Ergebnis auszuzählen — ist nicht praktikabel: Die XG-Desktop-App bietet keine programmatische Schnittstelle, sodass das Übergeben von Positionen und Zügen zwischen den Engines ein manueller Klickvorgang ist. Eine Stichprobe zu erreichen, die groß genug ist, um die kleinen Unterschiede zwischen zwei starken Engines aufzulösen, würde viel zu lange dauern.
Stattdessen nutzen wir XGs Stapelanalyse, die Hunderte transkribierter Partien in einem einzigen unbeaufsichtigten Durchgang bewerten kann. Open Sage spielt beide Seiten vieler Partien; jede Partie wird in einem Standard-Textformat exportiert, das XG importieren kann; XG analysiert das Ganze; und wir lesen seine Urteile wieder aus. Auf dieser gemeinsamen Grundlage wenden wir zwei verschiedene Methoden an, beschrieben in Abschnitt 3 und Abschnitt 4. Eine dritte Studie (Abschnitt 5) legt die Simulationen ganz beiseite und arbeitet mit echten Turniermatches, die in XG analysiert wurden.
Beide Engines können eine Position in verschiedenen Tiefen auswerten und tauschen dabei Genauigkeit gegen Geschwindigkeit. Diese Stufen zu verstehen ist entscheidend, um die Ergebnisse zu lesen, denn der Vergleich findet immer zwischen einander entsprechenden Stufen der beiden Engines statt.
Direkte Auswertung (1-Ply). Die rohe Ausgabe des neuronalen Netzes für eine Position, ohne Vorausschau. Das ist die schnellste Einstellung und die Grundlage, auf der jede tiefere Stufe aufbaut. (Wir folgen der Konvention von XG, in der 1-Ply die rohe Netzauswertung bezeichnet.)
Mehr-Ply-Vorausschau (2, 3, 4 Ply). Die Engine schaut mehrere Züge in die Zukunft, berücksichtigt die Antworten des Gegners und mittelt bei jedem Schritt über die möglichen Würfe, mit einer rohen Netzauswertung am Ende jeder Linie. Jedes zusätzliche Ply ist genauer und deutlich aufwendiger.
Verkürzte Rollouts (1T, 2T, 3T). Statt bis zu einer festen Tiefe zu suchen, spielt die Engine viele kurze simulierte Partien, bricht sie nach einigen Zügen ab und bewertet die entstandene Position mit Mehr-Ply-Vorausschau. Varianzreduktion hebt einen Großteil des Zufalls in den gezogenen Würfeln auf. Das sind XGs „Roller“-Einstellungen; sie sind stärker als eine Suche mit fester Tiefe und bleiben dabei weit günstiger als ein vollständiger Rollout.
Vollständiger Rollout. Viele simulierte Partien, die bis zum Ende gespielt werden. In ausreichendem Umfang und mit Varianzreduktion ausgeführt, ist ein vollständiger Rollout das, was einer Referenzwahrheit am nächsten kommt, die eine Backgammon-Engine erzeugen kann; wir verwenden ihn in dieser Studie durchgehend als Maßstab.
| Familie | Sage | XG-Entsprechung | Was sie tut |
|---|---|---|---|
| Direkt | 1-Ply | 1-Ply (rohe Auswertung) | Eine einzelne Auswertung der Position durch das neuronale Netz — keine Vorausschau. |
| Mehr-Ply | 2P · 3P · 4P | 2-Ply · 3-Ply · 4-Ply | Durchsucht die Antworten des Gegners mehrere Züge tief und mittelt über die Würfel. |
| Verkürzter Rollout | 1T · 2T · 3T | Roller · Roller+ · Roller++ | Viele kurze simulierte Partien, nach 5–7 Zügen abgebrochen und mit Mehr-Ply ausgewertet, mit Varianzreduktion. 3T/Roller++ nutzen 3-Ply-Entscheidungen; 2T/Roller+ 2-Ply; 1T/Roller 1-Ply. |
| Vollständiger Rollout | Rollout | Rollout | Bis zum Ende gespielte simulierte Partien — die Referenz-„Wahrheit“ in dieser Studie. |
Die erste Methode bewertet jede Engine an einer festen Menge von Entscheidungen, deren „wahren“ besten Zug wir so genau wie möglich bestimmt haben. Sie folgt demselben Ansatz wie die bekannte XG-Studie von 2012, die XG mit einer Reihe anderer Bots verglich.
Wir haben zunächst 500 unbegrenzte Partien simuliert, in denen Sage 3P gegen sich selbst spielt. Eine mittelstarke Stufe wie 3P erzeugt eine realistische Verteilung von Positionen über alle Spielpläne hinweg — Rennen, Angriff, Prime, Anker —, also genau die Vielfalt, gegen die wir testen wollen. Anschließend haben wir die gesamte Studie ein zweites Mal für 130 Fünf-Punkte-Matches ausgeführt, in denen der Punktestand auf dem Brett den Wert jeder Entscheidung verändert; die Ergebnisse für beide erscheinen unten.
Den wahren besten Zug für jede Entscheidung per vollständigem Rollout zu bestimmen wäre enorm aufwendig — und unnötig, denn die meisten Entscheidungen sind nicht knapp. Wir bauen die Referenz daher in drei aufsteigenden Durchgängen auf und investieren Rollout-Aufwand nur dort, wo die Wahl wirklich zweifelhaft ist. Dasselbe Rezept wird auf beide Datensätze angewendet; jeder Durchgang klärt die Entscheidungen, die er sicher entscheiden kann, und reicht die übrigen weiter:
Jede Entscheidung wird auf 3-Ply ausgewertet. Wo der beste Zug den zweitbesten um mehr als 0.05 Equity schlägt, wird das 3P-Urteil als Wahrheit akzeptiert und die Entscheidung ist geklärt.
Die verbleibenden Entscheidungen werden auf 3T neu ausgewertet. Wo der Abstand nun größer als 0.02 Equity ist, wird das 3T-Urteil als Wahrheit akzeptiert.
Alles, was noch innerhalb von 0.02 liegt, wird durch einen vollständigen Sage-Rollout geklärt: 3P-Entscheidungen für Zugspiel wie Cube-Aktionen, ausgeführt in Stapeln von 1.296 Pfaden, bis das 95-%-Konfidenzband der Equity unter 0.005 fällt — oder eine Obergrenze von 20.736 Pfaden (16 × 1.296) erreicht ist. Die langsamsten Backgame-Positionen brauchten jeweils weit über eine Stunde.
Das Ergebnis ist eine geschichtete Referenz, in der jede Entscheidung genau in der Tiefe geklärt ist, die ihre Schwierigkeit verlangt. Wir haben dieses Drei-Durchgang-Rezept über beide Datensätze laufen lassen — die 500 unbegrenzten Partien und die 130 Fünf-Punkte-Matches — und die daraus entstandene Zusammensetzung der Stufen wird unten neben den Ergebnissen des jeweiligen Satzes gezeigt.
Mit einer geschichteten Menge vertrauenswürdiger Bewertungen in der Hand ist es einfach, eine Engine zu bewerten: Wir legen ihr jede Benchmark-Entscheidung vor, halten den Equity-Fehler des von ihr gewählten Zuges oder der gewählten Cube-Aktion gegenüber der Wahrheit fest und geben den mittleren Fehler × 500 als PR an. Dieselbe Summe wird in Zug- und Cube-PR aufgeschlüsselt und weiter nach Spielplan.
XG zu bewerten erforderte den in der Einleitung beschriebenen zusätzlichen Schritt. Da XG keine API hat, haben wir seine Stapelanalyse über die 500 Transkripte der unbegrenzten Partien und die 130 Match-Transkripte laufen lassen — mit einer eigenen Stufe: 3-Ply-Entscheidungen, hochgestuft auf die geprüfte Stufe überall dort, wo Uneinigkeit bestand — und XGs bevorzugte Entscheidung für jede Position aus den
.xg
Dateien ausgelesen, die es erzeugt, um sie an denselben Referenz-Equities zu messen.
Über die 500 unbegrenzten Partien hinweg klärten die drei Durchgänge 16.889 Positionen (17.535 Entscheidungen) wie folgt:
Die fünf einander entsprechenden Stufen, bewertet über diese 17.535 Entscheidungen. Ein niedrigerer PR ist besser; die stärkere Engine jedes Paares ist hervorgehoben.
Der PR für jede getestete Engine und Stufe, aufgeschlüsselt nach Entscheidungsart und Spielplan. Niedriger ist besser.
| Engine | PR | Zug | Cube | Reines Rennen | Rennen | Angriff | Prime | Anker |
|---|---|---|---|---|---|---|---|---|
| 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 |
Der Match-Datensatz durchläuft dieselben drei Durchgänge, mit einer Ergänzung: Der Away-Stand jedes Spielers und die Crawford-Kennzeichnung werden durch jede Auswertung geführt, sodass die Wahrheit im Match-Equity-Raum (MWC) gegen den richtigen Punktestand berechnet wird. Über die 130 Fünf-Punkte-Matches hinweg klärten die Durchgänge 17.892 Positionen (18.292 Entscheidungen) wie folgt:
Die fünf einander entsprechenden Stufen, bewertet über diese 18.292 Entscheidungen. Ein niedrigerer PR ist besser; die stärkere Engine jedes Paares ist hervorgehoben.
Der PR für jede getestete Engine und Stufe im Datensatz der 5-Punkte-Matches, aufgeschlüsselt nach Entscheidungsart und Spielplan. Niedriger ist besser.
| Engine | PR | Zug | Cube | Reines Rennen | Rennen | Angriff | Prime | Anker |
|---|---|---|---|---|---|---|---|---|
| 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 |
Gewöhnliche Selbstspiel-Partien bringen selten ein tiefes Backgame, ein Containment-Spiel oder einen Prime auf der gegnerischen Bretthälfte hervor, der einen einzelnen Nachzügler festhält; die Datensätze der unbegrenzten Partien und der Matches sagen daher wenig darüber, wie eine Engine sie spielt — und es sind die Positionen, in denen Engines seit jeher am schwächsten waren. Dreizehn Benchmarks über Positionsfamilien messen sie direkt, jeder gebaut wie der Benchmark der unbegrenzten Partien — echte Entscheidungen, jede mit einer Referenz in Rollout-Qualität —, aber mit Entscheidungen, die aus dem Inneren der Familie stammen:
Jede Familie geht von einer kleinen Menge von Ausgangspositionen aus. Sage spielt aus diesen Ausgangspositionen unbegrenzte Partien gegen sich selbst auf 3-Ply, jede Entscheidung, die entsteht, solange die Position noch zur Familie gehört, wird aufgezeichnet, und jede aufgezeichnete Entscheidung wird ausgerollt, um ihre Referenz zu erzeugen — 5.184 bis zum Ende gespielte Pfade, mit 3-Ply-Zug- und Cube-Entscheidungen in den ersten drei Halbzügen und 2-Ply danach, Varianzreduktion eingeschaltet. Durchgänge zur Kandidatenvervollständigung haben jeden Zug ausgerollt, den eine getestete Engine tatsächlich gewählt hat, sodass jede Bewertung unten gegen einen Kandidaten in Rollout-Qualität erfolgt. Eine Cube-Position, in der der Gegner den Cube besitzt, ist für den Spieler am Zug keine Entscheidung und wird nicht bewertet.
| Benchmark | Entscheidungen | 2-ply | 3-ply | 4-ply | 1T / Roller | 2T / Roller+ | 3T / Roller++ | ||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Sage | XG | Sage | XG | Sage | XG | Sage | XG | Sage | XG | Sage | XG | ||
| 2-1-Backgame | 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 |
| 3-1-Backgame | 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 |
| 3-2-Backgame | 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 |
| 4-1-Backgame | 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 |
| 4-2-Backgame | 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 |
| 5-1-Backgame | 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 |
| 5-2-Backgame | 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 |
| 4-3-Backgame | 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 |
| 5-3-Backgame | 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 |
| 5-4-Backgame | 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 |
| Containment | 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 |
| Massives Backgame | 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 Exporte (siehe Anhang).
Die Rollout-PR-Methode bewertet beide Engines an einer gemeinsamen Referenz. Eine schärfere, direktere Frage ist diese: Wo sind sich die beiden Engines im realistischen Spiel tatsächlich uneins über den besten Zug — und wer hat dann recht?
Wir beantworten sie anhand der schwierigsten unbegrenzten Entscheidungen aus Methode eins — der ausgerollten Positionen, von denen jede nun sowohl einen vollständigen Sage-Rollout als auch einen vollständigen XG-Rollout trägt. Darunter suchen wir jede Entscheidung, in der Sage 3T und XG Roller++ unterschiedlich gewählt haben, und fragen, welche Wahl der jeweilige Rollout bevorzugte. Beide Rollouts zu haben ist der ganze Punkt: Jede Uneinigkeit wird an Sages Rollout und an XGs eigenem gemessen, sodass die Antwort nie darauf beruht, der Wahrheit einer einzelnen Engine zu vertrauen.
Über die ausgerollten Positionen der unbegrenzten Partien hinweg — die schwierigsten Entscheidungen der Studie — sind sich die beiden Engines bei 1.286 Zügen und 80 Cube-Entscheidungen uneins. Jedes Feld zeigt, wie oft jede Engine mit der besten Entscheidung des Rollouts übereinstimmte — bewertet an XGs eigenem Rollout und der Reihe nach an Sages Rollout.
Die ersten beiden Methoden fragen, welche Engine stärker ist. Eine dritte Frage ist für alle, die eine Engine zum Studium des eigenen Spiels nutzen, genauso wichtig: Wenn du ein echtes Match in XG analysierst, dir dein Performance Rating notierst und dann genau dasselbe Match in Sage analysierst — wie nah liegen die beiden Bewertungen beieinander? Wer jahrelang ein Gefühl dafür entwickelt hat, was ein bestimmter PR in XG bedeutet, sollte von Sage im Wesentlichen dieselbe Zahl bekommen.
Um das direkt zu prüfen, haben wir eine große Sammlung echter Turniermatches genommen, die bereits in XG analysiert waren, jedes davon von Grund auf in Sage neu analysiert und das Performance Rating verglichen, das jede Engine jedem Spieler zuwies.
Die Match-Dateien stammen aus drei Turnieren des Jahres 2026, allesamt 7-Punkte-Matches, freundlicherweise bereitgestellt von Máté Fehér — bereits in eXtreme Gammon analysiert, genau so, wie ein Wettkampfspieler seine eigenen Partien studieren würde.
Insgesamt 290 Matches und 580 einzelne Spielerbewertungen. Ein weiteres Match wurde als fehlerhafte Transkription aussortiert.
Über alle 580 Spielerbewertungen hinweg stimmen die beiden Engines fast genau überein. Der mittlere Unterschied ist statistisch nicht von null unterscheidbar, und die Streuung dieses Unterschieds ist klein gegenüber der Streuung des PR selbst.
| Performance Rating je Spieler | XG | Sage | UnterschiedSage − XG |
|---|---|---|---|
| Durchschnitt | 4.36 | 4.36 | +0.002 |
| Standardabweichung | 2.08 | 2.10 | 0.37 |
| 95-%-Bereich | 1.52 – 9.36 | 1.44 – 9.67 | −0.76 – +0.74 |
In den Stärkestudien gehören Open Sage 3T und XG Roller++ zu den stärksten verfügbaren Backgammon-Auswertungen und liegen nahe beieinander. Die Rollout-PR-Studie — durchgeführt für unbegrenztes Spiel wie für 5-Punkte-Matches — findet Sage auf jeder vergleichbaren Stufe stärker, außer bei 3-ply, wo die beiden Engines im Rauschen liegen, mit dem deutlichsten Vorsprung auf den Stufen der abgeschnittenen Rollouts. Die Studie der strittigen Positionen, die jene Positionen betrachtet, bei denen die beiden Engines auf der stärksten Auswertungsstufe uneins sind, und sie gegen die Rollouts beider bewertet, endet beim Steinespiel unentschieden — jeder Rollout begünstigt die Engine, die ihn erzeugt hat —, während die Doppler-Meinungsverschiedenheiten zu selten und zu geteilt für ein Urteil sind.
Die ehrliche Zusammenfassung lautet also, dass die beiden Engines auf sehr ähnlichem, sehr hohem Niveau spielen. Sages Vorteil stammt aus den Entscheidungen, die seine abgeschnittenen Rollouts richtig treffen und XGs Roller-Stufen nicht; auf den Positionen, bei denen die beiden Engines offen uneins sind, setzt keiner der beiden Rollouts den anderen klar zurück. Bei den Familien-Benchmarks — Backgames, Containment-Partien und dem Snake — trennen sich die beiden: mit demselben Maßstab und auf jeder vergleichbaren Stufe führt Sage in allen dreizehn, und um einen Faktor von drei oder mehr bei Containment-Partien und dem Snake.
Und die dritte Studie beantwortet die Frage, vor der ein Sage-Nutzer tatsächlich steht: Über 290 echte Turniermatches hinweg, die XG bereits bewertet hatte, erzeugt Sage im Wesentlichen dasselbe Performance Rating — der mittlere Unterschied zwischen der Sage- und der XG-Bewertung eines Spielers ist statistisch nicht von null unterscheidbar, und die Streuung dieses Unterschieds ist klein gegenüber der Streuung des PR selbst. Ob die Prüfung nun die Stärke gegen eine ausgerollte Wahrheit ist oder die schlichte Übereinstimmung darüber, wie eine echte Partie gespielt wurde: Open Sage und XG landen am selben Ort.
Open Sage ist als Open Source veröffentlicht, und die vollständige Pipeline hinter beiden Methoden liegt im Repository der Engine bei. Alles Folgende läuft allein gegen das
bgsage Paket und einen lokalen Build seiner Engine — externe Dienste, Datensätze oder Infrastruktur sind nicht erforderlich. Die einzige manuelle Abhängigkeit ist eXtreme Gammon selbst, mit dem die XG-Spalten neu erzeugt werden, da XG keine programmatische Schnittstelle hat.
bgbot_cpp Erweiterung) nach den Anweisungen des Repositorys für deine Plattform. Um eine XG-Spalte nachzuvollziehen, wird zusätzlich eXtreme Gammon (Windows) für dessen Stapelanalyse-Schritt benötigt. Jedes Skript löst seine Pfade innerhalb des Repositorys auf, führe sie also aus dem bgsage/ Wurzelverzeichnis aus.
Du musst die Pipeline nicht von Hand steuern. Claude Code — Anthropics agentisches Kommandozeilen-Werkzeug zum Programmieren — kann die Engine bauen und die Benchmarks für dich ausführen. Richte es auf einen Checkout des Repositorys und beschreibe, was du willst; es arbeitet dieselben Schritte ab, die unten im Detail stehen:
data/money_benchmark/benchmark.json.gz und gib sie als Tabelle aus, die ich mit der Studie vergleichen kann.“./mybot — werte für jede Entscheidung im mitgelieferten Benchmark diese mit meinem Bot aus und berechne seinen PR gegenüber den Referenz-Equities.“
Der Benchmark — die geschichtete Menge vertrauenswürdiger Bewertungen — wird von einem einzigen Skript erzeugt und ausgewertet, scripts/benchmark_money.py. Es gibt zwei Wege hinein.
Das Repository liefert den fertigen Benchmark als
data/money_benchmark/benchmark.json.gz (das unkomprimierte JSON überschreitet GitHubs Dateigrößenlimit; die Skripte lesen das gzip transparent). Eine beliebige Sage-Stufe zu bewerten reproduziert ihre Zeile in der Tabelle aus Abschnitt 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
Um eine ganz andere Engine zu bewerten, wende dieselbe Regel an, die das Skript intern nutzt: Nimm für jede Entscheidung im Datensatz die Wahl deiner Engine und vergleiche deren Equity mit der hinterlegten Referenz-Equity („Rollout“) — der mittlere Fehler × 500 ist ihr PR.
Drei adaptive Durchgänge erzeugen den Datensatz neu. Die Partien sind mit einem Startwert versehen (500 Partien aus Startwert 1), sodass Entscheidungen und Referenz-Equities gleich ausfallen:
# 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
Durchgang 3 schreibt data/money_benchmark/benchmark.json
(und dessen .gz); bewerte es genau wie in Möglichkeit A. Lässt man --stages weg, laufen alle drei Durchgänge der Reihe nach.
XG hat keine API, seine Ergebnisse stammen daher aus XGs Stapelanalyse. Durchgang 1 schreibt XG-Importtranskripte nach data/money_benchmark/xg/ — diese werden nicht mitgeliefert, erzeuge sie also mit Durchgang 1 neu, wenn du allein vom Datensatz ausgegangen bist.
xg/ per Stapelanalyse mit einer eigenen Stufe — 3-Ply-Entscheidungen, bei Uneinigkeit hochgestuft auf die geprüfte Stufe — und aktiviertem Save Games after analyze. XG schreibt eine
.xg je Partie.
python scripts/benchmark_pr_xg_levels_all.py --benchmark moneyaus; es liest XGs oberste Entscheidung je Position auf jeder analysierten Stufe aus den
.xg Dateien und misst sie an denselben Referenz-Equities, wobei es dieselbe PR-Aufschlüsselung ausgibt und XGs Wahl daneben festhält.
Die Studie der strittigen Positionen benötigt stattdessen XGs Rollouts der schwierigsten Positionen. Führe XGs Batch Rollout auf diesen Positionen aus (Save Games aktiviert); python scripts/xg_benchmark_report.py wertet sie aus. Siehe Methode Zwei unten.
Die Studie zu den 5-Punkte-Matches wird auf demselben Weg nachvollzogen, mit
scripts/benchmark_match.py, dem Match-Spiel-Zwilling von
benchmark_money.py — Matchlänge und Anzahl der Matches sind Argumente, und der Match-Stand wird durch jede Auswertung geführt. Seine Referenzwahrheit wird mitgeliefert als 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
Die Uneinigkeitsstudie schöpft aus demselben Benchmark unbegrenzter Partien, der für Methode eins gebaut wurde, abgeglichen mit XGs eigenem vollständigem Rollout der schwierigsten Positionen. Die einzige manuelle Abhängigkeit ist XGs Batch Rollout; ein einziges Skript erledigt den Rest.
data/money_benchmark/xg/.
.xg Dateien trägt.
python scripts/xg_benchmark_report.py python scripts/xg_dispute_analysis.py --sage-picks data/money_benchmark/scores/sage_truncated3.picks.jsonl
Das erste liest XGs Rollouts nach
data/money_benchmark/xg_results/rollout.jsonlein; das zweite erzeugt aus Sage 3Ts aufgezeichneter Wahl den Bericht zu den strittigen Positionen — jede Uneinigkeit der Reihe nach am Sage- und am XG-Rollout gemessen.
Das Match-Spiel ist von dieser Methode noch nicht abgedeckt: Es bräuchte einen vollständigen XG-Rollout der Match-Positionen, den wir nicht ausgeführt haben. Die Match-Stärke deckt stattdessen die Rollout-PR-Studie ab (Abschnitt 3) sowie die Studie zur Übereinstimmung bei echten Matches (Abschnitt 5).
Sage und XG können auch direkt gegeneinander spielen, wobei XGs Züge aus seiner eigenen Analyse stammen. Sage spielt beide Seiten einer unbegrenzten Partie; das Protokoll wird in XG stapelweise analysiert; die erste gegnerische Entscheidung, die von XGs bester Wahl abweicht, wird durch XGs Zug ersetzt und die Partie von dort mit neuen Würfeln weitergespielt, bis jeder gegnerische Zug derjenige ist, den XG gemacht hätte. Der Runner spielt eine Serie solcher Partien (die Seeds laufen weiter ab logs/sage_vs_xg.txt) und gibt die durchschnittlichen Punkte pro Partie mit ihrem Standardfehler aus:
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 muss auf dem Windows-Desktop laufen: Jede Iteration steuert seinen Batch-Analyze-Dialog über scripts/xg_batch_analyze.py, ein Anthropic-Computer-Use-Agent (setze ANTHROPIC_API_KEY), der Maus und Tastatur für etwa eine Minute pro Iteration übernimmt. Eine Partie konvergiert in wenigen Iterationen; XGs Urteil „too good to double“ zählt als kein Doppeln.
Die dreizehn Familien-Benchmarks liegen unter
backgame_ref_positions/benchmark/ — eine Datei
<family> starting.txt mit Ausgangspositionen und eine Referenz
<family> rollout.jsonl je Benchmark — und bewertet werden sie von
scripts/score_backgame_pr.py, das die PR zusammen mit dem Anteil der Züge in Rollout-Qualität ausgibt.
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 Dateien trägt.