Pytorch学习-自动求梯度

2.3 自动求梯度

对函数计算梯度（gradient），Pytoch提供的autograd包能够根据输入和前向传播过程自动构建计算图，并执行反向传播。

2.3.1 概念

Tensor是autograd包的核心类

如果将其属性.requires_grad设置为True，它将开始追踪在其上的所有操作（这样就可以利用链式法则进行梯度传播）。

完成计算后，可以调用.backward()来完成所有梯度计算。此Tensor的梯度将累积到.grad属性中。

注：在y.backward()时，如果y是标量，则不需要为backward()传入任何参数；否则，需要传入一个与y同形的Tensor。

如果不想继续追踪，调用.detach()将追踪记录分离出来（防止将来的计算被追踪，这样梯度就传不过去）。也可以使用with torch.no_grad()将不想被追踪的操作代码块包裹起来。（在评估模型时经常使用，因为在评估模型时，我们不需要计算可训练参数(requires_grad=True)的梯度）

Function是另外一个很重要的类。Tensor和Function互相结合可以构建一个记录有整个计算过程的有向无环图（DAG）。每个Tensor都有一个.grad_fn属性，该属性即创建该Tensor的Function。就是说该Tensor若是通过运算得到的，则grad_fn返回一个与这些运算相关的对象，否则是None。

2.3.2 Tensor

创建一个Tensor并设置requires_grad = True:

import torch

x = torch.ones(2,2,requires_grad = True)
print(x)
print(x.grad_fn)

tensor([[1., 1.],
        [1., 1.]], requires_grad=True)
None

y = x + 2
print(y)
print(y.grad_fn)

tensor([[3., 3.],
        [3., 3.]], grad_fn=<AddBackward0>)
<AddBackward0 object at 0x000002431FFFBAC0>

注意x是直接创建的，所以返回的是None，而y是x进行了加法操作创建的，所以它有一个为<AddBackward>的运算对象

像x这种直接创建的称为叶子节点，叶子节点对应的grad_fn是None

print(x.is_leaf,y.is_leaf)

True False

运算操作复杂化

z = y*y*3
out = z.mean()
print(z,out)

tensor([[27., 27.],
        [27., 27.]], grad_fn=<MulBackward0>) tensor(27., grad_fn=<MeanBackward0>)

通过.requires_grad_()来用in-place的方式改变requires_grad属性：

a = torch.randn(2,2) #缺失情况下默认 requires_grad = False
a = ((a*3)/(a-1))
print(a.requires_grad)
a.requires_grad_(True)
print(a.requires_grad)
b = (a*a).sum()
print(b.grad_fn)

False
True
<SumBackward0 object at 0x0000024325F150A0>

2.3.2 梯度

因为out是一个标量，所以调用backward()时不需要指定求导变量：

out.backward() #等价于 out.backward(torch.tensor(1.))

out关于x的梯度 $\frac{d(out)}{dx}$

print(x.grad)

tensor([[4.5000, 4.5000],
        [4.5000, 4.5000]])

#再来反向传播一次，注意grad是累加的
out2 = x.sum()
out2.backward()
print(x.grad)

out3 = x.sum()
x.grad.data.zero_()
out3.backward()
print(x.grad)

tensor([[5.5000, 5.5000],
        [5.5000, 5.5000]])
tensor([[1., 1.],
        [1., 1.]])

举例：

x = torch.tensor([1.0,2.0,3.0,4.0],requires_grad=True)
y = 2*x
z = y.view(2,2)
print(z)

tensor([[2., 4.],
        [6., 8.]], grad_fn=<ViewBackward>)

#现在 y 不是一个标量，所以在调用 backward 时需要传入一个和 y 同形的权重向量进行加权求和得到一个标量
v = torch.tensor([[1.0,0.1],[0.01,0.001]],dtype = torch.float)
z.backward(v)
print(x.grad)

tensor([2.0000, 0.2000, 0.0200, 0.0020])

注：x.grad是和x同形的张量

中断梯度追踪的例子：

x = torch.tensor(1.0,requires_grad = True)
y1 = x ** 2
with torch.no_grad():
    y2 = x ** 3
y3 = y1+y2

print(x.requires_grad)
print(y1,y1.requires_grad)
print(y2,y2.requires_grad)
print(y3,y3.requires_grad)

True
tensor(1., grad_fn=<PowBackward0>) True
tensor(1.) False
tensor(2., grad_fn=<AddBackward0>) True

y2是没有grad_fn而且y2.requires_grad = False,而y3有，接下来对y3求梯度

y3.backward()
print(x.grad)

tensor(2.)

想要修改tensor的数值又不希望被autograd记录（不影响反向传播），可以对tensor.data操作

x = torch.ones(1,requires_grad = True)
print(x.data) #还是一个tensor
print(x.data.requires_grad) #独立于计算图之外

y = 2*x
x.data *= 100 #只改变了值，不会记录在计算图，不影响梯度传播

y.backward()
print(x) #修改data会影响tensor值
print(x.grad)

tensor([1.])
False
tensor([100.], requires_grad=True)
tensor([2.])