PyTorch 自定义损失函数

Question

自定义损失函数应该如何实现？使用以下代码会导致错误：

 import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
import numpy as np
import matplotlib.pyplot as plt
import torch.utils.data as data_utils
import torch.nn as nn
import torch.nn.functional as F

num_epochs = 20

x1 = np.array([0,0])
x2 = np.array([0,1])
x3 = np.array([1,0])
x4 = np.array([1,1])

num_epochs = 200

class cus2(torch.nn.Module):

    def __init__(self):
        super(cus2,self).__init__()

    def forward(self, outputs, labels):
        # reshape labels to give a flat vector of length batch_size*seq_len
        labels = labels.view(-1)

        # mask out 'PAD' tokens
        mask = (labels >= 0).float()

        # the number of tokens is the sum of elements in mask
        num_tokens = int(torch.sum(mask).data[0])

        # pick the values corresponding to labels and multiply by mask
        outputs = outputs[range(outputs.shape[0]), labels]*mask

        # cross entropy loss for all non 'PAD' tokens
        return -torch.sum(outputs)/num_tokens

x = torch.tensor([x1,x2,x3,x4]).float()

y = torch.tensor([0,1,1,0]).long()

train = data_utils.TensorDataset(x,y)
train_loader = data_utils.DataLoader(train , batch_size=2 , shuffle=True)

device = 'cpu'

input_size = 2
hidden_size = 100
num_classes = 2

learning_rate = .0001

class NeuralNet(nn.Module) :
    def __init__(self, input_size, hidden_size, num_classes) :
        super(NeuralNet, self).__init__()
        self.fc1 = nn.Linear(input_size , hidden_size)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(hidden_size , num_classes)

    def forward(self, x) :
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out

for i in range(0 , 1) :

        model = NeuralNet(input_size, hidden_size, num_classes).to(device)

        criterion = nn.CrossEntropyLoss()
#         criterion = Regress_Loss()
#         criterion = cus2()
        optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)

        total_step = len(train_loader)
        for epoch in range(num_epochs) :
            for i,(images , labels) in enumerate(train_loader) :
                images = images.reshape(-1 , 2).to(device)
                labels = labels.to(device)

                outputs = model(images)
                loss = criterion(outputs , labels)

                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
#                 print(loss)

        outputs = model(x)

        print(outputs.data.max(1)[1])

对训练数据做出完美预测：

 tensor([0, 1, 1, 0])

从 这里 使用自定义损失函数：

在上面的代码中实现为 cus2

取消注释代码 # criterion = cus2() 使用此损失函数返回：

 tensor([0, 0, 0, 0])

还返回警告：

用户警告：0 维张量的无效索引。这将是 PyTorch 0.5 中的一个错误。使用 tensor.item() 将 0-dim 张量转换为 Python 数字

我没有正确实现自定义损失函数？

原文由 blue-sky 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 1

您的损失函数在编程上是正确的，但以下情况除外：

     # the number of tokens is the sum of elements in mask
    num_tokens = int(torch.sum(mask).data[0])

当你做 torch.sum 它返回一个 0 维张量，因此警告它不能被索引。要解决此问题，请按照建议执行 int(torch.sum(mask).item()) 或 int(torch.sum(mask)) 也可以。

现在，您是否尝试使用自定义损失来模拟 CE 损失？如果是，那么您缺少 log_softmax

要修复该问题，请在语句 4 之前添加 outputs = torch.nn.functional.log_softmax(outputs, dim=1) 。请注意，如果您已附加教程，则 log_softmax 已在前向调用中完成。你也可以那样做。

另外，我注意到学习速度很慢，即使有 CE 损失，结果也不一致。在自定义和 CE 损失的情况下，将学习率提高到 1e-3 对我来说效果很好。

原文由 Umang Gupta 发布，翻译遵循 CC BY-SA 4.0 许可协议

Answer 2

解决方案

以下是我在 此 Kaggle Notebook 中遇到的一些自定义损失函数示例。它在 PyTorch 以及 TensorFlow 中提供了以下自定义损失函数的实现。

Keras 和 PyTorch 的损失函数参考

我希望这对希望了解如何制作您自己的自定义损失函数的任何人都有帮助。

• 骰子损失
• BCE-骰子损失
• Jaccard/Intersection over Union (IoU) 损失
• 焦点丢失
• 特沃斯基损失
• 局部特沃斯基损失
• Lovasz 铰链损失
• 连击损失

原文由 CypherX 发布，翻译遵循 CC BY-SA 4.0 许可协议