＜PaddlePaddle学习使用P1＞——《PaddlePaddle教程》

一、PaddlePaddle概述

1.什么是PaddlePaddle

PaddlePaddle官网地址链接：https://www.paddlepaddle.org.cn/
为什么学习PaddlePaddle：

2.PaddlePaddle特点

PaddlePaddle优点（目前）：

PaddlePaddle缺点（目前）：

PaddlePaddle平台获奖情况（目前）：

PaddlePaddle行业应用（目前）：

PaddlePaddle学习资源（目前）：

AIStudio官网地址链接：https://aistudio.baidu.com

3.PaddlePaddle体系结构

总体架构：

编译时与执行时：

三个重要术语：

4.PaddlePaddle安装与卸载

以Pycharm安装为例：
官方安装教程地址链接

注：

• 由于百度提供了AIStudio平台，这里在Pycharm上安装只是为了在Pycharm配置PaddlePaddle环境，通过Pycharm的代码编辑方便快捷优点，实际运行还是在AIStudio平台。
• 目前pycharm对paddle的兼容性不是很好，因此建议在pycharm编写代码，而运行则将代码拷贝至AIStudio集成平台。

5.在AIStudio集成平台运行PaddlePaddle

（1）打开AIStudio平台官网，注册账号

• 注册需要身份认证，认证成功后才能使用项目编辑、运行。
• 百度目前发布新手任务赢算力时长活动。
  新手赢算力任务活动地址链接：https://aistudio.baidu.com/newbie
• 百度目前发布每日运行即获赠8点GPU免费额度(最多8小时)。
  
  

（2）创建项目

项目创建举例：

（3）编辑运行

• 由于众所周知的原因：作为学生的我们，经济比较紧张，作者选用免费版。（因人而异，量力而行）
• 作者在此感谢百度提供的开源学习资源，同时也感谢其他公司、机构、组织、个人等提供的开源学习资源。
  
  基于jupyter notebook的编辑环境页面：
  基于Linux的终端环境：
  AI Studio 经典版环境使用说明地址链接：https://ai.baidu.com/ai-doc/AISTUDIO/sk3e2z8sb
  示例1：使用paddle进行加法操作
  这是paddle 1.x版本支持的调用编写方式：
  

#paddle 1.x版本的调用编写方式
import paddle.fluid as fluid

# 创建两个常量
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  # 执行两个常量的相加

# 创建执行器
place = fluid.CPUPlace()  # 指定程序在CPU上执行
exe = fluid.Executor(place)  # 创建执行器
result = exe.run(fluid.default_main_program(),
                 fetch_list=[z])  # 指定要返回的结果
print(result)

注：

• 在paddle新的版本中运行以上代码可能出现报错的情况，这是因为上面的代码是在paddle1.x版本中支持的调用编写。而新版本的paddle可能对之前的版本进行升级，不再支持老版本的部分调用编写。

新版本实现加法：

import paddle.fluid as fluid
import paddle
try:
    # 兼容PaddlePaddle2.0
    paddle.enable_static()
except:
    pass

# 定义两个张量
x1 = fluid.layers.fill_constant(shape=[2, 2], value=1, dtype='int64')
x2 = fluid.layers.fill_constant(shape=[2, 2], value=1, dtype='int64')

# 将两个张量求和
y1 = fluid.layers.sum(x=[x1, x2])

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

# 进行运算，并把y的结果输出
result = exe.run(program=fluid.default_main_program(),
                 fetch_list=[y1])
print(result)

二、PaddlePaddle的基本概念与操作

1.PaddlePaddle的基本概念

张量：


Layer：

Variable：

Program：

Executor:

Place:

Optimizer:

示例2：执行两个张量计算

import paddle.fluid as fluid
import numpy as np
import paddle
try:
    # 兼容PaddlePaddle2.0
    paddle.enable_static()
except:
    pass

# 定义两个张量
a = fluid.layers.create_tensor(dtype='int64', name='a')
b = fluid.layers.create_tensor(dtype='int64', name='b')

# 将两个张量求和
y = fluid.layers.sum(x=[a, b])

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

# 定义两个要计算的变量
a1 = np.array([3, 2]).astype('int64')
b1 = np.array([1, 1]).astype('int64')

