Обучение нейронной сети. Алгоритм обратного распространения ошибки.

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

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

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

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

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

Дельта правило (правило Видроу-Хоффа).

Определим ошибку \delta:

\delta = y_0\medspace-\medspace y

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

Дельта-правило заключается в следующем – изменение величины весового коэффициента должно быть равно:

\Delta w_{jk} = \eta\medspace\delta_k\medspace x_j

Где \eta – норма обучения. Это число мы сами задаем перед началом обучения. x_j – это сигнал, приходящий к элементу k от элемента j. А \delta_k – ошибка элемента k.

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

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

Алгоритм обратного распространения ошибки.

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

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

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

\delta_j = f{\Large{\prime}}(net_j)\medspace\cdot\medspace \sum_{k}{}{\delta_k\medspace w_{jk}}

Функция f(x) – это функция активности элемента. Давайте использовать логистическую функцию, для нее:

f{\Large{\prime}}(net_j) = f(net_j)\medspace (1\medspace-\medspace f(net_j))

Подставляем в предыдущую формулу и получаем величину ошибки:

\delta_j = f(net_j)\medspace (1\medspace-\medspace f(net_j))\medspace \sum_{k}{}{\delta_k\medspace w_{kj}}

В этой формуле:

  • \delta_j – ошибка элемента с индексом j
  • k – индекс, соответствующий слою, который посылает ошибку “обратно”
  • net_j – комбинированный ввод элемента
  • f(net_j) – активность элемента

Наверняка сейчас еще все это кажется не совсем понятным, но не переживайте, при рассмотрении практического примера все встанет на свои места! Собственно, давайте к нему и перейдем.

Обучение нейронной сети, практический пример.

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

Рассмотрим нейронную сеть  и вручную проведем расчеты для прямого и обратного “потоков” в сети.

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

На вход мы должны подать образец, пусть это будет (0.2, 0.5). Ожидаемый выход сети – 0.4. Норма обучения пусть будет равна 0.85. Давайте проведем все расчеты поэтапно. Кстати, совсем забыл, в качестве функции активности мы будем использовать логистическую функцию:

f(x) = \frac{1}{1 + e^{-x}}

Итак, приступаем! Вычислим комбинированный ввод элементов 2, 3 и 4:

net_2 = (-1)\cdot 0.2 + 2\cdot0.5 = 0.8
net_3 = 1\cdot 0.2 + 1\cdot 0.5 = 0.7
net_4 = (-2)\cdot 0.5 + 3\cdot 0.2 = -0.4

Активность этих элементов равна:

f(net_2) = 0.69
f(net_3) = 0.67
f(net_4) = 0.40

Комбинированный ввод пятого элемента:

net_5 = 0.69 + 0.67\cdot 2 + 0.4\cdot 4 = 3.63

Активность пятого элемента и в то же время вывод нейронной сети равен:

f(net_5) = 0.974

С прямым “потоком” разобрались, теперь перейдем к обратному “потоку”. Все расчеты будем производить в соответствии с формулами, которые мы уже обсудили. Итак, вычислим ошибку выходного элемента:

\delta_5 = (0.4\medspace-\medspace 0.974)\cdot f(net_5)\cdot (1\medspace-\medspace f(net_5))
\delta_5 = (0.4\medspace-\medspace 0.974)\cdot 0.974\cdot (1\medspace-\medspace 0.974)
\delta_5 = -0.014

Тогда ошибки для элементов 2, 3 и 4 равны соответственно:

\delta_j = \sum_{k}{}{\delta_k\medspace w_{jk}}\medspace f(net_j)\medspace (1\medspace-\medspace f(net_j))
\delta_2 = -0.014\cdot 0.69\medspace (1\medspace-\medspace 0.69) = -0.0029
\delta_3 = -0.028\cdot 0.67\medspace (1\medspace-\medspace 0.67) = -0.0061
\delta_4 = -0.056\cdot 0.40\medspace (1\medspace-\medspace 0.40) = -0.0134

Здесь значения -0.014, -0.028 и -0.056 получаются в результате прохода ошибки выходного элемента -0.014 по взвешенным связям в направлении к элементам 2, 3 и 4 соответственно.

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

\Delta w_{02} = 0.2\cdot (-0.0029)\cdot\medspace0.85

Аналогичным образом производим расчеты и для остальных элементов:

\Delta w_{03} = 0.2\cdot (-0.0061)\cdot\medspace 0.85
\Delta w_{04} = 0.2\cdot (-0.0134)\cdot\medspace 0.85
\Delta w_{12} = 0.5\cdot (-0.0029)\cdot\medspace 0.85
\Delta w_{13} = 0.5\cdot (-0.0061)\cdot\medspace 0.85
\Delta w_{14} = 0.5\cdot (-0.0134)\cdot\medspace 0.85
\Delta w_{25} = 0.69\cdot (-0.014)\cdot\medspace 0.85
\Delta w_{35} = 0.67\cdot (-0.014)\cdot\medspace 0.85
\Delta w_{45} = 0.40\cdot (-0.014)\cdot\medspace 0.85

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

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

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

Пример обучение нейронной сети с несколькими скрытыми слоями.

Итак, добавляем в нашу сеть два новых элемента (X и Y), которые теперь будут выполнять роль входных. На вход также подаем образец (0.2, 0.5). Рассмотрим алгоритм в данном случае:

1. Прямой проход сети. Здесь все точно также как и для сети с одним скрытым слоем. Результатом будет значение f(net_5).

2. Вычисляем ошибку выходного элемента:

\delta_5 = (0.4\medspace-\medspace f(net_5))\medspace f(net_5)\medspace (1\medspace-\medspace f(net_5))

3. Теперь нам нужно вычислить ошибки элементов 2, 3 и 4:

\delta_2 = \delta_5 \cdot 1 \cdot f(net_2) \cdot\medspace (1\medspace-\medspace f(net_2))
\delta_3 = \delta_5 \cdot 2 \cdot f(net_3) \cdot\medspace (1\medspace-\medspace f(net_3))
\delta_4 = \delta_5 \cdot 4 \cdot f(net_4) \cdot\medspace (1\medspace-\medspace f(net_4))

4. Давайте рассчитаем величину корректировки весов связей:

\Delta w_{25} = f(net_2)\cdot \delta_5 \cdot 0.85
\Delta w_{35} = f(net_3) \cdot \delta_5 \cdot 0.85
\Delta w_{45} = f(net_4) \cdot \delta_5 \cdot 0.85

В принципе, пункты 3 и 4 можно поменять местами, поскольку ошибки, рассчитанные на шаге 3 нам не потребовались для расчета величин корректировки весов.

5. Определяем ошибки элементов первого скрытого слоя (0 и 1):

\delta_0 = (\delta_2 \cdot (-1) + \delta_3 \cdot 1 + \delta_4 \cdot 3)\cdot f(net_0) \cdot\medspace (1\medspace-\medspace f(net_0))
\delta_1 = (\delta_2 \cdot 2 + \delta_3 \cdot 1 + \delta_4 \cdot (-2)) \cdot f(net_1) \cdot\medspace (1\medspace-\medspace f(net_1))

Здесь отличие заключается в том, что нам нужно просуммировать ошибки элементов 2, 3 и 4, которые “возвращаются” к элементам 0 и 1, с учетом связей между элементами.

6. Корректируем веса связей:

\Delta w_{02} = f(net_0) \cdot \delta_2 \cdot 0.85
\Delta w_{03} = f(net_0) \cdot \delta_3 \cdot 0.85
\Delta w_{04} = f(net_0) \cdot \delta_4 \cdot 0.85
\Delta w_{12} = f(net_1) \cdot\medspace \delta_2 \cdot 0.85
\Delta w_{13} = f(net_1) \cdot \delta_3 \cdot 0.85
\Delta w_{14} = f(net_1) \cdot \delta_4 \cdot 0.85

Здесь снова величины, рассчитанные на шаге 5 не фигурируют, они нам понадобятся чуть позже, а именно на шаге 7.

7. Определяем величины корректировки оставшихся весов:

\Delta w_{X0} = 0.2 \cdot \delta_0 \cdot 0.85
\Delta w_{X1} = 0.2 \cdot \delta_1 \cdot 0.85
\Delta w_{Y0} = 0.5 \cdot \delta_0 \cdot 0.85
\Delta w_{Y1} = 0.5 \cdot \delta_1 \cdot 0.85

Поскольку элементы X и Y – входные, здесь мы используем значения 0.2 и 0.5, которые соответствуют подаваемому на вход образцу.

8. Собственно, на этом обратный проход завершен! 🙂

На этом сегодня мы закончим, до скорых встреч!

Поделиться!

Подписаться
Уведомление о
guest
81 Комментарий
старее
новее большинство голосов
Inline Feedbacks
View all comments
Alexey
Alexey
5 лет назад

