Przejdź do głównej treści
Polski— Wybierz język
Menu

Tree-of-Thought: Eksploracja strukturalna

Lekcja 7 z 16 Zaktualizowano 3 listopada 2026 Programista
Na tej stronie
  1. Tree-of-Thought: Eksploracja strukturalna
  2. Różnica względem Chain-of-Thought
  3. Implementacja w jednym prompcie
  4. Implementacja z wieloma wywołaniami
  5. Przykład praktyczny: Architektura oprogramowania
  6. Gdzie ToT wygrywa, a gdzie marnuje Twój czas
  7. Łączenie z ustawieniami rozumowania
  8. Kluczowe wnioski

Lekcja zaktualizowana 3 listopada 2026 r. na podstawie dokumentacji OpenAI: parametry temperature i top_p są akceptowane wyłącznie przy wysiłku rozumowania (reasoning effort) ustawionym na none, podczas gdy modele GPT-5.6 domyślnie przeprowadzają rozumowanie (medium). Wywołania ustawiające te parametry muszą zatem określać reasoning={"effort": "none"} (Responses API) lub reasoning_effort="none" (Chat Completions). Źródła: Using GPT-6 · GPT-5.6 Terra.

Tree-of-Thought: Eksploracja strukturalna

Tree-of-Thought (ToT) to technika promptowania, która organizuje rozumowanie modelu w postaci drzewa decyzyjnego. Zamiast podążać pojedynczą, liniową ścieżką myślową, model eksploruje wiele gałęzi, ocenia każdą z nich i zachowuje tylko te najbardziej obiecujące. Podobieństwo do algorytmu wyszukiwania jest bezpośrednie: generujesz kandydatów, oceniasz ich i odrzucasz resztę. Dzięki temu metoda ta jest wysoce skuteczna w przypadku problemów wymagających planowania lub cofania się do wcześniejszych etapów.

Różnica względem Chain-of-Thought

Chain-of-Thought (CoT) podąża za rozumowaniem liniowym: krok 1, krok 2, krok 3. Jego słabością jest struktura. Jeśli model zejdzie na niewłaściwą ścieżkę już w kroku 2, wszystko, co następuje później, dziedziczy ten błąd i nie istnieje mechanizm pozwalający zawrócić. Rozumowanie może być doskonale sformułowane, ale wychodzi z fałszywej przesłanki. Tree-of-Thought eksploruje wiele kierunków na każdym etapie i odrzuca ślepe uliczki, zanim zainwestuje w nie dalszy rozwój.

# Chain-of-Thought (liniowe)
# Krok 1 → Krok 2 → Krok 3 → Odpowiedź

# Tree-of-Thought (oparte na drzewie)
#            Krok 1
#          /    |    \
#     Opcja A  Opcja B  Opcja C    ← ocena
#       |      |      ✗      ← przycinanie
#    Opcja A1  Opcja B1
#      |       |
#   Odpowiedź  Odpowiedź            ← wybór końcowy

Implementacja w jednym prompcie

Najprostsza wersja mieści się w jednym wywołaniu: prompt wymusza na modelu podążanie za strukturą eksploracji – wygeneruj trzy podejścia, oceń je, wybierz jedno i rozwijaj je. Jest to rozwiązanie niedrogie i często wystarczające do rozwiązania otwartego problemu. Miej jednak na uwadze jedno ograniczenie przed poleganiem na tej metodzie: model proponuje i ocenia rozwiązania w tym samym oddechu, co czyni go pobłażliwym wobec własnych pomysłów i skutkuje mniej surowym przycinaniem, niż byłoby to konieczne.

from openai import OpenAI

client = OpenAI()

def tree_of_thought_simple(problem: str) -> str:
    """ToT w jednym prompcie."""
    prompt = f"""Rozwiąż ten problem, stosując podejście Tree-of-Thought.

Problem: {problem}

Krok 1 - Wygeneruj 3 różne podejścia:
- Podejście A: ...
- Podejście B: ...
- Podejście C: ...

Krok 2 - Oceń każde podejście (mocne i słabe strony):
- Podejście A: ...
- Podejście B: ...
- Podejście C: ...

Krok 3 - Wybierz najlepsze podejście i rozwijaj je:
Wybrane podejście: ...
Szczegółowy rozwój: ...

Krok 4 - Odpowiedź końcowa:
..."""

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

Implementacja z wieloma wywołaniami

W przypadku złożonych problemów rozdziel każdy etap na osobne wywołania. Taki podział daje Ci dwie rzeczy, których nie zapewnia pojedynczy prompt. Po pierwsze, kontrolę temperatury krok po kroku: 0,8 dla generowania, gdzie różnorodność propozycji jest sednem metody, a następnie 0,3 dla oceny i rozwoju, gdzie zależy Ci na rygorze i powtarzalności. Po drugie, uzyskujesz wyniki pośrednie, które możesz inspectować, logować, a nawet poddać walidacji przez człowieka, zanim pozwolisz łańcuchowi kontynuować działanie.

