Энтропия, KL-дивергенция, perplexity

Зачем это нужно

В уроке 1.3.2 вы узнали, что LLM учат минимизировать перекрёстная энтропияперекрёстная энтропияEN cross-entropy. Но что именно она измеряет и почему её минимум не равен нулю? Ответ даёт теория информации Клода Шеннона (1948). Это четыре числа, которые вы будете встречать в каждой статье о языковых моделях:

• энтропия — насколько неопределённо распределение;
• cross-entropy — сколько «стоит» описать данные с помощью модели;
• KL-дивергенция — насколько одно распределение отличается от другого;
• perplexity — та же энтропия, пересчитанная в «число вариантов».

KL-дивергенция особенно важна для второй половины курса. В обучение с подкреплением на основе отзывов людейобучение с подкреплением на основе отзывов людей (RLHF)EN reinforcement learning from human feedback (RLHF) (дообучении модели по оценкам людей) и GRPO (алгоритме обучения с подкреплением от DeepSeek, его вы видели в «Китайском угле» урока 1.3.1) она держит обучаемую модель рядом с исходной. В дистилляциидистилляцияEN (knowledge) distillation — обучении маленькой модели копировать большую — она измеряет, насколько ученик похож на учителя. А в DeepSeek-V3.2 с её помощью учат одну из деталей механизма внимания. Все эти темы ждут вас на ступенях 5–6; сейчас важно понять саму KL. В конце урока разберём температуру — ручку, которой регулируют энтропию при генерации.

Как проходить этот урок

Обязательное ядро — энтропия, равенство $H(p, q) = H(p) + \mathrm{KL}(p \Vert q)$, свойства KL (и чем прямая KL отличается от обратной), perplexity, температура и ловушка F.kl_div: на них построены задание и квиз. Таблица «Где это встретится в курсе», раздел «KL по сэмплам» и «Китайский угол» — анонс ступеней 5–6. Прочитайте их для общей картины и не застревайте: каждая из этих тем вернётся со своим уроком.

Информация: сколько «удивления» в событии

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

$$I(x) = -\log_2 p(x)$$

Это собственная информациясобственная информация («удивление»)EN self-information (surprisal)I(x) = −log p(x). Чем менее вероятно событие, тем больше информации оно несёт. В битах при log₂, в натах при ln.. Читаем: «чем меньше вероятность, тем больше информации». Единица измерения при логарифме по основанию 2 — бит:

• честная монета, $p = 1/2$: $I = -\log_2 \frac{1}{2} = 1$ бит — один ответ «да/нет»;
• один из 8 равновероятных вариантов: $\log_2 8 = 3$ бита — три вопроса «да/нет» (урок 1.0.2);
• верный токен, которому свежая модель Qwen дала вероятность $1/151\,936$: $\log_2 151\,936 \approx 17.2$ бита;
• событие с $p = 1$: ноль бит, никакого удивления.

Почему именно логарифм? Для независимых событий вероятности перемножаются, а информация должна складываться: два броска монеты — это 2 бита. Логарифм превращает произведение в сумму (урок 1.0.2).

Биты и наты

С натуральным логарифмом единица называется нат. 1 нат $= 1 / \ln 2 \approx 1.443$ бита. PyTorch и почти все статьи про обучение LLM считают loss в натах (через ln), а теория информации и сжатие данных — в битах. Формулы одни и те же, отличается только основание логарифма.

Энтропия: среднее удивление

энтропияэнтропия (информационная)EN (Shannon) entropyH(p) = −Σ p log p — среднее «удивление», мера неопределённости распределения. Максимальна у равномерного распределения. распределения — это матожидание информации (урок 1.3.1), то есть «сколько удивления в среднем»:

$$H(p) = \mathbb{E}_{x \sim p}\big[-\log p(x)\big] = -\sum_i p_i \log p_i$$

Читаем: «удивление каждого исхода $-\log p_i$ умножаем на его вероятность и складываем» — то же взвешенное среднее, что матожидание в уроке 1.3.1. Слагаемые с $p_i = 0$ пропускают: по соглашению $0 \cdot \log 0 = 0$. Невозможное событие никогда не случается и средней неопределённости не добавляет.

