专栏——深度学习入门笔记

推荐文章

• 深度学习入门笔记（一）：机器学习基础
• 深度学习入门笔记（二）：神经网络基础
• 深度学习入门笔记（三）：感知机
• 深度学习入门笔记（四）：神经网络
• 深度学习入门笔记（五）：神经网络的学习
• 深度学习入门笔记（六）：误差反向传播算法
• 未完待续。。。

——————————————————————————————————————————————————————

文章目录

• 专栏——深度学习入门笔记
• 推荐文章
• 1. 计算图
• 1.1 用计算图求解
• 1.2 局部计算
• 1.3 为何用计算图解题
• 2. 链式法则
• 2.1 计算图的反向传播
• 2.2 什么是链式法则
• 2.3 链式法则和计算图
• 3. 反向传播
• 3.1 加法节点反向传播
• 3.2 乘法节点的反向传播
• 4. 简单层的实现
• 4.1 乘法层的实现
• 4.2 加法层的实现
• 5. 激活函数层的实现
• 5.1 ReLu层
• 5.2 Sigmoid层
• 6. Affine/Softmax层的实现
• 6.1 Affine层
• 6.2 批版本的Affine层
• 6.3 Softmax-with-Loss层
• 7. 误差反向传播法的实现
• 7.1 神经网络学习的全貌图
• 7.2 对应误差反向传播法的神经网络的实现
• 7.3 误差反向传播法的梯度确认
• 7.4 使用误差反向传播法的学习
• 8. 小结

误差反向传播法——能够高效计算权重参数的梯度的方法。
要正确理解误差反向传播法，有两种方法: 一种是基于数学式；另一种是基于 计算图(computational graph)。前者是比较常见的方法，机器学习相关的图书中多数都是以数学式为中心展开论述的。因为这种方法严密且简洁，所以确实非常合理，但如果一上来就围绕数学式进行探讨，会忽略一些根本的东西，止步于式子的罗列。因此，本章希望大家通过计算图，直观地理解误差反向传播法。然后，再结合实际的代码加深理解，相信大家一定会有种“原来如此!”的感觉。

1. 计算图

计算图将计算过程用图形表示出来。这里说的图形是数据结构图，通过多个节点和边表示(连接节点的直线称为“边”)。为了让大家熟悉计算图，本节先用计算图解一些简单的问题。从这些简单的问题开始，逐步深人，最终抵达 误差反向传播法。

1.1 用计算图求解

问题1: 太郎在超市买了2个100日元一个的苹果，消费税是10%，请计算支付金额。

计算图通过节点和箭头表示计算过程。节点用O表示，O中是计算的内容。将计算的中间结果写在箭头的上方，表示各个节点的计算结果从左向右传递。用计算图解问题1，求解过程如图5-1所示。

如图5-1所示，开始时，苹果的100日元流到“X 2”节点，变成200日元，然后被传递给下一个节点。接着，这个200日元流向“X 1.1”节点，变成220日元。因此，从这个计算图的结果可知，答案为220日元。

虽然图5-1中把 “X 2” “X 1.1”等作为一个运算整体用O括起来了，不过只用 O 表示乘法运算 “x" 也是可行的。此时，如图5-2 所示，可以将 “2” 和 “1.1” 分别作为变量“苹果的个数”和“消费税”标在O外面。

问题2:太郎在超市买了2个苹果、3个橘子。其中，苹果每个100日元，橘子每个150日元。消费税是10%，请计算支付金额。同问题1，我们用计算图来解问题2，求解过程如图5-3所示。

这个问题中新增了加法节点“+”，用来合计苹果和橘子的金额。构建了计算图后，从左向右进行计算。就像电路中的电流流动一样，计算结果从左向右传递。到达最右边的计算结果后，计算过程就结束了。从图5-3中可知，问题2的答案为715日元。

综上，用计算图解题的情况下，需要按如下流程进行。

1. 构建计算图。
2. 在计算图上，从左向右进行计算。

1.2 局部计算

计算图的特征是可以通过传递 “局部计算” 获得最终结果。“局部”这个词的意思是“与自己相关的某个小范围”。局部计算是指,，论全局发生了什么，都能只根据与自己相关的信息输出接下来的结果。

