来自 2 个列表的差异的可微分损失

Question

I have a model

import torch
from torch.autograd import grad
import torch.nn as nn
import torch.optim as optim

class net_x(nn.Module): 
        def __init__(self):
            super(net_x, self).__init__()
            self.fc1=nn.Linear(1, 1) 
            self.out=nn.Linear(1, 1) 

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

nx = net_x()
#inputs
t = torch.tensor([1.0, 2.0, 3.2], requires_grad = True) #input vector
t = torch.reshape(t, (3,1)) #reshape for batch

and 2 lists:

pred_lst = [] 
goal_lst = list(range(10))

I was trying to get the loss between these two lists as follows:

for epoch in range(10):
    optimizer.zero_grad()
    y = nx(t)
    if torch.sum(y) > 5:
        pred_lst.append(epoch) 
    else:
        pass
    loss = len(set(pred_lst).symmetric_difference(set(goal_lst)))
    loss = torch.tensor(float(loss), requires_grad = True)
    print('loss: ', loss)
    loss.backward()

But the parameters were not updating because symmetric_difference is a non differentiable operation. How can I modify/use something else that will take these 2 lists and give me a differentiable loss that I can backpropagate?

Answer 1

Questions of non-differentiability aside, here's how you'd do it with K-hot encoding and L1:

label_vec = torch.zeros(100).float()
label_vec[goal_lst] = 1

pred_vec = torch.zeros(100).float()
pred_vec[pred_lst] = 1

loss = torch.nn.L1Loss(pred_vec,label_vec)

But the indexing operations are non-differentiable with respect to the indices I believe.

It seems that to solve this issue one solution would be to have your NN natively output a vector ( pred_vec ) rather than a list. Furthermore, this vector should likely contain values in the range [0,1] so that the gradient contains meaningful information. Standard practice would be to output continuous predictions during training, and use some cuttoff to determine the list of final discrete outputs for inference.