← AI Курс

Урок 5. Продвинутые техники промптов: CoT, ReAct, chaining

Зачем тебе этот урок

Базовые промпты из урока 4 покрывают 80% задач. Но есть 20%, где обычный промпт ломается:

• Многошаговые рассуждения (математика, логика).
• Задачи, требующие плана и стратегии.
• Случаи, когда нужно «передумать» при ошибке.
• Цепочки обработки данных, где один промпт не справляется.
• Задачи, требующие действий во внешнем мире.

Этот урок — арсенал техник для этих сложных задач. Ты узнаешь:

• Chain-of-Thought — пошаговое рассуждение, повышает точность на 20–60% на сложных задачах.
• Self-consistency — голосование между несколькими попытками.
• Tree-of-Thoughts — ветвление решений.
• ReAct — паттерн для агентов: рассуждай и действуй.
• Prompt chaining — цепочки промптов вместо одного длинного.

1. Chain-of-Thought (CoT) — пошаговое рассуждение

Магия в одной фразе

В 2022 Google опубликовал статью «Chain-of-Thought Prompting Elicits Reasoning in Large Language Models». Открытие было странным: достаточно добавить в промпт фразу «Let's think step by step» — и точность модели на математических задачах вырастает на 20–60%.

Почему это работает

Когда модель сразу пишет финальный ответ, она по сути «угадывает» его за один токен. Если задача требует промежуточных вычислений, у неё нет места для них.

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

Это эффект «внешней памяти». Модель не «думает» в человеческом смысле, но способность пошагово раскладывать ход рассуждения значительно повышает её точность.

Пример

Задача: «У Маши было 5 яблок. Она съела 2 и купила ещё 3. Потом отдала половину Лене. Сколько у неё осталось?»

Без CoT (GPT-3.5): часто отвечает «3» (неправильно).

С CoT («Рассуждай пошагово»):

Шаг 1: было 5 яблок.
Шаг 2: съела 2 → стало 5 - 2 = 3.
Шаг 3: купила 3 → стало 3 + 3 = 6.
Шаг 4: отдала половину = 6 / 2 = 3.
Шаг 5: осталось 6 - 3 = 3.

Ответ: 3.

В этом примере получилось «3» в обоих случаях, но это совпадение — на более сложных задачах разница существенная.

Когда применять CoT

• ✅ Математика и вычисления.
• ✅ Логические задачи.
• ✅ Многошаговая обработка (извлечь → проверить → классифицировать).
• ✅ Анализ кода и багов.
• ✅ Юридические и медицинские рассуждения (но не для финального решения!).
• ❌ Простые фактические запросы — лишний оверхед.
• ❌ Креативные задачи (поэзия, стиль) — может «убить» спонтанность.

Как включать CoT в промпт

Вариант 1. Прямая инструкция:

... Рассуждай пошагово, прежде чем дать финальный ответ.
В конце выдели итог фразой "Ответ:".

Вариант 2. Few-shot с примерами рассуждений:

Пример:
Вопрос: Если 3 рубашки сохнут 1 час...
Рассуждение: Сушка — параллельный процесс...
Ответ: 1 час.

Вопрос: [твой вопрос]
Рассуждение:

Вариант 3. Reasoning-модели (o1, o3, R1):

У них CoT встроен в архитектуру — ты пишешь обычный промпт, а внутри они сами думают по шагам. Не нужно явно просить.

2. Self-consistency — голосование между попытками

Идея

Прогоняешь один и тот же промпт несколько раз с temperature>0 — получаешь несколько разных ответов. Если задача с однозначно правильным ответом, берёшь самый частый (мажорное голосование).

Когда полезно

• Сложные задачи, где модель ошибается в 30–40% случаев.
• Можешь себе позволить запустить 5–20 раз (это в 5–20 раз дороже).
• Есть «правильный ответ», который можно сравнить.

Псевдокод

answers = []
for i in range(10):
    response = llm(prompt, temperature=0.7)
    answers.append(extract_answer(response))

final_answer = most_common(answers)

Реальный кейс

На задаче GSM8K (математика для младших классов) Self-consistency повышает точность GPT-3 с ~50% до ~70%. Дорогая, но иногда оправданная техника.

3. Tree-of-Thoughts (ToT) — ветвление мышления

Идея

Модель не идёт по одному пути решения, а генерирует несколько вариантов на каждом шаге, оценивает их и продолжает лучший. Получается дерево возможных решений.

Структура

Шаг 1: Сгенерируй 3 варианта первого хода.
Шаг 2: Для каждого оцени, насколько он перспективен (1-10).
Шаг 3: Возьми лучший. Сгенерируй 3 варианта следующего хода.
... (повторить N раз)
Шаг финал: Выдай решение по лучшему пути.

Когда применять

• Творческие задачи с большим пространством решений (стратегии, сценарии).
• Игры, головоломки.
• Программирование — пробовать несколько подходов к багу.
• Принятие решений с трейд-оффами.

