Нейросети и глубокое обучение, глава 2: как работает алгоритм обратного распространения

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

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

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

Причина, конечно, в понимании. В основе обратного распространения лежит выражение частной производной ∂C / ∂w функции стоимости C по весу w (или смещению b) сети. Выражение показывает, насколько быстро меняется стоимость при изменении весов и смещений. И хотя это выражение довольно сложное, у него есть своя красота, ведь у каждого его элемента есть естественная и интуитивная интерпретация. Поэтому обратное распространение – не просто быстрый алгоритм для обучения. Он даёт нам подробное понимание того, как изменение весов и смещений меняет всё поведение сети. А это стоит того, чтобы изучить подробности.

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

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

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

Начнём с записи, позволяющей нам недвусмысленно обозначать веса в сети. Мы будем использовать w^l_jk для обозначения веса связи нейрона №k в слое №(l-1) с нейроном №j в слое №l. Так, к примеру, на диаграмме ниже показан вес связи четвёртого нейрона второго слоя со вторым нейроном третьего слоя:



Сначала такая запись кажется неуклюжей, и требует некоторых усилий на привыкание. Однако вскоре она покажется вам простой и естественной. Одна её особенность – порядок индексов j и k. Вы могли бы решить, что разумнее было бы использовать j для обозначения входного нейрона, а k – для выходного, а не наоборот, как у нас. Причину такой особенности я объясню ниже.

Сходные обозначения мы будем использовать для смещений и активаций сети. В частности, b^l_j будет обозначать смещение нейрона №j в слое №l. a^l_j будет обозначать активацию нейрона №j в слое №l. На следующей диаграмме показаны примеры использования этой записи:



С такой записью активация a^l_j нейрона №j в слое №l связана с активацией в слое №(l-1) следующим уравнением (сравните с уравнением (4) и его обсуждением в прошлой главе):

где сумма идёт по всем нейронам k в слое (l-1). Чтобы перезаписать это выражение в матричном виде, мы определим матрицу весов w^l для каждого слоя l. Элементы матрицы весов – это просто веса, соединённые со слоем №l, то есть, элемент в строке №j и столбце №k будет w^l_jk. Сходным образом для каждого слоя l мы определяем вектор смещения b^l. Вы, наверное, догадались, как это работает – компонентами вектора смещения будут просто значения b^l_j, по одному компоненту для каждого нейрона в слое №l. И, наконец, мы определим вектор активации a^l, компонентами которого будут активации a^l_j.

Последним ингредиентом, необходимым для того, чтобы перезаписать (23), будет матричная форма векторизации функции σ. С векторизацией мы вскользь столкнулись в прошлой главе – идея в том, что мы хотим применить функцию σ к каждому элементу вектора v. Мы используем очевидную запись σ(v) для обозначения поэлементного применения функции. То есть, компонентами σ(v) будут просто σ(v)_j = σ(v_j). Для примера, если у нас есть функция f(x) = x², то векторизованная форма f даёт нам

то есть, векторизованная f просто возводит в квадрат каждый элемент вектора.

Учитывая все эти формы записи, уравнение (23) можно переписать в красивой и компактной векторизованной форме:

Такое выражение позволяет нам более глобально взглянуть на связь активаций одного слоя с активациями предыдущего: мы просто применяем матрицу весов к активациям, добавляем вектор смещения и потом применяем сигмоиду. Кстати, именно эта запись и требует использования записи w^l_jk. Если бы мы использовали индекс j для обозначения входного нейрона, а k для выходного, нам пришлось бы заменить матрицу весов в уравнении (25) на транспонированную. Это небольшое, но раздражающее изменение, и мы бы потеряли простоту заявления (и размышления) о «применении матрицы весов к активациям». Такой глобальный подход проще и лаконичнее (и использует меньше индексов!), чем понейронный. Это просто способ избежать индексного ада, не теряя точности обозначения происходящего. Также это выражение полезно на практике, поскольку большинство матричных библиотек предлагают быстрые способы перемножения матриц, сложения векторов и векторизации. Код в прошлой главе непосредственно пользовался этим выражением для вычисления поведения сети.

