BCE: бинарная кросс-энтропия

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

Модель бинарной классификации выдаёт число $\hat y\in(0;\,1)$ — свою вероятность того, что объект принадлежит классу 1: письмо — спам, транзакция — мошенничество, на снимке есть опухоль. Чтобы модель училась, нужна функция потерь (loss): одно число, которое тем больше, чем хуже предсказание, и которое можно дифференцировать. Бинарная кросс-энтропия (binary cross-entropy, BCE; в статистике — log loss, отрицательное лог-правдоподобие) — стандартный выбор для такой задачи.

Где она стоит:

• логистическая регрессия и выход любого бинарного классификатора — связка сигмоида + BCE;
• multi-label классификация — у каждой метки (теги фото, категории токсичности) своя сигмоида и своя BCE, метки независимы;
• градиентный бустинг — binary:logistic в XGBoost, binary в LightGBM, Logloss в CatBoost — это та же BCE по «сырому» счёту деревьев;
• дискриминатор GAN учится с BCE: «настоящее» — 1, «сгенерированное» — 0;
• модели вознаграждения в RLHF и DPO — потеря $-\log\sigma(r_{\text{лучше}}-r_{\text{хуже}})$ — это BCE с меткой 1 для разности оценок (модель Брэдли — Терри);
• метрика — log loss на соревнованиях и в отчётах: он оценивает не только «угадал ли», но и честность вероятностей.

Интуиция: штраф за удивление

Представьте, что модель — синоптик, который каждый день называет вероятность дождя. Если он сказал «90%» и дождь пошёл — он почти не удивлён, штраф маленький. Если сказал «10%», а дождь пошёл — он сильно ошибся и был в этом уверен; штраф должен быть большим. А если он вообще отказался от прогноза и всегда говорит «50%», его штраф каждый день один и тот же — $\ln2\approx0{,}693$.

BCE устроена именно так: потеря равна $-\ln$ вероятности того, что произошло на самом деле. Для правильного ответа $y=1$ это $-\ln\hat y$ (красная кривая), для $y=0$ — $-\ln(1-\hat y)$ (синяя). Потяните точку.

Формула по косточкам

Возьмём одно слагаемое — потерю на одном объекте — и посмотрим на каждую деталь.

$y\in\{0,1\}$

правильный ответ (метка). Работает как переключатель: при $y=1$ второе слагаемое умножается на 0, при $y=0$ — первое;

$\hat y\in(0;\,1)$

предсказанная вероятность класса 1, обычно $\hat y=\sigma(z)$, где $z$ — логит (сырой выход модели);

$1-\hat y$

предсказанная вероятность класса 0 — две вероятности в сумме дают 1;

$\log$

натуральный логарифм ($\ln$): потеря измеряется в «натах»; с $\log_2$ получились бы биты;

$-$

минус нужен, потому что логарифм вероятности отрицателен: $\log\hat y\le0$, а потеря должна быть $\ge0$;

$\frac1n\sum_{i=1}^{n}$

усреднение по объектам — чтобы величина потери не зависела от размера батча.

Переключатель даёт компактную запись: пусть $p_t$ — вероятность, которую модель дала правильному классу ($p_t=\hat y$ при $y=1$ и $p_t=1-\hat y$ при $y=0$). Тогда

Вторая форма — «BCE по логитам» — понадобится для вывода градиента и для устойчивого кода. Если метки записаны как $s=\pm1$, та же потеря принимает вид логистической потери $\log(1+e^{-s z})$, где $s z$ — отступ (margin): положительный отступ означает верный ответ.

Таблица показывает асимметрию: на правильной стороне потеря быстро прижимается к нулю, на неправильной растёт как логарифм, а наклон $-1/\hat y$ при $\hat y=0{,}001$ достигает $-1000$.

Пример на четырёх объектах

Метки $y=(1;\,0;\,1;\,1)$, предсказания $\hat y=(0{,}9;\,0{,}2;\,0{,}6;\,0{,}95)$. Вероятности правильных ответов: $0{,}9$; $0{,}8$; $0{,}6$; $0{,}95$. Потери: $0{,}105$; $0{,}223$; $0{,}511$; $0{,}051$. Среднее — $\mathrm{BCE}\approx0{,}223$. Больше всех «виноват» третий объект: модель дала правильному ответу всего $0{,}6$.

