Шпаргалка формул нейросетей

Сжимает любое число в интервал $(0;\,1)$, поэтому выход читается как вероятность. Кривая S-образная, симметрична относительно точки $(0;\,0{,}5)$; асимптоты — $y=0$ и $y=1$.

$\sigma(0)=0{,}5$, $\sigma(2)\approx0{,}881$, $\sigma(-2)\approx0{,}119$. Наклон максимален в нуле: $\sigma'(0)=0{,}25$, а уже $\sigma'(2)\approx0{,}105$.

def sigmoid(x):
    return 0.5 * (1 + np.tanh(0.5 * x))  # = 1 / (1 + e^-x), no overflow

def sigmoid_grad(x):
    s = sigmoid(x)
    return s * (1 - s)

Та же S-образная форма, но центрирована в нуле, а диапазон — $(-1;\,1)$. Функция нечётная: $\tanh(-x)=-\tanh(x)$.

$\tanh(1)\approx0{,}762$, $\tanh'(0)=1$ — в четыре раза круче сигмоиды в нуле, $\tanh'(1)\approx0{,}420$.

def tanh_grad(x):
    t = np.tanh(x)
    return 1 - t ** 2

Положительное пропускает как есть, отрицательное обнуляет. Считается дёшево, а справа от нуля градиент не затухает.

$\operatorname{ReLU}(-3)=0$, $\operatorname{ReLU}(2{,}5)=2{,}5$. В точке $x=0$ производной нет; библиотеки по соглашению берут $0$.

def relu(x):
    return np.maximum(0, x)

def relu_grad(x):
    return (x > 0).astype(float)

Как ReLU, но отрицательная часть не обнуляется, а умножается на маленький $\alpha$ (при $0<\alpha<1$). Лечит «умирающий ReLU».

При $\alpha=0{,}01$: $\operatorname{LReLU}(-3)=-0{,}03$, $\operatorname{LReLU}(2)=2$.

def leaky_relu(x, alpha=0.01):
    return np.where(x > 0, x, alpha * x)

Превращает вектор логитов (logits — сырых выходов сети) в распределение вероятностей: все $s_i\in(0;\,1)$, сумма равна 1. Стоит в конце многоклассового классификатора.

На практике из всех логитов вычитают максимум: $\dfrac{e^{x_i-\max x}}{\sum_j e^{x_j-\max x}}$. Результат тот же, а переполнения экспоненты нет.

Логиты $(2;\,1;\,0)$ дают вероятности $\approx(0{,}665;\,0{,}245;\,0{,}090)$.

def softmax(x):
    e = np.exp(x - x.max())
    return e / e.sum()

Средний модуль ошибки. Измеряется в тех же единицах, что и целевая переменная, и проще всего интерпретируется. К выбросам устойчивее, чем MSE.

Сквозной пример: $y=(3;\,5;\,8)$, $\hat{y}=(2{,}5;\,5;\,10)$, ошибки $y-\hat{y}=(0{,}5;\,0;\,-2)$. $\mathrm{MAE}=(0{,}5+0+2)/3\approx0{,}833$.

mae = np.mean(np.abs(y - y_hat))

Средний квадрат ошибки. Квадрат сильно штрафует крупные промахи. Единицы — квадрат единиц целевой переменной.

Сквозной пример: $y=(3;\,5;\,8)$, $\hat{y}=(2{,}5;\,5;\,10)$, ошибки $y-\hat{y}=(0{,}5;\,0;\,-2)$. $\mathrm{MSE}=(0{,}25+0+4)/3\approx1{,}417$: одна ошибка $-2$ даёт 94% суммы.

mse = np.mean((y - y_hat) ** 2)

Корень из MSE возвращает ошибку в единицы целевой переменной. Наглядна, как MAE, но по-прежнему сильнее наказывает крупные ошибки.

Сквозной пример: $y=(3;\,5;\,8)$, $\hat{y}=(2{,}5;\,5;\,10)$, ошибки $y-\hat{y}=(0{,}5;\,0;\,-2)$. $\mathrm{RMSE}=\sqrt{1{,}417}\approx1{,}190$ против $\mathrm{MAE}\approx0{,}833$.

rmse = np.sqrt(np.mean((y - y_hat) ** 2))

Ошибка в процентах от факта: «в среднем модель ошибается на MAPE %». Удобна, когда важна относительная, а не абсолютная ошибка.

