Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Tree-of-Thought: Štruktúrované skúmanie

Lekcia 7 z 16 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Tree-of-Thought: Štruktúrované skúmanie
  2. Rozdiel oproti Chain-of-Thought
  3. Implementácia jedným promptom
  4. Implementácia s viacerými volaniami
  5. Praktický príklad: Softvérová architektúra
  6. Kde ToT víťazí a kde plytva tvojím časom
  7. Kombinácia s nastavením logického uvažovania
  8. Kľúčové poznatky

Lekcia aktualizovaná 3. novembra 2026 na základe dokumentácie OpenAI: parametre temperature a top_p sú akceptované len pri úsilí o logické uvažovanie (reasoning effort) nastavenom na none, zatiaľ čo modely GPT-5.6 štandardne uvažujú (medium). Volania, ktoré nastavujú tieto parametre, preto musia špecifikovať reasoning={"effort": "none"} (Responses API) alebo reasoning_effort="none" (Chat Completions). Zdroje: Using GPT-6 · GPT-5.6 Terra.

Tree-of-Thought: Štruktúrované skúmanie

Tree-of-Thought (ToT) je technika promptingu, ktorá štruktúruje logické uvažovanie modelu ako rozhodovací strom. Namiesto toho, aby model nasledoval jedinú lineárnu cestu myšlienok, preskúmava viacero vetiev, každú z nich vyhodnotí a ponechá si len tie najsľubnejšie. Podobnosť s vyhľadávacím algoritmom je priama: generuješ kandidátov, hodnotíš ich a ostatné orezávaš. Vďaka tomu je táto metóda vysoko efektívna pri problémoch vyžadujúcich plánovanie alebo spätné kroky (backtracking).

Rozdiel oproti Chain-of-Thought

Chain-of-Thought (CoT) nasleduje lineárne uvažovanie: krok 1, krok 2, krok 3. Jeho slabou stránkou je štruktúra. Ak sa model v kroku 2 vydá zlým smerom, všetko, čo nasleduje, zdedí túto chybu a neexistuje mechanizmus na návrat. Uvažovanie môže byť dokonale artikulované, ale vychádza z falošného predpokladu. Tree-of-Thought naopak v každom kroku preskúmava viacero smerov a odstraňuje slepé uličky skôr, než do nich investuje ďalší vývoj.

# Chain-of-Thought (lineárne)
# Krok 1 → Krok 2 → Krok 3 → Odpoveď

# Tree-of-Thought (stromové)
#            Krok 1
#          /    |    \
#     Možnosť A  Možnosť B  Možnosť C    ← vyhodnotenie
#       |      |      ✗      ← orezanie
#    Možnosť A1  Možnosť B1
#      |       |
#   Odpoveď  Odpoveď            ← finálny výber

Implementácia jedným promptom

Najjednoduchšia verzia sa zmestí do jedného volania: prompt prinúti model nasledovať štruktúru skúmania – vygeneruj tri prístupy, vyhodnoť ich, vyber jeden a rozpracuj ho. Je to lacné a často dostatočné na vyriešenie otvorenej otázky. Pred tým, než sa na to úplne spoľahneš, si uvedom jedno obmedzenie: model navrhuje aj vyhodnocuje v rámci tej istej odpovede, čo ho robí zhovievavým voči vlastným nápadom a výsledné orezávanie nie je také prísne, ako by malo byť.

from openai import OpenAI

client = OpenAI()

