参考的项目是官方的一个入门项目：波士顿房价预测
首先点击上面网址，fork该项目。
输入项目名称和项目描述后，创建该项目。
然后就会来到这个页面。点击运行。
现在Baidu AI Studio，创建项目并运行，即赠送12小时GPU算力，非常给力。
选择高级版，确定。等待项目运行。
进入项目。就可以开始愉快地学习了。
其实原文档讲解得也很详细，但是有很多接口没有给出说明，我尽力帮助大家说明补充。
首先导入需要的包：
paddle.fluid——PaddlePaddle深度学习框架
numpy——python基本库，用于科学计算
os——python的模块，可使用该模块对操作系统进行操作
matplotlib——python绘图库，可方便绘制折线图、散点图等图形
import paddle.fluid as fluid
import paddle
import numpy as np
import os
import matplotlib.pyplot as plt
一、数据准备
uci-housing数据集介绍
数据集共506行,每行14列。前13列用来描述房屋的各种信息，最后一列为该类房屋价格中位数。
PaddlePaddle提供了读取uci_housing训练集和测试集的接口，分别为paddle.dataset.uci_housing.train()和paddle.dataset.uci_housing.test()。
train_reader和test_reader
paddle.reader.shuffle()表示每次缓存BUF_SIZE个数据项，并进行打乱。
shuffle()在官方的API文档的描述是这样的：
shuffle(reader,buffer_size)，这里reader是paddle.dataset.uci_housing.train()，这是调用paddle.dataset下的uci_housing.train()波士顿房价的训练集，OK，buf_size=BUF_SIZE，buf_size是指缓存的数据的大小。
通俗易通地来说就是，我先从波士顿房价的训练集取500个样本出来到缓存里面存着，缓存可以理解成一个可以即存即取的小房间，然后开始摇这个房间，把这个500个样本打乱顺序，接下来每次从房间里倒出batch_size=20个样本来训练。
BUF_SIZE=500
BATCH_SIZE=20
#用于训练的数据提供器，每次从缓存中随机读取批次大小的数据
train_reader = paddle.batch(paddle.reader.shuffle(paddle.dataset.uci_housing.train()
,buf_size=BUF_SIZE)
,batch_size=BATCH_SIZE)
paddle.batch()表示每BATCH_SIZE组成一个batch
batch对应的API如下，有两个参数(reader,batch_size)
同理可以理解如何处理test_reader
然后这段官方给的代码就很容易理解了。
BUF_SIZE=500
BATCH_SIZE=20
#用于训练的数据提供器，每次从缓存中随机读取批次大小的数据
train_reader = paddle.batch(
paddle.reader.shuffle(paddle.dataset.uci_housing.train(),
buf_size=BUF_SIZE),
batch_size=BATCH_SIZE)
#用于测试的数据提供器，每次从缓存中随机读取批次大小的数据
test_reader = paddle.batch(
paddle.reader.shuffle(paddle.dataset.uci_housing.test(),
buf_size=BUF_SIZE),
batch_size=BATCH_SIZE)
打印看下数据是什么样的？
PaddlePaddle接口提供的数据已经经过归一化等处理
(array([-0.02964322, -0.11363636, 0.39417967, -0.06916996, 0.14260276, -0.10109875, 0.30715859, -0.13176829, -0.24127857, 0.05489093, 0.29196451, -0.2368098 , 0.12850267]), array([15.6]))
#用于打印，查看uci_housing数据
train_data=paddle.dataset.uci_housing.train();
sampledata=next(train_data())
print(sampledata)
(array([-0.0405441 , 0.06636364, -0.32356227, -0.06916996, -0.03435197,
0.05563625, -0.03475696, 0.02682186, -0.37171335, -0.21419304,
-0.33569506, 0.10143217, -0.21172912]), array([24.]))
这里注解一下next()这个函数：
举这个实例最为方便理解，next()返回可迭代对象的下一个元素，所以next(train_data())，直接输出第一个train_data()中的元素，查看一下样本的格式。
二、网络配置
如果你了解线性回归和神经网络中的全连接层（FC），那么你一定明白多元线性回归和在不设置激活函数的情况下n个神经元与1个神经元的全连接层是一样的。
本文不详细讲理论部分，主要讲解paddlepaddle的代码，有兴趣的朋友们可以去原文仔细阅读。
附上原文档中的一张图补充说明：
#定义张量变量x，表示13维的特征值
x = fluid.layers.data(name='x', shape=[13], dtype='float32')
#定义张量y,表示目标值
y = fluid.layers.data(name='y', shape=[1], dtype='float32')
#定义一个简单的线性网络,连接输入和输出的全连接层
#input:输入tensor;
#size:该层输出单元的数目
#act:激活函数
y_predict=fluid.layers.fc(input=x,size=1,act=None)
和大部分的深度学习框架一样，对数据的输入有很多格式上的要求。
#定义张量变量x，表示13维的特征值
x = fluid.layers.data(name='x', shape=[13], dtype='float32')
#定义张量y,表示目标值
y = fluid.layers.data(name='y', shape=[1], dtype='float32')
上面则是给出输入数据的名字，大小，数据类型。
fluid.layers.data()官方给出API如下：
#定义一个简单的线性网络,连接输入和输出的全连接层
#input:输入tensor;
#size:该层输出单元的数目
#act:激活函数
y_predict=fluid.layers.fc(input=x,size=1,act=None)
简单地说，就是输入设置一个神经元，不要任何的激活函数，输入是x，输出是一个值。
关于fluid.layers.fc()的API比较长，大家可以在这里看到fluid.layers.fc()的API
定义损失函数
和其它框架一样，我们也需要定义损失函数。
此处使用均方误差损失函数，也就是我们常说的MSE。
square_error_cost(input,lable):接受输入预测值和目标值，并返回方差估计,即为（y-y_predict）的平方。
cost = fluid.layers.square_error_cost(input=y_predict, label=y)
#求一个batch的损失值
avg_cost = fluid.layers.mean(cost)
#对损失值求平均值
定义优化函数
和其它深度学习的框架一样，需要定义求解最优值的方式。
此处使用的是随机梯度下降SGD，此外还有带动量的SGD，adam等等。
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001)
opts = optimizer.minimize(avg_cost)
我们可以看到minimize这一步初始化了startup_program。
简单了解一下startup_program：
然后下一步是这句代码：
test_program = fluid.default_main_program().clone(for_test=True)
我们先来看下default_main_program()的API，了解它的作用：
此函数用于获取默认或全局main program(主程序)，该主程序用于训练和测试模型。
关于clone()函数的说明如下：
简单理解就是clone是克隆的意思，也就是我们要复制一份一摸一样的program，里面的参数for_test，如果是clone(for_test = True)则意思和字面一样，复制一份主程序用于测试集，不会像训练集一样跟着训练（这里是我个人的理解，不知道是否正确）
在上述模型配置完毕后，得到两个fluid.Program：fluid.default_startup_program() 与fluid.default_main_program() 配置完毕了。
参数初始化操作会被写入fluid.default_startup_program()
fluid.default_main_program()用于获取默认或全局main program(主程序)。该主程序用于训练和测试模型。fluid.layers 中的所有layer函数可以向 default_main_program 中添加算子和变量。default_main_program 是fluid的许多编程接口（API）的Program参数的缺省值。例如,当用户program没有传入的时候， Executor.run() 会默认执行 default_main_program 。
模型训练
创建Executor
首先定义运算场所 fluid.CPUPlace()和 fluid.CUDAPlace(0)分别表示运算场所为CPU和GPU
Executor:接收传入的program，通过run()方法运行program。
use_cuda = False
#use_cuda为False,表示运算场所为CPU;use_cuda为True,表示运算场所为GPU
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
我们先学习一下Executor的API
首先它需要输入的参数只有place，而CUDAplace()的作用是：
()里面代表GPU的卡数，所以CUDAplace(0)代表不使用GPU，CUDAplace(n)则代表使用n张GPU
第二点：
exe = fluid.Executor(place)
#创建一个Executor实例exe
exe.run(fluid.default_startup_program())
#Executor的run()方法执行startup_program(),进行参数初始化
上面两个语句说明，Executor()首先要实例化，然后用run()方法来执行startup_program(),进行参数初始化。
我们可以看看run()下的API：
run()方法的作用是执行program
Executor则是可以接收传入的program,并根据feed map(输入映射表)和fetch_list(结果获取表) 向program中添加feed operators(数据输入算子)和fetch operators（结果获取算子)。
feed map为该program提供输入数据。fetch_list提供program训练结束后用户预期的变量（或识别类场景中的命名）。
从这里我们就能看出接下来就是要定义上面说的feed map和fetch_list。
定义输入数据维度
DataFeeder负责将数据提供器（train_reader,test_reader）返回的数据转成一种特殊的数据结构，使其可以输入到Executor中。这里我的理解应该就是我上面说的feed map。
feed_list设置向模型输入的向变量表或者变量表名。
# 定义输入数据维度
feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
#feed_list:向模型输入的变量表或变量表名
定义绘制训练过程的损失值变化趋势的方法
定义这个draw_train_process()函数。
iter=0;
iters=[]
train_costs=[]
def draw_train_process(iters,train_costs):
title="training cost"
plt.title(title, fontsize=24)
plt.xlabel("iter", fontsize=14)
plt.ylabel("cost", fontsize=14)
plt.plot(iters, train_costs,color='red',label='training cost')
plt.grid()
plt.show()
实际上这段代码还是挺好理解的，iters从后面训练的代码来看就是第几个batch，这里输出的是每一个batch和这个batch对应的损失函数的值。
正常的话，这个图画出来就是逐步下降的一个图。
训练并保存模型
Executor接收传入的program,并根据feed_list(输入映射表)和fetch_list(结果获取表) 向program中添加feed operators(数据输入算子)和fetch operators（结果获取算子)。 feed_list为该program提供输入数据。fetch_list提供program训练结束后用户预期的变量。
上面这段话，在讲解Executor的API时已经重复了两次了，大家再次细细阅读加深印象。
注：enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标。
EPOCH_NUM=50
#一共跑50个epoch
model_save_dir = "/home/aistudio/work/fit_a_line.inference.model"
#把模型存在这个路径下面
for pass_id in range(EPOCH_NUM):
#训练EPOCH_NUM轮
# 开始训练并输出最后一个batch的损失值
train_cost = 0
for batch_id, data in enumerate(train_reader()):
#遍历train_reader迭代器
train_cost = exe.run(program=fluid.default_main_program()
#运行主程序
,feed=feeder.feed(data)
'''
喂入一个batch的训练数据，
根据feed_list和data提供的信息，
将输入数据转成一种特殊的数据结构。
我这里理解是把data转化成feed_list要求
的那种形式。
'''
,fetch_list=[avg_cost])
if batch_id % 40 == 0:
print("Pass:%d, Cost:%0.5f" % (pass_id, train_cost[0][0]))
'''
打印最后一个batch的损失值（官方）
我感觉是不对的，前面的代码写的是
BUF_SIZE=500
BATCH_SIZE=20
所以这个代码应该改成
if batch_id % 20 == 0:
'''
iter=iter+BATCH_SIZE
iters.append(iter)
train_costs.append(train_cost[0][0])
# 开始测试并输出最后一个batch的损失值
test_cost = 0
for batch_id, data in enumerate(test_reader()):
#遍历test_reader迭代器
test_cost= exe.run(program=test_program
#运行测试cheng
,feed=feeder.feed(data)
#喂入一个batch的测试数据
,fetch_list=[avg_cost])
#fetch均方误差
print('Test:%d, Cost:%0.5f' % (pass_id, test_cost[0][0]))
#打印最后一个batch的损失值
#保存模型
# 如果保存路径不存在就创建
if not os.path.exists(model_save_dir):
os.makedirs(model_save_dir)
print ('save models to %s' % (model_save_dir))
#保存训练参数到指定路径中，构建一个专门用预测的program
fluid.io.save_inference_model(model_save_dir
#保存推理model的路径
,['x']
#推理（inference）需要 feed 的数据
,[y_predict]
#保存推理（inference）结果的 Variables
,exe
#exe 保存 inference model
)
draw_train_process(iters,train_costs)
这里有一点需要解释的是，batch_size = 20，其实一个batch是抽了21个数据的，因为如果你print(“batch_id=%d”%batch_id)的话，你会发现一个enumerate内batch_id是从0-20，所以一共是21个样本。
然后呢，我们epoch是50个，其实说白了就是跑了50个batch，每个batch_size是21，一共跑了50*21=1050个数据。
之前写的那个画图的函数就这个效果：
模型预测
创建预测用的Executor
infer_exe = fluid.Executor(place) #创建推测用的executor
inference_scope = fluid.core.Scope() #Scope指定作用域
可视化真实值与预测值方法定义
infer_results=[]
groud_truths=[]
#绘制真实值和预测值对比图
def draw_infer_result(groud_truths,infer_results):
title='Boston'
plt.title(title, fontsize=24)
x = np.arange(1,20)
y = x
plt.plot(x, y)
plt.xlabel('ground truth', fontsize=14)
plt.ylabel('infer result', fontsize=14)
plt.scatter(groud_truths, infer_results,color='green',label='training cost')
plt.grid()
plt.show()
开始预测
通过fluid.io.load_inference_model，预测器会从params_dirname中读取已经训练好的模型，来对从未遇见过的数据进行预测。
with fluid.scope_guard(inference_scope):
#修改全局/默认作用域（scope）, 运行时中的所有变量都将分配给新的scope。
#从指定目录中加载 推理model(inference model)
[inference_program,
#推理的program
feed_target_names,
#需要在推理program中提供数据的变量名称
fetch_targets] = fluid.io.load_inference_model(
#fetch_targets: 推断结果
model_save_dir,
#model_save_dir:模型训练路径
infer_exe)
#infer_exe: 预测用executor
#获取预测数据
infer_reader = paddle.batch(paddle.dataset.uci_housing.test(),
#获取uci_housing的测试数据
batch_size=200)
#从测试数据中读取一个大小为200的batch数据
#从test_reader中分割x
test_data = next(infer_reader())
test_x = np.array([data[0] for data in test_data]).astype("float32")
test_y= np.array([data[1] for data in test_data]).astype("float32")
results = infer_exe.run(inference_program,
#预测模型
feed={feed_target_names[0]:np.array(test_x)},
#喂入要预测的x值
fetch_list=fetch_targets)
#得到推测结果
print("infer results: (House Price)")
for idx, val in enumerate(results[0]):
print("%d: %.2f" % (idx, val))
infer_results.append(val)
print("ground truth:")
for idx, val in enumerate(test_y):
print("%d: %.2f" % (idx, val))
groud_truths.append(val)
draw_infer_result(groud_truths,infer_results)
画出来的图是这样的
扫一扫
467
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
