一、项目平台 百度飞桨
二、项目框架 1.数据处理;
2.模型设计:网络结构,损失函数;
3.训练配置:优化器,资源配置;
4.训练过程;
5.保存加载。
三、手写数字识别任务 1.构建神经网络流程;
手写数字识别是一个典型的图像分类问题;
MNIST数据集;
2.构建神经网络设计思路:
(1)明确任务输入输出:
任务输入:手写数字图片,每张照片对应的28*28像素矩阵。
任务输出:经过大小归一化和居中处理,输出对应的0-9数字标签。
(2)模型构建的代码结构:
数据处理:
模型设计:
训练配置:
训练过程:
模型保存。
文章图片
四、模型入门 1.前提条件-加载好库类
#加载飞桨和相关类库
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Linear
import numpy as np
import os
from PIL import Image
2.数据集获取和读取
官网上获得数据集。
通过paddle.dataset.mnist.train()函数设置数据读取器,batch_size设置为8,即一个批次有8张图片和8个标签,代码如下所示。
# 如果~/.cache/paddle/dataset/mnist/目录下没有MNIST数据,API会自动将MINST数据下载到该文件夹下
# 设置数据读取器,读取MNIST数据训练集
trainset = paddle.dataset.mnist.train()
# 包装数据读取器,每次读取的数据数量设置为batch_size=8
train_reader = paddle.batch(trainset, batch_size=8)
paddle.batch函数将MNIST数据集拆分成多个批次,通过如下代码读取第一个批次的数据内容,观察数据打印结果。
# 以迭代的形式读取数据
for batch_id, data in enumerate(train_reader()):
# 获得图像数据,并转为float32类型的数组
img_data = https://www.it610.com/article/np.array([x[0] for x in data]).astype('float32')
# 获得图像标签数据,并转为float32类型的数组
label_data = https://www.it610.com/article/np.array([x[1] for x in data]).astype('float32')
# 打印数据形状
print("图像数据形状和对应数据为:", img_data.shape, img_data[0])
print("图像标签形状和对应数据为:", label_data.shape, label_data[0])
breakprint("\n打印第一个batch的第一个图像,对应标签数字为{}".format(label_data[0]))
# 显示第一batch的第一个图像
import matplotlib.pyplot as plt
img = np.array(img_data[0]+1)*127.5
img = np.reshape(img, [28, 28]).astype(np.uint8)plt.figure("Image") # 图像窗口名称
plt.imshow(img)
plt.axis('on') # 关掉坐标轴为 off
plt.title('image') # 图像题目
plt.show()
3.模型设计
在房价预测深度学习任务中,我们使用了单层且没有非线性变换的模型,取得了理想的预测效果。在手写数字识别中,我们依然使用这个模型预测输入的图形数字值。其中,模型的输入为784维(2828)数据,输出为1维数据,如 图所示。
文章图片
输入像素的位置排布信息对理解图像内容非常重要(如将原始尺寸为2828图像的像素按照7112的尺寸排布,那么其中的数字将不可识别),因此网络的输入设计为2828的尺寸,而不是1*784,以便于模型能够正确处理像素之间的空间信息。
下面以类的方式组建手写数字识别的网络,实现方法如下所示。
# 定义mnist数据识别网络结构,同房价预测网络
class MNIST(fluid.dygraph.Layer):
def __init__(self):
super(MNIST, self).__init__()# 定义一层全连接层,输出维度是1,激活函数为None,即不使用激活函数
self.fc = Linear(input_dim=784, output_dim=1, act=None)# 定义网络结构的前向计算过程
def forward(self, inputs):
outputs = self.fc(inputs)
return outputs
4.训练配置
训练配置需要先生成模型实例(设为“训练”状态),再设置优化算法和学习率(使用随机梯度下降SGD,学习率设置为0.001),实现方法如下所示。
# 定义飞桨动态图工作环境
with fluid.dygraph.guard():
# 声明网络结构
model = MNIST()
# 启动训练模式
model.train()
# 定义数据读取函数,数据读取batch_size设置为16
train_loader = paddle.batch(paddle.dataset.mnist.train(), batch_size=16)
# 定义优化器,使用随机梯度下降SGD优化器,学习率设置为0.001
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001, parameter_list=model.parameters())
5.训练过程
训练过程采用二层循环嵌套方式,训练完成后需要保存模型参数,以便后续使用。
内层循环:负责整个数据集的一次遍历,遍历数据集采用分批次(batch)方式。
外层循环:定义遍历数据集的次数,本次训练中外层循环10次,通过参数EPOCH_NUM设置。
# 通过with语句创建一个dygraph运行的context
# 动态图下的一些操作需要在guard下进行
with fluid.dygraph.guard():
model = MNIST()
model.train()
train_loader = paddle.batch(paddle.dataset.mnist.train(), batch_size=16)
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001, parameter_list=model.parameters())
EPOCH_NUM = 10
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(train_loader()):
#准备数据,格式需要转换成符合框架要求的
image_data = https://www.it610.com/article/np.array([x[0] for x in data]).astype('float32')
label_data = https://www.it610.com/article/np.array([x[1] for x in data]).astype('float32').reshape(-1, 1)
# 将数据转为飞桨动态图格式
image = fluid.dygraph.to_variable(image_data)
label = fluid.dygraph.to_variable(label_data)#前向计算的过程
predict = model(image)#计算损失,取一个批次样本损失的平均值
loss = fluid.layers.square_error_cost(predict, label)
avg_loss = fluid.layers.mean(loss)#每训练了1000批次的数据,打印下当前Loss的情况
if batch_id !=0 and batch_id% 1000 == 0:
print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))#后向传播,更新参数的过程
avg_loss.backward()
optimizer.minimize(avg_loss)
model.clear_gradients()# 保存模型
fluid.save_dygraph(model.state_dict(), 'mnist')
【深度学习|深度学习入门实践学习——手写数字识别(百度飞桨平台)——上篇】6.模型测试:
模型测试的主要目的是验证训练好的模型是否能正确识别出数字,包括如下四步:
(1)声明实例
(2)加载模型:加载训练过程中保存的模型参数,
(3)灌入数据:将测试样本传入模型,模型的状态设置为校验状态(eval),显式告诉框架我们接下来只会使用前向计算的流程,不会计算梯度和梯度反向传播。
(4)获取预测结果,取整后作为预测标签输出。
在模型测试之前,需要先从’./work/example_0.jpg’文件中读取样例图片,并进行归一化处理。
# 导入图像读取第三方库
import matplotlib.image as mpimg
import matplotlib.pyplot as plt
import cv2
import numpy as np
# 读取图像
img1 = cv2.imread('./work/example_0.png')
example = mpimg.imread('./work/example_0.png')
# 显示图像
plt.imshow(example)
plt.show()
im = Image.open('./work/example_0.png').convert('L')
print(np.array(im).shape)
im = im.resize((28, 28), Image.ANTIALIAS)
plt.imshow(im)
plt.show()
print(np.array(im).shape)
# 读取一张本地的样例图片,转变成模型输入的格式
def load_image(img_path):
# 从img_path中读取图像,并转为灰度图
im = Image.open(img_path).convert('L')
print(np.array(im))
im = im.resize((28, 28), Image.ANTIALIAS)
im = np.array(im).reshape(1, -1).astype(np.float32)
# 图像归一化,保持和数据集的数据范围一致
im = 1 - im / 127.5
return im# 定义预测过程
with fluid.dygraph.guard():
model = MNIST()
params_file_path = 'mnist'
img_path = './work/example_0.png'
# 加载模型参数
model_dict, _ = fluid.load_dygraph("mnist")
model.load_dict(model_dict)
# 灌入数据
model.eval()
tensor_img = load_image(img_path)
result = model(fluid.dygraph.to_variable(tensor_img))
#预测输出取整,即为预测的数字,打印结果
print("本次预测的数字是", result.numpy().astype('int32'))
(在上边的测试中发现测出的数字与实际输入的不一样。对模型进行修改。)
#加载飞桨和相关类库
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Linear
import numpy as np
import os# 定义mnist数据识别网络结构,同房价预测网络
class MNIST(fluid.dygraph.Layer):
def __init__(self):
super(MNIST, self).__init__()# 定义一层全连接层,输出维度是1,激活函数为None,即不使用激活函数
self.fc = Linear(input_dim=784, output_dim=1, act=None)# 定义网络结构的前向计算过程
def forward(self, inputs):
outputs = self.fc(inputs)
return outputstrainset = paddle.dataset.mnist.train()
test_reader = paddle.batch(trainset, batch_size=100)
# 无序的100个数据
shuffle_reader = paddle.fluid.io.shuffle(test_reader,100)# 以迭代的形式读取数据
for batch_id, data in enumerate(shuffle_reader()):
# 获得图像数据,并转为float32类型的数组
img_data = https://www.it610.com/article/np.array([x[0] for x in data]).astype('float32')
# 获得图像标签数据,并转为float32类型的数组
label_data = https://www.it610.com/article/np.array([x[1] for x in data]).astype('float32')
# 打印数据形状
print("图像数据形状和对应数据为:", img_data.shape)
print("图像标签形状和对应数据为:", label_data.shape)
break# 定义预测过程
with fluid.dygraph.guard():
model = MNIST()
params_file_path = 'mnist'
# 加载模型参数
model_dict, _ = fluid.load_dygraph("mnist")
model.load_dict(model_dict)
# 灌入数据
model.eval()
result = model(fluid.dygraph.to_variable(img_data))
#预测输出取整,即为预测的数字,打印结果
print("本次预测的数字是", result.numpy().astype('int32'))print(label_data)
五、数据处理 在工业实践中,我们面临的任务和数据环境千差万别,通常需要自己编写适合当前任务的数据处理程序,一般涉及如下五个环节:
读入数据
划分数据集
生成批次数据
训练样本集乱序
校验数据有效性
1.前提条件
在数据读取与处理前,首先要加载飞桨平台和数据处理库,代码如下。
#数据处理部分之前的代码,加入部分数据处理的库
import paddle
import paddle.fluid as fluid
from paddle.fluid.dygraph.nn import Linear
import numpy as np
import os
import gzip
import json
import random
2.读入数据并划分数据集
在实际应用中,保存到本地的数据存储格式多种多样,如MNIST数据集以json格式存储在本地,其数据存储结构如 图所示。
文章图片
data包含三个元素的列表:train_set、val_set、 test_set。
train_set(训练集):包含50000条手写数字图片和对应的标签,用于确定模型参数。
val_set(验证集):包含10000条手写数字图片和对应的标签,用于调节模型超参数(如多个网络结构、正则化权重的最优选择)。
test_set(测试集):包含10000条手写数字图片和对应的标签,用于估计应用效果(没有在模型中应用过的数据,更贴近模型在真实场景应用的效果)。
train_set包含两个元素的列表:train_images、train_labels。
train_images:[5000, 784]的二维列表,包含5000张图片。每张图片用一个长度为784的向量表示,内容是28*28尺寸的像素灰度值(黑白图片)。
train_labels:[5000, ]的列表,表示这些图片对应的分类标签,即0-9之间的一个数字。
data包含三个元素的列表:train_set、val_set、 test_set。
train_set(训练集):包含50000条手写数字图片和对应的标签,用于确定模型参数。
val_set(验证集):包含10000条手写数字图片和对应的标签,用于调节模型超参数(如多个网络结构、正则化权重的最优选择)。
test_set(测试集):包含10000条手写数字图片和对应的标签,用于估计应用效果(没有在模型中应用过的数据,更贴近模型在真实场景应用的效果)。
train_set包含两个元素的列表:train_images、train_labels。
train_images:[5000, 784]的二维列表,包含5000张图片。每张图片用一个长度为784的向量表示,内容是28*28尺寸的像素灰度值(黑白图片)。
train_labels:[5000, ]的列表,表示这些图片对应的分类标签,即0-9之间的一个数字。
# 声明数据集文件位置
datafile = './work/mnist.json.gz'
print('loading mnist dataset from {} ......'.format(datafile))
# 加载json数据文件
data = https://www.it610.com/article/json.load(gzip.open(datafile))
print('mnist dataset load done')
# 读取到的数据区分训练集,验证集,测试集
train_set, val_set, eval_set = data# 数据集相关参数,图片高度IMG_ROWS, 图片宽度IMG_COLS
IMG_ROWS = 28
IMG_COLS = 28# 打印数据信息
imgs, labels = train_set[0], train_set[1]
print("训练数据集数量: ", len(imgs))# 观察验证集数量
imgs, labels = val_set[0], val_set[1]
print("验证数据集数量: ", len(imgs))# 观察测试集数量
imgs, labels = val= eval_set[0], eval_set[1]
print("测试数据集数量: ", len(imgs))
3.训练样本乱序、生成批次数据
(1)训练样本乱序: 先将样本按顺序进行编号,建立ID集合index_list。然后将index_list乱序,最后按乱序后的顺序读取数据。
说明:通过大量实验发现,模型对最后出现的数据印象更加深刻。训练数据导入后,越接近模型训练结束,最后几个批次数据对模型参数的影响越大。为了避免模型记忆影响训练效果,需要进行样本乱序操作。
(2)生成批次数据: 先设置合理的batch_size,再将数据转变成符合模型输入要求的np.array格式返回。同时,在返回数据时将Python生成器设置为yield模式,以减少内存占用。
在执行如上两个操作之前,需要先将数据处理代码封装成load_data函数,方便后续调用。load_data有三种模型:train、valid、eval,分为对应返回的数据是训练集、验证集、测试集。
imgs, labels = train_set[0], train_set[1]
print("训练数据集数量: ", len(imgs))
# 获得数据集长度
imgs_length = len(imgs)
# 定义数据集每个数据的序号,根据序号读取数据
index_list = list(range(imgs_length))
# 读入数据时用到的批次大小
BATCHSIZE = 100# 随机打乱训练数据的索引序号
random.shuffle(index_list)# 定义数据生成器,返回批次数据
def data_generator():imgs_list = []
labels_list = []
for i in index_list:
# 将数据处理成希望的格式,比如类型为float32,shape为[1, 28, 28]
img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
label = np.reshape(labels[i], [1]).astype('float32')
imgs_list.append(img)
labels_list.append(label)
if len(imgs_list) == BATCHSIZE:
# 获得一个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
# 声明数据读取函数,从训练集中读取数据
train_loader = data_generator
# 以迭代的形式读取数据
for batch_id, data in enumerate(train_loader()):
image_data, label_data = https://www.it610.com/article/data
if batch_id == 0:
# 打印数据shape和类型
print("打印第一个batch数据的维度:")
print("图像维度: {}, 标签维度: {}".format(image_data.shape, label_data.shape))
break
4.检验数据的有效性
在实际应用中,原始数据可能存在标注不准确、数据杂乱或格式不统一等情况。因此在完成数据处理流程后,还需要进行数据校验,一般有两种方式:
(1)机器校验:加入一些校验和清理数据的操作。
(2)人工校验:先打印数据输出结果,观察是否是设置的格式。再从训练的结果验证数据处理和读取的有效性。
(1)机器校验
如下代码所示,如果数据集中的图片数量和标签数量不等,说明数据逻辑存在问题,可使用assert语句校验图像数量和标签数据是否一致。
imgs_length = len(imgs)assert len(imgs) == len(labels), \
"length of train_imgs({}) should be the same as train_labels({})".format(len(imgs), len(label))
(2)人工校验
人工校验是指打印数据输出结果,观察是否是预期的格式。实现数据处理和加载函数后,我们可以调用它读取一次数据,观察数据的shape和类型是否与函数中设置的一致。
# 声明数据读取函数,从训练集中读取数据
train_loader = data_generator
# 以迭代的形式读取数据
for batch_id, data in enumerate(train_loader()):
image_data, label_data = https://www.it610.com/article/data
if batch_id == 0:
# 打印数据shape和类型
print("打印第一个batch数据的维度,以及数据的类型:")
print("图像维度: {}, 标签维度: {}, 图像数据类型: {}, 标签数据类型: {}".format(image_data.shape, label_data.shape, type(image_data), type(label_data)))
break
5.封装数据读取与处理函数
上文,我们从读取数据、划分数据集、到打乱训练数据、构建数据读取器以及数据数据校验,完成了一整套一般性的数据处理流程,下面将这些步骤放在一个函数中实现,方便在神经网络训练时直接调用。
def load_data(mode='train'):
datafile = './work/mnist.json.gz'
print('loading mnist dataset from {} ......'.format(datafile))
# 加载json数据文件
data = https://www.it610.com/article/json.load(gzip.open(datafile))
print('mnist dataset load done')# 读取到的数据区分训练集,验证集,测试集
train_set, val_set, eval_set = data
if mode=='train':
# 获得训练数据集
imgs, labels = train_set[0], train_set[1]
elif mode=='valid':
# 获得验证数据集
imgs, labels = val_set[0], val_set[1]
elif mode=='eval':
# 获得测试数据集
imgs, labels = eval_set[0], eval_set[1]
else:
raise Exception("mode can only be one of ['train', 'valid', 'eval']")
print("训练数据集数量: ", len(imgs))# 校验数据
imgs_length = len(imgs)assert len(imgs) == len(labels), \
"length of train_imgs({}) should be the same as train_labels({})".format(len(imgs), len(label))# 获得数据集长度
imgs_length = len(imgs)# 定义数据集每个数据的序号,根据序号读取数据
index_list = list(range(imgs_length))
# 读入数据时用到的批次大小
BATCHSIZE = 100# 定义数据生成器
def data_generator():
if mode == 'train':
# 训练模式下打乱数据
random.shuffle(index_list)
imgs_list = []
labels_list = []
for i in index_list:
# 将数据处理成希望的格式,比如类型为float32,shape为[1, 28, 28]
img = np.reshape(imgs[i], [1, IMG_ROWS, IMG_COLS]).astype('float32')
label = np.reshape(labels[i], [1]).astype('float32')
imgs_list.append(img)
labels_list.append(label)
if len(imgs_list) == BATCHSIZE:
# 获得一个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
下面定义一层神经网络,利用定义好的数据处理函数,完成神经网络的训练。
#数据处理部分之后的代码,数据读取的部分调用Load_data函数
# 定义网络结构,同上一节所使用的网络结构
class MNIST(fluid.dygraph.Layer):
def __init__(self):
super(MNIST, self).__init__()
self.fc = Linear(input_dim=784, output_dim=1, act=None)def forward(self, inputs):
inputs = fluid.layers.reshape(inputs, (-1, 784))
outputs = self.fc(inputs)
return outputs# 训练配置,并启动训练过程
with fluid.dygraph.guard():
model = MNIST()
model.train()
#调用加载数据的函数
train_loader = load_data('train')
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001, parameter_list=model.parameters())
EPOCH_NUM = 10
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(train_loader()):
#准备数据,变得更加简洁
image_data, label_data = https://www.it610.com/article/data
image = fluid.dygraph.to_variable(image_data)
label = fluid.dygraph.to_variable(label_data)#前向计算的过程
predict = model(image)#计算损失,取一个批次样本损失的平均值
loss = fluid.layers.square_error_cost(predict, label)
avg_loss = fluid.layers.mean(loss)#每训练了200批次的数据,打印下当前Loss的情况
if batch_id % 200 == 0:
print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))#后向传播,更新参数的过程
avg_loss.backward()
optimizer.minimize(avg_loss)
model.clear_gradients()#保存模型参数
fluid.save_dygraph(model.state_dict(), 'mnist')
6.异步数据读取
上面提到的数据读取采用的是同步数据读取方式。对于样本量较大、数据读取较慢的场景,建议采用异步数据读取方式。异步读取数据时,数据读取和模型训练并行执行,从而加快了数据读取速度,牺牲一小部分内存换取数据读取效率的提升,二者关系如 图所示。
文章图片
(1)同步数据读取:数据读取与模型训练串行。当模型需要数据时,才运行数据读取函数获得当前批次的数据。在读取数据期间,模型一直等待数据读取结束才进行训练,数据读取速度相对较慢。
(2)异步数据读取:数据读取和模型训练并行。读取到的数据不断的放入缓存区,无需等待模型训练就可以启动下一轮数据读取。当模型训练完一个批次后,不用等待数据读取过程,直接从缓存区获得下一批次数据进行训练,从而加快了数据读取速度。
(3)异步队列:数据读取和模型训练交互的仓库,二者均可以从仓库中读取数据,它的存在使得两者的工作节奏可以解耦。
使用飞桨实现异步数据读取非常简单,如下所示。
# 定义数据读取后存放的位置,CPU或者GPU,这里使用CPU
# place = fluid.CUDAPlace(0) 时,数据读取到GPU上
place = fluid.CPUPlace()
with fluid.dygraph.guard(place):
# 声明数据加载函数,使用训练模式
train_loader = load_data(mode='train')
# 定义DataLoader对象用于加载Python生成器产生的数据
data_loader = fluid.io.DataLoader.from_generator(capacity=5, return_list=True)
# 设置数据生成器
data_loader.set_batch_generator(train_loader, places=place)
# 迭代的读取数据并打印数据的形状
for i, data in enumerate(data_loader):
image_data, label_data = https://www.it610.com/article/data
print(i, image_data.shape, label_data.shape)
if i>=5:
break
异步数据读取并训练的完整案例代码如下所示。
with fluid.dygraph.guard():
model = MNIST()
model.train()
#调用加载数据的函数
train_loader = load_data('train')
# 创建异步数据读取器
place = fluid.CPUPlace()
data_loader = fluid.io.DataLoader.from_generator(capacity=5, return_list=True)
data_loader.set_batch_generator(train_loader, places=place)optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001, parameter_list=model.parameters())
EPOCH_NUM = 3
for epoch_id in range(EPOCH_NUM):
for batch_id, data in enumerate(data_loader):
image_data, label_data = https://www.it610.com/article/data
image = fluid.dygraph.to_variable(image_data)
label = fluid.dygraph.to_variable(label_data)predict = model(image)loss = fluid.layers.square_error_cost(predict, label)
avg_loss = fluid.layers.mean(loss)if batch_id % 200 == 0:
print("epoch: {}, batch: {}, loss is: {}".format(epoch_id, batch_id, avg_loss.numpy()))avg_loss.backward()
optimizer.minimize(avg_loss)
model.clear_gradients()fluid.save_dygraph(model.state_dict(), 'mnist')
注意,异步读取数据只在数据量规模巨大时会带来显著的性能提升,对于多数场景采用同步数据读取的方式已经足够。
下边六章内容放在下节继续。
六、网络结构 七、损失函数 八、优化函数 九、多GPU训练 十、恢复训练
推荐阅读
- 深度学习|DL在材料化学中(基于图像模型)的应用
- 深度学习|Tensorflow操作明细
- 计算机视觉|SPP Net 空间金字塔池化(Spatial Pyramid Pooling, SPP)原理
- 目标检测|空间金字塔池化(SPP)
- 基于深度学习的图像识别|#21天学习挑战赛—深度学习实战100例#——乳腺癌识别
- 深度学习各种积累|Yolov3/Yolov4原理对比改进创新
- 深度学习|faster rcnn 中的 region proposal函数(proposal_layer、anchor_target_layer、proposal_target_layer)
- 神经网络|深度学习入门笔记-第三章-神经网络
- 深度学习|循环神经网络(RNN)实现股票预测