Может ли ICLR 2018 Best Paper AMSGrad заменить Адама?

искусственный интеллект GitHub алгоритм регулярное выражение
Филип Корженёвски Сборник: слабенький

Примечание редактора: Редди из Google и др.Бумага о схождении АдамаНедавно оцененный ICLR Лучшая статья 2018 года, предлагающая вариант Адама, АМСГрад. Итак, на практике может ли AMSGrad заменить Адама (один из самых популярных сегодня методов оптимизации в глубоком обучении)? Давайте посмотрим на эксперименты, проведенные доктором Филипом Корженёвски из Университета Линца (JKU) в Австрии.

В ICLR 2018 Best Paper On the Convergence of Adam and Beyond (о конвергенции Адама и других) Редди и др. из Google указали на недостатки доказательства сходимости Адама и предложили вариант алгоритма Адама, AMSGrad. В статье демонстрируются преимущества АМСГрад за счет синтетической задачи и небольшого количества экспериментов. Однако он использует только небольшие сети (однослойный MLP на MNIST, небольшие сверточные сети на CIFAR-10) и не указывает на точность теста (очевидно, мы больше заботимся о точности, чем о кросс-энтропийных потерях). С точки зрения потерь при обучении и тестировании их сверточная сеть, обученная на CIFAR-10, намного хуже, чем текущие результаты (точность нам неизвестна).

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

Я внес изменения на основе реализации Адама Lasagne для реализации AMSGrad. Я также добавил возможность отключить коррекцию смещения Адама.

    

  1. def amsgrad(loss_or_grads, params, learning_rate=0.001, beta1=0.9,
    2. 

  2.             beta2=0.999, epsilon=1e-8, bias_correction=True):
    3. 

  3.     all_grads = get_or_compute_grads(loss_or_grads, params)
    4. 

  4.     t_prev = theano.shared(utils.floatX(0.))
    5. 

  5.     updates = OrderedDict()
    6. 

    7. 

  7.     # 使用theano常量以避免向上转型（upcast）到float32
    8. 

  8.     one = T.constant(1)
    9. 

    10. 

  10.     t = t_prev + 1
    11. 

    12. 

  12.     if bias_correction:
    13. 

  13.         a_t = learning_rate*T.sqrt(one-beta2**t)/(one-beta1**t)
    14. 

  14.     else:
    15. 

  15.         a_t = learning_rate
    16. 

    17. 

  17.     for param, g_t in zip(params, all_grads):
    18. 

  18.         value = param.get_value(borrow=True)
    19. 

    20. 

  20.         m_prev = theano.shared(np.zeros(value.shape, dtype=value.dtype), 
    21. 

  21.                                broadcastable=param.broadcastable)
    22. 

  22.         v_prev = theano.shared(np.zeros(value.shape, dtype=value.dtype), 
    23. 

  23.                                broadcastable=param.broadcastable)
    24. 

  24.         v_hat_prev = theano.shared(np.zeros(value.shape, dtype=value.dtype), 
    25. 

  25.                                    broadcastable=param.broadcastable)
    26. 

    27. 

  27.         m_t = beta1*m_prev + (one-beta1)*g_t
    28. 

  28.         v_t = beta2*v_prev + (one-beta2)*g_t**2
    29. 

  29.         v_hat_t = T.maximum(v_hat_prev, v_t)
    30. 

  30.         step = a_t*m_t/(T.sqrt(v_hat_t) + epsilon)
    31. 

    32. 

  32.         updates[m_prev] = m_t
    33. 

  33.         updates[v_prev] = v_t
    34. 

  34.         updates[v_hat_prev] = v_hat_t
    35. 

  35.         updates[param] = param - step
    36. 

    37. 

  37.     updates[t_prev] = t
    38. 

  38.     return updates
    39. 

скопировать код

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

Это довольно близко к графику в статье и похоже на повторную реализацию ycmario. Адам ошибочно сходится к 1, тогда как оптимальное значение x равно -1.

Затем я экспериментировал с четырьмя конфигурациями:

  • Логистическая регрессия на MNIST.

  • CifarNet (CNN, описанный в документе) на CIFAR-10.

  • SmallVgg на CIFAR-10 (небольшая сеть в стиле VGG)

  • Vgg на CIFAR-10 (более крупная сеть в стиле VGG)

