Neue Testaufgaben für Schach-Programme

Der «Eigenmann Rapid Engine Test» (ERET)

von Walter Eigenmann

Der sog. Eigenmann Rapid Engine Test (ERET) ist eine neue Sammlung von 111 Aufgaben für Schach-Programme. Er wurde konzipiert, um schnell einen ersten Eindruck von der Spielstärke einer neuen Engine ausmachen zu können. Die Computerschach-Anwenderschaft erhält mit diesem ERET erstmals eine Test-Suite an die Hand, deren Ergebnisse innert zehn Minuten eine grobe, aber recht verlässliche Einschätzung eines (neuen) Programms erlauben.

Die 111 Stellungen bzw. ihre Hauptvarianten können hier nachgespielt und als PGN-Datei heruntergeladen werden. Downloadbar ist ausserdem der Test im CBH-Format (für Chessbase-Software) sowie als EPD-Datei für den Import in diverse Schach-GUI’s.

Die Vorzüge des ERET gegenüber älteren Sammlungen sind namentlich:

  • Grosse Bandbreite der Schachmotivik
  • Eindeutigkeit der Lösungen
  • Ausgewogenheit der Partiephasen
  • Mittlerer bis hoher Schwierigkeitsgrad
  • Keine Auswertungsformeln
  • Schnelle Programm-Resultate bereits nach 10 Min.
  • Auch für zukünftige Engine-Generationen tauglich

Die Axiomatik des ERET-Stellungstests

Eine Aufgaben-Sammlung wie der ERET-Stellungstest für Schachprogramme basiert auf einer eigenen Axiomatik.

Diese lässt sich in den folgenden fünf Punkten zusammenfassen:

  1. Die 111 Aufgaben des ERET decken einen grossen Bereich der (computer-)schachlichen Realität ab; diese abgestimmte Kompaktheit der Zusammenstellung ist weder durch Hinzufügungen noch Wegstreichungen antastbar.
  2. Für Computerprogramme (anders als für Menschen) ist eine Schachpartie grundsätzlich eine Sammlung von Einzel-Aufgabenstellungen unter definierten Bedingungen – ein Stellungstest also.
  3. Die Denk- bzw. Rechengeschwindigkeit beim Schachspielen ist eine maßgebliche Komponente der «Spielstärke».
  4. Das vom Test-Autor empfohlene Test-Setting ist ein integraler Bestandteil des Stellungstests.
  5. Unter Berücksichtigung bzw. Wahrung der Punkte 1 bis 4 garantiert der ERET keine 100%ige, aber eine weitgehende Übereinstimmung seiner Testergebnisse mit den durchschnittlichen Resultaten des praktischen Engine-Turnierbetriebes.

Test-Setting / Anmerkungen