我们用一个具体的例子来说明局部计算。比如，在超市买了2个苹果和其他很多东西。此时，可以画出如图5-4所示的计算图。

如图5-4所示，假设(经过复杂的计算)购买的其他很多东西总共花费4000日元。这里的重点是，各个节点处的计算都是局部计算。这意味着，例如苹果和其他很多东西的求和运算 (4000 + 200 → 4200) 并不关心 4000 这个数字是如何计算而来的，只要把两个数字相加就可以了。换言之，各个节点处只需进行与自己有关的计算(在这个例子中是对输入的两个数字进行加法运算)，不用考虑全局。

综上，计算图可以集中精力于局部计算。无论全局的计算有多么复杂，各个步骤所要做的就是对象节点的局部计算。虽然局部计算非常简单，但是通过传递它的计算结果，可以获得全局的复杂计算的结果。

1.3 为何用计算图解题

前面我们用计算图解答了两个问题，那么计算图到底有什么优点呢？一个优点就在于前面所说的 局部计算。无论全局是多么复杂的计算，都可以通过局部计算使各个节点致力于简单的计算，从而简化问题。另一个优点是，利用计算图可以 将中间的计算结果全部保存起来(比如，计算进行到2个苹果时的金额是200日元、加上消费税之前的金额650日元等)。但是只有这些理由可能还无法令人信服。实际上，使用计算图最大的原因是，可以通过反向传播高效计算导数。

2. 链式法则

前面介绍的计算图的正向传播将计算结果正向(从左到右)传递，其计算过程是我们日常接触的计算过程，所以感觉上可能比较自然。而反向传播将局部导数向正方向的反方向(从右到左)传递，一开始可能会让人感到困惑。传递这个局部导数的原理，是基于 **链式法则(chainrule)**的。本节将介绍链式法则，并阐明它是如何对应计算图上的反向传播的。

2.1 计算图的反向传播

话不多说，让我们先来看一个使用计算图的反向传播的例子。假设存在 y= f(x) 的计算，这个计算的反向传播如图5-6所示。

如图所示，反向传播的计算顺序是，将信号 E 乘以节点的局部导数 ( ∂ y ∂ x ) (\frac{∂y}{∂x}) (∂x∂y​)，然后将结果传递给下一个节点。这里所说的局部导数是指正向传播中 y = f(x) 的导数，也就是 y 关于 x 的导数 ( ∂ y ∂ x ) (\frac{∂y}{∂x}) (∂x∂y​)。比如，假设 y = f ( x ) = x 2 y= f(x)=x^2 y=f(x)=x2，则局部导数为 ( ∂ y ∂ x ) = 2 x (\frac{∂y}{∂x}) = 2x (∂x∂y​)=2x 。把这个局部导数乘以上游传过来的值(本例中为 E )，然后传递给前面的节点。

这就是反向传播的计算顺序。通过这样的计算，可以高效地求出导数的值，这是反向传播的要点。那么这是如何实现的呢?我们可以从链式法则的原理进行解释。下面我们就来介绍 链式法则。

2.2 什么是链式法则

介绍链式法则时，我们]需要先从复合函数说起。复合函数是由多个函数构成的函数。比如， z = ( x + y ) 2 z= (x + y)^2 z=(x+y)2 是由式(5.1)所示的两个式子构成的。

z = t 2 t = x + y (5.1) z = t^2\\t = x + y\tag{5.1} z=t2t=x+y(5.1)

链式法则是关于复合函数的导数的性质，定义如下。

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

这就是链式法则的原理，乍一看可能比较难理解，但实际上它是一个非常简单的性质。以式 (5.1) 为例， ∂ z ∂ x \frac{∂z}{∂x} ∂x∂z​ (z关于 x 的导数)可以用 ∂ z ∂ t \frac{∂z}{∂t} ∂t∂z​(z关于 t 的导数)和 ∂ t ∂ x \frac{∂t}{∂x} ∂x∂t​ (t关于 x 的导数)的乘积表示。用数学式表示的话，可以写成式(5.2)。

