ЛР5
Как сеть учится

Как сеть учится

Главная страница: forward, backward и обновление весов.

Три действия

  1. Forward: данные идут вперёд, получается ответ.
  2. Loss: сравниваем ответ с правильным.
  3. Backward: ошибка идёт назад, каждый слой вычисляет свои производные и меняет веса.

Правило цепочки: если одна величина зависит от другой через промежуточный шаг, чувствительности перемножаются. Как передаточные отношения шестерёнок.

Один реальный числовой шаг

Простой учебный нейрон: x=2, w=0.5, b=0, правильный ответ y=3. Identity пропускает сумму без изменений. Прогноз 1, MSE=4. Градиент по прогнозу 2*(1-3)=-4. По весу: x*(-4)=-8; по сдвигу -4. При шаге 0.1 новые w=1.3, b=0.4. Новый прогноз 3, ошибка 0.

Сделай шаг сам

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

Те же действия для слоя

Строка кодаСмысл
grad_outputs * activation.grad(...)Переносим ошибку через активацию.
grad_linear @ weights.TПередаём градиент предыдущему слою.
inputs.T @ grad_linearПолучаем чувствительность потери к каждому весу.
grad_linear.sum(axis=0)Суммируем вклад объектов в общий сдвиг.
weights -= learning_rate * grad_weightsДвигаем веса против направления роста ошибки.

[31] / И82: class Layer:

Код и построчный разбор
 1  class Layer:
 2      def __init__(self, input_size, output_size, activation=None, random_seed=17):
 3          self.activation = Identity() if activation is None else activation
 4          rng = np.random.default_rng(random_seed)
 5          scale = np.sqrt(2 / input_size) if isinstance(self.activation, ReLU) else np.sqrt(1 / input_size)
 6          self.weights = rng.normal(0, scale, size=(input_size, output_size))
 7          self.bias = np.zeros((1, output_size))
 8  
 9      def forward(self, inputs):
10          self.inputs = inputs
11          self.linear_output = inputs @ self.weights + self.bias
12          return self.activation(self.linear_output)
13  
14      def backward(self, grad_outputs, learning_rate=0.01):
15          if isinstance(self.activation, Softmax):
16              probabilities = self.activation(self.linear_output)
17              grad_linear = probabilities * (grad_outputs - np.sum(
18                  grad_outputs * probabilities, axis=-1, keepdims=True))
19          else:
20              grad_linear = grad_outputs * self.activation.grad(self.linear_output)
21          grad_inputs = grad_linear @ self.weights.T
22          grad_weights = self.inputs.T @ grad_linear
23          grad_bias = grad_linear.sum(axis=0, keepdims=True)
24          # Градиент входов уже вычислен со старыми весами.
25          self.weights -= learning_rate * grad_weights
26          self.bias -= learning_rate * grad_bias
27          return grad_inputs
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Конструктор вызывается при создании объекта. Запоминает настройки и создаёт начальное состояние.
3Сохраняем выбранную активацию. Если её не передали, слой остаётся линейным.
4Создаём локальный генератор: одинаковый seed даёт те же начальные веса.
5Для ReLU используем масштаб Хе. Для других активаций умеренный масштаб 1/sqrt(числа входов).
6Создаём случайные веса. У каждого входа есть вес для каждого выходного нейрона.
7Создаём один сдвиг на выходной нейрон. Одинаковый вектор прибавится ко всем объектам.
9Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
10Запоминаем вход для обратного прохода: он понадобится в формуле градиента весов.
11Взвешиваем входы и добавляем сдвиг. Это ещё не результат активации.
12Применяем нелинейное преобразование и передаём результат следующему слою.
14Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
15Softmax связывает выходы. Для него нужна специальная ветка, простое поэлементное умножение неверно.
16Повторно получаем вероятности Softmax по сохранённым логитам этого слоя.
17Начало сокращённого произведения на Якобиан: p умножается на входной градиент с поправкой.
18Поправка есть сумма g*p по классам каждой строки. В итоге p*(g-sum(g*p)), с учётом связей классов.
19Выбираем ветку вычислений по условию.
20Обычная активация: умножаем пришедший градиент на локальную производную по правилу цепочки.
21Вычисляем градиент для предыдущего слоя. Здесь ещё используются старые веса.
22Суммируем вклад объектов в градиенты весов одним матричным умножением.
23Суммируем градиенты по объектам: каждый сдвиг использовался во всех строках.
24Комментарий: Градиент входов уже вычислен со старыми весами.
25Шаг обучения: двигаем веса против направления роста ошибки.
26Так же обновляем сдвиги.
27Возвращаем сигнал ошибки предыдущему слою.

[32] / И83: class NeuralNetwork:

Код и построчный разбор
 1  class NeuralNetwork:
 2      def __init__(self, layers, loss):
 3          self.layers = layers
 4          self.loss = loss
 5  
 6      def forward(self, X):
 7          outputs = X
 8          for layer in self.layers:
 9              outputs = layer.forward(outputs)
10          return outputs
11  
12      def backward(self, outputs, targets, learning_rate=0.01):
13          gradient = self.loss.grad(targets, outputs)
14          for layer in reversed(self.layers):
15              gradient = layer.backward(gradient, learning_rate)
16  
17      def train(self, X, y, epochs=1000, learning_rate=0.01):
18          loss_history = []
19          for epoch in range(epochs):
20              outputs = self.forward(X)
21              loss_history.append(float(self.loss(y, outputs)))
22              self.backward(outputs, y, learning_rate)
23          return np.array(loss_history)
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Конструктор вызывается при создании объекта. Запоминает настройки и создаёт начальное состояние.
3Сохраняем слои в порядке от входа к выходу.
4Сохраняем объект функции потерь, выбранный под задачу.
6Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
7Первый вход всей сети: исходная матрица объектов и признаков.
8Проходим слои от входа к выходу. Следующий слой зависит от предыдущего, поэтому нужен цикл.
9Выход текущего слоя становится входом следующего.
10После обхода слоёв возвращаем окончательный ответ сети.
12Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
13Начинаем обратный проход с производной потери по ответу сети.
14Идём от последнего слоя к первому, потому что ошибка приходит с выхода.
15Слой обновляет свои параметры и возвращает градиент для предыдущего слоя.
17Объявляем функцию или метод. Аргументы в скобках являются её входными данными.
18Пустой список для одного значения потери на каждую эпоху.
19Эпоха здесь означает один прямой и обратный проход по всей обучающей выборке.
20Сеть делает прогнозы с текущими весами.
21Записываем ошибку до обновления. Потом по истории строится график обучения.
22Переносим ошибку назад и меняем параметры всех слоёв.
23Возвращаем историю ошибок, а обученные веса остаются внутри объекта сети.

Проверь себя

Где у вас реализовано обучение?

NeuralNetwork.train вызывает forward, затем backward. В NeuralNetwork.backward идём по reversed(self.layers). Само изменение чисел weights и bias находится в Layer.backward.

Где готовая сеть PyTorch?

Её нет. PyTorch используется только для проверок. Сеть и производные реализованы вручную на NumPy.

Почему backward идёт с конца?

Производную для раннего слоя нельзя вычислить без градиента, пришедшего от следующего слоя.

Можно ли убрать все циклы?

По объектам в формулах циклов нет. Слои и эпохи зависят от предыдущих шагов, поэтому управляющие циклы нужны.

Что сохраняется между forward и backward?

Входы слоя и сумма до активации: self.inputs и self.linear_output.