PaddlePaddle安装与线性回归、房价预测

这几天参加了百度图像分割七天打卡活动，快学起来呀~啦啦啦啦啦啦

1. PaddlePaddle安装

在官网https://www.paddlepaddle.org.cn/install/quick中，选择操作系统、安装方式、Python版本以及CUDA版本即可生成安装命令，安装即可。

我的电脑是Win10，Python3.6.11，无CUDA，所以选择以下代码进行安装：

python -m pip install paddlepaddle -i https://mirror.baidu.com/pypi/simple

安装结束后，进行测试：

在命令行输入python进入python解释器，然后依次输入以下代码：

import paddle.fluid
paddle.fluid.install_check.run_check()

如果出现如下图所示的Your Paddle Fluid is installed successfully!，即可完成安装。

2. 线性回归

# 线性回归
import paddle.fluid as fluid
import paddle
import numpy as np 

# 定义线性网络
# 1. 定义输入，形状为13
x = fluid.layers.data(name='x', shape=[13], dtype='float32')
# 2. 定义全连接层，大小为100，激活函数ReLU
hidden = fluid.layers.fc(input=x, size=100, act='relu')
# 3. 定义输出层，输出为1
net = fluid.layers.fc(input=hidden, size=1, act=None)

# 定义损失函数
y = fluid.layers.data(name='y', shape=[1], dtype='float32')
# 求一个batch的损失值
cost = fluid.layers.square_error_cost(input=net, label=y)
# 取平均
avg_cost = fluid.layers.mean(cost)

# 复制主程序，做预测
test_program = fluid.default_main_program().clone(for_test=True)

# 定义优化方法
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.01)
opts = optimizer.minimize(avg_cost)

# 创建一个使用CPU的解释器
place = fluid.CPUPlace()
exe = fluid.Executor(place)
# 进行参数初始化
exe.run(fluid.default_startup_program())

# 定义训练和测试数据  y = 2 * x + 1
x_data = np.array([[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 
                   [2.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 
                   [3.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 
                   [4.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0], 
                   [5.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]).astype('float32')
y_data = np.array([[3.0], [5.0], [7.0], [9.0], [11.0]]).astype('float32')
test_data = np.array([[6.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]]).astype('float32')

# 开始训练100个pass
for pass_id in range(100):
    train_cost = exe.run(program=fluid.default_main_program(),
                        feed={'x':x_data, 'y':y_data},
                        fetch_list=[avg_cost])
    print("Pass:%d, Cost:%0.5f" % (pass_id, train_cost[0]))

# 开始预测
result = exe.run(program=test_program, 
                feed={'x': test_data, 'y':np.array([[0.0]]).astype('float32')},
                fetch_list=[net])
print("当x为6.0时，y为：%0.5f" % result[0][0][0])

 3. 房价预测（使用线性模型）

import paddle.fluid as fluid
import paddle 
import numpy as np 
import os

import matplotlib

print(matplotlib.get_backend())
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt

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) 

# 打印，查看uci_housing数据
train_data = paddle.dataset.uci_housing.train();
sampledata = next(train_data())
print(sampledata)

# 
# 定义张量变量x，表示13维的特征值
x = fluid.layers.data(name='x', shape=[13], dtype='float32')
# 定义张量变量y, 表示目标值
y = fluid.layers.data(name='y', shape=[1], dtype='float32')

# 定义简单的线性网络
hidden = fluid.layers.fc(input=x, size=100, act='relu')
y_predict = fluid.layers.fc(input=hidden, size=1, act=None)

# 定义损失函数，使用均方差损失函数
# 求一个batch的损失值
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)
test_program = fluid.default_main_program().clone(for_test=True)

# 模型训练
use_cuda = False
place = fluid.CUDAPlace(0) if use_cuda else 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 = []

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.savefig('train_process.png')

# Executor接收传入的program,并根据feed map(输入映射表)和fetch_list(结果获取表) 向program中添加feed operators(数据输入算子)和fetch operators（结果获取算子)。 feed map为该program提供输入数据。fetch_list提供program训练结束后用户预期的变量。
# enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标。

EPOCH_NUM = 50
model_save_dir = "./fit_a_line.inference.model"

for pass_id in range(EPOCH_NUM):
    train_cost = 0
    for batch_id, data in enumerate(train_reader()):
        train_cost = exe.run(program=fluid.default_main_program(),
                            feed=feeder.feed(data),
                            fetch_list=[avg_cost])
        if batch_id % 40 == 0:
            print("Pass:%d, Cost:%0.5f" %(pass_id, train_cost[0][0]))
        iter = iter + BATCH_SIZE
        iters.append(iter)
        train_costs.append(train_cost[0][0])
    
    # 测试
    test_cost = 0
    for batch_id, data in enumerate(test_reader()):
        test_cost = exe.run(program=test_program,
                            feed = feeder.feed(data),
                            fetch_list = [avg_cost])
    # 打印最后一个batch的损失值
    print('Test:%d, Cost:%0.5f' % (pass_id, test_cost[0][0]))

# 保存模型
if not os.path.exists(model_save_dir):
    os.makedirs(model_save_dir)
print('save models to %s' %(model_save_dir))
fluid.io.save_inference_model(model_save_dir, 
                            ['x'],
                            [y_predict],
                            exe)
draw_train_process(iters, train_costs)

# 模型预测
infer_exe = fluid.Executor(place)
# Scope指定作用域
inference_scope = fluid.core.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.savefig('infer_result.png')

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)

结果图：

参考百度AI Studio新手入门第四课——PaddlePaddle快速入门。