Что такое градиент?

Градиент: математика и практика

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

Математическое определение

Градиент функции f(x) — это вектор, содержащий все частные производные функции по каждому переменному:

∇f = [∂f/∂x1, ∂f/∂x2, ..., ∂f/∂xn]

Для функции одной переменной f(x), градиент — это просто производная:

df/dx

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

∇f = [∂f/∂x, ∂f/∂y]

Геометрический смысл

Градиент указывает на направление наибольшего возрастания функции:

• Направление: в какую сторону идти, чтобы быстрее всего возрастала функция
• Величина: насколько быстро растёт функция в этом направлении

Если мы идём в направлении против градиента (-∇f), мы движемся в сторону уменьшения функции — именно это используется при обучении моделей.

Пример для интуиции

Имагинируй, ты стоишь на холме в тумане и не видишь окружающее. Как найти самую низкую точку (впадину)?

Ты пощупаешь землю под ногами (вычислишь градиент):

• Градиент покажет, в какую сторону земля повышается
• Ты пойдёшь в противоположную сторону
• Повторишь несколько раз — спустишься в низину

Это и есть gradient descent (градиентный спуск).

Градиентный спуск в машинном обучении

Цель обучения модели — минимизировать функцию потерь L (loss function):

Минимизировать: L(w) = (1/N) * Σ(y_true - y_pred(w))^2

где w — параметры модели (weights, coefficients).

Алгоритм:

1. Инициализировать w случайными значениями
2. Вычислить градиент: ∇L(w) = ∂L/∂w
3. Обновить параметры: w = w - α * ∇L(w), где α — learning rate
4. Повторить шаги 2–3 до сходимости

Пример: Линейная регрессия

Представим модель y = w*x + b с одним признаком и одним параметром w.

Функция потерь (Mean Squared Error):

L(w) = (1/N) * Σ(y_i - (w*x_i + b))^2

Градиент:

∂L/∂w = (2/N) * Σ(-(y_i - (w*x_i + b)) * x_i)

Обновление:

w_new = w - α * ∂L/∂w

import numpy as np

X = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 5, 4, 5])
w = 0.5  # Initial weight
b = 0.0
alpha = 0.01  # Learning rate

for epoch in range(100):
    # Predictions
    y_pred = w * X + b
    
    # Gradients
    N = len(X)
    dL_dw = (2/N) * np.sum(-(y - y_pred) * X)
    dL_db = (2/N) * np.sum(-(y - y_pred))
    
    # Update
    w = w - alpha * dL_dw
    b = b - alpha * dL_db
    
    # Loss
    loss = np.mean((y - y_pred)**2)
    if epoch % 20 == 0:
        print(f"Epoch {epoch}, Loss: {loss:.4f}, w: {w:.3f}, b: {b:.3f}")

Типы градиентного спуска

1. Batch Gradient Descent

Вычисляем градиент на всем датасете:

w = w - α * ∇L(w) где L(w) вычислена на всех примерах

Преимущества: Стабильная сходимость, точная оценка градиента Недостатки: Медленно на больших данных

2. Stochastic Gradient Descent (SGD)

Вычисляем градиент на одном примере:

w = w - α * ∇L(w, x_i, y_i) где градиент по одному примеру

Преимущества: Быстро, работает с потоковыми данными Недостатки: Шумная оценка градиента, колебания

3. Mini-Batch Gradient Descent

Вычисляем градиент на батче (subset данных):

w = w - α * ∇L(w, X_batch, y_batch)

Это хороший баланс между двумя предыдущими подходами. Используется в deep learning.

Практический пример в sklearn

from sklearn.linear_model import SGDRegressor
from sklearn.preprocessing import StandardScaler

# Модель с SGD
model = SGDRegressor(
    loss='squared_error',
    max_iter=1000,
    learning_rate='optimal',
    eta0=0.01,
    random_state=42
)

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_train)
model.fit(X_scaled, y_train)

# Предсказание
y_pred = model.predict(scaler.transform(X_test))

Проблемы и решения

Локальные минимумы

Градиентный спуск может застрять в локальном минимуме вместо глобального:

     Global minimum
          ||
         /  \
        /    \
       /      \
      /    ∘   \   ← Застрял здесь
     /         \

Решения: Стохастичность (SGD), различные инициализации, momentum.

Выбор learning rate (α)

• Слишком большой: Может прыгнуть через минимум
• Слишком маленький: Очень медленная сходимость

Решение: Adaptive learning rates (Adam, RMSprop):

from tensorflow.keras.optimizers import Adam

optimizer = Adam(learning_rate=0.001)

Исчезающий градиент (Vanishing Gradient)

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

Решения: ReLU вместо sigmoid, batch normalization, skip connections.

Численное вычисление градиента (Numerical Gradient)

Если аналитическую формулу сложно вывести, используют численное приближение:

∂f/∂x ≈ (f(x + ε) - f(x - ε)) / (2*ε)

где ε — малое число (обычно 1e-5).

def numerical_gradient(f, x, eps=1e-5):
    grad = np.zeros_like(x)
    for i in range(x.shape[0]):
        x_plus = x.copy()
        x_minus = x.copy()
        x_plus[i] += eps
        x_minus[i] -= eps
        grad[i] = (f(x_plus) - f(x_minus)) / (2 * eps)
    return grad

Visualization

import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Создание поверхности функции
X = np.linspace(-5, 5, 100)
Y = np.linspace(-5, 5, 100)
X_grid, Y_grid = np.meshgrid(X, Y)
Z = X_grid**2 + Y_grid**2  # Парабола

fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(X_grid, Y_grid, Z, cmap='viridis')
plt.title('Функция потерь и градиентный спуск')
plt.show()

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