Логистическая и softmax-регрессия

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

В мире LLM классификация повсюду. Перед претрейном (предобучением из урока 2.1.1) классификатор решает, математическая ли страница из интернета и стоит ли её брать в корпус. модель вознаграждениямодель вознагражденияEN reward model в RLHF (обучении с подкреплением по оценкам людей) учится предсказывать, какой из двух ответов человек сочтёт лучшим. А сама генерация текста — это классификация на 150 тысяч классов: какой токен будет следующим.

В прошлом уроке линейная модель предсказывала число. Теперь нам нужна вероятность класса. Рецепт простой: берём ту же $x^\top w + b$, пропускаем через сигмоиду и получаем логистическую регрессиюлогистическая регрессияEN logistic regressionНесмотря на название, это метод классификации. У Чжоу Чжихуа («арбузная книга») — «регрессия логарифма шансов», у Ли Хана («Методы статистического обучения») — фонетическая запись английского слова logistic.. Через softmax — softmax-регрессию для многих классов. Это однослойная нейросеть, и она в точности совпадает с последним слоем любой языковой модели.

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

Обязательное ядро: сигмоида и её таблица, логит и шансы на примере фильтра страниц, бинарная cross-entropy и её таблица, градиент «предсказание минус правда», граница решения, softmax-регрессия на числах. На них построены задание и квиз. Вывод устойчивой формулы loss, абзац про обобщённые линейные модели, разделы про LM head и «Китайский угол» при первом чтении можно пробежать: из устойчивой формулы достаточно правила «в loss передают логиты», а LLM-разделы — анонс ступеней 4–6.

Слово «log» в этом уроке. Здесь и дальше $\log$ — натуральный логарифм $\ln$ с основанием $e \approx 2.718$ (урок 1.0.2). Так принято в ML-статьях; в Python это np.log.

Почему не взять линейную регрессию

Можно обучить линейную регрессию на метках 0 и 1 и резать по порогу 0.5. Но выходы вида 1.7 или $-0.3$ — не вероятности. Хуже другое: MSE штрафует даже «слишком правильные» ответы. Очевидно математическая страница с прогнозом 3.0 вместо 1 даёт ошибку $2^2 = 4$ и тянет прямую к себе. Граница решения сдвигается из-за примеров, с которыми и так всё ясно. Нужна функция, которая сжимает любое число в интервал $(0, 1)$.

Сигмоида: из числа — вероятность

Сигмоидасигмоида (логистическая функция)EN sigmoid (logistic function)σ(z) = 1 / (1 + e^(−z)) — превращает любое число в вероятность от 0 до 1. — именно такая функция. Вы встречали её в уроках 1.0.1 и 1.2.1:

$$\sigma(z) = \frac{1}{1 + e^{-z}}$$

Почему результат всегда между 0 и 1: $e^{-z}$ — положительное число, поэтому знаменатель больше единицы, а дробь меньше единицы. При большом $z$ экспонента $e^{-z}$ почти ноль, и $\sigma \approx 1$; при большом отрицательном $z$ экспонента огромна, и $\sigma \approx 0$. Пример: $\sigma(1) = 1 / (1 + e^{-1}) = 1 / (1 + 0.368) \approx 0.731$.

$z$	$-4$	$-2$	$-1$	0	1	2	4
$\sigma(z)$	0.018	0.119	0.269	0.5	0.731	0.881	0.982

Свойства, которые понадобятся:

• $\sigma(0) = 0.5$ и $\sigma(-z) = 1 - \sigma(z)$ — кривая симметрична;
• $\sigma'(z) = \sigma(z)(1 - \sigma(z))$ — производная выражается через само значение (урок 1.2.1). Максимум производной — $0.25$ в нуле; при $\lvert z \rvert > 5$ она почти ноль: сигмоида насыщается.

Модель логистической регрессии:

$$p = P(y = 1 \mid x) = \sigma(x^\top w + b)$$