Сквозной пример: $y=(3;\,5;\,8)$, $\hat{y}=(2{,}5;\,5;\,10)$, ошибки $y-\hat{y}=(0{,}5;\,0;\,-2)$. $\mathrm{MAPE}=\frac{100\%}{3}\bigl(\tfrac{0{,}5}{3}+0+\tfrac{2}{8}\bigr)\approx13{,}9\%$.

mape = 100 * np.mean(np.abs((y - y_hat) / y))

Возле нуля квадратична, как MSE (точная подстройка), на больших ошибках линейна, как MAE (не боится выбросов). Обе ветви и их производные сходятся в точке $|r|=\delta$.

Сквозной пример: $y=(3;\,5;\,8)$, $\hat{y}=(2{,}5;\,5;\,10)$, ошибки $y-\hat{y}=(0{,}5;\,0;\,-2)$. При $\delta=1$: потери $0{,}125$, $0$ и $1\cdot(2-0{,}5)=1{,}5$; среднее $\approx0{,}542$.

def huber(y, y_hat, delta=1.0):
    r = np.abs(y - y_hat)
    return np.mean(np.where(r <= delta, 0.5 * r ** 2,
                            delta * (r - 0.5 * delta)))

Для двух классов. Метка $y\in\{0,1\}$ работает как переключатель: из двух слагаемых остаётся одно, $-\log$ вероятности правильного ответа.

Правильный ответ $y=1$. Модель уверена и права, $\hat{y}=0{,}9$: потеря $-\ln0{,}9\approx0{,}105$. Уверена и ошибается, $\hat{y}=0{,}1$: $-\ln0{,}1\approx2{,}303$ — в 22 раза больше.

p = np.clip(y_hat, 1e-7, 1 - 1e-7)
bce = -np.mean(y * np.log(p)
               + (1 - y) * np.log(1 - p))

Для $K$ классов; $y$ — one-hot вектор (единица на месте правильного класса). В сумме выживает одно слагаемое — $-\log$ вероятности правильного класса.

Логиты $(2;\,1;\,0)$, правильный класс — первый. $s\approx(0{,}665;\,0{,}245;\,0{,}090)$, $\mathrm{CE}=-\ln0{,}665\approx0{,}408$, градиент $s-y\approx(-0{,}335;\,0{,}245;\,0{,}090)$: правильный логит тянется вверх, остальные — вниз.

def cross_entropy(logits, k):
    z = logits - logits.max()
    return np.log(np.exp(z).sum()) - z[k]

$\eta=0{,}001$ (темп обучения, learning rate), $\beta_1=0{,}9$, $\beta_2=0{,}999$, $\epsilon=10^{-8}$. Все операции — поэлементные: у каждого веса свои $m$ и $v$.

Первый шаг, $g_1=0{,}5$, $m_0=v_0=0$: $m_1=0{,}05$, $v_1=0{,}00025$. Без поправки шаг был бы в $3{,}16$ раза больше: $0{,}05/\sqrt{0{,}00025}\approx3{,}16$, потому что $v$ занижен сильнее, чем $m$; с поправкой $\hat{m}_1=0{,}5$, $\hat{v}_1=0{,}25$, и $\hat{m}_1/\sqrt{\hat{v}_1}=1$. На первом шаге вес сдвигается ровно на $\eta$ — каким бы ни был масштаб градиента.

m = b1 * m + (1 - b1) * g
v = b2 * v + (1 - b2) * g ** 2
m_hat = m / (1 - b1 ** t)
v_hat = v / (1 - b2 ** t)
theta -= lr * m_hat / (np.sqrt(v_hat) + eps)

$\operatorname{SiLU}(1)\approx0{,}731$, $\operatorname{SiLU}(-1)\approx-0{,}269$: в отличие от ReLU, небольшие отрицательные значения проходят.

$\operatorname{GELU}(1)\approx0{,}841$, $\operatorname{GELU}(-1)\approx-0{,}159$.

Зазор $m=0{,}2$. $d(a,p)=0{,}4$, $d(a,n)=1{,}1$: $L=0$, тройка уже разделена. $d(a,p)=0{,}9$, $d(a,n)=1{,}0$: $L=0{,}1$ — «чужой» слишком близко.

$p_t$ — вероятность правильного класса. При $\gamma=2$ лёгкий пример с $p_t=0{,}9$ весит в 100 раз меньше, чем в CE ($0{,}001$ против $0{,}105$), а трудный с $p_t=0{,}3$ — всего в 2 раза ($0{,}590$ против $1{,}204$).