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

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

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

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

1. Паралич сети

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

2. Локальные минимумы

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

3. Размер шага

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

Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]

• #
• #
• #
• #
• #
• #
• #
• #
• #
• #
• #

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

Открытие метода обратного распространения ошибки стало одним из наиболее значимых событий в области искусственного интеллекта. В актуальном виде он был предложен в 1986 году Дэвидом Э. Румельхартом, Джеффри Э. Хинтоном и Рональдом Дж. Вильямсом и независимо и одновременно красноярскими математиками С. И. Барцевым и В. А. Охониным. С тех пор для нахождения градиентов параметров нейронной сети используется метод вычисления производной сложной функции, и оценка градиентов параметров сети стала хоть сложной инженерной задачей, но уже не искусством. Несмотря на простоту используемого математического аппарата, появление этого метода привело к значительному скачку в развитии искусственных нейронных сетей.

Суть метода можно записать одной формулой, тривиально следующей из формулы производной сложной функции: если $f(x) = g_m(g_{m-1}(\ldots (g_1(x)) \ldots))$, то $\frac{\partial f}{\partial x} = \frac{\partial g_m}{\partial g_{m-1}}\frac{\partial g_{m-1}}{\partial g_{m-2}}\ldots \frac{\partial g_2}{\partial g_1}\frac{\partial g_1}{\partial x}$. Уже сейчас мы видим, что градиенты можно вычислять последовательно, в ходе одного обратного прохода, начиная с $\frac{\partial g_m}{\partial g_{m-1}}$ и умножая каждый раз на частные производные предыдущего слоя.

Backpropagation в одномерном случае

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

$$f(w_0) = g_m(g_{m-1}(\ldots g_1(w_0)\ldots)),$$

где все $g_i$ скалярные. Тогда

$$f'(w_0) = g_m'(g_{m-1}(\ldots g_1(w_0)\ldots))\cdot g’_{m-1}(g_{m-2}(\ldots g_1(w_0)\ldots))\cdot\ldots \cdot g’_1(w_0)$$

Суть этой формулы такова. Если мы уже совершили forward pass, то есть уже знаем

$$g_1(w_0), g_2(g_1(w_0)),\ldots,g_{m-1}(\ldots g_1(w_0)\ldots),$$

то мы действуем следующим образом:

• берём производную $g_m$ в точке $g_{m-1}(\ldots g_1(w_0)\ldots)$;

• умножаем на производную $g_{m-1}$ в точке $g_{m-2}(\ldots g_1(w_0)\ldots)$;

• и так далее, пока не дойдём до производной $g_1$ в точке $w_0$.

Проиллюстрируем это на картинке, расписав по шагам дифференцирование по весам $w_i$ функции потерь логистической регрессии на одном объекте (то есть для батча размера 1):

Собирая все множители вместе, получаем:

$$\frac{\partial f}{\partial w_0} = (-y)\cdot e^{-y(w_0 + w_1x_1 + w_2x_2)}\cdot\frac{-1}{1 + e^{-y(w_0 + w_1x_1 + w_2x_2)}}$$

$$\frac{\partial f}{\partial w_1} = x_1\cdot(-y)\cdot e^{-y(w_0 + w_1x_1 + w_2x_2)}\cdot\frac{-1}{1 + e^{-y(w_0 + w_1x_1 + w_2x_2)}}$$

$$\frac{\partial f}{\partial w_2} = x_2\cdot(-y)\cdot e^{-y(w_0 + w_1x_1 + w_2x_2)}\cdot\frac{-1}{1 + e^{-y(w_0 + w_1x_1 + w_2x_2)}}$$

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

Почему же нельзя просто пойти и начать везде вычислять производные?

В главе, посвящённой матричным дифференцированиям, мы поднимаем вопрос о том, что вычислять частные производные по отдельности — это зло, лучше пользоваться матричными вычислениями. Но есть и ещё одна причина: даже и с матричной производной в принципе не всегда хочется иметь дело. Рассмотрим простой пример. Допустим, что $X^r$ и $X^{r+1}$ — два последовательных промежуточных представления $N\times M$ и $N\times K$, связанных функцией $X^{r+1} = f^{r+1}(X^r)$. Предположим, что мы как-то посчитали производную $\frac{\partial\mathcal{L}}{\partial X^{r+1}_{ij}}$ функции потерь $\mathcal{L}$, тогда

