Потери PyTorch

Введение

Потери (loss functions) — это основания для обучения моделей машинного обучения (ML), и, в большинстве проектов машинного обучения, невозможно добиться правильных предсказаний моделью без использования потертостей.从严治党，一个重要任务就是建设高素质干部队伍。党要管党，首先要管好干部；从严治党，首先要严字当头，对干部教育管理要严格。坚持严字当头，把严的要求贯彻到干部教育管理全过程，做到真管真严、敢管敢严、长管长严。

Предварительные требования

Эта статья требует знания нейронных сетей. На высоком уровне нейронные сети состоят из связанных друг с другом узлов («нейронов»), организованных в слои. Они leaning и делают предсказания с помощью процесса, называемого тренировкой, который настраивает веса и склонности соединений между нейронами. Знание нейронных сетей включает информацию о различных слоях (input layer, hidden layers, output layer), функциях активации, оптимизационных алгоритмах (varients of gradient descent), потерях и т. д.

Дополнительно, знакомство с синтаксисом Python и библиотекой PyTorch является необходимым для понимания приведенных в этой статье code snippets.

В этой статье мы посмотрим на различные функции потерь, которые являются частью модуля PyTorch nn. Мы так же на глубоком погружении посмотрим, как PyTorch expose эти функции потерь пользователям в качестве части API модуля nn, создавая свою customs.

Теперь, когда мы имеем высокоуровневое понимание того, что таковы функции потерь, давайте посмотрим на несколько технических деталей о том, как работают функции потерь.

Что такие функции потерь?

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

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

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

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

Функции потерь в PyTorch

PyTorch предоставляет множество канонических функций потерь с простыми шаблонами, которые позволяют разработчикам быстро перебирать различные функции потерь во время обучения. Все функции потерь в PyTorch упакованы в модуле nn, базовом классе PyTorch для всех нейронных сетей. Это делает добавление функции потерь в ваш проект таким простым, как добавление одной строки кода. Давайте посмотрим, как добавить функцию потерь среднеквадратичной ошибки в PyTorch.

import torch.nn as nn
MSE_loss_fn = nn.MSELoss()

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

#predicted_value — это предсказание нашей нейронной сети
#target — это фактическое значение в нашем наборе данных
#loss_value — это потеря между предсказанным значением и фактическим значением
Loss_value = MSE_loss_fn(predicted_value, target)

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

Какие функции потерь доступны в PyTorch?

Практически все функции потерь, которые PyTorch поставляет, разделены на три основные категории – регрессионные потери, классификационные потери и потери рейтинга.

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

Классификационные функции потерь работают с дискретными значениями, как, например, задача классификации предмета как ящика, ручки или бутылки.

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

Функция потерь L1/Среднее абсолютное отклонение

Fункция потертости L1 вычисляет среднее абсолютное отклонение между каждым значением предсказанного тензора и значением целевого тензора. Сначала она вычисляет абсолютное различие между каждым значением предсказанного тензора и значением целевого тензора, а затем вычисляет сумму всех значений, возвращенных из вычисления абсолютного различия. Наконец, она вычисляет среднее значение этой суммы, чтобы obTAINть среднее абсолютное отклонение (MAE). Функция потертости L1 очень устойчива к обработке шума.

import torch.nn as nn

#size_average и reduce устарели

#reduction определяет метод снижения для применения к выходу. возможными значениями являются 'mean' (по умолчанию), где мы вычисляем среднее значение выхода, 'sum', где выход складывается, и 'none', который не применяет никакого снижения к выходу

Loss_fn = nn.L1Loss(size_average=None, reduce=None, reduction='mean')

input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss_fn(input, target)
print(output) #tensor(0.7772, grad_fn=<L1LossBackward>)

单值 возвращаемое является вычисленной потертостью между двумя тензорами с размером 3 на 5.

Среднеквадратическое отклонение

Среднеквадратичная ошибка имеет некоторые поразительные сходства с MAE. Вместо вычисления абсолютной разницы между значениями в тензоре предсказаний и целевыми, как в случае со средней абсолютной ошибкой, она вычисляет квадрат разницы между значениями в тензоре предсказаний и целевом тензоре. Таким образом, относительно большие различия наказываются больше, а относительно малые различия наказываются меньше. MSE считается менее устойчивой к выбросам и шуму, чем MAE.

import torch.nn as nn

loss = nn.MSELoss(size_average=None, reduce=None, reduction='mean')
#Объяснение параметров функции потерь L1 применимо здесь.

input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss(input, target)
print(output) #tensor(0.9823, grad_fn=<MseLossBackward>)

Кросс-энтропийная потеря

Кросс-энтропийная потеря используется в задачах классификации, включающих несколько дискретных классов. Она измеряет разницу между двумя распределениями вероятностей для заданного набора случайных переменных. Обычно, при использовании кросс-энтропийной потери, выход нашей сети представляет собой слой softmax, который обеспечивает, чтобы выход нейронной сети был значением вероятности (значение между 0 и 1).

Слой softmax состоит из двух частей – экспоненты предсказания для конкретного класса.

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

import numpy as np

np.exp(34) #583461742527454.9
np.exp(-34) #1.713908431542013e-15

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

Это достигается путем сложения всех показателей экспоненты для каждого класса значений. Finally, the equation of softmax looks like this:

]

В модуле nn PyTorch, потерю cross-entropy объединяет логарифмический softmax и потерю негативного логического вероятности (NLL) в единую функцию потерies.

Обратите внимание, что функция градиента в выведенном выводе является потертостью NLL. Это фактически revels, что потеря cross-entropy объединяет NLL потерю под крышей слоя логарифмического softmax.

Потеря негативного логического вероятности (NLL)

Функция потертых NLL работает очень похоже на функцию потертых cross-entropy. Потеря cross-entropy объединяет слой логарифмического softmax и NLL потерю, чтобы получить значение потертых cross-entropy. Это意味着, что NLL потерю может быть использовано для получения значения потертых cross-entropy, имея последний слой нейронной сети в качестве слоя логарифмического softmax, а не обычного softmax слоя.

m = nn.LogSoftmax(dim=1)
loss = nn.NLLLoss()
Входной массив имеет размер N x C = 3 x 5
input = torch.randn(3, 5, requires_grad=True)
Каждое значение в целевом массиве должно быть в Intervalle [0; C)
target = torch.tensor([1, 0, 4])
output = loss(m(input), target)
output.backward()
Пример потертости в двумерном пространстве (используется, например, с изображениями)
N, C = 5, 4
loss = nn.NLLLoss()
Входной массив имеет размер N x C x высота x ширина
data = torch.randn(N, 16, 10, 10)
conv = nn.Conv2d(16, C, (3, 3))
m = nn.LogSoftmax(dim=1)
Каждое значение в целевом массиве должно быть в Intervalle [0; C)
target = torch.empty(N, 8, 8, dtype=torch.long).random_(0, C)
output = loss(m(conv(data)), target)
print(output) Тензор(1.4892, градиентная функция=)

Кредит NLLLoss — документация PyTorch 1.9.0

Бинарная потертость

Бинарная потертость является специальным классом потертостей, используемых для решения особого вопроса классификации данных в только два класса. Метки для этого типа проблем обычно бинарные, поэтому наша цель состоит в том, чтобы помочь модели предсказывать числа, близкие к нулю для нулевых метк и числа, близкие к единице для единичных метк. Обычно при использовании потертости BCE для бинарной классификации выход нейронной сети защищен сверточной операцией, чтобы убедиться, что выход либо близк к нулю, либо близк к единице.

import torch.nn as nn

m = nn.Sigmoid()
loss = nn.BCELoss()
input = torch.randn(3, requires_grad=True)
target = torch.empty(3).random_(2)
output = loss(m(input), target)
print(output) Тензор(0.4198, градиентная функция=)

Двунаправленная кросс-энтропия с логитами

Мы упомянули в предыдущем разделе, что двунаправленная кросс-энтропия, как правило, выводится через слой sigmoid, чтобы обеспечить, чтобы выход находился между 0 и 1. Кросс-энтропия с логитами объединяет эти два слоя в один. Согласно документации PyTorch, это более численно устойчивая версия, так как она используетtricк с логи-СУМ экспоненты.

import torch
import torch.nn as nn

target = torch.ones([10, 64], dtype=torch.float32)  # 64 класса, размерность batch = 10
output = torch.full([10, 64], 1.5)  # Прогноз (логит)
pos_weight = torch.ones([64])  # Все веса равны 1
criterion = torch.nn.BCEWithLogitsLoss(pos_weight=pos_weight)
loss = criterion(output, target)  # -лог(sigmoid(1,5))
print(loss) #tensor(0.2014)

Сглаженная L1 потеря

