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

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

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

3.6 手写数字识别

介绍完神经网络的结构之后，现在我们来试着解决实际问题。这里我们来进行手写数字图像的分类。假设学习已经全部结束，我们使用学习到的参数，先实现神经网络的“推理处理”。这个推理处理也称为神经网络的前向传播（forward propagation）。

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

3.6.1 MNIST数据集

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

MNIST数据集是由0到9的数字图像构成的（图3-24）。训练图像有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 
# 第一次调用会花费几分钟 …… 
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, 
normalize=False) 
# 输出各个数据的形状 
print(x_train.shape) # (60000, 784)
print(t_train.shape) # (60000,) 
print(x_test.shape) # (10000, 784) 
print(t_test.shape) # (10000,)

首先，为了导入父目录中的文件，进行相应的设定。然后，导入dataset/mnist.py中的 load_mnist函数。最后，使用 load_mnist函数，读入MNIST数据集。第一次调用load_mnist函数时，因为要下载MNIST数据集，所以需要接入网络。第2次及以后的调用只需读入保存在本地的文件（pickle文件）即可，因此处理所需的时间非常短。

用来读入MNIST图像的文件在本书提供的源代码的dataset目录下。并且，我们假定了这个MNIST数据集只能从ch01、ch02、ch03、…、ch08目录中使用，因此，使用时需要从父目录（dataset目录）中导入文件，为此需要添加sys.path.append(os.pardir)语句。

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数据的准备工作。

也可以使用tensorflow框架下的自带数据集加载：

from tensorflow.keras.datasets import mnist

# 加载数据集（返回四个变量：训练数据、标签、测试数据、测试标签）
(x_train, t_train), (x_test, t_test) = mnist.load_data()
# 可能需要几分钟时间
# 输出各个数据的形状
print(x_train.shape)  # (60000, 784)
print(t_train.shape)  # (60000,)
print(x_test.shape)  # (10000, 784)
print(t_test.shape)  # (10000,)

现在，我们试着显示MNIST图像，同时也确认一下数据。图像的显示使用PIL（Python Image Library）模块。执行下述代码后，训练图像的第一张就会显示出来，如图3-25所示（源代码在ch03/mnist_show.py中）。

import numpy as np
from PIL import Image
from tensorflow.keras.datasets import mnist


def img_show(img):
    pil_img = Image.fromarray(np.uint8(img))
    pil_img.show()


# 加载数据集（返回四个变量：训练数据、标签、测试数据、测试标签）
(x_train, t_train), (x_test, t_test) = mnist.load_data()
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)

# 鱼书第三章 mnist_show.py的优化
import sys
from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt
from tensorflow.keras.utils import to_categorical

def visualize_image(image, label):
    """专业图像可视化函数"""
    plt.figure(figsize=(6, 6))
    plt.imshow(image.reshape(28, 28), cmap='gray', vmin=0, vmax=1)
    plt.title(f"Digit: {label}", fontsize=14, color='blue')
    plt.colorbar(label='Intensity', ticks=[0, 0.5, 1], orientation='horizontal')
    plt.show()


def main():
    """主程序入口"""
    # 加载数据
    (x_train, y_train), (x_test, y_test) = mnist.load_data()

    # 可视化第一个样本
    first_image = x_train[0]
    first_label = y_train[0]
    print(f"\n正在显示第1个训练样本:")
    print(f"标签: {first_label}")
    print(f"图像形状: {first_image.shape}\n")

    visualize_image(first_image, first_label)

    # 数据预处理（可选）
    x_train = x_train.astype('float32') / 255.0
    y_train = to_categorical(y_train)


if __name__ == "__main__":
    main()

这里需要注意的是，flatten=True时读入的图像是以一列（一维）NumPy数组的形式保存的。因此，显示图像时，需要把它变为原来的28像素 × 28像素的形状。可以通过reshape()方法的参数指定期望的形状，更改NumPy数组的形状。此外，还需要把保存为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可以设置为任何值。下面我们先定义get_data()、init_network()、predict()这3个函数（代码在ch03/neuralnet_mnist.py中）。

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

#从dataset/mnist文件夹导入load_minst函数
from dataset.mnist import load_mnist 
from common.functions import sigmoid, softmax 
#从common/functions文件夹导入sigmoid和softmax函数


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

#用init_network()读入保存在pickle文件sample_weight.pkl中的学习到的权重参数A
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


x, t = get_data()
network = init_network()
accuracy_cnt = 0
#用for语句逐一取出保存在x中的图像数据，用predict()函数进行分类
for i in range(len(x)):  
    y = predict(network, x[i])
    p= np.argmax(y)      # 用np.argmax(x)函数取出数组中的最大值的索引
    if p == t[i]:
        accuracy_cnt += 1

print("Accuracy:" + str(float(accuracy_cnt) / len(x)))
#Accuracy:0.9352

首先获得 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的数组中的最大值元素的索引 。最后，比较神经网络所预测的答案和正确解标签，将回答正确的概率作为识别精度。

执行上面的代码后，会显示“ Accuracy:0 . 9352 ”。这表示有 93 . 52 % 的数据被正确分类了。目前我们的目标是运行学习到的神经网络，所以不讨论识别精度本身，不过 以后我们会花精力在神经网络的结构和学习方法上，思考如何进一步提高这个精度 。实际上，我们打算把精度提高到 99 % 以上。

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

