Pytorch学习记录-自动求导机制与张量操作规则

pytorch学习记录

一、自动求导机制

参考：Pytorch的自动求导机制与使用方法(一) – 知乎 (zhihu.com)

​ 自动求导机制是pytorch核心功能之一。

1.1 求导法则

​ 限制：pytorch中默认只能是标量对标量/向量/矩阵求导。

​ 即只能对$f(x)=z,f:R^n\to R$求导，其中$x$可以通过多次复合函数得到，对$f$求导利用链式法则：

$$\frac{\partial z}{\partial x}=\frac{\partial z}{\partial y}\frac{\partial y}{\partial x}$$

​ 其中$x$为叶节点，$z$为根节点，$y$是过程操作，并不会被收集，只是作一个传播作用。

​ pytorch中的求导法则，实则是反向传播。

1.2 Tensor张量操作规则

​ PyTorch中数据以张量(n维数组)的形式流动torch.Tensor可以用来创建张量。

​ 当Tensor的属性中requires_grad=True时，则系统就可以开始跟踪对此Tensor的所有操作。其中记录的每个操作求得的梯度不会保存，只有在最后的一个操作才会保存梯度。

​ 如上述的两次链式法则，只保存$\frac{\partial z}{\partial x}$，而$\frac{\partial z}{\partial y}$只是被当作中间值，不会保存。

​ 例：Tensor.backward()方法默认计算对计算图叶子节点的导数,中间过程的导数是不计算的

x = torch.tensor(3.0, requires_grad=True)
y = 2*x
z = y**2
f = z+2
f.backward()
print(x.grad)
print(y.grad)
print(z.grad)

​ 输出结果：

tensor(24.)
None
None

​ pytorch在求导时候会自动构建计算图。

​ 从上图可以看出，一个Tensor中：

• data中保存着所存有的数据
• grad中保存梯度
• requires_grad表示是否开始追踪所有的操作历史

​ 想要计算梯度的时候，需要调用Tensor.backward()。在调用backward()时，只有当requires_grad和is_leaf同时为真时，才会计算节点的梯度值。

​ 例：pytorch只能标量对其他进行求导。

input:
import torch
x = torch.ones(2,2,requires_grad=True)
y = x+2# y 为非标量
print(x.is_leaf, y.is_leaf)
print(y.requires_grad)
y.backward()
ouput:
<<<True False
<<<True
<<<RuntimeError: grad can be implicitly created only for scalar outputs
    
# y为非标量，所以不符合y.requires_grad=True，所以无法求导

z = y * y * 3
out = z.mean()
print(out)
print(out.requires_grad)
out.backward()
print(x.grad)

output:
<<<tensor(27., grad_fn=<MeanBackward0>)
<<<True
<<<tensor([[4.5000, 4.5000],
        [4.5000, 4.5000]])

​ 求导过程如下：

​ 令$out=o$，由于

$$o=\frac{1}{4}\sum z_i=\frac{1}{4}\sum 3(x_i)+2$$

​ 所以

$$\frac{\partial o}{\partial x_i}{|}_{x_i=1}=\frac{9}{2}=4.5$$

​ 例：对$y=x^3$，对$x=2$进行求导

import torch
import torch.autograd

x = torch.tensor([2,0],requires_grad=True)
print("x= ",x)
print("x.requires_grad= ", x.requires_grad)
y = x ** 3
print("y= ",y)
print("y.requires_grad = ", y.grad_fn)

y.backward() #反向传播,求解导数
print("x.grad = ", x.grad)

​ 输出结果为：

x =  tensor([2.], requires_grad=True)
x.requires_grad =  True
y =  tensor([8.], grad_fn=<PowBackward0>)
y.requires_grad =  <PowBackward0 object at 0x7f3a1dac6320>
x.grad =  tensor([12.])

1.3 autograd类原理

​ autograd类的原理其实是利用雅可比矩阵进行计算。

​ 设函数$f:R^n\to R^m$，其中$f=(f_1,f_2,\dots ,f_m)$，则雅克比矩阵为：

$$J=\left[\frac{\partial f}{\partial x_1}\cdots \frac{\partial f}{\partial x_n}\right]=\left[\begin{array}{ccc}\frac{\partial f_1}{\partial x_1}& \cdots & \frac{\partial f_1}{\partial x_n}\\ ⋮& \ddots & ⋮\\ \frac{\partial f_m}{\partial x_1}& \cdots & \frac{\partial f_m}{\partial x_n}\end{array}\right]$$

​ 上面矩阵是$f$关于$x=(x_1,\dots ,x_m)$求导。

​ 令$l$是一个标量函数，对$f$进行求导有：

$$v=[\frac{\partial l}{\partial f_1},\frac{\partial l}{\partial f_2},\cdots ,\frac{\partial l}{\partial f_m}]$$

