矩阵计算(导数)

阅读目录

• 1 标量的导数
• 2 亚导数
• 矩阵求导
  • 向量化的优点
  • 标量函数和向量函数
  • 矩阵求导
  • 求导方法
  • 常见矩阵求导公式的推导
  • 两种布局
• 梯度
• pytorch 自动求导
  • 向量的链式法则
  • 自动求导
  • 计算图
  • 自动求导的两种模式
  • 自动求导的实现

 

回到顶部

1 标量的导数

回到顶部

2 亚导数

比如说$y=|x|$这个函数在x=0的时候时不可导的。当x>0，其到导数为1，x<0，其导数为-1，所以在x=0的这个地方的亚导数就是可以是[-1,1]中的一个数

回到顶部

矩阵求导

向量化的优点

1.简洁
比如说：
$\begin{split}\begin{cases} y_1=W_1*X_{11}+W_2*X_{12}+...+W_n*X{1n}\\ y_2=W_1*X_{21}+W_2*X_{22}+...+W_n*X{1n}\\ .....\\ y_n=W_1*X_{n1}+W_2*X_{n2}+...+W_n*X{nn}\\ \end{cases}\end{split}$
这个函数可以简化成

$$Y=X*W$$

$$\begin{bmatrix} y_1\\ y_2\\ ...\\ y_n\\ \end{bmatrix} =\begin{bmatrix} X_{11},X_{12}...,X_{1n}\\ X_{21},X_{22}...,X_{2n}\\ ...\\ X_{n1},X_{n2}...,X_{nn}\\ \end{bmatrix} *\begin{bmatrix} W_1\\ W_2\\ ...\\ W_n\\ \end{bmatrix}$$

2.加速计算机的计算

对于同样一个矩阵相乘的操作，我们可以我们可以看出用矩阵的话是1.5ms，但是如果用for循环的话是474ms。

标量函数和向量函数

标量函数

其实标量函数就是最后运算之后输出为标量的函数，例如：

• $f(x)=x^2,其中x->x^2$
• $f(x)=x_1^2+x_2^2$,其中$\begin{bmatrix} X_1\\ X_2\\ \end{bmatrix}=>X_1^2+X_2^2$

这两个最终的运算结果都是一个标量。

向量函数

就是最后运算结果为一个向量，例如：
① $f(x)=\begin{bmatrix} f_1(x)=X\\ f_2(x)=X^2\\ \end{bmatrix}, x->\begin{bmatrix} X\\ X^2\\ \end{bmatrix}$

② $f(x)=\begin{bmatrix} f_1(x)=X,f_2(x)=X^2\\ f_3(x)=X^3,f_4(x)=X^4\\ \end{bmatrix}, 其中：x->\begin{bmatrix} X,X^2\\ X^3,X^4\\ \end{bmatrix}$

③ $f(x)=\begin{bmatrix} f_1(x)=X_1+X_2,f_2(x)=X_1^2+X_2^2\\ f_3(x)=X_1^3+X_2^3,f_4(x)=X_1^4+X_2^4\\ \end{bmatrix} , \begin{bmatrix} X_1\\ X_2\\ \end{bmatrix} ->\begin{bmatrix} X_1+X_2,X_1^2+X_2^2\\ X_1^3+X_2^3,X_1^4+X_2^4\\ \end{bmatrix}$

矩阵求导

$\frac{dA}{dB}$:矩阵求导的本质就是矩阵A中的每一个元素对矩阵B中的每个元素求导。
然后从求导后的元素个数角度：
因为他是矩阵A中的每个元素对矩阵B中的每个元素，所以是这样的形状。

A	B	$\frac{dA}{dB}$
$$1\times1$$	$$1\times 1$$	$$1\times 1$$
$$1\times p$$	$$1\times n$$	$$p\times n$$
$$q\times p$$	$$m\times n$$	$$p\times q\times m\times n$$

求导方法

$YX$拉伸，其中$Y$横向拉伸，$X$纵向拉伸。

$$\begin{split} \begin{cases}标量不变,向量拉伸\\ 前面横向拉伸，后面纵向拉伸\end{cases}\end{split}$$

这里的前面，后面指的是$YX$或者是$XY$，这里本文用的是$YX$。

例一：f(x)标量，x向量

