Tree-of-Thought: Struktureret udforskning
På denne side
Lektion opdateret 3. november 2026 baseret på OpenAI-dokumentation:
temperatureogtop_paccepteres kun med en ræsonneringsindsats pånone, hvorimod GPT-5.6-modeller ræsonnerer som standard (medium). Opkald, der sætter disse parametre, skal derfor specificerereasoning={"effort": "none"}(Responses API) ellerreasoning_effort="none"(Chat Completions). Kilder: Brug af GPT-6 · GPT-5.6 Terra.
Tree-of-Thought: Struktureret udforskning
Tree-of-Thought (ToT) er en prompting-teknik, der strukturerer modellens ræsonnement som et beslutningstræ. I stedet for at følge en enkelt, lineær tankegang udforsker modellen flere grene, evaluerer hver enkelt og beholder kun de mest lovende. Ligheden med en søgealgoritme er direkte: du genererer kandidater, scorer dem og beskærer resten. Det gør teknikken yderst effektiv til problemer, der kræver planlægning eller backtracking.
Forskel fra Chain-of-Thought
Chain-of-Thought (CoT) følger lineær ræsonnering: trin 1, trin 2, trin 3. Dens svaghed er strukturel. Hvis modellen vælger en forkert vej ved trin 2, arver alt, der følger, den fejl, og der findes ingen mekanisme til at gå tilbage. Ræsonnementet kan være perfekt formuleret, men det tager udgangspunkt i en falsk præmis. Tree-of-Thought udforsker flere retninger ved hvert trin og kasserer blindgyder, før der investeres yderligere udvikling i dem.
# Chain-of-Thought (lineær)
# Trin 1 → Trin 2 → Trin 3 → Svar
# Tree-of-Thought (træbaseret)
# Trin 1
# / | \
# Mul A Mul B Mul C ← evaluering
# | | ✗ ← beskæring
# Mul A1 Mul B1
# | |
# Svar Svar ← endeligt valg
Implementering med ét prompt
Den enkleste version passer ind i et enkelt opkald: promptet tvinger modellen til at følge en udforskningsstruktur – generer tre tilgange, evaluér dem, vælg én og udvikl den. Dette er billigt og ofte tilstrækkeligt til at tackle et åbent spørgsmål. Vær dog opmærksom på én begrænsning, før du stoler på det: modellen foreslår og evaluerer i samme åndedrag, hvilket gør den lempelig over for sine egne idéer og resulterer i en mindre streng beskæring, end nødvendigt er.
from openai import OpenAI
client = OpenAI()
def tree_of_thought_simple(problem: str) -> str:
"""ToT i et enkelt prompt."""
prompt = f"""Løs dette problem ved hjælp af Tree-of-Thought-tilgangen.
Problem: {problem}
Trin 1 - Generer 3 forskellige tilgange:
- Tilgang A: ...
- Tilgang B: ...
- Tilgang C: ...
Trin 2 - Evaluér hver tilgang (styrker og svagheder):
- Tilgang A: ...
- Tilgang B: ...
- Tilgang C: ...
Trin 3 - Vælg den bedste tilgang og udvikl den:
Valgt tilgang: ...
Detaljeret udvikling: ...
Trin 4 - Endeligt svar:
..."""
response = client.responses.create(
model="gpt-5.6-sol",
reasoning={"effort": "none"}, # temperature kræver effort none
input=prompt,
temperature=0.7
)
return response.output_text
Implementering med flere opkald
Til komplekse problemer bør du adskille hvert trin i distinkte opkald. Denne opdeling giver dig to ting, som et enkelt prompt ikke kan. For det første kontrol af temperaturen trin for trin: 0,8 til generering, hvor mangfoldighed i forslag er hele pointen med metoden, og derefter 0,3 til evaluering og udvikling, hvor du ønsker rigorøsitet og reproducerbarhed. For det andet mellemresultater, som du kan inspicere, logge eller endda sende til menneskelig validering, før du lader kæden fortsætte.
def tree_of_thought(problem: str, breadth: int = 3,
depth: int = 3) -> dict:
"""ToT med udforskning på flere niveauer."""
system = "Du er en ekspert i struktureret problemløsning."
# Trin 1: Generer indledende grene
gen_prompt = (f"Problem: {problem}\n\n"
f"Foreslå {breadth} forskellige tilgange til at løse "
f"dette problem. For hver tilgang skal du angive en titel og "
f"en beskrivelse på 2-3 sætninger. Nummerér dem fra 1 til {breadth}.")
branches_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature kræver effort none
instructions=system,
input=gen_prompt,
temperature=0.8
)
branches = branches_response.output_text
# Trin 2: Evaluér hver gren
eval_prompt = (f"Problem: {problem}\n\n"
f"Her er {breadth} foreslåede tilgange:\n{branches}\n\n"
f"Evaluér hver tilgang ud fra 3 kriterier (score /10):\n"
f"- Gennemførlighed\n- Effektivitet\n- Enkelhed\n\n"
f"Rangér dem fra bedst til værst med begrundelse.")
eval_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature kræver effort none
instructions=system,
input=eval_prompt,
temperature=0.3
)
evaluation = eval_response.output_text
# Trin 3: Udvikl den bedste gren
dev_prompt = (f"Problem: {problem}\n\n"
f"Evaluering af tilgange:\n{evaluation}\n\n"
f"Udvikl den højest rangerede tilgang i detaljer. "
f"Levér en komplet, handlingsorienteret løsning.")
solution = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature kræver effort none
instructions=system,
input=dev_prompt,
temperature=0.3
)
return {
"branches": branches,
"evaluation": evaluation,
"solution": solution.output_text
}
Gennemarbejdet eksempel: Softwarearkitektur
Problemet nedenfor er netop den type, hvor ToT tilfører værdi. Flere strategier er forsvarlige – caching, læsereplikaer, udskillelse af søgetjenesten, blue-green deployment – og valget afhænger af begrænsninger, som promptet angiver eksplicit, især teamstørrelse. Et direkte prompt ville give dig den løsning, der oftest citeres i teknisk litteratur, uanset disse begrænsninger; ToT sætter den op mod de andre og skal forsvare sin rangering baseret på kriterier for gennemførlighed.
problem = """
Vores monolitiske REST-API (Django, PostgreSQL) rammer sine grænser:
- Maks. 500 forespørgsler/sekund
- Svartid > 2 sek. på søge-endepunkter
- Deployment = 30 minutters nedetid
- 3 udviklere på teamet
Hvordan kan vi forbedre ydeevne og tilgængelighed
uden at omskrive hele applikationen?
"""
result = tree_of_thought(problem, breadth=4)
print(result["solution"])
Hvor ToT vinder, og hvor det spilder din tid
Teknikken skinner ved planlægningsproblemer – arkitektur, køreplaner, strategi – ved begrænsede problemer som optimering eller ressourceallokering, ved kompleks fejlsøgning, hvor flere årsager forbliver plausible samtidigt, og ved tekniske beslutninger som valg af framework eller database. Disse situationer deler to træk: Der findes flere gyldige løsninger, og der findes et eksplicit kriterium til at skelne mellem dem.
Omvendt bør du springe det over ved simple faktuelle spørgsmål, hvor der ikke er noget at udforske, og hvor du ville betale for tre opkald for at få et indlysende svar. Det fejler også ved åbne kreative opgaver på grund af manglen på et forsvarligt evalueringskriterium: Det giver ingen mening at rangere tre reklameslogans på en skala for gennemførlighed. Undgå det endelig, når latens er kritisk, da versionen med flere opkald mekanisk kæder flere API-anmodninger sammen, før noget returneres.
Kombination med ræsonneringsindstillinger
Ved høje ræsonneringsindstillinger udfører GPT-5.6-modeller allerede struktureret intern udforskning. Eksplicit ToT bliver da i høj grad redundant og får dig til at betale dobbelt for det samme arbejde. Reserver det til situationer, hvor ræsonnering er deaktiveret eller lav, som i sammenligningen nedenfor.
# Med lav ræsonnering: eksplicit ToT er nyttigt
result = tree_of_thought(problem, breadth=3)
# Med høj ræsonnering: modellen ræsonnerer allerede dybt
response = client.responses.create(
model="gpt-5.6-sol",
input=problem,
reasoning={"effort": "high"}
)
For at beslutte det i din egen kontekst: Tag et arkitektur- eller designproblem, du faktisk har på tegnebrættet denne uge, kør det gennem ToT med flere opkald med breadth=3, og indsend det derefter, som det er, i et direkte prompt. Sammenlign de to løsninger og frem for alt token-omkostningerne ved hver. Ved en beslutning med høje indsats mere end opvejer kvalitetsforskellen de ekstra omkostninger; ved et sekundært spørgsmål gør den ikke, og viden om dette vil forhindre dig i at anvende teknikken overalt ud af vane.
Vigtige pointer
- ToT udforsker flere ræsonnementsveje og vælger den bedste
- Enkel version med ét prompt eller avanceret version med flere opkald
- Ideel til planlægning, arkitektur og kompleks fejlsøgning
- Ved høje ræsonneringsindstillinger har GPT-5.6-modeller allerede implicit ToT
- De ekstra token-omkostninger er berettigede ved beslutninger med stor betydning