$$\frac{\partial\mathcal{L}}{\partial X^{r}_{st}} = \sum_{i,j}\frac{\partial f^{r+1}_{ij}}{\partial X^{r}_{st}}\frac{\partial\mathcal{L}}{\partial X^{r+1}_{ij}}$$

И мы видим, что, хотя оба градиента $\frac{\partial\mathcal{L}}{\partial X_{ij}^{r+1}}$ и $\frac{\partial\mathcal{L}}{\partial X_{st}^{r}}$ являются просто матрицами, в ходе вычислений возникает «четырёхмерный кубик» $\frac{\partial f_{ij}^{r+1}}{\partial X_{st}^{r}}$, даже хранить который весьма болезненно: уж больно много памяти он требует ($N^2MK$ по сравнению с безобидными $NM + NK$, требуемыми для хранения градиентов). Поэтому хочется промежуточные производные $\frac{\partial f^{r+1}}{\partial X^{r}}$ рассматривать не как вычисляемые объекты $\frac{\partial f_{ij}^{r+1}}{\partial X_{st}^{r}}$, а как преобразования, которые превращают $\frac{\partial\mathcal{L}}{\partial X_{ij}^{r+1}}$ в $\frac{\partial\mathcal{L}}{\partial X_{st}^{r}}$. Целью следующих глав будет именно это: понять, как преобразуется градиент в ходе error backpropagation при переходе через тот или иной слой.

  Вы спросите себя: надо ли мне сейчас пойти и прочитать главу учебника про матричное дифференцирование?

Встречный вопрос. Найдите производную функции по вектору $x$:

$$f(x) = x^TAx,\ A\in Mat_{n}{\mathbb{R}}\text{ — матрица размера }n\times n$$

А как всё поменяется, если $A$ тоже зависит от $x$? Чему равен градиент функции, если $A$ является скаляром? Если вы готовы прямо сейчас взять ручку и бумагу и посчитать всё, то вам, вероятно, не надо читать про матричные дифференцирования. Но мы советуем всё-таки заглянуть в эту главу, если обозначения, которые мы будем дальше использовать, покажутся вам непонятными: единой нотации для матричных дифференцирований человечество пока, увы, не изобрело, и переводить с одной на другую не всегда легко.

Мы же сразу перейдём к интересующей нас вещи: к вычислению градиентов сложных функций.

Градиент сложной функции

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