def tree_of_thought(problem: str, breadth: int = 3,
                    depth: int = 3) -> dict:
    """ToT z eksploracją wielopoziomową."""
    system = "Jesteś ekspertem w zakresie strukturalnego rozwiązywania problemów."

    # Krok 1: Generowanie początkowych gałęzi
    gen_prompt = (f"Problem: {problem}\n\n"
                  f"Zaproponuj {breadth} różnych podejść do rozwiązania "
                  f"tego problemu. Dla każdego podejścia podaj tytuł i "
                  f"2-3 zdania opisu. Ponumeruj je od 1 do {breadth}.")

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

    # Krok 2: Ocena każdej gałęzi
    eval_prompt = (f"Problem: {problem}\n\n"
                   f"Oto {breadth} zaproponowanych podejść:\n{branches}\n\n"
                   f"Oceń każde podejście w 3 kryteriach (skala 0-10):\n"
                   f"- Wykonalność\n- Efektywność\n- Prostota\n\n"
                   f"Uszereguj je od najlepszego do najgorszego z uzasadnieniem.")

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

    # Krok 3: Rozwój najlepszej gałęzi
    dev_prompt = (f"Problem: {problem}\n\n"
                  f"Ocena podejść:\n{evaluation}\n\n"
                  f"Rozwiń najwyżej ocenione podejście szczegółowo. "
                  f"Przedstaw kompletne, możliwe do wdrożenia rozwiązanie.")

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

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

Przykład praktyczny: Architektura oprogramowania

Poniższy problem jest dokładnie tego typu, w którym ToT wnosi wartość. Kilka strategii jest obronnych – buforowanie, repliki do odczytu, wydzielenie usługi wyszukiwania, wdrożenie blue-green – a wybór zależy od ograniczeń jawnie stated w prompcie, zwłaszcza wielkości zespołu. Bezpośredni prompt dałby Ci rozwiązanie najczęściej cytowane w literaturze technicznej, niezależnie od tych ograniczeń; ToT zestawia je z innymi i musi obronić swój ranking w oparciu o kryteria wykonalności.

problem = """
Nasz monolityczny API REST (Django, PostgreSQL) osiąga swoje limity:
- Maksymalnie 500 żądań na sekundę
- Czas odpowiedzi > 2 s na endpointach wyszukiwania
- Wdrożenie = 30 minut przestoju
- 3 programistów w zespole

Jak możemy poprawić wydajność i dostępność
bez przepisywania całej aplikacji?
"""

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

Gdzie ToT wygrywa, a gdzie marnuje Twój czas

Technika ta błyszczy w problemach planistycznych – architektura, harmonogramy, strategia – w problemach z ograniczeniami, takich jak optymalizacja czy alokacja zasobów, w złożonym debugowaniu, gdzie wiele przyczyn pozostaje jednocześnie prawdopodobnych, oraz w decyzjach technicznych, takich jak wybór frameworka czy bazy danych. Sytuacje te mają dwie wspólne cechy: istnieje wiele poprawnych rozwiązań oraz istnieje wyraźne kryterium pozwalające je rozróżnić.

Z drugiej strony, pomiń tę metodę w przypadku prostych pytań faktograficznych, gdzie nie ma nic do eksploracji, a płaciłbyś za trzy wywołania, by uzyskać oczywistą odpowiedź. Zawodzi ona również w otwartych zadaniach kreatywnych z powodu braku obronnego kryterium oceny: rankingowanie trzech haseł reklamowych w skali wykonalności nie ma sensu. Na koniec unikaj jej, gdy kluczowa jest niskie opóźnienie (latencja), ponieważ wersja z wieloma wywołaniami mechanicznie łączy kilka żądań API przed zwróceniem jakiegokolwiek wyniku.

Łączenie z ustawieniami rozumowania

Przy wysokich ustawieniach rozumowania modele GPT-5.6 już przeprowadzają strukturalną eksplorację wewnętrzną. Jawne ToT staje się wtedy w dużej mierze zbędne i płacisz podwójnie za tę samą pracę. Rezerwuj tę technikę dla sytuacji, w których rozumowanie jest wyłączone lub niskie, jak w poniższym porównaniu.

# Przy niskim rozumowaniu: jawne ToT jest przydatne
result = tree_of_thought(problem, breadth=3)

# Przy wysokim rozumowaniu: model już głęboko rozumuje
response = client.responses.create(
    model="gpt-5.6-sol",
    input=problem,
    reasoning={"effort": "high"}
)

Aby podjąć decyzję w swoim własnym kontekście, weź problem architektoniczny lub projektowy, który faktycznie masz na tapecie w tym tygodniu, przepuść go przez ToT z wieloma wywołaniami z parametrem breadth=3, a następnie prześlij go bez zmian w bezpośrednim prompcie. Porównaj oba rozwiązania i, co najważniejsze, koszt tokenów dla każdego z nich. W przypadku decyzji o wysokim ryzyku luka w jakości więcej niż rekompensuje dodatkowy koszt; w przypadku pytania drugorzędnego – nie, a świadomość tego faktu uchroni Cię przed stosowaniem tej techniki wszędzie z przyzwyczajenia.

Kluczowe wnioski

  • ToT eksploruje wiele ścieżek rozumowania i wybiera najlepszą
  • Dostępna prosta wersja z jednym promptem lub zaawansowana z wieloma wywołaniami
  • Idealne do planowania, architektury i złożonego debugowania
  • Przy wysokich ustawieniach rozumowania modele GPT-5.6 mają już implicitzne ToT
  • Dodatkowy koszt tokenów jest uzasadniony w przypadku decyzji o wysokim wpływie