深度学习入门笔记：第三章神经网络

深度学习入门笔记：第三章神经网络

笔记来源书籍：《深度学习入门：基于+Python+的理论与实现》

感知机看第二章笔记

前言

即便是计算机进行的复杂处理，感知机（理论上）也可以将 其表示出来。坏消息是，设定权重的工作，即确定合适的、能符合预期的输 入与输出的权重，现在还是由人工进行的。

神经网络的出现就是为了解决这个问题，神经网络的一 个重要性质是它可以自动地从数据中学习到合适的权重参数。

3.1从感知机到神经网络

3.1.1神经网络的例子

用图表示神经网络如图，

把最左边的一列称为 输入层，最右边的一列称为输出层，中间的一列称为中间层。中间层有时

也称为隐藏层。

“隐藏”一词的意思是，隐藏层的神经元（和输入层、输出层不同）肉眼看不见。

书籍中，将第0层对应输入层，第1层对应中间层，第2层对应输出层

图中网络一共由3层神经元构成，但实质上只有 2层神经元有权重，因此将其称为“2层网络”。有的书也会称为3层网络。

3.1.2感知机复习

图中x1和x2代表两个输入信号，输出y。数学表达式为

b是被称为偏置的参数，用于控制神经元被激活的容易程度；而w1和w2 是表示各个信号的权重的参数，用于控制各个信号的重要性。

图中没有画出偏置，如画出偏置，可以认为输出1，权重为偏置，如下图所示。则此时1，x1，x2

三个信号作为神经元输入。

将上面数学表达式简化为以下式子

则此时数学表达式更改为

输入信号的总和会被函数h(x)转换，转换后的值就是输出y。 然后，式值所表示的函数h(x)，在输入超过0时返回1，否则返回0。

3.1.3激活函数

h（x）函数会将输入信号的总和转换为输出信号，这种函数 一般称为激活函数（activation function）。

改写y式子

式（3.4）计算加权输入信号和偏置的总和，记为a。然后，式（3.5） 用h()函数将a转换为输出y。

可以如图表示

表示神经元的○中明确显示了激活函数的计算过程，即 信号的加权总和为节点a，然后节点a被激活函数h()转换成节点y。节点与神经元含义相同。

即：

“朴素感知机”是指单层网络，指的是激活函数使用了阶跃函数A 的模型。“多层感知机”是指神经网络，即使用 sigmoid 函数等平滑的激活函数的多层网络。

A 阶跃函数是指一旦输入超过阈值，就切换输出的函数。

3.2激活函数

3.2.1　sigmoid函数

经常使用的阶跃函数之一。如图

神经网络中用sigmoid函数作为激活函数，进行信号的转换，转换后的信号被传送给下一个神经元。同时感知机和神经网络的主要区别就是激活函数。

3.2.2　阶跃函数的实现

python实现阶跃函数，当输入超过0时，输出1， 否则输出0。

def step_function(x):
 if x > 0:
 return 1
 else:
 return 0

修改为支持NumPy数组的实现。

def step_function(x):
 y = x > 0
 return y.astype(np.int)

数组y是一个布尔型数组，想要阶跃函数是会输出int型的0 或1的函数，需要把数组y的元素类型从布尔型转换为int型。可以用astype()方法转换NumPy数组的类型。astype()方 法通过参数指定期望的类型，这个例子中是np.int型。Python中将布尔型 转换为int型后，True会转换为1，False会转换为0。

3.2.3　阶跃函数的图形

用图来表示阶跃函数

import numpy as np
import matplotlib.pylab as plt
def step_function(x):
 return np.array(x > 0, dtype=np.int)
x = np.arange(-5.0, 5.0, 0.1)
y = step_function(x)
plt.plot(x, y)
plt.ylim(-0.1, 1.1) # 指定y轴的范围
plt.show()

step_function()以该NumPy数组为 参数，对数组的各个元素执行阶跃函数运算，并以数组形式返回运算结果。

结果如图

阶跃函数以0为界，输出从0切换为1（或者从1切换为0）。 它的值呈阶梯式变化，所以称为阶跃函数。

3.2.4　sigmoid函数的实现

python表示sigmoid函数，

