Skip to content

F
FluidDoc

PaddlePaddle / FluidDoc

通知 5
Star 2
Fork 0
F
FluidDoc
未验证 提交 2b2d0133 编写于 作者: D Dong Daxiang 提交者： GitHub
浏览文件
操作

Merge pull request #1 from PaddlePaddle/develop 

merge remote
上级 1fe89e8a 18824802
展开全部 隐藏空白更改
内联 并排
Showing with 36110 addition and 5957 deletion

要显示的变更太多。

To preserve performance only 1000 of 1000+ files are displayed.
文本差异 电子邮件补丁
.gitignore 0 → 100644
浏览文件 @ 2b2d0133
.vscode/
/doc/fluid/menu.zh.json
/doc/fluid/menu.en.json
.gitmodules
浏览文件 @ 2b2d0133
[submodule "external/Paddle"]
path = external/Paddle
url = https://github.com/PaddlePaddle/Paddle
[submodule "external/book"]
path = external/book
url = https://github.com/PaddlePaddle/book
......@@ -10,6 +7,9 @@
[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"]
path = external/models
url = https://github.com/PaddlePaddle/models
.travis.yml
浏览文件 @ 2b2d0133
......@@ -5,7 +5,6 @@ cache:
- $HOME/.ccache
- $HOME/.cache/pip
- $HOME/docker
# - $TRAVIS_BUILD_DIR/external/
- $TRAVIS_BUILD_DIR/external/Paddle/build/third_party
sudo: required
......@@ -24,26 +23,20 @@ addons:
- python2.7-dev
ssh_known_hosts: 13.229.163.131
before_install:
- sudo pip install pylint pytest astroid isort
# Load cached docker images
#- if [[ -d $HOME/docker ]]; then ls $HOME/docker/*.tar.gz | xargs -I {file} sh -c "zcat {file} | docker load"; fi
- sudo pip install pylint pytest astroid isort
before_install:
- sudo pip install pylint pytest astroid isort
# Force the script to be timed out after certain duration
- function timeout() { perl -e 'alarm shift; exec @ARGV' "$@"; }
jobs:
include:
- script: scripts/deploy_docs.sh full
# Force the deploy_docs.sh to time out after 40 minutes.
# Travis CI will terminate the build completely after 50 minutes and won't allow caching to happen.
# Time out the build preemptively to cache built libraries.
- script: timeout 2400 scripts/deploy_docs.sh full
name: Generate Docs
- script: scripts/deploy_docs.sh pybind
name: Cache pybind build
- script: scripts/deploy_docs.sh proto
name: Cache proto build
- script: scripts/deploy_en_external_docs.sh
name: Generate EN external docs
#before_cache:
# # Save tagged docker images
# - >
# mkdir -p $HOME/docker && docker images -a --filter='dangling=false' --format 'paddlepaddle/paddle:latest-dev {{.ID}}'
# | xargs -n 2 -t sh -c 'test -e $HOME/docker/$1.tar.gz || docker save $0 | gzip -2 > $HOME/docker/$1.tar.gz'
notifications:
email:
......
README.md
浏览文件 @ 2b2d0133
<h1 align="center">FluidDoc</h1>
English | [简体中文](./README_cn.md)
# Introduction
Fluiddoc consolidates all the documentations related to Paddle. It supplies the contents to PaddlePaddle.org via CI.
FluidDoc consolidates all the documentations related to Paddle. It supplies the contents to PaddlePaddle.org via CI.
# Architecture
FluidDoc submodules Paddle, Book, Models, Mobile and Anakin under `external` folder. All submodules should be put under `external` as standard practice.
Fluiddoc then uses them as references to load up the documents. The FluidDoc constructs the whole doc-tree under the `FluidDoc/doc/fluid` folder. The entry point is `FluidDoc/doc/fluid/index_cn.rst` and `FluidDoc/doc/fluid/index_en.rst`
FluidDoc then uses them as references to load up the documents. The FluidDoc constructs the whole doc-tree under the `FluidDoc/doc/fluid` folder. The entry point is `FluidDoc/doc/fluid/index_cn.rst` and `FluidDoc/doc/fluid/index_en.rst`
When a release branch is pushed to Github, Travis-CI will start automatically to compile documents and deploy documents to the server.
......@@ -21,5 +25,4 @@ To preview documents constructured by FluidDoc. Please follow the [regular previ
1. Make sure all the submodules are ready for release. Paddle, book, model, mobile and Anakin should all have stable commits. Note: Paddle repo should update the API RST files accordinly if Paddle changes the included module/classes.
1. Update the submodules under `external` folder and commit the changes.
1. Git push the branch to Github, Travis CI will start several builds to publish the documents to the PaddlePaddle.org server
1. Please notify the PaddlePaddle.org team that the release content is ready. PaddlePaddl.org team should enable the version and update the default version to the latest one. PaddlePaddle.org should also update the search index accordingly (Until the search server is up)
1. Please notify the PaddlePaddle.org team that the release content is ready. PaddlePaddle.org team should enable the version and update the default version to the latest one. PaddlePaddle.org should also update the search index accordingly (Until the search server is up)
README_cn.md 0 → 100644
浏览文件 @ 2b2d0133
<h1 align="center">FluidDoc</h1>
[English](./README.md) | 简体中文
# 介绍
FluidDoc包含了所有PaddlePaddle相关的文档，它通过CI系统为PaddlePaddle.org提供文档内容
# 架构
FluidDoc将Paddle, Book, Models, Mobile and Anakin作为子模块，并放置在 `external` 目录下。按照标准做法，所有的子模块应当置于`external` 目录下
FluidDoc通过引用这些子模块来加载这些Repo中的文档。FluidDoc在 `FluidDoc/doc/fluid` 目录下构建了文档的整体树形结构。可以分别在 `FluidDoc/doc/fluid/index_cn.rst` 和 `FluidDoc/doc/fluid/index_en.rst` 查看。
当一个新发布的分支被push到了Github上，Travis-CI 将会自动启动编译文档并把文档部署到服务器
## 注意：
FluidDoc 需要Paddle Repo的python模块去编译生成API文档。但由于Paddle的python模块过于庞大，超过了Travis CI允许的最大时长，通常Travis CI将会因为超时问题失败。这是Travis上有三项作业的原因，其中两项用于构建库。当Travis缓存了这些库以后，下一次的构建将会变得非常的快。
## 通过PaddlePaddle.org预览文档
为了预览FluidDoc的文档，请按照[常规预览步骤](https://github.com/PaddlePaddle/PaddlePaddle.org/blob/develop/README.md)，但请在这一步将 paddle 的路径替换为 Fluid 的路径
`./runserver --paddle <path_to_FluidDoc_dir>`
## 发布新的分支
1. 创建一个新的分支，此分支的名字应遵循`release/<version>`
1. 在FluidDoc和子模块中更新文档
1. 确认所有的子模块中处于发布就绪的状态。Paddle, book, model, mobile and Anakin 应全部有稳定的commit
请注意：如果Paddle Repo更改了module/classes，涉及API文档的RST文件应当也被更新
1. 在 `external` 中更新文件然后commit文档变更
1. 将这个分支push到Github，Travis CI将会启动几项构建工作以把文档发布到PaddlePaddle.org的服务器
1. 请告知PaddlePaddle.org团队，发布的内容已经就绪。PaddlePaddle.org团队将使版本生效并更新默认的版本到最新版。PaddlePaddle.org也应当更新相应的搜索引擎文件
doc/fluid/advanced_usage/benchmark.rst 已删除 100644 → 0
浏览文件 @ 1fe89e8a
#################
如何进行基准测试
#################
本文介绍如何给深度学习框架做基准测试。基准测试主要包含验证模型的精度和性能两方面，下文包含搭建测试环境，选择基准测试模型，验证测试结果等几方面内容。
验证深度学习框架，可分为训练和测试两个阶段， 验证指标略有不同，本文只介绍训练阶段的指标验证。训练阶段关注的是模型训练集上的精度，训练集是完备的，因此关注大batch\_size下的训练速度,关注吞吐量，例如图像模型常用的batch\_size=128, 多卡情况下会加大；预测阶段关注的是在测试集上的精度，线上服务测试数据不能提前收集，因此关注小batch\_size下的预测速度，关注延迟，例如预测服务常用的batch\_size=1, 4等。
`Fluid <https://github.com/PaddlePaddle/Paddle>`__ 是PaddlePaddle从0.11.0版本开始引入的设计，本文的基准测试在该版本上完成。
环境搭建
""""""""""""
基准测试中模型精度和硬件、框架无关，由模型结构和数据共同决定；性能方面由测试硬件和框架性能决定。框架基准测试为了对比框架之间的差异，控制硬件环境，系统库等版本一致。下文中的对比实验都在相同的硬件条件和系统环境条件下进行.
不同架构的GPU卡性能差异巨大，在验证模型在GPU上训练性能时，可使用NVIDIA提供的工具:code `nvidia-smi` 检验当前使用的GPU型号，如果测试多卡训练性能，需确认硬件连接是 `nvlink <https://zh.wikipedia.org/zh/NVLink>`__ 或 `PCIe <https://zh.wikipedia.org/zh-hans/PCI_Express>`__ 。 同样地，CPU型号会极大影响模型在CPU上的训练性能。可读取`/proc/cpuinfo`中的参数，确认当前正在使用的CPU型号。
下载GPU对应的Cuda Tool Kit和 Cudnn，或者使用NVIDIA官方发布的nvidia-docker镜像 `nvidia-docker <https://github.com/NVIDIA/nvidia-docker>`__, 镜像内包含了Cuda和Cudnn，本文采用这种方式。 Cuda Tool Kit包含了GPU代码使用到的基础库，影响在此基础上编译出的Fluid二进制运行性能。
准备好Cuda环境后，从github上的下载Paddle并源码编译，会生成对应的最适合当前GPU的sm\_arch二进制\ `sm\_arch <https://docs.nvidia.com/cuda/cuda-compiler-driver-nvcc/index.html>`__\ 。另外，cudnn对卷积类任务影响巨大，在基准测试中需要小版本一致，例如Cudnn7.0.2与Cudnn7.1.4在Resnet上有5%以上差异。
选择基准模型
""""""""""""
对框架做基准测试，需要覆盖不同训练任务和不同大小的模型，本文中选取了图像和NLP的最为常用的5个模型。
============ ============ ================= ============
任务种类 模型名称 网络结构 数据集
============ ============ ================= ============
图像分类 mnist Lenet mnist
图像分类 VGG VGG-16 Flowers102
图像分类 Resnet Resnet-50 Flowers102
文本分类 Stacked-LSTM Stacked-LSTM IMDB
机器翻译 seq-seq Stacked-LSTM wmt14
============ ============ ================= ============
其中mnist, VGG, Resnet属于CNN模型, stacked-lstm, seq2seq代表RNN模型。
`benchmark <https://github.com/PaddlePaddle/Paddle/tree/develop/benchmark/fluid>`__
基准模型测试脚本中，均跳过了前几个batch的训练过程，原因是加载数据和分配显存受系统当前运行情况影响，会导致统计性能不准确。运行完若干个轮次后，统计对应指标。
基准模型的数据的选择方面，数据量大且验证效果多的公开数据集为首选。图像模型VGG和resnet, 本文选择了 `flowers102 <http://www.robots.ox.ac.uk/~vgg/data/flowers/102/>`__ ，图像大小预处理为和Imagenet相同大小，因此性能可直接对比
NLP模型的公开且影响力大数据集较少，seq2seq模型选择了wmt14数据，stacked-lstm模型中选择了 `imdb <https://www.imdb.com/interfaces/>`__ 数据。
注意，图像模型每条样本大小相同，图像经过变换后大小一致，因此经过的计算路径基本相同，计算速度和显存占用波动较小，可以从若干个batch的数据中采样得到当前的训练性能数据。而NLP模型由于样本长度不定，计算路径和显存占用也不相同，因此只能完整运行若干个轮次后，统计速度和显存消耗。
显存分配是特别耗时的操作，因此Fluid默认会占用所有可用显存空间形成显存池，用以加速计算过程中的显存分配。如果需要统计模型真实显存消耗，可设置环境变量`FLAGS_fraction_of_gpu_memory_to_use=0.0`，观察最大显存开销。
测试过程
""""""""""""
- CPU 单机单线程测试
测试CPU上单线程的性能，先设置CUDA的环境变量为空，``CUDA_VISIBLE_DEVICES=``，并通过环境变量关闭OpenMP和MKL的多线程 ``OMP_NUM_THREADS=1``， ``MKL_NUM_THREADS=1;``。
然后代码中设置为使用CPUPlace，如果使用Paddle代码库中的脚本，只需要命令行参数传入 use_gpu=False即可。
.. code-block:: python
>>> import paddle.fluid as fluid
>>> place = fluid.CPUPlace()
.. code:: bash
docker run -it --name CASE_NAME --security-opt seccomp=unconfined -v $PWD/benchmark:/benchmark paddlepaddle/paddle:latest-dev /bin/bash
- GPU 单机单卡测试
本教程使用了Cuda8, Cudnn7.0.1。来源为:code `nvidia/cuda:8.0-cudnn7-devel-ubuntu16.04`
.. code:: bash
nvidia-docker run -it --name CASE_NAME --security-opt seccomp=unconfined -v $PWD/benchmark:/benchmark -v /usr/lib/x86_64-linux-gnu:/usr/lib/x86_64-linux-gnu paddlepaddle/paddle:latest-dev /bin/bash
在单卡上测试，设置CUDA的环境变量使用一块GPU，``CUDA_VISIBLE_DEVICES=0``
然后代码中设置为使用CUDAPlace，如果使用Paddle代码库中的脚本，只需要命令行参数传入 use_gpu=True即可。
.. code-block:: python
>>> import paddle.fluid as fluid
>>> place = fluid.CUDAPlace(0) // 0 指第0块GPU
测试结果
""""""""""""
本教程对比相同环境下的Fluid0.12.0和TensorFlow1.4.0的性能表现。
硬件环境为 CPU: Intel(R) Xeon(R) CPU E5-2660 v4 @ 2.00GHz, GPU: TITAN X(Pascal) 12G x 1, Nvidia-Driver 384.90。
系统环境为Ubuntu 16.04.3 LTS, 本文中采用了docker环境，系统版本为nvidia-docker17.05.0-ce。
测试的Fluid版本为\ `v.0.12.0 <https://github.com/PaddlePaddle/Paddle/releases/tag/v.0.12.0>`__ 。
TensorFlow版本为\ `v.1.4.0-rc1 <https://github.com/tensorflow/tensorflow/tree/v1.4.0-rc1>`__ 。
使用的脚本和配置见\ `benchmark <https://github.com/PaddlePaddle/Paddle/tree/develop/benchmark/fluid>`__ 。
图表中统计单位为samples/秒。
- CPU 单机单线程测试结果
================ ==================== ===================
Speed Fluid CPU TensorFlow CPU
================ ==================== ===================
mnist 1298.75 samples/s 637.57 samples/s
VGG-16 0.4147 images/s 0.1229 images/s
Resnet-50 1.6935 images/s 0.3657 images/s
Stacked-LSTM 472.3225 words/s 48.2293words/s
Seq2Seq 217.1655 words/s 28.6164 words/s
================ ==================== ===================
- GPU 单机单卡测试结果
=============== ===================== =================
Speed Fluid GPU TensorFlow GPU
=============== ===================== =================
mnist 19710.90 samples/s 15576.3 samples/s
VGG-16 59.83327 images/s 40.9967 images/s
Resnet-50 105.84412 97.8923 images/s
Stacked-LSTM 1319.99315 1608.2526 words/s
Seq2Seq 7147.89081 6845.1161 words/s
=============== ===================== =================
doc/fluid/advanced_usage/best_practice/cpu_train_best_practice.rst 0 → 100644
浏览文件 @ 2b2d0133
.. _api_guide_cpu_training_best_practice:
####################
分布式CPU训练最佳实践
####################
提高CPU分布式训练的训练速度，主要要从两个方面来考虑：
1）提高训练速度，主要是提高CPU的使用率；2）提高通信速度，主要是减少通信传输的数据量。
提高CPU的使用率
=============
提高CPU使用率主要依赖 :code:`ParallelExecutor`，可以充分利用多个CPU的计算能力来加速计算。
API详细使用方法参考 :ref:`cn_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一致
提高通信速度
==========
要减少通信数据量，提高通信速度，主要是使用稀疏更新 ，目前支持 :ref:`api_guide_sparse_update` 的主要是 :ref:`cn_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/advanced_usage/best_practice/cpu_train_best_practice_en.rst 0 → 100644
浏览文件 @ 2b2d0133
.. _api_guide_cpu_training_best_practice_en:
######################################################
Best practices of distributed training on CPU
######################################################
To improve the training speed of CPU distributed training, we must consider two aspects:
1. Improve the training speed mainly by improving utilization rate of CPU;
2. Improve the communication speed mainly by reducing the amount of data transmitted in the communication.
Improve CPU utilization
=============================
The CPU utilization mainly depends on :code:`ParallelExecutor`, which can make full use of the computing power of multiple CPUs to speed up the calculation.
For detailed API usage, please refer to :ref:`api_fluid_ParallelExecutor` . A simple example:
.. code-block:: python
# Configure the execution strategy, mainly to set the number of threads
exec_strategy = fluid.ExecutionStrategy()
exec_strategy.num_threads = 8
# Configure the composition strategy, for CPU training, you should use the Reduce mode for training.
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)
Among the parameters above:
- :code:`num_threads` : the number of threads used by the model training. It is preferably close to the number of the physical CPU cores of the machine where the training is performed.
- :code:`reduce_strategy` : For CPU training, you should choose fluid.BuildStrategy.ReduceStrategy.Reduce
Configuration of general environment variables:
- :code:`CPU_NUM`: The number of replicas of the model, preferably the same as num_threads
Improve communication speed
==============================
To reduce the amount of communication data and improve communication speed is achieved mainly by using sparse updates, the current support for `sparse update <../layers/sparse_update_en.html>`_ is mainly :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)
Among the parameters above:
- :code:`is_sparse`: Use sparse updates to configure embedding. If the dict_size of embedding is large but the number of data are very small each time, it is recommended to use the sparse update method.
doc/fluid/advanced_usage/best_practice/dist_training_gpu.rst 0 → 100644
浏览文件 @ 2b2d0133
.. _best_practice_dist_training_gpu:
#####################
分布式GPU训练最佳实践
#####################
开始优化您的GPU分布式训练任务
-------------------------
PaddlePaddle Fluid可以支持在现代GPU [#]_ 服务器集群上完成高性能分布式训练。
通常可以通过以下方法优化在多机多卡环境训练性能，建议在进行性能优化时，
检查每项优化点并验证对应提升，最终获得最优性能。
一个简单的验证当前的训练程序是否需要进一步优化性能的方法，
是查看GPU的计算利用率 [#]_ ，通常用 :code:`nvidia-smi`命令查看。
如果GPU利用率较低，则可能存在较大的优化空间。
下列表格中列出本文将介绍的所有可优化点的概述：
可配置项一览
++++++++++
.. csv-table:: GPU分布式训练性能调节项
:header: "调节项", "可选值说明", "配置方法"
:widths: 3, 3, 5
"通信模式", "pserver模式；NCCL2模式（collective [#]_ ）", "配置方法参考：:ref:`cluster_howto`"
"执行模式", "单进程；单进程ParallelGraph；多进程", "配置方法参考：:ref:`cluster_howto`"
"同步AllReduce操作", "开启则使每次调用等待AllReduce同步", "设置环境变量 :code:`FLAGS_sync_nccl_allreduce`"
"CPU线程数", "int值，配置使用的CPU线程数", "参考本篇后续说明"
"预先分配足够的显存", "0~1之间的float值，预先分配显存的占比", "设置环境变量 :code:`FLAGS_fraction_of_gpu_memory_to_use`"
"scope drop频率", "int值，设置每隔N个batch的迭代之后执行一次清理scope", "设置 :code:`fluid.ExecutionStrategy().num_iteration_per_drop_scope`"
"fetch频率", "代码配置", "参考本篇后续说明"
"启用RDMA多机通信", "如果机器硬件支持，可以选择开启RDMA支持", "配置环境变量 :code:`NCCL_IB_DISABLE` "
"使用GPU完成部分图片预处理", "代码配置", "参考本篇后续说明"
"设置通信频率（batch merge）", "代码配置", "参考本篇后续说明"
"优化reader性能", "代码优化", "参考本篇后续说明"
"混合精度", "FP32训练；混合FP32,FP16训练（在V100下启用TensorCore）", "参考项目：`图像分类 <https://github.com/PaddlePaddle/models/tree/develop/fluid/PaddleCV/image_classification>`_ "
选择通信模式和执行模式
+++++++++++++++++++
GPU分布式训练场景，使用多进程+NCCL2模式（collective）通常可以获得最好的性能。参考 :ref:`cluster_howto` 配置您的程序使用多进程NCCL2模式训练。
在多进程模式下，每台服务器的每个GPU卡都会对应启动一个训练进程，
集群中的所有进程之间会互相通信完成训练。以此方式最大限度的降低进程内部资源抢占的开销。
对比在单进程开启ParallelGraph方法，多进程模式不但可以获得更高性能，
而且无需考虑reader在多卡下io性能不足的问题，直接使用多进程提升数据读取IO效率。
使用ParallelGraph模式相对而言会减少多进程管理，并提升性能，而且可以无需修改代码，只需要开启下列开关即可：
.. code-block:: bash
:linenos:
export FLAGS_enable_parallel_graph=1
如果是单机多卡模式，同样可以通过开启ParallelGraph来提升性能：
.. code-block:: bash
:linenos:
export FLAGS_enable_parallel_graph=1
export FLAGS_sync_nccl_allreduce=1
注：在单机多卡ParallelGraph模式下，
配置 :code:`FLAGS_sync_nccl_allreduce=1` 让每次allreduce操作都等待完成，可以提升性能，
详细原因和分析可以参考：https://github.com/PaddlePaddle/Paddle/issues/15049
设置合适的CPU线程数
+++++++++++++++++
PaddlePaddle Fluid使用“线程池” [#]_ 模型调度并执行Op，Op在启动GPU计算之前，
通常需要CPU的协助，然而如果Op本身占用时间很小，“线程池”模型下又会带来额外的调度开销。
使用多进程模式时，如果神经网络的计算图 [#]_ 节点间有较高的并发度，
即使每个进程只在一个GPU上运行，使用多个线程可以更大限度的提升GPU利用率。
这项配置需要根据运行模型的情况来配置，通常在多进程模式，设置线程数为1和4，
然后观察是否存在提升，然后逐步调整此项配置。设置CPU线程数的方法参考：
.. code-block:: python
:linenos:
exe_st = fluid.ExecutionStrategy()
exe_st.num_threads = 1
exe = fluid.ParallelExecutor(
True,
avg_loss.name,
main_program=train_prog,
exec_strategy=exe_st,
num_trainers=num_trainers,
trainer_id=trainer_id)
预先分配足够的显存
+++++++++++++++
通过设置环境变量 :code:`FLAGS_fraction_of_gpu_memory_to_use=0.95` 设置预先分配的显存占比，
比如0.95是指95%的显存会预先分配。设置的范围是0.0~1.0。注意，
设置成0.0会让每次显存分配都调用 :code:`cudaMalloc` 这样会极大的降低训练性能。
降低scope drop频率和fetch频率
+++++++++++++++++++++++++++
减少scope drop和fetch频率，可以减少频繁的变量内存申请、释放和拷贝，
从而提升性能。配置这两项的方法参考下面代码：
.. code-block:: python
:linenos:
exe_st = fluid.ExecutionStrategy()
strategy.num_iteration_per_drop_scope = 30
exe = fluid.ParallelExecutor(
True,
avg_loss.name,
main_program=train_prog,
exec_strategy=exe_st,
num_trainers=num_trainers,
trainer_id=trainer_id)
for pass_id in xrange(PASS_NUM):
batch_id = 0
while True:
if batch_id % 30 == 0:
fetched = exe.run(fetch_list)
else:
exe.run([])
启用RDMA多机通信
++++++++++++++
在使用NCCL2模式训练时，其会默认尝试开启RDMA通信，如果系统不支持，
则会自动降级为使用TCP通信。
可以通过打开环境变量 :code:`NCCL_DEBUG=INFO` 查看NCCL是否选择了开启RDMA通信。
如果需要强制使用TCP方式通信，可以设置 :code:`NCCL_IB_DISABLE=1` 。
使用GPU完成部分图片预处理
++++++++++++++++++++++
如果可能，使用GPU完成可以部分数据预处理，比如图片Tensor的归一化：
.. code-block:: python
:linenos:
image = fluid.layers.data()
img_mean = fluid.layers.create_global_var([3, 1, 1], 0.0, "float32", name="img_mean", persistable=True)
img_std = fluid.layers.create_global_var([3, 1, 1], 0.0, "float32", name="img_std", persistable=True)
t1 = fluid.layers.elementwise_sub(image / 255.0, img_mean, axis=1)
image = fluid.layers.elementwise_div(t1, img_std, axis=1)
对输入的图片Tensor，使用 :code:`fluid.layers` 完成图片数据归一化预处理，
这样可以减轻CPU预处理数据的负担，提升总体训练速度。
增大batch_size或使用设置通信频率（batch merge）
++++++++++++++++++++++++++++++++++++++++++
分布式同步训练，跨节点通信或多或少会带来性能影响，增大训练的batch_size，
可以保持通信开销不变的情况下，增大计算吞吐从而降低通信在整个训练过程中的占比来提升总体的训练吞吐。
然而增大batch_size会带来同等比例的显存消耗提升，为了进一步的增大batch_size，Fluid提供“batch merge”功能，
通过在一个GPU上串行计算多个小的batch并积累梯度，然后再执行多机多卡之间的通信，
此模式同样也可以被称为“可变通信频率“。使用batch merge功能，在同样的模型，
可以极大的增加batch size，提升多机训练的总吞吐。
使用方法可以参考实例：https://github.com/PaddlePaddle/models/tree/develop/fluid/PaddleCV/image_classification/dist_train
优化reader性能
+++++++++++++
数据读取的优化在GPU训练中至关重要，尤其在不断增加batch_size提升吞吐时，计算对reader性能会有更高对要求，
优化reader性能需要考虑的点包括：
1. 使用 :code:`pyreader`
参考 `这里 <../../user_guides/howto/prepare_data/use_py_reader.html>`_
使用pyreader，并开启 :code:`use_double_buffer`
2. reader返回uint8类型数据
图片在解码后一般会以uint8类型存储，如果在reader中转换成float类型数据，会将数据体积扩大4倍。直接返回uint8数据，然后在GPU
上转化成float类型进行训练
3. reader pin memory
reader读取的数据会在训练时组成batch，并从CPU拷贝到GPU上，如果在CPU上分配pin memory内存，这个拷贝过程可以通过硬件
DMA完成拷贝提升性能。在使用pyreader的方式下，可以使用下面的实例代码开启pin memory batch reader：
.. code-block:: python
:linenos:
def batch_feeder(batch_reader, pin_memory=True, img_dtype="uint8"):
# batch((sample, label)) => batch(sample), batch(label)
def _feeder():
for batch_data in batch_reader():
sample_batch = []
label_batch = []
for sample, label in batch_data:
sample_batch.append(sample)
label_batch.append([label])
tensor = core.LoDTensor()
label = core.LoDTensor()
place = core.CUDAPinnedPlace() if pin_memory else core.CPUPlace()
tensor.set(np.array(sample_batch, dtype=img_dtype, copy=False), place)
label.set(np.array(label_batch, dtype="int64", copy=False), place)
yield [tensor, label]
return _feeder
pyreader.decorate_tensor_provider(
batch_feeder(
paddle.batch(rd, batch_size=batch_size_per_gpu),
pin_memory=True,
img_dtype='uint8'
)
)
4. 减少reader初始化时间 (infinite read）
在训练任务开始执行第一轮训练时，reader开始异步的，不断的从磁盘或其他存储中读取数据并执行预处理，然后将处理好的数据
填充到队列中供计算使用。从0开始填充这个队列直到数据可以源源不断供给计算，需要一定时间的预热。所以，如果每轮训练
都重新填充队列，会产生一些时间的开销。所以，在使用pyreader时，可以让reader函数不断的产生数据，直到训练循环手动break：
.. code-block:: python
:linenos:
def infinite_reader(file_path):
while True:
with open(file_path) as fn:
for line in fn:
yield process(line)
def train():
...
for pass_id in xrange(NUM_PASSES):
if pass_id == 0:
pyreader.start()
for batch_id in (iters_per_pass):
exe.run()
pyreader.reset()
使用混合精度训练
++++++++++++++
V100 GPU提供了 `Tensor Core <https://www.nvidia.com/en-us/data-center/tensorcore/>`_ 可以在混合精度计算
场景极大的提升性能。使用混合精度计算的例子可以参考：
https://github.com/PaddlePaddle/models/tree/develop/fluid/PaddleCV/image_classification#using-mixed-precision-training
目前Paddle只提供在两个模型（ResNet, BERT）的混合精度计算实现并支持static loss scaling，其他模型使用混合精度也
可以参考以上的实现完成验证。
附录
----
.. [#] 现代GPU：指至少支持运行 `CUDA <https://developer.nvidia.com/cuda-downloads>`_ 版本7.5以上的GPU
.. [#] GPU利用率：这里指GPU计算能力被使用部分所占的百分比
.. [#] Collective定义参考：https://en.wikipedia.org/wiki/Message_Passing_Interface#Collective_basics
.. [#] https://en.wikipedia.org/wiki/Thread_pool
.. [#] https://en.wikipedia.org/wiki/Data-flow_diagram
doc/fluid/advanced_usage/best_practice/index_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
#########
最佳实践
#########
.. toctree::
:maxdepth: 1
cpu_train_best_practice.rst
dist_training_gpu.rst
training_best_practice.rst
memory_optimize.rst
doc/fluid/advanced_usage/best_practice/index_en.rst 0 → 100644
浏览文件 @ 2b2d0133
###############
Best Practice
###############
.. toctree::
:hidden:
cpu_train_best_practice_en.rst
doc/fluid/advanced_usage/best_practice/memory_optimize.rst 0 → 100644
浏览文件 @ 2b2d0133
.. _api_guide_memory_optimize:
###########
显存分配与优化
###########
PaddlePaddle的显存分配策略
========================
由于原生的CUDA系统调用 :code:`cudaMalloc` 和 :code:`cudaFree` 均是同步操作，非常耗时。因此与许多框架类似，PaddlePaddle采用了显存预分配的策略加速显存分配。具体方式为：
- 在分配requested_size大小的显存时，
- 若requested_size <= chunk_size，则框架会预先分配chunk_size大小的显存池chunk，并从chunk中分出requested_size大小的块返回。之后每次申请显存都会从chunk中分配。
- 若requested_size > chunk_size，则框架会直接调用 :code:`cudaMalloc` 分配requested_size大小的显存返回。
- 在释放free_size大小的显存时，
- 若free_size <= chunk_size，则框架会将该显存放回预分配的chunk中，而不是直接返回给CUDA。
- 若free_size > chunk_size，则框架会直接调用 :code:`cudaFree` 将显存返回给CUDA。
上述的chunk_size由环境变量 :code:`FLAGS_fraction_of_gpu_memory_to_use` 确定，chunk_size的计算公式为：
.. code-block:: python
chunk_size = FLAGS_fraction_of_gpu_memory_to_use * 单张GPU卡的总显存
:code:`FLAGS_fraction_of_gpu_memory_to_use` 的默认值为0.92，即框架预先分配显卡92%的显存。
若你的GPU卡上有其他任务占用显存，你可以适当将 :code:`FLAGS_fraction_of_gpu_memory_to_use` 减少，保证框架能预分配到合适的chunk，例如：
.. code-block:: shell
export FLAGS_fraction_of_gpu_memory_to_use=0.4 # 预先40%的GPU显存
若 :code:`FLAGS_fraction_of_gpu_memory_to_use` 设为0，则每次显存分配和释放均会调用 :code:`cudaMalloc` 和 :code:`cudaFree` ，会严重影响性能，不建议你使用。
只有当你想测量网络的实际显存占用量时，你可以设置 :code:`FLAGS_fraction_of_gpu_memory_to_use` 为0，观察nvidia-smi显示的显存占用情况。
PaddlePaddle的显存优化策略
========================
PaddlePaddle提供了多种通用显存优化方法，优化你的网络的显存占用。
GC策略: 显存垃圾及时回收
====================
GC（Garbage Collection）的原理是在网络运行阶段及时释放无用变量的显存空间，达到节省显存的目的。GC适用于使用Executor，ParallelExecutor做模型训练/预测的场合。
GC策略由三个环境变量控制：
- :code:`FLAGS_eager_delete_tensor_gb`
GC策略的使能开关，double类型，默认值为-1。GC策略会积攒一定大小的显存垃圾后再统一释放，:code:`FLAGS_eager_delete_tensor_gb` 控制的是显存垃圾的阈值，单位是GB。**建议用户设置** :code:`FLAGS_eager_delete_tensor_gb=0` 。
若 :code:`FLAGS_eager_delete_tensor_gb=0` ，则一旦有显存垃圾则马上回收，最为节省显存。
若 :code:`FLAGS_eager_delete_tensor_gb=1` ，则显存垃圾积攒到1G后才触发回收。
若 :code:`FLAGS_eager_delete_tensor_gb<0` ，则GC策略关闭。
- :code:`FLAGS_memory_fraction_of_eager_deletion`
GC策略的调节flag，double类型，默认值为1，范围为[0,1]，仅适用于使用ParallelExecutor或CompiledProgram+with_data_parallel的场合。
GC内部会根据变量占用的显存大小，对变量进行降序排列，且仅回收前 :code:`FLAGS_memory_fraction_of_eager_deletion` 大的变量显存。**建议用户维持默认值**，即 :code:`FLAGS_memory_fraction_of_eager_deletion=1` 。
若 :code:`FLAGS_memory_fraction_of_eager_deletion=0.6` ，则表示仅回收显存占用60%大的变量显存。
若 :code:`FLAGS_memory_fraction_of_eager_deletion=0` ，则表示不回收任何变量的显存，GC策略关闭。
若 :code:`FLAGS_memory_fraction_of_eager_deletion=1` ，则表示回收所有变量的显存。
- :code:`FLAGS_fast_eager_deletion_mode`
快速GC策略的开关，bool类型，默认值为True，表示使用快速GC策略。快速GC策略会不等待CUDA Kernel结束直接释放显存。**建议用户维持默认值**，即 :code:`FLAGS_fast_eager_deletion_mode=True` 。
Inplace策略: Op内部的输出复用输入
=============================
Inplace策略的原理是Op的输出复用Op输入的显存空间。例如，reshape操作的输出和输入可复用同一片显存空间。
Inplace策略适用于使用ParallelExecutor或CompiledProgram+with_data_parallel的场合，通过 :code:`BuildStrategy` 设置。
具体方式为:
.. code-block:: python
build_strategy = fluid.BuildStrategy()
build_strategy.enable_inplace = True # 开启Inplace策略
compiled_program = fluid.CompiledProgram(train_program)
.with_data_parallel(loss_name=loss.name, build_strategy=build_strategy)
由于目前设计上的一些问题，在开启Inplace策略后，必须保证后续exe.run中fetch_list的变量是persistable的，即假如你后续需要fetch的变量为loss和acc，则必须设置：
.. code-block:: python
loss.persistable = True
acc.persistable = True
MemoryOptimize策略: 跨Op间的显存复用（不推荐）
========================================
MemoryOptimize策略的原理是当前Op的输出变量复用前继Op的无用变量空间。由于MemoryOptimize策略会延长显存空间的生命周期，这部分复用的显存可能无法及时释放，导致显存峰值升高，因此不建议用户使用该开关。
由于历史原因，PaddlePaddle提供了2个MemoryOptimize接口：
- :code:`BuildStrategy` 中的 :code:`memory_optimize` ：设置 :code:`build_strategy.memory_optimize=True` 开启MemoryOptimize策略。
- :code:`fluid.memory_optimize()` 接口：**该接口已废弃，不建议用户使用！**
与Inplace策略相同，开启MemoryOptimize策略时同样要保证后续exe.run中fetch_list的变量是persistable的。
显存优化Best Practice
====================
我们推荐你的最佳显存优化策略为：
- 开启GC策略：设置 :code:`FLAGS_eager_delete_tensor_gb=0` 。
- 开启Inplace策略：设置 :code:`build_strategy.enable_inplace = True` ，并设置fetch_list中的 :code:`var.persistable = True` 。
doc/fluid/advanced_usage/best_practice/training_best_practice.rst 0 → 100644
浏览文件 @ 2b2d0133
.. training_best_practice:
#####################
单机训练最佳实践
#####################
开始优化您的单机训练任务
-------------------------
PaddlePaddle Fluid可以支持在现代CPU、GPU平台上进行训练。如果您发现Fluid进行单机训练的速度较慢，您可以根据这篇文档的建议对您的Fluid程序进行优化。
神经网络训练代码通常由三个步骤组成：网络构建、数据准备、模型训练。这篇文档将分别从这三个方向介绍Fluid训练中常用的优化方法。
1. 网络构建过程中的配置优化
=============
这部分优化与具体的模型有关，在这里，我们列举出一些优化过程中遇到过的一些示例。
1.1 cuDNN操作的选择
^^^^^^^^^^^^^^^^
cuDNN是NVIDIA提供的深度神经网络计算库，其中包含了很多神经网络中常用算子，Paddle中的部分Op底层调用的是cuDNN库，例如 :code:`conv2d` ：
.. code-block:: python
paddle.fluid.layers.conv2d(input,
num_filters,
filter_size,
stride=1,
padding=0,
dilation=1,
groups=None,
param_attr=None,
bias_attr=None,
use_cudnn=True,
act=None,
name=None)
在 :code:`use_cudnn=True` 时，框架底层调用的是cuDNN中的卷积操作。
通常cuDNN库提供的操作具有很好的性能表现，其性能明显优于Paddle原生的CUDA实现，比如 :code:`conv2d` 。但是cuDNN中有些操作的性能较差，比如： :code:`conv2d_transpose` 在 :code:`batch_size=1` 时、:code:`pool2d` 在 :code:`global_pooling=True` 时等，这些情况下，cuDNN实现的性能差于Paddle的CUDA实现，建议手动设置 :code:`use_cudnn=False` 。
1.2 使用融合功能的API
^^^^^^^^^^^^^^^^
Paddle提供一些粗粒度的API，这些API融合了多个细粒度API的计算，比如：
.. code-block:: python
logits = fluid.layers.softmax(logits)
loss = fluid.layers.cross_entropy(logits, label, ignore_index=255)
和
.. code-block:: python
loss = fluid.layers.softmax_with_cross_entropy(logits, label, ignore_index=255, numeric_stable_mode=True)
用户网络配置中使用融合功能的API，通常能取得更好的计算性能。
2. 数据准备优化
=============
2.1 分析数据准备部分的耗时
^^^^^^^^^^^^^^^^
数据准备部分通常分为两个部分：数据读取部分和预处理部分。
- 数据读取部分：用户需要在Python端从磁盘中加载数据，然后将数据feed到Fluid的执行器中。
- 数据预处理部分：用户需要在Python端进行数据预处理，比如图像任务通常需要进行数据增强、裁剪等。
Fluid提供了两种数据读取方式：**同步数据读取** 和 **异步数据读取**，详情请参考文档 `如何准备数据 <http://paddlepaddle.org/documentation/docs/zh/1.5/user_guides/howto/prepare_data/index_cn.html>`_ 。
2.1.1 同步数据读取
>>>>>>>>>>>>>>>
同步数据读取是一种简单并且直观的数据准备方式，代码示例如下：
.. code-block:: python
# 读取数据
end = time.time()
for batch_id, batch in enumerate(train_reader):
data_time = time.time() - end
# 训练网络
executor.run(feed=[...], fetch_list=[...])
batch_time = time.time() - end
end = time.time()
用户通过调用自己编写的reader函数，reader每次输出一个batch的数据，并将数据传递给执行器。因此数据准备和执行是顺序进行的，用户可通过加入Python计时函数 time.time() 来统计数据准备部分和执行部分所占用的时间。
2.1.2 异步数据读取
>>>>>>>>>>>>>>>
Paddle里面使用py_reader接口来实现异步数据读取，代码示例如下：
.. code-block:: python
# 启动py_reader
train_py_reader.start()
batch_id = 0
try:
end = time.time()
while True:
print("queue size: ", train_py_reader.queue.size())
loss, = executor.run(fetch_list=[...])
# ...
batch_time = time.time() - end
end = time.time()
batch_id += 1
except fluid.core.EOFException:
train_py_reader.reset()
使用异步数据读取时，Paddle的C++端会维护一个数据队列，Python端通过单独的线程向C++端的数据队列传入数据。用户可以在训练过程中输出数据队列中数据的个数，如果queue size始终不为空，表明Python端数据准备的速度比模型执行的速度快，这种情况下Python端的数据读取可能不是瓶颈。
此外，Paddle提供的一些FLAGS也能很好的帮助分析性能，比如通过设置 :code:`export FLAGS_reader_queue_speed_test_mode=True` ，数据队列中的训练数据在被读取之后，不会从数据队列中弹出，这样能够保证数据队列始终不为空，这样就能够很好的评估出数据读取所占的开销。**注意，FLAGS_reader_queue_speed_test_mode只能在分析的时候打开，正常训练模型时需要关闭**。
2.2 优化数据准备速度的方法
^^^^^^^^^^^^^^^^
- 为降低训练的整体时间，建议用户使用异步数据读取的方式，并开启 :code:`use_double_buffer` 。此外，用户可根据模型的实际情况设置数据队列的大小。
- 如果数据准备的时间大于模型执行的时间，或者出现了数据队列为空的情况，这时候需要考虑对Python的用户reader进行加速。常用的方法为：**使用Python多进程准备数据**。一个简单的使用多进程准备数据的示例，请参考 `YOLOv3 <https://github.com/PaddlePaddle/models/blob/develop/PaddleCV/yolov3/reader.py>`_ 。
- Python端的数据预处理，都是使用CPU完成。如果Paddle提供了相应功能的API，可将这部分预处理功能写到模型配置中，如此Paddle就可以使用GPU来完成该预处理功能，这样也可以减轻CPU预处理数据的负担，提升总体训练速度。
3. 模型训练相关优化
=============
3.1 执行器介绍
^^^^^^^^^^^^^^^^
目前Paddle中有两个执行器， :code:`Executor` 和 :code:`ParallelExecutor` ，这两个执行器的区别：
执行调度器
>>>>>>>>>>>>>>>
.. csv-table::
:header: "执行器 ", "执行对象", "执行策略"
:widths: 3, 3, 5
":code:`Executor`", ":code:`Program`", "根据 :code:`Program` 中Operator定义的先后顺序依次运行。"
":code:`ParallelExecutor`", "SSA Graph", "根据Graph中各个节点之间的依赖关系，通过多线程运行。"
为了更好的分析模型， :code:`ParallelExecutor` 内部首先会将输入的 :code:`Program` 转为SSA Graph，然后根据 :code:`build_strategy` 中的配置，通过一系列的Pass对Graph进行优化，比如：memory optimize，operator fuse等优化。最后根据 :code:`execution_strategy` 中的配置执行训练任务。
此外， :code:`ParallelExecutor` 支持数据并行，即单进程多卡和多进程多卡，关于 :code:`ParallelExecutor` 的具体介绍请参考 `文档 <http://www.paddlepaddle.org.cn/documentation/docs/zh/1.5/api_guides/low_level/parallel_executor.html>`_ 。
为了统一 :code:`ParallelExecutor` 接口和 :code:`Executor` 接口，Paddle提供了 :code:`fluid.compiler.CompiledProgram` 接口，在数据并行模式下，该接口底层调用的是 :code:`ParallelExecutor` 。
3.2 BuildStrategy中参数配置说明
^^^^^^^^^^^^^^^^
BuildStrategy配置选项
>>>>>>>>>>>>>>>
.. csv-table::
:header: "选项", "类型", "默认值", "说明"
:widths: 3, 3, 3, 5
":code:`reduce_strategy`", ":code:`fluid.BuildStrategy.ReduceStrategy`", ":code:`fluid.BuildStrategy.ReduceStrategy.AllReduce`", "使用数据并行训练模型时选用 :code:`AllReduce` 模式训练还是 :code:`Reduce` 模式训练."
":code:`enable_backward_optimizer_op_deps`", "bool", "FALSE", "在反向操作和参数更新操作之间添加依赖，保证在所有的反向操作都运行结束之后才开始运行参数更新操作."
":code:`fuse_all_optimizer_ops`", "bool", "FALSE", "对模型中的参数更新算法进行融合."
":code:`fuse_all_reduce_ops`", "bool", "FALSE", "多卡训练时，将all_reduce Op进行融合."
":code:`fuse_relu_depthwise_conv`", "bool", "FALSE", "如果模型中存在relu和depthwise_conv，并且是连接的，即relu->depthwise_conv，该选项可以将这两个操作合并为一个."
":code:`fuse_broadcast_ops`", "bool", "FALSE", "在 :code:`Reduce` 模式下，对最后的多个Broadcast操作融合为一个."
":code:`mkldnn_enabled_op_types`", "list", "{}", "如果是CPU训练，可以用 :code:`mkldnn_enabled_op_types` 指明模型中的那些操作可以使用MKLDNN库，如果不进行设置，模型可以使用MKLDNN库的所有操作都会使用MKLDNN库."
说明：
- 关于 :code:`reduce_strategy` ，在 :code:`ParallelExecutor` 对于数据并行支持两种参数更新模式： :code:`AllReduce` 和 :code:`Reduce` 。在 :code:`AllReduce` 模式下，各个节点上计算得到梯度之后，调用 :code:`AllReduce` 操作，梯度在各个节点上聚合，然后各个节点分别进行参数更新。在 :code:`Reduce` 模式下，参数的更新操作被均匀的分配到各个节点上，即各个节点计算得到梯度之后，将梯度在指定的节点上进行 :code:`Reduce` ，然后在该节点上，最后将更新之后的参数Broadcast到其他节点。即：如果模型中有100个参数需要更新，训练时使用的是4个节点，在 :code:`AllReduce` 模式下，各个节点需要分别对这100个参数进行更新；在 :code:`Reduce` 模式下，各个节点需要分别对这25个参数进行更新，最后将更新的参数Broadcast到其他节点上.
- 关于 :code:`enable_backward_optimizer_op_deps` ，在多卡训练时，打开该选项可能会提升训练速度。
- 关于 :code:`fuse_all_optimizer_ops` ，目前只支持SGD、Adam和Momentum算法。**注意：目前不支持sparse参数梯度** 。
- 关于 :code:`fuse_all_reduce_ops` ，多GPU训练时，可以对 :code:`AllReduce` 操作进行融合，以减少 :code:`AllReduce` 的调用次数。默认情况下会将同一layer中参数的梯度的 :code:`AllReduce` 操作合并成一个，比如对于 :code:`fluid.layers.fc` 中有Weight和Bias两个参数，打开该选项之后，原本需要两次 :code:`AllReduce` 操作，现在只用一次 :code:`AllReduce` 操作。此外，为支持更大粒度的参数梯度融合，Paddle提供了 :code:`FLAGS_fuse_parameter_memory_size` 选项，用户可以指定融合AllReduce操作之后，每个 :code:`AllReduce` 操作的梯度字节数，比如希望每次 :code:`AllReduce` 调用传输64MB的梯度，:code:`export FLAGS_fuse_parameter_memory_size=64` 。**注意：目前不支持sparse参数梯度**。
- 关于 :code:`mkldnn_enabled_op_types` ，支持mkldnn库的Op有：transpose, sum, softmax, requantize, quantize, pool2d, lrn, gaussian_random, fc, dequantize, conv2d_transpose, conv2d, conv3d, concat, batch_norm, relu, tanh, sqrt, abs.
3.3 ExecutionStrategy中的配置参数
^^^^^^^^^^^^^^^^
ExecutionStrategy配置选项
>>>>>>>>>>>>>>>
.. csv-table::
:header: "选项", "类型", "默认值", "说明"
:widths: 3, 3, 5, 5
":code:`num_iteration_per_drop_scope`", "INT", "1", "经过多少次迭代之后清理一次local execution scope"
":code:`num_threads`", "INT", "对于CPU：2*dev_count；对于GPU：4*dev_count. （这是一个经验值）", ":code:`ParallelExecutor` 中执行所有Op使用的线程池大小"
说明：
- 关于 :code:`num_iteration_per_drop_scope` ，框架在运行过程中会产生一些临时变量，这些变量被放在local execution scope中。通常每经过一个batch就要清理一下local execution scope中的变量，但是由于GPU是异步设备，在清理local execution scope之前需要对所有的GPU调用一次同步操作，因此耗费的时间较长。为此我们在 :code:`execution_strategy` 中添加了 :code:`num_iteration_per_drop_scope` 选项。用户可以指定经过多少次迭代之后清理一次local execution scope。
- 关于 :code:`num_threads` ，:code:`ParallelExecutor` 根据Op之间的依赖关系确定Op的执行顺序，即：当Op的输入都已经变为ready状态之后，该Op会被放到一个队列中，等待被执行。 :code:`ParallelExecutor` 内部有一个任务调度线程和一个线程池，任务调度线程从队列中取出所有Ready的Op，并将其放到线程队列中。 :code:`num_threads` 表示线程池的大小。根据以往的经验，对于CPU任务，:code:`num_threads=2*dev_count` 时性能较好，对于GPU任务，:code:`num_threads=4*dev_count` 时性能较好。**注意：线程池不是越大越好**。
执行策略配置推荐
>>>>>>>>>>>>>>>
- 在显存足够的前提下，建议将 :code:`exec_strategy.num_iteration_per_drop_scope` 设置成一个较大的值，比如设置 :code:`exec_strategy.num_iteration_per_drop_scope=100` ，这样可以避免反复地申请和释放内存。该配置对于一些模型的优化效果较为明显。
- 对于一些较小的模型，比如mnist、language_model等，多个线程乱序调度op的开销大于其收益，因此推荐设置 :code:`exec_strategy.num_threads=1` 。
CPU训练设置
>>>>>>>>>>>>>>>
- 如果使用CPU做数据并行训练，需要指定环境变量CPU_NUM，这个环境变量指定程序运行过程中使用的 :code:`CPUPlace` 的个数。
- 如果使用CPU进行数据并行训练，并且 :code:`build_strategy.reduce_strategy` = :code:`fluid.BuildStrategy.ReduceStrategy.Reduce` ，所有 :code:`CPUPlace` 上的参数是共享的，因此对于一些使用CPU进行数据并行训练的模型，选用 :code:`Reduce` 模式可能会更快一些。
4. 运行时FLAGS设置
=============
Fluid中有一些FLAGS可以有助于性能优化：
- FLAGS_fraction_of_gpu_memory_to_use表示每次分配GPU显存的最小单位，取值范围为[0, 1)。由于CUDA原生的显存分配cuMalloc和释放cuFree操作均是同步操作，非常耗时，因此将FLAGS_fraction_of_gpu_memory_to_use设置成一个较大的值，比如0.92（默认值），可以显著地加速训练的速度。
- FLAGS_cudnn_exhaustive_search表示cuDNN在选取conv实现算法时采取穷举搜索策略，因此往往能选取到一个更快的conv实现算法，这对于CNN网络通常都是有加速的。但穷举搜索往往也会增加cuDNN的显存需求，因此用户可根据模型的实际情况选择是否设置该变量。
- FLAGS_enable_cublas_tensor_op_math表示是否使用TensorCore加速计算cuBLAS。这个环境变量只在Tesla V100以及更新的GPU上适用，且可能会带来一定的精度损失。
5. 使用Profile工具进行性能分析
=============
为方便用户更好的发现程序中的性能瓶颈，Paddle提供了多种Profile工具，这些工具的详细介绍和使用说明请参考 `性能调优 <http://www.paddlepaddle.org.cn/documentation/docs/zh/1.5/advanced_usage/development/profiling/index_cn.html>`_ 。
doc/fluid/advanced_usage/deploy/anakin_arm_benchmark.md 已删除 100644 → 0
浏览文件 @ 1fe89e8a
# Anakin ARM 性能测试
## 测试环境和参数:
+ 测试模型Mobilenetv1, mobilenetv2, mobilenet-ssd
+ 采用android ndk交叉编译，gcc 4.9，enable neon， ABI： armveabi-v7a with neon -mfloat-abi=softfp
+ 测试平台
- 荣耀v9(root): 处理器:麒麟960, 4 big cores in 2.36GHz, 4 little cores in 1.8GHz
- nubia z17:处理器:高通835, 4 big cores in 2.36GHz, 4 little cores in 1.9GHz
- 360 N5:处理器:高通653, 4 big cores in 1.8GHz, 4 little cores in 1.4GHz
+ 多线程：openmp
+ 时间：warmup10次，运行10次取均值
+ ncnn版本：来源于github的master branch中commits ID：307a77f04be29875f40d337cfff6df747df09de6（msg:convert LogisticRegressionOutput)版本
+ TFlite版本：来源于github的master branch中commits ID：65c05bc2ac19f51f7027e66350bc71652662125c（msg:Removed unneeded file copy that was causing failure in Pi builds)版本
在BenchMark中本文将使用**`ncnn`**、**`TFlite`**和**`Anakin`**进行性能对比分析
## BenchMark model
> 注意在性能测试之前，请先将测试model通过[External Converter](#10003)转换为Anakin model
> 对这些model，本文在ARM上进行多线程的单batch size测试。
- [Mobilenet v1](#11) *caffe model 可以在[这儿](https://github.com/shicai/MobileNet-Caffe)下载*
- [Mobilenet v2](#22) *caffe model 可以在[这儿](https://github.com/shicai/MobileNet-Caffe)下载*
- [mobilenet-ssd](#33) *caffe model 可以在[这儿](https://github.com/chuanqi305/MobileNet-SSD)下载*
### <span id = '11'> mobilenetv1 </span>
|platform | Anakin (1) | Anakin (2) | Anakin (4) | ncnn (1) | ncnn (2) | ncnn (4) | TFlite (1) | TFlite (2) | TFlite (4)|
|:---: | :---: | :---: | :---:| :---:| :---:| :---:| :---:| :---:| :---:|
|麒麟960|107.7ms|61.1ms|38.2ms|152.8ms|85.2ms|51.9ms|152.6ms|nan|nan|
|高通835|105.7ms|63.1ms|~~46.8ms~~|152.7ms|87.0ms|~~92.7ms~~|146.9ms|nan|nan|
|高通653|120.3ms|64.2ms|46.6ms|202.5ms|117.6ms|84.8ms|158.6ms|nan|nan|
### <span id = '22'> mobilenetv2 </span>
|platform | Anakin (1) | Anakin (2) | Anakin (4) | ncnn (1) | ncnn (2) | ncnn (4) | TFlite (1) | TFlite (2) | TFlite (4)|
|:---: | :---: | :---: | :---:| :---:| :---:| :---:| :---:| :---:| :---:|
|麒麟960|93.1ms|53.9ms|34.8ms|144.4ms|84.3ms|55.3ms|100.6ms|nan|nan|
|高通835|93.0ms|55.6ms|41.1ms|139.1ms|88.4ms|58.1ms|95.2ms|nan|nan|
|高通653|106.6ms|64.2ms|48.0ms|199.9ms|125.1ms|98.9ms|108.5ms|nan|nan|
### <span id = '33'> mobilenet-ssd </span>
|platform | Anakin (1) | Anakin (2) | Anakin (4) | ncnn (1) | ncnn (2) | ncnn (4) | TFlite (1) | TFlite (2) | TFlite (4)|
|:---: | :---: | :---: | :---:| :---:| :---:| :---:| :---:| :---:| :---:|
|麒麟960|213.9ms|120.5ms|74.5ms|307.9ms|166.5ms|104.2ms|nan|nan|nan|
|高通835|213.0ms|125.7ms|~~98.4ms~~|292.9ms|177.9ms|~~167.8ms~~|nan|nan|nan|
|高通653|236.0ms|129.6ms|96.0ms|377.7ms|228.9ms|165.0ms|nan|nan|nan
## How to run those Benchmark models?
1. 首先, 使用[External Converter](../docs/Manual/Converter_en.md)对caffe model 进行转换
2. 然后将转换后的Anakin model和编译好的benchmark_arm 二进制文件通过'adb push'命令上传至测试机
3. 接着在测试机含有Anakin model的目录中运行'./benchmark_arm ./ anakin_model.anakin.bin 1 10 10 1' 命令
4. 最后，终端显示器上将会打印该模型的运行时间
5. 其中运行命令的参数个数和含义可以通过运行'./benchmark_arm'看到
doc/fluid/advanced_usage/deploy/anakin_example.md 已删除 100644 → 0
浏览文件 @ 1fe89e8a
# Example
Anakin目前只支持NCHW的格式
示例文件在test/framework/net下
## 在NV的GPU上运行CNN模型
示例文件为打开example_nv_cnn_net.cpp，整体流程如下：
- 将模型的的path设置为anakin模型的路径，初始化NV平台的图对象。 anakin模型可以通过转换器转化caffe或fluid的模型得到
- 根据模型设置网络图的输入尺寸，进行图优化
- 根据优化后的网络图初始化网络执行器
- 取出网络的输入tensor，将数据拷贝到输入tensor
- 运行推导
- 取出网络的输出tensor
以NV平台为例演示Anakin框架的使用方法，注意编译时需要打开GPU编译开关
## 在X86上运行RNN模型
示例文件为example_x86_rnn_net.cpp
整体流程与在NV的GPU上运行CNN模型相似，不同之处如下：
- 使用X86标识初始化图对象和网络执行器对象
- rnn模型的输入尺寸是可变的，初始化图时的输入维度是维度的最大值，输入维度N代表总的词的个数。还需要设置输入tensor的seq_offset来标示这些词是如何划分为句子的,如{0,5,12}表示共有12个词，其中第0到第4个词是第一句话，第5到第11个词是第二句话
以X86平台为例演示Anakin框架的使用方法，注意编译时需要打开X86编译开关
## 在NV的GPU上使用Anakin的线程池运行CNN模型
示例文件为example_nv_cnn_net_multi_thread.cpp ，示例使用worker的同步预测接口
整体流程与在NV的GPU上运行CNN模型相似，不同之处如下：
- 用模型地址和线程池大小初始化worker对象
- 将输入tensor注入任务队列,获得输出tensor
doc/fluid/advanced_usage/deploy/anakin_gpu_benchmark.md 已删除 100644 → 0
浏览文件 @ 1fe89e8a
# Anakin GPU Benchmark
## Machine:
> CPU: `12-core Intel(R) Xeon(R) CPU E5-2620 v2 @2.10GHz`
> GPU: `Tesla P4`
> cuDNN: `v7`
## Counterpart of anakin :
The counterpart of **`Anakin`** is the acknowledged high performance inference engine **`NVIDIA TensorRT 3`** , The models which TensorRT 3 doesn't support we use the custom plugins to support.
## Benchmark Model
The following convolutional neural networks are tested with both `Anakin` and `TenorRT3`.
You can use pretrained caffe model or the model trained by youself.
> Please note that you should transform caffe model or others into anakin model with the help of [`external converter ->`](../docs/Manual/Converter_en.md)
- [Vgg16](#1) *caffe model can be found [here->](https://gist.github.com/jimmie33/27c1c0a7736ba66c2395)*
- [Yolo](#2) *caffe model can be found [here->](https://github.com/hojel/caffe-yolo-model)*
- [Resnet50](#3) *caffe model can be found [here->](https://github.com/KaimingHe/deep-residual-networks#models)*
- [Resnet101](#4) *caffe model can be found [here->](https://github.com/KaimingHe/deep-residual-networks#models)*
- [Mobilenet v1](#5) *caffe model can be found [here->](https://github.com/shicai/MobileNet-Caffe)*
- [Mobilenet v2](#6) *caffe model can be found [here->](https://github.com/shicai/MobileNet-Caffe)*
- [RNN](#7) *not support yet*
We tested them on single-GPU with single-thread.
### <span id = '1'>VGG16 </span>
- Latency (`ms`) of different batch
| BatchSize | TensorRT | Anakin |
| --- | --- | --- |
| 1 | 8.8690 | 8.2815 |
| 2 | 15.5344 | 13.9116 |
| 4 | 26.6000 | 21.8747 |
| 8 | 49.8279 | 40.4076 |
| 32 | 188.6270 | 163.7660 |
- GPU Memory Used (`MB`)
| BatchSize | TensorRT | Anakin |
| --- | --- | --- |
| 1 | 963 | 997 |
| 2 | 965 | 1039 |
| 4 | 991 | 1115 |
| 8 | 1067 | 1269 |
| 32 | 1715 | 2193 |
### <span id = '2'>Yolo </span>
- Latency (`ms`) of different batch
| BatchSize | TensorRT | Anakin |
| --- | --- | --- |
| 1 | 16.4596| 15.2124 |
| 2 | 26.6347| 25.0442 |
| 4 | 43.3695| 43.5017 |
| 8 | 80.9139 | 80.9880 |
| 32 | 293.8080| 310.8810 |
- GPU Memory Used (`MB`)
| BatchSize | TensorRT | Anakin |
| --- | --- | --- |
| 1 | 1569 | 1775 |
| 2 | 1649 | 1815 |
| 4 | 1709 | 1887 |
| 8 | 1731 | 2031 |
| 32 | 2253 | 2907 |
### <span id = '3'> Resnet50 </span>
- Latency (`ms`) of different batch
| BatchSize | TensorRT | Anakin |
| --- | --- | --- |
| 1 | 4.2459 | 4.1061 |
| 2 | 6.2627 | 6.5159 |
| 4 | 10.1277 | 11.3327 |
| 8 | 17.8209 | 20.6680 |
| 32 | 65.8582 | 77.8858 |
- GPU Memory Used (`MB`)
| BatchSize | TensorRT | Anakin |
| --- | --- | --- |
| 1 | 531 | 503 |
| 2 | 543 | 517 |
| 4 | 583 | 541 |
| 8 | 611 | 589 |
| 32 | 809 | 879 |
### <span id = '4'> Resnet101 </span>
- Latency (`ms`) of different batch
| BatchSize | TensorRT | Anakin |
| --- | --- | --- |
| 1 | 7.5562 | 7.0837 |
| 2 | 11.6023 | 11.4079 |
| 4 | 18.3650 | 20.0493 |
| 8 | 32.7632 | 36.0648 |
| 32 | 123.2550 | 135.4880 |
- GPU Memory Used (`MB)`
| BatchSize | TensorRT | Anakin |
| --- | --- | --- |
| 1 | 701 | 683 |
| 2 | 713 | 697 |
| 4 | 793 | 721 |
| 8 | 819 | 769 |
| 32 | 1043 | 1059 |
### <span id = '5'> MobileNet V1 </span>
- Latency (`ms`) of different batch
| BatchSize | TensorRT | Anakin |
| --- | --- | --- |
| 1 | 45.5156 | 1.3947 |
| 2 | 46.5585 | 2.5483 |
| 4 | 48.4242 | 4.3404 |
| 8 | 52.7957 | 8.1513 |
| 32 | 83.2519 | 31.3178 |
- GPU Memory Used (`MB`)
| BatchSize | TensorRT | Anakin |
| --- | --- | --- |
| 1 | 329 | 283 |
| 2 | 345 | 289 |
| 4 | 371 | 299 |
| 8 | 393 | 319 |
| 32 | 531 | 433 |
### <span id = '6'> MobileNet V2</span>
- Latency (`ms`) of different batch
| BatchSize | TensorRT | Anakin |
| --- | --- | --- |
| 1 | 65.6861 | 2.9842 |
| 2 | 66.6814 | 4.7472 |
| 4 | 69.7114 | 7.4163 |
| 8 | 76.1092 | 12.8779 |
| 32 | 124.9810 | 47.2142 |
- GPU Memory Used (`MB`)
| BatchSize | TensorRT | Anakin |
| --- | --- | --- |
| 1 | 341 | 293 |
| 2 | 353 | 301 |
| 4 | 385 | 319 |
| 8 | 421 | 351 |
| 32 | 637 | 551 |
## How to run those Benchmark models?
> 1. At first, you should parse the caffe model with [`external converter`](https://github.com/PaddlePaddle/Anakin/blob/b95f31e19993a192e7428b4fcf852b9fe9860e5f/docs/Manual/Converter_en.md).
> 2. Switch to *source_root/benchmark/CNN* directory. Use 'mkdir ./models' to create ./models and put anakin models into this file.
> 3. Use command 'sh run.sh', we will create files in logs to save model log with different batch size. Finally, model latency summary will be displayed on the screen.
> 4. If you want to get more detailed information with op time, you can modify CMakeLists.txt with setting `ENABLE_OP_TIMER` to `YES`, then recompile and run. You will find detailed information in model log file.
doc/fluid/advanced_usage/deploy/anakin_tutorial.md 已删除 100644 → 0
浏览文件 @ 1fe89e8a
# Anakin 使用教程 ##
本教程将会简略的介绍Anakin的工作原理，一些基本的Anakin API，以及如何调用这些API。
## 内容 ###
- [Anakin的工作原理](#principle)
- [Anakin APIs](#api)
- [示例代码](#example)
## <span id = 'principle'> Anakin的工作原理</span> ###
![Anakin_principle](../pics/anakin_fm_ch.png)
用Anakin来进行前向计算主要分为三个步骤：
- 将外部模型通过[Anakin Parser](Converter_ch.md)解析为Anakin模型
在使用Anakin之前，用户必须将所有其他模型转换成Anakin模型，我们提供了转换脚本，用户可通过[Anakin Parser](Converter_ch.md)进行模型转换。
- 生成Anakin计算图
加载Anakin模型生成原始计算图，然后需要对原始计算图进行优化。你只需要调用相应的API优化即可。
- 执行计算图
Anakin会选择不同硬件平台执行计算图。
## <span id ='api'>Anakin APIs </span> ###
### Tensor ####
`Tensor`提供基础的数据操作和管理，为ops提供统一的数据接口。`Tensor`包含以下几个属性：
- Buffer
数据存储区
- Shape
数据的维度信息
- Event
用于异步计算的同步
`Tensor` 类包含三个`Shape`对象， 分别是`_shape`, `_valid_shape`和 `offset`。 `_shape`为`tensor`真正空间信息，`_valid_shape`表示当前`tensor`使用的空间信息， `_offset`表示当前`tensor`数据指针相对于真正数据空间的信息。 `Tensor`不同维度与分别与数学中的向量、矩阵等相对应如下表所示。
Dimentions | Math entity |
:----: | :----:
1 | vector
2 | matrix
3 | 3-tensor
n | n-tensor
#### 声明tensor对象
`Tensor`接受三个模板参数:
```c++
template<typename TargetType, DataType datatype, typename LayOutType = NCHW>
class Tensor .../* Inherit other class */{
//some implements
...
};
```
TargetType是平台类型，如X86，GPU等等，在Anakin内部有相应的标识与之对应；datatype是普通的数据类型，在Anakin内部也有相应的标志与之对应；[LayOutType](#layout)是数据分布类型，如batch x channel x height x width [NxCxHxW], 在Anakin内部用一个struct来标识。 Anakin中数据类型与基本数据类型的对应如下:
1. <span id='target'>TargetType</sapn>
Anakin TargetType | platform
:----: | :----:|
NV | NVIDIA GPU
ARM | ARM
AMD | AMD GPU
X86 | X86
NVHX86 | NVIDIA GPU with Pinned Memory
2. <sapn id='datatype'>DataType</span>
Anakin DataType | C++ | Description
:---: | :---: | :---: |
AK_HALF | short | fp16
AK_FLOAT | float | fp32
AK_DOUBLE | double | fp64
AK_INT8 | char | int8
AK_INT16 | short | int16
AK_INT32 | int | int32
AK_INT64 | long | int64
AK_UINT8 | unsigned char | uint8
AK_UINT16 | unsigned short | uint8
AK_UINT32 | unsigned int | uint32
AK_STRING | std::string | /
AK_BOOL | bool | /
AK_SHAPE | / | Anakin Shape
AK_TENSOR | / | Anakin Tensor
3. <span id = 'layout'>LayOutType </span>
Anakin LayOutType ( Tensor LayOut ) | Tensor Dimention | Tensor Support | Op Support
:---: | :---: | :---: | :---: |
W | 1-D | YES | NO
HW | 2-D | YES | NO
WH | 2-D | YES | NO
NW | 2-D | YES | YES
NHW | 3-D | YES |YES
NCHW ( default ) | 4-D | YES | YES
NHWC | 4-D | YES | NO
NCHW_C4 | 5-D | YES | YES
理论上，Anakin支持申明1维以上的tensor，但是对于Anakin中的Op来说，只支持NW、NHW、NCHW、NCHW_C4这四种LayOut，其中NCHW是默认的LayOutType，NCHW_C4是专门针对于int8这种数据类型的。
例子
> 下面的代码将展示如何使用tensor， 我们建议先看看这些示例。
> 要想获得更多关于tensor的信息， 请参考 *soure_path/core/tensor.h*
> 1. 使用shape对象初始化tensor
``` c++
//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 Layout is NCHW(default)
Tensor<X86, AK_FLOAT> mytensor;
//1. using shape object to create a tensor.
Shape shape1(NUM); //1-D shape. NUM is the number of dimention.
Tensor<X86, AK_FLOAT, W> mytensor1(shape1); //1-D tensor.
// A 4-D shape
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，否则会出错。如下列代码所示`
```c++
// A 4-D tensor.
Tensor<X86, AK_FLOAT> mytensor2(shape2); //right
//A 4-D tensor which is resident at GPU and its datatype is AK_INT8
Tensor<NV, AK_INT8> mytensor3(shape2); //right
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!!!!
```
> 2. 使用现有的数据和shape初始化tensor
```c++
/**
* A construtor of Tensor.
* data_ptr is a pointer to any data type of data
* TargetType is type of a platform [Anakin TargetType]
* id : device id
* shape: a Anakin shape
*/
Tensor(Dtype* data_ptr, TargetType_t target, int id, Shape shape);
//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).
```
> 3. 使用tensor初始化tensor
```c++
Tensor<NV, AK_FLOAT> tensor(exist_tensor);
```
> 提示： 你可以用` typedef Tensor<X86, AK_FLOAT> Tensor4d_X86 `方便定义tensor
#### 填充tensor数据区
填充数据区得看你申明tensor的方式， 下面展示了如何填充tensor的数据区。
```c++
首先来看看tensor的四种声明方式：
1. Tensor<X86, AK_FLOAT> mytensor;
2. Tensor<X86, AK_FLOAT, W> mytensor1(shape1);
3. Tensor<X86, AK_FLOAT> mytensor(data_ptr, TargetType, device_id, shape);
4. Tensor<NV, AK_FLOAT> tensor(exist_tensor);
相关的声明方式的数据填充方法如下：
1：声明一个空的tensor，此时没有为其分配内存，所以，我们需要手动的为其分配内存。
//parama shape
mytensor.re_alloc(Shape shape);
//Get writable pointer to mytensor.
//parama index (int): where you start to write.
//Dtype is your data type such int, float or double.
Dtype *p = mytensor.mutable_data(index/*=0*/);
//write data to mytensor
for(int i = 0; i < mytensor.size(); i++){
p[i] = 1.0f;
}
//do something ...
2: 这种声明方式会自动分配内存
//Get writable pointer to mytensor.
//parama index (int): where you start to write.
//Dtype is your data type such int, float or double.
Dtype *p = mytensor1.mutable_data(index/*=0*/);
//write data to mytensor
for(int i = 0; i < mytensor.size(); i++){
p[i] = 1.0f;
}
//do something ...
3：在该种声明方式中，我们仍不需要手动为其分配内存。但在构造函数内部是否为其分配内存，得依情况而定。如果data_ptr和申明的
tensor都在都一个目标平台上，那么该tensor就会与data_ptr共享内存空间，相反，如果他们不在同一个平台上（如data_ptr在X86上，而
tensor在GPU上），那么此时tensor就会开辟一个新的内存空间，并将data_ptr所指向的数据拷贝到tensor的buffer中。
//Get writable pointer to mytensor.
//parama index (int): where you start to write.
//Dtype is your data type such int, float or double.
Dtype *p = mytensor.mutable_data(index/*=0*/);
//write data to mytensor
for(int i = 0; i < mytensor.size(); i++){
p[i] = 1.0f;
}
//do something ...
4：该种方式仍不需要手动分配内存
//Get writable pointer to mytensor.
//parama index (int): where you start to write.
//Dtype is your data type such int, float or double.
Dtype *p = mytensor.mutable_data(index/*=0*/);
//write data to mytensor
for(int i = 0; i < mytensor.size(); i++){
p[i] = 1.0f;
}
//do something ...
另外，你还可以获取一个tensor的可读指针，示例如下：
//Get read-only pointer to mytensor.
//parama index (int): where you start to read.
//Dtype is your data type such int, float or double.
Dtype *p = mytensor.data(index/*=0*/);
//do something ...
```
如果想更详细的了解tensor，请查阅*soure_path/saber/core/tensor.h*
#### 获取tensor的shape
```c++
//some declarations
// ...
Shape shape = mytensor.shape();
//Get a first dimetion size of tesor, if it has.
int d1 = shape[0];
//Get a second dimention size of tensor, if it has.
int d2 = shape[1];
...
//Get a n-th dimention size of tensor, if it has.
int dn = shape[n-1];
//Get a tensor's dimention
int dims = mytensor.dims();
//Get the size of tensor.
//size = d1 x d2 x ... x dn.
int size = mytensor.size();
//Get the size of tensor at interval [Di, Dj)
// form i-th dimention to j-th dimention, but not including the j-th dimention.
// which means di x (di+1) x ... x (dj -1)
int size = mytensor.count(start, end);
```
#### 设置tensor的shape
我们可以用tensor的成员函数set_shape来设置tensor的shape。 下面是set_shape的定义
```c++
/**
* \brief set a tensor's shape
* \param valid_shape [a Shape object]
* \param shape [a Shape object]
* \param offset [a Shape object]
* \return the status of this operation, that means whether it success * or not.
*/
SaberStatus set_shape(Shape valid_shape, Shape shape = Shape::zero(TensorAPI::layout_dims::value), Shape offset = Shape::minusone(TensorAPI::layout_dims::value));
```
这个成员函数只设置tensor的shape。这些shape对象(valid_shape, shape, offset)的[LayOutType](#layout)必须和当前的tensor的相应三个shape对象的LayOutType相同，如果不同就会出错，返回SaberInvalidValue。 如果相同，那么将成功设置tensor的shape。
```c++
// some declarations
// ...
//valid_shape, shape , offset are Shape object;
//All these Shape object's LayOutType must be equal to mytensor's.
mytensor.set_shape(valid_shape, shape, offset);
```
#### 重置 tensor的shape
```c++
//some declarations
Shape shape, valid_shape, offset;
//do some initializations
...
mytensor.reshape(valid_shape, shape, offset);
```
注意： Reshape操作仍然需要shape的[LayOutType](#layout) 与tensor的相同
### Graph ###
`Graph`类负责加载Anakin模型生成计算图、对图进行优化、存储模型等操作。
#### 图的声明
与`Tensor`一样，graph也接受三个模板参数。
```c++
template<typename TargetType, DataType Dtype, Precision Ptype>
class Graph ... /* inherit other class*/{
//some implements
...
};
```
前面已经介绍过[TargetType](#target)和[DataType](#datatype)是Anakin内部自定义数据类型。[TargetType](#target)表示平台类型 (如NV、X86), [DataType](#datatype)是Anakin基本数据类型与C++/C中的基本数据类型相对应。 [Precision](#precision)为op所支持的精度类型, 稍后我们在介绍它。
```c++
//Create a empty graph object.
Graph graph = Graph<NV, AK_FLOAT, Precision::FP32> tmp();
//Create a pointer to a empty graph.
Graph *graph = new Graph<NV, AK_FLOAT, Precision::FP32>();
//Create a pointer to a empty graph.
auto graph = new Graph<NV, AK_FLOAT, Precision::FP32>();
```
#### 加载 Anakin 模型
```c++
//some declarations
...
auto graph = new Graph<NV, AK_FLOAT, Precision::FP32>();
std::string model_path = "the/path/to/where/your/models/are";
const char *model_path1 = "the/path/to/where/your/models/are";
//Loading Anakin model to generate a compute graph.
auto status = graph->load(model_path);
//Or this way.
auto status = graph->load(model_path1);
//Check whether load operation success.
if(!status){
std::cout << "error" << endl;
//do something...
}
```
#### 优化计算图
```c++
//some declarations
...
//Load graph.
...
//According to the ops of loaded graph, optimize compute graph.
graph->Optimize();
```
> 注意： 第一次加载原始图，必须要优化。
#### 保存模型
你可以在任何时候保存模型， 特别的， 你可以保存一个优化的模型，这样，下次再加载模型时，就不必进行优化操作。
```c++
//some declarations
...
//Load graph.
...
// save a model
//save_model_path: the path to where your model is.
auto status = graph->save(save_model_path);
//Checking
if(!status){
cout << "error" << endl;
//do somethin...
}
```
#### 重新设置计算图里的tensor的shape
```c++
//some declarations
...
//Load graph.
...
vector<int> shape{10, 256, 256, 10};
//input_name : std::string.
//Reshape a tensor named input_name.
graph->Reshape(input_name, shape);//Note: shape is a vector, not a Shape object.
```
#### 设置 batch size
`Graph` 支持重新设置batch size的大小。
```c++
//some declarations
...
//Load graph.
...
//input_name : std::string.
//Reset a tensor named input_name.
int new_batch_size = 4;
graph->ResetBatchSize(input_name, new_batch_size);
```
### Net ###
`Net` 是计算图的执行器。你可以通过Net对象获得输入和输出
#### Creating a graph executor
`Net`接受四个模板参数。
```c++
template<typename TargetType, DataType Dtype, Precision PType OpRunType RunType = OpRunType::ASYNC>
class Net{
//some implements
...
};
```
由于有些Op可能支持多种精度，我们可以通过Precision来指定。OpRunType表示同步或异步类型，异步是默认类型。OpRunType::SYNC表示同步，在GPU上只有单个流；OpRunType::ASYNC表示异步，在GPU上有多个流并以异步方式执行。实际上，Precision和OpRunType都是enum class, 详细设计请参考*source_root/framework/core/types.h*.
1. <span id = 'precision'> Precision </span>
Precision | Op support
:---: | :---:
Precision::INT4 | NO
Precision::INT8 | NO
Precision::FP16 | NO
Precision::FP32 | YES
Precision::FP64 | NO
现在Op的精度只支持FP32， 但在将来我们会支持剩下的Precision.
2. OpRunType
OpRunType | Sync/Aync |Description
:---: | :---: | :---:
OpRunType::SYNC | Synchronization | single-stream on GPU
OpRunType::ASYNC | Asynchronization | multi-stream on GPU
用graph对象创建一个执行器。
```c++
//some declarations
...
//Create a pointer to a graph.
auto graph = new Graph<NV, AK_FLOAT, Precision::FP32>();
//do something...
...
//create a executor
Net<NV, AK_FLOAT, Precision::FP32> executor(*graph);
```
#### 获取输入输出tensor
获取输入输出tensor，并填充输入tensor的buffer。如果想要获取输入和输出tensor，那么必须指定输入的名字，如"input_0", "input_1", "input_2", ..., 必须传入如上字符串才能够获得输入tensor。另外，如果想知道input_i对应哪个输入，你需要去dash board查看，如何使用dash board请看[Anakin Parser](Converter_ch.md)。请看如下示例代码
```c++
//some declaratinos
...
//create a executor
//TargetType is NV [NVIDIA GPU]
Net<NV, AK_FLOAT, Precision::FP32> executor(*graph);
//Get the first input tensor.
//The following tensors(tensor_in0, tensor_in2 ...) are resident at GPU.
//Note: Member function get_in returns an pointer to tensor.
Tensor<NV, AK_FLOAT>* tensor_in0 = executor.get_in("input_0");
//If you have multiple input tensors
//You just type this code below.
Tensor<NV, AK_FLOAT>* tensor_in1 = executor.get_in("input_1");
...
auto tensor_inn = executor.get_in("input_n");
```
当得到输入tensor之后，就可以填充它的数据区了。
```c++
//This tensor is resident at GPU.
auto tensor_d_in = executor.get_in("input_0");
//If we want to feed above tensor, we must feed the tensor which is resident at host. And then copy the host tensor to the device's one.
//using Tensor4d = Tensor<Ttype, Dtype>;
Tensor4d<X86, AK_FLOAT> tensor_h_in; //host tensor;
//Tensor<X86, AK_FLOAT> tensor_h_in;
//Allocate memory for host tensor.
tensor_h_in.re_alloc(tensor_d_in->valid_shape());
//Get a writable pointer to tensor.
float *h_data = tensor_h_in.mutable_data();
//Feed your tensor.
/** example
for(int i = 0; i < tensor_h_in.size(); i++){
h_data[i] = 1.0f;
}
*/
//Copy host tensor's data to device tensor.
tensor_d_in->copy_from(tensor_h_in);
// And then
```
类似的，我们可以利用成员函数get_out来获得输出tensor。但与获得输入tensor不同的是， 我们需要指定输入tensor结点的名字，这个可以从dash board中看到，请从[Anakin Parser](Converter_ch.md)中查看dash board的使用方法。假如有个输出结点叫pred_out, 那么我们可以通过如下代码获得相应的输出tensor：
```c++
//Note: this tensor are resident at GPU.
Tensor<NV, AK_FLOAT>* tensor_out_d = executor.get_out("pred_out");
```
#### Executing graph
当一切准备就绪后，我们就可以执行真正的计算了！
```c++
executor.prediction();
```
## <span id='example'> 示例代码 </span> ##
下面的例子展示了如何调用Anakin。
在这儿之前， 请确保你已经有了Anakin模型。如果还没有，那么请使用[Anakin Parser](Converter_ch.md)转换你的模型。
### Single-thread
单线程例子在 *source_root/test/framework/net/net_exec_test.cpp`*
```c++
std::string model_path = "your_Anakin_models/xxxxx.anakin.bin";
// Create an empty graph object.
auto graph = new Graph<NV, AK_FLOAT, Precision::FP32>();
// Load Anakin model.
auto status = graph->load(model_path);
if(!status ) {
LOG(FATAL) << " [ERROR] " << status.info();
}
// Reshape
graph->Reshape("input_0", {10, 384, 960, 10});
// You must optimize graph for the first time.
graph->Optimize();
// Create a executer.
Net<NV, AK_FLOAT, Precision::FP32> net_executer(*graph);
//Get your input tensors through some specific string such as "input_0", "input_1", and
//so on.
//And then, feed the input tensor.
//If you don't know Which input do these specific string ("input_0", "input_1") correspond with, you can launch dash board to find out.
auto d_tensor_in_p = net_executer.get_in("input_0");
Tensor4d<X86, AK_FLOAT> h_tensor_in;
auto valid_shape_in = d_tensor_in_p->valid_shape();
for (int i=0; i<valid_shape_in.size(); i++) {
LOG(INFO) << "detect input dims[" << i << "]" << valid_shape_in[i]; //see tensor's dimentions
}
h_tensor_in.re_alloc(valid_shape_in);
float* h_data = h_tensor_in.mutable_data();
for (int i=0; i<h_tensor_in.size(); i++) {
h_data[i] = 1.0f;
}
d_tensor_in_p->copy_from(h_tensor_in);
//Do inference.
net_executer.prediction();
//Get result tensor through the name of output node.
//And also, you need to see the dash board again to find out how many output nodes are and remember their name.
//For example, you've got a output node named obj_pre_out
//Then, you can get an output tensor.
auto d_tensor_out_0_p = net_executer.get_out("obj_pred_out"); //get_out returns a pointer to output tensor.
auto d_tensor_out_1_p = net_executer.get_out("lc_pred_out"); //get_out returns a pointer to output tensor.
//......
// do something else ...
//...
//save model.
//You might not optimize the graph when you load the saved model again.
std::string save_model_path = model_path + std::string(".saved");
auto status = graph->save(save_model_path);
if (!status ) {
LOG(FATAL) << " [ERROR] " << status.info();
}
```
doc/fluid/advanced_usage/deploy/convert_paddle_to_anakin.md 已删除 100644 → 0
浏览文件 @ 1fe89e8a
# 模型转换指南
Anakin 支持不同框架的模型预测。但由于格式的差别，Anakin 需要您预先转换模型。本文档介绍如何转换模型。
## 简介
Anakin 模型转换器输入支持 Caffe 和 Fluid 两种格式的预测模型，模型包含网络结构（model 或 prototxt）和权重参数（param 或 caffemodel）。
模型转换的输出是一个 bin 文件，它作为 Anakin 框架的 graph 参数导入。
您还可以使用模型转换器的 launch board 功能生成网络结构的 HTML 预览。
## 系统要求
- python 2.7+
- pyyaml
- flask
- protobuf 3.5+
## 用法
### 1、环境
转换器所需的依赖标注于 *系统要求* 一节。
### 2、配置
您需要对 *config.yaml* 文件进行修改以告知您的需求。工程中给出了 *config.yaml* 示例，下面作进一步说明。
#### config.yaml
```bash
OPTIONS:
Framework: CAFFE # 依框架类型填写 CAFFE 或 FLUID
SavePath: ./output # 转换结束后模型的保存位置
ResultName: googlenet # 输出模型的名字
Config:
LaunchBoard: ON # 是否生成网络结构预览页面
Server:
ip: 0.0.0.0
port: 8888 # 从一个可用端口访问预览页面
OptimizedGraph: # 当您使用了 Anakin 框架的 Optimized 功能时，才应该打开此项
enable: OFF
path: /path/to/anakin_optimized_anakin_model/googlenet.anakin.bin.saved
LOGGER:
LogToPath: ./log/ # 生成日志的路径
WithColor: ON
TARGET:
CAFFE:
# 当 Framework 为 CAFFE 时需填写
ProtoPaths:
- /path/to/caffe/src/caffe/proto/caffe.proto
PrototxtPath: /path/to/your/googlenet.prototxt
ModelPath: /path/to/your/googlenet.caffemodel
FLUID:
# 当 Framework 为 FLUID 时需填写
Debug: NULL
ProtoPaths:
- /
PrototxtPath: /path/to/fluid/inference_model
ModelPath: /path/to/fluid/inference_model
# ...
```
### 3、转换
在完成配置文件的修改后，您只需执行 ```python converter.py``` 就可以进行模型转换了。
### 4、预览
最后一步，就是在浏览器中查看令人振奋的转换结果！网址是在 *config.yaml* 中配置的，例如 http://0.0.0.0:8888 。
> 注意：若您使用了默认的 IP 地址 0.0.0.0，请在预览时使用真实的服务器地址 real_ip:port 替代它。
doc/fluid/advanced_usage/deploy/how_to_add_anakin_op.md 已删除 100644 → 0
浏览文件 @ 1fe89e8a
# 如何增加新的Operator
## 基本概念
简单介绍下几个同Operator相关的基本概念，详情请参考设计文档。
```framework```: 上层的逻辑代码，负责从parser中获取参数及weights，添加op时主要修改framework/operator目录下的内容。
```saber```: 底层的实现代码，Anakin通过saber封装了不同的backends，不同的实现(impl)分别特化出自己的实现，外层framework通过不同的template进入各自的impl完成调用。各个op的parameter放在saber/saber_funcs_param.h文件中，增加op主要修改saber/funcs下的内容。
saber的文件结构：
* saber/funcs下的是各个funcs的外部接口，这一层的op与具体的设备实现无关，只与各op完成的功能有关。由于跟实现(impl)无关，本层文件明均不带impl。
* saber/funcs/impl下是各个op的impl声明，特定设备需要完成该层声明的特化版本，如saber/funcs/impl/x86实现了上一层impl声明的x86特化版本，saber/funcs/impl/cuda实现了上一层impl声明的NV特化版本。当增加新的backends时需要特化出新的实现。本层代码同实现相关，均带有```impl_```前缀。
* saber/funcs/impl/cuda/base/cuda_c内有cuda```.cu```扩展名的文件，添加cuda的kernel需要在该文件目录下添加。
* saber/funcs/impl/cuda/base/sass 内有不同架构的汇编代码编译的静态库。
### 涉及到的基类及各个类之前的关系
简单介绍相关的基类
* ```anakin::Operator```: framework的operator基类，位于framework/core/operator/operator.h
* ```anakin::saber::BaseFunc```: saber对外的op接口基类，提供统一的对外接口，位于saber/funcs/base.h。BaseFunc的```compute_output_shape```接口只根据input的shape和param的参数计算输出的shape，并通过```tensor```的```set_shape```接口(只设置shape，不分配空间)设置到output中。```operator()```接口为各个op的计算接口。
* ```ankain::saber::ImplBase```: saber设备实现的op的接口，所有设备相关实现的基类。位于saber/funcs/impl/impl_base.h。实现版本中这里分为两类，一类以```vender_```为前缀，带有```vender_```代码意为使用第三方库来实现该op，如cudnn的conv，或mkl的conv等等，这类op的性能我们难以调优，因此单独列为一类。另一类是带有源码的saber实现，这些实现都带有```saber_```为前缀，此类实现带有源码，能够通过后续优化不断提升性能，实现起名时需要注意这一点。
## 添加operator
添加一个新的op需要以下几步：
1. 添加saber的param
2. 定义saber的Operator类
3. 定义新的impl声明
3. 完成新的impl实现
4. 增加framework的实现或特化
接下来就针对这几步，以一个简单例子为例介绍实现。
例如我们要添加新的Mul op。给出计算公式如下：$$Out = alpha \dot X * Y$$
### 为operator增加param
涉及到的文件：```saber/saber_funcs_param.h```。如果之前已经存在需要添加的op的param，这一步可以跳过。
这里```XXXParam```是一个```struct```。包含一个无参数的构造函数，含参数的构造函数，复制构造函数，```operator=()```及```operator==()```。
```
template <typename opTensor> // 能够获得target, datatype, layout
struct MulParam{
MulParam()
: alpha(0)
{}
MulParam(float alpha_in)
: alpha(alpha_in)
{}
MulParam(const MulParam& right)
: alpha(right.alpha)
{}
MulParam &operator=(const MulParam &right) {
alpha = right.alpha;
}
bool operator==(const MulParam &right) {
return alpha == right.alpha;
}
float alpha;
};
```
### 定义Operator类
涉及到的文件:```saber/funcs/mul.h```。如果之前定义过该op的类，这里需要修改输入的impl定义头文件。
下面给出一个相对完整的定义结构供参考。
```
//不同的设备需要包含对应的operator实现.[详见](#impl)
#ifdef NVIDIA_GPU
#include "saber/funcs/impl/cuda/saber_mul.h"
#include "saber/funcs/impl/cuda/vender_mul.h"
#endif
//如果一个设备现在还没有对应的operator实现，需要包含声明。[详见](#declare)
#ifdef USE_X86_PLACE
#include "saber/funcs/impl/impl_mul.h"
#endif
namespace anakin {
namespace saber {
template<typename TargetType,
DataType OpDtype,
DataType inDtype = AK_FLOAT,
DataType outDtype = AK_FLOAT,
typename LayOutType_op = NCHW,
typename LayOutType_in = NCHW,
typename LayOutType_out = NCHW>
class Mul : public BaseFunc<
Tensor<TargetType, inDtype, LayOutType_in>,
Tensor<TargetType, outDtype, LayOutType_out>,
Tensor<TargetType, OpDtype, LayOutType_op>,
ImplBase, MulParam> {
public:
using BaseFunc<
Tensor<TargetType, inDtype, LayOutType_in>,
Tensor<TargetType, outDtype, LayOutType_out>,
Tensor<TargetType, OpDtype, LayOutType_op>,
ImplBase, MulParam>::BaseFunc;
Mul() = default;
typedef Tensor<TargetType, inDtype, LayOutType_in> InDataTensor;
typedef Tensor<TargetType, outDtype, LayOutType_out> OutDataTensor;
typedef Tensor<TargetType, OpDtype, LayOutType_op> OpTensor;
typedef MulParam<OpTensor> Param_t;
typedef std::vector<InDataTensor *> Input_v;
typedef std::vector<OutDataTensor *> Output_v;
typedef std::vector<Shape> Shape_v;
virtual SaberStatus compute_output_shape(const Input_v &input,
Output_v &output, Param_t &param) override {
//计算输出的shape，
Shape output_shape = (input[0]->valid_shape());
/* code */
return output[0]->set_shape(output_shape);
}
virtual SaberStatus init_impl(ImplEnum implenum) override {
// 不同设备均使用此init_impl, 此接口创建对应impl的实现。
switch (implenum) {
case VENDER_IMPL:
this->_impl.push_back(new VenderMul <TargetType,
OpDtype, inDtype, outDtype,
LayOutType_op, LayOutType_in, LayOutType_out>);
return SaberSuccess;
case SABER_IMPL:
this->_impl.push_back(new SaberMul <TargetType,
OpDtype, inDtype, outDtype,
LayOutType_op, LayOutType_in, LayOutType_out>);
return SaberSuccess;
default:
return SaberUnImplError;
}
}
private:
virtual void pick_best_static() override {
if (true) // some condition?
this->_best_impl = this->_impl[0];
}
virtual void pick_best_specify(ImplEnum implenum) override {
this->_best_impl = this->_impl[0];
}
};
} // namespace saber
} // namespace anakin
```
### 为operator增加新的impl<span id="declare">声明</span>
涉及的文件:```saber/funcs/impl/impl_mul.h```。不同的设备都特化同一个声明，特化版本放在对应的文件夹下，这里的声明就是给出所有设备的统一声明。下面给出一个参考。
```
#include "saber/funcs/impl/impl_macro.h"
namespace anakin{
namespace saber{
DEFINE_OP_CLASS(Mul, MulParam); // 第一个参数是op的名字，第二个是对应param的名字
}
}
```
### 完成新的operator特定后端<span id="impl">实现</span>
涉及的文件:```saber/funcs/impl/xxx/vender_mul.h```或```saber/funcs/impl/xxx/saber_mul.h```
这里```xxx```指代特定的一种设备。```vender```是指的使用第三方库实现的op，```saber```指的源码实现的op。这里以cuda的vender实现为例，简单介绍一下特化出的函数的几个基本接口。
```
// include 对应的声明
#include "saber/funcs/impl/impl_mul.h"
namespace anakin{
namespace saber{
template <DataType OpDtype,
DataType inDtype,
DataType outDtype,
typename LayOutType_op,
typename LayOutType_in,
typename LayOutType_out>
class VenderMul<NV, //偏特化出需要的后端。
OpDtype, inDtype, outDtype,
LayOutType_op, LayOutType_in, LayOutType_out> :
public ImplBase<
Tensor<NV, inDtype, LayOutType_in>,
Tensor<NV, outDtype, LayOutType_out>,
Tensor<NV, OpDtype, LayOutType_op>,
MulParam<Tensor<NV, OpDtype, LayOutType_op> > >
{
public:
typedef Tensor<NV, inDtype, LayOutType_in> DataTensor_in;
typedef Tensor<NV, outDtype, LayOutType_out> DataTensor_out;
typedef Tensor<NV, OpDtype, LayOutType_op> OpTensor;
typedef typename DataTensor_in::Dtype InDataType;
typedef typename DataTensor_out::Dtype OutDataType;
typedef typename OpTensor::Dtype OpDataType;
VenderMul(){}
~VenderMul() {}
virtual SaberStatus init(const std::vector<DataTensor_in *>& inputs,
std::vector<DataTensor_out *>& outputs,
MulParam<OpTensor>& param, Context<NV>& ctx) {
this->_ctx = ctx;
create(inputs, outputs, param, ctx);
}
virtual SaberStatus create(const std::vector<DataTensor_in *>& inputs,
std::vector<DataTensor_out *>& outputs,
MulParam<OpTensor>& param, Context<NV>& ctx) {
// set内部参数
}
virtual SaberStatus dispatch(const std::vector<DataTensor_in*>& inputs,
std::vector<DataTensor_out*>& outputs,
MulParam<OpTensor>& param) {
// dispatch kernel.
}
private:
};
}
}
```
```init```和```create```的区别：```init```接口是第一次初始化op的时候进入的接口，此函数只在第一次初始化op时调用，这个接口一般放一些只需要执行一次的代码，如malloc或者create之类的函数。```create```函数除了第一次init执行外，在输入发生变化或者param发生变化时会再次触发，create一般放置set函数，设置内部变量，当input发生变化时这里执行一些同input或weights直接相关的代码。但create因为触发位置在网络内，如果```create```函数执行了一些严重耗时的操作，这里会拖慢整个op的执行时间，需要慎重选择操作放置的位置。
### 添加framework的特化
涉及的文件:```framework/operators/mul.h```和```framework/operators/mul.cpp```。
这里简单介绍下如果添加或修改framework内的operator
```
#include "framework/core/base.h"
#include "framework/core/data_types.h"
#include "framework/core/operator/operator.h"
#include "utils/logger/logger.h"
#include "saber/funcs/mul.h" // 需要包对应的saber头文件
namespace anakin {
namespace ops {
template<typename Ttype, DataType Dtype, Precision Ptype>
class MulHelper;
template<typename Ttype, DataType Dtype, Precision Ptype>
class Mul : public Operator<Ttype, Dtype, Ptype> {
public:
Mul() {}
/// forward impl
virtual void operator() (OpContext<Ttype> &ctx,
const std::vector<Tensor4dPtr<Ttype, Dtype> >& ins,
std::vector<Tensor4dPtr<Ttype, Dtype> >& outs) {
LOG(ERROR) << "Not Impl Yet Operator power<TargetType:"<<"unknown"<<","
<<type_id<typename DataTypeWarpper<Dtype>::type>().type_info()<<">";
}
friend class MulHelper<Ttype, Dtype, Ptype>;
};
template<typename Ttype, DataType Dtype, Precision Ptype>
class MulHelper : public OperatorHelper<Ttype, Dtype, Ptype> {
public:
MulHelper() = default;
~MulHelper();
Status InitParam() override;
Status Init(OpContext<Ttype> &ctx,
const std::vector<Tensor4dPtr<Ttype, Dtype> >& ins,
std::vector<Tensor4dPtr<Ttype, Dtype> >& outs) override;
Status InferShape(const std::vector<Tensor4dPtr<Ttype, Dtype> >& ins,
std::vector<Tensor4dPtr<Ttype, Dtype> >& outs) override;
public:
saber::MulParam<Tensor4d<Ttype, Dtype>> _param_mul;
saber::Mul<Ttype, Dtype> _funcs_mul;
};
}
} /* namespace anakin */
```
对应的```.cpp```文件如下：
```
#include "framework/operators/mul.h"
namespace anakin {
namespace ops {
#ifdef USE_CUDA
template<>
void Mul<NV, AK_FLOAT, Precision::FP32>::operator()(
OpContext<NV>& ctx,
const std::vector<Tensor4dPtr<NV, AK_FLOAT> >& ins,
std::vector<Tensor4dPtr<NV, AK_FLOAT> >& outs) {
auto* impl =
static_cast<MulHelper<NV, AK_FLOAT, Precision::FP32>*>(this->_helper);
auto& param =
static_cast<MulHelper<NV, AK_FLOAT, Precision::FP32>*>(this->_helper)->_param_mul;
impl->_funcs_mul(ins, outs, param, ctx);
}
#endif
template<typename Ttype, DataType Dtype, Precision Ptype>
Status MulHelper<Ttype, Dtype, Ptype>::InitParam() {
auto alpha = GET_PARAMETER(float, alpha);
MulParam<Tensor4d<Ttype, Dtype>> param_mul(alpha);
_param_mul = param_mul;
return Status::OK();
}
template<typename Ttype, DataType Dtype, Precision Ptype>
Status MulHelper<Ttype, Dtype, Ptype>::Init(OpContext<Ttype>& ctx,
const std::vector<Tensor4dPtr<Ttype, Dtype> >& ins,
std::vector<Tensor4dPtr<Ttype, Dtype> >& outs) {
SABER_CHECK(_funcs_mul.init(ins, outs, _param_mul, SPECIFY, VENDER_IMPL, ctx));
return Status::OK();
}
template<typename Ttype, DataType Dtype, Precision Ptype>
Status MulHelper<Ttype, Dtype, Ptype>::InferShape(const
std::vector<Tensor4dPtr<Ttype, Dtype> >& ins,
std::vector<Tensor4dPtr<Ttype, Dtype> >& outs) {
SABER_CHECK(_funcs_mul.compute_output_shape(ins, outs, _param_mul));
return Status::OK();
}
#ifdef USE_CUDA
template class MulHelper<NV, AK_FLOAT, Precision::FP32>;
#endif
#ifdef USE_ARM_PLACE
template class MulHelper<ARM, AK_FLOAT, Precision::FP32>;
#endif
// register helper
#ifdef USE_CUDA
ANAKIN_REGISTER_OP_HELPER(Mul, MulHelper, NV, AK_FLOAT, Precision::FP32);
#endif
#ifdef USE_ARM_PLACE
ANAKIN_REGISTER_OP_HELPER(Mul, MulHelper, ARM, AK_FLOAT, Precision::FP32);
#endif
//! register op
ANAKIN_REGISTER_OP(Mul)
.Doc("Mul operator")
#ifdef USE_CUDA
.__alias__<NV, AK_FLOAT, Precision::FP32>("mul")
#endif
#ifdef USE_ARM_PLACE
.__alias__<ARM, AK_FLOAT, Precision::FP32>("mul")
#endif
.num_in(1)
.num_out(1)
.Args<float>("alpha", " alpha of Mul "); //注册
} /* namespace ops */
} /* namespace anakin */
```
## 实现单元测试
涉及的文件:```test/saber/xxx/test_saber_funcs_mul_xxx.cpp```
在对应的test下需要添加新的单元测试
```
TEST(TestSaberFuncNV, test_depthwise_conv) {
// init tensors and some param.
// start Reshape & doInfer
Context<NV> ctx1(0, 1, 1);
// create param
MulParam<Tensor<NV, AK_FLOAT, NCHW> > param(alpha);
std::vector<Tensor<NV, AK_FLOAT, NCHW>*> input;
std::vector<Tensor<NV, AK_FLOAT, NCHW>*> output;
// create saber op
Mul<NV, AK_FLOAT, AK_FLOAT, AK_FLOAT, NCHW> mul;
// compute output shape
mul.compute_output_shape(input, output, param);
// re_alloc output tensors memory based on output shape
output[0]->re_alloc(output[0]->shape());
// init saber op(calling init and create)
mul.init(input, output, param, SPECIFY, VENDER_IMPL, ctx1);
// call operator()
mul(input, output, param, ctx1);
// cuda specified, record events
cudaStream_t cuda_stream = ctx1.get_compute_stream();
output[0]->record_event(cuda_stream);
output_dev.sync();
// param changed
param.alpha = 2.0;
// auto calling saber op(create and dispatch)
mul(input, output, param, ctx1);
cudaDeviceSynchronize();
CUDA_CHECK(cudaPeekAtLastError());
}
int main(int argc, const char** argv){
anakin::saber::Env<NV>::env_init();
// initial logger
//logger::init(argv[0]);
InitTest();
RUN_ALL_TESTS(argv[0]);
return 0;
}
```
## 调试及注意事项
一个op需要有对外的op接口和内部实现，由于存在saber/funcs/impl的非特化版本声明，当有op在某种设备下没有对应实现时，也能够编译，但此时是没有任何实现的空实现，
doc/fluid/advanced_usage/deploy/how_to_support_new_device_in_anakin.md 已删除 100644 → 0
浏览文件 @ 1fe89e8a
# 如何支持一个新的设备
## 概览
添加一个新的设备需要以下3个步骤：
* [在`CMakeList`中添加设备的支持](#0001)
* [在`saber`中添加设备的实现](#0002)
* [在`framework`中添加设备的具体化或实例化](#0003)
假设新设备的名称为`TNEW`, 以下将以这个设备名称进行演示。
## <span id = '0001'> 在`CMakeList`中添加设备的支持 </span> ##
* 修改根目录`CMakeList.txt`
```cmake
#select the plantform to build
anakin_option(USE_GPU_PLACE "Select the build mode for GPU place." NO)
anakin_option(USE_X86_PLACE "Select the build mode for X86 place." NO)
anakin_option(USE_ARM_PLACE "Select the build mode for ARM place." NO)
anakin_option(USE_TNEW_PLACE "Select the build mode for ARM place." YES)
```
* 修改`saber/CMakeList.txt`
根据新增设备的目录完善`saber`目录下的`CMakeList.txt`。
```cmake
if(USE_TNEW_PLACE)
anakin_fetch_files_with_suffix(${ANAKIN_SABER}/core/impl/tnew "cpp" ANAKIN_SABER_BASE_SRC)
anakin_fetch_files_with_suffix(${ANAKIN_SABER}/funcs/impl/tnew "cpp" ANAKIN_SABER_BASE_SRC)
endif()
```
* 修改`test/CMakeList.txt`
新增设备的单测文件放在`test/saber/tnew`目录下，修改`test`目录下的`CMakeList.txt`。
```cmake
if(USE_TNEW_PLACE)
anakin_fetch_files_with_suffix(${ANAKIN_UNIT_TEST}/saber/tnew "cpp" ANAKIN_TEST_CASE_SRC)
endif()
```
* 修改`cmake/anakin_config.h.in`
```c++
// plantform to use
#cmakedefine USE_GPU_PLACE
#cmakedefine USE_X86_PLACE
#cmakedefine USE_ARM_PLACE
#cmakedefine USE_TNEW_PLACE
```
* 其他依赖和编译选项
修改`cmake`目录下的`compiler_options.cmake`和`find_modules.cmake`
## <span id = '0002'> 在`saber`中添加设备的实现 </span> ##
`saber`是`Anakin`的基础计算库，对外提供设备无关的统一的API，设备相关的实现都会封装到`TargetWrapper`中。
### 在`saber/saber_types.h`中添加设备
```c++
enum TargetTypeEnum {
eINVALID = -1,
eNV = 1,
eAMD = 2,
eARM = 3,
eX86 = 4,
eNVHX86 = 5,
eTNEW = 6
};
typedef TargetType<eNV> NV;
typedef TargetType<eARM> ARM;
typedef TargetType<eAMD> AMD;
typedef TargetType<eX86> X86;
typedef TargetType<eTNEW> TNEW;
```
### 在`saber/core`中添加设备的实现
1. 在`target_traits.h`中添加新设备
* 增加设备类型
```c++
struct __cuda_device{};
struct __arm_device{};
struct __amd_device{};
struct __x86_device{};
struct __tnew_device{};
```
* `TargetTypeTraits`模板具体化
```c++
template <>
struct TargetTypeTraits<TNEW> {
typedef __xxx_target target_category;//根据实际设备是host端还是device端进行选择
typedef __tnew_device target_type;
};
```
2. 在`data_traits.h`中特化`DataTrait`模板类
如果设备需要特殊的数据类型，则特化出设备的`DataTrait`类的实现，例如opencl数据类型的实现如下：
```c++
#ifdef USE_OPENCL
struct ClMem{
ClMem(){
dmem = nullptr;
offset = 0;
}
ClMem(cl_mem* mem_in, int offset_in = 0) {
dmem = mem_in;
offset = offset_in;
}
ClMem(ClMem& right) {
dmem = right.dmem;
offset = right.offset;
}
ClMem& operator=(ClMem& right) {
this->dmem = right.dmem;
this->offset = right.offset;
return *this;
}
ClMem& operator+(int offset_in) {
this->offset += offset_in;
return *this;
}
int offset{0};
cl_mem* dmem;
};
template <>
struct DataTrait<AMD, AK_FLOAT> {
typedef ClMem Dtype;
typedef float dtype;
};
template <>
struct DataTrait<AMD, AK_DOUBLE> {
typedef ClMem Dtype;
typedef double dtype;
};
template <>
struct DataTrait<AMD, AK_INT8> {
typedef ClMem Dtype;
typedef char dtype;
};
#endif //use_opencl
```
3. 在`target_wrapper.h`中特化`TargetWrapper`模板类
特化`TargetWrapper`模板类，在`target_wrapper.h`中声明函数，具体如下：
```c++
template <>
struct TargetWrapper<TNEW, __xxx_target> { //根据TNEW的具体类型修改__xxx_target，__host_target或者__device_target
typedef xxx_event event_t; //根据设备实现xxx_event
typedef xxx_stream stream_t; //根据设备实现xxx_stream
static void get_device_count(int& count);
static void set_device(int id);
//We should add strategy to avoid malloc directly
static void mem_alloc(void** ptr, size_t n);
static void mem_free(void* ptr);
static void mem_set(void* ptr, int value, size_t n);
static void create_event(event_t& event, bool flag = false);
static void create_stream(stream_t& stream);
static void create_stream_with_flag(stream_t& stream, unsigned int flag);
static void create_stream_with_priority(stream_t& stream, unsigned int flag, int priority);
static void destroy_stream(stream_t& stream);
static void destroy_event(event_t& event);
static void record_event(event_t& event, stream_t stream);
static void query_event(event_t& event);
static void sync_event(event_t& event);
static void sync_stream(event_t& event, stream_t& stream);
static void sync_memcpy(void* dst, int dst_id, const void* src, int src_id, \
size_t count, __DtoD);
static void async_memcpy(void* dst, int dst_id, const void* src, int src_id, \
size_t count, stream_t& stream, __DtoD);
static void sync_memcpy(void* dst, int dst_id, const void* src, int src_id, \
size_t count, __HtoD);
static void async_memcpy(void* dst, int dst_id, const void* src, int src_id, \
size_t count, stream_t& stream, __HtoD);
static void sync_memcpy(void* dst, int dst_id, const void* src, int src_id, \
size_t count, __DtoH);
static void async_memcpy(void* dst, int dst_id, const void* src, int src_id, \
size_t count, stream_t& stream, __DtoH);
static void sync_memcpy_p2p(void* dst, int dst_dev, const void* src, \
int src_dev, size_t count);
static void async_memcpy_p2p(void* dst, int dst_dev, const void* src, \
int src_dev, size_t count, stream_t& stream);
static int get_device_id();
};
```
4. 在`impl/`目录下添加设备目录和实现
在`saber/core/impl`目录下添加设备目录`tnew`。
* 实现`TargetWrapper<TNEW, __xxx_target>`结构体中各函数的定义。
如果`TargetWrapper<TNEW, __xxx_target>`的实现与默认的模板类一致，则不用特化出该类。
```c++
typedef TargetWrapper<TNEW, __xxx_target> TNEW_API;
void TNEW_API::get_device_count(int &count) {
// add implementation
}
void TNEW_API::set_device(int id){
// add implementation
}
void TNEW_API::mem_alloc(void** ptr, size_t n){
// add implementation
}
void TNEW_API::mem_free(void* ptr){
if(ptr != nullptr){
// add implementation
}
}
...
```
* 特化实现`device.h`中的`Device<TNEW>`
```c++
template <>
void Device<TNEW>::create_stream() {
// add implementation
}
template <>
void Device<TNEW>::get_info() {
// add implementation
}
```
### 在`saber/funcs`中实现设备相关的op
参考[如何增加新的Operator](addCustomOp.md)
## <span id = '0003'> 在`framework`中添加设备的具体化或实例化 </span> ##
### `framework/core`
* `net.cpp`中添加实例化
```c++
#ifdef USE_TNEW_PLACE
template class Net<TNEW, AK_FLOAT, Precision::FP32, OpRunType::ASYNC>;
template class Net<TNEW, AK_FLOAT, Precision::FP32, OpRunType::SYNC>;
#endif
```
* `operator_func.cpp`中添加实例化
```c++
#ifdef USE_TNEW_PLACE
template class OperatorFunc<TNEW, AK_FLOAT, Precision::FP32>;
#endif
```
* `worker.cpp`中添加实例化
```c++
#ifdef USE_TNEW_PLACE
template class Worker<TNEW, AK_FLOAT, Precision::FP32, OpRunType::ASYNC>;
template class Worker<TNEW, AK_FLOAT, Precision::FP32, OpRunType::SYNC>;
#endif
```
* `operator_attr.cpp`中添加实例化
```c++
template
OpAttrWarpper& OpAttrWarpper::__alias__<TNEW, AK_FLOAT, Precision::FP32>(const std::string& op_name);
template
OpAttrWarpper& OpAttrWarpper::__alias__<TNEW, AK_FLOAT, Precision::FP16>(const std::string& op_name);
template
OpAttrWarpper& OpAttrWarpper::__alias__<TNEW, AK_FLOAT, Precision::INT8>(const std::string& op_name);
```
* `parameter.h`中添加设备的实现
```c++
#ifdef USE_TNEW_PLACE
template<typename Dtype>
class PBlock<Dtype, TNEW> {
public:
typedef Tensor4d<TNEW, DataTypeRecover<Dtype>::type> type;
PBlock() {
_inner_tensor = std::make_shared<type>();
}
...
}
#endif //TNEW
```
* `type_traits_extend.h`中添加设备的实现
```c++
template<>
struct target_host<saber::TNEW> {
typedef saber::X86 type; //根据TNEW选择正确的host type
};
```
### `framework/graph`
* `graph.cpp`中添加实例化
```c++
#ifdef USE_TNEW_PLACE
template class Graph<TNEW, AK_FLOAT, Precision::FP32>;
template class Graph<TNEW, AK_FLOAT, Precision::FP16>;
template class Graph<TNEW, AK_FLOAT, Precision::INT8>;
#endif
```
### `framework/model_parser`
* `parser.cpp`中添加实例化
```c++
#ifdef USE_TNEW_PLACE
template
Status load<TNEW, AK_FLOAT, Precision::FP32>(graph::Graph<TNEW, AK_FLOAT, Precision::FP32>* graph,
const char* model_path);
template
Status load<TNEW, AK_FLOAT, Precision::FP16>(graph::Graph<TNEW, AK_FLOAT, Precision::FP16>* graph,
const char* model_path);
template
Status load<TNEW, AK_FLOAT, Precision::INT8>(graph::Graph<TNEW, AK_FLOAT, Precision::INT8>* graph,
const char* model_path);
template
Status save<TNEW, AK_FLOAT, Precision::FP32>(graph::Graph<TNEW, AK_FLOAT, Precision::FP32>* graph,
std::string& model_path);
template
Status save<TNEW, AK_FLOAT, Precision::FP16>(graph::Graph<TNEW, AK_FLOAT, Precision::FP16>* graph,
std::string& model_path);
template
Status save<TNEW, AK_FLOAT, Precision::INT8>(graph::Graph<TNEW, AK_FLOAT, Precision::INT8>* graph,
std::string& model_path);
template
Status load<TNEW, AK_FLOAT, Precision::FP32>(graph::Graph<TNEW, AK_FLOAT, Precision::FP32>* graph,
std::string& model_path);
template
Status load<TNEW, AK_FLOAT, Precision::FP16>(graph::Graph<TNEW, AK_FLOAT, Precision::FP16>* graph,
std::string& model_path);
template
Status load<TNEW, AK_FLOAT, Precision::INT8>(graph::Graph<TNEW, AK_FLOAT, Precision::INT8>* graph,
std::string& model_path);
template
Status save<TNEW, AK_FLOAT, Precision::FP32>(graph::Graph<TNEW, AK_FLOAT, Precision::FP32>* graph,
const char* model_path);
template
Status save<TNEW, AK_FLOAT, Precision::FP16>(graph::Graph<TNEW, AK_FLOAT, Precision::FP16>* graph,
const char* model_path);
template
Status save<TNEW, AK_FLOAT, Precision::INT8>(graph::Graph<TNEW, AK_FLOAT, Precision::INT8>* graph,
const char* model_path);
#endif
```
* `model_io.cpp`中添加实例化
```c++
#ifdef USE_TNEW_PLACE
template class NodeIO<TNEW, AK_FLOAT, Precision::FP32>;
template class NodeIO<TNEW, AK_FLOAT, Precision::FP16>;
template class NodeIO<TNEW, AK_FLOAT, Precision::INT8>;
#endif
```
### `framework/operators`
为`framework/operators`目录下所有op添加实例化或具体化
以`activation.cpp`为例，实例化如下：
```c++
#ifdef USE_TNEW_PLACE
INSTANCE_ACTIVATION(TNEW, AK_FLOAT, Precision::FP32);
INSTANCE_ACTIVATION(TNEW, AK_FLOAT, Precision::FP16);
INSTANCE_ACTIVATION(TNEW, AK_FLOAT, Precision::INT8);
template class ActivationHelper<TNEW, AK_FLOAT, Precision::FP32>;
ANAKIN_REGISTER_OP_HELPER(Activation, ActivationHelper, TNEW, AK_FLOAT, Precision::FP32);
#endif
```
如果TNEW设备函数的实现与现有模板实现不一致，可以特化实现如下（以init()为例）：
```c++
#ifdef USE_TNEW_PLACE
INSTANCE_ACTIVATION(TNEW, AK_FLOAT, Precision::FP32);
INSTANCE_ACTIVATION(TNEW, AK_FLOAT, Precision::FP16);
INSTANCE_ACTIVATION(TNEW, AK_FLOAT, Precision::INT8);
template <>
Status ActivationHelper<TNEW, AK_FLOAT, Precision::FP32>::Init(OpContext<TNEW> &ctx,\
const std::vector<Tensor4dPtr<TNEW, AK_FLOAT> >& ins, \
std::vector<Tensor4dPtr<TNEW, AK_FLOAT> >& outs) {
SABER_CHECK(_funcs_activation.init(ins, outs, _param_activation, SPECIFY, SABER_IMPL, ctx)); //在这里选择实现方式
return Status::OK();
}
ANAKIN_REGISTER_OP_HELPER(Activation, ActivationHelper, TNEW, AK_FLOAT, Precision::FP32);
#endif
```
在`ANAKIN_REGISTER_OP(Activation)`中添加TNEW的注册
```c++
#ifdef USE_TNEW_PLACE
.__alias__<TNEW, AK_FLOAT, Precision::FP32>("activation")
#endif
```
## 注意事项
不要修改`Tensor`/`Buffer`/`Env`/`Context`这些类函数的接口和实现
doc/fluid/advanced_usage/deploy/index_anakin.rst 已删除 100644 → 0
浏览文件 @ 1fe89e8a
服务器端部署 - Anakin
#######################
使用文档
~~~~~~~
.. toctree::
:maxdepth: 1
install_anakin.md
convert_paddle_to_anakin.md
run_anakin_on_arm.md
anakin_tutorial.md
anakin_example.md
anakin_gpu_benchmark.md
anakin_arm_benchmark.md
开发文档
~~~~~~~
.. toctree::
:maxdepth: 1
how_to_add_anakin_op.md
how_to_support_new_device_in_anakin.md
doc/fluid/advanced_usage/deploy/index_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
########
预测部署
########
- `服务器端部署 <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_en.rst 0 → 100644
浏览文件 @ 2b2d0133
#######################
Deploy Inference Model
#######################
- `Server side Deployment <inference/index_en.html>`_ : This section illustrates Fluid C++ API to support deployment and release of trained models.
- `Paddle Mobile <mobile/index_en.html>`_ : Embedded deep learning framework Paddle-Mobile organized by PaddlePaddle.
.. toctree::
:hidden:
inference/index_en.rst
mobile/index_en.rst
doc/fluid/advanced_usage/deploy/index_mobile.rst 已删除 100644 → 0
浏览文件 @ 1fe89e8a
移动端部署
##########
.. toctree::
:maxdepth: 2
mobile_readme.md
mobile_build.md
mobile_dev.md
doc/fluid/advanced_usage/deploy/inference/build_and_install_lib_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
.. _install_or_build_cpp_inference_lib:
安装与编译C++预测库
===========================
直接下载安装
-------------
.. csv-table:: c++预测库列表
:header: "版本说明", "预测库(1.5.1版本)", "预测库(develop版本)"
:widths: 1, 3, 3
"cpu_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.5.1-cpu-avx-mkl/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-avx-mkl/fluid_inference.tgz>`_"
"cpu_avx_openblas", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.5.1-cpu-avx-openblas/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-avx-openblas/fluid_inference.tgz>`_"
"cpu_noavx_openblas", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.5.1-cpu-noavx-openblas/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-noavx-openblas/fluid_inference.tgz>`_"
"cuda8.0_cudnn7_avx_openblas", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.5.1-gpu-cuda8-cudnn7-avx-openblas/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-gpu-cuda8-cudnn7-avx-openblas/fluid_inference.tgz>`_"
"cuda8.0_cudnn7_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.5.1-gpu-cuda8-cudnn7-avx-mkl/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-gpu-cuda8-cudnn7-avx-mkl/fluid_inference.tgz>`_"
"cuda9.0_cudnn7_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.5.1-gpu-cuda9-cudnn7-avx-mkl/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-gpu-cuda9-cudnn7-avx-mkl/fluid_inference.tgz>`_"
"cuda10.0_cudnn7_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.5.1-gpu-cuda10-cudnn7-avx-mkl/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-gpu-cuda10-cudnn7-avx-mkl/fluid_inference.tgz>`_"
从源码编译
----------
用户也可以从 PaddlePaddle 核心代码编译C++预测库，只需在编译时配制下面这些编译选项：
============================ =========
选项 值
============================ =========
CMAKE_BUILD_TYPE Release
FLUID_INFERENCE_INSTALL_DIR 安装路径
WITH_PYTHON OFF（推荐）
ON_INFER ON（推荐）
WITH_GPU ON/OFF
WITH_MKL ON/OFF
============================ =========
建议按照推荐值设置，以避免链接不必要的库。其它可选编译选项按需进行设定。
下面的代码片段从github拉取最新代码，配制编译选项（需要将PADDLE_ROOT替换为PaddlePaddle预测库的安装路径）：
.. code-block:: bash
PADDLE_ROOT=/path/of/capi
git clone https://github.com/PaddlePaddle/Paddle.git
cd Paddle
mkdir build
cd build
cmake -DFLUID_INFERENCE_INSTALL_DIR=$PADDLE_ROOT \
-DCMAKE_BUILD_TYPE=Release \
-DWITH_PYTHON=OFF \
-DWITH_MKL=OFF \
-DWITH_GPU=OFF \
-DON_INFER=ON \
..
make
make inference_lib_dist
成功编译后，使用C++预测库所需的依赖（包括：（1）编译出的PaddlePaddle预测库和头文件；（2）第三方链接库和头文件；（3）版本信息与编译选项信息）
均会存放于PADDLE_ROOT目录中。目录结构如下：
.. code-block:: text
PaddleRoot/
├── CMakeCache.txt
├── paddle
│   ├── include
│   │   ├── paddle_anakin_config.h
│   │   ├── paddle_analysis_config.h
│   │   ├── paddle_api.h
│   │   ├── paddle_inference_api.h
│   │   ├── paddle_mkldnn_quantizer_config.h
│   │   └── paddle_pass_builder.h
│   └── lib
│   ├── libpaddle_fluid.a
│   └── libpaddle_fluid.so
├── third_party
│   ├── boost
│   │   └── boost
│   ├── eigen3
│   │   ├── Eigen
│   │   └── unsupported
│   └── install
│   ├── gflags
│   ├── glog
│   ├── mkldnn
│   ├── mklml
│   ├── protobuf
│   ├── snappy
│   ├── snappystream
│   ├── xxhash
│   └── zlib
└── version.txt
version.txt 中记录了该预测库的版本信息，包括Git Commit ID、使用OpenBlas或MKL数学库、CUDA/CUDNN版本号，如：
.. code-block:: text
GIT COMMIT ID: cc9028b90ef50a825a722c55e5fda4b7cd26b0d6
WITH_MKL: ON
WITH_MKLDNN: ON
WITH_GPU: ON
CUDA version: 8.0
CUDNN version: v7
doc/fluid/advanced_usage/deploy/inference/build_and_install_lib_en.rst 0 → 100644
浏览文件 @ 2b2d0133
.. _install_or_build_cpp_inference_lib_en:
Install and Compile C++ Inference Library
=============================================
Direct Download and Installation
---------------------------------
.. csv-table:: c++ inference library list
:header: "version description", "inference library(1.5.1 version)", "inference library(develop version)"
:widths: 1, 3, 3
"cpu_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.5.1-cpu-avx-mkl/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-avx-mkl/fluid_inference.tgz>`_"
"cpu_avx_openblas", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.5.1-cpu-avx-openblas/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-avx-openblas/fluid_inference.tgz>`_"
"cpu_noavx_openblas", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.5.1-cpu-noavx-openblas/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-noavx-openblas/fluid_inference.tgz>`_"
"cuda8.0_cudnn7_avx_openblas", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.5.1-gpu-cuda8-cudnn7-avx-openblas/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-gpu-cuda8-cudnn7-avx-openblas/fluid_inference.tgz>`_"
"cuda8.0_cudnn7_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.5.1-gpu-cuda8-cudnn7-avx-mkl/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-gpu-cuda8-cudnn7-avx-mkl/fluid_inference.tgz>`_"
"cuda9.0_cudnn7_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.5.1-gpu-cuda9-cudnn7-avx-mkl/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-gpu-cuda9-cudnn7-avx-mkl/fluid_inference.tgz>`_"
"cuda10.0_cudnn7_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.5.1-gpu-cuda10-cudnn7-avx-mkl/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-gpu-cuda10-cudnn7-avx-mkl/fluid_inference.tgz>`_"
Build from Source Code
-----------------------
Users can also compile C++ inference libraries from the PaddlePaddle core code by specifying the following compile options at compile time:
============================ ======================
Option Value
============================ ======================
CMAKE_BUILD_TYPE Release
FLUID_INFERENCE_INSTALL_DIR Path of installation
WITH_PYTHON OFF（recommended）
ON_INFER ON（recommended）
WITH_GPU ON/OFF
WITH_MKL ON/OFF
============================ ======================
It is recommended to configure options according to the recommended values to avoid the link to unnecessary library. Other options can be set if it is necessary.
The following code snippet pulls the latest code from github and specifies the compiling options (you need to replace PADDLE_ROOT with the installation path of the PaddlePaddle inference library):
.. code-block:: bash
PADDLE_ROOT=/path/of/capi
git clone https://github.com/PaddlePaddle/Paddle.git
cd Paddle
mkdir build
cd build
cmake -DFLUID_INFERENCE_INSTALL_DIR=$PADDLE_ROOT \
-DCMAKE_BUILD_TYPE=Release \
-DWITH_PYTHON=OFF \
-DWITH_MKL=OFF \
-DWITH_GPU=OFF \
-DON_INFER=ON \
..
make
make inference_lib_dist
After successful compilation, dependencies required by the C++ inference library Will be stored in the PADDLE_ROOT directory. (dependencies including: (1) compiled PaddlePaddle inference library and header files; (2) third-party link libraries and header files; (3) version information and compilation option information)
The directory structure is:
.. code-block:: text
PaddleRoot/
├── CMakeCache.txt
├── paddle
│ ├── include
│ │ ├── paddle_anakin_config.h
│ │ ├── paddle_analysis_config.h
│ │ ├── paddle_api.h
│ │ ├── paddle_inference_api.h
│   │   ├── paddle_mkldnn_quantizer_config.h
│ │ └── paddle_pass_builder.h
│ └── lib
│ ├── libpaddle_fluid.a
│ └── libpaddle_fluid.so
├── third_party
│ ├── boost
│ │ └── boost
│ ├── eigen3
│ │ ├── Eigen
│ │ └── unsupported
│ └── install
│ ├── gflags
│ ├── glog
│ ├── mkldnn
│ ├── mklml
│ ├── protobuf
│ ├── snappy
│ ├── snappystream
│ ├── xxhash
│ └── zlib
└── version.txt
The version information of the inference library is recorded in version.txt, including Git Commit ID, version of OpenBlas, MKL math library, or CUDA/CUDNN. For example:
.. code-block:: text
GIT COMMIT ID: cc9028b90ef50a825a722c55e5fda4b7cd26b0d6
WITH_MKL: ON
WITH_MKLDNN: ON
WITH_GPU: ON
CUDA version: 8.0
CUDNN version: v7
doc/fluid/advanced_usage/deploy/inference/index_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
############
服务器端部署
############
PaddlePaddle Fluid 提供了 C++ API 来支持模型的部署上线
.. toctree::
:titlesonly:
build_and_install_lib_cn.rst
native_infer.md
python_infer_cn.md
paddle_tensorrt_infer.md
paddle_gpu_benchmark.md
windows_cpp_inference.md
doc/fluid/advanced_usage/deploy/inference/index_en.rst 0 → 100644
浏览文件 @ 2b2d0133
######################
Server-side Deployment
######################
PaddlePaddle Fluid provides C++ API to support deployment and release of trained models.
.. toctree::
:titlesonly:
build_and_install_lib_en.rst
native_infer_en.md
paddle_tensorrt_infer_en.md
paddle_gpu_benchmark_en.md
windows_cpp_inference_en.md
doc/fluid/advanced_usage/deploy/inference/native_infer.md 0 → 100644
浏览文件 @ 2b2d0133
# C++ 预测 API介绍
为了更简单方便的预测部署，PaddlePaddle 提供了一套高层 API 预测接口。
预测库包含:
- 头文件主要包括：
- `paddle_analysis_config.h `
- `paddle_api.h `
- `paddle_inference_api.h`
- 库文件：
- `libpaddle_fluid.so`
- `libpaddle_fluid.a`
下面是详细介绍。
## 内容
- [NativePredictor使用](#NativePredictor使用)
- [AnalysisPredictor使用](#AnalysisPredictor使用)
- [输入输出的管理](#输入输出的管理)
- [多线程预测](#多线程预测)
- [性能建议](#性能建议)
## <a name="NativePredictor使用">NativePredictor使用</a>
`NativePredictor`为原生预测引擎，底层由 PaddlePaddle 原生的 forward operator
组成，可以天然**支持所有Paddle 训练出的模型**。
#### NativePredictor 使用样例
```c++
#include "paddle_inference_api.h"
namespace paddle {
// 配置NativeConfig
void CreateConfig(NativeConfig *config, const std::string& model_dirname) {
config->use_gpu=true;
config->device=0;
config->fraction_of_gpu_memory=0.1;
/* for cpu
config->use_gpu=false;
config->SetCpuMathLibraryNumThreads(1);
*/
// 设置模型的参数路径
config->prog_file = model_dirname + "model";
config->param_file = model_dirname + "params";
// 当模型输入是多个的时候，这个配置是必要的。
config->specify_input_name = true;
}
void RunNative(int batch_size, const std::string& model_dirname) {
// 1. 创建NativeConfig
NativeConfig config;
CreateConfig(&config, model_dirname);
// 2. 根据config 创建predictor
auto predictor = CreatePaddlePredictor(config);
int channels = 3;
int height = 224;
int width = 224;
float *data = new float[batch_size * channels * height * width];
// 3. 创建输入 tensor
PaddleTensor tensor;
tensor.name = "image";
tensor.shape = std::vector<int>({batch_size, channels, height, width});
tensor.data = PaddleBuf(static_cast<void *>(data),
sizeof(float) * (batch_size * channels * height * width));
tensor.dtype = PaddleDType::FLOAT32;
std::vector<PaddleTensor> paddle_tensor_feeds(1, tensor);
// 4. 创建输出 tensor
std::vector<PaddleTensor> outputs;
// 5. 预测
predictor->Run(paddle_tensor_feeds, &outputs, batch_size);
const size_t num_elements = outputs.front().data.length() / sizeof(float);
auto *data_out = static_cast<float *>(outputs.front().data.data());
}
} // namespace paddle
int main() {
// 模型下载地址 http://paddle-inference-dist.cdn.bcebos.com/tensorrt_test/mobilenet.tar.gz
paddle::RunNative(1, "./mobilenet");
return 0;
}
```
## <a name="AnalysisPredictor使用"> AnalysisPredictor使用</a>
AnalysisConfig 创建了一个高性能预测引擎。该引擎通过对计算图的分析，完成对计算图的一系列的优化（Op 的融合, MKLDNN，TRT等底层加速库的支持 etc），大大提升预测引擎的性能。
#### AnalysisPredictor 使用样例
```c++
#include "paddle_inference_api.h"
namespace paddle {
void CreateConfig(AnalysisConfig* config, const std::string& model_dirname) {
// 模型从磁盘进行加载
config->SetModel(model_dirname + "/model",
model_dirname + "/params");
// config->SetModel(model_dirname);
// 如果模型从内存中加载，可以使用SetModelBuffer接口
// config->SetModelBuffer(prog_buffer, prog_size, params_buffer, params_size);
config->EnableUseGpu(10 /*the initial size of the GPU memory pool in MB*/, 0 /*gpu_id*/);
/* for cpu
config->DisableGpu();
config->EnableMKLDNN(); // 可选
config->SetCpuMathLibraryNumThreads(10);
*/
// 当使用ZeroCopyTensor的时候，此处一定要设置为false。
config->SwitchUseFeedFetchOps(false);
// 当多输入的时候，此处一定要设置为true
config->SwitchSpecifyInputNames(true);
config->SwitchIrDebug(true); // 开关打开，会在每个图优化过程后生成dot文件，方便可视化。
// config->SwitchIrOptim(false); // 默认为true。如果设置为false，关闭所有优化，执行过程同 NativePredictor
// config->EnableMemoryOptim(); // 开启内存/显存复用
}
void RunAnalysis(int batch_size, std::string model_dirname) {
// 1. 创建AnalysisConfig
AnalysisConfig config;
CreateConfig(&config, model_dirname);
// 2. 根据config 创建predictor
auto predictor = CreatePaddlePredictor(config);
int channels = 3;
int height = 224;
int width = 224;
float input[batch_size * channels * height * width] = {0};
// 3. 创建输入
// 同NativePredictor样例一样，此处可以使用PaddleTensor来创建输入
// 以下的代码中使用了ZeroCopy的接口，同使用PaddleTensor不同的是：此接口可以避免预测中多余的cpu copy，提升预测性能。
auto input_names = predictor->GetInputNames();
auto input_t = predictor->GetInputTensor(input_names[0]);
input_t->Reshape({batch_size, channels, height, width});
input_t->copy_from_cpu(input);
// 4. 运行
CHECK(predictor->ZeroCopyRun());
// 5. 获取输出
std::vector<float> out_data;
auto output_names = predictor->GetOutputNames();
auto output_t = predictor->GetOutputTensor(output_names[0]);
std::vector<int> output_shape = output_t->shape();
int out_num = std::accumulate(output_shape.begin(), output_shape.end(), 1, std::multiplies<int>());
out_data.resize(out_num);
output_t->copy_to_cpu(out_data.data());
}
} // namespace paddle
int main() {
// 模型下载地址 http://paddle-inference-dist.cdn.bcebos.com/tensorrt_test/mobilenet.tar.gz
paddle::RunAnalysis(1, "./mobilenet");
return 0;
}
```
## <a name="输入输出的管理"> 输入输出的管理</a>
### PaddleTensor 的使用
PaddleTensor可用于NativePredictor和AnalysisPredictor，在 NativePredictor样例中展示了PaddleTensor的使用方式。
PaddleTensor 定义了预测最基本的输入输出的数据格式，常用字段如下：
- `name`，类型：string，用于指定输入数据对应的模型中variable的名字
- `shape`，类型：`vector<int>`, 表示一个Tensor的shape
- `data`，类型：`PaddleBuf`, 数据以连续内存的方式存储在`PaddleBuf`中，`PaddleBuf`可以接收外面的数据或者独立`malloc`内存，详细可以参考头文件中相关定义。
- `dtype`，类型：`PaddleType`, 有`PaddleDtype::FLOAT32`, `PaddleDtype::INT64`, `PaddleDtype::INT32`三种, 表示 Tensor 的数据类型。
- `lod`，类型：`vector<vector<size_t>>`，在处理变长输入的时候，需要对 `PaddleTensor`设置LoD信息。可以参考[LoD-Tensor使用说明](../../../user_guides/howto/basic_concept/lod_tensor.html)
### ZeroCopyTensor的使用
ZeroCopyTensor的使用可避免预测时候准备输入以及获取输出时多余的数据copy，提高预测性能。**只可用于AnalysisPredictor**。
**Note:**使用ZeroCopyTensor，务必在创建config时设置`config->SwitchUseFeedFetchOps(false)`
```
// 通过创建的AnalysisPredictor获取输入和输出的tensor
auto input_names = predictor->GetInputNames();
auto input_t = predictor->GetInputTensor(input_names[0]);
auto output_names = predictor->GetOutputNames();
auto output_t = predictor->GetOutputTensor(output_names[0]);
// 对tensor进行reshape
input_t->Reshape({batch_size, channels, height, width});
// 通过copy_from_cpu接口，将cpu数据输入；通过copy_to_cpu接口，将输出数据copy到cpu
input_t->copy_from_cpu<float>(input_data /*数据指针*/);
output_t->copy_to_cpu(out_data /*数据指针*/);
// 设置LOD
std::vector<std::vector<size_t>> lod_data = {{0}, {0}};
input_t->SetLoD(lod_data);
// 获取tensor数据指针
float *input_d = input_t->mutable_data<float>(PaddlePlace::kGPU); // CPU下使用PaddlePlace::kCPU
int output_size;
float *output_d = output_t->data<float>(PaddlePlace::kGPU, &output_size);
```
## <a name="多线程预测"> 多线程预测</a>
多线程场景下，每个服务线程执行同一种模型，支持 CPU 和 GPU。
下面演示最简单的实现，用户需要根据具体应用场景做相应的调整
```c++
auto main_predictor = paddle::CreatePaddlePredictor(config);
const int num_threads = 10; // 假设有 10 个服务线程
std::vector<std::thread> threads;
std::vector<decl_type(main_predictor)> predictors;
// 将克隆的 predictor 放入 vector 供线程使用
for (int i = 0; i < num_threads; i++) {
predictors.emplace_back(main_predictor->Clone());
}
// 创建线程并执行
for (int i = 0; i < num_threads; i++) {
threads.emplace_back([i, &]{
auto& predictor = predictors[i];
// 执行
CHECK(predictor->Run(...));
});
}
// 线程join
for (auto& t : threads) {
if (t.joinable()) t.join();
}
// 结束
```
## <a name="性能建议"> 性能建议</a>
1. 在CPU型号允许的情况下，尽量使用带AVX和MKL的版本
2. CPU或GPU预测，可以尝试把`NativeConfig`改成`AnalysisConfig`来进行优化
3. 尽量使用`ZeroCopyTensor`避免过多的内存copy
4. CPU下可以尝试使用Intel的`MKLDNN`加速
5. GPU 下可以尝试打开`TensorRT`子图加速引擎, 通过计算图分析，Paddle可以自动将计算图中部分子图切割，并调用NVidia的 `TensorRT` 来进行加速。
详细内容可以参考 [Paddle-TRT 子图引擎](./paddle_tensorrt_infer.html)
doc/fluid/advanced_usage/deploy/inference/native_infer_en.md 0 → 100644
浏览文件 @ 2b2d0133
# Introduction to C++ Inference API
To make the deployment of inference model more convenient, a set of high-level APIs are provided in Fluid to hide diverse optimization processes in low level.
Inference library contains:
- header file `paddle_inference_api.h` which defines all interfaces
- library file `libpaddle_fluid.so` or `libpaddle_fluid.a`
Details are as follows:
## PaddleTensor
PaddleTensor defines basic format of input and output data for inference. Common fields are as follows:
- `name` is used to indicate the name of variable in model correspondent with input data.
- `shape` represents the shape of a Tensor.
- `data` is stored in `PaddleBuf` in method of consecutive storage. `PaddleBuf` can receieve outer data or independently `malloc` memory. You can refer to associated definitions in head file.
- `dtype` represents data type of Tensor.
## Use Config to create different engines
The low level of high-level API contains various optimization methods which are called engines. Switch between different engines is done by transferring different Config.
- `NativeConfig` native engine, consisting of native forward operators of paddle, can naturally support all models trained by paddle.
- `AnalysisConfig` TensorRT mixed engine. It is used to speed up GPU and supports [TensorRT] with subgraph. Moreover, this engine supports all paddle models and automatically slices part of computing subgraphs to TensorRT to speed up the process (WIP). For specific usage, please refer to [here](http://paddlepaddle.org/documentation/docs/zh/1.1/user_guides/howto/inference/paddle_tensorrt_infer.html).
## Process of Inference Deployment
In general, the steps are:
1. Use appropriate configuration to create `PaddlePredictor`
2. Create `PaddleTensor` for input and transfer it into `PaddlePredictor`
3. `PaddleTensor` for fetching output
The complete process of implementing a simple model is shown below with part of details omitted.
```c++
#include "paddle_inference_api.h"
// create a config and modify associated options
paddle::NativeConfig config;
config.model_dir = "xxx";
config.use_gpu = false;
// create a native PaddlePredictor
auto predictor =
paddle::CreatePaddlePredictor<paddle::NativeConfig>(config);
// create input tensor
int64_t data[4] = {1, 2, 3, 4};
paddle::PaddleTensor tensor;
tensor.shape = std::vector<int>({4, 1});
tensor.data.Reset(data, sizeof(data));
tensor.dtype = paddle::PaddleDType::INT64;
// create output tensor whose memory is reusable
std::vector<paddle::PaddleTensor> outputs;
// run inference
CHECK(predictor->Run(slots, &outputs));
// fetch outputs ...
```
At compile time, it is proper to co-build with `libpaddle_fluid.a/.so` .
## Adavanced Usage
### memory management of input and output
`data` field of `PaddleTensor` is a `PaddleBuf`, used to manage a section of memory for copying data.
There are two modes in term of memory management in `PaddleBuf` :
1. Automatic allocation and manage memory
```c++
int some_size = 1024;
PaddleTensor tensor;
tensor.data.Resize(some_size);
```
2. Transfer outer memory
```c++
int some_size = 1024;
// You can allocate outside memory and keep it available during the usage of PaddleTensor
void* memory = new char[some_size];
tensor.data.Reset(memory, some_size);
// ...
// You need to release memory manually to avoid memory leak
delete[] memory;
```
In the two modes, the first is more convenient while the second strictly controls memory management to facilitate integration with `tcmalloc` and other libraries.
### Upgrade performance based on contrib::AnalysisConfig
AnalyisConfig is at the stage of pre-release and protected by `namespace contrib` , which may be adjusted in the future.
Similar to `NativeConfig` , `AnalysisConfig` can create a inference engine with high performance after a series of optimization, including analysis and optimization of computing graph as well as integration and revise for some important Ops, which **largely promotes the peformance of models, such as While, LSTM, GRU** .
The usage of `AnalysisConfig` is similiar with that of `NativeConfig` but the former *only supports CPU at present and is supporting GPU more and more*.
```c++
AnalysisConfig config;
config.SetModel(dirname); // set the directory of the model
config.EnableUseGpu(100, 0 /*gpu id*/); // use GPU,or
config.DisableGpu(); // use CPU
config.SwitchSpecifyInputNames(true); // need to appoint the name of your input
config.SwitchIrOptim(); // turn on the optimization switch,and a sequence of optimizations will be executed in operation
```
Note that input PaddleTensor needs to be allocated. Previous examples need to be revised as follows:
```c++
auto predictor =
paddle::CreatePaddlePredictor<paddle::contrib::AnalysisConfig>(config); // it needs AnalysisConfig here
// create input tensor
int64_t data[4] = {1, 2, 3, 4};
paddle::PaddleTensor tensor;
tensor.shape = std::vector<int>({4, 1});
tensor.data.Reset(data, sizeof(data));
tensor.dtype = paddle::PaddleDType::INT64;
tensor.name = "input0"; // name need to be set here
```
The subsequent execution process is totally the same with `NativeConfig` .
### variable-length sequence input
When dealing with variable-length sequence input, you need to set LoD for `PaddleTensor` .
``` c++
# Suppose the sequence lengths are [3, 2, 4, 1, 2, 3] in order.
tensor.lod = {{0,
/*0 + 3=*/3,
/*3 + 2=*/5,
/*5 + 4=*/9,
/*9 + 1=*/10,
/*10 + 2=*/12,
/*12 + 3=*/15}};
```
For more specific examples, please refer to[LoD-Tensor Instructions](../../../user_guides/howto/basic_concept/lod_tensor_en.html)
### Suggestion for Performance
1. If the CPU type permits, it's best to use the versions with support for AVX and MKL.
2. Reuse input and output `PaddleTensor` to avoid frequent memory allocation resulting in low performance
3. Try to replace `NativeConfig` with `AnalysisConfig` to perform optimization for CPU or GPU inference
## Code Demo
[inference demos](https://github.com/PaddlePaddle/Paddle/tree/develop/paddle/fluid/inference/api/demo_ci)
doc/fluid/advanced_usage/deploy/inference/paddle_gpu_benchmark.md 0 → 100644
浏览文件 @ 2b2d0133
# 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/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/advanced_usage/deploy/inference/paddle_gpu_benchmark_en.md 0 → 100644
浏览文件 @ 2b2d0133
# Performance Profiling for TensorRT Library
## Test Environment
- CPU:Intel(R) Xeon(R) Gold 5117 CPU @ 2.00GHz GPU:Tesla P4
- TensorRT4.0, CUDA8.0, CUDNNV7
- Test model ResNet50, MobileNet, ResNet101, Inception V3.
## Test Targets
**PaddlePaddle, Pytorch, Tensorflow**
- In test, PaddlePaddle adopts subgraph optimization to integrate TensorRT [model](https://github.com/PaddlePaddle/models/tree/develop/fluid/PaddleCV/image_classification/models) .
- Native implementation is used in Pytorch. Model [address 1](https://github.com/pytorch/vision/tree/master/torchvision/models) , [address 2](https://github.com/marvis/pytorch-mobilenet) .
- Test for TensorFlow contains test for native TF and TF—TRT. **Test for TF—TRT hasn't reached expectation wihch will be complemented later**. Model [address](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/advanced_usage/deploy/inference/paddle_tensorrt_infer.md 0 → 100644
浏览文件 @ 2b2d0133
# 使用Paddle-TensorRT库预测
NVIDIA TensorRT 是一个高性能的深度学习预测库，可为深度学习推理应用程序提供低延迟和高吞吐量。PaddlePaddle 采用了子图的形式对TensorRT进行了集成，即我们可以使用该模块来提升Paddle模型的预测性能。该模块依旧在持续开发中，目前已支持的模型有：AlexNet, MobileNetV1, ResNet50, VGG19, ResNext, Se-ReNext, GoogLeNet, DPN, ICNET, Deeplabv3, MobileNet-SSD等。在这篇文档中，我们将会对Paddle-TensorRT库的获取、使用和原理进行介绍。
## 内容
- [编译Paddle-TRT预测库](#编译Paddle-TRT预测库)
- [Paddle-TRT接口使用](#Paddle-TRT接口使用)
- [Paddle-TRT参数介绍](#Paddle-TRT参数介绍)
- [Paddle-TRT样例编译测试](#Paddle-TRT样例编译测试)
- [Paddle-TRT INT8使用](#Paddle-TRT_INT8使用)
- [Paddle-TRT子图运行原理](#Paddle-TRT子图运行原理)
## <a name="编译Paddle-TRT预测库">编译Paddle-TRT预测库</a>
**使用Docker编译预测库**
TensorRT预测库目前仅支持使用GPU编译。
1. 下载Paddle
```
git clone https://github.com/PaddlePaddle/Paddle.git
```
2. 获取docker镜像
```
nvidia-docker run --name paddle_trt -v $PWD/Paddle:/Paddle -it hub.baidubce.com/paddlepaddle/paddle:latest-dev /bin/bash
```
3. 编译Paddle TensorRT
```
# 在docker容器中执行以下操作
cd /Paddle
mkdir build
cd build
# TENSORRT_ROOT为TRT的路径，默认为 /usr，根据自己需求进行改动
# MKLDNN 可以根据自己的需求自行打开
cmake .. \
-DWITH_FLUID_ONLY=ON \
-DWITH_MKL=ON \
-DWITH_MKLDNN=OFF \
-DCMAKE_BUILD_TYPE=Release \
-DWITH_PYTHON=OFF \
-DTENSORRT_ROOT=/usr \
-DON_INFER=ON
# 编译
make -j
# 生成预测库
make inference_lib_dist -j
```
编译后的库的目录如下：
```
fluid_inference_install_dir
├── paddle
│
├── CMakeCache.txt
├── version.txt
├── third_party
├── boost
├── install
└── engine3
```
`fluid_inference_install_dir`下， paddle目录包含了预测库的头文件和预测库的lib， version.txt 中包含了lib的版本和配置信息，third_party 中包含了预测库依赖的第三方库
## <a name="Paddle-TRT接口使用">Paddle-TRT接口使用</a>
Paddle-TRT预测使用总体上分为以下步骤：
1. 创建合适的配置AnalysisConfig.
2. 根据配置创建 `PaddlePredictor`.
3. 创建输入tensor.
4. 获取输出tensor，输出结果.
以下的代码展示了完整的过程：
```c++
#include "paddle_inference_api.h"
namespace paddle {
using paddle::AnalysisConfig;
void RunTensorRT(int batch_size, std::string model_dirname) {
// 1. 创建AnalysisConfig
AnalysisConfig config(model_dirname);
// config->SetModel(model_dirname + "/model",
// model_dirname + "/params");
config->EnableUseGpu(10, 0 /*gpu_id*/);
// 我们在这里使用了 ZeroCopyTensor, 因此需要将此设置成false
config->SwitchUseFeedFetchOps(false);
config->EnableTensorRtEngine(1 << 20 /*work_space_size*/, batch_size /*max_batch_size*/, AnalysisConfig::Precision::kFloat32, false /*use_static*/);
// 2. 根据config 创建predictor
auto predictor = CreatePaddlePredictor(config);
// 3. 创建输入 tensor
int channels = 3;
int height = 224;
int width = 224;
float *input = new float[input_num];
memset(input, 0, input_num * sizeof(float));
auto input_names = predictor->GetInputNames();
auto input_t = predictor->GetInputTensor(input_names[0]);
input_t->Reshape({batch_size, channels, height, width});
input_t->copy_from_cpu(input);
// 4. 运行
predictor->ZeroCopyRun()
// 5. 获取输出
std::vector<float> out_data;
auto output_names = predictor->GetOutputNames();
auto output_t = predictor->GetOutputTensor(output_names[0]);
std::vector<int> output_shape = output_t->shape();
int out_num = std::accumulate(output_shape.begin(), output_shape.end(), 1, std::multiplies<int>());
out_data.resize(out_num);
output_t->copy_to_cpu(out_data.data());
}
} // namespace paddle
int main() {
// 模型下载地址 http://paddle-inference-dist.cdn.bcebos.com/tensorrt_test/mobilenet.tar.gz
paddle::RunTensorRT(1, "./mobilenet");
return 0;
}
```
## <a name="Paddle-TRT参数介绍">Paddle-TRT参数介绍</a>
在使用AnalysisPredictor时，我们通过配置
```c++
config->EnableTensorRtEngine(1 << 20 /* workspace_size*/,
batch_size /*max_batch_size*/,
3 /*min_subgraph_size*/,
AnalysisConfig::Precision::kFloat32 /*precision*/,
false /*use_static*/,
false /* use_calib_mode*/);
```
的方式来指定使用Paddle-TRT子图方式来运行。以下我们将对此接口中的参数进行详细的介绍：
- **`workspace_size`**，类型：int，默认值为`1 << 20`。
- **`max_batch_size`**，类型：int，默认值1。需要提前设置最大的batch的大小，运行时batch数目不得超过此大小。
- **`min_subgraph_size`**，类型：int，默认值3。Paddle-TRT是以子图的形式运行，为了避免性能损失，当子图内部节点个数大于`min_subgraph_size`的时候，才会使用Paddle-TRT运行。
- **`precision`**，类型：`enum class Precision {kFloat32 = 0, kInt8,};`, 默认值为`AnalysisConfig::Precision::kFloat32`。如果需要使用Paddle-TRT calib int8的时候，需要指定precision为 `AnalysisConfig::Precision::kInt8`, 且`use_calib_mode` 为true
- **`use_static`**，类型：bool, 默认值为false。如果指定为true，在初次运行程序的时候会将TRT的优化信息进行序列化，下次运行的时候直接加载优化的序列化信息而不需要重新生成。
- **`use_calib_mode`**，类型：bool, 默认值为false。如果需要运行Paddle-TRT calib int8的时候，需要将此设置为true。
**Note：** Paddle-TRT目前只支持固定shape的输入，不支持变化shape的输入。
## <a name="Paddle-TRT样例编译测试">Paddle-TRT样例编译测试</a>
1. 下载样例
```
https://paddle-inference-dist.cdn.bcebos.com/tensorrt_test/paddle_trt_samples_v1.5.tar.gz
```
解压后的目录如下：
```
sample
├── CMakeLists.txt
├── mobilenet_test.cc
├── thread_mobilenet_test.cc
├── mobilenetv1
│ ├── model
│ └── params
└── run_impl.sh
```
- `mobilenet_test.cc` 为单线程的程序文件
- `thread_mobilenet_test.cc` 为多线程的程序文件
- `mobilenetv1` 为模型文件
在这里假设预测库的路径为 ``BASE_DIR/fluid_inference_install_dir/`` ，样例所在的目录为 ``SAMPLE_BASE_DIR/sample``
2. 编译样例
```shell
cd SAMPLE_BASE_DIR/sample
# sh run_impl.sh {预测库的地址} {测试脚本的名字} {模型目录}
sh run_impl.sh BASE_DIR/fluid_inference_install_dir/ mobilenet_test SAMPLE_BASE_DIR/sample/mobilenetv1
```
3. 编译多线程的样例
```shell
cd SAMPLE_BASE_DIR/sample
# sh run_impl.sh {预测库的地址} {测试脚本的名字} {模型目录}
sh run_impl.sh BASE_DIR/fluid_inference_install_dir/ thread_mobilenet_test SAMPLE_BASE_DIR/sample/mobilenetv1
```
## <a name="Paddle-TRT_INT8使用">Paddle-TRT INT8使用</a>
1. Paddle-TRT INT8 简介
神经网络的参数在一定程度上是冗余的，在很多任务上，我们可以在保证模型精度的前提下，将Float32的模型转换成Int8的模型。目前，Paddle-TRT支持离线将预训练好的Float32模型转换成Int8的模型，具体的流程如下：1）**生成校准表**（Calibration table）；我们准备500张左右的真实输入数据，并将数据输入到模型中去，Paddle-TRT会统计模型中每个op输入和输出值的范围信息，并将记录到校准表中，这些信息有效的减少了模型转换时的信息损失。2）生成校准表后，再次运行模型，**Paddle-TRT会自动加载校准表**，并进行INT8模式下的预测。
2. 编译测试INT8样例
```shell
cd SAMPLE_BASE_DIR/sample
# sh run_impl.sh {预测库的地址} {测试脚本的名字} {模型目录}
# 我们随机生成了500个输入来模拟这一过程，建议大家用真实样例进行实验。
sh run_impl.sh BASE_DIR/fluid_inference_install_dir/ fluid_generate_calib_test SAMPLE_BASE_DIR/sample/mobilenetv1
```
运行结束后，在 `SAMPLE_BASE_DIR/sample/build/mobilenetv1/_opt_cache` 模型目录下会多出一个名字为trt_calib_*的文件，即校准表。
``` shell
# 执行INT8预测
# 将带校准表的模型文件拷贝到特定地址
cp -rf SAMPLE_BASE_DIR/sample/build/mobilenetv1 SAMPLE_BASE_DIR/sample/mobilenetv1_calib
sh run_impl.sh BASE_DIR/fluid_inference_install_dir/ fluid_int8_test SAMPLE_BASE_DIR/sample/mobilenetv1_calib
```
## <a name="Paddle-TRT子图运行原理">Paddle-TRT子图运行原理</a>
PaddlePaddle采用子图的形式对TensorRT进行集成，当模型加载后，神经网络可以表示为由变量和运算节点组成的计算图。Paddle TensorRT实现的功能是能够对整个图进行扫描，发现图中可以使用TensorRT优化的子图，并使用TensorRT节点替换它们。在模型的推断期间，如果遇到TensorRT节点，Paddle会调用TensoRT库对该节点进行优化，其他的节点调用Paddle的原生实现。TensorRT在推断期间能够进行Op的横向和纵向融合，过滤掉冗余的Op，并对特定平台下的特定的Op选择合适的kenel等进行优化，能够加快模型的预测速度。
下图使用一个简单的模型展示了这个过程：
**原始网络**
<p align="center">
<img src="https://raw.githubusercontent.com/NHZlX/FluidDoc/add_trt_doc/doc/fluid/user_guides/howto/inference/image/model_graph_original.png" width="600">
</p>
**转换的网络**
<p align="center">
<img src="https://raw.githubusercontent.com/NHZlX/FluidDoc/add_trt_doc/doc/fluid/user_guides/howto/inference/image/model_graph_trt.png" width="600">
</p>
我们可以在原始模型网络中看到，绿色节点表示可以被TensorRT支持的节点，红色节点表示网络中的变量，黄色表示Paddle只能被Paddle原生实现执行的节点。那些在原始网络中的绿色节点被提取出来汇集成子图，并由一个TensorRT节点代替，成为转换网络中的`block-25` 节点。在网络运行过程中，如果遇到该节点，Paddle将调用TensorRT库来对其执行。
doc/fluid/advanced_usage/deploy/inference/paddle_tensorrt_infer_en.md 0 → 100755
浏览文件 @ 2b2d0133
# Use Paddle-TensorRT Library for inference
NVIDIA TensorRT is a is a platform for high-performance deep learning inference. It delivers low latency and high throughput for deep learning inference application.
Subgraph is used in PaddlePaddle to preliminarily integrate TensorRT, which enables TensorRT module to enhance inference performance of paddle models. The module is still under development. Currently supported models are AlexNet, MobileNet, ResNet50, VGG19, ResNext, Se-ReNext, GoogleNet, DPN, ICNET, Deeplabv3 Mobile, Net-SSD and so on. We will introduce the obtaining, usage and theory of Paddle-TensorRT library in this documentation.
## Contents
- [compile Paddle-TRT inference libraries](#compile Paddle-TRT inference libraries)
- [Paddle-TRT interface usage](#Paddle-TRT interface usage)
- [Paddle-TRT example compiling test](#Paddle-TRT example compiling test)
- [Paddle-TRT INT8 usage](#Paddle-TRT_INT8 usage)
- [Paddle-TRT subgraph operation principle](#Paddle-TRT subgraph operation principle)
## <a name="compile Paddle-TRT inference libraries">compile Paddle-TRT inference libraries</a>
**Use Docker to build inference libraries**
TRT inference libraries can only be compiled using GPU.
1. Download Paddle
```
git clone https://github.com/PaddlePaddle/Paddle.git
```
2. Get docker image
```
nvidia-docker run --name paddle_trt -v $PWD/Paddle:/Paddle -it hub.baidubce.com/paddlepaddle/paddle:latest-dev /bin/bash
```
3. Build Paddle TensorRT
```
# perform the following operations in docker container
cd /Paddle
mkdir build
cd build
cmake .. \
-DWITH_FLUID_ONLY=ON \
-DWITH_MKL=OFF \
-DWITH_MKLDNN=OFF \
-DCMAKE_BUILD_TYPE=Release \
-DWITH_PYTHON=OFF \
-DTENSORRT_ROOT=/usr \
-DON_INFER=ON
# build
make -j
# generate inference library
make inference_lib_dist -j
```
## <a name="Paddle-TRT interface usage">Paddle-TRT interface usage</a>
[`paddle_inference_api.h`]('https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/inference/api/paddle_inference_api.h') defines all APIs of TensorRT.
General steps are as follows:
1. Create appropriate AnalysisConfig.
2. Create `PaddlePredictor` based on config.
3. Create input tensor.
4. Get output tensor and output result.
A complete process is shown below:
```c++
#include "paddle_inference_api.h"
namespace paddle {
using paddle::AnalysisConfig;
void RunTensorRT(int batch_size, std::string model_dirname) {
// 1. Create MixedRTConfig
AnalysisConfig config(model_dirname);
// config->SetModel(model_dirname + "/model",
// model_dirname + "/params");
config->EnableUseGpu(100, 0 /*gpu_id*/);
config->EnableTensorRtEngine(1 << 20 /*work_space_size*/, batch_size /*max_batch_size*/);
// 2. Create predictor based on config
auto predictor = CreatePaddlePredictor(config);
// 3. Create input tensor
int height = 224;
int width = 224;
float data[batch_size * 3 * height * width] = {0};
PaddleTensor tensor;
tensor.shape = std::vector<int>({batch_size, 3, height, width});
tensor.data = PaddleBuf(static_cast<void *>(data),
sizeof(float) * (batch_size * 3 * height * width));
tensor.dtype = PaddleDType::FLOAT32;
std::vector<PaddleTensor> paddle_tensor_feeds(1, tensor);
// 4. Create output tensor
std::vector<PaddleTensor> outputs;
// 5. Inference
predictor->Run(paddle_tensor_feeds, &outputs, batch_size);
const size_t num_elements = outputs.front().data.length() / sizeof(float);
auto *data = static_cast<float *>(outputs.front().data.data());
for (size_t i = 0; i < num_elements; i++) {
std::cout << "output: " << data[i] << std::endl;
}
}
} // namespace paddle
int main() {
// Download address of the model http://paddle-inference-dist.cdn.bcebos.com/tensorrt_test/mobilenet.tar.gz
paddle::RunTensorRT(1, "./mobilenet");
return 0;
}
```
The compilation process is [here](https://github.com/PaddlePaddle/Paddle/tree/develop/paddle/fluid/inference/api/demo_ci)
## <a name="Paddle-TRT_INT8 usage">Paddle-TRT INT8 usage</a>
1. Paddle-TRT INT8 introduction
The parameters of the neural network are redundant to some extent. In many tasks, we can turn the Float32 model into Int8 model on the premise of precision. At present, Paddle-TRT supports to turn the trained Float32 model into Int8 model off line. The specific processes are as follows: 1）**Create the calibration table**. We prepare about 500 real input data, and input the data to the model. Paddle-TRT will count the range information of each op input and output value in the model, and record in the calibration table. The information can reduce the information loss during model transformation. 2）After creating the calibration table, run the model again, **Paddle-TRT will load the calibration table automatically**, and conduct the inference in the INT8 mode.
2. compile and test the INT8 example
```shell
cd SAMPLE_BASE_DIR/sample
# sh run_impl.sh {the address of inference libraries} {the name of test script} {model directories}
# We generate 500 input data to simulate the process, and it's suggested that you use real example for experiment.
sh run_impl.sh BASE_DIR/fluid_inference_install_dir/ fluid_generate_calib_test SAMPLE_BASE_DIR/sample/mobilenetv1
```
After the running period, there will be a new file named trt_calib_* under the `SAMPLE_BASE_DIR/sample/build/mobilenetv1` model directory, which is the calibration table.
``` shell
# conduct INT8 inference
# copy the model file with calibration tables to a specific address
cp -rf SAMPLE_BASE_DIR/sample/build/mobilenetv1 SAMPLE_BASE_DIR/sample/mobilenetv1_calib
sh run_impl.sh BASE_DIR/fluid_inference_install_dir/ fluid_int8_test SAMPLE_BASE_DIR/sample/mobilenetv1_calib
```
## <a name="Paddle-TRT subgraph operation principle">Paddle-TRT subgraph operation principle</a>
Subgraph is used to integrate TensorRT in PaddlePaddle. After model is loaded, neural network can be represented as a computing graph composed of variables and computing nodes. Functions Paddle TensorRT implements are to scan the whole picture, discover subgraphs that can be optimized with TensorRT and replace them with TensorRT nodes. During the inference of model, Paddle will call TensorRT library to optimize TensorRT nodes and call native library of Paddle to optimize other nodes. During the inference, TensorRT can integrate Op horizonally and vertically to filter redundant Ops and is able to choose appropriate kernel for specific Op in specific platform to speed up the inference of model.
A simple model expresses the process :
**Original Network**
<p align="center">
<img src="https://raw.githubusercontent.com/NHZlX/FluidDoc/add_trt_doc/doc/fluid/user_guides/howto/inference/image/model_graph_original.png" width="600">
</p>
**Transformed Network**
<p align="center">
<img src="https://raw.githubusercontent.com/NHZlX/FluidDoc/add_trt_doc/doc/fluid/user_guides/howto/inference/image/model_graph_trt.png" width="600">
</p>
We can see in the Original Network that the green nodes represent nodes supported by TensorRT, the red nodes represent variables in network and yellow nodes represent nodes which can only be operated by native functions in Paddle. Green nodes in original network are extracted to compose subgraph which is replaced by a single TensorRT node to be transformed into `block-25` node in network. When such nodes are encountered during the runtime, TensorRT library will be called to execute them.
doc/fluid/advanced_usage/deploy/inference/python_infer_cn.md 0 → 100644
浏览文件 @ 2b2d0133
# Python 预测 API介绍
Fluid提供了高度优化的[C++预测库](./native_infer.html)，为了方便使用，我们也提供了C++预测库对应的Python接口，两者含义完全相同，下面是详细的使用说明
## PaddleTensor
`PaddleTensor`是预测库输入和输出的数据结构，包括以下字段
* `name`(str): 指定输入的名称
* `shape`(tuple|list): Tensor的shape
* `data`(PaddleBuf): Tensor的数据，存储在`PaddleBuf`中，
* `dtype`(PaddleDType): Tensor的类型
## PaddleBuf
`PaddleBuf`定义了`PaddleTensor`的存储结构，创建`PaddleBuf`:
``` python
int64_buf = PaddleBuf([1, 2, 3, 4])
float_buf = PaddleBuf([1., 2., 3., 4.])
```
`PadleBuf`包括以下方法
* `resize`: 重新分配内存，单位为byte
* `reset`: 重新设置数据
* `empty`: buffer是否为空
* `float_data`: 将数据转为float型的list返回
* `int64_data`: 将数据转为int64型的list返回
* `length`: 内存大小，单位为byte
## PaddleDType
`PaddleDType`定义了`PaddleTensor`的类型，包括
* `PaddleDType.INT64`: 64位整型
* `PaddleDType.FLOAT32`: 32位浮点型
## AnalysisConfig
`AnalysisConfig`是创建预测引擎的配置，主要包括以下方法
* `set_model`: 设置模型的路径
* `model_dir`: 返回模型路径
* `enable_use_gpu`: 设置GPU显存(单位M)和ID
* `disable_gpu`: 禁用GPU
* `gpu_device_id`: 返回使用的GPU ID
* `switch_ir_optim`: IR优化(默认开启)
* `enable_tensorrt_engine`: 启用TensorRT
* `enable_mkldnn`: 启用MKLDNN
## PaddlePredictor
`PaddlePredictor`是运行预测的引擎，下面是创建和使用的说明
``` python
# 创建预测引擎
config = AnalysisConfig(model_dir)
config.enable_use_gpu(200, 0) # 200M显存, 设备id为0
config.enable_tensorrt_engine() # 打开TensorRT
predictor = create_paddle_predictor(config)
# 设置输入
x = fluid.core.PaddleTensor()
# x.name = ...
# x.shape = ...
# x.data = ...
# x.dtype = ...
y = fluid.core.PaddleTensor()
# y.name = ...
# y.shape = ...
# y.data = ...
# y.dtype = ...
# 运行预测引擎得到结果，返回值是一个PaddleTensor的list
results = predictor.run([x, y])
# 获得 results，并应用到自己的应用中
```
**Python API 相关接口与 C++ API 完全对应，可以对照查阅**
## 完整使用示例
下面是一个完整的resnet50预测示例
下载[resnet50模型](http://paddle-inference-dist.bj.bcebos.com/resnet50_model.tar.gz)并解压，运行如下命令将会调用预测引擎
``` bash
python resnet50_infer.py --model_dir model --prog_file model --params_file params --batch_size 2
```
`resnet50_infer.py` 的内容是
``` python
import argparse
import numpy as np
from paddle.fluid.core import PaddleBuf
from paddle.fluid.core import PaddleDType
from paddle.fluid.core import PaddleTensor
from paddle.fluid.core import AnalysisConfig
from paddle.fluid.core import create_paddle_predictor
def main():
args = parse_args()
# Set config
config = AnalysisConfig(args.model_dir)
config.disable_gpu()
# Create PaddlePredictor
predictor = create_paddle_predictor(config)
# Set inputs
inputs = fake_input(args.batch_size)
# Infer
outputs = predictor.run(inputs)
# parse outputs
output = outputs[0]
print(output.name)
output_data = output.data.float_data()
assert len(output_data) == 512 * args.batch_size
for i in range(args.batch_size):
print(np.argmax(output_data[i * 512:(i + 1) * 512]))
def fake_input(batch_size):
image = PaddleTensor()
image.name = "data"
image.shape = [batch_size, 3, 318, 318]
image.dtype = PaddleDType.FLOAT32
image.data = PaddleBuf(
np.random.randn(*image.shape).flatten().astype("float32").tolist())
return [image]
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument("--model_dir", type=str, help="model dir")
parser.add_argument("--prog_file", type=str, help="program filename")
parser.add_argument("--params_file", type=str, help="parameter filename")
parser.add_argument("--batch_size", type=int, default=1, help="batch size")
return parser.parse_args()
if __name__ == "__main__":
main()
```
doc/fluid/advanced_usage/deploy/inference/windows_cpp_inference.md 0 → 100644
浏览文件 @ 2b2d0133
.. _install_or_build_windows_inference_lib:
安装与编译Windows预测库
===========================
直接下载安装
-------------
| 版本说明 | 预测库(1.5.1版本) |
|:---------|:-------------------|
| cpu_avx_mkl | [fluid_inference.zip](https://paddle-inference-lib.bj.bcebos.com/1.5.1-win/cpu_mkl_avx/fluid_inference_install_dir.zip) |
| cpu_avx_openblas | [fluid_inference.zip](https://paddle-inference-lib.bj.bcebos.com/1.5.1-win/cpu_open_avx/fluid_inference_install_dir.zip) |
| cuda8.0_cudnn7_avx_mkl | [fluid_inference.zip](https://paddle-inference-lib.bj.bcebos.com/1.5.1-win/gpu_mkl_avx_8.0/fluid_inference_install_dir.zip) |
| cuda8.0_cudnn7_avx_openblas | [fluid_inference.zip](https://paddle-inference-lib.bj.bcebos.com/1.5.1-win/gpu_open_avx_8.0/fluid_inference_install_dir.zip)|
| cuda9.0_cudnn7_avx_mkl | [fluid_inference.zip](https://paddle-inference-lib.bj.bcebos.com/1.5.1-win/gpu_mkl_avx_9.0/fluid_inference_install_dir.zip) |
| cuda9.0_cudnn7_avx_openblas | [fluid_inference.zip](https://paddle-inference-lib.bj.bcebos.com/1.5.1-win/gpu_open_avx_9.0/fluid_inference_install_dir.zip) |
从源码编译预测库
--------------
用户也可以从 PaddlePaddle 核心代码编译C++预测库，只需在编译时配制下面这些编译选项：
|选项 | 值 |
|:---------|:-------------------|
|CMAKE_BUILD_TYPE | Release |
|FLUID_INFERENCE_INSTALL_DIR | 安装路径 |
|WITH_PYTHON | OFF（推荐）|
|ON_INFER | ON（推荐） |
|WITH_GPU | ON/OFF |
|WITH_MKL | ON/OFF |
建议按照推荐值设置，以避免链接不必要的库。其它可选编译选项按需进行设定。
下面的代码片段从github拉取最新代码，配制编译选项（需要将PADDLE_ROOT替换为PaddlePaddle预测库的安装路径）：
.. code-block::
PADDLE_ROOT=\path_to_paddle
git clone https://github.com/PaddlePaddle/Paddle.git
cd Paddle
mkdir build
cd build
cmake -DFLUID_INFERENCE_INSTALL_DIR=$PADDLE_ROOT \
-DCMAKE_BUILD_TYPE=Release \
-DWITH_PYTHON=OFF \
-DWITH_MKL=OFF \
-DWITH_GPU=OFF \
-DON_INFER=ON \
..
使用 vs2015 打开 paddle.sln 文件，选择 Release 编译即可。
成功编译后，使用C++预测库所需的依赖（包括：（1）编译出的PaddlePaddle预测库和头文件；（2）第三方链接库和头文件；（3）版本信息与编译选项信息）
均会存放于PADDLE_ROOT目录中。目录结构如下：
.. code-block:: text
PaddleRoot/
├── CMakeCache.txt
├── paddle
│   ├── include
│   │   ├── paddle_anakin_config.h
│   │   ├── paddle_analysis_config.h
│   │   ├── paddle_api.h
│   │   ├── paddle_inference_api.h
│   │   ├── paddle_mkldnn_quantizer_config.h
│   │   └── paddle_pass_builder.h
│   └── lib
│   ├── libpaddle_fluid.a
│   └── libpaddle_fluid.so
├── third_party
│   ├── boost
│   │   └── boost
│   ├── eigen3
│   │   ├── Eigen
│   │   └── unsupported
│   └── install
│   ├── gflags
│   ├── glog
│   ├── mkldnn
│   ├── mklml
│   ├── protobuf
│   ├── snappy
│   ├── snappystream
│   ├── xxhash
│   └── zlib
└── version.txt
version.txt 中记录了该预测库的版本信息，包括Git Commit ID、使用OpenBlas或MKL数学库、CUDA/CUDNN版本号，如：
.. code-block:: text
GIT COMMIT ID: cc9028b90ef50a825a722c55e5fda4b7cd26b0d6
WITH_MKL: ON
WITH_MKLDNN: ON
WITH_GPU: ON
CUDA version: 8.0
CUDNN version: v7
编译预测demo
-------------
### 硬件环境
测试环境硬件配置：
| CPU | I7-8700K |
|:---------|:-------------------|
| 内存 | 16G |
| 硬盘 | 1T hdd + 256G ssd |
| 显卡 | GTX1080 8G |
测试环境操作系统使用 win10 家庭版本。
### 软件要求
**请您严格按照以下步骤进行安装，否则可能会导致安装失败！**
**安装Visual Studio 2015 update3**
安装Visual Studio 2015，安装选项中选择安装内容时勾选自定义，选择安装全部关于c，c++，vc++的功能。
### 编译demo
下载并解压 fluid_inference_install_dir.zip 压缩包。
进入 Paddle/paddle/fluid/inference/api/demo_ci 目录，新建build目录并进入，然后使用cmake生成vs2015的solution文件。
指令为：
`cmake .. -G "Visual Studio 14 2015 Win64" -DWITH_GPU=OFF -DWITH_MKL=ON -DWITH_STATIC_LIB=ON -DCMAKE_BUILD_TYPE=Release -DDEMO_NAME=simple_on_word2vec -DPADDLE_LIB=path_to_the_paddle_lib`
注：
-DDEMO_NAME 是要编译的文件
-DPADDLE_LIB fluid_inference_install_dir，例如
-DPADDLE_LIB=D:\fluid_inference_install_dir
Cmake可以在[官网进行下载](https://cmake.org/download/)，并添加到环境变量中。
执行完毕后，build 目录如图所示，打开箭头指向的 solution 文件：
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/deploy/inference/image/image3.png">
</p>
修改编译属性为 `/MT` ：
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/deploy/inference/image/image4.png">
</p>
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/deploy/inference/image/image5.png">
</p>
编译生成选项改成 `Release` 。
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/deploy/inference/image/image6.png">
</p>
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/deploy/inference/image/image7.png">
</p>
通过cmd进到Release目录执行：
1. 开启GLOG
`set GLOG_v=100`
2. 进行预测
`simple_on_word2vec.exe --dirname=.\word2vec.inference.model`
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/deploy/inference/image/image9.png">
</p>
doc/fluid/advanced_usage/deploy/inference/windows_cpp_inference_en.md 0 → 100755
浏览文件 @ 2b2d0133
Model Inference on Windows
===========================
Set up Environment
-------------------
### Hardware Environment
Hardware Configuration of the experimental environment:
| CPU | I7-8700K |
|:--------------|:-------------------|
| Memory | 16G |
| Hard Disk | 1T hdd + 256G ssd |
| Graphics Card | GTX1080 8G |
The operating system is win10 family version in the experimental environment.
### Steps to Configure Environment
**Please strictly follow the subsequent steps to install, otherwise the installation may fail**
**Install Visual Studio 2015 update3**
Install Visual Studio 2015. Please choose "customize" for the options of contents to be installed and choose to install all functions relevant to c, c++ and vc++.
Usage of Inference demo
------------------------
Decompress Paddle, Release and fluid_install_dir compressed package.
First enter into Paddle/paddle/fluid/inference/api/demo_ci, then create and enter into directory /build, finally use cmake to generate vs2015 solution file.
Commands are as follows:
`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`
Note:
-DDEMO_NAME is the file to be built
-DPADDLE_LIB is the path of fluid_install_dir, for example:
-DPADDLE_LIB=D:\fluid_install_dir
Cmake can be [downloaded at official site](https://cmake.org/download/) and added to environment variables.
After the execution, the directory build is shown in the picture below. Then please open the solution file that which the arrow points at:
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/deploy/inference/image/image3.png">
</p>
Modify the attribute of build as `/MT` :
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/deploy/inference/image/image4.png">
</p>
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/deploy/inference/image/image5.png">
</p>
Modify option of building and generating as `Release` .
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/deploy/inference/image/image6.png">
</p>
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/deploy/inference/image/image7.png">
</p>
In the dependent packages provided, please copy openblas and model files under Release directory to the directory of Release built and generated.
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/deploy/inference/image/image8.png">
</p>
Enter into Release in cmd and run:
1. Open GLOG
`set GLOG_v=100`
2. Start inference
`simple_on_word2vec.exe --dirname=.\word2vec.inference.model`
<p align="center">
<img src="https://raw.githubusercontent.com/PaddlePaddle/FluidDoc/develop/doc/fluid/advanced_usage/deploy/inference/image/image9.png">
</p>
doc/fluid/advanced_usage/deploy/install_anakin.md 已删除 100644 → 0
浏览文件 @ 1fe89e8a
## 从源码编译安装Anakin ##
我们已经在CentOS 7.3上成功的安装和测试了Anakin，对于其他操作系统，我们将很快支持。
### 安装概览 ###
* [在CentOS上安装 Anakin]()
* [在Ubuntu上安装 Anakin]()
* [在ARM上安装 Anakin](run_on_arm_ch.md)
* [验证安装]()
### 在CentOS上安装 Anakin ###
#### 1. 系统要求 ####
* make 3.82+
* cmake 2.8.12+
* gcc 4.8.2+
* g++ 4.8.2+
* 其他需要补充的。。。
#### 2. 编译CPU版Anakin ####
暂时不支持
#### 3. 编译支持NVIDIA GPU的Anakin ####
- 3.1. 安装依赖
- 3.1.1 protobuf
>$ git clone https://github.com/google/protobuf
>$ cd protobuf
>$ git submodule update --init --recursive
>$ ./autogen.sh
>$ ./configure --prefix=/path/to/your/insall_dir
>$ make
>$ make check
>$ make install
>$ sudo ldconfig
如安装protobuf遇到任何问题，请访问[这里](https://github.com/google/protobuf/blob/master/src/README.md)
- 3.2 CUDA Toolkit
- [CUDA 8.0](https://developer.nvidia.com/cuda-zone) or higher. 具体信息参见[NVIDIA's documentation](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/).
- [cuDNN v7](https://developer.nvidia.com/cudnn). 具体信息参见[NVIDIA's documentation](https://docs.nvidia.com/cuda/cuda-installation-guide-linux/).
- 3.3 编译Anakin
>$ git clone https:/xxxxx
>$ cd anakin
>$ mkdir build
>$ camke ..
>$ make
#### 4. 编译支持AMD GPU的Anakin ####
暂时还不支持
### 在Ubuntu上安装 Anakin ###
暂时还不支持
### 在ARM上安装 Anakin ###
暂时还不支持
### 验证安装 ###
we are coming soon...
doc/fluid/advanced_usage/deploy/mobile/for_developer.md 0 → 100644
浏览文件 @ 2b2d0133
# 开发者文档
## 基本概念
### Place
`Place`类确定了kernel运行时的上下文信息，其中包含了kernel运行时所在的平台，执行运算数据的精度以及数据的布局等信息，使得MIR的分析更加清晰准确。它主要的成员变量如下：
* `TargetType target`: kernel运行时所在的平台，如X86/CUDA/ARM等；
* `PrecisionType precision`: kernel执行运算的数据的精度，如Float, Int8, Fp16等；
* `DataLayoutType layout`: kernel执行运算的数据的布局，如NCHW, NHWC等；
### OpLite
`Oplite`类负责协助kernel计算，本身不具备计算功能，主要的接口功能包括：
* `CheckShape`: 用于检查op的输入/输出参数维度、类型是否合法，以及属性信息是否符合设计；
* `InferShape`: 用于设置输出Tensor的形状信息；
* `CreateKernels`: 创建相关的kernel;
* `Attach`: 用于从`Scope`和`OpDesc`中获取参数的指针，并传递给kernel;
重要方法及声明如下：
```c++
class OpLite : public Registry {
public:
OpLite() = default;
explicit OpLite(const std::string &type) : op_type_(type) {}
explicit OpLite(const std::vector<Place> &valid_places)
: valid_places_(valid_places) {}
void SetValidPlaces(const std::vector<Place> &places) {
VLOG(3) << "valid places " << valid_places_.size();
valid_places_ = places;
}
// Set supported places
const std::vector<Place> &valid_places() const { return valid_places_; }
// Check the shape.
virtual bool CheckShape() const { return true; }
// Inference the outputs' shape.
virtual bool InferShape() const { return true; }
// Run this operator.
virtual bool Run();
// Link the external execution environ to internal context.
bool Attach(const cpp::OpDesc &opdesc, lite::Scope *scope);
// Create all the kernels for the valid targets.
std::vector<std::unique_ptr<KernelBase>> CreateKernels(
const std::vector<Place> &places, const std::string &kernel_type = "");
// Assign op param to kernel.
virtual void AttachKernel(KernelBase *kernel) = 0;
};
```
### KernelLite
为了提升kernel对`Target`, `Precision`, `DataLayout`等多种执行模式的支持，引入了`KernelLite`的概念，它主要有以下特点：
* 可以通过模版特化不同`Place`和kernel的实现，加强对不同执行模式的支持；
* 轻量级，`KernelLite`类似functor，只有执行的职能，执行效率更高；
* 每个kernel有明确执行的模式，并且可以在analysis time参与分析；
* 依赖简单，便于部署到mobile执行；
* 硬件调度信息等`context`跟具体的kernel绑定，方便定制不同kernel的行为。
重要的方法及声明如下：
```c++
template <TargetType Target, PrecisionType Precision,
DataLayoutType DataLayout = DataLayoutType::kNCHW>
class KernelLite : public KernelBase {
public:
// Run the kernel.
virtual void Run() { CHECK(false) << "Not Implemented"; }
// Set target
TargetType target() const override { return Target; }
// Set precision
PrecisionType precision() const override { return Precision; }
// Set data layout
DataLayoutType layout() const override { return DataLayout; }
Place place() const override { return Place{Target, Precision, DataLayout}; }
void Touch() {}
KernelLite() = default;
virtual ~KernelLite() = default;
};
```
## 架构简介
Mobile 在这次升级为 lite 架构， 侧重多硬件、高性能的支持，其主要设计思想如下
- 引入 Type system，强化多硬件、量化方法、data layout 的混合调度能力
- 硬件细节隔离，通过不同编译开关，对支持的任何硬件可以自由插拔
- 引入 MIR(Machine IR) 的概念，强化带执行环境下的优化支持
- 优化期和执行期严格隔离，保证预测时轻量和高效率
架构图如下
![Paddle Inference Refactor1.0](https://github.com/Superjomn/_tmp_images/raw/master/images/lite.jpg)
## 增加新 Kernel的方法
下面主要介绍op新增kernel如何写，简单总结新增kernel的实现需要包含如下内容：
- kernel实现：继承自`KernelLite`类的对应op的Compute类定义与实现，根据输入的数据类型，数据布局，数据所在的设备以及运行时所调用的第三方库的不同实现不同的kernel；server端CPU kernel实现在.h文件中。
- kernel注册：server端CPU kernel注册实现在.cc文件。
## 实现C++类
以mul op的CPU Kernel实现为例，mul kernel执行运算的矩阵乘法的公式为*Out* = *X* * *Y*, 可见该计算由两个输入，一个输出组成; 输入输出参数分别从OP的param中获取，如mul op的param定义如下：
```c++
struct MulParam {
const lite::Tensor* x{};
const lite::Tensor* y{};
lite::Tensor* output{};
int x_num_col_dims{1};
int y_num_col_dims{1};
};
```
下面开始定义`MulCompute`类的实现：
```c++
template <typename T>
class MulCompute : public KernelLite<TARGET(kX86), PRECISION(kFloat)> {
public:
using param_t = operators::MulParam;
void Run() override {
auto& context = ctx_->As<X86Context>();
auto& param = *param_.get_mutable<operators::MulParam>();
CHECK(context.x86_device_context());
//1. 为output分配内存
param.output->template mutable_data<T>();
// 2. 获取计算用的输入输出
auto* x = &param.x->raw_tensor();
auto* y = &param.y->raw_tensor();
auto* z = &param.output->raw_tensor();
//3. 对输入输出数据进行需要的处理...
Tensor x_matrix, y_matrix;
if (x->dims().size() > 2) {
x_matrix = framework::ReshapeToMatrix(*x, param.x_num_col_dims);
} else {
x_matrix = *x;
}
//4. 调用数学库进行矩阵的运算...
auto blas = paddle::operators::math::GetBlas<platform::CPUDeviceContext, T>(
*context.x86_device_context());
blas.MatMul(x_matrix, y_matrix, z);
}
virtual ~MulCompute() = default;
};
```
`MulCompute`类继承自`kernelLite`, 带有下面两个模版参数：
- `TARGET(kX86)`: `Target`代表的是硬件信息，如CUDA/X86/ARM/…，表示该kernel运行的硬件平台，在该示例中我们写的是kX86，表示mul这个kernel运行在X86平台上；
- `PRECISION(kFloat)`：`Precision`代表该kernel运算支持的数据精度信息，示例中写的是`kFloat`, 表示mul这个kernel支持Float数据的运算；
需要为`MulCompute`类重写`Run`接口， kernel 的输入和输出分别通过`MulParam`获得，输入/输出的变量类型是`lite::Tensor`。
到此，前向mul kernel的实现完成，接下来需要在.cc文件中注册该kernel。
## 注册kernel
在.cc文件中注册实现的kernel：
```c++
REGISTER_LITE_KERNEL(mul, kX86, kFloat, kNCHW,
paddle::lite::kernels::x86::MulCompute<float>, def)
.BindInput("X", {LiteType::GetTensorTy(TARGET(kX86))})
.BindInput("Y", {LiteType::GetTensorTy(TARGET(kX86))})
.BindOutput("Out", {LiteType::GetTensorTy(TARGET(kX86))})
.Finalize();
```
在上面的代码中；
- `REGISTER_LITE_KERNEL`: 注册MulCompute类，并特化模版参数为float类型， 类型名为mul, 运行的平台为X86, 数据精度为float, 数据布局为NCHW；
- 在运行时，框架系统根据输入数据所在的设备，输入数据的类型，数据布局等信息静态的选择合适的kernel执行运算。
## 开发环境
### Mobile端开发和测试
我们提供了移动端开发所需的docker镜像环境，在`paddle/fluid/lite/tools/Dockerfile.mobile`，可以直接通过
`docker build --file paddle/fluid/lite/tools/Dockerfile.mobile --tag paddle-lite-mobile:latest . `生成镜像文件。
该镜像中提供了
- Android端的交叉编译环境
- ARM Linux端的交叉编译环境
- Android端的模拟器环境
- 开发所需的格式检查工具
#### 相关的cmake选项
目前支持如下的编译配置，以生成不同目标上的程序。
- `ARM_TARGET_OS` 代表目标操作系统， 目前支持 "android" "armlinux"， 默认是Android
- `ARM_TARGET_ARCH_ABI` 代表ARCH，支持输入"armv8"和"armv7"，针对OS不一样选择不一样。
- `-DARM_TARGET_OS="android"` 时
- "armv8", 等效于 "arm64-v8a"。 default值为这个。
- "armv7", 等效于 "armeabi-v7a"。
- `-DARM_TARGET_OS="armlinux"` 时
- "armv8", 等效于 "arm64"。 default值为这个。
- "armv7hf", 等效于使用`eabihf`且`-march=armv7-a -mfloat-abi=hard -mfpu=neon-vfpv4 `。
- "armv7", 等效于使用`eabi`且`-march=armv7-a -mfloat-abi=softfp -mfpu=neon-vfpv4`。
- `ARM_TARGET_LANG` 代表目标编译的语言， 默认为gcc，支持 gcc和clang两种。
注意: ARM Linux当前仅支持在armv8上编译并测试。
#### 开发
添加新的ARM端kernel，主要分为3部分：
1. 添加具体的数学计算，在`paddle/fluid/lite/arm/math`中添加对应的数学函数，侧重点在于代码本身的优化，充分利用NEON指令发挥其优势。
2. 添加kernel声明和调用实例，在`paddle/fluid/lite/kernels/arm`中添加对应kernel的框架声明和调用，侧重点在于每种kernel严格对应输入输出的类型。
3. 添加单元测试，在`paddle/fluid/lite/kernels/arm`中添加相应的单元测试，并保持其在模拟器或者真机中可以通过。
#### 测试
我们在镜像开发环境中添加了`arm64-v8a`和`armeabi-v7a`的Android模拟环境，在没有真机环境下，可以很方便的用于测试对应平台上的单元测试。
常用步骤如下
```shell
# 创建Android avd (armv8)
$ echo n | avdmanager create avd -f -n paddle-armv8 -k "system-images;android-24;google_apis;arm64-v8a"
# 启动Android armv8 emulator
$ ${ANDROID_HOME}/emulator/emulator -avd paddle-armv8 -noaudio -no-window -gpu off -verbose &
# 其他正常测试步骤
# 关闭所有模拟器
$ adb devices | grep emulator | cut -f1 | while read line; do adb -s $line emu kill; done
```
doc/fluid/advanced_usage/deploy/mobile/index_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
##########
移动端部署
##########
本模块介绍了 PaddlePaddle 组织下的嵌入式平台深度学习框架——Paddle-Mobile，包括：
* `项目简介 <mobile_index.html>`_：简要介绍了 Paddle-Mobile 特点以及使用说明
* `开发者文档 <for_developer.html>`_：分别介绍如何开发扩展及编译 mobile 预测库
.. toctree::
:hidden:
mobile_index.md
for_developer.md
doc/fluid/advanced_usage/deploy/mobile/index_en.rst 0 → 100644
浏览文件 @ 2b2d0133
#################
Mobile Deployment
#################
doc/fluid/advanced_usage/deploy/mobile/mobile_index.md 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/advanced_usage/deploy/mobile_build.md 已删除 100644 → 0
浏览文件 @ 1fe89e8a
# 环境搭建
## 使用 docker
### 1. 安装 docker
安装 docker 的方式，参考官方文档 [https://docs.docker.com/install/](https://docs.docker.com/install/)
### 2. 使用 docker 搭建构建环境
首先进入 paddle-mobile 的目录下，执行 `docker build`
以 Linux/Mac 为例 (windows 建议在 'Docker Quickstart Terminal' 中执行)
```
$ docker build -t paddle-mobile:dev - < Dockerfile
```
使用 `docker images` 可以看到我们新建的 image
```
$ docker images
REPOSITORY TAG IMAGE ID CREATED SIZE
paddle-mobile dev 33b146787711 45 hours ago 372MB
```
### 3. 使用 docker 构建
进入 paddle-mobile 目录，执行 docker run
```
$ docker run -it --mount type=bind,source=$PWD,target=/paddle-mobile paddle-mobile:dev
root@5affd29d4fc5:/ # cd /paddle-mobile
# 生成构建 android 产出的 Makefile
root@5affd29d4fc5:/ # rm CMakeCache.txt
root@5affd29d4fc5:/ # cmake -DCMAKE_TOOLCHAIN_FILE=tools/toolchains/arm-android-neon.cmake
# 生成构建 linux 产出的 Makefile
root@5affd29d4fc5:/ # rm CMakeCache.txt
root@5affd29d4fc5:/ # cmake -DCMAKE_TOOLCHAIN_FILE=tools/toolchains/arm-linux-gnueabi.cmake
```
### 4. 设置编译选项
可以通过 ccmake 设置编译选项
```
root@5affd29d4fc5:/ # ccmake .
Page 1 of 1
CMAKE_ASM_FLAGS
CMAKE_ASM_FLAGS_DEBUG
CMAKE_ASM_FLAGS_RELEASE
CMAKE_BUILD_TYPE
CMAKE_INSTALL_PREFIX /usr/local
CMAKE_TOOLCHAIN_FILE /paddle-mobile/tools/toolchains/arm-android-neon.cmake
CPU ON
DEBUGING ON
FPGA OFF
LOG_PROFILE ON
MALI_GPU OFF
NET googlenet
USE_EXCEPTION ON
USE_OPENMP OFF
```
修改选项后，按 `c`, `g` 更新 Makefile
### 5. 构建
使用 make 命令进行构建
```
root@5affd29d4fc5:/ # make
```
### 6. 查看构建产出
构架产出可以在 host 机器上查看，在 paddle-mobile 的目录下，build 以及 test/build 下，可以使用 adb 指令或者 scp 传输到 device 上执行
## 不使用 docker
不使用 docker 的方法，可以直接用 cmake 生成 makefile 后构建。使用 ndk 构建 android 应用需要正确设置 NDK_ROOT。构建 linux 应用需要安装 arm-linux-gnueabi-gcc 或者类似的交叉编译工具，可能需要设置 CC，CXX 环境变量，或者在 tools/toolchains/ 中修改 arm-linux-gnueabi.cmake，或者增加自己需要的 toolchain file。
doc/fluid/advanced_usage/deploy/mobile_dev.md 已删除 100644 → 0
浏览文件 @ 1fe89e8a
# iOS开发文档
## 编译
### 一. 使用 build.sh 编译
```sh
sh build.sh ios
# 如果只想编译某个特定模型的 op, 则需执行以下命令
sh build.sh ios googlenet
# 在这个文件夹下, 你可以拿到生成的 .a 库
cd ../build/release/ios/build
```
### 二. 使用 xcode 编译
我们提供了 ios 开发更为熟悉的 xcode 编译环境:
在 ios/ 目录下打开 PaddleMobile.xcworkspace 即可编译 PaddleMobile 或者 运行 Demo
### 三. 集成
#### 如使用 c++ 接口
将
```
libpaddle-mobile.a
io.h
program.h
types.h
lod_tensor.h
tensor.h
```
拖入工程, io.h 为接口文件, 可在 [github](https://github.com/PaddlePaddle/paddle-mobile/blob/develop/src/io/io.h)上查看接口注释
#### 如使用 oc 接口
将在xcode 编译生成的
```
libPaddleMobile.a
PaddleMobile.h
```
拖入工程, 接口如下:
```
/*
创建单例对象
*/
+ (instancetype)sharedInstance;
/*
load 模型, 开辟内存
*/
- (BOOL)load:(NSString *)modelPath andWeightsPath:(NSString *)weighsPath;
/*
进行预测, means 和 scale 为训练模型时的预处理参数, 如训练时没有做这些预处理则直接使用 predict
*/
- (NSArray *)predict:(CGImageRef)image means:(NSArray<NSNumber *> *)means scale:(float)scale;
/*
进行预测
*/
- (NSArray *)predict:(CGImageRef)image;
/*
清理内存
*/
- (void)clear;
```
doc/fluid/advanced_usage/development/contribute_to_paddle/faq.rst 0 → 100644
浏览文件 @ 2b2d0133
.. _contribute_to_paddle_faq:
###################
FAQ
###################
.. contents::
1. CLA签署不成功，怎么办？
---------------------------
由于 `CLA <https://github.com/cla-assistant/cla-assistant>`_ 是第三方开源库，有时候会不稳定。如果确定自己已签署CLA，但CLA没触发成功，可尝试：
* 关闭并重新开启本PR，来重新触发CLA。点击 :code:`Close pull request` ，再点击 :code:`Reopen pull request` ，并等待几分钟。
* 如果上述操作重复2次仍未生效，请重新提一个PR或评论区留言。
2. CI没有触发，怎么办？
------------------------
* 请在commit信息中添加正确的CI触发规则：
* develop分支请添加 :code:`test=develop`
* release分支请添加如 :code:`test=release/1.4` 来触发release/1.4分支
* 文档预览请添加 :code:`test=document_preview`
* 该CI触发规则以commit为单位，即对同一个PR来说，不管前面的commit是否已经添加，如果新commit想继续触发CI，那么仍然需要添加。
* 添加CI触发规则后，仍有部分CI没有触发：请关闭并重新开启本PR，来重新触发CI。
3. CI随机挂，即错误信息与本PR无关，怎么办？
--------------------------------------
由于develop分支代码的不稳定性，CI可能会随机挂。
如果确定CI错误和本PR无关，请在评论区贴上错误截图和错误链接。
4. 如何修改API.spec？
-----------------------
为了保证API接口/文档的稳定性，我们对API进行了监控，即API.spec文件。
修改方法请参考 `diff_api.py <https://github.com/PaddlePaddle/Paddle/blob/ddfc823c73934d483df36fa9a8b96e67b19b67b4/tools/diff_api.py#L29-L34>`_ 。
**注意**：提交PR后请查看下diff，不要改到非本PR修改的API上。
doc/fluid/advanced_usage/development/contribute_to_paddle/index_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
############
如何贡献代码
############
.. toctree::
:maxdepth: 1
local_dev_guide.md
submit_pr_guide.md
faq.rst
doc/fluid/advanced_usage/development/contribute_to_paddle/index_en.rst 0 → 100644
浏览文件 @ 2b2d0133
#################################
How to contribute codes to Paddle
#################################
.. toctree::
:maxdepth: 1
local_dev_guide_en.md
submit_pr_guide_en.md
doc/fluid/advanced_usage/development/cpu_profiling_cn.md 已删除 120000 → 0
浏览文件 @ 1fe89e8a
../../howto/optimization/cpu_profiling_cn.md
\ No newline at end of file
doc/fluid/advanced_usage/development/host_memory_profiling_cn.md 已删除 120000 → 0
浏览文件 @ 1fe89e8a
../../howto/optimization/host_memory_profiling_cn.md
\ No newline at end of file
doc/fluid/advanced_usage/development/new_op.md 已删除 120000 → 0
浏览文件 @ 1fe89e8a
../../dev/new_op_cn.md
\ No newline at end of file
doc/fluid/advanced_usage/development/new_op/index_en.rst 0 → 100644
浏览文件 @ 2b2d0133
###################
Write New Operators
###################
- `How to write new operator <new_op_en.html>`_ ：guides to write new operators
- `op notes <op_notes_en.html>`_ ：notes on developing new operators
.. toctree::
:hidden:
new_op_en.md
op_notes_en.md
doc/fluid/advanced_usage/development/new_op/new_op.md 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/advanced_usage/development/new_op/op_notes.md 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/advanced_usage/development/write_docs_cn.md 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/advanced_usage/development/write_docs_en.md 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/advanced_usage/index.rst 已删除 100644 → 0
浏览文件 @ 1fe89e8a
此差异已折叠。
doc/fluid/advanced_usage/index_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/advanced_usage/index_en.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/advanced_usage/paddle_slim/paddle_slim.md 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/advanced_usage/pics/int8_design.png 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/CMakeLists.txt
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/average.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/average/WeightedAverage.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/backward.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/backward/append_backward.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/backward/gradients.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/clip.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/clip/ErrorClipByValue.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/clip/GradientClipByGlobalNorm.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/clip/GradientClipByNorm.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/clip/GradientClipByValue.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/data/data_reader.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/data/data_reader/Reader.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/data/dataset.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/data/dataset/cifar.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/data/dataset/conll05.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/data/dataset/imdb.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/data/dataset/imikolov.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/data/dataset/movielens.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/data/dataset/sentiment.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/data/dataset/uci_housing.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/data/dataset/wmt14.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/data/dataset/wmt16.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/data/image.rst 已删除 100644 → 0
浏览文件 @ 1fe89e8a
此差异已折叠。
doc/fluid/api/data_feeder.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/data_feeder/DataFeeder.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dataset.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dataset/DatasetFactory.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dataset/InMemoryDataset.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dataset/QueueDataset.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/BackwardStrategy.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/BatchNorm.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/BilinearTensorProduct.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/Conv2D.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/Conv2DTranspose.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/Conv3D.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/Conv3DTranspose.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/CosineDecay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/Embedding.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/ExponentialDecay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/FC.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/GRUUnit.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/GroupNorm.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/InverseTimeDecay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/Layer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/LayerNorm.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/NCE.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/NaturalExpDecay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/NoamDecay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/PRelu.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/PiecewiseDecay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/PolynomialDecay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/Pool2D.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/SpectralNorm.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/Tracer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/TreeConv.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/enabled.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/guard.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/load_persistables.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/no_grad.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/not_support.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/prepare_context.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/save_persistables.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/start_gperf_profiler.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/stop_gperf_profiler.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/dygraph/to_variable.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/executor.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/executor/Executor.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/executor/global_scope.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/executor/scope_guard.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/BuildStrategy.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/CPUPlace.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/CUDAPinnedPlace.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/CUDAPlace.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/CompiledProgram.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/DataFeedDesc.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/DataFeeder.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/DistributeTranspiler.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/DistributeTranspilerConfig.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/ExecutionStrategy.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/Executor.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/LoDTensor.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/LoDTensorArray.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/ParallelExecutor.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/ParamAttr.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/Program.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/Tensor.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/WeightNormParamAttr.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/cpu_places.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/create_lod_tensor.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/create_random_int_lodtensor.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/cuda_pinned_places.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/cuda_places.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/default_main_program.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/default_startup_program.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/global_scope.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/gradients.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/in_dygraph_mode.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/memory_optimize.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/name_scope.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/program_guard.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/release_memory.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/fluid/scope_guard.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/gen_doc.py
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/gen_doc.sh 100755 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/gen_index.py 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/gen_module_index.py 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/index_en.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/Bilinear.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/BilinearInitializer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/Constant.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/ConstantInitializer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/MSRA.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/MSRAInitializer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/Normal.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/NormalInitializer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/NumpyArrayInitializer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/TruncatedNormal.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/Uniform.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/UniformInitializer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/Xavier.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/XavierInitializer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/force_init_on_cpu.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/initializer/init_on_cpu.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/io.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/io/PyReader.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/io/load_inference_model.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/io/load_params.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/io/load_persistables.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/io/load_vars.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/io/save_inference_model.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/io/save_params.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/io/save_persistables.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/io/save_vars.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/DynamicRNN.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/IfElse.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/Preprocessor.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/Print.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/StaticRNN.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/Switch.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/While.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/abs.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/accuracy.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/acos.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/adaptive_pool2d.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/adaptive_pool3d.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/add_position_encoding.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/affine_channel.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/affine_grid.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/anchor_generator.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/argmax.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/argmin.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/argsort.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/array_length.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/array_read.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/array_write.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/asin.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/assign.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/atan.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/auc.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/autoincreased_step_counter.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/batch.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/batch_norm.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/beam_search.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/beam_search_decode.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/bilinear_tensor_product.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/bipartite_match.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/box_clip.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/box_coder.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/box_decoder_and_assign.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/bpr_loss.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/brelu.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/cast.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/ceil.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/chunk_eval.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/clip.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/clip_by_norm.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/collect_fpn_proposals.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/concat.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/continuous_value_model.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/conv2d.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/conv2d_transpose.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/conv3d.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/conv3d_transpose.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/cos.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/cos_sim.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/cosine_decay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/create_array.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/create_global_var.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/create_parameter.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/create_py_reader_by_data.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/create_tensor.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/crf_decoding.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/crop.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/cross_entropy.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/ctc_greedy_decoder.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/cumsum.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/data.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/data_norm.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/deformable_conv.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/deformable_roi_pooling.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/density_prior_box.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/detection_map.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/detection_output.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/diag.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/dice_loss.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/distribute_fpn_proposals.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/double_buffer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/dropout.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/dynamic_gru.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/dynamic_lstm.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/dynamic_lstmp.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/edit_distance.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/elementwise_add.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/elementwise_div.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/elementwise_floordiv.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/elementwise_max.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/elementwise_min.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/elementwise_mod.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/elementwise_mul.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/elementwise_pow.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/elementwise_sub.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/elu.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/embedding.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/equal.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/exp.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/expand.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/exponential_decay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/fc.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/fill_constant.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/fill_constant_batch_size_like.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/flatten.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/floor.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/fsp_matrix.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/gather.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/gaussian_random.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/generate_mask_labels.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/generate_proposal_labels.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/generate_proposals.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/get_tensor_from_selected_rows.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/greater_equal.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/greater_than.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/grid_sampler.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/group_norm.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/gru_unit.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/hard_shrink.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/hard_sigmoid.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/has_inf.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/has_nan.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/hash.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/hsigmoid.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/huber_loss.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/im2sequence.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/image_resize.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/image_resize_short.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/increment.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/inverse_time_decay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/iou_similarity.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/is_empty.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/isfinite.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/kldiv_loss.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/l2_normalize.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/label_smooth.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/layer_norm.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/leaky_relu.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/less_equal.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/less_than.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/linear_chain_crf.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/linear_lr_warmup.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/linspace.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/load.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/lod_reset.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/log.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/log_loss.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/logical_and.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/logical_not.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/logical_or.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/logical_xor.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/logsigmoid.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/lrn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/lstm.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/lstm_unit.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/margin_rank_loss.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/matmul.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/maxout.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/mean.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/mean_iou.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/merge_selected_rows.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/mul.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/multi_box_head.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/multiclass_nms.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/multiplex.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/natural_exp_decay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/nce.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/noam_decay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/not_equal.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/npair_loss.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/one_hot.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/ones.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/open_files.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/pad.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/pad2d.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/pad_constant_like.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/piecewise_decay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/pixel_shuffle.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/polygon_box_transform.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/polynomial_decay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/pool2d.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/pool3d.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/pow.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/prelu.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/prior_box.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/psroi_pool.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/py_func.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/py_reader.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/random_crop.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/random_data_generator.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/range.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/rank.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/rank_loss.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/read_file.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/reciprocal.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/reduce_all.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/reduce_any.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/reduce_max.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/reduce_mean.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/reduce_min.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/reduce_prod.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/reduce_sum.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/relu.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/relu6.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/reorder_lod_tensor_by_rank.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/reshape.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/resize_bilinear.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/resize_nearest.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/retinanet_detection_output.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/retinanet_target_assign.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/reverse.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/roi_align.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/roi_perspective_transform.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/roi_pool.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/round.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/row_conv.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/rpn_target_assign.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/rsqrt.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sampling_id.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/scale.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/scatter.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/selu.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_concat.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_conv.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_enumerate.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_expand.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_expand_as.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_first_step.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_last_step.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_mask.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_pad.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_pool.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_reshape.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_reverse.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_scatter.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_slice.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_softmax.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sequence_unpad.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/shape.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/shuffle.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/shuffle_channel.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sigmoid.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sigmoid_focal_loss.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sign.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/similarity_focus.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sin.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/slice.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/smooth_l1.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/soft_relu.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/softmax.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/softmax_with_cross_entropy.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/softplus.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/softshrink.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/softsign.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/space_to_depth.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/spectral_norm.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/split.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sqrt.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/square.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/square_error_cost.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/squeeze.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/ssd_loss.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/stack.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/stanh.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sum.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/sums.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/swish.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/tanh.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/tanh_shrink.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/target_assign.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/teacher_student_sigmoid_loss.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/temporal_shift.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/tensor_array_to_tensor.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/thresholded_relu.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/topk.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/transpose.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/tree_conv.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/uniform_random.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/uniform_random_batch_size_like.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/unsqueeze.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/unstack.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/warpctc.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/where.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/yolo_box.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/yolov3_loss.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/zeros.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/layers/zeros_like.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/metrics.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/metrics/Accuracy.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/metrics/Auc.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/metrics/ChunkEvaluator.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/metrics/CompositeMetric.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/metrics/DetectionMAP.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/metrics/EditDistance.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/metrics/MetricBase.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/metrics/Precision.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/metrics/Recall.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/nets.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/nets/glu.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/nets/img_conv_group.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/nets/scaled_dot_product_attention.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/nets/sequence_conv_pool.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/nets/simple_img_conv_pool.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/Adadelta.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/Adagrad.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/AdagradOptimizer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/Adam.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/AdamOptimizer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/Adamax.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/AdamaxOptimizer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/DGCMomentumOptimizer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/DecayedAdagrad.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/DecayedAdagradOptimizer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/ExponentialMovingAverage.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/Ftrl.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/FtrlOptimizer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/LambOptimizer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/LarsMomentum.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/LarsMomentumOptimizer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/ModelAverage.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/Momentum.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/MomentumOptimizer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/PipelineOptimizer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/RMSPropOptimizer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/SGD.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/optimizer/SGDOptimizer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/param_attr.rst 已删除 100644 → 0
浏览文件 @ 1fe89e8a
此差异已折叠。
doc/fluid/api/profiler.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/profiler/cuda_profiler.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/profiler/profiler.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/profiler/reset_profiler.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/profiler/start_profiler.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/profiler/stop_profiler.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/recordio_writer.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/regularizer.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/regularizer/L1Decay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/regularizer/L1DecayRegularizer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/regularizer/L2Decay.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/regularizer/L2DecayRegularizer.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/transpiler.rst
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/transpiler/DistributeTranspiler.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/transpiler/DistributeTranspilerConfig.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/transpiler/HashName.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/transpiler/RoundRobin.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/transpiler/memory_optimize.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/transpiler/release_memory.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/unique_name.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/unique_name/generate.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/unique_name/guard.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api/unique_name/switch.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/average_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/average_cn/WeightedAverage_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/backward_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/backward_cn/append_backward_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/backward_cn/gradients_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/clip_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/clip_cn/ErrorClipByValue_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/clip_cn/GradientClipByNorm_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/clip_cn/GradientClipByValue_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data/data_reader_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data/data_reader_cn/DataFeeder_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data/data_reader_cn/Reader_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data/dataset_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data/dataset_cn/Conll05_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data/dataset_cn/cifar_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data/dataset_cn/imdb_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data/dataset_cn/imikolov_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data/dataset_cn/mnist_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data/dataset_cn/movielens_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data/dataset_cn/sentiment_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data/dataset_cn/uci_housing_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data/dataset_cn/wmt14_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data/dataset_cn/wmt16_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data_feeder_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/data_feeder_cn/DataFeeder_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dataset_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dataset_cn/DatasetFactory_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dataset_cn/InMemoryDataset_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dataset_cn/QueueDataset_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/BackwardStrategy_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/BatchNorm_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/Conv2DTranspose_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/Conv2D_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/Conv3DTranspose_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/Conv3D_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/CosineDecay_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/Embedding_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/ExponentialDecay_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/FC_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/GRUUnit_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/GroupNorm_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/InverseTimeDecay_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/LayerNorm_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/Layer_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/NCE_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/NaturalExpDecay_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/NoamDecay_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/PRelu_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/PiecewiseDecay_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/PolynomialDecay_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/Pool2D_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/SpectralNorm_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/TreeConv_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/guard_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/load_persistables_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/save_persistables_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/dygraph_cn/to_variable_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/executor_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/executor_cn/Executor_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/executor_cn/global_scope_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/executor_cn/scope_guard_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/BuildStrategy_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/CPUPlace_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/CUDAPinnedPlace_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/CUDAPlace_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/CompiledProgram_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/DataFeedDesc_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/DataFeeder_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/DistributeTranspiler_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/ExecutionStrategy_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/Executor_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/LoDTensorArray_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/LoDTensor_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/ParallelExecutor_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/ParamAttr_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/Program_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/Tensor_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/WeightNormParamAttr_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/cpu_places_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/create_lod_tensor_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/cuda_pinned_places_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/cuda_places_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/default_main_program_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/global_scope_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/gradients_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/in_dygraph_mode_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/memory_optimize_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/name_scope_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/program_guard_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/release_memory_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/fluid_cn/scope_guard_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/gen_index.py 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/index_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/initializer_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/initializer_cn/Bilinear_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/initializer_cn/Constant_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/initializer_cn/MSRAInitializer_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/initializer_cn/MSRA_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/initializer_cn/Normal_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/initializer_cn/TruncatedNormal_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/initializer_cn/Uniform_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/initializer_cn/Xavier_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/initializer_cn/init_on_cpu_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/io_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/io_cn/PyReader_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/io_cn/load_inference_model_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/io_cn/load_params_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/io_cn/load_persistables_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/io_cn/load_vars_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/io_cn/save_inference_model_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/io_cn/save_params_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/io_cn/save_persistables_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/io_cn/save_vars_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/DynamicRNN_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/IfElse_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/Preprocessor_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/Print_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/StaticRNN_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/Switch_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/While_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/abs_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/accuracy_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/acos_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/adaptive_pool2d_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/adaptive_pool3d_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/add_position_encoding_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/affine_channel_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/affine_grid_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/anchor_generator_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/argmax_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/argmin_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/argsort_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/array_length_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/array_read_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/array_write_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/asin_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/assign_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/atan_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/auc_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/batch_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/batch_norm_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/beam_search_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/beam_search_decode_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/bipartite_match_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/box_clip_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/box_coder_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/bpr_loss_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/brelu_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/cast_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/ceil_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/chunk_eval_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/clip_by_norm_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/clip_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/collect_fpn_proposals_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/concat_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/conv2d_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/conv2d_transpose_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/conv3d_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/conv3d_transpose_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/cos_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/cos_sim_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/cosine_decay_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/create_array_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/create_global_var_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/create_parameter_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/create_tensor_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/crf_decoding_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/crop_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/cross_entropy_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/ctc_greedy_decoder_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/cumsum_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/data_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/data_norm_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/deformable_conv_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/density_prior_box_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/detection_map_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/detection_output_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/diag_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/dice_loss_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/double_buffer_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/dropout_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/dynamic_gru_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/dynamic_lstm_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/dynamic_lstmp_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/edit_distance_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/elementwise_add_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/elementwise_div_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/elementwise_floordiv_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/elementwise_max_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/elementwise_min_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/elementwise_mod_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/elementwise_mul_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/elementwise_pow_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/elementwise_sub_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/elu_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/embedding_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/equal_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/exp_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/expand_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/exponential_decay_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/fc_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/fill_constant_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/flatten_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/floor_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/fsp_matrix_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/gather_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/gaussian_random_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/generate_mask_labels_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/generate_proposals_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/greater_equal_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/greater_than_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/grid_sampler_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/group_norm_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/gru_unit_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/hard_shrink_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/hard_sigmoid_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/has_inf_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/has_nan_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/hash_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/hsigmoid_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/huber_loss_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/im2sequence_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/image_resize_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/image_resize_short_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/increment_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/inverse_time_decay_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/iou_similarity_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/is_empty_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/isfinite_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/kldiv_loss_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/l2_normalize_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/label_smooth_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/layer_norm_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/leaky_relu_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/less_equal_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/less_than_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/linear_chain_crf_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/linear_lr_warmup_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/linspace_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/load_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/lod_reset_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/log_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/log_loss_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/logical_and_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/logical_not_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/logical_or_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/logical_xor_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/logsigmoid_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/lrn_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/lstm_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/lstm_unit_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/margin_rank_loss_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/matmul_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/maxout_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/mean_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/mean_iou_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/merge_selected_rows_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/mul_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/multi_box_head_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/multiclass_nms_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/multiplex_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/natural_exp_decay_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/nce_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/noam_decay_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/not_equal_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/npair_loss_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/one_hot_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/ones_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/open_files_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/pad2d_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/pad_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/pad_constant_like_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/piecewise_decay_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/pixel_shuffle_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/polygon_box_transform_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/polynomial_decay_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/pool2d_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/pool3d_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/pow_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/prelu_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/prior_box_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/psroi_pool_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/py_func_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/py_reader_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/random_crop_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/random_data_generator_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/range_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/rank_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/rank_loss_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/read_file_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/reciprocal_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/reduce_all_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/reduce_any_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/reduce_max_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/reduce_mean_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/reduce_min_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/reduce_prod_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/reduce_sum_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/relu6_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/relu_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/reshape_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/resize_bilinear_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/resize_nearest_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/reverse_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/roi_align_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/roi_pool_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/round_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/row_conv_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/rpn_target_assign_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/rsqrt_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sampling_id_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/scale_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/scatter_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/selu_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_concat_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_conv_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_enumerate_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_expand_as_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_expand_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_first_step_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_last_step_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_mask_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_pad_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_pool_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_reshape_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_reverse_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_scatter_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_slice_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_softmax_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sequence_unpad_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/shape_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/shuffle_channel_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/shuffle_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sigmoid_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sigmoid_focal_loss_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sign_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/similarity_focus_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sin_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/slice_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/smooth_l1_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/soft_relu_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/softmax_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/softplus_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/softshrink_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/softsign_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/space_to_depth_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/spectral_norm_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/split_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sqrt_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/square_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/square_error_cost_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/squeeze_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/ssd_loss_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/stack_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/stanh_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sum_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/sums_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/swish_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/tanh_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/tanh_shrink_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/target_assign_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/temporal_shift_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
doc/fluid/api_cn/layers_cn/thresholded_relu_cn.rst 0 → 100644
浏览文件 @ 2b2d0133
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或