Kapitel 3: Und−Oder−Graphen Bisher wurde die Lösung eines

Wissensbasierte Systeme
Kapitel 3: Und−Oder−Graphen
Bisher wurde die Lösung eines Problems als Suchproblem aufgefaßt, das durch Verfolgung
von Pfaden in einem ungerichteten oder gerichteten Graph gelöst wird. Geht man nämlich von
der Vorstellung aus, daß sich ein Problem durch eine Hintereinanderfolge von geeigneten
Transformationen lösen läßt, dann kann man dies als Wegsuche in einem Graphen
modellieren, in dem die möglichen Transformationsergebnisse die Knoten und die
Transformationen die Kanten bedeuten. Diese Modellierung der Problemlösung ist aber nicht
immer adäquat.
Als Methoden zur Problemlösung kennt man nicht nur die Transformation, sondern auch
die Zerlegung eines Problems in Teilprobleme, die zusammen die Lösung ergeben ( divide
and conquerˆ). Diese beiden Methoden zusammen bilden die abstrakte Basis von
Problemlösestrategien. Nun gibt es aber in den bislang betrachteten Graphen keine
gleichzeitige natürliche Entsprechung dieser beiden Methoden. In Graphen werden direkt nur
die Transformationen modelliert, und zwar durch die Kanten des Graphen. Die Zerlegung in
Teilprobleme hat keine Entsprechung in der Grundstruktur des Graphen. Die Einführung des
Und−Oder−Graphen liefert eine adäquate Basis für Verfahren der Problemlösung in dem
Sinne, daß beide Methoden, sowohl der Transformation als auch der Zerlegung, bereits in der
Grundstruktur des Graphen eine Entsprechung haben.
Grundlegende Definitionen und Beispiele
Ein Graph besteht aus Knoten und Kanten. Demgegenüber besteht ein Und−Oder−Graph aus
Knoten und
`Konnektoren´. Ein Konnektor besteht wiederum aus Kanten, die einen
gemeinsamen Anfangspunkt haben. Jede Kante hat einen Anfangspunkt und einen Endpunkt.
Der gemeinsame Anfangspunkt der Kanten eines Konnektors heißt Anfangspunkt des
Konnektors, die Endpunkte der Kanten eines Konnektors heißen Endpunkte des Konnektors.
Die graphische Darstellung eines Konnektors ist ein Streckenbündel von gerichteten Strecken,
deren gemeinsamer Anfangspunkt dem Anfangspunkt des dargestellten Konnektors
entspricht. Jede Strecke des Bündels repräsentiert eine Kante und endet im Endpunkt der
Kante. Die Zugehörigkeit von Kanten zu einem gemeinsamen Konnektor kennzeichnen wir
graphisch durch einen Kreisbogen, der alle gemeinsamen Kanten schneidet (alle Kanten
liegen graphisch in einem Winkelfeld).
1
Wissensbasierte Systeme
Definition:
Ein Und−Oder−Graph ist eine Menge von Knoten, eine Menge von
Konnektoren und eine Abbildung, die für jeden Konnektor dessen Anfangspunkt und jedem
seiner Endpunkte einen Knoten des Graphen zuordnet. Die zugeordneten Knoten heißen
Eingangs− bzw. Ausgangsknoten des Konnektors.
Ein einfaches Beispiel eines Und−Oder−Graphen ist durch die folgende Graphik gegeben:
A
U
V
Der Graph besteht aus den Knoten A, U und V, sowie aus einem einzigen Konnektor, dessen
Anfangspunkt dem Knoten A (Eingangsknoten des Konnektors) und dessen Endpunkte den
Knoten U bzw. V (Ausgangsknoten des Konnektors) zugeordnet sind.
Darstellung von Oder−Kanten:
A
U
V
Der Graph enthält zwei Oder−Kanten, d.h. zwei Konnektoren.
Der Unterschied in der Darstellung zwischen Und−Kanten und Oder−Kanten ist nur, daß
Und−Kanten eines Konnektors mit zusätzlicher Winkelmarkierung gekennzeichnet sind.
Wir interpretieren die vorausgegangenen Graphen wie folgt:
Interpretation Oder−Fall:
Ausgangsproblem ist lösbar entweder durch Lösen von U oder
durch Lösen von V.
Interpretation Und−Fall:
Ausgangsproblem ist lösbar durch Zerlegung in Teilprobleme U,
V und Lösung von beiden.
2
Wissensbasierte Systeme
Beispiel: Und−Oder−Graph
Graue Knoten bedeuten hier, daß diese eine ’Terminierungsbedingung’ erfüllen.
A
V
U
R1
W
Z
R2
X1
X2
Y1
Y2
Interpretation: Das Ausgangsproblem ist lösbar
− entweder durch Aufteilen von A in U und V,
V muß dann weiter aufgeteilt werden in R1, R2.
U, R1, R2 sind terminale Knoten, d.h. als gelöst erkenbar.
− oder durch Aufteilen in Z und W.
Z und W können durch Aufteilen in X1, X2 bzw Y1, Y2 gelöst werden.
X1,...,Y2 werden anschließend gelöst, d.h. sie terminieren.
Beispiel 1: Formelbehandlung
Ziel:
Auflösung der Produkte von Trigonometrischen Funktionen.
Ergebnis soll nur noch Summe einzelner Trig. Funktionen sein
Transformationsregeln:
(1)
sin a sin b = 1/2(cos(a−b) − cos(a+b))
(2)
cos a cos b = 1/2(cos(a−b) + cos(a+b))
(3)
sin a cos b = 1/2(sin(a−b) + sin(a+b))
Graph:
3
Wissensbasierte Systeme
sin a sin b cos c
(1)
(3)
(1)
1 cos(a−b) cos c
2
(3)
− 1 cos (a+b) cos c
2
(2)
1 cos(a−b−c) + 1
4
4
cos(a−b+c)
1 sin a sin(b−c)
2
1 sin a sin(b+c)
2
...
...
(2)
1
1
− 4 cos(a+b−c) − 4
cos(a+b+c)
Beispiel 2: Symbolische Integration
Integrationsregeln (Substitution etc.) liefern Kanten, entlang denen das Grundproblem
transformiert werden kann.Terminale Knoten sind z. B.Teilausdrücke, für die ein
unbestimmtes Integral bekannt ist.
Beispiel 3: Montagefolgen
Gegeben:
CAD−Beschreibung des Endprodukts und aller Einzelteile, d.h. fertiges
Produkt
Gesucht:
ist auch gegeben.
Die Folge von Operationen zum Zusammensetzen des Endprodukts aus seinen
Teilen.
Ansatz:
Suche ausgehend vom Endprodukt eine Folge zur Zerlegung in Teilgruppen,
dann Folgen zur Zerlegung der Teilgruppen etc.
Teile:
Deckel
Schraube1
Behälter
Fracht
Schraube2
Terminierungsbedingung: Alle Knoten für Teilgruppen bestehen aus genau einem Teil.
Montagegraph:
4
Wissensbasierte Systeme
Schraube2
Schraube1
Deckel
Behälter
Fracht
Nun vervollständigen wir das Modell der Problemlösung mit Und−Oder−Graphen. Wir
zeichnen im Graphen einen (eine Menge von) Startknoten aus, der (die) das zu lösende
Problem darstellt. Wir zeichnen außerdem eine Menge von Knoten als Zielknoten aus, die die
gelösten Probleme darstellen. Denken wir uns zudem eine Markierung im Startknoten. Sie
wird benutzt, um den eingeschlagenen `Weg´ zur Lösung des Problems darzustellen. Eine
Markierung bzw. die Markierungen können nun in der folgenden Weise durch den Graphen
propagiert werden:
Eine Markierung wird in einem Knoten gelöscht, wenn für genau einen Konnektor des
Knotens alle seine Ausgangsknoten markiert werden.
Definition: Das Problem ist dann gelöst, wenn alle Markierungen in die Zielknoten propagiert
sind.
Der Weg, den die Markierung durchläuft, kann in diesem Fall mit den Begriffen Pfad bzw.
Weg als Folgeaufeinanderfolgender Kantenˆ erfaßt werden. Bei einem Und−Graphen werden
im allgemeinen mehrere Markierungen produziert.
5
Wissensbasierte Systeme
Suchbäume und Lösungsgraphen
Ein `Und−Oder−Suchbaum´ ist ein Und−Oder−Baum, der zu einem Graphen G konstruiert
werden kann. Ein Suchbaum stellt alle möglichen `Wegdurchläufe´ durch einen Graphen
ausgehend von einem Startknoten, a.a., jede mögliche Propagierung von Markierungen durch
einen Graphen dar. Ein Suchbaum stellt auch mehrfache Durchläufe von Schleifen im
Graphen dar.
Ein Und−Oder−Graph ist ein Und−Oder−Baum, falls der Trägergraph des Graphen ein Baum
ist. Wir nehmen nun einen beliebigen Und−Oder−Graphen G als gegeben an. In G sei ein
Knoten S ausgezeichnet. Wir bezeichnen S als Startknoten.
Definition: Ein Und−Oder−Baum SB zusammen mit einer Abbildung spur, die alle Knoten
von SB in Knoten von G und alle Konnektoren von SB in Konnektoren von G abbildet, heißt
vollständiger Suchbaum zum Startknoten S in G, falls die Abbildung spur die folgenden
Eigenschaften besitzt:
− der Wurzelknoten W von SB wird durch spur in den Startknoten abgebildet, d.h.
spur(w)=S,
− jedem Knoten X von SB sind gleich viele Konnektoren zugeordnet wie dem Knoten
spur(X),
− für
jeden Eingangsknoten E eines Konnektors x von SB ist spur(E) der
Eingangsknoten von spur(x),
− für jeden Konnektor x in SB hat spur(x) gleich viele Kanten wie x,
− wenn A1, A2, ... , An die Ausgangsknoten eines Konnektors x sind, dann sind
spur(A1), spur(A2), ... , spur(An) die Ausgangsknoten von spur(x).
Die Abbildung spur wird üblicherweise als Knotenbezeichnung für Knoten des Suchbaums
realisiert, falls benötigt können auch die Konnektoren des Suchbaums bezeichnet werden. Die
Bezeichnungen sind gerade die Bildknoten bzw. Bildkonnektoren in G. Alle Bilder liegen in
einer einzigen Zusammenhangskomponente in G, nämlich in der, die durch den Startknoten
6
Wissensbasierte Systeme
festgelegt ist. Das Bild von SB unter spur bezeichnen wir als Spur oder Spurgraph von SB.
Der vollständige Suchbaum eines Graphen mit Schleifen hat i.a. unendlich viele Knoten.
Ausgehend vom Startknoten können aber stets beliebige endliche Teile des vollständigen
Suchbaums induktiv konstruiert und in einer geeigneten Datenstruktur dargestellt werden.
Jeder der in diesem Kapitel vorgestellten Algorithmen konstruiert gewisse Teile eines
vollständigen Suchbaums. Wir nennen diese Teile selbst wieder (Und−Oder−)Suchbäume.
Das Hinzufügen von Knoten und Konnektoren in Suchbäume nennt man expandieren von
Knoten des Graphen.
Bei Suchproblemen ist zu einem Startknoten auch eine Knotenmenge des Graphen G als
Menge der Zielknoten ausgezeichnet. Wir interessieren uns für Wegeˆdie vom Startknoten in
die Zielknoten führen. Alle Knoten des Suchbaums, die in Zielknoten des Graphen abgebildet
werden, nennen wir Zielknoten des Suchbaums.
Definition (Lösungspfad, Lösungsgraph): Ein Teilgraph P eines Und−Oder−Baumes SB
heißt Pfad, wenn P ein Und−Baum ist, also ausschließlich Und−Knoten besitzt und ein Baum
ist. Die Wurzel von P heißt Anfangsknoten und die Blätter des Baumes heißen Endknoten des
Pfades. Ein Pfad P heißt Lösungspfad von SB, wenn der Anfangsknoten von P gleich der
Wurzel von SB ist, die Endknoten von P alle Zielknoten sind und P keine anderen Zielknoten
enthält als die Endknoten. Die Spur eines Lösungspfades heißt Lösungsgraph.
Beispiel 4: Lösungsgraph
Graph G:
N0
h(N1) = 2
N1
h(N0) = 0
h(N2) = 4
h(N4) = 1
N2
N4
h(N3) = 4
h(N5) = 1
N3
N5
h(N6) =2
N6
h(N8) = 0
N7
N8
h(N7) = 0
Die beiden Kanten (N0,N4) und (N0,N5) bilden einen Konnektor. Die Beschriftungen werden
später benötigt.
7
Wissensbasierte Systeme
Lösungsgraph L1 (von N0 nach Z = {N7, N8}) :
N0
N1
N3
N5
N6
N8
N7
Lösungsgraph L2:
N0
N4
N5
N8
N7
Beispiel 5: Lösungsgraph zum Montageproblem (Beispiel 3)
8
Wissensbasierte Systeme
Schraube2
Schraube1
Deckel
Behälter
Fracht
Beim Expandieren eines Knotens müssen alle möglichen Bewegungsrichtungen lokal
betrachtet werden.
Behälter
Lokale Bewegungen
der Fracht
Fracht
Ausgehend vom
Endprodukt
wird
die Teilgruppe
T
gewählt und
die lokalen
Bewegungsrichtungen berechnet. Dann wird für jede lokale Bewegungsrichtung geprüft, ob
Teilgruppe T in dieser Richtung entfernbar ist (Kollisionserkennungsproblem). Falls ja,
entsteht Und−Konnektor mit zwei Kanten, die zwei Kanten zeigen auf die Teilgruppen T und
Rest−T (−> Zerlegung des Ausgangsproblems). Behandle die neuen Teilgruppen in der
gleichen Weise.
Bestimmung von Lösungsgraphen
Da der Trägergraph eines Und−Oder−Suchbaums selbst ein Baum ist, kann man diesen
Suchbaum grundsätzlich mit den gleichen Verfahren aufbauen wie bei gerichtete Graphen.
Man muß allerdings gewisse Nebenbedingungen erfüllen, insbesondere werden die
9
Wissensbasierte Systeme
Abbruchbedingungen
bei
der
Suche
nach
Lösungsgraphen
komplexer.
Beim
Breitensuchverfahren wird der Baum wieder schichtenweise erzeugt:
− Expandieren eines Knotens wie bei Breitensuche in gewöhnlichen Graphen, d.h.,
alle Nachfolger entlang aller ausgehenden Konnektoren werden im Suchbaum
erzeugt
− Prüfung der Terminierungsbedingung im Suchbaum nach jeder Expansion.
Das folgende Beitensuchverfahren ist auf alle Und−Oder−Graphen anwendbar. Falls ein
Lösungspfad existiert, terminiert das Verfahren und liefert einen Suchbaum, in dem ein
Lösungspfad enthalten ist. Die Datenstruktur für den Suchbaum muß die Möglichkeit
gestatten, für jeden Knoten zu markieren, ob er gelöst ist. Ein Knoten P heißt dabei gelöst,
wenn ein Lösungspfad von P zum Ziel existiert.
Prozedur (einfache) Und−Oder−Breitensuche:
1. Initialisiere Liste L von Baumknoten. L enthält nur den Startknoten S.
Solange Ende noch nicht erreicht, wiederhole:
2. Setze P := erstes Element von L.
Prüfe, ob S gelöst ist.
Falls ja, Ende.
Prüfe, ob L leer ist. Falls ja, Ende.
Lösche erstes Element in L.
(a) Expandiere P. Füge alle neuen
Knoten ans Ende von L an.
(b) Aktualisiere den Suchbaum.
Die Expansion in Schritt 2 a erzeugt also in der Datenstruktur des Suchbaums für alle
Konnektoren eines Knotens P alle Ausgangsknoten:
− Mit jedem Knoten wird eine Liste der ausgehenden Konnektoren gespeichert.
− Zusätzlich: Zeiger auf Vorgänger im Baum
Aktualisierung des Suchbaums:
Sind alle Knoten in einem Konnektor gelöst (erfüllen Terminierungsbedingung),
markiere gesamten Knoten als gelöst und reiche dies an Baumvorgänger weiter.
10
Wissensbasierte Systeme
Prüfe dort, ob alle Knoten im Konnektor gelöst sind, und reiche das ggf. weiter
Das einfache Breitensuchverfahren terminiert nicht immer, z.B. dann nicht, wenn Schleifen
existieren, aus denen Markierungen prinzipiell nicht eliminiert werden können, wie bei Und−
Graphen mit Schleifen außerhalb der Zielknoten, oder wenn gar keine Zielknoten in der
Zusammenhangs−komponente des Startknotens liegen. Um auch in diesen Fällen eine
Terminierung zu gewährleisten, muß man eine Schleifenbehandlung vorsehen oder ein
Abbruchkriterium aus einer Abschätzung der maximalen Tiefe eines Lösungspfades angeben.
Beides ist für beliebige Und−Oder−Graphen möglich (−> Übung).
Falls das Verfahren erfolgreich terminiert, kann man aus dem Suchbaum mindestens einen
Lösungspfad berechnen, indem man vom Startknoten aus einen Lösungspfad entlang von
gelösten Konnektoren verfolgt. Dies braucht an Oder−Knoten des Suchbaumes nicht eindeutig
zu sein.
Kostenfunktionen, Schätzfunktionen, das AO*−Verfahren.
Der Übergang von ungewichteten Gaphen zu gewichteten Graphen eröffnete bereits in Kapitel
2 die Möglichkeit zur Verfeinerung des Breitensuchverfahrens. Bei Und−OderGraphen ist
dies nicht anders. Der Ansatz für die Gewichtung von Und−Oder−Graphen ist die Angabe
einer Kostenfunktion, die die Kosten der Expansion eines Knotens bzw. eines Konnektors
angibt. Daraus ergeben sich dann die Kosten eines Lösungspfades:
c(K) bezeichne Kosten der Expansion eines Konnektors K des Und−Oder−Graphen.
Einem Knoten N eines Lösungspfades des Suchbaums können nun die Summe der Kosten
aller Konnektoren, die nach dem Knoten N bis zu den Zielknoten auftreten, zugeordnet
werden. Wir bezeichnen diese Summe als Kosten des Knotens N, i.Z. k(N). Die Berechnung
verläuft rekursiv wie folgt:
Liegt N im Ziel Z, dann gilt:
k(N) = 0.
Andernfalls gibt es genau einen (ausgehenden) Konnektor von N mit Ausgangsknoten N1, ...,
Ni und die Kosten von N sind:
k(N) = c(N) + k(N1) + ... + k(Ni)
11
Wissensbasierte Systeme
Wir betrachten nun wieder das Problem, in einem gewichteten Graphen, in dem Start und
Zielknoten angegeben sind, einen Lösungspfad zu finden, der minimale Kosten verursacht.
Wir setzen auch gleich voraus, daß wir eine Schätzfunktion h zur Verfügung haben, die die
minimalen Kosten eines Lösungspfads von einem einzelnen Knoten aus brauchbarˆ abschätzt.
h(N) gibt die geschätzten Kosten des besten Lösungspfads von N zum Ziel Z an.
Die Lösung des Problems liefert das `AO*−Verfahren´.
Prinzip:
− Zu jedem Knoten kann Schätzwert der ’Restkosten’ berechnet werden, das sind die
geschätzten Kosten der Lösung dieses Knotens relativ zum bisherigen Baum.
− Bisherige Kosten werden akkumuliert und liefern eine Entscheidungsgrundlage für
die Wahl des nächsten zu expandierenden Knoten. Dazu ist eine
Kostenpropagation notwendig, die (anders als bei A*) rückwärts durch den
ganzen Baum zum Start erfolgen muß.
Algorithmus AO*
Der wesentliche Unterschied des AO*−Verfahrens gegenüber dem A*−Verfahren ist, daß bei
Und−Oder Graphen die Lösungspfade i.a. mehr als einen Endknoten haben. Deshalb können
die Kosten eines vom Startknoten ausgehenden Lösungspfades nicht mehr einem Endknoten
zugeordnet werden. Den Ablauf der Kostenpropagation verfolgen wir zuerst in
Beispielgraphen.
In dem folgenden Beipielgraphen sind die Knoten X mit Schätzwerten h(X) versehen. Die
Kanten haben alle das Gewicht 1.
S
h(A) = 2
A
h(S) = 0
B
h(B) = 2
D
h(D) = 3
E
...
12
...
h(E) = 5
C
h(C) = 3
Wissensbasierte Systeme
Schritt 1: Expandiere S
Markierung
h(A) = 2
S
A
h(S) = 0
B
h(B) = 2
C
h(C) = 3
a)
Kette alle Nachfolger von S in Suchbaum ein
b)
Aktualisiere Kosten k(S), wo k(S) = Kosten des Teilgraphen entlang des
günstigsten Konnektors ausgehend von S ist.
Hier:
c)
k(A) = 1 + h(A) = 3.
Markiere den günstigsten Konnektor.
Schritt 2:
a)
Expandiere Graph entlang des aktuell günstigsten (jetzt markierten)
Konnektors
S
h(A) = 2
A
h(S) = 0
B
h(B) = 2
D
h(D) = 3
b)
c)
C
h(C) = 3
E
h(E) = 5
Aktualisiere Kosten des neu expandierten Knotens A
k(A)alt
= h(A),
k(A)neu
= 1 + 1 + h(D) + h(E) = 10.
Kostenpropagation: Aktualisiere jetzt Kosten von S
k(S)alt = 1 + h(A)
k(S)neu
= 1 + k(A)neu = 11
Prüfe, ob der zuvor markierte günstigste von S
13
Wissensbasierte Systeme
ausgehende Konnektor (hier S−A) immer noch günstigster von S ausgehender
Konnektor ist. Hier:
Nach Neuberechnung von k(A) wird Konnektor S−(B und C)
günstiger als S−A
−> Wechsle Markierung
d)
Entscheide, ob neu eingefügte Knoten gelöst sind. Falls ja,
Aufwärtspropagation, der Eigenschaft `ist gelöst´.
Wir geben im folgenden eine Variante des A*−Algorithmus zur Berechnung eines bestenˆ
Lösungsgraphen an. Wie schon beim Breitensuchverfahren ist eine Schleifenbehandlung nicht
zwingend notwendig, d.h., wir erhalten auch in Graphen mit Zyklen einen Lösungsgraphen,
sofern ein solcher überhaupt existiert. Wir benötigen aber eine andere Datenstruktur als die,
die wir für den A*−Algorithmus vorgesehen hatten.
Datenstruktur Suchbaum:
Vorwärts− und Rückwärts verzeigerte Liste von Knoten.
Vorwärtsverzeigerung:
zu Knoten P eine Liste aller von P ausgehenden
Konnektoren.
Rückwärtsverzeigerung:
Vorgänger von P im Suchbaum.
Datenfelder für k(P) und h(P).
Knotenliste L:
Liste aller (offenen) Blattknoten.
Prozedur AO*
1. L = {S}
2. Solange noch nicht Ende, wiederhole:
a)
falls S gelöst oder L leer −> Ende.
b)
Expandiere ersten Knoten P in L, füge
Nachfolger X1,...,Xn von P in L ein.
Setze k(Xi) = h(Xi); lösche P aus L.
c)
Propagiere Kosten aufwärts im Suchbaum:
Für P:
14
Wissensbasierte Systeme
Sei (Xi1 und Xi2 und ... Xik) günstigster von
P ausgehender Konnektor, c Kosten der Kanten in diesem
Konnektor.
Dann:
k
(P) = c + h(Xi1) + ... + h(Xik)
neu
Für Vorgänger von P: ersetze überall k
(P) durch k
alt
d)
Propagiere Markierungen
c)
Propagiere Terminierungsbedingung
e)
Sortiere L so, daß Blattknoten im markierten
(P).
neu
Teilbaum vorne stehen.
Sonderfälle: Falls der neu zu expandierende Knoten P nicht gelöst ist und keine Nachfolger
hat, dann ist ein Teilbaum nicht lösbar und muß im Suchbaum als unlösbar markiert werden.
Beachte: Die obige Prozedur enthält noch keine dynamische Programmierung, d.h. es wird
bei Epansion nicht festgestellt. ob irgendwo im Baum schon ein Knoten existiert, der die
gleiche Bezeichnung eines Graphknoten hat, aber in einem anderen Oder−Zweig des Baumes
steht. Wie schon erwähnt, enthält die Prozedur auch noch keine Schleifenbehandlung.
Außerdem geht man bei diesem Algorithmus davon aus, daß in einem Lösungspfad mehrfach
auftretende Knoten stets neu berechnet werden und die Kosten dafür entsprechend mehrfach
gezählt werden (Kreuzungen in Lösungspraphen).
Der AO*−Algorithmus hängt wesentlich von den Eigenschaften der Schätzfunktion h ab.
Analog wie bei A*−Algorithmen muß man die Zulässigkeit der Funktion h voraussetzen. Wir
erhalten die Zulässigkeit von h durch ein hinreichendes Kriterium, nämlich die Geltung der
`Monotonierestriktion´.
Satz: Das AO*−Verfahren ist zulässig, falls die Monotonierestriktion erfüllt ist und h(T) = 0
für alle gelösten Knoten gilt. Dabei gilt die Monotonierestriktion für Und−Oder Graphen, falls
gilt:
h(V) <= c + h(N1) + ... +h(Nn) für alle von V ausgehenden Konnektoren, wobei
N1,...,Nn die Nachfolger von V in einem Konnektor seien.
15
Wissensbasierte Systeme
Ein Beispiel für die Zulässigkeit erhalten wir aus Beispiel 4.
Beispiel 7: Zulässigkeit
N0
h(N1) = 2
h(N0) = 0
h(N2) = 4
N1
h(N4) = 1
N2
N4
h(N3) = 4
h(N5) = 1
N3
N5
h(N6) =2
N6
N7
N8
h(N8) = 0
h(N7) = 0
Notation: N−(X und Y) bezeichnet den Und−Konnektor von einem Knoten N zu den Knoten
X, Y
Monotonierestriktion:
Ist erfüllt: Prüfe alle Konnektoren, etwa für den Konnektor N0−(N4 und N5);
h(N0)<= 2 + h(N4) + h(N5)
Zulässigkeit: h<= h*. Man prüft dies über die Bestimmung der besten Lösungsgraphen für
jeden Knoten.
Im folgenden bezieht sich die Numerierung der Schritte auf Durchläufe der Schleife 2. in
AO*.
Schritt 1:
N0
h(N0) = 0
k(N0) = 3
k(N4) =h(N4) = 1
N1
N4
k(N1) =h(N1) = 2
k(N5) = h(N5) = 1
Schritt 2:
N5
Markierung wechselt von N0−N1 nach N0−(N4 und N5)
16
Wissensbasierte Systeme
h(N0) = 0
k(N0) = 4
N0
h(N1) = 2
k(N1) = 5
h(N4) = 1
N1
N2
N4
h(N2) = 4
N3
N5
h(N3) = 4
h(N5) = 1
Schritt 3:
h(N0) = 0
k(N0) = 4
N0
h(N1) = 2
k(N1) = 5
h(N4) = 1
N1
N2
h(N2) = 4
N4
h(N5) = 1
k(N5) = 2
N3
N5
gelöst
h(N3) = 4
N6
h(N6) = 2
N8
h(N8) = 0
h(N7) = 0
N7
gelöst
gelöst
Schritt 4:
N0
h(N1) = 2
k(N1) = 5
h(N0) = 0
gelöst
k(N0) = 4
h(N4) = 1
k(N4) = 1
N4 gelöst
N1
h(N2) = 4
N2
h(N5) = 1
k(N5) = 2
N3
N5
gelöst
h(N3) = 4
h(N6) = 2
N6
h(N8) = 0
h(N7) = 0
Ziel:
N7
N8
gelöst
gelöst
Der Markierte Graph (ausgehend von S) ist bester Lösungsgraph für S.
Spielbäume
Die bekanntesten speziellen Und−Oder−Graphen sind Spielbäume. Sie bilden die Basis von,
beispielweise, Schachprogrammen. Es werden hier spezielle Suchverfahren angewendet, z.B.
das Minimax−Verfahren oder das Alpha−Beta−Verfahren. Wir kommen damit zu einer
Alternative der Verfahren im vorausgegangenen Kapitel, wo Gewichte als Summen berechnet
17
Wissensbasierte Systeme
wurden. Den nun folgenden Verfahren liegt im Gegensatz zu jenen eine Gewichtung als
Maximumsbildung zugrunde.
Den Spielen soll (wie beim Schach) die folgende Situation zugrunde liegen:
Es gibt zwei Spieler, die Spieler heißen Max und Min.
Jeder Spieler besitzt die vollständige Information über die Zugmöglichkeiten des ^
Gegners.
Gesucht ist eine bestimme Strategie, die garantiert, daß Max immer gewinnt. (Beim
Schach wäre das, falls berechenbar, die Strategie des Programms.)
Die Und−Oder Graphen, die im Zusammenhang mit Spielen auftreten, haben eine spezielle
Gestalt. Bisher betrachteten wir den allgemeinen Fall, daß ein Knoten mehrere beliebige
Konnektoren hat. Nun aber treten Graphen auf, deren Knoten entweder einen einzigen
Konnektor mit i.a. mehreren Kanten besitzt oder aber mehrere Konnektoren mit je einer
Kante besitzt.
Bei Schachprogrammen werden Suchbäume berechnet. Der Wurzelknoten stellt die
Anfangsstellung, ein beliebiger Knoten eine beliebige Zwischenstellung im Spiel dar. Zu
bestimmen ist der günstigste Zug. Die Nachfolger von Knoten sind alle in dieser Stellung
möglichen Züge.
Züge des Programms
S
a
b
Züge des
Gegenspielers
Um zu entscheiden, ob Zug a für das Programm besser ist als Zug b müsste der gesamte
Baum ausgehend von der Startstellung untersucht werden. Wenn man für Schach folgende
Annahmen macht
− nur 16 mögliche Züge werden an jeder Stelle betrachtet
18
Wissensbasierte Systeme
− insgesamt kann jedes Spiel mit 100 Zügen beendet werden.
Dann ergibt der Baum mit Tiefe 100 und Verzweigungsfaktor 16 etwa 16100 Knoten und
10120 Blattknoten. Deshalb werden Bewertungsfunktionen für Stellungen benutzt. Der Baum
wird ausgehend von gegebener Stellung nur bis zu einer festen Tiefe entwickelt. Die
Bewertungsfunktion wird dann nur für Blattknoten aufgerufen.
Programm
S
b
a
Gegner
f=3
f= 7
f= 0
f= 8
Die Bewertungsfunktion f liefert den (geschätzten) maximalen (für das Programm
günstigsten) Wert im b−Zweig. Ist deshalb hier Zug b der Bessere? Das sogenannte
Minimax−Verfahren sagt: Nein! b ist der falsche Zug für das Programm, denn nach
Ausführung von b ist der Gegner am Zug. Der Gegner kann aber von hier aus immer eine
Stellung mit f−Wert 0 erreichen, was für Max Verlust des Spiels bedeutet. Von a aus kann der
Gegner schlimmstenfalls f−Wert 3 erreichen.
Die f−Werte von A und B sind also:
f(A) = Min{f(X1), f(X2)},
f(B) = Min{f(Y1), f(Y2)}
und es gilt
f(S) = Max{f{A},f(B)} = Max{ Min{f(X1), f(X2)}, Min{f(Y1), f(Y2)}} = 3.
Lösungsgraph (für Max): Graph, der ausgehend vom Start stets zum terminalen Knoten führt.
Für Schach ist eine vollständige Berechnung eines solchen Graphen nicht möglich. Deshalb
wird bei Schachprogrammen die Berechnung des Suchbaumes oder Lösungsgraphen nur bis
zu einer bestimmten Suchtiefe durchgeführt und dann für die `Restabschätzung´ die
Bewertung der Blattknoten verwendet. Der Ansatz für ein Verfahren lautet: Ausgehend von
19
Wissensbasierte Systeme
aktueller Stellung wird der Und−Oder−Suchbaum durch ein bewertendes Suchverfahren
expandiert.
Beispiel: Minimax mit Suchtiefe 2
Max
Min
2
7
1
8
Max
Wie man sieht, hat der Suchbaum eine spezielle Gestalt. In Startstellung (Baumtiefe 0) ist
Max am Zug, also hat die Ebene 0 im Baum nur Oder−Kanten. Auf Tiefe 1 ist Min am Zug,
also gibt es auf Ebene 1 nur Und−Konnektoren als Nachfolger von Knoten. Auf Tiefe 2 ist
wieder Max am Zug, also gibt es nur Oder−Kanten. Die Bewertungsfunktion f bewertet
Spielstellungen. Max versucht, eine Stellung mit hohem Wert für f zu erreichen. Min
versucht, eine Stellung mit niedrigem f−Wert zu erreichen. Wir leiten daraus das Minimax−
Verfahren ab.
Ansatz für Minimax−Verfahren:
Expandiere Baum bis Suchtiefe m.
Rufe dann f für alle Blattknoten auf.
(D.h. f wird nie für Knoten mit Baumtiefe < m direkt aufgerufen! Für alle
Knoten mit Baumtiefe <m wird f nur durch Aufwärtspropagation berechnet)
Propagiere f−Wert im Baum nach oben nach folgendem Schema
Ist X auf Ebene m−1, und ist m−1 eine Min−Ebene,
dann setze f(X) = Min{f(X1),...,f(Xn)}, X1,...,Xn sind die Nachfolger von X.
(D.h. X1,.., Xn sind auf Ebene m, und f(Xi) wurde direkt berechnet).
Ist m−1 Max Ebene, dann f(X) = Max{f(X1),...,f(Xn)}
Ist f−Wert bis Tiefe m−k schon berechnet,
dann bestimme f−Wert als Minimum bzw. Maximum der f−Werte von
Nachfolgern auf Stufe m−(k−1)
Im Beispiel:
20
Wissensbasierte Systeme
S
Max
X
X1
2
Y
X2
7
Y1
1
Min
Y2
8
Max
Durch Ausführen von Zügen wird der Baum von S ausgehend (S ist auf Ebene 0) bis Ebene 2
expandiert. Die Stellungen X1, X2, Y1, Y2 werden direkt bewertet (Bewertung einer
Spielstellung z.B. als gewichtete Summe von Gesamtzahl der schwarzen Figuren, Anzahl der
bedrohten weißen Figuren, etc.). Für Stellung X ist dann f(X) = Min{2,7} = 2. Analog erhält
man f(Y) = 1
Ergebnis:
f(S) = Max{f(X), f(Y)} = 2.
2 ist der sogenannte Minimax−Wert in diesem Fall.
Interpretation:
Max wählt immer den besten Zug.
Min wählt immer den (für Max!) schlechtesten Zug.
Max erhält durch Berechnung die Information, in welchem Ast die
bestmögliche Stellung liegt, unter der Hypothese, daß Min (nach der
gleichen Strategie wie Max) immer den (für Max) ungünstigsten Zug
tatsächlich ausführen wird.
Minimax−Verfahren
Die Umsetzung des obigen Ansatzes führt zum folgenden Minimax−Verfahren.
function minimax(K : Knoten) : integer; (* liefert f(K) *)
var m, m1 : integer;
begin
Expandiere K, liefert Liste (X1,...,Xn) der Nachfolger
If Ebene(K) = Blattknoten
return Bewertung(K)
Else
if Ebene(K) = Max
m1 := − maxint;
for i := 1,...,n
21
von K
Wissensbasierte Systeme
m := minimax(Xi);
if m > m1 then m1 := m
Else (* Ebene(K) = Min *)
m1 := maxint;
for i := 1,...,n
m := minimax(Xi);
if m < m1 then m1 := m
return m1
end
Beispiel: Tic−Tac−Toe mit Minimax−Verfahren
Situation:
Max und Min plazieren abwechselnd Scheiben auf einem 3x3 Spielfeld. Beide
Spieler versuchen, eine Dreierreihe (−Spalte oder Diagonale) ihrer Farbe zu erzeugen.
(Statt Farben verwende Zeichen ’X’ für Max, ’O’ für Min)
Bewertungsfunktion:
Anzahl Zeilen, Spalten, Diagonalen, die Max noch ganz besetzen kann minus Anzahl Zeilen,
Spalten, Diagonalen, die Min noch ganz besetzen kann.
Baum für Suchtiefe 2:
Max
bester Zug
Min
x
o
x
x
x
x
o
o
f=0 1
x
x
o
0
o
−1
o
x
x
−1
o
0
x
x
o
−1
x o xo
ox
−2
2
0
o
x
1
f = 6−5=1
Ob das Minimax−Verfahren den Lösungsbaum findet, hängt wesentlich von der
Bewertungsfunktion ab. Das Problem bei der Anwendung des Minimax−Verfahrens ist also
die Angabe der Bewertungsfunktion. Das folgende Beispiel mag dies illustrieren.
22
Wissensbasierte Systeme
Beispiel: Schach (Seymore/Norwood 1993)
Weiss am Zug: Das Schachprogramm Deep−Thought nimmt den Turm. Dies bedeutet aber
eine sichere Niederlage für Weiss, obwohl die Stellung für Weiss ein sicheres Remis
garantiert.
Das Alpha−Beta−Verfahren
Das Minimax−Verfahrens läßt sich für bestimmte Klassen von Anwendungen effizienter
gestalten, wenn man versucht, die Anzahl der zu expandierender Knoten zu reduzieren. Dies
geschieht beim Alpha−Beta−Verfahren. Wir betrachten zunächst ein Beispiel.
S
Max
X
X1
2
Y
X2
7
Y1
1
Min
Y2
8
Max
Idee:
Die Idee des Alpha−Beta−Verfahrens ist, daß zur des Minimax−Wertes nicht jeder
Blattknoten im obigen Baum betrachtet werden muß. Es muß also nicht jeder Knotenwert
berechnet werden (Reduktion des Suchbaums). Im Beispiel sei die Berechnung der f−Werte
23
Wissensbasierte Systeme
bereits für Knoten X1, X2 und für Y1 erfolgt. Dann braucht Knoten Y2 nicht mehr betrachtet
zu werden, weil man auch ohne Berechnung von Y2 weiß, daß das Minimum von Y1 und Y2
und damit der Wert von Y jedenfalls kleiner oder gleich 1 ist. Dann scheidet aber der Y−
Zweig als Kandidat für einen Zug aus, weil X bereits den Wert 2 besitzt und der Wert von S
das Maximum der Werte von X und Y ist (flaches Abschneiden). Die Gleiche Idee kann auch
bei Bäumen mit Tiefe >2 angewendet werden.
Verfahren:
Weise Max−Knoten Wert für alpha zu, alpha ist untere Schranke für f−Wert dieses Max−
Knotens. Weise Min−Knoten Wert für beta zu, beta ist obere Schranke für f−Wert dieses
Min−Knotens.
Unterscheide zwischen vorläufigen und endgültigen alpha− bzw. beta−Werten für Knoten.
Ein vorläufiger alpha−Wert für Max−Knoten X (beta−Wert für Min−Knoten X) kennzeichnet
eine Bewertung, die Max (Min) von X aus in jedem Fall schon erreichen kann. Ein
endgültiger alpha−Wert (beta−Wert) bezeichnet die Bewertung des für Max (Min) von X aus
günstigsten Zuges.
Initialisiere alpha mit −∞, beta mit +∞. Für den ganzen Baumdurchlauf ist stets der bisher
günstigste alpha−Wert und der bisher günstigste beta−Wert bekannt. Max versucht, diesen
alpha−Wert zu maximieren, Min versucht, beta zu minimieren.
Die Expandierung von Knoten und die Propagation von alpha− und beta−Werten gestaltet
sich wie folgt:
Expandiere Baum im Tiefensuchverfahren. Die Suchtiefe ist (wie bei Minimax−Verfahren)
fest vorgegeben. Für Blattknoten kann f−Wert direkt bestimmt werden. Sobald endgültiger
alpha− Wert für einen Knoten feststeht, reiche diesen Wert als vorläufigen beta−Wert an
unmittelbaren Vorgänger nach oben. Der neue beta−Wert ist dann das Minimum des
hochgereichten beta−Wertes mit dem alten beta−Wert. Umgekehrt: reiche endgültigen beta−
Wert als vorläufigen alpha−Wert an Baumvorgänger. Der neue alpha−Wert ist dann das
Maximum des hochgereichten alpha−Wertes mit dem alten alpha−Wert.
Reduktion des Suchbaums:
a) Flaches Abschneiden:
24
Wissensbasierte Systeme
X
Max
Min
X2
T1
...
T2
Nehmen wir an, daß Teilbaum T1, in dem Max in jedem Fall alpha=2 erreichen kann, bereits
untersucht wurde. Nun wurde Teilbaum T2 angetroffen, in dem Min in jedem Fall beta = 1
erreichen kann. Danngilt: Die Untersuchung weiterer Nachfolger von X2 kann abgebrochen
werden.
b) Tiefes Abschneiden:
X
Max
Min
10
Max
Y
...
Z
5
Min
W
Hier braucht W nicht mehr betrachtet zu werden.
Merke:
Die Propagation erfolgt immer nur um genau eine Stufe nach oben. Bei einer
Propagation wird stets der bisher günstigste alpha− bzw. beta−Wert propagiert. Es werden nur
endgültige Werte propagiert. Wenn eine Reduktion stattfindet, wird der bisher günstigste
alpha− bzw. beta−Wert nicht verändert, d.h. aber daß die propagierten Werte nicht immer
gleich dem f−Wert der Knoten sind, sondern nur dann, wenn dieser f−Wert günstiger als der
im bisherigen Baum erreichte günstigste Wert ist.
Beispiel: Propagation
X1, X2 seien Blattknoten
Fall 1: X ist Min−Knoten
a) Suche beginnt auf linkem Ast.
25
Wissensbasierte Systeme
Max
...
Min
Max
X
X1
2
X2
7
Rufe statische Bewertungsfunktion f für Blattknoten X1 auf, das liefert 2. Der f−Wert von X1
ist jetzt endgültiger alpha−Wert für X1. Propagiere diesen Wert nach oben zu X. Damit erhält
X den vorläufigen beta−Wert 2. Werte jetzt f(X2) aus. Der durchgereichte Wert ändert den
schon bestehenden Wert von beta nicht. Damit wird die Suche im zu X gehörigen Ast
abgeschlossen, und beta−Wert 2 von X wird endgültig.
Fall 2: X ist Max−Knoten
Analog zu Fall 1, aber jetzt wird das Maximum der f−Werte propagiert. Der vorläufige, bisher
günstigste alpha−Wert kann zur Laufzeit nie sinken.
Merke: alpha wird mit −∞ initialisiert und wächst monoton, beta wird mit ∞ initialisiert und
fällt monoton.
Wir haben in Beispielen zwei Varianten von Reduktionen des Suchbaums bereits
kennengelernt, nämlich flaches bzw. tiefes Abschneiden von Zweigen. Dies führt zu der
folgenden Idee:
Sei alpha mit −unendlich, beta mit +unendlich initialisiert. Dann kann die Suche in einem
Zweig abgebrochen werden, falls ein geeigneter Vergleich (für diesen Zweig) alpha >= beta
liefert.
Die folgenden Regeln für einen Vergleich bedeuten flaches Abschneiden.
Alpha−Beta−Regeln:
Betrachte Knoten V, N. V sei direkter Vorgänger von N im Baum. Ein Abbruch bei der
Untersuchung der Nachfolger von N erfolgt, falls
1. alpha(V) >= beta(X) für irgend einen direkten Nachfolger X von N (wenn V ein Max−
Knoten)
oder
26
Wissensbasierte Systeme
2. alpha(X) >= beta(V) für irgend einen direkten Nachfolger X von N (wenn V ein Min−
Knoten ist).
Alpha−Beta−Algorithmus
function ab(
K : Knoten; alpha, beta : integer) : integer;
var m : integer;
begin
Expandiere K, liefert Liste (X1,...,Xn) der Nachfolger von K;
if Ebene(K) = Blattknoten
return Bewertung(K)
else
if Ebene(K) = Max
for i := 1,...,n
m := ab(Xi, alpha, beta);
if m > alpha then alpha := m;
if alpha >= beta then return alpha
return alpha
else (* Ebene(K) = Min *)
for i := 1,...,n
m := ab(Xi, alpha, beta);
if m < beta then beta := m;
if alpha >= beta then return beta
return beta
end
{alpha und beta sind Werteparameter!}
Beispiel: Alpha−Beta−Regel 1
Vollständiger Baum:
27
Wissensbasierte Systeme
Min
S
X
...
Y
Max
...
X1
U1
2
X2
U2 V1
7
1
Y1
V2
8
Y2
W1 W2 Z1
2
9
7
Min
Z2
9
Schritt 1: Expandiere Baum im Tiefensuchverfahren entlang der linken Zweige bis zu U1.
S
X
Max
X1
U1
2
Min
Min
U2
7
X1 ist Min−Knoten, der endgültige beta−Wert für X1 ist 2. Damit wird der vorläufige alpha−
Wert von X auf 2 gesetzt.
Schritt 2: Expandiere X2 bis zu V1, liefert vorläufigen beta−Wert 1 für X2. Abbruch, da jetzt
alpha−v(X) >= beta−v(X2) (vorläufige alpha− bzw. beta−Werte), d.h. die Untersuchung der
Nachfolger von X2 wird beendet. beta−v(X2) wird zu beta−e(X2) = 1 (endgültiger beta−
Wert). Die Untersuchung der Nachfolger von X ist abgeschlossen. Damit ist alpha−e(X) = 2
und schließlich beta−v(S) = 2
Beispiel: Alpha−Beta−Regel 2
(Fortsetzung Beispiel zu Regel 1)
28
Wissensbasierte Systeme
Min
S
X
...
Y
Max
...
X1
U1
2
X2
U2 V1
7
1
Y2
Y1
V2
8
W1 W2 Z1
2
9
7
Min
Z2
9
Aufruf ab(Y,− ∞, 2) liefert beta−e = 2 für Y1, damit alpha−v = 2 für Y, also Abbruch. Y2 wird
nicht mehr untersucht.
Wegen der Möglichkeit des vorzeitigen Abbruchs liefert der Alpha−Beta−Algorithmus für
einen Knoten nicht notwendigerweise die gleichen endgültigen beta−Werte wie das Minimax−
Verfahren. Dazu ein
Beispiel:
S
beta−e = 1
Y
Min
X
X1
2
Max
X2
7
Y1
1
Y2
0
Max
Das Minimax−Suche würde den f−Wert 0 für den Knoten Y liefern. Alpha−Beta−Suche
liefert den endgültigen beta−Wert 1 für Y, findet aber trotzdem den gleichen Zug wie das
Minimax−Verfahren.
Beachte aber: Für den Wurzelknoten wird der gleiche Wert zurückgeliefert wie beim
Minimax−Verfahren.
Beispiel: Tic−Tac−Toe mit Alpha−Beta
29
Wissensbasierte Systeme
Max
x
Min
x
o
x
x
1
x
o
0
x
o
1
x
o
o
x
o
−1
0
x
−1
x
o
o
x
0
x o xo
ox
−2
2
−1
0
o
x
1
Wir übersetzen entsprechend die Bezeichnungen der Knoten:
Max
N0
Min
N1
N2
N4
N5
N6
N7
N8
N9
1
0
1
0
−1
−1
N3
N10 N11
N12
N13
N14
N15
2
1
−2
0
−1
0
N0
ab(N0,− ∞,∞)
Schritt 1:
Max
N1 ab(N1,− ∞,∞)
Min
N2
N4
N5
N6
N7
N8
N9
1
0
1
0
−1
−1
N3
N10 N11
0
N12
−1
N13
N14 N15
2
−2
0
1
ab(N4,− ∞,∞)=1
Aufruf ab(N1,− ∞,∞) wird umgesetzt in die Aufrufe
ab(N4,−∞, ∞), ab(N5,− ∞,1), ab(N6,− ∞,0), ab(N7,− ∞,0), ab(N8,− ∞,0).
ab(N4,− ∞,∞) terminiert mit ab(N4,− ∞,∞) =1. Genauso
ab(N5,− ∞,1) = 0, ab(N6,− ∞,0) = 1, ab(N7,− ∞,0) = 1, ab(N8,− ∞,0) = −1.
Damit terminiert ab(N1,− ∞,∞) mit ab(N1,− ∞,∞) = −1 und wir erhalten die folgende
Situation:
Max
Min
N0
N1
ab(N1,− ∞,∞) =−1
Untersuchung N4−N8
beendet
N2
N9
−1
30
ab(N0,− ∞,∞)
N3
N10 N11
0
−1
N12
0
N13
−2
N14
N15
2
1
Wissensbasierte Systeme
Dies führt zu dem Aufruf ab(N2,−1, ∞), der bereits nach Untersuchung von N9 terminiert mit
dem Ergebnis ab(N2,−1, ∞) = −1. alpha bleibt jetzt unverändert −1, und es wird ab(N3,−1, ∞)
aufgerufen. Der Aufruf ab(N3,−1, ∞) terminiert mit ab(N3,−1, ∞) = 1, d.h., der Gesamtaufruf
ab(N0,− ∞,∞) terminiert mit ab(N3,− ∞,∞) = 1. Die Knoten N10−N13 brauchten nicht
untersucht zu werden.
Definition: Baumtiefe = Anzahl der Kanten im längsten Pfad von einem Blattknoten zur
Wurzel (d.h. Baum bestehend aus nur dem Wurzelknoten hat Tiefe 0)
Wir untersuchen die Anzahl der zu berechnenden Knoten beim Alpha−Beta−Verfahren.
Baum mit Tiefe 1: Alle Knoten müssen untersucht werden
Binärer Baum mit Tiefe 2: 7 Knoten insgesamt, 6 müssen in jedem Fall untersucht werden
Baum mit Verzweigungsfaktor 3, Tiefe 2: 13 Knoten, 9 müssen untersucht werden
Der günstigste Fall tritt ein, wenn
(E)
der ’zuerst gefundene vorläufige alpha−Wert immer gleich dem später festgelegten
endgültigen alpha−Wert ist (und Analoges für beta gilt)’
Wir betrachten den allgemeine Fall für Baum mit Tiefe T = 2. Sei V der Verzweigungsfaktor.
Dann gibt es insgesamt V2 Blattknoten
Max
N0
ab(N0,− ∞,∞)
ab(N1,− ∞,∞) = 10
Min
ab(N3,10 ,∞)
N2 ab(N2,10 ,∞)
N1
10
10
10
9
N3
9
Das Alpha−beta−Verfahren untersucht 2V−1 Blattknoten, falls Eigenschaft (E) gilt. D.h., die
Knotenzahl wächst quadratisch, die Zahl untersuchter Knoten wächst nur linear, falls (E) gilt.
31
Wissensbasierte Systeme
Für den allgemeine Baum mit Tiefe T = 3 ist V3 die Anzahl der Blattknoten. Im Fall (E)
werden aber nur V 2 + V − 1 Blattknoten untersucht:
Min
N0
ab(N0,− ∞,∞)
ab(N1,− ∞,∞) = 4
Max
ab(N3,− ∞,4)
N1
N2 ab(N2,− ∞, 4)=5
N3
Min
4 4 4 3
3
5 5 5
5 5 5
Im Fall V = 3 werden 11 von 27 Knoten untersucht. Allgemein gilt:
Im Fall (E) erlaubt alpha−beta−Verfahren gegenüber Minimax eine Verdoppelung der
Suchtiefe.
Das S*−Verfahren
Beim Alpha−Beta−Algorithmus tritt der günstigste Fall ein, falls die Eigenschaft (E) gilt. Man
kann nun versuchen, das Verfahren so zu steuern, daß die Gültigkeit dieser Eigenschaft
angestrebt wird, indem man immer diejenigen Knoten expandiert, die in dem derzeit
günstigsten Teilbaum liegen. Damit erhält man das S*−Verfahren. Das S*−Verfahren ist ein
Spielbaumverfahren ähnlich wie AO*. Die Bewertung der Knoten ist gleich wie beim
Minimax−Verfahren. Die Steuerung erfolgt nach dem Best−First Prinzip, d.h. die Knoten im
jeweils `günstigsten´ Teilbaum werden expandiert. Wir passen die Definition des
Lösungsbaums an die jetzige Situation an, insbesondere definieren wir den Lösungsbaum aus
der Sicht von Max. Im folgenden sei der Wurzelknoten immer ein Max−Knoten.
Definition Lösungsbaum (für Max): Ein Lösungsbaum ist ein Teilbaum, in dem zu jedem
nicht−terminalen Max−Knoten genau ein Nachfolger, und zu jedem nicht−terminalen Min−
Knoten alle Nachfolger gehören.
Beispiel: Lösungsbaum
40
4
32
10
80
Wissensbasierte Systeme
Notation: Max−Knoten mit Viereck, Min−Knoten mit Kreis.
Zur Bestimmung eines `besten´ Lösungsbaums mit dem S*−Verfahren werden Knoten immer
entlang des besten Teilbaums expandiert, bis ein kompletter Lösungsbaum gefunden wurde.
Dieser Lösungsbaum ist (wie bei AO*) dann auch der beste.
Definitionen:
W
2
1
1.1
4
1.2
2
2.1
1
2.2
8
Notation: Nachfolger von Knoten 1 heißen 1.1 und 1.2 etc.
Knoten haben zwei Zustände:
−Lebend (in Liste OFFEN)
−Gelöst (auch in OFFEN)
h−Funktion gibt Bewertung der Knoten an.
Zustandsbeschreibung für Knoten in Liste OFFEN:
(Name, Lebend | Gelöst, h)
S*− Algorithmus
1. Füge Startknoten (S, Lebend, ∞) in OFFEN ein
2. Wiederhole
a. Lösche Knoten K mit höchstem h−Wert aus OFFEN
b. Falls Zustand(K) = Gelöst und K = S Ende
c. Expandiere K mit Operator EXP
Definition Operator EXP:
Eingabe: (K, z, h)
K hat Nachfolger K.1,...,K.n
f(K) statische Bewertung für terminale Knoten
Fall 1: Zustand von K Lebend
33
Wissensbasierte Systeme
FallNr
Fall
Aktion
1a
K n.−terminal
Füge (K.j, z, h) am Anfang von OFFEN ein
K Maxknoten
für alle j = 1,...,n (Reihenf. aufst. nach j)
K n.−terminal
Füge (K.1,z,h) am Anf.
K Minknoten
von OFFEN ein
K terminal
Füge (K,Gelöst,u) sortiert nach absteigendem h−Wert
1b
1c
in OFFEN ein, u = min{h, f(K)}
bei gleichem h−Wert wird die Sortierung von links nach rechts im Baum festgelegt.
Fall 2: K Gelöst
FallNr
Fall
Aktion
2a
K Maxknoten
Füge (K’.j+1, Lebend, h)
K’ Vorg. von K
an Anf. von OFFEN ein
d.h. K= K’.j, j<n
2b
K Maxknoten
Füge (K’, Gelöst, h)
K’ Vorg. von K
an Anf. von OFFEN ein
d.h. K= K’.j, j=n
2c
K Minknoten
Füge (K’, Gelöst,h)
K= K’.j
an Anf. von OFFEN ein
Lösche Nachfolger von K’ in OFFEN
Wir verfolgen die Veränderungen der Liste OFFEN im obigen Beispiel.
Fall EXP−
Operator
OFFEN
(W, L, ∞)
34
Wissensbasierte Systeme
1a
(1, L, ∞)
(2, L, ∞)
1b
(1.1, L, ∞)
(2, L, ∞)
1c
(2, L, ∞)
(1.1, G, 4)
1b
(2.1, L, ∞)
(1.1, G, 4)
1c
(1.1, G, 4)
(2.1, G,1)
2a
(1.2, L, 4)
(2.1, G, 1)
1c
(1.2, G, 2)
(2.1, G,1)
2b
(1, G, 2)
(2.1, G,1)
2c
(W,G, 2)
Zurückgeliefert wird Wert 2 (Minimax−Wert)
Wir vergleichen den Alpha−Beta−Algorithmus mit dem S*−Verfahren an einem Beispiel.
a−b versus S*
W
2
1
1.1
1.2
2.1
2.2
2
1
4
6
a−b muß alle Blattknoten betrachten!
S*:
(W, L, ¯)
1a
(1,L, ¯)
(2,L,¯)
1b
(1.1, L, ¯)
1c
(2, L, ¯)
1b
(2.1,L, ¯)
(1.1, G, 2)
1c
(2.1,G, 4)
(1.1, G, 2)
2a
(2.2,L, 4)
(1.1, G, 2)
1c
(2.2,G, 4)
(1.1, G, 2)
2b
(2,G, 4)
(2, L, ¯)
(1.1,G, 2)
(1.1, G, 2)
35
Wissensbasierte Systeme
2c
(W, G, 4)
−> S* betrachtet Knoten 1.2 nicht!
Ohne Beweis geben wir folgende Sätze an. Sie klären, wie die Ergebnisse von Alpha−Beta
mit denen von S* zu vergleichen sind.
Satz 1: S* liefert den Minimax−Wert für den Wurzelknoten zurück.
Satz 2: Alle Knoten, die von S* expandiert werden, müssen auch von a−b expandiert werden
Übung:
a−b versus S* ([Pearl 85])
41 5 12 90
101 80 20 30
34 80 36 35
50 36
25 3
Zeige: a−b expandiert 12 Blattknoten, S* nur 8.
Wir vergleichen S* nocheinmal mit Alpha−Beta−Verfahren:
1)
S* expandiert weniger Knoten als a−b
2)
Aber: S* muß alle Teilbäume speichern
a−b kann Teilbaum sofort löschen, wenn a− bzw. b −Wert für Teilbaumwurzel
feststeht
−> exponentieller Speicheraufwand bei S*
In fast allen Spielprogrammen wird das Alpha−Beta−Verfahren benutzt. Als Beispiel
skizzieren wir das Programm Deep Thought.
Deep Thought:
Alpha−beta−Suche
Suchtiefe z.Z. 10 Züge
Verzweigungsfaktor 6
Bewertungsfunktion
36
Wissensbasierte Systeme
− Figurenzahl
− Arrangement von Bauern und Türmen
− Beurteilung der Gesamtstellung
Erhöhung der Rechenleistung um Faktor 1000 liefert Erhöhung der
Suchtiefe auf 14 Züge.
Statistische Auswertung liefert proportionalen Zusammenhang
zwischen Spielstärke und Suchtiefe.
Spielstärke ergibt sich aus Plazierung in Rangliste.
37