Merge remote-tracking branch 'upstream/develop' into fleet20_api_cn

ci_scripts/api_white_list.txt

@@ -7,3 +7,13 @@ paddle/optimizer/Dpsgd_cn.rst
 paddle/reader/ComposeNotAligned_cn.rst
 paddle/fluid/layers/scatter_cn.rst
 paddle/tensor/manipulation/scatter_cn.rst
+paddle/distributed/fleet/Fleet_cn.rst
+paddle/distributed/fleet/utils/fs/ExecuteError_cn.rst
+paddle/distributed/fleet/utils/fs/FSFileExistsError_cn.rst
+paddle/distributed/fleet/utils/fs/FSFileNotExistsError_cn.rst
+paddle/distributed/fleet/utils/fs/FSShellCmdAborted_cn.rst
+paddle/distributed/fleet/utils/fs/FSTimeOut_cn.rst
+paddle/distributed/fleet/utils/fs/FS_cn.rst
+paddle/distributed/fleet/utils/fs/HDFSClient_cn.rst
+paddle/distributed/fleet/utils/fs/LocalFS_cn.rst
+upgrade_guide_cn.md

ci_scripts/check_api_cn.sh

 #!/bin/bash
+set -x
 
-git_files=`git diff --numstat upstream/$BRANCH | awk '{print $NF}'`
+function build_paddle() {
+    git clone https://github.com/PaddlePaddle/Paddle.git
+    mkdir Paddle/build
+    cd Paddle/build
 
-for file in `echo $git_files`;do
+    cmake .. -DWITH_GPU=ON  -DWITH_COVERAGE=OFF -DWITH_TESTING=OFF -DCMAKE_BUILD_TYPE=Release
+    make -j`nproc`
+    pip install -U python/dist/paddlepaddle_gpu-0.0.0-cp27-cp27mu-linux_x86_64.whl
+
+    cd -
+}
+
+need_check_files=""
+function find_need_check_files() {
+    git_files=`git diff --numstat upstream/$BRANCH | awk '{print $NF}'`
+
+    for file in `echo $git_files`;do
         grep "code-block" ../$file
         if [ $? -eq 0 ] ;then 
             echo $file | grep "doc/paddle/api/paddle/.*_cn.rst"
@@ -10,13 +25,48 @@ for file in `echo $git_files`;do
                 api_file=`echo $file | sed 's#doc/paddle/api/##g'`
                 grep -w "${api_file}" ${DIR_PATH}/api_white_list.txt
                 if [ $? -ne 0 ];then
+                    need_check_files="${need_check_files} $file"
+                fi 
+            fi
+        fi
+    done
+}
+
+
+need_check_cn_doc_files=`git diff --numstat upstream/$BRANCH | awk '{print $NF}' | grep "doc/paddle/api/paddle/.*_cn.rst" | sed 's#doc/##g'` 
+echo $need_check_cn_doc_files
+find_need_check_files
+if [ "$need_check_files" = "" -a "$need_check_cn_doc_files" = "" ]
+then
+    echo "need check files is empty, skip chinese api check"
+else
+    echo "need check files is not empty, begin to build and install paddle"
+    build_paddle
+    if [ $? -ne 0 ];then
+      echo "paddle build error"
+      exit 5
+    fi
+
+   if [ "${need_check_files}" != "" ]; then
+        for file in $need_check_files;do
             python chinese_samplecode_processor.py ../$file
             if [ $? -ne 0 ];then
-                echo "chinese sample code failed"
+                echo "chinese sample code failed, the file is ${file}"
                 exit 5
             fi
+        done
     fi
+
+    if [ "${need_check_cn_doc_files}" != "" ];then
+        cd ../doc/paddle/api
+        python gen_doc.py
+        cd -
+
+        for file in $need_check_cn_doc_files; do
+            cat ../doc/paddle/api/en_cn_files_diff | awk '{print $1}' | grep ${file}
+            if [ $? -eq 0 ];then
+                echo "Chinese doc file exist, but the Englist doc does not exist, the Chinese file is ${file}"
             fi
+        done
     fi
-done
-
+fi

ci_scripts/checkapproval.sh

 #!/bin/bash
 
+set -x
+
 API_FILES=("doc/paddle/api/paddle")
 
 for API_FILE in ${API_FILES[*]}; do

doc/fluid/advanced_guide/dygraph_to_static/program_translator_cn.rst

@@ -60,7 +60,7 @@ trace是指在模型运行时记录下其运行过哪些算子。TracedLayer就
 
     place = paddle.CPUPlace()
     exe = paddle.Executor(place)
-    program, feed_vars, fetch_vars = paddle.io.load_inference_model(save_dirname, exe)
+    program, feed_vars, fetch_vars = paddle.static.load_inference_model(save_dirname, exe)
     fetch, = exe.run(program, feed={feed_vars[0]: in_np}, fetch_list=fetch_vars)
 
 

doc/fluid/advanced_guide/dygraph_to_static/program_translator_en.rst

@@ -60,7 +60,7 @@ Load model and run it in static graph mode:
 
     place = paddle.CPUPlace()
     exe = paddle.Executor(place)
-    program, feed_vars, fetch_vars = paddle.io.load_inference_model(save_dirname, exe)
+    program, feed_vars, fetch_vars = paddle.static.load_inference_model(save_dirname, exe)
     fetch, = exe.run(program, feed={feed_vars[0]: in_np}, fetch_list=fetch_vars)
 
 However, as tracing only records operators once, if user's code contains Tensor-dependent (including Tensor value or Tensor shape) control flow, that is the Tensor can cause different operators being executed, then TracedLayer cannot handle this case. For instance:

doc/fluid/api/data/dataset.rst

@@ -10,7 +10,6 @@ dataset
     dataset/imdb.rst
     dataset/imikolov.rst
     dataset/movielens.rst
-    dataset/sentiment.rst
     dataset/uci_housing.rst
     dataset/wmt14.rst
     dataset/wmt16.rst

doc/fluid/api/data/dataset/sentiment.rst

-sentiment
-+++++++++
-
-..  automodule:: paddle.dataset.sentiment
-    :members:
-    :noindex:

doc/fluid/api/io.rst

 ========
-paddle.io
+fluid.io
 ========
 
 ..  toctree::
@@ -7,14 +7,10 @@ paddle.io
 
     io/batch.rst
     io/BatchSampler.rst
-    io/buffered.rst
-    io/cache.rst
-    io/chain.rst
-    io/compose.rst
     io/ComposeNotAligned.rst
     io/DataLoader.rst
     io/Dataset.rst
-    io/firstn.rst
+    io/default_collate_fn.rst
     io/get_program_parameter.rst
     io/get_program_persistable_vars.rst
     io/load.rst
@@ -23,17 +19,10 @@ paddle.io
     io/load_persistables.rst
     io/load_program_state.rst
     io/load_vars.rst
-    io/map_readers.rst
-    io/multiprocess_reader.rst
     io/PyReader.rst
     io/save.rst
     io/save_inference_model.rst
-    io/save_inference_model.rst
     io/save_params.rst
     io/save_persistables.rst
     io/save_vars.rst
     io/set_program_state.rst
-    io/set_program_state.rst
-    io/shuffle.rst
-    io/shuffle.rst
-    io/xmap_readers.rst

doc/fluid/api/io/buffered.rst

-..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
-    !DO NOT EDIT THIS FILE MANUALLY!
-
-.. _api_fluid_io_buffered:
-
-buffered
---------
-
-..  autofunction:: paddle.fluid.io.buffered
-    :noindex:
-

doc/fluid/api/io/cache.rst

-..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
-    !DO NOT EDIT THIS FILE MANUALLY!
-
-.. _api_fluid_io_cache:
-
-cache
------
-
-..  autofunction:: paddle.fluid.io.cache
-    :noindex:
-

doc/fluid/api/io/chain.rst

-..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
-    !DO NOT EDIT THIS FILE MANUALLY!
-
-.. _api_fluid_io_chain:
-
-chain
------
-
-..  autofunction:: paddle.fluid.io.chain
-    :noindex:
-

doc/fluid/api/io/compose.rst → doc/fluid/api/io/default_collate_fn.rst

 ..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
     !DO NOT EDIT THIS FILE MANUALLY!
 
-.. _api_fluid_io_compose:
+.. _api_fluid_io_default_collate_fn:
 
-compose
--------
+default_collate_fn
+------------------
 
-..  autofunction:: paddle.fluid.io.compose
+..  autofunction:: paddle.fluid.io.default_collate_fn
     :noindex:
 

doc/fluid/api/io/firstn.rst

-..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
-    !DO NOT EDIT THIS FILE MANUALLY!
-
-.. _api_fluid_io_firstn:
-
-firstn
-------
-
-..  autofunction:: paddle.fluid.io.firstn
-    :noindex:
-

doc/fluid/api/io/map_readers.rst

-..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
-    !DO NOT EDIT THIS FILE MANUALLY!
-
-.. _api_fluid_io_map_readers:
-
-map_readers
------------
-
-..  autofunction:: paddle.fluid.io.map_readers
-    :noindex:
-

doc/fluid/api/io/multiprocess_reader.rst

-..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
-    !DO NOT EDIT THIS FILE MANUALLY!
-
-.. _api_fluid_io_multiprocess_reader:
-
-multiprocess_reader
--------------------
-
-..  autofunction:: paddle.fluid.io.multiprocess_reader
-    :noindex:
-

doc/fluid/api/io/shuffle.rst

-..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
-    !DO NOT EDIT THIS FILE MANUALLY!
-
-.. _api_fluid_io_shuffle:
-
-shuffle
--------
-
-..  autofunction:: paddle.fluid.io.shuffle
-    :noindex:
-

doc/fluid/api/io/xmap_readers.rst

-..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
-    !DO NOT EDIT THIS FILE MANUALLY!
-
-.. _api_fluid_io_xmap_readers:
-
-xmap_readers
-------------
-
-..  autofunction:: paddle.fluid.io.xmap_readers
-    :noindex:
-

doc/fluid/api_cn/data/dataset_cn.rst

@@ -14,7 +14,6 @@ dataset
     dataset_cn/imdb_cn.rst
     dataset_cn/imikolov_cn.rst
     dataset_cn/movielens_cn.rst
-    dataset_cn/sentiment_cn.rst
     dataset_cn/uci_housing_cn.rst
     dataset_cn/wmt14_cn.rst
     dataset_cn/wmt16_cn.rst

doc/fluid/api_cn/data/dataset_cn/sentiment_cn.rst

-.. _cn_api_paddle_dataset_sentiment:
-
-sentiment
--------------------------------
-
-脚本获取并预处理由NLTK提供的movie_reviews数据集。
-
-
-.. py:function:: paddle.dataset.sentiment.get_word_dict()
-
-按照样本中出现的单词的频率对单词进行排序。
-
-返回： words_freq_sorted
-
-.. py:function:: paddle.dataset.sentiment.train()
-
-默认的训练集reader creator。
-
-.. py:function:: paddle.dataset.sentiment.test()
-
-默认的测试集reader creator。
-
-.. py:function:: paddle.dataset.sentiment.convert(path)
-
-将数据集转换为recordio格式。
-
-
-

doc/fluid/api_cn/fluid_cn/save_cn.rst

@@ -7,8 +7,8 @@ save
 .. py:function:: paddle.fluid.save(program, model_path)
 
 :api_attr: 声明式编程模式（静态图)
-:alias_main: paddle.save
-:alias: paddle.save,paddle.tensor.save,paddle.tensor.io.save
+:alias_main: paddle.static.save
+:alias: paddle.static.save
 :old_api: paddle.fluid.save
 
 

doc/fluid/api_cn/io_cn/load_cn.rst

@@ -6,8 +6,8 @@ load
 .. py:function:: paddle.fluid.io.load(program, model_path, executor=None, var_list=None)
 
 :api_attr: 声明式编程模式（静态图)
-:alias_main: paddle.load
-:alias: paddle.load,paddle.tensor.load,paddle.tensor.io.load
+:alias_main: paddle.static.load
+:alias: paddle.static.load
 :old_api: paddle.fluid.io.load
 
 

doc/fluid/api_cn/layers_cn/add_position_encoding_cn.rst

@@ -40,13 +40,13 @@ add_position_encoding
 
 .. code-block:: python
 
-    import paddle.fluid as fluid
+    import numpy as np
+    import paddle
+    import paddle.nn.functional as F
 