def tree_of_thought_simple(problem: str) -> str:
    """ToT v jednom prompte."""
    prompt = f"""Vyrieš tento problém pomocou prístupu Tree-of-Thought.

Problém: {problem}

Krok 1 - Vygeneruj 3 rôzne prístupy:
- Prístup A: ...
- Prístup B: ...
- Prístup C: ...

Krok 2 - Vyhodnoť každý prístup (silné a slabé stránky):
- Prístup A: ...
- Prístup B: ...
- Prístup C: ...

Krok 3 - Vyber najlepší prístup a rozpracuj ho:
Vybraný prístup: ...
Detailné rozpracovanie: ...

Krok 4 - Finálna odpoveď:
..."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # temperature vyžaduje effort none
        input=prompt,
        temperature=0.7
    )
    return response.output_text

Implementácia s viacerými volaniami

Pri komplexných problémoch rozdeľ každý krok do samostatných volaní. Toto rozdelenie ti dá dve veci, ktoré jeden prompt nedokáže. Po prvé, kontrolu teploty krok po kroku: 0,8 pre generovanie, kde je rozmanitosť návrhov celým zmyslom metódy, a následne 0,3 pre vyhodnotenie a vývoj, kde potrebuješ rigoróznosť a reprodukovateľnosť. Po druhé, medzivýsledky, ktoré môžeš skontrolovať, zaznamenať do logu, alebo dokonca predložiť ľudskej validácii predtým, než reťazec pokračuje ďalej.

def tree_of_thought(problem: str, breadth: int = 3,
                    depth: int = 3) -> dict:
    """ToT s viacúrovňovým skúmaním."""
    system = "Si expert na štruktúrované riešenie problémov."

    # Krok 1: Vygeneruj počiatočné vetvy
    gen_prompt = (f"Problém: {problem}\n\n"
                  f"Navrhni {breadth} rôznych prístupov na vyriešenie "
                  f"tohto problému. Pre každý prístup uveď názov a "
                  f"2-3 vetový opis. Očísluj ich od 1 do {breadth}.")

    branches_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature vyžaduje effort none
        instructions=system,
        input=gen_prompt,
        temperature=0.8
    )
    branches = branches_response.output_text

    # Krok 2: Vyhodnoť každú vetvu
    eval_prompt = (f"Problém: {problem}\n\n"
                   f"Tu je {breadth} navrhovaných prístupov:\n{branches}\n\n"
                   f"Vyhodnoť každý prístup podľa 3 kritérií (skóre /10):\n"
                   f"- Realizovateľnosť\n- Efektivita\n- Jednoduchosť\n\n"
                   f"Zoraď ich od najlepšieho po najhorší s odôvodnením.")

    eval_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature vyžaduje effort none
        instructions=system,
        input=eval_prompt,
        temperature=0.3
    )
    evaluation = eval_response.output_text

    # Krok 3: Rozpracuj najlepšiu vetvu
    dev_prompt = (f"Problém: {problem}\n\n"
                  f"Vyhodnotenie prístupov:\n{evaluation}\n\n"
                  f"Detailne rozpracuj najvyššie hodnotený prístup. "
                  f"Poskytni kompletné, realizovateľné riešenie.")

    solution = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature vyžaduje effort none
        instructions=system,
        input=dev_prompt,
        temperature=0.3
    )

    return {
        "branches": branches,
        "evaluation": evaluation,
        "solution": solution.output_text
    }

Praktický príklad: Softvérová architektúra

Problém nižšie je presne typom úlohy, kde ToT pridáva hodnotu. Niekoľko stratégií je obhájiteľných – cachovanie, čítacie repliky, extrakcia vyhľadávacej služby, nasadenie blue-green – a výber závisí od obmedzení, ktoré prompt explicitne uvádza, najmä od veľkosti tímu. Priamy prompt by ti dal riešenie, ktoré je najčastejšie citované v technickej literatúre, bez ohľadu na tieto obmedzenia; ToT ho postaví proti ostatným a musí obhájiť svoje zaradenie na základe kritérií realizovateľnosti.

problem = """
Naša monolitická REST API (Django, PostgreSQL) naráža na svoje limity:
- Max 500 požiadaviek za sekundu
- Doba odozvy > 2 s na endpointoch vyhľadávania
- Nasadenie = 30 minút výpadku
- 3 vývojári v tíme

Ako môžeme zlepšiť výkon a dostupnosť
bez prepísania celej aplikácie?
"""

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

Kde ToT víťazí a kde plytva tvojím časom

Táto technika vyniká pri problémoch plánovania – architektúra, plány vývoja, stratégia – pri problémoch s obmedzeniami, ako je optimalizácia alebo alokácia zdrojov, pri komplexnom ladení (debugging), kde je súčasne pravdepodobných viacero príčin, a pri technických rozhodnutiach, ako je výber frameworku alebo databázy. Tieto situácie majú dve spoločné črty: existuje viacero platných riešení a existuje explicitné kritérium na rozlíšenie medzi nimi.

Naopak, vynechaj ju pri jednoduchých faktografických otázkach, kde niet čo skúmať a platil by si za tri volania, aby si dostal zrejmú odpoveď. Zlyháva aj pri otvorených kreatívnych úlohách kvôli absencii obhájiteľného evaluačného kritéria: hodnotenie troch reklamných sloganov podľa stupnice realizovateľnosti nedáva zmysel. Nakoniec sa jej vyhni, keď je kritická latencia, pretože verzia s viacerými volaniami mechanicky reťazí niekoľko požiadaviek API skôr, než vráti čokoľvek späť.

Kombinácia s nastavením logického uvažovania

Pri vysokých nastaveniach logického uvažovania modely GPT-5.6 už vykonávajú štruktúrované interné skúmanie. Explicitné ToT sa potom stáva z veľkej časti nadbytočným a účtuješ si dvakrát za tú istú prácu. Vyhradź si ho pre situácie, keď je logické uvažovanie vypnuté alebo nastavené nízko, ako v porovnaní nižšie.

# Pri nízkom logickom uvažovaní: explicitné ToT je užitočné
result = tree_of_thought(problem, breadth=3)

# Pri vysokom logickom uvažovaní: model už hlboko uvažuje
response = client.responses.create(
    model="gpt-5.6-sol",
    input=problem,
    reasoning={"effort": "high"}
)

Aby si sa rozhodol vo svojom vlastnom kontexte, vezmi si problém s architektúrou alebo dizajnom, ktorý máš tento týždeň skutočne na stole, prežeň ho cez ToT s viacerými volaniami s breadth=3 a následne ho zadaj tak, ako je, v priamom prompte. Porovnaj obe riešenia a predovšetkým náklady na tokeny pri každom z nich. Pri rozhodnutí s vysokými stávkami rozdiel v kvalite viac ako zaplatí extra náklady; pri vedľajšej otázke to tak nie je a uvedomenie si to ťa udrží od toho, aby si túto techniku zo zvyku aplikoval všade.

Kľúčové poznatky

  • ToT preskúmava viacero ciest logického uvažovania a vyberá tú najlepšiu
  • Existuje jednoduchá verzia s jedným promptom alebo pokročilá verzia s viacerými volaniami
  • Ideálne pre plánovanie, architektúru a komplexné ladenie chýb
  • Pri vysokom nastavení logického uvažovania majú modely GPT-5.6 už implicitné ToT
  • Extra náklady na tokeny sú opodstatnené pri rozhodnutiach s vysokým dopadom