22. 深度学习 - 自动求导

22. 深度学习 - 自动求导_第1张图片

Hi,你好。我是茶桁。

咱们接着上节课内容继续讲,我们上节课已经了解了拓朴排序的原理,并且简单的模拟实现了。我们这节课就来开始将其中的内容变成具体的计算过程。

linear, sigmoidloss这三个函数的值具体该如何计算呢?

我们现在似乎大脑已经有了一个起比较模糊的印象,可以通过它的输入来计算它的点。

让我们先把最初的父类Node改造一下:


class Node():
    def __init__(self, inputs=[], name=None):
        ...
        self.value = None
    
    ...

然后再复制出一个,和Placeholder一样,我们需要继承Node,并且改写这个方法自己独有的内容:

class Linear(Node):
    def __init__(self, x, k, b, name=None):
        Node.__init__(self, inputs=[x, k, b], name=name)

    def forward(self):
        x, k, b = self.inputs[0], self.inputs[1], self.inputs[2]
        self.value = k.value * x.value + b.value
        print('我是{}, 我没有人类爸爸,需要自己计算结果{}'.format(self.name, self.value))
    ...

我们新定义的这个类叫Linear, 它会接收x, k, b。它继承了Node。这个里面的forward该如何计算呢? 我们需要每一个节点都需要一个值,一个变量,因为我们初始化的时候接收的x,k,b都赋值到了inputs里,这里我们将其取出来就行了,然后就是线性方程的公式k*x+b,赋值到它自己的value上。

然后接着呢,就轮到Sigmoid了,一样的,我们定义一个子类来继承Node:

class Sigmoid(Node):
    def __init__(self, x, name=None):
        Node.__init__(self, inputs=[x], name=name)
        self.x = self.inputs[0]

    def _sigmoid(self, x):
        return 1/(1+np.exp(-x))

    def forward(self):
        self.value = self._sigmoid(self.x.value)
        print('我是{}, 我自己计算了结果{}'.format(self.name, self.value))
    ...

Sigmoid函数只接收一个参数,就是x,其公式为1/(1+e^{-x}),我们在这里定义一个新的方法来计算,然后在forward里把传入的x取出来,再将其送到这个方法里进行计算,最后将结果返回给它自己的value。

那下面自然是Loss函数了,方式也是一模一样:

class Loss(Node):
    def __init__(self, y, yhat, name=None):
        Node.__init__(self, inputs = [y, yhat], name=name)
        self.y = self.inputs[0]
        self.yhat = self.inputs[1]

    def forward(self):
        y_v = np.array(self.y.value)
        yhat_v = np.array(self.y_hat.value)
        self.value = np.mean((y.value - yhat.value) ** 2)
        print('我是{}, 我自己计算了结果{}'.format(self.name, self.value))

    ...

那我们这里定义成Loss其实并不确切,因为我们虽然喊它是损失函数,但是其实损失函数的种类也非常多。而这里,我们用的MSE。所以我们应该定义为MSE,不过为了避免歧义,这里还是沿用Loss好了。

定义完类之后,我们参数调用的类名也就需要改一下了:

...
node_linear = Linear(x=node_x, k=node_k, b=node_b, name='linear')
node_sigmoid = Sigmoid(x=node_linear, name='sigmoid')
node_loss = Loss(y=node_y, yhat=node_sigmoid, name='loss')

好,这个时候我们基本完成了,计算之前让我们先看一下sorted_node:

sorted_node

---
[Placeholder: y,
 Placeholder: k,
 Placeholder: x,
 Placeholder: b,
 Linear: Linear,
 Sigmoid: Sigmoid,
 MSE: Loss]

没有问题,我们现在可以模拟神经网络的计算过程了:

for node in sorted_nodes:
    node.forward()

---
我是x, 我已经被人类爸爸赋值为3
我是b, 我已经被人类爸爸赋值为0.3737660632429008
我是k, 我已经被人类爸爸赋值为0.35915077292816744
我是y, 我已经被人类爸爸赋值为0.6087876106387002
我是Linear, 我没有人类爸爸,需要自己计算结果1.4512183820274032
我是Sigmoid, 我没有人类爸爸,需要自己计算结果0.8101858733432837
我是Loss, 我没有人类爸爸,需要自己计算结果0.04056126022042443

咱们这个整个过程就像是数学老师推公式一样,因为这个比较复杂。你不了解这个过程就求解不出来。

这就是为什么我一直坚持要手写代码的原因。c+v大法确实好,但是肯定是学的不够深刻。表面的东西懂了,但是更具体的为什么不清楚。

我们可以看到,我们现在已经将Linear、Sigmoid和Loss都将值计算出来了。那我们现在已经实现了从x到loss的前向传播

现在我们有了loss,那就又要回到我们之前机器学习要做的事情了,就是将损失函数loss的值降低。

之前咱们讲过,要将loss的值减小,那我们就需要求它的偏导,我们前面课程的求导公式这个时候就需要拿过来了。

然后我们需要做的事情并不是完成求导就好了,而是要实现「链式求导」。

