Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Tree-of-Thought: Utforskning med struktur

Lektion 7 av 16 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Tree-of-Thought: Utforskning med struktur
  2. Skillnad från Chain-of-Thought
  3. Implementering med en enda prompt
  4. Implementering med flera anrop
  5. Genomgångsexempel: Programvaruarkitektur
  6. Där ToT vinner, och där det slösar din tid
  7. Kombinera med inställningar för resonemang
  8. Viktiga punkter

Lektionen uppdaterad den 3 november 2026 baserat på OpenAI:s dokumentation: temperature och top_p accepteras endast med ett resonemangsarbete (reasoning effort) på none, medan GPT-5.6-modeller resonerar som standard (medium). Anrop som ställer in dessa parametrar måste därför specificera reasoning={"effort": "none"} (Responses API) eller reasoning_effort="none" (Chat Completions). Källor: Använda GPT-6 · GPT-5.6 Terra.

Tree-of-Thought: Utforskning med struktur

Tree-of-Thought (ToT) är en promptteknik som strukturerar modellens resonemang som ett beslutsträd. Istället för att följa en enda, linjär tankegång utforskar modellen flera grenar, utvärderar var och en och behåller endast de mest lovande. Liknelsen med en sökalgoritm är direkt: du genererar kandidater, poängsätter dem och beskär resten. Detta gör tekniken mycket effektiv för problem som kräver planering eller backtracking.

Skillnad från Chain-of-Thought

Chain-of-Thought (CoT) följer linjärt resonemang: steg 1, steg 2, steg 3. Svagheten ligger i strukturen. Om modellen hamnar på fel spår vid steg 2 ärver allt som följer detta fel, och det finns ingen mekanism för att gå tillbaka. Resonemanget kan vara perfekt formulerat, men det utgår från en falsk premiss. Tree-of-Thought utforskar flera riktningar vid varje steg och sållar bort återvändsgränder innan ytterligare utveckling investeras i dem.

# Chain-of-Thought (linjär)
# Steg 1 → Steg 2 → Steg 3 → Svar

# Tree-of-Thought (trädstruktur)
#            Steg 1
#          /    |    \
#     Alt A  Alt B  Alt C    ← utvärdering
#       |      |      ✗      ← beskärning
#    Alt A1  Alt B1
#      |       |
#   Svar    Svar              ← slutligt val

Implementering med en enda prompt

Den enklaste versionen ryms i ett enda anrop: prompten tvingar modellen att följa en utforskningsstruktur – generera tre tillvägagångssätt, utvärdera dem, välj ett och utveckla det. Detta är billigt och ofta tillräckligt för att tackla en öppen fråga. Var dock medveten om en begränsning innan du förlitar dig på det: modellen föreslår och utvärderar i samma veva, vilket gör den överseende med sina egna idéer och resulterar i en mindre hård beskärning än vad som egentligen behövs.

from openai import OpenAI

client = OpenAI()

