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
"""
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 = """
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 = """
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
"""
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
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
"""
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
"""
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
"""
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