Как работает обучение

Число на странице ещё не является предсказанием. Сначала нужно правило. Положим в миску 2 шарика, затем добавим 1. Правило принимает 2 и возвращает 3. Математики называют такое правило функцией.

Функция переводит входное число в выходное. Начнём с 2 и прибавим 1.

function addOne(value) {
  return { output: value + 1 };
}
const result = addOne(2);

В f(x) буква x обозначает любое входное число, а f — название правила. Скобки означают «использовать этот вход». Можно подставить 4 вместо 2 и получить f(4) = 5.

В статье числа собраны в множества. ℕ содержит числа для счёта; ℤ включает также ноль и отрицательные числа, например долг −2; ℝ включает и числа вроде 1.5. Запись [5] означает {1, 2, 3, 4, 5}, а не только 5. Вектор — это список чисел, например (2, 3).

Представим четыре равновероятных исхода: 0, 0, 0 и 1. Сложим их и разделим на 4: (0 + 0 + 0 + 1)/4 = 0.25. Это ожидаемое среднее, обозначаемое E: оно учитывает шансы всех исходов. Среднее по реальным попыткам может отличаться. Σ означает сложение чисел.

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

Предположим, мы хотим предсказать завтрашнюю температуру. Один пример содержит вход, например сегодняшнюю температуру, и правильный ответ, например завтрашнюю. Пара записывается как z = (x, y): x подаётся на вход, а y — метка, которую мы надеемся предсказать.

Для вымышленных температур в градусах Цельсия входу 2 соответствует метка 5. Правило предсказывает 4. Насколько оно отличается от метки?

function predictionLoss(value, target) {
  const prediction = 2 * value;
  return { prediction, loss: (prediction - target) ** 2 };
}
const result = predictionLoss(2, 5);

Квадратичная потеря равна 1°C². Ошибка в 2°C дала бы 4°C². Такое предсказание числа называется регрессией.

Другая задача — выбор между двумя классами. Представим фильтр спама: +1 означает спам, а −1 — обычное письмо. Его исходная оценка может быть любым числом. Мы преобразуем её в класс и сравниваем класс с меткой, а не считаем нулевую исходную оценку автоматически правильной.

Используем +1 и −1 для двух классов. Метка равна +1, начальная оценка равна −2.

function classify(score, target) {
  if (target !== 1 && target !== -1) {
    throw new Error('Метка должна быть +1 или −1.');
  }
  let predicted = -1;
  if (score >= 0) predicted = 1;
  let loss = 0;
  if (predicted !== target) loss = 1;
  return { predicted, loss };
}
const result = classify(-2, 1);

При оценке 0 правило знака в статье выбирает +1. Функция JavaScript Math.sign(0) возвращает 0, поэтому это другое правило. Для условного примера с меткой −1 нулевая оценка означала бы ошибку классификации.

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

Можно изучать, какие температуры встречаются часто. Кривая плотности помогает увидеть, какие диапазоны, например от 19°C до 21°C, вероятнее. Площадь под кривой над диапазоном даёт вероятность: шанс, что измерение попадёт в него. Высота кривой при одной точной температуре сама по себе не является вероятностью.

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

Поместим входные числа в список x. Таблица W хранит веса, а список b — смещения. Для одного нейрона входы 2 и 3, веса 2 и −1 и смещение 1 дают 2×2 − 1×3 + 1 = 2. Затем слой применяет правило активации, обозначенное ρ.

function layer(firstInput, secondInput, bias) {
  const sum = 2 * firstInput - secondInput + bias;
  return { sum, relu: Math.max(0, sum) };
}
const result = layer(2, 3, 1);

ReLU сохраняет положительную сумму, а отрицательную заменяет нулём: −2 становится 0. В формуле Φ обозначает вычисление, θ содержит его настраиваемые числа, а (1) означает первый слой. Черта над Φ отмечает результат после активации. Правило, которое умножает входы на веса и добавляет смещение, называется аффинным. Если смещение равно нулю, оно линейное.