Спасибо! Следим! Ну и ждем интересный пример из собственных задач и программную реализацию на QT 🙂

Nemp
5 лет назад

Теория и математика очень круто 🙂 А как использовать на практике в Embedded? например на STM32 или BeagleBone, Black Raspberry Pi

Nemo
5 лет назад

Очень интересно, напишите примеры где можно использовать ИИ

Лев
Лев
5 лет назад

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

Вадим
Вадим
4 лет назад

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

Евгений
Евгений
4 лет назад

Может я ошибаюсь, но комбинированный ввод элементов 2,3 и 4 рассчитаны в примере как 0.8 , 0.7 и -0.4 соответственно, и при этом их активности указаны как 0.31, 0.33 и 0.60 однако если в функцию активации подставить значения 0.8 , 0.7 и -0.4 то результаты будут 0.69, 0.67 и 0.40 соответственно. Вопрос как появились значения 0.31, 0,33 и 0,60 ?
P.S. Очевидно что 0.31 = 1- 0.69 и т.д

Евгений
Евгений
4 лет назад

по моему та же ошибка осталась для 5-го элемента:
при 3.63 функция активации должна быть 0,974

Koss
Koss
4 лет назад

Статья очень понравилась, единственное не могу до сих пор вкурить что обозначает (вычисляет) данная формула
f'(net_j)=f(net_j)*(1-f(net_j))
Объясните пожалуйста.

антон
антон
4 лет назад

>Здесь значения 0.009, 0.018 и 0.036 получаются в результате прохода ошибки выходного элемента 0.009 по взвешенным связям в направлении к элементам 2, 3 и 4 соответственно.

наверное, имелось ввиду
Здесь значения -0.014, -0.028 и -0.056 получаются в результате прохода ошибки выходного элемента -0.014 по взвешенным связям в направлении к элементам 2, 3 и 4 соответственно.

антон
антон
4 лет назад

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

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

δ5 = (y0-y)*f(net5)(1-f(net5)) [1]

после которой получилось δ5=-0.014

если следовать формуле для вычисления δj по δk
δj=f(net-j)*(1-f(net-j))*Σwk*δk [2]

то для того, чтобы для δ5 получилась формула [1] из формулы [2], нужно взять j=5, k=6: получается, что типа добавляем фиктивный выход 6 с входным нейроном 5 с весом w6=1 и ошибкой δ6=y0-y

другой вариант – просто постулировать формулу [1] для вычисления ошибки выходного слоя

третий вариант – брать ошибку для выходного слоя δ5=(y0-y), как показано в начале статьи, но в таком случае вычисления в статье не верны

антон
антон
Reply to  Aveal
4 лет назад

Написал реализацию сетки с обучением на Java, взял δ5 = (y0-y), все работает, думаю, нюанс не принципиальный, пойдут оба варианта.

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

Пробую учить простому XOR, два входа, два скрытых нейрона, один выход.

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

Павел
Павел
3 лет назад

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

Павел
Павел
Reply to  Aveal
3 лет назад

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

Андрей
Андрей
2 лет назад

А можете пример привести пример для 3-4 слойной сети. Реально корректировка весов за з-слоем вводит в ступор

arand
arand
2 лет назад

5. Определяем ошибки элементов первого скрытого слоя (0 и 1):

Насколько я понял во второй формуле должна быть f(net1)

Александр
Александр
2 лет назад

Добрый день! Спасибо за статью!
Боюсь показаться чайником, но возник интересный вопрос? Подскажите пожалуйста как можно определить выходные условия если они не известны? Есть ли для этого методики? Например для распознавания определенного символа (буквы, цифры) с картинки.

Алексей
Алексей
2 лет назад

Похоже ошибки в формулах с дельта. W_(k, j) – это вес из k в j. А на примерах вы берете как раз-таки все дельты, В КОТОРЫЕ входят стрелочки. Короче говоря, в формулах для дельта должно быть не w(k, j), а w(j, k). Не так ли?

Александр
Александр
2 лет назад

Здравствуйте, правильно ли я понимаю, что если у нас теперь есть новые весовые коэффициенты, то учитывая их , выход сети должен быть равен – 0,4 ? Или мы должны еще по много раз находить новые весовые коэффициенты, до тех пор пока выход сети не станет равным – 0,4 ?

Александр
Александр
Reply to  Aveal
2 лет назад

Ну например, я всегда буду на вход подавать только 0.2 и 0.5 и ждать с выхода сети 0,4. Получается за один проход, не получится 0,4 получить ? Нужно как вы говорите много раз пройти корректировку весов ?