Die technische Durchführung des Tests ist einfach und bei den verschiedenen Schach-Interfaces wie z.B. Arena, Shredder, Aquarium oder Fritz im Grundsatz ähnlich, wobei der Autor auf aktueller Computer-Hardware (2017) das folgende Test-Setting empfiehlt:

  • Bedenkzeit: 5-10 Sekunden pro Aufgabe
  • Prozessoren/Threads: 1-4
  • Hash-Memory: 256-512Mb
  • Opening-Books: beliebig
  • Endgame-Tablebases: beliebig
  • Extra Halbzüge: 2-99
  • eret-rochadeangriff-carlsen
    Der ERET-Schachtest für Computer-Programme deckt ein weites Spektrum an Eröffnungs-, Mittelspiel- und Endspiel-Elementen ab. Namentlich enthält er exemplarische Beispiele der folgenden taktischen und positionellen Motive (alphabetisch): Ablenkung – Abtausch – Damenopfer – Entlastung – Entwicklung – Festung – Freibauer – Initiative – Königsangriff – Königssicherheit – Läuferopfer – Linienöffnen -Mobilität – Offene Linien – Positionelles Opfer – Qualitätsopfer – Räumung – Rochadeangriff – Springeropfer – Starke Felder – Unterverwandlung – Vergifteter Bauer – Verteidigung – Zentralisierung – Zentrum – Zugzwang – Zwischenzug (Bild: Die Brennpunkte des weißen Rochadangriffs in einer Fernschachpartie Copie-Patrici 1986)

    Die Anzahl Lösungen einer Engine ergibt deren wichtigstes Testergebnis; dieses erlaubt bereits einen groben Vergleich mit anderen Programmen. Um die Resultate mehrerer Engines noch zu differenzieren, empfiehlt der Autor das Interface «Fritz» ab Version 11, dessen Testergebnisse – aus der CBH- in eine PGN-Datei konvertiert – dann mit dem Freeware-Tool von Dr. Frank Schubert EloStatTS104 abgeglichen werden sollten. Diese mathematisch-statistisch fundierte Methode der Test-Auswertung ist wenn immer möglich vorzuziehen. Außerdem ist bei einer Verwendung des Testes mit «Fritz» die von EloStatTS104 mitgelieferte «Offset»-Test-File zu berücksichtigen: Mit ihm lassen sich die unterschiedlichen Reaktions- bzw. Initialisierungszeiten der Engines unter diesem Interface eruieren, womit nochmals genauere Ergebnisse generiert werden können (siehe hierzu die entspr. Readme-Datei).
    Eine Alternative zum «Fritz»-GUI ist die Freeware-Oberfläche «Arena», die mit zusätzlichen Features beim Automatisierten Stellungstesten aufwartet und auch einen Output der Engine-Berechnungen bietet, allerdings auf jegliche Ranglisten-Generierung verzichtet bzw. nur die Anzahl Lösungen angibt, so dass keine weitergehende Differenzierung der Testergebnisse möglich ist bzw. manuell erfolgen müsste. Andere Benutzeroberflächen bieten ebenfalls nur rudimentäre Optionen bezüglich Stellungstests und sind deshalb für den ERET nur bedingt zu empfehlen.

  • Moderne Rechner mit Multi-Prozessoren- bzw. -Threads-Technik neigen zu Fluktuationen in ihrer Zug-Generierung. Deren Auswirkung in der Praxis wird zwar generell sehr überschätzt, aber wer auf Nummer sicher gehen will, macht pro Engine drei bis fünf Test-Durchläufe und nimmt den Durchschnitt der jeweiligen Lösungszeiten.
  • Um Software-übergreifende Vergleiche zu ermöglichen, sollten die Engines grundsätzlich mit ihren Default-Parametern getestet werden – natürlich abgesehen von Thread-, Hash- oder Tablebase-Einstellungen.
  • Auf schneller Hardware reichen 5 Sekunden pro Aufgabe aus; das entspricht ungefähr der im modernen Engine-Turnier-Betrieb häufig angewendeten Bedenkzeit von 40 Zügen in 4 Minuten. Bei langsameren Rechnern empfehlen sich 7-10 Sekunden.
  • Bei der Generierung von Ranglisten mit dem ERET sollten nicht die absoluten Zahlen-Ergebnisse, sondern vielmehr die Engine-Relationen beachtet werden – so wie bei den Rankings der verschiedenen bekannten Engine-Turnieren auch. Diese können bekanntlich (je nach Turnier-Settings und Berechnungsgrundlage) überraschend unterschiedlich ausfallen – siehe u.a. hier: CEGT, CCRL, FCP, OHCR, SPCC, FGRL
    Ein Vergleich von fünf häufig zitierten Ranglisten im Internet mit den ERET-Ergebnissen findet sich hier (März 2017).
  • Die einzelnen Stellungen hat der Autor hauptsächlich mit den drei Programmen Deep-Shredder 11/12, Critter 1.6 und RybkaWinFinder 2.2 im Hinblick auf ihre taktische Korrektheit untersucht. Ansonsten hat er auf weiteres Einzeltesten bewusst und konsequent verzichtet, um den Test möglichst objektiv und nicht irgendwie «geeicht» auf bestimmte Programme gestalten zu können. (Über entsprechende Resultat-Meldungen aus der Leser- bzw. Anwenderschaft per E-Mail würde sich der Autor also sehr freuen!).
  • Trotz der relativ kurzen Zeit-Vorgabe von 5 Sekunden/Stellung sind die ERET-Aufgaben keineswegs trivial. Viele der Stellungen dürften sogar ganz besondere Knacknüsse auch für heutige Engines sein. Die umfangreichen persönlichen Analysen mithilfe der obengenannten Programme legen den Schluss nahe, dass dieser Test eher im oberen Schwierigkeitsbereich angesiedelt ist. Der Autor ist deshalb zuversichtlich, dass der ERET auch noch in fünf oder zehn Jahren interessant sein wird…

