paddle17模型训练和预测&资源配置(多卡、分布式)

在完成数据预处理，数据加载与模型的组建后，你就可以进行模型的训练与预测了。飞桨框架提供了两种训练与预测的方法，一种是用paddle.Model对模型进行封装，通过高层API如Model.fit()、Model.evaluate()、Model.predict()等完成模型的训练与预测；另一种就是基于基础API常规的训练方式。

高层API实现的模型训练与预测如Model.fit()、Model.evaluate()、Model.predict()都可以通过基础API实现，本文先介绍高层API的训练方式，然后会将高层API拆解为基础API的方式，方便对比学习。

一、训练前准备

在封装模型前，需要先完成数据的加载与模型的组建，由于这一部分高层API与基础API通用，所以都可用下面的代码实现：

import paddle
from paddle.vision.transforms import ToTensor

# 加载数据集
train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=ToTensor())
test_dataset = paddle.vision.datasets.MNIST(mode='test', transform=ToTensor())

# 定义网络结构
mnist = paddle.nn.Sequential(
    paddle.nn.Flatten(1, -1),
    paddle.nn.Linear(784, 512),
    paddle.nn.ReLU(),
    paddle.nn.Dropout(0.2),
    paddle.nn.Linear(512, 10)
)

通过上述的代码，你就完成了训练集与测试集的构建，并创建了一个 mnist的网络模型。下面分别用两种方式完成模型的训练与预测。

二、通过paddle.Model训练与预测（高层API）

你可以使用paddle.Model完成模型的封装，将网络结构组合成一个可快速使用高层API进行训练和预测的对象。代码如下：

model = paddle.Model(mnist)

• 概述
  增加了paddle.Model高层API，大部分任务可以使用此API用于简化训练、评估、预测类代码开发。注意区别Model和Net概念，Net是指继承paddle.nn.Layer的网络结构；而Model是指持有一个Net对象，同时指定损失函数、优化算法、评估指标的可训练、评估、预测的实例。具体参考高层API的代码示例。

import paddle
from paddle.vision.transforms import ToTensor

train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=ToTensor())
test_dataset = paddle.vision.datasets.MNIST(mode='test', transform=ToTensor())
lenet = paddle.vision.models.LeNet()

# Mnist继承paddle.nn.Layer属于Net，model包含了训练功能
model = paddle.Model(lenet)

# 设置训练模型所需的optimizer, loss, metric
model.prepare(
    paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()),
    paddle.nn.CrossEntropyLoss(),
    paddle.metric.Accuracy()
    )

# 启动训练
model.fit(train_dataset, epochs=2, batch_size=64, log_freq=200)

# 启动评估
model.evaluate(test_dataset, log_freq=20, batch_size=64)

2.1 用Model.prepare()配置模型

用paddle.Model完成模型的封装后，在训练前，需要对模型进行配置，通过Model.prepare接口来对训练进行提前的配置准备工作，包括设置模型优化器，Loss计算方法，精度计算方法等。

# 为模型训练做准备，设置优化器，损失函数和精度计算方式
model.prepare(optimizer=paddle.optimizer.Adam(parameters=model.parameters()),
              loss=paddle.nn.CrossEntropyLoss(),
              metrics=paddle.metric.Accuracy())

2.2 用Model.fit()训练模型

做好模型训练的前期准备工作后，调用fit()接口来启动训练过程，需要指定至少3个关键参数：训练数据集，训练轮次和单次训练数据批次大小。

# 启动模型训练，指定训练数据集，设置训练轮次，设置每次数据集计算的批次大小，设置日志格式
model.fit(train_dataset,
          epochs=5,
          batch_size=64,
          verbose=1)

2.3 用Model.evaluate()评估模型

对于训练好的模型进行评估可以使用evaluate接口，事先定义好用于评估使用的数据集后，直接调用evaluate接口即可完成模型评估操作，结束后根据在prepare中loss和metric的定义来进行相关评估结果计算返回。

返回格式是一个字典： * 只包含loss，{'loss': xxx} * 包含loss和一个评估指标，{'loss': xxx, 'metric name': xxx} * 包含loss和多个评估指标，{'loss': xxx, 'metric name1': xxx, 'metric name2': xxx}

