深度学习如何自动微分-51CTO.COM

在深度学习中，求导几乎是所有优化算法的关键步骤，但是对于单个值的求导比较简单，但是如果对于模型训练过程中每次都需要手动求导就很麻烦，因此深度学习框架都提供了自动导数（自动微分）。

1、PyTorch自动微分

对函数 y = 2X^X 求导（其中X为列向量，这里表示两段列向量做矩阵乘法），其中PyTorch自动微分的代码如下：

import torch
x = torch.arange(4.0)
print("x: ", x)
x.requires_grad_(True)  # 等价于x=torch.arange(4.0,requires_grad=True)
print("x.grad: ", x.grad)
y = 2 * torch.dot(x, x)
print("y: ", y)
y.backward()
print("x.grad: ", x.grad)1.
2.
3.
4.
5.
6.
7.
8.
9.

1、先给x赋值 tensor([0., 1., 2., 3.]) ；2、将x设置为自动微分；3、赋值y表达式，计算y的值，结果：tensor(28., grad_fn=<MulBackward0>)；4、y.backward() 调用反向传播函数来自动计算y关于x每个分量的梯度，并打印这些梯度；

输出结果：tensor([ 0., 4., 8., 12.]) 和 y = 4X 的导数是一样的。

2、如何自动微分

自动微分开源实现很多，其中类似 PyTorch 的 API 包括 karpathy 开源的 https://github.com/karpathy/micrograd 和 https://github.com/tinygrad/tinygrad，这里为了简单借鉴 micrograd，重写部分代码实现自动微分。

2.1 前向传播

微分需要支持多个基础运算，如+，-，*，/，power等，代码如下：

class Value:
    def __init__(self, data, _children=(), _op=''):
        self.data = data
        self.grad = 0
        self._prev = set(_children)
        self._op = _op

    def __add__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data + other.data, (self, other), '+')
        return out

    def __mul__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data * other.data, (self, other), '*')
        return out

    def __pow__(self, other):
        assert isinstance(other, (int, float)), "only supporting int/float powers for now"
        out = Value(self.data**other, (self,), f'**{other}')
        return out

    def relu(self):
        out = Value(0 if self.data < 0 else self.data, (self,), 'ReLU')
        return out

    def __neg__(self): # -self
        return self * -1

    def __radd__(self, other): # other + self
        return self + other

    def __sub__(self, other): # self - other
        return self + (-other)

    def __rsub__(self, other): # other - self
        return other + (-self)

    def __rmul__(self, other): # other * self
        return self * other

    def __truediv__(self, other): # self / other
        return self * other**-1

    def __rtruediv__(self, other): # other / self
        return other * self**-1

    def __repr__(self):
        return f"Value(data={self.data}, grad={self.grad})"1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.

那么表达式 a * b + c + d**2，按照赋值变量的运行：

a = Value(2.0)
b = Value(-3.0)
c = Value(10.0)
d = Value(2.0)
d = a * b + c
z = d + f**2
print("z: ", z)1.
2.
3.
4.
5.
6.
7.

结果：Value(data=8.0, grad=0)，同时按照前向传播路径画图如下：

前向传播

2.2 反向传播

在反向传播的过程，本质是求网络的每个参数关于最终损失函数的梯度，而该梯度可以成是回传的全局梯度和局部梯度之乘。
其中梯度代表了当前层参数的变化，对最终预测损失的影响（变化率），而该变化率实际取决于当前层参数对下一层输入的影响，以及下一层输入对最终预测损失的影响，两个变化一乘，就是当前层参数对最终预测损失的影响。

那么反向传播的代码实现就是要将每个变量与表达式的结果关联，根据微积分的链式法则（https://zh.wikipedia.org/wiki/%E9%93%BE%E5%BC%8F%E6%B3%95%E5%88%99），如果变量 z 依赖于变量 y，而变量 y 又依赖于变量 x（即 y 和 z 是因变量），那么 z 也通过中间变量 y 来依赖于 x，其中 c = 2 * a; d = c + b; 推倒如下：

c = 2 * a 
d = c + b

求导数 dd/da 可以根据微分传递性转换 dd/dc * dc/da
那么 dd/dc = 1（加法的导数是常数），dc/da = 2（乘法的导数对应是2），所以 dd/da = 21.
2.
3.
4.
5.

根据前向传播的代码添加反向传播：

class Value:
    def __init__(self, data, _children=(), _op=''):
        self.data = data
        self.grad = 0
        self._backward = lambda: None
        self._prev = set(_children)
        self._op = _op

    def __add__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data + other.data, (self, other), '+')

        def _backward():
            self.grad += out.grad
            other.grad += out.grad
        out._backward = _backward

        return out

    def __mul__(self, other):
        other = other if isinstance(other, Value) else Value(other)
        out = Value(self.data * other.data, (self, other), '*')

        def _backward():
            self.grad += other.data * out.grad
            other.grad += self.data * out.grad
        out._backward = _backward

        return out

    def __pow__(self, other):
        assert isinstance(other, (int, float)), "only supporting int/float powers for now"
        out = Value(self.data**other, (self,), f'**{other}')

        def _backward():
            self.grad += (other * self.data**(other-1)) * out.grad
        out._backward = _backward

        return out

    def relu(self):
        out = Value(0 if self.data < 0 else self.data, (self,), 'ReLU')

        def _backward():
            self.grad += (out.data > 0) * out.grad
        out._backward = _backward

        return out
    
    def backward(self):
        topo = []
        visited = set()
        
        def build_topo(v):
            if v not in visited:
                visited.add(v)
                for child in v._prev:
                    build_topo(child)
                topo.append(v)
        build_topo(self)

        self.grad = 1
        for v in reversed(topo):
            v._backward()1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.

其中 backward 遍历所有孩子节点，然后 reversed 计算每个_backward，那么表达式 a * b + c + d**2，按照赋值变量的运行：

a = Value(2.0)
b = Value(-3.0)
c = Value(10.0)
f = Value(2.0)
d = a * b + c
z = d + f**2
z.backward()
print("a: ", a.grad)1.
2.
3.
4.
5.
6.
7.
8.

结果：a:-3.0，同时按照反向传播路径画图如下：

反向传播

3、总结

以上就是构造自动微分的代码，功能比较简单，主要是理解梯度的计算方法，并计算各个计算变量在图节点上的关系。