output.backwardgradient = df和loss.backward有什么区别？

问题描述

我目前正在测试开源存储库（https://github.com/jzengust/RGBD2Normal）的表面法线估计，以下函数用作表面法线损失函数：

def l1norm(input,label,mask,train=True):
    # input: bs*ch*h*w
    # label: bs*h*w*ch
    # mask: bs*h*w
    bz,ch,h,w = input.size()
    
    # normalization
    input = input.permute(0,2,3,1).contiguous().view(-1,ch)
    input_v = F.normalize(input,p=2)
    label_v = label.contiguous().view(-1,ch)
    target = torch.ones([input.size(0),],dtype=torch.float).cuda()
    mask_t = mask.contiguous().view(-1,1)
    mask_t = torch.squeeze(mask_t)
    target[torch.eq(mask_t,0)] = -1
    
    if(train == True): # use mask from surface normal
        loss = F.l1_loss(input_v,label_v,reduce=False)#compute inner product
        loss[torch.eq(mask_t,0)] = 0 #rm the masked pixels 
        loss = torch.mean(loss)
        df = torch.autograd.grad(loss,input_v,only_inputs=True)
        df = df[0]
        df = torch.autograd.grad(input_v,input,grad_outputs=df,only_inputs=True)
        df = df[0]
        mask = mask.contiguous().view(-1,1).expand_as(df)
        df[torch.eq(mask,0)] = 0
        df = df.view(-1,w,ch)
        df = df.permute(0,1,2).contiguous()
    else:  # use mask from depth valid
        loss = F.l1_loss(input_v,reduce=False)
        loss[torch.eq(mask_t,0)] = 0
        loss = torch.mean(loss)
        df = None
    return loss,df

然后在训练过程中，通过调用output.backward（gradient = df）而不是loss.backward（）来反向传播梯度，对我来说，第二个似乎更常见。我的问题是，在哪种情况下应该使用torch.autograd.grad（）函数计算梯度，这样做有什么好处？我可以用loss.backward（）替换它吗？

谢谢您的帮助！

解决方法

暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！

如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@）

autograd backpropagation gradient python