def sigmoid(x):
 return 1 / (1 + np.exp(-x))

np.exp(-x)对应exp(−x)，x可以为NumPy数组

sigmoid函数能支持NumPy数组，原因是广播功能，np.exp(-x)是一个NumPy数组，所以最后返回的值也是一个NumPy数组。

sigmoid函数画在图上

x = np.arange(-5.0, 5.0, 0.1)
y = sigmoid(x)
plt.plot(x, y)
plt.ylim(-0.1, 1.1) # 指定y轴的范围
plt.show()

3.2.5　sigmoid函数和阶跃函数的比较

• “平滑性”的不同。sigmoid函数是一条平 滑的曲线，输出随着输入发生连续性的变化。而阶跃函数以0为界，输出发 生急剧性的变化。
• 返回值不同，阶跃函数只能返回0或1，sigmoid函数可以返 回0.731 …、0.880 …等实数（这点与平滑性有关），感知机中神经元之间流动的是0或1的二元信号，而神经网络中流动的是连续 的实数值信号。
• 共同性质：从宏观视角看图3-8，可以发现它们 具有相似的形状。实际上，两者的结构均是“输入小时，输出接近0（为0）； 随着输入增大，输出向1靠近（变成1）”。也就是说，当输入信号为重要信息时， 阶跃函数和sigmoid函数都会输出较大的值；当输入信号为不重要的信息时， 两者都输出较小的值。还有一个共同点是，不管输入信号有多小，或者有多 大，输出信号的值都在0到1之间。

3.2.6　非线性函数

阶跃函数（折线）和sigmoid函数（曲线）还有其他共同点，就是两者均为非线性函数。

为了发挥叠加层所 带来的优势，激活函数必须使用非线性函数。

解析例子：考虑把线性函数 h(x) = cx 作为激活 函数，把y(x) = h(h(h(x)))的运算对应3层神经网络A。这个运算会进行 y(x) = c × c × c × x的乘法运算，但是同样的处理可以由y(x) = ax（注意， a = c 3 ）这一次乘法运算（即没有隐藏层的神经网络）来表示。如本例所示， 使用线性函数时，无法发挥多层网络带来的优势。

3.2.7　ReLU函数

最近的主要使用函数。ReLU（Rectified Linear Unit）。

ReLU函数在输入大于0时，直接输出该值；在输入小于等于0时，输出0。

python实现

def relu(x):
 return np.maximum(0, x)

maximum函数会从输入的数值中选 择较大的那个值进行输出。

3.3 多维数组的运算

3.3.1　多维数组

NumPy实现多维数组

>>> B = np.array([[1,2], [3,4], [5,6]])
>>> print(B)
[[1 2]
 [3 4]
 [5 6]]
>>> np.ndim(B)
2
>>> B.shape
(3, 2)

数组的维数可以通过np.dim()函数获得。此外，数组的形状可以通过实例变量shape获得。

第一个维度对应第0维，第二个维度对应第1维（Python的索引从0开始）。二维数组也称为矩阵。

3.3.2　矩阵乘法

与线性代数中矩阵乘法相同。矩阵的乘积是通过左边矩阵的行（横向）和右边矩阵的列（纵向）以对应元素的方式相乘后再求和而得到的。并且，运算的结果保存为新的多维数组的元素。

python代码实现

>>> A = np.array([[1,2,3], [4,5,6]])
>>> A.shape
(2, 3)
>>> B = np.array([[1,2], [3,4], [5,6]])
>>> B.shape
(3, 2)
>>> np.dot(A, B)
array([[22, 28],
 [49, 64]])

矩阵A的第1维的元素个数（列数） 必须和矩阵B的第0维的元素个数（行数）相等。

另外，当A是二维矩阵、B是一维数组时，如图3-13所示，对应维度 的元素个数要保持一致的原则依然成立。如图

3.3.3　神经网络的内积

NumPy矩阵来实现神经网络。如图（其中x形状与w的行形状一致）

python实现

>>> X = np.array([1, 2])
>>> X.shape
(2,)
>>> W = np.array([[1, 3, 5], [2, 4, 6]])
>>> print(W)
[[1 3 5]
 [2 4 6]]
