Задача оптимизатора — сделать функцию потерь как можно меньше, чтобы найти подходящие параметры для выполнения определенной задачи. В настоящее время основными оптимизаторами, используемыми при обучении моделей, являются SGD, RMSProp, Adam, AdaDelt и так далее. Оптимизаторы SGD с импульсом широко используются в научных кругах и промышленности, поэтому большинство выпускаемых моделей обучаются с помощью оптимизатора SGD с импульсом. Но у SGD-оптимизатора с импульсом есть два недостатка: во-первых, скорость сходимости низкая, во-вторых, трудно установить начальную скорость обучения, однако, если начальная скорость обучения установлена правильно, а модели обучены в достаточном количестве итераций. , модели, обученные SGD с помощью импульса, могут достигать более высокой точности по сравнению с моделями, обученными другими оптимизаторами. Некоторые другие оптимизаторы с адаптивной скоростью обучения, такие как Adam, RMSProp и т. д., стремятся сходиться быстрее, но окончательная точность сходимости будет немного хуже. Если вы хотите обучить модель с более высокой скоростью сходимости, мы рекомендуем вам использовать оптимизаторы с адаптивной скоростью обучения, но если вы хотите обучить модель с более высокой точностью, мы рекомендуем вам использовать оптимизатор SGD с импульсом.
Концепция скорости обучения: скорость обучения — это гиперпараметр для управления скоростью обучения, чем ниже скорость обучения, тем медленнее изменяется значение потерь, хотя использование низкой скорости обучения может гарантировать, что вы не пропустите ни один локальный минимум, но это также означает, что скорость конвергенции медленная, особенно когда градиент попадает в область градиентного плато.
=========================
Нейронные сети глубокого обучения обучаются с использованием алгоритма стохастического градиентного спуска.
Стохастический градиентный спуск — это алгоритм оптимизации, который оценивает градиент ошибки для текущего состояния модели, используя примеры из обучающего набора данных, а затем обновляет веса модели, используя алгоритм обратного распространения ошибок, называемый просто обратным распространением.
Величина, на которую веса обновляются во время обучения, называется размером шага или «скоростью обучения».
В частности, скорость обучения — это настраиваемый гиперпараметр, используемый при обучении нейронных сетей, который имеет небольшое положительное значение, часто в диапазоне от 0,0 до 1,0.Скорость обучения определяет, насколько быстро модель адаптируется к проблеме. Меньшие скорости обучения требуют большего количества эпох обучения, учитывая меньшие изменения, вносимые в веса при каждом обновлении, тогда как более высокие скорости обучения приводят к быстрым изменениям и требуют меньшего количества эпох обучения.Слишком большая скорость обучения может привести к слишком быстрой сходимости модели к неоптимальному решению, тогда как слишком маленькая скорость обучения может привести к зависанию процесса.
Задача обучения нейронных сетей глубокого обучения заключается в тщательном выборе скорости обучения. Это может быть самый важный гиперпараметр для модели.
============================
Стратегия снижения скорости обучения:Во время обучения, если мы всегда используем одну и ту же скорость обучения, мы не можем получить модель с максимальной точностью, поэтому скорость обучения следует регулировать во время обучения. На ранней стадии обучения веса находятся в состоянии случайной инициализации, а градиенты имеют тенденцию к снижению, поэтому мы можем установить относительно большую скорость обучения для более быстрой сходимости. На поздней стадии обучения веса близки к оптимальным значениям, оптимальное значение не может быть достигнуто при относительно большой скорости обучения, поэтому следует использовать относительно меньшую скорость обучения. Во время обучения многие исследователи используют стратегию снижения скорости обучения piecewise_decay, которая представляет собой пошаговое снижение скорости обучения. Например, при обучении ResNet50 начальная скорость обучения, которую установили, равна 0,1, и скорость обучения падает до 1/10 каждые 30 эпох, общее количество эпох для обучения равно 120. Помимо кусочного_распада, многие исследователи также предлагали другие способы уменьшить скорость обучения, например, polynomial_decay, exponential_decay и cosine_decay и т. д. Среди них cosine_decay стал предпочтительным методом снижения скорости обучения для повышения точности модели, поскольку нет необходимости настраивать гиперпараметры, а надежность относительно высока. Кривые скорости обучения cosine_decay и piecewise_decay показаны на следующих рисунках, легко заметить, что в течение всего процесса обучения cosine_decay сохраняет относительно большую скорость обучения, поэтому его сходимость медленнее, но конечная точность сходимости лучше, чем у один с использованием piecewise_decay.
Кроме того, мы также можем видеть из рисунков, что количество эпох с небольшой скоростью обучения в cosine_decay меньше, что повлияет на итоговую точность, поэтому, чтобы заставить cosine_decay играть лучше, рекомендуется использовать cosine_decay в большие эпохи, например, 200 эпох.
ResNet50 — это вариант модели ResNet, который имеет 48 слоев свертки, а также 1 слой MaxPool и 1 средний пул.
Он имеет 3,8 x 10 ^ 9 операций с плавающей запятой. Это широко используемая модель ResNet и ее архитектура хорошо известна.
========================================
Эффект адаптивных скоростей обучения
========================================
Скорость обучения и графики скорости обучения сложны в настройке и имеют решающее значение для производительности модели нейронной сети с глубоким обучением.Keras предоставляет ряд различных популярных вариантов стохастического градиентного спуска с адаптивной скоростью обучения, таких как:
Adaptive Gradient Algorithm (AdaGrad).
Root Mean Square Propagation (RMSprop).
Adaptive Moment Estimation (Adam).
Каждый из них предоставляет различную методологию адаптации скорости обучения для каждого веса в сети.
Не существует единственного лучшего алгоритма, и результаты алгоритмов гоночной оптимизации для одной задачи вряд ли можно будет перенести на новые задачи.Мы можем изучить динамику различных методов адаптивной скорости обучения в задаче о каплях. Функцию fit_model() можно обновить, чтобы она брала имя алгоритма оптимизации для оценки, которое можно указать в аргументе «оптимизатор» при компиляции модели MLP. Затем будут использоваться параметры по умолчанию для каждого метода.
(.env) boris@boris-All-Series:~/LEARNINGRATE$ cat AdaptLearnRates.py
# study of sgd with adaptive learning rates in the blobs problem
from sklearn.datasets import make_blobs
from keras.layers import Dense
from keras.models import Sequential
from keras.optimizers import SGD
from keras.utils import to_categorical
from keras.callbacks import Callback
from keras import backend
from matplotlib import pyplot
# prepare train and test dataset
def prepare_data():
# generate 2d classification dataset
X, y = make_blobs(n_samples=1000, centers=3, n_features=2, cluster_std=2, random_state=2)
# one hot encode output variable
y = to_categorical(y)
# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]
return trainX, trainy, testX, testy
# fit a model and plot learning curve
def fit_model(trainX, trainy, testX, testy, optimizer):
# define model
model = Sequential()
model.add(Dense(50, input_dim=2, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(3, activation='softmax'))
# compile model
model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=200, verbose=0)
# plot learning curves
pyplot.plot(history.history['accuracy'], label='train')
pyplot.plot(history.history['val_accuracy'], label='test')
pyplot.title('opt='+optimizer, pad=-80)
# prepare dataset
trainX, trainy, testX, testy = prepare_data()
# create learning curves for different optimizers
momentums = ['sgd', 'rmsprop', 'adagrad', 'adam']
for i in range(len(momentums)):
# determine the plot number
plot_no = 220 + (i+1)
pyplot.subplot(plot_no)
# fit model and plot learning curves for an optimizer
fit_model(trainX, trainy, testX, testy, momentums[i])
# show learning curves
pyplot.show()
===========================
Затухание скорости обучения
===========================
Выполнение примера создает единую фигуру, содержащую четыре линейных графика для различных оцененных значений затухания скорости обучения. Точность классификации в обучающем наборе данных отмечена синим цветом, тогда как точность в тестовом наборе данных отмечена оранжевым цветом.
(.env) boris@boris-All-Series:~/LEARNINGRATE$ cat learnRateKeras.py
# study of decay rate on accuracy for blobs problem
from sklearn.datasets import make_blobs
from keras.layers import Dense
from keras.models import Sequential
from keras.optimizers import SGD
from keras.utils import to_categorical
from matplotlib import pyplot
# prepare train and test dataset
def prepare_data():
# generate 2d classification dataset
X, y = make_blobs(n_samples=1000, centers=3, n_features=2, cluster_std=2, random_state=2)
# one hot encode output variable
y = to_categorical(y)
# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]
return trainX, trainy, testX, testy
# fit a model and plot learning curve
def fit_model(trainX, trainy, testX, testy, decay):
# define model
model = Sequential()
model.add(Dense(50, input_dim=2, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(3, activation='softmax'))
# compile model
opt = SGD(learning_rate=0.01, decay=decay)
model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])
# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=200, verbose=0)
# plot learning curves
pyplot.plot(history.history['accuracy'], label='train')
pyplot.plot(history.history['val_accuracy'], label='test')
pyplot.title('decay='+str(decay), pad=-80)
# prepare dataset
trainX, trainy, testX, testy = prepare_data()
# create learning curves for different decay rates
decay_rates = [1E-1, 1E-2, 1E-3, 1E-4]
for i in range(len(decay_rates)):
# determine the plot number
plot_no = 220 + (i+1)
pyplot.subplot(plot_no)
# fit model and plot learning curves for a decay rate
fit_model(trainX, trainy, testX, testy, decay_rates[i])
# show learning curves
pyplot.show()
=================================
Влияние скорости обучения и импульса
=================================
Импульсная динамика
Импульс может сгладить прогресс алгоритма обучения, что, в свою очередь, может ускорить процесс обучения
Выполнение примера создает единую фигуру, содержащую четыре линейных графика для различных оцененных значений импульса. Точность классификации в обучающем наборе данных отмечена синим цветом, тогда как точность в тестовом наборе данных отмечена оранжевым цветом.
(.env) boris@boris-All-Series:~/LEARNINGRATE$ cat MomentumDynam.py
# study of momentum on accuracy for blobs problem
from sklearn.datasets import make_blobs
from keras.layers import Dense
from keras.models import Sequential
from keras.optimizers import SGD
from keras.utils import to_categorical
from matplotlib import pyplot
# prepare train and test dataset
def prepare_data():
# generate 2d classification dataset
X, y = make_blobs(n_samples=1000, centers=3, n_features=2, cluster_std=2, random_state=2)
# one hot encode output variable
y = to_categorical(y)
# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]
return trainX, trainy, testX, testy
# fit a model and plot learning curve
def fit_model(trainX, trainy, testX, testy, momentum):
# define model
model = Sequential()
model.add(Dense(50, input_dim=2, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(3, activation='softmax'))
# compile model
opt = SGD(learning_rate=0.01, momentum=momentum)
model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])
# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=200, verbose=0)
# plot learning curves
pyplot.plot(history.history['accuracy'], label='train')
pyplot.plot(history.history['val_accuracy'], label='test')
pyplot.title('momentum='+str(momentum), pad=-80)
# prepare dataset
trainX, trainy, testX, testy = prepare_data()
# create learning curves for different momentums
momentums = [0.0, 0.5, 0.9, 0.99]
for i in range(len(momentums)):
# determine the plot number
plot_no = 220 + (i+1)
pyplot.subplot(plot_no)
# fit model and plot learning curves for a momentum
fit_model(trainX, trainy, testX, testy, momentums[i])
# show learning curves
pyplot.show()
