Вниз по склону: Gradient Descent и два шага, которые все пропускают

Повторим, чтобы эта глава читалась самостоятельно: восемь деталей с конвейера из главы 1, но с другим вопросом. Не принять или отклонить — это вернётся позже, — а предсказать вес детали по её ширине.

import numpy as np

WIDTH  = np.array([18.0, 19.5, 20.2, 21.0, 24.0, 25.5, 23.0, 26.0])
WEIGHT = np.array([47.0, 52.0, 49.0, 55.0, 61.0, 66.0, 70.0, 58.0])

x = WIDTH  - WIDTH.mean()      # 22.15 mm
y = WEIGHT - WEIGHT.mean()     # 57.25 g

Измерения центрированы, ровно как в главе 1 и по причине, которая с процентами вернётся до конца этой главы. Модель — прямая, $\hat{y} = a x + b$, а функция потерь — среднеквадратичная ошибка, которую вывела предыдущая глава:

Два параметра. Почему бы просто не попробовать много значений? Давайте правда попробуем — сетку от $a = 0$ до $5$ и от $b = -5$ до $5$ с шагом $0.01$:

grid 501 x 1001 = 501,501 evaluations in 3.67 s
  best found: a = 2.1000, b = -0.0000, L = 24.592450

Полмиллиона вычислений, чтобы зафиксировать два числа с точностью до двух знаков после запятой, — и эта секунда является временем на одной конкретной машине, так что повторный запуск окажется где-то между тремя и шестью; воспроизводятся число вычислений и минимум. Gradient descent к концу этой главы получает четыре знака после запятой за восемь шагов и полный ответ float64 за тридцать шесть.

Но скорость — не главный аргумент, и именно этот пункт решает судьбу всего курса. Grid search стоит $k^P$ вычислений для $P$ параметров при $k$ значениях каждого. Если взять тысячу значений на ось:

Третья строка — не большое число, а бессмысленное: в наблюдаемой Вселенной примерно $10^{80}$ атомов. Поиск не становится медленнее по мере роста моделей; он перестаёт существовать. Всё, что дальше, существует из-за этой таблицы.

На мгновение зафиксируйте $b = 0$, чтобы остался один параметр и одна кривая — та самая картинка, которой закончилась прошлая глава. Возьмите на ней точку, $a = 1$, и спросите: если я сдвину $a$ на небольшую величину $h$, насколько изменится функция потерь на единицу сдвига?

Это отношение — подъём к пробегу, наклон прямой через две точки на кривой. Когда $h$ уменьшается, две точки сходятся, и прямая становится касательной. Её наклон — производная $L'(a)$: скорость, с которой функция потерь меняется на единицу изменения $a$. Не приближение к чему-то и не бесконечно малая величина. Предел обычных отношений.

Стоит это запустить, потому что числа говорят то, чего не говорит определение:

def loss1(a):
    return np.mean((a * x - y) ** 2)

for h in [1.0, 1e-2, 1e-4, 1e-6, 1e-8, 1e-10, 1e-12, 1e-14]:
    q = (loss1(1.0 + h) - loss1(1.0)) / h
    print(f"h = {h:<8.0e}   slope estimate = {q:.10f}   error = {abs(q + 16.385):.3e}")

h = 1e+00      slope estimate = -8.9400000000    error = 7.445e+00
h = 1e-02      slope estimate = -16.3105500000   error = 7.445e-02
h = 1e-04      slope estimate = -16.3842555001   error = 7.445e-04
h = 1e-06      slope estimate = -16.3849925556   error = 7.444e-06
h = 1e-08      slope estimate = -16.3850003787   error = 3.787e-07
h = 1e-10      slope estimate = -16.3850444324   error = 4.443e-05
h = 1e-12      slope estimate = -16.3851154866   error = 1.155e-04
h = 1e-14      slope estimate = -17.0530256582   error = 6.680e-01

Здесь происходят две вещи, и обе несущие.