Логит и шансы

Обратим сигмоиду. Если $p = \sigma(z)$, то

$$z = \log \frac{p}{1 - p}$$

Отношение $p / (1 - p)$ — это шансы (odds), как у букмекеров: при $p = 0.8$ шансы $0.8 / 0.2 = 4$, «4 к 1». Значит, $z$ — логарифм шансов, или логитлогитEN logitСтрого — логарифм шансов log(p / (1 − p)). В нейросетях логитами называют любые выходы до softmax или сигмоиды.. Проверка на числах: $\log 4 \approx 1.386$, и $\sigma(1.386) = 1 / (1 + e^{-1.386}) = 1 / (1 + 0.25) = 0.8$ — вернулись к исходной вероятности. Логистическая регрессия утверждает простую вещь: логарифм шансов линейно зависит от признаков.

Отсюда понятный смысл весов. Рост признака $x_j$ на единицу прибавляет $w_j$ к логиту, то есть умножает шансы в $e^{w_j}$ раз: прибавить к логарифму $w_j$ — значит умножить само число на $e^{w_j}$ (урок 1.0.2).

Пример: фильтр математических страниц. Пусть у страницы два признака: $x_1$ — доля цифр и формульных символов, $x_2$ — сколько раз встретились слова «теорема», «доказательство», «уравнение». Допустим, модель обучилась так:

$$z = -4 + 8 x_1 + 1.5 x_2$$

• Страница A: $x_1 = 0.30$, $x_2 = 2$. Тогда $z = -4 + 2.4 + 3 = 1.4$ и $p = \sigma(1.4) \approx 0.80$.
• Страница B: $x_1 = 0.05$, $x_2 = 0$. Тогда $z = -3.6$ и $p \approx 0.027$.
• Каждое ключевое слово умножает шансы в $e^{1.5} \approx 4.5$ раза. Проверим на странице A: её шансы $0.8 / 0.2 = 4$. Добавим ещё одно ключевое слово: $z = 1.4 + 1.5 = 2.9$, $p = \sigma(2.9) \approx 0.948$, шансы $0.948 / 0.052 \approx 18$ — ровно в 4.5 раза больше.

Функция потерь: бинарная cross-entropy

Метка $y \in \lbrace 0, 1 \rbrace$ — это бросок монетки с вероятностью $p$, то есть распределение Бернуллираспределение БернуллиEN Bernoulli distributionВеличина принимает 1 с вероятностью p и 0 с вероятностью 1 − p. Пример — награда «верно/неверно». (урок 1.3.1). Его записывают одной формулой: $P(y) = p^{y} (1 - p)^{1 - y}$. При $y = 1$ остаётся $p$, при $y = 0$ — $1 - p$. Дальше — метод максимального правдоподобия из урока 1.3.2: берём логарифм, ставим минус, усредняем по примерам и получаем бинарную cross-entropy (BCE)бинарная перекрёстная энтропия (BCE)EN binary cross-entropy (BCE), log loss:

$$L = -\frac{1}{n} \sum_{i=1}^{n} \Big[ y_i \log p_i + (1 - y_i) \log (1 - p_i) \Big]$$

Это обычная перекрёстная энтропияперекрёстная энтропияEN cross-entropy для двух классов. Для каждого примера работает только одно слагаемое: $-\log p$, если $y = 1$, и $-\log(1 - p)$, если $y = 0$: второе слагаемое умножается на $1 - y = 0$ и пропадает.

Пример на двух страницах. Первая математическая ($y = 1$), модель дала $p = 0.9$: потери $-\log 0.9 \approx 0.105$. Вторая обычная ($y = 0$), модель дала $p = 0.2$: потери $-\log(1 - 0.2) = -\log 0.8 \approx 0.223$. Средняя BCE — $(0.105 + 0.223) / 2 \approx 0.164$.

