3,583 papers
arXiv:2605.13511 74 13 мая 2026 г. FREE

Many-Shot CoT-ICL: порядок примеров в промпте работает как учебная программа

КЛЮЧЕВАЯ СУТЬ
Обнаружено: два внешне похожих примера в промпте могут требовать разных процедур решения. Модель получает конфликтующие инструкции — и усредняет их. Чем больше таких примеров, тем хуже результат. Метод Many-Shot CoT-ICL позволяет выстраивать примеры так, чтобы модель усваивала процедуру рассуждения, а не путалась в противоречиях. Фишка: порядок от простого к сложному плюс разные процедуры в примерах — вместо набора похожих случаев. Модель читает не ответы, а методику: исследователи заменили рассуждения в примерах на скопированный текст, оставив правильные ответы — точность упала. Значит, важно именно КАК думали, а не ЧТО ответили.
Адаптировать под запрос

TL;DR

Когда ты даёшь LLM несколько примеров в промпте — это не просто "образцы для копирования". Модель читает их как учебную программу: следует процедурам рассуждения, а не просто запоминает ответы. Если примеры идут в случайном порядке или выбраны неправильно — результат деградирует, а не улучшается.

Главная находка: для задач с рассуждением (математика, логика, анализ) больше примеров ≠ лучше. Когда ты добавляешь похожие примеры в надежде помочь модели — ты на самом деле мешаешь. Два внешне похожих примера могут требовать совершенно разных процедур решения, и модель начинает путаться в "конфликтующих инструкциях".

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


🔬

Схема метода

ШАГ 1: Определи тип задачи
→ Рассуждение (математика, анализ, логика) → применяй все принципы ниже
→ Классификация/простые ответы → порядок не так важен

ШАГ 2: Выбери примеры (если есть возможность выбирать)
→ НЕ бери "похожие на вопрос" — бери разные процедуры
→ ИЛИ попроси модель сгенерировать примеры самостоятельно

ШАГ 3: Упорядочи примеры в промпте
→ Сначала — простые случаи с базовой процедурой
→ В конце — сложные, похожие на твою задачу

ШАГ 4: Добавь свою задачу
→ Модель "продолжает обучение" и применяет усвоенную процедуру

ВСЁ выполняется в одном промпте (или в двух шагах,
если используешь самогенерацию примеров)

🚀

Пример применения

Задача: Ты хочешь, чтобы Claude разбирал финансовую модель стартапа по одной и той же логике — проверял unit-экономику, находил слабые места. Ты даёшь несколько примеров разборов.

Промпт (двухшаговый вариант):

ШАГ 1 — отправь отдельным запросом:

Сгенерируй 3 примера разбора unit-экономики стартапов — 
от простого к сложному.

Пример 1: простой случай (подписочный SaaS с понятными метриками)
Пример 2: средний (маркетплейс с двусторонней моделью)
Пример 3: сложный (hardware + SaaS с длинным циклом продажи)

Для каждого покажи пошаговое рассуждение:
— Какие метрики считаем в первую очередь и почему
— Где ищем разрыв между юнит-экономикой и ростом
— Какой вывод и почему

---

ШАГ 2 — в тот же чат, после ответа:

Отлично. Теперь используй ту же логику разбора и проанализируй 
стартап: [описание своего кейса]

Результат:

В первом шаге модель сгенерирует три разбора с нарастающей сложностью — каждый покажет конкретную процедуру анализа с шагами. Во втором шаге модель применит усвоенную процедуру к твоему кейсу — не просто выдаст общие слова про "CAC и LTV", а пройдёт по тем же шагам, что в примерах. Структура разбора будет согласованной между примерами, потому что все они в одном "процедурном стиле".


🧠

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

Слабость LLM: Когда ты добавляешь примеры в промпт, модель не просто "смотрит на ответы". Она читает процедуры рассуждения и пытается им следовать. Если несколько примеров требуют разных процедур — модель получает конфликтующие инструкции и начинает "усреднять" их. Результат: хуже, чем без примеров вообще.

Сильная сторона LLM: Модели с режимом рассуждения (Claude с extended thinking, ChatGPT o1/o3/o4) умеют поглощать процедуры из контекста и применять их к новой задаче. Это не просто копирование — они реально усваивают методику. Исследователи проверили это жёстко: взяли правильные примеры, заменили в них всё рассуждение на один и тот же скопированный текст (но ответы оставили верными). Результат упал. Значит, модель читает не только ответы — она читает КАК думали.

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