∂ z ∂ x = ∂ z ∂ t ∂ t ∂ x 5.2 ) (() \frac{∂z}{∂x} = \frac{∂z}{∂t}\frac{∂t}{∂x}\tag(5.2) ∂x∂z​=∂t∂z​∂x∂t​5.2)(()

式(5.2)中的 ∂ z ∂z ∂z 正好可以像下面这样“互相抵消”，所以记起来很简单。
                                                                                                

现在我们使用链式法则，试着求 式(5.2) 的导数 ∂ z ∂ x \frac{∂z}{∂x} ∂x∂z​。为此，我们要先求式(5.1)中的局部导数(偏导数)。

∂ z ∂ t = 2 t ∂ t ∂ x = 1 (5.3) \frac{∂z}{∂t} = 2t\\\frac{∂t}{∂x} = 1\tag{5.3} ∂t∂z​=2t∂x∂t​=1(5.3)

如式(5.3)所示， ∂ z ∂ t \frac{∂z}{∂t} ∂t∂z​ 等于 2t， ∂ t ∂ x \frac{∂t}{∂x} ∂x∂t​ 等于1。这是基于导数公式的解析解。然后，最后要计算的\frac{∂z}{∂x}可由式(5.3)求得的导 数的乘积计算出来。

∂ z ∂ x = ∂ z ∂ t ∂ t ∂ x = 2 t ∗ 1 = 2 ( x + y ) 5.4 ) (() \frac{∂z}{∂x} = \frac{∂z}{∂t}\frac{∂t}{∂x} = 2t * 1=2(x+y)\tag(5.4) ∂x∂z​=∂t∂z​∂x∂t​=2t∗1=2(x+y)5.4)(()

2.3 链式法则和计算图

现在我们尝试将式(5.4)的链式法则的计算用计算图表示出来。

如图所示，计算图的反向传播从右到左传播信号。反向传播的计算顺序是，先将节点的输入信号乘以节点的局部导数(偏导数),然后再传递给下一个节点。比如，反向传播时，“**2” 节点的输入是 ∂ z ∂ x \frac{∂z}{∂x} ∂x∂z​，将其乘以局部导数 ∂ z ∂ t \frac{∂z}{∂t} ∂t∂z​ (因为正向传播时输人是t、输出是 z，所以这个节点的局部导数是 ∂ z ∂ t \frac{∂z}{∂t} ∂t∂z​)，然后传递给下一个节点。另外，图5-7中反向传播最开始的信号 ∂ z ∂ z \frac{∂z}{∂z} ∂z∂z​ 在前面的数学式中没有出现，这是因为 ∂ z ∂ z \frac{∂z}{∂z} ∂z∂z​ = 1,所以在刚才的式子中被省略了。

图5-7中需要注意的是最左边的反向传播的结果。根据链式法则， ∂ z ∂ z ∂ z ∂ t ∂ t ∂ x = ∂ z ∂ t ∂ t ∂ x = ∂ z ∂ x \frac{∂z}{∂z}\frac{∂z}{∂t}\frac{∂t}{∂x}=\frac{∂z}{∂t}\frac{∂t}{∂x}=\frac{∂z}{∂x} ∂z∂z​∂t∂z​∂x∂t​=∂t∂z​∂x∂t​=∂x∂z​ 成立，对应“z关于x的导数”。也就是说，反向传播是基于链式法则的。

把式(5.3)的结果代人到图5-7中，结果如图5-8所示， ∂ z ∂ x \frac{∂z}{∂x} ∂x∂z​ 品的结果为2(x + y)。

3. 反向传播

上一节介绍了计算图的反向传播是基于链式法则成立的。本节将以“+”和“x”等运算为例，介绍反向传播的结构。

3.1 加法节点反向传播

设z = x + y，则该公式的计算图如下：

我们把从上游传过来的导数的值设为 ∂ L ∂ z \frac{∂L}{∂z} ∂z∂L​。这是因为，如图5-10所示，我们假定了一个最终输出值为L的大型计算图。z = x + y的计算位于这个大型计算图的某个地方，从上游会传来时的值，并向下游传递 ∂ L ∂ x \frac{∂L}{∂x} ∂x∂L​ 和 ∂ L ∂ y \frac{∂L}{∂y} ∂y∂L​。

3.2 乘法节点的反向传播

设 z = xy，则计算图如下：

乘法的反向传播会将上游的值乘以正向传播时的输人信号的 “翻转值" 后传递给下游。翻转值表示一种翻转关系，如图5-12所示，正向传播时信号是 x 的话，反向传播时则是 y；正向传播时信号是 y 的话，反向传播时则是 x。

4. 简单层的实现

本节将用Python实现前面的购买苹果的例子。这里，我们把要实现的计算图的乘法节点称为 “乘法层"(MulLayer),加法节点称为 “加法层"(Addlayer)。

4.1 乘法层的实现

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

现在来实现乘法层。乘法层作为MulLayer类,其实现过程如下所示(保存在layer_ naive.py文件中)。

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

init() 中会初始化实例变量 x 和 y ,它们用于保存正向传播时的输入值。forward()接收 x 和 y 两个参数,将它们相乘后输出。backward()将从 上游传来的导数(dout )乘以正向传播的翻转值，然后传给下游。

上面就是MulLayer的实现。现在我们使用MulLayer实现前面的购买苹果的例子(2个苹果和消费税)。上一 节中我们使用计算图的正向传播和反向传播，像图5-16这样进行了计算。

# coding: utf-8
from layer_naive import *


apple = 100
apple_num = 2
tax = 1.1

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)

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

