Алгоритм градиентного спуска в машинном обучении

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

В статье разберем, как работает градиентный спуск, зачем нужна скорость обучения, почему важен масштаб признаков, чем отличаются batch, stochastic и mini-batch gradient descent, а также как реализовать базовый вариант алгоритма на Python с NumPy.

Что внутри:

что такое градиентный спуск простыми словами;
как функция стоимости связана с обучением модели;
как алгоритм обновляет параметры модели;
зачем нужна скорость обучения;
что происходит при слишком маленьком или слишком большом learning rate;
почему признаки нужно приводить к одному масштабу;
batch gradient descent;
stochastic gradient descent;
mini-batch gradient descent;
пример реализации градиентного спуска на Python.

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

Алгоритм градиентного спуска

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

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

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

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

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

Пакетный градиентный спуск:

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

# Batch Gradient Descent
import numpy as np
eta = 0.1 # learning rate
n_iterations = 1000
m = 100

X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)
X_b = np.c_[np.ones((100, 1)), X]  # add x0 = 1 to each instance
theta = np.random.randn(2,1) #random initilization
for iteration in range(n_iterations):
    gradients = 2/m * X_b.T.dot(X_b.dot(theta)-y)
    theta = theta - eta * gradients
print(theta)

Стохастический градиентный спуск:

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

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

# Stochastic Gradient Descent
n_epochs = 50
t0, t1 = 5, 50 #learning schedule hyperparameters
m = 100
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)
X_b = np.c_[np.ones((100, 1)), X]  # add x0 = 1 to each instance
def learning_schedule(t):
    return t0/(t+t1)

theta = np.random.randn(2,1) #random initilization
for epoch in range(n_epochs):
    for i in range(m):
        random_index = np.random.randint(m)
        xi = X_b[random_index:random_index+1]
        yi = y[random_index:random_index+1]
        gradients = 2 * xi.T.dot(xi.dot(theta)-yi)
        eta = learning_schedule(epoch * m + i)
        theta = theta - eta * gradients
print(theta)

Мини-пакетный градиентный спуск:

Последний тип алгоритма градиентного спуска – это мини-пакетный градиентный спуск. Он вычисляет градиенты для небольших случайных наборов экземпляров, известных как мини-пакеты, вместо вычисления набора обучающих данных или одного случайного экземпляра. Теперь давайте посмотрим, как реализовать это с помощью Python:

# Mini-batch Gradient Descent
n_iterations = 50
minibatch_size = 20
m = 100
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)
X_b = np.c_[np.ones((100, 1)), X]  # add x0 = 1 to each instance
np.random.seed(42)
theta = np.random.randn(2,1)  # random initialization

t0, t1 = 200, 1000
def learning_schedule(t):
    return t0 / (t + t1)

t = 0
for epoch in range(n_iterations):
    shuffled_indices = np.random.permutation(m)
    X_b_shuffled = X_b[shuffled_indices]
    y_shuffled = y[shuffled_indices]
    for i in range(0, m, minibatch_size):
        t += 1
        xi = X_b_shuffled[i:i+minibatch_size]
        yi = y_shuffled[i:i+minibatch_size]
        gradients = 2/minibatch_size * xi.T.dot(xi.dot(theta) - yi)
        eta = learning_schedule(t)
        theta = theta - eta * gradients
print(theta)

Резюме

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

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

Вопрос: Что такое градиентный спуск?

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

Вопрос: Зачем нужен градиентный спуск в машинном обучении?

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

Вопрос: Что такое скорость обучения?

Ответ: Скорость обучения, или learning rate, определяет размер шага при обновлении параметров. Если шаг слишком маленький, обучение идет медленно. Если слишком большой, алгоритм может не сойтись к хорошему решению.

Вопрос: Чем batch gradient descent отличается от stochastic gradient descent?

Ответ: Batch gradient descent использует весь набор данных для одного шага обновления, а stochastic gradient descent обновляет параметры по одному примеру. Mini-batch использует небольшие группы примеров.

Вопрос: Почему перед градиентным спуском масштабируют признаки?

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

← Предыдущая статья

Алгоритм полиномиальной регрессии

Следующая статья →

Поиск по сетке для настройки модели