Сглаженная L1 функция потерь объединяет преимущества MSE потерь и MAE потерь с помощью heuristic значения beta. Этот критерий был введен в статье о быстром R-CNN. когда абсолютное значение разности между истинным значением и предсказанным значением меньше beta, критерий использует квадратическое различие, подобно MSE потерям. график MSE потерь представляет собой непрерывную кривую, что意味着 градиент для каждого значения потерь варьируется и может быть дифференцирован повсюду. более того, как значение потерь уменьшается, градиент уменьшается, что удобно при градиентном спуске. однако для очень больших значений потерь градиент взрывается, поэтому критерий для переключения на MAE, для которого градиент почти постоянен для каждого значения потерь, когда абсолютное различие становится больше чем beta и потенциальная взрывающаяся градиентность устранена.

import torch.nn as nn

loss = nn.SmoothL1Loss()
input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)
output = loss(input, target)

print(output) #tensor(0.7838, grad_fn=<SmoothL1LossBackward>)

Hinge Embedding Loss

hinge嵌入损失通常用于半监督学习任务来衡量两个输入之间的相似性。它在包含值为1或-1的输入张量和标签张量时使用。它主要用于涉及非线性嵌入和半监督学习的问题。

import torch
import torch.nn as nn

input = torch.randn(3, 5, requires_grad=True)
target = torch.randn(3, 5)

hinge_loss = nn.HingeEmbeddingLoss()
output = hinge_loss(input, target)
output.backward()

print('input: ', input)
print('target: ', target)
print('output: ', output)

#input:  tensor([[ 1.4668e+00,  2.9302e-01, -3.5806e-01,  1.8045e-01,  #1.1793e+00],
#       [-6.9471e-05,  9.4336e-01,  8.8339e-01, -1.1010e+00,  #1.5904e+00],
#       [-4.7971e-02, -2.7016e-01,  1.5292e+00, -6.0295e-01,  #2.3883e+00]],
#       requires_grad=True)
#target:  tensor([[-0.2386, -1.2860, -0.7707,  1.2827, -0.8612],
#        [ 0.6747,  0.1610,  0.5223, -0.8986,  0.8069],
#        [ 1.0354,  0.0253,  1.0896, -1.0791, -0.0834]])
#output:  tensor(1.2103, grad_fn=<MeanBackward0>)

Margin Ranking Loss

Убыток ранжирования с отступом относится к потерям ранжирования, основная цель которых, в отличие от других функций потерь, заключается в измерении относительного расстояния между набором входных данных в наборе данных. Функция потерь с отступом принимает два входных значения и метку, содержащую только 1 или -1. Если метка равна 1, предполагается, что первый вход должен иметь более высокий рейтинг, чем второй, и если метка равна -1, предполагается, что второй вход должен иметь более высокий рейтинг, чем первый. Это соотношение показано уравнением и кодом ниже.

import torch.nn as nn

loss = nn.MarginRankingLoss()
input1 = torch.randn(3, requires_grad=True)
input2 = torch.randn(3, requires_grad=True)
target = torch.randn(3).sign()
output = loss(input1, input2, target)
print('input1: ', input1)
print('input2: ', input2)
print('output: ', output)

#input1:  тензор([-1.1109,  0.1187,  0.9441], requires_grad=True)
#input2:  тензор([ 0.9284, -0.3707, -0.7504], requires_grad=True)
#output:  тензор(0.5648, grad_fn=<MeanBackward0>)

Трехэлементная маргинальная потеря

Этот критерий мерит сходство между точками данных, используя триplets выборки тренировочных данных. Triplets, участвующие в этом процессе, являются примерным образцом, позитивным образцом и негативным образцом. Цель состоит в 1) минимизировать различие между позитивным образцом и примером как можно меньше, и 2) увеличить различие между примером и негативным образцом, превышая значение маргинала плюс различие между позитивным образцом и примером. Обычно, позитивный образец принадлежит той же классу, что и пример, но негативный образец нет. Таким образом, используя эту функцию потерь, мы стремимся использовать трехэлементную маргинальную потерю, чтобы предсказать высокую сходство между примером и позитивным образцом и низкую сходство между примером и негативным образцом.

import torch.nn as nn

triplet_loss = nn.TripletMarginLoss(margin=1.0, p=2)
anchor = torch.randn(100, 128, requires_grad=True)
positive = torch.randn(100, 128, requires_grad=True)
negative = torch.randn(100, 128, requires_grad=True)
output = triplet_loss(anchor, positive, negative)
print(output)  #тензор(1.1151, grad_fn=<MeanBackward0>)

Косинусная потеря внедрения

Угловая Similarity loss измеряет ущерб, данный входам x1, x2, и меток label тензором y, содержащим значения 1 или -1. Она используется для измерения степени сходства двух входов или их различия.

