Глава 0. Искусственный нейрон — интерактивная разминка

Если термины вроде backprop, feature map или residual звучат как чужой язык — начните здесь.
Ниже не «новая теория», а медленный разбор того, что дальше в книге идёт быстрее.

Эта глава — разминка с интерактивом в тексте: не отдельная лаба, а «прочитал абзац — сразу потрогал» демо ниже. Можно пощупать нейроны — у каждого свои ползунки w и b, на графике видно, как меняется ответ. Клик по кривой — подать другой вход.

Словарь на одну страницу

0.1. Один нейрон: вход → сумма → активация → выход

Самый маленький кирпичик сети:

вход x  →  z = w·x + b  →  y = act(z)  →  выход y

• x — что подали (температура, яркость пикселя, любое число).
• w — насколько вход важен.
• b — сдвиг порога.
• act — что делаем с суммой: обрезаем отрицательное (ReLU), сжимаем в 0…1 (сигмоида) и т.д.

Пощупайте: карточка нейрона — ползунки w и b. Клик по графику — другой x. Смотрите, как двигается точка и меняется y.

0.2. Несколько нейронов в одном слое

Один вход x можно развести на несколько нейронов. Каждый смотрит на тот же x, но с своим весом — получаются разные ответы.

Это уже не «одна формула», а набор признаков: один нейрон чувствителен к большим x, другой — к малым, третий — к средним.

У каждого нейрона — своя карточка с w и b. На карточке сразу видно его y. Жирная линия на графике — сумма всех. Тонкие — каждый по отдельности (можно выключить).

0.3. Второй и третий слой: цепочка

Добавляем скрытый слой и выходной:

x → [скрытые нейроны] → y

Скрытый слой берёт вход и строит промежуточные признаки. Выходной — сводит их в один ответ (например «да / нет»).

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

Скрытые нейроны — карточки с w,b. Выходной — ползунки vᵢ (насколько слушать каждый скрытый). Жирная кривая — ответ всей сети.

0.4. Зачем обучение: вход, предсказание, цель

Выше вы вручную крутили w и b и смотрели, как меняется кривая. В реальной задаче крутить миллион ползунков нельзя — нужен автоматический подбор.

Что на входе, что на выходе

вход x  ──→  сеть (w, b, …)  ──→  предсказание ŷ
                                        ↕ сравниваем
                              цель y*  (правильный ответ из данных)

Цель не подаётся на вход нейрона. Сеть видит только x. Цель нужна снаружи — чтобы измерить ошибку и понять, куда двигать веса.

Результат обучения — не новая формула, а найденные числа: w, b, v и т.д. После обучения вы сохраняете веса и дальше подаёте новые x — сеть выдаёт ŷ без цели.

Частая путаница: что такое «цель»?

Цель y* — это не «хочу такие веса». Вы никогда не говорите сети: «пусть w₁ = 0,42». Веса подбирает алгоритм сам.

Цель — это ответ на один вопрос: «при этом входе x правильный выход должен быть столько-то y*».

Аналогия. Ученик (сеть) решает задачу (x). Пишет ответ ŷ. Учитель сверяет с ключом (y*) — ключ ученику не показывают, только для проверки. После сотен задач привычки ученика (веса) меняются так, что ответы совпадают с ключом. На экзамене дают только x — без ключа.

Что крутите ползунком «цель» на демо: меняете правильный ответ для текущего x, как будто в учебнике другая задача. Сеть заново подстраивает веса, чтобы ŷ ≈ y* при этом x. На графике красный кружок — куда должна попасть зелёная кривая в этой точке x (вертикальная линия). В остальных x цель не задана — кривая там «живёт своей жизнью».

Что обучаем в итоге? Не форму, не цель — параметры w, b, v, c. Они и есть «память» сети. Сохранили — подаёте любой новый x, получаете ŷ. Цель нужна только пока учим.

Четыре шага

1. Пример: пара (x, y*) — «при таком входе правильный ответ такой».
2. Ошибка L = (ŷ − y*)² — насколько промахнулись.
3. Градиент — кому из весов «виноват» больше: ∂L/∂w, ∂L/∂b, …
4. Градиентный спуск — чуть сдвигаем каждый вес против градиента. Повторяем тысячи раз.

Почему «обратное» и что именно распространяется

Название путает. Разберём по шагам — это неочевидно, но логично.

Что НЕ происходит. Вы не берёте ŷ с выхода и не подаёте его снова на вход сети. Вход x остаётся тем же. Цель y* тоже не идёт внутрь нейрона — она нужна только снаружи, чтобы посчитать L.

