PyTorch提供的autograd包能够根据输⼊和前向传播过程⾃动构建计算图，并执⾏反向传播。
Tensor
Tensor的几个重要属性或方法
- .requires_grad 设为true的话,tensor将开始追踪在其上的所有操作
- .backward()完成梯度计算
- .grad属性 计算的梯度累积到.grad属性
- .detach()解除对一个tensor上操作的追踪,或者用with torch.no_grad()将不想被追踪的操作代码块包裹起来.
- .grad_fn属性 该属性即创建Tensor的Function类的类型,即该Tensor是由什么运算得来的
几个例子具体地解释一下:
import torch
x = torch.ones(2, 2, requires_grad=True)
print(x)
print(x.grad_fn)
y = x+2
print(y)
print(y.grad_fn)
z = y*y*3
out=z.mean()
print(z,out)
输出
tensor([[1., 1.],
[1., 1.]], requires_grad=True)
None
tensor([[3., 3.],
[3., 3.]], grad_fn=<AddBackward>)
<AddBackward object at 0x0000018752434B70>
tensor([[27., 27.],
[27., 27.]], grad_fn=<MulBackward>) tensor(27., grad_fn=<MeanBackward1>)
y由加法得到,所以y.grad_fn=
print(x.is_leaf, y.is_leaf) # True False
可以用.requires_grad_()来用in-place的方式改变requires_grad属性.
a = torch.randn(2, 2) # 缺失情况下默认 requires_grad = False
a = ((a * 3) / (a - 1))
print(a.requires_grad) # False
a.requires_grad_(True)
print(a.requires_grad) # True
b = (a * a).sum()
print(b.grad_fn)
输出
False
True
<SumBackward0 object at 0x0000018752434D30>
梯度
所计算的梯度都是结果变量关于创建变量的梯度。
比如对:
x = torch.ones(2, 2, requires_grad=True)
print(x)
print(x.grad_fn)
y = x+2
print(y)
print(y.grad_fn)
z = y*3
z.backward(torch.ones_like(z))
print(y.grad) #None
print(x.grad)
输出
None
tensor([[3., 3.],
[3., 3.]])
上述代码相当于创建了一个动态图,其中x是我们创建的变量,y和z都是因为x的改变会改变的结果变量. 所以在这个动态图里能够求的梯度只有(frac{partial{z}}{partial{x}}),(frac{partial{y}}{partial{x}})
为什么l.backward(gradient)需要传入一个和l同样形状的gradient?
对于l.backward()而言,当l是标量时,可以不传参,相当于l.backward(torch.tensor(1.))
当l不是标量时,需要传入一个和l同shape的gradient。
假设 x 经过一番计算得到 y，那么 y.backward(w) 求的不是 y 对 x 的导数，而是 l = torch.sum(y*w) 对 x 的导数。w 可以视为 y 的各分量的权重，也可以视为遥远的损失函数 l 对 y 的偏导数（这正是函数说明文档的含义）。特别地，若 y 为标量，w 取默认值 1.0，才是按照我们通常理解的那样，求 y 对 x 的导数
简单地说就是,张量对张量没法求导,所以我们需要人为地定义一个w,把一个非标量的Tensor通过torch.sum(y*w)的形式转换成标量。我们自己定义的这个w的不同,当然最后得到的梯度就不同.通常定义为全1.也就是认为Tensor y中的每一个变量的重要性是等同的.
另一个角度的理解就是,y是一个tensor,是一个向量,有N个标量,这每一个标量都与x有关。对这N个标量我们需要赋以不同的权重,以显示y中每一个标量受到x影响的程度.
比如对
import torch
x = torch.ones(2, 2, requires_grad=True)
print(x)
print(x.grad_fn)
y = x+2
print(y)
print(y.grad_fn)
z = y*3
print(z.shape)
w1=torch.Tensor([[1,2],[1,2]])
z.backward([w1])
print(x.grad)
x.grad.data.zero_()
w2=torch.Tensor([[1,1],[1,1]])
z.backward([w2])
print(x.grad)
输出
tensor([[1., 1.],
[1., 1.]], requires_grad=True)
None
tensor([[3., 3.],
[3., 3.]], grad_fn=<AddBackward>)
<AddBackward object at 0x00000187524A6828>
torch.Size([2, 2])
tensor([[3., 6.],
[3., 6.]])
tensor([[3., 3.],
[3., 3.]])
对w1和w2而言,z.backward()以后x.grad是不同的。
注意:梯度是累加的,所以第二次计算之前我们做了清零的操作:x.grad.data.zero_()
可以参考:
https://zhuanlan.zhihu.com/p/29923090
https://www.cnblogs.com/zhouyang209117/p/11023160.html
再来看看中断梯度追踪的例子：
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) # True
print(y2, y2.requires_grad) # False
print(y3, y3.requires_grad) # True
输出：
True
tensor(1., grad_fn=<PowBackward0>) True
tensor(1.) False
tensor(2., grad_fn=<ThAddBackward>) True
反向传播,求梯度
y3.backward()
print(x.grad)
输出：
tensor(2.)
为什么是2呢？$ y_3 = y_1 + y_2 = x^2 + x^3$，当 (x=1) 时 (frac {dy_3} {dx}) 不应该是5吗？事实上，由于 (y_2) 的定义是被torch.no_grad():包裹的，所以与 (y_2) 有关的梯度是不会回传的，只有与 (y_1) 有关的梯度才会回传，即 (x^2) 对 (x) 的梯度。
上面提到，y2.requires_grad=False，所以不能调用 y2.backward()，会报错：
RuntimeError: element 0 of tensors does not require grad and does not have a grad_fn
此外，如果我们想要修改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.])