Что такое эпохи в нейронных сетях
Перейти к содержимому

Что такое эпохи в нейронных сетях

  • автор:

Эпохи

Одна эпоха — это когда ВЕСЬ набор данных передается вперед и назад через нейронную сеть только ОДИН РАЗ.

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

Почему мы используем более одной эпохи?

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

Одна эпоха приводит к недооценке кривой на графике (ниже).

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

Итак, каковы правильные числа эпох?

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

Размер партии

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

Заметка:Размер партии и количество партий — это две разные вещи.

Но что такое партия?

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

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

Итерации

Чтобы получить итерации, вам просто нужно знать таблицы умножения или иметь калькулятор. ��

Итерации — это количество пакетов, необходимое для завершения одной эпохи.

Заметка:Количество пакетов равно количеству итераций за одну эпоху.

Допустим, у нас есть 2000 учебных примеров, которые мы собираемся использовать.

Мы можем разделить набор данных 2000 примеров на пакеты по 500, тогда для завершения 1 эпохи потребуется 4 итерации.

Где Размер партии равен 500, а число итераций равно 4, для 1 полной эпохи.

Следуй за мной по средний чтобы получить аналогичные сообщения.

Любые комментарии или если у вас есть какие-либо вопросы,напишите это в комментарии.

Хлопай! Поделиться этим! Подписывайтесь на меня !

Рад быть полезным. престижность . ..

Предыдущие истории, которые вы полюбите:

Что такое batch? Эпоха, батч, итерация – в чем различия? Руководство

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

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

Нейронные сети — это программы, которые состоят из множества алгоритмов. Алгоритмы отвечают за распознавание конкретных свойств входных данных. Причем все эти свойства конвертированы в цифровой мир. То есть нейронной сети нельзя просто показать две фотографии и сказать: «Вот это кошка, а вот это собака». Им нужно «объяснить», почему кошка — это кошка, а собака — это собака. Причем не просто «объяснить», а показать на конкретные свойства, которые отличают кошек от собак. Таких свойств может быть сотни и даже тысячи.

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

Что такое batch (батч), эпоха и итерация?

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

Что такое эпоха?

  • размеру и форме тела;
  • форме мордочки;
  • характерной окраске;
  • форме хвоста.
  • форме лап;
  • форме ушей;
  • форме глаз;
  • форме усов на мордочке.

Что такое итерация?

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

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

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

Что такое батч?

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

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

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

Заключение

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

Мы будем очень благодарны

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

Эпоха против итерации при обучении нейронных сетей

Например: если у вас 1000 примеров обучения, а размер вашей партии 500, то для завершения 1 эпохи потребуется 2 итерации.

Термин «batch» неоднозначен: некоторые люди используют его для обозначения всего набора тренировок, а некоторые люди используют его для ссылки на количество примеров обучения в одном переходном/отстающем проходе (как я сделал в этом ответе). Чтобы избежать этой неоднозначности и четко указать, что пакет соответствует количеству примеров обучения в одном переходном/отстающем проходе, можно использовать термин mini-batch.

Поделиться 05 августа 2015 в 21:14

Эпоха и итерация описывают разные вещи.

Эпоха

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

Итерация

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

Пример

Пример может сделать это более понятным.

Предположим, у вас есть набор данных из 10 примеров (или примеров). У вас есть пакет размером 2 и вы указали, что хотите, чтобы алгоритм работал для 3 эпох.

Поэтому в каждой эпохе у вас есть 5 партий (10/2 = 5). Каждая партия проходит через алгоритм, поэтому у вас есть 5 итераций в одну эпоху. Поскольку вы указали 3 эпохи, у вас есть в общей сложности 15 итераций (5*3 = 15) для обучения.

Поделиться 21 июля 2016 в 02:45

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

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

Поделиться 21 января 2011 в 09:17

Чтобы понять разницу между ними, необходимо понять Алгоритм градиентного происхождения и его варианты.

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

Пакет — это полный набор данных. Его размер — это общее количество обучающих примеров в доступном наборе данных.

Размер мини-пакета — это количество примеров, которые алгоритм обучения обрабатывает в одном проходе (вперед и назад).