Aktuelle ERET-Rangliste (Mai 2017)   –   Generiert mit EloStatTS104

    Program                                    Elo   +/-  Matches  Score   Av.Op.   S.Pos.   MST1    MST2   RIndex

  1 AsmFish 2017-03-15 (4CPU)                  : 3421    3   8204    68.5 %   3286    72/111    2.0s    3.0s   0.68
  2 Stockfish 170417 (4CPU)                    : 3414    3   7923    67.6 %   3286    67/111    1.9s    3.1s   0.69
  3 Komodo 10.4 (4CPU)                         : 3411    3   8074    67.2 %   3286    68/111    2.0s    3.2s   0.62
  4 Stockfish 8 (4CPU)                         : 3409    3   7946    67.0 %   3286    64/111    1.8s    3.2s   0.68
  5 Brainfish 190317 (4CPU)                    : 3408    3   8080    66.8 %   3286    65/111    1.9s    3.2s   0.64
  6 Houdini 5.01 (4CPU)                        : 3404    4   7617    66.2 %   3288    62/111    1.9s    3.2s   0.64
  7 Komodo 10.3 (4CPU)                         : 3397    4   7774    65.3 %   3287    60/111    1.9s    3.3s   0.60
  8 Stockfish 8 (1CPU)                         : 3390    4   7188    64.3 %   3287    57/111    1.9s    3.4s   0.56
  9 Houdini 5.01 (1CPU)                        : 3384    4   6732    63.4 %   3289    54/111    2.0s    3.4s   0.56
 10 Fizbo 1.9 (4CPU)                           : 3382    4   6725    62.8 %   3291    50/111    1.7s    3.5s   0.56
 11 Komodo 10.4 (1CPU)                         : 3382    4   7094    63.2 %   3288    56/111    2.2s    3.6s   0.46
 12 Komodo 10.3 (1CPU)                         : 3379    4   6718    62.7 %   3289    52/111    1.9s    3.5s   0.55
 13 McBrain 2.1 (1CPU)                         : 3373    4   6558    61.9 %   3289    51/111    2.1s    3.6s   0.49
 14 Stockfish 7 (1CPU)                         : 3372    4   6826    61.8 %   3289    53/111    2.3s    3.7s   0.45
 15 Komodo 10 (1CPU)                           : 3367    4   6220    60.7 %   3292    48/111    2.1s    3.7s   0.51
 16 DeepShredder 13 (4CPU)                     : 3362    4   6205    60.1 %   3291    46/111    2.0s    3.7s   0.44
 17 Houdini 4 (4CPU)                           : 3361    4   6278    59.7 %   3292    45/111    1.9s    3.7s   0.45
 18 Komodo 9.42 (1CPU)                         : 3359    4   6127    59.7 %   3291    45/111    2.1s    3.8s   0.42
 19 Andscacs 0.90 (4CPU)                       : 3358    4   6044    59.4 %   3292    42/111    1.7s    3.7s   0.46
 20 Stockfish 6 (1CPU)                         : 3353    4   5734    58.7 %   3292    42/111    1.9s    3.8s   0.48
 21 Komodo 9.2 (1CPU)                          : 3352    4   5981    58.6 %   3292    44/111    2.2s    3.9s   0.44
 22 Andscacs 0.89 (4CPU)                       : 3349    5   5872    57.9 %   3293    43/111    2.1s    3.8s   0.41
 23 Fritz 15 (4CPU)                            : 3349    4   5935    57.7 %   3294    41/111    2.0s    3.9s   0.39
 24 Komodo 9 (1CPU)                            : 3348    4   5827    57.9 %   3292    40/111    1.9s    3.8s   0.43
 25 Fizbo 1.9 (1CPU)                           : 3346    5   6014    57.3 %   3295    42/111    2.2s    3.9s   0.38
 26 Critter 1.6a (4CPU)                        : 3344    5   5874    57.1 %   3294    41/111    2.2s    3.9s   0.41
 27 Gull 3 (4CPU)                              : 3341    5   5762    56.6 %   3295    40/111    2.1s    3.9s   0.39
 28 Protector 1.9.0 (4CPU)                     : 3340    5   5734    56.6 %   3294    39/111    2.1s    3.9s   0.40
 29 Stockfish 5 (1CPU)                         : 3335    5   5470    55.9 %   3294    41/111    2.4s    4.0s   0.41
 30 Andscacs 0.87 (4CPU)                       : 3333    5   5598    55.4 %   3295    36/111    2.0s    3.9s   0.37
 31 Houdini 4 (1CPU)                           : 3328    5   5181    54.6 %   3296    34/111    1.8s    4.0s   0.45
 32 Fire 5 (1CPU)                              : 3327    5   5277    54.5 %   3296    33/111    1.7s    4.0s   0.37
 33 DeepShredder 13 (1CPU)                     : 3326    5   5315    54.4 %   3296    36/111    2.2s    4.1s   0.28
 34 Booot 6.1 (1CPU)                           : 3325    5   4521    54.1 %   3297    28/111    1.6s    2.7s   0.42
 35 Komodo 8 (1CPU)                            : 3323    5   5271    53.9 %   3296    33/111    2.0s    4.0s   0.37
 36 Andscacs 0.89 (1CPU)                       : 3318    5   5386    53.1 %   3296    34/111    2.3s    4.1s   0.28
 37 Critter 1.6a (1CPU)                        : 3318    5   5234    52.9 %   3298    33/111    2.1s    4.1s   0.35
 38 Andscacs 0.86 (4CPU)                       : 3317    5   5057    52.8 %   3298    32/111    2.1s    4.0s   0.36
 39 Nirvanachess 2.3 (4CPU)                    : 3316    5   5031    52.8 %   3297    33/111    2.1s    4.1s   0.33
 40 Equinox 3.30 (4CPU)                        : 3314    5   5062    52.1 %   3300    32/111    2.0s    4.0s   0.38
 41 Equinox 3.30 (1CPU)                        : 3312    5   5062    51.7 %   3300    31/111    2.1s    4.1s   0.35
 42 Naum 4.6 (4CPU)                            : 3308    5   4886    51.1 %   3300    33/111    2.6s    4.2s   0.34
 43 Andscacs 0.87 (1CPU)                       : 3307    5   4894    51.1 %   3300    31/111    2.2s    4.1s   0.30
 44 Fizbo 1.8 (1CPU)                           : 3305    5   5094    50.9 %   3299    28/111    1.8s    4.2s   0.29
 45 Fritz 15 (1CPU)                            : 3303    5   4899    50.4 %   3300    30/111    2.2s    4.2s   0.30
 46 Spark 1.0 (4CPU)                           : 3302    5   5287    50.2 %   3300    30/111    2.4s    4.3s   0.23
 47 DeepRybka 4.1 (1CPU)                       : 3299    5   4834    49.5 %   3302    27/111    2.0s    4.2s   0.30
 48 Andscacs 0.86 (1CPU)                       : 3298    5   4793    49.9 %   3299    29/111    2.2s    4.1s   0.33
 49 Texel 1.06 (4CPU)                          : 3296    5   4927    49.4 %   3300    28/111    2.1s    4.3s   0.25
 50 Hannibal 1.7 (1CPU)                        : 3295    5   4641    49.2 %   3300    24/111    1.2s    4.2s   0.37
 51 Nirvanachess 2.3 (1CPU)                    : 3295    5   4815    49.2 %   3300    28/111    2.2s    4.3s   0.26
 52 Arasan 19.2 (4CPU)                         : 3294    5   4961    48.8 %   3302    29/111    2.5s    4.3s   0.26
 53 Gull 3 (1CPU)                              : 3293    5   4742    48.9 %   3300    26/111    1.8s    4.2s   0.30
 54 Protector 1.8 (1CPU)                       : 3289    5   4564    48.3 %   3301    25/111    1.9s    4.0s   0.30
 55 Protector 1.9 (1CPU)                       : 3289    5   4668    48.4 %   3300    25/111    1.8s    4.3s   0.27
 56 Protector 1.6 (1CPU)                       : 3287    5   4611    47.8 %   3302    26/111    2.3s    4.2s   0.24
 57 BlackMamba 2.0 (4CPU)                      : 3285    5   4507    47.7 %   3301    25/111    1.9s    4.2s   0.31
 58 iCE 3.0 (1CPU)                             : 3283    5   4559    47.3 %   3302    24/111    1.9s    4.3s   0.28
 59 Fizbo 1.7 (1CPU)                           : 3283    5   4729    47.3 %   3302    23/111    1.7s    4.3s   0.27
 60 DeepGandalf 7.0 (2CPU)                     : 3282    6   4473    46.6 %   3305    22/111    1.6s    4.2s   0.32
 61 Chiron 4 (4CPU)                            : 3278    5   4631    46.5 %   3303    24/111    2.3s    4.3s   0.23
 62 RybkaWinFinder 2.2 (4CPU)                  : 3275    6   4525    45.7 %   3305    22/111    1.9s    4.3s   0.27
 63 DeepJunior 13.3 (1CPU)                     : 3274    6   4482    45.6 %   3305    21/111    1.6s    4.3s   0.28
 64 Chiron 3.01 (4CPU)                         : 3274    5   4528    45.6 %   3305    25/111    2.6s    4.4s   0.22
 65 Nirvanachess 2.2 (1CPU)                    : 3274    5   4506    45.9 %   3302    23/111    2.0s    4.4s   0.21
 66 Crafty 25.2 (4CPU)                         : 3273    6   4223    45.7 %   3303    19/111    2.2s    3.1s   0.18
 67 Texel 1.06 (1CPU)                          : 3272    5   4566    45.5 %   3304    25/111    2.8s    4.5s   0.21
 68 DeepFritz 10 (4CPU)                        : 3271    5   4617    45.2 %   3304    23/111    2.4s    4.4s   0.21
 69 Chiron 2 (1CPU)                            : 3270    6   4550    45.0 %   3305    22/111    2.1s    4.3s   0.18
 70 Wasp 2.00 (4CPU)                           : 3269    5   4507    45.0 %   3304    24/111    2.6s    4.5s   0.24
 71 Rybka 3 (1CPU)                             : 3269    5   4350    45.0 %   3304    21/111    2.0s    4.3s   0.30
 72 Naum 4.6 (1CPU)                            : 3269    6   4312    44.9 %   3304    20/111    1.6s    4.3s   0.29
 73 Chiron 1.5 (1CPU)                          : 3267    6   4486    44.7 %   3304    22/111    2.3s    4.4s   0.20
 74 Hakkapeliitta 3.0 (1CPU)                   : 3261    6   4453    43.8 %   3305    23/111    2.7s    4.4s   0.17
 75 Texel 1.05 (1CPU)                          : 3260    6   4272    43.3 %   3307    22/111    2.4s    4.5s   0.22
 76 Arasan 19.1 (4CPU)                         : 3260    5   4312    43.4 %   3306    21/111    2.4s    4.5s   0.23
 77 LittleGoliath Revival (1CPU)               : 3257    6   4219    42.7 %   3308    17/111    1.5s    4.1s   0.23
 78 Chiron 4 (1CPU)                            : 3255    6   4404    42.8 %   3306    22/111    2.8s    4.5s   0.15
 79 Arasan 19.2 (1CPU)                         : 3253    6   4254    42.5 %   3306    22/111    2.8s    4.5s   0.21
 80 Vajolet 22.2 (1CPU)                        : 3253    6   4236    42.6 %   3305    22/111    2.8s    4.5s   0.16
 81 Nimzo 8 (1CPU)                             : 3253    6   4252    42.1 %   3309    16/111    1.2s    4.3s   0.23
 82 Arasan 19.1 (1CPU)                         : 3253    6   4315    42.4 %   3306    18/111    1.8s    4.4s   0.16
 83 ZappaMexico II (1CPU)                      : 3249    6   3903    41.5 %   3309    15/111    1.1s    3.9s   0.28
 84 TheKing 3.33 (1CPU)                        : 3247    6   4170    41.3 %   3309    16/111    1.6s    4.3s   0.21
 85 Spark 1.0 (1CPU)                           : 3245    6   4276    41.4 %   3306    20/111    2.8s    4.6s   0.16
 86 DeepFritz 10 (1CPU)                        : 3245    6   4106    40.9 %   3309    16/111    1.7s    4.4s   0.22
 87 Naum 4 (1CPU)                              : 3245    6   3950    40.9 %   3308    15/111    1.2s    4.1s   0.24
 88 TheKing 3.50 (4CPU)                        : 3243    6   4103    40.7 %   3308    18/111    2.3s    4.5s   0.18
 89 Senpai 1.0 (1CPU)                          : 3241    6   4112    40.7 %   3307    17/111    2.0s    4.5s   0.19
 90 Dragon 4.6 (1CPU)                          : 3241    6   3786    40.1 %   3311    14/111    1.6s    3.7s   0.19
 91 Fruit 2.3 (1CPU)                           : 3238    6   3909    39.7 %   3311    15/111    1.4s    4.5s   0.26
 92 Ruffian 1.0.1 (1CPU)                       : 3237    6   4116    39.8 %   3309    15/111    1.8s    4.5s   0.19
 93 Spike 1.4 (1CPU)                           : 3228    6   4001    38.5 %   3309    15/111    2.3s    4.4s   0.17
 94 RodentII 0.9.64 (1CPU)                     : 3227    6   3947    38.4 %   3310    17/111    2.8s    4.6s   0.15
 95 Quazar 0.4 (1CPU)                          : 3226    6   3945    38.4 %   3309    15/111    2.2s    4.5s   0.13
 96 Ufim 8.02 (1CPU)                           : 3226    6   3999    38.0 %   3311    14/111    1.9s    4.6s   0.18
 97 Fruit 2.2.1 (1CPU)                         : 3224    6   3899    37.8 %   3311    13/111    1.5s    4.5s   0.22
 98 Amoeba 1.2 (1CPU)                          : 3219    6   3810    37.0 %   3312    14/111    2.2s    4.5s   0.19
 99 Junior 13.8Yokohama (1CPU)                 : 3219    6   3899    37.2 %   3310    12/111    1.1s    4.6s   0.19
