3,583 papers
arXiv:2511.06125 76 8 нояб. 2025 г. FREE

Justified QA: структурированный вывод с доказательствами для сложных вопросов

КЛЮЧЕВАЯ СУТЬ
Обнаружено: LLM принимают решения «в голове» без явной проверки каждого факта. При сложных вопросах (много критериев, десятки документов) модель пропускает правильные ответы или включает неверные — рассуждения остаются невидимыми. Метод Justified QA позволяет получать ответы с полным аудит-трейлом: для каждого кандидата видны доказательства «за», доказательства «против», логика рассуждений и финальный вердикт TRUE/FALSE. JSON-структура создаёт принудительную декомпозицию: модель не может перейти к вердикту, пока не заполнит evidence_for/against и reasoning. +0.14 F1 на RAG-задачах — это работает через вынос рассуждений наружу.
Адаптировать под запрос

TL;DR

Justified QA — техника промптинга, которая заставляет LLM для каждого ответа-кандидата выводить доказательства "за", доказательства "против", рассуждение и финальный вердикт в JSON-структуре. Вместо одного ответа модель генерирует список кандидатов с обоснованием каждого.

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

Метод решает проблему принудительной декомпозицией: модель сначала собирает ВСЕ возможные кандидаты (приоритет на полноту), затем для каждого явно выписывает цитаты "за" и "против", рассуждает вслух и выносит вердикт. Эта структура +0.14 F1 на RAG-задачах по сравнению с обычным промптом.


🔬

Схема метода

ШАГ 1: Сбор кандидатов → список ВСЕХ возможных ответов (приоритет на полноту)
ШАГ 2: Для каждого кандидата:
        → evidence_for: цитаты-доказательства "за"
        → evidence_against: цитаты "против"  
        → reasoning: рассуждение по критериям
        → final_judgment: TRUE/FALSE
ШАГ 3: Финальный ответ → только TRUE-кандидаты

[Всё в одном промпте, одним запросом]

🚀

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

Задача: Ты готовишь обзор российских IT-компаний для инвестора. Нужно понять, какие из упомянутых в статьях компании реально подходят под критерии: выручка >1 млрд рублей, работают с госзаказами, имеют продукт в сфере ИИ.

Промпт:

Твоя задача — ответить на вопрос на основе предоставленных документов.

Выведи ответ в формате JSON по схеме:

{
  "question": "Какие компании подходят под ВСЕ критерии: выручка >1 млрд ₽, госзаказы, продукт в ИИ?",
  "candidate_answers": [
    {
      "candidate_answer": "Название компании",
      "evidence_for": [{"doc_id": "ID документа", "text": "Цитата-доказательство..."}],
      "evidence_against": [{"doc_id": "ID документа", "text": "Цитата-опровержение..."}],
      "reasoning": "Подробное рассуждение по каждому критерию: выручка — да/нет потому что..., госзаказы — да/нет потому что..., ИИ-продукт — да/нет потому что...",
      "final_judgment": "TRUE/FALSE"
    }
  ],
  "answer": ["Список компаний только с TRUE вердиктом"]
}

Инструкции:
* Сначала собери ВСЕХ возможных кандидатов — приоритет на полноту. Потом фильтруй через reasoning и final_judgment.
* Каждая компания — отдельный candidate_answer.
* В evidence включай ВСЕ релевантные предложения из документа, пропуская нерелевантные (ставь "..." вместо них).

===== Документы =====
[здесь тексты статей]

===== Вопрос =====
Какие компании подходят под ВСЕ критерии: выручка >1 млрд ₽, работают с госзаказами, имеют продукт в сфере ИИ?

Результат: Модель выдаст JSON с 5-10 кандидатами. Для каждой компании — конкретные цитаты из документов с указанием источника. В reasoning будет явная проверка каждого критерия. В финале — отфильтрованный список только подтверждённых кандидатов. Ты видишь ВСЮ логику принятия решений — можно проверить любой вердикт.


🧠

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

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

Сильная сторона LLM: Модели отлично работают с структурой. Если задать шаблон "для каждого X сделай Y" — они следуют ему. JSON-схема создаёт принудительную декомпозицию: модель не может перейти к final_judgment, пока не заполнит evidence_for/against и reasoning.

Как метод использует силу против слабости: Структура промпта экстернализует рассуждения — выносит их из "головы" модели в текст. Это работает как Chain-of-Thought, но с жёстким форматом. Исследователи обнаружили: для мощных моделей (Gemini Pro) JSON-структуры достаточно, для слабых (Flash) нужен дополнительный этап "подумай своими словами" перед JSON (+0.07 F1).