Рычаги управления: - Количество примеров → для рассуждений достаточно 3–5 хорошо упорядоченных; больше не всегда лучше - Источник примеров → самогенерация (попроси модель сначала сделать примеры) работает лучше, чем примеры, которые ты нашёл сам — стиль рассуждения остаётся согласованным - Порядок → всегда от простого к сложному, никогда случайный - Тип модели → с reasoning-моделями (o1, o3, Claude Thinking) принцип работает сильнее; с обычными моделями — аккуратнее, можно навредить


📋

Шаблон промпта

{Описание задачи}

Ниже — примеры того, как рассуждать при решении таких задач. 
Они идут от простого к сложному:

Пример 1 (базовый):
Задача: {простой_пример}
Рассуждение: {шаги_1}
Вывод: {ответ_1}

Пример 2 (средний):
Задача: {средний_пример}
Рассуждение: {шаги_2}
Вывод: {ответ_2}

Пример 3 (ближе к моей задаче):
Задача: {сложный_пример}
Рассуждение: {шаги_3}
Вывод: {ответ_3}

Теперь, используя ту же логику рассуждения, реши:
{моя_задача}

Рассуждение:

Плейсхолдеры: - {Описание задачи} — что нужно сделать в целом: "проверь бизнес-гипотезу", "оцени юридический риск", "разбери аргумент" - {простой_пример}{сложный_пример} — три случая с нарастающей сложностью; важно: разные процедуры решения, не три похожих случая - {шаги_1–3} — пошаговое рассуждение, не просто ответ - {моя_задача} — реальный вопрос, с которым пришёл


🚀 Быстрый старт — вставь в чат:

Вот шаблон для few-shot промпта с упорядоченными примерами. 
Адаптируй под мою задачу: [твоя задача].
Задавай вопросы, чтобы заполнить поля.

[вставить шаблон выше]

LLM спросит про тип задачи, попросит описать несколько примеров с разными уровнями сложности — потому что без этого невозможно построить правильную "прогрессию" от простого к сложному. Она возьмёт паттерн из шаблона и адаптирует под задачу.


⚠️

Ограничения

⚠️ Обычные (не reasoning) модели: На задачах с рассуждением добавление большого числа CoT-примеров нестабильно — может ухудшить результат. Принцип работает надёжнее на Claude Thinking, ChatGPT o3/o4, чем на обычных версиях без режима рассуждения.

⚠️ Для классификации и простых ответов: Порядок примеров почти не влияет — там важнее количество и качество. Вся система выше заточена под задачи с многошаговым рассуждением.

⚠️ CDS-метод из исследования (автоматический подбор порядка) требует векторных эмбеддингов и математики кривизны — в чате недоступен. В шаблоне выше — ручная версия принципа.

⚠️ Самогенерация примеров не панацея: Если модель слабая и сама генерирует ошибочные рассуждения — она подкармливает себя плохими примерами. Проверяй, что сгенерированные примеры логически верны, до использования их как демонстраций.


🔍

Как исследовали

Команда взяла 8 LLM двух типов: обычные (LLaMA, Qwen 2.5) и "рассуждающие" (DeepSeek-R1, QwQ, Qwen3). Тестировали на задачах двух видов: классификация (где ответ — просто метка) и математические рассуждения (геометрия, теория чисел, нарративные детективные задачи).

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

Самый показательный эксперимент — "коррупция процедур": взяли 128 правильных примеров и заменили все рассуждения в них на одно и то же скопированное рассуждение (ответы остались верными). При 16 примерах разница незаметна. При 128 — падение стало чётким. Это доказывает: модель читает процедуру, а не просто смотрит на ответ. Отсюда вытекает весь практический смысл метода.


💡

Адаптации и экстраполяции

1. Принцип "зоны понимания" при отладке промптов

Если модель не следует инструкции — не добавляй сложные примеры. Попробуй сначала дать самый простой случай, убедись что он работает, затем усложняй.

🔧 Техника: нарастающая сложность примеров → диагностика где ломается

"Покажи как ты решаешь задачу уровня 1, потом 2, потом 3. Остановись, когда почувствуешь неуверенность."