Посчитаем руками энтропию нечестной монеты $[0.9, 0.1]$ (орёл с вероятностью 0.9, решка — 0.1) в битах. Удивление орла $-\log_2 0.9 \approx 0.152$ бита, решки $-\log_2 0.1 \approx 3.32$ бита. Взвешиваем вероятностями: $0.9 \cdot 0.152 + 0.1 \cdot 3.32 \approx 0.137 + 0.332 = 0.47$ бита. Редкая решка очень удивительна, но случается редко, поэтому в среднем удивления меньше, чем у честной монеты (1 бит).

Распределение	Энтропия, бит	Смысл
честная монета $[0.5, 0.5]$	1.00	полная неопределённость между двумя вариантами
нечестная монета $[0.9, 0.1]$	0.47	почти всегда угадываем
$[0.99, 0.01]$	0.08	почти уверены
уверенное $[1, 0]$	0	неопределённости нет
8 равновероятных исходов	3.00	$\log_2 8$
«Карп прыгает через…»: $[0.71, 0.12, 0.08, 0.05, 0.04]$	1.41	модель неплохо, но не полностью уверена

Два крайних случая стоит запомнить. Энтропия минимальна (ноль) у one-hot распределения и максимальна у равномерного: для $K$ исходов $H = \log K$. Для словаря Qwen это $\log_2 151\,936 \approx 17.2$ бита или $\ln 151\,936 \approx 11.93$ ната — ровно тот начальный loss свежей модели, который вы считали в уроке 1.3.2.

Энтропия — это длина кода

У энтропии есть очень конкретный смысл. Пусть надо передавать по каналу исходы A, B, C, D с вероятностями $\frac{1}{2}, \frac{1}{4}, \frac{1}{8}, \frac{1}{8}$. Код фиксированной длины тратит 2 бита на символ. Умнее дать частым символам короткие коды: A → 0, B → 10, C → 110, D → 111. Средняя длина: $\frac{1}{2} \cdot 1 + \frac{1}{4} \cdot 2 + \frac{1}{8} \cdot 3 + \frac{1}{8} \cdot 3 = 1.75$ бита. А энтропия этого распределения — тоже ровно 1.75 бита.

Это не совпадение. Теорема Шеннона: при кодировании без потерь меньше чем $H(p)$ бит на символ в среднем потратить нельзя, а приблизиться к $H(p)$ можно. Языковая модель — это, по сути, архиватор: чем точнее она предсказывает следующий токен, тем короче код текста. Поэтому в статьях качество модели иногда меряют в «битах на байт» (бит на байтбит на байт (BPB)EN bits per byte (BPB)Loss, пересчитанный на байт исходного текста; в отличие от perplexity, его можно сравнивать между моделями с разными токенизаторами., урок 4.2.3).

Cross-entropy: платим за чужой код

Пусть настоящие данные приходят из распределения $p$, а код построен под распределение модели $q$. Тогда средняя длина сообщения — это cross-entropy:

$$H(p, q) = -\sum_i p_i \log q_i$$

Если $q = p$, то $H(p, q) = H(p)$, и лучше не бывает. Любая ошибка модели удлиняет код. Разница между «ценой с чужим кодом» и «идеальной ценой» — это и есть KL-дивергенцияKL-дивергенция (дивергенция Кульбака — Лейблера)EN Kullback–Leibler divergenceKL(p ‖ q) = Σ p log(p / q) = H(p, q) − H(p) ≥ 0. Несимметрична, поэтому не настоящее расстояние.:

$$H(p, q) = H(p) + \mathrm{KL}(p \Vert q)$$

Это тождество — главное в уроке. Оно объясняет три вещи:

1. Почему loss LLM не падает до нуля. $H(p)$ — энтропия самого языка: после «Я выпил чашку…» осмысленных продолжений много («чая», «кофе», «воды»). Модель тут ни при чём, и эта часть loss неустранима (неустранимый lossнеустранимый lossEN irreducible lossЧасть loss, которую нельзя убрать никаким масштабом, — непредсказуемость самого текста (слагаемое E в формуле Chinchilla)., урок 5.1.1).
2. Что на самом деле минимизирует обучение. $H(p)$ не зависит от параметров модели. Значит, минимизируя cross-entropy, мы минимизируем $\mathrm{KL}(p_{\text{данных}} \Vert q_{\text{модели}})$ — подтягиваем распределение модели к распределению языка.
3. Связь с правдоподобием из урока 1.3.2. В отдельной позиции текста цель — one-hot с нулевой энтропией, и cross-entropy совпадает с KL и с $-\log q_t$. Но один и тот же контекст встречается в корпусе с разными продолжениями, поэтому в среднем по корпусу цель — уже распределение языка с ненулевой энтропией. Отсюда и пункт 1.

KL-дивергенция

$$\mathrm{KL}(p \Vert q) = \sum_i p_i \log \frac{p_i}{q_i} = \mathbb{E}_{x \sim p}\big[\log p(x) - \log q(x)\big]$$

Читаем: «для каждого исхода берём логарифм отношения вероятностей и усредняем с весами $p$». Запись $p \Vert q$ читается «$p$ относительно $q$». Свойства:

• $\mathrm{KL}(p \Vert q) \ge 0$, и $\mathrm{KL} = 0$ только при $p = q$ (неравенство Гиббса);
• несимметрична: $\mathrm{KL}(p \Vert q) \ne \mathrm{KL}(q \Vert p)$, поэтому это не расстояние в обычном смысле, а «дивергенция»;
• если $q_i = 0$ там, где $p_i > 0$, то $\mathrm{KL}(p \Vert q) = \infty$: модель «не верит» в то, что случается.

Пример. $p = [0.5, 0.5]$ (честная монета), $q = [0.9, 0.1]$:

$$\mathrm{KL}(p \Vert q) = 0.5 \ln \frac{0.5}{0.9} + 0.5 \ln \frac{0.5}{0.1} = -0.294 + 0.805 \approx 0.511 \text{ ната},$$

а $\mathrm{KL}(q \Vert p) = 0.9 \ln 1.8 + 0.1 \ln 0.2 \approx 0.368$. Разные числа — асимметрия налицо.

Прямая и обратная KL: кто кого покрывает

Асимметрия — не формальность. Пусть цель $p$ имеет два пика, а модель $q$ может «уместить» только один. Рассмотрим цель $p = [0.495, 0.01, 0.495]$ и двух кандидатов:

Кандидат	$\mathrm{KL}(p \Vert q)$, прямая	$\mathrm{KL}(q \Vert p)$, обратная
A — один пик: $[0.98, 0.01, 0.01]$	1.593	0.630
B — размазан: $[0.34, 0.32, 0.34]$	0.337	0.854

• Прямая KL $\mathrm{KL}(p \Vert q)$ усредняет по $p$. Она жестоко штрафует модель, если та даёт малую вероятность тому, что в данных встречается часто. Поэтому выбирает B — покрыть все пики, пусть и размыто (mode covering). Так устроено обычное обучение на текстах (cross-entropy): модель старается не пропустить ни одного варианта.
• Обратная KL $\mathrm{KL}(q \Vert p)$ (обратная KL-дивергенцияобратная KL-дивергенция (reverse KL)EN reverse KL divergenceKL(q ‖ p), где q — модель, p — цель. «Ищет моду» — модель концентрируется на одном пике цели. Прямая KL(p ‖ q) «покрывает» все пики.) усредняет по $q$. Ей всё равно, что модель пропустила второй пик, но она штрафует за вероятность там, где цель почти нулевая. Поэтому выбирает A — уверенно сесть на один пик (mode seeking).

Где это встретится в курсе. В таблице $\pi_\theta$ — обучаемая модель («политика» с параметрами $\theta$, урок 1.0.3), а $\pi_{\text{ref}}$ — её исходная копия до дообучения. Претрейн — обучение на огромном корпусе текстов, обучение с учителем на инструкцияхобучение с учителем на инструкциях (SFT)EN supervised fine-tuning (SFT) — дообучение на примерах «вопрос — хороший ответ».