Рычаги управления:

  • Количество кандидатов: "собери минимум 10 кандидатов" → больше полноты, длиннее вывод
  • Детализация evidence: "включай ВСЕ релевантные предложения" vs "только ключевую цитату"
  • Chain-of-thought: добавь "сначала подумай своими словами, потом JSON" для сложных задач
  • Критерии в reasoning: явно перечисли что проверять → модель проверит каждый пункт

📋

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

Твоя задача — ответить на вопрос на основе предоставленных документов/информации.

Выведи ответ в формате JSON:

{
  "question": "{вопрос}",
  "candidate_answers": [
    {
      "candidate_answer": "{кандидат}",
      "evidence_for": [{"source": "{источник}", "text": "{цитата-доказательство}"}],
      "evidence_against": [{"source": "{источник}", "text": "{цитата-опровержение}"}],
      "reasoning": "{рассуждение по каждому критерию}",
      "final_judgment": "TRUE/FALSE"
    }
  ],
  "answer": ["{только TRUE-кандидаты}"]
}

Инструкции:
* Приоритет на ПОЛНОТУ при сборе кандидатов. Фильтруй через reasoning и final_judgment.
* Каждый отдельный ответ — отдельный candidate_answer.
* В evidence включай все релевантные фрагменты, пропуская нерелевантные ("...").

===== Контекст =====
{документы или информация для анализа}

===== Вопрос =====
{твой вопрос}

Плейсхолдеры:

  • {вопрос} — что ищешь/проверяешь
  • {документы или информация} — тексты для анализа
  • {критерии} — можно добавить в инструкции явный список критериев для reasoning

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

Вот шаблон Justified QA для анализа информации. Адаптируй под мою задачу: [твоя задача]. 
Задавай вопросы, чтобы заполнить поля.

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

LLM спросит: какой вопрос анализируем? какие критерии проверяем? какие документы/источники? — потому что эти параметры определяют структуру reasoning и что искать в evidence.


⚠️

Ограничения

⚠️ Длина вывода: Для каждого кандидата модель генерирует evidence + reasoning. При 20+ кандидатах вывод становится очень длинным — следи за лимитами токенов.

⚠️ Качество источников: Метод работает когда есть документы/контекст для анализа. Без источников evidence_for/against будет пустым — модель вернётся к "галлюцинациям".

⚠️ Субъективные критерии: Исследователи тестировали на фактических вопросах (есть/нет в документе). Для субъективных оценок ("качественный продукт?") evidence менее надёжен.

⚠️ Дополнительная верификация даёт мало: Отдельный этап проверки каждого ответа улучшил результат всего на +0.02 F1. Основная ценность — в самом Justified QA промпте, не в дополнительных шагах.


🔍

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

Команда Google DeepMind взялась за QUEST-LOFT — бенчмарк где LLM должна найти ответы в корпусе из 328 документов (Wikipedia-статьи). Вопросы требуют сложной логики: "найди X И Y" или "X ИЛИ Z", где ответ — список из 5-15 сущностей. Это не "столица Франции", а "какие швейцарские фильмы про сталкинг" с ответом из нескольких пунктов.

Первый сюрприз: исследователи провели ручную проверку golden answers и обнаружили, что треть "ошибок" модели — на самом деле ошибки в эталоне. Модель отвечала правильно, но её ответ не совпадал с неполным golden set. Это важный урок: бенчмарки врут чаще, чем кажется.

После ревизии тестировали комбинации: RAG vs длинный контекст × базовый промпт vs Justified QA × с верификацией vs без. Результат: RAG + Justified QA = 0.83 F1 против 0.67 F1 у базового RAG (почти +25% относительного улучшения). Длинный контекст (весь корпус в промпте) дал только 0.77 F1 даже с оптимизациями.

Второй сюрприз: Chain-of-thought перед JSON помогает только слабым моделям. Gemini 1.5 Pro справлялся с JSON-структурой напрямую, а вот Flash без "подумай сначала" терял ~0.05 F1. Вывод: чем мощнее модель, тем меньше нужны костыли.

Практический инсайт: Самый большой буст дала не верификация (+0.02), а сам Justified QA промпт (+0.14). Структура с evidence и reasoning — это главное, остальное — тюнинг на краях.


📄

Оригинал из исследования

Контекст: Ниже — полный промпт Justified QA, который дал лучшие результаты на QUEST-LOFT.

Your task is to answer a given question based on the provided documents.

