損失函式權威指南「Pytorch」

神經網路可以執行許多不同的任務。無論是分類資料，如將動物圖片分組為貓和狗；或迴歸任務，如預測月收入，還是其他任何事情。每個任務都有不同的輸出，需要不同型別的損失函式。

配置損失函式的方式可以成就或破壞演算法的效能。透過正確配置損失函式，可以確保模型按你希望的方式工作。

對我們來說幸運的是，可以使用損失函式來充分利用機器學習任務。

在本文中，我們將討論 PyTorch 中流行的損失函式，以及構建自定義損失函式。閱讀完本文後，就知道為專案選擇哪一個損失函數了。

1、什麼是損失函式？

在進入 PyTorch 細節之前，讓我們回顧一下什麼是損失函式。

損失函式用於衡量預測輸出與提供的目標值之間的誤差。損失函式告訴我們演算法模型離實現預期結果還有多遠。 “損失”一詞是指模型因未能產生預期結果而受到的懲罰。

例如，損失函式（我們稱之為 J）可以採用以下兩個引數：

預測輸出（y_pred）

目標值（y）

此函式透過將預測輸出與預期輸出進行比較來確定模型的效能。如果 y_pred和 y的偏差很大，loss值會很高。

如果偏差很小或值幾乎相同，它會輸出一個非常低的損失值。因此，當模型在提供的資料集上訓練時，你需要使用可以適當懲罰模型的損失函式。

損失函式會根據你的演算法試圖解決的問題陳述而變化。

2、如何新增 PyTorch 損失函式？

PyTorch 的 torch。nn 模組有多個標準損失函式，可以在你的專案中使用。

要新增它們，需要先匯入庫：

import torchimport torch。nn as nn

接下來，定義要使用的損失型別。以下是定義平均絕對誤差損失函式的方法：

loss = nn。L1Loss（）

新增函式後，可以使用它來完成你的特定任務。

3、PyTorch 中有哪些損失函式可用？

從廣義上講，PyTorch 中的損失函式分為兩大類：迴歸損失和分類損失。

當模型預測連續值（例如人的年齡）時，會使用

迴歸損失函式

。

當模型預測離散值時使用

分類損失函式

，例如電子郵件是否為垃圾郵件。

當模型預測輸入之間的相對距離時使用

排名損失函式

，例如根據產品在電子商務搜尋頁面上的相關性對產品進行排名。

現在我們將探索 PyTorch 中不同型別的損失函式，以及如何使用它們：

平均絕對誤差損失

均方誤差損失

負對數似然損失

交叉熵損失

鉸鏈嵌入損失

邊際排名損失

三元組邊際損失

Kullback-Leibler 散度

3。1 PyTorch平均絕對誤差（L1損失函式）

torch。nn。L1Loss

平均絕對誤差（MAE），也稱為 L1 損失，計算實際值和預測值之間的絕對差之和的平均值。

它檢查一組預測值中誤差的大小，而不關心它們的正方向或負方向。如果不使用誤差的絕對值，則負值可以抵消正值。

Pytorch L1 Loss 表示為：

x 代表實際值，y 代表預測值。

什麼時候可以用L1損失？

迴歸問題，特別是當目標變數的分佈有異常值時，例如與平均值相差很大的小值或大值。它被認為對異常值更穩健。

示例如下：

import torchimport torch。nn as nninput = torch。randn（3， 5， requires_grad=True）target = torch。randn（3， 5）mae_loss = nn。L1Loss（）output = mae_loss（input， target）output。backward（）print（‘input： ’， input）print（‘target： ’， target）print（‘output： ’， output）

###################### OUTPUT ######################input： tensor（［［ 0。2423， 2。0117， -0。0648， -0。0672， -0。1567］，［-0。2198， -1。4090， 1。3972， -0。7907， -1。0242］，［ 0。6674， -0。2657， -0。9298， 1。0873， 1。6587］］， requires_grad=True）target： tensor（［［-0。7271， -0。6048， 1。7069， -1。5939， 0。1023］，［-0。7733， -0。7241， 0。3062， 0。9830， 0。4515］，［-0。4787， 1。3675， -0。7110， 2。0257， -0。9578］］）output： tensor（1。2850， grad_fn=）

3。2 PyTorch 均方誤差損失函式

torch。nn。MSELoss

均方誤差（MSE），也稱為 L2 損失，計算實際值和預測值之間的平方差的平均值。

無論實際值和預測值的符號如何，Pytorch MSE Loss 始終輸出正結果。為了提高模型的準確性，你應該嘗試減少 L2 Loss——一個完美的值是 0。0。

平方意味著較大的錯誤比較小的錯誤產生更大的錯誤。如果分類器偏離 100，則錯誤為 10，000。如果偏離 0。1，則誤差為 0。01。這會懲罰犯大錯誤的模型並鼓勵小錯誤。

Pytorch L2 Loss 表示為：

x 代表實際值，y 代表預測值。

什麼時候可以用？

MSE 是大多數 Pytorch 迴歸問題的預設損失函式。

示例如下：

import torchimport torch。nn as nninput = torch。randn（3， 5， requires_grad=True）target = torch。randn（3， 5）mse_loss = nn。MSELoss（）output = mse_loss（input， target）output。backward（）print（‘input： ’， input）print（‘target： ’， target）print（‘output： ’， output）

3。3 PyTorch 負對數似然損失函式

torch。nn。NLLLoss

負對數似然損失函式（NLL）僅適用於以 softmax 函式作為輸出啟用層的模型。 Softmax 是指計算層中每個單元的歸一化指數函式的啟用函式。

Softmax函式表示為：

該函式採用大小為 N 的輸入向量，然後修改值，使每個值都落在 0 和 1 之間。此外，它對輸出進行歸一化，使向量的 N 個值之和等於 1。

NLL 使用否定含義，因為機率（或可能性）在0和1之間變化，並且此範圍內值的對數為負。最後，損失值變為正值。

在 NLL 中，最小化損失函式有助於我們獲得更好的輸出。從近似最大似然估計（MLE）中檢索負對數似然。這意味著我們嘗試最大化模型的對數似然，並因此最小化 NLL。

在 NLL 中，模型因做出正確預測的機率較小而受到懲罰，並因預測機率較高而受到鼓勵。對數執行懲罰。

NLL 不僅關心預測是否正確，還關心模型對高分預測的確定性。

Pytorch NLL Loss 表示為：

其中 x 是輸入，y 是目標，w 是權重，N 是批次大小。

什麼時候可以用？

多類分類問題

示例如下：

import torchimport torch。nn as nn# size of input （N x C） is = 3 x 5input = torch。randn（3， 5， requires_grad=True）# every element in target should have 0 <= value < Ctarget = torch。tensor（［1， 0， 4］）m = nn。LogSoftmax（dim=1）nll_loss = nn。NLLLoss（）output = nll_loss（m（input）， target）output。backward（）print（‘input： ’， input）print（‘target： ’， target）print（‘output： ’， output）

###################### OUTPUT ######################input： tensor（［［ 1。6430， -1。1819， 0。8667， -0。5352， 0。2585］，［ 0。8617， -0。1880， -0。3865， 0。7368， -0。5482］，［-0。9189， -0。1265， 1。1291， 0。0155， -2。6702］］， requires_grad=True）target： tensor（［1， 0， 4］）output： tensor（2。9472， grad_fn=）

3。4 PyTorch 交叉熵損失函式

torch。nn。CrossEntropyLoss

此損失函式針對提供的一組事件或隨機變數計算兩個機率分佈之間的差異。

它用於計算出一個分數，該分數總結了預測值和實際值之間的平均差異。為了提高模型的準確性，你應該嘗試最小化分數——交叉熵分數介於 0 和 1 之間，完美值為 0。

其他損失函式，如平方損失，懲罰不正確的預測。交叉熵會因為非常自信和錯誤而受到很大懲罰。

與不根據預測置信度進行懲罰的負對數似然損失不同，交叉熵懲罰不正確但置信度高的預測，以及正確但置信度較低的預測。

交叉熵函式有多種變體，其中最常見的型別是二元交叉熵（BCE）。 BCE Loss主要用於二元分類模型；也就是說，模型只有 2 個類。

Pytorch 交叉熵損失表示為：

其中 x 是輸入，y 是目標，w 是權重，C 是類數，N 跨越小批次維度。

什麼時候可以用？

二元分類任務，它是 Pytorch 中的預設損失函式。

建立有信心的模型——預測將是準確的，而且機率更高。

示例如下：

import torchimport torch。nn as nninput = torch。randn（3， 5， requires_grad=True）target = torch。empty（3， dtype=torch。long）。random_（5）cross_entropy_loss = nn。CrossEntropyLoss（）output = cross_entropy_loss（input， target）output。backward（）print（‘input： ’， input）print（‘target： ’， target）print（‘output： ’， output）

###################### OUTPUT ######################input： tensor（［［ 0。1639， -1。2095， 0。0496， 1。1746， 0。9474］，［ 1。0429， 1。3255， -1。2967， 0。2183， 0。3562］，［-0。1680， 0。2891， 1。9272， 2。2542， 0。1844］］， requires_grad=True）target： tensor（［4， 0， 3］）output： tensor（1。0393， grad_fn=）

3。5 PyTorch 鉸鏈嵌入損失函式

torch。nn。HingeEmbeddingLoss

Hinge Embedding Loss 用於計算輸入張量 x 和標籤張量 y 時的損失。目標值介於 {1， -1} 之間，這使其適用於二元分類任務。

使用 Hinge Loss 函式，只要實際類別值和預測類別值之間的符號存在差異，就可以給出更多錯誤。這激勵示例具有正確的符號。

Hinge Embedding Loss 表示為：

什麼時候可以用？

分類問題，尤其是在確定兩個輸入是不同還是相似時。

學習非線性嵌入或半監督學習任務。

示例如下：

import torchimport torch。nn as nninput = 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）

###################### OUTPUT ######################input： tensor（［［ 0。1054， -0。4323， -0。0156， 0。8425， 0。1335］，［ 1。0882， -0。9221， 1。9434， 1。8930， -1。9206］，［ 1。5480， -1。9243， -0。8666， 0。1467， 1。8022］］， requires_grad=True）target： tensor（［［-1。0748， 0。1622， -0。4852， -0。7273， 0。4342］，［-1。0646， -0。7334， 1。9260， -0。6870， -1。5155］，［-0。3828， -0。4476， -0。3003， 0。6489， -2。7488］］）output： tensor（1。2183， grad_fn=）

3。6 PyTorch 邊際排名損失函式

torch。nn。MarginRankingLoss

Margin Ranking Loss 計算一個標準來預測輸入之間的相對距離。這不同於其他損失函式，例如 MSE 或交叉熵，它們學習直接從一組給定的輸入進行預測。

使用 Margin Ranking Loss，你可以計算損失，前提是有輸入 x1、x2 以及標籤張量 y（包含 1 或 -1）。

當 y == 1 時，第一個輸入將被假定為較大的值。它將比第二個輸入排名更高。如果 y == -1，則第二個輸入的排名更高。

Pytorch Margin Ranking Loss 表示為：

什麼時候可以用？

排名問題

示例如下：

import torchimport torch。nn as nninput_one = torch。randn（3， requires_grad=True）input_two = torch。randn（3， requires_grad=True）target = torch。randn（3）。sign（）ranking_loss = nn。MarginRankingLoss（）output = ranking_loss（input_one， input_two， target）output。backward（）print（‘input one： ’， input_one）print（‘input two： ’， input_two）print（‘target： ’， target）print（‘output： ’， output）

###################### OUTPUT ######################input one： tensor（［1。7669， 0。5297， 1。6898］， requires_grad=True）input two： tensor（［ 0。1008， -0。2517， 0。1402］， requires_grad=True）target： tensor（［-1。， -1。， -1。］）output： tensor（1。3324， grad_fn=）

3。7 PyTorch Triplet Margin 損失函式

torch。nn。TripletMarginLoss

Triplet Margin Loss 計算衡量模型中三重態損失的標準。使用此損失函式，你可以計算損失，前提是輸入張量 x1、x2、x3 以及值大於零的邊距。

三元組由 a（錨點）、p（正例）和 n（負例）組成。

Pytorch Triplet Margin Loss 表示為：

什麼時候可以用？

確定樣本之間存在的相對相似性。

用於基於內容的檢索問題

示例如下：

import torchimport torch。nn as nnanchor = torch。randn（100， 128， requires_grad=True）positive = torch。randn（100， 128， requires_grad=True）negative = torch。randn（100， 128， requires_grad=True）triplet_margin_loss = nn。TripletMarginLoss（margin=1。0， p=2）output = triplet_margin_loss（anchor， positive， negative）output。backward（）print（‘anchor： ’， anchor）print（‘positive： ’， positive）print（‘negative： ’， negative）print（‘output： ’， output）

###################### OUTPUT ######################anchor： tensor（［［ 0。6152， -0。2224， 2。2029，。。。， -0。6894， 0。1641， 1。7254］，［ 1。3034， -1。0999， 0。1705，。。。， 0。4506， -0。2095， -0。8019］，［-0。1638， -0。2643， 1。5279，。。。， -0。3873， 0。9648， -0。2975］，。。。，［-1。5240， 0。4353， 0。3575，。。。， 0。3086， -0。8936， 1。7542］，［-1。8443， -2。0940， -0。1264，。。。， -0。6701， -1。7227， 0。6539］，［-3。3725， -0。4695， -0。2689，。。。， 2。6315， -1。3222， -0。9542］］， requires_grad=True）positive： tensor（［［-0。4267， -0。1484， -0。9081，。。。， 0。3615， 0。6648， 0。3271］，［-0。0404， 1。2644， -1。0385，。。。， -0。1272， 0。8937， 1。9377］，［-1。2159， -0。7165， -0。0301，。。。， -0。3568， -0。9472， 0。0750］，。。。，［ 0。2893， 1。7894， -0。0040，。。。， 2。0052， -3。3667， 0。5894］，［-1。5308， 0。5288， 0。5351，。。。， 0。8661， -0。9393， -0。5939］，［ 0。0709， -0。4492， -0。9036，。。。， 0。2101， -0。8306， -0。6935］］， requires_grad=True）negative： tensor（［［-1。8089， -1。3162， -1。7045，。。。， 1。7220， 1。6008， 0。5585］，［-0。4567， 0。3363， -1。2184，。。。， -2。3124， 0。7193， 0。2762］，［-0。8471， 0。7779， 0。1627，。。。， -0。8704， 1。4201， 1。2366］，。。。，［-1。9165， 1。7768， -1。9975，。。。， -0。2091， -0。7073， 2。4570］，［-1。7506， 0。4662， 0。9482，。。。， 0。0916， -0。2020， -0。5102］，［-0。7463， -1。9737， 1。3279，。。。， 0。1629， -0。3693， -0。6008］］， requires_grad=True）output： tensor（1。0755， grad_fn=）

3。8 PyTorch Kullback-Leibler 散度損失函式

torch。nn。KLDivLoss

Kullback-Leibler 散度，縮寫為 KL 散度，計算兩個機率分佈之間的差異。

使用此損失函式，你可以計算在預測機率分佈用於估計預期目標機率分佈的情況下丟失的資訊量（以位表示）。

它的輸出告訴你兩個機率分佈的接近程度。如果預測的機率分佈與真實的機率分佈相差甚遠，就會導致很大的損失。如果 KL Divergence 的值為零，則意味著機率分佈相同。

KL 散度的行為就像交叉熵損失，它們在處理預測機率和實際機率的方式上存在關鍵差異。 Cross-Entropy 根據預測的置信度對模型進行懲罰，而 KL Divergence 則不會。 KL 散度僅評估機率分佈預測與地面實況分佈有何不同。

KL Divergence Loss表示為：

x 代表真實標籤的機率，y 代表預測標籤的機率。

什麼時候可以用？

逼近複雜函式

多類分類任務

如果你想確保預測的分佈與訓練資料的分佈相似

示例如下：

import torchimport torch。nn as nninput = torch。randn（2， 3， requires_grad=True）target = torch。randn（2， 3）kl_loss = nn。KLDivLoss（reduction = ‘batchmean’）output = kl_loss（input， target）output。backward（）print（‘input： ’， input）print（‘target： ’， target）print（‘output： ’， output）

###################### OUTPUT ######################input： tensor（［［ 1。4676， -1。5014， -1。5201］，［ 1。8420， -0。8228， -0。3931］］， requires_grad=True）target： tensor（［［ 0。0300， -1。7714， 0。8712］，［-1。7118， 0。9312， -1。9843］］）output： tensor（0。8774， grad_fn=）

