Python-Implementierung von Schlussfolgern und Planung

Dieses Kapitel führt in die zentralen intelligenten Fähigkeiten von KI-Agenten ein, nämlich die Fähigkeiten zum Reasoning und zur Planung.

Im Gegensatz zu traditionellen Mustern der Instruktionsausführung kann ein Agent mit Reasoning-Fähigkeiten komplexe Denkprozesse durchlaufen.

Er kann komplexe Aufgaben in ausführbare Schritte zerlegen und Entscheidungen auf der Grundlage des Kontexts treffen.


ReAct-Framework

ReAct (Reasoning + Acting) ist ein Framework, das Reasoning und Acting kombiniert.

Im ReAct-Muster wechselt der Agent zwischen Reasoning und Acting ab und bildet so eine geschlossene Schleife.

Reasoning leitet die Aktion, und die Ergebnisse der Aktionen fließen in den Reasoning-Prozess zurück, wobei sich dieser Zyklus wiederholt.

ReAct simuliert den menschlichen Problemlösungsprozess: Denken vor dem Handeln, Beobachten der Ergebnisse nach dem Handeln und anschließendes Weiterdenken auf der Grundlage neuer Informationen.

Funktionsprinzip

Die Kernidee von ReAct lässt sich als dreiphasige Schleife zusammenfassen:

Erstens die Reasoning-Phase. Der Agent generiert den nächsten Handlungsgedanken auf der Grundlage des aktuellen Kontexts.

Zweitens die Aktionsphase. Der Agent führt das ausgewählte Werkzeug oder die ausgewählte Aktion aus.

Drittens die Beobachtungsphase. Der Agent empfängt das Aktionsergebnis, aktualisiert den Kontext und kehrt zum ersten Schritt zurück, um das Reasoning fortzusetzen.

Code-Implementierung

Nachfolgend finden Sie eine vereinfachte Implementierung eines ReAct-Agenten:

Basisimplementierung eines ReAct-Agenten

class ReActAgent:
    """
Agent-Implementierung des ReAct-Frameworks
Kernmechanismus: Reasoning -> Aktion -> Beobachtung -> Reasoning (Schleife)
    """

   
    def __init__(self, llm, tools, max_iterations=5):
        # LLM-Instanz, verwendet für Reasoning und Generierung
        self.llm = llm
        # Liste der verfügbaren Tools
        self.tools = tools
        # Maximale Anzahl von Iterationen, um Endlosschleifen zu verhindern
        self.max_iterations = max_iterations
   
    def run(self, task):
        """
ReAct-Schleife ausführen
:param task: Beschreibung der Benutzeraufgabe
:return: Ausführungsergebnis
        """

        # Kontext initialisieren, einschließlich Aufgaben- und Verlaufsinformationen
        context = {
            "task": task,
            "steps": [],      # Aufzeichnung der ausgeführten Schritte
            "observations": []  # Aufzeichnung der Beobachtungsergebnisse
        }
       
        for i in range(self.max_iterations):
            # Phase 1: Reasoning – Generiere die nächste Aktion auf der Grundlage des aktuellen Kontexts
            reasoning = self.llm.reason(context)
           
            # Bestimmen, ob ein Werkzeug ausgeführt werden muss, oder die Antwort direkt zurückgeben
            if reasoning.needs_action:
                # Das zu verwendende Werkzeug auswählen
                action = reasoning.select_tool(self.tools)
                # Das Werkzeug ausführen und das Beobachtungsergebnis abrufen
                observation = action.execute(reasoning.tool_input)
                # Das Beobachtungsergebnis zum Kontext hinzufügen
                context["observations"].append(observation)
            else:
                # Keine Aktion erforderlich, die aus dem Reasoning erhaltene Antwort direkt zurückgeben
                return reasoning.answer
       
        # Maximale Anzahl von Iterationen erreicht, ohne abzuschließen
        return "Maximum iteration limit reached"

Typische Anwendungsszenarien

Das ReAct-Muster eignet sich besonders für die folgenden Szenarien:

