手写数字识别之优化算法
目录概述
上一节我们明确了分类任务的损失函数（优化目标）的相关概念和实现方法，本节我们依旧横向展开"横纵式"教学法，如 图1 所示，本节主要探讨在手写数字识别任务中，使得损失达到最小的参数取值的实现方法。
前提条件
在优化算法之前，需要进行数据处理、设计神经网络结构，代码与上一节保持一致，如下所示。如果读者已经掌握了这部分内容，可以直接阅读正文部分。
# 加载相关库
import os
import random
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, Linear
import numpy as np
from PIL import Image
import gzip
import json
# 定义数据集读取器
def load_data(mode='train'):
# 读取数据文件
datafile = './work/mnist.json.gz'
print('loading mnist dataset from {} ......'.format(datafile))
data = json.load(gzip.open(datafile))
# 读取数据集中的训练集，验证集和测试集
train_set, val_set, eval_set = data
# 数据集相关参数，图片高度IMG_ROWS, 图片宽度IMG_COLS
IMG_ROWS = 28
IMG_COLS = 28
# 根据输入mode参数决定使用训练集，验证集还是测试
if mode == 'train':
imgs = train_set[0]
labels = train_set[1]
elif mode == 'valid':
imgs = val_set[0]
labels = val_set[1]
elif mode == 'eval':
imgs = eval_set[0]
labels = eval_set[1]
# 获得所有图像的数量
imgs_length = len(imgs)
# 验证图像数量和标签数量是否一致
assert len(imgs) == len(labels), \
"length of train_imgs({}) should be the same as train_labels({})".format(
len(imgs), len(labels))
index_list = list(range(imgs_length))
# 读入数据时用到的batchsize
BATCHSIZE = 100
# 定义数据生成器
def data_generator():
# 训练模式下，打乱训练数据
if mode == 'train':
random.shuffle(index_list)
imgs_list = []
labels_list = []
# 按照索引读取数据
for i in index_list:
# 读取图像和标签，转换其尺寸和类型
img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
label = np.reshape(labels[i], [1]).astype('int64')
imgs_list.append(img)
labels_list.append(label)
# 如果当前数据缓存达到了batch size，就返回一个批次数据
if len(imgs_list) == BATCHSIZE:
yield np.array(imgs_list), np.array(labels_list)
# 清空数据缓存列表
imgs_list = []
labels_list = []
# 如果剩余数据的数目小于BATCHSIZE，
# 则剩余数据一起构成一个大小为len(imgs_list)的mini-batch
if len(imgs_list) > 0:
yield np.array(imgs_list), np.array(labels_list)
return data_generator
# 定义模型结构
class MNIST(fluid.dygraph.Layer):
def __init__(self):
super(MNIST, self).__init__()
# 定义一个卷积层，输出通道20，卷积核大小为5，步长为1，padding为2，使用relu激活函数
self.conv1 = Conv2D(num_channels=1, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
# 定义一个池化层，池化核为2，步长为2，使用最大池化方式
self.pool1 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
# 定义一个卷积层，输出通道20，卷积核大小为5，步长为1，padding为2，使用relu激活函数
self.conv2 = Conv2D(num_channels=20, num_filters=20, filter_size=5, stride=1, padding=2, act='relu')
# 定义一个池化层，池化核为2，步长为2，使用最大池化方式
self.pool2 = Pool2D(pool_size=2, pool_stride=2, pool_type='max')
# 定义一个全连接层，输出节点数为10
self.fc = Linear(input_dim=980, output_dim=10, act='softmax')
# 定义网络的前向计算过程
def forward(self, inputs):
x = self.conv1(inputs)
x = self.pool1(x)
x = self.conv2(x)
x = self.pool2(x)
x = fluid.layers.reshape(x, [x.shape[0], -1])
x = self.fc(x)
return x
设置学习率
在深度学习神经网络模型中，通常使用标准的随机梯度下降算法更新参数，学习率代表参数更新幅度的大小，即步长。当学习率最优时，模型的有效容量最大，最终能达到的效果最好。学习率和深度学习任务类型有关，合适的学习率往往需要大量的实验和调参经验。探索学习率最优值时需要注意如下两点：
- 学习率不是越小越好。学习率越小，损失函数的变化速度越慢，意味着我们需要花费更长的时间进行收敛，如 图2 左图所示。
- 学习率不是越大越好。只根据总样本集中的一个批次计算梯度，抽样误差会导致计算出的梯度不是全局最优的方向，且存在波动。在接近最优解时，过大的学习率会导致参数在最优解附近震荡，损失难以收敛，如 图2 右图所示。
图2: 不同学习率（步长过大/过小）的示意图
在训练前，我们往往不清楚一个特定问题设置成怎样的学习率是合理的，因此在训练时可以尝试调小或调大，通过观察Loss下降的情况判断合理的学习率，设置学习率的代码如下所示。
P.S.:为了方便对比不同学习率，或者后续提到的不同优化器，这里本人封装了一个training_config函数来提供一个修改训练模型超参数的接口，代码如下：
#仅优化算法的设置有所差别
def training_config(optimizer_type='SGD', learning_rate=0.01, EPOCH_NUM=5, save_model=False, use_gpu=False):
Loss_list = list()
optimizer_funcList = {'SGD':fluid.optimizer.SGDOptimizer,\
'Momentum':fluid.optimizer.MomentumOptimizer,\
'Adagrad':fluid.optimizer.AdagradOptimizer,\
'Adam':fluid.optimizer.AdamOptimizer}
place = fluid.CUDAPlace(0) if use_gpu else fluid.CPUPlace()
with fluid.dygraph.guard(place):
model = MNIST()
model.train()
#调用加载数据的函数
train_loader = load_data('train')
#设置不同初始学习率
if optimizer_type != 'Momentum':
op_dict = {'learning_rate':learning_rate, 'parameter_list':model.parameters()}
else:
op_dict = {'learning_rate':learning_rate, 'momentum':0.9, 'parameter_list':model.parameters()}
optimizer = optimizer_funcList[optimizer_type](**op_dict)
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(train_loader()):
#准备数据，变得更加简洁
image_data, label_data = data
image = fluid.dygraph.to_variable(image_data)
label = fluid.dygraph.to_variable(label_data)
#前向计算的过程
predict = model(image)
#计算损失，取一个批次样本损失的平均值
loss = fluid.layers.cross_entropy(predict, label)
avg_loss = fluid.layers.mean(loss)
#每训练了100批次的数据，打印下当前Loss的情况
if batch_id % 100 == 0:
print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))
Loss_list.append(avg_loss.numpy())
#后向传播，更新参数的过程
avg_loss.backward()
optimizer.minimize(avg_loss)
model.clear_gradients()
if save_model:
#保存模型参数
fluid.save_dygraph(model.state_dict(), 'mnist')
return Loss_list
对比不同学习率下模型的收敛效果
比较了三种不同学习率（0.01， 0.1， 1）的模型收敛情况如图2所示，训练代码及作图如下：
from matplotlib import pyplot as plt
Loss_List = []
LRs = [0.01, 0.1, 1.]
# 按照不同学习率训练模型，将训练过程的误差保存至Loss_List
for idx, lr in enumerate(LRs):
print('learning rate{}:'.format(idx))
Loss_List.append(training_config(optimizer_type='SGD', learning_rate=lr, use_gpu=True))
# 保存误差数据至'Loss_learningRate.npy'
np.save('Loss_learningRate.npy', Loss_List)
# 绘制不同学习率的图像
def plot_differentLearningRate(x, y, legend_list):
for idx,y_ in enumerate(y):
plt.plot(x, y_, label='learning rate:'+str(legend_list[idx]))
plt.title('SGD optimizer learning curve with different learning rates')
plt.xlabel('number of training')
plt.ylabel('loss')
plt.legend()
plt.show()
# 加载不同学习率下模型所得训练误差数据
Loss_lr = np.load('Loss_learningRate.npy')
arg_dict = {'x':np.arange(len(Loss_lr[0]))*100*100, 'y':Loss_lr, 'legend_list':LRs}
plot_differentLearningRate(**arg_dict)
图3: SGD优化器的不同学习率学习曲线的示意图
由图3可得，学习率为0.1时收敛速度最快，当步长过大(lr=1)时误差一直处于较高水平无法下降，当步长过小(lr=0.01)时收敛速度比学习率为0.1时慢。
学习率的主流优化算法
学习率是优化器的一个参数，调整学习率看似是一件非常麻烦的事情，需要不断的调整步长，观察训练时间和Loss的变化。经过研究员的不断的实验，当前已经形成了四种比较成熟的优化算法：SGD、Momentum、AdaGrad和Adam，效果如 图3 所示。
图3: 不同学习率算法效果示意图
每个批次的数据含有抽样误差，导致梯度更新的方向波动较大。如果我们引入物理动量的概念，给梯度下降的过程加入一定的“惯性”累积，就可以减少更新路径上的震荡，即每次更新的梯度由“历史多次梯度的累积方向”和“当次梯度”加权相加得到。历史多次梯度的累积方向往往是从全局视角更正确的方向，这与“惯性”的物理概念很像，也是为何其起名为“Momentum”的原因。类似不同品牌和材质的篮球有一定的重量差别，街头篮球队中的投手（擅长中远距离投篮）喜欢稍重篮球的比例较高。一个很重要的原因是，重的篮球惯性大，更不容易受到手势的小幅变形或风吹的影响。
- AdaGrad： 根据不同参数距离最优解的远近，动态调整学习率。学习率逐渐下降，依据各参数变化大小调整学习率。
通过调整学习率的实验可以发现：当某个参数的现值距离最优解较远时（表现为梯度的绝对值较大），我们期望参数更新的步长大一些，以便更快收敛到最优解。当某个参数的现值距离最优解较近时（表现为梯度的绝对值较小），我们期望参数的更新步长小一些，以便更精细的逼近最优解。类似于打高尔夫球，专业运动员第一杆开球时，通常会大力打一个远球，让球尽量落在洞口附近。当第二杆面对离洞口较近的球时，他会更轻柔而细致的推杆，避免将球打飞。与此类似，参数更新的步长应该随着优化过程逐渐减少，减少的程度与当前梯度的大小有关。根据这个思想编写的优化算法称为“AdaGrad”，Ada是Adaptive的缩写，表示“适应环境而变化”的意思。RMSProp是在AdaGrad基础上的改进，学习率随着梯度变化而适应，解决AdaGrad学习率急剧下降的问题。
- Adam： 由于动量和自适应学习率两个优化思路是正交的，因此可以将两个思路结合起来，这就是当前广泛应用的算法。
说明：
每种优化算法均有更多的参数设置，详情可查阅飞桨的官方API文档。理论最合理的未必在具体案例中最有效，所以模型调参是很有必要的，最优的模型配置往往是在一定“理论”和“经验”的指导下实验出来的。
我们可以尝试选择不同的优化算法训练模型，观察训练时间和损失变化的情况，代码实现如下。
Loss_List = []
opts = ['SGD', 'Momentum', 'Adagrad', 'Adam']
# 尝试不同优化器训练模型并获取对应
for idx, opt in enumerate(opts):
print('learning rate{}:'.format(idx))
Loss_List.append(training_config(optimizer_type=opt, use_gpu=True))
# 保存损失参数
np.save('Loss_optimizer.npy', Loss_List)
# 绘制使用不同优化器的训练曲线（学习率为0.01）
def plot_different_optimizer(x, y, legend_list):
for idx,y_ in enumerate(y):
plt.plot(x, y_, label='optimizer:'+str(legend_list[idx]))
plt.title('learning curve with different optimizer when lr=0.01')
plt.xlabel('number of training')
plt.ylabel('loss')
plt.legend()
plt.show()
lr_opt = np.load('Loss_optimizer.npy')
arg_dict = {'x':np.arange(len(lr_opt[0]))*100*100, 'y':lr_opt, 'legend_list':opts}
plot_different_optimizer(**arg_dict)
图4: 相同学习率下不同优化器的学习曲线
由图4可得，Adam,Adagrad,Momentum效果接近，均优于SGD。