Это работает как диагностика: видишь на каком уровне сложности модель начинает "угадывать" вместо рассуждения.


2. Самогенерация как замена поиску примеров

Вместо того чтобы часами подбирать хорошие few-shot примеры — делегируй это модели:

Сгенерируй 4 учебных примера для задачи: {тип_задачи}.
Требования:
- Каждый пример должен использовать немного другую процедуру решения
- Порядок: от простого к сложному
- Для каждого — полное пошаговое рассуждение, не только ответ

После генерации примеров подтверди, что готов получить мою задачу.

Получаешь согласованные примеры в стиле модели — без поиска, без подбора.


🔗

Ресурсы

Название работы: Many-Shot CoT-ICL: Making In-Context Learning Truly Learn Конференция: 43rd International Conference on Machine Learning (ICML), Seoul, South Korea, PMLR 306, 2026 Авторы: Tsz Ting Chung, Lemao Liu, Mo Yu, Dit-Yan Yeung Организации: Hong Kong University of Science and Technology, Fudan University, WeChat AI (Tencent) Контакт: ttchungac@connect.ust.hk


📋 Дайджест исследования

Ключевая суть

Обнаружено: два внешне похожих примера в промпте могут требовать разных процедур решения. Модель получает конфликтующие инструкции — и усредняет их. Чем больше таких примеров, тем хуже результат. Метод Many-Shot CoT-ICL позволяет выстраивать примеры так, чтобы модель усваивала процедуру рассуждения, а не путалась в противоречиях. Фишка: порядок от простого к сложному плюс разные процедуры в примерах — вместо набора похожих случаев. Модель читает не ответы, а методику: исследователи заменили рассуждения в примерах на скопированный текст, оставив правильные ответы — точность упала. Значит, важно именно КАК думали, а не ЧТО ответили.

Принцип работы

Стандартный подход: подбери примеры, похожие на задачу — модель поймёт. Это ловушка. Похожесть по теме не равна похожести по процедуре. Два примера про финансы могут требовать разной логики — модель получает два конкурирующих сценария и начинает «усреднять». Чем больше похожих примеров — тем сильнее разброс на задачах с рассуждением. Правильная механика другая: каждый следующий пример показывает новый аспект той же процедуры и чуть больший уровень сложности. Модель не путается — она разогревается. Случайный порядок ломает это разогревание: каждый новый пример сбрасывает накопленный контекст.

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

Исследователи провели жёсткую проверку. Взяли правильные примеры. Заменили в них всё рассуждение на скопированный бессмысленный текст — но правильные ответы оставили нетронутыми. Точность упала. Модель читает не «что ответили», а «как думали» — усваивает процедуру целиком. Поэтому два параметра решают всё: порядок (нарастание сложности даёт плавный переход между концепциями) и разнообразие процедур (разные методики в примерах = богатый набор инструментов вместо конкурирующих инструкций). Самогенерация примеров работает лучше подобранных вручную — стиль рассуждений остаётся согласованным, модель не переключается между «чужими голосами».

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

Задачи с многошаговым рассуждением → конкретно для математики, логического анализа, разбора аргументов, финансового моделирования, юридической оценки — особенно когда нужна воспроизводимая структура ответа каждый раз. Работает сильнее с reasoning-моделями (o1, o3, Claude Thinking) — с обычными осторожнее, лишние примеры могут навредить. НЕ подходит для классификации и простых ответов: там порядок примеров почти не влияет на результат — важнее количество и покрытие классов.

Мини-рецепт

1. Определи тип задачи: Это рассуждение, анализ, логика? Тогда читай дальше. Простые ответы или классификация? Порядок примеров не важен — этот метод не для тебя.

2. Попроси модель сгенерировать примеры самостоятельно: Отправь отдельным запросом: Сгенерируй 3 примера [тип задачи] — от простого к сложному. Для каждого покажи пошаговое рассуждение. Стиль рассуждений останется согласованным. Проверь логику примеров до использования — слабая модель может нагенерировать ошибочные рассуждения.

3. Выбери процедуры, не похожесть: Три примера — три разных подхода к решению. Не три похожих случая с одинаковой механикой.

4. Выстрой порядок вручную: Базовый случай с простой процедурой → средней сложности → ближе всего к твоей задаче. Никогда не перемешивай случайно.