Aufgaben, die nach der Erkundung der Umgebung und dem Sammeln von Informationen erledigt werden müssen.

Intelligentes Suchszenario: Der Agent muss zuerst nach Informationen suchen und dann auf Grundlage der Suchergebnisse schlussfolgern und zusammenfassen.

Konversations-Frage-und-Antwort: Der Agent muss Anforderungen klären und Informationen durch mehrrundigen Dialog erhalten.

Komplexe Problemlösung: Das Problem kann nicht in einem Schritt gelöst werden und erfordert mehrere Zwischenschritte.

Hinweis: Der Vorteil des ReAct-Musters liegt in seiner Flexibilität, sodass es nachfolgende Aktionen dynamisch anhand des Ausführungsergebnisses jedes Schritts anpassen kann. Das bedeutet aber auch, dass der Ausführungspfad instabil sein kann, was es für Aufgaben geeignet macht, die Erkundung erfordern.


Gedankenkette (Chain of Thought, CoT)

Die Gedankenkette ist eine Technik, die das Modell dazu anregt, einen schrittweisen Denkprozess zu zeigen.

CoT fordert das Modell nicht auf, die Antwort direkt zu geben, sondern führt es dazu, zuerst die Denkschritte aufzuzeigen und dann zur endgültigen Schlussfolgerung zu gelangen.

Warum die Gedankenkette benötigt wird

Das Modell direkt die Antwort ausgeben zu lassen, hat mehrere Probleme:

Zwischenschritte bei komplexem Schlussfolgern werden leicht übersehen oder übersprungen.

Es ist schwierig, genau zu bestimmen, wo der Fehler aufgetreten ist.

Benutzer können den Denkprozess des Modells nicht nachvollziehen.

Die Gedankenkette löst diese Probleme, indem sie vom Modell verlangt, seinen Denkprozess aufzuzeigen.

Zero-Shot-CoT

Zero-Shot-CoT ist eine Methode, die schrittweise Schlussfolgerungsfähigkeit hervorrufen kann, ohne Beispiele zu benötigen.

Fügen Sie einfach einen Auslösesatz wie „Denken wir Schritt für Schritt“ am Ende des Prompts hinzu.

Zero-Shot-CoT-Beispiel

# Prompt-Vorlage für Zero-Shot-CoT
prompt = """
Frage: Xiao Ming hat 5 Äpfel. Xiao Hong gibt ihm 3. Xiao Ming isst 2. Wie viele bleiben übrig?
Denken wir Schritt für Schritt:
"""


# Das Sprachmodell aufrufen
response = llm.generate(prompt)

# Beispielausgabe des Modells:
# Schritt 1: Berechne die Gesamtzahl der Äpfel, nachdem Xiao Ming sie erhalten hat
# Xiao Ming hatte ursprünglich 5 Äpfel, Xiao Hong gab ihm 3
# 5 + 3 = 8
#
# Schritt 2: Berechne die Anzahl nach dem Essen
# Xiao Ming aß 2
# 8 - 2 = 6
#
# Schlussfolgerung: Es sind noch 6 Äpfel übrig

Few-Shot-CoT

Few-Shot-CoT hilft dem Modell, spezifische Denkmuster zu erlernen, indem Beispiele mit detaillierten Denkprozessen bereitgestellt werden.

Wenn Zero-Shot-CoT nicht effektiv ist, können Sie Few-Shot-CoT ausprobieren.

Few-Shot-CoT-Beispiel

# Prompt-Vorlage für Few-Shot-CoT
prompt = """
Beispiel 1:
Frage: Xiao Zhang hat 10 Yuan. Er kauft 3 Bücher zu je 2 Yuan. Wie viel bleibt übrig?
Denken wir Schritt für Schritt:
- Xiao Zhang hatte ursprünglich 10 Yuan
- Jedes Buch kostet 2 Yuan, er kauft 3 Bücher, gibt 3 × 2 = 6 Yuan aus
- 10 - 6 = 4 Yuan
Antwort: 4 Yuan übrig

Beispiel 2:
Frage: Eine Katze fängt 2 Mäuse pro Stunde. Wie viele fängt sie in 8 Stunden?
Denken wir Schritt für Schritt:
- Fängt 2 Mäuse pro Stunde
- In 8 Stunden fängt sie 8 × 2 = 16
Antwort: 16 gefangen

Frage: {user_question}
Denken wir Schritt für Schritt:
"""


