Brinkmann - Department of Information Systems

Westfälische Wilhelms-Universität Münster
Seminararbeit
Kombinatorische Suche
im Rahmen des Seminars Parallele Programmierung
Lars Brinkmann
Themensteller: Prof. Dr. Herbert Kuchen
Betreuer: Prof. Dr. Herbert Kuchen
Institut für Wirtschaftsinformatik
Praktische Informatik in der Wirtschaft
Inhaltsverzeichnis
1
Einleitung................................................................................................................... 3
2
Grundlagen ................................................................................................................ 3
3
4
2.1
Suchbäume........................................................................................................ 3
2.2
Divide-and-Conquer ......................................................................................... 4
Branch-and-Bound..................................................................................................... 6
3.1
Traveling Salesperson Problem ........................................................................ 8
3.2
Parallele Branch-and-Bound-Algorithmen ..................................................... 11
3.3
Anomalien in parallelen Branch-and-Bound-Algorithmen ............................ 13
Spielbäume .............................................................................................................. 15
4.1
MiniMax-Algorithmus.................................................................................... 16
4.2
Alpha-Beta-Search.......................................................................................... 17
4.3
Parallele Alpha-Beta-Suche............................................................................ 19
5
Fazit ......................................................................................................................... 20
6
Literaturverzeichnis ................................................................................................. 21
II
1 Einleitung
Kombinatorische Algorithmen führen Berechnungen mit diskreten, endlichen
mathematischen Strukturen durch [ReiNieDeo 77]. Eine kombinatorische Suche ist der
Prozess, „eine oder mehrere optimale oder fast optimale Lösungen in einem definierten
Problemraum“ zu finden [WahLiYu 85]. Kombinatorische Algorithmen haben heute
eine große Bedeutung bei der Problemlösung im Bereich der Künstlichen Intelligenz,
sowie bei der Erzeugung effizienter Lösungen für NP-vollständige Probleme.
Entscheidungsprobleme
und
Optimierungsprobleme
bilden
zwei
Arten
von
kombinatorischen Suchproblemen. Ein Algorithmus, der ein Entscheidungsproblem
löst, muss eine Lösung finden, die alle Einschränkungen erfüllt. Ein Algorithmus, der
ein Optimierungsproblem löst, muss bei der Lösung gleichzeitig eine Zielfunktion
minimieren oder maximieren. Die weiteren Beispiele in dieser Ausarbeitung werden
sich mit den Optimierungsproblemen der kombinatorischen Suche befassen. In Kapitel
zwei werden Grundlagen zu Suchbäumen und Divide-and-Conquer-Verfahren
dargestellt. Im dritten Kapitel wird am Beispiel des Problem des Handlungsreisenden
die Branch-and-Bound-Technik erklärt und Parallelisierungsmöglichkeiten vorgestellt.
Im vierten Kapitel beschäftigt sich diese Ausarbeitung mit Algorithmen auf
Spielbäumen und deren Parallelisierung. Im fünften Kapitel wird abschließend ein Fazit
aus den Ergebnissen gezogen.
2 Grundlagen
2.1 Suchbäume
Ein Optimierungsproblem kann durch einen Baum dargestellt werden. Das
Grundprinzip der Problemlösungsmethode beruht auf der rekursiven Zerlegung des
Ausgangsproblems in Teilprobleme. Man unterscheidet dabei Teilprobleme, die alle zur
3
Lösung des übergeordneten Problems gelöst werden müssen, und Teilproblemen, von
denen die Lösung eines Einzigen zur Lösung des übergeordneten Problems ausreicht.
Durch die fortgesetzte rekursive Zerlegung wird eine baumartige Verknüpfung von
Teilproblemen gebildet. Die Wurzel des Baumes repräsentiert das zu lösende
Ausgangsproblem, innere Knoten repräsentieren reduzierbare Teilprobleme und die
Blätter stellen entweder direkt lösbare oder unlösbare Teilprobleme dar. Den beiden
Zerlegungsmöglichkeiten entsprechen zwei verschiedene Knotentypen, die UNDKnoten und die ODER-Knoten. Aus diesen Knotentypen lassen sich drei
unterschiedliche Baumarten darstellen, der UND-Baum, der ODER-Baum und der
UND-ODER-Baum. Diese Baumtypen werden in der weiteren Ausarbeitung noch
detailliert dargestellt.
2.2 Divide-and-Conquer
Das Divide-and-Conquer-Verfahren beruht auf der Idee, ein Problem in Unterprobleme
aufzuteilen und deren Lösungen zu einer Lösung des Gesamtproblems zu kombinieren.
Die Methodik ist rekursiv, das bedeutet, dass die Teilprobleme ihrerseits wieder durch
die Divide-and-Conquer-Strategie gelöst werden können [Aho 96].
Die Divide-and-Conquer-Lösung eines Problems kann durch einen UND-Baum
dargestellt werden (vgl. Abbildung 1), da die Lösung jedes Problems, die Lösung aller
Teilprobleme erfordert.
Es existieren drei Möglichkeiten für die Ausführung von Divide-and-Conquer
Algorithmen auf MIMD-Computern (Multiple Instruction Multiple Data) [Quinn 94].
Die erste Methode ist die Abbildung des Suchbaums auf einem Prozessorbaum, der dem
Suchbaum im Aufbau entspricht. Diese Methode hat jedoch zwei Nachteile. Der
Wurzelprozessor kann hierbei zu einem Flaschenhals werden, da er der Kanal für
jeglichen In- und Output ist. Ein weiterer Nachteil ist die starre Verbindungsstruktur
4
dieses Prozessorbaums, so dass auf ihm nur ganz spezielle Divide-and-Conquer
Algorithmen gelöst werden können.
Problem
UND
Teilproblem
Teilproblem
UND
Teilproblem
UND
Teilproblem
Teilproblem
Teilproblem
Abbildung 1: UND-Baum
Eine zweite Möglichkeit ist die Abbildung des Suchbaumes auf eine virtuelle BaumMaschine, die eine robuste Verbindungsstruktur hat, wie z.B. Multicomputer mit
hyperkubischer Prozessoranordnung. Wichtig bei dieser Lösung ist ein Algorithmus, der
das Suchproblem möglichst effizient auf die virtuelle Baum-Maschine abbildet, um die
nötige Kommunikation zu minimieren. Ein Vorteil dieser Technik ist die Möglichkeit,
unterschiedliche Divide-and-Conquer Algorithmen auf dem gleichen Prozessornetzwerk
zu bearbeiten. Eine dritte Möglichkeit ist die Ausführung der Divide-and-ConquerAlgorithmen auf einem UMA-Multiprozessor-System (Uniform Memory Access). Die
Architektur des gemeinsamen Speichers ermöglicht den Zugriff auf die Daten der
Teilprobleme durch mehrere Prozessoren.
Der Lösungsprozess einer parallelen Suche auf einem UND-Baum kann in drei Phasen
unterteilt werden. In der ersten Phase wird das Problem in Unterprobleme aufgeteilt und
auf die Prozessoren verteilt. In den meisten Fällen gibt es in diesem Schritt weniger
Prozesse als Prozessoren, so dass die meisten Prozessoren solange untätig sind, bis
Ihnen ein Problem zum Zerlegen und Verteilen zugeteilt wird. In der zweiten Phase sind
5
die Prozessoren mit der Berechnung der Probleme beschäftigt, bis in der dritten Phase
die Ergebnisse der Unterprobleme von wenigen Prozessoren kombiniert werden.
Infolgedessen ist die Optimierung dieses Verfahrens durch den Overhead des Verteilund Kombinieraufwandes begrenzt.
3 Branch-and-Bound
Backtracking ist die Bezeichnung für ein Lösungsverfahren, bei dem eine Teillösung
eines Problems systematisch zu einer Gesamtlösung ausgebaut wird. Falls in einem
gewissen Stadium ein weiterer Ausbau einer vorliegenden Lösung nicht mehr möglich
ist, werden einer oder mehrere der letzten Teilschritte rückgängig gemacht. Es wird
versucht die erhaltene, reduzierte Teillösung auf einem anderen Weg wieder
auszubauen. Das Zurücknehmen von Schritten und erneute Vorangehen wird solange
wiederholt, bis eine Lösung des vorliegenden Problems gefunden ist oder bis erkannt
wurde, dass das Problem keine Lösung besitzt. Die Möglichkeit in Sackgassen zu laufen
und aus ihnen wieder herauszufinden, zeichnet das Backtracking-Verfahren aus.
Das Branch-and-Bound-Verfahren ist eine Variante des Backtrackings, welches Nutzen
aus Informationen über die Optimalität von Teillösungen ziehen kann, um die
Untersuchung von Lösungen zu vermeiden, die nicht optimal sein können. Ein Branchand-Bound-Algorithmus
versucht
ein
gegebenes
Problem
bei
gleichzeitiger
Minimierung oder Maximierung einer Zielfunktion f zu lösen. Das gegebene Problem
wird in ein oder mehrere Teilprobleme zerlegt, falls es nicht direkt lösbar ist. Dieser
Prozess wird Branching genannt und wird solange fortgeführt, bis eine zulässige
Lösung gefunden wurde, oder festgestellt wird, dass dieses Teilproblem nicht zu einer
optimalen Lösung führen kann. Für diese Überprüfung, wird für jedes Teilproblem eine
untere Schrank g berechnet. Diese gibt die Kosten an, die für eine mögliche Lösung des
Teilproblems mindestens benötigt werden. Ist eine Lösung gefunden, müssen nur noch
6
Teilprobleme untersucht werden, deren untere Schranke kleiner als der Wert f der
gefundenen Lösung sind. Diese Begrenzung des Suchraumes wird Bounding genannt.
Die wesentlichen Bestandteile eines Branch-and-Bound-Algorithmus sind:
•
Eine Regel zur Erzeugung von Teilproblemen (branching rule)
•
Eine Regel zur Auswahl von Teilproblemen (selection rule)
•
Eine Regel zum Ausschluss von nicht optimalen Teilproblemen (elimination
rule)
•
Eine Abbruchbedingung (termination rule)
Der Zerlegungsprozess kann durch einen ODER-Baum (vgl. Abbildung 2) dargestellt
werden. Die Wurzel repräsentiert das Gesamtproblem, innere Knoten stellen
Teilprobleme und Blätter nicht weiter zerlegbare oder unlösbare Teilprobleme dar.
Problem
ODER
Teilproblem
Teilproblem
ODER
ODER
Teilproblem
Teilproblem
Teilproblem
Teilproblem
Abbildung 2: Oder-Baum
Bei
der
Auswahl
noch
nicht
untersuchter
Teilprobleme
gibt
es
mehrere
Traversierungsarten:
•
Die Tiefensuche (depth-first)
•
Die Breitensuchen (breadth-first)
•
Die Bestensuche (best-first)
7
Das Branch-and-Bound Verfahren soll nun an einem Beispiel, dem Traveling
Salesperson Problem, verdeutlicht werden.
3.1 Traveling Salesperson Problem
Das Traveling-Salesperson-Problem (TSP) ist auch als Problem des Handelsreisenden
bekannt. Der Handelsreisende (travelling salesperson) hat zur Abwicklung von
Geschäften eine Rundreise durch n Städte zu unternehmen, wobei die Reihenfolge so
gewählt werden soll, dass der Gesamtreiseweg möglichst kurz wird. Mathematisch lässt
sich das Problem folgendermaßen beschreiben:
Gegeben: Ein gerichteter vollständiger Graph G(V,E) mit N = |V| Knoten, die
Orten entsprechen, sowie eine Distanzmatrix C mit cii = +∞ und cij >= 0 ∀i,j
Gesucht: Eine Rundtour T ⊂ E durch alle N Orte, die jede Stadt genau einmal
besucht und einen minimalen Distanzwert c aufweist.
c(T) =
∑
( i , j )∈T
c
ij
Little et al. entwickelten 1963 einen berühmten Branch-and-Bound-Algorithmus zur
Lösung des TSP [Quinn 94]. Das Verfahren beruht auf der Idee der Zeilen- und
Spaltenreduktion der Distanzmatrix und der sukzessiven Erzeugung von Teilproblemen,
die Touren darstellen.
Noch nicht untersuchte Teilprobleme werden in einer Liste verwaltet, auf der eine
Bestensuche durchgeführt wird. Der Algorithmus entnimmt jeweils das Teilproblem mit
der kleinsten unteren Schranke. Ist dieses Teilproblem direkt lösbar, wurde eine Route
gefunden, ansonsten wird das Teilproblem durch Hinzunahme einer weiteren Kante in
zwei neue Teilprobleme zerlegt. Ein Kinderknoten repräsentiert die Menge aller
Routen, die diese Kanten enthalten, der andere Knoten die Menge aller Routen, die
8
diese Kante nicht enthalten. Die Kosten für die Kanten der möglichen Routen lassen
sich in einer Matrix [i][j] darstellen.
Jede Stadt muss in einer Tour genau einmal verlassen werden. Zeile i der Matrix enthält
jeweils die Kosten für das Verlassen von Stadt i. Die günstigste Möglichkeit stellt hier
das Zeilenminimum cij dar. Alle Einträge in dieser Zeile der Matrix werden um den
Wert dieser Kante reduziert und die untere Schranke wird um diesen Wert erhöht. Das
gleiche gilt für das Spaltenminimum, denn jede Stadt muss genau einmal betreten
werden, und die Kosten dafür sind in Spalte j gegeben. Die entstehende Matrix enthält
somit nur noch die Zusatzkosten für die Kanten. Die Gesamtkosten einer Route
berechnet sich somit aus der unteren Schranke und den zusätzlichen Kosten für die
gewählten Kanten.
Zeilenreduktion
Spaltenreduktion
A
B
C
D
E
MIN
A
∞
9
6
7
∞
6
B
9
∞
3
∞
10
C
6
3
∞
5
D
7
∞
5
E
∞
10
4
∑
A
B
C
D
E
A
∞
3
0
1
∞
3
B
6
∞
0
∞
4
3
C
3
0
∞
∞
8
5
D
2
∞
8
∞
4
E
∞
21
MIN 2
Reduzierte Matrix
∑
A
B
C
D
E
A
∞
3
0
0
∞
7
B
4
∞
0
∞
6
2
1
C
1
0
∞
1
0
0
∞
3
D
0
∞
0
∞
2
6
0
4
∞
E
∞
6
0
3
∞
0
0
1
1
4
g: 21 + 4 = 24
Abbildung 3: Beispiel Matrixreduktion
Der Algorithmus soll nun an einem Beispiel mit fünf Orten (A-E) verdeutlicht werden.
In Abbildung 4 ist der Zyklus der Route von A nach E in einem bewerteten Graph
dargestellt.
9
9
A
B
3
6
C
7
5
10
4
D
E
8
Abbildung 4: Graph
Ausgehend von einem Knoten wird der Zustandsbaum gebildet und mittels
Matrixreduktion untere Schranken für jeden relevanten Knoten berechnet. In Abbildung
5 ist der korrespondierende Zustandsbaum dargestellt.
Die Wurzel repräsentiert die Menge aller möglichen Routen. Rechte Kinderknoten
stellen die Routen ohne Hinzunahme einer bestimmten Kante da, während linke
Kinderknoten alle Routen unter Hinzunahme dieser Kante repräsentieren. Die untere
Schranke von 25 erhöht sich auf 31 bei der Hinzunahme der Kante (B,C). Wird die
Kante (B,C) ausgeschlossen, erhöht sich die Schranke nur auf den Wert 29, so dass die
Suche im rechten Teilbaum fortgesetzt wird. Bei der Fortsetzung dieses Verfahrens
ergibt sich eine Rundreise über die Kanten (A,D), (D,E), (E,C), (C,B) und (B,A) mit
Gesamtkosten von 31.
10
Mit (B,C)
25
Ohne (B,C)
31
29
Ohne (E,C)
Mit (E,C)
Mit (A,D)
31
Ohne (A,D)
31
Ohne (C,B)
Mit (C,B)
31
31
Ohne (D,E)
Ohne (B,A)
32
8
Mit (D,E)
31
35
8
Mit (B,A)
32
Abbildung 5: Branch-and-Bound-Baum des TSP-Beispiels
3.2 Parallele Branch-and-Bound-Algorithmen
Mohan entwickelte 1983 zwei Parallelisierungen dieses Algorithmus. Der erste
Algorithmus setzt bei der Zerlegung eines Problems in Teilprobleme an. Ursprünglich
hat dieser Prozess einen natürlichen Parallelismus von zwei, da die Probleme in zwei
Teilprobleme, Einschluss oder Ausschluss einer Kante, zerlegt werden. Der modifizierte
Algorithmus erhöht den Verzweigungsfaktor des Zustandsbaumes, so dass k Kanten
berücksichtigt werden und ein Knoten 2k Kinder besitzt. Dieser Algorithmus folgt dem
Verfahren von Little und eignet sich für den Einsatz von 2k Prozessoren.
Der zweite Algorithmus verwaltet die noch nicht untersuchten Teilprobleme in einer
Liste, auf die von mehreren Prozessen zugegriffen werden kann. Ein Prozess wählt
jeweils ein noch nicht untersuchtes Teilproblem mit der kleinsten unteren Schranke aus
der Liste aus und berechnet die unteren Schranken für die untergeordneten
11
Teilprobleme, wenn diese nicht sofort gelöst werden können. Da die exklusive
Verwaltung der Liste durch einen eigenen Prozess nur einen geringen Teil der Zeit in
Anspruch nimmt, der für die Zerlegung benötigt wird, stellt dies kein signifikantes
Hindernis für die Beschleunigung da.
Abbildung 6: Vergleich der zwei Algorithmen
Wie in Abbildung 6 zu sehen, erzielt der erste Algorithmus nur eine geringe
Beschleunigung, da laut Quinn die zusätzlichen Prozessoren den größten Teil ihrer Zeit
mit der Erzeugung von Knoten verbringen, die nie untersucht werden, da ihre unteren
Schranken zu hoch sind. Mohans zweiter Algorithmus erzielt eine achtfache
Beschleunigung mit 16 Prozessoren bei einem TSP mit 30 Knoten.
Quinn entwickelte vier parallele Branch-and-Bound-Algorithmen für einen HypercubeMulticomputer, die für jeden Prozessor eine eigene Prioritätswarteschlange verwalten.
Befindet sich ein Teilproblem in dieser Warteschlange, wird dieses entnommen, und
falls es nicht direkt gelöst werden kann, wird es nach dem Verfahren von Little zerteilt.
Die entstandenen Teilprobleme werden wieder in die Warteschlange eingefügt. Die
Algorithmen von Quinn können anhand der Heuristik, welches Teilproblem an einen
anderen Prozessor weitergegeben wird, unterschieden werden. Quinn benutzte die
folgenden vier Heuristiken:
12
1. Füge das Teilproblem in die eigene Warteschlange des Prozessors ein, bei dem
die Kante eingeschlossen wird und sende das Teilproblem, bei dem die Kante
ausgeschlossen wird, an einen benachbarten Prozessor weiter.
2. Füge ein neues Teilproblem mit einer niedrigeren unteren Schranke in die
Warteschlange ein und sende das Teilproblem mit der höheren, unteren
Schranke weiter.
3. Füge beide Teilprobleme in die Warteschlange ein und sende und entferne das
zweitbeste Problem der Warteschlange.
4. Füge beide Teilprobleme in die Warteschlange ein und sende und entferne das
beste Problem aus der Warteschlange.
Bei der Auswahl des benachbarten Prozessors, an den ein Teilproblem gesendet wird,
benutzen alle vier Algorithmen die gleiche Technik. Ein Prozessor i sendet bei der
Iteration j ein Teilproblem an den Prozessor, dessen Nummer sich durch die
Invertierung des Bits an der Stelle j mod d der Zahl i ergibt (p=2d). Nach log2(p)
Iterationen wurde an jeden Prozessor ein Teilproblem gesendet. Bei einem Vergleich
dieser vier Algorithmen sind die Heuristiken drei und vier den beiden übrigen deutlich
überlegen. Ziel dieser parallelen Algorithmen ist es, möglichst viele Prozessoren mit für
die Lösung relevanten Teilproblemen zu versorgen.
3.3 Anomalien in parallelen Branch-and-Bound-Algorithmen
Lai und Sahni [LaSa 84] zeigten in einer Analyse, dass die Parallelisierung des Branchand-Bound-Algorithmus
sowohl
zu
superlinearen
als
auch
sublinearen
Beschleunigungen führen kann. Die Analyse stützt sich auf folgende Annahmen:
•
Die Zeit für die Untersuchung und Zerlegung eines Knotens, ist für alle Knoten
gleich.
13
•
Die Ausführung des Algorithmus besteht aus einer Reihe von Iterationen, in
denen die Prozessoren Teilprobleme untersuchen und zerlegen.
Bei einem gegebenen Branch-and-Bound-Problem und einer gegebenen unteren
Schranke g stellt I(p) die Anzahl Iterationen bei p Prozessoren da. Lai und Sahni
konnten folgende Anomalien nachweisen:
•
acceleration anomaly: Es tritt eine superlineare Beschleunigung mit einem
Faktor größer als die eingesetzte Prozessoranzahl auf.
•
deceleration anomaly: Die Beschleunigung ist kleiner als die eingesetzte
Prozessorenanzahl, jedoch größer als eins.
•
detrimental anomaly: Der Faktor der Beschleunigung ist kleiner als eins.
Eine Erhöhung der Zahl der benötigten Iterationen bei einer Erhöhung der verwendeten
Prozessoren entspricht dem ersten Theorem von Lai und Sahni, dass hier beispielhaft
für die möglichen Anomalien in branch-and-bound Algorithmen dargestellt werden soll:
Theorem 1 [LaSa 84]: Sind n1 < n2 und k > 0 gegeben, dann existiert ein Zustandsbaum
mit k*I(n1) < I(n2).
Beweis: Das Theorem kann an dem in Abbildung 7 dargestellten Zustandsbaum
bewiesen werden. Alle Knoten mit der Markierung „=“ haben die gleiche untere Grenze
wie der optimale Knoten A. Alle Knoten mit der Bezeichnung „>“ haben eine größere
untere Schranke als dieser Knoten. Führen n1 Prozessoren die Suche durch, so wird
während der ersten Iteration der Wurzelknoten in n1 + 1 Teilprobleme expandiert. Die
zweite Iteration besteht aus der Expansion der n1 am weitesten links stehenden Knoten
der Ebene zwei in n1 Knoten der Ebene drei. Bei der dritten Iteration werden die
übrigen Knoten der Ebene 3 und Knoten B expandiert. Da der Knoten auf Ebene drei
zum Lösungsknoten führt, terminiert der Algorithmus mit I(n1) = 3.
14
Werden n2 Prozessoren für die Suche eingesetzt ist die erste Iteration gleich. In der
zweiten Iteration werden alle n1 + 1 Knoten der Ebene zwei expandiert, was zu n1 + n2
Knoten in der Ebene 3 führt. Werden jetzt die n2 am weitesten rechts stehenden Knoten
ausgewählt, würden n2 Knoten der Ebene vier erzeugt und der Lösungsknoten A würde
erst während der 3k + 1 Iteration expandiert. Daher ist es möglich, dass der Einsatz von
n2 Prozessoren zu I(n2) = 3k+1 Iterationen führt.
Abbildung 7: Zustandsbaum Theorem 1
Lai und Sahni konnten vereinzelt bei einem 0-1 Rucksackproblem anormales Verhalten
feststellen, schlussfolgerten jedoch, dass anomales Verhalten in der Praxis nur sehr
selten auftritt und die Erhöhung der Prozessorzahl nicht zu einer Erhöhung der
Ausführungszeit führt [Quinn 94].
4 Spielbäume
Ein Zwei-Personen-Spiel kann formal als ein Suchproblem über der Menge aller
möglichen Züge definiert werden. Die geläufigste Art der Implementierung eines ZweiPersonen-Spiels ist die Darstellung als UND-ODER-Spielbaum (vgl. Abbildung 8). In
einem Spielbaum repräsentieren Knoten Spielfeldkonfigurationen und Kanten
Spielzüge. Da eine vollständige Enumeration des Spielbaumes gerade bei komplexen
Spielen aufgrund der exponentiell steigenden Rechenzeit nicht möglich ist, werden auch
15
hier Heuristiken eingesetzt, die mittels einer geeigneten Bewertungsfunktion den
optimalen Zug innerhalb einer vorgegebenen Suchtiefe finden sollen. Bei einem
trivialen Spiel kann der MiniMax-Algorithmus verwendet werden, um eine Strategie zu
finden.
Problem
ODER
Teilproblem
Teilproblem
UND
Teilproblem
ODER
Teilproblem
Teilproblem
Teilproblem
Abbildung 8: UND-ODER-Baum
4.1 MiniMax-Algorithmus
Der MiniMax Algorithmus baut einen Spielbaum bis zu einer bestimmten Ebene auf
und ordnet jedem Blatt mit Hilfe der Bewertungsfunktion einen Zahlenwert zu [Kaindl
89].
Der Minimax-Algorithmus besteht aus fünf Schritten:
1. Generiere den Spielbaum bis zu den Endzuständen in einer festgelegten Tiefe
2. Wende die Nutzenfunktion auf alle Endzustände an
3. Die Elternkoten der Endzustände erhalten den aus ihrer Sicht jeweils
ungünstigsten Wert ihrer Kindknoten
4. Führe dies bis zu den Kindknoten der Wurzel fort
5. Wähle den Kindknoten ( Zug ) mit dem höchsten Wert aus
16
4.2 Alpha-Beta-Search
Der Alpha-Beta-Algorithmus ist eine Erweiterung des MiniMax-Algorithmus. Ziel ist
es, die Performance durch das Abschneiden von Teilbäumen zu steigern. Hierzu werden
zwei Schranken α und β übergeben, die zu einem vorzeitigen Abschneiden von
Teilbäumen führen können. Die untere α -Schranke entspricht dem Mindestgewinn, den
der maximierende Spieler (MAX) bei beliebigem Gegenspiel garantiert erzielen kann.
Analog bezeichnet β den Mindestgewinn des minimierenden Spielers (MIN) unter
Berücksichtigung
aller
MAX-Reaktionen.
Zusammen
begrenzen
die
beiden
Schrankenwerte ein Intervall, das (α, β)-Suchfenster, in dem der MiniMax-Wert des
Spielbaums gesucht wird. Knoten mit einem Wert von kleiner α oder größer β werden
ohne Informationsverlust abgeschnitten. Die Wurzel des Baumes wird mit a = -∞ und β
= +∞ aufgerufen. In Abbildung 9 ist die Alpha-Beta-Suche an einem Spielbaum zu
sehen. An den Knoten sind die sich ändernden Suchfenster angegeben. Abgeschnittene
Teilbäume sind durch gestrichelte Linien gekennzeichnet.
Die Komplexität der Alpha-Beta-Suche entspricht der Anzahl der untersuchten Blätter
im Spielbaum. Im Worst-Case müssen alle Blätter des Spielbaumes untersucht werden,
das entspricht einem Aufwand von O(vt), wobei v dem Verzweigungsfaktor und t der
Tiefe des Suchbaumes entspricht. Im Best-Case wird von jedem Knoten aus nur der
beste Zug untersucht. Slagle und Dixon [SD69] zeigten, dass der Aufwand im BestCase v[t/2] + v[t/2] +1, also O(2*v[d/2]), entspricht. Quinn gibt den effektiven
Verzweigungsfaktor eines Algorithmus mit
d
Anzahl der untersuchten Blätter an, wobei
d der Suchtiefe des Algorithmus entspricht. Im Best-Case entspricht der
Verzweigungsfaktor also
d
d /2
2 *b
⇔
d
2 * b . Bei großem d strebt der erste Faktor
17
gegen Null, so dass sich ein Verzweigungsfaktor von
b ergibt. Im besten Fall kann
also die Suchtiefe bei gleichem Aufwand verdoppelt werden.
Abbildung 9: Alpha-Beta-Suche in einem Spielbaum
Der Standard Alpha-Beta-Algorithmus kann in vielerlei Hinsichten verbessert werden.
Eine der Verbesserungstechniken ist die Aspirationssuche. Die Aspirationssuche
versucht durch engere Suchfenster schnellere Ergebnisse zu erzeugen. Sie arbeitet mit
der Schätzung eines Wertes v der Brettposition an der Wurzel und dem
wahrscheinlichen Fehler e dieser Schätzung. Der Aufruf erfolgt in dem Suchfenster (ve,v+e). Wenn der Wert des Spielbaums tatsächlich in dieses Suchfenster fällt, ist die
Suche viel schneller abgeschlossen als mit einem Suchfenster von (-∞, +∞). Wenn der
Wert der Position kleiner als v-e ist, gibt die Suche den Wert v-e zurück und die Suche
muss mit einem neuen Suchfenster von (-∞, v-e) durchgeführt werden, analog dazu wird
eine neue Suche mit dem Fenster (v+e, +∞) durchgeführt, wenn der Wert größer als v+e
ist. In vielen Zweipersonen-Spielen treten identische Positionen an verschiedenen
Stellen im Suchbaum auf. Eine Alternative zur wiederholten Bewertung gleicher
Positionen ist es, die zuvor ausgewerteten Positionen in einer Hashtabelle, der
18
sogennanten Transpositionstabelle, zu speichern. Bevor eine Position bewertet wird,
wird in der Transpositionstabelle geprüft, ob bereits ein Wert für diese Position
berechnet worden ist.
4.3 Parallele Alpha-Beta-Suche
Die Alpha-Beta-Suche bietet mehrere Möglichkeiten der Parallelisierung. Die
Auswertung der Spielfeldkonfiguration nimmt bei den meisten Spielen die größte Zeit
in Anspruch. Bei einigen Schachprogrammen wird z.B. mehr als 40% der Zeit für die
Bewertung der Spielfeldkonfiguration eingesetzt. Durch die Verteilung einzelner Terme
der Bewertungsfunktion auf mehrere Prozessoren kann eine gute Beschleunigung des
Algorithmus erzeugt werden. Marsland und Campbell beschreiben drei Vorteile dieser
Technik [Quinn 94]. Zum einen kann die Suche tiefer durchgeführt werden, da die
Auswertungszeit
reduziert
wird,
zum
anderen
könnte
eine
komplizierte
Bewertungsposition gefunden werden, die nur durch die Anzahl der eingesetzten
Prozessoren limitiert wird.
Eine weitere Parallelisierungsmöglichkeit ist die direkte Durchführung einer parallelen
Aspirationssuche. Wenn z.B. drei Prozessoren zur Verfügung stehen, könnte jedem
dieser Prozessoren ein Suchfenster der Aspirationssuche zugeteilt werden. Einem wird
das Intervall (-∞, v-e) zugeteilt, einem weiteren das Intervall (v-e, v+e) und dem dritten
Prozessor wird das Intervall (v+e, ∞) zugeteilt. Im Idealfall wird der Prozessor mit dem
kleinsten Intervall (v-e, v+e) erfolgreich sein, es werden jedoch alle Prozessoren Ihre
Suche schneller beenden, als wenn ein einzelner Prozessor das Fenster (-∞,∞)
untersucht. Baudet erforschte die parallele Aspirationssuche auf dem Cm* [Baudet 78].
Daraus folgte, dass die parallele Aspirationssuche eine maximale Beschleunigung von
fünf bis sechs zeigte.
19
Eine weitere Methode ist die sequentielle Durchführung des Alpha-Beta-Algorithmus
durch zwei Prozessoren. Der zweite Prozessor verwaltet ausschließlich die
Transpositionstabelle. Während dieser Prozessor die Transpositionstabelle überprüft,
kann der andere Prozessor bereits mit der Berechnung dieser Position beginnen. Steht
der Wert nicht in der Tabelle, wurde keine Zeit mit der Suche vergeudet. Steht die
Position bereits in der Tabelle, besteht die Zeit, die für die Berechnung des Wertes
benötigt wird, aus dem Minimum der Berechnungszeit und der Zeit, die für das
Auslesen des Wertes aus der Tabelle benötigt wird.
5 Fazit
Heuristische Suchalgorithmen sind ein fester Bestandteil vieler Softwareprodukte, wie
z.B. Routenplaner oder Computerspiele. Aufgrund der hohen Komplexität solcher
Anwendungen reichen auch effiziente Algorithmen oft nicht aus, Ergebnisse in einer
angemessenen Zeit zu liefern. Die Parallelisierung solcher Algorithmen bietet hier einen
Ansatz zur Steigerung der Performance. Baumsuchalgorithmen eignen sich aufgrund
ihrer Struktur sehr gut zur Parallelisierung selbst auf massiv parallelen Systemen. Die
Schwierigkeit dabei liegt jedoch in der Lastverteilung. Der Baum kann beliebig in
Teilbäume zerlegt werden, welche unabhängig voneinander durchsucht werden können.
Bei der Aufteilung des Suchbaumes unter den Prozessoren ist die Größe der sich dabei
ergebenden Teilbäume jedoch nicht a priori bekannt. Aus diesem Grund ist eine
effiziente dynamische Lastverteilungsstrategie notwendig, um die Prozessoren während
der Suche möglichst gleichmäßig auszulasten. Alle in dieser Ausarbeitung vorgestellten
Algorithmen zeigten eine Effizienzsteigerung durch ihre Parallelisierung, wovon einige
jedoch nur sehr gering ausfielen. Es bleibt also bei einzelnen Problemen zu prüfen, ob
eine Parallelisierung in Abhängigkeit von der Beschleunigung und der zusätzlich
entstehenden Kosten gerechtfertigt scheint.
20
6 Literaturverzeichnis
[Aho 96]
Aho, A.V., Ullmann J. D., Informatik, Datenstrukturen und
Konzepte der Abstraktion, Thomson Publishing Gmbh, Bonn
1996
[Baudet 78]
Gérard M. Baudet, The Design and Analysis of Algorithms for
Asynchronous Multiprocessors. PhDthesis, Carnegie Mellon
University, Pittsburgh, PA, 1978.
[Kaindl 89]
Kaindl, H., Problemlösen durch heuristische Suche in der
Artificial Intelligence, Springer 1989
[LaSa 84]
Ten-Hwang Lai, Sartaj Sahni, Anomalies in Parallel Branch-andBound Algorithms, CACM 27(6): 594-602 (1984)
[Quinn 94]
Quinn, M.J., Parallel Computing Theory and Practise. MacGrawHill 1994
[ReiNieDeo 77]
Reingold, E., M. Nievergelt, J., Deo, N., Combinatorial
Algortithmus: Theory and Practice. Prentice-Hall, Englewood
Cliffs, NJ. 1977
[RE 89]
Reinefeld, A., Spielbaum-Suchverfahren, Springer 1989
[SD69]
J. Slagle, J. Dixon, Experiments with some Programs that Search
Game Trees, Journal of the ACM 2, (1969), 189-207.
[WahLiYu 85]
Benjamin W. Wah, Guo-Jie Li, Chee-Fen Yu, Multiprocessing of
combinatorial search problems. Computer 18, 6 (Juni), S. 93-108.
1985
[WahLiYu 90]
Benjamin W. Wah, Guo-Jie Li, Chee-Fen Yu, Multiprocessing of
combinatorial search problems, Parallel Algorithms for Machine
Intelligence and Vision, Springer 1990