Promptteknik til AI · Lektion

Udforskning af tree-of-thought

Forgren og evaluér tanker.

Lektion 3 af 413 trin

Udforskning af tree-of-thought er en gratis Promptteknik til AI-lektion på CoddyKit. Dette er lektion 3 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Promptteknik til AI, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Promptteknik til AI-kurset indeholder 4 lektioner i alt.

Fra kæder til træer

Tanketræ (ToT, Yao et al., 2023) generaliserer ræsonneringskæden fra én lineær sti til et søgetræ med delvise løsninger. Hver node er en sammenhængende mellemtanke, og grenene udforsker alternative fortsættelser.

Det giver modellen mulighed for at overveje flere muligheder: generér flere næste trin, evaluér dem, behold de lovende, og gå tilbage fra blinde spor. Det efterligner systematisk problemløsning i stedet for at binde sig til den første idé.

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 score

De fire ToT-komponenter

Et ToT-system har fire designvalg: opdeling af tanker (hvad er et trin), tankegeneratoren (hvordan næste trin foreslås), tilstandsvurderingen (hvordan delvise løsninger bedømmes) og søgealgoritmen (BFS, DFS eller bedste-først).

Hver del er en separat instruktion eller strategi. At designe ToT betyder, at du skal specificere alle fire dele til din opgave.

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
}

Generering af kandidattanker

Der er to genereringsstrategier: udtag flere uafhængige tanker ved moderat temperatur (godt, når rummet er rigt), eller foreslå et sæt forskellige næste trin i én instruktion (godt, når du ønsker udtrykkeligt forskellige muligheder).

Brug en lille forgreningsfaktor (ofte 3 til 5); for mange kandidater får søgningen og omkostningen til at eksplodere.

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))

Evaluering af tilstande

Tilstandsvurderingen er det, der gør ToT til mere end tilfældig udtagning. Den bedømmer, hvor lovende en delvis løsning er, enten med en værdibaseret instruktion (vurder denne tilstand fra 1 til 10 efter, hvor tæt den er på at løse problemet) eller med en afstemningsinstruktion (hvilken af disse tilstande er mest lovende).

Afstemning blandt kandidater er ofte mere robust end absolutte pointtal, fordi relative vurderinger er lettere for modellen.

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 med strålesøgning

Bredde-først ToT udvider alle noder på søgefronten ét niveau ad gangen og beholder derefter kun de b bedste efter vurderingsmodellens pointtal (en stråle). Det begrænser eksplosionen, samtidig med at flere linjer udforskes parallelt.

Strålebredden b afvejer udforskningens bredde mod omkostningen; en bredde på 5 med dybde 3 er et almindeligt udgangspunkt for strukturerede gåder.

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 med tilbagesporing

Dybde-først ToT går ned ad den mest lovende gren og går tilbage, når vurderingsmodellen bedømmer en tilstand som håbløs. Det passer til problemer med en klar forståelse af, hvornår en delvis tilstand er umulig, såsom begrænsningsopgaver.

Beskæring af umulige grene tidligt er den vigtigste effektivitetsgevinst, fordi det undgår unødvendig udvidelse af dødsdømte undertræer.

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 None

ToT sammenlignet med selvkonsistens

Selvkonsistens udtager uafhængige komplette kæder og stemmer om dem. ToT styrer aktivt udforskningen med mellemliggende vurdering og tilbagesporing og investerer beregning dér, hvor mulighederne er lovende.

ToT er bedst til problemer, der kræver planlægning eller søgning, eller hvor tidlige fejl er fatale (Game of 24, krydsord og planlægning). Ved opgaver med billige, forskellige kæder og et diskret svar er selvkonsistens enklere og ofte tilstrækkeligt.

# 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 calls

Omkostningseksplosion og budgetter

ToT er dyrt: hver node udløser genererings- og evalueringskald. De samlede omkostninger skalerer omtrent som forgrening × dybde × strålebredde plus kald til vurderingsmodellen. Uden et fast budget kan omkostningerne vokse voldsomt.

Sæt en grænse for det samlede antal LLM-kald, brug bedste-først-søgning til at bruge budgettet på den mest værdifulde søgefront, og vælg den bedste delvise løsning som reserve, hvis budgettet slipper op.

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 best

Vurderingsmodellens pålidelighed

ToT er kun så god som sin vurderingsmodel. En forkert kalibreret vurderingsmodel beskærer korrekte grene eller forfølger blinde spor. Forbedr den med afstemning (flere vurderinger af hver tilstand), få eksempler på gode og dårlige tilstande eller en ekstern verificator (en enhedstest, en løser eller et kontrolprogram).

Hvor der findes en objektiv kontrol (holder ligningen, består koden), bør du foretrække den frem for en LLM-vurdering.

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 available

Praktisk anvendelighed

ToT kan betale sig for en snæver, men værdifuld klasse af problemer: planlægning i flere trin, kombinatoriske opgaver og opgaver, hvor det er billigere at verificere et trin end at løse det hele. Ved de fleste almindelige instruktioner er ToT overflødigt.

På modeller med indbygget ræsonnering og stærk søgning tilfører en eksplicit ToT-struktur ofte omkostninger uden stor gevinst; mål dens effekt, før du tager den i brug.

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'

En minimal ToT-løser

Fra start til slut: definér et trin, foreslå en lille forgrening af tanker, evaluér hver tanke (med afstemning eller en verificator), søg med BFS-strålesøgning eller DFS-tilbagesporing inden for et kaldsbudget, og returnér den bedste sluttilstand.

Registrér antallet af noder og vurderingsmodellens pointtal, så du empirisk kan justere forgrening, dybde og stråle for hver opgave.

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)

Hurtigt tjek

Vælg den rigtige strategi for overvejelse.

Besvar den i den interaktive lektion

Opsummering

Vigtigste pointer:

ToT generaliserer CoT til et søgetræ med tankegenerering, tilstandsvurdering og en søgealgoritme.
Brug BFS med en stråle eller DFS med tilbagesporing; hold forgreningsfaktoren lille for at begrænse eksplosionen.
Tilstandsvurderingen er kernen; gør den mere robust med afstemning eller en ekstern verificator.
Omkostningen skalerer som forgrening × dybde × strålebredde, så håndhæv et kaldsbudget, ofte via bedste-først-søgning.
Forbehold ToT til planlægnings- og kombinatoriske opgaver, hvor trin kan verificeres; til almindelige instruktioner er den overflødig.

Gratis at komme i gang

Lær Promptteknik til AI med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 53
Lektioner: 199

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Udforskning af tree-of-thought” gratis?

Ja — alle 3 lektioner i læringssporet Promptteknik til AI, inklusive “Udforskning af tree-of-thought”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Promptteknik til AI-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Udforskning af tree-of-thought”?

Forgren og evaluér tanker. Du øver dig i Promptteknik til AI med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Promptteknik til AI?

Der kræves ingen tidligere erfaring. Promptteknik til AI på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 3 af 4.

Hvor lang tid tager lektionen “Udforskning af tree-of-thought”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Promptteknik til AI-lektion?

Ja. Alle Promptteknik til AI-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Promptteknik til AI