TL;DR
Thought-ICS — метод самокоррекции LLM через пошаговую генерацию рассуждений. Вместо того чтобы генерировать текст сплошным потоком (как обычный Chain-of-Thought), модель выдаёт рассуждение мысль-за-мыслью: на каждом шаге осознанно формулирует следующую законченную мысль, делает паузу, затем следующую. Это создаёт дискретную цепочку рассуждений с чёткими границами между шагами. После генерации система проверяет ответ, и если он неверен — запускает цикл коррекции: модель анализирует свои шаги, находит первую ошибочную мысль, откатывается к последнему правильному шагу и генерирует альтернативное продолжение.
LLM плохо находят ошибки в сплошном тексте своих рассуждений. Когда модель генерирует CoT обычным способом (токен за токеном), получается непрерывный поток текста без явных границ между логическими шагами. Попытка найти ошибку превращается в задачу "укажи где именно в этих трёх абзацах ты ошибся" — модель не может точно локализовать проблему, часто указывает не на первую ошибку или вообще мимо. Исследователи показали: на неструктурированном CoT модели получают erroneous prefix (префикс который всё ещё содержит ошибку) в значительной части случаев, что ломает всю идею отката и пересэмплирования.
Дискретная структура решает проблему. Когда модель генерирует мысль-за-мыслью, каждый шаг — это осознанное решение "какая следующая законченная мысль должна быть". Это создаёт естественные границы принятия решений в рассуждении. При анализе модель может пройтись по пронумерованным шагам и точно сказать "шаг 6 — вот здесь ошибка". Откат к шагу 5 даёт clean prefix (чистый префикс без ошибок). Большие модели получают clean prefix в 97% случаев. От чистого префикса пересэмплирование работает в разы эффективнее — модель строит альтернативное рассуждение с правильной основой. Thought-ICS показывает 20-40% lift над базовым Chain-of-Thought при наличии верификатора.
Схема метода
ГЕНЕРАЦИЯ (Thought MDP): Мысль-за-мыслью до финального ответа
Промпт: "Сформулируй следующий шаг рассуждения (одно наблюдение, вычисление или вывод)"
→ Мысль 1 [стоп]
→ Мысль 2 [стоп]
→ ...
→ Мысль N [финальный ответ]
ВЕРИФИКАЦИЯ: Ответ правильный?
НЕТ → продолжить цикл коррекции
ДА → выход
ЛОКАЛИЗАЦИЯ: Найти первую ошибочную мысль
Промпт: "Проанализируй каждый шаг. Найди логические ошибки, неправильные вычисления,
ложные предположения. Верни номер первого ошибочного шага"
→ "Ошибка в шаге 6: [объяснение]"
ПЕРЕСЭМПЛИРОВАНИЕ: Откат и новая ветка
Откат к шагу 5 (последний правильный)
Генерация новой последовательности мыслей от шага 6
→ альтернативное рассуждение
Цикл повторяется до корректного ответа или максимума итераций.
Пример применения
Задача: Ты консультируешь стартап по подписке на здоровое питание. Надо посчитать unit-экономику: сколько стоит привлечь клиента, сколько он принесёт, когда окупится. Цифры: CAC 3000₽, средний чек 4500₽/мес, маржа 40%, средний LT 8 месяцев, churn 15%/мес. Нужна точность — инвестор спрашивает ROI.
Промпт:
Задача: Рассчитай unit-экономику для бизнеса с подпиской.
Данные:
- CAC (стоимость привлечения клиента): 3000₽
- Средний чек: 4500₽/месяц
- Маржинальность: 40%
- Средний LT (lifetime): 8 месяцев
- Churn rate: 15%/месяц
Рассуждай пошагово. После каждого шага делай паузу.
Структура вывода:
ШАГ 1: [первая мысль/вычисление]
---
ШАГ 2: [следующая мысль/вычисление]
---
...
После финального ответа остановись.
Если получишь ответ — я проверю правильность. Если неверно — ты проанализируешь
свои шаги, найдёшь первую ошибку, вернёшься к последнему правильному шагу
и продолжишь рассуждение по-другому.
Результат:
Модель выдаст последовательность пронумерованных шагов: расчёт маржинального дохода с клиента, умножение на LT, вычет CAC, расчёт payback period. Каждый шаг — отдельный блок с явной границей.
Если в решении ошибка (например, забыла учесть churn при расчёте retention) — ты говоришь "неверно". Модель анализирует шаги, находит "ШАГ 3: ошибка — не учёл влияние churn на средний LT", откатывается к ШАГу 2 и строит альтернативное продолжение: пересчитывает retention с учётом churn, корректирует LT, выдаёт правильный итоговый расчёт.
Вместо полного пересчёта с нуля — точечная коррекция конкретного шага.
Почему это работает
LLM не может надёжно локализовать ошибки в сплошном потоке текста. Когда модель генерирует Chain-of-Thought обычным способом, получается непрерывная последовательность токенов без чётких границ между логическими шагами. Попытка найти "где именно ошибка" требует парсинга смысла из абзацев текста. Модель часто промахивается: указывает на шаг который уже содержит последствия ранней ошибки, или вообще не может найти.
LLM хорошо умеет генерировать последовательности и следовать структурированным инструкциям. Когда на каждом шаге модель получает промпт "сформулируй следующую законченную мысль", она делает осознанное решение о содержании этого шага. Это создаёт естественные границы принятия решений — точки где одна мысль закончилась, следующая началась. Структура явная: мысль 1, мысль 2, мысль 3...
Метод использует эти границы как якоря для локализации. Модель проходит по пронумерованным шагам и анализирует каждый отдельно. "Шаг 1 — корректен. Шаг 2 — корректен. Шаг 3 — здесь ошибка в вычислении." Исследование показало: большие модели получают clean prefix (префикс до первой ошибки) в 97% случаев при структурированных рассуждениях — против значительно меньшего процента на сплошном CoT. От чистого префикса пересэмплирование работает эффективно: модель строит альтернативное рассуждение с правильной основой.
Рычаги управления:
- Stopping marker между мыслями (
---,[NEXT],) — выбираешь что удобнее парсится - Глубина детализации шагов ("одно вычисление" vs "один логический блок") — влияет на точность локализации
- Максимум итераций цикла коррекции — баланс между качеством и токенами
- Источник верификации (oracle = ты сам проверяешь / self = модель сама) — oracle точнее, self автономнее
Шаблон промпта
Вариант 1: Структурированная генерация с ручной коррекцией
Задача: {описание_задачи}
Рассуждай пошагово. Каждый шаг — одна законченная мысль (наблюдение, вычисление, вывод).
Формат вывода:
ШАГ 1: [текст мысли]
---
ШАГ 2: [текст мысли]
---
...
ШАГ N: [финальный ответ]
Делай паузу после каждого шага. Переходи к следующему только когда текущий
сформулирован полностью.
Применение: После генерации ты проверяешь ответ. Если неверно → просишь модель проанализировать шаги и найти ошибку → она возвращает номер шага → ты пишешь "вернись к шагу N-1 и продолжи по-другому".
Вариант 2: Автономный цикл самокоррекции
Задача: {описание_задачи}
ИНСТРУКЦИЯ:
1. Сгенерируй решение пошагово. Каждый шаг нумеруй.
Формат: "ШАГ X: [мысль]"
2. После завершения — проверь ответ самостоятельно.
3. Если ответ неверен:
- Проанализируй каждый шаг
- Найди первую ошибку (логическую, вычислительную, концептуальную)
- Верни: "Ошибка в ШАГе X: [объяснение]"
- Откатись к ШАГу X-1
- Сгенерируй альтернативное продолжение
4. Повтори проверку. Если снова неверно — повтори анализ и коррекцию.
Максимум {N} итераций коррекции.
Начни с генерации первого варианта решения:
Заполни: {описание_задачи} — твоя задача, {N} — количество попыток коррекции (2-3 достаточно).
🚀 Быстрый старт — вставь в чат:
Вот метод Thought-ICS для точной самокоррекции. Адаптируй под мою задачу: [твоя задача].
Задай вопросы чтобы правильно структурировать.
[вставить Вариант 2 выше]
Модель спросит детали задачи, сколько итераций, нужна ли ей автономная проверка или ты будешь верифицировать вручную. Она возьмёт паттерн пошаговой генерации → локализации → отката и адаптирует под твой кейс.
Ограничения
⚠️ Простые задачи: Для вопросов типа "столица Франции" структура избыточна — обычный CoT достаточен. Метод эффективен когда рассуждение сложное и вероятность ошибки высока (математика, многошаговый анализ, расчёты).
⚠️ Токены: Цикл коррекции требует больше токенов чем однократная генерация: несколько веток рассуждений + анализ + локализация. На сложных задачах это оправдано ростом точности, на простых — расточительно.
⚠️ Self-verification неидеальна: Когда модель сама проверяет правильность (без внешнего верификатора), она может пропустить ошибку или наоборот ложно забраковать правильный ответ. Исследование показало что V/L disagreement (верификация говорит "неверно", локализация не находит ошибку) — частый случай выхода при self-verification. Oracle verification (ты сам проверяешь или есть ground truth) надёжнее.
⚠️ Маленькие модели: Локализация работает тем лучше, чем больше модель. Модели 3B-8B дают clean prefix (чистый откат до первой ошибки) реже — часто промахиваются мимо реальной первой ошибки и откатываются к префиксу который всё ещё содержит баг. Модели 70B+ показывают 97% clean prefix.
Почему структура эффективнее сплошного CoT
Исследователи сравнивали Thought-ICS (структурированная генерация) с Token-ICS (обычный CoT + попытка локализовать ошибку в тексте). Обе версии использовали одинаковый фреймворк: верификация → локализация → откат → пересэмплирование. Разница только в генерации: мысль-за-мыслью vs токен-за-токеном.
Тестировали на восьми моделях (от 3B до 120B параметров) и шести бенчмарках: математические соревнования (AMC, AIME), сложные задачи уровня MATH-L5, арифметические задачи (MathQA), здравый смысл (CSQA), наука уровня PhD (GPQA). По 100 задач на датасет.
Ключ к честному эксперименту: использовали oracle verification — внешний верификатор (ground truth) говорил "ответ неверен", чтобы изолировать способность к локализации и коррекции от проблем с верификацией. Если модель не может определить что ошибка есть — коррекция не запустится вообще. Oracle убрал этот барьер.
Находка: Thought-ICS показал 20-40% lift (рост точности относительно baseline CoT) почти на всех моделях и датасетах. Token-ICS в лучшем случае давал 5-10% lift, часто вообще не давал улучшения или даже вредил.
Почему такая разница? Провели детальный анализ локализации. Взяли три frontier модели (Sonnet-3.7, GPT-4.1, GPT-o1-mini) как oracle localizer — они независимо анализировали ошибочные решения и указывали первую ошибку. Если все три согласились — это "ground truth" локализация. Согласие на структурированных рассуждениях: 51% полное совпадение, 74% в пределах ±1 шаг, 85% в пределах ±2 шагов. На сплошном CoT согласие было значительно ниже — модели цитировали разные фрагменты текста, даже с tolerance 10% длины решения согласие всего 58%.
Затем сравнили self-localization (модель сама ищет ошибку) с oracle. На структурированных рассуждениях большие модели (70B+) получали clean prefix в 97% случаев — откатывались к точке до первой ошибки или раньше. Средние модели (7-32B) — 53-71% clean prefix. На сплошном CoT даже большие модели часто промахивались.
Критический инсайт: когда модель откатывается к clean prefix (без ошибок), пересэмплирование работает в разы эффективнее. От чистой основы модель строит альтернативное рассуждение с вероятностью успеха ~60-80%. Когда префикс erroneous (содержит ошибку которую пропустили) — вероятность коррекции падает до ~20-30%, потому что модель снова приходит к неверному выводу, наследуя раннюю ошибку.
Бонус: сама структурированная генерация (даже без коррекции) давала небольшой initial lift — модель сразу чаще решала правильно. Авторы предполагают: явная пауза между мыслями заставляет модель более обдуманно формулировать следующий шаг, снижая импульсивные ошибки.
Также тестировали self-verification режим (никакого oracle) — модель сама решает, проверяет, находит ошибку, корректирует. Результат: всё равно net positive lift, хотя и меньше чем с oracle, потому что self-verification иногда пропускает ошибки или ложно бракует правильное. Но Thought-ICS всё равно обогнал существующие методы самокоррекции (Self-Refine, CoVe) которые работают на сплошном CoT.
Оригинал из исследования
Промпт для пошаговой генерации (Thought MDP):
State your next reasoning step (one observation, calculation, or deduction).
Модель выдаёт одну мысль, затем специальный closing marker (например --- или ). Система добавляет эту мысль к префиксу и снова даёт тот же промпт. Цикл до финального ответа (например \boxed{...}).
Промпт для локализации ошибки:
You generated the following reasoning trace:
[STEP 1] {thought 1}
[STEP 2] {thought 2}
...
[STEP N] {thought N}
Analyze each step carefully. Identify any logical flaws, arithmetic mistakes,
or incorrect assumptions.
If you find an erroneous step, return:
- The step number of the FIRST error
- Brief explanation of what went wrong
If no error is found, state "No error identified."
Контекст: Исследователи использовали эти промпты для тестирования на моделях через API. Пошаговая генерация создавала дерево рассуждений: каждая мысль — узел, откат — переход к родительскому узлу, пересэмплирование — новая ветка. В inference time фреймворк управлял циклом: генерация → верификация → локализация → откат → новая генерация.
Адаптации и экстраполяции
💡 Адаптация: упрощённый мануальный режим
Если не хочешь автоматизировать цикл — используй структуру вручную:
Шаг 1: Попроси модель решить задачу пошагово с явной нумерацией.
Реши задачу шаг за шагом. Нумеруй каждый шаг: "ШАГ 1:", "ШАГ 2:", и т.д.
Задача: {твоя_задача}
Шаг 2: Проверь финальный ответ. Если неверен → запроси анализ:
Ответ неверен. Проанализируй свои шаги. Найди первую ошибку.
Верни номер шага и объяснение.
Шаг 3: Получив номер (например, "ошибка в ШАГе 5") → откат:
Вернись к ШАГу 4. Продолжи решение с этого момента,
но рассуждай по-другому на ШАГе 5.
Ценность: контроль на каждом этапе. Ты видишь что модель локализовала, можешь согласиться или оспорить, можешь сам указать шаг для отката.
🔧 Техника: добавь явный финальный чек-лист
После финального ответа попроси модель проверить себя по критериям:
ШАГ N: [финальный ответ]
ФИНАЛЬНАЯ ПРОВЕРКА:
□ Все вычисления корректны?
□ Логика не содержит противоречий?
□ Ответ соответствует исходному вопросу?
□ Единицы измерения правильные?
Если хоть один пункт НЕТ — верни номер шага с ошибкой.
Эффект: снижает ложные срабатывания локализации (когда модель не видит ошибку) и добавляет структурированную самопроверку.
🔧 Техника: мета-рефлексия после коррекции
После пересэмплирования попроси модель объяснить что изменилось:
Ты откатился к ШАГу X и сгенерировал новое продолжение.
Объясни:
1. Что было неправильно в первой версии?
2. Что изменилось во второй версии?
3. Почему новое рассуждение корректнее?
Эффект: прозрачность коррекции. Видишь не только итоговый ответ, но и понимание модели что именно она исправила. Полезно для обучения и для сложных кейсов где нужна уверенность в выводах.
Ресурсы
"Structure Enables Effective Self-Localization of Errors in LLMs" — оригинальное исследование, тестировавшее Thought-ICS на восьми моделях (LLaMA 3, Qwen 2.5, GPT-OSS) и шести reasoning бенчмарках.
Авторы упоминают связь с работами по anterior cingulate cortex (нейробиология мониторинга ошибок на уровне discrete decision points): Botvinick et al. 2004, Carter et al. 1998, MacDonald et al. 2000 — как вдохновение для архитектуры метода.
Связанные методы самокоррекции: Self-Refine (Madaan et al., 2023), CoVe (Dhuliawala et al., 2023), Reflexion (Shinn et al., 2023), RCI (Kim et al., 2023). Thought-ICS отличается от них наличием явной структуры и точечной локализации, вместо холистической регенерации всего решения.
Thought-level generation использовалась в Tree-of-Thoughts (Yao et al., 2023), но там сегментация rule-based и требуется external scoring. Thought-ICS даёт модели самой определять boundaries мыслей.