AI Prompt Engineering · Урок

Исследование дерева мыслей

Разветвление и оценка мыслей

«Исследование дерева мыслей» — бесплатный урок AI Prompt Engineering на CoddyKit. Это урок 3 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения AI Prompt Engineering, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс AI Prompt Engineering содержит 4 уроков всего.

От цепочек к деревьям

Дерево рассуждений (ToT, Yao и др., 2023) обобщает цепочку рассуждений от одного линейного пути до дерева поиска частичных решений. Каждый узел представляет связную промежуточную мысль; ветви исследуют альтернативные продолжения.

Это позволяет модели обдумывать задачу: генерировать несколько следующих шагов, оценивать их, сохранять перспективные и возвращаться назад из тупиков, имитируя систематическое решение задач, а не привязываясь к первой идее.

class ThoughtNode:
    def __init__(self, state, parent=None):
        self.state = state      # partial solution / reasoning so far
        self.parent = parent
        self.children = []
        self.value = None       # evaluator score

Четыре компонента ToT

Система ToT включает четыре проектных решения: декомпозицию мыслей (что считать шагом), генератор мыслей (как предлагать следующие шаги), оценщик состояний (как оценивать частичные решения) и алгоритм поиска (BFS, DFS или поиск сначала лучших).

Каждый компонент задаётся отдельным запросом или правилом. Проектирование ToT означает, что для задачи нужно определить все четыре компонента.

tot = {
    'decompose': step_definition,   # e.g. one equation, one move
    'generate':  propose_thoughts,  # sampling or proposal prompt
    'evaluate':  score_state,        # value/vote prompt
    'search':    bfs_with_beam,      # BFS | DFS | best-first
}

Генерация мыслей-кандидатов

Есть две стратегии генерации: создавать выборку из нескольких независимых мыслей при умеренной температуре (подходит для богатого пространства вариантов) или предлагать набор различных следующих шагов в одном запросе (подходит, когда нужны явно разные варианты).

Используйте небольшой коэффициент ветвления (обычно 3–5); слишком большое число кандидатов резко увеличивает пространство поиска и затраты.

def propose_thoughts(state, k=4):
    prompt = (
        'Given the partial solution below, propose ' + str(k) +
        ' DISTINCT possible next steps.\n' + state
    )
    return parse_list(llm(prompt, temperature=0.7))

Оценка состояний

Оценщик состояний делает ToT чем-то большим, чем случайная выборка. Он оценивает перспективность частичного решения либо с помощью запроса на оценку (оцените это состояние по шкале от 1 до 10 с точки зрения решения задачи), либо с помощью запроса на голосование (какое из этих состояний наиболее перспективно).

Голосование между кандидатами часто устойчивее абсолютной оценки, поскольку относительные суждения даются модели проще.

def score_state(state):
    prompt = (
        'Rate how likely this partial solution leads to a correct '
        'final answer. Reply sure / likely / impossible.\n' + state
    )
    label = llm(prompt, temperature=0).strip().lower()
    return {'sure': 1.0, 'likely': 0.5, 'impossible': 0.0}.get(label, 0.3)

BFS с поиском по лучу

Поиск в ширину в ToT расширяет все узлы границы поиска на один уровень за раз, а затем оставляет только b лучших по оценке оценщика (луч). Это ограничивает рост числа вариантов и позволяет параллельно исследовать несколько линий.

Ширина луча b определяет компромисс между охватом поиска и затратами; ширина 5 при глубине 3 — распространённая отправная точка для структурированных головоломок.

def bfs_with_beam(root, depth, branch, beam):
    frontier = [root]
    for _ in range(depth):
        nxt = []
        for node in frontier:
            for t in propose_thoughts(node.state, branch):
                child = ThoughtNode(node.state + '\n' + t, node)
                child.value = score_state(child.state)
                nxt.append(child)
        frontier = sorted(nxt, key=lambda n: -n.value)[:beam]
    return max(frontier, key=lambda n: n.value)

DFS с возвратом

Поиск в глубину в ToT углубляется в наиболее перспективную ветвь и возвращается назад, когда оценщик считает состояние безнадёжным. Это подходит для задач с чётким понятием недопустимого частичного состояния, например для задач с ограничениями.

Раннее отсечение невозможных ветвей — главный способ повысить эффективность: оно предотвращает напрасное расширение обречённых поддеревьев.

def dfs(node, depth, branch, prune=0.2):
    if depth == 0 or is_solution(node.state):
        return node
    for t in propose_thoughts(node.state, branch):
        child = ThoughtNode(node.state + '\n' + t, node)
        child.value = score_state(child.state)
        if child.value < prune:
            continue                      # backtrack: prune dead end
        res = dfs(child, depth - 1, branch, prune)
        if res and is_solution(res.state):
            return res
    return None

ToT и самосогласованность

Самосогласованность создаёт выборку из независимых полных цепочек и проводит голосование. ToT активно направляет поиск с помощью промежуточной оценки и возврата назад, вкладывая вычислительные ресурсы в перспективные направления.