>>> W.shape
(2, 3)
>>> Y = np.dot(X, W)
>>> print(Y)
[ 5 11 17]

np.dot（多维数组的点积）

3.4 3层神经网络的实现

巧妙地使用NumPy数组，可以用很少的代码完成神经网络的前向处理。

前项处理：输入到输出的处理

3.4.1　符号确认

3.4.2　各层间信号传递的实现

输入层到第1层的偏置如图表示

第一层加权和可以表示为

用NumPy多维数组来实现

X = np.array([1.0, 0.5])
W1 = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
B1 = np.array([0.1, 0.2, 0.3])
print(W1.shape) # (2, 3)
print(X.shape) # (2,)
print(B1.shape) # (3,)
A1 = np.dot(X, W1) + B1

后使用激活函数将输入的加权和转化为输出

Z1 = sigmoid(A1)

实现第1层到第2层的信号传递代码相同，如下。

W2 = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
B2 = np.array([0.1, 0.2])
print(Z1.shape) # (3,)
print(W2.shape) # (3, 2)
print(B2.shape) # (2,)
A2 = np.dot(Z1, W2) + B2
Z2 = sigmoid(A2)

可以发现只是更改了变量，由此可知，通过使用NumPy数组，可以将层到层的信号传递过程简单地写出来。

第二层到输出层的信号传递与之前类似，唯一不懂的是激活函数，

def identity_function(x):
 return x
W3 = np.array([[0.1, 0.3], [0.2, 0.4]])
B3 = np.array([0.1, 0.2])
A3 = np.dot(Z2, W3) + B3
Y = identity_function(A3) # 或者Y = A3

identity_function()函数（也称为“恒等函数”），并将 其作为输出层的激活函数。恒等函数会将输入按原样输出，因此，这个例子 中没有必要特意定义identity_function()。这里这样实现只是为了和之前的 流程保持统一。

输出层的激活函数用σ()表示，不同于隐 藏层的激活函数h()（σ读作sigma）。

输出层所用的激活函数，要根据求解问题的性质决定。一般地，回 归问题可以使用恒等函数，二元分类问题可以使用 sigmoid函数， 多元分类问题可以使用 softmax函数。

3.4.3　代码实现小结

3层神经网络实现代码全部整合

def init_network():
 network = {}
 network['W1'] = np.array([[0.1, 0.3, 0.5], [0.2, 0.4, 0.6]])
 network['b1'] = np.array([0.1, 0.2, 0.3])
 network['W2'] = np.array([[0.1, 0.4], [0.2, 0.5], [0.3, 0.6]])
 network['b2'] = np.array([0.1, 0.2])
 network['W3'] = np.array([[0.1, 0.3], [0.2, 0.4]])
 network['b3'] = np.array([0.1, 0.2])
 return network
def forward(network, x):
 W1, W2, W3 = network['W1'], network['W2'], network['W3']
 b1, b2, b3 = network['b1'], network['b2'], network['b3']
 a1 = np.dot(x, W1) + b1
 z1 = sigmoid(a1)
 a2 = np.dot(z1, W2) + b2
 z2 = sigmoid(a2)
 a3 = np.dot(z2, W3) + b3
 y = identity_function(a3)
 return y
 network = init_network()
 x = np.array([1.0, 0.5])
 y = forward(network, x)
 print(y) # [ 0.31682708 0.69627909]

init_network()函数会进行权重和偏置的初始化，并将它们保存在字典变量network中。这个字典变 量network中保存了每一层所需的参数（权重和偏置）。forward()函数中则封装了将输入信号转换为输出信号的处理过程。

forward表示的是从输入到输出方向 的传递处理。

3.5 输出层的设计

机器学习的问题大致可以分为分类问题和回归问题。分类问题是数 据属于哪一个类别的问题。比如，区分图像中的人是男性还是女性 的问题就是分类问题。而回归问题是根据某个输入预测一个（连续的） 数值的问题。比如，根据一个人的图像预测这个人的体重的问题就 是回归问题。

3.5.1　恒等函数和 softmax函数

恒等函数会将输入按原样输出。神经网络图表示

分类问题中使用的softmax函数

假设输出层共有n个神经元，计算第k个神经元的输出yk。softmax函数的分子是输入信号ak的指数函数，分母是所有输入信号的指数函数的和。

