Функции, экспонента и логарифм

Функция — это машинка

Функция $f$ берёт вход $x$ и выдаёт выход $f(x)$ . Нейросеть — это тоже функция: на вход картинка (64 числа), на выход 10 вероятностей. Просто очень сложная функция, собранная из простых. В этом модуле мы научимся понимать, как выход функции меняется при изменении входа, — это ключ к обучению.

import numpy as np
import vis

x = np.linspace(-3, 3, 200)
vis.line(x, {"2x + 1 (линейная)": 2 * x + 1, "x² (парабола)": x ** 2, "x³": x ** 3},
         title="Простые функции", xlabel="x")

Линейная $f(x) = wx + b$ — прямая: $w$ задаёт наклон, $b$ — сдвиг. Это модель из первого урока.
Квадратичная $x^2$ — парабола с минимумом в нуле. Квадрат ошибки, который мы минимизируем, выглядит именно так.
Кусочные функции задаются разными формулами на разных участках. Самая знаменитая в ML — ReLU:

\text{ReLU}(x) = \max(0, x) = \begin{cases} x, & x > 0 \\ 0, & x \le 0 \end{cases}

Экспонента

Экспонента $e^x$ , где $e \approx 2.718$ , — функция, которая растёт со скоростью, равной самой себе. Её свойства:

$e^x > 0$ всегда — поэтому её используют, чтобы превратить любое число в положительное (так получаются вероятности в softmax);
$e^0 = 1$ , $e^{a + b} = e^a e^b$ ;
растёт очень быстро: $e^{10} \approx 22\,026$ , $e^{100} \approx 2.7 \cdot 10^{43}$ , а $e^{1000}$ уже не помещается в float.

import numpy as np
import vis

x = np.linspace(-3, 3, 200)
vis.line(x, {"eˣ": np.exp(x), "2ˣ": 2 ** x, "e⁻ˣ": np.exp(-x)}, title="Экспоненты", xlabel="x")

print(np.exp([0, 1, 10, 100]))
print(np.exp(1000))          # inf — переполнение!

Почему именно e

Число $e$ — то основание, при котором скорость роста функции в каждой точке в точности равна её значению. Наклон графика $e^x$ в точке $x$ равен $e^x$ . Из-за этого формулы с $e$ получаются самыми простыми — увидим это в уроке о производных.

import numpy as np

for n in (1, 10, 100, 10_000, 1_000_000):
    print(f"(1 + 1/{n})^{n} = {(1 + 1 / n) ** n:.6f}")
print("e =", np.e)

Логарифм

Натуральный логарифм $\ln x$ — обратная функция к экспоненте: $\ln x$ — это степень, в которую нужно возвести $e$ , чтобы получить $x$ . $\ln(e^x) = x$ , $e^{\ln x} = x$ .

Определён только для $x > 0$ ; $\ln 1 = 0$ ; при $x \to 0$ уходит в $-\infty$ .
Растёт очень медленно: $\ln 1\,000\,000 \approx 13.8$ .
Превращает произведения в суммы: $\ln(ab) = \ln a + \ln b$ , и степени — в множители: $\ln a^k = k \ln a$ .

import numpy as np
import vis

x = np.linspace(0.01, 5, 300)
vis.line(x, {"ln x": np.log(x), "log₂ x": np.log2(x)}, title="Логарифмы", xlabel="x")
print(np.log([1, np.e, 10, 1e6]))
print(np.log(2 * 3), np.log(2) + np.log(3))

Зачем логарифм в ML

1. Произведения вероятностей. Вероятность того, что модель права на всём наборе из N объектов, — произведение N вероятностей. При N = 1000 и вероятностях около 0.9 это $0.9^{1000} \approx 10^{-46}$ , а дальше — просто ноль в компьютере. Логарифм превращает произведение в сумму вполне нормальных чисел:

import numpy as np

p = np.full(5000, 0.9)
print("произведение:", np.prod(p))               # 0.0 — исчезло
print("сумма логарифмов:", np.log(p).sum())      # −526.8 — вполне считаемо

2. Функции потерь. Кросс-энтропия, главная функция потерь для классификации, — это $-\ln p$ , где $p$ — вероятность правильного ответа. Она сильно штрафует уверенные ошибки: при $p = 0.01$ потеря $4.6$ , а при $p = 0.9$ — всего $0.1$ .

import numpy as np
import vis

p = np.linspace(0.01, 1, 200)
vis.line(p, -np.log(p), title="−ln p: штраф за вероятность правильного ответа", xlabel="p", ylabel="потеря")

3. Шкалы. Потери при обучении часто падают в тысячи раз — их рисуют в логарифмическом масштабе (vis.line(..., logy=True)).

Сигмоида и tanh

Скомбинируем экспоненту с дробью и получим сигмоиду — гладкую «ступеньку» от 0 до 1:

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

Она превращает любое число в «вероятность»: большие положительные $z$ → почти 1, большие отрицательные → почти 0, $\sigma(0) = 0.5$ . Её близкий родственник tanh — такая же ступенька, но от −1 до 1: $\tanh z = 2\sigma(2z) - 1$ .

import numpy as np
import vis

z = np.linspace(-6, 6, 200)
sigmoid = 1 / (1 + np.exp(-z))
vis.line(z, {"σ(z)": sigmoid, "tanh z": np.tanh(z), "ReLU(z)": np.maximum(0, z) / 6},
         title="Функции активации (ReLU сжата в 6 раз для масштаба)", xlabel="z")

Все три — функции активации, та самая нелинейность между слоями нейросети. Подробно сравним их в отдельном уроке.

Композиция функций

Композиция — применение функций одна за другой: $h(x) = g(f(x))$ . Нейросеть — композиция слоёв:

\text{сеть}(x) = f_3(\,f_2(\,f_1(x)\,)\,)

Например, нейрон — это композиция линейной функции и сигмоиды: $\sigma(wx + b)$ . Меняя $w$ и $b$ , мы двигаем и растягиваем ступеньку:

import numpy as np
import vis

x = np.linspace(-5, 5, 200)
sig = lambda z: 1 / (1 + np.exp(-z))
vis.line(x, {"σ(x)": sig(x), "σ(3x) — круче": sig(3 * x), "σ(x − 2) — сдвиг": sig(x - 2), "σ(−x) — отражение": sig(-x)},
         title="Нейрон σ(w·x + b) при разных w и b", xlabel="x")

Чтобы обучать такие композиции, нам понадобится узнать, как меняется выход при малом изменении входа или параметра, — это производная. Ей посвящён следующий урок.

Итог

Нейросеть — функция, собранная из простых функций (композиция).
Экспонента $e^x$ всегда положительна, быстро растёт и легко переполняется.
Логарифм — обратная к экспоненте, превращает произведения в суммы; на нём построены функции потерь.
Сигмоида $\sigma(z) = 1/(1 + e^{-z})$ сжимает любое число в (0, 1); tanh — в (−1, 1); ReLU — $\max(0, z)$ .