Сеть на рисунке 1.1 соединяет много нейронов в этапы: 3 входных числа → 4 скрытых нейрона → 6 скрытых нейронов → 1 выход. Здесь два скрытых слоя и три набора обучаемых весов и смещений. Последний этап аффинный; в определении статьи после его выхода нет ReLU.

У сети 3 входа, затем скрытые слои из 4 и 6 нейронов и 1 выход. Каждый нейрон соединён со всеми числами предыдущего этапа. На первом этапе 3×4 = 12 весов и 4 смещения. На втором 4×6 = 24 веса и 6 смещений. На последнем 6×1 = 6 весов и 1 смещение.

function countParameters(
  inputs, firstLayer, secondLayer, outputs
) {
  const weights = inputs * firstLayer + firstLayer * secondLayer
    + secondLayer * outputs;
  const biases = firstLayer + secondLayer + outputs;
  return { weights, biases, parameters: weights + biases };
}
const result = countParameters(3, 4, 6, 1);

В сети 42 веса и 11 смещений: всего 53 настраиваемых числа.

Каждый скрытый нейрон применяет активацию после взвешенной суммы. ReLU и сигмоида — два возможных правила для этого шага; архитектура обычно заранее определяет схему активации.

Применим ReLU и сигмоиду к одному входу 0. Это два варианта из таблицы активаций статьи.

function activations(value) {
  const relu = Math.max(0, value);
  const sigmoid = 1 / (1 + Math.exp(-value));
  return { relu, sigmoid };
}
const result = activations(0);

Сигмоида превращает 0 в 0.5, а ReLU — в 0. При −2 ReLU даёт 0, а сигмоида примерно 0.119. В статье есть и гауссова активация: её значение максимально в нуле и падает по обе стороны.

Почему бы не использовать только шаги с весами и смещениями? Два аффинных шага без нелинейности между ними можно объединить в один аффинный шаг.

Применим сначала одно аффинное правило, затем другое: умножим первый результат на 4 и прибавим 5.

function combineLayers(value) {
  const h = 2 * value + 3;
  return { h, output: 4 * h + 5, combined: 8 * value + 17 };
}
const result = combineLayers(1);

Оба шага объединяются в 8x + 17. Активация вроде ReLU позволяет разным входам следовать разным частям правила, которые не всегда можно так объединить.

Представим, что меняем все 53 веса и смещения, но оставляем слои и правила активации прежними. Разные настройки могут дать разные правила предсказания; некоторые дают одно и то же правило. Размеры слоёв и правила активации составляют архитектуру. Все правила, которые она может создать, образуют множество гипотез — правила, из которых можно выбирать.

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

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

function averageRisk(losses) {
  let mistakes = 0;
  for (const loss of losses) mistakes += loss;
  return { mistakes, average: mistakes / losses.length };
}
const result = averageRisk([0, 0, 1, 0, 1]);

Среднее 0.4 означает 40% ошибок для этой функции потерь. Квадратичная потеря имеет другие единицы и не является процентом.

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

В формуле F — набор разрешённых правил, s — собранные обучающие примеры, а R̂ — их средняя потеря. Обозначение минимума означает выбор правила с наименьшим средним. Например, средние потери трёх вариантов равны 0.5, 0.2 и 0.4.

function bestCandidate(losses) {
  const minimum = Math.min(...losses);
  return { minimum, candidate: losses.indexOf(minimum) + 1 };
}
const result = bestCandidate([0.5, 0.2, 0.4]);

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

Потеря классификации создаёт проблему для этого поиска: оценки −2 и −1 обе ошибочны при метке +1. Подсчёт ошибок назначает каждой потерю 1, хотя −1 ближе к положительному значению. Гладкая функция потерь, используемая вместо подсчёта ошибок, может измениться раньше, чем выбранный класс.

Для положительной метки сравним оценку с нулём. И −2, и −1 дают неверный класс, но логистическая потеря их различает.

function compareLosses(score) {
  let classLoss = 0;
  if (score < 0) classLoss = 1;
  const logistic = Math.log(1 + Math.exp(-score));
  return { classLoss, logistic };
}
const result = compareLosses(-2);

