Skip to content

07. Градиент: от производной до check_gradient ​

Вторая часть задания — линейный классификатор. Чтобы обучать его, нужно уметь считать градиент функции потерь: вектор, который говорит, в какую сторону двигать веса, чтобы loss уменьшался. Этот урок — фундамент: разберём численную производную и реализуем утилиту check_gradient, которая будет автопроверять все наши будущие градиенты.

Зачем градиент ​

У нас будет функция «потерь» L(w) (число: насколько модель ошибается). Мы хотим найти веса w, при которых L мала. Алгоритм градиентного спуска делает шаги:

w←w−η⋅∇L(w)

где η — learning rate (размер шага), ∇L — градиент (вектор частных производных ∂L/∂wi). Градиент указывает наискорейший рост функции; поэтому чтобы уменьшать loss — шагаем в противоположную сторону.

Численная производная (two-point / центральная разность) ​

Аналитическая производная — это предел. Численно её приближают. Самая простая — прямая разность: f′(x)≈(f(x+h)−f(x))/h. Точность — O(h): грубовато.

Лучше центральная (two-point) разность:

f′(x)≈f(x+h)−f(x−h)2h

Точность — O(h2): в разы точнее при том же h. Именно её использует check_gradient.

Ручной пример: f(x)=x2 в точке x=3 ​

Аналитически: f′(x)=2x, значит f′(3)=6.

Численно, h=10−5:

  • f(3+10−5)=9.0000600001
  • f(3−10−5)=8.9999400001
  • (f(x+h)−f(x−h))/(2h)=(9.0000600001−8.9999400001)/2⋅10−5≈6.0000

Совпало. Если бы наша аналитическая реализация вернула, скажем, 3.0 (забыли умножить на 2) — численная проверка поймала бы расхождение.

TODO: check_gradient в gradient_check.py ​

Разберём скелет. Функция получает:

  • f — функцию, которая по точке x возвращает кортеж(value, analytic_grad) — значение функции и ваш аналитический градиент;
  • x — точку, где проверяем (обязательно float-массив);
  • delta — шаг (по умолчанию 1e-5);
  • tol — допуск (по умолчанию 1e-4).

Скелет уже обходит все координаты x через np.nditer с флагом multi_index и на каждой координате сравнивает аналитическую производную с численной. Численная — как раз и есть наш TODO:

python
# Мы идём по всем измерениям x и считаем для каждого численную производную
it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite'])
while not it.finished:
    ix = it.multi_index
    analytic_grad_at_ix = analytic_grad[ix]
    numeric_grad_at_ix = 0

    # TODO compute value of numeric gradient of f to idx
    if not np.isclose(numeric_grad_at_ix, analytic_grad_at_ix, tol):
        print("Gradients are different at %s. ..." % (...))
        return False
    it.iternext()

Решение TODO ​

python
    # Центральная (two-point) разность по одной координате
    x[ix] += delta
    fx_plus, _ = f(x)
    x[ix] -= 2 * delta
    fx_minus, _ = f(x)
    x[ix] += delta                       # возвращаем x в исходное состояние
    numeric_grad_at_ix = (fx_plus - fx_minus) / (2 * delta)

Важные детали:

  1. Меняем ровно одну координату (x[ix]), остальные остаются на месте — это и есть частная производная ∂f/∂xix;
  2. f(x) возвращает кортеж — значение и градиент; нам нужно только значение (fx_plus), градиент отбрасываем (_);
  3. Возвращаем x на место (x[ix] += delta в конце) — иначе на следующей итерации мы будем проверять уже «сбитую» точку;
  4. Знаки и порядок: f(x+h) - f(x-h), делить на 2h (не h).

Прогоняем контрольные функции (ноутбук, ячейка 6) ​

В ноутбуке уже даны три «эталонные» функции — на них должна пройти проверка:

python
def square(x):
    return float(np.sum(x * x)), 2 * x

check_gradient(square, np.array([3.0]))

def array_sum(x):
    assert x.shape == (2,)
    return np.sum(x), np.ones_like(x)

check_gradient(array_sum, np.array([3.0, 2.0]))

def array_2d_sum(x):
    assert x.shape == (2, 2)
    return np.sum(x), np.ones_like(x)

check_gradient(array_2d_sum, np.array([[3.0, 2.0], [1.0, 0.0]]))