Откуда она берётся: максимальное правдоподобие

BCE не придумана «на глаз» — она выводится. Пусть модель говорит: «объект относится к классу 1 с вероятностью $\hat y$». Это распределение Бернулли, и его формулу удобно записать одной строкой — снова с меткой в роли переключателя, но теперь в показателе степени:

Если объекты независимы, вероятность увидеть все метки обучающей выборки — правдоподобие (likelihood) — равна произведению. Метод максимального правдоподобия подбирает параметры модели так, чтобы это произведение было как можно больше:

Логарифм превращает произведение в сумму и не сдвигает точку максимума (он строго возрастает), минус превращает максимум в минимум, $\tfrac1n$ — в среднее. Итак, минимизировать BCE — то же самое, что максимизировать правдоподобие модели Бернулли.

На примере выше: $\mathcal L=0{,}9\cdot0{,}8\cdot0{,}6\cdot0{,}95=0{,}4104$, $-\ln0{,}4104\approx0{,}891$ — ровно сумма четырёх потерь, а деленное на 4 — та же $\mathrm{BCE}\approx0{,}223$.

Взгляд теории информации: удивление, энтропия, KL

Тот же результат получается с другой стороны. В теории информации Клода Шеннона событие с вероятностью $p$ несёт собственную информацию $I(p)=-\log p$; её ещё называют удивлением (surprisal). Достоверное событие ($p=1$) не удивляет ($I=0$); редкое удивляет сильно; удивления независимых событий складываются. В битах ($\log_2$) событие с вероятностью $\tfrac18$ несёт 3 бита; в натах ($\ln$) один бит равен $\ln2\approx0{,}693$.

Пусть настоящий мир устроен как монетка с вероятностью «1» равной $y$, а модель верит в вероятность $\hat y$. Тогда:

Кросс-энтропия — это и есть BCE (отсюда название), причём формула работает и для «мягких» меток $y\in[0;\,1]$. Разница двух величин — расхождение Кульбака — Лейблера (KL-дивергенция):

Энтропия $H(y)$ от модели не зависит, поэтому минимизировать BCE — значит минимизировать KL, то есть «расстояние» от убеждений модели до правды. KL равна нулю только при $\hat y=y$. Для жёстких меток $y\in\{0,1\}$ энтропия равна нулю и BCE совпадает с KL.

Свойства

• Неотрицательность. $\ell\ge0$; для жёстких меток $\ell=0$ только в пределе $\hat y\to y$. С сигмоидой на выходе $\hat y$ никогда не равна точно 0 или 1, поэтому ноль недостижим.
• Неограниченность сверху. При $y=1$, $\hat y\to0$ потеря $\to+\infty$. Но в логитах рост лишь линейный: $\operatorname{softplus}(-z)\approx-z$ при $z\ll0$, и уверенная ошибка с логитом $-10$ стоит около 10, а не бесконечность.
• Ограниченный градиент по логиту. $|\partial\ell/\partial z|=|\hat y-y|<1$: каждый объект тянет модель с силой не больше 1, сколь бы сильно она ни ошибалась.
• Выпуклость по $\hat y$: $\dfrac{\partial^2\ell}{\partial\hat y^2}=\dfrac{y}{\hat y^2}+\dfrac{1-y}{(1-\hat y)^2}>0$. Выпуклость по логиту: $\dfrac{\partial^2\ell}{\partial z^2}=\hat y(1-\hat y)>0$. Отсюда — выпуклость по весам логистической регрессии (см. ниже).
• Симметрия классов: $\ell(z,y)=\ell(-z,1-y)$ — если поменять названия классов и знак логита, ничего не изменится.
• Строго собственное правило оценки (strictly proper scoring rule): если правда — монетка с вероятностью $p$, средняя потеря $H(p)+\mathrm{KL}(p\,\|\,q)$ минимальна только при прогнозе $q=p$. BCE вознаграждает честность (раздел о калибровке).
• Точка отсчёта. Модель-константа, всегда предсказывающая долю положительных $\pi$, получает $\mathrm{BCE}=H(\pi)$. Для сбалансированных классов это $\ln2\approx0{,}693$, для $\pi=0{,}1$ — $0{,}325$. Модель хуже этого порога не выучила ничего.

