Alpha-Beta-Suche

Die Alpha-Beta-Suche, auch Alpha-Beta-Cut genannt, ist eine optimierte Variante des Minimax-Suchverfahrens, also eines Algorithmus zur Bestimmung eines optimalen Zuges bei Spielen mit zwei gegnerischen Parteien. Während der Suche werden zwei Werte Alpha und Beta aktualisiert, die angeben, welches Ergebnis die Spieler bei optimaler Spielweise erzielen können. Mit Hilfe dieser Werte kann entschieden werden, welche Teile des Suchbaumes nicht untersucht werden müssen, weil sie das Ergebnis der Problemlösung nicht beeinflussen können.

Die einfache (nicht optimierte) Alpha-Beta-Suche liefert exakt dasselbe Ergebnis wie die Minimax-Suche.

Der Minimax-Algorithmus bewertet den vollständigen Suchbaum. Dabei werden aber auch Knoten betrachtet, die in das Ergebnis (die Wahl des Zweiges an der Wurzel) nicht einfließen. Die Alpha-Beta-Suche versucht, möglichst viele dieser Knoten zu ignorieren.

Folgendes Beispiel erklärt diesen Sachverhalt anschaulich: Nehmen wir an es gibt einige Taschen voll mit Gegenständen mit mehr oder weniger Wert und Sie erhalten einen Gegenstand aus einer der Taschen. Sie dürfen die Tasche wählen, und der Gegner wählt einen Gegenstand daraus. Sobald sie eine Tasche gewählt haben, wird ihr Gegner natürlich den wertlosesten Gegenstand daraus wählen. Sie wählen daher die Tasche, deren wertlosester Gegenstand immer noch mehr Wert besitzt, als der jeweils wertloseste der anderen Taschen.

Wendet man den Minimax-Algorithmus an, durchsucht man einfach alle Taschen vollständig und kennt damit den Wert eines jeden Gegenstandes, und somit kann man genau die richtige Tasche für sich wählen. Aber dieses Durchsuchen dauert eben ziemlich lange.

Also geht man folgendermaßen vor: Man durchsucht die erste Tasche vollständig. Nehmen wir an, darin befinden sich die Schlüssel für einen Neuwagen und ein 20 Euro Schein. Würden wir diese Tasche wählen, bekämen wir vom Gegner wohl den Geldschein zugeteilt, weil das der wertloseste Gegenstand in dieser Tasche ist. Egal wie wertvoll die anderen Dinge in dieser Tasche auch sein würden, wir bekämen immer nur diesen Geldschein daraus.

Wenn wir die zweite Tasche durchsuchen und darin als erstes einen 50 Euro Schein finden, steigt die Hoffnung, dass noch mehr wertvolle Gegenstände darin enthalten sind, und wir nehmen den zweiten Gegenstand daraus. Angenommen dabei handelt es sich um einen Apfel, dann wird uns der Gegner aus dieser Tasche wohl lieber diesen Apfel als den Geldschein geben. Dieser Apfel ist aber wertloser als der 20 Euro Schein, den wir aus der ersten Tasche bekämen. Also werden wir nie die zweite Taschen wählen, und durchsuchen sie nicht weiter. Die restlichen Gegenstände darin interessieren nicht mehr, diese können natürlich noch wertloser sein, als der Apfel. Wie wertlos aber diese Tasche genau ist, spielt keine Rolle, ausschlaggebend ist, dass sie wertloser als die erste Tasche ist, nicht, wie viel wertloser sie ist. Auch wenn die restlichen Gegenstände der Tasche großen Wert besitzen, wir bekämen doch nur höchstens diesen Apfel, also legen wir die Tasche beiseite.

Die Alpha-Beta-Suche arbeitet prinzipiell genauso wie obige informelle Beschreibung. Die Idee ist, dass zwei Werte (Alpha und Beta) weitergereicht werden, die das Worst-Case-Szenario der Spieler beschreiben. Der Alpha-Wert ist das Ergebnis, das Spieler A mindestens erreichen wird, der Beta-Wert ist das Ergebnis, das Spieler B mindestens erreichen wird. Besitzt ein maximierender Knoten (von Spieler A) einen Zug, dessen Rückgabe den Beta-Wert überschreitet, wird die Suche in diesem Knoten abgebrochen (Beta-Cutoff, denn Spieler B würde erst gar nicht diese Variante wählen, weil sie ein zu gutes Ergebnis für Spieler A liefern würde). Liefert der Zug stattdessen ein Ergebnis, das den Alpha-Wert übersteigt, wird dieser entsprechend nach oben angehoben. Analoges gilt für die minimierenden Knoten, wobei bei Werten kleiner als Alpha abgebrochen wird (Alpha-Cutoff) und der Beta Wert nach unten angepasst wird.

