深度学习入门（三）：误差反向传播法

最新推荐文章于 2022-12-01 11:23:13 发布

evil心安

最新推荐文章于 2022-12-01 11:23:13 发布

阅读量672

点赞数 1

分类专栏：深度学习文章标签：神经网络 python 深度学习

本文链接：https://blog.csdn.net/weixin_46013817/article/details/111463707

版权

深度学习专栏收录该内容

10 篇文章 2 订阅

订阅专栏

误差反向传播

误差反向传播法：一种能够高效计算权重参数的梯度的方法

计算图

局部计算

计算图的特征是可以通过传递“局部计算”获得最终结果。局部计算是指，无论全局发生了什么，都能只根据与自己相关的信息输出接下来的结果。计算图可以集中精力与局部计算，无论全局变量的计算多么复杂，各个步骤所要做的就是对象节点的局部计算。虽然局部计算非常简单，但是通过传递它的计算结果，可以获得全局的复杂计算的结果。
计算图将复杂的计算分解成简单的计算和流水线作业一样，将局部计算的结果传递给下一个节点。

为何用计算图解题

计算图的优点：

无论全局是多么复杂的计算，都可以通过局部计算使各个节点致力于简单的计算，从而简化问题。
利用计算图可以将中间的计算结果全部保存起来。
可以通过反向传播高效计算导数。

链式法则

传递局部导数的原理，是基于链式法则

计算图的反向传播

计算图的反向传播：沿着与正方向相反的方向，乘上局部导数
基于反向传播的导数的传递
反向传播的计算顺序是，将信息E乘以节点的局部导数（ $\frac{\partial x}{\partial y}$ ），然后将结果传递给下一个节点。这里所说的局部导数是指正向传播中y=f(x)的导数，也就是y关于x的导数（ $\frac{\partial x}{\partial y}$ ）。

什么是链式法则

链式法则的原理

如果某个函数有复合函数表示，则该复合函数的导数可以用构成复合函数的各个函数的导数的乘积表示

在这里插入图片描述
这就是链式法则的原理

加法节点的反向传播

加法的反向传播会将上游节点的值原封不动的输出到下游

乘法节点的反向传播

乘法的反向传播会将上游的值乘以正向传播时的输入信号的“翻转值”后传递给下游。

简单层的实现

乘法层的实现

层的实现中有两个共通的方法（接口）forward()和backward()。forward()对应正向传播，backward()对应反向传播。

class Mullayer:
    def __init__(self):
        self.x = None
        self.y = None

    def forward(self, x, y):
        self.x = x
        self.y = y
        out = x * y
        return out

    def backward(self, dout):
        dx = dout * self.y
        dy = dout * self.x

        return dx, dy

在这里插入图片描述
使用这个乘法层实现上图的前向传播

from layer_naive import *
apple = 100
apple_num = 2
tax = 1.1

# layer
mul_apple_layer = Mullayer()
mul_tax_layer = Mullayer()

# forward
apple_price = mul_apple_layer.forward(apple,apple_num)
price = mul_tax_layer.forward(apple_price, tax)

print(price) # 220

此外，关于各个变量的导数可由backward()求出

# backward
dprice = 1
dapple_price, dtax = mul_tax_layer.backward(dprice)
dapple, dapple_num = mul_apple_layer.backward(dapple_price)

print(dapple, dapple_num, dtax) # 2.2 110 200

加法层的实现

class AddLayer:
    def __init__(self):
        pass

    def forward(self, x, y):
        out = x + y
        return out
    
    def backward(self, dout):
        dx = dout * 1
        dy = dout * 1
        
        return dx, dy

在这里插入图片描述
用python实现上述代码

# coding: utf-8
from layer_naive import *

apple = 100
apple_num = 2
orange = 150
orange_num = 3
tax = 1.1

# layer
mul_apple_layer = MulLayer()
mul_orange_layer = MulLayer()
add_apple_orange_layer = AddLayer()
mul_tax_layer = MulLayer()

# forward
apple_price = mul_apple_layer.forward(apple, apple_num)  # (1)
orange_price = mul_orange_layer.forward(orange, orange_num)  # (2)
all_price = add_apple_orange_layer.forward(apple_price, orange_price)  # (3)
price = mul_tax_layer.forward(all_price, tax)  # (4)