print("price:", int(price))
print("dApple:", dapple)
print("dApple_num:", int(dapple_num))
print("dTax:", dtax)

这里，调用 backward() 的顺序与调用 forward() 的顺序相反。此外，要注意 backward() 的参数中需要输人“关于正向传播时的输出变量的导数”。比如，mul_apple_layer乘法层在正向传播时会输出apple_ price, 在反向传播时，则会将apple. price的导数dapple_ price设为参数。另外，这个程序的运行结果和图5-16是一致的。

4.2 加法层的实现

接下来，我们实现加法节点的加法层，如下所示。

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

加法层不需要特意进行初始化，所以__ init__ ()中什么 也不运行( pass语句表示“什么也不运行”)。加法层的forward()接收 x 和 y 两个参数，将它.们相加后输出。backward()将 上游传来的导数(dout)原封不动地传递给下游。

现在，我们使用加法层和来法层，实现图5-17所示的购买2个苹果和3个橘子的例子。

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

这个实现稍微有一-点长，但是每- - 条命令都很简单。首先，生成必要的层，以合适的顺序调用正向传播的forward()方法。然后，用与正向传播相反的顺序调用反向传播的backward()方法，就可以求出想要的导数。

综上，计算图中层的实现(这里是加法层和乘法层)非常简单，使用这些层可以进行复杂的导数计算。下面，我们来 实现神经网络中使用的层。

5. 激活函数层的实现

现在，我们将计算图的思路应用到神经网络中。这里，我们把构成神经网络的层实现为一个类。先来实现激活函数的ReLU层和Sigmoid层。

5.1 ReLu层

激活函数ReLU( Rectified Linear Unit)由下式(5.7)表示。

