Когда студент впервые слышит про градиентный спуск, ему часто говорят что-то вроде: “это алгоритм, который минимизирует функцию ошибки”. Формально это правильно, но почти бесполезно для понимания. Человек запоминает фразу, но не начинает чувствовать саму идею.

На практике градиентный спуск — это центральный механизм обучения почти всей современной индустрии Machine Learning и Deep Learning. Линейная регрессия, логистическая регрессия, нейронные сети, глубокие сети, autoencoder, transformer — у всех этих моделей разные архитектуры, разные функции потерь, разные данные, но обучаются они через одну и ту же логику: модель делает предсказание, мы измеряем ошибку, а потом двигаем параметры так, чтобы ошибка стала меньше.

Поэтому понимать градиентный спуск — значит понимать не одну тему из учебника, а сам язык обучения моделей.

Почему без оптимизации модель остаётся просто формулой

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

Например, даже простейшая линейная модель уже содержит неизвестные параметры:

Раздел математики: линейная алгебра и математическая статистика

Линейная модель:

$$ \hat{y} = Xw + b $$

Обозначения:

  • \(\hat{y}\) — вектор предсказаний модели;
  • \(X\) — матрица признаков, где строки — объекты, а столбцы — признаки;
  • \(w\) — вектор весов модели;
  • \(b\) — смещение модели.

Эта формула используется в линейной регрессии и как фундаментальная идея во множестве других моделей. Она показывает, что предсказание строится из данных и параметров. Но сама формула не говорит, как найти хорошие значения \(w\) и \(b\).

И вот здесь в модель приходит оптимизация. Мы должны не просто записать формулу, а сделать так, чтобы параметры модели начали соответствовать данным.

Ошибка — это язык, на котором данные разговаривают с моделью

Чтобы обучать модель, нужно сначала определить, что значит “модель ошибается”. В Machine Learning это делается через функцию потерь. Она переводит качество модели в число.

Для регрессии базовый пример — среднеквадратичная ошибка:

Раздел математики: математическая статистика

Среднеквадратичная ошибка:

$$ J(\theta) = \frac{1}{n}\sum_{i=1}^{n}\left(y_i - \hat{y}_i\right)^2 $$

Обозначения:

  • \(J(\theta)\) — функция потерь модели при параметрах \(\theta\);
  • \(n\) — количество объектов в выборке;
  • \(y_i\) — истинное значение целевой переменной для \(i\)-го объекта;
  • \(\hat{y}_i\) — предсказание модели для \(i\)-го объекта;
  • \(\theta\) — все параметры модели, например веса и смещения;
  • \(\left(y_i - \hat{y}_i\right)^2\) — квадрат ошибки на одном объекте.

Эта формула используется в задачах регрессии. Она нужна затем, чтобы превратить качество модели в конкретное число. Чем меньше значение \(J(\theta)\), тем ближе предсказания модели к истинным значениям.

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

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

Здесь начинается ключевая идея. Если функция потерь зависит от параметров модели, то её можно представить как поверхность. Для одной переменной это обычная кривая. Для двух параметров — поверхность. Для миллионов параметров, как в deep learning, это уже гигантский многомерный ландшафт.

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

Раздел математики: математический анализ и оптимизация

Шаг градиентного спуска:

$$ \theta_{t+1} = \theta_t - \eta \nabla J\left(\theta_t\right) $$

Обозначения:

  • \(\theta_t\) — параметры модели на шаге обучения \(t\);
  • \(\theta_{t+1}\) — параметры после обновления;
  • \(\eta\) — скорость обучения, или длина шага;
  • \(\nabla J\left(\theta_t\right)\) — градиент функции потерь в текущей точке;
  • \(J\left(\theta_t\right)\) — значение функции потерь при текущих параметрах.

Эта формула применяется почти во всех обучаемых моделях ML и DL. Она показывает, что новые параметры получаются из старых после движения в сторону уменьшения функции потерь.

Если говорить совсем живо, градиентный спуск — это поход по горам в тумане. Вы не видите весь ландшафт, но можете определить локальный наклон. Градиент показывает, куда вверх. Значит, чтобы спускаться, нужно идти в противоположную сторону.

Геометрическая интерпретация: почему оптимизация — это не абстракция

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

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

В нейронных сетях всё сложнее. Пространство параметров огромно, поверхность ошибки многообразна, с плато, узкими долинами и разной кривизной. Но принцип всё равно тот же: мы не ищем решение “угадыванием”, мы шаг за шагом двигаемся по геометрии функции потерь.

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

Почему скорость обучения может как спасти модель, так и сломать её

В формуле обновления есть один параметр, который кажется скромным, но на практике играет огромную роль: \(\eta\), learning rate.

Если скорость обучения слишком маленькая, модель идёт к минимуму очень медленно. Обучение может тянуться бесконечно, а прогресс будет почти незаметен.

Если скорость обучения слишком большая, модель начинает перепрыгивать минимум. Вместо спуска получается нервное метание по поверхности ошибки.

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

В Deep Learning это особенно критично. Плохой learning rate может сделать так, что хорошая архитектура будет обучаться ужасно, а проблема покажется “в модели”, хотя на самом деле сломана оптимизация.

Откуда в Deep Learning берётся backpropagation

