Математический анализ для машинного обучения

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

Тип: Обучение Язык: Python Предварительные требования: Фаза 1, уроки 01–03 Время: около 60 минут

Цели обучения

• Вычислять численные и аналитические производные для распространённых функций ML (x^2, сигмоида, кросс-энтропии).
• Реализовать градиентный спуск с нуля для минимизации функции потерь в одном и двух измерениях.
• Вывести градиент модели линейной регрессии и обучить её с помощью ручного обновления весов.
• Объяснить матрицу Гессе, приближения рядами Тейлора и их связь с методами оптимизации.

Проблема

У вас есть нейронная сеть с миллионами весов. Каждый вес — это ручка настройки. Нужно понять, в какую сторону повернуть каждую из них, чтобы модель стала немного менее ошибочной. Математический анализ даёт это направление.

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

Концепция

Что такое производная?

Производная измеряет скорость изменения. Для функции y = f(x) производная f'(x) говорит вам: если немного изменить x, насколько изменится y?

Геометрически производная — это наклон касательной в точке.

f(x) = x^2:

x	f(x)	f’(x) (наклон)
0	0	0 (горизонтально, внизу)
1	1	2
2	4	4 (наклон касательной в этой точке)
3	9	6

При x=2 наклон равен 4. Если немного сдвинуть x вправо, y увеличится примерно на величину, в 4 раза большую этого сдвига. При x=0 наклон равен 0. Вы на дне чаши.

Формальное определение:

f'(x) = lim   f(x + h) - f(x)
        h->0  -----------------
                     h

В коде вы пропускаете предел и просто используете очень малое h. Это численная производная.

Частные производные: по одной переменной за раз

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

f(x, y) = x^2 + 3xy + y^2

df/dx = 2x + 3y     (считаем y константой)
df/dy = 3x + 2y     (считаем x константой)

Каждая частная производная отвечает на вопрос: если я немного изменю только этот вес, как изменится функция потерь?

Градиент: вектор всех частных производных

Градиент собирает все частные производные в один вектор. Для функции f(x, y, z) градиент равен:

grad f = [ df/dx, df/dy, df/dz ]

Градиент указывает в направлении наискорейшего возрастания. Чтобы минимизировать функцию, двигайтесь в противоположном направлении.

Контурный график f(x,y) = x^2 + y^2:

Функция образует чашу с концентрическими окружностями в качестве линий уровня. Минимум находится в точке (0, 0).

Точка	grad f	-grad f (направление спуска)
(1, 1)	[2, 2] (указывает вверх, от минимума)	[-2, -2] (указывает вниз, к минимуму)
(0, 0)	[0, 0] (горизонтально, в минимуме)	[0, 0]

Это градиентный спуск на картинке. Вычислите градиент, возьмите его с противоположным знаком, сделайте шаг.

Связь с оптимизацией

Обучение нейронной сети — это оптимизация. У вас есть функция потерь L(w1, w2, ..., wn), измеряющая, насколько модель ошибается. Вы хотите её минимизировать.

Правило обновления градиентного спуска:

  w_new = w_old - learning_rate * dL/dw

Для каждого веса:
  1. Вычислите частную производную потерь по этому весу
  2. Вычтите из веса небольшую величину, кратную ей
  3. Повторите

Скорость обучения управляет размером шага. Слишком большая — и вы проскочите цель. Слишком маленькая — и будете двигаться черепашьим шагом.

Ландшафт функции потерь (одномерный срез):

Функция потерь L(w) образует кривую с пиками и долинами при изменении веса w.

Характеристика	Описание
Глобальный минимум	Самая низкая точка на всей кривой — лучшее решение
Локальный минимум	Долина ниже соседних точек, но не самая низкая в целом
Наклон	Градиентный спуск движется вниз по наклону из любой начальной точки

Градиентный спуск следует вниз по наклону. Он может застрять в локальных минимумах, но в пространствах большой размерности (с миллионами весов) это редко представляет практическую проблему.

Численные и аналитические производные

Есть два способа вычислить производную.

Аналитический: вручную применить правила математического анализа. Для f(x) = x^2 производная равна f'(x) = 2x. Точно. Быстро.

