Skip to content

08. Softmax и cross-entropy: первая «настоящая» функция ​

В этом уроке разбираем ядро линейного классификатора: softmax (логиты → вероятности) и cross-entropy (мера «насколько вероятности расходятся с правдой») — вместе с их градиентом, который сведётся к одной знаменитой формуле.

Softmax: логиты → вероятности ​

Линейная модель выдаёт «сырые» оценки (логиты) Z∈RC по C классам. Softmax превращает их в распределение вероятностей (все члены ≥ 0 и в сумме 1):

S(y)i=eyi∑j=1Ceyj

Свойства:

  • 0<S(y)i<1, ∑iS(y)i=1;
  • монотонность: больший логит → большая вероятность;
  • инвариантность к сдвигу: S(y+c⋅1)=S(y) для любого скаляра c (слагаемые в числителе и знаменателе умножаются на ec и сокращаются).

Численная стабильность: вычитание максимума ​

e1000 переполняет float64/float32. Но по инвариантности к сдвигу мы можем вычесть максимум до экспоненты — результат тот же, а переполнения нет:

python
Z_shift = Z - np.max(Z, axis=1, keepdims=True)   # максимум в каждой строке → 0
exp_Z = np.exp(Z_shift)
S = exp_Z / np.sum(exp_Z, axis=1, keepdims=True)

keepdims=True оставляет размерность ((batch, 1) вместо (batch,)), чтобы broadcasting работал по строкам.

TODO: softmax в linear_classifer.py ​

Договорённость из докстринга: вход — (N) или (batch, N), выход — того же shape. axis=-1 + keepdims=True закрывают оба случая одной строчкой (по последнему измерению, размерность остаётся):

python
def softmax(predictions):
    p = np.asarray(predictions, dtype=float)
    p_shift = p - np.max(p, axis=-1, keepdims=True)
    exp_p = np.exp(p_shift)
    return exp_p / np.sum(exp_p, axis=-1, keepdims=True)

Проверка из ноутбука (cell 8):

python
probs = linear_classifer.softmax(np.array([-10, 0, 10]))
# → [2.06e-09, 4.54e-05, 0.9999546]

# Make sure it works for big numbers too!
probs = linear_classifer.softmax(np.array([1000, 0, 0]))
assert np.isclose(probs[0], 1.0)
# → [1., 0., 0.]  (без вычитания максимума было бы inf/inf = nan)

Cross-entropy: штраф за неверную уверенность ​

Для одного образца с правильным классом y (one-hot) cross-entropy:

CE=−∑c=1C1[c=y]⋅log⁡S(y)c=−log⁡S(y)y

Читается просто: логарифм вероятности, которую модель поставила правильному классу, со знаком минус. Правильному классу 0.99 → CE ≈ 0.01 (маленький штраф). 0.01 → CE ≈ 4.6 (огромный штраф). Если модель «уверенно неверна» — CE взлетает.

Для батча из N образцов берём среднее: 1N∑CEi.

TODO: cross_entropy_loss в linear_classifer.py ​

Функция «сама по себе» (в ноутбуке её проверяют отдельной ячейкой): вход — уже готовые вероятности probs (N) или (batch, N) и target_index (скаляр/(1,)/(batch,)) → одно число (среднее по батчу). Приём тот же: reshape(-1) делает любой вариант target «одномерным», np.atleast_2d поднимает 1D-пробы до (1, N), и дальше — единый векторизованный путь:

python
def cross_entropy_loss(probs, target_index):
    p = np.atleast_2d(np.asarray(probs, dtype=float))
    ti = np.atleast_1d(np.asarray(target_index, dtype=int)).reshape(-1)
    correct = p[np.arange(p.shape[0]), ti]
    return float(-np.log(correct).mean())

p[np.arange(p.shape[0]), ti] — fancy-индексирование «на диагонали»: из каждой строки i берём ячейку ti[i] — вероятность правильного класса.

Проверка из ноутбука (cell 10):

python
probs = linear_classifer.softmax(np.array([-5, 0, 5]))
# → [4.5094e-05, 0.0066925, 0.9932624]
linear_classifer.cross_entropy_loss(probs, 1)
# → 5.006760443547122  (= -log(0.0066925))

Градиент: знаменитая формула ​