Ошибка не смутно пропорциональна $h$ — она равна ровно $7.445\,h$. Разделите $h$ на сто, ошибка разделится на сто, каждый раз до четырёх значащих цифр. Эта константа не украшение: это половина второй производной функции потерь, и это первое появление идеи, к которой мы придём через два раздела, — что кривая рядом с точкой выглядит как прямая плюс поправка, пропорциональная $h^2$.

А затем закономерность ломается. Ниже $h = 10^{-8}$ оценка становится хуже, а при $10^{-14}$ она неверна уже во второй цифре. Ничего математического не произошло; сработала коробка с floating point из прошлой главы. $L(a+h)$ и $L(a)$ совпадают в первых десяти цифрах, их вычитание уничтожает эти цифры, а деление обломков на крошечное число усиливает то, что осталось. Есть лучший $h$ — здесь около $10^{-8}$, примерно квадратный корень из машинного epsilon, — и брать меньше не значит быть осторожнее, а значит быть менее осторожным. Запомните это: функция в конце главы от этого зависит.

Точный наклон, из calculus, а не из измерения, равен $-16.385$. Так что можно перестать измерять и начать выводить.

Вот идея, на которой построена вся оставшаяся часть курса, сформулированная один раз и прямо.

Скомпоновать две функции — значит подать одну на вход другой: $(f \circ g)(x) = f(g(x))$. И всё.

Глубокая сеть не похожа на композицию. Она и есть композиция. Слой — это функция; складывать слои стопкой — значит компоновать их; «глубина» — это число функций в цепочке. Когда глава 5 строит сеть, она строит $f_4 \circ f_3 \circ f_2 \circ f_1$ и ничего больше. А значит, самое важное для нас правило calculus — то, которое дифференцирует композицию:

Скорости перемножаются. Если $g$ меняется в три раза быстрее, чем $x$, а $f$ меняется в два раза быстрее, чем $g$, то $f$ меняется в шесть раз быстрее, чем $x$. В этом всё содержание, и поэтому сигнал, проходя назад через десять слоёв, умножается на десять чисел — вот почему глава 6 выделяет раздел на то, что происходит, когда все эти числа чуть меньше единицы.

Применим это к нашей функции потерь. Запишем residual $r_i = a x_i + b - y_i$, так что $L = \frac{1}{n}\sum r_i^2$. Каждый $r_i$ зависит от $a$ через внутреннюю функцию $a x_i$, производная которой равна $x_i$. Chain rule, слагаемое за слагаемым:

Эти фигурные символы $\partial$ обозначают частную производную: дифференцируйте по одной переменной, а все остальные считайте константами. Ничего нового не происходит — это тот же предел, что и раньше, только взятый вдоль одной оси. Соберите частные производные в вектор, и у вас получится градиент:

В точке $(a, b) = (1, 4)$ этот вектор равен $(-16.385,\ 8.0)$. Два числа. Вопрос в том, что они означают, и это первый шаг, который все пропускают.

Градиент — это вектор наклонов вдоль осей. Это всё, что мы доказали. Не очевидно — и не должно быть очевидно, — что если собрать их в вектор, получится что-то, указывающее в каком-то конкретном направлении.

Поэтому определим то, что нам на самом деле нужно. Выберите единичный вектор $\mathbf{u}$, направление. Производная по направлению — это скорость, с которой меняется функция потерь, когда вы идёте в эту сторону:

Chain rule превращает это во что-то вычислимое. Движение вдоль $\mathbf{u}$ меняет $a$ со скоростью $u_1$ и $b$ со скоростью $u_2$, а вклады складываются:

Скорость изменения в любом направлении — это скалярное произведение градиента с этим направлением. А теперь развязка, одна строка геометрии. Запишем скалярное произведение через угол $\phi$ между векторами:

поскольку $\mathbf{u}$ имеет длину 1. Единственное, чем вы управляете, — это $\cos\phi$, максимальный при $\phi = 0$ и минимальный при половине оборота, $\phi = 180$ градусах. Поэтому:

• Самый крутой подъём идёт вдоль самого $\nabla L$, и наклон там ровно $\lVert \nabla L \rVert$.
• Самый крутой спуск идёт вдоль $-\nabla L$, и наклон там равен $-\lVert \nabla L \rVert$.
• Перпендикулярно градиенту функция потерь вообще не меняется. Поэтому линии на карте уровней пересекают градиент под прямым углом.