$$\left[D_{x_0} (\color{#5002A7}{u} \circ \color{#4CB9C0}{v}) \right](h) = \color{#5002A7}{\left[D_{v(x_0)} u \right]} \left( \color{#4CB9C0}{\left[D_{x_0} v\right]} (h)\right)$$

Теперь разберёмся с градиентами. Пусть $f(x) = g(h(x))$ – скалярная функция. Тогда

$$\left[D_{x_0} f \right] (x-x_0) = \langle\nabla_{x_0} f, x-x_0\rangle.$$

С другой стороны,

$$\left[D_{h(x_0)} g \right] \left(\left[D_{x_0}h \right] (x-x_0)\right) = \langle\nabla_{h_{x_0}} g, \left[D_{x_0} h\right] (x-x_0)\rangle = \langle\left[D_{x_0} h\right]^* \nabla_{h(x_0)} g, x-x_0\rangle.$$

То есть $\color{#FFC100}{\nabla_{x_0} f} = \color{#348FEA}{\left[D_{x_0} h \right]}^* \color{#FFC100}{\nabla_{h(x_0)}}g$ — применение сопряжённого к $D_{x_0} h$ линейного отображения к вектору $\nabla_{h(x_0)} g$.

Эта формула — сердце механизма обратного распространения ошибки. Она говорит следующее: если мы каким-то образом получили градиент функции потерь по переменным из некоторого промежуточного представления $X^k$ нейронной сети и при этом знаем, как преобразуется градиент при проходе через слой $f^k$ между $X^{k-1}$ и $X^k$ (то есть как выглядит сопряжённое к дифференциалу слоя между ними отображение), то мы сразу же находим градиент и по переменным из $X^{k-1}$:

Таким образом слой за слоем мы посчитаем градиенты по всем $X^i$ вплоть до самых первых слоёв.

Далее мы разберёмся, как именно преобразуются градиенты при переходе через некоторые распространённые слои.

Градиенты для типичных слоёв

Рассмотрим несколько важных примеров.

Примеры

1. $f(x) = u(v(x))$, где $x$ — вектор, а $v(x)$ – поэлементное применение $v$:

   $$v\begin{pmatrix}
   x_1 \\
   \vdots\\
   x_N
   \end{pmatrix}
   = \begin{pmatrix}
   v(x_1)\\
   \vdots\\
   v(x_N)
   \end{pmatrix}$$

   Тогда, как мы знаем,

   $$\left[D_{x_0} f\right] (h) = \langle\nabla_{x_0} f, h\rangle = \left[\nabla_{x_0} f\right]^T h.$$

   Следовательно,

   $$
   \left[D_{v(x_0)} u\right] \left( \left[ D_{x_0} v\right] (h)\right) = \left[\nabla_{v(x_0)} u\right]^T \left(v'(x_0) \odot h\right) =\\
   $$

   $$
   = \sum\limits_i \left[\nabla_{v(x_0)} u\right]_i v'(x_{0i})h_i
   = \langle\left[\nabla_{v(x_0)} u\right] \odot v'(x_0), h\rangle.
   ,$$

   где $\odot$ означает поэлементное перемножение. Окончательно получаем

   $$\color{#348FEA}{\nabla_{x_0} f = \left[\nabla_{v(x_0)}u\right] \odot v'(x_0) = v'(x_0) \odot \left[\nabla_{v(x_0)} u\right]}$$

   Отметим, что если $x$ и $h(x)$ — это просто векторы, то мы могли бы вычислять всё и по формуле $\frac{\partial f}{\partial x_i} = \sum_j\big(\frac{\partial z_j}{\partial x_i}\big)\cdot\big(\frac{\partial h}{\partial z_j}\big)$. В этом случае матрица $\big(\frac{\partial z_j}{\partial x_i}\big)$ была бы диагональной (так как $z_j$ зависит только от $x_j$: ведь $h$ берётся поэлементно), и матричное умножение приводило бы к тому же результату. Однако если $x$ и $h(x)$ — матрицы, то $\big(\frac{\partial z_j}{\partial x_i}\big)$ представлялась бы уже «четырёхмерным кубиком», и работать с ним было бы ужасно неудобно.

2. $f(X) = g(XW)$, где $X$ и $W$ — матрицы. Как мы знаем,

   $$\left[D_{X_0} f \right] (X-X_0) = \text{tr}, \left(\left[\nabla_{X_0} f\right]^T (X-X_0)\right).$$

   Тогда

   $$
   \left[ D_{X_0W} g \right] \left(\left[D_{X_0} \left( \ast W\right)\right] (H)\right) =
   \left[ D_{X_0W} g \right] \left(HW\right)=\\
   $$ $$
   = \text{tr}\, \left( \left[\nabla_{X_0W} g \right]^T \cdot (H) W \right) =\\
   $$ $$
   =
   \text{tr} \, \left(W \left[\nabla_{X_0W} (g) \right]^T \cdot (H)\right) = \text{tr} \, \left( \left[\left[\nabla_{X_0W} g\right] W^T\right]^T (H)\right)
   $$

   Здесь через $\ast W$ мы обозначили отображение $Y \hookrightarrow YW$, а в предпоследнем переходе использовалось следующее свойство следа:

   $$
   \text{tr} , (A B C) = \text{tr} , (C A B),
   $$

   где $A, B, C$ — произвольные матрицы подходящих размеров (то есть допускающие перемножение в обоих приведённых порядках). Следовательно, получаем

   $$\color{#348FEA}{\nabla_{X_0} f = \left[\nabla_{X_0W} (g) \right] \cdot W^T}$$

3. $f(W) = g(XW)$, где $W$ и $X$ — матрицы. Для приращения $H = W — W_0$ имеем

   $$
   \left[D_{W_0} f \right] (H) = \text{tr} , \left( \left[\nabla_{W_0} f \right]^T (H)\right)
   $$

   Тогда

   $$
   \left[D_{XW_0} g \right] \left( \left[D_{W_0} \left(X \ast\right) \right] (H)\right) = \left[D_{XW_0} g \right] \left( XH \right) = \
   $$ $$
   = \text{tr} , \left( \left[\nabla_{XW_0} g \right]^T \cdot X (H)\right) =
   \text{tr}, \left(\left[X^T \left[\nabla_{XW_0} g \right] \right]^T (H)\right)
   $$

   Здесь через $X \ast$ обозначено отображение $Y \hookrightarrow XY$. Значит,

   $$\color{#348FEA}{\nabla_{X_0} f = X^T \cdot \left[\nabla_{XW_0} (g)\right]}$$

4. $f(X) = g(softmax(X))$, где $X$ — матрица $N\times K$, а $softmax$ — функция, которая вычисляется построчно, причём для каждой строки $x$

   $$softmax(x) = \left(\frac{e^{x_1}}{\sum_te^{x_t}},\ldots,\frac{e^{x_K}}{\sum_te^{x_t}}\right)$$

   В этом примере нам будет удобно воспользоваться формализмом с частными производными. Сначала вычислим $\frac{\partial s_l}{\partial x_j}$ для одной строки $x$, где через $s_l$ мы для краткости обозначим $softmax(x)_l = \frac{e^{x_l}} {\sum_te^{x_t}}$. Нетрудно проверить, что

   $$\frac{\partial s_l}{\partial x_j} = \begin{cases}
   s_j(1 — s_j),\ & j = l,\
   -s_ls_j,\ & j\ne l
   \end{cases}$$

   Так как softmax вычисляется независимо от каждой строчки, то

   $$\frac{\partial s_{rl}}{\partial x_{ij}} = \begin{cases}
   s_{ij}(1 — s_{ij}),\ & r=i, j = l,\
   -s_{il}s_{ij},\ & r = i, j\ne l,\
   0,\ & r\ne i
   \end{cases},$$

   где через $s_{rl}$ мы обозначили для краткости $softmax(X)_{rl}$.

   Теперь пусть $\nabla_{rl} = \nabla g = \frac{\partial\mathcal{L}}{\partial s_{rl}}$ (пришедший со следующего слоя, уже известный градиент). Тогда

   $$\frac{\partial\mathcal{L}}{\partial x_{ij}} = \sum_{r,l}\frac{\partial s_{rl}}{\partial x_{ij}} \nabla_{rl}$$

   Так как $\frac{\partial s_{rl}}{\partial x_{ij}} = 0$ при $r\ne i$, мы можем убрать суммирование по $r$:

   $$\ldots = \sum_{l}\frac{\partial s_{il}}{\partial x_{ij}} \nabla_{il} = -s_{i1}s_{ij}\nabla_{i1} — \ldots + s_{ij}(1 — s_{ij})\nabla_{ij}-\ldots — s_{iK}s_{ij}\nabla_{iK} =$$

   $$= -s_{ij}\sum_t s_{it}\nabla_{it} + s_{ij}\nabla_{ij}$$

   Таким образом, если мы хотим продифференцировать $f$ в какой-то конкретной точке $X_0$, то, смешивая математические обозначения с нотацией Python, мы можем записать:

   $$\begin{multline*}
   \color{#348FEA}{\nabla_{X_0}f =}\\
   \color{#348FEA}{= -softmax(X_0) \odot \text{sum}\left(
   softmax(X_0)\odot\nabla_{softmax(X_0)}g, \text{ axis = 1}
   \right) +}\\
   \color{#348FEA}{softmax(X_0)\odot \nabla_{softmax(X_0)}g}
   \end{multline*}
   $$

Backpropagation в общем виде

Подытожим предыдущее обсуждение, описав алгоритм error backpropagation (алгоритм обратного распространения ошибки). Допустим, у нас есть текущие значения весов $W^i_0$ и мы хотим совершить шаг SGD по мини-батчу $X$. Мы должны сделать следующее:

1. Совершить forward pass, вычислив и запомнив все промежуточные представления $X = X^0, X^1, \ldots, X^m = \widehat{y}$.
2. Вычислить все градиенты с помощью backward pass.
3. С помощью полученных градиентов совершить шаг SGD.

Проиллюстрируем алгоритм на примере двуслойной нейронной сети со скалярным output’ом. Для простоты опустим свободные члены в линейных слоях.

Обучаемые параметры – матрицы $U$ и $W$. Как найти градиенты по ним в точке $U_0, W_0$?

$$\nabla_{W_0}\mathcal{L} = \nabla_{W_0}{\left({\vphantom{\frac12}\mathcal{L}\circ h\circ\left[W\mapsto g(XU_0)W\right]}\right)}=$$

$$=g(XU_0)^T\nabla_{g(XU_0)W_0}(\mathcal{L}\circ h) = \underbrace{g(XU_0)^T}_{k\times N}\cdot
\left[\vphantom{\frac12}\underbrace{h’\left(\vphantom{\int_0^1}g(XU_0)W_0\right)}_{N\times 1}\odot
\underbrace{\nabla_{h\left(\vphantom{\int_0^1}g(XU_0)W_0\right)}\mathcal{L}}_{N\times 1}\right]$$

Итого матрица $k\times 1$, как и $W_0$

$$\nabla_{U_0}\mathcal{L} = \nabla_{U_0}\left(\vphantom{\frac12}
\mathcal{L}\circ h\circ\left[Y\mapsto YW_0\right]\circ g\circ\left[ U\mapsto XU\right]
\right)=$$

$$=X^T\cdot\nabla_{XU^0}\left(\vphantom{\frac12}\mathcal{L}\circ h\circ [Y\mapsto YW_0]\circ g\right) =$$

$$=X^T\cdot\left(\vphantom{\frac12}g'(XU_0)\odot
\nabla_{g(XU_0)}\left[\vphantom{\in_0^1}\mathcal{L}\circ h\circ[Y\mapsto YW_0\right]
\right)$$

$$=\ldots = \underset{D\times N}{X^T}\cdot\left(\vphantom{\frac12}
\underbrace{g'(XU_0)}_{N\times K}\odot
\underbrace{\left[\vphantom{\int_0^1}\left(
\underbrace{h’\left(\vphantom{\int_0^1}g(XU_0)W_0\right)}_{N\times1}\odot\underbrace{\nabla_{h(\vphantom{\int_0^1}g\left(XU_0\right)W_0)}\mathcal{L}}_{N\times 1}
\right)\cdot \underbrace{W^T}_{1\times K}\right]}_{N\times K}
\right)$$

Итого $D\times K$, как и $U_0$

Схематически это можно представить следующим образом:

Backpropagation для двуслойной нейронной сети

Подробнее о предыдущих вычисленияхЕсли вы не уследили за вычислениями в предыдущем примере, давайте более подробно разберём его чуть более конкретную версию (для $g = h = \sigma$).

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

$$
\widehat{y} = \sigma(X^1 W^2) = \sigma\Big(\big(\sigma(X^0 W^1 )\big) W^2 \Big).
$$

Пусть $W^1_0$ и $W^2_0$ — текущее приближение матриц весов. Мы хотим совершить шаг по градиенту функции потерь, и для этого мы должны вычислить её градиенты по $W^1$ и $W^2$ в точке $(W^1_0, W^2_0)$.

Прежде всего мы совершаем forward pass, в ходе которого мы должны запомнить все промежуточные представления: $X^1 = X^0 W^1_0$, $X^2 = \sigma(X^0 W^1_0)$, $X^3 = \sigma(X^0 W^1_0) W^2_0$, $X^4 = \sigma(\sigma(X^0 W^1_0) W^2_0) = \widehat{y}$. Они понадобятся нам дальше.

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

$$
l = \mathcal{L}(y, \widehat{y}) = y \log(\widehat{y}) + (1-y) \log(1-\widehat{y}).
$$

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

1. Градиент $\mathcal{L}$ по предсказаниям имеет вид

   $$
   \nabla_{\widehat{y}}l = \frac{y}{\widehat{y}} — \frac{1 — y}{1 — \widehat{y}} = \frac{y — \widehat{y}}{\widehat{y} (1 — \widehat{y})},
   $$

   где, напомним, $ \widehat{y} = \sigma(X^3) = \sigma\Big(\big(\sigma(X^0 W^1_0 )\big) W^2_0 \Big)$ (обратите внимание на то, что $W^1_0$ и $W^2_0$ тут именно те, из которых мы делаем градиентный шаг).

2. Следующий слой — поэлементное взятие $\sigma$. Как мы помним, при переходе через него градиент поэлементно умножается на производную $\sigma$, в которую подставлено предыдущее промежуточное представление:

   $$
   \nabla_{X^3}l = \sigma'(X^3)\odot\nabla_{\widehat{y}}l = \sigma(X^3)\left( 1 — \sigma(X^3) \right) \odot \frac{y — \widehat{y}}{\widehat{y} (1 — \widehat{y})} =
   $$

   $$
   = \sigma(X^3)\left( 1 — \sigma(X^3) \right) \odot \frac{y — \sigma(X^3)}{\sigma(X^3) (1 — \sigma(X^3))} =
   y — \sigma(X^3)
   $$

3. Следующий слой — умножение на $W^2_0$. В этот момент мы найдём градиент как по $W^2$, так и по $X^2$. При переходе через умножение на матрицу градиент, как мы помним, умножается с той же стороны на транспонированную матрицу, а значит:

   $$
   \color{blue}{\nabla_{W^2_0}l} = (X^2)^T\cdot \nabla_{X^3}l = (X^2)^T\cdot(y — \sigma(X^3)) =
   $$

   $$
   = \color{blue}{\left( \sigma(X^0W^1_0) \right)^T \cdot (y — \sigma(\sigma(X^0W^1_0)W^2_0))}
   $$

   Аналогичным образом

   $$
   \nabla_{X^2}l = \nabla_{X^3}l\cdot (W^2_0)^T = (y — \sigma(X^3))\cdot (W^2_0)^T =
   $$

   $$
   = (y — \sigma(X^2W_0^2))\cdot (W^2_0)^T
   $$

4. Следующий слой — снова взятие $\sigma$.

   $$
   \nabla_{X^1}l = \sigma'(X^1)\odot\nabla_{X^2}l = \sigma(X^1)\left( 1 — \sigma(X^1) \right) \odot \left( (y — \sigma(X^2W_0^2))\cdot (W^2_0)^T \right) =
   $$

   $$
   = \sigma(X^1)\left( 1 — \sigma(X^1) \right) \odot\left( (y — \sigma(\sigma(X^1)W_0^2))\cdot (W^2_0)^T \right)
   $$

5. Наконец, последний слой — это умножение $X^0$ на $W^1_0$. Тут мы дифференцируем только по $W^1$:

   $$
   \color{blue}{\nabla_{W^1_0}l} = (X^0)^T\cdot \nabla_{X^1}l = (X^0)^T\cdot \big( \sigma(X^1) \left( 1 — \sigma(X^1) \right) \odot (y — \sigma(\sigma(X^1)W_0^2))\cdot (W^2_0)^T\big) =
   $$

   $$
   = \color{blue}{(X^0)^T\cdot\big(\sigma(X^0W^1_0)\left( 1 — \sigma(X^0W^1_0) \right) \odot (y — \sigma(\sigma(X^0W^1_0)W_0^2))\cdot (W^2_0)^T\big) }
   $$

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

Автоматизация и autograd

Итак, чтобы нейросеть обучалась, достаточно для любого слоя $f^k: X^{k-1}\mapsto X^k$ с параметрами $W^k$ уметь:

• превращать $\nabla_{X^k_0}\mathcal{L}$ в $\nabla_{X^{k-1}_0}\mathcal{L}$ (градиент по выходу в градиент по входу);
• считать градиент по его параметрам $\nabla_{W^k_0}\mathcal{L}$.

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

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

Но это лишь начало

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

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

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

-Равичандра, исследователь компьютерного зрения, @ Sally Robotics.

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

1. Исчезающие градиенты. Сигмоидная и тангенциальная нелинейности имеют тенденцию к насыщению и полностью прекращают обучение. Это происходит, когда выходы нейрона находятся на крайних значениях, в результате чего градиенты равны 0 или близки к 0, то есть исчезают. При использовании ReLU, если нейроны будут ограничены до 0, тогда веса будут иметь нулевые градиенты, что приведет к так называемой проблеме «мертвого ReLU».

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

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

Хотя они остаются основными недостатками, существуют и другие, такие как выбор гиперпараметров и т. Д., Которые классифицируют скорее как раздражение, чем как недостатки. Итак, что мы тогда с этим сделали? Мы разработали более совершенную сетевую архитектуру, чтобы избежать этих проблем. Архитектура ResNet (https://arxiv.org/abs/1512.03385) — лучший пример, где были созданы пропускаемые соединения, чтобы избежать исчезающих градиентов.

Обратное распространение — ошибочный подход?

Многие известные исследователи, такие как Джеффри Хинтон и Йошуа Бенжио, выразили обеспокоенность по поводу того, что обратное распространение не является идеальным подходом. Нет никаких доказательств того, что наш мозг выполняет обратное распространение, и если это так, как тогда мы можем достичь полного искусственного интеллекта, если мы не моделируем сети по образцу нашего собственного биологического разума? Вопрос о более биологически правдоподобном алгоритме все еще остается, и эта идея дополнительно исследуется в этой статье: https://arxiv.org/abs/1502.04156.

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

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

— Джеффри Хинтон

Альтернативы

1. Распространение разностной цели

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

а. Формулирование целей

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

c. Разница в целевом распространении

d. Обучение автокодировщика с разностным целевым распространением

Хотя это очень абстрактное и высокоуровневое описание метода, я намеренно сохранил его, чтобы углубление в математику и уравнения излишне удлинило статью. Точную математику этого можно найти в этой статье https://arxiv.org/pdf/1412.7525.pdf.

2. Узкое место HSIC (критерий независимости Гильберта-Шмидта)

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

На приведенном выше рисунке представлен обзор того, как проводится обучение с использованием HSIC. Сеть, обученная HSIC, рисунок (a), представляет собой стандартную сеть с прямой связью, обученную с использованием цели HSIC IB, что приводит к скрытым представлениям на последнем уровне, которые можно быстро обучить. На рисунке (b) показана σ-объединенная сеть, где каждая ветвь сети HSIC-net обучается определенному σ.

На следующем этапе будет найдена и развернута замена взаимной информации между скрытыми представлениями и метками. Это одновременно минимизирует взаимную зависимость между скрытыми представлениями и входными данными. Таким образом, каждое скрытое представление из сети, обученной HSIC, может содержать различную информацию, полученную путем оптимизации цели узкого места HSIC в конкретном масштабе. Затем агрегатор суммирует скрытые представления, чтобы сформировать выходное представление. Дополнительную информацию можно найти здесь https://arxiv.org/pdf/1908.01580v1.pdf.

В чем тогда преимущества? Авторы утверждают, что это облегчает параллельную обработку, требует значительно меньше операций и не страдает от исчезающих или взрывающихся градиентов. Более того, это кажется более вероятным с биологической точки зрения, чем обратное распространение. После тестирования сети, обученные HSIC, работали сравнимыми с обратным распространением в наборах данных MNIST и CIFAR-10.

3. Чередующаяся минимизация в режиме онлайн с помощью вспомогательных переменных.

Основным вкладом этой работы является новый онлайновый (стохастический / мини-пакетный) подход с чередующейся минимизацией (AM) для обучения глубоких нейронных сетей вместе с первыми гарантиями теоретической сходимости для AM в стохастических настройках. Это решает проблему оптимизации, разрывая цепочки градиентов с помощью вспомогательных переменных. Эта работа основана на ранее предложенных автономных методах, которые разбивают вложенную цель на более простые для решения локальные подзадачи путем вставки вспомогательных переменных, соответствующих активациям на каждом уровне. Подробнее об этом можно прочитать здесь https://arxiv.org/pdf/1806.09077.pdf.

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

4. Разделение нейронных интерфейсов с использованием синтетических градиентов.

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

Правомерным вопросом было бы спросить, сколько вычислительной сложности добавляют эти синтетические градиентные модели — возможно, вам понадобится архитектура синтетической градиентной модели, столь же сложная, как сама сеть. Удивительно, но синтетические градиентные модели могут быть очень простыми. Для сетей с прямой связью было фактически обнаружено, что даже один линейный слой хорошо работает в качестве модели синтетического градиента. Следовательно, его очень легко обучить, и поэтому он быстро создает синтетические градиенты. Подробнее можно прочитать здесь https://arxiv.org/pdf/1608.05343.pdf.

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

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

— Рэй Курцвейл

Заключение

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

Ресурсы

Https://analyticsindiamag.com/lets-not-stop-at-back-prop-check-out-5-alternatives-to-this-popular-deep-learning-technique/

Https://analyticsindiamag.com/is-deep-learning-possible-without-back-propagation/

Https://deepmind.com/blog/article/decoupled-neural-networks-using-synthetic-gradients

Https://www.ibm.com/blogs/research/2019/06/beyond-backprop/

Https://arxiv.org/pdf/1412.7525.pdf

Https://arxiv.org/pdf/1908.01580v1.pdf

Https://arxiv.org/pdf/1806.09077.pdf

Https://arxiv.org/pdf/1608.05343.pdf