Ошибка при обучении нейронной сети

Время прочтения
9 мин

Просмотры 37K

Сеть обучалась последние 12 часов. Всё выглядело хорошо: градиенты стабильные, функция потерь уменьшалась. Но потом пришёл результат: все нули, один фон, ничего не распознано. «Что я сделал не так?», — спросил я у компьютера, который промолчал в ответ.

Почему нейросеть выдаёт мусор (например, среднее всех результатов или у неё реально слабая точность)? С чего начать проверку?

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

Содержание

0. Как использовать это руководство?
I. Проблемы с набором данных
II. Нормализация данных/Проблемы аугментации
III. Проблемы реализации
IV. Проблемы обучения

0. Как использовать это руководство?

Многое может пойти не так. Но некоторые проблемы встречаются чаще, чем другие. Я обычно начинаю с этого маленького списка как набора экстренной помощи:

1. Начните с простой модели, которая точно правильно работает для этого типа данных (например, VGG для изображений). Используйте стандартную функцию потерь, если возможно.
2. Отключите все финтифлюшки, например, регуляризацию и аугментацию данных.
3. В случае тонкой настройки модели дважды проверьте препроцессинг, чтобы он соответствовал обучению первоначальной модели.
4. Удостоверьтесь в правильности входных данных.
5. Начните с действительно маленького набора данных (2-20 образцов). Затем расширяйте его, постепенно добавляя новые данные.
6. Начните постепенно добавлять обратно все фрагменты, которые были опущены: аугментация/регуляризация, кастомные функции потерь, пробуйте более сложные модели.

Если ничего не помогло, то приступайте к чтению этого длинного списка и проверяйте каждый пункт.

I. Проблемы с набором данных