Численный: приблизить производную с помощью определения. Вычислить f(x+h) и f(x-h) для очень малого h, а затем использовать разность.

Численный метод (центральная разность):

f'(x) ~= f(x + h) - f(x - h)
          -----------------------
                  2h

h = 0.0001 хорошо работает на практике

Численные производные медленнее, но работают для любой функции. Аналитические производные быстры, но требуют вывести формулу. Фреймворки нейронных сетей используют третий подход: автоматическое дифференцирование, которое механически вычисляет точные производные. Вы увидите его в фазе 3.

Производные простых функций вручную

Это производные, которые вы снова и снова будете встречать в ML.

Функция        Производная       Используется в
--------        ----------       ---------------
f(x) = x^2     f'(x) = 2x      Функциях потерь (MSE)
f(x) = wx + b  f'(w) = x        Линейном слое (градиент по весу)
                f'(b) = 1        Линейном слое (градиент по смещению)
                f'(x) = w        Линейном слое (градиент по входу)
f(x) = e^x     f'(x) = e^x     Softmax, attention
f(x) = ln(x)   f'(x) = 1/x     Кросс-энтропийной функции потерь
f(x) = 1/(1+e^-x)  f'(x) = f(x)(1-f(x))   Сигмоидной активации

Для f(x) = x^2:

f(x) = x^2    f'(x) = 2x

  x    f(x)   f'(x)   значение
  -2    4      -4      наклон влево (убывает)
  -1    1      -2      наклон влево (убывает)
   0    0       0      горизонтально (минимум!)
   1    1       2      наклон вправо (возрастает)
   2    4       4      наклон вправо (возрастает)

Для f(w) = wx + b при x=3, b=1:

f(w) = 3w + 1    f'(w) = 3

Производная по w — это просто x.
Если x велик, небольшое изменение w вызывает большое изменение выхода.

Цепное правило

Когда функции скомпонованы, цепное правило говорит, как их дифференцировать.

Если y = f(g(x)), то dy/dx = f'(g(x)) * g'(x)

Пример: y = (3x + 1)^2
  внешняя: f(u) = u^2       f'(u) = 2u
  внутренняя: g(x) = 3x + 1    g'(x) = 3
  dy/dx = 2(3x + 1) * 3 = 6(3x + 1)

Нейронные сети — это цепочки функций: вход -> линейный слой -> активация -> линейный слой -> активация -> потери. Обратное распространение ошибки — это цепное правило, многократно применённое от выхода ко входу. В этом и состоит весь алгоритм.

Матрица Гессе

Градиент говорит вам наклон. Матрица Гессе говорит вам кривизну.

Матрица Гессе — это матрица частных производных второго порядка. Для функции f(x1, x2, ..., xn) элемент (i, j) матрицы Гессе равен:

H[i][j] = d^2f / (dx_i * dx_j)

Для функции двух переменных f(x, y):

H = | d^2f/dx^2    d^2f/dxdy |
    | d^2f/dydx    d^2f/dy^2 |

Что матрица Гессе говорит в критической точке (где gradient = 0):

Свойство матрицы Гессе	Значение	Пример поверхности
Положительно определённая (все собственные значения > 0)	Локальный минимум	Чаша, направленная вверх
Отрицательно определённая (все собственные значения < 0)	Локальный максимум	Чаша, направленная вниз
Неопределённая (смешанные собственные значения)	Седловая точка	Поверхность в форме конского седла

Пример: f(x, y) = x^2 - y^2 (седловая функция)

df/dx = 2x       df/dy = -2y
d^2f/dx^2 = 2    d^2f/dy^2 = -2    d^2f/dxdy = 0

H = | 2   0 |
    | 0  -2 |

Собственные значения: 2 и -2 (одно положительное, одно отрицательное)
--> Седловая точка в (0, 0)

Сравните с f(x, y) = x^2 + y^2 (чаша):

H = | 2  0 |
    | 0  2 |

Собственные значения: 2 и 2 (оба положительные)
--> Локальный минимум в (0, 0)

Почему матрица Гессе важна в ML:

Метод Ньютона использует матрицу Гессе, чтобы делать более качественные шаги оптимизации, чем градиентный спуск. Вместо простого следования по наклону он учитывает кривизну:

Обновление Ньютона:    w_new = w_old - H^(-1) * gradient
Градиентный спуск:     w_new = w_old - lr * gradient

Метод Ньютона сходится быстрее, поскольку матрица Гессе «перемасштабирует» градиент: на крутых направлениях шаги становятся меньше, на плоских — больше.

Но есть нюанс: для нейронной сети с N параметрами матрица Гессе имеет размер N x N. Для модели с 1 миллионом параметров понадобилась бы матрица из 1 триллиона элементов. Поэтому мы используем приближения.

Метод	Что он использует	Стоимость	Сходимость
Градиентный спуск	Только производные первого порядка	O(N) на шаг	Медленная (линейная)
Метод Ньютона	Полную матрицу Гессе	O(N^3) на шаг	Быстрая (квадратичная)
L-BFGS	Приближённую матрицу Гессе из истории градиентов	O(N) на шаг	Средняя (сверхлинейная)
Adam	Адаптивные скорости для каждого параметра (приближение диагональной матрицей Гессе)	O(N) на шаг	Средняя
Естественный градиент	Матрицу информации Фишера (статистическая матрица Гессе)	O(N^2) на шаг	Быстрая

На практике Adam — оптимизатор по умолчанию для глубокого обучения. Он дёшево приближает информацию второго порядка, отслеживая скользящее среднее и дисперсию градиентов для каждого параметра.

Приближение рядом Тейлора

Любую гладкую функцию можно локально приблизить полиномом:

f(x + h) = f(x) + f'(x)*h + (1/2)*f''(x)*h^2 + (1/6)*f'''(x)*h^3 + ...

Чем больше членов вы включаете, тем лучше приближение, но только вблизи точки x.

Почему ряды Тейлора важны для ML:

• Тейлор первого порядка = градиентный спуск. Когда вы используете f(x + h) ~ f(x) + f'(x)*h, вы строите линейное приближение. Градиентный спуск минимизирует эту линейную модель, выбирая h = -lr * f'(x).

• Тейлор второго порядка = метод Ньютона. Используя f(x + h) ~ f(x) + f'(x)*h + (1/2)*f''(x)*h^2, вы получаете квадратичную модель. Её минимизация даёт h = -f'(x)/f''(x) — шаг Ньютона.

• Проектирование функций потерь. MSE и кросс-энтропия гладкие, то есть их разложения Тейлора хорошо себя ведут. Это не случайность. Гладкие потери делают оптимизацию предсказуемой.

Порядок приближения    Что оно описывает    Метод оптимизации
-------------------    -----------------    ------------------
0-й порядок (константа) Только значение      Случайный поиск
1-й порядок (линейный) Наклон                Градиентный спуск
2-й порядок (квадратичный) Кривизна          Метод Ньютона
Высшие порядки          Более тонкую структуру Редко используются в ML

Ключевая мысль: вся оптимизация на основе градиента на самом деле состоит в локальном приближении функции потерь и шаге к минимуму этого приближения.

Интегралы в ML

Производные показывают скорость изменения. Интегралы вычисляют накопления — площадь под кривой.

В ML вы редко вычисляете интегралы вручную, но эта концепция присутствует повсюду:

Вероятность. Для непрерывной случайной величины с плотностью p(x):

P(a < X < b) = integral from a to b of p(x) dx

Площадь под кривой плотности вероятности между a и b — это вероятность попасть в этот диапазон.

Математическое ожидание. Средний исход, взвешенный вероятностью:

E[f(X)] = integral of f(x) * p(x) dx

Ожидаемая функция потерь по распределению данных — это интеграл. Обучение минимизирует его эмпирическое приближение.

KL-дивергенция. Измеряет, насколько различаются два распределения:

KL(p || q) = integral of p(x) * log(p(x) / q(x)) dx

Используется в VAE, дистилляции знаний и байесовском выводе.

Нормировочные константы. В байесовском выводе:

p(w | data) = p(data | w) * p(w) / integral of p(data | w) * p(w) dw

Знаменатель — это интеграл по всем возможным значениям параметров. Его часто невозможно вычислить точно, поэтому мы используем приближения, такие как MCMC и вариационный вывод.

