ТЕХНИЧЕСКОЕ ЗАДАНИЕ: Реализовать deliberate decoding

1. Цель задачи

Реализовать механизм deliberate decoding — несколько раундов планирования перед финальной генерацией ответа. В отличие от стандартного auto-regressive decoding, модель сначала генерирует план (например, ключевые шаги, структуру ответа), затем на каждом шаге может пересматривать план перед генерацией следующего токена. Цель — улучшить качество ответов на сложные задачи (многошаговые рассуждения, генерация длинного контента).

Ключевой результат Рабочий пайплайн deliberate decoding, который для заданного набора сложных промптов выдаёт ответы с метрикой coherence ≥ 0.8 (по шкале 0-1) и демонстрирует улучшение по сравнению с обычным decoding (coherence < 0.6 для тех же промптов). В качестве метрики можно использовать GPT-оценку или человеческую оценку (на усмотрение практикующего).

2. Исходные данные

Если нет реальной LLM — симулируем:

1. Использовать небольшую модель (например, google/flan-t5-small) на CPU.
2. Для deliberate decoding имитировать «раунды планирования», заменяя повторный вызов модели на жёстко заданные шаблоны плана (например, всегда генерировать Шаг 1: ...; Шаг 2: ...).
3. Оценить корректность работы пайплайна на синтетических промптах.

3. Технологический стек

4. Этапы выполнения

Этап 1: Подготовка окружения и базовая генерация (30-60 минут)

Действия

1. Установить зависимости:

   pip install torch transformers datasets accelerate
   

2. Загрузить модель и токенизатор:

   from transformers import AutoModelForCausalLM, AutoTokenizer
   model_name = "mistralai/Mistral-7B-Instruct-v0.2"  # или меньше
   tokenizer = AutoTokenizer.from_pretrained(model_name)
   model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto")
   

3. Реализовать базовую функцию генерации без планирования:

   def generate_basic(prompt: str, max_new_tokens=200) -> str:
       inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
       outputs = model.generate(**inputs, max_new_tokens=max_new_tokens)
       return tokenizer.decode(outputs[0], skip_special_tokens=True)
   

4. Протестировать на 2-3 простых промптах (например, «Расскажи о квантовой запутанности»).
5. Ожидаемый результат этапа Функция generate_basic работает, модель генерирует ответы. Понимание структуры вывода.

Этап 2: Разработка механизма планирования (2-3 часа)

Действия

1. Определить формат плана. Например:
   • План — это последовательность шагов в виде:

     [PLAN]
     step_1: <описание>
     step_2: <описание>
     ...
     [GENERATE]
     

2. Реализовать функцию generate_plan(prompt) -> list[str]:
   • Вызвать модель с инструкцией «Сначала составь план ответа, перечисли шаги.»
   • Извлечь из сгенерированного текста шаги (парсинг).
3. Реализовать функцию generate_with_plan(prompt, plan_steps) -> str:
   • Для каждого шага плана:
     • Формировать контекст: исходный промпт + уже сгенерированные шаги + текущий шаг.
     • Вызвать модель для генерации текста для шага.
   • После всех шагов объединить результат.
4. Важно Включить возможность пересмотра плана — после генерации одного шага модель может решить изменить следующий шаг. Для этого на каждой итерации передаём модели текущий план и просим подтвердить или скорректировать.

   def refined_step_plan(context_so_far, current_plan, step_idx):
       # prompt: "Текущий ответ: {context}. План: {current_plan}. 
       #           Шаг {step_idx} уже выполнен. Если нужно изменить следующий шаги, выведи новый план."
       # модель вернёт либо "OK", либо новый план.
   

5. Ожидаемый результат этапа Функция generate_deliberate(prompt) -> str выдаёт ответ, состоящий из нескольких логических частей, каждая сгенерирована отдельно.

Этап 3: Интеграция итерированного планирования (3-4 часа)

Действия

1. Реализовать цикл с N раундами планирования (N=2 или 3):
   • Раунд 1 Генерация начального плана.
   • Раунд 2 Генерация первого фрагмента ответа, затем пересмотр плана.
   • Раунд 3 Генерация второго фрагмента и т.д.