Используя уравнение (25) для вычисления a^l, мы вычисляем промежуточное значение z^l ≡ w^la^l−1+b^l. Эта величина оказывается достаточно полезной для именования: мы называем z^l взвешенным входом нейронов слоя №l. Позднее мы активно будем использовать этот взвешенный вход. Уравнение (25) иногда записывают через взвешенный вход, как a^l = σ(z^l). Стоит также отметить, что у z^l есть компоненты , то есть, z^l_j — это всего лишь взвешенный вход функции активации нейрона j в слое l.

Два необходимых предположения по поводу функции стоимости

Цель обратного распространения – вычислить частные производные ∂C/∂w и ∂C/∂b функции стоимости C для каждого веса w и смещения b сети. Чтобы обратное распространение сработало, нам необходимо сделать два главных предположения по поводу формы функции стоимости. Однако перед этим полезно будет представлять себе пример функции стоимости. Мы используем квадратичную функцию из прошлой главы (уравнение (6)). В записи из предыдущего раздела она будет иметь вид

где: n – общее количество обучающих примеров; сумма идёт по всем примерам x; y=y(x) – необходимые выходные данные; L обозначает количество слоёв в сети; a^L = a^L (x) – вектор выхода активаций сети, когда на входе x.

Ладно, так какие нам нужны предположения касательно функции стоимости С, чтобы применять обратное распространение? Первое – функцию стоимости можно записать как среднее C = 1/n ∑_x C_x функций стоимости C_x для отдельных обучающих примеров x. Это выполняется в случае квадратичной функции стоимости, где стоимость одного обучающего примера C_x = 1/2 ||y − a^L||². Это предположение будет верным и для всех остальных функций стоимости, которые встретятся нам в книге.

Это предположение нужно нам потому, что на самом деле обратное распространение позволяет нам вычислять частные производные ∂C/∂w и ∂C/∂b, усредняя по обучающим примерам. Приняв это предположение, мы предположим, что обучающий пример x фиксирован, и перестанем указывать индекс x, записывая стоимость C_x как C. Потом мы вернём x, но пока что лучше его просто подразумевать.

Второе предположение касательно функции стоимости – её можно записать как функцию выхода нейросети:



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

что и будет функцией выходных активаций. Конечно, эта функция стоимости также зависит от желаемого выхода y, и вы можете удивиться, почему мы не рассматриваем C как функцию ещё и от y. Однако вспомним, что входной обучающий пример x фиксирован, поэтому выход y тоже фиксирован. В частности, его мы не можем изменить, меняя веса и смещения, то есть, это не то, что выучивает нейросеть. Поэтому имеет смысл считать C функцией от только выходных активаций a^L, а y – просто параметром, помогающим её определять.

Произведение Адамара s⊙t

Алгоритм обратного распространения основан на обычных операциях линейной алгебры – сложении векторов, умножении вектора на матрицу, и т.д. Однако одна из операций используется менее часто. Допустим, s и t – два вектора одной размерности. Тогда через s⊙t мы обозначим поэлементное перемножение двух векторов. Тогда компоненты s⊙t будут просто (s⊙t)_j = s_jt_j. Например:

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

Четыре фундаментальных уравнения в основе обратного распространения

Обратное распространение связано с пониманием того, как изменение весов и смещений сети меняет функцию стоимости. По сути, это означает подсчёт частных производных ∂C/∂w^l_jk и ∂C/∂b^l_j. Но для их вычисления сначала мы вычисляем промежуточное значение δ^l_j, которую мы называем ошибкой в нейроне №j в слое №l. Обратное распространение даст нам процедуру для вычисления ошибки δ^l_j, а потом свяжет δ^l_j с ∂C/∂w^l_jk и ∂C/∂b^l_j.

Чтобы понять, как определяется ошибка, представьте, что в нашей нейросети завёлся демон:



Он сидит на нейроне №j в слое №l. При поступлении входных данных демон нарушает работу нейрона. Он добавляет небольшое изменение Δz^l_j к взвешенному входу нейрона, и вместо того, чтобы выдавать σ(z^l_j), нейрон выдаст σ(z^l_j + Δz^l_j). Это изменение распространится и через следующие слои сети, что в итоге изменит общую стоимость на (∂C/∂z^l_j) * Δz^l_j.