Вот откуда знак минус. Не условность, не выбранная кем-то смена знака: направление самого быстрого уменьшения — отрицательный градиент, потому что $\cos\phi$ минимизируется при половине оборота, и ни по какой другой причине.

Поскольку это утверждение обо всех направлениях, проверим его на всех направлениях. Возьмём 3 600 из них, по одному на каждую десятую градуса, и измерим каждое небольшим сдвигом:

theta = np.array([1.0, 4.0])
g = grad(theta)
print("gradient      ", g)
print("its length    ", np.linalg.norm(g))
print("its angle     ", np.degrees(np.arctan2(g[1], g[0])) % 360, "degrees")

best = max(
    ((loss(theta + 1e-6 * u) - loss(theta - 1e-6 * u)) / 2e-6, np.degrees(ang))
    for ang, u in (
        (a, np.array([np.cos(a), np.sin(a)])) for a in np.arange(3600) * 2 * np.pi / 3600
    )
)
print("steepest slope", best[0], "at", best[1], "degrees")

gradient       [-16.385   8.   ]
its length     18.23371122399386
its angle      153.97598928042032 degrees
steepest slope 18.233709624837502 at 154.0 degrees

Поиск, который ничего не знает о градиентах, среди 3 600 направлений находит самый крутой подъём на 154.0 градусах — в собственном направлении градиента, с точностью до 0,1 градуса, заданной поиском. И наклон, найденный там, 18.2337, совпадает с длиной градиента до шести значащих цифр. Теорема — не история о том, что означают градиенты; это измеримый факт, и вот его измерение.

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

Мост — линеаризация. Рядом с точкой гладкая функция — это её касательная плюс поправка:

Это разложение Тейлора первого порядка. Отброшенный $O(\lVert\boldsymbol{\delta}\rVert^2)$ — кривизна, тот самый член, который делал оценку в таблице наклонов неверной ровно на $7.445\,h$. Подставим шаг, который собираемся сделать, $\boldsymbol{\delta} = -\eta \nabla L$:

Функция потерь падает на $\eta \lVert \nabla L \rVert^2$. Каждая часть здесь неотрицательна, так что обещание настоящее — для достаточно малого $\eta$, потому что отброшенный член растёт как $\eta^2$ и в конце концов его съедает. Вот и вся теория. Ниже обещание выполняется, а затем ломается:

eta = 0.2       promised    66.49364500   delivered   -16.01619240   ratio -0.240868
eta = 0.1       promised    33.24682250   delivered    12.61936315   ratio  0.379566
eta = 0.01      promised     3.32468225   delivered     3.11840766   ratio  0.937957
eta = 0.001     promised     0.33246822   delivered     0.33040548   ratio  0.993796
eta = 0.0001    promised     0.03324682   delivered     0.03322620   ratio  0.999380
eta = 1e-05     promised     0.00332468   delivered     0.00332448   ratio  0.999938

Читайте снизу. Когда $\eta$ уменьшается, полученное падение сходится к обещанному — отношение 0.99938, затем 0.99994, — то есть теорема Тейлора оказывается права. Читайте сверху, и при $\eta = 0.2$ полученное «падение» равно минус шестнадцати. Шаг пошёл вниз, а функция потерь выросла.

Итак, правило обновления такое:

и у него есть условие, которое никто не проговаривает: $\eta$ должно быть достаточно малым. Достаточно малым по сравнению с чем именно — следующий раздел.

Начнём с самой простой долины, $f(x) = x^2$, где $f'(x) = 2x$. Один шаг gradient descent:

Позиция умножается на $(1 - 2\eta)$ на каждом шаге. Это геометрическая прогрессия, а у геометрических прогрессий ровно одно правило: они уменьшаются, когда множитель меньше 1 по модулю, и растут иначе. Значит, $\lvert 1 - 2\eta \rvert < 1$, то есть $0 < \eta < 1$.

