标签: loss-function

我有一个简单的神经网络：

import torch
import torch.nn as nn
import torch.optim as optim

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.fc1 = nn.Linear(1, 5)
        self.fc2 = nn.Linear(5, 10)
        self.fc3 = nn.Linear(10, 1)

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

net = Model()

opt = optim.Adam(net.parameters())

我还有一些输入功能：

features = torch.rand((3,1)) 

我可以使用一个简单的损失函数来正常训练它，该函数将被最小化：

for i in range(10):
    opt.zero_grad()
    out = net(features)
    loss = torch.mean(torch.square(torch.tensor(5) - torch.sum(out)))
    print('loss:', loss)
    loss.backward()
    opt.step()

但是，如果我添加另一个我想要最大化的损失分量loss2——：

loss2s = [] …

import torch
import torchvision.models as models
model = models.resnet18()
optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)
x = torch.randn(1, 3, 224, 224)
y = torch.randn(1, 3, 224, 224)

#第一种方法

loss1 = model(x).mean()
loss2 = model(y).mean()
(loss1+loss2).backward()
optimizer.step()

我想转发两个数据集，它们的总损失将用于向后和更新一个模型。这种做法正确吗？

#第二种方法

loss1 = model(x).mean()
loss1.backward()
loss2 = model(y).mean()
loss2.backward()
optimizer.step()

第一种方法和第二种方法有什么区别？

我遇到过这行代码。

loss={'ctc': lambda y_true, y_pred: y_pred}

1. lambda的功能是什么？

2.“ ctc”的用途是什么？

根据Keras的骰子系数损失函数的实现，损失为骰子系数计算值的负值。损失应该随着时期的减少而减少，但是通过这种实现，我自然会总是得到负损失，并且损失随着时期的减少而减少，即从0移向负无穷大，而不是接近于0。如果我使用（1-骰子co-eff）而不是（-dice co-eff）作为损失，这是错误的吗？ 这是完整的Keras实现（我正在谈论）：https : //github.com/jocicmarko/ultrasound-nerve-segmentation/blob/master/train.py

smooth = 1.

def dice_coef(y_true, y_pred):
    y_true_f = K.flatten(y_true)
    y_pred_f = K.flatten(y_pred)
    intersection = K.sum(y_true_f * y_pred_f)
    return (2. * intersection + smooth) / (K.sum(y_true_f) + K.sum(y_pred_f) + smooth)


def dice_coef_loss(y_true, y_pred):
return -dice_coef(y_true, y_pred)

我已经与您分享了我的实验日志，尽管仅记录了2个纪元：

Train on 2001 samples, validate on 501 samples
Epoch 1/2
Epoch 00001: loss improved from inf to -0.73789, saving model to unet.hdf5
 - 3229s - loss: -7.3789e-01 - dice_coef: 0.7379 - val_loss: -7.9304e-01 - val_dice_coef: 0.7930
Epoch …

我想实现一个分类器，它可以有 10 个可能的类中的 1 个。我正在尝试使用 MultiClass Softmax 损失函数来做到这一点。通过文档，我不清楚该功能需要什么输入。

文档说它需要 [N, C] 的两个矩阵，其中一个是输入，另一个是目标。据我所知，输入矩阵将是我的神经网络将计算的矩阵，它具有神经网络对 10 个类别中的每一个类别给出的概率。目标是我从数据集中获得的目标。

文档说 - “目标（N，C） - 用 -1 填充的标签目标确保与输入相同的形状。” 这是什么意思？我是否在不正确的类中传递零并为正确的类传递 -1？

如果有人可以对此进行详细说明并显示甚至可以作为目标矩阵传递的示例二维矩阵，那就太好了。

我找不到 yolov4 损失函数的解释。

当我们训练神经网络时，我们通常使用梯度下降，这依赖于连续的，可微分的实值成本函数。最终成本函数可能会产生均方误差。或者换种说法，梯度下降隐式地认为最终目标是回归 -最大限度地减少实值误差度量。

有时，我们希望神经网络要做的就是执行分类 -给定输入，将其分类为两个或多个离散类别。在这种情况下，用户关心的最终目标是分类准确性-正确分类的案例的百分比。

但是，当我们使用神经网络进行分类时，尽管我们的目标是分类准确度，但这并不是神经网络试图优化的目标。神经网络仍在尝试优化实值成本函数。有时这些指向同一方向，但有时却不同。特别是，我一直在遇到这样的情况：经过训练以正确最小化成本函数的神经网络具有比简单的手工编码阈值比较差的分类精度。

我已经使用TensorFlow将其简化为一个最小的测试用例。它建立一个感知器（无隐藏层的神经网络），在绝对最小的数据集（一个输入变量，一个二进制输出变量）上训练它，评估结果的分类精度，然后将其与简单手的分类精度进行比较编码的阈值比较；结果分别是60％和80％。直观地讲，这是因为具有大输入值的单个离群值会产生相应的大输出值，因此，将成本函数最小化的方法是，在对两种以上普通情况进行错误分类的过程中，要尽最大努力适应这种情况。感知器正确地执行了被告知要执行的操作；只是这与我们实际想要的分类器不符。

我们如何训练神经网络，使其最终最大化分类精度？

import numpy as np
import tensorflow as tf
sess = tf.InteractiveSession()
tf.set_random_seed(1)

# Parameters
epochs = 10000
learning_rate = 0.01

# Data
train_X = [
    [0],
    [0],
    [2],
    [2],
    [9],
]
train_Y = [
    0,
    0,
    1,
    1,
    0,
]

rows = np.shape(train_X)[0]
cols = np.shape(train_X)[1]

# Inputs and outputs
X = tf.placeholder(tf.float32)
Y = tf.placeholder(tf.float32)

# Weights
W = tf.Variable(tf.random_normal([cols]))
b = tf.Variable(tf.random_normal([]))

# Model
pred …

我想在pytorch中实现以下距离损失功能。我正在关注pytorch论坛上的https://discuss.pytorch.org/t/custom-loss-functions/29387/4主题

np.linalg.norm(output - target)
# where output.shape = [1, 2] and target.shape = [1, 2]

所以我实现了这样的损失功能

def my_loss(output, target):    
    loss = torch.tensor(np.linalg.norm(output.detach().numpy() - target.detach().numpy()))
    return loss

使用此损失函数，向后调用会产生运行时错误

RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn

我的整个代码看起来像这样

model = nn.Linear(2, 2)

x = torch.randn(1, 2)
target = torch.randn(1, 2)
output = model(x)

loss = my_loss(output, target)
loss.backward()   <----- Error here

print(model.weight.grad)

PS：我知道pytorch是成对丢失的，但是由于它的某些限制，我必须自己实现。

按照pytorch源代码，我尝试了以下操作，

class my_function(torch.nn.Module): # forgot to define backward()
    def forward(self, …

我在 pytorch 中实现软交叉熵损失时遇到一些问题。

我需要为我的模型实现加权软交叉熵损失，这意味着目标值也是概率向量，而不是热向量。

我尝试按照一些论坛中的建议使用 kldivloss，但它不需要权重向量，所以我无法使用它。

一般来说，我对如何使用 pytorch 创建自定义损失函数以及自动梯度如何遵循自定义损失函数有点困惑，特别是如果在模型之后我们应用一些非数学函数，例如映射模型的输出到某个向量并计算映射向量的损失等。