Но наш демон хороший, и он пытается помочь вам улучшить стоимость, то есть, найти Δz^l_j, уменьшающее стоимость. Допустим, значение ∂C/∂z^l_j велико (положительное или отрицательное). Тогда демон может серьёзно уменьшить стоимость, выбрав Δz^l_j со знаком, противоположным ∂C/∂z^l_j. А если же ∂C/∂z^l_j близко к нулю, тогда демон не может сильно улучшить стоимость, меняя взвешенный вход z^l_j. Так что, с точки зрения демона, нейрон уже близок к оптимуму (это, конечно, верно только для малых Δz^l_j. Допустим, таковы ограничения действий демона). Поэтому в эвристическом смысле ∂C/∂z^l_j является мерой ошибки нейрона.

Под мотивацией от этой истории определим ошибку δ^l_j нейрона j в слое l, как

По обычному нашему соглашению мы используем δ^l для обозначения вектора ошибок, связанного со слоем l. Обратное распространение даст нам способ подсчитать δ^l для любого слоя, а потом соотнести эти ошибки с теми величинами, которые нас реально интересуют, ∂C/∂w^l_jk и ∂C/∂b^l_j.

Вас может интересовать, почему демон меняет взвешенный вход z^l_j. Ведь было бы естественнее представить, что демон изменяет выходную активацию a^l_j, чтобы мы использовали ∂C/∂a^l_j в качестве меры ошибки. На самом деле, если сделать так, то всё получается очень похожим на то, что мы будем обсуждать дальше. Однако в этом случае представление обратного распространения будет алгебраически чуть более сложным. Поэтому мы остановимся на варианте δ^l_j = ∂C/∂z^l_j в качестве меры ошибки.

В задачах классификации термин «ошибка» иногда означает количество неправильных классификаций. К примеру, если нейросеть правильно классифицирует 96,0% цифр, то ошибка будет равна 4,0%. Очевидно, это совсем не то, что мы имеем в виду под векторами δ. Но на практике обычно можно без труда понять, какое значение имеется в виду.

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

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

Уравнение ошибки выходного слоя, δ^L: компоненты δ^L считаются, как

Очень естественное выражение. Первый член справа, ∂C / ∂a^L_j, измеряет, насколько быстро стоимость меняется как функция выходной активации №j. Если, к примеру, C не особенно зависит от конкретного выходного нейрона j, тогда δ^L_j будет малым, как и ожидается. Второй член справа, σ'(z^L_j), измеряет, насколько быстро функция активации σ меняется в z^L_j.

Заметьте, что всё в (BP1) легко подсчитать. В частности, мы вычисляем z^L_j при подсчёте поведения сети, и на вычисление σ'(z^L_j) уйдёт незначительно больше ресурсов. Конечно, точная форма ∂C / ∂a^L_j зависит от формы функции стоимость. Однако, если функция стоимости известна, то не должно быть проблем с вычислением ∂C / ∂a^L_j. К примеру, если мы используем квадратичную функцию стоимости, тогда C = 1/2 ∑_j (y_j − a^L_j)², поэтому ∂C / ∂a^L_j = (a^L_j − y_j), что легко подсчитать.

Уравнение (BP1) – это покомпонентное выражение δ^L. Оно совершенно нормальное, но не записано в матричной форме, которая нужна нам для обратного распространения. Однако, его легко переписать в матричной форме, как

Здесь ∇_a C определяется, как вектор, чьими компонентами будут частные производные ∂C / ∂a^L_j. Его можно представлять, как выражение скорости изменения C по отношению к выходным активациям. Легко видеть, что уравнения (BP1a) и (BP1) эквивалентны, поэтому далее мы будем использовать (BP1) для отсылки к любому из них. К примеру, в случае с квадратичной стоимостью, у нас будет ∇_a C = (a^L — y), поэтому полной матричной формой (BP1) будет

Всё в этом выражении имеет удобную векторную форму, и его легко вычислить при помощи такой библиотеки, как, например, Numpy.

Выражение ошибки δ^l через ошибку в следующем слое, δ^l+1: в частности,

где (w^l+1)^T — транспонирование весовой матрицы w^l+1 для слоя №(l+1). Уравнение кажется сложным, но каждый его элемент легко интерпретировать. Допустим, мы знаем ошибку δ^l+1 для слоя (l+1). Транспонирование весовой матрицы, (w^l+1)^T, можно представить себе, как перемещение ошибки назад по сети, что даёт нам некую меру ошибки на выходе слоя №l. Затем мы считаем произведение Адамара ⊙σ'(z^l). Это продвигает ошибку назад через функцию активации в слое l, давая нам значение ошибки δl во взвешенном входе для слоя l.

