Обсуждение участника:Mishenkoil

Материал из Викиконспекты
Перейти к: навигация, поиск

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

Инициализация сети

Принцип выбора начальных значений весов для слоев, составляющих модель очень важен: установка всех весов в 0 будет серьезным препятствием для обучения, так как ни один из весов изначально не будет активен. Присваивать весам значения из интервала [math][-1, 1][/math] — тоже обычно не лучший вариант — на самом деле, иногда (в зависимости от задачи и сложности модели) от правильной инициализации модели может зависеть, достигнет она высочайшей производительности или вообще не будет сходиться. Даже если задача не предполагает такой крайности, удачно выбранный способ инициализации весов может значительно влиять на способность модели к обучению, так как он предустанавливает параметры модели с учетом функции потерь[1].

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

Инициализация случайными числами

Рассмотрим линейный нейрон:

  • [math]y=w^Tx+b=\sum(w_i x_i)+b=\sum(y_i)+b[/math]

Его дисперсия (считаем настраиваемые параметры и входные данные независимыми):

Если отнормировать входные данные и подобрать настраиваемые параметры, чтобы среднее было нулевым, получится:

  • [math](\mathrm{E}[x_i]=0, \mathrm{E}[w_i]=0) \Rightarrow \mathrm{Var}[y_i]=\mathrm{Var}[w_i]\mathrm{Var}[x_i][/math]

Поскольку $x_i$ мы отнормировали, а $w_i$ из одного распределения, то все дисперсии одинаковые:

  • [math]\mathrm{Var}[y]=\mathrm{Var}[\sum\limits_{i=1}^{n_{in}}[y_i]]=\sum\limits_{i=1}^{n_{in}}[w_i x_i]=n_{in} \mathrm{Var}[w_i]\mathrm{Var}[x_i][/math]

Отсюда видно, что дисперсия результата линейно зависит от дисперсии входных данных с коэффициентом $n_{in} \mathrm{Var}[w_i]$.

Если коэффициент будет $>1$ это приведет к увеличению дисперсии с каждым новым преобразованием, что может привести к ошибкам или насыщению функции активации, что негативно скажется на обучении сети.

Если коэффициент будет $<1$ это приведет к снижению дисперсии с каждым новым преобразованием с около нулевым промежуточным представлением, что тоже негативно скажется на обучении сети.

Поэтому для начальной инициализации настраиваемых параметров стоит использовать такое распределение, что $\mathrm{Var}[w_i]=\frac{1}{n_{in}}$, которое позволит сохранить дисперсию входных данных.

Метод инициализации Xavier[2].

Предыдущий подход хорошо работает, когда размерность наших данных не изменяется после преобразований $(n_{in} == n_{out})$, но так бывает не всегда. В качестве компромисса Xavier Glorot и Yoshua Bengio предлагают инициализировать параметры из распределения с дисперсией $\mathrm{Var}[w_i]=\frac{2}{n_{in}+n_{out}}$.

Для равномерного распределения $U$ это будет:

  • [math]w_i \sim U[-\frac{\sqrt{6}}{\sqrt{n_{in}+n_{out}}},\frac{\sqrt{6}}{\sqrt{n_{in}+n_{out}}}][/math]

Для нормального распределения $N$ это будет:

  • [math]w_i \sim N(0,\frac{2}{n_{in}+n_{out}})[/math]

Этот способ инициализации хорошо подойдет для симметричных относительно нуля функций активации (гиперболический тангенс, сигмоид), для ReLU[3] данный способ не подходит.

Метод инициализации He

Поскольку ReLU несимметричная функция $f(x) = max(0, x)$, мы уже не можем утверждать, что среднее значение входных данных в каждом преобразовании будет нулевым:

  • [math](\mathrm{E}[x_i] \neq 0, \mathrm{E}[w_i]=0)[/math]
    [math]\Rightarrow \mathrm{Var}[y_i]=\mathrm{E}[x_i]^2\mathrm{Var}[w_i] + \mathrm{Var}[w_i]\mathrm{Var}[x_i]=\mathrm{Var}[w_i](\mathrm{E}[x_i]^2 + \mathrm{Var}[x_i])=\mathrm{Var}[w_i]\mathrm{E}[x_i^2][/math]
    [math]\Rightarrow \mathrm{Var}[y]=n_{in}\mathrm{Var}[w_i]\mathrm{E}[x_i^2][/math]

