Правило цепочки — основа обратного распространения

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

Правило цепочки: если y = f(g(x)), то y' = f'(g(x)) · g'(x). Производная композиции — произведение производных «слоёв».

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

В жизни функции часто вложены друг в друга. «Стоимость» зависит от «количества», которое зависит от «спроса». Чтобы узнать, как стоимость реагирует на спрос, перемножают скорости изменения на каждом шаге. Формально: h(x) = f(g(x)), и производная — произведение производной внешней функции (в точке g(x)) на производную внутренней.

import math

# h(x) = sin(x^2). Внешняя f(u)=sin(u), внутренняя g(x)=x^2
# По цепочке: h'(x) = cos(x^2) · 2x
def h(x):
    return math.sin(x * x)

def derivative(f, x, h=1e-5):
    return (f(x + h) - f(x - h)) / (2 * h)

x = 1.0
numeric  = derivative(h, x)
analytic = math.cos(x * x) * 2 * x      # правило цепочки

print("Численно :", round(numeric, 5))
print("По цепочке:", round(analytic, 5))

Вывод:

Численно : 1.0806
По цепочке: 1.0806

Численная производная совпала с тем, что даёт правило цепочки — мы проверили формулу экспериментом.

Цепочка из нескольких звеньев

Звеньев может быть сколько угодно — производные просто перемножаются вдоль цепочки. Для y = f(g(k(x))) получаем y' = f'(...)·g'(...)·k'(...). Посмотрим на трёхзвенную композицию: возвести в квадрат, прибавить 1, взять синус.

import math

def derivative(f, x, h=1e-5):
    return (f(x + h) - f(x - h)) / (2 * h)

# y = sin( (x^2) + 1 )
def k(x): return x * x          # k'(x) = 2x
def g(u): return u + 1          # g'(u) = 1
def f(v): return math.sin(v)    # f'(v) = cos(v)

def y(x): return f(g(k(x)))

x = 2.0
# Цепочка: y' = cos(g(k(x))) · 1 · 2x
chain = math.cos(k(x) + 1) * 1 * (2 * x)
print("Численно :", round(derivative(y, x), 5))
print("По цепочке:", round(chain, 5))

Вывод:

Численно : 1.13465
По цепочке: 1.13465

Почему это и есть backpropagation

Нейросеть — это огромная композиция функций: вход → слой 1 → слой 2 → ... → потеря. Чтобы обучать, нужно знать, как потеря зависит от каждого веса в глубине сети. Считать это «в лоб» невозможно. Но правило цепочки превращает задачу в произведение локальных производных: ошибку «прогоняют назад» от потери ко входу, перемножая производные слоёв. Этот алгоритм называется обратное распространение ошибки (backpropagation). Без правила цепочки глубокого обучения бы не существовало.

Итог

• Правило цепочки: производная f(g(x)) равна f'(g(x))·g'(x).
• Для длинной цепочки производные звеньев просто перемножаются.
• Нейросеть — композиция функций; цепочка даёт градиент по каждому весу.
• Алгоритм backpropagation = правило цепочки, применённое от потери ко входу.