Функции и графики

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

Любая нейросеть — это функция. Большая языковая модельбольшая языковая модель (БЯМ, LLM)EN large language model (LLM)В китайском «большая модель» («да мосин») — разговорное общее название для LLM и вообще foundation models. вроде Qwen или DeepSeek принимает на вход текст (точнее, номера токенов) и возвращает вероятности следующего токена. Внутри у неё миллиарды чисел, но собрана она из простых деталей: прямых линий, «изломов» и экспонент. Все эти детали есть в школьной программе, просто там они назывались иначе.

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

Как проходить модуль 1.0

Это мостик для тех, кто давно не открывал учебник математики. Откройте рядом Python (Jupyter из урока 0.1.2) и повторяйте каждый пример руками — «сначала руками, потом теория». Если квиз внизу страницы решается легко, смело переходите к заданию.

Функция: вход → выход

ФункцияфункцияEN functionВ Python функция — обычный объект, её можно передать как аргумент или вернуть из другой функции. — это правило, которое каждому входу ставит в соответствие ровно один выход. Записывают так: $y = f(x)$. Здесь $x$ — аргумент (вход), $f$ — имя функции, $y$ — значение (выход).

Пример: $f(x) = 2x + 1$. Подставим $x = 3$ и получим $f(3) = 2 \cdot 3 + 1 = 7$. В Python всё то же самое:

def f(x):
    return 2 * x + 1    # правило: умножить на 2 и прибавить 1

print(f(3))    # 7
print(f(-1))   # -1

Математическая функция и функция в Python — близкие родственники: def задаёт правило, а вызов f(3) подставляет вход. Но математическая функция ничего не делает «по пути»: не печатает, не читает файлы, не помнит прошлых вызовов. На один и тот же вход она всегда даёт один и тот же выход.

А почему тогда ChatGPT отвечает по-разному?

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

Входы и параметры

Функция может принимать несколько входов. Например, площадь прямоугольника $S(a, b) = a \cdot b$. Нейросеть принимает тысячи входов сразу.

Для ML важнее другое различие — между входами и параметрамипараметрEN parameter. Возьмём запись $y = kx + b$:

• $x$ — вход, он меняется от вызова к вызову;
• $k$ и $b$ — параметры. Для конкретной функции они фиксированы, но если их поменять, получится другая функция из того же семейства.

def line(x, k, b):
    return k * x + b

print(line(3, k=2, b=1))    # 7
print(line(3, k=-1, b=10))  # 7 — совсем другая прямая, но и она проходит через точку (3, 7)

Обучение нейросети — это подбор параметров. Архитектура задаёт семейство функций: «все прямые», «все параболы», «все трансформеры с 7 млрд чисел». Обучение ищет в этом семействе функцию, которая лучше всего объясняет данные. Параметры нейросети называют весамивесаEN weights.

Где функция не определена

Не каждую функцию можно вычислить при любом входе. Квадратный корень из отрицательного числа, логарифм нуля, деление на ноль — Python на них ругается:

import math
# Запускайте по одной строке: первая же ошибка останавливает программу
math.sqrt(-1)   # ValueError: math domain error
1 / 0           # ZeroDivisionError: division by zero

Множество допустимых входов называют областью определения. Ошибку math domain error вы ещё встретите. Например, когда вероятность округлится до нуля и под логарифмом окажется 0 (следующий урок).

График: функция, которую видно

График функцииграфик функцииEN graph of a functionВсе точки (x, f(x)). Таблица значений и график — два способа увидеть одну и ту же функцию. — это все точки $(x, f(x))$ на плоскости. Проще всего построить его по таблице значений:

def f(x):
    return 2 * x + 1

for x in range(-3, 4):     # x = -3, -2, …, 3
    print(x, f(x))

-3 -5
-2 -3
-1 -1
0 1
1 3
2 5
3 7

Отметьте эти точки на клетчатой бумаге, и они лягут на прямую. Компьютер делает то же самое, только с сотнями точек. С matplotlib из урока 0.3.3 это выглядит так:

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(-3, 3, 200)              # 200 точек от −3 до 3
plt.plot(x, 2 * x + 1, label="2x + 1")   # NumPy считает формулу сразу для всех 200 точек
plt.plot(x, x ** 2, label="x²")
plt.axhline(0, color="gray", lw=0.5)     # ось x
plt.axvline(0, color="gray", lw=0.5)     # ось y
plt.legend()
plt.grid(alpha=0.3)
plt.show()