response = llm.generate(prompt)

Vorteile der Gedankenkette

Die Technologie der Gedankenkette bietet drei Kernwerte:

Rückverfolgbarkeit: Zerlegt komplexes Schlussfolgern in nachvollziehbare Zwischenschritte und macht den Denkprozess leichter verständlich.

Interpretierbarkeit: Verbessert die Interpretierbarkeit des Modells und lässt Benutzer wissen, woher die Antworten stammen.

Genauigkeitsverbesserung: Verbessert die Genauigkeit bei komplexen Schlussfolgerungsaufgaben erheblich, besonders wirksam bei mathematischen und logischen Aufgaben.


Gedankenbaum(ToT)

Tree of Thoughts ist eine Erweiterung der Gedankenkette; sie ist nicht mehr auf lineares Schlussfolgern beschränkt.

ToT erkundet an jedem Schlussfolgerungsknoten mehrere mögliche Pfade und bildet eine baumartige Struktur.

Dies ermöglicht es dem Agenten, Multi-Pfad-Exploration, Backtracking und globale Bewertung durchzuführen.

Unterschiede zu Chain of Thought

CoT verwendet lineares Schlussfolgern, bei dem jeder Schritt von der Schlussfolgerung des vorherigen Schritts abhängt, geeignet für Probleme mit klaren Pfaden.

ToT verwendet räumliches Schlussfolgern und berücksichtigt mehrere mögliche Zweige gleichzeitig, geeignet für Probleme, die Exploration und Planung erfordern.

Code-Implementierung

Grundlegende Implementierung eines ToT-Agenten

class ToTAgent:
    """
Implementierung eines Tree-of-Thoughts-Agenten
Kernmechanismus: An jedem Knoten mehrere Kandidatenzweige generieren, diese bewerten und dann den besten auswählen, um fortzufahren.
    """

   
    def __init__(self, llm, max_depth=4, beam_size=3):
        # LLM-Instanz
        self.llm = llm
        # Maximale Suchtiefe
        self.max_depth = max_depth
        # Anzahl der pro Ebene beibehaltenen Kandidatenknoten (Beam-Breite)
        self.beam_size = beam_size
   
    def solve(self, problem):
        """
Lösen von Problemen mit dem ToT-Framework
:param problem: Problembeschreibung
:return: Optimale Lösung
        """

        # Wurzelknoten erstellen, der das Problem als Anfangszustand enthält
        root = ThoughtNode(problem, depth=0)
        # Frontier-Knotenliste initialisieren (zu erweiternde Knoten)
        frontier = [root]
       
        # Schicht für Schicht erweitern
        for depth in range(self.max_depth):
            # Alle Kandidatenknoten speichern
            all_candidates = []
           
            # Über alle Frontier-Knoten iterieren
            for node in frontier:
                # Mehrere Kandidaten für die nächsten Schritte vom aktuellen Knoten generieren
                candidates = self.llm.generate_thoughts(
                    node.content,    # Aktueller Knoteninhalt
                    n=self.beam_size  # Anzahl der Generierungen
                )
                # Einen neuen Knoten erstellen und ihn zur Kandidatenliste hinzufügen
                for cand in candidates:
                    all_candidates.append(
                        ThoughtNode(cand, depth + 1, parent=node)
                    )
           
            # Alle Kandidatenknoten bewerten
            evaluated = self.evaluator.rank(all_candidates)
           
            # Die besten beam_size Knoten als nächste Frontier auswählen
            frontier = evaluated[:self.beam_size]
           
            # Prüfen, ob eine Lösung gefunden wurde
            if self.is_solution(frontier):
                break
       
        # Backtracking durchführen, um die optimale Lösung zu finden
        return self.backtrack_best(frontier)