预处理在神经网络（深度学习）中非常实用 ，其有效性已在提高识别性能和学习的效率等众多实验中得到证明。在刚才的例子中，作为一种预处理，我们将各个像素值除以 255，进行了简单的正规化。实际上，很多预处理都会考虑到数据的整体分布。比如， 利用数据整体的均值或标准差，移动数据，使数据整体以 0为中心分布，或者进行正规化，把数据的延展控制在一定范围内 。除此之外，还有将数据整体的分布形状均匀化的方法，即数据 白化 （whitening）等。

3.6.3　批处理

以上就是处理 MNIST 数据集的神经网络的实现，现在我们来关注输入数据和权重参数的“形状”。再看一下刚才的代码实现。

下面我们使用 Python解释器 ，输出刚才的神经网络的各层的权重的形状。

>>> x, _ = get_data()
>>> network = init_network()
>>> W1, W2, W3 = network['W1'], network['W2'], network['W3']
>>>
>>> x.shape
(10000, 784)
>>> x[0].shape
(784,)
>>> W1.shape
(784, 50)
>>> W2.shape
(50, 100)
>>> W3.shape
(100, 10)

我们通过上述结果来确认一下多维数组的对应维度的元素个数是否一致（省略了偏置）。用图表示的话，如图 3-26 所示。可以发现，多维数组的对应维度的元素个数确实是一致的。此外，我们还可以确认最终的结果是输出了元素个数为 10 的一维数组。

从整体的处理流程来看，图 3-26 中， 输入一个由784个元素（原本是一个28 × 28的二维数组） 构成的一维数组后， 输出一个有10个元素的一维数组 。这是只输入一张图像数据时的处理流程。

现在我们来考虑 打包输入多张图像的情形 。比如，我们想用 predict()函数一次性打包处理 100 张图像。为此，可以 把x的形状改为100 × 784 ，将100 张图像打包作为输入数据。用图表示的话，如图 3-27 所示。

如图 3-27 所示，输入数据的形状为 100 × 784，输出数据的形状为100 × 10。这表示输入的100张图像的结果被一次性输出了。比如，x[0]和y[0]中保存了第0张图像及其推理结果，x[1]和y[1]中保存了第1张图像及其推理结果，等等。

这种打包式的输入数据称为 批（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()函数若指定为range(start, end) ，则会生成一个由 start 到 end-1 之间的整数构成的列表。若像 range(start, end, step)这样指定3个整数，则生成的列表中的下一个元素会增加step指定的值 。我们来看一个例子。

>>> list( range(0, 10) )
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list( range(0, 10, 3) )
[0, 3, 6, 9]

在 range() 函数生成的列表的基础上， 通过x[i:i+batch_size]从输入数据中抽出批数据。x[i:i+batch_n]会取出从第i个到第i+batch_n个之间的数据。 本例中是像 x[0:100] 、 x[100:200] ……这样，从头开始以 100 为单位将数据提取为批数据。

然后， 通过argmax()获取值最大的元素的索引 。不过这里需要注意的是，我们给定了参数 axis=1 。这指定了在 100 × 10 的数组中，沿着第 1 维方向（以第 1 维为轴）找到值最大的元素的索引（第 0 维对应第 1 个维度）A 。这里也来看一个例子。

>>> x = np.array([[0.1, 0.8, 0.1], [0.3, 0.1, 0.6],
... [0.2, 0.5, 0.3], [0.8, 0.1, 0.1]])
>>> y = np.argmax(x, axis=1)
>>> print(y)
[1 2 1 0]

最后，我们比较一下以批为单位进行分类的结果和实际的答案。为此，需要在 NumPy 数组之间使用比较运算符（ == ）生成由 True/False 构成的布尔型数组，并计算 True 的个数。我们通过下面的例子进行确认。

>>> y = np.array([1, 2, 1, 0])
>>> t = np.array([1, 2, 0, 0])
>>> print(y==t)
[True True False True]
>>> np.sum(y==t)
3

至此，基于批处理的代码实现就介绍完了。 使用批处理，可以实现高速且高效的运算 。下一章介绍神经网络的学习时，我们将把图像数据作为打包的批数据进行学习，届时也将进行和这里的批处理一样的代码实现。

3.7 小结

本章介绍了神经网络的前向传播。本章介绍的神经网络和上一章的感知机在信号的按层传递这一点上是相同的，但是， 向下一个神经元发送信号时，改变信号的激活函数有很大差异 。神经网络中使用的是平滑变化的 sigmoid函数，而感知机中使用的是信号急剧变化的阶跃函数。这个差异对于神经网络的学习非常重要，我们将在下一章介绍。

本章所学的内容

• 神经网络中的激活函数使用平滑变化的sigmoid函数或ReLU函数。

• 通过巧妙地使用NumPy多维数组，可以高效地实现神经网络。

• 机器学习的问题大体上可以分为回归问题和分类问题。

• 关于输出层的激活函数，回归问题中一般用恒等函数，分类问题中一般用softmax函数。

• 分类问题中，输出层的神经元的数量设置为要分类的类别数。

• 输入数据的集合称为批。通过以批为单位进行推理处理，能够实现高速的运算。