# backward
dprice = 1
dall_price, dtax = mul_tax_layer.backward(dprice)  # (4)
dapple_price, dorange_price = add_apple_orange_layer.backward(dall_price)  # (3)
dorange, dorange_num = mul_orange_layer.backward(dorange_price)  # (2)
dapple, dapple_num = mul_apple_layer.backward(dapple_price)  # (1)

print("price:", int(price))
print("dApple:", dapple)
print("dApple_num:", int(dapple_num))
print("dOrange:", dorange)
print("dOrange_num:", int(dorange_num))
print("dTax:", dtax)

综上，计算图中层的实现非常简单，使用这些层可以进行复杂的导数计算。

激活函数层的实现

现在将计算图的思路应用到神经网络中。

ReLU层

$\begin{cases} 0, & \text {$x\leq0$} \\ x, & \text {$x>0$} \end{cases}$
可以求出y关于x的导数

$\frac{\partial x}{\partial y} = \begin{cases} 0, & \text {$x\leq0$} \\ 1, & \text {$x>0$} \end{cases}$
如果正向传播时的输入大于0，则反向传播会将上游的值原封不动地传给下游。如果正向传播时的x小于等于0，则反向传播中传给下游的信号将停在此处。
代码

class Relu:
    def __init__(self):
        self.mask  = None

    def forward(self, x):
        self.mask = (x <= 0)
        out = x.copy()
        out[self.mask] = 0

        return out

    def backward(self, dout):
        dout[self.mask] = 0
        dx = dout
        
        return dx

Relu类中有实例变量mask。这个变量mask是由True/False构成的Numpy数组，它会把正向传播时的输入x的元素中小于等于0的地方保存为True，其他地方(大于0的元素)保存为False。

Sigmoid层

$h(x)=\frac{1}{1+exp(-x)}$
在这里插入图片描述
对上述式子进一步化简可以得到
$\frac{\partial L}{\partial y}*y^{2}*exp(-x) = \frac{\partial L}{\partial y}*y*(1 - y)$

代码

class Sigmoid:
    def __init__(self):
        self.out = None
    
    def forward(self, x):
        out  = 1 / (1 + np.exp(-x))
        self.out = out
        
        return out
    
    def backward(self, dout):
        dx = dout * (1.0 - self.out) * self.out
        
        return dx

这个实现中，正向传播时将输出保存在了实例变量out中。然后，反向传播时，使用该变量out进行计算

Affine/Softmax层的实现

Affine层仿射层

神经网络中的一个全连接层。仿射（Affine）的意思是前面一层中的每一个神经元都连接到当前层中的每一个神经元。在许多方面，这是神经网络的「标准」层。仿射层通常被加在卷积神经网络或循环神经网络做出最终预测前的输出的顶层。仿射层的一般形式为 y = f(Wx + b)，其中 x 是层输入，w 是参数，b 是一个偏差矢量，f 是一个非线性激活函数。
在这里插入图片描述
批版本的Affine层

代码

class Affine:
    def __init__(self, W, b):
        self.W = W
        self.b = b

        self.x = None
        self.original_x_shape = None
        # 权重和偏置参数的导数
        self.dW = None
        self.db = None

    def forward(self, x):
        # 对应张量
        self.original_x_shape = x.shape
        x = x.reshape(x.shape[0], -1)
        self.x = x

        out = np.dot(self.x, self.W) + self.b

        return out

    def backward(self, dout):
        dx = np.dot(dout, self.W.T)
        self.dW = np.dot(self.x.T, dout)
        self.db = np.sum(dout, axis=0)

        dx = dx.reshape(*self.original_x_shape) # 还原输入数据的形状
        return dx

Softmax-with-Loss层(Softmax函数和交叉熵误差)

Softmax层的反向传播得到了 $y_1-t_1,y_2-t_2,y_3-t_3)$ 这样“漂亮”的结果。由于( $y_1,y_2,y_3$ )是Softmax层的输出，( $t_1,t_2,t_3$ )是监督数据，所以 $y_1-t_1,y_2-t_2,y_3-t_3)$ 是Softmax层和监督标签的差分。
使用交叉熵误差作为Softmax函数的损失函数后，反向传播得到( $y_1-t_1,y_2-t_2,y_3-t_3)$ 这样“漂亮”的结果。实际上，这样“漂亮”的结果并不是偶然的，而是为了得到这样的结果，特意设计了交叉熵误差函数。回归问题中输出层使用”恒等函数“，损失函数使用”平方和误差“，也是出于同样的理由。
代码

