TL;DR
CritICL — метод, который меняет содержание few-shot примеров в промпте. Вместо привычной пары "вопрос → правильный ответ" модель получает пример "вопрос → неправильный ответ → разбор, где именно ошибка и почему она возникла". Модель видит не образец для копирования, а предупреждение — куда не стоит сворачивать.
Главная находка исследования: маленькая и большая модель одного семейства ошибаются одинаково. Если Qwen на 1.5 миллиарда параметров путает знаки при переносе через равенство, то Qwen на 72 миллиарда — с большой вероятностью тоже. Это значит, что дешёвую маленькую модель можно использовать как "детектор слабых мест" для дорогой большой — не нужно гадать, где сильная модель ошибётся, достаточно посмотреть, где спотыкается её младший брат.
Метод строит базу таких типичных ошибок (называется CritBank): слабые модели решают задачи, часть решений неверна, для каждой ошибки отдельная LLM пишет короткий разбор — что пошло не так. При решении новой задачи система подбирает релевантные разборы ошибок из базы (либо предсказывая, какая ошибка вероятна именно здесь — dynamic, либо беря общий "профиль слабостей" модели — static) и вставляет их в промпт как few-shot примеры.
Схема метода
ЭТАП 1 (офлайн, разовая подготовка базы):
Слабая модель решает 15 000 задач → часть решений неверна
→ Другая LLM размечает: "какая это ошибка" + пишет критику (разбор)
→ Всё складывается в базу: вопрос + неверный ответ + тип ошибки + критика
ЭТАП 2 (при каждом новом вопросе):
CritICL-dynamic: модель сначала предсказывает "какие ошибки вероятны в этом вопросе"
→ достаёт из базы подходящие разборы → вставляет их в промпт → решает задачу
(два запроса к модели)
CritICL-static: берётся заранее готовый список "типичных слабостей этой модели"
→ достаются разборы под них → вставляются в промпт → модель решает задачу
(один запрос к модели)
Пример применения
Задача: Финансовый аналитик стартапа просит модель посчитать unit-экономику: LTV, CAC, точку безубыточности с учётом оттока клиентов. Модель регулярно забывает учесть отток в формуле LTV или путает валовую и чистую прибыль.
Промпт:
Вот пример, как модель обычно ошибается в подобных расчётах:
Вопрос: Посчитай LTV клиента, если средний чек 2000 руб/мес,
средний срок жизни клиента 8 месяцев, маржинальность 40%.
Неправильный расчёт: LTV = 2000 × 8 = 16 000 руб.
Почему это ошибка: расчёт использует выручку, а не маржинальную
прибыль. Правильно: LTV = 2000 × 0,4 × 8 = 6 400 руб.
Модель систематически забывает применить маржинальность
перед умножением на срок жизни.
Теперь реши мою задачу с учётом этой типичной ошибки:
[твои данные по стартапу]
Результат: Модель явно проговорит, что учитывает маржинальность до умножения на срок жизни клиента, и с большей вероятностью не повторит замеченную ошибку — потому что пример в промпте прямо указывает на эту ловушку, а не просто показывает "как правильно" в отрыве от контекста ошибки.
Почему это работает
Модели одного семейства учились похожим образом и наследуют одни и те же слепые пятна в рассуждениях — не случайные, а систематические. Обычные few-shot примеры показывают только "правильный путь" и не предупреждают, где модель обычно сворачивает не туда.
LLM хорошо считывает контраст в примере: "было — неправильно — почему — правильно" работает как явное предупреждение, а не абстрактная подсказка. Это использует сильную сторону модели — обучение в контексте (in-context learning) — но направляет его точнее, чем случайный набор примеров.
Рычаги управления: можно менять количество critique-примеров в промпте (в исследовании — до 5), можно выбирать между общим профилем типичных ошибок темы (static, экономит запрос) или точечным предсказанием ошибки под конкретный вопрос (dynamic, точнее, но нужен доп. запрос).
Шаблон промпта
Вот примеры типичных ошибок в задачах такого типа:
Пример 1
Вопрос: {похожий вопрос}
Неправильное решение: {как обычно ошибаются}
Почему это ошибка: {разбор причины ошибки}
Пример 2
Вопрос: {ещё один похожий вопрос}
Неправильное решение: {типичная ошибка}
Почему это ошибка: {разбор}
Теперь реши задачу, избегая этих ошибок:
{твоя задача}
Подставляй в примеры реальные типичные ошибки твоей темы — если не знаешь их, попроси саму модель сначала сгенерировать 2-3 частых заблуждения по теме, а потом используй их как основу для критики.
🚀 Быстрый старт — вставь в чат:
Вот шаблон CritICL — промпт с примерами типичных ошибок вместо обычных
few-shot примеров. Адаптируй под мою задачу: {твоя задача}.
Сначала предложи 2-3 типичные ошибки, которые модели обычно допускают
в такой задаче, распиши их в формате "неправильное решение → почему ошибка",
а потом реши мою реальную задачу с учётом этих ловушек.
[вставить шаблон выше]
LLM спросит про конкретику задачи и, если нужно, сама предложит вероятные типичные ошибки — потому что у неё есть общее представление о частых заблуждениях в теме, даже без доступа к базе CritBank.
Ограничения
⚠️ Нужна база примеров ошибок: оригинальный метод строит критики автоматически из ответов слабой модели. В чате без такой базы придётся вручную придумывать или просить модель сгенерировать типичные ошибки — это менее надёжно, чем реальные зафиксированные провалы.
⚠️ Работает лучше там, где есть чёткий правильный ответ: метод проверен на математике и похожих задачах с формальной проверкой. Для творческих или субъективных задач (текст, дизайн идеи) неясно, что считать "ошибкой" и критикой.
⚠️ Точная механика требует пары слабая-сильная модель одного семейства: в обычном чате пользователь не выбирает семейство модели и не имеет доступа к её "младшим версиям" — поэтому дословно воспроизвести retrieval невозможно, только сам принцип "критика вместо правильного примера".
Как исследовали
Команда взяла слабые модели Qwen (1.5, 3 и 7 миллиардов параметров) и Llama, прогнала через них 15 тысяч задач из GSM8K и MATH, собрала все неправильные решения. Отдельная LLM (GPT-4o-mini) размечала каждую ошибку по типу и писала короткую критику — что пошло не так. Затем эту базу использовали для подсказок сильным моделям того же семейства (Qwen 72B, Llama 70B) вместо обычных few-shot примеров.
Сравнивали с self-consistency (несколько генераций + голосование), self-reflection (модель сама себя правит) и LLM-as-judge — методами, которые требуют от 3 до 7 повторных генераций. CritICL обошёлся одной-двумя генерациями и показал точность на уровне или выше этих затратных методов.
Самое любопытное — проверка гипотезы: распределение типичных ошибок у модели на 1,5 миллиарда параметров почти совпадает с распределением ошибок у модели на 72 миллиарда из того же семейства. То есть дешёвая маленькая модель — надёжный индикатор слабостей дорогой большой. Это и объясняет, почему подсказки, собранные на слабых моделях, реально помогают сильным.