Tree-of-Thought-Exploration
Gedanken verzweigen und bewerten
Tree-of-Thought-Exploration ist eine kostenlose AI Prompt Engineering-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Prompt Engineering-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.
Von Ketten zu Bäumen
Tree-of-Thought (ToT, Yao et al., 2023) erweitert Chain-of-Thought von einem einzelnen linearen Pfad zu einem Suchbaum aus Teillösungen. Jeder Knoten enthält einen kohärenten Zwischengedanken; die Zweige untersuchen alternative Fortsetzungen.
Dadurch kann das Modell über eine Lösung nachdenken: Es erzeugt mehrere nächste Schritte, bewertet sie, behält die vielversprechenden bei und geht von Sackgassen zurück. So ahmt es systematisches Problemlösen nach, statt sich auf die erste Idee festzulegen.
class ThoughtNode:
def __init__(self, state, parent=None):
self.state = state # partial solution / reasoning so far
self.parent = parent
self.children = []
self.value = None # evaluator scoreDie vier ToT-Komponenten
Ein ToT-System umfasst vier Designentscheidungen: die Zerlegung in Denkschritte (was einen Schritt ausmacht), den Gedankengenerator (wie nächste Schritte vorgeschlagen werden), den Zustands-Evaluator (wie Teillösungen bewertet werden) und den Suchalgorithmus (BFS, DFS oder Best-First-Suche).
Jede davon ist ein eigenes Prompt oder eine eigene Richtlinie. ToT zu entwerfen bedeutet, alle vier Komponenten für Ihre Aufgabe festzulegen.
tot = {
'decompose': step_definition, # e.g. one equation, one move
'generate': propose_thoughts, # sampling or proposal prompt
'evaluate': score_state, # value/vote prompt
'search': bfs_with_beam, # BFS | DFS | best-first
}Kandidatengedanken erzeugen
Es gibt zwei Strategien zur Erzeugung: Samplen Sie mehrere unabhängige Gedanken bei moderater Temperatur (geeignet bei einem vielfältigen Suchraum) oder schlagen Sie in einem einzigen Prompt eine Reihe verschiedener nächster Schritte vor (geeignet, wenn Sie ausdrücklich unterschiedliche Optionen wünschen).
Verwenden Sie einen kleinen Verzweigungsfaktor (häufig 3 bis 5). Zu viele Kandidaten lassen Suchraum und Kosten explodieren.
def propose_thoughts(state, k=4):
prompt = (
'Given the partial solution below, propose ' + str(k) +
' DISTINCT possible next steps.\n' + state
)
return parse_list(llm(prompt, temperature=0.7))Zustände bewerten
Der Zustands-Evaluator macht ToT zu mehr als zufälligem Sampling. Er bewertet, wie vielversprechend eine Teillösung ist, entweder über ein Value-Prompt (bewerten Sie diesen Zustand auf einer Skala von 1 bis 10 im Hinblick auf die Lösung des Problems) oder über ein Vote-Prompt (welcher dieser Zustände ist am vielversprechendsten?).
Die Abstimmung über mehrere Kandidaten ist häufig robuster als eine absolute Bewertung, weil relative Einschätzungen dem Modell leichter fallen.
def score_state(state):
prompt = (
'Rate how likely this partial solution leads to a correct '
'final answer. Reply sure / likely / impossible.\n' + state
)
label = llm(prompt, temperature=0).strip().lower()
return {'sure': 1.0, 'likely': 0.5, 'impossible': 0.0}.get(label, 0.3)BFS mit Beam Search
Breitensuche in ToT erweitert alle Knoten der aktuellen Front jeweils um eine Ebene und behält anschließend nur die b besten Knoten nach dem Score des Evaluators (einen sogenannten Beam). So wird die Explosion begrenzt und gleichzeitig werden mehrere Lösungswege parallel untersucht.
Die Beam-Breite b stellt die Breite der Suche den Kosten gegenüber. Eine Breite von 5 bei einer Tiefe von 3 ist ein gängiger Ausgangspunkt für strukturierte Rätsel.
def bfs_with_beam(root, depth, branch, beam):
frontier = [root]
for _ in range(depth):
nxt = []
for node in frontier:
for t in propose_thoughts(node.state, branch):
child = ThoughtNode(node.state + '\n' + t, node)
child.value = score_state(child.state)
nxt.append(child)
frontier = sorted(nxt, key=lambda n: -n.value)[:beam]
return max(frontier, key=lambda n: n.value)DFS mit Backtracking
Tiefensuche in ToT verfolgt den vielversprechendsten Zweig bis in die Tiefe und führt ein Backtracking durch, wenn der Evaluator einen Zustand als aussichtslos bewertet. Das eignet sich für Probleme mit einer klaren Vorstellung davon, wann ein Teilzustand nicht realisierbar ist, etwa Constraint-Rätsel.
Das frühzeitige Abschneiden unmöglicher Zweige bringt den größten Effizienzgewinn, weil die Erweiterung zum Scheitern verurteilter Teilbäume vermieden wird.
def dfs(node, depth, branch, prune=0.2):
if depth == 0 or is_solution(node.state):
return node
for t in propose_thoughts(node.state, branch):
child = ThoughtNode(node.state + '\n' + t, node)
child.value = score_state(child.state)
if child.value < prune:
continue # backtrack: prune dead end
res = dfs(child, depth - 1, branch, prune)
if res and is_solution(res.state):
return res
return NoneToT im Vergleich zur Selbstkonsistenz
Selbstkonsistenz erzeugt unabhängige vollständige Ketten und stimmt über sie ab. ToT steuert die Suche aktiv durch Zwischenbewertungen und Backtracking und investiert Rechenaufwand dort, wo er vielversprechend ist.
ToT ist besonders stark bei Problemen, die Planung oder Suche erfordern oder bei denen frühe Fehler fatal sind (Game of 24, Kreuzworträtsel, Planung). Bei Aufgaben mit kostengünstigen vielfältigen Ketten und einer diskreten Antwort ist Selbstkonsistenz einfacher und häufig ausreichend.
# Rule of thumb
# - reachable by diverse single passes -> self-consistency
# - needs lookahead / pruning / backtrack -> tree-of-thought
# ToT cost ~ branch * depth * beam * (gen + eval) LLM callsKostenexplosion und Budgets
ToT ist teuer: Jeder Knoten löst Aufrufe zur Erzeugung und Bewertung aus. Die Gesamtkosten wachsen ungefähr wie Verzweigungsfaktor x Tiefe x Beam, zuzüglich der Aufrufe des Evaluators. Ohne ein festes Budget können sie stark anwachsen.
Begrenzen Sie die Gesamtzahl der LLM-Aufrufe, verwenden Sie Best-First-Suche, um das Budget auf die wertvollste Front zu konzentrieren, und greifen Sie auf die beste Teillösung zurück, wenn das Budget erschöpft ist.
import heapq
def best_first(root, max_calls):
heap = [(-root.value, root)]
best, calls = root, 0
while heap and calls < max_calls:
_, node = heapq.heappop(heap)
for t in propose_thoughts(node.state, 3):
calls += 1
child = ThoughtNode(node.state + '\n' + t, node)
child.value = score_state(child.state); calls += 1
if child.value > best.value:
best = child
heapq.heappush(heap, (-child.value, child))
return bestZuverlässigkeit des Evaluators
ToT ist nur so gut wie sein Evaluator. Ein schlecht kalibrierter Evaluator schneidet korrekte Zweige ab oder verfolgt Sackgassen. Verbessern Sie ihn durch Abstimmungen (mehrere Bewertungen pro Zustand), Few-shot-Beispiele guter und schlechter Zustände oder einen externen Verifier (einen Unit-Test, einen Solver oder einen Checker).
Wenn eine objektive Prüfung möglich ist (ob eine Gleichung erfüllt ist oder der Code erfolgreich ausgeführt wird), ziehen Sie sie einem LLM-Urteil vor.
def robust_eval(state, votes=3):
scores = [score_state(state) for _ in range(votes)]
return sum(scores) / votes # average to reduce judge noise
# Even better: replace with a deterministic verifier when availablePraktische Einsatzmöglichkeiten
ToT lohnt sich bei einer eng begrenzten, aber wertvollen Klasse von Problemen: mehrstufiger Planung, kombinatorischen Rätseln und Aufgaben, bei denen die Überprüfung eines Schritts günstiger ist als die Lösung des gesamten Problems. Für die meisten alltäglichen Prompts ist ToT übertrieben.
Bei Reasoning-native-Modellen mit leistungsfähiger integrierter Suche verursacht ein explizites ToT-Gerüst häufig zusätzliche Kosten ohne großen Zugewinn. Führen Sie vor der Einführung Benchmarks durch.
def choose_strategy(task):
if task.requires_search and task.step_verifiable:
return 'tree-of-thought'
if task.discrete_answer:
return 'self-consistency'
return 'single chain-of-thought'Ein minimaler ToT-Löser
Von Anfang bis Ende: Definieren Sie einen Schritt, schlagen Sie einen kleinen Gedanken-Zweig vor, bewerten Sie jeden Gedanken (durch Abstimmung oder mit einem Verifier), durchsuchen Sie den Raum per BFS-Beam oder DFS-Backtracking unter Einhaltung eines Aufrufbudgets und geben Sie den besten Endzustand zurück.
Erfassen Sie Knotenzahlen und Evaluator-Scores, damit Sie Verzweigungsfaktor, Tiefe und Beam empirisch für jede Aufgabe abstimmen können.
def solve(problem, branch=4, depth=3, beam=5, budget=200):
root = ThoughtNode(problem)
root.value = score_state(root.state)
node = bfs_with_beam(root, depth, branch, beam)
return extract_solution(node.state)Kurztest
Wählen Sie die passende Strategie für das Nachdenken aus.
Zusammenfassung
Wichtigste Erkenntnisse:
- ToT erweitert CoT zu einem Suchbaum mit Gedankenerzeugung, Zustandsbewertung und einem Suchalgorithmus.
- Verwenden Sie BFS mit einem Beam oder DFS mit Backtracking. Halten Sie den Verzweigungsfaktor klein, um eine Explosion des Suchraums zu verhindern.
- Der Zustands-Evaluator ist der entscheidende Bestandteil. Machen Sie ihn durch Abstimmungen oder einen externen Verifier robuster.
- Die Kosten wachsen wie Verzweigungsfaktor x Tiefe x Beam. Erzwingen Sie daher ein Aufrufbudget, häufig mithilfe der Best-First-Suche.
- Reservieren Sie ToT für planungs- oder kombinatorische Probleme, bei denen sich einzelne Schritte verifizieren lassen. Für alltägliche Prompts ist es übertrieben.
Lerne AI Prompt Engineering mit einem KI-Tutor — kostenlos
Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.
- Kurse
- 53
- Lektionen
- 199
Häufig gestellte Fragen
Ist die Lektion „Tree-of-Thought-Exploration“ kostenlos?
Ja — der vollständige Text von „Tree-of-Thought-Exploration“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Prompt Engineering-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Tree-of-Thought-Exploration“?
Gedanken verzweigen und bewerten Du übst AI Prompt Engineering mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Prompt Engineering zu starten?
Keine Vorkenntnisse erforderlich. AI Prompt Engineering auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.
Wie lange dauert die Lektion „Tree-of-Thought-Exploration“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Prompt Engineering-Lektion Code schreiben und ausführen?
Ja. Jede AI Prompt Engineering-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Chain-of-Thought-Prompting
- Self-Consistency-Sampling
- Tree-of-Thought-Exploration
- Wann Reasoning-Prompts helfen