Граница ровно при $\eta = 1$. Не «около 1», не «1 обычно слишком много». При $\eta = 1$ множитель равен $-1$, и точка вечно отскакивает между $x$ и $-x$, не приближаясь и не убегая. Ниже — сходимость; выше — расходимость. Интервал снова делится при $\eta = 0.5$, где множитель меняет знак: ниже подход монотонный, выше точка перескакивает и чередует стороны, а ровно при $0.5$ множитель равен 0, и один-единственный шаг попадает в минимум.

Четыре режима из четырёх строк алгебры. Пересеките границы сами:

А теперь интересный случай:

Теперь общее правило, которое выпадает из того же аргумента. Множитель $1 - 2\eta$ на самом деле был $1 - \eta f''$, а рядом с минимумом многопараметрическая функция потерь имеет по одному такому числу на направление — собственные значения матрицы вторых производных. Все направления должны быть устойчивы одновременно, поэтому потолок задаёт самое большое:

Для $f(x) = x^2$, $f'' = 2$, потолок равен 1, как мы только что вывели. Для нашего конвейера матрица вторых производных — $\frac{2}{n} A^{\top} A$, где $A$ — двухколоночная матрица входов, а её собственные значения равны 2 и 14.89, так что потолок равен $2 / 14.89 = 0.13432$. Это прогноз с пятью значащими цифрами. Проверим:

lr=0.1343    -> L =      24.5924
lr=0.13431   -> L =      24.5924
lr=0.13432   -> L =       4707.8       BLEW UP
lr=0.13433   -> L =  4.00452e+16       BLEW UP
lr=0.1344    -> L = 1.18229e+107       BLEW UP

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

И здесь возвращается глава 1. Всё выше использовало центрированные измерения. Запустите тот же код на сырых миллиметрах и граммах, и собственные значения будут 0.0298 и 998.1 вместо 2 и 14.89. Потолок рушится с 0.134 до 0.002004 — столь же точно: сходимость при lr=0.002003 и взрыв при lr=0.002004.

Хуже потолка — отношение собственных значений. Число обусловленности измеряет, насколько долина далека от круглой: длинная тонкая траншея заставляет взять rate, достаточно маленький для крутых стен, а затем по дну траншеи приходится ползти с той же скоростью. У нас оно меняется с 7.44 для центрированных данных до 33 452 для сырых. С лучшим rate, который может взять каждая версия:

Те же данные, тот же код, тот же ответ в конце — и в восемь тысяч раз больше работы, потому что никто не вычел среднее. В главе 1 тот же пропуск стоил персептрону фактора в шесть тысяч эпох, и диагноз там был геометрическим: данные плавали далеко от начала координат. Здесь та же геометрия в костюме оптимизации, и поэтому нормализация входов — не совет по гигиене, а арифметика.¹

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

def loss(theta):
    a, b = theta
    return np.mean((a * x + b - y) ** 2)


def grad(theta):
    a, b = theta
    residual = a * x + b - y
    return np.array([np.mean(2 * residual * x), np.mean(2 * residual)])


def descend(theta, lr, steps):
    theta = np.array(theta, dtype=float)
    for _ in range(steps):
        theta = theta - lr * grad(theta)   
    return theta


theta = descend([0.0, 0.0], lr=0.05, steps=60)
print(theta, loss(theta))

[ 2.10040296e+00 -2.76445533e-15] 24.592448791134984

Закрытая least-squares-формула для этих восьми точек даёт $a = 2.100403$, $b = 0$, с функцией потерь $24.592449$. Цикл нашёл это до восьми значащих цифр, не зная, что закрытая форма существует, — а это важно, потому что начиная с главы 5 её уже не будет.

Траектория, потому что смотреть на неё и есть смысл:

   0 a=0.000000 b=0.000000 L=57.437500
   1 a=1.563750 b=0.000000 L=26.736582
   2 a=1.963288 b=-0.000000 L=24.732418
   5 a=2.098116 b=-0.000000 L=24.592488
  10 a=2.100400 b=-0.000000 L=24.592449
  60 a=2.100403 b=-0.000000 L=24.592449

