«Большие языковые модели», главы 7–9: инструктивное дообучение, выравнивание, декодирование и сжатие

О конспекте

Пересказ своими словами глав 7–9 книги «Большие языковые модели» по электронной версии PDF; у книги нет открытой лицензии, поэтому таблицы и код книги не воспроизводятся, отдельные числа из экспериментов авторов приведены в тексте со ссылкой на книгу. Формулы общеизвестны, код на странице — наш. Общий обзор книги — в путеводителе.

Коротко

• Глава 7 — SFT. Откуда брать инструкции (NLP-наборы, реальные диалоги, синтетика), как их улучшать (сложность, разнообразие, отбор), как смешивать и учить. Самое ценное — собственные эксперименты авторов на LLaMA-2 и расчёт памяти для LoRA: 108 ГБ против 14 ГБ для модели 7B.
• Глава 8 — выравнивание. Критерии 3H, RLHF по шагам (данные, модель награды, PPO с выводом из policy gradient), опыт InstructGPT и LLaMA-2, RLAIF, DPO и другие методы без RL, и честное сравнение SFT и RLHF.
• Глава 9 — использование. Стратегии декодирования и их типичные настройки; количественный анализ, почему генерация токенов упирается в пропускную способность памяти («стена памяти»); системные и алгоритмические ускорения; квантование с практическими выводами; дистилляция и прунинг.

Как читать вместе с курсом

Раздел книги	Урок курса	Что даёт книга сверх урока
§7.1–7.2 данные и обучение SFT	6.1.2 SFT	обзор способов собрать инструкции, пропорции FLAN v2, эксперименты на LLaMA-2
§7.3 LoRA и PEFT	6.2.1 LoRA, 6.2.2 Практика	формула памяти $2P + 16P_{\text{LoRA}}$, время дообучения 7B–65B
§8.2 RLHF и PPO	6.3.2 RLHF и PPO, 6.0.3 Actor-critic и PPO	три способа учить модель награды, приёмы LLaMA-2
§8.3 DPO и др.	6.3.3 DPO	обзор «выравнивания без RL» до DPO
§9.1 декодирование	4.1.3 Сэмплирование	штрафы за повтор, контрастное декодирование, настройки известных моделей
§9.2 эффективность	7.1.1 Префилл и декодирование, 7.1.2 Сервинг	таблицы арифметической интенсивности для каждой операции
§9.3–9.4 сжатие	7.2.1 Квантование, 7.2.2 Локальные LLM	собственные замеры авторов: качество и память FP16/INT8/INT4

Глава 7. Инструктивное дообучение

Откуда берутся инструкции

1. Из готовых NLP-наборов. К паре «вход–выход» дописывают описание задачи («переведи это предложение на английский»). Без описания качество заметно падает — именно описание учит следовать инструкциям. Трюк: «перевернуть» пример (по ответу сгенерировать вопрос) и получить новую задачу. Итог этой линии — FLAN v2, около 20 млн примеров.
2. Из реальных диалогов. InstructGPT брала настоящие запросы к API OpenAI и дописывала ответы силами разметчиков (данные не открыты); открытые аналоги — Dolly, OpenAssistant, многоходовые диалоги ShareGPT.
3. Синтетика. Self-Instruct: 175 написанных людьми примеров → модель по образцам придумывает новые задачи и ответы → фильтр отсекает похожие, слишком короткие/длинные и неразрешимые. Так получены Self-Instruct-52K и Alpaca-52K. Evol-Instruct (WizardLM) «выращивает» сложность: углубление пятью способами (добавить ограничение, углубить, конкретизировать, добавить шаги рассуждения, усложнить вход) и расширение — новая задача той же области, но реже встречающаяся. Ещё есть обратный перевод инструкций: взять хороший человеческий текст как ответ и сгенерировать к нему вопрос.

Как сделать инструкции лучше

