По какой причине Adam Optimizer считается устойчивым к значению своих гиперпараметров?

Я читал об оптимизаторе Adam для глубокого обучения и наткнулся на следующее предложение в новой книге Бенжио, Гудфеллоу и Курвилля Deep Learning :

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

if Это правда, это большое дело, потому что поиск по гиперпараметрам может быть действительно важен (по крайней мере, по моему опыту) для статистической производительности системы глубокого обучения. Таким образом, у меня вопрос, почему Адам Робаст по таким важным параметрам? Специально $ beta_1 $ и $ beta_2 $?

Я прочитал статью Адама, и в ней не дается никаких объяснений, почему она работает с этими параметрами или почему она надежна. Обосновывают ли они это где-то еще?

Кроме того, когда я читал статью, мне показалось, что количество гиперпараметров, которые они пробовали, очень мало, для $ beta_1 $ всего 2, а для $ beta_2 $ только 3. Как это может быть тщательное эмпирическое исследование, если оно работает только с гиперпараметрами 2×3?


12
$ begingroup $

Что касается доказательств в отношении претензии, я считаю, что единственные доказательства, подтверждающие претензию, можно найти на рисунке 4 в их статье. Они показывают окончательные результаты в диапазоне различных значений для $ beta_1 $, $ beta_2 $ и $ alpha $.

Лично я не нахожу их аргумент убедительным, в частности потому, что они не дают результатов по множеству проблем. С учетом сказанного отмечу, что я использовал ADAM для решения множества задач, и мои личные выводы заключаются в том, что значения по умолчанию $ beta_1 $ и $ beta_2 $ действительно кажутся на удивление надежными. , хотя требуется немало возиться с $ alpha $.

Улучшите этот ответ
отредактировано 15 мая 2018 в 22:49
ответил 25 ноября ’17 в 18:15

$ endgroup $

добавить комментарий |

Что касается доказательств в отношении претензии, я считаю, что единственные доказательства, подтверждающие претензию, можно найти на рисунке 4 в их статье . Они показывают окончательные результаты в диапазоне различных значений для $ beta_1 $, $ beta_2 $ и $ alpha $.

Лично я не нахожу их аргумент убедительным, в частности потому, что они не дают результатов по множеству проблем.. С учетом сказанного отмечу, что я использовал ADAM для решения множества задач, и мои личные выводы заключаются в том, что значения по умолчанию $ beta_1 $ и $ beta_2 $ действительно кажутся на удивление надежными. , хотя требуется немало возиться с $ alpha $.


8
$ begingroup $

Адам изучает само обучение оценивается по параметрам. Параметры $ beta_1 $ и $ beta_2 $ напрямую не определяют скорость обучения, а только временные рамки, в течение которых усвоенная скорость обучения снижается. Если они распадаются очень быстро, то скорость обучения будет резко возрастать. Если они медленно разваливаются, потребуется время, чтобы выучить скорость обучения. Но обратите внимание, что во всех случаях скорость обучения определяется автоматически на основе скользящей оценки градиента для каждого параметра и градиента в квадрате для каждого параметра.

Это сильно контрастирует со стандартным ванильный стохастический градиентный спуск, где:

  • скорость обучения не зависит от параметра, но существует единая глобальная скорость обучения, которая прямо применяется ко всем параметрам
    • (кстати, это одна из причин, по которой данные часто отбеливаются, нормализуются перед отправкой в ​​сети, чтобы попытаться сохранить идеальные веса для каждого параметра, аналогичные)
  • предоставленная скорость обучения является точной используемой скоростью обучения и не адаптируется с течением времени

Адам — ​​не единственный оптимизатор с адаптивным обучением ставки. Как говорится в статье Адама, это тесно связано с Adagrad и Rmsprop, которые также крайне нечувствительны к гиперпараметрам. Особенно хорошо работает Rmsprop.

Но Адам в целом лучший. За очень немногими исключениями Адам будет делать то, что вы хотите 🙂

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

Улучшите этот ответ
ответил 9 октября 2017 в 20:35

$ endgroup $

  • 2
    $ begingroup $ Я не понимаю, почему Адам устойчив к значениям $ beta_1, beta_2 $. Кажется, что нет никаких исследований, подтверждающих это. Насколько я могу судить, кажется народной мудростью. $ endgroup $ — Чарли Паркер, 10 октября 2017 г., 3:42
  • 1
    $ begingroup $ Да, если вы имеете в виду, «есть ли здесь возможность глубже изучить, почему?», ну … может быть. $ endgroup $ — Хью Перкинс, 10 окт., 8:56
  • 3
    $ begingroup $ это не «более глубокий вопрос». Кажется, это один из самых важных пунктов статьи, не так ли? Все дело в том, что он все делает «сам», но есть и другие гиперпараметры, которые кажутся магически надежными. Вот в чем проблема. Мне кажется, что это связано с сутью статьи, если я не неправильно понял суть Адама. $ endgroup $ — Чарли Паркер, 10 октября 2017 г., 16:10
  • $ begingroup $ «Есть несколько довольно патологических случаев, когда Адам не будет работать, особенно для некоторых очень нестационарных распределений».
  • 1
    $ begingroup $ @HughPerkins, а как насчет их расширений: AdaMax, AdamW? $ endgroup $ — Алекс 07 авг.2020, 13:54
добавить комментарий |

Адам сам изучает скорость обучения для каждого параметра. Параметры $ beta_1 $ и $ beta_2 $ напрямую не определяют скорость обучения, а только временные рамки, в течение которых усвоенная скорость обучения снижается. Если они распадаются очень быстро, то скорость обучения будет резко возрастать. Если они медленно разваливаются, потребуется время, чтобы выучить скорость обучения. Но обратите внимание, что во всех случаях скорость обучения определяется автоматически на основе скользящей оценки градиента для каждого параметра и градиента в квадрате для каждого параметра.

Это сильно контрастирует со стандартным ванильный стохастический градиентный спуск, где:

  • скорость обучения не зависит от параметра, но существует единая глобальная скорость обучения, которая прямо применяется ко всем параметрам
    • (кстати, это одна из причин, по которой данные часто отбеливаются, нормализуются перед отправкой в ​​сети, чтобы попытаться сохранить идеальные веса для каждого параметра, аналогичные)
  • предоставленная скорость обучения является точной используемой скоростью обучения и не адаптируется с течением времени

Адам — ​​не единственный оптимизатор с адаптивным обучением ставки. Как говорится в статье Адама, это тесно связано с Adagrad и Rmsprop, которые также крайне нечувствительны к гиперпараметрам. Особенно хорошо работает Rmsprop.

Но Адам в целом лучший. За очень немногими исключениями Адам будет делать то, что вы хотите 🙂

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


0
$ begingroup $

Глядя на Формулы ADAM, кажется немного озадачивающим, что после очень большого числа пакетных итераций (скажем, ~ 400k) величина градиента, основанного на исходной ошибке, сама по себе не играет ~ фактической роли в предпринятом шаге, который, кажется, стремится к скорости обучения параметр конфигурации в соответствующем знаке.
Возможно, ADAM управляет адаптацией веса лучше, чем простой SGD во время первых итераций/периодов, но в дальнейшем обновление, похоже, сводится к чему-то несколько наивному (?) Кто-нибудь может дать некоторую интуицию относительно того, почему что действительно желательно и/или имеет тенденцию работать?

