这里只讲paddlepaddle框架的使用，不涉及深度学习的知识。这是笔者接触3天paddlepaddle后的作品，必有不完善之处，仅供参考，还望支持。借鉴了paddlepaddle官方文档后模仿其样式，完成了我的fluid版本的线性模型。
特点
- 自制数据集（简单的数据集制作方法）
- 数据喂养方法
- 训练过程作图
- 保存模型
- 调用模型预测
目标
拟合数学函数 y = k * x + b
第一步
制作数据集，既然要拟合函数y=kx+b自然要设计一个这样的一元一次方程。并采用numpy自带的生成随机数的办法，产生5000个这样的对应数据。以下是自制数据集的脚本，文件名mk_data.py。
#coding=utf-8
import numpy as np
size = 5000
k=3.2
b=4.3
train = 'train.txt'
test = 'test.txt'
with open(train,'w') as f: #采用with构造，如果没有train文件，会自动创建，且结束后关闭文件
for line in range (size):
x = np.random.randn()#生成随机数符合标准正态分布
y = k * x + b
f.write("%f\t%f\n" %(x,y))#写入文件
with open(test,'w') as f:
for line in range (size):
x = np.random.randn()
y = k * x + b
f.write("%f\t%f\n" %(x,y))
执行完文件之后，目录下会生成 train.txt 和 test.txt 两个文件。
由于常用的方法一致，所以只展示test.txt的示例，如下：
-0.120741 3.913630
2.027401 10.787683
-1.156099 0.600482
1.352947 8.629430
-0.124563 3.901399
-0.897575 1.427759
-0.379971 3.084093
-0.345199 3.195362
-0.271942 3.429785
0.824531 6.938499
-1.227654 0.371506
1.875533 10.301707数据集就制作完成了，不知大家看没看懂。可以加入qq群453134519，二维码在文章的最下面。
第二步
数据集制作成功后，就是如何喂入神经网络的问题了。paddlepaddle采用reader的方法，见链接。
def train_reader():
def reader():
with open(train,'r') as f:
lines = [line.strip() for line in f]
for line in lines:
x,y = line.strip().split('\t')
yield float(x),float(y)
return reader
def test_reader():
def reader():
with open(test,'r') as f:
lines = [line.strip() for line in f]
for line in lines:
x,y = line.strip().split('\t')
yield float(x),float(y)
return reader那么数据源就有了，接下来就是定义前向传播了。
第三步
定义数据使用（定义输入输出，前向传播过程）：
x = fluid.layers.data(name='x', shape=[13], dtype='float32') y = fluid.layers.data(name='y', shape=[1], dtype='float32')
#定义前向传播
def forward():
x = fluid.layers.data(name='x',shape=[1],dtype='float32')
#预测的y值（重点区分）
y_predict = fluid.layers.fc(input=x,size=1,act=None)
return y_predict你也可以在这边添加隐藏层，用以下的方法：
hidden = fluid.layers.fc(input=x, size=1, act=None)第四步
定义反向传播和计算损失函数的方法：
def train_program():
#喂入神经网络的y
y_label = fluid.layers.data(name='y_label',shape=[1],dtype='float32')
#使用前向传播
predict = forward()
#计算cost
cost = fluid.layers.square_error_cost(input=predict, label=y_label)
avg_cost = fluid.layers.mean(cost)
return avg_cost接下来定义优化方法，这里用还是用函数写，fluid貌似只接受这个方法。
#优化方法
def optimizer_program():
return fluid.optimizer.SGD(learning_rate=0.02)第五步
设置训练器（就是训练用什么方法，在哪训练，和优化哪些参数）
先上代码：
def main():
#训练数据
train_buff = paddle.batch(paddle.reader.shuffle(train_reader(),buf_size = 100),batch_size=20)
#测试数据
test_buff = paddle.batch(paddle.reader.shuffle(test_reader(),buf_size = 200),batch_size=10)
#是否使用显卡
use_cuda = False # set to True if training with GPU
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
#设置trainer（训练器）
trainer = fluid.Trainer(train_func=train_program, place=place, optimizer_func=optimizer_program)
lists = []
#打印训练事件（paddlepaddle采用event事件的方法，打印训练过程的参数）
def event_handler(event):
if isinstance(event, fluid.EndStepEvent):
if event.step % 10 == 0:
avg_cost= trainer.test(reader = test_buff,feed_order=['x', 'y_label'])
cost_ploter.append(train_title, event.step, event.metrics[0])
cost_ploter.append(test_title, event.step, avg_cost)
lists.append((event.step, event.epoch,event.metrics[0]))
#生成图像
cost_ploter.plot()
#打印数据
print lists
if isinstance(event, fluid.EndEpochEvent):
# 保存模型
trainer.save_params(params_dirname)
#训练模型
trainer.train(
num_epochs=1,
event_handler=event_handler,
reader=train_buff,
feed_order=['x', 'y_label'])
#使用模型预测
def inference_program():
x = fluid.layers.data(name='x', shape=[1], dtype='float32')
y_predict = fluid.layers.fc(input=x, size=1, act=None)
return y_predict
inferencer = fluid.Inferencer(
infer_func=forward,
param_path=params_dirname,
place=place)
batch_size = 10
tensor_x = np.random.uniform(0, 10, [batch_size, 1]).astype("float32")
results = inferencer.infer({'x': tensor_x})
print ("Data to be predicted: ",tensor_x)
print ("Prediction results: ", results[0])
if __name__ == '__main__':
main()
很简单吧！！
最后上整个代码one.py:
#coding=utf-8
import paddle
import paddle.fluid as fluid
import os
from paddle.v2.plot import Ploter
import numpy as np
train = '/home/liuxin/Desktop/one/train.txt'
test = '/home/liuxin/Desktop/one/test.txt'
train_title = "Train cost"
test_title = "Test cost"
cost_ploter = Ploter(train_title,test_title)
#设置模型名称
global params_dirname
params_dirname = "one.model"
def train_reader():
def reader():
with open(train,'r') as f:
lines = [line.strip() for line in f]
for line in lines:
x,y = line.strip().split('\t')
yield float(x),float(y)
return reader
def test_reader():
def reader():
with open(test,'r') as f:
lines = [line.strip() for line in f]
for line in lines:
x,y = line.strip().split('\t')
yield float(x),float(y)
return reader
#定义前向传播
def forward():
x = fluid.layers.data(name='x',shape=[1],dtype='float32')
y_predict = fluid.layers.fc(input=x,size=1,act=None)
return y_predict
def train_program():
y_label = fluid.layers.data(name='y_label',shape=[1],dtype='float32')
#使用前向传播
predict = forward()
#计算cost
cost = fluid.layers.square_error_cost(input=predict, label=y_label)
avg_cost = fluid.layers.mean(cost)
return avg_cost
#优化方法
def optimizer_program():
return fluid.optimizer.SGD(learning_rate=0.02)
def main():
#训练数据
train_buff = paddle.batch(paddle.reader.shuffle(train_reader(),buf_size = 100),batch_size=20)
#测试数据
test_buff = paddle.batch(paddle.reader.shuffle(test_reader(),buf_size = 200),batch_size=10)
#是否使用显卡
use_cuda = False # set to True if training with GPU
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
#设置trainer
trainer = fluid.Trainer(train_func=train_program, place=place, optimizer_func=optimizer_program)
lists = []
#打印训练事件
def event_handler(event):
if isinstance(event, fluid.EndStepEvent):
if event.step % 10 == 0:
avg_cost= trainer.test(reader = test_buff,feed_order=['x', 'y_label'])
cost_ploter.append(train_title, event.step, event.metrics[0])
cost_ploter.append(test_title, event.step, avg_cost)
lists.append((event.step, event.epoch,event.metrics[0]))
#生成图像
cost_ploter.plot()
#打印数据
print lists
if isinstance(event, fluid.EndEpochEvent):
# 保存模型
trainer.save_params(params_dirname)
#训练模型
trainer.train(
num_epochs=1,
event_handler=event_handler,
reader=train_buff,
feed_order=['x', 'y_label'])
def inference_program():
x = fluid.layers.data(name='x', shape=[1], dtype='float32')
y_predict = fluid.layers.fc(input=x, size=1, act=None)
return y_predict
inferencer = fluid.Inferencer(
infer_func=forward,
param_path=params_dirname,
place=place)
batch_size = 10
tensor_x = np.random.uniform(0, 10, [batch_size, 1]).astype("float32")
results = inferencer.infer({'x': tensor_x})
print ("Data to be predicted: ",tensor_x)
print ("Prediction results: ", results[0])
if __name__ == '__main__':
main()
训练最后的效果图：
最后的最后，我们联系一下吧，群号：453134519
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