Большая часть расстояния пройдена за первые два шага, потому что градиент максимален, когда вы дальше всего от дна, и уменьшается по мере приближения. Gradient descent автоматически замедляется рядом с минимумом. Это feature, и в главе 6 это также проблема.

В аргументе до сих пор есть дыра. Шаг останавливается, когда $\nabla L = \mathbf{0}$, и мы называли это «минимумом». Точка с нулевым градиентом — критическая точка, и быть минимумом — лишь один из способов быть такой точкой:

• локальный минимум: вверх во всех направлениях, но, возможно, это не самая низкая такая точка вообще;
• локальный максимум: вниз во всех направлениях;
• седловая точка: вверх в одних направлениях и вниз в других. Поверхность $f(x,y) = x^2 - y^2$ имеет $\nabla f = (2x, -2y)$, что равно нулю в начале координат, где функция одновременно является минимумом вдоль оси $x$ и максимумом вдоль оси $y$.

Gradient descent не умеет их различать, потому что он всегда смотрит только на градиент, а градиент равен нулю во всех трёх случаях.

У нашей прямой одна критическая точка, и она является ответом: функция потерь с квадратичной ошибкой для линейной модели выпукла, это одна чаша, и descent по ней не может не найти глобальный минимум. Это свойство не переживает встречи с этим курсом. Функция потерь нейронной сети не выпукла, и начиная с главы 5 «минимум» — не вещь, которая существует: их много, разной глубины, и то, какой получите вы, зависит от начальной точки. Это одно предложение и останется одним предложением, потому что теория большая, а практическое следствие маленькое.

Всё следствие можно увидеть на одной кривой. Возьмите $f(x) = \tfrac{x^4}{4} - \tfrac{x^2}{2} + \tfrac{x}{10}$, у которой две долины разной глубины:

   x =  -1.046681   f(x) =  -0.352386   minimum
   x =   0.101031   f(x) =   0.005026   maximum
   x =   0.945649   f(x) =  -0.152639   minimum

Попадание в мелкую долину даёт функцию потерь на 56.7% хуже, и алгоритм никак не может это узнать, потому что изнутри долины любое направление ведёт вверх. В gradient descent для этого нет исправления, и оно не появится. На практике есть другое: оказывается, это куда менее важно, чем подсказывает картинка, — в очень высокой размерности реальной сети большинство критических точек оказываются седлами, а не ловушками,² и глава 5 измеряет, как часто маленькая сеть действительно застревает.

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

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

В 219 раз меньше арифметики, чтобы прийти туда же. А крайний случай — по одному примеру за раз, исходная stochastic approximation Роббинса и Монро³, — не победитель: он в пять раз хуже batch размером 32, потому что 32 примера стоят почти не дороже одного на железе, которое перемножает матрицы, а шум падает как квадратный корень из размера batch. Из-за этого компромисса в каждом training script, который вы когда-либо прочитаете, есть batch_size.

Momentum — другое дешёвое исправление, и оно нацелено прямо на траншею. В плохо обусловленной долине шаги зигзагом пересекают узкое направление, пока ползут вдоль длинного. Momentum хранит скользящее среднее прошлых градиентов, так что колеблющиеся компоненты гасят друг друга, а согласованная накапливается:⁴

Две дополнительные строки. На сыром нецентрированном конвейере — число обусловленности 33 452, худший случай из имеющихся, — при лучшем rate, который может взять обычный descent:

momentum beta=0.0   ->    79,513 steps to 1%
momentum beta=0.9   ->     1,609 steps to 1%
momentum beta=0.99  ->       461 steps to 1%

Фактор 172 за две строки кода. Глава 6 превращает это в Adam; механизм уже здесь.

Каждый градиент в этой главе был выведен вручную и поэтому мог быть ошибочным. Исправление — таблица наклонов из начала: измерьте производную численно и сравните. Используйте центральную разность, $\frac{L(\theta+h) - L(\theta-h)}{2h}$, которая сокращает главный член ошибки и намного точнее при том же $h$.