Вот шесть функций этого урока — запомните их «в лицо»:

Шесть функций урока. По горизонтали — x (у сигмоиды от −6 до 6, у остальных примерно от −3 до 3), по вертикали — значение функции.

Глядя на любой график, задавайте три вопроса. Где функция растёт и где убывает? Где она пересекает ноль? Где у неё минимум или максимум? Для ML важнее всего минимум: обучение — это поиск минимума функции потерь.

Поиграйте с графиками

Откройте Desmos и введите y = kx + b. Desmos предложит добавить ползунки для k и b — подвигайте их и посмотрите, как меняется прямая. Так же можно «потрогать» каждую функцию из урока.

Линейная функция y = kx + b

Поездка на такси: посадка стоит 100 ₽, каждый километр — 30 ₽. Стоимость поездки на $x$ км равна $y = 30x + 100$:

Километры $x$	0	1	5	10
Цена $y$, ₽	100	130	250	400

Это линейная функциялинейная функцияEN linear functiony = kx + b. В ML её пишут y = wx + b (w — вес, b — смещение). В китайской школе — тоже y = kx + b., её график — прямая. Оба числа в формуле имеют простой смысл:

• $k$ — наклоннаклон (угловой коэффициент)EN slopeНа сколько меняется y, когда x растёт на 1. По двум точкам k = (y₂ − y₁) / (x₂ − x₁).: на сколько изменится $y$, если $x$ увеличить на 1. Здесь каждый километр добавляет 30 ₽.
• $b$ — значение при $x = 0$, то есть точка, где прямая пересекает вертикальную ось. Здесь это 100 ₽ за посадку.

Если $k > 0$, прямая растёт, если $k < 0$ — убывает, при $k = 0$ она горизонтальна.

Наклон можно найти по любым двум точкам прямой:

$$k = \frac{y_2 - y_1}{x_2 - x_1}$$

Пример: поездка на 2 км стоила 160 ₽, на 6 км — 280 ₽. Тогда $k = \frac{280 - 160}{6 - 2} = \frac{120}{4} = 30$ ₽ за км. Дробь «изменение $y$ / изменение $x$» — зародыш производной, к ней мы вернёмся в модуле 1.2.

Как это выглядит в ML. В нейросетях ту же прямую пишут как $y = wx + b$: $w$ — вес (weight), $b$ — смещение (bias). Пример из мира LLM, с условными числами: время ответа модели $t = 0.02 \cdot n + 0.5$ секунды. Здесь 0.5 с — задержка до первого токена, а 0.02 с — время на каждый следующий токен, то есть 50 токенов в секунду. Ответ из 50 токенов займёт 1.5 с, из 500 токенов — 10.5 с.

У настоящего нейрона входов много: $y = w_1 x_1 + w_2 x_2 + w_3 x_3 + b$. Это тоже линейная функция, только от нескольких переменных. Как записать её коротко через знак $\Sigma$, разберём в уроке 1.0.3, а через скалярное произведение векторов — в уроке 1.1.1.

Квадратичная функция и «чаша» ошибки

Квадратичная функцияквадратичная функцияEN quadratic functionГрафик — парабола. Квадратичные функции потерь (MSE) похожи на «чашу» с одним дном. $y = x^2$ даёт такую таблицу:

$x$	−3	−2	−1	0	1	2	3
$x^2$	9	4	1	0	1	4	9

Её график — парабола. Она симметрична, отрицательных значений у неё нет, а минимум равен 0 в точке $x = 0$. Параболу легко сдвигать. Например, $y = (x - 3)^2 + 1$ — это та же парабола, у которой минимум равен 1 в точке $x = 3$. Скобка $(x - a)$ сдвигает график вправо на $a$, а слагаемое $+c$ — вверх на $c$.

Почему квадрат так важен в ML. Пусть модель предсказала $\hat y$ (читается «игрек с крышкой»), а правильный ответ — $y$. Ошибка равна $\hat y - y$, а её квадрат растёт гораздо быстрее самой ошибки:

Ошибка $\hat y - y$	0.5	1	2	10
Квадрат ошибки	0.25	1	4	100

