Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Tree-of-Thought: Strukturovaný průzkum

Lekce 7 z 16 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Tree-of-Thought: Strukturovaný průzkum
  2. Rozdíl oproti Chain-of-Thought
  3. Implementace pomocí jednoho promptu
  4. Implementace pomocí více volání
  5. Praktický příklad: Softwarová architektura
  6. Kde ToT vítězí a kde plýtvá tvým časem
  7. Kombinace s nastavením uvažování
  8. Klíčové poznatky

Lekce aktualizována 3. listopadu 2026 na základě dokumentace OpenAI: parametry temperature a top_p jsou přijímány pouze při úsilí o uvažování (reasoning effort) nastaveném na none, zatímco modely GPT-5.6 ve výchozím nastavení uvažují (medium). Volání, která tyto parametry nastavují, musí proto specifikovat reasoning={"effort": "none"} (Responses API) nebo reasoning_effort="none" (Chat Completions). Zdroje: Using GPT-6 · GPT-5.6 Terra.

Tree-of-Thought: Strukturovaný průzkum

Tree-of-Thought (ToT) je technika promptingu, která strukturuje uvažování modelu jako rozhodovací strom. Místo toho, aby model sledoval jedinou lineární cestu myšlenek, prozkoumává více větví, každou z nich vyhodnotí a ponechá si pouze ty nejslibnější. Podobnost s vyhledávacím algoritmem je přímá: generuješ kandidáty, ohodnotíš je a ostatní odřízneš. Díky tomu je tato metoda vysoce efektivní pro problémy vyžadující plánování nebo návrat k předchozím krokům (backtracking).

Rozdíl oproti Chain-of-Thought

Chain-of-Thought (CoT) sleduje lineární uvažování: krok 1, krok 2, krok 3. Jeho slabina spočívá ve struktuře. Pokud se model ve druhém kroku vydá špatným směrem, všechno, co následuje, tuto chybu zdědí, a neexistuje žádný mechanismus pro návrat. Uvažování může být dokonale artikulované, ale vychází z falešného předpokladu. Tree-of-Thought naopak v každém kroku prozkoumává více směrů a slepé uličky odhalí dříve, než do nich investuje další úsilí.

# Chain-of-Thought (lineární)
# Krok 1 → Krok 2 → Krok 3 → Odpověď

# Tree-of-Thought (stromová struktura)
#            Krok 1
#          /    |    \
#     Možnost A  Možnost B  Možnost C    ← vyhodnocení
#       |      |      ✗      ← prořezávání
#    Možnost A1  Možnost B1
#      |       |
#   Odpověď  Odpověď            ← finální výběr

Implementace pomocí jednoho promptu

Nejjednodušší verze se vejde do jediného volání: prompt donutí model následovat strukturu průzkumu – vygeneruj tři přístupy, vyhodnoť je, vyber jeden a rozpracuj ho. Toto řešení je nenákladné a často postačuje k řešení otevřených otázek. Než se na něj však spolehneš, měj na paměti jedno omezení: model návrhy i jejich vyhodnocení generuje v jednom dechu, což ho činí shovívavým k vlastním nápadům a výsledné prořezávání není tak přísné, jak by mělo být.

from openai import OpenAI

client = OpenAI()

def tree_of_thought_simple(problem: str) -> str:
    """ToT v jediném promptu."""
    prompt = f"""Vyřeš tento problém pomocí přístupu Tree-of-Thought.

Problém: {problem}

Krok 1 - Vygeneruj 3 různé přístupy:
- Přístup A: ...
- Přístup B: ...
- Přístup C: ...

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

Krok 3 - Vyber nejlepší přístup a rozpracuj ho:
Vybraný přístup: ...
Podrobné rozpracování: ...

Krok 4 - Finální odpověď:
..."""

    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

Implementace pomocí více volání

U složitých problémů odděl každý krok do samostatných volání. Toto rozdělení ti poskytne dvě věci, které jediný prompt nedokáže. Zaprvé, kontrolu teploty krok za krokem: 0,8 pro generování, kde je rozmanitost návrhů samotným smyslem metody, a poté 0,3 pro vyhodnocení a rozpracování, kde potřebuješ přesnost a reprodukovatelnost. Zadruhé, mezivýsledky, které můžeš zkontrolovat, zaznamenat do logu, nebo dokonce předložit k lidské validaci, než necháš řetězec pokračovat.

