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

SGD означает стохастический градиентный спуск. Это алгоритм оптимизации, используемый для минимизации функции стоимости модели машинного обучения. Ключевое различие между SGD и пакетным градиентным спуском (BGD) заключается в том, что вместо использования всего набора данных для вычисления градиента на каждом шаге SGD случайным образом выбирает одну точку данных или небольшое подмножество точек данных (также называемое мини-пакетом) для вычисления. градиент.

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

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

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

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

Сравнение времени между SGD и BGD

Если мы сравним SGD и BGD с одинаковым количеством эпох и предположим, что мы используем одно и то же оборудование и одинаковую скорость обучения, верно, что SGD (с размером мини-пакета 1) будет выполнять больше вычислений, чем BGD для каждого эпоха. Это связано с тем, что в SGD нам нужно вычислить градиент для каждой отдельной точки данных, а в BGD мы вычисляем градиент для всего набора данных.

Например, если у нас есть 10 000 точек данных и мы обучаем 10 эпох, то с SGD мы выполним 100 000 (10 000 x 10) вычислений, чтобы обновить параметры модели. Напротив, с BGD мы выполним только 10 расчетов (1 расчет на эпоху) для обновления параметров модели.

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

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

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

from sklearn.datasets import load_diabetes

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score
from sklearn.model_selection import train_test_split
import time
X,y = load_diabetes(return_X_y=True)
print(X.shape)
print(y.shape)
>>> (442, 10)
>>> (442,)
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=2)
reg = LinearRegression()
reg.fit(X_train,y_train)
LinearRegression()
print(reg.coef_)
print(reg.intercept_)
>>> [  -9.16088483 -205.46225988  516.68462383  340.62734108 -895.54360867
  561.21453306  153.88478595  126.73431596  861.12139955   52.41982836]
>>> 151.88334520854633
y_pred = reg.predict(X_test)
r2_score(y_test,y_pred)
>>> 0.4399387660024645
class SGDRegressor:
    
    def __init__(self,learning_rate=0.01,epochs=100):
        
        self.coef_ = None
        self.intercept_ = None
        self.lr = learning_rate
        self.epochs = epochs
        
    def fit(self,X_train,y_train):
        # init your coefs
        self.intercept_ = 0
        self.coef_ = np.ones(X_train.shape[1])
        
        for i in range(self.epochs):
            for j in range(X_train.shape[0]):
                idx = np.random.randint(0,X_train.shape[0])
                
                y_hat = np.dot(X_train[idx],self.coef_) + self.intercept_
                
                intercept_der = -2 * (y_train[idx] - y_hat)
                self.intercept_ = self.intercept_ - (self.lr * intercept_der)
                
                coef_der = -2 * np.dot((y_train[idx] - y_hat),X_train[idx])
                self.coef_ = self.coef_ - (self.lr * coef_der)
        
        print(self.intercept_,self.coef_)
    
    def predict(self,X_test):
        return np.dot(X_test,self.coef_) + self.intercept_
sgd = SGDRegressor(learning_rate=0.01,epochs=40)
start = time.time()
sgd.fit(X_train,y_train)

print("The time taken is",time.time() - start)
>>> 157.2641767094034 [  58.34618831  -41.65635944  314.02875897  219.47021721   30.2641263
   -8.98591625 -165.98040412  132.42543708  294.42536821  122.71528461]
>>> The time taken is 0.17459607124328613
y_pred = sgd.predict(X_test)
r2_score(y_test,y_pred)
>>> 0.4205755931585481
from sklearn.linear_model import SGDRegressor
reg = SGDRegressor(max_iter=100,learning_rate='constant',eta0=0.01)
reg.fit(X_train,y_train)
C:\Users\91842\anaconda3\lib\site-packages\sklearn\linear_model\_stochastic_gradient.py:1220: ConvergenceWarning: Maximum number of iteration reached before convergence. Consider increasing max_iter to improve the fit.
  warnings.warn("Maximum number of iteration reached before "
SGDRegressor(learning_rate='constant', max_iter=100)
y_pred = reg.predict(X_test)
r2_score(y_test,y_pred)
>>> 0.43059547063734904

Отображение конвергенции

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

В (SGD) вы можете увидеть какое-то случайное поведение.

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

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

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

Вот некоторые ситуации, когда SGD может быть хорошим выбором:

1. Большие наборы данных. При работе с большими наборами данных вычисление градиента по всему набору данных может потребовать значительных вычислительных ресурсов. В таких случаях SGD можно использовать для обновления параметров модели с использованием мини-пакета точек данных, что может значительно сократить время вычислений.
2. Задачи невыпуклой оптимизации. В задачах невыпуклой оптимизации может быть много локальных минимумов, что затрудняет поиск глобального минимума алгоритмами оптимизации. Использование SGD может помочь оптимизатору уйти от локальных оптимумов и быстрее сходиться к глобальному минимуму.

1. Онлайн-обучение. При онлайн-обучении данные доступны в виде потока, и модель необходимо обновлять в режиме реального времени. В таких случаях SGD можно использовать для обновления параметров модели с использованием одной точки данных за раз, что делает его идеальным для сценариев онлайн-обучения.
2. Регуляризация: SGD также можно использовать для реализации методов регуляризации, таких как регуляризация L1 и L2, которые могут помочь предотвратить переоснащение и повысить эффективность обобщения модели.

планировщик скорости обучения

График скорости обучения. Использование фиксированной скорости обучения может быть неоптимальным, поскольку оптимальная скорость обучения может меняться во время обучения. Решение. Используйте график скорости обучения, который постепенно снижает скорость обучения с течением времени, например, уменьшая скорость обучения в 2 раза после фиксированного количества эпох.

вот более подробное сравнение сходимости пакетного градиентного спуска (BGD), стохастического градиентного спуска (SGD) и мини-пакетного градиентного спуска (MBGD):

БГД:

• Вычисляет градиент функции стоимости по всему обучающему набору.
• Обновляет параметры модели один раз за итерацию.
• Сходится медленнее, но неуклонно к минимуму функции стоимости.
• Может быть более стабильным, чем SGD и MBGD, но для сходимости может потребоваться больше времени.
• Требует больше памяти и вычислительных ресурсов, чем SGD и MBGD.

сингапурский доллар:

• Вычисляет градиент функции стоимости для одного обучающего примера.
• Обновляет параметры модели один раз для каждого примера.
• Сходится быстрее, но с большим количеством колебаний к минимуму функции стоимости.
• Может быть более чувствительным к выбору скорости обучения и случайности данных.
• Требует меньше памяти и вычислительных ресурсов, чем BGD.

МБГД:

• Вычисляет градиент функции стоимости для небольших случайных подмножеств обучающих данных (мини-пакетов).
• Обновляет параметры модели один раз за мини-пакет.
• Предлагает компромисс между скоростью SGD и стабильностью BGD.
• Сходится быстрее, чем BGD, и с меньшими колебаниями, чем SGD.
• Требует меньше памяти и вычислительных ресурсов, чем BGD, но больше, чем SGD.