100 Gandalf 6.0 (1CPU)                         : 3217    6   3785    36.8 %   3311    13/111    1.9s    4.4s   0.16
101 Anaconda 2.0.1 (1CPU)                      : 3217    6   3875    36.8 %   3311    16/111    2.8s    4.7s   0.16
102 Komodo 1.3 (1CPU)                          : 3216    6   3799    36.8 %   3310    14/111    2.1s    4.6s   0.14
103 Tao 5.7b (1CPU)                            : 3214    6   3778    36.5 %   3310    13/111    2.1s    4.3s   0.19
104 Tao 5.6 (1CPU)                             : 3211    6   3701    36.0 %   3311    12/111    1.7s    4.2s   0.18
105 Deuterium 14.3.34.130 (1CPU)               : 3211    6   3742    36.0 %   3311    12/111    1.6s    4.5s   0.16
106 Wasp 2.00 (1CPU)                           : 3206    6   3767    35.3 %   3312    14/111    2.6s    4.7s   0.15
107 ProDeo 2.3 (1CPU)                          : 3201    6   3771    34.6 %   3312    10/111    1.3s    4.6s   0.12
108 Tao 5.4 (1CPU)                             : 3199    6   3629    34.2 %   3313    10/111    1.7s    4.1s   0.14
109 LoopMP 12.32 (2CPU)                        : 3198    6   3703    33.9 %   3314    10/111    1.6s    4.7s   0.17
110 Wasp 1.25 (1CPU)                           : 3197    6   3623    33.9 %   3313    13/111    2.6s    4.7s   0.13
111 Gaviota 1.0 (1CPU)                         : 3192    6   3641    33.4 %   3312    11/111    2.0s    4.7s   0.15
112 Laser 1.2 (1CPU)                           : 3191    6   3687    33.1 %   3313    10/111    1.9s    4.7s   0.13
113 ChessMind 0.82 (1CPU)                      : 3190    6   3613    33.0 %   3314     9/111    1.3s    4.5s   0.15
114 ProDeo 2.2 (1CPU)                          : 3188    6   3587    32.7 %   3313    11/111    2.8s    4.3s   0.10
115 SmarThink 1.70 (1CPU)                      : 3180    6   3495    31.4 %   3315     8/111    1.1s    4.6s   0.16
116 Ktulu 9 (1CPU)                             : 3180    6   3548    31.5 %   3314     8/111    1.4s    4.6s   0.14
117 Minko 1.3 (1CPU)                           : 3179    6   3503    31.4 %   3315     9/111    1.5s    4.7s   0.15
118 Murka 3 (1CPU)                             : 3175    6   3624    31.1 %   3313     8/111    1.9s    4.7s   0.08
119 Octochess r5190                            : 3144    5   3387    27.1 %   3316     6/111    2.6s    4.8s   0.08