对应神经网络图

可以看出输出层的各个神经元都受到所有输入信号的影响。

python实现softmax函数

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

3.5.2　实现 softmax函数时的注意事项

上面的softmax函数的实现虽然正确描述了式，但在计算机的运算上有一定的缺陷，即溢出问题。softmax函数的实现中要进行指 数函数的运算，但是此时指数函数的值很容易变得非常大。例如e ^100会变成一个后面有40多个0的超大值。

计算机处理“数”时，数值必须在 4字节或 8字节的有限数据宽度内。 这意味着数存在有效位数，也就是说，可以表示的数值范围是有限的。因此，会出现超大值无法表示的问题。这个问题称为溢出。

对softmax函数的实现进行改进。

这里的C`可以使用任何值，但是为了防止溢出，一般会使用输入信号中的最大值。

例子如下

>>> a = np.array([1010, 1000, 990])
>>> np.exp(a) / np.sum(np.exp(a)) # softmax函数的运算
array([ nan, nan, nan]) # 没有被正确计算
>>>
>>> c = np.max(a) # 1010
>>> a - c
array([ 0, -10, -20])
>>>
>>> np.exp(a - c) / np.sum(np.exp(a - c))
array([ 9.99954600e-01, 4.53978686e-05, 2.06106005e-09])

可以发现，经过减去最大值1010后，原本为nan（不确定）的地方能够正确显示结果。此时对应的python代码为

def softmax(a):
 c = np.max(a)
 exp_a = np.exp(a - c) # 溢出对策
 sum_exp_a = np.sum(exp_a)
 y = exp_a / sum_exp_a
 return y

3.5.3　softmax函数的特征

使用softmax()函数，可以按如下方式计算神经网络的输出。

>>> a = np.array([0.3, 2.9, 4.0])
>>> y = softmax(a)
>>> print(y)
[ 0.01821127 0.24519181 0.73659691]
>>> np.sum(y)
1.0

softmax函数的输出是0.0到1.0之间的实数。并且，softmax 函数的输出值的总和是1。输出总和为1是softmax函数的一个重要性质。softmax函数的输出解释为“概率”。

例如y[0]的概率是0.018（1.8 %）。

注意：即便使用了softmax函数，各个元素之间的大小关系也不会改变。原因为所使用的指数函数为递增函数。实际上， 上例中a的各元素的大小关系和y的各元素的大小关系并没有改变。比如，a 的最大值是第2个元素，y的最大值也仍是第2个元素。

一般而言，神经网络只把输出值最大的神经元所对应的类别作为识别结果。 并且，即便使用softmax函数，输出值最大的神经元的位置也不会变。因此， 神经网络在进行分类时，输出层的softmax函数可以省略。在实际问题中，由于指数函数的运算需要一定的计算机运算量，因此输出层的softmax函数 一般会被省略。

求解机器学习问题的步骤可以分为“学习” 和“推理”两个阶段。首 先，在学习阶段进行模型的学习，然后，在推理阶段，用学到的模型对未知的数据进行推理（分类）。如前所述，推理阶段一般会省略输出层的 softmax函数。在输出层使用 softmax函数是因为它和 神经网络的学习有关系

3.5.4　输出层的神经元数量

输出层的神经元数量需要根据待解决的问题来决定。对于分类问题，输出层的神经元数量一般设定为类别的数量。比如，对于某个输入图像，预测是数字0到9中的哪一个的问题（10类别分类问题），将输出层的神经元设定为10个。

例如

这个例子中神经元y2颜色最深，输出的值最大。这表明这个神经网络预测的是y2对应 的类别，也就是“2”。

3.6 手写数字识别

使用神经网络解决实际问题，先要实现”推理处理“。这个推理处理也称为神经网络的前向 传播（forward propagation）。

和求解机器学习问题的步骤（分成学习和推理两个阶段进行）一样， 使用神经网络解决问题时，也需要首先使用训练数据（学习数据）进行权重参数的学习；进行推理时，使用刚才学习到的参数，对输入数据进行分类。

3.6.1 MNIST数据集

这里使用的数据集是MNIST手写数字图像集。MNIST是机器学习领域 最有名的数据集之一，被应用于从简单的实验到发表的论文研究等各种场合，实际上，在阅读图像识别或机器学习的论文时，MNIST数据集经常作为实 验用的数据出现。

MNIST数据集是由0到9的数字图像构成的。训练图像有6万张， 测试图像有1万张，这些图像可以用于学习和推理。MNIST数据集的一般 使用方法是，先用训练图像进行学习，再用学习到的模型度量能在多大程度 上对测试图像进行正确的分类。

MNIST的图像数据是28像素 × 28像素的灰度图像（1通道），各个像素 的取值在0到255之间。每个图像数据都相应地标有“7”“2”“1”等标签。

Python脚本mnist.py，该脚本支持从下载MNIST数据集到将这些数据转换成NumPy数组等处理（mnist.py在dataset目录下）。使用 mnist.py时，当前目录必须是ch01、ch02、ch03、…、ch08目录中的一个。使 用mnist.py中的load_mnist()函数，就可以按下述方式轻松读入MNIST数据。

import sys, os
sys.path.append(os.pardir) # 为了导入父目录中的文件而进行的设定
from dataset.mnist import load_mnist # dataset为父目录
# 第一次调用会花费几分钟 ……
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True,
normalize=False)
# 输出各个数据的形状
print(x_train.shape) # (60000, 784)

代码解析：首先，为了导入父目录中的文件，进行相应的设定。然后，导入 dataset/mnist.py中的 load_mnist函数。最后，使用 load_mnist函数，读入 MNIST数据集。

load_mnist函数以“(``训练图像 ,训练标签 )，(测试图像，测试标签` )”的 形式返回读入的MNIST数据。此外，还可以像load_mnist(normalize=True, flatten=True, one_hot_label=False) 这 样，设 置 3 个 参 数。第 1 个参数 normalize设置是否将输入图像正规化为0.0～1.0的值。如果将该参数设置 为False，则输入图像的像素会保持原来的0～255。第2个参数flatten设置 是否展开输入图像（变成一维数组）。如果将该参数设置为False，则输入图 像为1 × 28 × 28的三维数组；若设置为True，则输入图像会保存为由784个 元素构成的一维数组。第3个参数one_hot_label设置是否将标签保存为onehot表示（one-hot representation）。one-hot表示是仅正确解标签为1，其余 皆为0的数组，就像[0,0,1,0,0,0,0,0,0,0]这样。当one_hot_label为False时， 只是像7、2这样简单保存正确解标签；当one_hot_label为True时，标签则 保存为one-hot表示。