Понятие интеграла	Где оно встречается в ML
Площадь под кривой	Вероятность из функций плотности
Математическое ожидание	Функции потерь, минимизация риска
KL-дивергенция	VAE, оптимизация политики, дистилляция
Нормировка	Байесовские апостериорные распределения, знаменатель softmax
Маргинальное правдоподобие	Сравнение моделей, нижняя граница правдоподобия (ELBO)

Многомерное цепное правило в вычислительном графе

Цепное правило применяется не только к скалярным функциям в последовательности. В нейронной сети переменные разветвляются и объединяются. Вот как производные проходят через простой прямой проход:

Обратный проход вычисляет градиенты справа налево:

Каждая стрелка умножает на локальную производную. Градиент для любого параметра — произведение всех локальных производных на пути от потерь к этому параметру. Когда пути разветвляются и объединяются, вклады суммируются (многомерное цепное правило).

Именно этим и является обратное распространение ошибки: цепным правилом, систематически применённым в вычислительном графе от выхода ко входам.

Матрица Якоби

Когда функция отображает вектор в вектор (как слой нейронной сети), её производная — это матрица. Матрица Якоби содержит каждую частную производную каждого выхода по каждому входу.

Для f: R^n -> R^m матрица Якоби J — это матрица размера m x n:

	x1	x2	…	xn
f1	df1/dx1	df1/dx2	…	df1/dxn
f2	df2/dx1	df2/dx2	…	df2/dxn
…	…	…	…	…
fm	dfm/dx1	dfm/dx2	…	dfm/dxn

Вы не будете вручную вычислять матрицы Якоби для нейронных сетей. PyTorch делает это сам. Но знание об их существовании помогает понять формы тензоров при обратном распространении ошибки: если слой отображает R^n в R^m, его матрица Якоби имеет размер m x n. Градиент проходит назад через транспонирование этой матрицы.

Почему это важно для нейронных сетей

Каждый вес в нейронной сети получает градиент. Градиент говорит вам, как скорректировать этот вес, чтобы уменьшить функцию потерь.

Каждое обновление веса:

• W1 = W1 - lr * dL/dW1
• W2 = W2 - lr * dL/dW2

Прямой проход вычисляет предсказание и потери. Обратный проход вычисляет градиент потерь по каждому весу. Затем каждый вес делает небольшой шаг вниз. Повторяйте это миллионы шагов. Так работает глубокое обучение.

derivative-tangent

Соберите это

Шаг 1: Численная производная с нуля

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

def f(x):
    return x ** 2

for x in [-2, -1, 0, 1, 2]:
    numerical = numerical_derivative(f, x)
    analytical = 2 * x
    print(f"x={x:2d}  f'(x) numerical={numerical:.6f}  analytical={analytical:.1f}")

Численная производная совпадает с аналитической до многих знаков после запятой.

Шаг 2: Частные производные и градиенты

def numerical_gradient(f, point, h=1e-7):
    gradient = []
    for i in range(len(point)):
        point_plus = list(point)
        point_minus = list(point)
        point_plus[i] += h
        point_minus[i] -= h
        partial = (f(point_plus) - f(point_minus)) / (2 * h)
        gradient.append(partial)
    return gradient

def f_multi(point):
    x, y = point
    return x**2 + 3*x*y + y**2

grad = numerical_gradient(f_multi, [1.0, 2.0])
print(f"Numerical gradient at (1,2): {[f'{g:.4f}' for g in grad]}")
print(f"Analytical gradient at (1,2): [2*1+3*2, 3*1+2*2] = [{2*1+3*2}, {3*1+2*2}]")

Шаг 3: Градиентный спуск для поиска минимума f(x) = x^2

x = 5.0
lr = 0.1
for step in range(20):
    grad = 2 * x
    x = x - lr * grad
    print(f"step {step:2d}  x={x:8.4f}  f(x)={x**2:10.6f}")

Начиная с x=5, каждый шаг приближает вас к x=0 (минимуму).

Шаг 4: Градиентный спуск для двумерной функции

def f_2d(point):
    x, y = point
    return x**2 + y**2