Obige Abbildung zeigt einen Beispielbaum mit 18 Blättern, von denen nur 12 ausgewertet werden. Die drei umrandeten Werte eines inneren Knotens beschreiben den Alpha-Wert, den Rückgabewert und den Beta-Wert.

Der Suchalgorithmus verwendet ein sogenanntes Alpha-Beta-Fenster, dessen untere Grenze der Alpha-Wert und dessen obere Grenze der Beta-Wert darstellt. Dieses Fenster wird zu den Kindknoten weitergegeben, wobei in der Wurzel mit maximalem Fenster begonnen wird. Die Blätter 1, 2 und 3 werden von einem maximierenden Knoten ausgewertet und der beste Wert 10 wird dem minimierenden Vaterknoten übergeben. Dieser passt den Beta-Wert an (signalisiert durch die orange Linie links unten) und übergibt das neue Fenster (-inf, 10] dem nächsten maximierenden Kindknoten, der die Blätter 4, 5 und 6 besitzt. Der Rückgabewert 12 von Blatt 5 ist aber so gut, dass er den Beta-Wert 10 überschreitet. Somit muss Blatt 6 nicht mehr betrachtet werden, weil das Ergebnis 12 dieses Teilbaumes besser ist, als das des linken Teilbaumes, und deshalb vom minimierenden Spieler nie gewählt werden würde.

Ähnlich verhält es sich beim minimierenden Knoten mit dem 3-Alpha-Cutoff. Obwohl dieser Teilbaum erst teilweise ausgewertet wurde, ist klar, dass der maximierende Wurzelknoten diese Variante niemals wählen würde, weil der minimierende Knoten mindestens das Ergebnis 3 erzwingen könnte, während aus dem mittleren Teilbaum das Ergebnis 12 sichergestellt ist.

Anmerkung: Unterschiede zum einfachen Minimax sind blau gekennzeichnet.

 int Max(int tiefe, int alpha, int beta)
 {
     if (tiefe == 0)
         return Bewerten();
     GeneriereMoeglicheZuege();
     while (ZuegeUebrig())
     {
         FuehreNaechstenZugAus();
         wert = Min(tiefe-1, alpha, beta);
         MacheZugRueckgaengig();
         if (wert >= beta)
             return beta;
         if (wert > alpha)
             alpha = wert;
     }
     return alpha;
 }

 int Min(int tiefe, int alpha, int beta)
 {
     if (tiefe == 0)
         return Bewerten();
     GeneriereMoeglicheZuege();
     while (ZuegeUebrig())
     {
         FuehreNaechstenZugAus();
         wert = Max(tiefe-1, alpha, beta);
         MacheZugRueckgaengig();
         if (wert <= alpha)
             return alpha;
         if (wert < beta)
             beta = wert;
     }
     return beta;
 }

Die NegaMax-Variante lautet:

 int AlphaBeta(int tiefe, int alpha, int beta)
 {
     if (tiefe == 0)
         return Bewerten();
     GeneriereMoeglicheZuege();
     while (ZuegeUebrig())
     {
         FuehreNaechstenZugAus();
         wert = -AlphaBeta(tiefe-1, -beta, -alpha);
         MacheZugRueckgaengig();
         if (wert >= beta)
             return beta;
         if (wert > alpha)
             alpha = wert;
     }
     return alpha;
 }

Anmerkung: Während die Standard-Implementierung für einen Spieler maximiert und für den anderen Spieler minimiert, maximiert die Negamax-Variante für beide Spieler und vertauscht und negiert Alpha und Beta bei der Rekursion. Daraus folgt, dass sich die Bewertungsfunktion in beiden Implementierungen unterschiedlich verhalten muss.

