Skip to content

F
FluidDoc

PaddlePaddle / FluidDoc

通知 5
Star 2
Fork 0
F
FluidDoc
未验证 提交 60acca73 编写于 作者: C Cheerego 提交者： GitHub
浏览文件
操作

Update0323 (#718) 

* fix layers. ==> fluid.layers. (#688)

* fix data_reader_cn and dataset_cn (#685)

* fix textual content

* fix issue #682 3 3.2

* fix issues in conv

* Fix io_cn (#597)

* routine bug fix

* update text info

* fix io_cn all

* 持久性变量=>长期变量

* 1220 improve cnapi (#509)

* 1220 update cnapi

* Apply suggestions from code review
Co-Authored-By: Nhaowang101779990 <31058429+haowang101779990@users.noreply.github.com>

* refine reader doc (#686)

* update VisualDL README to add more details (#694)

* improve save_load_variables cn (#689)

* improve save_load_variables

* Update save_load_variables.rst

* fix typo of models (#698)

* fix typo of models

* fix en

* Fix arguments according to 1.3 en + ceil,floor 翻译 +operator 翻译 (#695)

* Fix arguments according to 1.3 en + ceil,floor trans +operator trans

* fix LoDTensorArray spell

* update_reading_data (#699)

* add api_guides low_level backward parameter program_en (#696)

* add api_guides low_level backward parameter program_en

* Apply suggestions from code review
Co-Authored-By: Nzy0531 <48094155+zy0531@users.noreply.github.com>

* Apply suggestions from code review
Co-Authored-By: Nzy0531 <48094155+zy0531@users.noreply.github.com>

* Update backward_en.rst

* Update parameter_en.rst

* Update program_en.rst

* Update doc/fluid/api_guides/low_level/program_en.rst
上级 6cd92b0b
显示空白变更内容
内联 并排
Showing with 635 addition and 280 deletion
doc/fluid/api_cn/data/data_reader_cn.rst
浏览文件 @ 60acca73
......@@ -11,7 +11,7 @@ DataFeeder
.. py:class:: paddle.fluid.data_feeder.DataFeeder(feed_list, place, program=None)
DataFeeder将读卡器返回的数据转换为可以输入Executor和ParallelExecutor的数据结构。读卡器通常返回一个小批量数据条目列表。列表中的每个数据条目都是一个样本。每个样本都是具有一个或多个特征的列表或元组。
DataFeeder将reader返回的数据转换为可以输入Executor和ParallelExecutor的数据结构。reader通常返回一个小批量数据条目列表。列表中的每个数据条目都是一个样本。每个样本都是具有一个或多个特征的列表或元组。
简单用法如下：
......@@ -42,7 +42,7 @@ DataFeeder将读卡器返回的数据转换为可以输入Executor和ParallelExe
参数：
- **feed_list** (list) – 将输入模型的变量或变量的名称。
- **place** (Place) – place表示将数据输入CPU或GPU，如果要将数据输入GPU，请使用fluid.CUDAPlace(i)（i表示GPU的ID），如果要将数据输入CPU，请使用fluid.CPUPlace()。
- **program** (Program) –将数据输入的Program，如果Program为None，它将使用default_main_program() 。默认值None.
- **program** (Program) –将数据输入的Program，如果Program为None，它将使用default_main_program() 。默认值None。
抛出异常： ``ValueError`` – 如果某些变量未在Program中出现
......@@ -81,7 +81,7 @@ DataFeeder将读卡器返回的数据转换为可以输入Executor和ParallelExe
需要多个mini-batches。每个mini-batch都将提前在每个设备上输入。
参数：
- **iterable** (list|tuple) – 输入的数据
- **iterable** (list|tuple) – 输入的数据。
- **num_places** (int) – 设备编号，默认值为None。
返回： 转换结果
......@@ -96,19 +96,19 @@ DataFeeder将读卡器返回的数据转换为可以输入Executor和ParallelExe
.. py:method:: decorate_reader(reader, multi_devices, num_places=None, drop_last=True)
将输入数据转换成读卡器返回的多个mini-batches。每个mini-batch
将输入数据转换成reader返回的多个mini-batches。每个mini-batch分别送入各设备中。
参数：
- **reader** (function) – reader是可以生成数据的函数
- **multi_devices** (bool) – 是否用多个设备
- **reader** (function) – reader是可以生成数据的函数。
- **multi_devices** (bool) – 是否用多个设备。
- **num_places** (int) – 如果multi_devices是True, 你可以指定GPU的使用数量, 如果multi_devices是None, 会使用当前机器的所有GPU ，默认值None。
- **drop_last** (bool) – 如果最后一个batch的大小小于batch_size，是否删除最后一个batch，默认值True。
- **drop_last** (bool) – 如果最后一个batch的大小小于batch_size，选择是否删除最后一个batch，默认值True。
返回： 转换结果
返回类型： dict
引起异常： ValueError – 如果drop_last为False并且数据批不适合设备。
抛出异常： ``ValueError`` – 如果drop_last为False并且数据batch和设备数目不匹配。
.. _cn_api_paddle_data_reader_reader:
......@@ -120,14 +120,14 @@ Reader
- reader是一个读取数据（从文件、网络、随机数生成器等）并生成数据项的函数。
- reader creator是返回reader函数的函数。
- reader decorator是一个函数，它接受一个或多个读卡器，并返回一个读卡器。
- batch reader是一个函数，它读取数据（从读卡器、文件、网络、随机数生成器等）并生成一批数据项。
- reader decorator是一个函数，它接受一个或多个reader，并返回一个reader。
- batch reader是一个函数，它读取数据（从reader、文件、网络、随机数生成器等）并生成一批数据项。
Data Reader Interface
------------------------------------
的确，数据阅读器不必是读取和生成数据项的函数，它可以是任何不带参数的函数来创建一个iterable（任何东西都可以被用于 ``for x in iterable`` ):
的确，data reader不必是读取和生成数据项的函数，它可以是任何不带参数的函数来创建一个iterable（任何东西都可以被用于 ``for x in iterable`` ):
.. code-block:: python
......@@ -163,7 +163,7 @@ Data Reader Interface
参数：
- **func** - 使用的函数. 函数类型应为(Sample) => Sample
- **readers** - 其输出将用作func参数的读卡器。
- **readers** - 其输出将用作func参数的reader。
类型：callable
......@@ -176,7 +176,7 @@ Data Reader Interface
创建缓冲数据读取器。
缓冲数据读卡器将读取数据条目并将其保存到缓冲区中。只要缓冲区不为空，就将继续从缓冲数据读取器读取数据。
缓冲数据reader将读取数据条目并将其保存到缓冲区中。只要缓冲区不为空，就将继续从缓冲数据读取器读取数据。
参数：
- **reader** (callable) - 要读取的数据读取器
......@@ -188,28 +188,28 @@ Data Reader Interface
.. py:function:: paddle.reader.compose(*readers, **kwargs)
创建一个数据读卡器，其输出是输入读卡器的组合。
创建一个数据reader，其输出是输入reader的组合。
如果输入读卡器输出以下数据项：（1，2）3（4，5），则组合读卡器将输出：（1，2，3，4，5）
如果输入reader输出以下数据项：（1，2）3（4，5），则组合reader将输出：（1，2，3，4，5）。
参数：
- **readers** - 将被组合的多个读取器
- **check_alignment** (bool) - 如果为True，将检查输入读卡器是否正确对齐。如果为False，将不检查对齐，将丢弃跟踪输出。默认值True。
- **readers** - 将被组合的多个读取器。
- **check_alignment** (bool) - 如果为True，将检查输入reader是否正确对齐。如果为False，将不检查对齐，将丢弃跟踪输出。默认值True。
返回：新的数据读取器
引起异常： ``ComposeNotAligned`` – 读卡器的输出不一致。 当check_alignment设置为False，不会升高。
抛出异常： ``ComposeNotAligned`` – reader的输出不一致。 当check_alignment设置为False，不会升高。
.. py:function:: paddle.reader.chain(*readers)
创建一个数据读卡器，其输出是链接在一起的输入数据读卡器的输出。
创建一个数据reader，其输出是链接在一起的输入数据reader的输出。
如果输入读卡器输出以下数据条目：[0，0，0][1，1，1][2，2，2]，链接读卡器将输出：[0，0，0，1，1，1，2，2，2]
如果输入reader输出以下数据条目：[0，0，0][1，1，1][2，2，2]，链接reader将输出：[0，0，0，1，1，1，2，2，2] 。
参数：
- **readers** – 输入的数据
- **readers** – 输入的数据。
返回： 新的数据读取器
......@@ -218,15 +218,15 @@ Data Reader Interface
.. py:function:: paddle.reader.shuffle(reader, buf_size)
创建数据读取器，该阅读器的数据输出将被无序排列。
创建数据读取器，该reader的数据输出将被无序排列。
由原始读卡器创建的迭代器的输出将被缓冲到shuffle缓冲区，然后进行打乱。打乱缓冲区的大小由参数buf_size决定。
由原始reader创建的迭代器的输出将被缓冲到shuffle缓冲区，然后进行打乱。打乱缓冲区的大小由参数buf_size决定。
参数：
- **reader** (callable) – 输出会被打乱的原始读卡器
- **reader** (callable) – 输出会被打乱的原始reader
- **buf_size** (int) – 打乱缓冲器的大小
返回： 输出会被打乱的读卡器
返回： 输出会被打乱的reader
返回类型： callable
......@@ -234,13 +234,13 @@ Data Reader Interface
.. py:function:: paddle.reader.firstn(reader, n)
限制读卡器可以返回的最大样本数。
限制reader可以返回的最大样本数。
参数：
- **reader** (callable) – 要读取的数据读取器
- **n** (int) – 返回的最大样本数
- **reader** (callable) – 要读取的数据读取器。
- **n** (int) – 返回的最大样本数 。
返回： 装饰读卡器
返回： 装饰reader
返回类型： callable
......@@ -294,11 +294,11 @@ rtype: string
.. py:function:: paddle.reader.multiprocess_reader(readers, use_pipe=True, queue_size=1000)
多进程读卡器使用python多进程从读卡器中读取数据，然后使用multi process.queue或multi process.pipe合并所有数据。进程号等于输入读卡器的编号，每个进程调用一个读卡器。
多进程reader使用python多进程从reader中读取数据，然后使用multi process.queue或multi process.pipe合并所有数据。进程号等于输入reader的编号，每个进程调用一个reader。
multiprocess.queue需要/dev/shm的rw访问权限，某些平台不支持。
您需要首先创建多个读卡器，这些读卡器应该相互独立，这样每个进程都可以独立工作。
您需要首先创建多个reader，这些reader应该相互独立，这样每个进程都可以独立工作。
**代码示例**
......@@ -314,11 +314,11 @@ multiprocess.queue需要/dev/shm的rw访问权限，某些平台不支持。
.. py:class::paddle.reader.Fake
Fake读卡器将缓存它读取的第一个数据，并将其输出data_num次。它用于缓存来自真实阅读器的数据，并将其用于速度测试。
Fakereader将缓存它读取的第一个数据，并将其输出data_num次。它用于缓存来自真实reader的数据，并将其用于速度测试。
参数：
- **reader** – 原始读取器
- **data_num** – 读卡器产生数据的次数
- **reader** – 原始读取器。
- **data_num** – reader产生数据的次数 。
返回： 一个Fake读取器
......@@ -343,7 +343,7 @@ Creator包包含一些简单的reader creator，可以在用户Program中使用
如果是numpy向量，则创建一个生成x个元素的读取器。或者，如果它是一个numpy矩阵，创建一个生成x行元素的读取器。或由最高维度索引的任何子超平面。
参数：
- **x** – 用于创建读卡器的numpy数组
- **x** – 用于创建reader的numpy数组。
返回： 从x创建的数据读取器
......@@ -359,7 +359,7 @@ Creator包包含一些简单的reader creator，可以在用户Program中使用
.. py:function:: paddle.reader.creator.recordio(paths, buf_size=100)
从给定的recordio文件路径创建数据读卡器，用“，”分隔“，支持全局模式。
从给定的recordio文件路径创建数据reader，用“，”分隔“，支持全局模式。
路径：recordio文件的路径，可以是字符串或字符串列表。
......
doc/fluid/api_cn/data/dataset_cn.rst
浏览文件 @ 60acca73
......@@ -153,7 +153,7 @@ imdb
IMDB数据集。
本模块的数据集从 http://ai.stanford.edu/%7Eamaas/data/sentiment/IMDB 数据集。这个数据集包含了一组25000个用于训练的极性电影评论数据和25000个用于测试的评论数据。此外，该模块还提供了用于构建词典的API。
本模块的数据集从 http://ai.stanford.edu/%7Eamaas/data/sentiment/IMDB 数据集。这个数据集包含了25000条训练用电影评论数据，25000条测试用评论数据，且这些评论带有明显情感倾向。此外，该模块还提供了用于构建词典的API。
.. py:function:: paddle.dataset.imdb.build_dict(pattern, cutoff)
......
doc/fluid/api_cn/executor_cn.rst
浏览文件 @ 60acca73
......@@ -144,7 +144,7 @@ feed map为该program提供输入数据。fetch_list提供program训练结束后
global_scope
-------------------------------
.. py:function:: paddle.fluid.global_scope ()
.. py:function:: paddle.fluid.executor.global_scope ()
获取全局/默认作用域实例。很多api使用默认 ``global_scope`` ，例如 ``Executor.run`` 。
......@@ -163,7 +163,7 @@ global_scope
scope_guard
-------------------------------
.. py:function:: paddle.fluid.scope_guard (scope)
.. py:function:: paddle.fluid.executor.scope_guard (scope)
修改全局/默认作用域（scope）, 运行时中的所有变量都将分配给新的scope。
......
doc/fluid/api_cn/fluid_cn.rst
浏览文件 @ 60acca73
......@@ -162,7 +162,9 @@ BuildStrategy
str类型。它表明了以graphviz格式向文件中写入SSA图的路径，有利于调试。 默认值为""。
.. py:attribute:: enable_sequential_execution
类型是BOOL。 如果设置为True，则ops的执行顺序将与program中的执行顺序相同。 默认为False。
.. py:attribute:: fuse_elewise_add_act_ops
......@@ -1015,10 +1017,10 @@ feed map为该program提供输入数据。fetch_list提供program训练结束后
.. code-block:: python
data = layers.data(name='X', shape=[1], dtype='float32')
hidden = layers.fc(input=data, size=10)
data = fluid.layers.data(name='X', shape=[1], dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
layers.assign(hidden, out)
loss = layers.mean(out)
loss = fluid.layers.mean(out)
adam = fluid.optimizer.Adam()
adam.minimize(loss)
......@@ -1183,7 +1185,7 @@ LoDTensorArray
.. py:method:: append(self: paddle.fluid.core.LoDTensorArray, tensor: paddle.fluid.core.LoDTensor) → None
将LoDensor追加到LoDTensorArray后。
将LoDTensor追加到LoDTensorArray后。
......
doc/fluid/api_cn/initializer_cn.rst
浏览文件 @ 60acca73
......@@ -116,7 +116,7 @@ force_init_on_cpu
init_on_cpu
-------------------------------
.. py:function:: paddle.fluid.initializer.init_on_cpu(*args, **kwds)
.. py:function:: paddle.fluid.initializer.init_on_cpu()
强制变量在 cpu 上初始化。
......@@ -125,7 +125,7 @@ init_on_cpu
.. code-block:: python
with init_on_cpu():
step = layers.create_global_var()
step = fluid.layers.create_global_var()
......
doc/fluid/api_cn/io_cn.rst
浏览文件 @ 60acca73
......@@ -9,9 +9,9 @@
load_inference_model
-------------------------------
.. py:class:: paddle.fluid.io.load_inference_model(dirname, executor, model_filename=None, params_filename=None, pserver_endpoints=None)
.. py:function:: paddle.fluid.io.load_inference_model(dirname, executor, model_filename=None, params_filename=None, pserver_endpoints=None)
从指定目录中加载预测模型model(inference model)
从指定目录中加载预测模型(inference model)。
参数:
- **dirname** (str) – model的路径
......@@ -52,13 +52,13 @@ load_inference_model
load_params
-------------------------------
.. py:class:: paddle.fluid.io.load_params(executor, dirname, main_program=None, filename=None)
.. py:function:: paddle.fluid.io.load_params(executor, dirname, main_program=None, filename=None)
该函数过滤掉 给定 ``main_program`` 中所有参数，然后将它们加载保存在到目录 ``dirname`` 中或文件中的参数。
该函数从给定 ``main_program`` 中取出所有参数，然后从目录 ``dirname`` 中或 ``filename`` 指定的文件中加载这些参数。
``dirname`` 用于指定保存变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用filename来指定它
``dirname`` 用于存有变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用filename来指明这个文件。
注意:有些变量不是参数，但它们对于训练是必要的。因此，您不能仅通过 ``save_params()`` 和 ``load_params()`` 保存并之后继续训练。可以使用 ``save_persistables()`` 和 ``load_persistables()`` 代替这两个函数
注意:有些变量不是参数，但它们对于训练是必要的。因此，调用 ``save_params()`` 和 ``load_params()`` 来保存和加载参数是不够的，可以使用 ``save_persistables()`` 和 ``load_persistables()`` 代替这两个函数。
参数:
- **executor** (Executor) – 加载变量的 executor
......@@ -89,11 +89,11 @@ load_params
load_persistables
-------------------------------
.. py:class:: paddle.fluid.io.load_persistables(executor, dirname, main_program=None, filename=None)
.. py:function:: paddle.fluid.io.load_persistables(executor, dirname, main_program=None, filename=None)
该函数过滤掉 给定 ``main_program`` 中所有参数，然后将它们加载保存在到目录 ``dirname`` 中或文件中的参数。
该函数从给定 ``main_program`` 中取出所有 ``persistable==True`` 的变量（即长期变量），然后将它们从目录 ``dirname`` 中或 ``filename`` 指定的文件中加载出来。
``dirname`` 用于指定保存变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用filename来指定它
``dirname`` 用于指定存有长期变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用filename来指定它。
参数:
- **executor** (Executor) – 加载变量的 executor
......@@ -124,13 +124,13 @@ load_persistables
load_vars
-------------------------------
.. py:class:: paddle.fluid.io.load_vars(executor, dirname, main_program=None, vars=None, predicate=None, filename=None)
.. py:function:: paddle.fluid.io.load_vars(executor, dirname, main_program=None, vars=None, predicate=None, filename=None)
``executor`` 从指定目录加载变量。
有两种方法来加载变量:方法一，``vars`` 为变量的列表。方法二，将已存在的 ``Program`` 赋值给 ``main_program`` ，然后将加载 ``Program`` 中的所有变量。第一种方法优先级更高。如果指定了 vars，那么忽略 ``main_program`` 和 ``predicate`` 。
``dirname`` 用于指定加载变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用 ``filename`` 来指定它
``dirname`` 用于指定加载变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用 ``filename`` 来指定它。
参数:
- **executor** (Executor) – 加载变量的 executor
......@@ -182,11 +182,12 @@ load_vars
save_inference_model
-------------------------------
.. py:class:: paddle.fluid.io.save_inference_model(dirname, feeded_var_names, target_vars, executor, main_program=None, model_filename=None, params_filename=None, export_for_deployment=True)
.. py:function:: paddle.fluid.io.save_inference_model(dirname, feeded_var_names, target_vars, executor, main_program=None, model_filename=None, params_filename=None, export_for_deployment=True)
修改指定的 ``main_program`` ，构建一个专门用预测的 ``Program``，然后 ``executor`` 把它和所有相关参数保存到 ``dirname`` 中
修改指定的 ``main_program`` ，构建一个专门用于预测的 ``Program``，然后 ``executor`` 把它和所有相关参数保存到 ``dirname`` 中。
``dirname`` 用于指定保存变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用filename来指定它
``dirname`` 用于指定保存变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用filename来指定它。
参数:
- **dirname** (str) – 保存预测model的路径
......@@ -229,13 +230,13 @@ save_inference_model
save_params
-------------------------------
.. py:class:: paddle.fluid.io.save_params(executor, dirname, main_program=None, filename=None)
.. py:function:: paddle.fluid.io.save_params(executor, dirname, main_program=None, filename=None)
该函数过滤掉 给定 ``main_program`` 中所有参数，然后将它们保存到目录 ``dirname`` 中或文件中。
该函数从 ``main_program`` 中取出所有参数，然后将它们保存到 ``dirname`` 目录下或名为 ``filename`` 的文件中。
``dirname`` 用于指定保存变量的目录。如果想将变量保存到指定目录的若干文件中，设置文件名 None; 如果想将所有变量保存在一个文件中，请使用filename来指定它
``dirname`` 用于指定保存变量的目标目录。如果想将变量保存到多个独立文件中，设置 ``filename`` 为 None; 如果想将所有变量保存在单个文件中，请使用 ``filename`` 来指定该文件的命名。
注意:有些变量不是参数，但它们对于训练是必要的。因此，您不能仅通过 ``save_params()`` 和 ``load_params()`` 保存并之后继续训练。可以使用 ``save_persistables()`` 和 ``load_persistables()`` 代替这两个函数
注意:有些变量不是参数，但它们对于训练是必要的。因此，调用 ``save_params()`` 和 ``load_params()`` 来保存和加载参数是不够的，可以使用 ``save_persistables()`` 和 ``load_persistables()`` 代替这两个函数。
参数:
......@@ -243,7 +244,7 @@ save_params
- **dirname** (str) – 目录路径
- **main_program** (Program|None) – 需要保存变量的 Program。如果为 None，则使用 default_main_Program 。默认值: None
- **vars** (list[Variable]|None) – 要保存的所有变量的列表。 优先级高于main_program。默认值: None
- **filename** (str|None) – 保存变量的文件。如果想分开保存变量，设置 filename=None. 默认值: None
- **filename** (str|None) – 保存变量的文件。如果想分不同独立文件来保存变量，设置 filename=None. 默认值: None
返回: None
......@@ -268,11 +269,11 @@ save_params
save_persistables
-------------------------------
.. py:class:: paddle.fluid.io.save_persistables(executor, dirname, main_program=None, filename=None)
.. py:function:: paddle.fluid.io.save_persistables(executor, dirname, main_program=None, filename=None)
该函数过滤掉 给定 ``main_program`` 中所有参数，然后将它们保存到目录 ``dirname`` 中或文件中。
该函数从给定 ``main_program`` 中取出所有 ``persistable==True`` 的变量，然后将它们保存到目录 ``dirname`` 中或 ``filename`` 指定的文件中。
``dirname`` 用于指定保存变量的目录。如果想将变量保存到指定目录的若干文件中，设置 ``filename=None`` ; 如果想将所有变量保存在一个文件中，请使用 ``filename`` 来指定它
``dirname`` 用于指定保存长期变量的目录。如果想将变量保存到指定目录的若干文件中，设置 ``filename=None`` ; 如果想将所有变量保存在一个文件中，请使用 ``filename`` 来指定它。
参数:
- **executor** (Executor) – 保存变量的 executor
......@@ -306,7 +307,7 @@ save_persistables
save_vars
-------------------------------
.. py:class:: paddle.fluid.io.save_vars(executor, dirname, main_program=None, vars=None, predicate=None, filename=None)
.. py:function:: paddle.fluid.io.save_vars(executor, dirname, main_program=None, vars=None, predicate=None, filename=None)
通过 ``Executor`` ,此函数将变量保存到指定目录下。
......
doc/fluid/api_cn/layers_cn.rst
浏览文件 @ 60acca73
......@@ -117,7 +117,7 @@ array_write
tmp = fluid.layers.zeros(shape=[10], dtype='int32')
i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
arr = layers.array_write(tmp, i=i)
arr = fluid.layers.array_write(tmp, i=i)
......@@ -704,15 +704,15 @@ While
.. code-block:: python
d0 = layers.data("d0", shape=[10], dtype='float32')
data_array = layers.array_write(x=d0, i=i)
array_len = layers.fill_constant(shape=[1],dtype='int64', value=3)
d0 = fluid.layers.data("d0", shape=[10], dtype='float32')
data_array = fluid.layers.array_write(x=d0, i=i)
array_len = fluid.layers.fill_constant(shape=[1],dtype='int64', value=3)
cond = layers.less_than(x=i, y=array_len)
while_op = layers.While(cond=cond)
cond = fluid.layers.less_than(x=i, y=array_len)
while_op = fluid.layers.While(cond=cond)
with while_op.block():
d = layers.array_read(array=data_array, i=i)
i = layers.increment(x=i, in_place=True)
d = fluid.layers.array_read(array=data_array, i=i)
i = fluid.layers.increment(x=i, in_place=True)
layers.array_write(result, i=i, array=d)
layers.less_than(x=i, y=array_len, cond=cond)
......@@ -1761,13 +1761,13 @@ beam_search
# 假设 `probs` 包含计算神经元所得的预测结果
# `pre_ids` 和 `pre_scores` 为beam_search之前时间步的输出
topk_scores, topk_indices = layers.topk(probs, k=beam_size)
accu_scores = layers.elementwise_add(
topk_scores, topk_indices = fluid.layers.topk(probs, k=beam_size)
accu_scores = fluid.layers.elementwise_add(
x=layers.log(x=topk_scores)),
y=layers.reshape(
pre_scores, shape=[-1]),
axis=0)
selected_ids, selected_scores = layers.beam_search(
selected_ids, selected_scores = fluid.layers.beam_search(
pre_ids=pre_ids,
pre_scores=pre_scores,
ids=topk_indices,
......@@ -1816,7 +1816,7 @@ beam_search_decode
# 假设 `ids` 和 `scores` 为 LodTensorArray变量，它们保留了
# 选择出的所有时间步的id和score
finished_ids, finished_scores = layers.beam_search_decode(
finished_ids, finished_scores = fluid.layers.beam_search_decode(
ids, scores, beam_size=5, end_id=0)
......@@ -2039,7 +2039,7 @@ clip
clip算子
clip运算符限制给定输入的值在一个区间内。间隔使用参数"min"和"max"来指定：公式为
clip算子限制给定输入的值在一个区间内。间隔使用参数"min"和"max"来指定：公式为
.. math::
Out=min(max(X,min),max)
......@@ -2076,7 +2076,7 @@ clip_by_norm
ClipByNorm算子
此运算符将输入 ``X`` 的L2范数限制在 ``max_norm`` 内。如果 ``X`` 的L2范数小于或等于 ``max_norm`` ，则输出（Out）将与 ``X`` 相同。如果X的L2范数大于 ``max_norm`` ，则 ``X`` 将被线性缩放，使得输出（Out）的L2范数等于 ``max_norm`` ，如下面的公式所示：
此算子将输入 ``X`` 的L2范数限制在 ``max_norm`` 内。如果 ``X`` 的L2范数小于或等于 ``max_norm`` ，则输出（Out）将与 ``X`` 相同。如果X的L2范数大于 ``max_norm`` ，则 ``X`` 将被线性缩放，使得输出（Out）的L2范数等于 ``max_norm`` ，如下面的公式所示：
.. math::
Out = \frac{max\_norm * X}{norm(X)}
......@@ -2478,7 +2478,7 @@ cos_sim
.. py:function:: paddle.fluid.layers.cos_sim(X, Y)
余弦相似度运算符（Cosine Similarity Operator）
余弦相似度算子（Cosine Similarity Operator）
.. math::
......@@ -2536,7 +2536,7 @@ crf_decoding
.. code-block:: python
crf_decode = layers.crf_decoding(
crf_decode = fluid.layers.crf_decoding(
input=hidden, param_attr=ParamAttr(name="crfw"))
......@@ -2864,7 +2864,7 @@ dice_loss定义为:
dropout
-------------------------------
.. py:function:: Paddle.fluid.layers.dropout(x,dropout_prob,is_test=False,seed=None,name=None,dropout_implementation='downgrade_in_infer')
.. py:function:: paddle.fluid.layers.dropout(x,dropout_prob,is_test=False,seed=None,name=None,dropout_implementation='downgrade_in_infer')
dropout操作
......@@ -3222,9 +3222,9 @@ LSTMP层(具有循环映射的LSTM)在LSTM层后有一个分离的映射层，
edit_distance
-------------------------------
.. py:function:: Paddle.fluid.layers.edit_distance(input,label,normalized=True,ignored_tokens=None)
.. py:function:: paddle.fluid.layers.edit_distance(input,label,normalized=True,ignored_tokens=None)
编辑距离运算符
编辑距离算子
计算一批给定字符串及其参照字符串间的编辑距离。编辑距离也称Levenshtein距离，通过计算从一个字符串变成另一个字符串所需的最少操作步骤来衡量两个字符串的相异度。这里的操作包括插入、删除和替换。
......@@ -3795,7 +3795,7 @@ fc
**全连接层**
该函数在神经网络中建立一个全连接层。 它可以同时将多个tensor作为自己的输入，并为每个输入的tensor创立一个变量，称为“权”（weights），等价于一个从每个输入单元到每个输出单元的全连接权矩阵。FC层用每个tensor和它对应的权相乘得到输出tensor。如果有多个输入tensor，那么多个乘法运算将会加在一起得出最终结果。如果 ``bias_attr`` 非空，则会新创建一个偏向变量（bias variable），并把它加入到输出结果的运算中。最后，如果 ``act`` 非空，它也会加入最终输出的计算中。
该函数在神经网络中建立一个全连接层。 它可以同时将多个tensor（ ``input`` 可使用多个tensor组成的一个list，详见参数说明）作为自己的输入，并为每个输入的tensor创立一个变量，称为“权”（weights），等价于一个从每个输入单元到每个输出单元的全连接权矩阵。FC层用每个tensor和它对应的权相乘得到输出tensor。如果有多个输入tensor，那么多个乘法运算将会加在一起得出最终结果。如果 ``bias_attr`` 非空，则会新创建一个偏向变量（bias variable），并把它加入到输出结果的运算中。最后，如果 ``act`` 非空，它也会加入最终输出的计算中。
这个过程可以通过如下公式表现：
......@@ -3882,11 +3882,13 @@ flatten
Out.shape = (1, 3 * 100 * 100 * 4)
参数：
- **x** (Variable): 一个秩>=axis 的张量
- **axis** (int)：指出应该将哪些输入维度(唯一的) flatten 到输出的外部维度。axis的值必须在[0,R]范围内，其中R是输入张量的秩。当 axis= 0 时，输出张量的形状为(1，(d_0 X d_1…)，其中输入张量的形状为(d_0, d_1，…)d_n)。
- **name** (str|None)：此层的名称(可选)。如果没有设置，层将自动命名。
- **x** (Variable) - 一个秩>=axis 的张量
- **axis** (int) - flatten的划分轴，[0, axis) 轴数据被flatten到输出矩阵的0轴，[axis, R)被flatten到输出矩阵的1轴，其中R是输入张量的秩。axis的值必须在[0,R]范围内。当 axis= 0 时，输出张量的形状为 (1，d_0 \* d_1 \*… d_n) ，其输入张量的形状为(d_0, d_1，… d_n)。
- **name** (str|None) - 此层的名称(可选)。如果没有设置，层将自动命名。
返回：Variable: 一个二维张量，它包含输入张量的内容，输入维数将沿给定轴flatten到输出的外部维度，剩余的输入维数flatten到输出的内部维数。
返回: 一个二维张量，它包含输入张量的内容，但维数发生变化。输入的[0, axis)维将沿给定轴flatten到输出的前一个维度，剩余的输入维数flatten到输出的后一个维度。
返回类型: Variable
抛出异常：
- ValueError: 如果 x 不是一个变量
......@@ -3971,7 +3973,7 @@ gaussian_random算子。
- **shape** （tuple | list）- （vector <int>）随机张量的维数
- **mean** （Float）- （默认值0.0）随机张量的均值
- **std** （Float）- （默认值为1.0）随机张量的std
- **seed** （Int）- （默认值为 0）生成器随机生成种子。0表示使用系统范围的种子。注意如果seed不为0，则此运算符每次将始终生成相同的随机数
- **seed** （Int）- （默认值为 0）生成器随机生成种子。0表示使用系统范围的种子。注意如果seed不为0，则此算子每次将始终生成相同的随机数
- **dtype** （np.dtype | core.VarDesc.VarType | str）- 输出的数据类型。
返回： 输出高斯随机运算矩阵
......@@ -3982,7 +3984,7 @@ gaussian_random算子。
.. code-block:: python
out = layers.gaussian_random(shape=[20, 30])
out = fluid.layers.gaussian_random(shape=[20, 30])
......@@ -4007,7 +4009,7 @@ gaussian_random_batch_size_like
- **output_dim_idx** （Int）- 默认值0.输出批量大小维度的索引。
- **mean** （Float）- （默认值0.0）高斯分布的平均值（或中心值）。
- **std** （Float）- （默认值 1.0）高斯分布的标准差（std或spread）。
- **seed** （Int）- （默认为0）用于随机数引擎的随机种子。0表示使用系统生成的种子。请注意，如果seed不为0，则此运算符将始终每次生成相同的随机数。
- **seed** （Int）- （默认为0）用于随机数引擎的随机种子。0表示使用系统生成的种子。请注意，如果seed不为0，则此算子将始终每次生成相同的随机数。
- **dtype** （np.dtype | core.VarDesc.VarType | str）- 输出数据的类型为float32，float_16，int等。
返回： 指定形状的张量将使用指定值填充。
......@@ -4020,9 +4022,9 @@ gaussian_random_batch_size_like
.. code-block:: python
input = layers.data(name="input", shape=[13, 11], dtype='float32')
input = fluid.layers.data(name="input", shape=[13, 11], dtype='float32')
out = layers.gaussian_random_batch_size_like(
out = fluid.layers.gaussian_random_batch_size_like(
input, shape=[-1, 11], mean=1.0, std=2.0)
......@@ -4373,7 +4375,7 @@ hash
hsigmoid
-------------------------------
.. py:function:: paddle.fluid.layers.hsigmoid(input, label, num_functiones, param_attr=None, bias_attr=None, name=None, path_table=None, path_code=None, is_custom=False, is_sparse=False)
.. py:function:: paddle.fluid.layers.hsigmoid(input, label, num_classes, param_attr=None, bias_attr=None, name=None, path_table=None, path_code=None, is_custom=False, is_sparse=False)
层次sigmod（ hierarchical sigmoid ）加速语言模型的训练过程。这个operator将类别组织成一个完全二叉树，也可以使用 ``is_custom`` 参数来传入自定义的树结构来实现层次化。
......@@ -4786,9 +4788,9 @@ label_smooth
.. code-block:: python
label = layers.data(name="label", shape=[1], dtype="float32")
one_hot_label = layers.one_hot(input=label, depth=10)
smooth_label = layers.label_smooth(
label = fluid.layers.data(name="label", shape=[1], dtype="float32")
one_hot_label = fluid.layers.one_hot(input=label, depth=10)
smooth_label = fluid.layers.label_smooth(
label=one_hot_label, epsilon=0.1, dtype="float32")
......@@ -5033,9 +5035,9 @@ lod_reset
.. code-block:: python
x = layers.data(name='x', shape=[10])
y = layers.data(name='y', shape=[10, 20], lod_level=2)
out = layers.lod_reset(x=x, y=y)
x = fluid.layers.data(name='x', shape=[10])
y = fluid.layers.data(name='y', shape=[10, 20], lod_level=2)
out = fluid.layers.lod_reset(x=x, y=y)
......@@ -5143,8 +5145,8 @@ logical_and算子
Out = X \&\& Y
参数：
- **x** （Variable）- （LoDTensor）logical_and运算符的左操作数
- **y** （Variable）- （LoDTensor）logical_and运算符的右操作数
- **x** （Variable）- （LoDTensor）logical_and算子的左操作数
- **y** （Variable）- （LoDTensor）logical_and算子的右操作数
- **out** （Tensor）- 输出逻辑运算的张量。
- **name** （basestring | None）- 输出的名称。
......@@ -5186,7 +5188,7 @@ logical_not算子
Out = !X
参数：
- **x** （Variable）- （LoDTensor）logical_not运算符的操作数
- **x** （Variable）- （LoDTensor）logical_not算子的操作数
- **out** （Tensor）- 输出逻辑运算的张量。
- **name** （basestring | None）- 输出的名称。
......@@ -5224,8 +5226,8 @@ logical_or算子
Out = X || Y
参数：
- **x** （Variable）- （LoDTensor）logical_or运算符的左操作数
- **y** （Variable）- （LoDTensor）logical_or运算符的右操作数
- **x** （Variable）- （LoDTensor）logical_or算子的左操作数
- **y** （Variable）- （LoDTensor）logical_or算子的右操作数
- **out** （Tensor）- 输出逻辑运算的张量。
- **name** （basestring | None）- 输出的名称。
......@@ -5266,8 +5268,8 @@ logical_xor算子
Out = (X || Y) \&\& !(X \&\& Y)
参数：
- **x** （Variable）- （LoDTensor）logical_xor运算符的左操作数
- **y** （Variable）- （LoDTensor）logical_xor运算符的右操作数
- **x** （Variable）- （LoDTensor）logical_xor算子的左操作数
- **y** （Variable）- （LoDTensor）logical_xor算子的右操作数
- **out** （Tensor）- 输出逻辑运算的张量。
- **name** （basestring | None）- 输出的名称。
......@@ -5413,10 +5415,10 @@ sigmoid的计算公式为： :math:`sigmoid(x) = 1 / (1 + e^{-x})` 。
input_size = 100
hidden_size = 150
num_layers = 1
init_hidden1 = layers.fill_constant( [num_layers, batch_size, hidden_size], 'float32', 0.0, stop_grad=False)
init_cell1 = layers.fill_constant( [num_layers, batch_size, hidden_size], 'float32', 0.0, stop_grad=False)
init_hidden1 = fluid.layers.fill_constant( [num_layers, batch_size, hidden_size], 'float32', 0.0, stop_grad=False)
init_cell1 = fluid.layers.fill_constant( [num_layers, batch_size, hidden_size], 'float32', 0.0, stop_grad=False)
rnn_out, last_h, last_c = layers.lstm( input, init_h, init_c, max_len, dropout_prob, input_size, hidden_size, num_layers)
rnn_out, last_h, last_c = fluid.layers.lstm( input, init_h, init_c, max_len, dropout_prob, input_size, hidden_size, num_layers)
......@@ -5688,7 +5690,7 @@ mean算子计算X中所有元素的平均值
mean_iou
-------------------------------
.. py:function:: paddle.fluid.layers.mean_iou(input, label, num_functiones)
.. py:function:: paddle.fluid.layers.mean_iou(input, label, num_classes)
均值IOU（Mean Intersection-Over-Union）是语义图像分割中的常用的评价指标之一，它首先计算每个语义类的IOU，然后计算类之间的平均值。定义如下:
......@@ -5868,7 +5870,7 @@ multiplex
nce
-------------------------------
.. py:function:: paddle.fluid.layers.nce(input, label, num_total_functiones, sample_weight=None, param_attr=None, bias_attr=None, num_neg_samples=None, name=None, sampler='uniform', custom_dist=None, seed=0, is_sparse=False)
.. py:function:: paddle.fluid.layers.nce(input, label, num_total_classes, sample_weight=None, param_attr=None, bias_attr=None, num_neg_samples=None, name=None, sampler='uniform', custom_dist=None, seed=0, is_sparse=False)
计算并返回噪音对比估计（ noise-contrastive estimation training loss）。
`请参考 See Noise-contrastive estimation: A new estimation principle for unnormalized statistical models
......@@ -5912,18 +5914,18 @@ nce
if i == label_word:
continue
emb = layers.embedding(input=words[i], size=[dict_size, 32],
emb = fluid.layers.embedding(input=words[i], size=[dict_size, 32],
param_attr='emb.w', is_sparse=True)
embs.append(emb)
embs = layers.concat(input=embs, axis=1)
loss = layers.nce(input=embs, label=words[label_word],
embs = fluid.layers.concat(input=embs, axis=1)
loss = fluid.layers.nce(input=embs, label=words[label_word],
num_total_classes=dict_size, param_attr='nce.w',
bias_attr='nce.b')
#使用custom distribution
dist = fluid.layers.assign(input=np.array([0.05,0.5,0.1,0.3,0.05]).astype("float32"))
loss = layers.nce(input=embs, label=words[label_word],
loss = fluid.layers.nce(input=embs, label=words[label_word],
num_total_classes=5, param_attr='nce.w',
bias_attr='nce.b',
num_neg_samples=3,
......@@ -5960,8 +5962,8 @@ one_hot
.. code-block:: python
label = layers.data(name="label", shape=[1], dtype="float32")
one_hot_label = layers.one_hot(input=label, depth=10)
label = fluid.layers.data(name="label", shape=[1], dtype="float32")
one_hot_label = fluid.layers.one_hot(input=label, depth=10)
......@@ -6263,7 +6265,7 @@ pooling2d操作符根据 ``input`` ， 池化类型 ``pool_type`` ， 池化核
pool3d
-------------------------------
.. py:function:: paddle.fluid.layers.pool3d(input, pool_size=-1, pool_type='max', pool_stride=1, pool_padding=0, global_pooling=False, use_cudnn=True, ceil_mode=False, name=None， exclusive=True)
.. py:function:: paddle.fluid.layers.pool3d(input, pool_size=-1, pool_type='max', pool_stride=1, pool_padding=0, global_pooling=False, use_cudnn=True, ceil_mode=False, name=None, exclusive=True)
函数使用上述输入参数的池化配置，为三维空间添加池化操作
......@@ -6967,7 +6969,7 @@ reshape
- **shape** (list) - 新的形状。新形状最多只能有一个维度为-1。
- **actual_shape** (variable) - 一个可选的输入。如果提供，则根据 ``actual_shape`` 进行 reshape，而不是指定 ``shape`` 。也就是说，actual_shape具有比shape更高的优先级。
- **act** (str) - 对reshpe后的tensor变量执行非线性激活
- **inplace** (bool) - 如果在多个操作符中使用x，则 ``inplace`` 必须设置为False。如果该标志设置为True，则重用输入x进行reshape，这将改变张量变量x的形状，并可能在多个操作符中使用x时造成错误。如果为False，则保留形状x，并创建一个新的输出张量变量，该张量变量的数据是从输入x复制的，但经过了重构。
- **inplace** (bool) - 如果在多个操作符中使用x，则 ``inplace`` 必须设置为False。如果该标志设置为True，则直接对输入x本身进行reshape操作，张量变量x的形状将会被改变，因此在其他操作中再使用x时会造成错误。如果为False，则保留输入变量x的原形状，并输出一个新的张量变量，该张量变量的数据是从输入x复制的，但是其形状已经经过reshape操作进行重构。
- **name** (str) - 可选变量，此层的名称
返回：如果 ``act`` 为 ``None``,返回reshape后的tensor变量。如果 ``inplace`` 为 ``False`` ,将返回一个新的Tensor变量，否则，将改变x自身。如果 ``act`` 不是 ``None`` ，则返回激活的张量变量。
......@@ -7304,7 +7306,7 @@ sampling_id算子。用于从输入的多项分布中对id进行采样的图层
- **x** （Variable）- softmax的输入张量（Tensor）。2-D形状[batch_size，input_feature_dimensions]
- **min** （Float）- 随机的最小值。（浮点数，默认为0.0）
- **max** （Float）- 随机的最大值。（float，默认1.0）
- **seed** （Float）- 用于随机数引擎的随机种子。0表示使用系统生成的种子。请注意，如果seed不为0，则此运算符将始终每次生成相同的随机数。（int，默认为0）
- **seed** （Float）- 用于随机数引擎的随机种子。0表示使用系统生成的种子。请注意，如果seed不为0，则此算子将始终每次生成相同的随机数。（int，默认为0）
- **dtype** （np.dtype | core.VarDesc.VarType | str）- 输出数据的类型为float32，float_16，int等。
返回： Id采样的数据张量。
......@@ -7316,13 +7318,13 @@ sampling_id算子。用于从输入的多项分布中对id进行采样的图层
.. code-block:: python
x = layers.data(
x = fluid.layers.data(
name="X",
shape=[13, 11],
dtype='float32',
append_batch_size=False)
out = layers.sampling_id(x)
out = fluid.layers.sampling_id(x)
......@@ -7360,7 +7362,7 @@ else:
- **act** (basestring|None) - 应用于输出的激活函数。
- **name** (basestring|None)- 输出的名称。
返回: 比例运算符的输出张量(Tensor)
返回: 比例算子的输出张量(Tensor)
返回类型: 变量(Variable)
......@@ -7631,7 +7633,7 @@ sequence_expand
x = fluid.layers.data(name='x', shape=[10], dtype='float32')
y = fluid.layers.data(name='y', shape=[10, 20],
dtype='float32', lod_level=1)
out = layers.sequence_expand(x=x, y=y, ref_level=0)
out = fluid.layers.sequence_expand(x=x, y=y, ref_level=0)
......@@ -7701,7 +7703,7 @@ Sequence Expand As Layer
x = fluid.layers.data(name='x', shape=[10], dtype='float32')
y = fluid.layers.data(name='y', shape=[10, 20],
dtype='float32', lod_level=1)
out = layers.sequence_expand_as(x=x, y=y)
out = fluid.layers.sequence_expand_as(x=x, y=y)
......@@ -8354,9 +8356,9 @@ shape算子
.. code-block:: python
input = layers.data(
input = fluid.layers.data(
name="input", shape=[3, 100, 100], dtype="float32")
out = layers.shape(input)
out = fluid.layers.shape(input)
......@@ -8371,7 +8373,7 @@ shuffle_channel
**Shuffle Channel 运算（通道重排运算）**
该运算符将输入 ``x`` 的通道混洗重排。 它将每个组中的输入通道分成 ``group`` 个子组，并通过逐个从每个子组中选择元素来获得新的顺序。
该算子将输入 ``x`` 的通道混洗重排。 它将每个组中的输入通道分成 ``group`` 个子组，并通过逐个从每个子组中选择元素来获得新的顺序。
请参阅 https://arxiv.org/pdf/1707.01083.pdf
......@@ -8645,10 +8647,10 @@ slice算子。
ends = [3, 3, 4]
axes = [0, 1, 2]
input = layers.data(
input = fluid.layers.data(
name="input", shape=[3, 4, 5, 6], dtype='float32')
out = layers.slice(input, axes=axes, starts=starts, ends=ends)
out = fluid.layers.slice(input, axes=axes, starts=starts, ends=ends)
......@@ -8966,9 +8968,9 @@ square_error_cost
.. code-block:: python
y = layers.data(name='y', shape=[1], dtype='float32')
y_predict = layers.data(name='y_predict', shape=[1], dtype='float32')
cost = layers.square_error_cost(input=y_predict, label=y)
y = fluid.layers.data(name='y', shape=[1], dtype='float32')
y_predict = fluid.layers.data(name='y_predict', shape=[1], dtype='float32')
cost = fluid.layers.square_error_cost(input=y_predict, label=y)
......@@ -9018,8 +9020,8 @@ squeeze
.. code-block:: python
x = layers.data(name='x', shape=[5, 1, 10])
y = layers.sequeeze(input=x, axes=[1])
x = fluid.layers.data(name='x', shape=[5, 1, 10])
y = fluid.layers.sequeeze(input=x, axes=[1])
......@@ -9104,10 +9106,10 @@ sum
sum算子。
该运算符对输入张量求和。所有输入都可以携带LoD（详细程度）信息，但是输出仅与第一个输入共享LoD信息。
该算子对输入张量求和。所有输入都可以携带LoD（详细程度）信息，但是输出仅与第一个输入共享LoD信息。
参数：
- **x** （Variable）- （vector <Tensor>）sum运算符的输入张量（Tensor）。
- **x** （Variable）- （vector <Tensor>）sum算子的输入张量（Tensor）。
返回: (Tensor）求和算子的输出张量。
......@@ -9118,8 +9120,8 @@ sum算子。
.. code-block:: python
input = layers.data(name="input", shape=[13, 11], dtype='float32')
out = layers.sum(input)
input = fluid.layers.data(name="input", shape=[13, 11], dtype='float32')
out = fluid.layers.sum(input)
......@@ -9200,7 +9202,7 @@ topk
-------------------------------
.. py:function:: paddle.fluid.layers.topk(input, k, name=None)
这个运算符用于查找最后一维的前k个最大项，返回它们的值和索引。
这个算子用于查找最后一维的前k个最大项，返回它们的值和索引。
如果输入是（1-D Tensor），则找到向量的前k最大项，并以向量的形式输出前k最大项的值和索引。values[j]是输入中第j最大项，其索引为indices[j]。
如果输入是更高阶的张量，则该operator会基于最后一维计算前k项
......@@ -9242,7 +9244,7 @@ topk
.. code-block:: python
top5_values, top5_indices = layers.topk(input, k=5)
top5_values, top5_indices = fluid.layers.topk(input, k=5)
......@@ -9280,7 +9282,7 @@ transpose
# 在数据张量中添加多余的batch大小维度
x = fluid.layers.data(name='x', shape=[5, 10, 15],
dtype='float32', append_batch_size=False)
x_transposed = layers.transpose(x, perm=[1, 0, 2])
x_transposed = fluid.layers.transpose(x, perm=[1, 0, 2])
......@@ -9316,21 +9318,21 @@ tree_conv
.. code-block:: python
nodes_vector = layers.data(name='vectors', shape=[None, 10, 5], dtype='float32)
nodes_vector = fluid.layers.data(name='vectors', shape=[None, 10, 5], dtype='float32)
# batch size为None, 10代表数据集最大节点大小max_node_size,5表示向量宽度
edge_set = layers.data(name='edge_set', shape=[None, 10, 2], dtype='float32')
edge_set = fluid.layers.data(name='edge_set', shape=[None, 10, 2], dtype='float32')
# None 代表batch size, 10 代表数据集的最大节点大小max_node_size, 2 代表每条边连接两个节点
# 边必须为有向边
out_vector = layers.tree_conv(nodes_vector, edge_set, 6, 1, 2, 'tanh',
out_vector = fluid.layers.tree_conv(nodes_vector, edge_set, 6, 1, 2, 'tanh',
ParamAttr(initializer=Constant(1.0), ParamAttr(initializer=Constant(1.0))
# 输出的形会是[None, 10, 6, 1],
# None 代表batch size, 10数据集的最大节点大小max_node_size, 6 代表输出大小output size, 1 代表 1 个filter
out_vector = layers.reshape(out_vector, shape=[None, 10, 6])
out_vector = fluid.layers.reshape(out_vector, shape=[None, 10, 6])
# reshape之后, 输出张量output tensor为下一个树卷积的nodes_vector
out_vector_2 = layers.tree_conv(out_vector, edge_set, 3, 4, 2, 'tanh',
out_vector_2 = fluid.layers.tree_conv(out_vector, edge_set, 3, 4, 2, 'tanh',
ParamAttr(initializer=Constant(1.0), ParamAttr(initializer=Constant(1.0))
# 输出tensor也可以用来池化(论文中称为global pooling)
pooled = layers.reduce_max(out_vector, dims=2) # global 池化
pooled = fluid.layers.reduce_max(out_vector, dims=2) # global 池化
......@@ -9354,7 +9356,7 @@ uniform_random_batch_size_like
uniform_random_batch_size_like算子。
此运算符使用与输入张量（Tensor）相同的batch_size初始化张量（Tensor），并使用从均匀分布中采样的随机值。
此算子使用与输入张量（Tensor）相同的batch_size初始化张量（Tensor），并使用从均匀分布中采样的随机值。
参数：
- **input** （Variable）- 其input_dim_idx'th维度指定batch_size的张量（Tensor）。
......@@ -9363,7 +9365,7 @@ uniform_random_batch_size_like算子。
- **output_dim_idx** （Int）- 默认值0.输出批量大小维度的索引。
- **min** （Float）- （默认 1.0）均匀随机的最小值。
- **max** （Float）- （默认 1.0）均匀随机的最大值。
- **seed** （Int）- （int，default 0）用于生成样本的随机种子。0表示使用系统生成的种子。注意如果seed不为0，则此运算符将始终每次生成相同的随机数。
- **seed** （Int）- （int，default 0）用于生成样本的随机种子。0表示使用系统生成的种子。注意如果seed不为0，则此算子将始终每次生成相同的随机数。
- **dtype** （np.dtype | core.VarDesc.VarType | str） - 数据类型：float32，float_16，int等。
返回: 指定形状的张量（Tensor）将使用指定值填充。
......@@ -9376,8 +9378,8 @@ uniform_random_batch_size_like算子。
.. code-block:: python
input = layers.data(name="input", shape=[13, 11], dtype='float32')
out = layers.uniform_random_batch_size_like(input, [-1, 11])
input = fluid.layers.data(name="input", shape=[13, 11], dtype='float32')
out = fluid.layers.uniform_random_batch_size_like(input, [-1, 11])
......@@ -9408,8 +9410,8 @@ unsqueeze
.. code-block:: python
x = layers.data(name='x', shape=[5, 10])
y = layers.unsequeeze(input=x, axes=[1])
x = fluid.layers.data(name='x', shape=[5, 10])
y = fluid.layers.unsequeeze(input=x, axes=[1])
......@@ -9461,7 +9463,7 @@ unstack
warpctc
-------------------------------
.. py:function:: paddle.fluid.layers.warpctc(input, label, blank=0, norm_by_times=False, use_cudnn=False))
.. py:function:: paddle.fluid.layers.warpctc(input, label, blank=0, norm_by_times=False, use_cudnn=False)
该操作符集成了 `开源Warp-CTC库 <https://github.com/baidu-research/warp-ctc>`_ ，计算基于神经网络的时序类分类（CTC）损失。原生softmax激活函数集成到Wrap-CTC库中，操作符也可称作含CTC的softmax，将输入张量每一行的值正则化。
......@@ -9512,9 +9514,9 @@ abs
out = |x|
参数:
- **x** - abs运算符的输入
- **x** - abs算子的输入
返回： Abs运算符的输出。
返回： Abs算子的输出。
......@@ -9533,7 +9535,7 @@ ceil
.. py:function:: paddle.fluid.layers.ceil(x, name=None)
天花板运算激活函数。
向上取整运算激活函数。
.. math::
out = \left \lceil x \right \rceil
......@@ -9541,9 +9543,9 @@ ceil
参数:
- **x** - Ceil运算符的输入
- **x** - Ceil算子的输入
返回： Ceil运算符的输出。
返回： Ceil算子的输出。
......@@ -9570,10 +9572,10 @@ Cosine余弦激活函数。
参数:
- **x** - cos运算符的输入
- **x** - cos算子的输入
返回： Cos运算符的输出
返回： Cos算子的输出
......@@ -9589,7 +9591,7 @@ Cosine余弦激活函数。
cumsum
-------------------------------
.. py:function:: paddle.fluid.layers.cumsum(x,axis=None,exclusive=None,reverse=None
.. py:function:: paddle.fluid.layers.cumsum(x,axis=None,exclusive=None,reverse=None)
沿给定轴的元素的累加和。默认结果的第一个元素和输入的第一个元素一致。如果exlusive为真，结果的第一个元素则为0。
......@@ -9629,7 +9631,7 @@ Exp激活函数(Exp指以自然常数e为底的指数运算)。
out = e^x
参数:
- **x** - Exp运算符的输入
- **x** - Exp算子的输入
返回： Exp算子的输出
......@@ -9651,17 +9653,17 @@ floor
.. py:function:: paddle.fluid.layers.floor(x, name=None)
地板运算激活函数。
向下取整运算激活函数。
.. math::
out = \left \lfloor x \right \rfloor
参数:
- **x** - Floor运算符的输入
- **x** - Floor算子的输入
返回： Floor运算符的输出。
返回： Floor算子的输出。
......@@ -9728,9 +9730,9 @@ Logsigmoid激活函数。
参数:
- **x** - LogSigmoid运算符的输入
- **x** - LogSigmoid算子的输入
返回： LogSigmoid运算符的输出
返回： LogSigmoid算子的输出
......@@ -9755,9 +9757,9 @@ Reciprocal（取倒数）激活函数
out = \frac{1}{x}
参数:
- **x** - Ceil运算符的输入
- **x** - reciprocal算子的输入
返回： Reciprocal运算符的输出。
返回： Reciprocal算子的输出。
......@@ -9786,9 +9788,9 @@ Round取整激活函数。
参数:
- **x** - Ceil运算符的输入
- **x** - round算子的输入
返回： Round运算符的输出。
返回： Round算子的输出。
......@@ -9813,7 +9815,7 @@ sigmoid激活函数
参数:
- **x** - Sigmoid运算符的输入
- **x** - Sigmoid算子的输入
返回： Sigmoid运算输出.
......@@ -9840,10 +9842,10 @@ sin
参数:
- **x** - sin运算符的输入
- **x** - sin算子的输入
返回： Sin运算符的输出。
返回： Sin算子的输出。
......@@ -9900,7 +9902,7 @@ Softshrink激活算子
- **x** - Softshrink算子的输入
- **lambda** （FLOAT）- 非负偏移量。
返回： Softshrink运算符的输出
返回： Softshrink算子的输出
......@@ -9916,7 +9918,7 @@ Softshrink激活算子
softsign
-------------------------------
.. py:function:: Paddle.fluid.layers.softsign(x,name=None)
.. py:function:: paddle.fluid.layers.softsign(x,name=None)
softsign激活函数。
......@@ -9951,7 +9953,7 @@ sqrt
out = \sqrt{x}
参数:
- **x** - Sqrt运算符的输入
- **x** - Sqrt算子的输入
返回： Sqrt算子的输出。
......@@ -10008,7 +10010,7 @@ tanh 激活函数。
参数:
- **x** - Tanh运算符的输入
- **x** - Tanh算子的输入
返回： Tanh算子的输出。
......@@ -10035,7 +10037,7 @@ tanh_shrink激活函数。
out = x - \frac{e^{x} - e^{-x}}{e^{x} + e^{-x}}
参数:
- **x** - TanhShrink运算符的输入
- **x** - TanhShrink算子的输入
返回： tanh_shrink算子的输出
......@@ -10089,7 +10091,7 @@ ThresholdedRelu激活函数
uniform_random
-------------------------------
.. py:function:: Paddle.fluid.layers.uniform_random(shape,dtype=None,min=None,max=None,seed=None)
.. py:function:: paddle.fluid.layers.uniform_random(shape,dtype=None,min=None,max=None,seed=None)
该操作符初始化一个张量，该张量的值是从均匀分布中抽样的随机值
参数：
......@@ -10127,7 +10129,7 @@ uniform_random
argmax
-------------------------------
.. py:function:: paddle.fluid.layers.argmin(x,axis=0)
.. py:function:: paddle.fluid.layers.argmax(x,axis=0)
**argmax**
......@@ -10686,12 +10688,12 @@ sums
tmp = fluid.layers.zeros(shape=[10], dtype='int32')
i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
a0 = layers.array_read(array=tmp, i=i)
i = layers.increment(x=i)
a1 = layers.array_read(array=tmp, i=i)
mean_a0 = layers.mean(a0)
mean_a1 = layers.mean(a1)
a_sum = layers.sums(input=[mean_a0, mean_a1])
a0 = fluid.layers.array_read(array=tmp, i=i)
i = fluid.layers.increment(x=i)
a1 = fluid.layers.array_read(array=tmp, i=i)
mean_a0 = fluid.layers.mean(a0)
mean_a1 = fluid.layers.mean(a1)
a_sum = fluid.layers.sums(input=[mean_a0, mean_a1])
......@@ -11124,7 +11126,7 @@ bipartite_match
.. py:function:: paddle.fluid.layers.bipartite_match(dist_matrix, match_type=None, dist_threshold=None, name=None)
该算子实现了贪心二分匹配算法，该算法用于根据输入距离矩阵获得与最大距离的匹配。对于输入二维矩阵，二分匹配算法可以找到每一行的匹配列（匹配意味着最大距离），也可以找到每列的匹配行。此运算符仅计算列到行的匹配索引。对于每个实例，匹配索引的数量是输入距离矩阵的列号。
该算子实现了贪心二分匹配算法，该算法用于根据输入距离矩阵获得与最大距离的匹配。对于输入二维矩阵，二分匹配算法可以找到每一行的匹配列（匹配意味着最大距离），也可以找到每列的匹配行。此算子仅计算列到行的匹配索引。对于每个实例，匹配索引的数量是输入距离矩阵的列号。
它有两个输出，匹配的索引和距离。简单的描述是该算法将最佳（最大距离）行实体与列实体匹配，并且匹配的索引在ColToRowMatchIndices的每一行中不重复。如果列实体与任何行实体不匹配，则ColToRowMatchIndices设置为-1。
......@@ -11217,7 +11219,7 @@ box_clip
box_coder
-------------------------------
.. py:function:: paddle.fluid.layers.box_coder(prior_box, prior_box_var, target_box, code_type='encode_center_size', box_normalized=True, name=None)
.. py:function:: paddle.fluid.layers.box_coder(prior_box, prior_box_var, target_box, code_type='encode_center_size', box_normalized=True, name=None, axis=0)
Bounding Box Coder
......@@ -11381,9 +11383,9 @@ density prior box的量由fixed_sizes and fixed_ratios决定。显然地，fixed
detection_map
-------------------------------
.. py:function:: paddle.fluid.layers.detection_map(detect_res, label, function_num, background_label=0, overlap_threshold=0.3, evaluate_difficult=True, has_state=None, input_states=None, out_states=None, ap_version='integral')
.. py:function:: paddle.fluid.layers.detection_map(detect_res, label, class_num, background_label=0, overlap_threshold=0.3, evaluate_difficult=True, has_state=None, input_states=None, out_states=None, ap_version='integral')
检测mAP评估运算符。一般步骤如下：首先，根据检测输入和标签计算TP（true positive）和FP（false positive），然后计算mAP评估值。支持'11 point'和积分mAP算法。请从以下文章中获取更多信息：
检测mAP评估算子。一般步骤如下：首先，根据检测输入和标签计算TP（true positive）和FP（false positive），然后计算mAP评估值。支持'11 point'和积分mAP算法。请从以下文章中获取更多信息：
https://sanchom.wordpress.com/tag/average-precision/
......@@ -11482,13 +11484,13 @@ Detection Output Layer for Single Shot Multibox Detector(SSD)
.. code-block:: python
pb = layers.data(name='prior_box', shape=[10, 4],
pb = fluid.layers.data(name='prior_box', shape=[10, 4],
append_batch_size=False, dtype='float32')
pbv = layers.data(name='prior_box_var', shape=[10, 4],
pbv = fluid.layers.data(name='prior_box_var', shape=[10, 4],
append_batch_size=False, dtype='float32')
loc = layers.data(name='target_box', shape=[2, 21, 4],
loc = fluid.layers.data(name='target_box', shape=[2, 21, 4],
append_batch_size=False, dtype='float32')
scores = layers.data(name='scores', shape=[2, 21, 10],
scores = fluid.layers.data(name='scores', shape=[2, 21, 10],
append_batch_size=False, dtype='float32')
nmsed_outs = fluid.layers.detection_output(scores=scores,
loc=loc,
......@@ -11508,7 +11510,7 @@ generate_mask_labels
**为Mask-RCNN生成mask标签**
对于给定的 RoI (Regions of Interest) 和相应的标签，该运算符可以对前景RoI进行采样。 该mask branch对每个前景RoI还具有 :math:`K*M^{2}` 维输出目标，用于编码分辨率为M×M的K个二进制mask，K个种类中的各种类分别对应一个这样的二进制mask。 此mask输出目标用于计算掩码分支的损失。
对于给定的 RoI (Regions of Interest) 和相应的标签，该算子可以对前景RoI进行采样。 该mask branch对每个前景RoI还具有 :math:`K*M^{2}` 维输出目标，用于编码分辨率为M×M的K个二进制mask，K个种类中的各种类分别对应一个这样的二进制mask。 此mask输出目标用于计算掩码分支的损失。
请注意groud-truth（真实值，下简称GT）分段的数据格式。假设分段如下， 第一个实例有两个GT对象。 第二个实例有一个GT对象，该对象有两个GT分段。
......@@ -11587,7 +11589,7 @@ generate_mask_labels
generate_proposal_labels
-------------------------------
.. py:function:: paddle.fluid.layers.generate_proposal_labels(rpn_rois, gt_functiones, is_crowd, gt_boxes, im_info, batch_size_per_im=256, fg_fraction=0.25, fg_thresh=0.25, bg_thresh_hi=0.5, bg_thresh_lo=0.0, bbox_reg_weights=[0.1, 0.1, 0.2, 0.2], function_nums=None, use_random=True)
.. py:function:: paddle.fluid.layers.generate_proposal_labels(rpn_rois, gt_classes, is_crowd, gt_boxes, im_info, batch_size_per_im=256, fg_fraction=0.25, fg_thresh=0.25, bg_thresh_hi=0.5, bg_thresh_lo=0.0, bbox_reg_weights=[0.1, 0.1, 0.2, 0.2], class_nums=None, use_random=True)
**该函数可以应用于 Faster-RCNN 网络，生成建议标签。**
......@@ -11710,7 +11712,7 @@ iou_similarity
multi_box_head
-------------------------------
.. py:function:: paddle.fluid.layers.multi_box_head(inputs, image, base_size, num_functiones, aspect_ratios, min_ratio=None, max_ratio=None, min_sizes=None, max_sizes=None, steps=None, step_w=None, step_h=None, offset=0.5, variance=[0.1, 0.1, 0.2, 0.2], flip=True, clip=False, kernel_size=1, pad=0, stride=1, name=None, min_max_aspect_ratios_order=False)
.. py:function:: paddle.fluid.layers.multi_box_head(inputs, image, base_size, num_classes, aspect_ratios, min_ratio=None, max_ratio=None, min_sizes=None, max_sizes=None, steps=None, step_w=None, step_h=None, offset=0.5, variance=[0.1, 0.1, 0.2, 0.2], flip=True, clip=False, kernel_size=1, pad=0, stride=1, name=None, min_max_aspect_ratios_order=False)
生成SSD（Single Shot MultiBox Detector）算法的候选框。有关此算法的详细信息，请参阅SSD论文 `SSD：Single Shot MultiBox Detector <https://arxiv.org/abs/1512.02325>`_ 的2.2节。
......@@ -11779,7 +11781,7 @@ multiclass_nms
该运算用于对边界框（bounding box）和评分进行多类非极大值抑制（NMS）。
在NMS中，如果提供 ``score_threshold`` 阈值，则此运算符贪婪地选择具有高于 ``score_threshold`` 的高分数的检测边界框（bounding box）的子集，然后如果nms_top_k大于-1，则选择最大的nms_top_k置信度分数。 接着，该运算符基于 ``nms_threshold`` 和 ``nms_eta`` 参数，通过自适应阈值NMS移去与已经选择的框具有高IOU（intersection over union）重叠的框。
在NMS中，如果提供 ``score_threshold`` 阈值，则此算子贪婪地选择具有高于 ``score_threshold`` 的高分数的检测边界框（bounding box）的子集，然后如果nms_top_k大于-1，则选择最大的nms_top_k置信度分数。 接着，该算子基于 ``nms_threshold`` 和 ``nms_eta`` 参数，通过自适应阈值NMS移去与已经选择的框具有高IOU（intersection over union）重叠的框。
在NMS步骤后，如果keep_top_k大于-1，则每个图像最多保留keep_top_k个总bbox数。
......@@ -11861,7 +11863,7 @@ PolygonBoxTransform 算子。
prior_box
-------------------------------
.. py:function:: paddle.fluid.layers.prior_box(input,image,min_sizes=None,aspect_ratios=[1.0],variance=[0.1,0.1,0.2,0.2],flip=False,clip=False,steps=[0.0,0.0],offset=0.5,name=None,min_max_aspect_ratios_order=False)
.. py:function:: paddle.fluid.layers.prior_box(input,image,min_sizes=None,max_sizes=None,aspect_ratios=[1.0],variance=[0.1,0.1,0.2,0.2],flip=False,clip=False,steps=[0.0,0.0],offset=0.5,name=None,min_max_aspect_ratios_order=False)
**Prior Box Operator**
......@@ -11997,13 +11999,13 @@ rpn_target_assign
.. code-block:: python
bbox_pred = layers.data(name=’bbox_pred’, shape=[100, 4],
bbox_pred = fluid.layers.data(name=’bbox_pred’, shape=[100, 4],
append_batch_size=False, dtype=’float32’)
cls_logits = layers.data(name=’cls_logits’, shape=[100, 1],
cls_logits = fluid.layers.data(name=’cls_logits’, shape=[100, 1],
append_batch_size=False, dtype=’float32’)
anchor_box = layers.data(name=’anchor_box’, shape=[20, 4],
anchor_box = fluid.layers.data(name=’anchor_box’, shape=[20, 4],
append_batch_size=False, dtype=’float32’)
gt_boxes = layers.data(name=’gt_boxes’, shape=[10, 4],
gt_boxes = fluid.layers.data(name=’gt_boxes’, shape=[10, 4],
append_batch_size=False, dtype=’float32’)
loc_pred, score_pred, loc_target, score_target, bbox_inside_weight=
fluid.layers.rpn_target_assign(bbox_pred=bbox_pred,
......@@ -12162,9 +12164,9 @@ target_assign
.. code-block:: python
matched_indices, matched_dist = fluid.layers.bipartite_match(iou)
gt = layers.data(
gt = fluid.layers.data(
name='gt', shape=[1, 1], dtype='int32', lod_level=1)
trg, trg_weight = layers.target_assign(
trg, trg_weight = fluid.layers.target_assign(
gt, matched_indices, mismatch_value=0)
......
doc/fluid/api_cn/metrics_cn.rst
浏览文件 @ 60acca73
......@@ -105,7 +105,7 @@ ChunkEvaluator
labels = fluid.layers.data(name="data", shape=[1], dtype="int32")
data = fluid.layers.data(name="data", shape=[32, 32], dtype="int32")
pred = fluid.layers.fc(input=data, size=1000, act="tanh")
precision, recall, f1_score, num_infer_chunks, num_label_chunks, num_correct_chunks = layers.chunk_eval(
precision, recall, f1_score, num_infer_chunks, num_label_chunks, num_correct_chunks = fluid.layers.chunk_eval(
input=pred,
label=label)
metric = fluid.metrics.ChunkEvaluator()
......
doc/fluid/api_cn/optimizer_cn.rst
浏览文件 @ 60acca73
......@@ -331,7 +331,7 @@ LarsMomentum
LarsMomentumOptimizer
-------------------------------
.. py:function:: paddle.fluid.optimizer.LarsMomentumOptimizer(learning_rate, momentum, lars_coeff=0.001, lars_weight_decay=0.0005, regularization=None, name=None)
.. py:class:: paddle.fluid.optimizer.LarsMomentumOptimizer(learning_rate, momentum, lars_coeff=0.001, lars_weight_decay=0.0005, regularization=None, name=None)
LARS支持的Momentum优化器
......
doc/fluid/api_guides/index.rst
浏览文件 @ 60acca73
......@@ -18,3 +18,6 @@ API使用指南分功能向您介绍PaddlePaddle Fluid的API体系和用法，
low_level/memory_optimize.rst
low_level/nets.rst
low_level/parallel_executor.rst
low_level/backward.rst
low_level/parameter.rst
low_level/program.rst
doc/fluid/api_guides/index_en.rst
浏览文件 @ 60acca73
......@@ -18,3 +18,6 @@ This section introduces the Fluid API structure and usage, to help you quickly g
low_level/memory_optimize_en.rst
low_level/nets_en.rst
low_level/parallel_executor_en.rst
low_level/backward_en.rst
low_level/parameter_en.rst
low_level/program_en.rst
doc/fluid/api_guides/low_level/backward_en.rst 0 → 100644
浏览文件 @ 60acca73
.. _api_guide_backward_en:
################
Back Propagation
################
The ability of neural network to define model depends on optimization algorithm. Optimization is a process of calculating gradient continuously and adjusting learnable parameters. You can refer to :ref:`api_guide_optimizer_en` to learn more about optimization algorithm in Fluid.
In the training process of network, gradient calculation is divided into two steps: forward computing and `back propagation <https://en.wikipedia.org/wiki/Backpropagation>`_ .
Forward computing transfers the state of the input unit to the output unit according to the network structure you build.
Back propagation calculates the derivatives of two or more compound functions by means of `chain rule <https://en.wikipedia.org/wiki/Chain_rule>`_ . The gradient of output unit is propagated back to input unit. According to the calculated gradient, the learning parameters of the network are adjusted.
You could refer to `back propagation algorithm <http://deeplearning.stanford.edu/wiki/index.php/%E5%8F%8D%E5%90%91%E4%BC%A0%E5%AF%BC%E7%AE%97%E6%B3%95>`_ for detialed implementation process.
We do not recommend directly calling backpropagation-related APIs in :code:`fluid` , as these are very low-level APIs. Consider using the relevant APIs in :ref:`api_guide_optimizer_en` instead. When you use optimizer APIs, Fluid automatically calculates the complex back-propagation for you.
If you want to implement it by yourself, you can also use: :code:`callback` in :ref:`api_fluid_backward_append_backward` to define the customized gradient form of Operator.
For more information, please refer to: :ref:`api_fluid_backward_append_backward`
doc/fluid/api_guides/low_level/parameter.rst
浏览文件 @ 60acca73
......@@ -4,7 +4,7 @@
模型参数
#########
模型参数为模型中的weight和bias统称，在fluid中对应fluid.Parameter类，继承自fluid.Variable，是一种可持久化的variable。模型的训练就是不断学习更新模型参数的过程。模型参数相关的属性可以通过 :ref:`cn_api_fluid_param_attr_ParamAttr` 来配置，可配置内容有：
模型参数为模型中的weight和bias统称，在fluid中对应fluid.Parameter类，继承自fluid.Variable，是一种可持久化的variable。模型的训练就是不断学习更新模型参数的过程。模型参数相关的属性可以通过 :ref:`cn_api_fluid_ParamAttr` 来配置，可配置内容有：
- 初始化方式
- 正则化
......
doc/fluid/api_guides/low_level/parameter_en.rst 0 → 100644
浏览文件 @ 60acca73
.. _api_guide_parameter_en:
##################
Model Parameters
##################
Model parameters are weights and biases in a model. In fluid, they are instances of ``fluid.Parameter`` class which is inherited from fluid, and they are all persistable variables. Model training is a process of learning and updating model parameters. The attributes related to model parameters can be configured by :ref:`api_fluid_ParamAttr` . The configurable contents are as follows:
- Initialization method
- Regularization
- gradient clipping
- Model Average
Initialization method
========================
Fluid initializes a single parameter by setting attributes of :code:`initializer` in :code:`ParamAttr` .
examples：
.. code-block:: python
param_attrs = fluid.ParamAttr(name="fc_weight",
initializer=fluid.initializer.ConstantInitializer(1.0))
y_predict = fluid.layers.fc(input=x, size=10, param_attr=param_attrs)
The following is the initialization method supported by fluid:
1. BilinearInitializer
-----------------------
Linear initialization. The deconvolution operation initialized by this method can be used as a linear interpolation operation.
Alias：Bilinear
API reference： :ref:`api_fluid_initializer_BilinearInitializer`
2. ConstantInitializer
--------------------------
Constant initialization. Initialize the parameter to the specified value.
Alias：Constant
API reference： :ref:`api_fluid_initializer_ConstantInitializer`
3. MSRAInitializer
----------------------
Please refer to https://arxiv.org/abs/1502.01852 for initialization.
Alias：MSRA
API reference： :ref:`api_fluid_initializer_MSRAInitializer`
4. NormalInitializer
-------------------------
Initialization method of random Gaussian distribution.
Alias：Normal
API reference： :ref:`api_fluid_initializer_NormalInitializer`
5. TruncatedNormalInitializer
---------------------------------
Initialization method of stochastic truncated Gauss distribution.
Alias：TruncatedNormal
API reference： :ref:`api_fluid_initializer_TruncatedNormalInitializer`
6. UniformInitializer
------------------------
Initialization method of random uniform distribution.
Alias：Uniform
API reference： :ref:`api_fluid_initializer_UniformInitializer`
7. XavierInitializer
------------------------
Please refer to http://proceedings.mlr.press/v9/glorot10a/glorot10a.pdf for initialization.
Alias：Xavier
API reference： :ref:`api_fluid_initializer_XavierInitializer`
Regularization
=================
Fluid regularizes a single parameter by setting attributes of :code:`regularizer` in :code:`ParamAttr` .
.. code-block:: python
param_attrs = fluid.ParamAttr(name="fc_weight",
regularizer=fluid.regularizer.L1DecayRegularizer(0.1))
y_predict = fluid.layers.fc(input=x, size=10, param_attr=param_attrs)
The following is the regularization approach supported by fluid:
- :ref:`api_fluid_regularizer_L1DecayRegularizer` (Alias：L1Decay)
- :ref:`api_fluid_regularizer_L2DecayRegularizer` (Alias：L2Decay)
Clipping
==========
Fluid sets clipping method for a single parameter by setting attributes of :code:`gradient_clip` in :code:`ParamAttr` .
.. code-block:: python
param_attrs = fluid.ParamAttr(name="fc_weight",
regularizer=fluid.regularizer.L1DecayRegularizer(0.1))
y_predict = fluid.layers.fc(input=x, size=10, param_attr=param_attrs)
The following is the clipping method supported by fluid:
1. ErrorClipByValue
----------------------
Used to clipping the value of a tensor to a specified range.
API reference： :ref:`api_fluid_clip_ErrorClipByValue`
2. GradientClipByGlobalNorm
------------------------------
Used to limit the global-norm of multiple Tensors to :code:`clip_norm`.
API reference： :ref:`api_fluid_clip_GradientClipByGlobalNorm`
3. GradientClipByNorm
------------------------
Limit the L2-norm of Tensor to :code:`max_norm` . If Tensor's L2-norm exceeds: :code:`max_norm` ,
it will calculate a :code:`scale` . And then all values of the Tensor multiply the :code:`scale` .
API reference： :ref:`api_fluid_clip_GradientClipByNorm`
4. GradientClipByValue
-------------------------
Limit the value of the gradient on a parameter to [min, max].
API reference： :ref:`api_fluid_clip_GradientClipByValue`
Model Averaging
================
Fluid determines whether to average a single parameter by setting attributes of :code:`do_model_average` in :code:`ParamAttr` .
Examples:
.. code-block:: python
param_attrs = fluid.ParamAttr(name="fc_weight",
do_model_average=true)
y_predict = fluid.layers.fc(input=x, size=10, param_attr=param_attrs)
In the miniBatch training process, parameters will be updated once after each batch, and the average model averages the parameters generated by the latest K updates.
The averaged parameters are only used for testing and prediction, and they do not get involved in the actual training process.
API reference :ref:`api_fluid_optimizer_ModelAverage`
doc/fluid/api_guides/low_level/program_en.rst 0 → 100644
浏览文件 @ 60acca73
.. _api_guide_Program_en:
###############################
Program/Block/Operator/Variable
###############################
==================
Program
==================
:code:`Fluid` describes neural network configuration in the form of abstract grammar tree similar to that of a programming language, and the user's description of computation will be written into a Program. Program in Fluid replaces the concept of models in traditional frameworks. It can describe any complex model through three execution structures: sequential execution, conditional selection and loop execution. Writing :code:`Program` is very close to writing a common program. If you have tried programming before, you will naturally apply your expertise to it.
In brief：
* A model is a Fluid :code:`Program` and can contain more than one :code:`Program` ;
* :code:`Program` consists of nested :code:`Block` , and the concept of :code:`Block` can be analogized to a pair of braces in C++ or Java, or an indentation block in Python.
* Computing in :code:`Block` is composed of three ways: sequential execution, conditional selection or loop execution, which constitutes complex computational logic.
* :code:`Block` contains descriptions of computation and computational objects. The description of computation is called Operator; the object of computation (or the input and output of Operator) is unified as Tensor. In Fluid, Tensor is represented by 0-leveled `LoD-Tensor <http://paddlepaddle.org/documentation/docs/zh/1.2/user_guides/howto/prepare_data/lod_tensor.html#permalink-4-lod-tensor>`_ .
=========
Block
=========
:code:`Block` is the concept of variable scope in advanced languages. In programming languages, Block is a pair of braces, which contains local variable definitions and a series of instructions or operators. Control flow structures :code:`if-else` and :code:`for` in programming languages can be equivalent to the following counterparts in deep learning:
+----------------------+-------------------------+
| programming languages| Fluid |
+======================+=========================+
| for, while loop | RNN,WhileOP |
+----------------------+-------------------------+
| if-else, switch | IfElseOp, SwitchOp |
+----------------------+-------------------------+
| execute sequentially | a series of layers |
+----------------------+-------------------------+
As mentioned above, :code:`Block` in Fluid describes a set of Operators that include sequential execution, conditional selection or loop execution, and the operating object of Operator: Tensor.
=============
Operator
=============
In Fluid, all operations of data are represented by :code:`Operator` . In Python, :code:`Operator` in Fluid is encapsulated into modules like :code:`paddle.fluid.layers` , :code:`paddle.fluid.nets` .
This is because some common operations on Tensor may consist of more basic operations. For simplicity, some encapsulation of the basic Operator is carried out inside the framework, including the creation of learnable parameters relied by an Operator, the initialization details of learnable parameters, and so on, so as to reduce the cost of further development.
More information can be read for reference. `Fluid Design Idea <../../advanced_usage/design_idea/fluid_design_idea.html>`_
=========
Variable
=========
In Fluid， :code:`Variable` can contain any type of value -- in most cases a LoD-Tensor.
All the learnable parameters in the model are kept in the memory space in form of :code:`Variable` . In most cases, you do not need to create the learnable parameters in the network by yourself. Fluid provides encapsulation for almost common basic computing modules of the neural network. Taking the simplest full connection model as an example, calling :code:`fluid.layers.fc` directly creates two learnable parameters for the full connection layer, namely, connection weight (W) and bias, without explicitly calling :code:`Variable` related interfaces to create learnable parameters.
==================
Related API
==================
* A single neural network configured by the user is called :ref:`api_fluid_Program` . It is noteworthy that when training neural networks, users often need to configure and operate multiple :code:`Program` . For example, :code:`Program` for parameter initialization, :code:`Program` for training, :code:`Program` for testing, etc.
* Users can also use :ref:`api_fluid_program_guard` with :code:`with` to modify the configured :ref:`api_fluid_default_startup_program` and :ref:`api_fluid_default_main_program` .
* In Fluid，the execution order in a Block is determined by control flow，such as :ref:`api_fluid_layers_IfElse` , :ref:`api_fluid_layers_While` and :ref:`api_fluid_layers_Switch` . For more information, please refer to： :ref:`api_guide_control_flow_en`
doc/fluid/user_guides/howto/evaluation_and_debugging/debug/visualdl.md 100755 → 100644
浏览文件 @ 60acca73
......@@ -48,12 +48,19 @@ VisualDL 目前支持以下组件：
可用于播放输入或生成的音频样本
### Graph
兼容 ONNX(Open Neural Network Exchange)[https://github.com/onnx/onnx], 通过与 python SDK的结合，VisualDL可以兼容包括 PaddlePaddle, pytorch, mxnet在内的大部分主流DNN平台。
VisualDL的graph支持paddle program的展示，同时兼容 ONNX(Open Neural Network Exchange)[https://github.com/onnx/onnx]，通过与 python SDK的结合，VisualDL可以兼容包括 PaddlePaddle, pytorch, mxnet在内的大部分主流DNN平台。
<p align="center">
<img src="https://raw.githubusercontent.com/daming-lu/large_files/master/graph_demo.gif" width="60%" />
<img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/docs/images/graph_demo.gif" width="60%" />
</p>
要进行paddle模型的展示，需要进行以下两步操作：
1. 在paddle代码中，调用`fluid.io.save_inference_model()`接口保存模型
2. 在命令行界面，使用`visualdl --model_pb [paddle_model_dir]` 加载paddle模型
### High Dimensional
用高维度数据映射在2D/3D来可视化嵌入
......@@ -235,3 +242,8 @@ board 还支持一下参数来实现远程的访问：
VisualDL 是由 [PaddlePaddle](http://www.paddlepaddle.org/) 和
[ECharts](http://echarts.baidu.com/) 合作推出的开源项目。我们欢迎所有人使用，提意见以及贡献代码。
## 更多细节
想了解更多关于VisualDL的使用介绍，请查看[文档](https://github.com/PaddlePaddle/VisualDL/tree/develop/demo)
doc/fluid/user_guides/howto/evaluation_and_debugging/debug/visualdl_en.md 100755 → 100644
浏览文件 @ 60acca73
......@@ -52,14 +52,21 @@ Image can be used to visualize any tensor or intermediate generated image.
Audio can be used to play input audio samples or generated audio samples.
### Graph
Graph is compatible with ONNX ([Open Neural Network Exchange](https://github.com/onnx/onnx)),
VisualDL graph supports displaying paddle model, furthermore is compatible with ONNX ([Open Neural Network Exchange](https://github.com/onnx/onnx)),
Cooperated with Python SDK, VisualDL can be compatible with most major DNN frameworks, including
PaddlePaddle, PyTorch and MXNet.
<p align="center">
<img src="https://raw.githubusercontent.com/daming-lu/large_files/master/graph_demo.gif" width="60%" />
<img src="https://raw.githubusercontent.com/PaddlePaddle/VisualDL/develop/docs/images/graph_demo.gif" width="60%" />
</p>
To display the paddle model, all you have to do is:
1. call the `fluid.io.save_inference_model()`interface to save paddle model
2. use `visualdl --model_pb [paddle_model_dir]` to load paddle model in command line
### High Dimensional
High Dimensional can be used to visualize data embeddings by projecting high-dimensional data into 2D / 3D.
......@@ -251,3 +258,8 @@ visualDL also supports following optional parameters:
VisualDL is initially created by [PaddlePaddle](http://www.paddlepaddle.org/) and
[ECharts](http://echarts.baidu.com/).
We welcome everyone to use, comment and contribute to Visual DL :)
## More details
For more details about how to use VisualDL, please take a look at [documents](https://github.com/PaddlePaddle/VisualDL/tree/develop/demo)
doc/fluid/user_guides/howto/prepare_data/feeding_data.rst
浏览文件 @ 60acca73
.. _user_guide_use_numpy_array_as_train_data:
###########################
使用Numpy Array作为训练数据
###########################
##############
同步数据读取
##############
PaddlePaddle Fluid支持使用 :code:`fluid.layers.data()` 配置数据层；
再使用 Numpy Array 或者直接使用Python创建C++的
......@@ -84,7 +84,7 @@ PaddlePaddle Fluid支持使用 :code:`fluid.layers.data()` 配置数据层；
exe.run(feed={
"sentence": create_lod_tensor(
data=numpy.array([1, 3, 4, 5, 3, 6, 8], dtype='int64').reshape(-1, 1),
lod=[4, 1, 2],
lod=[[4, 1, 2]],
place=fluid.CPUPlace()
)
})
......
doc/fluid/user_guides/howto/prepare_data/index.rst
浏览文件 @ 60acca73
......@@ -4,54 +4,104 @@
准备数据
########
PaddlePaddle Fluid支持两种传入数据的方式:
使用PaddlePaddle Fluid准备数据分为两个步骤：
1. Python Reader同步方式：用户需要使用 :code:`fluid.layers.data`
Step1: 自定义Reader生成训练/预测数据
###################################
生成的数据类型可以为Numpy Array或LoDTensor。根据Reader返回的数据形式的不同，可分为Batch级的Reader和Sample（样本）级的Reader。
Batch级的Reader每次返回一个Batch的数据，Sample级的Reader每次返回单个样本的数据
如果您的数据是Sample级的数据，我们提供了一个可以组建batch及数据预处理的工具：:code:`Python Reader` 。
Step2: 将数据送入网络进行训练/预测
###################################
Fluid提供两种方式，分别是同步Feed方式或异步py_reader接口方式，具体介绍如下：
- 同步Feed方式
用户需使用 :code:`fluid.layers.data`
配置数据输入层，并在 :code:`fluid.Executor` 或 :code:`fluid.ParallelExecutor`
中，使用 :code:`executor.run(feed=...)` 传入训练数据。
中使用 :code:`executor.run(feed=...)` 传入训练数据。数据准备和模型训练/预测的过程是同步进行的，
效率较低。
2. py_reader接口异步方式：用户需要先使用 :code:`fluid.layers.py_reader` 配置数据输入层，然后使用
- 异步py_reader接口方式
用户需要先使用 :code:`fluid.layers.py_reader` 配置数据输入层，然后使用
:code:`py_reader` 的 :code:`decorate_paddle_reader` 或 :code:`decorate_tensor_provider`
方法配置数据源，再通过 :code:`fluid.layers.read_file` 读取数据。
方法配置数据源，再通过 :code:`fluid.layers.read_file` 读取数据。数据传入与模型训练/预测过程是异步进行的，
效率较高。
这两种准备数据方法的比较如下:
======== ================================= =====================================
对比项 Python Reader同步方式 py_reader接口异步方式
对比项 同步Feed方式 异步py_reader接口方式
======== ================================= =====================================
API接口 :code:`executor.run(feed=...)` :code:`fluid.layers.py_reader`
数据格式 Numpy Array Numpy Array或LoDTensor
数据格式 Numpy Array或LoDTensor Numpy Array或LoDTensor
数据增强 Python端使用其他库完成 Python端使用其他库完成
速度 慢 快
推荐用途 调试模型 工业训练
======== ================================= =====================================
Python Reader同步方式
#####################
Reader数据类型对使用方式的影响
###############################
Fluid提供Python Reader方式传入数据。
Python Reader是纯的Python端接口，数据传入与模型训练/预测过程是同步的。用户可通过Numpy Array传入
数据，具体请参考:
根据Reader数据类型的不同，上述Step1和Step2的具体操作将有所不同，具体介绍如下:
.. toctree::
:maxdepth: 1
读取Sample级Reader数据
+++++++++++++++++++++
feeding_data.rst
若自定义的Reader每次返回单个样本的数据，用户需通过以下步骤完成数据送入：
Python Reader支持组batch、shuffle等高级功能，具体请参考：
Step1. 组建数据
=============================
调用Fluid提供的Reader相关接口完成组batch和部分的数据预处理功能，具体请参见：
.. toctree::
:maxdepth: 1
reader_cn.md
py_reader接口异步方式
#####################
Step2. 送入数据
=================================
若使用同步Feed方式送入数据，请使用DataFeeder接口将Reader数据转换为LoDTensor格式后送入网络，具体请参见 :ref:`cn_api_fluid_DataFeeder`
若使用异步py_reader接口方式送入数据，请调用 :code:`decorate_paddle_reader` 接口完成，具体请参见：
Fluid提供PyReader异步数据传入方式，数据传入与模型训练/预测过程是异步的，效率较高。具体请参考：
- :ref:`user_guides_use_py_reader`
读取Batch级Reader数据
+++++++++++++++++++++++
Step1. 组建数据
=================
由于Batch已经组好，已经满足了Step1的条件，可以直接进行Step2
Step2. 送入数据
=================================
若使用同步Feed方式送入数据，具体请参见:
.. toctree::
:maxdepth: 1
feeding_data.rst
若使用异步py_reader接口方式送入数据，请调用py_reader的 :code:`decorate_tensor_provider` 接口完成，具体方式请参见:
.. toctree::
:maxdepth: 1
use_py_reader.rst
doc/fluid/user_guides/howto/prepare_data/reader_cn.md
浏览文件 @ 60acca73
# Python Reader
在模型训练和预测阶段，PaddlePaddle程序需要读取训练或预测数据。为了帮助用户编写数据读取的代码，我们提供了如下接口：
# 数据预处理工具
- *reader*: 用于读取数据的函数，数据可来自于文件、网络、随机数生成器等，函数每次返回一个数据项。
在模型训练和预测阶段，PaddlePaddle程序需要读取训练或预测数据。为了帮助您编写数据读取的代码，我们提供了如下接口：
- *reader*: 样本级的reader，用于读取数据的函数，数据可来自于文件、网络、随机数生成器等，函数每次返回一个样本数据项。
- *reader creator*: 接受一个或多个reader作为参数、返回一个新reader的函数。
- *reader decorator*: 一个函数，接受一个或多个reader，并返回一个reader。
- *batch reader*: 用于读取数据的函数，数据可来自于文件、网络、随机数生成器等，函数每次返回一个batch大小的数据项。
......@@ -185,15 +186,4 @@ def image_reader_creator(image_path, label_path, n):
# images_reader_creator创建一个reader
reader = image_reader_creator("/path/to/image_file", "/path/to/label_file", 1024)
paddle.train(paddle.batch(reader, 128), {"image":0, "label":1}, ...)
```
### `paddle.train`实现原理
实现`paddle.train`的示例如下：
```python
def train(batch_reader, mapping, batch_size, total_pass):
for pass_idx in range(total_pass):
for mini_batch in batch_reader(): # this loop will never end in online learning.
do_forward_backward(mini_batch, mapping)
```
doc/fluid/user_guides/howto/prepare_data/use_py_reader.rst
浏览文件 @ 60acca73
.. _user_guides_use_py_reader:
############################
使用PyReader读取训练和测试数据
############################
#############
异步数据读取
#############
除Python Reader方法外，我们提供了PyReader。PyReader的性能比 :ref:`user_guide_use_numpy_array_as_train_data` 更好，因为PyReader的数据读取和模型训练过程是异步进行的，且能与 :code:`double_buffer_reader` 配合以进一步提高数据读取性能。此外， :code:`double_buffer_reader` 负责异步完成CPU Tensor到GPU Tensor的转换，一定程度上提升了数据读取效率。
除同步Feed方式外，我们提供了PyReader。PyReader的性能比 :ref:`user_guide_use_numpy_array_as_train_data` 更好，因为PyReader的数据读取和模型训练过程是异步进行的，且能与 :code:`double_buffer_reader` 配合以进一步提高数据读取性能。此外， :code:`double_buffer_reader` 负责异步完成CPU Tensor到GPU Tensor的转换，一定程度上提升了数据读取效率。
创建PyReader对象
################################
......
doc/fluid/user_guides/howto/training/save_load_variables.rst
浏览文件 @ 60acca73
......@@ -7,14 +7,14 @@
模型变量分类
############
在PaddlePaddle Fluid中，所有的模型变量都用 :code:`fluid.framework.Variable()` 作为基类进行表示。
在PaddlePaddle Fluid中，所有的模型变量都用 :code:`fluid.framework.Variable()` 作为基类。
在该基类之下，模型变量主要可以分为以下几种类别：
1. 模型参数
模型参数是深度学习模型中被训练和学习的变量，在训练过程中，训练框架根据反向传播算法计算出每一个模型参数当前的梯度，
并用优化器根据梯度对参数进行更新。模型的训练过程本质上可以看做是模型参数不断迭代更新的过程。
模型参数是深度学习模型中被训练和学习的变量，在训练过程中，训练框架根据反向传播(backpropagation)算法计算出每一个模型参数当前的梯度，
并用优化器(optimizer)根据梯度对参数进行更新。模型的训练过程本质上可以看做是模型参数不断迭代更新的过程。
在PaddlePaddle Fluid中，模型参数用 :code:`fluid.framework.Parameter` 来表示，
这是一个 :code:`fluid.framework.Variable()` 的派生类，除了 :code:`fluid.framework.Variable()` 具有的各项性质以外，
这是一个 :code:`fluid.framework.Variable()` 的派生类，除了具有 :code:`fluid.framework.Variable()` 的各项性质以外，
:code:`fluid.framework.Parameter` 还可以配置自身的初始化方法、更新率等属性。
2. 长期变量
......@@ -33,7 +33,7 @@
################
根据用途的不同，我们需要保存的模型变量也是不同的。例如，如果我们只是想保存模型用来进行以后的预测，
那么只保存模型参数就够用了。但如果我们需要保存一个checkpoint以备将来恢复训练，
那么只保存模型参数就够用了。但如果我们需要保存一个checkpoint（检查点，类似于存档，存有复现目前模型的必要信息）以备将来恢复训练，
那么我们应该将各种长期变量都保存下来，甚至还需要记录一下当前的epoch和step的id。
因为一些模型变量虽然不是参数，但对于模型的训练依然必不可少。
......@@ -63,7 +63,8 @@
如何载入模型变量
################
与模型变量的保存相对应，我们提供了两套API来分别载入模型的参数和载入模型的长期变量。
与模型变量的保存相对应，我们提供了两套API来分别载入模型的参数和载入模型的长期变量，分别为保存、加载模型参数的 ``save_params()`` 、 ``load_params()`` 和
保存、加载长期变量的 ``save_persistables`` 、 ``load_persistables`` 。
载入模型用于对新样本的预测
==========================
......@@ -98,8 +99,9 @@
预测所用的模型与参数的保存：
##################
预测模型的保存和加载
##############################
预测引擎提供了存储预测模型 :code:`fluid.io.save_inference_model` 和加载预测模型 :code:`fluid.io.load_inference_model` 两个接口。
- :code:`fluid.io.save_inference_model`：请参考 :ref:`api_guide_inference`。
......@@ -109,7 +111,8 @@
增量训练
############
增量训练指一个学习系统能不断地从新样本中学习新的知识，并能保存大部分以前已经学习到的知识。因此增量学习涉及到两点：在上一次训练结束的时候保存需要持久化的参数， 在下一次训练开始的时候加载上一次保存的持久化参数。 因此增量训练涉及到如下几个API:
增量训练指一个学习系统能不断地从新样本中学习新的知识，并能保存大部分以前已经学习到的知识。因此增量学习涉及到两点：在上一次训练结束的时候保存需要的长期变量， 在下一次训练开始的时候加载上一次保存的这些长期变量。 因此增量训练涉及到如下几个API:
:code:`fluid.io.save_persistables`、:code:`fluid.io.load_persistables` 。
单机增量训练
......@@ -152,14 +155,15 @@
多机增量（不带分布式大规模稀疏矩阵）训练的一般步骤为：
多机增量（不带分布式大规模稀疏矩阵）训练的一般步骤为
==========================
多机增量训练和单机增量训练有若干不同点：
1. 在训练的最后调用 :code:`fluid.io.save_persistables` 保存持久性参数时，不必要所有的trainer都调用这个方法，一般0号trainer来保存。
1. 在训练的最后调用 :code:`fluid.io.save_persistables` 保存长期变量时，不必要所有的trainer都调用这个方法来保存，一般0号trainer来保存即可。
2. 多机增量训练的参数加载在PServer端，trainer端不用加载参数。在PServer全部启动后，trainer会从PServer端同步参数。
多机增量（不启用分布式大规模稀疏矩阵）训练的一般步骤为：
多机增量（不带分布式大规模稀疏矩阵）训练的一般步骤为：
1. 0号trainer在训练的最后调用 :code:`fluid.io.save_persistables` 保存持久性参数到指定的 :code:`path` 下。
2. 通过HDFS等方式将0号trainer保存下来的所有的参数共享给所有的PServer(每个PServer都需要有完整的参数)。
......@@ -186,7 +190,7 @@
hadoop fs -mkdir /remote/$path
hadoop fs -put $path /remote/$path
上面的例子中，0号train通过调用 :code:`fluid.io.save_persistables` 函数，PaddlePaddle Fluid会从默认
上面的例子中，0号trainer通过调用 :code:`fluid.io.save_persistables` 函数，PaddlePaddle Fluid会从默认
:code:`fluid.Program` 也就是 :code:`prog` 的所有模型变量中找出长期变量，并将他们保存到指定的 :code:`path` 目录下。然后通过调用第三方的文件系统（如HDFS）将存储的模型进行上传到所有PServer都可访问的位置。
对于训练过程中待载入参数的PServer， 例如：
......
doc/fluid/user_guides/models/index_cn.rst
浏览文件 @ 60acca73
......@@ -112,7 +112,7 @@ kaldi 的解码器完成解码。
--------
机器翻译（Machine
Translation）将一种自然语言(源语言)转换成一种自然语言（目标语音），是自然语言处理中非常基础和重要的研究方向。在全球化的浪潮中，机器翻译在促进跨语言文明的交流中所起的重要作用是不言而喻的。其发展经历了统计机器翻译和基于神经网络的神经机器翻译(Nueural
Translation）将一种自然语言(源语言)转换成一种自然语言（目标语言），是自然语言处理中非常基础和重要的研究方向。在全球化的浪潮中，机器翻译在促进跨语言文明的交流中所起的重要作用是不言而喻的。其发展经历了统计机器翻译和基于神经网络的神经机器翻译(Nueural
Machine Translation, NMT)等阶段。在 NMT
成熟后，机器翻译才真正得以大规模应用。而早阶段的 NMT
主要是基于循环神经网络 RNN
......
doc/fluid/user_guides/models/index_en.rst
浏览文件 @ 60acca73
......@@ -92,7 +92,7 @@ Different from the end-to-end direct prediction for word distribution of the dee
Machine Translation
---------------------
Machine Translation transforms a natural language (source language) into another natural language (target speech), which is a very basic and important research direction in natural language processing. In the wave of globalization, the important role played by machine translation in promoting cross-language civilization communication is self-evident. Its development has gone through stages such as statistical machine translation and neural-network-based Neuro Machine Translation (NMT). After NMT matured, machine translation was really applied on a large scale. The early stage of NMT is mainly based on the recurrent neural network RNN. The current time step in the training process depends on the calculation of the previous time step, so it is difficult to parallelize the time steps to improve the training speed. Therefore, NMTs of non-RNN structures have emerged, such as structures based on convolutional neural networks CNN and structures based on Self-Attention.
Machine Translation transforms a natural language (source language) into another natural language (target language), which is a very basic and important research direction in natural language processing. In the wave of globalization, the important role played by machine translation in promoting cross-language civilization communication is self-evident. Its development has gone through stages such as statistical machine translation and neural-network-based Neuro Machine Translation (NMT). After NMT matured, machine translation was really applied on a large scale. The early stage of NMT is mainly based on the recurrent neural network RNN. The current time step in the training process depends on the calculation of the previous time step, so it is difficult to parallelize the time steps to improve the training speed. Therefore, NMTs of non-RNN structures have emerged, such as structures based on convolutional neural networks CNN and structures based on Self-Attention.
The Transformer implemented in this example is a machine translation model based on the self-attention mechanism, in which there is no more RNN or CNN structure, but fully utilizes Attention to learn the context dependency. Compared with RNN/CNN, in a single layer, this structure has lower computational complexity, easier parallelization, and easier modeling for long-range dependencies, and finally achieves the best translation effect among multiple languages.
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或