• Формат. Смесь примеров с демонстрациями и без них, с цепочками рассуждений и без улучшает и zero-shot, и few-shot. Но «больше текста в инструкции» не всегда лучше: советы и оговорки могут даже навредить.
• Количество. На FLAN-T5 рост числа инструкций 0,18M → 5,55M → 7,2M → 17,26M давал прирост, который после 7,2M почти остановился. Для диалога хватает гораздо меньшего: Alpaca — 52K синтетических примеров, LIMA — всего 1000 отборных для LLaMA-65B; но малым набором трудно покрыть и диалог, и классические NLP-задачи (Orca решала это 5M ответами GPT-4 и ChatGPT с пошаговыми объяснениями).
• Переписывание и отбор. YuLan-Chat-3 переписывала инструкции под 293 темы, собранные с Чжиху («перепиши для темы „образование“»); AlpaGasus оставила 9K из 52K примеров Alpaca с лучшей оценкой GPT-4 и не потеряла в качестве; YuLan-Chat-3 ещё и выкидывала слишком лёгкие и слишком трудные примеры по перплексии модели.
• Главный вывод авторов: качество важнее количества; человеческие разнообразные данные — лучше всего; синтетикой от сильных моделей количество компенсирует недостаток качества.

Что даёт SFT. Выигрывают модели от 77M до 540B параметров, и дообученная маленькая может обойти недообученную большую; стоимость — порядка одной десятитысячной от предобучения. SFT на чисто английских задачах (P3) улучшила многоязычную BLOOM в задаче дополнения предложений больше чем на 50% (BLOOMZ-P3). Для областей — Med-PaLM, китайская медицинская модель BenTsao поверх LLaMA.

Как учить

• Потерю считают только по ответу, не по инструкции.
• Батч и скорость обучения малы: InstructGPT (175B) — батч 8 и постоянная скорость около $5\cdot10^{-6}$; Alpaca (7B) — батч 128, разогрев до $2\cdot10^{-5}$ и косинус.
• Многоходовый диалог подают целиком одной последовательностью и маскируют потерю на репликах пользователя — вместо того чтобы резать диалог на много примеров с повторяющимися префиксами.
• Смешивание наборов: брать вперемешку NLP-задачи, диалоги и синтетику; ограничивать вклад огромных наборов «потолком». В FLAN v2 смесь — 46% FLAN, 27,9% T0, 24,2% NIV2, 1,8% CoT, а потолки — 30 000, 20 000, 5 000 и 100 000 примеров на задачу соответственно.
• Многоэтапность и регуляризация. YuLan-Chat-3: сначала массовые NLP-инструкции, потом диалоги и синтетика (с подмесью NLP против забывания). OPT-IML подмешивала 5% данных предобучения в SFT, GLM-130B — наоборот, 5% инструкций в предобучение, а MiniCPM вставляет между этапами «отжиг» на смеси качественного предобучающего текста и инструкций.

Эксперименты авторов (§7.4.2)

Авторы дообучили LLaMA-2 7B и 13B на пяти наборах примерно одного размера (по 50–70K примеров: выборка FLAN v2, ShareGPT, Alpaca, Alpaca после Evol-Instruct, Alpaca после переписывания под темы; батч 128, постоянная скорость $10^{-5}$, 3 эпохи, сервер 8×A800). Оценка — доля побед над text-davinci-003 на вопросах AlpacaFarm (судья ChatGPT) и точность на MMLU и BBH. Выводы:

• Формат данных должен совпадать с задачей. FLAN v2 лучше всех на MMLU и BBH, но в диалоге проваливается: у 7B доля побед 12,4% против 55,5% у ShareGPT.
• Сложность и разнообразие помогают. Переписывание Alpaca под темы подняло диалоговую метрику 13B с 48,5 до 58,2 — почти до уровня ShareGPT.
• Больше модель — лучше следование инструкциям: 13B впереди 7B во всех вариантах; на ShareGPT MMLU растёт с 49,7 до 56,8.

LoRA и память (§7.3)

$W = W_0 + \Delta W$, где $\Delta W = AB^\top$, $A, B \in \mathbb R^{H\times R}$, $R \ll H$; $W_0$ заморожена, после обучения $AB^\top$ вливают обратно, и при выводе накладных расходов нет.