# 进行运算，并把y的结果输出
out_a, out_b, result = exe.run(program=fluid.default_main_program(),
                               feed={a.name: a1, b.name: b1},
                               fetch_list=[a, b, y])
print(out_a," + ", out_b," = ", result)

2.程序执行步骤

三、PaddlePaddle综合案例——实现简单线性回归

1.任务介绍

2.任务实现

示例3：简单线性回归

#linear_regression.py的代码
import paddle.fluid as fluid
import numpy as np
import paddle
try:
    # 兼容PaddlePaddle2.0
    paddle.enable_static()
except:
    pass

# 定义一个简单的线性网络
x = fluid.data(name='x', shape=[None, 1], dtype='float32')
hidden = fluid.layers.fc(input=x, size=100, act='relu')
hidden = fluid.layers.fc(input=hidden, size=100, act='relu')
net = fluid.layers.fc(input=hidden, size=1, act=None)

# 获取预测程序
infer_program = fluid.default_main_program().clone(for_test=True)

# 定义损失函数
y = fluid.data(name='y', shape=[None, 1], dtype='float32')
cost = fluid.layers.square_error_cost(input=net, label=y)
avg_cost = fluid.layers.mean(cost)

# 定义优化方法
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())

# 定义训练和测试数据
x_data = np.array([[1.0], [2.0], [3.0], [4.0], [5.0]]).astype('float32')
y_data = np.array([[3.0], [5.0], [7.0], [9.0], [11.0]]).astype('float32')

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


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

四、PaddlePaddle数据准备

1.什么是数据准备

2.为什么需要数据准备

示例4：reader数据准备

# 04_reader_demo.py
import paddle
# 原始读取器
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("test.txt")  # 原始顺序读取器
shuffle_reader = paddle.reader.shuffle(reader, 10)  # 随机读取器
batch_reader = paddle.batch(shuffle_reader, 3)  # 批量随机读取器

# for data in reader():  # 迭代
# for data in shuffle_reader(): # 对随机读取器进行迭代
for data in batch_reader():  # 对批量随机读取器进行迭代
    print(data, end="")

3.预测模型保存和加载

4.fluid API结构图

五、PaddlePaddle综合案例——实现波士顿房价预测

1.数据集及任务

2.任务思路

3.执行结果

示例5：波士顿房价预测

#uci_housing_linear.py的代码
import paddle.fluid as fluid
import paddle
import paddle.dataset.uci_housing as uci_housing
import numpy
try:
    # 兼容PaddlePaddle2.0
    paddle.enable_static()
except:
    pass

# 定义一个简单的线性网络
x = fluid.data(name='x', shape=[None, 13], dtype='float32')
hidden = fluid.layers.fc(input=x, size=100, act='relu')
hidden = fluid.layers.fc(input=hidden, size=100, act='relu')
net = fluid.layers.fc(input=hidden, size=1, act=None)

# 获取预测程序
infer_program = fluid.default_main_program().clone(for_test=True)

# 定义损失函数
y = fluid.data(name='y', shape=[None, 1], dtype='float32')
cost = fluid.layers.square_error_cost(input=net, label=y)
avg_cost = fluid.layers.mean(cost)

# 定义优化方法
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())

# 从paddle接口中获取房价数据集，使用房价数据进行训练和测试
train_reader = paddle.batch(reader=uci_housing.train(), batch_size=128)
test_reader = paddle.batch(reader=uci_housing.test(), batch_size=128)

# 定义输入数据维度
feeder = fluid.DataFeeder(place=place, feed_list=[x, y])

# 开始训练和测试
for pass_id in range(300):
    # 开始训练并输出最后一个batch的损失值
    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])
    print("Pass:%d, Cost:%0.5f" % (pass_id, train_cost[0][0]))

# 开始测试
for data in test_reader():
    infer_data = numpy.array([data[0] for data in data]).astype("float32")
    infer_label = numpy.array([data[1] for data in data]).astype("float32")
    infer_result = exe.run(program=infer_program,
                           feed={x.name: infer_data},
                           fetch_list=[net])
    # 把每个预测结果都输出
    for i in range(len(infer_label)):
        print('预测结果：%f, 真实结果：%f' % (infer_result[0][i][0], infer_label[i][0]))

后记：
●本博客基于B站开源学习资源，是作者学习的笔记记录，仅用于学习交流，不做任何商业用途！