标签: autograd

当最终张量中有多个值时可以使用 autograd 吗？

我尝试了以下方法。

x = torch.tensor([4.0, 5.0], requires_grad=True)
y = x ** 2

print(y)

y.backward()

抛出错误

RuntimeError: grad can be implicitly created only for scalar outputs

然而，以下工作。

x = torch.tensor([4.0, 5.0], requires_grad=True)
y = x ** 2
y = torch.sum(y)
print(y)

y.backward()
print(x.grad)

输出为

tensor(41., grad_fn=<SumBackward0>)
tensor([ 8., 10.])

我在这里遗漏了什么，或者我可以继续假设 autograd 仅在最终张量中有单个值时才有效？

我试图了解 pytorch autograd 的工作原理。如果我有函数 y = 2x 和 z = y**2，如果我做正态微分，我在 x = 1 处得到 dz/dx 为 8 (dz/dx = dz/dy * dy/dx = 2y*2 = 2 (2x)*2 = 8x)。或者，z = (2x)**2 = 4x^2 并且 dz/dx = 8x，所以在 x = 1 时，它是 8。

如果我对 pytorch autograd 做同样的事情，我会得到 4

x = torch.ones(1,requires_grad=True)
y = 2*x
z = y**2
x.backward(z)
print(x.grad)

哪个打印

tensor([4.])

我哪里错了？

通常，一个forward函数将一堆层串在一起并返回最后一层的输出。在返回之前的最后一层之后，我可以做一些额外的处理吗？例如，一些标量乘法和通过.view?

我知道 autograd 以某种方式计算出梯度。所以我不知道我的额外处理是否会以某种方式搞砸。谢谢。

with torch.no_grad():
    input = Variable(input).cuda()
    target = Variable(target).cuda(non_blocking=True)
y=model(input)
# many things here

no_grad 是否继续在“with”范围之外生效？

在 Pytorch 训练中，我使用复合损失函数，定义为： 。为了更新权重 alpha 和 beta，我需要计算三个值：它们是网络中所有权重的损失项梯度的平均值。

有没有一种有效的方法可以在 pytorch 中编写它？

我的训练代码如下所示：

for epoc in range(1, nb_epochs+1):
  #init
  optimizer_fo.zero_grad()
  #get the current loss
  loss_total = mynet_fo.loss(tensor_xy_dirichlet,g_boundaries_d,tensor_xy_inside,tensor_f_inter,tensor_xy_neuman,g_boundaries_n)
  #compute gradients
  loss_total.backward(retain_graph=True)
  #optimize
  optimizer_fo.step()

我的 .loss() 函数直接返回各项之和。我考虑过进行第二次前向传递并独立地向后调用每个损失项，但这会非常昂贵。

我想计算网络中两个张量之间的梯度。输入X张量（批大小xm）通过一组卷积层发送，这些卷积层使我返回并输出Y张量（批大小xn）。

我正在创建一个新的损失，我想知道Y wrt X的梯度。在tensorflow中类似：

tf.gradients（ys = Y，xs = X）

不幸的是，我一直在使用torch.autograd.grad（）进行测试，但是我不知道该怎么做。我收到如下错误：“ RunTimeerror：grad只能为标量输出隐式创建”。

如果我想知道Y wrt X的梯度，torch.autograd.grad（）中的输入应该是什么？

我正在研究有关定义新的autograd函数的PyTorch教程。我要实现的autograd函数是一个包装器torch.nn.functional.max_pool1d。这是我到目前为止的内容：

import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.autograd as tag

class SquareAndMaxPool1d(tag.Function):

    @staticmethod
    def forward(ctx, input, kernel_size, stride=None, padding=0, dilation=1, \
                return_indices=False, ceil_mode=False):
        ctx.save_for_backward( input )

        inputC = input.clone() #copy input
        inputC *= inputC

        output = F.max_pool1d(inputC, kernel_size, stride=stride, \
                              padding=padding, dilation=dilation, \
                              return_indices=return_indices, \
                              ceil_mode=ceil_mode)

        return output

    @staticmethod
    def backward(ctx, grad_output):
        input, = ctx.saved_tensors
        grad_input = get_max_pool1d_grad_somehow(grad_output)
        return 2.0*input*grad_input

我的问题是：如何获得包装函数的梯度？我知道给出的示例很简单，但可能还有其他方法可以执行此操作，但是我想做的事情适合此框架，并且需要我实现一个autograd功能。

编辑：检查了此博客文章后，我决定尝试以下操作backward …