PyTorch 손실 함수

개요

손실 函數은 機械 学习 모델 훈련에서 기본적인 요소입니다. 대부분의 機械 学习 프로젝트에서는 모델에 정확한 예측을 하게 만들 수 있는 것이 없다면 손실 函數을 사용할 수 없습니다. 일반적인 term로, 손실 函數은 모델이 어떤 데이터셋에 대해 어떻게 되고 있는지를 衡量하기 위해 사용하는 수학적 函數 또는 표현입니다. 특정 데이터셋에 대해 모델의 성과를 알고 있으면 開発자는 훈련 도중에 많은 결정을 하는 것에 도움이 됩니다. 예를 들어 새로운, 더 강력한 모델을 사용하거나, 손실 函數本身을 다른 유형으로 변경할 것인지 결정할 수 있습니다. 손실 函數의 유형에 대해서는 수년 동안 개발되었고 각각 特定の 훈련 任务에 적용되는 것이기 때문입니다.

사전 요구 사항

이 글을 이해하려면 뇌 네트워크의 이해가 필요합니다. 뇌 네트워크는 이어지는 노드(“뇌 세 neuron”)로 구성되어 있는 层次들로 organized합니다. 他们은 훈련 과정을 통해 이전의 weigh와 bias를 조절하여 학습하고 예측을 합니다. 뇌 네트워크의 이해는 그들의 다양한 层次(input layer, hidden layer, output layer), 활성화 函數, 최적화 알고리즘(gradient descent의 변体), 손실 函數 등을 포함합니다.

이 記事에서 제시된 코드 snippet을 이해하기 위해서는 파이썬 문법과 PyTorch 라이브러리에 대한 熟悉성이 필요합니다.

이 記事에서는 PyTorch nn 모듈에 포함된 다양한 손실 函數을 탐구하고, PyTorch는 사용자에게 nn 모듈 API의 일부로 이러한 손실 函數을 노출하는 방법에 대해 심도 있게 구현할 것입니다.

이제 loss functions의 高层次적인 이해를 얻었으므로, loss functions가 어떻게 작동하는지 더 技术적인 자세로 탐구하 let’s explore some more technical details about how loss functions work.

What are loss functions?

我们早些时候说过，损失函數告訴我們模型在特定數據集上的表現情况。 技術적으로는 예측된 값이 실제 값에 가까운지 어떻게 측정하는 것입니다. 我们的模型이 기电力 및 평가 데이터셋에서 예측값이 실제 값에 非常に 가까워 있다면, 이는 우리가 상당히 健壮한 모델을 갖추고 있는 것을 의미합니다.

尽管损失函數은 우리의 모델의 성능에 대한 중요한 정보를 제공하는 것이 correct, 이러한 기능을 loss function이 아니며, 정확도와 F-score가 있는 더 健壮한 기술들을 사용하여 우리의 모델을 평가할 수 있습니다. 损失函數의 중요성은 대부분 훈련 시간에 실현되며, 모델의 가중치를 손실을 최소화하는 방향으로 推动了 weight update를 의미합니다. 이러한 과정을 통하면 모델이 정확한 예측을 할 가능성을 높이게 되며, loss function없이 이러한 예측을 할 수 있을지 unlikely했을 것입니다.

여러분의 문제에 적용되는 다양한 손실函數이 존재하며, 각 函數은 研究员들이 훈련 과정에서 안정적인 그라디언트 흐름을 보장하기 위해 精巧하게 조성한 것입니다.

때때로, 손실函數의 수학적 표현이 少し intimating할 수 있으며, 이는 某些 개발자들이 그들을 黑马Box(black boxes)로 대응하게 되었습니다. 나중에 PyTorch에서 가장 자주 사용되는 一些 loss functions을 보여드릴 것입니다만, 그 전에 PyTorch 내에서 loss functions을 어떻게 사용하는지 살펴봅시다.

PyTorch 中的 Loss functions

PyTorch는 다양한 loss functions을 갖추고 있으며, 개발자는 이러한 다양한 loss functions을 빠르게 iteration할 수 있는 간단한 design patterns을 사용하고 있습니다. PyTorch의 loss functions은 모두 nn module에 포함되어 있으며, PyTorch의 모든 신경망에 대한 기본 클래스입니다. 이는 loss function을 你们的项目에 추가하는 것이 한 行의 코드만 더해주면 되는 것과 같습니다. 이러한 mean squared error loss function을 PyTorch에서 어떻게 추가하는지 살펴봅시다.

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