class SoftmaxWithLoss:
    def __init__(self):
        self.loss = None  # 损失
        self.y = None     # softmax的输出
        self.t = None     # 监督数据(one-hot vector)

    def forward(self, x, t):
        self.t = t
        self.y = softmax(x)
        self.loss = cross_entropy_error(self.y, self.t)

        return self.loss

    def backward(self, dout = 1):
        batch_size = self.t.shape[0]
        if self.t.size == self.y.size:
            dx = (self.y - self.t) / batch_size
        else:
            dx = self.y.copy()
            dx[np.arange(batch_size), self.t] -= 1
            dx = dx / batch_size
        
        return dx

误差反向传播法的实现

对应误差反向传播法的神经网络的实现

import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
from common.layers import *
from common.gradient import numerical_gradient
from collections import OrderedDict


class TwoLayerNet:

    def __init__(self, input_size, hidden_size, output_size, weight_init_std = 0.01):
        # 初始化权重
        self.params = {}
        self.params['W1'] = weight_init_std * np.random.randn(input_size, hidden_size)
        self.params['b1'] = np.zeros(hidden_size)
        self.params['W2'] = weight_init_std * np.random.randn(hidden_size, output_size) 
        self.params['b2'] = np.zeros(output_size)

        # 生成层
        self.layers = OrderedDict()
        self.layers['Affine1'] = Affine(self.params['W1'], self.params['b1'])
        self.layers['Relu1'] = Relu()
        self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2'])

        self.lastLayer = SoftmaxWithLoss()
        
    def predict(self, x):
        for layer in self.layers.values():
            x = layer.forward(x)
        
        return x
        
    # x:输入数据, t:监督数据
    def loss(self, x, t):
        y = self.predict(x)
        return self.lastLayer.forward(y, t)
    
    def accuracy(self, x, t):
        y = self.predict(x)
        y = np.argmax(y, axis=1)
        if t.ndim != 1 : t = np.argmax(t, axis=1)
        
        accuracy = np.sum(y == t) / float(x.shape[0])
        return accuracy
        
    # x:输入数据, t:监督数据
    def numerical_gradient(self, x, t):
        loss_W = lambda W: self.loss(x, t)
        
        grads = {}
        grads['W1'] = numerical_gradient(loss_W, self.params['W1'])
        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
        grads['W2'] = numerical_gradient(loss_W, self.params['W2'])
        grads['b2'] = numerical_gradient(loss_W, self.params['b2'])
        
        return grads
        
    def gradient(self, x, t):
        # forward
        self.loss(x, t)

        # backward
        dout = 1
        dout = self.lastLayer.backward(dout)  # 按照与储存相反的方向进行反向传播
        
        layers = list(self.layers.values())
        layers.reverse()
        for layer in layers:
            dout = layer.backward(dout)

        # 设定
        grads = {}
        grads['W1'], grads['b1'] = self.layers['Affine1'].dW, self.layers['Affine1'].db
        grads['W2'], grads['b2'] = self.layers['Affine2'].dW, self.layers['Affine2'].db

        return grads

在这部分代码中将神经网络的层保存为OrderedDict这一点很重要。OrderedDict是有序字典，”有序“是指它可以记住向字典里添加元素的顺序。

误差反向传播法的梯度确认

数值微分的计算很消耗时间，而且如果有误差反向传播法的实现就能节约时间。但我们可以使用数值微分来确认误差反向传播法的实现是否正确。确认数值微分求出的梯度结果和误差反向传播法求出的结果是否一致的操作称为梯度确认。

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
from cp3.mnist import load_mnist
from TwoLayerNet import TwoLayerNet

# 读入数据
(x_train, t_train), (x_test, t_test) = load_mnist(normalize=True, one_hot_label=True)

network = TwoLayerNet(input_size=784, hidden_size=50, output_size=10)

x_batch = x_train[:3]
t_batch = t_train[:3]

grad_numerical = network.numerical_gradient(x_batch, t_batch)
grad_backprop = network.gradient(x_batch, t_batch)

for key in grad_numerical.keys():
    diff = np.average( np.abs(grad_backprop[key] - grad_numerical[key]) )
    print(key + ":" + str(diff))
    /*
    W1:6.511090674698411e-08
b1:1.3829615426880573e-06
W2:4.940173597393681e-09
b2:1.3966675545401542e-07
    /*