Поэтому мы будем пытаться контролировать дисперсию не между слоями, а между функциями активации ReLU. Пусть представление на входе было получено после применения данной функции активации к предыдущему представлению $y_{prev}$:

  • [math]x=\mathrm{ReLU}(y_{prev})[/math]

Тогда с учётом поведения ReLU и того, что $\mathrm{E}(y_{prev})=0$, можно сказать, что:

  • [math]\mathrm{E}[x_i^2]=\frac{1}{2}\mathrm{Var}[ y_{prev}][/math]
    [math]\Rightarrow \mathrm{Var}[y]=\frac{1}{2}n_{in}\mathrm{Var}[w_i]\mathrm{Var}[y_{prev}][/math]

Получается, что при использовании ReLU, нужно инициализировать параметры из распределения с дисперсией $\mathrm{Var}[w_i]=\frac{2}{n_{in}}$. Для нормального распределения $N$ это будет:

  • [math]w_i \sim N(0,\frac{2}{n_{in}})[/math]

Граф вычислений

Глубокие сети являются особенной формой графа вычиcлений.

Рис.1. Граф вычислений для функции [math]f(a,b)=(a+b)*(b+1)[/math]

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

Значения, которые вводятся в узлы и выходят из узлов, называются тензорами (т.е. многомерными массивами). На рисунке 1 представлен граф вычислений для функции [math]f(a,b)=(a+b)*(b+1)[/math]. В нейронах сетях функций имеют больше аргументов и сложнее, но смысл операций остаётся прежним.

Процесс передачи значений от входных нейронов к выходным называется прямым распространением (от англ. Forward pass). После чего мы вычисляем ошибку обработанных сетью данных на выходном нейроне и, основываясь на её значении, делаем обратную передачу ошибки (Back propagation). Обратное распространение ошибки заключается в том, чтобы последовательно менять настраиваемые параметры нейронной сети, начиная с параметров выходного нейрона. Значения параметров будут меняться в сторону уменьшения ошибки.

Рис.2. Граф вычислений для функции [math]f(x,y,z)=(x+y)*z[/math]. Зелёные цифры — значения вычислений по ходу выполнения операций графа, красные — значения производной выходной функции по текущей переменной в точке [math](x_0=-2, y_0=5, z_0=-4)[/math]


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

  • [math]q=x+y:\frac{\partial q}{\partial x}=1, \frac{\partial q}{\partial y}=1;[/math];
  • [math]q=xy:\frac{\partial q}{\partial x}=y, \frac{\partial q}{\partial y}=x;[/math];
  • [math]\frac{\partial f}{\partial y}=\frac{\partial f}{\partial q}\frac{\partial q}{\partial y}[/math].

Рассмотрим граф вычислений на рисунке 2 с поданными на вход значениями [math](x_0=-2, y_0=5, z_0=-4)[/math]. Подсчёт производных по графу вычислений производим от значения функции к значениям независимых переменных-входов.

  • [math]\frac{\partial f}{\partial f} = 1[/math];
  • [math]\frac{\partial f}{\partial q} = z_0 = -4[/math], [math]\frac{\partial f}{\partial z} = q_0 = 3[/math];
  • [math]\frac{\partial f}{\partial x} = \frac{\partial f}{\partial q}\frac{\partial q}{\partial x} = -4[/math], [math]\frac{\partial f}{\partial y} = \frac{\partial f}{\partial q}\frac{\partial q}{\partial y} = -4[/math].


Граф вычислений является частью нейронной сети, у которой [math]x_{n_{in}}[/math] — входные значения, [math]y_{n_{out}}[/math] — выходные с сети значения, [math]w[/math] — матрица параметров, приводящая значения предыдущего преобразования к выходным значениям.

