《深度学习入门》第5章实战：手写数字识别——误差反向传播

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

最近阅读了《深度学习入门——基于Python的理论与实现》这本书的第五章，这一章主要讲解的是误差反向传播法——一个相比于数值微分而言，能够高效计算权重参数的梯度的方法。

---

一、一点介绍

误差反向传播法，是用来计算神经网络的权重参数的梯度的。该方法旨在从后往前遍历一遍神经网络，从而能够计算出损失函数对网络中所有模型参数的梯度。

（一）计算图

书上用计算图来解释误差反向传播法。使用计算图的最大原因是，可以通过反向传播高效计算导数。比如说，下面的图片中就解释了“苹果价格的上涨会在多大程度上影响最终支付金额”这个问题，即求“支付金额关于苹果的价格的导数”这个问题。

那么为什么要通过反向传播计算导数呢？如果能计算出导数，就能知道神经网络权重参数的梯度，从而就能够根据梯度对参数进行更新，从而找到最优参数。

（二）反向传播

在简单介绍了计算图之后，作者还讲解了反向传播的方法，重点介绍了加法节点的反向传播、乘法节点的反向传播。

• 加法节点的反向传播
  加法节点的反向传播以z=x+y为例。该例旨在计算x的变化会在多大程度上影响z、y的变化会在多大程度上影响z，即z关于x的导数、z关于y的导数。
  
  
  

• 乘法节点的反向传播
  
  

（三）反向传播的代码表示

上面我们介绍了加法节点和乘法节点的反向传播方式，下面我们将以代码的形式来实现他们的反向传播。
下面，把要实现计算图的乘法节点称作“乘法层”，加法节点称作“加法层”。

• 乘法层的代码实现

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 # 根据（二）中所讲的，乘法节点的反向传播需要把x和y进行翻转
        dy = dout * self.x

        return dx, dy

• 加法层的代码实现

class AddLayer:
    def __init__(self):
        pass	# 加法层无需进行初始化，所以直接pass即可

    def forward(self, x, y):
        out = x + y

        return out

    def backward(self, dout):
        dx = dout * 1
        dy = dout * 1

        return dx, dy

看完概念后，结合代码再理解一次，突然有点悟了。书中还讲解了激活函数relu、sigmoid函数等的反向传播推导，在这里就不一一介绍了。

二、利用误差反向传播进行手写数字识别

在这个例子中，神经网络采用的是2层神经网络，该网络使用一个TwoLayerNet类来实现。TwoLayerNet类中的变量说明如下：

params：保存神经网络参数的字典型变量。params[‘W1’]是第1层的权重，params[‘b1’]是第1层的偏置，params[‘W2’]是第2层的权重，params[‘b2’]是第2层的偏置.

layers:保存神经网络的层的有序字典型变量，依次保存了Affine1层、ReLu1层、Affine2层。

lastLayer:神经网络的最后一层。本例中为SoftmaxWithLoss层。

下面说一下几个主要函数：
下面这个函数是TwoLayerNet类的初始化函数。从代码中可以看出，该神经网络采用的是2层神经网络。从前到后依次是Affine层、ReLu层、Affine层、SoftmaxWithLoss层。

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 gradient(self, x, t)主要用来计算权重参数的梯度。x是图像数据，t是图像的标签。self.loss(x, t)是正向传播的过程，用来计算预测的损失。然后就是backward反向传播的过程。在反向传播的过程中，使用layers.reverse()先把这些层的顺序都倒置，然后再逐层反向传播，最终得到dout，把更新后的参数值放到grad{}里面。

    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'] = self.layers['Affine1'].dW
        grads['b1'] = self.layers['Affine1'].db
        grads['W2'] = self.layers['Affine2'].dW
        grads['b2'] = self.layers['Affine2'].db

下面这个函数def predict(self, x)是用来进行预测的。神经网络的正向传播只需要按照添加元素的顺序调用各层的forward方法就可以完成处理。

def predict(self, x):
    for layer in self.layers.values():
        x = layer.forward(x)
    return x