Anwendungsszenarien

ToT eignet sich besonders für Szenarien, die Entscheidungen oder Planung erfordern:

Kreatives Schreiben: Mehrere Entwicklungsrichtungen für Geschichten generieren, sie bewerten und dann die beste auswählen.

Strategische Planung: Die potenziellen Ergebnisse mehrerer Aktionspläne bewerten.

Komplexe Entscheidungsfindung: Entscheidungsprobleme, die das Abwägen mehrerer Möglichkeiten erfordern.


Aufgabenplanung und MCTS

Monte-Carlo-Baumsuche (MCTS) ist ein heuristischer Suchalgorithmus, der für komplexe Entscheidungsprobleme verwendet wird.

MCTS findet breite Anwendung in der Agentenplanung und eignet sich besonders für Spiel-KI und komplexe Aufgabenplanung.

Kernidee

MCTS bewertet den potenziellen Wert jedes Entscheidungsknotens durch Simulation zufälliger Spiele.

Es muss nicht alle möglichen Pfade bewerten, sondern verwendet Sampling und Statistiken, um die Suchrichtung zu lenken.

Vier Schritte von MCTS

Schritt 1, Auswahl: Vom Wurzelknoten aus rekursiv den optimalen Kindknoten auswählen, bis ein Blattknoten erreicht ist.

Während der Auswahl wird die UCB-Formel (Upper Confidence Bound) verwendet, um Exploration und Exploitation auszubalancieren.

Schritt 2, Erweiterung: Einen oder mehrere Kindknoten zum Blattknoten hinzufügen.

Schritt 3, Simulation: Vom neuen Knoten aus das Spiel zufällig bis zum Ende simulieren.

Schritt 4, Backpropagation: Die Statistiken aller Knoten entlang des Simulationspfads aktualisieren.

Code-Implementierung

MCTS-Planer-Implementierung

import math

class MCTSNode:
    """
MCTS-Baumknoten
Speichert Knotenzustand, Statistiken und Beziehungen zu Kindknoten
    """

   
    def __init__(self, state, parent=None, action=None):
        # Aktueller Zustand
        self.state = state
        # Referenz auf Elternknoten
        self.parent = parent
        # Aktion vom Elternknoten zu diesem Knoten
        self.action = action
        # Liste der Kindknoten
        self.children = []
        # Besuchsanzahl dieses Knotens
        self.visit_count = 0
        # Kumulativer Belohnungswert dieses Knotens
        self.reward = 0.0
   
    def is_fully_expanded(self):
        """Prüft, ob alle möglichen Kindknoten erweitert wurden"""
        return len(self.children) > 0
   
    def is_terminal(self):
        """Prüft, ob es sich um einen Endknoten handelt (Spiel vorbei oder Ziel erreicht)"""
        return self.state.is_terminal()
   
    def uct_child(self):
        """
Verwende die UCT-Formel, um den optimalen Kindknoten auszuwählen
        UCT = reward/visits + C * sqrt(ln(parent_visits)/visits)
C ist die Explorationskonstante, üblicherweise auf sqrt(2) gesetzt
        """

        # Explorationskonstante, die Exploration und Ausbeutung ausgleicht
        C = math.sqrt(2)
       
        return max(
            self.children,
            key=lambda c: c.reward / c.visit_count +
                         C * math.sqrt(math.log(self.visit_count) / c.visit_count)
        )