y = { x ( x > 0 ) 0 ( x ≤ 0 ) (5.7) y = \begin{cases}x&(x>0)\\0&(x≤0)\end{cases}\tag{5.7} y={x0​(x>0)(x≤0)​(5.7)

通过式(5.7)，可以求出 y 关于 x 的导数，如式(5.8)所示。

∂ y ∂ x = { 1 ( x > 0 ) 0 ( x ≤ 0 ) (5.8) \frac{∂y}{∂x} = \begin{cases}1&(x>0)\\0&(x≤0)\end{cases}\tag{5.8} ∂x∂y​={10​(x>0)(x≤0)​(5.8)

在式(5.8)中，如果正向传播时的输人 x 大于 0，则反向传播会将上游的值原封不动地传给下游。反过来，如果正向传播时的 x 小于等于0，则反向传播中传给下游的信号将停在此处。

现在我们来实现ReLU层。在神经网络的层的实现中，一般假定 forward() 和 backward() 的参数是NumPy数组。(保存在文件layers. py中)。

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。

5.2 Sigmoid层

接下来，我们来实现sigmoid函数。sigmoid 函数由式(5.9)表示。

y = 1 1 + e x p ( − x ) y = \frac{1}{1+exp(-x)} y=1+exp(−x)1​

用计算图表示式(5.9)的话，则如图5-19所示。

图5-19中，除了“x"和“+“节点外，还出现了新的 “exp” 和 “/" 节点。“exp"节点会进行y= exp(x)的计算，“/” 节点会进行 y = 1 x y = \frac{1}{x} y=x1​的计算。

如图5-19所示，式(5.9) 的计算由局部计算的传播构成。下面我们就来进行图5- 19的计算图的反向传播。这里，作为总结，我们来依次看一下反向传播的流程。

由此可知 sigmoid 层反向传播的最终结果为 ∂ L ∂ y y 2 e x p ( − x ) \frac{∂L}{∂y}y^2exp(-x) ∂y∂L​y2exp(−x)，对该式进一步整理得：

因此，图5-21所表示的Sigmoid层的反向传播，只根据 正向传播的输出 就能计算出来。

现在，我们用Python实现Sigmoid层。参考图5-22，可以像下面这样实现(代码保存在layers. py文件中)。

class Sigmoid:
    def __init__(self):
        self.out = None

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

    def backward(self, dout):
        dx = dout * (1.0 - self.out) * self.out

        return dx

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

6. Affine/Softmax层的实现

6.1 Affine层

神经网络的正向传播中，为了计算加权信号的总和，使用了矩阵的乘积运算(NumPy中是np.dot())。

现在将这里进行的求矩阵的乘积与偏置的和的运算用计算图表示出来。将乘积运算用 “dot” 节点表示的话，则 np.dot(X, W) + B 的运算可用图5-24 所示的计算图表示出来。另外，在各个变量的上方标记了它们的形状（比如，计算图上显示了 X 的形状为 (2,)， X * W的形状为 (3,) 等）。

图5-24 是比较简单的计算图，不过要注意X、W、B是矩阵(多维数组)。之前我们见到的计算图中各个节点间流动的是标量，而这个例子中各个节点间传播的是 矩阵。

现在我们来考虑图5-24 的计算图的反向传播。以 矩阵为对象的反向传播，按矩阵的各个元素进行计算时，步骤和以标量为对象的计算图相同。实际写一下的话，可以得到下式(这里省略了式(5.13)的推导过程)。:

∂ L ∂ X = ∂ L ∂ Y ∗ W t ∂ L ∂ W = X T ∗ ∂ L ∂ Y (5.13) \frac{∂L}{∂X} = \frac{∂L}{∂Y}*W^t\\\quad\\\frac{∂L}{∂W} = X^T*\frac{∂L}{∂Y}\tag{5.13} ∂X∂L​=∂Y∂L​∗Wt∂W∂L​=XT∗∂Y∂L​(5.13)

式(5.13)中 W T W^T WT 的 T 表示转置。转置操作会把 W 的元素(i, j)换成元素(j,i)。

现在，我们根据式(5.13),尝试写出计算图的反向传播，如图5-25所示。

6.2 批版本的Affine层

前面介绍的Afine层的输人 X 是以单个数据为对象的。现在我们考虑N个数据一起进行正向传播的情况，也就是批版本的Affine层。

先给出批版本的Affine层的计算图，如图5-27所示。

正向传播时，偏置会被加到每一个数据（第1个、 第2个、…）上。因此，反向传播时，各个数据的反向传播的值需要汇总为偏置的元素。用代码表示的话，如下所示。

>>> dY = np.array([[1， 2, 3,]，[4， 5, 6]])
>>> dY
array([[1, 2, 3],
[4，5, 6]])
>>>
>>> dB = np.sum(dY, axis=0)
>>> dB
array([5，7, 9])

这个例子中，假定数据有2个（N=2）。偏置的反向传播会对这 2 个数据的导数按元素进行求和。因此，这里使用了np.sum()对第0轴(以数据为单位的轴，axis=0) 方向上的元素进行求和。

综上所述，Affine 的实现如下所示。

class Affine:
    def __init__(self, W, b):
        self.W =W
        self.b = b
        
        self.x = None
        # 权重和偏置参数的导数
        self.dW = None
        self.db = None

    def forward(self, x):
        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)
        return dx

6.3 Softmax-with-Loss层

最后介绍一下输出层的softmax函数。前面我们提到过，softmax函数会将输入值正规化之后再输出。比如手写数字识别时，Softmax层的输出如图5-28所示。

在图5-28中，Softmax 层将输人值正规化(将输出值的和调整为1)之后再输出。另外，因为手写数字识别要进行10类分类，所以向Softmax层的输人也有10个。

下面来实现Softmax层。考虑到这里也包含作为损失函数的 交叉熵误差(cross entropy error)，所以称为 “Softmax- with-Loss层"。Softmax- with-Loss层(Softmax函数和交叉熵误差)的计算图如图5-29所示。

图5-29的计算图可以简化成图5-30。

图5-30中要注意的是反向传播的结果。Softmax层的反向传播得到了 (y1 - t1，y2 - t2，y3 - t3) 这样“漂亮”的结果。由于(y1, y2, y3)是Softmax层的输出，(t1，t2，t3)是监督数据，所以 (y1 - t1，y2 - t2，y3 - t3) 是Softmax层的输出和教师标签的差分。神经网络的反向传播会把这个差分表示的误差传递给前面的层，这是神经网络学习中的重要性质。

使用交叉熵误差作为softmax函数的损失函数后，反向传播得到 (y1 - t1，y2 - t2，y3 - t3) 这样“漂亮"的结果。实际上，这样漂亮’的结果并不是偶然的，而是为了得到这样的结果，特意设计了交叉熵误差函数。回归问题中输出层使用“恒等函数”，损失函数使用“平方和误差”，也是出于同样的理由。也就是说，使用“平方和误差"作为“恒等函数”的损失函数，反向传播才能得到 (y1 - t1，y2 - t2，y3 - t3) 这样“漂亮"的结果。

现在来进行Softmax-with-Loss层的实现，实现过程如下所示。

class SoftmaxWithLoss:
    def __init__(self):
        self.loss = None
        self.y = None # softmax的输出
        self.t = None # 监督数据

    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: # 监督数据是one-hot-vector的情况
            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

这个实现利用了之前实现的softmax()和cross_ entropy_error()函数。因此，这里的实现非常简单。请注意反向传播时，将要传播的值除以批的大小( batch_ size)后， 传递给前面的层的是单个数据的误差。

7. 误差反向传播法的实现

通过像组装乐高积木一样组装上一节中实现的层，可以 构建神经网络。本节我们将通过组装已经实现的层来构建神经网络。

7.1 神经网络学习的全貌图

在进行具体的实现之前，我们再来确认一下神经网络学习的全貌图。神经网络学习的步骤如下所示。

前提

• 神经网络中有合适的权重和偏置，调整权重和偏置以便拟合训练数据的过程称为学习。神经网络的学习分为下面4个步骤。

步骤1 ( mini-batch )

• 从训练数据中随机选择一部分数据。

步骤2(计算梯度)

• 计算损失函数关于各个权重参数的梯度。

步骤3(更新参数)

• 将权重参数沿梯度方向进行微小的更新。

步骤4(重复)

• 重复步骤1、步骤2、步骤3。

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

现在来进行神经网络的实现。这里我们要把 2 层神经网络实现为TwoLayerNet。首先，将这个类的实例变量和方法整理成表5-1和表5-2。

下面是TwoLayerNet的代码实现。

# coding: utf-8
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 是有序字典，“有序"是指它可以记住向字典里添加元素的顺序。因此，神经网络的正向传播只需按照添加元素的顺序调用各层的 forward() 方法就可以完成处理，而反向传播只需要按照相反的顺序调用各层即可。因为Affine层和ReLU层的内部会正确处理正向传播和反向传播，所以这里要做的事情仅仅是以正确的顺序连接各层，再按顺序(或者逆序)调用各层。

像这样通过将神经网络的组成元素以层的方式实现，可以轻松地构建神经网络。这个用层进行模块化的实现具有很大优点。因为想另外构建一个神经网络(比如5层、10层、20层…的大的神经网络)时，只需像组装乐高积木那样添加必要的层就可以了。之后，通过各个层内部实现的正向传播和反向传播，就可以正确计算进行识别处理或学习所需的梯度。

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

到目前为止，我们介绍了两种求梯度的方法。一种是 基于数值微分的方法，另一种是 解析性地求解数学式的方法。后一种方法通过使用 误差反向传播法，即使存在大量的参数，也可以高效地计算梯度。因此，后文将不再使用耗费时间的数值微分，而是 使用误差反向传播法求梯度。

数值微分的计算很耗费时间，而且如果有误差反向传播法的(正确的)实现的话，就没有必要使用数值微分的实现了。那么数值微分有什么用呢？实际上，在确认误差反向传播法的实现是否正确时，是需要用到数值微分的。

数值微分的优点是实现简单，因此，一般情况下不太容易出错。而误差反向传播法的实现很复杂，容易出错。所以，经常会比较数值微分的结果和误差反向传播法的结果，以确认误差反向传播法的实现是否正确。确认数值微分求出的梯度结果和误差反向传播法求出的结果是否一致(严格地讲, 是非常相近)的操作称为 梯度确认(gradient check)。梯度确认的代码实现如下所示(源代码保存在gradient_ check.py文件中)。

# coding: utf-8
import sys, os
sys.path.append(os.pardir)  # 为了导入父目录的文件而进行的设定
import numpy as np
from dataset.mnist import load_mnist
from two_layer_net 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))

和以前一样，读人MNIST数据集。然后，使用训练数据的一部分，确认数值微分求出的梯度和误差反向传播法求出的梯度的误差。这里误差的计算方法是求各个权重参数中对应元素的差的绝对值，并计算其平均值。运行上面的代码后，会输出如下结果。

b1:9.70418809871e-13
W2:8.41139039497e-13
b2:1.1945999745e-10
W1:2.2232446644e- 13

从这个结果可以看出，通过数值微分和误差反向传播法求出的梯度的差非常小。比如，第1层的偏置的误差是9.7e-13(0.00000000097)。这样一来，我们就知道了通过误差反向传播法求出的梯度是正确的，误差反向传播法的实现没有错误。

7.4 使用误差反向传播法的学习

最后，我们来看一下使用了误差反向传播法的神经网络的学习的实现。和之前的实现相比，不同之处仅在于通过误差反向传播法求梯度这一点。

# coding: utf-8
import sys, os
sys.path.append(os.pardir)

import numpy as np
from dataset.mnist import load_mnist
from two_layer_net 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)

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 = []