MST1  : Mean solution time  (solved positions only)
MST2  : Mean solution time  (solved and unsolved positions)
RIndex: Score according to solution time ranking for each position

AMD 8350-FX - 5sec/move - 512Mb Hash - Fritz 15 - Windows 10 / 64bit

Der Output jeder Engine bei jeder Aufgabenstellung – auf die hundertstel Sekunde genau – lässt sich hier downloaden (Mai 2017 – PGN-Datei).

Weiterführende Links

  • Für jene Leser, die sich näher mit der Thematik Computerschach-Stellungstests befassen möchten, nachfolgend ein paar weiterführende Links:
  • Dr. Frank Schubert: Lösung eines alten Problems – Autor Schubert untersucht zuerst die seinerzeit gängigen Auswerteverfahren verschiedener bekannter Stellungstests und stellt dann einen mathematisch neuen, dem FIDE-Elo-Verfahren ähnlichen Ansatz zur Differenzierung von Test-Ergebnissen vor. In einem historischen Exkurs wird auch Bezug genommen auf noch vor einigen Jahren gebräuchliche Tests von Autoren wie Bednorz, Schumacher, Gurevich oder Scheidl. Zum Schluss stellt Schubert seine eigene Methode vor, «welche die Schwächen der bisherigen Formeln beseitigt und erstmalig auf einer soliden schachlichen Theorie basiert.»
  • Lars Bremer: Was Stellungstests testen – IT-Journalist und Programmierer Bremer repliziert darin auf den seinerzeit heftig umstrittenen CSS-WM-Test von M. Gurevich, wobei er ebenso unverhohlen wie amüsant in die Trick-Kiste greift, um seine Test-kritische These zu untermauern: Er löscht mit einem eigens dafür geschriebenen Tool in dem als Gesamtheit konzipierten Test jeweils so lange einzelne Aufgaben, bis immer wieder Top-Resultate der zufällig gewählten (ggf. schwachen) Engine resultieren, womit Bremer den zufälligen Charakter von Test-Ergebnissen beweisen möchte. Aber da selbstverständlich ein umfangreicher und durchdachter Stellungstest immer kompakt gemeint ist, seine Aufgaben aufeinander abgestimmt sind und darum nicht einfach willkürlich zusammengestrichen werden können, ist der ganze Artikel eher satirisch denn wissenschaftlich einzustufen und darum ein einziger «Quatsch» (Zitat) – aber dennoch witzig zu lesen.
  • Lars Bremer: Chaos-System Deep Engine – Ein sehr viel «seriöserer» und informativer Artikel des obigen Autors zur Problematik des «Zufälligen Zuges» bei Deep-Engines. Mit seinem «Fazit» bezüglich der Aussagekraft von Stellungstests bei MP-Rechnern ist der Schreibende zwar nicht einverstanden: Ausgedehnte Untersuchungen könnten sehr wohl dokumentieren, dass ein durchdachtes Design eines Stellungstestes diesen «MP-Effekt» zwar nicht restlos ausschalten, aber entscheidend abfedern kann, so dass er bezüglich Ranking schliesslich auch statistisch irrelevant wird. Doch Bremer erklärt das Phänomen aus der Sicht des Programmierers äusserst anschaulich und auch für Laien nachvollziehbar. Es wird erklärt, warum sich moderne «Deep»-Programme zuweilen völlig nicht-deterministisch, ja «chaotisch» verhalten beim Ausspielen von Zügen.
  • Tord Romstad (Stockfish): Eine kurz zusammengefasste Erklärung dieses «MP-Effektes» findet sich auch in einem Interview, das Frank Quisinsky vor Jahren mit Tord Romstad, dem verantwortlichen Stockfish-Programmierer, sowie dessen Co-Autoren geführt hat. Zitat: «Wenn ein Schachprogramm eine Position, irgendwo tief innerhalb des Suchbaums, untersucht, macht es Gebrauch bzw. erinnert sich an frühere bereits untersuchte Positionen der gleichen Suche. Die Zugbeschneidung, Verkürzung oder Verlängerung hängen davon ab, welche Positionen vorher überprüft wurden und wie die Ergebnisse der Untersuchung dieser Positionen waren. Der Großteil der Informationen, der für eine Entscheidung verwendet wird, liegt im Arbeitsspeicher. Der Arbeitsspeicher steht allen Prozessoren zur Verfügung.
    Solange es nur einen Thread gibt, ist alles zu 100% reproduzierbar. Aber bei mehreren Threads beginnen seltsame Dinge zu geschehen, weil diese Threads nie synchron mit gleicher Geschwindigkeit aktiv sein können. Immer wieder wird eine CPU für ein paar Millisekunden eine Pause einlegen müssen und das Betriebssystem weist dann sofort eine andere Aufgabe zu. Das geschieht zufällig und ist nicht vorhersehbar, eine Kontrolle gibt es hierfür nicht. Als Konsequenz erreicht jeder Prozessor eine bestimmte Position eher zufällig und das wirkt sich dann auf die Suche nach Entscheidungen zur aktuellen Position aus.»
  • Chess Programming Wiki: Test-Positions – Diese informative Seite verlinkt eine Vielzahl interessanter Artikel zur Thematik «Stellungstest» bzw. zu deren Autoren und stellt eine Fundgrube dar für jene, die sich mit der Materie näher befassen möchten. Gleichzeitig bietet die Webseite einen umfassenden Überblick auf die Historie und listet sogar interessante Forum-Beiträge aus früheren Jahren auf.

Computerschach-Beiträge im Glarean Magazin

Kommentar verfassen