Комбинируя (BP2) с (BP1), мы можем подсчитать ошибку δ^l для любого слоя сети. Мы начинаем с использования (BP1) для подсчёта δ^L, затем применяем уравнение (BP2) для подсчёта δ^L-1, затем снова для подсчёта δ^L-2, и так далее, до упора по сети в обратную сторону.

Уравнение скорости изменения стоимости по отношению к любому смещению в сети: в частности:

То есть, ошибка δ^l_j точно равна скорости изменения ∂C / ∂b^l_j. Это превосходно, поскольку (BP1) и (BP2) уже рассказали нам, как подсчитывать δ^l_j. Мы можем перезаписать (BP3) короче, как

где δ оценивается для того же нейрона, что и смещение b.

Уравнение для скорости изменения стоимости по отношению к любому весу в сети: в частности:

Отсюда мы узнаём, как подсчитать частную производную ∂C/∂w^l_jk через значения δ^l и a^l-1, способ расчёта которых нам уже известен. Это уравнение можно переписать в менее загруженной индексами форме:

где a_in — активация нейронного входа для веса w, а δ_out — ошибка нейронного выхода от веса w. Если подробнее посмотреть на вес w и два соединённых им нейрона, то можно будет нарисовать это так:



Приятное следствие уравнения (32) в том, что когда активация a_in мала, a_in ≈ 0, член градиента ∂C/∂w тоже стремится к нулю. В таком случае мы говорим, что вес обучается медленно, то есть, не сильно меняется во время градиентного спуска. Иначе говоря, одним из следствий (BP4) будет то, что весовой выход нейронов с низкой активацией обучается медленно.

Из (BP1)-(BP4) можно почерпнуть и другие идеи. Начнём с выходного слоя. Рассмотрим член σ'(z^L_j) в (BP1). Вспомним из графика сигмоиды из прошлой главы, что она становится плоской, когда σ(z^L_j) приближается к 0 или 1. В данных случаях σ'(z^L_j) ≈ 0. Поэтому вес в последнем слое будет обучаться медленно, если активация выходного нейрона мала (≈ 0) или велика (≈ 1). В таком случае обычно говорят, что выходной нейрон насыщен, и в итоге вес перестал обучаться (или обучается медленно). Те же замечания справедливы и для смещений выходного нейрона.

Сходные идеи можно получить и касательно более ранних слоёв. В частности, рассмотрим член σ'(z^l) в (BP2). Это значит, что δ^l_j, скорее всего, будет малой при приближении нейрона к насыщению. А это, в свою очередь, означает, что любые веса на входе насыщенного нейрона будут обучаться медленно (правда, это не сработает, если у w^l+1Tδ^l+1 будут достаточно большие элементы, компенсирующие небольшое значение σ'(z^L_j)).

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

В этом нет ничего особенно удивительного. И всё же, эти наблюдения помогают улучшить наше представление о том, что происходит при обучении сети. Более того, мы можем подойти к этим рассуждениям с обратной стороны. Четыре фундаментальных уравнения справедливы для любой функции активации, а не только для стандартной сигмоиды (поскольку, как мы увидим далее, в доказательствах не используются свойства сигмоиды). Поэтому эти уравнения можно использовать для разработки функций активации с определёнными нужными свойствами обучения. Для примера, допустим, мы выбрали функцию активации σ, непохожую на сигмоиду, такую, что σ' всегда положительна и не приближается к нулю. Это предотвратить замедление обучения, происходящее при насыщении обычных сигмоидных нейронов. Позднее в книге мы увидим примеры, где функция активации меняется подобным образом. Учитывая уравнения (BP1)-(BP4), мы можем объяснить, зачем нужны такие модификации, и как они могут повлиять на ситуацию.


Итог: уравнения обратного распространения

Задачи

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

где Σ'(z^L) – квадратная матрица, у которой по диагонали расположены значения σ'(z^L_j), а другие элементы равны 0. Учтите, что эта матрица взаимодействует с ∇_a C через обычное перемножение матриц.

