Как учится машина. Революция в области нейронных сетей и глубокого обучения - Ян Лекун

в направлении w[1] – это отношение (b – h) / dw. Сохраним два угла наклона в векторе g:

g[0]= (a – h)/dw

g[1]= (b – h)/dw

Вектор g называется градиентом функции стоимости. Он содержит вектор, составленный из наклонов по каждой оси. Данный вектор указывает на направление наибольшего наклона вверх. Используя метафору горного ландшафта, если наклон в направлении восток-запад (w[0]) больше, чем в направлении север-юг (w[1]), направление большего уклона будет ближе от оси восток-запад, чем от оси север-юг.

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

# функция расчета градиента через помехи

# X: таблица входов набора данных

# Y: таблица желаемых выходов

# W: вектор параметров

# Dw: помеха

def gradient (X, Y, w, dw):

h = L (X, Y, w) # расчет стоимости

wa = [0,0] # создаем вектор wa

wa [0] = w[0] + dw # помеха 1-й координаты

wa [1] = w[1]

a = L (X, Y, wa) # расчет стоимости после помехи

wb = [0,0] # создаем вектор wb

wb [0] = w[0]

wb [1] = w[1] + dw # помеха 2-й координаты

b = L (X, Y, wb) # расчет стоимости после помехи

g = [0,0] # создаем вектор g

g [0] = (a – h) / dw # наклон по 1-й координате

g [1] = (b – h) / dw # наклон по 2-й координате

return g # вернуть вектор градиента

Мы получаем приближение вектора градиента:

g = gradient(X, Y, w, dw)

По определению этот вектор g указывает вверх, но вектор – g, полученный инвертированием знаков его компонентов, указывает вниз в противоположном направлении. Таким образом, мы можем двигаться к дну долины в направлении наибольшего уклона, шагая в направлении, противоположном наклону. Это соответствует шагу размера – e*g[0] в направлении w[0] (восток-запад) и размера -e * g[1] в направлении w[1] (север-юг), где переменная e представляет собой небольшое положительное число, которое определяет размер шага, который необходимо выполнить.

Все это выполняется функцией в нескольких инструкциях:

# сделать шаг градиента

# X: таблица входов набора данных

# Y: таблица желаемых выходов

# w: вектор параметров

# e: без градиента

# dw: помеха

def descend (X, Y, w, e, dw):

g = gradient (X, Y, w, dw) # вычисление вектора

# градиента

w[0] = w[0] – e * g [0] # обновить w[0]

w[1] = w[1] – e * g [1] # обновить w[1]

return w # вернуть новый вектор параметров

Этапы обучения по градиентному спуску состоят из:

1) расчета стоимости;

2) расчета градиента;

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

При повторении данной процедуры и при условии, что шаг градиента достаточно мал, процедура «сходится» ко дну долины.

# процедура обучения

# n: количество итераций градиентного спуска

def learn (X, Y, w, e, dw, n):

for i in range (n): # повторить n раз

w = descend (X, Y, w, e, dw) # сделать шаг

print (L (X, Y, w)) # вывести стоимость

return w # вернуть вектор веса

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

Градиентный спуск на практике

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

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

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

def градиент (X, Y, w, dw):

h = L(X, Y, w)

for i in range (len(w)): # цикл по размерам

wa = w

wa[i] = w[i] + dw

a = L(X, Y, wa)

g[i] = (a – h)/dw

return g

Данная функция должна пересчитывать значение L после каждой помехи. Если бы у нас было 10 млн параметров, нам пришлось бы пересчитывать L 10 млн раз … Это просто нереально.

Гораздо более эффективный способ вычисления градиента без создания помех – это аналитический метод вычисления градиента. Он сводится к вычислению производных стоимости в направлении каждой из осей без помех.

Возьмем простой многочлен второй степени:

c(x, y, w) = (y – w * x) ** 2

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

dc_dw(x, y, w) = –2 * (y – w * x) * x = 2 *(x ** 2) * w – 2 * y * x

Не нужно изменять w, чтобы узнать наклон c(x, y, w) в любой точке: он задается его производной.

Теперь давайте возьмем двумерную линейную модель, функция входа-выхода которой:

f(x, w) = w[0] * x[0] + w[1] + x[1]

и рассмотрим квадратичную функцию стоимости (т. е. функцию с квадратом):

C(x, y, w) = (y – f(x, w)) ** 2 = (y – (w[0] * x[0] + w[1] * x[1])) ** 2

Мы можем вычислить производную этой функции по w[0], считая другие символы константами.

Данная производная будет отмечена: dc_dw[0]

dc_dw[0] = –2 * (y – (w[0] * x[0] + w[1] * x[1])) * x[0]

Мы можем сделать то же самое для производной по отношению к w[1], которая является вычислением производной.

dc_dw[1] = –2 * (y – (w[0] * x[0] + w[1] * x[1])) * x[1]

Вектор, компонентами которого являются эти два значения, будет градиентом C(x, y, w) по отношению к w. Это вектор того же размера, что и вектор параметров, каждый компонент которого содержит производную по соответствующему параметру, то есть наклон функции при движении в измерении рассматриваемого параметра.

dc_dw = [dc_dw[0], [dc_dw[1]]

Производная функции нескольких переменных по одной из