| 2.2 | 2.3.0 |
|---|---|
```python
>>> import paddle
>>> a = paddle.to_tensor([327])
>>> b = paddle.to_tensor([80])
>>> a / b
Tensor(shape=[1], dtype=int64, place=CUDAPlace(0), stop_gradient=True,
[4])
```
|
```python
>>> import paddle
>>> a = paddle.to_tensor([327])
>>> b = paddle.to_tensor([80])
>>> a / b
Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True,
[4.08750010])
```
|
| 2.2 | 2.3.0 |
|---|---|
```python
# elu(x) = max(0, x) + min(0, α ∗ (e^x − 1))
>>> import paddle
>>> x = paddle.to_tensor([-1., 6.])
>>> m = paddle.nn.ELU(-0.2)
>>> out = m(x)
>>> out
Tensor(shape=[2], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
[ 0. , -74.48576355])
>>> out = paddle.nn.functional.elu_(x, alpha=-0.2, name=None)
>>> out
Tensor(shape=[2], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
[ 0. , -74.48576355])
```
|
```python
# elu(x) = x, if x > 0
# elu(x) = α ∗ (e^x − 1), if x <= 0
>>> import paddle
>>> x = paddle.to_tensor([-1., 6.])
>>> m = paddle.nn.ELU(-0.2)
>>> out = m(x)
>>> out
Tensor(shape=[2], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
[0.12642412, 6. ])
>>> out = paddle.nn.functional.elu_(x, alpha=-0.2, name=None)
Traceback (most recent call last):
File "
|
| 2.2 | 2.3.0 |
|---|---|
```python
>>> import paddle
>>> a = paddle.to_tensor([327])
>>> b = paddle.to_tensor([80])
>>> a / b
Tensor(shape=[1], dtype=int64, place=CUDAPlace(0), stop_gradient=True,
[4])
```
|
```python
>>> import paddle
>>> a = paddle.to_tensor([327])
>>> b = paddle.to_tensor([80])
>>> a / b
Tensor(shape=[1], dtype=float32, place=Place(gpu:0), stop_gradient=True,
[4.08750010])
```
|
| 2.2 | 2.3.0 |
|---|---|
```python
# elu(x) = max(0, x) + min(0, α ∗ (e^x − 1))
>>> import paddle
>>> x = paddle.to_tensor([-1., 6.])
>>> m = paddle.nn.ELU(-0.2)
>>> out = m(x)
>>> out
Tensor(shape=[2], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
[ 0. , -74.48576355])
>>> out = paddle.nn.functional.elu_(x, alpha=-0.2, name=None)
>>> out
Tensor(shape=[2], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
[ 0. , -74.48576355])
```
|
```python
# elu(x) = x, if x > 0
# elu(x) = α ∗ (e^x − 1), if x <= 0
>>> import paddle
>>> x = paddle.to_tensor([-1., 6.])
>>> m = paddle.nn.ELU(-0.2)
>>> out = m(x)
>>> out
Tensor(shape=[2], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
[0.12642412, 6. ])
>>> out = paddle.nn.functional.elu_(x, alpha=-0.2, name=None)
Traceback (most recent call last):
File "
|
+ 报错分析：
Python 版本不匹配导致。用户使用的是 32 位 Python，但是对应的 32 位 pip 没有 PaddlePaddle 源。
+ 解决方法：
请用户使用 64 位的 Python 进行 PaddlePaddle 安装。
------
##### 问题： 本地使用 import paddle 时报错，`ModuleNotFoundError:No module named ‘paddle’`，如何解决？
+ 报错分析：
原因在于用户的计算机上可能安装了多个版本的 Python，而安装 PaddlePaddle 时的 Python 和`import paddle`时的 Python 版本不一致导致报错。如果用户熟悉 PyCharm 等常见的 IDE 配置包安装的方法，配置运行的方法，则可以避免此类问题。
+ 解决方法：
用户明确安装 Paddle 的 python 位置，并切换到该 python 进行安装。可能需要使用`python -m pip install paddlepaddle`命令确保 paddle 是安装到该 python 中。
------
##### 问题： 使用 PaddlePaddle GPU 的 Docker 镜像时报错， `Cuda Error: CUDA driver version is insufficient for CUDA runtime version`，如何解决？
+ 报错分析：
机器上的 CUDA 驱动偏低导致。
+ 解决方法：
需要升级 CUDA 驱动解决。
1. Ubuntu 和 CentOS 环境，需要把相关的驱动和库映射到容器内部。如果使用 GPU 的 docker 环境，需要用 nvidia-docker 来运行，更多请参考[nvidia-docker](https://github.com/NVIDIA/nvidia-docker)。
2. Windows 环境，需要升级 CUDA 驱动。
------
##### 问题： 使用 PaddlePaddle 时报错，`Error: no CUDA-capable device is detected`，如何解决？
+ 报错分析：
CUDA 安装错误导致。
+ 解决方法：
查找“libcudart.so”所在目录，并将其添加到`LD_LIBRARY_PATH`中。
例如：执行`find / -name libcudart.so`, 发现 libcudart.so 在`/usr/local/cuda-10.0/targets/x86_64-linux/lib/libcudart.so`路径下， 使用如下命令添加即可。
```bash
export LD_LIBRARY_PATH=/usr/local/cuda-10.0/targets/x86_64-linux/lib/libcudart.so:${LD_LIBRARY_PATH}
```
------
##### 问题： 如何升级 PaddlePaddle？
+ 答复：
1. GPU 环境：
```bash
pip install -U paddlepaddle-gpu
```
或者
```bash
pip install paddlepaddle-gpu==需要安装的版本号（如 2.0）
```
2. CPU 环境：
```bash
pip install -U paddlepaddle
```
或者
```bash
pip install paddlepaddle==需要安装的版本号（如 2.0）
```
------
##### 问题： 在 GPU 上如何选择 PaddlePaddle 版本？
+ 答复：
首先请确定你本机的 CUDA、cuDNN 版本，飞桨目前 pip 安装适配 CUDA 版本 9.0/10.0/10.1/10.2/11.0，CUDA9.0/10.0/10.1/10.2 配合 cuDNN v7.6.5+，CUDA 工具包 11.0 配合 cuDNN v8.0.4。请确定你安装的是适合的版本。更多安装信息见[官网安装文档](https://www.paddlepaddle.org.cn/install/quick?docurl=/documentation/docs/zh/2.0/install/pip/windows-pip.html)
------
##### 问题： import paddle 报错, dlopen: cannot load any more object with static TLS, 如何解决？
+ 答复：
glibc 版本过低，建议使用官方提供的 docker 镜像或者将 glibc 升级到 2.23+。
------
##### 问题： python2.7 中，如果使用 Paddle1.8.5 之前的版本，import paddle 时，报错，提示`/xxxx/rarfile.py, line820, print(f.filename, file=file), SyntaxError: invalid syntax`，如何解决？
+ 答复：
rarfile 版本太高，它的最新版本已经不支持 python2.x 了，可以通过`pip install rarfile==3.0`安装 3.0 版本的 rarfile 即可。
---
### Faq Others Cn (`docs/faq/others_cn.md`)
# 其他常见问题
##### 问题：使用 X2paddle 从 Caffe 转 Paddle model 时，报错 `TypeError: __new__() got an unexpected keyword argument 'serialized_options'` ，如何处理？
+ 答复：这是由于 ProtoBuf 版本较低导致，将 protobuf 升级到 3.6.0 即可解决。
----------
##### 问题：Windows 环境下，出现"Windows not support stack backtrace yet"，如何处理？
+ 答复：Windows 环境下，遇到程序报错不会详细跟踪内存报错内容。这些信息对底层开发者更有帮助，普通开发者不必关心这类警告。如果想得到完整内存追踪错误信息，可以尝试更换至 Linux 系统。
----------
---
### Faq Params Cn (`docs/faq/params_cn.md`)
# 参数调整常见问题
##### 问题：如何将本地数据传入`paddle.nn.embedding`的参数矩阵中？
+ 答复：需将本地词典向量读取为 NumPy 数据格式，然后使用`paddle.nn.initializer.Assign`这个 API 初始化`paddle.nn.embedding`里的`param_attr`参数，即可实现加载用户自定义（或预训练）的 Embedding 向量。
------
##### 问题：如何实现网络层中多个 feature 间共享该层的向量权重？
+ 答复：你可以使用`paddle.ParamAttr`并设定一个 name 参数，然后再将这个类的对象传入网络层的`param_attr`参数中，即将所有网络层中`param_attr`参数里的`name`设置为同一个，即可实现共享向量权重。如使用 embedding 层时，可以设置`param_attr=paddle.ParamAttr(name="word_embedding")`，然后把`param_attr`传入 embedding 层中。
----------
##### 问题：使用 optimizer 或 ParamAttr 设置的正则化和学习率，二者什么差异？
+ 答复：ParamAttr 中定义的`regularizer`优先级更高。若 ParamAttr 中定义了`regularizer`，则忽略 Optimizer 中的`regularizer`；否则，则使用 Optimizer 中的`regularizer`。ParamAttr 中的学习率默认为 1.0，在对参数优化时，最终的学习率等于 optimizer 的学习率乘以 ParamAttr 的学习率。
----------
##### 问题：如何导出指定层的权重，如导出最后一层的*weights*和*bias*？
+ 答复：
1. 在动态图中，使用`paddle.save` API， 并将最后一层的`layer.state_dict()` 传入至 save 方法的 obj 参数即可， 然后使用`paddle.load` 方法加载对应层的参数值。详细可参考 API 文档[save](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/save_cn.html#save) 和[load](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/load_cn.html#load)。
2. 在静态图中，使用`paddle.static.save_vars`保存指定的 vars，然后使用`paddle.static.load_vars`加载对应层的参数值。具体示例请见 API 文档：[load_vars](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/fluid/io/load_vars_cn.html) 和 [save_vars](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/fluid/io/save_vars_cn.html) 。
----------
##### 问题：训练过程中如何固定网络和 Batch Normalization（BN）？
+ 答复：
1. 对于固定 BN：设置 `use_global_stats=True`，使用已加载的全局均值和方差：`global mean/variance`，具体内容可查看官网 API 文档[batch_norm](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/nn/functional/batch_norm_cn.html#batch-norm)。
2. 对于固定网络层：如： stage1→ stage2 → stage3 ，设置 stage2 的输出，假设为*y*，设置 `y.stop_gradient=True`，那么， stage1→ stage2 整体都固定了，不再更新。
----------
##### 问题：训练的 step 在参数优化器中是如何变化的？
* 答复：
`step`表示的是经历了多少组 mini_batch，其统计方法为`exe.run`(对应 Program)运行的当前次数，即每运行一次`exe.run`，step 加 1。举例代码如下：
```python
# 执行下方代码后相当于 step 增加了 N x Epoch 总数
for epoch in range(epochs):
# 执行下方代码后 step 相当于自增了 N
for data in [mini_batch_1,2,3...N]:
# 执行下方代码后 step += 1
exe.run(data)
```
-----
##### 问题：如何修改全连接层参数，比如 weight，bias？
+ 答复：可以通过`param_attr`设置参数的属性，`paddle.ParamAttr(initializer=paddle.nn.initializer.Normal(0.0, 0.02), learning_rate=2.0)`，如果`learning_rate`设置为 0，该层就不参与训练。也可以构造一个 numpy 数据，使用`paddle.nn.initializer.Assign`来给权重设置想要的值。
-----
##### 问题：如何进行梯度裁剪？
+ 答复：Paddle 的梯度裁剪方式需要在[Optimizer](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/optimizer/Overview_cn.html#api)中进行设置，目前提供三种梯度裁剪方式，分别是[paddle.nn.ClipGradByValue](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/api/paddle/nn/ClipGradByValue_cn.html)`（设定范围值裁剪）`、[paddle.nn.ClipGradByNorm](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/api/paddle/nn/ClipGradByNorm_cn.html)`（设定 L2 范数裁剪）`
、[paddle.nn.ClipGradByGlobalNorm](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/api/paddle/nn/ClipGradByGlobalNorm_cn.html)`（通过全局 L2 范数裁剪）`，需要先创建一个该类的实例对象，然后将其传入到优化器中，优化器会在更新参数前，对梯度进行裁剪。
注：该类接口在动态图、静态图下均会生效，是动静统一的。目前不支持其他方式的梯度裁剪。
```python
linear = paddle.nn.Linear(10, 10)
clip = paddle.nn.ClipGradByNorm(clip_norm=1.0) # 可以选择三种裁剪方式
sdg = paddle.optimizer.SGD(learning_rate=0.1, parameters=linear.parameters(), grad_clip=clip)
sdg.step() # 更新参数前，会先对参数的梯度进行裁剪
```
[了解更多梯度裁剪知识](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/guides/01_paddle2.0_introduction/basic_concept/gradient_clip_cn.html)
----------
##### 问题：如何在同一个优化器中定义不同参数的优化策略，比如 bias 的参数 weight_decay 的值为 0.0，非 bias 的参数 weight_decay 的值为 0.01？
+ 答复：
1. [AdamW](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/optimizer/AdamW_cn.html#adamw)的参数`apply_decay_param_fun`可以用来选择哪些参数使用 decay_weight 策略。
2. 在创建`Param`的时候，可以通过设置[ParamAttr](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/ParamAttr_cn.html#paramattr)的属性来控制参数的属性。
----------
##### 问题：paddle fluid 如何自定义优化器，自定义更新模型参数的规则？
+ 答复：
1. 要定义全新优化器，自定义优化器中参数的更新规则，可以通过继承 fluid.Optimizer，重写_append_optimize_op 方法实现。不同优化器实现原理各不相同，一般流程是先获取 learning_rate，gradients 参数，可训练参数，以及该优化器自身特别需要的参数，然后实现更新参数的代码，最后返回更新后的参数。
在实现更新参数代码时，可以选择直接调用[paddle 的 API](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/index_cn.html)或者使用[自定义原生算子](https://www.paddlepaddle.org.cn/documentation/docs/zh/guides/07_new_op/index_cn.html)。在使用自定义原生算子时，要注意动态图与静态图调用方式有所区别：
需要首先使用`framework.in_dygraph_mode()`判断是否为动态图模式，如果是动态图模式，则需要调用`paddle._C_ops`中相应的优化器算子；如果不是动态图模式，则需要调用`block.append_op` 来添加优化器算子。
代码样例可参考[paddle 源码](https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/fluid/optimizer.py)中 AdamOptimizer 等优化器的实现。
2. 使用现有的常用优化器，可以在创建`Param`的时候，可以通过设置[ParamAttr](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/ParamAttr_cn.html#paramattr)的属性来控制参数的属性，可以通过设置`regularizer`，`learning_rate`等参数简单设置参数的更新规则。
---
### Faq Save Cn (`docs/faq/save_cn.md`)
# 模型保存常见问题
##### 问题：静态图的 save 接口与 save_inference_model 接口存储的结果有什么区别？
+ 答复：主要差别在于保存结果的应用场景：
1. save 接口（2.0 的`paddle.static.save`或者 1.8 的`fluid.io.save`）
该接口用于保存训练过程中的模型和参数，一般包括`*.pdmodel`，`*.pdparams`，`*.pdopt`三个文件。其中`*.pdmodel`是训练使用的完整模型 program 描述，区别于推理模型，训练模型 program 包含完整的网络，包括前向网络，反向网络和优化器，而推理模型 program 仅包含前向网络，`*.pdparams`是训练网络的参数 dict，key 为变量名，value 为 Tensor array 数值，`*.pdopt`是训练优化器的参数，结构与*.pdparams 一致。
2. save_inference_model 接口（2.0 的`paddle.static.save_inference_model`或者 1.8 的`fluid.io.save_inference_model`）
该接口用于保存推理模型和参数，2.0 的`paddle.static.save_inference_model`保存结果为`*.pdmodel`和`*.pdiparams`两个文件，其中`*.pdmodel`为推理使用的模型 program 描述，`*.pdiparams`为推理用的参数，这里存储格式与`*.pdparams`不同（注意两者后缀差个`i`），`*.pdiparams`为二进制 Tensor 存储格式，不含变量名。1.8 的`fluid.io.save_inference_model`默认保存结果为`__model__`文件，和以参数名为文件名的多个分散参数文件，格式与 2.0 一致。
3. 关于更多 2.0 动态图模型保存和加载的介绍可以参考教程：[模型存储与载入](https://www.paddlepaddle.org.cn/documentation/docs/zh/guides/02_paddle2.0_develop/08_model_save_load_cn.html)
----------
##### 问题：增量训练中，如何保存模型和恢复训练？
+ 答复：在增量训练过程中，不仅需要保存模型的参数，也需要保存优化器的参数。
具体地，在 2.0 版本中需要使用 Layer 和 Optimizer 的`state_dict`和`set_state_dict`方法配合`paddle.save/load`使用。简要示例如下：
```
import paddle
emb = paddle.nn.Embedding(10, 10)
layer_state_dict = emb.state_dict()
paddle.save(layer_state_dict, "emb.pdparams")
scheduler = paddle.optimizer.lr.NoamDecay(
d_model=0.01, warmup_steps=100, verbose=True)
adam = paddle.optimizer.Adam(
learning_rate=scheduler,
parameters=emb.parameters())
opt_state_dict = adam.state_dict()
paddle.save(opt_state_dict, "adam.pdopt")
load_layer_state_dict = paddle.load("emb.pdparams")
load_opt_state_dict = paddle.load("adam.pdopt")
emb.set_state_dict(para_state_dict)
adam.set_state_dict(opti_state_dict)
```
##### 问题：paddle.load 可以加载哪些 API 产生的结果呢？
+ 答复：
为了更高效地使用 paddle 存储的模型参数，`paddle.load`支持从除`paddle.save`之外的其他 save 相关 API 的存储结果中载入`state_dict`，但是在不同场景中，参数`path`的形式有所不同：
1. 从`paddle.static.save`或者`paddle.Model().save(training=True)`的保存结果载入：`path`需要是完整的文件名，例如`model.pdparams`或者`model.opt`；
2. 从`paddle.jit.save`或者`paddle.static.save_inference_model`或者`paddle.Model().save(training=False)`的保存结果载入：`path`需要是路径前缀， 例如`model/mnist`，`paddle.load`会从`mnist.pdmodel`和`mnist.pdiparams`中解析`state_dict`的信息并返回。
3. 从 paddle 1.x API`paddle.fluid.io.save_inference_model`或者`paddle.fluid.io.save_params/save_persistables`的保存结果载入：`path`需要是目录，例如`model`，此处 model 是一个文件夹路径。
需要注意的是，如果从`paddle.static.save`或者`paddle.static.save_inference_model`等静态图 API 的存储结果中载入`state_dict`，动态图模式下参数的结构性变量名将无法被恢复。在将载入的`state_dict`配置到当前 Layer 中时，需要配置`Layer.set_state_dict`的参数`use_structured_name=False`。
##### 问题：paddle.save 是如何保存 state_dict，Layer 对象，Tensor 以及包含 Tensor 的嵌套 list、tuple、dict 的呢？
+ 答复：
1. 对于``state_dict``保存方式与 paddle2.0 完全相同，我们将``Tensor``转化为``numpy.ndarray``保存。
2. 对于其他形式的包含``Tensor``的对象（``Layer``对象，单个``Tensor``以及包含``Tensor``的嵌套``list``、``tuple``、``dict``），在动态图中，将``Tensor``转化为``tuple(Tensor.name, Tensor.numpy())``;在静态图中，将``Tensor``直接转化为``numpy.ndarray``。之所以这样做，是因为当在静态图中使用动态保存的模型时，有时需要``Tensor``的名字因此将名字保存下来，同时，在``load``时区分这个``numpy.ndarray``是由 Tenosr 转化而来还是本来就是``numpy.ndarray``；保存静态图的``Tensor``时，通常通过``Variable.get_value``得到``Tensor``再使用``paddle.save``保存``Tensor``，此时，``Variable``是有名字的，这个``Tensor``是没有名字的，因此将静态图``Tensor``直接转化为``numpy.ndarray``保存。
> 此处动态图 Tensor 和静态图 Tensor 是不相同的，动态图 Tensor 有 name、stop_gradient 等属性；而静态图的 Tensor 是比动态图 Tensor 轻量级的，只包含 place 等基本信息，不包含名字等。
##### 问题：将 Tensor 转换为 numpy.ndarray 或者 tuple(Tensor.name, Tensor.numpy())不是惟一可译编码，为什么还要做这样的转换呢？
+ 答复：
1. 我们希望``paddle.save``保存的模型能够不依赖 paddle 框架就能够被用户解析（pickle 格式模型），这样用户可以方便的做调试，轻松的看到保存的参数的数值。其他框架的模型与 paddle 模型做转化也会容易很多。
2. 我们希望保存的模型尽量小，只保留了能够满足大多场景的信息（动态图保存名字和数值，静态图只保存数值），如果需要``Tensor``的其他信息（例如``stop_gradient``），可以向被保存的对象中添加这些信息，``load``之后再还原这些信息。这样的转换方式可以覆盖绝大多数场景，一些特殊场景也是可以通过一些方法解决的，如下面的问题。
##### 问题：什么情况下 save 与 load 的结果不一致呢，应该如何避免这种情况发生呢？
+ 答复：
以下情况会造成 save 与 load 的结果不一致:
1. 被保存的对象包含动态图``Tensor``同时包含``tuple(string, numpy.ndarray)``；
2. 被保存的对象包含静态图``Tensor``，同时包含``numpy.ndarray``或者``tuple(string, numpy.ndarray)``；
3. 被保存的对象只包含``numpy.ndarray``，但是包含``tuple(string, numpy.ndarray)``。
针对这些情况我们有以下建议：
1. 被保存的对象（包括``Layer``对象中的``ParamBase``）,避免包含形如``tuple(string, numpy.ndarray)``的对象；
2. 如果被保存的对象包含``numpy.ndarray``，尽量在``load``时设置``return_numpy = True``。
3. 对于``Layer``对象，只保存参数的值和名字，如果需要其他信息（例如``stop_gradient``），请将手将这些信息打包成`dict`等，一并保存。
##### 问题：paddle 2.x 如何保存模型文件？如何保存 paddle 1.x 中的 model 文件?
+ 答复：
1. 在 paddle2.x 可使用``paddle.jit.save``接口以及``paddle.static.save_inference_model``,通过指定``path``来保存成为``path.pdmodel``和``path.pdiparams``,可对应 paddle1.x 中使用``save_inference_model``指定 dirname 和 params_filename 生成``dirname/__model__``和``dirname/params 文件``。paddle2.x 保存模型文件详情可参考:
- [paddle.jit.save/load](https://www.paddlepaddle.org.cn/documentation/docs/zh/guides/02_paddle2.0_develop/08_model_save_load_cn.html#dongtaitumoxing-canshubaocunzairu-xunliantuili)
- [paddle.static.save/load_inference_model](https://www.paddlepaddle.org.cn/documentation/docs/zh/guides/02_paddle2.0_develop/08_model_save_load_cn.html#jingtaitumoxing-canshubaocunzairu-tuilibushu)
2. 如果想要在 paddle2.x 中读取 paddle 1.x 中的 model 文件，可参考:
- [兼容载入旧格式模型](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.2rc/guides/01_paddle2.0_introduction/load_old_format_model.html#cn-guides-load-old-format-model)
##### 问题：paddle 如何单独 load 存下来所有模型变量中某一个变量，然后修改变量中的值？
+ 答复：
1. 如果目的是修改存储变量的值，可以使用``paddle.save``保存下来所有变量，然后再使用``paddle.load``将所有变量载入后，查找目标变量进行修改，示例代码如下：
```python
import paddle
layer = paddle.nn.Linear(3, 4)
path = 'example/model.pdparams'
paddle.save(layer.state_dict(), path)
layer_param = paddle.load(path)
# 修改 fc_0.b_0 的值
layer_param["fc_0.b_0"] = 10
```
2. 如果目的是单独访问某个变量，需要单独存储然后再单独读取，示例代码如下：
```python
import paddle
layer = paddle.nn.Linear(3, 4)
path_w = 'example/weight.tensor'
path_b = 'example/bias.tensor'
paddle.save(layer.weight, path_w)
paddle.save(layer.bias, path_b)
tensor_bias = paddle.load(path_b)
tensor_bias[0] = 10
```
更多介绍请参考以下 API 文档：
- [paddle.save](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/save_cn.html#save)
- [paddle.load](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/load_cn.html#load)
---
### Faq Train Cn (`docs/faq/train_cn.md`)
# 组网、训练、评估常见问题
##### 问题：`stop_gradient=True`的影响范围？
+ 答复：如果静态图中某一层使用`stop_gradient=True`，那么这一层之前的层都会自动 `stop_gradient=True`，梯度不再回传。
----------
##### 问题：请问`paddle.matmul`和`paddle.multiply`有什么区别？
+ 答复：`matmul`支持的两个 tensor 的矩阵乘操作。`muliply`是支持两个 tensor 进行逐元素相乘。
----------
##### 问题：请问`paddle.gather`和`torch.gather`有什么区别？
+ 答复：[`paddle.gather`](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/gather_cn.html#gather)和`torch.gather`的函数签名分别为：
```python
paddle.gather(x, index, axis=None, name=None)
torch.gather(input, dim, index, *, sparse_grad=False, out=None)
```
其中，`paddle.gather`的参数`x`，`index`，`axis`分别与`torch.gather`的参数`input`，`index`，`dim`意义相同。
两者在输入形状、输出形状、计算公式等方面都有区别，具体如下：
- `paddle.gather`
- 输入形状：`x`可以是任意的`N`维 Tensor。但`index`必须是形状为`[M]`的一维 Tensor，或形状为`[M, 1]`的二维 Tensor。
- 输出形状：输出 Tensor `out`的形状`shape_out`和`x`的形状`shape_x`的关系为：`shape_out[i] = shape_x[i] if i != axis else M`。
- 计算公式：`out[i_1][i_2]...[i_axis]...[i_N] = x[i_1][i_2]...[index[i_axis]]...[i_N]` 。
- 举例说明：假设`x`的形状为`[N1, N2, N3]`，`index`的形状为`[M]`，`axis`的值为 1，那么输出`out`的形状为`[N1, M, N3]`，且`out[i_1][i_2][i_3] = x[i_1][index[i_2]][i_3]`。
- `torch.gather`
- 输入形状：`input`可以是任意的`N`维 Tensor，且`index.rank`必须等于`input.rank`。
- 输出形状：输出 Tensor `out`的形状与`index`相同。
- 计算公式：`out[i_1][i_2]...[i_dim]...[i_N] = input[i_1][i_2]...[index[i_1][i_2]...[i_N]]...[i_N]`。
- 举例说明：假设`x`的形状为`[N1, N2, N3]`，`index`的形状为`[M1, M2, M3]`，`dim`的值为 1，那么输出`out`的形状为`[M1, M2, M3]`，且`out[i_1][i_2][i_3] = input[i_1][index[i_1][i_2][i_3]][i_3]`。
- 异同比较
- 只有当`x.rank == 1`且`index.rank == 1`时，`paddle.gather`和`torch.gather`功能相同。其余情况两者无法直接互换使用。
- `paddle.gather`不支持`torch.gather`的`sparse_grad`参数。
----------
##### 问题：在模型组网时，inplace 参数的设置会影响梯度回传吗？经过不带参数的 op 之后，梯度是否会保留下来？
+ 答复：inplace 参数不会影响梯度回传。只要用户没有手动设置`stop_gradient=True`，梯度都会保留下来。
----------
##### 问题：如何不训练某层的权重？
+ 答复：在`ParamAttr`里设置`learning_rate=0`或`trainable`设置为`False`。具体请[参考文档](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/ParamAttr_cn.html#paramattr)
----------
##### 问题：使用 CPU 进行模型训练，如何利用多处理器进行加速？
+ 答复：在 2.0 版本动态图模式下，CPU 训练加速可以从以下两点进行配置：
1. 使用多进程 DataLoader 加速数据读取：训练数据较多时，数据处理往往会成为训练速度的瓶颈，paddle 提供了异步数据读取接口 DataLoader，可以使用多进程进行数据加载，充分利用多处理的优势，具体使用方法及示例请参考 API 文档：[paddle.io.DataLoader](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/io/DataLoader_cn.html#dataloader)。
2. 推荐使用支持[MKL（英特尔数学核心函数库）](https://software.intel.com/content/www/us/en/develop/tools/oneapi/components/onemkl.html)的 paddle 安装包，MKL 相比 Openblas 等通用计算库在计算速度上有显著的优势，能够提升您的训练效率。
----------
##### 问题：使用 NVIDIA 多卡运行 Paddle 时报错 Nccl error，如何解决？
+ 答复：这个错误大概率是环境配置不正确导致的，建议您使用 NVIDIA 官方提供的方法参考检测自己的环境是否配置正确。具体地，可以使用[ NCCL Tests ](https://github.com/NVIDIA/nccl-tests) 检测您的环境；如果检测不通过，请登录[ NCCL 官网 ](https://developer.nvidia.com/zh-cn)下载 NCCl，安装后重新检测。
----------
##### 问题：多卡训练时启动失败，`Error：Out of all 4 Trainers`，如何处理？
+ 问题描述：多卡训练时启动失败，显示如下信息：
+ 报错分析：主进程发现一号卡（逻辑）上的训练进程退出了。
+ 解决方法：查看一号卡上的日志，找出具体的出错原因。`paddle.distributed.launch` 启动多卡训练时，设置 `--log_dir` 参数会将每张卡的日志保存在设置的文件夹下。
----------
##### 问题：训练时报错提示显存不足，如何解决？
+ 答复：可以尝试按如下方法解决：
1. 检查是当前模型是否占用了过多显存，可尝试减小`batch_size` ；
2. 开启以下三个选项：
```bash
#一旦不再使用即释放内存垃圾，=1.0 垃圾占用内存大小达到 10G 时，释放内存垃圾
export FLAGS_eager_delete_tensor_gb=0.0
#启用快速垃圾回收策略，不等待 cuda kernel 结束，直接释放显存
export FLAGS_fast_eager_deletion_mode=1
#该环境变量设置只占用 0%的显存
export FLAGS_fraction_of_gpu_memory_to_use=0
```
详细请参考官方文档[存储分配与优化](https://www.paddlepaddle.org.cn/documentation/docs/zh/advanced_guide/performance_improving/singlenode_training_improving/memory_optimize.html) 调整相关配置。
此外，建议您使用[AI Studio 学习与 实训社区训练](https://aistudio.baidu.com/aistudio/index)，获取免费 GPU 算力，提升您的训练效率。
----------
##### 问题：如何提升模型训练时的 GPU 利用率？
+ 答复：有如下两点建议：
1. 如果数据预处理耗时较长，可使用 DataLoader 加速数据读取过程，具体请参考 API 文档：[paddle.io.DataLoader](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/io/DataLoader_cn.html#dataloader)。
2. 如果提高 GPU 计算量，可以增大`batch_size`，但是注意同时调节其他超参数以确保训练配置的正确性。
以上两点均为比较通用的方案，其他的优化方案和模型相关，可参考官方模型库 [models](https://github.com/PaddlePaddle/models) 中的具体示例。
----------
##### 问题：如何处理变长 ID 导致程序内存占用过大的问题？
+ 答复：请先参考[显存分配与优化文档](https://www.paddlepaddle.org.cn/documentation/docs/zh/advanced_guide/performance_improving/singlenode_training_improving/memory_optimize.html) 开启存储优化开关，包括显存垃圾及时回收和 Op 内部的输出复用输入等。若存储空间仍然不够，建议：
1. 降低 `batch_size` ；
2. 对 index 进行排序，减少 padding 的数量。
----------
##### 问题：训练过程中如果出现不收敛的情况，如何处理？
+ 答复：不收敛的原因有很多，可以参考如下方式排查：
1. 检查数据集中训练数据的准确率，数据是否有错误，特征是否归一化；
2. 简化网络结构，先基于 benchmark 实验，确保在 baseline 网络结构和数据集上的收敛结果正确；
3. 对于复杂的网络，每次只增加一个改动，确保改动后的网络正确；
4. 检查网络在训练数据上的 Loss 是否下降；
5. 检查学习率、优化算法是否合适，学习率过大会导致不收敛；
6. 检查`batch_size`设置是否合适，`batch_size`过小会导致不收敛；
7. 检查梯度计算是否正确，是否有梯度过大的情况，是否为`NaN`。
----------
##### 问题：Loss 为 NaN，如何处理？
+ 答复：可能由于网络的设计问题，Loss 过大（Loss 为 NaN）会导致梯度爆炸。如果没有改网络结构，但是出现了 NaN，可能是数据读取导致，比如标签对应关系错误。还可以检查下网络中是否会出现除 0，log0 的操作等。
----------
##### 问题：训练后的模型很大，如何压缩？
+ 答复：建议您使用飞桨模型压缩工具[PaddleSlim](https://www.paddlepaddle.org.cn/tutorials/projectdetail/489539)。PaddleSlim 是飞桨开源的模型压缩工具库，包含模型剪裁、定点量化、知识蒸馏、超参搜索和模型结构搜索等一系列模型压缩策略，专注于**模型小型化技术**。
----------
##### 问题：`load_inference_model`在加载预测模型时能否用`py_reader`读取？
+ 答复：目前`load_inference_model`加载进行的模型还不支持`py_reader`输入。
----------
##### 问题：预测时如何打印模型中每一步的耗时？
+ 答复：可以在设置 config 时使用`config.enable_profile()`统计预测时每个算子和数据搬运的耗时。对于推理 api 的使用，可以参考官网文档[Python 预测 API 介绍](https://www.paddlepaddle.org.cn/documentation/docs/zh/guides/05_inference_deployment/inference/python_infer_cn.html)。示例代码：
```python
# 设置 config:
def set_config(args):
config = Config(args.model_file, args.params_file)
config.disable_gpu()
# enable_profile()打开后会统计每一步耗时
config.enable_profile()
config.switch_use_feed_fetch_ops(False)
config.switch_specify_input_names(True)
config.switch_ir_optim(False)
return config
```
----------
##### 问题：模型训练时如何进行梯度裁剪？
+ 答复：设置 Optimizer 中的`grad_clip`参数值。
----------
##### 问题：静态图模型如何拿到某个 variable 的梯度？
+ 答复：飞桨提供以下三种方式，用户可根据需求选择合适的方法：
1. 使用[paddle.static.Print()](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/static/Print_cn.html#print)接口，可以打印中间变量及其梯度。
2. 将变量梯度名放到 fetch_list 里，通过[Executor.run()](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/static/Executor_cn.html#run)获取，一般 variable 的梯度名是 variable 的名字加上 "@GRAD"。
3. 对于参数（不适用于中间变量和梯度），还可以通过[Scope.find_var()](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/static/global_scope_cn.html#global-scope)接口，通过变量名字查找对应的 tensor。
后两个方法需要使用变量名，飞桨中变量的命名规则请参见[Name](https://www.paddlepaddle.org.cn/documentation/docs/zh/api_guides/low_level/program.html#api-guide-name) 。
```python
# paddlepaddle>=2.0
import paddle
import numpy as np
paddle.enable_static()
data = paddle.static.data('data', shape=[4, 2])
out = paddle.static.nn.fc(x=data, size=1, num_flatten_dims=1, name='fc')
loss = paddle.mean(out)
loss = paddle.static.Print(loss) # 通过 Print 算子打印中间变量及梯度
opt = paddle.optimizer.SGD(learning_rate=0.01)
opt.minimize(loss)
exe = paddle.static.Executor()
exe.run(paddle.static.default_startup_program())
loss, loss_g, fc_bias_g = exe.run(
paddle.static.default_main_program(),
feed={'data': np.random.rand(4, 2).astype('float32')},
fetch_list=[loss, loss.name + '@GRAD', 'fc.b_0@GRAD']) # 通过将变量名加入到 fetch_list 获取变量
print(loss, loss_g, fc_bias_g)
print(paddle.static.global_scope().find_var('fc.b_0').get_tensor()) # 通过 scope.find_var 获取变量
```
----------
##### 问题：paddle 有对应 torch.masked_fill 函数 api 吗，还是需要自己实现？
+ 答复：由于框架设计上的区别，没有对应的 api，但是可以使用 [paddle.where](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/where_cn.html) 实现相同的功能。
```python
# paddlepaddle >= 2.0
import paddle
paddle.seed(123)
x = paddle.rand([3, 3], dtype='float32')
# Tensor(shape=[3, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
# [[0.00276479, 0.45899123, 0.96637046],
# [0.66818708, 0.05855134, 0.33184195],
# [0.34202638, 0.95503175, 0.33745834]])
mask = paddle.randint(0, 2, [3, 3]).astype('bool')
# Tensor(shape=[3, 3], dtype=bool, place=CUDAPlace(0), stop_gradient=True,
# [[True , True , False],
# [True , True , True ],
# [True , True , True ]])
def masked_fill(x, mask, value):
y = paddle.full(x.shape, value, x.dtype)
return paddle.where(mask, y, x)
out = masked_fill(x, mask, 2)
# Tensor(shape=[3, 3], dtype=float32, place=CUDAPlace(0), stop_gradient=True,
# [[2. , 2. , 0.96637046],
# [2. , 2. , 2. ],
# [2. , 2. , 2. ]])
```
----------
##### 问题：在 paddle 中如何实现`torch.nn.utils.rnn.pack_padded_sequence`和`torch.nn.utils.rnn.pad_packed_sequence`这两个 API？
+ 答复：目前 paddle 中没有和上述两个 API 完全对应的实现。关于 torch 中这两个 API 的详细介绍可以参考知乎上的文章 [pack_padded_sequence 和 pad_packed_sequence](https://zhuanlan.zhihu.com/p/342685890) :
`pack_padded_sequence`的功能是将 mini-batch 数据进行压缩，压缩掉无效的填充值，然后输入 RNN 网络中；`pad_packed_sequence`则是把 RNN 网络输出的压紧的序列再填充回来，便于进行后续的处理。
在 paddle 中，大家可以在 GRU、LSTM 等 RNN 网络中输入含有填充值的 mini-batch 数据的同时传入对应的`sequence_length`参数实现上述等价功能，具体用法可以参考 [RNN](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/nn/RNN_cn.html#rnn) 。
----------
##### 问题：paddle 是否有爱因斯坦求和（einsum）这个 api？
+ 答复：paddle 在 2.2rc 版本之后，新增了[paddle.einsum](https://www.paddlepaddle.org.cn/documentation/docs/zh/develop/api/paddle/einsum_cn.html#einsum)，在 develop 和 2.2rc 之后的版本中都可以正常使用。
----------
----------
##### 问题：[BatchNorm](https://www.paddlepaddle.org.cn/documentation/docs/zh/api/paddle/nn/BatchNorm_cn.html#batchnorm)在训练时加载预测时保存的模型参数时报错 AssertionError: Optimizer set error, batch_norm_1.w_0_moment_0 should in state dict.
+ 答复：BatchNorm 在 train 模式和 eval 模式下需要的变量有差别，在 train 模式下要求传入优化器相关的变量，在 eval 模式下不管是保存参数还是加载参数都是不需要优化器相关变量的，因此如果在 train 模式下加载 eval 模式下保存的 checkpoint，没有优化器相关的变量则会报错。如果想在 train 模式下加载 eval 模式下保存的 checkpoint 的话，用 ```paddle.load``` 加载进来参数之后，通过 ```set_state_dict``` 接口把参数赋值给模型，参考以下示例：
```python
import paddle
bn = paddle.nn.BatchNorm(3)
bn_param = paddle.load('./bn.pdparams')
bn.set_state_dict()
```
----------
---
### Guides Index Cn (`docs/guides/index_cn.rst`)
########
使用指南
########
飞桨开源框架(PaddlePaddle)是一个易用、高效、灵活、可扩展的深度学习框架。
你可参考飞桨框架的 `Github
| 依赖包名称 | 版本 | 说明 | 安装命令 |
|---|---|---|---|
| CMake | 3.15, 3.16(推荐),3.17 | ||
| GCC (Linux Only) | 5.4 / 8.2 | 推荐使用 CentOS 的 devtools2 | |
| Clang (macOS Only) | 9.0 及以上 | 通常使用 macOS 10.11 及以上的系统对应的 Clang 版本即可 | |
| Python（64 bit） | 3.7+ | 依赖 libpython3.7+.so | 请访问Python 官网 |
| SWIG | 最低 2.0 | apt install swig 或 yum install swig |
|
| wget | any | apt install wget 或 yum install wget |
|
| openblas | any | 可选 | |
| pip | >=20.2.2 | apt install python-pip 或 yum install python-pip |
|
| numpy | >=1.12.0 | pip install numpy |
|
| protobuf | >=3.1.0 | pip install protobuf |
|
| wheel | any | pip install wheel |
|
| patchELF | any | apt install patchelf 或参见 github patchELF 官方文档 |
|
| go | >=1.8 | 可选 | |
| setuptools | >= 28.0.0 | ||
| unrar | brew install rar (For macOS), apt-get install unrar (For Ubuntu) |
| 选项 | 说明 | 默认值 |
|---|---|---|
| WITH_GPU | 是否支持 CUDA | ON |
| WITH_ROCM | 是否支持 ROCM | OFF |
| WITH_AVX | 是否编译含有 AVX 指令集的 PaddlePaddle 二进制文件 | ON |
| WITH_PYTHON | 是否内嵌 PYTHON 解释器 | ON |
| WITH_TESTING | 是否开启单元测试 | OFF |
| WITH_MKL | 是否使用 MKL 数学库，如果为否则是用 OpenBLAS | ON |
| WITH_SYSTEM_BLAS | 是否使用系统自带的 BLAS | OFF |
| WITH_DISTRIBUTE | 是否编译带有分布式的版本 | OFF |
| WITH_BRPC_RDMA | 是否使用 BRPC RDMA 作为 RPC 协议 | OFF |
| ON_INFER | 是否打开预测优化 | OFF |
| CUDA_ARCH_NAME | 是否只针对当前 CUDA 架构编译 | All:编译所有可支持的 CUDA 架构 可选：Auto 自动识别当前环境的架构编译 |
| TENSORRT_ROOT | 指定 TensorRT 路径 | Windows 下默认值为'/'，Linux 下默认值为 '/usr/' |
| 版本号 | 版本说明 |
|---|---|
| paddlepaddle==[版本号] 例如 paddlepaddle==2.2.1 | 只支持 CPU 对应版本的 PaddlePaddle，具体版本请参见Pypi |
| paddlepaddle-gpu==[版本号] 例如 paddlepaddle-gpu==2.2.1 | 默认安装支持 CUDA 10.2 和 cuDNN 7 的对应[版本号]的 PaddlePaddle 安装包 |
paddlepaddle-gpu==2.2.1 在 windows 环境下，会默认安装支持 CUDA 10.2 和 cuDNN 7 的对应[版本号]的 PaddlePaddle 安装包
## **多版本 whl 包列表-Release**
## **多版本 whl 包列表-develop**
# Appendix ## Compile Dependency Table
| Dependency package name | Version | Description | Installation command |
|---|---|---|---|
| CMake | 3.15, 3.16(Recommend),3.17 | ||
| GCC | 5.4 / 8.2 | recommends using devtools2 for CentOS | |
| Clang (macOS Only) | 9.0 and above | Usually use the clang version of macOS 10.11 and above | |
| Python（64 bit） | 3.7+ | depends on libpython3.7+.so | please go to Python official website |
| SWIG | at least 2.0 | apt install swig or yum install swig |
|
| wget | any | apt install wget or yum install wget |
|
| openblas | any | optional | |
| pip | at least 20.2.2 | apt install python-pip or yum install Python-pip |
|
| numpy | >=1.12.0 | pip install numpy |
|
| protobuf | >=3.1.0 | pip install protobuf |
|
| wheel | any | pip install wheel |
|
| patchELF | any | apt install patchelf or read github patchELF official documentation |
|
| go | >=1.8 | optional | |
| setuptools | >= 28.0.0 | ||
| unrar | brew install rar (For macOS), apt-get install unrar (For Ubuntu) |
| Option | Description | Default |
|---|---|---|
| WITH_GPU | Whether to support GPU | ON |
| WITH_AVX | whether to compile PaddlePaddle binaries file containing the AVX instruction set | ON |
| WITH_PYTHON | Whether the PYTHON interpreter is embedded | ON |
| WITH_TESTING | Whether to turn on unit test | OFF |
| WITH_MKL | Whether to use the MKL math library, if not,using OpenBLAS | ON |
| WITH_SYSTEM_BLAS | Whether to use the system's BLAS | OFF |
| WITH_DISTRIBUTE | Whether to Compile with distributed version | OFF |
| WITH_BRPC_RDMA | Whether to use BRPC RDMA as RPC protocol | OFF |
| ON_INFER | Whether to turn on prediction optimization | OFF |
| CUDA_ARCH_NAME | Compile only for current CUDA schema or not | All:Compile all supported CUDA architectures optional: Auto automatically recognizes the schema compilation of the current environment |
| TENSORRT_ROOT | Specify TensorRT path | The default value under windows is '/', The default value under windows is '/usr/' |
| Version Number | Release Discription |
|---|---|
| paddlepaddle==[version code] such as paddlepaddle==2.2.1 | Only support the corresponding version of the CPU PaddlePaddle, please refer to Pypi for the specific version. |
| paddlepaddle-gpu==[version code], such as paddlepaddle-gpu==2.2.1 | The default installation supports the PaddlePaddle installation package corresponding to [version number] of CUDA 10.2 and cuDNN 7 |
paddlepaddle-gpu==2.2.1 will install the installation package of PaddlePaddle that supports CUDA 10.2 and cuDNN 7 by default under Windows environment.
## **Multi-version whl package list - Release**
## **Multi-version whl package list - dev**