Подсчёт памяти книги (без ZeRO, только веса и оптимизатор): замороженные веса FP16 — $2P$ байт; у обучаемых $P_{\text{LoRA}}$ параметров те же 16 байт на параметр, что при полном обучении. Итого

$$M_{\text{LoRA}} \approx 2P + 16\,P_{\text{LoRA}}, \qquad P_{\text{LoRA}} = 4\cdot 2\cdot L\cdot H\cdot R$$

(LoRA на четырёх матрицах внимания). Для LLaMA-7B и $R=8$: $P_{\text{LoRA}} = 8\,388\,608$, память ≈ 13,6 млрд байт («14 ГБ») против $16P \approx 108$ ГБ при полном обучении. QLoRA хранит замороженные веса в 4 битах — $\approx 0{,}5P$, что позволяет дообучать 65B на одной карте 48 ГБ.

Замер авторов (LoRA $R=16$, длина 512, 3 эпохи Alpaca, A800 80G): 7B — одна карта, 2,3 ч; 13B — одна карта, 3,8 ч; 30B — одна карта, 10,2 ч; 65B — две карты, 26 ч. Для полного дообучения тех же моделей им понадобилось 2, 4, 8 и 16 карт. Обратная сторона: у 30B и 65B память почти целиком занята весами, батч падает до 1, и обучение сильно замедляется.

Деталь в коде LoRA из книги

В учебной реализации LoRALinear комментарий говорит о «масштабированном» выходе LoRA, но множителя в коде нет. В библиотеке PEFT выход умножается на $\alpha/R$ (lora_alpha / r). В конфигурации авторов lora_alpha = r = 16, так что множитель равен 1 и результаты не страдают, но при смене $R$ без масштабирования поменяется эффективная скорость обучения.

Другие методы PEFT — адаптеры (узкое «горлышко» внутри блока), prefix tuning и prompt tuning — книга описывает для полноты и отмечает, что для больших моделей их используют заметно реже LoRA. Из вариантов LoRA упомянута AdaLoRA (ранг распределяется по матрицам по их важности).

Глава 8. Выравнивание

Критерии и RLHF в целом

Три критерия 3H: полезность (helpful), честность (honest — в том числе выражать неуверенность), безвредность (harmless). Их трудно формализовать, отсюда идея учиться на человеческих предпочтениях. Конвейер RLHF: SFT → сбор сравнений → модель награды → RL (обычно PPO) с KL-штрафом за уход от исходной модели. Важная практика — отбор разметчиков: InstructGPT проверяла согласие кандидатов с разметкой самих исследователей (в проекте работали 40 разметчиков), Sparrow брала носителей британского английского с высшим образованием.

Модель награды (§8.2.3)

Языковая модель с линейной «головой», выдающей скаляр. Три способа обучения:

1. Оценка по шкале — регрессия на человеческие баллы; страдает от разных строгостей разметчиков.
2. Попарное сравнение — $\mathcal L = -\mathbb E\,\log\sigma\big(r_\theta(x,y^+) - r_\theta(x,y^-)\big)$; сравнивать проще и согласованнее, чем ставить баллы.
3. Ранжирование $K$ ответов — та же потеря по всем парам.

Приёмы: добавлять к попарной потере обычную LM-потерю на лучшем ответе (против переобучения); модель награды не меньше обучаемой (InstructGPT обходилась RM на 6B, LLaMA-2 инициализировала RM из того же чекпоинта, чтобы у них были одинаковые знания); при нескольких критериях — несколько моделей награды и взвешенная сумма $r = \sum_i \lambda_i r_i$ (например, строже к вредности, мягче к полезности). В книге есть и код модели награды поверх LlamaForCausalLM.

Знак в формуле (8.1)

Потеря для оценки по шкале записана в PDF как $\mathcal L = -\mathbb E\big[(r_\theta(x,y) - \tilde r)^2\big]$. С минусом её минимизация увеличивала бы ошибку; правильно — без минуса (обычная MSE). И мелочь в (8.3): у InstructGPT потеря ранжирования нормируется на число пар $\binom K2$, а не на $K^2$ — на результат это влияет лишь как множитель.

PPO (§8.2.4)