Улучшите этот ответ
ответил 19 мая ’19 в 10:54

v>

$ endgroup $

  • 1
    $ begingroup $ На самом деле кажется, что величина градиента на основе ошибок сама по себе не играет реальной роли даже с самого начала. Вопрос в том, почему такая нормализация работает хорошо и что она означает в отношении интуиции GD, определяющей DL, и других распространенных моделей обучения? $ endgroup $ — Дэнни Розен 19 мая ’19 в 11:08
добавить комментарий |

Глядя на формулы ADAM, кажется немного озадачивающим, что после очень большого числа пакетных итераций (скажем, ~ 400 тыс.) величина сам градиент, основанный на исходной ошибке, не играет никакой реальной роли в предпринятом шаге, который, кажется, стремится к параметру конфигурации скорости обучения в соответствующем знаке.
Возможно, ADAM контролирует адаптацию веса лучше, чем простой SGD во время первых итераций /epocs, но в будущем обновление, похоже, сведено к чему-то несколько наивному (?) Может ли кто-нибудь дать некоторую интуицию о том, почему это на самом деле желательно и/или имеет тенденцию работать?



torch.optim — документация PyTorch 1.7.0

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

Как использовать оптимизатор¶

Чтобы использовать torch.optim , вам необходимо создать объект оптимизатора, который будет содержать текущее состояние и обновлять параметры на основе вычисленных градиентов.

Создание его ¶

Чтобы создать Optimizer , вы должны дать ему итерацию, содержащую параметры (все должны быть Variable s) для оптимизации . Затем вы можете указать параметры оптимизатора, такие как скорость обучения, снижение веса и т. Д..

Примечание

Если вам нужно перенести модель на GPU через .cuda () , сделайте поэтому, прежде чем создавать для него оптимизаторы. Параметры модели после .cuda () будут отличаться от объектов до вызова.

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

Пример:

 optimizer = optim.SGD (model.parameters (  ), lr = 0,01, импульс = 0,9) optimizer = optim.Adam ([var1, var2], lr = 0,0001) 

Параметры для каждого параметра¶

Оптимизаторы также поддерживают указание параметров для каждого параметра. Для этого вместо передачи итерируемых переменных Variable передайте итерируемые значения dict . Каждый из них будет определять отдельную группу параметров и должен содержать ключ params , содержащий список принадлежащих ему параметров. Другие ключи должны соответствовать аргументам ключевого слова, принятым оптимизаторами, и будут использоваться в качестве параметров оптимизации для этой группы.

Примечание

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

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

 optim.SGD ([{'params': model.base.parameters ()}, {'params': model.classifier.parameters (  ), 'lr': 1e-3}], lr = 1e-2, импульс = 0,9) 

Это означает, что model.base Параметры будут использовать скорость обучения по умолчанию 1e-2 , параметры model.classifier будут использовать скорость обучения 1e-3 , и импульс 0,9 будет использоваться для всех параметров.

Выполнение шага оптимизации¶

Все оптимизаторы реализуют метод step () , который обновляет параметры. Его можно использовать двумя способами:

optimizer.step ()

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

Пример:

 для ввода, цель в наборе данных: optimizer.zero_grad () output = model (input) loss = loss_fn (output, target) loss.backward () optimizer.step () 

optimizer.step (closure)

Некоторые алгоритмы оптимизации, такие как Conjugate Gradient и LBFGS необходимо повторно оценить функцию несколько раз, поэтому вам нужно передать замыкание, которое позволит им пересчитать вашу модель. Замыкание должно очистить градиенты, вычислить потери и вернуть их.

Пример:

 для ввода, цель в  набор данных: def closure (): optimizer.zero_grad () output = model (input) loss = loss_fn (output, target) loss. backward () return loss optimizer.step (closure) 

Алгоритмы¶

class torch.optim. Оптимизатор ( params , по умолчанию ) [источник] ¶

Базовый класс для всех оптимизаторов.

Предупреждение

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

Параметры
  • params ( iterable ) — итерабельность torch.Tensor s или dict s. Указывает, какие тензоры следует оптимизировать.

  • defaults — (dict): словарь, содержащий значения параметров оптимизации по умолчанию (используется, когда группа параметров не определяет их).

add_param_group ( param_group ) [source] ¶

Добавить группу параметров в оптимизатор s param_groups .

Это может быть полезно при точной настройке предварительно обученной сети, поскольку замороженные слои можно сделать обучаемыми и добавить в Optimizer как обучение продолжается.

Параметры
  • param_group ( dict ) — указывает, какие тензоры следует оптимизировать вместе с параметрами оптимизации group

  • . ( специфический ) —

load_state_dict ( state_dict ) [источник] ¶

Загружает состояние оптимизатора.

Параметры

state_dict ( dict ) — состояние оптимизатора. Должен быть объект, возвращаемый в результате вызова state_dict().

state_dict () [источник] ¶

Возвращает состояние оптимизатора в виде dict .

Он содержит две записи:

  • state — словарь, содержащий текущее состояние оптимизации. Его содержимое

    различается между классами оптимизатора.

  • param_groups — a dict, содержащий все группы параметров

step ( закрытие ) [источник] ¶

Выполняет один шаг оптимизации (обновление параметров).

Параметры

закрытие ( callable ) — закрытие, которое повторно оценивает модель и возвращает убытки. Необязательный для большинства оптимизаторов.

Примечание

Если не указано иное, эта функция не должна изменять .grad поле параметров.

zero_grad ( set_to_none: bool = False ) [source] ¶

Устанавливает градиенты всех оптимизированных torch.Tensor s до нуля.

Параметры

set_to_none ( bool ) — вместо нулевого значения установите для градаций значение Нет. Это, как правило, будет иметь меньший объем памяти и может незначительно улучшить производительность, однако изменит определенные поведения. Например: 1. Когда пользователь пытается получить доступ к градиенту и выполнить с ним ручные операции, атрибут None или Tensor, заполненный нулями, будут вести себя по-другому. Если пользователь запрашивает zero_grad (set_to_none = True) с последующим обратным проходом, .grad s гарантированно будет None для параметров, которые не получили градиент. 3. Оптимизаторы torch.optim ведут себя иначе, если градиент равен 0 или None (в одном случае он выполняет шаг с градиентом 0, а в другом он полностью пропускает шаг).

класс torch.optim. Adadelta ( params , lr = 1.0 , rho = 0,9 , eps = 1e-06 , weight_decay = 0 ) [источник] ¶

Реализует алгоритм Ададелта.

Он был предложен в ADADELTA: метод адаптивной скорости обучения.

Параметры
  • params ( iterable ) — итерация параметров для оптимизации или dicts, определяющая группы параметров

  • rho ( float , необязательно ) — коэффициент, используемый для вычисления скользящего среднего квадрата градиентов (по умолчанию: 0,9)

  • eps ( float , optional ) — термин добавлен в знаменатель улучшения численной устойчивости (по умолчанию: 1e-6)

  • lr ( float , необязательно ) — коэффициент, который масштабирует дельту перед ее применением к параметрам (по умолчанию: 1.0)

  • weight_decay ( float , необязательно ) — вес распад (штраф L2) (по умолчанию: 0)

step ( closure = None ) [source] ¶

Выполняет один шаг оптимизации.

Параметры