Для метки +1 логистическая функция потерь оценивает результат −2 примерно в 2.127, а −1 — примерно в 1.313. Класс всё ещё неверен, но меньшая потеря указывает на улучшение. Это помогает поиску при обучении, хотя наименьшая логистическая потеря не всегда даёт наименьшее число ошибок.

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

Сравним две условные модели. При силе штрафа 0.01 значение для модели A равно 0.10 + 0.01×100 = 1.10; для модели B — 0.15 + 0.01×2 = 0.17. Сила штрафа определяет вклад квадратов параметров.

function penalizedLoss(strength) {
  return { A: 0.1 + strength * 100, B: 0.15 + strength * 2 };
}
const result = penalizedLoss(0.01);

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

Мы измерили ошибки на уже имеющихся примерах. Но настоящая цель — хорошо работать на новом примере, взятом из процесса того же типа. Статья называет среднее по этому неизвестному распределению риском и обозначает его R(f).

Представим два вида новых случаев. Верный ответ выпадает с шансом три из четырёх, или 0,75; ошибка — один из четырёх, или 0,25. Сравним среднее с учётом этих шансов с двумя увиденными случаями: одним верным и одним ошибочным.

function compareRisk(chance) {
  if (!(chance >= 0 && chance <= 1)) {
    throw new Error('Вероятность должна быть от 0 до 1.');
  }
  const expectedRisk = (1 - chance) * 0 + chance * 1;
  const observedAverage = (0 + 1) / 2;
  return { expectedRisk, observedAverage };
}
const result = compareRisk(0.25);

Ожидаемая потеря равна 0.25, а наблюдаемое среднее — 0.5. Ожидание описывает распределение, выборочное среднее — полученные случаи.

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

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

Представим лучшее возможное правило и его среднюю потерю на будущих примерах. Избыточный риск показывает, насколько средняя потеря нашего правила больше этого лучшего среднего. Следующая граница складывает три запаса: за пропущенную лучшую настройку, за разрыв между средними потерями на обучении и в будущем и за отсутствие достаточно хорошего правила. Для разрыва берётся наибольший такой разрыв среди всех разрешённых правил, а не только на пяти тестовых примерах. Возьмём 0.1, 0.2 и 0.3.

function riskBound(generalization) {
  return { upperBound: 0.1 + 2 * generalization + 0.3 };
}
const result = riskBound(0.2);

Подставим примерные числа в верхнюю границу: 2×0.2 = 0.4, затем 0.1 + 0.4 + 0.3 = 0.8. По определениям статьи избыточный риск не больше этой границы. Это не сама ошибка. Среднее слагаемое учитывается дважды, потому что сравнение использует два разрыва между средними ошибками на обучении и в будущем.

Теперь у нас есть карта остальной части статьи: можем ли мы найти хорошие настройки, способна ли такая сеть выразить ответ и можно ли доверять ей на примерах, которые ей не показывали?

Семейство моделей может содержать очень хорошее правило, но как найти его веса? Возьмём один регулятор w, который должен равняться 2. Используем квадратичную потерю L(w) = (w − 2)². При w = 5 потеря равна (5 − 2)² = 9.

Градиент показывает локальное направление наиболее быстрого роста потери. В примере с одним регулятором градиент равен 2(w − 2), поэтому при w = 5 он равен 6. Положительный градиент означает, что небольшое движение влево должно уменьшить потерю.

Статья обновляет параметры Θ по среднему градиенту потерь на мини-пакете S′ из m′ примеров с темпом обучения η. В примере с одним весом и одним обучающим примером L(w) = (w − 2)² при w = 5.

function updateWeight(weight, target, step) {
  const gradient = 2 * (weight - target);
  return { gradient, next: weight - step * gradient };
}
const result = updateWeight(5, 2, 0.25);

Вычитание 0.25 × 6 перемещает регулятор с 5 на 3.5. Новая потеря равна (3.5 − 2)² = 2.25, что меньше 9. Число 0.25 — скорость обучения: при слишком большой скорости можно перескочить через хорошую настройку.

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