Покажите, что (BP2) можно переписать, как

Комбинируя предыдущие задачи, покажите, что:

Для читателей, привычных к матричному перемножению, это уравнение будет легче понять, чем (BP1) и (BP2). Я концентрируюсь на (BP1) и (BP2) потому, что этот подход оказывается быстрее реализовать численно. [здесь Σ — это не сумма (∑), а заглавная σ (сигма) / прим. перев.]

Доказательство четырёх фундаментальных уравнений (необязательный раздел)

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

Начнём с уравнения (BP1), которое даёт нам выражение для выходной ошибки δ^L. Чтобы доказать его, вспомним, что, по определению:

Применяя цепное правило, перепишем частные производные через частные производные по выходным активациям:

где суммирование идёт по всем нейронам k в выходном слое. Конечно, выходная активация a^L_k нейрона №k зависит только от взвешенного входа z^L_j для нейрона №j, когда k=j. Поэтому ∂a^L_k / ∂z^L_j исчезает, когда k ≠ j. В итоге мы упрощаем предыдущее уравнение до

Вспомнив, что a^L_j = σ(z^L_j), мы можем переписать второй член справа, как σ'(z^L_j), и уравнение превращается в

то есть, в (BP1) в покомпонентном виде.

Затем докажем (BP2), дающее уравнение для ошибки δ^l через ошибку в следующем слое δ^l+1. Для этого нам надо переписать δ^l_j = ∂C / ∂z^l_j через δ^l+1_k = ∂C / ∂z^l+1_k. Это можно сделать при помощи цепного правила:

где в последней строчке мы поменяли местами два члена справа, и подставили определение δ^l+1_k. Чтобы вычислить первый член на последней строчке, отметим, что

Продифференцировав, получим

Подставив это в (42), получим

То есть, (BP2) в покомпонентной записи.

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

Упражнение

• Докажите (BP3) и (BP4).

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

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

Уравнения обратного распространения дают нам метод подсчёта градиента функции стоимости. Давайте запишем это явно в виде алгоритма:

1. Вход x: назначить соответствующую активацию a¹ для входного слоя.
2. Прямое распространение: для каждого l = 2,3,…,L вычислить z^l = w^la^l−1+b^l и a^l = σ(z^l).
3. Выходная ошибка δ^L: вычислить вектор δ^L = ∇_a C ⊙ σ'(z^L).
4. Обратное распространение ошибки: для каждого l = L−1,L−2,…,2 вычислить δ^l = ((w^l+1)^Tδ^l+1) ⊙ σ'(z^l).
5. Выход: градиент функции стоимости задаётся и .

Посмотрев на алгоритм, вы поймёте, почему он называется обратное распространение. Мы вычисляем векторы ошибки δ^l задом наперёд, начиная с последнего слоя. Может показаться странным, что мы идём по сети назад. Но если подумать о доказательстве обратного распространения, то обратное движение является следствием того, что стоимость – это функция выхода сети. Чтобы понять, как меняется стоимость в зависимости от ранних весов и смещений, нам нужно раз за разом применять цепное правило, идя назад через слои, чтобы получить полезные выражения.

Упражнения

• Обратное распространение с одним изменённым нейроном. Допустим, мы изменили один нейрон в сети с прямым распространением так, чтобы его выход был f(∑_j w_jx_j+b), где f – некая функция, не похожая на сигмоиду. Как нам поменять алгоритм обратного распространения в данном случае?
• Обратное распространение с линейными нейронами. Допустим, мы заменим обычную нелинейную сигмоиду на σ(z) = z по всей сети. Перепишите алгоритм обратного распространения для данного случая.

Как я уже пояснял ранее, алгоритм обратного распространения вычисляет градиент функции стоимости для одного обучающего примера, C = C_x. На практике часто комбинируют обратное распространение с алгоритмом обучения, например, со стохастическим градиентным спуском, когда мы подсчитываем градиент для многих обучающих примеров. В частности, при заданном мини-пакете m обучающих примеров, следующий алгоритм применяет градиентный спуск на основе этого мини-пакета:

1. Вход: набор обучающих примеров.
2. Для каждого обучающего примера x назначить соответствующую входную активацию a^x,1 и выполнить следующие шаги:
   
   • Прямое распространение для каждого l=2,3,…,L вычислить z^x,l = w^la^x,l−1+b^l и a^x,l = σ(z^x,l).
   • Выходная ошибка δ^x,L: вычислить вектор δ^x,L = ∇_a C_x ⋅ σ'(z^x,L).
   • Обратное распространение ошибки: для каждого l=L−1,L−2,…,2 вычислить δ^x,l = ((w^l+1)^Tδ^x,l+1) ⋅ σ'(z^x,l).
3. Градиентный спуск: для каждого l=L,L−1,…,2 обновить веса согласно правилу , и смещения согласно правилу .

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

Код для обратного распространения

Поняв абстрактную сторону обратного распространения, теперь мы можем понять код, использованный в предыдущей главе, реализующий обратное распространение. Вспомним из той главы, что код содержался в методах update_mini_batch и backprop класс Network. Код этих методов – прямой перевод описанного выше алгоритма. В частности, метод update_mini_batch обновляет веса и смещения сети, подсчитывая градиент для текущего mini_batch обучающих примеров:

class Network(object):
...
    def update_mini_batch(self, mini_batch, eta):
        """Обновить веса и смещения сети, применяя градиентный спуск с использованием обратного распространения к одному мини-пакету. mini_batch – это список кортежей (x, y), а eta – скорость обучения."""
        nabla_b = [np.zeros(b.shape) for b in self.biases]
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        for x, y in mini_batch:
            delta_nabla_b, delta_nabla_w = self.backprop(x, y)
            nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]
            nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]
        self.weights = [w-(eta/len(mini_batch))*nw 
                        for w, nw in zip(self.weights, nabla_w)]
        self.biases = [b-(eta/len(mini_batch))*nb 
                       for b, nb in zip(self.biases, nabla_b)]

Большую часть работы делают строки delta_nabla_b, delta_nabla_w = self.backprop(x, y), использующие метод backprop для подсчёта частных производных ∂C_x/∂b^l_j и ∂C_x/∂w^l_jk. Метод backprop почти повторяет алгоритм предыдущего раздела. Есть одно небольшое отличие – мы используем немного другой подход к индексированию слоёв. Это сделано для того, чтобы воспользоваться особенностью python, отрицательными индексами массива, позволяющими отсчитывать элементы назад, с конца. l[-3] будет третьим элементом с конца массива l. Код backprop приведён ниже, вместе со вспомогательными функциями, используемыми для подсчёта сигмоиды, её производной и производной функции стоимости. С ними код получается законченным и понятным. Если что-то неясно, обратитесь к первому описанию кода с полным листингом.

class Network(object):
...
   def backprop(self, x, y):
        """Вернуть кортеж ``(nabla_b, nabla_w)``, представляющий градиент для функции стоимости C_x.  ``nabla_b`` и ``nabla_w`` - послойные списки массивов numpy, похожие на ``self.biases`` and ``self.weights``."""
        nabla_b = [np.zeros(b.shape) for b in self.biases]
        nabla_w = [np.zeros(w.shape) for w in self.weights]
        # прямой проход
        activation = x
        activations = [x] # список для послойного хранения активаций
        zs = [] # список для послойного хранения z-векторов
        for b, w in zip(self.biases, self.weights):
            z = np.dot(w, activation)+b
            zs.append(z)
            activation = sigmoid(z)
            activations.append(activation)
        # обратный проход
        delta = self.cost_derivative(activations[-1], y) * \
            sigmoid_prime(zs[-1])
        nabla_b[-1] = delta
        nabla_w[-1] = np.dot(delta, activations[-2].transpose())
        """Переменная l в цикле ниже используется не так, как описано во второй главе книги. l = 1 означает последний слой нейронов, l = 2 – предпоследний, и так далее. Мы пользуемся преимуществом того, что в python можно использовать отрицательные индексы в массивах."""
        for l in xrange(2, self.num_layers):
            z = zs[-l]
            sp = sigmoid_prime(z)
            delta = np.dot(self.weights[-l+1].transpose(), delta) * sp
            nabla_b[-l] = delta
            nabla_w[-l] = np.dot(delta, activations[-l-1].transpose())
        return (nabla_b, nabla_w)

...

    def cost_derivative(self, output_activations, y):
        """Вернуть вектор частных производных (чп C_x / чп a) для выходных активаций."""
        return (output_activations-y) 

