Merge branch 'develop' of https://github.com/PaddlePaddle/FluidDoc into 2.0_api

ci_scripts/api_white_list.txt

+paddle/fluid/DistributeTranspiler_cn.rst
+paddle/fluid/DistributeTranspilerConfig_cn.rst
+paddle/fluid/transpiler/HashName_cn.rst
+paddle/fluid/memory_optimize_cn.rst
+paddle/fluid/release_memory_cn.rst
+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
+
+function build_paddle() {
+    git clone https://github.com/PaddlePaddle/Paddle.git
+    mkdir Paddle/build
+    cd Paddle/build
+
+    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"
+            if [ $? -eq 0 ];then
+                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, 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
+fi

ci_scripts/check_code.sh

+#!/usr/bin/env bash
+
+# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#=================================================
+#                   Utils
+#=================================================
+
+set -ex
+
+if [ -z ${BRANCH} ]; then
+    BRANCH="develop"
+fi
+
+BENCHMARK_ROOT="$( cd "$( dirname "${BASH_SOURCE[0]}")/.." && pwd )"
+echo ${BENCHMARK_ROOT}
+
+function prepare_env(){
+    # Install tensorflow and other packages
+    pip install pre-commit==1.21 pylint==1.9.5 pytest==4.6.9
+}
+
+function abort(){
+    echo "Your change doesn't follow benchmark's code style." 1>&2
+    echo "Please use pre-commit to check what is wrong." 1>&2
+    exit 1
+}
+
+
+function check_style(){
+	trap 'abort' 0
+	pre-commit install
+	commit_files=on
+    	for file_name in `git diff --numstat upstream/$BRANCH| awk '{print $NF}'`;do
+		if  ! pre-commit run --files ../$file_name ; then
+            		git diff
+            		commit_files=off
+        	fi
+    	done
+    	if [ $commit_files == 'off' ];then
+        	echo "code format error"
+        	exit 1
+    	fi
+    	trap 0
+}
+
+prepare_env
+check_style

ci_scripts/check_pr_approval.py

+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+import sys
+import json
+
+
+def check_approval(count, required_reviewers):
+    json_buff = ""
+    for line in sys.stdin:
+        json_buff = "".join([json_buff, line])
+    json_resp = json.loads(json_buff)
+    approves = 0
+    approved_user_ids = []
+    for review in json_resp:
+        if review["state"] == "APPROVED":
+            approves += 1
+            approved_user_ids.append(review["user"]["id"])
+
+    # convert to int
+    required_reviewers_int = set()
+    for rr in required_reviewers:
+        required_reviewers_int.add(int(rr))
+
+    if len(set(approved_user_ids) & required_reviewers_int) >= count:
+        print("TRUE")
+    else:
+        print("FALSE")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1].isdigit():
+        check_approval(int(sys.argv[1]), sys.argv[2:])
+    else:
+        print(
+            "Usage: python check_pr_approval.py [count] [required reviewer id] ..."
+        )

ci_scripts/checkapproval.sh

+#!/bin/bash
+
+set -x
+
+API_FILES=("doc/paddle/api/paddle")
+
+for API_FILE in ${API_FILES[*]}; do
+  API_CHANGE=`git diff --name-only upstream/$BRANCH | grep "${API_FILE}"`
+  if [ "${API_CHANGE}" ];then
+    approval_line=`curl -H "Authorization: token ${GITHUB_API_TOKEN}" https://api.github.com/repos/PaddlePaddle/FluidDoc/pulls/${GIT_PR_ID}/reviews?per_page=10000`
+    if [ "${API_FILE}" == "doc/paddle/api/paddle" ];then
+      APPROVALS=`echo ${approval_line} | python ./check_pr_approval.py 1 2870059 27208573 29231 28379894 23093488 11935832`
+    fi
+  fi
+  if [ "${APPROVALS}" == "FALSE" ]; then
+    if [ "${API_FILE}" == "doc/paddle/api/paddle" ];then
+      echo "You must have one TPM (saxon-zh or swtkiwi or jzhang533 or Heeenrrry or dingjiaweiww or TCChenlong) approval for the api change! ${API_FILE} for the management reason of API interface and API document."
+    fi
+    exit 1
+  fi
+done
+

ci_scripts/chinese_samplecode_processor.py