В каждой конфигурации я выполнил 5 тренировочных проходов для всех следующих комбинаций:

  • бета2 ∈ {0,99, 0,999} (согласно статье)

  • скорость обучения ∈ {0,01, 0,001, 0,0001}

  • Коррекция смещения ∈ {вкл., выкл.}

Размер партии составляет 128 (такой же, как у оригинальной бумаги). После обучения в течение 150 эпох начальная скорость обучения уменьшалась линейно, пока не упала до 0 после 150-й эпохи.В экспериментах CIFAR-10 я также использовал стандартное увеличение данных с переворачиванием влево-вправо. Соответствующий код можно найти в репозитории GitHub fdlm/amsgrad_experiments.

Давайте сначала сосредоточимся на конфигурации Vgg. Хотя у каждой из этих конфигураций есть свои особенности, выводы, которые мы можем сделать из результатов, одинаковы.

Вгг на СИФАР-10

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

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

На приведенном ниже графике результаты Адама показаны синим цветом, а результаты AMSGrad — красным. Более светлый цвет указывает на то, что коррекция смещения отключена. Каждая строка представляет одну тренировку.

потеря тренировки

В моих экспериментах потери при обучении очень близки к 0, а значение в статье равно 0,3, Это, конечно, потому, что я использую гораздо большую модель. Мы также видим, что AMSGrad, по-видимому, сходится немного быстрее на заключительном этапе обучения, если скорость обучения не слишком низкая, и что в большинстве случаев помогает использование коррекции смещения. Однако, в конце концов, все варианты сходятся к одинаковой окончательной потере при большинстве конфигураций гиперпараметров (за исключением слишком низких скоростей обучения). Если мы присмотримся повнимательнее, то увидим, что Адам превзошел АМСГрад в последние несколько эпох. В этом нет ничего страшного — в конце концов, это потеря на тренировке. Однако результаты этого типа модели (и схемы обучения) сильно отличаются от модели CifarNet, о которой сообщается в статье, где AMSGrad имеет гораздо меньшие потери при обучении, чем Адам.

потеря проверки

Потеря проверки ведет себя по-другому. Мы видим, что АМСГрад постоянно превосходит Адама, особенно на поздних эпохах. Оба алгоритма достигают одинаковых минимальных ошибок проверки (около эпох 20-25), но с тех пор Адам, похоже, больше переоснащается, по крайней мере, в отношении потери перекрестной энтропии. Так может ли AMSGrad компенсировать тот факт, что Адам часто менее универсален, чем стандартный SGD (стохастический градиентный спуск)? Чтобы ответить на этот вопрос, необходимо провести некоторые стандартные эксперименты с SGD.

точность обучения

Посмотрим на точность. В задачах классификации точность является гораздо более важным показателем, чем кросс-энтропийные потери. В конце концов, все, о чем мы заботимся, это то, сколько образцов наша модель успешно классифицировала. Во-первых, давайте посмотрим на точность обучения. Что касается CIFAR-10, самые мощные модели могут достигать почти 100% точности при правильном обучении (на самом деле они все еще могут достигать 100% точности даже со случайными метками).

Как мы видим, точность обучения и потери при обучении работают примерно одинаково: AMSGrad сходится быстрее, чем Адам, но конечный результат аналогичен. Если гиперпараметры не слишком запредельные, мы можем достичь почти 100% точности с любым алгоритмом (опять же, скорость обучения не может быть слишком низкой).

Наконец, наступает самое интересное — проверка точности.

Проверить точность

Сейчас время разочарования. Хотя AMSGrad имеет меньшие потери при проверке для всех конфигураций гиперпараметров, в основном это ничья с точки зрения точности проверки. В одних условиях Адам работает лучше (lr = 0,01, b2 = 0,999), а в других лучше работает AMSGrad (lr = 0,001, b2 = 0,999). Лучший результат из всех конфигураций у Адама (lr = 0,001, b2 = 0,99), но я не думаю, что разница существенна. Похоже, что при подходящих настройках гиперпараметров оба алгоритма работают примерно одинаково.