4、如何在 PyTorch 中建立自定義損失函式？

PyTorch 允許你建立自己的自定義損失函式以在專案中實施。

下面介紹如何建立自己的簡單交叉熵損失函式。

一種方法是建立自定義損失函式作為 python 函式：

def myCustomLoss（my_outputs， my_labels）： #specifying the batch size my_batch_size = my_outputs。size（）［0］ #calculating the log of softmax values my_outputs = F。log_softmax（my_outputs， dim=1） #selecting the values that correspond to labels my_outputs = my_outputs［range（my_batch_size）， my_labels］ #returning the results return -torch。sum（my_outputs）/number_examples

還可以建立其他高階 PyTorch 自定義損失函式。

另一種方法是使用類定義建立自定義損失函式

讓我們修改計算兩個樣本之間相似度的 Dice 係數，作為二元分類問題的損失函式：

class DiceLoss（nn。Module）： def __init__（self， weight=None， size_average=True）： super（DiceLoss， self）。__init__（） def forward（self， inputs， targets， smooth=1）： inputs = F。sigmoid（inputs） inputs = inputs。view（-1） targets = targets。view（-1） intersection = （inputs * targets）。sum（） dice = （2。*intersection + smooth）/（inputs。sum（） + targets。sum（） + smooth） return 1 - dice

5、如何監控 PyTorch 損失函式？

很明顯，在訓練模型時，需要關注損失函式值以跟蹤模型的效能。隨著損失值不斷減小，模型不斷變好。我們可以透過多種方式做到這一點。讓我們來看看它們。

為此，我們將訓練一個在 PyTorch 中建立的簡單神經網路，它將對著名的 Iris 資料集進行分類。

進行獲取資料集所需的匯入。

from sklearn。datasets import load_irisfrom sklearn。model_selection import train_test_splitfrom sklearn。preprocessing import StandardScaler

載入資料集：

iris = load_iris（）X = iris［‘data’］y = iris［‘target’］names = iris［‘target_names’］feature_names = iris［‘feature_names’］

將資料集縮放為均值 = 0 和方差 = 1，可以快速收斂模型。

scaler = StandardScaler（）X_scaled = scaler。fit_transform（X）

以 80-20 的比例將資料集拆分為訓練集和測試集。

X_train， X_test， y_train， y_test = train_test_split（X_scaled， y， test_size=0。2， random_state=2）

為我們的神經網路及其訓練進行必要的匯入。

import torchimport torch。nn。functional as Fimport torch。nn as nnimport matplotlib。pyplot as pltimport numpy as npplt。style。use（‘ggplot’）

定義網路：

class PyTorch_NN（nn。Module）： def __init__（self， input_dim， output_dim）： super（PyTorch_NN， self）。__init__（） self。input_layer = nn。Linear（input_dim， 128） self。hidden_layer = nn。Linear（128， 64） self。output_layer = nn。Linear（64， output_dim） def forward（self， x）： x = F。relu（self。input_layer（x）） x = F。relu（self。hidden_layer（x）） x = F。softmax（self。output_layer（x）， dim=1） return x

定義用於獲得準確性和訓練網路的函式。

def get_accuracy（pred_arr，original_arr）： pred_arr = pred_arr。detach（）。numpy（） original_arr = original_arr。numpy（） final_pred= ［］ for i in range（len（pred_arr））： final_pred。append（np。argmax（pred_arr［i］）） final_pred = np。array（final_pred） count = 0 for i in range（len（original_arr））： if final_pred［i］ == original_arr［i］： count+=1 return count/len（final_pred）*100def train_network（model， optimizer， criterion， X_train， y_train， X_test， y_test， num_epochs）： train_loss=［］ train_accuracy=［］ test_accuracy=［］ for epoch in range（num_epochs）： #forward feed output_train = model（X_train） train_accuracy。append（get_accuracy（output_train， y_train）） #calculate the loss loss = criterion（output_train， y_train） train_loss。append（loss。item（）） #clear out the gradients from the last step loss。backward（） optimizer。zero_grad（） #backward propagation： calculate gradients loss。backward（） #update the weights optimizer。step（） with torch。no_grad（）： output_test = model（X_test） test_accuracy。append（get_accuracy（output_test， y_test）） if （epoch + 1） % 5 == 0： print（f“Epoch {epoch+1}/{num_epochs}， Train Loss： {loss。item（）：。4f}， Train Accuracy： {sum（train_accuracy）/len（train_accuracy）：。2f}， Test Accuracy： {sum（test_accuracy）/len（test_accuracy）：。2f}”） return train_loss， train_accuracy， test_accuracy