Производная: почему σ′ сокращается

Это центральная формула страницы. Сначала производная по вероятности $\hat y$, затем — по логиту $z$, где $\hat y=\sigma(z)$.

Эта производная неудобна: при $\hat y\to0$ или $\hat y\to1$ знаменатель стремится к нулю, и градиент взрывается (в таблице выше — $-1000$ при $\hat y=0{,}001$). Но модель не выдаёт $\hat y$ напрямую — она выдаёт логит, а вероятность получается сигмоидой. Цепное правило:

Знаменатель первой дроби — в точности производная сигмоиды $\sigma'(z)=\sigma(z)\bigl(1-\sigma(z)\bigr)$ (вывод — на странице сигмоиды). Они сокращаются, и остаётся «предсказание минус правда».

Для весов логистической регрессии $\hat y_i=\sigma(w^\top x_i+b)$ это даёт короткие формулы, которые и используются в обучении:

Почему не MSE: насыщение и невыпуклость

Почему бы не учить классификатор квадратичной ошибкой $(\hat y-y)^2$, как в регрессии? Посчитаем градиент по логиту, когда $\hat y=\sigma(z)$:

Здесь множитель $\sigma'(z)$ уже ничем не сокращается. Если модель уверенно ошибается ($y=1$, $z\ll0$), то $\sigma'(z)\approx0$ и градиент почти нулевой: модель «не слышит» свою самую грубую ошибку. При $z=-4$ градиент BCE равен $-0{,}982$, а MSE — $-0{,}0347$, в 28 раз меньше; при $z=-6$ — уже в 203 раза. Наибольший по модулю градиент MSE, $-0{,}296$, достигается при $z=-\ln2\approx-0{,}693$ — то есть MSE сильнее всего толкает модель, которая ошибается чуть-чуть.

Вторая беда — невыпуклость. Для $y=1$ вторая производная MSE по логиту равна $-2\sigma(1-\sigma)^2(1-3\sigma)$ и отрицательна при $\sigma<\tfrac13$, то есть при $z<-\ln2$. Потеря там вогнута и почти плоская: у суммы таких слагаемых по многим объектам появляются плато и седловые области (рисунок 5). Третья беда — ограниченность: MSE не больше 1, и «очень неправ» стоит почти столько же, сколько «безнадёжно неправ».

Ландшафт потерь в 3D

Посмотрим на потерю целиком как на функцию параметров. Возьмём логистическую регрессию с одним признаком, $\hat y=\sigma(wx+b)$, и 24 точки (по 12 каждого класса). Средняя потеря — функция двух переменных $L(w,b)$, её можно нарисовать поверхностью.

Что видно на рисунке:

• BCE — выпуклая чаша с единственным минимумом $(1{,}441;\,0{,}149)$, где $L=0{,}451$. Вдали от минимума стенки почти плоские наклонные плоскости, а не парабола: потеря растёт линейно, градиент ограничен.
• MSE — плато и складки. Её минимум $(1{,}374;\,0{,}320)$, $L=0{,}150$, лежит в узкой долине, а на краях поверхность почти горизонтальна.
• Скорость спуска. На старте норма градиента BCE равна $0{,}969$, MSE — $0{,}0174$, в 56 раз меньше. Потеря BCE отличается от минимальной меньше чем на $0{,}01$ уже на шаге 15, а останавливается спуск (норма градиента $<10^{-4}$) на шаге 63. MSE подходит к своему минимуму с той же точностью $0{,}01$ только к шагу 600, а останавливается на шаге 1150; между шагами 100 и 400 она ползёт по плато, где потеря почти не меняется ($0{,}500\to0{,}495$).
• Разные минимумы. Оптимумы двух потерь не совпадают: это разные определения «лучшей» модели. BCE ищет честные вероятности, MSE — наименьшие квадраты отклонений вероятностей от 0 и 1.

BCE в обучении

Теперь двумерный случай: 60 точек двух классов, модель $\hat y=\sigma(w_1x_1+w_2x_2+b)$, полный градиентный спуск с шагом $\eta=1$ от нулевых весов:

Обратите внимание на размеры точек: крупнее всего остаются точки по «чужую» сторону границы. Их градиент $|\hat y-y|$ близок к 1, а у уверенно и верно классифицированных — к нулю. BCE сама решает, на что тратить «внимание» модели: в основном на ошибки и на точки у границы.

Линейно разделимые данные: веса уходят в бесконечность

Если классы разделяются прямой, BCE можно сделать сколь угодно малой, просто увеличивая $\|w\|$: граница остаётся на месте, а сигмоида становится всё круче. Минимума нет — есть только инфимум 0. На рисунке это видно по счётчику: на шаге 100 потеря $0{,}0205$ и $\|w\|=3{,}94$, на шаге 200 — $0{,}0133$ и $4{,}77$, на шаге 400 — $0{,}0082$ и $5{,}76$. Норма растёт примерно как логарифм числа шагов и не останавливается.

Численная устойчивость: BCEWithLogits

Формула $-[y\log\hat y+(1-y)\log(1-\hat y)]$ на бумаге безупречна, но в компьютере ломается. Если сначала вычислить $\hat y=\sigma(z)$, а потом логарифм, возникают три проблемы:

1. log(0). В float32 значение $\sigma(z)$ округляется ровно до 1 уже при $z>16{,}64$: тогда $1-\hat y=0$, потеря равна $\infty$, а градиент — NaN. В float64 то же самое начинается с $z>36{,}74$.
2. Потеря точности до этого. Разность $1-\sigma(z)$ двух близких чисел теряет значащие цифры (катастрофическое сокращение): при $z=16$ наивный float32 даёт $15{,}942$ вместо $16$, и график идёт ступеньками.
3. Обрезка (clipping) — заплатка, а не лечение. Если ограничить $\hat y$ отрезком $[\varepsilon;\,1-\varepsilon]$ с $\varepsilon=10^{-7}$ (так Keras поступает с вероятностями на входе), потеря упирается в потолок $-\ln10^{-7}\approx16{,}118$, а в float32 — даже $15{,}942$, потому что $1-10^{-7}$ округляется до $1-2^{-23}$. Хуже того, за потолком градиент обрезки равен нулю: уверенно ошибающиеся примеры перестают учить модель. PyTorch BCELoss поступает похоже — обрезает логарифм на $-100$.

Лечение — никогда не вычислять $\hat y$ отдельно, а считать потерю прямо по логиту, через softplus и приём log-sum-exp:

pythonimport numpy as np

def sigmoid(z):
    # σ(z) = (1 + tanh(z/2)) / 2 — без переполнения при любом z
    return 0.5 * (1.0 + np.tanh(0.5 * np.asarray(z, dtype=float)))

def bce_with_logits(z, y, pos_weight=1.0):
    """Устойчивая BCE по логитам: y·softplus(−z) + (1 − y)·softplus(z)."""
    z, y = np.asarray(z, dtype=float), np.asarray(y, dtype=float)
    sp_pos = np.logaddexp(0.0, z)      # softplus(z)  = −log(1 − σ(z))
    sp_neg = sp_pos - z                # softplus(−z) = −log σ(z)
    return np.mean(pos_weight * y * sp_neg + (1 - y) * sp_pos)

def bce_grad(z, y):
    """Градиент средней BCE по логитам: (σ(z) − y) / n."""
    return (sigmoid(z) - y) / len(z)

z = np.array([3.0, -2.0, 0.5, 20.0])
y = np.array([1.0, 0.0, 1.0, 0.0])
print(bce_with_logits(z, y))         # 5.1624 — почти всё дал последний пример
print(bce_grad(z, y))                # ≈ [-0.0119  0.0298 -0.0944  0.25]
print(bce_with_logits(z, y, 10.0))   # 6.3384 — положительные примеры весят в 10 раз больше

# Наивно в float32: σ(20) округляется до 1, и log(1 − 1) = −inf
p = 1 / (1 + np.exp(-np.float32(20.0)))
print(-np.log(1 - p))                # inf (и RuntimeWarning)

pythonimport torch
import torch.nn as nn

z = torch.tensor([3.0, -2.0, 0.5, 20.0], requires_grad=True)   # логиты
y = torch.tensor([1.0, 0.0, 1.0, 0.0])