# 用 evaluate 在测试集上对模型进行验证
eval_result = model.evaluate(test_dataset, verbose=1)

2.4 用Model.predict()预测模型

高层API中提供了predict接口来方便用户对训练好的模型进行预测验证，只需要基于训练好的模型将需要进行预测测试的数据放到接口中进行计算即可，接口会将经过模型计算得到的预测结果进行返回。

返回格式是一个list，元素数目对应模型的输出数目： * 模型是单一输出：[(numpy_ndarray_1, numpy_ndarray_2, …, numpy_ndarray_n)] * 模型是多输出：[(numpy_ndarray_1, numpy_ndarray_2, …, numpy_ndarray_n), (numpy_ndarray_1, numpy_ndarray_2, …, numpy_ndarray_n), …]

numpy_ndarray_n是对应原始数据经过模型计算后得到的预测数据，数目对应预测数据集的数目。

# 用 predict 在测试集上对模型进行测试
test_result = model.predict(test_dataset)

三、通过基础API实现模型的训练与预测

除了通过第一部分的高层API实现模型的训练与预测，飞桨框架也同样支持通过基础API对模型进行训练与预测。简单来说，Model.prepare()、Model.fit()、Model.evaluate()、Model.predict()都是由基础API封装而来。下面通过拆解高层API到基础API的方式，来了解如何用基础API完成模型的训练与预测。

• 概述

import paddle
from paddle.vision.transforms import ToTensor

train_dataset = paddle.vision.datasets.MNIST(mode='train', transform=ToTensor())
test_dataset = paddle.vision.datasets.MNIST(mode='test', transform=ToTensor())
lenet = paddle.vision.models.LeNet()
loss_fn = paddle.nn.CrossEntropyLoss()

# 加载训练集 batch_size 设为 64
train_loader = paddle.io.DataLoader(train_dataset, batch_size=64, shuffle=True)

def train():
    epochs = 2
    adam = paddle.optimizer.Adam(learning_rate=0.001, parameters=lenet.parameters())
    # 用Adam作为优化函数
    for epoch in range(epochs):
        for batch_id, data in enumerate(train_loader()):
            x_data = data[0]
            y_data = data[1]
            predicts = lenet(x_data)
            acc = paddle.metric.accuracy(predicts, y_data)
            loss = loss_fn(predicts, y_data)
            loss.backward()
            if batch_id % 100 == 0:
                print("epoch: {}, batch_id: {}, loss is: {}, acc is: {}".format(epoch, batch_id, loss.numpy(), acc.numpy()))
            adam.step()
            adam.clear_grad()

# 启动训练
train()

3.1 拆解Model.prepare()、Model.fit()-- 用基础API训练模型

飞桨框架通过基础API对模型进行训练与预测，对应第一部分的Model.prepare()与Model.fit()：

# dataset与mnist的定义与第一部分内容一致

# 用 DataLoader 实现数据加载
train_loader = paddle.io.DataLoader(train_dataset, batch_size=64, shuffle=True)

mnist.train()

# 设置迭代次数
epochs = 5

# 设置优化器
optim = paddle.optimizer.Adam(parameters=mnist.parameters())
# 设置损失函数
loss_fn = paddle.nn.CrossEntropyLoss()

for epoch in range(epochs):
    for batch_id, data in enumerate(train_loader()):

        x_data = data[0]            # 训练数据
        y_data = data[1]            # 训练数据标签
        predicts = mnist(x_data)    # 预测结果

        # 计算损失 等价于 prepare 中loss的设置
        loss = loss_fn(predicts, y_data)

        # 计算准确率 等价于 prepare 中metrics的设置
        acc = paddle.metric.accuracy(predicts, y_data)

        # 下面的反向传播、打印训练信息、更新参数、梯度清零都被封装到 Model.fit() 中

        # 反向传播
        loss.backward()

        if (batch_id+1) % 900 == 0:
            print("epoch: {}, batch_id: {}, loss is: {}, acc is: {}".format(epoch, batch_id+1, loss.numpy(), acc.numpy()))

        # 更新参数
        optim.step()

        # 梯度清零
        optim.clear_grad()

result:

epoch: 0, batch_id: 900, loss is: [0.29550618], acc is: [0.90625]
epoch: 1, batch_id: 900, loss is: [0.05875912], acc is: [0.984375]
epoch: 2, batch_id: 900, loss is: [0.05824642], acc is: [0.96875]
epoch: 3, batch_id: 900, loss is: [0.02940615], acc is: [1.]
epoch: 4, batch_id: 900, loss is: [0.05713747], acc is: [0.984375]

3.2 拆解Model.evaluate()-- 用基础API验证模型

飞桨框架通过基础API对模型进行验证，对应第一部分的Model.evaluate():

# 加载测试数据集
test_loader = paddle.io.DataLoader(test_dataset, batch_size=64, drop_last=True)
loss_fn = paddle.nn.CrossEntropyLoss()

mnist.eval()

for batch_id, data in enumerate(test_loader()):

    x_data = data[0]            # 测试数据
    y_data = data[1]            # 测试数据标签
    predicts = mnist(x_data)    # 预测结果

    # 计算损失与精度
    loss = loss_fn(predicts, y_data)
    acc = paddle.metric.accuracy(predicts, y_data)

    # 打印信息
    if (batch_id+1) % 30 == 0:
        print("batch_id: {}, loss is: {}, acc is: {}".format(batch_id+1, loss.numpy(), acc.numpy()))

result:

batch_id: 30, loss is: [0.15860887], acc is: [0.953125]
batch_id: 60, loss is: [0.21005578], acc is: [0.921875]
batch_id: 90, loss is: [0.0889321], acc is: [0.953125]
batch_id: 120, loss is: [0.00115552], acc is: [1.]
batch_id: 150, loss is: [0.12016675], acc is: [0.984375]

3.3 拆解Model.predict()-- 用基础API测试模型

飞桨框架通过基础API对模型进行测试，对应第一部分的Model.predict():

# 加载测试数据集
test_loader = paddle.io.DataLoader(test_dataset, batch_size=64, drop_last=True)

mnist.eval()
for batch_id, data in enumerate(test_loader()):
    x_data = data[0]
    predicts = mnist(x_data)
    # 获取预测结果
print("predict finished")

资源配置: 多卡启动、分布式训练

飞桨框架2.0增加paddle.distributed.spawn函数来启动单机多卡训练，同时原有的paddle.distributed.launch的方式依然保留。

一、launch启动

1.1 高层API场景

当调用paddle.Model高层API来实现训练时，想要启动单机多卡训练非常简单，代码不需要做任何修改，只需要在启动时增加一下参数-m paddle.distributed.launch。

# 单机单卡启动，默认使用第0号卡        不需要指定GPU运行,自动放到GPU ?   数据+模型 不用设置CUDA？ 
$ python train.py

# 单机多卡启动，默认使用当前可见的所有卡
$ python -m paddle.distributed.launch train.py

# 单机多卡启动，设置当前使用的第0号和第1号卡
$ python -m paddle.distributed.launch --gpus='0,1' train.py

# 单机多卡启动，设置当前使用第0号和第1号卡
$ export CUDA_VISIBLE_DEVICES=0,1
$ python -m paddle.distributed.launch train.py

1.2 基础API场景

如果使用基础API实现训练，想要启动单机多卡训练，需要对单机单卡的代码进行3处修改，具体如下：

import paddle
# 第1处改动 导入分布式训练所需的包
import paddle.distributed as dist

# 加载数据集
train_dataset = paddle.vision.datasets.MNIST(mode='train')
test_dataset = paddle.vision.datasets.MNIST(mode='test')

# 定义网络结构
mnist = paddle.nn.Sequential(
    paddle.nn.Flatten(1, -1),
    paddle.nn.Linear(784, 512),
    paddle.nn.ReLU(),
    paddle.nn.Dropout(0.2),
    paddle.nn.Linear(512, 10)
)

# 第2处改动，初始化并行环境
dist.init_parallel_env()

# 用 DataLoader 实现数据加载
train_loader = paddle.io.DataLoader(train_dataset, batch_size=32, shuffle=True)

# 第3处改动，增加paddle.DataParallel封装
mnist = paddle.DataParallel(mnist)
mnist.train()

# 设置迭代次数
epochs = 5

# 设置优化器
optim = paddle.optimizer.Adam(parameters=model.parameters())

for epoch in range(epochs):
    for batch_id, data in enumerate(train_loader()):

        x_data = data[0]            # 训练数据
        y_data = data[1]            # 训练数据标签
        predicts = mnist(x_data)    # 预测结果

        # 计算损失 等价于 prepare 中loss的设置
        loss = paddle.nn.functional.cross_entropy(predicts, y_data)

        # 计算准确率 等价于 prepare 中metrics的设置
        acc = paddle.metric.accuracy(predicts, y_data)

        # 下面的反向传播、打印训练信息、更新参数、梯度清零都被封装到 Model.fit() 中

        # 反向传播
        loss.backward()

        if (batch_id+1) % 1800 == 0:
            print("epoch: {}, batch_id: {}, loss is: {}, acc is: {}".format(epoch, batch_id, loss.numpy(), acc.numpy()))

        # 更新参数
        optim.step()

        # 梯度清零
        optim.clear_grad()

修改完后保存文件，然后使用跟高层API相同的启动方式即可。 注意： 单卡训练不支持调用init_parallel_env，请使用以下几种方式进行分布式训练。

# 单机多卡启动，默认使用当前可见的所有卡
$ python -m paddle.distributed.launch train.py

# 单机多卡启动，设置当前使用的第0号和第1号卡
$ python -m paddle.distributed.launch --gpus '0,1' train.py

# 单机多卡启动，设置当前使用第0号和第1号卡
$ export CUDA_VISIBLE_DEVICES=0,1
$ python -m paddle.distributed.launch train.py

二、spawn启动

launch方式启动训练，以文件为单位启动多进程，需要用户在启动时调用paddle.distributed.launch，对于进程的管理要求较高。飞桨框架2.0版本增加了spawn启动方式，可以更好地控制进程，在日志打印、训练退出时更友好。使用示例如下：

from __future__ import print_function

import paddle
import paddle.nn as nn
import paddle.optimizer as opt
import paddle.distributed as dist

class LinearNet(nn.Layer):
    def __init__(self):
        super(LinearNet, self).__init__()
        self._linear1 = nn.Linear(10, 10)
        self._linear2 = nn.Linear(10, 1)

    def forward(self, x):
        return self._linear2(self._linear1(x))

def train(print_result=False):

    # 1. 初始化并行训练环境
    dist.init_parallel_env()

    # 2. 创建并行训练 Layer 和 Optimizer
    layer = LinearNet()
    dp_layer = paddle.DataParallel(layer)

    loss_fn = nn.MSELoss()
    adam = opt.Adam(
        learning_rate=0.001, parameters=dp_layer.parameters())

    # 3. 运行网络
    inputs = paddle.randn([10, 10], 'float32')
    outputs = dp_layer(inputs)
    labels = paddle.randn([10, 1], 'float32')
    loss = loss_fn(outputs, labels)

    if print_result is True:
        print("loss:", loss.numpy())

    loss.backward()

    adam.step()
    adam.clear_grad()

# 使用方式1：仅传入训练函数
# 适用场景：训练函数不需要任何参数，并且需要使用所有当前可见的GPU设备并行训练
if __name__ == '__main__':
    dist.spawn(train)

# 使用方式2：传入训练函数和参数
# 适用场景：训练函数需要一些参数，并且需要使用所有当前可见的GPU设备并行训练
if __name__ == '__main__':
    dist.spawn(train, args=(True,))

# 使用方式3：传入训练函数、参数并指定并行进程数
# 适用场景：训练函数需要一些参数，并且仅需要使用部分可见的GPU设备并行训练，例如：
# 当前机器有8张GPU卡 {0,1,2,3,4,5,6,7}，此时会使用前两张卡 {0,1}；
# 或者当前机器通过配置环境变量 CUDA_VISIBLE_DEVICES=4,5,6,7，仅使4张
# GPU卡可见，此时会使用可见的前两张卡 {4,5}
if __name__ == '__main__':
    dist.spawn(train, args=(True,), nprocs=2)

# 使用方式4：传入训练函数、参数、指定进程数并指定当前使用的卡号
# 使用场景：训练函数需要一些参数，并且仅需要使用部分可见的GPU设备并行训练，但是
# 可能由于权限问题，无权配置当前机器的环境变量，例如：当前机器有8张GPU卡
# {0,1,2,3,4,5,6,7}，但你无权配置CUDA_VISIBLE_DEVICES，此时可以通过
# 指定参数 gpus 选择希望使用的卡，例如 gpus='4,5'，
# 可以指定使用第4号卡和第5号卡
if __name__ == '__main__':
    dist.spawn(train, nprocs=2, gpus='4,5')

相关API

设备篇

• 1.在GPU上,会自动使用GPU进行训练,使用单机单卡,如果不设定就是用 逻辑0卡。
• 2.在GPU上,高级模式、详细模式在命令行中的操作一致,并行 有两种启动方式,可以指定卡.
• 3.在GPU上,可以在命令中设置执行两种 并行训练方式。
• 4.在多卡并行中,data不需要to_gpu, 只需要dataparallel(model)就行了,其他地方不变。
• paddle.DataParallel(mninst), x.cpu() x.cudu(0).....
• 将数据转移到GPU: x.cuda() 、 place = CUDAPlace(0)、exe.run(place)、set_device(device)
• 注意: 分布式训练过程中 直接命令行改就行,代码中不要用 set_device()

⭐ paddle device 相关 6个

• 1.paddle.get_cudnn_vision() 返回cudnn的版本

  返回值是int，它表示cudnn版本。 例如，如果返回7600，则表示cudnn的版本为7.6。  
  device = paddle.get_cudnn_version()
  

• 2.paddle.is_compiled_with_cuda() 检查whl 包是否可以被用来在GPU上运行

  support_gpu = paddle.is_compiled_with_cuda()
  

• 3.paddle.is_compiled_with_xpu() 检查whl 包是否可以被用来在baidu kunlun 上运行模型

  support_xpu = paddle.is_compiled_with_xpu() 
  

• 4.paddle.get_device() 返回当前程序运行的全局设备

  该功能返回当前程序运行的全局设备，返回的是一个类似于 cpu 或者 gpu:0 字符串，   
  如果没有设置全局设备，当cuda可用的时候返回 gpu:0 ，当cuda不可用的时候返回 cpu 。
  
  device = paddle.get_device()
  

• 5.paddle.set_device(device) paddle支持包括CPU/GPU在内的多种设备运行,可以通过字符串标识符表示 设备，可以指定OP运行的全局设备，这一种吗?

  返回: 返回：Place, 设置的Place
  * device: str, 此参数确定特定的运行设备，它可以是 cpu、gpu、gpu:x、xpu 或者是 xpu:x,其中,x是GPU或者是XPU的编号。   
  当 device 是 cpu 的时候， 程序在CPU上运行， 当device是 gpu:x 的时候，程序在GPU上运行。
  
  paddle.set_device("cpu")
  paddle.set_device("gpu:0,1,2,3")      ??? 是这样吗?  
  

• 6.paddle.XPUPlace() 设备描述符,表示一个分配或者将要分配tensor的baidu kunlun XPU设备

???? framework 相关 14个

• 1.paddle.CPUPlace() 一个设备描述符，指定CPUPlace则Tensor将被自动分配在该设备上，并且模型将会运行在该设备上.

  cpu_place = paddle.CPUPlace()
  

• 2.paddle.CUDAPinnerPlace() 通过数据并行模型 执行静态图模型

  一个设备描述符，它所指代的页锁定内存由 CUDA 函数 cudaHostAlloc() 在主机内存上分配，主机的操作系统将不会对这块内存进行分页和交换操作，可以通过直接内存访问技术访问，加速主机和 GPU 之间的数据拷贝
  

• 3.paddle.CUDAPlace() 一个设备描述符，表示一个分配或将要分配 Tensor 或 LoDTensor 的 GPU 设备

  如果通过
  CUDAPlace 是一个设备描述符，表示一个分配或将要分配 Tensor 或 LoDTensor 的 GPU 设备。 每个 CUDAPlace 有一个 dev_id （设备id）来表明当前的 CUDAPlace 所代表的显卡编号，编号从 0 开始。 dev_id 不同的 CUDAPlace 所对应的内存不可相互访问。 这里编号指的是可见显卡的逻辑编号，而不是显卡实际的编号。 可以通过 CUDA_VISIBLE_DEVICES 环境变量限制程序能够使用的 GPU 设备，程序启动时会遍历当前的可见设备，并从 0 开始为这些设备编号。 如果没有设置 CUDA_VISIBLE_DEVICES，则默认所有的设备都是可见的，此时逻辑编号与实际编号是相同的。
  
  place = paddle.CUDAPlace(0)
  

• 4.类class paddle.DataParallel(layers, strategy=None, comm_buffer_size=25, last_comm_buffer_size=1) 通过数据并行模式执行动态图模型

  返回: 支持数据并行的 Layer, 返回类型: Layer类型  
  
  目前，DataParallel 仅支持以多进程的方式执行动态图模型。  
  支持两种使用方式:    
      1. 使用 paddle.distributed.spawn 方法启动, 例如: 
          ```
          python demo.py (spawn need to be called in __main__ method)
          ```
      2. 使用paddle.distributed.launch 方法启动,例如: 
          ```
          python -m paddle.distributed.launch –selected_gpus=0,1 demo.py
  
          其中 demo.py 脚本的代码可以是下面的示例代码。
          ```
  
  
  class LinearNet(nn.Layer):
      def __init__(self):
          super(LinearNet, self).__init__()
          self._linear1 = nn.Linear(10, 10)
          self._linear2 = nn.Linear(10, 1)
  
      def forward(self, x):
          return self._linear2(self._linear1(x))
  
  def train():
      # 1. initialize parallel environment
      dist.init_parallel_env()
  
      # 2. create data parallel layer & optimizer
      layer = LinearNet()
      dp_layer = paddle.DataParallel(layer)
  
      loss_fn = nn.MSELoss()
      adam = opt.Adam(
          learning_rate=0.001, parameters=dp_layer.parameters())
  
      # 3. run layer
      inputs = paddle.randn([10, 10], 'float32')
      outputs = dp_layer(inputs)
      labels = paddle.randn([10, 1], 'float32')
      loss = loss_fn(outputs, labels)
  
      loss.backward()
  
      adam.step()
      adam.clear_grad()
  
  if __name__ == '__main__':
      # 1. start by ``paddle.distributed.spawn`` (default)
      dist.spawn(train, nprocs=2)
      # 2. start by ``paddle.distributed.launch``
      # train()
  

  • 方法: state_dict ( destination=None, include_sublayers=True )

    返回：dict， 包含所有parameters和持久的buffers的dict
    获取当前层及其子层的所有parameters和持久的buffers。并将所有parameters和buffers存放在dict结构中。
    
    * destination (dict, 可选) - 如果提供 destination ，则所有参数和持久的buffers都将存放在 destination 中。 默认值：None。   
    * include_sublayers (bool, 可选) - 如果设置为True，则包括子层的参数和buffers。默认值：True。
    

  • set_state_dict ( state_dict, include_sublayers=True, use_structured_name=True )

    返回: 无
    根据传入的 state_dict 设置parameters和持久的buffers。 所有parameters和buffers将由 state_dict 中的 Tensor 设置。   
    
    * state_dict (dict) - 包含所有parameters和可持久性buffers的dict
    * include_sublayers (bool, 可选) - 如果设置为True，则还包括子Layer的parameters和buffers。 默认值：True   
    * use_structured_name (bool, 可选) - 如果设置为True，将使用Layer的结构性变量名作为dict的key，否则将使用Parameter或者Buffer的变量名作为key。默认值：True  
    

• 5.paddle.disable_static(place=None) 关闭静态图模式

  place (paddle.CPUPlace|paddle.CUDAPlace，可选) - 动态图运行时的设备。默认值为 None , 此时，会根据paddle的版本自动判断
  
  print(paddle.in_dynamiic_mode())    True， pp2.0默认动态图模式  
  paddle.enable_static()  
  print(paddle.in_dynamic_mode())        False, 已经开启静态图  
  
  paddle.disable_static()     
  print(paddle.in_dynamic_mode())         True，已经关闭静态图  
  

• 6.paddle.enable_static() 开启静态图模式

• 7.paddle.get_default_dtype() 得到当前全局的 dtype, 该初始值是 float32

  返回: string，这个全局dtype仅支持float16、float32、float64
  paddle.get_default_dtype()  
  

• 8.不懂 paddle.grad() 对于每个inputs, 计算所有 outputs相对于其的梯度和

• 9.paddle.in_dynamic_mode() 查看paddle 当前是否在动态图模式中

• 10.paddle.save(obj, path, pickle_protocol=2) 将对象实例obj保存到指定路径中。 【模型保存 & 导入】

• 11.paddle.load(path, **configs) 从指定路径载入可以在 paddle中使用的 对象实例。 【模型保存 & 导入】

• 12.paddle.ParamAttr() 创建一个参数属性对象
  class paddle.ParamAttr(name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, do_model_average=False, need_clip=True)
  ```
  返回: 表示参数属性的对象。

    类, 创建一个参数属性对象，用户可以设置参数的名称、初始化方式、学习率、正则化规则、是否需要训练、梯度裁剪方式、是否做模型平均等属性。   
    一般用在paddle.nn*  下面的模型初始化过程中,进行 类的实例化  
    * name: str,可选， 参数的名称。 默认值: None， 表示框架自动创建参数的名称。  
    * initializer: Initializer, 可选，参数的初始化方式， 默认:None,表示权重参数采用Xavier初始化方式,偏置参数全0   
    * learning_rate: float, 可选, 参数的学习率。  实际参数的学习率等于全局学习率乘以参数的学习率，再乘以learning rate schedule的系数。   
    * regularizer: 可选，正则化方法,支持两种正则化策略: api_paddle_regularizer_L1Decay 、 api_paddle_regularizer_L2Decay, 如果在 optimizer (例如 api_paddle_optimizer_SGD ) 中也 设置了正则化，optimizer 中的正则化将被忽略。默认值为None，表示没有正则化。      
    * trainanle: bool, 可选, 参数是否需要训练。 默认值为True.   
    * do_model_average: bool, 可选, 是否做模型平均， 默认值: True. 仅在 ExponentialMovingAverage 下使用。   
    * need_clip: bool, 可选, 参数是否进行梯度裁剪。 默认值True, 表示该参数的梯度会根据优化器中中设置的裁剪规则进行裁剪。   
  
    weight_attr = paddle.ParamAttr(name="weight",
                                    learning_rate=0.5,
                                    regularizer=paddle.regularizer.L2Decay(1.0),
                                    trainable=True)
    print(weight_attr.name) # "weight"
    paddle.nn.Linear(3, 4, weight_attr=weight_attr)
    ```
  

• 13.paddle.no_grad() 创建一个上下文来 禁止动态图梯度计算。

  在此模式下，每次计算的结果都将具有stop_gradient=True。也可以用作一个装饰器（需要创建实例对象作为装饰器）
  
  # 用作生成器
  data = np.array([[2, 3], [4, 5]]).astype('float32')
  l0 = paddle.nn.Linear(2, 2)  # l0.weight.gradient() is None
  l1 = paddle.nn.Linear(2, 2)
  with paddle.no_grad():
      # l1.weight.stop_gradient is False
      tmp = l1.weight * 2  # tmp.stop_gradient is True
  x = paddle.to_tensor(data)
  y = l0(x) + tmp
  o = l1(y)
  o.backward()
  print(tmp.gradient() is None)  # True
  print(l0.weight.gradient() is None)  # False
  
  # 用作装饰器
  @paddle.no_grad()
  def test_layer():
      inp = np.ones([3, 1024], dtype='float32')
      t = paddle.to_tensor(inp)
      linear1 = paddle.nn.Linear(1024, 4, bias_attr=False)
      linear2 = paddle.nn.Linear(4, 4)
      ret = linear1(t)
      dy_ret = linear2(ret)
  
  test_layer()
  

• 14.paddle.set_default_dtype() 设置默认的 全局dtype,默认的全局dtype最初是float32

  paddle.set_default_dtype("float32")