Heuristic search planning - Stefan Ender / Matthias Raps Hauptseminar "Problemlösen und Planen"

Die Seite wird erstellt Mara Ehlers
 
WEITER LESEN
Heuristic search planning - Stefan Ender / Matthias Raps Hauptseminar "Problemlösen und Planen"
Heuristic search planning

            Hauptseminar
     „Problemlösen und Planen“
   Stefan Ender / Matthias Raps

                                  1
Agenda

„   Einleitung mit Definitionen
„   STRIPS und Zustandsraummodell
„   Eingesetzte Heuristiken
„   HSP 2.0 (Heuristic search planner)
„   Bewertung und Ausblick

                                         2
Was ist eine Heuristik? [1]

„   eine allgemeine Definition:
    {   abgeleitet aus dem Altgriechischen
    {   zu deutsch „ich finde“
    {   Als Heuristik bezeichnet man eine Strategie,
    {   die das Streben nach Erkenntnis
    {   und das Finden von Wegen zum Ziel
    {   planvoll gestaltet.
    (aus www.wikipedia.org)

                                                       3
Was ist eine Heuristik? [2]

„   d.h. eine „Heuristik" ist
    {   eine Daumenregel,
    {   eine Strategie,
    {   ein Trick,
    {   eine Vereinfachung oder
    {   ein anderes Hilfsmittel,
    {   das die Problemlösungssuche in großen Problemräumen
        drastisch begrenzt.
„   garantiert keine optimale Lösung
    {   eigentlich garantiert sie nicht einmal irgendeine Lösung

                                                                   4
Was ist eine Heuristik? [3]

„   aus Sicht der Informatik:
    {   Lehre zur methodischen Gewinnung neuer Erkenntnisse,
        mit Hilfe der Erfahrung
    {   beruht meist auf Faustregeln bzw. Algorithmen
    {   liefern häufig keine optimalen
    {   aber meist gute Lösungen
    {   Einsatzgebiet: Aufwand zu groß für die Berechnung der
        optimalen Lösung

                                                                5
Beispiel für eine Heuristik:
„nächster Nachbar“
„   wird häufig im täglichen Leben angewandt
„   Ausgangspunkt: Reisender muss verschiedene Kunden
    besuchen
    {   sucht zuerst nächsten Nachbarn seines aktuellen Standortes
    {   bewegt sich zu diesem und
    {   wendet die Heuristik erneut an
    {   wenn er alle Kunden besucht hat, fährt er nach Hause zurück.
„   Nachteil: oftmals schlechte Resultate, da
    {   Heimweg und
    {   andere unterwegs vergessene Punkte
    hohe Kosten verursachen.

                                                                       6
Planungsproblem in STRIPS [1]
„   Planungsproblem wird in STRIPS dargestellt als Tupel P =
    (A,O,I,G) mit
    {   A: Menge von Atomen
    {   O: Menge von Operatoren mit Prec(op), Add(op), Del(op)
    {   I: Initialzustand
    {   G: Zielzustände
„   Ein STRIPS Problem definiert dabei einen Zustandsraum
    bestehend aus:
    {   Menge von Zuständen
    {   Startzustand
    {   Zielzustände
    {   Menge von möglichen Aktionen (Operatoren)
    {   Zustandsübergangsfunktion ( s´= s \ Del (a ) ∪ Add (a ))
    {   Kosten der Aktionen (sind für jeden Übergang 1!)

                                                                   7
Planungsproblem in STRIPS [2]

„   heuristic search planning kann jetzt als
    Suche im Zustandsraum angesehen werden
„   d.h. Überführung des Startzustands in
    Zielzustand durch eine Folge von Aktionen
„   HSP nutzt Beschreibungen in PDDL
    {   Planning Domain Definition Language
    {   Erweiterung von STRIPS
    {   Standard für Darstellung von Plannungsproblemen

                                                          8
Domänendefinition für die
         Blockswelt in PDDL
; Block World Domain definition
                                                                         Definition der
(define (domain blocks_world)
  (:requirements :strips)                                              möglichen Prädikate
  (:predicates (on-table ?x) (on ?x ?y) (clear ?x))
  (:action MoveToTable
     :parameters (?x ?y)                                       Block x wird von Block y auf
     :precondition (and (clear ?x) (on ?x ?y))
                                                                    den Tisch gelegt
     :effect (and (clear ?y) (on-table ?x)
                (not (on ?x ?y))))
  (:action MoveToBlock1
     :parameters (?x ?y ?z)
     :precondition (and (clear ?x) (clear ?z) (on ?x ?y))         Block x wird von Block y
     :effect (and (clear ?y) (on ?x ?z)                              auf Block z gelegt
                (not (clear ?z)) (not (on ?x ?y))))
  (:action MoveToBlock2
     :parameters (?x ?y)
     :precondition (and (clear ?x) (clear ?y) (on-table ?x))
     :effect (and (on ?x ?y)                                        Block x wird vom Tisch
                (not (clear ?y)) (not (on-table ?x)))))               auf Block y gelegt

                                                                                              9
Problemdefinition in PDDL -
          Ein Beispiel für die Blockswelt
(define (problem hs1)                                Zugehörige
 (:domain blocks_world)
 (:objects A B C D E F)
                                                   Domänendefinition
(:init
 (on-table A) (on D A) (clear D)
 (on-table F) (on B F) (on C B) (clear C)               C
 (on-table E) (clear E))                       D        B
                                               A        F         E
(:goal
                                                   Startzustand
(and (on B C) (on-table C) (on A F)
(on-table F) (on-table D) (on E D) (clear B)
(clear A) (clear E))))
                                               B       A          E
                                               C       F          D
                                                   Endzustand
                                                                       10
Suche im Zustandsraum

„   Einsatz von Heuristiken um diese effizient
    zu gestalten
„   Heuristik soll dabei automatisch aus der
    Problemrepräsentation gewonnen werden
„   => Domänenunabhängigkeit

                                                 11
Gewinnung der Heuristik [1]

„   Heuristische Funktion h(s)
    {   Betrachtung eines vereinfachten Problems
        (relaxed problem P´), in dem
    {   delete lists ignoriert werden
    {   Kosten h´(s) sind untere Schranke für h*(s)
        (Kosten des Problems P)
    {   => h´(s) zulässige (admissible) Heuristik

                                                      12
Gewinnung der Heuristik [2]

„   Aber: auch Lösung von P´ und damit
    Gewinnung der Funktion h´ ist NP-hard
„   => Annäherung an h´(s):
    {   Kosten für die Gewinnung der einzelnen
        Zielatome (Teilziele) aus Zustand s werden
        geschätzt
    {   h(s) ist dann eine geeignete Kombination aus
        diesen einzelnen Schätzungen

                                                       13
Die additive Heuristik
„   „Summe der Kosten um alle Teilziele zu erreichen“
        hadd ( s ) = ∑ g S (r )
                   r∈C
„   Beispiel:
    gS (Teilziel 1) = 3, gS(Teilziel 2) = 5, gS(Teilziel 3) = 2
    => hadd = 3 + 5 + 2 = 10
„   nicht admissible,
    {     da Teilziele nicht unabhängig voneinander sind
    {     d.h. es kann auch zu Überschätzungen kommen

                                                             14
Die Max – Heuristik
„   „die höchsten Kosten um ein Teilziel zu erreichen“

    hmax ( s ) = max g S (r )
                 r∈C

„   Beispiel:
    gS (Teilziel 1) = 3, gS(Teilziel 2) = 5, gS(Teilziel 3) = 2
    => hmax = 5
„   ist admissible,
    {   d.h. keine Überschätzung möglich

                                                             15
Berechnung der Kosten für die
    Erreichung der Teilziele
„   Version des Bellman–Ford Algorithmus (findet den
    kürzesten Weg in einem Graphen)
„   falls Teilziel im Zustand s vorhanden ist, so werden die
    Kosten hierfür auf gS(p)= 0, andernfalls auf ∞ gesetzt
„   Ausführung aller anwendbaren Operatoren
„   Hinzufügen der Atome aus den zugehörigen Add-Listen
    zum Zustand s.
„   gS(p) verändern auf: g S ( p ) := min[ g S ( p),1 + g S (Prec(op ))]
„   Vorgang wiederholen bis sich gS(p) nicht mehr verändert

                                                                   16
Berechung der Kosten für die
            Erreichung der Teilziele - Beispiel
                                   „   Bewertung der bereits erfüllten Teilziele mit 0:
             C                         gs(on-table(F)) = 0; gs(clear (E)) = 0
    D        B                     „   Ausführung aller möglichen Operatoren
    A        F       E
     Startzustand                      z.B. MoveToTable (D A), MoveToBlock2 (E D)
„ S = ((on-table A) (on-table E)
                                       usw.
(on-table F) (on D A) (on B F)     „   Atome der Add-Listen zu S hinzufügen
(on C B) (clear C) (clear D)
(clear E))                             z.B. on-table (D), clear(A), on(E D) usw.
                                   „   Jetzt erreichte Teilziele werden mit Kosten 1
        B    A       E                 bewertet
        C    F       D
                                       z.B. gs(on-table(D)) = 1; gs(clear(A)) = 1;
        Endzustand
„ G = ((on-table C) (on-table D)
                                       gs(on(E D)) = 1 usw.
(on-table F) (on B C) (on E D)     „   Wieder alle möglichen Operatoren ausführen
(on A F) (clear A) (clear B)
(clear E))                             usw.
                                                                                  17
HSP 2.0
(Heuristic search planner)

„   domänenunabhängig (general problem
    solver)
„   automatische Gewinnung der Heuristik aus
    der Problemdefinition
„   verschiedene Funktionalitäten des HSP 2.0
    {   Vorwärts- bzw. Rückwärtsplanung
    {   Verschiedene Heuristiken (add, max, h2)
„   implementiert in C

                                                  18
HSP 2.0 [1]

„   Best-First-Search Planner (entspricht einer
    Breitensuche)
„   Suchalgorithmus in HSP 2.0
    {   nutzt WA* - Algorithmus (Abwandlung von A*)
    {   A*: Entscheidung anhand Evaluierungsfunktion
        welcher Knoten als nächstes generiert wird
        „   f(n) = g(n) + h (n)
        „   g(n): tatsächliche Kosten bis Knoten n
        „   h(n): geschätzte Kosten bis zum Ziel

                                                       19
HSP 2.0 [2]
„   WA*: f(n) = g(n) + W*h(n)
„   W: Parameter zur Gewichtung der Heuristik
„   Für W = 1 entspricht WA* dem A* -
    Algorithmus
„   Für W > 1: Lösungen werden schneller
    gefunden, aber wahrscheinlich sind diese
    weiter entfernt von der optimalen Lösung,
    d.h. mehr Schritte vom Startzustand in den
    Zielzustand

                                                 20
Berechnung der
     Evaluierungsfunktion - Beispiel
      C
D     B
A     F      E
Startzustand
           Kosten sind bekannt
           => hier z.B. g(n) = 2

                                           Evaluierungsfunktion
      B
A     F     E      C      D                f(n) = g(n) + W * h(n)
    aktueller Zustand                 => hier z.B f(n) = 2 + 2 * 3 = 10
                                                 mit W = 2
            Kosten werden vom
             Planer geschätzt
           => hier z.B. hAdd(n) = 4

A     B     E
F     C     D
                                                                          21
Endzustand
HSP 2.0 in Aktion

                                   cost = g(n)
Default-Modus: Vorwärtssuche mit   h1plus = hadd(n)
 der additiven Heuristik und W=2
                                   h1max = hmax(n)
                                                      22
HSP 2.0 – Die Lösung
unseres Beispiels                                       Schritt 1

                                                        Schritt 2

                                                        Schritt 3
    C
D   B                                                   Schritt 4
A   F      E
Startzustand                                            Endzustand

D   B                            B
A   F     E     C           A    F         E        C     D
    Schritt 1                           Schritt 2

          B     E                                   B
A   F     C     D           A       F       E       C      D
    Schritt 4                           Schritt 3

                    A   B       E
                    F   C       D
                                                                     23
                    Endzustand
Bewertung von HSP 2.0

„   komplett,
    { d.h. es wird eine Lösung gefunden, wenn
       eine existiert
„   nicht optimal,
    { da hadd nicht admissible ist

„   Nachteil vom Vorwärtsplanen: Heuristik
    muss in jedem Zustand neu berechnet
    werden

                                            24
Ergebnisse der AIPS-00 Planning
                      Competition für die Blockswelt
                                                                                     BlackBox

                                                                                     Mips
          1000
                                                                                     System R

                                                                                     FF

                                                                                     HSP2

           10                                                                        IPP
Seconds

                                                                                     PropPlan

                                                                                     TokenPlan
                                   12
                                   14
                                        16
                                        18

                                             22
                                                  24

                                                            32
                                                            34
                                                                 36
                                                                 83
                                                                      40
                                                                      42
                                                                           44

                                                                                50
                              10

                                             20

                                                  26
                                                       28
                                                       30

                                                                           46
                                                                                48
                  5
                      6
                          8
                               9
           4

                                                                                     STAN
           0.1
                                                                                     BDDPlan

                                                                                     AltAlt

                                                                                     GRT 25

          0.001
Ausblick: FF Planer
„   FF = Fast Forward
„   entwickelt an der Universität Freiburg (Hoffmann,
    Nebel)
„   Vorwärtsplaner
„   Erweitert Heuristik des HSP
    {   Informationen aus der Extraktionsphase des Graphplan –
        Algorithmus
„   Suchstrategie: Kombination aus
    {   Hill-Climbing und
    {   systematischer Suche
„   Top Performer in der AIPS–Competition ´02
                                                                 26
Sie können auch lesen