loss = nn.BCEWithLogitsLoss()(z, y)    # σ и log внутри одной устойчивой формулы
loss.backward()
print(loss.item())                     # 5.1624
print(z.grad)                          # (σ(z) − y) / 4 ≈ [-0.0119, 0.0298, -0.0944, 0.2500]

# Плохо: сначала sigmoid, потом BCELoss. σ(20) в float32 равна 1,
# BCELoss обрезает log на −100, и последний пример стоит 100 вместо 20
p = torch.sigmoid(z.detach())
print(nn.BCELoss()(p, y).item())       # 25.1624

# Дисбаланс классов: ошибка на положительном примере в 10 раз дороже
loss_w = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([10.0]))

# Сглаживание меток: у BCEWithLogitsLoss такого параметра нет — сглаживаем сами
eps = 0.1
y_smooth = y * (1 - eps) + eps / 2     # 1 → 0.95, 0 → 0.05

Дисбаланс классов: веса и pos_weight

В реальных задачах положительных примеров часто мало: 1% мошеннических транзакций, 0,1% кликов. Обычная BCE честно учит вероятности, но вероятность редкого класса почти всюду мала, и при пороге $0{,}5$ модель почти никого не находит. Частое средство — вес положительного класса $w_+$ (в PyTorch — pos_weight):

Вес $w_+$ равносилен тому, чтобы повторить каждый положительный пример $w_+$ раз. Для правильно заданной модели оптимальные шансы умножаются на $w_+$, то есть логит сдвигается на $\ln w_+$. Модель-константа для доли положительных $\pi$ выбирает

Поэтому популярный выбор $w_+=n_{\text{neg}}/n_{\text{pos}}$ «выравнивает» классы: константа становится $0{,}5$.

Три вывода из рисунка:

• Без весов среднее предсказание равно доле класса: $0{,}091=15/165$. Это не совпадение: у логистической регрессии со сдвигом в оптимуме $\partial\mathrm{BCE}/\partial b=\frac1n\sum(\hat y_i-y_i)=0$, то есть $\sum\hat y_i=\sum y_i$.
• Вес двигает порог, а не «умнеет» модель. При $w_+=10$ сдвиг $b$ равен $1{,}91$ — близко к $\ln10\approx2{,}30$ (на конечной выборке меняется и $w$). Полнота растёт, точность падает: это та же кривая компромисса, по которой можно двигаться и порогом.
• Веса портят калибровку. Среднее $\hat y=0{,}244$ уже не равно доле $0{,}091$. Если нужны настоящие вероятности, обучайте без весов и выбирайте порог (он равен $1/(1+w_+)$ для того же решения) или пересчитайте шансы обратно: $\text{шансы}=\text{шансы}_w/w_+$.

Сглаживание меток

При жёстких метках оптимальный логит бесконечен: чтобы потеря на положительном примере стала нулём, нужно $z\to+\infty$. Градиентный спуск честно туда идёт. На одном положительном примере с шагом $\eta=1$ от $z=0$ логит через 10, 100 и 1000 шагов равен $2{,}26$; $4{,}59$; $6{,}91$ — растёт примерно как $\ln t$ и не останавливается. Модель учится быть самоуверенной.

Сглаживание меток (label smoothing) заменяет жёсткие метки мягкими:

Теперь градиент $\sigma(z)-y_s$ обращается в ноль в конечной точке $z^*$, где $\sigma(z^*)=y_s$, а минимальная потеря равна не 0, а энтропии $H(y_s)$ (рисунок 2). При $\varepsilon=0{,}1$: $y_s=0{,}95$, $z^*=\ln19\approx2{,}944$, и тот же спуск даёт $1{,}97$; $2{,}936$; $2{,}944$ — логит останавливается. Вернитесь к рисунку 3 и сдвиньте ползунок $\varepsilon$: у кривой появится минимум, а оранжевый градиент пересечёт ноль.

