Тензорный поток: путаница в отношении оптимизатора adam

Я смущен относительно того, как оптимизатор adam работает в тензорном потоке.

То, как я читаю документы , говорит, что скорость обучения меняется на каждую итерацию с градиентом спуска.

Но когда я вызываю функцию, я даю ей скорость обучения. И я не называю эту функцию, допустим, сделать одну эпоху (неявно вызывая # итерации, чтобы пройти обучение по данным). Я вызываю функцию для каждой партии явно

for epoch in epochs for batch in data sess.run(train_adam_step, feed_dict={eta:1e-3}) 

Поэтому моя эта не может меняться. И я не передаю переменную времени. Или это какая-то вещь типа генератора, где при создании сеанса t увеличивается каждый раз, когда я вызываю оптимизатор?

Предполагая, что это какая-то вещь типа генератора, и скорость обучения невидимо снижается: как я могу запустить оптимизатор adam, не разлагая скорость обучения? Мне кажется, что RMSProp в основном то же самое, единственное, что мне нужно сделать, чтобы сделать его равным (без учета скорости обучения) – изменить momentum гиперпараметров и decay в соответствии с beta1 и beta2 соответственно. Это верно?

  • Django SessionWizardView не выполняет выполненный метод
  • Как пропустить поддеревья в обход AST, используя привязки python для libclang
  • Django Rest Framework ListField и DictField
  • Как удалить пробелы и символы новой строки из каждого значения в файле JSON?
  • python: как преобразовать строковый литерал в строковый литерал?
  • Как работает / исполняется статут RENAME TABLE в MySQL?
  • Как я могу избежать преобразования python больших чисел в научную нотацию?
  • Текст по умолчанию, а также список textvariable Виджет ввода Tkinter
  • 2 Solutions collect form web for “Тензорный поток: путаница в отношении оптимизатора adam”

    Я нахожу документацию совершенно ясной, я вложу здесь алгоритм в псевдокод:

    Ваши параметры :

    • learning_rate : между 1е-4 и 1е-2 стандартно
    • beta1 : 0.9 по умолчанию
    • beta2 : 0.999 по умолчанию
    • epsilon : 1e-08 по умолчанию

      Значение по умолчанию 1e-8 для epsilon не может быть хорошим дефолтом в целом. Например, при обучении начальной сети в ImageNet текущий хороший выбор – 1,0 или 0,1.


    Инициализация:

     m_0 <- 0 (Initialize initial 1st moment vector) v_0 <- 0 (Initialize initial 2nd moment vector) t <- 0 (Initialize timestep) 

    m_t и v_t будут отслеживать скользящее среднее градиента и его квадрат для каждого параметра сети. (Итак, если у вас есть 1M параметры, Адам сохранит в памяти еще 2 миллиона параметров)


    На каждой итерации t и для каждого параметра модели :

     t <- t + 1 lr_t <- learning_rate * sqrt(1 - beta2^t) / (1 - beta1^t) m_t <- beta1 * m_{t-1} + (1 - beta1) * gradient v_t <- beta2 * v_{t-1} + (1 - beta2) * gradient ** 2 variable <- variable - lr_t * m_t / (sqrt(v_t) + epsilon) 

    Здесь lr_t немного отличается от learning_rate потому что для ранних итераций скользящие средние еще не сходились, поэтому мы должны нормализоваться путем умножения на sqrt(1 - beta2^t) / (1 - beta1^t) . Когда t велико ( t > 1./(1.-beta2) ), lr_t почти равен learning_rate


    Чтобы ответить на ваш вопрос, вам просто нужно пройти фиксированную скорость обучения , сохранить значения по умолчанию beta1 и beta2 , возможно, изменить epsilon , и Адам сделает магию 🙂


    Ссылка с RMSProp

    Адам с beta1=1 эквивалентен RMSProp с momentum=0 . Аргумент beta2 Адама и decay аргумента RMSProp одинаковы.

    Однако RMSProp не сохраняет скользящее среднее градиента. Но он может поддерживать импульс, например MomentumOptimizer.

    Подробное описание rmsprop.

    • поддерживать скользящее (дисконтированное) среднее значение квадрата градиентов
    • разделите градиент на корень этого среднего
    • (может поддерживать импульс)

    Вот псевдокод:

     v_t <- decay * v_{t-1} + (1-decay) * gradient ** 2 mom = momentum * mom{t-1} + learning_rate * gradient / sqrt(v_t + epsilon) variable <- variable - mom 

    RMS_PROP и ADAM имеют адаптивные уровни обучения.

    Основной RMS_PROP

     cache = decay_rate * cache + (1 - decay_rate) * dx**2 x += - learning_rate * dx / (np.sqrt(cache) + eps) 

    Вы можете видеть, изначально это имеет два параметра: decay_rate & eps

    Тогда мы можем добавить импульс, чтобы сделать наш градиент более устойчивым. Тогда мы можем написать

     cache = decay_rate * cache + (1 - decay_rate) * dx**2 **m = beta1*m + (1-beta1)*dx** [beta1 =momentum parameter in the doc ] x += - learning_rate * dx / (np.sqrt(cache) + eps) 

    Теперь вы можете увидеть, если мы будем держать beta1 = o Тогда это rms_prop без импульса.

    Затем основы ADAM

    В cs-231 Андрей Карпати изначально описал адама следующим образом

    Адам – ​​недавно появившееся обновление, которое немного напоминает RMSProp с импульсом

    Так да ! Тогда что делает это отличие от rms_prop с импульсом?

     m = beta1*m + (1-beta1)*dx v = beta2*v + (1-beta2)*(dx**2) **x += - learning_rate * m / (np.sqrt(v) + eps)** 

    Он снова упомянул в уравнении обновления m, v более гладкие .

    Таким образом, отличие от rms_prop – это обновление менее шумно.

    Что делает этот шум?

    В процедуре инициализации мы инициализируем m и v как ноль.

    т = у = 0

    Чтобы уменьшить этот эффект инициализации, всегда нужно провести разминку. Итак, уравнение похоже

     m = beta1*m + (1-beta1)*dx beta1 -o.9 beta2-0.999 **mt = m / (1-beta1**t)** v = beta2*v + (1-beta2)*(dx**2) **vt = v / (1-beta2**t)** x += - learning_rate * mt / (np.sqrt(vt) + eps) 

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

    mt = m

    Python - лучший язык программирования в мире.