Где в LLM	Какая KL	Зачем
Претрейн и SFT (cross-entropy)	прямая, $\mathrm{KL}(p_{\text{данных}} \Vert q)$	покрыть всё разнообразие текста
RLHF и GRPO (модули 6.3–6.4)	обратная, $\mathrm{KL}(\pi_\theta \Vert \pi_{\text{ref}})$ по ответам самой модели	не уходить далеко от исходной модели
Классическая дистилляция	прямая, от учителя к ученику	ученик копирует «мягкие» вероятности учителя
On-policy дистилляция (тренд 2025–2026)	обратная, по ответам ученика	ученик уверенно делает то, что одобрил бы учитель

KL по сэмплам

Последнее равенство в определении — матожидание по $p$. Значит, KL можно оценить, не перебирая все исходы: сэмплировать $x$ из $p$ и усреднить $\log p(x) - \log q(x)$. Для ответов LLM перебрать все варианты невозможно (их астрономически много), поэтому в RLHF и GRPO KL всегда оценивают именно так — по сгенерированным ответам (урок 6.3.1). У такой оценки есть подвох: отдельные слагаемые бывают отрицательными, и разброс велик. Как DeepSeek с этим справляется — в китайском углу ниже.

Perplexity: эффективное число вариантов

Энтропию в битах трудно почувствовать. Поэтому её переводят обратно в «число вариантов»:

$$\mathrm{PPL}(p) = 2^{H(p) \text{ в битах}} = e^{H(p) \text{ в натах}}$$

У равномерного распределения на $K$ исходах perplexity равна ровно $K$. Поэтому perplexity — это эффективное число равновероятных вариантов. У распределения «Карп прыгает через…» энтропия 1.41 бита, а perplexity $2^{1.41} \approx 2.66$: модель «колеблется» примерно между двумя-тремя словами, хотя формально вариантов пять.

перплексияперплексияEN perplexity языковой модели на тексте — это $e^{\text{средний loss}}$ (урок 1.3.2), то есть perplexity cross-entropy, а не энтропии. При loss 3.0 ната perplexity $\approx 20$: на каждом шаге модель в среднем выбирает будто из 20 равновероятных токенов. У свежей модели Qwen perplexity примерно равна размеру словаря, 151 936. Та же идея «эффективного числа» стоит за параметром perplexity в алгоритме t-SNE (урок 2.3.2).

Perplexity разных моделей сравнивать опасно

Perplexity считается на токен, а токены у моделей разные. Модель с крупными токенами (меньше токенов на тот же текст) получает более высокую perplexity на токен, даже если текст в целом предсказывает так же хорошо. Сравнивать perplexity можно только при одинаковом токенизаторе. Для разных — пересчитывают loss на байт текста (урок 4.2.3).

Температура

При генерации логиты $z$ делят на температуратемпература (сэмплирования)EN temperatureЛогиты делятся на T перед softmax. T < 1 — распределение острее, T > 1 — площе, T → 0 — greedy. $T$ перед softmax:

$$p_i(T) = \frac{e^{z_i / T}}{\sum_j e^{z_j / T}}$$

Разница логитов $z_i - z_j$ превращается в $(z_i - z_j)/T$. При $T < 1$ разницы растут — распределение становится острее, энтропия падает. При $T > 1$ разницы сжимаются — распределение площе, энтропия растёт. Порядок токенов (какой вероятнее) не меняется никогда.

import torch

logits = torch.tensor([3.2, 1.6, 1.1, 0.3, -0.4, -1.5])   # 6 токенов
for T in [0.5, 1.0, 2.0]:
    p = torch.softmax(logits / T, dim=-1)                  # делим логиты на температуру
    H = -(p * p.log2()).sum()                              # энтропия в битах
    print(f"T={T}: p={[round(x, 3) for x in p.tolist()]}  H={H:.2f} бит  PPL={2 ** H:.2f}")

