Skip to content

F
FluidDoc

PaddlePaddle / FluidDoc

通知 10
Star 2
Fork 0
F
FluidDoc
未验证 提交 cb4f4929 编写于 作者: L lujun 提交者： GitHub
浏览文件
操作

Merge pull request #1 from PaddlePaddle/develop 

update
上级 37fd49da 97dcf6e5
显示空白变更内容
内联 并排
Showing with 20504 addition and 631 deletion
.gitmodules
浏览文件 @ cb4f4929
[submodule "external/Paddle"]
path = external/Paddle
url = https://github.com/PaddlePaddle/Paddle
[submodule "external/book"] [submodule "external/book"]
path = external/book path = external/book
url = https://github.com/PaddlePaddle/book url = https://github.com/PaddlePaddle/book
[submodule "external/Anakin"]
path = external/Anakin
url = https://github.com/PaddlePaddle/Anakin
[submodule "external/paddle-mobile"]
path = external/paddle-mobile
url = https://github.com/PaddlePaddle/paddle-mobile
[submodule "external/Paddle"]
path = external/Paddle
url = https://github.com/PaddlePaddle/Paddle
[submodule "external/models"] [submodule "external/models"]
path = external/models path = external/models
url = https://github.com/PaddlePaddle/models url = https://github.com/PaddlePaddle/models
doc/fluid/advanced_usage/deploy/anakin_gpu_benchmark.md → doc/fluid/advanced_usage/deploy/anakin/anakin_gpu_benchmark.md
浏览文件 @ cb4f4929
...@@ -30,21 +30,19 @@ ...@@ -30,21 +30,19 @@
| BatchSize | TensorRT | Anakin | | BatchSize | TensorRT | Anakin |
| --- | --- | --- | | --- | --- | --- |
| 1 | 8.8690 | 8.2815 | | 1 | 8.53945 | 8.18737 |
| 2 | 15.5344 | 13.9116 | | 2 | 14.2269 | 13.8976 |
| 4 | 26.6000 | 21.8747 | | 4 | 24.2803 | 21.7976 |
| 8 | 49.8279 | 40.4076 | | 8 | 45.6003 | 40.319 |
| 32 | 188.6270 | 163.7660 |
- GPU Memory Used (`MB`) - GPU Memory Used (`MB`)
| BatchSize | TensorRT | Anakin | | BatchSize | TensorRT | Anakin |
| --- | --- | --- | | --- | --- | --- |
| 1 | 963 | 997 | | 1 | 1053.88 | 762.73 |
| 2 | 965 | 1039 | | 2 | 1055.71 | 762.41 |
| 4 | 991 | 1115 | | 4 | 1003.22 | 832.75 |
| 8 | 1067 | 1269 | | 8 | 1108.77 | 926.9 |
| 32 | 1715 | 2193 |
### <span id = '2'>Yolo </span> ### <span id = '2'>Yolo </span>
...@@ -53,21 +51,19 @@ ...@@ -53,21 +51,19 @@
| BatchSize | TensorRT | Anakin | | BatchSize | TensorRT | Anakin |
| --- | --- | --- | | --- | --- | --- |
| 1 | 16.4596| 15.2124 | | 1 | 8.41606| 7.07977 |
| 2 | 26.6347| 25.0442 | | 2 | 16.6588| 15.2216 |
| 4 | 43.3695| 43.5017 | | 4 | 31.9955| 30.5102 |
| 8 | 80.9139 | 80.9880 | | 8 | 66.1107 | 64.3658 |
| 32 | 293.8080| 310.8810 |
- GPU Memory Used (`MB`) - GPU Memory Used (`MB`)
| BatchSize | TensorRT | Anakin | | BatchSize | TensorRT | Anakin |
| --- | --- | --- | | --- | --- | --- |
| 1 | 1569 | 1775 | | 1 | 1054.71 | 299.8 |
| 2 | 1649 | 1815 | | 2 | 951.51 | 347.47 |
| 4 | 1709 | 1887 | | 4 | 846.9 | 438.47 |
| 8 | 1731 | 2031 | | 8 | 1042.31 | 515.15 |
| 32 | 2253 | 2907 |
### <span id = '3'> Resnet50 </span> ### <span id = '3'> Resnet50 </span>
...@@ -75,21 +71,19 @@ ...@@ -75,21 +71,19 @@
| BatchSize | TensorRT | Anakin | | BatchSize | TensorRT | Anakin |
| --- | --- | --- | | --- | --- | --- |
| 1 | 4.2459 | 4.1061 | | 1 | 4.10063 | 3.33845 |
| 2 | 6.2627 | 6.5159 | | 2 | 6.10941 | 5.54814 |
| 4 | 10.1277 | 11.3327 | | 4 | 9.90233 | 10.2763 |
| 8 | 17.8209 | 20.6680 | | 8 | 17.3287 | 20.0783 |
| 32 | 65.8582 | 77.8858 |
- GPU Memory Used (`MB`) - GPU Memory Used (`MB`)
| BatchSize | TensorRT | Anakin | | BatchSize | TensorRT | Anakin |
| --- | --- | --- | | --- | --- | --- |
| 1 | 531 | 503 | | 1 | 1059.15 | 299.86 |
| 2 | 543 | 517 | | 2 | 1077.8 | 340.78 |
| 4 | 583 | 541 | | 4 | 903.04 | 395 |
| 8 | 611 | 589 | | 8 | 832.53 | 508.86 |
| 32 | 809 | 879 |
### <span id = '4'> Resnet101 </span> ### <span id = '4'> Resnet101 </span>
...@@ -97,21 +91,19 @@ ...@@ -97,21 +91,19 @@
| BatchSize | TensorRT | Anakin | | BatchSize | TensorRT | Anakin |
| --- | --- | --- | | --- | --- | --- |
| 1 | 7.5562 | 7.0837 | | 1 | 7.29828 | 5.672 |
| 2 | 11.6023 | 11.4079 | | 2 | 11.2037 | 9.42352 |
| 4 | 18.3650 | 20.0493 | | 4 | 17.9306 | 18.0936 |
| 8 | 32.7632 | 36.0648 | | 8 | 31.4804 | 35.7439 |
| 32 | 123.2550 | 135.4880 |
- GPU Memory Used (`MB)` - GPU Memory Used (`MB)`
| BatchSize | TensorRT | Anakin | | BatchSize | TensorRT | Anakin |
| --- | --- | --- | | --- | --- | --- |
| 1 | 701 | 683 | | 1 | 1161.94 | 429.22 |
| 2 | 713 | 697 | | 2 | 1190.92 | 531.92 |
| 4 | 793 | 721 | | 4 | 994.11 | 549.7 |
| 8 | 819 | 769 | | 8 | 945.47 | 653.06 |
| 32 | 1043 | 1059 |
### <span id = '5'> MobileNet V1 </span> ### <span id = '5'> MobileNet V1 </span>
...@@ -119,21 +111,19 @@ ...@@ -119,21 +111,19 @@
| BatchSize | TensorRT | Anakin | | BatchSize | TensorRT | Anakin |
| --- | --- | --- | | --- | --- | --- |
| 1 | 45.5156 | 1.3947 | | 1 | 1.52692 | 1.39282 |
| 2 | 46.5585 | 2.5483 | | 2 | 1.98091 | 2.05788 |
| 4 | 48.4242 | 4.3404 | | 4 | 3.2705 | 4.03476 |
| 8 | 52.7957 | 8.1513 | | 8 | 5.15652 | 7.06651 |
| 32 | 83.2519 | 31.3178 |
- GPU Memory Used (`MB`) - GPU Memory Used (`MB`)
| BatchSize | TensorRT | Anakin | | BatchSize | TensorRT | Anakin |
| --- | --- | --- | | --- | --- | --- |
| 1 | 329 | 283 | | 1 | 1144.35 | 99.6 |
| 2 | 345 | 289 | | 2 | 1160.03 | 199.75 |
| 4 | 371 | 299 | | 4 | 1098 | 184.33 |
| 8 | 393 | 319 | | 8 | 990.71 | 232.11 |
| 32 | 531 | 433 |
### <span id = '6'> MobileNet V2</span> ### <span id = '6'> MobileNet V2</span>
...@@ -141,21 +131,20 @@ ...@@ -141,21 +131,20 @@
| BatchSize | TensorRT | Anakin | | BatchSize | TensorRT | Anakin |
| --- | --- | --- | | --- | --- | --- |
| 1 | 65.6861 | 2.9842 | | 1 | 1.95961 | 1.78249 |
| 2 | 66.6814 | 4.7472 | | 2 | 2.8709 | 3.01144 |
| 4 | 69.7114 | 7.4163 | | 4 | 4.46131 | 5.43946 |
| 8 | 76.1092 | 12.8779 | | 8 | 7.161 | 10.2081 |
| 32 | 124.9810 | 47.2142 |
- GPU Memory Used (`MB`) - GPU Memory Used (`MB`)
| BatchSize | TensorRT | Anakin | | BatchSize | TensorRT | Anakin |
| --- | --- | --- | | --- | --- | --- |
| 1 | 341 | 293 | | 1 | 1154.69 | 195.25 |
| 2 | 353 | 301 | | 2 | 1187.25 | 227.6 |
| 4 | 385 | 319 | | 4 | 1053 | 241.75 |
| 8 | 421 | 351 | | 8 | 1062.48 | 352.18 |
| 32 | 637 | 551 |
## How to run those Benchmark models ## How to run those Benchmark models
......
doc/fluid/advanced_usage/deploy/anakin_tutorial.md → doc/fluid/advanced_usage/deploy/anakin/anakin_tutorial.md
浏览文件 @ cb4f4929
...@@ -114,15 +114,15 @@ Anakin中数据类型与基本数据类型的对应如下: ...@@ -114,15 +114,15 @@ Anakin中数据类型与基本数据类型的对应如下:
理论上，Anakin支持申明1维以上的tensor，但是对于Anakin中的Op来说，只支持NW、NHW、NCHW、NCHW_C4这四种LayOut，其中NCHW是默认的LayOuteType，NCHW_C4是专门针对于int8这种数据类型的。 理论上，Anakin支持申明1维以上的tensor，但是对于Anakin中的Op来说，只支持NW、NHW、NCHW、NCHW_C4这四种LayOut，其中NCHW是默认的LayOuteType，NCHW_C4是专门针对于int8这种数据类型的。
**例子：** 例子
下面的代码将展示如何使用tensor， 我们建议先看看这些示例。 下面的代码将展示如何使用tensor， 我们建议先看看这些示例。
要想获得更多关于tensor的信息， 请参考 *soure_path/core/tensor.h* 要想获得更多关于tensor的信息， 请参考 *soure_path/core/tensor.h*
1. 使用shape对象初始化tensor > 1. 使用shape对象初始化tensor
```cpp ```c++
//create a null tensor. A null tensor holds for nothing. //create a null tensor. A null tensor holds for nothing.
//tensor's buffer is resident at CPU and its datatype is AK_FLOAT. //tensor's buffer is resident at CPU and its datatype is AK_FLOAT.
//tensor's Layout is NCHW(default) //tensor's Layout is NCHW(default)
...@@ -136,7 +136,7 @@ Anakin中数据类型与基本数据类型的对应如下: ...@@ -136,7 +136,7 @@ Anakin中数据类型与基本数据类型的对应如下:
Shape shape2(N, C, H, W); // batch x channel x height x width Shape shape2(N, C, H, W); // batch x channel x height x width
``` ```
`注意：Shape的维度必须和tensor的`[LayoutType](#layout)`相同，比如Shape(N,C,H,W), 那么Tensor的 LayoutType必须是NCHW，否则会出错。如下列代码所示` >`注意：Shape的维度必须和tensor的`[LayoutType](#layout)`相同，比如Shape(N,C,H,W), 那么Tensor的 LayoutType必须是NCHW，否则会出错。如下列代码所示`
```c++ ```c++
// A 4-D tensor. // A 4-D tensor.
...@@ -147,11 +147,13 @@ Anakin中数据类型与基本数据类型的对应如下: ...@@ -147,11 +147,13 @@ Anakin中数据类型与基本数据类型的对应如下:
Tensor<X86, AK_FLOAT, NHW> mytensor4(shape2); //wrong!! shape's dimetion must be equal to tensor's Layout. Tensor<X86, AK_FLOAT, NHW> mytensor4(shape2); //wrong!! shape's dimetion must be equal to tensor's Layout.
Tensor<NV, AK_FLOAT, NCHW_C4> mytensor5(shape2); //wrong!!!! Tensor<NV, AK_FLOAT, NCHW_C4> mytensor5(shape2); //wrong!!!!
``` ```
2. 使用现有的数据和shape初始化tensor > 2. 使用现有的数据和shape初始化tensor
```c++ ```c++
/** /**
* A construtor of Tensor. * A construtor of Tensor.
* data_ptr is a pointer to any data type of data * data_ptr is a pointer to any data type of data
...@@ -163,15 +165,16 @@ Anakin中数据类型与基本数据类型的对应如下: ...@@ -163,15 +165,16 @@ Anakin中数据类型与基本数据类型的对应如下:
//using existing data feed to a tensor //using existing data feed to a tensor
Tensor<X86, AK_FLOAT> mytensor(data_ptr, TargetType, device_id, shape); //shape must has dimention (N, C, H, W). Tensor<X86, AK_FLOAT> mytensor(data_ptr, TargetType, device_id, shape); //shape must has dimention (N, C, H, W).
``` ```
3. 使用tensor初始化tensor > 3. 使用tensor初始化tensor
```c++ ```c++
Tensor<NV, AK_FLOAT> tensor(exist_tensor); Tensor<NV, AK_FLOAT> tensor(exist_tensor);
``` ```
>提示： 你可以用` typedef Tensor<X86, AK_FLOAT> Tensor4d_X86 `方便定义tensor > 提示： 你可以用` typedef Tensor<X86, AK_FLOAT> Tensor4d_X86 `方便定义tensor
#### 填充tensor数据区 #### 填充tensor数据区
......
doc/fluid/advanced_usage/deploy/index_anakin.rst → doc/fluid/advanced_usage/deploy/anakin/index_cn.rst
浏览文件 @ cb4f4929
...@@ -13,6 +13,7 @@ Anakin 预测引擎 ...@@ -13,6 +13,7 @@ Anakin 预测引擎
anakin_tutorial.md anakin_tutorial.md
anakin_run_on_arm.md anakin_run_on_arm.md
anakin_example.md anakin_example.md
int8_design_anakin.md
anakin_gpu_benchmark.md anakin_gpu_benchmark.md
anakin_arm_benchmark.md anakin_arm_benchmark.md
......
doc/fluid/advanced_usage/deploy/index_cn.rst 0 → 100644
浏览文件 @ cb4f4929
########
预测部署
########
- `原生预测引擎 <inference/index_cn.html>`_ ：介绍了支持模型部署上线的Fluid C++ API
- `移动端部署 <mobile/index_cn.html>`_：介绍了 PaddlePaddle组织下的嵌入式平台深度学习框架Paddle-Mobile
.. toctree::
:hidden:
inference/index_cn.rst
mobile/index_cn.rst
doc/fluid/advanced_usage/deploy/index_mobile.rst 已删除 100644 → 0
浏览文件 @ 37fd49da
移动端部署
##########
.. toctree::
:maxdepth: 2
mobile_readme.md
mobile_build.md
doc/fluid/user_guides/howto/inference/build_and_install_lib_cn.rst → doc/fluid/advanced_usage/deploy/inference/build_and_install_lib_cn.rst
浏览文件 @ cb4f4929
...@@ -22,18 +22,18 @@ cuda9.0_cudnn7_avx_mkl `fluid_inference.tgz <https://guest:@paddleci.ngrok.io/ ...@@ -22,18 +22,18 @@ cuda9.0_cudnn7_avx_mkl `fluid_inference.tgz <https://guest:@paddleci.ngrok.io/
---------- ----------
用户也可以从 PaddlePaddle 核心代码编译C++预测库，只需在编译时配制下面这些编译选项： 用户也可以从 PaddlePaddle 核心代码编译C++预测库，只需在编译时配制下面这些编译选项：
================= ========= ============================ =========
选项 值 选项 值
================= ========= ============================ =========
CMAKE_BUILD_TYPE Release CMAKE_BUILD_TYPE Release
FLUID_INFERENCE_INSTALL_DIR 安装路径 FLUID_INFERENCE_INSTALL_DIR 安装路径
WITH_FLUID_ONLY ON（推荐） WITH_FLUID_ONLY ON（推荐）
WITH_SWIG_PY OFF（推荐 WITH_SWIG_PY OFF（推荐）
WITH_PYTHON OFF（推荐） WITH_PYTHON OFF（推荐）
ON_INFER ON（推荐）
WITH_GPU ON/OFF WITH_GPU ON/OFF
WITH_MKL ON/OFF WITH_MKL ON/OFF
ON_INFER ON（预测优化） ============================ =========
================= =========
建议按照推荐值设置，以避免链接不必要的库。其它可选编译选项按需进行设定。 建议按照推荐值设置，以避免链接不必要的库。其它可选编译选项按需进行设定。
...@@ -67,7 +67,12 @@ ON_INFER ON（预测优化） ...@@ -67,7 +67,12 @@ ON_INFER ON（预测优化）
├── CMakeCache.txt ├── CMakeCache.txt
├── paddle ├── paddle
│   ├── include │   ├── include
│   │   └── paddle_inference_api.h │   │   ├── paddle_anakin_config.h
│   │   ├── paddle_analysis_config.h
│   │   ├── paddle_api.h
│   │   ├── paddle_inference_api.h
│   │   ├── paddle_inference_pass.h
│   │   └── paddle_pass_builder.h
│   └── lib │   └── lib
│   ├── libpaddle_fluid.a │   ├── libpaddle_fluid.a
│   └── libpaddle_fluid.so │   └── libpaddle_fluid.so
...@@ -80,10 +85,12 @@ ON_INFER ON（预测优化） ...@@ -80,10 +85,12 @@ ON_INFER ON（预测优化）
│   └── install │   └── install
│   ├── gflags │   ├── gflags
│   ├── glog │   ├── glog
│   ├── mkldnn
│   ├── mklml │   ├── mklml
│   ├── protobuf │   ├── protobuf
│   ├── snappy │   ├── snappy
│   ├── snappystream │   ├── snappystream
│   ├── xxhash
│   └── zlib │   └── zlib
└── version.txt └── version.txt
...@@ -91,9 +98,9 @@ version.txt 中记录了该预测库的版本信息，包括Git Commit ID、使 ...@@ -91,9 +98,9 @@ version.txt 中记录了该预测库的版本信息，包括Git Commit ID、使
.. code-block:: text .. code-block:: text
GIT COMMIT ID: 23da8defc8314b0c711130c1d9536e2cf2fb8414 GIT COMMIT ID: cc9028b90ef50a825a722c55e5fda4b7cd26b0d6
WITH_MKL: ON WITH_MKL: ON
WITH_MKLDNN: OFF WITH_MKLDNN: ON
WITH_GPU: ON WITH_GPU: ON
CUDA version: 8.0 CUDA version: 8.0
CUDNN version: v5 CUDNN version: v5
doc/fluid/user_guides/howto/inference/index.rst → doc/fluid/advanced_usage/deploy/inference/index_cn.rst
浏览文件 @ cb4f4929
############ ############
预测部署 原生预测引擎
############ ############
PaddlePaddle Fluid 提供了 C++ API 来支持模型的部署上线 PaddlePaddle Fluid 提供了 C++ API 来支持模型的部署上线
.. toctree:: .. toctree::
:maxdepth: 2 :hidden:
build_and_install_lib_cn.rst build_and_install_lib_cn.rst
native_infer.md native_infer.md
paddle_tensorrt_infer.md paddle_tensorrt_infer.md
paddle_gpu_benchmark.md
windows_cpp_inference.md windows_cpp_inference.md
doc/fluid/user_guides/howto/inference/native_infer.md → doc/fluid/advanced_usage/deploy/inference/native_infer.md
浏览文件 @ cb4f4929
# Paddle 预测 API # C++ 预测 API介绍
为了更简单方便的预测部署，Fluid 提供了一套高层 API 用来隐藏底层不同的优化实现。 为了更简单方便的预测部署，Fluid 提供了一套高层 API 用来隐藏底层不同的优化实现。
......
doc/fluid/advanced_usage/deploy/inference/paddle_gpu_benchmark.md 0 → 100644
浏览文件 @ cb4f4929
# TensorRT库性能测试
## 测试环境
- CPU:Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz GPU:Tesla P4
- TensorRT4.0, CUDA8.0, CUDNNV7
- 测试模型 ResNet50，MobileNet，ResNet101, Inception V3.
## 测试对象
**PaddlePaddle, Pytorch, Tensorflow**
- 在测试中，PaddlePaddle使用子图优化的方式集成了TensorRT, 模型[地址](https://github.com/PaddlePaddle/models/tree/develop/fluid/PaddleCV/image_classification/models)。
- Pytorch使用了原生的实现, 模型[地址1](https://github.com/pytorch/vision/tree/master/torchvision/models)、[地址2](https://github.com/marvis/pytorch-mobilenet)。
- 对TensorFlow测试包括了对TF的原生的测试，和对TF—TRT的测试，**对TF—TRT的测试并没有达到预期的效果，后期会对其进行补充**， 模型[地址](https://github.com/tensorflow/models)。
### ResNet50
|batch_size|PaddlePaddle(ms)|Pytorch(ms)|TensorFlow(ms)|
|---|---|---|---|
|1|4.64117 |16.3|10.878|
|5|6.90622| 22.9 |20.62|
|10|7.9758 |40.6|34.36|
### MobileNet
|batch_size|PaddlePaddle(ms)|Pytorch(ms)|TensorFlow(ms)|
|---|---|---|---|
|1| 1.7541 | 7.8 |2.72|
|5| 3.04666 | 7.8 |3.19|
|10|4.19478 | 14.47 |4.25|
### ResNet101
|batch_size|PaddlePaddle(ms)|Pytorch(ms)|TensorFlow(ms)|
|---|---|---|---|
|1|8.95767| 22.48 |18.78|
|5|12.9811 | 33.88 |34.84|
|10|14.1463| 61.97 |57.94|
### Inception v3
|batch_size|PaddlePaddle(ms)|Pytorch(ms)|TensorFlow(ms)|
|---|---|---|---|
|1|15.1613 | 24.2 |19.1|
|5|18.5373 | 34.8 |27.2|
|10|19.2781| 54.8 |36.7|
doc/fluid/user_guides/howto/inference/paddle_tensorrt_infer.md → doc/fluid/advanced_usage/deploy/inference/paddle_tensorrt_infer.md
浏览文件 @ cb4f4929
# 使用Paddle TensorRT预测 # 使用TensorRT库预测
NVIDIA TensorRT 是一个高性能的深度学习预测库，可为深度学习推理应用程序提供低延迟和高吞吐量。Paddle 1.0 采用了子图的形式对TensorRT进行了初步集成，即我们可以使用该模块来提升Paddle模型的预测性能。该模块依旧在持续开发中，目前已支持的模型有：AlexNet, MobileNet, ResNet50, VGG19, ResNext, Se-ReNext, GoogleNet, DPN, ICNET, MobileNet-SSD等。在这篇文档中，我们将会对Paddle-TensorRT库的获取、使用和原理进行介绍。 NVIDIA TensorRT 是一个高性能的深度学习预测库，可为深度学习推理应用程序提供低延迟和高吞吐量。Paddle 1.0 采用了子图的形式对TensorRT进行了初步集成，即我们可以使用该模块来提升Paddle模型的预测性能。该模块依旧在持续开发中，目前已支持的模型有：AlexNet, MobileNet, ResNet50, VGG19, ResNext, Se-ReNext, GoogleNet, DPN, ICNET, MobileNet-SSD等。在这篇文档中，我们将会对Paddle-TensorRT库的获取、使用和原理进行介绍。
......
doc/fluid/user_guides/howto/inference/windows_cpp_inference.md → doc/fluid/advanced_usage/deploy/inference/windows_cpp_inference.md
浏览文件 @ cb4f4929
Windows环境模型预测使用说明 Windows环境模型预测
=========================== ===========================
环境部署 环境部署
...@@ -9,78 +9,49 @@ Windows环境模型预测使用说明 ...@@ -9,78 +9,49 @@ Windows环境模型预测使用说明
测试环境硬件配置： 测试环境硬件配置：
| CPU | I7-8700K | | CPU | I7-8700K |
|----------|:-------------:| |:---------|:-------------------|
| 内存 | 16G | | 内存 | 16G |
| 硬盘 | 1T hdd + 256G ssd | | 硬盘 | 1T hdd + 256G ssd |
| 显卡 | GTX1080 8G | | 显卡 | GTX1080 8G |
测试环境操作系统使用win10 Version 18.03 版本。下载地址： 测试环境操作系统使用 win10 家庭版本。
### 环境配置步骤 ### 环境配置步骤
**一定要严格按照安装步骤顺序，否则会安装失败！** **请您严格按照以下步骤进行安装，否则可能会导致安装失败！**
**安装vs2015** **安装Visual Studio 2015 update3**
安装vs2015，安装选项中选择安装内容时勾选自定义，把关于c，c++，vc++的功能都安装上。下载地址： 安装Visual Studio 2015，安装选项中选择安装内容时勾选自定义，选择安装全部关于c，c++，vc++的功能。
**安装CUDA8**
需要去NVIDIA官网[https://www.geforce.cn/drivers](https://www.geforce.cn/drivers)
下载显卡对应的驱动。推荐391版本
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/user_guides/howto/inference/image/image1.png" >
</p>
安装时需要勾选自定义，勾选安装全部。
验证安装需要进入cmd中，输入nvcc -V查看。
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/user_guides/howto/inference/image/image2.png">
</p>
如果有显卡安装驱动，也可以选择直接安装CUDA8.0，[https://developer.nvidia.com/cuda-80-ga2-download-archive](https://developer.nvidia.com/cuda-80-ga2-download-archive)
**安装CUDNN**
安装CUDNN只需要将文件中CUDNN
7下的文件复制到对应的CUDA安装目录下。文件名，cudnn-8.0-windows10-x64-v7.zip。这里提供了cudnn
7
64位的版本。需要其他版本可在[https://developer.nvidia.com/cudnn](https://developer.nvidia.com/cudnn)
下载。
预测demo使用 预测demo使用
------------ ------------
解压Paddle，Release，fluid\_install\_dir压缩包。 解压Paddle，Release，fluid_install_dir压缩包。
进入Paddle/paddle/fluid/inference/api/demo\_ci目录，新建build目录并进入，然后使用cmake生成vs2015的solution文件。 进入Paddle/paddle/fluid/inference/api/demo_ci目录，新建build目录并进入，然后使用cmake生成vs2015的solution文件。
指令为： 指令为：
```cmake
cmake .. -G \"Visual Studio 14 2015 Win64\" -DWITH\_GPU=ON `cmake .. -G "Visual Studio 14 2015 Win64" -DWITH_GPU=OFF -DWITH_MKL=OFF -DWITH_STATIC_LIB=ON -DCMAKE_BUILD_TYPE=Release -DDEMO_NAME=simple_on_word2vec -DPADDLE_LIB=path_to_the_patddle\paddle_fluid.lib`
-DWITH\_MKL=OFF -DWITH\_STATIC\_LIB=ON -DCMAKE\_BUILD\_TYPE=Release
-DDEMO\_NAME=simple\_on\_word2vec
-DPADDLE\_LIB=D:\\to\_the\_paddle\_fluid.lib
-DCUDA\_LIB=D:\\CUDA\\v8.0\\lib\\x64
```
注： 注：
-DDEMO\_NAME 是要编译的文件 -DDEMO_NAME 是要编译的文件
-DPADDLE\_LIB 是fluid\_install\_dir路径，例如 -DPADDLE_LIB 是fluid_install_dir路径，例如
-DPADDLE\_LIB=D:\\fluid\_install\_dir -DPADDLE_LIB=D:\fluid_install_dir
-DCUDA\_LIB 是CUDA安装目录对应的文件夹
Cmake可以在官网进行下载，并添加到环境变量中。[[https://cmake.org/download/]{.underline}](https://cmake.org/download/) Cmake可以在[官网进行下载](https://cmake.org/download/)，并添加到环境变量中。
执行完毕后，build目录如图所示，打开 箭头指向的solution文件： 执行完毕后，build 目录如图所示，打开箭头指向的 solution 文件：
<p align="center"> <p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/user_guides/howto/inference/image/image3.png"> <img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/user_guides/howto/inference/image/image3.png">
</p> </p>
修改编译属性为/MT： 修改编译属性为 `/MT` ：
<p align="center"> <p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/user_guides/howto/inference/image/image4.png"> <img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/user_guides/howto/inference/image/image4.png">
...@@ -90,7 +61,7 @@ Cmake可以在官网进行下载，并添加到环境变量中。[[https://cmake ...@@ -90,7 +61,7 @@ Cmake可以在官网进行下载，并添加到环境变量中。[[https://cmake
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/user_guides/howto/inference/image/image5.png"> <img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/user_guides/howto/inference/image/image5.png">
</p> </p>
编译生成选项改成Release。 编译生成选项改成 `Release` 。
<p align="center"> <p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/user_guides/howto/inference/image/image6.png"> <img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/user_guides/howto/inference/image/image6.png">
...@@ -110,17 +81,13 @@ Cmake可以在官网进行下载，并添加到环境变量中。[[https://cmake ...@@ -110,17 +81,13 @@ Cmake可以在官网进行下载，并添加到环境变量中。[[https://cmake
1. 开启GLOG 1. 开启GLOG
set GLOG\_v=3 `set GLOG_v=100`
2. 进行预测 2. 进行预测
simple\_on\_word2vec.exe \--dirname=.\\word2vec.inference.model `simple_on_word2vec.exe --dirname=.\word2vec.inference.model`
<p align="center"> <p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/user_guides/howto/inference/image/image9.png"> <img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/user_guides/howto/inference/image/image9.png">
</p> </p>
**FAQ：**
路径中尽量不要包含空格，例如发现CUDA\_LIB路径是Program
Files(x86)可能会出错。可以将CUDA拷贝到一个新位置（这里直接拷贝就行）
doc/fluid/advanced_usage/deploy/mobile/index_cn.rst 0 → 100644
浏览文件 @ cb4f4929
##########
移动端部署
##########
本模块介绍了 PaddlePaddle 组织下的嵌入式平台深度学习框架——Paddle-Mobile，包括：
* `项目简介 <mobile_readme.html>`_：简要介绍了 Paddle-Mobile 的应用效果，特点以及使用说明
* `环境搭建 <mobile_build.html>`_：分别介绍如何在Docker和非Docker下搭建环境
.. toctree::
:hidden:
mobile_readme.md
mobile_build.md
doc/fluid/advanced_usage/deploy/mobile_build.md → doc/fluid/advanced_usage/deploy/mobile/mobile_build.md
浏览文件 @ cb4f4929
# 环境搭建 # 环境搭建
## 使用 docker ## 使用 docker
### 1. 安装 docker ### 1. 安装 docker
安装 docker 的方式，参考官方文档 [https://docs.docker.com/install/](https://docs.docker.com/install/) 安装 docker 的方式，参考 [官方文档](https://docs.docker.com/install/)
### 2. 使用 docker 搭建构建环境 ### 2. 使用 docker 搭建构建环境
首先进入 paddle-mobile 的目录下，执行 `docker build` 首先进入 paddle-mobile 的目录下，执行 `docker build`
以 Linux/Mac 为例 (windows 建议在 'Docker Quickstart Terminal' 中执行) 以 Linux/Mac 为例 (windows 建议在 'Docker Quickstart Terminal' 中执行)
......
doc/fluid/advanced_usage/deploy/mobile_readme.md → doc/fluid/advanced_usage/deploy/mobile/mobile_readme.md
浏览文件 @ cb4f4929
...@@ -33,13 +33,11 @@ ...@@ -33,13 +33,11 @@
开发文档主要是关于编译、运行等问题。作为开发者，它可以和贡献文档共同结合使用 开发文档主要是关于编译、运行等问题。作为开发者，它可以和贡献文档共同结合使用
[iOS](https://github.com/PaddlePaddle/paddle-mobile/blob/develop/doc/development_ios.md) * [iOS](https://github.com/PaddlePaddle/paddle-mobile/blob/develop/doc/development_ios.md)
* [Android_CPU](https://github.com/PaddlePaddle/paddle-mobile/blob/develop/doc/development_android.md)
[Android](https://github.com/PaddlePaddle/paddle-mobile/blob/develop/doc/development_android.md) * [Android_GPU](https://github.com/PaddlePaddle/paddle-mobile/blob/develop/doc/development_android_GPU.md)
* [FPGA](https://github.com/PaddlePaddle/paddle-mobile/blob/develop/doc/development_fpga.md)
[FPGA](https://github.com/PaddlePaddle/paddle-mobile/blob/develop/doc/development_fpga.md) * [ARM_LINUX](https://github.com/PaddlePaddle/paddle-mobile/blob/develop/doc/development_arm_linux.md)
[ARM_LINUX](https://github.com/PaddlePaddle/paddle-mobile/blob/develop/doc/development_arm_linux.md)
### 贡献代码 ### 贡献代码
...@@ -71,10 +69,6 @@ ONNX全称为“Open Neural Network Exchange”，即“开放的神经网络切 ...@@ -71,10 +69,6 @@ ONNX全称为“Open Neural Network Exchange”，即“开放的神经网络切
[下载链接](http://mms-graph.bj.bcebos.com/paddle-mobile%2FmodelsAndImages.zip) [下载链接](http://mms-graph.bj.bcebos.com/paddle-mobile%2FmodelsAndImages.zip)
如下gif是简单搜索app的线上主体检测应用效果
![ezgif-1-050a733dfb](http://otkwwi4x8.bkt.clouddn.com/2018-07-05-ezgif-1-050a733dfb.gif)
## 问题解决 ## 问题解决
欢迎提出或解决我们的问题，有疑问可以发[Issue](https://github.com/PaddlePaddle/paddle-mobile/issues) 欢迎提出或解决我们的问题，有疑问可以发[Issue](https://github.com/PaddlePaddle/paddle-mobile/issues)
...@@ -85,3 +79,4 @@ Paddle-Mobile 提供相对宽松的Apache-2.0开源协议 [Apache-2.0 license](L ...@@ -85,3 +79,4 @@ Paddle-Mobile 提供相对宽松的Apache-2.0开源协议 [Apache-2.0 license](L
## 旧版 Mobile-Deep-Learning ## 旧版 Mobile-Deep-Learning
原MDL(Mobile-Deep-Learning)工程被迁移到了这里 [Mobile-Deep-Learning](https://github.com/allonli/mobile-deep-learning) 原MDL(Mobile-Deep-Learning)工程被迁移到了这里 [Mobile-Deep-Learning](https://github.com/allonli/mobile-deep-learning)
doc/fluid/user_guides/design_idea/fluid_design_idea.md → doc/fluid/advanced_usage/design_idea/fluid_design_idea.md
浏览文件 @ cb4f4929
# Fluid设计思想 # 设计思想
## 简介 ## 简介
...@@ -17,7 +17,7 @@ Fluid使用一种编译器式的执行流程，分为编译时和运行时两个 ...@@ -17,7 +17,7 @@ Fluid使用一种编译器式的执行流程，分为编译时和运行时两个
本地训练任务执行流程图如下所示： 本地训练任务执行流程图如下所示：
<p align="center"> <p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/user_guides/design_idea/image/fluid_process.png" width=800> <img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/design_idea/image/fluid_process.png" width=800>
</p> </p>
1. 编译时，用户编写一段python程序，通过调用 Fluid 提供的算子，向一段 Program 中添加变量（Tensor）以及对变量的操作（Operators 或者 Layers）。用户只需要描述核心的前向计算，不需要关心反向计算、分布式下以及异构设备下如何计算。 1. 编译时，用户编写一段python程序，通过调用 Fluid 提供的算子，向一段 Program 中添加变量（Tensor）以及对变量的操作（Operators 或者 Layers）。用户只需要描述核心的前向计算，不需要关心反向计算、分布式下以及异构设备下如何计算。
...@@ -153,7 +153,7 @@ Executor 在运行时将接受一个`ProgramDesc`、一个`block_id`和一个`Sc ...@@ -153,7 +153,7 @@ Executor 在运行时将接受一个`ProgramDesc`、一个`block_id`和一个`Sc
完成的编译执行的具体过程如下图所示： 完成的编译执行的具体过程如下图所示：
<p align="center"> <p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/user_guides/design_idea/image/executor_design.png" width=600> <img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/design_idea/image/executor_design.png" width=600>
</p> </p>
1. Executor 为每一个block创建一个Scope，Block是可嵌套的，因此Scope也是可嵌套的 1. Executor 为每一个block创建一个Scope，Block是可嵌套的，因此Scope也是可嵌套的
...@@ -359,5 +359,5 @@ Fluid使用Executor.run来运行一段Program。 ...@@ -359,5 +359,5 @@ Fluid使用Executor.run来运行一段Program。
[6.099215 ]], dtype=float32), array([1.6935859], dtype=float32)] [6.099215 ]], dtype=float32), array([1.6935859], dtype=float32)]
``` ```
至此您已经了解了Fluid 内部的执行流程的核心概念，更多框架使用细节请参考[使用指南](../../user_guides/index.html)相关内容，[模型库](../../user_guides/models/index.html 至此您已经了解了Fluid 内部的执行流程的核心概念，更多框架使用细节请参考[使用指南](../../user_guides/index.html)相关内容，[模型库](../../user_guides/models/index_cn.html
)中也为您提供了丰富的模型示例以供参考。 )中也为您提供了丰富的模型示例以供参考。
doc/fluid/advanced_usage/development/contribute_to_paddle/index_cn.rst
浏览文件 @ cb4f4929
######## ############
如何贡献代码 如何贡献代码
######## ############
.. toctree:: .. toctree::
:maxdepth: 2 :maxdepth: 1
local_dev_guide.md local_dev_guide.md
submit_pr_guide.md submit_pr_guide.md
doc/fluid/advanced_usage/development/new_op.md 已删除 120000 → 0
浏览文件 @ 37fd49da
../../dev/new_op_cn.md
\ No newline at end of file
doc/fluid/advanced_usage/development/new_op/index_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#############
新增operator
#############
- `如何写新的operator <../../../advanced_usage/development/new_op.html>`_ ：介绍如何在 Fluid 中添加新的 Operator
- `op相关的一些注意事项 <../../../advanced_usage/development/op_notes.html>`_ ：介绍op相关的一些注意事项
.. toctree::
:hidden:
new_op_cn.md
op_notes.md
doc/fluid/advanced_usage/development/new_op/new_op_cn.md 0 → 120000
浏览文件 @ cb4f4929
../../../dev/new_op_cn.md
\ No newline at end of file
doc/fluid/advanced_usage/development/new_op/op_notes.md 0 → 100644
浏览文件 @ cb4f4929
# op相关的一些注意事项
## Fluid中Op的构建逻辑
### 1.Fluid中Op的构建逻辑
Fluid中所有的Op都继承自`OperatorBase`，且所有的Op都是无状态的，每个Op包含的成员变量只有四个：type、inputs、outputs、attribute。
Op的核心方法是Run，Run方法需要两方面的资源：数据资源和计算资源，这两个资源分别通过`Scope`和`Place`获取。框架内部有一个全局的`DeviceContextPool`，用来记录`Place`和`DeviceContext`之间的对应的关系，即每个`Place`有且仅有一个`DeviceContext`与之对应，`DeviceContext`中存放了当前设备的计算资源。比如对于GPU，这些资源包括`cudnn_handle`、`cublas_handle`、`stream`等，Op内部所有的计算（数据拷贝和CUDA Kernel等）都必须在`DeviceContext`中进行。
Fluid框架的设计理念是可以在多种设备及第三方库上运行，有些Op的实现可能会因为设备或者第三方库的不同而不同。为此，Fluid引入了OpKernel的方式，即一个Op可以有多个OpKernel，这类Op继承自`OperatorWithKernel`，这类Op的代表是conv，conv_op的OpKerne有：`GemmConvKernel`、`CUDNNConvOpKernel`、`ConvMKLDNNOpKernel`，且每个OpKernel都有double和float两种数据类型。不需要OpKernel的代表有`WhileOp`等。
Operator继承关系图：
![op_inheritance_relation_diagram](../../pics/op_inheritance_relation_diagram.png)
进一步了解可参考：[multi_devices](https://github.com/PaddlePaddle/FluidDoc/tree/develop/doc/fluid/design/multi_devices)，[scope](https://github.com/PaddlePaddle/FluidDoc/blob/develop/doc/fluid/design/concepts/scope.md)，[Developer's_Guide_to_Paddle_Fluid](https://github.com/PaddlePaddle/FluidDoc/blob/develop/doc/fluid/getstarted/Developer's_Guide_to_Paddle_Fluid.md)
### 2.Op的注册逻辑
每个Operator的注册项包括：
```C++
OpCreator creator_;
GradOpMakerFN grad_op_maker_;
proto::OpProto* proto_{nullptr};
OpAttrChecker* checker_{nullptr};
InferVarTypeFN infer_var_type_;
InferShapeFN infer_shape_;
```
<table>
<thead>
<tr>
<th>注册项</th>
<th>类型</th>
<th>说明</th>
<th>调用</th>
</tr>
</thead>
<tbody>
<tr>
<td>proto::OpProto </td>
<td>Class </td>
<td>存放Op的输入/输出/属性/Op类型 </td>
<td>编译时调用 </td>
</tr>
<tr>
<td>GradOpMakerFN </td>
<td>Functor </td>
<td>返回当前Op对应的反向Op的一组OpDesc，因为正向Op的反向可能有多个Op构成 </td>
<td>编译时调用 </td>
</tr>
<tr>
<td>OpAttrChecker </td>
<td>Class </td>
<td>对Op的attr进行check </td>
<td>编译时调用</td>
</tr>
<tr>
<td>InferVarTypeFN </td>
<td>Functor </td>
<td>用于推断输出Var的Type，比如是LoDTensor还是SelectedRows，或者其他 </td>
<td>编译时调用 </td>
</tr>
<tr>
<td>InferShapeFN </td>
<td>Functor </td>
<td>用于推断Output的Shape </td>
<td>分为编译时和运行时，编译时是在Python端调用；如果Op继承自OperatorWithKernel，运行时是在op.run时调用 </td>
</tr>
<tr>
<td>OpCreator </td>
<td>Functor </td>
<td>每次调用都会创建一个新的OperatorBase </td>
<td>运行时调用 </td>
</tr>
</tbody>
</table>
通常Op注释时需要调用REGISTER_OPERATOR，即：
```
REGISTER_OPERATOR(op_type,
OperatorBase
op_maker_and_checker_maker,
op_grad_opmaker,
op_infer_var_shape,
op_infer_var_type)
```
**注意：**
1. 对于所有Op，前三个参数是必须的，op_type指明op的名字，OperatorBase是该Op的对象，op_maker_and_checker_maker是op的maker和op中attr的checker。
2. 如果该Op有反向，则必须要有op_grad_opmaker，因为在backward会根据正向的Op中获取反向Op的Maker。
3. 框架提供了一个默认的op_grad_opmaker：`DefaultGradOpDescMaker`，这个Maker会将前向Op的输入和输出都作为反向Op的输入，将前向Op的输入的梯度作为反向Op的输出，并将前向Op的属性拷贝过来。**注意：**DefaultGradOpDescMaker会将前向Op的所有输入输出都做反向Op的输入，即使这个输入是没有必要的，这将会导致无法对没有用到的变量做内存优化。
4. 框架没有提供默认的op_infer_var_shape方法。如果该Op是无OpKernel的，通常需要用户添加对应的op_infer_var_shape方法；如果该Op是有OpKernel的，需要实现`OperatorWithKernel`中的`InferShape`方法，此时不需要提供op_infer_var_shape方法。具体实现可参考[while_op.cc](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/operators/controlflow/while_op.cc)，[conv_op.cc](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/operators/conv_op.cc)。
5. 框架没有提供默认的op_infer_var_type方法，用户需要根据实际情况添加op_infer_var_shape。严格来说每个Op都应该注册一个InferVarType，op_infer_var_type根据输入的Var的type和dtype推断输出Var的type和dtype。**注意：**在Python端的LayerHelper中create_variable_for_type_inference操作返回的Variable里面是LoDTensor，C++端的InferVarType可以修改`Variable`的type和dtype。
更多内容请参考: [如何写新的Op](../new_op.html)
## 写Op注意事项
### 1.Op可以支持输入输出类型
Fluid的Op的输入输出都是`Variable`，从设计上讲，`Variable`中可以存放任意类型，Op的输入输出`Variable`可能是是任意类型，通常情况下`Variable`中存放的是`LoDTensor`、`SlelecteRows`。
**注意：**
- 代码中经常出现`context.Input<Tensor>("Input")`，并不表示"Input"的`Variable`是`Tensor`，而是从"Input"的`Variable`的`LoDTensor`中获取`Tensor`。如果"Input"的`Variable`是`SelecetedRows`，则会报错。
- 如果”Input”是`SelectedRows`，`context->GetInputDim("Input")`返回的是`var->Get<SelectedRows>().GetCompleteDims()`，而不是`SelectedRows`中`Tensor`的Dim。
### 2.在Op内部不能对输入的数据做任何的改写
在Op内部绝不允许对输入数据做任何改写，因为可能存在其他Op需要读这个数据。
### 3.OpKernel需要注册的数据类型
目前要求所有OpKernel都要注册double和float数据类型。
### 4.Op兼容性问题
对Op的修改需要考虑兼容性问题，要保证Op修改之后，之前的模型都能够正常加载及运行。<font color="#FF0000">**所以现在不允许对已有的Op新增输入或者输出，不允许减去Op的已有属性及修改默认值**</font> 。
### 5.ShareDataWith的调用
ShareDataWith的功能是使两个Tensor共享底层buffer，在调用这个操作的时候需要特别注意，在Op内部不能将ShareDataWith作用在Op的输出上，即Op输出的Tensor必须是Malloc出来的。
### 6.稀疏梯度参数更新方法
目前稀疏梯度在做更新更新的时候会先对梯度做merge，即对相同参数的梯度做累加，然后做参数以及附加参数（如velocity）的更新。
### 7.显存优化
如果Op的反向不需要将前向op的所有输入输出作为其输入，则不要用`DefaultGradOpDescMaker`，这将会导致无法对没有用到的变量做内存/显存优化。
### 8.混合设备调用
由于GPU是异步执行的，当CPU调用返回之后，GPU端可能还没有真正的执行，所以如果在Op中创建了GPU运行时需要用到的临时变量，当GPU开始运行的时候，该临时变量可能在CPU端已经被释放，这样可能会导致GPU计算出错。
关于GPU中的一些同步和异步操作：
```
The following device operations are asynchronous with respect to the host:
Kernel launches;
Memory copies within a single device's memory;
Memory copies from host to device of a memory block of 64 KB or less;
Memory copies performed by functions that are suffixed with Async;
Memory set function calls.
```
关于cudaMemCpy和cudaMemCpyAsync注意事项：
- 如果数据传输是从GPU端到非页锁定的CPU端，数据传输将是同步，即使调用的是异步拷贝操作。
- 如果数据传输时从CPU端到CPU端，数据传输将是同步的，即使调用的是异步拷贝操作。
更多内容可参考：[Asynchronous Concurrent Execution](https://docs.nvidia.com/cuda/cuda-c-programming-guide/#asynchronous-concurrent-execution)，[API synchronization behavior](https://docs.nvidia.com/cuda/cuda-runtime-api/api-sync-behavior.html#api-sync-behavior)
## Op性能优化
### 1.第三方库的选择
在写Op过程中优先使用高性能（如cudnn、mkldnn、mklml、eigen等）中提供的操作，但是一定要做benchmark，有些库中的操作在深度学习任务中可能会比较慢。因为高性能库（如eigen等）中提供的操作为了更为通用，在性能方面可能并不是很好，通常深度学习模型中数据量较小，所以有些情况下可能高性能库中提供的某些操作速度较慢。比如Elementwise系列的所有Op（前向和反向），Elementwise操作在模型中调用的次数比较多，尤其是Elementwise_add，在很多操作之后都需要添加偏置项。在之前的实现中Elementwise_op直接调用Eigen库，由于Elementwise操作在很多情况下需要对数据做Broadcast，而实验发现Eigen库做Broadcast的速度比较慢，慢的原因在这个PR[#6229](https://github.com/PaddlePaddle/Paddle/pull/6229)中有描述。
### 2.Op性能优化
Op的计算速度与输入的数据量有关，对于某些Op可以根据输入数据的Shape和Op的属性参数来选择不同的计算方式。比如concat_op，当axis>=1时，在对多个tensor做拼接过程中需要对每个tensor做很多次拷贝，如果是在GPU上，需要调用cudaMemCopy。相对CPU而言，GPU属于外部设备，所以每次调用GPU的操作都会有一定的额外开销，并且当需要拷贝的次数较多时，这种开销就更为凸现。目前concat_op的实现会根据输入数据的Shape以及axis值来选择不同的调用方式，如果输入的tensor较多，且axis不等于0，则将多次拷贝操作转换成一个CUDA Kernel来完成；如果输入tensor较少，且axis等于0，使用直接进行拷贝。相关实验过程在该PR（[#8669](https://github.com/PaddlePaddle/Paddle/pull/8669)）中有介绍。
由于CUDA Kernel的调用有一定的额外开销，所以如果Op中出现多次调用CUDA Kernel，可能会影响Op的执行速度。比如之前的sequence_expand_op中包含很多CUDA Kernel，通常这些CUDA Kernel处理的数据量较小，所以频繁调用这样的Kernel会影响Op的计算速度，这种情况下最好将这些小的CUDA Kernel合并成一个。在优化sequence_expand_op过程（相关PR[#9289](https://github.com/PaddlePaddle/Paddle/pull/9289)）中就是采用这种思路，优化后的sequence_expand_op比之前的实现平均快出约1倍左右，相关实验细节在该PR（[#9289](https://github.com/PaddlePaddle/Paddle/pull/9289)）中有介绍。
减少CPU与GPU之间的拷贝和同步操作的次数。比如fetch操作，在每个迭代之后都会对模型参数进行更新并得到一个loss，并且数据从GPU端到没有页锁定的CPU端的拷贝是同步的，所以频繁的fetch多个参数会导致模型训练速度变慢。
## Op数值稳定性问题
### 1.有些Op存在数值稳定性问题
出现数值稳定性的主要原因程序在多次运行时，对浮点型数据施加操作的顺序可能不同，进而导致最终计算结果不同。而GPU是通过多线程并行计算的方式来加速计算的，所以很容易出现对浮点数施加操作的顺序不固定现象。
目前发现cudnn中的卷积操作、cudnn中的MaxPooling、CUDA中CudaAtomicXX、ParallelExecutor的Reduce模式下参数梯度的聚合等操作运行结果是非确定的。
为此Fluid中添加了一些FLAGS，比如使用FLAGS_cudnn_deterministic来强制cudnn使用确定性算法、FLAGS_cpu_deterministic强制CPU端的计算使用确定性方法。
### 2.WITH_FAST_MATH的开与关
如果WITH_FAST_MATH是ON，NVCC在编译Paddle和Egien的时候会使用--use_fast_math，这样可能会使CUDA中的一些操作在损失一定精度的情况下变快，比如log、exp、tanh等，但也会使一些操作的计算结果是错的，比如pow操作，具体原因请查看[torch/DEPRECEATED-torch7-distro#132](https://github.com/torch/DEPRECEATED-torch7-distro/issues/132)。
## 其他
### 1.报错信息
Enforce提示信息不能为空，并且需要写明，因为报错信息可以更快更方便地分析出错误的原因。
### 2.Op的数学公式
如果Op有数学公式，一定要在代码中将数学公式写明，并在Python API的Doc中显示，因为用户在对比不同框架的计算结果时可能需要了解Paddle对Op是怎么实现的。
**注意：**在merge到develop分支之前一定进行公式预览。可参考[dynamic_lstmp](http://paddlepaddle.org/documentation/docs/zh/1.1/api/layers.html#dynamic-lstmp)。
### 3.Python端Op接口中参数的顺序
Python API中参数的顺序一般按照重要性来排，以fc为例：
```
def fc(input,
size,
num_flatten_dims=1,
param_attr=None,
bias_attr=None,
act=None,
is_test=False,
name=None)
```
doc/fluid/advanced_usage/development/profiling/index.rst 已删除 100644 → 0
浏览文件 @ 37fd49da
##########
性能调优
##########
.. toctree::
benchmark.rst
cpu_profiling_cn.md
gpu_profiling_cn.rst
host_memory_profiling_cn.md
timeline_cn.md
doc/fluid/advanced_usage/development/profiling/index_cn.rst 0 → 100644
浏览文件 @ cb4f4929
##########
性能调优
##########
本模块介绍 Fluid 使用过程中的调优方法，包括：
- `如何进行基准测试 <benchmark.html>`_：介绍如何选择基准模型，从而验证模型的精度和性能
- `CPU性能调优 <cpu_profiling_cn.html>`_：介绍如何使用 cProfile 包、yep库、Google perftools 进行性能分析与调优
- `GPU性能调优 <gpu_profiling_cn.html>`_：介绍如何使用 Fluid 内置的定时工具、nvprof 或 nvvp 进行性能分析和调优
- `堆内存分析和优化 <host_memory_profiling_cn.html>`_：介绍如何使用 gperftool 进行堆内存分析和优化，以解决内存泄漏的问题
- `Timeline工具简介 <timeline_cn.html>`_ ：介绍如何使用 Timeline 工具进行性能分析和调优
.. toctree::
:hidden:
benchmark.rst
cpu_profiling_cn.md
gpu_profiling_cn.rst
host_memory_profiling_cn.md
timeline_cn.md
doc/fluid/advanced_usage/index.rst
浏览文件 @ cb4f4929
...@@ -2,48 +2,30 @@ ...@@ -2,48 +2,30 @@
进阶使用 进阶使用
######## ########
=====================
概览
=====================
.. todo:: .. todo::
如果您非常熟悉 Fluid，期望获得更高效的模型或者定义自己的Operator，请阅读： 如果您非常熟悉 Fluid，期望获得更高效的模型或者定义自己的Operator，请阅读：
- `移动端部署 <../advanced_usage/deploy/index_mobile.html>`_：介绍了 PaddlePaddle 组织下的嵌入式平台深度学习框架——Paddle-Mobile，包括： - `Fluid 设计思想 <../advanced_usage/design_idea/fluid_design_idea.html>`_：介绍 Fluid 底层的设计思想，帮助您更好的理解框架运作过程
- `简介 <../advanced_usage/deploy/mobile_readme.html>`_：简要介绍了 Paddle-Mobile 的应用效果，特点以及使用说明 - `预测部署 <../advanced_usage/deploy/index_cn.html>`_ ：介绍如何应用训练好的模型进行预测
- `环境搭建 <../advanced_usage/deploy/mobile_build.html>`_：从使用 Docker 和不使用 Docker 两种方法下分别介绍如何搭建环境
- `ios开发文档 <../advanced_usage/deploy/mobile_dev.html>`_：介绍如何在 ios 系统下运用 Paddle-Mobile 进行开发
- `Anakin预测引擎 <../advanced_usage/deploy/index_anakin.html>`_：介绍如何使用 Anakin 在不同硬件平台实现深度学习的高速预测 - `新增operator <../advanced_usage/development/new_op/index_cn.html>`_ ：介绍新增operator的方法及注意事项
- `如何写新的Operator <../advanced_usage/development/new_op.html>`_ ：介绍如何在 Fluid 中添加新的 Operator
- `性能调优 <../advanced_usage/development/profiling/index.html>`_ ：介绍 Fluid 使用过程中的调优方法，包括：
- `如何进行基准测试 <../advanced_usage/development/profiling/benchmark.html>`_：介绍如何选择基准模型，从而验证模型的精度和性能
- `CPU性能调优 <../advanced_usage/development/profiling/cpu_profiling_cn.html>`_：介绍如何使用 cProfile 包、yep库、Google perftools 进行性能分析与调优
- `GPU性能调优 <../advanced_usage/development/profiling/gpu_profiling_cn.html>`_：介绍如何使用 Fluid 内置的定时工具、nvprof 或 nvvp 进行性能分析和调优
- `堆内存分析和优化 <../advanced_usage/development/profiling/host_memory_profiling_cn.html>`_：介绍如何使用 gperftool 进行堆内存分析和优化，以解决内存泄漏的问题
- `Timeline工具简介 <../advanced_usage/development/profiling/timeline_cn.html>`_ ：介绍如何使用 Timeline 工具进行性能分析和调优
- `性能调优 <../advanced_usage/development/profiling/index.html>`_ ：介绍 Fluid 使用过程中的调优方法
非常欢迎您为我们的开源社区做出贡献，关于如何贡献您的代码或文档，请阅读： 非常欢迎您为我们的开源社区做出贡献，关于如何贡献您的代码或文档，请阅读：
- `如何贡献代码 <../advanced_usage/development/contribute_to_paddle.html>`_：介绍如何向 PaddlePaddle 开源社区贡献代码 - `如何贡献代码 <../advanced_usage/development/contribute_to_paddle/index_cn.html>`_：介绍如何向 PaddlePaddle 开源社区贡献代码
- `如何贡献文档 <../advanced_usage/development/write_docs_cn.html>`_：介绍如何向 PaddlePaddle 开源社区贡献文档 - `如何贡献文档 <../advanced_usage/development/write_docs_cn.html>`_：介绍如何向 PaddlePaddle 开源社区贡献文档
=====================
目录
=====================
.. toctree:: .. toctree::
:maxdepth: 2 :hidden:
deploy/index_mobile.rst design_idea/fluid_design_idea.md
deploy/index_anakin.rst deploy/index_cn.rst
development/new_op/index_cn.rst
development/profiling/index_cn.rst
development/contribute_to_paddle/index_cn.rst development/contribute_to_paddle/index_cn.rst
development/write_docs_cn.md development/write_docs_cn.md
development/new_op.md
development/profiling/index.rst
doc/fluid/api/api_guides/index.rst
浏览文件 @ cb4f4929
...@@ -12,3 +12,4 @@ API使用指南 ...@@ -12,3 +12,4 @@ API使用指南
low_level/metrics.rst low_level/metrics.rst
low_level/model_save_reader.rst low_level/model_save_reader.rst
low_level/inference.rst low_level/inference.rst
low_level/distributed/index.rst
doc/fluid/api/api_guides/low_level/cluster/cluster_train_data_cn.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_cluster_train_data:
####################
分布式训练reader准备
####################
一个数据并行的分布式训练任务通常会含有多个训练进程，每个训练进程处理整个数据集中的一部分，根据当前进程的唯一序号(trainer_id)以及训练进程总数(trainers)可以决定当前训练进程应该读取哪一部分数据。
实现 cluster_reader 来读取分布式训练数据集
----------------------------------------
比较通用的方法，可以实现一个 cluster_reader, 根据训练进程数量以及进程序号决定读取哪些 example:
.. code-block:: python
def cluster_reader(reader, trainers, trainer_id):
def reader_creator():
for idx, data in enumerate(reader()):
if idx % trainers == trainer_id:
yield data
return reader
trainers = int(os.getenv("PADDLE_TRAINERS", "1"))
trainer_id = int(os.getenv("PADDLE_TRAINER_ID", "0"))
train_reader = cluster_reader(paddle.dataset.mnist.train(), trainers, trainer_id)
上述代码中，`trainers` 和 `trainer_id` 分别是训练进程总数和当前训练进程的序号，可以通过环境变量或者参数的方式传递给 Python 程序。
预先切分训练文件
-----------------
由于使用 `cluster_reader` 依然会读取全量数据，对于训练进程比较多的任务，会造成IO资源的浪费、影响训练性能。另一种方法是可以将训练数据切分成多个小文件，每个进程处理其中的一部分文件,
例如在 Linux 系统中可以使用 `split <http://man7.org/linux/man-pages/man1/split.1.html>`_ 命令将训练数据切分成多个小文件：
.. code-block:: bash
$ split -d -a 4 -d -l 100 housing.data cluster/housing.data.
$ find ./cluster
cluster/
cluster/housing.data.0002
cluster/housing.data.0003
cluster/housing.data.0004
cluster/housing.data.0000
cluster/housing.data.0001
cluster/housing.data.0005
数据切分好以后, 可以实现一个 file_dispatcher 函数，根据训练进程数量以及序号决定需要读取哪些文件：
.. code-block:: python
def file_dispatcher(files_pattern, trainers, trainer_id):
file_list = glob.glob(files_pattern)
ret_list = []
for idx, f in enumerate(file_list):
if (idx + trainers) % trainers == trainer_id:
ret_list.append(f)
return ret_list
trainers = int(os.getenv("PADDLE_TRAINERS", "1"))
trainer_id = int(os.getenv("PADDLE_TRAINER_ID", "0"))
files_pattern = "cluster/housing.data.*"
my_files = file_dispatcher(files_pattern, triners, trainer_id)
在上述例子中，`files_pattern` 是训练文件的 `glob 表达式 <https://docs.python.org/2.7/library/glob.html>`_，一般可以用通配符来表示。
doc/fluid/api/api_guides/low_level/distributed/async_training.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_async_training:
############
分布式异步训练
############
Fluid支持数据并行的分布式异步训练，API使用 :code:`DistributedTranspiler` 将单机网络配置转换成可以多机执行的
:code:`pserver` 端程序和 :code:`trainer` 端程序。用户在不同的节点执行相同的一段代码，根据环境变量或启动参数，
可以执行对应的 :code:`pserver` 或 :code:`trainer` 角色。Fluid异步训练只支持pserver模式，异步训练和 `同步训练 <../distributed/sync_training.html>`_ 的主要差异在于：异步训练每个trainer的梯度是单独更新到参数上的，
而同步训练是所有trainer的梯度合并之后统一更新到参数上，因此，同步训练和异步训练的超参数需要分别调节。
pserver模式分布式异步训练
======================
API详细使用方法参考 :ref: `api_fluid_DistributeTranspiler` ，简单示例用法：
.. code-block:: python
config = fluid.DistributedTranspilerConfig()
# 配置策略config
config.slice_var_up = False
t = fluid.DistributedTranspiler(config=config)
t.transpile(trainer_id,
program=main_program,
pservers="192.168.0.1:6174,192.168.0.2:6174",
trainers=1,
sync_mode=False)
以上参数说明请参考`同步训练 <../distributed/sync_training.html>`_
需要注意的是：进行异步训练时，请修改 :code:`sync_mode` 的值
- :code:`sync_mode` ： 是否是同步训练模式，默认为True，不传此参数也默认是同步训练模式，设置为False则为异步训练
doc/fluid/api/api_guides/low_level/distributed/cpu_train_best_practice.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_cpu_training_best_practice:
##################
分布式CPU训练最佳实践
##################
提高CPU分布式训练的训练速度，主要要从两个方面来考虑：
1）提高训练速度，主要是提高CPU的使用率；2）提高通信速度，主要是减少通信传输的数据量。
提高CPU的使用率
=============
提高CPU使用率主要依赖 :code:`ParallelExecutor`，可以充分利用多个CPU的计算能力来加速计算。
API详细使用方法参考 :ref:`api_fluid_ParallelExecutor` ，简单实例用法：
.. code-block:: python
# 配置执行策略，主要是设置线程数
exec_strategy = fluid.ExecutionStrategy()
exec_strategy.num_threads = 8
# 配置构图策略，对于CPU训练而言，应该使用Reduce模式进行训练
build_strategy = fluid.BuildStrategy()
if int(os.getenv("CPU_NUM")) > 1:
build_strategy.reduce_strategy = fluid.BuildStrategy.ReduceStrategy.Reduce
pe = fluid.ParallelExecutor(
use_cuda=False,
loss_name=avg_cost.name,
main_program=main_program,
build_strategy=build_strategy,
exec_strategy=exec_strategy)
以上参数中：
- :code:`num_threads` ： 模型训练使用的线程数，最好和训练所在机器的物理CPU核数接近
- :code:`reduce_strategy` ： 对于CPU训练而言，应该选择 fluid.BuildStrategy.ReduceStrategy.Reduce
通用环境变量配置：
- :code:`CPU_NUM` ：模型副本replica的个数，最好和num_threads一致
提高通信速度
==========
要减少通信数据量，提高通信速度，主要是使用稀疏更新 ，目前支持 `稀疏更新 <../distributed/sparse_update.html>`_ 的主要是 :ref:`api_fluid_layers_embedding` 。
.. code-block:: python
data = fluid.layers.data(name='ids', shape=[1], dtype='int64')
fc = fluid.layers.embedding(input=data, size=[dict_size, 16], is_sparse=True)
以上参数中：
- :code:`is_sparse` ： 配置embedding使用稀疏更新，如果embedding的dict_size很大，而每次数据data很少，建议使用sparse更新方式。
doc/fluid/api/api_guides/low_level/distributed/index.rst 0 → 100644
浏览文件 @ cb4f4929
=============
分布式训练
=============
.. toctree::
:maxdepth: 1
async_training.rst
cpu_train_best_practice.rst
large_scale_sparse_feature_training.rst
doc/fluid/api/api_guides/low_level/distributed/large_scale_sparse_feature_training.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_large_scale_sparse_feature_training:
###################
大规模稀疏特征模型训练
###################
模型配置和训练
=============
embedding被广泛应用在各种网络结构中，尤其是文本处理相关的模型。在某些场景，例如推荐系统或者搜索引擎中，
embedding的feature id可能会非常多，当feature id达到一定数量时，embedding参数会变得很大，
会带来两个问题：
1）单机内存由于无法存放如此巨大的embedding参数，导致无法训练；
2）普通的训练模式每一轮迭代都需要同步完整的参数，参数太大会让通信变得非常慢，进而影响训练速度。
Fluid支持千亿量级超大规模稀疏特征embedding的训练，embedding参数只会保存在parameter server上，通过
参数prefetch和梯度稀疏更新的方法，大大减少通信量，提高通信速度。
该功能只对分布式训练有效，单机无法使用。
需要配合 `稀疏更新 <../distributed/sparse_update.html>`_ 一起使用。
使用方法：在配置embedding的时候，加上参数 :code:`is_distributed=True` 以及 :code:`is_sparse=True` 即可。
参数 :code:`dict_size` 定义数据中总的id的数量，id可以是int64范围内的任意值，只要总id个数小于等于dict_size就可以支持。
所以配置之前需要预估一下数据中总的feature id的数量。
.. code-block:: python
emb = fluid.layers.embedding(
is_distributed=True,
input=input,
size=[dict_size, embedding_width],
is_sparse=True,
is_distributed=True)
模型存储和预测
=============
当特征数量达到千亿的时候，参数量很大，单机已经无法存下，所以模型的存储和加载都和普通模式不同：
1）普通模式下，参数是在trainer端保存和加载的；
2）分布式模式下，参数的保存和加载，都是在pserver端进行，每个pserver只保存和加载该pserver自身对应部分的参数
doc/fluid/api/api_guides/low_level/distributed/sync_training.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_sync_training:
############
分布式同步训练
############
Fluid支持数据并行的分布式同步训练，API使用 :code:`DistributedTranspiler` 将单机网络配置转换成可以多机执行的
:code:`pserver` 端程序和 :code:`trainer` 端程序。用户在不同的节点执行相同的一段代码，根据环境变量或启动参数，
可以执行对应的 :code:`pserver` 或 :code:`trainer` 角色。Fluid分布式同步训练同时支持pserver模式和NCCL2模式，
在API使用上有差别，需要注意。
pserver模式分布式训练
===================
API详细使用方法参考 :ref:`DistributeTranspiler` ，简单实例用法：
.. code-block:: python
config = fluid.DistributedTranspilerConfig()
# 配置策略config
config.slice_var_up = False
t = fluid.DistributedTranspiler(config=config)
t.transpile(trainer_id,
program=main_program,
pservers="192.168.0.1:6174,192.168.0.2:6174",
trainers=1,
sync_mode=True)
以上参数中：
- :code:`trainer_id` ： trainer节点的id，从0到n-1，n为当前训练任务中trainer节点的个数
- :code:`program` ： 被转换的 :code:`program` 默认使用 :code:`fluid.default_main_program()`
- :code:`pservers` ： 当前训练任务中pserver节点的IP端口列表
- :code:`trainers` ： int类型，当前训练任务中trainer节点的个数。注意：
* pserver模式下，trainer节点个数可以和pserver节点个数不一致，比如使用20个pserver和50个trainer。在实际训练任务中，您可以通过调整pserver节点和trainer节点个数找到最佳性能
* NCCL2模式中，此项参数是字符串，指定trainer节点的IP端口列表
- :code:`sync_mode` ： 是否是同步训练模式，默认为True，不传此参数也默认是同步训练模式
其中，支持的config包括：
- :code:`slice_var_up` ： 配置是否切分一个参数到多个pserver上进行优化，默认开启。此选项适用于模型参数个数少，但需要使用大量节点的场景，有利于提升pserver端计算并行度
- :code:`split_method` ： 配置transpiler分配参数（或参数的切片）到多个pserver的方式，默认为"RoundRobin"，也可以使用"HashName"
- :code:`min_block_size` ： 如果配置了参数切分，指定最小Tensor的切分大小，防止RPC请求包过小，默认为8192，一般情况不需要调整此项参数
- :code:`enable_dc_asgd` ： 是否开启 :code:`DC-ASGD` 此选项在异步训练中生效，启用异步训练补偿算法
- :code:`mode` : 可以选择"pserver"或"nccl2"，指定使用pserver模式或NCCL2模式分布式训练
- :code:`print_log` ： 是否开启transpiler debug日志，此项为开发调试使用
通用环境变量配置：
- :code:`FLAGS_rpc_send_thread_num` ：int，指定RPC通信发送时线程的个数
- :code:`FLAGS_rpc_get_thread_num` ： int，指定RPC通信接受时线程的个数
- :code:`FLAGS_rpc_prefetch_thread_num` ： int，分布式lookup table执行RPC通信时，prefetch线程的个数
- :code:`FLAGS_rpc_deadline` ： int，RPC通信最长等待时间，单位为毫秒，默认180000
NCCL2模式分布式训练
=================
基于NCCL2 (Collective Communication) 的多机同步训练模式，仅支持在GPU集群下进行。
此部分详细API说明可以参考 :ref:`DistributeTranspiler` 。
注意：NCCL2模式下，集群不需要启动pserver，只需要启动多个trainer节点即可。
使用以下代码，将当前 :code:`Program` 转化成适用于NCCL2分布式计算的Fluid :code:`Program` ：
.. code-block:: python
config = fluid.DistributeTranspilerConfig()
config.mode = "nccl2"
t = fluid.DistributedTranspiler(config=config)
t.transpile(trainer_id,
program=main_program,
startup_program=startup_program,
trainers="192.168.0.1:6174,192.168.0.2:6174",
current_endpoint="192.168.0.1:6174")
其中：
- :code:`trainer_id` : trainer节点的id，从0到n-1，n为当前训练任务中trainer节点的个数
- :code:`program` 和 :code:`startup_program` : 分别为Fluid 模型的主配置program和初始化startup_program
- :code:`trainers` : 字符串类型，指定当前任务所有trainer的IP和端口号，仅用于NCCL2初始化（pserver模式中，此参数为int，指定trainer节点的个数）
- :code:`current_endpoint` : 当前任务的当前节点的IP和端口号
doc/fluid/api/api_guides/low_level/layers/index.rst
浏览文件 @ cb4f4929
...@@ -14,4 +14,5 @@ ...@@ -14,4 +14,5 @@
loss_function.rst loss_function.rst
data_in_out.rst data_in_out.rst
control_flow.rst control_flow.rst
sparse_update.rst
doc/fluid/api/api_guides/low_level/layers/sparse_update.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_sparse_update:
#####
稀疏更新
#####
Fluid的 :ref:`api_fluid_layers_embedding` 层在单机训练和分布式训练时，均可以支持“稀疏更新”，即梯度以sparse tensor 结构存储，只保存梯度不为0的行。
在分布式训练中，对于较大的embedding层，开启稀疏更新有助于减少通信数据量，提升训练速度。
在paddle内部，我们用lookup_table来实现embedding。下边这张图说明了embedding在正向和反向计算的过程：
如图所示：一个Tensor中有两行不为0，正向计算的过程中，我们使用ids存储不为0的行，并使用对应的两行数据来进行计算；反向更新的过程也只更新这两行。
.. image:: ../../../../images/lookup_table_training.png
:scale: 50 %
embedding使用例子:
---------------------
API详细使用方法参考 :ref:`api_fluid_layers_embedding` ，以下是一个简单的例子：
.. code-block:: python
DICT_SIZE = 10000 * 10
EMBED_SIZE = 64
IS_SPARSE = False
def word_emb(word, dict_size=DICT_SIZE, embed_size=EMBED_SIZE):
embed = fluid.layers.embedding(
input=word,
size=[dict_size, embed_size],
dtype='float32',
param_attr=fluid.ParamAttr(
initializer=fluid.initializer.Normal(scale=1/math.sqrt(dict_size))),
is_sparse=IS_SPARSE,
is_distributed=False)
return embed
以上参数中：
- :code:`is_sparse` ： 反向计算的时候梯度是否为sparse tensor。如果不设置，梯度是一个 `LodTensor <https://github.com/PaddlePaddle/FluidDoc/blob/develop/doc/fluid/user_guides/howto/prepare_data/lod_tensor.md>`_ 。默认为False。
- :code:`is_distributed` ： 标志是否是用在分布式的场景下。一般大规模稀疏更新（embedding的第0维维度很大，比如几百万以上）才需要设置。具体可以参考大规模稀疏的API guide :ref:`api_guide_async_training` 。默认为False。
- API汇总:
- :ref:`api_fluid_layers_embedding`
doc/fluid/api/average.rst
浏览文件 @ cb4f4929
...@@ -14,3 +14,5 @@ WeightedAverage ...@@ -14,3 +14,5 @@ WeightedAverage
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_average_WeightedAverage`
doc/fluid/api/backward.rst
浏览文件 @ cb4f4929
...@@ -13,3 +13,5 @@ append_backward ...@@ -13,3 +13,5 @@ append_backward
.. autofunction:: paddle.fluid.backward.append_backward .. autofunction:: paddle.fluid.backward.append_backward
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_backward_append_backward`
doc/fluid/api/clip.rst
浏览文件 @ cb4f4929
...@@ -14,6 +14,8 @@ ErrorClipByValue ...@@ -14,6 +14,8 @@ ErrorClipByValue
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_clip_ErrorClipByValue`
.. _api_fluid_clip_GradientClipByGlobalNorm: .. _api_fluid_clip_GradientClipByGlobalNorm:
GradientClipByGlobalNorm GradientClipByGlobalNorm
...@@ -23,6 +25,8 @@ GradientClipByGlobalNorm ...@@ -23,6 +25,8 @@ GradientClipByGlobalNorm
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_clip_GradientClipByGlobalNorm`
.. _api_fluid_clip_GradientClipByNorm: .. _api_fluid_clip_GradientClipByNorm:
GradientClipByNorm GradientClipByNorm
...@@ -32,6 +36,8 @@ GradientClipByNorm ...@@ -32,6 +36,8 @@ GradientClipByNorm
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_clip_GradientClipByNorm`
.. _api_fluid_clip_GradientClipByValue: .. _api_fluid_clip_GradientClipByValue:
GradientClipByValue GradientClipByValue
...@@ -41,3 +47,5 @@ GradientClipByValue ...@@ -41,3 +47,5 @@ GradientClipByValue
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_clip_GradientClipByValue`
doc/fluid/api/data_feeder.rst
浏览文件 @ cb4f4929
...@@ -14,3 +14,5 @@ DataFeeder ...@@ -14,3 +14,5 @@ DataFeeder
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_data_feeder_DataFeeder`
doc/fluid/api/executor.rst
浏览文件 @ cb4f4929
...@@ -5,14 +5,6 @@ ...@@ -5,14 +5,6 @@
fluid.executor fluid.executor
============== ==============
.. _api_fluid_executor__switch_scope:
_switch_scope
-------------
.. autofunction:: paddle.fluid.executor._switch_scope
:noindex:
.. _api_fluid_executor_Executor: .. _api_fluid_executor_Executor:
Executor Executor
...@@ -22,6 +14,8 @@ Executor ...@@ -22,6 +14,8 @@ Executor
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_executor_Executor`
.. _api_fluid_executor_global_scope: .. _api_fluid_executor_global_scope:
global_scope global_scope
...@@ -30,6 +24,8 @@ global_scope ...@@ -30,6 +24,8 @@ global_scope
.. autofunction:: paddle.fluid.executor.global_scope .. autofunction:: paddle.fluid.executor.global_scope
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_executor_global_scope`
.. _api_fluid_executor_scope_guard: .. _api_fluid_executor_scope_guard:
scope_guard scope_guard
...@@ -38,3 +34,5 @@ scope_guard ...@@ -38,3 +34,5 @@ scope_guard
.. autofunction:: paddle.fluid.executor.scope_guard .. autofunction:: paddle.fluid.executor.scope_guard
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_executor_scope_guard`
doc/fluid/api/fluid.rst
浏览文件 @ cb4f4929
...@@ -5,14 +5,17 @@ ...@@ -5,14 +5,17 @@
fluid fluid
===== =====
.. _api_fluid__switch_scope: .. _api_fluid_AsyncExecutor:
_switch_scope AsyncExecutor
------------- -------------
.. autofunction:: paddle.fluid._switch_scope .. autoclass:: paddle.fluid.AsyncExecutor
:members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_AsyncExecutor`
.. _api_fluid_BuildStrategy: .. _api_fluid_BuildStrategy:
BuildStrategy BuildStrategy
...@@ -22,6 +25,8 @@ BuildStrategy ...@@ -22,6 +25,8 @@ BuildStrategy
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_BuildStrategy`
.. _api_fluid_CPUPlace: .. _api_fluid_CPUPlace:
CPUPlace CPUPlace
...@@ -31,6 +36,8 @@ CPUPlace ...@@ -31,6 +36,8 @@ CPUPlace
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_CPUPlace`
.. _api_fluid_create_lod_tensor: .. _api_fluid_create_lod_tensor:
create_lod_tensor create_lod_tensor
...@@ -39,6 +46,8 @@ create_lod_tensor ...@@ -39,6 +46,8 @@ create_lod_tensor
.. autofunction:: paddle.fluid.create_lod_tensor .. autofunction:: paddle.fluid.create_lod_tensor
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_create_lod_tensor`
.. _api_fluid_create_random_int_lodtensor: .. _api_fluid_create_random_int_lodtensor:
create_random_int_lodtensor create_random_int_lodtensor
...@@ -47,6 +56,8 @@ create_random_int_lodtensor ...@@ -47,6 +56,8 @@ create_random_int_lodtensor
.. autofunction:: paddle.fluid.create_random_int_lodtensor .. autofunction:: paddle.fluid.create_random_int_lodtensor
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_create_random_int_lodtensor`
.. _api_fluid_CUDAPinnedPlace: .. _api_fluid_CUDAPinnedPlace:
CUDAPinnedPlace CUDAPinnedPlace
...@@ -56,6 +67,8 @@ CUDAPinnedPlace ...@@ -56,6 +67,8 @@ CUDAPinnedPlace
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_CUDAPinnedPlace`
.. _api_fluid_CUDAPlace: .. _api_fluid_CUDAPlace:
CUDAPlace CUDAPlace
...@@ -65,6 +78,19 @@ CUDAPlace ...@@ -65,6 +78,19 @@ CUDAPlace
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_CUDAPlace`
.. _api_fluid_DataFeedDesc:
DataFeedDesc
------------
.. autoclass:: paddle.fluid.DataFeedDesc
:members:
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_DataFeedDesc`
.. _api_fluid_DataFeeder: .. _api_fluid_DataFeeder:
DataFeeder DataFeeder
...@@ -74,6 +100,8 @@ DataFeeder ...@@ -74,6 +100,8 @@ DataFeeder
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_DataFeeder`
.. _api_fluid_default_main_program: .. _api_fluid_default_main_program:
default_main_program default_main_program
...@@ -82,6 +110,8 @@ default_main_program ...@@ -82,6 +110,8 @@ default_main_program
.. autofunction:: paddle.fluid.default_main_program .. autofunction:: paddle.fluid.default_main_program
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_default_main_program`
.. _api_fluid_default_startup_program: .. _api_fluid_default_startup_program:
default_startup_program default_startup_program
...@@ -90,6 +120,8 @@ default_startup_program ...@@ -90,6 +120,8 @@ default_startup_program
.. autofunction:: paddle.fluid.default_startup_program .. autofunction:: paddle.fluid.default_startup_program
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_default_startup_program`
.. _api_fluid_DistributeTranspiler: .. _api_fluid_DistributeTranspiler:
DistributeTranspiler DistributeTranspiler
...@@ -99,6 +131,8 @@ DistributeTranspiler ...@@ -99,6 +131,8 @@ DistributeTranspiler
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_DistributeTranspiler`
.. _api_fluid_DistributeTranspilerConfig: .. _api_fluid_DistributeTranspilerConfig:
DistributeTranspilerConfig DistributeTranspilerConfig
...@@ -108,6 +142,8 @@ DistributeTranspilerConfig ...@@ -108,6 +142,8 @@ DistributeTranspilerConfig
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_DistributeTranspilerConfig`
.. _api_fluid_ExecutionStrategy: .. _api_fluid_ExecutionStrategy:
ExecutionStrategy ExecutionStrategy
...@@ -117,6 +153,8 @@ ExecutionStrategy ...@@ -117,6 +153,8 @@ ExecutionStrategy
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_ExecutionStrategy`
.. _api_fluid_Executor: .. _api_fluid_Executor:
Executor Executor
...@@ -126,6 +164,8 @@ Executor ...@@ -126,6 +164,8 @@ Executor
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_Executor`
.. _api_fluid_global_scope: .. _api_fluid_global_scope:
global_scope global_scope
...@@ -134,6 +174,8 @@ global_scope ...@@ -134,6 +174,8 @@ global_scope
.. autofunction:: paddle.fluid.global_scope .. autofunction:: paddle.fluid.global_scope
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_global_scope`
.. _api_fluid_LoDTensor: .. _api_fluid_LoDTensor:
LoDTensor LoDTensor
...@@ -143,6 +185,8 @@ LoDTensor ...@@ -143,6 +185,8 @@ LoDTensor
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_LoDTensor`
.. _api_fluid_LoDTensorArray: .. _api_fluid_LoDTensorArray:
LoDTensorArray LoDTensorArray
...@@ -152,6 +196,8 @@ LoDTensorArray ...@@ -152,6 +196,8 @@ LoDTensorArray
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_LoDTensorArray`
.. _api_fluid_memory_optimize: .. _api_fluid_memory_optimize:
memory_optimize memory_optimize
...@@ -160,6 +206,8 @@ memory_optimize ...@@ -160,6 +206,8 @@ memory_optimize
.. autofunction:: paddle.fluid.memory_optimize .. autofunction:: paddle.fluid.memory_optimize
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_memory_optimize`
.. _api_fluid_name_scope: .. _api_fluid_name_scope:
name_scope name_scope
...@@ -168,6 +216,8 @@ name_scope ...@@ -168,6 +216,8 @@ name_scope
.. autofunction:: paddle.fluid.name_scope .. autofunction:: paddle.fluid.name_scope
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_name_scope`
.. _api_fluid_ParallelExecutor: .. _api_fluid_ParallelExecutor:
ParallelExecutor ParallelExecutor
...@@ -177,6 +227,8 @@ ParallelExecutor ...@@ -177,6 +227,8 @@ ParallelExecutor
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_ParallelExecutor`
.. _api_fluid_ParamAttr: .. _api_fluid_ParamAttr:
ParamAttr ParamAttr
...@@ -186,6 +238,8 @@ ParamAttr ...@@ -186,6 +238,8 @@ ParamAttr
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_ParamAttr`
.. _api_fluid_Program: .. _api_fluid_Program:
Program Program
...@@ -195,6 +249,8 @@ Program ...@@ -195,6 +249,8 @@ Program
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_Program`
.. _api_fluid_program_guard: .. _api_fluid_program_guard:
program_guard program_guard
...@@ -203,6 +259,8 @@ program_guard ...@@ -203,6 +259,8 @@ program_guard
.. autofunction:: paddle.fluid.program_guard .. autofunction:: paddle.fluid.program_guard
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_program_guard`
.. _api_fluid_release_memory: .. _api_fluid_release_memory:
release_memory release_memory
...@@ -211,6 +269,8 @@ release_memory ...@@ -211,6 +269,8 @@ release_memory
.. autofunction:: paddle.fluid.release_memory .. autofunction:: paddle.fluid.release_memory
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_release_memory`
.. _api_fluid_Scope: .. _api_fluid_Scope:
Scope Scope
...@@ -220,6 +280,8 @@ Scope ...@@ -220,6 +280,8 @@ Scope
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_Scope`
.. _api_fluid_scope_guard: .. _api_fluid_scope_guard:
scope_guard scope_guard
...@@ -228,6 +290,8 @@ scope_guard ...@@ -228,6 +290,8 @@ scope_guard
.. autofunction:: paddle.fluid.scope_guard .. autofunction:: paddle.fluid.scope_guard
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_scope_guard`
.. _api_fluid_Tensor: .. _api_fluid_Tensor:
Tensor Tensor
...@@ -237,6 +301,8 @@ Tensor ...@@ -237,6 +301,8 @@ Tensor
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_Tensor`
.. _api_fluid_WeightNormParamAttr: .. _api_fluid_WeightNormParamAttr:
WeightNormParamAttr WeightNormParamAttr
...@@ -246,3 +312,5 @@ WeightNormParamAttr ...@@ -246,3 +312,5 @@ WeightNormParamAttr
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_WeightNormParamAttr`
doc/fluid/api/gen_doc.sh
浏览文件 @ cb4f4929
#!/bin/bash #!/bin/bash
python gen_doc.py layers --submodules control_flow device io nn ops tensor learning_rate_scheduler detection metric_op > layers.rst python gen_doc.py layers --submodules control_flow device io nn ops tensor learning_rate_scheduler detection metric_op > layers.rst
for module in data_feeder clip metrics executor initializer io nets optimizer param_attr profiler regularizer transpiler recordio_writer backward average profiler for module in data_feeder clip metrics executor initializer io nets optimizer profiler regularizer transpiler recordio_writer backward average profiler
do do
python gen_doc.py ${module} > ${module}.rst python gen_doc.py ${module} > ${module}.rst
done done
......
doc/fluid/api/index_cn.rst
浏览文件 @ cb4f4929
============= =============
API 说明文档 API Reference
============= =============
.. toctree:: .. toctree::
:maxdepth: 1 :maxdepth: 1
api_guides/index.rst
fluid.rst fluid.rst
average.rst average.rst
backward.rst backward.rst
......
doc/fluid/api/index_en.rst
浏览文件 @ cb4f4929
...@@ -5,8 +5,6 @@ API Reference ...@@ -5,8 +5,6 @@ API Reference
.. toctree:: .. toctree::
:maxdepth: 1 :maxdepth: 1
api_guides/index.rst
fluid.rst fluid.rst
average.rst average.rst
backward.rst backward.rst
......
doc/fluid/api/initializer.rst
浏览文件 @ cb4f4929
...@@ -14,6 +14,8 @@ Bilinear ...@@ -14,6 +14,8 @@ Bilinear
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_Bilinear`
.. _api_fluid_initializer_BilinearInitializer: .. _api_fluid_initializer_BilinearInitializer:
BilinearInitializer BilinearInitializer
...@@ -23,6 +25,8 @@ BilinearInitializer ...@@ -23,6 +25,8 @@ BilinearInitializer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_BilinearInitializer`
.. _api_fluid_initializer_Constant: .. _api_fluid_initializer_Constant:
Constant Constant
...@@ -32,6 +36,8 @@ Constant ...@@ -32,6 +36,8 @@ Constant
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_Constant`
.. _api_fluid_initializer_ConstantInitializer: .. _api_fluid_initializer_ConstantInitializer:
ConstantInitializer ConstantInitializer
...@@ -41,6 +47,8 @@ ConstantInitializer ...@@ -41,6 +47,8 @@ ConstantInitializer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_ConstantInitializer`
.. _api_fluid_initializer_force_init_on_cpu: .. _api_fluid_initializer_force_init_on_cpu:
force_init_on_cpu force_init_on_cpu
...@@ -49,6 +57,8 @@ force_init_on_cpu ...@@ -49,6 +57,8 @@ force_init_on_cpu
.. autofunction:: paddle.fluid.initializer.force_init_on_cpu .. autofunction:: paddle.fluid.initializer.force_init_on_cpu
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_force_init_on_cpu`
.. _api_fluid_initializer_init_on_cpu: .. _api_fluid_initializer_init_on_cpu:
init_on_cpu init_on_cpu
...@@ -57,6 +67,8 @@ init_on_cpu ...@@ -57,6 +67,8 @@ init_on_cpu
.. autofunction:: paddle.fluid.initializer.init_on_cpu .. autofunction:: paddle.fluid.initializer.init_on_cpu
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_init_on_cpu`
.. _api_fluid_initializer_MSRA: .. _api_fluid_initializer_MSRA:
MSRA MSRA
...@@ -66,6 +78,8 @@ MSRA ...@@ -66,6 +78,8 @@ MSRA
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_MSRA`
.. _api_fluid_initializer_MSRAInitializer: .. _api_fluid_initializer_MSRAInitializer:
MSRAInitializer MSRAInitializer
...@@ -75,6 +89,8 @@ MSRAInitializer ...@@ -75,6 +89,8 @@ MSRAInitializer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_MSRAInitializer`
.. _api_fluid_initializer_Normal: .. _api_fluid_initializer_Normal:
Normal Normal
...@@ -84,6 +100,8 @@ Normal ...@@ -84,6 +100,8 @@ Normal
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_Normal`
.. _api_fluid_initializer_NormalInitializer: .. _api_fluid_initializer_NormalInitializer:
NormalInitializer NormalInitializer
...@@ -93,6 +111,8 @@ NormalInitializer ...@@ -93,6 +111,8 @@ NormalInitializer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_NormalInitializer`
.. _api_fluid_initializer_TruncatedNormal: .. _api_fluid_initializer_TruncatedNormal:
TruncatedNormal TruncatedNormal
...@@ -102,6 +122,8 @@ TruncatedNormal ...@@ -102,6 +122,8 @@ TruncatedNormal
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_TruncatedNormal`
.. _api_fluid_initializer_TruncatedNormalInitializer: .. _api_fluid_initializer_TruncatedNormalInitializer:
TruncatedNormalInitializer TruncatedNormalInitializer
...@@ -111,6 +133,8 @@ TruncatedNormalInitializer ...@@ -111,6 +133,8 @@ TruncatedNormalInitializer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_TruncatedNormalInitializer`
.. _api_fluid_initializer_Uniform: .. _api_fluid_initializer_Uniform:
Uniform Uniform
...@@ -120,6 +144,8 @@ Uniform ...@@ -120,6 +144,8 @@ Uniform
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_Uniform`
.. _api_fluid_initializer_UniformInitializer: .. _api_fluid_initializer_UniformInitializer:
UniformInitializer UniformInitializer
...@@ -129,6 +155,8 @@ UniformInitializer ...@@ -129,6 +155,8 @@ UniformInitializer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_UniformInitializer`
.. _api_fluid_initializer_Xavier: .. _api_fluid_initializer_Xavier:
Xavier Xavier
...@@ -138,6 +166,8 @@ Xavier ...@@ -138,6 +166,8 @@ Xavier
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_Xavier`
.. _api_fluid_initializer_XavierInitializer: .. _api_fluid_initializer_XavierInitializer:
XavierInitializer XavierInitializer
...@@ -147,3 +177,5 @@ XavierInitializer ...@@ -147,3 +177,5 @@ XavierInitializer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_initializer_XavierInitializer`
doc/fluid/api/io.rst
浏览文件 @ cb4f4929
...@@ -13,6 +13,8 @@ load_inference_model ...@@ -13,6 +13,8 @@ load_inference_model
.. autofunction:: paddle.fluid.io.load_inference_model .. autofunction:: paddle.fluid.io.load_inference_model
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_io_load_inference_model`
.. _api_fluid_io_load_params: .. _api_fluid_io_load_params:
load_params load_params
...@@ -21,6 +23,8 @@ load_params ...@@ -21,6 +23,8 @@ load_params
.. autofunction:: paddle.fluid.io.load_params .. autofunction:: paddle.fluid.io.load_params
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_io_load_params`
.. _api_fluid_io_load_persistables: .. _api_fluid_io_load_persistables:
load_persistables load_persistables
...@@ -29,6 +33,8 @@ load_persistables ...@@ -29,6 +33,8 @@ load_persistables
.. autofunction:: paddle.fluid.io.load_persistables .. autofunction:: paddle.fluid.io.load_persistables
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_io_load_persistables`
.. _api_fluid_io_load_vars: .. _api_fluid_io_load_vars:
load_vars load_vars
...@@ -37,6 +43,8 @@ load_vars ...@@ -37,6 +43,8 @@ load_vars
.. autofunction:: paddle.fluid.io.load_vars .. autofunction:: paddle.fluid.io.load_vars
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_io_load_vars`
.. _api_fluid_io_save_inference_model: .. _api_fluid_io_save_inference_model:
save_inference_model save_inference_model
...@@ -45,6 +53,8 @@ save_inference_model ...@@ -45,6 +53,8 @@ save_inference_model
.. autofunction:: paddle.fluid.io.save_inference_model .. autofunction:: paddle.fluid.io.save_inference_model
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_io_save_inference_model`
.. _api_fluid_io_save_params: .. _api_fluid_io_save_params:
save_params save_params
...@@ -53,6 +63,8 @@ save_params ...@@ -53,6 +63,8 @@ save_params
.. autofunction:: paddle.fluid.io.save_params .. autofunction:: paddle.fluid.io.save_params
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_io_save_params`
.. _api_fluid_io_save_persistables: .. _api_fluid_io_save_persistables:
save_persistables save_persistables
...@@ -61,6 +73,8 @@ save_persistables ...@@ -61,6 +73,8 @@ save_persistables
.. autofunction:: paddle.fluid.io.save_persistables .. autofunction:: paddle.fluid.io.save_persistables
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_io_save_persistables`
.. _api_fluid_io_save_vars: .. _api_fluid_io_save_vars:
save_vars save_vars
...@@ -69,3 +83,5 @@ save_vars ...@@ -69,3 +83,5 @@ save_vars
.. autofunction:: paddle.fluid.io.save_vars .. autofunction:: paddle.fluid.io.save_vars
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_io_save_vars`
doc/fluid/api/layers.rst
浏览文件 @ cb4f4929
...@@ -16,6 +16,8 @@ array_length ...@@ -16,6 +16,8 @@ array_length
.. autofunction:: paddle.fluid.layers.array_length .. autofunction:: paddle.fluid.layers.array_length
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_array_length`
.. _api_fluid_layers_array_read: .. _api_fluid_layers_array_read:
array_read array_read
...@@ -24,6 +26,8 @@ array_read ...@@ -24,6 +26,8 @@ array_read
.. autofunction:: paddle.fluid.layers.array_read .. autofunction:: paddle.fluid.layers.array_read
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_array_read`
.. _api_fluid_layers_array_write: .. _api_fluid_layers_array_write:
array_write array_write
...@@ -32,6 +36,8 @@ array_write ...@@ -32,6 +36,8 @@ array_write
.. autofunction:: paddle.fluid.layers.array_write .. autofunction:: paddle.fluid.layers.array_write
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_array_write`
.. _api_fluid_layers_create_array: .. _api_fluid_layers_create_array:
create_array create_array
...@@ -40,6 +46,8 @@ create_array ...@@ -40,6 +46,8 @@ create_array
.. autofunction:: paddle.fluid.layers.create_array .. autofunction:: paddle.fluid.layers.create_array
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_create_array`
.. _api_fluid_layers_DynamicRNN: .. _api_fluid_layers_DynamicRNN:
DynamicRNN DynamicRNN
...@@ -49,6 +57,8 @@ DynamicRNN ...@@ -49,6 +57,8 @@ DynamicRNN
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_DynamicRNN`
.. _api_fluid_layers_equal: .. _api_fluid_layers_equal:
equal equal
...@@ -57,6 +67,8 @@ equal ...@@ -57,6 +67,8 @@ equal
.. autofunction:: paddle.fluid.layers.equal .. autofunction:: paddle.fluid.layers.equal
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_equal`
.. _api_fluid_layers_IfElse: .. _api_fluid_layers_IfElse:
IfElse IfElse
...@@ -66,6 +78,8 @@ IfElse ...@@ -66,6 +78,8 @@ IfElse
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_IfElse`
.. _api_fluid_layers_increment: .. _api_fluid_layers_increment:
increment increment
...@@ -74,6 +88,8 @@ increment ...@@ -74,6 +88,8 @@ increment
.. autofunction:: paddle.fluid.layers.increment .. autofunction:: paddle.fluid.layers.increment
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_increment`
.. _api_fluid_layers_is_empty: .. _api_fluid_layers_is_empty:
is_empty is_empty
...@@ -82,6 +98,8 @@ is_empty ...@@ -82,6 +98,8 @@ is_empty
.. autofunction:: paddle.fluid.layers.is_empty .. autofunction:: paddle.fluid.layers.is_empty
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_is_empty`
.. _api_fluid_layers_less_than: .. _api_fluid_layers_less_than:
less_than less_than
...@@ -90,6 +108,8 @@ less_than ...@@ -90,6 +108,8 @@ less_than
.. autofunction:: paddle.fluid.layers.less_than .. autofunction:: paddle.fluid.layers.less_than
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_less_than`
.. _api_fluid_layers_Print: .. _api_fluid_layers_Print:
Print Print
...@@ -98,6 +118,8 @@ Print ...@@ -98,6 +118,8 @@ Print
.. autofunction:: paddle.fluid.layers.Print .. autofunction:: paddle.fluid.layers.Print
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_Print`
.. _api_fluid_layers_reorder_lod_tensor_by_rank: .. _api_fluid_layers_reorder_lod_tensor_by_rank:
reorder_lod_tensor_by_rank reorder_lod_tensor_by_rank
...@@ -106,6 +128,8 @@ reorder_lod_tensor_by_rank ...@@ -106,6 +128,8 @@ reorder_lod_tensor_by_rank
.. autofunction:: paddle.fluid.layers.reorder_lod_tensor_by_rank .. autofunction:: paddle.fluid.layers.reorder_lod_tensor_by_rank
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_reorder_lod_tensor_by_rank`
.. _api_fluid_layers_StaticRNN: .. _api_fluid_layers_StaticRNN:
StaticRNN StaticRNN
...@@ -115,6 +139,8 @@ StaticRNN ...@@ -115,6 +139,8 @@ StaticRNN
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_StaticRNN`
.. _api_fluid_layers_Switch: .. _api_fluid_layers_Switch:
Switch Switch
...@@ -124,6 +150,8 @@ Switch ...@@ -124,6 +150,8 @@ Switch
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_Switch`
.. _api_fluid_layers_While: .. _api_fluid_layers_While:
While While
...@@ -133,6 +161,8 @@ While ...@@ -133,6 +161,8 @@ While
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_While`
device device
====== ======
...@@ -147,6 +177,18 @@ batch ...@@ -147,6 +177,18 @@ batch
.. autofunction:: paddle.fluid.layers.batch .. autofunction:: paddle.fluid.layers.batch
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_batch`
.. _api_fluid_layers_create_py_reader_by_data:
create_py_reader_by_data
------------------------
.. autofunction:: paddle.fluid.layers.create_py_reader_by_data
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_create_py_reader_by_data`
.. _api_fluid_layers_data: .. _api_fluid_layers_data:
data data
...@@ -155,6 +197,8 @@ data ...@@ -155,6 +197,8 @@ data
.. autofunction:: paddle.fluid.layers.data .. autofunction:: paddle.fluid.layers.data
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_data`
.. _api_fluid_layers_double_buffer: .. _api_fluid_layers_double_buffer:
double_buffer double_buffer
...@@ -163,6 +207,8 @@ double_buffer ...@@ -163,6 +207,8 @@ double_buffer
.. autofunction:: paddle.fluid.layers.double_buffer .. autofunction:: paddle.fluid.layers.double_buffer
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_double_buffer`
.. _api_fluid_layers_load: .. _api_fluid_layers_load:
load load
...@@ -171,6 +217,8 @@ load ...@@ -171,6 +217,8 @@ load
.. autofunction:: paddle.fluid.layers.load .. autofunction:: paddle.fluid.layers.load
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_load`
.. _api_fluid_layers_open_files: .. _api_fluid_layers_open_files:
open_files open_files
...@@ -179,6 +227,8 @@ open_files ...@@ -179,6 +227,8 @@ open_files
.. autofunction:: paddle.fluid.layers.open_files .. autofunction:: paddle.fluid.layers.open_files
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_open_files`
.. _api_fluid_layers_Preprocessor: .. _api_fluid_layers_Preprocessor:
Preprocessor Preprocessor
...@@ -188,6 +238,8 @@ Preprocessor ...@@ -188,6 +238,8 @@ Preprocessor
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_Preprocessor`
.. _api_fluid_layers_py_reader: .. _api_fluid_layers_py_reader:
py_reader py_reader
...@@ -196,6 +248,8 @@ py_reader ...@@ -196,6 +248,8 @@ py_reader
.. autofunction:: paddle.fluid.layers.py_reader .. autofunction:: paddle.fluid.layers.py_reader
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_py_reader`
.. _api_fluid_layers_random_data_generator: .. _api_fluid_layers_random_data_generator:
random_data_generator random_data_generator
...@@ -204,6 +258,8 @@ random_data_generator ...@@ -204,6 +258,8 @@ random_data_generator
.. autofunction:: paddle.fluid.layers.random_data_generator .. autofunction:: paddle.fluid.layers.random_data_generator
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_random_data_generator`
.. _api_fluid_layers_read_file: .. _api_fluid_layers_read_file:
read_file read_file
...@@ -212,6 +268,8 @@ read_file ...@@ -212,6 +268,8 @@ read_file
.. autofunction:: paddle.fluid.layers.read_file .. autofunction:: paddle.fluid.layers.read_file
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_read_file`
.. _api_fluid_layers_shuffle: .. _api_fluid_layers_shuffle:
shuffle shuffle
...@@ -220,9 +278,41 @@ shuffle ...@@ -220,9 +278,41 @@ shuffle
.. autofunction:: paddle.fluid.layers.shuffle .. autofunction:: paddle.fluid.layers.shuffle
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_shuffle`
nn nn
== ==
.. _api_fluid_layers_add_position_encoding:
add_position_encoding
---------------------
.. autofunction:: paddle.fluid.layers.add_position_encoding
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_add_position_encoding`
.. _api_fluid_layers_affine_channel:
affine_channel
--------------
.. autofunction:: paddle.fluid.layers.affine_channel
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_affine_channel`
.. _api_fluid_layers_affine_grid:
affine_grid
-----------
.. autofunction:: paddle.fluid.layers.affine_grid
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_affine_grid`
.. _api_fluid_layers_autoincreased_step_counter: .. _api_fluid_layers_autoincreased_step_counter:
autoincreased_step_counter autoincreased_step_counter
...@@ -231,6 +321,8 @@ autoincreased_step_counter ...@@ -231,6 +321,8 @@ autoincreased_step_counter
.. autofunction:: paddle.fluid.layers.autoincreased_step_counter .. autofunction:: paddle.fluid.layers.autoincreased_step_counter
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_autoincreased_step_counter`
.. _api_fluid_layers_batch_norm: .. _api_fluid_layers_batch_norm:
batch_norm batch_norm
...@@ -239,6 +331,8 @@ batch_norm ...@@ -239,6 +331,8 @@ batch_norm
.. autofunction:: paddle.fluid.layers.batch_norm .. autofunction:: paddle.fluid.layers.batch_norm
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_batch_norm`
.. _api_fluid_layers_beam_search: .. _api_fluid_layers_beam_search:
beam_search beam_search
...@@ -247,6 +341,8 @@ beam_search ...@@ -247,6 +341,8 @@ beam_search
.. autofunction:: paddle.fluid.layers.beam_search .. autofunction:: paddle.fluid.layers.beam_search
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_beam_search`
.. _api_fluid_layers_beam_search_decode: .. _api_fluid_layers_beam_search_decode:
beam_search_decode beam_search_decode
...@@ -255,6 +351,18 @@ beam_search_decode ...@@ -255,6 +351,18 @@ beam_search_decode
.. autofunction:: paddle.fluid.layers.beam_search_decode .. autofunction:: paddle.fluid.layers.beam_search_decode
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_beam_search_decode`
.. _api_fluid_layers_bilinear_tensor_product:
bilinear_tensor_product
-----------------------
.. autofunction:: paddle.fluid.layers.bilinear_tensor_product
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_bilinear_tensor_product`
.. _api_fluid_layers_brelu: .. _api_fluid_layers_brelu:
brelu brelu
...@@ -263,6 +371,8 @@ brelu ...@@ -263,6 +371,8 @@ brelu
.. autofunction:: paddle.fluid.layers.brelu .. autofunction:: paddle.fluid.layers.brelu
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_brelu`
.. _api_fluid_layers_chunk_eval: .. _api_fluid_layers_chunk_eval:
chunk_eval chunk_eval
...@@ -271,6 +381,8 @@ chunk_eval ...@@ -271,6 +381,8 @@ chunk_eval
.. autofunction:: paddle.fluid.layers.chunk_eval .. autofunction:: paddle.fluid.layers.chunk_eval
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_chunk_eval`
.. _api_fluid_layers_clip: .. _api_fluid_layers_clip:
clip clip
...@@ -279,6 +391,8 @@ clip ...@@ -279,6 +391,8 @@ clip
.. autofunction:: paddle.fluid.layers.clip .. autofunction:: paddle.fluid.layers.clip
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_clip`
.. _api_fluid_layers_clip_by_norm: .. _api_fluid_layers_clip_by_norm:
clip_by_norm clip_by_norm
...@@ -287,6 +401,8 @@ clip_by_norm ...@@ -287,6 +401,8 @@ clip_by_norm
.. autofunction:: paddle.fluid.layers.clip_by_norm .. autofunction:: paddle.fluid.layers.clip_by_norm
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_clip_by_norm`
.. _api_fluid_layers_conv2d: .. _api_fluid_layers_conv2d:
conv2d conv2d
...@@ -295,6 +411,8 @@ conv2d ...@@ -295,6 +411,8 @@ conv2d
.. autofunction:: paddle.fluid.layers.conv2d .. autofunction:: paddle.fluid.layers.conv2d
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_conv2d`
.. _api_fluid_layers_conv2d_transpose: .. _api_fluid_layers_conv2d_transpose:
conv2d_transpose conv2d_transpose
...@@ -303,6 +421,8 @@ conv2d_transpose ...@@ -303,6 +421,8 @@ conv2d_transpose
.. autofunction:: paddle.fluid.layers.conv2d_transpose .. autofunction:: paddle.fluid.layers.conv2d_transpose
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_conv2d_transpose`
.. _api_fluid_layers_conv3d: .. _api_fluid_layers_conv3d:
conv3d conv3d
...@@ -311,6 +431,8 @@ conv3d ...@@ -311,6 +431,8 @@ conv3d
.. autofunction:: paddle.fluid.layers.conv3d .. autofunction:: paddle.fluid.layers.conv3d
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_conv3d`
.. _api_fluid_layers_conv3d_transpose: .. _api_fluid_layers_conv3d_transpose:
conv3d_transpose conv3d_transpose
...@@ -319,6 +441,8 @@ conv3d_transpose ...@@ -319,6 +441,8 @@ conv3d_transpose
.. autofunction:: paddle.fluid.layers.conv3d_transpose .. autofunction:: paddle.fluid.layers.conv3d_transpose
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_conv3d_transpose`
.. _api_fluid_layers_cos_sim: .. _api_fluid_layers_cos_sim:
cos_sim cos_sim
...@@ -327,6 +451,8 @@ cos_sim ...@@ -327,6 +451,8 @@ cos_sim
.. autofunction:: paddle.fluid.layers.cos_sim .. autofunction:: paddle.fluid.layers.cos_sim
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_cos_sim`
.. _api_fluid_layers_crf_decoding: .. _api_fluid_layers_crf_decoding:
crf_decoding crf_decoding
...@@ -335,6 +461,8 @@ crf_decoding ...@@ -335,6 +461,8 @@ crf_decoding
.. autofunction:: paddle.fluid.layers.crf_decoding .. autofunction:: paddle.fluid.layers.crf_decoding
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_crf_decoding`
.. _api_fluid_layers_crop: .. _api_fluid_layers_crop:
crop crop
...@@ -343,6 +471,8 @@ crop ...@@ -343,6 +471,8 @@ crop
.. autofunction:: paddle.fluid.layers.crop .. autofunction:: paddle.fluid.layers.crop
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_crop`
.. _api_fluid_layers_cross_entropy: .. _api_fluid_layers_cross_entropy:
cross_entropy cross_entropy
...@@ -351,6 +481,8 @@ cross_entropy ...@@ -351,6 +481,8 @@ cross_entropy
.. autofunction:: paddle.fluid.layers.cross_entropy .. autofunction:: paddle.fluid.layers.cross_entropy
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_cross_entropy`
.. _api_fluid_layers_ctc_greedy_decoder: .. _api_fluid_layers_ctc_greedy_decoder:
ctc_greedy_decoder ctc_greedy_decoder
...@@ -359,6 +491,8 @@ ctc_greedy_decoder ...@@ -359,6 +491,8 @@ ctc_greedy_decoder
.. autofunction:: paddle.fluid.layers.ctc_greedy_decoder .. autofunction:: paddle.fluid.layers.ctc_greedy_decoder
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_ctc_greedy_decoder`
.. _api_fluid_layers_dice_loss: .. _api_fluid_layers_dice_loss:
dice_loss dice_loss
...@@ -367,6 +501,8 @@ dice_loss ...@@ -367,6 +501,8 @@ dice_loss
.. autofunction:: paddle.fluid.layers.dice_loss .. autofunction:: paddle.fluid.layers.dice_loss
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_dice_loss`
.. _api_fluid_layers_dropout: .. _api_fluid_layers_dropout:
dropout dropout
...@@ -375,6 +511,8 @@ dropout ...@@ -375,6 +511,8 @@ dropout
.. autofunction:: paddle.fluid.layers.dropout .. autofunction:: paddle.fluid.layers.dropout
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_dropout`
.. _api_fluid_layers_dynamic_gru: .. _api_fluid_layers_dynamic_gru:
dynamic_gru dynamic_gru
...@@ -383,6 +521,8 @@ dynamic_gru ...@@ -383,6 +521,8 @@ dynamic_gru
.. autofunction:: paddle.fluid.layers.dynamic_gru .. autofunction:: paddle.fluid.layers.dynamic_gru
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_dynamic_gru`
.. _api_fluid_layers_dynamic_lstm: .. _api_fluid_layers_dynamic_lstm:
dynamic_lstm dynamic_lstm
...@@ -391,6 +531,8 @@ dynamic_lstm ...@@ -391,6 +531,8 @@ dynamic_lstm
.. autofunction:: paddle.fluid.layers.dynamic_lstm .. autofunction:: paddle.fluid.layers.dynamic_lstm
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_dynamic_lstm`
.. _api_fluid_layers_dynamic_lstmp: .. _api_fluid_layers_dynamic_lstmp:
dynamic_lstmp dynamic_lstmp
...@@ -399,6 +541,8 @@ dynamic_lstmp ...@@ -399,6 +541,8 @@ dynamic_lstmp
.. autofunction:: paddle.fluid.layers.dynamic_lstmp .. autofunction:: paddle.fluid.layers.dynamic_lstmp
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_dynamic_lstmp`
.. _api_fluid_layers_edit_distance: .. _api_fluid_layers_edit_distance:
edit_distance edit_distance
...@@ -407,6 +551,8 @@ edit_distance ...@@ -407,6 +551,8 @@ edit_distance
.. autofunction:: paddle.fluid.layers.edit_distance .. autofunction:: paddle.fluid.layers.edit_distance
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_edit_distance`
.. _api_fluid_layers_elementwise_add: .. _api_fluid_layers_elementwise_add:
elementwise_add elementwise_add
...@@ -415,6 +561,8 @@ elementwise_add ...@@ -415,6 +561,8 @@ elementwise_add
.. autofunction:: paddle.fluid.layers.elementwise_add .. autofunction:: paddle.fluid.layers.elementwise_add
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_elementwise_add`
.. _api_fluid_layers_elementwise_div: .. _api_fluid_layers_elementwise_div:
elementwise_div elementwise_div
...@@ -423,6 +571,8 @@ elementwise_div ...@@ -423,6 +571,8 @@ elementwise_div
.. autofunction:: paddle.fluid.layers.elementwise_div .. autofunction:: paddle.fluid.layers.elementwise_div
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_elementwise_div`
.. _api_fluid_layers_elementwise_max: .. _api_fluid_layers_elementwise_max:
elementwise_max elementwise_max
...@@ -431,6 +581,8 @@ elementwise_max ...@@ -431,6 +581,8 @@ elementwise_max
.. autofunction:: paddle.fluid.layers.elementwise_max .. autofunction:: paddle.fluid.layers.elementwise_max
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_elementwise_max`
.. _api_fluid_layers_elementwise_min: .. _api_fluid_layers_elementwise_min:
elementwise_min elementwise_min
...@@ -439,6 +591,8 @@ elementwise_min ...@@ -439,6 +591,8 @@ elementwise_min
.. autofunction:: paddle.fluid.layers.elementwise_min .. autofunction:: paddle.fluid.layers.elementwise_min
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_elementwise_min`
.. _api_fluid_layers_elementwise_mul: .. _api_fluid_layers_elementwise_mul:
elementwise_mul elementwise_mul
...@@ -447,6 +601,8 @@ elementwise_mul ...@@ -447,6 +601,8 @@ elementwise_mul
.. autofunction:: paddle.fluid.layers.elementwise_mul .. autofunction:: paddle.fluid.layers.elementwise_mul
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_elementwise_mul`
.. _api_fluid_layers_elementwise_pow: .. _api_fluid_layers_elementwise_pow:
elementwise_pow elementwise_pow
...@@ -455,6 +611,8 @@ elementwise_pow ...@@ -455,6 +611,8 @@ elementwise_pow
.. autofunction:: paddle.fluid.layers.elementwise_pow .. autofunction:: paddle.fluid.layers.elementwise_pow
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_elementwise_pow`
.. _api_fluid_layers_elementwise_sub: .. _api_fluid_layers_elementwise_sub:
elementwise_sub elementwise_sub
...@@ -463,6 +621,8 @@ elementwise_sub ...@@ -463,6 +621,8 @@ elementwise_sub
.. autofunction:: paddle.fluid.layers.elementwise_sub .. autofunction:: paddle.fluid.layers.elementwise_sub
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_elementwise_sub`
.. _api_fluid_layers_elu: .. _api_fluid_layers_elu:
elu elu
...@@ -471,6 +631,8 @@ elu ...@@ -471,6 +631,8 @@ elu
.. autofunction:: paddle.fluid.layers.elu .. autofunction:: paddle.fluid.layers.elu
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_elu`
.. _api_fluid_layers_embedding: .. _api_fluid_layers_embedding:
embedding embedding
...@@ -479,6 +641,8 @@ embedding ...@@ -479,6 +641,8 @@ embedding
.. autofunction:: paddle.fluid.layers.embedding .. autofunction:: paddle.fluid.layers.embedding
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_embedding`
.. _api_fluid_layers_expand: .. _api_fluid_layers_expand:
expand expand
...@@ -487,6 +651,8 @@ expand ...@@ -487,6 +651,8 @@ expand
.. autofunction:: paddle.fluid.layers.expand .. autofunction:: paddle.fluid.layers.expand
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_expand`
.. _api_fluid_layers_fc: .. _api_fluid_layers_fc:
fc fc
...@@ -495,6 +661,8 @@ fc ...@@ -495,6 +661,8 @@ fc
.. autofunction:: paddle.fluid.layers.fc .. autofunction:: paddle.fluid.layers.fc
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_fc`
.. _api_fluid_layers_flatten: .. _api_fluid_layers_flatten:
flatten flatten
...@@ -503,6 +671,8 @@ flatten ...@@ -503,6 +671,8 @@ flatten
.. autofunction:: paddle.fluid.layers.flatten .. autofunction:: paddle.fluid.layers.flatten
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_flatten`
.. _api_fluid_layers_gather: .. _api_fluid_layers_gather:
gather gather
...@@ -511,6 +681,8 @@ gather ...@@ -511,6 +681,8 @@ gather
.. autofunction:: paddle.fluid.layers.gather .. autofunction:: paddle.fluid.layers.gather
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_gather`
.. _api_fluid_layers_gaussian_random: .. _api_fluid_layers_gaussian_random:
gaussian_random gaussian_random
...@@ -519,6 +691,8 @@ gaussian_random ...@@ -519,6 +691,8 @@ gaussian_random
.. autofunction:: paddle.fluid.layers.gaussian_random .. autofunction:: paddle.fluid.layers.gaussian_random
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_gaussian_random`
.. _api_fluid_layers_gaussian_random_batch_size_like: .. _api_fluid_layers_gaussian_random_batch_size_like:
gaussian_random_batch_size_like gaussian_random_batch_size_like
...@@ -527,6 +701,38 @@ gaussian_random_batch_size_like ...@@ -527,6 +701,38 @@ gaussian_random_batch_size_like
.. autofunction:: paddle.fluid.layers.gaussian_random_batch_size_like .. autofunction:: paddle.fluid.layers.gaussian_random_batch_size_like
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_gaussian_random_batch_size_like`
.. _api_fluid_layers_get_tensor_from_selected_rows:
get_tensor_from_selected_rows
-----------------------------
.. autofunction:: paddle.fluid.layers.get_tensor_from_selected_rows
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_get_tensor_from_selected_rows`
.. _api_fluid_layers_grid_sampler:
grid_sampler
------------
.. autofunction:: paddle.fluid.layers.grid_sampler
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_grid_sampler`
.. _api_fluid_layers_group_norm:
group_norm
----------
.. autofunction:: paddle.fluid.layers.group_norm
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_group_norm`
.. _api_fluid_layers_gru_unit: .. _api_fluid_layers_gru_unit:
gru_unit gru_unit
...@@ -535,6 +741,8 @@ gru_unit ...@@ -535,6 +741,8 @@ gru_unit
.. autofunction:: paddle.fluid.layers.gru_unit .. autofunction:: paddle.fluid.layers.gru_unit
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_gru_unit`
.. _api_fluid_layers_hard_sigmoid: .. _api_fluid_layers_hard_sigmoid:
hard_sigmoid hard_sigmoid
...@@ -543,6 +751,18 @@ hard_sigmoid ...@@ -543,6 +751,18 @@ hard_sigmoid
.. autofunction:: paddle.fluid.layers.hard_sigmoid .. autofunction:: paddle.fluid.layers.hard_sigmoid
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_hard_sigmoid`
.. _api_fluid_layers_hash:
hash
----
.. autofunction:: paddle.fluid.layers.hash
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_hash`
.. _api_fluid_layers_hsigmoid: .. _api_fluid_layers_hsigmoid:
hsigmoid hsigmoid
...@@ -551,6 +771,8 @@ hsigmoid ...@@ -551,6 +771,8 @@ hsigmoid
.. autofunction:: paddle.fluid.layers.hsigmoid .. autofunction:: paddle.fluid.layers.hsigmoid
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_hsigmoid`
.. _api_fluid_layers_im2sequence: .. _api_fluid_layers_im2sequence:
im2sequence im2sequence
...@@ -559,6 +781,8 @@ im2sequence ...@@ -559,6 +781,8 @@ im2sequence
.. autofunction:: paddle.fluid.layers.im2sequence .. autofunction:: paddle.fluid.layers.im2sequence
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_im2sequence`
.. _api_fluid_layers_image_resize: .. _api_fluid_layers_image_resize:
image_resize image_resize
...@@ -567,6 +791,8 @@ image_resize ...@@ -567,6 +791,8 @@ image_resize
.. autofunction:: paddle.fluid.layers.image_resize .. autofunction:: paddle.fluid.layers.image_resize
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_image_resize`
.. _api_fluid_layers_image_resize_short: .. _api_fluid_layers_image_resize_short:
image_resize_short image_resize_short
...@@ -575,6 +801,8 @@ image_resize_short ...@@ -575,6 +801,8 @@ image_resize_short
.. autofunction:: paddle.fluid.layers.image_resize_short .. autofunction:: paddle.fluid.layers.image_resize_short
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_image_resize_short`
.. _api_fluid_layers_l2_normalize: .. _api_fluid_layers_l2_normalize:
l2_normalize l2_normalize
...@@ -583,6 +811,8 @@ l2_normalize ...@@ -583,6 +811,8 @@ l2_normalize
.. autofunction:: paddle.fluid.layers.l2_normalize .. autofunction:: paddle.fluid.layers.l2_normalize
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_l2_normalize`
.. _api_fluid_layers_label_smooth: .. _api_fluid_layers_label_smooth:
label_smooth label_smooth
...@@ -591,6 +821,8 @@ label_smooth ...@@ -591,6 +821,8 @@ label_smooth
.. autofunction:: paddle.fluid.layers.label_smooth .. autofunction:: paddle.fluid.layers.label_smooth
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_label_smooth`
.. _api_fluid_layers_layer_norm: .. _api_fluid_layers_layer_norm:
layer_norm layer_norm
...@@ -599,6 +831,8 @@ layer_norm ...@@ -599,6 +831,8 @@ layer_norm
.. autofunction:: paddle.fluid.layers.layer_norm .. autofunction:: paddle.fluid.layers.layer_norm
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_layer_norm`
.. _api_fluid_layers_leaky_relu: .. _api_fluid_layers_leaky_relu:
leaky_relu leaky_relu
...@@ -607,6 +841,8 @@ leaky_relu ...@@ -607,6 +841,8 @@ leaky_relu
.. autofunction:: paddle.fluid.layers.leaky_relu .. autofunction:: paddle.fluid.layers.leaky_relu
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_leaky_relu`
.. _api_fluid_layers_linear_chain_crf: .. _api_fluid_layers_linear_chain_crf:
linear_chain_crf linear_chain_crf
...@@ -615,6 +851,8 @@ linear_chain_crf ...@@ -615,6 +851,8 @@ linear_chain_crf
.. autofunction:: paddle.fluid.layers.linear_chain_crf .. autofunction:: paddle.fluid.layers.linear_chain_crf
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_linear_chain_crf`
.. _api_fluid_layers_lod_reset: .. _api_fluid_layers_lod_reset:
lod_reset lod_reset
...@@ -623,6 +861,8 @@ lod_reset ...@@ -623,6 +861,8 @@ lod_reset
.. autofunction:: paddle.fluid.layers.lod_reset .. autofunction:: paddle.fluid.layers.lod_reset
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_lod_reset`
.. _api_fluid_layers_log: .. _api_fluid_layers_log:
log log
...@@ -631,6 +871,18 @@ log ...@@ -631,6 +871,18 @@ log
.. autofunction:: paddle.fluid.layers.log .. autofunction:: paddle.fluid.layers.log
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_log`
.. _api_fluid_layers_log_loss:
log_loss
--------
.. autofunction:: paddle.fluid.layers.log_loss
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_log_loss`
.. _api_fluid_layers_logical_and: .. _api_fluid_layers_logical_and:
logical_and logical_and
...@@ -639,6 +891,8 @@ logical_and ...@@ -639,6 +891,8 @@ logical_and
.. autofunction:: paddle.fluid.layers.logical_and .. autofunction:: paddle.fluid.layers.logical_and
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_logical_and`
.. _api_fluid_layers_logical_not: .. _api_fluid_layers_logical_not:
logical_not logical_not
...@@ -647,6 +901,8 @@ logical_not ...@@ -647,6 +901,8 @@ logical_not
.. autofunction:: paddle.fluid.layers.logical_not .. autofunction:: paddle.fluid.layers.logical_not
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_logical_not`
.. _api_fluid_layers_logical_or: .. _api_fluid_layers_logical_or:
logical_or logical_or
...@@ -655,6 +911,8 @@ logical_or ...@@ -655,6 +911,8 @@ logical_or
.. autofunction:: paddle.fluid.layers.logical_or .. autofunction:: paddle.fluid.layers.logical_or
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_logical_or`
.. _api_fluid_layers_logical_xor: .. _api_fluid_layers_logical_xor:
logical_xor logical_xor
...@@ -663,6 +921,8 @@ logical_xor ...@@ -663,6 +921,8 @@ logical_xor
.. autofunction:: paddle.fluid.layers.logical_xor .. autofunction:: paddle.fluid.layers.logical_xor
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_logical_xor`
.. _api_fluid_layers_lrn: .. _api_fluid_layers_lrn:
lrn lrn
...@@ -671,6 +931,18 @@ lrn ...@@ -671,6 +931,18 @@ lrn
.. autofunction:: paddle.fluid.layers.lrn .. autofunction:: paddle.fluid.layers.lrn
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_lrn`
.. _api_fluid_layers_lstm:
lstm
----
.. autofunction:: paddle.fluid.layers.lstm
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_lstm`
.. _api_fluid_layers_lstm_unit: .. _api_fluid_layers_lstm_unit:
lstm_unit lstm_unit
...@@ -679,6 +951,18 @@ lstm_unit ...@@ -679,6 +951,18 @@ lstm_unit
.. autofunction:: paddle.fluid.layers.lstm_unit .. autofunction:: paddle.fluid.layers.lstm_unit
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_lstm_unit`
.. _api_fluid_layers_margin_rank_loss:
margin_rank_loss
----------------
.. autofunction:: paddle.fluid.layers.margin_rank_loss
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_margin_rank_loss`
.. _api_fluid_layers_matmul: .. _api_fluid_layers_matmul:
matmul matmul
...@@ -687,6 +971,8 @@ matmul ...@@ -687,6 +971,8 @@ matmul
.. autofunction:: paddle.fluid.layers.matmul .. autofunction:: paddle.fluid.layers.matmul
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_matmul`
.. _api_fluid_layers_maxout: .. _api_fluid_layers_maxout:
maxout maxout
...@@ -695,6 +981,8 @@ maxout ...@@ -695,6 +981,8 @@ maxout
.. autofunction:: paddle.fluid.layers.maxout .. autofunction:: paddle.fluid.layers.maxout
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_maxout`
.. _api_fluid_layers_mean: .. _api_fluid_layers_mean:
mean mean
...@@ -703,6 +991,8 @@ mean ...@@ -703,6 +991,8 @@ mean
.. autofunction:: paddle.fluid.layers.mean .. autofunction:: paddle.fluid.layers.mean
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_mean`
.. _api_fluid_layers_mean_iou: .. _api_fluid_layers_mean_iou:
mean_iou mean_iou
...@@ -711,6 +1001,18 @@ mean_iou ...@@ -711,6 +1001,18 @@ mean_iou
.. autofunction:: paddle.fluid.layers.mean_iou .. autofunction:: paddle.fluid.layers.mean_iou
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_mean_iou`
.. _api_fluid_layers_merge_selected_rows:
merge_selected_rows
-------------------
.. autofunction:: paddle.fluid.layers.merge_selected_rows
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_merge_selected_rows`
.. _api_fluid_layers_mul: .. _api_fluid_layers_mul:
mul mul
...@@ -719,6 +1021,8 @@ mul ...@@ -719,6 +1021,8 @@ mul
.. autofunction:: paddle.fluid.layers.mul .. autofunction:: paddle.fluid.layers.mul
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_mul`
.. _api_fluid_layers_multiplex: .. _api_fluid_layers_multiplex:
multiplex multiplex
...@@ -727,6 +1031,8 @@ multiplex ...@@ -727,6 +1031,8 @@ multiplex
.. autofunction:: paddle.fluid.layers.multiplex .. autofunction:: paddle.fluid.layers.multiplex
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_multiplex`
.. _api_fluid_layers_nce: .. _api_fluid_layers_nce:
nce nce
...@@ -735,6 +1041,8 @@ nce ...@@ -735,6 +1041,8 @@ nce
.. autofunction:: paddle.fluid.layers.nce .. autofunction:: paddle.fluid.layers.nce
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_nce`
.. _api_fluid_layers_one_hot: .. _api_fluid_layers_one_hot:
one_hot one_hot
...@@ -743,6 +1051,8 @@ one_hot ...@@ -743,6 +1051,8 @@ one_hot
.. autofunction:: paddle.fluid.layers.one_hot .. autofunction:: paddle.fluid.layers.one_hot
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_one_hot`
.. _api_fluid_layers_pad: .. _api_fluid_layers_pad:
pad pad
...@@ -751,6 +1061,8 @@ pad ...@@ -751,6 +1061,8 @@ pad
.. autofunction:: paddle.fluid.layers.pad .. autofunction:: paddle.fluid.layers.pad
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_pad`
.. _api_fluid_layers_pad2d: .. _api_fluid_layers_pad2d:
pad2d pad2d
...@@ -759,6 +1071,8 @@ pad2d ...@@ -759,6 +1071,8 @@ pad2d
.. autofunction:: paddle.fluid.layers.pad2d .. autofunction:: paddle.fluid.layers.pad2d
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_pad2d`
.. _api_fluid_layers_pad_constant_like: .. _api_fluid_layers_pad_constant_like:
pad_constant_like pad_constant_like
...@@ -767,6 +1081,8 @@ pad_constant_like ...@@ -767,6 +1081,8 @@ pad_constant_like
.. autofunction:: paddle.fluid.layers.pad_constant_like .. autofunction:: paddle.fluid.layers.pad_constant_like
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_pad_constant_like`
.. _api_fluid_layers_pool2d: .. _api_fluid_layers_pool2d:
pool2d pool2d
...@@ -775,6 +1091,8 @@ pool2d ...@@ -775,6 +1091,8 @@ pool2d
.. autofunction:: paddle.fluid.layers.pool2d .. autofunction:: paddle.fluid.layers.pool2d
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_pool2d`
.. _api_fluid_layers_pool3d: .. _api_fluid_layers_pool3d:
pool3d pool3d
...@@ -783,6 +1101,8 @@ pool3d ...@@ -783,6 +1101,8 @@ pool3d
.. autofunction:: paddle.fluid.layers.pool3d .. autofunction:: paddle.fluid.layers.pool3d
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_pool3d`
.. _api_fluid_layers_pow: .. _api_fluid_layers_pow:
pow pow
...@@ -791,6 +1111,8 @@ pow ...@@ -791,6 +1111,8 @@ pow
.. autofunction:: paddle.fluid.layers.pow .. autofunction:: paddle.fluid.layers.pow
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_pow`
.. _api_fluid_layers_prelu: .. _api_fluid_layers_prelu:
prelu prelu
...@@ -799,6 +1121,8 @@ prelu ...@@ -799,6 +1121,8 @@ prelu
.. autofunction:: paddle.fluid.layers.prelu .. autofunction:: paddle.fluid.layers.prelu
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_prelu`
.. _api_fluid_layers_random_crop: .. _api_fluid_layers_random_crop:
random_crop random_crop
...@@ -807,6 +1131,8 @@ random_crop ...@@ -807,6 +1131,8 @@ random_crop
.. autofunction:: paddle.fluid.layers.random_crop .. autofunction:: paddle.fluid.layers.random_crop
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_random_crop`
.. _api_fluid_layers_rank_loss: .. _api_fluid_layers_rank_loss:
rank_loss rank_loss
...@@ -815,6 +1141,8 @@ rank_loss ...@@ -815,6 +1141,8 @@ rank_loss
.. autofunction:: paddle.fluid.layers.rank_loss .. autofunction:: paddle.fluid.layers.rank_loss
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_rank_loss`
.. _api_fluid_layers_reduce_max: .. _api_fluid_layers_reduce_max:
reduce_max reduce_max
...@@ -823,6 +1151,8 @@ reduce_max ...@@ -823,6 +1151,8 @@ reduce_max
.. autofunction:: paddle.fluid.layers.reduce_max .. autofunction:: paddle.fluid.layers.reduce_max
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_reduce_max`
.. _api_fluid_layers_reduce_mean: .. _api_fluid_layers_reduce_mean:
reduce_mean reduce_mean
...@@ -831,6 +1161,8 @@ reduce_mean ...@@ -831,6 +1161,8 @@ reduce_mean
.. autofunction:: paddle.fluid.layers.reduce_mean .. autofunction:: paddle.fluid.layers.reduce_mean
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_reduce_mean`
.. _api_fluid_layers_reduce_min: .. _api_fluid_layers_reduce_min:
reduce_min reduce_min
...@@ -839,6 +1171,8 @@ reduce_min ...@@ -839,6 +1171,8 @@ reduce_min
.. autofunction:: paddle.fluid.layers.reduce_min .. autofunction:: paddle.fluid.layers.reduce_min
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_reduce_min`
.. _api_fluid_layers_reduce_prod: .. _api_fluid_layers_reduce_prod:
reduce_prod reduce_prod
...@@ -847,6 +1181,8 @@ reduce_prod ...@@ -847,6 +1181,8 @@ reduce_prod
.. autofunction:: paddle.fluid.layers.reduce_prod .. autofunction:: paddle.fluid.layers.reduce_prod
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_reduce_prod`
.. _api_fluid_layers_reduce_sum: .. _api_fluid_layers_reduce_sum:
reduce_sum reduce_sum
...@@ -855,6 +1191,8 @@ reduce_sum ...@@ -855,6 +1191,8 @@ reduce_sum
.. autofunction:: paddle.fluid.layers.reduce_sum .. autofunction:: paddle.fluid.layers.reduce_sum
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_reduce_sum`
.. _api_fluid_layers_relu: .. _api_fluid_layers_relu:
relu relu
...@@ -863,6 +1201,8 @@ relu ...@@ -863,6 +1201,8 @@ relu
.. autofunction:: paddle.fluid.layers.relu .. autofunction:: paddle.fluid.layers.relu
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_relu`
.. _api_fluid_layers_relu6: .. _api_fluid_layers_relu6:
relu6 relu6
...@@ -871,6 +1211,8 @@ relu6 ...@@ -871,6 +1211,8 @@ relu6
.. autofunction:: paddle.fluid.layers.relu6 .. autofunction:: paddle.fluid.layers.relu6
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_relu6`
.. _api_fluid_layers_reshape: .. _api_fluid_layers_reshape:
reshape reshape
...@@ -879,6 +1221,8 @@ reshape ...@@ -879,6 +1221,8 @@ reshape
.. autofunction:: paddle.fluid.layers.reshape .. autofunction:: paddle.fluid.layers.reshape
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_reshape`
.. _api_fluid_layers_resize_bilinear: .. _api_fluid_layers_resize_bilinear:
resize_bilinear resize_bilinear
...@@ -887,6 +1231,28 @@ resize_bilinear ...@@ -887,6 +1231,28 @@ resize_bilinear
.. autofunction:: paddle.fluid.layers.resize_bilinear .. autofunction:: paddle.fluid.layers.resize_bilinear
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_resize_bilinear`
.. _api_fluid_layers_resize_nearest:
resize_nearest
--------------
.. autofunction:: paddle.fluid.layers.resize_nearest
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_resize_nearest`
.. _api_fluid_layers_roi_align:
roi_align
---------
.. autofunction:: paddle.fluid.layers.roi_align
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_roi_align`
.. _api_fluid_layers_roi_pool: .. _api_fluid_layers_roi_pool:
roi_pool roi_pool
...@@ -895,6 +1261,8 @@ roi_pool ...@@ -895,6 +1261,8 @@ roi_pool
.. autofunction:: paddle.fluid.layers.roi_pool .. autofunction:: paddle.fluid.layers.roi_pool
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_roi_pool`
.. _api_fluid_layers_row_conv: .. _api_fluid_layers_row_conv:
row_conv row_conv
...@@ -903,6 +1271,8 @@ row_conv ...@@ -903,6 +1271,8 @@ row_conv
.. autofunction:: paddle.fluid.layers.row_conv .. autofunction:: paddle.fluid.layers.row_conv
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_row_conv`
.. _api_fluid_layers_sampling_id: .. _api_fluid_layers_sampling_id:
sampling_id sampling_id
...@@ -911,6 +1281,8 @@ sampling_id ...@@ -911,6 +1281,8 @@ sampling_id
.. autofunction:: paddle.fluid.layers.sampling_id .. autofunction:: paddle.fluid.layers.sampling_id
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sampling_id`
.. _api_fluid_layers_scale: .. _api_fluid_layers_scale:
scale scale
...@@ -919,6 +1291,8 @@ scale ...@@ -919,6 +1291,8 @@ scale
.. autofunction:: paddle.fluid.layers.scale .. autofunction:: paddle.fluid.layers.scale
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_scale`
.. _api_fluid_layers_scatter: .. _api_fluid_layers_scatter:
scatter scatter
...@@ -927,6 +1301,18 @@ scatter ...@@ -927,6 +1301,18 @@ scatter
.. autofunction:: paddle.fluid.layers.scatter .. autofunction:: paddle.fluid.layers.scatter
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_scatter`
.. _api_fluid_layers_selu:
selu
----
.. autofunction:: paddle.fluid.layers.selu
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_selu`
.. _api_fluid_layers_sequence_concat: .. _api_fluid_layers_sequence_concat:
sequence_concat sequence_concat
...@@ -935,6 +1321,8 @@ sequence_concat ...@@ -935,6 +1321,8 @@ sequence_concat
.. autofunction:: paddle.fluid.layers.sequence_concat .. autofunction:: paddle.fluid.layers.sequence_concat
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_concat`
.. _api_fluid_layers_sequence_conv: .. _api_fluid_layers_sequence_conv:
sequence_conv sequence_conv
...@@ -943,6 +1331,8 @@ sequence_conv ...@@ -943,6 +1331,8 @@ sequence_conv
.. autofunction:: paddle.fluid.layers.sequence_conv .. autofunction:: paddle.fluid.layers.sequence_conv
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_conv`
.. _api_fluid_layers_sequence_enumerate: .. _api_fluid_layers_sequence_enumerate:
sequence_enumerate sequence_enumerate
...@@ -951,6 +1341,8 @@ sequence_enumerate ...@@ -951,6 +1341,8 @@ sequence_enumerate
.. autofunction:: paddle.fluid.layers.sequence_enumerate .. autofunction:: paddle.fluid.layers.sequence_enumerate
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_enumerate`
.. _api_fluid_layers_sequence_expand: .. _api_fluid_layers_sequence_expand:
sequence_expand sequence_expand
...@@ -959,6 +1351,8 @@ sequence_expand ...@@ -959,6 +1351,8 @@ sequence_expand
.. autofunction:: paddle.fluid.layers.sequence_expand .. autofunction:: paddle.fluid.layers.sequence_expand
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_expand`
.. _api_fluid_layers_sequence_expand_as: .. _api_fluid_layers_sequence_expand_as:
sequence_expand_as sequence_expand_as
...@@ -967,6 +1361,8 @@ sequence_expand_as ...@@ -967,6 +1361,8 @@ sequence_expand_as
.. autofunction:: paddle.fluid.layers.sequence_expand_as .. autofunction:: paddle.fluid.layers.sequence_expand_as
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_expand_as`
.. _api_fluid_layers_sequence_first_step: .. _api_fluid_layers_sequence_first_step:
sequence_first_step sequence_first_step
...@@ -975,6 +1371,8 @@ sequence_first_step ...@@ -975,6 +1371,8 @@ sequence_first_step
.. autofunction:: paddle.fluid.layers.sequence_first_step .. autofunction:: paddle.fluid.layers.sequence_first_step
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_first_step`
.. _api_fluid_layers_sequence_last_step: .. _api_fluid_layers_sequence_last_step:
sequence_last_step sequence_last_step
...@@ -983,6 +1381,8 @@ sequence_last_step ...@@ -983,6 +1381,8 @@ sequence_last_step
.. autofunction:: paddle.fluid.layers.sequence_last_step .. autofunction:: paddle.fluid.layers.sequence_last_step
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_last_step`
.. _api_fluid_layers_sequence_mask: .. _api_fluid_layers_sequence_mask:
sequence_mask sequence_mask
...@@ -991,6 +1391,8 @@ sequence_mask ...@@ -991,6 +1391,8 @@ sequence_mask
.. autofunction:: paddle.fluid.layers.sequence_mask .. autofunction:: paddle.fluid.layers.sequence_mask
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_mask`
.. _api_fluid_layers_sequence_pad: .. _api_fluid_layers_sequence_pad:
sequence_pad sequence_pad
...@@ -999,6 +1401,8 @@ sequence_pad ...@@ -999,6 +1401,8 @@ sequence_pad
.. autofunction:: paddle.fluid.layers.sequence_pad .. autofunction:: paddle.fluid.layers.sequence_pad
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_pad`
.. _api_fluid_layers_sequence_pool: .. _api_fluid_layers_sequence_pool:
sequence_pool sequence_pool
...@@ -1007,6 +1411,8 @@ sequence_pool ...@@ -1007,6 +1411,8 @@ sequence_pool
.. autofunction:: paddle.fluid.layers.sequence_pool .. autofunction:: paddle.fluid.layers.sequence_pool
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_pool`
.. _api_fluid_layers_sequence_reshape: .. _api_fluid_layers_sequence_reshape:
sequence_reshape sequence_reshape
...@@ -1015,6 +1421,18 @@ sequence_reshape ...@@ -1015,6 +1421,18 @@ sequence_reshape
.. autofunction:: paddle.fluid.layers.sequence_reshape .. autofunction:: paddle.fluid.layers.sequence_reshape
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_reshape`
.. _api_fluid_layers_sequence_reverse:
sequence_reverse
----------------
.. autofunction:: paddle.fluid.layers.sequence_reverse
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_reverse`
.. _api_fluid_layers_sequence_scatter: .. _api_fluid_layers_sequence_scatter:
sequence_scatter sequence_scatter
...@@ -1023,6 +1441,18 @@ sequence_scatter ...@@ -1023,6 +1441,18 @@ sequence_scatter
.. autofunction:: paddle.fluid.layers.sequence_scatter .. autofunction:: paddle.fluid.layers.sequence_scatter
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_scatter`
.. _api_fluid_layers_sequence_slice:
sequence_slice
--------------
.. autofunction:: paddle.fluid.layers.sequence_slice
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_slice`
.. _api_fluid_layers_sequence_softmax: .. _api_fluid_layers_sequence_softmax:
sequence_softmax sequence_softmax
...@@ -1031,6 +1461,18 @@ sequence_softmax ...@@ -1031,6 +1461,18 @@ sequence_softmax
.. autofunction:: paddle.fluid.layers.sequence_softmax .. autofunction:: paddle.fluid.layers.sequence_softmax
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_softmax`
.. _api_fluid_layers_sequence_unpad:
sequence_unpad
--------------
.. autofunction:: paddle.fluid.layers.sequence_unpad
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sequence_unpad`
.. _api_fluid_layers_shape: .. _api_fluid_layers_shape:
shape shape
...@@ -1039,6 +1481,8 @@ shape ...@@ -1039,6 +1481,8 @@ shape
.. autofunction:: paddle.fluid.layers.shape .. autofunction:: paddle.fluid.layers.shape
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_shape`
.. _api_fluid_layers_sigmoid_cross_entropy_with_logits: .. _api_fluid_layers_sigmoid_cross_entropy_with_logits:
sigmoid_cross_entropy_with_logits sigmoid_cross_entropy_with_logits
...@@ -1047,6 +1491,18 @@ sigmoid_cross_entropy_with_logits ...@@ -1047,6 +1491,18 @@ sigmoid_cross_entropy_with_logits
.. autofunction:: paddle.fluid.layers.sigmoid_cross_entropy_with_logits .. autofunction:: paddle.fluid.layers.sigmoid_cross_entropy_with_logits
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sigmoid_cross_entropy_with_logits`
.. _api_fluid_layers_similarity_focus:
similarity_focus
----------------
.. autofunction:: paddle.fluid.layers.similarity_focus
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_similarity_focus`
.. _api_fluid_layers_slice: .. _api_fluid_layers_slice:
slice slice
...@@ -1055,6 +1511,8 @@ slice ...@@ -1055,6 +1511,8 @@ slice
.. autofunction:: paddle.fluid.layers.slice .. autofunction:: paddle.fluid.layers.slice
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_slice`
.. _api_fluid_layers_smooth_l1: .. _api_fluid_layers_smooth_l1:
smooth_l1 smooth_l1
...@@ -1063,6 +1521,8 @@ smooth_l1 ...@@ -1063,6 +1521,8 @@ smooth_l1
.. autofunction:: paddle.fluid.layers.smooth_l1 .. autofunction:: paddle.fluid.layers.smooth_l1
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_smooth_l1`
.. _api_fluid_layers_soft_relu: .. _api_fluid_layers_soft_relu:
soft_relu soft_relu
...@@ -1071,6 +1531,8 @@ soft_relu ...@@ -1071,6 +1531,8 @@ soft_relu
.. autofunction:: paddle.fluid.layers.soft_relu .. autofunction:: paddle.fluid.layers.soft_relu
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_soft_relu`
.. _api_fluid_layers_softmax: .. _api_fluid_layers_softmax:
softmax softmax
...@@ -1079,6 +1541,8 @@ softmax ...@@ -1079,6 +1541,8 @@ softmax
.. autofunction:: paddle.fluid.layers.softmax .. autofunction:: paddle.fluid.layers.softmax
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_softmax`
.. _api_fluid_layers_softmax_with_cross_entropy: .. _api_fluid_layers_softmax_with_cross_entropy:
softmax_with_cross_entropy softmax_with_cross_entropy
...@@ -1087,6 +1551,18 @@ softmax_with_cross_entropy ...@@ -1087,6 +1551,18 @@ softmax_with_cross_entropy
.. autofunction:: paddle.fluid.layers.softmax_with_cross_entropy .. autofunction:: paddle.fluid.layers.softmax_with_cross_entropy
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_softmax_with_cross_entropy`
.. _api_fluid_layers_space_to_depth:
space_to_depth
--------------
.. autofunction:: paddle.fluid.layers.space_to_depth
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_space_to_depth`
.. _api_fluid_layers_split: .. _api_fluid_layers_split:
split split
...@@ -1095,6 +1571,8 @@ split ...@@ -1095,6 +1571,8 @@ split
.. autofunction:: paddle.fluid.layers.split .. autofunction:: paddle.fluid.layers.split
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_split`
.. _api_fluid_layers_square_error_cost: .. _api_fluid_layers_square_error_cost:
square_error_cost square_error_cost
...@@ -1103,6 +1581,8 @@ square_error_cost ...@@ -1103,6 +1581,8 @@ square_error_cost
.. autofunction:: paddle.fluid.layers.square_error_cost .. autofunction:: paddle.fluid.layers.square_error_cost
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_square_error_cost`
.. _api_fluid_layers_squeeze: .. _api_fluid_layers_squeeze:
squeeze squeeze
...@@ -1111,6 +1591,8 @@ squeeze ...@@ -1111,6 +1591,8 @@ squeeze
.. autofunction:: paddle.fluid.layers.squeeze .. autofunction:: paddle.fluid.layers.squeeze
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_squeeze`
.. _api_fluid_layers_stack: .. _api_fluid_layers_stack:
stack stack
...@@ -1119,6 +1601,8 @@ stack ...@@ -1119,6 +1601,8 @@ stack
.. autofunction:: paddle.fluid.layers.stack .. autofunction:: paddle.fluid.layers.stack
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_stack`
.. _api_fluid_layers_stanh: .. _api_fluid_layers_stanh:
stanh stanh
...@@ -1127,6 +1611,8 @@ stanh ...@@ -1127,6 +1611,8 @@ stanh
.. autofunction:: paddle.fluid.layers.stanh .. autofunction:: paddle.fluid.layers.stanh
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_stanh`
.. _api_fluid_layers_sum: .. _api_fluid_layers_sum:
sum sum
...@@ -1135,6 +1621,8 @@ sum ...@@ -1135,6 +1621,8 @@ sum
.. autofunction:: paddle.fluid.layers.sum .. autofunction:: paddle.fluid.layers.sum
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sum`
.. _api_fluid_layers_swish: .. _api_fluid_layers_swish:
swish swish
...@@ -1143,6 +1631,8 @@ swish ...@@ -1143,6 +1631,8 @@ swish
.. autofunction:: paddle.fluid.layers.swish .. autofunction:: paddle.fluid.layers.swish
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_swish`
.. _api_fluid_layers_topk: .. _api_fluid_layers_topk:
topk topk
...@@ -1151,6 +1641,8 @@ topk ...@@ -1151,6 +1641,8 @@ topk
.. autofunction:: paddle.fluid.layers.topk .. autofunction:: paddle.fluid.layers.topk
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_topk`
.. _api_fluid_layers_transpose: .. _api_fluid_layers_transpose:
transpose transpose
...@@ -1159,6 +1651,8 @@ transpose ...@@ -1159,6 +1651,8 @@ transpose
.. autofunction:: paddle.fluid.layers.transpose .. autofunction:: paddle.fluid.layers.transpose
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_transpose`
.. _api_fluid_layers_uniform_random_batch_size_like: .. _api_fluid_layers_uniform_random_batch_size_like:
uniform_random_batch_size_like uniform_random_batch_size_like
...@@ -1167,6 +1661,8 @@ uniform_random_batch_size_like ...@@ -1167,6 +1661,8 @@ uniform_random_batch_size_like
.. autofunction:: paddle.fluid.layers.uniform_random_batch_size_like .. autofunction:: paddle.fluid.layers.uniform_random_batch_size_like
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_uniform_random_batch_size_like`
.. _api_fluid_layers_unsqueeze: .. _api_fluid_layers_unsqueeze:
unsqueeze unsqueeze
...@@ -1175,6 +1671,8 @@ unsqueeze ...@@ -1175,6 +1671,8 @@ unsqueeze
.. autofunction:: paddle.fluid.layers.unsqueeze .. autofunction:: paddle.fluid.layers.unsqueeze
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_unsqueeze`
.. _api_fluid_layers_unstack: .. _api_fluid_layers_unstack:
unstack unstack
...@@ -1183,6 +1681,8 @@ unstack ...@@ -1183,6 +1681,8 @@ unstack
.. autofunction:: paddle.fluid.layers.unstack .. autofunction:: paddle.fluid.layers.unstack
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_unstack`
.. _api_fluid_layers_warpctc: .. _api_fluid_layers_warpctc:
warpctc warpctc
...@@ -1191,6 +1691,8 @@ warpctc ...@@ -1191,6 +1691,8 @@ warpctc
.. autofunction:: paddle.fluid.layers.warpctc .. autofunction:: paddle.fluid.layers.warpctc
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_warpctc`
ops ops
=== ===
...@@ -1202,6 +1704,8 @@ abs ...@@ -1202,6 +1704,8 @@ abs
.. autofunction:: paddle.fluid.layers.abs .. autofunction:: paddle.fluid.layers.abs
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_abs`
.. _api_fluid_layers_ceil: .. _api_fluid_layers_ceil:
ceil ceil
...@@ -1210,6 +1714,8 @@ ceil ...@@ -1210,6 +1714,8 @@ ceil
.. autofunction:: paddle.fluid.layers.ceil .. autofunction:: paddle.fluid.layers.ceil
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_ceil`
.. _api_fluid_layers_cos: .. _api_fluid_layers_cos:
cos cos
...@@ -1218,6 +1724,8 @@ cos ...@@ -1218,6 +1724,8 @@ cos
.. autofunction:: paddle.fluid.layers.cos .. autofunction:: paddle.fluid.layers.cos
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_cos`
.. _api_fluid_layers_cumsum: .. _api_fluid_layers_cumsum:
cumsum cumsum
...@@ -1226,6 +1734,8 @@ cumsum ...@@ -1226,6 +1734,8 @@ cumsum
.. autofunction:: paddle.fluid.layers.cumsum .. autofunction:: paddle.fluid.layers.cumsum
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_cumsum`
.. _api_fluid_layers_exp: .. _api_fluid_layers_exp:
exp exp
...@@ -1234,6 +1744,8 @@ exp ...@@ -1234,6 +1744,8 @@ exp
.. autofunction:: paddle.fluid.layers.exp .. autofunction:: paddle.fluid.layers.exp
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_exp`
.. _api_fluid_layers_floor: .. _api_fluid_layers_floor:
floor floor
...@@ -1242,6 +1754,8 @@ floor ...@@ -1242,6 +1754,8 @@ floor
.. autofunction:: paddle.fluid.layers.floor .. autofunction:: paddle.fluid.layers.floor
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_floor`
.. _api_fluid_layers_hard_shrink: .. _api_fluid_layers_hard_shrink:
hard_shrink hard_shrink
...@@ -1250,6 +1764,8 @@ hard_shrink ...@@ -1250,6 +1764,8 @@ hard_shrink
.. autofunction:: paddle.fluid.layers.hard_shrink .. autofunction:: paddle.fluid.layers.hard_shrink
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_hard_shrink`
.. _api_fluid_layers_logsigmoid: .. _api_fluid_layers_logsigmoid:
logsigmoid logsigmoid
...@@ -1258,6 +1774,8 @@ logsigmoid ...@@ -1258,6 +1774,8 @@ logsigmoid
.. autofunction:: paddle.fluid.layers.logsigmoid .. autofunction:: paddle.fluid.layers.logsigmoid
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_logsigmoid`
.. _api_fluid_layers_reciprocal: .. _api_fluid_layers_reciprocal:
reciprocal reciprocal
...@@ -1266,6 +1784,8 @@ reciprocal ...@@ -1266,6 +1784,8 @@ reciprocal
.. autofunction:: paddle.fluid.layers.reciprocal .. autofunction:: paddle.fluid.layers.reciprocal
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_reciprocal`
.. _api_fluid_layers_round: .. _api_fluid_layers_round:
round round
...@@ -1274,6 +1794,8 @@ round ...@@ -1274,6 +1794,8 @@ round
.. autofunction:: paddle.fluid.layers.round .. autofunction:: paddle.fluid.layers.round
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_round`
.. _api_fluid_layers_sigmoid: .. _api_fluid_layers_sigmoid:
sigmoid sigmoid
...@@ -1282,6 +1804,8 @@ sigmoid ...@@ -1282,6 +1804,8 @@ sigmoid
.. autofunction:: paddle.fluid.layers.sigmoid .. autofunction:: paddle.fluid.layers.sigmoid
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sigmoid`
.. _api_fluid_layers_sin: .. _api_fluid_layers_sin:
sin sin
...@@ -1290,6 +1814,8 @@ sin ...@@ -1290,6 +1814,8 @@ sin
.. autofunction:: paddle.fluid.layers.sin .. autofunction:: paddle.fluid.layers.sin
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sin`
.. _api_fluid_layers_softplus: .. _api_fluid_layers_softplus:
softplus softplus
...@@ -1298,6 +1824,8 @@ softplus ...@@ -1298,6 +1824,8 @@ softplus
.. autofunction:: paddle.fluid.layers.softplus .. autofunction:: paddle.fluid.layers.softplus
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_softplus`
.. _api_fluid_layers_softshrink: .. _api_fluid_layers_softshrink:
softshrink softshrink
...@@ -1306,6 +1834,8 @@ softshrink ...@@ -1306,6 +1834,8 @@ softshrink
.. autofunction:: paddle.fluid.layers.softshrink .. autofunction:: paddle.fluid.layers.softshrink
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_softshrink`
.. _api_fluid_layers_softsign: .. _api_fluid_layers_softsign:
softsign softsign
...@@ -1314,6 +1844,8 @@ softsign ...@@ -1314,6 +1844,8 @@ softsign
.. autofunction:: paddle.fluid.layers.softsign .. autofunction:: paddle.fluid.layers.softsign
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_softsign`
.. _api_fluid_layers_sqrt: .. _api_fluid_layers_sqrt:
sqrt sqrt
...@@ -1322,6 +1854,8 @@ sqrt ...@@ -1322,6 +1854,8 @@ sqrt
.. autofunction:: paddle.fluid.layers.sqrt .. autofunction:: paddle.fluid.layers.sqrt
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sqrt`
.. _api_fluid_layers_square: .. _api_fluid_layers_square:
square square
...@@ -1330,6 +1864,8 @@ square ...@@ -1330,6 +1864,8 @@ square
.. autofunction:: paddle.fluid.layers.square .. autofunction:: paddle.fluid.layers.square
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_square`
.. _api_fluid_layers_tanh: .. _api_fluid_layers_tanh:
tanh tanh
...@@ -1338,6 +1874,8 @@ tanh ...@@ -1338,6 +1874,8 @@ tanh
.. autofunction:: paddle.fluid.layers.tanh .. autofunction:: paddle.fluid.layers.tanh
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_tanh`
.. _api_fluid_layers_tanh_shrink: .. _api_fluid_layers_tanh_shrink:
tanh_shrink tanh_shrink
...@@ -1346,6 +1884,8 @@ tanh_shrink ...@@ -1346,6 +1884,8 @@ tanh_shrink
.. autofunction:: paddle.fluid.layers.tanh_shrink .. autofunction:: paddle.fluid.layers.tanh_shrink
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_tanh_shrink`
.. _api_fluid_layers_thresholded_relu: .. _api_fluid_layers_thresholded_relu:
thresholded_relu thresholded_relu
...@@ -1354,6 +1894,8 @@ thresholded_relu ...@@ -1354,6 +1894,8 @@ thresholded_relu
.. autofunction:: paddle.fluid.layers.thresholded_relu .. autofunction:: paddle.fluid.layers.thresholded_relu
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_thresholded_relu`
.. _api_fluid_layers_uniform_random: .. _api_fluid_layers_uniform_random:
uniform_random uniform_random
...@@ -1362,6 +1904,8 @@ uniform_random ...@@ -1362,6 +1904,8 @@ uniform_random
.. autofunction:: paddle.fluid.layers.uniform_random .. autofunction:: paddle.fluid.layers.uniform_random
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_uniform_random`
tensor tensor
====== ======
...@@ -1373,6 +1917,8 @@ argmax ...@@ -1373,6 +1917,8 @@ argmax
.. autofunction:: paddle.fluid.layers.argmax .. autofunction:: paddle.fluid.layers.argmax
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_argmax`
.. _api_fluid_layers_argmin: .. _api_fluid_layers_argmin:
argmin argmin
...@@ -1381,6 +1927,8 @@ argmin ...@@ -1381,6 +1927,8 @@ argmin
.. autofunction:: paddle.fluid.layers.argmin .. autofunction:: paddle.fluid.layers.argmin
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_argmin`
.. _api_fluid_layers_argsort: .. _api_fluid_layers_argsort:
argsort argsort
...@@ -1389,6 +1937,8 @@ argsort ...@@ -1389,6 +1937,8 @@ argsort
.. autofunction:: paddle.fluid.layers.argsort .. autofunction:: paddle.fluid.layers.argsort
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_argsort`
.. _api_fluid_layers_assign: .. _api_fluid_layers_assign:
assign assign
...@@ -1397,6 +1947,8 @@ assign ...@@ -1397,6 +1947,8 @@ assign
.. autofunction:: paddle.fluid.layers.assign .. autofunction:: paddle.fluid.layers.assign
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_assign`
.. _api_fluid_layers_cast: .. _api_fluid_layers_cast:
cast cast
...@@ -1405,6 +1957,8 @@ cast ...@@ -1405,6 +1957,8 @@ cast
.. autofunction:: paddle.fluid.layers.cast .. autofunction:: paddle.fluid.layers.cast
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_cast`
.. _api_fluid_layers_concat: .. _api_fluid_layers_concat:
concat concat
...@@ -1413,6 +1967,8 @@ concat ...@@ -1413,6 +1967,8 @@ concat
.. autofunction:: paddle.fluid.layers.concat .. autofunction:: paddle.fluid.layers.concat
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_concat`
.. _api_fluid_layers_create_global_var: .. _api_fluid_layers_create_global_var:
create_global_var create_global_var
...@@ -1421,6 +1977,8 @@ create_global_var ...@@ -1421,6 +1977,8 @@ create_global_var
.. autofunction:: paddle.fluid.layers.create_global_var .. autofunction:: paddle.fluid.layers.create_global_var
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_create_global_var`
.. _api_fluid_layers_create_parameter: .. _api_fluid_layers_create_parameter:
create_parameter create_parameter
...@@ -1429,6 +1987,8 @@ create_parameter ...@@ -1429,6 +1987,8 @@ create_parameter
.. autofunction:: paddle.fluid.layers.create_parameter .. autofunction:: paddle.fluid.layers.create_parameter
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_create_parameter`
.. _api_fluid_layers_create_tensor: .. _api_fluid_layers_create_tensor:
create_tensor create_tensor
...@@ -1437,6 +1997,8 @@ create_tensor ...@@ -1437,6 +1997,8 @@ create_tensor
.. autofunction:: paddle.fluid.layers.create_tensor .. autofunction:: paddle.fluid.layers.create_tensor
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_create_tensor`
.. _api_fluid_layers_fill_constant: .. _api_fluid_layers_fill_constant:
fill_constant fill_constant
...@@ -1445,6 +2007,8 @@ fill_constant ...@@ -1445,6 +2007,8 @@ fill_constant
.. autofunction:: paddle.fluid.layers.fill_constant .. autofunction:: paddle.fluid.layers.fill_constant
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_fill_constant`
.. _api_fluid_layers_fill_constant_batch_size_like: .. _api_fluid_layers_fill_constant_batch_size_like:
fill_constant_batch_size_like fill_constant_batch_size_like
...@@ -1453,6 +2017,38 @@ fill_constant_batch_size_like ...@@ -1453,6 +2017,38 @@ fill_constant_batch_size_like
.. autofunction:: paddle.fluid.layers.fill_constant_batch_size_like .. autofunction:: paddle.fluid.layers.fill_constant_batch_size_like
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_fill_constant_batch_size_like`
.. _api_fluid_layers_has_inf:
has_inf
-------
.. autofunction:: paddle.fluid.layers.has_inf
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_has_inf`
.. _api_fluid_layers_has_nan:
has_nan
-------
.. autofunction:: paddle.fluid.layers.has_nan
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_has_nan`
.. _api_fluid_layers_isfinite:
isfinite
--------
.. autofunction:: paddle.fluid.layers.isfinite
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_isfinite`
.. _api_fluid_layers_ones: .. _api_fluid_layers_ones:
ones ones
...@@ -1461,6 +2057,8 @@ ones ...@@ -1461,6 +2057,8 @@ ones
.. autofunction:: paddle.fluid.layers.ones .. autofunction:: paddle.fluid.layers.ones
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_ones`
.. _api_fluid_layers_reverse: .. _api_fluid_layers_reverse:
reverse reverse
...@@ -1469,6 +2067,8 @@ reverse ...@@ -1469,6 +2067,8 @@ reverse
.. autofunction:: paddle.fluid.layers.reverse .. autofunction:: paddle.fluid.layers.reverse
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_reverse`
.. _api_fluid_layers_sums: .. _api_fluid_layers_sums:
sums sums
...@@ -1477,6 +2077,18 @@ sums ...@@ -1477,6 +2077,18 @@ sums
.. autofunction:: paddle.fluid.layers.sums .. autofunction:: paddle.fluid.layers.sums
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_sums`
.. _api_fluid_layers_tensor_array_to_tensor:
tensor_array_to_tensor
----------------------
.. autofunction:: paddle.fluid.layers.tensor_array_to_tensor
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_tensor_array_to_tensor`
.. _api_fluid_layers_zeros: .. _api_fluid_layers_zeros:
zeros zeros
...@@ -1485,6 +2097,8 @@ zeros ...@@ -1485,6 +2097,8 @@ zeros
.. autofunction:: paddle.fluid.layers.zeros .. autofunction:: paddle.fluid.layers.zeros
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_zeros`
learning_rate_scheduler learning_rate_scheduler
======================= =======================
...@@ -1496,6 +2110,8 @@ append_LARS ...@@ -1496,6 +2110,8 @@ append_LARS
.. autofunction:: paddle.fluid.layers.append_LARS .. autofunction:: paddle.fluid.layers.append_LARS
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_append_LARS`
.. _api_fluid_layers_exponential_decay: .. _api_fluid_layers_exponential_decay:
exponential_decay exponential_decay
...@@ -1504,6 +2120,8 @@ exponential_decay ...@@ -1504,6 +2120,8 @@ exponential_decay
.. autofunction:: paddle.fluid.layers.exponential_decay .. autofunction:: paddle.fluid.layers.exponential_decay
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_exponential_decay`
.. _api_fluid_layers_inverse_time_decay: .. _api_fluid_layers_inverse_time_decay:
inverse_time_decay inverse_time_decay
...@@ -1512,6 +2130,8 @@ inverse_time_decay ...@@ -1512,6 +2130,8 @@ inverse_time_decay
.. autofunction:: paddle.fluid.layers.inverse_time_decay .. autofunction:: paddle.fluid.layers.inverse_time_decay
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_inverse_time_decay`
.. _api_fluid_layers_natural_exp_decay: .. _api_fluid_layers_natural_exp_decay:
natural_exp_decay natural_exp_decay
...@@ -1520,6 +2140,8 @@ natural_exp_decay ...@@ -1520,6 +2140,8 @@ natural_exp_decay
.. autofunction:: paddle.fluid.layers.natural_exp_decay .. autofunction:: paddle.fluid.layers.natural_exp_decay
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_natural_exp_decay`
.. _api_fluid_layers_noam_decay: .. _api_fluid_layers_noam_decay:
noam_decay noam_decay
...@@ -1528,6 +2150,8 @@ noam_decay ...@@ -1528,6 +2150,8 @@ noam_decay
.. autofunction:: paddle.fluid.layers.noam_decay .. autofunction:: paddle.fluid.layers.noam_decay
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_noam_decay`
.. _api_fluid_layers_piecewise_decay: .. _api_fluid_layers_piecewise_decay:
piecewise_decay piecewise_decay
...@@ -1536,6 +2160,8 @@ piecewise_decay ...@@ -1536,6 +2160,8 @@ piecewise_decay
.. autofunction:: paddle.fluid.layers.piecewise_decay .. autofunction:: paddle.fluid.layers.piecewise_decay
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_piecewise_decay`
.. _api_fluid_layers_polynomial_decay: .. _api_fluid_layers_polynomial_decay:
polynomial_decay polynomial_decay
...@@ -1544,6 +2170,8 @@ polynomial_decay ...@@ -1544,6 +2170,8 @@ polynomial_decay
.. autofunction:: paddle.fluid.layers.polynomial_decay .. autofunction:: paddle.fluid.layers.polynomial_decay
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_polynomial_decay`
detection detection
========= =========
...@@ -1555,6 +2183,8 @@ anchor_generator ...@@ -1555,6 +2183,8 @@ anchor_generator
.. autofunction:: paddle.fluid.layers.anchor_generator .. autofunction:: paddle.fluid.layers.anchor_generator
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_anchor_generator`
.. _api_fluid_layers_bipartite_match: .. _api_fluid_layers_bipartite_match:
bipartite_match bipartite_match
...@@ -1563,6 +2193,8 @@ bipartite_match ...@@ -1563,6 +2193,8 @@ bipartite_match
.. autofunction:: paddle.fluid.layers.bipartite_match .. autofunction:: paddle.fluid.layers.bipartite_match
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_bipartite_match`
.. _api_fluid_layers_box_coder: .. _api_fluid_layers_box_coder:
box_coder box_coder
...@@ -1571,6 +2203,18 @@ box_coder ...@@ -1571,6 +2203,18 @@ box_coder
.. autofunction:: paddle.fluid.layers.box_coder .. autofunction:: paddle.fluid.layers.box_coder
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_box_coder`
.. _api_fluid_layers_density_prior_box:
density_prior_box
-----------------
.. autofunction:: paddle.fluid.layers.density_prior_box
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_density_prior_box`
.. _api_fluid_layers_detection_map: .. _api_fluid_layers_detection_map:
detection_map detection_map
...@@ -1579,6 +2223,8 @@ detection_map ...@@ -1579,6 +2223,8 @@ detection_map
.. autofunction:: paddle.fluid.layers.detection_map .. autofunction:: paddle.fluid.layers.detection_map
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_detection_map`
.. _api_fluid_layers_detection_output: .. _api_fluid_layers_detection_output:
detection_output detection_output
...@@ -1587,6 +2233,8 @@ detection_output ...@@ -1587,6 +2233,8 @@ detection_output
.. autofunction:: paddle.fluid.layers.detection_output .. autofunction:: paddle.fluid.layers.detection_output
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_detection_output`
.. _api_fluid_layers_generate_proposal_labels: .. _api_fluid_layers_generate_proposal_labels:
generate_proposal_labels generate_proposal_labels
...@@ -1595,6 +2243,8 @@ generate_proposal_labels ...@@ -1595,6 +2243,8 @@ generate_proposal_labels
.. autofunction:: paddle.fluid.layers.generate_proposal_labels .. autofunction:: paddle.fluid.layers.generate_proposal_labels
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_generate_proposal_labels`
.. _api_fluid_layers_generate_proposals: .. _api_fluid_layers_generate_proposals:
generate_proposals generate_proposals
...@@ -1603,6 +2253,8 @@ generate_proposals ...@@ -1603,6 +2253,8 @@ generate_proposals
.. autofunction:: paddle.fluid.layers.generate_proposals .. autofunction:: paddle.fluid.layers.generate_proposals
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_generate_proposals`
.. _api_fluid_layers_iou_similarity: .. _api_fluid_layers_iou_similarity:
iou_similarity iou_similarity
...@@ -1611,6 +2263,8 @@ iou_similarity ...@@ -1611,6 +2263,8 @@ iou_similarity
.. autofunction:: paddle.fluid.layers.iou_similarity .. autofunction:: paddle.fluid.layers.iou_similarity
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_iou_similarity`
.. _api_fluid_layers_multi_box_head: .. _api_fluid_layers_multi_box_head:
multi_box_head multi_box_head
...@@ -1619,6 +2273,8 @@ multi_box_head ...@@ -1619,6 +2273,8 @@ multi_box_head
.. autofunction:: paddle.fluid.layers.multi_box_head .. autofunction:: paddle.fluid.layers.multi_box_head
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_multi_box_head`
.. _api_fluid_layers_polygon_box_transform: .. _api_fluid_layers_polygon_box_transform:
polygon_box_transform polygon_box_transform
...@@ -1627,6 +2283,8 @@ polygon_box_transform ...@@ -1627,6 +2283,8 @@ polygon_box_transform
.. autofunction:: paddle.fluid.layers.polygon_box_transform .. autofunction:: paddle.fluid.layers.polygon_box_transform
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_polygon_box_transform`
.. _api_fluid_layers_prior_box: .. _api_fluid_layers_prior_box:
prior_box prior_box
...@@ -1635,6 +2293,8 @@ prior_box ...@@ -1635,6 +2293,8 @@ prior_box
.. autofunction:: paddle.fluid.layers.prior_box .. autofunction:: paddle.fluid.layers.prior_box
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_prior_box`
.. _api_fluid_layers_roi_perspective_transform: .. _api_fluid_layers_roi_perspective_transform:
roi_perspective_transform roi_perspective_transform
...@@ -1643,6 +2303,8 @@ roi_perspective_transform ...@@ -1643,6 +2303,8 @@ roi_perspective_transform
.. autofunction:: paddle.fluid.layers.roi_perspective_transform .. autofunction:: paddle.fluid.layers.roi_perspective_transform
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_roi_perspective_transform`
.. _api_fluid_layers_rpn_target_assign: .. _api_fluid_layers_rpn_target_assign:
rpn_target_assign rpn_target_assign
...@@ -1651,6 +2313,8 @@ rpn_target_assign ...@@ -1651,6 +2313,8 @@ rpn_target_assign
.. autofunction:: paddle.fluid.layers.rpn_target_assign .. autofunction:: paddle.fluid.layers.rpn_target_assign
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_rpn_target_assign`
.. _api_fluid_layers_ssd_loss: .. _api_fluid_layers_ssd_loss:
ssd_loss ssd_loss
...@@ -1659,6 +2323,8 @@ ssd_loss ...@@ -1659,6 +2323,8 @@ ssd_loss
.. autofunction:: paddle.fluid.layers.ssd_loss .. autofunction:: paddle.fluid.layers.ssd_loss
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_ssd_loss`
.. _api_fluid_layers_target_assign: .. _api_fluid_layers_target_assign:
target_assign target_assign
...@@ -1667,6 +2333,8 @@ target_assign ...@@ -1667,6 +2333,8 @@ target_assign
.. autofunction:: paddle.fluid.layers.target_assign .. autofunction:: paddle.fluid.layers.target_assign
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_target_assign`
metric_op metric_op
========= =========
...@@ -1678,6 +2346,8 @@ accuracy ...@@ -1678,6 +2346,8 @@ accuracy
.. autofunction:: paddle.fluid.layers.accuracy .. autofunction:: paddle.fluid.layers.accuracy
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_accuracy`
.. _api_fluid_layers_auc: .. _api_fluid_layers_auc:
auc auc
...@@ -1686,3 +2356,5 @@ auc ...@@ -1686,3 +2356,5 @@ auc
.. autofunction:: paddle.fluid.layers.auc .. autofunction:: paddle.fluid.layers.auc
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_layers_auc`
doc/fluid/api/metrics.rst
浏览文件 @ cb4f4929
...@@ -14,6 +14,8 @@ Accuracy ...@@ -14,6 +14,8 @@ Accuracy
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_metrics_Accuracy`
.. _api_fluid_metrics_Auc: .. _api_fluid_metrics_Auc:
Auc Auc
...@@ -23,6 +25,8 @@ Auc ...@@ -23,6 +25,8 @@ Auc
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_metrics_Auc`
.. _api_fluid_metrics_ChunkEvaluator: .. _api_fluid_metrics_ChunkEvaluator:
ChunkEvaluator ChunkEvaluator
...@@ -32,6 +36,8 @@ ChunkEvaluator ...@@ -32,6 +36,8 @@ ChunkEvaluator
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_metrics_ChunkEvaluator`
.. _api_fluid_metrics_CompositeMetric: .. _api_fluid_metrics_CompositeMetric:
CompositeMetric CompositeMetric
...@@ -41,6 +47,8 @@ CompositeMetric ...@@ -41,6 +47,8 @@ CompositeMetric
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_metrics_CompositeMetric`
.. _api_fluid_metrics_DetectionMAP: .. _api_fluid_metrics_DetectionMAP:
DetectionMAP DetectionMAP
...@@ -50,6 +58,8 @@ DetectionMAP ...@@ -50,6 +58,8 @@ DetectionMAP
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_metrics_DetectionMAP`
.. _api_fluid_metrics_EditDistance: .. _api_fluid_metrics_EditDistance:
EditDistance EditDistance
...@@ -59,6 +69,8 @@ EditDistance ...@@ -59,6 +69,8 @@ EditDistance
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_metrics_EditDistance`
.. _api_fluid_metrics_MetricBase: .. _api_fluid_metrics_MetricBase:
MetricBase MetricBase
...@@ -68,6 +80,8 @@ MetricBase ...@@ -68,6 +80,8 @@ MetricBase
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_metrics_MetricBase`
.. _api_fluid_metrics_Precision: .. _api_fluid_metrics_Precision:
Precision Precision
...@@ -77,6 +91,8 @@ Precision ...@@ -77,6 +91,8 @@ Precision
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_metrics_Precision`
.. _api_fluid_metrics_Recall: .. _api_fluid_metrics_Recall:
Recall Recall
...@@ -86,3 +102,5 @@ Recall ...@@ -86,3 +102,5 @@ Recall
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_metrics_Recall`
doc/fluid/api/nets.rst
浏览文件 @ cb4f4929
...@@ -13,6 +13,8 @@ glu ...@@ -13,6 +13,8 @@ glu
.. autofunction:: paddle.fluid.nets.glu .. autofunction:: paddle.fluid.nets.glu
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_nets_glu`
.. _api_fluid_nets_img_conv_group: .. _api_fluid_nets_img_conv_group:
img_conv_group img_conv_group
...@@ -21,6 +23,8 @@ img_conv_group ...@@ -21,6 +23,8 @@ img_conv_group
.. autofunction:: paddle.fluid.nets.img_conv_group .. autofunction:: paddle.fluid.nets.img_conv_group
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_nets_img_conv_group`
.. _api_fluid_nets_scaled_dot_product_attention: .. _api_fluid_nets_scaled_dot_product_attention:
scaled_dot_product_attention scaled_dot_product_attention
...@@ -29,6 +33,8 @@ scaled_dot_product_attention ...@@ -29,6 +33,8 @@ scaled_dot_product_attention
.. autofunction:: paddle.fluid.nets.scaled_dot_product_attention .. autofunction:: paddle.fluid.nets.scaled_dot_product_attention
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_nets_scaled_dot_product_attention`
.. _api_fluid_nets_sequence_conv_pool: .. _api_fluid_nets_sequence_conv_pool:
sequence_conv_pool sequence_conv_pool
...@@ -37,6 +43,8 @@ sequence_conv_pool ...@@ -37,6 +43,8 @@ sequence_conv_pool
.. autofunction:: paddle.fluid.nets.sequence_conv_pool .. autofunction:: paddle.fluid.nets.sequence_conv_pool
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_nets_sequence_conv_pool`
.. _api_fluid_nets_simple_img_conv_pool: .. _api_fluid_nets_simple_img_conv_pool:
simple_img_conv_pool simple_img_conv_pool
...@@ -45,3 +53,5 @@ simple_img_conv_pool ...@@ -45,3 +53,5 @@ simple_img_conv_pool
.. autofunction:: paddle.fluid.nets.simple_img_conv_pool .. autofunction:: paddle.fluid.nets.simple_img_conv_pool
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_nets_simple_img_conv_pool`
doc/fluid/api/optimizer.rst
浏览文件 @ cb4f4929
...@@ -14,6 +14,8 @@ Adadelta ...@@ -14,6 +14,8 @@ Adadelta
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_Adadelta`
.. _api_fluid_optimizer_Adagrad: .. _api_fluid_optimizer_Adagrad:
Adagrad Adagrad
...@@ -23,6 +25,8 @@ Adagrad ...@@ -23,6 +25,8 @@ Adagrad
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_Adagrad`
.. _api_fluid_optimizer_AdagradOptimizer: .. _api_fluid_optimizer_AdagradOptimizer:
AdagradOptimizer AdagradOptimizer
...@@ -32,6 +36,8 @@ AdagradOptimizer ...@@ -32,6 +36,8 @@ AdagradOptimizer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_AdagradOptimizer`
.. _api_fluid_optimizer_Adam: .. _api_fluid_optimizer_Adam:
Adam Adam
...@@ -41,6 +47,8 @@ Adam ...@@ -41,6 +47,8 @@ Adam
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_Adam`
.. _api_fluid_optimizer_Adamax: .. _api_fluid_optimizer_Adamax:
Adamax Adamax
...@@ -50,6 +58,8 @@ Adamax ...@@ -50,6 +58,8 @@ Adamax
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_Adamax`
.. _api_fluid_optimizer_AdamaxOptimizer: .. _api_fluid_optimizer_AdamaxOptimizer:
AdamaxOptimizer AdamaxOptimizer
...@@ -59,6 +69,8 @@ AdamaxOptimizer ...@@ -59,6 +69,8 @@ AdamaxOptimizer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_AdamaxOptimizer`
.. _api_fluid_optimizer_AdamOptimizer: .. _api_fluid_optimizer_AdamOptimizer:
AdamOptimizer AdamOptimizer
...@@ -68,6 +80,8 @@ AdamOptimizer ...@@ -68,6 +80,8 @@ AdamOptimizer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_AdamOptimizer`
.. _api_fluid_optimizer_DecayedAdagrad: .. _api_fluid_optimizer_DecayedAdagrad:
DecayedAdagrad DecayedAdagrad
...@@ -77,6 +91,8 @@ DecayedAdagrad ...@@ -77,6 +91,8 @@ DecayedAdagrad
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_DecayedAdagrad`
.. _api_fluid_optimizer_DecayedAdagradOptimizer: .. _api_fluid_optimizer_DecayedAdagradOptimizer:
DecayedAdagradOptimizer DecayedAdagradOptimizer
...@@ -86,6 +102,8 @@ DecayedAdagradOptimizer ...@@ -86,6 +102,8 @@ DecayedAdagradOptimizer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_DecayedAdagradOptimizer`
.. _api_fluid_optimizer_Ftrl: .. _api_fluid_optimizer_Ftrl:
Ftrl Ftrl
...@@ -95,6 +113,8 @@ Ftrl ...@@ -95,6 +113,8 @@ Ftrl
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_Ftrl`
.. _api_fluid_optimizer_FtrlOptimizer: .. _api_fluid_optimizer_FtrlOptimizer:
FtrlOptimizer FtrlOptimizer
...@@ -104,6 +124,30 @@ FtrlOptimizer ...@@ -104,6 +124,30 @@ FtrlOptimizer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_FtrlOptimizer`
.. _api_fluid_optimizer_LarsMomentum:
LarsMomentum
------------
.. autoclass:: paddle.fluid.optimizer.LarsMomentum
:members:
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_LarsMomentum`
.. _api_fluid_optimizer_LarsMomentumOptimizer:
LarsMomentumOptimizer
---------------------
.. autoclass:: paddle.fluid.optimizer.LarsMomentumOptimizer
:members:
:noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_LarsMomentumOptimizer`
.. _api_fluid_optimizer_ModelAverage: .. _api_fluid_optimizer_ModelAverage:
ModelAverage ModelAverage
...@@ -113,6 +157,8 @@ ModelAverage ...@@ -113,6 +157,8 @@ ModelAverage
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_ModelAverage`
.. _api_fluid_optimizer_Momentum: .. _api_fluid_optimizer_Momentum:
Momentum Momentum
...@@ -122,6 +168,8 @@ Momentum ...@@ -122,6 +168,8 @@ Momentum
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_Momentum`
.. _api_fluid_optimizer_MomentumOptimizer: .. _api_fluid_optimizer_MomentumOptimizer:
MomentumOptimizer MomentumOptimizer
...@@ -131,14 +179,7 @@ MomentumOptimizer ...@@ -131,14 +179,7 @@ MomentumOptimizer
:members: :members:
:noindex: :noindex:
.. _api_fluid_optimizer_RMSPropOptimizer: Read Chinese Version: :ref:`cn_api_fluid_optimizer_MomentumOptimizer`
RMSPropOptimizer
----------------
.. autoclass:: paddle.fluid.optimizer.RMSPropOptimizer
:members:
:noindex:
.. _api_fluid_optimizer_RMSPropOptimizer: .. _api_fluid_optimizer_RMSPropOptimizer:
...@@ -149,6 +190,8 @@ RMSPropOptimizer ...@@ -149,6 +190,8 @@ RMSPropOptimizer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_RMSPropOptimizer`
.. _api_fluid_optimizer_SGD: .. _api_fluid_optimizer_SGD:
SGD SGD
...@@ -158,6 +201,8 @@ SGD ...@@ -158,6 +201,8 @@ SGD
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_SGD`
.. _api_fluid_optimizer_SGDOptimizer: .. _api_fluid_optimizer_SGDOptimizer:
SGDOptimizer SGDOptimizer
...@@ -167,3 +212,5 @@ SGDOptimizer ...@@ -167,3 +212,5 @@ SGDOptimizer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_optimizer_SGDOptimizer`
doc/fluid/api/profiler.rst
浏览文件 @ cb4f4929
...@@ -13,6 +13,8 @@ cuda_profiler ...@@ -13,6 +13,8 @@ cuda_profiler
.. autofunction:: paddle.fluid.profiler.cuda_profiler .. autofunction:: paddle.fluid.profiler.cuda_profiler
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_profiler_cuda_profiler`
.. _api_fluid_profiler_profiler: .. _api_fluid_profiler_profiler:
profiler profiler
...@@ -21,6 +23,8 @@ profiler ...@@ -21,6 +23,8 @@ profiler
.. autofunction:: paddle.fluid.profiler.profiler .. autofunction:: paddle.fluid.profiler.profiler
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_profiler_profiler`
.. _api_fluid_profiler_reset_profiler: .. _api_fluid_profiler_reset_profiler:
reset_profiler reset_profiler
...@@ -29,6 +33,8 @@ reset_profiler ...@@ -29,6 +33,8 @@ reset_profiler
.. autofunction:: paddle.fluid.profiler.reset_profiler .. autofunction:: paddle.fluid.profiler.reset_profiler
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_profiler_reset_profiler`
.. _api_fluid_profiler_start_profiler: .. _api_fluid_profiler_start_profiler:
start_profiler start_profiler
...@@ -37,6 +43,8 @@ start_profiler ...@@ -37,6 +43,8 @@ start_profiler
.. autofunction:: paddle.fluid.profiler.start_profiler .. autofunction:: paddle.fluid.profiler.start_profiler
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_profiler_start_profiler`
.. _api_fluid_profiler_stop_profiler: .. _api_fluid_profiler_stop_profiler:
stop_profiler stop_profiler
...@@ -45,3 +53,5 @@ stop_profiler ...@@ -45,3 +53,5 @@ stop_profiler
.. autofunction:: paddle.fluid.profiler.stop_profiler .. autofunction:: paddle.fluid.profiler.stop_profiler
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_profiler_stop_profiler`
doc/fluid/api/recordio_writer.rst
浏览文件 @ cb4f4929
...@@ -13,6 +13,8 @@ convert_reader_to_recordio_file ...@@ -13,6 +13,8 @@ convert_reader_to_recordio_file
.. autofunction:: paddle.fluid.recordio_writer.convert_reader_to_recordio_file .. autofunction:: paddle.fluid.recordio_writer.convert_reader_to_recordio_file
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_recordio_writer_convert_reader_to_recordio_file`
.. _api_fluid_recordio_writer_convert_reader_to_recordio_files: .. _api_fluid_recordio_writer_convert_reader_to_recordio_files:
convert_reader_to_recordio_files convert_reader_to_recordio_files
...@@ -21,3 +23,5 @@ convert_reader_to_recordio_files ...@@ -21,3 +23,5 @@ convert_reader_to_recordio_files
.. autofunction:: paddle.fluid.recordio_writer.convert_reader_to_recordio_files .. autofunction:: paddle.fluid.recordio_writer.convert_reader_to_recordio_files
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_recordio_writer_convert_reader_to_recordio_files`
doc/fluid/api/regularizer.rst
浏览文件 @ cb4f4929
...@@ -14,6 +14,8 @@ L1Decay ...@@ -14,6 +14,8 @@ L1Decay
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_regularizer_L1Decay`
.. _api_fluid_regularizer_L1DecayRegularizer: .. _api_fluid_regularizer_L1DecayRegularizer:
L1DecayRegularizer L1DecayRegularizer
...@@ -23,6 +25,8 @@ L1DecayRegularizer ...@@ -23,6 +25,8 @@ L1DecayRegularizer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_regularizer_L1DecayRegularizer`
.. _api_fluid_regularizer_L2Decay: .. _api_fluid_regularizer_L2Decay:
L2Decay L2Decay
...@@ -32,6 +36,8 @@ L2Decay ...@@ -32,6 +36,8 @@ L2Decay
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_regularizer_L2Decay`
.. _api_fluid_regularizer_L2DecayRegularizer: .. _api_fluid_regularizer_L2DecayRegularizer:
L2DecayRegularizer L2DecayRegularizer
...@@ -41,3 +47,5 @@ L2DecayRegularizer ...@@ -41,3 +47,5 @@ L2DecayRegularizer
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_regularizer_L2DecayRegularizer`
doc/fluid/api/transpiler.rst
浏览文件 @ cb4f4929
...@@ -14,6 +14,8 @@ DistributeTranspiler ...@@ -14,6 +14,8 @@ DistributeTranspiler
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_transpiler_DistributeTranspiler`
.. _api_fluid_transpiler_DistributeTranspilerConfig: .. _api_fluid_transpiler_DistributeTranspilerConfig:
DistributeTranspilerConfig DistributeTranspilerConfig
...@@ -23,6 +25,8 @@ DistributeTranspilerConfig ...@@ -23,6 +25,8 @@ DistributeTranspilerConfig
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_transpiler_DistributeTranspilerConfig`
.. _api_fluid_transpiler_HashName: .. _api_fluid_transpiler_HashName:
HashName HashName
...@@ -32,6 +36,8 @@ HashName ...@@ -32,6 +36,8 @@ HashName
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_transpiler_HashName`
.. _api_fluid_transpiler_memory_optimize: .. _api_fluid_transpiler_memory_optimize:
memory_optimize memory_optimize
...@@ -40,6 +46,8 @@ memory_optimize ...@@ -40,6 +46,8 @@ memory_optimize
.. autofunction:: paddle.fluid.transpiler.memory_optimize .. autofunction:: paddle.fluid.transpiler.memory_optimize
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_transpiler_memory_optimize`
.. _api_fluid_transpiler_release_memory: .. _api_fluid_transpiler_release_memory:
release_memory release_memory
...@@ -48,6 +56,8 @@ release_memory ...@@ -48,6 +56,8 @@ release_memory
.. autofunction:: paddle.fluid.transpiler.release_memory .. autofunction:: paddle.fluid.transpiler.release_memory
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_transpiler_release_memory`
.. _api_fluid_transpiler_RoundRobin: .. _api_fluid_transpiler_RoundRobin:
RoundRobin RoundRobin
...@@ -57,3 +67,5 @@ RoundRobin ...@@ -57,3 +67,5 @@ RoundRobin
:members: :members:
:noindex: :noindex:
Read Chinese Version: :ref:`cn_api_fluid_transpiler_RoundRobin`
doc/fluid/api_cn/api_guides/high_low_level_api.md 0 → 100644
浏览文件 @ cb4f4929
## High/Low-level API简介
Paddle目前有2套API接口：
- Low-level（底层） API：
- 灵活性强并且已经相对成熟，使用它训练的模型，能直接支持C++预测上线。
- 提供了大量的模型作为使用示例，包括[Book](https://github.com/PaddlePaddle/book)中的第7和8章，以及[models](https://github.com/PaddlePaddle/models)中的所有章节。
- 适用人群：对深度学习有一定了解，需要自定义网络进行训练/预测/上线部署的用户。
- High-level（高层）API：
- 使用简单，[Book](https://github.com/PaddlePaddle/book)中前六章提供了示例。
- 尚未成熟，接口暂时在[paddle.fluid.contrib](https://github.com/PaddlePaddle/Paddle/tree/develop/python/paddle/fluid/contrib)下面。
- 适用人群：想通过Book课程进行深度学习基础知识学习的初级用户。
doc/fluid/api_cn/api_guides/index.rst 0 → 100755
浏览文件 @ cb4f4929
===========
API使用指南
===========
.. toctree::
:hidden:
high_low_level_api.md
low_level/layers/index.rst
low_level/executor.rst
low_level/optimizer.rst
low_level/metrics.rst
low_level/model_save_reader.rst
low_level/inference.rst
low_level/distributed/index.rst
low_level/memory_optimize.rst
low_level/nets.rst
low_level/parallel_executor.rst
doc/fluid/api_cn/api_guides/low_level/distributed/async_training.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_async_training:
############
分布式异步训练
############
Fluid支持数据并行的分布式异步训练，API使用 :code:`DistributedTranspiler` 将单机网络配置转换成可以多机执行的
:code:`pserver` 端程序和 :code:`trainer` 端程序。用户在不同的节点执行相同的一段代码，根据环境变量或启动参数，
可以执行对应的 :code:`pserver` 或 :code:`trainer` 角色。Fluid异步训练只支持pserver模式，异步训练和 `同步训练 <../distributed/sync_training.html>`_ 的主要差异在于：异步训练每个trainer的梯度是单独更新到参数上的，
而同步训练是所有trainer的梯度合并之后统一更新到参数上，因此，同步训练和异步训练的超参数需要分别调节。
pserver模式分布式异步训练
======================
API详细使用方法参考 :ref: `api_fluid_DistributeTranspiler` ，简单示例用法：
.. code-block:: python
config = fluid.DistributedTranspilerConfig()
# 配置策略config
config.slice_var_up = False
t = fluid.DistributedTranspiler(config=config)
t.transpile(trainer_id,
program=main_program,
pservers="192.168.0.1:6174,192.168.0.2:6174",
trainers=1,
sync_mode=False)
以上参数说明请参考`同步训练 <../distributed/sync_training.html>`_
需要注意的是：进行异步训练时，请修改 :code:`sync_mode` 的值
- :code:`sync_mode` ： 是否是同步训练模式，默认为True，不传此参数也默认是同步训练模式，设置为False则为异步训练
doc/fluid/api_cn/api_guides/low_level/distributed/cluster_train_data_cn.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_cluster_train_data:
####################
分布式训练reader准备
####################
一个数据并行的分布式训练任务通常会含有多个训练进程，每个训练进程处理整个数据集中的一部分，根据当前进程的唯一序号(trainer_id)以及训练进程总数(trainers)可以决定当前训练进程应该读取哪一部分数据。
实现 cluster_reader 来读取分布式训练数据集
----------------------------------------
比较通用的方法，可以实现一个 cluster_reader, 根据训练进程数量以及进程序号决定读取哪些 example:
.. code-block:: python
def cluster_reader(reader, trainers, trainer_id):
def reader_creator():
for idx, data in enumerate(reader()):
if idx % trainers == trainer_id:
yield data
return reader
trainers = int(os.getenv("PADDLE_TRAINERS", "1"))
trainer_id = int(os.getenv("PADDLE_TRAINER_ID", "0"))
train_reader = cluster_reader(paddle.dataset.mnist.train(), trainers, trainer_id)
上述代码中，`trainers` 和 `trainer_id` 分别是训练进程总数和当前训练进程的序号，可以通过环境变量或者参数的方式传递给 Python 程序。
预先切分训练文件
-----------------
由于使用 `cluster_reader` 依然会读取全量数据，对于训练进程比较多的任务，会造成IO资源的浪费、影响训练性能。另一种方法是可以将训练数据切分成多个小文件，每个进程处理其中的一部分文件,
例如在 Linux 系统中可以使用 `split <http://man7.org/linux/man-pages/man1/split.1.html>`_ 命令将训练数据切分成多个小文件：
.. code-block:: bash
$ split -d -a 4 -d -l 100 housing.data cluster/housing.data.
$ find ./cluster
cluster/
cluster/housing.data.0002
cluster/housing.data.0003
cluster/housing.data.0004
cluster/housing.data.0000
cluster/housing.data.0001
cluster/housing.data.0005
数据切分好以后, 可以实现一个 file_dispatcher 函数，根据训练进程数量以及序号决定需要读取哪些文件：
.. code-block:: python
def file_dispatcher(files_pattern, trainers, trainer_id):
file_list = glob.glob(files_pattern)
ret_list = []
for idx, f in enumerate(file_list):
if (idx + trainers) % trainers == trainer_id:
ret_list.append(f)
return ret_list
trainers = int(os.getenv("PADDLE_TRAINERS", "1"))
trainer_id = int(os.getenv("PADDLE_TRAINER_ID", "0"))
files_pattern = "cluster/housing.data.*"
my_files = file_dispatcher(files_pattern, triners, trainer_id)
在上述例子中，`files_pattern` 是训练文件的 `glob 表达式 <https://docs.python.org/2.7/library/glob.html>`_，一般可以用通配符来表示。
doc/fluid/api_cn/api_guides/low_level/distributed/cpu_train_best_practice.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_cpu_training_best_practice:
##################
分布式CPU训练最佳实践
##################
提高CPU分布式训练的训练速度，主要要从两个方面来考虑：
1）提高训练速度，主要是提高CPU的使用率；2）提高通信速度，主要是减少通信传输的数据量。
提高CPU的使用率
=============
提高CPU使用率主要依赖 :code:`ParallelExecutor`，可以充分利用多个CPU的计算能力来加速计算。
API详细使用方法参考 :ref:`api_fluid_ParallelExecutor` ，简单实例用法：
.. code-block:: python
# 配置执行策略，主要是设置线程数
exec_strategy = fluid.ExecutionStrategy()
exec_strategy.num_threads = 8
# 配置构图策略，对于CPU训练而言，应该使用Reduce模式进行训练
build_strategy = fluid.BuildStrategy()
if int(os.getenv("CPU_NUM")) > 1:
build_strategy.reduce_strategy = fluid.BuildStrategy.ReduceStrategy.Reduce
pe = fluid.ParallelExecutor(
use_cuda=False,
loss_name=avg_cost.name,
main_program=main_program,
build_strategy=build_strategy,
exec_strategy=exec_strategy)
以上参数中：
- :code:`num_threads` ： 模型训练使用的线程数，最好和训练所在机器的物理CPU核数接近
- :code:`reduce_strategy` ： 对于CPU训练而言，应该选择 fluid.BuildStrategy.ReduceStrategy.Reduce
通用环境变量配置：
- :code:`CPU_NUM` ：模型副本replica的个数，最好和num_threads一致
提高通信速度
==========
要减少通信数据量，提高通信速度，主要是使用稀疏更新 ，目前支持 `稀疏更新 <../distributed/sparse_update.html>`_ 的主要是 :ref:`api_fluid_layers_embedding` 。
.. code-block:: python
data = fluid.layers.data(name='ids', shape=[1], dtype='int64')
fc = fluid.layers.embedding(input=data, size=[dict_size, 16], is_sparse=True)
以上参数中：
- :code:`is_sparse` ： 配置embedding使用稀疏更新，如果embedding的dict_size很大，而每次数据data很少，建议使用sparse更新方式。
doc/fluid/api_cn/api_guides/low_level/distributed/index.rst 0 → 100644
浏览文件 @ cb4f4929
=============
分布式训练
=============
.. toctree::
:maxdepth: 1
sync_training.rst
async_training.rst
cpu_train_best_practice.rst
large_scale_sparse_feature_training.rst
cluster_train_data_cn.rst
doc/fluid/api_cn/api_guides/low_level/distributed/large_scale_sparse_feature_training.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_large_scale_sparse_feature_training:
###################
大规模稀疏特征模型训练
###################
模型配置和训练
=============
embedding被广泛应用在各种网络结构中，尤其是文本处理相关的模型。在某些场景，例如推荐系统或者搜索引擎中，
embedding的feature id可能会非常多，当feature id达到一定数量时，embedding参数会变得很大，
会带来两个问题：
1）单机内存由于无法存放如此巨大的embedding参数，导致无法训练；
2）普通的训练模式每一轮迭代都需要同步完整的参数，参数太大会让通信变得非常慢，进而影响训练速度。
Fluid支持千亿量级超大规模稀疏特征embedding的训练，embedding参数只会保存在parameter server上，通过
参数prefetch和梯度稀疏更新的方法，大大减少通信量，提高通信速度。
该功能只对分布式训练有效，单机无法使用。
需要配合 `稀疏更新 <../distributed/sparse_update.html>`_ 一起使用。
使用方法：在配置embedding的时候，加上参数 :code:`is_distributed=True` 以及 :code:`is_sparse=True` 即可。
参数 :code:`dict_size` 定义数据中总的id的数量，id可以是int64范围内的任意值，只要总id个数小于等于dict_size就可以支持。
所以配置之前需要预估一下数据中总的feature id的数量。
.. code-block:: python
emb = fluid.layers.embedding(
is_distributed=True,
input=input,
size=[dict_size, embedding_width],
is_sparse=True,
is_distributed=True)
模型存储和预测
=============
当特征数量达到千亿的时候，参数量很大，单机已经无法存下，所以模型的存储和加载都和普通模式不同：
1）普通模式下，参数是在trainer端保存和加载的；
2）分布式模式下，参数的保存和加载，都是在pserver端进行，每个pserver只保存和加载该pserver自身对应部分的参数
doc/fluid/api_cn/api_guides/low_level/distributed/sync_training.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_sync_training:
############
分布式同步训练
############
Fluid支持数据并行的分布式同步训练，API使用 :code:`DistributedTranspiler` 将单机网络配置转换成可以多机执行的
:code:`pserver` 端程序和 :code:`trainer` 端程序。用户在不同的节点执行相同的一段代码，根据环境变量或启动参数，
可以执行对应的 :code:`pserver` 或 :code:`trainer` 角色。Fluid分布式同步训练同时支持pserver模式和NCCL2模式，
在API使用上有差别，需要注意。
pserver模式分布式训练
===================
API详细使用方法参考 :ref:`DistributeTranspiler` ，简单实例用法：
.. code-block:: python
config = fluid.DistributedTranspilerConfig()
# 配置策略config
config.slice_var_up = False
t = fluid.DistributedTranspiler(config=config)
t.transpile(trainer_id,
program=main_program,
pservers="192.168.0.1:6174,192.168.0.2:6174",
trainers=1,
sync_mode=True)
以上参数中：
- :code:`trainer_id` ： trainer节点的id，从0到n-1，n为当前训练任务中trainer节点的个数
- :code:`program` ： 被转换的 :code:`program` 默认使用 :code:`fluid.default_main_program()`
- :code:`pservers` ： 当前训练任务中pserver节点的IP端口列表
- :code:`trainers` ： int类型，当前训练任务中trainer节点的个数。注意：
* pserver模式下，trainer节点个数可以和pserver节点个数不一致，比如使用20个pserver和50个trainer。在实际训练任务中，您可以通过调整pserver节点和trainer节点个数找到最佳性能
* NCCL2模式中，此项参数是字符串，指定trainer节点的IP端口列表
- :code:`sync_mode` ： 是否是同步训练模式，默认为True，不传此参数也默认是同步训练模式
其中，支持的config包括：
- :code:`slice_var_up` ： 配置是否切分一个参数到多个pserver上进行优化，默认开启。此选项适用于模型参数个数少，但需要使用大量节点的场景，有利于提升pserver端计算并行度
- :code:`split_method` ： 配置transpiler分配参数（或参数的切片）到多个pserver的方式，默认为"RoundRobin"，也可以使用"HashName"
- :code:`min_block_size` ： 如果配置了参数切分，指定最小Tensor的切分大小，防止RPC请求包过小，默认为8192，一般情况不需要调整此项参数
- :code:`enable_dc_asgd` ： 是否开启 :code:`DC-ASGD` 此选项在异步训练中生效，启用异步训练补偿算法
- :code:`mode` : 可以选择"pserver"或"nccl2"，指定使用pserver模式或NCCL2模式分布式训练
- :code:`print_log` ： 是否开启transpiler debug日志，此项为开发调试使用
通用环境变量配置：
- :code:`FLAGS_rpc_send_thread_num` ：int，指定RPC通信发送时线程的个数
- :code:`FLAGS_rpc_get_thread_num` ： int，指定RPC通信接受时线程的个数
- :code:`FLAGS_rpc_prefetch_thread_num` ： int，分布式lookup table执行RPC通信时，prefetch线程的个数
- :code:`FLAGS_rpc_deadline` ： int，RPC通信最长等待时间，单位为毫秒，默认180000
NCCL2模式分布式训练
=================
基于NCCL2 (Collective Communication) 的多机同步训练模式，仅支持在GPU集群下进行。
此部分详细API说明可以参考 :ref:`DistributeTranspiler` 。
注意：NCCL2模式下，集群不需要启动pserver，只需要启动多个trainer节点即可。
使用以下代码，将当前 :code:`Program` 转化成适用于NCCL2分布式计算的Fluid :code:`Program` ：
.. code-block:: python
config = fluid.DistributeTranspilerConfig()
config.mode = "nccl2"
t = fluid.DistributedTranspiler(config=config)
t.transpile(trainer_id,
program=main_program,
startup_program=startup_program,
trainers="192.168.0.1:6174,192.168.0.2:6174",
current_endpoint="192.168.0.1:6174")
其中：
- :code:`trainer_id` : trainer节点的id，从0到n-1，n为当前训练任务中trainer节点的个数
- :code:`program` 和 :code:`startup_program` : 分别为Fluid 模型的主配置program和初始化startup_program
- :code:`trainers` : 字符串类型，指定当前任务所有trainer的IP和端口号，仅用于NCCL2初始化（pserver模式中，此参数为int，指定trainer节点的个数）
- :code:`current_endpoint` : 当前任务的当前节点的IP和端口号
doc/fluid/api_cn/api_guides/low_level/executor.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_executor:
##########
执行引擎
##########
:code:`Executor` 即 :code:`执行器` 。PaddlePaddle Fluid中有两种执行器可以选择。
:code:`Executor` 实现了一个简易的执行器，所有Operator会被顺序执行。用户可以使用
Python脚本驱动 :code:`Executor` 执行。默认情况下 :code:`Executor` 是单线程的，如果
想使用数据并行，请参考另一个执行器， :ref:`api_guide_parallel_executor` 。
:code:`Executor` 的代码逻辑非常简单。建议用户在调试过程中，先使用
:code:`Executor` 跑通模型，再切换到多设备计算，甚至多机计算。
:code:`Executor` 在构造的时候接受一个 :code:`Place`， 它们可以是 :ref:`api_fluid_CPUPlace`
或 :ref:`api_fluid_CUDAPlace` 。 :code:`Executor` 在执行的时候可以选择执行的
:ref:`api_guide_low_level_program` 。
简单的使用方法，请参考 `quick_start_fit_a_line <http://paddlepaddle.org/documentation/docs/zh/1.1/beginners_guide/quick_start/fit_a_line/README.cn.html>`_ , API Reference 请参考
:ref:`api_fluid_Executor` 。
doc/fluid/api_cn/api_guides/low_level/inference.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_inference:
#########
预测引擎
#########
预测引擎提供了存储预测模型 :ref:`api_fluid_io_save_inference_model` 和加载预测模型 :ref:`api_fluid_io_load_inference_model` 两个接口。
预测模型的存储格式
=================
预测模型的存储格式有两种，由上述两个接口中的 :code:`model_filename` 和 :code:`params_filename` 变量控制：
- 参数保存到各个独立的文件，如设置 :code:`model_filename` 为 :code:`None` 、:code:`params_filename` 为 :code:`None`
.. code-block:: bash
ls recognize_digits_conv.inference.model/*
__model__ conv2d_1.w_0 conv2d_2.w_0 fc_1.w_0 conv2d_1.b_0 conv2d_2.b_0 fc_1.b_0
- 参数保存到同一个文件，如设置 :code:`model_filename` 为 :code:`None` 、:code:`params_filename` 为 :code:`__params__`
.. code-block:: bash
ls recognize_digits_conv.inference.model/*
__model__ __params__
存储预测模型
===========
.. code-block:: python
exe = fluid.Executor(fluid.CPUPlace())
path = "./infer_model"
fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'],
target_vars=[predict_var], executor=exe)
在这个示例中，:code:`fluid.io.save_inference_model` 接口对默认的 :code:`fluid.Program` 进行裁剪，只保留预测 :code:`predict_var` 所需部分。
裁剪后的 :code:`program` 会保存在 :code:`./infer_model/__model__` 下，参数会保存到 :code:`./infer_model` 下的各个独立文件。
加载预测模型
===========
.. code-block:: python
exe = fluid.Executor(fluid.CPUPlace())
path = "./infer_model"
[inference_program, feed_target_names, fetch_targets] =
fluid.io.load_inference_model(dirname=path, executor=exe)
results = exe.run(inference_program,
feed={feed_target_names[0]: tensor_img},
fetch_list=fetch_targets)
在这个示例中，首先调用 :code:`fluid.io.load_inference_model` 接口，获得预测的 :code:`program` 、输入数据的 :code:`variable` 名称和输出结果的 :code:`variable` ;
然后调用 :code:`executor` 执行预测的 :code:`program` 获得预测结果。
doc/fluid/api_cn/api_guides/low_level/layers/activations.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_activations:
####
激活函数
####
激活函数将非线性的特性引入到神经网络当中。
PaddlePaddle Fluid 对大部分的激活函数进行了支持，其中有:
:ref:`api_fluid_layers_relu`, :ref:`api_fluid_layers_tanh`, :ref:`api_fluid_layers_sigmoid`, :ref:`api_fluid_layers_elu`, :ref:`api_fluid_layers_relu6`, :ref:`api_fluid_layers_pow`, :ref:`api_fluid_layers_stanh`, :ref:`api_fluid_layers_hard_sigmoid`, :ref:`api_fluid_layers_swish`, :ref:`api_fluid_layers_prelu`, :ref:`api_fluid_layers_brelu`, :ref:`api_fluid_layers_leaky_relu`, :ref:`api_fluid_layers_soft_relu`, :ref:`api_fluid_layers_thresholded_relu`, :ref:`api_fluid_layers_maxout`, :ref:`api_fluid_layers_logsigmoid`, :ref:`api_fluid_layers_hard_shrink`, :ref:`api_fluid_layers_softsign`, :ref:`api_fluid_layers_softplus`, :ref:`api_fluid_layers_tanh_shrink`, :ref:`api_fluid_layers_softshrink`, :ref:`api_fluid_layers_exp`。
**Fluid提供了两种使用激活函数的方式：**
- 如果一个层的接口提供了 :code:`act` 变量（默认值为None），我们可以通过该变量指定该层的激活函数类型。该方式支持常见的激活函数: :code:`relu`, :code:`tanh`, :code:`sigmoid`, :code:`identity`。
.. code-block:: python
conv2d = fluid.layers.conv2d(input=data, num_filters=2, filter_size=3, act="relu")
- Fluid为每个Activation提供了接口，我们可以显式的对它们进行调用。
.. code-block:: python
conv2d = fluid.layers.conv2d(input=data, num_filters=2, filter_size=3)
relu1 = fluid.layers.relu(conv2d)
doc/fluid/api_cn/api_guides/low_level/layers/control_flow.rst 0 → 100644
浏览文件 @ cb4f4929
.. api_guide_control_flow:
######
控制流
######
在程序语言中，控制流(control flow)决定了语句的执行顺序，常见的控制流包括顺序执行、分支和循环等。PaddlePaddle Fluid继承了这一概念，提供了多种控制流API, 以控制深度学习模型在训练或者预测过程中的执行逻辑。
IfElse
======
条件分支，允许对同一个batch的输入，根据给定的条件，分别选择 :code:`true_block` 或 :code:`false_block` 中的逻辑进行执行，执行完成之后再将两个分支的输出合并为同一个输出。通常，条件表达式可由 :ref:`api_fluid_layers_less_than`, :ref:`api_fluid_layers_equal` 等逻辑比较 API 产生。
请参考 :ref:`api_fluid_layers_IfElse`
Switch
======
多分支选择结构，如同程序语言中常见的 :code:`switch-case` 声明, 其根据输入表达式的取值不同，选择不同的分支执行。具体来说，Fluid 所定义的 :code:`Switch` 控制流有如下特性：
* case的条件是个bool类型的值，即在Program中是一个张量类型的Variable；
* 依次检查逐个case，选择第一个满足条件的case执行，完成执行后即退出所属的block；
* 如果所有case均不满足条件，会选择默认的case进行执行。
请参考 :ref:`api_fluid_layers_Switch`
While
=====
While 循环，当条件判断为真时，循环执行 :code:`While` 控制流所属 :code:`block` 内的逻辑，条件判断为假时退出循环。与之相关的API有
* :ref:`api_fluid_layers_increment` ：累加API，通常用于对循环次数进行计数；
* :ref:`api_fluid_layers_array_read` ：从 :code:`LOD_TENSOR_ARRAY` 中指定的位置读入Variable，进行计算；
* :ref:`api_fluid_layers_array_write` ：将 Variable 写回到 :code:`LOD_TENSOR_ARRAY` 指定的位置，存储计算结果。
请参考 :ref:`api_fluid_layers_While`
DynamicRNN
==========
即动态RNN，可处理一个batch不等长的序列数据，其接受 :code:`lod_level=1` 的 Variable 作为输入，在 :code:`DynamicRNN` 的 :code:`block` 内，用户需自定义RNN的单步计算逻辑。在每一个时间步，用户可将需记忆的状态写入到 :code:`DynamicRNN` 的 :code:`memory` 中，并将需要的输出写出到其 :code:`output` 中。
:ref:`api_fluid_layers_sequence_last_step` 可获取 :code:`DynamicRNN` 最后一个时间步的输出。
请参考 :ref:`api_fluid_layers_DynamicRNN`
StaticRNN
=========
即静态RNN，只能处理固定长度的序列数据，接受 :code:`lod_level=0` 的 Variable 作为输入。与 :code:`DynamicRNN` 类似，在RNN的每单个时间步，用户需自定义计算逻辑，并可将状态和输出写出。
请参考 :ref:`api_fluid_layers_StaticRNN`
doc/fluid/api_cn/api_guides/low_level/layers/conv.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_conv:
#####
卷积
#####
卷积有两组输入：特征图和卷积核，依据输入特征和卷积核的形状、Layout不同、计算方式的不同，在Fluid里，有针对变长序列特征的一维卷积，有针对定长图像特征的二维(2D Conv)、三维卷积(3D Conv)，同时也有卷积计算的逆向过程，下面先介绍Fluid里的2D/3D卷积，再来介绍序列卷积。
2D/3D卷积
==============
1. 卷积输入参数：
---------------------
卷积需要依据滑动步长(stride)、填充长度(padding)、卷积核窗口大小(filter size)、分组数(groups)、扩张系数(dilation rate)来决定如何计算。groups最早在 `AlexNet <https://www.nvidia.cn/content/tesla/pdf/machine-learning/imagenet-classification-with-deep-convolutional-nn.pdf>`_ 中引入, 可以理解为将原始的卷积分为独立若干组卷积计算。
**注意**: 同cuDNN的方式，Fluid目前只支持在特征图上下填充相同的长度，左右也是。
- 输入输出Layout:
2D卷积输入特征的Layout为[N, C, H, W]或[N, H, W, C], N即batch size，C是通道数，H、W是特征的高度和宽度，输出特征和输入特征的Layout一致。(相应的3D卷积输入特征的Layout为[N, C, D, H, W]或[N, D, H, W, C]，但**注意**，Fluid的卷积当前只支持[N, C, H, W]，[N, C, D, H, W]。)
- 卷积核的Layout:
Fluid中2D卷积的卷积核(也称权重)的Layout为[C_o, C_in / groups, f_h, f_w]，C_o、C_in表示输出、输入通道数，f_h、f_w表示卷积核窗口的高度和宽度，按行序存储。(相应的2D卷积的卷积核Layout为[C_o, C_in / groups, f_d, f_h, d_w]，同样按行序存储。)
- 深度可分离卷积(depthwise separable convolution):
在深度可分离卷积中包括depthwise convolution和pointwise convolution两组，这两个卷积的接口和上述普通卷积接口相同。前者可以通过给普通卷积设置groups来做，后者通过设置卷积核filters的大小为1x1，深度可分离卷积减少参数的同时减少了计算量。
对于depthwise convolution，可以设置groups等于输入通道数，此时，2D卷积的卷积核形状为[C_o, 1, f_h, f_w]。
对于pointwise convolution，卷积核的形状为[C_o, C_in, 1, 1]。
**注意**：Fluid针对depthwise convolution的GPU计算做了高度优化，您可以通过在 :code:`fluid.layers.conv2d`接口设置 :code:`use_cudnn=False`来使用Fluid自身优化的CUDA程序。
- 空洞卷积(dilated convolution):
空洞卷积相比普通卷积而言，卷积核在特征图上取值时不在连续，而是间隔的，这个间隔数称作dilation，等于1时，即为普通卷积，空洞卷积相比普通卷积的感受野更大。
- API汇总:
- :ref:`api_fluid_layers_conv2d`
- :ref:`api_fluid_layers_conv3d`
- :ref:`api_fluid_layers_conv2d_transpose`
- :ref:`api_fluid_layers_conv3d_transpose`
1D序列卷积
==============
Fluid可以表示变长的序列结构，这里的变长是指不同样本的时间步(step)数不一样，通常是一个2D的Tensor和一个能够区分的样本长度的辅助结构来表示。假定，2D的Tensor的形状是shape，shape[0]是所有样本的总时间步数，shape[1]是序列特征的大小。
基于此数据结构的卷积在Fluid里称作序列卷积，也表示一维卷积。同图像卷积，序列卷积的输入参数有卷积核大小、填充大小、滑动步长，但与2D卷积不同的是，这些参数个数都为1。**注意**，目前仅支持stride为1的情况，输出序列的时间步数和输入序列相同。
假如：输入序列形状为(T, N)， T即该序列的时间步数，N是序列特征大小；卷积核的上下文步长为K，输出序列长度为M，则卷积核权重形状为(K * N, M），输出序列形状为(T, M)。
另外，参考DeepSpeech，Fluid实现了行卷积row convolution, 或称
`look ahead convolution <http://www.cs.cmu.edu/~dyogatam/papers/wang+etal.iclrworkshop2016.pdf>`_ ，
该卷积相比上述普通序列卷积可以减少参数。
- API汇总:
- :ref:`api_fluid_layers_sequence_conv`
- :ref:`api_fluid_layers_row_conv`
doc/fluid/api_cn/api_guides/low_level/layers/data_feeder.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_data_feeder:
使用DataFeeder传入训练/预测数据
###################################
Fluid提供 :code:`DataFeeder` 类，将numpy array等数据转换为 :code:`LoDTensor` 类型传入训练/预测网络。
用户创建 :code:`DataFeeder` 对象的方式为：
.. code-block:: python
import paddle.fluid as fluid
image = fluid.layers.data(name='image', shape=[-1, 3, 224, 224], dtype='float32')
label = fluid.layers.data(name='label', shape=[-1, 1], dtype='int64')
place = fluid.CUDAPlace(0) if fluid.core.is_compiled_with_cuda() else fluid.CPUPlace()
feeder = fluid.DataFeeder(feed_list=[image, label], place=place)
其中，:code:`feed_list` 参数为变量列表，这些变量由 :code:`fluid.layers.data()` 创建，
:code:`place` 参数表示应将Python端传入的numpy array等数据转换为GPU端或是CPU端的 :code:`LoDTensor` 。
创建 :code:`DataFeeder` 对象后，用户可调用其 :code:`feed(iterable)` 方法将用户传入的
:code:`iterable` 数据转换为 :code:`LoDTensor`。
:code:`iterable` 应为Python List或Tuple类型对象，且 :code:`iterable` 的每个元素均为长度为N的
Python List或Tuple类型对象，其中N为创建 :code:`DataFeeder` 对象时传入的 :code:`feed_list` 变量个数。
:code:`iterable` 的具体格式为：
.. code-block:: python
iterable = [
(image_1, label_1),
(image_2, label_2),
...
(image_n, label_n)
]
其中，:code:`image_i` 与 :code:`label_i` 均为numpy array类型数据。若传入数据的维度为[1]，如 :code:`label_i`,
则可传入Python int、float等类型数据。 :code:`image_i` 与 :code:`label_i` 的数据类型和维度不必
与 :code:`fluid.layers.data()` 创建时指定的 :code:`dtype` 和 :code:`shape` 完全一致，:code:`DataFeeder` 内部
会完成数据类型和维度的转换。若 :code:`feed_list` 中的变量的 :code:`lod_level` 不为零，则Fluid会将经过维度转换后的
:code:`iterable` 中每行数据的第0维作为返回结果的 :code:`LoD`。
具体使用方法请参见 :ref:`api_fluid_DataFeeder` 。
\ No newline at end of file
doc/fluid/api_cn/api_guides/low_level/layers/data_in_out.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_data_in_out:
数据输入输出
###############
数据输入
-------------
Fluid支持两种数据输入方式，包括：
1. Python Reader: 纯Python的Reader。用户在Python端定义 :code:`fluid.layers.data` 层构建网络，并通过
:code:`executor.run(feed=...)` 的方式读入数据。数据读取和模型训练/预测的过程是同步进行的。
2. PyReader: 高效灵活的C++ Reader接口。PyReader内部维护容量为 :code:`capacity` 的队列（队列容量由
:code:`fluid.layers.py_reader` 接口中的 :code:`capacity` 参数设置），Python端调用队列的 :code:`push`
方法送入训练/预测数据，C++端的训练/预测程序调用队列的 :code:`pop` 方法取出Python端送入的数据。PyReader可与
:code:`double_buffer` 配合使用，实现数据读取和训练/预测的异步执行。
具体使用方法请参考 :ref:`api_fluid_layers_py_reader`。
数据输出
------------
Fluid支持在训练/预测阶段获取当前batch的数据。
用户可通过 :code:`executor.run(fetch_list=[...], return_numpy=...)` 的方式
fetch期望的输出变量，通过设置 :code:`return_numpy` 参数设置是否将输出数据转为numpy array。
若 :code:`return_numpy` 为 :code:`False` ，则返回 :code:`LoDTensor` 类型数据。
具体使用方式请参考相关API文档 :ref:`api_fluid_executor_Executor` 和
:ref:`api_fluid_ParallelExecutor`。
\ No newline at end of file
doc/fluid/api_cn/api_guides/low_level/layers/detection.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_detection:
图像检测
#########
PaddlePaddle Fluid在图像检测任务中实现了多个特有的操作。以下分模型介绍各个api：
通用操作
-------------
图像检测中的一些通用操作，是对检测框的一系列操作，其中包括：
* 对检测框的编码，解码（box_coder）：实现两种框之间编码和解码的转换。例如训练阶段对先验框和真实框进行编码得到训练目标值。API Reference 请参考 :ref:`api_fluid_layers_box_coder`
* 比较两个检测框并进行匹配：
* iou_similarity：计算两组框的IOU值。API Reference 请参考 :ref:`api_fluid_layers_iou_similarity`
* bipartite_match：通过贪心二分匹配算法得到每一列中距离最大的一行。API Reference 请参考 :ref:`api_fluid_layers_bipartite_match`
* 根据检测框和标签得到分类和回归目标值（target_assign）：通过匹配索引和非匹配索引得到目标值和对应权重。API Reference 请参考 :ref:`api_fluid_layers_target_assign`
Faster RCNN
-------------
`Faster RCNN <https://arxiv.org/abs/1506.01497>`_ 是典型的两阶段目标检测器，相较于传统提取区域的方法，Faster RCNN中RPN网络通过共享卷积层参数大幅提高提取区域的效率，并提出高质量的候选区域。RPN网络需要对输入anchor和真实值进行比较生成初选候选框，并对初选候选框分配分类和回归值，>需要如下四个特有api：
* rpn_target_assign：通过anchor和真实框为anchor分配RPN网络的分类和回归目标值。API Reference 请参考 :ref:`api_fluid_layers_rpn_target_assign`
* anchor_generator：为每个位置生成一系列anchor。API Reference 请参考 :ref:`api_fluid_layers_anchor_generator`
* generate_proposal_labels: 通过generate_proposals得到的候选框和真实框得到RCNN部分的分类和回归的目标值。API Reference 请参考 :ref:`api_fluid_layers_generate_proposal_labels`
* generate_proposals: 对RPN网络输出box解码并筛选得到新的候选框。API Reference 请参考 :ref:`api_fluid_layers_generate_proposals`
SSD
----------------
`SSD <https://arxiv.org/abs/1512.02325>`_ 全称Single Shot MultiBox Detector，是目标检测领域较新且效果较好的检测算法之一，具有检测速度快且检测精度高的特点。与两阶段的检测方法不同，单阶段目标检测并不进行区域推荐，而是直接从特征图回归出目标的边界框和分类概率。SSD网络对六个尺度特>征图计算损失，进行预测，需要如下五种特有api：
* Prior Box：根据不同参数为每个输入位置生成一系列候选框。API Reference 请参考 :ref:`api_fluid_layers_prior_box`
* multi_box_head ：得到不同prior box的位置和置信度。API Reference 请参考 :ref:`api_fluid_layers_multi_box_head`
* detection_output：对prioir box解码，通过多分类NMS得到检测结果。API Reference 请参考 :ref:`api_fluid_layers_detection_output`
* ssd_loss：通过位置偏移预测值，置信度，检测框位置和真实框位置和标签计算损失。API Reference 请参考 :ref:`api_fluid_layers_ssd_loss`
* detection map: 利用mAP评估SSD网络模型。API Reference 请参考 :ref:`api_fluid_layers_detection_map`
OCR
---------
场景文字识别是在图像背景复杂、分辨率低下、字体多样、分布随意等情况下，将图像信息转化为文字序列的过程，可认为是一种特别的翻译过程：将图像输入翻译为自然语言输出。OCR任务中需要对检测框进行不规则变换，其中需要如下两个api：
* roi_perspective_transform：对输入roi做透视变换。API Reference 请参考 :ref:`api_fluid_layers_roi_perspective_transform`
* polygon_box_transform：对不规则检测框进行坐标变换。API Reference 请参考 :ref:`api_fluid_layers_polygon_box_transform`
doc/fluid/api_cn/api_guides/low_level/layers/index.rst 0 → 100644
浏览文件 @ cb4f4929
=============
神经网络层
=============
.. toctree::
:maxdepth: 1
conv.rst
pooling.rst
detection.rst
sequence.rst
math.rst
activations.rst
loss_function.rst
data_in_out.rst
control_flow.rst
sparse_update.rst
data_feeder.rst
learning_rate_scheduler.rst
tensor.rst
doc/fluid/api_cn/api_guides/low_level/layers/learning_rate_scheduler.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_learning_rate_scheduler:
############
学习率调度器
############
当我们使用诸如梯度下降法等方式来训练模型时，一般会兼顾训练速度和损失(loss)来选择相对合适的学习率。但若在训练过程中一直使用一个学习率，训练集的损失下降到一定程度后便不再继续下降，而是在一定范围内震荡。其震荡原理如下图所示，即当损失函数收敛到局部极小值附近时，会由于学习率过大导致更新步幅过大，每步参数更新会反复越过极小值而出现震荡。
.. image:: ../../../../images/learning_rate_scheduler.png
:scale: 80 %
:align: center
学习率调度器定义了常用的学习率衰减策略来动态生成学习率，学习率衰减函数以epoch或step为参数，返回一个随训练逐渐减小的学习率，从而兼顾降低训练时间和在局部极小值能更好寻优两个方面。
下面介绍学习率调度器中相关的Api：
======
* :code:`noam_decay`: 诺姆衰减，相关算法请参考 `《Attention Is All You Need》 <https://arxiv.org/pdf/1706.03762.pdf>`_ 。
相关API Reference请参考 :ref:`api_fluid_layers_noam_decay`
* :code:`exponential_decay`: 指数衰减，即每次将当前学习率乘以给定的衰减率得到下一个学习率。
相关API Reference请参考 :ref:`api_fluid_layers_exponential_decay`
* :code:`natural_exp_decay`: 自然指数衰减，即每次将当前学习率乘以给定的衰减率的自然指数得到下一个学习率。
相关API Reference请参考 :ref:`api_fluid_layers_natural_exp_decay`
* :code:`inverse_time_decay`: 逆时间衰减，即得到的学习率与当前衰减次数成反比。
相关API Reference请参考 :ref:`api_fluid_layers_inverse_time_decay`
* :code:`polynomial_decay`: 多项式衰减，即得到的学习率为初始学习率和给定最终学习之间由多项式计算权重定比分点的插值。
相关API Reference请参考 :ref:`api_fluid_layers_polynomial_decay`
* :code:`piecewise_decay`: 分段衰减，即由给定step数分段呈阶梯状衰减，每段内学习率相同。
相关API Reference请参考 :ref:`api_fluid_layers_piecewise_decay`
* :code:`append_LARS`: 通过Layer-wise Adaptive Rate Scaling算法获得学习率，相关算法请参考 `《Train Feedfoward Neural Network with Layer-wise Adaptive Rate via Approximating Back-matching Propagation》 <https://arxiv.org/abs/1802.09750>`_ 。
相关API Reference请参考 :ref:`api_fluid_layers_append_LARS`
doc/fluid/api_cn/api_guides/low_level/layers/loss_function.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_loss_function:
#######
损失函数
#######
损失函数定义了拟合结果和真实结果之间的差异，作为优化的目标直接关系模型训练的好坏，很多研究工作的内容也集中在损失函数的设计优化上。
Paddle Fluid 中提供了面向多种任务的多种类型的损失函数，以下列出了一些 Paddle Fluid 中包含的较为常用的损失函数。
回归
====
平方误差损失（squared error loss）使用预测值和真实值之间误差的平方作为样本损失，是回归问题中最为基本的损失函数。
API Reference 请参考 :ref:`api_fluid_layers_square_error_cost`。
平滑 L1 损失（smooth_l1 loss）是一种分段的损失函数，较平方误差损失其对异常点相对不敏感，因而更为鲁棒。
API Reference 请参考 :ref:`api_fluid_layers_smooth_l1`。
分类
====
`交叉熵（cross entropy） <https://en.wikipedia.org/wiki/Cross_entropy>`_ 是分类问题中使用最为广泛的损失函数，Paddle Fluid 中提供了接受归一化概率值和非归一化分值输入的两种交叉熵损失函数的接口，并支持 soft label 和 hard label 两种样本类别标签。
API Reference 请参考 :ref:`api_fluid_layers_cross_entropy` 和 :ref:`api_fluid_layers_softmax_with_cross_entropy`。
多标签分类
---------
对于多标签分类问题，如一篇文章同属于政治、科技等多个类别的情况，需要将各类别作为独立的二分类问题计算损失，Paddle Fluid 中为此提供了 sigmoid_cross_entropy_with_logits 损失函数，
API Reference 请参考 :ref:`api_fluid_layers_sigmoid_cross_entropy_with_logits`。
大规模分类
---------
对于大规模分类问题，通常需要特殊的方法及相应的损失函数以加速训练，常用的方法有 `噪声对比估计（Noise-contrastive estimation，NCE） <http://proceedings.mlr.press/v9/gutmann10a/gutmann10a.pdf>`_ 和 `层级 sigmoid <http://www.iro.umontreal.ca/~lisa/pointeurs/hierarchical-nnlm-aistats05.pdf>`_ 。
* 噪声对比估计通过将多分类问题转化为学习分类器来判别数据来自真实分布和噪声分布的二分类问题，基于二分类来进行极大似然估计，避免在全类别空间计算归一化因子从而降低了计算复杂度。
* 层级 sigmoid 通过二叉树进行层级的二分类来实现多分类，每个样本的损失对应了编码路径上各节点二分类交叉熵的和，避免了归一化因子的计算从而降低了计算复杂度。
这两种方法对应的损失函数在 Paddle Fluid 中均有提供，API Reference 请参考 :ref:`api_fluid_layers_nce` 和 :ref:`api_fluid_layers_hsigmoid`。
序列分类
-------
序列分类可以分为以下三种：
* 序列分类（Sequence Classification）问题，整个序列对应一个预测标签，如文本分类。这种即是普通的分类问题，可以使用 cross entropy 作为损失函数。
* 序列片段分类（Segment Classification）问题，序列中的各个片段对应有自己的类别标签，如命名实体识别。对于这种序列标注问题，`（线性链）条件随机场（Conditional Random Field，CRF） <http://www.cs.columbia.edu/~mcollins/fb.pdf>`_ 是一种常用的模型方法，其使用句子级别的似然概率，序列中不同位置的标签不再是条件独立，能够有效解决标记偏置问题。Paddle Fluid 中提供了 CRF 对应损失函数的支持，API Reference 请参考 :ref:`api_fluid_layers_linear_chain_crf`。
* 时序分类（Temporal Classification）问题，需要对未分割的序列进行标注，如语音识别。对于这种时序分类问题，`CTC（Connectionist Temporal Classification） <http://people.idsia.ch/~santiago/papers/icml2006.pdf>`_ 损失函数不需要对齐输入数据及标签，可以进行端到端的训练，Paddle Fluid 提供了 warpctc 的接口来计算相应的损失，API Reference 请参考 :ref:`api_fluid_layers_warpctc`。
排序
====
`排序问题 <https://en.wikipedia.org/wiki/Learning_to_rank>`_ 可以使用 Pointwise、Pairwise 和 Listwise 的学习方法，不同的方法需要使用不同的损失函数：
* Pointwise 的方法通过近似为回归问题解决排序问题，可以使用回归问题的损失函数。
* Pairwise 的方法需要特殊设计的损失函数，其通过近似为分类问题解决排序问题，使用两篇文档与 query 的相关性得分以偏序作为二分类标签来计算损失。Paddle Fluid 中提供了两种常用的 Pairwise 方法的损失函数，API Reference 请参考 :ref:`api_fluid_layers_rank_loss` 和 :ref:`api_fluid_layers_margin_rank_loss`。
更多
====
对于一些较为复杂的损失函数，可以尝试使用其他损失函数组合实现；Paddle Fluid 中提供的用于图像分割任务的 :ref:`api_fluid_layers_dice_loss` 即是使用其他 OP 组合（计算各像素位置似然概率的均值）而成；多目标损失函数也可看作这样的情况，如 Faster RCNN 就使用 cross entropy 和 smooth_l1 loss 的加权和作为损失函数。
**注意**，在定义损失函数之后为能够使用 :ref:`api_guide_optimizer` 进行优化，通常需要使用 :ref:`api_fluid_layers_mean` 或其他操作将损失函数返回的高维 Tensor 转换为 Scalar 值。
\ No newline at end of file
doc/fluid/api_cn/api_guides/low_level/layers/math.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_math:
数学操作
#########
Paddle提供了丰富的数学操作，以下列出的数学操作都是对目标张量进行逐元素的操作。其中，如果二元操作的两个输入有不同形状，会先进行 :code:`broadcast`. 部分数学操作还支持数学操作符，比如： :code:`+`, :code:`-`, :code:`*`, :code:`/` 等。数学操作符不仅支持张量，还支持标量。
一元操作
==================
exp
------------------
对输入 :code:`Tensor` 逐元素做 :code:`exp` 操作。
API Reference 请参考 :ref:`api_fluid_layers_exp`
tanh
------------------
对输入 :code:`Tensor` 逐元素取正切。
API Reference 请参考 :ref:`api_fluid_layers_tanh`
sqrt
------------------
对输入 :code:`Tensor` 逐元素取平方根。
API Reference 请参考 :ref:`api_fluid_layers_sqrt`
abs
------------------
对输入 :code:`Tensor` 逐元素取绝对值。
API Reference 请参考 :ref:`api_fluid_layers_abs`
ceil
------------------
对输入 :code:`Tensor` 逐元素向上取整。
API Reference 请参考 :ref:`api_fluid_layers_ceil`
floor
------------------
对输入 :code:`Tensor` 逐元素向下取整。
API Reference 请参考 :ref:`api_fluid_layers_floor`
sin
------------------
对输入 :code:`Tensor` 逐元素取正玄。
API Reference 请参考 :ref:`api_fluid_layers_sin`
cos
------------------
对输入 :code:`Tensor` 逐元素取余玄。
API Reference 请参考 :ref:`api_fluid_layers_cos`
round
------------------
对输入 :code:`Tensor` 逐元素四舍五入取整。
API Reference 请参考 :ref:`api_fluid_layers_round`
square
------------------
对输入 :code:`Tensor` 逐元素取平方。
API Reference 请参考 :ref:`api_fluid_layers_square`
reciprocal
------------------
对输入 :code:`Tensor` 逐元素取倒数。
API Reference 请参考 :ref:`api_fluid_layers_reciprocal`
reduce
------------------
对输入 :code:`Tensor` 在指定的若干轴上做reduce操作，包括：min, max, sum, mean, product
API Reference 请参考:
:ref:`api_fluid_layers_reduce_min`
:ref:`api_fluid_layers_reduce_max`
:ref:`api_fluid_layers_reduce_sum`
:ref:`api_fluid_layers_reduce_mean`
:ref:`api_fluid_layers_reduce_prod`
二元操作
==================
elementwise_add
------------------
对两个 :code:`Tensor` 逐元素相加，对应的数学操作符为 :code:`+`
API Reference 请参考 :ref:`api_fluid_layers_elementwise_add`
elementwise_sub
------------------
对两个 :code:`Tensor` 逐元素相减，对应数学操作符 :code:`-`
API Reference 请参考 :ref:`api_fluid_layers_elementwise_sub`
elementwise_mul
------------------
对两个 :code:`Tensor` 逐元素相乘， 对应数学操作符 :code:`*`
API Reference 请参考 :ref:`api_fluid_layers_elementwise_mul`
elementwise_div
------------------
对两个 :code:`Tensor` 逐元素相除， 对应数学操作符 :code:`/` 或 :code:`//`
API Reference 请参考 :ref:`api_fluid_layers_elementwise_div`
elementwise_pow
------------------
对两个 :code:`Tensor` 逐元素做次幂操作， 对应数学操作符 :code:`**`
API Reference 请参考 :ref:`api_fluid_layers_elementwise_pow`
equal
------------------
对两个 :code:`Tensor` 逐元素判断是否相等， 对应数学操作符 :code:`==`
API Reference 请参考 :ref:`api_fluid_layers_equal`
not_equal
------------------
对两个 :code:`Tensor` 逐元素判断是否不等， 对应数学操作符 :code:`!=`
API Reference 请参考 :ref:`api_fluid_layers_elementwise_not_equal`
less_than
------------------
对两个 :code:`Tensor` 逐元素判断是否满足小于关系， 对应数学操作符 :code:`<`
API Reference 请参考 :ref:`api_fluid_layers_less_than`
less_equal
------------------
对两个 :code:`Tensor` 逐元素判断是否满足小于或等于关系， 对应数学操作符 :code:`<=`
API Reference 请参考 :ref:`api_fluid_layers_less_equal`
greater_than
------------------
对两个 :code:`Tensor` 逐元素判断是否满足大于关系， 对应数学操作符 :code:`>`
API Reference 请参考 :ref:`api_fluid_layers_greater_than`
greater_equal
------------------
对两个 :code:`Tensor` 逐元素判断是否满足大于或等于关系， 对应数学操作符 :code:`>=`
API Reference 请参考 :ref:`api_fluid_layers_greater_equal`
sum
------------------
对两个 :code:`Tensor` 逐元素相加。
API Reference 请参考 :ref:`api_fluid_layers_sum`
min
------------------
对两个 :code:`Tensor` 逐元素进行 :code:`min(x, y)` 操作。
API Reference 请参考 :ref:`api_fluid_layers_min`
max
------------------
对两个 :code:`Tensor` 逐元素进行 :code:`max(x, y)` 操作。
API Reference 请参考 :ref:`api_fluid_layers_max`
matmul
------------------
对两个 :code:`Tensor` 进行矩阵乘操作。
API Reference 请参考 :ref:`api_fluid_layers_matmul`
doc/fluid/api_cn/api_guides/low_level/layers/pooling.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_pool:
#####
池化
#####
池化的作用是对输入特征做下采样和降低过拟合。降低过拟合是减小输出大小的结果，它同样也减少了后续层中的参数的数量。
池化通常只需要将前一层的特征图作为输入，此外需要一些参数来确定池化具体的操作。在PaddlePaddle中我们同样通过设定池化的大小，方式，步长，是否是全局池化，是否使用cudnn，是否使用ceil函数计算输出等参数来选择具体池化的方式。
PaddlePaddle中有针对定长图像特征的二维(pool2d)、三维卷积(pool3d)，RoI池化(roi_pool)，以及针对序列的序列池化(sequence_pool)，同时也有池化计算的反向过程，下面先介绍2D/3D池化，以及RoI池化，再来介绍序列池化。
--------------
1. pool2d/pool3d
------------------------
- ``input`` : 池化操作接收任何符合layout是：\ ``N（batch size）* C(channel size) * H(height) * W(width)``\ 格式的\ ``Tensor``\ 类型作为输入。
- ``pool_size``\ : 用来确定池化\ ``filter``\ 的大小，即将多大范围内的数据池化为一个值。
- ``num_channels``\ : 用来确定输入的\ ``channel``\ 数量，如果未设置参数或设置为\ ``None``\ ，其实际值将自动设置为输入的\ ``channel``\ 数量。
- ``pooling_type``\ : 接收\ ``avg``\ 和\ ``max``\ 2种类型之一作为pooling的方式，默认值为\ ``max``\ 。其中\ ``max``\ 意为最大池化，即计算池化\ ``filter``\ 区域内的数据的最大值作为输出；而\ ``avg``\ 意为平均池化，即计算池化\ ``filter``\ 区域内的数据的平均值作为输出。
- ``pool_stride``\ : 意为池化的\ ``filter``\ 在输入特征图上移动的步长。
- ``pool_padding``\ : 用来确定池化中\ ``padding``\ 的大小，\ ``padding``\ 的使用是为了对于特征图边缘的特征进行池化，选择不同的\ ``pool_padding``\ 大小确定了在特征图边缘增加多大区域的补零。从而决定边缘特征被池化的程度。
- ``global_pooling``\ : 意为是否使用全局池化，全局池化是指使用和特征图大小相同的\ ``filter``\ 来进行池化，同样这个过程也可以使用平均池化或者最大池化来做为池化的方式，全局池化通常会用来替换全连接层以大量减少参数防止过拟合。
- ``use_cudnn``\ : 选项可以来选择是否使用cudnn来优化计算池化速度。
- ``ceil_mode``\ : 是否使用ceil函数计算输出高度和宽度。\ ``ceil mode``\ 意为天花板模式，是指会把特征图中不足\ ``filter size``\ 的边给保留下来，单独另算，或者也可以理解为在原来的数据上补充了值为-NAN的边。而floor模式则是直接把不足\ ``filter size``\ 的边给舍弃了。具体计算公式如下：
- 非\ ``ceil_mode``\ 下:\ ``输出大小 = (输入大小 - filter size + 2 * padding) / stride（步长） + 1``
- ``ceil_mode``\ 下:\ ``输出大小 = (输入大小 - filter size + 2 * padding + stride - 1) / stride + 1``
api汇总：
- :ref:`api_fluid_layers_pool2d`
- :ref:`api_fluid_layers_pool3d`
2. roi_pool
------------------
``roi_pool``\ 一般用于检测网络中，将输入特征图依据候选框池化到特定的大小。
- ``rois``\ : 接收\ ``LoDTensor``\ 类型来表示需要池化的 Regions of Interest，关于RoI的解释请参考\ `论文 <https://arxiv.org/abs/1506.01497>`__
- ``pooled_height`` 和 ``pooled_width``\ : 这里可以接受非正方的池化窗口大小
- ``spatial_scale``\ : 用作设定缩放RoI和原图缩放的比例，注意，这里的设定需要用户自行计算RoI和原图的实际缩放比例。
api汇总：
- :ref:`api_fluid_layers_roi_pool`
3. sequence_pool
--------------------
``sequence_pool``\ 是一个用作对于不等长序列进行池化的接口，它将每一个实例的全部时间步的特征进行池化，它同样支持
``average``, ``sum``, ``sqrt`` 和\ ``max``\ 4种类型之一作为pooling的方式。 其中:
- ``average``\ 是对于每一个时间步内的数据求和后分别取平均值做为池化的结果。
- ``sum``\ 则是对每一个时间步内的数据分别求和作为池化的结果。
- ``sqrt``\ 则是对每一个时间步内的数据分别求和再分别取平方根作为池化的结果。
- ``max``\ 则是对每一个时间步内的数据分别求取最大值作为池化的结果。
api汇总：
- :ref:`api_fluid_layers_sequence_pool`
\ No newline at end of file
doc/fluid/api_cn/api_guides/low_level/layers/sequence.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_sequence:
########
序列
########
在深度学习领域许多问题涉及到对 `序列（sequence） <https://en.wikipedia.org/wiki/Sequence>`_ 的处理。
从Wiki上的释义可知，序列可以表征多种物理意义，但在深度学习中，最常见的仍然是"时间序列"——一个序列包含多个时间步的信息。
在Paddle Fluid中，我们将序列表示为 :ref:`api_fluid_LoDTensor` 。
因为一般进行神经网络计算时都是一个batch一个batch地计算，所以我们用一个LoDTensor来存储一个mini batch的序列。
一个LoDTensor的第0维包含该mini batch中所有序列的所有时间步，并且用LoD来记录各个序列的长度，区分不同序列。
而在运算时，还需要根据LoD信息将LoDTensor中一个mini batch的第0维拆开成多个序列。（具体请参考上述LoD相关的文档。）
所以，对这类LoDTensor第0维的操作不能简单地使用一般的layer来进行，针对这一维的操作必须要结合LoD的信息。
(例如，你不能用 :code:`layers.reshape` 来对一个序列的第0维进行reshape)。
为了实行各类针对序列的操作，我们设计了一系列序列相关的API，专门用于正确处理序列相关的操作。
实践中，由于一个LoDTensor包括一个mini batch的序列，同一个mini batch中不同的序列通常属于多个sample，它们彼此之间不会也不应该发生相互作用。
因此，若一个layer以两个（或多个）LoDTensor为输入（或者以一个list的LoDTensor为输入），每一个LoDTensor代表一个mini batch的序列，则第一个LoDTensor中的第一个序列只会和第二个LoDTensor中的第一个序列发生计算，
第一个LoDTensor中的第二个序列只会和第二个LoDTensor中的第二个序列发生计算，第一个LoDTensor中的第i个序列只会和第二个LoDTensor中第i个序列发生计算，依此类推。
**总而言之，一个LoDTensor存储一个mini batch的多个序列，其中的序列个数为batch size；多个LoDTensor间发生计算时，每个LoDTensor中的第i个序列只会和其他LoDTensor中第i个序列发生计算。理解这一点对于理解接下来序列相关的操作会至关重要。**
1. sequence_softmax
-------------------
这个layer以一个mini batch的序列为输入，在每个序列内做softmax操作。其输出为一个mini batch相同shape的序列，但在序列内是经softmax归一化过的。
这个layer往往用于在每个sequence内做softmax归一化。
API Reference 请参考 :ref:`api_fluid_layers_sequence_softmax`
2. sequence_concat
------------------
这个layer以一个list为输入，该list中可以含有多个LoDTensor，每个LoDTensor为一个mini batch的序列。
该layer会将每个batch中第i个序列在时间维度上拼接成一个新序列，作为返回的batch中的第i个序列。
理所当然地，list中每个LoDTensor的序列必须有相同的batch size。
API Reference 请参考 :ref:`api_fluid_layers_sequence_concat`
3. sequence_first_step
----------------------
这个layer以一个LoDTensor作为输入，会取出每个序列中的第一个元素（即第一个时间步的元素），并作为返回值。
API Reference 请参考 :ref:`api_fluid_layers_sequence_first_step`
4. sequence_last_step
---------------------
同 :code:`sequence_first_step` ，除了本layer是取每个序列中最后一个元素（即最后一个时间步）作为返回值。
API Reference 请参考 :ref:`api_fluid_layers_sequence_last_step`
5. sequence_expand
------------------
这个layer有两个LoDTensor的序列作为输入，并按照第二个LoDTensor中序列的LoD信息来扩展第一个batch中的序列。
通常用来将只有一个时间步的序列（例如 :code:`sequence_first_step` 的返回结果）延展成有多个时间步的序列，以此方便与有多个时间步的序列进行运算。
API Reference 请参考 :ref:`api_fluid_layers_sequence_expand`
6. sequence_expand_as
---------------------
这个layer需要两个LoDTensor的序列作为输入，然后将第一个Tensor序列中的每一个序列延展成和第二个Tensor中对应序列等长的序列。
不同于 :code:`sequence_expand` ，这个layer会将第一个LoDTensor中的序列严格延展为和第二个LoDTensor中的序列等长。
如果无法延展成等长的（例如第二个batch中的序列长度不是第一个batch中序列长度的整数倍），则会报错。
API Reference 请参考 :ref:`api_fluid_layers_sequence_expand_as`
7. sequence_enumerate
---------------------
这个layer需要一个LoDTensor的序列作为输入，同时需要指定一个 :code:`win_size` 的长度。这个layer将依次取所有序列中长度为 :code:`win_size` 的子序列，并组合成新的序列。
API Reference 请参考 :ref:`api_fluid_layers_sequence_enumerate`
8. sequence_reshape
-------------------
这个layer需要一个LoDTensor的序列作为输入，同时需要指定一个 :code:`new_dim` 作为新的序列的维度。
该layer会将mini batch内每个序列reshape为new_dim给定的维度。注意，每个序列的长度会改变（因此LoD信息也会变），以适应新的形状。
API Reference 请参考 :ref:`api_fluid_layers_sequence_reshape`
9. sequence_scatter
-------------------
这个layer可以将一个序列的数据scatter到另一个tensor上。这个layer有三个input，一个要被scatter的目标tensor :code:`input`；
一个是序列的数据 :code:`update` ，一个是目标tensor的上坐标 :code:`index` 。Output为scatter后的tensor，形状和 :code:`input` 相同。
API Reference 请参考 :ref:`api_fluid_layers_sequence_scatter`
10. sequence_pad
----------------
这个layer可以将不等长的序列补齐成等长序列。使用这个layer需要提供一个 :code:`PadValue` 和一个 :code:`padded_length`。
前者是用来补齐序列的元素，可以是一个数也可以是一个tensor；后者是序列补齐的目标长度。
这个layer会返回补齐后的序列，以及一个记录补齐前各个序列长度的tensor :code:`Length`。
API Reference 请参考 :ref:`api_fluid_layers_sequence_pad`
11. sequence_mask
-----------------
这个layer会根据 :code:`input` 生成一个mask，:code:`input` 是一个记录了每个序列长度的tensor。
此外这个layer还需要一个参数 :code:`maxlen` 用于指定序列中最长的序列长度。
通常这个layer用于生成一个mask，将被pad后的序列中pad的部分过滤掉。
:code:`input` 的长度tensor通常可以直接用 :code:`sequence_pad` 返回的 :code:`Length`。
API Reference 请参考 :ref:`api_fluid_layers_sequence_mask`
doc/fluid/api_cn/api_guides/low_level/layers/sparse_update.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_sparse_update:
#####
稀疏更新
#####
Fluid的 :ref:`api_fluid_layers_embedding` 层在单机训练和分布式训练时，均可以支持“稀疏更新”，即梯度以sparse tensor 结构存储，只保存梯度不为0的行。
在分布式训练中，对于较大的embedding层，开启稀疏更新有助于减少通信数据量，提升训练速度。
在paddle内部，我们用lookup_table来实现embedding。下边这张图说明了embedding在正向和反向计算的过程：
如图所示：一个Tensor中有两行不为0，正向计算的过程中，我们使用ids存储不为0的行，并使用对应的两行数据来进行计算；反向更新的过程也只更新这两行。
.. image:: ../../../../images/lookup_table_training.png
:scale: 50 %
embedding使用例子:
---------------------
API详细使用方法参考 :ref:`api_fluid_layers_embedding` ，以下是一个简单的例子：
.. code-block:: python
DICT_SIZE = 10000 * 10
EMBED_SIZE = 64
IS_SPARSE = False
def word_emb(word, dict_size=DICT_SIZE, embed_size=EMBED_SIZE):
embed = fluid.layers.embedding(
input=word,
size=[dict_size, embed_size],
dtype='float32',
param_attr=fluid.ParamAttr(
initializer=fluid.initializer.Normal(scale=1/math.sqrt(dict_size))),
is_sparse=IS_SPARSE,
is_distributed=False)
return embed
以上参数中：
- :code:`is_sparse` ： 反向计算的时候梯度是否为sparse tensor。如果不设置，梯度是一个 `LodTensor <https://github.com/PaddlePaddle/FluidDoc/blob/develop/doc/fluid/user_guides/howto/prepare_data/lod_tensor.md>`_ 。默认为False。
- :code:`is_distributed` ： 标志是否是用在分布式的场景下。一般大规模稀疏更新（embedding的第0维维度很大，比如几百万以上）才需要设置。具体可以参考大规模稀疏的API guide :ref:`api_guide_async_training` 。默认为False。
- API汇总:
- :ref:`api_fluid_layers_embedding`
doc/fluid/api_cn/api_guides/low_level/layers/tensor.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_tensor:
########
张量
########
Fluid 中使用两种数据结构来承载数据，分别是 `Tensor 和 LoD_Tensor <../../../../user_guides/howto/prepare_data/lod_tensor.html>`_ 。 其中 LoD-Tensor 是 Fluid 的特有概念，它在 Tensor 基础上附加了序列信息。框架中可传输的数据包括：输入、输出、网络中的可学习参数，全部统一使用 LoD-Tensor 表示，Tensor 可以看作是一种特殊的 LoD-Tensor。
下面介绍这两种数据的相关操作。
Tensor
=======
1. create_tensor
---------------------
Tensor用于在框架中承载数据，使用 :code:`create_tensor` 可以创建一个指定数据类型的Lod-Tensor变量，
API reference 请参考： :ref:`api_fluid_layers_create_tensor`
2. create_parameter
---------------------
神经网络的训练过程是一个对参数的学习过程，Fluid 使用 :code:`create_parameter` 创建一个可学习的参数。该参数的值可以被operator改变。
API reference 请参考：:ref:`api_fluid_layers_create_parameter`
3. create_global_var
---------------------
Fluid 使用 :code:`create_global_var` 创建一个全局tensor，通过此 API 可以指定被创建 Tensor 变量的数据类型、形状和值。
API reference 请参考：:ref:`api_fluid_layers_create_global_var`
4. cast
---------------
Fluid 使用 :code:`cast` 将数据转换为指定类型。
API reference 请参考：:ref:`api_fluid_layers_cast`
5. concat
----------------
Fluid 使用 :code:`concat` 将输入数据沿指定维度连接。
API reference 请参考：:ref:`api_fluid_layers_concat`
6. sums
----------------
Fluid 使用 :code:`sums` 执行对输入数据的加和。
API reference 请参考：:ref:`api_fluid_layers_sums`
7. fill_constant_batch_size_like
---------------------------------
Fluid 使用 :code:`fill_constant_batch_size_like` 创建一个具有特定形状、类型和 batch_size 的 Tensor。并且该Tensor的初始值可以被指定为任意常数。其中 batch_size 信息由该tensor的 :code:`input_dim_idx` 和 :code:`output_dim_idx` 确定。
API reference 请参考：:ref:`api_fluid_layers_fill_constant_batch_size_like`
8. fill_constant
-----------------
Fluid 使用 :code:`fill_constant` 创建一个具有特定形状和类型的 Tensor。可以通过 :code:`value` 设置该变量的初始值。
API reference 请参考： :ref:`api_fluid_layers_fill_constant`
9. assign
---------------
Fluid 使用 :code:`assign` 复制一个变量。
API reference 请参考：:ref:`api_fluid_layers_assign`
10. argmin
--------------
Fluid 使用 :code:`argmin` 计算输入 Tensor 指定轴上最小元素的索引。
API reference 请参考：:ref:`api_fluid_layers_assign`
11. argmax
-----------
Fluid 使用 :code:`argmax` 计算输入 Tensor 指定轴上最大元素的索引。
API reference 请参考：:ref:`api_fluid_layers_argmax`
12. argsort
------------
Fluid 使用 :code:`argsort` 对输入 Tensor 在指定轴上进行排序，并返回排序后的数据变量及其对应的索引值。
API reference 请参考： :ref:`api_fluid_layers_argsort`
13. ones
-------------
Fluid 使用 :code:`ones` 创建一个指定大小和数据类型的Tensor，且初始值为1。
API reference 请参考： :ref:`api_fluid_layers_ones`
14. zeros
---------------
Fluid 使用 :code:`zeros` 创建一个指定大小和数据类型的Tensor，且初始值为0。
API reference 请参考： :ref:`api_fluid_layers_zeros`
15. reverse
-------------------
Fluid 使用 :code:`reverse` 沿指定轴反转 Tensor。
API reference 请参考： :ref:`api_fluid_layers_reverse`
LoD-Tensor
============
LoD-Tensor非常适用于序列数据，相关知识可以参考阅读 `LoD_Tensor <../../../../user_guides/howto/prepare_data/lod_tensor.html>`_ 。
1. create_lod_tensor
-----------------------
Fluid 使用 :code:`create_lod_tensor` 基于numpy数组、列表或现有 LoD_Tensor 创建拥有新的层级信息的 LoD_Tensor。
API reference 请参考： :ref:`api_fluid_create_lod_tensor`
2. create_random_int_lodtensor
----------------------------------
Fluid 使用 :code:`create_random_int_lodtensor` 创建一个由随机整数组成的 LoD_Tensor。
API reference 请参考： :ref:`api_fluid_create_random_int_lodtensor`
3. reorder_lod_tensor_by_rank
---------------------------------
Fluid 使用 :code:`reorder_lod_tensor_by_rank` 对输入 LoD_Tensor 的序列信息按指定顺序重拍。
API reference 请参考：:ref:`api_fluid_layers_reorder_lod_tensor_by_rank`
\ No newline at end of file
doc/fluid/api_cn/api_guides/low_level/memory_optimize.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_memory_optimize:
#####
显存优化
#####
显存优化是通过分析、复用 :code:`Program` 中 :code:`Varaible` 使用的显存，从而降低 :code:`Program` 执行时显存消耗的方法。用户可以通过Python脚本调用 :code:`memory_optimize` 接口进行显存优化，显存优化的执行策略如下：
- 首先根据 :code:`Program` 中 :code:`Operator` 之间的关系对 :code:`Variable` 的最后存活时间进行分析，得到每个 :code:`Variable` 的最后存活时间;
- 其次根据每个 :code:`Variable` 的最后存活时间，我们将到达存活时间、不再存活的 :code:`Variable` 所占用的显存提供给后来的 :code:`Variable` 使用。
.. code-block:: python
z = fluid.layers.sum([x, y])
m = fluid.layers.matmul(y, z)
在这个示例中，:code:`x` 的存活时间到 :code:`fluid.layers.sum` 操作为止，所以它的显存可以被 :code:`m` 复用。
针对特定部分禁用显存优化
===========
:code:`memory_optimize` 支持针对特定部分禁用显存优化，用户可以通过传入 :code:`Variable` 名字的集合来指定哪些 :code:`Variable` 所使用的显存不会被复用;
与此同时，:code:`memory_optimize` 能够针对网络的反向部分禁用显存优化，用户可以通过传入 :code:`skip_grads` 参数来开启这个功能。
.. code-block:: python
fluid.memory_optimize(fluid.default_main_program(),
skip_opt_set=("fc"), skip_grads=True)
在这个示例中，:code:`fluid.memory_optimize` 接口对默认的 :code:`Program` 进行了 :code:`Variable` 最后存活时间的分析，并跳过了名字为 :code:`fc` 的 :code:`Variable` 以及网络反向部分的所有 :code:`Variable` 。
这部分 :code:`Variable` 的显存都不会被别的 :code:`Varaible` 再次使用。
指定显存优化等级
===========
:code:`memory_optimize` 支持打印显存复用的信息以方便用户进行调试，用户可以通过指定 :code:`print_log=True` 来开启显存复用的调试信息;
:code:`memory_optimize` 支持两种显存优化的等级，:code:`0` 或者 :code:`1` :
- 优化等级为 :code:`0` 时： :code:`memory_optimize` 在分析完 :code:`Variable` 的最后生存时间后，会判断 :code:`Variable` 的 :code:`shape` ，只有 :code:`shape` 相同的 :code:`Variable` 才会进行显存复用；
- 优化等级为 :code:`1` 时： :code:`memory_optimize` 会尽可能地进行显存复用，在分析完 :code:`Variable` 的最后生存时间后，即使是 :code:`shape` 不同的 :code:`Variable` 也会进行最大程度的显存复用。
.. code-block:: python
fluid.memory_optimize(fluid.default_main_program(),
level=0, print_log=True)
在这个示例中，:code:`fluid.memory_optimize` 接口对默认的 :code:`Program` 进行了 :code:`Variable` 最后存活时间的分析。
只有 :code:`shape` 完全相同的 :code:`Variable` 才会进行显存复用，并且在分析结束后，会打印出所有显存复用相关的调试信息。
doc/fluid/api_cn/api_guides/low_level/metrics.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_metrics:
评价指标
#########
在神经网络训练过程中或者训练完成后，需要评价模型的训练效果。评价的方法一般是计算全体预测值和全体真值(label)之间的距离，不同类型的任务会使用不同的评价方法，或者综合使用多个评价方法。在具体的任务中，可以选用一种或者多种评价方法。下面对常用的评价方法按照任务类型做介绍。
分类任务评价
------------------
分类任务中最常用的是二分类，而多分类任务也可以转化为多个二分类任务的组合，二分类任务常用的评价指标有准确率、正确率、召回率、AUC和平均准确度。
- 准确率: :code:`Precision` ，用来衡量二分类中召回真值和召回值的比例。
API Reference 请参考 :ref:`api_fluid_metrics_Precision`
- 正确率: :code:`Accuracy` ，用来衡量二分类中召回真值和总样本数的比例。需要注意的是，准确率和正确率的定义是不同的，可以类比于误差分析中的 :code:`Variance` 和 :code:`Bias` 。
API Reference 请参考 :ref:`api_fluid_metrics_Accuracy`
- 召回率: :code:`Recall` ，用来衡量二分类中召回值和总样本数的比例。准确率和召回率的选取相互制约，实际模型中需要进行权衡，可以参考文档 `Precision_and_recall <https://en.wikipedia.org/wiki/Precision_and_recall>`_ 。
API Reference 请参考 :ref:`api_fluid_metrics_Recall`
- AUC: :code:`Area Under Curve`， 适用于二分类的分类模型评估，用来计算 `ROC曲线的累积面积 <https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve>`_。:code:`Auc` 通过python计算实现，如果关注性能，可以使用 :code:`fluid.layers.auc` 代替。
API Reference 请参考 :ref:`api_fluid_metrics_Auc`
- 平均准确度: :code:`Average Precision` ，常用在Faster R-CNN和SSD等物体检测任务中。在不同召回条件下，计算了准确率的平均值，具体可以参考文档 `Average-precision <https://sanchom.wordpress.com/tag/average-precision/>`_ 和 `SSD: Single Shot MultiBox Detector <https://arxiv.org/abs/1512.02325>`_。
API Reference 请参考 :ref:`api_fluid_metrics_DetectionMAP`
序列标注任务评价
------------------
序列标注任务中，token的分组称为语块(chunk)，模型会同时将输入的token分组和分类，常用的评估方法是语块评估方法。
- 语块评估方法: :code:`ChunkEvaluator` ，接收 :code:`chunk_eval` 接口的输出，累积每一个minibatch的语块统计值，最后计算准确率、召回率和F1值。:code:`ChunkEvaluator` 支持IOB, IOE, IOBES和IO四种标注模式。可以参考文档 `Chunking with Support Vector Machines <https://aclanthology.info/pdf/N/N01/N01-1025.pdf>`_ 。
API Reference 请参考 :ref:`api_fluid_metrics_ChunkEvaluator`
生成任务评价
------------------
生成任务会依据输入直接产生输出。对应NLP任务中(比如语音识别)，则生成新字符串。评估生成字符串和目标字符串之间距离的方法也有多种，比如多分类评估方法，而另外一种常用的方法叫做编辑距离。
- 编辑距离: :code:`EditDistance` ，用来衡量两个字符串的相似度。可以参考文档 `Edit_distance <https://en.wikipedia.org/wiki/Edit_distance>`_。
API Reference 请参考 :ref:`api_fluid_metrics_EditDistance`
doc/fluid/api_cn/api_guides/low_level/model_save_reader.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_model_save_reader:
#########
模型保存与加载
#########
模型的保存与加载主要涉及到如下八个API：
:code:`fluid.io.save_vars`、:code:`fluid.io.save_params`、:code:`fluid.io.save_persistables`、:code:`fluid.io.save_inference_model`、:code:`fluid.io.load_vars`、:code:`fluid.io.load_params`、:code:`fluid.io.load_persistables` 和 :code:`fluid.io.load_inference_model`。
变量、持久性变量和参数
====================
在 :code:`Paddle` 中，算子(:code:`Operator`)的每一个输入和输出都是一个变量（:code:`Variable`），而参数（:code:`Parameter`）是变量（:code:`Variable`）的子类。持久性变量（:code:`Persistables`）是一种在每次迭代结束后均不会被删除的变量。参数是一种持久性变量，其在每次迭代后都会被优化器（:ref:`api_guide_optimizer`）更新。训练神经网络本质上就是在更新参数。
模型保存API介绍
====================
- :code:`fluid.io.save_vars`：通过执行器（:ref:`api_guide_executor`）保存变量到指定的目录中。保存变量的方式有两种：
1）通过接口中的 :code:`vars` 指定需要保存的变量列表。
2）将一个已经存在的程序（:code:`Program`）赋值给接口中的 :code:`main_program`，然后这个程序中的所有变量都将被保存下来。
第一种保存方式的优先级要高于第二种。
API Reference 请参考 :ref:`api_fluid_io_save_vars`。
- :code:`fluid.io.save_params`：通过接口中的 :code:`main_program` 指定好程序（:code:`Program`），该接口会将所指定程序中的全部参数（:code:`Parameter`）过滤出来，并将它们保存到 :code:`dirname` 指定的文件夹或 :code:`filename` 指定的文件中。
API Reference 请参考 :ref:`api_fluid_io_save_params`。
- :code:`fluid.io.save_persistables`：通过接口中的 :code:`main_program` 指定好程序（:code:`Program`），该接口会将所指定程序中的全部持久性变量（:code:`persistable==True`）过滤出来，并将它们保存到 :code:`dirname` 指定的文件夹或 :code:`filename` 指定的文件中。
API Reference 请参考 :ref:`api_fluid_io_save_persistables`。
- :code:`fluid.io.save_inference_model`：请参考 :ref:`api_guide_inference`。
模型加载API介绍
====================
- :code:`fluid.io.load_vars`：通过执行器（:code:`Executor`）加载指定目录中的变量。加载变量的方式有两种：
1）通过接口中的 :code:`vars` 指定需要加载的变量列表。
2）将一个已经存在的程序（:code:`Program`）赋值给接口中的 :code:`main_program`，然后这个程序中的所有变量都将被加载。
第一种加载方式的优先级要高于第二种。
API Reference 请参考 :ref:`api_fluid_io_load_vars`。
- :code:`fluid.io.load_params`：该接口从 :code:`main_program` 指定的程序中过滤出全部参数（:code:`Parameter`），并试图从 :code:`dirname` 指定的文件夹或 :code:`filename` 指定的文件中加载这些参数。
API Reference 请参考 :ref:`api_fluid_io_load_params`。
- :code:`fluid.io.load_persistables`：该接口从 :code:`main_program` 指定的程序中过滤出全部持久性变量（:code:`persistable==True`），并试图从 :code:`dirname` 指定的文件夹或 :code:`filename` 指定的文件中加载这些持久性变量。
API Reference 请参考 :ref:`api_fluid_io_load_persistables`。
- :code:`fluid.io.load_inference_model`：请参考 :ref:`api_guide_inference`。
doc/fluid/api_cn/api_guides/low_level/nets.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_nets:
###########
复杂网络
###########
在处理复杂功能时，我们通常需要写大量的代码来构建复杂的 `神经网络 <https://zh.wikipedia.org/wiki/人工神经网络>`_ 。
因此，为了方便用户更加容易地搭建复杂网络模型，我们提供了一些比较常用的基本函数模块，以此来简化用户的代码量，从而降低开发成本。
这些模块通常是由细粒度的函数根据一定的逻辑拼接组合而成，实现代码请参考 `nets.py <https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/fluid/nets.py>`_ 。
1.simple_img_conv_pool
----------------------
:code:`simple_img_conv_pool` 是由 :ref:`api_fluid_layers_conv2d` 与 :ref:`api_fluid_layers_pool2d` 串联而成。
该模块在图像分类模型中广泛使用，比如应用在 `MNIST <https://en.wikipedia.org/wiki/MNIST_database>`_ 数字分类的问题。
API Reference 请参考 :ref:`api_fluid_nets_simple_img_conv_pool`
2.img_conv_group
----------------
:code:`img_conv_group` 是由 :ref:`api_fluid_layers_conv2d` , :ref:`api_fluid_layers_batch_norm`, :ref:`api_fluid_layers_dropout` 和 :ref:`api_fluid_layers_pool2d` 组成。
该模块可以实现多个 :ref:`api_fluid_layers_conv2d` , :ref:`api_fluid_layers_batch_norm` 和 :ref:`api_fluid_layers_dropout` 的串联单元与一个 :ref:`api_fluid_layers_pool2d` 的组合。
其中， :ref:`api_fluid_layers_conv2d` , :ref:`api_fluid_layers_batch_norm` 和 :ref:`api_fluid_layers_dropout` 的数量都可以分别控制，从而得到多样的组合。
该模块广泛使用在比较复杂的图像分类任务中，比如 `VGG <https://arxiv.org/pdf/1409.1556.pdf>`_ 。
API Reference 请参考 :ref:`api_fluid_nets_img_conv_group`
3.sequence_conv_pool
--------------------
:code:`sequence_conv_pool` 是由 :ref:`api_fluid_layers_sequence_conv` 与 :ref:`api_fluid_layers_sequence_pool` 串联而成。
该模块在 `自然语言处理 <https://zh.wikipedia.org/wiki/自然语言处理>`_ 以及 `语音识别 <https://zh.wikipedia.org/wiki/语音识别>`_ 等领域均有广泛应用，
比如 `文本分类模型 <https://github.com/PaddlePaddle/models/blob/develop/fluid/PaddleNLP/text_classification/nets.py>`_ ,
`TagSpace <https://github.com/PaddlePaddle/models/blob/develop/fluid/PaddleRec/tagspace/train.py>`_ 以及 `Multi-view Simnet <https://github.com/PaddlePaddle/models/blob/develop/fluid/PaddleRec/multiview_simnet/nets.py>`_ 等模型。
API Reference 请参考 :ref:`api_fluid_nets_sequence_conv_pool`
4.glu
-----
:code:`glu` 全称 Gated Linear Units， 来源于论文 `Language Modeling with Gated Convolutional Networks <https://arxiv.org/pdf/1612.08083.pdf>`_ ，由 :ref:`api_fluid_layers_split` ， :ref:`api_fluid_layers_sigmoid` 和 :ref:`api_fluid_layers_elementwise_mul` 组成。
它会把输入数据均分为2等份，并对第二部分求 `Sigmoid <https://en.wikipedia.org/wiki/Sigmoid_function>`_ , 然后再与第一部分数据求点乘得到输出。
API Reference 请参考 :ref:`api_fluid_nets_glu`
5.scaled_dot_product_attention
------------------------------
:code:`scaled_dot_product_attention` 来源于论文 `Attention Is All You Need <https://arxiv.org/pdf/1706.03762.pdf>`_ ，主要是由 :ref:`api_fluid_layers_fc` 和 :ref:`api_fluid_layers_softmax` 组成。
对于输入数据 :code:`Queries` , :code:`Key` 和 :code:`Values` 按照如下公式求出 :code:`Attention` 。
.. math::
Attention(Q, K, V)= softmax(QK^\mathrm{T})V
该模块广泛使用在 `机器翻译 <https://zh.wikipedia.org/zh/机器翻译>`_ 的模型中，比如 `Transformer <https://github.com/PaddlePaddle/models/tree/develop/fluid/PaddleNLP/neural_machine_translation/transformer>`_ 。
API Reference 请参考 :ref:`api_fluid_nets_scaled_dot_product_attention`
doc/fluid/api_cn/api_guides/low_level/optimizer.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_optimizer:
###########
优化器
###########
神经网络最终是一个 `最优化问题 <https://en.wikipedia.org/wiki/Optimization_problem>`_ ，
在经过 `前向计算和反向传播 <https://zh.wikipedia.org/zh-hans/反向传播算法>`_ 后，
:code:`Optimizer` 使用反向传播梯度，优化神经网络中的参数。
1.SGD/SGDOptimizer
------------------
:code:`SGD` 是实现 `随机梯度下降 <https://arxiv.org/pdf/1609.04747.pdf>`_ 的一个 :code:`Optimizer` 子类，是 `梯度下降 <https://zh.wikipedia.org/zh-hans/梯度下降法>`_ 大类中的一种方法。
当需要训练大量样本的时候，往往选择 :code:`SGD` 来使损失函数更快的收敛。
API Reference 请参考 :ref:`api_fluid_optimizer_SGDOptimizer`
2.Momentum/MomentumOptimizer
----------------------------
:code:`Momentum` 优化器在 :code:`SGD` 基础上引入动量，减少了随机梯度下降过程中存在的噪声问题。
用户在使用时可以将 :code:`ues_nesterov` 参数设置为False或True，分别对应传统 `Momentum(论文4.1节)
<https://arxiv.org/pdf/1609.04747.pdf>`_ 算法和 `Nesterov accelerated gradient(论文4.2节)
<https://arxiv.org/pdf/1609.04747.pdf>`_ 算法。
API Reference 请参考 :ref:`api_fluid_optimizer_MomentumOptimizer`
3. Adagrad/AdagradOptimizer
---------------------------
`Adagrad <http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf>`_ 优化器可以针对不同参数样本数不平均的问题，自适应地为各个参数分配不同的学习率。
API Reference 请参考 :ref:`api_fluid_optimizer_AdagradOptimizer`
4.RMSPropOptimizer
------------------
`RMSProp优化器 <http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf>`_ ，是一种自适应调整学习率的方法，
主要解决使用Adagrad后，模型训练中后期学习率急剧下降的问题。
API Reference 请参考 :ref:`api_fluid_optimizer_RMSPropOptimizer`
5.Adam/AdamOptimizer
--------------------
`Adam <https://arxiv.org/abs/1412.6980>`_ 的优化器是一种自适应调整学习率的方法，
适用于大多非 `凸优化 <https://zh.wikipedia.org/zh/凸優化>`_ 、大数据集和高维空间的场景。在实际应用中，:code:`Adam` 是最为常用的一种优化方法。
API Reference 请参考 :ref:`api_fluid_optimizer_AdamOptimizer`
6.Adamax/AdamaxOptimizer
------------------------
`Adamax <https://arxiv.org/abs/1412.6980>`_ 是 :code:`Adam` 算法的一个变体，对学习率的上限提供了一个更简单的范围，使学习率的边界范围更简单。
API Reference 请参考 :ref:`api_fluid_optimizer_AdamaxOptimizer`
7.DecayedAdagrad/ DecayedAdagradOptimizer
-------------------------------------------
`DecayedAdagrad <http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf>`_ 优化器，可以看做是引入了衰减速率的 :code:`Adagrad` 算法，解决使用Adagrad后，模型训练中后期学习率急剧下降的问题。
API Reference 请参考 :ref:`api_fluid_optimizer_DecayedAdagrad`
8. Ftrl/FtrlOptimizer
----------------------
`FtrlOptimizer <https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf>`_ 优化器结合了 `FOBOS算法 <https://stanford.edu/~jduchi/projects/DuchiSi09b.pdf>`_ 的高精度与 `RDA算法
<http://www1.se.cuhk.edu.hk/~sqma/SEEM5121_Spring2015/dual-averaging.pdf>`_ 的稀疏性，是目前效果非常好的一种 `Online Learning <https://en.wikipedia.org/wiki/Online_machine_learning>`_ 算法。
API Reference 请参考 :ref:`api_fluid_optimizer_FtrlOptimizer`
9.ModelAverage
-----------------
:code:`ModelAverage` 优化器，在训练中通过窗口来累计历史 parameter，在预测时使用取平均值后的paramet，整体提高预测的精度。
API Reference 请参考 :ref:`api_fluid_optimizer_ModelAverage`
doc/fluid/api_cn/api_guides/low_level/parallel_executor.rst 0 → 100644
浏览文件 @ cb4f4929
.. _api_guide_parallel_executor:
#####
数据并行执行引擎
#####
:code:`ParallelExecutor` 是以数据并行的方式在多个节点上分别执行 :code:`Program` 的执行器。用户可以通过Python脚本驱动 :code:`ParallelExecutor` 执行， :code:`ParallelExecutor` 的执行过程：
- 首先根据 :code:`Program` 、 :code:`GPU` 卡的数目（或者 :code:`CPU` 的核数）以及 :ref:`api_fluid_BuildStrategy` 构建 :code:`SSA Graph` 和一个线程池;
- 执行过程中，根据Op的输入是否Ready决定是否执行该Op，这样可以使没有相互依赖的多个Op可在线程池中并行执行；
:code:`ParallelExecutor` 在构造时需要指定当前 :code:`Program` 的设备类型， :code:`GPU` 或者 :code:`CPU` ：
* 使用 :code:`GPU` 执行： :code:`ParallelExecutor` 会自动检测当前机器可以使用 :code:`GPU` 的个数，并在每个 :code:`GPU` 上分别执行 :code:`Program` ，用户也可以通过设置 :code:`CUDA_VISIBLE_DEVICES` 环境变量来指定执行器可使用的 :code:`GPU` ；
* 使用 :code:`CPU` 多线程执行：:code:`ParallelExecutor` 会自动检测当前机器可利用的 :code:`CPU` 核数，并将 :code:`CPU` 核数作为执行器中线程的个数，每个线程分别执行 :code:`Program` ，用户也可以通过设置 :code:`CPU_NUM` 环境变量来指定当前训练使用的线程个数。
:code:`ParallelExecutor` 支持模型训练和模型预测：
* 模型训练： :code:`ParallelExecutor` 在执行过程中对多个节点上的参数梯度进行聚合，然后进行参数的更新；
* 模型预测： :code:`ParallelExecutor` 在执行过程中各个节点独立运行当前的 :code:`Program` ；
:code:`ParallelExecutor` 在模型训练时支持两种模式的梯度聚合, :code:`AllReduce` 和 :code:`Reduce` ：
* :code:`AllReduce` 模式下， :code:`ParallelExecutor` 调用AllReduce操作使多个节点上参数梯度完全相等，然后各个节点独立进行参数的更新；
* :code:`Reduce` 模式下， :code:`ParallelExecutor` 会预先将所有参数的更新分派到不同的节点上，在执行过程中 :code:`ParallelExecutor` 调用Reduce操作将参数梯度在预先指定的节点上进行聚合，并进行参数更新，最后调用Broadcast操作将更新后的参数发送到其他节点。
这两种模式通过 :code:`build_strategy` 来指定，使用方法，请参考 :ref:`api_fluid_BuildStrategy` 。
**注意** ：如果在Reduce模式下使用 :code:`CPU` 多线程执行 :code:`Program` ， :code:`Program` 的参数在多个线程间是共享的，在某些模型上，Reduce模式可以大幅节省内存。
由于模型的执行速度与模型结构和执行器的执行策略相关， :code:`ParallelExecutor` 允许用户修改执行器的相关参数，如：线程池大小（ :code:`num_threads` ）、多少次迭代之后清理一次临时变量 :code:`num_iteration_per_drop_scope` 等，更多信息请参考 :ref:`api_fluid_ExecutionStrategy` >。
- 相关API汇总:
- :ref:`api_fluid_ParallelExecutor`
- :ref:`api_fluid_BuildStrategy`
- :ref:`api_fluid_ExecutionStrategy`
\ No newline at end of file
doc/fluid/api_cn/api_guides/low_level/parameter.rst 0 → 100755
浏览文件 @ cb4f4929
.. _api_guide_parameter:
#########
模型参数
#########
模型参数为模型中的weight和bias统称，在fluid中对应fluid.Parameter类，继承自fluid.Variable，是一种可持久化的variable。模型的训练就是不断学习更新模型参数的过程。模型参数相关的属性可以通过 :ref:`api_fluid_param_attr_ParamAttr` 来配置，可配置内容有：
- 初始化方式
- 正则化
- 梯度剪切
- 模型平均
初始化方式
=================
fluid通过设置 :code:`ParamAttr` 的 :code:`initializer` 属性为单个parameter设置初始化方式。
示例如下：
.. code-block:: python
param_attrs = fluid.ParamAttr(name="fc_weight",
initializer=fluid.initializer.ConstantInitializer(1.0))
y_predict = fluid.layers.fc(input=x, size=10, param_attr=param_attrs)
以下为fluid支持的初始化方式：
1. BilinearInitializer
-----------------------
线性初始化方法。用该方法初始化的反卷积操作可当做线性插值操作使用。
可用别名：Bilinear
API请参考：:ref:`api_fluid_initializer_BilinearInitializer`
2. ConstantInitializer
----------------------
常数初始化方式，将parameter初始化为指定的数值。
可用别名：Constant
API请参考：:ref:`api_fluid_initializer_ConstantInitializer`
3. MSRAInitializer
------------------
该初始化方法参考论文: https://arxiv.org/abs/1502.01852
可用别名：MSRA
API请参考：:ref:`api_fluid_initializer_MSRAInitializer`
4. NormalInitializer
---------------------
随机高斯分布初始化方法。
可用别名：Normal
API请参考：:ref:`api_fluid_initializer_NormalInitializer`
5. TruncatedNormalInitializer
-----------------------------
随机截断高斯分布初始化方法。
可用别名：TruncatedNormal
API请参考：:ref:`api_fluid_initializer_TruncatedNormalInitializer`
6. UniformInitializer
--------------------
随机均匀分布初始化方式。
可用别名：Uniform
API请参考：:ref:`api_fluid_initializer_UniformInitializer`
7. XavierInitializer
--------------------
该初始化方式参考论文: http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf
可用别名：Xavier
API请参考：:ref:`api_fluid_initializer_XavierInitializer`
正则化方式
=============
fluid通过设置 :code:`ParamAttr` 的 :code:`regularizer` 属性为单个parameter设置正则化。
.. code-block:: python
param_attrs = fluid.ParamAttr(name="fc_weight",
regularizer=fluid.regularizer.L1DecayRegularizer(0.1))
y_predict = fluid.layers.fc(input=x, size=10, param_attr=param_attrs)
以下为fluid支持的正则化方式：
- :ref:`api_fluid_regularizer_L1DecayRegularizer` (别名：L1Decay)
- :ref:`api_fluid_regularizer_L2DecayRegularizer` (别名：L2Decay)
Clipping
==========
fluid通过设置 :code:`ParamAttr` 的 :code:`gradient_clip` 属性为单个parameter设置clipping方式。
.. code-block:: python
param_attrs = fluid.ParamAttr(name="fc_weight",
regularizer=fluid.regularizer.L1DecayRegularizer(0.1))
y_predict = fluid.layers.fc(input=x, size=10, param_attr=param_attrs)
以下为fluid支持的clipping方式：
1. ErrorClipByValue
-------------------
用来将一个tensor的值clipping到指定范围。
API请参考：:ref:`api_fluid_clip_ErrorClipByValue`
2. GradientClipByGlobalNorm
---------------------------
用来将多个Tensor的global-norm限制在 :code:`clip_norm` 以内。
API请参考：:ref:`api_fluid_clip_GradientClipByGlobalNorm`
3. GradientClipByNorm
---------------------
将Tensor的l2-norm限制在 :code:`max_norm` 以内。如果Tensor的l2-norm超过了 :code:`max_norm` ，
会将计算出一个 :code:`scale` ，该Tensor的所有值乘上计算出来的 :code:`scale` .
API请参考：:ref:`api_fluid_clip_GradientClipByNorm`
4. GradientClipByValue
----------------------
将parameter对应的gradient的值限制在[min, max]范围内。
API请参考：:ref:`api_fluid_clip_GradientClipByValue`
模型平均
========
fluid通过 :code:`ParamAttr` 的 :code:`do_model_average` 属性设置单个parameter是否进行平均优化。
示例如下：
.. code-block:: python
param_attrs = fluid.ParamAttr(name="fc_weight",
do_model_average=true)
y_predict = fluid.layers.fc(input=x, size=10, param_attr=param_attrs)
在miniBatch训练过程中，每个batch过后，都会更新一次parameters，模型平均做的就是平均最近k次更新产生的parameters。
平均后的parameters只是被用来进行测试和预测，其并不参与实际的训练过程。
具体API请参考：:ref:`api_fluid_optimizer_ModelAverage`
doc/fluid/api_cn/average_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#################
fluid.average
#################
.. _cn_api_fluid_average_WeightedAverage:
WeightedAverage
-------------------------------
.. py:class:: paddle.fluid.average.WeightedAverage
计算加权平均值。
平均计算完全通过Python完成。它们不会改变Paddle的程序，也不会修改NN模型的配置。它们完全是Python函数的包装器。
**示例代码**
.. code-block:: python
avg = fluid.average.WeightedAverage()
avg.add(value=2.0, weight=1)
avg.add(value=4.0, weight=2)
avg.eval()
# 结果为 3.333333333.
# 因为 (2.0 * 1 + 4.0 * 2) / (1 + 2) = 3.333333333
doc/fluid/api_cn/backward_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#################
fluid.backward
#################
.. _cn_api_fluid_backward_append_backward:
append_backward
-------------------------------
.. py:function:: paddle.fluid.backward.append_backward(loss, parameter_list=None, no_grad_set=None, callbacks=None)
将向 ``main_program`` 追加 ``backward`` 。
完整的神经网络训练由前向和反向传播组成。但是当我们配置网络时，我们只需要指定其前向部分。通过该功能，根据前向部分自动生成反向部分。
在大多数情况下，用户无需手动调用此功能。它将由优化程序的最小化函数自动调用。
参数：
- **loss** （Variable）- 网络的损失变量。
- **parameter_list** （list [string] | None）- 优化器需要更新的参数名称。如果为None，则将更新所有参数。默认值：None。
- **no_grad_set** （set | None）- ``block`` 0中变量的梯度应该被忽略。所有 ``block`` 中带有 ``step_gradient = True`` 的所有变量都将自动添加到此集合中。默认值：None。
- **callbacks** （list [callable object] | None）- 回调用于在反向传播构建中执行一些自定义作业。每次将新的梯度运算符添加到程序中时，将调用其中的所有可调用对象。可调用对象必须有两个输入参数： ``block`` 和 ``context`` 。 ``block`` 是将被添加到新梯度算子的块。 ``context`` 是一个映射，其键是梯度变量名，值是对应的原始变量。除此之外， ``context`` 还有另一个特殊的键值对：键是字符串 ``__ current_op_desc__`` ，值是刚刚触发可调用对象的梯度运算符的 ``op_desc`` 。
返回： 成对参数及其相应的梯度。键是参数，值是梯度变量。
返回类型： list[(Variable,Variable)]
抛出：
- ``AssertionError`` - 如果loss不是Variable的实例。
**示例代码**
.. code-block:: python
# 网络配置
# ...
avg_loss = fluid.layers.mean(loss)
param_grad_list = fluid.backward.append_backward(loss=avg_loss)
doc/fluid/api_cn/clip_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#################
fluid.clip
#################
.. _cn_api_fluid_clip_ErrorClipByValue:
ErrorClipByValue
-------------------------------
.. py:class:: paddle.fluid.clip.ErrorClipByValue(max, min=None)
将张量值的范围压缩到 [min, max]。
给定一个张量 ``t`` ，该操作将它的值压缩到 ``min`` 和 ``max`` 之间
- 任何小于最小值的值都被设置为最小值
- 任何大于max的值都被设置为max
参数:
- **max** (foat) - 要修剪的最大值。
- **min** (float) - 要修剪的最小值。如果用户没有设置，将被 ``framework`` 设置为 ``-max``
**代码示例**
.. code-block:: python
var = fluid.framework.Variable(..., error_clip=ErrorClipByValue(max=5.0), ...)
.. _cn_api_fluid_clip_GradientClipByGlobalNorm:
GradientClipByGlobalNorm
-------------------------------
.. py:class:: paddle.fluid.clip.GradientClipByGlobalNorm(clip_norm, group_name='default_group')
通过多个张量的范数之和的比率来剪切（clip）多个张量。
给定一个张量列表 :math:`t\_list` 和一个剪切比率 ``clip_norm`` ，返回一个被剪切的张量列表list_clipped和 :math:`t\_list` 中所有张量的全局范数(global_norm)。
剪切过程如下：
.. math::
\\t\_list[i]=t\_list[i]∗\frac{clip\_norm}{max(global\_norm,clip\_norm)}\\
其中：
.. math::
\\global\_norm=\sqrt{\sum_{i=0}^{n-1}(l2norm(t\_list[i]))^2}\\
如果 :math:`clip\_norm>global\_norm` ， :math:`t\_list` 中的张量保持不变，否则它们都会按照全局比率缩减。
参数:
- **clip_norm** (float) - 范数最大值
- **group_name** (str, optional) - 剪切的组名
**代码示例**
.. code-block:: python
p_g_clip = fluid.backward.append_backward(loss=avg_cost_clip)
with fluid.program_guard(main_program=prog_clip):
fluid.clip.set_gradient_clip(
fluid.clip.GradientClipByGlobalNorm(clip_norm=2.0))
p_g_clip = fluid.clip.append_gradient_clip_ops(p_g_clip)
.. _cn_api_fluid_clip_GradientClipByNorm:
GradientClipByNorm
-------------------------------
.. py:class:: paddle.fluid.clip.GradientClipByNorm(clip_norm)
将张量转换为L2范数不超过 ``clip_norm`` 的张量
该operator 限制了 输入张量 :math:`X` 的L2范数不会超过 :math:`max\_norm` 。如果 :math:`X` 的 ``L2`` 范数小于或等于 :math:`max\_norm` ,输出和 :math:`X` 一样，如果 :math:`X` 的L2范数大于 :math:`max\_norm` , :math:`X` 将被线性缩放到L2范数等于 :math:`max\_norm` ,如以下公式所示:
.. math::
\\Out = \frac{max\_norm∗X}{norm(X)}\\
其中 :math:`norm（X）` 代表 :math:`X` 的 L2 范数
参数:
- **clip_norm** (float) - 二范数最大值
**代码示例**
.. code-block:: python
w_param_attrs = ParamAttr(name=None,
initializer=UniformInitializer(low=-1.0, high=1.0, seed=0),
learning_rate=1.0,
regularizer=L1Decay(1.0),
trainable=True,
clip=GradientClipByNorm(clip_norm=2.0))
y_predict = fluid.layers.fc(input=x, size=1, param_attr=w_param_attrs)
.. _cn_api_fluid_clip_GradientClipByValue:
GradientClipByValue
-------------------------------
.. py:class:: paddle.fluid.clip.GradientClipByValue(max, min=None)
将梯度值(gradient values)的范围压缩到 [min, max]。
给定一个张量 ``t`` ，该操作将它的值压缩到 ``min`` 和 ``max`` 之间
- 任何小于最小值的值都被设置为最小值
- 任何大于max的值都被设置为max
参数:
- **max** (foat) - 要修剪的最大值。
- **min** (float，optional) - 要修剪的最小值。如果用户没有设置，将被 ``framework`` 设置为 ``-max`` 。
**代码示例**
.. code-block:: python
w_param_attrs = ParamAttr(name=None,
initializer=UniformInitializer(low=-1.0, high=1.0, seed=0),
learning_rate=1.0,
regularizer=L1Decay(1.0),
trainable=True,
clip=GradientClipByValue(-1.0, 1.0))
y_predict = fluid.layers.fc(input=x, size=1, param_attr=w_param_attrs)
doc/fluid/api_cn/data_feeder_cn.rst 0 → 100644
浏览文件 @ cb4f4929
###################
fluid.data_feeder
###################
.. _cn_api_fluid_data_feeder_DataFeeder:
DataFeeder
-------------------------------
.. py:class:: paddle.fluid.data_feeder.DataFeeder(feed_list, place, program=None)
``DataFeeder`` 负责将reader(读取器)返回的数据转成一种特殊的数据结构，使它们可以输入到 ``Executor`` 和 ``ParallelExecutor`` 中。
reader通常返回一个minibatch条目列表。在列表中每一条目都是一个样本（sample）,它是由具有一至多个特征的列表或元组组成的。
以下是简单用法：
.. code-block:: python
place = fluid.CPUPlace()
img = fluid.layers.data(name='image', shape=[1, 28, 28])
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
feeder = fluid.DataFeeder([img, label], fluid.CPUPlace())
result = feeder.feed([([0] * 784, [9]), ([1] * 784, [1])])
在多GPU模型训练时，如果需要提前分别向各GPU输入数据，可以使用 ``decorate_reader`` 函数。
.. code-block:: python
place=fluid.CUDAPlace(0)
feeder = fluid.DataFeeder(place=place, feed_list=[data, label])
reader = feeder.decorate_reader(
paddle.batch(flowers.train(), batch_size=16))
参数：
- **feed_list** (list) – 向模型输入的变量表或者变量表名
- **place** (Place) – place表明是向GPU还是CPU中输入数据。如果想向GPU中输入数据, 请使用 ``fluid.CUDAPlace(i)`` (i 代表 the GPU id)；如果向CPU中输入数据, 请使用 ``fluid.CPUPlace()``
- **program** (Program) – 需要向其中输入数据的Program。如果为None, 会默认使用 ``default_main_program()``。 缺省值为None
弹出异常: ``ValueError`` – 如果一些变量不在此 Program 中
**代码示例**
.. code-block:: python
# ...
place = fluid.CPUPlace()
feed_list = [
main_program.global_block().var(var_name) for var_name in feed_vars_name
] # feed_vars_name 是一个由变量名组成的列表
feeder = fluid.DataFeeder(feed_list, place)
for data in reader():
outs = exe.run(program=main_program,
feed=feeder.feed(data))
.. py:method:: feed(iterable)
根据feed_list（数据输入表）和iterable（可遍历的数据）提供的信息，将输入数据转成一种特殊的数据结构，使它们可以输入到 ``Executor`` 和 ``ParallelExecutor`` 中。
参数:
- **iterable** (list|tuple) – 要输入的数据
返回： 转换结果
返回类型: dict
.. py:method:: feed_parallel(iterable, num_places=None)
该方法获取的多个minibatch，并把每个minibatch提前输入进各个设备中。
参数:
- **iterable** (list|tuple) – 要输入的数据
- **num_places** (int) – 设备数目。默认为None。
返回: 转换结果
返回类型: dict
.. note::
设备（CPU或GPU）的数目必须等于minibatch的数目
.. py:method:: decorate_reader(reader, multi_devices, num_places=None, drop_last=True)
将reader返回的输入数据batch转换为多个mini-batch，之后每个mini-batch都会被输入进各个设备（CPU或GPU）中。
参数：
- **reader** (fun) – 该参数是一个可以生成数据的函数
- **multi_devices** (bool) – bool型，指明是否使用多个设备
- **num_places** (int) – 如果 ``multi_devices`` 为 ``True`` , 可以使用此参数来设置GPU数目。如果 ``num_places`` 为 ``None`` ，该函数默认使用当前训练机所有GPU设备。默认为None。
- **drop_last** (bool) – 如果最后一个batch的大小比 ``batch_size`` 要小，则可使用该参数来指明是否选择丢弃最后一个batch数据。 默认为 ``True``
返回：转换结果
返回类型: dict
弹出异常： ValueError – 如果 ``drop_last`` 值为False并且reader返回的minibatch数目与设备数目不相等时，产生此异常
doc/fluid/api_cn/executor_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#################
fluid.executor
#################
.. _cn_api_fluid_executor_Executor:
Executor
-------------------------------
.. py:class:: paddle.fluid.executor.Executor (place)
执行引擎（Executor）使用python脚本驱动，仅支持在单GPU环境下运行。多卡环境下请参考 ``ParallelExecutor`` 。
Python Executor可以接收传入的program,并根据feed map(输入映射表)和fetch_list(结果获取表)
向program中添加feed operators(数据输入算子)和fetch operators（结果获取算子)。
feed map为该program提供输入数据。fetch_list提供program训练结束后用户预期的变量（或识别类场景中的命名）。
应注意，执行器会执行program中的所有算子而不仅仅是依赖于fetch_list的那部分。
Executor将全局变量存储到全局作用域中，并为临时变量创建局部作用域。
当每一mini-batch上的前向/反向运算完成后，局部作用域的内容将被废弃，
但全局作用域中的变量将在Executor的不同执行过程中一直存在。
program中所有的算子会按顺序执行。
参数:
- **place** (core.CPUPlace|core.CUDAPlace(n)) – 指明了 ``Executor`` 的执行场所
提示：你可以用Executor来调试基于并行GPU实现的复杂网络，他们有完全一样的参数也会产生相同的结果。
.. py:method:: close()
关闭这个执行器(Executor)。调用这个方法后不可以再使用这个执行器。 对于分布式训练, 该函数会释放在PServers上涉及到目前训练器的资源。
**示例代码**
.. code-block:: python
cpu = core.CPUPlace()
exe = Executor(cpu)
...
exe.close()
.. py:method:: run(program=None, feed=None, fetch_list=None, feed_var_name='feed', fetch_var_name='fetch', scope=None, return_numpy=True,use_program_cache=False)
调用该执行器对象的此方法可以执行program。通过feed map提供待学习数据，以及借助fetch_list得到相应的结果。
Python执行器(Executor)可以接收传入的program,并根据输入映射表(feed map)和结果获取表(fetch_list)
向program中添加数据输入算子(feed operators)和结果获取算子（fetch operators)。
feed map为该program提供输入数据。fetch_list提供program训练结束后用户预期的变量（或识别类场景中的命名）。
应注意，执行器会执行program中的所有算子而不仅仅是依赖于fetch_list的那部分。
参数：
- **program** (Program) – 需要执行的program,如果没有给定那么默认使用default_main_program
- **feed** (dict) – 前向输入的变量，数据,词典dict类型, 例如 {“image”: ImageData, “label”: LableData}
- **fetch_list** (list) – 用户想得到的变量或者命名的列表, run会根据这个列表给与结果
- **feed_var_name** (str) – 前向算子(feed operator)变量的名称
- **fetch_var_name** (str) – 结果获取算子(fetch operator)的输出变量名称
- **scope** (Scope) – 执行这个program的域，用户可以指定不同的域。缺省为全局域
- **return_numpy** (bool) – 如果为True,则将结果张量（fetched tensor）转化为numpy
- **use_program_cache** (bool) – 当program较上次比没有改动则将其置为True
返回: 根据fetch_list来获取结果
返回类型: list(numpy.array)
**示例代码**
.. code-block:: python
data = layers.data(name='X', shape=[1], dtype='float32')
hidden = layers.fc(input=data, size=10)
layers.assign(hidden, out)
loss = layers.mean(out)
adam = fluid.optimizer.Adam()
adam.minimize(loss)
.. code-block:: python
cpu = core.CPUPlace()
exe = Executor(cpu)
exe.run(default_startup_program())
.. code-block:: python
x = numpy.random.random(size=(10, 1)).astype('float32')
outs = exe.run(
feed={'X': x},
fetch_list=[loss.name])
.. _cn_api_fluid_executor_global_scope:
global_scope
-------------------------------
.. py:function:: paddle.fluid.global_scope()
获取全局/默认作用域实例。很多api使用默认 ``global_scope`` ，例如 ``Executor.run`` 。
返回：全局/默认作用域实例
返回类型：Scope
.. _cn_api_fluid_executor_scope_guard:
scope_guard
-------------------------------
.. py:function:: paddle.fluid.scope_guard(*args, **kwds)
修改全局/默认作用域（scope）, 运行时中的所有变量都将分配给新的scope。
参数：
- **scope** - 新的全局/默认 scope。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
new_scope = fluid.Scope()
with fluid.scope_guard(new_scope):
...
doc/fluid/api_cn/fluid_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#################
fluid
#################
.. _cn_api_fluid_AsyncExecutor:
AsyncExecutor
-------------------------------
.. py:function:: paddle.fluid.AsyncExecutor(place=None)
Python中的异步执行器。AsyncExecutor利用多核处理器和数据排队的强大功能，使数据读取和融合解耦，每个线程并行运行。
AsyncExecutor不是在python端读取数据，而是接受一个训练文件列表，该列表将在c++中检索，然后训练输入将被读取、解析并在c++代码中提供给训练网络。
AsyncExecutor正在积极开发，API可能在不久的将来会发生变化。
参数：
- **place** (fluid.CPUPlace|None) - 指示 executor 将在哪个设备上运行。目前仅支持CPU
**代码示例：**
.. code-block:: python
data_feed = fluid.DataFeedDesc('data.proto')
startup_program = fluid.default_startup_program()
main_program = fluid.default_main_program()
filelist = ["train_data/part-%d" % i for i in range(100)]
thread_num = len(filelist) / 4
place = fluid.CPUPlace()
async_executor = fluid.AsyncExecutor(place)
async_executor.run_startup_program(startup_program)
epoch = 10
for i in range(epoch):
async_executor.run(main_program,
data_feed,
filelist,
thread_num,
[acc],
debug=False)
.. note::
对于并行gpu调试复杂网络，您可以在executor上测试。他们有完全相同的参数，并可以得到相同的结果。
目前仅支持CPU
.. py:method:: run(program, data_feed, filelist, thread_num, fetch, debug=False)
使用此 ``AsyncExecutor`` 来运行 ``program`` 。
``filelist`` 中包含训练数据集。用户也可以通过在参数 ``fetch`` 中提出变量来检查特定的变量， 正如 ``fluid.Executor`` 。
但不像 ``fluid.Executor`` ， ``AsyncExecutor`` 不返回获取到的变量，而是将每个获取到的变量作为标准输出展示给用户。
数据集上的运算在多个线程上执行，每个线程中都会独立出一个线程本地作用域，并在此域中建立运算。
所有运算同时更新参数值。
参数:
- program (Program) – 需要执行的program。如果没有提供该参数，默认使用 ``default_main_program``
- data_feed (DataFeedDesc) – ``DataFeedDesc`` 对象
- filelist (str) – 一个包含训练数据集文件的文件列表
- thread_num (int) – 并发训练线程数。参照 *注解* 部分获取合适的设置方法
- fetch (str|list) – 变量名，或者变量名列表。指明最后要进行观察的变量命名
- debug (bool) – 如果为True, 在每一个minibatch处理后，fetch 中指明的变量将会通过标准输出打印出来
.. note::
1.该执行器会运行program中的所有运算，不只是那些依赖于fetchlist的运算
2.该类执行器在多线程上运行，每个线程占用一个CPU核。为了实现效率最大化，建议将 ``thread_num`` 等于或稍微小于CPU核心数
.. _cn_api_fluid_BuildStrategy:
BuildStrategy
-------------------------------
.. py:class:: paddle.fluid.BuildStrategy
``BuildStrategy`` 使用户更精准地控制 ``ParallelExecutor`` 中SSA图的建造方法。可通过设置 ``ParallelExecutor`` 中的 ``BuildStrategy`` 成员来实现此功能。
**代码示例**
.. code-block:: python
build_strategy = fluid.BuildStrategy()
build_strategy.reduce_strategy = fluid.BuildStrategy.ReduceStrategy.Reduce
train_exe = fluid.ParallelExecutor(use_cuda=True,
loss_name=loss.name,
build_strategy=build_strategy)
train_loss, = train_exe.run([loss.name], feed=feed_dict)
.. py:attribute:: debug_graphviz_path
str类型。它表明了以graphviz格式向文件中写入SSA图的路径，有利于调试。 默认值为""。
.. py:attribute:: fuse_elewise_add_act_ops
bool类型。它表明了是否融合（fuse）elementwise_add_op和activation_op。这会使整体执行过程更快一些。默认为False。
.. py:attribute:: gradient_scale_strategy
str类型。在 ``ParallelExecutor`` 中，存在三种定义 *loss@grad* 的方式，分别为 ``CoeffNumDevice``, ``One`` 与 ``Customized``。默认情况下， ``ParallelExecutor`` 根据设备数目来设置 *loss@grad* 。如果你想自定义 *loss@grad* ，你可以选择 ``Customized`` 方法。默认为 ``CoeffNumDevice`` 。
.. py:attribute:: reduce_strategy
str类型。在 ``ParallelExecutor`` 中，存在两种减少策略（reduce strategy），即 ``AllReduce`` 和 ``Reduce`` 。如果你需要在所有执行场所上独立地进行参数优化，可以使用 ``AllReduce`` 。反之，如果使用 ``Reduce`` 策略，所有参数的优化将均匀地分配给不同的执行场所，随之将优化后的参数广播给其他执行场所。在一些模型中， ``Reduce`` 策略执行速度更快一些。默认值为 ``AllReduce`` 。
.. _cn_api_fluid_CPUPlace:
CPUPlace
-------------------------------
.. py:class:: paddle.fluid.CPUPlace
.. _cn_api_fluid_create_lod_tensor:
create_lod_tensor
-------------------------------
.. py:function:: paddle.fluid.create_lod_tensor(data, recursive_seq_lens, place)
该函数从一个numpy数组，列表或者已经存在的lod tensor中创建一个lod tensor。
通过一下几步实现:
1. 检查length-based level of detail (LoD,长度为基准的细节层次)，或称recursive_sequence_lengths(递归序列长度)的正确性
2. 将recursive_sequence_lengths转化为offset-based LoD(偏移量为基准的LoD)
3. 把提供的numpy数组，列表或者已经存在的lod tensor复制到CPU或GPU中(依据执行场所确定)
4. 利用offset-based LoD来设置LoD
例如：
假如我们想用LoD Tensor来承载一词序列的数据，其中每个词由一个整数来表示。现在，我们意图创建一个LoD Tensor来代表两个句子，其中一个句子有两个词，另外一个句子有三个。
那么数 ``data`` 可以是一个numpy数组，形状为（5,1）。同时， ``recursive_seq_lens`` 为 [[2, 3]]，表明各个句子的长度。这个长度为基准的 ``recursive_seq_lens`` 将在函数中会被转化为以偏移量为基准的 LoD [[0, 2, 5]]。
参数:
- **data** (numpy.ndarray|list|LoDTensor) – 容纳着待复制数据的一个numpy数组、列表或LoD Tensor
- **recursive_seq_lens** (list) – 一组列表的列表， 表明了由用户指明的length-based level of detail信息
- **place** (Place) – CPU或GPU。 指明返回的新LoD Tensor存储地点
返回: 一个fluid LoDTensor对象，包含数据和 ``recursive_seq_lens`` 信息
.. _cn_api_fluid_create_random_int_lodtensor:
create_random_int_lodtensor
-------------------------------
.. py:function:: paddle.fluid.create_random_int_lodtensor(recursive_seq_lens, base_shape, place, low, high)
该函数创建一个存储多个随机整数的LoD Tensor。
该函数是经常在书中出现的案例，所以我们根据新的API： ``create_lod_tensor`` 更改它然后放在LoD Tensor板块里来简化代码。
该函数实现以下功能：
1. 根据用户输入的length-based ``recursive_seq_lens`` （基于长度的递归序列长）和在 ``basic_shape`` 中的基本元素形状计算LoDTensor的整体形状
2. 由此形状，建立numpy数组
3. 使用API： ``create_lod_tensor`` 建立LoDTensor
假如我们想用LoD Tensor来承载一词序列，其中每个词由一个整数来表示。现在，我们意图创建一个LoD Tensor来代表两个句子，其中一个句子有两个词，另外一个句子有三个。那么 ``base_shape`` 为[1], 输入的length-based ``recursive_seq_lens`` 是 [[2, 3]]。那么LoDTensor的整体形状应为[5, 1]，并且为两个句子存储5个词。
参数:
- **recursive_seq_lens** (list) – 一组列表的列表， 表明了由用户指明的length-based level of detail信息
- **base_shape** (list) – LoDTensor所容纳的基本元素的形状
- **place** (Place) – CPU或GPU。 指明返回的新LoD Tensor存储地点
- **low** (int) – 随机数下限
- **high** (int) – 随机数上限
返回: 一个fluid LoDTensor对象，包含数据和 ``recursive_seq_lens`` 信息
.. _cn_api_fluid_CUDAPinnedPlace:
CUDAPinnedPlace
-------------------------------
.. py:class:: paddle.fluid.CUDAPinnedPlace
.. _cn_api_fluid_CUDAPlace:
CUDAPlace
-------------------------------
.. py:class:: paddle.fluid.CUDAPlace
.. _cn_api_fluid_DataFeedDesc:
DataFeedDesc
-------------------------------
.. py:function:: paddle.fluid.DataFeedDesc(proto_file)
数据描述符，描述输入训练数据格式。
这个类目前只用于AsyncExecutor(有关类AsyncExecutor的简要介绍，请参阅注释)
DataFeedDesc应由来自磁盘的有效protobuf消息初始化:
.. code-block:: python
data_feed = fluid.DataFeedDesc('data.proto')
可以参考 :code:`paddle/fluid/framework/data_feed.proto` 查看我们如何定义message
一段典型的message可能是这样的：
.. code-block:: text
name: "MultiSlotDataFeed"
batch_size: 2
multi_slot_desc {
slots {
name: "words"
type: "uint64"
is_dense: false
is_used: true
}
slots {
name: "label"
type: "uint64"
is_dense: false
is_used: true
}
}
但是，用户通常不应该关心消息格式;相反，我们鼓励他们在将原始日志文件转换为AsyncExecutor可以接受的训练文件的过程中，使用 :code:`Data Generator` 生成有效数据描述。
DataFeedDesc也可以在运行时更改。一旦你熟悉了每个字段的含义，您可以修改它以更好地满足您的需要。例如:
.. code-block:: python
data_feed.set_batch_size(128)
data_feed.set_dense_slots('wd') # The slot named 'wd' will be dense
data_feed.set_use_slots('wd') # The slot named 'wd' will be used
#Finally, the content can be dumped out for debugging purpose:
print(data_feed.desc())
参数：
- **proto_file** (string) - 包含数据feed中描述的磁盘文件
.. py:method:: set_batch_size(self, batch_size)
设置batch size，训练期间有效
参数：
- batch_size：batch size
**代码示例：**
.. code-block:: python
data_feed = fluid.DataFeedDesc('data.proto')
data_feed.set_batch_size(128)
.. py:method:: set_dense_slots(self, dense_slots_name)
指定slot经过设置后将变成密集的slot，仅在训练期间有效。
密集slot的特征将被输入一个Tensor，而稀疏slot的特征将被输入一个lodTensor
参数：
- **dense_slots_name** : slot名称的列表，这些slot将被设置为密集的
**代码示例：**
.. code-block:: python
data_feed = fluid.DataFeedDesc('data.proto')
data_feed.set_dense_slots(['words'])
.. note::
默认情况下，所有slot都是稀疏的
.. py:method:: set_use_slots(self, use_slots_name)
设置一个特定的slot是否用于训练。一个数据集包含了很多特征，通过这个函数可以选择哪些特征将用于指定的模型。
参数：
- **use_slots_name** :将在训练中使用的slot名列表
**代码示例：**
.. code-block:: python
data_feed = fluid.DataFeedDesc('data.proto')
data_feed.set_use_slots(['words'])
.. note::
默认值不用于所有slot
.. py:method:: desc(self)
返回此DataFeedDesc的protobuf信息
返回：一个message字符串
**代码示例：**
.. code-block:: python
data_feed = fluid.DataFeedDesc('data.proto')
print(data_feed.desc())
.. _cn_api_fluid_DataFeeder:
DataFeeder
-------------------------------
.. py:class:: paddle.fluid.DataFeeder(feed_list, place, program=None)
``DataFeeder`` 负责将reader(读取器)返回的数据转成一种特殊的数据结构，使它们可以输入到 ``Executor`` 和 ``ParallelExecutor`` 中。
reader通常返回一个minibatch条目列表。在列表中每一条目都是一个样本（sample）,它是由具有一至多个特征的列表或元组组成的。
以下是简单用法：
.. code-block:: python
place = fluid.CPUPlace()
img = fluid.layers.data(name='image', shape=[1, 28, 28])
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
feeder = fluid.DataFeeder([img, label], fluid.CPUPlace())
result = feeder.feed([([0] * 784, [9]), ([1] * 784, [1])])
在多GPU模型训练时，如果需要提前分别向各GPU输入数据，可以使用 ``decorate_reader`` 函数。
.. code-block:: python
place=fluid.CUDAPlace(0)
feeder = fluid.DataFeeder(place=place, feed_list=[data, label])
reader = feeder.decorate_reader(
paddle.batch(flowers.train(), batch_size=16))
参数：
- **feed_list** (list) – 向模型输入的变量表或者变量表名
- **place** (Place) – place表明是向GPU还是CPU中输入数据。如果想向GPU中输入数据, 请使用 ``fluid.CUDAPlace(i)`` (i 代表 the GPU id)；如果向CPU中输入数据, 请使用 ``fluid.CPUPlace()``
- **program** (Program) – 需要向其中输入数据的Program。如果为None, 会默认使用 ``default_main_program()``。 缺省值为None
抛出异常:
- ``ValueError`` – 如果一些变量不在此 Program 中
**代码示例**
.. code-block:: python
# ...
place = fluid.CPUPlace()
feed_list = [
main_program.global_block().var(var_name) for var_name in feed_vars_name
] # feed_vars_name 是一个由变量名组成的列表
feeder = fluid.DataFeeder(feed_list, place)
for data in reader():
outs = exe.run(program=main_program,
feed=feeder.feed(data))
.. py:method:: feed(iterable)
根据feed_list（数据输入表）和iterable（可遍历的数据）提供的信息，将输入数据转成一种特殊的数据结构，使它们可以输入到 ``Executor`` 和 ``ParallelExecutor`` 中。
参数:
- **iterable** (list|tuple) – 要输入的数据
返回： 转换结果
返回类型: dict
.. py:method:: feed_parallel(iterable, num_places=None)
该方法获取的多个minibatch，并把每个minibatch提前输入进各个设备中。
参数:
- **iterable** (list|tuple) – 要输入的数据
- **num_places** (int) – 设备数目。默认为None。
返回: 转换结果
返回类型: dict
.. note::
设备（CPU或GPU）的数目必须等于minibatch的数目
.. py:method:: decorate_reader(reader, multi_devices, num_places=None, drop_last=True)
将reader返回的输入数据batch转换为多个mini-batch，之后每个mini-batch都会被输入进各个设备（CPU或GPU）中。
参数：
- **reader** (fun) – 该参数是一个可以生成数据的函数
- **multi_devices** (bool) – bool型，指明是否使用多个设备
- **num_places** (int) – 如果 ``multi_devices`` 为 ``True`` , 可以使用此参数来设置GPU数目。如果 ``num_places`` 为 ``None`` ，该函数默认使用当前训练机所有GPU设备。默认为None。
- **drop_last** (bool) – 如果最后一个batch的大小比 ``batch_size`` 要小，则可使用该参数来指明是否选择丢弃最后一个batch数据。 默认为 ``True``
返回：转换结果
返回类型: dict
抛出异常： ``ValueError`` – 如果 ``drop_last`` 值为False并且reader返回的minibatch数目与设备数目不相等时，产生此异常
.. _cn_api_fluid_default_main_program:
default_main_program
-------------------------------
.. py:function:: paddle.fluid.default_main_program()
此函数用于获取默认或全局main program(主程序)。该主程序用于训练和测试模型。
``fluid.layers`` 中的所有layer函数可以向 ``default_main_program`` 中添加operators（算子）和variables（变量）。
``default_main_program`` 是fluid的许多编程接口（API）的Program参数的缺省值。例如,当用户program没有传入的时候，
``Executor.run()`` 会默认执行 ``default_main_program`` 。
返回： main program
返回类型: Program
.. _cn_api_fluid_default_startup_program:
default_startup_program
-------------------------------
.. py:function:: paddle.fluid.default_startup_program()
该函数可以获取默认/全局 startup program (启动程序)。
``fluid.layers`` 中的layer函数会新建参数、readers(读取器)、NCCL句柄作为全局变量。
startup_program会使用内在的operators（算子）去初始化他们，并由layer函数将这些operators追加到startup program中。
该函数将返回默认的或当前的startup_program。用户可以使用 ``fluid.program_guard`` 去切换program。
返回: startup program
返回类型: Program
.. _cn_api_fluid_DistributeTranspiler:
DistributeTranspiler
-------------------------------
.. py:class:: paddle.fluid.DistributeTranspiler (config=None)
该类可以把fluid program转变为分布式数据并行计算程序（distributed data-parallelism programs）,可以有Pserver和NCCL2两种模式。
当program在Pserver（全称：parameter server）模式下， ``main_program`` (主程序)转为使用一架远程parameter server(即pserver,参数服务器)来进行参数优化，并且优化图会被输入到一个pserver program中。
在NCCL2模式下，transpiler会在 ``startup_program`` 中附加一个 ``NCCL_ID`` 广播算子（broadcasting operators）来实现在该集群中所有工作结点共享 ``NCCL_ID`` 。
调用 ``transpile_nccl2`` 后， 你 **必须** 将 ``trainer_id`` , ``num_trainers`` 参数提供给 ``ParallelExecutor`` 来启动NCCL2分布式模式。
**代码示例**
.. code-block:: python
#pserver模式下
pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
current_endpoint = "192.168.0.1:6174"
trainer_id = 0
trainers = 4
role = os.getenv("PADDLE_TRAINING_ROLE")
t = fluid.DistributeTranspiler()
t.transpile(
trainer_id, pservers=pserver_endpoints, trainers=trainers)
if role == "PSERVER":
pserver_program = t.get_pserver_program(current_endpoint)
pserver_startup_program = t.get_startup_program(current_endpoint,
pserver_program)
elif role == "TRAINER":
trainer_program = t.get_trainer_program()
# nccl2模式下
config = fluid.DistributeTranspilerConfig()
config.mode = "nccl2"
t = fluid.DistributeTranspiler(config=config)
t.transpile(trainer_id, workers=workers, current_endpoint=curr_ep)
exe = fluid.ParallelExecutor(
use_cuda,
loss_name=loss_var.name,
num_trainers=len(trainers.split(",)),
trainer_id=trainer_id
)
.. py:method:: transpile(trainer_id, program=None, pservers='127.0.0.1:6174', trainers=1, sync_mode=True, startup_program=None, current_endpoint='127.0.0.1:6174')
该方法可以运行该transpiler（转译器）。
参数:
- **trainer_id** (int) – 当前Trainer worker的id, 如果有n个Trainer worker, id 取值范围为0 ~ n-1
- **program** (Program|None) – 待transpile（转译）的program, 缺省为 ``fluid.default_main_program()``
- **startup_program** (Program|None) - 要转译的 ``startup_program`` ,默认为 ``fluid.default_startup_program()``
- **pservers** (str) – 内容为Pserver列表的字符串，格式为：按逗号区分不同的Pserver，每个Pserver的格式为 *ip地址:端口号*
- **trainers** (int|str) – 在Pserver模式下，该参数指Trainer机的个数；在nccl2模式下，它是一个内容为Trainer终端列表的字符串
- **sync_mode** (bool) – 是否做同步训练(synchronous training), 默认为True
- **startup_program** (Program|None) – 待transpile（转译）的startup_program，默认为 ``fluid.default_main_program()``
- **current_endpoint** (str) – 当需要把program转译（transpile）至NCCL2模式下时，需要将当前endpoint（终端）传入该参数。Pserver模式不使用该参数
.. py:method:: get_trainer_program(wait_port=True)
该方法可以得到Trainer侧的program。
返回: Trainer侧的program
返回类型: Program
.. py:method:: get_pserver_program(endpoint)
该方法可以得到Pserver（参数服务器）侧的程序
参数:
- **endpoint** (str) – 当前Pserver终端
返回: 当前Pserver需要执行的program
返回类型: Program
.. py:method:: get_pserver_programs(endpoint)
该方法可以得到Pserver侧用于分布式训练的 ``main_program`` 和 ``startup_program`` 。
参数:
- **endpoint** (str) – 当前Pserver终端
返回: (main_program, startup_program), “Program”类型的元组
返回类型: tuple
.. py:method:: get_startup_program(endpoint, pserver_program=None, startup_program=None)
**该函数已停止使用**
获取当前Pserver的startup_program，如果有多个被分散到不同blocks的变量，则修改operator的输入变量。
参数:
- **endpoint** (str) – 当前Pserver终端
- **pserver_program** (Program) – 已停止使用。 先调用get_pserver_program
- **startup_program** (Program) – 已停止使用。应在初始化时传入startup_program
返回: Pserver侧的startup_program
返回类型: Program
.. _cn_api_fluid_DistributeTranspilerConfig:
DistributeTranspilerConfig
-------------------------------
.. py:class:: paddle.fluid.DistributeTranspilerConfig
.. py:attribute:: slice_var_up (bool)
为多个Pserver（parameter server）将tensor切片, 默认为True。
.. py:attribute:: split_method (PSDispatcher)
可使用 RoundRobin 或者 HashName。
注意: 尝试选择最佳方法来达到Pserver间负载均衡。
.. py:attribute:: min_block_size (int)
最小数据块的大小
注意: 根据：`issuecomment-369912156 <https://github.com/PaddlePaddle/Paddle/issues/8638#issuecomment-369912156>`_ , 当数据块大小超过2MB时，我们可以有效地使用带宽。如果你想更改它，请详细查看 ``slice_variable`` 函数。
.. _cn_api_fluid_ExecutionStrategy:
ExecutionStrategy
-------------------------------
.. py:class:: paddle.fluid.ExecutionStrategy
``ExecutionStrategy`` 允许用户更加精准地控制program在 ``ParallelExecutor`` 中的运行方式。可以通过在 ``ParallelExecutor`` 中设置本成员来实现。
**代码示例**
.. code-block:: python
exec_strategy = fluid.ExecutionStrategy()
exec_strategy.num_threads = 4
train_exe = fluid.ParallelExecutor(use_cuda=True,
loss_name=loss.name,
exec_strategy=exec_strategy)
train_loss, = train_exe.run([loss.name], feed=feed_dict)
.. py:attribute:: allow_op_delay
这是一个bool类型成员，表示是否推迟communication operators(交流运算)的执行，这样做会使整体执行过程更快一些。但是在一些模型中，allow_op_delay会导致程序中断。默认为False。
.. py:attribute:: num_iteration_per_drop_scope
int型成员。它表明了清空执行时产生的临时变量需要的程序执行重复次数。因为临时变量的形可能在两次重复过程中保持一致，所以它会使整体执行过程更快。默认值为100。
.. note::
1. 如果在调用 ``run`` 方法时获取结果数据，``ParallelExecutor`` 会在当前程序重复执行尾部清空临时变量
2. 在一些NLP模型里，该成员会致使GPU内存不足。此时，你应减少 ``num_iteration_per_drop_scope`` 的值
.. py:attribute:: num_threads
int型成员。它代表了线程池(thread pool)的大小。这些线程会被用来执行当前 ``ParallelExecutor`` 的program中的operator（算子，运算）。如果 :math:`num\_threads=1` ，则所有的operator将一个接一个地执行，但在不同的程序重复周期(iterations)中执行顺序可能不同。如果该成员没有被设置，则在 ``ParallelExecutor`` 中，它会依据设备类型(device type)、设备数目(device count)而设置为相应值。对GPU，:math:`num\_threads=device\_count∗4` ；对CPU， :math:`num\_threads=CPU\_NUM∗4` 。在 ``ParallelExecutor`` 中有关于 :math:`CPU\_NUM` 的详细解释。如果没有设置 :math:`CPU\_NUM` ， ``ParallelExecutor`` 可以通过调用 ``multiprocessing.cpu_count()`` 获取CPU数目(cpu count)。默认值为0。
.. _cn_api_fluid_executor:
Executor
-------------------------------
.. py:class:: paddle.fluid.Executor (place)
执行引擎（Executor）使用python脚本驱动，仅支持在单GPU环境下运行。多卡环境下请参考 ``ParallelExecutor`` 。
Python Executor可以接收传入的program,并根据feed map(输入映射表)和fetch_list(结果获取表)
向program中添加feed operators(数据输入算子)和fetch operators（结果获取算子)。
feed map为该program提供输入数据。fetch_list提供program训练结束后用户预期的变量（或识别类场景中的命名）。
应注意，执行器会执行program中的所有算子而不仅仅是依赖于fetch_list的那部分。
Executor将全局变量存储到全局作用域中，并为临时变量创建局部作用域。
当每一mini-batch上的前向/反向运算完成后，局部作用域的内容将被废弃，
但全局作用域中的变量将在Executor的不同执行过程中一直存在。
program中所有的算子会按顺序执行。
参数:
- **place** (core.CPUPlace|core.CUDAPlace(n)) – 指明了 ``Executor`` 的执行场所
提示：你可以用 ``Executor`` 来调试基于并行GPU实现的复杂网络，他们有完全一样的参数也会产生相同的结果。
.. py:method:: close()
关闭这个执行器(Executor)。调用这个方法后不可以再使用这个执行器。 对于分布式训练, 该函数会释放在PServers上涉及到目前训练器的资源。
**示例代码**
.. code-block:: python
cpu = core.CPUPlace()
exe = Executor(cpu)
...
exe.close()
.. py:method:: run(program=None, feed=None, fetch_list=None, feed_var_name='feed', fetch_var_name='fetch', scope=None, return_numpy=True,use_program_cache=False)
调用该执行器对象的此方法可以执行program。通过feed map提供待学习数据，以及借助fetch_list得到相应的结果。
Python执行器(Executor)可以接收传入的program,并根据输入映射表(feed map)和结果获取表(fetch_list)
向program中添加数据输入算子(feed operators)和结果获取算子（fetch operators)。
feed map为该program提供输入数据。fetch_list提供program训练结束后用户预期的变量（或识别类场景中的命名）。
应注意，执行器会执行program中的所有算子而不仅仅是依赖于fetch_list的那部分。
参数：
- **program** (Program) – 需要执行的program,如果没有给定那么默认使用default_main_program
- **feed** (dict) – 前向输入的变量，数据,词典dict类型, 例如 {“image”: ImageData, “label”: LableData}
- **fetch_list** (list) – 用户想得到的变量或者命名的列表, run会根据这个列表给与结果
- **feed_var_name** (str) – 前向算子(feed operator)变量的名称
- **fetch_var_name** (str) – 结果获取算子(fetch operator)的输出变量名称
- **scope** (Scope) – 执行这个program的域，用户可以指定不同的域。缺省为全局域
- **return_numpy** (bool) – 如果为True,则将结果张量（fetched tensor）转化为numpy
- **use_program_cache** (bool) – 当program较上次比没有改动则将其置为True
返回: 根据fetch_list来获取结果
返回类型: list(numpy.array)
**示例代码**
.. code-block:: python
data = layers.data(name='X', shape=[1], dtype='float32')
hidden = layers.fc(input=data, size=10)
layers.assign(hidden, out)
loss = layers.mean(out)
adam = fluid.optimizer.Adam()
adam.minimize(loss)
.. code-block:: python
cpu = core.CPUPlace()
exe = Executor(cpu)
exe.run(default_startup_program())
.. code-block:: python
x = numpy.random.random(size=(10, 1)).astype('float32')
outs = exe.run(
feed={'X': x},
fetch_list=[loss.name])
.. _cn_api_fluid_global_scope:
global_scope
-------------------------------
.. py:function:: paddle.fluid.global_scope()
获取全局/默认作用域实例。很多api使用默认 ``global_scope`` ，例如 ``Executor.run`` 。
返回：全局/默认作用域实例
返回类型：Scope
.. _cn_api_fluid_LoDTensor:
LoDTensor
-------------------------------
.. py:class:: paddle.fluid.LoDTensor
LoDTensor是一个具有LoD信息的张量(Tensor)
``np.array(lod_tensor)`` 可以将LoDTensor转换为numpy array。
``lod_tensor.lod()`` 可以获得LoD信息。
LoD是多层序列（Level of Details）的缩写，通常用于不同长度的序列。如果您不需要了解LoD信息，可以跳过下面的注解。
举例:
X 为 LoDTensor，它包含两个序列。第一个长度是2，第二个长度是3。
从Lod中可以计算出X的第一维度为5， 因为5=2+3， 说明X中有5个序列。在X中的每个序列中的每个元素有2列，因此X的shape为[5,2]。
::
x.lod = [[2, 3]]
x.data = [[1, 2], [3, 4], // seq 1
[5, 6], [7, 8], [9, 10]] // seq 2
x.shape = [5, 2]
LoD可以有多个level(例如，一个段落可以有多个句子，一个句子可以有多个单词)。下面的例子中，Y为LoDTensor ，lod_level为2。表示有2个序列，第一个序列的长度是2(有2个子序列)，第二个序列的长度是1。第一序列的两个子序列长度分别为2和2。第二个序列的子序列的长度是3。
::
y.lod = [[2 1], [2 2 3]] y.shape = [2+2+3, ...]
.. note::
在上面的描述中，LoD是基于长度的。在paddle内部实现中，lod是基于偏移的。因此,在内部,y.lod表示为[[0,2,3]，[0,2,4,7]](基于长度的Lod表示为为[[2-0,3-2]，[2-0,4-2,7-4]])。
可以将LoD理解为recursive_sequence_length（递归序列长度）。此时，LoD必须是基于长度的。由于历史原因。当LoD在API中被称为lod时，它可能是基于偏移的。用户应该注意。
.. py:method:: has_valid_recursive_sequence_lengths(self: paddle.fluid.core.LoDTensor) → bool
.. py:method:: lod(self: paddle.fluid.core.LoDTensor) → List[List[int]]
.. py:method:: recursive_sequence_lengths(self: paddle.fluid.core.LoDTensor) → List[List[int]]
.. py:method:: set_lod(self: paddle.fluid.core.LoDTensor, arg0: List[List[int]]) → None
.. py:method:: set_recursive_sequence_lengths(self: paddle.fluid.core.LoDTensor, arg0: List[List[int]]) → None
.. _cn_api_fluid_LoDTensorArray:
LoDTensorArray
-------------------------------
.. py:class:: paddle.fluid.LoDTensorArray
.. py:method:: append(self: paddle.fluid.core.LoDTensorArray, arg0: paddle.fluid.core.LoDTensor) → None
.. _cn_api_fluid_memory_optimize:
memory_optimize
-------------------------------
.. py:function:: paddle.fluid.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=False)
通过重用var内存来优化内存。
.. note::
它不支持block中嵌套子block。
参数:
- **input_program** (str) – 输入Program。
- **skip_opt_set** (set) – set中的vars将不被内存优化。
- **print_log** (bool) – 是否打印debug日志。
- **level** (int) 如果 level=0 并且shape是完全相等，则重用。
返回: None
.. _cn_api_fluid_name_scope:
name_scope
-------------------------------
.. py:function:: paddle.fluid.name_scope(*args, **kwds)
为operators生成层次名称前缀
注意： 这个函数只能用于调试和可视化。不要将其用于分析，比如graph/program转换。
参数：
- **prefix** (str) - 前缀
**示例代码**
.. code-block:: python
with name_scope("encoder"):
...
with name_scope("decoder"):
...
with name_scope("attention"):
...
.. _cn_api_fluid_ParallelExecutor:
ParallelExecutor
-------------------------------
.. py:class:: paddle.fluid.ParallelExecutor(use_cuda, loss_name=None, main_program=None, share_vars_from=None, exec_strategy=None, build_strategy=None, num_trainers=1, trainer_id=0, scope=None)
``ParallelExecutor`` 专门设计用来实现数据并行计算，着力于向不同结点(node)分配数据，并行地在不同结点中对数据进行操作。如果在GPU上使用该类运行程序，node则用来指代GPU， ``ParallelExecutor`` 也将自动获取在当前机器上可用的GPU资源。如果在CPU上进行操作，node则指代CPU，同时你也可以通过添加环境变量 ``CPU_NUM`` 来设置CPU设备的个数。例如，``CPU_NUM=4``。但是如果没有设置该环境变量，该类会调用 ``multiprocessing.cpu_count`` 来获取当前系统中CPU的个数。
参数:
- **use_cuda** (bool) – 是否使用CUDA
- **loss_name** (str) – 在训练阶段，必须提供loss function名称。默认为None
- **main_program** (Program) – 需要执行的program。如果未提供， 那么将使用 ``default_main_program``。 默认为None
- **share_vars_from** (ParallelExecutor) – 如果提供了该参数， 则该 ``ParallelExecutor`` 与指定的 ``ParallelExecutor`` 共享变量。默 认为空
- **exec_strategy** (ExecutionStrategy) – ``exec_strategy`` 用于调控program在 ``ParallelExecutor`` 中的执行方式，例如，执行该program需要的线程数, 释放在执行过程中产生的临时变量需要的重复(iterations)次数。 请参考 ``fluid.ExecutionStrategy`` 获取详细介绍。该参数默认为 None
- **build_strategy** (BuildStrategy) – 设置成员 ``build_strategy`` 可以控制在 ``ParallelExecutor`` 中搭建SSA Graph的方式，例如， ``reduce_strategy`` ， ``gradient_scale_strategy`` 。 请参考 ``fluid.BuildStrategy`` 获取详细介绍。 该参数默认为None
- **num_trainers** (int) – 如果该值大于1， NCCL将会通过多层级node的方式来初始化。每个node应有相同的GPU数目。 随之会启用分布式训练。该参数默认为1
- **trainer_id** (int) – 必须与 ``num_trainers`` 参数同时使用。``trainer_id`` 是当前所在node的 “rank”（层级），从0开始计数。该参数默认为0
- **scope** (Scope) – 指定执行program所在的作用域， 默认使用 ``fluid.global_scope()``
返回：初始化后的 ``ParallelExecutor`` 对象
返回类型: ParallelExecutor
抛出异常：``TypeError`` - 如果提供的参数 ``share_vars_from`` 不是 ``ParallelExecutor`` 类型的，将会弹出此异常
**代码示例**
.. code-block:: python
train_exe = fluid.ParallelExecutor(use_cuda=True, loss_name=loss.name)
test_exe = fluid.ParallelExecutor(use_cuda=True,
main_program=test_program,
share_vars_from=train_exe)
train_loss, = train_exe.run([loss.name], feed=feed_dict)
test_loss, = test_exe.run([loss.name], feed=feed_dict)
.. py:method:: run(fetch_list, feed=None, feed_dict=None, return_numpy=True)
使用 ``fetch_list`` 执行一个 ``ParallelExecutor`` 对象。
参数 ``feed`` 可以是 ``dict`` 或者 ``list`` 类型变量。如果该参数是 ``dict`` 类型，feed中的数据将会被分割(split)并分送给多个设备（CPU/GPU）。
反之，如果它是 ``list`` ，则列表中的各个元素都会直接分别被拷贝到各设备中。
例如，如果 ``feed`` 是个 ``dict`` 类型变量，则有
.. code-block:: python
exe = ParallelExecutor()
# 图像会被split到设备中。假设有两个设备，那么每个设备将会处理形为 (24, 1, 28, 28)的图像
exe.run(feed={'image': numpy.random.random(size=(48, 1, 28, 28))})
如果 ``feed`` 是个 ``list`` 类型变量，则有
.. code-block:: python
exe = ParallelExecutor()
# 各设备挨个处理列表中的每个元素
# 第一个设备处理形为 (48, 1, 28, 28) 的图像
# 第二个设备处理形为 (32, 1, 28, 28) 的图像
#
# 使用 exe.device_count 得到设备数目
exe.run(feed=[{"image": numpy.random.random(size=(48, 1, 28, 28))},
{"image": numpy.random.random(size=(32, 1, 28, 28))},
])
参数：
- **fetch_list** (list) – 获取的变量名列表
- **feed** (list|dict|None) – feed变量。 如果该参数是 ``dict`` 类型，feed中的数据将会被分割(split)并分送给多个设备（CPU/GPU）。反之，如果它是 ``list`` ，则列表中的各个元素都直接分别被拷贝到各设备中。默认为None
- **feed_dict** – 该参数已经停止使用。feed参数的别名, 为向后兼容而立。默认为None
- **return_numpy** (bool) – 是否将fetched tensor转换为numpy。默认为True
返回： 获取的结果列表
返回类型：List
抛出异常:
- ``ValueError`` - 如果feed参数是list类型，但是它的长度不等于可用设备（执行场所）的数目，再或者给定的feed不是dict类型，抛出此异常
- ``TypeError`` - 如果feed参数是list类型，但是它里面的元素不是dict类型时，弹出此异常
.. note::
1.如果feed参数为dict类型，那么传入 ``ParallelExecutor`` 的数据量 *必须* 大于可用的执行场所数目。否则，C++端将会抛出异常。应额外注意核对数据集的最后一个batch是否比可用执行场所数目大。
2.如果可用执行场所大于一个，则为每个变量最后获取的结果都是list类型，且这个list中的每个元素都是各个可用执行场所的变量
**代码示例**
.. code-block:: python
pe = fluid.ParallelExecutor(use_cuda=use_cuda,
loss_name=avg_cost.name,
main_program=fluid.default_main_program())
loss = pe.run(feed=feeder.feed(cur_batch),
fetch_list=[avg_cost.name]))
.. _cn_api_fluid_ParamAttr:
ParamAttr
-------------------------------
.. py:class:: paddle.fluid.ParamAttr(name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, gradient_clip=None, do_model_average=False)
该类代表了参数的各种属性。 为了使神经网络训练过程更加流畅，用户可以根据需要调整参数属性。比如learning rate（学习率）, regularization（正则化）, trainable（可训练性）, do_model_average(平均化模型)和参数初始化方法.
参数:
- **name** (str) – 参数名。默认为None。
- **initializer** (Initializer) – 初始化该参数的方法。 默认为None
- **learning_rate** (float) – 参数的学习率。计算方法为 :math:`global\_lr*parameter\_lr∗scheduler\_factor` 。 默认为1.0
- **regularizer** (WeightDecayRegularizer) – 正则因子. 默认为None
- **trainable** (bool) – 该参数是否可训练。默认为True
- **gradient_clip** (BaseGradientClipAttr) – 减少参数梯度的方法。默认为None
- **do_model_average** (bool) – 该参数是否服从模型平均值。默认为False
**代码示例**
.. code-block:: python
w_param_attrs = fluid.ParamAttr(name="fc_weight",
learning_rate=0.5,
regularizer=fluid.L2Decay(1.0),
trainable=True)
y_predict = fluid.layers.fc(input=x, size=10, param_attr=w_param_attrs)
.. _cn_api_fluid_Program:
Program
-------------------------------
.. py:function:: paddle.fluid.Program
创建python program， 在paddleFluid内部会被转换为ProgramDesc描述语言，是被用来创建c++ Program。Program像容器一样也是一种独立的程序语言。Program包括至少一个块（Block），控制流比如conditional_block包括while_op，该Program将会含有嵌套块（nested block）。详情请参阅framework.proto。
注意：默认情况下，paddleFluid内部默认含有 ``default_startup_program`` 和 ``default_main_program`` ，它们将共享参数。 ``default_startup_program`` 只运行一次来初始化参数， ``default_main_program`` 在每个mini batch中运行并调整权重。
返回： empty program
**代码示例**
.. code-block:: python
main_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(main_program=main_program, startup_program=startup_program):
fluid.layers.data(name="x", shape=[-1, 784], dtype='float32')
fluid.layers.data(name="y", shape=[-1, 1], dtype='int32')
fluid.layers.fc(name="fc", shape=[10], dtype='float32', act="relu")
.. py:attribute:: op_role
operator的角色，值只能是枚举变量{Forward, Backward, Optimize}。
注意：这是一个底层API。它仅用于 ``ParallelExecutor`` 复制或调度operator到设备。
例如，Forward operator应该在每个设备上执行。Backward operator在每个设备上执行，并将后向传播的参数梯度(使用 ``op_role_var`` 获得该变量)合并到一个设备上。Optimize operator只在一个设备上执行，并向其他设备广播新的参数，
.. py:attribute:: set_op_role
operator的角色，值只能是枚举变量{Forward, Backward, Optimize}。
注意：这是一个底层API。它仅用于 ``ParallelExecutor`` 复制或调度operator到设备上执行。
例如，Forward operator应该在每个设备上执行。Backward operato应该在每个设备上执行，并将后向传播的参数梯度(使用op_role_var获得该变量)合并到一个设备上。Optimize operator只在一个设备上执行，并向其他设备广播新的参数
.. py:attribute:: op_role_var
``op_role`` 的辅助变量。
参考: ``Program.op_role`` 文档。
注意:这是一个底层API，用户不应该直接使用它。
.. py:attribute:: set_op_role_var
``op_role`` 的辅助变量。
参考: ``Program.op_role`` 文档。
注意:这是一个底层API。用户不应该直接使用它。
.. py:method:: to_string(throw_on_error, with_details=False)
用于debug
参数：
- **throw_on_error** (bool): 没有设置任何必需的字段时，抛出值错误。
- **with_details** (bool): 值为true时，打印更多关于变量和参数的信息，如trainable, optimize_attr等
返回：(str): debug 字符串
抛出异常： ``ValueError`` - 当 ``throw_on_error == true`` ，但没有设置任何必需的字段时，抛出 ``ValueError`` 。
.. py:method:: clone(for_test=False)
创建一个新的、相同的Program。
有些operator，在训练和测试之间的行为是不同的，比如batch_norm。它们有一个属性is_test来控制行为。当for_test=True时，此方法将把它们的is_test属性更改为True。
- 克隆Program，该Program用于训练时，将 ``for_test`` 设置为False。
- 克隆Program，该Program用于测试时，将 ``for_test`` 设置为True。
注意:此API不会删除任何操作符。请在backward和optimization之前使用clone(for_test=True)。
**代码示例**
.. code-block:: python
test_program = fluid.default_main_program().clone(for_test=True)
optimizer = fluid.optimizer.Momentum(learning_rate=0.01, momentum=0.9)
optimizer.minimize()
参数：
- **for_test** (bool) – 取值为True时，clone方法内部会把operator的属性 ``is_test`` 设置为 True
返回：一个新的、相同的Program
返回类型:Program
**代码示例**
1.克隆一个Program，示例代码如下：
.. code-block:: python
train_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(train_program, startup_program):
img = fluid.layers.data(name='image', shape=[784])
hidden = fluid.layers.fc(input=img, size=200, act='relu')
hidden = fluid.layers.dropout(hidden, dropout_prob=0.5)
loss = fluid.layers.cross_entropy(
input=fluid.layers.fc(hidden, size=10, act='softmax'),
label=fluid.layers.data(name='label', shape=[1], dtype='int64'))
test_program = train_program.clone(for_test=True)
sgd = fluid.optimizer.SGD(learning_rate=1e-3)
with fluid.program_guard(train_program, startup_program):
sgd.minimize(loss)
2.如果分别运行 train Program 和 test Program，则可以不使用clone。
.. code-block:: python
import paddle.fluid as fluid
def network(is_test):
img = fluid.layers.data(name='image', shape=[784])
hidden = fluid.layers.fc(input=img, size=200, act='relu')
hidden = fluid.layers.dropout(hidden, dropout_prob=0.5, is_test=is_test)
loss = fluid.layers.cross_entropy(
input=fluid.layers.fc(hidden, size=10, act='softmax'),
label=fluid.layers.data(name='label', shape=[1], dtype='int64'))
return loss
train_program = fluid.Program()
startup_program = fluid.Program()
test_program = fluid.Program()
with fluid.program_guard(train_program, startup_program):
with fluid.unique_name.guard():
loss = network(is_test=False)
sgd = fluid.optimizer.SGD(learning_rate=1e-3)
sgd.minimize(loss)
# 不使用测试阶段的startup program
with fluid.program_guard(test_program, fluid.Program()):
with fluid.unique_name.guard():
loss = network(is_test=True)
上边两个代码片段生成的Program是一样的。
.. py:staticmethod:: parse_from_string(binary_str)
反序列化protobuf，转换成program
注意:在序列化和反序列化之后，所有关于参数的信息都会丢失。
参数:
- **binary_str_type** (str) – prootbuf二进制字符串
返回: 反序列化后的ProgramDesc
返回类型：Program
.. py:attribute:: num_blocks
该program中的block的个数
.. py:attribute:: random_seed
程序中随机运算符的默认随机种子。0意味着从随机设备中获取随机种子。
注意：必须在operator被添加之前设置。
.. py:method:: global_block()
获取该program的第一个block。
.. py:method:: block(index)
返回该program中 ， ``index`` 指定的block。 ``index`` 类型为int
返回：index对应的block
返回类型：Block
.. py:method:: current_block()
获取当前block。当前block是用来添加operators。
.. py:method:: list_vars()
获取当前program中所有变量。返回值是一个可迭代对象（iterable object)。
返回：generator 会yield每个Program中的变量
返回类型：iterable
.. _cn_api_fluid_program_guard:
program_guard
-------------------------------
.. py:function:: paddle.fluid.program_guard(*args, **kwds)
该函数应配合使用python的“with”语句来改变全局主程序(main program)和启动程序(startup program)。
“with”语句块中的layer函数将在新的main program（主程序）中添加operators（算子）和variables（变量）。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
main_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(main_program, startup_program):
data = fluid.layers.data(...)
hidden = fluid.layers.fc(...)
需要注意的是，如果用户不需要构建自己的启动程序或者主程序，一个临时的program将会发挥作用。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
main_program = fluid.Program()
# 如果您不需要关心startup program,传入一个临时值即可
with fluid.program_guard(main_program, fluid.Program()):
data = ...
参数：
- **main_program** (Program) – “with”语句中将使用的新的main program。
- **startup_program** (Program) – “with”语句中将使用的新的startup program。若传入 ``None`` 则不改变当前的启动程序。
.. _cn_api_fluid_release_memory:
release_memory
-------------------------------
.. py:function:: paddle.fluid.release_memory(input_program, skip_opt_set=None)
该函数可以调整输入program，插入 ``delete_op`` 删除算子，提前删除不需要的变量。
改动是在变量本身上进行的。
**提醒**: 该API还在试验阶段，会在后期版本中删除。不建议用户使用。
参数:
- **input_program** (Program) – 在此program中插入 ``delete_op``
- **skip_opt_set** (set) – 在内存优化时跳过的变量的集合
返回: None
.. _cn_api_fluid_Scope:
Scope
-------------------------------
.. py:class:: paddle.fluid.scope(scope)
(作用域)Scope为变量名的联合。所有变量都属于Scope。
从本地作用域中可以拉取到其双亲作用域的变量。
要想运行一个网络，需要指明它运行所在的域，确切的说： exe.Run(&scope) 。
一个网络可以在不同域上运行，并且更新该域的各类变量。
在作用域上创建一个变量，并在域中获取。
**代码示例**
.. code-block:: python
# create tensor from a scope and set value to it.
param = scope.var('Param').get_tensor()
param_array = np.full((height, row_numel), 5.0).astype("float32")
param.set(param_array, place)
.. py:method:: drop_kids(self: paddle.fluid.core.Scope) → None
.. py:method:: find_var(self: paddle.fluid.core.Scope, arg0: unicode) → paddle.fluid.core.Variable
.. py:method:: new_scope(self: paddle.fluid.core.Scope) → paddle.fluid.core.Scope
.. py:method:: var(self: paddle.fluid.core.Scope, arg0: unicode) → paddle.fluid.core.Variable
.. _cn_api_fluid_scope_guard:
scope_guard
-------------------------------
.. py:function:: paddle.fluid.scope_guard(*args, **kwds)
修改全局/默认作用域（scope）, 运行时中的所有变量都将分配给新的scope。
参数：
- **scope** - 新的全局/默认 scope。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
new_scope = fluid.Scope()
with fluid.scope_guard(new_scope):
...
.. _cn_api_fluid_Tensor:
Tensor
-------------------------------
.. py:function:: paddle.fluid.Tensor
``LoDTensor`` 的别名
.. _cn_api_fluid_WeightNormParamAttr:
WeightNormParamAttr
-------------------------------
.. py:class:: paddle.fluid.WeightNormParamAttr(dim=None, name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, gradient_clip=None, do_model_average=False)
权重归一化。权重归一化是将权重向量的长度与其方向解耦。`Weight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural Networks <https://arxiv.org/pdf/1602.07868.pdf>`_ 这篇paper中讨论了权重归一化的实现
参数:
- **dim** (list) - 参数的名称。默认None。
- **name** (str) - 参数的名称。默认None。
- **initializer** （initializer) - 初始化参数的方法。默认None。
- **learning_rate** (float) - 学习率。优化时学习速率 :math:`global\_lr∗parameter\_lr∗scheduler\_factor` 。默认1.0。
- **regularizer** (WeightDecayRegularizer) - 正则化因子。默认None。
- **trainable** (bool) - 参数是否可训练。默认True。
- **gradient_clip** (BaseGradientClipAttr) - 梯度下降裁剪（Gradient Clipping）的方法。默认None。
- **do_model_average** (bool) - 参数是否应该model average。默认False。
返回： empty program
**代码示例**
.. code-block:: python
data = fluid.layers.data(name="data", shape=[3, 32, 32], dtype="float32")
fc = fluid.layers.fc(input=data,
size=1000,
param_attr=WeightNormParamAttr(
dim=None,
name='weight_norm_param'))
doc/fluid/api_cn/gen_index.py 0 → 100644
浏览文件 @ cb4f4929
import os.path, time
import exceptions
import glob
import os
if __name__ == '__main__':
file_object = open('index_cn.rst', 'w')
file_object.write('''=============
API Reference
=============
.. toctree::
:maxdepth: 1
''')
file_object.write(' api_guides/index.rst'+'\n')
file_object.write(' fluid_cn.rst'+'\n')
for file_name in sorted(glob.glob("*.rst")):
if file_name != ('index_cn.rst' and 'fluid_cn.rst'):
file_object.write(' '+file_name + "\n")
file_object.close( )
doc/fluid/api_cn/index_cn.rst 0 → 100644
浏览文件 @ cb4f4929
=============
API Reference
=============
.. toctree::
:maxdepth: 1
api_guides/index.rst
fluid_cn.rst
average_cn.rst
backward_cn.rst
clip_cn.rst
data_feeder_cn.rst
executor_cn.rst
index_cn.rst
initializer_cn.rst
io_cn.rst
layers_cn.rst
metrics_cn.rst
net_cn.rst
optimizer_cn.rst
param_attr_cn.rst
profiler_cn.rst
regularizer_cn.rst
transpiler_cn.rst
doc/fluid/api_cn/initializer_cn.rst 0 → 100644
浏览文件 @ cb4f4929
###################
fluid.initializer
###################
.. _cn_api_fluid_initializer_Bilinear:
Bilinear
>>>>>>>>>>>
.. py:attribute:: paddle.fluid.initializer.Bilinear
``BilinearInitializer`` 的别名
.. _cn_api_fluid_initializer_BilinearInitializer:
BilinearInitializer
>>>>>>>>>>>>>>>>>>>>>
.. py:class:: paddle.fluid.initializer.BilinearInitializer
该初始化函数用于转置卷积函数，进行上采样。用户通过任意整型因子放大shape为(B，C，H，W)的特征图。用法如下：
**代码示例**:
.. code-block:: python
factor = 2
w_attr = ParamAttr(learning_rate=0., regularizer=L2Decay(0.),
initializer=Bilinear())
conv_up = fluid.layers.conv2d_transpose(
input,
num_filters=C,
output_size=None,
filter_size=2 * factor - factor % 2,
padding=ceil((factor - 1) / 2.),
stride=factor,
groups=C,
param_attr=w_attr,
bias_attr=False)
num_filters = C和groups = C 表示这是按通道转置的卷积函数。滤波器shape为(C,1,K,K)，K为filter_size。该初始化函数为滤波器的每个通道设置(K,K)插值核。输出特征图的最终输出shape为(B,C,factor*H,factor*W)。注意学习率和权重衰减设为0，以便在训练过程中双线性插值的系数值保持不变
.. _cn_api_fluid_initializer_Constant:
Constant
>>>>>>>>>>
.. py:attribute:: paddle.fluid.initializer.Constant
``ConstantInitializer`` 的别名
.. _cn_api_fluid_initializer_ConstantInitializer:
ConstantInitializer
>>>>>>>>>>>>
.. py:class:: paddle.fluid.initializer.ConstantInitializer(value=0.0, force_cpu=False)
常量初始器
参数：
- **value** (float) - 用常量初始化变量
**代码示例**
.. code-block:: python
fc = fluid.layers.fc(input=x, size=10,
param_attr=fluid.initializer.Constant(value=2.0))
.. _cn_api_fluid_initializer_force_init_on_cpu:
force_init_on_cpu
>>>>>>>>>>>>>>>>>>>
.. py:function:: paddle.fluid.initializer.force_init_on_cpu()
标志位，是否强制在CPU上进行变量初始化。
返回：状态，是否应强制在CPU上强制进行变量初始化
返回类型：bool
**代码示例**：
.. code-block:: python
if force_init_on_cpu():
create_op('force_cpu': force_init_on_cpu())
.. _cn_api_fluid_initializer_init_on_cpu:
init_on_cpu
>>>>>>>>>>>>
.. py:function:: paddle.fluid.initializer.init_on_cpu(*args, **kwds)
强制变量在 cpu 上初始化。
**代码示例**
.. code-block:: python
with init_on_cpu():
step = layers.create_global_var()
.. _cn_api_fluid_initializer_MSRA:
MSRA
>>>>>>
.. py:attribute:: paddle.fluid.initializer.MSRA
``MSRAInitializer`` 的别名
.. _cn_api_fluid_initializer_MSRAInitializer:
MSRAInitializer
>>>>>>>>>>>>>>>>>
.. py:class:: paddle.fluid.initializer.MSRAInitializer(uniform=True, fan_in=None, seed=0)
实现MSRA初始化（a.k.a. Kaiming初始化）
该类实现权重初始化方法，方法来自Kaiming He，Xiangyu Zhang，Shaoqing Ren 和 Jian Sun所写的论文: `Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification <https://arxiv.org/abs/1502.01852>`_ 。这是一个鲁棒性特别强的初始化方法，并且适应了非线性激活函数（rectifier nonlinearities）。
在均匀分布中，范围为[-x,x]，其中：
.. math::
x = \sqrt{\frac{6.0}{fan\_in}}
在正态分布中，均值为0，标准差为：
.. math::
\sqrt{\frac{2.0}{fan\_in}}
参数：
- **uniform** (bool) - 是否用均匀分布或正态分布
- **fan_in** (float) - MSRAInitializer的fan_in。如果为None，fan_in沿伸自变量
- **seed** (int) - 随机种子
.. note::
在大多数情况下推荐设置fan_in为None
**代码示例**：
.. code-block:: python
fc = fluid.layers.fc(
input=queries, size=10,
param_attr=fluid.initializer.MSRA(uniform=False))
.. _cn_api_fluid_initializer_Normal:
Normal
>>>>>>>>
.. py:attribute:: paddle.fluid.initializer.Normal
``NormalInitializer`` 的别名
.. _cn_api_fluid_initializer_NormalInitializer:
NormalInitializer
>>>>>>>>>>>>
.. py:class:: paddle.fluid.initializer.NormalInitializer(loc=0.0, scale=1.0, seed=0)
随机正态（高斯）分布初始化器
参数：
- **loc** （float） - 正态分布的平均值
- **scale** （float） - 正态分布的标准差
- **seed** （int） - 随机种子
**代码示例**
.. code-block:: python
fc = fluid.layers.fc(input=x, size=10,
param_attr=fluid.initializer.Normal(loc=0.0, scale=2.0)
.. _cn_api_fluid_initializer_TruncatedNormal:
TruncatedNormal
>>>>>>>>>>>>>>>>>
.. py:attribute:: paddle.fluid.initializer.TruncatedNormal
``TruncatedNormalInitializer`` 的别名
.. _cn_api_fluid_initializer_TruncatedNormalInitializer:
TruncatedNormalInitializer
>>>>>>>>>>>>
.. py:class:: paddle.fluid.initializer.TruncatedNormalInitializer(loc=0.0, scale=1.0, seed=0)
Random Truncated Normal（高斯）分布初始化器
参数：
- **loc** （float） - 正态分布的平均值
- **scale** （float） - 正态分布的标准差
- **seed** （int） - 随机种子
**代码示例**
.. code-block:: python
fc = fluid.layers.fc(input=x, size=10,
param_attr=fluid.initializer.TruncatedNormal(loc=0.0, scale=2.0))
.. _cn_api_fluid_initializer_Uniform:
Uniform
>>>>>>>>>
.. py:attribute:: paddle.fluid.initializer.Uniform
``UniformInitializer`` 的别名
.. _cn_api_fluid_initializer_UniformInitializer:
UniformInitializer
>>>>>>>>>>>>
.. py:class:: paddle.fluid.initializer.UniformInitializer(low=-1.0, high=1.0, seed=0)
随机均匀分布初始化器
参数：
- **low** (float) - 下界
- **high** (float) - 上界
- **seed** (float) - 随机种子
**代码示例**
.. code-block:: python
fc = fluid.layers.fc(input=x, size=10,
param_attr=fluid.initializer.Uniform(low=-0.5, high=0.5))
.. _cn_api_fluid_initializer_Xavier:
Xavier
>>>>>>>>>
.. py:attribute:: paddle.fluid.initializer.Xavier
``XavierInitializer`` 的别名
.. _cn_api_fluid_initializer_XavierInitializer:
XavierInitializer
>>>>>>>>>>>>>>>>>>>
.. py:class:: paddle.fluid.initializer.XavierInitializer(uniform=True, fan_in=None, fan_out=None, seed=0)
该类实现Xavier权重初始化方法（ Xavier weight initializer），Xavier权重初始化方法出自Xavier Glorot和Yoshua Bengio的论文 `Understanding the difficulty of training deep feedforward neural networks <http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf>`_
该初始化函数用于保持所有层的梯度尺度几乎一致。
在均匀分布的情况下，取值范围为[-x,x]，其中：
.. math::
x = \sqrt{\frac{6.0}{fan\_in+fan\_out}}
正态分布的情况下，均值为0，标准差为：
.. math::
x = \sqrt{\frac{2.0}{fan\_in+fan\_out}}
参数：
- **uniform** (bool) - 是否用均匀分布或者正态分布
- **fan_in** (float) - 用于Xavier初始化的fan_in。如果为None，fan_in沿伸自变量
- **fan_out** (float) - 用于Xavier初始化的fan_out。如果为None，fan_out沿伸自变量
- **seed** (int) - 随机种子
.. note::
在大多数情况下推荐将fan_in和fan_out设置为None
**代码示例**：
.. code-block:: python
fc = fluid.layers.fc(
input=queries, size=10,
param_attr=fluid.initializer.Xavier(uniform=False))
doc/fluid/api_cn/io_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#################
fluid.io
#################
.. _cn_api_fluid_io_load_inference_model:
load_inference_model
-------------------------------
.. py:class:: paddle.fluid.io.load_inference_model(dirname, executor, model_filename=None, params_filename=None, pserver_endpoints=None)
从指定目录中加载 推理model(inference model)
参数:
- **dirname** (str) – model的路径
- **executor** (Executor) – 运行 inference model的 ``executor``
- **model_filename** (str|None) – 推理 Program 的文件名称。如果设置为None，将使用默认的文件名为： ``__model__``
- **params_filename** (str|None) – 加载所有相关参数的文件名称。如果设置为None，则参数将保存在单独的文件中。
- **pserver_endpoints** (list|None) – 只有在分布式推理时需要用到。 当在训练时使用分布式 look up table , 需要这个参数. 该参数是 pserver endpoints 的列表
返回: 这个函数的返回有三个元素的元组(Program，feed_target_names, fetch_targets)。Program 是一个 ``Program`` ，它是推理 ``Program``。 ``feed_target_names`` 是一个str列表，它包含需要在推理 ``Program`` 中提供数据的变量的名称。` `fetch_targets`` 是一个 ``Variable`` 列表，从中我们可以得到推断结果。
返回类型：元组(tuple)
抛出异常：
- ``ValueError`` – 如果 ``dirname`` 非法
.. code-block:: python
exe = fluid.Executor(fluid.CPUPlace())
path = "./infer_model"
endpoints = ["127.0.0.1:2023","127.0.0.1:2024"]
[inference_program, feed_target_names, fetch_targets] =
fluid.io.load_inference_model(dirname=path, executor=exe)
results = exe.run(inference_program,
feed={feed_target_names[0]: tensor_img},
fetch_list=fetch_targets)
# 在这个示例中，inference program 保存在 ./infer_model/__model__”中
# 参数保存在./infer_mode 单独的若干文件中
# 加载 inference program 后， executor 使用 fetch_targets 和 feed_target_names 执行Program， 得到推理结果
.. _cn_api_fluid_io_load_params:
load_params
-------------------------------
.. py:class:: paddle.fluid.io.load_params(executor, dirname, main_program=None, filename=None)
该函数过滤掉 给定 ``main_program`` 中所有参数，然后将它们加载保存在到目录 ``dirname`` 中或文件中的参数。
``dirname`` 用于指定保存变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用filename来指定它
注意:有些变量不是参数，但它们对于训练是必要的。因此，您不能仅通过 ``save_params()`` 和 ``load_params()`` 保存并之后继续训练。可以使用 ``save_persistables()`` 和 ``load_persistables()`` 代替这两个函数
参数:
- **executor** (Executor) – 加载变量的 executor
- **dirname** (str) – 目录路径
- **main_program** (Program|None) – 需要加载变量的 Program。如果为 None，则使用 default_main_Program 。默认值: None
- **filename** (str|None) – 保存变量的文件。如果想分开保存变量，设置 filename=None. 默认值: None
返回: None
**代码示例**
.. code-block:: python
exe = fluid.Executor(fluid.CPUPlace())
param_path = "./my_paddle_model"
prog = fluid.default_main_program()
fluid.io.load_params(executor=exe, dirname=param_path,
main_program=None)
.. _cn_api_fluid_io_load_persistables:
load_persistables
-------------------------------
.. py:class:: paddle.fluid.io.load_persistables(executor, dirname, main_program=None, filename=None)
该函数过滤掉 给定 ``main_program`` 中所有参数，然后将它们加载保存在到目录 ``dirname`` 中或文件中的参数。
``dirname`` 用于指定保存变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用filename来指定它
参数:
- **executor** (Executor) – 加载变量的 executor
- **dirname** (str) – 目录路径
- **main_program** (Program|None) – 需要加载变量的 Program。如果为 None，则使用 default_main_Program 。默认值: None
- **filename** (str|None) – 保存变量的文件。如果想分开保存变量，设置 filename=None. 默认值: None
返回: None
**代码示例**
.. code-block:: python
exe = fluid.Executor(fluid.CPUPlace())
param_path = "./my_paddle_model"
prog = fluid.default_main_program()
fluid.io.load_persistables(executor=exe, dirname=param_path,
main_program=None)
.. _cn_api_fluid_io_load_vars:
load_vars
-------------------------------
.. py:class:: paddle.fluid.io.load_vars(executor, dirname, main_program=None, vars=None, predicate=None, filename=None)
``executor`` 从指定目录加载变量。
有两种方法来加载变量:方法一，``vars`` 为变量的列表。方法二，将已存在的 ``Program`` 赋值给 ``main_program`` ，然后将加载 ``Program`` 中的所有变量。第一种方法优先级更高。如果指定了 vars，那么忽略 ``main_program`` 和 ``predicate`` 。
``dirname`` 用于指定加载变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用 ``filename`` 来指定它
参数:
- **executor** (Executor) – 加载变量的 executor
- **dirname** (str) – 目录路径
- **main_program** (Program|None) – 需要加载变量的 Program。如果为 None，则使用 default_main_Program 。默认值: None
- **vars** (list[Variable]|None) – 要加载的变量的列表。 优先级高于main_program。默认值: None
- **predicate** (function|None) – 如果不等于None，当指定main_program， 那么只有 predicate(variable)==True 时，main_program中的变量会被加载。
- **filename** (str|None) – 保存变量的文件。如果想分开保存变量，设置 filename=None. 默认值: None
抛出异常：
- ``TypeError`` - 如果参数 ``main_program`` 为 None 或为一个非 ``Program`` 的实例
返回: None
**代码示例**
.. code-block:: python
exe = fluid.Executor(fluid.CPUPlace())
param_path = "./my_paddle_model"
# 第一种使用方式 使用 main_program 指定变量
def name_has_fc(var):
res = "fc" in var.name
return res
prog = fluid.default_main_program()
fluid.io.load_vars(executor=exe, dirname=path, main_program=prog,
vars=None, predicate=name_has_fc)
#加载所有`main_program`中变量名包含 ‘fc’ 的变量
#并且此前所有变量应该保存在不同文件中
#用法2：使用 `vars` 列表来指明变量
var_list = [var_a, var_b, var_c]
fluid.io.load_vars(executor=exe, dirname=path, vars=var_list,
filename="vars_file")
# 加载 var_a ， var_b ， var_c .它们此前应被保存在同一文件中
# 文件名为 'var_file' ，路径为 "./my_paddle_model".
.. _cn_api_fluid_io_save_inference_model:
save_inference_model
-------------------------------
.. py:class:: paddle.fluid.io.save_inference_model(dirname, feeded_var_names, target_vars, executor, main_program=None, model_filename=None, params_filename=None, export_for_deployment=True)
修改指定的 ``main_program`` ，构建一个专门用于推理的 ``Program``，然后 ``executor`` 把它和所有相关参数保存到 ``dirname`` 中
``dirname`` 用于指定保存变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用filename来指定它
参数:
- **dirname** (str) – 保存推理model的路径
- **feeded_var_names** (list[str]) – 推理（inference）需要 feed 的数据
- **target_vars** (list[Variable]) – 保存推理（inference）结果的 Variables
- **executor** (Executor) – executor 保存 inference model
- **main_program** (Program|None) – 使用 ``main_program`` ，构建一个专门用于推理的 ``Program`` （inference model）. 如果为None, 使用 ``default main program`` 默认: None.
- **model_filename** (str|None) – 保存 推理P rogram 的文件名称。如果设置为None，将使用默认的文件名为： ``__model__``
- **params_filename** (str|None) – 保存所有相关参数的文件名称。如果设置为None，则参数将保存在单独的文件中。
- **export_for_deployment** (bool) – 如果为真，Program将被修改为只支持直接推理部署的Program。否则，将存储更多的信息，方便优化和再训练。目前只支持True。
返回: None
抛出异常：
- ``ValueError`` – 如果 ``feed_var_names`` 不是字符串列表
- ``ValueError`` – 如果 ``target_vars`` 不是 ``Variable`` 列表
**代码示例**
.. code-block:: python
exe = fluid.Executor(fluid.CPUPlace())
path = "./infer_model"
fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'],
target_vars=[predict_var], executor=exe)
# 在这个示例中，函数将修改默认的主程序让它适合于推断‘predict_var’。修改的
# 推理Program 将被保存在 ./infer_model/__model__”中。
# 和参数将保存在文件夹下的单独文件中 ./infer_mode
.. _cn_api_fluid_io_save_params:
save_params
-------------------------------
.. py:class:: paddle.fluid.io.save_params(executor, dirname, main_program=None, filename=None)
该函数过滤掉 给定 ``main_program`` 中所有参数，然后将它们保存到目录 ``dirname`` 中或文件中。
``dirname`` 用于指定保存变量的目录。如果想将变量保存到指定目录的若干文件中，设置文件名 None; 如果想将所有变量保存在一个文件中，请使用filename来指定它
注意:有些变量不是参数，但它们对于训练是必要的。因此，您不能仅通过 ``save_params()`` 和 ``load_params()`` 保存并之后继续训练。可以使用 ``save_persistables()`` 和 ``load_persistables()`` 代替这两个函数
参数:
- **executor** (Executor) – 保存变量的 executor
- **dirname** (str) – 目录路径
- **main_program** (Program|None) – 需要保存变量的 Program。如果为 None，则使用 default_main_Program 。默认值: None
- **vars** (list[Variable]|None) – 要保存的所有变量的列表。 优先级高于main_program。默认值: None
- **filename** (str|None) – 保存变量的文件。如果想分开保存变量，设置 filename=None. 默认值: None
返回: None
**代码示例**
.. code-block:: python
exe = fluid.Executor(fluid.CPUPlace())
param_path = "./my_paddle_model"
prog = fluid.default_main_program()
fluid.io.save_params(executor=exe, dirname=param_path,
main_program=None)
.. _cn_api_fluid_io_save_persistables:
save_persistables
-------------------------------
.. py:class:: paddle.fluid.io.save_persistables(executor, dirname, main_program=None, filename=None)
该函数过滤掉 给定 ``main_program`` 中所有参数，然后将它们保存到目录 ``dirname`` 中或文件中。
``dirname`` 用于指定保存变量的目录。如果想将变量保存到指定目录的若干文件中，设置 ``filename=None`` ; 如果想将所有变量保存在一个文件中，请使用 ``filename`` 来指定它
参数:
- **executor** (Executor) – 保存变量的 executor
- **dirname** (str) – 目录路径
- **main_program** (Program|None) – 需要保存变量的 Program。如果为 None，则使用 default_main_Program 。默认值: None
- **predicate** (function|None) – 如果不等于None，当指定main_program， 那么只有 predicate(variable)==True 时，main_program中的变量
- **vars** (list[Variable]|None) – 要保存的所有变量的列表。 优先级高于main_program。默认值: None
- **filename** (str|None) – 保存变量的文件。如果想分开保存变量，设置 filename=None. 默认值: None
返回: None
**代码示例**
.. code-block:: python
exe = fluid.Executor(fluid.CPUPlace())
param_path = "./my_paddle_model"
prog = fluid.default_main_program()
fluid.io.save_persistables(executor=exe, dirname=param_path,
main_program=None)
.. _cn_api_fluid_io_save_vars:
save_vars
-------------------------------
.. py:class:: paddle.fluid.io.save_vars(executor, dirname, main_program=None, vars=None, predicate=None, filename=None)
通过 ``Executor`` ,此函数将变量保存到指定目录下。
有两种方法可以指定要保存的变量：第一种方法，在列表中列出变量并将其传给 ``vars`` 参数。第二种方法是，将现有程序分配给 ``main_program`` ，它会保存program中的所有变量。第一种方式具有更高的优先级。换句话说，如果分配了变量，则将忽略 ``main_program`` 和 ``predicate`` 。
``dirname`` 用于指定保存变量的文件夹。如果您希望将变量分别保存在文件夹目录的多个单独文件中，请设置 ``filename`` 为无；如果您希望将所有变量保存在单个文件中，请使用 ``filename`` 指定它。
参数：
- **executor** （Executor）- 为保存变量而运行的执行器。
- **dirname** （str）- 目录路径。
- **main_program** （Program | None）- 保存变量的程序。如果为None，将自动使用默认主程序。默认值：None。
- **vars** （list [Variable] | None）- 包含要保存的所有变量的列表。它的优先级高于 ``main_program`` 。默认值：None。
- **predicate** （function | None）- 如果它不是None，则只保存 ``main_program`` 中使 :math:`predicate(variable)== True` 的变量。它仅在我们使用 ``main_program`` 指定变量时才起作用（换句话说，vars为None）。默认值：None。
- **filename** （str | None）- 保存所有变量的文件。如果您希望单独保存变量，请将其设置为None。默认值：None。
返回： None
抛出异常：
- ``TypeError`` - 如果main_program不是Program的实例，也不是None。
**代码示例**
.. code-block:: python
exe = fluid.Executor(fluid.CPUPlace())
param_path = "./my_paddle_model"
# 第一种用法:用main_program来指定变量。
def name_has_fc(var):
res = "fc" in var.name
return res
prog = fluid.default_main_program()
fluid.io.save_vars(executor=exe, dirname=path, main_program=prog,
vars=None, predicate = name_has_fc)
# 将main_program中名中包含“fc”的的所有变量保存。
# 变量将分开保存。
# 第二种用法: 用vars来指定变量。
var_list = [var_a, var_b, var_c]
fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
filename="vars_file")
# var_a，var_b和var_c将被保存。 他们将使用同一文件，名为“var_file”，保存在路径“./my_paddle_model”下。
doc/fluid/api_cn/layers_cn.rst 0 → 100644
浏览文件 @ cb4f4929
因为 它太大了无法显示 source diff 。你可以改为 查看blob。
doc/fluid/api_cn/metrics_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#################
fluid.metrics
#################
.. _cn_api_fluid_metrics_Accuracy:
Accuracy
-------------------------------
.. py:class:: paddle.fluid.metrics.Accuracy(name=None)
累加mini-batch正确率，计算每次pass的平均准确率。https://en.wikipedia.org/wiki/Accuracy_and_precision
参数:
- **name** — 度量标准的名称
**代码示例**
.. code-block:: python
labels = fluid.layers.data(name="data", shape=[1], dtype="int32")
data = fluid.layers.data(name="data", shape=[32, 32], dtype="int32")
pred = fluid.layers.fc(input=data, size=1000, act="tanh")
minibatch_accuracy = fluid.layers.accuracy(pred, label)
accuracy_evaluator = fluid.metrics.Accuracy()
for pass in range(PASSES):
accuracy_evaluator.reset()
for data in train_reader():
batch_size = data[0]
loss = exe.run(fetch_list=[cost, minibatch_accuracy])
accuracy_evaluator.update(value=minibatch_accuracy, weight=batch_size)
numpy_acc = accuracy_evaluator.eval()
.. py:method:: update(value, weight)
更新mini batch的状态.
参数：
- **value** (float|numpy.array) – 每个mini batch的正确率
- **weight** (int|float) – batch 大小
.. _cn_api_fluid_metrics_Auc:
Auc
-------------------------------
.. py:class:: paddle.fluid.metrics.Auc(name, curve='ROC', num_thresholds=4095)
Auc度量适用于二分类。参考 https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve 。需要注意auc度量本身是用Python计算值。如果关心速度，请用fluid.layers.auc。
auc函数创建四个局部变量true_positives, true_negatives, false_positives和false_negatives，用于计算AUC。对于离散化AUC曲线，临界值线性间隔设置以便计算召回率和准确率的值，用false positive率的召回值高度计算ROC曲线面积，用recall的准确值高度计算PR曲线面积。
参数：
- **name** - 度量名
- **curve** - 将要计算的曲线名的详情，曲线包括ROC（默认）或者PR（Precision-Recall-curve）。
注：目前只用Python实现ROC曲线
**代码示例**：
.. code-block:: python
pred = fluid.layers.fc(input=data, size=1000, act="tanh")
metric = fluid.metrics.Auc()
for data in train_reader():
loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
metric.update(preds, labels)
numpy_auc = metric.eval()
.. _cn_api_fluid_metrics_ChunkEvaluator:
ChunkEvaluator
-------------------------------
.. py:class:: paddle.fluid.metrics.ChunkEvaluator(name=None)
用mini-batch的chunk_eval累计counter numbers，用累积的counter numbers计算准确率、召回率和F1值。对于chunking的基础知识，请参考 .. _Chunking with Support Vector Machines: https://aclanthology.info/pdf/N/N01/N01-1025.pdf 。ChunkEvalEvaluator计算块检测（chunk detection）的准确率，召回率和F1值，支持IOB, IOE, IOBES和IO标注方案。
**代码示例**：
.. code-block:: python
labels = fluid.layers.data(name="data", shape=[1], dtype="int32")
data = fluid.layers.data(name="data", shape=[32, 32], dtype="int32")
pred = fluid.layers.fc(input=data, size=1000, act="tanh")
precision, recall, f1_score, num_infer_chunks, num_label_chunks, num_correct_chunks = layers.chunk_eval(
input=pred,
label=label)
metric = fluid.metrics.ChunkEvaluator()
for data in train_reader():
loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
metric.update(num_infer_chunks, num_label_chunks, num_correct_chunks)
numpy_precision, numpy_recall, numpy_f1 = metric.eval()
.. py:method:: update(num_infer_chunks, num_label_chunks, num_correct_chunks)
基于layers.chunk_eval()输出更新状态（state)输出
参数:
- **num_infer_chunks** (int|numpy.array): 给定minibatch的Interface块数。
- **num_label_chunks** (int|numpy.array): 给定minibatch的Label块数。
- **num_correct_chunks** （int|numpy.array）: 给定minibatch的Interface和Label的块数
.. _cn_api_fluid_metrics_CompositeMetric:
CompositeMetric
-------------------------------
.. py:class:: paddle.fluid.metrics.CompositeMetric(name=None)
在一个实例中组合多个指标。例如，将F1、准确率、召回率合并为一个指标。
**代码示例**
.. code-block:: python
labels = fluid.layers.data(name="data", shape=[1], dtype="int32")
data = fluid.layers.data(name="data", shape=[32, 32], dtype="int32")
pred = fluid.layers.fc(input=data, size=1000, act="tanh")
comp = fluid.metrics.CompositeMetric()
acc = fluid.metrics.Precision()
recall = fluid.metrics.Recall()
comp.add_metric(acc)
comp.add_metric(recall)
for pass in range(PASSES):
comp.reset()
for data in train_reader():
loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
comp.update(preds=preds, labels=labels)
numpy_acc, numpy_recall = comp.eval()
.. py:method:: add_metric(metric)
向CompositeMetric添加一个度量指标
参数:
- **metric** – MetricBase的一个实例。
.. py:method:: update(preds, labels)
更新序列中的每个指标。
参数:
- **preds** (numpy.array) - 当前mini batch的预测
- **labels** (numpy.array) - 当前minibatch的label，如果标签是one-hot或soft-laebl 编码，应该自定义相应的更新规则。
.. py:method:: eval()
按顺序评估每个指标。
返回：Python中的度量值列表。
返回类型：list（float | numpy.array）
.. _cn_api_fluid_metrics_DetectionMAP:
DetectionMAP
-------------------------------
.. py:class:: paddle.fluid.metrics.DetectionMAP(name=None)
计算 detection 平均精度（mAP）。 mAP是衡量object detectors精度的指标，比如 Faster R-CNN,SSD等。它不同于召回率，它是最大精度的平均值。 请从以下文章中获取更多信息：
https://sanchom.wordpress.com/tag/average-precision/
https://arxiv.org/abs/1512.02325
通常步骤如下：
1. 根据detectors中的输入和label，计算 true positive 和 false positive
2. 计算map，支持 ‘11 point’ and ‘integral’
**代码示例**
.. code-block:: python
pred = fluid.layers.fc(input=data, size=1000, act="tanh")
batch_map = layers.detection_map(
input,
label,
class_num,
background_label,
overlap_threshold=overlap_threshold,
evaluate_difficult=evaluate_difficult,
ap_version=ap_version)
metric = fluid.metrics.DetectionMAP()
for data in train_reader():
loss, preds, labels = exe.run(fetch_list=[cost, batch_map])
batch_size = data[0]
metric.update(value=batch_map, weight=batch_size)
numpy_map = metric.eval()
.. _cn_api_fluid_metrics_EditDistance:
EditDistance
-------------------------------
.. py:class:: paddle.fluid.metrics.EditDistance(name)
编辑距离是通过计算将一个字符串转换为另一个字符串所需的最小操作数来量化两个字符串(例如单词)之间的差异的一种方法。参考 https://en.wikipedia.org/wiki/Edit_distance
从mini batch中累计编辑距离和序列号，计算所有batch的平均编辑距离和实例错误。
参数:
- **name** - 度量标准名称
**代码示例**
.. code-block:: python
distances, seq_num = fluid.layers.edit_distance(input, label)
distance_evaluator = fluid.metrics.EditDistance()
for epoch in PASS_NUM:
distance_evaluator.reset()
for data in batches:
loss = exe.run(fetch_list=[cost] + list(edit_distance_metrics))
distance_evaluator.update(distances, seq_num)
distance, instance_error = distance_evaluator.eval()
在上面的例子中：'distance'是一个pass中的编辑距离的平均值。 'instance_error'是一个pass中的实例的错误率。
.. _cn_api_fluid_metrics_MetricBase:
MetricBase
-------------------------------
.. py:class:: paddle.fluid.metrics.MetricBase(name)
所有Metrics的基类。MetricBase为模型估计方法定义一组接口。Metrics累积连续的两个minibatch之间的度量状态，对每个minibatch用最新接口将当前minibatch值添加到全局状态。用eval函数来计算last reset()或者scratch on()中累积的度量值。如果需要定制一个新的metric，请继承自MetricBase和自定义实现类。
参数：
- **name** (str) - metric实例名。例如准确率（accuracy）。如果想区分一个模型里不同的metrics，则需要实例名。
.. py:method:: reset()
reset()清除度量（metric）的状态（state）。默认情况下，状态（state）包含没有 ``_`` 前缀的metric。reset将这些状态设置为初始状态。如果不想使用隐式命名规则，请自定义reset接口。
.. py:method:: get_config()
获取度量（metric)状态和当前状态。状态（state）包含没有 ``_`` 前缀的成员。
参数：**None**
返回：metric对应到state的字典
返回类型：字典（dict）
.. py:method:: update(preds,labels)
更新每个minibatch的度量状态（metric states），用户可通过Python或者C++操作符计算minibatch度量值（metric）。
参数：
- **preds** (numpy.array) - 当前minibatch的预测
- **labels** (numpy.array) - 当前minibatch的标签，如果标签为one-hot或者soft-label，应该自定义相应的更新规则。
.. py:method:: eval()
基于累积状态（accumulated states）评估当前度量（current metric）。
返回：metrics（Python中）
返回类型：float|list(float)|numpy.array
.. _cn_api_fluid_metrics_Precision:
Precision
-------------------------------
.. py:class:: paddle.fluid.metrics.Precision(name=None)
Precision(也称为 positive predictive value,正预测值)是被预测为正样例中实际为正的比例。https://en.wikipedia.org/wiki/Evaluation_of_binary_classifiers
注:二分类中，Precision与Accuracy不同,
.. math::
Accuracy & = \frac{true \quad positive}{total \quad instances(所有样例)} \\\\
Precision & = \frac{true \quad positive}{all \quad positive \quad instances(所有正样例)}
**代码示例**
.. code-block:: python
metric = fluid.metrics.Precision()
for pass in range(PASSES):
metric.reset()
for data in train_reader():
loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
metric.update(preds=preds, labels=labels)
numpy_precision = metric.eval()
.. _cn_api_fluid_metrics_Recall:
Recall
-------------------------------
.. py:class:: paddle.fluid.metrics.Recall(name=None)
召回率（也称为敏感度）是度量有多个正例被分为正例
https://en.wikipedia.org/wiki/Precision_and_recall
**代码示例**
.. code-block:: python
metric = fluid.metrics.Recall()
for pass in range(PASSES):
metric.reset()
for data in train_reader():
loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
metric.update(preds=preds, labels=labels)
numpy_recall = metric.eval()
doc/fluid/api_cn/net_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#################
fluid.nets
#################
.. _cn_api_fluid_nets_glu:
glu
>>>>
.. py:function:: paddle.fluid.nets.glu(input, dim=-1)
T
he Gated Linear Units(GLU)由切分（split），sigmoid激活函数和按元素相乘组成。沿着给定维将input拆分成两个大小相同的部分，a和b，计算如下：
.. math::
GLU(a,b) = a\bigotimes \sigma (b)
参考论文: `Language Modeling with Gated Convolutional Networks <https://arxiv.org/pdf/1612.08083.pdf>`_
参数：
- **input** (Variable) - 输入变量，张量或者LoDTensor
- **dim** (int) - 拆分的维度。如果 :math:`dim<0`，拆分的维为 :math:`rank(input)+dim`。默认为-1
返回：变量 —— 变量的大小为输入的一半
返回类型：变量（Variable）
**代码示例：**
.. code-block:: python
data = fluid.layers.data(name="words", shape=[3, 6, 9], dtype="float32")
output = fluid.nets.glu(input=data, dim=1) # shape of output: [3, 3, 9]
英文版API文档: :ref:`api_fluid_nets_glu`
.. _cn_api_fluid_nets_img_conv_group:
img_conv_group
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
.. py:function:: paddle.fluid.nets.img_conv_group(input, conv_num_filter, pool_size, conv_padding=1, conv_filter_size=3, conv_act=None, param_attr=None, conv_with_batchnorm=False, conv_batchnorm_drop_rate=0.0, pool_stride=1, pool_type='max', use_cudnn=True)
Image Convolution Group由Convolution2d，BatchNorm，DropOut和Pool2d组成。根据输入参数，img_conv_group将使用Convolution2d，BatchNorm，DropOut对Input进行连续计算，并将最后一个结果传递给Pool2d。
参数：
- **input** （Variable） - 具有[N，C，H，W]格式的输入图像。
- **conv_num_filter** （list | tuple） - 表示该组的过滤器数。
- **pool_size** （int | list | tuple） - ``Pool2d Layer`` 池的大小。如果pool_size是列表或元组，则它必须包含两个整数（pool_size_H，pool_size_W）。否则，pool_size_H = pool_size_W = pool_size。
- **conv_padding** （int | list | tuple） - Conv2d Layer的 ``padding`` 大小。如果 ``padding`` 是列表或元组，则其长度必须等于 ``conv_num_filter`` 的长度。否则，所有Conv2d图层的 ``conv_padding`` 都是相同的。默认1。
- **conv_filter_size** （int | list | tuple） - 过滤器大小。如果filter_size是列表或元组，则其长度必须等于 ``conv_num_filter`` 的长度。否则，所有Conv2d图层的 ``conv_filter_size`` 都是相同的。默认3。
- **conv_act** （str） - ``Conv2d Layer`` 的激活类型， ``BatchNorm`` 后面没有。默认值：无。
- **param_attr** （ParamAttr） - Conv2d层的参数。默认值：无
- **conv_with_batchnorm** （bool | list） - 表示在 ``Conv2d Layer`` 之后是否使用 ``BatchNorm`` 。如果 ``conv_with_batchnorm`` 是一个列表，则其长度必须等于 ``conv_num_filter`` 的长度。否则， ``conv_with_batchnorm`` 指示是否所有Conv2d层都遵循 ``BatchNorm``。默认为False。
- **conv_batchnorm_drop_rate** （float | list） - 表示 ``BatchNorm`` 之后的 ``Dropout Layer`` 的 ``rop_rate`` 。如果 ``conv_batchnorm_drop_rate`` 是一个列表，则其长度必须等于 ``conv_num_filter`` 的长度。否则，所有 ``Dropout Layers`` 的 ``drop_rate`` 都是 ``conv_batchnorm_drop_rate`` 。默认值为0.0。
- **pool_stride** （int | list | tuple） - ``Pool2d`` 层的汇集步幅。如果 ``pool_stride`` 是列表或元组，则它必须包含两个整数（pooling_stride_H，pooling_stride_W）。否则，pooling_stride_H = pooling_stride_W = pool_stride。默认1。
- **pool_type** （str） - 池化类型可以是最大池化的 ``max`` 和平均池化的 ``avg`` 。默认max。
- **use_cudnn** （bool） - 是否使用cudnn内核，仅在安装cudnn库时才有效。默认值：True
返回： 使用Convolution2d进行串行计算后的最终结果，BatchNorm，DropOut和Pool2d。
返回类型： 变量（Variable）。
**代码示例**
.. code-block:: python
img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
conv_pool = fluid.nets.img_conv_group(input=img,
num_channels=3,
conv_padding=1,
conv_num_filter=[3, 3],
conv_filter_size=3,
conv_act="relu",
pool_size=2,
pool_stride=2)
英文版API文档: :ref:`api_fluid_nets_img_conv_group`
.. _cn_api_fluid_nets_scaled_dot_product_attention:
scaled_dot_product_attention
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
.. py:function:: paddle.fluid.nets.scaled_dot_product_attention(queries, keys, values, num_heads=1, dropout_rate=0.0)
点乘attention运算。
attention运算机制可以被视为将查询和一组键值对映射到输出。 将输出计算为值的加权和，其中分配给每个值的权重由查询的兼容性函数（此处的点积）与对应的密钥计算。
可以通过（batch）矩阵乘法实现点积attention运算，如下所示：
.. math::
Attention(Q, K, V)= softmax(QK^\mathrm{T})V
请参阅 `Attention Is All You Need <https://arxiv.org/pdf/1706.03762.pdf>`_
参数：
- **queries** （Variable） - 输入变量，应为3-D Tensor。
- **keys** （Variable） - 输入变量，应为3-D Tensor。
- **values** （Variable） - 输入变量，应为3-D Tensor。
- **num_heads** （int） - 计算缩放点积attention运算的head数。默认值：1。
- **dropout_rate** （float） - 降低attention的dropout率。默认值：0.0。
返回： 通过multi-head来缩放点积attention运算的三维张量。
返回类型： 变量（Variable）。
抛出异常:
- ``ValueError`` - 如果输入查询键，值不是3-D Tensor会报错。
.. note::
当num_heads> 1时，分别学习三个线性投影，以将输入查询，键和值映射到查询'，键'和值'。 查询'，键'和值'与查询，键和值具有相同的形状。
当num_heads == 1时，scaled_dot_product_attention没有可学习的参数。
**代码示例**
.. code-block:: python
queries = fluid.layers.data(name="queries",
shape=[3, 5, 9],
dtype="float32",
append_batch_size=False)
queries.stop_gradient = False
keys = fluid.layers.data(name="keys",
shape=[3, 6, 9],
dtype="float32",
append_batch_size=False)
keys.stop_gradient = False
values = fluid.layers.data(name="values",
shape=[3, 6, 10],
dtype="float32",
append_batch_size=False)
values.stop_gradient = False
contexts = fluid.nets.scaled_dot_product_attention(queries, keys, values)
contexts.shape # [3, 5, 10]
英文版API文档: :ref:`api_fluid_nets_scaled_dot_product_attention`
.. _cn_api_fluid_nets_sequence_conv_pool:
sequence_conv_pool
>>>>>>>>>>>>>>>>>>>
.. py:function:: paddle.fluid.nets.sequence_conv_pool(input, num_filters, filter_size, param_attr=None, act='sigmoid', pool_type='max')
sequence_conv_pool由序列卷积和池化组成
参数：
- **input** (Variable) - sequence_conv的输入，支持变量时间长度输入序列。当前输入为shape为（T，N）的矩阵，T是mini-batch中的总时间步数，N是input_hidden_size
- **num_filters** （int）- 滤波器数
- **filter_size** （int）- 滤波器大小
- **param_attr** （ParamAttr) - Sequence_conv层的参数。默认：None
- **act** （str） - Sequence_conv层的激活函数类型。默认：sigmoid
- **pool_type** （str）- 池化类型。可以是max-pooling的max，average-pooling的average，sum-pooling的sum，sqrt-pooling的sqrt。默认max
返回：序列卷积（Sequence Convolution）和池化（Pooling）的结果
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
input_dim = len(word_dict)
emb_dim = 128
hid_dim = 512
data = fluid.layers.data( ame="words", shape=[1], dtype="int64", lod_level=1)
emb = fluid.layers.embedding(input=data, size=[input_dim, emb_dim], is_sparse=True)
seq_conv = fluid.nets.sequence_conv_pool(input=emb,
num_filters=hid_dim,
filter_size=3,
act="tanh",
pool_type="sqrt")
英文版API文档: :ref:`api_fluid_nets_sequence_conv_pool`
.. _cn_api_fluid_nets_simple_img_conv_pool:
simple_img_conv_pool
>>>>>>>>>>>>>>>>>>>>>>>>>
.. py:function:: paddle.fluid.nets.simple_img_conv_pool(input, num_filters, filter_size, pool_size, pool_stride, pool_padding=0, pool_type='max', global_pooling=False, conv_stride=1, conv_padding=0, conv_dilation=1, conv_groups=1, param_attr=None, bias_attr=None, act=None, use_cudnn=True)
``simple_img_conv_pool`` 由一个Convolution2d和一个Pool2d组成。
参数：
- **input** （Variable） - 输入图像的格式为[N，C，H，W]。
- **num_filters** （int） - ``filter`` 的数量。它与输出的通道相同。
- **filter_size** （int | list | tuple） - 过滤器大小。如果 ``filter_size`` 是列表或元组，则它必须包含两个整数（filter_size_H，filter_size_W）。否则，filter_size_H = filter_size_W = filter_size。
- **pool_size** （int | list | tuple） - Pool2d池化层大小。如果pool_size是列表或元组，则它必须包含两个整数（pool_size_H，pool_size_W）。否则，pool_size_H = pool_size_W = pool_size。
- **pool_stride** （int | list | tuple） - Pool2d池化层步长。如果pool_stride是列表或元组，则它必须包含两个整数（pooling_stride_H，pooling_stride_W）。否则，pooling_stride_H = pooling_stride_W = pool_stride。
- **pool_padding** （int | list | tuple） - Pool2d池化层的padding。如果pool_padding是列表或元组，则它必须包含两个整数（pool_padding_H，pool_padding_W）。否则，pool_padding_H = pool_padding_W = pool_padding。默认值为0。
- **pool_type** （str） - 池化类型可以是 ``max-pooling`` 的 ``max`` 和平均池的 ``avg`` 。默认 ``max`` 。
- **global_pooling** （bool）- 是否使用全局池。如果global_pooling = true，则忽略pool_size和pool_padding。默认为False
- **conv_stride** （int | list | tuple） - conv2d Layer的步长。如果stride是列表或元组，则它必须包含两个整数，（conv_stride_H，conv_stride_W）。否则，conv_stride_H = conv_stride_W = conv_stride。默认值：conv_stride = 1。
- **conv_padding** （int | list | tuple） - conv2d Layer的padding大小。如果padding是列表或元组，则它必须包含两个整数（conv_padding_H，conv_padding_W）。否则，conv_padding_H = conv_padding_W = conv_padding。默认值：conv_padding = 0。
- **conv_dilation** （int | list | tuple） - conv2d Layer的dilation大小。如果dilation是列表或元组，则它必须包含两个整数（conv_dilation_H，conv_dilation_W）。否则，conv_dilation_H = conv_dilation_W = conv_dilation。默认值：conv_dilation = 1。
- **conv_groups** （int） - conv2d Layer的组数。根据Alex Krizhevsky的Deep CNN论文中的分组卷积：当group = 2时，前半部分滤波器仅连接到输入通道的前半部分，而后半部分滤波器仅连接到后半部分输入通道。默认值：groups = 1。
- **param_attr** （ParamAttr | None） - 可学习参数的参数属性或conv2d权重。如果将其设置为None或ParamAttr的一个属性，则conv2d将创建ParamAttr作为param_attr。如果未设置param_attr的初始化，则使用 :math:`Normal（0.0，std）` 初始化参数，并且 ``std`` 为 :math:`(\frac{2.0 }{filter\_elem\_num})^{0.5}` 。默认值:None
- **bias_attr** （ParamAttr | bool | None） - conv2d的bias参数属性。如果设置为False，则不会向输出单元添加bias。如果将其设置为None或ParamAttr的一个属性，则conv2d将创建ParamAttr作为bias_attr。如果未设置bias_attr的初始化程序，则将偏差初始化为零。默认值：None
- **act** （str） - conv2d的激活类型，如果设置为None，则不附加激活。默认值：无。
- **use_cudnn** （bool） - 是否使用cudnn内核，仅在安装cudnn库时才有效。默认值：True。
返回： Convolution2d和Pool2d之后输入的结果。
返回类型： 变量（Variable）
**示例代码**
.. code-block:: python
img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
conv_pool = fluid.nets.simple_img_conv_pool(input=img,
filter_size=5,
num_filters=20,
pool_size=2,
pool_stride=2,
act="relu")
英文版API文档: :ref:`api_fluid_nets_simple_img_conv_pool`
doc/fluid/api_cn/nets_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#################
fluid.nets
#################
.. _cn_api_fluid_nets_glu:
glu
-------------------------------
.. py:function:: paddle.fluid.nets.glu(input, dim=-1)
T
he Gated Linear Units(GLU)由切分（split），sigmoid激活函数和按元素相乘组成。沿着给定维将input拆分成两个大小相同的部分，a和b，计算如下：
.. math::
GLU(a,b) = a\bigotimes \sigma (b)
参考论文: `Language Modeling with Gated Convolutional Networks <https://arxiv.org/pdf/1612.08083.pdf>`_
参数：
- **input** (Variable) - 输入变量，张量或者LoDTensor
- **dim** (int) - 拆分的维度。如果 :math:`dim<0`，拆分的维为 :math:`rank(input)+dim`。默认为-1
返回：变量 —— 变量的大小为输入的一半
返回类型：变量（Variable）
**代码示例：**
.. code-block:: python
data = fluid.layers.data(name="words", shape=[3, 6, 9], dtype="float32")
output = fluid.nets.glu(input=data, dim=1) # shape of output: [3, 3, 9]
.. _cn_api_fluid_nets_img_conv_group:
img_conv_group
-------------------------------
.. py:function:: paddle.fluid.nets.img_conv_group(input, conv_num_filter, pool_size, conv_padding=1, conv_filter_size=3, conv_act=None, param_attr=None, conv_with_batchnorm=False, conv_batchnorm_drop_rate=0.0, pool_stride=1, pool_type='max', use_cudnn=True)
Image Convolution Group由Convolution2d，BatchNorm，DropOut和Pool2d组成。根据输入参数，img_conv_group将使用Convolution2d，BatchNorm，DropOut对Input进行连续计算，并将最后一个结果传递给Pool2d。
参数：
- **input** （Variable） - 具有[N，C，H，W]格式的输入图像。
- **conv_num_filter** （list | tuple） - 表示该组的过滤器数。
- **pool_size** （int | list | tuple） - ``Pool2d Layer`` 池的大小。如果pool_size是列表或元组，则它必须包含两个整数（pool_size_H，pool_size_W）。否则，pool_size_H = pool_size_W = pool_size。
- **conv_padding** （int | list | tuple） - Conv2d Layer的 ``padding`` 大小。如果 ``padding`` 是列表或元组，则其长度必须等于 ``conv_num_filter`` 的长度。否则，所有Conv2d图层的 ``conv_padding`` 都是相同的。默认1。
- **conv_filter_size** （int | list | tuple） - 过滤器大小。如果filter_size是列表或元组，则其长度必须等于 ``conv_num_filter`` 的长度。否则，所有Conv2d图层的 ``conv_filter_size`` 都是相同的。默认3。
- **conv_act** （str） - ``Conv2d Layer`` 的激活类型， ``BatchNorm`` 后面没有。默认值：无。
- **param_attr** （ParamAttr） - Conv2d层的参数。默认值：无
- **conv_with_batchnorm** （bool | list） - 表示在 ``Conv2d Layer`` 之后是否使用 ``BatchNorm`` 。如果 ``conv_with_batchnorm`` 是一个列表，则其长度必须等于 ``conv_num_filter`` 的长度。否则， ``conv_with_batchnorm`` 指示是否所有Conv2d层都遵循 ``BatchNorm``。默认为False。
- **conv_batchnorm_drop_rate** （float | list） - 表示 ``BatchNorm`` 之后的 ``Dropout Layer`` 的 ``rop_rate`` 。如果 ``conv_batchnorm_drop_rate`` 是一个列表，则其长度必须等于 ``conv_num_filter`` 的长度。否则，所有 ``Dropout Layers`` 的 ``drop_rate`` 都是 ``conv_batchnorm_drop_rate`` 。默认值为0.0。
- **pool_stride** （int | list | tuple） - ``Pool2d`` 层的汇集步幅。如果 ``pool_stride`` 是列表或元组，则它必须包含两个整数（pooling_stride_H，pooling_stride_W）。否则，pooling_stride_H = pooling_stride_W = pool_stride。默认1。
- **pool_type** （str） - 池化类型可以是最大池化的 ``max`` 和平均池化的 ``avg`` 。默认max。
- **use_cudnn** （bool） - 是否使用cudnn内核，仅在安装cudnn库时才有效。默认值：True
返回： 使用Convolution2d进行串行计算后的最终结果，BatchNorm，DropOut和Pool2d。
返回类型： 变量（Variable）。
**代码示例**
.. code-block:: python
img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
conv_pool = fluid.nets.img_conv_group(input=img,
num_channels=3,
conv_padding=1,
conv_num_filter=[3, 3],
conv_filter_size=3,
conv_act="relu",
pool_size=2,
pool_stride=2)
.. _cn_api_fluid_nets_scaled_dot_product_attention:
scaled_dot_product_attention
-------------------------------
.. py:function:: paddle.fluid.nets.scaled_dot_product_attention(queries, keys, values, num_heads=1, dropout_rate=0.0)
点乘attention运算。
attention运算机制可以被视为将查询和一组键值对映射到输出。 将输出计算为值的加权和，其中分配给每个值的权重由查询的兼容性函数（此处的点积）与对应的密钥计算。
可以通过（batch）矩阵乘法实现点积attention运算，如下所示：
.. math::
Attention(Q, K, V)= softmax(QK^\mathrm{T})V
请参阅 `Attention Is All You Need <https://arxiv.org/pdf/1706.03762.pdf>`_
参数：
- **queries** （Variable） - 输入变量，应为3-D Tensor。
- **keys** （Variable） - 输入变量，应为3-D Tensor。
- **values** （Variable） - 输入变量，应为3-D Tensor。
- **num_heads** （int） - 计算缩放点积attention运算的head数。默认值：1。
- **dropout_rate** （float） - 降低attention的dropout率。默认值：0.0。
返回： 通过multi-head来缩放点积attention运算的三维张量。
返回类型： 变量（Variable）。
抛出异常:
- ``ValueError`` - 如果输入查询键，值不是3-D Tensor会报错。
.. note::
当num_heads> 1时，分别学习三个线性投影，以将输入查询，键和值映射到查询'，键'和值'。 查询'，键'和值'与查询，键和值具有相同的形状。
当num_heads == 1时，scaled_dot_product_attention没有可学习的参数。
**代码示例**
.. code-block:: python
queries = fluid.layers.data(name="queries",
shape=[3, 5, 9],
dtype="float32",
append_batch_size=False)
queries.stop_gradient = False
keys = fluid.layers.data(name="keys",
shape=[3, 6, 9],
dtype="float32",
append_batch_size=False)
keys.stop_gradient = False
values = fluid.layers.data(name="values",
shape=[3, 6, 10],
dtype="float32",
append_batch_size=False)
values.stop_gradient = False
contexts = fluid.nets.scaled_dot_product_attention(queries, keys, values)
contexts.shape # [3, 5, 10]
.. _cn_api_fluid_nets_sequence_conv_pool:
sequence_conv_pool
-------------------------------
.. py:function:: paddle.fluid.nets.sequence_conv_pool(input, num_filters, filter_size, param_attr=None, act='sigmoid', pool_type='max')
sequence_conv_pool由序列卷积和池化组成
参数：
- **input** (Variable) - sequence_conv的输入，支持变量时间长度输入序列。当前输入为shape为（T，N）的矩阵，T是mini-batch中的总时间步数，N是input_hidden_size
- **num_filters** （int）- 滤波器数
- **filter_size** （int）- 滤波器大小
- **param_attr** （ParamAttr) - Sequence_conv层的参数。默认：None
- **act** （str） - Sequence_conv层的激活函数类型。默认：sigmoid
- **pool_type** （str）- 池化类型。可以是max-pooling的max，average-pooling的average，sum-pooling的sum，sqrt-pooling的sqrt。默认max
返回：序列卷积（Sequence Convolution）和池化（Pooling）的结果
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
input_dim = len(word_dict)
emb_dim = 128
hid_dim = 512
data = fluid.layers.data( ame="words", shape=[1], dtype="int64", lod_level=1)
emb = fluid.layers.embedding(input=data, size=[input_dim, emb_dim], is_sparse=True)
seq_conv = fluid.nets.sequence_conv_pool(input=emb,
num_filters=hid_dim,
filter_size=3,
act="tanh",
pool_type="sqrt")
.. _cn_api_fluid_nets_simple_img_conv_pool:
simple_img_conv_pool
-------------------------------
.. py:function:: paddle.fluid.nets.simple_img_conv_pool(input, num_filters, filter_size, pool_size, pool_stride, pool_padding=0, pool_type='max', global_pooling=False, conv_stride=1, conv_padding=0, conv_dilation=1, conv_groups=1, param_attr=None, bias_attr=None, act=None, use_cudnn=True)
``simple_img_conv_pool`` 由一个Convolution2d和一个Pool2d组成。
参数：
- **input** （Variable） - 输入图像的格式为[N，C，H，W]。
- **num_filters** （int） - ``filter`` 的数量。它与输出的通道相同。
- **filter_size** （int | list | tuple） - 过滤器大小。如果 ``filter_size`` 是列表或元组，则它必须包含两个整数（filter_size_H，filter_size_W）。否则，filter_size_H = filter_size_W = filter_size。
- **pool_size** （int | list | tuple） - Pool2d池化层大小。如果pool_size是列表或元组，则它必须包含两个整数（pool_size_H，pool_size_W）。否则，pool_size_H = pool_size_W = pool_size。
- **pool_stride** （int | list | tuple） - Pool2d池化层步长。如果pool_stride是列表或元组，则它必须包含两个整数（pooling_stride_H，pooling_stride_W）。否则，pooling_stride_H = pooling_stride_W = pool_stride。
- **pool_padding** （int | list | tuple） - Pool2d池化层的padding。如果pool_padding是列表或元组，则它必须包含两个整数（pool_padding_H，pool_padding_W）。否则，pool_padding_H = pool_padding_W = pool_padding。默认值为0。
- **pool_type** （str） - 池化类型可以是 ``max-pooling`` 的 ``max`` 和平均池的 ``avg`` 。默认 ``max`` 。
- **global_pooling** （bool）- 是否使用全局池。如果global_pooling = true，则忽略pool_size和pool_padding。默认为False
- **conv_stride** （int | list | tuple） - conv2d Layer的步长。如果stride是列表或元组，则它必须包含两个整数，（conv_stride_H，conv_stride_W）。否则，conv_stride_H = conv_stride_W = conv_stride。默认值：conv_stride = 1。
- **conv_padding** （int | list | tuple） - conv2d Layer的padding大小。如果padding是列表或元组，则它必须包含两个整数（conv_padding_H，conv_padding_W）。否则，conv_padding_H = conv_padding_W = conv_padding。默认值：conv_padding = 0。
- **conv_dilation** （int | list | tuple） - conv2d Layer的dilation大小。如果dilation是列表或元组，则它必须包含两个整数（conv_dilation_H，conv_dilation_W）。否则，conv_dilation_H = conv_dilation_W = conv_dilation。默认值：conv_dilation = 1。
- **conv_groups** （int） - conv2d Layer的组数。根据Alex Krizhevsky的Deep CNN论文中的分组卷积：当group = 2时，前半部分滤波器仅连接到输入通道的前半部分，而后半部分滤波器仅连接到后半部分输入通道。默认值：groups = 1。
- **param_attr** （ParamAttr | None） - 可学习参数的参数属性或conv2d权重。如果将其设置为None或ParamAttr的一个属性，则conv2d将创建ParamAttr作为param_attr。如果未设置param_attr的初始化，则使用 :math:`Normal（0.0，std）` 初始化参数，并且 ``std`` 为 :math:`(\frac{2.0 }{filter\_elem\_num})^{0.5}` 。默认值:None
- **bias_attr** （ParamAttr | bool | None） - conv2d的bias参数属性。如果设置为False，则不会向输出单元添加bias。如果将其设置为None或ParamAttr的一个属性，则conv2d将创建ParamAttr作为bias_attr。如果未设置bias_attr的初始化程序，则将偏差初始化为零。默认值：None
- **act** （str） - conv2d的激活类型，如果设置为None，则不附加激活。默认值：无。
- **use_cudnn** （bool） - 是否使用cudnn内核，仅在安装cudnn库时才有效。默认值：True。
返回： Convolution2d和Pool2d之后输入的结果。
返回类型： 变量（Variable）
**示例代码**
.. code-block:: python
img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
conv_pool = fluid.nets.simple_img_conv_pool(input=img,
filter_size=5,
num_filters=20,
pool_size=2,
pool_stride=2,
act="relu")
doc/fluid/api_cn/optimizer_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#################
fluid.optimizer
#################
.. _cn_api_fluid_optimizer_Adadelta:
Adadelta
-------------------------------
.. py:attribute:: paddle.fluid.optimizer.Adadelta
``AdadeltaOptimizer`` 的别名
.. _cn_api_fluid_optimizer_Adagrad:
Adagrad
-------------------------------
.. py:attribute:: paddle.fluid.optimizer.Adagrad
``AdagradOptimizer`` 的别名
.. _cn_api_fluid_optimizer_AdagradOptimizer:
AdagradOptimizer
-------------------------------
.. py:class:: paddle.fluid.optimizer.AdagradOptimizer(learning_rate, epsilon=1e-06, regularization=None, name=None)
**Adaptive Gradient Algorithm(Adagrad)**
更新如下：
.. math::
moment\_out &= moment + grad * grad\\param\_out
&= param - \frac{learning\_rate * grad}{\sqrt{moment\_out} + \epsilon}
原始论文（http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf）没有epsilon属性。在我们的实现中也作了如下更新：
http://cs231n.github.io/neural-networks-3/#ada 用于维持数值稳定性，避免除数为0的错误发生。
参数：
- **learning_rate** (float|Variable)-学习率，用于更新参数。作为数据参数，可以是一个浮点类型值或者有一个浮点类型值的变量
- **epsilon** (float) - 维持数值稳定性的短浮点型值
- **regularization** - 规则化函数，例如fluid.regularizer.L2DecayRegularizer
- **name** - 名称前缀（可选）
**代码示例**：
.. code-block:: python:
optimizer = fluid.optimizer.Adagrad(learning_rate=0.2)
optimizer.minimize(cost)
.. _cn_api_fluid_optimizer_Adam:
Adam
-------------------------------
.. py:attribute:: paddle.fluid.optimizer.Adam
``AdamOptimizer`` 的别名
.. _cn_api_fluid_optimizer_Adamax:
Adamax
-------------------------------
.. py:attribute:: paddle.fluid.optimizer.Adamax
``AdamaxOptimizer`` 的别名
.. _cn_api_fluid_optimizer_AdamaxOptimizer:
AdamaxOptimizer
-------------------------------
.. py:class:: paddle.fluid.optimizer.AdamaxOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, regularization=None, name=None)
我们参考Adam论文第7节中的Adamax优化: https://arxiv.org/abs/1412.6980 ， Adamax是基于无穷大范数的Adam算法的一个变种。
Adamax 更新规则:
.. math::
\\t = t + 1
.. math::
moment\_out=\beta_1∗moment+(1−\beta_1)∗grad
.. math::
inf\_norm\_out=\max{(\beta_2∗inf\_norm+ϵ, \left|grad\right|)}
.. math::
learning\_rate=\frac{learning\_rate}{1-\beta_1^t}
.. math::
param\_out=param−learning\_rate*\frac{moment\_out}{inf\_norm\_out}\\
论文中没有 ``epsilon`` 参数。但是，为了数值稳定性， 防止除0错误， 增加了这个参数
参数:
- **learning_rate** (float|Variable) - 用于更新参数的学习率。可以是浮点值，也可以是具有一个浮点值作为数据元素的变量。
- **beta1** (float) - 第1阶段估计的指数衰减率
- **beta2** (float) - 第2阶段估计的指数衰减率。
- **epsilon** (float) -非常小的浮点值，为了数值的稳定性质
- **regularization** - 正则化器，例如 ``fluid.regularizer.L2DecayRegularizer``
- **name** - 可选的名称前缀。
**代码示例**
.. code-block:: python
optimizer = fluid.optimizer.Adamax(learning_rate=0.2)
optimizer.minimize(cost)
.. note::
目前 ``AdamaxOptimizer`` 不支持 sparse gradient
.. _cn_api_fluid_optimizer_AdamOptimizer:
AdamOptimizer
-------------------------------
.. py:class:: paddle.fluid.optimizer. AdamOptimizer(learning_rate=0.001, beta1=0.9, beta2=0.999, epsilon=1e-08, regularization=None, name=None)
该函数实现了自适应矩估计优化器，介绍自 `Adam论文 <https://arxiv.org/abs/1412.6980>`_ 的第二节。Adam是一阶基于梯度下降的算法，基于自适应低阶矩估计。
Adam更新如下：
.. math::
t & = t + 1\\moment\_out & = {\beta}_1 * moment + (1 - {\beta}_1) * grad\\inf\_norm\_out & = max({\beta}_2 * inf\_norm + \epsilon, |grad|)\\learning\_rate & = \frac{learning\_rate}{1 - {\beta}_1^t}\\param\_out & = param - learning\_rate * \frac{moment\_out}{inf\_norm\_out}
参数:
- **learning_rate** (float|Variable)-学习率，用于更新参数。作为数据参数，可以是一个浮点类型值或有一个浮点类型值的变量
- **beta1** (float)-一阶矩估计的指数衰减率
- **beta2** (float)-二阶矩估计的指数衰减率
- **epsilon** (float)-保持数值稳定性的短浮点类型值
- **regularization** - 规则化函数，例如''fluid.regularizer.L2DecayRegularizer
- **name** - 可选名称前缀
**代码示例**：
.. code-block:: python:
optimizer = fluid.optimizer.Adam(learning_rate=0.2)
optimizer.minimize(cost)
.. _cn_api_fluid_optimizer_DecayedAdagrad:
DecayedAdagrad
-------------------------------
.. py:attribute:: paddle.fluid.optimizer.DecayedAdagrad
``DecayedAdagradOptimizer`` 的别名
.. _cn_api_fluid_optimizer_DecayedAdagradOptimizer:
DecayedAdagradOptimizer
-------------------------------
.. py:class:: paddle.fluid.optimizer.DecayedAdagradOptimizer(learning_rate, decay=0.95, epsilon=1e-06, regularization=None, name=None)
Decayed Adagrad Optimizer
`原始论文 <http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf>`_
原始论文： `http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf <http://www.jmlr.org/papers/volume12/duchi11a/duchi11a.pdf>`_ 中没有 ``epsilon`` 参数。但是，为了数值稳定性， 防止除0错误， 增加了这个参数
.. math::
moment\_out = decay*moment+(1-decay)*grad*grad
.. math::
param\_out=param-\frac{learning\_rate*grad}{\sqrt{moment\_out+\epsilon }}
参数:
- **learning_rate** (float|Variable) - 用于更新参数的学习率。可以是浮点值，也可以是具有一个浮点值作为数据元素的变量。
- **decay** (float) – 衰减率
- **regularization** - 一个正则化器，例如 ``fluid.regularizer.L2DecayRegularizer``
- **epsilon** (float) - 非常小的浮点值，为了数值稳定性
- **name** — 可选的名称前缀。
**代码示例**
.. code-block:: python
optimizer = fluid.optimizer.DecayedAdagrad(learning_rate=0.2)
optimizer.minimize(cost)
.. note::
``DecayedAdagradOptimizer`` 不支持 sparse gradient
.. _cn_api_fluid_optimizer_Ftrl:
Ftrl
-------------------------------
.. py:attribute:: paddle.fluid.optimizer.Ftrl
``FtrlOptimizer`` 的别名
.. _cn_api_fluid_optimizer_FtrlOptimizer:
FtrlOptimizer
-------------------------------
.. py:class:: paddle.fluid.optimizer.FtrlOptimizer(learning_rate, l1=0.0, l2=0.0, lr_power=-0.5,regularization=None, name=None)
FTRL (Follow The Regularized Leader) Optimizer.
TFRTL 原始论文: ( `https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf <https://www.eecs.tufts.edu/~dsculley/papers/ad-click-prediction.pdf>`_)
.. math::
&\qquad new\_accum=squared\_accum+grad^2\\\\
&\qquad if(lr\_power==−0.5):\\
&\qquad \qquad linear\_accum+=grad-\frac{\sqrt{new\_accum}-\sqrt{squared\_accum}}{learning\_rate*param}\\
&\qquad else:\\
&\qquad \qquad linear\_accum+=grad-\frac{new\_accum^{-lr\_power}-accum^{-lr\_power}}{learning\_rate*param}\\\\
&\qquad x=l1*sign(linear\_accum)−linear\_accum\\\\
&\qquad if(lr\_power==−0.5):\\
&\qquad \qquad y=\frac{\sqrt{new\_accum}}{learning\_rate}+(2*l2)\\
&\qquad \qquad pre\_shrink=\frac{x}{y}\\
&\qquad \qquad param=(abs(linear\_accum)>l1).select(pre\_shrink,0.0)\\
&\qquad else:\\
&\qquad \qquad y=\frac{new\_accum^{-lr\_power}}{learning\_rate}+(2*l2)\\
&\qquad \qquad pre\_shrink=\frac{x}{y}\\
&\qquad \qquad param=(abs(linear\_accum)>l1).select(pre\_shrink,0.0)\\\\
&\qquad squared\_accum+=grad^2
参数:
- **learning_rate** (float|Variable)-全局学习率。
- **l1** (float) - 暂无，请等待后期更新
- **l2** (float) - 暂无，请等待后期更新
- **lr_power** (float) - 暂无，请等待后期更新
- **regularization** - 正则化器，例如 ``fluid.regularizer.L2DecayRegularizer``
- **name** — 可选的名称前缀
抛出异常：
- ``ValueError`` - 如果 ``learning_rate`` , ``rho`` , ``epsilon`` , ``momentum`` 为 None.
**代码示例**
.. code-block:: python
optimizer = fluid.optimizer.Ftrl(0.0001)
_, params_grads = optimizer.minimize(cost)
.. note::
目前, FtrlOptimizer 不支持 sparse gradient
.. _cn_api_fluid_optimizer_LarsMomentum:
LarsMomentum
-------------------------------
.. py:attribute:: paddle.fluid.optimizer.LarsMomentum
``fluid.optimizer.LarsMomentumOptimizer`` 的别名
.. _cn_api_fluid_optimizer_LarsMomentumOptimizer:
LarsMomentumOptimizer
-------------------------------
.. py:function:: paddle.fluid.optimizer.LarsMomentumOptimizer(learning_rate, momentum, lars_coeff=0.001, lars_weight_decay=0.0005, regularization=None, name=None)
LARS支持的Momentum优化器
公式作如下更新：
.. math::
& local\_learning\_rate = learning\_rate * lars\_coeff * \
\frac{||param||}{||gradient|| + lars\_weight\_decay * ||param||}\\
& velocity = mu * velocity + local\_learning\_rate * (gradient + lars\_weight\_decay * param)\\
& param = param - velocity
参数：
- **learning_rate** (float|Variable) - 学习率，用于参数更新。作为数据参数，可以是浮点型值或含有一个浮点型值的变量
- **momentum** (float) - 动量因子
- **lars_coeff** (float) - 定义LARS本地学习率的权重
- **lars_weight_decay** (float) - 使用LARS进行衰减的权重衰减系数
- **regularization** - 正则化函数，例如 :code:`fluid.regularizer.L2DecayRegularizer`
- **name** - 名称前缀，可选
**代码示例：**
.. code-block:: python
optimizer = fluid.optimizer.LarsMomentum(learning_rate=0.2, momentum=0.1, lars_weight_decay=0.001)
optimizer.minimize(cost)
.. _cn_api_fluid_optimizer_ModelAverage:
ModelAverage
-------------------------------
.. py:class:: paddle.fluid.optimizer.ModelAverage(average_window_rate, min_average_window=10000, max_average_window=10000, regularization=None, name=None)
在滑动窗口中累积参数的平均值。平均结果将保存在临时变量中，通过调用 ``apply()`` 方法可应用于当前模型的参数变量。使用 ``restore()`` 方法恢复当前模型的参数值。
平均窗口的大小由 ``average_window_rate`` ， ``min_average_window`` ， ``max_average_window`` 以及当前更新次数决定。
参数:
- **average_window_rate** – 窗口平均速率
- **min_average_window** – 平均窗口大小的最小值
- **max_average_window** – 平均窗口大小的最大值
- **regularization** – 正则化器，例如 ``fluid.regularizer.L2DecayRegularizer``
- **name** – 可选的名称前缀
**代码示例**
.. code-block:: python
optimizer = fluid.optimizer.Momentum()
optimizer.minimize(cost)
model_average = fluid.optimizer.ModelAverage(0.15,
min_average_window=10000,
max_average_window=20000)
for pass_id in range(args.pass_num):
for data in train_reader():
exe.run(fluid.default_main_program()...)
with model_average.apply(exe):
for data in test_reader():
exe.run(inference_program...)
.. py:method:: apply(*args, **kwds)
将平均值应用于当前模型的参数。
.. py:method:: restore(executor)
恢复当前模型的参数值
.. _cn_api_fluid_optimizer_Momentum:
Momentum
-------------------------------
.. py:attribute:: paddle.fluid.optimizer.Momentum
``MomentumOptimizer`` 的别名
.. _cn_api_fluid_optimizer_MomentumOptimizer:
MomentumOptimizer
-------------------------------
.. py:class:: paddle.fluid.optimizer.MomentumOptimizer(learning_rate, momentum, use_nesterov=False, regularization=None, name=None)
含有速度状态的Simple Momentum 优化器
该优化器含有牛顿动量标志，公式更新如下：
.. math::
& velocity = mu * velocity + gradient\\
& if (use\_nesterov):\
\&\quad param = param - (gradient + mu * velocity) * learning\_rate\\
& else:\\&\quad param = param - learning\_rate * velocity
参数：
- **learning_rate** (float|Variable) - 学习率，用于参数更新。作为数据参数，可以是浮点型值或含有一个浮点型值的变量
- **momentum** (float) - 动量因子
- **use_nesterov** (bool) - 赋能牛顿动量
- **regularization** - 正则化函数，比如fluid.regularizer.L2DecayRegularizer
- **name** - 名称前缀（可选）
**代码示例**：
.. code-block:: python
optimizer = fluid.optimizer.Momentum(learning_rate=0.2, momentum=0.1)
optimizer.minimize(cost)
.. _cn_api_fluid_optimizer_RMSPropOptimizer:
RMSPropOptimizer
-------------------------------
.. py:class:: paddle.fluid.optimizer.RMSPropOptimizer(learning_rate, rho=0.95, epsilon=1e-06, momentum=0.0, centered=False, regularization=None, name=None)
均方根平均传播（RMSProp）法是一种未发表的,自适应学习率的方法。原始slides提出了RMSProp：[http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf]中的第29张slide。等式如下所示：
.. math::
r(w, t) & = \rho r(w, t-1) + (1 - \rho)(\nabla Q_{i}(w))^2\\
w & = w - \frac{\eta} {\sqrt{r(w,t) + \epsilon}} \nabla Q_{i}(w)
第一个等式计算每个权重平方梯度的移动平均值，然后将梯度除以 :math:`sqrtv（w，t）` 。
.. math::
r(w, t) & = \rho r(w, t-1) + (1 - \rho)(\nabla Q_{i}(w))^2\\
v(w, t) & = \beta v(w, t-1) +\frac{\eta} {\sqrt{r(w,t) +\epsilon}} \nabla Q_{i}(w)\\
w & = w - v(w, t)
如果居中为真：
.. math::
r(w, t) & = \rho r(w, t-1) + (1 - \rho)(\nabla Q_{i}(w))^2\\
g(w, t) & = \rho g(w, t-1) + (1 -\rho)\nabla Q_{i}(w)\\
v(w, t) & = \beta v(w, t-1) + \frac{\eta} {\sqrt{r(w,t) - (g(w, t))^2 +\epsilon}} \nabla Q_{i}(w)\\
w & = w - v(w, t)
其中， :math:`ρ` 是超参数，典型值为0.9,0.95等。 :math:`beta` 是动量术语。 :math:`epsilon` 是一个平滑项，用于避免除零，通常设置在1e-4到1e-8的范围内。
参数：
- **learning_rate** （float） - 全球学习率。
- **rho** （float） - rho是等式中的 :math:`rho` ，默认设置为0.95。
- **epsilon** （float） - 等式中的epsilon是平滑项，避免被零除，默认设置为1e-6。
- **momentum** （float） - 方程中的β是动量项，默认设置为0.0。
- **centered** （bool） - 如果为True，则通过梯度估计方差对梯度进行归一化；如果false，则由未centered的第二个moment归一化。将此设置为True有助于培训，但在计算和内存方面稍微昂贵一些。默认为False。
- **regularization** - 正则器项，如 ``fluid.regularizer.L2DecayRegularizer`` 。
- **name** - 可选的名称前缀。
抛出异常:
- ``ValueError`` -如果 ``learning_rate`` ， ``rho`` ， ``epsilon`` ， ``momentum`` 为None。
**示例代码**
.. code-block:: python
optimizer = fluid.optimizer.RMSProp(0.0001)
_, params_grads = optimizer.minimize(cost)
.. _cn_api_fluid_optimizer_SGD:
SGD
-------------------------------
.. py:attribute:: paddle.fluid.optimizer.SGD
``SGDOptimizer`` 的别名
.. _cn_api_fluid_optimizer_SGDOptimizer:
SGDOptimizer
-------------------------------
.. py:class:: paddle.fluid.optimizer.SGDOptimizer(learning_rate, regularization=None, name=None)
随机梯度下降算法的优化器
.. math::
\\param\_out=param-learning\_rate*grad\\
参数:
- **learning_rate** (float|Variable) - 用于更新参数的学习率。可以是浮点值，也可以是具有一个浮点值作为数据元素的变量。
- **regularization** - 一个正则化器，例如 ``fluid.regularizer.L2DecayRegularizer``
- **name** - 可选的名称前缀。
**代码示例**
.. code-block:: python
sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.2)
sgd_optimizer.minimize(cost)
doc/fluid/api_cn/param_attr_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#################
fluid.param_attr
#################
.. _cn_api_fluid_param_attr_ParamAttr:
ParamAttr
-------------------------------
.. py:class:: paddle.fluid.param_attr.ParamAttr(name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, gradient_clip=None, do_model_average=False)
该类代表了参数的各种属性。 为了使神经网络训练过程更加流畅，用户可以根据需要调整参数属性。比如learning rate（学习率）, regularization（正则化）, trainable（可训练性）, do_model_average(平均化模型)和参数初始化方法.
参数:
- **name** (str) – 参数名。默认为None。
- **initializer** (Initializer) – 初始化该参数的方法。 默认为None
- **learning_rate** (float) – 参数的学习率。计算方法为 global_lr*parameter_lr∗scheduler_factor。 默认为1.0
- **regularizer** (WeightDecayRegularizer) – 正则因子. 默认为None
- **trainable** (bool) – 该参数是否可训练。默认为True
- **gradient_clip** (BaseGradientClipAttr) – 减少参数梯度的方法。默认为None
- **do_model_average** (bool) – 该参数是否服从模型平均值。默认为False
**代码示例**
.. code-block:: python
w_param_attrs = fluid.ParamAttr(name="fc_weight",
learning_rate=0.5,
regularizer=fluid.L2Decay(1.0),
trainable=True)
y_predict = fluid.layers.fc(input=x, size=10, param_attr=w_param_attrs)
.. _cn_api_fluid_param_attr_WeightNormParamAttr:
WeightNormParamAttr
-------------------------------
.. py:class:: paddle.fluid.param_attr.WeightNormParamAttr(dim=None, name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, gradient_clip=None, do_model_average=False)
权重归一化。权范数是神经网络中权向量的再参数化，它将权向量的长度与其方向解耦。该paper对权值归一化的实现进行了讨论： `Weight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural Networks <https://arxiv.org/pdf/1602.07868.pdf>`_
参数:
- **dim** (list) – 参数维度. Default None.
- **name** (str) – 参数名称. Default None.
- **initializer** (Initializer) – 初始化参数的方法. Default None.
- **learning_rate** (float) – 参数的学习率. 优化的参数学习率为 :math:`global\_lr*parameter\_lr*scheduler\_factor` . Default 1.0
- **regularizer** (WeightDecayRegularizer) – 正则化因子. Default None.
- **trainable** (bool) – 参数是否可训练. Default True.
- **gradient_clip** (BaseGradientClipAttr) – 修剪这个参数的梯度的方法. Default None.
- **do_model_average** (bool) – 这个参数是否应该做模型平均. Default False.
**代码示例**
.. code-block:: python
data = fluid.layers.data(name="data", shape=[3, 32, 32], dtype="float32")
fc = fluid.layers.fc(input=data,
size=1000,
param_attr=WeightNormParamAttr(
dim=None,
name='weight_norm_param'))
doc/fluid/api_cn/profiler_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#################
fluid.profiler
#################
.. _cn_api_fluid_profiler_cuda_profiler:
cuda_profiler
-------------------------------
.. py:function:: paddle.fluid.profiler.cuda_profiler(*args, **kwds)
CUDA分析器。通过CUDA运行时应用程序编程接口对CUDA程序进行性能分析。分析结果将以键-值对格式或逗号分隔的格式写入output_file。用户可以通过output_mode参数设置输出模式，并通过配置参数设置计数器/选项。默认配置是[' gpustarttimestamp '， ' gpustarttimestamp '， ' gridsize3d '， ' threadblocksize '， ' streamid '， ' enableonstart 0 '， ' conckerneltrace ']。然后，用户可使用 `NVIDIA Visual Profiler <https://developer.nvidia.com/nvidia-visualprofiler>`_ 工具来加载这个输出文件以可视化结果。
参数:
- **output_file** (string) – 输出文件名称, 输出结果将会写入该文件
- **output_mode** (string) – 输出格式是有 key-value 键值对 和 逗号的分割的格式。格式应该是' kvp '或' csv '
- **config** (list of string) – 参考"Compute Command Line Profiler User Guide" 查阅 profiler options 和 counter相关信息
抛出异常:
- ``ValueError`` - 如果 ``output_mode`` 不在 ['kvp', 'csv'] 中
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
import paddle.fluid.profiler as profiler
epoc = 8
dshape = [4, 3, 28, 28]
data = fluid.layers.data(name='data', shape=[3, 28, 28], dtype='float32')
conv = fluid.layers.conv2d(data, 20, 3, stride=[1, 1], padding=[1, 1])
place = fluid.CUDAPlace(0)
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
output_file = 'cuda_profiler.txt'
with profiler.cuda_profiler(output_file, 'csv') as nvprof:
for i in range(epoc):
input = np.random.random(dshape).astype('float32')
exe.run(fluid.default_main_program(), feed={'data': input})
# 之后可以使用 NVIDIA Visual Profile 可视化结果
.. _cn_api_fluid_profiler_profiler:
profiler
-------------------------------
.. py:function:: paddle.fluid.profiler.profiler(*args, **kwds)
profile interface 。与cuda_profiler不同，此profiler可用于分析CPU和GPU程序。默认情况下，它记录CPU和GPU kernel，如果想分析其他程序，可以参考教程来在c++代码中添加更多代码。
如果 state== ' All '，在profile_path 中写入文件 profile proto 。该文件记录执行期间的时间顺序信息。然后用户可以看到这个文件的时间轴，请参考 `https://github.com/PaddlePaddle/Paddle/blob/develop/doc/fluid/howto/optimization/timeline.md <https://github.com/PaddlePaddle/Paddle/blob/develop/doc/fluid/howto/optimization/timeline.md>`_
参数:
- **state** (string) – profiling state, 取值为 'CPU' 或 'GPU', profiler 使用 CPU timer 或GPU timer 进行 profiling. 虽然用户可能在开始时指定了执行位置(CPUPlace/CUDAPlace)，但是为了灵活性，profiler不会使用这个位置。
- **sorted_key** (string) – 如果为None，prfile的结果将按照事件的第一次结束时间顺序打印。否则，结果将按标志排序。标志取值为"call"、"total"、"max"、"min" "ave"之一，根据调用着的数量进行排序。total表示按总执行时间排序，max 表示按最大执行时间排序。min 表示按最小执行时间排序。ave表示按平均执行时间排序。
- **profile_path** (string) – 如果 state == 'All', 结果将写入文件 profile proto.
抛出异常：
- ``ValueError`` – 如果state 取值不在 ['CPU', 'GPU', 'All']中. 如果 sorted_key 取值不在 ['calls', 'total', 'max', 'min', 'ave']
**代码示例**
.. code-block:: python
import paddle.fluid.profiler as profiler
with profiler.profiler('All', 'total', '/tmp/profile') as prof:
for pass_id in range(pass_num):
for batch_id, data in enumerate(train_reader()):
exe.run(fluid.default_main_program(),
feed=feeder.feed(data),
fetch_list=[],
use_program_cache=True)
# ...
.. _cn_api_fluid_profiler_reset_profiler:
reset_profiler
-------------------------------
.. py:function:: paddle.fluid.profiler.reset_profiler()
清除之前的时间记录。此接口不适用于 ``fluid.profiler.cuda_profiler`` ，它只适用于 ``fluid.profiler.start_profiler`` , ``fluid.profiler.stop_profiler`` , ``fluid.profiler.profiler`` 。
**代码示例**
.. code-block:: python
import paddle.fluid.profiler as profiler
with profiler.profiler(state, 'total', '/tmp/profile'):
for iter in range(10):
if iter == 2:
profiler.reset_profiler()
# ...
.. _cn_api_fluid_profiler_start_profiler:
start_profiler
-------------------------------
.. py:function:: paddle.fluid.profiler.start_profiler(state)
激活使用 profiler， 用户可以使用 ``fluid.profiler.start_profiler`` 和 ``fluid.profiler.stop_profiler`` 插入代码
不能使用 ``fluid.profiler.profiler``
如果 state== ' All '，在profile_path 中写入文件 profile proto 。该文件记录执行期间的时间顺序信息。然后用户可以看到这个文件的时间轴，请参考 `https://github.com/PaddlePaddle/Paddle/blob/develop/doc/fluid/howto/optimization/timeline.md <https://github.com/PaddlePaddle/Paddle/blob/develop/doc/fluid/howto/optimization/timeline.md>`_
参数:
- **state** (string) – profiling state, 取值为 'CPU' 或 'GPU' 或 'All', 'CPU' 代表只分析 cpu. 'GPU' 代表只分析 GPU . 'All' 会产生 timeline.
抛出异常:
- ``ValueError`` – 如果state 取值不在 ['CPU', 'GPU', 'All']中
**代码示例**
.. code-block:: python
import paddle.fluid.profiler as profiler
profiler.start_profiler('GPU')
for iter in range(10):
if iter == 2:
profiler.reset_profiler()
# except each iteration
profiler.stop_profiler('total', '/tmp/profile')
# ...
.. _cn_api_fluid_profiler_stop_profiler:
stop_profiler
-------------------------------
.. py:function::paddle.fluid.profiler.stop_profiler(sorted_key=None, profile_path='/tmp/profile')
停止 profiler， 用户可以使用 ``fluid.profiler.start_profiler`` 和 ``fluid.profiler.stop_profiler`` 插入代码
不能使用 fluid.profiler.profiler``
参数:
- **sorted_key** (string) – 如果为None，prfile的结果将按照事件的第一次结束时间顺序打印。否则，结果将按标志排序。标志取值为"call"、"total"、"max"、"min" "ave"之一，根据调用着的数量进行排序。total表示按总执行时间排序，max 表示按最大执行时间排序。min 表示按最小执行时间排序。ave表示按平均执行时间排序。
- **profile_path** (string) - 如果 state == 'All', 结果将写入文件 profile proto.
抛出异常:
- ``ValueError`` – 如果state 取值不在 ['CPU', 'GPU', 'All']中
**代码示例**
.. code-block:: python
import paddle.fluid.profiler as profiler
profiler.start_profiler('GPU')
for iter in range(10):
if iter == 2:
profiler.reset_profiler()
# except each iteration
profiler.stop_profiler('total', '/tmp/profile')
doc/fluid/api_cn/recordio_writer_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#######################
fluid.recordio_writer
#######################
.. _cn_api_fluid_recordio_writer_convert_reader_to_recordio_file:
convert_reader_to_recordio_file
-------------------------------
.. py:function:: paddle.fluid.recordio_writer.convert_reader_to_recordio_file(filename, reader_creator, feeder, compressor=Compressor.Snappy, max_num_records=1000, feed_order=None)
将 Python reader 转换为recordio文件
**代码示例：**
.. code-block:: python
import paddle.fluid as fluid
import paddle.dataset.mnist as mnist
import paddle
tmp_program = fluid.Program()
with fluid.program_guard(tmp_program):
img = fluid.layers.data(name='img', shape=[784])
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
feeder = fluid.DataFeeder(feed_list=[img, label], place=fluid.CPUPlace())
# mnist.recordio 会在当前目录生成
fluid.recordio_writer.convert_reader_to_recordio_file(
filename="mnist.recordio",
reader_creator=paddle.batch(mnist.train(), batch_size=32),
feeder=feeder)
参数：
- **filename** (str) - recordio文件名
- **reader_creator** (callable) - Python reader的创造器。可参考 :ref:`api_guide_python_reader`
- **feeder** (DataFeeder) - 数据处理实例。用于将 :code:`reader_creator` 转换为 :code:`lod_tensor`
- **compressor** – 必须在 :code:`fluid.core.RecordIOWriter.Compressor.Snappy` 或 :code:` fluid.core.RecordIOWriter.Compressor.NoCompress` 中， 默认情况下使用 :code:`Snappy`
- **max_num_records** (int) – 一个 chuck 中 records 的最大数量。每个 records 都是 reader 函数的返回值
- **feed_order** (list) - reader 返回的变量名的顺序
返回： 保存的 record 的数目
返回类型： int
.. _cn_api_fluid_recordio_writer_convert_reader_to_recordio_files:
convert_reader_to_recordio_files
-------------------------------
.. py:function:: paddle.fluid.recordio_writer.convert_reader_to_recordio_files(filename, batch_per_file, reader_creator, feeder, compressor=Compressor.Snappy, max_num_records=1000, feed_order=None)
该函数可以将一个python驱动的reader（数据读取器）转变为多个recodio文件。
该API实现的功能和 ``convert_reader_to_recordio_file`` 基本相同，只不过本函数会生成多个recordio文件。
每个文件最多存储 ``batch_per_file`` 条记录。
请参照 :ref:`cn_api_fluid_recordio_writer_convert_reader_to_recordio_file` 获取更详细的介绍。
doc/fluid/api_cn/regularizer_cn.rst 0 → 100644
浏览文件 @ cb4f4929
###################
fluid.regularizer
###################
.. _cn_api_fluid_regularizer_L1Decay:
L1Decay
-------------------------------
.. py:attribute:: paddle.fluid.regularizer.L1Decay
``L1DecayRegularizer`` 的别名
.. _cn_api_fluid_regularizer_L1DecayRegularizer:
L1DecayRegularizer
-------------------------------
.. py:class:: paddle.fluid.regularizer.L1DecayRegularizer(regularization_coeff=0.0)
实现 L1 权重衰减正则化。
L1正则将会稀疏化权重矩阵。
.. math::
\\L1WeightDecay=reg\_coeff∗sign(parameter)\\
参数:
- **regularization_coeff** (float) – 正则化系数
**代码示例**
.. code-block:: python
ioptimizer = fluid.optimizer.Adagrad(
learning_rate=1e-4,
regularization=fluid.regularizer.L1DecayRegularizer(
regularization_coeff=0.1))
optimizer.minimize(avg_cost)
.. _cn_api_fluid_regularizer_L2Decay:
L2Decay
-------------------------------
.. py:attribute:: paddle.fluid.regularizer.L2Decay
``L2DecayRegularizer`` 的别名
.. _cn_api_fluid_regularizer_L2DecayRegularizer:
L2DecayRegularizer
-------------------------------
.. py:class:: paddle.fluid.regularizer.L2DecayRegularizer(regularization_coeff=0.0)
实现L2 权重衰减正则化。
较小的 L2 的有助于防止对训练数据的过度拟合。
.. math::
\\L2WeightDecay=reg\_coeff*parameter\\
参数:
- **regularization_coeff** (float) – 正则化系数
**代码示例**
.. code-block:: python
optimizer = fluid.optimizer.Adagrad(
learning_rate=1e-4,
regularization=fluid.regularizer.L2DecayRegularizer(
regularization_coeff=0.1))
optimizer.minimize(avg_cost)
doc/fluid/api_cn/transpiler_cn.rst 0 → 100644
浏览文件 @ cb4f4929
#################
fluid.transpiler
#################
.. _cn_api_fluid_transpiler_DistributeTranspiler:
DistributeTranspiler
-------------------------------
.. py:class:: paddle.fluid.transpiler.DistributeTranspiler (config=None)
该类可以把fluid program转变为分布式数据并行计算程序（distributed data-parallelism programs）,可以有Pserver和NCCL2两种模式。
当program在Pserver（全称：parameter server）模式下， ``main_program`` (主程序)转为使用一架远程parameter server(即pserver,参数服务器)来进行参数优化，并且优化图会被输入到一个pserver program中。
在NCCL2模式下，transpiler会在 ``startup_program`` 中附加一个 ``NCCL_ID`` 广播算子（broadcasting operators）来实现在该集群中所有工作结点共享``NCCL_ID`` 。
调用 ``transpile_nccl2`` 后， 你 **必须** 将 ``trainer_id`` , ``num_trainers`` 参数提供给 ``ParallelExecutor`` 来启动NCCL2分布式模式。
**代码示例**
.. code-block:: python
# for pserver mode
pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
current_endpoint = "192.168.0.1:6174"
trainer_id = 0
trainers = 4
role = os.getenv("PADDLE_TRAINING_ROLE")
t = fluid.DistributeTranspiler()
t.transpile(
trainer_id, pservers=pserver_endpoints, trainers=trainers)
if role == "PSERVER":
pserver_program = t.get_pserver_program(current_endpoint)
pserver_startup_program = t.get_startup_program(current_endpoint,
pserver_program)
elif role == "TRAINER":
trainer_program = t.get_trainer_program()
# for nccl2 mode
config = fluid.DistributeTranspilerConfig()
config.mode = "nccl2"
t = fluid.DistributeTranspiler(config=config)
t.transpile(trainer_id, workers=workers, current_endpoint=curr_ep)
exe = fluid.ParallelExecutor(
use_cuda,
loss_name=loss_var.name,
num_trainers=len(trainers.split(",)),
trainer_id=trainer_id
)
.. py:method:: transpile(trainer_id, program=None, pservers='127.0.0.1:6174', trainers=1, sync_mode=True, startup_program=None, current_endpoint='127.0.0.1:6174')
该方法可以运行该transpiler（转译器）。
参数:
- **trainer_id** (int) – 当前Trainer worker的id, 如果有n个Trainer worker, id 取值范围为0 ~ n-1
- **program** (Program|None) – 待transpile（转译）的program, 缺省为 ``fluid.default_main_program()``
- **startup_program** (Program|None) - 要转译的 ``startup_program`` ,默认为 ``fluid.default_startup_program()``
- **pservers** (str) – 内容为Pserver列表的字符串，格式为：按逗号区分不同的Pserver，每个Pserver的格式为 *ip地址:端口号*
- **trainers** (int|str) – 在Pserver模式下，该参数指Trainer机的个数；在nccl2模式下，它是一个内容为Trainer终端列表的字符串
- **sync_mode** (bool) – 是否做同步训练(synchronous training), 默认为True
- **startup_program** (Program|None) – 待transpile（转译）的startup_program，默认为 ``fluid.default_main_program()``
- **current_endpoint** (str) – 当需要把program转译（transpile）至NCCL2模式下时，需要将当前endpoint（终端）传入该参数。Pserver模式不使用该参数
.. py:method:: get_trainer_program(wait_port=True)
该方法可以得到Trainer侧的program。
返回: Trainer侧的program
返回类型: Program
.. py:method:: get_pserver_program(endpoint)
该方法可以得到Pserver（参数服务器）侧的程序
参数:
- **endpoint** (str) – 当前Pserver终端
返回: 当前Pserver需要执行的program
返回类型: Program
.. py:method:: get_pserver_programs(endpoint)
该方法可以得到Pserver侧用于分布式训练的 ``main_program`` 和 ``startup_program`` 。
参数:
- **endpoint** (str) – 当前Pserver终端
返回: (main_program, startup_program), “Program”类型的元组
返回类型: tuple
.. py:method:: get_startup_program(endpoint, pserver_program=None, startup_program=None)
**该函数已停止使用**
获取当前Pserver的startup_program，如果有多个被分散到不同blocks的变量，则修改operator的输入变量。
参数:
- **endpoint** (str) – 当前Pserver终端
- **pserver_program** (Program) – 已停止使用。 先调用get_pserver_program
- **startup_program** (Program) – 已停止使用。应在初始化时传入startup_program
返回: Pserver侧的startup_program
返回类型: Program
.. _cn_api_fluid_transpiler_DistributeTranspilerConfig:
DistributeTranspilerConfig
-------------------------------
.. py:class:: paddle.fluid.transpiler.DistributeTranspilerConfig
.. py:method:: slice_var_up (bool)
为Pserver将张量切片, 默认为True
.. py:method:: split_method (PSDispatcher)
可使用 RoundRobin 或者 HashName
注意: 尝试选择最佳方法来达到负载均衡。
.. py:attribute:: min_block_size (int)
最小数据块的大小
注意: 根据：https：//github.com/PaddlePaddle/Paddle/issues/8638#issuecomment-369912156, 当数据块大小超过2MB时，我们可以有效地使用带宽。如果你想更改它，请详细查看slice_variable函数。
.. _cn_api_fluid_transpiler_HashName:
HashName
-------------------------------
.. py:class:: paddle.fluid.transpiler.HashName(pserver_endpoints)
使用 python ``Hash()`` 函数将变量名散列到多个pserver终端。
参数:
- **pserver_endpoints** (list) - endpoint （ip:port）的 list
.. _cn_api_fluid_transpiler_memory_optimize:
memory_optimize
-------------------------------
.. py:function:: paddle.fluid.transpiler.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=False)
通过重用var内存来优化内存。
注意:它不支持block中嵌套子block。
参数:
- **input_program** (str) – 输入Program。
- **skip_opt_set** (set) – set中的vars将不被内存优化。
- **print_log** (bool) – 是否打印debug日志。
- **level** (int) - 如果 level=0 并且shape是完全相等，则重用。
返回: None
.. _cn_api_fluid_transpiler_release_memory:
release_memory
-------------------------------
.. py:function:: paddle.fluid.transpiler.release_memory(input_program, skip_opt_set=None)
该函数可以调整输入program，插入 ``delete_op`` 删除算子，提前删除不需要的变量。
改动是在变量本身上进行的。
**提醒** : 该API还在试验阶段，会在后期版本中删除。不建议用户使用。
参数:
- **input_program** (Program) – 在此program中插入 ``delete_op``
- **skip_opt_set** (set) – 在内存优化时跳过的变量的集合
返回: None
.. _cn_api_fluid_transpiler_RoundRobin:
RoundRobin
-------------------------------
.. py:class:: paddle.fluid.transpiler.RoundRobin(pserver_endpoints)
使用 ``RondRobin`` 方法将变量分配给服务器端点。
`RondRobin <https://en.wikipedia.org/wiki/Round-robin_scheduling>`_
参数:
- **pserver_endpoints** (list) - endpoint （ip:port）的 list
doc/fluid/beginners_guide/basics/index.rst
浏览文件 @ cb4f4929
################ ################
深度学习基础知识 深度学习基础
################ ################
.. todo:: 本章由6篇文档组成，它们按照简单到难的顺序排列，将指导您如何使用PaddlePaddle完成基础的深度学习任务
概述 本章文档涉及大量了深度学习基础知识，也介绍了如何使用PaddlePaddle实现这些内容，请参阅以下说明了解如何使用：
内容简介
======================
您现在在看的这本书是一本“交互式”电子书 —— 每一章都可以运行在一个Jupyter Notebook里。
.. toctree:: .. toctree::
:titlesonly: :titlesonly:
...@@ -16,3 +21,67 @@ ...@@ -16,3 +21,67 @@
understand_sentiment/index.md understand_sentiment/index.md
label_semantic_roles/index.md label_semantic_roles/index.md
machine_translation/index.md machine_translation/index.md
我们把Jupyter、PaddlePaddle、以及各种被依赖的软件都打包进一个Docker image了。所以您不需要自己来安装各种软件，只需要安装Docker即可。对于各种Linux发行版，请参考 https://www.docker.com 。如果您使用 `Windows <https://www.docker.com/docker-windows>`_ 或者 `Mac <https://www.docker.com/docker-mac>`_，可以考虑 `给Docker更多内存和CPU资源 <http://stackoverflow.com/a/39720010/724872>`_ 。
使用方法
======================
本书默认使用CPU训练，若是要使用GPU训练，使用步骤会稍有变化,请参考下文“使用GPU训练”
使用CPU训练
>>>>>>>>>>>>
只需要在命令行窗口里运行：
.. code-block:: shell
docker run -d -p 8888:8888 paddlepaddle/book
即可从DockerHub.com下载和运行本书的Docker image。阅读和在线编辑本书请在浏览器里访问 http://localhost:8888
如果您访问DockerHub.com很慢，可以试试我们的另一个镜像docker.paddlepaddlehub.com：
::
docker run -d -p 8888:8888 docker.paddlepaddlehub.com/book
使用GPU训练
>>>>>>>>>>>>>
为了保证GPU驱动能够在镜像里面正常运行，我们推荐使用 `nvidia-docker <https://github.com/NVIDIA/nvidia-docker>`_ 来运行镜像。请先安装nvidia-docker，之后请运行：
::
nvidia-docker run -d -p 8888:8888 paddlepaddle/book:latest-gpu
或者使用国内的镜像请运行：
::
nvidia-docker run -d -p 8888:8888 docker.paddlepaddlehub.com/book:latest-gpu
还需要将以下代码
.. code-block:: python
use_cuda = False
改成：
.. code-block:: python
use_cuda = True
贡献新章节
=============
您要是能贡献新的章节那就太好了！请发Pull Requests把您写的章节加入到 :code:`pending` 下面的一个子目录里。当这一章稳定下来，我们一起把您的目录挪到根目录。
为了写作、运行、调试，您需要安装Python 2.x和Go >1.5, 并可以用 `脚本程序 <https://github.com/PaddlePaddle/book/blob/develop/.tools/convert-markdown-into-ipynb-and-test.sh>`_ 来生成新的Docker image。
**Please Note:** We also provide `English Readme <https://github.com/PaddlePaddle/book/blob/develop/README.md>`_ for PaddlePaddle book
doc/fluid/beginners_guide/index.rst
浏览文件 @ cb4f4929
...@@ -4,16 +4,11 @@ ...@@ -4,16 +4,11 @@
PaddlePaddle (PArallel Distributed Deep LEarning)是一个易用、高效、灵活、可扩展的深度学习框架 PaddlePaddle (PArallel Distributed Deep LEarning)是一个易用、高效、灵活、可扩展的深度学习框架
您可参考我们的 `Github <https://github.com/PaddlePaddle/Paddle>`_ 了解详情，也可阅读 `版本说明 <../release_note.html>`_ 了解新版本的特性 您可参考PaddlePaddle的 `Github <https://github.com/PaddlePaddle/Paddle>`_ 了解详情，也可阅读 `版本说明 <../release_note.html>`_ 了解新版本的特性
=========
概览
=========
当您第一次来到PaddlePaddle，请您首先阅读以下文档，了解安装方法： 当您第一次来到PaddlePaddle，请您首先阅读以下文档，了解安装方法：
- `安装说明 <../beginners_guide/install/Start.html>`_：我们支持在Ubunt/CentOS/Windows/MacOS环境上的安装 - `安装说明 <../beginners_guide/install/Start.html>`_：我们支持在Ubuntu/CentOS/Windows/MacOS环境上的安装
如果您初次接触深度学习，在学习PaddlePaddle之前建议您先阅读以下资料： 如果您初次接触深度学习，在学习PaddlePaddle之前建议您先阅读以下资料：
...@@ -27,17 +22,13 @@ PaddlePaddle (PArallel Distributed Deep LEarning)是一个易用、高效、灵 ...@@ -27,17 +22,13 @@ PaddlePaddle (PArallel Distributed Deep LEarning)是一个易用、高效、灵
- `快速入门 <../beginners_guide/quick_start/index.html>`_：提供线性回归和识别数字两个入门级模型，帮助您快速上手训练网络 - `快速入门 <../beginners_guide/quick_start/index.html>`_：提供线性回归和识别数字两个入门级模型，帮助您快速上手训练网络
- `深度学习基础知识 <../beginners_guide/basics/index.html>`_：覆盖图像分类、个性化推荐、机器翻译等多个深度领域的基础知识，提供 Fluid 实现案例 - `深度学习基础 <../beginners_guide/basics/index.html>`_：覆盖图像分类、个性化推荐、机器翻译等多个深度领域的基础知识，提供 Fluid 实现案例
=========
目录
=========
.. toctree:: .. toctree::
:maxdepth: 2 :hidden:
install/Start.rst install/index_cn.rst
quick_start/index.rst quick_start/index.rst
basics/index.rst basics/index.rst
basics/learning_materials.md basics/learning_materials.md
......
doc/fluid/beginners_guide/install/compile/compile_CentOS.md
浏览文件 @ cb4f4929
...@@ -63,7 +63,7 @@ ...@@ -63,7 +63,7 @@
7. 使用以下命令安装相关依赖： 7. 使用以下命令安装相关依赖：
For Python2: pip install protobuf==3.1.0 For Python2: pip install protobuf==3.1.0
For Python3: pip install protobuf==3.1.0 For Python3: pip3 install protobuf==3.1.0
> 安装protobuf 3.1.0。 > 安装protobuf 3.1.0。
...@@ -127,48 +127,42 @@ ...@@ -127,48 +127,42 @@
* a. 安装Python-dev: * a. 安装Python-dev:
For Python2: yum install python-devel For Python2: yum install python-devel
For Python3: (这里由于python3.5的编译安装过程较为复杂，请参照Python官方流程安装） For Python3: (请参照Python官方流程安装）
* b. 安装pip: * b. 安装pip:
For Python2: yum install python-pip (请保证拥有9.0.1及以上的pip版本) For Python2: yum install python-pip (请保证拥有9.0.1及以上的pip版本)
For Python3: (这里由于pip3的编译安装过程较为复杂，请参照Python官方流程安装）(请保证拥有9.0.1及以上的pip3版本） For Python3: (请参照Python官方流程安装, 并保证拥有9.0.1及以上的pip3版本，请注意，python3.6及以上版本环境下，pip3并不一定对应python版本，如python3.7下默认只有pip3.7）
* c.（Only For Python3）设置Python3相关的环境变量，这里以python3.5版本示例，请替换成您使用的版本（3.6、3.7）：
* c.（Only For Python3）设置Python3相关的环境变量：
1. 首先使用``` find `dirname $(dirname 1. 首先使用``` find `dirname $(dirname
$(which python3))` -name "libpython3.so"```找到Pythonlib的路径，然后（下面[python-lib-path]替换为找到文件路径） $(which python3))` -name "libpython3.so"```找到Python lib的路径，如果是3.6或3.7，请将`python3`改成`python3.6`或`python3.7`，然后将下面[python-lib-path]替换为找到文件路径
2. 设置PYTHON_LIBRARIES：`export PYTHON_LIBRARY=[python-lib-path]` 2. 设置PYTHON_LIBRARIES：`export PYTHON_LIBRARY=[python-lib-path]`
3. 其次使用```find `dirname $(dirname 3. 其次使用```find `dirname $(dirname
$(which python3))`/include -name "python3.5m"```找到PythonInclude的路径，然后（下面[python-include-path]替换为找到文件路径） $(which python3))`/include -name "python3.5m"```找到Python Include的路径，请注意python版本，然后将下面[python-include-path]替换为找到文件路径
4. 设置PYTHON_INCLUDE_DIR: `export PYTHON_INCLUDE_DIRS=[python-include-path]` 4. 设置PYTHON_INCLUDE_DIR: `export PYTHON_INCLUDE_DIRS=[python-include-path]`
5. 设置系统环境变量路径：`export PATH=[python-lib-path]:$PATH` （这里将[python-lib-path]的最后两级目录替换为/bin/) 5. 设置系统环境变量路径：`export PATH=[python-lib-path]:$PATH` （这里将[python-lib-path]的最后两级目录替换为/bin/)
* d. 安装虚环境`virtualenv`以及`virtualenvwrapper`并创建名为`paddle-venv`的虚环境：(请注意对应python版本的pip3的命令，如pip3.6、pip3.7)
* d. 安装虚环境`virtualenv`以及`virtualenvwrapper`并创建名为`paddle-venv`的虚环境：
1. `pip install virtualenv` 或 `pip3 install virtualenv` 1. `pip install virtualenv` 或 `pip3 install virtualenv`
2. `pip install virtualenvwrapper` 或 `pip3 install virtualenvwrapper` 2. `pip install virtualenvwrapper` 或 `pip3 install virtualenvwrapper`
3. 找到`virtualenvwrapper.sh`： `find / -name virtualenvwrapper.sh`（请找到对应Python版本的`virtualenvwrapper.sh` 3. 找到`virtualenvwrapper.sh`： `find / -name virtualenvwrapper.sh`（请找到对应Python版本的`virtualenvwrapper.sh`）
4. 查看`virtualenvwrapper.sh`中的安装方法： `cat vitualenvwrapper.sh` 4. 查看`virtualenvwrapper.sh`中的安装方法： `cat vitualenvwrapper.sh`
5. 安装`virtualwrapper` 5. 安装`virtualwrapper`
6. 创建名为`paddle-venv`的虚环境： `mkvirtualenv paddle-venv` 6. 创建名为`paddle-venv`的虚环境： `mkvirtualenv paddle-venv`
5. 进入虚环境：`workon paddle-venv` 5. 进入虚环境：`workon paddle-venv`
6. **执行编译前**请您确认在虚环境中安装有[编译依赖表](../Tables.html/#third_party)中提到的相关依赖：<!--TODO：Link 安装依赖表到这里--> 6. **执行编译前**请您确认在虚环境中安装有[编译依赖表](../Tables.html/#third_party)中提到的相关依赖：<!--TODO：Link 安装依赖表到这里-->
* 这里特别提供`patchELF`的安装方法，其他的依赖可以使用`yum install`或者`pip install`/`pip3 install` 后跟依赖名称和版本安装: * 这里特别提供`patchELF`的安装方法，其他的依赖可以使用`yum install`或者`pip install`/`pip3 install` 后跟依赖名称和版本安装:
`yum install patchelf` `yum install patchelf`
> 不能使用apt安装的用户请参见patchElF github[官方文档](https://gist.github.com/ruario/80fefd174b3395d34c14) > 不能使用apt安装的用户请参见patchElF github[官方文档](https://gist.github.com/ruario/80fefd174b3395d34c14)
7. 将PaddlePaddle的源码clone在当下目录下的Paddle的文件夹中，并进入Padde目录下： 7. 将PaddlePaddle的源码clone在当下目录下的Paddle的文件夹中，并进入Padde目录下：
...@@ -177,9 +171,9 @@ ...@@ -177,9 +171,9 @@
- `cd Paddle` - `cd Paddle`
8. 切换到较稳定release分支下进行编译： 8. 切换到较稳定release分支下进行编译(从1.2.0分支开始支持python3.6及3.7版本)：
`git checkout release/1.0.0` `git checkout release/1.2.0`
9. 并且请创建并进入一个叫build的目录下： 9. 并且请创建并进入一个叫build的目录下：
...@@ -189,17 +183,14 @@ ...@@ -189,17 +183,14 @@
>具体编译选项含义请参见[编译选项表](../Tables.html/#Compile)<!--TODO：Link 安装选项表到这里--> >具体编译选项含义请参见[编译选项表](../Tables.html/#Compile)<!--TODO：Link 安装选项表到这里-->
* 对于需要编译**CPU版本PaddlePaddle**的用户： * 对于需要编译**CPU版本PaddlePaddle**的用户：
For Python2: cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release For Python2: cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release
For Python3: cmake .. -DPY_VERSION=3.5 -DPYTHON_INCLUDE_DIR=${PYTHON_INCLUDE_DIRS} \ For Python3: cmake .. -DPY_VERSION=3.5 -DPYTHON_INCLUDE_DIR=${PYTHON_INCLUDE_DIRS} \
-DPYTHON_LIBRARY=${PYTHON_LIBRARY} -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release -DPYTHON_LIBRARY=${PYTHON_LIBRARY} -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release
> 如果遇到`Could NOT find PROTOBUF (missing: PROTOBUF_LIBRARY PROTOBUF_INCLUDE_DIR)`可以重新执行一次cmake指令。
> 如果遇到`Could NOT find PROTOBUF (missing: PROTOBUF_LIBRARY PROTOBUF_INCLUDE_DIR)`可以重新执行一次cmake指令 > 请注意PY_VERSION参数更换为您需要的python版本
11. 使用以下命令来编译： 11. 使用以下命令来编译：
......
doc/fluid/beginners_guide/install/compile/compile_MacOS.md
浏览文件 @ cb4f4929
...@@ -74,7 +74,7 @@ ...@@ -74,7 +74,7 @@
8. 使用以下命令安装相关依赖： 8. 使用以下命令安装相关依赖：
For Python2: pip install protobuf==3.1.0 For Python2: pip install protobuf==3.1.0
For Python3: pip install protobuf==3.1.0 For Python3: pip3 install protobuf==3.1.0
> 安装protobuf 3.1.0。 > 安装protobuf 3.1.0。
...@@ -128,7 +128,7 @@ ...@@ -128,7 +128,7 @@
2. 安装python以及pip： 2. 安装python以及pip：
> **请不要使用MacOS中自带python**，我们强烈建议您使用[Homebrew](https://brew.sh)安装python(对于**Python3**请使用python[官方下载](https://www.python.org/downloads/mac-osx/)python3.5.x), pip以及其他的依赖，这会大大降低您安装编译的难度。 > **请不要使用MacOS中自带python**，我们强烈建议您使用[Homebrew](https://brew.sh)安装python(对于**Python3**请使用python[官方下载](https://www.python.org/downloads/mac-osx/)python3.5.x、python3.6.x、python3.7.x), pip以及其他的依赖，这会大大降低您安装编译的难度。
For python2: brew install python@2 For python2: brew install python@2
For python3: 使用Python官网安装 For python3: 使用Python官网安装
...@@ -180,7 +180,7 @@ ...@@ -180,7 +180,7 @@
- `cd Paddle` - `cd Paddle`
7. 切换到较稳定release分支下进行编译： 7. 切换到较稳定release分支下进行编译：(注意，python3.6、python3.7版本是从1.2.0分支开始支持)
`git checkout release/1.0.0` `git checkout release/1.0.0`
...@@ -192,12 +192,12 @@ ...@@ -192,12 +192,12 @@
>具体编译选项含义请参见[编译选项表](../Tables.html/#Compile)<!--TODO：Link 安装选项表到这里--> >具体编译选项含义请参见[编译选项表](../Tables.html/#Compile)<!--TODO：Link 安装选项表到这里-->
* 对于需要编译**CPU版本PaddlePaddle**的用户： * 对于需要编译**CPU版本PaddlePaddle**的用户：
For Python2: cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release For Python2: cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release
For Python3: cmake .. -DPY_VERSION=3.5 -DPYTHON_INCLUDE_DIR=${PYTHON_INCLUDE_DIRS} \ For Python3: cmake .. -DPY_VERSION=3.5 -DPYTHON_INCLUDE_DIR=${PYTHON_INCLUDE_DIRS} \
-DPYTHON_LIBRARY=${PYTHON_LIBRARY} -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release -DPYTHON_LIBRARY=${PYTHON_LIBRARY} -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release
>`-DPY_VERSION=3.5`请修改为安装环境的Python版本
10. 使用以下命令来编译： 10. 使用以下命令来编译：
......
doc/fluid/beginners_guide/install/compile/compile_Ubuntu.md
浏览文件 @ cb4f4929
...@@ -54,9 +54,9 @@ ...@@ -54,9 +54,9 @@
4. 进入Docker后进入paddle目录下：`cd paddle` 4. 进入Docker后进入paddle目录下：`cd paddle`
5. 切换到较稳定版本下进行编译： 5. 切换到较稳定release分支下进行编译：(注意，python3.6、python3.7版本是从1.2.0分支开始支持)
`git checkout v1.1` `git checkout release/1.2.0`
6. 创建并进入/paddle/build路径下： 6. 创建并进入/paddle/build路径下：
...@@ -65,8 +65,7 @@ ...@@ -65,8 +65,7 @@
7. 使用以下命令安装相关依赖： 7. 使用以下命令安装相关依赖：
For Python2: pip install protobuf==3.1.0 For Python2: pip install protobuf==3.1.0
For Python3: pip install protobuf==3.1.0 For Python3: pip3 install protobuf==3.1.0
> 安装protobuf 3.1.0。 > 安装protobuf 3.1.0。
...@@ -77,16 +76,15 @@ ...@@ -77,16 +76,15 @@
8. 执行cmake： 8. 执行cmake：
>具体编译选项含义请参见[编译选项表](../Tables.html/#Compile)<!--TODO: Link 编译选项表到这里--> >具体编译选项含义请参见[编译选项表](../Tables.html/#Compile)<!--TODO: Link 编译选项表到这里-->
>请注意修改参数`-DPY_VERSION`为您当前环境下使用的python版本
* 对于需要编译**CPU版本PaddlePaddle**的用户： * 对于需要编译**CPU版本PaddlePaddle**的用户：
`cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release` `cmake .. -DPY_VERSION=3.5 -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release`
* 对于需要编译**GPU版本PaddlePaddle**的用户： * 对于需要编译**GPU版本PaddlePaddle**的用户：
`cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=ON -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release` `cmake .. -DPY_VERSION=3.5 -DWITH_FLUID_ONLY=ON -DWITH_GPU=ON -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release`
9. 执行编译： 9. 执行编译：
...@@ -114,32 +112,25 @@ ...@@ -114,32 +112,25 @@
<br/><br/> <br/><br/>
### ***本机编译*** ### ***本机编译***
**请严格按照以下指令顺序执行** **请严格按照以下指令顺序执行**
1. 检查您的计算机和操作系统是否符合我们支持的编译标准： `uname -m && cat /etc/*release` 1. 检查您的计算机和操作系统是否符合我们支持的编译标准： `uname -m && cat /etc/*release`
2. 更新`apt`的源： `apt update` 2. 更新`apt`的源： `apt update`
2. 我们支持使用virtualenv进行编译安装，首先请使用以下命令创建一个名为`paddle-venv`的虚环境： 3. 我们支持使用virtualenv进行编译安装，首先请使用以下命令创建一个名为`paddle-venv`的虚环境：
* a. 安装Python-dev:
* a. 安装Python-dev:（请安装与当前环境python版本匹配的python3.x-dev）
For Python2: apt install python-dev For Python2: apt install python-dev
For Python3: apt install python3.5-dev For Python3: apt install python3.5-dev
* b. 安装pip: (请保证拥有9.0.1及以上版本的pip):（请注意修改对应python3的版本）
* b. 安装pip: (请保证拥有9.0.1及以上版本的pip):
For Python2: apt install python-pip For Python2: apt install python-pip
For Python3: apt install curl && curl https://bootstrap.pypa.io/get-pip.py -o - | python3.5 && easy_install pip For Python3: apt-get udpate && apt-get install -y software-properties-common && add-apt-repository ppa:deadsnakes/ppa && apt install curl && curl https://bootstrap.pypa.io/get-pip.py -o - | python3.5 && easy_install pip
* c. 安装虚环境`virtualenv`以及`virtualenvwrapper`并创建名为`paddle-venv`的虚环境： * c. 安装虚环境`virtualenv`以及`virtualenvwrapper`并创建名为`paddle-venv`的虚环境：(请注意修改python版本)
1. `apt install virtualenv` 或 `pip install virtualenv` 或 `pip3 install virtualenv` 1. `apt install virtualenv` 或 `pip install virtualenv` 或 `pip3 install virtualenv`
2. `apt install virtualenvwrapper` 或 `pip install virtualenvwrapper` 或 `pip3 install virtualenvwrapper` 2. `apt install virtualenvwrapper` 或 `pip install virtualenvwrapper` 或 `pip3 install virtualenvwrapper`
...@@ -149,11 +140,9 @@ ...@@ -149,11 +140,9 @@
6. 按照`virtualenvwrapper.sh`中的安装方法安装`virtualwrapper` 6. 按照`virtualenvwrapper.sh`中的安装方法安装`virtualwrapper`
7. 创建名为`paddle-venv`的虚环境： `mkvirtualenv paddle-venv` 7. 创建名为`paddle-venv`的虚环境： `mkvirtualenv paddle-venv`
4. 进入虚环境：`workon paddle-venv`
3. 进入虚环境：`workon paddle-venv` 5. **执行编译前**请您确认在虚环境中安装有[编译依赖表](../Tables.html/#third_party)中提到的相关依赖：<!--TODO：Link 安装依赖表到这里-->
4. **执行编译前**请您确认在虚环境中安装有[编译依赖表](../Tables.html/#third_party)中提到的相关依赖：<!--TODO：Link 安装依赖表到这里-->
* 这里特别提供`patchELF`的安装方法，其他的依赖可以使用`apt install`或者`pip install` 后跟依赖名称和版本安装: * 这里特别提供`patchELF`的安装方法，其他的依赖可以使用`apt install`或者`pip install` 后跟依赖名称和版本安装:
...@@ -179,13 +168,11 @@ ...@@ -179,13 +168,11 @@
>具体编译选项含义请参见[编译选项表](../Tables.html/#Compile)<!--TODO：Link 安装选项表到这里--> >具体编译选项含义请参见[编译选项表](../Tables.html/#Compile)<!--TODO：Link 安装选项表到这里-->
* 对于需要编译**CPU版本PaddlePaddle**的用户：(*For Python3: 请给PY_VERSION参数配置正确的python版本*)
* 对于需要编译**CPU版本PaddlePaddle**的用户：
For Python2: cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release For Python2: cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release
For Python3: cmake .. -DPY_VERSION=3.5 -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release For Python3: cmake .. -DPY_VERSION=3.5 -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release
* 对于需要编译**GPU版本PaddlePaddle**的用户：(*仅支持ubuntu16.04/14.04*) * 对于需要编译**GPU版本PaddlePaddle**的用户：(*仅支持ubuntu16.04/14.04*)
1. 请确保您已经正确安装nccl2，或者按照以下指令安装nccl2（这里提供的是ubuntu 16.04，CUDA9，cuDNN7下nccl2的安装指令），更多版本的安装信息请参考NVIDIA[官方网站](https://developer.nvidia.com/nccl/nccl-download): 1. 请确保您已经正确安装nccl2，或者按照以下指令安装nccl2（这里提供的是ubuntu 16.04，CUDA9，cuDNN7下nccl2的安装指令），更多版本的安装信息请参考NVIDIA[官方网站](https://developer.nvidia.com/nccl/nccl-download):
...@@ -193,11 +180,13 @@ ...@@ -193,11 +180,13 @@
ii. `dpkg -i nvidia-machine-learning-repo-ubuntu1604_1.0.0-1_amd64.deb` ii. `dpkg -i nvidia-machine-learning-repo-ubuntu1604_1.0.0-1_amd64.deb`
iii. `sudo apt-get install -y libnccl2=2.2.13-1+cuda9.0 libnccl-dev=2.2.13-1+cuda9.0` iii. `sudo apt-get install -y libnccl2=2.2.13-1+cuda9.0 libnccl-dev=2.2.13-1+cuda9.0`
2. 如果您已经正确安装了`nccl2`，就可以开始cmake了： 2. 如果您已经正确安装了`nccl2`，就可以开始cmake了：(*For Python3: 请给PY_VERSION参数配置正确的python版本*)
For Python2: cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=ON -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release For Python2: cmake .. -DWITH_FLUID_ONLY=ON -DWITH_GPU=ON -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release
For Python3: cmake .. -DPY_VERSION=3.5 -DWITH_FLUID_ONLY=ON -DWITH_GPU=ON -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release For Python3: cmake .. -DPY_VERSION=3.5 -DWITH_FLUID_ONLY=ON -DWITH_GPU=ON -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release
>`-DPY_VERSION=3.5`请修改为安装环境的Python版本
9. 使用以下命令来编译： 9. 使用以下命令来编译：
`make -j$(nproc)` `make -j$(nproc)`
......
doc/fluid/beginners_guide/install/compile/compile_Windows.md 0 → 100644
浏览文件 @ cb4f4929
***
# **Windows下从源码编译**
本说明将介绍如何在*64位台式机或笔记本电脑*以及Windows 10系统下编译PaddlePaddle，我们支持的Windows系统需满足以下要求：
* Windows 10 家庭版/专业版/企业版
* Visual Studio 2015 Update3
## 确定要编译的版本
* **仅支持CPU的PaddlePaddle**。
<!--* 支持GPU的PaddlePaddle，为了使得PaddlePaddle程序运行的更加迅速，我们通常使用GPU对PaddlePaddle程序进行加速，但安装GPU版本的PaddlePaddle需要先拥有满足以下条件的NVIDIA? GPU（具体安装流程和配置请务必参见NVIDIA官方文档：[For CUDA](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/)，[For cuDNN](https://docs.nvidia.com/deeplearning/sdk/cudnn-install/)）
* *Cuda 工具包9.0配合cuDNN v7*
* *Cuda 工具包8.0配合cuDNN v7*
* *GPU运算能力超过1.0的硬件设备*-->
## 选择如何编译
我们在Windows的系统下提供1种编译方式：
* 直接本机源码编译
由于在本机上的情况更加复杂，因此我们只支持特定的系统。
请注意：当前版本不支持NCCL，分布式，AVX，warpctc和MKL相关功能。
<a name="ct_source"></a>
### ***本机编译***
**请严格按照以下指令顺序执行**
1. 检查您的计算机和操作系统是否符合我们支持的编译标准
* Windows 10 家庭版/专业版/企业版
* Visual Studio 2015 Update3
2. 安装必要的工具 cmake，git 以及 python ：
> cmake 需要3.0 及以上版本, 可以在官网进行下载，并添加到环境变量中。 [下载地址](https://cmake.org/download/)
> git可以在官网进行下载，并添加到环境变量中。 [下载地址](https://gitforwindows.org/)
> python 需要2.7 及以上版本, 同时确保 `numpy, protobuf, wheel` 等模块得到安装 [下载地址](https://www.python.org/download/releases/2.7/)
* 安装 numpy 包可以通过命令 `pip install numpy` 或 `pip3 install numpy`
* 安装 protobuf 包可以通过命令 `pip install protobuf` 或 `pip3 install protobuf`
* 安装 wheel 包可以通过命令 `pip install wheel` 或 `pip3 install wheel`
3. 将PaddlePaddle的源码clone在当下目录下的Paddle的文件夹中，并进入Padde目录下：
- `git clone https://github.com/PaddlePaddle/Paddle.git`
- `cd Paddle`
4. 切换到较稳定release分支下进行编译(支持1.2.x及以上版本)：
- `git checkout release/x.x.x`
5. 创建名为build的目录并进入：
- `mkdir build`
- `cd build`
6. 执行cmake：
>具体编译选项含义请参见[编译选项表](../Tables.html/#Compile)<!--TODO：Link 安装选项表到这里-->
* 对于需要编译**CPU版本PaddlePaddle**的用户：
For Python2: `cmake .. -G "Visual Studio 14 2015 Win64" -DPYTHON_INCLUDE_DIR=${PYTHON_INCLUDE_DIRS}
-DPYTHON_LIBRARY=${PYTHON_LIBRARY}
-DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE} -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release`
For Python3: `cmake .. -G "Visual Studio 14 2015 Win64" -DPY_VERSION=3.5 -DPYTHON_INCLUDE_DIR=${PYTHON_INCLUDE_DIRS}
-DPYTHON_LIBRARY=${PYTHON_LIBRARY}
-DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE} -DWITH_FLUID_ONLY=ON -DWITH_GPU=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release`
> 如果遇到`Could NOT find PROTOBUF (missing: PROTOBUF_LIBRARY PROTOBUF_INCLUDE_DIR)`可以重新执行一次cmake指令
7. 部分第三方依赖包（openblas，snappystream）目前需要用户自己提供预编译版本，也可以到 `https://github.com/wopeizl/Paddle_deps` 下载预编译好的文件， 将整个 `third_party` 文件夹放到 `build` 目录下.
8. 使用Blend for Visual Studio 2015 打开 `paddle.sln` 文件，选择平台为 `x64`，配置为 `Release`，开始编译
9. 编译成功后进入 `\paddle\build\python\dist` 目录下找到生成的 `.whl` 包：
`cd \paddle\build\python\dist`
10. 在当前机器或目标机器安装编译好的 `.whl` 包：
`pip install （whl包的名字）` 或 `pip3 install （whl包的名字）`
恭喜您，现在您已经完成使本机编译PaddlePaddle的过程了。
## ***验证安装***
安装完成后您可以使用：`python` 进入Python解释器，然后使用 `import paddle.fluid`, 如沒有提示错误，则表明安装成功。
## ***如何卸载***
请使用以下命令卸载PaddlePaddle：
* ***CPU版本的PaddlePaddle***: `pip uninstall paddlepaddle` 或 `pip3 uninstall paddlepaddle`
doc/fluid/beginners_guide/install/compile/fromsource.rst
浏览文件 @ cb4f4929
...@@ -4,10 +4,11 @@ ...@@ -4,10 +4,11 @@
您也可以选择源码编译的方式编译安装PaddlePaddle，但由于本机环境的多样性，在编译源码时易出现复杂问题，可能会造成您安装失败。为保证您顺利安装，推荐您优先选择普通安装方式。 您也可以选择源码编译的方式编译安装PaddlePaddle，但由于本机环境的多样性，在编译源码时易出现复杂问题，可能会造成您安装失败。为保证您顺利安装，推荐您优先选择普通安装方式。
**编译PaddlePaddle**
---------------------
.. toctree:: .. toctree::
:hidden:
compile_Ubuntu.md compile_Ubuntu.md
compile_CentOS.md compile_CentOS.md
compile_MacOS.md compile_MacOS.md
compile_Windows.md
doc/fluid/beginners_guide/install/Start.rst → doc/fluid/beginners_guide/install/index_cn.rst
浏览文件 @ cb4f4929
...@@ -25,28 +25,13 @@ ...@@ -25,28 +25,13 @@
其中[docker版本号]请查阅 `DockerHub <https://hub.docker.com/r/paddlepaddle/paddle/tags/>`_ 其中[docker版本号]请查阅 `DockerHub <https://hub.docker.com/r/paddlepaddle/paddle/tags/>`_
如果对上面的指令有疑问或者不能正常使用，请参见以下内容
安装PaddlePaddle
-----------------------
.. toctree:: .. toctree::
:maxdepth:1 :hidden:
install_Ubuntu.md install_Ubuntu.md
install_CentOS.md install_CentOS.md
install_MacOS.md install_MacOS.md
install_Windows.md install_Windows.md
compile/fromsource.rst compile/fromsource.rst
参考信息
-----------------------
如在安装或编译过程中遇到问题请参见
.. toctree::
:maxdepth:1
FAQ.md FAQ.md
Tables.md Tables.md
doc/fluid/beginners_guide/install/install_CentOS.md
浏览文件 @ cb4f4929
...@@ -52,7 +52,7 @@ Python2.7： ...@@ -52,7 +52,7 @@ Python2.7：
yum update && yum install -y epel-release && yum install -y python-devel python-pip && pip install paddlepaddle yum update && yum install -y epel-release && yum install -y python-devel python-pip && pip install paddlepaddle
Python3.5: (由于在CentOS下安装Python3的方法较为复杂，我们提供默认您已经正确安装python3.5已经pip3之后的安装命令） Python3.5、3.6、3.7: (由于在CentOS下安装Python3的方法较为复杂，我们提供默认您已经正确安装python3.5+以及pip3之后的安装命令）
yum update && yum install -y epel-release && pip3 install paddlepaddle yum update && yum install -y epel-release && pip3 install paddlepaddle
...@@ -70,8 +70,7 @@ Python3.5: (由于在CentOS下安装Python3的方法较为复杂，我们提供 ...@@ -70,8 +70,7 @@ Python3.5: (由于在CentOS下安装Python3的方法较为复杂，我们提供
> CentOS6需要编译Python2.7成[共享库](./FAQ.html/#FAQ)。 > CentOS6需要编译Python2.7成[共享库](./FAQ.html/#FAQ)。
* Python3.5.x (devel)，Pip3 >= 9.0.1 * Python3.5+.x (devel)，Pip3 >= 9.0.1
> 您的CentOS上可能已经安装pip请使用pip -V来确认我们建议使用pip 9.0.1或更高版本来安装。 > 您的CentOS上可能已经安装pip请使用pip -V来确认我们建议使用pip 9.0.1或更高版本来安装。
...@@ -79,9 +78,8 @@ Python3.5: (由于在CentOS下安装Python3的方法较为复杂，我们提供 ...@@ -79,9 +78,8 @@ Python3.5: (由于在CentOS下安装Python3的方法较为复杂，我们提供
使用以下命令安装或升级Python和pip到需要的版本： 使用以下命令安装或升级Python和pip到需要的版本：
- For Python2: `sudo yum install python-devel python-pip` - For Python2: `sudo yum install python-devel python-pip`
- For Python3: (这里由于python3.5的编译安装过程较为复杂，请参照Python官方流程安装） - For Python3: (请参照Python官方流程安装，并注意pip3命令对应的python3版本是否一致，如果有多个python3版本，请指定pip版本如pip3.7，或者将pip3软链到您使用的python版本下）
> 即使您的环境中已经有`Python`也需要安装`python develop`套装。 > 即使您的环境中已经有`Python`也需要安装`python develop`套装。
...@@ -91,13 +89,12 @@ Python3.5: (由于在CentOS下安装Python3的方法较为复杂，我们提供 ...@@ -91,13 +89,12 @@ Python3.5: (由于在CentOS下安装Python3的方法较为复杂，我们提供
* 对于需要**CPU版本PaddlePaddle**的用户：`pip install paddlepaddle` 或 `pip3 install paddlepaddle` * 对于需要**CPU版本PaddlePaddle**的用户：`pip install paddlepaddle` 或 `pip3 install paddlepaddle`
* 对于需要**GPU版本PaddlePaddle**的用户: `pip install paddlepaddle-gpu` 或 `pip3 install paddlepaddle-gpu` * 对于需要**GPU版本PaddlePaddle**的用户: `pip install paddlepaddle-gpu` 或 `pip3 install paddlepaddle-gpu`
> 1. 为防止出现nccl.h找不到的问题请首先按照NVIDIA[官方网站](https://developer.nvidia.com/nccl/nccl-download)的指示正确安装nccl2 > 1. 为防止出现nccl.h找不到的问题请首先按照NVIDIA[官方网站](https://developer.nvidia.com/nccl/nccl-download)的指示正确安装nccl2
> 2. 如果您不规定pypi包版本号，我们默认为您提供支持Cuda 9/cuDNN v7的PaddlePaddle版本。 > 2. 如果您不规定pypi包版本号，我们默认为您提供支持Cuda 9/cuDNN v7的PaddlePaddle版本。
对于出现`Cannot uninstall 'six'.`问题的用户，可是由于您的系统中已有的Python安装问题造 成的，请使用`pip install paddlepaddle --ignore-installed six`（CPU）或`pip install paddlepaddle-gpu --ignore-installed six`（GPU）解决。 * 对于出现`Cannot uninstall 'six'.`问题的用户，可是由于您的系统中已有的Python安装问题造 成的，请使用`pip install paddlepaddle --ignore-installed six`（CPU）或`pip install paddlepaddle-gpu --ignore-installed six`（GPU）解决。
* 对于有**其他要求**的用户：`pip install paddlepaddle==[版本号]` 或 `pip3 install paddlepaddle==[版本号]` * 对于有**其他要求**的用户：`pip install paddlepaddle==[版本号]` 或 `pip3 install paddlepaddle==[版本号]`
...@@ -130,14 +127,10 @@ Python3.5: (由于在CentOS下安装Python3的方法较为复杂，我们提供 ...@@ -130,14 +127,10 @@ Python3.5: (由于在CentOS下安装Python3的方法较为复杂，我们提供
1. 使用以下指令拉取我们为您预安装好PaddlePaddle的镜像： 1. 使用以下指令拉取我们为您预安装好PaddlePaddle的镜像：
* 对于需要**CPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For CPU*的镜像： * 对于需要**CPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For CPU*的镜像：
`docker pull hub.baidubce.com/paddlepaddle/paddle:1.1` `docker pull hub.baidubce.com/paddlepaddle/paddle:1.1`
* 您也可以通过以下指令拉取任意的我们提供的Docker镜像： * 您也可以通过以下指令拉取任意的我们提供的Docker镜像：
`docker pull hub.baidubce.com/paddlepaddle/paddle:[tag]` `docker pull hub.baidubce.com/paddlepaddle/paddle:[tag]`
......
doc/fluid/beginners_guide/install/install_MacOS.md
浏览文件 @ cb4f4929
...@@ -38,13 +38,15 @@ ...@@ -38,13 +38,15 @@
其次，您的计算机需要满足以下要求： 其次，您的计算机需要满足以下要求：
> **请不要使用MacOS中自带python**，对于**Python2**，建议您使用[Homebrew](https://brew.sh)或[Python.org](https://www.python.org/ftp/python/2.7.15/python-2.7.15-macosx10.9.pkg)提供的python2.7.15；对于**Python3**，请使用[Python.org](https://www.python.org/downloads/mac-osx/)提供的python3.5.x。 > **请不要使用MacOS中自带python**，对于**Python2**，建议您使用[Homebrew](https://brew.sh)或[Python.org](https://www.python.org/ftp/python/2.7.15/python-2.7.15-macosx10.9.pkg)提供的python2.7.15；对于**Python3**，请使用[Python.org](https://www.python.org/downloads/mac-osx/)提供的python3.5.x、python3.6.x或python3.7.x。
For python2: brew install python@2 或 使用Python官方下载的python2.7.15 For python2: brew install python@2 或 使用Python官方下载的python2.7.15
For python3: 使用Python官方下载的python3.5.x For python3: 使用Python官方下载的python3.5.x、python3.6.x或python3.7.x
* Python2.7.x，Pip >= 9.0.1 * Python2.7.x，Pip >= 9.0.1
* Python3.5.x，Pip3 >= 9.0.1 * Python3.5.x，Pip3 >= 9.0.1
* Python3.6.x，Pip3 >= 9.0.1
* Python3.7.x，Pip3 >= 9.0.1
> 注： 您的MacOS上可能已经安装pip请使用pip -V来确认我们建议使用pip 9.0.1或更高版本来安装。 > 注： 您的MacOS上可能已经安装pip请使用pip -V来确认我们建议使用pip 9.0.1或更高版本来安装。
...@@ -55,8 +57,6 @@ ...@@ -55,8 +57,6 @@
* 对于需要**CPU版本PaddlePaddle**的用户：`pip install paddlepaddle` 或 `pip3 install paddlepaddle` * 对于需要**CPU版本PaddlePaddle**的用户：`pip install paddlepaddle` 或 `pip3 install paddlepaddle`
* 对于有**其他要求**的用户：`pip install paddlepaddle==[版本号]` 或 `pip3 install paddlepaddle==[版本号]` * 对于有**其他要求**的用户：`pip install paddlepaddle==[版本号]` 或 `pip3 install paddlepaddle==[版本号]`
> `版本号`参见[安装包列表](./Tables.html/#whls)或者您如果需要获取并安装**最新的PaddlePaddle开发分支**，可以从[多版本whl包列表](./Tables.html/#ciwhls)或者我们的[CI系统](https://paddleci.ngrok.io/project.html?projectId=Manylinux1&tab=projectOverview) 中下载最新的whl安装包和c-api开发包并安装。如需登录，请点击“Log in as guest”。 > `版本号`参见[安装包列表](./Tables.html/#whls)或者您如果需要获取并安装**最新的PaddlePaddle开发分支**，可以从[多版本whl包列表](./Tables.html/#ciwhls)或者我们的[CI系统](https://paddleci.ngrok.io/project.html?projectId=Manylinux1&tab=projectOverview) 中下载最新的whl安装包和c-api开发包并安装。如需登录，请点击“Log in as guest”。
...@@ -84,12 +84,10 @@ ...@@ -84,12 +84,10 @@
1. 使用以下指令拉取我们为您预安装好PaddlePaddle的镜像： 1. 使用以下指令拉取我们为您预安装好PaddlePaddle的镜像：
* 对于需要**CPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For CPU*的镜像： * 对于需要**CPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For CPU*的镜像：
`docker pull hub.baidubce.com/paddlepaddle/paddle:1.1` `docker pull hub.baidubce.com/paddlepaddle/paddle:1.1`
* 您也可以通过以下指令拉取任意的我们提供的Docker镜像： * 您也可以通过以下指令拉取任意的我们提供的Docker镜像：
`docker pull hub.baidubce.com/paddlepaddle/paddle:[tag]` `docker pull hub.baidubce.com/paddlepaddle/paddle:[tag]`
......
doc/fluid/beginners_guide/install/install_Ubuntu.md
浏览文件 @ cb4f4929
...@@ -43,6 +43,8 @@ ...@@ -43,6 +43,8 @@
<br/><br/> <br/><br/>
### ***使用pip安装*** ### ***使用pip安装***
#### ****直接安装****
您可以直接粘贴以下命令到命令行来安装PaddlePaddle(适用于ubuntu16.04及以上安装CPU-ONLY的版本)，如果出现问题，您可以参照后面的解释对命令作出适应您系统的更改： 您可以直接粘贴以下命令到命令行来安装PaddlePaddle(适用于ubuntu16.04及以上安装CPU-ONLY的版本)，如果出现问题，您可以参照后面的解释对命令作出适应您系统的更改：
Python2.7： Python2.7：
...@@ -51,12 +53,18 @@ Python2.7： ...@@ -51,12 +53,18 @@ Python2.7：
Python3.5（该指令适用于本机未安装python2的用户，否则，请卸载python2之后再使用本指令）： Python3.5（该指令适用于本机未安装python2的用户，否则，请卸载python2之后再使用本指令）：
apt-get install -y curl python3.5 python3.5-dev wget vim git && curl https://bootstrap.pypa.io/get-pip.py -o - | python3.5 && easy_install pip && pip3 install paddlepaddle apt-get udpate && apt-get install -y software-properties-common && add-apt-repository ppa:deadsnakes/ppa && apt-get install -y curl python3.5 python3.5-dev wget vim git && curl https://bootstrap.pypa.io/get-pip.py -o - | python3.5 && easy_install pip && pip3 install paddlepaddle
Python3.6、Python3.7：（由于版本相对较新，在不同Ubuntu版本上安装差异较大，不一一描述其安装过程，执行以下命令前，我们认为您已经准备好python3.6或3.7的环境，并安装了对应版本的python3-dev以及pip3）
apt update && pip3 install paddlepaddle
<br/>
#### ****分步安装****
首先，我们使用以下指令来**检测本机的环境**是否适合安装PaddlePaddle： 首先，我们使用以下指令来**检测本机的环境**是否适合安装PaddlePaddle：
`uname -m && cat /etc/*release` uname -m && cat /etc/*release
> 上面的命令将会显示本机的操作系统和位数信息，请确保您的计算机和本教程的要求一致。 > 上面的命令将会显示本机的操作系统和位数信息，请确保您的计算机和本教程的要求一致。
...@@ -64,18 +72,18 @@ Python3.5（该指令适用于本机未安装python2的用户，否则，请卸 ...@@ -64,18 +72,18 @@ Python3.5（该指令适用于本机未安装python2的用户，否则，请卸
其次，您的电脑需要满足以下任一要求： 其次，您的电脑需要满足以下任一要求：
* Python2.7.x (dev)，Pip >= 9.0.1 * Python2.7.x (dev)，Pip >= 9.0.1
* Python3.5.x (dev)，Pip3 >= 9.0.1 * Python3.5+.x (dev)，Pip3 >= 9.0.1
> 您的Ubuntu上可能已经安装pip请使用pip -V或pip3 -V来确认我们建议使用pip 9.0.1或更高版本来安装 > 您的Ubuntu上可能已经安装pip请使用pip -V或pip3 -V来确认我们建议使用pip 9.0.1或更高版本来安装
更新apt的源： `apt update` 更新apt的源： `apt update`
使用以下命令安装或升级Python和pip到需要的版本： 使用以下命令安装或升级Python和pip到需要的版本：（python3.6、python3.7安装pip和dev在不同Ubuntu版本下差别较大，不一一描述）
- For python2： `sudo apt install python-dev python-pip` - For python2： `sudo apt install python-dev python-pip`
- For python3：`sudo apt install python3.5-dev` and `curl https://bootstrap.pypa.io/get-pip.py -o - | python3.5 && easy_install pip` - For python3.5：`sudo apt install python3.5-dev` and `curl https://bootstrap.pypa.io/get-pip.py -o - | python3.5 && easy_install pip`
- For python3.6、python3.7： 我们默认您应准备好python3.6（3.7）以及对应版本的dev和pip3
> 即使您的环境中已经有Python2或Python3也需要安装Python-dev或Python3.5-dev。 > 即使您的环境中已经有Python2或Python3也需要安装Python-dev或Python3.5（3.6、3.7）-dev。
现在，让我们来安装PaddlePaddle： 现在，让我们来安装PaddlePaddle：
...@@ -83,17 +91,16 @@ Python3.5（该指令适用于本机未安装python2的用户，否则，请卸 ...@@ -83,17 +91,16 @@ Python3.5（该指令适用于本机未安装python2的用户，否则，请卸
* 对于需要**CPU版本PaddlePaddle**的用户：`pip install paddlepaddle` 或 `pip3 install paddlepaddle` * 对于需要**CPU版本PaddlePaddle**的用户：`pip install paddlepaddle` 或 `pip3 install paddlepaddle`
* 对于需要**GPU版本PaddlePaddle**的用户：`pip install paddlepaddle-gpu` 或 `pip3 install paddlepaddle-gpu` * 对于需要**GPU版本PaddlePaddle**的用户：`pip install paddlepaddle-gpu` 或 `pip3 install paddlepaddle-gpu`
> 1. 为防止出现nccl.h找不到的问题请首先按照以下命令安装nccl2（这里提供的是ubuntu 16.04，CUDA9，cuDNN v7下nccl2的安装指令），更多版本的安装信息请参考NVIDIA[官方网站](https://developer.nvidia.com/nccl/nccl-download): > 1. 为防止出现nccl.h找不到的问题请首先按照以下命令安装nccl2（这里提供的是ubuntu 16.04，CUDA9，cuDNN v7下nccl2的安装指令），更多版本的安装信息请参考NVIDIA[官方网站](https://developer.nvidia.com/nccl/nccl-download):
i. `wget http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64/nvidia-machine-learning-repo-ubuntu1604_1.0.0-1_amd64.deb` i. `wget http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1604/x86_64/nvidia-machine-learning-repo-ubuntu1604_1.0.0-1_amd64.deb`
ii. `dpkg -i nvidia-machine-learning-repo-ubuntu1604_1.0.0-1_amd64.deb` ii. `dpkg -i nvidia-machine-learning-repo-ubuntu1604_1.0.0-1_amd64.deb`
iii. `sudo apt-get install -y libnccl2=2.2.13-1+cuda9.0 libnccl-dev=2.2.13-1+cuda9.0` iii. `sudo apt-get install -y libnccl2=2.2.13-1+cuda9.0 libnccl-dev=2.2.13-1+cuda9.0`
> 2. 如果您不规定pypi包版本号，我们默认为您提供支持Cuda 9/cuDNN v7的PaddlePaddle版本。
> 2. 如果您不规定pypi包版本号，我们默认为您提供支持Cuda 9/cuDNN v7的PaddlePaddle版本。
对于出现`Cannot uninstall 'six'.`问题的用户，可是由于您的系统中已有的Python安装问题造成的，请使用`pip install paddlepaddle --ignore-installed six`（CPU）或`pip install paddlepaddle --ignore-installed six`（GPU）解决。 * 对于出现`Cannot uninstall 'six'.`问题的用户，可是由于您的系统中已有的Python安装问题造成的，请使用`pip install paddlepaddle --ignore-installed six`（CPU）或`pip install paddlepaddle --ignore-installed six`（GPU）解决。
* 对于有**其他要求**的用户：`pip install paddlepaddle==[版本号]` 或 `pip3 install paddlepaddle==[版本号]` * 对于有**其他要求**的用户：`pip install paddlepaddle==[版本号]` 或 `pip3 install paddlepaddle==[版本号]`
...@@ -123,17 +130,14 @@ Python3.5（该指令适用于本机未安装python2的用户，否则，请卸 ...@@ -123,17 +130,14 @@ Python3.5（该指令适用于本机未安装python2的用户，否则，请卸
1. 使用以下指令拉取我们为您预安装好PaddlePaddle的镜像： 1. 使用以下指令拉取我们为您预安装好PaddlePaddle的镜像：
* 对于需要**CPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For CPU*的镜像： * 对于需要**CPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For CPU*的镜像：
`docker pull hub.baidubce.com/paddlepaddle/paddle:1.1` `docker pull hub.baidubce.com/paddlepaddle/paddle:1.1`
* 对于需要**GPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For GPU*的镜像： * 对于需要**GPU版本的PaddlePaddle**的用户请使用以下指令拉取我们为您预安装好*PaddlePaddle For GPU*的镜像：
`docker pull hub.baidubce.com/paddlepaddle/paddle:1.1-gpu-cuda9.0-cudnn7` `docker pull hub.baidubce.com/paddlepaddle/paddle:1.1-gpu-cuda9.0-cudnn7`
* 您也可以通过以下指令拉取任意的我们提供的Docker镜像： * 您也可以通过以下指令拉取任意的我们提供的Docker镜像：
`docker pull hub.baidubce.com/paddlepaddle/paddle:[tag]` `docker pull hub.baidubce.com/paddlepaddle/paddle:[tag]`
......
doc/fluid/beginners_guide/install/install_Windows.md
浏览文件 @ cb4f4929
...@@ -6,31 +6,41 @@ ...@@ -6,31 +6,41 @@
请注意：在其他系统上的尝试可能会导致安装失败。 请注意：在其他系统上的尝试可能会导致安装失败。
当前版本不支持NCCL，分布式，AVX，warpctc和MKL相关功能。
* *Windows 7/8 and Windows 10 专业版/企业版* * *Windows 7/8 and Windows 10 专业版/企业版*
## 确定要安装的版本 ## 确定要安装的版本
* Windows下我们目前仅提供支持CPU的PaddlePaddle。 * Windows下我们目前仅提供支持CPU的PaddlePaddle。
## 选择如何安装 ## 选择如何安装
在Windows系统下请使用我们为您提供的[一键安装包](http://paddle-windows.bj.bcebos.com/1.1/PaddlePaddle-windows-1.1.zip)进行安装
> 我们提供的一键安装包将基于Docker为您进行便捷的安装流程 ### ***使用pip安装***
我们暂不提供快速安装的命令，请您按照以下步骤进行安装
* 首先，**检查您的计算机和操作系统**是否满足以下要求：
For python2: 使用Python官方下载的python2.7.15
For python3: 使用Python官方下载的python3.5.x
我们之所以使用**基于Docker的安装方式**，是因为我们在把工具和配置都安装在一个 Docker image 里，这样如果遇到问题，其他人可以复现问题以便帮助。另外，对于习惯使用Windows和MacOS的开发者来说，使用Docker就不用配置交叉编译环境了。需要强调的是：Docker 不会虚拟任何硬件，Docker container 里运行的编译工具实际上都是在本机的 CPU 和操作系统上直接运行的，性能和把编译工具安装在本机运行一样。 * Python2.7.x，pip >= 9.0.1
* Python3.5.x，pip3 >= 9.0.1
下面将说明如何安装PaddlePaddle：
* 使用pip install来安装PaddlePaddle：
** paddlepaddle 的依赖包 `recordio` 有可能用 `pip` 的默认源无法安装，可以使用 `easy_install recordio` 来安装 **
** 对于需要**CPU版本PaddlePaddle**的用户：`pip install paddlepaddle` 或 `pip3 install paddlepaddle` **
现在您已经完成通过`pip install` 来安装的PaddlePaddle的过程。
<br/><br/>
## ***验证安装*** ## ***验证安装***
安装完成后您可以使用：`python` 或 `python3` 进入python解释器，然后使用`import paddle.fluid` 验证是否安装成功。 安装完成后您可以使用：`python` 或 `python3` 进入python解释器，然后使用`import paddle.fluid` 验证是否安装成功。
<br/><br/>
## ***如何卸载*** ## ***如何卸载***
请使用以下命令卸载PaddlePaddle（使用docker安装PaddlePaddle的用户请进入包含PaddlePaddle的容器中使用以下命令）： 请使用以下命令卸载PaddlePaddle（使用docker安装PaddlePaddle的用户请进入包含PaddlePaddle的容器中使用以下命令）：
......
doc/fluid/book/fit_a_line/README.md 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/01.fit_a_line/README.md
\ No newline at end of file
doc/fluid/book/fit_a_line/image 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/01.fit_a_line/image/
\ No newline at end of file
doc/fluid/book/image_classification/README.md 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/03.image_classification/README.md
\ No newline at end of file
doc/fluid/book/image_classification/image 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/03.image_classification/image/
\ No newline at end of file
doc/fluid/book/index_en.rst 0 → 100644
浏览文件 @ cb4f4929
Book
======
.. toctree::
:maxdepth: 1
fit_a_line/README.md
recognize_digits/README.md
image_classification/README.md
word2vec/README.md
recommender_system/README.md
understand_sentiment/README.md
label_semantic_roles/README.md
machine_translation/README.md
doc/fluid/book/label_semantic_roles/README.md 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/07.label_semantic_roles/README.md
\ No newline at end of file
doc/fluid/book/label_semantic_roles/image 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/07.label_semantic_roles/image/
\ No newline at end of file
doc/fluid/book/machine_translation/README.md 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/08.machine_translation/README.md
\ No newline at end of file
doc/fluid/book/machine_translation/image 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/08.machine_translation/image/
\ No newline at end of file
doc/fluid/book/recognize_digits/README.md 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/02.recognize_digits/README.md
\ No newline at end of file
doc/fluid/book/recognize_digits/image 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/02.recognize_digits/image/
\ No newline at end of file
doc/fluid/book/recommender_system/README.md 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/05.recommender_system/README.md
\ No newline at end of file
doc/fluid/book/recommender_system/image 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/05.recommender_system/image/
\ No newline at end of file
doc/fluid/book/understand_sentiment/README.md 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/06.understand_sentiment/README.md
\ No newline at end of file
doc/fluid/book/understand_sentiment/image 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/06.understand_sentiment/image/
\ No newline at end of file
doc/fluid/book/word2vec/README.md 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/04.word2vec/README.md
\ No newline at end of file
doc/fluid/book/word2vec/images 0 → 120000
浏览文件 @ cb4f4929
../../../../external/book/04.word2vec/image/
\ No newline at end of file
doc/fluid/dev/index_cn.rst
浏览文件 @ cb4f4929
...@@ -8,6 +8,7 @@ ...@@ -8,6 +8,7 @@
write_docs_cn.md write_docs_cn.md
api_doc_std_cn.md api_doc_std_cn.md
new_op_cn.md new_op_cn.md
op_notes.md
new_op_kernel.md new_op_kernel.md
use_eigen_cn.md use_eigen_cn.md
name_convention.md name_convention.md
......
doc/fluid/dev/index_en.rst
浏览文件 @ cb4f4929
...@@ -11,6 +11,5 @@ Development ...@@ -11,6 +11,5 @@ Development
new_op_kernel.md new_op_kernel.md
use_eigen_en.md use_eigen_en.md
name_convention.md name_convention.md
support_new_device.md
releasing_process_en.md releasing_process_en.md
op_markdown_format.md op_markdown_format.md
doc/fluid/dev/new_op_cn.md
浏览文件 @ cb4f4929
# 如何写新的Operator # 如何写新的operator
- [概念简介](#概念简介) - [概念简介](#概念简介)
- [实现C++类](#实现c类) - [实现C++类](#实现c类)
......
doc/fluid/index_cn.rst
浏览文件 @ cb4f4929
...@@ -14,5 +14,5 @@ ...@@ -14,5 +14,5 @@
beginners_guide/index.rst beginners_guide/index.rst
user_guides/index.rst user_guides/index.rst
advanced_usage/index.rst advanced_usage/index.rst
api/index_cn.rst api_cn/index_cn.rst
release_note.rst release_note.rst
doc/fluid/index_en.rst
浏览文件 @ cb4f4929
...@@ -9,5 +9,7 @@ ...@@ -9,5 +9,7 @@
design/index_en.rst design/index_en.rst
howto/index_en.rst howto/index_en.rst
dev/index_en.rst dev/index_en.rst
faq/index_en.rst
api/index_en.rst api/index_en.rst
book/index_en.rst
user_guides/models/index_en.rst
advanced_usage/deploy/index_mobile.rst
doc/fluid/user_guides/howto/basic_concept/index_cn.rst 0 → 100644
浏览文件 @ cb4f4929
############
基本概念
############
本文介绍Fluid版本基本使用概念：
- `LoD-Tensor使用说明 <lod_tensor.html>`_ : LoD-Tensor是Fluid中特有的概念，它在Tensor基础上附加了序列信息，支持处理变长数据。
.. toctree::
:hidden:
lod_tensor.rst
doc/fluid/user_guides/howto/prepare_data/lod_tensor.md → doc/fluid/user_guides/howto/basic_concept/lod_tensor.rst
浏览文件 @ cb4f4929
# LoD-Tensor使用说明 ##################
LoD-Tensor使用说明
##################
LoD(Level-of-Detail) Tensor是Fluid中特有的概念，它在Tensor基础上附加了序列信息。Fluid中可传输的数据包括：输入、输出、网络中的可学习参数，全部统一使用LoD-Tensor表示。 LoD(Level-of-Detail) Tensor是Fluid中特有的概念，它在Tensor基础上附加了序列信息。Fluid中可传输的数据包括：输入、输出、网络中的可学习参数，全部统一使用LoD-Tensor表示。
阅读本文档将帮助您了解 Fluid 中的 LoD-Tensor 设计思想，以便您更灵活的使用这一数据类型。 阅读本文档将帮助您了解 Fluid 中的 LoD-Tensor 设计思想，以便您更灵活的使用这一数据类型。
## 变长序列的挑战 变长序列的挑战
================
大多数的深度学习框架使用Tensor表示一个mini-batch。 大多数的深度学习框架使用Tensor表示一个mini-batch。
...@@ -19,7 +22,8 @@ LoD(Level-of-Detail) Tensor是Fluid中特有的概念，它在Tensor基础上附 ...@@ -19,7 +22,8 @@ LoD(Level-of-Detail) Tensor是Fluid中特有的概念，它在Tensor基础上附
Fluid引入了一个索引数据结构（LoD）来将张量分割成序列。 Fluid引入了一个索引数据结构（LoD）来将张量分割成序列。
## LoD 索引 LoD 索引
===========
为了更好的理解LoD的概念，本节提供了几个例子供您参考： 为了更好的理解LoD的概念，本节提供了几个例子供您参考：
...@@ -27,213 +31,254 @@ Fluid引入了一个索引数据结构（LoD）来将张量分割成序列。 ...@@ -27,213 +31,254 @@ Fluid引入了一个索引数据结构（LoD）来将张量分割成序列。
假设一个mini-batch中有3个句子，每个句子中分别包含3个、1个和2个单词。我们可以用(3+1+2)xD维Tensor 加上一些索引信息来表示这个mini-batch: 假设一个mini-batch中有3个句子，每个句子中分别包含3个、1个和2个单词。我们可以用(3+1+2)xD维Tensor 加上一些索引信息来表示这个mini-batch:
``` .. code-block :: text
3 1 2
| | | | | | 3 1 2
``` | | | | | |
上述表示中，每一个`|` 代表一个D维的词向量，数字3，1，2构成了 1-level LoD。
上述表示中，每一个 :code:`|` 代表一个D维的词向量，数字3，1，2构成了 1-level LoD。
**递归序列** **递归序列**
让我们来看另一个2-level LoD-Tensor的例子：假设存在一个mini-batch中包含3个句子、1个句子和2个句子的文章，每个句子都由不同数量的单词组成，则这个mini-batch的样式可以看作： 让我们来看另一个2-level LoD-Tensor的例子：假设存在一个mini-batch中包含3个句子、1个句子和2个句子的文章，每个句子都由不同数量的单词组成，则这个mini-batch的样式可以看作：
```
3 1 2 .. code-block :: text
3 2 4 1 2 3
||| || |||| | || |||
``` 3 1 2
3 2 4 1 2 3
||| || |||| | || |||
表示的LoD信息为： 表示的LoD信息为：
```
[[3，1，2]/*level=0*/，[3，2，4，1，2，3]/*level=1*/] .. code-block :: text
```
[[3，1，2]/*level=0*/，[3，2，4，1，2，3]/*level=1*/]
**视频的mini-batch** **视频的mini-batch**
在视觉任务中，时常需要处理视频和图像这些元素是高维的对象，假设现存的一个nimi-batch包含3个视频，分别有3个，1个和2个帧，每个帧都具有相同大小：640x480，则这个mini-batch可以被表示为： 在视觉任务中，时常需要处理视频和图像这些元素是高维的对象，假设现存的一个nimi-batch包含3个视频，分别有3个，1个和2个帧，每个帧都具有相同大小：640x480，则这个mini-batch可以被表示为：
```
3 1 2
口口口 口 口口
```
最底层tensor大小为（3+1+2）x640x480，每一个`口` 表示一个640x480的图像 .. code-block :: text
3 1 2
口口口 口 口口
最底层tensor大小为（3+1+2）x640x480，每一个 :code:`口` 表示一个640x480的图像
**图像的mini-batch** **图像的mini-batch**
在传统的情况下，比如有N个固定大小的图像的mini-batch，LoD-Tensor表示为: 在传统的情况下，比如有N个固定大小的图像的mini-batch，LoD-Tensor表示为:
``` .. code-block :: text
1 1 1 1 1
口口口口 ... 口 1 1 1 1 1
``` 口口口口 ... 口
在这种情况下，我们不会因为索引值都为1而忽略信息，仅仅把LoD-Tensor看作是一个普通的张量: 在这种情况下，我们不会因为索引值都为1而忽略信息，仅仅把LoD-Tensor看作是一个普通的张量:
```
口口口口 ... 口 .. code-block :: text
```
口口口口 ... 口
**模型参数** **模型参数**
模型参数只是一个普通的张量，在Fluid中它们被表示为一个0-level LoD-Tensor。 模型参数只是一个普通的张量，在Fluid中它们被表示为一个0-level LoD-Tensor。
<a name="#LoDTensor的偏移表示"></a> LoDTensor的偏移表示
## LoDTensor的偏移表示 =====================
为了快速访问基本序列，Fluid提供了一种偏移表示的方法——保存序列的开始和结束元素，而不是保存长度。 为了快速访问基本序列，Fluid提供了一种偏移表示的方法——保存序列的开始和结束元素，而不是保存长度。
在上述例子中，您可以计算基本元素的长度： 在上述例子中，您可以计算基本元素的长度：
```
3 2 4 1 2 3 .. code-block :: text
```
3 2 4 1 2 3
将其转换为偏移表示： 将其转换为偏移表示：
```
0 3 5 9 10 12 15 .. code-block :: text
0 3 5 9 10 12 15
= = = = = = = = = = = =
3 2+3 4+5 1+9 2+10 3+12 3 2+3 4+5 1+9 2+10 3+12
```
所以我们知道第一个句子是从单词0到单词3，第二个句子是从单词3到单词5。 所以我们知道第一个句子是从单词0到单词3，第二个句子是从单词3到单词5。
类似的，LoD的顶层长度 类似的，LoD的顶层长度
```
3 1 2 .. code-block :: text
```
3 1 2
可以被转化成偏移形式： 可以被转化成偏移形式：
```
0 3 4 6 .. code-block :: text
0 3 4 6
= = = = = =
3 3+1 4+2 3 3+1 4+2
```
因此该LoD-Tensor的偏移表示为： 因此该LoD-Tensor的偏移表示为：
```
0 3 4 6 .. code-block :: text
0 3 4 6
3 5 9 10 12 15 3 5 9 10 12 15
```
## LoD-Tensor
LoD-Tensor
=============
一个LoD-Tensor可以被看作是一个树的结构，树叶是基本的序列元素，树枝作为基本元素的标识。 一个LoD-Tensor可以被看作是一个树的结构，树叶是基本的序列元素，树枝作为基本元素的标识。
在 Fluid 中 LoD-Tensor 的序列信息有两种表述形式：原始长度和偏移量。在 Paddle 内部采用偏移量的形式表述 LoD-Tensor，以获得更快的序列访问速度；在 python API中采用原始长度的形式表述 LoD-Tensor 方便用户理解和计算，并将原始长度称为：`recursive_sequence_lengths` 。 在 Fluid 中 LoD-Tensor 的序列信息有两种表述形式：原始长度和偏移量。在 Paddle 内部采用偏移量的形式表述 LoD-Tensor，以获得更快的序列访问速度；在 python API中采用原始长度的形式表述 LoD-Tensor 方便用户理解和计算，并将原始长度称为： :code:`recursive_sequence_lengths` 。
以上文提到的一个2-level LoD-Tensor为例： 以上文提到的一个2-level LoD-Tensor为例：
```
3 1 2 .. code-block :: text
3 2 4 1 2 3
||| || |||| | || ||| 3 1 2
``` 3 2 4 1 2 3
||| || |||| | || |||
- 以偏移量表示此 LoD-Tensor:[ [0,3,4,6] , [0,3,5,9,10,12,15] ]， - 以偏移量表示此 LoD-Tensor:[ [0,3,4,6] , [0,3,5,9,10,12,15] ]，
- 以原始长度表达此 Lod-Tensor：recursive_sequence_lengths=[ [3-0 , 4-3 , 6-4] , [3-0 , 5-3 , 9-5 , 10-9 , 12-10 , 15-12] ]。 - 以原始长度表达此 Lod-Tensor：recursive_sequence_lengths=[ [3-0 , 4-3 , 6-4] , [3-0 , 5-3 , 9-5 , 10-9 , 12-10 , 15-12] ]。
以文字序列为例： [3,1,2] 可以表示这个mini-batch中有3篇文章，每篇文章分别有3、2、1个句子，[3,2,4,1,2,3] 表示每个句子中分别含有3、2、4、1、2、3个字。
以文字序列为例： [3,1,2] 可以表示这个mini-batch中有3篇文章，每篇文章分别有3、1、2个句子，[3,2,4,1,2,3] 表示每个句子中分别含有3、2、4、1、2、3个字。
recursive_seq_lens 是一个双层嵌套列表，也就是列表的列表，最外层列表的size表示嵌套的层数，也就是lod-level的大小；内部的每个列表，对应表示每个lod-level下，每个元素的大小。 recursive_seq_lens 是一个双层嵌套列表，也就是列表的列表，最外层列表的size表示嵌套的层数，也就是lod-level的大小；内部的每个列表，对应表示每个lod-level下，每个元素的大小。
```python
#查看lod-tensor嵌套层数
print len(recursive_seq_lengths)
# output：2
#查看最基础元素个数 .. code-block :: text
print sum(recursive_seq_lengths[-1])
# output:15 (3+2+4+1+2+3=15) #查看lod-tensor嵌套层数
print len(recursive_seq_lengths)
# output：2
``` #查看最基础元素个数
print sum(recursive_seq_lengths[-1])
# output:15 (3+2+4+1+2+3=15)
## 代码示例 代码示例
===========
本节代码将根据指定的级别y-lod，扩充输入变量x。本例综合了LoD-Tensor的多个重要概念，跟随代码实现，您将： 本节代码将根据指定的级别y-lod，扩充输入变量x。本例综合了LoD-Tensor的多个重要概念，跟随代码实现，您将：
- 直观理解Fluid中 `fluid.layers.sequence_expand` 的实现过程 - 直观理解Fluid中 :code:`fluid.layers.sequence_expand` 的实现过程
- 掌握如何在Fluid中创建LoD-Tensor - 掌握如何在Fluid中创建LoD-Tensor
- 学习如何打印LoDTensor内容 - 学习如何打印LoDTensor内容
**创建LoD-Tensor** **创建LoD-Tensor**
Fluid中可以通过`fluid.create_lod_tensor()`创建一个LoD-Tensor，使用说明请参考[API reference](http://paddlepaddle.org/documentation/api/zh/develop/fluid.html#create-lod-tensor)。需要注意的是，这个API只能支持int64的数据，如果您希望处理float32的数据，推荐您使用下述方式创建lod_tensor： Fluid中可以通过 :code:`fluid.create_lod_tensor()` 创建一个LoD-Tensor，使用说明请参考 :ref:`api_fluid_layers_sequence-expand` 。需要注意的是，这个API只能支持int64的数据，如果您希望处理float32的数据，推荐您使用下述方式创建lod_tensor：
使用fluid.LoDTensor()创建一个LoD-Tensor，并为其指定数据、运算场所和LoD值： 使用fluid.LoDTensor()创建一个LoD-Tensor，并为其指定数据、运算场所和LoD值：
```python
import paddle.fluid as fluid
import numpy as np
def create_lod_tensor(data, lod, place): .. code-block :: python
import paddle.fluid as fluid
import numpy as np
def create_lod_tensor(data, lod, place):
res = fluid.LoDTensor() res = fluid.LoDTensor()
res.set(data, place) res.set(data, place)
res.set_lod(lod) res.set_lod(lod)
return res return res
```
**定义计算过程** **定义计算过程**
layers.sequence_expand通过获取 y 的 lod 值对 x 的数据进行扩充，关于`fluid.layers.sequence_expand` 的功能说明，请先阅读[API reference](http://www.paddlepaddle.org/documentation/api/zh/0.15.0/layers.html#sequence-expand)。 layers.sequence_expand通过获取 y 的 lod 值对 x 的数据进行扩充，关于 :code:`fluid.layers.sequence_expand` 的功能说明，请先阅读 :ref:`api_fluid_layers_sequence-expand` 。
序列扩充代码实现： 序列扩充代码实现：
```python
x = fluid.layers.data(name='x', shape=[1], dtype='float32', lod_level=0) .. code-block :: python
y = fluid.layers.data(name='y', shape=[1], dtype='float32', lod_level=1)
out = fluid.layers.sequence_expand(x=x, y=y, ref_level=0) x = fluid.layers.data(name='x', shape=[1], dtype='float32', lod_level=0)
``` y = fluid.layers.data(name='y', shape=[1], dtype='float32', lod_level=1)
out = fluid.layers.sequence_expand(x=x, y=y, ref_level=0)
*说明*：输出LoD-Tensor的维度仅与传入的真实数据维度有关，在定义网络结构阶段为x、y设置的shape值，仅作为占位，并不影响结果。 *说明*：输出LoD-Tensor的维度仅与传入的真实数据维度有关，在定义网络结构阶段为x、y设置的shape值，仅作为占位，并不影响结果。
**创建Executor** **创建Executor**
```python
place = fluid.CPUPlace() .. code-block :: python
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program()) place = fluid.CPUPlace()
``` exe = fluid.Executor(place)
<a name="#准备数据"></a> exe.run(fluid.default_startup_program())
**准备数据** **准备数据**
这里我们使用[偏移量](#LoDTensor的偏移表示)的方法表示Tensor的LoD索引： 这里我们使用偏移量的方法表示Tensor的LoD索引：
假使x_d 为一个LoDTensor： 假使x_d 为一个LoDTensor：
```
x.lod = [[0,1,4]] .. code-block :: shell
x.data = [[1],[2],[3],[4]]
x.dims = [4,1] x.lod = [[0,1,4]]
``` x.data = [[1],[2],[3],[4]]
x.dims = [4,1]
y_d 也为一个LoDTensor： y_d 也为一个LoDTensor：
```
y.lod = [[0, 1, 4], .. code-block :: shell
y.lod = [[0, 1, 4],
[0, 2, 3, 5, 6]] [0, 2, 3, 5, 6]]
```
其中，输出值只与 y 的LoD值有关，y_d 的 data 值在这里并不参与计算，维度上与LoD[-1]一致即可。 其中，输出值只与 y 的LoD值有关，y_d 的 data 值在这里并不参与计算，维度上与LoD[-1]一致即可。
预期输出结果为： 预期输出结果为：
```
#预期输出lod的原始长度 .. code-block :: shell
out.lod = [ [1, 3, 3, 3]]
#预期输出结果 #预期输出lod的原始长度
out.data = [ [1],[2],[3],[4],[2],[3],[4],[2],[3],[4]] out.lod = [ [1, 3, 3, 3]]
``` #预期输出结果
out.data = [ [1],[2],[3],[4],[2],[3],[4],[2],[3],[4]]
实现代码如下： 实现代码如下：
```python
x_d = create_lod_tensor(np.array([[1], [2],[3],[4]]), [[0,1,4]], place) .. code-block :: python
y_d = create_lod_tensor(np.array([[1],[1],[1],[1],[1],[1]]), [[0,1,4], [0,2,3,5,6]], place)
``` x_d = create_lod_tensor(np.array([[1], [2],[3],[4]]), [[0,1,4]], place)
y_d = create_lod_tensor(np.array([[1],[1],[1],[1],[1],[1]]), [[0,1,4], [0,2,3,5,6]], place)
**执行运算** **执行运算**
在Fluid中，LoD>1的Tensor与其他类型数据一样，使用feed定义数据传入顺序。此外，由于输出results是带有LoD信息的Tensor，需在exe.run( )中添加`return_numpy=False`参数，获得LoD-Tensor的输出结果。 在Fluid中，LoD>1的Tensor与其他类型数据一样，使用feed定义数据传入顺序。此外，由于输出results是带有LoD信息的Tensor，需在exe.run( )中添加 :code: `return_numpy=False`参数，获得LoD-Tensor的输出结果。
```python
feeder = fluid.DataFeeder(place=place, feed_list=[x, y]) .. code-block :: python
results = exe.run(fluid.default_main_program(),
feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
results = exe.run(fluid.default_main_program(),
feed={'x':x_d, 'y': y_d }, feed={'x':x_d, 'y': y_d },
fetch_list=[out],return_numpy=False) fetch_list=[out],return_numpy=False)
```
**查看LodTensor结果** **查看LodTensor结果**
由于LoDTensor的特殊属性，无法直接print查看内容，常用操作时将LoD-Tensor作为网络的输出fetch出来，然后执行 numpy.array(lod_tensor), 就能转成numpy array： 由于LoDTensor的特殊属性，无法直接print查看内容，常用操作时将LoD-Tensor作为网络的输出fetch出来，然后执行 numpy.array(lod_tensor), 就能转成numpy array：
```python .. code-block :: python
np.array(results[0])
``` np.array(results[0])
输出结果为： 输出结果为：
```
array([[1],[2],[3],[4],[2],[3],[4],[2],[3],[4]])
```
可以看到与[准备数据](#准备数据)一节中的预期结果一致。
## 总结 .. code-block :: python
array([[1],[2],[3],[4],[2],[3],[4],[2],[3],[4]])
可以看到与准备数据一节中的预期结果一致。
总结
========
至此，相信您已经基本掌握了LoD-Tensor的概念，尝试修改上述代码中的 x_d 与 y_d，观察输出结果，有助于您更好的理解这一灵活的结构。 至此，相信您已经基本掌握了LoD-Tensor的概念，尝试修改上述代码中的 x_d 与 y_d，观察输出结果，有助于您更好的理解这一灵活的结构。
更多LoDTensor的模型应用，可以参考新手入门中的[词向量](../../../beginners_guide/basics/word2vec/index.html)、[个性化推荐](../../../beginners_guide/basics/recommender_system/index.html)、[情感分析](../../../beginners_guide/basics/understand_sentiment/index.html)等指导教程。 更多LoDTensor的模型应用，可以参考新手入门中的 `词向量 <../../../beginners_guide/basics/word2vec/index.html>`_ 、`个性化推荐 <../../../beginners_guide/basics/recommender_system/index.html>`_、`情感分析 <../../../beginners_guide/basics/understand_sentiment/index.html>`_ 等指导教程。
更高阶的应用案例，请参考[模型库](../../../user_guides/models/index.html)中的相关内容。 更高阶的应用案例，请参考 `模型库 <../../../user_guides/models/index_cn.html>`_ 中的相关内容。
doc/fluid/user_guides/howto/evaluation_and_debugging/index.rst
浏览文件 @ cb4f4929
...@@ -3,7 +3,7 @@ ...@@ -3,7 +3,7 @@
############### ###############
.. toctree:: .. toctree::
:maxdepth: 2 :maxdepth: 1
evaluation/metrics.rst evaluation/metrics.rst
debug/visualdl.md debug/visualdl.md
doc/fluid/user_guides/howto/prepare_data/index.rst
浏览文件 @ cb4f4929
...@@ -35,14 +35,14 @@ Python Reader是纯的Python端接口，数据传入与模型训练/预测过程 ...@@ -35,14 +35,14 @@ Python Reader是纯的Python端接口，数据传入与模型训练/预测过程
数据，具体请参考: 数据，具体请参考:
.. toctree:: .. toctree::
:maxdepth: 2 :maxdepth: 1
feeding_data.rst feeding_data.rst
Python Reader支持组batch、shuffle等高级功能，具体请参考： Python Reader支持组batch、shuffle等高级功能，具体请参考：
.. toctree:: .. toctree::
:maxdepth: 2 :maxdepth: 1
reader.md reader.md
...@@ -52,17 +52,6 @@ py_reader接口异步方式 ...@@ -52,17 +52,6 @@ py_reader接口异步方式
Fluid提供PyReader异步数据传入方式，数据传入与模型训练/预测过程是异步的，效率较高。具体请参考： Fluid提供PyReader异步数据传入方式，数据传入与模型训练/预测过程是异步的，效率较高。具体请参考：
.. toctree:: .. toctree::
:maxdepth: 2 :maxdepth: 1
use_py_reader.rst use_py_reader.rst
LoD-Tensor简介
#####################
LoD-Tensor是Fluid中特有的概念，它在Tensor基础上附加了序列信息，支持处理变长数据。具体请参考：
.. toctree::
:maxdepth:2
lod_tensor.md
\ No newline at end of file
doc/fluid/user_guides/howto/training/cluster_howto.rst
浏览文件 @ cb4f4929
...@@ -218,8 +218,15 @@ NCCL2模式的分布式训练，由于没有parameter server角色，是trainer ...@@ -218,8 +218,15 @@ NCCL2模式的分布式训练，由于没有parameter server角色，是trainer
目前使用NCCL2进行分布式训练仅支持同步训练方式。使用NCCL2方式的分布式训练，更适合模型体积较大，并需要使用\ 目前使用NCCL2进行分布式训练仅支持同步训练方式。使用NCCL2方式的分布式训练，更适合模型体积较大，并需要使用\
同步训练和GPU训练，如果硬件设备支持RDMA和GPU Direct，可以达到很高的分布式训练性能。 同步训练和GPU训练，如果硬件设备支持RDMA和GPU Direct，可以达到很高的分布式训练性能。
注意如果系统中有多个网络设备，需要手动指定NCCL2使用的设备， NCCL2分布式训练注意事项
假设需要使用 :code:`eth2` 为通信设备，需要设定如下环境变量： +++++++++++++++++++++
**注意：** 使用NCCL2模式分布式训练时，需要确保每个节点训练等量的数据，防止在最后一轮训练中任务不退出。通常有两种方式：
- 随机采样一些数据，补全分配到较少数据的节点上。（推荐使用这种方法，以训练完整的数据集）。
- 在python代码中，每个节点每个pass只训练固定的batch数，如果这个节点数据较多，则不训练这些多出来的数据。
**注意：** 如果系统中有多个网络设备，需要手动指定NCCL2使用的设备，假设需要使用 :code:`eth2` 为通信设备，需要设定如下环境变量：
.. code-block:: bash .. code-block:: bash
......
doc/fluid/user_guides/howto/training/index.rst
浏览文件 @ cb4f4929
...@@ -5,7 +5,7 @@ ...@@ -5,7 +5,7 @@
PaddlePaddle Fluid支持单机训练，和多节点训练。每种训练模式下，都支持多种训练方法。 PaddlePaddle Fluid支持单机训练，和多节点训练。每种训练模式下，都支持多种训练方法。
.. toctree:: .. toctree::
:maxdepth: 2 :maxdepth: 1
single_node single_node
multi_node multi_node
......
doc/fluid/user_guides/howto/training/multi_node.rst
浏览文件 @ cb4f4929
...@@ -3,7 +3,7 @@ ...@@ -3,7 +3,7 @@
######## ########
.. toctree:: .. toctree::
:maxdepth: 2 :maxdepth: 1
cluster_quick_start.rst cluster_quick_start.rst
cluster_howto.rst cluster_howto.rst
......
doc/fluid/user_guides/howto/training/save_load_variables.rst
浏览文件 @ cb4f4929
.. _user_guide_save_load_vars: .. _user_guide_save_load_vars:
################## ##################
保存与载入模型变量 模型/变量的保存、载入与增量训练
################## ##################
模型变量分类 模型变量分类
...@@ -37,8 +37,6 @@ ...@@ -37,8 +37,6 @@
那么我们应该将各种长期变量都保存下来，甚至还需要记录一下当前的epoch和step的id。 那么我们应该将各种长期变量都保存下来，甚至还需要记录一下当前的epoch和step的id。
因为一些模型变量虽然不是参数，但对于模型的训练依然必不可少。 因为一些模型变量虽然不是参数，但对于模型的训练依然必不可少。
因此，根据需求的不同，我们提供了两套API来分别进行模型的参数和checkpoint的保存。
保存模型用于对新样本的预测 保存模型用于对新样本的预测
========================== ==========================
...@@ -61,44 +59,11 @@ ...@@ -61,44 +59,11 @@
筛选出其中所有的模型参数，并将这些模型参数保存到指定的 :code:`param_path` 之中。 筛选出其中所有的模型参数，并将这些模型参数保存到指定的 :code:`param_path` 之中。
保存checkpoint用于将来恢复训练
==============================
在训练过程中，我们可能希望在一些节点上将当前的训练状态保存下来，
以便在将来需要的时候恢复训练环境继续进行训练。这一般被称作“checkpoint”。
想要保存checkpoint，可以使用 :code:`fluid.io.save_checkpiont()` 接口。
例如：
.. code-block:: python
import paddle.fluid as fluid
exe = fluid.Executor(fluid.CPUPlace())
path = "./checkpoints"
prog = fluid.default_main_program()
trainer_args = {"epoch_id": 200,
"step_id": 20} # just an example
fluid.io.save_checkpoint(executor=exe,
checkpoint_dir=path,
trainer_id=0,
trainer_args=trainer_args,
main_program=prog,
max_num_checkpoints=3)
上面的例子中，通过调用 :code:`fluid.io.save_checkpoint` 函数，PaddlePaddle Fluid会对默认
:code:`fluid.Program` 也就是 :code:`prog` 中的所有模型变量进行扫描，
根据一系列内置的规则自动筛选出其中所有需要保存的变量，并将他们保存到指定的 :code:`path` 目录下。
:code:`fluid.io.save_checkpoint` 的各个参数中， :code:`trainer_id` 在单机情况下设置为0即可； :code:`trainer_args`
为一个Python dict，用于给定当前的epoch_id和step_id；
:code:`max_num_checkpoints` 用于表示的最大checkpoint数量，
如果目录中已经存在的checkpoint数量超过这个值，那最早的checkpoint将被删除。
如何载入模型变量 如何载入模型变量
################ ################
与模型变量的保存相对应，我们提供了两套API来分别载入模型的参数和载入模型的checkpoint。 与模型变量的保存相对应，我们提供了两套API来分别载入模型的参数和载入模型的长期变量。
载入模型用于对新样本的预测 载入模型用于对新样本的预测
========================== ==========================
...@@ -132,11 +97,29 @@ ...@@ -132,11 +97,29 @@
之前。如果在之后运行，可能会覆盖已加载的模型参数导致错误。 之前。如果在之后运行，可能会覆盖已加载的模型参数导致错误。
载入checkpoint用于恢复训练
预测所用的模型与参数的保存：
##################
预测引擎提供了存储预测模型 :code:`fluid.io.save_inference_model` 和加载预测模型 :code:`fluid.io.load_inference_model` 两个接口。
- :code:`fluid.io.save_inference_model`：请参考 :ref:`api_guide_inference`。
- :code:`fluid.io.load_inference_model`：请参考 :ref:`api_guide_inference`。
增量训练
############
增量训练指一个学习系统能不断地从新样本中学习新的知识，并能保存大部分以前已经学习到的知识。因此增量学习涉及到两点：在上一次训练结束的时候保存需要持久化的参数， 在下一次训练开始的时候加载上一次保存的持久化参数。 因此增量训练涉及到如下几个API:
:code:`fluid.io.save_persistables`、:code:`fluid.io.load_persistables` 。
单机增量训练
========================== ==========================
单机的增量训练的一般步骤如下：
1. 在训练的最后调用 :code:`fluid.io.save_persistables` 保存持久性参数到指定的位置。
2. 在训练的startup_program通过执行器 :code:`Executor` 执行成功之后调用 :code:`fluid.io.load_persistables` 加载之前保存的持久性参数。
3. 通过执行器 :code:`Executor` 或者 :code:`ParallelExecutor` 继续训练。
对于通过 :code:`fluid.io.save_checkpoint` 保存的模型，可以使用 :code:`fluid.io.load_checkpoint`
来进行载入。
例如： 例如：
...@@ -145,101 +128,100 @@ ...@@ -145,101 +128,100 @@
import paddle.fluid as fluid import paddle.fluid as fluid
exe = fluid.Executor(fluid.CPUPlace()) exe = fluid.Executor(fluid.CPUPlace())
path = "./checkpoints" path = "./models"
prog = fluid.default_main_program() prog = fluid.default_main_program()
fluid.io.load_checkpoint(executor=exe, checkpoint_dir=path, fluid.io.save_persistables(exe, path, prog)
serial=9, main_program=prog)
上面的例子中，通过调用 :code:`fluid.io.save_checkpoint` 函数，PaddlePaddle Fluid会对
:code:`prog` 中的所有模型变量进行扫描，根据内置规则自动筛选出需要加载的变量，
并尝试从 :code:`path` 之中加载它们。
参数 :code:`serial` 用来标记具体要加载的checkpoint的版本号。在保存checkpoint的时候， 上面的例子中，通过调用 :code:`fluid.io.save_persistables` 函数，PaddlePaddle Fluid会从默认 :code:`fluid.Program` 也就是 :code:`prog` 的所有模型变量中找出长期变量，并将他们保存到指定的 :code:`path` 目录下。
一个checkpoint会被保存在一个子目录中，并在目录名上体现出自己的版本号。
一般越大的版本号表示这个checkpoint越新。
这里的 :code:`prog` 必须和调用 :code:`fluid.io.save_checkpoint` 时所用的 :code:`prog`
完全一致，否则会导致变量加载错误或者未加载。另外，与 :code:`fluid.io.save_params` 类似，
运行 :code:`fluid.default_startup_program()` 也必须在 :code:`fluid.io.load_checkpoint`
之前进行。
多机checkpoint保存 .. code-block:: python
##################
Checkpoint功能使用指南
======================
* 背景 import paddle.fluid as fluid
单机/多机在训练过程中会由于软件/硬件的问题出现异常，导致训练中断，进而导致训练无结果或结果不可用，浪费大量时间和机器性能。
* 目的 exe = fluid.Executor(fluid.CPUPlace())
Checkpoint功能能够在训练中途对训练数据中间数据进行保存，出现异常恢复训练的时候能够加载中途保存的数据继续训练， 实现单机/多机的容错训练的功能。 path = "./models"
startup_prog = fluid.default_startup_program()
exe.run(startup_prog)
fluid.io.load_persistables(exe, path, startup_prog)
main_prog = fluid.default_main_program()
exe.run(main_prog)
* 说明 上面的例子中，通过调用 :code:`fluid.io.load_persistables` 函数，PaddlePaddle Fluid会从默认
:code:`fluid.Program` 也就是 :code:`prog` 的所有模型变量中找出长期变量，从指定的 :code:`path` 目录中将它们一一加载， 然后再继续进行训练。
* 目前已实现的参数保存：
1. 基于Trainer 0 实现训练过程中的参数保存
2. 基于PServer 实现了`Distribute Lookup Table`相关参数保存 多机增量（不带分布式大规模稀疏矩阵）训练的一般步骤为：
==========================
多机增量训练和单机增量训练有若干不同点：
* Fluid Checkpoint 保存数据目录结构： 1. 在训练的最后调用 :code:`fluid.io.save_persistables` 保存持久性参数时，不必要所有的trainer都调用这个方法，一般0号trainer来保存。
2. 多机增量训练的参数加载在PServer端，trainer端不用加载参数。在PServer全部启动后，trainer会从PServer端同步参数。
.. code-block:: python 多机增量（不启用分布式大规模稀疏矩阵）训练的一般步骤为：
checkpoint_dir (用户定义的checkpoint目录) 1. 0号trainer在训练的最后调用 :code:`fluid.io.save_persistables` 保存持久性参数到指定的 :code:`path` 下。
├── checkpoint_0 (第一次保存) 2. 通过HDFS等方式将0号trainer保存下来的所有的参数共享给所有的PServer(每个PServer都需要有完整的参数)。
│ ├── __lockup_table__ (Distribute Lookup Table 目录) 3. PServer在训练的startup_program通过执行器（:code:`Executor`）执行成功之后调用 :code:`fluid.io.load_persistables` 加载0号trainer保存的持久性参数。
│ │ ├── table_pserver_0 (Pserver 0 号保存的lookup table 数据) 4. PServer通过执行器 :code:`Executor` 继续启动PServer_program.
│ │ └── table_pserver_1 5. 所有的训练节点trainer通过执行器 :code:`Executor` 或者 :code:`ParallelExecutor` 正常训练。
│ ├── __model__ (model 目录)
│ │ └── var.w_1
│ └── trainer_0 (trainer 自有数据保存)
│ ├── epoch_id
│ └── step_id
└── checkpoint_1 (第二次保存)
* 使用方法
* 声明Fluid.CheckpointConfig 对于训练过程中待保存参数的trainer， 例如：
用户对checkpoint功能的配置，主要是配置对象 :code:`Fluid` 中的 :code:`CheckpointConfig` . .. code-block:: python
:code:`CheckpointConfig` 包括4个参数： import paddle.fluid as fluid
===================== ===== ========================== exe = fluid.Executor(fluid.CPUPlace())
参数 类型 说明 path = "./models"
===================== ===== ========================== trainer_id = 0
checkpoint_dir int checkpoint存储目录 if trainer_id == 0:
prog = fluid.default_main_program()
fluid.io.save_persistables(exe, path, prog)
max_num_checkpoints int 最大保存的checkpoint副本数
epoch_interval int 每隔epoch_interval轮epoch .. code-block:: bash
hadoop fs -mkdir /remote/$path
hadoop fs -put $path /remote/$path
step_interval int 每隔step_interval轮step 上面的例子中，0号train通过调用 :code:`fluid.io.save_persistables` 函数，PaddlePaddle Fluid会从默认
===================== ===== ========================== :code:`fluid.Program` 也就是 :code:`prog` 的所有模型变量中找出长期变量，并将他们保存到指定的 :code:`path` 目录下。然后通过调用第三方的文件系统（如HDFS）将存储的模型进行上传到所有PServer都可访问的位置。
* 在Fluid.Trainer对象的声明中加入Fluid.CheckpointConfig的声明 对于训练过程中待载入参数的PServer， 例如：
Trainer的__init__方法的参数中包含了对 :code:`CheckpointConfig` ， 需要传入在声明Trainer前声明的 :code:`CheckpointConfig` 对象。
如：
.. code-block:: python .. code-block:: bash
hadoop fs -get /remote/$path $path
config = CheckpointConfig(
checkpoint_dir = "/tmp/ckpt", max_num_checkpoints = 2,
epoch_interval = 2, step_interval = 10)
trainer = Trainer(..., checkpoint_config=config)
定义和声明完成后， 训练在运行过程中就会在指定的step和epoch处进行保存，出现异常时，就会自动从最新的checkpoint目录进行参数恢复啦！ .. code-block:: python
* 相关API import paddle.fluid as fluid
`Trainer API 说明 <https://github.com/PaddlePaddle/Paddle/blob/develop/python/paddle/fluid/trainer.py>`_ exe = fluid.Executor(fluid.CPUPlace())
path = "./models"
pserver_endpoints = "127.0.0.1:1001,127.0.0.1:1002"
trainers = 4
training_role == "PSERVER"
config = fluid.DistributeTranspilerConfig()
t = fluid.DistributeTranspiler(config=config)
t.transpile(trainer_id, pservers=pserver_endpoints, trainers=trainers, sync_mode=True)
if training_role == "PSERVER":
current_endpoint = "127.0.0.1:1001"
pserver_prog = t.get_pserver_program(current_endpoint)
pserver_startup = t.get_startup_program(current_endpoint, pserver_prog)
exe.run(pserver_startup)
fluid.io.load_persistables(exe, path, pserver_startup)
exe.run(pserver_prog)
if training_role == "TRAINER":
main_program = t.get_trainer_program()
exe.run(main_program)
上面的例子中，每个PServer通过调用HDFS的命令获取到0号trainer保存的参数，通过配置获取到PServer的 :code:`fluid.Program` ，PaddlePaddle Fluid会从此
:code:`fluid.Program` 也就是 :code:`pserver_startup` 的所有模型变量中找出长期变量，并通过指定的 :code:`path` 目录下一一加载。
* 注意
1. 保证每个训练的 :code:`checkpoint_dir` 与其他训练独立。
2. 最大副本数量 :code:`max_num_checkpoints` 需要根据磁盘容量以及模型的大小进行调整， 保证磁盘的可用性。
3. :code:`epoch_interval` 和 :code:`step_interval` 不宜过小， 频繁的进行checkpoint会拖慢训练速度。
4. **分布式训练** 的过程中：每个Trainer都会在 :code:`checkpoint_dir` 目录中保存当前Trainer的参数（只有Trainer 0会保存模型的参数），需要 **分布式文件系统(HDFS等)** 将同 :code:`checkpoint_dir` 目录的数据进行合并才能得到完整的数据，恢复训练的时候需要用完整的数据进行恢复。
doc/fluid/user_guides/index.rst
浏览文件 @ cb4f4929
...@@ -2,15 +2,11 @@ ...@@ -2,15 +2,11 @@
使用指南 使用指南
######## ########
==============
概览
==============
.. todo:: .. todo::
如果您已经掌握了新手入门阶段的内容，期望可以针对实际问题建模、搭建自己网络，本模块提供了一些 Fluid 的使用细节供您参考： 如果您已经掌握了新手入门阶段的内容，期望可以针对实际问题建模、搭建自己网络，本模块提供了一些 Fluid 的使用细节供您参考：
- `基本概念 <../user_guides/howto/basic_concept/index_cn.rst>`_ ：介绍了Fluid的基本使用概念
- `Fluid 设计思想 <../user_guides/design_idea/fluid_design_idea.html>`_：介绍 Fluid 底层的设计思想，帮助用户更好的理解框架运作过程
- `准备数据 <../user_guides/howto/prepare_data/index.html>`_ ：介绍使用 Fluid 训练网络时，数据的支持类型及传输方法 - `准备数据 <../user_guides/howto/prepare_data/index.html>`_ ：介绍使用 Fluid 训练网络时，数据的支持类型及传输方法
...@@ -23,25 +19,16 @@ ...@@ -23,25 +19,16 @@
- `模型评估 <../user_guides/howto/evaluation_and_debugging/evaluation/metrics.html>`_：介绍常用模型评估指标的构造方法 - `模型评估 <../user_guides/howto/evaluation_and_debugging/evaluation/metrics.html>`_：介绍常用模型评估指标的构造方法
- `Visual DL 工具 <../user_guides/howto/evaluation_and_debugging/debug/visualdl.html>`_：介绍如何利用 Visual DL 工具可视化训练过程 - `Visual DL 工具 <../user_guides/howto/evaluation_and_debugging/debug/visualdl.html>`_：介绍如何利用 Visual DL 工具可视化训练过程
- `预测部署 <../user_guides/howto/inference/index.html>`_：介绍如何应用训练好的模型进行预测
基于 Fluid 复现的多领域经典模型： 基于 Fluid 复现的多领域经典模型：
- `Fluid 模型库 <../user_guides/models/index_cn.html>`_ - `Fluid 模型库 <../user_guides/models/index_cn.html>`_
==============
目录
==============
.. toctree:: .. toctree::
:maxdepth: 2 :hidden:
howto/basic_concept/index_cn.rst
howto/prepare_data/index howto/prepare_data/index
howto/configure_simple_model/index howto/configure_simple_model/index
howto/training/index howto/training/index
howto/evaluation_and_debugging/index howto/evaluation_and_debugging/index
howto/inference/index
models/index_cn.rst models/index_cn.rst
design_idea/fluid_design_idea.md
doc/fluid/user_guides/models/index_en.rst 0 → 100644
浏览文件 @ cb4f4929
############################################################################
`Models <https://github.com/PaddlePaddle/models/tree/develop/fluid>`_
############################################################################
PaddlePaddle provides a rich set of computational units to enable users to adopt a modular approach to solving various learning problems. In this repo, we demonstrate how to use PaddlePaddle to solve common machine learning tasks, providing several different neural network model that anyone can easily learn and use.
- `fluid models <https://github.com/PaddlePaddle/models/tree/develop/fluid>`_ : use PaddlePaddle's Fluid APIs. We especially recommend users to use Fluid models.
- `legacy models <https://github.com/PaddlePaddle/models/tree/develop/legacy>`_ : use PaddlePaddle's v2 APIs.
Anakin @ 65178d41
Subproject commit 65178d41c3a61ba846f1e94909e3cb50a8c19c92
Paddle @ 08f927de
比较 cb27a921...08f927de
Subproject commit cb27a9219d8dfc02be49484ce697495886a3e6fb Subproject commit 08f927dee74372977fc770082fecadba2e864fd7
book @ ef293450
比较 13c6f692...ef293450
Subproject commit 13c6f692513771afb50e86a5de2d1cf9a3a53975 Subproject commit ef2934505b87eeb516eed7d083900ec88a62fb20
paddle-mobile @ 2c088e20
Subproject commit 2c088e20d8083accacaf2057bc35531ac7fba7ce
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或