Please do so by outputting a response in the form of a JSON object
conforming to the following schema:
```json
{
 "question": "",
 "candidate_answers": [
   {
    "candidate_answer": "",
    "evidence_for": [{"doc_id": "", "text": ""}],
    "evidence_against": [{"doc_id": "", "text": ""}],
    "reasoning": "",
    "final_judgment": ""
   }
 ],
 "answer": [""],
 "answer_doc_ids": ["

💡

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

💡 Адаптация для проверки резюме кандидатов:

{
  "question": "Подходит ли кандидат под требования: 3+ года Python, опыт ML, английский B2+?",
  "candidate_answers": [
    {
      "candidate_answer": "Иван Петров",
      "evidence_for": [{"source": "резюме", "text": "5 лет разработки на Python... участвовал в ML-проектах..."}],
      "evidence_against": [{"source": "резюме", "text": "Английский не указан..."}],
      "reasoning": "Python 5 лет — ОК. ML — есть упоминание проектов. Английский — НЕТ данных в резюме, нужно уточнить.",
      "final_judgment": "MAYBE — уточнить английский"
    }
  ]
}

🔧 Техника: добавить "MAYBE" вердикт → для неопределённых случаев

Оригинал использует только TRUE/FALSE. Для реальных задач часто нужен третий вариант — "недостаточно данных". Добавь в инструкции: final_judgment: "TRUE/FALSE/MAYBE — укажи что уточнить".

🔧 Техника: упростить для быстрых проверок

Полный JSON избыточен для простых вопросов. Минимальная версия:

Для каждого варианта ответа:
1. Кандидат: [название]
2. ЗА: [цитата-доказательство]
3. ПРОТИВ: [цитата-опровержение]
4. Вердикт: ДА/НЕТ + почему

Финал: [только ДА-кандидаты]

Та же логика, меньше формализма — для чатов без анализа документов.


🔗

Ресурсы

Evaluation of retrieval-based QA on QUEST-LOFT (2025)

Nathan Scales, Nathanael Schärli, Olivier Bousquet — Google DeepMind

Связанные работы:

  • LOFT benchmark: Lee et al., 2024 — оригинальный бенчмарк длинного контекста
  • Chain-of-Verification (CoVe): Dhuliawala et al., 2023 — верификация через дополнительные вопросы
  • QUEST dataset: Malaviya et al., 2023 — датасет сложных вопросов с множественными ответами

Библиотека: OneTwo — фреймворк для работы с LLM от DeepMind


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

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

Обнаружено: LLM принимают решения «в голове» без явной проверки каждого факта. При сложных вопросах (много критериев, десятки документов) модель пропускает правильные ответы или включает неверные — рассуждения остаются невидимыми. Метод Justified QA позволяет получать ответы с полным аудит-трейлом: для каждого кандидата видны доказательства «за», доказательства «против», логика рассуждений и финальный вердикт TRUE/FALSE. JSON-структура создаёт принудительную декомпозицию: модель не может перейти к вердикту, пока не заполнит evidence_for/against и reasoning. +0.14 F1 на RAG-задачах — это работает через вынос рассуждений наружу.

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

Трёхшаговая декомпозиция в одном промпте. Сначала модель собирает полный список кандидатов (приоритет на охват всех возможных ответов). Затем для каждого — доказательства «за»/«против» из источников + рассуждение по критериям. В конце — финальный список только TRUE-вердиктов. Фишка: модель не может «перепрыгнуть» к ответу — структура заставляет проверить каждый факт явно. Без заполнения evidence и reasoning блок final_judgment не имеет смысла, модель вынуждена идти по шагам.

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

LLM отвечают «потоком сознания» — генерируют без явной проверки. При многих источниках/критериях это ведёт к пропускам и ложным включениям. Модель «не видит» свои рассуждения — они остаются неявными. JSON-схема выносит рассуждения наружу — модель «видит» свою логику и не может пропустить проверку. Работает как цепочка рассуждений (Chain-of-Thought), но с жёстким форматом. Исследователи обнаружили: для мощных моделей (Gemini Pro) структуры достаточно, для слабых (Flash) нужен доп. этап «подумай своими словами» перед JSON (+0.07 F1).

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

RAG-задачи и анализ документов → конкретно для проверки фактов по нескольким критериям, особенно когда информация размазана по десяткам источников или нужна сложная логика. НЕ подходит для: субъективных оценок (evidence менее надёжен), задач без источников (модель вернётся к галлюцинациям — evidence_for/against будет пустым).

Мини-рецепт

1. Задай JSON-структуру: поля candidate_answer, evidence_for (массив цитат с источниками), evidence_against, reasoning (рассуждение по каждому критерию), final_judgment (TRUE/FALSE)
2. Инструкция на полноту: Приоритет на ПОЛНОТУ при сборе кандидатов. Фильтруй через reasoning и final_judgment — модель сначала соберёт всех, потом отсеет
3. Для слабых моделей: добавь Сначала подумай своими словами, потом выведи JSON — дополнительный этап даёт +0.07 F1
4. Явные критерии: перечисли в инструкциях что проверять в reasoning — модель проверит каждый пункт

Примеры

[ПЛОХО] : Какие компании из списка работают с госзаказами и имеют продукт в ИИ? — модель даст прямой ответ без обоснования, можешь пропустить подходящих или включить неподходящих
[ХОРОШО] : Выведи JSON: для каждой компании - candidate_answer, evidence_for/against по критериям (госзаказы: да/нет, ИИ-продукт: да/нет), reasoning с проверкой каждого критерия, final_judgment TRUE/FALSE. В evidence включай цитаты с doc_id — модель явно проверит каждый критерий, ты увидишь все доказательства и логику, можно верифицировать любой вердикт
Источник: Evaluation of retrieval-based QA on QUEST-LOFT (2511.06125)
ArXiv ID: 2511.06125 | Сгенерировано: 2026-01-11 20:13

Проблемы LLM

ПроблемаСутьКак обойти
Модель "решает в голове" — рассуждения остаются неявнымиДаёшь модели сложный вопрос с несколькими критериями и много документов. Модель генерирует ответ "потоком сознания" — без явной проверки каждого факта. Результат: пропускает правильные варианты (теряет полноту) и включает неверные (теряет точность). Рассуждения происходят внутри модели — ты их не видишь, проверить логику невозможноЗаставь модель вынести рассуждения наружу. Используй структурированный формат (JSON): для каждого кандидата модель должна явно выписать доказательства "за", доказательства "против", рассуждение и вердикт. Структура не даст модели "перепрыгнуть" к ответу без проверки

Методы

МетодСуть
Структурированный вывод с доказательствами "за" и "против"ШАГ 1: Попроси модель собрать ВСЕ возможные кандидаты-ответы (приоритет на полноту). ШАГ 2: Для каждого кандидата модель заполняет JSON: evidence_for (цитаты-доказательства), evidence_against (цитаты-опровержения), reasoning (рассуждение по критериям), final_judgment (TRUE/FALSE). ШАГ 3: Финальный ответ — только TRUE-кандидаты. Почему работает: JSON-структура создаёт принудительную декомпозицию. Модель не может вынести вердикт пока не заполнит все поля. Рассуждения экстернализуются — выносятся из "головы" модели в текст, где их можно проверить. Когда применять: сложные вопросы с несколькими критериями, анализ документов, нужна прозрачность логики. Когда не работает: простые вопросы (избыточно), нет источников для evidence (модель вернётся к галлюцинациям)

Тезисы

ТезисКомментарий
Структурированный формат принуждает к декомпозицииКогда задаёшь JSON-схему с обязательными полями, модель не может "перепрыгнуть" через шаги. Чтобы заполнить final_judgment, модель должна сначала заполнить evidence_for, evidence_against, reasoning. Это работает как жёсткий вариант цепочки рассуждений. Механика: структура создаёт последовательность — каждое следующее поле зависит от предыдущих. Применяй: Для сложных задач используй JSON с явной последовательностью: сначала факты, потом анализ, потом вывод
📖 Простыми словами

Justified QA: структурированный вывод с доказательствами для сложных вопросов

arXiv: 2511.06125

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

Это как если бы ты нанял детектива, а он пришел и сказал: «Виноват дворецкий», не предъявив ни улик, ни алиби, ни мотива. Ты вроде и получил ответ, но верить ему на слово — полный провал, потому что ты не видишь, как он пришел к этому выводу. Метод Justified QA заставляет модель не просто тыкать пальцем в ответ, а вести полноценное следственное дело по каждому подозреваемому, выкладывая все карты на стол в жесткой структуре.

Суть метода в трех шагах: сначала модель вываливает вообще всех кандидатов на ответ, а потом для каждого пишет evidencefor (почему это подходит), evidenceagainst (почему это может быть лажей) и reasoning (финальное взвешивание фактов). Все это упаковывается в JSON-структуру, что превращает хаотичный текст в четкую таблицу. Если ты ищешь IT-компанию с выручкой от миллиарда и ИИ-продуктом, модель не просто скажет «Рога и Копыта», а честно напишет: «Выручка есть, но ИИ там и не пахнет, так что вычеркиваем».

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

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

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

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

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