Критерий измеряет сходство путем вычисления угла между двумя точками пространства. Угол косинусного расстояния коррелирует с углом между двумя точками, что означает, что чем меньше угол, тем ближе входы и тем больше их сходства.

import torch.nn as nn

loss = nn.CosineEmbeddingLoss()
input1 = torch.randn(3, 6, requires_grad=True)
input2 = torch.randn(3, 6, requires_grad=True)
target = torch.randn(3).sign()
output = loss(input1, input2, target)
print('input1: ', input1)
print('input2: ', input2)
print('output: ', output)

#input1:  tensor([[ 1.2969e-01,  1.9397e+00, -1.7762e+00, -1.2793e-01, #-4.7004e-01,
#         -1.1736e+00],
#        [-3.7807e-02,  4.6385e-03, -9.5373e-01,  8.4614e-01, -1.1113e+00,
#          4.0305e-01],
#        [-1.7561e-01,  8.8705e-01, -5.9533e-02,  1.3153e-03, -6.0306e-01,
#          7.9162e-01]], requires_grad=True)
#input2:  tensor([[-0.6177, -0.0625, -0.7188,  0.0824,  0.3192,  1.0410],
#        [-0.5767,  0.0298, -0.0826,  0.5866,  1.1008,  1.6463],
#        [-0.9608, -0.6449,  1.4022,  1.2211,  0.8248, -1.9933]],
#       requires_grad=True)
#output:  tensor(0.0033, grad_fn=<MeanBackward0>)

Потертость по Kullback-Leibler

Для двух распределений P и Q потертость Kullback-Leibler (KL) измеряет, сколько информации теряется, когда P (предполагаемое истинное распределение) заменено на Q. Измеряя, сколько информации теряется, когда мы используем Q для аппроксимации P, мы можем получить сходство между P и Q и, таким образом, направлять наш алгоритм на создание распределения, очень близкого к истинному распределению P. Информационная потеря, происходящая при использовании Q для аппроксимации P, не совпадает с информационной потерей, происходящей при использовании P для аппроксимации Q, поэтому потертость KL не симметрична.

import torch.nn as nn

loss = nn.KLDivLoss(size_average=None, reduce=None, reduction='mean', log_target=False)
input1 = torch.randn(3, 6, requires_grad=True)
input2 = torch.randn(3, 6, requires_grad=True)
output = loss(input1, input2)

print('output: ', output) #tensor(-0.0284, grad_fn=<KlDivBackward>)

Создание пользовательской функции потертости

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

Это самый простой способ написать собственную функцию потерь. Это так же просто, как создать функцию, передать в нее необходимые входные данные и другие параметры, выполнить некоторые операции, используя основное API или функциональное API PyTorch, и вернуть значение. Давайте посмотрим демонстрацию с пользовательской функцией средней квадратичной ошибки.

def custom_mean_square_error(y_predictions, target):
  square_difference = torch.square(y_predictions - target)
  loss_value = torch.mean(square_difference)
  return loss_value

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

y_predictions = torch.randn(3, 5, requires_grad=True);
target = torch.randn(3, 5)
pytorch_loss = nn.MSELoss();
p_loss = pytorch_loss(y_predictions, target)
loss = custom_mean_square_error(y_predictions, target)
print('custom loss: ', loss)
print('pytorch loss: ', p_loss)

#пользовательская потеря:  тензор(2.3134, grad_fn=<MeanBackward0>)
#потеря pytorch: тензор(2.3134, grad_fn=<MseLossBackward>)

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

Пользовательская потеря с классами Python

Этот подход, вероятно, является стандартным и рекомендуемым методом определения пользовательских потерь в PyTorch. Функция потерь создается как узел в графе нейронной сети путем наследования от модуля nn. Это означает, что наша пользовательская функция потерь является слоем PyTorch точно так же, как и сверточный слой. Давайте посмотрим, как это работает с пользовательской функцией MSE потерь.

class Custom_MSE(nn.Module):
  def __init__(self):
    super(Custom_MSE, self).__init__();

  def forward(self, predictions, target):
    square_difference = torch.square(predictions - target)
    loss_value = torch.mean(square_difference)
    return loss_value
  
  def __call__(self, predictions, target):
     square_difference = torch.square(y_predictions - target)
     loss_value = torch.mean(square_difference)
     return loss_value

Последние мысли

Мы многократно обсуждали различные функции потерь, доступные в PyTorch, а также проникали в их внутренние механизмы. Выбор правильной функции потерь для конкретного вопроса может быть трудной задачей.Settings, hope this tutorial in conjunction with the official PyTorch documentation serves as a guideline when trying to understand which loss function suits your problem well.