위의 코드로 돌려지는 함수는 다음과 같은 형식으로 예측값이 실제값에 얼마나 멀어지는지 계산할 수 있습니다.

#predicted_value는 우리의 신경망으로 예측한 값
#target는 우리의 dataset에서 실제로 나온 값
#loss_value는 예측값과 실제값 사이의 loss
Loss_value = MSE_loss_fn(predicted_value, target)

이제 PyTorch에서 손실 함수를 사용하는 방법에 대해 이해했으니, PyTorch에서 제공하는 여러 손실 함수의 내부 작동 방식에 대해 깊이 탐구해 봅시다.

PyTorch에는 어떤 손실 함수가 있나요?

PyTorch에서 제공하는 많은 손실 함수는 크게 3가지 그룹으로 분류됩니다 – 회귀 손실, 분류 손실 및 순위 손실.

회귀 손실은 주로 두 한계 사이의 임의의 값을 가질 수 있는 연속 값과 관련이 있습니다. 이의 한 예로 커뮤니티의 주택 가격 예측을 들 수 있습니다.

분류 손실 함수는 상자, 펜 또는 병과 같은 객체를 분류하는 작업처럼 이산 값을 다룹니다.

순위 손실은 값들 사이의 상대적 거리를 예측합니다. 예를 들어 얼굴 검증의 경우 특정 얼굴에 속하는 얼굴 이미지를 알고 싶을 때, 원본 얼굴 소유자에게 상대적으로 더 가까운 얼굴을 순위 매겨 어떤 얼굴이 원본 얼굴 소유자의 얼굴인지 아닌지를 확인할 수 있습니다.

L1 손실 함수/ 평균 절대 오차

L1 손실 函數은 예측tensor에 있는 각 값과 대상tensor의 값 사이의 평균 絶対 오차를 computes한다. 먼저, 예측tensor의 각 값과 대상tensor의 값 사이의 絶対 차이를 computes하고, 각 絶対 차이 computation으로 돌아온 모든 값의 합을 computes한다. 마지막으로, 이 합 값의 평균을 computes하여 평균 絶対 오차(MAE)을 얻는다. L1 손실 函數은 雑音 handling에 매우 robust하다.

import torch.nn as nn

#size_average and reduce are deprecated

#reduction specifies the method of reduction to apply to output. Possible values are 'mean' (default) where we compute the average of the output, 'sum' where the output is summed and 'none' which applies no reduction to output

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인 두 tensor 사이의 computed loss입니다.

Mean Squared Error

평균 제곱 오차(MSE)는 MAE(평균 절대 오차)와 몇 가지 놀라운 유사점을 공유합니다. MAE에서처럼 예측 텐서와 타겟 값 간의 절대 차이를 계산하는 대신, MSE는 예측 텐서와 타겟 텐서 값 간의 차이를 제곱하여 계산합니다. 이를 통해 비교적 큰 차이는 더 크게, 작은 차이는 덜 크게 페널티가 주어집니다. 그러나 MSE는 MAE보다 이상치(outlier)와 노이즈를 처리하는 데 있어 덜 강건하다고 여겨집니다.

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>)

교차 엔트로피 손실

교차 엔트로피 손실은 여러 개의 이산 클래스가 있는 분류 문제에서 사용됩니다. 이는 주어진 랜덤 변수 집합에 대해 두 확률 분포 간의 차이를 측정합니다. 일반적으로 교차 엔트로피 손실을 사용할 때, 네트워크의 출력은 소프트맥스 레이어로, 이 레이어는 신경망의 출력을 0에서 1 사이의 확률 값으로 보장합니다.

소프트맥스 레이어는 특정 클래스에 대한 예측의 지수로 구성됩니다.

yi는 특정 클래스에 대한 신경망의 출력입니다. 이 함수의 출력은 yi가 크고 음수일 때 0에 가까운 값이지만, 절대 0은 아니며, yi가 양수이고 매우 클 때는

import numpy as np

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

第二部分는 정규화 값으로, softmax 层层의 출력이 항상 확률 값이 되도록 사용합니다.

이것은 각 클래스 값의 모든 지수를 더한 것입니다. softmax의 最終적 方程式은 다음과 같습니다:

]