T=0.5: p=[0.944, 0.038, 0.014, 0.003, 0.001, 0.0]  H=0.38 бит  PPL=1.30
T=1.0: p=[0.706, 0.143, 0.086, 0.039, 0.019, 0.006]  H=1.40 бит  PPL=2.64
T=2.0: p=[0.436, 0.196, 0.153, 0.102, 0.072, 0.042]  H=2.20 бит  PPL=4.59

Предельные случаи: при $T \to 0$ вся вероятность уходит самому большому логиту (жадная генерация, $H \to 0$), при $T \to \infty$ распределение стремится к равномерному ($H \to \log_2 6 \approx 2.58$ бита). Делить на ноль нельзя, поэтому «температура 0» в API реализована как отдельный режим argmax. Название пришло из физики: в распределении Больцмана $p \propto e^{-E/kT}$ при высокой температуре частицы равномерно занимают все состояния.

Подвигайте ползунок температуры в песочнице и посмотрите, как меняются вероятности, энтропия и perplexity (виджет считает энтропию в битах). Top-k и top-p пока оставьте выключенными: их разберём в уроке 4.1.3.

Песочница: softmax и сэмплированиеинтерактив

КонтекстКарп прыгает через…

Температура 1.00top-k выклtop-p 1.00

ТокенЛогитВероятность%

Сэмплировать 20 разНажмите, чтобы вытянуть 20 токенов из этого распределения

Температура встречается не только при генерации. В классической дистилляции (Хинтон и соавторы, 2015) учителя «размягчают» температурой $T > 1$, чтобы ученик видел не только правильный ответ, но и то, какие ошибки учитель считает «почти правильными»: «кошка» больше похожа на «собаку», чем на «автомобиль».

Практика

Реализуйте энтропию, KL и softmax с температурой на чистом Python. Тесты проверят числа из урока, асимметрию KL, обработку нулей и разложение $H(p, q) = H(p) + \mathrm{KL}(p \Vert q)$.

Энтропия, KL и температура8 тестов

import math

LOGITS = [3.2, 1.6, 1.1, 0.3, -0.4, -1.5]   # логиты модели для 6 токенов


def entropy(p, base=2):
    """Энтропия H(p) = −Σ p·log(p). По умолчанию в битах (base=2); base=math.e — в натах.

    Слагаемые с p = 0 пропускайте: по соглашению 0·log 0 = 0.
    """
    # TODO: ваш код
    ...


def kl(p, q):
    """KL(p ‖ q) = Σ p·ln(p / q) в натах.

    Слагаемые с p = 0 пропускайте. Если p > 0, а q = 0 — верните math.inf.
    """
    # TODO: ваш код
    ...


def softmax_t(logits, T=1.0):
    """Softmax с температурой: softmax(logits / T). Должен быть устойчив к логитам порядка 1000."""
    # TODO: ваш код
    ...


# Проверьте себя кнопкой «Запустить»:
print(entropy([0.5, 0.5]), entropy([0.25] * 4))           # 1.0 2.0
print(kl([0.5, 0.5], [0.9, 0.1]))                           # ≈ 0.5108
print(kl([0.9, 0.1], [0.5, 0.5]))                           # ≈ 0.3681 — KL несимметрична
for T in (0.5, 1.0, 2.0):
    p = softmax_t(LOGITS, T)
    if p:                                                   # покажется, когда softmax_t заработает
        print(T, [round(x, 3) for x in p], entropy(p))      # энтропия растёт с T

ЗапуститьПроверитьПодсказкаСбросить

Ловушка PyTorch: F.kl_div

В PyTorch есть готовая функция, но с неочевидным порядком аргументов: F.kl_div(input, target) считает $\mathrm{KL}(\text{target} \Vert \text{model})$ и ждёт в input логарифмы вероятностей модели, а в target — обычные вероятности цели. Так её используют при дистилляции:

import torch
import torch.nn.functional as F