Александр
Александр
2 лет назад

Здравствуйте. Я сделал на Си нейронную сеть, там у меня просто 1 входной элемент, 1 скрытый, 1 выходной. Она находит ожидаемый выход, но не для всех входных значений и не для всех начальных весовых коэффициентов. Правильно ли я понимаю, что начальные весовые коэффициенты должны быть какими то определенными ? И еще вопрос, есть ли смысл от такой маленькой сети которую я сделал или лучше сразу начинать с двумя входами, 2 скрытыми и 1 выходным элементами ?

Александр
Александр
2 лет назад

Спасибо!

Александр
Александр
2 лет назад

Здравствуйте! У вас нет примера того как обучить сеть получать один и тот же выходной сигнал, при разных парах входных значениях? То есть первый раз мы кинули на вход (0.2 и 0.5) получили выход сети — 0.4. Можно ли на вход бросить например (0,3 и 0,8) и получить тоже 0,4 ?

Евгений
Евгений
1 год назад

Добрый день! Спасибо за статью. Но, к Вам есть вопрос! Если истинный выход сети меняется, как поступать? К примеру, у нас имеется таблица XOR и в зависимости от входных X и Y результат операции будет либо нуль, либо единица. Как научить нейросеть угадывать результат XOR? Заранее большое спасибо!

Евгений
Евгений
Reply to  Aveal
1 год назад

Спасибо за быстрый ответ! Я Вам уже успел на эмэйл написать =) Извиняюсь. Не могли бы Вы еще объяснить что значит (вход, вход, выход)? Я прогоняю X и Y (1; 1), (1; 0), (0; 1), (0; 0) вместо Ваших указанных (в статье) 0.2 и 0.5. Что я делаю неверно?

Евгений
Евгений
Reply to  Aveal
1 год назад

Вы также мне поможете, если объясните как можно научить сеть предугадывать функцию y = x ^ 2.

Евгений
Евгений
Reply to  Aveal
1 год назад

Спасибо огромное! Разъяснили. В случае с XOR, выходит что сеть обучится за четыре итерации?

Евгений
Евгений
Reply to  Aveal
1 год назад

Последний вопрос и оставлю Вас в покое. Во время тестирования некоторые веса повышаются аж до 2. Это нормально?

Евгений
Евгений
Reply to  Aveal
1 год назад

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

Евгений
Евгений
Reply to  Aveal
1 год назад

Вечер добрый! Еще один вопрос, вечерний. Так вот, если обучать систему операции XOR, то выходит, что контрольные значения следует подменять вместе с входными (т.е., что контрольные значения, те, которые достоверные, соответствовали входным). Я все правильно понимаю? Но, как тогда понимать, что обучение закончено успешно? Заранее спасибо.

Евгений
Евгений
Reply to  Aveal
1 год назад

Т.е., ничего особенного добавлять в алгоритм не следует? Ведь я использую Ваш пример. Еще раз спасибо

Евгений
Евгений
1 год назад

Добрый вечер! Вы не могли бы помочь или наставить советом? Столкнулся со следующей проблемой. У меня есть нейронная сеть с обратным распространением ошибок. При обучении сети выдавать одно и тоже число, вне зависимости от значения входных параметров (как у Вас в статье), все проходит отлично, и она справляется с задачей. Но! Как только я пытаюсь добавить еще одну пару параметров к примеру: 0.2, 0.3 соответствует 0.8 (все идет хорошо), а вот, 0.2, 0.3 соответствует 0.8; 0.4, 0.6 cсоответствует 0.5 — уже не работает. Т.е., когда у нейросети более одного контрольного параметра она не справляется с задачей. Такое ощущение, будто подстроив веса к первому контрольному параметру, она сразу теряет полученный результат, подстроив ко второму параметру. Как быть? Заранее спасибо

Евгений
Евгений
Reply to  Евгений
1 год назад

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

Евгений
Евгений
Reply to  Aveal
1 год назад

Спасибо! Вы были правы, я нашел ошибку

Professor Woland
Professor Woland
2 месяцев назад

Спасибо огромное. Именно таких примеров “на пальцах”, посчитанных ручками я и искал долгое время. Наконец получилось создать нейросеть на Питоне. Пока только с одним скрытым слоем. Работает великолепно!!! Причём написал код так, что можно изменять до бесконечности количество входных нейронов и нейронов скрытого слоя.
Теперь буду писать код для нескольких скрытых слоёв с сохранением парадигмы расширяемости количества нейронов в слоях.
Ещё раз огромное спасибо! Мастер!!!