2. Добавить ограничение на максимальное количество токенов на шаг (например, 100 токенов) и на общий план (200 токенов).
3. Реализовать механизм early stopping: если модель на шаге пересмотра плана выдаёт <END>, то завершить генерацию.
4. Обернуть всё в единый класс:

   class DeliberateDecoder:
       def __init__(self, model, tokenizer, num_rounds=3, max_plan_tokens=200, step_max_tokens=100):
           ...
       def decode(self, prompt: str) -> str:
           ...
   

5. Ожидаемый результат этапа Класс DeliberateDecoder готов, можно задавать количество раундов и параметры. Модель генерирует ответ пошагово с пересмотром плана.

Этап 4: Сбор сложных промптов и бенчмарк (1-2 часа)

Действия

1. Составить 10-15 сложных промптов, требующих многошагового рассуждения:
   • «Реши задачу: Если поезд едет со скоростью 80 км/ч, а машина со скоростью 120 км/ч, то через сколько времени они встретятся, если расстояние между ними 500 км?»
   • «Напиши эссе на тему "Плюсы и минусы удалённой работы" с аргументами и примерами.»
   • «Объясни процесс фотосинтеза шаг за шагом, включая химические реакции.»
2. Для каждого промпта запустить:
   • generate_basic (baseline)
   • generate_deliberate с num_rounds=2 и num_rounds=3
3. Сохранить все ответы в JSON:

   {
       "prompt": "...",
       "baseline": "...",
       "deliberate_r2": "...",
       "deliberate_r3": "..."
   }
   

4. Ожидаемый результат этапа Набор ответов для анализа.

Этап 5: Оценка и сравнение (1-2 часа)

Действия

1. Выбрать метрику. Простой вариант — GPT-оценка coherence:
   • Использовать промпт: «Оцени связность и структурированность следующего ответа по шкале от 0 до 1».
   • GPT-4 или локальная модель для оценки (например, mistral-7b).
   • Усреднить по всем промптам. (Или ручная оценка по 3 экспертам.)
2. Построить таблицу сравнения:

   Метод	Средняя coherence	Максимальная	Минимальная
   baseline	X	Y	Z
   deliberate (R2)	...	...	...
   deliberate (R3)	...	...	...

3. Дополнительно: оценить время генерации (latency) и количество токенов.
4. Ожидаемый результат этапа Численные метрики, показывающие улучшение deliberate decoding над baseline. Сделать выводы.

5. Критерии приемки (Definition of Done)

• Реализован класс DeliberateDecoder с параметрами num_rounds, max_plan_tokens, step_max_tokens.
• Механизм пересмотра плана работает: на каждом раунде модель может изменить последующие шаги.
• Для 10 сложных промптов получены ответы от baseline и deliberate (минимум 2 раунда).
• Средняя coherence deliberate ≥ 0.8, baseline ≤ 0.6 (или другое значимое улучшение).
• Код выложен в репозиторий с инструкцией по запуску (README).
• Написаны unit-тесты для ключевых функций (генерация плана, парсинг шагов, цикл итераций).
• Проведён анализ latency — deliberate decoding не превышает 2x времени baseline.
• Задокументированы примеры работы (3-4 примера с пошаговым выводом).

6. Ожидаемый результат

Файл/артефакт:

• Репозиторий с кодом: deliberate_decoder.py, evaluate.py, prompts.json, results.json.
• Документ REPORT.md, содержащий:
  • Описание подхода.
  • Таблица с метриками.
  • 3 примера ответов (baseline vs deliberate).
  • Графики (опционально).

Дополнительно:

• Код может быть использован как модуль для интеграции в существующие пайплайны.
• Метрики и анализ могут быть представлены в виде презентации.

7. Возможные сложности и их решение

8. Бюджет времени (оценка)

Примечание Время может варьироваться в зависимости от опыта и производительности GPU. Для первого раза рекомендуется закладывать 2 рабочих дня.

9. Связанные вопросы из базы знаний

10. Чек-лист самопроверки

• Я установил все зависимости и запустил базовую генерацию.
• Я реализовал парсинг плана из вывода модели (регулярки или другой способ).
• Я проверил, что на каждом раунде модель может изменить план (если нужно).
• Я сравнил deliberate и baseline на 10 промптах и получил численные метрики.
• Я написал хотя бы минимальные unit-тесты для функций generate_plan и refined_step_plan.