Что происходит. После того как посчитали L, идём по той же цепочке вычислений, но в обратном порядке — от выхода к входу — и на каждом звене спрашиваем:

«Если чуть сдвинуть этот сигнал или вес — насколько изменится L?»

Эти «насколько» и есть дельты (градиенты): ∂L/∂ŷ, ∂L/∂h, ∂L/∂w, … Их как раз распространяют назад: от ошибки к весам.

вперёд (счёт ответа):     x  →  скрытые h  →  ŷ  →  сравнить с y*  →  L

назад (счёт вины):        L  ←  ∂L/∂ŷ  ←  ∂L/∂v, ∂L/∂c  ←  ∂L/∂h  ←  ∂L/∂w, ∂L/∂b
                          (от конечного слоя к начальному)

Порядок по слоям:

Не «подкрутили выход — пересчитали — подкрутили вход». Один проход вперёд, один назад, один шаг по всем весам.

Связь Δw и ΔL. Не перебираем случайные Δw и смотрим, что вышло. Математика сразу даёт направление:

Δw ≈ −η · ∂L/∂w

Смысл: «если сдвинуть w в эту сторону — ошибка уменьшится». На демо справа это видно как L(w) — холм, по которому катится точка.

Итого одной фразой: обратное — потому что дельты считаем от конца к началу; распространение ошибки — потому что число L «размазывается» по слоям: каждому весу достаётся своя доля вины.

Режим «1 нейрон» — слева ŷ(x), справа L(w): оранжевая точка катится по «холму» ошибки.
Режим «Мини-сеть» — слева ŷ(x), блок backprop с числами ∂L/∂… (дельты от выхода к входу), справа L по шагам.
Кнопка «Шаг обучения» сдвигает все веса; «Авто» — много шагов, пока ŷ не приблизится к цели.

От числа к классу

В регрессии цель — число y*. В классификации цель — метка: «это класс 1» или «класс 2». Один выход уже неудобен — нужно два (по одному на класс) и правило: кто больше, тот и победил.

Ниже — упрощённая задача: по числу x понять, в каком диапазоне оно лежит.

Сеть не может отличить классы одной прямой на весь x — нужны скрытые нейроны с изломами (ReLU): каждый «смотрит» на свой участок оси. Их комбинация даёт горб p₁ или p₂ только в своей полосе. На демо тонкие линии — это скрытые hᵢ(x).

Обучаем на 12 примерах (цветные и серые точки) — mini-batch. Два выхода независимы (сигмоиды): вне полос оба могут быть низкими. Внизу демо — 18 весов сети (4 скрытых + 2 выхода).

Проверьте ползунком x: в полосе 1 — высокая p₁; в полосе 2 — высокая p₂; между полосами и за x>0,7 — «вне классов», оба p низкие.

0.5. Мост к свёртке: окно по картинке

В гл. 2 свёртка бегает окном 3×3 по пикселям. Это тот же нейрон:

• 9 входов — яркости в окне;
• 9 весов — ядро (kernel), крутите на карточках;
• 1 выход — отклик в этой позиции.

Цель — карта справа «эталон»: где должен быть сильный отклик (край, пятно). Обучение подбирает 9 весов, чтобы зелёная кривая на графике совпала с красной целью.

Пресет — другая картинка и другой эталон. Позиция — какое окно смотрим на строке. Авто — ядро учится, ошибка на правом графике падает.

0.6. Ещё разминка

0.6.1. Три точки — одна кривая

В §0.4 учились на одном примере (x, y*). В жизни примеров много: сеть должна пройти через все красные точки сразу. Ошибка — средняя по всем точкам; backprop на каждом шаге суммирует градиенты и обновляет веса один раз.

Ползунком x смотрите, как кривая ведёт себя между точками. Авто — сеть из 6 скрытых ReLU подстраивается под все три цели.

0.6.2. XOR: зачем нужен скрытый слой

Классическая задача: два входа x₁, x₂ (0 или 1), выход 1 только когда входы разные. Одним нейроном без скрытого слоя это невозможно — нужна нелинейная «склейка». Таблица истинности справа: зелёная ячейка — сеть угадала, красная — ещё нет.

Карта слева — оттенок по ŷ в плоскости (x₁, x₂). После обучения углы 0/1 и центр 1/1 должны разойтись.

0.7. Куда дальше

Другой тип обучения — глава 0b: награды вместо y*, лабиринт, Q-learning.

Если после этой главы термины в основном тексте всё ещё давят — напишите, какие слова непонятны: можно добавить такие же интерактивы точечно.