Python的pickle功能可以将程序运行中的对象保存为文件。如果加载保存过的 pickle文件，可以立刻复原之前 程序运行中的对象。用于读入MNIST数据集的load_mnist()函数内 部也使用了 pickle功能（在第 2次及以后读入时）。利用 pickle功能， 可以高效地完成MNIST数据的准备工作.

使用代码演示

import sys, os
sys.path.append(os.pardir)
import numpy as np
from dataset.mnist import load_mnist
from PIL import Image
def img_show(img):
 pil_img = Image.fromarray(np.uint8(img))
 pil_img.show()
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True,
normalize=False)
img = x_train[0]
label = t_train[0]
print(label) # 5
print(img.shape) # (784,)
img = img.reshape(28, 28) # 把图像的形状变成原来的尺寸
print(img.shape) # (28, 28)
img_show(img)

• 通过reshape()方法的参数指定期望的形状，更改NumPy 数组的形状。flatten=True时读入的图像是以一列（一维）NumPy 数组的形式保存的，显示图像时，需要把它变为原来的28像素 × 28 像素的形状。
• 还需要把保存为NumPy数组的图像数据转换为PIL用 的数据对象，这个转换处理由Image.fromarray()来完成。

3.6.2　神经网络的推理处理

MNIST数据集实现神经网络的推理处理，神经网络 的输入层有784个神经元，输出层有10个神经元。输入层的784这个数字来 源于图像大小的28 × 28 = 784，输出层的10这个数字来源于10类别分类（数 字0到9，共10类别）。此外，这个神经网络有2个隐藏层，第1个隐藏层有 50个神经元，第2个隐藏层有100个神经元。这个50和100可以设置为任何值。