Зная производные, можно искать матрицы параметров [math]w[/math] (числа, на которые умножаются входные для этого преобразования значения) с помощью градиентного спуска сдвигаемся в сторону градиента (при максимизации) или обратную ему (при минимизации) [math]w^{(k+1)}=w^{(k)}-\eta \frac{\partial L(w^{(k)})}{\partial w^{(k)}}[/math], где [math]L[/math] — функция потерь, а [math]w^{(k)}[/math] — параметры после [math]k[/math]-ой итерации, или его модификаций[4].

Способы настройки параметров

Рис.3. Сравнение модификаций метода градиентного спуска на ландшафте "бассейны и стены"[5].
Рис.4. Сравнение модификаций метода градиентного спуска на "шатком" ландшафте[6].

Ниже представлены различные вариации градиентного спуска (более подробное сравнение, применительно к данной задаче [7]). Градиентный спуск — итеративный алгоритм поиска минимума или максимума функции, метриками качества алгоритма этого семейства методов являются скорость сходимости и сходимость в глобальный оптимум. Методы имеют различные преимущества на различных функциях. Так например на рисунке 3 из локального минимума метод adam и метод Нестерова не могут достигнуть глобального, а в случае "шаткого" ландшафта (рисунок 4) эти методы сходятся быстрее.


  • Модификация Momentum [8] запоминает скорость на предыдущем шаге и добавляет в [math]\alpha[/math] раз меньшую величину на следующем шаге: [math] v^{(k+1)}=\alpha v^{(k)} -\eta \frac{\partial L(w^{(k)})}{\partial w^{(k)}}[/math], [math] w^{(k+1)}=w^{(k)}+v^{(k)}[/math];


  • Метод Нестерова (англ. Nesterov accelerated gradient, NAG)[9] добавляет к методу Momentum идею "заглядывания вперёд", используя производную не в текущей точке, а в следующей (если бы мы продолжали двигаться в этом же направлении без измений): [math] w^{(k+1)} = w^{(k)}-v^{(k)}; v^{(k+1)}=\gamma v^{(k)}+\mu\frac{\partial L(w^{(k)}-v^{(k)})}{\partial w}[/math];


  • Adagrad имеет преимущество в плане обучения нейронных сетей в предположении, что процесс обучения должен сходится (т.е. не нужно сильно менять настраиваемые параметры сети, когда мы уже немного научились). В процессе обучения после каждого прецендента алгоритм будет уменьшать шаг за счёт суммы квадратов координат градиента предыдущих итераций[10]: [math]g_i^{(k)}=\frac{\partial L(w_i^{(k)})}{\partial w_i^{(k)}}, w_i^{(k+1)}=w_i^{(k)}-\frac{\mu}{\sqrt{G^{(k)}_{i,i}+\epsilon}}g_{i}^{(k)}[/math], где [math]G[/math] — диагональная матрица, элементы которой, суммы квадратов координат градиента к [math]k[/math]-ой итерации алгоритма: [math]G_{i,i}^{(k)} = \sum_{t=0}^k (g_i^{(t)})^2[/math];


  • RMSProp[11] основан на идее Adagrad'a, но с учётом того элементы матрицы [math]G[/math] могут быть большими величинами и начать препятствовать обучению. Для этого RMSProp делит шаг не на полную сумму градиентов, а на скользящую, т.е. [math]E_i^{(k)} = \gamma E_i^{(k-1)}+(1-\gamma)(g_{i}^{(k)})^2[/math], обновление параметров осталось таким же как в Adagrad : [math] w_i^{(k+1)} = w_i^{(k)}-\frac{\mu}{\sqrt{E_i^{(k)}+\epsilon}}g_{i}^{(k)}[/math];


  • Adadelta[12] устраняет "нефизичность" методов Adagrad и RMSProp, добавка с градиентом в которых не имеет размерности параметров(точнее вообще безразмерна). Умножение этого слагаемого на любую величину правильной размерности — не самая хорошая идея. Используем разложение ряда Тейлора в точке с большим числом членов, тогда появится матрица [math]Q[/math] вторых производных функции потерь: [math]w^{(k+1)}=w^{(k)}-\mu(Q(w^{(k)})^{-1}Q(w^{(k)}))[/math], расчёт которой повлечёт за собой дополнительные затраты на её расчёт (сами градиенты мы получаем сразу при обратном распространении ошибки), поэтому вместо неё можно брать приближение (из сложных выводов получаем необходимый множитель [math]RMS^{(k-1)}[\delta w_i][/math]), однако в данном случае знание предыдущей скорости не добавляет алгоритму "инерции" методов Momentum и NAG): [math]w^{(k+1)}=w^{(k)}-\frac{RMS^{(k-1)}[\delta w_i]}{RMS^{(k)}[g_i]}g_i^{(k)}[/math], где [math]RMS^{(k)}[x_i]=\sqrt{E^{(k)}[x^2_i]+\epsilon}[/math];


  • Adam[13] сочетает в себе преимущества NAG и Adadelta над обычным градиентным спуском: [math] w^{(k+1)}_i = w_i^{(k)}-\frac{\mu}{\sqrt{\hat{b}^2_{(k)}+\epsilon}}\hat{m}_{(k)}[/math], где [math]\hat{m}_{(k)}=\frac{\gamma_1 E^{(k-1)}[g_i]+(1-\gamma_1)g_{i,(k)}}{1-\gamma_1^k}[/math] и [math]\hat{b}^2_{(k)}= \frac{\gamma_2 E^{(k-1)}[g^2_i]+(1-\gamma_2)g:2_{i,(k)}}{1-\gamma_2^k}[/math].

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

