PaddlePaddle——高层API建立模型

paddlepaddle2.0极大地简化了模型的搭建、训练、评估等过程，较前些版本有极大的简化，易于上手。

高层API搭建模型的步骤

1.准备数据

（1）导入库

因为paddle直接操作的对象就是张量，而在建立一些数据时需要先建立矩阵，再通过paddle.to_tensor()方法转换成张量，所以这里需要使用numpy库。

import paddle
import numpy as np

（2）数据预处理

将用于训练和测试的数据进行归一化操作后，进行数据的加载工作：

#在这里使用的是paddle提供的uci_housing数据集的接口，正常来说是要自己准备数据集
train_dataset = paddle.text.datasets.UCIHousing(mode='train')
valid_dataset = paddle.text.datasets.UCIHousing(mode='test')

（3）加载训练和测试数据集

PaddlePaddle中使用paddle.io.DataLoader来进行数据的加载操作，通过参数batch_size控制批次大小，shuffle控制是否打乱顺序。

#用于训练的数据加载器，每次随机读取批次大小的数据，剩余不满足批大小的数据丢弃
train_loader = paddle.io.DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, drop_last=True)

#用于测试的数据加载器，每次随机读取批次大小的数据
valid_loader = paddle.io.DataLoader(valid_dataset, batch_size=BATCH_SIZE, shuffle=True)

2.网络配置

（1）搭建网络结构

paddle提供了直接搭建网络结构的方法paddle.nn，可以直接使用这些方法进行网络搭建，非常方便好用。

• 如果采用单层网络：

仅有一层线性层 y = ax + b

# 输入数据形状为[13]，输出形状[1]
net = paddle.nn.Linear(13, 1)

• 如果采用多层网络：

[输入层] --> [隐层] --> [激活函数] --> [输出层]

# 定义一个简单的线性网络
net = paddle.nn.Sequential(
    paddle.nn.Linear(13, 100),
    paddle.nn.ReLU(),
    paddle.nn.Linear(100, 1)
)

（2）定义损失函数

paddle同样提供了很多损失函数的方法，可以直接通过paddle.nn.functional.xxx()进行调用，具体可参考官方文档：paddle.nn.functional
square_error_cost(input,lable)：接受输入预测值和目标值，并返回方差估计,即为（y-y_predict）的平方。

# 使用均方差损失函数
paddle.nn.functional.square_error_cost(out, labels)

（3）定义优化函数

优化函数使用起来非常方便，paddle.optimizer 目录下包含飞桨框架支持的优化器算法相关的API与学习率衰减相关的API。具体可以参考官方文档：paddle.optimizer

optimizer = paddle.optimizer.SGD(learning_rate=0.001, parameters=net.parameters())

3.模型训练和评估

遍历轮次和数据集loader，将批次数据送入net里面进行计算，最终经过loss计算，在进行反向传播和参数优化。

EPOCH_NUM=50

#训练EPOCH_NUM轮
for pass_id in range(EPOCH_NUM):                                  
    # 开始训练并输出最后一个batch的损失值
    train_cost = 0
#----------------------训练---------------------
    #遍历train_reader迭代器
    for batch_id, data in enumerate(train_loader()):
        inputs = paddle.to_tensor(data[0])
        labels = paddle.to_tensor(data[1])
        out = net(inputs)
        train_loss = paddle.mean(paddle.nn.functional.square_error_cost(out, labels))
        # 反向传播
        train_loss.backward() 
        # 参数优化
        optimizer.step() 
        optimizer.clear_grad()

        #打印最后一个batch的损失值
        if batch_id % 40 == 0:
            print("Pass:%d, Cost:%0.5f" % (pass_id, train_loss))    
        
        iter = iter + BATCH_SIZE
        iters.append(iter)
        train_costs.append(train_loss.numpy()[0])
	
	# 开始测试并输出最后一个batch的损失值
    test_loss = 0
#----------------------测试---------------------
    #遍历test_reader迭代器
    for batch_id, data in enumerate(valid_loader()):               
        inputs = paddle.to_tensor(data[0])
        labels = paddle.to_tensor(data[1])
        out = net(inputs)
        test_loss = paddle.mean(paddle.nn.functional.square_error_cost(out, labels))
        
    #打印最后一个batch的损失值
    print('Test:%d, Cost:%0.5f' % (pass_id, test_loss))     
    
#保存模型
paddle.save(net.state_dict(), 'fit_a_line.pdparams')

4.模型预测

通过paddle.load加载已经训练好的模型，来对新数据进行预测。

import paddle
import numpy as np
import matplotlib.pyplot as plt

# 读入预测数据
valid_dataset = paddle.text.UCIHousing(mode='test')
infer_loader = paddle.io.DataLoader(valid_dataset, batch_size=200)

infer_net = paddle.nn.Linear(13, 1)
param = paddle.load('fit_a_line.pdparams')
infer_net.set_dict(param)


data = next(infer_loader())
inputs = paddle.to_tensor(data[0])
results = infer_net(inputs)

for idx, item in enumerate(zip(results, data[1])):
    print("Index:%d, Infer Result: %.2f, Ground Truth: %.2f" % (idx, item[0], item[1]))
    infer_results.append(item[0].numpy()[0])
    groud_truths.append(item[1].numpy()[0])

• PaddlePaddle API文档