Модель дала $p$	Loss, если $y = 1$	Loss, если $y = 0$
0.99	0.01	4.61
0.9	0.105	2.30
0.5	0.693	0.693
0.1	2.30	0.105
0.01	4.61	0.01

Уверенная ошибка стоит очень дорого: при $p \to 0$ и $y = 1$ потери уходят в бесконечность.

Градиент: та же форма, что у линейной регрессии

Продифференцируем потери одного примера по логиту $z$. Цепное правило (урок 1.2.2): производная loss по $p$, умноженная на производную $p$ по $z$, а последняя для сигмоиды равна $\sigma' = p(1 - p)$:

$$\frac{\partial L}{\partial z} = \left( -\frac{y}{p} + \frac{1 - y}{1 - p} \right) \cdot p(1 - p) = p - y$$

Всё сократилось до «предсказание минус правда». Например, модель дала $p = 0.9$ при $y = 1$: градиент $-0.1$, логит нужно чуть-чуть поднять. При $y = 0$ градиент был бы $0.9$: логит надо сильно опустить. Дальше $z = x^\top w + b$, поэтому

$$\nabla_w L = \frac{1}{n} X^\top (p - y), \qquad \frac{\partial L}{\partial b} = \frac{1}{n} \sum_i (p_i - y_i)$$

Сравните с линейной регрессией: там было $\frac{2}{n} X^\top (\hat y - y)$. Та же схема — признаки, взвешенные ошибками. Это не совпадение. (Для любознательных.) В обоих случаях loss — отрицательное лог-правдоподобие «своего» распределения: гауссовского для чисел, Бернулли для меток 0/1. А выходная функция (тождественная или сигмоида) подобрана под это распределение. Такие согласованные пары «выход + loss» дают градиент вида «ошибка × признаки». В статистике всё это семейство называют обобщёнными линейными моделями (GLM).

Почему не MSE

Возьмём пример с $y = 1$, где модель уверенно ошиблась: $z = -4.6$, $p \approx 0.01$.

• BCE: $\partial L / \partial z = p - y \approx -0.99$. Сильный сигнал: «срочно исправляйся».
• MSE поверх сигмоиды: $\partial L / \partial z = 2(p - y) \cdot p(1 - p) \approx -0.0195$. В 50 раз слабее.

Множитель $p(1 - p)$ гасит градиент ровно тогда, когда модель ошибается сильнее всего. Вдобавок MSE поверх сигмоиды невыпукла по $w$, а BCE выпуклавыпуклая функцияEN convex function«Чаша» без ложных ям — любой локальный минимум глобальный. Отрезок между двумя точками графика лежит не ниже графика. (урок 1.4.1): ложных локальных минимумов у неё нет.

Устойчивая реализация

Наивный код -np.log(sigmoid(z)) ломается при $z = -1000$: сигмоида округляется до 0 (компьютер хранит дробные числа с ограниченной точностью, урок 0.0.2), и $\log 0 = -\infty$. Как и в уроке 1.3.2, считаем потери сразу по логиту.

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

1. $-\log \sigma(z) = \log(1 + e^{-z})$ и $-\log(1 - \sigma(z)) = -\log \sigma(-z) = \log(1 + e^{z})$.
2. Подставляем в BCE и пользуемся тем, что $\log(1 + e^{-z}) = \log(1 + e^{z}) - z$: $L = y \log(1 + e^{-z}) + (1 - y) \log(1 + e^{z}) = \log(1 + e^{z}) - y z$.
3. Осталось устойчиво посчитать $\log(1 + e^{z})$. При $z \le 0$ экспонента и так не больше единицы. При $z > 0$ выносим $e^{z}$ за скобку: $\log(1 + e^{z}) = z + \log(1 + e^{-z})$. Обе ветки записываются одной формулой:

$$L(z, y) = \max(z, 0) - y z + \log\left(1 + e^{-\lvert z \rvert}\right)$$