Промах в 10 раз больше штрафуется в 100 раз сильнее. Средний квадрат ошибки по всем примерам называют MSEсреднеквадратичная ошибка (MSE)EN mean squared error (MSE)Корень из MSE — RMSE (root mean squared error), измеряется в тех же единицах, что и целевая переменная. (mean squared error). Это главная функция потерьфункция потерьEN loss function для задач, где нужно предсказать число (модуль 2.2).

Теперь посмотрим на ошибку как на функцию параметра. Возьмём модель $\hat y = w \cdot x$ и один обучающий пример: вход $x = 2$, правильный ответ $y = 6$.

def loss(w):
    x, y = 2, 6          # один обучающий пример
    y_hat = w * x        # предсказание модели с параметром w
    return (y_hat - y) ** 2

for w in range(6):
    print(w, loss(w))

0 36
1 16
2 4
3 0
4 4
5 16

Получилась парабола $L(w) = (2w - 6)^2$ с дном при $w = 3$. Это обучение в миниатюре: найти параметр, при котором функция потерь минимальна. Градиентный спуск (модуль 1.4) «скатывается» по такой чаше на дно. У LLM параметров миллиарды и «чаша» многомерная, но идея та же.

Модуль: расстояние до нуля

Модульмодуль (абсолютная величина)EN absolute valueРасстояние от числа до нуля, |−3| = 3. В Python — abs(). Основа MAE и нормы L1. $|x|$ — это расстояние от числа до нуля: $|-3| = 3$, $|2.5| = 2.5$, $|0| = 0$. График похож на букву V. В Python модуль считает функция abs(-3).

В ML модуль встречается в MAEсредняя абсолютная ошибка (MAE)EN mean absolute error (MAE) — средней абсолютной ошибке. В отличие от квадрата, модуль штрафует промахи линейно: ошибка 10 даёт штраф 10, а не 100, поэтому MAE спокойнее относится к выбросам в данных. Обратите внимание на «угол» графика в нуле: там у функции нет одного наклона. Это пригодится в модуле 1.2.

Кусочные функции и ReLU

Кусочная функциякусочная функцияEN piecewise functionРазные формулы на разных участках оси. ReLU = max(0, x) — самая известная кусочная функция в ML. задаётся разными формулами на разных участках. Модуль — уже кусочная функция: слева от нуля это $-x$, справа — $x$.

Пример из жизни: мобильный тариф, где первые 100 МБ бесплатны, а дальше каждый мегабайт стоит 2 ₽.

$$f(x) = \begin{cases} 0, & x \le 100 \\ 2(x - 100), & x > 100 \end{cases}$$

За 50 МБ вы платите 0 ₽, за 150 МБ — 100 ₽, за 600 МБ — 1000 ₽.

Самая знаменитая кусочная функция в ML называется ReLU (rectified linear unit, дословно «выпрямленный линейный элемент»):

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

Отрицательные числа она обнуляет, положительные пропускает без изменений: $\mathrm{ReLU}(-2) = 0$, $\mathrm{ReLU}(0) = 0$, $\mathrm{ReLU}(2) = 2$. Наш тариф — это $2 \cdot \mathrm{ReLU}(x - 100)$, то есть ReLU, сдвинутая вправо на 100 и растянутая вдвое по вертикали. Запомните этот приём, он понадобится в разделе о композиции.

import numpy as np

def relu(x):
    return max(0, x)               # для одного числа: большее из 0 и x

print(relu(-2), relu(3.5))         # 0 3.5

xs = np.array([-2.0, -1.0, 0.0, 1.0, 2.0])
print(np.maximum(0, xs))           # для массива сразу: [0. 0. 0. 1. 2.]

Ловушка: np.max и np.maximum

np.max(xs) возвращает одно число — самый большой элемент массива (здесь 2.0). А np.maximum(0, xs) сравнивает с нулём каждый элемент. Если по ошибке написать np.max(0, xs), NumPy примет xs за номер оси и выдаст TypeError: only integer scalar arrays can be converted to a scalar index. Запишите этот случай в тетрадь ошибок.

ReLU популярна, потому что её очень дёшево считать, а положительный сигнал она передаёт без «сжатия». Стандартом глубокого обучения она стала в начале 2010-х годов. В современных LLM чаще используют её гладких родственников: GELU (GPT-2) и SwiGLU (Llama, Qwen, DeepSeek). Их разберём в уроках 3.1.1 и 4.5.3.