• Standard-Implementierung: Je besser die Brettstellung für den maximierenden Spieler ist, desto größer ist der Rückgabewert der Bewertungsfunktion. Je besser sie für den minimierenden Spieler ist, desto kleiner ist der Rückgabewert.
• Negamax-Implementierung: Da beide Spieler maximieren, muss die Bewertungsfunktion desto größere Werte liefern, je besser die Brettposition des gerade Ziehenden ist.

Anders als beim Minimax-Algorithmus spielt bei der Alpha-Beta-Suche die Reihenfolge, in der Kindknoten (Züge) bearbeitet werden, eine wesentliche Rolle. Je schneller das Alpha-Beta-Fenster verkleinert wird, desto mehr Cutoffs werden erreicht. Deshalb ist es wichtig, zuerst die Züge zu betrachten, die das beste Ergebnis versprechen. In der Praxis werden verschiedene Heuristiken verwendet. Bei Schach z. B. kann man die Züge danach sortieren, ob bzw. welche Figur geschlagen wird, oder auch welche Figur schlägt. „Turm schlägt Dame“ wird danach vor „Turm schlägt Turm“ einsortiert „und Bauer schlägt Turm“ wird zwischen beiden einsortiert.

Ein Knoten bei der Alpha-Beta-Suche gehört einer von drei Kategorien an (bezogen auf die NegaMax-Variante):

• Alpha-Knoten: Jeder Folgezug liefert einen Wert kleiner oder gleich Alpha, was bedeutet, dass hier keiner guter Zug möglich ist.
• Beta-Knoten: Mindestens ein Folgezug liefert einen Wert größer oder gleich Beta, was einen Cutoff bedeutet.
• Principal Variation-Knoten: Mindestens ein Folgezug liefert einen Wert größer als Alpha, aber alle liefern einen Wert kleiner oder gleich Beta.

Manchmal kann man frühzeitig erkennen, um welchen Knoten es sich handelt. Liefert der erste getestete Folgezug einen Wert größer gleich Beta, dann ist es ein Beta-Knoten. Liefert er einen Wert kleiner gleich Alpha, dann ist es möglicherweise ein Alpha-Knoten (vorausgesetzt, die Züge sind gut vorsortiert). Liefert er aber einen Wert zwischen Alpha und Beta, so handelt sich möglicherweise um einen Principal Variation-Knoten.

Die Principal-Variation-Suche nimmt nun an, dass ein Folgezug, der einen Wert zwischen Alpha und Beta liefert, sich als bester möglicher Zug herausstellen wird. Deshalb wird das Alpha-Beta-Fenster im folgenden minimal verkleinert, um eine maximale Anzahl an Cutoffs zu erreichen, aber dennoch die verbleibenden Züge als schlechter zu beweisen.

int AlphaBeta(int tiefe, int alpha, int beta)
{
    BOOL PVgefunden = FALSE;
    if (tiefe == 0)
        return Bewerten();
    GeneriereMoeglicheZuege();
    while (ZuegeUebrig())
    {
        FuehreNaechstenZugAus();
        if (PVgefunden)
        {
            wert = -AlphaBeta(tiefe-1, -alpha-1, -alpha);
            if (wert > alpha && wert < beta)        // Fenster war zu klein :(
                wert = -AlphaBeta(tiefe-1, -beta, -alpha);
        } else
            wert = -AlphaBeta(depth-1, -beta, -alpha);
        MacheZugRueckgaengig();
        if (wert >= beta)
            return wert;
        if (wert > alpha)
        {
            alpha = wert;
            PVgefunden = TRUE;
        }
    }
    return alpha;
}

Stellt sich bei Suche mit dem minimierten Alpha-Beta-Fenster heraus, dass es zu klein gewählt wurde, muss die Suche mit dem originalen Fenster wiederholt werden. Deshalb erreicht man durch dieses Verfahren nur dann Erfolge, wenn die Züge gut vorsortiert wurden. Andererseit können diese Principal Variation-Knoten in Verbindung mit dem Iterative Deepening auch für die Sortierung der Züge verwendet werden.