class MCTSPlanner:
    """
MCTS-Planer
Verwendet Monte-Carlo-Baumsuche, um Aktionspläne für den Agenten zu generieren
    """

   
    def __init__(self, simulation_limit=1000, exploration_constant=1.41):
        # Maximale Anzahl an Simulationen
        self.simulation_limit = simulation_limit
        # Explorationskonstante
        self.exploration_constant = exploration_constant
   
    def plan(self, initial_state):
        """
Beginne die Planung vom Anfangszustand aus
:param initial_state: Anfangszustand
:return: optimale Aktion
        """

        # Wurzelknoten erstellen
        root = MCTSNode(initial_state)
       
        # Mehrere Simulationen durchführen
        for _ in range(self.simulation_limit):
            # 1. Auswahl: Wähle vom Wurzelknoten abwärts den optimalen Kindknoten, bis ein Blattknoten erreicht ist
            node = self._selection(root)
           
            # 2. Erweiterung: Wenn es kein Endknoten ist, erweitere einen neuen Knoten
            if not node.is_terminal():
                node = self._expansion(node)
           
            # 3. Simulation: Simuliere zufällig vom neuen Knoten bis zum Endknoten
            reward = self._simulation(node)
           
            # 4. Backpropagation: Aktualisiere die Statistiken aller Knoten auf dem Pfad
            self._backpropagation(node, reward)
       
        # Gib die Aktion zurück, die dem optimalen Kindknoten des Wurzelknotens entspricht
        return root.best_child().action
   
    def _selection(self, node):
        """Auswahlphase: den optimalen Kindknoten auswählen"""
        while node.is_fully_expanded() and not node.is_terminal():
            node = node.uct_child()
        return node
   
    def _expansion(self, node):
        """Expansionsphase: einen neuen Kindknoten hinzufügen"""
        # Alle möglichen Aktionen generieren
        possible_actions = node.state.get_possible_actions()
        # Für jede Aktion einen Kindknoten erstellen
        for action in possible_actions:
            new_state = node.state.apply_action(action)
            child = MCTSNode(new_state, parent=node, action=action)
            node.children.append(child)
        # Einen zufälligen Kindknoten zurückgeben (oder eine deterministische Strategie verwenden)
        return node.children[0]
   
    def _simulation(self, node):
        """Simulationsphase: zufällig simulieren, bis das Spiel endet"""
        state = node.state
        while not state.is_terminal():
            # Zufällig eine Aktion auswählen
            actions = state.get_possible_actions()
            action = random.choice(actions)
            state = state.apply_action(action)
        # Die endgültige Belohnung zurückgeben
        return state.get_reward()
   
    def _backpropagation(self, node, reward):
        """Backpropagation: Statistiken aktualisieren"""
        while node is not None:
            node.visit_count += 1
            node.reward += reward
            node = node.parent

Hinweis: MCTS hat hohe Rechenkosten und eignet sich für Szenarien, die eine tiefe Planung erfordern, aber klare Abbruchbedingungen haben. Für Aufgaben mit hohen Echtzeitanforderungen kann es notwendig sein, die Anzahl der Simulationen zu begrenzen oder andere Methoden zu verwenden.


Reflexion (Selbstreflexion)

Reflexion ist eine Technik, die einem Agenten Selbstreflexionsfähigkeiten verleiht.

Durch das Hinzufügen eines Reflexionsmechanismus zum Agenten kann er nach einem Fehlschlag die Ursachen des Fehlschlags analysieren, seine Strategie anpassen und es erneut versuchen.

Kernidee

Der Agent führt nicht nur Aktionen aus, sondern beobachtet auch Ergebnisse und reflektiert: Warum bin ich gescheitert? Wie sollte ich mich beim nächsten Mal verbessern?

Diese Fähigkeit ist entscheidend für kontinuierliches Lernen und Selbstverbesserung.

Code-Implementierung

Implementierung des Reflexion-Agenten