обсуждать

В документе указывается на фатальную ошибку в доказательстве сходимости Адама и показан проверенный вариант Адама, AMSGrad. Однако я нашел ограниченную экспериментальную оценку фактического влияния статьи на AMSGrad. В статье авторы утверждают (курсив мой): "AMSGrad превосходит Адама по потерям и точности при обучении. Кроме того, это улучшение производительности приводит к потерям при тестировании". подтвердите это:

  • Независимо от того, основан ли он на потерях или на точности, оба они работают одинаково на тренировочном наборе.

  • Потери в тесте AMSGrad (проверка здесь) действительно низкие. Тем не мение,

  • Улучшение потерь при тестировании не привело к повышению точности тестирования (честно говоря, авторы никогда не заявляли об этом).

  • Разница в производительности между потерями при тестировании и точностью теста поднимает ключевой вопрос: насколько подходит класс cross-entropy для обучения нейронных сетей классификации? Можем ли мы сделать лучше?

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

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

приложение

Здесь я показываю результаты для других настроек.

Логистическая регрессия на MNIST

Эта установка аналогична эксперименту в статье. Единственная разница заключается в скорости обучения: в статье используется α/√t, где t — итерация, а я использую линейное затухание после каждой эпохи, упомянутой ранее. Давайте посмотрим на результаты.

потеря тренировки

Первое, что мы видим, это то, что линейное снижение скорости обучения может привести к гораздо меньшим потерям при обучении. В документе кривая обучения остается ровной на уровне около 0,25 после более чем 5000 итераций (размер партии 128, ~ 13 эпох). В то время как в моих экспериментах, в зависимости от гиперпараметров, он достигал 0,2.Еще один интересный вывод заключается в том, что Адам добился наименьших конечных потерь при обучении среди всех конфигураций. Это противоречит результатам, приведенным в документе, особенно в документе утверждается, что AMSGrad более устойчив к изменениям параметров, чем Adam.

потеря проверки

Здесь все по-другому. AMSGrad обычно дает наименьшие потери при проверке (если только мы не используем слишком низкую скорость обучения). Однако при lr = 0,002, b2 = 0,99 Адам достиг наименьших потерь при валидации (разница была минимальной), но затем разошлись.

точность обучения

Точность обучения ведет себя очень похоже на потери при обучении, как и точность проверки.

Проверить точность

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

CifarNet на CIFAR-10

Я пытаюсь воспроизвести реализацию сверточной нейронной сети, описанную в статье. Тем не менее, мне не удалось воспроизвести тренировочный уход. В зависимости от скорости обучения и бета2 я либо получаю лучшие потери при обучении (но худшие потери при проверке), либо оба хуже, чем в статье. Поскольку в документе не представлены все детали модели (например, мы не знаем схему инициализации, используется ли регуляризация L2 или нет), трудно понять, почему. Во всяком случае, ниже результат, который я получил.

потеря тренировки

Мы видим, что оба алгоритма не сходятся при более высоких скоростях обучения. Что касается потерь при обучении, скорость обучения, равная 0,001, кажется, работает лучше всего. Хотя Адам достигает наименьших потерь при тренировках, тренировки AMSGrad кажутся более стабильными (меньше дисперсии), хотя я думаю, что для подтверждения этого необходимы дополнительные испытания.

потеря проверки

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

точность обучения

Точность обучения ведет себя аналогично потерям при обучении.

Проверить точность

Вот самая интересная часть. Ранее мы видели модели, в которых потери при проверке сильно расходились, а точность проверки была на самом деле оптимальной. Модель, которая, по-видимому, лучше обобщает с точки зрения потерь при проверке, плохо обобщает с точки зрения точности проверки. Важно помнить об этом.

В зависимости от настройки, Adam или AMSGrad с небольшим отрывом превосходят друг друга. Более того, по сравнению с текущими современными моделями модель работала значительно хуже (точность всего 78%), независимо от используемого алгоритма оптимизации.

SmallVgg на CIFAR-10

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

потеря тренировки

потеря проверки

точность обучения

Проверить точность

Оригинальный адрес: https://fdlm.github.io/post/amsgrad/

Категории