Мини-пакет — это небольшая часть набора данных заданного размера мини-пакета.

Iterations — это количество партий данных, которые алгоритм видел (или просто количество проходов, которые алгоритм выполнил в наборе данных).

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

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

Стохастический градиентный спуск — это особый случай мини-пакета градиентного спуска, в котором размер мини-пакета равен 1.

Batch gradient descent vs Mini-batch gradient descent

Comparison of batch, stochastic and mini-batch gradient descents.

Поделиться 09 апреля 2019 в 12:52

Я предполагаю, что в контексте термологии нейронной сети:

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

Чтобы определить итерацию (например, шаги), вам сначала нужно знать о размере партии:

  • Размер партии: Вероятно, вам не хотелось бы обрабатывать все учебные экземпляры за один переход, так как это неэффективно и требует огромного количества памяти. Так что обычно делается разделение учебных экземпляров на подмножества (т.е. партии), выполнение одного перехода по выбранному подмножеству (т.е. партии), а затем оптимизация сети с помощью обратной пропаганды.Количество учебных экземпляров внутри подмножества (т.е. партии) называется batch_size.
  • Iteration: (например, шаги обучения) Вы знаете, что ваша сеть должна пройти все учебные экземпляры за один проход, чтобы завершить одну эпоху. Но подождите! когда вы разделяете свои учебные экземпляры на партии, это означает, что вы можете обработать только одну батачю (подмножество учебных экземпляров) за один проход вперед, так что как быть с другими партиями? Вот где вступает в силу термин Итерация:
  • Definition: Количество пропусков переадресации (Количество созданных партий), которое должна сделать ваша сеть, чтобы завершить одну эпоху (т.е. пройти все учебные экземпляры), называется Итерация.

Например, когда у вас есть 10 000 тренировочных экземпляров и вы хотите выполнить батажирование с размером 10; вам нужно сделать 10 000/10 = 1000 итераций, чтобы завершить 1 эпоху.

Надеюсь, это сможет ответить на ваш вопрос!

Поделиться 03 апреля 2020 в 17:28

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

После того, как вы закончите свои мини-пакеты, вы завершаете эпоху. Затем вы снова перемещаете свои тренировочные данные, снова выбираете свои мини-пакеты и перебираете все из них снова. Это будет ваша вторая эпоха.

Поделиться 06 сентября 2016 в 06:51

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

Поделиться 06 января 2012 в 22:41

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

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

Поделиться 26 октября 2012 в 21:46

Я считаю, что итерация эквивалентна одной пакетной переменной forward+backprop в пакетном SGD. Epoch проходит через весь набор данных один раз (как кто-то еще упомянул).

Поделиться 16 июня 2015 в 20:55

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

Поделиться 20 января 2011 в 21:18

  1. Эпоха — это 1 полный цикл, в котором нейронная сеть видела все данные.
  2. Можно было сказать, что 100 000 изображений для обучения модели, однако пространства памяти может быть недостаточно для обработки всех изображений сразу, поэтому мы разделяем обучение модели на меньшие куски данных, называемые партиями. Например, размер партии равен 100.
  3. Нам нужно покрыть все изображения с помощью нескольких партий. Поэтому нам нужно будет 1000 итераций для покрытия всех 100 000 изображений. (100 размер партии * 1000 итераций)
  4. Как только нейронная сеть рассматривает все данные, она называется 1 эпохой (точка 1). Для обучения модели может понадобиться несколько эпох. (допустим, 10 эпох).

Поделиться 23 сентября 2019 в 22:58

Эпоха — это итерация подмножества образцов для обучения, например, алгоритма градиентного спуска в нейронной сети. Хорошая справка: http://neuralnetworksanddeeplearning.com/chap1.html

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

def SGD(self, training_data, epochs, mini_batch_size, eta, test_data=None): """Train the neural network using mini-batch stochastic gradient descent. The "training_data" is a list of tuples "(x, y)" representing the training inputs and the desired outputs. The other non-optional parameters are self-explanatory. If "test_data" is provided then the network will be evaluated against the test data after each epoch, and partial progress printed out. This is useful for tracking progress, but slows things down substantially.""" if test_data: n_test = len(test_data) n = len(training_data) for j in xrange(epochs): random.shuffle(training_data) mini_batches = [ training_data[k:k+mini_batch_size] for k in xrange(0, n, mini_batch_size)] for mini_batch in mini_batches: self.update_mini_batch(mini_batch, eta) if test_data: print "Epoch : / ".format( j, self.evaluate(test_data), n_test) else: print "Epoch complete".format(j) 

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