下面我们来康一康“主函数”的逻辑。说明都写在注释里了。

	# 加载数据
	(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)

    # 超参数
    iters_num = 10000	# 随机抽数据，抽10000次
    train_size = x_train.shape[0]	# 训练集的大小
    batch_size = 100	# 随机抽数据，每次抽100个数据
    learning_rate = 0.1	# 学习率
    train_loss_list = []# 记录训练集的损失值
    train_acc_list = []	# 记录训练集的准确度
    test_acc_list = []	# 记录测试集的准确度

    # 平均每个epoch的重复次数
    iter_per_epoch = max(train_size / batch_size, 1)
    for i in range(iters_num):
        # 获取mini-batch
        batch_mask = np.random.choice(train_size, batch_size)
        x_batch = x_train[batch_mask]
        t_batch = t_train[batch_mask]

        # 计算梯度
        grad = network.gradient(x_batch, t_batch)
        # 更新参数
        for key in ('W1', 'b1', 'W2', 'b2'):
            network.params[key] -= learning_rate * grad[key]

        # 记录学习过程
        loss = network.loss(x_batch, t_batch)
        train_loss_list.append(loss)

        # 计算每个epoch的识别精度
        if i % iter_per_epoch == 0:
            train_acc = network.accuracy(x_train, t_train)
            test_acc = network.accuracy(x_test, t_test)
            train_acc_list.append(train_acc)
            test_acc_list.append(test_acc)

全部代码

PS:下述代码是我根据书上代码敲的，跑代码之前别忘了在官网上下载相应的包common和dataset，放到项目路径venv\Lib\site-packages中去。
官网链接：http://www.ituring.com.cn/book/1921
然后，先点击右侧的“随书下载”，再点击第二个“下载”即可。

放好了就像这样：

来看代码：

import sys, os

sys.path.append(os.pardir)
import numpy as np
import matplotlib.pyplot as plt
from common.functions import *
from common.gradient import numerical_gradient
from common.layers import *
from collections import OrderedDict
from dataset.mnist import load_mnist
from dataset.two_layer_net import TwoLayerNet


def cross_entropy_error(y, t):
    if y.ndim == 1:
        t = t.reshape(1, t.size)
        y = y.reshape(1, y.size)
        batch_size = y.shape[0]
        return -np.sum(t * np.log(y + 1e-7)) / batch_size


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 sigmoid(a):
        return 1 / (1 + np.exp(-a))

    def softmax(a):
        exp_a = np.exp(a)
        sum = np.sum(exp_a)
        y = exp_a / sum
        return y

    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

    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['W2'] = numerical_gradient(loss_W, self.params['W2'])
        grads['b1'] = numerical_gradient(loss_W, self.params['b1'])
        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'] = self.layers['Affine1'].dW
        grads['b1'] = self.layers['Affine1'].db
        grads['W2'] = self.layers['Affine2'].dW
        grads['b2'] = self.layers['Affine2'].db

        return grads

    (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)

    # 超参数
    iters_num = 10000
    train_size = x_train.shape[0]
    batch_size = 100
    learning_rate = 0.1
    train_loss_list = []
    train_acc_list = []
    test_acc_list = []

    # 平均每个epoch的重复次数
    iter_per_epoch = max(train_size / batch_size, 1)
    for i in range(iters_num):
        # 获取mini-batch
        batch_mask = np.random.choice(train_size, batch_size)
        x_batch = x_train[batch_mask]
        t_batch = t_train[batch_mask]

        # 计算梯度
        grad = network.gradient(x_batch, t_batch)
        # 更新参数
        for key in ('W1', 'b1', 'W2', 'b2'):
            network.params[key] -= learning_rate * grad[key]

        # 记录学习过程
        loss = network.loss(x_batch, t_batch)
        train_loss_list.append(loss)

        # 计算每个epoch的识别精度
        if i % iter_per_epoch == 0:
            train_acc = network.accuracy(x_train, t_train)
            test_acc = network.accuracy(x_test, t_test)
            train_acc_list.append(train_acc)
            test_acc_list.append(test_acc)

    # 导入数据
    m = list(np.arange(1, iters_num + 1))
    n = list(np.arange(1, len(train_acc_list) + 1))
    t = list(np.arange(1, len(test_acc_list) + 1))
    # 绘图命令
    print(train_loss_list)
    print(train_acc_list)
    print(test_acc_list)
    # 画第一个图
    plt.subplot(221)
    plt.title("Train Loss List")
    plt.plot(m, train_loss_list)
    # 画第二个图
    plt.subplot(222)
    plt.title("Train Acc List")
    plt.plot(n, train_acc_list)
    # 画第三个图
    plt.subplot(223)
    plt.title("Test Acc List")
    plt.plot(t, test_acc_list)
    # show出图形
    plt.show()

运行结果

不得不说误差反向传播的训练速度真的要比数值微分快好多呀！