PyTorch의 nn 모듈에서, 交叉熵 损失는 log-softmax과 否定 交叉熵(NLL) 损失를 하나의 损失 함수로 결합합니다.

printed output에서 gradient function의 NLL loss가 나타나는 것을 주의 깊게 보세요. 이는 交叉熵 损失가 하이ddenneath에서 NLL 损失를 결합하는 것을 表시합니다.

Negative Log-Likelihood (NLL) Loss

NLL 损失 함수는 交叉熵 损失 함수와 유사하게 작동합니다. 交叉熵 损失는 log-softmax 层层과 NLL 损失을 결합하여 交叉熵 损失 값을 얻습니다. 这意味着 NLL 损失은 신경망의 마지막 层层이 正常的 softmax 层层이 아닌 log-softmax 层层으로 되어 있으면 交叉熵 损失 값을 얻을 수 있습니다.

m = nn.LogSoftmax(dim=1)
loss = nn.NLLLoss()
# 입력 크기는 N x C = 3 x 5
input = torch.randn(3, 5, requires_grad=True)
# 타겟의 각 요소는 0 <= 값 < C 여야 합니다
target = torch.tensor([1, 0, 4])
output = loss(m(input), target)
output.backward()
# 2D 손실 예제 (예를 들어 이미지 입력과 함께 사용됨)
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)
# 타겟의 각 요소는 0 <= 값 < C 여야 합니다
target = torch.empty(N, 8, 8, dtype=torch.long).random_(0, C)
output = loss(m(conv(data)), target)
print(output) #tensor(1.4892, grad_fn=)

#NLLLoss에 대한 크레딧 — PyTorch 1.9.0 문서

이진 교차 엔트로피 손실

이진 교차 엔트로피 손실은 데이터 포인트를 두 개의 클래스에만 분류하는 특별한 문제를 위한 교차 엔트로피 손실의 특별한 유형입니다. 이 유형의 문제에 대한 레이블은 일반적으로 이진이며, 우리의 목표는 모델이 0 레이블에 대해 0에 가까운 수를 예측하고 1 레이블에 대해 1에 가까운 수를 예측하도록 하는 것입니다. 일반적으로 이진 분류에 BCE 손실을 사용할 때, 신경망의 출력은 시그모이드 레이어로, 출력이 0에 가깝거나 1에 가까운 값이 되도록 보장합니다.

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) #tensor(0.4198, grad_fn=)

이진 クロスエントロピー損失について

이전 섹션에서 이진 クロスエン트로피 손실이 sigmoid 层层로 출력되어야 0에서 1 사이의 값이 Ensure가 되도록 한다고 말했습니다. 이진 ク로스エン트로피 손실 with logits는 이러한 두 层层을 하나의 层层로 합칩니다. PyTorch 文档에 따르면, log-sum exp tricks을 이용하여 수치적으로 안정性이 좋은 버전입니다. PyTorch documentation

import torch
import torch.nn as nn

target = torch.ones([10, 64], dtype=torch.float32)  # 64 클래스, 배치 사이즈 = 10
output = torch.full([10, 64], 1.5)  # 예측(logit)
pos_weight = torch.ones([64])  # 모든 가중치는 1로 되어 있습니다.
criterion = torch.nn.BCEWithLogitsLoss(pos_weight=pos_weight)
loss = criterion(output, target)  # -log(sigmoid(1.5))
print(loss) #tensor(0.2014)

Smooth L1 Loss

Fast R-CNN 논문에서 introduced되었으며, 이 기준은 heuristic value beta를 통해 MSE 손실과 MAE 손실의 장점을 결합한 smooth L1 손실函數입니다. 정상적인 값과 예측 값 사이의 절대 차이가 beta를 벗어나지 않으면, 이 기준은 MSE 손실과 유사하게 제곱 차이를 사용합니다. MSE 손실의 그래프는 연속된 曲线이며, 각 손실 값에 대한 梯度(gradient)이 변화하며 모든 곳에서 導出(derived)할 수 있습니다. 또한 손실 값이 감소하면 梯度이 감소하는 것이 이를 기울기 descend(梯度下降)를 위해 유용하게 합니다. 그러나 非常大的 손실 값에 대해 梯度이 폭발하는 것이 있으며, 이러한 梯度 폭발를 방지하기 위해 MAE로 전환합니다. MAE로서 非常大的 손실 값에 대해 梯度이 거의 상수가 되는 것을 의미합니다.

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 embedding loss는 대부분 semi-supervised learning 任务에서 두 개의 입력 사이의 유사성을 衡量(measure)하는 것을 사용합니다. 인풋 텐서와 라벨 텐서가 1이나 -1의 값을 포함하는 것을 사용하며, 이는 non-linear embeddings와 semi-supervised learning에 대한 문제에서 대 preponderance를 享有하고 있습니다.

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)