Поделиться 20 ноября 2015 в 13:18

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

Если вы являетесь учебной моделью для 10 эпох с размером партии 6, учитывая общее количество 12 примеров, это означает:

  1. модель сможет видеть весь набор данных в 2 итерациях ( 12 / 6 = 2) т.е. в одну эпоху.
  2. в целом, модель будет иметь 2 X 10 = 20 итераций (итерации на одну эпоху X отсутствия эпох)
  3. переоценка потерь и параметров модели будет выполняться после каждой итерации!

Поделиться 30 декабря 2020 в 05:43

эпоха

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

итерация

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

Анализ подбора гиперпараметров при обучении нейронной сети прямого распространения — FNN (на примере MNIST)

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

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

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

Общий подход

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

Подготовка данных

Подготовка данных происходит абсолютно стандартно, как и в большинстве роликов и статей по MNIST, поэтому особо не комментируем, просто прикладываем.

import numpy as np import matplotlib.pyplot as plt %matplotlib inline import keras from keras.models import Sequential from keras.layers import Dense, Flatten, Dropout from keras.datasets import mnist from keras.callbacks import ReduceLROnPlateau from keras.callbacks import ModelCheckpoint 

Скачивание и преобразование данных

# Скачиваем данные и сразу распределяем на обучающую и тестовую выборки (x_train, y_train), (x_test, y_test) = mnist.load_data() # Преобразуем данные в интервал [0,1] x_train = x_train / 255 x_test = x_test / 255 y_train_cat = keras.utils.to_categorical(y_train, 10) y_test_cat = keras.utils.to_categorical(y_test, 10)

Проверка корректности данных

# проверяем формы print(x_train.shape, y_train.shape, x_test.shape, y_test.shape) # выводим выбранный вектор данных из обучающей выборки print(x_train[7777]) выводим метку класса print(y_train[7777]) # выводим метку класса в one-hot-codding print(y_train_cat[7777]) # Выводим выбранное изображение plt.imshow(x_train[7777], cmap='binary') plt.axis('off') # без осей plt.show() # Выводим первых 25 изображений из обучающей выборки plt.figure(figsize=(20,10)) for i in range(25): plt.subplot(5,5,i+1) plt.xticks([]) plt.yticks([]) plt.imshow(x_train[i], cmap=plt.cm.binary) plt.show()

Базовая комплектация сети

Берем самый простой стандартный вариант:

FNN: входной слой, один скрытый слой, выходной слой;
на выходе 10 нейронов (потому что 10 цифр = 10 классов);
функции активации — «relu» и «softmax» (стандарт);
функция потерь — «categorical_crossentropy» (стандарт, когда несколько классов);
метрика качества — «accuracy» (стандарт);
оптимизатор — «adam» (стандарт);
размер батча — 32 (надо с чего-то начинать);
размер валидационной выборки — 20% (стандарт).

Запускаем первый раз на 20 эпох и смотрим, что к чему.