def tree_of_thought_simple(problem: str) -> str:
    """ToT i en enda prompt."""
    prompt = f"""Lös detta problem med Tree-of-Thought-metoden.

Problem: {problem}

Steg 1 - Generera 3 olika tillvägagångssätt:
- Tillvägagångssätt A: ...
- Tillvägagångssätt B: ...
- Tillvägagångssätt C: ...

Steg 2 - Utvärdera varje tillvägagångssätt (styrkor och svagheter):
- Tillvägagångssätt A: ...
- Tillvägagångssätt B: ...
- Tillvägagångssätt C: ...

Steg 3 - Välj det bästa tillvägagångssättet och utveckla det:
Valt tillvägagångssätt: ...
Detaljerad utveckling: ...

Steg 4 - Slutligt 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 flera anrop

För komplexa problem bör du separera varje steg i distinkta anrop. Denna uppdelning ger dig två saker som en enda prompt inte kan erbjuda. Först, temperaturkontroll steg för steg: 0,8 för generering, där mångfalden i förslagen är hela poängen med metoden, och sedan 0,3 för utvärdering och utveckling, där du istället vill ha rigorös noggrannhet och reproducerbarhet. För det andra, mellanliggande resultat som du kan inspektera, logga eller till och med skicka för mänsklig validering innan du låter kedjan fortsätta.

def tree_of_thought(problem: str, breadth: int = 3,
                    depth: int = 3) -> dict:
    """ToT med utforskning på flera nivåer."""
    system = "Du är en expert på strukturerad problemlösning."

    # Steg 1: Generera initiala grenar
    gen_prompt = (f"Problem: {problem}\n\n"
                  f"Föreslå {breadth} olika tillvägagångssätt för att lösa "
                  f"detta problem. För varje tillvägagångssätt, ange en titel och "
                  f"en beskrivning på 2–3 meningar. Numrera dem 1 till {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

    # Steg 2: Utvärdera varje gren
    eval_prompt = (f"Problem: {problem}\n\n"
                   f"Här är {breadth} föreslagna tillvägagångssätt:\n{branches}\n\n"
                   f"Utvärdera varje tillvägagångssätt utifrån 3 kriterier (poäng /10):\n"
                   f"- Genomförbarhet\n- Effektivitet\n- Enkelhet\n\n"
                   f"Ranka dem från bäst till sämst med motivering.")

    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

    # Steg 3: Utveckla den bästa grenen
    dev_prompt = (f"Problem: {problem}\n\n"
                  f"Utvärdering av tillvägagångssätt:\n{evaluation}\n\n"
                  f"Utveckla det högst rankade tillvägagångssättet i detalj. "
                  f"Ge en komplett och genomförbar 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
    }

Genomgångsexempel: Programvaruarkitektur

Problemet nedan är exakt den typ där ToT tillför värde. Flera strategier är försvarbara – cachelagring, läskopior, extrahering av söktjänsten, blue-green-deployments – och valet beror på begränsningar som prompten uttryckligen anger, särskilt teamstorlek. En direkt prompt skulle ge dig den lösning som oftast citeras i teknisk litteratur, oavsett dessa begränsningar; ToT ställer den mot de andra och måste försvara sin rankning baserat på genomförbarhetskriterier.

problem = """
Vårt monolitiska REST-API (Django, PostgreSQL) når sina gränser:
- Max 500 förfrågningar/sekund
- Svarstid > 2 s på sökendpunkter
- Deployment = 30 minuters driftstopp
- 3 utvecklare i teamet

Hur kan vi förbättra prestanda och tillgänglighet
utan att skriva om hela applikationen?
"""

result = tree_of_thought(problem, breadth=4)
print(result["solution"])

Där ToT vinner, och där det slösar din tid

Tekniken lyser vid planeringsproblem – arkitektur, färdplaner, strategi – vid begränsade problem som optimering eller resursfördelning, vid komplex felsökning där flera orsaker är plausibla samtidigt, och vid tekniska beslut som valet av ramverk eller databas. Dessa situationer delar två egenskaper: det finns flera giltiga lösningar, och det finns ett explicit kriterium för att skilja mellan dem.

Å andra sidan, hoppa över det för enkla faktafrågor där det inte finns något att utforska och där du bara skulle betala för tre anrop för att få ett uppenbart svar. Det misslyckas också med öppna kreativa uppgifter på grund av avsaknaden av ett försvarbart utvärderingskriterium: att ranka tre reklamslogans på en genomförbarhetsskala ger ingen mening. Undvik det slutligen när latens är avgörande, eftersom versionen med flera anrop mekaniskt kedjar ihop flera API-förfrågningar innan något returneras.

Kombinera med inställningar för resonemang

Vid höga inställningar för resonemang utför GPT-5.6-modeller redan en strukturerad intern utforskning. Explicit ToT blir då till stor del överflödigt och du betalar dubbelt för samma arbete. Reservera det för situationer där resonemang är inaktiverat eller lågt, som i jämförelsen nedan.

# Med lågt resonemang: explicit ToT är användbart
result = tree_of_thought(problem, breadth=3)

# Med högt resonemang: modellen resonerar redan djupt
response = client.responses.create(
    model="gpt-5.6-sol",
    input=problem,
    reasoning={"effort": "high"}
)

För att besluta i din egen kontext, ta ett arkitektur- eller designproblem som du faktiskt har på ditt bord denna vecka, kör det genom ToT med flera anrop med breadth=3, och skicka det sedan oförändrat i en direkt prompt. Jämför de två lösningarna och framför allt token-kostnaden för var och en. För ett beslut med hög insats betalar sig kvalitetsskillnaden mer än väl för den extra kostnaden; för en sekundär fråga gör den det inte, och att veta detta hindrar dig från att applicera tekniken överallt av ren vana.

Viktiga punkter

  • ToT utforskar flera resonemangsvägar och väljer den bästa
  • Enkel version med en prompt eller avancerad version med flera anrop
  • Idealiskt för planering, arkitektur och komplex felsökning
  • Vid höga inställningar för resonemang har GPT-5.6-modeller redan implicit ToT
  • Den extra token-kostnaden är motiverad för beslut med stor påverkan