def sigmoid(z):
    """Сигмоида."""
    return 1.0/(1.0+np.exp(-z))

def sigmoid_prime(z):
    """Производная сигмоиды."""
    return sigmoid(z)*(1-sigmoid(z))

Задача

• Полностью основанный на матрицах подход к обратному распространению на мини-пакете. Наша реализация стохастического градиентного спуска использует цикл по обучающим примерам из мини-пакета. Алгоритм обратного распространения можно поменять так, чтобы он вычислял градиенты для всех обучающих примерах мини-пакета одновременно. Вместо того, чтобы начинать с одного вектора x, мы можем начать с матрицы X=[x₁x₂…x_m], чьими столбцами будут векторы мини-пакета. Прямое распространение идёт через произведение весовых матриц, добавление подходящей матрицы для смещений и повсеместного применения сигмоиды. Обратное распространение идёт по той же схеме. Напишите псевдокод для такого подхода для алгоритма обратного распространения. Измените network.py так, чтобы он использовал этот матричный подход. Преимуществом такого подхода будет использование всех преимуществ современных библиотек для линейной алгебры. В итоге он может работать быстрее цикла по мини-пакеты (к примеру, на моём компьютере программа ускоряется примерно в 2 раза на задачах классификации MNIST). На практике все серьёзные библиотеки для обратного распространения используют такой полноматричный подход или какой-то его вариант.

В каком смысле обратное распространение является быстрым алгоритмом?

В каком смысле обратное распространение является быстрым алгоритмом? Для ответа на этот вопрос рассмотрим ещё один подход к вычислению градиента. Представьте себе ранние дни исследований нейросетей. Возможно, это 1950-е или 1960-е годы, и вы – первый человек в мире, придумавший использовать для обучения градиентный спуск! Но чтобы это сработало, вам нужно подсчитать градиент функции стоимости. Вы вспоминаете алгебру и решаете посмотреть, можно ли использовать цепное правило для вычисления градиента. Немного поигравшись, вы видите, что алгебра кажется сложной, и вы разочаровываетесь. Вы пытаетесь найти другой подход. Вы решаете считать стоимость функцией только весов C=C(w) (к смещениям вернёмся чуть позже). Вы нумеруете веса w₁, w₂,… и хотите вычислить ∂C/∂w_j для веса w_j. Очевидный способ – использовать приближение

Где ε > 0 – небольшое положительное число, а e_j — единичный вектор направления j. Иначе говоря, мы можем приблизительно оценить ∂C/∂w_j, вычислив стоимость C для двух немного различных значений w_j, а потом применить уравнение (46). Та же идея позволит нам подсчитать частные производные ∂C/∂b по смещениям.

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

К сожалении, хотя такой подход выглядит многообещающим, при его реализации в коде оказывается, что работает он крайне медленно. Чтобы понять, почему, представьте, что у нас в сети миллион весов. Тогда для каждого веса w_j нам нужно вычислить C(w + εe_j), чтобы подсчитать ∂C/∂w_j. А это значит, что для вычисления градиента нам нужно вычислить функцию стоимости миллион раз, что потребует миллион прямых проходов по сети (на каждый обучающий пример). А ещё нам надо подсчитать C(w), так что получается миллион и один проход по сети.

Хитрость обратного распространения в том, что она позволяет нам одновременно вычислять все частные производные ∂C/∂w_j, используя только один прямой проход по сети, за которым следует один обратный проход. Грубо говоря, вычислительная стоимость обратного прохода примерно такая же, как у прямого.

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

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

Обратное распространение: в общем и целом

Как я уже объяснил, обратное распространение являет нам две загадки. Первая, что на самом деле делает алгоритм? Мы выработали схему обратного распространения ошибки от выходных данных. Можно ли углубиться дальше, получить более интуитивное представление о происходящем во время всех этих перемножений векторов и матриц? Вторая загадка – как вообще кто-то мог обнаружить обратное распространение? Одно дело, следовать шагам алгоритма или доказательству его работы. Но это не значит, что вы так хорошо поняли задачу, что могли изобрести этот алгоритм. Есть ли разумная цепочка рассуждений, способная привести нас к открытию алгоритма обратного распространения? В этом разделе я освещу обе загадки.