point = [4.0, 3.0]
lr = 0.1
for step in range(30):
    grad = numerical_gradient(f_2d, point)
    point = [p - lr * g for p, g in zip(point, grad)]
    loss = f_2d(point)
    if step % 5 == 0 or step == 29:
        print(f"step {step:2d}  point=({point[0]:7.4f}, {point[1]:7.4f})  f={loss:.6f}")

Шаг 5: Сравнение численных и аналитических производных

import math

test_functions = [
    ("x^2",      lambda x: x**2,          lambda x: 2*x),
    ("x^3",      lambda x: x**3,          lambda x: 3*x**2),
    ("sin(x)",   lambda x: math.sin(x),   lambda x: math.cos(x)),
    ("e^x",      lambda x: math.exp(x),   lambda x: math.exp(x)),
    ("1/x",      lambda x: 1/x,           lambda x: -1/x**2),
]

x = 2.0
print(f"{'Function':<12} {'Numerical':>12} {'Analytical':>12} {'Error':>12}")
print("-" * 50)
for name, f, df in test_functions:
    num = numerical_derivative(f, x)
    ana = df(x)
    err = abs(num - ana)
    print(f"{name:<12} {num:12.6f} {ana:12.6f} {err:12.2e}")

Шаг 6: Численное вычисление матрицы Гессе

def hessian_2d(f, x, y, h=1e-5):
    fxx = (f(x + h, y) - 2 * f(x, y) + f(x - h, y)) / (h ** 2)
    fyy = (f(x, y + h) - 2 * f(x, y) + f(x, y - h)) / (h ** 2)
    fxy = (f(x + h, y + h) - f(x + h, y - h) - f(x - h, y + h) + f(x - h, y - h)) / (4 * h ** 2)
    return [[fxx, fxy], [fxy, fyy]]

def saddle(x, y):
    return x ** 2 - y ** 2

def bowl(x, y):
    return x ** 2 + y ** 2

H_saddle = hessian_2d(saddle, 0.0, 0.0)
H_bowl = hessian_2d(bowl, 0.0, 0.0)
print(f"Saddle Hessian: {H_saddle}")  # [[2, 0], [0, -2]] -- mixed signs
print(f"Bowl Hessian:   {H_bowl}")    # [[2, 0], [0, 2]]  -- both positive

Матрица Гессе седловой функции имеет собственные значения 2 и -2 (разные знаки, что подтверждает седловую точку). У чаши собственные значения равны 2 и 2 (оба положительны, что подтверждает минимум).

Шаг 7: Приближение Тейлора в действии

import math

def taylor_approx(f, f_prime, f_double_prime, x0, h, order=2):
    result = f(x0)
    if order >= 1:
        result += f_prime(x0) * h
    if order >= 2:
        result += 0.5 * f_double_prime(x0) * h ** 2
    return result

x0 = 0.0
for h in [0.1, 0.5, 1.0, 2.0]:
    true_val = math.sin(h)
    t1 = taylor_approx(math.sin, math.cos, lambda x: -math.sin(x), x0, h, order=1)
    t2 = taylor_approx(math.sin, math.cos, lambda x: -math.sin(x), x0, h, order=2)
    print(f"h={h:.1f}  sin(h)={true_val:.4f}  order1={t1:.4f}  order2={t2:.4f}")

Вблизи x0=0 выполняется sin(x) ~ x (Тейлор первого порядка). Приближение превосходно для малого h, но становится неточным для большого h. Поэтому градиентный спуск лучше всего работает с малыми скоростями обучения: каждый шаг предполагает, что линейное приближение точно.

Шаг 8: Почему это важно для нейронной сети

import random

random.seed(42)

w = random.gauss(0, 1)
b = random.gauss(0, 1)
lr = 0.01

xs = [1.0, 2.0, 3.0, 4.0, 5.0]
ys = [3.0, 5.0, 7.0, 9.0, 11.0]

for epoch in range(200):
    total_loss = 0
    dw = 0
    db = 0
    for x, y in zip(xs, ys):
        pred = w * x + b
        error = pred - y
        total_loss += error ** 2
        dw += 2 * error * x
        db += 2 * error
    dw /= len(xs)
    db /= len(xs)
    total_loss /= len(xs)
    w -= lr * dw
    b -= lr * db
    if epoch % 40 == 0 or epoch == 199:
        print(f"epoch {epoch:3d}  w={w:.4f}  b={b:.4f}  loss={total_loss:.6f}")

