diff --git a/doc/fluid/api_cn/data/dataset_cn/imdb_cn.rst b/doc/fluid/api_cn/data/dataset_cn/imdb_cn.rst index cbee378c8af28a806ef1d925e2abe4354556014a..16365c63889b96af684946c412ef0095a8f278db 100644 --- a/doc/fluid/api_cn/data/dataset_cn/imdb_cn.rst +++ b/doc/fluid/api_cn/data/dataset_cn/imdb_cn.rst @@ -5,7 +5,7 @@ imdb IMDB数据集。 -本模块的数据集从 http://ai.stanford.edu/%7Eamaas/data/sentiment/IMDB 数据集。这个数据集包含了25000条训练用电影评论数据，25000条测试用评论数据，且这些评论带有明显情感倾向。此外，该模块还提供了用于构建词典的API。 +本模块的数据集来自 https://aistudio.baidu.com/aistudio/datasetDetail/69 。这个数据集包含了25000条训练用电影评论数据，25000条测试用评论数据，且这些评论带有明显情感倾向。此外，该模块还提供了用于构建词典的API。 .. py:function:: paddle.dataset.imdb.build_dict(pattern, cutoff) diff --git a/doc/fluid/api_cn/data_feeder_cn/DataFeeder_cn.rst b/doc/fluid/api_cn/data_feeder_cn/DataFeeder_cn.rst index f2f3db29a8ed42c05ebcaad22c09b37faa6846dd..ea56557486cc2cb0e9326072997355ab100615ec 100644 --- a/doc/fluid/api_cn/data_feeder_cn/DataFeeder_cn.rst +++ b/doc/fluid/api_cn/data_feeder_cn/DataFeeder_cn.rst @@ -136,10 +136,12 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是 def reader(limit=10): for i in range(limit): - yield [random.random([784]).astype('float32'), random.randint(10)], + yield [random.random([784]).astype('float32'), random.random([1]).astype('float32')], x = fluid.layers.data(name='x', shape=[1, 28, 28]) - y = fluid.layers.data(name='y', shape=[1], dtype='int64') + y = fluid.layers.data(name='y', shape=[1], dtype='float32') + + fluid.layers.elementwise_add(x, y) feeder = fluid.DataFeeder(['x','y'], fluid.CPUPlace()) place_num = 2 @@ -185,7 +187,7 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是 for i in range(limit): yield (random.random([784]).astype('float32'), random.random([1]).astype('int64')), - place=fluid.CUDAPlace(0) + place=fluid.CPUPlace() data = fluid.layers.data(name='data', shape=[1, 28, 28], dtype='float32') label = fluid.layers.data(name='label', shape=[1], dtype='int64') diff --git a/doc/fluid/api_cn/dataset_cn/InMemoryDataset_cn.rst b/doc/fluid/api_cn/dataset_cn/InMemoryDataset_cn.rst index e35defef0a8e7983038d4dab8ec3c20bb6af6ac6..e23ec9aa19d03e89e01eb060fe17216237c4a6ed 100644 --- a/doc/fluid/api_cn/dataset_cn/InMemoryDataset_cn.rst +++ b/doc/fluid/api_cn/dataset_cn/InMemoryDataset_cn.rst @@ -29,6 +29,49 @@ InMemoryDataset会向内存中加载数据并在训练前缓冲数据。此类 dataset.load_into_memory() +.. py:method:: set_queue_num(queue_num) + +设置 ``Dataset`` 的输出队列数量，训练进程从队列中获取数据。 + + + +参数: + - **queue_num** (int) - dataset输出队列的数量。 + +**代码示例**： + +.. code-block:: python + + import paddle.fluid as fluid + dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset") + dataset.set_queue_num(12) + +.. py:method:: set_fleet_send_batch_size(fleet_send_batch_size) + +设置发送batch的大小 + +参数: + - **fleet_send_batch_size** (int) - 设置发送batch的大小。 + +**代码示例** + +.. code-block:: python + + import paddle.fluid as fluid + dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset") + dataset.set_fleet_send_batch_size(800) + + +.. py:method:: set_merge_by_lineid(var_list, erase_duplicate_feas=True, min_merge_size=2, keep_unmerged-ins=True) + +通过样本id来设置合并，一些线id的实例将会在shuffle之后进行合并，你应该在一个data生成器里面解析样本id。 + +参数: + - **var_list** (list) - 可以被合并的特征列表，其中的每一个元素都是一个 ``Variable`` 。一些类特征我们通常不把它们合并为同样的样本id，所以用户应当指定哪个类特征可以被合并。 + - **erase_duplicate_feas** (bool) - 合并的时候是否删除重复的特征值。默认为True。 + - **min_merge_size** (int) - 合并的最小数量。默认为2。 + - **keep_unmerged_ins** (bool) - 是否保留没有合并的样本，比如有着独特id的样本，或者重复id的数量小于 ``min_merge_size`` 的样本。 + .. py:method:: local_shuffle() 局域shuffle。 @@ -89,7 +132,7 @@ InMemoryDataset会向内存中加载数据并在训练前缓冲数据。此类 .. py:method:: get_memory_data_size(fleet=None) -用户可以调用此函数以了解加载进内存后所有workers中的ins数量。 +用户可以调用此函数以了解加载进内存后所有workers中的样本数量。 .. note:: 该函数可能会导致性能不佳，因为它具有barrier。 @@ -114,7 +157,7 @@ InMemoryDataset会向内存中加载数据并在训练前缓冲数据。此类 .. py:method:: get_shuffle_data_size(fleet=None) -获取shuffle数据大小，用户可以调用此函数以了解局域/全局shuffle后所有workers中的ins数量。 +获取shuffle数据大小，用户可以调用此函数以了解局域/全局shuffle后所有workers中的样本数量。 .. note:: 该函数可能会导致局域shuffle性能不佳，因为它具有barrier。但其不影响局域shuffle。 diff --git a/doc/fluid/api_cn/dygraph_cn.rst b/doc/fluid/api_cn/dygraph_cn.rst index d5d83b011111a949b1201f0d34968de7e619a96e..37a2272f2b60d8b569d54b9ba23f598384613ce2 100644 --- a/doc/fluid/api_cn/dygraph_cn.rst +++ b/doc/fluid/api_cn/dygraph_cn.rst @@ -29,6 +29,7 @@ fluid.dygraph dygraph_cn/NaturalExpDecay_cn.rst dygraph_cn/NCE_cn.rst dygraph_cn/NoamDecay_cn.rst + dygraph_cn/no_grad_cn.rst dygraph_cn/PiecewiseDecay_cn.rst dygraph_cn/PolynomialDecay_cn.rst dygraph_cn/Pool2D_cn.rst diff --git a/doc/fluid/api_cn/dygraph_cn/BackwardStrategy_cn.rst b/doc/fluid/api_cn/dygraph_cn/BackwardStrategy_cn.rst index 9cfa53bc1d3fa2aa6a615e38f6867eebc3407a47..9d11e1cc99998f219d3d9ef7fd9497da72309c93 100644 --- a/doc/fluid/api_cn/dygraph_cn/BackwardStrategy_cn.rst +++ b/doc/fluid/api_cn/dygraph_cn/BackwardStrategy_cn.rst @@ -7,7 +7,7 @@ BackwardStrategy BackwardStrategy是描述反向过程的描述符，现有如下功能: -1. ``sort_sum_gradient`` 按回溯逆序将梯度加和 + ``sort_sum_gradient`` 按回溯逆序将梯度加和 **代码示例** diff --git a/doc/fluid/api_cn/dygraph_cn/BatchNorm_cn.rst b/doc/fluid/api_cn/dygraph_cn/BatchNorm_cn.rst index de7e438faa0f65c7f3ca74e85a055401a325fd0d..0549db7f027c0956b9f26f6acfb3d7dfbf25e915 100644 --- a/doc/fluid/api_cn/dygraph_cn/BatchNorm_cn.rst +++ b/doc/fluid/api_cn/dygraph_cn/BatchNorm_cn.rst @@ -35,19 +35,19 @@ BatchNorm 参数： - **name_scope** (str) - 该类的名称 - - **act** （string，默认None）- 激活函数类型，linear|relu|prelu|... - - **is_test** （bool,默认False） - 指示它是否在测试阶段。 - - **momentum** （float，默认0.9）- 此值用于计算 moving_mean and moving_var. 更新公式为: :math:`moving\_mean = moving\_mean * momentum + new\_mean * (1. - momentum` :math:`moving\_var = moving\_var * momentum + new\_var * (1. - momentum` ， 默认值0.9. - - **epsilon** （float，默认1e-05）- 加在分母上为了数值稳定的值。默认值为1e-5。 + - **act** （str|None）- 激活函数类型，linear|relu|prelu|... + - **is_test** （bool） - 指示它是否在测试阶段。默认False。 + - **momentum** （float）- 此值用于计算 moving_mean and moving_var. 更新公式为: :math:`moving\_mean = moving\_mean * momentum + new\_mean * (1. - momentum` :math:`moving\_var = moving\_var * momentum + new\_var * (1. - momentum` ， 默认值0.9. + - **epsilon** （float）- 加在分母上为了数值稳定的值。默认值为1e-5。 - **param_attr** （ParamAttr|None） - batch_norm参数范围的属性，如果设为None或者是ParamAttr的一个属性，batch_norm创建ParamAttr为param_attr。如果没有设置param_attr的初始化函数，参数初始化为Xavier。默认：None - **bias_attr** （ParamAttr|None） - batch_norm bias参数的属性，如果设为None或者是ParamAttr的一个属性，batch_norm创建ParamAttr为bias_attr。如果没有设置bias_attr的初始化函数，参数初始化为0。默认：None - - **data_layout** （string,默认NCHW) - NCHW|NHWC。默认NCHW - - **in_place** （bool，默认False）- 得出batch norm可复用记忆的输入和输出 - - **moving_mean_name** （string，默认None）- moving_mean的名称，存储全局Mean均值。 + - **data_layout** （string) - NCHW|NHWC。默认NCHW + - **in_place** （bool）- 得出batch norm可复用记忆的输入和输出，默认False。 + - **moving_mean_name** （string|None）- moving_mean的名称，存储全局Mean均值。默认为None。 - **moving_variance_name** （string，默认None）- moving_variance的名称，存储全局方差。 - **do_model_average_for_mean_and_var** （bool，默认False）- 是否为mean和variance做模型均值 - **fuse_with_relu** （bool）- 如果为True，batch norm后该操作符执行relu。默认为False。 - - **use_global_stats** （bool, Default False） – 是否使用全局均值和方差。 在预测或测试模式下，将use_global_stats设置为true或将is_test设置为true，并且行为是等效的。 在训练模式中，当设置use_global_stats为True时，在训练期间也使用全局均值和方差。 + - **use_global_stats** （bool） – 是否使用全局均值和方差。 在预测或测试模式下，将use_global_stats设置为true或将is_test设置为true，并且行为是等效的。 在训练模式中，当设置use_global_stats为True时，在训练期间也使用全局均值和方差。默认为False。 - **trainable_statistics** （bool）- eval模式下是否计算mean均值和var方差。eval模式下，trainable_statistics为True时，由该批数据计算均值和方差。默认为False。 返回： 张量，在输入中运用批正则后的结果 diff --git a/doc/fluid/api_cn/dygraph_cn/FC_cn.rst b/doc/fluid/api_cn/dygraph_cn/FC_cn.rst index b18db1a3e3ccef59b3e3ae3f4b6ed9e0c516023c..5817d0d774990087c8c52abe8ea467e690eac292 100644 --- a/doc/fluid/api_cn/dygraph_cn/FC_cn.rst +++ b/doc/fluid/api_cn/dygraph_cn/FC_cn.rst @@ -55,11 +55,11 @@ FC 参数: - **name_scope** (str) – 该类的名称 - **size** (int) – 该层输出单元的数目 - - **num_flatten_dims** (int, 默认为1) – fc层可以接受一个维度大于2的tensor。此时， 它首先会被扁平化(flattened)为一个二维矩阵。 参数 ``num_flatten_dims`` 决定了输入tensor的flattened方式: 前 ``num_flatten_dims`` (包含边界，从1开始数) 个维度会被扁平化为最终矩阵的第一维 (维度即为矩阵的高), 剩下的 rank(X) - num_flatten_dims 维被扁平化为最终矩阵的第二维 (即矩阵的宽)。 例如， 假设X是一个五维tensor，其形可描述为(2, 3, 4, 5, 6), 且num_flatten_dims = 3。那么扁平化的矩阵形状将会如此： (2 x 3 x 4, 5 x 6) = (24, 30) + - **num_flatten_dims** (int) – fc层可以接受一个维度大于2的tensor。此时， 它首先会被扁平化(flattened)为一个二维矩阵。 参数 ``num_flatten_dims`` 决定了输入tensor的flattened方式: 前 ``num_flatten_dims`` (包含边界，从1开始数) 个维度会被扁平化为最终矩阵的第一维 (维度即为矩阵的高), 剩下的 rank(X) - num_flatten_dims 维被扁平化为最终矩阵的第二维 (即矩阵的宽)。 例如， 假设X是一个五维tensor，其形可描述为[2, 3, 4, 5, 6], 且num_flatten_dims = 3。那么扁平化的矩阵形状将会如此： [2 x 3 x 4, 5 x 6] = [24, 30]。默认为1。 - **param_attr** (ParamAttr|list of ParamAttr|None) – 该层可学习的参数/权的参数属性 - **bias_attr** (ParamAttr|list of ParamAttr, default None) – 该层bias变量的参数属性。如果值为False， 则bias变量不参与输出单元运算。 如果值为None，bias变量被初始化为0。默认为 None。 - **act** (str|None) – 应用于输出的Activation（激励函数） - - **is_test** (bool) – 表明当前执行是否处于测试阶段的标志 + - **is_test** (bool) – 表明当前执行是否处于测试阶段的标志。默认为False。 - **dtype** (str) – 权重的数据类型 diff --git a/doc/fluid/api_cn/dygraph_cn/GRUUnit_cn.rst b/doc/fluid/api_cn/dygraph_cn/GRUUnit_cn.rst index 765dc12fc86d5140c56353a5fb184563c6f5b3a7..2a6b3f3d5ff2b86e9e51416d009e5022fb77bb57 100644 --- a/doc/fluid/api_cn/dygraph_cn/GRUUnit_cn.rst +++ b/doc/fluid/api_cn/dygraph_cn/GRUUnit_cn.rst @@ -9,7 +9,8 @@ GRU单元层。GRU执行步骤基于如下等式： 如果origin_mode为True，则该运算公式来自论文 -`Empirical Evaluation of Gated Recurrent Neural Networks on Sequence Modeling `_ 。 +`Learning Phrase Representations using RNN Encoder-Decoder for Statistical +Machine Translation `_ 。 公式如下: diff --git a/doc/fluid/api_cn/dygraph_cn/GroupNorm_cn.rst b/doc/fluid/api_cn/dygraph_cn/GroupNorm_cn.rst index d5b001511b49c74bd2c7c7b5f02f79db173876f5..727ed5ea4a7b1bcfc03cdf89ed2713ff3210898f 100644 --- a/doc/fluid/api_cn/dygraph_cn/GroupNorm_cn.rst +++ b/doc/fluid/api_cn/dygraph_cn/GroupNorm_cn.rst @@ -10,10 +10,10 @@ GroupNorm 请参考 `Group Normalization `_ 。 参数： - - **name_scope** (str) - 该类名称 - - **groups** (int) - 从 channel 中分离出来的 group 的数目 - - **epsilon** (float) - 为防止方差除零，增加一个很小的值 - - **param_attr** (ParamAttr|None) - 可学习标度的参数属性 :math:`g`,如果设置为False，则不会向输出单元添加标度。如果设置为0，偏差初始化为1。默认值:None + - **name_scope** (str) - 该类名称。 + - **groups** (int) - 从 channel 中分离出来的 group 的数目。 + - **epsilon** (float) - 为防止方差除零，增加一个很小的值，默认为1e-05。 + - **param_attr** (ParamAttr|None) - 可学习标度的参数属性 :math:`g`,如果设置为False，则不会向输出单元添加标度。如果设置为0，偏差初始化为1。默认值:None。 - **bias_attr** (ParamAttr|None) - 可学习偏置的参数属性 :math:`b ` , 如果设置为False，则不会向输出单元添加偏置量。如果设置为零，偏置初始化为零。默认值:None。 - **act** (str) - 将激活应用于输出的 group normalizaiton - **data_layout** (string|NCHW) - 只支持NCHW。 diff --git a/doc/fluid/api_cn/dygraph_cn/NCE_cn.rst b/doc/fluid/api_cn/dygraph_cn/NCE_cn.rst index d8978a5aa67911319c5ed203de534d9a866eeec4..e97b387e6bd5a43b807ca39a3e3d313a21c64830 100644 --- a/doc/fluid/api_cn/dygraph_cn/NCE_cn.rst +++ b/doc/fluid/api_cn/dygraph_cn/NCE_cn.rst @@ -12,17 +12,17 @@ NCE 该operator默认使用均匀分布进行抽样。 参数: - - **name_scope** (str) – 该类的名称 - - **num_total_classes** (int) - 所有样本中的类别的总数 - - **sample_weight** (Variable|None) - 存储每个样本权重，shape为[batch_size, 1]存储每个样本的权重。每个样本的默认权重为1.0 - - **param_attr** (ParamAttr|None) - :math:`可学习参数/nce权重` 的参数属性。如果它没有被设置为ParamAttr的一个属性，nce将创建ParamAttr为param_attr。如没有设置param_attr的初始化器，那么参数将用Xavier初始化。默认值:None - - **bias_attr** (ParamAttr|bool|None) - nce偏置的参数属性。如果设置为False，则不会向输出添加偏置（bias）。如果值为None或ParamAttr的一个属性，则bias_attr=ParamAtt。如果没有设置bias_attr的初始化器，偏置将被初始化为零。默认值:None - - **num_neg_samples** (int) - 负样例的数量。默认值是10 - - **name** (str|None) - 该layer的名称(可选)。如果设置为None，该层将被自动命名 - - **sampler** (str) – 取样器，用于从负类别中进行取样。可以是 ‘uniform’, ‘log_uniform’ 或 ‘custom_dist’。 默认 ‘uniform’ + - **name_scope** (str) – 该类的名称。 + - **num_total_classes** (int) - 所有样本中的类别的总数。 + - **sample_weight** (Variable|None) - 存储每个样本权重，shape为[batch_size, 1]存储每个样本的权重。每个样本的默认权重为1.0。 + - **param_attr** (ParamAttr|None) - :math:`可学习参数/nce权重` 的参数属性。如果它没有被设置为ParamAttr的一个属性，nce将创建ParamAttr为param_attr。如没有设置param_attr的初始化器，那么参数将用Xavier初始化。默认值:None。 + - **bias_attr** (ParamAttr|bool|None) - nce偏置的参数属性。如果设置为False，则不会向输出添加偏置（bias）。如果值为None或ParamAttr的一个属性，则bias_attr=ParamAtt。如果没有设置bias_attr的初始化器，偏置将被初始化为零。默认值:None。 + - **num_neg_samples** (int) - 负样例的数量。默认值是10。 + - **name** (str|None) - 该layer的名称(可选)。如果设置为None，该层将被自动命名。 + - **sampler** (str) – 取样器，用于从负类别中进行取样。可以是 ‘uniform’, ‘log_uniform’ 或 ‘custom_dist’。 默认 ‘uniform’。 - **custom_dist** (float[]) – 一个 float[] 并且它的长度为 ``num_total_classes`` 。 如果取样器类别为‘custom_dist’，则使用此参数。 custom_dist[i] 是第i个类别被取样的概率。默认为 None - - **seed** (int) – 取样器使用的seed。默认为0 - - **is_sparse** (bool) – 标志位，指明是否使用稀疏更新, :math:`weight@GRAD` 和 :math:`bias@GRAD` 会变为 SelectedRows + - **seed** (int) – 取样器使用的seed。默认为0。 + - **is_sparse** (bool) – 标志位，指明是否使用稀疏更新, :math:`weight@GRAD` 和 :math:`bias@GRAD` 会变为 SelectedRows。默认为False。 返回： nce loss diff --git a/doc/fluid/api_cn/dygraph_cn/PRelu_cn.rst b/doc/fluid/api_cn/dygraph_cn/PRelu_cn.rst index 7ff113af6308dca9f889ae4396f513e67e8b9afe..d1426f47f68c2f2d9dd5b658d028d3c13de54cd5 100644 --- a/doc/fluid/api_cn/dygraph_cn/PRelu_cn.rst +++ b/doc/fluid/api_cn/dygraph_cn/PRelu_cn.rst @@ -12,8 +12,8 @@ PRelu 参数： - - **name_scope** （string）- 该类的名称。 - - **mode** (string) - 权重共享模式。共提供三种激活方式： + - **name_scope** （str）- 该类的名称。 + - **mode** (str) - 权重共享模式。共提供三种激活方式： .. code-block:: text diff --git a/doc/fluid/api_cn/dygraph_cn/Pool2D_cn.rst b/doc/fluid/api_cn/dygraph_cn/Pool2D_cn.rst index c8953dd371b0abb58269feec9fc2c39f39747317..ae9834336040eedc3dcd9a85dcfa3e9fa6a3dcf7 100644 --- a/doc/fluid/api_cn/dygraph_cn/Pool2D_cn.rst +++ b/doc/fluid/api_cn/dygraph_cn/Pool2D_cn.rst @@ -15,7 +15,7 @@ pooling2d操作符根据 ``input`` ， 池化类型 ``pooling_type`` ， 池化 参数： - **name_scope** (str) - 该类的名称 - **pool_size** (int|list|tuple) - 池化核的大小。如果它是一个元组或列表，它必须包含两个整数值， (pool_size_Height, pool_size_Width)。其他情况下，若为一个整数，则它的平方值将作为池化核大小，比如若pool_size=2, 则池化核大小为2x2，默认值为-1。 - - **pool_type** (string) - 池化类型，可以是“max”对应max-pooling，“avg”对应average-pooling，默认值为max。 + - **pool_type** (str) - 池化类型，可以是“max”对应max-pooling，“avg”对应average-pooling，默认值为max。 - **pool_stride** (int|list|tuple) - 池化层的步长。如果它是一个元组或列表，它将包含两个整数，(pool_stride_Height, pool_stride_Width)。否则它是一个整数的平方值。默认值为1。 - **pool_padding** (int|list|tuple) - 填充大小。如果它是一个元组，它必须包含两个整数值，(pool_padding_on_Height, pool_padding_on_Width)。否则它是一个整数的平方值。默认值为0。 - **global_pooling** （bool）- 是否用全局池化。如果global_pooling = true， ``ksize`` 和 ``paddings`` 将被忽略。默认值为false @@ -40,13 +40,13 @@ pooling2d操作符根据 ``input`` ， 池化类型 ``pooling_type`` ， 池化 import numpy with fluid.dygraph.guard(): - data = numpy.random.random((3, 32, 32)).astype('float32') + data = numpy.random.random((3, 32, 32)).astype('float32') - pool2d = fluid.dygraph.Pool2D("pool2d",pool_size=2, + pool2d = fluid.dygraph.Pool2D("pool2d",pool_size=2, pool_type='max', pool_stride=1, global_pooling=False) - pool2d_res = pool2d(data) + pool2d_res = pool2d(data) diff --git a/doc/fluid/api_cn/dygraph_cn/no_grad_cn.rst b/doc/fluid/api_cn/dygraph_cn/no_grad_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..a1e68205617b5e7898d5c4bb4f3d35af02c1cdd6 --- /dev/null +++ b/doc/fluid/api_cn/dygraph_cn/no_grad_cn.rst @@ -0,0 +1,31 @@ +.. _cn_api_fluid_dygraph_no_grad: + +no_grad +------------------------------- + +.. py:method:: paddle.fluid.dygraph.no_grad(func) + +在动态图模式中，此装饰器将会避免 ``func`` 被装饰时创建反向传播网络。 + +参数: + - **func** (str) – 不需要梯度的函数。 + +**代码示例** + +.. code-block:: python + + + import numpy as np + import paddle.fluid as fluid + + @fluid.dygraph.no_grad + def test_layer(): + with fluid.dygraph.guard(): + inp = np.ones([3, 32, 32], dtype='float32') + t = fluid.dygraph.base.to_variable(inp) + fc1 = fluid.FC('fc1', size=4, bias_attr=False, num_flatten_dims=1) + fc2 = fluid.FC('fc2', size=4) + ret = fc1(t) + dy_ret = fc2(ret) + + test_layer() \ No newline at end of file diff --git a/doc/fluid/api_cn/fluid_cn.rst b/doc/fluid/api_cn/fluid_cn.rst index c4e8d5d4ebaddc65cf041b226d5ef0771dc48b89..1cb96dacaf28dd27cc95b1c38293ace9f8265629 100644 --- a/doc/fluid/api_cn/fluid_cn.rst +++ b/doc/fluid/api_cn/fluid_cn.rst @@ -29,6 +29,7 @@ fluid fluid_cn/global_scope_cn.rst fluid_cn/gradients_cn.rst fluid_cn/in_dygraph_mode_cn.rst + fluid_cn/is_compiled_with_cuda_cn.rst fluid_cn/LoDTensor_cn.rst fluid_cn/LoDTensorArray_cn.rst fluid_cn/memory_optimize_cn.rst diff --git a/doc/fluid/api_cn/fluid_cn/BuildStrategy_cn.rst b/doc/fluid/api_cn/fluid_cn/BuildStrategy_cn.rst index 2569ed6776e4e4909b54f95ba01044e304a3fa00..387f545da17657e3ca47a32d10b677c883329b16 100644 --- a/doc/fluid/api_cn/fluid_cn/BuildStrategy_cn.rst +++ b/doc/fluid/api_cn/fluid_cn/BuildStrategy_cn.rst @@ -26,7 +26,7 @@ str类型。它表明了以graphviz格式向文件中写入SSA图的路径，有 import paddle.fluid as fluid build_strategy = fluid.BuildStrategy() - build_strategy.debug_graphviz_path = "" + build_strategy.debug_graphviz_path = "./graph" .. py:attribute:: enable_sequential_execution @@ -73,23 +73,64 @@ BOOL类型，fuse_relu_depthwise_conv指示是否融合relu和depthwise_conv2d .. py:attribute:: gradient_scale_strategy -str类型。在 ``ParallelExecutor`` 中，存在三种定义 *loss@grad* 的方式，分别为 ``CoeffNumDevice``, ``One`` 与 ``Customized``。默认情况下， ``ParallelExecutor`` 根据设备数目来设置 *loss@grad* 。如果你想自定义 *loss@grad* ，你可以选择 ``Customized`` 方法。默认为 ``CoeffNumDevice`` 。 +``fluid.BuildStrategy.GradientScaleStrategy`` 类型。在 ``ParallelExecutor`` 中，存在三种定义 *loss@grad* 的方式，分别为 ``CoeffNumDevice``, ``One`` 与 ``Customized``。默认情况下， ``ParallelExecutor`` 根据设备数目来设置 *loss@grad* 。如果你想自定义 *loss@grad* ，你可以选择 ``Customized`` 方法。默认为 ``CoeffNumDevice`` 。 **代码示例** .. code-block:: python - import paddle.fluid as fluid + import paddle.fluid.compiler as compiler + import numpy + import os + + use_cuda = True + place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() + exe = fluid.Executor(place) + + # NOTE: 如果你使用CPU计算，需要指定CPU_NUM, 否则,fluid + # 将使用所有的核的数目作为CPU_NUM, + # 这种情况下，输入的batch size应该大于CPU_NUM, 否则, + # 进程将会因为异常而失败。 + if not use_cuda: + os.environ['CPU_NUM'] = str(2) + places = fluid.cpu_places() + else: + places = places = fluid.cuda_places() + + data = fluid.layers.data(name='X', shape=[1], dtype='float32') + hidden = fluid.layers.fc(input=data, size=10) + loss = fluid.layers.mean(hidden) + fluid.optimizer.SGD(learning_rate=0.01).minimize(loss) + + fluid.default_startup_program().random_seed=1 + exe.run(fluid.default_startup_program()) + build_strategy = fluid.BuildStrategy() - build_strategy.gradient_scale_strategy = True + build_strategy.gradient_scale_strategy = \ + fluid.BuildStrategy.GradientScaleStrategy.Customized + compiled_prog = compiler.CompiledProgram( + fluid.default_main_program()).with_data_parallel( + loss_name=loss.name, build_strategy=build_strategy, + places = places) + + dev_count = len(places) + x = numpy.random.random(size=(10, 1)).astype('float32') + loss_grad = numpy.ones((dev_count)).astype("float32") * 0.01 + loss_grad_name = loss.name+"@GRAD" + loss_data = exe.run(compiled_prog, + feed={"X": x, loss_grad_name : loss_grad}, + fetch_list=[loss.name, loss_grad_name]) .. py:attribute:: memory_optimize -bool类型。设为True时可用于减少总内存消耗。为实验性属性，一些变量可能会被优化策略重用/移除。如果你需要在使用该特征时获取某些变量，请把变量的persistable property设为True。默认为False。 +bool类型或者None。设为True时可用于减少总内存消耗。 +默认为None。None表示框架会自动选择使用或者不使用优化策略。当前，None意味着当GC不能使用时，优化策略将被使用。 +True表示可使用，False表示不可使用。默认为None。 .. py:attribute:: reduce_strategy -str类型。在 ``ParallelExecutor`` 中，存在两种减少策略（reduce strategy），即 ``AllReduce`` 和 ``Reduce`` 。如果你需要在所有执行场所上独立地进行参数优化，可以使用 ``AllReduce`` 。反之，如果使用 ``Reduce`` 策略，所有参数的优化将均匀地分配给不同的执行场所，随之将优化后的参数广播给其他执行场所。在一些模型中， ``Reduce`` 策略执行速度更快一些。默认值为 ``AllReduce`` 。 +``fluid.BuildStrategy.ReduceStrategy`` 类型。在 ``ParallelExecutor`` 中，存在两种减少策略（reduce strategy），即 ``AllReduce`` 和 ``Reduce`` 。如果你需要在所有执行设备上独立地进行参数优化，可以使用 ``AllReduce`` 。反之，如果使用 ``Reduce`` 策略，所有参数的优化将均匀地分配给不同的执行设备，随之将优化后的参数广播给其他执行设备。 +默认值为 ``AllReduce`` 。 **代码示例** @@ -101,7 +142,7 @@ str类型。在 ``ParallelExecutor`` 中，存在两种减少策略（reduce str .. py:attribute:: remove_unnecessary_lock -BOOL类型。如果设置为True, GPU操作中的一些锁将被释放，ParallelExecutor将运行得更快，默认为 True。 +BOOL类型。如果设置为True, GPU操作中的一些锁将被释放， ``ParallelExecutor`` 将运行得更快，默认为 True。 **代码示例** @@ -114,7 +155,7 @@ BOOL类型。如果设置为True, GPU操作中的一些锁将被释放，Paralle .. py:attribute:: sync_batch_norm -类型为bool，sync_batch_norm表示是否使用同步的批正则化，即在训练阶段通过多个设备同步均值和方差。 +类型为bool， ``sync_batch_norm`` 表示是否使用同步的批正则化，即在训练阶段通过多个设备同步均值和方差。 当前的实现不支持FP16训练和CPU。仅在一台机器上进行同步式批正则，不适用于多台机器。 diff --git a/doc/fluid/api_cn/fluid_cn/DataFeeder_cn.rst b/doc/fluid/api_cn/fluid_cn/DataFeeder_cn.rst index a00aadc7dbf29270651b631bb8f03e40368e345b..9ba577a5908d1ded7549d9c19ed4cb517753e323 100644 --- a/doc/fluid/api_cn/fluid_cn/DataFeeder_cn.rst +++ b/doc/fluid/api_cn/fluid_cn/DataFeeder_cn.rst @@ -137,10 +137,12 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是 def reader(limit=10): for i in range(limit): - yield [random.random([784]).astype('float32'), random.randint(10)], + yield [random.random([784]).astype('float32'), random.random([1]).astype('float32')], x = fluid.layers.data(name='x', shape=[1, 28, 28]) - y = fluid.layers.data(name='y', shape=[1], dtype='int64') + y = fluid.layers.data(name='y', shape=[1], dtype='float32') + + fluid.layers.elementwise_add(x, y) feeder = fluid.DataFeeder(['x','y'], fluid.CPUPlace()) place_num = 2 @@ -185,7 +187,7 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是 for i in range(limit): yield (random.random([784]).astype('float32'), random.random([1]).astype('int64')), - place=fluid.CUDAPlace(0) + place=fluid.CPUPlace() data = fluid.layers.data(name='data', shape=[1, 28, 28], dtype='float32') label = fluid.layers.data(name='label', shape=[1], dtype='int64') diff --git a/doc/fluid/api_cn/fluid_cn/ExecutionStrategy_cn.rst b/doc/fluid/api_cn/fluid_cn/ExecutionStrategy_cn.rst index 4b556d449ca0683b5fad01279b8d9f22fecbfc6b..d901675c6870327e6faed05438fc33a044320db2 100644 --- a/doc/fluid/api_cn/fluid_cn/ExecutionStrategy_cn.rst +++ b/doc/fluid/api_cn/fluid_cn/ExecutionStrategy_cn.rst @@ -33,7 +33,7 @@ ExecutionStrategy .. py:attribute:: allow_op_delay -这是一个bool类型成员，表示是否推迟communication operators(交流运算)的执行，这样做会使整体执行过程更快一些。但是在一些模型中，allow_op_delay会导致程序中断。默认为False。 +这是一个bool类型成员，表示是否推迟communication operators(交流运算)的执行，这样做会使整体执行过程更快一些。此选项现在已经失效，在下个版本中将会被移除。默认为False。 diff --git a/doc/fluid/api_cn/fluid_cn/LoDTensor_cn.rst b/doc/fluid/api_cn/fluid_cn/LoDTensor_cn.rst index 502c7040c0b84c1462865be5a922a06c915a831f..02fca98c0061fd3a3d6a2b72730c66d76eb60366 100644 --- a/doc/fluid/api_cn/fluid_cn/LoDTensor_cn.rst +++ b/doc/fluid/api_cn/fluid_cn/LoDTensor_cn.rst @@ -55,7 +55,7 @@ LoD可以有多个level(例如，一个段落可以有多个句子，一个句 -.. py:method:: has_valid_recursive_sequence_lengths(self: paddle.fluid.core.LoDTensor) → bool +.. py:method:: has_valid_recursive_sequence_lengths(self: paddle.fluid.core_avx.LoDTensor) → bool 检查LoDTensor的lod值的正确性。 @@ -154,7 +154,7 @@ LoD可以有多个level(例如，一个段落可以有多个句子，一个句 t.set(np.ndarray([5, 30]), fluid.CPUPlace()) t.set_lod([[0, 2, 5]]) -.. py:method:: set_recursive_sequence_lengths(self: paddle.fluid.core.LoDTensor, recursive_sequence_lengths: List[List[int]]) → None +.. py:method:: set_recursive_sequence_lengths(self: paddle.fluid.core_avx.LoDTensor, recursive_sequence_lengths: List[List[int]]) → None 根据递归序列长度recursive_sequence_lengths设置LoDTensor的LoD。 diff --git a/doc/fluid/api_cn/fluid_cn/ParallelExecutor_cn.rst b/doc/fluid/api_cn/fluid_cn/ParallelExecutor_cn.rst index 2d8ee05a819c0ef8d660480508dc976adc18f91d..60ad4cd9762b43db539e97230350a847e9853b2b 100644 --- a/doc/fluid/api_cn/fluid_cn/ParallelExecutor_cn.rst +++ b/doc/fluid/api_cn/fluid_cn/ParallelExecutor_cn.rst @@ -39,7 +39,7 @@ ParallelExecutor test_program = fluid.default_main_program().clone(for_test=True) fluid.optimizer.SGD(learning_rate=0.01).minimize(loss) - startup_program.random_seed=1 + exe.run(startup_program) train_exe = fluid.ParallelExecutor(use_cuda=use_cuda, diff --git a/doc/fluid/api_cn/fluid_cn/Program_cn.rst b/doc/fluid/api_cn/fluid_cn/Program_cn.rst index 2d8ea38d8b8c896adb39cbf269782560384016c5..293c397799cb348dc3108958cf453e12d93fb083 100644 Binary files a/doc/fluid/api_cn/fluid_cn/Program_cn.rst and b/doc/fluid/api_cn/fluid_cn/Program_cn.rst differ diff --git a/doc/fluid/api_cn/fluid_cn/WeightNormParamAttr_cn.rst b/doc/fluid/api_cn/fluid_cn/WeightNormParamAttr_cn.rst index efff7023e94f3b05b64d97bc349258c43343c075..9ce34534f90b327cdee23eb0e3ff7969382622c8 100644 --- a/doc/fluid/api_cn/fluid_cn/WeightNormParamAttr_cn.rst +++ b/doc/fluid/api_cn/fluid_cn/WeightNormParamAttr_cn.rst @@ -6,10 +6,10 @@ WeightNormParamAttr .. py:class:: paddle.fluid.WeightNormParamAttr(dim=None, name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, gradient_clip=None, do_model_average=False) -权重归一化。权重归一化是将权重向量的长度与其方向解耦。`Weight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural Networks `_ 这篇paper中讨论了权重归一化的实现 +权重归一化。权重归一化是将权重向量的量级与其方向解耦。`Weight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural Networks `_ 这篇paper中讨论了权重归一化的实现 参数: - - **dim** (list) - 参数的名称。默认None。 + - **dim** (int) - 归一化的维度。默认None。 - **name** (str) - 参数的名称。默认None。 - **initializer** （initializer) - 初始化参数的方法。默认None。 - **learning_rate** (float) - 学习率。优化时学习速率 :math:`global\_lr∗parameter\_lr∗scheduler\_factor` 。默认1.0。 diff --git a/doc/fluid/api_cn/fluid_cn/default_main_program_cn.rst b/doc/fluid/api_cn/fluid_cn/default_main_program_cn.rst index 5d12f9e7f5887f46e76ab137a39395489580f172..cecf38b7e5e325ce2fcad5fe2fb92ddda719a497 100644 --- a/doc/fluid/api_cn/fluid_cn/default_main_program_cn.rst +++ b/doc/fluid/api_cn/fluid_cn/default_main_program_cn.rst @@ -25,35 +25,32 @@ default_main_program .. code-block:: python - import paddle.fluid as fluid + import paddle.fluid as fluid - # Sample Network: - data = fluid.layers.data(name='image', shape=[3, 224, 224], dtype='float32') - label = fluid.layers.data(name='label', shape=[1], dtype='int64') + #示例网络: + data = fluid.layers.data(name='image', shape=[3, 224, 224], dtype='float32') + label = fluid.layers.data(name='label', shape=[1], dtype='int64') + + conv1 = fluid.layers.conv2d(data, 4, 5, 1, act=None) + bn1 = fluid.layers.batch_norm(conv1, act='relu') + pool1 = fluid.layers.pool2d(bn1, 2, 'max', 2) + conv2 = fluid.layers.conv2d(pool1, 16, 5, 1, act=None) + bn2 = fluid.layers.batch_norm(conv2, act='relu') + pool2 = fluid.layers.pool2d(bn2, 2, 'max', 2) + + fc1 = fluid.layers.fc(pool2, size=50, act='relu') + fc2 = fluid.layers.fc(fc1, size=102, act='softmax') - conv1 = fluid.layers.conv2d(data, 4, 5, 1, act=None) - bn1 = fluid.layers.batch_norm(conv1, act='relu') - pool1 = fluid.layers.pool2d(bn1, 2, 'max', 2) - conv2 = fluid.layers.conv2d(pool1, 16, 5, 1, act=None) - bn2 = fluid.layers.batch_norm(conv2, act='relu') - pool2 = fluid.layers.pool2d(bn2, 2, 'max', 2) + loss = fluid.layers.cross_entropy(input=fc2, label=label) + loss = fluid.layers.mean(loss) + opt = fluid.optimizer.Momentum( + learning_rate=0.1, + momentum=0.9, + regularization=fluid.regularizer.L2Decay(1e-4)) + opt.minimize(loss) - fc1 = fluid.layers.fc(pool2, size=50, act='relu') - fc2 = fluid.layers.fc(fc1, size=102, act='softmax') - - loss = fluid.layers.cross_entropy(input=fc2, label=label) - loss = fluid.layers.mean(loss) - opt = fluid.optimizer.Momentum( - learning_rate=0.1, - momentum=0.9, - regularization=fluid.regularizer.L2Decay(1e-4)) - opt.minimize(loss) - - print(fluid.default_main_program()) - - - - + print(fluid.default_main_program().num_blocks) + print(fluid.default_main_program().blocks[0].var('image')) diff --git a/doc/fluid/api_cn/fluid_cn/gradients_cn.rst b/doc/fluid/api_cn/fluid_cn/gradients_cn.rst index 271c086237030c7bea191b23fffd44a3eeb0983f..28a8526bdd5c863ae45b47b1e15628306f613e78 100644 --- a/doc/fluid/api_cn/fluid_cn/gradients_cn.rst +++ b/doc/fluid/api_cn/fluid_cn/gradients_cn.rst @@ -11,7 +11,7 @@ gradients - **targets** (Variable|list[Variable]) – 目标变量 - **inputs** (Variable|list[Variable]) – 输入变量 - **target_gradients** (Variable|list[Variable]|None) – 目标的梯度变量，应与目标变量形状相同；如果设置为None，则以1初始化所有梯度变量 - - **no_grad_sethread** (set[string]) – 在Block 0中不具有梯度的变量，所有block中被设置 ``stop_gradient=True`` 的变量将被自动加入该set + - **no_grad_set** (set[string]) – 在Block 0中不具有梯度的变量，所有block中被设置 ``stop_gradient=True`` 的变量将被自动加入该set 返回：数组，包含与输入对应的梯度。如果一个输入不影响目标函数，则对应的梯度变量为None diff --git a/doc/fluid/api_cn/fluid_cn/is_compiled_with_cuda_cn.rst b/doc/fluid/api_cn/fluid_cn/is_compiled_with_cuda_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..58112a408b1d57275e69a37ca48ba1bf7e55db6f --- /dev/null +++ b/doc/fluid/api_cn/fluid_cn/is_compiled_with_cuda_cn.rst @@ -0,0 +1,21 @@ +.. _cn_api_fluid_is_compiled_with_cuda: + +is_compiled_with_cuda +------------------------------- + +.. py:function:: paddle.fluid.is_compiled_with_cuda() + +检查 ``whl`` 包是否可以被用来在GPU上运行模型 + +返回：支持gpu则为True,否则为False。 + +返回类型：out(boolean) + +**示例代码** + +.. code-block:: python + + import paddle.fluid as fluid + support_gpu = fluid.is_compiled_with_cuda() + + diff --git a/doc/fluid/api_cn/fluid_cn/memory_optimize_cn.rst b/doc/fluid/api_cn/fluid_cn/memory_optimize_cn.rst index 50ae632721260fb867f315ed899640f35bbb878a..b3727a26ca2264875da944105b3291a3ef52fef6 100644 --- a/doc/fluid/api_cn/fluid_cn/memory_optimize_cn.rst +++ b/doc/fluid/api_cn/fluid_cn/memory_optimize_cn.rst @@ -3,7 +3,7 @@ memory_optimize ------------------------------- -.. py:function:: paddle.fluid.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=False) +.. py:function:: paddle.fluid.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=True) 历史遗留的内存优化策略，通过在不同operators间重用var内存来减少总内存消耗。 用一个简单的示例来解释该算法： diff --git a/doc/fluid/api_cn/fluid_cn/program_guard_cn.rst b/doc/fluid/api_cn/fluid_cn/program_guard_cn.rst index 9762d371b5ac9aa05dee176a8dcdc33be8b0bab0..553ae003e18e4cf738007bb15c194d5762c89604 100644 --- a/doc/fluid/api_cn/fluid_cn/program_guard_cn.rst +++ b/doc/fluid/api_cn/fluid_cn/program_guard_cn.rst @@ -7,9 +7,9 @@ program_guard -该函数应配合使用python的“with”语句来改变全局主程序(main program)和启动程序(startup program)。 +该函数应配合使用python的 ``with`` 语句来改变全局主程序(main program)和启动程序(startup program)。 -“with”语句块中的layer函数将在新的main program（主程序）中添加operators（算子）和variables（变量）。 + ``with`` 语句块中的layer函数将在新的main program（主程序）中添加operators（算子）和variables（变量）。 **代码示例** diff --git a/doc/fluid/api_cn/initializer_cn/BilinearInitializer_cn.rst b/doc/fluid/api_cn/initializer_cn/BilinearInitializer_cn.rst index 0a9500669a7e78a9f7051c1fd86fdada9a5ce59d..44719343da906b76b3a4d697c7b0371280d9b7f5 100644 --- a/doc/fluid/api_cn/initializer_cn/BilinearInitializer_cn.rst +++ b/doc/fluid/api_cn/initializer_cn/BilinearInitializer_cn.rst @@ -14,7 +14,7 @@ BilinearInitializer import paddle.fluid as fluid factor = 2 C = 2 - w_attr = fluid.initializer.ParamAttr( + w_attr = fluid.param_attr.ParamAttr( learning_rate=0., regularizer=fluid.regularizer.L2Decay(0.), initializer=fluid.initializer.Bilinear()) diff --git a/doc/fluid/api_cn/io_cn/PyReader_cn.rst b/doc/fluid/api_cn/io_cn/PyReader_cn.rst index 6eec67e408c7d2586495217ca551440cdc145865..b298ffa427731c49316e4e97c36317d808323ff1 100644 --- a/doc/fluid/api_cn/io_cn/PyReader_cn.rst +++ b/doc/fluid/api_cn/io_cn/PyReader_cn.rst @@ -26,7 +26,10 @@ PyReader .. code-block:: python - import paddle.fluid as fluid + import paddle + import paddle.fluid as fluid + import numpy as np + EPOCH_NUM = 3 ITER_NUM = 5 BATCH_SIZE = 3 @@ -68,7 +71,10 @@ PyReader .. code-block:: python - import paddle.fluid as fluid + import paddle + import paddle.fluid as fluid + import numpy as np + EPOCH_NUM = 3 ITER_NUM = 5 BATCH_SIZE = 10 @@ -137,7 +143,10 @@ PyReader .. code-block:: python + import paddle import paddle.fluid as fluid + import numpy as np + BATCH_SIZE = 10 def generator(): @@ -168,7 +177,10 @@ PyReader .. code-block:: python + import paddle import paddle.fluid as fluid + import numpy as np + BATCH_SIZE = 10 def generator(): @@ -211,7 +223,9 @@ PyReader .. code-block:: python - import paddle.fluid as fluid + import paddle.fluid as fluid + import numpy as np + EPOCH_NUM = 3 ITER_NUM = 15 BATCH_SIZE = 3 @@ -258,7 +272,10 @@ PyReader .. code-block:: python + import paddle import paddle.fluid as fluid + import numpy as np + EPOCH_NUM = 3 ITER_NUM = 15 BATCH_SIZE = 3 @@ -305,7 +322,9 @@ PyReader .. code-block:: python - import paddle.fluid as fluid + import paddle.fluid as fluid + import numpy as np + EPOCH_NUM = 3 ITER_NUM = 15 BATCH_SIZE = 3 diff --git a/doc/fluid/api_cn/layers_cn.rst b/doc/fluid/api_cn/layers_cn.rst index 69a2737d475db17089c0a9160d39039c2bab0fec..a71cb978bdf513992932dc519499738da2e0cb50 100644 --- a/doc/fluid/api_cn/layers_cn.rst +++ b/doc/fluid/api_cn/layers_cn.rst @@ -41,6 +41,7 @@ fluid.layers layers_cn/brelu_cn.rst layers_cn/cast_cn.rst layers_cn/ceil_cn.rst + layers_cn/center_loss_cn.rst layers_cn/chunk_eval_cn.rst layers_cn/clip_by_norm_cn.rst layers_cn/clip_cn.rst @@ -141,6 +142,7 @@ fluid.layers layers_cn/linear_lr_warmup_cn.rst layers_cn/linspace_cn.rst layers_cn/load_cn.rst + layers_cn/lod_append_cn.rst layers_cn/lod_reset_cn.rst layers_cn/log_cn.rst layers_cn/log_loss_cn.rst @@ -239,6 +241,7 @@ fluid.layers layers_cn/sequence_softmax_cn.rst layers_cn/sequence_unpad_cn.rst layers_cn/shape_cn.rst + layers_cn/shard_index_cn.rst layers_cn/shuffle_channel_cn.rst layers_cn/shuffle_cn.rst layers_cn/sigmoid_cn.rst @@ -247,6 +250,7 @@ fluid.layers layers_cn/sign_cn.rst layers_cn/similarity_focus_cn.rst layers_cn/sin_cn.rst + layers_cn/size_cn.rst layers_cn/slice_cn.rst layers_cn/smooth_l1_cn.rst layers_cn/soft_relu_cn.rst @@ -280,10 +284,14 @@ fluid.layers layers_cn/topk_cn.rst layers_cn/transpose_cn.rst layers_cn/tree_conv_cn.rst + layers_cn/unfold_cn.rst layers_cn/uniform_random_batch_size_like_cn.rst layers_cn/uniform_random_cn.rst + layers_cn/unique_cn.rst + layers_cn/unique_with_counts_cn.rst layers_cn/unsqueeze_cn.rst layers_cn/unstack_cn.rst + layers_cn/var_conv_2d_cn.rst layers_cn/warpctc_cn.rst layers_cn/where_cn.rst layers_cn/While_cn.rst diff --git a/doc/fluid/api_cn/layers_cn/auc_cn.rst b/doc/fluid/api_cn/layers_cn/auc_cn.rst index f49683671bbd0cbaa5777243139e063353d6d7bd..076b684fefbfcd6c676d288076e6ba0c6cc01ae6 100644 --- a/doc/fluid/api_cn/layers_cn/auc_cn.rst +++ b/doc/fluid/api_cn/layers_cn/auc_cn.rst @@ -25,7 +25,8 @@ auc - **topk** (int) - 只有预测输出的topk数才被用于auc - **slide_steps** - 计算批auc时，不仅用当前步也用先前步。slide_steps=1，表示用当前步；slide_steps = 3表示用当前步和前两步；slide_steps = 0，则用所有步 -返回：代表当前AUC的scalar +返回：代表当前AUC的一个元组 +返回的元组为auc_out, batch_auc_out, [batch_stat_pos, batch_stat_neg, stat_pos, stat_neg]。 返回类型：变量（Variable） diff --git a/doc/fluid/api_cn/layers_cn/batch_norm_cn.rst b/doc/fluid/api_cn/layers_cn/batch_norm_cn.rst index 3e3b22b865d884a694362cdbb290bab25b80fe91..b7be96ecade662ffc4caaec4e44041ddac2d4b01 100644 --- a/doc/fluid/api_cn/layers_cn/batch_norm_cn.rst +++ b/doc/fluid/api_cn/layers_cn/batch_norm_cn.rst @@ -33,20 +33,20 @@ batch_norm 参数： - - **input** (Variable) - 输入变量的排序，可以为 2, 3, 4, 5 + - **input** (Variable) - 输入变量的排序，可以为 2, 3, 4, 5。 - **act** （string，默认None）- 激活函数类型，linear|relu|prelu|... - **is_test** （bool,默认False） - 指示它是否在测试阶段。 - - **momentum** （float，默认0.9）- 此值用于计算 moving_mean 和 moving_var。更新公式为: :math:`moving\_mean = moving\_mean * momentum + new\_mean * (1. - momentum)` ， :math:`moving\_var = moving\_var * momentum + new\_var * (1. - momentum)` ， 默认值0.9. + - **momentum** （float，默认0.9）- 此值用于计算 moving_mean 和 moving_var。更新公式为: :math:`moving\_mean = moving\_mean * momentum + new\_mean * (1. - momentum)` ， :math:`moving\_var = moving\_var * momentum + new\_var * (1. - momentum)` ， 默认值0.9。 - **epsilon** （float，默认1e-05）- 加在分母上为了数值稳定的值。默认值为1e-5。 - - **param_attr** （ParamAttr|None） - batch_norm参数范围的属性，如果设为None或者是ParamAttr的一个属性，batch_norm创建ParamAttr为param_attr。如果没有设置param_attr的初始化函数，参数初始化为Xavier。默认：None - - **bias_attr** （ParamAttr|None） - batch_norm bias参数的属性，如果设为None或者是ParamAttr的一个属性，batch_norm创建ParamAttr为bias_attr。如果没有设置bias_attr的初始化函数，参数初始化为0。默认：None - - **data_layout** （string,默认NCHW) - NCHW|NHWC - - **in_place** （bool，默认False）- 得出batch norm可复用记忆的输入和输出 - - **name** （string，默认None）- 该层名称（可选）。若设为None，则自动为该层命名 - - **moving_mean_name** （string，默认None）- moving_mean的名称，存储全局Mean。如果将其设置为None, ``batch_norm`` 将随机命名全局平均值；否则， ``batch_norm`` 将命名全局平均值为 ``moving_mean_name`` - - **moving_variance_name** （string，默认None）- moving_variance的名称，存储全局变量。如果将其设置为None, ``batch_norm`` 将随机命名全局方差；否则， ``batch_norm`` 将命名全局方差为 ``moving_variance_name`` - - **do_model_average_for_mean_and_var** （bool，默认False）- 是否为mean和variance做模型均值 - - **fuse_with_relu** （bool）- 如果为True，batch norm后该操作符执行relu + - **param_attr** （ParamAttr|None） - batch_norm参数范围的属性，如果设为None或者是ParamAttr的一个属性，batch_norm创建ParamAttr为param_attr。如果没有设置param_attr的初始化函数，参数初始化为Xavier。默认：None。 + - **bias_attr** （ParamAttr|None） - batch_norm bias参数的属性，如果设为None或者是ParamAttr的一个属性，batch_norm创建ParamAttr为bias_attr。如果没有设置bias_attr的初始化函数，参数初始化为0。默认：None。 + - **data_layout** （string,默认NCHW) - NCHW|NHWC。 + - **in_place** （bool，默认False）- 得出batch norm可复用记忆的输入和输出。 + - **name** （string，默认None）- 该层名称（可选）。若设为None，则自动为该层命名。 + - **moving_mean_name** （string，默认None）- moving_mean的名称，存储全局Mean。如果将其设置为None, ``batch_norm`` 将随机命名全局平均值；否则， ``batch_norm`` 将命名全局平均值为 ``moving_mean_name`` 。 + - **moving_variance_name** （string，默认None）- moving_variance的名称，存储全局变量。如果将其设置为None, ``batch_norm`` 将随机命名全局方差；否则， ``batch_norm`` 将命名全局方差为 ``moving_variance_name`` 。 + - **do_model_average_for_mean_and_var** （bool，默认False）- 是否为mean和variance做模型均值。 + - **fuse_with_relu** （bool）- 如果为True，batch norm后该操作符执行relu。 - **use_global_stats** （bool, Default False） – 是否使用全局均值和方差。 在预测或测试模式下，将use_global_stats设置为true或将is_test设置为true，并且行为是等效的。 在训练模式中，当设置use_global_stats为True时，在训练期间也使用全局均值和方差。 返回： 张量，在输入中运用批正则后的结果 diff --git a/doc/fluid/api_cn/layers_cn/center_loss_cn.rst b/doc/fluid/api_cn/layers_cn/center_loss_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..ae7418e719b4c149393cd8b09228b314602d2748 --- /dev/null +++ b/doc/fluid/api_cn/layers_cn/center_loss_cn.rst @@ -0,0 +1,56 @@ +.. _cn_api_fluid_layers_center_loss: + +center_loss +------------------------------- + +.. py:function:: paddle.fluid.layers.center_loss(input, label, num_classes, alpha, param_attr, update_center=True) + +center_loss层 +该层接收一个来自于最后一个隐藏层的输出和目标标签作为输入，返回损失值。 +对于输入，\(X\)和标签\(Y\)，计算公式为： + + .. math:: + + out = \frac{1}{2}(X - Y)^2 + + + +参数: + + - **input** (Variable) - 形为[N x M]的2维张量 + - **label** (Variable) - groud truth,一个形为[N x 1]的2维张量，N表示batch size + - **num_class** (int) - 表示类别的数 + - **alpha** (float|Variable) - 学习率 + - **param_attr** (ParamAttr) - 参数初始化 + - **update_center** (bool) - 是否更新损失值 + +返回：形为[N x 1]的2维张量。 + +返回类型：Variable + +**代码示例**： + +.. code-block:: python + + import paddle.fluid as fluid + + input = fluid.layers.data(name='x',shape=[20,30],dtype='float32') + label = fluid.layers.data(name='y',shape=[20,1],dtype='int64') + num_classes = 1000 + alpha = 0.01 + param_attr = fluid.initializer.Xavier(uniform=False) + center_loss=fluid.layers.center_loss(input=input, + label=label, + num_classes=1000, + alpha=alpha, + param_attr=fluid.initializer.Xavier(uniform=False), + update_center=True) + + + + + + + + + diff --git a/doc/fluid/api_cn/layers_cn/chunk_eval_cn.rst b/doc/fluid/api_cn/layers_cn/chunk_eval_cn.rst index 7b693be3d3e4d1d71c4b523d059ea736beaf157f..7781b692151da6c782adda44869424471d14b62f 100644 --- a/doc/fluid/api_cn/layers_cn/chunk_eval_cn.rst +++ b/doc/fluid/api_cn/layers_cn/chunk_eval_cn.rst @@ -3,7 +3,7 @@ chunk_eval ------------------------------- -.. py:function:: paddle.fluid.layers.chunk_eval(input, label, chunk_scheme, num_chunk_types, excluded_chunk_types=None) +.. py:function:: paddle.fluid.layers.chunk_eval(input, label, chunk_scheme, num_chunk_types, excluded_chunk_types=None, sqe_length=None) 块估计（Chunk Evaluator） @@ -67,6 +67,7 @@ num_tag_type是标注规则中的标签类型数，num_chunk_type是块类型数 - **chunk_scheme** (str) - 标注规则，表示如何解码块。必须数IOB，IOE，IOBES或者plain。详情见描述 - **num_chunk_types** (int) - 块类型数。详情见描述 - **excluded_chunk_types** (list) - 列表包含块类型id，表示不在计数内的块类型。详情见描述 + - **seq_length** (Variable) - 当输入和标签是张量时，指定序列长度的一个1维张量 返回：元组（tuple），包含precision, recall, f1_score, num_infer_chunks, num_label_chunks, num_correct_chunks diff --git a/doc/fluid/api_cn/layers_cn/conv2d_transpose_cn.rst b/doc/fluid/api_cn/layers_cn/conv2d_transpose_cn.rst index feeab03fac675fd2eacd384309b0328373982099..7e7ea4a6e36278eb11cda44f5f27858e04ff7aa6 100644 --- a/doc/fluid/api_cn/layers_cn/conv2d_transpose_cn.rst +++ b/doc/fluid/api_cn/layers_cn/conv2d_transpose_cn.rst @@ -53,7 +53,10 @@ conv2d_transpose & H_{out}\in[H'_{out},H'_{out} + strides[0])\\ & W_{out}\in[W'_{out},W'_{out} + strides[1])\\ - +注意： +如果 ``output_size`` 为None，则 :math:`H_{out}` = :math:`H^\prime_{out}` , :math:`W_{out}` = :math:`W^\prime_{out}` ; +否则， 输出size的 :math:`H_{out}` 应当介于 :math:`H^\prime_{out}` +和 :math:`H^\prime_{out} + strides[0]` 之间, 并且输出size的 :math:`W_{out}` 应当介于 :math:`W^\prime_{out}` 和 :math:`W^\prime_{out} + strides[1]` 之间, ``conv2d_transpose`` 可以自动计算kernel大小。 参数: - **input** （Variable）- 输入张量，格式为[N, C, H, W] diff --git a/doc/fluid/api_cn/layers_cn/create_py_reader_by_data_cn.rst b/doc/fluid/api_cn/layers_cn/create_py_reader_by_data_cn.rst index ccc96f8720897bf0ffd4873693f0d9dc42ca0381..412bb63d851d3abacc47775446906fc31958b813 100644 --- a/doc/fluid/api_cn/layers_cn/create_py_reader_by_data_cn.rst +++ b/doc/fluid/api_cn/layers_cn/create_py_reader_by_data_cn.rst @@ -32,6 +32,9 @@ create_py_reader_by_data predict = fluid.layers.fc(input=img, size=10, act='softmax') loss = fluid.layers.cross_entropy(input=predict, label=label) return fluid.layers.mean(loss) + + MEMORY_OPT = False + USE_CUDA = False image = fluid.layers.data(name='image', shape=[1, 28, 28], dtype='float32') label = fluid.layers.data(name='label', shape=[1], dtype='int64') @@ -42,14 +45,23 @@ create_py_reader_by_data img, label = fluid.layers.read_file(reader) loss = network(img, label) # 一些网络定义 - fluid.Executor(fluid.CUDAPlace(0)).run(fluid.default_startup_program()) + place = fluid.CUDAPlace(0) if USE_CUDA else fluid.CPUPlace() + exe = fluid.Executor(place) + exe.run(fluid.default_startup_program()) + + build_strategy = fluid.BuildStrategy() + build_strategy.memory_optimize = True if MEMORY_OPT else False + compiled_prog = compiler.CompiledProgram( + fluid.default_main_program()).with_data_parallel( + loss_name=loss.name, + build_strategy=build_strategy, + exec_strategy=exec_strategy) - exe = fluid.ParallelExecutor(use_cuda=True, loss_name=loss.name) - for epoch_id in range(10): + for epoch_id in range(2): reader.start() try: while True: - exe.run(fetch_list=[loss.name]) + exe.run(compiled_prog, fetch_list=[loss.name]) except fluid.core.EOFException: reader.reset() diff --git a/doc/fluid/api_cn/layers_cn/density_prior_box_cn.rst b/doc/fluid/api_cn/layers_cn/density_prior_box_cn.rst index a15a5c684222b3982c565a00abac717ea1ff5391..d0d2b5d5d13b53a9361699121223ca2641c3f56d 100644 --- a/doc/fluid/api_cn/layers_cn/density_prior_box_cn.rst +++ b/doc/fluid/api_cn/layers_cn/density_prior_box_cn.rst @@ -9,10 +9,10 @@ density_prior_box **Density Prior Box Operator** 为SSD算法(Single Shot MultiBox Detector)生成density prior box。 -每个input的位置产生N个prior box，其中，N通过densities, fixed_sizes and fixed_ratios -的量来决定。在每个input位置附近的box center格点，通过此op生成。格点坐标由densities决定， -density prior box的量由fixed_sizes and fixed_ratios决定。显然地，fixed_sizes -和densities相等。对于densities中的densities_i： +每个 ``input`` 的位置产生N个prior box，其中，N通过 ``densities`` , ``fixed_sizes`` 和 ``fixed_ratios`` +的量来决定。在每个input位置附近的box center格点，通过此op生成。格点坐标由 ``densities`` 决定， +density prior box的量由 ``fixed_sizes`` 和 ``fixed_ratios`` 决定。显然地，``fixed_sizes`` +和 ``densities`` 相等。对于 ``densities`` 中的densities_i： .. math:: @@ -27,7 +27,7 @@ density prior box的量由fixed_sizes and fixed_ratios决定。显然地，fixed - **fixed_ratios** (list|tuple|None) - 被生成的density prior boxes的固定长度，如果该属性未被设置，同时 :attr:`densities` 和 :attr:`fix_sizes` 被设置，则 :attr:`aspect_ratios` 被用于生成 density prior boxes - **variance** (list|tuple) - 将被用于density prior boxes编码的方差，默认值为:[0.1, 0.1, 0.2, 0.2] - **clip(bool)** - 是否clip超出范围的box。默认值：False - - **step** (list|turple) - Prior boxes在宽度和高度的步长，如果step[0] == 0.0/step[1] == 0.0, input的the density prior boxes的高度/宽度的步长将被自动计算。默认值：Default: [0., 0.] + - **step** (list|tuple) - Prior boxes在宽度和高度的步长，如果step[0] == 0.0/step[1] == 0.0, input的the density prior boxes的高度/宽度的步长将被自动计算。默认值：Default: [0., 0.] - **offset** (float) - Prior boxes中心补偿值，默认为：0.5 - **flatten_to_2d** (bool) - 是否将output prior boxes和方差 ``flatten`` 至2维形状，第二个dim为4。默认值：False - **name(str)** - density prior box op的名字，默认值: None diff --git a/doc/fluid/api_cn/layers_cn/diag_cn.rst b/doc/fluid/api_cn/layers_cn/diag_cn.rst index 9313bc9bf6f11b55d821549d49f32691f35c4f6d..479dae4233fa4ef1932b9cdc88ab85418a358aa5 100644 --- a/doc/fluid/api_cn/layers_cn/diag_cn.rst +++ b/doc/fluid/api_cn/layers_cn/diag_cn.rst @@ -21,8 +21,10 @@ diag # [3, 0, 0] # [0, 4, 0] # [0, 0, 5] + import paddle.fluid as fluid - data = fluid.layers.diag(np.arange(3, 6)) + import numpy as np + data = fluid.layers.diag(np.arange(3, 6, dtype='int32')) diff --git a/doc/fluid/api_cn/layers_cn/double_buffer_cn.rst b/doc/fluid/api_cn/layers_cn/double_buffer_cn.rst index 90b0d7da7d5286b4c1e0e955b2d16521ae5a1d68..1a43bb279b1c505364a02fac2f3518af0c6584ea 100644 --- a/doc/fluid/api_cn/layers_cn/double_buffer_cn.rst +++ b/doc/fluid/api_cn/layers_cn/double_buffer_cn.rst @@ -24,6 +24,7 @@ double_buffer import paddle.fluid as fluid reader = fluid.layers.open_files(filenames=['mnist.recordio'], shapes=[[-1, 784], [-1, 1]], + lod_levels=[0, 0], dtypes=['float32', 'int64']) reader = fluid.layers.double_buffer(reader) img, label = fluid.layers.read_file(reader) diff --git a/doc/fluid/api_cn/layers_cn/edit_distance_cn.rst b/doc/fluid/api_cn/layers_cn/edit_distance_cn.rst index 308f4dfdd381d9087a87486c475caf1138acf603..37b4cd7df7f48283cbc5577dc3e2390e4944b49c 100644 --- a/doc/fluid/api_cn/layers_cn/edit_distance_cn.rst +++ b/doc/fluid/api_cn/layers_cn/edit_distance_cn.rst @@ -4,7 +4,7 @@ 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, input_length=None, label_length=None） 编辑距离算子 @@ -14,53 +14,37 @@ edit_distance “kitten”->“sitten”->“sittn”->“sitting” -输入为LoDTensor,包含假设字符串（带有表示批尺寸的总数）和分离信息（具体为LoD信息）。并且批尺寸大小的参照字符串和输入LoDTensor的顺序保持一致。 +输入为LoDTensor/Tensor,包含假设字符串（带有表示批尺寸的总数）和分离信息（具体为LoD信息或者 ``input_length`` ）。并且批尺寸大小的参照字符串和输入LoDTensor的顺序保持一致。 输出包含批尺寸大小的结果，代表一对字符串中每个字符串的编辑距离。如果Attr(normalized)为真，编辑距离则处以参照字符串的长度。 参数： - - **input** (Variable)-假设字符串的索引 - - **label** (Variable)-参照字符串的索引 + - **input** (Variable)-假设字符串的索引，为两列并且类型为int64 + - **label** (Variable)-参照字符串的索引，为两列并且类型为int64 - **normalized** (bool,默认为True)-表示是否用参照字符串的长度进行归一化 - **ignored_tokens** (list,默认为None)-计算编辑距离前需要移除的token - **name** (str)-该层名称，可选 -返回：[batch_size,1]中序列到序列到编辑距离 +返回：形为[batch_size,1]的编辑距离。 +sequence_num(Variable):形为[ ]的序列数 -返回类型：变量 - -**代码示例**： +**代码示例** .. code-block:: python import paddle.fluid as fluid - x = fluid.layers.data(name='x', shape=[1], dtype='int64') - y = fluid.layers.data(name='y', shape=[1], dtype='int64') - cost, _ = fluid.layers.edit_distance(input=x,label=y) - - cpu = fluid.core.CPUPlace() - exe = fluid.Executor(cpu) - exe.run(fluid.default_startup_program()) - - import numpy - x_ = numpy.random.randint(5, size=(2, 1)).astype('int64') - y_ = numpy.random.randint(5, size=(2, 1)).astype('int64') - - print(x_) - print(y_) - - x = fluid.create_lod_tensor(x_, [[2]], cpu) - y = fluid.create_lod_tensor(y_, [[2]], cpu) - - outs = exe.run(feed={'x':x, 'y':y}, fetch_list=[cost.name]) - - print(outs) - - - - - - - - + # 使用 LoDTensor + x_lod = fluid.layers.data(name='x_lod', shape=[1], dtype='int64', lod_level=1) + y_lod = fluid.layers.data(name='y_lod', shape=[1], dtype='int64', lod_level=1) + distance_lod, seq_num_lod = fluid.layers.edit_distance(input=x_lod, label=y_lod) + + # 使用 Tensor + x_seq_len = 5 + y_seq_len = 6 + x_pad = fluid.layers.data(name='x_pad', shape=[x_seq_len], dtype='int64') + y_pad = fluid.layers.data(name='y_pad', shape=[y_seq_len], dtype='int64') + x_len = fluid.layers.data(name='x_len', shape=[], dtype='int64') + y_len = fluid.layers.data(name='y_len', shape=[], dtype='int64') + distance_pad, seq_num_pad = fluid.layers.edit_distance( + input=x_pad, label=y_pad, input_length=x_len, label_length=y_len) \ No newline at end of file diff --git a/doc/fluid/api_cn/layers_cn/embedding_cn.rst b/doc/fluid/api_cn/layers_cn/embedding_cn.rst index deb5d03bbf181a0cc523619d819a05bcfcbd22ea..bd0229cb9d9619340e44efa83ae8d07692c2068a 100644 --- a/doc/fluid/api_cn/layers_cn/embedding_cn.rst +++ b/doc/fluid/api_cn/layers_cn/embedding_cn.rst @@ -11,7 +11,7 @@ embedding 所有的输入变量都作为局部变量传入LayerHelper构造器 参数： - - **input** (Variable)-包含IDs的张量 + - **input** (Variable)-包含IDs信息的int64的张量变量。 - **size** (tuple|list)-查找表参数的维度。应当有两个参数，一个代表嵌入矩阵字典的大小，一个代表每个嵌入向量的大小。 - **is_sparse** (bool)-代表是否用稀疏更新的标志 - **is_distributed** (bool)-是否从远程参数服务端运行查找表 diff --git a/doc/fluid/api_cn/layers_cn/expand_cn.rst b/doc/fluid/api_cn/layers_cn/expand_cn.rst index 5dcea43ef59274b00e626a6714af6f7ee21c6483..11d817d7319ba750c2b7a8aca9b80e58eb3a621d 100644 --- a/doc/fluid/api_cn/layers_cn/expand_cn.rst +++ b/doc/fluid/api_cn/layers_cn/expand_cn.rst @@ -38,7 +38,7 @@ expand运算会按给定的次数对输入各维度进行复制（tile）运算 .. code-block:: python import paddle.fluid as fluid - x = fluid.layers.data(name='x', shape=[10], dtype='float32') + x = fluid.layers.fill_constant(shape=[2, 3, 1], dtype='int32', value=0) out = fluid.layers.expand(x=x, expand_times=[1, 2, 2]) diff --git a/doc/fluid/api_cn/layers_cn/generate_proposal_labels_cn.rst b/doc/fluid/api_cn/layers_cn/generate_proposal_labels_cn.rst index cb0e4a2261cfcfc3f2c0c4e8b56c31b800ab97fd..c998df51ff202cd031d665b0f5d6eb12bc3421f4 100644 --- a/doc/fluid/api_cn/layers_cn/generate_proposal_labels_cn.rst +++ b/doc/fluid/api_cn/layers_cn/generate_proposal_labels_cn.rst @@ -49,8 +49,8 @@ RpnRois 是RPN的输出box， 并由 ``GenerateProposals`` 来进一步处理, append_batch_size=False, dtype='float32') im_info = fluid.layers.data(name='im_info', shape=[10, 3], append_batch_size=False, dtype='float32') - rois, labels_int32, bbox_targets, bbox_inside_weights, - bbox_outside_weights = fluid.layers.generate_proposal_labels( + rois, labels, bbox, inside_weights, + outside_weights = fluid.layers.generate_proposal_labels( rpn_rois, gt_classes, is_crowd, gt_boxes, im_info, class_nums=10) diff --git a/doc/fluid/api_cn/layers_cn/greater_equal_cn.rst b/doc/fluid/api_cn/layers_cn/greater_equal_cn.rst index 88d39aa2de089b5e9c66b8868a70a02dc260acbc..3053baef0f173a2b5031b2ec1b7df2b606d39255 100644 --- a/doc/fluid/api_cn/layers_cn/greater_equal_cn.rst +++ b/doc/fluid/api_cn/layers_cn/greater_equal_cn.rst @@ -21,6 +21,8 @@ greater_equal .. code-block:: python import paddle.fluid as fluid + label = fluid.layers.data(name='label', shape=[1], dtype='int64') + limit = fluid.layers.fill_constant(shape=[1], value=1, dtype='int64') out = fluid.layers.greater_equal(x=label, y=limit) diff --git a/doc/fluid/api_cn/layers_cn/greater_than_cn.rst b/doc/fluid/api_cn/layers_cn/greater_than_cn.rst index bce6b32ac27e531c8880ed78eb1c9b6dfafcc197..a2fd2104eca454e0959a00b8999daf2c512678c6 100644 --- a/doc/fluid/api_cn/layers_cn/greater_than_cn.rst +++ b/doc/fluid/api_cn/layers_cn/greater_than_cn.rst @@ -21,6 +21,8 @@ greater_than .. code-block:: python import paddle.fluid as fluid + label = fluid.layers.data(name='label', shape=[1], dtype='int64') + limit = fluid.layers.fill_constant(shape=[1], value=1, dtype='int64') out = fluid.layers.greater_than(x=label, y=limit) diff --git a/doc/fluid/api_cn/layers_cn/hash_cn.rst b/doc/fluid/api_cn/layers_cn/hash_cn.rst index cf102621f0b9e8d3ad6fb32b466cee1d5f7a7da5..ec165bfa7e02f7a1a355ca8787662a1b2d780297 100644 --- a/doc/fluid/api_cn/layers_cn/hash_cn.rst +++ b/doc/fluid/api_cn/layers_cn/hash_cn.rst @@ -16,10 +16,9 @@ hash 给出： # shape [2, 2] - input.data = [ + input.data = [[1, 2], - [3, 4]], - ] + [3, 4]] input.lod = [[0, 2]] @@ -46,12 +45,12 @@ hash output.lod = [[0, 2]] 参数： - - **input** (Variable) - 输入变量是一个 one-hot 词。输入变量的维数必须是2。 + - **input** (Variable) - 输入变量是一个 one-hot 词。输入变量的维数必须是2。支持Tensor与LodTensor。 - **hash_size** (int) - 哈希算法的空间大小。输出值将保持在 :math:`[0, hash\_size - 1]` 范围内。 - **num_hash** (int) - 哈希次数，默认为1。 - **name** (str, default None) - 该层的名称 -返回：哈希的结果变量，是一个lodtensor。 +返回：哈希的结果变量，与输入变量类型相同。 返回类型： Variable @@ -60,24 +59,16 @@ hash .. code-block:: python import paddle.fluid as fluid - import paddle.fluid.layers as layers - import numpy as np - - titles = fluid.layers.data(name='titles', shape=[1], dtype='int32', lod_level=1) - hash_r = fluid.layers.hash(name='hash_x', input=titles, num_hash=1, hash_size=1000) - place = fluid.core.CPUPlace() - exece = fluid.Executor(place) - exece.run(fluid.default_startup_program()) - - # 初始化Tensor - tensor = fluid.core.LoDTensor() - tensor.set(np.random.randint(0, 10, (3, 1)).astype("int32"), place) - # 设置LoD - tensor.set_recursive_sequence_lengths([[1, 1, 1]]) - - out = exece.run(feed={'titles': tensor}, fetch_list=[hash_r], return_numpy=False) + # titles形为[batch, 1] + titles = fluid.layers.data(name='titles', shape=[1], dtype='int32', lod_level=0) + # hash_r形为[batch, 2] + hash_r = fluid.layers.hash(name='hash_x', input=titles, num_hash=2, hash_size=1000) + # titles形为[batch, 1]并且拥有lod信息 + titles = fluid.layers.data(name='titles', shape=[1], dtype='int32', lod_level=1) + # hash_r形为[batch, 2]并且从titles继承lod信息 + hash_r = fluid.layers.hash(name='hash_x', input=titles, num_hash=2, hash_size=1000) diff --git a/doc/fluid/api_cn/layers_cn/isfinite_cn.rst b/doc/fluid/api_cn/layers_cn/isfinite_cn.rst index 7e0b8d870da77e9afab0fec2a6d573e1a842b41c..a7552a7f90965b842613d00875a90aa45465302f 100644 --- a/doc/fluid/api_cn/layers_cn/isfinite_cn.rst +++ b/doc/fluid/api_cn/layers_cn/isfinite_cn.rst @@ -22,7 +22,7 @@ isfinite var = fluid.layers.data(name="data", shape=(4, 6), dtype="float32") - out = fluid.layers.isfinite(v) + out = fluid.layers.isfinite(var) diff --git a/doc/fluid/api_cn/layers_cn/less_equal_cn.rst b/doc/fluid/api_cn/layers_cn/less_equal_cn.rst index 8f2ff9ccfdeb0749ac937eba141f20487247a14b..0087d32c3482d124c6e7ea77a9bc659b46bca2d0 100644 --- a/doc/fluid/api_cn/layers_cn/less_equal_cn.rst +++ b/doc/fluid/api_cn/layers_cn/less_equal_cn.rst @@ -21,6 +21,8 @@ less_equal .. code-block:: python import paddle.fluid as fluid + label = fluid.layers.data(name='label', shape=[1], dtype='int64') + limit = fluid.layers.fill_constant(shape=[1], value=1, dtype='int64') out = fluid.layers.less_equal(x=label, y=limit) diff --git a/doc/fluid/api_cn/layers_cn/lod_append_cn.rst b/doc/fluid/api_cn/layers_cn/lod_append_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..ac96e2db264c64b5de324e7d72b11943fea1bac1 --- /dev/null +++ b/doc/fluid/api_cn/layers_cn/lod_append_cn.rst @@ -0,0 +1,53 @@ +.. _cn_api_fluid_layers_lod_append: + +lod_append +------------------------------- + +.. py:function:: paddle.fluid.layers.lod_append(x, level) + +给 ``x`` 的LoD添加 ``level`` 。 + +简单示例： + +.. code-block:: python + + give a 1-level LodTensor x: + x.lod = [[2, 3, 1]] + x.data = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]] + x.dims = [6, 1] + + level:[1, 1, 1, 1, 1, 1] + + Then we get a 2-level LodTensor: + x.lod = [[2, 3, 1], [1, 1, 1, 1, 1, 1] + x.data = [[1.0], [2.0], [3.0], [4.0], [5.0], [6.0]] + x.dims = [6, 1] + +参数： + - **x** (Variable)-输入变量，可以是LoDTensor或tensor。 + - **level** (list|tuple|Variable)-预添加到x的LoD里的LoD level。 + +返回：一个有着新的LoD level的输出变量 + +返回类型：Variable + +Raise: ``ValueError`` - 如果y为None或者level不可迭代。 + +**代码示例：** + +.. code-block:: python + + import paddle.fluid as fluid + x = fluid.layers.data(name='x', shape=[6, 10], lod_level=1) + out = fluid.layers.lod_append(x, [1,1,1,1,1,1]) + + + + + + + + + + + diff --git a/doc/fluid/api_cn/layers_cn/lod_reset_cn.rst b/doc/fluid/api_cn/layers_cn/lod_reset_cn.rst index 12b41ffaa8ef529e0c06cb2d87e84541c792a4eb..91666f10f92fae756d0dba365cdf36e00bfacab7 100644 --- a/doc/fluid/api_cn/layers_cn/lod_reset_cn.rst +++ b/doc/fluid/api_cn/layers_cn/lod_reset_cn.rst @@ -6,7 +6,7 @@ lod_reset .. py:function:: paddle.fluid.layers.lod_reset(x, y=None, target_lod=None) -设定x的LoD为y或者target_lod。如果提供y，首先将y.lod指定为目标LoD,否则y.data将指定为目标LoD。如果未提供y，目标LoD则指定为target_lod。如果目标LoD指定为Y.data或target_lod，只提供一层LoD。 +设定 ``x`` 的LoD为 ``y`` 或者 ``target_lod`` 。如果提供 ``y`` ，首先将y.lod指定为目标LoD,否则y.data将指定为目标LoD。如果未提供y，目标LoD则指定为 ``target_lod`` 。如果目标LoD指定为y.data或 ``target_lod`` ，只提供一层LoD。 :: @@ -59,15 +59,15 @@ lod_reset out.dims = [6, 1] 参数： - - **x** (Variable)-输入变量，可以为Tensor或者LodTensor - - **y** (Variable|None)-若提供，输出的LoD则衍生自y - - **target_lod** (list|tuple|None)-一层LoD，y未提供时作为目标LoD + - **x** (Variable)-输入变量，可以为Tensor或者LoDTensor + - **y** (Variable|None)-若提供，输出的LoD则衍生自 ``y`` + - **target_lod** (list|tuple|None)-一层LoD，``y`` 未提供时作为目标LoD 返回：输出变量，该层指定为LoD 返回类型：变量 -抛出异常：``TypeError`` - 如果y和target_lod都为空 +抛出异常：``TypeError`` - 如果 ``y`` 和 ``target_lod`` 都为空 **代码示例**： diff --git a/doc/fluid/api_cn/layers_cn/logical_and_cn.rst b/doc/fluid/api_cn/layers_cn/logical_and_cn.rst index ecab68072984238e888929d88a2001ae2de6007e..11ab3305ce53808fdac865f421fce9c7c59339d8 100644 --- a/doc/fluid/api_cn/layers_cn/logical_and_cn.rst +++ b/doc/fluid/api_cn/layers_cn/logical_and_cn.rst @@ -7,7 +7,7 @@ logical_and logical_and算子 -它在X和Y上以元素方式操作，并返回Out。X、Y和Out是N维布尔张量（Tensor）。Out的每个元素的计算公式为： +它在 ``X`` 和 ``Y`` 上以元素方式操作，并返回 ``Out`` 。``X``、 ``Y`` 和 ``Out`` 是N维布尔张量（Tensor）。 ``Out`` 的每个元素的计算公式为： .. math:: Out = X \&\& Y @@ -29,9 +29,9 @@ logical_and算子 import paddle.fluid as fluid left = fluid.layers.data( - name='left', shape=[1], dtype='int32') + name='left', shape=[1], dtype='bool') right = fluid.layers.data( - name='right', shape=[1], dtype='int32') + name='right', shape=[1], dtype='bool') result = fluid.layers.logical_and(x=left, y=right) diff --git a/doc/fluid/api_cn/layers_cn/logical_not_cn.rst b/doc/fluid/api_cn/layers_cn/logical_not_cn.rst index 320c0cb4b1e98e0cc1f5d5a133ec53a40fdc70e1..bcd776f337773db6e2e564304b7b1a7448bb7818 100644 --- a/doc/fluid/api_cn/layers_cn/logical_not_cn.rst +++ b/doc/fluid/api_cn/layers_cn/logical_not_cn.rst @@ -7,7 +7,7 @@ logical_not logical_not算子 -它在X上以元素方式操作，并返回Out。X和Out是N维布尔张量（Tensor）。Out的每个元素的计算公式为： +它在 ``X`` 上以元素方式操作，并返回 ``Out`` 。 ``X`` 和 ``Out`` 是N维布尔张量（Tensor）。 ``Out`` 的每个元素的计算公式为： .. math:: Out = !X @@ -28,7 +28,7 @@ logical_not算子 import paddle.fluid as fluid left = fluid.layers.data( - name='left', shape=[1], dtype='int32') + name='left', shape=[1], dtype='bool') result = fluid.layers.logical_not(x=left) diff --git a/doc/fluid/api_cn/layers_cn/logical_or_cn.rst b/doc/fluid/api_cn/layers_cn/logical_or_cn.rst index fca2ff6293c7924a251a0ea96b1e375cc4a5faf0..bb1d22f3dc44d58d92b60d10634ac06b6ef47b87 100644 --- a/doc/fluid/api_cn/layers_cn/logical_or_cn.rst +++ b/doc/fluid/api_cn/layers_cn/logical_or_cn.rst @@ -7,7 +7,7 @@ logical_or logical_or算子 -它在X和Y上以元素方式操作，并返回Out。X、Y和Out是N维布尔张量（Tensor）。Out的每个元素的计算公式为： +它在 ``X`` 和 ``Y`` 上以元素方式操作，并返回 ``Out`` 。 ``X`` 、 ``Y`` 和 ``Out`` 是N维布尔张量（Tensor）。 ``Out`` 的每个元素的计算公式为： .. math:: Out = X || Y @@ -31,9 +31,9 @@ logical_or算子 import paddle.fluid as fluid left = fluid.layers.data( - name='left', shape=[1], dtype='int32') + name='left', shape=[1], dtype='bool') right = fluid.layers.data( - name='right', shape=[1], dtype='int32') + name='right', shape=[1], dtype='bool') result = fluid.layers.logical_or(x=left, y=right) diff --git a/doc/fluid/api_cn/layers_cn/logical_xor_cn.rst b/doc/fluid/api_cn/layers_cn/logical_xor_cn.rst index 4d08bea36bbada237c95a2833bbce9c08bf186ec..97523852437077d1d6b4ca421b796d03c94f35a4 100644 --- a/doc/fluid/api_cn/layers_cn/logical_xor_cn.rst +++ b/doc/fluid/api_cn/layers_cn/logical_xor_cn.rst @@ -7,7 +7,7 @@ logical_xor logical_xor算子 -它在X和Y上以元素方式操作，并返回Out。X、Y和Out是N维布尔张量（Tensor）。Out的每个元素的计算公式为： +它在 ``X`` 和 ``Y`` 上以元素方式操作，并返回 ``Out`` 。 ``X`` 、 ``Y`` 和 ``Out`` 是N维布尔张量（Tensor）。 ``Out`` 的每个元素的计算公式为： .. math:: Out = (X || Y) \&\& !(X \&\& Y) @@ -30,9 +30,9 @@ logical_xor算子 import paddle.fluid as fluid left = fluid.layers.data( - name='left', shape=[1], dtype='int32') + name='left', shape=[1], dtype='bool') right = fluid.layers.data( - name='right', shape=[1], dtype='int32') + name='right', shape=[1], dtype='bool') result = fluid.layers.logical_xor(x=left, y=right) diff --git a/doc/fluid/api_cn/layers_cn/lstm_cn.rst b/doc/fluid/api_cn/layers_cn/lstm_cn.rst index a99cc7affd564cecd0f8c4a533ecbfb48db336ae..8b60cdfc87547ba9667ad72042c07d7ed8ac4864 100644 --- a/doc/fluid/api_cn/layers_cn/lstm_cn.rst +++ b/doc/fluid/api_cn/layers_cn/lstm_cn.rst @@ -46,9 +46,9 @@ sigmoid的计算公式为： :math:`sigmoid(x) = 1 / (1 + e^{-x})` 。 返回： 三个张量， rnn_out, last_h, last_c: -- rnn_out为LSTM hidden的输出结果。形为(seq_len x batch_size x hidden_size)如果is_bidirec设置为True,则形为(seq_len x batch_sze hidden_size * 2) -- last_h(Tensor): LSTM最后一步的隐藏状态，形状为(num_layers x batch_size x hidden_size)；如果is_bidirec设置为True，形状为(num_layers*2 x batch_size x hidden_size) -- last_c(Tensor)： LSTM最后一步的cell状态，形状为(num_layers x batch_size x hidden_size)；如果is_bidirec设置为True，形状为(num_layers*2 x batch_size x hidden_size) +- rnn_out为LSTM hidden的输出结果。形为(seq_len x batch_size x hidden_size)如果 ``is_bidirec`` 设置为True,则形为(seq_len x batch_sze hidden_size * 2) +- last_h(Tensor): LSTM最后一步的隐藏状态，形状为(num_layers x batch_size x hidden_size)；如果 ``is_bidirec`` 设置为True，形状为(num_layers*2 x batch_size x hidden_size) +- last_c(Tensor)： LSTM最后一步的cell状态，形状为(num_layers x batch_size x hidden_size)；如果 ``is_bidirec`` 设置为True，形状为(num_layers*2 x batch_size x hidden_size) 返回类型: rnn_out(Tensor),last_h(Tensor),last_c(Tensor) @@ -57,6 +57,8 @@ sigmoid的计算公式为： :math:`sigmoid(x) = 1 / (1 + e^{-x})` 。 .. code-block:: python import paddle.fluid as fluid + import paddle.fluid.layers as layers + emb_dim = 256 vocab_size = 10000 data = fluid.layers.data(name='x', shape=[-1, 100, 1], diff --git a/doc/fluid/api_cn/layers_cn/lstm_unit_cn.rst b/doc/fluid/api_cn/layers_cn/lstm_unit_cn.rst index e0858f17496e123b849fe2feb04d66a996d42fc4..7e919a7d8482f08a9e12ec1454d8023381e2c676 100644 --- a/doc/fluid/api_cn/layers_cn/lstm_unit_cn.rst +++ b/doc/fluid/api_cn/layers_cn/lstm_unit_cn.rst @@ -36,8 +36,8 @@ lstm单元的输入包括 :math:`x_{t}` ， :math:`h_{t-1}` 和 :math:`c_{t-1}` - **hidden_t_prev** (Variable) - lstm单元的隐藏状态值，二维张量，shape为 M x S，M是批尺寸，N是lstm单元的大小 - **cell_t_prev** (Variable) - lstm单元的cell值，二维张量，shape为 M x S ，M是批尺寸，N是lstm单元的大小 - **forget_bias** (Variable) - lstm单元的遗忘bias - - **param_attr** (ParamAttr|None) - 可学习hidden-hidden权重的擦参数属性。如果设为None或者ParamAttr的一个属性，lstm_unit创建ParamAttr为param_attr。如果param_attr的初始化函数未设置，参数初始化为Xavier。默认：None - - **bias_attr** (ParamAttr|None) - 可学习bias权重的bias属性。如果设为False，输出单元中则不添加bias。如果设为None或者ParamAttr的一个属性，lstm_unit创建ParamAttr为bias_attr。如果bias_attr的初始化函数未设置，bias初始化为0.默认：None + - **param_attr** (ParamAttr|None) - 可学习hidden-hidden权重的擦参数属性。如果设为None或者 ``ParamAttr`` 的一个属性，lstm_unit创建 ``ParamAttr`` 为param_attr。如果param_attr的初始化函数未设置，参数初始化为Xavier。默认：None + - **bias_attr** (ParamAttr|None) - 可学习bias权重的bias属性。如果设为False，输出单元中则不添加bias。如果设为None或者 ``ParamAttr`` 的一个属性，lstm_unit创建 ``ParamAttr`` 为bias_attr。如果bias_attr的初始化函数未设置，bias初始化为0.默认：None - **name** (str|None) - 该层名称（可选）。若设为None，则自动为该层命名 返回：lstm单元的hidden(隐藏状态)值和cell值 diff --git a/doc/fluid/api_cn/layers_cn/matmul_cn.rst b/doc/fluid/api_cn/layers_cn/matmul_cn.rst index 8a47f6d05fe05344f1ed7521daa7c74e2c4aa89d..1b05d0789281e88b1a09e06de7dfc48ca6f1db40 100644 --- a/doc/fluid/api_cn/layers_cn/matmul_cn.rst +++ b/doc/fluid/api_cn/layers_cn/matmul_cn.rst @@ -10,11 +10,11 @@ matmul 对两个张量进行矩阵相乘 当前输入的张量可以为任意阶，但当任意一个输入的阶数大于3时，两个输入的阶必须相等。 -实际的操作取决于x,y的维度和 ``transpose_x`` , ``transpose_y`` 的标记值。具体如下： +实际的操作取决于 ``x`` , ``y`` 的维度和 ``transpose_x`` , ``transpose_y`` 的标记值。具体如下： -- 如果transpose值为真，则对应 ``tensor`` 的最后两维将被转置。如：x是一个shape=[D]的一阶张量，那么x在非转置形式中为[1,D]，在转置形式中为[D,1],而y则相反，在非转置形式中作为[D,1]，在转置形式中作为[1,D]。 +- 如果transpose值为真，则对应 ``tensor`` 的最后两维将被转置。如：``x``是一个shape=[D]的一阶张量，那么 ``x`` 在非转置形式中为[1,D]，在转置形式中为[D,1],而 ``y`` 则相反，在非转置形式中作为[D,1]，在转置形式中作为[1,D]。 -- 转置后，这两个`tensors`将为 2-D 或 n-D ,并依据下列规则进行矩阵相乘： +- 转置后，这两个tensors将为 2-D 或 n-D ,并依据下列规则进行矩阵相乘： - 如果两个都是2-D，则同普通矩阵一样进行矩阵相乘 - 如果任意一个是n-D，则将其视为驻留在最后两个维度的矩阵堆栈，并在两个张量上应用支持广播的批处理矩阵乘法。 @@ -29,7 +29,7 @@ matmul - **alpha** (float)-输出比例。默认为1.0 - **name** (str|None)-该层名称（可选）。如果设置为空，则自动为该层命名 -返回：张量乘积变量 +返回：Tensor或者LoDTensor变量 返回类型：变量（Variable） diff --git a/doc/fluid/api_cn/layers_cn/not_equal_cn.rst b/doc/fluid/api_cn/layers_cn/not_equal_cn.rst index 86c3d0266fca9a160c0975ba51da83d8847ba0dd..e2ef5c2d3512d948ec4904859c53f0d5bc8fef8b 100644 --- a/doc/fluid/api_cn/layers_cn/not_equal_cn.rst +++ b/doc/fluid/api_cn/layers_cn/not_equal_cn.rst @@ -21,6 +21,9 @@ not_equal .. code-block:: python import paddle.fluid as fluid + + label = fluid.layers.data(name='label', shape=[1], dtype='int64') + limit = fluid.layers.fill_constant(shape=[1], value=1, dtype='int64') out = fluid.layers.not_equal(x=label, y=limit) diff --git a/doc/fluid/api_cn/layers_cn/one_hot_cn.rst b/doc/fluid/api_cn/layers_cn/one_hot_cn.rst index d3ed87ff7fc461d891cb4379cbe3b80f3e6eee0b..d4d391e758e8b08d5f7c978d061958059e8cc8fe 100644 --- a/doc/fluid/api_cn/layers_cn/one_hot_cn.rst +++ b/doc/fluid/api_cn/layers_cn/one_hot_cn.rst @@ -3,13 +3,14 @@ one_hot ------------------------------- -.. py:function:: paddle.fluid.layers.one_hot(input, depth) +.. py:function:: paddle.fluid.layers.one_hot(input, depth, allow_out_of_range=False) 该层创建输入指数的one-hot表示 参数： - - **input** (Variable)-输入指数，最后维度必须为1 - - **depth** (scalar)-整数，定义one-hot维度的深度 + - **input** (Variable) - 输入指数，最后维度必须为1 + - **depth** (scalar) - 整数，定义one-hot维度的深度 + - **allow_out_of_range** - bool值，指明输入的索引是否可以超出[0, depth]。当输入索引超出范围时，如果 ``allow_out_of_range`` 为False，则会引发异常，如果设置为True，超出的部分会以0填充。 返回：输入的one-hot表示 diff --git a/doc/fluid/api_cn/layers_cn/ones_like_cn.rst b/doc/fluid/api_cn/layers_cn/ones_like_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..06082a02bae8d5b6e1595d3adafe5aea063dd110 --- /dev/null +++ b/doc/fluid/api_cn/layers_cn/ones_like_cn.rst @@ -0,0 +1,31 @@ +.. _cn_api_fluid_layers_ones_like: + +ones_like +------------------------------- + +.. py:function:: paddle.fluid.layers.ones_like(x, out=None) + +ones_like + +该功能创建一个形状与类型与x相似的张量，初始值为1。 + + +参数： + - **x** (Variable) - 指定形状与数据类型的输入张量 + - **out** (Variable)-输出张量 + +返回：输出张量 + +返回类型：变量（Variable） + +**代码示例**： + +.. code-block:: python + + import paddle.fluid as fluid + + x = fluid.layers.data(name='x', dtype='float32', shape=[3], append_batch_size=False) + data = fluid.layers.ones_like(x) # [1.0, 1.0, 1.0] + + + diff --git a/doc/fluid/api_cn/layers_cn/pad_cn.rst b/doc/fluid/api_cn/layers_cn/pad_cn.rst index d3fde596d1ac121221cf394925f888ab8f9c672e..b2a144d2e03bc392d1f938a0ccc47edbb792f367 100644 --- a/doc/fluid/api_cn/layers_cn/pad_cn.rst +++ b/doc/fluid/api_cn/layers_cn/pad_cn.rst @@ -6,7 +6,7 @@ pad .. py:function:: paddle.fluid.layers.pad(x, paddings, pad_value=0.0, name=None) 在张量上加上一个由 ``pad_value`` 给出的常数值，填充宽度由 ``paddings`` 指定。 -其中，维度 ``i`` 中 ``x`` 内容前填充的值个数用 ``paddings[i]`` 表示，维度 ``i`` 中 ``x`` 内容后填充的值个数用 ``paddings[i+1]`` 表示。 +其中，维度 ``i`` 中 ``x`` 内容前填充的值个数用 ``paddings[2i]`` 表示，维度 ``i`` 中 ``x`` 内容后填充的值个数用 ``paddings[2i+1]`` 表示。 一个例子: diff --git a/doc/fluid/api_cn/layers_cn/reduce_all_cn.rst b/doc/fluid/api_cn/layers_cn/reduce_all_cn.rst index a027f53c992d52ce2d5ff5cc3a3b42a3d92b9bc3..ff22299cc213d26904620d949786ae3f3e063fd4 100644 --- a/doc/fluid/api_cn/layers_cn/reduce_all_cn.rst +++ b/doc/fluid/api_cn/layers_cn/reduce_all_cn.rst @@ -22,16 +22,19 @@ reduce_all .. code-block:: python - # x是一个布尔型Tensor，元素如下: - # [[True, False] - # [True, True]] - # 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。 import paddle.fluid as fluid import paddle.fluid.layers as layers import numpy as np - fluid.layers.reduce_all(x) # False - fluid.layers.reduce_all(x, dim=0) # [True, False] - fluid.layers.reduce_all(x, dim=-1) # [False, True] - fluid.layers.reduce_all(x, dim=1, - keep_dim=True) # [[False], [True]] + + # x是一个布尔型Tensor，元素如下: + # [[True, False] + # [True, True]] + x = layers.assign(np.array([[1, 0], [1, 1]], dtype='int32')) + x = layers.cast(x, 'bool') + + out = layers.reduce_all(x) # False + out = layers.reduce_all(x, dim=0) # [True, False] + out = layers.reduce_all(x, dim=-1) # [False, True] + + out = layers.reduce_all(x, dim=1, keep_dim=True) # [[False], [True]] diff --git a/doc/fluid/api_cn/layers_cn/reduce_any_cn.rst b/doc/fluid/api_cn/layers_cn/reduce_any_cn.rst index 60050c1c01cf299fb98339228077b2728b7d7f51..ae925dddc2d6891d037a3d1e93910c4afbada6d0 100644 --- a/doc/fluid/api_cn/layers_cn/reduce_any_cn.rst +++ b/doc/fluid/api_cn/layers_cn/reduce_any_cn.rst @@ -22,19 +22,21 @@ reduce_any .. code-block:: python - # x是一个布尔型Tensor，元素如下: - # [[True, False] - # [False, False]] - # 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。 import paddle.fluid as fluid import paddle.fluid.layers as layers import numpy as np - fluid.layers.reduce_any(x) # True - fluid.layers.reduce_any(x, dim=0) # [True, False] - fluid.layers.reduce_any(x, dim=-1) # [True, False] - fluid.layers.reduce_any(x, dim=1, - keep_dim=True) # [[True], [False]] + # x是一个布尔型Tensor，元素如下: + # [[True, False] + # [False, False]] + x = layers.assign(np.array([[1, 0], [0, 0]], dtype='int32')) + x = layers.cast(x, 'bool') + + out = layers.reduce_any(x) # True + out = layers.reduce_any(x, dim=0) # [True, False] + out = layers.reduce_any(x, dim=-1) # [True, False] + out = layers.reduce_any(x, dim=1, + keep_dim=True) # [[True], [False]] diff --git a/doc/fluid/api_cn/layers_cn/roi_perspective_transform_cn.rst b/doc/fluid/api_cn/layers_cn/roi_perspective_transform_cn.rst index 0bb8208595b71c07aff21e815703c0f91b1cef31..0c3c5102b2a2eea6ebf563de0b28b920e137369a 100644 --- a/doc/fluid/api_cn/layers_cn/roi_perspective_transform_cn.rst +++ b/doc/fluid/api_cn/layers_cn/roi_perspective_transform_cn.rst @@ -15,9 +15,12 @@ roi_perspective_transform - **spatial_scale** (float) - 空间尺度因子，用于缩放ROI坐标，默认：1.0。 返回： - ``ROIPerspectiveTransformOp`` 的输出，它是一个4维张量，形为 (num_rois,channels,transformed_h,transformed_w) +三变量的一个元组。 (out, mask, transform_matrix) + - ``out`` : ``ROIPerspectiveTransformOp`` 的输出，它是一个4维张量，形为 (num_rois,channels,transformed_h,transformed_w)。 + - ``mask`` : ``ROIPerspectiveTransformOp`` 的掩码，它是一个4维张量，形为 (num_rois,1,transformed_h,transformed_w)。 + - ``transform_matrix`` : ``ROIPerspectiveTransformOp`` 的转换矩阵，它是一个2维张量，形为 (num_rois,9)。 -返回类型：变量（Variable） +返回类型：元组 **代码示例**： @@ -27,7 +30,7 @@ roi_perspective_transform x = fluid.layers.data(name='x', shape=[256, 28, 28], dtype='float32') rois = fluid.layers.data(name='rois', shape=[8], lod_level=1, dtype='float32') - out = fluid.layers.roi_perspective_transform(x, rois, 7, 7, 1.0) + out, mask, transform_matrix = fluid.layers.roi_perspective_transform(x, rois, 7, 7, 1.0) diff --git a/doc/fluid/api_cn/layers_cn/sequence_enumerate_cn.rst b/doc/fluid/api_cn/layers_cn/sequence_enumerate_cn.rst index ad8dd4f6c1930e7b3646397c7355b5429e530808..c2fef0e524b93c7ddb922ffc9400f9c1e85c4315 100644 --- a/doc/fluid/api_cn/layers_cn/sequence_enumerate_cn.rst +++ b/doc/fluid/api_cn/layers_cn/sequence_enumerate_cn.rst @@ -32,7 +32,7 @@ sequence_enumerate .. code-block:: python import paddle.fluid as fluid - x = fluid.layers.data(shape[-1, 1], dtype='int32', lod_level=1) + x = fluid.layers.data(name='x',shape=[-1, 1], dtype='int32', lod_level=1) out = fluid.layers.sequence_enumerate(input=x, win_size=3, pad_value=0) diff --git a/doc/fluid/api_cn/layers_cn/shard_index_cn.rst b/doc/fluid/api_cn/layers_cn/shard_index_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..26b7b1bedfc051ea577c42649438e0b39720a285 --- /dev/null +++ b/doc/fluid/api_cn/layers_cn/shard_index_cn.rst @@ -0,0 +1,67 @@ +.. _cn_api_fluid_layers_shard_index: + +shard_index +------------------------------- + +.. py:function:: paddle.fluid.layers.shard_index(input, index_num, nshards, shard_id, ignore_value=-1) + +该层为输入创建碎片化索引，通常在模型和数据并行混合训练时使用，索引数据（通常是标签）应该在每一个trainer里面被计算，通过 +:: + + assert index_num % nshards == 0 + + shard_size = index_num / nshards + + 如果 x / shard_size == shard_id + + y = x % shard_size + + 否则 + + y = ignore_value + +我们使用分布式 ``one-hot`` 表示来展示该层如何使用， 分布式的 ``one-hot`` 表示被分割为多个碎片, 碎片索引里不为1的都使用0来填充。为了在每一个trainer里面创建碎片化的表示，原始的索引应该先进行计算(i.e. sharded)。我们来看个例子： + +.. code-block:: text + + X 是一个整形张量 + X.shape = [4, 1] + X.data = [[1], [6], [12], [19]] + + 假设 index_num = 20 并且 nshards = 2, 我们可以得到 shard_size = 10 + + 如果 shard_id == 0, 我们得到输出: + Out.shape = [4, 1] + Out.data = [[1], [6], [-1], [-1]] + 如果 shard_id == 1, 我们得到输出: + Out.shape = [4, 1] + Out.data = [[-1], [-1], [2], [9]] + + 上面的例子中默认 ignore_value = -1 + +参数： + - **input** (Variable）- 输入的索引，最后的维度应该为1 + - **index_num** (scalar) - 定义索引长度的整形参数 + - **nshards** (scalar) - shards数量 + - **shard_id** (scalar) - 当前碎片的索引 + - **ignore_value** (scalar) - 超出碎片索引范围的整型值 + +返回： 输入的碎片索引 + +返回类型： Variable + +**代码示例：** + +.. code-block:: python + + import paddle.fluid as fluid + label = fluid.layers.data(name="label", shape=[1], dtype="int64") + shard_label = fluid.layers.shard_index(input=label, + index_num=20, + nshards=2, + shard_id=0) + + + + + diff --git a/doc/fluid/api_cn/layers_cn/sign_cn.rst b/doc/fluid/api_cn/layers_cn/sign_cn.rst index 11eb6e3ff618acc4b34f607029ab3ac461c51093..988d68963d08ce1fc6f3e194e46c5597bd99a7c2 100644 --- a/doc/fluid/api_cn/layers_cn/sign_cn.rst +++ b/doc/fluid/api_cn/layers_cn/sign_cn.rst @@ -18,9 +18,11 @@ sign .. code-block:: python - # [1, 0, -1] import paddle.fluid as fluid - data = fluid.layers.sign(np.array([3, 0, -2])) + import numpy as np + + # [1, 0, -1] + data = fluid.layers.sign(np.array([3, 0, -2], dtype='int32')) diff --git a/doc/fluid/api_cn/layers_cn/sin_cn.rst b/doc/fluid/api_cn/layers_cn/sin_cn.rst index a9b2250da81eea4a2517b2bc530abc47d09ef155..81898e423ee8c5c093a23a77995d76f074a92823 100644 --- a/doc/fluid/api_cn/layers_cn/sin_cn.rst +++ b/doc/fluid/api_cn/layers_cn/sin_cn.rst @@ -12,7 +12,6 @@ sin 参数: - - **x** - sin算子的输入 - **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn diff --git a/doc/fluid/api_cn/layers_cn/size_cn.rst b/doc/fluid/api_cn/layers_cn/size_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..de6f3ad93a884ff4a2ea64349b4b48977cd28d4b --- /dev/null +++ b/doc/fluid/api_cn/layers_cn/size_cn.rst @@ -0,0 +1,27 @@ +.. _cn_api_fluid_layers_size: + +size +------------------------------- + +.. py:function:: paddle.fluid.layers.size(input) + +size层 + +返回一个形为[1]的int64类型的张量，代表着输入张量的元素的数量。 + + +参数： + - **input** - 输入的变量 + + +返回：输入变量的元素的数量。 + +**代码示例**： + +.. code-block:: python + + import paddle.fluid.layers as layers + + input = layers.data( + name="input", shape=[3, 100], dtype="float32", append_batch_size=False) + rank = layers.size(input) # 300 \ No newline at end of file diff --git a/doc/fluid/api_cn/layers_cn/soft_relu_cn.rst b/doc/fluid/api_cn/layers_cn/soft_relu_cn.rst index c9e678cc61f1cd338638b57944d1ac602464f857..0c8e412f00a6900e72559b40e48e6b7c5db5c361 100644 --- a/doc/fluid/api_cn/layers_cn/soft_relu_cn.rst +++ b/doc/fluid/api_cn/layers_cn/soft_relu_cn.rst @@ -7,7 +7,7 @@ soft_relu SoftRelu 激活函数 -.. math:: out=ln(1+exp(max(min(x,threshold),threshold)) +.. math:: out=ln(1+exp(max(min(x,threshold),threshold))) 参数: - **x** (variable) - SoftRelu operator的输入 diff --git a/doc/fluid/api_cn/layers_cn/space_to_depth_cn.rst b/doc/fluid/api_cn/layers_cn/space_to_depth_cn.rst index 3c5824983c53fcf32c447874cfecf6cfc1b534f3..d72948469b5b2c443a8650e98c8c70eb96e24e70 100644 --- a/doc/fluid/api_cn/layers_cn/space_to_depth_cn.rst +++ b/doc/fluid/api_cn/layers_cn/space_to_depth_cn.rst @@ -44,7 +44,7 @@ space_to_depth space_to_depthed = fluid.layers.space_to_depth( x=data, blocksize=2) - exe = fluid.Executor(fluid.CUDAPlace(0)) + exe = fluid.Executor(fluid.CPUPlace()) data_np = np.arange(0,16).reshape((1,4,2,2)).astype('float32') out_main = exe.run(fluid.default_main_program(), feed={'data': data_np}, diff --git a/doc/fluid/api_cn/layers_cn/split_cn.rst b/doc/fluid/api_cn/layers_cn/split_cn.rst index ad7fca6094155389428241f4207e3be739421fe4..975699208bf6748ef998f31d30b814ee6341fd1c 100644 --- a/doc/fluid/api_cn/layers_cn/split_cn.rst +++ b/doc/fluid/api_cn/layers_cn/split_cn.rst @@ -27,7 +27,7 @@ split input = fluid.layers.data( name="input", shape=[3, 9, 5], dtype="float32") - x0, x1, x2 = fluid.layers.split(x, num_or_sections=3, dim=2) + x0, x1, x2 = fluid.layers.split(input, num_or_sections=3, dim=2) # x0.shape [-1, 3, 3, 5] # x1.shape [-1, 3, 3, 5] # x2.shape [-1, 3, 3, 5] diff --git a/doc/fluid/api_cn/layers_cn/unfold_cn.rst b/doc/fluid/api_cn/layers_cn/unfold_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..ce60f025e7774057ddffc676f27bcc79d56c6667 --- /dev/null +++ b/doc/fluid/api_cn/layers_cn/unfold_cn.rst @@ -0,0 +1,51 @@ +.. _cn_api_fluid_layers_unfold: + +unfold +------------------------------- + +.. py:function:: paddle.fluid.layers.unfold(x, kernel_size, strides=1, paddings=0, dilation=1, name=None) + +该函数会将在输入 ``x`` 上滑动的filter block转换为一列缓存数据。对于每一个卷积过滤器下的block，下面的元素都会被重新排成一列，当滑动的卷积过滤器走过整个特征图时，将会形成一系列的列。 +对于每一个输入形为[N, C, H, W]的 ``x`` ，都将会按照下面公式计算出一个形为[N, Cout, Lout]的输出。 + + +.. math:: + + dkernel[0] &= dilations[0] * (kernel\_sizes[0] - 1) + 1 + + dkernel[1] &= dilations[1] * (kernel\_sizes[1] - 1) + 1 + + hout &= \frac{H + paddings[0] + paddings[2] - dkernel[0]}{strides[0]} + 1 + + wout &= \frac{W + paddings[1] + paddings[3] - dkernel[1]}{strides[1]} + 1 + + Cout &= C * kernel\_sizes[0] * kernel\_sizes[1] + + Lout &= hout * wout + +参数： + - **x** (Variable) – 格式为[N, C, H, W]的输入张量 + - **kernel_size** (int|list) – 卷积核的尺寸，应该为[k_h, k_w],或者为一个整型k，处理为[k, k] + - **strides** (int|list) – 卷积步长，应该为[stride_h, stride_w],或者为一个整型stride，处理为[stride, stride],默认为[1, 1] + - **paddings** (int|list) – 每个维度的扩展, 应该为[padding_top, padding_left，padding_bottom, padding_right]或者[padding_h, padding_w]或者一个整型padding。如果给了[padding_h, padding_w],则应该被扩展为[padding_h, padding_w, padding_h, padding_w]. 如果给了一个整型的padding，则会使用[padding, padding, padding, padding]，默认为[0, 0, 0, 0] + - **dilations** (int|list) – 卷积膨胀，应当为[dilation_h, dilation_w]，或者一个整型的dilation处理为[dilation, dilation]。默认为[1, 1]。 + + +返回： + 滑动block的输出张量，形状如上面所描述的[N, Cout, Lout]，Cout每一个滑动block里面值的总数，Lout是滑动block的总数. + +返回类型：（Variable） + +**代码示例**: + +.. code-block:: python + + import paddle.fluid as fluid + x = fluid.layers.data(name = 'data', shape = [3, 224, 224], dtype = 'float32') + y = fluid.layers.unfold(x, [3, 3], 1, 1, 1) + + + + + + diff --git a/doc/fluid/api_cn/layers_cn/unique_cn.rst b/doc/fluid/api_cn/layers_cn/unique_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..719f4e15dfc303b6d457aa24dbb7e0f9a3864d6c --- /dev/null +++ b/doc/fluid/api_cn/layers_cn/unique_cn.rst @@ -0,0 +1,35 @@ +.. _cn_api_fluid_layers_unique: + +unique +------------------------------- + +.. py:function:: paddle.fluid.layers.unique(x, dtype='int32') + +unique为 ``x`` 返回一个unique张量和一个指向该unique张量的索引。 + +参数： + - **x** (Variable) - 一个1维输入张量 + - **dtype** (np.dtype|core.VarDesc.VarType|str) – 索引张量的类型，int32，int64。 + +返回：元组(out, index)。 ``out`` 为 ``x`` 的指定dtype的unique张量, ``index`` 是一个指向 ``out`` 的索引张量, 用户可以通过该函数来转换原始的 ``x`` 张量的索引。 + +返回类型：元组(tuple) + +**代码示例**： + +.. code-block:: python + + import numpy as np + import paddle.fluid as fluid + x = fluid.assign(np.array([2, 3, 3, 1, 5, 3], dtype='int32')) + out, index = fluid.layers.unique(x) # out is [2, 3, 1, 5]; index is [0, 1, 1, 2, 3, 1] + + + + + + + + + + diff --git a/doc/fluid/api_cn/layers_cn/unique_with_counts_cn.rst b/doc/fluid/api_cn/layers_cn/unique_with_counts_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..83544944ee8b32e77c31b47c08f344d5646cfb3e --- /dev/null +++ b/doc/fluid/api_cn/layers_cn/unique_with_counts_cn.rst @@ -0,0 +1,37 @@ +.. _cn_api_fluid_layers_unique_with_counts: + +unique_with_counts +------------------------------- + +.. py:function:: paddle.fluid.layers.unique_with_counts(x, dtype='int32') + +unique_with_count为 ``x`` 返回一个unique张量和一个指向该unique张量的索引以及 ``x`` 中unique元素的数量。 + +参数： + - **x** (Variable) - 一个1维输入张量 + - **dtype** (np.dtype|core.VarDesc.VarType|str) – 索引张量的类型，int32，int64。 + +返回：元组(out, index, count)。 ``out`` 为 ``x`` 的指定dtype的unique张量, ``index`` 是一个指向 ``out`` 的索引张量, 用户可以通过该函数来转换原始的 ``x`` 张量的索引， ``count`` 是 ``x`` 中unique元素的数量。 + +返回类型：元组(tuple) + +**代码示例**： + +.. code-block:: python + + import numpy as np + import paddle.fluid as fluid + x = fluid.assign(np.array([2, 3, 3, 1, 5, 3], dtype='int32')) + out, index, count = fluid.layers.unique_with_counts(x) # out is [2, 3, 1, 5]; + # index is [0, 1, 1, 2, 3, 1]; + # count is [1, 3, 1, 1] + + + + + + + + + + diff --git a/doc/fluid/api_cn/layers_cn/var_conv_2d_cn.rst b/doc/fluid/api_cn/layers_cn/var_conv_2d_cn.rst new file mode 100644 index 0000000000000000000000000000000000000000..2eab3f30f66a267021ec360ce4054ba469e277f5 --- /dev/null +++ b/doc/fluid/api_cn/layers_cn/var_conv_2d_cn.rst @@ -0,0 +1,63 @@ +.. _cn_api_fluid_layers_var_conv_2d: + +var_conv_2d +------------------------------- + +.. py:function:: paddle.fluid.layers.var_conv_2d(input, row, col, input_channel, output_channel, filter_size, stride=1, param_attr=None, act=None, dtype='float32', name=None) + +var_conv_2d层依据给定的参数来计算输出， ``input`` 、 ``row`` 和 ``col`` 都是1-level的 ``LodTensor`` 卷积操作与普通的conv2d卷积层一样，值得注意的是，输入数据的第二个维度即input.dim[1]应该为1。 +如果 ``input_channel`` 是2，并且给了如下的row lodTensor 和 col lodTensor: + +.. code-block:: text + + row.lod = [[5, 4]] + col.lod = [[6, 7]] + 输入是一个lodTensor: + input.lod = [[60, 56]] # where 60 = input_channel * 5 * 6 + input.dims = [116, 1] # where 116 = 60 + 56 + 如果设置 output_channel 为3, filter_size 为 [3, 3], stride 为 [1, 1]: + output.lod = [[90, 84]] # where 90 = output_channel * [(5-1)/stride + 1] * [(6-1)/stride + 1] + output.dims = [174, 1] # where 174 = 90 + 84 + +参数: + - **input** (Variable) – dims[1]等于1的1-level的LodTensor。 + - **row** (Variable) – 1-level的LodTensor提供height。 + - **col** (Variable) – 1-level的LodTensor提供width。 + - **input_channel** (int) – 输入通道的数目。 + - **output_channel** (int) – 输出通道的数目。 + - **filter_size** (int|tuple|None) – 过滤器尺寸。 如果是元组，则应当为两个整型数字(filter_size_H, filter_size_W)。否则，过滤器会变为正方形。 + - **stride** (int|tuple) – 步长。 如果是元组，则应当为两个整型数字(stride_H, stride_W)。否则，stride_H = stride_W = stride。默认: stride = 1. + - **param_attr** (ParamAttr|None) – 为var_conv2d可学习的权重分配参数属性如果设置为None，或者ParamAttr的一个属性, var_conv2d将会创建ParamAttr做为param_attr。如果param_attr的初始化没有设定，参数将会以 \(Normal(0.0, std)\),进行初始化，\(std\) 为 \((\frac{2.0 }{filter\_elem\_num})^{0.5}\). 默认: None。 + - **act** (str) – 激活类型，如果设置为None，则不会激活。默认:None + - **dtype** ('float32') – 输出与参数的数据类型 + - **name** (str|None) – 层名。如果没有设置，将会被自动命名。默认: None。 + + +返回: 由该层指定LoD的输出变量 + +返回类型: 变量(Variable) + +**代码示例**： + +.. code-block:: python + + import numpy as np + from paddle.fluid import layers + + x_lod_tensor = layers.data(name='x', shape=[1], lod_level=1) + row_lod_tensor = layers.data(name='row', shape=[6], lod_level=1) + col_lod_tensor = layers.data(name='col', shape=[6], lod_level=1) + out = layers.var_conv_2d(input=x_lod_tensor, + row=row_lod_tensor, + col=col_lod_tensor, + input_channel=3, + output_channel=5, + filter_size=[3, 3], + stride=1) + + + + + + + diff --git a/doc/fluid/api_cn/layers_cn/where_cn.rst b/doc/fluid/api_cn/layers_cn/where_cn.rst index 9222314af365ab4bf5df28ad888e13c01def001e..fdb6065068061fff040ce2b2a8e87885ff3d01fd 100644 --- a/doc/fluid/api_cn/layers_cn/where_cn.rst +++ b/doc/fluid/api_cn/layers_cn/where_cn.rst @@ -23,15 +23,20 @@ where import paddle.fluid as fluid import paddle.fluid.layers as layers import numpy as np - # condition为张量[True, False, True] - out = fluid.layers.where(condition) # [[0], [2]] - - # condition为张量[[True, False], [False, True]] - out = fluid.layers.where(condition) # [[0, 0], [1, 1]] - - # condition为张量[False, False, False] - out = fluid.layers.where(condition) # [[]] - + # tensor 为 [True, False, True] + condition = layers.assign(np.array([1, 0, 1], dtype='int32')) + condition = layers.cast(condition, 'bool') + out = layers.where(condition) # [[0], [2]] + + # tensor 为 [[True, False], [False, True]] + condition = layers.assign(np.array([[1, 0], [0, 1]], dtype='int32')) + condition = layers.cast(condition, 'bool') + out = layers.where(condition) # [[0, 0], [1, 1]] + + # tensor 为 [False, False, False] + condition = layers.assign(np.array([0, 0, 0], dtype='int32')) + condition = layers.cast(condition, 'bool') + out = layers.where(condition) # [[]] diff --git a/doc/fluid/api_cn/layers_cn/yolo_box_cn.rst b/doc/fluid/api_cn/layers_cn/yolo_box_cn.rst index 1d277106333f0d07f75c40a12ec5c51268596502..cb33a55e4038253e700438c4eef9b36ebeb24f11 100644 --- a/doc/fluid/api_cn/layers_cn/yolo_box_cn.rst +++ b/doc/fluid/api_cn/layers_cn/yolo_box_cn.rst @@ -55,8 +55,9 @@ yolo_box import paddle.fluid as fluid x = fluid.layers.data(name='x', shape=[255, 13, 13], dtype='float32') + img_size = fluid.layers.data(name='img_size',shape=[2],dtype='int64') anchors = [10, 13, 16, 30, 33, 23] - loss = fluid.layers.yolo_box(x=x, img_size=608, class_num=80, anchors=anchors, + loss = fluid.layers.yolo_box(x=x, img_size=img_size, class_num=80, anchors=anchors, conf_thresh=0.01, downsample_ratio=32) diff --git a/doc/fluid/api_cn/metrics_cn/DetectionMAP_cn.rst b/doc/fluid/api_cn/metrics_cn/DetectionMAP_cn.rst index a67071850cdd149dfa55eb3a3bff6b66b38dfe46..93bc8e578e2cf8d565746e25fdc337e860282ffc 100644 --- a/doc/fluid/api_cn/metrics_cn/DetectionMAP_cn.rst +++ b/doc/fluid/api_cn/metrics_cn/DetectionMAP_cn.rst @@ -25,7 +25,7 @@ DetectionMAP - **background_label** (int) – 背景标签的索引，背景标签将被忽略。如果设置为-1，则所有类别将被考虑，默认为0。 - **overlap_threshold** (float) – 判断真假阳性的阈值，默认为0.5 - **evaluate_difficult** (bool) – 是否考虑 difficult ground truth 进行评价，默认为 True。当 gt_difficult 为 None 时，这个参数不起作用。 - - **ap_version** (string) – 平均精度的计算方法，必须是 "integral" 或 "11point"。详情请查看 https://sanchom.wordpress.com/tag/averageprecision/。 其中，11point为：11-point 插值平均精度。积分: precision-recall曲线的自然积分。 + - **ap_version** (string) – 平均精度的计算方法，必须是 "integral" 或 "11point"。详情请查看 https://sanchom.wordpress.com/2011/09/01/precision-recall/。 其中，11point为：11-point 插值平均精度。积分: precision-recall曲线的自然积分。 **代码示例** @@ -61,9 +61,6 @@ DetectionMAP map_evaluator = fluid.metrics.DetectionMAP(nmsed_outs, gt_label, gt_box, difficult, class_num = 3) cur_map, accum_map = map_evaluator.get_map_var() - # 更详细的例子请参见 - # https://github.com/PaddlePaddle/models/blob/43cdafbb97e52e6d93cc5bbdc6e7486f27665fc8/PaddleCV/object_detection - .. py:method:: get_map_var() diff --git a/doc/fluid/api_cn/optimizer_cn/LarsMomentumOptimizer_cn.rst b/doc/fluid/api_cn/optimizer_cn/LarsMomentumOptimizer_cn.rst index 2232a0ca4c8cb85cdfb95576331dec2457641e83..bc726a78df9671c078bea7c5716b2a07b371789d 100644 --- a/doc/fluid/api_cn/optimizer_cn/LarsMomentumOptimizer_cn.rst +++ b/doc/fluid/api_cn/optimizer_cn/LarsMomentumOptimizer_cn.rst @@ -29,8 +29,20 @@ LARS支持的Momentum优化器 .. code-block:: python import paddle.fluid as fluid - optimizer = fluid.optimizer.LarsMomentum(learning_rate=0.2, momentum=0.1, lars_weight_decay=0.001) - optimizer.minimize(cost) + + np_inp = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32) + inp = fluid.layers.data( + name="inp", shape=[2, 2], append_batch_size=False) + out = fluid.layers.fc(inp, size=3) + out = fluid.layers.reduce_sum(out) + optimizer = fluid.optimizer.LarsMomentumOptimizer(learning_rate=0.001, momentum=0.9) + optimizer.minimize(out) + + exe = fluid.Executor(fluid.CPUPlace()) + exe.run(fluid.default_startup_program()) + exe.run( + feed={"inp": np_inp}, + fetch_list=[out.name]) .. py:method:: apply_gradients(params_grads) diff --git a/doc/fluid/api_cn/profiler_cn/cuda_profiler_cn.rst b/doc/fluid/api_cn/profiler_cn/cuda_profiler_cn.rst index e8240f5a9ae992faacfb4c9f9e38c2e42cc0bd45..810b1da2d8cb78dcd44170de348962ed028f63be 100644 --- a/doc/fluid/api_cn/profiler_cn/cuda_profiler_cn.rst +++ b/doc/fluid/api_cn/profiler_cn/cuda_profiler_cn.rst @@ -6,7 +6,7 @@ cuda_profiler .. py:function:: paddle.fluid.profiler.cuda_profiler(output_file, output_mode=None, config=None) -CUDA分析器。通过CUDA运行时应用程序编程接口对CUDA程序进行性能分析。分析结果将以键-值对格式或逗号分隔的格式写入output_file。用户可以通过output_mode参数设置输出模式，并通过配置参数设置计数器/选项。默认配置是[' gpustarttimestamp '， ' gpustarttimestamp '， ' gridsize3d '， ' threadblocksize '， ' streamid '， ' enableonstart 0 '， ' conckerneltrace ']。然后，用户可使用 `NVIDIA Visual Profiler `_ 工具来加载这个输出文件以可视化结果。 +CUDA分析器。通过CUDA运行时应用程序编程接口对CUDA程序进行性能分析。分析结果将以键-值对格式或逗号分隔的格式写入output_file。用户可以通过output_mode参数设置输出模式，并通过配置参数设置计数器/选项。默认配置是[' gpustarttimestamp '， ' gpuendtimestamp '， ' gridsize3d '， ' threadblocksize '， ' streamid '， ' enableonstart 0 '， ' conckerneltrace ']。然后，用户可使用 `NVIDIA Visual Profiler `_ 工具来加载这个输出文件以可视化结果。 参数: diff --git a/doc/fluid/api_cn/profiler_cn/profiler_cn.rst b/doc/fluid/api_cn/profiler_cn/profiler_cn.rst index ff818568d0679e741d5f85c0fcb14cc9675b4265..b63593a6ff2fee74eb0d2bd36b784017a6a92494 100644 --- a/doc/fluid/api_cn/profiler_cn/profiler_cn.rst +++ b/doc/fluid/api_cn/profiler_cn/profiler_cn.rst @@ -8,7 +8,7 @@ profiler profile interface 。与cuda_profiler不同，此profiler可用于分析CPU和GPU程序。默认情况下，它记录CPU和GPU kernel，如果想分析其他程序，可以参考教程来在c++代码中添加更多代码。 -如果 state== ' All '，在profile_path 中写入文件 profile proto 。该文件记录执行期间的时间顺序信息。然后用户可以看到这个文件的时间轴，请参考 `这里 <../advanced_usage/development/profiling/timeline_cn.html>`_ +如果 state== ' All '，在profile_path 中写入文件 profile proto 。该文件记录执行期间的时间顺序信息。然后用户可以看到这个文件的时间轴，请参考 `这里 `_ 参数: - **state** (string) – profiling state, 取值为 'CPU' 或 'GPU', profiler 使用 CPU timer 或GPU timer 进行 profiling. 虽然用户可能在开始时指定了执行位置(CPUPlace/CUDAPlace)，但是为了灵活性，profiler不会使用这个位置。 diff --git a/doc/fluid/api_cn/profiler_cn/start_profiler_cn.rst b/doc/fluid/api_cn/profiler_cn/start_profiler_cn.rst index 4cf45a6676d064836ef51a804dd0c1a7b24da2a4..d99ee7db11db3562d5a917820b9f2d0b7c7bf333 100644 --- a/doc/fluid/api_cn/profiler_cn/start_profiler_cn.rst +++ b/doc/fluid/api_cn/profiler_cn/start_profiler_cn.rst @@ -9,7 +9,7 @@ start_profiler 不能使用 ``fluid.profiler.profiler`` -如果 state== ' All '，在profile_path 中写入文件 profile proto 。该文件记录执行期间的时间顺序信息。然后用户可以看到这个文件的时间轴，请参考 `这里 <../advanced_usage/development/profiling/timeline_cn.html>`_ +如果 state== ' All '，在profile_path 中写入文件 profile proto 。该文件记录执行期间的时间顺序信息。然后用户可以看到这个文件的时间轴，请参考 `这里 `_ 参数: - **state** (string) – profiling state, 取值为 'CPU' 或 'GPU' 或 'All', 'CPU' 代表只分析 cpu. 'GPU' 代表只分析 GPU . 'All' 会产生 timeline. diff --git a/doc/fluid/api_cn/transpiler_cn/memory_optimize_cn.rst b/doc/fluid/api_cn/transpiler_cn/memory_optimize_cn.rst index 1f69ed357c53b5c08d84f7ff5690ac63295dc79c..0679366b8c0a59ab5147398735b8aa857206bfc0 100644 --- a/doc/fluid/api_cn/transpiler_cn/memory_optimize_cn.rst +++ b/doc/fluid/api_cn/transpiler_cn/memory_optimize_cn.rst @@ -3,7 +3,7 @@ memory_optimize ------------------------------- -.. py:function:: paddle.fluid.transpiler.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=False) +.. py:function:: paddle.fluid.transpiler.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=True) 历史遗留内存优化策略，通过在不同operators之间重用可变内存来减少总内存消耗。 用一个简单的例子来解释该算法： diff --git a/doc/fluid/api_guides/low_level/layers/detection.rst b/doc/fluid/api_guides/low_level/layers/detection.rst index 527615efd7f0bfa8e60f959e77552c50142bec97..a904accd2d5951491422b3089afab75eeafb5944 100644 --- a/doc/fluid/api_guides/low_level/layers/detection.rst +++ b/doc/fluid/api_guides/low_level/layers/detection.rst @@ -69,7 +69,7 @@ SSD * ssd_loss：通过位置偏移预测值，置信度，检测框位置和真实框位置和标签计算损失。API Reference 请参考 :ref:`cn_api_fluid_layers_ssd_loss` -* detection map: 利用mAP评估SSD网络模型。API Reference 请参考 :ref:`cn_api_fluid_layers_detection_map` +* detection_map: 利用mAP评估SSD网络模型。API Reference 请参考 :ref:`cn_api_fluid_layers_detection_map` YOLO V3 ---------------