Чтобы улучшить понимание работы алгоритма, представим, что мы провели небольшое изменение Δw^l_jk некоего веса w^l_jk:



Это изменение веса приведёт к изменению выходной активации соответствующего нейрона:



Это приведёт к изменению всех активаций следующего слоя:



Эти изменения приведут к изменениям следующего слоя, и так далее, вплоть до последнего, а потом к изменениям функции стоимости:



Изменение ΔC связано с изменением Δw^l_jk уравнением

Из этого следует, что вероятным подходом к вычислению ∂C/∂w^l_jk будет тщательное отслеживание распространения небольшого изменения w^l_jk, приводящего к небольшому изменению в C. Если мы сможем это сделать, тщательно выражая по пути всё в величинах, которые легко вычислить, то мы сможем вычислить и ∂C/∂w^l_jk.

Давайте попробуем. Изменение Δw^l_jk вызывает небольшое изменение Δa^l_j в активации нейрона j в слое l. Это изменение задаётся

Изменение активации Δa^l_j приводит к изменениям во всех активациях следующего слоя, (l+1). Мы сконцентрируемся только на одной из этих изменённых активаций, допустим, a^l+1_q,



Это приведёт к следующим изменениям:

Подставляя уравнение (48), получаем:

Конечно, изменение Δa^l+1_q изменит и активации в следующем слое. Мы даже можем представить путь по всей сети от w^l_jk до C, где каждое изменение активации приводит к изменению следующей активации, и, наконец, к изменению стоимости на выходе. Если путь проходит через активации a^l_j, a^l+1_q,…,a^L−1_n, a^L_m, тогда итоговое выражение будет

То есть, мы выбираем член вида ∂a/∂a для каждого следуюшего проходимого нами нейрона, а также для члена ∂C / ∂a^L_m в конце. Это представление изменений в C из-за изменений в активациях по данному конкретному пути сквозь сеть. Конечно, существует много путей, по которым изменение в w^l_jk может пройти и повлиять на стоимость, а мы рассматривали только один из них. Чтобы подсчитать общее изменение C разумно предположить, что мы должны просуммировать все возможные пути от веса до конечной стоимости:

где мы просуммировали все возможные выборы для промежуточных нейронов по пути. Сравнивая это с (47), мы видим, что:

Уравнение (53) выглядит сложно. Однако у него есть приятная интуитивная интерпретация. Мы подсчитываем изменение C по отношению к весам сети. Оно говорит нам, что каждое ребро между двумя нейронами сети связано с фактором отношения, являющимся только лишь частной производной активации одного нейрона по отношению к активации другого нейрона. У ребра от первого веса до первого нейрона фактор отношения равен ∂a^l_j / ∂w^l_jk. Коэффициент отношения для пути – это просто произведение коэффициентов по всему пути. А общий коэффициент изменения ∂C / ∂w^l_jk является суммой коэффициентов по всем путям от начального веса до конечной стоимости. Эта процедура показана далее, для одного пути:



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

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

Что насчёт другой загадки – как вообще можно было открыть обратное распространение? На самом деле, если вы последуете по обрисованному мною пути, вы получите доказательство обратного распространения. К несчастью, доказательство будет длиннее и сложнее чем то, что я описал ранее. Так как же было открыто то короткое (но ещё более загадочное) доказательство? Если записать все детали длинного доказательства, вам сразу бросятся в глаза несколько очевидных упрощений. Вы применяете упрощения, получаете более простое доказательство, записываете его. А затем вам опять на глаза попадаются несколько очевидных упрощений. И вы повторяете процесс. После нескольких повторений получится то доказательство, что мы видели ранее – короткое, но немного непонятное, поскольку из него удалены все путеводные вехи! Я, конечно, предлагаю вам поверить мне на слово, однако никакой загадки происхождения приведённого доказательства на самом деле нет. Просто много тяжёлой работы по упрощению доказательства, описанного мною в этом разделе.

Однако в этом процессе есть один хитроумный трюк. В уравнении (53) промежуточные переменные – это активации, типа a^l+1_q. Хитрость в том, чтобы перейти к использованию взвешенных входов, типа z^l+1_q, в качестве промежуточных переменных. Если не пользоваться этим, и продолжать использовать активации, полученное доказательство будет немногим более сложным, чем данное ранее в этой главе.