Формулы математического анализа для ML¶

~5 минут чтения

Предварительно: Подготовка к интервью по математике

Математический анализ -- механизм обучения каждой нейросети. Backpropagation -- это chain rule, применённый к вычислительному графу: GPT-4 вычисляет ~1.8 триллиона частных производных за один backward pass. Gradient descent -- итеративное применение формулы theta = theta - lr * grad(L). Знание производных активаций (sigmoid'(x) = sigma(x)(1-sigma(x))) критично для понимания vanishing gradients: при 50 слоях с sigmoid градиент уменьшается в (0.25)^50 раз. Вопросы на вывод градиентов MSE, Cross-Entropy и Softmax+CE встречаются на 50%+ ML-интервью. Log-sum-exp trick предотвращает numerical overflow в softmax -- без него модель крашится на logits > 700.

Производные¶

Основные правила¶

\[\frac{d}{dx}[cf(x)] = c \cdot f'(x)\]

\[\frac{d}{dx}[f(x) + g(x)] = f'(x) + g'(x)\]

\[\frac{d}{dx}[f(x) \cdot g(x)] = f'(x)g(x) + f(x)g'(x)\]

\[\frac{d}{dx}\left[\frac{f(x)}{g(x)}\right] = \frac{f'(x)g(x) - f(x)g'(x)}{[g(x)]^2}\]

Chain Rule¶

\[\frac{d}{dx}[f(g(x))] = f'(g(x)) \cdot g'(x)\]

Базовые производные¶

Функция	Производная
\(x^n\)	\(nx^{n-1}\)
\(e^x\)	\(e^x\)
\(a^x\)	\(a^x \ln a\)
\(\ln x\)	\(\frac{1}{x}\)
\(\log_a x\)	\(\frac{1}{x \ln a}\)
\(\sin x\)	\(\cos x\)
\(\cos x\)	\(-\sin x\)
\(\tan x\)	\(\sec^2 x = \frac{1}{\cos^2 x}\)

Производные для ML¶

Sigmoid¶

\[\sigma(x) = \frac{1}{1 + e^{-x}}\]

\[\sigma'(x) = \sigma(x)(1 - \sigma(x))\]

Tanh¶

\[\tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}\]

\[\tanh'(x) = 1 - \tanh^2(x)\]

ReLU¶

\[\text{ReLU}(x) = \max(0, x)\]

\[\text{ReLU}'(x) = \begin{cases} 1 & x > 0 \\ 0 & x \leq 0 \end{cases}\]

Leaky ReLU¶

\[f(x) = \max(\alpha x, x)\]

\[f'(x) = \begin{cases} 1 & x > 0 \\ \alpha & x \leq 0 \end{cases}\]

Softplus¶

\[f(x) = \ln(1 + e^x)\]

\[f'(x) = \frac{e^x}{1 + e^x} = \sigma(x)\]

GELU (приближение)¶

\[\text{GELU}(x) \approx 0.5x\left(1 + \tanh\left[\sqrt{\frac{2}{\pi}}(x + 0.044715x^3)\right]\right)\]

Log¶

\[\frac{d}{dx}\ln(f(x)) = \frac{f'(x)}{f(x)}\]

Частные производные¶

Градиент¶

\[\nabla f = \left(\frac{\partial f}{\partial x_1}, \frac{\partial f}{\partial x_2}, ..., \frac{\partial f}{\partial x_n}\right)\]

Направление наибольшего роста¶

\[\nabla f\]

указывает в направлении наибольшего роста функции

Производная по направлению¶

\[D_{\mathbf{u}}f = \nabla f \cdot \mathbf{u} = |\nabla f| \cos\theta\]

Градиенты для Loss функций¶

MSE¶

\[L = \frac{1}{n}\sum_{i=1}^n(y_i - \hat{y}_i)^2\]

\[\frac{\partial L}{\partial \hat{y}_i} = \frac{2}{n}(\hat{y}_i - y_i)\]

Cross-Entropy¶

\[L = -\sum_i y_i \log(\hat{y}_i)\]

\[\frac{\partial L}{\partial \hat{y}_i} = -\frac{y_i}{\hat{y}_i}\]

Binary Cross-Entropy¶

\[L = -[y\log(\hat{y}) + (1-y)\log(1-\hat{y})]\]

\[\frac{\partial L}{\partial \hat{y}} = -\frac{y}{\hat{y}} + \frac{1-y}{1-\hat{y}} = \frac{\hat{y} - y}{\hat{y}(1-\hat{y})}\]

Softmax + Cross-Entropy¶

\[L = -\log\left(\frac{e^{z_k}}{\sum_j e^{z_j}}\right)\]

\[\frac{\partial L}{\partial z_i} = p_i - y_i\]

где \(p_i = \text{softmax}(z_i)\), \(y\) — one-hot

Гессиан¶

Определение¶

\[\mathbf{H} = \nabla^2 f = \begin{pmatrix} \frac{\partial^2 f}{\partial x_1^2} & \frac{\partial^2 f}{\partial x_1 \partial x_2} \\ \frac{\partial^2 f}{\partial x_2 \partial x_1} & \frac{\partial^2 f}{\partial x_2^2} \end{pmatrix}\]

Условие минимума¶

\(\nabla f = 0\) (стационарная точка)
\(\mathbf{H}\) положительно определена (локальный минимум)

Условие седловой точки¶

\(\nabla f = 0\)
\(\mathbf{H}\) имеет разные знаки собственных значений

Оптимизация¶

Gradient Descent¶

\[\theta_{t+1} = \theta_t - \alpha \nabla L(\theta_t)\]

Newton's Method¶

\[\theta_{t+1} = \theta_t - \mathbf{H}^{-1} \nabla L(\theta_t)\]

Taylor Expansion (первый порядок)¶

\[f(x + \Delta x) \approx f(x) + \nabla f(x)^T \Delta x\]

Taylor Expansion (второй порядок)¶

\[f(x + \Delta x) \approx f(x) + \nabla f(x)^T \Delta x + \frac{1}{2}\Delta x^T \mathbf{H} \Delta x\]

Интегралы¶

Основные¶

\[\int x^n dx = \frac{x^{n+1}}{n+1} + C\]

\[\int e^x dx = e^x + C\]

\[\int \frac{1}{x} dx = \ln|x| + C\]

Гауссов интеграл¶

\[\int_{-\infty}^{\infty} e^{-x^2} dx = \sqrt{\pi}\]

\[\int_{-\infty}^{\infty} e^{-\frac{(x-\mu)^2}{2\sigma^2}} dx = \sigma\sqrt{2\pi}\]

Гамма-функция¶

\[\Gamma(n) = \int_0^{\infty} x^{n-1}e^{-x}dx = (n-1)!\]

Backpropagation¶

Chain Rule для композиций¶

\[\frac{\partial L}{\partial x} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial x}\]

Для нескольких путей¶

\[\frac{\partial L}{\partial x} = \sum_i \frac{\partial L}{\partial y_i} \cdot \frac{\partial y_i}{\partial x}\]

Пример: Dense Layer¶

\[y = Wx + b\]

\[\frac{\partial L}{\partial W} = \frac{\partial L}{\partial y} \cdot x^T\]

\[\frac{\partial L}{\partial x} = W^T \cdot \frac{\partial L}{\partial y}\]

\[\frac{\partial L}{\partial b} = \frac{\partial L}{\partial y}\]

Полезные тождества¶

Производная softmax¶

\[\frac{\partial \text{softmax}(z)_i}{\partial z_j} = \text{softmax}(z)_i \cdot (\delta_{ij} - \text{softmax}(z)_j)\]

где \(\delta_{ij}\) — дельта Кронекера

Log-sum-exp trick¶

\[\log\sum_i e^{x_i} = c + \log\sum_i e^{x_i - c}\]

где \(c = \max_i x_i\) (для численной стабильности)

Производная log-softmax¶

\[\frac{\partial \log\text{softmax}(z)_i}{\partial z_j} = \delta_{ij} - \text{softmax}(z)_j\]

Типичные заблуждения¶

Заблуждение: градиент softmax + cross-entropy сложный

Отдельно производная softmax -- матрица Якоби p_i * (delta_ij - p_j). Отдельно производная CE -- (-y_i / p_i). Но их композиция элегантно упрощается до dL/dz_i = p_i - y_i. Это одна из причин, почему CE используется именно с softmax: простой градиент, быстрый backward. Если на интервью вас просят вывести градиент -- выводите сразу для пары, не по отдельности.

Заблуждение: ReLU не дифференцируем, значит gradient descent не работает

ReLU не дифференцируем в одной точке x=0. На практике вероятность попасть ровно в 0 при float32 -- исчезающе мала. В PyTorch/TensorFlow для x=0 субградиент определён как 0. Это не мешает обучению: сходимость SGD доказана для субдифференцируемых функций. Настоящая проблема ReLU -- dying neurons (40--50% нейронов могут "умереть" при большом learning rate), что решается Leaky ReLU или PReLU.

Заблуждение: Newton's method всегда быстрее gradient descent

Метод Ньютона имеет квадратичную сходимость vs линейная у GD. Но вычисление Hessian стоит O(n^2) памяти и O(n^3) для инверсии, где n -- количество параметров. Для GPT-3 с 175B параметров Hessian занял бы ~10^20 float32 = 10^11 ТБ. Поэтому на практике используют приближения: L-BFGS (квази-ньютоновский, хранит ~10 последних градиентов), Adam (адаптивный lr с momentum), или natural gradient (использует Fisher information matrix).

Интервью¶

Выведите градиент Binary Cross-Entropy по предсказанию модели.

"dL/dy_hat = -y/y_hat ... или что-то такое"

"L = -[y * log(y_hat) + (1-y) * log(1-y_hat)]. Берём производную: dL/dy_hat = -y/y_hat + (1-y)/(1-y_hat). Приводим к общему знаменателю: = (-y(1-y_hat) + (1-y)y_hat) / (y_hat(1-y_hat)) = (y_hat - y) / (y_hat(1-y_hat)). Важно: если y_hat близко к 0 или 1, знаменатель стремится к 0 и градиент взрывается -- поэтому на практике используют BCEWithLogitsLoss, которая принимает logits до sigmoid и численно стабильна."

Почему для softmax используют log-sum-exp trick?

"Для скорости вычислений"

"Для численной стабильности, не скорости. softmax(z_i) = exp(z_i) / sum(exp(z_j)). Если max(z) = 1000, то exp(1000) = inf в float32 (overflow при z > 709). Trick: log(sum(exp(z_i))) = c + log(sum(exp(z_i - c))), где c = max(z). Вычитая c, все экспоненты <= 1, overflow невозможен. В PyTorch это реализовано в torch.nn.functional.log_softmax и CrossEntropyLoss. Без этого трика модель NaN-ится на logits > 700."

Объясните chain rule в контексте backpropagation.

"Это когда мы перемножаем производные слоёв"

"Chain rule: dL/dx = dL/dy * dy/dx. В нейросети с N слоями: dL/dW_1 = dL/dz_N * dz_N/dz_{N-1} * ... * dz_2/dz_1 * dz_1/dW_1. Это произведение Якобианов. Проблема: при sigmoid каждый множитель <= 0.25, после 50 слоёв градиент = (0.25)^50 ~ 10^{-30} -- vanishing gradient. Решения: ReLU (множитель = 1 для x>0), skip connections (ResNet -- добавляет единичную матрицу к Якобиану), нормализация (BatchNorm, LayerNorm). На практике autograd в PyTorch строит computational graph и применяет chain rule автоматически через .backward()."