Сводка цепного правила для softmax + cross-entropy (по батчу из N) даёт чудесно простую формулу:

∂CE∂Z=S−1[y]N

Матрично: берём матрицу вероятностей S, в строке каждого образца вычитаем 1/N из ячейки правильного класса. Всё. Неважно, насколько «грязная» была softmax-функция, — итоговый градиент элементарный.

Интуиция: для правильного класса градиент отрицательный (S - 1), т.е. логит правильного класса надо увеличить; для остальных — положительный (S), т.е. логиты «конкурентов» — уменьшить. Соотношение — ровно текущие вероятности (чем больше модель «ошибается по конкуренту», тем сильнее его давим).

TODO: softmax_with_cross_entropy в linear_classifer.py ​

По докстроингу функция должна работать и на одном образце (вход (N), target — скаляр), и на батче ((batch, N), target — (batch,) — в ячейке 14 ноутбука даже (batch, 1)). Секрет — привести вход к «каноническому» виду и вернуть градиент в форме, которую дал вход:

python
def softmax_with_cross_entropy(predictions, target_index):
    was_1d = np.asarray(predictions).ndim == 1
    p = np.atleast_2d(np.asarray(predictions, dtype=float))
    ti = np.atleast_1d(np.asarray(target_index, dtype=int)).reshape(-1)
    batch = p.shape[0]

    # softmax (стабильный) по строкам
    p_shift = p - np.max(p, axis=1, keepdims=True)
    exp_p = np.exp(p_shift)
    S = exp_p / np.sum(exp_p, axis=1, keepdims=True)

    # CE = -log(S[y]) по батчу, в среднем
    S_yn = S[np.arange(batch), ti]
    cross_entropy = float(-np.log(S_yn).mean())

    # grad = (S - one_hot(y)) / batch
    grad = S / batch
    grad[np.arange(batch), ti] -= 1.0 / batch

    if was_1d:
        grad = grad[0]          # вход (N) → выход (N)
    return cross_entropy, grad

По строкам:

  1. was_1d / atleast_2d / atleast_1d — приводим (N) → (1, N), скаляр/(1,)/(batch, 1) target → (batch,); дальше один путь;
  2. p_shift, S — стабильный softmax по строкам;
  3. S[np.arange(batch), ti] — по каждой строке взять ячейку правильного класса → N «правильных» вероятностей;
  4. cross_entropy = -np.log(S_yn).mean() — среднее по батчу (на одном образце «среднее» — то же число);
  5. grad = S / batch — делим всю матрицу на N;
  6. grad[np.arange(batch), ti] -= 1.0 / batch — вычитание one-hot «на диагонали», без построения матрицы np.eye;
  7. если вход был 1D — возвращаем градиент (N,), иначе check_gradient упёрся бы в assert analytic_grad.shape == x.shape.

Проверка на малых примерах ​

Пример 1: Z=[[2.0,1.0,0.1]], y=[0].

  • Z_shift = [[0,−1,−1.9]];
  • exp = [[1,0.3679,0.1496]]; сумма = 1.5174;
  • S = [[0.6590,0.2424,0.0986]];
  • CE = −log⁡(0.6590)=0.4170;
  • grad = [[−0.3410,0.2424,0.0986]].

Пример 2: Z=[[1.0,2.0]], y=[1].

  • S = [[0.2689,0.7311]]; CE = −log⁡(0.7311)=0.3133;
  • grad = [[0.2689,−0.2689]].

Пример 3 (стабильность): Z=[[1000.0,0.0,0.0]], y=[0]. Без вычитания максимума np.exp(1000) → inf, S → nan. С вычитанием: S = [[1, 0, 0]], CE ≈ 0.

Пример 4 (равные логиты): Z=[1,1,1] → S=[1/3,1/3,1/3] (softmax «равных» логитов — равномерное распределение).

Проверка в ноутбуке (cell 12 и 14) ​

Функция — TODO в linear_classifer.py: реализуете её вы, а ячейки ноутбука только проверяют:

python
# cell 12: один образец (вход (3,), target — скаляр 1)
loss, grad = linear_classifer.softmax_with_cross_entropy(np.array([1, 0, 0]), 1)
check_gradient(lambda x: linear_classifer.softmax_with_cross_entropy(x, 1),
               np.array([1, 0, 0], float))
