Appearance
08. Softmax и cross-entropy: первая «настоящая» функция
В этом уроке разбираем ядро линейного классификатора: softmax (логиты → вероятности) и cross-entropy (мера «насколько вероятности расходятся с правдой») — вместе с их градиентом, который сведётся к одной знаменитой формуле.
Softmax: логиты → вероятности
Линейная модель выдаёт «сырые» оценки (логиты)
Свойства:
, ; - монотонность: больший логит → большая вероятность;
- инвариантность к сдвигу:
для любого скаляра (слагаемые в числителе и знаменателе умножаются на и сокращаются).
Численная стабильность: вычитание максимума
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: штраф за неверную уверенность
Для одного образца с правильным классом
Читается просто: логарифм вероятности, которую модель поставила правильному классу, со знаком минус. Правильному классу 0.99 → CE ≈ 0.01 (маленький штраф). 0.01 → CE ≈ 4.6 (огромный штраф). Если модель «уверенно неверна» — CE взлетает.
Для батча из
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-индексирование «на диагонали»: из каждой строки 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 (по батчу из
Матрично: берём матрицу вероятностей
Интуиция: для правильного класса градиент отрицательный (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По строкам:
was_1d/atleast_2d/atleast_1d— приводим(N)→(1, N), скаляр/(1,)/(batch, 1)target →(batch,); дальше один путь;p_shift,S— стабильный softmax по строкам;S[np.arange(batch), ti]— по каждой строке взять ячейку правильного класса →«правильных» вероятностей; cross_entropy = -np.log(S_yn).mean()— среднее по батчу (на одном образце «среднее» — то же число);grad = S / batch— делим всю матрицу на; grad[np.arange(batch), ti] -= 1.0 / batch— вычитание one-hot «на диагонали», без построения матрицыnp.eye;- если вход был 1D — возвращаем градиент
(N,), иначеcheck_gradientупёрся бы вassert analytic_grad.shape == x.shape.
Проверка на малых примерах
Пример 1:
Z_shift=; exp=; сумма = ; S=; - CE =
; - grad =
.
Пример 2:
S=; CE = ; - grad =
.
Пример 3 (стабильность): np.exp(1000) → inf, S → nan. С вычитанием: S = [[1, 0, 0]], CE ≈ 0.
Пример 4 (равные логиты):
Проверка в ноутбуке (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 |
| sum | 9.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.214403 | P1 − 1 |
| dL/ds2 | 0.175290 | P2 − 0 |
| dL/ds3 | 0.039113 | P3 − 0 |
Формула: dL/dsj = Pj − 1(j = t). Градиент показывает, как «дёрнуть» сырые оценки, чтобы поднять вероятности правильного класса.
Практика
1. Вычислите softmax для
2. 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.
2. Вычтем максимум (2.0):
3. np.eye(C)[y] — для каждого eye по индексу y[i]: это и есть one-hot (единица в столбце y[i], ноли в остальном). Вычитание one_hot(y)/batch поэлементно: в каждой строке 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 =
, среднее по батчу; штрафует за «уверенную ошибку»; - Градиент
softmax + CE—: элементарная формула, которую стоит запомнить; - Сигнатура
(value, grad)— та же, что уsquare, и проверяетсяcheck_gradient(урок 07).
Следующий урок — 09. Откуда берётся градиент: цепное правило: выводим формулу