teacher_logits = torch.tensor([[2.0, 1.0, 0.1]])   # «учитель»: батч из 1 примера, 3 токена
student_logits = torch.tensor([[1.0, 1.5, 0.5]])   # «ученик»

p = F.softmax(teacher_logits, dim=-1)              # цель
log_q = F.log_softmax(student_logits, dim=-1)      # ЛОГ-вероятности модели

kl_manual = (p * (p.log() - log_q)).sum(dim=-1).mean()
kl_torch = F.kl_div(log_q, p, reduction="batchmean")   # KL(p ‖ q): сначала log q, потом p
wrong = F.kl_div(F.softmax(student_logits, dim=-1), p, reduction="batchmean")  # вероятности вместо логарифмов

print(round(kl_manual.item(), 4), round(kl_torch.item(), 4), round(wrong.item(), 4))

0.2616 0.2616 -1.1903

Ошибочный вариант не падает с ошибкой — он молча возвращает отрицательное число. Запомните правило отладки: KL меньше нуля — значит, где-то перепутаны аргументы или логарифмы. И используйте reduction="batchmean": вариант по умолчанию "mean" делит ещё и на размер словаря и даёт число, которое не является KL.

Китайский угол: KL в рецептах DeepSeek и Qwen

Как DeepSeek считает KL в GRPO. В DeepSeekMath (arXiv:2402.03300) KL-штраф к референсной модели не вычитают из награды, как в классическом RLHF, а добавляют прямо в функцию потерь. Причём не наивной оценкой $\log \frac{\pi_\theta}{\pi_{\text{ref}}}$, а такой (для каждого токена сгенерированного ответа):

$$\widehat{\mathrm{KL}} = \frac{\pi_{\text{ref}}}{\pi_\theta} - \log \frac{\pi_{\text{ref}}}{\pi_\theta} - 1$$

Её матожидание то же самое (оценка несмещённая), но она никогда не бывает отрицательной: $r - 1 - \log r \ge 0$ для любого $r > 0$. Почему матожидание не меняется: обозначим $r = \pi_{\text{ref}} / \pi_\theta$. Ответы сэмплируются из $\pi_\theta$, поэтому $\mathbb{E}[r] = \sum_x \pi_\theta(x) \cdot \frac{\pi_{\text{ref}}(x)}{\pi_\theta(x)} = \sum_x \pi_{\text{ref}}(x) = 1$. Слагаемое $r - 1$ в среднем равно нулю и только гасит разброс, а $\mathbb{E}[-\log r]$ — это и есть $\mathrm{KL}(\pi_\theta \Vert \pi_{\text{ref}})$. В блоге Джона Шульмана эта оценка названа k3. Проверим на игрушечном примере:

import numpy as np

pi = np.array([0.6, 0.3, 0.1])        # π_θ: модель после RL
ref = np.array([0.4, 0.4, 0.2])       # π_ref: модель до RL
exact = np.sum(pi * np.log(pi / ref))          # точная KL(π_θ ‖ π_ref)

rng = np.random.default_rng(0)
x = rng.choice(3, size=1000, p=pi)             # сэмплы из π_θ — как ответы при RL
k1 = np.log(pi[x]) - np.log(ref[x])            # наивная оценка
r = ref[x] / pi[x]
k3 = r - 1 - np.log(r)                         # оценка из GRPO

print(f"точно: {exact:.4f}")
print(f"k1: среднее {k1.mean():.4f}, std {k1.std():.4f}, доля < 0: {(k1 < 0).mean():.2f}")
print(f"k3: среднее {k3.mean():.4f}, std {k3.std():.4f}, доля < 0: {(k3 < 0).mean():.2f}")

точно: 0.0877
k1: среднее 0.0761, std 0.4032, доля < 0: 0.42
k3: среднее 0.0861, std 0.0729, доля < 0: 0.00

Разброс k3 в пять с лишним раз меньше. Коэффициент KL-штрафа в DeepSeekMath — $\beta = 0.04$. Подробно — в уроке 6.4.1.