def tree_of_thought(problem: str, breadth: int = 3,
                    depth: int = 3) -> dict:
    """ToT s víceúrovňovým průzkumem."""
    system = "Jsi expert na strukturované řešení problémů."

    # Krok 1: Generování počátečních větví
    gen_prompt = (f"Problém: {problem}\n\n"
                  f"Navrhni {breadth} různých přístupů k řešení "
                  f"tohoto problému. Pro každý přístup uveď název a "
                  f"popis o 2–3 větách. Očísluj je 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: Vyhodnocení každé větve
    eval_prompt = (f"Problém: {problem}\n\n"
                   f"Zde je {breadth} navržených přístupů:\n{branches}\n\n"
                   f"Vyhodnoť každý přístup podle 3 kritérií (skóre /10):\n"
                   f"- Proveditelnost\n- Efektivita\n- Jednoduchost\n\n"
                   f"Seřaď je od nejlepšího po nejhorší s odůvodnění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: Rozpracování nejlepší větve
    dev_prompt = (f"Problém: {problem}\n\n"
                  f"Vyhodnocení přístupů:\n{evaluation}\n\n"
                  f"Podrobně rozpracuj nejlépe hodnocený přístup. "
                  f"Poskytni kompletní a realizovatelné řešení.")

    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ý příklad: Softwarová architektura

Níže uvedený problém je přesně toho typu, kde ToT přináší přidanou hodnotu. Obhajitelných je několik strategií – caching, repliky pro čtení, extrakce vyhledávací služby, nasazení typu blue-green – a volba závisí na omezeních, která prompt explicitně uvádí, zejména na velikosti týmu. Přímý prompt by ti poskytl řešení nejčastěji citované v technické literatuře bez ohledu na tato omezení; ToT jej postaví proti ostatním a musí své pořadí obhájit na základě kritérií proveditelnosti.

problem = """
Naše monolitické REST API (Django, PostgreSQL) naráží na své limity:
- Maximálně 500 požadavků za sekundu
- Doba odezvy > 2 s u endpointů pro vyhledávání
- Nasazení = 30 minut výpadku
- Tým tvoří 3 vývojáři

Jak můžeme zlepšit výkon a dostupnost,
aniž bychom přepisovali celou aplikaci?
"""

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

Kde ToT vítězí a kde plýtvá tvým časem

Tato technika vyniká u problémů spojených s plánováním – architektura, roadmapy, strategie –, u problémů s omezeními, jako je optimalizace nebo alokace zdrojů, u složitého ladění, kde je současně pravděpodobných více příčin, a u technických rozhodnutí, jako je výběr frameworku nebo databáze. Tyto situace mají dvě společné vlastnosti: existuje více platných řešení a existuje explicitní kritérium, které je odlišuje.

Naopak ji vynechej u jednoduchých faktografických otázek, kde není co zkoumat a platil bys za tři volání, abys získal zřejmou odpověď. Selhává také u otevřených kreativních úkolů kvůli absenci obhajitelného evaluačního kritéria: řazení tří reklamních sloganů podle škály proveditelnosti nedává smysl. Nakonec se jí vyhni, když je kritická latence, protože verze s více voláními mechanicky řetězí několik požadavků na API, než cokoli vrátí.

Kombinace s nastavením uvažování

Při vysokém nastavení uvažování již modely GPT-5.6 provádějí strukturovaný interní průzkum. Explicitní ToT se pak stává z velké části nadbytečným a účtuješ si dvakrát za stejnou práci. Rezervuj si ji pro situace, kdy je uvažování vypnuto nebo nízké, jak ukazuje níže uvedené srovnání.

# S nízkým uvažováním: explicitní ToT je užitečné
result = tree_of_thought(problem, breadth=3)

# S vysokým uvažováním: model již hluboce uvažuje
response = client.responses.create(
    model="gpt-5.6-sol",
    input=problem,
    reasoning={"effort": "high"}
)

Abys rozhodl ve svém vlastním kontextu, vezmi si problém s architekturou nebo designem, který právě tento týden řešíš, proveď jím vícevolbové ToT s breadth=3 a poté jej tak, jak je, zadej do přímého promptu. Porovnej obě řešení a především náklady na tokeny u každého z nich. U rozhodnutí s vysokými sázkami rozdíl v kvalitě více než vyváží vyšší náklady; u vedlejší otázky tomu tak není a vědomí tohoto faktu ti pomůže vyhnout se aplikaci této techniky všude jen ze zvyku.

Klíčové poznatky

  • ToT prozkoumává více cest uvažování a vybírá tu nejlepší
  • Existuje jednoduchá verze s jedním promptem nebo pokročilá verze s více voláními
  • Ideální pro plánování, architekturu a složité ladění
  • Při vysokém nastavení uvažování mají modely GPT-5.6 již implicitní ToT
  • Dodatečné náklady na tokeny jsou u rozhodnutí s vysokým dopadem oprávněné