$\frac{df(x)}{dx}$,其中f(x)就是Y,f(x)为标量函数，x为向量。也就是$f(x)=f(x_1,x_2,x_3...x_n),x=[x_1,x_2,x_2...n]^T$
我们按照上面的规则，f(x)是标量不变，拉伸，X纵向拉伸。

$$\frac{df(x)}{dx}=\begin{bmatrix} \frac{\partial f(x)}{\partial x_1}\\ \frac{\partial f(x)}{\partial x_2}\\ \frac{\partial f(x)}{\partial x_3}\\ ....\\ \frac{\partial f(x)}{\partial x_n}\\ \end{bmatrix}$$

这个实际上就是将多元函数的偏导写在一个列向量中。

例二：f(x)向量，x标量

$\frac{df(x)}{dx}$,f(x)为向量函数，x为向量。也就是$f(x)=\begin{bmatrix} f_1(x)\\ f_2(x)\\ ...\\ f_n(x)\\ \end{bmatrix}$,然后这个f(x)横向拉伸,x不变。
最终结果就是:
$\frac{df(x)}{dx}=\begin{bmatrix} \frac{\partial f_1(x)}{\partial x},\frac{\partial f_2(x)}{\partial x}...\frac{\partial f_n(x)}{\partial x}\\ \end{bmatrix}$

例三：f(x)为向量函数,x为向量函数

$f(x)=\begin{bmatrix} f_1(x)\\ f_2(x)\\ ...\\ f_n(x)\\ \end{bmatrix}，x=\begin{bmatrix} x_1\\ x_2\\ ...\\ x_n\\ \end{bmatrix}$
然后我们按照我们的规则，前面的横向拉伸，后面的纵向拉伸，然后本质就是A中的每个元素对矩阵B中的每一个求导。

$$\frac{df(x)}{dx}=\begin{bmatrix} \frac{\partial f_1(x)}{\partial x_1},\frac{\partial f_2(x)}{\partial x_1}....\frac{\partial f_n(x)}{\partial x_1}\\ \frac{\partial f_1(x)}{\partial x_2},\frac{\partial f_2(x)}{\partial x_2}....\frac{\partial f_n(x)}{\partial x_2}\\ \frac{\partial f_1(x)}{\partial x_3},\frac{\partial f_2(x)}{\partial x_3}....\frac{\partial f_n(x)}{\partial x_3}\\ ....\\ \frac{\partial f_1(x)}{\partial x_n},\frac{\partial f_2(x)}{\partial x_n}....\frac{\partial f_n(x)}{\partial x_n}\\ \end{bmatrix}$$

我们看完上面这个对矩阵求导后的形状应该就了解了，上面的图也应该就知道了。

常见矩阵求导公式的推导

例一：$f(x)=A^T*X$,求$\frac{df(x)}{dx}$
其中:
$A=\begin{bmatrix} a_1\\ a_2\\ ...\\ a_n\\ \end{bmatrix}，x=\begin{bmatrix} x_1\\ x_2\\ ...\\ x_n\\ \end{bmatrix}$
我们可以看出f(x)是标量，x是向量。
解：$f(x)=A^T*X=\sum^n_1{a_i*x_i}$
所以要把x纵向展开
$\frac{df(x)}{dx}=\begin{bmatrix} \frac{\partial f(x)}{\partial x_1}\\ \frac{\partial f(x)}{\partial x_2}\\ \frac{\partial f(x)}{\partial x_3}\\ ...\\ \frac{\partial f(x)}{\partial x_n}\\ \end{bmatrix}=\begin{bmatrix} a_1\\ a_2\\ a_3\\ ...\\ a_n\\ \end{bmatrix}=A$
ps：这里$\frac{\partial f(x)}{\partial x_1}=a_1$是因为$f(x)=\sum^n_1{a_i*x_i}$,对于除了$a_1*x_1$在外的其他项，对$x_1$求偏导都是0。
也可以这样看，$\frac{d(A^T*X)}{dx}=\frac{d(X^T*A)}{dx}=A$

例二：$f(x)=X^T*A*X$
这个可以自己证明一下，最终结果为$（A+A^T）X$.

两种布局

• 两种布局:

$$\begin{split} \begin{cases}分母布局-->YX拉伸术\\ 分子布局-->XY拉伸术\\ \end{cases}\end{split}$$

• 向量求导时的拉伸方向:

都是前面的横向拉伸，后面的纵向拉伸

• YX拉伸术-->分母布局
  Y横向拉伸(f(x)横向拉伸)
  X纵向拉伸

• XY拉伸术-->分子布局
  X横向拉伸
  Y纵向拉伸(f(x)横向拉伸)

回到顶部

梯度

这里主要搞得清楚他的形状

下面我们都使用的是分子布局（XY拉伸术），也就是X横向拉伸，Y纵向拉伸

• ∂y/∂x
  当y是标量，x是向量的时候：
  
  这里注意一点，你的梯度指向的是你的值变大的方向。
  我们将X横向拉伸

• ∂y/∂x
  当y是向量，x是标量的时候：
  

• ∂y/∂x
  我们可以发现$（分子布局）^T=（分母布局）$
  
  然后我们拓展的矩阵：
  

回到顶部

pytorch 自动求导

向量的链式法则

• 标量的链式法则

$y=f(x),u=g(x),\frac{\partial y}{\partial x}=\frac{\partial y}{\partial u}*\frac{\partial u}{\partial x}$

• 拓展到向量
  

例一：

例二：

自动求导

自动求导计算一个函数在指定值上的导数
它有别于

• 符号求导（显式求导）
  
• 数值求导（隐式求导）
  

计算图

·将代码分解成操作子
·将计算表示成一个无环图

·将代码分解成操作子
·将计算表示成一个无环图
·显示构造

·将代码分解成操作子
·将计算表示成一个无环图
·显式构造
     .Tensorflow/Theano/MXNet
·隐式构造
     .PyTorch/MXNet

自动求导的两种模式

正向积累和反向传播（反向积累）

对于反向积累

他需要读取之前的结果

自动求导的实现

假设我们想对函数$y=2x^⊤x$关于列向量x求导，最终计算的结果是个标量

import torch

x = torch.arange(4.0)
x

# tensor([0., 1., 2., 3.])

在我们计算y关于x的梯度之前，我们需要一个地方来存储梯度

x.requires_grad_(True)
x.grad

requires_grad: 如果需要为张量计算梯度，则为True，否则为False。我们使用pytorch创建tensor时，可以指定requires_grad为True（默认为False)，创建一个Tensor并设置requires_grad=True，requires_grad=True说明该变量需要计算梯度。

grad：当执行完了backward()之后，通过x.grad查看x的梯度值。

在这里我们可以在创建完x之后再x.requires_grad_(True)，或者我们创建的时候就
`x = torch.arange(4.0,requires_grad=True)``

现在让我们计算y

y = 2 * torch.dot(x, x)
y


# tensor(28., grad_fn=<MulBackward0>)

通过调用反向传播函数来自动计算y关于x每个分量的梯度

y.backward()
x.grad

# tensor([ 0.,  4.,  8., 12.])

x.grad == 4 * x

# tensor([True, True, True, True])

$y=2x^⊤x$然后他的函数求导之后的值和4*x一样的。
现在让我们计算x的另一个函数
x.grad.zero_()是让他的梯度清空

x.grad.zero_()
y = x.sum()
y.backward()
x.grad

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

深度学习中 ，我们的目的不是计算微分矩阵，而是批量中每个样本单独计算的偏导数之和

x.grad.zero_()
y = x * x
y.sum().backward()
x.grad
# tensor([0., 2., 4., 6.])

将某些计算移动到记录的计算图之外

x.grad.zero_()
y = x * x
u = y.detach()
z = u * x

z.sum().backward()
x.grad == u

# tensor([True, True, True, True])

x.grad.zero_()
y.sum().backward()
x.grad == 2 * x
# tensor([True, True, True, True])

即使构建函数的计算图需要通过Python控制流（例如，条件、循环或任意函数调用），我们仍然可以计算得到的变量的梯度

def f(a):
    b = a * 2
    while b.norm() < 1000:
        b = b * 2
    if b.sum() > 0:
        c = b
    else:
        c = 100 * b
    return c

a = torch.randn(size=(), requires_grad=True)
d = f(a)
d.backward()

a.grad == d / a

# tensor(True)