5. Добавь свою задачу последней: Заверши промпт строкой Рассуждение: и оставь пустым — модель продолжит в том же стиле.

Примеры

[ПЛОХО] : Вот три примера разбора юридического договора: [три похожих случая про аренду]. Разбери мой договор.
[ХОРОШО] : Шаг 1 — отдельным запросом: Сгенерируй 3 примера разбора юридических рисков договора — от простого к сложному. Пример 1: стандартная аренда офиса. Пример 2: договор с иностранным подрядчиком. Пример 3: лицензионное соглашение с неявными ограничениями. Для каждого — пошаговое рассуждение: что проверяем первым, где ищем скрытый риск, какой вывод и почему. Шаг 2 — после ответа: Используй ту же логику разбора и проанализируй мой договор: [текст или описание договора]
Источник: Many-Shot CoT-ICL: Making In-Context Learning Truly Learn
ArXiv ID: 2605.13511 | Сгенерировано: 2026-05-14 05:32

Проблемы LLM

ПроблемаСутьКак обойти
Больше похожих примеров — хуже результатДобавляешь примеры которые "выглядят похоже" на задачу. Кажется это должно помочь. Но внешне похожие задачи часто решаются по-разному. Модель читает несколько примеров с разными процедурами рассуждения. Начинает "усреднять" их. Результат хуже чем с одним примером или вообще без примеров. Работает именно для задач с рассуждением: математика, анализ, логикаВыбирай примеры по разнообразию процедур решения, а не по похожести на задачу. Три разных подхода к решению — лучше чем три похожих случая

Методы

МетодСуть
Самогенерация примеров — согласованный стиль рассужденияШаг 1: попроси модель сгенерировать примеры по твоей теме — от простого к сложному. Шаг 2: в том же чате попроси решить реальную задачу "той же логикой". Почему работает: внешние примеры написаны в чужом стиле рассуждений. Самогенерированные — в стиле этой модели. Процедура остаётся согласованной между примерами. Конфликта нет. Осторожно: если модель слабая — проверь что примеры логически верны до использования

Тезисы

ТезисКомментарий
Модель усваивает процедуру рассуждения, а не ответы из примеровКогда даёшь примеры в промпт, модель читает KAK думали — шаги, логику, переходы. Не просто запоминает ответы. Это доказывается просто: если заменить рассуждение в примере на бессмысленный текст (но оставить верный ответ) — результат падает. Следствие для практика: пиши в примерах развёрнутые шаги решения. Правильный ответ без объяснения — почти бесполезен
📖 Простыми словами

Many-Shot CoT-ICL: Making In-Context Learning Truly Learn

arXiv: 2605.13511

Модели не просто копируют твои примеры, они пытаются вычислить скрытый алгоритм действий. Когда ты закидываешь в промпт пачку примеров с рассуждениями, для нейронки это не просто «образцы», а полноценная учебная программа. Она сканирует логику шагов, а не финальный ответ. Если ты даешь ей Many-Shot CoT, ты буквально перепрошиваешь ее поведение на лету, заставляя мозг модели работать по твоим рельсам.

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

Суть метода в том, что процедура рассуждения важнее правильного ответа. Если ты хочешь, чтобы Claude или GPT разобрали финансовую модель, тебе нужно дать им несколько примеров, где логика анализа (например, проверка unit-экономики) всегда идет по одному сценарию. Модель цепляется за этот паттерн мышления. Если примеры подобраны грамотно, точность взлетает, но если в них бардак — модель получает конфликтующие инструкции и начинает выдавать среднюю температуру по больнице, что в итоге хуже, чем вообще отсутствие примеров.

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

Короче, хватит кормить модель случайными кусками текста и ждать магии. Либо делай Many-Shot с идеальной последовательностью и единой логикой, либо не мучай промпт. Плохие примеры — это информационный шум, который сбивает модель с толку. Хочешь крутой результат — выстраивай примеры как четкую лестницу, по которой нейронка поднимется к правильному выводу, иначе она просто споткнется на первом же шаге.

Работа с исследованием

Адаптируйте исследование под ваши задачи или создайте готовый промпт на основе техник из исследования.

0 / 2000
~0.5-2 N-токенов ~10-30с
~0.3-1 N-токенов ~5-15с