закрытие ( вызываемый , необязательно ) — Замыкание, которое повторно оценивает страну моделей, возвращает потерю.

class torch.optim. Adagrad ( params , lr = 0,01 , lr_decay = 0 , weight_decay = 0 , initial_accumulator_value = 0 , eps = 1e-10 ) [источник] ¶

Реализация ts Алгоритм Адаграда.

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

Параметры
  • params ( iterable ) — итерация параметров для оптимизации или определение групп параметров

  • lr ( float , необязательно ) — скорость обучения (по умолчанию: 1e-2)

  • lr_decay ( float , необязательно ) — снижение скорости обучения (по умолчанию: 0)

  • weight_decay ( float , необязательно ) — снижение веса (штраф L2) (по умолчанию: 0)

  • eps ( float , необязательно ) — член добавляется к знаменателю для улучшения числового стабильность (по умолчанию: 1e-10)

step ( closure = None ) [source] ¶

Выполняет один шаг оптимизации.

Параметры

closure ( callable , optiona l ) — закрытие, которое переоценивает состояние модели, возвращает потерю.

class torch.optim. Adam ( params , lr = 0,001 , betas = (0,9 , 0,999) , eps = 1e-08 , weight_decay = 0 , amsgrad = False ) [источник] ¶

Реализует Адам алгоритм.

Он был предложен в Adam: A Method for Stochastic Optimization. Реализация штрафа L2 следует за изменениями, предложенными в разделенной регуляризации спада веса.

Параметры
  • params ( iterable ) — итерация параметров для оптимизации или определение групп параметров

  • lr ( float , необязательно ) — скорость обучения (по умолчанию: 1e-3)

  • бета-версии ( Кортеж [ float , float ] , m> необязательно ) — коэффициенты, используемые для вычисления средних значений градиента и его квадрата (по умолчанию: (0.9, 0.999))

  • eps ( float , необязательно ) — член добавляется в знаменатель к улучшенная устойчивость (по умолчанию: 1e-8)

  • weight_decay ( float , необязательно ) — снижение веса (штраф L2) (по умолчанию: 0)

  • amsgrad ( boolean , optional ) — использовать ли вариант этого алгоритма AMSGrad из статьи «О схождении Адама и не только» (по умолчанию: False)

step ( closure = None ) [source] ¶

Выполняет один шаг оптимизации.

Параметры

закрытие ( вызываемый , необязательно ) — закрытие, которое повторно оценивает модель, возвращает потерю.

класс torch.optim. AdamW ( params , lr = 0.001 , betas = (0,9 , 0,999) , eps = 1e-08 , weight_decay = 0,01 , amsgrad = False ) [source] ¶

Реализует алгоритм AdamW.

Был предложен исходный алгоритм Adam в Адаме: метод стохастической оптимизации. Вариант AdamW был предложен в разделенной регуляризации спада веса.

Параметры
  • params ( iterable ) — итерация параметров для оптимизации или определение групп параметров

  • lr ( float , необязательно ) — скорость обучения (по умолчанию: 1e-3)

  • бета ( Кортеж [ float , float ] , необязательно ) — коэффициенты, используемые для вычисления текущих средних значений. градиента и его квадрата (по умолчанию: (0.9, 0.999))

  • eps ( float , необязательно ) — член, добавляемый к знаменателю для улучшения численной устойчивости (по умолчанию: 1e-8)

  • weight_decay ( float , необязательно ) — коэффициент уменьшения веса (по умолчанию: 1e-2)

  • amsgrad ( логическое , optional ) — использовать ли вариант этого алгоритма AMSGrad из статьи On the Convergence of Adam and Beyond (по умолчанию: False)

step ( closure = None ) [ источник] ¶

Выполняет один шаг оптимизации.

Параметры

closure ( callable , optional ) — закрытие, которое переоценивает modeland возвращает убыток.

class torch.optim.e> SparseAdam ( params , lr = 0.001 , betas = (0.9 , 0,999) , eps = 1e-08 ) [источник] ¶

Реализует ленивую версию Алгоритм Адама подходит для разреженных тензоров.

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

Параметры
  • params ( iterable ) — итерация параметров для оптимизации или определение групп параметров

  • lr ( float , необязательно ) — скорость обучения (по умолчанию: 1e-3)

  • бета ( Кортеж [ float , float ] , optional ) — коэффициенты, используемые для вычисления текущих средних значений градиента и его квадрата (по умолчанию: (0.9, 0. 999))

  • eps ( float , необязательный ) — член, добавляемый к знаменателю для улучшения численной устойчивости (по умолчанию: 1e-8)

step ( closure = None ) [источник] ¶

Выполняет один шаг оптимизации.

Параметры

закрытие ( callable , optional ) — закрытие, которое повторно оценивает модель, возвращает потерю.

class torch.optim. Adamax ( params , lr = 0.002 , betas = (0.9 , 0,999) , eps = 1e-08 , weight_decay = 0 ) [источник] ¶

Реализует алгоритм Adamax (вариант Адама, основанный на норме бесконечности).

Он был предложен в Adam: A Method for Stochastic Optimization.

Параметры
  • params ( iterable ) — итерация параметров для оптимизации или определение групп параметров

  • lr ( float , необязательно ) — скорость обучения (по умолчанию: 2e-3)

  • бета ( Кортеж [ float , float ] , optional ) — коэффициенты, используемые для вычисление среднее значение градиента и его площади

  • eps ( float , необязательный ) — член, добавляемый к знаменателю для улучшения численной устойчивости (по умолчанию: 1e-8)

  • weight_decay ( float , optional ) — снижение веса (штраф L2) (по умолчанию: 0)

step ( closure = None ) [source] ¶

Выполняет один шаг оптимизации.

Параметры

закрытие ( вызываемый , необязательно ) — закрытие, которое повторно оценивает страну моделей, возвращает потери.

class torch.optim. ASGD ( params , lr = 0,01 , lambd = 0,0001 , alpha = 0,75 , t0 = 1000000.0 , weight_decay = 0 ) [source] ¶

Реализует усредненный стохастический градиентный спуск.

Это было предложено в разделе «Ускорение стохастической аппроксимации путем усреднения.

Параметры
  • params ( iterable ) — итерация параметров для оптимизации или определение групп параметров

  • lr ( float , необязательно ) — скорость обучения (по умолчанию: 1e-2)

  • lambd ( float , необязательно ) — срок распада (по умолчанию: 1e-4)

  • alpha ( float , необязательно ) — мощность для обновления eta (по умолчанию: 0,75)

  • t0 ( float , необязательно ) — точка, с которой начинается усреднение (по умолчанию : 1e6)

  • weight_decay ( float , необязательно ) — снижение веса (штраф L2) (по умолчанию: 0)

step ( closure = None ) [source] ¶

Выполняет одиночный шаг оптимизации.

Par ameters

закрытие ( вызываемый , необязательный ) — закрытие, которое повторно оценивает страну моделей, возвращает потерю.

class torch.optim. LBFGS ( params , lr = 1 , max_iter = 20 , max_eval = None , толерантность_града = 1e-07 , допуск_change = 1e-09 , history_size = 100 , line_search_fn = None ) [источник] ¶

Реализует алгоритм L-BFGS, в значительной степени вдохновленный minFunc .

Предупреждение