Сглаживание работает как регуляризатор уверенности: веса не уходят в бесконечность, вероятности не прилипают к 0 и 1, а калибровка часто улучшается. Платить приходится тем, что оптимальный прогноз теперь не выше $1-\varepsilon/2$ (больше модель предсказывать не стремится), а «тёмное знание» о сходстве классов частично теряется (Мюллер, Корнблит, Хинтон, 2019). В Keras это параметр label_smoothing у BinaryCrossentropy, в PyTorch для BCE метки сглаживают вручную (см. код выше).

Калибровка: BCE вознаграждает честность

Модель откалибрована, если её вероятностям можно верить буквально: среди всех объектов, которым она дала около $0{,}8$, класс 1 встречается примерно в 80% случаев. Проверяют это диаграммой надёжности (reliability diagram): предсказания делят на корзины, и в каждой сравнивают среднее предсказание с долей единиц. Сводное число — ожидаемая ошибка калибровки:

Почему BCE учит калибровке? Если на объектах с одинаковыми признаками класс 1 встречается с частотой $p$, средняя потеря прогноза $q$ равна $H(p)+\mathrm{KL}(p\,\|\,q)$, и она минимальна только при $q=p$. Любое приукрашивание — и в сторону уверенности, и в сторону осторожности — стоит дороже. Точность (accuracy) так не умеет: ей безразлично, сказала модель $0{,}51$ или $0{,}99$.

На этом и основано температурное шкалирование (temperature scaling, Го и др., 2017): у обученной сети подбирают один параметр $T$ в $\hat y=\sigma(z/T)$, минимизируя BCE на валидационной выборке. Здесь $k=1/T$. Порядок предсказаний и точность при этом не меняются — меняется только честность вероятностей.

Частые ошибки

1. Двойная сигмоида. Модель уже применила sigmoid, а потеря — BCEWithLogitsLoss — применяет её ещё раз. Тогда $\sigma(\sigma(z))\in(0{,}5;\,0{,}731)$: модель в принципе не может предсказать класс 0 с вероятностью больше половины, и потеря на нём не опускается ниже $\ln2\approx0{,}693$.
2. Сигмоида + BCELoss вместо BCEWithLogitsLoss. Работает до первого уверенного примера, потом $\log0$, обрезка на $-100$ и нулевой градиент (раздел об устойчивости).
3. Метки $\pm1$ вместо $\{0,1\}$. С $y=-1$ формула BCE даёт $\log\hat y-2\log(1-\hat y)$, которая уходит в $-\infty$ при $\hat y\to0$: потеря становится отрицательной и обучение расходится. Для меток $\pm1$ есть своя форма $\log(1+e^{-s z})$.
4. BCE для взаимоисключающих классов. Если ровно один из $K>2$ классов верен, нужны softmax и категориальная кросс-энтропия. Несколько сигмоид с BCE — это multi-label, где классы независимы.
5. Сравнение BCE без точки отсчёта. «Потеря 0,05» звучит отлично, но при доле положительных 1% константа даёт $H(0{,}01)\approx0{,}056$ — модель почти ничему не научилась. Сравнивайте с $H(\pi)$.
6. Веса классов и «вероятности». После pos_weight выход сигмоиды уже не вероятность (рисунок 8). Для решений с ценой ошибок подбирайте порог; для честных вероятностей — пересчитывайте или калибруйте.
7. reduction='sum' вместо среднего. Сумма растёт с размером батча, и вместе с ней фактический шаг обучения. Меняете размер батча — меняется оптимальный темп обучения (learning rate).

Связи с другими формулами

• Сигмоида: превращает логит в $\hat y$; её производная $\sigma(1-\sigma)$ сокращается в градиенте BCE.
• Категориальная кросс-энтропия: обобщение на $K$ классов; при $K=2$ softmax + CE совпадает с сигмоидой + BCE от разности логитов $z_1-z_2$.
• Softmax: для двух классов $\operatorname{softmax}(z_1,z_2)_1=\sigma(z_1-z_2)$.
• Focal Loss: $-(1-p_t)^\gamma\log p_t$ — BCE, приглушающая лёгкие примеры; при $\gamma=0$ совпадает с BCE.
• MSE: правильная потеря для гауссова шума; с сигмоидой даёт насыщение и невыпуклость (рисунки 4 и 5).
• SGD и Adam: оптимизаторы, которые используют градиент $\frac1nX^\top(\hat y-y)$.

Итоги

Проверь себя