ToT особенно полезно для задач, требующих планирования или поиска, а также для задач, где ранние ошибки фатальны (игра «24», кроссворды, планирование). Для задач с дешёвыми разнообразными цепочками и дискретным ответом самосогласованность проще и часто достаточна.

# Rule of thumb
# - reachable by diverse single passes  -> self-consistency
# - needs lookahead / pruning / backtrack -> tree-of-thought
# ToT cost ~ branch * depth * beam * (gen + eval) LLM calls

Резкий рост затрат и бюджеты

ToT требует больших затрат: каждый узел порождает вызовы генерации и оценки. Общие затраты примерно пропорциональны произведению числа ветвей, глубины и ширины луча, плюс вызовы оценщика. Без жёсткого бюджета затраты могут резко вырасти.

Ограничивайте общее число вызовов LLM, используйте поиск сначала лучших, чтобы направлять бюджет на наиболее ценную границу поиска, и переходите к лучшему частичному решению, если бюджет исчерпан.

import heapq

def best_first(root, max_calls):
    heap = [(-root.value, root)]
    best, calls = root, 0
    while heap and calls < max_calls:
        _, node = heapq.heappop(heap)
        for t in propose_thoughts(node.state, 3):
            calls += 1
            child = ThoughtNode(node.state + '\n' + t, node)
            child.value = score_state(child.state); calls += 1
            if child.value > best.value:
                best = child
            heapq.heappush(heap, (-child.value, child))
    return best

Надёжность оценщика

ToT хорош настолько, насколько хорош его оценщик. Неправильно откалиброванный оценщик отсекает правильные ветви или выбирает тупиковые пути. Улучшайте его с помощью голосования (нескольких оценок каждого состояния), примеров хороших и плохих состояний для обучения по нескольким примерам или внешнего проверяющего средства (модульной проверки, решателя, средства проверки).

Там, где существует объективная проверка (выполняется ли уравнение, проходит ли код проверку), предпочитайте её суждению LLM.

def robust_eval(state, votes=3):
    scores = [score_state(state) for _ in range(votes)]
    return sum(scores) / votes        # average to reduce judge noise
# Even better: replace with a deterministic verifier when available

Практическая применимость

ToT эффективен в узком, но важном классе задач: многошаговом планировании, комбинаторных головоломках и задачах, где проверить шаг дешевле, чем решить всё целиком. Для большинства повседневных запросов ToT — избыточный подход.

На моделях со встроенным рассуждением и сильным поиском явный каркас ToT часто увеличивает затраты без заметной пользы; сравните результаты, прежде чем внедрять его.

def choose_strategy(task):
    if task.requires_search and task.step_verifiable:
        return 'tree-of-thought'
    if task.discrete_answer:
        return 'self-consistency'
    return 'single chain-of-thought'

Минимальный решатель ToT

От начала до конца: определите шаг, предложите небольшое разветвление мыслей, оцените каждую (с помощью голосования или проверяющего средства), выполняйте поиск по BFS с лучом или DFS с возвратом в рамках бюджета вызовов и верните лучшее конечное состояние.

Собирайте показатели числа узлов и оценок оценщика, чтобы на основе измерений настраивать число ветвей, глубину и ширину луча для каждой задачи.

def solve(problem, branch=4, depth=3, beam=5, budget=200):
    root = ThoughtNode(problem)
    root.value = score_state(root.state)
    node = bfs_with_beam(root, depth, branch, beam)
    return extract_solution(node.state)

Быстрая проверка

Выберите подходящую стратегию обдумывания.

Итоги

Главные выводы:

ToT обобщает CoT в дерево поиска с генерацией мыслей, оценкой состояний и алгоритмом поиска.
Используйте BFS с лучом или DFS с возвратом; сохраняйте небольшой коэффициент ветвления, чтобы контролировать рост числа вариантов.
Оценщик состояний — главное звено; повышайте его надёжность с помощью голосования или внешнего проверяющего средства.
Затраты растут как произведение числа ветвей, глубины и ширины луча, поэтому устанавливайте бюджет вызовов, часто используя поиск сначала лучших.
Оставляйте ToT для задач планирования и комбинаторных задач, где шаги можно проверять; для повседневных запросов это избыточно.

Часто задаваемые вопросы

Урок «Исследование дерева мыслей» бесплатный?

Да — полный текст урока «Исследование дерева мыслей» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс AI Prompt Engineering, подпишись на CoddyKit PRO. Курс AI Prompt Engineering содержит 4 уроков всего.

Чему я научусь в уроке «Исследование дерева мыслей»?

Разветвление и оценка мыслей Ты практикуешь AI Prompt Engineering с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать AI Prompt Engineering?

Предыдущий опыт не требуется. AI Prompt Engineering на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 3 из 4.

Сколько времени занимает урок «Исследование дерева мыслей»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке AI Prompt Engineering?

Да. Каждый урок AI Prompt Engineering включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

← Назад к AI Prompt Engineering