Suche mit A*

Hole das Buch

=> Problemlösen == Suche im Graphen

Informierte Suche: Nutzung der Kostenfunktion:

Gesamtkosten: $f(n) = g(n) + h(n)$

• $n \in S$ auf aktuellem Weg erreichter Knoten
• $g(n)$ tatsächliche Kosten für Weg vom Start bis Knoten $n$
• $h(n)$ geschätzte Restkosten für Weg von Knoten $n$ zum Ziel => $h(n)$ wird auch "heuristische Funktion" oder "Heuristik" genannt

Varianten:

• Branch-and-Bound
• Best First
• A*

A*-Suche

• Kombination aus Branch-and-Bound und Best-First-Suche

• Kostenfunktion: $f(n) = g(n) + h(n)$

• Datenstruktur: sortierte Queue (Prioritätsqueue)

• Voraussetzung:

  1. Alle Aktionen haben positive Kosten ($g(n) \ge \epsilon$)
  2. Heuristik $h(n)$ muss zulässig/konsistent sein

Konventionen für diese Lehrveranstaltung

In der Beschreibung der Algorithmen werden häufig nur die letzten Knoten der partiellen Wege in den Datenstrukturen mitgeführt (das gilt auch für die Beschreibung im [Russell2020]). Dies erschwert die Nachvollziehbarkeit, wenn man die Queue oder den Stack schrittweise aufschreibt. Deshalb wird für diese Veranstaltung die Konvention eingeführt, immer die partiellen Wege aufzuschreiben.

Notieren Sie die Bestandteile der Kosten für jeden partiellen Weg in der Queue einzeln: "$g(n) + h(n) = f(n)$". Das erleichtert Ihnen die weiteren Schritte, da Sie dort ja nur mit $g(n)$ weiter rechnen dürfen. Gleichzeitig erleichtert es die Nachvollziehbarkeit.

Auf dem Papier sortiert sich die Queue schlecht, deshalb können Sie darauf verzichten, wenn Sie den im nächsten Schritt zu expandierenden Weg unterstreichen. Wer nicht mit Unterstreichen arbeiten will, muss eben dann manuell sortieren ...

Wenn bei der Graph-Search-Variante ein Weg nicht in die Queue aufgenommen wird, weil bereits ein anderer (günstigerer) Weg zum selben (Zwischen-/End-) Knoten bereits in der Queue enthalten ist, schreiben Sie dies geeignet auf. Dies gilt auch für den analogen Fall, wenn ein Weg aus der Queue entfernt wird, weil ein günstigerer Weg zum selben (Zwischen-/End-) Knoten eingefügt werden soll.

A*-Suche -- Anforderungen an Heuristik (Tree-Search)

Tree-Search-Variante: Die Heuristik muss zulässig sein:

• Seien $h^\star(n)$ die tatsächlichen optimalen Restkosten von einem Knoten $n$ zum nächsten Ziel.
• Dann muss für jeden beliebigen Knoten $n$ gelten: $$h(n) \le h^\star(n)$$
• Außerdem muss gelten:
  • $h(n) \ge 0$ für jeden Knoten $n$
  • $h(n) = 0$ für jeden Zielknoten $n$

=> Beispiel: Luftlinie als Abschätzung

Hinweis: Im der englischen Ausgabe des [Russell2020] wird die zulässige Heuristik auch "admissible heuristic" genannt.

A* ist optimal

A* (Tree-Search-Variante) mit zulässiger Heuristik ist optimal.

Beweis siehe Übung :-)

Einfache Verbesserungen A* (Tree-Search)

• Dynamische Programmierung: Behalte von mehreren Pfaden zum gleichen Knoten nur den günstigsten in der Queue

• Pfade, deren Endknoten bereits früher im Pfad vorkommt (Schleifen), werden in Schritt 2 nicht in die Queue aufgenommen

• Übergang zur Graph-Search-Variante und Markierung von Knoten

  => Achtung: Dann schärfere Anforderungen an Heuristik (Konsistenz)

A*-Suche -- Anforderungen an Heuristik (Graph-Search)

Graph-Search-Variante: Die Heuristik muss konsistent sein:

Für jeden Knoten $n$ und jeden durch eine Aktion $a$ erreichten Nachfolger $m$ gilt: $$h(n) \le c(n,a,m) + h(m)$$ mit $c(n,a,m)$ Schrittkosten für den Weg von $n$ nach $m$ mit Aktion $a$.

Außerdem muss gelten:

• $h(n) \ge 0$ für jeden Knoten $n$
• $h(n) = 0$ für jeden Zielknoten $n$

=> Eine konsistente Heuristik ist gleichzeitig zulässig.

Hinweis: Im der englischen Ausgabe des [Russell2020] wird die konsistente Heuristik auch "consistent heuristic" genannt.

Eigenschaften Branch-and-Bound, Best-First, A*

Wrap-Up

• Informierte Suchverfahren

  • Nutzen reale Pfadkosten und/oder Schätzungen der Restkosten
  • A*: komplette Kostenfunktion $f(n) = g(n)+h(n)$ => besondere Anforderungen an die Heuristik! (Tree-Search: zulässige Heuristik; Graph-Search: konsistente Heuristik)

• Ausblick auf Verbesserungen der vorgestellten Suchverfahren:

  • Beschränkung der Suchtiefe ("Depth-Limited-Search")
  • Iterative Vertiefung der Suchtiefe ("Iterative-Deepening-Search"), beispielsweise IDA* ("Iterative-Deepening A*")
  • Beschränkung des verwendeten Speichers, beispielsweise SMA* ("Simplified Memory-Bounded A*")