Question

我在Pytorch中的自定义损失功能在训练期间不会更新。损失保持不变。我正在尝试根据误报率和误报率编写此自定义损失函数。我给您简化的代码版本。知道会发生什么吗？反向传播是否变为0？这不是定义自定义损失函数的正确方法吗？

我已经检查过，在反向传播期间，渐变始终保持为TRUE（置位require_grad）。我也尝试过制作一个函数false_pos_neg_rate的类（torch.nn.module），但这没有用。断言Requires_grad为负数，此后我将其省略。没有错误，培训确实会继续。

def false_pos_neg_rate(outputs, truths):
    y = truths
    y_predicted = outputs
    cut_off= torch.tensor(0.5, requires_grad=True)
    y_predicted =torch.where(y_predicted <= cut_off, zeros, ones)
    tp, fp, tn, fn = confusion_matrix(y_predicted, y)
    fp_rate = fp / (fp+tn).float()
    fn_rate = fn / (fn+tp).float()
    loss = fn_rate + fp_rate
    return loss

for i, (samples, truths) in enumerate(train_loader):
    samples = Variable(samples)
    truths = Variable(truths)    
    outputs = model(samples) 
    loss = false_pos_neg_rate_torch(outputs, truths)
    loss.backward()                  
    optimizer.step()

我希望损失函数能够更新模型，并且在每个训练步骤中都会更小。相反，损失保持不变，什么也没有发生。

请帮助我，会发生什么？为什么在训练步骤中无法训练模型？

Answer 1

正如Umang Gupta所指出的，损失函数是不可微的。如果以数学方式写，那么您会发现损失几乎在所有地方都具有零梯度，并且表现得像“阶跃函数”。
为了使用梯度下降方法训练模型，您必须具有针对损失函数的有意义的梯度。

Answer 2

根据您的提示，我更新了损失函数。我做了一个假人，所以您也可以检查前两个功能。我添加了其余的内容，因此您可以看到它是如何实现的。但是，仍然在某个地方梯度变为零。现在渐变变为零的步骤是什么，或者该如何检查？请我想知道如何解决这个问题：）。

我尝试为您提供更多信息，以便您也可以玩耍，但是如果您错过任何事情，请告诉我！

y = Variable(torch.tensor((0, 0, 0, 1, 1,1), dtype=torch.float), requires_grad = True)
y_pred = Variable(torch.tensor((0.333, 0.2, 0.01, 0.99, 0.49, 0.51), dtype=torch.float), requires_grad = True)

def binary_y_pred(y_pred):
    y_pred.register_hook(lambda grad: print(grad))
    y_pred = y_pred+torch.tensor(0.5, requires_grad=True, dtype=torch.float)
    y_pred = y_pred.pow(5)  # this is my way working around using torch.where() 
    y_pred = y_pred.pow(10)
    y_pred = y_pred.pow(15)
    m = nn.Sigmoid()
    y_pred = m(y_pred)
    y_pred = y_pred-torch.tensor(0.5, requires_grad=True, dtype=torch.float)
    y_pred = y_pred*2
    y_pred.register_hook(lambda grad: print(grad))
    return y_pred

def confusion_matrix(y_pred, y):
    TP = torch.sum(y*y_pred)
    TN = torch.sum((1-y)*(1-y_pred))
    FP = torch.sum((1-y)*y_pred)
    FN = torch.sum(y*(1-y_pred))

    k_eps = torch.tensor(1e-12, requires_grad=True, dtype=torch.float)
    FN_rate = FN/(TP + FN + k_eps)
    FP_rate = FP/(TN + FP + k_eps)
    cost = FN_rate + FP_rate
    return cost

class FeedforwardNeuralNetModel(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super(FeedforwardNeuralNetModel, self).__init__()
        self.fc1 = nn.Linear(input_dim, hidden_dim) 
        self.relu1 = nn.ReLU()
        self.fc2 = nn.Linear(hidden_dim, output_dim)
        self.sigmoid = nn.Sigmoid()

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

model = FeedforwardNeuralNetModel(input_dim, hidden_dim, output_dim)

optimizer = torch.optim.Adam(model.parameters(), lr=0.0001, betas=[0.9, 0.99], amsgrad=True)
criterion = torch.nn.BCELoss(weight=None, size_average=None, reduce=None, reduction='mean')


    samples= Variable(samples)
    truths = Variable(truths)    
    outputs = model(samples) 
    loss = confusion_matrix(outputs, truths)
    loss.backward()                  
    optimizer.step()

我在Pytorch中的自定义损失功能无法训练

2 个答案: