Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Tree-of-Thought: Strukturált felderítés

7. lecke 16 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. Tree-of-Thought: Strukturált felderítés
  2. Különbség a Chain-of-Thought módszertől
  3. Egyszeres hívásos megvalósítás
  4. Többszörös hívásos megvalósítás
  5. Kidolgozott példa: Szoftverarchitektúra
  6. Hol nyer a ToT, és hol pocsékolod vele az időt
  7. Kombinálás a gondolkodási beállításokkal
  8. Főbb megállapítások

Lecke frissítve: 2026. november 3. az OpenAI dokumentációja alapján: a temperature és a top_p paraméterek csak none gondolkodási erőfeszítés (reasoning effort) mellett fogadhatók el, míg a GPT-5.6 modellek alapértelmezetten (medium) végeznek következtetést. Az ezeket a paramétereket beállító hívásoknak ezért explicit meg kell adniuk a reasoning={"effort": "none"} (Responses API) vagy reasoning_effort="none" (Chat Completions) beállítást. Források: GPT-6 használata · GPT-5.6 Terra.

Tree-of-Thought: Strukturált felderítés

A Tree-of-Thought (ToT, azaz „Gondolatfa“) egy olyan promptolási technika, amely döntési faként strukturálja a modell következtetési folyamatát. Ahelyett, hogy egyetlen, lineáris gondolatmenetet követne, a modell több ágat is feltár, kiértékeli őket, és csak a legígéretesebbeket tartja meg. A hasonlóság a keresőalgoritmusokkal közvetlen: jelölteket generálsz, pontozod őket, majd a többit selejted. Ez rendkívül hatékonnyá teszi olyan problémák esetén, amelyek tervezést vagy visszalépést (backtracking) igényelnek.

Különbség a Chain-of-Thought módszertől

A Chain-of-Thought (CoT, azaz „Gondolatlánc“) lineáris következtetést követ: 1. lépés, 2. lépés, 3. lépés. Gyengesége strukturális. Ha a modell a 2. lépésnél rossz irányba indul, minden ezt követő lépés örökli ezt a hibát, és nincs mechanizmus a visszalépésre. A következtetés lehet, hogy tökéletesen artikulált, de hamis premisszából indul ki. A Tree-of-Thought minden lépésnél több irányt is feltár, és még mielőtt további fejlesztési energiát fektetne beléjük, elveti a zsákutcákat.

# Chain-of-Thought (lineáris)
# 1. lépés → 2. lépés → 3. lépés → Válasz

# Tree-of-Thought (fa-alapú)
#            1. lépés
#          /    |    \
#     A opció  B opció  C opció    ← kiértékelés
#       |      |      ✗      ← selejtezés
#    A1 opció  B1 opció
#      |       |
#   Válasz   Válasz            ← végső kiválasztás

Egyszeres hívásos megvalósítás

A legegyszerűbb verzió egyetlen hívásba belefér: a prompt rákényszeríti a modellt egy felderítési struktúra követésére – generálj három megközelítést, értékeld ki őket, válassz egyet, és fejleszd tovább. Ez olcsó, és gyakran elegendő egy nyitott kérdés kezeléséhez. Mielőtt támaszkodnál rá, légy tisztában egy korláttal: a modell ugyanabban a „lélegzetvételben“ javasol és értékel, így engedékenyebb a saját ötleteivel szemben, ami a szükségesnél kevésbé szigorú selejtezést eredményez.

from openai import OpenAI

client = OpenAI()

def tree_of_thought_simple(problem: str) -> str:
    """ToT egyetlen promptban."""
    prompt = f"""Oldd meg ezt a problémát a Tree-of-Thought megközelítés segítségével.

Probléma: {problem}

1. lépés - Generálj 3 különböző megközelítést:
- A megközelítés: ...
- B megközelítés: ...
- C megközelítés: ...

2. lépés - Értékeld ki az egyes megközelítéseket (erősségek és gyengeségek):
- A megközelítés: ...
- B megközelítés: ...
- C megközelítés: ...

3. lépés - Válaszd ki a legjobb megközelítést és fejleszd tovább:
Kiválasztott megközelítés: ...
Részletes kidolgozás: ...

4. lépés - Végső válasz:
..."""

    response = client.responses.create(
        model="gpt-5.6-sol",
        reasoning={"effort": "none"},  # a temperature megköveteli a none erőfeszítést
        input=prompt,
        temperature=0.7
    )
    return response.output_text

Többszörös hívásos megvalósítás

Komplex problémák esetén válaszd szét az egyes lépéseket külön hívásokra. Ez a lebontás két olyan előnyt biztosít, amit egyetlen prompt nem tud nyújtani. Először is, lépésenkénti hőmérséklet-szabályozást: 0,8-at a generáláshoz, ahol a javaslatok sokszínűsége a módszer lényege, majd 0,3-at az értékeléshez és a kidolgozáshoz, ahol a szigor és a reprodukálhatóság a cél. Másodszor, olyan közbenső eredményeket kapsz, amelyeket ellenőrizhetsz, naplózhatsz, vagy akár emberi validálásnak is alávehetsz, mielőtt engednéd folytatódni a láncot.