那从Loss开始反向传播的时候该做些什么?先让我们把“口号”喊出来:

class Node:
    def __init__(...):
        ...
    ...
    def backward(self):
        for n in self.inputs:
            print('获取∂{} / ∂{}'.format(self.name, n.name))

这样修改一下Node, 然后在其中假如一个反向传播的方法,将口号喊出来。

然后我们来看一下口号喊的如何,用[::-1]来实现反向获取:

for node in sorted_nodes[::-1]:
    node.backward()

---
获取∂Loss / ∂y
获取∂Loss / ∂Sigmoid
获取∂Sigmoid / ∂Linear
获取∂Linear / ∂x
获取∂Linear / ∂k
获取∂Linear / ∂b

这样看着似乎不是太直观,我们再将node的名称加上去来看就明白很多:

for node in sorted_nodes[::-1]:
    print(node.name)
    node.backward()
---
Loss
获取∂Loss / ∂y
获取∂Loss / ∂Sigmoid
Sigmoid
获取∂Sigmoid / ∂Linear
Linear
获取∂Linear / ∂x
获取∂Linear / ∂k
获取∂Linear / ∂b
...

最后的k, y, x, b我就用…代替了,主要是函数。

那我们就清楚的看到,Loss获取了两个偏导,然后传到了Sigmoid, Sigmoid获取到一个,再传到Linear,获取了三个。那现在其实我们只要把这些值能乘起来就可以了。我们要计算步骤都有了,只需要把它乘起来就行了。

我们先是需要一个变量,用于存储Loss对某个值的偏导

class Node:
    def __init__(...):
        ...
        self.gradients = dict()
    ...

然后我们倒着来看, 先来看Loss:

class Loss(Node):
    ...
    def backward(self):
        self.gradients[self.inputs[0]] = '∂{}/∂{}'.format(self.name, self.inputs[0].name)
        self.gradients[self.inputs[1]] = '∂{}/∂{}'.format(self.name, self.inputs[1].name)
        print('[0]: {}'.format(self.gradients[self.inputs[0]]))
        print('[1]: {}'.format(self.gradients[self.inputs[1]]))

眼尖的小伙伴应该看出来了,我现在依然还是现在里面进行「喊口号」的动作。主要是先来看一下过程。

刚才每个node都有一个gradients,它代表的是对某个节点的偏导。

现在这个节点self就是loss,然后我们self.inputs[0]就是y, self.inputs[1]就是yhat, 也就是node_sigmoid。那么我们现在这个self.gradients[self.inputs[n]]其实就分别是∂loss/∂y∂loss/∂yhat,我们把对的值分别赋值给它们。

然后我们再来看Sigmoid:

class Sigmoid(Node):
    ...

    def backward(self):
        self.gradients[self.inputs[0]] = '∂{}/∂{}'.format(self.name, self.inputs[0].name)
        print('[0]: {}'.format(self.gradients[self.inputs[0]]))

我们依次来看哈,这个时候的self就是Sigmoid了,这个时候的sigmoid.inputs[0]应该是Linear对吧,然后我们整个self.gradients[self.inputs[0]]自然就应该是∂sigmoid/∂linear

我们继续,这个时候self.outputs[0]就是loss, loss.gradients[self]那自然就应该是输出过来的∂loss/∂sigmoid,然后呢,我们需要将这两个部分乘起来:

def backward(self):
    self.gradients[self.inputs[0]] = '*'.join([self.outputs[0].gradients[self], '∂{}/∂{}'.format(self.name, self.inputs[0].name)])
    print('[0]: {}'.format(self.gradients[self.inputs[0]]))

接着,我们就需要来看看Linear了:

def backward(self):
    self.gradients[self.inputs[0]] = '*'.join([self.outputs[0].gradients[self], '∂{}/∂{}'.format(self.name, self.inputs[0].name)])
    self.gradients[self.inputs[1]] = '*'.join([self.outputs[0].gradients[self], '∂{}/∂{}'.format(self.name, self.inputs[1].name)])
    self.gradients[self.inputs[2]] = '*'.join([self.outputs[0].gradients[self], '∂{}/∂{}'.format(self.name, self.inputs[2].name)])
    print('[0]: {}'.format(self.gradients[self.inputs[0]]))
    print('[1]: {}'.format(self.gradients[self.inputs[1]]))
    print('[2]: {}'.format(self.gradients[self.inputs[2]]))

和上面的分析一样,我们先来看三个inputs[n]的部分,self在这里是linear了,这里的self.inputs[n]分别应该是x, k, b对吧,那么它们就应该分别是linear.gradients[x], linear.gradients[k]linear.gradients[b], 也就是∂linear/∂x,∂linear/∂k, ∂linear/∂b

那反过来,outputs就应该反向来找,那么self.outputs[0]这会儿就应该是sigmoid。sigmoid.gradients[self]就是前一个输出过来的∂loss/∂sigmoid * ∂sigmoid/∂linear, 那后面以此的[1]和[2]我们也就应该明白了。

