ЛР5
Потери и градиенты

Потери и градиенты

Ошибка одним числом и подсказка, как её уменьшить.

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

ПотеряКогдаЧто получает
MSEПредсказываем числоЧисловой прогноз и правильное значение
BinaryCrossEntropyДва классаВероятность класса 1 и метку 0/1
CrossEntropyНесколько классовВероятности либо логиты, в зависимости от use_softmax

MSE: квадрат ошибки усредняется. Для [3.0, 1.8, 6.8, 5.5, 4.0] и ответов [3.5, 2.0, 7.1, 5.2, 4.6] получаем 0.166. Градиент равен [-0.2, -0.08, -0.12, 0.12, -0.24].

MSE = mean((p-y)²); grad = 2(p-y)/n

BCE на правильном классе штрафует -log(p). Если ответ 1 и вероятность 0.8, потеря около 0.223. Если вероятность 0.2, около 1.609: уверенная ошибка хуже.

One-hot означает строку с одной единицей на месте правильного класса. Для цифры 2 среди трёх классов это [0,0,1].

[25] / И64: class MeanSquaredError(LossFunction):

Код и построчный разбор
 1  class MeanSquaredError(LossFunction):
 2      def __call__(self, targets, outputs):
 3          return np.mean((outputs - targets) ** 2)
 4  
 5      def grad(self, targets, outputs):
 6          return 2 * (outputs - targets) / outputs.size
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Позволяет вызывать объект как функцию: например, Sigmoid()(x). Здесь вычисляется значение.
3Из прогнозов вычитаем ответы, возводим ошибки в квадрат и усредняем.
5Метод grad возвращает производную по входу функции, для потерь по прогнозам.
6Градиент MSE: удвоенная ошибка, делённая на число всех выходных элементов. Усреднение делается только здесь.

[27] / И70: class BinaryCrossEntropy(LossFunction):

Код и построчный разбор
 1  class BinaryCrossEntropy(LossFunction):
 2      def __call__(self, targets, outputs):
 3          probabilities = np.clip(outputs, 1e-12, 1 - 1e-12)
 4          return -np.mean(targets * np.log(probabilities)
 5                          + (1 - targets) * np.log1p(-probabilities))
 6  
 7      def grad(self, targets, outputs):
 8          probabilities = np.clip(outputs, 1e-12, 1 - 1e-12)
 9          return ((probabilities - targets)
10                  / (probabilities * (1 - probabilities) * outputs.size))
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Позволяет вызывать объект как функцию: например, Sigmoid()(x). Здесь вычисляется значение.
3Отодвигаем вероятности от точных 0 и 1, чтобы не брать логарифм нуля и не делить на ноль.
4Начало BCE: при метке 1 учитываем логарифм вероятности положительного класса.
5При метке 0 учитываем log(1-p). Внешние минус и mean превращают сумму в средний штраф.
7Метод grad возвращает производную по входу функции, для потерь по прогнозам.
8Отодвигаем вероятности от точных 0 и 1, чтобы не брать логарифм нуля и не делить на ноль.
9Числитель производной BCE: предсказанная вероятность минус правильный ответ.
10Делим на p*(1-p) и количество элементов. Это производная по вероятности, ещё до переноса через Sigmoid.

[29] / И75: class CrossEntropy(LossFunction):

Код и построчный разбор
 1  class CrossEntropy(LossFunction):
 2      def __init__(self, use_softmax=False):
 3          self.use_softmax = use_softmax
 4          self.softmax = Softmax()
 5  
 6      def __call__(self, targets, outputs):
 7          if self.use_softmax:
 8              shifted = outputs - outputs.max(axis=-1, keepdims=True)
 9              log_probabilities = shifted - np.log(np.exp(shifted).sum(axis=-1, keepdims=True))
10          else:
11              log_probabilities = np.log(np.clip(outputs, 1e-12, 1))
12          return -np.mean(np.sum(targets * log_probabilities, axis=-1))
13  
14      def grad(self, targets, outputs):
15          if self.use_softmax:
16              return (self.softmax(outputs) - targets) / outputs.shape[0]
17          return -targets / np.clip(outputs, 1e-12, 1) / outputs.shape[0]
СтрокаЧто происходит
1Объявляем класс: шаблон объекта с данными и методами. Это наша реализация.
2Конструктор вызывается при создании объекта. Запоминает настройки и создаёт начальное состояние.
3Запоминаем режим: True принимает логиты, False принимает вероятности.
4Создаём экземпляр нашей реализации Softmax для вычисления вероятностей.
6Позволяет вызывать объект как функцию: например, Sigmoid()(x). Здесь вычисляется значение.
7Если поданы логиты, включаем Softmax внутрь функции потерь.
8В каждой строке вычитаем максимальный логит для устойчивости экспоненты.
9Сразу считаем log-softmax: логит минус логарифм суммы экспонент. Не берём логарифм уже округлившегося до нуля p.
10Выбираем ветку вычислений по условию.
11В режиме готовых вероятностей просто берём их защищённый логарифм.
12One-hot оставляет логарифм правильного класса. Усредняем отрицательные логарифмы по объектам.
14Метод grad возвращает производную по входу функции, для потерь по прогнозам.
15Если поданы логиты, включаем Softmax внутрь функции потерь.
16Градиент объединённой Softmax + CrossEntropy по логитам. Размер батча учитывается один раз.
17Другой режим: вход уже вероятности. Производная по ним равна -y/(N*p), а не (p-y)/N.
Custom Loss Value: 0.16599999999999987
PyTorch Loss Value: 0.16599997878074646
Custom Loss Gradient: [-0.2  -0.08 -0.12  0.12 -0.24]
PyTorch Loss Gradient: [-0.2  -0.08 -0.12  0.12 -0.24]
Custom Loss Value: 0.334092522854375
PyTorch Loss Value: 0.33409252762794495
Custom Loss Gradient: [ 0.285714 -0.285714 -0.25      0.25     -0.333333]
PyTorch Loss Gradient: [ 0.285714 -0.285714 -0.25      0.25     -0.333333]
Custom Loss Value: 1.6285315044458581
PyTorch Loss Value: 1.6285316944122314
Custom Loss Gradient:
 [[ 0.04954   0.036305 -0.158981  0.038542  0.034594]
 [-0.156366  0.038418  0.047129  0.040933  0.029887]
 [ 0.022629 -0.174704  0.05342   0.047326  0.051329]
 [ 0.055216  0.032548  0.024483  0.03883  -0.151077]
 [ 0.034     0.056054  0.041534 -0.157979  0.02639 ]]
PyTorch Loss Gradient:
 [[ 0.04954   0.036305 -0.158981  0.038542  0.034594]
 [-0.156366  0.038418  0.047129  0.040933  0.029887]
 [ 0.022629 -0.174704  0.05342   0.047326  0.051329]
 [ 0.055216  0.032548  0.024483  0.03883  -0.151077]
 [ 0.034     0.056054  0.041534 -0.157979  0.02639 ]]

Проверь себя

Почему не обучать по accuracy?

Выбор максимального класса скачкообразный. Он не даёт полезного плавного градиента для изменения весов.

Зачем clip?

Защита от log(0) и деления на ноль. Вне внутреннего интервала это стабилизированный градиент, а не точная производная clip.

Где деление на число объектов?

В grad функции потерь. В Layer.backward второй раз делить нельзя.

Какая потеря у Digits?

CrossEntropy(use_softmax=True). Входом служат логиты, целевыми значениями one-hot.