Этот оптимизатор не поддерживает параметры и группы параметров для отдельных параметров (может быть только одна).

Предупреждение

Сейчас все параметры должны быть на одном устройстве. Это будет улучшено в будущем.

Примечание

Это оптимизатор с очень интенсивным использованием памяти (для него требуется дополнительный param_bytes * (history_size + 1) байтов). Если это не умещается в памяти, попробуйте уменьшить размер истории или используйте другой алгоритм.

Параметры
  • lr ( float ) — скорость обучения (по умолчанию: 1)

  • max_iter ( int ) — максимальное количество итераций на шаг оптимизации (по умолчанию: 20)

  • max_eval ( int ) — максимальное количество вычислений функции на шаг оптимизации (по умолчанию: max_iter * 1,25) .

  • толерантность_града ( float ) — допуск завершения при оптимальности первого порядка (по умолчанию : 1e-5).

  • толерантность_замена ( float ) — допуск завершения на изменение значения функции/параметра (по умолчанию: 1e-9).

  • history_size ( int ) — размер истории обновлений (по умолчанию: 100).

  • line_search_fn ( str ) — либо ‘strong_wolfe’, либо None (по умолчанию: Нет).

step ( закрытие ) [источник] ¶

Выполняет один шаг оптимизации.

Параметры

closure ( callable ) — закрытие, которое переоценивает модель, возвращает убыток.

class torch.optim. RMSprop ( params , lr = 0,01 , alpha = 0,99 , eps = 1e-08 , weight_decay = 0 , momentum = 0 , centered = False ) [источник] ¶

Реализует алгоритм RMSprop.

Предложено Дж. Хинтоном в его курсе.

Центрированная версия сначала появляется в разделе «Создание последовательностей с рекуррентными нейронными сетями».

Реализация здесь берет квадратный корень из среднего градиента перед добавлением эпсилон (обратите внимание, что TensorFlow inte r меняет эти две операции). Таким образом, эффективная скорость обучения составляет α / ( v + ϵ ) alpha/( sqrt {v} + epsilon) α/(v + ϵ) где αalpha αis запланированная скорость обучения и vv v — взвешенное скользящее среднее квадрата градиента.

Параметры
  • params ( iterable ) — итерация параметров для оптимизации или определение групп параметров

  • lr ( float , optional ) — скорость обучения (по умолчанию: 1e -2)

  • импульс ( float , необязательно ) — коэффициент импульса (по умолчанию: 0)

  • alpha ( float , необязательно ) — константа сглаживания (по умолчанию: 0,99)

  • eps ( float , необязательно ) — член, добавляемый к знаменателю для улучшения численной устойчивости (по умолчанию: 1e-8)

  • по центру ( bool , необязательно ) — если True , вычислить центрированный RMSProp, градиент нормализован оценкой его дисперсии

  • weight_decay ( float , необязательно ) — снижение веса (штраф L2) (по умолчанию: 0)

step ( closure = None ) [источник] ¶

Выполняет один шаг оптимизации.

Параметры

closure ( callable , optional ) — закрытие, которое переоценивает возвращаемую модель потеря.

класс torch.optim. Rprop ( params , lr = 0.01 , etas = (0,5 , 1,2) , step_sizes = (1e-06 , 50) ) [источник] ¶

Реализует устойчивый алгоритм обратного распространения.

Параметры
  • params ( iterable ) — итерация параметров для оптимизации или определение групп параметров

  • lr ( float , необязательно ) — скорость обучения (по умолчанию: 1e-2)

  • etas ( Кортеж [ float , float ] , optional ) — пара (этаминус, этаплис), которые являются множителями мультипликативного увеличения и уменьшения (по умолчанию: (0.5, 1.2))

  • размер_шага ( Кортеж [ float , float ] , необязательно ) — пара минимального и максимального разрешенных размеров шага (по умолчанию: (1e-6, 50))

step ( closure = None ) [источник] ¶

Выполняет один шаг оптимизации.

Параметры

закрытие ( callable , необязательно ) — A закрытие, которое повторно оценивает страну моделей, возвращает потерю.

class torch.optim. SGD ( params , lr = , импульс = 0 , dampening = 0 , weight_decay = 0 , nesterov = False ) [source] ¶

Реализует стохастический градиентный спуск (необязательно с импульсом).

Импульс Нестерова равен на основе формулы из О важности инициализации и импульса в глубоком обучении.

Параметры
  • params ( итерация ) — итерация параметров для оптимизации или определение групп параметров

  • lr ( float ) — скорость обучения

  • импульс ( float , необязательно ) — коэффициент импульса (по умолчанию: 0)

  • weight_decay ( float , optional ) — уменьшение веса (штраф L2) (по умолчанию: 0)

  • демпфирование ( float , необязательно ) — гашение импульса (по умолчанию: 0)

  • нестеров ( bool , optional ) — включает импульс Нестерова (по умолчанию: False)

Пример

>>> optimizer = torch.optim.SGD (model.parameters (),  lr = 0,1, импульс = 0,9) >>> optimizer.zero_grad () >>> loss_fn (модель (входные данные), цель) .backward () >>> optimizer. step () 

Примечание

Реализация SGD с Momentum/Nesterov тонко отличается от Sutskever et. al. и реализации в некоторых других фреймворках.

Учитывая конкретный случай Momentum, обновление можно записать как

v t + 1 = μ ∗ v t + g t + 1 , p т + 1 = p t — lr ∗ v t+1 , begin {align} v_ {t + 1} & = mu * v_ {t} + g_ {t + 1}, \ p_ {t + 1} & = p_ {t} — text {lr} * v_ {t + 1}, end {align} vt + 1 pt + 1 = μ ∗ vt + gt + 1, = pt −lr ∗ vt + 1,

где p p p, g g g, v v v и μ mu μ обозначают параметры, градиент, скорость и импульс соответственно.

В этом отличие от Sutskever et. al. и другие фреймворки, в которых используется обновление формы

v t + 1 = μ ∗ v t + lr ∗ g t + 1 , p т + 1 = p t — v t + 1 . begin {align} v_ {t + 1} & = mu * v_ {t} + text {lr} * g_ {t + 1}, \ p_ {t + 1} & = p_ {t} — v_ {t + 1}. end {align} vt + 1 pt + 1 = μ ∗ vt + lr ∗ gt + 1, = pt −vt + 1.

Аналогично модифицирована версия Нестерова.

step ( closure = None ) [source] ¶

Выполняет один шаг оптимизации.

Параметры

закрытие ( вызываемый , необязательно ) — закрытие, которое переоценивает состояние модели, возвращает убыток.

Как настроить скорость обучения¶

torch.optim.lr_scheduler предоставляет несколько методов для настройки скорости обучения в зависимости от количества эпох. torch.optim.lr_scheduler.ReduceLROnPlateau позволяет динамически снижать скорость обучения на основе некоторых проверочных измерений.

Планирование скорости обучения должно применяться после обновления оптимизатора; например, вы должны написать свой код следующим образом:

>>> scheduler = ... >>> для эпохи в диапазоне (100): >>>  train (...) >>> validate (...) >>> scheduler.step () 

Предупреждение