​ 则$l$对$x$进行求导有：

$$\frac{dl}{dx}=J\ast v^T$$

​ 其中对$x_i$求偏导有：

$$\frac{\partial l}{\partial x_i}=v\ast J_i$$

​ 其中$J_i$表示$J$矩阵的第$i$列。

​ 可以看到，$l:R^m\to R$，从神经网络的例子来理解，$f$是隐藏层为$m$个神经元的个数，$l$为输出层。

​ 从损失函数理解：标量$l$类似于MSE函数将minibatch平均为一个平均loss上.

1.4 具体例子

标量对向量求导:

​ 令$x=[x_1,x_2,x_3{]}^T$，$w=[w_1,w_2,w_3{]}^T$，$y=w\ast x+b$

​ 则偏导数为：

$$\frac{\partial y}{\partial x}=[\frac{\partial y}{\partial x_1},\frac{\partial y}{\partial x_2},\frac{\partial y}{\partial x_3}]=[w_1,w_2,w_3]$$

x = torch.tensor([1.0,2.0,3.0], requires_grad=True)
w = torch.tensor([4.0,5.0,6.0], requires_grad=True)
b = 10
y = torch.dot(x,w)+b
y.backward()
print(x.grad)
print(w.grad)

output:
<<<tensor([4., 5., 6.])
<<<tensor([1., 2., 3.])

标量对矩阵求导:

​ 令$X=\left[\begin{array}{ccc}{x}_{11}& x_{12}& x_{13}\\ x_{21}& x_{22}& x_{23}\end{array}\right]$

​ 第一次操作：

$$Y=X+1=\left[\begin{array}{ccc}{x}_{11}+1& x_{12}+1& x_{13}+1\\ x_{21}+1& x_{22}+1& x_{23}+1\end{array}\right]$$

​ 第二次操作：

$$Z=\left[\begin{array}{ccc}{z}_{11}& z_{12}& z_{13}\\ z_{21}& z_{22}& z_{23}\end{array}\right]=\left[\begin{array}{ccc}{\left(y_{11}\right)}^2& {\left(y_{12}\right)}^2& {\left(y_{13}\right)}^2\\ {\left(y_{21}\right)}^2& {\left(y_{22}\right)}^2& {\left(y_{23}\right)}^2\end{array}\right]$$

​ 第三次操作：

$$f=\frac{1}{6}sum(Z)$$

​ 偏导数为：

$$\frac{\partial f}{\partial x_{ij}}=\frac{1}{6}\ast 2(\frac{\partial (x_{ij}+1{)}^2}{\partial x_{ij}})=\frac{1}{3}(x_{ij}+1)$$

import torch
import torch.autograd

x = torch.tensor([[1.0,2.0,3.0],[4.0,5.0,6.0]], requires_grad=True)
y = x+1
z = y**2
f = torch.mean(z)

f.backward()
print(x.grad)

ouput:
<<<tensor([[0.6667, 1.0000, 1.3333],
        [1.6667, 2.0000, 2.3333]])

向量/矩阵对向量/矩阵求导：

​ 在pytorch中一般标量对向量或矩阵用的比较多，因为深度学习中最后的loss是输出一个值为标量，因此向量对矩阵求导需要传入一个梯度，即传入一个$l$对$f$的求导得到的梯度。

​ 令$x=[x_1,x_2,x_3]$，$y=x\ast 2=[2\ast x_1,2\ast x_2,2\ast x_3]$，此时对应上面1.3节有，$y=(f_1,f_2,f_3)$，其中$f_i=2\ast x_i$，所以有：

$$\frac{dy}{dx}=\left[\begin{array}{ccc}\frac{\partial f_1}{\partial x_1}& \frac{\partial f_1}{\partial x_2}& \frac{\partial f_1}{\partial x_3}\\ \frac{\partial f_2}{\partial x_1}& \frac{\partial f_2}{\partial x_2}& \frac{\partial f_2}{\partial x_3}\\ \frac{\partial f_3}{\partial x_1}& \frac{\partial f_3}{\partial x_2}& \frac{\partial f_3}{\partial x_3}\end{array}\right]=\left[\begin{array}{ccc}2& 0& 0\\ 0& 2& 0\\ 0& 0& 2\end{array}\right]$$

​ 传入：$v$为$l$对$f$的梯度

$$v=[0.1,1.0,0.0001]$$

​ 例：

x = torch.randn(3, requires_grad=True)
y = x * 2
print(y)
v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float)
y.backward(v)
print(x.grad)

output:
<<<tensor([-0.1656,  1.2321, -3.1254], grad_fn=<MulBackward0>)
<<<tensor([2.0000e-01, 2.0000e+00, 2.0000e-04])

​ 注意此处获得的梯度是$l$对$x$的梯度，而$l$是没有显式的，因为只是传入了一个$l$对$f$的梯度。