Die Alpha-Beta-Suche (auch Alpha-Beta-Cut oder Alpha-Beta-Pruning 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.

Informelle Beschreibung

Der Minimax-Algorithmus analysiert 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 ignoriert alle Knoten, von denen im Moment, da sie von der Suche erreicht werden, bereits feststeht, dass sie das Ergebnis nicht beeinflussen können.

Ein anschauliches Beispiel für die Funktionsweise ist ein Zweipersonenspiel, bei dem der erste Spieler eine von mehreren Taschen auswählt und von seinem Gegenspieler den Gegenstand mit geringstem Wert aus dieser Tasche erhält.

Der Minimax-Algorithmus durchsucht für die Auswahl alle Taschen vollständig und benötigt somit viel Zeit. Die Alpha-Beta-Suche hingegen durchsucht zunächst nur die erste Tasche vollständig nach dem Gegenstand mit minimalem Wert. In allen weiteren Taschen wird nur solange gesucht, bis der Wert eines Gegenstands dieses Minimum erreicht oder unterschreitet. Dann steht fest, dass diese Tasche für den ersten Spieler nicht besser als die erste ist, und die Suche darin kann abgebrochen werden. Andernfalls ist diese Tasche eine bessere Wahl, und ihr minimaler Wert dient für die weitere Suche als neue Grenze.

Ähnliche Situationen sind jedem Schachspieler vertraut, der gerade einen konkreten Zug darauf prüft, ob er ihm vorteilhaft erscheint. Findet er bei seiner Analyse des Zuges eine für sich selbst ungünstige Erwiderung des Gegners, dann wird er diesen Zug als „widerlegt“ ansehen und verwerfen. Es wäre sinnlos, noch weitere Erwiderungen des Gegners zu untersuchen, um festzustellen, ob der Gegner noch effektivere Widerlegungen besitzt und wie schlecht der betrachtete Zug tatsächlich ist.

Der Algorithmus

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 höchstens erreichen wird. (Hier ist zu beachten, dass es für Spieler B darum geht, ein möglichst niedriges Ergebnis zu erhalten, da er ja „minimierend“ spielt!)

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 A diese Variante erst gar nicht anbieten, weil sie sein bisheriges Höchst-Zugeständnis überschreiten würde). Liefert der Zug stattdessen ein Ergebnis, das den momentanen 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 dem maximalen Fenster [-inf, inf] 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 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 ein Ergebnis von höchstens 3 erzwingen könnte, während aus dem mittleren Teilbaum das Ergebnis 12 sichergestellt ist.

Implementierung

Anmerkung: Unterschiede zum einfachen Minimax-Algorithmus sind gelb hinterlegt.

Hauptprogramm (Auszug):

 besterZug = NULL;
 int Suchtiefe = 4;
 int bewertung = max(Suchtiefe,
                     -unendlich, +unendlich);
 if (besterZug == NULL)
    es gab keine weiteren Zuege mehr (Matt oder Patt);
 else
    spiele(besterZug);

Die normale Variante lautet:

 int max(int tiefe,
         int alpha, int beta) {
    if (tiefe == 0 or keineZuegeMehr(spieler_max))
       return bewerten();
    int maxWert = alpha;
    Zugliste = generiereMoeglicheZuege(spieler_max);
    for each (Zug in Zugliste) {
       fuehreZugAus(Zug);
       int wert = min(tiefe-1,
                      maxWert, beta);
       macheZugRueckgaengig(Zug);
       if (wert > maxWert) {
          maxWert = wert;
          if (tiefe == Suchtiefe)
             besterZug = Zug;
          if (maxWert >= beta)
             break;
       }
    }
    return maxWert;
 }

 int min(int tiefe,
         int alpha, int beta) {
    if (tiefe == 0 or keineZuegeMehr(spieler_min))
       return bewerten();
    int minWert = beta;
    Zugliste = generiereMoeglicheZuege(spieler_min);
    for each (Zug in Zugliste) {
       fuehreZugAus(Zug);
       int wert = max(tiefe-1,
                      alpha, minWert);
       macheZugRueckgaengig(Zug);
       if (wert < minWert) {
          minWert = wert;
          if (minWert <= alpha)
             break;
       }
    }
    return minWert;
 }

Die NegaMax-Variante lautet:

 int miniMax(int spieler, int tiefe,
             int alpha, int beta) {
    if (tiefe == 0 or keineZuegeMehr(spieler))
       return bewerten(spieler);
    int maxWert = alpha;
    Zugliste = generiereMoeglicheZuege(spieler);
    for each (Zug in Zugliste) {
       fuehreZugAus(Zug);
       int wert = -miniMax(-spieler, tiefe-1,
                           -beta, -maxWert);
       macheZugRueckgaengig(Zug);
       if (wert > maxWert) {
          maxWert = wert;
          if (tiefe == Suchtiefe)
             besterZug = Zug;
          if (maxWert >= beta)
             break;
       }
    }
    return maxWert;
 }

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 und betrachtet die Werte immer aus der Sicht des Spielers, der am Zug ist; positive Werte sind für diesen günstig, negative ungünstig. Daraus folgt, dass sich die Bewertungsfunktion in beiden Implementierungen unterschiedlich verhalten muss.

• Standard-Implementierung: Die Brettstellung wird aus der Sicht des maximierenden Spielers bewertet (Funktion bewerten()). Wenn der maximierende Spieler besser steht, ist der Wert positiv.
• Negamax-Implementierung: Bewertet wird aus der Sicht des Spielers, der jeweils am Zug ist. Darum wird die Funktion bewerten(spieler) mit dem ziehenden Spieler als Parameter aufgerufen.

Optimierungen

Kann man auf Grund der Komplexität des betrachteten Spiels den Spielbaum nur bis zu einer gewissen Tiefe berechnen, sind zwei Optimierungsansätze möglich. Zum einen kann die Bewertungsfunktion verbessert werden, zum anderen bietet der Alpha-Beta-Algorithmus selbst Optimierungspotential. Je besser die Bewertungsfunktion ist, desto weniger tief muss der Spielbaum betrachtet werden, um eine gewisse Spielstärke zu erlangen.

Im Folgenden werden Optimierungen der Alpha-Beta-Suche dargestellt.

int AlphaBeta(int tiefe, int alpha, int beta)
{
    if (tiefe == 0)
        return Bewerten();
    BOOL PVgefunden = FALSE;
    best = -unendlich;
    Zugliste = GeneriereMoeglicheZuege();
    for each (Zug in Zugliste)
    {
        FuehreZugAus(Zug);
        if (PVgefunden)
        {
            wert = -AlphaBeta(tiefe-1, -alpha-1, -alpha);
            if (wert > alpha && wert < beta)
                wert = -AlphaBeta(tiefe-1, -beta, -wert);
        } else
            wert = -AlphaBeta(tiefe-1, -beta, -alpha);
        MacheZugRueckgaengig(Zug);
        if (wert > best)
        {
            if (wert >= beta)
                return wert;
            best = wert;
            if (wert > alpha)
            {
                alpha = wert;
                PVgefunden = TRUE;
            }
        }
    }
    return best;
}

Vergleich von Minimax und AlphaBeta

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, wie viel 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).

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.

Geschichte

Während die zentrale Bedeutung des Minimax-Algorithmus für die Schachprogrammierung bereits von deren Pionieren Alan Turing und Claude Shannon in den 1940er-Jahren hervorgehoben wurde, liegen die Anfänge der Alpha-Beta-Suche in den späten 1950er-Jahren, wobei zunächst nur Alpha-Cutoffs verwendet wurden. Erst in den 1960er-Jahren wurde der Alpha-Beta-Algorithmus zum festen Bestandteil von Schachprogrammen. Eine erste, allerdings unveröffentlichte Beschreibung stammt aus dem Jahr 1963. Alexander Brudno veröffentlichte 1963 eine genaue Beschreibung und einen mathematischen Beweis der Korrektheit der Alpha-Beta-Suche. Die erste ausführliche Untersuchung erschien 1975.

Literatur

• Jörg Bewersdorff: Glück, Logik und Bluff. Mathematik im Spiel – Methoden, Ergebnisse und Grenzen. 5. Auflage. Vieweg + Teubner, Wiesbaden 2010, ISBN 978-3-8348-0775-5, doi:10.1007/978-3-8348-9696-4, S. 177–197 (Kapitel 2.10).
• Alexander Reinefeld: Entwicklung der Spielbaum-Suchverfahren: Von Zuses Schachhirn zum modernen Schachcomputer. In: Wolfgang Reisig & Johann-Christoph Freytag (Hrsg.): Informatik. Aktuelle Themen im historischen Kontext. Springer, Berlin/Heidelberg/New York 2006, ISBN 978-3-540-32742-4, doi:10.1007/3-540-32743-6_11, S. 241–276.
• Wolfgang Ertel: Grundkurs Künstliche Intelligenz: Eine praxisorientierte Einführung, Computational Intelligence. 4. Auflage. Springer Vieweg, Wiesbaden 2016, ISBN 978-3658135485, doi:10.1007/978-3-658-13549-2, S. 125–127.

Weblinks

• Burkhard Monien, Ulf Lorenz & Daniel Warner: Der Alphabeta-Algorithmus für Spielbaumsuche. 2006.
• Visualisierung der Alpha-Beta-Suche als Java-Applet für beliebige Spielbäume

Fußnoten

1. ↑ Jörg Bewersdorff: Glück, Logik und Bluff. Mathematik im Spiel – Methoden, Ergebnisse und Grenzen. 5. Auflage. 2010, S. 184.
2. ↑ Allen Newell, J. C. Shaw & H. A. Simon: Chess-playing programs and the problem of complexity. In: IBM Journal of Research and Development. Band 2, Heft 4, 1958, doi:10.1147/rd.24.0320, S. 330–335 (PDF; 2,172 MB).
3. ↑ D. J. Edwards & T. P. Hart: The alpha-beta heuristic (= AI Memos. 030). Massachusetts Institute of Technology, 1963 (PDF; 288 kB).
4. ↑ Brudno, A.L.: Bounds and valuations for shortening the search of estimates. In: Problems of Cybernetics. Band 10, 1963, S. 225–241. 
5. ↑ Donald E. Knuth & Ronald W. Moore: An analysis of alpha-beta Pruning. In: Artificial Intelligence. Band 6, Heft 4, 1975, doi:10.1016/0004-3702(75)90019-3, S. 293–326