Экспонента и сигмоида

Экспонентаэкспонента (показательная функция)EN exponential functioneˣ — всегда положительна, растёт взрывообразно. Внутри softmax и сигмоиды. $e^x$ строится на особом числе $e \approx 2.718$. Откуда оно берётся, разберём в следующем уроке, а пока посмотрим на поведение функции:

$x$	−2	−1	0	1	2	3
$e^x$	0.135	0.368	1	2.718	7.389	20.09

У экспоненты три важных свойства. Она всегда положительна. В нуле она равна 1. Вправо она растёт взрывообразно, а влево стремится к нулю, но никогда его не достигает. Именно поэтому softmax использует экспоненту: она превращает любое число, даже отрицательное, в положительное (урок 1.3.2).

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

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

Посчитаем по шагам для $x = 2$. Сначала $e^{-2} \approx 0.135$, затем $1 + 0.135 = 1.135$, и наконец $1 / 1.135 \approx 0.881$.

$x$	−4	−2	0	2	4	10
$\sigma(x)$	0.018	0.119	0.5	0.881	0.982	0.99995

Сигмоида сжимает любое число в интервал от 0 до 1, поэтому её выход можно читать как вероятность. В нуле она равна ровно 0.5, а ещё она симметрична: $\sigma(-x) = 1 - \sigma(x)$. Проверьте по таблице: $0.119 + 0.881 = 1$. Сигмоида встретится вам в логистической регрессии (урок 2.2.2, «вероятность, что письмо — спам») и внутри функции активации SiLU, $x \cdot \sigma(x)$, на которой построен SwiGLU в Qwen и DeepSeek.

Ловушка переполнения. Число math.exp(1000) не помещается во float, и Python бросает исключение:

import math

def sigmoid_naive(x):
    return 1 / (1 + math.exp(-x))

print(sigmoid_naive(2))       # 0.8807970779778823
print(sigmoid_naive(-1000))   # OverflowError: math range error — внутри считается exp(1000)

Выход простой. При $x \ge 0$ исходная формула безопасна: $e^{-x}$ не больше 1. А при $x < 0$ умножим числитель и знаменатель на $e^x$ и получим равную формулу $\frac{e^x}{1 + e^x}$. В ней экспонента тоже берётся от отрицательного числа, а значит, не больше 1. Это та же идея, что и у устойчивого softmax в уроке 1.3.2: никогда не считать экспоненту от большого положительного числа. Устойчивую сигмоиду вы напишете в задании.

Композиция: как функции склеиваются в нейросеть

Композициякомпозиция функцийEN function compositionf(g(x)) — сначала g, потом f. Нейросеть — композиция слоёв. $f(g(x))$ означает: сначала вычислить $g(x)$, а результат подать в $f$. Пусть $f(x) = x^2$ и $g(x) = x + 1$. Тогда $f(g(2)) = f(3) = 9$, а $g(f(2)) = g(4) = 5$. Порядок важен.

Искусственный нейрон — это композиция линейной функции и функции активациифункция активацииEN activation function: $\mathrm{neuron}(x) = \mathrm{ReLU}(wx + b)$. Нейросеть — композиция многих таких шагов:

flowchart LR
X["x"] --> L1["w₁·x + b₁"] --> A1["h = ReLU(…)"] --> L2["w₂·h + b₂"] --> S["σ"] --> Y["y от 0 до 1"]

Крошечная нейросеть: линейная функция → ReLU → линейная функция → сигмоида

Почему без нелинейности никак

Составим композицию двух линейных функций: $g(x) = 3x + 1$ и $f(u) = 2u + 5$. Получится

$$f(g(x)) = 2(3x + 1) + 5 = 6x + 7.$$

Снова прямая! Сколько линейных слоёв ни ставь друг за другом, в итоге выйдет одна линейная функция. В многомерном случае это одно матричное умножение (урок 1.1.2). Поэтому между слоями нейросети всегда стоит нелинейность — ReLU, сигмоида или их родственники. Подробнее об этом — в уроке 3.1.1.

Из изломов можно собрать любую кривую

