AI模型深度学习

Paddle快速入门

字数统计: 1.2k字   |   阅读时长: 6分
,

摘要: Paddle快速入门，附一份 PaddleNLP 工具集介绍。

【对数据分析、人工智能、金融科技、风控服务感兴趣的同学，欢迎关注我哈，阅读更多原创文章】
我的网站：潮汐朝夕的生活实验室
我的公众号：潮汐朝夕
我的知乎：潮汐朝夕
我的github：FennelDumplings
我的leetcode：FennelDumplings

安装

在 快速安装 中选自己的安装信息。

1
2
3
# CPU
conda install paddlepaddle --channel https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/Paddle/
conda install paddlepaddle --upgrade --channel https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/Paddle/

线性回归

step1 定义训练和测试数据

用 Numpy 定义训练和测试数据

13 个特征，5 个数据。

1
2
3
4
5
6
7
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')

step2: 定义网络

1
2
3
4
5
net = paddle.nn.Sequential(
        paddle.nn.Linear(13, 100),
        paddle.nn.ReLU(),
        paddle.nn.Linear(100, 1)
        )

step3: 定义优化方法

1
optimizer = paddle.optimizer.SGD(learning_rate=0.01, parameters=net.parameters())

损失函数: 平方差损失函数 paddle.nn.functional.square_error_cost 求的是一个Batch的损失值

step4: 训练

1
2
3
4
5
6
7
8
9
10
inputs = paddle.to_tensor(x_data)
labels = paddle.to_tensor(y_data)

for pass_id in range(10):
    out = net(inputs)
    loss = paddle.mean(paddle.nn.functional.square_error_cost(out, labels))
    loss.backward()
    optimizer.step()
    optimizer.clear_grad()
    print("Pass: {}, Cost: {:.5f}".format(pass_id, float(loss)))

打印信息如下

1
2
3
4
5
6
7
8
9
10
Pass: 0, Cost: 4.24929
Pass: 1, Cost: 0.15542
Pass: 2, Cost: 0.03112
Pass: 3, Cost: 0.03047
Pass: 4, Cost: 0.02984
Pass: 5, Cost: 0.02922
Pass: 6, Cost: 0.02862
Pass: 7, Cost: 0.02802
Pass: 8, Cost: 0.02745
Pass: 9, Cost: 0.02688

step5: 预测

1
2
3
4
predict_inputs = paddle.to_tensor(test_data)
result = net(predict_inputs)

print("result: {}".format(result))

输出结果

1
2
result: Tensor(shape=[1, 1], dtype=float32, place=CPUPlace, stop_gradient=False,
       [[13.25140858]])

房价预测 Demo

数据集介绍

数据集共 506 行,每行 14 列。前 13 列用来描述房屋的各种信息，最后一列为该类房屋价格中位数。

PaddlePaddle提供了读取uci_housing数据集的接口，paddle.text.datasets.UCIHousing

数据准备

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

1
2
3
4
5
6
7
BATCH_SIZE = 20

train_dataset = paddle.text.datasets.UCIHousing(mode="train")
valid_dataset = paddle.text.datasets.UCIHousing(mode="test")

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)

数据洞察

1
print(train_dataset[0])
1
2
3
(array([-0.0405441 ,  0.06636363, -0.32356226, -0.06916996, -0.03435197,
        0.05563625, -0.03475696,  0.02682186, -0.37171334, -0.21419305,
       -0.33569506,  0.10143217, -0.21172912], dtype=float32), array([24.], dtype=float32))

定义网络

输入到输出的简单全连接层。

1
net = paddle.nn.Linear(13, 1)

定义损失函数

1
square_error_cost(pred, label)

定义优化器

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

模型训练

定义绘制训练过程损失变化趋势的方法

1
2
3
4
5
6
7
8
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()

训练并保存模型

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
EPOCH_NUM = 50

iter = 0
iters = []
train_costs = []

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()

        if batch_id % 40 == 0:
            print("Pass: {}, Cost: {:.5f}".format(pass_id, float(train_loss)))

        iter = iter + BATCH_SIZE
        iters.append(iter)
        train_costs.append(train_loss.numpy()[0])

    # 测试并输出最后一个 batch 的损失
    test_loss = 0

    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))

    print("Test: {}, Cost: {:.5f}".format(pass_id, float(test_loss)))

# 保存模型
paddle.save(net.state_dict(), "fit_a_line.pdparams")

draw_train_process(iters, train_costs)

模型预测

可视化真实值与预测值的方法

1
2
3
4
5
6
7
8
9
10
11
def draw_infer_result(ground_truths, infer_results):
    title = "Infer"
    plt.title(title, fontsize=24)
    x = np.arange(1, 20)
    y = x
    plt.plot(x, y)
    plt.xlabel("ground truths", fontsize=14)
    plt.ylabel("infer results", fontsize=14)
    plt.scatter(ground_truths, infer_results, color="green", label="training_cost")
    plt.grid()
    plt.show()

模型预测

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
infer_results = []
ground_truths = []

test_dataset= paddle.text.UCIHousing(mode="test")
infer_loader = paddle.io.DataLoader(test_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: {}, Infer Result: {:.2f}, Ground Truth: {:.2f}".format(idx, float(item[0]), float(item[1])))
    infer_results.append(item[0].numpy()[0])
    ground_truths.append(item[1].numpy()[0])

draw_infer_result(ground_truths, infer_results)

Share