建立模型、最佳化器和損失函式物件。

input_dim = 4output_dim = 3learning_rate = 0。01model = PyTorch_NN（input_dim， output_dim）criterion = nn。CrossEntropyLoss（）optimizer = torch。optim。Adam（model。parameters（）， lr=learning_rate）

6、在notebook中監控PyTorch loss

現在你一定已經注意到 train_network 函式中的列印語句來監控損失和準確性。這是一種方法。

X_train = torch。FloatTensor（X_train）X_test = torch。FloatTensor（X_test）y_train = torch。LongTensor（y_train）y_test = torch。LongTensor（y_test）train_loss， train_accuracy， test_accuracy = train_network（model=model， optimizer=optimizer， criterion=criterion， X_train=X_train， y_train=y_train， X_test=X_test， y_test=y_test， num_epochs=100）

我們得到這樣的輸出。

如果需要，我們還可以使用 Matplotlib 繪製這些值：

fig，（ax1， ax2， ax3） = plt。subplots（3， figsize=（12， 6）， sharex=True）ax1。plot（train_accuracy）ax1。set_ylabel（“training accuracy”）ax2。plot（train_loss）ax2。set_ylabel（“training loss”）ax3。plot（test_accuracy）ax3。set_ylabel（“test accuracy”）ax3。set_xlabel（“epochs”）

我們會看到這樣的圖表，表明損失和準確性之間的相關性。

這種方法還不錯，可以完成工作。但我們必須記住，我們的問題陳述和模型越複雜，它需要的監控技術就越複雜。

7、使用 Neptune 監控 PyTorch 損失

一種更簡單的監控指標的方法是將其記錄在一個地方，使用 Neptune 之類的服務，並專注於更重要的任務，例如構建和訓練模型。

為此，我們只需要執行幾個小步驟。

首先，讓我們安裝所需的東西。

pip install neptune-client

現在讓我們初始化 Neptune 執行。

import neptune。new as neptunerun = neptune。init（project = ‘common/pytorch-integration’， api_token = ‘ANONYMOUS’， source_files = ［‘*。py’］）

我們還可以分配配置變數，例如：

run［‘config/model’］ = type（model）。__name__run［‘config/criterion’］ = type（criterion）。__name__run［‘config/optimizer’］ = type（optimizer）。__name__

這是它在 UI 中的樣子。

最後，我們可以透過在 train_network 函式中新增幾行來記錄我們的損失。注意“執行”相關的行。

def train_network（model， optimizer， criterion， X_train， y_train， X_test， y_test， num_epochs）： train_loss=［］ train_accuracy=［］ test_accuracy=［］ for epoch in range（num_epochs）： #forward feed output_train = model（X_train） acc = get_accuracy（output_train， y_train） train_accuracy。append（acc） run［“training/epoch/accuracy”］。log（acc） #calculate the loss loss = criterion（output_train， y_train） run［“training/epoch/loss”］。log（loss） train_loss。append（loss。item（）） #clear out the gradients from the last step loss。backward（） optimizer。zero_grad（） #backward propagation： calculate gradients loss。backward（） #update the weights optimizer。step（） with torch。no_grad（）： output_test = model（X_test） test_acc = get_accuracy（output_test， y_test） test_accuracy。append（test_acc） run［“test/epoch/accuracy”］。log（test_acc） if （epoch + 1） % 5 == 0： print（f“Epoch {epoch+1}/{num_epochs}， Train Loss： {loss。item（）：。4f}， Train Accuracy： {sum（train_accuracy）/len（train_accuracy）：。2f}， Test Accuracy： {sum（test_accuracy）/len（test_accuracy）：。2f}”） return train_loss， train_accuracy， test_accuracy

這是我們在儀表板中得到的。絕對無縫。