Экспонента берётся только от $-\lvert z \rvert \le 0$, переполнения нет. Проверка: при $z = 1000$ и $y = 0$ loss равен $1000 - 0 + \log(1 + e^{-1000}) \approx 1000$ — огромный, но конечный штраф за уверенную ошибку. В PyTorch это F.binary_cross_entropy_with_logits (или nn.BCEWithLogitsLoss). Правило то же, что для softmax: в loss передают логиты, а не вероятности.

Граница решения

Класс 1 предсказываем, если $p \ge 0.5$. Поскольку $\sigma(z) \ge 0.5 \iff z \ge 0$, условие превращается в

$$x^\top w + b \ge 0$$

Множество точек, где $x^\top w + b = 0$, — граница решенияграница решенияEN decision boundary. В двумерном случае это прямая, в трёхмерном — плоскость, в $d$-мерном — гиперплоскость (так называют такую же «ровную перегородку» в пространстве любой размерности). В примере с фильтром граница — прямая $-4 + 8 x_1 + 1.5 x_2 = 0$. Страница совсем без цифр ($x_1 = 0$) пройдёт фильтр, только если в ней хотя бы 3 ключевых слова: при двух $p = 0.27$, при трёх $p = 0.62$.

Фильтр математических страниц z = −4 + 8x₁ + 1.5x₂. Сплошная прямая — граница решения (z = 0, p = 0.5); выше и правее неё — класс «математика». Пунктиры — линии p = 0.2 и p = 0.8: все линии равной вероятности параллельны границе. Полые кружки — страницы без цифр с двумя и тремя ключевыми словами.

Отсюда три важных следствия.

1. Логистическая регрессия — линейный классификатор. Если классы нельзя разделить прямой, она бессильна. Классический пример — XOR: класс 1, если ровно один из двух признаков равен 1. Всего четыре точки: $(0, 0)$ и $(1, 1)$ — класс 0, $(0, 1)$ и $(1, 0)$ — класс 1. Нарисуйте их на листке: классы стоят «крест-накрест», и никакая прямая не оставит обе единицы с одной стороны, а оба нуля — с другой. Вот почему. Пусть прямая оставила точки $(0, 1)$ и $(1, 0)$ по одну сторону. Тогда там же и середина отрезка между ними, $(0.5, 0.5)$. Но это и середина отрезка между $(0, 0)$ и $(1, 1)$, так что хотя бы одна из этих точек тоже окажется на той же стороне. Нужны скрытые слои с нелинейностью — это урок 3.1.1.
2. Норма весов — это уверенность. Умножьте $w$ и $b$ на 10: граница не сдвинется, но сигмоида станет почти ступенькой. На рисунке пунктиры $p = 0.2$ и $p = 0.8$ прижмутся к границе в 10 раз ближе.
3. На линейно разделимых данных веса растут бесконечно. Loss можно уменьшать вечно, увеличивая $\lVert w \rVert$. Спасают регуляризациярегуляризацияEN regularization (L2) и ранняя остановка из урока 2.1.2.

Порог 0.5 — не закон природы. Для фильтра, который не должен пропускать мусор, порог поднимают — например, до 0.8. Как выбирать порог и чем мерить результат — в следующем уроке.

Много классов: softmax-регрессия

Теперь классов $K$, например «код», «математика», «проза». Заводим по линейной модели на каждый класс: каждая выдаёт свой логит — «балл» своего класса. Веса всех $K$ моделей складываем в матрицу $W \in \mathbb{R}^{K \times d}$ (строка на класс), сдвиги — в вектор $b \in \mathbb{R}^{K}$. Логиты превращаем в вероятности через softmax из урока 1.3.2: $\mathrm{softmax}(z)_k = e^{z_k} / \sum_j e^{z_j}$ — каждую экспоненту делим на их сумму, и вероятности в сумме дают 1. Потери — минус логарифм вероятности правильного класса $y$:

$$z = W x + b, \qquad p = \mathrm{softmax}(z), \qquad L = -\log p_{y}$$

Это softmax-регрессияsoftmax-регрессия (многоклассовая логистическая регрессия)EN softmax regression (multinomial logistic regression). Градиент по логитам вы уже выводили в уроке 1.3.2. Это снова «предсказание минус правда», только теперь правда — one-hot вектор:

$$\begin{gathered} \frac{\partial L}{\partial z} = p - \mathrm{onehot}(y), \\ \nabla_W L = (p - \mathrm{onehot}(y)) \, x^\top, \\ \nabla_b L = p - \mathrm{onehot}(y) \end{gathered}$$

Здесь $\mathrm{onehot}(y)$ — one-hot векторone-hot кодирование (унитарный код)EN one-hot encodingВектор длины V из нулей с единицей в позиции номера токена. Все one-hot векторы попарно ортогональны.: единица на месте правильного класса, нули на остальных местах. Градиент по $W$ — внешнее произведение (урок 1.1.2): матрица $K \times d$, такая же, как $W$. Для батча из $n$ примеров градиенты усредняют, как в бинарном случае.

На числах: логиты $z = [2.0, 1.0, 0.1]$, правильный класс — второй. Softmax даёт $p = [0.659, 0.242, 0.099]$, loss $= -\ln 0.242 = 1.42$. Градиент: $[0.659, -0.758, 0.099]$. Логит правильного класса тянем вверх, остальные — вниз, и тем сильнее, чем больше вероятность они «украли».

Логистическая регрессия — частный случай softmax

При $K = 2$ softmax зависит только от разности логитов:

$$\mathrm{softmax}(z_0, z_1)_1 = \frac{e^{z_1}}{e^{z_0} + e^{z_1}} = \frac{1}{1 + e^{-(z_1 - z_0)}} = \sigma(z_1 - z_0)$$

Например, $z = [0.3, 1.7]$ даёт $0.802$ в обоих вариантах. Бинарная модель с одним логитом — та же softmax-регрессия, просто без лишнего параметра.

Softmax или сигмоида на каждый класс? Softmax подходит, когда правильный класс ровно один. Вероятности конкурируют: если одна растёт, остальные падают, а в сумме всегда 1. Но страница может быть одновременно и кодом, и математикой. Когда классы не исключают друг друга (multi-label), берут $K$ независимых сигмоид и BCE на каждом выходе. Получается $K$ отдельных логистических регрессий. Например, логиты $[2.0, 1.5, -1.0]$ через сигмоиды дают $[0.88, 0.82, 0.27]$: «код — да, математика — да, проза — нет». Softmax от тех же логитов дал бы $[0.60, 0.37, 0.03]$ и заставил бы классы делить единицу. Этот выбор вы встретите в китайском углу ниже.

Однослойная нейросеть — и выходной слой LLM

flowchart LR
X["Признаки x<br/>(d чисел)"] --> L["Linear: z = Wx + b<br/>W: K × d"]
L --> S["softmax"]
S --> P["p₁ … p_K"]
P --> CE["Loss = −log p_y"]
H["Скрытое состояние h<br/>трансформера"] -.->|"в LLM вместо x"| L

Softmax-регрессия — это однослойная нейросеть. В LLM на её вход подают выход трансформера

Softmax-регрессия — это нейронная сетьнейронная сетьEN neural network из одного линейного слоя без скрытых слоёв. Теперь посмотрите на LLM. Трансформер превращает контекст в вектор $h$ размерности $d_{\text{model}}$. Последний слой — LM headLM-голова (языковая голова)EN LM head (language modeling head)Последний линейный слой GPT: превращает вектор ширины d в V логитов, по одному на токен словаря. Часто делит матрицу с эмбеддингами (weight tying). — считает $z = W_{\text{out}} h$: логиты по всему словарю, а дальше softmax и cross-entropy.

