【PaddlePaddle】模型的保存与使用
目录
- 前言
- 模型搭建
- 加载已经存在的模型并进行训练
- 参数模型：fluid.io.load_params()
- 持久化变量模型：fluid.io.load_persistables()
- 保存模型
- 保存预测模型
- 保存参数模型
- 保存持久化变量模型
- 全部代码
- 以上代码效果
- 预测
前言
在之前PaddleFluid的实例分析中，一直是训练过后，进行预测就结束了，没有进行模型的保存。这篇文章就讲解了如何在训练过程中保存模型，用于之后进行预测或者继续训练模型。本章会介绍三种保存模型的方法。一种方法是保存预测模型，是以后用来进行预测的模型；另外两种方法用来保存初始化模型，用来初始化模型继续训练。
接下就在代码中看看他们怎么用吧！我们将使用残差神经网络对经典的cifar数据集做一个10分类的工作（cifar数据集有100分类、10分类两个选择，我们这个网络使用的是cifar的10分类）。
模型搭建
导入相关的模块
#coding:utf-8
'''
created on February 19 15:06 2019
@author:lhy
'''
import os
import shutil
import paddle
import paddle.dataset.cifar as cifar
import paddle.fluid as fluid
定义一个残差神经网络，这是目前比较常用的网络，它可以通过增加网络深度达到提高识别率。不像传统的神经网络，对于传统的神经网络，当网络深度加深时，会出现损失精度（比如梯度消失等问题）。
#定义一个残差神经网络(ResNet)
def resnet_cifar(ipt,class_dim):
#定义一个卷积+批标准化层
def conv_bn_layer(input,ch_out,filter_size,stride,padding,act='relu',bias_attr=False):
tmp=fluid.layers.conv2d(input=input,filter_size=filter_size,num_filters=ch_out,stride=stride,padding=padding,bias_attr=bias_attr)
return fluid.layers.batch_norm(input=tmp,act=act)
def shortcut(input,ch_in,ch_out,stride):
if ch_in!=ch_out:
return conv_bn_layer(input,ch_out,1,stride,0,None)
else:
return input
#残差块
def basicblock(input,ch_in,ch_out,stride):
temp=conv_bn_layer(input,ch_out,3,stride,1)
temp=conv_bn_layer(temp,ch_out,3,1,1,act=None,bias_attr=True)
#如果输入层和输出层的大小不一样，就经过一个conv_bn，将输入层的大小变得和输出层一样
short=shortcut(input,ch_in,ch_out,stride)
#将两次卷积批标准化的结果和输入层相加，达到学习残差的目的
return fluid.layers.elementwise_add(x=temp,y=short,act='relu')
def layer_warp(block_func,input,ch_in,ch_out,count,stride):
temp=block_func(input,ch_in,ch_out,stride)
for i in range(1,count):
temp=block_func(temp,ch_out,ch_out,1)
return temp
conv1=conv_bn_layer(ipt,ch_out=16,filter_size=3,stride=1,padding=1)
res1=layer_warp(basicblock,conv1,16,16,5,1)
res2=layer_warp(basicblock,res1,16,32,5,2)
res3=layer_warp(basicblock,res2,32,64,5,2)
pool=fluid.layers.pool2d(input=res3,pool_size=8,pool_type='avg',pool_stride=1)
predict=fluid.layers.fc(input=pool,size=class_dim,act='softmax')
return predict
定义数据层，使用的是cifar数据集，这个数据集的图片是宽高都是32的3通道彩色图片，所以定义的输入层的shape是[3,32,32]。
#使用的数据集是cifar数据集，这个数据集是32*32的图片，3通道，则输入层shape应该是[3,32,32]
image=fluid.layers.data(name='image',shape=[3,32,32],dtype='float32')
#label是每张图片对应的0-9的分类数字，是int类型的，所以shape=[1]
label=fluid.layers.data(name='label',shape=[1],dtype='int64')
获取残差神经网络的分类器，制定分类的大小为10分类，因为这个数据集有10个类别。
#获取残差神经网络的分类器
model=resnet_cifar(image,10)
定义交叉熵损失函数和平均准确率。其中交叉熵损失函数和计算准确率会选取输出model的10分类中最大的那个值的下标和label做对比。详情可以看PaddlePaddle官方的1.1版本的api：PaddlePaddle Fluid-1.1-api
#损失函数和准确率
cost=fluid.layers.cross_entropy(input=model,label=label)
avg_cost=fluid.layers.mean(cost)
acc=fluid.layers.accuracy(input=model,label=label)
克隆出测试程序，用于以后测试使用。
test_program=fluid.default_main_program().clone(for_test=True)
定义优化方法(又是我最喜欢的Adam优化器，速度比梯度下降快)
#定义优化方法
optimizer=fluid.optimizer.AdamOptimizer(learning_rate=1e-3)
opts=optimizer.minimize(avg_cost)
获取训练和测试数据，在这里使用的是cifar数据集，cifar数据集有两种，一种是100类别的，一种是10类别的，在这里我们使用10类别的。因为这个数据集很大，所以下载cifar数据集所需要的时间会比较长。
#获取cifar数据集
train_reader=paddle.batch(cifar.train10(),batch_size=32)
test_reader=paddle.batch(cifar.test10(),batch_size=32)
创建执行器，头铁，还用CPU进行训练（实际上就是我的虚拟机没有CUDA）。并进行参数初始化。
#创建执行器,虚拟机不配用CUDA（实际上是我没得CUDA用
place=fluid.CPUPlace()
exe=fluid.Executor(place)
#参数初始化
exe.run(fluid.default_startup_program())
加载已经存在的模型并进行训练
创建执行器之后就可以用我们之前提到过的两种加载模型的方式，他们两个对应着两种方式保存模型，这两种方法随便用一种即可。而且这两种方式是用来初始化模型继续训练的的，而不是使用进行预测的那个模型。
参数模型：fluid.io.load_params()
fluid.io.load_params()是加载之前训练保存的参数模型，对应的保存接口是fluid.io.save_params()。当使用这个模型参数恢复网络参数时，可以这样写：
#加载之前的params_model模型，没有模型就不加载
save_path='models/params_model'
if os.path.exists(save_path):
print("使用参数模型作为预训练模型")
fluid.io.load_params(executor=exe,dirname=save_path)
持久化变量模型：fluid.io.load_persistables()
fluid.io.load_persistables()施加在之前训练保存的持久化变量模型，对应的保存接口是fluid.io.save_persistables()。当使用这个模型参数恢复网络时，可以这样写：
#加载之前的persistables_model模型，没有模型就不加载
save_path='models/persistables_model/'
if os.path.exists(save_path):
print("使用持久化变量模型作为预训练模型")
fluid.io.load_persistables(executor=exe,dirname=save_path)
以上二者都是保存的是初始化模型，所以在选择的时候，这两者可以随意选择，我比较喜欢前者，所以在最终的全部代码中，我会使用参数模型来保存模型参数。
而对于预测模型的存储和使用，文章后面就会提到。
开始训练模型：
#开始训练
for pass_id in range(10):
for batch_id ,data in enumerate(train_reader()):
train_cost,train_acc=exe.run(program=fluid.default_main_program(),feed=feeder.feed(data),fetch_list=[avg_cost,acc])
#100batch打印一次
if batch_id%100==0:
print("Pass:%d,Batch:%d,Cost:%0.5f,Accuracy:%0.5f"%(pass_id,batch_id,train_cost[0],train_acc[0]))
#测试
test_accs=[]
test_costs=[]
for batch_id,data in enumerate(test_reader()):
test_cost,test_acc=exe.run(program=test_program,feed=feeder.feed(data),fetch_list=[avg_cost,acc])
test_accs.append(test_acc[0])
test_costs.append(test_cost[0])
#求测试平均值
test_cost=(sum(test_costs)/len(test_costs))
test_acc=(sum(test_accs)/len(test_accs))
print('Test:%d,Cost:%0.5f,Accuracy:%0.5f'%(pass_id,test_cost,test_acc))
保存模型
在训练过程中就可以保存模型，这里介绍全部三种模型的保存,一般使用fluid.io.save_inference_model()函数保存的模型之后用于预测，是预测模型。使用fluid.io.save_params()或者fluid.io.save_persistables()函数保存的模型用于初始化模型，进行训练。
保存预测模型
fluid.io.save_inference_model()函数一般用来保存预测模型，用于以后预测图像。通过这个方式保存的模型，之后看来使用是非常方便的，具体怎样使用可以阅读下面的预测部分。使用方法如下：
#保存预测模型，方便以后预测
save_path='models/infer_model/'
#删除旧的模型文件
shutil.rmtree(save_path,ignore_errors=True)
#创建预测模型文件目录
os.makedirs(save_path)
#保存预测模型,值得注意的是，这个需要把输入层的name记录下来以便以后使用输入层的name进行feed
#想要预测的内容也要存入模型，以便以后使用fetch_list进行预测
fluid.io.save_inference_model(save_path,feeded_var_names=[image.name],target_vars=[model],executor=exe)
保存参数模型
保存参数模型，以便以后初始化模型，继续训练。
#保存参数模型
save_path='model/params_model/'
#删除旧的模型文件
shutil.rmtree(save_path,ignore_errors=True)
#创建保持模型文件目录
os.makedirs(save_path)
#保存模型参数
fluid.io.save_params(executor=exe,dirname=save_path)
保存持久化变量模型
保存持久化变量模型，便于以后初始化模型，继续训练。
# 保存持久化变量模型
save_path = 'models/persistables_model/'
# 删除旧的模型文件
shutil.rmtree(save_path, ignore_errors=True)
# 创建保持模型文件目录
os.makedirs(save_path)
# 保存持久化变量模型
fluid.io.save_persistables(executor=exe, dirname=save_path)
全部代码
#coding:utf-8
'''
created on February 19 15:06 2019
@author:lhy
'''
#使用fluid.io.save_params保存模型
import os
import shutil
import paddle
import paddle.dataset.cifar as cifar
import paddle.fluid as fluid
#定义一个残差神经网络(ResNet)
def resnet_cifar(ipt,class_dim):
#定义一个卷积+批标准化层
def conv_bn_layer(input,ch_out,filter_size,stride,padding,act='relu',bias_attr=False):
tmp=fluid.layers.conv2d(input=input,filter_size=filter_size,num_filters=ch_out,stride=stride,padding=padding,bias_attr=bias_attr)
return fluid.layers.batch_norm(input=tmp,act=act)
def shortcut(input,ch_in,ch_out,stride):
if ch_in!=ch_out:
return conv_bn_layer(input,ch_out,1,stride,0,None)
else:
return input
#残差块
def basicblock(input,ch_in,ch_out,stride):
temp=conv_bn_layer(input,ch_out,3,stride,1)
temp=conv_bn_layer(temp,ch_out,3,1,1,act=None,bias_attr=True)
short=shortcut(input,ch_in,ch_out,stride)
return fluid.layers.elementwise_add(x=temp,y=short,act='relu')
def layer_warp(block_func,input,ch_in,ch_out,count,stride):
temp=block_func(input,ch_in,ch_out,stride)
for i in range(1,count):
temp=block_func(temp,ch_out,ch_out,1)
return temp
conv1=conv_bn_layer(ipt,ch_out=16,filter_size=3,stride=1,padding=1)
res1=layer_warp(basicblock,conv1,16,16,5,1)
res2=layer_warp(basicblock,res1,16,32,5,2)
res3=layer_warp(basicblock,res2,32,64,5,2)
pool=fluid.layers.pool2d(input=res3,pool_size=8,pool_type='avg',pool_stride=1)
predict=fluid.layers.fc(input=pool,size=class_dim,act='softmax')
return predict
#使用的数据集是cifar数据集，这个数据集是32*32的图片，3通道，则输入层shape应该是[3,32,32]
image=fluid.layers.data(name='image',shape=[3,32,32],dtype='float32')
label=fluid.layers.data(name='label',shape=[1],dtype='int64')
print(label.shape)
#获取残差神经网络的分类器，指定是10分类，这个数据集有10个类别
model=resnet_cifar(image,10)
print(model.shape)
#损失函数和准确率
cost=fluid.layers.cross_entropy(input=model,label=label)
avg_cost=fluid.layers.mean(cost)
acc=fluid.layers.accuracy(input=model,label=label)
#克隆测试程序
test_program=fluid.default_main_program().clone(for_test=True)
#定义优化方法
optimizer=fluid.optimizer.AdamOptimizer(learning_rate=1e-3)
opts=optimizer.minimize(avg_cost)
#获取cifar数据集，cifar数据集有两种，一种是100类别，一种是10类别，这里使用10类别,一组取出32组
train_reader=paddle.batch(cifar.train10(),batch_size=32)
test_reader=paddle.batch(cifar.test10(),batch_size=32)
#创建执行器,虚拟机不配用CUDA（实际上是我没得CUDA用
place=fluid.CPUPlace()
exe=fluid.Executor(place)
#参数初始化
exe.run(fluid.default_startup_program())
#加载之前的params_model模型，没有模型就不加载
save_path='models/params_model'
if os.path.exists(save_path):
print("使用参数模型作为预训练模型")
fluid.io.load_params(executor=exe,dirname=save_path)
#定义输入数据维度
feeder=fluid.DataFeeder(place=place,feed_list=[image,label])
#开始训练
for pass_id in range(10):
for batch_id ,data in enumerate(train_reader()):
train_cost,train_acc=exe.run(program=fluid.default_main_program(),feed=feeder.feed(data),fetch_list=[avg_cost,acc])
#100batch打印一次
if batch_id%100==0:
print("Pass:%d,Batch:%d,Cost:%0.5f,Accuracy:%0.5f"%(pass_id,batch_id,train_cost[0],train_acc[0]))
#测试
test_accs=[]
test_costs=[]
for batch_id,data in enumerate(test_reader()):
test_cost,test_acc=exe.run(program=test_program,feed=feeder.feed(data),fetch_list=[avg_cost,acc])
test_accs.append(test_acc[0])
test_costs.append(test_cost[0])
#求测试平均值
test_cost=(sum(test_costs)/len(test_costs))
test_acc=(sum(test_accs)/len(test_accs))
print('Test:%d,Cost:%0.5f,Accuracy:%0.5f'%(pass_id,test_cost,test_acc))
#保存模型,一般使用fluid.io.save_inference_model()函数保存的模型之后用于预测，是预测模型。
#使用fluid.io.save_params()或者fluid.io.save_persistables()函数保存的模型用于初始化模型，进行训练。
#保存预测模型，方便以后预测
save_path='models/infer_model/'
#删除旧的模型文件
shutil.rmtree(save_path,ignore_errors=True)
#创建预测模型文件目录
os.makedirs(save_path)
#保存预测模型
fluid.io.save_inference_model(save_path,feeded_var_names=[image.name],target_vars=[model],executor=exe)
#保存参数模型
save_path='models/params_model/'
#删除旧的模型文件
shutil.rmtree(save_path,ignore_errors=True)
#创建保持模型文件目录
os.makedirs(save_path)
#保存模型参数
fluid.io.save_params(executor=exe,dirname=save_path)
以上代码效果
由于一共有10个pass，每个pass又有1500+的batch，输出信息太多，所以这里只展示最后一个Pass的输出：
Pass:9,Batch:0,Cost:0.23369,Accuracy:0.87500
Pass:9,Batch:100,Cost:0.13673,Accuracy:0.93750
Pass:9,Batch:200,Cost:0.14569,Accuracy:0.96875
Pass:9,Batch:300,Cost:0.11853,Accuracy:1.00000
Pass:9,Batch:400,Cost:0.10782,Accuracy:1.00000
Pass:9,Batch:500,Cost:0.10297,Accuracy:0.93750
Pass:9,Batch:600,Cost:0.09028,Accuracy:0.96875
Pass:9,Batch:700,Cost:0.13088,Accuracy:0.93750
Pass:9,Batch:800,Cost:0.46306,Accuracy:0.90625
Pass:9,Batch:900,Cost:0.15785,Accuracy:0.93750
Pass:9,Batch:1000,Cost:0.11927,Accuracy:0.93750
Pass:9,Batch:1100,Cost:0.12313,Accuracy:0.93750
Pass:9,Batch:1200,Cost:0.32262,Accuracy:0.84375
Pass:9,Batch:1300,Cost:0.20035,Accuracy:0.93750
Pass:9,Batch:1400,Cost:0.06530,Accuracy:1.00000
Pass:9,Batch:1500,Cost:0.23624,Accuracy:0.93750
Test:9,Cost:0.83426,Accuracy:0.78235
从测试集测试结果来看。。。有点过拟合了。。。
模型保存在models文件夹下，如下图所示：
模型中是这样存储参数的：
网络越复杂，参数越多，生成的模型文件越多。
预测
在训练的时候，我们使用fluid.io.save_inference_model接口保存了预测模型，通过以下程序，我们知道用这个接口保存的模型使用起来有多简单，其中很大一个改变就是不需要前向传播获得分类器了。
导入相关模块：
import paddle.fluid as fluid
from PIL import Image
import numpy as np
创建执行器：
#创建执行器
place=fluid.CPUPlace()
exe=fluid.Executor(place)
exe.run(fluid.default_startup_program())
重点：加载模型，通过fluid.io.load_inference_model()函数可以轻松获得这个模型存储的预测程序，输入参数的名称，以及分类器的输出。
save_path='models/infer_model/'
#从模型中得到预测程序，输入数据名称列表和分类器
[infer_program,feeded_var_names,target_var]=fluid.io.load_inference_model(dirname=save_path,executor=exe)
预处理图像,将图片统一大小，修改图像的存储顺序和通道顺序，并转化成一个numpy数组：
#定义一个图像预处理的函数
def load_image(file):
im=Image.open(file)
im=im.resize((32,32),Image.ANTIALIAS)
im=np.array(im).astype(np.float32)
#PIL打开图片存储顺序为H（高度），W（宽度），C（通道数）
#但是PaddlePaddle要求数据的顺序是CHW，需要调整顺序
im=im.transpose((2,0,1))
#cifar训练的图片通道顺序为B(蓝)，G(绿)，R(红)
#但是PIL打开的图片是默认的RGB，所以要交换通道
im=im[(2,1,0),:,:]
im=im/255.0#归一化
im=np.expand_dims(im,axis=0)
return im
获取数据并进行预测，不需要再输入一个模拟的标签了，因为在保存模型的时候，已经对标签进行了修剪，去掉了这部分不必要的输入。
输入一张猫的图片：
#获取图片数据
img=load_image('cat.jpeg')
#执行预测
result=exe.run(program=infer_program,feed={feed_var_names[0]:img},fetch_list=target_var)
执行预测程序之后，获得一个10分类的数组，表示每种分类的概率，我们获得最大值的下标来确定该类的名称：
#获得值最大的元素对应的下标
lab=np.argmax(result[0][0])
names=['飞机','汽车','鸟','猫','鹿','狗','青蛙','马','船','卡车']
print("预测的标签是：%d,名称是：%s,概率是：%f"%(lab,names[lab],result[0][0][lab]))
输出结果：
预测的标签是：3,名称是：猫,概率是：0.951282
可以看到模型很成功的识别出了猫。
代码参考：夜雨飘零1—PaddlePaddle系列课程
非常感谢这位大佬！！！