#입력:  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)
#타겟:  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]])
#출력:  tensor(1.2103, grad_fn=<MeanBackward0>)

마진 랭킹 손실

마진 랭킹 손실은 데이터셋의 입력 집합 간 상대적인 거리를 측정하는 것을 주된 목표로 하는 랭킹 손실에 속합니다. 마진 랭킹 손실 함수는 두 개의 입력과 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:  tensoor([-1.1109,  0.1187,  0.9441], requires_grad=True)
#input2:  tensoor([ 0.9284, -0.3707, -0.7504], requires_grad=True)
#output:  tensoor(0.5648, grad_fn=<MeanBackward0>)

Triplet Margin Loss

이 기준은 트리플렛 형태의 추가 정보를 사용하여 데이터 포인트 사이의 유사도를 측정합니다. 트리플렛은 어нchellor 샘플, 긍정 샘플, 부정 샘플로 구성되며, 이들의 목적은 1) 긍정 샘플과 어нchellor 사이의 거리를 가장 작게 만들고, 2) 어нchellor 샘플과 부정 샘플 사이의 거리가 마argin 값과 긍정 샘플과 어нchellor 사이의 거리의 차이가 更大하도록 만들기 입니다. 보통, 긍정 샘플은 어нchellor 샘플과 같은 claass를 가지지만, 부정 샘플은 그렇지 않습니다. 따라서, 이 손실 함수를 사용하면, 어нchellor와 긍정 샘플 사이의 유사도 값이 높고, 어нchellor와 부정 샘플 사이의 유사도 값이 낮게 하는 트리플렛 마argin 손실을 예측하는 것을 목표로 합니다.

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)  #tensoor(1.1151, grad_fn=<MeanBackward0>)

Cosine Embedding Loss

코사인 嵌入 损失는 입력 x1, x2와 1 또는 -1의 값을 包含하는 레이블 텍스트 y를 사용하여 损失를 衡量하는 것을 의미합니다. 이는 두 입력의 유사성 또는 陌异性을 衡量하는 도입을 사용합니다.

이 기준은 공간 内의 두 데이터 포인트 사이의 코사인 거리를 계산하여 유사성을 衡量하며, 코사인 거리는 두 포인트 사이의 각도와 관계를 맺으며, 각도가 작을 수록 입력이 더 가까이 있으며 따라서 더 유사합니다.

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는 우리의 문제에 따라 사용자 정의 손실 함수를 만들 수 있는 두 가지 인기 있는 방법을 제공한다; 이这些는 클래스 구현과 함수 구현이다. 함수 구현을 시작하여 두 방법을 어떻게 구현할 수 있는지 보겠습니다.

이것은 사용자 정의 손실 함수를 작성하는 가장 간단한 방법입니다. 함수 생성, 필요한 입력값과 다른 매개변수 전달, PyTorch의 핵심 API 또는 Functional API를 사용한 연산 수행, 값 반환 등과 같은 과정이 매우 간단합니다. 사용자 정의 평균 제곱 오차를 사용한 예시를 살펴봅시다.

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)

#custom loss:  tensor(2.3134, grad_fn=<MeanBackward0>)
#pytorch loss:  tensor(2.3134, grad_fn=<MseLossBackward>)

사용자 정의 손실 함수와 PyTorch의 MSE 손실 함수를 사용하여 손실을 계산하면 동일한 결과를 얻을 수 있습니다.

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에서 사용 가능한 损失函數에 대해 많은 이야기를 해보았고, 대부분의 损失函數의 내부 작동方式에 深耕하였습니다. 특정 문제에 적절한 损失函數을 선택하는 것은 멋진 일이 아닐 수 있습니다. 이 튜토리얼과 PyTorch 공식 文档을 함께 이 튜토리얼은 어느 损失函數이 您的 문제에 가장 적절한지 이해하는 데에 가이드라인이 되는지 여기서 시작하세요.