class ReflexionAgent:
    """
Ein Agent mit Selbstreflexionsfähigkeit
Kernmechanismus: Ausführen -> Bewerten -> Reflektieren -> Erneut versuchen
    """

   
    def __init__(self, actor, reviewer, max_retries=3):
        # Executor: verantwortlich für die Ausführung spezifischer Aufgaben
        self.actor = actor
        # Evaluator: verantwortlich für die Bewertung der Ausführungsergebnisse
        self.reviewer = reviewer
        # Maximale Anzahl an Wiederholungsversuchen
        self.max_retries = max_retries
   
    def run(self, task):
        """
Aufgabe mit Selbstreflexion ausführen
:param task: Aufgabenbeschreibung
:return: Ausführungsergebnis
        """

        # Ausführungsverlauf pflegen
        history = []
       
        for attempt in range(self.max_retries):
            # Phase 1: Versuch, die Aufgabe auszuführen
            result = self.actor.execute(task, history)
           
            # Diesen Versuch aufzeichnen
            history.append({
                "attempt": attempt,
                "result": result
            })
           
            # Phase 2: Ergebnis bewerten
            feedback = self.reviewer.evaluate(task, result)
           
            # Phase 3: Prüfen, ob es erfolgreich war
            if feedback.is_success:
                return result
           
            # Phase 4: Über die Ursache des Fehlschlags reflektieren
            # Einen neuen Strategie-Prompt generieren, um den nächsten Versuch zu leiten
            reflection = self.reviewer.reflect(
                task,           # Ursprüngliche Aufgabe
                result,         # Fehlgeschlagenes Ergebnis
                feedback        # Bewertungsfeedback
            )
           
            # Das Reflexionsergebnis zur Historie hinzufügen, um es beim nächsten Versuch als Referenz zu verwenden
            history.append({
                "type": "reflection",
                "content": reflection
            })
       
        # Wenn alle Wiederholungsversuche fehlschlagen, die Historie zurückgeben
        return history


class Reviewer:
    """Bewerter: Ausführungsergebnisse bewerten und Reflexionen generieren"""
   
    def evaluate(self, task, result):
        """
Ausführungsergebnis bewerten
:return: ein Objekt, das angibt, ob es erfolgreich war, und detailliertes Feedback enthält
        """

        # Prüfen, ob das Ergebnis die Aufgabenanforderungen erfüllt
        is_success = self.check_success(task, result)
       
        if is_success:
            return EvaluationResult(is_success=True)
        else:
            # Analyse der Fehlerursachen generieren
            failure_reasons = self.analyze_failures(task, result)
            return EvaluationResult(
                is_success=False,
                reasons=failure_reasons
            )
   
    def reflect(self, task, result, feedback):
        """
Reflexionsinhalt generieren
Dem Actor helfen, die Ursache des Fehlschlags zu verstehen und seine Strategie zu verbessern
        """

        prompt = f"""
Aufgabe: {task}
Ausführungsergebnis: {result}
Gründe für das Scheitern: {feedback.reasons}

Bitte analysiere die Ursachen des Fehlschlags und gib Verbesserungsvorschläge.
Wichtige Punkte:
1. Was ist schiefgelaufen?
2. Wie können wir es beim nächsten Mal vermeiden?
3. Welche Strategie muss geändert werden?
"""

        return self.llm.generate(prompt)

Anwendungsszenarien

Reflexion ist besonders geeignet für die folgenden Szenarien:

Aufgaben, die kontinuierliche Verbesserung erfordern, wie Dialogsysteme, Codegenerierung usw.

Szenarien, in denen die Kosten von Fehlern hoch, die Kosten eines erneuten Versuchs aber niedrig sind.

Situationen, in denen aus Fehlschlägen gelernt werden muss.


Strategien zur Aufgabenzerlegung

Komplexe Aufgaben müssen normalerweise in handhabbare Teilaufgaben zerlegt werden.

Effektive Aufgabenzerlegung ist die Grundlage der Planungsfähigkeit.

Rekursive Aufgabenzerlegung

Eine Aufgabe rekursiv in kleinere Teilaufgaben zerlegen, bis die Teilaufgaben direkt ausgeführt werden können.

Rekursive Aufgabenzerlegung