Die iterative Tiefensuche ist die schrittweise Erhöhung der Tiefe des Suchbaumes. Da die Alpha-Beta-Suche eine Tiefensuche ist, kann man meist vorher nicht bestimmen, wie lange die Berechnung dauern wird. Deshalb beginnt man mit einer geringen Suchtiefe und erhöht diese nach und nach. Das Ergebnis einer Berechnung kann benutzt werden, um bei der nächsten Berechnung die Züge besser vorzusortieren.

Aspiration windows werden zusammen mit der iterativen Tiefensuche verwendet. Grundsätzlich beginnt die Alpha-Beta-Suche an der Wurzel mit einem maximalen Fenster. Bei der iterativen Tiefensuche kann aber angenommen werden, dass eine neue Berechnung mit höherer Tiefe einen ähnlichen Ergebniswert liefert wird wie die vorangegangene. Deshalb kann das Suchfenster initial auf einen (relativ) kleinen Bereich um den Ergebniswert der vorherigen Berechnung gesetzt werden. Stellt sich heraus, dass dieses Fenster zu klein war, muss man (ähnlich wie bei der Principal-Variation-Suche) die Suche mit maximalem Fenster wiederholen.

Die Killer-Heuristik ist eine spezielle Art der Zugvorsortierung. Man nimmt hierbei an, dass Züge, die einen Cutoff verursacht haben, auch in anderen Teilen des Suchbaumes (bei gleicher Tiefe) einen Cutoff verursachen werden. Deshalb werden sie künftig immer zuerst betrachtet, sofern sie in der gerade betrachteten Spielposition gültige Züge darstellen. Diese Heuristik kann nicht bei allen Spielen sinnvoll angewendet werden, da die Aussicht darauf, dass Killerzüge auch in anderen Teilen des Suchbaumes noch gültige Züge sind, gering ist.

Die Alpha-Beta-Suche bzw. der Minimax-Algorithmus allgemein haben das Problem, dass bei einer gewissen Tiefe die Suche strikt abgebrochen wird, obwohl der Ergebniswert an dieser Stelle die Brettstellung nicht besonders gut widerspiegelt. Anstatt die Alpha-Beta-Suche bei der erreichten Höchsttiefe abzubrechen, wird eine spezielle Quiescent-Suche fortgeführt, die nur noch wenige wichtige der möglichen Züge betrachtet. Dadurch wird vermieden, dass kritische Spielpositionen an den Blättern allein durch die Bewertungsfunktion evaluiert werden. Bei Schach wird zum Beispiel der Schlagabtausch weiter betrachtet.

Die Null-Zug-Suche ist eine Optimierung, die sich die Tatsache zu Nutze macht, dass bei manchen Spielen (z. B. Schach) das Zugrecht von Vorteil ist.

Nachfolgende Tabelle zeigt eine Beispielberechnung einer Schachstellung bei konstanter Suchtiefe von vier Halbzügen (jeder Spieler zieht zweimal). Es wurde der normale Minimax-Algorithmus angewendet und Alpha-Beta ohne Zugsortierung und mit (einfacher) Zugsortierung. Die Prozentangabe bei den Cutoffs beziehen sich auf den gesamten Suchbaum und beschreibt, wieviel des gesamten Suchbaumes nicht ausgewertet wurde. Es handelt sich dabei um Schätzungen, denen zugrunde liegt, dass die Teilbäume in etwa gleich groß sind (bei Cutoffs ist nicht bekannt, wie groß der weggeschnittene Teilbaum wirklich wäre).

Algorithmus	Bewertungen	Cutoffs	Anteil der Cutoffs	Rechenzeit in Sekunden
Minimax	28018531	0	0,00 %	134.87 s
AlphaBeta	2005246	136478	91,50 %	9.88 s
AlphaBeta + Zugsortierung	128307	27025	99,28 %	0.99 s

Es ist deutlich zu erkennen, dass die Alpha-Beta-Suche eine erhebliche Geschwindigkeitssteigerung gegenüber Minimax bedeutet. Auch die Zugsortierung verbessert die Rechenzeit in diesem Beispiel um den Faktor 10. Die Tatsache, dass mit Zugsortierung die Anzahl der Cutoffs absolut sinkt, lässt sich dadurch erklären, dass diese auf höheren Ebenen im Suchbaum erfolgen und somit größere Teile weggeschnitten werden. Vorlage:Lesenswert Kandidat