def tree_of_thought(problem: str, breadth: int = 3,
                    depth: int = 3) -> dict:
    """ToT többszintű felderítéssel."""
    system = "Te egy strukturált problémamegoldás szakértője vagy."

    # 1. lépés: Kezdeti ágak generálása
    gen_prompt = (f"Probléma: {problem}\n\n"
                  f"Javasolj {breadth} különböző megközelítést ennek a "
                  f"problémának a megoldására. Minden megközelítéshez adj egy címet és "
                  f"egy 2-3 mondatos leírást. Számozd őket 1-től {breadth}-ig.")

    branches_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # a temperature megköveteli a none erőfeszítést
        instructions=system,
        input=gen_prompt,
        temperature=0.8
    )
    branches = branches_response.output_text

    # 2. lépés: Minden ág kiértékelése
    eval_prompt = (f"Probléma: {problem}\n\n"
                   f"Íme {breadth} javasolt megközelítés:\n{branches}\n\n"
                   f"Értékeld ki az egyes megközelítéseket 3 kritérium alapján (pontszám /10):\n"
                   f"- Megvalósíthatóság\n- Hatékonyság\n- Egyszerűség\n\n"
                   f"Rangsorold őket a legjobbtól a legrosszabbig indoklással.")

    eval_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # a temperature megköveteli a none erőfeszítést
        instructions=system,
        input=eval_prompt,
        temperature=0.3
    )
    evaluation = eval_response.output_text

    # 3. lépés: A legjobb ág kidolgozása
    dev_prompt = (f"Probléma: {problem}\n\n"
                  f"A megközelítések kiértékelése:\n{evaluation}\n\n"
                  f"Dolgozd ki részletesen a legmagasabbra rangsorolt megközelítést. "
                  f"Adj meg egy teljes, cselekvőképes megoldást.")

    solution = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # a temperature megköveteli a none erőfeszítést
        instructions=system,
        input=dev_prompt,
        temperature=0.3
    )

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

Kidolgozott példa: Szoftverarchitektúra

Az alábbi probléma pontosan az a típus, ahol a ToT hozzáadott értéket képvisel. Több stratégia is védhető – gyorsítótárazás, olvasási replikák, a keresési szolgáltatás kiszervezése, blue-green telepítés –, és a választás olyan korlátoktól függ, amelyeket a prompt explicit megfogalmaz, különösen a csapat méretétől. Egy közvetlen prompt a technikai irodalomban leggyakrabban idézett megoldást adná, függetlenül ezektől a korlátoktól; a ToT ezzel szemben ütközteti őket egymással, és a megvalósíthatósági kritériumok alapján kell megvédenie a rangsorolást.

problem = """
Monolit REST API-nk (Django, PostgreSQL) elérte a határait:
- Maximum 500 kérés/másodperc
- Válaszidő > 2 másodperc a keresési végpontokon
- Telepítés = 30 perc kiesés
- 3 fejlesztő a csapatban

Hogyan javíthatjuk a teljesítményt és a rendelkezésre állást
anélkül, hogy az egész alkalmazást újraírnánk?
"""

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

Hol nyer a ToT, és hol pocsékolod vele az időt

A technika tervezési problémáknál – architektúra, ütemtervek, stratégia –, korlátozott problémáknál, mint az optimalizálás vagy erőforrás-allokáció, komplex hibakeresésnél, ahol több ok is egyszerre plausible, valamint technikai döntéseknél, mint egy keretrendszer vagy adatbázis kiválasztása, ragyogóan teljesít. Ezeket a helyzeteket két tulajdonság köti össze: több érvényes megoldás létezik, és van egy explicit kritérium a közöttük való választásra.

Ezzel szemben hagyd ki egyszerű ténykérdéseknél, ahol nincs mit felderíteni, és csak fizetnél három hívásért egy nyilvánvaló válaszért. Nyitott végű kreatív feladatoknál is kudarcot vall, mivel hiányzik a védhető értékelési kritérium: három reklámszlogent rangsorolni egy megvalósíthatósági skálán nincs értelme. Végül kerüld, ha a késleltetés (latency) kritikus, mivel a többszörös hívásos verzió mechanikusan láncol össze több API-kérést, mielőtt bármit visszaadna.

Kombinálás a gondolkodási beállításokkal

Magas gondolkodási beállítások mellett a GPT-5.6 modellek már végeznek strukturált belső felderítést. Az explicit ToT ilyenkor nagyrészt feleslegessé válik, és kétszer fizetteti meg veled ugyanazt a munkát. Tartogasd olyan helyzetekre, ahol a gondolkodás ki van kapcsolva vagy alacsony szinten van, ahogy az alábbi összehasonlítás is mutatja.

# Alacsony gondolkodási szinttel: az explicit ToT hasznos
result = tree_of_thought(problem, breadth=3)

# Magas gondolkodási szinttel: a modell már mélyen következtet
response = client.responses.create(
    model="gpt-5.6-sol",
    input=problem,
    reasoning={"effort": "high"}
)

Hogy a saját kontextusodban dönts, végy egy architektúrális vagy tervezési problémát, ami valóban előtted áll ezen a héten, futtasd le többszörös hívásos ToT-val breadth=3 paraméterrel, majd küldd el változatlanul egy közvetlen promptban. Hasonlítsd össze a két megoldást, és mindenekelőtt az egyes megoldások token-költségét. Egy nagy tétű döntésnél a minőségbeli különbség bőven megéri a plusz költséget; egy másodlagos kérdésnél nem, és ennek ismerete megakadályozza, hogy szokásból mindenhol alkalmazd a technikát.

Főbb megállapítások

  • A ToT több következtetési utat tár fel, és kiválasztja a legjobbat
  • Létezik egyszerű, egyszeres promptos és fejlett, többszörös hívásos verzió is
  • Ideális tervezéshez, architektúrához és komplex hibakereséshez
  • Magas gondolkodási beállításoknál a GPT-5.6 modellek már rendelkeznek implicit ToT-val
  • A plusz token-költség magas hatású döntéseknél megtérül