PaddlePaddle基本用法详解（一）、PaddelPaddle进行波士顿房价预测
# helloworld示例
import paddle.fluid as fluid
# 创建两个类型为int64, 形状为1*1张量
x = fluid.layers.fill_constant(shape=[1], dtype="int64", value=5)
y = fluid.layers.fill_constant(shape=[1], dtype="int64", value=1)
z = x + y # z只是一个对象,没有run,所以没有值
# 创建执行器
place = fluid.CPUPlace() # 指定在CPU上执行
exe = fluid.Executor(place) # 创建执行器
result = exe.run(fluid.default_main_program(),
fetch_list=[z]) #返回哪个结果 执行默认的fluid.default_main_program()
print(result) # result为多维张量
import paddle.fluid as fluid
import numpy
# 创建x, y两个2行3列，类型为float32的变量(张量)
x = fluid.layers.data(name="x", shape=[2, 3], dtype="float32")
y = fluid.layers.data(name="y", shape=[2, 3], dtype="float32")
x_add_y = fluid.layers.elementwise_add(x, y) # 两个张量按元素相加
x_mul_y = fluid.layers.elementwise_mul(x, y) # 两个张量按元素相乘
place = fluid.CPUPlace() # 指定在CPU上执行
exe = fluid.Executor(place) # 创建执行器
exe.run(fluid.default_startup_program()) # 初始化网络
a = numpy.array([[1, 2, 3],
[4, 5, 6]]) # 输入x, 并转换为数组
b = numpy.array([[1, 1, 1],
[2, 2, 2]]) # 输入y, 并转换为数组
params = {"x": a, "y": b}
outs = exe.run(fluid.default_main_program(), # 默认程序上执行
feed=params, # 喂入参数
fetch_list=[x_add_y, x_mul_y]) # 获取结果
for i in outs:
print(i)
# 简单线性回归
import paddle
import paddle.fluid as fluid
import numpy as np
import matplotlib.pyplot as plt
# 制作数据集
train_data = np.array([[0.5], [0.6], [0.8], [1.1], [1.4]]).astype("float32")
y_true = np.array([[5.0], [5.5], [6.0], [6.8], [6.8]]).astype("float32")
# 定义数据类型变量
x = fluid.layers.data(name="x", shape=[1], dtype="float32")
y = fluid.layers.data(name="y", shape=[1], dtype="float32")
# 通过全连接网络进行预测
y_predict = fluid.layers.fc(input=x, # 输入数据
size=1, # 输出数据
act=None) # 因为是回归问题。所以不使用激活函数
# 添加损失函数
cost = fluid.layers.square_error_cost(input=y_predict, label=y) # 求得与测试与真实值的差值，再求平方
avg_cost = fluid.layers.mean(cost) # 在求得平均值
# 定义优化方法
optimizer = fluid.optimizer.SGD(learning_rate=0.01)
optimizer.minimize(avg_cost) # 指定最小化房差值
# 搭建网络
place = fluid.CPUPlace() # 指定在CPU执行
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program()) # 初始化系统参数
# 开始迭代，迭代100次
costs = []
iters = []
values = []
params = {"x": train_data, "y": y_true}
for i in range(200):
outs = exe.run(feed=params, fetch_list=[y_predict, avg_cost])
iters.append(i) # 迭代次数
costs.append(outs[1][0]) # 损失值
print("i:", i, "cost:", outs[1][0])
# 线性模型可视化
tmp = np.random.rand(10, 1) # 产生10行1列均匀随机数组
tmp = tmp * 2 # 调整值范围
tmp.sort(axis=0) # 排序
x_test = np.array(tmp).astype("float32")
params={"x":x_test,"y":x_test} # 传y仅仅是为了避免语法错误
y_out = exe.run(feed=params, fetch_list=[y_predict]) # 进行预测
y_test=y_out[0] # 取出预测结果
# 绘制回归的曲线
plt.figure("Infer") # 创建一张图
plt.title("Linear Regression",fontsize=24) # 设置标题
plt.plot(x_test,y_test,color="red",label="Infer") # 绘制回归的曲线
plt.scatter(train_data,y_true) # 绘制散点图
plt.legend() # 绘制图例
plt.grid() # 绘制网格线
plt.savefig("infer.png")
# 绘制损失函数的曲线图
plt.figure("Training") # #创建另外一个窗体
plt.title("Training Cost",fontsize=24) # 设置标题
plt.xlabel("Iter",fontsize=14)
plt.ylabel("Cost",fontsize=14)
plt.plot(iters,costs,color="red",label="Training Cost")
plt.legend()
plt.grid()
plt.savefig("train.png")
plt.show()
# 05_reader_demo_demo.py
# 读取文件样本实例
import paddle.fluid as fluid
import paddle
import numpy
# 1、定义原始读取器
def reader_creator(file_path): # 原始读取器
def reader():
with open(file_path,"r") as f:
lines = f.readlines() # 读取所有行。返回一个列表
for line in lines:
yield line.replace("\n","") # 生成数据对象并返回 (即每次调用时返回一行数据，下次调用时返回此行的下一行数据)
return reader
reader = reader_creator(r"D:\project\paddle_learn\day06\test.txt")
# 2、将原始读取器包装成随机读取器
capacity=10 # capacity:表示缓冲区的大小
# 将原始的读取器传至paddleshuffle中进行数据的打乱操作
shuffle_reader= paddle.reader.shuffle(reader,capacity) # 将其包装成随机读取器 capacity:表示缓冲区的大小 （缓冲区的大小只会影响预分配内存的大小）
# 3、将随机读取器包装成批量读取器（即得到一个随机批量的读取器）
batch_size=5 # 表示每一个批次读取的大小
batch_reader = paddle.batch(shuffle_reader,batch_size)
# 从随机批量读取器中进行迭代
for data in batch_reader(): # 从随机批量读取器中进行迭代
print(data)
# 多元回归示例：波士顿房价预测
''' 数据集介绍:
1) 共506行，每行14列，前13列描述房屋特征信息，最后一列为价格中位数
2) 考虑了犯罪率（CRIM） 宅用地占比（ZN）
非商业用地所占尺寸（INDUS） 查尔斯河虚拟变量（CHAS）
环保指数（NOX） 每栋住宅的房间数（RM）
1940年以前建成的自建单位比例（AGE） 距离5个波士顿就业中心的加权距离（DIS）
距离高速公路便利指数（RAD） 每一万元不动产税率（TAX）
教师学生比（PTRATIO） 黑人比例（B）
房东属于中低收入比例（LSTAT）
'''
import paddle
import paddle.fluid as fluid
import numpy as np
import os
import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt
# step1：数据准备
# paddle提供了uci_housing训练集、测试集，直接读取并返回数据
BUF_SIZE = 500
BATCH_SIZE = 20
# 训练数据集读取器
# 将原始读取器封装为随机读取器
random_reader = paddle.reader.shuffle(paddle.dataset.uci_housing.train(),
buf_size=BUF_SIZE) # 创建随机读取器
# 再花瓣飞随机读取器包装为随机批量读取器
train_reader = paddle.batch(random_reader,
batch_size=BATCH_SIZE) # 训练数据读取器
# 打印数据
# train_data = paddle.dataset.uci_housing.train()
for sample_data in train_reader():
print(sample_data)
# step2:配置网络
# 定义输入、输出，类型均为张量
x = fluid.layers.data(name="x", shape=[13], dtype="float32")
y = fluid.layers.data(name="y", shape=[1], dtype="float32")
# 定义简单的线性网络,连接输入层与输出层
y_predict = fluid.layers.fc(input=x, # 输入数据
size=256, # 输出值个数
act=None
)
y_predict = fluid.layers.fc(input=y_predict, # 输入数据
size=1, # 输出值个数
act=None
)
# 定义损失函数，并将损失函数指定给优化器
cost = fluid.layers.square_error_cost(input=y_predict, # 预测值，张量
label=y # 期望值，张量
)
avg_cost = fluid.layers.mean(cost) # 求损失平均值
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001) # 使用随机梯度下降优化器
opts = optimizer.minimize(avg_cost) # 优化器最小化损失值
# 创建新的program用于测试计算
test_program = fluid.default_main_program().clone(for_test=True)
# step3:模型训练、模型评估
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program()) # 初始化变量
# 数据喂入器
feeder = fluid.DataFeeder(place=place, feed_list=[x, y]) # 数据喂入器，将数据转换为神经网络所需要的张量形式
iter=0
iters=[] # 存放迭代次数
train_costs=[] # 存放每轮训练损失函数值
EPOCH_NUM=200
model_save_dir = "./model/uci_housing" # 模型保存路径
for pass_id in range(EPOCH_NUM):
train_cost = 0
i = 0
for data in train_reader(): # 从随机批量读取器中读取批量数据
i += 1
train_cost = exe.run(program=fluid.default_main_program(),
feed=feeder.feed(data), # 将data转换为神将网络所需要的张量格式，并喂入
fetch_list=[avg_cost]) # 指定要获取的哪个结果
if i % 20 == 0: # 每20笔打印一次损失函数值
print("PassID: %d, Cost: %0.5f" % (pass_id, train_cost[0][0]))
iter = iter + BATCH_SIZE # 加上每批次笔数
iters.append(iter) # 记录笔数
train_costs.append(train_cost[0][0]) # 记录损失值
# 保存模型
if not os.path.exists(model_save_dir): # 如果存储模型的目录不存在，则创建
os.makedirs(model_save_dir)
fluid.io.save_inference_model(model_save_dir, # 保存模型的路径
["x"], # 预测需要喂入的数据 （即表明x需要传参）
[y_predict], # 保存预测结果的变量
exe) # 模型（执行器）
# 训练过程可视化
plt.figure("Training Cost")
plt.title("Training Cost", 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.savefig("train.png")
#####################################模型预测####################################################
# step4: 模型预测
infer_exe = fluid.Executor(place) # 创建用于预测的Executor
# infer_scope = fluid.core.Scope() # 修改全局/默认作用域, 运行时中的所有变量都将分配给新的scope
infer_result = [] #预测值列表
ground_truths = [] #真实值列表
# with fluid.scope_guard(infer_scope):
# 加载模型，返回三个值
# program: 预测程序(包含了数据、计算规则)
# feed_target_names: 需要喂入的变量
# fetch_targets: 预测结果保存的变量
[infer_program, feed_target_names, fetch_targets] = \
fluid.io.load_inference_model(model_save_dir, # 模型保存路径
infer_exe) # 要执行模型的Executor
# 获取测试数据
infer_reader = paddle.batch(paddle.dataset.uci_housing.test(),
batch_size=200) # 测试数据读取器
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")
x_name = feed_target_names[0] # 模型中保存的输入参数名称
results = infer_exe.run(infer_program, # 预测program
feed={x_name: np.array(test_x)}, # 喂入预测的值
fetch_list=fetch_targets) # 预测结果
# 预测值
for idx, val in enumerate(results[0]):
print("%d: %.2f" % (idx, val))
infer_result.append(val)
# 真实值
for idx, val in enumerate(test_y):
print("%d: %.2f" % (idx, val))
ground_truths.append(val)
# 可视化
plt.figure('scatter')
plt.title("TestFigure", fontsize=24)
plt.xlabel("ground truth", fontsize=14)
plt.ylabel("infer result", fontsize=14)
x = np.arange(1, 30)
y = x
plt.plot(x, y)
plt.scatter(ground_truths, infer_result, color="green", label="Test")
plt.grid()
plt.legend()
plt.savefig("predict.png")
plt.show()
# plt.savefig("predict.png")
551
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