def numeric_grad(f, theta, h=1e-5):
    theta = np.asarray(theta, dtype=float)
    out = np.zeros_like(theta)
    for i in range(theta.size):
        bump = np.zeros_like(theta)
        bump[i] = h
        out[i] = (f(theta + bump) - f(theta - bump)) / (2 * h)     
    return out


def gradcheck(f, df, theta, h=1e-5):
    analytic = np.asarray(df(theta), dtype=float)
    numeric = numeric_grad(f, theta, h)
    return np.max(np.abs(analytic - numeric) / np.maximum(1e-8, np.abs(analytic) + np.abs(numeric)))

Относительная форма сравнения важна: абсолютная разница $10^{-4}$ — катастрофа для градиента размера $10^{-3}$ и ерунда для градиента размера $10^{6}$.

relative error: 1.8929136036763527e-11
with 2 dropped: 0.33333333331650744

Первая строка — выведенный вручную градиент выше. Вторая — та же функция, но в одной компоненте забыли множитель 2, опечатка в один символ, и проверка ловит её мгновенно. Всё ниже примерно $10^{-7}$ — совпадение; всё выше $10^{-4}$ — bug. Сохраните эту функцию: глава 5 использует её для отладки automatic differentiation engine, и только благодаря ей неправильный градиент вообще можно найти.

Всё в этой главе держалось на одном неозвученном предположении: что вы можете записать $\partial L / \partial \theta$.

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

Третья строка — сеть с 57 параметрами, настолько маленькая, что в главе 6 она была бы сноской, — и выписать её градиент вручную означает примерно 97 869 операций для одного обучающего примера. Нет нотации, которая это спасёт. Спасает наблюдение, что chain rule, применённый к композиции, имеет огромную структуру, что одни и те же промежуточные величины появляются снова и снова, и что вычисление их в правильном порядке даёт все производные примерно по цене одного forward pass. Это глава 5.

Но сначала есть проблема поменьше, и она ждёт прямо сейчас.

Теперь у нас есть машина, которая скатится вниз по любой дифференцируемой функции потерь. Направьте её на исходный вопрос конвейера — принять или отклонить, target равен 1 или 0, — поставьте sigmoid на выход, чтобы она предсказывала вероятность, и минимизируйте квадратичную ошибку. Она запустится. Но она также почти не будет двигаться тогда, когда ошибается сильнее всего, и градиент объясняет почему:

Модель, которая уверенно, катастрофически ошибается — предсказывает 0.0000454, когда ответ равен 1, — выдаёт градиент квадратичной ошибки $9 \times 10^{-5}$. Она понятия не имеет, что попала в беду. Другой столбец, из функции потерь, которую мы ещё не вывели, сообщает 1.0: максимальная срочность ровно там, где она заслужена.

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

Метод старше всех этих работ: Коши описал его в заметке для Académie des Sciences в 1847 году как способ решать системы уравнений, двигаясь вниз по сумме квадратов их residuals. Также вместе с этой главой стоит прочитать обзор Sebastian Ruder An overview of gradient descent optimization algorithms (arXiv:1609.04747), где momentum до Adam разобран на четырнадцати понятных страницах; главу 3 книги Nocedal and Wright Numerical Optimization (2nd ed., Springer, 2006), где теорема 3.3 даёт скорость сходимости steepest descent на квадратичной функции через число обусловленности — это теория за тем, почему обусловленность определяет число шагов, хотя она рассматривает line search, а не фиксированный шаг и потолок $2/\lambda_{\max}$, измеренный выше; или §5.8 и §7.1 книги Deisenroth, Faisal and Ong Mathematics for Machine Learning для того же материала с меньшим аппаратом; §6.1 книги Prince Understanding Deep Learning и §4.3 книги Goodfellow, Bengio and Courville Deep Learning; Dive into Deep Learning §12.1–12.3, где minibatch-анализ дан с большим числом измерений, чем здесь поместилось; и главу 4 книги Géron Hands-On Machine Learning (3rd ed.), самое практичное изложение learning rate как вещи, которую настраивают, а не выводят. Конспекты MIT 6.390 ставят gradient descent перед классификацией, как и этот курс, и по той же причине.