Сравнение разных методов на седловой функции

Рассмотрим график седловой функции с "седлом" в точке [math](0, 0, 0)[/math]. Предположим, что в качестве начальной точки выбрана точка [math](0, y, z)[/math], где [math]y \gt 0, z \gt 0[/math]. На рисунке координата [math]x[/math] варьируется в пределах от [math]-1.5[/math] до [math]1[/math], координата [math]y \in [-0.5; 1][/math], а координата [math]z \in [-4; 4][/math]. Рассмотрим работу описанных выше методов, примененных к данной оптимизируемой функции с данной начальной точкой:

  • SGD (Стандартный градиентный спуск без оптимизаций) никак не учитывает тот факт, что по координате [math]x[/math] производная в данной точке пренебрежимо мала по сравнению с производной по [math]y[/math]. Поэтому через малое число итераций алгоритм сойдется в окрестности седловой точки [math](0, 0, 0)[/math] и остановится, потому что производная в данной точке нулевая.
  • Momentum. Так как добавится инерция, то спуск в сторону седловой точки будет значительно быстрее, чем в случае со стандартным градиентным спуском. Однако, оптимизируемая переменная будет еще долго колебаться в плоскости [math]x = 0[/math], накапливая градиенты. При этом колебания будут затухать из-за того, что параметр [math]\alpha \lt 1[/math], но т.к. оптимизируемая переменная несколько раз отдалится от точки [math](0, 0, 0)[/math] на достаточное расстояние, успеет накопиться значение производной по координате [math]x[/math], достаточное для того чтобы выйти из локального минимума. Однако для этого потребуется большое число итераций, необходимое для того, чтобы производная по [math]y[/math] перестала преобладать над производной по [math]x[/math].
  • NAG. Эффект будет схожим с алгоритмом Momentum, однако спуск в плоскости [math]y = 0[/math] будет происходить быстрее благодаря заглядыванию вперед.
  • Adagrad. Изначально спуск будет происходить медленнее, чем при использовании SGD из-за нормирования градиента по всем координатам, однако метод сойдется в глобальном минимуме выбранной области графика.
  • RMSProp. Изначально процесс оптимизации почти совпадает с Adagrad, но в области, где функция начинает сильно убывать, благодаря использованию скользящей суммы градиентов (то есть благодаря тому, что мы забываем старые изменения и больше учитываем новые) алгоритм RMSProp оптимизирует переменную быстрее, чем Adagrad.
  • Adadelta. Использует все преимущества RMSProp, но при этом в данном случае сходится быстрее в [math]RMS[\delta w_i][/math] раз.

См.также

Примечания

Источники информации

  1. Курс лекций по машинному обучению — Воронцов К.В.
  2. Онлайн-учебник по машинному обучению от ШАД
  3. Riedmiller, M., & Braun, H. (1993). A direct adaptive method for faster backpropagation learning: The RPROP algorithm. In Neural Networks, 1993., IEEE International Conference on (pp. 586-591). IEEE.