def get_data():
 (x_train, t_train), (x_test, t_test) = \
 load_mnist(normalize=True, flatten=True, one_hot_label=False)
 return x_test, t_test
def init_network():
 with open("sample_weight.pkl", 'rb') as f:
 network = pickle.load(f)
 return network
def predict(network, x):
 W1, W2, W3 = network['W1'], network['W2'], network['W3']
 b1, b2, b3 = network['b1'], network['b2'], network['b3']
 a1 = np.dot(x, W1) + b1
 z1 = sigmoid(a1)
 a2 = np.dot(z1, W2) + b2
 z2 = sigmoid(a2)
 a3 = np.dot(z2, W3) + b3
 y = softmax(a3)
 
 return y

• init_network()会读入保存在pickle文件sample_weight.pkl中的学习到的 权重参数A。这个文件中以字典变量的形式保存了权重和偏置参数。

实现神经网络的推理处理

x, t = get_data()
network = init_network()
accuracy_cnt = 0
for i in range(len(x)):
 y = predict(network, x[i])
 p = np.argmax(y) # 获取概率最高的元素的索引
 if p == t[i]:
 accuracy_cnt += 1
print("Accuracy:" + str(float(accuracy_cnt) / len(x)))

首先获得MNIST数据集，生成网络。接着，用for语句逐一取出保存在x中的图像数据，用predict()函数进行分类。predict()函数以NumPy数 组的形式输出各个标签对应的概率。比如输出[0.1, 0.3, 0.2, …, 0.04]的 数组，该数组表示“0”的概率为0.1，“1”的概率为0.3，等等。然后，我们 取出这个概率列表中的最大值的索引（第几个元素的概率最高），作为预测结 果。可以用np.argmax(x)函数取出数组中的最大值的索引，np.argmax(x)将 获取被赋给参数x的数组中的最大值元素的索引。最后，比较神经网络所预测的答案和正确解标签，将回答正确的概率作为识别精度.

在这个例子中，我们把load_mnist函数的参数normalize设置成了 True。将normalize设置成True后，函数内部会进行转换，将图像的各个像 素值除以255，使得数据的值在0.0～1.0的范围内。像这样把数据限定到某 个范围内的处理称为正规化（normalization）。此外，对神经网络的输入数据 进行某种既定的转换称为预处理（pre-processing）。

将数据整体的分布形状均匀化的方法，即数据白化.

3.6.3　批处理

输入一张图片时，输入一个由784个元素（原本是一 个28 × 28的二维数组）构成的一维数组后，输出一个有10个元素的一维数组。

输入100张图片时

这种打包式的输入数据称为批（batch）。即输入数据的集合称为批。通过以批为单位进行推理处理，能够实现高速的运算。

批处理对计算机的运算大有利处，可以大幅缩短每张图像的处理时间。那么为什么批处理可以缩短处理时间呢？这是因为大多数处理 数值计算的库都进行了能够高效处理大型数组运算的最优化。并且， 在神经网络的运算中，当数据传送成为瓶颈时，批处理可以减轻数 据总线的负荷

使用批处理实现神经网络的推理处理

x, t = get_data()# 返回测试图像和测试标签
network = init_network()
batch_size = 100 # 批数量
accuracy_cnt = 0
for i in range(0, len(x), batch_size):
 x_batch = x[i:i+batch_size]
 y_batch = predict(network, x_batch)
 p = np.argmax(y_batch, axis=1)
 accuracy_cnt += np.sum(p == t[i:i+batch_size])
print("Accuracy:" + str(float(accuracy_cnt) / len(x)))

• range()函数若指定为range(start, end)，则会生成一个由start到end-1之间的整数构成的 列表。若像range(start, end, step)这样指定3个整数，则生成的列表中的 下一个元素会增加step(步长）指定的值。
• 参数axis=1。这指定了在100 × 10的数组中，沿着第1维方向（以 第1维为轴）找到值最大的元素的索引（第0维对应第1个维度）。
• 比较一下以批为单位进行分类的结果和实际的答案。 需要在NumPy数组之间使用比较运算符（==）生成由True/False构成的布尔型数组。