Книга выводит PPO по шагам: цель $J(\theta) = \mathbb E_{\tau\sim P_\theta}R(\tau)$ → policy gradient $\nabla J \approx \frac1N\sum_\tau R(\tau)\nabla\log P_\theta(\tau)$ → преимущество $\hat A_t = Q(s_t,a_t) - V(s_t)$ вместо сырой награды (иначе, как в примере книги, случайно выпавшее плохое действие с положительной наградой усиливается) → importance sampling с отношением $r_t(\theta) = \pi_\theta(a_t|s_t)/\pi_{\theta_{\text{old}}}(a_t|s_t)$, чтобы несколько раз учиться на одной выборке → обрезка $\min\big(r_t\hat A_t,\ \mathrm{clip}(r_t, 1-\epsilon, 1+\epsilon)\hat A_t\big)$ или KL-штраф с адаптивным $\beta$. Всего в работе четыре модели: политика, референс, критик (оценивает $V$, инициализируется из модели награды) и модель награды.

Практика из книги: перед RL полезна выборка с отклонением (best-of-$N$ по модели награды и SFT на лучших ответах); LLaMA-2 прошла пять итераций RLHF — в первых четырёх только rejection sampling, затем PPO, — и каждый раз заново собирала предпочтения под текущую модель. LLaMA-2 учила две модели награды (полезность и безопасность), использовала около 1,5M открытых пар предпочтений из семи наборов и добавляла в попарную потерю зазор $m(y^+, y^-)$ по степени предпочтения. Инженерный совет: держать обучаемые политику и критика на одном сервере, а замороженные модель награды и референс — на другом, обмениваясь по сети.

Про «off-policy»

Книга называет PPO обучением «вне политики» (off-policy), потому что данные собирает $\pi_{\theta_{\text{old}}}$, а учится $\pi_\theta$. В большинстве учебников по RL PPO относят к on-policy методам: выборка свежая, от только что обновлённой политики, а importance sampling лишь позволяет сделать на ней несколько шагов. Важно понимать механизм, а не ярлык. Также в описании алгоритма есть фраза, будто новая политика «принимается, только если стала лучше старой», — такой проверки в стандартном PPO нет.

Без RL (§8.3)

• RLAIF: предпочтения ставит модель (Constitutional AI); по приведённым в книге результатам RLAIF сопоставим с RLHF, а в части задач лучше. Вариант Meta и NYU — модель сама оценивает свои ответы и учится на собственных парах через DPO; LLaMA-2 70B после таких итераций обошла на AlpacaEval 2.0 Claude 2, Gemini Pro и GPT-4 0613.
• DPO: из KL-регуляризованной RL-задачи выражается оптимальная политика, и награда «сокращается»:

$$\mathcal L_{\text{DPO}} = -\mathbb E\,\log\sigma\!\left(\beta\log\frac{\pi_\theta(y^+|x)}{\pi_{\text{ref}}(y^+|x)} - \beta\log\frac{\pi_\theta(y^-|x)}{\pi_{\text{ref}}(y^-|x)}\right).$$

• Другие «надзорные» методы — обычная SFT-потеря на хорошем ответе плюс вспомогательная: метки качества в префиксе («хороший ответ:», «ответ на 5 баллов:»), ранжирующие потери между хорошими и плохими ответами, контраст с ответами на другие вопросы (чтобы модель не отвечала всем одинаково).

SFT или RLHF (§8.4)

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

Глава 9. Декодирование и развёртывание

Стратегии декодирования (§9.1)

• Жадный поиск и лучевой (обычно 3–6 лучей) с нормировкой на длину (делим логарифм вероятности на длину в степени $\alpha \approx 0{,}6$–$0{,}7$, иначе выигрывают короткие ответы).
• Против повторов: запрет повторять $n$-граммы ($n = 3$–$5$), «мягкие» штрафы за присутствие и частоту (вычесть $\alpha$ или $\alpha\cdot$число повторов из логита; $\alpha \approx 0{,}1$–$1$).
• Сэмплирование: температура, top-$k$, top-$p$ и контрастное декодирование — брать разность логарифмов вероятностей большой и маленькой модели, чтобы поднять «содержательные» токены, которые большая модель знает, а маленькая — нет.
• Настройки в известных работах: T5 и GPT-3 — 4 луча и штраф длины 0,6; Alpaca — top-$k$ 50, top-$p$ 0,9, температура 0,7; LLaMA на коде — температура 0,1 для pass@1 и 0,8 для pass@100.