-    tensor = fluid.data(
-        name='tensor',
-        shape=[None, 64, 512],
-        dtype='float32')
-    position_tensor = fluid.layers.add_position_encoding(
+    tensor = np.random.randn(16, 32, 64) 
+    tensor = paddle.to_tensor(tensor)
+    position_tensor = F.add_position_encoding(
         input=tensor, alpha=1.0, beta=1.0)
 
 

doc/fluid/api_cn/layers_cn/warpctc_cn.rst

@@ -14,7 +14,7 @@ warpctc
 该OP用于计算 `CTC loss <https://www.cs.toronto.edu/~graves/icml_2006.pdf>`_ 。该OP的底层调用了第三方 `baidu-research::warp-ctc <https://github.com/baidu-research/warp-ctc>`_ 的实现。
 
 参数：
-    - **input** (Variable) - 可以是3-D Tensor或2-D LoDTensor。当输入类型是3-D Tensor时，则表示输入是经过padding的定长序列，其 shape 必须是 ``[seq_length, batch_size, num_classes + 1]`` 。当输入类型是2-D LoDTensor时，则表示输入为变长序列，其shape必须为 ``[Lp，num_classes+1]`` ， ``Lp`` 是所有输入序列长度之和。以上 shape 中的 ``num_classes`` 是实际类别数，不包括空白标签。该输入不需要经过 softmax 操作，因为该OP的内部对 ``input`` 做了 softmax 操作。数据类型仅支持float32。
+    - **input** (Variable) - 可以是3-D Tensor或2-D LoDTensor。当输入类型是3-D Tensor时，则表示输入是经过padding的定长序列，其 shape 必须是 ``[seq_length, batch_size, num_classes + 1]`` 。当输入类型是2-D LoDTensor时，则表示输入为变长序列，其shape必须为 ``[Lp，num_classes+1]`` ， ``Lp`` 是所有输入序列长度之和。以上 shape 中的 ``num_classes`` 是实际类别数，不包括空白标签。该输入不需要经过 softmax 操作，因为该OP的内部对 ``input`` 做了 softmax 操作。数据类型支持 float32 和 float64。
     - **label** (Variable) - 可以是3-D Tensor或2-D LoDTensor，需要跟 ``input`` 保持一致。当输入类型为3-D Tensor时，表示输入是经过 padding 的定长序列，其 shape 为 ``[batch_size, label_length]`` ，其中， ``label_length`` 是最长的 label 序列的长度。当输入类型是2-D LoDTensor时，则表示输入为变长序列，其shape必须为 ``[Lp, 1]`` ， 其中 ``Lp`` 是所有 label 序列的长度和。 ``label`` 中的数值为字符ID。数据类型支持int32。 
     - **blank** (int，可选) - 空格标记的ID，其取值范围为 ``[0，num_classes+1)`` 。数据类型支持int32。缺省值为0。
     - **norm_by_times** (bool，可选) - 是否根据序列长度对梯度进行正则化。数据类型支持 bool 。缺省值为False。 

doc/fluid/api_cn/nn_cn/functional_cn/ctc_loss_cn.rst

@@ -8,7 +8,7 @@ ctc_loss
 
 参数
 :::::::::
-    - **log_probs** (Tensor): - 经过 padding 的概率序列，其 shape 必须是 [max_logit_length, batch_size, num_classes + 1]。其中 max_logit_length 是最长输入序列的长度。该输入不需要经过 softmax 操作，因为该 OP 的内部对 input 做了 softmax 操作。数据类型仅支持float32。
+    - **log_probs** (Tensor): - 经过 padding 的概率序列，其 shape 必须是 [max_logit_length, batch_size, num_classes + 1]。其中 max_logit_length 是最长输入序列的长度。该输入不需要经过 softmax 操作，因为该 OP 的内部对 input 做了 softmax 操作。数据类型支持 float32 和 float64。
     - **labels** (Tensor): - 经过 padding 的标签序列，其 shape 为 [batch_size, max_label_length]，其中 max_label_length 是最长的 label 序列的长度。数据类型支持int32。
     - **input_lengths** (Tensor): - 表示输入 ``log_probs`` 数据中每个序列的长度，shape为 [batch_size] 。数据类型支持int64。
     - **label_lengths** (Tensor): - 表示 label 中每个序列的长度，shape为 [batch_size] 。数据类型支持int64。

doc/fluid/api_cn/nn_cn/loss_cn/CTCLoss_cn.rst

@@ -13,7 +13,7 @@ CTCLoss
 
 形状
 :::::::::
-    - **log_probs** (Tensor): - 经过 padding 的概率序列，其 shape 必须是 [max_logit_length, batch_size, num_classes + 1]。其中 max_logit_length 是最长输入序列的长度。该输入不需要经过 softmax 操作，因为该 OP 的内部对 input 做了 softmax 操作。数据类型仅支持float32。
+    - **log_probs** (Tensor): - 经过 padding 的概率序列，其 shape 必须是 [max_logit_length, batch_size, num_classes + 1]。其中 max_logit_length 是最长输入序列的长度。该输入不需要经过 softmax 操作，因为该 OP 的内部对 input 做了 softmax 操作。数据类型支持 float32 和 float64。
     - **labels** (Tensor): - 经过 padding 的标签序列，其 shape 为 [batch_size, max_label_length]，其中 max_label_length 是最长的 label 序列的长度。数据类型支持int32。
     - **input_lengths** (Tensor): - 表示输入 ``log_probs`` 数据中每个序列的长度，shape为 [batch_size] 。数据类型支持int64。
     - **label_lengths** (Tensor): - 表示 label 中每个序列的长度，shape为 [batch_size] 。数据类型支持int64。

doc/fluid/beginners_guide/coding_practice/save_load_variables.rst

@@ -204,8 +204,8 @@ save_vars、save_params、save_persistables 以及 save_inference_model的区别
     path = "./models"
     startup_prog = fluid.default_startup_program()
     exe.run(startup_prog)
+    fluid.io.load_persistables(exe, path, startup_prog)
     main_prog = fluid.default_main_program()
-    fluid.io.load_persistables(exe, path, main_prog)
     exe.run(main_prog)
 
 上面的例子中，通过调用 :code:`fluid.io.load_persistables` 函数，PaddlePaddle Fluid会从默认
@@ -270,12 +270,12 @@ save_vars、save_params、save_persistables 以及 save_inference_model的区别
     pserver_endpoints = "127.0.0.1:1001,127.0.0.1:1002"
     trainers = 4
     training_role == "PSERVER"
+    current_endpoint = "127.0.0.1:1002"
     config = fluid.DistributeTranspilerConfig()
     t = fluid.DistributeTranspiler(config=config)
     t.transpile(trainer_id, pservers=pserver_endpoints, trainers=trainers, sync_mode=True, current_endpoint=current_endpoint)
 
     if training_role == "PSERVER":
-        current_endpoint = "127.0.0.1:1001"
         pserver_prog = t.get_pserver_program(current_endpoint)
         pserver_startup = t.get_startup_program(current_endpoint, pserver_prog)
 

doc/fluid/beginners_guide/coding_practice/save_load_variables_en.rst

@@ -27,23 +27,6 @@ How to save model variables
 
 The model variables we need to save are different depending on the application. For example, if we just want to save the model for future predictions, just saving the model parameters will be enough. But if we need to save a checkpoint for future recovery of current training, then we should save all the persistable variables, and even record the current epoch and step id. It is because even though some model variables are not parameters, they are still essential for model training.
 
-
-Difference between save_vars、save_params、save_persistables and save_inference_model
-##########################################################################
-1. :code:`save_inference_model` will prune the inference model based on :code:`feeded_var_names` and :code:`target_vars` , this method will save the ``__model__`` file of the pruned program and the persistable variables in the program.
-
-2. :code:`save_persistables` this method will not save model, it will save all the persistable variables in the program.
-
-3. :code:`save_params` this method will not save model, it will save all the parameters in the program.
-
-4. :code:`save_vars` this method will not save model, it will save the given parameter by user.
-
- :code:`save_persistables` this method is useful for increment training or checkpoint training, it can save persistable variables in program comprehensively, such as parameter variables, optimizer variables, if you need increment training or checkpoint training, please choose this one. 
- :code:`save_inference_model` this method  is useful for inference, it will save persistable variables and pruned program, if you need program and variables for follow-up  high performance inference, please choose this one.
-
- :code:`save_vars 和 save_params` there methods are only needed in particular cases, we suppose you already know the purpose of there APIs, there are not recommended for use normally.
-
-
 Save the model to make prediction for new samples
 ===================================================
 
@@ -143,8 +126,8 @@ In the above example, by calling the :code:`fluid.io.save_persistables` function
     path = "./models"
     startup_prog = fluid.default_startup_program()
     exe.run(startup_prog)
+    fluid.io.load_persistables(exe, path, startup_prog)
     main_prog = fluid.default_main_program()
-    fluid.io.load_persistables(exe, path, main_prog)
     exe.run(main_prog)
     
 In the above example, by calling the :code:`fluid.io.load_persistables` function, PaddlePaddle Fluid will find persistable variables from all model variables in the default :code:`fluid.Program` , e.t. :code:`prog` . and load them one by one from the specified :code:`path` directory to continue training.
@@ -199,12 +182,12 @@ For the PServer to be loaded with parameters during training, for example:
     pserver_endpoints = "127.0.0.1:1001,127.0.0.1:1002"
     trainers = 4
     Training_role == "PSERVER"
+    current_endpoint = "127.0.0.1:1002"
     config = fluid.DistributeTranspilerConfig()
     t = fluid.DistributeTranspiler(config=config)
-	t.transpile(trainer_id, pservers=pserver_endpoints, trainers=trainers, sync_mode=True)
+    t.transpile(trainer_id, pservers=pserver_endpoints, trainers=trainers, sync_mode=True, current_endpoint=current_endpoint)
     
     if training_role == "PSERVER":
-		current_endpoint = "127.0.0.1:1001"
         pserver_prog = t.get_pserver_program(current_endpoint)
         pserver_startup = t.get_startup_program(current_endpoint, pserver_prog)
     

doc/fluid/beginners_guide/dygraph/DyGraph.md

@@ -551,7 +551,7 @@ static_layer.save_inference_model(save_dirname, feed=[0], fetch=[0])
 # 声明式编程中需要使用执行器执行之前已经定义好的网络
 place = paddle.CPUPlace()
 exe = paddle.Executor(place)
-program, feed_vars, fetch_vars = paddle.io.load_inference_model(save_dirname, exe)
+program, feed_vars, fetch_vars = paddle.static.load_inference_model(save_dirname, exe)
 # 声明式编程中需要调用执行器的run方法执行计算过程
 fetch, = exe.run(program, feed={feed_vars[0]: in_np}, fetch_list=fetch_vars)
 ```

doc/paddle/advanced_guide/inference_deployment/inference/build_and_install_lib_cn.rst

@@ -7,16 +7,16 @@
 -------------
 
 ..  csv-table:: 
-    :header: "版本说明", "预测库(1.8.3版本)", "预测库(develop版本)"
-    :widths: 3, 2, 2
+    :header: "版本说明", "预测库(1.8.4版本)", "预测库(2.0.0-beta0版本)", "预测库(develop版本)"
+    :widths: 3, 2, 2, 2
 
-    "ubuntu14.04_cpu_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.3-cpu-avx-mkl/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-avx-mkl/fluid_inference.tgz>`_"
-    "ubuntu14.04_cpu_avx_openblas", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.3-cpu-avx-openblas/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-avx-openblas/fluid_inference.tgz>`_"
-    "ubuntu14.04_cpu_noavx_openblas", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.3-cpu-noavx-openblas/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-noavx-openblas/fluid_inference.tgz>`_"
-    "ubuntu14.04_cuda9.0_cudnn7_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.3-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>`_"
-    "ubuntu14.04_cuda10.0_cudnn7_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.3-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>`_"
-    "ubuntu14.04_cuda10.1_cudnn7.6_avx_mkl_trt6", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.3-gpu-cuda10.1-cudnn7.6-avx-mkl-trt6%2Ffluid_inference.tgz>`_", 
-    "nv-jetson-cuda10-cudnn7.5-trt5", "`fluid_inference.tar.gz <https://paddle-inference-lib.bj.bcebos.com/1.7.1-nv-jetson-cuda10-cudnn7.5-trt5/fluid_inference.tar.gz>`_", 
+    "ubuntu14.04_cpu_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.4-cpu-avx-mkl/fluid_inference.tgz>`_", "`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/2.0.0-beta0-cpu-avx-mkl/paddle_inference.tgz>`_", "`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-avx-mkl/paddle_inference.tgz>`_"
+    "ubuntu14.04_cpu_avx_openblas", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.4-cpu-avx-openblas/fluid_inference.tgz>`_", ,"`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-avx-openblas/paddle_inference.tgz>`_"
+    "ubuntu14.04_cpu_noavx_openblas", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.4-cpu-noavx-openblas/fluid_inference.tgz>`_", ,"`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-noavx-openblas/paddle_inference.tgz>`_"
+    "ubuntu14.04_cuda9.0_cudnn7_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.4-gpu-cuda9-cudnn7-avx-mkl/fluid_inference.tgz>`_", "`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/2.0.0-beta0-gpu-cuda9-cudnn7-avx-mkl/paddle_inference.tgz>`_", "`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-gpu-cuda9-cudnn7-avx-mkl/paddle_inference.tgz>`_"
+    "ubuntu14.04_cuda10.0_cudnn7_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.4-gpu-cuda10-cudnn7-avx-mkl/fluid_inference.tgz>`_", "`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/2.0.0-beta0-gpu-cuda10-cudnn7-avx-mkl/paddle_inference.tgz>`_", "`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-gpu-cuda10-cudnn7-avx-mkl/paddle_inference.tgz>`_"
+    "ubuntu14.04_cuda10.1_cudnn7.6_avx_mkl_trt6", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.4-gpu-cuda10.1-cudnn7.6-avx-mkl-trt6%2Ffluid_inference.tgz>`_", "`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/2.0.0-beta0-gpu-cuda10.1-cudnn7.6-avx-mkl-trt6%2Fpaddle_inference.tgz>`_", 
+    "nv-jetson-cuda10-cudnn7.5-trt5", "`fluid_inference.tar.gz <https://paddle-inference-lib.bj.bcebos.com/1.7.1-nv-jetson-cuda10-cudnn7.5-trt5/fluid_inference.tar.gz>`_", "`paddle_inference.tar.gz <https://paddle-inference-lib.bj.bcebos.com/2.0.0-beta0-nv-jetson-cuda10-cudnn7.5-trt5/paddle_inference.tgz>`_",
 
 
 从源码编译
@@ -46,7 +46,7 @@ WITH_NV_JETSON                OFF            在NV Jetson硬件上编译时需
   git clone https://github.com/paddlepaddle/Paddle
   cd Paddle
   # 建议使用git checkout切换到Paddle稳定的版本，如：
-  git checkout v1.7.2
+  git checkout v1.8.4
 
 **note**: 如果您是多卡机器，建议安装NCCL；如果您是单卡机器则可以在编译时显示指定WITH_NCCL=OFF来跳过这一步。注意如果WITH_NCCL=ON，且没有安装NCCL，则编译会报错。
 
@@ -188,3 +188,4 @@ version.txt 中记录了该预测库的版本信息，包括Git Commit ID、使
      WITH_GPU: ON
      CUDA version: 10.1
      CUDNN version: v7
+

doc/paddle/advanced_guide/inference_deployment/inference/build_and_install_lib_en.rst

@@ -7,16 +7,16 @@ Direct Download and Installation
 ---------------------------------
 
 ..  csv-table:: c++ inference library list
-    :header: "version description", "inference library(1.8.3 version)", "inference library(develop version)"
-    :widths: 3, 2, 2
+    :header: "version description", "inference library(1.8.4 version)", "inference library(2.0.0-beta0 version)", "inference library(develop version)"
+    :widths: 3, 2, 2, 2
 
-    "ubuntu14.04_cpu_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.3-cpu-avx-mkl/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-avx-mkl/fluid_inference.tgz>`_"
-    "ubuntu14.04_cpu_avx_openblas", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.3-cpu-avx-openblas/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-avx-openblas/fluid_inference.tgz>`_"
-    "ubuntu14.04_cpu_noavx_openblas", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.3-cpu-noavx-openblas/fluid_inference.tgz>`_", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-noavx-openblas/fluid_inference.tgz>`_"
-    "ubuntu14.04_cuda9.0_cudnn7_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.3-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>`_"
-    "ubuntu14.04_cuda10.0_cudnn7_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.3-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>`_"
-    "ubuntu14.04_cuda10.1_cudnn7.6_avx_mkl_trt6", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.3-gpu-cuda10.1-cudnn7.6-avx-mkl-trt6%2Ffluid_inference.tgz>`_", 
-    "nv-jetson-cuda10-cudnn7.5-trt5", "`fluid_inference.tar.gz <https://paddle-inference-lib.bj.bcebos.com/1.7.1-nv-jetson-cuda10-cudnn7.5-trt5/fluid_inference.tar.gz>`_", 
+    "ubuntu14.04_cpu_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.4-cpu-avx-mkl/fluid_inference.tgz>`_", "`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/2.0.0-beta0-cpu-avx-mkl/paddle_inference.tgz>`_", "`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-avx-mkl/paddle_inference.tgz>`_"
+    "ubuntu14.04_cpu_avx_openblas", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.4-cpu-avx-openblas/fluid_inference.tgz>`_", ,"`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-avx-openblas/paddle_inference.tgz>`_"
+    "ubuntu14.04_cpu_noavx_openblas", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.4-cpu-noavx-openblas/fluid_inference.tgz>`_", ,"`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-cpu-noavx-openblas/paddle_inference.tgz>`_"
+    "ubuntu14.04_cuda9.0_cudnn7_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.4-gpu-cuda9-cudnn7-avx-mkl/fluid_inference.tgz>`_", "`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/2.0.0-beta0-gpu-cuda9-cudnn7-avx-mkl/paddle_inference.tgz>`_", "`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-gpu-cuda9-cudnn7-avx-mkl/paddle_inference.tgz>`_"
+    "ubuntu14.04_cuda10.0_cudnn7_avx_mkl", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.4-gpu-cuda10-cudnn7-avx-mkl/fluid_inference.tgz>`_", "`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/2.0.0-beta0-gpu-cuda10-cudnn7-avx-mkl/paddle_inference.tgz>`_", "`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/latest-gpu-cuda10-cudnn7-avx-mkl/paddle_inference.tgz>`_"
+    "ubuntu14.04_cuda10.1_cudnn7.6_avx_mkl_trt6", "`fluid_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/1.8.4-gpu-cuda10.1-cudnn7.6-avx-mkl-trt6%2Ffluid_inference.tgz>`_", "`paddle_inference.tgz <https://paddle-inference-lib.bj.bcebos.com/2.0.0-beta0-gpu-cuda10.1-cudnn7.6-avx-mkl-trt6%2Fpaddle_inference.tgz>`_",
+    "nv-jetson-cuda10-cudnn7.5-trt5", "`fluid_inference.tar.gz <https://paddle-inference-lib.bj.bcebos.com/1.7.1-nv-jetson-cuda10-cudnn7.5-trt5/fluid_inference.tar.gz>`_", "`paddle_inference.tar.gz <https://paddle-inference-lib.bj.bcebos.com/2.0.0-beta0-nv-jetson-cuda10-cudnn7.5-trt5/paddle_inference.tgz>`_",
 
 Build from Source Code
 -----------------------
@@ -46,8 +46,8 @@ Firstly we pull the latest code from github.
 
   git clone https://github.com/paddlepaddle/Paddle
   cd Paddle
-  # Use git checkout to switch to stable versions such as v1.7.2
-  git checkout v1.7.2
+  # Use git checkout to switch to stable versions such as v1.8.4
+  git checkout v1.8.4
 
 
 **note**: If your environment is a multi-card machine, it is recommended to install nccl; otherwise, you can skip this step by specifying WITH_NCCL = OFF during compilation. Note that if WITH_NCCL = ON, and NCCL is not installed, the compiler will report an error.
@@ -202,3 +202,4 @@ The version information of the inference library is recorded in version.txt, inc
      WITH_GPU: ON
      CUDA version: 8.0
      CUDNN version: v7
+

doc/paddle/advanced_guide/inference_deployment/inference/python_infer_cn.md

 # Python 预测 API介绍
 
-Fluid提供了高度优化的[C++预测库](./native_infer.html)，为了方便使用，我们也提供了C++预测库对应的Python接口，下面是详细的使用说明。
-
+Paddle提供了高度优化的[C++预测库](./native_infer.html)，为了方便使用，我们也提供了C++预测库对应的Python接口，下面是详细的使用说明。
 
+如果您在使用2.0之前的Paddle，请参考[旧版API](https://www.paddlepaddle.org.cn/documentation/docs/zh/1.8/advanced_guide/inference_deployment/inference/python_infer_cn.html)文档。
 
 ## Python预测相关数据结构
 
-使用Python预测API与C++预测API相似，主要包括`PaddleTensor`, `PaddleDType`, `AnalysisConfig`和`PaddlePredictor`，分别对应于C++ API中同名的类型。
+使用Python预测API与C++预测API相似，主要包括`Tensor`, `DataType`, `Config`和`Predictor`，分别对应于C++ API中同名的类型。
 
-### PaddleTensor
+### DataType
 
-class paddle.fluid.core.PaddleTensor
+class paddle.inference.DataType
 
-`PaddleTensor`是预测库输入和输出的数据结构，包括以下字段
+`DataType`定义了`Tensor`的数据类型，由传入`Tensor`的numpy数组类型确定，包括以下成员
 
-* `name`(str): 指定输入的名称
-* `shape`(tuple|list): Tensor的shape
-* `data`(numpy.ndarray): Tensor的数据，可在PaddleTensor构造的时候用`numpy.ndarray`直接传入
-* `dtype`(PaddleDType): Tensor的类型
-* `lod`(List[List[int]]): [LoD](../../../user_guides/howto/basic_concept/lod_tensor.html)信息
+* `INT64`: 64位整型
+* `INT32`: 32位整型
+* `FLOAT32`: 32位浮点型
 
-`PaddleTensor`包括以下方法
+### PrecisionType
 
-* `as_ndarray`: 返回`data`对应的numpy数组
+class paddle.3.inference.PrecisionType
 
-#### 代码示例
-``` python
-tensor = PaddleTensor(name="tensor", data=numpy.array([1, 2, 3], dtype="int32"))
-```
-调用`PaddleTensor`的成员字段和方法输出如下：
-``` python
->>> tensor.name
-'tensor'
->>> tensor.shape
-[3]
->>> tensor.dtype
-PaddleDType.INT32
->>> tensor.lod
-[]
->>> tensor.as_ndarray()
-array([1, 2, 3], dtype=int32)
-```
+`PrecisionType`定义了`Predictor`运行的精度模式，包括一下成员
 
+* `Float32`: fp32模式运行
+* `Half`: fp16模式运行
+* `Int8`: int8模式运行
 
-### PaddleDType
+### Tensor
 
-class paddle.fluid.core.PaddleTensor
+class paddle.inference.Tensor
 
-`PaddleDType`定义了`PaddleTensor`的数据类型，由传入`PaddleTensor`的numpy数组类型确定，包括以下成员
+`Tensor`是`Predictor`的一种输入/输出数据结构，通过`predictor`获取输入/输出handle得到，主要提供以下方法
 
-* `INT64`: 64位整型
-* `INT32`: 32位整型
-* `FLOAT32`: 32位浮点型
+* `copy_from_cpu`: 从cpu获取模型运行所需输入数据
+* `copy_to_cpu`: 获取模型运行输出结果
+* `lod`: 获取lod信息
+* `set_lod`: 设置lod信息
+* `shape`: 获取shape信息
+* `reshape`: 设置shape信息
+* `type`: 获取DataType信息
 
-### AnalysisConfig
+``` python
+# 创建predictor
+predictor = create_predictor(config)
+
+# 获取输入的名称
+input_names = predictor.get_input_names()
+input_tensor = predictor.get_input_handle(input_names[0])
 
-class paddle.fluid.core.AnalysisConfig
+# 设置输入
+fake_input = numpy.random.randn(1, 3, 318, 318).astype("float32")
+input_tensor.copy_from_cpu(fake_input)
 
-`AnalysisConfig`是创建预测引擎的配置，提供了模型路径设置、预测引擎运行设备选择以及多种优化预测流程的选项，主要包括以下方法  
+# 运行predictor
+predictor.run()
+
+# 获取输出
+output_names = predictor.get_output_names()
+output_tensor = predictor.get_output_handle(output_names[0])
+output_data = output_tensor.copy_to_cpu() # numpy.ndarray类型
+```
+
+### Config
+
+class paddle.inference.Config
+
+`Config`是创建预测引擎的配置，提供了模型路径设置、预测引擎运行设备选择以及多种优化预测流程的选项，主要包括以下方法
 
 * `set_model`: 设置模型的路径
 * `model_dir`: 返回模型文件夹路径
@@ -71,15 +81,16 @@ class paddle.fluid.core.AnalysisConfig
 * `enable_mkldnn`: 开启MKLDNN
 * `disable_glog_info`: 禁用预测中的glog日志
 * `delete_pass`: 预测的时候删除指定的pass
+
 #### 代码示例
 设置模型和参数路径有两种形式：
 * 当模型文件夹下存在一个模型文件和多个参数文件时，传入模型文件夹路径，模型文件名默认为`__model__`
 ``` python
-config = AnalysisConfig("./model")
+config = Config("./model")
 ```
 * 当模型文件夹下只有一个模型文件和一个参数文件时，传入模型文件和参数文件路径
 ``` python
-config = AnalysisConfig("./model/model", "./model/params")
+config = Config("./model/model", "./model/params")
 ```
 使用`set_model`方法设置模型和参数路径方式同上
 
@@ -89,145 +100,51 @@ config.enable_use_gpu(100, 0) # 初始化100M显存，使用gpu id为0
 config.gpu_device_id()        # 返回正在使用的gpu id
 config.disable_gpu()          # 禁用gpu
 config.switch_ir_optim(True)  # 开启IR优化
-config.enable_tensorrt_engine(precision_mode=AnalysisConfig.Precision.Float32,
+config.enable_tensorrt_engine(precision_mode=PrecisionType.Float32,
                               use_calib_mode=True) # 开启TensorRT预测，精度为fp32，开启int8离线量化
 config.enable_mkldnn()          # 开启MKLDNN
 ```
 
+### Predictor
 
+class paddle.inference.Predictor
 
-### PaddlePredictor
-
-class paddle.fluid.core.PaddlePredictor
-
-`PaddlePredictor`是运行预测的引擎，由`paddle.fluid.core.create_paddle_predictor(config)`创建，主要提供以下方法
-
-* `run`: 输入和返回值均为`PaddleTensor`列表类型，功能为运行预测引擎，返回预测结果
-
-#### 代码示例
-
-``` python
-# 设置完AnalysisConfig后创建预测引擎PaddlePredictor
-predictor = create_paddle_predictor(config)
-
-# 设置输入
-x = numpy.array([1, 2, 3], dtype="int64")
-x_t = fluid.core.PaddleTensor(x)
-
-y = numpy.array([4], dtype = "int64")
-y_t = fluid.core.PaddleTensor(y)
-
-# 运行预测引擎得到结果，返回值是一个PaddleTensor的列表
-results = predictor.run([x_t, y_t])
-
-# 获得预测结果，并应用到自己的应用中
-```
-
-### 使用ZeroCopyTensor管理输入/输出
-
-`ZeroCopyTensor`是`AnalysisPredictor`的一种输入/输出数据结构，与`PaddleTensor`等同。`ZeroCopyTensor`相比于`PaddleTensor`，可以避免预测时候准备输入以及获取输出时多余的数据拷贝，提高预测性能。
-
-注意: 需要注意的是，使用`ZeroCopyTensor`，务必在创建`config`时设置`config.switch_use_feed_fetch_ops(False)`用于显式地在模型运行的时候删去`feed`和`fetch`ops，不会影响模型的效果，但是能提升性能。
+`Predictor`是运行预测的引擎，由`paddle.inference.create_predictor(config)`创建，主要提供以下方法
 
-``` python
-# 创建predictor
-predictor = create_paddle_predictor(config)
-
-# 获取输入的名称
-input_names = predictor.get_input_names()
-input_tensor = predictor.get_input_tensor(input_names[0])
-
-# 设置输入
-fake_input = numpy.random.randn(1, 3, 318, 318).astype("float32")
-input_tensor.copy_from_cpu(fake_input)
-
-# 运行predictor
-predictor.zero_copy_run()
-
-# 获取输出
-output_names = predictor.get_output_names()
-output_tensor = predictor.get_output_tensor(output_names[0])
-output_data = output_tensor.copy_to_cpu() # numpy.ndarray类型
-```
-
-### AnalysisPredictor
-
-class paddle.fluid.core.AnalysisPredictor
-
-`AnalysisPredictor`是运行预测的引擎，继承于`PaddlePredictor`，同样是由`paddle.fluid.core.create_paddle_predictor(config)`创建，主要提供以下方法
-
-* `zero_copy_run()`: 运行预测引擎，返回预测结果
+* `run()`: 运行预测引擎，返回预测结果
 * `get_input_names()`: 获取输入的名称
-* `get_input_tensor(input_name: str)`: 根据输入的名称获取对应的`ZeroCopyTensor`
+* `get_input_handle(input_name: str)`: 根据输入的名称获取对应的`Tensor`
 * `get_output_names()`: 获取输出的名称
-* `get_output_tensor(output_name: str)`: 根据输出的名称获取对应的`ZeroCopyTensor`
+* `get_output_handle(output_name: str)`: 根据输出的名称获取对应的`Tensor`
 
 #### 代码示例
 
 ``` python
 # 设置完AnalysisConfig后创建预测引擎PaddlePredictor
-predictor = create_paddle_predictor(config)
+predictor = create_predictor(config)
 
 # 获取输入的名称
 input_names = predictor.get_input_names()
-input_tensor = predictor.get_input_tensor(input_names[0])
+input_handle = predictor.get_input_handle(input_names[0])
 
 # 设置输入
 fake_input = numpy.random.randn(1, 3, 318, 318).astype("float32")
-input_tensor.reshape([1, 3, 318, 318])
-input_tensor.copy_from_cpu(fake_input)
+input_handle.reshape([1, 3, 318, 318])
+input_handle.copy_from_cpu(fake_input)
 
 # 运行predictor
-predictor.zero_copy_run()
+predictor.run()
 
 # 获取输出
 output_names = predictor.get_output_names()
-output_tensor = predictor.get_output_tensor(output_names[0])
+output_handle = predictor.get_output_handle(output_names[0])
 ```
 
-## 支持方法列表
-* PaddleTensor
-	* `as_ndarray() -> numpy.ndarray`
-* ZeroCopyTensor
-    * `copy_from_cpu(input: numpy.ndarray) -> None`
-    * `copy_to_cpu() -> numpy.ndarray`
-    * `reshape(input: numpy.ndarray|List[int]) -> None`
-    * `shape() -> List[int]`
-    * `set_lod(input: numpy.ndarray|List[List[int]]) -> None`
-    * `lod() -> List[List[int]]`
-    * `type() -> PaddleDType`
-* AnalysisConfig
-	* `set_model(model_dir: str) -> None`
-	* `set_model(prog_file: str, params_file: str) -> None`
-	* `model_dir() -> str`
-	* `prog_file() -> str`
-	* `params_file() -> str`
-	* `enable_use_gpu(memory_pool_init_size_mb: int, device_id: int) -> None`
-	* `gpu_device_id() -> int`
-	* `switch_ir_optim(x: bool = True) -> None`
-	* `enable_tensorrt_engine(workspace_size: int = 1 << 20,
-	                          max_batch_size: int,
-                              min_subgraph_size: int,
-                              precision_mode: AnalysisConfig.precision,
-                              use_static: bool,
-                              use_calib_mode: bool) -> None`
-	* `enable_mkldnn() -> None`
-    * `disable_glog_info() -> None`
-    * `delete_pass(pass_name: str) -> None`
-* PaddlePredictor
-	* `run(input: List[PaddleTensor]) -> List[PaddleTensor]`
-* AnalysisPredictor
-    * `zero_copy_run() -> None`
-    * `get_input_names() -> List[str]`
-    * `get_input_tensor(input_name: str) -> ZeroCopyTensor`
-    * `get_output_names() -> List[str]`
-    * `get_output_tensor(output_name: str) -> ZeroCopyTensor`
 
-可参考对应的[C++预测接口](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/pybind/inference_api.cc)，其中定义了每个接口的参数和返回值
 
 ## 完整使用示例
 
-下面是使用Fluid Python API进行预测的一个完整示例，使用resnet50模型
+下面是使用Paddle Inference Python API进行预测的一个完整示例，使用resnet50模型
 
 下载[resnet50模型](http://paddle-inference-dist.bj.bcebos.com/resnet50_model.tar.gz)并解压，运行如下命令将会调用预测引擎
 
@@ -237,70 +154,11 @@ python resnet50_infer.py --model_file ./model/model --params_file ./model/params
 
 `resnet50_infer.py` 的内容是
 
-### PaddleTensor的完整使用示例
-
 ``` python
 import argparse
 import numpy as np
-
-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()
-
-    # 设置AnalysisConfig
-    config = AnalysisConfig(args.model_file, args.params_file)
-    config.disable_gpu()
-
-    # 创建PaddlePredictor
-    predictor = create_paddle_predictor(config)
-
-    # 设置输入，此处以随机输入为例，用户可自行输入真实数据
-    inputs = fake_input(args.batch_size)
-
-    # 运行预测引擎
-    outputs = predictor.run(inputs)
-    output_num = 512
-
-    # 获得输出并解析
-    output = outputs[0]
-    print(output.name)
-    output_data = output.as_ndarray() #return numpy.ndarray
-    assert list(output_data.shape) == [args.batch_size, output_num]
-    for i in range(args.batch_size):
-        print(np.argmax(output_data[i]))
-
-
-def fake_input(batch_size):  
-    shape = [batch_size, 3, 318, 318]
-    data = np.random.randn(*shape).astype("float32")
-    image = PaddleTensor(data)
-    return [image]
-
-
-def parse_args():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--model_file", type=str, help="model 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()  
-```
-
-### ZeroCopyTensor的完整使用示例
-
-``` python
-import argparse
-import numpy as np
-from paddle.fluid.core import AnalysisConfig
-from paddle.fluid.core import create_paddle_predictor
+from paddle.inference import Config
+from paddle.inference import create_predictor
 
 
 def main():
@@ -310,24 +168,24 @@ def main():
     config = set_config(args)
 
     # 创建PaddlePredictor
-    predictor = create_paddle_predictor(config)
+    predictor = create_predictor(config)
 
     # 获取输入的名称
     input_names = predictor.get_input_names()
-    input_tensor = predictor.get_input_tensor(input_names[0])
+    input_handle = predictor.get_input_handle(input_names[0])
 
     # 设置输入
     fake_input = np.random.randn(1, 3, 318, 318).astype("float32")
-    input_tensor.reshape([1, 3, 318, 318])
-    input_tensor.copy_from_cpu(fake_input)
+    input_handle.reshape([1, 3, 318, 318])
+    input_handle.copy_from_cpu(fake_input)
 
     # 运行predictor
-    predictor.zero_copy_run()
+    predictor.run()
 
     # 获取输出
     output_names = predictor.get_output_names()
-    output_tensor = predictor.get_output_tensor(output_names[0])
-    output_data = output_tensor.copy_to_cpu() # numpy.ndarray类型
+    output_handle = predictor.get_output_handle(output_names[0])
+    output_data = output_handle.copy_to_cpu() # numpy.ndarray类型
 
 
 def parse_args():
@@ -340,7 +198,7 @@ def parse_args():
 
 
 def set_config(args):
-    config = AnalysisConfig(args.model_file, args.params_file)
+    config = Config(args.model_file, args.params_file)
     config.disable_gpu()
     config.switch_use_feed_fetch_ops(False)
     config.switch_specify_input_names(True)
@@ -350,3 +208,77 @@ def set_config(args):
 if __name__ == "__main__":
     main()
 ```
+
+## 支持方法列表
+
+* Tensor
+    * `copy_from_cpu(input: numpy.ndarray) -> None`
+    * `copy_to_cpu() -> numpy.ndarray`
+    * `reshape(input: numpy.ndarray|List[int]) -> None`
+    * `shape() -> List[int]`
+    * `set_lod(input: numpy.ndarray|List[List[int]]) -> None`
+    * `lod() -> List[List[int]]`
+    * `type() -> PaddleDType`
+* Config
+    * `set_model(model_dir: str) -> None`
+    * `set_model(prog_file: str, params_file: str) -> None`
+    * `set_model_buffer(model: str, model_size: int, param: str, param_size: int) -> None`
+    * `model_dir() -> str`
+    * `prog_file() -> str`
+    * `params_file() -> str`
+    * `model_from_memory() -> bool`
+    * `set_cpu_math_library_num_threads(num: int) -> None`
+    * `enable_use_gpu(memory_pool_init_size_mb: int, device_id: int) -> None`
+    * `use_gpu() -> bool`
+    * `gpu_device_id() -> int`
+    * `switch_ir_optim(x: bool = True) -> None`
+    * `switch_ir_debug(x: int=True) -> None`
+    * `ir_optim() -> bool`
+    * `enable_tensorrt_engine(workspace_size: int = 1 << 20,
+                              max_batch_size: int,
+                              min_subgraph_size: int,
+                              precision_mode: AnalysisConfig.precision,
+                              use_static: bool,
+                              use_calib_mode: bool) -> None`
+    * `set_trt_dynamic_shape_info(min_input_shape: Dict[str, List[int]]={}, max_input_shape: Dict[str, List[int]]={}, optim_input_shape: Dict[str, List[int]]={}, disable_trt_plugin_fp16: bool=False) -> None`
+    * `tensorrt_engine_enabled() -> bool`
+    * `enable_mkldnn() -> None`
+    * `enable_mkldnn_bfloat16() -> None`
+    * `mkldnn_enabled() -> bool`
+    * `set_mkldnn_cache_capacity(capacity: int=0) -> None`
+    * `set_mkldnn_op(ops: Set[str]) -> None`
+    * `set_optim_cache_dir(dir: str) -> None`
+    * `disable_glog_info() -> None`
+    * `pass_builder() -> paddle::PassStrategy`
+    * `delete_pass(pass_name: str) -> None`
+    * `cpu_math_library_num_threads() -> int`
+    * `disable_gpu() -> None`
+    * `enable_lite_engine(precision: PrecisionType, zero_copy: bool, passes_filter: List[str]=[], ops_filter: List[str]=[]) -> None`
+    * `lite_engine_enabled() -> bool`
+    * `enable_memory_optim() -> None`
+    * `enable_profile() -> None`
+    * `enable_quantizer() -> None`
+    * `quantizer_config() -> paddle::MkldnnQuantizerConfig`
+    * `fraction_of_gpu_memory_for_pool() -> float`
+    * `memory_pool_init_size_mb() -> int`
+    * `glog_info_disabled() -> bool`
+    * `gpu_device_id() -> int`
+    * `specify_input_name() -> bool`
+    * `switch_specify_input_names(x: bool=True) -> None`
+    * `specify_input_name(q) -> bool`
+    * `switch_use_feed_fetch_ops(x: int=True) -> None`
+    * `use_feed_fetch_ops_enabled() -> bool`
+    * `to_native_config() -> paddle.fluid.core_avx.NativeConfig`
+* `create_predictor(config: Config) -> Predictor`
+* Predictor
+    * `run() -> None`
+    * `get_input_names() -> List[str]`
+    * `get_input_handle(input_name: str) -> Tensor`
+    * `get_output_names() -> List[str]`
+    * `get_output_handle(output_name: str) -> Tensor`
+    * `clear_intermediate_tensor() -> None`
+    * `clone() -> Predictor`
+* PredictorPool
+    * `retrive(idx: int) -> Predictor`
+
+可参考对应的[C++预测接口](https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/pybind/inference_api.cc)，其中定义了每个接口的参数和返回值

doc/paddle/advanced_guide/inference_deployment/inference/windows_cpp_inference.md

@@ -2,30 +2,30 @@
 安装与编译 Windows 预测库
 ===========================
 
-下载安装包与对应的测试环境
+直接下载安装
 -------------
 
-| 版本说明      |     预测库(1.8.3版本)     |       编译器        |    构建工具      |  cuDNN  |  CUDA  |
+| 版本说明      |     预测库(1.8.4版本)  |预测库(2.0.0-beta0版本)   |     编译器     |    构建工具      |  cuDNN  |  CUDA  |
 |:---------|:-------------------|:-------------------|:----------------|:--------|:-------|
-|    cpu_avx_mkl | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.3/win-infer/mkl/cpu/fluid_inference_install_dir.zip) | MSVC 2015 update 3|  CMake v3.16.0  |
-|    cpu_avx_openblas | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.3/win-infer/open/cpu/fluid_inference_install_dir.zip) | MSVC 2015 update 3|  CMake v3.16.0  |
-|    cuda9.0_cudnn7_avx_mkl | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.3/win-infer/mkl/post97/fluid_inference_install_dir.zip) |  MSVC 2015 update 3 |  CMake v3.16.0  |  7.3.1  |   9.0    |
-|    cuda9.0_cudnn7_avx_openblas | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.3/win-infer/open/post97/fluid_inference_install_dir.zip) | MSVC 2015 update 3 |  CMake v3.16.0  |  7.3.1  |   9.0    |
-|    cuda10.0_cudnn7_avx_mkl | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.3/win-infer/mkl/post107/fluid_inference_install_dir.zip) | MSVC 2015 update 3 |  CMake v3.16.0  |  7.4.1  |   10.0    |
+|    cpu_avx_mkl | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.4/win-infer/mkl/cpu/fluid_inference_install_dir.zip) | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/2.0.0-beta0/win-infer/mkl/cpu/fluid_inference_install_dir.zip) | MSVC 2015 update 3|  CMake v3.16.0  |
+|    cpu_avx_openblas | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.4/win-infer/open/cpu/fluid_inference_install_dir.zip) || MSVC 2015 update 3|  CMake v3.16.0  |
+|    cuda9.0_cudnn7_avx_mkl | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.4/win-infer/mkl/post97/fluid_inference_install_dir.zip) ||  MSVC 2015 update 3 |  CMake v3.16.0  |  7.3.1  |   9.0    |
+|    cuda9.0_cudnn7_avx_openblas | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.4/win-infer/open/post97/fluid_inference_install_dir.zip) || MSVC 2015 update 3 |  CMake v3.16.0  |  7.3.1  |   9.0    |
+|    cuda10.0_cudnn7_avx_mkl | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.4/win-infer/mkl/post107/fluid_inference_install_dir.zip) | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.3/win-infer/mkl/cpu/fluid_inference_install_dir.zip) | MSVC 2015 update 3 |  CMake v3.16.0  |  7.4.1  |   10.0    |
 
 ### 硬件环境
 
 测试环境硬件配置：
 
-| CPU      |      I7-8700K      |
+| 操作系统      |    win10 家庭版本      |
 |:---------|:-------------------|
+| CPU      |      I7-8700K      |
 | 内存 | 16G               |
 | 硬盘 | 1T hdd + 256G ssd |
 | 显卡 | GTX1080 8G        |
 
-测试环境操作系统使用 win10 家庭版本
 
-从源码编译预测库
+从源码编译
 --------------
 用户也可以从 PaddlePaddle 核心代码编译C++预测库，只需在编译时配制下面这些编译选项：
 
@@ -34,9 +34,9 @@
 |CMAKE_BUILD_TYPE |  配置生成器上的构建类型，windows预测库目前只支持Release          | Release    |
 |ON_INFER |   是否生成预测库，编译预测库时必须设置为ON                | ON         |
 |WITH_GPU |   是否支持GPU                  | ON/OFF     |
-|WITH_MKL |   是否使用Intel MKL(数学核心库)                 | ON/OFF     |
-|WITH_PYTHON | 是否内嵌PYTHON解释器                | OFF(推荐)        |
-|MSVC_STATIC_CRT|是否使用/MT 模式进行编译，Windows默认使用 /MT 模式进行编译 |ON/OFF|
+|WITH_MKL |   是否使用Intel MKL(数学核心库)或者OPENBLAS     | ON/OFF     |
+|WITH_PYTHON | 是否编译Python包                | OFF(推荐)        |
+|MSVC_STATIC_CRT|是否使用/MT 模式进行编译，默认使用 /MT 模式进行编译 |ON/OFF|
 |CUDA_TOOKIT_ROOT_DIR|编译GPU预测库时，需设置CUDA的根目录|YOUR_CUDA_PATH|
 
 请按照推荐值设置，以避免链接不必要的库。其它可选编译选项按需进行设定。
@@ -45,46 +45,45 @@
 
 Windows下安装与编译预测库步骤：(在Windows命令提示符下执行以下指令)
 
-1. 将PaddlePaddle的源码clone在当下目录的Paddle文件夹中，并进入Paddle目录：
+1. 将PaddlePaddle的源码clone在当下目录的Paddle文件夹中，并进入Paddle目录，创建build目录：
    ```bash
    git clone https://github.com/PaddlePaddle/Paddle.git
    cd Paddle
-   ```
-
-2. 执行cmake：
-   - 编译CPU预测
-   ```bash
    # 创建并进入build目录
    mkdir build
    cd build
+   ```
 
-   cmake .. -G "Visual Studio 14 2015" -A x64 -T host=x64 -DCMAKE_BUILD_TYPE=Release -DWITH_MKL=OFF -DWITH_GPU=OFF -DON_INFER=ON -DWITH_PYTHON=OFF
+2. 执行cmake：
+   - 编译CPU预测库
+   ```bash
+   cmake .. -G "Visual Studio 14 2015" -A x64 -T host=x64 -DCMAKE_BUILD_TYPE=Release -DWITH_MKL=ON -DWITH_GPU=OFF -DON_INFER=ON -DWITH_PYTHON=OFF
 
    # Windows默认使用 /MT 模式进行编译，如果想使用 /MD 模式，请使用以下命令。如不清楚两者的区别，请使用上面的命令
-   cmake .. -G "Visual Studio 14 2015" -A x64 -T host=x64 -DCMAKE_BUILD_TYPE=Release -DWITH_MKL=OFF -DWITH_GPU=OFF -DON_INFER=ON -DWITH_PYTHON=OFF -DMSVC_STATIC_CRT=OFF
+   cmake .. -G "Visual Studio 14 2015" -A x64 -T host=x64 -DCMAKE_BUILD_TYPE=Release -DWITH_MKL=ON -DWITH_GPU=OFF -DON_INFER=ON -DWITH_PYTHON=OFF -DMSVC_STATIC_CRT=OFF
    ```
    - 编译GPU预测库:
    ```bash
-   # -DCUDA_TOOKIT_ROOT_DIR 为cuda根目录，例如-DCUDA_TOOKIT_ROOT_DIR="D:\\cuda"
+   # -DCUDA_TOOKIT_ROOT_DIR为你所安装的cuda根目录，例如-DCUDA_TOOKIT_ROOT_DIR="C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v10.0"
    cmake .. -G "Visual Studio 14 2015" -A x64 -T host=x64 -DCMAKE_BUILD_TYPE=Release -DWITH_MKL=ON -DWITH_GPU=ON -DON_INFER=ON -DWITH_PYTHON=OFF -DCUDA_TOOKIT_ROOT_DIR=YOUR_CUDA_PATH
    ```
 
 3. 使用Blend for Visual Studio 2015 打开 `paddle.sln` 文件，选择平台为`x64`，配置为`Release`，编译inference_lib_dist项目。
    操作方法：在Visual Studio中选择相应模块，右键选择"生成"（或者"build"）
 
-编译成功后，使用C++预测库所需的依赖（包括：（1）编译出的PaddlePaddle预测库和头文件；（2）第三方链接库和头文件；（3）版本信息与编译选项信息）
-均会存放于`fluid_inference_install_dir`目录中。
-
-version.txt 中记录了该预测库的版本信息，包括Git Commit ID、使用OpenBlas或MKL数学库、CUDA/CUDNN版本号，如：
+编译成功后，使用C++预测库所需的依赖（包括：1. 编译出的PaddlePaddle预测库和头文件；2. 第三方链接库和头文件；3. 版本信息与编译选项信息）均会存放于`fluid_inference_install_dir`目录中。
 
+version.txt 中记录了该预测库的版本信息，包括Git Commit ID、使用OpenBlas或MKL数学库、CUDA/CUDNN版本号、C++编译器版本，如：
 
-     GIT COMMIT ID: cc9028b90ef50a825a722c55e5fda4b7cd26b0d6
-     WITH_MKL: ON
-     WITH_MKLDNN: ON
-     WITH_GPU: ON
-     CUDA version: 8.0
-     CUDNN version: v7
-
+```text
+GIT COMMIT ID: 264e76cae6861ad9b1d4bcd8c3212f7a78c01e4d
+WITH_MKL: ON
+WITH_MKLDNN: ON
+WITH_GPU: ON
+CUDA version: 10.0
+CUDNN version: v7.4
+CXX compiler version: 19.0.24215.1
+```
 
 编译预测demo
 -------------
@@ -93,14 +92,13 @@ version.txt 中记录了该预测库的版本信息，包括Git Commit ID、使
 
 测试环境硬件配置：
 
-| CPU      |      I7-8700K      |
+| 操作系统      |    win10 家庭版本      |
 |:---------|:-------------------|
+| CPU      |      I7-8700K      |
 | 内存 | 16G               |
 | 硬盘 | 1T hdd + 256G ssd |
 | 显卡 | GTX1080 8G        |
 
-测试环境操作系统使用 win10 家庭版本。
-
 ### 软件要求
 
 **请您严格按照以下步骤进行安装，否则可能会导致安装失败！**

doc/paddle/advanced_guide/inference_deployment/inference/windows_cpp_inference_en.md

@@ -2,23 +2,24 @@
 Install and Compile C++ Inference Library on Windows
 ===========================
 
-Direct Download and Install
+Download and Install directly
 -------------
 
-| Version      |     Inference Libraries(v1.8.3)   | Compiler | Build tools | cuDNN | CUDA |
+| Version      |  Inference Libraries(v1.8.4)   |Inference Libraries(v2.0.0-beta0)| Compiler | Build tools | cuDNN | CUDA |
 |:---------|:-------------------|:-------------------|:----------------|:--------|:-------|
-|    cpu_avx_mkl | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.3/win-infer/mkl/cpu/fluid_inference_install_dir.zip) | MSVC 2015 update 3|  CMake v3.16.0  |
-|    cpu_avx_openblas | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.3/win-infer/open/cpu/fluid_inference_install_dir.zip) | MSVC 2015 update 3|  CMake v3.16.0  |
-|    cuda9.0_cudnn7_avx_mkl | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.3/win-infer/mkl/post97/fluid_inference_install_dir.zip) |  MSVC 2015 update 3 |  CMake v3.16.0  |  7.3.1  |   9.0    |
-|    cuda9.0_cudnn7_avx_openblas | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.3/win-infer/open/post97/fluid_inference_install_dir.zip) | MSVC 2015 update 3 |  CMake v3.16.0  |  7.3.1  |   9.0    |
-|    cuda10.0_cudnn7_avx_mkl | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.3/win-infer/mkl/post107/fluid_inference_install_dir.zip) | MSVC 2015 update 3 |  CMake v3.16.0  |  7.4.1  |   10.0    |
+|    cpu_avx_mkl | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.4/win-infer/mkl/cpu/fluid_inference_install_dir.zip) | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/2.0.0-beta0/win-infer/mkl/cpu/fluid_inference_install_dir.zip) | MSVC 2015 update 3|  CMake v3.16.0  |
+|    cpu_avx_openblas | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.4/win-infer/open/cpu/fluid_inference_install_dir.zip) || MSVC 2015 update 3|  CMake v3.16.0  |
+|    cuda9.0_cudnn7_avx_mkl | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.4/win-infer/mkl/post97/fluid_inference_install_dir.zip) ||  MSVC 2015 update 3 |  CMake v3.16.0  |  7.3.1  |   9.0    |
+|    cuda9.0_cudnn7_avx_openblas | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.4/win-infer/open/post97/fluid_inference_install_dir.zip) || MSVC 2015 update 3 |  CMake v3.16.0  |  7.3.1  |   9.0    |
+|    cuda10.0_cudnn7_avx_mkl | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.4/win-infer/mkl/post107/fluid_inference_install_dir.zip) | [fluid_inference.zip](https://paddle-wheel.bj.bcebos.com/1.8.3/win-infer/mkl/cpu/fluid_inference_install_dir.zip) | MSVC 2015 update 3 |  CMake v3.16.0  |  7.4.1  |   10.0    |
 
 ### Hardware Environment
 
 Hardware Configuration of the experimental environment:
 
+|Operating System| win10 family version|
+|:---------------|:-------------------|
 | CPU            | I7-8700K      |
-|:--------------|:-------------------|
 | Memory         | 16G               |
 | Hard Disk      | 1T hdd + 256G ssd |
 | Graphics Card  | GTX1080 8G        |
@@ -36,8 +37,8 @@ Users can also compile C++ inference libraries from the PaddlePaddle core code b
 |ON_INFER|Whether to generate the inference library. Must be set to ON when compiling the inference library. | ON   |
 |WITH_GPU|Whether to support GPU   | ON/OFF     |
 |WITH_MKL|Whether to support MKL   | ON/OFF     |
-|WITH_PYTHON|Whether the PYTHON interpreter is embedded      | OFF        |
-|MSVC_STATIC_CRT|Whether to compile with / MT mode |   ON   |
+|WITH_PYTHON|Whether to generate the Python whl package| OFF        |
+|MSVC_STATIC_CRT|Whether to compile with /MT mode |   ON   |
 |CUDA_TOOKIT_ROOT_DIR | When compiling the GPU inference library, you need to set the CUDA root directory | YOUR_CUDA_PATH |
 
 For details on the compilation options, see [the compilation options list](../../../beginners_guide/install/Tables_en.html/#Compile)
@@ -54,21 +55,16 @@ For details on the compilation options, see [the compilation options list](../..
 
    - compile CPU inference library
    ```bash
-   # create build directory
-   mkdir build
-
-   # change to the build directory
-   cd build
-   cmake .. -G "Visual Studio 14 2015" -A x64 -T host=x64 -DCMAKE_BUILD_TYPE=Release -DWITH_MKL=OFF -DWITH_GPU=OFF -DON_INFER=ON -DWITH_PYTHON=OFF
+   cmake .. -G "Visual Studio 14 2015" -A x64 -T host=x64 -DCMAKE_BUILD_TYPE=Release -DWITH_MKL=ON -DWITH_GPU=OFF -DON_INFER=ON -DWITH_PYTHON=OFF
    # use -DWITH_MKL to select math library: Intel MKL or OpenBLAS
 
    # By default on Windows we use /MT for C Runtime Library, If you want to use /MD, please use the below command
    # If you have no ideas the differences between the two, use the above one
-   cmake .. -G "Visual Studio 14 2015" -A x64 -T host=x64 -DCMAKE_BUILD_TYPE=Release -DWITH_MKL=OFF -DWITH_GPU=OFF -DON_INFER=ON -DWITH_PYTHON=OFF -DMSVC_STATIC_CRT=OFF
+   cmake .. -G "Visual Studio 14 2015" -A x64 -T host=x64 -DCMAKE_BUILD_TYPE=Release -DWITH_MKL=ON -DWITH_GPU=OFF -DON_INFER=ON -DWITH_PYTHON=OFF -DMSVC_STATIC_CRT=OFF
    ```
    - compile GPU inference library
    ```bash
-   # -DCUDA_TOOKIT_ROOT_DIR is cuda root directory, such as -DCUDA_TOOKIT_ROOT_DIR="D:\\cuda"
+   # -DCUDA_TOOKIT_ROOT_DIR is cuda root directory, such as -DCUDA_TOOKIT_ROOT_DIR="C:/Program Files/NVIDIA GPU Computing Toolkit/CUDA/v10.0"
    cmake .. -G "Visual Studio 14 2015" -A x64 -T host=x64 -DCMAKE_BUILD_TYPE=Release -DWITH_MKL=ON -DWITH_GPU=ON -DON_INFER=ON -DWITH_PYTHON=OFF -DCUDA_TOOKIT_ROOT_DIR=YOUR_CUDA_PATH
    ```
 
@@ -76,15 +72,18 @@ For details on the compilation options, see [the compilation options list](../..
 
 The inference library will be installed in `fluid_inference_install_dir`.
 
-version.txt constains the detailed configurations about the library, including git commit ID、math library, CUDA, CUDNN versions：
+version.txt constains the detailed configurations about the library, including git commit ID、math library, CUDA, CUDNN versions, CXX compiler version:
 
 
-     GIT COMMIT ID: cc9028b90ef50a825a722c55e5fda4b7cd26b0d6
-     WITH_MKL: ON
-     WITH_MKLDNN: ON
-     WITH_GPU: ON
-     CUDA version: 8.0
-     CUDNN version: v7
+```text
+GIT COMMIT ID: 264e76cae6861ad9b1d4bcd8c3212f7a78c01e4d
+WITH_MKL: ON
+WITH_MKLDNN: ON
+WITH_GPU: ON
+CUDA version: 10.0
+CUDNN version: v7.4
+CXX compiler version: 19.0.24215.1
+```
 
 
 Inference Demo Compilation
@@ -94,14 +93,13 @@ Inference Demo Compilation
 
 Hardware Configuration of the experimental environment:
 
+|Operating System| win10 family version|
+|:---------------|:-------------------|
 | 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**

doc/paddle/api/alias_api_mapping

@@ -8,7 +8,7 @@ paddle.nn.functional.common.alpha_dropout	paddle.nn.functional.alpha_dropout
 paddle.nn.functional.activation.log_sigmoid	paddle.nn.functional.log_sigmoid
 paddle.fluid.executor.Executor	paddle.static.Executor
 paddle.nn.functional.pooling.avg_pool2d	paddle.nn.functional.avg_pool2d
-paddle.fluid.dygraph.checkpoint.load_dygraph	paddle.load,paddle.framework.load
+paddle.framework.io.load	paddle.load,paddle.framework.load
 paddle.fluid.dygraph.container.Sequential	paddle.nn.Sequential
 paddle.fluid.dygraph.BilinearTensorProduct	paddle.nn.BilinearTensorProduct,paddle.nn.layer.BilinearTensorProduct,paddle.nn.layer.common.BilinearTensorProduct
 paddle.fluid.layers.box_coder	paddle.nn.functional.box_coder,paddle.nn.functional.vision.box_coder
@@ -251,7 +251,7 @@ paddle.nn.functional.activation.prelu	paddle.nn.functional.prelu
 paddle.tensor.linalg.matmul	paddle.matmul,paddle.tensor.matmul
 paddle.fluid.layers.generate_proposals	paddle.nn.functional.generate_proposals,paddle.nn.functional.vision.generate_proposals
 paddle.nn.layer.loss.SmoothL1Loss	paddle.nn.SmoothL1Loss,paddle.nn.layer.SmoothL1Loss
-paddle.fluid.dygraph.checkpoint.save_dygraph	paddle.save,paddle.framework.save
+paddle.framework.io.save	paddle.save,paddle.framework.save
 paddle.fluid.core	paddle.framework.core
 paddle.nn.functional.vision.grid_sample	paddle.nn.functional.grid_sample
 paddle.tensor.random.rand	paddle.rand,paddle.tensor.rand
@@ -282,7 +282,7 @@ paddle.framework.get_default_dtype	paddle.get_default_dtype
 paddle.fluid.layers.atan	paddle.atan,paddle.tensor.atan,paddle.tensor.math.atan
 paddle.fluid.layers.pad2d	paddle.nn.functional.pad2d,paddle.nn.functional.common.pad2d
 paddle.nn.layer.pooling.MaxPool3d	paddle.nn.MaxPool3d,paddle.nn.layer.MaxPool3d
-paddle.fluid.io.load	paddle.static.load,paddle.tensor.load,paddle.tensor.io.load
+paddle.fluid.io.load	paddle.static.load
 paddle.fluid.dygraph.learning_rate_scheduler.ExponentialDecay	paddle.ExponentialDecay,paddle.framework.ExponentialDecay
 paddle.fluid.layers.conv3d	paddle.static.nn.conv3d
 paddle.nn.layer.activation.Softmax	paddle.nn.Softmax
@@ -447,7 +447,7 @@ paddle.tensor.stat.numel	paddle.numel,paddle.tensor.numel
 paddle.nn.functional.activation.relu6	paddle.nn.functional.relu6
 paddle.tensor.math.cumsum	paddle.cumsum,paddle.tensor.cumsum
 paddle.fluid.layers.resize_trilinear	paddle.nn.functional.resize_trilinear,paddle.nn.functional.vision.resize_trilinear
-paddle.fluid.save	paddle.static.save,paddle.tensor.save,paddle.tensor.io.save
+paddle.fluid.io.save	paddle.static.save
 paddle.fluid.layers.scale	paddle.scale,paddle.tensor.scale,paddle.tensor.math.scale
 paddle.fluid.framework.default_startup_program	paddle.static.default_startup_program
 paddle.fluid.layers.noam_decay	paddle.nn.functional.noam_decay,paddle.nn.functional.learning_rate.noam_decay
@@ -561,7 +561,6 @@ paddle.text.datasets.conll05.Conll05st	paddle.text.datasets.Conll05st,paddle.tex
 paddle.text.datasets.imdb.Imdb	paddle.text.datasets.Imdb,paddle.text.Imdb
 paddle.text.datasets.imikolov.Imikolov	paddle.text.datasets.Imikolov,paddle.text.Imikolov
 paddle.text.datasets.movielens.Movielens	paddle.text.datasets.Movielens,paddle.text.Movielens
-paddle.text.datasets.movie_reviews.MovieReviews	paddle.text.datasets.MovieRevie,paddle.text.MovieRevie
 paddle.text.datasets.uci_housing.UCIHousing	paddle.text.datasets.UCIHousing,paddle.text.UCIHousing
 paddle.text.datasets.wmt14.WMT14	paddle.text.datasets.WMT14,paddle.text.WMT14
 paddle.text.datasets.wmt16.WMT16	paddle.text.datasets.WMT16,paddle.text.WMT16

doc/paddle/api/gen_doc.py

@@ -20,6 +20,9 @@ api_set = set()
 def get_all_api(root_path='paddle'):
     for filefiner, name, ispkg in pkgutil.walk_packages(
             path=paddle.__path__, prefix=paddle.__name__ + '.'):
+        # not show paddle.reader APIs
+        if name.startswith("paddle.reader"):
+            continue
         try:
             m = eval(name)
         except AttributeError:

doc/paddle/api/not_display_doc_list

 paddle.utils
 paddle.incubate
 paddle.hapi.progressbar.ProgressBar
-paddle.metric.accuracy
-paddle.metric.auc
+paddle.fluid.contrib
+paddle.optimizer._LRScheduler
+paddle.fluid.dygraph.dygraph_to_static

doc/paddle/api/paddle/dataset/sentiment_cn.rst

-.. _cn_api_paddle_dataset_sentiment:
-
-sentiment
--------------------------------
-
-脚本获取并预处理由NLTK提供的movie_reviews数据集。
-
-
-.. py:function:: paddle.dataset.sentiment.get_word_dict()
-
-按照样本中出现的单词的频率对单词进行排序。
-
-返回： words_freq_sorted
-
-.. py:function:: paddle.dataset.sentiment.train()
-
-默认的训练集reader creator。
-
-.. py:function:: paddle.dataset.sentiment.test()
-
-默认的测试集reader creator。
-
-.. py:function:: paddle.dataset.sentiment.convert(path)
-
-将数据集转换为recordio格式。
-
-
-

doc/paddle/api/paddle/distributed/fleet/DistributedStrategy_cn.rst

@@ -30,6 +30,35 @@ DistributedStrategy
 
 **checkpoints(int):** Recompute策略的检查点，默认为空列表，也即不启用Recompute。
 
+.. py:attribute:: pipeline
+
+是否启用Pipeline并行。目前，主要实现单机多GPU间的Pipeline并行和多机间的数据并行。Pipeline信息由用户定义程序中的device_guard确定。
+
+**示例代码**
+
+.. code-block:: python
+
+  import paddle.distributed.fleet as fleet
+  strategy = fleet.DistributedStrategy()
+  strategy.pipeline = True
+
+
+.. py:attribute:: pipeline_configs
+
+设置Pipeline策略的配置。Pipeline策略下，神经网络的不同层在不同的GPU设备。相邻的GPU设备间有用于同步隐层Tensor的队列。Pipeline并行包含多种生产者-消费者形式的硬件对，如GPU-CPU、CPU-GPU、GPU-XPU。加速PIpeline并行的最佳方式是减少Tensor队列中的Tensor大小，这样生产者可以更快的为下游消费者提供数据。
+
+**micro_batch (int):** 每个用户定义的mini-batch中包含的更小的micro-batch的数量。
+
+**示例代码**
+
+.. code-block:: python
+
+  import paddle.distributed.fleet as fleet
+  strategy = fleet.DistributedStrategy()
+  strategy.pipeline = True
+  strategy.pipeline_configs = {"micro_batch": 12}
+
+
 .. py:attribute:: gradient_merge
 
 梯度累加，是一种大Batch训练的策略。添加这一策略后，模型的参数每过 **k_steps** 步更新一次，
@@ -102,3 +131,137 @@ DistributedStrategy
 **lamb_weight_decay(float):** lars 公式中 weight decay 系数。 默认值是 0.01.
 
 **exclude_from_weight_decay(list[str]):** 不应用 weight decay 的 layers 的名字列表，某一layer 的name 如果在列表中，这一layer 的 lamb_weight_decay将被置为 0. 默认值是 None.
+
+.. py:attribute:: localsgd
+是否使用LocalSGD optimizer，默认值：False。更多的细节请参考[Don't Use Large Mini-Batches, Use Local SGD](https://arxiv.org/pdf/1808.07217.pdf)
+
+**示例代码**
+
+.. code-block:: python  
+
+  import paddle.distributed.fleet as fleet
+  strategy = fleet.DistributedStrategy()
+  strategy.localsgd = True # by default this is false
+
+
+.. py:attribute:: localsgd_configs
+设置LocalSGD优化器的参数。用户可以配置k_steps和begin_step参数。
+
+**示例代码**
+
+.. code-block:: python
+
+  import paddle.distributed.fleet as fleet
+  strategy = fleet.DistributedStrategy()
+  strategy.localsgd = True
+  strategy.localsgd_configs = {"k_steps": 4,
+                                "begin_step": 30}
+
+**k_steps(int):** 训练过程中的全局参数更新间隔，默认值1。
+
+**begin_step(int):** 指定从第几个step之后进行local SGD算法，默认值1。
+
+.. py:attribute:: adaptive_localsgd
+是否使用AdaptiveLocalSGD optimizer，默认值：False。更多的细节请参考[Adaptive Communication Strategies to Achieve the Best Error-Runtime Trade-off in Local-Update SGD](https://arxiv.org/pdf/1810.08313.pdf)
+
+**示例代码**
+
+.. code-block:: python
+
+  import paddle.distributed.fleet as fleet
+  strategy = fleet.DistributedStrategy()
+  strategy.adaptive_localsgd = True # by default this is false
+
+.. py:attribute:: adaptive_localsgd_configs
+设置AdaptiveLocalSGD优化器的参数。用户可以配置init_k_steps和begin_step参数。
+
+**示例代码**
+
+.. code-block:: python
+
+  import paddle.distributed.fleet as fleet
+  strategy = fleet.DistributedStrategy()
+  strategy.adaptive_localsgd = True
+  strategy.adaptive_localsgd_configs = {"init_k_steps": 1,
+                                        "begin_step": 30}
+
+**init_k_steps(int):** 自适应localsgd的初始训练步长。训练后，自适应localsgd方法将自动调整步长。 默认值1。
+
+**begin_step(int):** 指定从第几个step之后进行Adaptive LocalSGD算法，默认值1。
+
+.. py:attribute:: amp
+
+是否启用自动混合精度训练。默认值：False
+
+**示例代码**
+
+.. code-block:: python
+
+  import paddle.distributed.fleet as fleet
+  strategy = fleet.DistributedStrategy()
+  strategy.amp = True # by default this is false
+
+.. py:attribute:: amp_configs
+
+设置自动混合精度训练配置。为避免梯度inf或nan，amp会根据梯度值自动调整loss scale值。目前可以通过字典设置以下配置。
+
+**init_loss_scaling(float):** 初始loss scaling值。默认值32768。
+
+**use_dynamic_loss_scaling(bool):** 是否动态调整loss scale值。默认True。
+
+**incr_every_n_steps(int):** 每经过n个连续的正常梯度值才会增大loss scaling值。默认值1000。
+
+**decr_every_n_nan_or_inf(int):** 每经过n个连续的无效梯度值(nan或者inf)才会减小loss scaling值。默认值2。
+
+**incr_ratio(float):** 每次增大loss scaling值的扩增倍数，其为大于1的浮点数。默认值2.0。
+
+**decr_ratio(float):** 每次减小loss scaling值的比例系数，其为小于1的浮点数。默认值0.5。
+
+**custom_white_list(list[str]):** 用户自定义OP开启fp16执行的白名单。
+
+**custom_black_list(list[str]):** 用户自定义OP禁止fp16执行的黑名单。
+
+**示例代码**
+
+.. code-block:: python
+
+  import paddle.distributed.fleet as fleet
+  strategy = fleet.DistributedStrategy()
+  strategy.amp = True
+  strategy.amp_configs = {
+      "init_loss_scaling": 32768,
+      "custom_white_list": ['conv2d']}
+
+.. py:attribute:: dgc
+
+是否启用深度梯度压缩训练。更多信息请参考[Deep Gradient Compression](https://arxiv.org/abs/1712.01887)。 默认值：False
+
+**示例代码**
+
+.. code-block:: python
+
+  import paddle.distributed.fleet as fleet
+  strategy = fleet.DistributedStrategy()
+  strategy.dgc = True  # by default this is false
+
+.. py:attribute:: dgc_configs
+
+设置dgc策略的配置。目前用户可配置 rampup_begin_step，rampup_step，sparsity参数。
+
+**rampup_begin_step(int):** 梯度压缩的起点步。默认值0。
+
+**rampup_step(int):** 使用稀疏预热的时间步长。默认值为1。例如：如果稀疏度为[0.75,0.9375,0.984375,0.996,0.999]，\
+并且rampup_step为100，则在0~19步时使用0.75，在20~39步时使用0.9375，依此类推。当到达sparsity数组末尾时，此后将会使用0.999。
+
+**sparsity(list[float]):** 从梯度张量中获取top个重要元素，比率为（1-当前稀疏度）。默认值为[0.999]。\
+例如：如果sparsity为[0.99, 0.999]，则将传输top [1%, 0.1%]的重要元素。
+
+**示例代码**
+
+.. code-block:: python
+
+  import paddle.distributed.fleet as fleet
+  strategy = fleet.DistributedStrategy()
+  strategy.dgc = True
+  strategy.dgc_configs = {"rampup_begin_step": 1252}
+

doc/paddle/api/paddle/distributed/fleet/Fleet_cn.rst

@@ -6,80 +6,723 @@ Fleet
 
 .. py:class:: paddle.distributed.fleet.Fleet
 
-
+Fleet是飞桨分布式训练统一API, 只需要import fleet并简单初始化后即可快速开始使用飞桨大规模分布式训练
 
 
 .. py:method:: init(role_maker=None, is_collective=False)
 
+使用RoleMaker或其他配置初始化fleet。
+
+
+参数：
+    role_maker (RoleMakerBase) 已初始化好的PaddleCloudRoleMaker或UserDefineRoleMaker
+    is_collective (bool) 在未指定role_maker的情况下,可由init方法自行初始化RoleMaker, is_collective为True则按照collective模式进行创建， is_collective=False则按照ParameterServer模式进行创建
+
+返回：None
+
+
+**代码示例1**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+
+**代码示例2**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init(is_collective=True)
+
+**代码示例3**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    role = fleet.PaddleCloudRoleMaker()
+    fleet.init(role)
+
 
 .. py:method:: is_first_worker()
 
+返回当前节点是否为第一个`worker`节点, 判断当前worker_index是否为0， 如果为0则返回True，否则返回False
+
+返回：True/False
+
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+    fleet.is_first_worker()
+
+
 
 .. py:method:: worker_index()
 
+返回当前节点的编号, 每个`worker`节点被分配[0, worker_num-1]内的唯一的编码ID
+
+返回：int
+
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+    fleet.worker_index()
+
 
 .. py:method:: worker_num()
 
+返回当前全部训练节点中`workjer`节点的个数
+
+返回：int
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+    fleet.worker_num()
+
 
 .. py:method:: is_worker()
 
+返回当前节点是否为`worker`节点
+
+返回：True/False
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+    fleet.is_worker()
+
 
 .. py:method:: worker_endpoints(to_string=False)
 
+返回全部worker节点的ip及端口信息
+
+返回：list/string
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+    fleet.worker_endpoints()
+
 
 .. py:method:: server_num()
 
+**注意：**
+
+  **该参数只在ParameterServer模式下生效**
+
+
+返回当前全部Server节点的个数
+
+返回：int
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+    fleet.server_num()
+
 
 .. py:method:: server_index()
 
 
+**注意：**
+
+  **该参数只在ParameterServer模式下生效**
+
+
+返回当前节点的编号, 每个`server`节点被分配[0, server_num-1]内的唯一的编码ID
+
+返回：int
+
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+    fleet.server_index()
+
+
 .. py:method:: server_endpoints(to_string=False)
 
 
+**注意：**
+
+  **该参数只在ParameterServer模式下生效**
+
+
+返回全部server节点的ip及端口信息
+
+返回：list/string
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+    fleet.server_endpoints()
+
+
 .. py:method:: is_server()
 
 
+**注意：**
+
+  **该参数只在ParameterServer模式下生效**
+
+
+返回当前节点是否为`server`节点
+
+返回：True/False
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+    fleet.is_server()
+
+
 .. py:method:: barrier_worker()
 
+调用集合通信功能，强制要求所有的worker在此处相互等待一次
+
+返回：无
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+    fleet.barrier_worker()
+
 
 .. py:method:: init_worker()
 
+worker节点在训练前的初始化, 包括通信模块， 参数同步等
+
+返回：无
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+    fleet.init_worker()
+
 
 .. py:method:: init_server(*args, **kwargs)
 
+server节点的初始化, 包括server端参数初始化，模型加载等
+
+返回：无
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+    fleet.init_server()
+
 
 .. py:method:: run_server()
 
+server节点的运行, 此命令会将ParameterServer的进程启动并常驻直至训练结束
+
+返回：无
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+    fleet.init_server()
+    fleet.run_server()
+
 
 .. py:method:: stop_worker()
 
+停止当前正在运行的worker节点
+
+返回：无
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    fleet.init()
+    fleet.init_worker()
+    "..."
+    fleet.stop_worker()
+
 
 .. py:method:: save_inference_model(executor, dirname, feeded_var_names, target_vars, main_program=None, export_for_deployment=True)
 
+修剪指定的 ``main_program`` 以构建一个专门用于预测的 ``Inference Program`` （ ``Program`` 含义详见 :ref:`api_guide_Program` ）。 所得到的 ``Inference Program`` 及其对应的所>有相关参数均被保存到 ``dirname`` 指定的目录中。
+
+
+参数:
+  - **executor** (Executor) –  用于保存预测模型的 ``executor`` ，详见 :ref:`api_guide_executor` 。
+  - **dirname** (str) – 指定保存预测模型结构和参数的文件目录。
+  - **feeded_var_names** (list[str]) – 字符串列表，包含着Inference Program预测时所需提供数据的所有变量名称（即所有输入变量的名称）。
+  - **target_vars** (list[Variable]) – ``Variable`` （详见 :ref:`api_guide_Program` ）类型列表，包含着模型的所有输出变量。通过这些输出变量即可得到模型的预测结果。
+  - **main_program** (Program，可选) – 通过该参数指定的 ``main_program`` 可构建一个专门用于预测的 ``Inference Program`` 。 若为None, 则使用全局默认的  ``_main_program_`` 。>默认值为None。
+  - **export_for_deployment** (bool，可选) – 若为True，则 ``main_program`` 指定的Program将被修改为只支持直接预测部署的Program。否则，将存储更多的信息，方便优化和再训练。目前
+只支持设置为True，且默认值为True。
+
+
+返回：无
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    import paddle.fluid as fluid
+
+    fleet.init()
+
+    # build net
+    # fleet.distributed_optimizer(...)
+
+    exe = fluid.Executor(fluid.CPUPlace())
+    fleet.save_inference_model(exe, "dirname", ["feednames1"], [acc, loss], fluid.default_main_program())
+
 
 .. py:method:: save_persistables(executor, dirname, main_program=None)
 
 
+保存全量模型参数
+
+参数:
+ - **executor**  (Executor) – 用于保存持久性变量的 ``executor`` ，详见 :ref:`api_guide_executor` 。
+ - **dirname**  (str) – 用于储存持久性变量的文件目录。
+ - **main_program**  (Program，可选) – 需要保存持久性变量的Program（ ``Program`` 含义详见 :ref:`api_guide_Program` ）。如果为None，则使用default_main_Program 。默认值为None>。
+
+返回：无
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    import paddle.fluid as fluid
+
+    fleet.init()
+
+    # build net
+    # fleet.distributed_optimizer(...)
+
+    exe = fluid.Executor(fluid.CPUPlace())
+    fleet.save_persistables(exe, "dirname", fluid.default_main_program())
+
+
 .. py:method:: distributed_optimizer(optimizer, strategy=None)
 
+基于分布式布式并行策略进行模型的拆分及优化。
+
+**代码示例**
+
+.. code-block:: python
+    import paddle.distributed.fleet as fleet
+    role = fleet.role_maker.PaddleCloudRoleMaker(is_collective=True)
+    fleet.init(role)
+    strategy = fleet.DistributedStrategy()
+    optimizer = paddle.optimizer.SGD(learning_rate=0.001)
+    optimizer = fleet.distributed_optimizer(optimizer, strategy=strategy)
+
 
 .. py:method:: distributed_model(model)
 
+**注意：**
+
+  **1. 该API只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
+
+返回分布式数据并行模型。
+
+参数：
+    model (Layer) - 用户定义的模型，此处模型是指继承动态图Layer的网络。
+
+返回：分布式数据并行模型，该模型同样继承动态图Layer。
+
+
+**代码示例**
+
+.. code-block:: python
+
+
+    # 这个示例需要由fleetrun启动, 用法为:
+    # fleetrun --gpus=0,1 example.py
+    # 脚本example.py中的代码是下面这个示例.
+
+    import paddle
+    import paddle.nn as nn
+    from paddle.distributed import fleet
+
+    class LinearNet(nn.Layer):
+        def __init__(self):
+            super(LinearNet, self).__init__()
+            self._linear1 = nn.Linear(10, 10)
+            self._linear2 = nn.Linear(10, 1)
+
+        def forward(self, x):
+            return self._linear2(self._linear1(x))
+
+    # 1. enable dynamic mode
+    paddle.disable_static()
+
+    # 2. initialize fleet environment
+    fleet.init(is_collective=True)
+
+    # 3. create layer & optimizer
+    layer = LinearNet()
+    loss_fn = nn.MSELoss()
+    adam = paddle.optimizer.Adam(
+        learning_rate=0.001, parameters=layer.parameters())
+
+    # 4. get data_parallel model using fleet
+    adam = fleet.distributed_optimizer(adam)
+    dp_layer = fleet.distributed_model(layer)
+
+    # 5. run layer
+    inputs = paddle.randn([10, 10], 'float32')
+    outputs = dp_layer(inputs)
+    labels = paddle.randn([10, 1], 'float32')
+    loss = loss_fn(outputs, labels)
+
+    print("loss:", loss.numpy())
+
+    loss = dp_layer.scale_loss(loss)
+    loss.backward()
+    dp_layer.apply_collective_grads()
+
+    adam.step()
+    adam.clear_grad()
 
 .. py:method:: state_dict()
 
+**注意：**
+
+  **1. 该API只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
+
+以 ``dict`` 返回当前 ``optimizer`` 使用的所有Tensor 。比如对于Adam优化器，将返回 beta1, beta2, momentum 等Tensor。
+
+返回：dict, 当前 ``optimizer`` 使用的所有Tensor。
+
+
+**代码示例**
+
+.. code-block:: python
+
+    # 这个示例需要由fleetrun启动, 用法为:
+    # fleetrun --gpus=0,1 example.py
+    # 脚本example.py中的代码是下面这个示例.
+
+    import numpy as np
+    import paddle
+    from paddle.distributed import fleet
+
+    paddle.disable_static()
+    fleet.init(is_collective=True)
+
+    value = np.arange(26).reshape(2, 13).astype("float32")
+    a = paddle.fluid.dygraph.to_variable(value)
+
+    layer = paddle.nn.Linear(13, 5)
+    adam = paddle.optimizer.Adam(learning_rate=0.01, parameters=layer.parameters())
+
+    adam = fleet.distributed_optimizer(adam)
+    dp_layer = fleet.distributed_model(layer)
+    state_dict = adam.state_dict()
+
+
+.. py:method:: set_state_dict(state_dict)
+
+**注意：**
+
+  **1. 该API只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
+
+加载 ``optimizer`` 的Tensor字典给当前 ``optimizer`` 。
+
+返回：None
+
+
+**代码示例**
+
+.. code-block:: python
+
+    # 这个示例需要由fleetrun启动, 用法为:
+    # fleetrun --gpus=0,1 example.py
+    # 脚本example.py中的代码是下面这个示例.
+
+    import numpy as np
+    import paddle
+    from paddle.distributed import fleet
+
+    paddle.disable_static()
+    fleet.init(is_collective=True)
+
+    value = np.arange(26).reshape(2, 13).astype("float32")
+    a = paddle.fluid.dygraph.to_variable(value)
+
+    layer = paddle.nn.Linear(13, 5)
+    adam = paddle.optimizer.Adam(learning_rate=0.01, parameters=layer.parameters())
+
+    adam = fleet.distributed_optimizer(adam)
+    dp_layer = fleet.distributed_model(layer)
+    state_dict = adam.state_dict()
+    paddle.framework.save(state_dict, "paddle_dy")
+    para_state_dict, opti_state_dict = paddle.framework.load( "paddle_dy")
+    adam.set_state_dict(opti_state_dict)
+
 
 .. py:method:: set_lr(value)
 
+**注意：**
+
+  **1. 该API只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
+
+手动设置当前 ``optimizer`` 的学习率。
+
+参数：
+    value (float) - 需要设置的学习率的值。
+
+返回：None
+
+
+**代码示例**
+
+.. code-block:: python
+
+    # 这个示例需要由fleetrun启动, 用法为:
+    # fleetrun --gpus=0,1 example.py
+    # 脚本example.py中的代码是下面这个示例.
+
+    import numpy as np
+    import paddle
+    from paddle.distributed import fleet
+
+    paddle.disable_static()
+    fleet.init(is_collective=True)
+
+    value = np.arange(26).reshape(2, 13).astype("float32")
+    a = paddle.fluid.dygraph.to_variable(value)
+
+    layer = paddle.nn.Linear(13, 5)
+    adam = paddle.optimizer.Adam(learning_rate=0.01, parameters=layer.parameters())
+
+    adam = fleet.distributed_optimizer(adam)
+    dp_layer = fleet.distributed_model(layer)
+
+    lr_list = [0.2, 0.3, 0.4, 0.5, 0.6]
+    for i in range(5):
+        adam.set_lr(lr_list[i])
+        lr = adam.get_lr()
+        print("current lr is {}".format(lr))
+    # Print:
+    #    current lr is 0.2
+    #    current lr is 0.3
+    #    current lr is 0.4
+    #    current lr is 0.5
+    #    current lr is 0.6
+
 
 .. py:method:: get_lr()
 
+**注意：**
+
+  **1. 该API只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
+
+获取当前步骤的学习率。
+
+返回：float，当前步骤的学习率。
+
+
+
+**代码示例**
+
+.. code-block:: python
+
+    # 这个示例需要由fleetrun启动, 用法为:
+    # fleetrun --gpus=0,1 example.py
+    # 脚本example.py中的代码是下面这个示例.
+
+    import numpy as np
+    import paddle
+    from paddle.distributed import fleet
+
+    paddle.disable_static()
+    fleet.init(is_collective=True)
+
+    value = np.arange(26).reshape(2, 13).astype("float32")
+    a = paddle.fluid.dygraph.to_variable(value)
+
+    layer = paddle.nn.Linear(13, 5)
+    adam = paddle.optimizer.Adam(learning_rate=0.01, parameters=layer.parameters())
+
+    adam = fleet.distributed_optimizer(adam)
+    dp_layer = fleet.distributed_model(layer)
+
+    lr = adam.get_lr()
+    print(lr) # 0.01
+
 
 .. py:method:: step()
 
+**注意：**
+
+  **1. 该API只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
+
+执行一次优化器并进行参数更新。
+
+返回：None。
+
+
+**代码示例**
+
+.. code-block:: python
+
+    # 这个示例需要由fleetrun启动, 用法为:
+    # fleetrun --gpus=0,1 example.py
+    # 脚本example.py中的代码是下面这个示例.
+
+    import paddle
+    import paddle.nn as nn
+    from paddle.distributed import fleet
+
+    class LinearNet(nn.Layer):
+        def __init__(self):
+            super(LinearNet, self).__init__()
+            self._linear1 = nn.Linear(10, 10)
+            self._linear2 = nn.Linear(10, 1)
+
+        def forward(self, x):
+            return self._linear2(self._linear1(x))
+
+    # 1. enable dynamic mode
+    paddle.disable_static()
+
+    # 2. initialize fleet environment
+    fleet.init(is_collective=True)
+
+    # 3. create layer & optimizer
+    layer = LinearNet()
+    loss_fn = nn.MSELoss()
+    adam = paddle.optimizer.Adam(
+        learning_rate=0.001, parameters=layer.parameters())
+
+    # 4. get data_parallel model using fleet
+    adam = fleet.distributed_optimizer(adam)
+    dp_layer = fleet.distributed_model(layer)
+
+    # 5. run layer
+    inputs = paddle.randn([10, 10], 'float32')
+    outputs = dp_layer(inputs)
+    labels = paddle.randn([10, 1], 'float32')
+    loss = loss_fn(outputs, labels)
+
+    print("loss:", loss.numpy())
+
+    loss = dp_layer.scale_loss(loss)
+    loss.backward()
+    dp_layer.apply_collective_grads()
+
+    adam.step()
+    adam.clear_grad()
+
 
 .. py:method:: clear_grad()
 
+**注意：**
+
+  **1. 该API只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
+
+
+清除需要优化的参数的梯度。
+
+返回：None。
+
+
+**代码示例**
+
+.. code-block:: python
+
+    # 这个示例需要由fleetrun启动, 用法为:
+    # fleetrun --gpus=0,1 example.py
+    # 脚本example.py中的代码是下面这个示例.
+
+    import paddle
+    import paddle.nn as nn
+    from paddle.distributed import fleet
+
+    class LinearNet(nn.Layer):
+        def __init__(self):
+            super(LinearNet, self).__init__()
+            self._linear1 = nn.Linear(10, 10)
+            self._linear2 = nn.Linear(10, 1)
+
+        def forward(self, x):
+            return self._linear2(self._linear1(x))
+
+    # 1. enable dynamic mode
+    paddle.disable_static()
+
+    # 2. initialize fleet environment
+    fleet.init(is_collective=True)
+
+    # 3. create layer & optimizer
+    layer = LinearNet()
+    loss_fn = nn.MSELoss()
+    adam = paddle.optimizer.Adam(
+        learning_rate=0.001, parameters=layer.parameters())
+
+    # 4. get data_parallel model using fleet
+    adam = fleet.distributed_optimizer(adam)
+    dp_layer = fleet.distributed_model(layer)
+
+    # 5. run layer
+    inputs = paddle.randn([10, 10], 'float32')
+    outputs = dp_layer(inputs)
+    labels = paddle.randn([10, 1], 'float32')
+    loss = loss_fn(outputs, labels)
+
+    print("loss:", loss.numpy())
+
+    loss = dp_layer.scale_loss(loss)
+    loss.backward()
+    dp_layer.apply_collective_grads()
+
+    adam.step()
+    adam.clear_grad()
+
 
 .. py:method:: minimize(loss, startup_program=None, parameter_list=None, no_grad_set=None)
 

doc/paddle/api/paddle/distributed/fleet/PaddleCloudRoleMaker_cn.rst

@@ -5,6 +5,41 @@ PaddleCloudRoleMaker
 
 .. py:class:: paddle.distributed.fleet.PaddleCloudRoleMaker
 
+PaddleCloudRoleMaker是基于从环境变量中获取分布式相关信息进行分布式配置初始化的接口.
+它会自动根据用户在环境变量中的配置进行分布式训练环境初始化，目前PaddleCloudRoleMaker支持ParameterServer分布式训练及Collective分布式训练两种模式的初始化。
 
 
+**代码示例**
+
+.. code-block:: python
+
+    import os
+    import paddle.distributed.fleet as fleet
+
+    os.environ["PADDLE_PSERVER_NUMS"] = "2"
+    os.environ["PADDLE_TRAINERS_NUM"] = "2"
+
+    os.environ["POD_IP"] = "127.0.0.1"
+    os.environ["PADDLE_PORT"] = "36001"
+    os.environ["TRAINING_ROLE"] = "PSERVER"
+    os.environ["PADDLE_PSERVERS_IP_PORT_LIST"] = \
+        "127.0.0.1:36001,127.0.0.2:36001"
+
+    os.environ["PADDLE_TRAINER_ID"] = "0"
+
+    fleet.PaddleCloudRoleMaker(is_collective=False)
+
+.. py:method:: to_string()
+将当前环境变量以字符串的形式输出
+
+返回: string
+
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    role = fleet.PaddleCloudRoleMaker(is_collective=False)
+    role.to_string()
 

doc/paddle/api/paddle/distributed/fleet/UserDefinedRoleMaker_cn.rst

@@ -5,6 +5,45 @@ UserDefinedRoleMaker
 
 .. py:class:: paddle.distributed.fleet.UserDefinedRoleMaker
 
+UserDefinedRoleMaker是基于从用户自定义的参数中获取分布式相关信息进行分布式配置初始化的接口
+它会自动根据用户的自定义配置进行分布式训练环境初始化，目前UserDefinedRoleMaker支持ParameterServer分布式训练及Collective分布式训练两种模式的初始化。
+
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    from paddle.distributed.fleet.base.role_maker import Role
+
+    fleet.UserDefinedRoleMaker(
+        current_id=0,
+        role=Role.SERVER,
+        worker_num=2,
+        server_endpoints=["127.0.0.1:36011", "127.0.0.1:36012"])
+
+.. py:method:: to_string()
+将当前环境变量以字符串的形式输出
+
+返回: string
+
+
+**代码示例**:
+
+.. code-block:: python
+
+    import paddle.distributed.fleet as fleet
+    from paddle.distributed.fleet.base.role_maker import Role
+
+    role = fleet.UserDefinedRoleMaker(
+        current_id=0,
+        role=Role.SERVER,
+        worker_num=2,
+        server_endpoints=["127.0.0.1:36011", "127.0.0.1:36012"])
+
+    role.to_string()
+
+
 
 
 

doc/paddle/api/paddle/distributed/fleet/UtilBase_cn.rst

@@ -4,7 +4,189 @@ UtilBase
 -------------------------------
 
 .. py:class:: paddle.distributed.fleet.UtilBase
+分布式训练工具类，主要提供集合通信、文件系统操作等接口。
 
+.. py:method:: all_reduce(input, mode="sum", comm_world="worker")
+在指定的通信集合间进行归约操作，并将归约结果返回给集合中每个实例。
 
+参数：
+    - **input** (list|numpy.array) – 归约操作的输入。
+    - **mode** (str) - 归约操作的模式，包含求和，取最大值和取最小值，默认为求和归约。
+    - **comm_world** (str) - 归约操作的通信集合，包含: server集合(“server")，worker集合("worker")及所有节点集合("all")，默认为worker集合。
 
+返回：
+    - Numpy.array|None: 一个和 `input` 形状一致的numpy数组或None.
 
+**代码示例**:
+
+.. code-block:: python
+
+    # Save the following code in `train.py` , and then execute the command `fleetrun --server_num 2 --worker_num 2 train.py` .
+    from paddle.distributed.fleet.base.util_factory import fleet_util
+    import paddle.distributed.fleet as fleet
+    from paddle.distributed.fleet import PaddleCloudRoleMaker
+    import sys
+    import numpy as np
+
+    def train():
+        role = PaddleCloudRoleMaker(
+            is_collective=False,
+            init_gloo=True,
+            path="./tmp_gloo")
+        fleet.init(role)
+        fleet_util._set_role_maker(role)
+
+        if fleet.is_server():
+            input = [1, 2]
+            output = fleet_util.all_reduce(input, "sum", "server")
+            print(output)
+            # [2, 4]
+        elif fleet.is_worker():
+            input = np.array([3, 4])
+            output = fleet_util.all_reduce(input, "sum", "worker")
+            print(output)
+            # [6, 8]
+        output = fleet_util.all_reduce(input, "sum", "all")
+        print(output)
+        # [8, 12]
+    if __name__ == "__main__":
+        train()
+
+.. py:method:: barrier(comm_world="worker")
+在指定的通信集合间进行阻塞操作，以实现集合间进度同步。
+
+参数：
+   - **comm_world** (str) - 阻塞操作的通信集合，包含: server集合(“server")，worker集合("worker")及所有节点集合("all")，默认为worker集合。
+
+**代码示例**:
+
+.. code-block:: python
+
+    # Save the following code in `train.py` , and then execute the command `fleetrun --server_num 2 --worker_num 2 train.py` .
+
+    from paddle.distributed.fleet.base.util_factory import fleet_util
+    import paddle.distributed.fleet as fleet
+    from paddle.distributed.fleet import PaddleCloudRoleMaker
+    import sys
+
+    def train():
+        role = PaddleCloudRoleMaker(
+            is_collective=False,
+            init_gloo=True,
+            path="./tmp_gloo")
+        fleet.init(role)
+        fleet_util._set_role_maker(role)
+
+        if fleet.is_server():
+            fleet_util.barrier("server")
+            print("all server arrive here")
+        elif fleet.is_worker():
+            fleet_util.barrier("worker")
+            print("all server arrive here")
+        fleet_util.barrier("all")
+        print("all servers and workers arrive here")
+
+    if __name__ == "__main__":
+        train()
+
+.. py:method:: all_gather(input, comm_world="worker")
+在指定的通信集合间进行聚合操作，并将聚合的结果返回给集合中每个实例。
+
+参数：
+   - **input** (int|float) - 聚合操作的输入。
+   - **comm_world** (str) - 聚合操作的通信集合，包含: server集合(“server")，worker集合("worker")及所有节点集合("all")，默认为worker集合。
+
+返回：
+   - **output** (List): List格式的聚合结果。
+
+**代码示例**:
+
+.. code-block:: python
+
+    # Save the following code in `train.py` , and then execute the command `fleetrun --server_num 2 --worker_num 2 train.py` .
+    from paddle.distributed.fleet.base.util_factory import fleet_util
+    import paddle.distributed.fleet as fleet
+    from paddle.distributed.fleet import PaddleCloudRoleMaker
+    import sys
+
+    def train():
+        role = PaddleCloudRoleMaker(
+            is_collective=False,
+            init_gloo=True,
+            path="./tmp_gloo")
+        fleet.init(role)
+        fleet_util._set_role_maker(role)
+
+        if fleet.is_server():
+            input = fleet.server_index()
+            output = fleet_util.all_gather(input, "server")
+            print(output)
+            # output = [0, 1]
+        elif fleet.is_worker():
+            input = fleet.worker_index()
+            output = fleet_util.all_gather(input, "worker")
+            # output = [0, 1]
+            print(output)
+        output = fleet_util.all_gather(input, "all")
+        print(output)
+        # output = [0, 1, 0, 1]
+
+    if __name__ == "__main__":
+        train()
+
+.. py:method:: get_file_shard(files)
+在数据并行的分布式训练中，获取属于当前训练节点的文件列表。
+
+.. code-block:: text
+
+    示例 1: 原始所有文件列表 `files` = [a, b, c ,d, e]，训练节点个数 `trainer_num` = 2，那么属于零号节点的训练文件为[a, b, c]，属于1号节点的训练文件为[d, e]。
+    示例 2: 原始所有文件列表 `files` = [a, b]，训练节点个数 `trainer_num` = 3，那么属于零号节点的训练文件为[a]，属于1号节点的训练文件为[b]，属于2号节点的训练文件为[]。
+
+参数：
+    - **files** (List)：原始所有文件列表。
+
+返回：
+    - List: 属于当前训练节点的文件列表。
+
+**代码示例**:
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.base.util_factory import fleet_util
+    import paddle.distributed.fleet.base.role_maker as role_maker
+
+    role = role_maker.UserDefinedRoleMaker(
+        is_collective=False,
+        init_gloo=False,
+        current_id=0,
+        role=role_maker.Role.WORKER,
+        worker_endpoints=["127.0.0.1:6003", "127.0.0.1:6004"],
+        server_endpoints=["127.0.0.1:6001", "127.0.0.1:6002"])
+    fleet_util._set_role_maker(role)
+    files = fleet_util.get_file_shard(["file1", "file2", "file3"])
+    # files = ["file1", "file2"]
+
+.. py:method:: print_on_rank(message, rank_id)
+
+在编号为 `rank_id` 的节点上打印指定信息。
+
+参数：
+    - **message** (str) – 打印内容。
+    - **rank_id** (int) - 节点编号。
+
+**代码示例**:
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.base.util_factory import fleet_util
+    import paddle.distributed.fleet.base.role_maker as role_maker
+
+    role = role_maker.UserDefinedRoleMaker(
+        is_collective=False,
+        init_gloo=False,
+        current_id=0,
+        role=role_maker.Role.WORKER,
+        worker_endpoints=["127.0.0.1:6003", "127.0.0.1:6004"],
+        server_endpoints=["127.0.0.1:6001", "127.0.0.1:6002"])
+    fleet_util._set_role_maker(role)
+    fleet_util.print_on_rank("I'm worker 0", 0)
\ No newline at end of file

doc/paddle/api/paddle/distributed/fleet/utils/fs/ExecuteError_cn.rst

-.. _cn_api_distributed_fleet_utils_fs_ExecuteError:
-
-ExecuteError
--------------------------------
-
-.. py:class:: paddle.distributed.fleet.utils.fs.ExecuteError
-
-
-
-

doc/paddle/api/paddle/distributed/fleet/utils/fs/FSFileExistsError_cn.rst

-.. _cn_api_distributed_fleet_utils_fs_FSFileExistsError:
-
-FSFileExistsError
--------------------------------
-
-.. py:class:: paddle.distributed.fleet.utils.fs.FSFileExistsError
-
-
-
-

doc/paddle/api/paddle/distributed/fleet/utils/fs/FSFileNotExistsError_cn.rst

-.. _cn_api_distributed_fleet_utils_fs_FSFileNotExistsError:
-
-FSFileNotExistsError
--------------------------------
-
-.. py:class:: paddle.distributed.fleet.utils.fs.FSFileNotExistsError
-
-
-
-

doc/paddle/api/paddle/distributed/fleet/utils/fs/FSShellCmdAborted_cn.rst

-.. _cn_api_distributed_fleet_utils_fs_FSShellCmdAborted:
-
-FSShellCmdAborted
--------------------------------
-
-.. py:class:: paddle.distributed.fleet.utils.fs.FSShellCmdAborted
-
-
-
-

doc/paddle/api/paddle/distributed/fleet/utils/fs/FSTimeOut_cn.rst

-.. _cn_api_distributed_fleet_utils_fs_FSTimeOut:
-
-FSTimeOut
--------------------------------
-
-.. py:class:: paddle.distributed.fleet.utils.fs.FSTimeOut
-
-
-
-

doc/paddle/api/paddle/distributed/fleet/utils/fs/FS_cn.rst

-.. _cn_api_distributed_fleet_utils_fs_FS:
-
-FS
--------------------------------
-
-.. py:class:: paddle.distributed.fleet.utils.fs.FS
-
-
-
-

doc/paddle/api/paddle/distributed/fleet/utils/fs/HDFSClient_cn.rst

@@ -3,8 +3,279 @@
 HDFSClient
 -------------------------------
 
-.. py:class:: paddle.distributed.fleet.utils.fs.HDFSClient
+.. py:class:: paddle.distributed.fleet.utils.HDFSClient
+一个HADOOP文件系统工具类。
 
+参数：
+    - **hadoop_home** (str)：HADOOP HOME地址。
+    - **configs** (dict): HADOOP文件系统配置。需包含 `fs.default.name` 和 `hadoop.job.ugi` 这两个字段。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import HDFSClient
+    hadoop_home = "/home/client/hadoop-client/hadoop/"
+
+    configs = {
+        "fs.default.name": "hdfs://xxx.hadoop.com:54310",
+        "hadoop.job.ugi": "hello,hello123"
+    }
+
+    client = HDFSClient(hadoop_home, configs)
+    client.ls_dir("hdfs:/test_hdfs_client")
+
+.. py:method:: ls_dir(fs_path)
+列出 `fs_path` 路径下所有的文件和子目录。
+
+参数：
+    - **fs_path** (str): HADOOP文件路径。
+
+返回：
+    - Tuple， 一个包含所有子目录和文件名的2-Tuple，格式形如: ([subdirname1, subdirname1, ...], [filename1, filename2, ...])。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import HDFSClient
+
+    hadoop_home = "/home/client/hadoop-client/hadoop/"
+    configs = {
+        "fs.default.name": "hdfs://xxx.hadoop.com:54310",
+        "hadoop.job.ugi": "hello,hello123"
+    }
+
+    client = HDFSClient(hadoop_home, configs)
+    subdirs, files = client.ls_dir("hdfs:/test_hdfs_client")
+
+.. py:method:: mkdirs(fs_path)
+创建一个目录。
+
+参数：
+    - **fs_path** (str): HADOOP文件路径。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import HDFSClient
+
+    hadoop_home = "/home/client/hadoop-client/hadoop/"
+    configs = {
+        "fs.default.name": "hdfs://xxx.hadoop.com:54310",
+        "hadoop.job.ugi": "hello,hello123"
+    }
+
+    client = HDFSClient(hadoop_home, configs)
+    client.mkdirs("hdfs:/test_hdfs_client")
+
+.. py:method:: delete(fs_path)
+删除HADOOP文件（或目录）。
+
+参数：
+    - **fs_path** (str): HADOOP文件路径。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import HDFSClient
+
+    hadoop_home = "/home/client/hadoop-client/hadoop/"
+    configs = {
+        "fs.default.name": "hdfs://xxx.hadoop.com:54310",
+        "hadoop.job.ugi": "hello,hello123"
+    }
+
+    client = HDFSClient(hadoop_home, configs)
+    client.delete("hdfs:/test_hdfs_client")
+
+.. py:method:: is_file(fs_path)
+判断当前路径是否是一个文件。
+
+参数：
+    - **fs_path** (str): HADOOP文件路径。
+
+返回：
+    - Bool：若当前路径存在且是一个文件，返回 `True` ，反之则返回 `False` 。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import HDFSClient
+
+    hadoop_home = "/home/client/hadoop-client/hadoop/"
+    configs = {
+        "fs.default.name": "hdfs://xxx.hadoop.com:54310",
+        "hadoop.job.ugi": "hello,hello123"
+    }
+
+    client = HDFSClient(hadoop_home, configs)
+    ret = client.is_file("hdfs:/test_hdfs_client")
+
+.. py:method:: is_dir(fs_path)
+判断当前路径是否是一个目录。
+
+参数：
+    - **fs_path** (str): HADOOP文件路径。
+
+返回：
+    - Bool：若当前路径存在且是一个目录，返回 `True` ，反之则返回 `False` 。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import HDFSClient
+
+    hadoop_home = "/home/client/hadoop-client/hadoop/"
+    configs = {
+        "fs.default.name": "hdfs://xxx.hadoop.com:54310",
+        "hadoop.job.ugi": "hello,hello123"
+    }
+
+    client = HDFSClient(hadoop_home, configs)
+    ret = client.is_file("hdfs:/test_hdfs_client")
+
+.. py:method:: is_exist(fs_path)
+判断当前路径是否存在。
+
+参数：
+    - **fs_path** (str): HADOOP文件路径。
+
+返回：
+    - Bool：若当前路径存在返回 `True` ，反之则返回 `False` 。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import HDFSClient
+
+    hadoop_home = "/home/client/hadoop-client/hadoop/"
+    configs = {
+        "fs.default.name": "hdfs://xxx.hadoop.com:54310",
+        "hadoop.job.ugi": "hello,hello123"
+    }
+
+    client = HDFSClient(hadoop_home, configs)
+    ret = client.is_exist("hdfs:/test_hdfs_client")
+
+.. py:method:: upload(local_path, fs_path)
+上传本地文件至HADOOP文件系统。
+
+参数：
+    - **local_path** (str): 本地文件路径。
+    - **fs_path** (str): HADOOP文件路径。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import HDFSClient
+
+    hadoop_home = "/home/client/hadoop-client/hadoop/"
+    configs = {
+        "fs.default.name": "hdfs://xxx.hadoop.com:54310",
+        "hadoop.job.ugi": "hello,hello123"
+    }
+
+    client = HDFSClient(hadoop_home, configs)
+    client.upload("test_hdfs_client", "hdfs:/test_hdfs_client")
+
+.. py:method:: download(fs_path, local_path)
+下载HADOOP文件至本地文件系统。
+
+参数：
+    - **local_path** (str): 本地文件路径。
+    - **fs_path** (str): HADOOP文件路径。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import HDFSClient
+
+    hadoop_home = "/home/client/hadoop-client/hadoop/"
+    configs = {
+        "fs.default.name": "hdfs://xxx.hadoop.com:54310",
+        "hadoop.job.ugi": "hello,hello123"
+    }
+
+    client = HDFSClient(hadoop_home, configs)
+    client.download("hdfs:/test_hdfs_client", "./")
+
+
+.. py:method:: touch(fs_path, exist_ok=True)
+创建一个HADOOP文件。
+
+参数：
+    - **fs_path** (str): HADOOP文件路径。
+    - **exist_ok** (bool): 路径已存在时程序是否报错。若 `exist_ok = True`，则直接返回，反之则抛出文件存在的异常，默认不抛出异常。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import HDFSClient
+
+    hadoop_home = "/home/client/hadoop-client/hadoop/"
+    configs = {
+        "fs.default.name": "hdfs://xxx.hadoop.com:54310",
+        "hadoop.job.ugi": "hello,hello123"
+    }
+
+    client = HDFSClient(hadoop_home, configs)
+    client.touch("hdfs:/test_hdfs_client")
+
+.. py:method:: mv(fs_src_path, fs_dst_path, overwrite=False)
+HADOOP系统文件移动。
+
+参数：
+    - **fs_src_path** (str): 移动前源文件路径名。
+    - **fs_dst_path** (str): 移动后目标文件路径名。
+    - **overwrite** (bool): 若目标文件已存在，是否删除进行重写，默认不重写并抛出异常。
+ 
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import HDFSClient
+
+    hadoop_home = "/home/client/hadoop-client/hadoop/"
+    configs = {
+        "fs.default.name": "hdfs://xxx.hadoop.com:54310",
+        "hadoop.job.ugi": "hello,hello123"
+    }
+
+    client = HDFSClient(hadoop_home, configs)
+    client.mv("hdfs:/test_hdfs_client", "hdfs:/test_hdfs_client2")
+
+.. py:method:: list_dirs(fs_path)
+列出HADOOP文件路径下所有的子目录。
+
+参数：
+    - **fs_path** (str): HADOOP文件路径。
+
+返回：
+    - List: 该路径下所有的子目录名。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import HDFSClient
+
+    hadoop_home = "/home/client/hadoop-client/hadoop/"
+    configs = {
+        "fs.default.name": "hdfs://xxx.hadoop.com:54310",
+        "hadoop.job.ugi": "hello,hello123"
+    }
+
+    client = HDFSClient(hadoop_home, configs)
+    subdirs = client.list_dirs("hdfs:/test_hdfs_client")
 
 
 

doc/paddle/api/paddle/distributed/fleet/utils/fs/LocalFS_cn.rst

@@ -3,8 +3,196 @@
 LocalFS
 -------------------------------
 
-.. py:class:: paddle.distributed.fleet.utils.fs.LocalFS
+.. py:class:: paddle.distributed.fleet.utils.LocalFS
+一个本地文件系统工具类。
 
+**示例代码**：
+.. code-block:: python
 
+    from paddle.distributed.fleet.utils import LocalFS
 
+    client = LocalFS()
+    subdirs, files = client.ls_dir("./")
 
+.. py:method:: ls_dir(fs_path)
+列出 `fs_path` 路径下所有的文件和子目录。
+
+参数：
+    - **fs_path** (str): 本地文件路径。
+
+返回：
+    - Tuple， 一个包含所有子目录和文件名的2-Tuple，格式形如: ([subdirname1, subdirname1, ...], [filename1, filename2, ...])。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import LocalFS
+
+    client = LocalFS()
+    subdirs, files = client.ls_dir("./")
+
+.. py:method:: mkdirs(fs_path)
+创建一个本地目录。
+
+参数：
+    - **fs_path** (str): 本地文件路径。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import LocalFS
+
+    client = LocalFS()
+    client.mkdirs("test_mkdirs")
+    client.delete("test_mkdirs")
+
+.. py:method:: rename(fs_src_path, fs_dst_path)
+重命名本地文件名。
+
+参数：
+    - **fs_src_path** (str)：重命名前原始文件名。
+    - **fs_dst_path** (str)：新文件名。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import LocalFS
+
+    client = LocalFS()
+    client.touch("test_rename_src")
+    print(client.is_exists("test_rename_src")) # True
+    client.rename("test_rename_src", "test_rename_dst")
+    print(client.is_exists("test_rename_src")) # False
+    print(client.is_exists("test_rename_dst")) # True
+    client.delete("test_rename_dst")
+
+.. py:method:: delete(fs_path)
+删除本地文件（或目录）。
+
+参数：
+    - **fs_path** (str): 本地文件路径。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import LocalFS
+
+    client = LocalFS()
+    client.mkdirs("test_localFS_mkdirs")
+    client.delete("test_localFS_mkdirs")
+
+.. py:method:: is_file(fs_path)
+判断当前路径是否是一个文件。
+
+参数：
+    - **fs_path** (str): 本地文件路径。
+
+返回：
+    - Bool：若当前路径存在且是一个文件，返回 `True` ，反之则返回 `False` 。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import LocalFS
+
+    client = LocalFS()
+    client.touch("test_is_file")
+    print(client.is_file("test_is_file")) # True
+    client.delete("test_is_file")
+
+.. py:method:: is_dir(fs_path)
+判断当前路径是否是一个目录。
+
+参数：
+    - **fs_path** (str): 本地文件路径。
+
+返回：
+    - Bool：若当前路径存在且是一个目录，返回 `True` ，反之则返回 `False` 。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import LocalFS
+
+    client = LocalFS()
+    client.mkdirs("test_is_dir")
+    print(client.is_dir("test_is_file")) # True
+    client.delete("test_is_dir")
+
+.. py:method:: is_exist(fs_path)
+判断当前路径是否存在。
+
+参数：
+    - **fs_path** (str): 本地文件路径。
+
+返回：
+    - Bool：若当前路径存在返回 `True` ，反之则返回 `False` 。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import LocalFS
+
+    client = LocalFS()
+    ret = local_fs.is_exist("test_is_exist")
+
+.. py:method:: touch(fs_path, exist_ok=True)
+创建一个本地文件。
+
+参数：
+    - **fs_path** (str): 本地文件路径。
+    - **exist_ok** (bool): 文件路径已存在时程序是否报错。若 `exist_ok = True`，则直接返回，反之则抛出文件存在的异常，默认不抛出异常。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import LocalFS
+
+    client = LocalFS()
+    client.touch("test_touch")
+    client.delete("test_touch")
+
+.. py:method:: mv(src_path, dst_path, overwrite=False)
+本地文件移动。
+
+参数：
+    - **src_path** (str): 移动前源文件路径名。
+    - **dst_path** (str): 移动后目标文件路径名。
+    - **overwrite** (bool): 若目标文件已存在，是否删除进行重写，默认不重写并抛出异常。
+ 
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import LocalFS
+
+    client = LocalFS()
+    client.touch("test_mv_src")
+    client.mv("test_mv_src", "test_mv_dst")
+    client.delete("test_mv_dst")
+
+.. py:method:: list_dirs(fs_path)
+列出本地路径下所有的子目录。
+
+参数：
+    - **fs_path** (str): 本地文件路径。
+
+返回：
+    - List: 该路径下所有的子目录名。
+
+**示例代码**：
+
+.. code-block:: python
+
+    from paddle.distributed.fleet.utils import LocalFS
+
+    client = LocalFS()
+    subdirs = client.list_dirs("./")
\ No newline at end of file

doc/paddle/api/paddle/fluid/dygraph/checkpoint/load_dygraph_cn.rst

@@ -4,17 +4,17 @@ load
 ----
 
 
-.. py:function:: paddle.load(model_path, config=None)
+.. py:function:: paddle.fluid.dygraph.load_dygraph(model_path, config=None)
 
 
 该接口用于从磁盘中加载Layer和Optimizer的 ``state_dict`` ，该接口会同时加载 ``model_path + ".pdparams"`` 和 ``model_path + ".pdopt"`` 中的内容。
 
 .. note::
-    由于一些历史原因，如果从 ``paddle.io.save_inference_model`` 的存储结果中载入 ``state_dict`` ，动态图模式下参数的结构性变量名将无法被恢复。并且在将载入的 ``state_dict`` 配置到当前Layer中时，需要配置 ``Layer.set_state_dict`` 的参数 ``use_structured_name=False`` 。
+    如果从 ``paddle.static.save_inference_model`` 的存储结果中载入 ``state_dict`` ，动态图模式下参数的结构性变量名将无法被恢复。并且在将载入的 ``state_dict`` 配置到当前Layer中时，需要配置 ``Layer.set_state_dict`` 的参数 ``use_structured_name=False`` 。
 
 参数:
     - **model_path** (str) – 保存state_dict的文件前缀。该路径不应该包括后缀 ``.pdparams`` 或 ``.pdopt``。
-    - **config** (SaveLoadConfig, 可选) - 用于指定额外配置选项的 :ref:`cn_api_fluid_dygraph_jit_SaveLoadConfig` 对象，这些选项主要是用于兼容 ``paddle.io.save_inference_model`` 存储模型的格式。默认为 ``None``。
+    - **config** (SaveLoadConfig, 可选) - 用于指定额外配置选项的 :ref:`cn_api_fluid_dygraph_jit_SaveLoadConfig` 对象，这些选项主要是用于兼容 ``paddle.static.save_inference_model`` 存储模型的格式。默认为 ``None``。
 
 
 返回: 两个 ``dict`` ，即从文件中恢复的模型参数 ``dict`` 和优化器参数 ``dict``，如果只找到其中一个的存储文件，另一个返回None
@@ -29,13 +29,14 @@ load
 .. code-block:: python
 
     import paddle
+    import paddle.fluid as fluid
 
     paddle.disable_static()
 
-    emb = paddle.nn.Embedding([10, 10])
+    emb = paddle.nn.Embedding(10, 10)
 
     state_dict = emb.state_dict()
-    paddle.save(state_dict, "paddle_dy")
+    fluid.save_dygraph(state_dict, "paddle_dy")
 
     scheduler = paddle.optimizer.lr_scheduler.NoamLR(
         d_model=0.01, warmup_steps=100, verbose=True)
@@ -43,9 +44,9 @@ load
         learning_rate=scheduler,
         parameters=emb.parameters())
     state_dict = adam.state_dict()
-    paddle.save(state_dict, "paddle_dy")
+    fluid.save_dygraph(state_dict, "paddle_dy")
 
-    para_state_dict, opti_state_dict = paddle.load("paddle_dy")
+    para_state_dict, opti_state_dict = fluid.load_dygraph("paddle_dy")
 
 
 

doc/paddle/api/paddle/fluid/dygraph/jit/SaveLoadConfig_cn.rst

@@ -5,7 +5,7 @@ SaveLoadConfig
 
 .. py:class:: paddle.SaveLoadConfig()
 
-用于配置接口 :ref:`cn_api_fluid_dygraph_jit_save` 和 :ref:`cn_api_fluid_dygraph_jit_load` 存储载入 :ref:`cn_api_fluid_dygraph_TranslatedLayer` 时的附加选项。
+用于配置接口 ``paddle.jit.save/load`` 和 ``paddle.load`` 存储载入时的附加选项。
 
 **示例代码：**
 
@@ -74,10 +74,10 @@ SaveLoadConfig
 
 .. py:attribute:: output_spec
 
-选择保存模型（ :ref:`cn_api_fluid_dygraph_TranslatedLayer` ）的输出变量，通过指定的这些变量能够使模型仅计算特定的结果。
-默认情况下，原始 :ref:`cn_api_fluid_dygraph_Layer` 的forward方法的所有返回变量都将配置为存储后模型 :ref:`cn_api_fluid_dygraph_TranslatedLayer` 的输出变量。
+选择保存模型（ ``paddle.jit.TranslatedLayer`` ）的输出变量，通过指定的这些变量能够使模型仅计算特定的结果。
+默认情况下，原始 ``paddle.nn.Layer`` 的forward方法的所有返回变量都将配置为存储后模型 ``paddle.jit.TranslatedLayer`` 的输出变量。
 
-``output_spec`` 属性类型需要是 ``list[Variable]``。如果输入的 ``output_spec`` 列表不是原始 :ref:`cn_api_fluid_dygraph_Layer` 的forward方法的所有返回变量，
+``output_spec`` 属性类型需要是 ``list[Variable]``。如果输入的 ``output_spec`` 列表不是原始 ``paddle.nn.Layer`` 的forward方法的所有返回变量，
 将会依据输入的 ``output_spec`` 列表对存储的模型进行裁剪。
 
 .. note::
@@ -132,7 +132,7 @@ SaveLoadConfig
 
 .. py:attribute:: model_filename
 
-存储转写 :ref:`cn_api_fluid_dygraph_Layer` 模型结构 ``Program`` 的文件名称。默认文件名为 ``__model__``。
+存储转写 ``paddle.nn.Layer`` 模型结构 ``Program`` 的文件名称。默认文件名为 ``__model__``。
 
 **示例代码**
     .. code-block:: python
@@ -183,7 +183,7 @@ SaveLoadConfig
 
 .. py:attribute:: params_filename
 
-存储转写 :ref:`cn_api_fluid_dygraph_Layer` 所有持久参数（包括 ``Parameters`` 和持久的 ``Buffers``）的文件名称。默认文件名称为 ``__variable__``。
+存储转写 ``paddle.nn.Layer`` 所有持久参数（包括 ``Parameters`` 和持久的 ``Buffers``）的文件名称。默认文件名称为 ``__variable__``。
 
 **示例代码**
     .. code-block:: python
@@ -236,10 +236,13 @@ SaveLoadConfig
 .. py:attribute:: separate_params
 
 配置是否将 :ref:`cn_api_fluid_dygraph_Layer` 的参数存储为分散的文件。
-（这是为了兼容接口 :ref:`cn_api_fluid_io_save_inference_model` 的行为）
+（这是为了兼容接口 ``paddle.static.save_inference_model`` 的行为）
 
 如果设置为 ``True`` ，每个参数将会被存储为一个文件，文件名为参数名，同时``SaveLoadConfig.params_filename`` 指定的文件名将不会生效。默认为 ``False``。
 
+.. note::
+    仅用于 ``paddle.load`` 方法.
+
 **示例代码**
     .. code-block:: python
 
@@ -273,7 +276,7 @@ SaveLoadConfig
             adam.clear_grad()
 
         model_path = "simplenet.example.model.separate_params"
-        config = paddle.jit.SaveLoadConfig()
+        config = paddle.SaveLoadConfig()
         config.separate_params = True
 
         # saving with configs.separate_params
@@ -307,11 +310,11 @@ SaveLoadConfig
         linear = paddle.nn.Linear(5, 1)
 
         state_dict = linear.state_dict()
-        paddle.save(state_dict, "paddle_dy")
+        paddle.save(state_dict, "paddle_dy.pdparams")
 
-        configs = paddle.SaveLoadConfig()
-        configs.keep_name_table = True
-        para_state_dict, _ = paddle.load("paddle_dy", configs)
+        config = paddle.SaveLoadConfig()
+        config.keep_name_table = True
+        para_state_dict = paddle.load("paddle_dy.pdparams", config)
 
         print(para_state_dict)
         # the name_table is 'StructuredToParameterName@@'

doc/paddle/api/paddle/fluid/dygraph/layers/Layer_cn.rst

@@ -410,12 +410,12 @@ buffer是一个非参数类型的变量，不会被优化器更新，但在评
                 
     paddle.disable_static()
     
-    emb = paddle.nn.Embedding([10, 10])
+    emb = paddle.nn.Embedding(10, 10)
 
     state_dict = emb.state_dict()
-    paddle.save(state_dict, "paddle_dy")
+    paddle.save(state_dict, "paddle_dy.pdparams")
     
-    para_state_dict, _ = paddle.load("paddle_dy")
+    para_state_dict = paddle.load("paddle_dy.pdparams")
 
     emb.set_state_dict(para_state_dict)
 

doc/paddle/api/paddle/fluid/io/load_cn.rst

-.. _cn_api_fluid_dygraph_jit_load:
+.. _cn_api_fluid_load:
 
 load
------------------
+-------------------------------
 
-.. py:function:: paddle.fluid.dygraph.jit.load(model_path, configs=None)
+.. py:function:: paddle.fluid.load(program, model_path, executor=None, var_list=None)
 
+:api_attr: 声明式编程模式（静态图)
 
-将接口 :ref:`cn_api_fluid_dygraph_jit_save` 或者 :ref:`cn_api_fluid_io_save_inference_model` 存储的模型载入为 :ref:`cn_api_fluid_dygraph_TranslatedLayer` ，用于预测推理或者fine-tune训练。
 
-.. note::
-    由于一些历史原因，如果载入的模型是通过 :ref:`cn_api_fluid_io_save_inference_model` 存储的，
-    在使用它进行fine-tune训练时会存在一些局限：
-    1. 命令式编程模式不支持 ``LoDTensor`` ，所有原先输入变量或者参数依赖于LoD信息的模型暂时无法使用；
-    2. 所有存储模型的feed变量都需要被传入 ``Translatedlayer`` 的forward方法；
-    3. 原模型变量的 ``stop_gradient`` 信息已丢失且无法准确恢复；
-    4. 原模型参数的 ``trainable`` 信息已丢失且无法准确恢复。
 
-参数：
-    - **model_path** (str) - 存储模型的目录。
-    - **configs** (SaveLoadConfig, 可选) - 用于指定额外配置选项的 :ref:`cn_api_fluid_dygraph_jit_SaveLoadConfig` 对象。默认为 ``None``。
+该接口从Program中过滤出参数和优化器信息，然后从文件中获取相应的值。
 
-返回：TranslatedLayer - 一个能够执行存储模型的 ``Layer`` 对象。
+如果Program和加载的文件之间参数的维度或数据类型不匹配，将引发异常。
 
-**示例代码**
+该函数还可以加载用[save_params，save_persistables，save_vars]接口保存的模型文件。
+当[save_params，save_persistables，save_vars]保存的模型格式为单个大文件时，var_list不能为None。
 
-1. 载入由接口 :ref:`cn_api_fluid_dygraph_jit_save` 存储的模型进行预测推理及fine-tune训练。
+参数:
+ - **program**  ( :ref:`cn_api_fluid_Program` ) – 要加载的Program。
+ - **model_path**  (str) – 保存Program的目录名称+文件前缀。格式为 ``目录名称/文件前缀`` 。
+ - **executor** (Executor, 可选) - 当startup program没有运行时，用于初始化参数的Executor。默认值：None。
+ - **var_list** (list, 可选) - 指定加载的变量列表，该参数只在加载旧接口[save_params，save_persistables，save_vars]保存的模型文件时使用。当加载的是多个小文件时，变量列表可以是所有加载文件中变量的子集；当加载的单个大文件时，变量列表必须和加载文件中的变量保持一致。
 
-    .. code-block:: python
+返回: 无
 
-        import numpy as np
+**代码示例**
+
+.. code-block:: python
+
+    # example1
+    import paddle
     import paddle.fluid as fluid
-        from paddle.fluid.dygraph import Linear
-        from paddle.fluid.dygraph import declarative
-        BATCH_SIZE = 32
-        BATCH_NUM = 20
-        def random_batch_reader():
-            def _get_random_images_and_labels(image_shape, label_shape):
-                image = np.random.random(size=image_shape).astype('float32')
-                label = np.random.random(size=label_shape).astype('int64')
-                return image, label
-            def __reader__():
-                for _ in range(BATCH_NUM):
-                    batch_image, batch_label = _get_random_images_and_labels(
-                        [BATCH_SIZE, 784], [BATCH_SIZE, 1])
-                    yield batch_image, batch_label
-            return __reader__
-        class LinearNet(fluid.dygraph.Layer):
-            def __init__(self, in_size, out_size):
-                super(LinearNet, self).__init__()
-                self._linear = Linear(in_size, out_size)
-            @declarative
-            def forward(self, x):
-                return self._linear(x)
-        # 开启命令式编程模式
-        fluid.enable_dygraph() 
-        # 1. 训练存储模型.
-        # 创建网络
-        net = LinearNet(784, 1)
-        adam = fluid.optimizer.AdamOptimizer(learning_rate=0.1, parameter_list=net.parameters())
-        # 创建DataLoader
-        train_loader = fluid.io.DataLoader.from_generator(capacity=5)
-        train_loader.set_batch_generator(random_batch_reader())
-        # 训练
-        for data in train_loader():
-            img, label = data
-            label.stop_gradient = True
-            cost = net(img)
-            loss = fluid.layers.cross_entropy(cost, label)
-            avg_loss = fluid.layers.mean(loss)
-            avg_loss.backward()
-            adam.minimize(avg_loss)
-            net.clear_gradients()
-        model_path = "linear.example.model"
-        fluid.dygraph.jit.save(
-            layer=net,
-            model_path=model_path,
-            input_spec=[img])
-        # 2. 载入模型 & 预测
-        # 载入模型
-        infer_net = fluid.dygraph.jit.load(model_path)
-        # 预测
-        x = fluid.dygraph.to_variable(np.random.random((1, 784)).astype('float32'))
-        pred = infer_net(x)
-        # 3. 载入模型 & fine-tune训练
-        # 载入模型
-        train_net = fluid.dygraph.jit.load(model_path)
-        train_net.train()
-        adam = fluid.optimizer.AdamOptimizer(learning_rate=0.1, parameter_list=train_net.parameters())
-        # 创建DataLoader
-        train_loader = fluid.io.DataLoader.from_generator(capacity=5)
-        train_loader.set_batch_generator(random_batch_reader())
-        # fine-tune训练
-        for data in train_loader():
-            img, label = data
-            label.stop_gradient = True
-            cost = train_net(img)
-            loss = fluid.layers.cross_entropy(cost, label)
-            avg_loss = fluid.layers.mean(loss)
-            avg_loss.backward()
-            adam.minimize(avg_loss)
-            train_net.clear_gradients()
-
-
-2. 载入由接口 :ref:`cn_api_fluid_io_save_inference_model` 存储的模型进行预测推理及fine-tune训练。
-
-    .. code-block:: python
-
-        import numpy as np
+
+    paddle.enable_static()
+
+    x = fluid.data( name="x", shape=[10, 10], dtype='float32')
+    y = fluid.layers.fc(x, 10)
+    z = fluid.layers.fc(y, 10)
+    place = fluid.CPUPlace()
+    exe = fluid.Executor(place)
+    exe.run(fluid.default_startup_program())
+    fluid.save(fluid.default_main_program(), "./test_path")
+    fluid.load(fluid.default_main_program(), "./test_path")
+
+    # example2
+    # 注意example1和example2应该分开执行，避免干扰。
     import paddle.fluid as fluid
-        BATCH_SIZE = 32
-        BATCH_NUM = 20
-        def random_batch_reader():
-            def _get_random_images_and_labels(image_shape, label_shape):
-                image = np.random.random(size=image_shape).astype('float32')
-                label = np.random.random(size=label_shape).astype('int64')
-                return image, label
-            def __reader__():
-                for _ in range(BATCH_NUM):
-                    batch_image, batch_label = _get_random_images_and_labels(
-                        [BATCH_SIZE, 784], [BATCH_SIZE, 1])
-                    yield batch_image, batch_label
-            return __reader__
-        img = fluid.data(name='img', shape=[None, 784], dtype='float32')
-        label = fluid.data(name='label', shape=[None, 1], dtype='int64')
-        pred = fluid.layers.fc(input=img, size=10, act='softmax')
-        loss = fluid.layers.cross_entropy(input=pred, label=label)
-        avg_loss = fluid.layers.mean(loss)
-        optimizer = fluid.optimizer.SGD(learning_rate=0.001)
-        optimizer.minimize(avg_loss)
+
+    x = fluid.data( name="x", shape=[10, 10], dtype='float32')
+    y = fluid.layers.fc(x, 10)
+    z = fluid.layers.fc(y, 10)
     place = fluid.CPUPlace()
     exe = fluid.Executor(place)
     exe.run(fluid.default_startup_program())
-        loader = fluid.io.DataLoader.from_generator(
-            feed_list=[img, label], capacity=5, iterable=True)
-        loader.set_batch_generator(random_batch_reader(), places=place)
-        # 1. 训练 & 存储预测模型
-        for data in loader():
-            exe.run(
-                fluid.default_main_program(),
-                feed=data, 
-                fetch_list=[avg_loss])
-        model_path = "fc.example.model"
-        fluid.io.save_inference_model(
-            model_path, ["img"], [pred], exe)
-        # 开启命令式编程模式
-        fluid.enable_dygraph() 
-        # 2. 载入模型 & 预测
-        fc = fluid.dygraph.jit.load(model_path)
-        x = fluid.dygraph.to_variable(np.random.random((1, 784)).astype('float32'))
-        pred = fc(x)
-        # 3. 载入模型 & fine-tune训练
-        fc = fluid.dygraph.jit.load(model_path)
-        fc.train()
-        sgd = fluid.optimizer.SGD(learning_rate=0.001,
-                                    parameter_list=fc.parameters())
-        train_loader = fluid.io.DataLoader.from_generator(capacity=5)
-        train_loader.set_batch_generator(
-            random_batch_reader(), places=place)
-        for data in train_loader():
-            img, label = data
-            label.stop_gradient = True
-            cost = fc(img)
-            loss = fluid.layers.cross_entropy(cost, label)
-            avg_loss = fluid.layers.mean(loss)
-            avg_loss.backward()
-            sgd.minimize(avg_loss)
+    fluid.save(fluid.default_main_program(), "./test_path")
+    fluid.load(fluid.default_main_program(), "./test_path", exe)
+

doc/paddle/api/paddle/fluid/io/save_cn.rst

+.. _cn_api_fluid_save:
+
+save
+-------------------------------
+
+
+.. py:function:: paddle.fluid.save(program, model_path)
+
+:api_attr: 声明式编程模式（静态图)
+:alias_main: paddle.static.save
+:alias: paddle.static.save
+:old_api: paddle.fluid.save
+
+
+
+该接口将传入的参数、优化器信息和网络描述保存到 ``model_path`` 。
+
+参数包含所有的可训练 :ref:`cn_api_fluid_Variable` ，将保存到后缀为 ``.pdparams`` 的文件中。
+
+优化器信息包含优化器使用的所有变量。对于Adam优化器，包含beta1、beta2、momentum等。
+所有信息将保存到后缀为 ``.pdopt`` 的文件中。（如果优化器没有需要保存的变量（如sgd），则不会生成）。
+
+网络描述是程序的描述。它只用于部署。描述将保存到后缀为 ``.pdmodel`` 的文件中。
+
+参数:
+ - **program**  ( :ref:`cn_api_fluid_Program` ) – 要保存的Program。
+ - **model_path**  (str) – 保存program的文件前缀。格式为 ``目录名称/文件前缀``。如果文件前缀为空字符串，会引发异常。
+
+返回: 无
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle
+    import paddle.fluid as fluid
+
+    paddle.enable_static()
+
+    x = fluid.data(name="x", shape=[10, 10], dtype='float32')
+    y = fluid.layers.fc(x, 10)
+    z = fluid.layers.fc(y, 10)
+    place = fluid.CPUPlace()
+    exe = fluid.Executor(place)
+    exe.run(fluid.default_startup_program())
+
+    fluid.save(fluid.default_main_program(), "./test_path")
+
+
+
+
+
+
+

doc/paddle/api/paddle/fluid/save_cn.rst

-.. _cn_api_fluid_dygraph_jit_save:
-
-save
------------------
-
-.. py:function:: paddle.fluid.dygraph.jit.save(layer, model_path, input_spec=None, configs=None)
-
-将输入的经过 ``@declarative`` 装饰的 :ref:`cn_api_fluid_dygraph_Layer` 存储为 :ref:`cn_api_fluid_dygraph_TranslatedLayer` 格式的模型，
-载入后可用于预测推理或者fine-tune训练。
-
-该接口将会将输入 :ref:`cn_api_fluid_dygraph_Layer` 转写后的模型结构 ``Program`` 和所有必要的持久参数变量存储至输入路径 ``model_path`` 中。
-
-默认存储的 ``Program`` 文件名为 ``__model__``， 默认存储持久参数变量的文件名为 ``__variables__``，
-同时会将变量的一些描述信息存储至文件 ``__variables.info__``，这些额外的信息将在fine-tune训练中使用。
-
-存储的模型能够被以下API载入使用：
-  - :ref:`cn_api_fluid_dygraph_jit_load`
-  - :ref:`cn_api_fluid_io_load_inference_model` （需要配置参数 ``params_filename='__variables__'`` ）
-  - 其他预测库API
-
-参数：
-    - **layer** (Layer) - 需要存储的 :ref:`cn_api_fluid_dygraph_Layer` 对象。输入的 ``Layer`` 需要经过 ``@declarative`` 装饰。
-    - **model_path** (str) - 存储模型的目录。
-    - **input_spec** (list[Variable], 可选) - 描述存储模型的输入。此参数是传入当前存储的 ``TranslatedLayer`` forward方法的一个示例输入。如果为 ``None`` ，所有原 ``Layer`` forward方法的输入变量将都会被配置为存储模型的输入变量。默认为 ``None``。
-    - **configs** (SaveLoadConfig, 可选) - 用于指定额外配置选项的 :ref:`cn_api_fluid_dygraph_jit_SaveLoadConfig` 对象。默认为 ``None``。
-
-返回：无
-
-**示例代码**
-
-.. code-block:: python
-
-    import numpy as np
-    import paddle.fluid as fluid
-    from paddle.fluid.dygraph import Linear
-    from paddle.fluid.dygraph import declarative
-    BATCH_SIZE = 32
-    BATCH_NUM = 20
-    def random_batch_reader():
-        def _get_random_images_and_labels(image_shape, label_shape):
-            image = np.random.random(size=image_shape).astype('float32')
-            label = np.random.random(size=label_shape).astype('int64')
-            return image, label
-        def __reader__():
-            for _ in range(BATCH_NUM):
-                batch_image, batch_label = _get_random_images_and_labels(
-                    [BATCH_SIZE, 784], [BATCH_SIZE, 1])
-                yield batch_image, batch_label
-        return __reader__
-    class LinearNet(fluid.dygraph.Layer):
-        def __init__(self, in_size, out_size):
-            super(LinearNet, self).__init__()
-            self._linear = Linear(in_size, out_size)
-        @declarative
-        def forward(self, x):
-            return self._linear(x)
-    # 开启命令式编程模式
-    fluid.enable_dygraph() 
-    # 创建网络
-    net = LinearNet(784, 1)
-    adam = fluid.optimizer.AdamOptimizer(learning_rate=0.1, parameter_list=net.parameters())
-    # 创建DataLoader
-    train_loader = fluid.io.DataLoader.from_generator(capacity=5)
-    train_loader.set_batch_generator(random_batch_reader())
-    # 训练
-    for data in train_loader():
-        img, label = data
-        label.stop_gradient = True
-        cost = net(img)
-        loss = fluid.layers.cross_entropy(cost, label)
-        avg_loss = fluid.layers.mean(loss)
-        avg_loss.backward()
-        adam.minimize(avg_loss)
-        net.clear_gradients()
-    # 存储模型
-    model_path = "linear.example.model"
-    fluid.dygraph.jit.save(
-        layer=net,
-        model_path=model_path,
-        input_spec=[img])

doc/paddle/api/paddle/framework/io/load_cn.rst

+.. _cn_api_paddle_framework_io_load:
+
+load
+-----
+
+.. py:function:: paddle.load(path, config=None)
+
+从指定路径载入可以在paddle中使用的对象实例。
+
+.. note::
+    目前仅支持载入 Layer 或者 Optimizer 的 ``state_dict`` 。
+
+.. note::
+    ``paddle.load`` 支持从paddle1.x版本中静态图save相关API的存储结果中载入 ``state_dict`` 。 但是从``paddle.static.save_inference_model/paddle.fluid.io.save_params/paddle.fluid.io.save_persistables`` 等API的存储结果中载入 ``state_dict`` 时，动态图模式下参数的结构性变量名将无法被恢复。并且在将载入的 ``state_dict`` 配置到当前Layer中时，需要配置 ``Layer.set_state_dict`` 的参数 ``use_structured_name=False`` 。
+
+参数:
+    - **path** (str) – 载入目标对象实例的路径。通常该路径是目标文件的路径，在兼容载入 ``paddle.jit.save/paddle.static.save_inference_model`` 的存储结果时，该路径是一个目录。
+    - **config** (SaveLoadConfig, 可选) - 用于指定额外配置选项的 :ref:`cn_api_fluid_dygraph_jit_SaveLoadConfig` 对象，这些选项主要是用于兼容 ``paddle.jit.save/paddle.static.save_inference_model`` 存储结果的格式。默认为 ``None``。
+
+
+返回: 一个可以在paddle中使用的对象实例
+
+返回类型: Object
+  
+**代码示例**
+
+.. code-block:: python
+
+    import paddle
+            
+    paddle.disable_static()
+
+    emb = paddle.nn.Embedding(10, 10)
+    layer_state_dict = emb.state_dict()
+    paddle.save(layer_state_dict, "emb.pdparams")
+
+    scheduler = paddle.optimizer.lr_scheduler.NoamLR(
+        d_model=0.01, warmup_steps=100, verbose=True)
+    adam = paddle.optimizer.Adam(
+        learning_rate=scheduler,
+        parameters=emb.parameters())
+    opt_state_dict = adam.state_dict()
+    paddle.save(opt_state_dict, "adam.pdopt")
+
+    load_layer_state_dict = paddle.load("emb.pdparams")
+    load_opt_state_dict = paddle.load("adam.pdopt")

doc/paddle/api/paddle/reader/ComposeNotAligned_cn.rst

-..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
-    !DO NOT EDIT THIS FILE MANUALLY!
-
-.. _api_fluid_io_ComposeNotAligned:
-
-ComposeNotAligned
------------------
-
-..  autoclass:: paddle.fluid.io.ComposeNotAligned
-    :members:
-    :inherited-members:
-    :noindex:
-
-表示一种错误状态，说明调用compose API时, reader的输出数据没有对齐。