Tree-of-Thought: Raziskovanje s strukturo
Na tej strani
Lekcija posodobljena 3. novembra 2026 na podlagi dokumentacije OpenAI: parametra
temperatureintop_psta sprejeta le pri prizadevanju za sklepanje (reasoning effort) vrednostinone, medtem ko modeli GPT-5.6 privzeto sklepajo (medium). Klici, ki nastavljajo te parametre, morajo zato določitireasoning={"effort": "none"}(Responses API) alireasoning_effort="none"(Chat Completions). Viri: Uporaba GPT-6 · GPT-5.6 Terra.
Tree-of-Thought: Raziskovanje s strukturo
Tree-of-Thought (ToT) je tehnika pozivov, ki strukturira sklepanje modela kot odločitveno drevo. Namesto da bi sledil eni sami linearni poti razmišljanja, model raziskuje več vej, ovrednoti vsako in obdrži le najbolj obetavne. Podobnost z algoritmom iskanja je neposredna: generiraš kandidate, jih oceniš in ostale odrežeš. To metodo makes izjemno učinkovito za težave, ki zahtevajo načrtovanje ali vračanje nazaj (backtracking).
Razlika glede na Chain-of-Thought
Chain-of-Thought (CoT) sledi linearnemu razmišljanju: 1. korak, 2. korak, 3. korak. Njegova šibkost je strukturna. Če model v 2. koraku krene po napačni poti, vse, kar sledi, podeduje to napako, saj ni mehanizma za vrnitev nazaj. Razmišljanje je lahko popolnoma artikulirano, a izhaja iz napačne predpostavke. Tree-of-Thought na vsakem koraku raziskuje več smeri in odreže slepe ulice, preden bi vanje vložil nadaljnji razvoj.
# Chain-of-Thought (linearno)
# Korak 1 → Korak 2 → Korak 3 → Odgovor
# Tree-of-Thought (temelji na drevesu)
# Korak 1
# / | \
# Možnost A Možnost B Možnost C ← ovrednotenje
# | | ✗ ← obrezovanje
# Možnost A1 Možnost B1
# | |
# Odgovor Odgovor ← končna izbira
Izvedba z enim pozivom
Najpreprostejša različica se prilega v en sam klic: poziv prisili model, da sledi strukturi raziskovanja – generiraj tri pristope, jih ovrednoti, izberi enega in ga razvij. To je poceni in pogosto zadostuje za reševanje odprtih vprašanj. Preden se zanašaš na to, bodi pozoren na eno omejitev: model predlaga in ovrednoti v istem dihu, zaradi česar je popustljiv do lastnih idej, kar povzroči manj strogo obrezovanje, kot bi bilo potrebno.
from openai import OpenAI
client = OpenAI()
def tree_of_thought_simple(problem: str) -> str:
"""ToT v enem samem pozivu."""
prompt = f"""Reši to težavo z uporabo pristopa Tree-of-Thought.
Težava: {problem}
1. korak - Generiraj 3 različne pristope:
- Pristop A: ...
- Pristop B: ...
- Pristop C: ...
2. korak - Ovrednoti vsak pristop (prednosti in slabosti):
- Pristop A: ...
- Pristop B: ...
- Pristop C: ...
3. korak - Izberi najboljši pristop in ga razvij:
Izbran pristop: ...
Podroben razvoj: ...
4. korak - Končni odgovor:
..."""
response = client.responses.create(
model="gpt-5.6-sol",
reasoning={"effort": "none"}, # temperature requires effort none
input=prompt,
temperature=0.7
)
return response.output_text
Izvedba z več klici
Za kompleksne težave vsak korak loči v posebne klice. Ta razčlenitev ti daje dve stvari, ki jih en sam poziv ne more. Prvič, nadzor temperature korak za korakom: 0,8 za generiranje, kjer je raznolikost predlogov bistvo metode, nato 0,3 za ovrednotenje in razvoj, kjer želiš strogost in ponovljivost. Drugič, vmesne rezultate, ki jih lahko pregledaš, zabeležiš ali celo predložiš v človeško validacijo, preden veriga nadaljuje.
def tree_of_thought(problem: str, breadth: int = 3,
depth: int = 3) -> dict:
"""ToT z raziskovanjem na več ravneh."""
system = "Si strokovnjak za strukturirano reševanje težav."
# 1. korak: Generiraj začetne veje
gen_prompt = (f"Težava: {problem}\n\n"
f"Predlagaj {breadth} različnih pristopov za rešitev "
f"te težave. Za vsak pristop navedi naslov in "
f"opis v 2–3 stavkih. Oštevilči jih od 1 do {breadth}.")
branches_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
instructions=system,
input=gen_prompt,
temperature=0.8
)
branches = branches_response.output_text
# 2. korak: Ovrednoti vsako vejo
eval_prompt = (f"Težava: {problem}\n\n"
f"Tukaj je {breadth} predlaganih pristopov:\n{branches}\n\n"
f"Ovrednoti vsak pristop glede na 3 merila (ocena /10):\n"
f"- Izvedljivost\n- Učinkovitost\n- Preprostost\n\n"
f"Razvrsti jih od najboljšega do najslabšega z utemeljitvijo.")
eval_response = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
instructions=system,
input=eval_prompt,
temperature=0.3
)
evaluation = eval_response.output_text
# 3. korak: Razvij najboljšo vejo
dev_prompt = (f"Težava: {problem}\n\n"
f"Ovrednotenje pristopov:\n{evaluation}\n\n"
f"Podrobno razvij najvišje uvrščeni pristop. "
f"Zagotovi popolno, izvedljivo rešitev.")
solution = client.responses.create(
model="gpt-5.6-terra",
reasoning={"effort": "none"}, # temperature requires effort none
instructions=system,
input=dev_prompt,
temperature=0.3
)
return {
"branches": branches,
"evaluation": evaluation,
"solution": solution.output_text
}
Primer iz prakse: Programska arhitektura
Spodnja težava je točno tista vrsta, kjer ToT doda vrednost. Več strategij je zagovornih – predpomnenje, bralne replike, izvleček iskalne storitve, modro-zelena uvedba – izbira pa je odvisna od omejitev, ki jih poziv izrecno navaja, zlasti velikosti ekipe. Neposreden poziv bi ti dal rešitev, ki se najpogosteje navaja v tehnični literaturi, ne glede na te omejitve; ToT jo postavi nasproti drugim in mora braniti svojo razvrstitev na podlagi meril izvedljivosti.
problem = """
Naš monolitni REST API (Django, PostgreSQL) dosega svoje meje:
- Največ 500 zahtev/sekundo
- Čas odziva > 2 s na iskalnih končnih točkah
- Uvedba = 30 minut nedelovanja
- 3 razvijalci v ekipi
Kako lahko izboljšamo zmogljivost in razpoložljivost,
ne da bi prepisali celotno aplikacijo?
"""
result = tree_of_thought(problem, breadth=4)
print(result["solution"])
Kje ToT zmaga in kjer ti zapravlja čas
Tehnika blesti pri težavah načrtovanja – arhitektura, načrti, strategija – pri omejenih težavah, kot sta optimizacija ali dodeljevanje virov, pri kompleksnem odpravljanju napak, kjer je hkrati verjetnih več vzrokov, in pri tehničnih odločitvah, kot je izbira ogrodja ali baze podatkov. Te situacije imajo dve skupni lastnosti: obstaja več veljavnih rešitev in obstaja izrecno merilo za razlikovanje med njimi.
Po drugi strani jo preskoči pri preprostih dejanskih vprašanjih, kjer ni kaj raziskovati in bi plačal tri klice za očiten odgovor. Prav tako odpove pri odprtih ustvarjalnih nalogah zaradi pomanjkanja zagovornega merila za ovrednotenje: razvrščanje treh oglaševalskih sloganov na lestvici izvedljivosti nima smisla. Nazadnje, se ji izogni, ko je latenca kritična, saj različica z več klici mehansko veriži več zahtev API, preden vrne karkoli.
Kombiniranje z nastavitvami sklepanja
Pri visokih nastavitvah sklepanja modeli GPT-5.6 že izvajajo strukturirano notranje raziskovanje. Eksplicitni ToT takrat postane večinoma odvečen in te dvakrat obremeni za isto delo. Pridržite ga za situacije, ko je sklepanje onemogočeno ali nizko, kot v spodnji primerjavi.
# Z nizkim sklepanjem: eksplicitni ToT je uporaben
result = tree_of_thought(problem, breadth=3)
# Z visokim sklepanjem: model že globoko sklepa
response = client.responses.create(
model="gpt-5.6-sol",
input=problem,
reasoning={"effort": "high"}
)
Če se želiš odločiti v svojem kontekstu, vzemi težavo arhitekture ali načrtovanja, ki jo dejansko imaš na mizi ta teden, jo zaženi skozi ToT z več klici z breadth=3, nato pa jo takšno, kot je, predloži v neposrednem pozivu. Primerjaj obe rešitvi in predvsem strošek žetonov za vsako. Za odločitve z visokim tveganjem razlika v kakovosti več kot pokrije dodatne stroške; za stransko vprašanje ne, in če to veš, te bo obvarovalo, da tehnike ne bi iz navade uporabljal povsod.
Ključne ugotovitve
- ToT raziskuje več poti razmišljanja in izbere najboljšo
- Preprosta različica z enim pozivom ali napredna različica z več klici
- Idealno za načrtovanje, arhitekturo in kompleksno odpravljanje napak
- Pri visokih nastavitvah sklepanja modeli GPT-5.6 že imajo implicitni ToT
- Dodatni strošek žetonov je upravičen za odločitve z velikim vplivom