Почему генерация медленная (§9.2.1)

Генерация делится на префилл (весь промпт за один проход, заполняем KV-кэш) и пошаговое декодирование (один новый токен, чтение всего кэша). Инструмент анализа — арифметическая интенсивность $I$ = FLOPs / прочитанные байты. Если $I$ меньше предела видеокарты $I_{\max}$ = пиковые FLOPs / пропускная способность памяти, мы упираемся в память.

Числа книги для LLaMA-7B ($H = 4096$, $D = 128$) при $B = 8$, $T = 1024$: в префилле интенсивность линейных слоёв $\approx 2731$, внимания $\approx 115$ — это упор в вычисления; при пошаговом декодировании у линейных слоёв $I \le 8$ — в десятки раз ниже предела A100. Это и есть «стена памяти»: каждый новый токен требует прочитать все веса.

def intensity_linear(H, tokens):          # линейный слой: 1 / (1/H + 1/(B*T))
    return 1 / (1 / H + 1 / tokens)

def intensity_attn(D, T):                 # внимание при префилле
    return (1 + 1 / D) / (1 / D + 1 / T)

H, D, B, T = 4096, 128, 8, 1024           # LLaMA-7B, пример книги
print("префилл: линейные", round(intensity_linear(H, B * T), 2),
      "| внимание", round(intensity_attn(D, T), 2))   # 2730.67 | 114.67
print("декодирование: линейные", round(intensity_linear(H, B), 2))   # 7.98
print("предел A100 ≈", round(312e12 / 2039e9))                     # 153

P = 6.74e9                                 # параметров LLaMA-7B
for name, bw in [("A100", 2039e9), ("RTX 4090", 1008e9)]:
    for bits in (16, 8, 4):                # каждый токен = прочитать все веса
        print(f"{name}, {bits} бит: не быстрее {bw / (P * bits / 8):.0f} ток/с при B=1")
# A100: 151 / 303 / 605 ток/с;  RTX 4090: 75 / 150 / 299 ток/с

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

Откуда 142,5

Книга называет предел интенсивности A100 «≈142,51 FLOP/байт». $312\cdot10^{12} / (2039\cdot10^{9}) \approx 153$; число 142,5 получается, если гигабайты в пропускной способности считать как $2^{30}$ байт. На вывод это не влияет.

Как ускоряют (§9.2.2–9.2.3)

• Системно: FlashAttention — блочное вычисление внимания без записи промежуточных матриц в видеопамять (в примере книги внимание LLaMA-2 7B при длине 2048 и батче 8 в десять раз быстрее); PagedAttention — KV-кэш страницами, как виртуальная память в ОС, без копирования при росте и без фрагментации; непрерывный батчинг (vLLM) — новые запросы подсаживаются в батч по мере освобождения мест, а не ждут самого длинного ответа.
• Алгоритмически: спекулятивное декодирование — маленькая модель черновиком пишет несколько токенов, большая проверяет их за один проход (качество не меняется, ускорение около 2×); каскад (FrugalGPT) — сначала дешёвая модель, к дорогой — только если классификатор не доверяет ответу; полу-авторегрессия (Medusa: две дополнительные головы предсказывают 2-й и 3-й токены, а исходная модель проверяет); ранний выход из слоёв, когда распределение уже уверенное (низкая энтропия).

Пример спекулятивного декодирования в книге построен на первой фразе эссе Чжу Цзыцина «Вид со спины» (1925) — хрестоматийного текста, который знает каждый китайский школьник: «Мы с отцом не виделись больше двух лет, и больше всего я не могу забыть его спину» (перевод наш; в книге — китайский оригинал). Восемь слов продолжения большая модель получает за три проверки вместо восьми шагов.

Квантование (§9.3)