print(f"\nLearned: y = {w:.2f}x + {b:.2f}")
print(f"Actual:  y = 2x + 1")

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

Используйте это

С NumPy те же операции выполняются быстрее и более лаконично:

import numpy as np

x = np.array([1, 2, 3, 4, 5], dtype=float)
y = np.array([3, 5, 7, 9, 11], dtype=float)

w, b = np.random.randn(), np.random.randn()
lr = 0.01

for epoch in range(200):
    pred = w * x + b
    error = pred - y
    loss = np.mean(error ** 2)
    dw = np.mean(2 * error * x)
    db = np.mean(2 * error)
    w -= lr * dw
    b -= lr * db

print(f"Learned: y = {w:.2f}x + {b:.2f}")

Вы только что создали градиентный спуск с нуля. PyTorch автоматизирует вычисление градиентов, но цикл обновления идентичен.

Упражнения

1. Реализуйте numerical_second_derivative(f, x), дважды вызывая numerical_derivative. Убедитесь, что вторая производная x^3 при x=2 равна 12.
2. Используйте градиентный спуск, чтобы найти минимум f(x, y) = (x - 3)^2 + (y + 1)^2. Начните из (0, 0). Ответ должен сойтись к (3, -1).
3. Добавьте импульс в цикл градиентного спуска: поддерживайте вектор скорости, который накапливает прошлые градиенты. Сравните скорость сходимости с импульсом и без него для f(x) = x^4 - 3x^2.

Ключевые термины

Термин	Что обычно говорят	Что это означает на самом деле
Производная	«Наклон»	Скорость изменения функции в точке. Показывает, насколько меняется выход при единичном изменении входа.
Частная производная	«Производная одной переменной»	Производная по одной переменной при удержании всех остальных постоянными.
Градиент	«Направление наискорейшего возрастания»	Вектор всех частных производных. Указывает направление, в котором функция возрастает быстрее всего.
Градиентный спуск	«Идти вниз»	Вычесть градиент (умноженный на скорость обучения) из параметров, чтобы уменьшить потери. Основа обучения нейронных сетей.
Скорость обучения	«Размер шага»	Скаляр, который управляет размером каждого шага градиентного спуска. Слишком большая: расходимость. Слишком малая: медленная сходимость.
Цепное правило	«Умножить производные»	Правило дифференцирования составных функций: df/dx = df/dg * dg/dx. Математическая основа обратного распространения ошибки.
Якобиан	«Матрица производных»	Когда функция отображает векторы в векторы, якобиан — это матрица всех частных производных выходов по входам.
Численная производная	«Конечные разности»	Приближение производной путём вычисления функции в двух близких точках и нахождения наклона между ними.
Обратное распространение ошибки	«Автоматическое дифференцирование в обратном режиме»	Вычисление градиентов слой за слоем от выхода ко входу с использованием цепного правила. Так обучаются нейронные сети.
Матрица Гессе	«Матрица вторых производных»	Матрица всех частных производных второго порядка. Описывает кривизну функции. Положительно определённая матрица Гессе в критической точке означает локальный минимум.
Ряд Тейлора	«Полиномиальное приближение»	Приближение функции около точки с использованием её производных: f(x+h) ~ f(x) + f'(x)h + (1/2)f''(x)h^2 + .... Основа понимания работы градиентного спуска и метода Ньютона.
Интеграл	«Площадь под кривой»	Накопление величины на диапазоне. В ML интегралы определяют вероятности, математические ожидания и KL-дивергенцию.

Дополнительные материалы

• 3Blue1Brown: Essence of Calculus — визуальная интуиция для производных, интегралов и цепного правила.
• Stanford CS231n: Backpropagation — как градиенты проходят через слои нейронной сети.

---

Источник: Calculus for Machine Learning — оригинал Навигация: назад: 01.03 — Матричные преобразования · Фаза 1 — Математические основы · Полный каталог · далее: 01.05 — Цепное правило и автоматическое дифференцирование.