В чистом виде ToT обычно реализуется в коде, а не одним промптом, потому что каждый «узел дерева» — отдельный вызов LLM.

4. ReAct — Reasoning + Acting

Идея

Базовый паттерн для агентов. Модель чередует:

• Thought — рассуждение, что нужно сделать.
• Action — вызов инструмента (поиск, расчёт, API).
• Observation — результат вызова, добавленный в контекст.
• ...повторить пока не получен ответ.

Пример диалога с ReAct

Вопрос: Какая текущая температура в столице Уругвая?

Thought: Мне нужно узнать столицу Уругвая, потом погоду там.
Action: search("столица Уругвая")
Observation: Монтевидео.

Thought: Теперь нужна температура в Монтевидео.
Action: weather("Монтевидео")
Observation: +18°C, облачно.

Thought: Достаточно информации для ответа.
Final Answer: Текущая температура в Монтевидео (столице
Уругвая) — +18°C, облачно.

Что важно

• Каждое Action — это вызов реальной функции в коде. Модель не «делает» поиск сама — она просит твой код запустить поиск.
• Результат функции возвращается в контекст как Observation.
• Цикл продолжается, пока модель не выдаст Final Answer.

Подробно ReAct и агенты будут в фазе 2 (уроки 16+). Здесь главное — понять механику.

5. Prompt chaining — цепочки промптов

Идея

Сложную задачу режем на этапы. На каждом этапе — отдельный промпт. Выход одного — вход следующего.

Когда полезно

• Задача требует разных инструкций на разных этапах.
• Промежуточные результаты нужно проверять/фильтровать.
• Результат одного шага влияет на стратегию следующего.
• Хочется отлаживать каждый этап отдельно.

Пример: пайплайн анализа писем

Задача: «Из 100 писем составь сводку по приоритетным запросам клиентов».

Плохо (одним промптом): «Прочитай эти 100 писем и сделай сводку приоритетных запросов» — модель размажется, ошибётся в классификации, упустит детали.

Хорошо (chain):

Промпт 1 (для каждого письма): извлеки тип запроса и срочность.
→ JSON {request_type, urgency}

Промпт 2 (агрегация): сгруппируй извлечённые JSON по типам.
→ Список групп с count и примерами.

Промпт 3 (саммари): по группам с urgency>7 напиши сводку
для руководителя. Структура: тип, количество, пример,
рекомендация.
→ Готовый отчёт.

Каждый промпт делает одно. Проще отлаживать, легче масштабировать, выше итоговое качество.

Структура «map-reduce» в LLM

Частный случай chaining, очень популярный:

• Map — обрабатываем каждый кусок данных независимо одним промптом.
• Reduce — агрегируем результаты вторым промптом.

Например, суммаризация книги: суммаризируем каждую главу (map), потом суммаризируем все саммари (reduce).

6. Какой паттерн когда

Задача	Паттерн
Математика, логика	CoT
Критическая точность, можно платить	Self-consistency
Творчество, стратегия	Tree-of-Thoughts
Нужны действия (поиск, API)	ReAct
Сложный pipeline данных	Prompt chaining
Обработка большого корпуса	Map-reduce
Простой запрос	Обычный промпт без оверхеда

7. Тонкости и подводные камни

CoT не всегда лучше

На простых задачах CoT добавляет шум: модель «рассуждает» там, где надо просто ответить. Это:

• Удлиняет ответ → дороже.
• Может внести ошибки в простой ответ.
• Замедляет real-time приложения.

Применяй CoT селективно, не везде по умолчанию.

Reasoning-модели (o1, o3) vs CoT

У o1/o3 chain-of-thought зашит в архитектуру — они тратят время на «thinking» перед ответом. Если ты используешь их:

• НЕ нужно явно просить «think step by step» — это уже происходит.
• Промпт должен быть кратким — лишние инструкции мешают.
• Стоят дороже обычных моделей и медленнее.
• Подходят для задач, где обычные модели не справляются.

Hidden chain в reasoning-моделях

OpenAI не показывает внутренний CoT моделей o1 — только финальный ответ. Это сделано против reverse-engineering. Anthropic в Claude показывает «extended thinking», DeepSeek-R1 тоже открыто пишет рассуждения.

Стоимость chaining vs длинного промпта

3 промпта по 500 токенов != 1 промпт на 1500 токенов. У chaining дороже:

• Каждый запрос — отдельные накладные расходы (latency, network, system prompt).
• Промежуточный output становится новым input — токены считаются дважды.

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

Структурированный CoT

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

Используй формат:
<analysis>[твой анализ]</analysis>
<answer>[финальный ответ]</answer>

В коде потом извлекаешь только <answer> для пользователя, а <analysis> сохраняешь в логах.

8. Глоссарий