$x_q = R(x/S) - Z$, обратно $\tilde x = S\,(x_q + Z)$; симметричное ($Z = 0$) и несимметричное, по тензору, каналу или группе; квантование после обучения (PTQ) и с обучением (QAT). Для LLM книга разбирает LLM.int8() (выбросы в активациях считаются отдельно в FP16), SmoothQuant (трудность переносится с активаций на веса), GPTQ (послойная оптимизация с учётом второго порядка) и AWQ (масштабирование весов, важных для активаций). Практические выводы:

1. INT8 по весам почти бесплатен; 4 бита требуют хорошего метода. При равном объёме памяти лучше большая модель в 4 битах, чем вдвое меньшая в 8 битах — 60 ГБ модели в 4 битах обычно сильнее 30 ГБ модели того же семейства в 8 битах.
2. Активации квантовать труднее весов: начиная с некоторого размера модели в них появляются большие выбросы.
3. Потерю можно отыграть LoRA: 65B в 2 битах после дообучения адаптеров приближается к 13B в FP16.

Замер авторов на своих SFT-моделях: LLaMA-7B занимает 12,6 ГБ в FP16, 6,7 ГБ в INT8 и 3,9 ГБ в INT4, а точность на MMLU и BBH меняется в пределах одного-двух пунктов. Рекомендация книги: при нехватке памяти начинать с 4-битной модели.

Дистилляция и прунинг (§9.4)

Дистилляция — по ответам (логитам) учителя или по промежуточным признакам; «белый ящик» (доступ к внутренностям учителя) и «чёрный ящик» (только тексты учителя через API — так многие открытые модели учатся на ответах сильных закрытых). Прунинг — неструктурированный (обнуляем отдельные веса; SparseGPT) и структурированный (выкидываем головы, каналы, слои; Sheared LLaMA). Добавим от себя: неструктурированная разреженность лучше сохраняет качество, но без специальной поддержки в железе и ядрах почти не ускоряет вывод.

Что сделать руками

1. Маска потерь для диалога. Возьмите шаблон чата своей модели из урока 6.1.2 и напишите функцию, которая по многоходовому диалогу строит labels с -100 на всех токенах пользователя и системы. Проверьте, что число токенов с потерей равно суммарной длине ответов ассистента.
2. Память LoRA. Пересчитайте формулу $2P + 16P_{\text{LoRA}}$ для Qwen3-8B с LoRA на всех линейных слоях (а не только на внимании) (как в нашем переводе рецепта LoRA, где target_modules включает и MLP) и сравните с реальным расходом видеопамяти при запуске.
3. Знак и масштаб. Обучите модель награды на 1000 пар из любого открытого набора предпочтений двумя потерями: попарной и MSE по меткам 1/0. Какая лучше ранжирует отложенные пары?
4. Потолок скорости. Измерьте токены в секунду при батче 1 для 7B-модели в FP16 и 4 битах (например, в llama.cpp из урока 7.2.2) и сравните с нашей прикидкой «пропускная способность / размер весов». Какую долю от потолка вы получили?

Словарик

English	Русский
instruction tuning / supervised fine-tuning, SFT	инструктивное / контролируемое дообучение (SFT)
synthetic data	синтетические данные
parameter-efficient fine-tuning, PEFT	параметрически эффективное дообучение (PEFT)
low-rank adaptation, LoRA	низкоранговая адаптация (LoRA)
helpfulness / honesty / harmlessness	полезность / честность / безвредность
reward model	модель награды
policy / reference / critic model	политика / референс / критик
advantage function	функция преимущества
importance sampling	выборка по значимости
rejection sampling	выборка с отклонением
alignment tax	«налог на выравнивание»
beam search	лучевой поиск
nucleus (top-p) sampling	ядерное (top-p) сэмплирование
key-value cache, KV cache	KV-кэш
full / incremental decoding	префилл / пошаговое декодирование
arithmetic intensity	арифметическая интенсивность
memory wall	«стена памяти»
speculative decoding	спекулятивное декодирование
quantization / dequantization	квантование / деквантование
distillation / pruning	дистилляция / прунинг