# loss = 1.551444713932051
# grad = [0.5761168847658291, -0.7880584423829146, 0.21194155761708544]
# Gradient check passed!

# cell 14: батчи (batch=1 и batch=3, 4 класса, target формы (batch, 1))
# → два раза «Gradient check passed!»
# + assert, что вычитание максимума — по каждой строке отдельно:
probs = linear_classifer.softmax(np.array([[20, 0, 0], [1000, 0, 0]]))
assert np.all(np.isclose(probs[:, 0], 1.0))

Ожидаемый вывод cell 12 (ориентир):

text
Gradient check passed!
True

Если градиент посчитан неверно, check_gradient напечатает Gradients are different at (i,). Analytic: ..., Numeric: ... и вернёт False — как читать сообщение, разобрано в уроке 07.

Интерактив: логиты → вероятности ​

Три логита — три слайдера. Стенд показывает:

  • softmax-вероятности (три полосы, в сумме 1);
  • CE при заданном «правильном» классе;
  • инвариантность: добавьте к всем логитам константу — вероятности не изменятся.

1. exp «в лоб» (без вычитания max)

exp(s1)7.3891
exp(s2)1.6487
exp(s3)0.3679
sum9.4057

max(s) = 2 — его вычитаем, чтобы exp не переполнялся.

2. softmax (с вычитанием max)

P(s1)0.785597
P(s2)0.175290
P(s3)0.039113

3. loss и градиент

Cross-entropy: 0.241311

dL/ds1-0.214403P1 − 1
dL/ds20.175290P2 − 0
dL/ds30.039113P3 − 0

Формула: dL/dsj = Pj − 1(j = t). Градиент показывает, как «дёрнуть» сырые оценки, чтобы поднять вероятности правильного класса.

Практика ​

1. Вычислите softmax для Z=[0,0,0]. Для чего это полезно (подсказка: это «нулевая» модель, модель «я ничего не знаю»)?

2. Z=[[2.0,0.5,0.1]], y=[1] (правильный — средний класс). Найдите: S, CE, grad. (Используйте вычисление с вычитанием максимума.)

3. Почему grad[np.arange(batch), y] -= 1.0 / batch делает то же самое, что вычитание one-hot-матрицы one_hot(y) / batch? Напишите мини-код, который строит one_hot через np.eye (подсказка: np.eye(C)[y]) и убедитесь, что оба пути дают одинаковый grad.

Показать решения

1. S=[1/3,1/3,1/3] — равномерное распределение. Это «нулевая» модель: без обучения все логиты 0, и softmax даёт «я ничего не знаю». CE при этом = −log⁡(1/3)=log⁡3≈1.099 — базовая величина, с которой сравнивают обученную модель (если CE ≈ 1.099 — модель не лучше случайного угадывания).

2. Вычтем максимум (2.0): Z′=[0,−1.5,−1.9]. eZ′=[1,0.2231,0.1496], сумма = 1.3727. S=[0.7285,0.1625,0.1090]. CE = −log⁡(S[y])=−log⁡(0.1625)=1.8170. grad = [0.7285,0.1625−1,0.1090]/1=[0.7285,−0.8375,0.1090].

3. np.eye(C)[y] — для каждого i из батха берём строку eye по индексу y[i]: это и есть one-hot (единица в столбце y[i], ноли в остальном). Вычитание one_hot(y)/batch поэлементно: в каждой строке i — вычитаем 1/N из ячейки y[i]. Тот же эффект, что grad[np.arange(batch), y] -= 1.0 / batch.

Мини-код:

python
C = Z.shape[1]
one_hot = np.eye(C)[y]            # (batch, C)
grad_ref = (S - one_hot) / batch
np.allclose(grad, grad_ref)       # True

Итоги урока ​

  • Softmax — логиты → вероятности; инвариантен к сдвигу → вычитаем максимум до np.exp (защита от переполнения);
  • Cross-entropy = −log⁡S[y], среднее по батчу; штрафует за «уверенную ошибку»;
  • Градиент softmax + CE — S−1[y]N: элементарная формула, которую стоит запомнить;
  • Сигнатура (value, grad) — та же, что у square, и проверяется check_gradient (урок 07).

Следующий урок — 09. Откуда берётся градиент: цепное правило: выводим формулу S−1[y]N с нуля и учимся её доказывать.