До PyTorch 1.1.0 планировщик скорости обучения должен был вызываться перед обновлением оптимизатора; 1.1.0 изменил это поведение до отказа. Если вы используете планировщик скорости обучения (вызывая scheduler.step () ) до обновления оптимизатора (вызывая optimizer.step () ), это пропустит первый значение расписания скорости обучения. Если вы не можете воспроизвести результаты после обновления до PyTorch 1.1.0, проверьте, не вызываете ли вы scheduler.step () не в то время.

class torch.optim.lr_scheduler. LambdaLR ( optimizer , lr_lambda , last_epoch = -1 , verbose = False ) [ источник] ¶

Устанавливает скорость обучения каждой группы параметров равной начальному времени данной функции. Когда last_epoch = -1, устанавливает начальный lr как lr.

Параметры
  • optimizer ( Optimizer ) — Оптимизатор в оболочке.

  • lr_lambda ( function или list ) — функция, которая вычисляет мультипликативный коэффициент с учетом эпохи целочисленного параметра, или список таких функций, по одной для каждой группы в optimizer.param_groups.

  • last_epoch ( int ) — индекс последней эпохи. По умолчанию: -1.

  • verbose ( bool ) — Если True , выводит сообщение в стандартный вывод для каждого обновления. По умолчанию: False.

Пример

>>> # Предполагается, что оптимизатор имеет две группы. >>> lambda1 = lambda epoch: epoch//30 >>> lambda2 = lambda epoch: 0.95 ** epoch >>> scheduler = LambdaLR (optimizer  , lr_lambda = [lambda1, lambda2]) >>> для эпохи в диапазоне (100): >>> train (...) >>> validate (...) >>> scheduler.step () 

load_state_dict ( state_dict ) [источник] ¶

Загружает состояние планировщика.

Параметры

state_dict ( dict ) — состояние планировщика. Должен быть объект, возвращенный при вызове state_dict().

state_dict () [source] ¶

Возвращает состояние планировщика в виде dict .

Он содержит запись для каждой переменной в self .__ dict__, которая не является оптимизатором. Лямбда-функции скорости обучения будут сохранены, только если они являются вызываемыми объектами, а не если они являются функциями или лямбда-выражениями.

class torch.optim.lr_scheduler. MultiplicativeLR ( optimizer , lr_lambda , last_epoch = -1 , verbose = False ) [source] ¶

Умножьте скорость обучения каждой группы параметров на коэффициент, указанный в указанной функции. Когда last_epoch = -1, устанавливает начальный lr как lr.

Параметры
  • optimizer ( Optimizer ) — Оптимизатор в оболочке.

  • lr_lambda ( function или list ) — функция, которая вычисляет мультипликативный коэффициент с учетом эпохи целочисленного параметра, или список таких функций, по одной для каждой группы в optimizer.param_groups.

  • last_epoch ( int ) — индекс последней эпохи. По умолчанию: -1.

  • verbose ( bool ) — Если True , выводит сообщение в стандартный вывод для каждого обновления. По умолчанию: False.

Пример

>>> lmbda = эпоха лямбда: 0,95 >>> scheduler = MultiplicativeLR (optimizer, lr_lambda = lmbda) >>> для эпохи в диапазоне (100): >>> поезд (...)  >>> validate (...) >>> scheduler.step () 

load_state_dict ( state_dict ) [источник] ¶

Загружает состояние планировщика.

Параметры

state_dict ( dict ) — состояние планировщика. Должен быть объект, возвращаемый в результате вызова state_dict().

state_dict () [source] ¶

Возвращает состояние планировщика в виде dict .

Он содержит запись для каждой переменной в self .__ dict__, которая не является оптимизатором. Лямбда-функции скорости обучения будут сохранены, только если они являются вызываемыми объектами, а не если они являются функциями или лямбда-выражениями.

class torch.optim.lr_scheduler. StepLR ( optimizer , step_size , gamma = 0.1 , last_epoch = -1 , verbose = False ) [источник] ¶

Снижает скорость обучения каждого параметра группировать по гамме по эпохам. Обратите внимание, что такой спад может происходить одновременно с другими изменениями скорости обучения извне этого планировщика.. Whenlast_epoch = -1, устанавливает начальный lr как lr.

Параметры
  • optimizer ( Optimizer ) — Оптимизатор в оболочке.

  • step_size ( int ) — Период снижения скорости обучения.

  • gamma ( float ) — Мультипликативный коэффициент снижения скорости обучения. По умолчанию: 0,1.

  • last_epoch ( int ) — Индекс последней эпохи. По умолчанию: -1.

  • verbose ( bool ) — Если True , выводит сообщение в стандартный вывод для каждого обновления. По умолчанию: False.

Пример

>>> # Предполагается, что оптимизатор использует lr = 0,05 для всех групп >>> # lr = 0,05 если эпоха >> # lr = 0,005 если 30 >> #  lr = 0,0005, если 60 >> # ... >>> scheduler = StepLR (optimizer, step_size = 30, gamma = 0.1) >>> для эпохи в диапазоне (100): >>> train (  ...) >>> validate (...) >>> scheduler.step () 

класс torch.optim.lr_scheduler. MultiStepLR ( optimizer , вехи , gamma = 0,1 , last_epoch = -1 , verbose = False ) [ источник] ¶

Уменьшает скорость обучения каждой группы параметров по гамме, как только количество эпох достигает одной из вех. Обратите внимание, что такой спад может происходить одновременно с другими изменениями скорости обучения извне этого планировщика. Когда last_epoch = -1, устанавливает начальный lr как lr.

Параметры
  • optimizer ( Optimizer ) — Оптимизатор в оболочке.

  • вехи ( list ) — Список индексов эпох. Должно увеличиваться.

  • gamma ( float ) — мультипликативный коэффициент скорости обучения decay. По умолчанию: 0,1.

  • last_epoch ( int ) — индекс последняя эпоха. По умолчанию: -1.

  • verbose ( bool ) — Если True , выводит сообщение в стандартный вывод для каждого обновления. По умолчанию: False.

Пример

>>> # Предполагается, что оптимизатор использует lr = 0,05 для всех групп >>> # lr = 0,05 если эпоха >> # lr = 0,005 если 30 >> #  lr = 0,0005, если эпоха> = 80 >>> scheduler = MultiStepLR (optimizer, milestones = [30,80], gamma = 0.1) >>> для эпохи в диапазоне (100): >>> train (...)>  >> проверить (...) >>> scheduler.step () 

класс torch.optim.lr_scheduler. ExponentialLR ( optimizer , gamma , last_epoch = -1 , verbose = False ) [source] ¶

Уменьшает скорость обучения каждой группы параметров по гамме каждую эпоху. Когда last_epoch = -1 , устанавливает начальный lr как lr.

Параметры
  • optimizer ( Optimizer ) — Оптимизатор в оболочке.

  • гамма ( float ) — мультипликативный коэффициент снижения скорости обучения.

  • last_epoch ( int ) — индекс последней эпохи. По умолчанию: -1.

  • verbose ( bool ) — Если True , выводит сообщение в стандартный вывод для каждого обновления. По умолчанию: False.

класс torch.optim.lr_scheduler. CosineAnnealingLR ( optimizer , T_max , eta_min = 0 , last_epoch = -1 , verbose = False ) [источник] ¶

Установить скорость обучения каждая группа параметров с использованием расписания косинусного отжига, где η m ax eta_ {max} ηmax устанавливается равным начальному lr и T c u r T_ {cur} Tcur — это количество эпох с момента последнего перезапуска в SGDR:

η t = η min + 1 2 ( η m a x — η m i n ) ( 1 + cos ⁡ ( T c ur T m a x π )), T c u r ≠ ( 2 k + 1 ) T m a x ; η t + 1 =ηt + 1 2 ( η m a x — η m i n ) ( 1 — cos ⁡ ( 1 T m a x π ) ) , T c u r = ( 2 k + 1 ) T m ax . begin {align} eta_t & = eta_ {min} + frac {1} { 2} ( eta_ {max} — eta_ {min}) left (1 + cos left ( frac {T_ {cur}} {T_ {max}} pi right) right), & T_ {cur} neq (2k + 1) T_ {max}; \ eta_ {t + 1} & = eta_ {t} + frac {1} {2} ( eta_ {max} — eta_ {min}) left (1 — cos left ( frac {1} {T_ {max}} pi right) right), & T_ {cur} = (2k + 1) T_ {max}. End {align} ηt ηt + 1 = ηmin +21 (ηmax −ηmin) (1 + cos (Tmax Tcur π)), = ηt +21 (ηmax −ηmin) (1 −cos (Tmax 1 π)), Tcur  = (2k + 1) Tmax; Tcur = (2k + 1) Tmax.

Когда last_epoch = -1 , устанавливает начальный lr как lr. Обратите внимание: поскольку расписание определяется рекурсивно, скорость обучения может быть одновременно изменена вне этого планировщика другими операторами. Если скорость обучения устанавливается исключительно этим планировщиком, скорость обучения на каждом шаге становится следующей:

η t = η m i n + 1 2 ( η m a x — η m i n ) ( 1 + cos ⁡ ( T c u r T m a x π ) ) eta_t = eta_ {min} + frac {1} {2} ( eta_ {max} — eta_ {min}) left (1 + cos left ( frac {T_ {cur}} {T_ {max}} pi right) right) ηt = ηmin +2 1 (ηmax −ηmin) (1 + cos (Tmax Tcur π))

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

Параметры
  • optimizer ( Optimizer ) — Оптимизатор в оболочке.

  • T_max ( int ) — максимальное количество итераций.

  • eta_min ( float ) — минимальная скорость обучения. По умолчанию: 0.

  • last_epoch ( int ) — индекс последней эпохи . По умолчанию: -1.

  • verbose ( bool ) — Если True , выводит сообщение в стандартный вывод для каждого обновления. По умолчанию: False.

class torch.optim.lr_scheduler. ReduceLROnPlateau ( optimizer , mode = ‘min’ , factor = 0,1 , терпение = 10 , threshold = 0. 0001 , threshold_mode = ‘rel’ , cooldown = 0 , min_lr = 0 , eps = 1e-08 , verbose = False ) [источник] ¶

Уменьшить скорость обучения, если метрика имеет перестала улучшаться.Модели часто выигрывают от снижения скорости обучения в 2-10 раз, когда обучение застопоривается. Этот планировщик считывает количество метрик, и если не наблюдается улучшений для «терпеливого» количества эпох, скорость обучения снижается.

Параметры
  • optimizer ( Optimizer ) — обернутый оптимизатор.

  • mode ( str ) — один из min , max . В режиме min lr будет уменьшено, когда отслеживаемое количество перестанет уменьшаться; в режиме max он будет уменьшен, когда отслеживаемое количество перестанет увеличиваться. По умолчанию: ‘min’.

  • factor ( float ) — коэффициент, по которому скорость обучения будет снижена. new_lr = lr * коэффициент. По умолчанию: 0,1.

  • терпение ( int ) — количество эпох без улучшение, после которого скорость обучения будет снижена. Например, если терпение = 2 , то мы проигнорируем первые 2 эпохи без улучшения и уменьшим LR только после 3-й эпохи, если потери все еще не улучшились. По умолчанию: 10 .

  • threshold ( float ) — Порог для измерения нового оптимума, чтобы сосредоточьтесь только на существенных изменениях. По умолчанию: 1e-4.

  • threshold_mode ( str ) — Один из rel , abs . В режиме rel dynamic_threshold = лучший * (1 + порог) в режиме ‘max’ или лучший * (1 — порог) в режиме min . Режим # cite> abs , dynamic_threshold = лучший + порог в режиме max или лучший — порог в режиме min . По умолчанию: ‘rel’.

  • cooldown ( int ) — количество эпох для ожидания перед возобновлением нормальной работы после уменьшения lr. По умолчанию: 0.

  • min_lr ( float или list ) — скаляр или список скаляров. Нижняя граница скорости обучения всех групп параметров или каждой группы соответственно. По умолчанию: 0.

  • eps ( float ) — минимальное затухание применяется к lr . Если разница между новым и старым lr меньше, чем eps, обновление игнорируется. По умолчанию: 1e-8.

  • verbose ( bool ) — Если True , выводит сообщение в стандартный вывод для каждого обновления. По умолчанию: False.

Пример

>>> optimizer = torch.optim.SGD (model.parameters (), lr = 0.1, momentum = 0.9) >>> scheduler = ReduceLROnPlateau (optimizer, 'min') >>> для  эпоха в диапазоне (10): >>> поезд (... ) >>> val_loss = validate (...) >>> # Обратите внимание, что шаг должен вызываться после validate () >>> scheduler.step (val_loss) 

class torch.optim.lr_scheduler. CyclicLR ( оптимизатор , base_lr , max_lr , step_size_up = 2000 , step_size_down = Нет , mode = ‘triangular’ , gamma = 1.0 , scale_fn = None , scale_mode = ‘cycle’ , cycle_momentum = True , base_momentum = 0.8 , max_momentum = 0.9 , last_epoch = -1 , verbose = False ) [источник] ¶

Устанавливает скорость обучения для каждой группы параметров в соответствии с политикой циклической скорости обучения (CLR). Политика циклически изменяет скорость обучения между двумя границами с постоянной частотой, как подробно описано в статье Циклические скорости обучения для обучения нейронных сетей. Расстояние между двумя границами можно масштабировать для каждой итерации или на основе цикла.

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

В этом классе есть три встроенные политики, изложенные в документе:

  • «треугольник»: основной треугольный цикл без масштабирования амплитуды.

  • «triangular2»: основной треугольный цикл, который масштабирует начальную амплитуду наполовину за каждый цикл.

  • «exp_range»: Цикл, масштабирующий начальную амплитуду на gamma итераций цикла text {gamma} ^ { text {cycle iterations}} gammacycle итераций на каждой итерации цикла.

    i>

Эта реализация была адаптирована из репозитория github: bckenstler/CLR