На этом месте у студентов часто возникает следующий вопрос: если в линейной модели градиент ещё можно понять руками, то как он считается в нейронной сети с десятками слоёв?

Ответ — через правило цепочки. Именно оно лежит в основе backpropagation.

Раздел математики: математический анализ

Правило цепочки:

$$ \frac{dJ}{dx} = \frac{dJ}{du}\cdot\frac{du}{dx} $$

Обозначения:

  • \(J\) — итоговая функция потерь;
  • \(x\) — исходная переменная или параметр, по которому нужен градиент;
  • \(u\) — промежуточная переменная, через которую выражается зависимость;
  • \(\frac{dJ}{dx}\) — производная функции потерь по \(x\);
  • \(\frac{dJ}{du}\) — чувствительность функции потерь к промежуточной переменной;
  • \(\frac{du}{dx}\) — чувствительность промежуточной переменной к \(x\).

Эта формула используется в backpropagation. Она позволяет передавать информацию об ошибке от выхода сети назад к её параметрам, слой за слоем.

Интуитивно backpropagation — это распространение ответственности за ошибку назад по сети. Выход ошибся. Значит, нужно понять, какие параметры к этой ошибке привели и насколько сильно. Правило цепочки делает именно это.

Поэтому в Deep Learning градиентный спуск и backpropagation работают как пара:

  • backpropagation считает градиенты;
  • градиентный спуск использует эти градиенты для обновления параметров.

Почему в Machine Learning и Deep Learning используют разные варианты градиентного спуска

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

Поэтому появилось несколько режимов:

  • Batch Gradient Descent — градиент считается по всей выборке;
  • Stochastic Gradient Descent — обновление идёт по одному объекту;
  • Mini-Batch Gradient Descent — обновление идёт по маленькому батчу объектов.

В Deep Learning почти всегда побеждает mini-batch подход. Он даёт разумный компромисс: градиент достаточно информативный, но при этом вычисление остаётся быстрым и хорошо ложится на GPU.

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

Почему появились Adam, RMSprop и Momentum

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

Их идея проста: не просто идти в направлении текущего градиента, а учитывать историю прошлых шагов и масштаб координат.

Например, Momentum сглаживает движение и помогает не дёргаться на шумных участках. RMSprop и Adam адаптируют шаг по разным параметрам по-разному. Это особенно полезно в deep learning, где разные части сети могут иметь очень разную чувствительность.

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

Как связь между математикой, ML и Python выглядит на практике

Хороший способ действительно понять тему — не только прочитать формулу, но и увидеть, как она превращается в код. Ниже — простой пример обучения линейной регрессии через ручной градиентный спуск. Это не deep learning framework, а учебная реализация, которая помогает почувствовать механику.

example.pyPython
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 = 0.0
b = 0.0
eta = 0.01
n = len(X)

for epoch in range(2000):
    y_pred = w * X + b

    loss = np.mean((y - y_pred) ** 2)

    dw = (-2 / n) * np.sum(X * (y - y_pred))
    db = (-2 / n) * np.sum(y - y_pred)

    w = w - eta * dw
    b = b - eta * db

print("w =", w)
print("b =", b)
print("loss =", loss)

Что здесь происходит по смыслу:

  • модель строит предсказание через текущие параметры \(w\) и \(b\);
  • ошибка измеряется через \(MSE\);
  • производные по параметрам дают направление, в котором ошибка растёт;
  • вычитание градиента двигает параметры к лучшему решению.

Это очень важный момент: Python здесь не заменяет математику. Он просто исполняет то, что уже заложено в формулах.

А где здесь Deep Learning?

С математической точки зрения deep learning — это та же логика, только модель становится глубже и сложнее. Вместо одного слоя у вас много слоёв. Вместо одной линейной комбинации — композиция преобразований. Вместо пары параметров — миллионы.

Но процесс обучения не меняется принципиально:

  • вход проходит вперёд через сеть;
  • считается функция потерь;
  • через backpropagation вычисляются градиенты;
  • оптимизатор обновляет параметры.

То есть deep learning не отменяет градиентный спуск. Он, наоборот, делает его ещё важнее. Если в классическом ML можно встретить аналитические решения, то в deep learning без градиентной оптимизации вообще ничего не обучается.

Что чаще всего мешает понять градиентный спуск

Есть три типичные ошибки в восприятии темы.

  • Первая: думать, что градиентный спуск — это отдельный алгоритм из маленькой главы, а не центральная идея обучения моделей.
  • Вторая: запомнить формулу обновления, но не понимать геометрию движения по поверхности ошибки.
  • Третья: видеть в PyTorch или TensorFlow магию, хотя под капотом работают те же градиенты, шаги и функции потерь.

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

Главная мысль, без которой тема остаётся мёртвой

Градиентный спуск — это не просто формула обновления параметров. Это способ связать три мира:

  • мир математики, где есть производные и поверхности функций;
  • мир машинного обучения, где есть модели и функции потерь;
  • мир Python-реализации, где параметры действительно меняются шаг за шагом.

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

Если эта идея действительно уложилась, то дальше и Machine Learning, и Deep Learning начинают выглядеть намного менее мистически. Остаются не “чёрные ящики”, а системы, в которых ошибка измеряется, градиент считается, параметры обновляются, а модель постепенно учится видеть закономерность в данных.