Нейросети ошибка увеличивается

Реализовал свою нейронную сеть и решил проверить ее работоспособность.

Структура нейронной сети: 3 входных нейрона, скрытый слой с 2 нейронами и 2 выходных нейрона.

Обучающая выборка:

double_t** trainSet = new double_t * [] {
    new double_t[]{ 0, 0, 0 },
    new double_t[]{ 0, 1, 0 },
    new double_t[]{ 1, 0, 0 },
    new double_t[]{ 1, 1, 0 },
    new double_t[]{ 0, 0, 1 },
    new double_t[]{ 0, 1, 1 },
    new double_t[]{ 1, 0, 1 },
    new double_t[]{ 1, 1, 1 },
    new double_t[]{ 0, 0, 2 },
    new double_t[]{ 0, 1, 2 },
    new double_t[]{ 1, 0, 2 },
    new double_t[]{ 1, 1, 2 }
};

Первый и второй нейрон это значения операндов, а третий нейрон это номер операции 1 — &, 2 — | или 3 — ^ (xor). Эти числа нормализуются в 0, 0.5 и 1 соответственно.

Вот последние результаты работы:

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

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

Дополнено

Ошибка выходного нейрона: error = (ideal - output) * derivative(output)

Ошибка скрытого нейрона: error[i] = derivative(output[i]) * summa(weights[i][i+1] * error[i+1]

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

Ошибка для выбранного сета:

trainError = summa(ideals[i] - output[i]) / countOutputNeurons

Ошибка эпохи: epochError = summa(trainError[i]) / countSets

Ошибка эпохи = сумма ошибок каждого сета разделенного на количество сетов.

Дополнено

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

И получил следующее:

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

Объясните пожалуйста кто разбирается почему так.

При начальной структуре (3 входных, 2 скрытых и 2 выходных), ошибки некоторых сетов например на 50 эпохе < 0.00001, у большинства в районе (0.01, 0.09) и только проклятого двенадцатого сета ошибка растет.

Обновлено

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

Добавил случайное перемешивание сетов каждую эпоху, что вроде ускорило обучение (раньше было в среднем 250+ эпох сейчас 150+).

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

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

Количество просмотров 38K

Сеть обучалась последние 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.

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

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

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

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

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

Искусственная нейронная сеть состоит из трех компонентов:

• Входной слой;
• Скрытые (вычислительные) слои;
• Выходной слой.

Обучение нейросетей происходит в два этапа:

• Прямое распространение ошибки;
• Обратное распространение ошибки.

Во время прямого распространения ошибки делается предсказание ответа. При обратном распространении ошибка между фактическим ответом и предсказанным минимизируется.

Прямое распространение ошибки

Зададим начальные веса случайным образом:

• w1
• w2
• w3

Умножим входные данные на веса для формирования скрытого слоя:

• h1 = (x1 * w1) + (x2 * w1)
• h2 = (x1 * w2) + (x2 * w2)
• h3 = (x1 * w3) + (x2 * w3)

Выходные данные из скрытого слоя передается через нелинейную функцию (функцию активации), для получения выхода сети:

• y_ = fn(h1 , h2, h3)

Обратное распространение

• Суммарная ошибка (total_error) вычисляется как разность между ожидаемым значением «y» (из обучающего набора) и полученным значением «y_» (посчитанное на этапе прямого распространения ошибки), проходящих через функцию потерь (cost function).
• Частная производная ошибки вычисляется по каждому весу (эти частные дифференциалы отражают вклад каждого веса в общую ошибку (total_loss)).
• Затем эти дифференциалы умножаются на число, называемое скорость обучения или learning rate (η).

Полученный результат затем вычитается из соответствующих весов.

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

• w1 = w1 — (η * ∂(err) / ∂(w1))
• w2 = w2 — (η * ∂(err) / ∂(w2))
• w3 = w3 — (η * ∂(err) / ∂(w3))

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

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

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

Частные производные

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

Разберем необходимость частных производных на примере.

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

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

Ошибка нескольких детей может уменьшиться, но общая ошибка все еще увеличивается.

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

Гиперпараметры

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

Скорость обучения (learning rate)

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

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

Функция активации (activation function)

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

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

Функция потери (loss function)

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

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

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

Некоторые известные функции потерь:

• Квадратичная (среднеквадратичное отклонение);
• Кросс-энтропия;
• Экспоненциальная (AdaBoost);
• Расстояние Кульбака — Лейблера или прирост информации.

Cреднеквадратичное отклонение – самая простая фукция потерь и наиболее часто используемая. Она задается следующим образом:

Функция потерь в нейронной сети должна удовлетворять двум условиям:

• Функция потерь должна быть записана как среднее;
• Функция потерь не должна зависеть от каких-либо активационных значений нейронной сети, кроме значений, выдаваемых на выходе.

Глубокие нейронные сети

Глубокое обучение (deep learning) – это класс алгоритмов машинного обучения, которые учатся глубже (более абстрактно) понимать данные. Популярные алгоритмы нейронных сетей глубокого обучения представлены на схеме ниже.

Более формально в deep learning:

• Используется каскад (пайплайн, как последовательно передаваемый поток) из множества обрабатывающих слоев (нелинейных) для извлечения и преобразования признаков;
• Основывается на изучении признаков (представлении информации) в данных без обучения с учителем. Функции более высокого уровня (которые находятся в последних слоях) получаются из функций нижнего уровня (которые находятся в слоях начальных слоях);
• Изучает многоуровневые представления, которые соответствуют разным уровням абстракции; уровни образуют иерархию представления.

Пример

Рассмотрим однослойную нейронную сеть:

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

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

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

Не следует путать с широкой нейронной сетью.

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

Пример:

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

Но

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

Главное — баланс

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

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

Проклятье размерности

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

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

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

Компромисс

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

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

Действительно,

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

Следовательно, как правило, невозможно иметь маленькое смещение и маленькую дисперсию одновременно.

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

1

Странное поведение ошибки в нейросети

13.04.2021, 00:08. Показов 1875. Ответов 2

1
2
3
4
5
6
7
8

public static void FindOutputError(Neuron[] layer, double[] expectedOutputs)
        {
            for (int out_layer = 0; out_layer < layer.Length; out_layer++)
            {
                // Нужно ли тут умножать на производную?
                layer[out_layer].error = expectedOutputs[out_layer] - layer[out_layer].value;
            }
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public static void Backward (Neuron[] outputs, Weight[,] weights, Neuron[] inputs, ActivationType activator, double learningRate, bool bias)
        {
            for (int in_layer = 0; in_layer < inputs.Length; in_layer++)
            {
                for (int out_layer = 0; out_layer < outputs.Length - (bias ? 1 : 0); out_layer++)
                {
                    inputs[in_layer].error += weights[in_layer, out_layer].value * outputs[out_layer].error;
                }
            }
            for (int in_layer = 0; in_layer < weights.GetLength(0); in_layer++)
            {
                for (int out_layer = 0; out_layer < weights.GetLength(1); out_layer++)
                {
                    if (activator == ActivationType.Sigmoid)
                    {
                        weights[in_layer, out_layer].value += 
                        outputs[out_layer].error * SigmoidDx(outputs[out_layer].value) * inputs[in_layer].value * learningRate;
                    }
                    else if (activator == ActivationType.ReLU)
                    {
                        weights[in_layer, out_layer].value += 
                        outputs[out_layer].error * ReLUDx(outputs[out_layer].value) * inputs[in_layer].value * learningRate;
                    }
                }
            }
        }

0

ОРО и корректировка весов в нейросети

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

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

Выясним, как мы будем обновлять матрицы весов.

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

Воспользуемся методом ОРО, пропорционально распределяя ошибку между имеющимися узлами:

Определим ошибку на выходном слое ( e^{О}), как разность между эталонным значением ( t_{i}) и полученным ( o_{i}) на выходе нейросети :

( e^{О}_{i} = t_{i} — o_{i})

Тогда, глядя на рисунок выше, заключим, что ошибка ( e^{О}_{1}) распределяется пропорционально весам ( w_{11}) и ( w_{21}), а ошибка ( e^{О}_{2}) должна распределяться пропорционально весам ( w_{12}) и ( w_{22}).

Запишем эти доли в явном виде:

( e^{O}_{1} = displaystylefrac {w_{11}}{w_{11} + w_{21}}; quad e^{O}_{2} = displaystylefrac {w_{12}}{w_{12} + w_{22}}, )

Итак, на основе отклонения текущего выхода от эталонного, мы будем обновлять весовые коэффициенты во всей нейросети, двигаясь с конца к её началу.

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

Ошибка скрытого слоя

Мы можем воссоединить ошибки, распределенные по связям следующим образом: ошибка на первом скрытом узле ( e^{H}_{1} ) представляет собой сумму ошибок, распределенных по всем связям, исходящим из этого узла в прямом направлении:

( e^{H}_{1} = e^{O}_{1} cdot frac {w_{11}}{w_{11} + w_{21}} + e^{O}_{2} cdot frac {w_{12}}{w_{12} + w_{22}}, )

или как показано на иллюстрации ниже:

Применять данную методику мы будем до тех пор, пока не доберёмся до входного слоя:

Векторизация метода ОРО в нейросети

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

Зададим эталонный вектор ( V_{e}), тогда ошибка ( E_O) на выходном слое ( O) считается самым простым способом:

( E_O = V_{e} — O )

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

( E_H = begin{pmatrix}
frac {w_{11}}{w_{11} + w_{21}} & frac {w_{12}}{w_{12} + w_{22}} \
frac {w_{21}}{w_{21} + w_{11}} & frac {w_{22}}{w_{22} + w_{12}}
end{pmatrix} cdot E_o
)

Здесь ( w_{ij} ) — элементы матрицы ( W_{HO} ), задающей веса для слоёв выходной-скрытый.

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

( E_H = begin{pmatrix}
w_{11} & w_{12} \
w_{21} & w_{22}
end{pmatrix} cdot E_O
)

Итак, ошибка ( E_H ) скрытого вычисляется с учётом ошибки (E_O) выходного слоя и матрицы ( W_{HO} ):

( E_H = W_{HO}^T cdot E_O)

Аналогично, для входного слоя ошибка ( E_I ) будет вычисляться с учётом ошибки (E_H) предыдущего слоя в связи с матрицей ( W_{IH} ), определяющей веса входной-скрытый слоёв:

( E_I = W_{IH}^T cdot E_H)

Обновление весовых коэффициентов

Для обновления весовых коэффициентов мы воспользуемся методом градиентного спуска (подробнее в (1)).

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

( Delta w = — alpha cdot E_k cdot O_k cdot (1 — O_k) cdot O^T_j, )

где
(alpha — ) скорость обучения нейронной сети (alpha in (0,1) ),
(E_k — ) ошибка текущего слоя (вектор столбец),
(O_k — ) текущий слой (вектор-столбец),
(O^T_j — ) предыдущий слой (вектор-столбец).

А обновлённая матрица весов примет вид:

( W^{new} = W^{cur} — Delta w )

Осталось лишь собрать всё в программный код обучения нейросети 😁

Данная статья создана на основе чудесной книги(1) с реализацией автором приведённых примеров на Scilab.

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

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

Определение

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

В процессе обратного распространения ошибки при прохождении через слои нейронной сети в элементах градиента могут накапливаться большие значения, что будет приводить к сильным изменениям весов. Это в свою очередь может сделать нестабильным алгоритм обучения нейронной сети. В таком случае элементы градиента могут переполнить тип данных, в котором они хранятся. Такое явление называется взрывающимся градиентом (англ. 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.

Анализ ошибок в нейронных сетях

  Перевод

  Ссылка на автора

Анализ ошибок — это анализ ошибок. Хе хе! Ты не должен говорить мне это. На самом деле весь анализ ошибок столь же интуитивен. Но люди склонны упускать некоторые моменты в реальных проектах. Мы можем рассматривать это как своего рода переподготовку, которую можно проверить — когда разочарование заставляет нас забыть основы.

С такими богатыми библиотеками, как Pytorch и Tensorflow, большинство алгоритмов машинного обучения теперь доступны прямо из коробки — просто создайте экземпляр объекта и обучите его имеющимся данным. Вы готовы к работе!

Это может работать для тривиальных задач учебника, таких как Чтение цифр MNIST, Мы можем просто поиграть с несколькими конфигурациями и вскоре получить почти 100% точность. Но жизнь не так проста. Все становится все сложнее, когда мы пытаемся работать над «реальными» проблемами.

Разработка модели нейронной сети — это гораздо больше, чем просто создание экземпляра объекта Python. Что мне делать, если я понимаю, что моя модель не так точна, как хотелось бы? Должен ли я добавить слои? Должен ли я обрезать модель? Должен ли я изменить некоторые гиперпараметры? Это где анализ ошибок приходит.

Что такое анализ ошибок

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

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

Распространенные источники ошибок

Мы можем столкнуться с несколькими источниками ошибок. У каждой модели будут свои уникальные ошибки. И нам нужно смотреть на них индивидуально. Но типичные причины:

Неправильно маркированные данные

Большая часть маркировки данных восходит к людям. Мы можем извлекать данные из сети или опросов или из других источников. Основные материалы поступили от людей. И люди подвержены ошибкам. Таким образом, мы должны признать тот факт, что все наши данные по train / dev / test имеют ошибочные записи. Если наша модель хорошо построена и обучена должным образом, то она должна быть в состоянии преодолеть такие ошибки.

Размытая линия разграничения

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

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

Переоснащение или занижение размера

Давайте рассмотрим тривиальный пример, чтобы понять концепцию. Предположим, мы работаем над классификатором изображений, чтобы различать ворону и попугая. Помимо размера, клюва, хвоста, крыльев … очевидным отличием является цвет. Но возможно как-то модель не узнает эту разницу. Таким образом, классифицирует маленькую ворону как попугая.

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

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

Многие другие

Это всего лишь несколько видов источников ошибок. Их может быть гораздо больше, которые можно обнаружить, проанализировав набор ошибок. Давайте не будем «переусердствовать» в нашем понимании, чтобы ограничить наш анализ этими типами ошибок.

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

Набор для глазных яблок

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

Мы не можем оценить каждую запись в тренировочном наборе. Мы также не можем оценить каждую запись в наборе разработчиков Чтобы определить тип ошибок, которые генерирует наша модель, мы разделили набор dev на две части — набор eyeball и blackbox set.

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

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

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

Предвзятость и дисперсия

Работая над анализом ошибок, мы определяем определенный параметр или область проблем; или мы замечаем, что ошибка довольно равномерная. Как мы пойдем отсюда? Я получу больше данных? Это может звучать логично. Но не всегда так. Дополнительные данные не всегда могут помочь — после определенного момента любые другие данные могут быть просто избыточными. Нужна ли мне более богатая модель? Простое обогащение модели может значительно улучшить цифры — путем переоснащения. Это тоже не правильно! Итак, как мы решаем направление?

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

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

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

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

Уменьшение смещения

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

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

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

Увеличить размер модели

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

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

Разрешить больше возможностей

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

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

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

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

Избегайте локального минимума

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

Лучшая сетевая архитектура

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

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

Уменьшение дисперсии

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

Добавить больше данных обучения

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

Добавить регуляризацию

Регуляризация L1 или L2 — это проверенные методы, позволяющие уменьшить проблему переоснащения и, таким образом, избежать высокой дисперсии По сути, они держат каждый параметр ближе к 0. Это означает, что ни один параметр не может учиться слишком много. Если один параметр содержит много информации, модель становится несбалансированной и приводит к переобучению и высокой дисперсии.

Методы регуляризации L1 и L2 помогают предотвратить такие проблемы. Регуляризация L1 быстрее и вычислительно проще. Он генерирует разреженные модели. Естественно, L2 намного точнее, поскольку имеет дело с более мелкими деталями.

Ранняя остановка

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

Уменьшить Особенности

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

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

Уменьшить размер модели

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

Уменьшение размера модели напрямую влияет на это.

Используйте разреженную модель

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

Модельная архитектура

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

Резюме

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

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

Ключевые слова: нейронная сеть, интеллектуальные технологии, анализ многомерных данных.

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

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

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

Построим нейросетевую модель финансовых показателей для предприятия ОАО «Башинформсвязь», которое является одним из крупнейших операторов связи в уральском регионе и в стране. Статистические данные для построения модели взяты поквартально за период с 2006 года по 2013 год [3].

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

Для выявления взаимосвязи между всеми переменными проведен корреляционный анализ. На основе анализа матрицы коэффициентов парной корреляции из модели исключаются такие факторы, как  и .

Для построения нейросетевой модели использовано 6 входных факторов (), 1 выходное значение (), 31 наблюдение. Для получения достоверных результатов необходимо использовать нейросеть, аппроксимирующую исходные данные с максимальной степенью точности. Выбор архитектуры сети для решения конкретной задачи основывается на опыте разработчика. Для получения наилучшей сети проведем ряд экспериментов. Построим в Matlab нейросети с обратным распространением ошибки, т. к. они обладают хорошими обобщающими свойствами. Изменяя число скрытых слоев, число нейронов в слоях, функции активации нейронов выберем сеть с наилучшим значением общей среднеквадратической ошибки.

Создадим двухслойную однонаправленную сеть, предварительно нормализуя исходные значения финансовых показателей. Первый слой состоит из 20 нейронов с функциями активации ‘tansig‘, второй слой содержит 1 нейрон с функцией активации ‘purelin’. Для обучения воспользуемся алгоритмом Левенберга-Маркара (‘trainlm’):

net=newff([-2.146 1.526; -1.140 2.498; -1.498 2.264; -2.591 2.130; -2.177 2.698],

[20 1],{‘tansig’ ‘purelin’});

Обучим созданную сеть, используя функцию train:

net=train(net,INP,OUTP),

где INP — сформированный входной вектор из обучающей выборки, а OUTP — сформированный выходной вектор из обучающей выборки.

Для моделирования нейронной сети воспользуемся функцией sim:

Y = sim(net,X),

где net — сеть, X — вектор входных сигналов, Y — вектор выходных значений сети.

Для оценки качества сети рассчитана общая среднеквадратическая ошибка, значение которой менее 0,05 считается удовлетворительным [4, с. 1575].

Построим 9 нейросетей с одним скрытым слоем, изменяя типы функции активации и число нейронов от 7 до 20. Значения среднеквадратической ошибки этих сетей приведены в табл. 1.

Таблица 1

Значение среднеквадратической ошибки для нейросетей с одним скрытым слоем

На рис. 1 приведен график зависимости среднеквадратической ошибки от количества нейронов в скрытом слое. Отсюда видно, что для нейросетей № 1–6 с увеличением числа нейронов скрытого слоя ошибка уменьшается, а для нейросетей № 7–9, наоборот, увеличивается.

Рис. 1. График зависимости среднеквадратической ошибки от количества нейронов

Построим нейронные сети с двумя скрытыми слоями. В табл. 2 приведены значения среднеквадратических ошибок для нейросетей с двумя скрытыми слоями, количество нейронов на слое изменяется от 2 до 6, используются функции активации Tansig/ Tansig /Purelin и Logsig/ Tansig /Purelin.

Таблица 2

Значение среднеквадратической ошибки для нейросетей с двумя скрытыми слоями

Из рисунка 2 видно, что размер ошибки для сетей с функциями активации Logsig/ Tansig /Purelin ниже, чем для аналогичных сетей с функциями Tansig/ Tansig /Purelin.

Рис. 2. График зависимости размера среднеквадратической ошибки от количества нейронов в скрытых слоях

Анализ полученных данных показал, что наилучшей сетью является сеть с архитектурой 6:20:1 (6 входных нейронов, 20 нейронов на 1 скрытом слое и 1 выходное значение), функциями активации Tansig/Purelin (среднеквадратическая ошибка равна 0,009). На рис. 3 представлены фактические значения финансовых показателей и значения, предоставляемые нейросетевой моделью.

Рис. 3. Динамика чистой прибыли ОАО «Башинформсвязь»

Коэффициент детерминации R², рассчитанный для нейросетевой модели 6:20:1, равен 0,971, что свидетельствует о том, что нейронная сеть достаточно хорошо описывает связь между входными и выходными значениями модели.

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

Литература:

1.         Кравченко М. Л., Грекова Т. И. Моделирование экономических систем с применением нейронных сетей // Вестник Томского государственного университета, 2006. — № 290. — С. 169–172.

2.         Степашина Е. В. Оптимизация финансовых показателей предприятия на основе нейросетевой модели // Информационные системы и технологии, 2014. — № 5. — С. 34–42.

3.         Бухгалтерский баланс и приложения к нему ОАО «Башинформсвязь» [Электронный ресурс]. — URL: http://www.bashtel.ru/buh_ballance.php.

4.         Antipin A. F. A Computer-aided System for Designing Multidimensional Logic Controllers with Variables Representing a Set of Binary Logic Arguments // Automation and Remote Control, 2013. — No 9. — Vol. 74. — P. 1573–1581.