def decompose(task, is_executable_fn, decompose_fn):
    """
Aufgaben rekursiv zerlegen
:param task: Die zu zerlegende Aufgabe
:param is_executable_fn: Funktion, die bestimmt, ob die Aufgabe direkt ausgeführt werden kann
:param decompose_fn: Funktion zum Zerlegen der Aufgabe
:return: Liste der ausführbaren Aufgaben
    """

    # Wenn die Aufgabe direkt ausgeführt werden kann, gib sie direkt zurück
    if is_executable_fn(task):
        return [task]
   
    # Die Aufgabe in Teilaufgaben zerlegen
    subtasks = decompose_fn(task)
   
    # Jede Teilaufgabe rekursiv zerlegen
    result = []
    for subtask in subtasks:
        # Die Zerlegungsfunktion rekursiv auf Teilaufgaben aufrufen
        result.extend(
            decompose(subtask, is_executable_fn, decompose_fn)
        )
   
    return result


# Beispiel: Ermitteln, ob die Aufgabe ausführbar ist
def is_code_complete(task):
    """Prüfen, ob die Aufgabe Code direkt ausführen kann"""
    return task.get("type") == "code" and len(task.get("dependencies", [])) == 0


# Beispiel: Eine komplexe Aufgabe zerlegen
def decompose_programming_task(task):
    """Eine Programmieraufgabe zerlegen"""
    if "write_function" in task["type"]:
        return [
            {"type": "understand_requirements", "task": task["spec"]},
            {"type": "write_code", "spec": task["spec"]},
            {"type": "write_tests", "function": task["function_name"]},
            {"type": "verify_tests", "function": task["function_name"]}
        ]
    return [task]

Parallele Aufgabenzerlegung

Unabhängige Teilaufgaben identifizieren, die parallel ausgeführt werden können, um die Ausführungseffizienz zu verbessern.

Dies ist eine Schlüsselstrategie zur Beschleunigung der Aufgabenausführung.

Hierarchische Aufgabenzerlegung

Aufgaben in verschiedene Abstraktionsebenen unterteilen; Aufgaben auf hoher Ebene rufen Aufgaben auf niedriger Ebene auf und bilden einen Aufgabenhierarchiebaum.

Geeignet für komplexe Systeme, die mehrere Abstraktionsebenen erfordern.


Plan-and-Execute-Muster

Plan-and-Execute ist ein Architekturmuster, das Planung von Ausführung trennt.

Der Agent plant zuerst den gesamten Aufgabenablauf vollständig und führt dann gemäß dem Plan aus.

Unterschiede zu ReAct

ReAct verzahnt Reasoning und Ausführung, was flexibler ist, aber der Pfad kann instabil sein.

Plan-and-Execute plant zuerst und führt dann aus, was stabiler ist, aber keine dynamische Anpassungsfähigkeit bietet.

Code-Implementierung

Implementierung eines Plan-and-Execute-Agenten

class PlanAndExecuteAgent:
    """
Agent mit Plan-and-Execute-Architektur
Kernmechanismus: zuerst vollständig planen, dann gemäß dem Plan ausführen
    """

   
    def __init__(self, planner, executor):
        # Planer: verantwortlich für das Erstellen des Ausführungsplans
        self.planner = planner
        # Executor: verantwortlich für die Ausführung bestimmter Schritte
        self.executor = executor
   
    def run(self, task):
        """
Aufgabe ausführen
Unterteilt in Planungsphase und Ausführungsphase
        """

        # ==================== Planungsphase ====================
        # Den vollständigen Ausführungsplan auf einmal generieren
        plan = self.planner.create_plan(task)
       
        # ==================== Ausführungsphase ====================
        results = []
       
        # In der Reihenfolge gemäß dem Plan ausführen
        for step in plan.steps:
            # Den aktuellen Schritt ausführen
            result = self.executor.execute(step)
            results.append(result)
           
            # Prüfen, ob eine Neuplanung erforderlich ist
            # Zum Beispiel: Ausführungsergebnisse entsprechen nicht den Erwartungen oder es treten unerwartete Situationen auf
            if self.needs_replan(results):
                # Basierend auf aktuellen Ergebnissen neu planen
                plan = self.planner.replan(task, results)
       
        # Alle Ergebnisse integrieren
        return self.summarize(results)
   
    def needs_replan(self, results):
        """
Ermitteln, ob eine Neuplanung erforderlich ist
Prüfen, ob Ausführungsergebnisse den Erwartungen entsprechen
        """

        # Das letzte Ergebnis abrufen
        last_result = results[-1]
       
        # Wenn das Ergebnis eindeutig nicht den Erwartungen entspricht, ist eine Neuplanung erforderlich
        if last_result.is_unexpected():
            return True
       
        # Wenn das Ergebnis die Ausführung nachfolgender Schritte unmöglich macht, ist eine Neuplanung erforderlich
        if last_result.blocks_future():
            return True
       
        return False


