2. 深度学习的helloworld！ 用Keras实现手写数字识别

经过上一章的1. Keras神经网络基础知识的铺垫，我们今天就利用Keras构建一个可以识别手写数字的网络。

1. MNIST数据集介绍

MNIST数据集是一个手写体数据集，由600000个训练样例和10000个测试样例组成的手写数字数据库。每个MNIST数据集都是灰度的，由28*28像素组成。

简单说就是一堆这样东西

我们的任务就是通过输入的手写数字图像信息来识别出相应的数字。

2. 程序示例

8说了，上代码

import numpy as np
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers.core import Dense, Activation
from keras.optimizers import SGD
from keras.utils import np_utils
np.random.seed(2019)             # 重复性设置

# 网络和训练
NB_EPOCH = 200
BATCH_SIZE = 128
VERBOSE = 1
NB_CLASSES = 10           # 输出个数等于数字个数
OPTIMIZER = SGD()         # SGD 优化器
N_HIDDEN = 128
VALIDATION_SPLIT = 0.2    # 训练集中用座验证集的比例

# 数据：混合并划分训练集和测试集数据
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# X_trian是60000行28*28的书据，变形为60000*784
RESHAPED = 784
X_train = X_train.reshape(60000, RESHAPED)
X_test = X_test.reshape(10000, RESHAPED)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')

# 归一化
X_train /= 255
X_test /= 255
print(X_train.shape[0], 'train sample')
print(X_test.shape[0], 'test sample')

# 将类向量转换为二值类别矩阵
Y_train = np_utils.to_categorical(y_train, NB_CLASSES)
Y_test = np_utils.to_categorical(y_test, NB_CLASSES)

# 10个输出
# 最后是softmax激活函数
model = Sequential()
model.add(Dense(NB_CLASSES, input_shape=(RESHAPED,)))
model.add(Activation('softmax'))
model.summary()

# 编译模型
# loss: 损失函数; 这里选择多分类对数损失函数(categorical_crossentropy)
# optimizer: 优化器; 这里选择SGD()
# metrics: 性能评估,该性能的评估结果讲不会用于训练; 这里选择accuracy准确率
model.compile(loss='categorical_crossentropy', optimizer=OPTIMIZER, metrics=['accuracy'])

# fit() 模型训练
# epochs 训练轮数
# batch_size 优化器进行权重更新前要观察的训练实例数
history = model.fit(X_train, Y_train, batch_size=BATCH_SIZE, epochs=NB_EPOCH,
                    verbose=VERBOSE, validation_split=VALIDATION_SPLIT)

#对模型训练的结果进行评估
score = model.evaluate(X_test, Y_test, verbose=VERBOSE)
print("Test score:", score[0])
print('Test accuracy:', score[1])

3. 训练结果

训练结束后，我们用测试数据对模型对模型进行测试，其中训练集上的准确率为92.31%，验证集上的准确率为92.32%，测试集上的准确率为92.25%

4. 进一步的改进

以上的测试结果表明10个手写数字里只有不到一个没有被正确识别。当然我们可以做的更好。我们看一下如何改进。

4.1 用隐藏层改进简单网络

第一个改进的方法是为我们的网络添加更多的层。所以在输入层之后，我们加入了两个具有N_HIDDEN个神经元并将ReLU作为激活函数的dense层。

model = Sequential()
model.add(Dense(N_HIDDEN, input_shape=(RESHAPED,)))  # 加入的第一个隐藏层
model.add(Activation('relu'))
model.add(Dense(N_HIDDEN))                           # 加入的第二个隐藏层
model.add(Activation('relu'))
model.add(Dense(NB_CLASSES))
model.add(Activation('softmax'))
model.summary()

结果：

测试集精度达到了97%

4.2 用dropout进一步改进简单网络

dropout就是我们决定在内部全连接的隐藏层上传播的值里，按dropout概率随机丢弃某些值。在机器学习中，这是一种众所周知的正则化形式。这看起来很荒唐，但它确实能提高我们的性能。

dropout层的效果

它的效果是让网络对神经元的特定权重变得不那么敏感。让网络能够更好地泛化，并且很少过拟合训练数据。

model = Sequential()
model.add(Dense(N_HIDDEN, input_shape=(RESHAPED,)))  # 加入的第一个隐藏层
model.add(Activation('relu'))                        # 激励函数为RELU
model.add(Dropout(DROPOUT))                          # 加在隐藏层上的dropout层
model.add(Dense(N_HIDDEN))                           # 加入的第二个隐藏层
model.add(Activation('relu'))
model.add(Dropout(DROPOUT))                          # 加在隐藏层上的dropout层
model.add(Dense(NB_CLASSES))
model.add(Activation('softmax'))
model.summary()

4.3 增加迭代次数

注意，训练集上的准确率应高于测试集上的准确率，否则说明我们的训练时间不够长。所以我们试着将训练轮数大幅增加至250。但注意，增加训练轮数不一定会使网络提高！

4.4 更换不同的优化器

我们一开始就使用叫做随机梯度下降 (Stochastic Gradient Descent, SGD) 优化器，关于梯度下降的原理，大家自行百度吧。除了SGD具有的加速度分量之外，RMSSprop和Adam还包括了动量的概念（速度分量）。这样可以通过更多的计算代价来实现更快的收敛。我们选用Adam作为优化器。

4.5 采用正则化方式避免过拟合

在模型的训练过程中，模型可能会变得过度复杂，因其所有内在关系都被记忆下来，复杂的模型可能在训练数据上会取得优秀的性能，但在验证数据上的性能却不好，因为对于全新的数据，模型不能很好地泛化。
如果在训练期间，我们看到损失函数在验证集上初始下降后转为增长，那就是一个过度训练的模型复杂度问题。我们称为过拟合。为了解决过拟合问题，我们需要用到正则化。
机器学习中用到了三种不同的正则化方法:

• L1正则化（也称为lasso）：模型复杂度表示为权重的绝对值之和
• L2正则化（也称为ridge）：模型复杂度表示为权重的平方和
• 弹性网络正则化：模型复杂度通过联合两种技术捕捉。

这里我们在内核（权重w）上使用了L2正则化方法：

from keras import regularizers
model.add(Dense(64, input_dim=64, kernel_regularizer=regularizers.l2(0.01)))

由于本实验并没有出现过拟合，所以并没有加入到最终代码中去。

4.6 其他的提高手段

• 控制优化器的学习率
• 增加内部隐藏神经元的数量N_HIDDEN
• 增加批处理的大小BATCH_SIZE
  以上几个提高模型准确率的方法都可以通过绘图来确定最佳参数，若参数设置不合理
  会出现计算变得更复杂但收益没有增加的情况

4.7 超参数调优

上述实验让我们了解了微调网络的可能方式。实际上有很多可以优化的参数（如隐藏神经元的数量、BATCH_SIZE、训练轮数，以及关于网络本身复杂度的参数等）
超参数调优是找到使成本函数最小化的那些参数组合的过程。

5. 输出预测

当模型训练好后，就可以用于预测。在Keras中这很简单：

prediction = model.predict(X)

对于给定的输入，可以计算出几种类型的输出，包括以下方法：

model.evaluate()          #用于计算损失值
model.predict_classes()   #用于计算输出类别
model.predict_proba()     #用于计算类别概率

---

6. 贴上最后的代码和结果

import numpy as np
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation
from keras.optimizers import SGD, RMSprop, Adam
from keras.utils import np_utils
np.random.seed(2019)             # 重复性设置

# 网络和训练
NB_EPOCH = 250
BATCH_SIZE = 128
VERBOSE = 1
NB_CLASSES = 10           # 输出个数等于数字个数
# OPTIMIZER = SGD()         # SGD 优化器
OPTIMIZER = Adam()        # Adam 优化器
N_HIDDEN = 128            # 隐藏层中输出个数
VALIDATION_SPLIT = 0.2    # 训练集中用作验证集的比例
DROPOUT = 0.3             # dropout丢弃神经元的概率

# 数据：混合并划分训练集和测试集数据
(X_train, y_train), (X_test, y_test) = mnist.load_data()

# X_trian是60000行28*28的书据，变形为60000*784
RESHAPED = 784
X_train = X_train.reshape(60000, RESHAPED)
X_test = X_test.reshape(10000, RESHAPED)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')

# 归一化
X_train /= 255
X_test /= 255
print(X_train.shape[0], 'train sample')
print(X_test.shape[0], 'test sample')

# 将类向量转换为二值类别矩阵（One-Hot编码）
Y_train = np_utils.to_categorical(y_train, NB_CLASSES)
Y_test = np_utils.to_categorical(y_test, NB_CLASSES)

# 10个输出
# 最后是softmax激活函数
model = Sequential()
model.add(Dense(N_HIDDEN, input_shape=(RESHAPED,)))  # 加入的第一个隐藏层
model.add(Activation('relu'))                        # 激励函数为RELU
model.add(Dropout(DROPOUT))                          # 加在隐藏层上的dropout层
model.add(Dense(N_HIDDEN))                           # 加入的第二个隐藏层
model.add(Activation('relu'))
model.add(Dropout(DROPOUT))                          # 加在隐藏层上的dropout层
model.add(Dense(NB_CLASSES))
model.add(Activation('softmax'))
model.summary()

# 编译模型
# loss: 损失函数; 这里选择多分类对数损失函数(categorical_crossentropy)
# optimizer: 优化器; 这里选择SGD()
# metrics: 性能评估,该性能的评估结果讲不会用于训练; 这里选择accuracy准确率
model.compile(loss='categorical_crossentropy', optimizer=OPTIMIZER, metrics=['accuracy'])

# fit() 模型训练
# epochs 训练轮数
# batch_size 优化器进行权重更新前要观察的训练实例数
# verbose 日志显示
# validation_split 验证集划分
history = model.fit(X_train, Y_train, batch_size=BATCH_SIZE, epochs=NB_EPOCH,
                    verbose=VERBOSE, validation_split=VALIDATION_SPLIT)

# 对模型训练的结果进行评估
score = model.evaluate(X_test, Y_test, verbose=VERBOSE)
print("Test score:", score[0])
print('Test accuracy:', score[1])

可以看出，最后的几个改进并没有显著提高。增加内部神经元的数量会产生更复杂的模型，并需要更昂贵的计算，但它只有微小的收益。即使增加训练轮数，也是同样的结果。

7. 开始你的深度学习之路

恭喜你完成了你的第一个神经网络模型，并且尝试对它进行了优化。
在优化的过程中，我们发现，越接近99%，优化就越困难。如果要更多的改进，我们需要一个全新的思路。想一想，我们错过了什么？
我们丢失了所有与图像的局部空间相关的信息！特别是这段代码将位图转换为空间局部性消失的平面向量：

X_train = X_train.reshape(60000, RESHAPED)
X_test = X_test.reshape(10000, RESHAPED)

为了利用这种空间局部信息，这就需要一种特殊的深度学习神经网络——卷积神经网络（Convolutional Neural Network, CNN），它既保留了图像的空间局部性信息，也保留了层次渐进的抽象学习的思想。如果你感兴趣的话，那就开始你的深度学习之路吧！