Ожидаемый вывод:

text
Gradient check passed!
Gradient check passed!
Gradient check passed!

Вспомни урок 01: в square стоит float(np.sum(x * x)), а неfloat(x * x). На numpy 2.x float() от одноэлементного массива падает с TypeError. Это исправление уже в нашем ноутбуке.

Как читать падение check_gradient ​

Если градиент неверен, функция печатает:

text
Gradients are different at (0,). Analytic: 3.00000, Numeric: 6.00000
  • Расхождение в 2 раза (3 против 6) — чаще всего забыт множитель (в square — 2x) или деление на размерность;
  • Знак противоположный (−6 против 6) — перепутано «спуск/восход» или знак в формуле;
  • Расхождение на всех координатах равномерно — ошибка в общем виде формулы (например, забыто усреднение по батчу);
  • Расхождение только на некоторых координатах — off-by-one в индексации, перепутаны оси.

Интерактив: почувствуйте шаг градиентного спуска ​

На стенде — «чашка» (выпуклая функция от двух переменных). Точка — текущие веса. Кнопка Step делает один шаг w←w−η∇f. Крутите learning rate: слишком малый — ползёте, слишком большой — расхождение (точка улетает, loss растёт). Слайдер «reset» возвращает старт.

шагов: 0

f(x, y) = 100.0938

x = -9.500, y = 7.500

grad = (-19.000, 2.625)

|grad| = 19.1805

История f (последние 12):
100.094

Связь с тем, что будет дальше ​

Каждая следующая функция задания (softmax_with_cross_entropy, linear_softmax, l2_regularization) будет возвращать (value, grad) — ту же сигнатуру, что и square выше. И каждая будет проверяться тем же check_gradient. Поэтому, разобрав один раз механику, вы получите бесплатную автопроверку для всех будущих градиентов.

Практика ​

1. Для f(x)=x3 в точке x=2: аналитическая производная = ? Сколько даст численная two-point с h=10−5 (прикиньте)?

2. Почему в check_gradient после вычисления fx_minus обязательно x[ix] += delta? Что произойдёт, если эту строку удалить (что будет с второй итерацией цикла)?

3. Функция cube_grad(x) возвращает (float(np.sum(x**3)), 3*x**2). Пройдёт ли check_gradient(cube_grad, np.array([1.0, 2.0]))? А если в градиенте ошибочно написать 3*x (вместо 3*x**2)? Что покажет вывод?

Показать решения

1. Аналитически: f′(x)=3x2, f′(2)=3⋅4=12. Численно раскроем: (2+h)3−(2−h)3=(8+12h+6h2+h3)−(8−12h+6h2−h3)=24h+2h3. Делим на 2h: 12+h2. При h=10−5 это 12+10−10≈12.0000000000 — совпало с аналитикой с точностью O(h2). Именно поэтому two-point и точнее прямой разности (у неё погрешность O(h), а тут O(h2)).

2. Без x[ix] += delta после вычисления fx_minus массив x остаётся уменьшенным на delta. На следующей итерации цикла мы берём новую координату, но «база» уже сдвинута → численная производная считается в сбитой точке, и проверка ложно падает (или, хуже, ложно проходит). Возврат исходного состояния — часть контракта check_gradient (см. и assert np.all(np.isclose(orig_x, x, tol)) в начале — функция не должна менять вход).

3. Для 3*x**2: check_gradient пройдёт (градиент корректен). Для 3*x (ошибка): в точке x=[1,2] аналитический grad = [3, 6], а численный: f′(1)=3, f′(2)=12. На координате (1,) расхождение 6 против 12 → вывод «Gradients are different at (1,). Analytic: 6.00000, Numeric: 12.00000», функция вернёт False.

Итоги урока ​

  • Градиентный спуск: w←w−η∇L; градиент — наискорейший рост, спускаемся против него;
  • Численная производная — центральная разность (f(x+h)−f(x−h))/2h, точность O(h2);
  • check_gradient обходит все координаты, меняет по одной, сравнивает аналитический и численный градиент с допуском tol;
  • Все будущие функции задания имеют сигнатуру f(x) → (value, grad) и проверяются этим же инструментом;
  • Типичные баги: забытый множитель (в 2 раза), знак, off-by-one.

Следующий урок — 08. Softmax и cross-entropy: первая «настоящая» функция с градиентом.