Это softmax-регрессия с $V$ классами (по классу на каждый токен словаря). Её признаки $h$ не заданы вручную, а обучаются вместе с ней. Возьмём размеры Qwen3-8B: длина вектора $h$ — $d_{\text{model}} = 4096$ чисел, словарь $V = 151\,936$ токенов. Одна матрица $W_{\text{out}}$ размера $V \times d_{\text{model}}$ содержит $4096 \cdot 151\,936 \approx 622$ млн параметров.

Ещё два места, где вы встретите эту конструкцию:

• Биграммная модель из урока 4.1.2 — это softmax-регрессия, у которой признак — one-hot вектор предыдущего токена.
• Линейный зонд (linear probe). Берут скрытые состояния замороженной LLM и учат на них логистическую регрессию. Если зонд справляется, нужная информация линейно закодирована внутри модели. Это базовый инструмент интерпретируемости (его возможности и ловушки — в уроке 9.3.1).

Где сигмоида встретится дальше

Это анонс: запоминать названия сейчас не нужно, просто узнайте сигмоиду, когда встретите её снова. Модель Брэдли–Терри в reward model: $P(\text{A лучше B}) = \sigma(r_A - r_B)$ — это логистическая регрессия на разности оценок. Loss DPO — тоже $-\log \sigma(\dots)$. Оба разберём в модуле 6.3. Активация SiLU в SwiGLU — это $x \cdot \sigma(x)$ (урок 4.5.3). Роутеры MoE — в модуле 5.3.

Практика

Реализуйте логистическую регрессию на NumPy: устойчивую сигмоиду, BCE по логитам, градиенты, обучение и предсказание с порогом. Тесты проверят устойчивость на $z = \pm 1000$ и accuracy ≥ 95% на двух «облаках» точек. Структура та же, что в задании прошлого урока: fit_logreg почти дословно повторяет fit_gd, меняются только градиенты и функция потерь.

Логистическая регрессия с нуляnumpy · нужен интернет7 тестов

import numpy as np


def sigmoid(z):
    """Сигмоида σ(z) = 1 / (1 + e^(−z)) поэлементно для массива z.

    Должна работать без переполнения и nan даже для z = ±1000.
    Подсказка: для z ≥ 0 берите 1 / (1 + e^(−z)), для z < 0 — e^z / (1 + e^z).
    Осторожно: np.where вычисляет ОБЕ ветки для всех элементов, поэтому
    np.exp(-z) и np.exp(z) по отдельности всё равно переполнятся. Подумайте,
    как обойтись одной экспонентой от −|z| (она всегда не больше 1).
    """
    # TODO
    ...


def bce_with_logits(z, y):
    """Средняя бинарная cross-entropy, посчитанная прямо по логитам z (без вызова sigmoid).

    Для одного примера: −[y·log σ(z) + (1 − y)·log(1 − σ(z))].
    Устойчивая форма той же величины: max(z, 0) − y·z + log(1 + e^(−|z|)).
    Возвращает число (float) — среднее по всем примерам.
    """
    # TODO
    ...


def gradients(X, y, w, b):
    """Градиенты средней BCE по w и b для логистической регрессии.

    p = σ(X·w + b);  dL/dw = Xᵀ(p − y) / n;  dL/db = mean(p − y).
    Возвращает (dw, db).
    """
    # TODO
    ...


def fit_logreg(X, y, lr=0.5, steps=500):
    """Обучает логистическую регрессию градиентным спуском из нулей.

    Возвращает (w, b, history), где history — список средних BCE после каждого шага.
    """
    # TODO
    ...


def predict(X, w, b, threshold=0.5):
    """Метки классов 0/1: 1, если σ(X·w + b) ≥ threshold. Возвращает массив int."""
    # TODO
    ...