class Planner:
    """Planner: Aufgabenausführungsplan generieren"""
   
    def create_plan(self, task):
        """Anfänglichen Ausführungsplan erstellen"""
        prompt = f"""
Aufgabe: {task}

Bitte erstellen Sie einen detaillierten Ausführungsplan, einschließlich:
1. Die Reihenfolge der auszuführenden Schritte
2. Die konkreten Operationen für jeden Schritt
3. Die Abhängigkeitsbeziehungen zwischen den Schritten

Ausgabeformat:
Schritt 1: [Operationsbeschreibung]
Schritt 2: [Operationsbeschreibung]
...
"""

        plan_text = self.llm.generate(prompt)
        return Plan.parse(plan_text)
   
    def replan(self, task, results):
        """Basierend auf Ausführungsergebnissen neu planen"""
        # Die abgeschlossenen Ergebnisse analysieren
        completed = [r for r in results if r.is_success]
        failed = [r for r in results if not r.is_success]
       
        # Einen angepassten Plan generieren
        prompt = f"""
Ursprüngliche Aufgabe: {task}
Abgeschlossene Schritte: {completed}
Fehlgeschlagene Schritte: {failed}

Bitte erstellen Sie einen angepassten Ausführungsplan:
"""

        plan_text = self.llm.generate(prompt)
        return Plan.parse(plan_text)


class Executor:
    """Executor: bestimmte Planschritte ausführen"""
   
    def execute(self, step):
        """Einen einzelnen Schritt ausführen"""
        # Die Ausführungsmethode basierend auf dem Schritttyp auswählen
        if step.type == "tool_call":
            return self.execute_tool_call(step)
        elif step.type == "code":
            return self.execute_code(step)
        elif step.type == "query":
            return self.execute_query(step)
       
        return Result.(success=False, error="Unbekannter Schritttyp")

Hinweis: Der Plan-and-Execute-Modus eignet sich für Szenarien, in denen die Aufgabenstruktur relativ stabil ist und im Voraus geplant werden kann. Für Umgebungen, die flexible Anpassung erfordern, ist der ReAct-Modus möglicherweise besser geeignet.


Kapitelzusammenfassung

Dieses Kapitel stellt die Kernfähigkeiten von KI-Agenten zum Schlussfolgern und Planen vor.

ReActDas Framework ermöglicht es dem Agenten, seine Strategie während der Ausführung durch eine Schleife aus Schlussfolgern und Handeln anzupassen.

Chain of Thought (CoT)Verbessert die Genauigkeit bei der Ausführung komplexer Aufgaben, indem der schrittweise Schlussfolgerungsprozess demonstriert wird.

Tree of Thoughts (ToT)Erweiterte die Gedankenkette und unterstützt Multipfad-Erkundung und Backtracking.

MCTSEs ist ein heuristischer Suchalgorithmus, geeignet für komplexe Entscheidungs- und Planungsprobleme.

ReflexionVerleiht dem Agenten Selbstreflexionsfähigkeiten, um aus Fehlern zu lernen und sich zu verbessern.

AufgabenzerlegungsstrategieSie ist die Grundlage der Planungsfähigkeit, einschließlich rekursiver Zerlegung, paralleler Zerlegung und hierarchischer Zerlegung.

Plan-and-ExecuteVerfolgt einen Ansatz, bei dem zuerst geplant und dann ausgeführt wird, geeignet für Aufgaben mit stabilen Strukturen.

Diese Technologien können einzeln oder in Kombination verwendet werden, um leistungsfähigere Agentensysteme zu erstellen.

Weitere Erweiterungen