iter_per_epoch = max(train_size / batch_size, 1)

for i in range(iters_num):
    batch_mask = np.random.choice(train_size, batch_size)
    x_batch = x_train[batch_mask]
    t_batch = t_train[batch_mask]
    
    # 梯度
    #grad = network.numerical_gradient(x_batch, t_batch)
    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)
    
    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)
        print(train_acc, test_acc)

8. 小结

本章我们介绍了将计算过程可视化的计算图，并使用计算图，介绍了神经网络中的误差反向传播法，并以层为单位实现了神经网络中的处理。我们学过的层有ReLU层、Softmax- with-Loss层、Affine层、 Softmax层等，这些层中实现了fonward和backward方法，通过将数据正向和反向地传播，可以高效地计算权重参数的梯度。通过使用层进行模块化，神经网络中可以自由地组装层，轻松构建出自己喜欢的网络。

本章所学的内容

• 通过使用计算图，可以直观地把握计算过程。
• 计算图的节点是由局部计算构成的。局部计算构成全局计算。
• 计算图的正向传播进行一般的计算。通过计算图的反向传播，可以计算各个节点的导数。
• 通过将神经网络的组成元素实现为层，可以高效地计算梯度(反向传播法)。
• 通过比较数值微分和误差反向传播法的结果，可以确认误差反向传播法的实现是否正确(梯度确认)。