Skip to content

F
FluidDoc

PaddlePaddle / FluidDoc

通知 10
Star 2
Fork 0
F
FluidDoc
提交 3eb99f7e 编写于 作者: C chentianyu03
浏览文件
操作

modify alias

上级 a219c253
展开全部 隐藏空白更改
内联 并排
Showing with 3224 addition and 6415 deletion
doc/paddle/api/alias_api_mapping
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/gen_doc.py
浏览文件 @ 3eb99f7e
......@@ -68,8 +68,8 @@ def get_alias_mapping(file="./alias_api_mapping"):
for line in f.readlines():
t = line.strip().split('\t')
real_api = t[0].strip()
alias_api = t[1].strip()
alias_api_map[real_api] = alias_api
alias_apis = t[1].strip().split(',')
alias_api_map[real_api] = alias_apis
def is_filter_api(api):
......@@ -77,7 +77,7 @@ def is_filter_api(api):
if api in display_doc_map:
return False
#check in api in not_display_list
#check api in not_display_list
for key in not_display_doc_map:
#find the api
if key == api:
......@@ -127,6 +127,14 @@ def is_filter_api(api):
return False
def get_display_api(api):
# recomment alias api
if api.startswith("paddle.fluid") and alias_api_map.has_key(api):
return alias_api_map[api][0]
else:
return api
def gen_en_files(root_path='paddle'):
backup_path = root_path + "_" + str(int(time.time()))
......@@ -134,11 +142,15 @@ def gen_en_files(root_path='paddle'):
if is_filter_api(api):
continue
api = get_display_api(api)
doc_file = api.split(".")[-1]
path = "/".join(api.split(".")[0:-1])
if not os.path.exists(path):
os.makedirs(path)
f = api.replace(".", "/")
if os.path.exists(f + en_suffix):
continue
os.mknod(f + en_suffix)
gen = EnDocGenerator()
with gen.guard(f + en_suffix):
......
doc/paddle/api/paddle/dataset/common/split_cn.rst
浏览文件 @ 3eb99f7e
.. _cn_api_paddle_tensor_split
.. _cn_api_fluid_layers_split:
split
-------------------------------
.. py:function:: paddle.tensor.split(x, num_or_sections, axis=0, name=None)
.. py:function:: paddle.fluid.layers.split(input, num_or_sections, dim=-1, name=None)
该OP将输入Tensor分割成多个子Tensor。
**参数**：
- **x** (Tensor) - 输入变量，数据类型为bool, float16, float32，float64，int32，int64的多维Tensor。
- **num_or_sections** (int|list|tuple) - 如果 ``num_or_sections`` 是一个整数，则表示Tensor平均划分为相同大小子Tensor的数量。如果 ``num_or_sections`` 是一个list或tuple，那么它的长度代表子Tensor的数量，它的元素可以是整数或者形状为[1]的Tensor，依次代表子Tensor需要分割成的维度的大小。list或tuple的长度不能超过输入Tensor待分割的维度的大小。在list或tuple中，至多有一个元素值为-1，表示该值是由 ``x`` 的维度和其他 ``num_or_sections`` 中元素推断出来的。例如对一个维度为[4,6,6]Tensor的第三维进行分割时，指定 ``num_or_sections=[2,-1,1]`` ，输出的三个Tensor维度分别为：[4,6,2]，[4,6,3]，[4,6,1]。
- **axis** (int|Tensor，可选) - 整数或者形状为[1]的Tensor，数据类型为int32或int64。表示需要分割的维度。如果 ``axis < 0`` ，则划分的维度为 ``rank(x) + axis`` 。默认值为0。
- **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
参数：
- **input** (Tensor) - 输入变量，数据类型为bool， float16，float32，float64，int32，int64的多维Tensor。
- **num_or_sections** (int|list|tuple) - 如果 ``num_or_sections`` 是一个整数，则表示Tensor平均划分为相同大小子Tensor的数量。如果 ``num_or_sections`` 是一个list或tuple，那么它的长度代表子Tensor的数量，它的元素可以是整数或者形状为[1]的Tensor，依次代表子Tensor需要分割成的维度的大小。list或tuple的长度不能超过输入Tensor待分割的维度的大小。至多有一个元素值为-1，-1表示该值是由 ``input`` 待分割的维度值和 ``num_or_sections`` 的剩余元素推断出来的。
- **dim** (int|Tenspr，可选) - 整数或者形状为[1]的Tensor，数据类型为int32或int64。表示需要分割的维度。如果 ``dim < 0`` ，则划分的维度为 ``rank(input) + dim`` 。默认值为-1。
- **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
返回：分割后的Tensor列表。
抛出异常：
- :code:`TypeError`：``x`` 的数据类型不是float16、float32、float64、int32或int64时 。
- :code:`TypeError`：``input`` 的数据类型不是bool、float16、float32、float64、int32或int64时 。
- :code:`TypeError`：``num_or_sections`` 不是int、list 或 tuple时。
- :code:`TypeError`：``axis`` 不是 int 或 Tensor时。当 ``axis`` 为Tensor，其数据类型不是int32或int64时。
- :code:`TypeError`：``dim`` 不是 int 或 Tensor时。当 ``dim`` 为Tensor，其数据类型不是int32或int64时。
**代码示例**：
.. code-block:: python
import numpy as np
import paddle
paddle.enable_imperative()
# x is a Tensor which shape is [3, 9, 5]
x_np = np.random.random([3, 9, 5]).astype("int32")
x = paddle.imperative.to_variable(x_np)
import paddle.fluid as fluid
out0, out1, out22 = paddle.split(x, num_or_sections=3, axis=1)
# input is a Tensor which shape is [3, 9, 5]
input = fluid.data(
name="input", shape=[3, 9, 5], dtype="float32")
out0, out1, out2 = fluid.layers.split(input, num_or_sections=3, dim=1)
# out0.shape [3, 3, 5]
# out1.shape [3, 3, 5]
# out2.shape [3, 3, 5]
out0, out1, out2 = paddle.split(x, num_or_sections=[2, 3, 4], axis=1)
out0, out1, out2 = fluid.layers.split(input, num_or_sections=[2, 3, 4], dim=1)
# out0.shape [3, 2, 5]
# out1.shape [3, 3, 5]
# out2.shape [3, 4, 5]
out0, out1, out2 = paddle.split(x, num_or_sections=[2, 3, -1], axis=1)
out0, out1, out2 = fluid.layers.split(input, num_or_sections=[2, 3, -1], dim=1)
# out0.shape [3, 2, 5]
# out1.shape [3, 3, 5]
# out2.shape [3, 4, 5]
# axis is negative, the real axis is (rank(x) + axis) which real
# dim is negative, the real dim is (rank(input) + axis) which real
# value is 1.
out0, out1, out2 = paddle.split(x, num_or_sections=3, axis=-2)
out0, out1, out2 = fluid.layers.split(input, num_or_sections=3, dim=-2)
# out0.shape [3, 3, 5]
# out1.shape [3, 3, 5]
# out2.shape [3, 3, 5]
doc/paddle/api/paddle/fluid/BuildStrategy_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_BuildStrategy:
BuildStrategy
-------------------------------
.. py:class:: paddle.fluid.BuildStrategy
:api_attr: 声明式编程模式（静态图)
``BuildStrategy`` 使用户更方便地控制 :ref:`cn_api_fluid_ParallelExecutor` 中计算图的建造方法，可通过设置 ``ParallelExecutor`` 中的 ``BuildStrategy`` 成员来实现此功能。
**代码示例**
.. code-block:: python
import os
import numpy as np
import paddle.fluid as fluid
os.environ["CPU_NUM"] = '2'
places = fluid.cpu_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)
build_strategy = fluid.BuildStrategy()
build_strategy.enable_inplace = True
build_strategy.memory_optimize = True
build_strategy.reduce_strategy = fluid.BuildStrategy.ReduceStrategy.Reduce
program = fluid.compiler.CompiledProgram(fluid.default_main_program())
program = program.with_data_parallel(loss_name=loss.name,
build_strategy=build_strategy,
places=places)
.. py:attribute:: debug_graphviz_path
str类型。表示以graphviz格式向文件中写入计算图的路径，有利于调试。默认值为空字符串。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
build_strategy = fluid.BuildStrategy()
build_strategy.debug_graphviz_path = "./graph"
.. py:attribute:: enable_sequential_execution
bool类型。如果设置为True，则算子的执行顺序将与算子定义的执行顺序相同。默认为False。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
build_strategy = fluid.BuildStrategy()
build_strategy.enable_sequential_execution = True
.. py:attribute:: fuse_broadcast_ops
bool类型。表明是否融合(fuse) broadcast ops。该选项指在Reduce模式下有效，使程序运行更快。默认为False。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
build_strategy = fluid.BuildStrategy()
build_strategy.fuse_broadcast_ops = True
.. py:attribute:: fuse_elewise_add_act_ops
bool类型。表明是否融合(fuse) elementwise_add_op和activation_op。这会使整体执行过程更快。默认为False。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
build_strategy = fluid.BuildStrategy()
build_strategy.fuse_elewise_add_act_ops = True
.. py:attribute:: fuse_relu_depthwise_conv
bool类型。表明是否融合(fuse) relu和depthwise_conv2d，节省GPU内存并可能加速执行过程。此选项仅适用于GPU设备。默认为False。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
build_strategy = fluid.BuildStrategy()
build_strategy.fuse_relu_depthwise_conv = True
.. py:attribute:: gradient_scale_strategy
``fluid.BuildStrategy.GradientScaleStrategy`` 类型。在 ``ParallelExecutor`` 中，存在三种定义loss对应梯度( *loss@grad* )的方式，分别为 ``CoeffNumDevice``, ``One`` 与 ``Customized``。默认情况下， ``ParallelExecutor`` 根据设备数目来设置 *loss@grad* 。如果用户需要自定义 *loss@grad* ，可以选择 ``Customized`` 方法。默认为 ``CoeffNumDevice`` 。
**代码示例**
.. code-block:: python
import os
import numpy as np
import paddle.fluid as fluid
import paddle.fluid.compiler as compiler
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 = \
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 = np.random.random(size=(10, 1)).astype('float32')
loss_grad = np.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类型或None。设为True时可用于减少总内存消耗，False表示不使用，None表示框架会自动选择使用或者不使用优化策略。当前，None意味着当GC不能使用时，优化策略将被使用。默认为None。
.. py:attribute:: reduce_strategy
``fluid.BuildStrategy.ReduceStrategy`` 类型。在 ``ParallelExecutor`` 中，存在两种参数梯度聚合策略，即 ``AllReduce`` 和 ``Reduce`` 。如果用户需要在所有执行设备上独立地进行参数更新，可以使用 ``AllReduce`` 。如果使用 ``Reduce`` 策略，所有参数的优化将均匀地分配给不同的执行设备，随之将优化后的参数广播给其他执行设备。
默认值为 ``AllReduce`` 。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
build_strategy = fluid.BuildStrategy()
build_strategy.reduce_strategy = fluid.BuildStrategy.ReduceStrategy.Reduce
.. py:attribute:: remove_unnecessary_lock
bool类型。设置True会去除GPU操作中的一些锁操作， ``ParallelExecutor`` 将运行得更快，默认为True。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
build_strategy = fluid.BuildStrategy()
build_strategy.remove_unnecessary_lock = True
.. py:attribute:: sync_batch_norm
bool类型。表示是否使用同步的批正则化，即在训练阶段通过多个设备同步均值和方差。当前的实现不支持FP16训练和CPU。并且目前**仅支持**仅在一台机器上进行同步式批正则。默认为 False。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
build_strategy = fluid.BuildStrategy()
build_strategy.sync_batch_norm = True
doc/paddle/api/paddle/fluid/CPUPlace_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
.. _cn_api_fluid_CPUPlace:
CPUPlace
-------------------------------
.. py:class:: paddle.fluid.CPUPlace
``CPUPlace`` 是一个设备描述符，表示一个分配或将要分配 ``Tensor`` 或 ``LoDTensor`` 的 ``CPU`` 设备。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
cpu_place = fluid.CPUPlace()
doc/paddle/api/paddle/fluid/CUDAPinnedPlace_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
.. _cn_api_fluid_CUDAPinnedPlace:
CUDAPinnedPlace
-------------------------------
.. py:class:: paddle.fluid.CUDAPinnedPlace
``CUDAPinnedPlace`` 是一个设备描述符，它所指代的页锁定内存由 CUDA 函数 ``cudaHostAlloc()`` 在主机内存上分配，主机的操作系统将不会对这块内存进行分页和交换操作，可以通过直接内存访问技术访问，加速主机和 GPU 之间的数据拷贝。
有关 CUDA 的数据转移和 ``pinned memory``，参见 `官方文档 <https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#pinned-memory>`_ 。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
place = fluid.CUDAPinnedPlace()
doc/paddle/api/paddle/fluid/CUDAPlace_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
.. _cn_api_fluid_CUDAPlace:
CUDAPlace
-------------------------------
.. py:class:: paddle.fluid.CUDAPlace
.. note::
多卡任务请先使用 FLAGS_selected_gpus 环境变量设置可见的GPU设备，下个版本将会修正 CUDA_VISIBLE_DEVICES 环境变量无效的问题。
``CUDAPlace`` 是一个设备描述符，表示一个分配或将要分配 ``Tensor`` 或 ``LoDTensor`` 的 GPU 设备。
每个 ``CUDAPlace`` 有一个 ``dev_id`` （设备id）来表明当前的 ``CUDAPlace`` 所代表的显卡编号，编号从 0 开始。
``dev_id`` 不同的 ``CUDAPlace`` 所对应的内存不可相互访问。
这里编号指的是可见显卡的逻辑编号，而不是显卡实际的编号。
可以通过 ``CUDA_VISIBLE_DEVICES`` 环境变量限制程序能够使用的 GPU 设备，程序启动时会遍历当前的可见设备，并从 0 开始为这些设备编号。
如果没有设置 ``CUDA_VISIBLE_DEVICES``，则默认所有的设备都是可见的，此时逻辑编号与实际编号是相同的。
参数：
- **id** (int，可选) - GPU的设备ID。如果为 ``None``，则默认会使用 id 为 0 的设备。默认值为 ``None``。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
gpu_place = fluid.CUDAPlace(0)
doc/paddle/api/paddle/fluid/CompiledProgram_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_CompiledProgram:
CompiledProgram
-------------------------------
.. py:class:: paddle.fluid.CompiledProgram(program_or_graph, build_strategy=None)
:api_attr: 声明式编程模式（静态图)
CompiledProgram根据 `build_strategy` 的配置将输入的Program或Graph进行转换和优化，例如：计算图中算子融合、计算图执行过程中开启内存/显存优化等，关于build_strategy更多信息。请参阅 ``fluid.BuildStrategy`` 。
参数：
- **program_or_graph** (Graph|Program): 该参数为被执行的Program或Graph。
- **build_strategy** (BuildStrategy): 通过配置build_strategy，对计算图进行转换和优化，例如：计算图中算子融合、计算图执行过程中开启内存/显存优化等。关于build_strategy更多信息，请参阅 ``fluid.BuildStrategy`` 。 默认为None。
返回：初始化后的 ``CompiledProgram`` 对象
返回类型：CompiledProgram
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
import numpy
place = fluid.CUDAPlace(0) # fluid.CPUPlace()
exe = fluid.Executor(place)
data = fluid.data(name='X', shape=[None, 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)
exe.run(fluid.default_startup_program())
compiled_prog = fluid.CompiledProgram(
fluid.default_main_program())
x = numpy.random.random(size=(10, 1)).astype('float32')
loss_data, = exe.run(compiled_prog,
feed={"X": x},
fetch_list=[loss.name])
.. py:method:: with_data_parallel(loss_name=None, build_strategy=None, exec_strategy=None, share_vars_from=None, places=None)
该接口用于将输入的Program或Graph进行转换，以便通过数据并行模式运行该模型。用户可以通过 `build_strategy` 和 `exec_strategy` 设置计算图构建和计算图执行过程中可以进行的一些优化，例如：将梯度聚合的AllReduce操作进行融合、指定计算图运行过程中使用的线程池大小等。**注意：如果在构建CompiledProgram和调用with_data_parallel时都指定了build_strategy，在CompiledProgram中的build_strategy会被复写，因此，如果是数据并行训练，建议在调用with_data_parallel接口时设置build_strategy**。
参数：
- **loss_name** （str） - 该参数为模型最后得到的损失变量的名字，**注意：如果是模型训练，必须设置loss_name，否则计算结果可能会有问题。** 默认为：None。
- **build_strategy** （BuildStrategy）: 通过配置build_strategy，对计算图进行转换和优化，例如：计算图中算子融合、计算图执行过程中开启内存/显存优化等。关于build_strategy更多的信息，请参阅 ``fluid.BuildStrategy`` 。 默认为：None。
- **exec_strategy** （ExecutionStrategy） - 通过exec_strategy指定执行计算图过程可以调整的选项，例如线程池大小等。 关于exec_strategy更多信息，请参阅 ``fluid.ExecutionStrategy`` 。 默认为：None。
- **share_vars_from** （CompiledProgram） - 如果设置了share_vars_from，当前的CompiledProgram将与share_vars_from指定的CompiledProgram共享参数值。需要设置该参数的情况：模型训练过程中需要进行模型测试，并且训练和测试都是采用数据并行模式，那么测试对应的CompiledProgram在调用with_data_parallel时，需要将share_vars_from设置为训练对应的CompiledProgram。由于CompiledProgram只有在第一次执行时才会将变量分发到其他设备上，因此share_vars_from指定的CompiledProgram必须在当前CompiledProgram之前运行。默认为：None。
- **places** （list(CUDAPlace)|list(CPUPlace)） - 该参数指定模型运行所在的设备。如果希望在GPU0和GPU1上运行，places为[fluid.CUDAPlace(0), fluid.CUDAPlace(1)]；如果希望使用2个CPU运行，places为[fluid.CPUPlace()] * 2。 如果没有设置该参数，即该参数为None，模型执行时，将从环境变量中获取可用的设备：如果使用GPU，模型执行时，从环境变量FLAGS_selected_gpus或CUDA_VISIBLE_DEVICES中获取当前可用的设备ID；如果使用CPU，模型执行时，从环境变量CPU_NUM中获取当前可利用的CPU个数。例如：export CPU_NUM=4，如果没有设置该环境变量，执行器会在环境变量中添加该变量，并将其值设为1。默认为：None。
返回：配置之后的 ``CompiledProgram`` 对象
返回类型：CompiledProgram
.. note::
1. 如果只是进行多卡测试，不需要设置loss_name以及share_vars_from。
2. 如果程序中既有模型训练又有模型测试，则构建模型测试所对应的CompiledProgram时必须设置share_vars_from，否则模型测试和模型训练所使用的参数是不一致。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
import numpy
import os
use_cuda = True
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
parallel_places = [fluid.CUDAPlace(0), fluid.CUDAPlace(1)] if use_cuda else [fluid.CPUPlace()] * 2
# 注意：如果你使用CPU运行程序，需要具体设置CPU_NUM，
# 否则fluid会把逻辑核的所有数目设为CPU_NUM，
# 在这种情况下，输入的batch size应大于CPU_NUM，
# 否则程序会异常中断。
if not use_cuda:
os.environ['CPU_NUM'] = str(2)
exe = fluid.Executor(place)
data = fluid.data(name='X', shape=[None, 1], dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
loss = fluid.layers.mean(hidden)
test_program = fluid.default_main_program().clone(for_test=True)
fluid.optimizer.SGD(learning_rate=0.01).minimize(loss)
exe.run(fluid.default_startup_program())
compiled_train_prog = fluid.CompiledProgram(
fluid.default_main_program()).with_data_parallel(
loss_name=loss.name, places=parallel_places)
# 注意：如果此处不设置share_vars_from=compiled_train_prog，
# 测试过程中用的参数与训练使用的参数是不一致
compiled_test_prog = fluid.CompiledProgram(
test_program).with_data_parallel(
share_vars_from=compiled_train_prog,
places=parallel_places)
train_data = numpy.random.random(size=(10, 1)).astype('float32')
loss_data, = exe.run(compiled_train_prog,
feed={"X": train_data},
fetch_list=[loss.name])
test_data = numpy.random.random(size=(10, 1)).astype('float32')
loss_data, = exe.run(compiled_test_prog,
feed={"X": test_data},
fetch_list=[loss.name])
\ No newline at end of file
doc/paddle/api/paddle/fluid/ExecutionStrategy_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_ExecutionStrategy:
ExecutionStrategy
-------------------------------
.. py:class:: paddle.fluid.ExecutionStrategy
:api_attr: 声明式编程模式（静态图)
通过设置 ``ExecutionStrategy`` 中的选项，用户可以对执行器的执行配置进行调整，比如设置执行器中线程池的大小等。
返回：初始化后的ExecutionStrategy的实例
返回类型：ExecutionStrategy
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[13], dtype='float32')
y = fluid.layers.data(name='y', shape=[1], dtype='float32')
y_predict = fluid.layers.fc(input=x, size=1, act=None)
cost = fluid.layers.square_error_cost(input=y_predict, label=y)
avg_loss = fluid.layers.mean(cost)
sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.001)
sgd_optimizer.minimize(avg_loss)
exec_strategy = fluid.ExecutionStrategy()
exec_strategy.num_threads = 4
train_exe = fluid.ParallelExecutor(use_cuda=False,
loss_name=avg_loss.name,
exec_strategy=exec_strategy)
.. py:attribute:: num_iteration_per_drop_scope
int型成员。该选项表示间隔多少次迭代之后清理一次临时变量。模型运行过程中，生成的中间临时变量将被放到local execution scope中，为了避免对临时变量频繁的申请与释放，通常将其设为较大的值（比如10或者100）。默认值为100。
.. py:attribute:: num_iteration_per_run
int型成员。它配置了当用户在python脚本中调用pe.run()时执行器会执行的迭代次数。Executor每次调用，会进行num_iteration_per_run次训练，它会使整体执行过程更快。
.. py:attribute:: num_threads
int型成员。该选项表示当前 ``Executor`` 的线程池(thread pool)的大小, 此线程池可用来并发执行program中的operator（算子，运算）。如果 :math:`num\_threads=1` ，则所有的operator将一个接一个地执行，但在不同的program重复周期(iterations)中执行顺序可能不同。如果该选项没有被设置，则在 ``Executor`` 中，它会依据设备类型(device type)、设备数目(device count)而设置为相应值。对GPU，:math:`num\_threads=device\_count∗4` ；对CPU， :math:`num\_threads=CPU\_NUM∗4` 。在 ``Executor`` 中有关于 :math:`CPU\_NUM` 的详细解释。如果没有设置 :math:`CPU\_NUM` ，则设置默认值为1， 并提示用户进行 :math:`CPU\_NUM` 的设置。
doc/paddle/api/paddle/fluid/Executor_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_executor:
Executor
-------------------------------
.. py:class:: paddle.fluid.Executor (place=None)
:api_attr: 声明式编程模式（静态图)
Executor支持单GPU、多GPU以及CPU运行。
参数：
- **place** (fluid.CPUPlace()|fluid.CUDAPlace(N)|None) – 该参数表示Executor执行所在的设备，这里的N为GPU对应的ID。当该参数为 `None` 时，PaddlePaddle会根据其安装版本设置默认的运行设备。当安装的Paddle为CPU版时，默认运行设置会设置成 `CPUPlace()` ，而当Paddle为GPU版时，默认运行设备会设置成 `CUDAPlace(0)` 。默认值为None。
返回：初始化后的 ``Executor`` 对象
返回类型：Executor
**示例代码**
.. 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)
# 如果不显示设置运行设备，PaddlePaddle会设置默认运行设备
exe = fluid.Executor()
train_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(train_program, startup_program):
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)
# 仅运行一次startup program
# 不需要优化/编译这个startup program
startup_program.random_seed=1
exe.run(startup_program)
# 无需编译，直接运行main program
x = numpy.random.random(size=(10, 1)).astype('float32')
loss_data, = exe.run(train_program,
feed={"X": x},
fetch_list=[loss.name])
# 另一种方法是，编译这个main program然后运行。
# 参考CompiledProgram以获取更多信息。
# 注意：如果你使用CPU运行程序，需要具体设置CPU_NUM，
# 否则fluid会把逻辑核的所有数目设为CPU_NUM，
# 在这种情况下，输入的batch size应大于CPU_NUM，
# 否则程序会异常中断。
# 显式设置运行设备
# if not use_cuda:
# os.environ['CPU_NUM'] = str(2)
# 未显示设置运行设备且安装的Paddle为CPU版本
os.environ['CPU_NUM'] = str(2)
compiled_prog = compiler.CompiledProgram(
train_program).with_data_parallel(
loss_name=loss.name)
loss_data, = exe.run(compiled_prog,
feed={"X": x},
fetch_list=[loss.name])
.. py:method:: close()
关闭执行器。该接口主要用于对于分布式训练，调用该接口后不可以再使用该执行器。该接口会释放在PServers上和目前Trainer有关联的资源。
返回：无
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
cpu = fluid.CPUPlace()
exe = fluid.Executor(cpu)
# 执行训练或测试过程
exe.close()
.. py:method:: run(program=None, feed=None, fetch_list=None, feed_var_name='feed', fetch_var_name='fetch', scope=None, return_numpy=True, use_program_cache=False, return_merged=True)
执行指定的Program或者CompiledProgram。需要注意的是，执行器会执行Program或CompiledProgram中的所有算子，而不会根据fetch_list对Program或CompiledProgram中的算子进行裁剪。同时，需要传入运行该模型用到的scope，如果没有指定scope，执行器将使用全局scope，即fluid.global_scope()。
参数：
- **program** (Program|CompiledProgram) – 该参数为被执行的Program或CompiledProgram，如果未提供该参数，即该参数为None，在该接口内，main_program将被设置为fluid.default_main_program()。默认为：None。
- **feed** (list|dict) – 该参数表示模型的输入变量。如果是单卡训练，``feed`` 为 ``dict`` 类型，如果是多卡训练，参数 ``feed`` 可以是 ``dict`` 或者 ``list`` 类型变量，如果该参数类型为 ``dict`` ，feed中的数据将会被分割(split)并分送给多个设备（CPU/GPU），即输入数据被均匀分配到不同设备上；如果该参数类型为 ``list`` ，则列表中的各个元素都会直接分别被拷贝到各设备中。默认为：None。
- **fetch_list** (list) – 该参数表示模型运行之后需要返回的变量。默认为：None。
- **feed_var_name** (str) – 该参数表示数据输入算子(feed operator)的输入变量名称。默认为："feed"。
- **fetch_var_name** (str) – 该参数表示结果获取算子(fetch operator)的输出变量名称。默认为："fetch"。
- **scope** (Scope) – 该参数表示执行当前program所使用的作用域，用户可以为不同的program指定不同的作用域。默认值：fluid.global_scope()。
- **return_numpy** (bool) – 该参数表示是否将返回的计算结果（fetch list中指定的变量）转化为numpy；如果为False，则每个变量返回的类型为LoDTensor，否则返回变量的类型为numpy.ndarray。默认为：True。
- **use_program_cache** (bool) – 该参数表示是否对输入的Program进行缓存。如果该参数为True，在以下情况时，模型运行速度可能会更快：输入的program为 ``fluid.Program`` ，并且模型运行过程中，调用该接口的参数（program、 feed变量名和fetch_list变量）名始终不变。默认为：False。
- **return_merged** (bool) – 该参数表示是否按照执行设备维度将返回的计算结果（fetch list中指定的变量）进行合并。如果 ``return_merged`` 设为False，返回值类型是一个Tensor的二维列表（ ``return_numpy`` 设为Fasle时）或者一个numpy.ndarray的二维列表（ ``return_numpy`` 设为True时）。如果 ``return_merged`` 设为True，返回值类型是一个Tensor的一维列表（ ``return_numpy`` 设为Fasle时）或者一个numpy.ndarray的一维列表（ ``return_numpy`` 设为True时）。更多细节请参考示例代码2。如果返回的计算结果是变长的，请设置 ``return_merged`` 为False，即不按照执行设备维度合并返回的计算结果。该参数的默认值为True，但这仅是为了兼容性考虑，在未来的版本中默认值可能会更改为False。
返回：返回fetch_list中指定的变量值
返回类型：List
.. note::
1. 如果是多卡训练，并且feed参数为dict类型，输入数据将被均匀分配到不同的卡上，例如：使用2块GPU训练，输入样本数为3，即[0, 1, 2]，经过拆分之后，GPU0上的样本数为1，即[0]，GPU1上的样本数为2，即[1, 2]。如果样本数少于设备数，程序会报错，因此运行模型时，应额外注意数据集的最后一个batch的样本数是否少于当前可用的CPU核数或GPU卡数，如果是少于，建议丢弃该batch。
2. 如果可用的CPU核数或GPU卡数大于1，则fetch出来的结果为不同设备上的相同变量值（fetch_list中的变量）在第0维拼接在一起。
**示例代码1**
.. code-block:: python
import paddle.fluid as fluid
import numpy
#首先创建执行引擎
place = fluid.CPUPlace() # fluid.CUDAPlace(0)
exe = fluid.Executor(place)
data = fluid.layers.data(name='X', shape=[1], dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
loss = fluid.layers.mean(hidden)
adam = fluid.optimizer.Adam()
adam.minimize(loss)
#仅运行startup程序一次
exe.run(fluid.default_startup_program())
x = numpy.random.random(size=(10, 1)).astype('float32')
outs = exe.run(feed={'X': x},
fetch_list=[loss.name])
**示例代码2**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
# 创建Executor对象
place = fluid.CUDAPlace(0)
exe = fluid.Executor(place)
data = fluid.data(name='X', shape=[None, 1], dtype='float32')
class_dim = 2
prediction = fluid.layers.fc(input=data, size=class_dim)
loss = fluid.layers.mean(prediction)
adam = fluid.optimizer.Adam()
adam.minimize(loss)
# 运行且仅运行一次startup program
exe.run(fluid.default_startup_program())
build_strategy = fluid.BuildStrategy()
binary = fluid.CompiledProgram(fluid.default_main_program()).with_data_parallel(
loss_name=loss.name, build_strategy=build_strategy)
batch_size = 6
x = np.random.random(size=(batch_size, 1)).astype('float32')
# 1) 设置 return_merged 参数为False以获取不合并的计算结果：
unmerged_prediction, = exe.run(binary, feed={'X': x},
fetch_list=[prediction.name],
return_merged=False)
# 如果用户使用两个GPU卡来运行此python代码示例，输出结果将为(2, 3, class_dim)。
# 输出结果中第一个维度值代表所使用的GPU卡数，而第二个维度值代表batch_size和所使用
# 的GPU卡数之商。
print("The unmerged prediction shape: {}".format(np.array(unmerged_prediction).shape))
print(unmerged_prediction)
# 2) 设置 return_merged 参数为True以获取合并的计算结果：
merged_prediction, = exe.run(binary, feed={'X': x},
fetch_list=[prediction.name],
return_merged=True)
# 如果用户使用两个GPU卡来运行此python代码示例，输出结果将为(6, class_dim)。输出结果
# 中第一个维度值代表batch_size值。
print("The merged prediction shape: {}".format(np.array(merged_prediction).shape))
print(merged_prediction)
# 输出:
# The unmerged prediction shape: (2, 3, 2)
# [array([[-0.37620035, -0.19752218],
# [-0.3561043 , -0.18697084],
# [-0.24129935, -0.12669306]], dtype=float32), array([[-0.24489994, -0.12858354],
# [-0.49041364, -0.25748932],
# [-0.44331917, -0.23276259]], dtype=float32)]
# The merged prediction shape: (6, 2)
# [[-0.37789783 -0.19921964]
# [-0.3577645 -0.18863106]
# [-0.24274671 -0.12814042]
# [-0.24635398 -0.13003758]
# [-0.49232286 -0.25939852]
# [-0.44514108 -0.2345845 ]]
.. py:method:: infer_from_dataset(program=None, dataset=None, scope=None, thread=0, debug=False, fetch_list=None, fetch_info=None, print_period=100)
infer_from_dataset的文档与train_from_dataset几乎完全相同，只是在分布式训练中，推进梯度将在infer_from_dataset中禁用。 infer_from_dataset（）可以非常容易地用于多线程中的评估。
参数：
- **program** (Program|CompiledProgram) – 需要执行的program,如果没有给定那么默认使用default_main_program (未编译的)
- **dataset** (paddle.fluid.Dataset) – 在此函数外创建的数据集，用户应当在调用函数前提供完整定义的数据集。必要时请检查Dataset文件。默认为None
- **scope** (Scope) – 执行这个program的域，用户可以指定不同的域。默认为全局域
- **thread** (int) – 用户想要在这个函数中运行的线程数量。线程的实际数量为min(Dataset.thread_num, thread)，如果thread > 0，默认为0
- **debug** (bool) – 是否开启debug模式，默认为False
- **fetch_list** (Variable List) – 返回变量列表，每个变量都会在训练过程中被打印出来，默认为None
- **fetch_info** (String List) – 每个变量的打印信息，默认为None
- **print_period** (int) – 每两次打印之间间隔的mini-batches的数量，默认为100
返回：None
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
place = fluid.CPUPlace() # 使用GPU时可设置place = fluid.CUDAPlace(0)
exe = fluid.Executor(place)
x = fluid.layers.data(name="x", shape=[10, 10], dtype="int64")
y = fluid.layers.data(name="y", shape=[1], dtype="int64", lod_level=1)
dataset = fluid.DatasetFactory().create_dataset()
dataset.set_use_var([x, y])
dataset.set_thread(1)
filelist = [] # 您可以设置您自己的filelist，如filelist = ["dataA.txt"]
dataset.set_filelist(filelist)
exe.run(fluid.default_startup_program())
exe.infer_from_dataset(program=fluid.default_main_program(),dataset=dataset)
.. py:method:: train_from_dataset(program=None, dataset=None, scope=None, thread=0, debug=False, fetch_list=None, fetch_info=None, print_period=100)
从预定义的数据集中训练。 数据集在paddle.fluid.dataset中定义。 给定程序（或编译程序），train_from_dataset将使用数据集中的所有数据样本。 输入范围可由用户给出。 默认情况下，范围是global_scope()。训练中的线程总数是thread。 训练中使用的线程数将是数据集中threadnum的最小值，同时也是此接口中线程的值。 可以设置debug，以便执行器显示所有算子的运行时间和当前训练任务的吞吐量。
注意：train_from_dataset将销毁每次运行在executor中创建的所有资源。
参数：
- **program** (Program|CompiledProgram) – 需要执行的program,如果没有给定那么默认使用default_main_program (未编译的)
- **dataset** (paddle.fluid.Dataset) – 在此函数外创建的数据集，用户应当在调用函数前提供完整定义的数据集。必要时请检查Dataset文件。默认为None
- **scope** (Scope) – 执行这个program的域，用户可以指定不同的域。默认为全局域
- **thread** (int) – 用户想要在这个函数中运行的线程数量。线程的实际数量为min(Dataset.thread_num, thread)，如果thread > 0，默认为0
- **debug** (bool) – 是否开启debug模式，默认为False
- **fetch_list** (Variable List) – 返回变量列表，每个变量都会在训练过程中被打印出来，默认为None
- **fetch_info** (String List) – 每个变量的打印信息，默认为None
- **print_period** (int) – 每两次打印之间间隔的mini-batches的数量，默认为100
返回：None
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
place = fluid.CPUPlace() # 通过设置place = fluid.CUDAPlace(0)使用GPU
exe = fluid.Executor(place)
x = fluid.layers.data(name="x", shape=[10, 10], dtype="int64")
y = fluid.layers.data(name="y", shape=[1], dtype="int64", lod_level=1)
dataset = fluid.DatasetFactory().create_dataset()
dataset.set_use_var([x, y])
dataset.set_thread(1)
filelist = [] # 您可以设置您自己的filelist，如filelist = ["dataA.txt"]
dataset.set_filelist(filelist)
exe.run(fluid.default_startup_program())
exe.train_from_dataset(program=fluid.default_main_program(),
dataset=dataset)
doc/paddle/api/paddle/fluid/ParallelExecutor_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_ParallelExecutor:
ParallelExecutor
-------------------------------
.. py:class:: paddle.fluid.ParallelExecutor(use_cuda, loss_name=None, main_program=None, share_vars_from=None, exec_strategy=None, build_strategy=None, num_trainers=1, trainer_id=0, scope=None)
:api_attr: 声明式编程模式（静态图)
``ParallelExecutor`` 是 ``Executor`` 的一个升级版本，可以支持基于数据并行的多节点模型训练和测试。如果采用数据并行模式， ``ParallelExecutor`` 在构造时会将参数分发到不同的节点上，并将输入的 ``Program`` 拷贝到不同的节点，在执行过程中，各个节点独立运行模型，将模型反向计算得到的参数梯度在多个节点之间进行聚合，之后各个节点独立的进行参数的更新。如果使用GPU运行模型，即 ``use_cuda=True`` ，节点指代GPU， ``ParallelExecutor`` 将自动获取在当前机器上可用的GPU资源，用户也可以通过在环境变量设置可用的GPU资源，例如：希望使用GPU0、GPU1计算，export CUDA_VISIBLEDEVICES=0,1；如果在CPU上进行操作，即 ``use_cuda=False`` ，节点指代CPU，**注意：此时需要用户在环境变量中手动添加 CPU_NUM ，并将该值设置为CPU设备的个数，例如：export CPU_NUM=4，如果没有设置该环境变量，执行器会在环境变量中添加该变量，并将其值设为1**。
参数:
- **use_cuda** (bool) – 该参数表示是否使用GPU执行。
- **loss_name** （str） - 该参数为模型最后得到的损失变量的名字。**注意：如果是数据并行模型训练，必须设置loss_name，否则计算结果可能会有问题。** 默认为：None。
- **main_program** (Program) – 需要被执行的Program 。如果未提供该参数，即该参数为None，在该接口内，main_program将被设置为fluid.default_main_program()。 默认为：None。
- **share_vars_from** (ParallelExecutor) - 如果设置了share_vars_from，当前的ParallelExecutor将与share_vars_from指定的ParallelExecutor共享参数值。需要设置该参数的情况：模型训练过程中需要进行模型测试，并且训练和测试都是采用数据并行模式，那么测试对应的ParallelExecutor在调用with_data_parallel时，需要将share_vars_from设置为训练所对应的ParallelExecutor。由于ParallelExecutor只有在第一次执行时才会将参数变量分发到其他设备上，因此share_vars_from指定的ParallelExecutor必须在当前ParallelExecutor之前运行。默认为：None。
- **exec_strategy** (ExecutionStrategy) - 通过exec_strategy指定执行计算图过程可以调整的选项，例如线程池大小等。 关于exec_strategy更多信息，请参阅 ``fluid.ExecutionStrategy`` 。 默认为：None。
- **build_strategy** (BuildStrategy): 通过配置build_strategy，对计算图进行转换和优化，例如：计算图中算子融合、计算图执行过程中开启内存/显存优化等。关于build_strategy更多的信息，请参阅 ``fluid.BuildStrategy`` 。 默认为：None。
- **num_trainers** (int) – 进行GPU分布式训练时需要设置该参数。如果该参数值大于1，NCCL将会通过多层级节点的方式来初始化。每个节点应有相同的GPU数目。默认为：1。
- **trainer_id** (int) – 进行GPU分布式训练时需要设置该参数。该参数必须与num_trainers参数同时使用。trainer_id指明是当前所在节点的 “rank”（层级）。trainer_id从0开始计数。默认为：0。
- **scope** (Scope) – 指定执行Program所在的作用域。默认为：fluid.global_scope()。
返回：初始化后的 ``ParallelExecutor`` 对象
返回类型：ParallelExecutor
抛出异常：``TypeError``
- 如果提供的参数 ``share_vars_from`` 不是 ``ParallelExecutor`` 类型的，将会抛出此异常。
.. note::
1. 如果只是进行多卡测试，不需要设置loss_name以及share_vars_from。
2. 如果程序中既有模型训练又有模型测试，则构建模型测试所对应的ParallelExecutor时必须设置share_vars_from，否则模型测试和模型训练所使用的参数是不一致。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy
import os
use_cuda = True
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
# 注意：如果你使用CPU运行程序，需要具体设置CPU_NUM，
# 否则fluid会把逻辑核的所有数目设为CPU_NUM，
# 在这种情况下，输入的batch size应大于CPU_NUM，
# 否则程序会异常中断。
if not use_cuda:
os.environ['CPU_NUM'] = str(2)
exe = fluid.Executor(place)
train_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(train_program, startup_program):
data = fluid.layers.data(name='X', shape=[1], dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
loss = fluid.layers.mean(hidden)
test_program = fluid.default_main_program().clone(for_test=True)
fluid.optimizer.SGD(learning_rate=0.01).minimize(loss)
exe.run(startup_program)
train_exe = fluid.ParallelExecutor(use_cuda=use_cuda,
main_program=train_program,
loss_name=loss.name)
# 注意：如果此处不设置share_vars_from=train_exe，测试过程中用的参数与训练使用的参数是不一致
test_exe = fluid.ParallelExecutor(use_cuda=use_cuda,
main_program=test_program,
share_vars_from=train_exe)
train_data = numpy.random.random(size=(10, 1)).astype('float32')
loss_data, = train_exe.run(feed={"X": train_data},
fetch_list=[loss.name])
test_data = numpy.random.random(size=(10, 1)).astype('float32')
loss_data, = test_exe.run(feed={"X": test_data},
fetch_list=[loss.name])
.. py:method:: run(fetch_list, feed=None, feed_dict=None, return_numpy=True)
该接口用于运行当前模型，需要注意的是，执行器会执行Program中的所有算子，而不会根据fetch_list对Program中的算子进行裁剪。
参数：
- **fetch_list** (list) – 该变量表示模型运行之后需要返回的变量。
- **feed** (list|dict) – 该变量表示模型的输入变量。如果该参数类型为 ``dict`` ，feed中的数据将会被分割(split)并分送给多个设备（CPU/GPU）；如果该参数类型为 ``list`` ，则列表中的各个元素都会直接分别被拷贝到各设备中。默认为：None。
- **feed_dict** – 该参数已经停止使用。默认为：None。
- **return_numpy** (bool) – 该变量表示是否将fetched tensor转换为numpy。默认为：True。
返回：返回fetch_list中指定的变量值
返回类型：List
抛出异常：
- ``ValueError`` - 如果feed参数是list类型，但是它的长度不等于可用设备（执行场所）的数目，再或者给定的feed不是dict类型，抛出此异常
- ``TypeError`` - 如果feed参数是list类型，但是它里面的元素不是dict类型时，抛出此异常
.. note::
1. 如果feed参数为dict类型，输入数据将被均匀分配到不同的卡上，例如：使用2块GPU训练，输入样本数为3，即[0, 1, 2]，经过拆分之后，GPU0上的样本数为1，即[0]，GPU1上的样本数为2，即[1, 2]。如果样本数少于设备数，程序会报错，因此运行模型时，应额外注意数据集的最后一个batch的样本数是否少于当前可用的CPU核数或GPU卡数，如果是少于，建议丢弃该batch。
2. 如果可用的CPU核数或GPU卡数大于1，则fetch出来的结果为不同设备上的相同变量值（fetch_list中的变量）在第0维拼接在一起。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy
import os
use_cuda = True
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
# 注意：如果你使用CPU运行程序，需要具体设置CPU_NUM，
# 否则fluid会把逻辑核的所有数目设为CPU_NUM，
# 在这种情况下，输入的batch size应大于CPU_NUM，
# 否则程序会异常中断。
if not use_cuda:
os.environ['CPU_NUM'] = str(2)
exe = fluid.Executor(place)
train_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(train_program, startup_program):
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)
exe.run(startup_program)
train_exe = fluid.ParallelExecutor(use_cuda=use_cuda,
main_program=train_program,
loss_name=loss.name)
# 如果feed参数是dict类型:
# 图像会被split到设备中。假设有两个设备，那么每个设备将会处理形为 (5, 1)的图像
x = numpy.random.random(size=(10, 1)).astype('float32')
loss_data, = train_exe.run(feed={"X": x},
fetch_list=[loss.name])
# 如果feed参数是list类型:
# 各设备挨个处理列表中的每个元素
# 第一个设备处理形为 (10, 1) 的图像
# 第二个设备处理形为 (9, 1) 的图像
#
# 使用 exe.device_count 得到设备数目
x1 = numpy.random.random(size=(10, 1)).astype('float32')
x2 = numpy.random.random(size=(9, 1)).astype('float32')
loss_data, = train_exe.run(feed=[{"X": x1}, {"X": x2}],
fetch_list=[loss.name])
.. py:method:: drop_local_exe_scopes()
立即清除scope中的临时变量。模型运行过程中，生成的中间临时变量将被放到local execution scope中，为了避免对临时变量频繁的申请与释放，ParallelExecutor中采取的策略是间隔若干次迭代之后清理一次临时变量。ParallelExecutor在ExecutionStrategy中提供了num_iteration_per_drop_scope选项，该选项表示间隔多少次迭代之后清理一次临时变量。如果num_iteration_per_drop_scope值为100，但是希望在迭代50次之后清理一次临时变量，可以通过手动调用该接口。
返回：无
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
import numpy
import os
use_cuda = True
# 注意：如果你使用CPU运行程序，需要具体设置CPU_NUM，
# 否则fluid会把逻辑核的所有数目设为CPU_NUM，
# 在这种情况下，输入的batch size应大于CPU_NUM，
# 否则程序会异常中断。
if not use_cuda:
os.environ['CPU_NUM'] = str(2)
train_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(train_program, startup_program):
data = fluid.layers.data(name='X', shape=[1], dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
loss = fluid.layers.mean(hidden)
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(startup_program)
parallel_exe = fluid.ParallelExecutor(use_cuda=use_cuda,
main_program=train_program,
loss_name=loss.name)
x = numpy.random.random(size=(10, 1)).astype('float32')
loss_data, = parallel_exe.run(feed={"X": x},
fetch_list=[loss.name])
parallel_exe.drop_local_exe_scopes()
doc/paddle/api/paddle/fluid/Program_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_Program:
Program
-------------------------------
.. py:class:: paddle.fluid.Program
**注意：默认情况下，Paddle Fluid内部默认含有** :ref:`cn_api_fluid_default_startup_program` **和** :ref:`cn_api_fluid_default_main_program` **，它们共享参数。** :ref:`cn_api_fluid_default_startup_program` **只运行一次来初始化参数，** :ref:`cn_api_fluid_default_main_program` **在每个mini batch中运行并更新权重。**
Program是Paddle Fluid对于计算图的一种静态描述，使用Program的构造函数可以创建一个Program。Program中包括至少一个 :ref:`api_guide_Block` ，当 :ref:`api_guide_Block` 中存在条件选择的控制流OP（例如 :ref:`cn_api_fluid_layers_While` 等）时，该Program将会含有嵌套着的 :ref:`api_guide_Block` 即控制流外部的 :ref:`api_guide_Block` 将包含着控制流内部的 :ref:`api_guide_Block` ，而嵌套的 :ref:`api_guide_Block` 的元素访问控制将由具体的控制流OP来决定。关于Program具体的结构和包含的类型请参阅 `framework.proto <https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/framework/framework.proto>`_
。
一个Program的集合通常包含初始化程序（startup_program）与主程序(main_program)，初始化程序是一个包含一些初始化工作的Program，主程序将会包含用来训练的网络结构和变量，在使用同一个 :ref:`api_guide_executor` 执行时他们会共享初始化工作的结果，例如初始化的参数。一个Program的集合可以被用来测试或者训练，被用来训练时， ``Paddle Fluid`` 将会利用所有用户使用的OP和变量来搭建一个训练网络，被用来测试时， 可以通过调用Program相关的接口例如：`clone` 剪去一些与测试无关的OP和变量，比如反向传播的OP和变量。
返回：创建的空的Program
返回值类型：Program
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
main_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(main_program=main_program, startup_program=startup_program):
x = fluid.layers.data(name="x", shape=[-1, 784], dtype='float32')
y = fluid.layers.data(name="y", shape=[-1, 1], dtype='int32')
z = fluid.layers.fc(name="fc", input=x, size=10, act="relu")
# start_up program here will share fc's weight with main program
print("main program is: {}".format(main_program))
print("start up program is: {}".format(startup_program))
.. py:method:: to_string(throw_on_error, with_details=False)
将Program转换为字符串
参数：
- **throw_on_error** (bool) - 是否在没有设置必需字段时抛出异常。
- **with_details** (bool) - 值为true时，打印更多关于变量和参数的信息，如trainable, optimize_attr等
返回： 将Program转换为字符串
返回类型： str
抛出异常： ``ValueError`` - 当 ``throw_on_error == true`` ，当没有设置任何必需的字段时，抛出 ``ValueError`` 。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
prog = fluid.default_main_program()
x = fluid.layers.data(name="X", shape=[2,3], dtype="float32", append_batch_size=False)
pred = fluid.layers.fc(x, size=3)
prog_string = prog.to_string(throw_on_error=True, with_details=False)
prog_string_with_details = prog.to_string(throw_on_error=False, with_details=True)
print("program string without detail: {}".format(prog_string))
print("program string with detail: {}".format(prog_string_with_details))
.. py:method:: clone(for_test=False)
**注意:**
**1.** ``Program.clone()`` **方法不会克隆例如** :ref:`cn_api_fluid_io_DataLoader` **这样的数据读取相关的部分，这可能会造成的数据读取部分在克隆后丢失**
**2. 此API当** ``for_test=True`` **时将会裁剪部分OP和变量。为防止错误的裁剪，推荐在** :ref:`cn_api_fluid_backward_append_backward` **和执行优化器之前使用** ``clone(for_test=True)`` 。
当 ``for_test=True`` 时创建一个新的、仅包含当前Program前向内容的Program。否则创建一个新的，和当前Program完全相同的Program
有些OP，在训练和测试之间的行为是不同的，比如 :ref:`cn_api_fluid_layers_batch_norm` 。它们有一个属性 ``is_test`` 来控制行为。当 ``for_test=True`` 时，此方法将把它们的 ``is_test`` 属性更改为True。
- 克隆Program用于训练时，将 ``for_test`` 设置为False。
- 克隆Program用于测试时，将 ``for_test`` 设置为True。虽然在这种情况下，如果在使用了优化器之后调用 ``clone`` 我们依旧会对Program当中反向执行以及优化器相关的内容进行自动裁剪，但是，我们强烈建议在使用优化器之前使用 ``clone`` 例如如果使用的是 :ref:`cn_api_fluid_optimizer_Momentum` 可以这样去使用:
**代码示例**
::
import paddle.fluid as fluid
img = fluid.layers.data(name='image', shape=[784])
pred = fluid.layers.fc(input=img, size=10, act='relu')
loss = fluid.layers.mean(pred)
## 我们推荐在使用 Optimizer前使用clone()接口
test_program = fluid.default_main_program().clone(for_test=True)
optimizer = fluid.optimizer.Momentum(learning_rate=0.01, momentum=0.9)
optimizer.minimize(loss)
参数：
- **for_test** (bool) – 取值为True时，clone方法内部会把operator的属性 ``is_test`` 设置为 True， 并裁剪反向OP和参数优化OP，默认值为False
返回：当 ``for_test=True`` 时返回一个新的、仅包含当前Program前向内容的Program。否则返回一个新的，和当前Program完全相同的Program
返回类型： Program
**代码示例**
注意，Program在clone后的顺序可能不同，这不会影响的训练或测试进程。在下面的示例中，我们提供了一个简单的方法print_prog（Program）来打印程序描述，以确保clone后仍能得到同样的打印结果：
.. code-block:: python
import paddle.fluid as fluid
import six
def print_prog(prog):
for name, value in sorted(six.iteritems(prog.block(0).vars)):
print(value)
for op in prog.block(0).ops:
print("op type is {}".format(op.type))
print("op inputs are {}".format(op.input_arg_names))
print("op outputs are {}".format(op.output_arg_names))
for key, value in sorted(six.iteritems(op.all_attrs())):
if key not in ['op_callstack', 'op_role_var']:
print(" [ attrs: {}: {} ]".format(key, value))
1.克隆一个Program，示例代码如下。
.. code-block:: python
import paddle.fluid as fluid
import six
def print_prog(prog):
for name, value in sorted(six.iteritems(prog.block(0).vars)):
print(value)
for op in prog.block(0).ops:
print("op type is {}".format(op.type))
print("op inputs are {}".format(op.input_arg_names))
print("op outputs are {}".format(op.output_arg_names))
for key, value in sorted(six.iteritems(op.all_attrs())):
if key not in ['op_callstack', 'op_role_var']:
print(" [ attrs: {}: {} ]".format(key, value))
train_program = fluid.Program()
startup_program = fluid.Program()
# ``startup_program`` 被用来执行一些参数初始化工作
# ``main_program`` 被用来容纳网络
with fluid.program_guard(train_program, startup_program):
with fluid.unique_name.guard():
img = fluid.layers.data(name='image', shape=[784])
hidden = fluid.layers.fc(input=img, size=200, act='relu')
hidden = fluid.layers.dropout(hidden, dropout_prob=0.5)
loss = fluid.layers.cross_entropy(
input=fluid.layers.fc(hidden, size=10, act='softmax'),
label=fluid.layers.data(name='label', shape=[1], dtype='int64'))
avg_loss = fluid.layers.mean(loss)
test_program = train_program.clone(for_test=True)
print_prog(test_program)
# 由于需要使训练和测试参数共享，我们需要使用训练的 ``startup_program``
# 来代替测试用的 ``startup_program``, 尽管测试的 ``startup_program`` 里面什么也没有。
# 在Paddle Fluid中我们会通过同样的变量名来共享权重.
# 训练和测试程序的所有参数将会拥有同样的名字，这将会使训练和测试程序实现参数的共享，
# 所以我们使用训练程序的 ``startup_program`` .并且由于测试的 ``startup_program`` 什么也没有,
# 因此它是一个新的程序.
with fluid.program_guard(train_program, startup_program):
with fluid.unique_name.guard():
sgd = fluid.optimizer.SGD(learning_rate=1e-3)
sgd.minimize(avg_loss)
2.如果分别运行 train Program 和 test Program，则可以不使用clone。
.. code-block:: python
import paddle.fluid as fluid
import six
def print_prog(prog):
for name, value in sorted(six.iteritems(prog.block(0).vars)):
print(value)
for op in prog.block(0).ops:
print("op type is {}".format(op.type))
print("op inputs are {}".format(op.input_arg_names))
print("op outputs are {}".format(op.output_arg_names))
for key, value in sorted(six.iteritems(op.all_attrs())):
if key not in ['op_callstack', 'op_role_var']:
print(" [ attrs: {}: {} ]".format(key, value))
def network():
img = fluid.layers.data(name='image', shape=[784])
hidden = fluid.layers.fc(input=img, size=200, act='relu')
hidden = fluid.layers.dropout(hidden, dropout_prob=0.5)
loss = fluid.layers.cross_entropy(
input=fluid.layers.fc(hidden, size=10, act='softmax'),
label=fluid.layers.data(name='label', shape=[1], dtype='int64'))
avg_loss = fluid.layers.mean(loss)
return avg_loss
train_program_2 = fluid.Program()
startup_program_2 = fluid.Program()
test_program_2 = fluid.Program()
with fluid.program_guard(train_program_2, startup_program_2):
with fluid.unique_name.guard():
avg_loss = network()
sgd = fluid.optimizer.SGD(learning_rate=1e-3)
sgd.minimize(avg_loss)
# 不使用测试阶段的启动程序
with fluid.program_guard(test_program_2, startup_program_2):
with fluid.unique_name.guard():
avg_loss = network()
print_prog(test_program_2)
上边两个代码片段生成和打印的Program是一样的。
.. py:staticmethod:: parse_from_string(binary_str)
通过对 `protobuf <https://en.wikipedia.org/wiki/Protocol_Buffers>`_ 的反序列化，转换成Program
参数：
- **binary_str_type** (str) – `protobuf <https://en.wikipedia.org/wiki/Protocol_Buffers>`_ 二进制字符串
返回：反序列化后的 Program
返回类型：Program
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
startup_prog = fluid.Program()
main_prog = fluid.Program()
with fluid.program_guard(startup_prog, main_prog):
x = fluid.layers.data(
name='X', shape=[1000, 784], dtype='float32', append_batch_size=False)
y = fluid.layers.data(
name='Y', shape=[784, 100], dtype='float32', append_batch_size=False)
z = fluid.layers.mul(x=x, y=y)
binary_str = fluid.default_main_program().desc.serialize_to_string()
prog_restored = fluid.default_main_program().parse_from_string(binary_str)
print(fluid.default_main_program())
print(prog_restored)
# 这里打印出的两个Program应该是一模一样的
.. py:attribute:: num_blocks
该Program中的 :ref:`api_guide_Block` 的个数
返回： 该Program中的 :ref:`api_guide_Block` 的个数
返回类型：int
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
prog = fluid.default_main_program()
num_blocks = prog.num_blocks
print(num_blocks)
## 1
## 当前Program中只有一个Block，即全局的Block
.. py:attribute:: random_seed
**注意：必须在相关OP被添加之前设置。**
程序中随机运算符的默认随机种子。0意味着随机生成随机种子。
返回：该Program中当前正在使用的random seed
返回类型：int64
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
prog = fluid.default_main_program()
random_seed = prog.random_seed
x_var = fluid.layers.data(name="X", shape=[3,3], dtype="float32", append_batch_size=False)
print(random_seed)
## 0
## 默认的random seed是 0
# 这里我们必须要在fluid.layers.dropout之前设置random_seed
prog.random_seed = 1
z_var = fluid.layers.dropout(x_var, 0.7)
print(prog.random_seed)
## 1
## 修改后random seed变成了 1
.. py:method:: global_block()
获取该Program的第一个 :ref:`api_guide_Block` 。
返回：该Program的第一个 :ref:`api_guide_Block`
返回类型：:ref:`api_guide_Block`
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
prog = fluid.default_main_program()
gb_block = prog.global_block()
print(gb_block)
##
## idx: 0
## parent_idx: -1
## 打印出了当前全局Block的描述
.. py:method:: block(index)
返回该Program中 ， ``index`` 指定的 :ref:`api_guide_Block` 。 ``index`` 类型为int
参数:
- **index** (int) - 需要获取的 :ref:`api_guide_Block` 的index
返回: 该Program中index对应的那个 :ref:`api_guide_Block`
返回类型: :ref:`api_guide_Block`
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
prog = fluid.default_main_program()
block_0 = prog.block(0)
print(block_0)
##
## idx: 0
## parent_idx: -1
## 打印出了0号Block的描述
.. py:method:: current_block()
获取当前 :ref:`api_guide_Block` 。当前 :ref:`api_guide_Block` 是用来添加OP的。
返回: 该Program中用户当前所在的 :ref:`api_guide_Block`
返回类型: :ref:`api_guide_Block`
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
prog = fluid.default_main_program()
current_blk = prog.current_block()
print(current_blk)
##
## idx: 0
## parent_idx: -1
## 打印出了当前Block的描述
.. py:method:: list_vars()
获取当前Program中所有变量。返回值是一个可迭代对象（iterable object)。
返回: Generator 会yield每个Program中的变量
返回类型: iterable 的 :ref:`api_guide_Variable`
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
prog = fluid.default_main_program()
img = fluid.layers.data(name='img', shape=[1,28,28], dtype='float32')
label = fluid.layers.data(name='label', shape=[128,1], dtype='int64')
for var in prog.list_vars():
print(var)
# 这里将会打印出当前Program中所有的Variable
.. py:method:: all_parameters()
获取当前Program中所有的 :ref:`api_guide_parameter` 。返回值是一个列表。
返回: 一个包含当前Program中所有参数的列表。
返回类型: list[ :ref:`api_guide_parameter` ]
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
program = fluid.default_main_program()
data = fluid.data(name='x', shape=[None, 13], dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
loss = fluid.layers.mean(hidden)
fluid.optimizer.SGD(learning_rate=0.01).minimize(loss)
for param in program.all_parameters():
print(param)
# 这里将会打印出当前Program中所有的Parameters，在本例中，输出结果是:
#
# name: "fc_0.w_0"
# type {
# type: LOD_TENSOR
# lod_tensor {
# tensor {
# data_type: FP32
# dims: 13
# dims: 10
# }
# }
# }
#
# persistable: true
# name: "fc_0.b_0"
# type {
# type: LOD_TENSOR
# lod_tensor {
# tensor {
# data_type: FP32
# dims: 10
# }
# }
# }
# persistable: true
#
# 这里print(param)将会打印出一个参数所有的属性，包括name，type和persistable，
# 你可以访问一个参数的指定属性，例如param.name，param.type
\ No newline at end of file
doc/paddle/api/paddle/fluid/WeightNormParamAttr_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_WeightNormParamAttr:
WeightNormParamAttr
-------------------------------
.. py:class:: paddle.fluid.WeightNormParamAttr(dim=None, name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, do_model_average=False)
:api_attr: 声明式编程模式（静态图)
.. note::
该类中的 ``gradient_clip`` 属性在2.0版本会废弃，推荐在初始化 ``optimizer`` 时设置梯度裁剪。共有三种裁剪策略： :ref:`cn_api_fluid_clip_GradientClipByGlobalNorm` 、
:ref:`cn_api_fluid_clip_GradientClipByNorm` 、 :ref:`cn_api_fluid_clip_GradientClipByValue` 。
该类定义了权重归一化(Weight Normalization)的参数。权重归一化可以将神经网络中权重向量的长度与其方向解耦，详细的定义与实现可以参考论文：`Weight Normalization: A Simple Reparameterization to Accelerate Training of Deep Neural Networks <https://arxiv.org/pdf/1602.07868.pdf>`_
参数:
- **dim** (int) - 进行归一化操作(norm)的切片所在维度，是小于权重Tensor rank的非负数。比如卷积的权重shape是 :math:`[cout, cin, kh, kw]` , rank是4，则dim可以选0,1,2,3；fc的权重shape是 :math:`[cout, cin]` ，rank是2，dim可以选0，1。 dim 默认为None，如果为None就对所有元素做归一化(norm)。
- **name** (None|str) - 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认为None。
- **initializer** （Initializer) - 初始化参数方法，例如 ``initializer = fluid.initializer.ConstantInitializer(1.0)`` 。默认为None，如果为None则使用默认初始化函数 `Xavier()` 。
- **learning_rate** (float32) - 学习率，优化过程 :math:`global\_lr∗parameter\_lr∗scheduler\_factor` 的学习速率，默认为1.0。
- **regularizer** (WeightDecayRegularizer，可选) - 正则化方法。支持两种正则化策略: :ref:`cn_api_fluid_regularizer_L1Decay` 、
:ref:`cn_api_fluid_regularizer_L2Decay` ，如果在 ``optimizer`` (例如 :ref:`cn_api_fluid_optimizer_SGDOptimizer` ) 中也
设置了正则化，``optimizer`` 中的正则化将被忽略。默认值为None，表示没有正则化。
- **trainable** (bool) - 可选，指明参数是否可训练，默认为True。
- **do_model_average** (bool) - 可选，指明参数是否需要模型平均化操作(Model Average)，默认为False。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name="data", shape=[3, 32, 32], dtype="float32")
fc = fluid.layers.fc(input=data,
size=1000,
param_attr=fluid.WeightNormParamAttr(
dim=None,
name='weight_norm_param',
initializer=fluid.initializer.ConstantInitializer(1.0),
learning_rate=1.0,
regularizer=fluid.regularizer.L2DecayRegularizer(regularization_coeff=0.1),
trainable=True,
do_model_average=False))
doc/paddle/api/paddle/fluid/default_main_program_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_default_main_program:
default_main_program
-------------------------------
.. py:function:: paddle.fluid.default_main_program()
此接口可以获取当前用于存储op和variable描述信息的 ``default main program``
``fluid.layers`` 接口中添加的op和variable会存储在 ``default main program`` 中
``default main program`` 是fluid的许多编程接口中Program参数的默认值。例如对于 ``Executor.run()`` 如果用户没有传入Program参数，会默认使用 ``default main program``
可以使用 :ref:`cn_api_fluid_program_guard` 来替换 ``default main program``
参数:
- 无
返回： 当前默认用于存储op和variable描述的Program
返回类型： :ref:`cn_api_fluid_Program`
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
#示例网络:
data = fluid.data(name='image', shape=[None, 3, 224, 224], dtype='float32')
label = fluid.data(name='label', shape=[None, 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')
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().num_blocks)
print(fluid.default_main_program().blocks[0].var('image'))
doc/paddle/api/paddle/fluid/default_startup_program_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_default_startup_program:
default_startup_program
-------------------------------
.. py:function:: paddle.fluid.default_startup_program()
该函数可以获取默认/全局 startup :ref:`cn_api_fluid_Program` (初始化启动程序)。
:ref:`_cn_api_fluid_layers` 中的函数会新建参数或 :ref:`cn_api_paddle_data_reader_reader` (读取器) 或 `NCCL <https://developer.nvidia.com/nccl>`_ 句柄作为全局变量。
startup_program会使用内在的OP（算子）去初始化他们，并由 :ref:`_cn_api_fluid_layers` 中的函数将这些OP追加到startup :ref:`cn_api_fluid_Program` 中。
该函数将返回默认的或当前的startup_program。用户可以使用 :ref:`cn_api_fluid_program_guard` 去切换 :ref:`cn_api_fluid_default_startup_program` 。
返回: 当前的默认/全局 初始化 :ref:`cn_api_fluid_Program`
返回类型: :ref:`cn_api_fluid_Program`
**代码示例：**
.. code-block:: python
import paddle.fluid as fluid
main_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(main_program=main_program, startup_program=startup_program):
x = fluid.layers.data(name="x", shape=[-1, 784], dtype='float32')
y = fluid.layers.data(name="y", shape=[-1, 1], dtype='int32')
z = fluid.layers.fc(name="fc", input=x, size=10, act="relu")
print("main program is: {}".format(fluid.default_main_program()))
print("start up program is: {}".format(fluid.default_startup_program()))
doc/paddle/api/paddle/fluid/dygraph/base/disable_dygraph_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_disable_dygraph:
disable_dygraph
-------------------------------
.. py:function:: paddle.fluid.disable_dygraph()
该接口关闭动态图模式。
返回：无
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
fluid.enable_dygraph() # Now we are in dygraph mode
print(fluid.in_dygraph_mode()) # True
fluid.disable_dygraph()
print(fluid.in_dygraph_mode()) # False
doc/paddle/api/paddle/fluid/dygraph/base/enable_dygraph_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_enable_dygraph:
enable_dygraph
-------------------------------
.. py:function:: paddle.fluid.enable_dygraph(place=None)
该接口打开动态图模式。
参数：
- **place** (fluid.CPUPlace 或 fluid.CUDAPlace，可选) - 执行动态图的设备数目。若为None，则设备根据paddle的编译方式决定。默认值为 ``None``。
返回：无
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
fluid.enable_dygraph() # Now we are in dygraph mode
print(fluid.in_dygraph_mode()) # True
fluid.disable_dygraph()
print(fluid.in_dygraph_mode()) # False
doc/paddle/api/paddle/fluid/framework/in_dygraph_mode_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_in_dygraph_mode:
in_dygraph_mode
-------------------------------
.. py:function:: paddle.fluid.in_dygraph_mode()
该接口检查程序是否在动态图模式中运行。
可以通过 ``fluid.dygraph.guard`` 接口开启动态图模式。
返回：如果程序是在动态图模式下运行的，则返回 ``True``。
返回类型：bool
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
fluid.enable_dygraph() # 现在进入 dygragh 模式
print(fluid.in_dygraph_mode()) # True
fluid.disable_dygraph()
print(fluid.in_dygraph_mode()) # False
doc/paddle/api/paddle/fluid/global_scope_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_executor_global_scope:
global_scope
-------------------------------
.. py:function:: paddle.fluid.global_scope()
:api_attr: 声明式编程模式（静态图)
获取全局/默认作用域实例。很多API使用默认 ``global_scope`` ，例如 ``Executor.run`` 等。
返回：全局/默认作用域实例
返回类型：Scope
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy
fluid.global_scope().var("data").get_tensor().set(numpy.ones((1, 2)), fluid.CPUPlace())
data = numpy.array(fluid.global_scope().find_var("data").get_tensor())
print(data) # [[1. 1.]]
doc/paddle/api/paddle/fluid/gradients_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_backward_gradients:
gradients
-------------------------------
.. py:function:: paddle.fluid.backward.gradients(targets, inputs, target_gradients=None, no_grad_set=None)
:api_attr: 声明式编程模式（静态图)
将目标梯度反向传播到输入。
参数：
- **targets** (Variable|list[Variable]) – 目标变量
- **inputs** (Variable|list[Variable]) – 输入变量
- **target_gradients** (Variable|list[Variable]，可选) – 目标的梯度变量，应与目标变量形状相同；如果设置为None，则以1初始化所有梯度变量
- **no_grad_set** (set[Variable|str]，可选) – 在 `block0` ( :ref:`api_guide_Block` ) 中要忽略梯度的 :ref:`api_guide_Variable` 的名字的集合。所有的 :ref:`api_guide_Block` 中带有 ``stop_gradient = True`` 的所有 :ref:`api_guide_Variable` 的名字都会被自动添加到此集合中。如果该参数不为 ``None``，则会将该参数集合的内容添加到默认的集合中。默认值为 ``None``。
返回：数组，包含与输入对应的梯度。如果一个输入不影响目标函数，则对应的梯度变量为None
返回类型：(list[Variable])
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
x = fluid.data(name='x', shape=[None,2,8,8], dtype='float32')
x.stop_gradient=False
y = fluid.layers.conv2d(x, 4, 1, bias_attr=False)
y = fluid.layers.relu(y)
y = fluid.layers.conv2d(y, 4, 1, bias_attr=False)
y = fluid.layers.relu(y)
z = fluid.gradients([y], x)
print(z)
\ No newline at end of file
doc/paddle/api/paddle/fluid/initializer/Normal_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_Normal:
Normal
-------------------------------
.. py:class:: paddle.fluid.layers.Normal(loc, scale)
正态分布
数学公式：
.. math::
pdf(x; \mu, \sigma) = \frac{1}{Z}e^{\frac {-0.5 (x - \mu)^2} {\sigma^2} }
Z = (2 \pi \sigma^2)^{0.5}
上面的数学公式中：
:math:`loc = \mu` : 平均值。
:math:`scale = \sigma` : 标准差。
:math:`Z`: 正态分布常量。
参数：
- **loc** (float|list|numpy.ndarray|Variable) - 正态分布平均值。数据类型为float32。
- **scale** (float|list|numpy.ndarray|Variable) - 正态分布标准差。数据类型为float32。
**代码示例**：
.. code-block:: python
import numpy as np
from paddle.fluid import layers
from paddle.fluid.layers import Normal
# 定义参数为float的正态分布。
dist = Normal(loc=0., scale=3.)
# 定义一组有两个数的正态分布。
# 第一组为均值1，标准差11，第二组为均值2，标准差22。
dist = Normal(loc=[1., 2.], scale=[11., 22.])
# 得到3个样本, 返回一个 3 x 2 张量。
dist.sample([3])
# 通过广播的方式，定义一个两个参数的正态分布。
# 均值都是1，标准差不同。
dist = Normal(loc=1., scale=[11., 22.])
# 一个完整的例子
value_npdata = np.array([0.8], dtype="float32")
value_tensor = layers.create_tensor(dtype="float32")
layers.assign(value_npdata, value_tensor)
normal_a = Normal([0.], [1.])
normal_b = Normal([0.5], [2.])
sample = normal_a.sample([2])
# 一个由定义好的正太分布随机生成的张量，维度为: [2, 1]
entropy = normal_a.entropy()
# [1.4189385] with shape: [1]
lp = normal_a.log_prob(value_tensor)
# [-1.2389386] with shape: [1]
kl = normal_a.kl_divergence(normal_b)
# [0.34939718] with shape: [1]
.. py:function:: sample(shape, seed=0)
生成指定维度的样本
参数：
- **shape** (list) - 1维列表，指定生成样本的维度。数据类型为int32。
- **seed** (int) - 长整型数。
返回：预先设计好维度的张量, 数据类型为float32
返回类型：Variable
.. py:function:: entropy()
信息熵
返回：正态分布的信息熵, 数据类型为float32
返回类型：Variable
.. py:function:: log_prob(value)
对数概率密度函数
参数：
- **value** (Variable) - 输入张量。数据类型为float32或float64。
返回：对数概率, 数据类型与value相同
返回类型：Variable
.. py:function:: kl_divergence(other)
两个正态分布之间的KL散度。
参数：
- **other** (Normal) - Normal的实例。
返回：两个正态分布之间的KL散度, 数据类型为float32
返回类型：Variable
doc/paddle/api/paddle/fluid/initializer/Uniform_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_Uniform:
Uniform
-------------------------------
.. py:class:: paddle.fluid.layers.Uniform(low, high)
均匀分布
概率密度函数（pdf）为：
.. math::
pdf(x; a, b) = \frac{1}{Z}, a <=x < b
Z = b - a
上面的数学公式中：
:math:`low = a` 。
:math:`high = b` 。
:math:`Z`: 正态分布常量。
参数low和high的维度必须能够支持广播。
参数：
- **low** (float|list|numpy.ndarray|Variable) - 均匀分布的下边界。数据类型为float32。
- **high** (float|list|numpy.ndarray|Variable) - 均匀分布的上边界。数据类型为float32。
**代码示例**：
.. code-block:: python
import numpy as np
from paddle.fluid import layers
from paddle.fluid.layers import Uniform
# 定义参数为float的均匀分布
u1 = Uniform(low=3.0, high=4.0)
# 定义参数为list的均匀分布
u2 = Uniform(low=[1.0, 2.0],
high=[3.0, 4.0])
# 通过广播的方式，定义一个均匀分布
u3 = Uniform(low=[[1.0, 2.0],
[3.0, 4.0]],
high=[[1.5, 2.5],
[3.5, 4.5]])
# 通过广播的方式，定义一个均匀分布
u4 = Uniform(low=3.0, high=[5.0, 6.0, 7.0])
# 一个完整的例子
value_npdata = np.array([0.8], dtype="float32")
value_tensor = layers.create_tensor(dtype="float32")
layers.assign(value_npdata, value_tensor)
uniform = Uniform([0.], [2.])
sample = uniform.sample([2])
# 一个由定义好的均匀分布随机生成的张量，维度为: [2, 1]
entropy = uniform.entropy()
# [0.6931472] with shape: [1]
lp = uniform.log_prob(value_tensor)
# [-0.6931472] with shape: [1]
.. py:function:: sample(shape, seed=0)
生成指定维度的样本
参数：
- **shape** (list) - 1维列表，指定生成样本的维度。数据类型为int32。
- **seed** (int) - 长整型数。
返回：预先设计好维度的张量, 数据类型为float32
返回类型：Variable
.. py:function:: entropy()
信息熵
返回：均匀分布的信息熵, 数据类型为float32
返回类型：Variable
.. py:function:: log_prob(value)
对数概率密度函数
参数：
- **value** (Variable) - 输入张量。数据类型为float32或float64。
返回：对数概率, 数据类型与value相同
返回类型：Variable
doc/paddle/api/paddle/fluid/io/load_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_dygraph_jit_load:
load
-----------------
.. py:function:: paddle.fluid.dygraph.jit.load(model_path, configs=None)
:api_attr: 命令式编程模式（动态图)
将接口 :ref:`cn_api_fluid_dygraph_jit_save` 或者 :ref:`cn_api_fluid_io_save_inference_model` 存储的模型载入为 :ref:`cn_api_fluid_dygraph_TranslatedLayer` ，用于预测推理或者fine-tune训练。
.. note::
由于一些历史原因，如果载入的模型是通过 :ref:`cn_api_fluid_io_save_inference_model` 存储的，
在使用它进行fine-tune训练时会存在一些局限：
1. 命令式编程模式不支持 ``LoDTensor`` ，所有原先输入变量或者参数依赖于LoD信息的模型暂时无法使用；
2. 所有存储模型的feed变量都需要被传入 ``Translatedlayer`` 的forward方法；
3. 原模型变量的 ``stop_gradient`` 信息已丢失且无法准确恢复；
4. 原模型参数的 ``trainable`` 信息已丢失且无法准确恢复。
参数：
- **model_path** (str) - 存储模型的目录。
- **configs** (SaveLoadConfig, 可选) - 用于指定额外配置选项的 :ref:`cn_api_fluid_dygraph_jit_SaveLoadConfig` 对象。默认为 ``None``。
返回：TranslatedLayer - 一个能够执行存储模型的 ``Layer`` 对象。
**示例代码**
1. 载入由接口 :ref:`cn_api_fluid_dygraph_jit_save` 存储的模型进行预测推理及fine-tune训练。
.. code-block:: python
import numpy as np
import paddle.fluid as fluid
from paddle.fluid.dygraph import Linear
from paddle.fluid.dygraph import declarative
BATCH_SIZE = 32
BATCH_NUM = 20
def random_batch_reader():
def _get_random_images_and_labels(image_shape, label_shape):
image = np.random.random(size=image_shape).astype('float32')
label = np.random.random(size=label_shape).astype('int64')
return image, label
def __reader__():
for _ in range(BATCH_NUM):
batch_image, batch_label = _get_random_images_and_labels(
[BATCH_SIZE, 784], [BATCH_SIZE, 1])
yield batch_image, batch_label
return __reader__
class LinearNet(fluid.dygraph.Layer):
def __init__(self, in_size, out_size):
super(LinearNet, self).__init__()
self._linear = Linear(in_size, out_size)
@declarative
def forward(self, x):
return self._linear(x)
# 开启命令式编程模式
fluid.enable_dygraph()
# 1. 训练存储模型.
# 创建网络
net = LinearNet(784, 1)
adam = fluid.optimizer.AdamOptimizer(learning_rate=0.1, parameter_list=net.parameters())
# 创建DataLoader
train_loader = fluid.io.DataLoader.from_generator(capacity=5)
train_loader.set_batch_generator(random_batch_reader())
# 训练
for data in train_loader():
img, label = data
label.stop_gradient = True
cost = net(img)
loss = fluid.layers.cross_entropy(cost, label)
avg_loss = fluid.layers.mean(loss)
avg_loss.backward()
adam.minimize(avg_loss)
net.clear_gradients()
model_path = "linear.example.model"
fluid.dygraph.jit.save(
layer=net,
model_path=model_path,
input_spec=[img])
# 2. 载入模型 & 预测
# 载入模型
infer_net = fluid.dygraph.jit.load(model_path)
# 预测
x = fluid.dygraph.to_variable(np.random.random((1, 784)).astype('float32'))
pred = infer_net(x)
# 3. 载入模型 & fine-tune训练
# 载入模型
train_net = fluid.dygraph.jit.load(model_path)
train_net.train()
adam = fluid.optimizer.AdamOptimizer(learning_rate=0.1, parameter_list=train_net.parameters())
# 创建DataLoader
train_loader = fluid.io.DataLoader.from_generator(capacity=5)
train_loader.set_batch_generator(random_batch_reader())
# fine-tune训练
for data in train_loader():
img, label = data
label.stop_gradient = True
cost = train_net(img)
loss = fluid.layers.cross_entropy(cost, label)
avg_loss = fluid.layers.mean(loss)
avg_loss.backward()
adam.minimize(avg_loss)
train_net.clear_gradients()
2. 载入由接口 :ref:`cn_api_fluid_io_save_inference_model` 存储的模型进行预测推理及fine-tune训练。
.. code-block:: python
import numpy as np
import paddle.fluid as fluid
BATCH_SIZE = 32
BATCH_NUM = 20
def random_batch_reader():
def _get_random_images_and_labels(image_shape, label_shape):
image = np.random.random(size=image_shape).astype('float32')
label = np.random.random(size=label_shape).astype('int64')
return image, label
def __reader__():
for _ in range(BATCH_NUM):
batch_image, batch_label = _get_random_images_and_labels(
[BATCH_SIZE, 784], [BATCH_SIZE, 1])
yield batch_image, batch_label
return __reader__
img = fluid.data(name='img', shape=[None, 784], dtype='float32')
label = fluid.data(name='label', shape=[None, 1], dtype='int64')
pred = fluid.layers.fc(input=img, size=10, act='softmax')
loss = fluid.layers.cross_entropy(input=pred, label=label)
avg_loss = fluid.layers.mean(loss)
optimizer = fluid.optimizer.SGD(learning_rate=0.001)
optimizer.minimize(avg_loss)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
loader = fluid.io.DataLoader.from_generator(
feed_list=[img, label], capacity=5, iterable=True)
loader.set_batch_generator(random_batch_reader(), places=place)
# 1. 训练 & 存储预测模型
for data in loader():
exe.run(
fluid.default_main_program(),
feed=data,
fetch_list=[avg_loss])
model_path = "fc.example.model"
fluid.io.save_inference_model(
model_path, ["img"], [pred], exe)
# 开启命令式编程模式
fluid.enable_dygraph()
# 2. 载入模型 & 预测
fc = fluid.dygraph.jit.load(model_path)
x = fluid.dygraph.to_variable(np.random.random((1, 784)).astype('float32'))
pred = fc(x)
# 3. 载入模型 & fine-tune训练
fc = fluid.dygraph.jit.load(model_path)
fc.train()
sgd = fluid.optimizer.SGD(learning_rate=0.001,
parameter_list=fc.parameters())
train_loader = fluid.io.DataLoader.from_generator(capacity=5)
train_loader.set_batch_generator(
random_batch_reader(), places=place)
for data in train_loader():
img, label = data
label.stop_gradient = True
cost = fc(img)
loss = fluid.layers.cross_entropy(cost, label)
avg_loss = fluid.layers.mean(loss)
avg_loss.backward()
sgd.minimize(avg_loss)
doc/paddle/api/paddle/fluid/layers/abs_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_abs:
abs
-------------------------------
.. py:function:: paddle.fluid.layers.abs(x, name=None)
:alias_main: paddle.abs
:alias: paddle.abs,paddle.tensor.abs,paddle.tensor.math.abs
:old_api: paddle.fluid.layers.abs
绝对值激活函数。
.. math::
out = |x|
参数:
- **x** (Variable)- 多维Tensor，数据类型为float32或float64。
- **name** (str) – 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None。
返回：表示绝对值结果的Tensor，数据类型与x相同。
返回类型：Variable
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.abs(data)
doc/paddle/api/paddle/fluid/layers/acos_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_acos:
acos
-------------------------------
.. py:function:: paddle.fluid.layers.acos(x, name=None)
:alias_main: paddle.acos
:alias: paddle.acos,paddle.tensor.acos,paddle.tensor.math.acos
:old_api: paddle.fluid.layers.acos
arccosine激活函数。
.. math::
out = cos^{-1}(x)
参数:
- **x(Variable)** - acos的输入Tensor，数据类型为 float32 或 float64
- **name** (str|None) – 具体用法请参见 :ref:`cn_api_guide_Name` ，一般无需设置，默认值为None。
返回： `acos` 的输出Tensor，数据类型与 `x` 相同。
返回类型： Variable
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name="input", shape=[4])
# if data is [-0.8183, 0.4912, -0.6444, 0.0371]
result = fluid.layers.acos(data)
# result is [2.5293, 1.0573, 2.2711, 1.5336]
doc/paddle/api/paddle/fluid/layers/asin_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_asin:
asin
-------------------------------
.. py:function:: paddle.fluid.layers.asin(x, name=None)
:alias_main: paddle.asin
:alias: paddle.asin,paddle.tensor.asin,paddle.tensor.math.asin
:old_api: paddle.fluid.layers.asin
arcsine激活函数。
.. math::
out = sin^{-1}(x)
参数:
- **x(Variable)** - asin的输入Tensor，数据类型为 float32 或 float64
- **name** (str|None) – 具体用法请参见 :ref:`cn_api_guide_Name` ，一般无需设置，默认值为None。
返回： `asin` 的输出Tensor，数据类型与 `x` 相同。
返回类型： Variable
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name="input", shape=[4])
# if data is [-0.8183, 0.4912, -0.6444, 0.0371]
result = fluid.layers.asin(data)
# result is [-0.9585, 0.5135, -0.7003, 0.0372]
doc/paddle/api/paddle/fluid/layers/atan_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_tensor_atan:
atan
-------------------------------
.. py:function:: paddle.atan(x, name=None, out=None)
arctanh 激活函数。
.. math::
out = tanh^{-1}(x)
参数:
- **x(Variable)** - atan的输入Tensor，数据类型为 float32 或 float64
- **name** (str|None) – 具体用法请参见 :ref:`cn_api_guide_Name` ，一般无需设置，默认值为None。
- **out** (Variable, 可选) – 指定存储运算结果的Tensor。如果设置为None或者不设置，将创建新的Tensor存储运算结果，默认值为None。
返回：返回类型为Variable(Tensor|LoDTensor)， 数据类型同输入一致。
**代码示例**：
.. code-block:: python
import numpy as np
import paddle
import paddle.fluid as fluid
inputs = fluid.layers.data(name="x", shape = [3], dtype='float32')
output = paddle.atan(inputs)
exe = fluid.Executor(fluid.CPUPlace())
exe.run(fluid.default_startup_program())
img = np.array([-0.8183, 0.4912, -0.6444, 0.0371]).astype(np.float32)
res = exe.run(fluid.default_main_program(), feed={'x':img}, fetch_list=[output])
print(res)
#[array([-0.6858003, 0.45658287, -0.5724284, 0.03708299], dtype=float32)]
doc/paddle/api/paddle/fluid/layers/ceil_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_ceil:
ceil
-------------------------------
.. py:function:: paddle.fluid.layers.ceil(x, name=None)
:alias_main: paddle.ceil
:alias: paddle.ceil,paddle.tensor.ceil,paddle.tensor.math.ceil
:old_api: paddle.fluid.layers.ceil
向上取整运算函数。
.. math::
out = \left \lceil x \right \rceil
参数:
- **x** (Variable) - 该OP的输入为多维Tensor。数据类型为float32或float64。
- **name** (str, 可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为None。
返回： 输出为Tensor，与 ``x`` 维度相同、数据类型相同。
返回类型： Variable
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
input_ceil = np.array([[-1.5,6],[1,15.6]])
with fluid.dygraph.guard():
x = fluid.dygraph.to_variable(input_ceil)
y = fluid.layers.ceil(x)
print(y.numpy())
# [[-1. 6.]
# [ 1. 16.]]
doc/paddle/api/paddle/fluid/layers/cos_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_cos:
cos
-------------------------------
.. py:function:: paddle.fluid.layers.cos(x, name=None)
:alias_main: paddle.cos
:alias: paddle.cos,paddle.tensor.cos,paddle.tensor.math.cos
:old_api: paddle.fluid.layers.cos
余弦函数。
.. math::
out = cos(x)
参数:
- **x** (Variable) - 该OP的输入为多维Tensor，数据类型为float32，float64。
- **name** (str, 可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为None。
返回：输出为Tensor，与 ``x`` 维度相同、数据类型相同。
返回类型：Variable
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
input_cos = np.array([[-1,np.pi],[1,15.6]])
with fluid.dygraph.guard():
x = fluid.dygraph.to_variable(input_cos)
y = fluid.layers.cos(x)
print(y.numpy())
# [[ 0.54030231 -1. ]
# [ 0.54030231 -0.99417763]]
doc/paddle/api/paddle/fluid/layers/cumsum_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_cumsum:
cumsum
-------------------------------
.. py:function:: paddle.fluid.layers.cumsum(x,axis=None,exclusive=None,reverse=None)
:alias_main: paddle.cumsum
:alias: paddle.cumsum,paddle.tensor.cumsum,paddle.tensor.math.cumsum
:old_api: paddle.fluid.layers.cumsum
沿给定轴(axis)的元素的累加和。默认结果的第一个元素和输入的第一个元素一致。如果exlusive为True，结果的第一个元素则为0。
参数：
- **x** (Variable) - 累加的输入，需要进行累加操作的变量Tensor/LoDTensor。
- **axis** (int，可选) - 指明需要累加的维。-1代表最后一维。默认为：-1。
- **exclusive** (bool，可选) - 是否执行exclusive累加。默认为：False。
- **reverse** (bool，可选) - 若为True，则以相反顺序执行累加。默认为：False。
返回：Variable(Tensor)。是累加的结果，即累加器的输出。
返回类型：变量(Variable)。
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.cumsum(data, axis=0)
doc/paddle/api/paddle/fluid/layers/elementwise_add_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_elementwise_add:
elementwise_add
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_add(x, y, axis=-1, act=None, name=None)
:alias_main: paddle.elementwise_add
:alias: paddle.elementwise_add,paddle.tensor.elementwise_add,paddle.tensor.math.elementwise_add
:old_api: paddle.fluid.layers.elementwise_add
该OP是逐元素相加算子，输入 ``x`` 与输入 ``y`` 逐元素相加，并将各个位置的输出元素保存到返回结果中。
等式为：
.. math::
Out = X + Y
- :math:`X` ：多维Tensor。
- :math:`Y` ：维度必须小于等于X维度的Tensor。
对于这个运算算子有2种情况：
1. :math:`Y` 的 ``shape`` 与 :math:`X` 相同。
2. :math:`Y` 的 ``shape`` 是 :math:`X` 的连续子序列。
对于情况2:
1. 用 :math:`Y` 匹配 :math:`X` 的形状（shape），其中 ``axis`` 是 :math:`Y` 在 :math:`X` 上的起始维度的位置。
2. 如果 ``axis`` 为-1（默认值），则 :math:`axis= rank(X)-rank(Y)` 。
3. 考虑到子序列， :math:`Y` 的大小为1的尾部维度将被忽略，例如shape（Y）=（2,1）=>（2）。
例如：
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
参数：
- **x** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` 。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64``。
- **y** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` 。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64``。
- **axis** （int32，可选）- ``y`` 的维度对应到 ``x`` 维度上时的索引。默认值为 -1。
- **act** （str，可选）- 激活函数名称，作用于输出上。默认值为None。详细请参考 :ref:`api_guide_activations` ， 常见的激活函数有: ``relu`` ``tanh`` ``sigmoid`` 等。
- **name** （str，可选）- 输出的名字。默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。
返回： 维度与 ``x`` 相同的 ``Tensor`` 或 ``LoDTensor`` ，数据类型与 ``x`` 相同。
返回类型： Variable。
**代码示例 1**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.array([2, 3, 4]),
"y": np.array([1, 5, 2])
}
x = fluid.layers.data(name="x", shape=[3], dtype='float32')
y = fluid.layers.data(name="y", shape=[3], dtype='float32')
z = fluid.layers.elementwise_add(x, y)
# z = x + y
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) # [3., 8., 6.]
**代码示例 2**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.random.randint(1, 5, size=[2, 3, 4, 5]).astype('float32'),
"y": np.random.randint(1, 5, size=[3, 4]).astype('float32')
}
x = fluid.layers.data(name="x", shape=[2,3,4,5], dtype='float32')
y = fluid.layers.data(name="y", shape=[3,4], dtype='float32')
z = fluid.layers.elementwise_add(x, y, axis=1)
# z = x + y
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) # z.shape=[2,3,4,5]
**代码示例 3**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.random.randint(1, 5, size=[2, 3, 4, 5]).astype('float32'),
"y": np.random.randint(1, 5, size=[5]).astype('float32')
}
x = fluid.layers.data(name="x", shape=[2,3,4,5], dtype='float32')
y = fluid.layers.data(name="y", shape=[5], dtype='float32')
# z = x + y
z = fluid.layers.elementwise_add(x, y, axis=3)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) # z.shape=[2,3,4,5]
doc/paddle/api/paddle/fluid/layers/elementwise_div_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_elementwise_div:
elementwise_div
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_div(x, y, axis=-1, act=None, name=None)
:alias_main: paddle.elementwise_div
:alias: paddle.elementwise_div,paddle.tensor.elementwise_div,paddle.tensor.math.elementwise_div
:old_api: paddle.fluid.layers.elementwise_div
该OP是逐元素相除算子，输入 ``x`` 与输入 ``y`` 逐元素相除，并将各个位置的输出元素保存到返回结果中。
等式是：
.. math::
Out = X / Y
- :math:`X` ：多维Tensor。
- :math:`Y` ：维度必须小于等于X维度的Tensor。
对于这个运算算子有2种情况：
1. :math:`Y` 的 ``shape`` 与 :math:`X` 相同。
2. :math:`Y` 的 ``shape`` 是 :math:`X` 的连续子序列。
对于情况2:
1. 用 :math:`Y` 匹配 :math:`X` 的形状（shape），其中 ``axis`` 是 :math:`Y` 在 :math:`X` 上的起始维度的位置。
2. 如果 ``axis`` 为-1（默认值），则 :math:`axis= rank(X)-rank(Y)` 。
3. 考虑到子序列， :math:`Y` 的大小为1的尾部维度将被忽略，例如shape（Y）=（2,1）=>（2）。
例如：
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
参数：
- **x** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` 。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64``。
- **y** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` 。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64``。
- **axis** （int32，可选）- ``y`` 的维度对应到 ``x`` 维度上时的索引。默认值为 -1。
- **act** （str，可选）- 激活函数名称，作用于输出上。默认值为None。详细请参考 :ref:`api_guide_activations` ， 常见的激活函数有: ``relu`` ``tanh`` ``sigmoid`` 等。
- **name** （str，可选）- 输出的名字。默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。
返回： 维度与 ``x`` 相同的 ``Tensor`` 或 ``LoDTensor`` ，数据类型与 ``x`` 相同。
返回类型： Variable。
**代码示例 1**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.array([2, 3, 4]),
"y": np.array([1, 5, 2])
}
x = fluid.layers.data(name="x", shape=[3], dtype='float32')
y = fluid.layers.data(name="y", shape=[3], dtype='float32')
z = fluid.layers.elementwise_div(x, y)
# z = x / y
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) # [2., 0.6, 2.]
**代码示例 2**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.random.randint(1, 5, size=[2, 3, 4, 5]).astype('float32'),
"y": np.random.randint(1, 5, size=[3, 4]).astype('float32')
}
x = fluid.layers.data(name="x", shape=[2,3,4,5], dtype='float32')
y = fluid.layers.data(name="y", shape=[3,4], dtype='float32')
z = fluid.layers.elementwise_div(x, y, axis=1)
# z = x / y
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) # z.shape=[2,3,4,5]
**代码示例 3**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.random.randint(1, 5, size=[2, 3, 4, 5]).astype('float32'),
"y": np.random.randint(1, 5, size=[5]).astype('float32')
}
x = fluid.layers.data(name="x", shape=[2,3,4,5], dtype='float32')
y = fluid.layers.data(name="y", shape=[5], dtype='float32')
z = fluid.layers.elementwise_div(x, y, axis=3)
# z = x / y
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) # z.shape=[2,3,4,5]
doc/paddle/api/paddle/fluid/layers/elementwise_floordiv_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_elementwise_floordiv:
elementwise_floordiv
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_floordiv(x, y, axis=-1, act=None, name=None)
:alias_main: paddle.elementwise_floordiv
:alias: paddle.elementwise_floordiv,paddle.tensor.elementwise_floordiv,paddle.tensor.math.elementwise_floordiv
:old_api: paddle.fluid.layers.elementwise_floordiv
该OP是逐元素整除算子，输入 ``x`` 与输入 ``y`` 逐元素整除，并将各个位置的输出元素保存到返回结果中。
等式为：
.. math::
Out = X // Y
- :math:`X` ：多维Tensor。
- :math:`Y` ：维度必须小于等于X维度的Tensor。
对于这个运算算子有2种情况：
1. :math:`Y` 的 ``shape`` 与 :math:`X` 相同。
2. :math:`Y` 的 ``shape`` 是 :math:`X` 的连续子序列。
对于情况2:
1. 用 :math:`Y` 匹配 :math:`X` 的形状（shape），其中 ``axis`` 是 :math:`Y` 在 :math:`X` 上的起始维度的位置。
2. 如果 ``axis`` 为-1（默认值），则 :math:`axis= rank(X)-rank(Y)` 。
3. 考虑到子序列， :math:`Y` 的大小为1的尾部维度将被忽略，例如shape（Y）=（2,1）=>（2）。
例如：
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
参数：
- **x** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` 。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64``。
- **y** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` 。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64``。
- **axis** （int32，可选）- ``y`` 的维度对应到 ``x`` 维度上时的索引。默认值为 -1。
- **act** （str，可选）- 激活函数名称，作用于输出上。详细请参考 :ref:`api_guide_activations` ， 常见的激活函数有: ``relu`` ``tanh`` ``sigmoid`` 等。如果为None则不添加激活函数。默认值为None。
- **name** （str，可选）- 输出的名字。默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。
返回： 维度与 ``x`` 相同的 ``Tensor`` 或 ``LoDTensor`` ，数据类型与 ``x`` 相同。
返回类型： Variable。
**代码示例 1**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.array([2, 3, 4]),
"y": np.array([1, 5, 2])
}
x = fluid.data(name="x", shape=[3], dtype='int64')
y = fluid.data(name="y", shape=[3], dtype='int64')
z = fluid.layers.elementwise_floordiv(x, y)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(), fetch_list=[z.name])
print(z_value) #[2,0,2]
**代码示例 2**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.random.randint(1, 5, size=[2, 3, 4, 5]),
"y": np.random.randint(1, 5, size=[3, 4])
}
x = fluid.data(name="x", shape=[2,3,4,5], dtype='int64')
y = fluid.data(name="y", shape=[3,4], dtype='int64')
z = fluid.layers.elementwise_floordiv(x, y, axis=1)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) # z.shape=[2,3,4,5]
**代码示例 3**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.random.randint(1, 5, size=[2, 3, 4, 5]),
"y": np.random.randint(1, 5, size=[5])
}
x = fluid.data(name="x", shape=[2,3,4,5], dtype='int64')
y = fluid.data(name="y", shape=[5], dtype='int64')
z = fluid.layers.elementwise_floordiv(x, y, axis=3)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) # z.shape=[2,3,4,5]
doc/paddle/api/paddle/fluid/layers/elementwise_max_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_elementwise_max:
elementwise_max
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_max(x, y, axis=-1, act=None, name=None)
:alias_main: paddle.elementwise_max
:alias: paddle.elementwise_max,paddle.tensor.elementwise_max,paddle.tensor.math.elementwise_max
:old_api: paddle.fluid.layers.elementwise_max
该OP逐元素对比输入的两个多维Tensor，并且把各个位置更大的元素保存到返回结果中。
等式是：
.. math::
Out = max(X, Y)
- :math:`X` ：多维Tensor。
- :math:`Y` ：多维Tensor。
此运算算子有两种情况：
1. :math:`Y` 的 ``shape`` 与 :math:`X` 相同。
2. :math:`Y` 的 ``shape`` 是 :math:`X` 的连续子序列。
对于情况2：
1. 用 :math:`Y` 的 ``shape`` 匹配 :math:`X` 的 ``shape``，其中 ``axis`` 是 :math:`Y` 在 :math:`X` 上的起始维度的位置。
2. 如果 ``axis`` 为-1（默认值），则 :math:`axis = rank（X）-rank（Y）` 。
3. 考虑到子序列， :math:`Y` 的大小为1的尾部维度将被忽略，例如shape（Y）=（2,1）=>（2）。
例如：
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
参数：
- **x** （Variable）- 多维Tensor。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64`` 。
- **y** （Variable）- 多维Tensor。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64`` 。
- **axis** （int32, 可选）- Y的维度对应到X维度上时的索引。默认值为 -1。
- **act** （string, 可选）- 激活函数名称，作用于输出上。默认值为None。详细请参考 :ref:`api_guide_activations` ， 常见的激活函数有: ``relu`` ``tanh`` ``sigmoid`` 等。
- **name** （string, 可选）- 输出的名字。默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。
返回： 维度和数据类型与 ``x`` 相同的多维Tensor。
返回类型： 多维Tensor。
**代码示例 1**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.array([2, 3, 4]),
"y": np.array([1, 5, 2])
}
x = fluid.layers.data(name="x", shape=[3], dtype='float32')
y = fluid.layers.data(name="y", shape=[3], dtype='float32')
z = fluid.layers.elementwise_max(x, y)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) #[2, 5, 4]
**代码示例 2**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.ones((2, 3, 4, 5)).astype('float32'),
"y": np.zeros((3, 4)).astype('float32')
}
x = fluid.layers.data(name="x", shape=[2,3,4,5], dtype='float32')
y = fluid.layers.data(name="y", shape=[3,4], dtype='float32')
z = fluid.layers.elementwise_max(x, y, axis=1)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value)#[[[[1., 1., 1., 1., 1.] .... [1., 1., 1., 1., 1.]]]]
doc/paddle/api/paddle/fluid/layers/elementwise_min_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_elementwise_min:
elementwise_min
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_min(x, y, axis=-1, act=None, name=None)
:alias_main: paddle.elementwise_min
:alias: paddle.elementwise_min,paddle.tensor.elementwise_min,paddle.tensor.math.elementwise_min
:old_api: paddle.fluid.layers.elementwise_min
该OP逐元素对比输入的两个多维Tensor，并且把各个位置更小的元素保存到返回结果中。
等式是：
.. math::
Out = min(X, Y)
- :math:`X` ：多维Tensor。
- :math:`Y` ：多维Tensor。
此运算算子有两种情况：
1. :math:`Y` 的 ``shape`` 与 :math:`X` 相同。
2. :math:`Y` 的 ``shape`` 是 :math:`X` 的连续子序列。
对于情况2：
1. 用 :math:`Y` 的 ``shape`` 匹配 :math:`X` 的 ``shape``，其中 ``axis`` 是 :math:`Y` 在 :math:`X` 上的起始维度的位置。
2. 如果 ``axis`` 为-1（默认值），则 :math:`axis = rank（X）-rank（Y）` 。
3. 考虑到子序列， :math:`Y` 的大小为1的尾部维度将被忽略，例如shape（Y）=（2,1）=>（2）。
例如：
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
参数：
- **x** （Variable）- 多维Tensor。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64`` 。
- **y** （Variable）- 多维Tensor。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64`` 。
- **axis** （int32, 可选）- Y的维度对应到X维度上时的索引。默认值为 -1。
- **act** （string, 可选）- 激活函数名称，作用于输出上。默认值为None。详细请参考 :ref:`api_guide_activations` ， 常见的激活函数有: ``relu`` ``tanh`` ``sigmoid`` 等。
- **name** （string, 可选）- 输出的名字。默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。
返回： 维度和数据类型与 ``x`` 相同的多维Tensor。
返回类型： 多维Tensor。
**代码示例 1**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.array([2, 3, 4]),
"y": np.array([1, 5, 2])
}
x = fluid.layers.data(name="x", shape=[3], dtype='float32')
y = fluid.layers.data(name="y", shape=[3], dtype='float32')
z = fluid.layers.elementwise_min(x, y)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) #[1, 3, 2]
**代码示例 2**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.ones((2, 3, 4, 5)).astype('float32'),
"y": np.zeros((3, 4)).astype('float32')
}
x = fluid.layers.data(name="x", shape=[2,3,4,5], dtype='float32')
y = fluid.layers.data(name="y", shape=[3,4], dtype='float32')
z = fluid.layers.elementwise_min(x, y, axis=1)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value)#[[[[0., 0., 0., 0., 0.] .... [0., 0., 0., 0., 0.]]]]
doc/paddle/api/paddle/fluid/layers/elementwise_mod_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_elementwise_mod:
elementwise_mod
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_mod(x, y, axis=-1, act=None, name=None)
:alias_main: paddle.elementwise_mod
:alias: paddle.elementwise_mod,paddle.tensor.elementwise_mod,paddle.tensor.math.elementwise_mod
:old_api: paddle.fluid.layers.elementwise_mod
该OP是逐元素取模算子，输入 ``x`` 与输入 ``y`` 逐元素取模，并将各个位置的输出元素保存到返回结果中。
等式为：
.. math::
Out = X \% Y
- :math:`X` ：多维Tensor。
- :math:`Y` ：维度必须小于等于X维度的Tensor。
对于这个运算算子有2种情况：
1. :math:`Y` 的 ``shape`` 与 :math:`X` 相同。
2. :math:`Y` 的 ``shape`` 是 :math:`X` 的连续子序列。
对于情况2:
1. 用 :math:`Y` 匹配 :math:`X` 的形状（shape），其中 ``axis`` 是 :math:`Y` 在 :math:`X` 上的起始维度的位置。
2. 如果 ``axis`` 为-1（默认值），则 :math:`axis= rank(X)-rank(Y)` 。
3. 考虑到子序列， :math:`Y` 的大小为1的尾部维度将被忽略，例如shape（Y）=（2,1）=>（2）。
例如：
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
参数：
- **x** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` 。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64``。
- **y** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` 。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64``。
- **axis** （int32，可选）- ``y`` 的维度对应到 ``x`` 维度上时的索引。默认值为 -1。
- **act** （str，可选）- 激活函数名称，作用于输出上。详细请参考 :ref:`api_guide_activations` ， 常见的激活函数有: ``relu`` ``tanh`` ``sigmoid`` 等。如果为None则不添加激活函数。默认值为None。
- **name** （str，可选）- 输出的名字。默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。
返回： 维度与 ``x`` 相同的 ``Tensor`` 或 ``LoDTensor`` ，数据类型与 ``x`` 相同。
返回类型： Variable。
**代码示例 1**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.array([2, 3, 4]),
"y": np.array([1, 5, 2])
}
x = fluid.data(name="x", shape=[3], dtype='int64')
y = fluid.data(name="y", shape=[3], dtype='int64')
z = fluid.layers.elementwise_mod(x, y)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(), fetch_list=[z.name])
print(z_value) #[0,3,0]
**代码示例 2**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.random.randint(1, 5, size=[2, 3, 4, 5]),
"y": np.random.randint(1, 5, size=[3, 4])
}
x = fluid.data(name="x", shape=[2,3,4,5], dtype='int64')
y = fluid.data(name="y", shape=[3,4], dtype='int64')
z = fluid.layers.elementwise_mod(x, y, axis=1)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) # z.shape=[2,3,4,5]
**代码示例 3**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.random.randint(1, 5, size=[2, 3, 4, 5]),
"y": np.random.randint(1, 5, size=[5])
}
x = fluid.data(name="x", shape=[2,3,4,5], dtype='int64')
y = fluid.data(name="y", shape=[5], dtype='int64')
z = fluid.layers.elementwise_mod(x, y, axis=3)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) # z.shape=[2,3,4,5]
doc/paddle/api/paddle/fluid/layers/elementwise_pow_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_elementwise_pow:
elementwise_pow
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_pow(x, y, axis=-1, act=None, name=None)
:alias_main: paddle.elementwise_pow
:alias: paddle.elementwise_pow,paddle.tensor.elementwise_pow,paddle.tensor.math.elementwise_pow
:old_api: paddle.fluid.layers.elementwise_pow
该OP逐元素对输入Tensor进行幂操作。
等式是：
.. math::
Out = X ^ Y
- :math:`X` ：多维Tensor。
- :math:`Y` ：多维Tensor。
此运算算子有两种情况：
1. :math:`Y` 的 ``shape`` 与 :math:`X` 相同。
2. :math:`Y` 的 ``shape`` 是 :math:`X` 的连续子序列。
对于情况2：
1. 用 :math:`Y` 的 ``shape`` 匹配 :math:`X` 的 ``shape``，其中 ``axis`` 是 :math:`Y` 在 :math:`X` 上的起始维度的位置。
2. 如果 ``axis`` 为-1（默认值），则 :math:`axis = rank（X）-rank（Y）` 。
3. 考虑到子序列， :math:`Y` 的大小为1的尾部维度将被忽略，例如shape（Y）=（2,1）=>（2）。
例如：
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
参数：
- **x** （Variable）- 多维Tensor。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64`` 。
- **y** （Variable）- 多维Tensor。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64`` 。
- **axis** （int32, 可选）- Y的维度对应到X维度上时的索引。默认值为 -1。
- **act** （string, 可选）- 激活函数名称，作用于输出上。默认值为None。详细请参考 :ref:`api_guide_activations` ， 常见的激活函数有: ``relu`` ``tanh`` ``sigmoid`` 等。
- **name** （string, 可选）- 输出的名字。默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。
返回： 维度和数据类型与 ``x`` 相同的多维Tensor。
返回类型： 多维Tensor。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.array([2, 3, 4]),
"y": np.array([1, 5, 2])
}
x = fluid.layers.data(name="x", shape=[3], dtype='float32')
y = fluid.layers.data(name="y", shape=[3], dtype='float32')
z = fluid.layers.elementwise_pow(x, y)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) #[2, 243, 16]
doc/paddle/api/paddle/fluid/layers/elementwise_sub_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_elementwise_sub:
elementwise_sub
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_sub(x, y, axis=-1, act=None, name=None)
:alias_main: paddle.elementwise_sub
:alias: paddle.elementwise_sub,paddle.tensor.elementwise_sub,paddle.tensor.math.elementwise_sub
:old_api: paddle.fluid.layers.elementwise_sub
该OP是逐元素相减算子，输入 ``x`` 与输入 ``y`` 逐元素相减，并将各个位置的输出元素保存到返回结果中。
等式是：
.. math::
Out = X - Y
- :math:`X` ：多维Tensor。
- :math:`Y` ：维度必须小于等于X维度的Tensor。
对于这个运算算子有2种情况：
1. :math:`Y` 的 ``shape`` 与 :math:`X` 相同。
2. :math:`Y` 的 ``shape`` 是 :math:`X` 的连续子序列。
对于情况2:
1. 用 :math:`Y` 匹配 :math:`X` 的形状（shape），其中 ``axis`` 是 :math:`Y` 在 :math:`X` 上的起始维度的位置。
2. 如果 ``axis`` 为-1（默认值），则 :math:`axis= rank(X)-rank(Y)` 。
3. 考虑到子序列， :math:`Y` 的大小为1的尾部维度将被忽略，例如shape（Y）=（2,1）=>（2）。
例如：
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
参数：
- **x** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` 。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64``。
- **y** （Variable）- 多维 ``Tensor`` 或 ``LoDTensor`` 。数据类型为 ``float32`` 、 ``float64`` 、 ``int32`` 或 ``int64``。
- **axis** （int32，可选）- ``y`` 的维度对应到 ``x`` 维度上时的索引。默认值为 -1。
- **act** （str，可选）- 激活函数名称，作用于输出上。默认值为None。详细请参考 :ref:`api_guide_activations` ， 常见的激活函数有: ``relu`` ``tanh`` ``sigmoid`` 等。
- **name** （str，可选）- 输出的名字。默认值为None。该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` 。
返回： 维度与 ``x`` 相同的 ``Tensor`` 或 ``LoDTensor`` ，数据类型与 ``x`` 相同。
返回类型： Variable。
**代码示例 1**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.array([2, 3, 4]),
"y": np.array([1, 5, 2])
}
x = fluid.layers.data(name="x", shape=[3], dtype='float32')
y = fluid.layers.data(name="y", shape=[3], dtype='float32')
z = fluid.layers.elementwise_sub(x, y)
# z = x - y
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) # [1., -2., 2.]
**代码示例 2**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.random.randint(1, 5, size=[2, 3, 4, 5]).astype('float32'),
"y": np.random.randint(1, 5, size=[3, 4]).astype('float32')
}
x = fluid.layers.data(name="x", shape=[2,3,4,5], dtype='float32')
y = fluid.layers.data(name="y", shape=[3,4], dtype='float32')
z = fluid.layers.elementwise_sub(x, y, axis=1)
# z = x - y
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) # z.shape=[2,3,4,5]
**代码示例 3**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {
"x": np.random.randint(1, 5, size=[2, 3, 4, 5]).astype('float32'),
"y": np.random.randint(1, 5, size=[5]).astype('float32')
}
x = fluid.layers.data(name="x", shape=[2,3,4,5], dtype='float32')
y = fluid.layers.data(name="y", shape=[5], dtype='float32')
z = fluid.layers.elementwise_sub(x, y, axis=3)
# z = x - y
place = fluid.CPUPlace()
exe = fluid.Executor(place)
z_value = exe.run(feed=gen_data(),
fetch_list=[z.name])
print(z_value) # z.shape=[2,3,4,5]
doc/paddle/api/paddle/fluid/layers/erf_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_erf:
erf
-------------------------------
.. py:function:: paddle.fluid.layers.erf(x)
:alias_main: paddle.erf
:alias: paddle.erf,paddle.tensor.erf,paddle.tensor.math.erf,paddle.nn.functional.erf,paddle.nn.functional.activation.erf
:old_api: paddle.fluid.layers.erf
逐元素计算 Erf 激活函数。更多细节请参考 `Error function <https://en.wikipedia.org/wiki/Error_function>`_ 。
.. math::
out = \frac{2}{\sqrt{\pi}} \int_{0}^{x}e^{- \eta^{2}}d\eta
参数：
- **x** (Variable) - Erf Op 的输入，多维 Tensor 或 LoDTensor，数据类型为 float16, float32 或 float64。
返回：
- 多维 Tensor 或 LoDTensor, 数据类型为 float16, float32 或 float64， 和输入 x 的数据类型相同，形状和输入 x 相同。
返回类型：
- Variable
**代码示例**：
.. code-block:: python
# declarative mode
import numpy as np
from paddle import fluid
x = fluid.data(name="x", shape=(-1, 3), dtype="float32")
y = fluid.layers.erf(x)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
start = fluid.default_startup_program()
main = fluid.default_main_program()
data = np.random.randn(2, 3).astype("float32")
exe.run(start)
y_np, = exe.run(main, feed={"x": data}, fetch_list=[y])
data
# array([[ 0.4643714 , -1.1509596 , 1.2538221 ],
# [ 0.34369683, 0.27478245, 1.1805398 ]], dtype=float32)
y_np
# array([[ 0.48863927, -0.8964121 , 0.9237998 ],
# [ 0.37307587, 0.30242872, 0.9049887 ]], dtype=float32)
.. code-block:: python
# imperative mode
import numpy as np
from paddle import fluid
import paddle.fluid.dygraph as dg
data = np.random.randn(2, 3).astype("float32")
place = fluid.CPUPlace()
with dg.guard(place) as g:
x = dg.to_variable(data)
y = fluid.layers.erf(x)
y_np = y.numpy()
data
# array([[ 0.4643714 , -1.1509596 , 1.2538221 ],
# [ 0.34369683, 0.27478245, 1.1805398 ]], dtype=float32)
y_np
# array([[ 0.48863927, -0.8964121 , 0.9237998 ],
# [ 0.37307587, 0.30242872, 0.9049887 ]], dtype=float32)
doc/paddle/api/paddle/fluid/layers/exp_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_exp:
exp
-------------------------------
.. py:function:: paddle.fluid.layers.exp(x, name=None)
:alias_main: paddle.exp
:alias: paddle.exp,paddle.tensor.exp,paddle.tensor.math.exp
:old_api: paddle.fluid.layers.exp
对输入，逐元素进行以自然数e为底指数运算。
.. math::
out = e^x
参数:
- **x** (Variable) - 该OP的输入为多维Tensor。数据类型为float32，float64。
- **name** (str, 可选) - 具体用法请参见 :ref:`api_guide_Name`，一般无需设置，默认值为None。
返回：输出为Tensor，与 ``x`` 维度相同、数据类型相同。
返回类型： Variable
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
input_exp = np.array([[-1.5,6],[1,15.6]])
with fluid.dygraph.guard():
x = fluid.dygraph.to_variable(input_exp)
y = fluid.layers.exp(x)
print(y.numpy())
# [[2.23130160e-01 4.03428793e+02]
# [2.71828183e+00 5.95653801e+06]]
doc/paddle/api/paddle/fluid/layers/flatten_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_flatten:
flatten
-------------------------------
.. py:function:: paddle.fluid.layers.flatten(x, axis=1, name=None)
:alias_main: paddle.flatten
:alias: paddle.flatten,paddle.tensor.flatten,paddle.tensor.manipulation.flatten
:old_api: paddle.fluid.layers.flatten
flatten op将输入的多维Tensor展平成2-D Tensor矩阵
例如：
.. code-block:: text
Case 1:
给定
X.shape = (3, 100, 100, 4)
且
axis = 2
得到:
Out.shape = (3 * 100, 4 * 100)
Case 2:
给定
X.shape = (3, 100, 100, 4)
且
axis = 0
得到:
Out.shape = (1, 3 * 100 * 100 * 4)
参数：
- **x** (Variable) - 一个维度数>=axis 的多维Tensor, 数据类型可以为float32，float64，int8，int32或int64。
- **axis** (int) - flatten展开的分割轴，[0, axis) 轴数据被flatten到输出矩阵的0轴，[axis, R)数据被flatten到输出矩阵的1轴，其中R是输入张量的总维度数。axis的值必须在[0,R]范围内。当 axis=0 时，若输入Tensor的维度为 :math:`[d_0, d_1，… d_n]` ，则输出张量的Tensor维度为 :math:`[1，d_0 * d_1 *… d_n]` ，默认值为1。
- **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
返回: 一个 2-D Tensor，它包含输入Tensor的数据，但维度发生变化。输入的[0, axis)维将沿axis展平到输出Tensor的0维度，剩余的输入维数展平到输出的1维度。数据类型与输入x相同。
返回类型: Variable
抛出异常：
- ValueError: 如果 x 不是一个Variable
- ValueError: 如果axis的范围不在 [0, rank(x)] 范围内
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name="x", shape=[4, 4, 3], append_batch_size=False, dtype="float32")
# x shape is [4, 4, 3]
out = fluid.layers.flatten(x=x, axis=2)
# out shape is [16, 3]
doc/paddle/api/paddle/fluid/layers/floor_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_floor:
floor
-------------------------------
.. py:function:: paddle.fluid.layers.floor(x, name=None)
:alias_main: paddle.floor
:alias: paddle.floor,paddle.tensor.floor,paddle.tensor.math.floor
:old_api: paddle.fluid.layers.floor
向下取整函数。
.. math::
out = \left \lfloor x \right \rfloor
参数：
- **x** - 该OP的输入为多维Tensor。数据类型必须为float32或float64。
- **name** (str，可选) - 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
返回：输出为Tensor，与 ``x`` 维度相同、数据类型相同。
返回类型：Variable
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data1 = fluid.layers.fill_constant(shape=[3, 2], value=2.5, dtype='float32') # [[2.5, 2.5], [2.5, 2.5], [2.5, 2.5]]
data2 = fluid.layers.fill_constant(shape=[2, 3], value=-2.5, dtype='float64') # [[-2.5, -2.5, -2.5], [-2.5, -2.5, -2.5]]
result1 = fluid.layers.floor(data1) # [[2., 2.], [2., 2.], [2., 2.]]
result2 = fluid.layers.floor(data2) # [[-3., -3., -3.], [-3., -3., -3.]]
doc/paddle/api/paddle/fluid/layers/hard_shrink_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_hard_shrink:
hard_shrink
-------------------------------
.. py:function:: paddle.fluid.layers.hard_shrink(x,threshold=None)
:alias_main: paddle.nn.functional.hard_shrink
:alias: paddle.nn.functional.hard_shrink,paddle.nn.functional.activation.hard_shrink
:old_api: paddle.fluid.layers.hard_shrink
HardShrink激活函数(HardShrink activation operator)
.. math::
out = \begin{cases}
x, \text{if } x > \lambda \\
x, \text{if } x < -\lambda \\
0, \text{otherwise}
\end{cases}
参数：
- **x** - HardShrink激活函数的输入
- **threshold** (FLOAT)-HardShrink激活函数的threshold值。[默认：0.5]
返回：HardShrink激活函数的输出
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name="input", shape=[784])
result = fluid.layers.hard_shrink(x=data, threshold=0.3)
doc/paddle/api/paddle/fluid/layers/increment_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_increment:
increment
-------------------------------
.. py:function:: paddle.fluid.layers.increment(x, value=1.0, in_place=True)
:alias_main: paddle.increment
:alias: paddle.increment,paddle.tensor.increment,paddle.tensor.math.increment
:old_api: paddle.fluid.layers.increment
使输入Tensor ``x`` 的数据累加 ``value`` , 该OP通常用于循环次数的计数。
参数:
- **x** (Variable) – 元素个数为1的Tensor，数据类型必须为float32，float64，int32，int64。
- **value** (float，可选) – 需要增加的值，默认为1.0。
- **in_place** (bool，可选) – 输出Tensor是否和输入Tensor ``x`` 复用同一块内存，默认为True。
返回：累加计算后的Tensor，形状、数据类型和 ``x`` 一致。
返回类型：Variable
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
counter = fluid.layers.zeros(shape=[1], dtype='float32') # [0.]
fluid.layers.increment(counter) # [1.]
doc/paddle/api/paddle/fluid/layers/log_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_log:
log
-------------------------------
.. py:function:: paddle.fluid.layers.log(x, name=None)
:alias_main: paddle.log
:alias: paddle.log,paddle.tensor.log,paddle.tensor.math.log
:old_api: paddle.fluid.layers.log
Log激活函数（计算自然对数）
.. math::
\\Out=ln(x)\\
参数:
- **x** (Variable) – 该OP的输入为LodTensor/Tensor。数据类型为float32，float64。
- **name** (str，可选) – 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None。
返回：Log算子自然对数输出
返回类型: Variable - 该OP的输出为LodTensor/Tensor，数据类型为输入一致。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
# Graph Organizing
x = fluid.layers.data(name="x", shape=[1], dtype="float32")
res = fluid.layers.log(x)
# Create an executor using CPU as an example
exe = fluid.Executor(fluid.CPUPlace())
exe.run(fluid.default_startup_program())
# Execute
x_i = np.array([[1], [2]]).astype(np.float32)
res_val, = exe.run(fluid.default_main_program(), feed={'x':x_i}, fetch_list=[res])
print(res_val) # [[0.], [0.6931472]]
doc/paddle/api/paddle/fluid/layers/margin_rank_loss_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_margin_rank_loss:
margin_rank_loss
-------------------------------
.. py:function:: paddle.fluid.layers.margin_rank_loss(label, left, right, margin=0.1, name=None)
:alias_main: paddle.nn.functional.margin_rank_loss
:alias: paddle.nn.functional.margin_rank_loss,paddle.nn.functional.loss.margin_rank_loss
:old_api: paddle.fluid.layers.margin_rank_loss
margin rank loss（间隔排序损失）层。在排序问题中，它可以比较来自排序网络的输入 ``left`` 和输入 ``right`` 的得分。
可用如下等式定义：
.. math::
rank\_loss = max(0, -label * (left - right) + margin)
参数:
- **label** (Variable) – 表示输入 ``left`` 的真实排序是否高于输入 ``right`` , 数据类型为 float32。
- **left** (Variable) – 输入 ``left`` 的排序得分， 数据类型为 float32 。
- **right** (Variable) – 输入 ``right`` 的排序得分， 数据类型为 float32。
- **margin** (float) – 指定的间隔。
- **name** (str，可选) – 具体用法请参见 :ref:`cn_api_guide_Name` ，一般无需设置，默认值为None。
返回： 排序损失
返回类型: Variable
抛出异常:
- ``ValueError`` - ``label`` , ``left`` , ``right`` 有一者不为Variable类型时，抛出此异常
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
label = fluid.layers.data(name="label", shape=[-1, 1], dtype="float32")
left = fluid.layers.data(name="left", shape=[-1, 1], dtype="float32")
right = fluid.layers.data(name="right", shape=[-1, 1], dtype="float32")
out = fluid.layers.margin_rank_loss(label, left, right)
doc/paddle/api/paddle/fluid/layers/mean_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_mean:
mean
-------------------------------
.. py:function:: paddle.fluid.layers.mean(x, name=None)
:alias_main: paddle.mean
:alias: paddle.mean,paddle.tensor.mean,paddle.tensor.stat.mean
:old_api: paddle.fluid.layers.mean
计算 ``x`` 所有元素的平均值。
参数：
- **x** (Variable) : Tensor 或 LoDTensor。均值运算的输入。
- **name** (basestring | None) : 输出变量的名称。
返回：
- Variable: 包含输出均值的 Tensor / LoDTensor。
返回类型：
- Variable（变量）。
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
import numpy
# Graph Organizing
input = fluid.layers.data(
name='data', shape=[2, 3], dtype='float32')
output = fluid.layers.mean(input)
# Create an executor using CPU as an example
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
# Execute
x_ndarray = numpy.ones([2, 3]).astype(numpy.float32)
res, = exe.run(fluid.default_main_program(),
feed={'data':x_ndarray},
fetch_list=[output])
print(res)
'''
Output Value:
[1.]
'''
doc/paddle/api/paddle/fluid/layers/sign_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
.. _cn_api_fluid_layers_sign:
sign
-------------------------------
.. py:function:: paddle.fluid.layers.sign(x)
:alias_main: paddle.sign
:alias: paddle.sign,paddle.tensor.sign,paddle.tensor.math.sign
:old_api: paddle.fluid.layers.sign
此OP对输入x中每个元素进行正负判断，并且输出正负判断值：1代表正，-1代表负，0代表零。
参数：
- **x** (Variable|numpy.ndarray) – 进行正负值判断的多维Tensor或者是多维的numpy数组，数据类型为 float32，float64。
返回：输出正负号Tensor，数据的shape大小和输入x的数据shape一致。
返回类型：Variable，数据类型和输入数据类型一致。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
data = fluid.layers.sign(np.array([3.0, 0.0, -2.0], dtype='float32'))
# data=[1.0, 0.0, -1.0]
doc/paddle/api/paddle/fluid/name_scope_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
此差异已折叠。
doc/paddle/api/paddle/fluid/save_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
此差异已折叠。
doc/paddle/api/paddle/framework/get_default_dtype_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
get
-------------------------------
**版本升级，文档正在开发中**
doc/paddle/api/paddle/framework/load_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
此差异已折叠。
doc/paddle/api/paddle/framework/save_cn.rst 已删除 100644 → 0
浏览文件 @ a219c253
此差异已折叠。
doc/paddle/api/paddle/framework/set_default_dtype_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
set
-------------------------------
**版本升级，文档正在开发中**
doc/paddle/api/paddle/load_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/nn/functional/mse_loss_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/nn/initializer/Normal_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/nn/initializer/Uniform_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/save_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/batch_norm_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/conv2d_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/conv2d_transpose_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/conv3d_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/conv3d_transpose_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/create_parameter_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/crf_decoding_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/data_norm_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/deformable_conv_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/embedding_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/fc_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/group_norm_cn.rst 0 → 100755
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/hsigmoid_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/instance_norm_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/layer_norm_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/multi_box_head_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/nce_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/prelu_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/row_conv_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/static/nn/spectral_norm_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/tensor/load_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/tensor/manipulation/expand_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/tensor/math/sum_cn.rst 100644 → 100755
浏览文件 @ 3eb99f7e
此差异已折叠。
doc/paddle/api/paddle/tensor/save_cn.rst 0 → 100644
浏览文件 @ 3eb99f7e
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或