Приём 1. Модуль собирается из двух ReLU: $|x| = \mathrm{ReLU}(x) + \mathrm{ReLU}(-x)$. Проверим при $x = -3$: $0 + 3 = 3$. Получилась сеть из двух «нейронов».

Приём 2. Приблизим параболу $x^2$ на отрезке от 0 до 3 тремя ReLU:

$$g(x) = \mathrm{ReLU}(x) + 2\,\mathrm{ReLU}(x - 1) + 2\,\mathrm{ReLU}(x - 2)$$

Каждая ReLU «включается» в своей точке и добавляет наклон. На отрезке $[0, 1]$ наклон равен 1, на $[1, 2]$ он становится $1 + 2 = 3$, на $[2, 3]$ — $3 + 2 = 5$. Получается ломаная через точки $(0, 0)$, $(1, 1)$, $(2, 4)$, $(3, 9)$. Проверим одну точку руками, $x = 2.5$: $\mathrm{ReLU}(2.5) + 2\,\mathrm{ReLU}(1.5) + 2\,\mathrm{ReLU}(0.5) = 2.5 + 3 + 1 = 6.5$, а настоящее $2.5^2 = 6.25$ — промах всего 0.25.

def relu(x):
    return max(0, x)

def g(x):
    # три «нейрона» с изломами в точках 0, 1 и 2
    return relu(x) + 2 * relu(x - 1) + 2 * relu(x - 2)

for x in [0, 0.5, 1, 1.5, 2, 2.5, 3]:
    # {x:<4} — вывести x, выровняв по левому краю в поле шириной 4 символа: так столбцы стоят ровно
    print(f"x = {x:<4} x² = {x * x:<5} g(x) = {g(x)}")

x = 0    x² = 0     g(x) = 0
x = 0.5  x² = 0.25  g(x) = 0.5
x = 1    x² = 1     g(x) = 1
x = 1.5  x² = 2.25  g(x) = 2.5
x = 2    x² = 4     g(x) = 4
x = 2.5  x² = 6.25  g(x) = 6.5
x = 3    x² = 9     g(x) = 9

Три ReLU-«нейрона» дают ломаную g(x), которая почти повторяет параболу: наибольшая ошибка 0.25 — посередине между изломами.

Добавьте больше «нейронов» с изломами почаще, и ломаная прижмётся к параболе ещё плотнее. В этом и состоит интуиция теоремы об универсальной аппроксимации: достаточно широкая сеть из ReLU может сколь угодно точно приблизить любую непрерывную функцию на отрезке. Обучение само подбирает, где ставить изломы и с какими коэффициентами.

Практика

Реализуйте детали нейросети: линейную функцию, ReLU, устойчивую сигмоиду, нейрон и модуль через ReLU. Кнопка «Запустить» печатает таблицу значений, кнопка «Проверить» запускает тесты.

Линейная функция, ReLU, сигмоида и нейрон6 тестов

import math


def linear(x, k, b):
    """Линейная функция: y = k·x + b.

    Пример: linear(3, 2, 1) → 7, потому что 2·3 + 1 = 7.
    """
    # TODO: одна строка с return
    ...


def relu(x):
    """ReLU: возвращает x, если x > 0, иначе 0.

    Примеры: relu(-2) → 0, relu(3.5) → 3.5.
    """
    # TODO
    ...


def sigmoid(x):
    """Сигмоида: σ(x) = 1 / (1 + e^(−x)). Результат всегда между 0 и 1.

    Пример: sigmoid(0) → 0.5.
    Должна работать и при x = -1000: math.exp(1000) вызывает OverflowError,
    поэтому для отрицательных x используйте равную формулу e^x / (1 + e^x).
    """
    # TODO: if x >= 0: ... else: ...
    ...


def neuron(x, w, b):
    """Один нейрон: сначала линейная функция w·x + b, затем ReLU.

    Пример: neuron(2, 3, -1) → relu(3·2 − 1) = 5.
    Подсказка: используйте уже написанные linear и relu.
    """
    # TODO
    ...


def abs_via_relu(x):
    """Модуль |x|, собранный из двух ReLU — без abs() и без if.

    Пример: abs_via_relu(-3) → 3.
    """
    # TODO
    ...