然后后面分别是∂linear/∂x,∂linear/∂k, ∂linear/∂b。一样,我们将它们用乘号连接起来。

公式就应该是:

∂ l o s s ∂ s i g m o i d ⋅ ∂ s i g m o i d ∂ l i n e a r ⋅ ∂ l i n e a r ∂ x ∂ l o s s ∂ s i g m o i d ⋅ ∂ s i g m o i d ∂ l i n e a r ⋅ ∂ l i n e a r ∂ k ∂ l o s s ∂ s i g m o i d ⋅ ∂ s i g m o i d ∂ l i n e a r ⋅ ∂ l i n e a r ∂ b \begin{align*} \frac{\partial loss}{\partial sigmoid} \cdot \frac{\partial sigmoid}{\partial linear} \cdot \frac{\partial linear}{\partial x} \\ \frac{\partial loss}{\partial sigmoid} \cdot \frac{\partial sigmoid}{\partial linear} \cdot \frac{\partial linear}{\partial k} \\ \frac{\partial loss}{\partial sigmoid} \cdot \frac{\partial sigmoid}{\partial linear} \cdot \frac{\partial linear}{\partial b} \\ \end{align*} sigmoidlosslinearsigmoidxlinearsigmoidlosslinearsigmoidklinearsigmoidlosslinearsigmoidblinear

那同理,我们还需要写一下Placeholder

def Placeholder(Node):
    ...
    def backward(self):
        print('我获取了我自己的gradients: {}'.format(self.outputs[0].gradients[self]))
    ...

好,我们来看下我们模拟的情况如何,看看它们是否都如期喊口号了, 结合我们之前的前向传播的结果,我们一起来看:

for node in sorted_nodes:
    node.forward()
    
for node in sorted_nodes[::-1]:
    print('\n{}'.format(node.name))
    node.backward()

---
Loss
[0]: ∂Loss/∂y
[1]: ∂Loss/∂Sigmoid

Sigmoid
[0]: ∂Loss/∂Sigmoid*∂Sigmoid/∂Linear

Linear
[0]: ∂Loss/∂Sigmoid*∂Sigmoid/∂Linear*∂Linear/∂x
[1]: ∂Loss/∂Sigmoid*∂Sigmoid/∂Linear*∂Linear/∂k
[2]: ∂Loss/∂Sigmoid*∂Sigmoid/∂Linear*∂Linear/∂b

k
我获取了我自己的gradients: ∂Loss/∂Sigmoid*∂Sigmoid/∂Linear*∂Linear/∂k

b
我获取了我自己的gradients: ∂Loss/∂Sigmoid*∂Sigmoid/∂Linear*∂Linear/∂b

x
我获取了我自己的gradients: ∂Loss/∂Sigmoid*∂Sigmoid/∂Linear*∂Linear/∂x

y
我获取了我自己的gradients: ∂Loss/∂y

好,观察下来没问题,那我们现在还剩下最后一步。就是将这些口号替换成真正的计算的值, 其实很简单,就是将我们之前学习过并写过的函数替换进去就可以了:

class Linear(Node):
    ...
    def backward(self):
        x, k, b = self.inputs[0], self.inputs[1], self.inputs[2]
        self.gradients[self.inputs[0]] = self.outputs[0].gradients[self] * k.value
        self.gradients[self.inputs[1]] = self.outputs[0].gradients[self] * x.value
        self.gradients[self.inputs[2]] = self.outputs[0].gradients[self] * 1
        ...

class Sigmoid(Node):
    ...
    def backward(self):
        self.value = self._sigmoid(self.x.value)
        self.gradients[self.inputs[0]] = self.outputs[0].gradients[self] * self.value * (1 - self.value)
        ...

class Loss(Node):
    ...
    def backward(self):
        y_v = self.y.value
        yhat_v = self.y_hat.value
        self.gradients[self.inputs[0]] = 2*np.mean(y_v - yhat_v)
        self.gradients[self.inputs[1]] = -2*np.mean(y_v - yhat_v)

那我们来看下真正计算的结果是怎样的:

for node in sorted_nodes[::-1]:
    print('\n{}'.format(node.name))
    node.backward()

---
Loss
∂Loss/∂y: -0.402796525409167
∂Loss/∂Sigmoid: 0.402796525409167

Sigmoid
∂Sigmoid/∂Linear: 0.06194395247945269

Linear
∂Linear/∂x: 0.02224721841122111
∂Linear/∂k: 0.18583185743835806
∂Linear/∂b: 0.06194395247945269

y
gradients: -0.402796525409167

k
gradients: 0.18583185743835806

b
gradients: 0.06194395247945269

x
gradients: 0.02224721841122111

好,到这里,我们就实现了前向传播和反向传播,让程序自动计算出了它们的偏导值。

不过我们整个动作还没有结束,就是我们需要将loss降低到最小才可以。

那我们下节课,就来完成这一步。

你可能感兴趣的:(茶桁的AI秘籍,-,核心基础,机器学习,神经网络,深度学习,人工智能)