PaddlePaddle概述

PaddlePaddle简介

为什么要学PaddlePaddle
什么是PaddlePaddle
PaddlePaddle优点
PaddlePaddle缺点
学习资源
什么是PaddlePaddle

PaddlePaddle（Parallel Distributed Deep Learning，中文名飞桨）
是百度公司推出的开源、易学习、易使用的分布式深度学习平台 源于产业实践，在实际中有着优异表现 支持多种机器学习经典模型

为什么学习PaddlePaddle

开源、国产 能更好、更快解工程决实际问题

PaddlePaddle优点

易用性。语法简洁，API的设计干净清晰 丰富的模型库。借助于其丰富的模型库，可以非常容易的复现一些经典 方法
全中文说明文档。首家完整支持中文文档的深度学习平台 运行速度快。充分利用 GPU 集群的性能，为分布式环境的并行计算进行 加速
PaddlePaddle缺点 教材少 习难度大、曲线陡峭

学习资源

官网 地址：https://www.paddlepaddle.org.cn/ 内容：学习指南、文档、API手册 百度云智学院
地址：http://abcxueyuan.cloud.baidu.com/#/courseDetail?id=14958 内容：教学视频
AIStudio
地址：https://aistudio.baidu.com/aistudio/projectoverview/public/1
内容：项目案例

编译与执行过程

1. 用户编写的python程序通过调用 Paddle 提供的算子，向Program 中添加变量 （Tensor）以及对变量的操作（Operators 或者 Layers）
2. 原始Program在框架内部转换为中间描述语言： ProgramDesc
3. Transpiler 接受一段 ProgramDesc ，输出一段变化后的 ProgramDesc ，作为后端 Executor 最终需要执行的 Program
4. 执行 ProgramDesc 中定义的 Operator（可以类比为程序语言中的指令），在执行 过程中会为 Operator 创建所需的输入输出并进行管理

三个重要术语

Fluid：定义程序执行流程 Program：对用户来说一个完整的程序 Executor：执行器，执行程序

快速开始

import paddle.fluid as fluid

# 创建两个类型为int64,形状为1行1列的张量
x = fluid.layers.fill_constant(
    shape=[1],
    dtype='int64',
    value=1
)
y = fluid.layers.fill_constant(
    shape=[1],
    dtype='int64',
    value=1
)
z = x + y
# 创建Executor执行器
place = fluid.CPUPlace()
exe = fluid.Executor(place)
result = exe.run(
    fluid.default_main_program(),
    fetch_list=[z]
)
print(result)

张量

• 什么是张量 张量（Tensor）: 多维数组或向量，同其它主流深度学习框架一样， PaddlePaddle使用张量来承载数据

张量（续）

• 张量示例 灰度图像为二维张量（矩阵），彩色图像为三维张量

LoDTensor

LoD(Level-of-Detail) Tensor是Paddle的高级特性，是对Tensor的一种
扩充。LoDTensor通过牺牲灵活性来提升训练的效率。 LoDTensor用来处理变长数据信息，将长度不一致的维度拼接为一个大的
维度，并引入了一个索引数据结构（LoD）来将张量分割成序列。

LoDTensor（续）

假设一个mini-batch中有3个句子，每个句子中分别包含3个、1个和2个单词，我 们可以用(3+1+2)xD维Tensor
加上一些索引信息来表示这个mini-batch： 假设存在一个mini-batch中包含3个句子、1个句子和2个句子的文章，每个句子都
由不同数量的单词组成，则这个mini-batch的可以表示为2-Level的LoDTensor：

Layer

表示一个独立的计算逻辑，通常包含一个或多个operator（操
作），如layers.relu表示ReLU计算；layers.pool2d表示pool操 作。Layer的输入和输出为Variable。

Variable

表示一个变量，在paddle中，Variable 基本等价于 Tensor 。
Variable进入Layer计算，然后Layer返回Variable。创建变量方式：

x = fluid.layers.fill_constant(shape=[1],dtype='int64',value=1)
y = fluid.layers.fill_constant(shape=[1],dtype='int64',value=1)

Variable（续）

Paddle 中存在三种 Variable： 模型中的可学习参数：包括网络权重、偏置，生存期和整个训练任务 一样长。通过
fluid.layers.create_parameter 来创建可学习参数 占位 Variable：Paddle 中使用
fluid.data 来接收输入数据， fluid.data 需要提供输入 Tensor 的形状信息，当遇到无法确定的维度
时，相应维度指定为 None 常量 Variable：通过 fluid.layers.fill_constant
来实现常量Variable

Program

Program包含Variable定义的多个变量和Layer定义的多个计算，是
一套完整的计算逻辑。从用户角度来看，Program是顺序、完整执 行的。program 的作用是存储网络结构，但不存储参数。

Program（续）

用户完成网络定义后，一段 Paddle 程序中通常存在 2 个 Program
fluid.default_startup_program：定义了模型参数初始化、优化器参
数初始化、reader初始化等各种操作。该program可以由框架自动生成， 使用时无需显式地创建
fluid.default_main_program ：定义了神经网络模型，前向反向计算， 以及模型参数更新、优化器参数更新等各种操作

Scope

scope 在 paddle 里可以看作变量空间，存储fluid创建的变量。变量 存储于unordered_map
数据结构中，该结构类似于python中的dict， 键是变量的名字，值是变量的指针。 一 个 p a d d l e 程 序 有 一 个
默 认 的 全 局 s c o p e （ 可 以 通 过 fluid.global_scope() 获取）。如果没有主动创建 scope
并且通过 fluid.scope_guard() 替换当前 scope，那么所有参数都在全局 scope
中。参数创建的时机不是在组网时，而是在 executor.run() 执行时。 program 和 scope
配合，才能表达完整模型（模型=网络结构+参数）

Executor

Executor用来接收并执行Program，会一次执行Program中定义的
所有计算。通过feed来传入参数，通过fetch_list来获取执行结果。
Place
PaddlePaddle可以运行在Intel CPU，Nvidia GPU，ARM CPU和更
多嵌入式设备上，可以通过Place用来指定执行的设备（CPU或
GPU）。

Optimizer

优化器，用于优化网络，一般用来对损失函数做梯度下降优化，从而 求得最小损失值

课
堂
练
习
案例2：执行两个张量计算

'''
1. 神经网络 全连接
2. 损失函数 均方差
3. SGD 随机梯度优化器。
'''
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.2],
    [1.3]
]).astype("float32")
y_true = np.array([
    [5.0],
    [5.5],
    [6.8],
    [6.9],
    [7.0]
]).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)
# 对cost求平均值
avg_cost = fluid.layers.mean(cost)
# 定义优化方法
optimizer = fluid.optimizer.SGD(learning_rate=0.001)
optimizer.minimize(avg_cost)

# 执行器
place = fluid.CPUPlace()
exe = fluid.Executor(place)
# 初始化网络
exe.run(fluid.default_startup_program())

# 开始训练

# 定义params
params = {"x": train_data, "y": y_true}
costs = []  # 损失值
iters = []  # 迭代次数
# values=[] # 获取到值
for i in range(100):
    # 传入的参数 最后要获取到的值，预测结果，cost均值。
    outs = exe.run(feed=params,
                   fetch_list=[y_predict.name,
                               avg_cost.name])
    # 记录迭代次数
    iters.append(i)
    # 记录损失值
    costs.append(outs[1][0])
    print("i", i, "cost", outs[1][0])

# 损失函数可视化 iters costs。
# plt.figure("Training")
# plt.xlabel("Iter",fontsize=14)
# plt.ylabel("cost",fontsize=14)
# plt.plot(iters, costs, color="red", label="Training cost")
# plt.legend()
# plt.show()
# 线性模型可视化
# 定义一系列的x，通过模型预测x对应的y
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_out = exe.run(feed=params,
                fetch_list=[y_predict.name])
y_test = y_out[0]
plt.xlabel("x_test")
plt.ylabel("y_test")
plt.title("Linear Regression")
plt.plot(x_test, y_test, color="orange",
         label="linear")
plt.scatter(train_data, y_true)

plt.legend()
plt.show()

编写简单线性回归

任务： 给出输入样本 给出实际输出样本 找出 y = wx+b 公式中的 w 和 b 思路： 定义输入数据、实际输出结果
将数据送入神经网络进行训练（全连接网络，即分类器） 根据实际输出、预测输出之间的损失值，进行梯度下降，直到收敛到极小值为止

案例：编写简单线性回归（续）

技术要点： 神经网络，选择 fluid.layers.fc( )，该函数在神经网络中建立一个全连接层。接收
多个输入，为每个输入分配一个权重w, 并维护一个偏置值b；预测时产生一个输出 损失函数：回归问题，选择均方差 f l u i d . l
a y e rs. squa re _ e rror _ cos t和 fluid.layers.mean( )作为损失函数
优化器：随机梯度下降优化器 fluild.SGD，做梯度下降计算

什么是数据准备

数据准备是指将样本数据从外部（主要指文件）读入，并且按照一 定方式（随机、批量）传递给神经网络，进行训练或测试的过程
数据准备包含三个步骤： 第一步：自定义Reader生成训练/预测数据 第二步：在网络配置中定义数据层变量
第三步：将数据送入网络进行训练/预测

知
识
讲
解

为什么需要数据准备

从文件读入数据。因为程序无法保存大量数据，数据一般保存到文 件中，所以需要单独的数据读取操作
批量快速读入。深度学习样本数据量较大，需要快速、高效读取 （批量读取模式） 随机读入。为了提高模型泛化能力，有时需要随机读取数据（随机
读取模式）