+import math
+import os
+import pickle
+import shutil
+import subprocess
+import multiprocessing
+import sys
+
+
+def remove_desc_code(srcls, filename):
+    if filename == 'fluid_cn/one_hot_cn.rst':
+        srcls.pop(13)
+        srcls.pop(28)
+        srcls.pop(44)
+    if filename == 'layers_cn/one_hot_cn.rst':
+        srcls.pop(15)
+        srcls.pop(30)
+        srcls.pop(46)
+    if filename == 'profiler_cn/profiler_cn.rst':
+        srcls.pop(41)
+    if filename == 'layers_cn/natural_exp_decay_cn.rst':
+        srcls.pop(13)
+    if filename == 'layers_cn/transpose_cn.rst':
+        srcls.pop(20)
+    if filename == 'layers_cn/array_length_cn.rst':
+        srcls.pop(36)
+    if filename == 'layers_cn/inverse_time_decay_cn.rst':
+        srcls.pop(13)
+    if filename == 'layers_cn/stack_cn.rst':
+        srcls.pop(12)
+        srcls.pop(33)
+    if filename == 'layers_cn/sums_cn.rst':
+        srcls.pop(11)
+    if filename == 'layers_cn/sum_cn.rst':
+        for i in range(len(srcls) - 1, 61, -1):
+            srcls.pop(i)
+    if filename == 'layers_cn/softmax_cn.rst':
+        srcls.pop(30)
+        srcls.pop(57)
+    if filename == 'layers_cn/array_write_cn.rst':
+        srcls.pop(37)
+    if filename == 'layers_cn/lod_append_cn.rst':
+        srcls.pop(11)
+    if filename == 'layers_cn/reorder_lod_tensor_by_rank_cn.rst':
+        srcls.pop(25)
+    if filename == 'layers_cn/round_cn.rst':
+        srcls.pop(10)
+    if filename == 'layers_cn/squeeze_cn.rst':
+        srcls.pop(11)
+        srcls.pop(19)
+        srcls.pop(27)
+    if filename == 'layers_cn/unsqueeze_cn.rst':
+        srcls.pop(11)
+    if filename == 'layers_cn/array_read_cn.rst':
+        srcls.pop(51)
+    if filename == 'layers_cn/scatter_cn.rst':
+        srcls.pop(9)
+    if filename == 'layers_cn/topk_cn.rst':
+        srcls.pop(11)
+    if filename == 'optimizer_cn/ModelAverage_cn.rst':
+        srcls.pop(15)
+    return srcls
+
+
+def check_indent(code_line):
+    indent = ""
+    for c in code_line:
+        if c == '\t':
+            indent += '    '
+        elif c == ' ':
+            indent += ' '
+        if c != ' ' and c != '\t':
+            break
+    return indent
+
+
+def find_all(src_str, substr):
+    indices = []
+    get_one = src_str.find(substr)
+    while get_one != -1:
+        indices.append(get_one)
+        get_one = src_str.find(substr, get_one + 1)
+    return indices
+
+
+def extract_sample_code(srcfile, status_all):
+    filename = srcfile.name
+    srcc = srcfile.read()
+    srcfile.seek(0, 0)
+    srcls = srcfile.readlines()
+    srcls = remove_desc_code(
+        srcls, filename)  # remove description info for samplecode
+    status = []
+    sample_code_begins = find_all(srcc, " code-block:: python")
+    if len(sample_code_begins) == 0:
+        status.append(-1)
+
+    else:
+        for i in range(0, len(srcls)):
+            if srcls[i].find(".. code-block:: python") != -1:
+                content = ""
+                start = i
+
+                blank_line = 1
+                while srcls[start + blank_line].strip() == '':
+                    blank_line += 1
+
+                startindent = ""
+                # remove indent error
+                if srcls[start + blank_line].find("from") != -1:
+                    startindent += srcls[start + blank_line][:srcls[
+                        start + blank_line].find("from")]
+                elif srcls[start + blank_line].find("import") != -1:
+                    startindent += srcls[start + blank_line][:srcls[
+                        start + blank_line].find("import")]
+                else:
+                    startindent += check_indent(srcls[start + blank_line])
+                content += srcls[start + blank_line][len(startindent):]
+                for j in range(start + blank_line + 1, len(srcls)):
+                    # planish a blank line
+                    if not srcls[j].startswith(startindent) and srcls[
+                            j] != '\n':
+                        break
+                    if srcls[j].find(" code-block:: python") != -1:
+                        break
+                    content += srcls[j].replace(startindent, "", 1)
+                status.append(run_sample_code(content, filename))
+
+    status_all[filename] = status
+    return status_all
+
+
+def run_sample_code(content, filename):
+    # three status ,-1:no sample code; 1: running error; 0:normal
+    fname = filename.split("/")[-1].replace("_cn", "").replace(".rst",
+                                                               "") + ".py"
+    tempf = open("temp/" + fname, 'w')
+    content = "# -*- coding: utf-8 -*-\n" + content
+    tempf.write(content)
+    tempf.close()
+    cmd = ["python", "temp/" + fname]
+
+    subprc = subprocess.Popen(
+        cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    _, error = subprc.communicate()
+    err = "".join(error.decode(encoding='utf-8'))
+
+    if subprc.returncode != 0:
+        print("\nSample code error found in ", filename, ":\n")
+        print(err)
+        status = 1
+    else:
+        status = 0
+    os.remove("temp/" + fname)
+    return status
+
+
+def test(file):
+    temp = []
+    src = open(file, 'r')
+    status_all = {}
+    extract_sample_code(src, status_all)
+    temp.append(status_all)
+    src.close()
+    return temp
+
+
+if os.path.isdir("temp"):
+    shutil.rmtree("temp")
+if os.path.isdir("infer_model"):
+    shutil.rmtree("infer_model")
+if os.path.isdir("image"):
+    shutil.rmtree("image")
+if os.path.isdir("my_paddle_model"):
+    shutil.rmtree("my_paddle_model")
+if os.path.isdir("my_paddle_vars"):
+    shutil.rmtree("my_paddle_vars")
+
+if not os.path.isdir("temp"):
+    os.mkdir("temp")
+
+output = []
+
+if len(sys.argv) < 2:
+    print("Error: inadequate number of arguments")
+    print("Please one file")
+    sys.exit(1)
+else:
+    if not os.path.exists(sys.argv[1]):
+        print("File not found")
+        sys.exit(1)
+    res = test(sys.argv[1])
+    output.append(res)
+
+status_groups = {-1: [], 0: [], 1: []}
+# polishes show format
+ci_pass = True
+for one_file in output:
+    for dicts in one_file:
+        for key in dicts:
+            status = dicts[key]
+            for ele in status:
+                if ele != 0:
+                    ci_pass = False
+                    break
+            if len(status) == 1:
+                status_groups[status[0]].append(key)
+            else:
+                for u in range(0, len(status)):
+                    status_groups[status[u]].append(key + '_' + str(u + 1))
+
+error_api = status_groups[-1] + status_groups[1]
+total_error_number = len(error_api)
+
+print("****************************************************")
+print("----------------End of the Check--------------------")
+print("****************************************************")
+if total_error_number > 0:
+    print("Error sample code number is:{}".format(total_error_number))
+    type_one_number = len(status_groups[-1])
+    type_two_number = len(status_groups[1])
+    if type_one_number > 0:
+        print("Error type one sample number is:{}".format(type_one_number))
+        print("Error raised from type one:no sample code.",
+              str(status_groups[-1]))
+    if type_two_number > 0:
+        print("Error type two sample number is:{}".format(type_two_number))
+        print("Error raised from type two:running error sample code.",
+              str(status_groups[1]))
+if not ci_pass:
+    print("Mistakes found in sample codes.")
+    exit(1)
+else:
+    print("Sample code check is successful!")

ci_scripts/ci_start.sh

+#!/bin/bash
+
+export DIR_PATH=${PWD}
+
+/bin/bash  ${DIR_PATH}/check_code.sh
+if [ $? -ne 0 ];then
+    echo "code format error"
+    exit 1
+fi
+
+/bin/bash -x ${DIR_PATH}/check_api_cn.sh
+if [ $? -ne 0 ];then
+  exit 1
+fi
+
+/bin/bash  ${DIR_PATH}/checkapproval.sh
\ No newline at end of file

doc/fluid/advanced_guide/dygraph_to_static/debugging_cn.md

+# 调试方法
+
+本节内容将介绍动态图转静态图（下文简称：动转静）推荐的几种调试方法。
+
+> **注解:**
+>
+> 请确保转换前的动态图代码能够成功运行，建议使用 [paddle.jit.ProgramTranslator().enable(False)](../../api_cn/dygraph_cn/ProgramTranslator_cn.html#enable)关闭动转静功能，直接运行动态图，如下：
+
+```python
+import paddle
+import numpy as np
+paddle.disable_static()
+# 关闭动转静动能
+paddle.jit.ProgramTranslator().enable(False)
+
+@paddle.jit.to_static
+def func(x):
+    x = paddle.to_tensor(x)
+    if x > 3:
+        x = x - 1
+    return x
+
+func(np.ones([3, 2]))
+```
+
+## 断点调试
+使用动转静功能时，您可以使用断点调试代码。
+例如，在代码中，调用 `pdb.set_trace()`：
+```Python
+import pdb
+
+@paddle.jit.to_static
+def func(x):
+    x = paddle.to_tensor(x)
+    pdb.set_trace()
+    if x > 3:
+        x = x - 1
+    return x
+```
+执行以下代码，将会在转化后的静态图代码中使用调试器：
+```Python
+func(np.ones([3, 2]))
+```
+
+运行结果：
+```bash
+> /tmp/tmpR809hf.py(6)func()
+-> def true_fn_0(x):
+(Pdb) n
+> /tmp/tmpR809hf.py(6)func()
+-> def false_fn_0(x):
+...
+```
+
+如果您想在原始的动态图代码中使用调试器，请先调用 [`paddle.jit.ProgramTranslator().enable(False)`](../../api_cn/dygraph_cn/ProgramTranslator_cn.html#enable)，如下：
+```python
+paddle.jit.ProgramTranslator().enable(False)
+func(np.ones([3, 2]))
+```
+运行结果：
+```bash
+> <ipython-input-22-0bd4eab35cd5>(10)func()
+-> if x > 3:
+...
+
+```
+
+## 打印转换后的代码
+您可以打印转换后的静态图代码，有2种方法：
+
+1. 使用被装饰后的函数的 `code` 属性
+   如下代码中，装饰器 `paddle.jit.to_static` 会将函数 `func` 转化为一个类对象 `StaticLayer`，可以使用 StaticLayer 的 `code` 属性来获得转化后的代码。
+    ```Python
+    @paddle.jit.to_static
+    def func(x):
+    x = paddle.to_tensor(x)
+        if x > 3:
+            x = x - 1
+        return x
+
+    print(func.code)
+    ```
+    运行结果：
+
+    ```bash
+
+    def func(x):
+        x = fluid.layers.assign(x)
+
+        def true_fn_0(x):
+            x = x - 1
+            return x
+
+        def false_fn_0(x):
+            return x
+        x = fluid.dygraph.dygraph_to_static.convert_operators.convert_ifelse(x >
+            3, true_fn_0, false_fn_0, (x,), (x,), (x,))
+        return x
+    ```
+
+2. 使用 `set_code_level(level)` 或环境变量 `TRANSLATOR_CODE_LEVEL=level`
+
+    通过调用 `set_code_level` 或设置环境变量 `TRANSLATOR_CODE_LEVEL`，可以在日志中查看转换后的代码：
+
+    ```python
+    @paddle.jit.to_static
+       def func(x):
+       x = paddle.to_tensor(x)
+       if x > 3:
+           x = x - 1
+       return x
+
+    paddle.jit.set_code_level() # 也可设置 os.environ["TRANSLATOR_CODE_LEVEL"] = '100'，效果相同
+    func(np.ones([1]))
+    ```
+   运行结果：
+
+    ```bash
+    2020-XX-XX 00:00:00,980-INFO: After the level 100 ast transformer: 'All Transformers', the transformed code:
+    def func(x):
+        x = fluid.layers.assign(x)
+
+        def true_fn_0(x):
+            x = x - 1
+            return x
+
+        def false_fn_0(x):
+            return x
+        x = fluid.dygraph.dygraph_to_static.convert_operators.convert_ifelse(x >
+            3, true_fn_0, false_fn_0, (x,), (x,), (x,))
+        return x
+    ```
+    `set_code_level` 函数可以设置查看不同的AST Transformer转化后的代码，详情请见 [set_code_level](../../../paddle/api/paddle/fluid/dygraph/jit/set_code_level_cn.html)。
+
+## 使用 `print`
+`print` 函数可以用来查看变量，该函数在动转静中会被转化。当仅打印 Paddle Tensor 时，实际运行时会被转换为 Paddle 算子 [Print](../../api_cn/layers_cn/Print_cn.html)，否则仍然运行 `print`。
+```python
+@paddle.jit.to_static
+def func(x):
+    x = paddle.to_tensor(x)
+
+    # 打印x，x是Paddle Tensor，实际运行时会运行Paddle Print(x)
+    print(x)
+
+    # 打印注释，非Paddle Tensor，实际运行时仍运行print
+    print("Here call print function.")
+
+    if len(x) > 3:
+        x = x - 1
+    else:
+        x = paddle.ones(shape=[1])
+    return x
+
+func(np.ones([1]))
+```
+
+运行结果：
+```bash
+Variable: assign_0.tmp_0
+  - lod: {}
+  - place: CPUPlace
+  - shape: [1]
+  - layout: NCHW
+  - dtype: double
+  - data: [1]
+Here call print function.  
+```
+
+## 日志打印
+ProgramTranslator在日志中记录了额外的调试信息，以帮助您了解动转静过程中函数是否被成功转换。
+您可以调用 [`paddle.jit.set_verbosity(level)`]((../../../paddle/api/paddle/fluid/dygraph/jit/set_verbosity_cn.html)) 或设置环境变量 `TRANSLATOR_VERBOSITY=level` 来设置日志详细等级，并查看不同等级的日志信息。目前，`level` 可以取值0-3：
+- 0: 无日志
+- 1: 包括了动转静转化流程的信息，如转换前的源码、转换的可调用对象
+- 2: 包括以上信息，还包括更详细函数转化日志
+- 3: 包括以上信息，以及更详细的动转静日志
+
+> **注意:**
+>
+> 日志中包括了源代码等信息，请在共享日志前确保它不包含敏感信息。
+
+可以在代码运行前调用 `paddle.jit.set_verbosity` 控制日志详细程度：
+```python
+paddle.jit.set_verbosity(3)
+```
+或者设置环境变量 `TRANSLATOR_VERBOSITY`：
+```python
+import os
+os.environ["TRANSLATOR_VERBOSITY"] = '3'
+```
+
+运行结果：
+```bash
+2020-XX-XX 00:00:00,123-Level 1:    Source code:
+@paddle.jit.to_static
+def func(x):
+    x = paddle.to_tensor(x)
+    if len(x) > 3:
+        x = x - 1
+    else:
+        x = paddle.ones(shape=[1])
+    return x
+
+2020-XX-XX 00:00:00,152-Level 1: Convert callable object: convert <built-in function len>.
+```

doc/fluid/advanced_guide/dygraph_to_static/debugging_en.md

+# Debugging Methods
+
+This section will introduce several debugging methods recommended by Dynamic Graph to Static Graph (hereafter called Dynamic-to-Staic).
+
+> **NOTE:**
+>
+> Please ensure that the dynamic graph code before transformation can run successfully. It is recommended to call [paddle.jit.ProgramTranslator().enable(False)](../../api/dygraph/ProgramTranslator_en.html#enable) to disable Dynamic-to-Static, and run dynamic graph code as follows:
+
+
+```python
+import paddle
+import numpy as np
+paddle.disable_static()
+
+# Disable Dynamic-to-Static
+paddle.jit.ProgramTranslator().enable(False)
+
+@paddle.jit.to_static
+def func(x):
+    x = paddle.to_tensor(x)
+    if x > 3:
+        x = x - 1
+    return x
+
+func(np.ones([3, 2]))
+```
+
+## Breakpoint Debugging
+When using Dynamic-to-Static, you can use breakpoints to debug.
+
+For example, call `pdb.set_trace()` in your code:
+```Python
+import pdb
+
+@paddle.jit.to_static
+def func(x):
+    x = paddle.to_tensor(x)
+    pdb.set_trace()
+    if x > 3:
+        x = x - 1
+    return x
+```
+Executing the following code will land the debugger in the transformed static graph code:
+```Python
+func(np.ones([3, 2]))
+```
+
+```bash
+> /tmp/tmpR809hf.py(6)func()
+-> def true_fn_0(x):
+(Pdb) n
+> /tmp/tmpR809hf.py(6)func()
+-> def false_fn_0(x):
+...
+```
+
+Calling [`paddle.jit.ProgramTranslator().enable(False)`](../../api/dygraph/ProgramTranslator_en.html#enable) before executing the code will land the debugger in the original dynamic graph code:
+```python
+paddle.jit.ProgramTranslator().enable(False)
+func(np.ones([3, 2]))
+```
+
+```bash
+> <ipython-input-22-0bd4eab35cd5>(10)func()
+-> if x > 3:
+...
+
+```
+
+## Print Transformed Code
+
+There are two ways to print the transformed static graph code:
+
+1. Use the attribute `code` of the decorated function
+
+   In the following code, the decorator `paddle.jit.to_static` transforms `func` into a class object `StaticLayer`. You can use the `code` attribute of `StaticLayer` to get the transformed code.
+    ```Python
+    @paddle.jit.to_static
+    def func(x):
+    x = paddle.to_tensor(x)
+        if x > 3:
+            x = x - 1
+        return x
+
+    print(func.code)
+    ```
+    ```bash
+
+    def func(x):
+        x = fluid.layers.assign(x)
+
+        def true_fn_0(x):
+            x = x - 1
+            return x
+
+        def false_fn_0(x):
+            return x
+        x = fluid.dygraph.dygraph_to_static.convert_operators.convert_ifelse(x >
+            3, true_fn_0, false_fn_0, (x,), (x,), (x,))
+        return x
+    ```
+2. Call `set_code_level(level)` or set environment variable `TRANSLATOR_CODE_LEVEL=level`
+
+    You can view the transformed code in the log by calling `set_code_level` or set environment variable `TRANSLATOR_CODE_LEVEL`.
+
+    ```python
+    @paddle.jit.to_static
+       def func(x):
+       x = paddle.to_tensor(x)
+       if x > 3:
+           x = x - 1
+       return x
+
+    paddle.jit.set_code_level() # the same effect to set os.environ["TRANSLATOR_CODE_LEVEL"] = '100'
+    func(np.ones([1]))
+    ```
+
+    ```bash
+    2020-XX-XX 00:00:00,980-INFO: After the level 100 ast transformer: 'All Transformers', the transformed code:
+    def func(x):
+        x = fluid.layers.assign(x)
+
+        def true_fn_0(x):
+            x = x - 1
+            return x
+
+        def false_fn_0(x):
+            return x
+        x = fluid.dygraph.dygraph_to_static.convert_operators.convert_ifelse(x >
+            3, true_fn_0, false_fn_0, (x,), (x,), (x,))
+        return x
+    ```
+    `set_code_level` can set different levels to view the code transformed by different ast transformers. For details, please refer to [set_code_level](../../../paddle/api/paddle/fluid/dygraph/jit/set_code_level_en.html)。
+
+## `print`
+You can call `print` to view variables. `print` will be transformed when using Dynamic-to-Static. When only Paddle Tensor is printed, `print` will be transformed and call Paddle operator [Print](../../api/layers/Print.html) in runtime. Otherwise, call python `print`.
+
+```python
+@paddle.jit.to_static
+def func(x):
+    x = paddle.to_tensor(x)
+    # x is a Paddle Tensor, so it will run Paddle Print(x) actually.
+    print(x)
+
+    # The string is not a Paddle Tensor, so it will run print as-is.
+    print("Here call print function.")
+
+    if len(x) > 3:
+        x = x - 1
+    else:
+        x = paddle.ones(shape=[1])
+    return x
+
+func(np.ones([1]))
+```
+
+```bash
+Variable: assign_0.tmp_0
+  - lod: {}
+  - place: CPUPlace
+  - shape: [1]
+  - layout: NCHW
+  - dtype: double
+  - data: [1]
+Here call print function.  
+```
+
+## Log Printing
+ProgramTranslator can log additional debugging information to help you know whether the function was successfully transformed or not.
+
+You can call [`paddle.jit.set_verbosity(level)`](../../../paddle/api/paddle/fluid/dygraph/jit/set_verbosity_en.html) or set environment variable `TRANSLATOR_VERBOSITY=level` to enable logging and view logs of different levels. The argument `level` varies from 0 to 3:
+- 0: no logging
+- 1: includes the information in Dynamic-to-Static tranformation process, such as the source code not transformed, the callable object to transform and so on
+- 2: includes above and more detailed function transformation logs
+- 3: includes above and extremely verbose logging
+
+> **WARNING:**
+>
+> The logs includes information such as source code. Please make sure logs don't contain any sensitive information before sharing them.
+
+You can call `paddle.jit.set_verbosity` to control the verbosity level of logs:
+```python
+paddle.jit.set_verbosity(3)
+```
+or use the environment variable `TRANSLATOR_VERBOSITY`：
+```python
+import os
+os.environ["TRANSLATOR_VERBOSITY"] = '3'
+```
+
+```bash
+2020-XX-XX 00:00:00,123-Level 1:    Source code:
+@paddle.jit.to_static
+def func(x):
+    x = paddle.to_tensor(x)
+    if len(x) > 3:
+        x = x - 1
+    else:
+        x = paddle.ones(shape=[1])
+    return x
+
+2020-XX-XX 00:00:00,152-Level 1: Convert callable object: convert <built-in function len>.

doc/fluid/advanced_guide/dygraph_to_static/error_handling_cn.md

+# 报错信息处理
+
+本节内容将介绍使用动态图转静态图（下文简称：动转静）功能发生异常时，[ProgramTranslator](./program_translator_cn.html)对报错信息做的处理，以帮助您更好地理解动转静报错信息。使用动转静功能运行动态图代码时，内部可以分为2个步骤：动态图代码转换成静态图代码，运行静态图代码。接下来将分别介绍这2个步骤中的异常报错情况。
+
+## 动转静过程中的异常
+在动态图代码转换成静态图代码的过程中，如果ProgramTranslator无法转换一个函数时，将会显示警告信息，并尝试直接运行该函数。
+如下代码中，函数 `inner_func` 在调用前被转换成静态图代码，当 `x = inner_func(data)` 调用该函数时，不能重复转换，会给出警告信息：
+
+```python
+import paddle
+import numpy as np
+
+paddle.disable_static()
+
+@paddle.jit.to_static
+def func():
+    def inner_func(x):
+        x_tensor = paddle.to_tensor(x)
+        return x_tensor
+    data = np.ones([3]).astype("int32")
+    x = inner_func(data)
+    return x
+func()
+```
+
+ProgramTranslator打印的警告信息如下：
+
+```bash
+WARNING: <function inner_func at 0x7fa9bcaacf50> doesn't have to be transformed to static function because it has been transformed before, it will be run as-is.
+```
+
+## 运行转换后的代码报错
+
+如果在动转静后的静态图代码中发生异常，ProgramTranslator 会捕获该异常，增强异常报错信息，将静态图代码报错行映射到转换前的动态图代码，并重新抛出该异常。
+重新抛出的异常具有以下特点：
+
+- 隐藏了部分对用户无用的动转静过程调用栈；
+- 转换前的代码会给出提示："In User Code:"；
+- 报错信息中包含了转换前的原始动态图代码；
+
+例如，运行以下代码，在静态图构建时，即编译期会抛出异常：
+
+```python
+import paddle
+import numpy as np
+
+paddle.disable_static()
+
+@paddle.jit.to_static
+def func(x):
+    x = paddle.to_tensor(x)
+    x = paddle.reshape(x, shape=[-1, -1])
+    return x
+
+func(np.ones([3, 2]))
+```
+
+运行结果：
+```bash
+Traceback (most recent call last):
+  <ipython-input-13-f9c3ea702e3a> in <module>()
+     func(np.ones([3, 2]))
+  File "paddle/fluid/dygraph/dygraph_to_static/program_translator.py", line 332, in __call__
+    raise new_exception
+AssertionError: In user code:
+
+    File "<ipython-input-13-f9c3ea702e3a>", line 7, in func
+        x = fluid.layers.reshape(x, shape=[-1, -1])
+    File "paddle/fluid/layers/nn.py", line 6193, in reshape
+        attrs["shape"] = get_attr_shape(shape)
+    File "paddle/fluid/layers/nn.py", line 6169, in get_attr_shape
+        "be -1. But received shape[%d] is also -1." % dim_idx)
+    AssertionError: Only one dimension value of 'shape' in reshape can be -1. But received shape[1] is also -1.
+```
+
+上述报错信息可以分为3点：
+
+1. 报错栈中，涉及代码转换过程的信息栈默认会被隐藏，不进行展示，以减少干扰信息。
+
+2. ProgramTranslator处理后的报错信息中，会包含提示"In user code:"，表示之后的报错栈中，包含动转静前的动态图代码，即用户写的代码：
+	```bash
+	AssertionError: In user code:
+
+        File "<ipython-input-13-f9c3ea702e3a>", line 7, in func
+	       x = fluid.layers.reshape(x, shape=[-1, -1])
+	    File "paddle/fluid/layers/nn.py", line 6193, in reshape
+	        attrs["shape"] = get_attr_shape(shape)
+	    File "paddle/fluid/layers/nn.py", line 6169, in get_attr_shape
+	        "be -1. But received shape[%d] is also -1." % dim_idx)
+	```
+	其中，`File "<ipython-input-13-f9c3ea702e3a>", line 7, in func` 是转换前的代码位置信息，`x = fluid.layers.reshape(x, shape=[-1, -1])` 是转换前的代码。
+
+3. 新的异常中，包含原始报错中的的报错信息，如下：
+	```bash
+	AssertionError: Only one dimension value of 'shape' in reshape can be -1. But received shape[1] is also -1.
+	```
+
+运行以下代码，在静态图运行时，即运行期会抛出异常：
+
+```Python
+@paddle.jit.to_static
+def func(x):
+    x = paddle.to_tensor(x)
+    two = paddle.fill_constant(shape=[1], value=2, dtype="int32")
+    x = paddle.reshape(x, shape=[1, two])
+    return x
+
+func(np.ones([3]).astype("int32"))
+```
+
+运行结果：
+
+```bash
+Traceback (most recent call last):
+  File "<ipython-input-57-c63d6a351262>", line 10, in <module>()
+     func(np.ones([3]).astype("int32"))
+  File "paddle/fluid/dygraph/dygraph_to_static/program_translator.py", line 332, in __call__
+    raise new_exception
+
+EnforceNotMet: In user code:
+
+    File "<ipython-input-57-c63d6a351262>", line 7, in func
+      x = paddle.reshape(x, shape=[1, two])
+    File "paddle/tensor/manipulation.py", line 1347, in reshape
+      return paddle.fluid.layers.reshape(x=x, shape=shape, name=name)
+    File "paddle/fluid/layers/nn.py", line 6209, in reshape
+      "XShape": x_shape})
+    File "paddle/fluid/layer_helper.py", line 43, in append_op
+      return self.main_program.current_block().append_op(*args, **kwargs)
+    File "paddle/fluid/framework.py", line 2880, in append_op
+      attrs=kwargs.get("attrs", None))
+    File "paddle/fluid/framework.py", line 1977, in __init__
+      for frame in traceback.extract_stack():
+
+--------------------------------------
+C++ Traceback (most recent call last):
+--------------------------------------
+0   paddle::imperative::Tracer::TraceOp(std::string const&, paddle::imperative::NameVarBaseMap const&, paddle::imperative::NameVarBaseMap const&, paddle::framework::AttributeMap, paddle::platform::Place const&, bool)
+1   paddle::imperative::OpBase::Run(paddle::framework::OperatorBase const&, paddle::imperative::NameVarBaseMap const&, paddle::imperative::NameVarBaseMap const&, paddle::framework::AttributeMap const&, paddle::platform::Place const&)
+2   paddle::imperative::PreparedOp::Run(paddle::imperative::NameVarBaseMap const&, paddle::imperative::NameVarBaseMap const&, paddle::framework::AttributeMap const&)
+3   std::_Function_handler<void (paddle::framework::ExecutionContext const&), paddle::framework::OpKernelRegistrarFunctor<paddle::platform::CPUPlace, false, 0ul, paddle::operators::RunProgramOpKernel<paddle::platform::CPUDeviceContext, float> >::operator()(char const*, char const*, int) const::{lambda(paddle::framework::ExecutionContext const&)#1}>::_M_invoke(std::_Any_data const&, paddle::framework::ExecutionContext const&)
+4   paddle::operators::RunProgramOpKernel<paddle::platform::CPUDeviceContext, float>::Compute(paddle::framework::ExecutionContext const&) const
+5   paddle::framework::Executor::RunPartialPreparedContext(paddle::framework::ExecutorPrepareContext*, paddle::framework::Scope*, long, long, bool, bool, bool)
+6   paddle::framework::OperatorBase::Run(paddle::framework::Scope const&, paddle::platform::Place const&)
+7   paddle::framework::OperatorWithKernel::RunImpl(paddle::framework::Scope const&, paddle::platform::Place const&) const
+8   paddle::framework::OperatorWithKernel::RunImpl(paddle::framework::Scope const&, paddle::platform::Place const&, paddle::framework::RuntimeContext*) const
+9   paddle::operators::ReshapeKernel::operator()(paddle::framework::ExecutionContext const&) const
+10  paddle::operators::ReshapeOp::ValidateShape(std::vector<int, std::allocator<int> >, paddle::framework::DDim const&)
+11  paddle::platform::EnforceNotMet::EnforceNotMet(std::string const&, char const*, int)
+12  paddle::platform::GetCurrentTraceBackString()
+
+----------------------
+Error Message Summary:
+----------------------
+InvalidArgumentError: The 'shape' in ReshapeOp is invalid. The input tensor X'size must be equal to the capacity of 'shape'. But received X's shape = [3], X's size = 3, 'shape' is [1, 2], the capacity of 'shape' is 2.
+  [Hint: Expected capacity == in_size, but received capacity:2 != in_size:3.] (at /paddle/paddle/fluid/operators/reshape_op.cc:206)
+  [operator < reshape2 > error]  [operator < run_program > error]
+```
+
+上述异常中，除了隐藏部分报错栈、报错定位到转换前的动态图代码外，报错信息中包含了C++报错栈 `C++ Traceback` 和 `Error Message Summary`，这是 Paddle 的 C++ 端异常信息，经处理后在 Python 的异常信息中显示。

doc/fluid/advanced_guide/dygraph_to_static/error_handling_en.md

+# Error Handling
+
+This section will introduce the error information when an exception occurs, so as to help you better understand the Dynamic-to-Static error information.
+When running the transformed static graph code, the internal procedure can be divided into two steps: the dynamic graph code is transformed into the static graph code, and the static graph code is run. We will introduce the error reporting in these two steps.
+
+## Exceptions in Dynamic-to-Static Transformation
+
+If ProgramTranslator cannot transform a function, it will display a warning message and try to run the function as-is.
+
+In the following code, the function `inner_func` is transformed before calling. When calling `inner_func` in `x = inner_func(data)`, it is not allowed to transform repeatedly, and a warning message will be given:
+
+```python
+import paddle
+import numpy as np
+
+paddle.disable_static()
+
+@paddle.jit.to_static
+def func():
+    def inner_func(x):
+        x_tensor = paddle.to_tensor(x)
+        return x_tensor
+    data = np.ones([3]).astype("int32")
+    x = inner_func(data)
+    return x
+func()
+```
+
+The warning message is as follows:
+```bash
+WARNING: <function inner_func at 0x7fa9bcaacf50> doesn't have to be transformed to static function because it has been transformed before, it will be run as-is.
+```
+## Exceptions in Running Transformed Code
+
+When an exception occurs in the transformed code by ProgramTranslator, the exception is caught and the error message is augmented. It maps the error line of the static graph code to the un-transformed dynamic graph code, and then re-raises the exception.
+
+Among the features of the re-raised exception:
+
+- Some useless call stacks of Dynamic-to-Static are hidden;
+- A prompt will be given before the un-transformed code: "In User Code:";
+- The error message includes references to the original dynamic graph code before transformation;
+
+For example, if executing the following code, an exception is raised when the static graph is built, that is, at compile time:
+
+```python
+import paddle
+import numpy as np
+
+paddle.disable_static()
+
+@paddle.jit.to_static
+def func(x):
+    x = paddle.to_tensor(x)
+    x = paddle.reshape(x, shape=[-1, -1])
+    return x
+
+func(np.ones([3, 2]))
+```
+
+```bash
+Traceback (most recent call last):
+  <ipython-input-13-f9c3ea702e3a> in <module>()
+     func(np.ones([3, 2]))
+  File "paddle/fluid/dygraph/dygraph_to_static/program_translator.py", line 332, in __call__
+    raise new_exception
+AssertionError: In user code:
+
+    File "<ipython-input-13-f9c3ea702e3a>", line 7, in func
+        x = fluid.layers.reshape(x, shape=[-1, -1])
+    File "paddle/fluid/layers/nn.py", line 6193, in reshape
+        attrs["shape"] = get_attr_shape(shape)
+    File "paddle/fluid/layers/nn.py", line 6169, in get_attr_shape
+        "be -1. But received shape[%d] is also -1." % dim_idx)
+    AssertionError: Only one dimension value of 'shape' in reshape can be -1. But received shape[1] is also -1.
+```
+
+The above error information can be divided into three points:
+
+1. In the error stack, the call stacks related to the code transformation process are hidden by default and not displayed, so as to avoid confusion.
+
+2. In the error message processed by ProgramTranslator, a prompt "In user code:" will be included, which means that the following error stacks contains the original dynamic graph code, that is, the code written by the user:
+
+    ```bash
+    AssertionError: In user code:
+
+        File "<ipython-input-13-f9c3ea702e3a>", line 7, in func
+           x = fluid.layers.reshape(x, shape=[-1, -1])
+        File "paddle/fluid/layers/nn.py", line 6193, in reshape
+            attrs["shape"] = get_attr_shape(shape)
+        File "paddle/fluid/layers/nn.py", line 6169, in get_attr_shape
+            "be -1. But received shape[%d] is also -1." % dim_idx)
+    ```
+    `File "<ipython-input-13-f9c3ea702e3a>", line 7, in func` is the location information of un-transformed code, `x = fluid.layers.reshape(x, shape=[-1, -1])` is the un-transformed code.
+
+3. The new exception contains the message that the exception originally reported, as follows:  
+    ```bash
+    AssertionError: Only one dimension value of 'shape' in reshape can be -1. But received shape[1] is also -1.
+    ```  
+
+If execute the following code, an exception is raised when the static graph is executed at runtime:
+
+```Python
+@paddle.jit.to_static
+def func(x):
+    x = paddle.to_tensor(x)
+    two = paddle.fill_constant(shape=[1], value=2, dtype="int32")
+    x = paddle.reshape(x, shape=[1, two])
+    return x
+
+func(np.ones([3]).astype("int32"))
+```
+
+```bash
+Traceback (most recent call last):
+  File "<ipython-input-57-c63d6a351262>", line 10, in <module>()
+     func(np.ones([3]).astype("int32"))
+  File "paddle/fluid/dygraph/dygraph_to_static/program_translator.py", line 332, in __call__
+    raise new_exception
+
+EnforceNotMet: In user code:
+
+    File "<ipython-input-57-c63d6a351262>", line 7, in func
+      x = paddle.reshape(x, shape=[1, two])
+    File "paddle/tensor/manipulation.py", line 1347, in reshape
+      return paddle.fluid.layers.reshape(x=x, shape=shape, name=name)
+    File "paddle/fluid/layers/nn.py", line 6209, in reshape
+      "XShape": x_shape})
+    File "paddle/fluid/layer_helper.py", line 43, in append_op
+      return self.main_program.current_block().append_op(*args, **kwargs)
+    File "paddle/fluid/framework.py", line 2880, in append_op
+      attrs=kwargs.get("attrs", None))
+    File "paddle/fluid/framework.py", line 1977, in __init__
+      for frame in traceback.extract_stack():
+
+--------------------------------------
+C++ Traceback (most recent call last):
+--------------------------------------
+0   paddle::imperative::Tracer::TraceOp(std::string const&, paddle::imperative::NameVarBaseMap const&, paddle::imperative::NameVarBaseMap const&, paddle::framework::AttributeMap, paddle::platform::Place const&, bool)
+1   paddle::imperative::OpBase::Run(paddle::framework::OperatorBase const&, paddle::imperative::NameVarBaseMap const&, paddle::imperative::NameVarBaseMap const&, paddle::framework::AttributeMap const&, paddle::platform::Place const&)
+2   paddle::imperative::PreparedOp::Run(paddle::imperative::NameVarBaseMap const&, paddle::imperative::NameVarBaseMap const&, paddle::framework::AttributeMap const&)
+3   std::_Function_handler<void (paddle::framework::ExecutionContext const&), paddle::framework::OpKernelRegistrarFunctor<paddle::platform::CPUPlace, false, 0ul, paddle::operators::RunProgramOpKernel<paddle::platform::CPUDeviceContext, float> >::operator()(char const*, char const*, int) const::{lambda(paddle::framework::ExecutionContext const&)#1}>::_M_invoke(std::_Any_data const&, paddle::framework::ExecutionContext const&)
+4   paddle::operators::RunProgramOpKernel<paddle::platform::CPUDeviceContext, float>::Compute(paddle::framework::ExecutionContext const&) const
+5   paddle::framework::Executor::RunPartialPreparedContext(paddle::framework::ExecutorPrepareContext*, paddle::framework::Scope*, long, long, bool, bool, bool)
+6   paddle::framework::OperatorBase::Run(paddle::framework::Scope const&, paddle::platform::Place const&)
+7   paddle::framework::OperatorWithKernel::RunImpl(paddle::framework::Scope const&, paddle::platform::Place const&) const
+8   paddle::framework::OperatorWithKernel::RunImpl(paddle::framework::Scope const&, paddle::platform::Place const&, paddle::framework::RuntimeContext*) const
+9   paddle::operators::ReshapeKernel::operator()(paddle::framework::ExecutionContext const&) const
+10  paddle::operators::ReshapeOp::ValidateShape(std::vector<int, std::allocator<int> >, paddle::framework::DDim const&)
+11  paddle::platform::EnforceNotMet::EnforceNotMet(std::string const&, char const*, int)
+12  paddle::platform::GetCurrentTraceBackString()
+
+----------------------
+Error Message Summary:
+----------------------
+InvalidArgumentError: The 'shape' in ReshapeOp is invalid. The input tensor X'size must be equal to the capacity of 'shape'. But received X's shape = [3], X's size = 3, 'shape' is [1, 2], the capacity of 'shape' is 2.
+  [Hint: Expected capacity == in_size, but received capacity:2 != in_size:3.] (at /paddle/paddle/fluid/operators/reshape_op.cc:206)
+  [operator < reshape2 > error]  [operator < run_program > error]
+```
+
+In the above exception, in addition to hiding part of the error stack and locating the error to the un-transformed dynamic graph code, the error information includes the c++ error stack `C++ Traceback` and `Error Message Summary`, which are the exception from C++ and are displayed in Python exception after processing.

doc/fluid/advanced_guide/dygraph_to_static/grammar_list_cn.rst

@@ -10,7 +10,7 @@ ProgramTranslator本质是把Python运行语法转写为PaddlePaddle静态图代
 控制流相关关键词
 ------------------
 
-控制流指if-elif-else，while等能够控制程序语句执行顺序的关键字。PaddlePaddle静态图通过cond，while_loop API来实现条件判断和循环，如果动态图Python控制流的判断条件/循环条件依赖 Paddle Tensor，动转静后会被转化为等价的Paddle控制流接口，否则仍然使用Python控制流逻辑运行。在动转静过程中这些关键字的转化情况为：
+控制流指if-elif-else，while等能够控制程序语句执行顺序的关键字。PaddlePaddle静态图通过cond，while_loop API来实现条件判断和循环，如果动态图Python控制流的判断条件或循环条件依赖 PaddlePaddle Tensor，动转静后会被转化为等价的PaddlePaddle控制流接口，否则仍然使用Python控制流逻辑运行。在动转静过程中这些关键字的转化情况为：
 
 1. if-elif-else 条件
 
@@ -47,7 +47,7 @@ ProgramTranslator 支持在循环，条件判断中return结果而不需要一
 一些需要转化的运算类型
 ------------------------
 
-1. +，-，*，/，** 等Python内置运算
+1. +，-，*，/，**, >, <, >= , <=, == 等Python内置运算
 
 由于静态图有重载这些基本运算符，所以这些被ProgramTranslator转化后都适用相应重载的运算符，动转静支持此类运算。
 
@@ -76,7 +76,7 @@ Python 函数相关
 
 4. 函数内再调用函数
 
-对于函数内调用其他函数的情况，ProgramTranslator也会对内部的函数递归地进行动转静，这样做的好处是可以在最外层函数加一次装饰器就能进行动转静，而不需要每个函数都加装饰器。
+对于函数内调用其他函数的情况，ProgramTranslator也会对内部的函数递归地进行动转静，这样做的好处是可以在最外层函数只需加一次装饰器即可，而不需要每个函数都加装饰器。但需要注意，动转静还不支持函数递归调用自己，详细原因请查看下文动转静无法正确运行的情况。
 
 报错异常相关
 --------------
@@ -96,7 +96,7 @@ Python基本容器
 动转静无法正确运行的情况
 --------------------------
 
-1. Reshape后的变量调用其shape作为Paddle API参数。
+1. Reshape后的变量调用其shape作为PaddlePaddle API参数。
 
 具体表现比如 ``x = reshape(x, shape=shape_tensor)`` ，再使用 ``x.shape[0]`` 的值进行其他操作。这种情况会由于动态图和静态图的本质不同而使得动态图能够运行，但静态图运行失败。其原因是动态图情况下，API是直接返回运行结果，因此 ``x.shape`` 在经过reshape运算后是确定的。但是在转化为静态图后，因为静态图API只是组网，``shape_tensor`` 的值在组网时是不知道的，所以 ``reshape`` 接口组网完，静态图并不知道 ``x.shape`` 的值。PaddlePaddle静态图用-1表示未知的shape值，此时 ``x`` 的shape每个维度会被设为-1，而不是期望的值。
 
@@ -104,7 +104,7 @@ Python基本容器
 
 2. 多重list嵌套读写Tensor
 
-具体表现如 ``l = [[tensor1, tensor2], [tensor3, tensor4]]`` ，因为现在静态图将元素全是Tensor的list转化为TensorArray，而Paddle的TensorArray还不支持多维数组，因此这种情况无法动转静正确运行。
+具体表现如 ``l = [[tensor1, tensor2], [tensor3, tensor4]]`` ，因为现在动转静将元素全是Tensor的list转化为TensorArray，而PaddlePaddle的TensorArray还不支持多维数组，因此这种情况下，动转静无法正确运行。
 
 遇到这类情况我们建议尽量用一维list，或者自己使用PaddlePaddle的create_array，array_read，array_write接口编写为TensorArray。
 
@@ -114,3 +114,9 @@ Python基本容器
 
 遇到这种情况我们建议在动转静的函数中尽量使用PaddlePaddle接口替代numpy接口进行运算。
 
+4. 一个函数递归调用自己
+
+ProgramTranslator还无法支持一个函数递归调用自己，原因是递归常常会用 ``if-else`` 构造停止递归的条件。然而这样的停止条件在静态图下只是一个 ``cond`` 组网，组网并不能在编译阶段决定自己组多少次，会导致函数运行时一直组网递归直至栈溢出，因此ProgramTranslator还无法支持一个函数递归调用自己。
+
+遇到这种情况我们建议将代码改为非递归写法。
+

doc/fluid/advanced_guide/dygraph_to_static/grammar_list_en.rst

+Supported Grammars
+==================
+
+The key part of ProgramTranslator is transforming Python grammar into PaddlePaddle static graph code, but there exists difference between Python and PaddlePaddle static graph which causes some limitation of the code transformation.
+
+In this section we will talk about the supported grammars and unsupported grammars, also give some suggestions when the grammar is unsupported. 
+
+There are several kinds of supported grammars:
+
+Control flow keywords
+---------------------
+
+Control flow means those keywords that controls the execution order of program statements, for example ``if-elif-else, while`` . Conditional operation and loop were implemented as ``cond, while_loop`` APIs in PaddlePaddle static graph. If the condition of a Python dygraph control flow depends on PaddlePaddle Tensor, the ProgramTranslator will convert the control flow into equivalent PaddlePaddle control flow APIs, else it will still be executed as Python control flow. The transformations of those control flow keywords are listed below:
+
+1. ``if-elif-else`` statements
+
+If the condition of ``if <condition>`` is Tensor, ProgramTranslator will turn this ``if-elif-else`` statement to equivalent PaddlePaddle static graph ``cond`` statements, otherwise the ``if-elif-else`` statement is executed as normal Python conditional statement. Note that ``cond`` API only accepts input conditional Tensor with numel equals to 1, so please use this kind of Tensor to write dygraph conditional statement, other Tensors will cause error.
+
+2. ``while`` loop
+
+If the condition of ``while`` is Tensor, ProgramTranslator will turn this ``while`` statement to equivalent PaddlePaddle static graph ``while_loop`` statements, otherwise the ``while`` statement is executed as normal Python ``while`` loop statement. Note that ``while_loop`` API only accepts input conditional Tensor with numel equals to 1, so please use this kind of Tensor to write dygraph loop condition statement, other Tensors will cause error.
+
+3. ``for`` loop
+
+3.1 ``for _ in range(__)`` loop
+
+Firstly, ProgramTranslator will transform it into equivalent Python while loop, then convert dygraph to static graph by same logic of ``while`` loop.
+
+3.2 ``for _ in x`` loop
+
+If ``x`` is a Python container, iterator, or generator, it will be executed as original Python statement. Otherwise ``x`` is a Tensor, ProgramTranslator will transform the loop into PaddlePaddle static graph loop and fetches ``x[0], x[1], ...`` as loop iteration variable in each loop iteration.
+
+3.3 ``for idx, val in enumerate(x)`` loop
+
+If ``x`` is a Python container, iterator, or generator, it will be executed as original Python statement. Otherwise ``x`` is a Tensor, Program
+Translator will transform the  loop into PaddlePaddle static graph loop. The ``idx`` will be transformed to 1-D tensor with value ``0, 1, ...`` and the ``val`` will be transformed to ``x[0], x[1], ...`` in each loop iteration.
+
+4. ``break, continue``
+
+ProgramTranslator supports ``break, continue`` statements in loop. ProgramTranslator will add some PaddlePaddle static graph ``cond`` statements to skip execution of corresponding part when ``break, continue`` condition is meet.
+
+5. ``return``
+
+ProgramTranslator supports ``return`` in a conditonal block or loop body, not necessary to be at the end of a function. It also supports returning tuple with various length of Tensors with different dtype. The implementation is adding some PaddlePaddle static graph ``cond`` statement to skipparts of code when ``return`` is triggered.
+
+
+Some Python basic operators
+---------------------------
+
+1. ``+, -, *, /, **, >, <, >= , <=, ==`` etc. 
+
+Because PaddlePaddle static graph overrides those Python basic arithmetic operators and comparison operators, ProgramTranslator can support those operators.
+
+2. ``and, or, not`` logical operators
+
+Python has ``and, or, not`` keywards as basic logical operators, ProgramTranslator will check whether the variables of the logical operators are Tensors, if they are Tensors, ProgramTranslator replaces the ``and, or, not`` statements into corresponding PaddlePaddle static graph logical operator and run it.
+
+3. Type casting
+
+In dygraph mode, users can use Python type casting grammar. For instance, if ``x`` is a Tensor, ``float(x)`` casts the data type of ``x`` to float. ProgramTranslator will check whether ``x`` is a Tensor during run time, if it is, the casting sentence will be modified to PaddlePaddle static graph ``cast`` API so that its dtype can be changed in the dygraph to static transformation.
+
+Python functions
+------------------------------
+
+1. ``print``
+
+In dygraph mode, ``print(x)`` will print Tensor value if ``x`` is a Tensor. ProgramTranslator converts the built-in ``print`` to PaddlePaddle static graph ``Print`` API during dygraph to static graph transformation if the arguments are Tensors, otherwise ProgramTranslator won't convert the ``print``. 
+
+2. ``len``
+
+If ``x`` is a Tensor, ``len(x)`` can get the length at 0-dimension of ``x`` in dygraph mode. ProgramTranslator turns it to PaddlePaddle static graph ``shape`` API and returns the 0-dimension of the ``shape``, else if ``x`` is a TensorArray, then ``len(x)`` will be transformed to static graph API ``control_flow.array_length`` to return the length of TensorArray. In other cases, the ``len`` function will be executed as Python built-in ``len``
+
+3. lambda expression
+
+ProgramTranslator supports Python lambda expression and it modifies code to return the expected result.
+
+
+4. Calling function
+
+If the transformed function calls another function, ProgramTranslator also transform the called function. The benefit is that users can add one decorator at the outside function to do transformation, no need to add the decorator for each function. Note that ProgramTranslator doesn't support 
+that a function calls itself recursively, the details is in the unsupported grammars section below.
+
+
+Errors and Exceptions
+---------------------
+
+1. ``assert``
+
+If ``x`` is a Tensor, ``assert x`` statement can assert ``x`` to be ``True`` or non-zero value in dygraph mode. ProgramTranslator converts the statement into PaddlePaddle static graph ``Assert`` API to support this grammar.
+
+
+Python containers
+-----------------
+
+1. ``list``: if all elements in a list are Tensors, then ProgramTranslator converts it to TensorArray. PaddlePaddle static graph TensorArray supports append, pop, and modify, other list operations such as sort cannot be supported. When not all elements in a list are Tensors, ProgramTranslator will treat it as normal Python list.
+
+2. ``dict``: ProgramTranslator will add the Tensors in a dict into PaddlePaddle static graph ``Program``, so ``dict`` is supported by ProgramTranslator.
+
+Unsupported grammars
+--------------------
+
+1. Use the shape of output tensor of ``reshape``
+
+For example, ``x = reshape(x, shape=shape_tensor)`` , then use ``x.shape[0]`` to do other operation. Due to the difference between dygraph and static graph, it is okay in dygraph but it will fail in static graph. The reason is that APIs return computation result in dygraph mode, so ``x.shape`` has deterministic value after calling ``reshape`` . However, static graph doesn't have the value ``shape_tensor`` during building network, so PaddlePaddle doesn't know the value of ``x.shape`` after calling ``reshape``. PaddlePaddle static graph will set -1 to represent unknown shape value for each dimension of ``x.shape`` in this case, not the expected value.
+
+We suggest to set fixed shape value as much as possible, reduce the reshape operation.
+
+2. List of list of Tensor
+
+For example: ``l = [[tensor1, tensor2], [tensor3, tensor4]]``, because ProgramTranslator transformed a list whose elements are all Tensors into PaddlePaddle static graph TensorArray, but TensorArray doesn't support multi-dimensions, ProgramTranslator cannot run this case.
+
+We suggest to use 1-D list at most time, or use PaddlePaddle API ``create_array, array_read, array_write`` to control TensorArray.
+
+3. Convert Tensor to numpy array and do operation
+
+For example, user doesn't return Tensor in the decorated function but call ``numpy.array(tensor)`` to convert Tensor to numpy array and then use numpy API to compute on it. In dygraph mode, it is okey because Tensor has value, but Tensor is variable for building network in static graph mode, it doesn't contain value if not in static graph running time, so we cannot do numpy calculation on it.
+
+We suggest to use PaddlePaddle APIs to replace numpy API in this case.
+
+4. A function calls itself recursively
+
+ProgramTranslator doesn't support a function calls itself recursively, the reason is that recursive function usually uses ``if-else`` for a condition to stop the recursion, the stop condition will be transformed to a ``cond`` in static graph mode. Since ``cond`` just builds network, it cannot determine how many times it recursively builds network during network built stage, so the function will recursively call itself and build network until stack overflow. Due to above reason, ProgramTranslator cannot support a function calls itself recursively now.
+
+We suggest to write non-recursive function in this case.

doc/fluid/advanced_guide/dygraph_to_static/index_cn.rst

@@ -6,8 +6,15 @@
 
 - `支持语法列表 <grammar_list_cn.html>`_ ：介绍了动态图转静态图支持的语法以及罗列不支持的语法写法
 
+- `报错信息处理 <error_handling_cn.html>`_ ：介绍了动态图转静态图的报错信息处理方法
+
+- `调试方法 <debugging_cn.html>`_ ：介绍了动态图转静态图支持的调试方法
+
+
 ..  toctree::
     :hidden:
 
     grammar_list_cn.rst
     program_translator_cn.rst
+    error_handling_cn.md
+    debugging_cn.md

doc/fluid/advanced_guide/dygraph_to_static/index_en.rst

+#######################
+Dygraph to Static Graph
+#######################
+
+- `Dygraph to Static Graph <program_translator_cn.html>`_ ：Introduce the basic usage for transforming dygraph code into static code and the architecture of ProgramTranslator.
+
+- `Supported Grammars <grammar_list_en.html>`_ ：Introduce the grammars supported by ProgramTranslator and list unsupport grammars.
+
+- `Error Handling <error_handling_en.html>`_ ：Introduce the error handling by ProgramTranslator.
+
+- `Debugging Methods <debugging_en.html>`_ ：Introduce the debugging methods when using ProgramTranslator.
+
+..  toctree::
+    :hidden:
+
+    grammar_list_en.rst
+    program_translator_en.rst
+    error_handling_en.md
+    debugging_en.md
+

doc/fluid/advanced_guide/dygraph_to_static/program_translator_cn.rst

 动态图转静态图
 ================
 
-PaddlePadde的动态图具有接口易用、Python风格的编程体验、友好的debug交互等优点。在动态图模式下，代码是按照我们编写的顺序依次执行。这种机制更符合python程序员的习惯，可以很方便地将大脑中的想法快速地转化为实际代码，也更容易调试。但在部分性能方面，python速度负担太大，无法与C++相提并论。因此在工业界部署很多地方（如大型推荐系统、移动端）都倾向于直接使用C++来提速。
+动态图有诸多优点，包括易用的接口，python风格的编程体验，友好的debug交互机制等。在动态图模式下，代码是按照我们编写的顺序依次执行。这种机制更符合Python程序员的习惯，可以很方便地将大脑中的想法快速地转化为实际代码，也更容易调试。但在性能方面，Python执行开销较大，与C++有一定差距。因此在工业界的许多部署场景中（如大型推荐系统、移动端）都倾向于直接使用C++来提速。
 
-此时，静态图在部署方面更具有性能的优势。静态图程序在编译执行时，先搭建模型的神经网络结构，然后再对神经网络执行计算操作。预先搭建好的神经网络可以脱离python依赖，在C++端被重新解析执行。
+相比动态图，静态图在部署方面更具有性能的优势。静态图程序在编译执行时，先搭建模型的神经网络结构，然后再对神经网络执行计算操作。预先搭建好的神经网络可以脱离Python依赖，在C++端被重新解析执行，而且拥有整体网络结构也能进行一些网络结构的优化。
 
 动态图代码更易编写和debug，但在部署性能上，静态图更具优势。因此我们新增了动态图转静态图的功能，支持用户依然使用动态图编写组网代码。PaddlePaddle会对用户代码进行分析，自动转换为静态图网络结构，兼顾了动态图易用性和静态图部署性能两方面优势。
 
 基本使用方法
 --------------
 
-PaddlePaddle提供了两种动态图转静态图的方式，基于动态图trace的转换与基于源代码级别的转换的ProgramTranslator。
+PaddlePaddle提供了两种动态图转静态图的方式，基于动态图trace的TracedLayer与基于源代码级别转换的ProgramTranslator。
 
 1. 基于trace的TracedLayer：
 
@@ -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)
 
 
@@ -88,7 +88,7 @@ trace是指在模型运行时记录下其运行过哪些算子。TracedLayer就
 
 2. 基于源代码转写的ProgramTranslator
 
-对于依赖数据的控制流，我们使用基于源代码转写的ProgramTranslator来进行动态图转静态图。其基本原理是通过分析python代码来将动态图代码转写为静态图代码，并在底层自动帮用户使用执行器运行。其基本使用方法十分简便，只需要在要转化的函数（该函数也可以是用户自定义动态图Layer的forward函数）前添加一个装饰器@paddle.jit.to_static，上面的例子转化如下，并且可以依旧使用该函数运行得到结果：
+对于依赖数据的控制流，我们使用基于源代码转写的ProgramTranslator来进行动态图转静态图。其基本原理是通过分析Python代码来将动态图代码转写为静态图代码，并在底层自动帮用户使用执行器运行。其基本使用方法十分简便，只需要在要转化的函数（该函数也可以是用户自定义动态图Layer的forward函数）前添加一个装饰器 ``@paddle.jit.to_static`` ，上面的例子转化如下，并且可以依旧使用该函数运行得到结果：
 
 .. code-block:: python
 
@@ -108,7 +108,7 @@ trace是指在模型运行时记录下其运行过哪些算子。TracedLayer就
     func(input_var)
 
 
-若要存储转化后的静态图模型，可以调用paddle.jit.save，我们再以SimpleFcLayer为例，需要在SimpleFcLayer的forward函数添加装饰器：
+若要存储转化后的静态图模型，可以调用 ``paddle.jit.save`` ，我们再以SimpleFcLayer为例，需要在SimpleFcLayer的forward函数添加装饰器：
 
 .. code-block:: python
 
@@ -141,7 +141,7 @@ trace是指在模型运行时记录下其运行过哪些算子。TracedLayer就
     input_var = paddle.to_tensor(in_np)
     out = fc_layer(input_var)
 
-    paddle.jit.save(mnist, "./mnist_dy2stat", input_spec=[input_var])
+    paddle.jit.save(fc_layer, "./fc_layer_dy2stat", input_spec=[input_var])
 
 内部架构原理
 --------------
@@ -157,21 +157,21 @@ TracedLayer的原理就是trace，相对简单，因此我们在这里不展开
 
 2. 动态图源码转AST（抽象语法树）
 
-动态图转静态图的最核心部分类似一个编译器，解析动态图代码语句为AST，再对应AST进行改写，最后反转回成静态图代码。从函数转化为代码字符串可以使用Python的inspect.getsource。从字符串Python提供了自带的ast库来解析字符串为 `AST <https://docs.python.org/3/library/ast.html>`_ ，但是由于python2，python3的语法略有不同，为了避免我们需要额外处理这些python2，python3的不同情况，我们使用了统一python2，python3的开源AST处理 `gast库 <https://github.com/serge-sans-paille/gast>`_ 。这些接口使得函数转化为AST没有本质上的困难。
+动态图转静态图的最核心部分类似一个编译器，解析动态图代码语句为AST，再对应AST进行改写，最后反转回成静态图代码。从函数转化为代码字符串可以使用Python的inspect.getsource。从字符串Python提供了自带的 `ast <https://docs.python.org/3/library/ast.html>`_ 库来解析字符串为AST，但是由于Python2，Python3的语法略有不同，为了避免我们需要额外处理这些Python2，Python3的不同情况，我们使用了统一Python2，Python3的开源AST处理 `gast库 <https://github.com/serge-sans-paille/gast>`_ 。这些接口使得函数转化为AST没有本质上的困难。
 
 3. AST改写和静态图源码转换
 
-这部分为动转静最核心的部分，我们对支持的各种语法进行ast转写。其中最重要的python控制流，if-else，while，for循环被分别分析转化为PaddlePaddle静态图接口cond，while_loop等接口实现。我们对想转化的每一种主要语法创建一个Transformer（这里的Transformer是python ast转写的概念，而不是自然语言处理NLP领域的Transformer），每个Transformer扫一遍AST并进行对应的改写。最后被转化完成的AST我们使用gast提供的接口转回成源码。
+这部分为动转静最核心的部分，我们对支持的各种语法进行ast转写。其中最重要的Python控制流，if-else，while，for循环被分别分析转化为PaddlePaddle静态图接口cond，while_loop等接口实现。我们对想转化的每一种主要语法创建一个Transformer（这里的Transformer是Python ast转写的概念，而不是自然语言处理NLP领域的Transformer），每个Transformer扫一遍AST并进行对应的改写。最后被转化完成的AST我们使用gast提供的接口转回成源码。
 
 4. 静态图源码作为动态图一部分运行的技术
 
-为了动静转化更加易用和被转化的代码能在动态图中复用，我们在拥有源码后运行生成Program，并将这个Program作为一个大op，包装成动态图的一个op，这样既能把用户的代码转为静态图提速或者保存部署，另一方面如果用户想在python层使用生成的静态图代码作为动态图的一部分继续训练或者别的动态图运算也是可以直接使用。
+为了动静转化更加易用和被转化的代码能在动态图中复用，我们在拥有源码后运行生成Program，并将这个Program作为一个大op，包装成动态图的一个op，这样既能把用户的代码转为静态图提速或者保存部署，另一方面如果用户想在Python层使用生成的静态图代码作为动态图的一部分继续训练或者别的动态图运算也是可以直接使用。
 
 5. 易用性与Debug功能在动转静过程的实现
 
 正如AST转写类似编译器，而一般编译器都会提供debug断点，报错，输出一些中间代码等功能。我们在进行动转静时，万一用户的动态图代码出错，或者用户想断点调试，或者用户想看看被转化后的静态图代码是否符合其预期，我们也希望能够像编译器一样提供这些易用性功能，使得动转静兼顾性能和部署同时还具有易用性。我们这里将列出这些功能的实现方式
 
-A. 报错对应到动态图代码行。由于被转化后的静态图代码和原动态图代码不同，python运行出错时会报静态图的错误，因此我们在每一次AST转写时添加AST节点对应的原动态图代码行等信息，在python报错栈中将静态图的报错转化成对应的动态图源码报错
+A. 报错对应到动态图代码行。由于被转化后的静态图代码和原动态图代码不同，Python运行出错时会报静态图的错误，因此我们在每一次AST转写时添加AST节点对应的原动态图代码行等信息，在Python报错栈中将静态图的报错转化成对应的动态图源码报错
 
 B. 设置断点功能。我们保留了被转化后代码的中的pdb.set_trace(), 用户可以使用这种方式进行断点调试
 

doc/fluid/advanced_guide/dygraph_to_static/program_translator_en.rst

+Dygraph to Static Graph
+=======================
+
+The imperative-style coding of PaddlePaddle takes advantage of flexibility, Pythonic coding, and easy-to-debug interface. In dygraph mode, code immediately executes kernels and gets numerical results, which allows users to enjoy traditional Pythonic code order. Therefore it is efficient to transform idea into real code and simple to debug. However, Python code is usually slower than C++ thus lots of industrial systems (such as large recommend system, mobile devices) prefer to deploy with C++ implementation.
+
+Static graph is better at speed and portability. Static graph builds the network structure during compiling time and then does computation. The built network intermediate representation can be executed in C++ and gets rids of Python dependency.
+
+While dygraph has usability and debug benefits and static graph yields performance and deployment advantage, we adds functionality to convert dygraph to static graph. Users use imperative mode to write dygraph code and PaddlePaddle will analyze the Python syntax and turn it into network structure of static graph mode. Our approach retains both the usability of dygraph and portability of static graph.
+
+Basic Usage
+--------------
+
+PaddlePaddle has two ways to transform dygraph to static graph. TracedLayer extracts computation graph through tracing and ProgramTranslator gets computation graph through source code transformation.
+
+
+1. TracedLayer：
+
+Tracing means recording the operators when running a model. TracedLayer is based on this technique. It runs dygraph program once and records all operators, then constructs static graph model and saves it. Now take a glance at an usage example:
+
+Define a simple fully connected network:
+
+.. code-block:: python
+
+    import numpy as np
+    import paddle
+
+    class SimpleFcLayer(paddle.nn.Layer):
+        def __init__(self, feature_size, batch_size, fc_size):
+            super(SimpleFCLayer, self).__init__()
+            self._linear = paddle.nn.Linear(feature_size, fc_size)
+            self._offset = paddle.to_tensor(
+                np.random.random((batch_size, fc_size)).astype('float32'))
+
+        def forward(self, x):
+            fc = self._linear(x)
+            return fc + self._offset
+
+Save model by TracedLayer:
+
+.. code-block:: python
+
+    import paddle
+    from paddle.jit import TracedLayer
+
+    paddle.disable_static()
+
+    fc_layer = SimpleFcLayer(3, 4, 2)
+    in_np = np.random.random([3, 4]).astype('float32')
+    # Turn numpy ndarray into Tensor
+    input_var = paddle.to_tensor(in_np)
+    # Transforming imperative mode into declarative mode by TracerLayer.trace
+    out_dygraph, static_layer = TracedLayer.trace(fc_layer, inputs=[input_var])
+    save_dirname = './saved_infer_model'
+    # Save the transformed model
+    static_layer.save_inference_model(save_dirname, feed=[0], fetch=[0])
+
+Load model and run it in static graph mode:
+
+.. code-block:: python
+
+    place = paddle.CPUPlace()
+    exe = paddle.Executor(place)
+    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:
+
+.. code-block:: python
+
+    import paddle
+
+    def func(input_var)
+        # if condition depends on the shape of input_var
+        if input_var.shape[0] > 1:
+            return paddle.cast(input_var, "float64")
+        else:
+            return paddle.cast(input_var, "int64")
+
+    paddle.disable_static()
+    in_np = np.array([-2]).astype('int')
+    input_var = paddle.to_tensor(in_np)
+    out = func(input_var)
+
+If we apply TracedLayer.trace(func, inputs=[input_var]) on above example, tracing can take record of operators in only one branch of if-else, then the model can not be saved as what user orignally means. The similar situations applies to while/for loop.
+
+2. ProgramTranslator
+
+For the Tensor-dependent control flow, we use source-code-translate based ProgramTranslator to convert dygraph into static graph. The basic idea is analyzing Python source code and turning into static graph code, then run the static graph code using Executor. The basic usage of ProgramTranslator is simple, put a decorator ``@paddle.jit.to_static`` before the definition of the function to transform (the function can also be a method of a class, e.g., the ``forward`` function of user-defined imperative Layer). Above Tensor-dependent example can be transformed correctly by ProgramTranslator as below:
+
+.. code-block:: python
+
+    import paddle
+
+    @paddle.jit.to_static
+    def func(input_var)
+        # if condition depends on the shape of input_var
+        if input_var.shape[0] > 1:
+            out = paddle.cast(input_var, "float64")
+        else:
+            out = paddle.cast(input_var, "int64")
+
+    paddle.disable_static()
+    in_np = np.array([-2]).astype('int')
+    input_var = paddle.to_tensor(in_np)
+    func(input_var)
+
+To save the transformed model, we can call ``paddle.jit.save`` . Let's take ``SimpleFcLayer`` as an example again, we put decorator at the ``forward`` method of ``SimpleFcLayer`` :
+
+.. code-block:: python
+
+    import numpy as np
+    import paddle
+
+    class SimpleFcLayer(paddle.nn.Layer):
+        def __init__(self, feature_size, batch_size, fc_size):
+            super(SimpleFCLayer, self).__init__()
+            self._linear = paddle.nn.Linear(feature_size, fc_size)
+            self._offset = paddle.to_tensor(
+                np.random.random((batch_size, fc_size)).astype('float32'))
+
+        @paddle.jit.to_static
+        def forward(self, x):
+            fc = self._linear(x)
+            return fc + self._offset
+
+
+Calling ``paddle.jit.save`` to save above model:
+
+.. code-block:: python
+
+    import paddle
+
+    paddle.disable_static()
+
+    fc_layer = SimpleFcLayer(3, 4, 2)
+    in_np = np.random.random([3, 4]).astype('float32')
+    input_var = paddle.to_tensor(in_np)
+    out = fc_layer(input_var)
+
+    paddle.jit.save(fc_layer, "./fc_layer_dy2stat")
+
+
+Architecture
+--------------
+
+The basic idea of TracedLayer is tracing, it is relatively simple so we won't expend here. This section will talk about the source code transformation of ProgramTranslator.
+
+The transformation is implemented in the decorator so transformation happens when user calls the decorated function, the procedure includes these steps:
+
+1. Function and cache.
+
+The entity for transforming dygraph to static graph is the decorated function. For the PaddlePaddle APIs in the function, since they are same code under dygraph mode and static mode, we don't have to transform those code. However, those APIs are computation in dygraph model while they are building network in static graph mode, if the transformed functions are called multiple times, those APIs will build network multiple times in static graph, which can cause problem. To solve it as well as speed up the transformation, we maintain a cache that maps from function, input shapes, input data types to the Program built by the transformed function. If the function hits cache, we run the stored Program in static graph mode to get result, else we do the code transformation on the function and store the transformed Program into the cache.
+
+2. From dygraph source code to AST (Abstract Syntax Tree)
+
+The core of transforming dygraph to static graph is similar to a compiler, we parse the dygraph code into AST, change AST, then turn it back into static graph code. We use Python ``inspect.getsource`` to get the source code string of the function. Python provides ``ast`` library to parse string code into AST, but Python2, Python3 have slight grammar difference. To avoid the work to handle different grammars, we used an open source AST library `gast <https://github.com/serge-sans-paille/gast>`_ that provides compatibility AST among various Python versions. There is no essential difficulty to turn function into AST with these library.
+
+3. Transform AST and turn it to static graph code
+
+This part is the key part in ProgramTranslator, we modify AST for supported grammars. Those important Python control flows, such as ``if-elif-else, while, for`` loop are converted to PaddlePaddle static graph API ``cond, while_loop`` and so on. We created a Transformer (AST-to-AST Transformer in Python, not the Transformer in Natural Language Process) to transform each grammar. Every Transformer scans AST and modify it. Lastly, we turn AST back to source code string by ``gast`` library.
+
+4. Running static graph code as part of dygraph
+
+In order to increase usability and re-use the transformed static graph code in dygraph, we wrap the generated Program as an dygraph op, the op can run the forward and backward computation of transformed Program. Then we can not only speed up dygraph code or save it for deployment, but also enable user to run part of their dygraph code in static graph mode so that they can continue training or other dygraph computation in their dygraph code.
+
+5. Error handling and Debug
+
+Compiler usually supports debug functionality like breakpoint, throwing exception, print some mid-level codes. ProgramTranslator is similar to a compiler, users may would like to set breakpoints for debugging, or see whether the transformed static graph code is expected. So we also implemented those error handling and debug functionality. Here we list those functions and their implementation.
+
+A. Report errors/exceptions on dygraph code line. Because the transformed static graph code is different to original dygraph code, when Python executes the static graph code, the exceptions will be reported at static graph code. To locate the corresponding dygraph code, we attach some informations such as line number on AST nodes when we transform AST, then we can re-write the static graph exception to the corresponding dygraph code exception.
+
+B. We support ``pdb.set_trace()`` when running ProgramTranslator, user can add this line to set breakpoints.
+
+C. Check the transformed static graph code. Our transformed output is a Python class named ``StaticLayer``, this class can be called, but it also stores the transformed code string. Users could call ``StaticLayer.code`` to get the converted code.
+
+D. Print mid-level transformed code, such as what's the code after transforming ``for`` loop. We provide APIs to set log level to let user check the mid-level code.
+
+

doc/fluid/advanced_guide/index_en.rst

@@ -15,6 +15,7 @@ So far you have already been familiar with PaddlePaddle. And the next expectatio
 ..  toctree::
     :hidden:
 
+    dygraph_to_static/index_en.rst
     inference_deployment/index_en.rst
     flags/flags_en.rst
 

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/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/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/nn.rst

@@ -33,10 +33,10 @@ paddle.nn
     nn/ConstantPad2d.rst
     nn/ConstantPad3d.rst
     nn/continuous_value_model.rst
-    nn/conv2d.rst
-    nn/conv2d_transpose.rst
-    nn/conv3d.rst
-    nn/conv3d_transpose.rst
+    nn/Conv2d.rst
+    nn/Conv3d.rst
+    nn/ConvTranspose2d.rst 
+    nn/ConvTranspose3d.rst 
     nn/cosine_decay.rst
     nn/cosine_similarity.rst
     nn/CosineSimilarity.rst
@@ -88,8 +88,8 @@ paddle.nn
     nn/Linear.rst
     nn/linear_lr_warmup.rst
     nn/log_loss.rst
+    nn/log_sigmoid.rst
     nn/log_softmax.rst
-    nn/logsigmoid.rst
     nn/loss.rst
     nn/lrn.rst
     nn/margin_rank_loss.rst

doc/fluid/api/io/cache.rst → doc/fluid/api/nn/Conv2d.rst

 ..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
     !DO NOT EDIT THIS FILE MANUALLY!
 
-.. _api_fluid_io_cache:
+.. _api_nn_layer_conv_Conv2d:
 
-cache
------
+Conv2d
+------
 
-..  autofunction:: paddle.fluid.io.cache
+..  autoclass:: paddle.nn.layer.conv.Conv2d
+    :members:
+    :inherited-members:
     :noindex:
 

doc/fluid/api/io/chain.rst → doc/fluid/api/nn/Conv3d.rst

 ..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
     !DO NOT EDIT THIS FILE MANUALLY!
 
-.. _api_fluid_io_chain:
+.. _api_nn_layer_conv_Conv3d:
 
-chain
------
+Conv3d
+------
 
-..  autofunction:: paddle.fluid.io.chain
+..  autoclass:: paddle.nn.layer.conv.Conv3d
+    :members:
+    :inherited-members:
     :noindex:
 

doc/paddle/api/paddle/reader/ComposeNotAligned_cn.rst → doc/fluid/api/nn/ConvTranspose2d.rst

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

doc/fluid/api/nn/ConvTranspose3d.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_nn_layer_conv_ConvTranspose3d:
+
+ConvTranspose3d
+---------------
+
+..  autoclass:: paddle.nn.layer.conv.ConvTranspose3d
+    :members:
+    :inherited-members:
+    :noindex:
+

doc/fluid/api/nn/conv2d.rst

-.. _api_nn_conv2d:
-
-conv2d
--------------------------------
-:doc_source: paddle.fluid.layers.conv2d
-
-

doc/fluid/api/nn/conv2d_transpose.rst

-.. _api_nn_conv2d_transpose:
-
-conv2d_transpose
--------------------------------
-:doc_source: paddle.fluid.layers.conv2d_transpose
-
-

doc/fluid/api/nn/conv3d.rst

-.. _api_nn_conv3d:
-
-conv3d
--------------------------------
-:doc_source: paddle.fluid.layers.conv3d
-
-

doc/fluid/api/nn/conv3d_transpose.rst

-.. _api_nn_conv3d_transpose:
-
-conv3d_transpose
--------------------------------
-:doc_source: paddle.fluid.layers.conv3d_transpose
-
-

doc/fluid/api/nn/functional.rst

@@ -9,8 +9,13 @@ functional
     functional/l1_loss.rst
     functional/nll_loss.rst
     functional/mse_loss.rst
+    functional/kl_div.rst
     functional/one_hot.rst
     functional/ctc_loss.rst
     functional/adaptive_avg_pool2d.rst
     functional/adaptive_avg_pool3d.rst
+    functional/conv2d.rst
+    functional/conv3d.rst
+    functional/conv_transpose2d.rst
+    functional/conv_transpose3d.rst
     functional/bilinear.rst

doc/fluid/api/io/firstn.rst → doc/fluid/api/nn/functional/conv2d.rst

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

doc/fluid/api/io/buffered.rst → doc/fluid/api/nn/functional/conv3d.rst

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

doc/fluid/api/nn/functional/conv_transpose2d.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_nn_functional_conv_conv_transpose2d:
+
+conv_transpose2d
+----------------
+
+..  autofunction:: paddle.nn.functional.conv.conv_transpose2d
+    :noindex:
+

doc/fluid/api/nn/functional/conv_transpose3d.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_nn_functional_conv_conv_transpose3d:
+
+conv_transpose3d
+----------------
+
+..  autofunction:: paddle.nn.functional.conv.conv_transpose3d
+    :noindex:
+

doc/fluid/api/nn/functional/kl_div.rst

+.. _api_nn_functional_kl_div:
+
+kl_div
+-------------------------------
+
+..  autoclass:: paddle.nn.functional.kl_div
+    :members:
+    :inherited-members:
+    :noindex:
+

doc/fluid/api/nn/logsigmoid.rst → doc/fluid/api/nn/log_sigmoid.rst

-.. _api_nn_logsigmoid:
+.. _api_nn_log_sigmoid:
 
-logsigmoid
+log_sigmoid
 -------------------------------
 
-..  autofunction:: paddle.nn.functional.logsigmoid
+..  autofunction:: paddle.nn.functional.log_sigmoid
     :noindex:
 
 

doc/fluid/api/nn/loss.rst

@@ -11,5 +11,7 @@ loss
     loss/L1Loss.rst
     loss/MSELoss.rst
     loss/NLLLoss.rst
+    loss/KLDivLoss.rst
     loss/SmoothL1Loss.rst
     loss/CTCLoss.rst
+    loss/KLDivLoss.rst

doc/fluid/api/nn/loss/KLDivLoss.rst

+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
+
+.. _api_nn_loss_KLDivLoss:
+
+KLDivLoss
+-------------------------------
+
+..  autoclass:: paddle.nn.loss.KLDivLoss
+    :members:
+    :inherited-members:
+    :noindex:
+

doc/fluid/api/paddle/norm.rst

@@ -2,6 +2,6 @@
 
 norm
 -------------------------------
-:doc_source: paddle.fluid.layers.l2_normalize
+:doc_source: paddle.tensor.norm
 
 

doc/fluid/api/tensor/norm.rst

-.. _api_tensor_cn_norm:
+..  THIS FILE IS GENERATED BY `gen_doc.{py|sh}`
+    !DO NOT EDIT THIS FILE MANUALLY!
 
-norm
--------------------------------
-:doc_source: paddle.fluid.layers.l2_normalize
+.. _api_tensor_linalg_norm:
 
+norm
+------------
 
+..  autofunction:: paddle.tensor.linalg.norm
+    :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/dygraph_cn/jit_cn.rst

@@ -6,5 +6,7 @@ jit
     :maxdepth: 1
 
     jit_cn/save_cn.rst
+    jit_cn/set_code_level_cn.rst
+    jit_cn/set_verbosity_cn.rst
     jit_cn/load_cn.rst
     jit_cn/SaveLoadConfig_cn.rst

doc/fluid/api_cn/dygraph_cn/jit_cn/set_code_level_cn.rst

+.. _cn_api_fluid_dygraph_jit_set_code_level:
+
+set_code_level
+-----------------
+
+.. py:function:: paddle.fluid.dygraph.jit.set_code_level(level=100)
+
+设置代码级别，打印该级别 AST Transformer 转化后的代码。
+
+有两种方法设置代码级别：
+
+1. 调用函数 ``set_code_level``
+2. 设置环境变量 ``TRANSLATOR_CODE_LEVEL``
+
+.. note::
+    函数 ``set_code_level`` 的优先级高于环境变量 ``TRANSLATOR_CODE_LEVEL``。
+
+
+参数：
+  - **level** (int) - 打印的代码级别。默认值为100，这意味着打印的是所有 AST Transformer 转化后的代码。
+
+**示例代码**
+
+.. code-block:: python
+
+    import os
+    import paddle
+
+    paddle.jit.set_code_level(2)
+    # It will print the transformed code at level 2, which means to print the code after second transformer,
+    # as the date of August 28, 2020, it is CastTransformer.
+
+    os.environ['TRANSLATOR_CODE_LEVEL'] = '3'
+    # The code level is now 3, but it has no effect because it has a lower priority than `set_code_level`

doc/fluid/api_cn/dygraph_cn/jit_cn/set_verbosity_cn.rst

+.. _cn_api_fluid_dygraph_jit_set_verbosity:
+
+set_verbosity
+-----------------
+
+.. py:function:: paddle.fluid.dygraph.jit.set_verbosity(level=0)
+
+设置动态图转静态图的日志详细级别。
+
+有两种方法设置日志详细级别：
+
+1. 调用函数 ``set_verbosity``
+2. 设置环境变量 ``TRANSLATOR_VERBOSITY``
+
+.. note::
+    函数 ``set_verbosity`` 的优先级高于环境变量 ``TRANSLATOR_VERBOSITY``。
+
+
+参数：
+    - **level** (int) - 日志详细级别。值越大，表示越详细。默认值为0，表示不显示日志。
+
+**示例代码**
+
+.. code-block:: python
+
+    import os
+    import paddle
+
+    paddle.jit.set_verbosity(1)
+    # The verbosity level is now 1
+
+    os.environ['TRANSLATOR_VERBOSITY'] = '3'
+    # The verbosity level is now 3, but it has no effect because it has a lower priority than `set_verbosity`
+
+

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/imperative_cn/jit_cn.rst

@@ -6,5 +6,7 @@ jit
     :maxdepth: 1
 
     jit_cn/save_cn.rst
+    jit_cn/set_code_level_cn.rst
+    jit_cn/set_verbosity.rst
     jit_cn/load_cn.rst
-    jit_cn/SaveLoadConfig_cn.rst
\ No newline at end of file
+    jit_cn/SaveLoadConfig_cn.rst

doc/fluid/api_cn/imperative_cn/jit_cn/set_code_level_cn.rst

+.. _cn_api_imperative_jit_set_code_level:
+
+set_code_level
+-------------------------------
+:doc_source: paddle.fluid.dygraph.jit.set_code_level
\ No newline at end of file

doc/fluid/api_cn/imperative_cn/jit_cn/set_verbosity_cn.rst

+.. _cn_api_imperative_jit_set_verbosity:
+
+set_verbosity
+-------------------------------
+:doc_source: paddle.fluid.dygraph.jit.set_verbosity
\ No newline at end of file

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/abs_cn.rst

@@ -29,11 +29,9 @@ abs
 .. code-block:: python
 
         import paddle
-        import numpy as np
-
         paddle.disable_static()
-        x_data = np.array([-1, -2, -3, -4]).astype(np.float32)
-        x = paddle.to_variable(x_data)
-        res = paddle.abs(x)
-        print(res.numpy())
-        # [1, 2, 3, 4]
+
+        x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+        out = paddle.abs(x)
+        print(out.numpy())
+        # [0.4 0.2 0.1 0.3]

doc/fluid/api_cn/layers_cn/acos_cn.rst

@@ -30,11 +30,9 @@ arccosine函数。
 .. code-block:: python
 
         import paddle
-        import numpy as np
-
         paddle.disable_static()
-        x_data = np.array([-0.8183,  0.4912, -0.6444,  0.0371]).astype(np.float32)
-        x = paddle.to_variable(x_data)
-        res = paddle.acos(x)
-        print(res.numpy())
-        # [2.5293, 1.0573, 2.2711, 1.5336]
+
+        x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+        out = paddle.acos(x)
+        print(out.numpy())
+        # [1.98231317 1.77215425 1.47062891 1.26610367]

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/asin_cn.rst

@@ -29,11 +29,9 @@ arcsine函数。
 .. code-block:: python
 
         import paddle
-        import numpy as np
-
         paddle.disable_static()
-        x_data = np.array([-0.8183,  0.4912, -0.6444,  0.0371]).astype(np.float32)
-        x = paddle.to_variable(x_data)
-        res = paddle.asin(x)
-        print(res.numpy())
-        # [-0.9585,  0.5135, -0.7003,  0.0372]
+
+        x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+        out = paddle.asin(x)
+        print(out.numpy())
+        # [-0.41151685 -0.20135792  0.10016742  0.30469265]

doc/fluid/api_cn/layers_cn/atan_cn.rst

@@ -29,11 +29,9 @@ arctangent函数。
 .. code-block:: python
 
         import paddle
-        import numpy as np
-
         paddle.disable_static()
-        x_data = np.array([-0.8183,  0.4912, -0.6444,  0.0371]).astype(np.float32)
-        x = paddle.to_variable(x_data)
-        res = paddle.atan(x)
-        print(res.numpy())
-        # [-0.6858,  0.4566, -0.5724,  0.0371]
+
+        x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+        out = paddle.atan(x)
+        print(out.numpy())
+        # [-0.38050638 -0.19739556  0.09966865  0.29145679]

doc/fluid/api_cn/layers_cn/ceil_cn.rst

@@ -31,12 +31,9 @@ ceil
 .. code-block:: python
 
         import paddle
-        import numpy as np
-
         paddle.disable_static()
-        x_data = np.array([[-1.5,6],[1,15.6]]).astype(np.float32)
-        x = paddle.to_variable(x_data)
-        res = paddle.ceil(x)
-        print(res.numpy())
-        # [[-1.  6.]
-        # [ 1. 16.]]
+
+        x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+        out = paddle.ceil(x)
+        print(out.numpy())
+        # [-0. -0.  1.  1.]

doc/fluid/api_cn/layers_cn/cos_cn.rst

@@ -32,12 +32,9 @@ cos
 .. code-block:: python
 
         import paddle
-        import numpy as np
-
         paddle.disable_static()
-        x_data = np.array([[-1,np.pi],[1,15.6]]).astype(np.float32)
-        x = paddle.to_variable(x_data)
-        res = paddle.cos(x)
-        print(res.numpy())
-        # [[ 0.54030231 -1.        ]
-        # [ 0.54030231 -0.99417763]]
+
+        x = paddle.to_tensor([-0.4, -0.2, 0.1, 0.3])
+        out = paddle.cos(x)
+        print(out.numpy())
+        # [0.92106099 0.98006658 0.99500417 0.95533649]

doc/fluid/api_cn/layers_cn/logsigmoid_cn.rst

@@ -5,12 +5,6 @@ logsigmoid
 
 .. py:function:: paddle.fluid.layers.logsigmoid(x, name=None)
 
-:alias_main: paddle.nn.functional.logsigmoid
-:alias: paddle.nn.functional.logsigmoid,paddle.nn.functional.activation.logsigmoid
-:old_api: paddle.fluid.layers.logsigmoid
-
-
-
 Logsigmoid激活函数
 
 

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.rst

@@ -8,8 +8,11 @@ paddle.nn
 ..  toctree::
     :maxdepth: 1
 
-    nn_cn/Conv1D_cn.rst
-    nn_cn/Conv2D_cn.rst
+    nn_cn/Conv1d_cn.rst
+    nn_cn/Conv2d_cn.rst
+    nn_cn/Conv3d_cn.rst
+    nn_cn/ConvTranspose2d_cn.rst
+    nn_cn/ConvTranspose3d_cn.rst
     nn_cn/diag_embed_cn.rst
     nn_cn/interpolate_cn.rst
     nn_cn/Linear_cn.rst
@@ -106,8 +109,8 @@ paddle.nn
     nn_cn/leaky_relu_cn.rst
     nn_cn/Linear_cn.rst
     nn_cn/linear_lr_warmup_cn.rst
-    nn_cn/logsigmoid_cn.rst
     nn_cn/log_loss_cn.rst
+    nn_cn/log_sigmoid_cn.rst
     nn_cn/log_softmax_cn.rst
     nn_cn/lrn_cn.rst
     nn_cn/margin_ranking_loss_cn.rst

doc/fluid/api_cn/nn_cn/Conv2d_cn.rst

+Conv2d
+-------------------------------
+
+.. py:class:: paddle.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, padding_mode='zeros', weight_attr=None, bias_attr=None, data_format="NCHW")
+
+
+
+**二维卷积层**
+
+该OP是二维卷积层（convolution2d layer），根据输入、卷积核、步长（stride）、填充（padding）、空洞大小（dilations）一组参数计算输出特征层大小。输入和输出是NCHW或NHWC格式，其中N是批尺寸，C是通道数，H是特征高度，W是特征宽度。卷积核是MCHW格式，M是输出图像通道数，C是输入图像通道数，H是卷积核高度，W是卷积核宽度。如果组数(groups)大于1，C等于输入图像通道数除以组数的结果。详情请参考UFLDL's : `卷积 <http://ufldl.stanford.edu/tutorial/supervised/FeatureExtractionUsingConvolution/>`_ 。如果bias_attr不为False，卷积计算会添加偏置项。
+
+对每个输入X，有等式：
+
+.. math::
+
+    Out = \sigma \left ( W * X + b \right )
+
+其中：
+    - :math:`X` ：输入值，NCHW或NHWC格式的4-D Tensor
+    - :math:`W` ：卷积核值，MCHW格式的4-D Tensor
+    - :math:`*` ：卷积操作
+    - :math:`b` ：偏置值，2-D Tensor，形状为 ``[M,1]``
+    - :math:`\sigma` ：激活函数
+    - :math:`Out` ：输出值，NCHW或NHWC格式的4-D Tensor， 和 ``X`` 的形状可能不同
+
+
+参数：
+    - **in_channels** (int) - 输入图像的通道数。
+    - **out_channels** (int) - 由卷积操作产生的输出的通道数。
+    - **kernel_size** (int|list|tuple) - 卷积核大小。可以为单个整数或包含两个整数的元组或列表，分别表示卷积核的高和宽。如果为单个整数，表示卷积核的高和宽都等于该整数。
+    - **stride** (int|list|tuple，可选) - 步长大小。可以为单个整数或包含两个整数的元组或列表，分别表示卷积沿着高和宽的步长。如果为单个整数，表示沿着高和宽的步长都等于该整数。默认值：1。
+    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有3种格式：(1)包含4个二元组：当 ``data_format`` 为"NCHW"时为 [[0,0], [0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NHWC"时为[[0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含4个整数值：[padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含2个整数值：[padding_height, padding_width]，此时padding_height_top = padding_height_bottom = padding_height， padding_width_left = padding_width_right = padding_width。若为一个整数，padding_height = padding_width = padding。默认值：0。
+    - **dilation** (int|list|tuple，可选) - 空洞大小。可以为单个整数或包含两个整数的元组或列表，分别表示卷积核中的元素沿着高和宽的空洞。如果为单个整数，表示高和宽的空洞都等于该整数。默认值：1。
+    - **groups** (int，可选) - 二维卷积层的组数。根据Alex Krizhevsky的深度卷积神经网络（CNN）论文中的成组卷积：当group=n，输入和卷积核分别根据通道数量平均分为n组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第n组卷积核和第n组输入进行卷积计算。默认值：1。
+    - **padding_mode** (str, 可选): 填充模式。 包括 ``'zeros'``, ``'reflect'``, ``'replicate'`` 或者 ``'circular'``. 默认值: ``'zeros'`` .
+    - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若 ``bias_attr`` 为bool类型，只支持为False，表示没有偏置参数。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+    - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCHW"和"NHWC"。N是批尺寸，C是通道数，H是特征高度，W是特征宽度。默认值："NCHW"。
+
+
+属性
+::::::::::::
+.. py:attribute:: weight
+本层的可学习参数，类型为 ``Parameter``
+
+.. py:attribute:: bias
+本层的可学习偏置，类型为 ``Parameter``
+    
+形状:
+    - 输入: :math:`(N, C_{in}, H_{in}, W_{in})`
+    - 输出: :math:`(N, C_{out}, H_{out}, W_{out})`
+
+    其中:
+
+    .. math::
+        H_{out} = \frac{(H_{in} + 2 * paddings[0] - (dilations[0] * (kernel\_size[0] - 1) + 1))}{strides[0]} + 1
+
+        W_{out} = \frac{(W_{in} + 2 * paddings[1] - (dilations[1] * (kernel\_size[1] - 1) + 1))}{strides[1]} + 1
+
+    如果 ``padding`` = "SAME":
+
+    .. math::
+        H_{out} = \frac{(H_{in} + stride[0] - 1)}{stride[0]}
+
+    .. math::
+        W_{out} = \frac{(W_{in} + stride[1] - 1)}{stride[1]}
+
+    如果 ``padding`` = "VALID":
+
+    .. math::
+        H_{out} = \frac{\left ( H_{in} -\left ( dilation[0]*\left ( kernel\_size[0]-1 \right )+1 \right ) \right )}{stride[0]}+1
+
+        W_{out} = \frac{\left ( W_{in} -\left ( dilation[1]*\left ( kernel\_size[1]-1 \right )+1 \right ) \right )}{stride[1]}+1
+
+
+抛出异常：
+    - ``ValueError`` - 如果 ``data_format`` 既不是"NCHW"也不是"NHWC"。
+    - ``ValueError`` - 如果 ``input`` 的通道数未被明确定义。
+    - ``ValueError`` - 如果 ``padding`` 是字符串，既不是"SAME"也不是"VALID"。
+    - ``ValueError`` - 如果 ``padding`` 含有4个二元组，与批尺寸对应维度的值不为0或者与通道对应维度的值不为0。
+    - ``ShapeError`` - 如果输入不是4-D Tensor。
+    - ``ShapeError`` - 如果输入和卷积核的维度大小不相同。
+    - ``ShapeError`` - 如果输入的维度大小与 ``stride`` 之差不是2。
+    - ``ShapeError`` - 如果输出的通道数不能被 ``groups`` 整除。
+
+
+**代码示例**：
+
+.. code-block:: python
+
+   import numpy as np
+   import paddle
+   import paddle.nn as nn
+   x = np.random.uniform(-1, 1, (2, 4, 8, 8)).astype('float32')
+   
+   paddle.disable_static()
+   x_var = paddle.to_tensor(x)
+   conv = nn.Conv2d(4, 6, (3, 3))
+   y_var = conv(x_var)
+   y_np = y_var.numpy()
+   print(y_np.shape)
+   
+   # (2, 6, 6, 6)

doc/fluid/api_cn/nn_cn/Conv3d_cn.rst

+Conv3d
+-------------------------------
+
+.. py:class:: paddle.nn.Conv3d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, padding_mode='zeros', weight_attr=None, bias_attr=None, data_format="NCDHW")
+
+
+
+**三维卷积层**
+
+该OP是三维卷积层（convolution3D layer），根据输入、卷积核、步长（stride）、填充（padding）、空洞大小（dilations）一组参数计算得到输出特征层大小。输入和输出是NCDHW或NDWHC格式，其中N是批尺寸，C是通道数，D是特征层深度，H是特征层高度，W是特征层宽度。三维卷积（Convlution3D）和二维卷积（Convlution2D）相似，但多了一维深度信息（depth）。如果bias_attr不为False，卷积计算会添加偏置项。
+
+对每个输入X，有等式：
+
+.. math::
+
+    Out = \sigma \left ( W * X + b \right )
+
+其中：
+    - :math:`X` ：输入值，NCDHW或NDHWC格式的5-D Tensor
+    - :math:`W` ：卷积核值，MCDHW格式的5-D Tensor
+    - :math:`*` ：卷积操作
+    - :math:`b` ：偏置值，2-D Tensor，形为 ``[M,1]``
+    - :math:`\sigma` ：激活函数
+    - :math:`Out` ：输出值, NCDHW或NDHWC格式的5-D Tensor，和 ``X`` 的形状可能不同
+
+参数：
+    - **in_channels** (int) - 输入图像的通道数。
+    - **out_channels** (int) - 由卷积操作产生的输出的通道数。
+    - **kernel_size** (int|list|tuple) - 卷积核大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积核的深度，高和宽。如果为单个整数，表示卷积核的深度，高和宽都等于该整数。
+    - **stride** (int|list|tuple，可选) - 步长大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积沿着深度，高和宽的步长。如果为单个整数，表示沿着高和宽的步长都等于该整数。默认值：1。
+    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有3种格式：(1)包含5个二元组：当 ``data_format`` 为"NCDHW"时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NDHWC"时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含6个整数值：[padding_depth_front, padding_depth_back, padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含3个整数值：[padding_depth, padding_height, padding_width]，此时 padding_depth_front = padding_depth_back = padding_depth, padding_height_top = padding_height_bottom = padding_height, padding_width_left = padding_width_right = padding_width。若为一个整数，padding_depth = padding_height = padding_width = padding。默认值：0。
+    - **dilation** (int|list|tuple，可选) - 空洞大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积核中的元素沿着深度，高和宽的空洞。如果为单个整数，表示深度，高和宽的空洞都等于该整数。默认值：1。
+    - **groups** (int，可选) - 三维卷积层的组数。根据Alex Krizhevsky的深度卷积神经网络（CNN）论文中的成组卷积：当group=n，输入和卷积核分别根据通道数量平均分为n组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第n组卷积核和第n组输入进行卷积计算。默认值：1。
+    - **padding_mode** (str, 可选): 填充模式。 包括 ``'zeros'``, ``'reflect'``, ``'replicate'`` 或者 ``'circular'``. 默认值: ``'zeros'`` .
+    - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若 ``bias_attr`` 为bool类型，只支持为False，表示没有偏置参数。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+    - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCDHW"和"NDHWC"。N是批尺寸，C是通道数，D是特征深度，H是特征高度，W是特征宽度。默认值："NCDHW"。
+
+
+属性
+::::::::::::
+.. py:attribute:: weight
+本层的可学习参数，类型为 ``Parameter``
+
+.. py:attribute:: bias
+本层的可学习偏置，类型为 ``Parameter``
+    
+形状：
+
+    - 输入：:math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`
+    - 输出：:math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`
+
+    其中
+
+    .. math::
+
+        D_{out} &= \frac{\left ( D_{in} + padding\_depth\_front + padding\_depth\_back-\left ( dilation[0]*\left ( kernel\_size[0]-1 \right )+1 \right ) \right )}{stride[0]}+1
+
+        H_{out} &= \frac{\left ( H_{in} + padding\_height\_top + padding\_height\_bottom-\left ( dilation[1]*\left ( kernel\_size[1]-1 \right )+1 \right ) \right )}{stride[1]}+1
+
+        W_{out} &= \frac{\left ( W_{in} + padding\_width\_left + padding\_width\_right -\left ( dilation[2]*\left ( kernel\_size[2]-1 \right )+1 \right ) \right )}{stride[2]}+1
+
+    如果 ``padding`` = "SAME":
+
+    .. math::
+        D_{out} = \frac{(D_{in} + stride[0] - 1)}{stride[0]}
+
+        H_{out} = \frac{(H_{in} + stride[1] - 1)}{stride[1]}
+
+        W_{out} = \frac{(W_{in} + stride[2] - 1)}{stride[2]}
+
+    如果 ``padding`` = "VALID":
+
+    .. math::
+        D_{out} = \frac{\left ( D_{in} -\left ( dilation[0]*\left ( kernel\_size[0]-1 \right )+1 \right ) \right )}{stride[0]}+1
+
+        H_{out} = \frac{\left ( H_{in} -\left ( dilation[1]*\left ( kernel\_size[1]-1 \right )+1 \right ) \right )}{stride[1]}+1
+
+        W_{out} = \frac{\left ( W_{in} -\left ( dilation[2]*\left ( kernel\_size[2]-1 \right )+1 \right ) \right )}{stride[2]}+1
+
+抛出异常：
+    - ``ValueError`` - 如果 ``data_format`` 既不是"NCDHW"也不是"NDHWC"。
+    - ``ValueError`` - 如果 ``input`` 的通道数未被明确定义。
+    - ``ValueError`` - 如果 ``padding`` 是字符串，既不是"SAME"也不是"VALID"。
+    - ``ValueError`` - 如果 ``padding`` 含有5个二元组，与批尺寸对应维度的值不为0或者与通道对应维度的值不为0。
+    - ``ShapeError`` - 如果输入不是5-D Tensor。
+    - ``ShapeError`` - 如果输入和卷积核的维度大小不相同。
+    - ``ShapeError`` - 如果输入的维度大小与 ``stride`` 之差不是2。
+    - ``ShapeError`` - 如果输出的通道数不能被 ``groups`` 整除。
+
+
+**代码示例**：
+
+.. code-block:: python
+
+   import numpy as np
+          
+   import paddle
+   import paddle.nn as nn
+   x = np.random.uniform(-1, 1, (2, 4, 8, 8, 8)).astype('float32')
+   
+   paddle.disable_static()
+   
+   x_var = paddle.to_tensor(x)
+   conv = nn.Conv3d(4, 6, (3, 3, 3))
+   y_var = conv(x_var)
+   y_np = y_var.numpy()
+   print(y_np.shape)
+   
+   # (2, 6, 6, 6, 6)

doc/fluid/api_cn/nn_cn/ConvTranspose2d_cn.rst

+ConvTranspose2d
+-------------------------------
+
+.. py:class:: paddle.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, dilation=1, weight_attr=None, bias_attr=None, data_format="NCHW")
+
+
+二维转置卷积层（Convlution2d transpose layer）
+
+该层根据输入（input）、卷积核（kernel）和空洞大小（dilations）、步长（stride）、填充（padding）来计算输出特征层大小或者通过output_size指定输出特征层大小。输入(Input)和输出(Output)为NCHW或NHWC格式，其中N为批尺寸，C为通道数（channel），H为特征层高度，W为特征层宽度。卷积核是MCHW格式，M是输出图像通道数，C是输入图像通道数，H是卷积核高度，W是卷积核宽度。如果组数大于1，C等于输入图像通道数除以组数的结果。转置卷积的计算过程相当于卷积的反向计算。转置卷积又被称为反卷积（但其实并不是真正的反卷积）。欲了解转置卷积层细节，请参考下面的说明和 参考文献_ 。如果参数bias_attr不为False, 转置卷积计算会添加偏置项。
+
+.. _参考文献: https://arxiv.org/pdf/1603.07285.pdf
+
+
+输入 :math:`X` 和输出 :math:`Out` 函数关系如下：
+
+.. math::
+                        Out=\sigma (W*X+b)\\
+
+其中：
+    -  :math:`X` : 输入，具有NCHW或NHWC格式的4-D Tensor
+    -  :math:`W` : 卷积核，具有NCHW格式的4-D Tensor
+    -  :math:`*` : 卷积计算（注意：转置卷积本质上的计算还是卷积）
+    -  :math:`b` : 偏置（bias），2-D Tensor，形状为 ``[M,1]``
+    -  :math:`σ` : 激活函数
+    -  :math:`Out` : 输出值，NCHW或NHWC格式的4-D Tensor， 和 ``X`` 的形状可能不同
+
+
+注意：
+
+如果output_size为None，则 :math:`H_{out}` = :math:`H^\prime_{out}` , :math:`W_{out}` = :math:`W^\prime_{out}` ;否则，指定的output_size_height（输出特征层的高） :math:`H_{out}` 应当介于 :math:`H^\prime_{out}` 和 :math:`H^\prime_{out} + strides[0]` 之间（不包含 :math:`H^\prime_{out} + strides[0]` ）, 并且指定的output_size_width（输出特征层的宽） :math:`W_{out}` 应当介于 :math:`W^\prime_{out}` 和 :math:`W^\prime_{out} + strides[1]` 之间（不包含 :math:`W^\prime_{out} + strides[1]` ）。
+
+由于转置卷积可以当成是卷积的反向计算，而根据卷积的输入输出计算公式来说，不同大小的输入特征层可能对应着相同大小的输出特征层，所以对应到转置卷积来说，固定大小的输入特征层对应的输出特征层大小并不唯一。
+
+如果指定了output_size， ``conv2d_transpose`` 可以自动计算卷积核的大小。
+
+参数:
+  - **in_channels** (int) - 输入图像的通道数。
+  - **out_channels** (int) - 卷积核的个数，和输出特征图通道数相同。
+  - **kernel_size** (int|list|tuple) - 卷积核大小。可以为单个整数或包含两个整数的元组或列表，分别表示卷积核的高和宽。如果为单个整数，表示卷积核的高和宽都等于该整数。
+  - **stride** (int|tuple, 可选) - 步长大小。如果 ``stride`` 为元组或列表，则必须包含两个整型数，分别表示垂直和水平滑动步长。否则，表示垂直和水平滑动步长均为 ``stride`` 。默认值：1。
+  - **padding** (int|tuple, 可选) - 填充大小。如果 ``padding`` 为元组或列表，则必须包含两个整型数，分别表示竖直和水平边界填充大小。否则，表示竖直和水平边界填充大小均为 ``padding`` 。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考下方形状 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。默认值：0。
+  - **output_padding** (int|list|tuple, optional): 输出形状上一侧额外添加的大小. 默认值: 0.
+  - **groups** (int, 可选) - 二维卷积层的组数。根据Alex Krizhevsky的深度卷积神经网络（CNN）论文中的分组卷积：当group=2，卷积核的前一半仅和输入特征图的前一半连接。卷积核的后一半仅和输入特征图的后一半连接。默认值：1。
+  - **dilation** (int|tuple, 可选) - 空洞大小。可以为单个整数或包含两个整数的元组或列表，分别表示卷积核中的元素沿着高和宽的空洞。如果为单个整数，表示高和宽的空洞都等于该整数。默认值：1。
+  - **weight_attr** (ParamAttr, 可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+  - **bias_attr** (ParamAttr|bool, 可选) - 指定偏置参数属性的对象。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+  - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCHW"和"NHWC"。N是批尺寸，C是通道数，H是特征高度，W是特征宽度。默认值："NCHW"。
+  
+
+形状:
+
+    - 输入：:math:`（N，C_{in}， H_{in}， W_{in}）`
+
+
+    - 输出：:math:`（N，C_{out}, H_{out}, W_{out}）`
+
+    其中
+
+    .. math::
+
+        & H'_{out} = (H_{in}-1)*strides[0] - pad\_height\_top - pad\_height\_bottom + dilations[0]*(kernel\_size[0]-1)+1\\
+        & W'_{out} = (W_{in}-1)*strides[1]- pad\_width\_left - pad\_width\_right + dilations[1]*(kernel\_size[1]-1)+1 \\
+        & H_{out}\in[H'_{out},H'_{out} + strides[0])\\
+        & W_{out}\in[W'_{out},W'_{out} + strides[1])\\
+
+    如果 ``padding`` = "SAME":
+
+    .. math::
+        & H'_{out} = \frac{(H_{in} + stride[0] - 1)}{stride[0]}\\
+        & W'_{out} = \frac{(W_{in} + stride[1] - 1)}{stride[1]}\\
+
+    如果 ``padding`` = "VALID":
+
+    .. math::
+        & H'_{out} = (H_{in}-1)*strides[0] + dilations[0]*(kernel\_size[0]-1)+1\\
+        & W'_{out} = (W_{in}-1)*strides[1] + dilations[1]*(kernel\_size[1]-1)+1 \\
+
+抛出异常:
+    -  ``ValueError`` : 如果输入的shape、filter_size、stride、padding和groups不匹配，抛出ValueError
+    -  ``ValueError`` - 如果 ``data_format`` 既不是"NCHW"也不是"NHWC"。
+    -  ``ValueError`` - 如果 ``padding`` 是字符串，既不是"SAME"也不是"VALID"。
+    -  ``ValueError`` - 如果 ``padding`` 含有4个二元组，与批尺寸对应维度的值不为0或者与通道对应维度的值不为0。
+    -  ``ValueError`` - 如果 ``output_size`` 和 ``filter_size`` 同时为None。
+    -  ``ShapeError`` - 如果输入不是4-D Tensor。
+    -  ``ShapeError`` - 如果输入和卷积核的维度大小不相同。
+    -  ``ShapeError`` - 如果输入的维度大小与 ``stride`` 之差不是2。
+
+**代码示例**
+
+..  code-block:: python
+
+    import numpy as np
+    import paddle
+    import paddle.nn as nn
+
+    x = np.random.uniform(-1, 1, (2, 4, 8, 8)).astype('float32')
+
+    paddle.disable_static()
+
+    x_var = paddle.to_tensor(x)
+    conv = nn.ConvTranspose2d(4, 6, (3, 3))
+    y_var = conv(x_var)
+    y_np = y_var.numpy()
+    print(y_np.shape)
+    
+    # (2, 6, 10, 10)

doc/fluid/api_cn/nn_cn/ConvTranspose3d_cn.rst

+ConvTranspose3d
+-------------------------------
+
+.. py:class:: paddle.nn.ConvTranspose3d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, dilation=1, weight_attr=None, bias_attr=None, data_format="NCDHW")
+
+
+三维转置卷积层（Convlution3d transpose layer)
+
+该层根据输入（input）、卷积核（kernel）和卷积核空洞大小（dilations）、步长（stride）、填充（padding）来计算输出特征层大小或者通过output_size指定输出特征层大小。输入(Input)和输出(Output)为NCDHW或者NDHWC格式。其中N为批尺寸，C为通道数（channel），D为特征深度，H为特征层高度，W为特征层宽度。转置卷积的计算过程相当于卷积的反向计算。转置卷积又被称为反卷积（但其实并不是真正的反卷积）。欲了解卷积转置层细节，请参考下面的说明和 参考文献_ 。如果参数bias_attr不为False, 转置卷积计算会添加偏置项。
+
+.. _参考文献: http://www.matthewzeiler.com/wp-content/uploads/2017/07/cvpr2010.pdf
+
+输入 :math:`X` 和输出 :math:`Out` 函数关系如下：
+
+.. math::
+                        \\Out=\sigma (W*X+b)\\
+
+其中：
+    -  :math:`X` : 输入，具有NCDHW或NDHWC格式的5-D Tensor
+    -  :math:`W` : 卷积核，具有NCDHW格式的5-D Tensor
+    -  :math:`*` : 卷积操作（注意：转置卷积本质上的计算还是卷积）
+    -  :math:`b` : 偏置（bias），2-D Tensor，形状为 ``[M,1]``
+    -  :math:`σ` : 激活函数
+    -  :math:`Out` : 输出值，NCDHW或NDHWC格式的5-D Tensor，和 ``X`` 的形状可能不同
+
+
+注意：
+
+如果output_size为None，则 :math:`H_{out}` = :math:`H^\prime_{out}` , :math:`W_{out}` = :math:`W^\prime_{out}` ;否则，指定的output_size_height（输出特征层的高） :math:`H_{out}` 应当介于 :math:`H^\prime_{out}` 和 :math:`H^\prime_{out} + strides[0]` 之间（不包含 :math:`H^\prime_{out} + strides[0]` ）, 并且指定的output_size_width（输出特征层的宽） :math:`W_{out}` 应当介于 :math:`W^\prime_{out}` 和 :math:`W^\prime_{out} + strides[1]` 之间（不包含 :math:`W^\prime_{out} + strides[1]` ）。
+
+由于转置卷积可以当成是卷积的反向计算，而根据卷积的输入输出计算公式来说，不同大小的输入特征层可能对应着相同大小的输出特征层，所以对应到转置卷积来说，固定大小的输入特征层对应的输出特征层大小并不唯一。
+
+如果指定了output_size， 该算子可以自动计算卷积核的大小。
+
+参数:
+  - **in_channels** (int) - 输入图像的通道数。
+  - **out_channels** (int) - 卷积核的个数，和输出特征图个数相同。
+  - **kernel_size** (int|list|tuple) - 卷积核大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积核的深度，高和宽。如果为单个整数，表示卷积核的深度，高和宽都等于该整数。默认：None。output_size和kernel_size不能同时为None。
+  - **stride** (int|tuple, 可选) - 步长大小。如果 ``stride`` 为元组或列表，则必须包含三个整型数，分别表示深度，垂直和水平滑动步长。否则，表示深度，垂直和水平滑动步长均为 ``stride`` 。默认值：1。
+  - **padding** (int|tuple, 可选) - 填充大小。如果 ``padding`` 为元组或列表，则必须包含三个整型数，分别表示深度，竖直和水平边界填充大小。否则，表示深度，竖直和水平边界填充大小均为 ``padding`` 。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考下方形状 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。默认值：0。
+  - **output_padding** (int|list|tuple, optional): 输出形状上一侧额外添加的大小. 默认值: 0.
+  - **groups** (int, 可选) - 二维卷积层的组数。根据Alex Krizhevsky的深度卷积神经网络（CNN）论文中的分组卷积：当group=2，卷积核的前一半仅和输入特征图的前一半连接。卷积核的后一半仅和输入特征图的后一半连接。默认值：1。
+  - **dilation** (int|tuple, 可选) - 空洞大小。可以为单个整数或包含三个整数的元组或列表，分别表示卷积核中的元素沿着深度，高和宽的空洞。如果为单个整数，表示深度，高和宽的空洞都等于该整数。默认值：1。
+  - **weight_attr** (ParamAttr, 可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+  - **bias_attr** (ParamAttr|bool, 可选) - 指定偏置参数属性的对象。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+  - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCHW"和"NHWC"。N是批尺寸，C是通道数，H是特征高度，W是特征宽度。默认值："NCDHW"。
+
+形状:
+
+    - 输入：:math:`（N，C_{in}， H_{in}， W_{in}）`
+
+
+    - 输出：:math:`（N，C_{out}, H_{out}, W_{out}）`
+
+    其中
+
+    .. math::
+
+        & D'_{out}=(D_{in}-1)*strides[0] - pad\_depth\_front - pad\_depth\_back + dilations[0]*(kernel\_size[0]-1)+1\\
+        & H'_{out} = (H_{in}-1)*strides[1] - pad\_height\_top - pad\_height\_bottom + dilations[1]*(kernel\_size[1]-1)+1\\
+        & W'_{out} = (W_{in}-1)*strides[2]- pad\_width\_left - pad\_width\_right + dilations[2]*(kernel\_size[2]-1)+1 \\
+        & D_{out}\in[D'_{out},D'_{out} + strides[0])\\
+        & H_{out}\in[H'_{out},H'_{out} + strides[1])\\
+        & W_{out}\in[W'_{out},W'_{out} + strides[2])\\
+
+    如果 ``padding`` = "SAME":
+
+    .. math::
+        & D'_{out} = \frac{(D_{in} + stride[0] - 1)}{stride[0]}\\
+        & H'_{out} = \frac{(H_{in} + stride[1] - 1)}{stride[1]}\\
+        & W'_{out} = \frac{(W_{in} + stride[2] - 1)}{stride[2]}\\
+
+    如果 ``padding`` = "VALID":
+
+    .. math::
+        & D'_{out} = (D_{in}-1)*strides[0] + dilations[0]*(kernel\_size[0]-1)+1\\
+        & H'_{out} = (H_{in}-1)*strides[1] + dilations[1]*(kernel\_size[1]-1)+1\\
+        & W'_{out} = (W_{in}-1)*strides[2] + dilations[2]*(kernel\_size[2]-1)+1 \\
+
+抛出异常:
+    -  ``ValueError`` : 如果输入的shape、kernel_size、stride、padding和groups不匹配，抛出ValueError
+    -  ``ValueError`` - 如果 ``data_format`` 既不是"NCHW"也不是"NHWC"。
+    -  ``ValueError`` - 如果 ``padding`` 是字符串，既不是"SAME"也不是"VALID"。
+    -  ``ValueError`` - 如果 ``padding`` 含有4个二元组，与批尺寸对应维度的值不为0或者与通道对应维度的值不为0。
+    -  ``ValueError`` - 如果 ``output_size`` 和 ``filter_size`` 同时为None。
+    -  ``ShapeError`` - 如果输入不是4-D Tensor。
+    -  ``ShapeError`` - 如果输入和卷积核的维度大小不相同。
+    -  ``ShapeError`` - 如果输入的维度大小与 ``stride`` 之差不是2。
+
+**代码示例**
+
+..  code-block:: python
+
+    import numpy as np
+    import paddle
+    import paddle.nn as nn
+    x = np.random.uniform(-1, 1, (2, 4, 8, 8, 8)).astype('float32')
+    
+    paddle.disable_static()
+    x_var = paddle.to_tensor(x)
+    conv = nn.ConvTranspose3d(4, 6, (3, 3, 3))
+    y_var = conv(x_var)
+    y_np = y_var.numpy()
+    print(y_np.shape)
+    
+    # (2, 6, 10, 10, 10)

doc/fluid/api_cn/nn_cn/Dropout_cn.rst

-.. _cn_api_nn_Dropout:
-
-Dropout
--------------------------------
-
-.. py:function:: paddle.nn.Dropout(p=0.5, axis=None, mode="upscale_in_train”, name=None)
-
-Dropout是一种正则化手段，该算子根据给定的丢弃概率 `p` ，在训练过程中随机将一些神经元输出设置为0，通过阻止神经元节点间的相关性来减少过拟合。论文请参考: `Improving neural networks by preventing co-adaptation of feature detectors <https://arxiv.org/abs/1207.0580>`_ 
-
-在动态图模式下，请使用模型的 `eval()` 方法切换至测试阶段。
-
-.. note::
-   对应的 `functional方法` 请参考: :ref:`cn_api_nn_functional_dropout` 。
-
-参数
-:::::::::
- - **p** (float): 将输入节点置为0的概率， 即丢弃概率。默认: 0.5。
- - **axis** (int|list): 指定对输入 `Tensor` 进行Dropout操作的轴。默认: None。
- - **mode** (str): 丢弃单元的方式，有两种'upscale_in_train'和'downscale_in_infer'，默认: 'upscale_in_train'。计算方法如下:
-
-    1. upscale_in_train, 在训练时增大输出结果。
-
-       - train: out = input * mask / ( 1.0 - p )
-       - inference: out = input
-
-    2. downscale_in_infer, 在预测时减小输出结果
-
-       - train: out = input * mask
-       - inference: out = input * (1.0 - p)
-
- - **name** (str，可选): 操作的名称(可选，默认值为None）。更多信息请参见 :ref:`api_guide_Name` 。
-
-形状
-:::::::::
- - **输入** : N-D `Tensor` 。
- - **输出** : N-D `Tensor` ，形状与输入相同。
-
-代码示例
-:::::::::
-
-.. code-block:: python
-
-    import paddle
-    import numpy as np
-
-    paddle.disable_static()
-    x = np.array([[1,2,3], [4,5,6]]).astype('float32')
-    x = paddle.to_tensor(x)
-    m = paddle.nn.Dropout(p=0.5)
-    y_train = m(x)
-    m.eval()  # switch the model to test phase
-    y_test = m(x)
-    print(x.numpy())
-    print(y_train.numpy())
-    print(y_test.numpy())

doc/fluid/api_cn/nn_cn/MaxPool1d_cn.rst

@@ -52,7 +52,7 @@ MaxPool1d
         import numpy as np
         paddle.disable_static()
         
-        data = paddle.to_variable(np.random.uniform(-1, 1, [1, 3, 32]).astype(np.float32))
+        data = paddle.to_tensor(np.random.uniform(-1, 1, [1, 3, 32]).astype(np.float32))
         MaxPool1d = nn.layer.MaxPool1d(kernel_size=2, stride=2, padding=0)
         pool_out = MaxPool1d(data)
         # pool_out shape: [1, 3, 16]

doc/fluid/api_cn/nn_cn/PairwiseDistance_cn.rst

@@ -30,12 +30,9 @@ PairwiseDistance
 ..  code-block:: python
 
             import paddle
-            import numpy as np
             paddle.disable_static()
-            x_np = np.array([[1., 3.], [3., 5.]]).astype(np.float64)
-            y_np = np.array([[5., 6.], [7., 8.]]).astype(np.float64)
-            x = paddle.to_variable(x_np)
-            y = paddle.to_variable(y_np)
+            x = paddle.to_tensor([[1., 3.], [3., 5.]], dtype='float64')
+            y = paddle.to_tensor([[5., 6.], [7., 8.]], dtype='float64')
             dist = paddle.nn.PairwiseDistance()
             distance = dist(x, y)
             print(distance.numpy()) # [5. 5.]

doc/fluid/api_cn/nn_cn/SyncBatchNorm_cn.rst

@@ -62,3 +62,27 @@ SyncBatchNorm
         print(hidden1.numpy())
         # [[[[0.26824948, 1.0936325],[0.26824948, -1.6301316]],[[ 0.8095662, -0.665287],[-1.2744656, 1.1301866 ]]]]
 
+
+方法
+:::::::::
+convert_sync_batchnorm(layer)
+'''''''''''''''''''''''''''''
+
+该接口用于把 ``BatchNorm*d`` 层转换为 ``SyncBatchNorm`` 层。
+
+参数：
+    - **layer** (paddle.nn.Layer) - 包含一个或多个 ``BatchNorm*d`` 层的模型。
+
+返回：
+    如果原始模型中有 ``BatchNorm*d`` 层， 则把 ``BatchNorm*d`` 层转换为 ``SyncBatchNorm`` 层的原始模型。
+
+**代码示例**
+
+.. code-block:: python
+
+    import paddle
+    import paddle.nn as nn
+    paddle.disable_static()
+    model = nn.Sequential(nn.Conv2d(3, 5, 3), nn.BatchNorm2d(5))
+    sync_model = nn.SyncBatchNorm.convert_sync_batchnorm(model)
+

doc/fluid/api_cn/nn_cn/activation_cn/Hardshrink_cn.rst

@@ -38,6 +38,6 @@ Hardshrink激活层
 
     paddle.disable_static()
 
-    x = paddle.to_variable(np.array([-1, 0.3, 2.5]))
+    x = paddle.to_tensor([-1, 0.3, 2.5])
     m = paddle.nn.Hardshrink()
     out = m(x) # [-1., 0., 2.5]

doc/fluid/api_cn/nn_cn/conv2d_transpose_cn.rst

-.. _cn_api_nn_cn_conv2d_transpose:
-
-conv2d_transpose
--------------------------------
-:doc_source: paddle.fluid.layers.conv2d_transpose
-
-

doc/fluid/api_cn/nn_cn/conv3d_cn.rst

-.. _cn_api_nn_cn_conv3d:
-
-conv3d
--------------------------------
-:doc_source: paddle.fluid.layers.conv3d
-
-

doc/fluid/api_cn/nn_cn/conv3d_transpose_cn.rst

-.. _cn_api_nn_cn_conv3d_transpose:
-
-conv3d_transpose
--------------------------------
-:doc_source: paddle.fluid.layers.conv3d_transpose
-
-

doc/fluid/api_cn/nn_cn/dropout_cn.rst

-.. _cn_api_nn_cn_dropout:
-
-dropout
--------------------------------
-:doc_source: paddle.fluid.layers.dropout
-
-

doc/fluid/api_cn/nn_cn/functional_cn.rst

@@ -28,6 +28,11 @@ functional
     functional_cn/mse_loss_cn.rst
     functional_cn/adaptive_avg_pool2d_cn.rst
     functional_cn/adaptive_avg_pool3d_cn.rst
+    functional_cn/kl_div_cn.rst
+    functional_cn/conv2d_cn.rst
+    functional_cn/conv3d_cn.rst
+    functional_cn/conv_transpose2d_cn.rst
+    functional_cn/conv_transpose3d_cn.rst
     functional_cn/sigmoid_cn.rst
     functional_cn/adaptive_avg_pool1d_cn.rst
     functional_cn/adaptive_max_pool1d_cn.rst

doc/fluid/api_cn/nn_cn/Conv2D_cn.rst → doc/fluid/api_cn/nn_cn/functional_cn/conv2d_cn.rst

-Conv2D
+conv2d
 -------------------------------
 
-.. py:class:: paddle.nn.Conv2d(num_channels, num_filters, filter_size, padding=0, stride=1, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None, data_format="NCHW", dtype="float32")
+.. py:function:: paddle.nn.functional.conv2d(x, weight, bias=None, stride=1, padding=0, dilation=1, groups=1, data_format="NCHW", name=None)
 
-:alias_main: paddle.nn.Conv2D
-:alias: paddle.nn.Conv2D,paddle.nn.layer.Conv2D,paddle.nn.layer.conv.Conv2D
-
-
-
-**二维卷积层**
-
-该OP是二维卷积层（convolution2D layer），根据输入、滤波器、步长（stride）、填充（padding）、膨胀比例（dilations）一组参数计算输出特征层大小。输入和输出是NCHW或NHWC格式，其中N是批尺寸，C是通道数，H是特征高度，W是特征宽度。滤波器是MCHW格式，M是输出图像通道数，C是输入图像通道数，H是滤波器高度，W是滤波器宽度。如果组数(groups)大于1，C等于输入图像通道数除以组数的结果。详情请参考UFLDL's : `卷积 <http://ufldl.stanford.edu/tutorial/supervised/FeatureExtractionUsingConvolution/>`_ 。如果bias_attr不为False，卷积计算会添加偏置项。如果指定了激活函数类型，相应的激活函数会作用在最终结果上。
+该OP是二维卷积层（convolution2d layer），根据输入、卷积核、步长（stride）、填充（padding）、空洞大小（dilations）一组参数计算输出特征层大小。输入和输出是NCHW或NHWC格式，其中N是批尺寸，C是通道数，H是特征高度，W是特征宽度。卷积核是MCHW格式，M是输出图像通道数，C是输入图像通道数，H是卷积核高度，W是卷积核宽度。如果组数(groups)大于1，C等于输入图像通道数除以组数的结果。详情请参考UFLDL's : `卷积 <http://ufldl.stanford.edu/tutorial/supervised/FeatureExtractionUsingConvolution/>`_ 。如果bias_attr不为False，卷积计算会添加偏置项。如果指定了激活函数类型，相应的激活函数会作用在最终结果上。
 
 对每个输入X，有等式：
 
@@ -20,7 +13,7 @@ Conv2D
 
 其中：
     - :math:`X` ：输入值，NCHW或NHWC格式的4-D Tensor
-    - :math:`W` ：滤波器值，MCHW格式的4-D Tensor
+    - :math:`W` ：卷积核值，MCHW格式的4-D Tensor
     - :math:`*` ：卷积操作
     - :math:`b` ：偏置值，2-D Tensor，形状为 ``[M,1]``
     - :math:`\sigma` ：激活函数
@@ -32,7 +25,7 @@ Conv2D
 
   输入形状：:math:`（N,C_{in},H_{in},W_{in}）`
 
-  滤波器形状： :math:`（C_{out},C_{in},H_{f},W_{f}）`
+  卷积核形状： :math:`（C_{out},C_{in},H_{f},W_{f}）`
 
 - 输出：
 
@@ -61,41 +54,31 @@ Conv2D
 
     W_{out} = \frac{\left ( W_{in} -\left ( dilation[1]*\left ( W_{f}-1 \right )+1 \right ) \right )}{stride[1]}+1
 
+
 参数：
-    - **num_channels** (int) - 输入图像的通道数。
-    - **num_filters** (int) - 滤波器（卷积核）的个数。和输出图像通道相同。
-    - **filter_size** (int|list|tuple) - 滤波器大小。如果它是一个列表或元组，则必须包含两个整数值：（filter_size_height，filter_size_width）。若为一个整数，filter_size_height = filter_size_width = filter_size。
+    - **x** (Tensor) - 输入是形状为 :math:`[N, C, H, W]` 或 :math:`[N, H, W, C]` 的4-D Tensor，N是批尺寸，C是通道数，H是特征高度，W是特征宽度，数据类型为float16, float32或float64。
+    - **weight** (Tensor)) - 形状为 :math:`[M, C/g, kH, kW]` 的卷积核。 M是输出通道数， g是分组的个数，kH是卷积核的高度，kW是卷积核的宽度。
+    - **bias** (int|list|tuple) - 偏置项，形状为： :math:`[M,]` 。
+    - **stride** (int|list|tuple，可选) - 步长大小。卷积核和输入进行卷积计算时滑动的步长。如果它是一个列表或元组，则必须包含两个整型数：（stride_height,stride_width）。若为一个整数，stride_height = stride_width = stride。默认值：1。
     - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有3种格式：(1)包含4个二元组：当 ``data_format`` 为"NCHW"时为 [[0,0], [0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NHWC"时为[[0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含4个整数值：[padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含2个整数值：[padding_height, padding_width]，此时padding_height_top = padding_height_bottom = padding_height， padding_width_left = padding_width_right = padding_width。若为一个整数，padding_height = padding_width = padding。默认值：0。
-    - **stride** (int|list|tuple，可选) - 步长大小。滤波器和输入进行卷积计算时滑动的步长。如果它是一个列表或元组，则必须包含两个整型数：（stride_height,stride_width）。若为一个整数，stride_height = stride_width = stride。默认值：1。
-    - **dilation** (int|list|tuple，可选) - 膨胀比例大小。空洞卷积时会使用该参数，滤波器对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。如果膨胀比例为列表或元组，则必须包含两个整型数：（dilation_height,dilation_width）。若为一个整数，dilation_height = dilation_width = dilation。默认值：1。
-    - **groups** (int，可选) - 二维卷积层的组数。根据Alex Krizhevsky的深度卷积神经网络（CNN）论文中的成组卷积：当group=n，输入和滤波器分别根据通道数量平均分为n组，第一组滤波器和第一组输入进行卷积计算，第二组滤波器和第二组输入进行卷积计算，……，第n组滤波器和第n组输入进行卷积计算。默认值：1。
-    - **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+    - **dilation** (int|list|tuple，可选) - 空洞大小。空洞卷积时会使用该参数，卷积核对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。如果空洞大小为列表或元组，则必须包含两个整型数：（dilation_height,dilation_width）。若为一个整数，dilation_height = dilation_width = dilation。默认值：1。
+    - **groups** (int，可选) - 二维卷积层的组数。根据Alex Krizhevsky的深度卷积神经网络（CNN）论文中的成组卷积：当group=n，输入和卷积核分别根据通道数量平均分为n组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第n组卷积核和第n组输入进行卷积计算。默认值：1。
+    - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
     - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若 ``bias_attr`` 为bool类型，只支持为False，表示没有偏置参数。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
-    - **use_cudnn** （bool，可选）- 是否使用cudnn内核。只有已安装cudnn库时才有效。默认值：True。
-    - **act** (str，可选) - 激活函数类型， 如tanh、softmax、sigmoid，relu等，支持列表请参考 :ref:`api_guide_activations` 。如果设为None，则未添加激活函数。默认值：None。
-    - **name** (str，可选) – 具体用法请参见 :ref:`cn_api_guide_Name` ，一般无需设置，默认值：None。
     - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCHW"和"NHWC"。N是批尺寸，C是通道数，H是特征高度，W是特征宽度。默认值："NCHW"。
-    - **dtype** (str, 可选) – 权重的数据类型，可以为float32或float64。默认为float32。
-
+    - **name** (str，可选) – 具体用法请参见 :ref:`cn_api_guide_Name` ，一般无需设置，默认值：None。
 
-属性
-::::::::::::
-.. py:attribute:: weight
-本层的可学习参数，类型为 ``Parameter``
+返回：4-D Tensor，数据类型与 ``x`` 一致。返回卷积的结果。
 
-.. py:attribute:: bias
-本层的可学习偏置，类型为 ``Parameter``
-    
-返回: 无。
+返回类型：Tensor。
 
 抛出异常：
-    - ``ValueError`` - 如果 ``use_cudnn`` 不是bool值。
     - ``ValueError`` - 如果 ``data_format`` 既不是"NCHW"也不是"NHWC"。
     - ``ValueError`` - 如果 ``input`` 的通道数未被明确定义。
     - ``ValueError`` - 如果 ``padding`` 是字符串，既不是"SAME"也不是"VALID"。
     - ``ValueError`` - 如果 ``padding`` 含有4个二元组，与批尺寸对应维度的值不为0或者与通道对应维度的值不为0。
     - ``ShapeError`` - 如果输入不是4-D Tensor。
-    - ``ShapeError`` - 如果输入和滤波器的维度大小不相同。
+    - ``ShapeError`` - 如果输入和卷积核的维度大小不相同。
     - ``ShapeError`` - 如果输入的维度大小与 ``stride`` 之差不是2。
     - ``ShapeError`` - 如果输出的通道数不能被 ``groups`` 整除。
 
@@ -104,17 +87,20 @@ Conv2D
 
 .. code-block:: python
 
-   import numpy as np
-   from paddle import fluid
-   import paddle.fluid.dygraph as dg
-   from paddle import nn
-   x = np.random.uniform(-1, 1, (2, 4, 8, 8)).astype('float32')
-   place = fluid.CPUPlace()
-   with dg.guard(place):
-       x_var = dg.to_variable(x)
-       conv = nn.Conv2D(4, 6, (3, 3))
-       y_var = conv(x_var)
-       y_np = y_var.numpy()
-       print(y_np.shape)
-
-    # (2, 6, 6, 6)
+    import paddle
+    import paddle.nn.functional as F
+    import numpy as np
+
+    x = np.random.randn(2, 3, 8, 8).astype(np.float32)
+    w = np.random.randn(6, 3, 3, 3).astype(np.float32)
+
+    paddle.disable_static()
+
+    x_var = paddle.to_tensor(x)
+    w_var = paddle.to_tensor(w)
+    y_var = F.conv2d(x_var, w_var)
+    y_np = y_var.numpy()
+
+    print(y_np.shape)
+
+    # (2, 6, 6, 6)
\ No newline at end of file

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

+conv3d
+-------------------------------
+
+.. py:function:: paddle.nn.functional.conv3d(x, weight, bias=None, stride=1, padding=0, dilation=1, groups=1, data_format="NCHW", name=None)
+
+该OP是三维卷积层（convolution3D layer），根据输入、卷积核、步长（stride）、填充（padding）、空洞大小（dilations）一组参数计算得到输出特征层大小。输入和输出是NCDHW或NDWHC格式，其中N是批尺寸，C是通道数，D是特征层深度，H是特征层高度，W是特征层宽度。三维卷积（Convlution3D）和二维卷积（Convlution2D）相似，但多了一维深度信息（depth）。如果bias_attr不为False，卷积计算会添加偏置项。
+
+对每个输入X，有等式：
+
+.. math::
+
+    Out = \sigma \left ( W * X + b \right )
+
+其中：
+    - :math:`X` ：输入值，NCDHW或NDHWC格式的5-D Tensor
+    - :math:`W` ：卷积核值，MCDHW格式的5-D Tensor
+    - :math:`*` ：卷积操作
+    - :math:`b` ：偏置值，2-D Tensor，形为 ``[M,1]``
+    - :math:`\sigma` ：激活函数
+    - :math:`Out` ：输出值, NCDHW或NDHWC格式的5-D Tensor，和 ``X`` 的形状可能不同
+
+**示例**
+
+- 输入：
+
+  输入形状： :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`
+
+  卷积核形状： :math:`(C_{out}, C_{in}, D_f, H_f, W_f)`
+
+- 输出：
+
+  输出形状： :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`
+
+参数：
+    - **x** (Tensor) - 输入是形状为 :math:`[N, C, H, W]` 或 :math:`[N, H, W, C]` 的4-D Tensor，N是批尺寸，C是通道数，H是特征高度，W是特征宽度，数据类型为float16, float32或float64。
+    - **weight** (Tensor) - 形状为 :math:`[M, C/g, kH, kW]` 的卷积核（卷积核）。 M是输出通道数， g是分组的个数，kH是卷积核的高度，kW是卷积核的宽度。
+    - **bias** (int|list|tuple) - 偏置项，形状为： :math:`[M,]` 。
+    - **stride** (int|list|tuple，可选) - 步长大小。卷积核和输入进行卷积计算时滑动的步长。如果它是一个列表或元组，则必须包含两个整型数：（stride_height,stride_width）。若为一个整数，stride_height = stride_width = stride。默认值：1。
+    - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有3种格式：(1)包含5个二元组：当 ``data_format`` 为"NCDHW"时为 [[0,0], [0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NDHWC"时为[[0,0], [padding_depth_front, padding_depth_back], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含6个整数值：[padding_depth_front, padding_depth_back, padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含3个整数值：[padding_depth, padding_height, padding_width]，此时 padding_depth_front = padding_depth_back = padding_depth, padding_height_top = padding_height_bottom = padding_height, padding_width_left = padding_width_right = padding_width。若为一个整数，padding_depth = padding_height = padding_width = padding。默认值：0。
+    - **dilation** (int|list|tuple，可选) - 空洞大小。空洞卷积时会使用该参数，卷积核对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。如果空洞大小为列表或元组，则必须包含两个整型数：（dilation_height,dilation_width）。若为一个整数，dilation_height = dilation_width = dilation。默认值：1。
+    - **groups** (int，可选) - 二维卷积层的组数。根据Alex Krizhevsky的深度卷积神经网络（CNN）论文中的成组卷积：当group=n，输入和卷积核分别根据通道数量平均分为n组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第n组卷积核和第n组输入进行卷积计算。默认值：1。
+    - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+    - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若 ``bias_attr`` 为bool类型，只支持为False，表示没有偏置参数。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+    - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCHW"和"NHWC"。N是批尺寸，C是通道数，H是特征高度，W是特征宽度。默认值："NCHW"。
+    - **name** (str，可选) – 具体用法请参见 :ref:`cn_api_guide_Name` ，一般无需设置，默认值：None。
+
+返回：5-D Tensor，数据类型与 ``input`` 一致。返回卷积计算的结果。
+
+返回类型：Tensor。
+
+抛出异常：
+    - ``ValueError`` - 如果 ``use_cudnn`` 不是bool值。
+    - ``ValueError`` - 如果 ``data_format`` 既不是"NCDHW"也不是"NDHWC"。
+    - ``ValueError`` - 如果 ``input`` 的通道数未被明确定义。
+    - ``ValueError`` - 如果 ``padding`` 是字符串，既不是"SAME"也不是"VALID"。
+    - ``ValueError`` - 如果 ``padding`` 含有5个二元组，与批尺寸对应维度的值不为0或者与通道对应维度的值不为0。
+    - ``ShapeError`` - 如果输入不是5-D Tensor。
+    - ``ShapeError`` - 如果输入和卷积核的维度大小不相同。
+    - ``ShapeError`` - 如果输入的维度大小与 ``stride`` 之差不是2。
+    - ``ShapeError`` - 如果输出的通道数不能被 ``groups`` 整除。
+
+
+**代码示例**：
+
+.. code-block:: python
+
+    import numpy as np
+    import paddle
+    import paddle.nn.functional as F
+
+    x = np.random.randn(2, 3, 8, 8, 8).astype(np.float32)
+    w = np.random.randn(6, 3, 3, 3, 3).astype(np.float32)
+
+    paddle.disable_static()
+    
+    x_var = paddle.to_tensor(x)
+    w_var = paddle.to_tensor(w)
+    y_var = F.conv3d(x_var, w_var)
+    
+    y_np = y_var.numpy()
+    print(y_np.shape)
+
+    # (2, 6, 6, 6, 6)
\ No newline at end of file

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

+
+conv_transpose2d
+-------------------------------
+
+
+.. py:function:: paddle.nn.functional.conv_transpose2d(x, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1, data_format='NCHW', output_size=None, name=None)
+
+
+
+二维转置卷积层（Convlution2D transpose layer）
+
+该层根据输入（input）、卷积核（kernel）和空洞大小（dilations）、步长（stride）、填充（padding）来计算输出特征层大小或者通过output_size指定输出特征层大小。输入(Input)和输出(Output)为NCHW或NHWC格式，其中N为批尺寸，C为通道数（channel），H为特征层高度，W为特征层宽度。卷积核是MCHW格式，M是输出图像通道数，C是输入图像通道数，H是卷积核高度，W是卷积核宽度。如果组数大于1，C等于输入图像通道数除以组数的结果。转置卷积的计算过程相当于卷积的反向计算。转置卷积又被称为反卷积（但其实并不是真正的反卷积）。欲了解转置卷积层细节，请参考下面的说明和 参考文献_ 。如果参数bias_attr不为False, 转置卷积计算会添加偏置项。如果act不为None，则转置卷积计算之后添加相应的激活函数。
+
+.. _参考文献: https://arxiv.org/pdf/1603.07285.pdf
+
+
+输入 :math:`X` 和输出 :math:`Out` 函数关系如下：
+
+.. math::
+                        Out=\sigma (W*X+b)\\
+
+其中：
+    -  :math:`X` : 输入，具有NCHW或NHWC格式的4-D Tensor
+    -  :math:`W` : 卷积核，具有NCHW格式的4-D Tensor
+    -  :math:`*` : 卷积计算（注意：转置卷积本质上的计算还是卷积）
+    -  :math:`b` : 偏置（bias），2-D Tensor，形状为 ``[M,1]``
+    -  :math:`σ` : 激活函数
+    -  :math:`Out` : 输出值，NCHW或NHWC格式的4-D Tensor， 和 ``X`` 的形状可能不同
+
+**示例**
+
+- 输入：
+
+    输入Tensor的形状： :math:`（N，C_{in}， H_{in}， W_{in}）`
+
+    卷积核的形状 ： :math:`（C_{in}, C_{out}, H_f, W_f）`
+
+- 输出：
+
+    输出Tensor的形状 ： :math:`（N，C_{out}, H_{out}, W_{out}）`
+
+其中
+
+.. math::
+
+        & H'_{out} = (H_{in}-1)*strides[0] - pad\_height\_top - pad\_height\_bottom + dilations[0]*(H_f-1)+1\\
+        & W'_{out} = (W_{in}-1)*strides[1]- pad\_width\_left - pad\_width\_right + dilations[1]*(W_f-1)+1 \\
+        & H_{out}\in[H'_{out},H'_{out} + strides[0])\\
+        & W_{out}\in[W'_{out},W'_{out} + strides[1])\\
+
+如果 ``padding`` = "SAME":
+
+.. math::
+   & H'_{out} = \frac{(H_{in} + stride[0] - 1)}{stride[0]}\\
+   & W'_{out} = \frac{(W_{in} + stride[1] - 1)}{stride[1]}\\
+
+如果 ``padding`` = "VALID":
+
+.. math::
+    & H'_{out} = (H_{in}-1)*strides[0] + dilations[0]*(H_f-1)+1\\
+    & W'_{out} = (W_{in}-1)*strides[1] + dilations[1]*(W_f-1)+1 \\
+
+注意：
+
+如果output_size为None，则 :math:`H_{out}` = :math:`H^\prime_{out}` , :math:`W_{out}` = :math:`W^\prime_{out}` ;否则，指定的output_size_height（输出特征层的高） :math:`H_{out}` 应当介于 :math:`H^\prime_{out}` 和 :math:`H^\prime_{out} + strides[0]` 之间（不包含 :math:`H^\prime_{out} + strides[0]` ）, 并且指定的output_size_width（输出特征层的宽） :math:`W_{out}` 应当介于 :math:`W^\prime_{out}` 和 :math:`W^\prime_{out} + strides[1]` 之间（不包含 :math:`W^\prime_{out} + strides[1]` ）。
+
+由于转置卷积可以当成是卷积的反向计算，而根据卷积的输入输出计算公式来说，不同大小的输入特征层可能对应着相同大小的输出特征层，所以对应到转置卷积来说，固定大小的输入特征层对应的输出特征层大小并不唯一。
+
+如果指定了output_size， ``conv2d_transpose`` 可以自动计算卷积核的大小。
+
+参数:
+  - **x** (Tensor) - 输入是形状为 :math:`[N, C, H, W]` 或 :math:`[N, H, W, C]` 的4-D Tensor，N是批尺寸，C是通道数，H是特征高度，W是特征宽度，数据类型为float16, float32或float64。
+  - **weight** (Tensor) - 形状为 :math:`[C, M/g, kH, kW]` 的卷积核（卷积核）。 M是输出通道数， g是分组的个数，kH是卷积核的高度，kW是卷积核的宽度。
+  - **bias** (int|list|tuple) - 偏置项，形状为： :math:`[M,]` 。
+  - **stride** (int|list|tuple，可选) - 步长大小。如果 ``stride`` 为元组，则必须包含两个整型数，分别表示垂直和水平滑动步长。否则，表示垂直和水平滑动步长均为 ``stride`` 。默认值：1。
+  - **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有3种格式：(1)包含4个二元组：当 ``data_format`` 为"NCHW"时为 [[0,0], [0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NHWC"时为[[0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含4个整数值：[padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含2个整数值：[padding_height, padding_width]，此时padding_height_top = padding_height_bottom = padding_height， padding_width_left = padding_width_right = padding_width。若为一个整数，padding_height = padding_width = padding。默认值：0。
+  - **output_padding** (int|list|tuple, optional): 输出形状上一侧额外添加的大小. 默认值: 0.
+  - **dilation** (int|list|tuple，可选) - 空洞大小。空洞卷积时会使用该参数，卷积核对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。如果空洞大小为列表或元组，则必须包含两个整型数：（dilation_height,dilation_width）。若为一个整数，dilation_height = dilation_width = dilation。默认值：1。
+  - **groups** (int，可选) - 二维卷积层的组数。根据Alex Krizhevsky的深度卷积神经网络（CNN）论文中的成组卷积：当group=n，输入和卷积核分别根据通道数量平均分为n组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算，……，第n组卷积核和第n组输入进行卷积计算。默认值：1。
+  - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+  - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若 ``bias_attr`` 为bool类型，只支持为False，表示没有偏置参数。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+  - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCHW"和"NHWC"。N是批尺寸，C是通道数，H是特征高度，W是特征宽度。默认值："NCHW"。
+  - **name** (str，可选) – 具体用法请参见 :ref:`cn_api_guide_Name` ，一般无需设置，默认值：None。
+
+
+返回：4-D Tensor，数据类型与 ``input`` 一致。如果未指定激活层，则返回转置卷积计算的结果，如果指定激活层，则返回转置卷积和激活计算之后的最终结果。
+
+返回类型：Variable
+
+抛出异常:
+    -  ``ValueError`` : 如果输入的shape、kernel_size、stride、padding和groups不匹配，抛出ValueError
+    -  ``ValueError`` - 如果 ``data_format`` 既不是"NCHW"也不是"NHWC"。
+    -  ``ValueError`` - 如果 ``padding`` 是字符串，既不是"SAME"也不是"VALID"。
+    -  ``ValueError`` - 如果 ``padding`` 含有4个二元组，与批尺寸对应维度的值不为0或者与通道对应维度的值不为0。
+    -  ``ValueError`` - 如果 ``output_size`` 和 ``filter_size`` 同时为None。
+    -  ``ShapeError`` - 如果输入不是4-D Tensor。
+    -  ``ShapeError`` - 如果输入和卷积核的维度大小不相同。
+    -  ``ShapeError`` - 如果输入的维度大小与 ``stride`` 之差不是2。
+
+**代码示例**
+
+..  code-block:: python
+
+    import numpy as np
+    import paddle
+    import paddle.nn.functional as F
+
+    x = np.random.randn(2, 3, 8, 8).astype(np.float32)
+    w = np.random.randn(3, 6, 3, 3).astype(np.float32)
+
+    paddle.disable_static()
+    x_var = paddle.to_tensor(x)
+    w_var = paddle.to_tensor(w)
+    y_var = F.conv_transpose2d(x_var, w_var)
+    y_np = y_var.numpy()
+    print(y_np.shape)
+
+    # (2, 6, 10, 10)
+
+

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

+conv_transpose3d
+-------------------------------
+
+
+.. py:function:: paddle.nn.functional.conv_transpose3d(x, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1, data_format='NCHW', output_size=None, name=None)
+
+
+
+
+三维转置卷积层（Convlution3d transpose layer)
+
+该层根据输入（input）、卷积核（kernel）和卷积核空洞大小（dilations）、步长（stride）、填充（padding）来计算输出特征层大小或者通过output_size指定输出特征层大小。输入(Input)和输出(Output)为NCDHW或者NDHWC格式。其中N为批尺寸，C为通道数（channel），D为特征深度，H为特征层高度，W为特征层宽度。转置卷积的计算过程相当于卷积的反向计算。转置卷积又被称为反卷积（但其实并不是真正的反卷积）。欲了解卷积转置层细节，请参考下面的说明和 参考文献_ 。如果参数bias_attr不为False, 转置卷积计算会添加偏置项。
+
+.. _参考文献: http://www.matthewzeiler.com/wp-content/uploads/2017/07/cvpr2010.pdf
+
+输入 :math:`X` 和输出 :math:`Out` 函数关系如下：
+
+.. math::
+                        \\Out=\sigma (W*X+b)\\
+
+其中：
+    -  :math:`X` : 输入，具有NCDHW或NDHWC格式的5-D Tensor
+    -  :math:`W` : 卷积核，具有NCDHW格式的5-D Tensor
+    -  :math:`*` : 卷积操作（注意：转置卷积本质上的计算还是卷积）
+    -  :math:`b` : 偏置（bias），2-D Tensor，形状为 ``[M,1]``
+    -  :math:`σ` : 激活函数
+    -  :math:`Out` : 输出值，NCDHW或NDHWC格式的5-D Tensor，和 ``X`` 的形状可能不同
+
+**示例**
+
+输入:
+
+    输入的shape：:math:`（N,C_{in}, D_{in}, H_{in}, W_{in}）`
+
+    卷积核的shape：:math:`（C_{in}, C_{out}, D_f, H_f, W_f）`
+
+输出:
+
+    输出的shape：:math:`（N,C_{out}, D_{out}, H_{out}, W_{out}）`
+
+
+其中：
+
+.. math::
+
+    & D'_{out}=(D_{in}-1)*strides[0] - pad\_depth\_front - pad\_depth\_back + dilations[0]*(D_f-1)+1\\
+    & H'_{out}=(H_{in}-1)*strides[1] - pad\_height\_top - pad\_height\_bottom + dilations[1]*(H_f-1)+1\\
+    & W'_{out}=(W_{in}-1)*strides[2] - pad\_width\_left - pad\_width\_right + dilations[2]*(W_f-1)+1\\
+    & D_{out}\in[D'_{out},D'_{out} + strides[0])\\
+    & H_{out}\in[H'_{out},H'_{out} + strides[1])\\
+    & W_{out}\in[W'_{out},W'_{out} + strides[2])\\
+
+如果 ``padding`` = "SAME":
+
+.. math::
+    D'_{out} = \frac{(D_{in} + stride[0] - 1)}{stride[0]}\\
+    H'_{out} = \frac{(H_{in} + stride[1] - 1)}{stride[1]}\\
+    W'_{out} = \frac{(W_{in} + stride[2] - 1)}{stride[2]}\\
+
+如果 ``padding`` = "VALID":
+
+.. math::
+    D'_{out}=(D_{in}-1)*strides[0] + dilations[0]*(D_f-1)+1\\
+    H'_{out}=(H_{in}-1)*strides[1] + dilations[1]*(H_f-1)+1\\
+    W'_{out}=(W_{in}-1)*strides[2] + dilations[2]*(W_f-1)+1\\
+
+注意：
+
+如果output_size为None，则 :math:`D_{out}` = :math:`D^\prime_{out}` , :math:`H_{out}` = :math:`H^\prime_{out}` , :math:`W_{out}` = :math:`W^\prime_{out}` ;否则，指定的output_size_depth（输出特征层的深度） :math:`D_{out}` 应当介于 :math:`D^\prime_{out}` 和 :math:`D^\prime_{out} + strides[0]` 之间（不包含 :math:`D^\prime_{out} + strides[0]` ），指定的output_size_height（输出特征层的高） :math:`H_{out}` 应当介于 :math:`H^\prime_{out}` 和 :math:`H^\prime_{out} + strides[1]` 之间（不包含 :math:`H^\prime_{out} + strides[1]` ）, 并且指定的output_size_width（输出特征层的宽） :math:`W_{out}` 应当介于 :math:`W^\prime_{out}` 和 :math:`W^\prime_{out} + strides[2]` 之间（不包含 :math:`W^\prime_{out} + strides[2]` ）。
+
+由于转置卷积可以当成是卷积的反向计算，而根据卷积的输入输出计算公式来说，不同大小的输入特征层可能对应着相同大小的输出特征层，所以对应到转置卷积来说，固定大小的输入特征层对应的输出特征层大小并不唯一。
+
+如果指定了output_size， ``conv_transpose3d`` 可以自动计算卷积核的大小。
+
+参数:
+  - **x** (Tensor) - 形状为 :math:`[N, C, D, H, W]` 或 :math:`[N, D, H, W, C]` 的5-D Tensor，N是批尺寸，C是通道数，D是特征深度，H是特征高度，W是特征宽度，数据类型：float32或float64。
+  - **weight** (Tensor) - 形状为 :math:`[C, M/g, kD, kH, kW]` 的卷积核。 M是输出通道数， g是分组的个数，kD是卷积核的深度，kH是卷积核的高度，kW是卷积核的宽度。
+  - **bias** (int|list|tuple) - 偏置项，形状为： :math:`[M,]` 。
+  - **stride** (int|list|tuple，可选) - 步长大小。如果 ``stride`` 为元组或列表，则必须包含三个整型数，分别表示深度，垂直和水平滑动步长。否则，表示深度，垂直和水平滑动步长均为 ``stride`` 。默认值：1。
+  - **padding** (int|list|tuple|str，可选) - 填充padding大小。padding参数在输入特征层每边添加 ``dilation * (kernel_size - 1) - padding`` 个0。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或  ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有3种格式：(1)包含5个二元组：当 ``data_format`` 为"NCDHW"时为 [[0,0], [0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right]]，当 ``data_format`` 为"NDHWC"时为[[0,0], [pad_depth_front, pad_depth_back], [pad_height_top, pad_height_bottom], [pad_width_left, pad_width_right], [0,0]]；(2)包含6个整数值：[pad_depth_front, pad_depth_back, pad_height_top, pad_height_bottom, pad_width_left, pad_width_right]；(3)包含3个整数值：[pad_depth, pad_height, pad_width]，此时 pad_depth_front = pad_depth_back = pad_depth, pad_height_top = pad_height_bottom = pad_height, pad_width_left = pad_width_right = pad_width。若为一个整数，pad_depth = pad_height = pad_width = padding。默认值：0。
+  - **output_padding** (int|list|tuple, optional): 输出形状上一侧额外添加的大小. 默认值: 0.
+  - **dilation** (int|list|tuple，可选) - 空洞大小。空洞卷积时会使用该参数，卷积核对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。如果空洞大小为列表或元组，则必须包含两个整型数：（dilation_height,dilation_width）。若为一个整数，dilation_height = dilation_width = dilation。默认值：1。
+  - **groups** (int，可选) - 三维转置卷积层的组数。从Alex Krizhevsky的CNN Deep论文中的群卷积中受到启发，当group=2时，输入和卷积核分别根据通道数量平均分为两组，第一组卷积核和第一组输入进行卷积计算，第二组卷积核和第二组输入进行卷积计算。默认：group = 1。
+  - **weight_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+  - **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若 ``bias_attr`` 为bool类型，只支持为False，表示没有偏置参数。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
+  - **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCHW"和"NHWC"。N是批尺寸，C是通道数，H是特征高度，W是特征宽度。默认值："NCHW"。
+  - **name** (str，可选) – 具体用法请参见 :ref:`cn_api_guide_Name` ，一般无需设置，默认值：None。
+
+  
+返回：5-D Tensor，数据类型与 ``input`` 一致。如果未指定激活层，则返回转置卷积计算的结果，如果指定激活层，则返回转置卷积和激活计算之后的最终结果。
+
+返回类型：Tensor
+
+抛出异常:
+    - ``ValueError`` - 如果输入的shape、kernel_size、stride、padding和groups不匹配。
+    - ``ValueError`` - 如果 ``data_format`` 既不是"NCDHW"也不是"NDHWC"。
+    - ``ValueError`` - 如果 ``padding`` 是字符串，既不是"SAME"也不是"VALID"。
+    - ``ValueError`` - 如果 ``padding`` 含有5个二元组，与批尺寸对应维度的值不为0或者与通道对应维度的值不为0。
+    - ``ValueError`` - 如果 ``output_size`` 和 ``filter_size`` 同时为None。
+    - ``ShapeError`` - 如果输入不是5-D Tensor。
+    - ``ShapeError`` - 如果输入和卷积核的维度大小不相同。
+    - ``ShapeError`` - 如果输入的维度大小与 ``stride`` 之差不是2。
+
+**代码示例**
+
+..  code-block:: python
+
+    import numpy as np
+
+    import paddle
+    import paddle.nn.functional as F
+
+    x = np.random.randn(2, 3, 8, 8, 8).astype(np.float32)
+    w = np.random.randn(3, 6, 3, 3, 3).astype(np.float32)
+
+    paddle.disable_static()
+
+    x_var = paddle.to_tensor(x)
+    w_var = paddle.to_tensor(w)
+    y_var = F.conv_transpose3d(x_var, w_var)
+    y_np = y_var.numpy()
+    print(y_np.shape)
+
+    # (2, 6, 10, 10, 10)

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/functional_cn/kl_div_cn.rst

+kl_div
+-------------------------------
+
+.. py:function:: paddle.nn.functional.kl_div(input, label, reduction='mean', name=None)
+
+该算子计算输入(Input)和输入(Label)之间的Kullback-Leibler散度损失。注意其中输入(Input)应为对数概率值，输入(Label)应为概率值。
+
+kL发散损失计算如下：
+
+..  math::
+
+    l(input, label) = label * (log(label) - input)
+
+
+当 ``reduction``  为 ``none`` 时，输出损失与输入（x）形状相同，各点的损失单独计算，不会对结果做reduction 。
+
+当 ``reduction``  为 ``mean`` 时，输出损失为[1]的形状，输出为所有损失的平均值。
+
+当 ``reduction``  为 ``sum`` 时，输出损失为[1]的形状，输出为所有损失的总和。
+
+当 ``reduction``  为 ``batchmean`` 时，输出损失为[N]的形状，N为批大小，输出为所有损失的总和除以批量大小。
+
+参数:
+    - **input** (Tensor) - KL散度损失算子的输入张量。维度为[N, \*]的多维Tensor，其中N是批大小，\*表示任何数量的附加维度，数据类型为float32或float64。
+    - **label** (Tensor) - KL散度损失算子的张量。与输入 ``input`` 的维度和数据类型一致的多维Tensor。
+    - **reduction** (str，可选) - 要应用于输出的reduction类型，可用类型为‘none’ | ‘batchmean’ | ‘mean’ | ‘sum’，‘none’表示无reduction，‘batchmean’ 表示输出的总和除以批大小，‘mean’ 表示所有输出的平均值，‘sum’表示输出的总和。
+    - **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置。默认值：None。
+    
+返回：Tensor KL散度损失。
+
+
+**代码示例：**
+
+.. code-block:: python
+
+    import paddle
+    import numpy as np
+    import paddle.nn.functional as F
+
+    paddle.disable_static()
+
+    shape = (5, 20)
+    input = np.random.uniform(-10, 10, shape).astype('float32')
+    target = np.random.uniform(-10, 10, shape).astype('float32')
+
+    # 'batchmean' reduction, loss shape will be [N]
+    pred_loss = F.kl_div(paddle.to_tensor(input),
+                            paddle.to_tensor(target), reduction='batchmean')
+    # shape=[5]
+
+    # 'mean' reduction, loss shape will be [1]
+    pred_loss = F.kl_div(paddle.to_tensor(input),
+                            paddle.to_tensor(target), reduction='mean')
+    # shape=[1]
+
+    # 'sum' reduction, loss shape will be [1]
+    pred_loss = F.kl_div(paddle.to_tensor(input),
+                            paddle.to_tensor(target), reduction='sum')
+    # shape=[1]
+
+    # 'none' reduction, loss shape is same with input shape
+    pred_loss = F.kl_div(paddle.to_tensor(input),
+                            paddle.to_tensor(target), reduction='none')
+    # shape=[5, 20]
+

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

@@ -40,14 +40,11 @@ l1_loss
 
 .. code-block:: python
 
-        import numpy as np
-        import paddle
-        
+        import paddle   
         paddle.disable_static()
-        input_data = np.array([[1.5, 0.8], [0.2, 1.3]]).astype("float32")
-        label_data = np.array([[1.7, 1], [0.4, 0.5]]).astype("float32")
-        input = paddle.to_variable(input_data)
-        label = paddle.to_variable(label_data)
+
+        input = paddle.to_tensor([[1.5, 0.8], [0.2, 1.3]])
+        label = paddle.to_tensor([[1.7, 1], [0.4, 0.5]])
 
         l1_loss = paddle.nn.functional.l1_loss(input, label)
         print(l1_loss.numpy())  

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

@@ -40,13 +40,11 @@ Tensor, 如果 :attr:`reduction` 为 ``'sum'`` 或者是 ``'mean'`` ，则形状
 
 .. code-block:: python
 
-    import numpy as np 
-    import paddle 
-    
+    import paddle
     paddle.disable_static()
      
-    input = paddle.to_variable(np.array([[1, 2], [3, 4]]).astype('float32'))
-    other = paddle.to_variable(np.array([[2, 1], [2, 4]]).astype('float32'))
-    label = paddle.to_variable(np.array([[1, -1], [-1, -1]]).astype('float32'))
+    input = paddle.to_tensor([[1, 2], [3, 4]], dtype='float32')
+    other = paddle.to_tensor([[2, 1], [2, 4]], dtype='float32')
+    label = paddle.to_tensor([[1, -1], [-1, -1]], dtype='float32')
     loss = paddle.nn.functional.margin_ranking_loss(input, other, label) 
     print(loss.numpy()) # [0.75]

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

@@ -58,8 +58,8 @@ mse_loss
     # [array([0.04000002], dtype=float32)]
     # dynamic graph mode
     paddle.disable_static()
-    input = paddle.to_variable(input_data)
-    label = paddle.to_variable(label_data)
+    input = paddle.to_tensor(input_data)
+    label = paddle.to_tensor(label_data)
     output = mse_loss(input, label)
     print(output.numpy())
     # [0.04000002]

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

@@ -38,8 +38,8 @@ nll_loss
 
         place = paddle.CPUPlace()
         paddle.disable_static(place)
-        input = paddle.to_variable(input_np)
+        input = paddle.to_tensor(input_np)
         log_out = log_softmax(input)
-        label = paddle.to_variable(label_np)
+        label = paddle.to_tensor(label_np)
         result = nll_loss(log_out, label)
         print(result.numpy()) # [1.0720209]

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

@@ -42,7 +42,7 @@ normalize
 
         paddle.disable_static()
         x = np.arange(6, dtype=np.float32).reshape(2,3)
-        x = paddle.to_variable(x)
+        x = paddle.to_tensor(x)
         y = F.normalize(x)
         print(y.numpy())
         # [[0.         0.4472136  0.8944272 ]

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

@@ -24,12 +24,10 @@ sigmoid 激活函数。
 :::::::::
 .. code-block:: python
 
-    import numpy as np
     import paddle
     import paddle.nn.functional as F 
 
     paddle.disable_static()
-    input_data = np.array([1.0, 2.0, 3.0, 4.0]).astype('float32')
-    x = paddle.to_variable(input_data)
+    x = paddle.to_tensor([1.0, 2.0, 3.0, 4.0])
     output = F.sigmoid(x)
     print(output.numpy()) # [0.7310586, 0.880797, 0.95257413, 0.98201376]

doc/fluid/api_cn/nn_cn/hardshrink_cn.rst

@@ -34,9 +34,7 @@ hardshrink激活层。计算公式如下：
 
     import paddle
     import paddle.nn.functional as F
-    import numpy as np
 
     paddle.disable_static()
-
-    x = paddle.to_variable(np.array([-1, 0.3, 2.5]))
+    x = paddle.to_tensor([-1, 0.3, 2.5])
     out = F.hardshrink(x) # [-1., 0., 2.5]

doc/fluid/api_cn/nn_cn/kldiv_loss_cn.rst

-.. _cn_api_nn_cn_kldiv_loss:
-
-kldiv_loss
--------------------------------
-:doc_source: paddle.fluid.layers.kldiv_loss
-
-

doc/fluid/api_cn/nn_cn/layer_cn/Sigmoid_cn.rst

@@ -29,12 +29,10 @@ Sigmoid
 
 .. code-block:: python
 
-     import numpy as np
      import paddle
 
      paddle.disable_static()
-     input_data = np.array([1.0, 2.0, 3.0, 4.0]).astype('float32')
      m = paddle.nn.Sigmoid()
-     x = paddle.to_variable(input_data)
+     x = paddle.to_tensor([1.0, 2.0, 3.0, 4.0])
      output = m(x)
      print(output.numpy()) # [0.7310586, 0.880797, 0.95257413, 0.98201376

doc/fluid/api_cn/nn_cn/logsigmoid_cn.rst → doc/fluid/api_cn/nn_cn/log_sigmoid_cn.rst

-.. _cn_api_nn_cn_logsigmoid:
+.. _cn_api_nn_cn_log_sigmoid:
 
-logsigmoid
+log_sigmoid
 -------------------------------
 
-.. py:function:: paddle.nn.functional.logsigmoid(x, name=None)
+.. py:function:: paddle.nn.functional.log_sigmoid(x, name=None)
 
-logsigmoid激活层。计算公式如下：
+log_sigmoid激活层。计算公式如下：
 
 .. math::
 
-    logsigmoid(x) = \log \frac{1}{1 + e^{-x}}
+    log\_sigmoid(x) = \log \frac{1}{1 + e^{-x}}
 
 其中，:math:`x` 为输入的 Tensor
 
@@ -29,9 +29,8 @@ logsigmoid激活层。计算公式如下：
 
     import paddle
     import paddle.nn.functional as F
-    import numpy as np
 
     paddle.disable_static()
 
-    x = paddle.to_tensor(np.array([1.0, 2.0, 3.0, 4.0]))
-    out = F.logsigmoid(x) # [-0.313262 -0.126928 -0.0485874 -0.0181499]
+    x = paddle.to_tensor([1.0, 2.0, 3.0, 4.0])
+    out = F.log_sigmoid(x) # [-0.313262 -0.126928 -0.0485874 -0.0181499]

doc/fluid/api_cn/nn_cn/loss_cn.rst

@@ -15,5 +15,6 @@ loss
     loss_cn/MarginRankingLoss_cn.rst
     loss_cn/MSELoss_cn.rst
     loss_cn/NLLLoss_cn.rst
+    loss_cn/KLDivLoss_cn.rst
     loss_cn/SmoothL1Loss.rst
     loss_cn/CTCLoss_cn.rst

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/api_cn/nn_cn/loss_cn/KLDivLoss_cn.rst

+KLDivLoss
+-------------------------------
+
+.. py:class:: paddle.nn.loss.KLDivLoss(reduction='mean')
+
+该算子计算输入(Input)和输入(Label)之间的Kullback-Leibler散度损失。注意其中输入(Input)应为对数概率值，输入(Label)应为概率值。
+
+kL发散损失计算如下：
+
+..  math::
+
+    l(input, label) = label * (log(label) - input)
+
+
+当 ``reduction``  为 ``none`` 时，输出损失与输入（input）形状相同，各点的损失单独计算，不会对结果做reduction 。
+
+当 ``reduction``  为 ``mean`` 时，输出损失为[1]的形状，输出为所有损失的平均值。
+
+当 ``reduction``  为 ``sum`` 时，输出损失为[1]的形状，输出为所有损失的总和。
+
+当 ``reduction``  为 ``batchmean`` 时，输出损失为[N]的形状，N为批大小，输出为所有损失的总和除以批量大小。
+
+参数:
+    - **reduction** (str，可选) - 要应用于输出的reduction类型，可用类型为‘none’ | ‘batchmean’ | ‘mean’ | ‘sum’，‘none’表示无reduction，‘batchmean’ 表示输出的总和除以批大小，‘mean’ 表示所有输出的平均值，‘sum’表示输出的总和。
+    
+形状:
+    - **input** (Tensor): - 输入的Tensor，维度是[N, *], 其中N是batch size， `*` 是任意数量的额外维度。数据类型为：float32、float64。
+    - **label** (Tensor): - 标签，维度是[N, *], 与 ``input`` 相同。数据类型为：float32、float64。
+    - **output** (Tensor): - 输入 ``input`` 和标签 ``label`` 间的kl散度。如果 `reduction` 是 ``'none'``, 则输出Loss的维度为 [N, *], 与输入 ``input`` 相同。如果 `reduction` 是 ``'batchmean'`` 、 ``'mean'`` 或 ``'sum'``, 则输出Loss的维度为 [1]。
+
+**代码示例：**
+
+.. code-block:: python
+
+    import paddle
+    import numpy as np
+    import paddle.nn as nn
+
+    paddle.disable_static()
+
+    shape = (5, 20)
+    x = np.random.uniform(-10, 10, shape).astype('float32')
+    target = np.random.uniform(-10, 10, shape).astype('float32')
+
+    # 'batchmean' reduction, loss shape will be [N]
+    kldiv_criterion = nn.KLDivLoss(reduction='batchmean')
+    pred_loss = kldiv_criterion(paddle.to_tensor(x),
+                                paddle.to_tensor(target))
+    # shape=[5]
+
+    # 'mean' reduction, loss shape will be [1]
+    kldiv_criterion = nn.KLDivLoss(reduction='mean')
+    pred_loss = kldiv_criterion(paddle.to_tensor(x),
+                                paddle.to_tensor(target))
+    # shape=[1]
+
+    # 'sum' reduction, loss shape will be [1]
+    kldiv_criterion = nn.KLDivLoss(reduction='sum')
+    pred_loss = kldiv_criterion(paddle.to_tensor(x),
+                                paddle.to_tensor(target))
+    # shape=[1]
+
+    # 'none' reduction, loss shape is same with X shape
+    kldiv_criterion = nn.KLDivLoss(reduction='none')
+    pred_loss = kldiv_criterion(paddle.to_tensor(x),
+                                paddle.to_tensor(target))
+    # shape=[5, 20]
+

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

@@ -39,14 +39,11 @@ L1Loss
 
 .. code-block:: python
 
-        import numpy as np
         import paddle
 
         paddle.disable_static()
-        input_data = np.array([[1.5, 0.8], [0.2, 1.3]]).astype("float32")
-        label_data = np.array([[1.7, 1], [0.4, 0.5]]).astype("float32")
-        input = paddle.to_variable(input_data)
-        label = paddle.to_variable(label_data)
+        input = paddle.to_tensor([[1.5, 0.8], [0.2, 1.3]])
+        label = paddle.to_tensor([[1.7, 1], [0.4, 0.5]])
 
         l1_loss = paddle.nn.loss.L1Loss()
         output = l1_loss(input, label)