Вместо измерения потери на всех обучающих примерах при каждом шаге стохастический градиентный спуск (SGD) может использовать небольшую случайно выбранную группу примеров — мини-пакет. Полученный градиент приближённо оценивает полный градиент. Для некоторых простых чашеобразных функций потерь существуют гарантии сходимости; у обычных нейросетей ландшафт может иметь несколько долин или плоских областей. Успешный шаг здесь не доказывает общего успеха.

Что, если мы ищем идеально, но ни одно разрешённое правило не может дать правильные ответы? Устройство, которое может возвращать только число 1, не воспроизведёт целевые значения 0, 1 и 2 для трёх разных входов.

Вопрос приближения относится к самому семейству правил, ещё до вопроса о том, нашло ли обучение нужный элемент.

Для условных входов 0, 1, 2 целевые выходы равны 0, 1, 2. Сравним постоянное правило 1 с гибким правилом, возвращающим свой вход.

function approximationError(flatOutput, inputs, targets) {
  let flatTotal = 0;
  let flexibleTotal = 0;
  for (let index = 0; index < targets.length; index++) {
    flatTotal += (flatOutput - targets[index]) ** 2;
    flexibleTotal += (inputs[index] - targets[index]) ** 2;
  }
  return {
    flat: flatTotal / targets.length,
    flexible: flexibleTotal / targets.length,
  };
}
const result = approximationError(1, [0, 1, 2], [0, 1, 2]);

Постоянное правило предсказывает 1, 1, 1: квадраты ошибок равны 1, 0, 1, а их среднее — 2/3. Правило f(x) = x предсказывает 0, 1, 2 без ошибок на этих трёх точках. Это условное сравнение конечного числа точек, а не утверждение, что гибкое правило верно всюду.

Возьмём целевое правило, которое меняется непрерывно при изменении входов, и ограничим диапазон входов. Статья рассматривает результаты: сети с подходящей активацией, включая ReLU, и достаточным числом скрытых нейронов могут приблизиться сколь угодно близко при указанных условиях. Это значит, что нужные настройки существуют; результат не обещает маленькую сеть или способ найти настройки обучением.

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

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

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

Условное правило правильно отвечает на 4 из 5 обучающих случаев и на 3 из 5 новых.

function compareMistakes(newMistakes, cases) {
  if (!Number.isInteger(cases) || cases <= 0
    || !Number.isInteger(newMistakes)
    || newMistakes < 0 || newMistakes > cases) {
    throw new Error('Используйте целые числа: 0 ≤ ошибок ≤ случаев; число случаев должно быть положительным.');
  }
  return { training: 1 / cases, newCases: newMistakes / cases };
}
const result = compareMistakes(2, 5);

Обе доли по пяти случаям являются шумными оценками; доля на новых случаях не обязательно равна истинному будущему риску.

Классическая теория часто предполагает независимый выбор примеров: один выбор не определяет следующий. Она также ограничивает рассматриваемое семейство правил. При таких условиях можно получить границу разрыва между средними потерями на обучении и в будущем. Больше независимых примеров обычно сужает границу; больше свободы подгонять любые метки может увеличить некоторые границы.

Может ли семейство правил присвоить двум точкам все пары меток: (+1, +1), (+1, −1), (−1, +1) и (−1, −1)? Размерность VC показывает, скольким точкам семейство может присвоить метки всеми возможными способами. Граница, основанная только на числе параметров огромной сети, часто мало говорит о её работе на новых примерах.

Объединим три вопроса. Во-первых, может ли выбранная сеть выразить нужное правило? Во-вторых, может ли обучение найти полезные параметры? В-третьих, будет ли результат работать за пределами тренировочных примеров?

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

function generalizationGap(newMistakes, cases) {
  if (!Number.isInteger(cases) || cases <= 0
    || !Number.isInteger(newMistakes)
    || newMistakes < 0 || newMistakes > cases) {
    throw new Error('Используйте целые числа: 0 ≤ ошибок ≤ случаев; число случаев должно быть положительным.');
  }
  const training = 0 / cases;
  const newCases = newMistakes / cases;
  return { training, newCases, gap: newCases - training };
}
const result = generalizationGap(2, 5);

Наблюдаемый разрыв 0.4 на пяти новых случаях не определяет истинное среднее для всех будущих случаев.

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

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