model = keras.Sequential([ Flatten(input_shape=(28, 28, 1)), Dense(128, activation='relu'), Dense(10, activation='softmax') ]) model.compile( optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'] ) history = model.fit( x_train, y_train_cat, batch_size=32, epochs=20, validation_split=0.2 )
print('train:', model.evaluate(x_train, y_train_cat, verbose = 0)) print('test:', model.evaluate(x_test, y_test_cat, verbose = 0)) print( 'val_loss:', np.argmin(history.history['val_loss']), history.history['val_loss'][np.argmin(history.history['val_loss'])] ) print( 'val_accuracy:', np.argmax(history.history['val_accuracy']), history.history['val_accuracy'][np.argmax(history.history['val_accuracy'])] )

train: [0.023798486217856407, 0.9946833252906799]
test: [0.09774788469076157, 0.9769999980926514]
val_loss: 7 0.08434651792049408
val_accuracy: 18 0.9779166579246521

plt.plot(list(range(1,len(history.history['loss'])+1)),history.history['loss']) plt.plot(list(range(1,len(history.history['val_loss'])+1)),history.history['val_loss']) plt.title("loss and val_loss") plt.grid(True) plt.show()

plt.plot(list(range(1,len(history.history['accuracy'])+1)),history.history['accuracy']) plt.plot(list(range(1,len(history.history['val_accuracy'])+1)),history.history['val_accuracy']) plt.title("accuracy and val_accuracy") plt.grid(True) plt.show()

В первом приближении видим, что все «как по учебнику»:

ошибка на обучающей выборке уменьшается;
ошибка на валидационной выборке сначала уменьшается, потом увеличивается — переобучение;
точность на обучающей выборке подходит вплотную к 1.0;
точность на валидационной выборке доходит до 0.978;
точность на тестовой выборке 0.977.

Отсюда начинаем перебирать параметры.

128 нейронов в скрытом слое, батчи 16-32-64-128

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

Объединим графики для наглядности:

Видно, что точность валидационной выборки идет очень похоже и практически одинаково.

Точность на тестовой выборке у всеx очень близкая,
находится в интервале 0.9769-0.9789, разница в десятые и сотые доли процента.

batch16: 0.9771999716758728
batch32: 0.978600025177002
batch64: 0.9789000153541565
batch128: 0.9768999814987183

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

256 нейронов в скрытом слое, батчи 16-32-64-128

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

Точность на тестовой выборке также очень близко,
находится в интервале 0.9795-0.9810,
и это интервально чуть лучше, чем 0.9769-0.9789 (на 128) .

batch16: 0.9794999957084656
batch32: 0.9801999926567078
batch64: 0.9785000085830688
batch128: 0.9810000061988831

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

512 нейронов в скрытом слое, батчи 16-32-64-128

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

Точность на тестовой выборке также очень близко,
находится в интервале 0.9783-0.9824
и это интервально чуть лучше, чем 0.9795-0.9810 (256) и 0.9769-0.9789 (128).

batch16: 0.9789000153541565
batch32: 0.9782999753952026
batch64: 0.9815000295639038
batch128: 0.9824000000953674

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

1024 нейрона в скрытом слое, батчи 16-32-64-128

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

Точность на тестовой выборке также очень близко,
находится в интервале 0.9806-0.9841, и это интервально чуть лучше, чем при 128, 256 и 512 нейронах.

batch16: 0.9805999994277954
batch32: 0.9811999797821045
batch64: 0.982200026512146
batch128: 0.9840999841690063

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

Необходимо отметить некоторое интервальное улучшение точности в целом при увеличении количества нейронов :

128: 0.9769-0.9789
256: 0.9795-0.9810
512: 0.9783-0.9824
1024: 0.9806-0.9841.

Объединяем полученные данные

Ошибка (‘loss’) на тестовой выборке:

Точность (‘accuracy’) на тестовой выборке:

Предварительные выводы по количествам нейронов скрытого слоя и размерам батчей

Предварительные выводы следующие:

  1. С увеличением размера батча линии валидационной выборки становятся плавнее.
  2. С увеличением размера батча ошибка валидационной выборки задирается вверх меньше, прогиб смещается правее, то есть переобучение уменьшается.
  3. С увеличением количества нейронов скрытого слоя ошибка валидационной выборки задирается вверх резче, прогиб смещается левее, то есть переобучение увеличивается.
  4. С увеличением размера батча ошибка тестовой выборки в целом уменьшается.
  5. В отношении точности тестовой выборки с увеличением размера батча неочевидно, в конечном итоге зависит от переобученности и количества нейронов. Предположительно, возможно подобрать такое соотношение количества нейронов и размера батча, что точность будет выше.
  6. С увеличением количества нейронов скрытого слоя ошибка тестовой выборки сначала падает, а потом или продолжает падать или начинает расти — переобучение. При этом чем меньше размер батча, тем выше уходит ошибка, и чем больше размер батча, тем меньше ошибка и может продолжать снижаться. То есть при увеличении количества нейронов ошибка может уменьшаться при соответствующем подборе размере батча.
  7. С увеличением количества нейронов скрытого слоя точность тестовой выборки в целом увеличивается, и это зависит от переобученности и размера батча.
  8. Самые лучшие результаты в данном примере наблюдаются при максимальном количестве признаков (1024) по мере увеличения размера батча.

Берем сразу большой батч (batch1024)

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

Можно сказать, что все ожидаемо:
1. линии гладкие;
2. ошибка валидационной выборки постепенно снижается;
3. линии ошибки идут ровненько одна за другой — чем больше батч, тем ниже линия:
4. линии точности также идут ровненько одна за другой — чем больше батч, тем выше линия

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

Также видно, что здесь уже не хватает эпох и оптимум может быть где-то правее.

И действительно, примерно за 40 эпох точность стабилизируется.

Таким образом становится понятен общий подход к подбору гиперпараметров:
1. увеличивать количество нейронов скрытого слоя;
2. под новое количество нейронов скрытого слоя подстраивать размер батча, чтобы сдвигать переобучение на более поздний срок;
3. увеличивать количество эпох
4. отслеживать, когда происходит переобучение.

Альтернативный вариант — представить нейросеть, осуществляющую распознавание и классификацию, как функцию от соответствующих гиперпараметров, и надстроить отдельную «управляющую» нейронную сеть, определяющую оптимум данной функции стандартным для нейросети способом. Подбор гиперпарметров с помощью «управляющей» нейросети — тема для отдельной статьи.

Добавляем уменьшение шага

Запустим обучение с batch128 сразу на 100 эпох,
количество нейронов в скрытом слое: 128-512-2048-8192.

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

сheckpoint = ModelCheckpoint('mnist-fnn.h5', monitor='val_acc', save_best_only=True, verbose=1)

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

reduce_on_plateau = ReduceLROnPlateau(monitor='val_accuracy', patience=3, verbose=1, factor=0.5, min_lr=0.0000001 )

Из нескольких тестируемых комбинаций лучшая точность была 0.9869 (8192 признака, уменьшение шага в два разе, если в течение 3 эпох точность не увеличивается, ограничение на минимальный шаг обучение e-07).

Добавляем Dropout

20 эпох 1024 нейрона давали следующие значения точности :
batch16: 0.9806
batch32: 0.9812
batch64: 0.9822
batch128: 0.9841

100 эпох batch128 с уменьшением шага обучения давали следующие значения точности :
128 нейронов: 0.9787
512 нейронов: 0.9822
2048 нейронов: 0.9849
8192 нейронов: 0.9869

С применением Dropout (0.1-0.2-0.3-0.4-0.5) 100 эпох, 1024 признака, batch128, без уменьшения шага — точность 0.9854 на Dropout 0.5.

За несколько итераций точность повысилась до 0.9860
(4096 нейронов, batch512, Dropout 0.8, уменьшение шага в 2 раза, если 3 эпохи точность не поднимается).

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

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

Выводы

Выводы получились интересные.

1. Сеть мгновенно доходит до точности 97,7-97.8%, и такая точность достигается «легко и сразу».

2. Следующий 1% точности (до 98.7%) достигается уже с трудом, нужно подбирать.

3. Забегая вперед, можно сказать, что CNN дают точность выше 99.5%, но этот «крайний» процент (выше 99%) достигается уже с очень большим трудом.

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

Касательно общего алгоритма подбора краткий вывод получился такой:
Для лучшего результата точности целесообразно брать количество нейронов «побольше» (насколько позволяют вычислительные мощности и время) и следить, чтобы сеть не переобучалась. Для контроля переобучения подбирать размер батча и dropout, а для окончательного «шлифования» подбирать схему уменьшения шага обучения.

Что дальше

Вариантом развития представляется тестирование FNN в несколько слоев, а также тестирование CNN в несколько слоев с разными размерами ядер.

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

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

  • machine learning
  • python
  • mnist
  • программирование
  • машинное обучени
  • сезон machine learning
  • нейронные сети
  • искусственный интеллект
  • Python
  • Программирование
  • Машинное обучение
  • Искусственный интеллект

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

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