Vladimir
Vladimir
2 месяцев назад

Спасибо! Отличная и наглядная практическая статья) Первая по которой не только удалось сделать свою реализацию НС но понять что есть что и для чего) Грамотно расставила всё по полочка в голове)

У меня есть вопрос:
Начинаю со случайных весов и обучаю НС XOR’у
В большинстве обучений всё в порядке и НС выдаёт ожидаемый результат, например:
[0,1] => 0.99; [1,0] => 0.97; [0,0] => 0.00; [1,1] => 0.02

Но иногда после обучения НС выдаёт странный результат, например:
[0,1] => 0.99; [1,0] => 0.99; [0,0] => 6.52; [1,1] => 0.00

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

В чём может быть проблема?

Александр
Александр
1 месяц назад

Спасибо большое за статью, наконец-то нашёл пример того, что происходит в ИНС!

Интересно, много ли математики скрыто от нас в том месте статьи, где даны итоговые формулы расчёта ошибки и активности элемента? Хотя, возможно, их можно и как данность принять, т.к. в целом механизм понятен. Было бы здорово, если бы мат.аппарат все же приводился, но был как-то выделен – мол, если сложно, пропускай этот кусок, читай дальше, но ты всё поймешь 🙂

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

1) Верно ли, что такой момент остановки может возникнуть до того момента, как кончится обучающая выборка? Если да, то Матлаб просто не задействует оставшиеся данные при обучении, или использует их для валидации/тестирования?

2) Если положим, что число допустимых итераций бесконечно, и обучающая выборка также бесконечна, не должна ли ИНС теоретически приходить к одним и тем же настройкам весов при разных начальных весах, выставленных произвольно? Учитывая, что начальные веса, как указано в статье, берутся из небольшого диапазона [-0.5,0.5], то вообще, кажется, что и при весьма ограниченной выборке ИНС должна быстро прийти к одной и той же конфигурации (правда, я так понял, этого не происходит).

2) Выборку в Матлабе можно разбить на Training, Validation и Testing. Не совсем понимаю, что это за этап – Validation и для чего он нужен?

Заранее спасибо!

Den
Den
12 дней назад

Здравствуйте. Очень круто! Стало понятно, как выполняются расчеты. И все-атки, уменя вопрос – как определять число нейронов в скрытом слое? Почему в примере 1 у нас 3 нейрона, а не 2 или 4?

Роман
Роман
9 дней назад

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

Роман
Роман
Reply to  Aveal
9 дней назад

Добрый!

1) а математически эти методы одинаковы?

2) рендом от -0,5 до 0,5 выставил, но сокрость также влияет. и это на сети 2-2-1. т.е. нужно еще постараться, чтобы она сошлась. реально странно или все-таки это нормально даже для таких простых сетей? (

3) еще вопрос какой физический смысл в скрытых слоях? как я понял в линейно-разделимых задачах они, вообще, не нужны? и они влияют только на нелинейные, но как?

Роман
Роман
Reply to  Aveal
8 дней назад

1) статья на хабре https://habr.com/ru/post/313216/ и изветсная гифка в середине. там умножают дифф после вычилсения всех ошибок.

2) 4 элемента. XOR задача. могу код скинуть, если нужно. на javascript писал с графиком)

3) как я понимаю, чем больше и сложнее взаимных пересечений, тем больше нужно скрытых слоев?

4) изучал движения прямой в 2-1 и обратил внимание, что не всегда прямая движется соазу к правильному углу, а переварачивается и заходит с другой стороны O.o Так должно быть?)
вот пример (синия – начало, красная – конец, зеленая – 5 эпоха): comment image

Роман
Роман
Reply to  Aveal
7 дней назад

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

чет там хостинг картинок не пашет, вот новая фотка к 4 вопросу:comment image

Роман
Роман
Reply to  Aveal
5 дней назад

3. Изменяем веса путем умножения еще диффиренциала

я проверял оба метода. результаты разные получается.
залил на гитхаб)
2-2-1
https://github.com/Listian/neuro_test

Роман
Роман
Reply to  Aveal
7 часов назад

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

Last edited 7 часов назад by Роман

Присоединяйтесь!

Profile Profile Profile Profile Profile
Vkontakte
Twitter

Язык сайта

Июнь 2020
Пн Вт Ср Чт Пт Сб Вс
« Май    
1234567
891011121314
15161718192021
22232425262728
2930  

© 2013-2020 MicroTechnics.ru