_{Источник: http://dilbert.com/strip/2014-05-07}

1. Проверьте входные данные

Проверьте, что входные данные имеют смысл. Например, я не раз смешивал в кучу высоту и ширину изображений. Иногда по ошибке отдавал в нейросеть все нули. Или использовал одну и ту же партию снова и снова. Так что напечатайте/посмотрите пару партий входных данных и плановых выходных данных — убедитесь, что всё в порядке.

2. Попробуйте случайные входные значения

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

3. Проверьте загрузчик данных

С данными всё может быть в порядке, а ошибка в коде, который передаёт входные данные нейросети. Распечатайте и проверьте входные данные первого слоя перед началом его операций.

4. Убедитесь, что вход соединяется с выходом

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

5. Взаимоотношение между входом и выходом слишком случайно?

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

6. Слишком много шума в наборе данных?

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

Данный пункт достоин отдельного разговора, потому что эта работа показывает точность выше 50% на базе MNIST при 50% повреждённых меток.

7. Перемешайте набор данных

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

8. Снизьте несбалансированность классов

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

9. Достаточно ли образцов для обучения?

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

10. Убедитесь в отсутствии партий с единственной меткой

Такое случается в отсортированном наборе данных (то есть первые 10 тыс. образцов содержат одинаковый класс). Легко исправляется перемешиванием набора данных.

11. Уменьшите размер партий

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

Дополнение 1. Используйте стандартный набор данных (например, mnist, cifar10)

Спасибо hengcherkeng за это:

При тестировании новой сетевой архитектуры или написании нового кода сначала используйте стандартные наборы данных вместо своих. Потому что для них уже есть много результатов и они гарантированно «разрешимые». Там не будет проблем с шумом в метках, разницей в распределении обучение/тестирование, слишком большой сложностью набора данных и т.д.

II. Нормализация данных/Проблемы аугментации

12. Откалибруйте признаки

Вы откалибровали входные данные на нулевое среднее и единичную дисперсию?

13. Слишком сильная аугментация данных?

Аугментация имеет регуляризующий эффект. Если она слишком сильная, то это вкупе с другими формами регуляризации (L2-регуляризация, dropout и др.) может привести к недообучению нейросети.

14. Проверьте предобработку предварительно обученной модели

Если вы используете уже подготовленную модель, то убедитесь, что используются та же нормализация и предобработка, что и в модели, которую вы обучаете. Например, должен пиксель быть в диапазоне [0, 1], [-1, 1] или [0, 255]?

15. Проверьте предварительную обработку для набора обучение/валидация/тестирование

CS231n указал на типичную ловушку:

«… любую статистику предобработки (например, среднее данных) нужно вычислять на данных для обучения, а потом применять на данных валидации/тестирования. Например, будет ошибкой вычисление среднего и вычитание его из каждого изображения во всём наборе данных, а затем разделение данных на фрагменты для обучения/валидации/тестирования».

Также проверьте на предмет наличия различающейся предварительной обработки каждого образца и партии.

III. Проблемы реализации

_{Источник: https://xkcd.com/1838/}

16. Попробуйте решить более простой вариант задачи

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

17. Поищите правильную функцию потерь «по вероятности»

Снова из бесподобного CS231n: Инициализируйте с небольшими параметрами, без регуляризации. Например, если у нас 10 классов, то «по вероятности» означает, что правильный класс определится в 10% случаев, а функция потерь Softmax — это обратный логарифм к вероятности правильного класса, то есть получается

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

18. Проверьте функцию потерь

Если вы реализовали свою собственную, проверьте её на баги и добавьте юнит-тесты. У меня часто бывало, что слегка неправильная функция потерь тонко вредила производительности сети.

19. Проверьте входные данные функции потерь

Если вы используете функцию потерь из фреймворка, то убедитесь, что передаёте ей то что нужно. Например, в PyTorch я бы смешал NLLLoss и CrossEntropyLoss, потому что первая требует входных данных softmax, а вторая — нет.

20. Отрегулируйте веса функции потерь

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

21. Отслеживайте другие показатели

Иногда функция потерь — не лучший предиктор того, насколько правильно обучается ваша нейросеть. Если возможно, используйте другие показатели, такие как точность.

22. Проверьте каждый кастомный слой

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

23. Проверьте отсутствие «зависших» слоёв или переменных

Посмотрите, может вы неумышленно отключили обновления градиента каких-то слоёв/переменных.

24. Увеличьте размер сети

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

25. Поищите скрытые ошибки измерений

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

26. Исследуйте Gradient Checking

Если вы самостоятельно реализовали Gradient Descent, то с помощью Gradient Checking можно убедиться в корректной обратной связи. Дополнительная информация: 1, 2, 3.

IV. Проблемы обучения

_{Источник: http://carlvondrick.com/ihog/}

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

Переобучите сеть на маленьком наборе данных и убедитесь в её работе. Например, обучите её всего с 1-2 примерами и посмотрите, способна ли сеть различать объекты. Переходите к большему количеству образцов для каждого класса.

28. Проверьте инициализацию весов

Если не уверены, используйте инициализацию Ксавьера или Хе. К тому же, ваша инициализация может вывести на плохой локальный минимум, так что испытайте другую инициализацию, может поможет.

29. Измените гиперпараметры

Может вы используете плохой набор гиперпараметров. Если возможно, попробуйте grid search.

30. Уменьшите регуляризацию

Из-за слишком сильной регуляризации сеть может конкретно недообучиться. Уменьшите регуляризацию, такую как dropout, batch norm, L2-регуляризацию weight/bias и др. В отличном курсе «Практическое глубинное обучение для программистов» Джереми Говард рекомендует в первую очередь избавиться от недообучения. То есть нужно достаточно переообучить сеть на исходных данных, и только затем бороться с переобучением.

31. Дайте время

Может сети нужно больше времени на обучение, прежде чем она начнёт делать осмысленные предсказания. Если функция потерь стабильно уменьшается, дайте ей обучиться чуть подольше.

32. Переходите от режима обучения в режим тестирования

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

33. Визуализируйте обучение

• Отслеживайте активации, веса и обновления для каждого слоя. Убедитесь, что отношения их величин совпадают. Например, отношение величины обновлений к параметрам (весам и смещениям) должно равняться 1e-3.
• Рассмотрите библиотеки визуализации вроде Tensorboard и Crayon. В крайнем случае, можно просто печатать значения весов/сдвигов/активаций.
• Будьте осторожны с активациями сетей со средним намного больше нуля. Попробуйте Batch Norm или ELU.
• Deeplearning4j указал, на что смотреть в гистограммах весов и сдвигов:

«Для весов эти гистограммы должны иметь примерно гауссово (нормальное) распределение, спустя какое-то время. Гистограммы сдвигов обычно начинаются с нуля и обычно заканчиваются на уровне примерно гауссова распределения (единственное исключение — LSTM). Следите за параметрами, которые отклоняются на плюс/минус бесконечность. Следите за сдвигами, которые становятся слишком большими. Иногда такое случается в выходном слое для классификации, если распределение классов слишком несбалансировано».

• Проверяйте обновления слоёв, они должны иметь нормальное распределение.

34. Попробуйте иной оптимизатор

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

Прочтите отличную статью Себастьяна Рудера, чтобы узнать больше об оптимизаторах градиентного спуска.

35. Взрыв/исчезновение градиентов

• Проверьте обновления слоя, поскольку очень большие значения могут указывать на взрывы градиентов. Может помочь клиппинг градиента.
• Проверьте активации слоя. Deeplearning4j даёт отличный совет: «Хорошее стандартное отклонение для активаций находится в районе от 0,5 до 2,0. Значительный выход за эти рамки может указывать на взрыв или исчезновение активаций».

36. Ускорьте/замедлите обучение

Низкая скорость обучения приведёт к очень медленному схождению модели.

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

Поэкспериментируйте со скоростью обучению, ускоряя либо замедляя её в 10 раз.

37. Устранение состояний NaN

Состояния NaN (Non-a-Number) гораздо чаще встречаются при обучении RNN (насколько я слышал). Некоторые способы их устранения:

• Уменьшите скорость обучения, особенно если NaN появляются в первые 100 итераций.
• Нечисла могут возникнуть из-за деления на ноль, взятия натурального логарифма нуля или отрицательного числа.
• Рассел Стюарт предлагает хорошие советы, что делать в случае появления NaN.
• Попробуйте оценить сеть слой за слоем и посмотреть, где появляются NaN.

Обучение нейронных сетей

Перед использованием нейронной сети ее необходимо обучить.

Процесс обучения нейронной сети заключается в подстройке ее внутренних параметров под конкретную задачу.

Алгоритм работы нейронной сети является итеративным, его шаги называют эпохами или циклами.

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

Процесс обучения осуществляется на обучающей выборке.

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

Таким образом, перед нами ставится вопрос — какие входные поля (признаки) нам необходимо использовать. Первоначально выбор осуществляется эвристически, далее количество входов может быть изменено.

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

Количество необходимых наблюдений зависит от сложности решаемой задачи. При увеличении количества признаков количество наблюдений возрастает нелинейно, эта проблема носит название «проклятие размерности». При недостаточном количестве данных рекомендуется использовать линейную модель.

Аналитик должен определить количество слоев в сети и количество нейронов в каждом слое.

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

Ошибка обучения для построенной нейронной сети вычисляется путем сравнения выходных и целевых (желаемых) значений. Из полученных разностей формируется функция ошибок.

Функция ошибок — это целевая функция, требующая минимизации в процессе управляемого обучения нейронной сети.

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

От качества обучения нейронной сети зависит ее способность решать поставленные перед ней задачи.

Переобучение нейронной сети

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

Переобучение, или чрезмерно близкая подгонка — излишне точное соответствие нейронной сети конкретному набору обучающих примеров, при котором сеть теряет способность к обобщению.

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

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

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

На обучающем множестве происходит обучение нейронной сети. На тестовом множестве осуществляется проверка построенной модели. Эти множества не должны пересекаться.

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

Описанный процесс проиллюстрирован на рис. 11.2.

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

Прогноз на тестовом множестве является проверкой работоспособности построенной модели. Ошибка на тестовом множестве может являться ошибкой прогноза, если тестовое множество максимально приближено к текущему моменту.

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

Взрывающийся и затухающий градиент

Определение

Напомним, что градиентом в нейронных сетях называется вектор частных производных функции потерь по весам нейронной сети. Таким образом, он указывает на направление наибольшего роста этой функции для всех весов по совокупности. Градиент считается в процессе тренировки нейронной сети и используется в оптимизаторе весов для улучшения качества модели.

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

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

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

Причины

Такая проблема может возникнуть при использовании нейронных сетях классической функцией активации (англ. activation function) сигмоиды (англ. sigmoid):

$sigma(x) = frac{1}{1 + e^{-x}}.$

Эта функция часто используется, поскольку множество ее возможных значений — отрезок $[0, 1]$ — совпадает с возможными значениями вероятностной меры, что делает более удобным ее предсказание. Также график сигмоиды соответствует многим естественным процессам, показывающим рост с малых значений, который ускоряется с течением времени, и достигающим своего предела^[2] (например, рост популяции).

Пусть сеть состоит из подряд идущих нейронов с функцией активации $sigma(x)$; функция потерть (англ. loss function) $L(y) = MSE(y, hat{y}) = (y — hat{y})^2$ (англ. MSE — Mean Square Error); $u_d$ — значение, поступающее на вход нейрону на слое $d$; $w_d$ — вес нейрона на слое $d$; $y$ — выход из последнего слоя. Оценим частные производные по весам такой нейронной сети на каждом слое. Оценка для производной сигмоиды видна из рисунка 1.

$frac{partial(L(y))}{partial(w_d)} = frac{partial(L(y))}{partial(y)} cdot frac{partial(y)}{partial(w_d)} = 2 (y — hat{y}) cdot sigma'(w_d u_d) u_d leq 2 (y — hat{y}) cdot frac{1}{4} u_d$

$frac{partial(L(y))}{partial(w_{d — 1})} = frac{partial(L(y))}{partial(w_d)} cdot frac{partial(w_d)}{partial(w_{d — 1})} leq 2 (y — hat{y}) cdot (frac{1}{4})^2 u_d u_{d-1}$

$ldots$

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

Однако, входные значения скрытых слоев есть выходные значения функций активаций предшествующих им слоев. В частности, сигмоида насыщается (англ. saturates) при стремлении аргумента к $+infty$ или $-infty$, то есть имеет там конечный предел. Это приводит к тому, что более отдаленные слои обучаются медленнее, так как увеличение или уменьшение аргумента насыщенной функции вносит малые изменения, и градиент становится все меньше. Это и есть проблема затухающего градиента.

Способы определения

Взрывающийся градиент

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

• Модель плохо обучается на данных, что отражается в высоком значении функции потерь.
• Модель нестабильна, что отражается в значительных скачках значения функции потерь.
• Значение функции потерь принимает значение NaN.

Более непрозрачные признаки, которые могут подтвердить возникновение проблемы:

• Веса модели растут экспоненциально.
• Веса модели принимают значение NaN.

Затухающий градиент

Признаки проблемы затухающего градиента:

• Точность модели растет медленно, при этом возможно раннее срабатывание критерия останова, так как алгоритм может решить, что дальнейшее обучение не будет оказывать существенного влияния.
• Градиент ближе к концу показывает более сильные изменения, в то время как градиент ближе к началу почти не показывает никакие изменения.
• Веса модели уменьшаются экспоненциально во время обучения.
• Веса модели стремятся к $0$ во время обучения.

Способы устранения

Использование другой функции активации

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

Tanh

$tanh(x) = frac{e^x — e^{-x}}{e^x + e^{-x}}$

Функция аналогична сигмоиде, но множество возможных значений: $[-1, 1]$. Градиенты при этом сосредоточены около $0$,. Однако, эта функция также насыщается в обоих направлениях, поэтому также может приводить к проблеме затухающего градиента.

ReLU

$h(x) = max(0, x)$

Функция проста для вычисления и имеет производную, равную либо $1$, либо $0$. Также есть мнение, что именно эта функция используется в биологических нейронных сетях. При этом функция не насыщается на любых положительных значениях, что делает градиент более чувствительным к отдаленным слоям.

Недостатком функции является отсутствие производной в нуле, что можно устранить доопределением производной в нуле слева или справа. Также эту проблему устраняет использование гладкой аппроксимации, Softplus.

Существуют модификации ReLU:

• Noisy ReLU: $h(x) = max(0, x + varepsilon), varepsilon sim N(0, sigma(x))$.
• Parametric ReLU: $h(x) = begin{cases} x & x > 0 \ beta x & text{otherwise} end{cases}$.
• Leaky ReLU: Paramtetric ReLU со значением $beta = 0.01$.

Softplus

$h(x) = ln(1 + e^x)$

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

Графики всех функций активации приведены на рисунок 2.

Изменение модели

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

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

Использование Residual blocks

В данной конструкции вывод нейрона подается как следующему нейрону, так и нейрону на расстоянии 2-3 слоев впереди, который суммирует его с выходом предшествующего нейрона, а функция активации в нем — ReLU (см. рисунок 3). Такая связка называется shortcut. Это позволяет при обратном распространении ошибки значениям градиента в слоях быть более чувствительным к градиенту в слоях, с которыми связаны с помощью shortcut, то есть расположенными несколько дальше следующего слоя.

Регуляризация весов

Регуляризация заключается в том, что слишком большие значения весов будут увеличивать функцию потерь. Таким образом, в процессе обучения нейронная сеть помимо оптимизации ответа будет также минимизировать веса, не позволяя им становиться слишком большими.

Обрезание градиента

Образание заключается в ограничении нормы градиента. То есть если норма градиента превышает заранее выбранную величину $T$, то следует масштабировать его так, чтобы его норма равнялась этой величине:

$nabla_{clipped} = begin{cases} nabla & || nabla || leq T \ frac{T}{|| nabla ||} cdot nabla & text{otherwise} end{cases}.$

См. также

• Нейронные сети, перцептрон
• Обратное распространение ошибки
• Регуляризация
• Глубокое обучение
• Сверточные нейронные сети

Примечания

Источники

• Курс Machine Learning, ИТМО, 2020;
• towardsdatascience.com — The vanishing exploding gradient problem in deep neural networks;
• machinelearningmastery.com — Exploding gradients in neural networks.

Verify that your code is bug free

There’s a saying among writers that «All writing is re-writing» — that is, the greater part of writing is revising. For programmers (or at least data scientists) the expression could be re-phrased as «All coding is debugging.»

Any time you’re writing code, you need to verify that it works as intended. The best method I’ve ever found for verifying correctness is to break your code into small segments, and verify that each segment works. This can be done by comparing the segment output to what you know to be the correct answer. This is called unit testing. Writing good unit tests is a key piece of becoming a good statistician/data scientist/machine learning expert/neural network practitioner. There is simply no substitute.

You have to check that your code is free of bugs before you can tune network performance! Otherwise, you might as well be re-arranging deck chairs on the RMS Titanic.

There are two features of neural networks that make verification even more important than for other types of machine learning or statistical models.

1. Neural networks are not «off-the-shelf» algorithms in the way that random forest or logistic regression are. Even for simple, feed-forward networks, the onus is largely on the user to make numerous decisions about how the network is configured, connected, initialized and optimized. This means writing code, and writing code means debugging.

2. Even when a neural network code executes without raising an exception, the network can still have bugs! These bugs might even be the insidious kind for which the network will train, but get stuck at a sub-optimal solution, or the resulting network does not have the desired architecture. (This is an example of the difference between a syntactic and semantic error.)

This Medium post, «How to unit test machine learning code,» by Chase Roberts discusses unit-testing for machine learning models in more detail. I borrowed this example of buggy code from the article:

def make_convnet(input_image):
    net = slim.conv2d(input_image, 32, [11, 11], scope="conv1_11x11")
    net = slim.conv2d(input_image, 64, [5, 5], scope="conv2_5x5")
    net = slim.max_pool2d(net, [4, 4], stride=4, scope='pool1')
    net = slim.conv2d(input_image, 64, [5, 5], scope="conv3_5x5")
    net = slim.conv2d(input_image, 128, [3, 3], scope="conv4_3x3")
    net = slim.max_pool2d(net, [2, 2], scope='pool2')
    net = slim.conv2d(input_image, 128, [3, 3], scope="conv5_3x3")
    net = slim.max_pool2d(net, [2, 2], scope='pool3')
    net = slim.conv2d(input_image, 32, [1, 1], scope="conv6_1x1")
    return net

Do you see the error? Many of the different operations are not actually used because previous results are over-written with new variables. Using this block of code in a network will still train and the weights will update and the loss might even decrease — but the code definitely isn’t doing what was intended. (The author is also inconsistent about using single- or double-quotes but that’s purely stylistic.)

The most common programming errors pertaining to neural networks are

• Variables are created but never used (usually because of copy-paste errors);
• Expressions for gradient updates are incorrect;
• Weight updates are not applied;
• Loss functions are not measured on the correct scale (for example, cross-entropy loss can be expressed in terms of probability or logits)
• The loss is not appropriate for the task (for example, using categorical cross-entropy loss for a regression task).
• Dropout is used during testing, instead of only being used for training.
• Make sure you’re minimizing the loss function $L(x)$, instead of minimizing $-L(x)$.
• Make sure your loss is computed correctly.

Unit testing is not just limited to the neural network itself. You need to test all of the steps that produce or transform data and feed into the network. Some common mistakes here are

• NA or NaN or Inf values in your data creating NA or NaN or Inf values in the output, and therefore in the loss function.
• Shuffling the labels independently from the samples (for instance, creating train/test splits for the labels and samples separately);
• Accidentally assigning the training data as the testing data;
• When using a train/test split, the model references the original, non-split data instead of the training partition or the testing partition.
• Forgetting to scale the testing data;
• Scaling the testing data using the statistics of the test partition instead of the train partition;
• Forgetting to un-scale the predictions (e.g. pixel values are in [0,1] instead of [0, 255]).
• Here’s an example of a question where the problem appears to be one of model configuration or hyperparameter choice, but actually the problem was a subtle bug in how gradients were computed. Is this drop in training accuracy due to a statistical or programming error?

For the love of all that is good, scale your data

The scale of the data can make an enormous difference on training. Sometimes, networks simply won’t reduce the loss if the data isn’t scaled. Other networks will decrease the loss, but only very slowly. Scaling the inputs (and certain times, the targets) can dramatically improve the network’s training.

• Prior to presenting data to a neural network, standardizing the data to have 0 mean and unit variance, or to lie in a small interval like $[-0.5, 0.5]$ can improve training. This amounts to pre-conditioning, and removes the effect that a choice in units has on network weights. For example, length in millimeters and length in kilometers both represent the same concept, but are on different scales. The exact details of how to standardize the data depend on what your data look like.

• Data normalization and standardization in neural networks

  • Why does $[0,1]$ scaling dramatically increase training time for feed forward ANN (1 hidden layer)?

• Batch or Layer normalization can improve network training. Both seek to improve the network by keeping a running mean and standard deviation for neurons’ activations as the network trains. It is not well-understood why this helps training, and remains an active area of research.
  • «Understanding Batch Normalization» by Johan Bjorck, Carla Gomes, Bart Selman
  • «Towards a Theoretical Understanding of Batch Normalization» by Jonas Kohler, Hadi Daneshmand, Aurelien Lucchi, Ming Zhou, Klaus Neymeyr, Thomas Hofmann
  • «How Does Batch Normalization Help Optimization? (No, It Is Not About Internal Covariate Shift)» by Shibani Santurkar, Dimitris Tsipras, Andrew Ilyas, Aleksander Madry

Crawl Before You Walk; Walk Before You Run

Wide and deep neural networks, and neural networks with exotic wiring, are the Hot Thing right now in machine learning. But these networks didn’t spring fully-formed into existence; their designers built up to them from smaller units. First, build a small network with a single hidden layer and verify that it works correctly. Then incrementally add additional model complexity, and verify that each of those works as well.

• Too few neurons in a layer can restrict the representation that the network learns, causing under-fitting. Too many neurons can cause over-fitting because the network will «memorize» the training data.

  Even if you can prove that there is, mathematically, only a small number of neurons necessary to model a problem, it is often the case that having «a few more» neurons makes it easier for the optimizer to find a «good» configuration. (But I don’t think anyone fully understands why this is the case.) I provide an example of this in the context of the XOR problem here: Aren’t my iterations needed to train NN for XOR with MSE < 0.001 too high?.

• Choosing the number of hidden layers lets the network learn an abstraction from the raw data. Deep learning is all the rage these days, and networks with a large number of layers have shown impressive results. But adding too many hidden layers can make risk overfitting or make it very hard to optimize the network.

• Choosing a clever network wiring can do a lot of the work for you. Is your data source amenable to specialized network architectures? Convolutional neural networks can achieve impressive results on «structured» data sources, image or audio data. Recurrent neural networks can do well on sequential data types, such as natural language or time series data. Residual connections can improve deep feed-forward networks.

Neural Network Training Is Like Lock Picking

To achieve state of the art, or even merely good, results, you have to set up all of the parts configured to work well together. Setting up a neural network configuration that actually learns is a lot like picking a lock: all of the pieces have to be lined up just right. Just as it is not sufficient to have a single tumbler in the right place, neither is it sufficient to have only the architecture, or only the optimizer, set up correctly.

Tuning configuration choices is not really as simple as saying that one kind of configuration choice (e.g. learning rate) is more or less important than another (e.g. number of units), since all of these choices interact with all of the other choices, so one choice can do well in combination with another choice made elsewhere.

This is a non-exhaustive list of the configuration options which are not also regularization options or numerical optimization options.

All of these topics are active areas of research.

• The network initialization is often overlooked as a source of neural network bugs. Initialization over too-large an interval can set initial weights too large, meaning that single neurons have an outsize influence over the network behavior.

• The key difference between a neural network and a regression model is that a neural network is a composition of many nonlinear functions, called activation functions. (See: What is the essential difference between neural network and linear regression)

  Classical neural network results focused on sigmoidal activation functions (logistic or $tanh$ functions). A recent result has found that ReLU (or similar) units tend to work better because the have steeper gradients, so updates can be applied quickly. (See: Why do we use ReLU in neural networks and how do we use it?) One caution about ReLUs is the «dead neuron» phenomenon, which can stymie learning; leaky relus and similar variants avoid this problem. See

• Why can’t a single ReLU learn a ReLU?

• My ReLU network fails to launch

There are a number of other options. See: Comprehensive list of activation functions in neural networks with pros/cons

• Residual connections are a neat development that can make it easier to train neural networks. «Deep Residual Learning for Image Recognition»
  Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun In: CVPR. (2016). Additionally, changing the order of operations within the residual block can further improve the resulting network. «Identity Mappings in Deep Residual Networks» by Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun.

Non-convex optimization is hard

The objective function of a neural network is only convex when there are no hidden units, all activations are linear, and the design matrix is full-rank — because this configuration is identically an ordinary regression problem.

In all other cases, the optimization problem is non-convex, and non-convex optimization is hard. The challenges of training neural networks are well-known (see: Why is it hard to train deep neural networks?). Additionally, neural networks have a very large number of parameters, which restricts us to solely first-order methods (see: Why is Newton’s method not widely used in machine learning?). This is a very active area of research.

• Setting the learning rate too large will cause the optimization to diverge, because you will leap from one side of the «canyon» to the other. Setting this too small will prevent you from making any real progress, and possibly allow the noise inherent in SGD to overwhelm your gradient estimates. See:

  • How can change in cost function be positive?

• Gradient clipping re-scales the norm of the gradient if it’s above some threshold. I used to think that this was a set-and-forget parameter, typically at 1.0, but I found that I could make an LSTM language model dramatically better by setting it to 0.25. I don’t know why that is.

• Learning rate scheduling can decrease the learning rate over the course of training. In my experience, trying to use scheduling is a lot like regex: it replaces one problem («How do I get learning to continue after a certain epoch?») with two problems («How do I get learning to continue after a certain epoch?» and «How do I choose a good schedule?»). Other people insist that scheduling is essential. I’ll let you decide.

• Choosing a good minibatch size can influence the learning process indirectly, since a larger mini-batch will tend to have a smaller variance (law-of-large-numbers) than a smaller mini-batch. You want the mini-batch to be large enough to be informative about the direction of the gradient, but small enough that SGD can regularize your network.

• There are a number of variants on stochastic gradient descent which use momentum, adaptive learning rates, Nesterov updates and so on to improve upon vanilla SGD. Designing a better optimizer is very much an active area of research. Some examples:

  • No change in accuracy using Adam Optimizer when SGD works fine
  • How does the Adam method of stochastic gradient descent work?
  • Why does momentum escape from a saddle point in this famous image?

• When it first came out, the Adam optimizer generated a lot of interest. But some recent research has found that SGD with momentum can out-perform adaptive gradient methods for neural networks. «The Marginal Value of Adaptive Gradient Methods in Machine Learning» by Ashia C. Wilson, Rebecca Roelofs, Mitchell Stern, Nathan Srebro, Benjamin Recht

• But on the other hand, this very recent paper proposes a new adaptive learning-rate optimizer which supposedly closes the gap between adaptive-rate methods and SGD with momentum. «Closing the Generalization Gap of Adaptive Gradient Methods in Training Deep Neural Networks» by Jinghui Chen, Quanquan Gu

  Adaptive gradient methods, which adopt historical gradient information to automatically adjust the learning rate, have been observed to generalize worse than stochastic gradient descent (SGD) with momentum in training deep neural networks. This leaves how to close the generalization gap of adaptive gradient methods an open problem. In this work, we show that adaptive gradient methods such as Adam, Amsgrad, are sometimes «over adapted». We design a new algorithm, called Partially adaptive momentum estimation method (Padam), which unifies the Adam/Amsgrad with SGD to achieve the best from both worlds. Experiments on standard benchmarks show that Padam can maintain fast convergence rate as Adam/Amsgrad while generalizing as well as SGD in training deep neural networks. These results would suggest practitioners pick up adaptive gradient methods once again for faster training of deep neural networks.

• Specifically for triplet-loss models, there are a number of tricks which can improve training time and generalization. See: In training a triplet network, I first have a solid drop in loss, but eventually the loss slowly but consistently increases. What could cause this?

Regularization

Choosing and tuning network regularization is a key part of building a model that generalizes well (that is, a model that is not overfit to the training data). However, at the time that your network is struggling to decrease the loss on the training data — when the network is not learning — regularization can obscure what the problem is.

When my network doesn’t learn, I turn off all regularization and verify that the non-regularized network works correctly. Then I add each regularization piece back, and verify that each of those works along the way.

This tactic can pinpoint where some regularization might be poorly set. Some examples are

• $L^2$ regularization (aka weight decay) or $L^1$ regularization is set too large, so the weights can’t move.

• Two parts of regularization are in conflict. For example, it’s widely observed that layer normalization and dropout are difficult to use together. Since either on its own is very useful, understanding how to use both is an active area of research.

  • «Understanding the Disharmony between Dropout and Batch Normalization by Variance Shift» by Xiang Li, Shuo Chen, Xiaolin Hu, Jian Yang
  • «Adjusting for Dropout Variance in Batch Normalization and Weight Initialization» by Dan Hendrycks, Kevin Gimpel.
  • «Self-Normalizing Neural Networks» by Günter Klambauer, Thomas Unterthiner, Andreas Mayr and Sepp Hochreiter

Keep a Logbook of Experiments

When I set up a neural network, I don’t hard-code any parameter settings. Instead, I do that in a configuration file (e.g., JSON) that is read and used to populate network configuration details at runtime. I keep all of these configuration files. If I make any parameter modification, I make a new configuration file. Finally, I append as comments all of the per-epoch losses for training and validation.

The reason that I’m so obsessive about retaining old results is that this makes it very easy to go back and review previous experiments. It also hedges against mistakenly repeating the same dead-end experiment. Psychologically, it also lets you look back and observe «Well, the project might not be where I want it to be today, but I am making progress compared to where I was $k$ weeks ago.»

As an example, I wanted to learn about LSTM language models, so I decided to make a Twitter bot that writes new tweets in response to other Twitter users. I worked on this in my free time, between grad school and my job. It took about a year, and I iterated over about 150 different models before getting to a model that did what I wanted: generate new English-language text that (sort of) makes sense. (One key sticking point, and part of the reason that it took so many attempts, is that it was not sufficient to simply get a low out-of-sample loss, since early low-loss models had managed to memorize the training data, so it was just reproducing germane blocks of text verbatim in reply to prompts — it took some tweaking to make the model more spontaneous and still have low loss.)

Verify that your code is bug free

There’s a saying among writers that «All writing is re-writing» — that is, the greater part of writing is revising. For programmers (or at least data scientists) the expression could be re-phrased as «All coding is debugging.»

Any time you’re writing code, you need to verify that it works as intended. The best method I’ve ever found for verifying correctness is to break your code into small segments, and verify that each segment works. This can be done by comparing the segment output to what you know to be the correct answer. This is called unit testing. Writing good unit tests is a key piece of becoming a good statistician/data scientist/machine learning expert/neural network practitioner. There is simply no substitute.

You have to check that your code is free of bugs before you can tune network performance! Otherwise, you might as well be re-arranging deck chairs on the RMS Titanic.

There are two features of neural networks that make verification even more important than for other types of machine learning or statistical models.

1. Neural networks are not «off-the-shelf» algorithms in the way that random forest or logistic regression are. Even for simple, feed-forward networks, the onus is largely on the user to make numerous decisions about how the network is configured, connected, initialized and optimized. This means writing code, and writing code means debugging.

2. Even when a neural network code executes without raising an exception, the network can still have bugs! These bugs might even be the insidious kind for which the network will train, but get stuck at a sub-optimal solution, or the resulting network does not have the desired architecture. (This is an example of the difference between a syntactic and semantic error.)

This Medium post, «How to unit test machine learning code,» by Chase Roberts discusses unit-testing for machine learning models in more detail. I borrowed this example of buggy code from the article:

def make_convnet(input_image):
    net = slim.conv2d(input_image, 32, [11, 11], scope="conv1_11x11")
    net = slim.conv2d(input_image, 64, [5, 5], scope="conv2_5x5")
    net = slim.max_pool2d(net, [4, 4], stride=4, scope='pool1')
    net = slim.conv2d(input_image, 64, [5, 5], scope="conv3_5x5")
    net = slim.conv2d(input_image, 128, [3, 3], scope="conv4_3x3")
    net = slim.max_pool2d(net, [2, 2], scope='pool2')
    net = slim.conv2d(input_image, 128, [3, 3], scope="conv5_3x3")
    net = slim.max_pool2d(net, [2, 2], scope='pool3')
    net = slim.conv2d(input_image, 32, [1, 1], scope="conv6_1x1")
    return net

Do you see the error? Many of the different operations are not actually used because previous results are over-written with new variables. Using this block of code in a network will still train and the weights will update and the loss might even decrease — but the code definitely isn’t doing what was intended. (The author is also inconsistent about using single- or double-quotes but that’s purely stylistic.)

The most common programming errors pertaining to neural networks are

• Variables are created but never used (usually because of copy-paste errors);
• Expressions for gradient updates are incorrect;
• Weight updates are not applied;
• Loss functions are not measured on the correct scale (for example, cross-entropy loss can be expressed in terms of probability or logits)
• The loss is not appropriate for the task (for example, using categorical cross-entropy loss for a regression task).
• Dropout is used during testing, instead of only being used for training.
• Make sure you’re minimizing the loss function $L(x)$, instead of minimizing $-L(x)$.
• Make sure your loss is computed correctly.

Unit testing is not just limited to the neural network itself. You need to test all of the steps that produce or transform data and feed into the network. Some common mistakes here are

• NA or NaN or Inf values in your data creating NA or NaN or Inf values in the output, and therefore in the loss function.
• Shuffling the labels independently from the samples (for instance, creating train/test splits for the labels and samples separately);
• Accidentally assigning the training data as the testing data;
• When using a train/test split, the model references the original, non-split data instead of the training partition or the testing partition.
• Forgetting to scale the testing data;
• Scaling the testing data using the statistics of the test partition instead of the train partition;
• Forgetting to un-scale the predictions (e.g. pixel values are in [0,1] instead of [0, 255]).
• Here’s an example of a question where the problem appears to be one of model configuration or hyperparameter choice, but actually the problem was a subtle bug in how gradients were computed. Is this drop in training accuracy due to a statistical or programming error?

For the love of all that is good, scale your data

The scale of the data can make an enormous difference on training. Sometimes, networks simply won’t reduce the loss if the data isn’t scaled. Other networks will decrease the loss, but only very slowly. Scaling the inputs (and certain times, the targets) can dramatically improve the network’s training.

• Prior to presenting data to a neural network, standardizing the data to have 0 mean and unit variance, or to lie in a small interval like $[-0.5, 0.5]$ can improve training. This amounts to pre-conditioning, and removes the effect that a choice in units has on network weights. For example, length in millimeters and length in kilometers both represent the same concept, but are on different scales. The exact details of how to standardize the data depend on what your data look like.

• Data normalization and standardization in neural networks

  • Why does $[0,1]$ scaling dramatically increase training time for feed forward ANN (1 hidden layer)?

• Batch or Layer normalization can improve network training. Both seek to improve the network by keeping a running mean and standard deviation for neurons’ activations as the network trains. It is not well-understood why this helps training, and remains an active area of research.
  • «Understanding Batch Normalization» by Johan Bjorck, Carla Gomes, Bart Selman
  • «Towards a Theoretical Understanding of Batch Normalization» by Jonas Kohler, Hadi Daneshmand, Aurelien Lucchi, Ming Zhou, Klaus Neymeyr, Thomas Hofmann
  • «How Does Batch Normalization Help Optimization? (No, It Is Not About Internal Covariate Shift)» by Shibani Santurkar, Dimitris Tsipras, Andrew Ilyas, Aleksander Madry

Crawl Before You Walk; Walk Before You Run

Wide and deep neural networks, and neural networks with exotic wiring, are the Hot Thing right now in machine learning. But these networks didn’t spring fully-formed into existence; their designers built up to them from smaller units. First, build a small network with a single hidden layer and verify that it works correctly. Then incrementally add additional model complexity, and verify that each of those works as well.

• Too few neurons in a layer can restrict the representation that the network learns, causing under-fitting. Too many neurons can cause over-fitting because the network will «memorize» the training data.

  Even if you can prove that there is, mathematically, only a small number of neurons necessary to model a problem, it is often the case that having «a few more» neurons makes it easier for the optimizer to find a «good» configuration. (But I don’t think anyone fully understands why this is the case.) I provide an example of this in the context of the XOR problem here: Aren’t my iterations needed to train NN for XOR with MSE < 0.001 too high?.

• Choosing the number of hidden layers lets the network learn an abstraction from the raw data. Deep learning is all the rage these days, and networks with a large number of layers have shown impressive results. But adding too many hidden layers can make risk overfitting or make it very hard to optimize the network.

• Choosing a clever network wiring can do a lot of the work for you. Is your data source amenable to specialized network architectures? Convolutional neural networks can achieve impressive results on «structured» data sources, image or audio data. Recurrent neural networks can do well on sequential data types, such as natural language or time series data. Residual connections can improve deep feed-forward networks.

Neural Network Training Is Like Lock Picking

To achieve state of the art, or even merely good, results, you have to set up all of the parts configured to work well together. Setting up a neural network configuration that actually learns is a lot like picking a lock: all of the pieces have to be lined up just right. Just as it is not sufficient to have a single tumbler in the right place, neither is it sufficient to have only the architecture, or only the optimizer, set up correctly.

Tuning configuration choices is not really as simple as saying that one kind of configuration choice (e.g. learning rate) is more or less important than another (e.g. number of units), since all of these choices interact with all of the other choices, so one choice can do well in combination with another choice made elsewhere.

This is a non-exhaustive list of the configuration options which are not also regularization options or numerical optimization options.

All of these topics are active areas of research.

• The network initialization is often overlooked as a source of neural network bugs. Initialization over too-large an interval can set initial weights too large, meaning that single neurons have an outsize influence over the network behavior.

• The key difference between a neural network and a regression model is that a neural network is a composition of many nonlinear functions, called activation functions. (See: What is the essential difference between neural network and linear regression)

  Classical neural network results focused on sigmoidal activation functions (logistic or $tanh$ functions). A recent result has found that ReLU (or similar) units tend to work better because the have steeper gradients, so updates can be applied quickly. (See: Why do we use ReLU in neural networks and how do we use it?) One caution about ReLUs is the «dead neuron» phenomenon, which can stymie learning; leaky relus and similar variants avoid this problem. See

• Why can’t a single ReLU learn a ReLU?

• My ReLU network fails to launch

There are a number of other options. See: Comprehensive list of activation functions in neural networks with pros/cons

• Residual connections are a neat development that can make it easier to train neural networks. «Deep Residual Learning for Image Recognition»
  Kaiming He, Xiangyu Zhang, Shaoqing Ren, Jian Sun In: CVPR. (2016). Additionally, changing the order of operations within the residual block can further improve the resulting network. «Identity Mappings in Deep Residual Networks» by Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun.

Non-convex optimization is hard

The objective function of a neural network is only convex when there are no hidden units, all activations are linear, and the design matrix is full-rank — because this configuration is identically an ordinary regression problem.

In all other cases, the optimization problem is non-convex, and non-convex optimization is hard. The challenges of training neural networks are well-known (see: Why is it hard to train deep neural networks?). Additionally, neural networks have a very large number of parameters, which restricts us to solely first-order methods (see: Why is Newton’s method not widely used in machine learning?). This is a very active area of research.

• Setting the learning rate too large will cause the optimization to diverge, because you will leap from one side of the «canyon» to the other. Setting this too small will prevent you from making any real progress, and possibly allow the noise inherent in SGD to overwhelm your gradient estimates. See:

  • How can change in cost function be positive?

• Gradient clipping re-scales the norm of the gradient if it’s above some threshold. I used to think that this was a set-and-forget parameter, typically at 1.0, but I found that I could make an LSTM language model dramatically better by setting it to 0.25. I don’t know why that is.

• Learning rate scheduling can decrease the learning rate over the course of training. In my experience, trying to use scheduling is a lot like regex: it replaces one problem («How do I get learning to continue after a certain epoch?») with two problems («How do I get learning to continue after a certain epoch?» and «How do I choose a good schedule?»). Other people insist that scheduling is essential. I’ll let you decide.

• Choosing a good minibatch size can influence the learning process indirectly, since a larger mini-batch will tend to have a smaller variance (law-of-large-numbers) than a smaller mini-batch. You want the mini-batch to be large enough to be informative about the direction of the gradient, but small enough that SGD can regularize your network.

• There are a number of variants on stochastic gradient descent which use momentum, adaptive learning rates, Nesterov updates and so on to improve upon vanilla SGD. Designing a better optimizer is very much an active area of research. Some examples:

  • No change in accuracy using Adam Optimizer when SGD works fine
  • How does the Adam method of stochastic gradient descent work?
  • Why does momentum escape from a saddle point in this famous image?

• When it first came out, the Adam optimizer generated a lot of interest. But some recent research has found that SGD with momentum can out-perform adaptive gradient methods for neural networks. «The Marginal Value of Adaptive Gradient Methods in Machine Learning» by Ashia C. Wilson, Rebecca Roelofs, Mitchell Stern, Nathan Srebro, Benjamin Recht

• But on the other hand, this very recent paper proposes a new adaptive learning-rate optimizer which supposedly closes the gap between adaptive-rate methods and SGD with momentum. «Closing the Generalization Gap of Adaptive Gradient Methods in Training Deep Neural Networks» by Jinghui Chen, Quanquan Gu

  Adaptive gradient methods, which adopt historical gradient information to automatically adjust the learning rate, have been observed to generalize worse than stochastic gradient descent (SGD) with momentum in training deep neural networks. This leaves how to close the generalization gap of adaptive gradient methods an open problem. In this work, we show that adaptive gradient methods such as Adam, Amsgrad, are sometimes «over adapted». We design a new algorithm, called Partially adaptive momentum estimation method (Padam), which unifies the Adam/Amsgrad with SGD to achieve the best from both worlds. Experiments on standard benchmarks show that Padam can maintain fast convergence rate as Adam/Amsgrad while generalizing as well as SGD in training deep neural networks. These results would suggest practitioners pick up adaptive gradient methods once again for faster training of deep neural networks.

• Specifically for triplet-loss models, there are a number of tricks which can improve training time and generalization. See: In training a triplet network, I first have a solid drop in loss, but eventually the loss slowly but consistently increases. What could cause this?

Regularization

Choosing and tuning network regularization is a key part of building a model that generalizes well (that is, a model that is not overfit to the training data). However, at the time that your network is struggling to decrease the loss on the training data — when the network is not learning — regularization can obscure what the problem is.

When my network doesn’t learn, I turn off all regularization and verify that the non-regularized network works correctly. Then I add each regularization piece back, and verify that each of those works along the way.

This tactic can pinpoint where some regularization might be poorly set. Some examples are

• $L^2$ regularization (aka weight decay) or $L^1$ regularization is set too large, so the weights can’t move.

• Two parts of regularization are in conflict. For example, it’s widely observed that layer normalization and dropout are difficult to use together. Since either on its own is very useful, understanding how to use both is an active area of research.

  • «Understanding the Disharmony between Dropout and Batch Normalization by Variance Shift» by Xiang Li, Shuo Chen, Xiaolin Hu, Jian Yang
  • «Adjusting for Dropout Variance in Batch Normalization and Weight Initialization» by Dan Hendrycks, Kevin Gimpel.
  • «Self-Normalizing Neural Networks» by Günter Klambauer, Thomas Unterthiner, Andreas Mayr and Sepp Hochreiter

Keep a Logbook of Experiments

When I set up a neural network, I don’t hard-code any parameter settings. Instead, I do that in a configuration file (e.g., JSON) that is read and used to populate network configuration details at runtime. I keep all of these configuration files. If I make any parameter modification, I make a new configuration file. Finally, I append as comments all of the per-epoch losses for training and validation.

The reason that I’m so obsessive about retaining old results is that this makes it very easy to go back and review previous experiments. It also hedges against mistakenly repeating the same dead-end experiment. Psychologically, it also lets you look back and observe «Well, the project might not be where I want it to be today, but I am making progress compared to where I was $k$ weeks ago.»

As an example, I wanted to learn about LSTM language models, so I decided to make a Twitter bot that writes new tweets in response to other Twitter users. I worked on this in my free time, between grad school and my job. It took about a year, and I iterated over about 150 different models before getting to a model that did what I wanted: generate new English-language text that (sort of) makes sense. (One key sticking point, and part of the reason that it took so many attempts, is that it was not sufficient to simply get a low out-of-sample loss, since early low-loss models had managed to memorize the training data, so it was just reproducing germane blocks of text verbatim in reply to prompts — it took some tweaking to make the model more spontaneous and still have low loss.)