动手学深度学习（Pytorch版）知识点笔记（2）

二、自动求梯度

• Tensor的属性.requires_grad 设置为 True ，它将开始追踪(track)在其上的所有操作（这样就可以利⽤链式法则进⾏梯度传播了）。完成计算后，可以调⽤ .
• backward() 来完成所有梯度计算。此 Tensor 的梯度将累积到 .grad 属性中。
• Tensor的属性.requires_grad 设置为 True 之后。每个 Tensor 都有⼀个 .grad_fn 属性，该属性即创建该 Tensor 的Function , 就是说该 Tensor 是不是通过某些运算得到的，若是，则 grad_fn 返回⼀个与这些运算相关的对象，否则是None。
  注意在 y.backward() 时，如果 y 是标量，则不需要为 backward() 传⼊任何参数；否则，需要传⼊⼀个与 y 同形的 Tensor 。

x = torch.ones(2, 2, requires_grad=True)
y=x+2
print(x)
print(x.grad_fn)
#输出结果为
tensor([[1., 1.],
 		[1., 1.]], requires_grad=True)
None

z = y * y * 3
out = z.mean()//求平均
print(z, out)
#结果如下：
tensor([[27., 27.],
 [27., 27.]], grad_fn=<MulBackward>) tensor(27., grad_fn=<MeanBackward1>)
#我们还可以通过.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

• 梯度
  因为 out 是⼀个标量，所以调⽤ backward() 时不需要指定求导变量：

out.backward() # 等价于 out.backward(torch.tensor(1.))
print(x.grad) #out对x求导
#输出结果为：
tensor([[4.5000, 4.5000],
		[4.5000, 4.5000]])

向量的函数 , 那么 关于 的梯度就是⼀个雅可⽐矩阵。如图所示：

⽽ torch.autograd 这个包就是⽤来计算⼀些雅克⽐矩阵的乘积的。

• 通过运行代码我们注意到：
  grad在反向传播过程中是累加的(accumulated)，这意味着每⼀次运⾏反向传播，梯度都会累加之前的梯度，所以⼀般在反向传播之前需把梯度清零。

# 再来反向传播⼀次，注意grad是累加的
out2 = x.sum()
out2.backward()
print(x.grad)
out3 = x.sum()
x.grad.data.zero_()
out3.backward()
print(x.grad)
#结果如下：5.5是因为之前的out对x的求导是4.5，而out2对x的求导是1.
tensor([[5.5000, 5.5000],
        [5.5000, 5.5000]])
tensor([[1., 1.],
        [1., 1.]])

可以通过x.grad.data.zero_()来把梯度清零

• 注意tensor.sum()求和含义
  
• 们不允许张量对张量求导，只允许标量对张量求导，求导结果是和⾃变量同形的张量。所以必要时我们要把张量通过将所有张量的元素加权求和的⽅式转换为标量，举个例⼦，假设 y 由 ⾃ 变 量 x 计 算 ⽽ 来 ，w 是 和 y 同 形 的 张 量 ，则 y.backward(w) 的含义是：先计算 l = torch.sum(y * w) ，则 l 是个标量，然后求 l 对⾃变量 x 的导数。
  w 可以视为 y 的各分量的权重，

x = torch.tensor([1.0, 2.0, 3.0, 4.0], requires_grad=True)
y = 2 * x
z = y.view(2, 2)
print(z)
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 同形的张量。
比如：y.backward(w) 的含义是：先计算 l = torch.sum(y * w)，然后求 l 对（能够影响到 y 的）所有变量 x 的导数。这里，y 和 w 是同型 Tensor。也就是说，可以理解成先按照 w 对 y 的各个分量加权，加权求和之后得到真正的 loss，再计算这个 loss 对于所有相关变量的导数。
假设 y 和 w 是同型 Tensor，那么 l = torch.sum(yw) 对 y 的导数 dl/dy 就是 w。所以把这里的 w 理解成 y 的各项的权重也好，或者理解成某个高高在上的虚拟 loss 对 y 的导数也好，其实是一样的。事实上，l = torch.sum(yw) 这个形式不正好是导数的定义么？数学分析一上来就学，微分是函数增量的线性主部，而在 l = torch.sum(y*w) 这个形式里，只有线性的项，因此 w 就是 dl/dy。