Chain-of-Thought

Chain-of-Thought (CoT), или «Цепочка Мыслей», — это не сложная архитектура или новая модель, а техника промптинга. Ее суть — заставить Большую Языковую Модель (LLM) генерировать пошаговую цепочку рассуждений до того, как она даст финальный ответ. Это похоже на то, как в школе учитель просит показать ход решения задачи, а не просто написать ответ.

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

Зачем нужен CoT: Проблема «черного ящика» и поспешных ответов

LLM по своей природе — это «черные ящики». Они отлично справляются с задачами, где ответ интуитивно следует за вопросом (например, «Столица Франции?»). Но они проваливаются там, где требуется многоэтапная логика.

Рассмотрим классический пример:

Промпт: «В кафе было 5 яблок. Они купили еще 2 коробки по 6 яблок в каждой. Сколько всего яблок стало в кафе?»

Ответ LLM (вероятный): 11 яблок.

Модель «увидела» цифры 5 и 6 и поспешно их сложила, проигнорировав «2 коробки». Она не выполнила промежуточный шаг: 2 * 6 = 12.

Chain-of-Thought решает именно эту проблему. Он заставляет LLM создать «внутренний монолог» или «рабочую тетрадь». Вместо того чтобы сразу выдать ответ, модель сначала генерирует текст вроде: «Окей, давай разберемся. 1. Изначально было 5 яблок. 2. Купили 2 коробки по 6 яблок, это 2 * 6 = 12 яблок. 3. Теперь сложим: 5 + 12 = 17 яблок. Финальный ответ: 17».

Этот процесс самогенерации промежуточных шагов и есть Chain-of-Thought.

Принцип работы Chain-of-Thought: Два основных метода

Существует два основных способа «включить» режим CoT у LLM.

Zero-Shot CoT (Нулевой выстрел): Магическая фраза

Это самый простой и удивительный метод, открытый в 2022 году. Оказалось, что для активации CoT в достаточно продвинутых моделях (как GPT-3.5+), не нужно ничего, кроме добавления «магической фразы» в конец промпта.

Самые известные фразы — это Let’s think step by step. или Давай подумаем по шагам.

• До: Q: [Сложная задача] A:
• После: Q: [Сложная задача] A: Let’s think step by step.

Эта простая инструкция заставляет модель изменить свой «шаблон вывода». Вместо того чтобы сразу генерировать «[Ответ]», она начинает генерировать «[Шаг 1… Шаг 2… Шаг 3… Финальный ответ: Ответ]».

Few-Shot CoT (Обучение на примерах): Показываем, как надо

Этот метод более надежный, но требует подготовки. Вместо того чтобы просить модель думать по шагам, вы показываете ей пример того, как это делать. Вы «обучаете» ее в рамках одного промпта (in-context learning).

Вы даете модели 1-2 примера (shots), где вы вручную прописали всю «цепочку мыслей».

Пример промпта в стиле Few-Shot CoT:

Q: Роджеру 5 теннисных мячей. Он покупает еще 2 банки по 3 мяча в каждой. Сколько у него мячей?
A: Let's think step by step.
1. У Роджера изначально 5 мячей.
2. Он покупает 2 банки по 3 мяча, это 2 * 3 = 6 мячей.
3. Общее количество: 5 + 6 = 11.
Final Answer: 11.

Q: [Ваша сложная задача]
A:

Получив такой пример, LLM понимает «ага, от меня ждут такой же подробный разбор» и применит тот же шаблон CoT к вашей задаче.

Ключевые сценарии использования CoT

Chain-of-Thought — это не универсальное решение, но он кардинально улучшает результаты в трех ключевых областях:

• Арифметические задачи: Любые текстовые задачи, требующие математических расчетов в несколько действий.
• Логические и символьные головоломки: Задачи, где нужно отслеживать состояние объектов (например, «Переложи кубики A, B, C…»).
• Многоэтапные запросы: Запросы, где для ответа нужно найти и связать несколько разных фактов (например, наш сквозной пример, который мы разберем ниже).

Взаимодействие с CoT: Практический сквозной пример

Давайте возьмем одну задачу и посмотрим, как она решается тремя разными способами. Мы будем использовать ту же среду, что и в прошлых статьях (Python и OpenAI).

Наша сквозная задача:

• «Кто выиграл чемпионат NBA в тот год, когда вышел первый фильм ‘Миссия: Невыполнима’?»

Эта задача требует двух шагов:

1. Узнать год выхода фильма «Миссия: Невыполнима» (1996).
2. Узнать, кто был чемпионом NBA в 1996 году (Chicago Bulls).

Формирование среды для запуска примеров (Python + OpenAI):

# Установите библиотеку: pip install openai
import os
from openai import OpenAI

# Установите ваш API ключ
client = OpenAI(api_key="YOUR_API_KEY")

def ask_llm(prompt_text):
    """Простая функция для запроса к LLM."""
    try:
        completion = client.chat.completions.create(
            model="gpt-3.5-turbo", # Используем быструю модель
            messages=[
                {"role": "system", "content": "Ты полезный ассистент."},
                {"role": "user", "content": prompt_text}
            ]
        )
        return completion.choices[0].message.content
    except Exception as e:
        return f"Произошла ошибка: {e}"

Пример 1: Стандартный промпт (Провальный)

Здесь мы просто задаем вопрос «в лоб» и надеемся, что LLM «догадается».

# ЗАПУСК ПРИМЕРА 1
prompt_1 = "Кто выиграл чемпионат NBA в тот год, когда вышел первый фильм 'Миссия: Невыполнима'?"
print("--- [РЕЗУЛЬТАТ СТАНДАРТНОГО ПРОМПТА] ---")
print(ask_llm(prompt_1))
print("--------------------------------------")

Вероятный результат (Провал): в нашем случае модель справилась с задачей ввиду своей тревиальности, но надеяться на это не стоит в реальной жизни

— [РЕЗУЛЬТАТ СТАНДАРТНОГО ПРОМПТА] —
[Предположение] Я не могу просматривать интернет в реальном времени. Однако, если вы скажете мне год выхода фильма, я смогу назвать чемпиона NBA.
—————————————

• Анализ: Модель (особенно gpt-3.5-turbo) не смогла самостоятельно выполнить двухэтапную логику. Она «споткнулась» на первом же шаге и попросила помощи.

Пример 2: Zero-Shot CoT (Успешный)

Теперь мы используем ту же модель, тот же Python, но добавляем «магическую фразу».

# ЗАПУСК ПРИМЕРА 2
prompt_2 = """Кто выиграл чемпионат NBA в тот год, когда вышел первый фильм 'Миссия: Невыполнима'?

Давай подумаем по шагам.
"""
print("--- [РЕЗУЛЬТАТ CoT ПРОМПТА] ---")
print(ask_llm(prompt_2))
print("---------------------------------")

Результат (Успех):

• Анализ: Это триумф CoT. Мы не дали модели никакой новой информации. Мы просто попросили ее подумать по шагам, и это изменило процесс генерации. Она сама создала «цепочку мыслей», нашла оба факта в своих данных и дала верный ответ.

Сравнение: CoT, Standard Prompting и Autonomous Prompting

Теперь мы подошли к главному. В чем разница между CoT и Autonomous Prompting (о котором мы говорили в прошлой статье)?

• Standard Prompting: «Сделай X». Провал.
• Chain-of-Thought (CoT): «Подумай, как сделать X, и сделай». Успех (если X решается внутренними знаниями модели).
• Autonomous Prompting (AI Agent): «Вот тебе цель X и инструменты (например, Поиск). Сам решай, как ее достичь».

Chain-of-Thought — это внутренний монолог. Модель рассуждает, используя только те знания, на которых ее обучали. Если бы мы спросили: «Кто выиграл матч NBA, который закончился час назад?», CoT бы провалился, потому что этой информации нет в его «памяти».

Autonomous Prompting — это цикл Мысль -> Действие. Агент использует CoT для планирования (генерации «Мысли»), а затем действует с помощью инструментов (например, веб-поиска), чтобы получить новые данные.

Пример 3: Autonomous Agent (Сквозной пример)

Давайте дадим ту же задачу нашему Autonomous Agent из прошлой статьи (LangChain + Tavily Search).

# КОД ИЗ ПРОШЛОЙ СТАТЬИ (Слегка адаптирован)
import os
from langchain_openai import ChatOpenAI
from langchain_community.tools.tavily_search import TavilySearchCV
from langchain import hub
from langchain.agents import create_react_agent, AgentExecutor

# 1. Установка API ключей
os.environ["OPENAI_API_KEY"] = "sk-..."
os.environ["TAVILY_API_KEY"] = "tvly-..."