# Кнопка «Запустить» печатает таблицу значений (пока функции возвращают None):
print("x | linear(x,2,1) | relu | sigmoid | |x|")
for x in [-2, -1, 0, 1, 2]:
    print(x, linear(x, 2, 1), relu(x), sigmoid(x), abs_via_relu(x))

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

Задание для Jupyter (по желанию). Постройте в matplotlib на одном рисунке $x^2$ и ломаную $g(x)$ на отрезке от 0 до 3 (для массивов используйте np.maximum(0, x)). Затем сделайте изломы чаще — в точках 0, 0.5, 1, 1.5, 2 и 2.5 — и подберите коэффициенты шести ReLU так, чтобы ломаная проходила через точки $(x, x^2)$. Подсказка: наклон на каждом следующем участке растёт на одно и то же число. Если всё верно, наибольшая ошибка уменьшится в 4 раза, до 0.0625.

Китайский угол: функция — «то, что вмещает» другое число

Откуда слово. Китайское название функции — «ханьшу» — в 1859 году придумал математик Ли Шаньлань. Вместе с британским миссионером Александром Уайли он переводил «Элементы алгебры» Огастеса де Моргана, книга вышла под названием «Алгебра». Определение Ли Шаньланя в переводе звучит так: «если одна переменная вмещает в себя другую, то первая есть функция второй». Первый слог названия значит «вмещать, содержать». Из переводов Ли Шаньланя и Уайли пришли и другие китайские термины, которыми пользуются до сих пор: названия алгебры, дифференциала и интеграла.

Как учат в китайской школе. Сквозной принцип китайской школьной математики — «число и форма вместе» («шу син цзехэ»): каждую формулу сразу рисуют, каждый график описывают формулой. Математик Хуа Логэн сформулировал его в стихах (в переводе): «число без формы лишено наглядности, форма без числа не даёт вникнуть в детали». Этот урок построен так же, только к формуле и графику мы добавили третью опору — код. Линейную функцию в китайской школе пишут как и в российской, $y = kx + b$, и называют буквально «функцией первой степени», а $k$ — «коэффициентом наклона».

Что посмотреть на китайском. В первой лекции курса Ли Хунъи (ML 2021 Spring) показан приём из этого урока. Профессор собирает произвольную ломаную из суммы «ступенек» (hard sigmoid), затем заменяет их сигмоидами и ReLU — и так приходит к нейросети. Текстовый конспект лекции есть в «Яблочной книге» (Datawhale, leedl-tutorial, глава 1). Графики функций активации с кодом есть в «Погружении в глубокое обучение» (d2l-zh), раздел 4.1.

Проверь себя

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

1 Прямая проходит через точки $(1, 5)$ и $(3, 11)$. Чему равен её наклон $k$?

2 Функция потерь $L(w) = (2w - 6)^2$. При каком $w$ она минимальна?

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

$\mathrm{ReLU}(-5) = 0$$\mathrm{ReLU}(2.5) = 2.5$ReLU никогда не бывает отрицательной$\mathrm{ReLU}(x) = |x|$ для всех $x$

4 Пусть $f(x) = x^2$ и $g(x) = x + 1$. Чему равно $f(g(2))$?

5964

5 Известно, что $\sigma(2) \approx 0.881$. Чему равно $\sigma(-2)$? Округлите до трёх знаков.

6 Зачем между линейными слоями нейросети ставят ReLU или другую нелинейность?

Чтобы ускорить вычисленияКомпозиция линейных функций снова линейна, и без нелинейности глубокая сеть равносильна одному слоюЧтобы выход сети всегда был от 0 до 1Чтобы веса не становились отрицательными

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

Итоги

• Функция — правило «вход → ровно один выход». В ML важно отличать входы от параметров: обучение подбирает параметры.
• В прямой $y = kx + b$ число $k$ — наклон (изменение $y$ на единицу $x$), а $b$ — значение в нуле. Квадратичная функция — «чаша» с минимумом, как функция потерь.
• ReLU $= \max(0, x)$ — кусочная функция. Сигмоида сжимает любое число в $(0, 1)$. Экспоненту от большого положительного числа не считаем — будет переполнение.
• Нейросеть — композиция линейных функций и нелинейностей. Без нелинейности глубина бесполезна, а с ней из «изломов» собирается любая кривая.

Дальше: степени, экспонента и логарифмы — откуда берётся число $e$ и почему в ML повсюду $\log$.