Дистилляция в Qwen3. В техотчёте Qwen3 маленькие модели получают знания от больших через strong-to-weak distillation в два этапа. Сначала off-policy: ученик учится на ответах учителя. Затем on-policy: ученик сам генерирует ответы, а его логиты подтягивают к логитам учителя, минимизируя KL. По данным авторов, это дешевле, чем обучать каждую маленькую модель через RL. В 2025–2026 годах on-policy дистилляция с обратной KL вошла в рецепты нескольких китайских лабораторий: Xiaomi MiMo-V2-Flash, OpenBMB MiniCPM5 (в README модели прямо сказано, что обратная KL до учителя на каждой позиции ответа служит сигналом обучения) и, по сообщениям, DeepSeek-V4. Подробнее — в уроке 6.4.4.

Температура в инструкциях к моделям. Авторы DeepSeek-R1 в README рекомендуют температуру 0.5–0.7 (лучше 0.6), чтобы избежать бесконечных повторов и бессвязного текста. Qwen3 в режиме размышлений советует $T = 0.6$ и прямо предостерегает от жадной генерации.

Как по-китайски «энтропия». Китайский знак для энтропии («шан») специально составили для перевода физического термина (по распространённой версии — физик Ху Ганфу в 1923 году). Его смысловая часть — «огонь», а звуковая — слог, который значит ещё и «частное»: в термодинамике энтропия — частное теплоты и температуры. От этого слова образованы китайские названия информационной энтропии, cross-entropy и «относительной энтропии» (другое название KL), а perplexity там называют «степенью замешательства». Самое понятное китайское изложение — подраздел «Основы теории информации» в главе 3.4 d2l-zh.

Проверь себя

Проверь себя6 вопросов·

1 Чему равна энтропия распределения $[0.5, 0.25, 0.25]$ в битах?

2 У цели $p$ два пика, а модель $q$ умеет изобразить только один. Какую KL нужно минимизировать, чтобы модель уверенно села на один пик, а не размазалась между двумя?

Прямую $\mathrm{KL}(p \Vert q)$ — среднее по даннымОбратную $\mathrm{KL}(q \Vert p)$ — среднее по ответам моделиЛюбую: KL симметричнаНикакую: пик выбирает только температура

3 Какие утверждения о KL-дивергенции верны?Можно выбрать несколько ответов

$\mathrm{KL}(p \Vert q) \ge 0$ для любых распределений$\mathrm{KL}(p \Vert q) = \mathrm{KL}(q \Vert p)$$\mathrm{KL}(p \Vert q) = H(p, q) - H(p)$Если $q_i = 0$ там, где $p_i > 0$, KL всё равно конечна

4 Средний loss модели на тексте — 3.0 ната на токен. Чему равна perplexity? Округлите до одного знака.

5 Что происходит с распределением $\mathrm{softmax}(z / T)$ при $T \to 0$?

Становится равномернымВся вероятность уходит токену с наибольшим логитомПорядок токенов по вероятности меняется на обратныйЭнтропия растёт до $\log K$

6 Ваш код посчитал KL-дивергенцию между учителем и учеником и выдал −1.19. Что это значит?

Ученик стал лучше учителяВ коде ошибка: перепутаны аргументы или вместо логарифмов вероятностей переданы сами вероятностиВсё нормально: KL бывает отрицательной, если распределения сильно различаютсяСлишком высокая температура

Проверить ответы

Итоги

• Информация события — $-\log p$, энтропия — её среднее. Энтропия от 0 (полная уверенность) до $\log K$ (равномерное распределение) и равна минимальной средней длине кода.
• $H(p, q) = H(p) + \mathrm{KL}(p \Vert q)$: обучение на cross-entropy подтягивает модель к данным по KL, а энтропия самого языка — неустранимая часть loss.
• KL неотрицательна и несимметрична. Прямая KL покрывает все пики, обратная садится на один. KL держит модель рядом с референсом в RLHF и GRPO и переносит знания в дистилляции.
• Perplexity = $e^{H}$ — эффективное число вариантов. Температура делает распределение острее ($T < 1$) или площе ($T > 1$), не меняя порядок токенов.

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