# Проверьте себя кнопкой «Запустить»:
print(sigmoid(np.array([-2.0, 0.0, 2.0])))                    # ≈ [0.1192 0.5 0.8808]
print(bce_with_logits(np.array([0.0, 0.0]), np.array([1.0, 0.0])))  # ln 2 ≈ 0.6931

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

Softmax-регрессия на PyTorch (локально)

Классифицируем страницы на три класса по двум признакам. Признаки — доля «кодовых» символов и доля цифр и формул:

import torch
import torch.nn.functional as F

torch.manual_seed(0)
# Синтетика: 2 признака страницы — доля «кодовых» символов ({}();=) и доля цифр/формул
centers = torch.tensor([[0.30, 0.05],    # 0: код
                        [0.05, 0.30],    # 1: математика
                        [0.03, 0.03]])   # 2: обычная проза
# по 200 точек вокруг каждого центра (центр + шум), склеенные в одну таблицу
X = torch.cat([c + 0.07 * torch.randn(200, 2) for c in centers])   # (600, 2)
y = torch.arange(3).repeat_interleave(200)                          # метки: 200 нулей, 200 единиц, 200 двоек

model = torch.nn.Linear(2, 3)        # W: (3, 2), b: (3,) — вот и вся «нейросеть»
opt = torch.optim.SGD(model.parameters(), lr=5.0)
for step in range(300):
    logits = model(X)                    # (600, 3): три логита на каждую страницу
    loss = F.cross_entropy(logits, y)    # softmax + NLL в одной устойчивой функции
    opt.zero_grad()                      # стандартные три строки шага обучения (урок 1.4.1)
    loss.backward()
    opt.step()
# argmax(dim=1) — номер класса с наибольшим логитом в каждой строке; сравниваем с правильными метками
acc = (model(X).argmax(dim=1) == y).float().mean()
print(f"loss = {loss.item():.3f}, accuracy = {acc:.3f}")

page = torch.tensor([[0.20, 0.12]])      # немного кода, немного формул
# softmax превращает 3 логита в 3 вероятности; tolist() — в обычный список Python
print("p(код, математика, проза) =", [round(p, 3) for p in F.softmax(model(page), dim=1).squeeze().tolist()])

# Бинарный случай: softmax по двум логитам = сигмоида от их разности
z = torch.tensor([0.3, 1.7])
print(f"{F.softmax(z, dim=0)[1].item():.4f} {torch.sigmoid(z[1] - z[0]).item():.4f}")

Ожидаемый вывод (последние знаки могут отличаться в другой версии PyTorch):

loss = 0.158, accuracy = 0.955
p(код, математика, проза) = [0.648, 0.173, 0.18]
0.8022 0.8022

Обратите внимание: F.cross_entropy принимает логиты, а не вероятности. Если подать в неё результат softmax, softmax применится дважды — классическая ошибка (о ней подробно в уроке 3.3.3). Шаг lr=5.0 большой, потому что признаки маленькие (сотые доли). Попробуйте стандартизировать их, как в прошлом уроке, и обойтись lr=0.5.

Китайский угол: линейный классификатор собрал 120B токенов математики

Здесь много терминов из будущих ступеней (GRPO, MoE, роутер, внимание). Читайте этот блок как анонс: важно лишь увидеть, что модели из этого урока работают внутри настоящих китайских LLM.

DeepSeekMath (arXiv:2402.03300) — работа, где впервые описан GRPOGRPO (групповая относительная оптимизация политики)EN Group Relative Policy Optimization (GRPO)PPO без критика: на промпт генерируется группа из G ответов, преимущество — (r − среднее) / std по группе. DeepSeekMath, 2024.. Но половина успеха — данные. Авторы собрали DeepSeekMath Corpus на 120 млрд токенов из Common Crawl. Отбирал страницы классификатор fastText, обученный сначала на примерах из OpenWebMath. Процесс шёл итеративно: найденные страницы расширяли обучающий набор, классификатор переобучали, и он находил больше. fastText — по сути softmax-регрессия над усреднёнными эмбеддингами слов и n-грамм. Модель из этого урока, только на миллиардах веб-страниц. Фильтрацию данных подробно разберём в уроке 5.1.2.