Parameters
  • optimizer ( Optimizer ) — Оптимизатор в оболочке.

  • base_lr ( float или list ) — начальный скорость обучения, которая является нижней границей цикла для каждой группы параметров.

  • max_lr ( float или list ) — верхние границы скорости обучения в цикле для каждой группы параметров. Функционально, он определяет амплитуду цикла (max_lr — base_lr). Lr в любом цикле является суммой base_l и некоторого масштабирования амплитуды; поэтому max_lr может не быть достигнут в зависимости от функции масштабирования.

  • step_size_up ( int ) — Количество итераций обучения в возрастающей половине цикла. По умолчанию: 2000

  • step_size_down ( int ) — количество итераций обучения в убывающем половина цикла. Если step_size_down имеет значение None, устанавливается значение step_size_up. По умолчанию: Нет

  • mode ( str ) — один из {triangular, triangular2 , exp_range}. Значения соответствуют политике, описанной выше. Если scale_fn не равно None, этот аргумент игнорируется. По умолчанию: ‘triangular’

  • gamma ( float ) — Константа в функции масштабирования exp_range: gamma ** (итерация цикла) По умолчанию: 1.0

  • scale_fn ( function ) — настраиваемая политика масштабирования, определяемая лямбда-функцией с одним аргументом, где 0 = 0. Если указано, то ‘режим’ игнорируется. По умолчанию: Нет

  • scale_mode ( str ) — {‘cycle’, ‘iterations’}. Определяет, оценивается ли scale_fn на количестве цикла или итерациях цикла (итераций обучения с начала цикла). По умолчанию: ‘cycle’

  • cycle_momentum ( bool ) — если True , импульс изменяется обратно пропорционально скорости обучения между ‘base_momentum’ и max_momentum. По умолчанию: True

  • base_momentum ( float или list ) — Нижние границы импульса в цикле для каждой группы параметров. Обратите внимание, что импульс изменяется обратно пропорционально скорости обучения; на пике цикла импульс равен ‘base_momentum’, а скорость обучения ‘max_lr’. По умолчанию: 0,8

  • max_momentum ( float или list ) — верхние границы импульса в цикле для каждой группы параметров. Функционально он определяет амплитуду цикла (max_momentum — base_momentum). Импульс в любом цикле представляет собой разность max_momentum и некоторого масштабирования амплитуды; поэтому базовый момент может не быть достигнут в зависимости от функции масштабирования. Обратите внимание, что импульс изменяется обратно пропорционально скорости обучения; в начале цикла импульс равен ‘max_momentum’, а скорость обучения ‘base_lr’ По умолчанию: 0,9

  • last_epoch ( int ) — индекс последней партии. Этот параметр используется при возобновлении учебной работы. Так как step () должен вызываться после каждого пакета, а не после каждой эпохи, это число представляет собой общее количество вычисленных пакетов , а не общее количество вычисленных эпох. Когда last_epoch = -1, расписание запускается с начала. По умолчанию: -1

  • verbose ( bool ) — если True , выводит сообщение в стандартный вывод для каждого обновления. По умолчанию: False.

Пример

>>> optimizer = torch.optim.SGD (model.parameters (), lr = 0.1, momentum = 0.9) >>> scheduler = torch.optim.lr_scheduler.CyclicLR (optimizer, base_lr =  0,01, max_lr = 0,1) >>> data_loader = torch.utils.data.DataLoader (...) >>> для эпохи в диапазоне (10): >>> для партии в data_loader: >>> train_batch (...  ) >>> scheduler.step () 

get_lr () [источник] ¶

Вычисляет скорость обучения при индексировании пакета. Эта функция обрабатывает self. last_epoch в качестве индекса последнего пакета.

Если self.cycle_momentum имеет значение True , эта функция имеет сторону эффект обновления импульса оптимизатора.

class torch.optim.lr_scheduler. OneCycleLR ( optimizer , max_lr , total_steps = Нет , epochs = Нет , steps_per_epoch = Нет , pct_start = 0,3 , anneal_strategy = ‘cos’ , cycle_momentum = True , base_momentum = 0.85 , max_momentum = 0.95 , div_factor = 25.0 , final_div_factor = 10000.0 , last_epoch = -1 , verbose = False ) [источник] ¶

Устанавливает скорость обучения каждой группы параметров в соответствии с политикой скорости обучения 1 цикла. Политика 1 цикла преобразует скорость обучения от начальной скорости обучения к некоторой максимальной скорости обучения, а затем от этой максимальной скорости обучения к некоторой минимальной скорости обучения, намного меньшей, чем начальная скорость обучения. Эта политика первоначально была описана в статье Супер-конвергенция: очень быстрое обучение Нейронные сети с высокой скоростью обучения.

Политика скорости обучения 1cycle изменяет скорость обучения после каждого пакета. step должен вызываться после того, как пакет был использован для обучения .

Этот планировщик не соединяется в цепочку.

Обратите внимание, что общее количество шагов в цикле может быть определено одним из двух способов (перечисленных в порядке приоритета) :

  1. Значение total_steps указано явно.

  2. Количество эпох (эпохи) и количество шагов на эпоху (steps_per_epoch). В этом случае общее количество шагов определяется следующим образом: total_steps = epochs * steps_per_epoch

You должен либо предоставить оценку e для total_steps или укажите значение для twopochs и steps_per_epoch.

Параметры
  • optimizer ( Optimizer ) — Оптимизатор в оболочке.

  • max_lr ( float или list ) — верхние границы скорости обучения в цикле для каждой группы параметров.

  • total_steps ( int ) — общее количество шагов в цикле. Обратите внимание, что если значение здесь не указано, оно должно быть выведено путем предоставления значения для эпох и шагов_ на_эпоху. По умолчанию: Нет

  • эпох ( int ) — количество эпох для тренировки. Он используется вместе с steps_per_epoch, чтобы вывести общее количество шагов в цикле, если значение total_steps не указано. По умолчанию: None

  • steps_per_epoch ( int ) — количество шагов в эпоху для тренировки. Это используется вместе с эпохами, чтобы вывести общее количество шагов в цикле, если значение total_steps не указано.. По умолчанию: Нет

  • pct_start ( float ) — Процент цикла ( в количестве шагов), увеличивая скорость обучения. По умолчанию: 0,3

  • anneal_strategy ( str ) — {‘cos’, ‘linear’} Определяет стратегию отжига: «cos» для косинусного отжига, «linear» для линейного отжига. По умолчанию: ‘cos’

  • cycle_momentum ( bool ) — если True , импульс изменяется обратно пропорционально скорости обучения между ‘base_momentum’ и ‘max_momentum’. По умолчанию: True

  • base_momentum ( float или list ) — нижние границы импульса в цикле для каждой группы параметров. Обратите внимание, что импульс изменяется обратно пропорционально скорости обучения; на пике цикла импульс равен base_momentum, а скорость обучения — max_lr. По умолчанию: 0.85

  • max_momentum ( float или list ) — верхние границы импульса в цикле для каждой группы параметров. Функционально он определяет амплитуду цикла (max_momentum — base_momentum). Обратите внимание, что количество импульсов изменяется обратно пропорционально скорости обучения; в начале цикла импульс равен ‘max_momentum’, а скорость обучения ‘base_lr’ По умолчанию: 0,95

  • div_factor ( float ) — определяет начальную скорость обучения viainitial_lr = max_lr/div_factor По умолчанию: 25

  • final_div_factor ( float ) — определяет минимальную скорость обучения viamin_lr = initial_lr/final_div_factor По умолчанию: 1e4

  • last_epoch ( int ) — индекс последней партии. Этот параметр используется при возобновлении учебной работы. Так как step () должен вызываться после каждого пакета, а не после каждой эпохи, это число представляет собой общее количество вычисленных пакетов , а не общее количество вычисленных эпох. Когда last_epoch = -1, расписание запускается с начала. По умолчанию: -1

  • verbose ( bool ) — если True , выводит сообщение в стандартный вывод для каждого обновления. По умолчанию: False.

Пример