# 2. Компоненты
llm = ChatOpenAI(model="gpt-4-turbo") # Агентам лучше брать модель помощнее
tools = [TavilySearchCV(max_results=1)]
prompt_template = hub.pull("hwchase17/react")

# 3. Создание Агента
agent = create_react_agent(llm, tools, prompt_template)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

# 4. ЗАПУСК АГЕНТА С НАШЕЙ ЗАДАЧЕЙ
print("--- [РЕЗУЛЬТАТ AUTONOMOUS AGENT] ---")
try:
    task = "Кто выиграл чемпионат NBA в тот год, когда вышел первый фильм 'Миссия: Невыполнима'?"
    response = agent_executor.invoke({"input": task})
    print("--- [ИТОГОВЫЙ ОТВЕТ АГЕНТА] ---")
    print(response["output"])
except Exception as e:
    print(f"Произошла ошибка: {e}")

Результат (Autonomous Agent verbose=True):

--- [РЕЗУЛЬТАТ AUTONOMOUS AGENT] ---
> Entering new AgentExecutor chain...

Thought: Мне нужно найти две вещи: год выхода первого фильма "Миссия: Невыполнима" и чемпиона NBA за тот год. Я начну с фильма.
Action: tavily_search(query="год выхода первый фильм Миссия: Невыполнима")
Observation: [Результат поиска: "Первый фильм 'Миссия: Невыполнима' (Mission: Impossible) вышел в 1996 году."]

Thought: Отлично, год 1996. Теперь мне нужно найти чемпиона NBA за 1996 год.
Action: tavily_search(query="чемпион NBA 1996")
Observation: [Результат поиска: "Победителем финала NBA 1996 года стали Chicago Bulls."]

Thought: Я нашел обе части информации. Год 1996, чемпион Chicago Bulls. Я могу дать финальный ответ.
Action: Final Answer: В год выхода первого фильма "Миссия: Невыполнима" (1996) чемпионат NBA выиграли **Chicago Bulls**.

> Finished chain.
--- [ИТОГОВЫЙ ОТВЕТ АГЕНТА] ---
В год выхода первого фильма "Миссия: Невыполнима" (1996) чемпионат NBA выиграли **Chicago Bulls**.

• Анализ: Посмотрите, как похожи «Мысль» (Thought) агента и «цепочка мыслей» из CoT! Autonomous Agent использует ту же логику CoT для планирования. Но ключевое отличие в том, что он не полагался на внутренние знания, а активно получил их извне с помощью «Действия» (Action).

Эволюция CoT: От Цепочки к Дереву (Tree-of-Thought)

Chain-of-Thought — это линейный процесс. Модель идет по «цепочке» (Шаг 1 -> Шаг 2 -> Шаг 3). Но что, если «Шаг 2» был ошибочным? Вся остальная цепочка будет неверной.

Следующая эволюция этой идеи — Tree-of-Thought (ToT) или «Дерево Мыслей». В этом подходе LLM не просто идет по одному пути, а исследует несколько (3-5) вариантов рассуждений на каждом шаге. Она как бы задается вопросами: А что, если пойти этим путем? А этим? А этим? Затем она сама оценивает, какой путь наиболее перспективный, и «обрезает» плохие «ветки», продолжая развивать хорошую. Это делает рассуждения ИИ еще более надежными и похожими на человеческие.

Заключение

Chain-of-Thought (CoT) — это не сложный инструмент, а фундаментальный навык работы с LLM. Это переход от «запроса» к «постановке задачи». Мы видим в этом простую, но мощную идею: если хочешь получить умный ответ, заставь LLM сначала «показать, как она думает».

CoT кардинально повышает точность моделей в сложных задачах, используя их же внутренние знания. Он также служит фундаментом для более продвинутых систем, таких как Autonomous Agents, которые используют ту же логику CoT для планирования, но дополняют ее внешними действиями (инструментами).

Референсные ссылки

1. Chain-of-Thought Prompting Elicits Reasoning in Large Language Models (arXiv.org) (https://arxiv.org/abs/2201.11903)
2. Prompting techniques: Chain-of-Thought (CoT) (Microsoft Azure AI) (https://learn.microsoft.com/ru-ru/azure/ai-services/openai/concepts/prompting-techniques)
3. What is Chain-of-Thought Prompting? (LangChain Blog) (https://blog.langchain.dev/chain-of-thought-prompting/)
4. Tree of Thoughts: Deliberate Problem Solving with Large Language Models (arXiv.org) (https://arxiv.org/abs/2305.10601)