• CoT (Chain-of-Thought) — пошаговое рассуждение в промпте.
• Self-consistency — несколько прогонов + голосование.
• ToT (Tree-of-Thoughts) — ветвление путей решения.
• ReAct — Reasoning + Acting, паттерн агентов.
• Prompt chaining — цепочка из нескольких промптов.
• Map-reduce — обработать каждый элемент → агрегировать.
• Reasoning model — LLM со встроенным CoT (o1, o3, R1).
• Decomposition — разбиение задачи на подзадачи.
• Tool use / function calling — вызов внешних функций моделью.
• Thought / Action / Observation — компоненты ReAct-цикла.

9. Практика (60 минут)

Упражнение 1. CoT vs обычный промпт (15 минут)

Возьми 3 сложные задачи. Например:

• «Если кран наполняет ванну за 6 минут, а слив опустошает за 9 минут, за сколько ванна наполнится при открытом сливе?»
• «Команда из 5 человек должна закрыть 12 задач за 3 дня. Один уходит в отпуск на день. Хватит ли времени, если каждый делает 1 задачу в день?»
• «У меня бюджет 500 000 на год. Подписки 8000/мес, налоги 25%. Сколько остаётся на жизнь в месяц?»

1. Прогони каждую без CoT. Запиши ответы.
2. Прогони с «Рассуждай пошагово, потом дай ответ». Сравни.
3. Оцени, в каких случаях CoT помог.

Упражнение 2. Структурированный CoT (10 минут)

Возьми задачу «оцени резюме на соответствие позиции». Напиши промпт со структурой:

<evaluation>
[пошаговая оценка по критериям]
</evaluation>
<score>[1-10]</score>
<recommendation>[hire / no-hire / interview]</recommendation>

Прогони на 3 разных «резюме». Заметь, как структура помогает консистентности.

Упражнение 3. Prompt chain (20 минут)

Реализуй пайплайн «вытащи из 10 коротких писем все запросы на встречу → сгруппируй по приоритету → составь календарь предложений»:

1. Промпт 1: для каждого письма извлеки {has_meeting_request, suggested_date, urgency}.
2. Промпт 2: возьми результаты, сгруппируй по urgency.
3. Промпт 3: сделай красивый календарь с рекомендациями.

Сравни с попыткой сделать всё одним длинным промптом.

Упражнение 4. Эксперимент с reasoning-моделью (15 минут)

Если есть доступ к o1, o3, R1 (DeepSeek), Gemini 2.0 Thinking:

1. Возьми задачу, на которой обычная модель плавала.
2. Напиши краткий промпт без «think step by step».
3. Прогони. Заметь, сколько модель «думала» (если показывает).
4. Сравни ответ с обычной моделью + CoT.

10. Проверь себя

1. Что значит «think step by step»?
Инструкция модели рассуждать пошагово, прежде чем дать ответ. Это позволяет ей использовать собственный текст как «черновик мышления». Резко повышает точность на сложных задачах.

2. Self-consistency: что и зачем?
Прогоняем один промпт N раз с temperature>0, выбираем самый частый ответ. Полезно на задачах с однозначно правильным ответом, где модель часто ошибается.

3. ReAct — что за паттерн?
Цикл Thought → Action → Observation для агентов. Модель чередует рассуждение и вызов внешних функций (поиск, API), пока не получит достаточно информации для финального ответа.

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

5. Что общего у reasoning-моделей с CoT?
У них CoT встроен в архитектуру: они сами генерируют длинный «черновик мышления» перед ответом. Не нужно явно просить.

6. Когда CoT — лишний?
На простых задачах: фактические вопросы, перевод, простая классификация. Там CoT добавляет шум, удлиняет ответ и удорожает запрос.

7. Что такое map-reduce в контексте LLM?
Частный случай chaining: одним промптом обрабатываем каждый элемент данных независимо (map), вторым агрегируем результаты (reduce). Классика для суммаризации больших корпусов.

8. У меня задача требует поиска в интернете в процессе. Какой паттерн?
ReAct + tool use. Модель рассуждает, вызывает поиск как инструмент, обрабатывает результат и продолжает.

9. У моей задачи 5 этапов обработки. Один промпт или chain?
Почти всегда chain. Один промпт на 5 разных задач даст хуже качество, чем 5 фокусированных. Исключение — если этапы тривиальны и модели легко.

10. Что такое hidden chain в reasoning-моделях?
Внутренние рассуждения модели, которые она генерирует, но не показывает пользователю. У OpenAI o1 — скрыты, у DeepSeek R1 — открыты, у Claude — частично («extended thinking»).

11. Что должно остаться в голове

1. CoT — самая полезная техника. Знай, когда добавлять «рассуждай пошагово».
2. Reasoning-модели — отдельный класс. Используй на сложных задачах, не «приклеивай» к ним CoT.
3. Self-consistency — когда точность важнее цены.
4. ReAct — основа всех агентов. Будем углубляться в фазе 2.
5. Chaining — спасает на сложных пайплайнах. Структура «map-reduce» — самая частая.
6. Не лей CoT везде — на простых задачах он мешает.
7. Структурируй ответы через теги, чтобы парсить программно.