>>> data_loader = torch.utils.data.DataLoader (...) >>> optimizer = torch.optim.SGD (model.parameters (), lr = 0.1, momentum = 0.9)  >>> scheduler = torch.optim.lr_scheduler.OneCycleLR (optimizer, max_lr = 0.01, steps_per_epoch = len (data_loader), epochs = 10) >>> для эпохи в диапазоне (10): >>> для партии в data_loader:>  >> train_batch (...) >>> scheduler.step () 

класс torch.optim.lr_scheduler. CosineAnnealingWarmRestarts ( optimizer , T_0 , T_mult = 1 , eta_min = 0 , last_epoch = -1 , verbose = False ) [источник] ¶

Установите скорость обучения каждой группы параметров с помощью расписания косинусного отжига, где η m a x eta_ {max} ηmax устанавливается равным начальному lr, ​​ Tcur T_ {cur} Tcur — количество эпох с момента последнего перезапуска и Ti T_ {i} Ti — количество эпох между двумя горячими перезапусками в SGDR:

η t = η m i n + 1 2 ( η m a x — η m i n ) ( 1 + cos ⁡ ( T c u r T i π ) ) eta_t = eta_ {min} + frac {1} {2} ( eta_ {max} — eta_ {min}) left (1 + cos left ( frac {T_ {cur}) } {T_ {i}} pi right) right) ηt = ηmin +21 (ηmax −ηmin) (1 + cos (Ti Tcur Π))

Когда T cur = T i T_ {cur} = T_ {i} Tcur = Ti, установите η t = η m i n eta_t = eta_ {min} ηt = ηmin. Когда T c u r =0T_{cur}=0 Tcur = 0 после перезапуска установите ηt = η m a x eta_t = eta_ {max} ηt = ηmax .

Это было предложено в SGDR: стохастический градиентный спуск с теплыми перезапусками.

Параметры
  • optimizer ( Optimizer ) — обернутый оптимизатор.

  • T_0 ( int ) — количество итераций для первого перезапуска.

  • T_mult ( int , необязательно ) — коэффициент увеличивает T i T_ {i} Ti после перезапуска. По умолчанию: 1.

  • eta_min ( float , необязательно ) — Минимальная скорость обучения. По умолчанию: 0.

  • last_epoch ( int , необязательно ) — индекс последней эпохи. По умолчанию: -1.

  • verbose ( bool ) — Если True , выводит сообщение в стандартный вывод для каждого обновления. По умолчанию: False.

step ( epoch = None ) [source] ¶

Шаг мог вызываться после каждого пакетного обновления

Пример

>>> scheduler = CosineAnnealingWarmRestarts (optimizer, T_0, T_mult) >>> iters = len (dataloader) >>> для эпохи в  range (20): >>> для i, образец в перечислении (загрузчик данных): >>> входы, метки = образец ['входы'], образец ['метки'] >>> optimizer.zero_grad () >>> выходы  = net (входы) >>> потеря = критерий (выходы, метки) >>> loss.backward () >>> optimizer.step () >>> scheduler.step (epoch + i/iters) 

Эту функцию можно вызывать чередующимся способом.

Пример

>>> scheduler = CosineAnnealingWarmRestarts (optimizer, T_0, T_mult) >>> для эпохи в диапазоне (20): >>> scheduler.step () >>> scheduler.step (26) >>> scheduler.step ()  # scheduler.step (27) вместо scheduler (20) 

Средние стохастические веса ng¶

torch.optim.swa_utils реализует стохастическое усреднение веса (SWA). В частности, класс torch.optim.swa_utils.AveragedModel реализует модели SWA, torch.optim.swa_utils.SWALR реализует планировщик скорости обучения SWA и torch.optim.swa_utils.update_bn () — служебная функция, используемая для обновления статистики пакетной нормализации SWA в конце обучения.

SWA был предложен в разделе «Усреднение веса ведет к расширению» Оптима и лучшее обобщение.

Построение усредненных моделей¶

AveragedModel класс служит для вычисления весов Модель SWA. Вы можете создать усредненную модель, выполнив:

>>> swa_model = AveragedModel (model) 

Здесь модель model может быть произвольным объектом torch.nn.Module . swa_model будет отслеживать текущие средние параметры модели . Чтобы обновить эти средние значения, вы можете использовать функцию update_parameters () :

>>> swa_model.update_parameters (model)  

Расписания скорости обучения SWA¶

Как правило, в SWA скорость обучения установлена ​​на высокое постоянное значение. SWALR — это планировщик скорости обучения, который преобразует скорость обучения в фиксированное значение, а затем поддерживает ее постоянной. Например, следующий код создает планировщик, который линейно изменяет скорость обучения от исходного значения до 0,05 за 5 эпох в каждой группе параметров:

>>>  swa_scheduler = torch.optim.swa_utils.SWALR (optimizer,  >>> anneal_strategy = "linear", anneal_epochs = 5, swa_lr = 0.05) 

Вы также можете используйте косинусный отжиг до фиксированного значения вместо линейного отжига, задав anneal_strategy = "cos" .

Забота о партии нормализация¶

update_bn () — это служебная функция, которая позволяет вычислять статистику пакетной обработки для модели SWA на заданном загрузчике данных в конце обучения:

>>> torch.optim.swa_utils.update_bn (loader, swa_model) 

update_bn () применяет swa_model к каждому элементу в загрузчике данных и вычисляет статистику активации для каждого уровня пакетной нормализации в модели .

Предупреждение

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

Пользовательские стратегии усреднения¶

По умолчанию torch.optim.swa_utils.AveragedModel вычисляет текущее равное среднее значение предоставленных вами параметров, но вы также можете использовать пользовательские функции усреднения с параметром avg_fn . В следующем примере ema_model вычисляет экспоненциальную скользящую среднюю.

Пример:

  >>> ema_avg = lambda averaged_model_parameter, model_parameter, num_averaged:  >>> 0,1 * averaged_model_parameter + 0,9 * параметр_модели >>> ema_model = torch.optim.swa_utils.AveragedModel (model, avg_fn = ema_avg) 

Собираем все вместе¶

В приведенном ниже примере swa_model — это SWA модель, которая накапливает средние значения весов. Мы обучаем модель в общей сложности 300 эпох, переключаемся на график скорости обучения SWA и начинаем собирать средние значения параметров SWA для эпохи 160:

  >>> загрузчик, оптимизатор, модель, loss_fn = ... >>> swa_model = torch.optim.swa_utils.AveragedModel (модель) >>> scheduler = torch.optim.lr_scheduler.CosineAnnealingLR (оптимизатор, T_max = 300) >>  > swa_start = 160 >>> swa_scheduler = SWALR (optimizer, swa_lr = 0.05) >>>>>> для эпохи в диапазоне (300): >>> для ввода, цель в загрузчике: >>> optimizer.zero_grad ()>  >> loss_fn (модель (вход), цель) .backward () >>> optimizer.step () >>> if i> swa_start: >>> swa_model.update_parameters (модель) >>> swa_scheduler.step () >>  > else: >>> scheduler.step () >>>>>> # Обновить bn-статистику для swa_model в конце >>> torch.optim.swa_utils.update_bn (loader, swa_model) >>> # Использовать swa_model для создания  прогнозы на тестовых данных >>> preds = swa_model (test_input) 

Оцените статью
logicle.ru
Добавить комментарий