DeepSeek-V3 (arXiv:2412.19437): в роутеремаршрутизатор (роутер), гейтEN router / gating network экспертов MoE близость токена к эксперту считают сигмоидой, а не softmax, как было в DeepSeek-V2. Сигмоида оценивает каждого эксперта независимо — как отдельная логистическая регрессия «подходит / не подходит». Нормировка идёт уже среди выбранных top-K. Подробно — в модуле 5.3.

Сигмоида как гейт. В gated attentionвнимание с выходным гейтом (gated attention)EN gated attentionПосле softmax-внимания выход каждой головы поэлементно умножается на сигмоидный гейт σ(xW). Убирает attention sink; работа Qwen — лучшая статья NeurIPS 2025. от Qwen (arXiv:2505.06708) после внимания стоит сигмоидный гейт. Он добавляет нелинейность и убирает attention sink. Этот приём лежит в основе Qwen3-Next и Qwen3.5.

Терминология. Самое частое китайское название логистической регрессии буквально значит «логическая регрессия»: слово «логистическая» при переводе спутали со словом «логика». В «Арбузной книге» Чжоу Чжихуа она называется «регрессией логарифма шансов» — то есть ровно то, что мы вывели в разделе про логит. Автор специально подчёркивает: несмотря на слово «регрессия», это метод классификации. В книге Ли Хана «Методы статистического обучения» название просто передаёт звучание английского logistic. Вывод формул по шагам — в «Тыквенной книге», глава 3.

Проверь себя

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

1 Логит примера равен $\ln 3 \approx 1.0986$. Какую вероятность класса 1 даёт логистическая регрессия?

2 Чему равна производная бинарной cross-entropy по логиту $z$ для одного примера?

$p(1 - p)$$p - y$$2(p - y)$$-\log p$

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

Граница решения логистической регрессии — гиперплоскость $x^\top w + b = 0$Логистическая регрессия на исходных признаках $x_1, x_2$ решает XORSoftmax-регрессия с двумя классами эквивалентна логистической: $p_1 = \sigma(z_1 - z_0)$На линейно разделимых данных без регуляризации норма весов растёт неограниченно

4 Почему для классификации берут BCE, а не MSE поверх сигмоиды?

MSE нельзя продифференцироватьС MSE градиент содержит множитель $p(1-p)$ и почти исчезает, когда модель уверенно ошибается; к тому же loss невыпуклыйBCE считается быстрееMSE не работает с NumPy

5 LM head модели: $d_{\text{model}} = 2048$, словарь $V = 32\,000$, без сдвига. Сколько миллионов параметров в этой матрице? (до одного знака)

6 Как называется величина $\log \frac{p}{1 - p}$? (одно слово)

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

Итоги

• Логистическая регрессия: $p = \sigma(x^\top w + b)$. Логит — логарифм шансов, и он линеен по признакам.
• Потери — бинарная cross-entropy (MLE для распределения Бернулли). Градиент по логиту — $p - y$. Считайте loss по логитам: BCEWithLogitsLoss.
• Граница решения — гиперплоскость. Поэтому модель линейна и не решает XOR.
• Softmax-регрессия: $p = \mathrm{softmax}(Wx + b)$, градиент $p - \mathrm{onehot}(y)$. Это однослойная нейросеть и в точности LM head любой LLM.

Логистическую регрессию с нуля вы соберёте ещё раз, уже как самостоятельный проект с автотестами, в домашней работе s2-hw01-logreg-from-scratch в конце ступени 2.

Дальше: метрики качества. Accuracy, precision, recall, F1 и ROC-AUC — и почему метрика, которую вы показываете людям, почти никогда не совпадает с loss, который минимизирует модель.