Skip to content

F
FluidDoc

PaddlePaddle / FluidDoc

通知 10
Star 2
Fork 0
F
FluidDoc
提交 9a601dd2 编写于 作者: R RaindragonD 提交者： Cheerego
浏览文件
操作

update api_cn (#954) 

* update api_cn; fix the error of reverting layers_cn to 1.4; include previous changes

* update layers_cn; add code example to elementwise_mod

* delete recordio_writer_cn; revert index_cn

* update api_cn after review

* fix io_cn.rst

* update layers_cn

* update io_cn
上级 0009c8e3
显示空白变更内容
内联 并排
Showing with 7248 addition and 2976 deletion
doc/fluid/api_cn/backward_cn.rst
浏览文件 @ 9a601dd2
......@@ -35,57 +35,49 @@ append_backward
.. code-block:: python
# 网络配置
# ...
avg_loss = fluid.layers.mean(loss)
param_grad_list = fluid.backward.append_backward(loss=avg_loss)
# 损失计算
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)
loss = fluid.layers.square_error_cost(input=y_predict, label=y)
avg_loss = fluid.layers.mean(loss)
param_grad_list = fluid.backward.append_backward(loss=avg_loss)
.. _cn_api_fluid_backward_gradients:
gradients
-------------------------------
.. py:function:: paddle.fluid.backward.gradients(targets, inputs, target_gradients=None, no_grad_set=None)
将目标梯度反向传播到输入。
参数：
- **targets** (Variable|list[Variable]) – 目标变量
- **inputs** (Variable|list[Variable]) – 输入变量
- **target_gradients** (Variable|list[Variable]|None) – 目标的梯度变量，应与目标变量形状相同；如果设置为None，则以1初始化所有梯度变量
- **no_grad_sethread** (set[string]) – 在Block 0中不具有梯度的变量，所有block中被设置 ``stop_gradient=True`` 的变量将被自动加入该set
返回：数组，包含与输入对应的梯度。如果一个输入不影响目标函数，则对应的梯度变量为None
返回类型：(list[Variable])
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[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/fluid/api_cn/clip_cn.rst
浏览文件 @ 9a601dd2
......@@ -28,8 +28,23 @@ ErrorClipByValue
.. code-block:: python
var = fluid.framework.Variable(..., error_clip=ErrorClipByValue(max=5.0), ...)
import paddle.fluid as fluid
BATCH_SIZE = 128
CLIP_MAX = 2e-6
CLIP_MIN = -1e-6
prog = fluid.framework.Program()
with fluid.program_guard(main_program=prog):
image = fluid.layers.data(name='x', shape=[784], dtype='float32')
hidden1 = fluid.layers.fc(input=image, size=128, act='relu')
hidden2 = fluid.layers.fc(input=hidden1, size=64, act='relu')
predict = fluid.layers.fc(input=hidden2, size=10, act='softmax')
label = fluid.layers.data(name='y', shape=[1], dtype='int64')
cost = fluid.layers.cross_entropy(input=predict, label=label)
avg_cost = fluid.layers.mean(cost)
prog_clip = prog.clone()
prog_clip.block(0).var(hidden1.name)._set_error_clip(
fluid.clip.ErrorClipByValue(
max=CLIP_MAX, min=CLIP_MIN)
......@@ -70,6 +85,20 @@ GradientClipByGlobalNorm
.. code-block:: python
import paddle.fluid as fluid
prog = fluid.framework.Program()
startup_program = fluid.framework.Program()
with fluid.program_guard(
main_program=prog, startup_program=startup_program):
image = fluid.layers.data(name='x', shape=[784], dtype='float32')
label = fluid.layers.data(name='y', shape=[1], dtype='int64')
hidden1 = fluid.layers.fc(input=image, size=128, act='relu')
hidden2 = fluid.layers.fc(input=hidden1, size=64, act='relu')
predict = fluid.layers.fc(input=hidden2, size=10, act='softmax')
cost = fluid.layers.cross_entropy(input=predict, label=label)
avg_cost = fluid.layers.mean(cost)
prog_clip = prog.clone()
avg_cost_clip = prog_clip.block(0).var(avg_cost.name)
p_g_clip = fluid.backward.append_backward(loss=avg_cost_clip)
with fluid.program_guard(main_program=prog_clip):
......@@ -83,6 +112,7 @@ GradientClipByGlobalNorm
.. _cn_api_fluid_clip_GradientClipByNorm:
GradientClipByNorm
......@@ -108,12 +138,14 @@ GradientClipByNorm
.. code-block:: python
import paddle.fluid as fluid
w_param_attrs = fluid.ParamAttr(name=None,
initializer=fluid.initializer.UniformInitializer(low=-1.0, high=1.0, seed=0),
learning_rate=1.0,
regularizer=fluid.regularizer.L1Decay(1.0),
trainable=True,
clip=fluid.clip.GradientClipByNorm(clip_norm=2.0))
gradient_clip=fluid.clip.GradientClipByNorm(clip_norm=2.0))
x = fluid.layers.data(name='x', shape=[10], dtype='float32')
y_predict = fluid.layers.fc(input=x, size=1, param_attr=w_param_attrs)
......@@ -147,12 +179,14 @@ GradientClipByValue
.. code-block:: python
import paddle.fluid as fluid
w_param_attrs = fluid.ParamAttr(name=None,
initializer=fluid.initializer.UniformInitializer(low=-1.0, high=1.0, seed=0),
learning_rate=1.0,
regularizer=fluid.regualrizer.L1Decay(1.0),
trainable=True,
clip=fluid.clip.GradientClipByValue(-1.0, 1.0))
gradient_clip=fluid.clip.GradientClipByValue(-1.0, 1.0))
x = fluid.layers.data(name='x', shape=[10], dtype='float32')
y_predict = fluid.layers.fc(input=x, size=1, param_attr=w_param_attrs)
......
doc/fluid/api_cn/data/data_reader_cn.rst
浏览文件 @ 9a601dd2
......@@ -19,6 +19,7 @@ DataFeeder将reader返回的数据转换为可以输入Executor和ParallelExecut
.. code-block:: python
import paddle.fluid as fluid
place = fluid.CPUPlace()
img = fluid.layers.data(name='image', shape=[1, 28, 28])
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
......@@ -33,10 +34,16 @@ DataFeeder将reader返回的数据转换为可以输入Executor和ParallelExecut
.. code-block:: python
import paddle
import paddle.fluid as fluid
place=fluid.CUDAPlace(0)
data = fluid.layers.data(name='data', shape=[3, 224, 224], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
feeder = fluid.DataFeeder(place=place, feed_list=[data, label])
reader = feeder.decorate_reader(
paddle.batch(flowers.train(), batch_size=16))
paddle.batch(paddle.dataset.flowers.train(), batch_size=16), multi_devices=False)
参数：
......@@ -51,16 +58,32 @@ DataFeeder将reader返回的数据转换为可以输入Executor和ParallelExecut
.. code-block:: python
# ...
import numpy as np
import paddle
import paddle.fluid as fluid
place = fluid.CPUPlace()
feed_list = [
main_program.global_block().var(var_name) for var_name in feed_vars_name
] # feed_vars_name is a list of variables' name.
feeder = fluid.DataFeeder(feed_list, place)
def reader():
yield [np.random.random([4]).astype('float32'), np.random.random([3]).astype('float32')],
main_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(main_program, startup_program):
data_1 = fluid.layers.data(name='data_1', shape=[1, 2, 2])
data_2 = fluid.layers.data(name='data_2', shape=[1, 1, 3])
out = fluid.layers.fc(input=[data_1, data_2], size=2)
# ...
feeder = fluid.DataFeeder([data_1, data_2], place)
exe = fluid.Executor(place)
exe.run(startup_program)
for data in reader():
outs = exe.run(program=main_program,
feed=feeder.feed(data))
feed=feeder.feed(data),
fetch_list=[out])
.. py:method:: feed(iterable)
......@@ -74,6 +97,24 @@ DataFeeder将reader返回的数据转换为可以输入Executor和ParallelExecut
返回类型： dict
**代码示例**
.. code-block:: python
import numpy.random as random
import paddle.fluid as fluid
def reader(limit=5):
for i in range(limit):
yield random.random([784]).astype('float32'), random.random([1]).astype('int64'), random.random([256]).astype('float32')
data_1 = fluid.layers.data(name='data_1', shape=[1, 28, 28])
data_2 = fluid.layers.data(name='data_2', shape=[1], dtype='int64')
data_3 = fluid.layers.data(name='data_3', shape=[16, 16], dtype='float32')
feeder = fluid.DataFeeder(['data_1','data_2', 'data_3'], fluid.CPUPlace())
result = feeder.feed(reader())
.. py:method:: feed_parallel(iterable, num_places=None)
......@@ -94,6 +135,34 @@ DataFeeder将reader返回的数据转换为可以输入Executor和ParallelExecut
设备数量和mini-batches数量必须一致。
**代码示例**
.. code-block:: python
import numpy.random as random
import paddle.fluid as fluid
def reader(limit=10):
for i in range(limit):
yield [random.random([784]).astype('float32'), random.randint(10)],
x = fluid.layers.data(name='x', shape=[1, 28, 28])
y = fluid.layers.data(name='y', shape=[1], dtype='int64')
feeder = fluid.DataFeeder(['x','y'], fluid.CPUPlace())
place_num = 2
places = [fluid.CPUPlace() for x in range(place_num)]
data = []
exe = fluid.Executor(fluid.CPUPlace())
exe.run(fluid.default_startup_program())
program = fluid.CompiledProgram(fluid.default_main_program()).with_data_parallel(places=places)
for item in reader():
data.append(item)
if place_num == len(data):
exe.run(program=program, feed=list(feeder.feed_parallel(data, place_num)), fetch_list=[])
data = []
.. py:method:: decorate_reader(reader, multi_devices, num_places=None, drop_last=True)
将输入数据转换成reader返回的多个mini-batches。每个mini-batch分别送入各设备中。
......@@ -110,6 +179,31 @@ DataFeeder将reader返回的数据转换为可以输入Executor和ParallelExecut
抛出异常： ``ValueError`` – 如果drop_last为False并且数据batch和设备数目不匹配。
**代码示例**
.. code-block:: python
import numpy.random as random
import paddle
import paddle.fluid as fluid
def reader(limit=5):
for i in range(limit):
yield (random.random([784]).astype('float32'), random.random([1]).astype('int64')),
place=fluid.CUDAPlace(0)
data = fluid.layers.data(name='data', shape=[1, 28, 28], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
feeder = fluid.DataFeeder(place=place, feed_list=[data, label])
reader = feeder.decorate_reader(reader, multi_devices=False)
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
for data in reader():
exe.run(feed=data)
.. _cn_api_paddle_data_reader_reader:
......@@ -374,4 +468,4 @@ Creator包包含一些简单的reader creator，可以在用户Program中使用
路径：recordio文件的路径，可以是字符串或字符串列表。
返回： recordio文件的数据读取器
返回：recordio文件的数据读取器
doc/fluid/api_cn/data/dataset_cn.rst
浏览文件 @ 9a601dd2
......@@ -18,7 +18,7 @@ MNIST数据集。
MNIST训练数据集的creator。
它返回一个reader creator, reader中的每个样本的图像像素范围是[0，1]，标签范围是[0，9]。
它返回一个reader creator, reader中的每个样本的图像像素范围是[-1，1]，标签范围是[0，9]。
返回： 训练数据的reader creator
......@@ -30,7 +30,7 @@ MNIST训练数据集的creator。
MNIST测试数据集的creator。
它返回一个reader creator, reader中的每个样本的图像像素范围是[0，1]，标签范围是[0，9]。
它返回一个reader creator, reader中的每个样本的图像像素范围是[-1，1]，标签范围是[0，9]。
返回： 测试数据集的reader creator
......
doc/fluid/api_cn/data_feeder_cn.rst
浏览文件 @ 9a601dd2
......@@ -14,13 +14,14 @@ DataFeeder
``DataFeeder`` 负责将reader(读取器)返回的数据转成一种特殊的数据结构，使它们可以输入到 ``Executor`` 和 ``ParallelExecutor`` 中。
reader通常返回一个minibatch条目列表。在列表中每一条目都是一个样本（sample）,它是由具有一至多个特征的列表或元组组成的。
reader通常返回一个minibatch条目列表。在列表中每一条目都是一个样本（sample），它是由具有一至多个特征的列表或元组组成的。
以下是简单用法：
.. code-block:: python
import paddle.fluid as fluid
place = fluid.CPUPlace()
img = fluid.layers.data(name='image', shape=[1, 28, 28])
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
......@@ -31,10 +32,16 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
.. code-block:: python
import paddle
import paddle.fluid as fluid
place=fluid.CUDAPlace(0)
data = fluid.layers.data(name='data', shape=[3, 224, 224], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
feeder = fluid.DataFeeder(place=place, feed_list=[data, label])
reader = feeder.decorate_reader(
paddle.batch(flowers.train(), batch_size=16))
paddle.batch(paddle.dataset.flowers.train(), batch_size=16), multi_devices=False)
......@@ -51,15 +58,32 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
.. code-block:: python
# ...
import numpy as np
import paddle
import paddle.fluid as fluid
place = fluid.CPUPlace()
feed_list = [
main_program.global_block().var(var_name) for var_name in feed_vars_name
] # feed_vars_name 是一个由变量名组成的列表
feeder = fluid.DataFeeder(feed_list, place)
def reader():
yield [np.random.random([4]).astype('float32'), np.random.random([3]).astype('float32')],
main_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(main_program, startup_program):
data_1 = fluid.layers.data(name='data_1', shape=[1, 2, 2])
data_2 = fluid.layers.data(name='data_2', shape=[1, 1, 3])
out = fluid.layers.fc(input=[data_1, data_2], size=2)
# ...
feeder = fluid.DataFeeder([data_1, data_2], place)
exe = fluid.Executor(place)
exe.run(startup_program)
for data in reader():
outs = exe.run(program=main_program,
feed=feeder.feed(data))
feed=feeder.feed(data),
fetch_list=[out])
.. py:method:: feed(iterable)
......@@ -74,6 +98,24 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
返回类型: dict
**代码示例**
.. code-block:: python
import numpy.random as random
import paddle.fluid as fluid
def reader(limit=5):
for i in range(limit):
yield random.random([784]).astype('float32'), random.random([1]).astype('int64'), random.random([256]).astype('float32')
data_1 = fluid.layers.data(name='data_1', shape=[1, 28, 28])
data_2 = fluid.layers.data(name='data_2', shape=[1], dtype='int64')
data_3 = fluid.layers.data(name='data_3', shape=[16, 16], dtype='float32')
feeder = fluid.DataFeeder(['data_1','data_2', 'data_3'], fluid.CPUPlace())
result = feeder.feed(reader())
.. py:method:: feed_parallel(iterable, num_places=None)
......@@ -91,10 +133,36 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
.. note::
设备（CPU或GPU）的数目必须等于minibatch的数目
**代码示例**
.. code-block:: python
.. py:method:: decorate_reader(reader, multi_devices, num_places=None, drop_last=True)
import numpy.random as random
import paddle.fluid as fluid
def reader(limit=10):
for i in range(limit):
yield [random.random([784]).astype('float32'), random.randint(10)],
x = fluid.layers.data(name='x', shape=[1, 28, 28])
y = fluid.layers.data(name='y', shape=[1], dtype='int64')
feeder = fluid.DataFeeder(['x','y'], fluid.CPUPlace())
place_num = 2
places = [fluid.CPUPlace() for x in range(place_num)]
data = []
exe = fluid.Executor(fluid.CPUPlace())
exe.run(fluid.default_startup_program())
program = fluid.CompiledProgram(fluid.default_main_program()).with_data_parallel(places=places)
for item in reader():
data.append(item)
if place_num == len(data):
exe.run(program=program, feed=list(feeder.feed_parallel(data, place_num)), fetch_list=[])
data = []
.. py:method:: decorate_reader(reader, multi_devices, num_places=None, drop_last=True)
将reader返回的输入数据batch转换为多个mini-batch，之后每个mini-batch都会被输入进各个设备（CPU或GPU）中。
......@@ -111,9 +179,29 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
弹出异常： ValueError – 如果 ``drop_last`` 值为False并且reader返回的minibatch数目与设备数目不相等时，产生此异常
**代码示例**
.. code-block:: python
import numpy.random as random
import paddle
import paddle.fluid as fluid
def reader(limit=5):
for i in range(limit):
yield (random.random([784]).astype('float32'), random.random([1]).astype('int64')),
place=fluid.CUDAPlace(0)
data = fluid.layers.data(name='data', shape=[1, 28, 28], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
feeder = fluid.DataFeeder(place=place, feed_list=[data, label])
reader = feeder.decorate_reader(reader, multi_devices=False)
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
for data in reader():
exe.run(feed=data)
......
doc/fluid/api_cn/dataset_cn.rst
浏览文件 @ 9a601dd2
......@@ -14,28 +14,221 @@ DatasetFactory
.. py:class:: paddle.fluid.dataset.DatasetFactory
DatasetFactory是一个按数据集名称创建数据集的 "工厂" ，可以创建“QueueDataset”或“InMemoryDataset”，默认为“QueueDataset”。
DatasetFactory是一个按数据集名称创建数据集的 "工厂"，可以创建“QueueDataset”，“InMemoryDataset”或“FileInstantDataset”，默认为“QueueDataset”。
**代码示例**
.. code-block:: python
dataset = paddle.fluid.DatasetFactory.create_dataset(“InMemoryDataset”)
import paddle.fluid as fluid
dataset = paddle.fluid.DatasetFactory().create_dataset("InMemoryDataset")
.. py:method:: create_dataset(datafeed_class='QueueDataset')
创建“QueueDataset”或“InMemoryDataset”，默认为“QueueDataset”。
创建“QueueDataset”，“InMemoryDataset” 或 “FileInstantDataset”，默认为“QueueDataset”。
参数：
- **datafeed_class** (str) – datafeed类名，为QueueDataset或InMemoryDataset。默认为QueueDataset。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
.. _cn_api_fluid_dataset_InMemoryDataset:
InMemoryDataset
-------------------------------
.. py:class:: paddle.fluid.dataset.InMemoryDataset
InMemoryDataset会向内存中加载数据并在训练前缓冲数据。此类由DatasetFactory创建。
**代码示例**:
.. code-block:: python
dataset = paddle.fluid.DatasetFactory().create_dataset(“InMemoryDataset”)
.. py:method:: load_into_memory()
向内存中加载数据。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
filelist = ["a.txt", "b.txt"]
dataset.set_filelist(filelist)
dataset.load_into_memory()
.. py:method:: local_shuffle()
局域shuffle。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
filelist = ["a.txt", "b.txt"]
dataset.set_filelist(filelist)
dataset.load_into_memory()
dataset.local_shuffle()
.. py:method:: global_shuffle(fleet=None)
全局shuffle。
只能用在分布式模式（单机多进程或多机多进程）中。您如果在分布式模式中运行，应当传递fleet而非None。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet
dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
filelist = ["a.txt", "b.txt"]
dataset.set_filelist(filelist)
dataset.load_into_memory()
dataset.global_shuffle(fleet)
参数：
- **fleet** (Fleet) – fleet单例。默认为None。
.. py:method:: release_memory()
当数据不再使用时，释放InMemoryDataset内存数据。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet
dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
filelist = ["a.txt", "b.txt"]
dataset.set_filelist(filelist)
dataset.load_into_memory()
dataset.global_shuffle(fleet)
exe = fluid.Executor(fluid.CPUPlace())
exe.run(fluid.default_startup_program())
exe.train_from_dataset(fluid.default_main_program(), dataset)dataset.release_memory()
dataset.release_memory()
.. py:method:: get_memory_data_size(fleet=None)
用户可以调用此函数以了解加载进内存后所有workers中的ins数量。
.. note::
该函数可能会导致性能不佳，因为它具有barrier。
参数：
- **fleet** (Fleet) – fleet对象。
返回：内存数据的大小。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet
dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
filelist = ["a.txt", "b.txt"]
dataset.set_filelist(filelist)
dataset.load_into_memory()
print dataset.get_memory_data_size(fleet)
.. py:method:: get_shuffle_data_size(fleet=None)
获取shuffle数据大小，用户可以调用此函数以了解局域/全局shuffle后所有workers中的ins数量。
.. note::
该函数可能会导致局域shuffle性能不佳，因为它具有barrier。但其不影响局域shuffle。
参数：
- **fleet** (Fleet) – fleet对象。
返回：shuffle数据的大小。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet
dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
filelist = ["a.txt", "b.txt"]
dataset.set_filelist(filelist)
dataset.load_into_memory()
dataset.global_shuffle(fleet)
print dataset.get_shuffle_data_size(fleet)
.. _cn_api_fluid_dataset_QueueDataset:
QueueDataset
-------------------------------
.. py:class:: paddle.fluid.dataset.QueueDataset
流式处理数据。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset("QueueDataset")
.. py:method:: local_shuffle()
局域shuffle数据
QueueDataset中不支持局域shuffle，可能抛出NotImplementedError
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset("QueueDataset")
dataset.local_shuffle()
.. py:method:: global_shuffle(fleet=None)
全局shuffle数据
QueueDataset中不支持全局shuffle，可能抛出NotImplementedError
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
from paddle.fluid.incubate.fleet.parameter_server.pslib import fleet
dataset = fluid.DatasetFactory().create_dataset("QueueDataset")
dataset.global_shuffle(fleet)
doc/fluid/api_cn/executor_cn.rst
浏览文件 @ 9a601dd2
......@@ -15,9 +15,7 @@ Executor
执行引擎（Executor）使用python脚本驱动，仅支持在单GPU环境下运行。多卡环境下请参考 ``ParallelExecutor`` 。
执行引擎（Executor）使用python脚本驱动，支持在单/多GPU、单/多CPU环境下运行。
Python Executor可以接收传入的program,并根据feed map(输入映射表)和fetch_list(结果获取表)
向program中添加feed operators(数据输入算子)和fetch operators（结果获取算子)。
feed map为该program提供输入数据。fetch_list提供program训练结束后用户预期的变量（或识别类场景中的命名）。
......@@ -28,54 +26,77 @@ Executor将全局变量存储到全局作用域中，并为临时变量创建局
当每一mini-batch上的前向/反向运算完成后，局部作用域的内容将被废弃，
但全局作用域中的变量将在Executor的不同执行过程中一直存在。
program中所有的算子会按顺序执行。
**示例代码**
.. code-block:: python
# 新建一个执行引擎Executor名为exe。
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)
# 仅运行一次startup program.
# 不需要优化/编译这个startup program.
exe.run(fluid.default_startup_program())
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
loss, = exe.run(fluid.default_main_program(),
feed=feed_dict,
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
# 另一种方法是，编译这个main program然后运行。
# 参考CompiledProgram以获取更多信息。
# 注意：如果你使用CPU运行程序，需要具体设置CPU_NUM，
# 否则fluid会把逻辑核的所有数目设为CPU_NUM，
# 在这种情况下，输入的batch size应大于CPU_NUM，
# 否则程序会异常中断。
if not use_cuda:
os.environ['CPU_NUM'] = str(2)
compiled_prog = compiler.CompiledProgram(
fluid.default_main_program()).with_data_parallel(
train_program).with_data_parallel(
loss_name=loss.name)
loss, = exe.run(compiled_prog,
feed=feed_dict,
loss_data, = exe.run(compiled_prog,
feed={"X": x},
fetch_list=[loss.name])
参数:
- **place** (core.CPUPlace|core.CUDAPlace(n)) – 指明了 ``Executor`` 的执行场所
- **place** (fluid.CPUPlace|fluid.CUDAPlace(n)) – 指明了 ``Executor`` 的执行场所
提示：你可以用 ``Executor`` 来调试基于并行GPU实现的复杂网络，他们有完全一样的参数也会产生相同的结果。
.. py:method:: close()
关闭这个执行器(Executor)。调用这个方法后不可以再使用这个执行器。 对于分布式训练, 该函数会释放在PServers上涉及到目前训练器的资源。
关闭这个执行器(Executor)。
调用这个方法后不可以再使用这个执行器。 对于分布式训练, 该函数会释放在PServers上和目前Trainer有关联的资源。
**示例代码**
.. code-block:: python
cpu = core.CPUPlace()
exe = Executor(cpu)
...
import paddle.fluid as fluid
cpu = fluid.CPUPlace()
exe = fluid.Executor(cpu)
# 执行训练或测试过程
exe.close()
......@@ -89,54 +110,115 @@ feed map为该program提供输入数据。fetch_list提供program训练结束后
应注意，执行器会执行program中的所有算子而不仅仅是依赖于fetch_list的那部分。
**示例代码**
.. 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])
参数：
- **program** (Program|CompiledProgram) – 需要执行的program,如果没有给定那么默认使用default_main_program (未编译的)
- **feed** (dict) – 前向输入的变量，数据,词典dict类型, 例如 {“image”: ImageData, “label”: LabelData}
- **fetch_list** (list) – 用户想得到的变量或者命名的列表, run会根据这个列表给与结果
- **fetch_list** (list) – 用户想得到的变量或者命名的列表, 该方法会根据这个列表给出结果
- **feed_var_name** (str) – 前向算子(feed operator)变量的名称
- **fetch_var_name** (str) – 结果获取算子(fetch operator)的输出变量名称
- **scope** (Scope) – 执行这个program的域，用户可以指定不同的域。缺省为全局域
- **return_numpy** (bool) – 如果为True,则将结果张量（fetched tensor）转化为numpy
- **use_program_cache** (bool) – 当program较上次比没有改动则将其置为True
- **use_program_cache** (bool) – 是否跨批使用缓存程序设置。设置为True时，只有当（1）程序没有用数据并行编译，并且（2）program、 feed变量名和fetch_list变量名与上一步相比没有更改时，运行速度才会更快。
返回: 根据fetch_list来获取结果
返回类型: list(numpy.array)
**示例代码**
.. py:method:: infer_from_dataset(program=None, dataset=None, scope=None, thread=0, debug=False, fetch_list=None, fetch_info=None, print_period=100)
.. code-block:: python
infer_from_dataset的文档与train_from_dataset几乎完全相同，只是在分布式训练中，推进梯度将在infer_from_dataset中禁用。 infer_from_dataset（）可以非常容易地用于多线程中的评估。
data = fluid.layers.data(name='X', shape=[1], dtype='float32')
out = fluid.layers.create_tensor(dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
fluid.layers.assign(hidden,out)
loss = fluid.layers.mean(out)
adam = fluid.optimizer.Adam()
# adam.minimize(loss)
参数：
- **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
cpu = core.CPUPlace()
exe = fluid.Executor(cpu)
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)
.. code-block:: python
x = numpy.random.random(size=(10, 1)).astype('float32')
outs = exe.run(
feed={'X': x},
fetch_list=[loss.name])
.. 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.infer_from_dataset(program=fluid.default_main_program(),
dataset=dataset)
.. _cn_api_fluid_executor_global_scope:
......@@ -144,11 +226,21 @@ feed map为该program提供输入数据。fetch_list提供program训练结束后
global_scope
-------------------------------
.. py:function:: paddle.fluid.executor.global_scope ()
.. py:function:: paddle.fluid.global_scope()
获取全局/默认作用域实例。很多api使用默认 ``global_scope`` ，例如 ``Executor.run`` 。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy
fluid.global_scope().var("data").get_tensor().set(numpy.ones((2, 2)), fluid.CPUPlace())
numpy.array(fluid.global_scope().find_var("data").get_tensor())
返回：全局/默认作用域实例
返回类型：Scope
......@@ -175,12 +267,12 @@ scope_guard
.. code-block:: python
import paddle.fluid as fluid
import numpy
new_scope = fluid.Scope()
with fluid.scope_guard(new_scope):
...
fluid.global_scope().var("data").get_tensor().set(numpy.ones((2, 2)), fluid.CPUPlace())
numpy.array(new_scope.find_var("data").get_tensor())
......
doc/fluid/api_cn/fluid_cn.rst
浏览文件 @ 9a601dd2
......@@ -15,57 +15,123 @@ BuildStrategy
.. code-block:: python
import paddle.fluid as fluid
build_strategy = fluid.BuildStrategy()
build_strategy.reduce_strategy = fluid.BuildStrategy.ReduceStrategy.Reduce
train_exe = fluid.ParallelExecutor(use_cuda=True,
loss_name=loss.name,
build_strategy=build_strategy)
train_loss, = train_exe.run([loss.name], feed=feed_dict)
.. py:attribute:: debug_graphviz_path
str类型。它表明了以graphviz格式向文件中写入SSA图的路径，有利于调试。 默认值为""。
**代码示例**
.. py:attribute:: debug_graphviz_path
.. code-block:: python
import paddle.fluid as fluid
build_strategy = fluid.BuildStrategy()
build_strategy.debug_graphviz_path = ""
str类型。它表明了以graphviz格式向文件中写入SSA图的路径，有利于调试。 默认值为""。
.. py:attribute:: enable_sequential_execution
类型是BOOL。 如果设置为True，则ops的执行顺序将与program中的执行顺序相同。 默认为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模式中，融合broadcast ops可以使程序运行更快，因为这个过程等同于延迟执行所有的broadcast ops。在这种情况下，所有的nccl streams仅用于一段时间内的NCCLReduce操作。默认为False。
.. 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_conv指示是否融合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
str类型。在 ``ParallelExecutor`` 中，存在三种定义 *loss@grad* 的方式，分别为 ``CoeffNumDevice``, ``One`` 与 ``Customized``。默认情况下， ``ParallelExecutor`` 根据设备数目来设置 *loss@grad* 。如果你想自定义 *loss@grad* ，你可以选择 ``Customized`` 方法。默认为 ``CoeffNumDevice`` 。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
build_strategy = fluid.BuildStrategy()
build_strategy.gradient_scale_strategy = True
.. py:attribute:: memory_optimize
bool类型。设为True时可用于减少总内存消耗。为实验性属性，一些变量可能会被优化策略重用/移除。如果你需要在使用该特征时获取某些变量，请把变量的persistable property设为True。默认为False。
.. py:attribute:: reduce_strategy
str类型。在 ``ParallelExecutor`` 中，存在两种减少策略（reduce strategy），即 ``AllReduce`` 和 ``Reduce`` 。如果你需要在所有执行场所上独立地进行参数优化，可以使用 ``AllReduce`` 。反之，如果使用 ``Reduce`` 策略，所有参数的优化将均匀地分配给不同的执行场所，随之将优化后的参数广播给其他执行场所。在一些模型中， ``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，sync_batch_norm表示是否使用同步的批正则化，即在训练阶段通过多个设备同步均值和方差。
当前的实现不支持FP16训练和CPU。仅在一台机器上进行同步式批正则，不适用于多台机器。
当前的实现不支持FP16培训和CPU。仅在一台机器上进行同步式批正则，不适用于多台机器。
默认为 False。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
build_strategy = fluid.BuildStrategy()
build_strategy.sync_batch_norm = True
.. _cn_api_fluid_CompiledProgram:
......@@ -84,22 +150,34 @@ CompiledProgram用于转换程序以进行各种优化。例如，
- 预先计算一些逻辑，以便每次运行更快。
- 转换Program，使其可以在多个设备中运行。
- 转换Program以进行优化预测或分布式训练。
- 转换Program以进行优化预测或分布式训练。注意：此部分尚未完成。
**代码示例**
.. code-block:: python
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
import paddle.fluid as fluid
import paddle.fluid.compiler as compiler
import numpy
import os
place = fluid.CUDAPlace(0) # fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(startup)
compiled_prog = compiler.CompiledProgram(main).with_data_parallel(
loss_name=loss.name)
for i in range(5):
test_loss, = exe.run(compiled_prog,
feed=feed_dict,
fetch_list=[loss.name])
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())
compiled_prog = compiler.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])
参数：
- **program_or_graph** (Graph|Program): 如果它是Program，那么它将首先被降成一个graph，以便进一步优化。如果它是一个graph（以前可能优化过），它将直接用于进一步的优化。注意：只有使用 with_data_parallel 选项编译时才支持graph。
......@@ -107,6 +185,42 @@ CompiledProgram用于转换程序以进行各种优化。例如，
配置Program使其以数据并行方式运行。
**代码示例**
.. 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()
#注意：如果你使用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.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())
compiled_prog = compiler.CompiledProgram(
fluid.default_main_program()).with_data_parallel(
loss_name=loss.name)
x = numpy.random.random(size=(10, 1)).astype('float32')
loss_data, = exe.run(compiled_prog,
feed={"X": x},
fetch_list=[loss.name])
参数：
- **loss_name** （str） - 损失函数名称必须在训练过程中设置。 默认None。
- **build_strategy** （BuildStrategy） - build_strategy用于构建图，因此它可以在具有优化拓扑的多个设备/核上运行。 有关更多信息，请参阅 ``fluid.BuildStrategy`` 。 默认None。
......@@ -144,6 +258,11 @@ cpu_places
返回类型：out (list(fluid.CPUPlace))
**代码示例**
.. code-block:: python
cpu_places = fluid.cpu_places()
.. _cn_api_fluid_CPUPlace:
......@@ -156,9 +275,11 @@ CPUPlace
CPUPlace是设备的描述符。它代表一个CPU，可以访问CPUPlace对应的内存。
**代码示例**
.. code-block:: python
cpu_place = fluid.CPUPlace()
.. _cn_api_fluid_create_lod_tensor:
......@@ -183,8 +304,16 @@ create_lod_tensor
4. 利用offset-based LoD来设置LoD
例如：
假如我们想用LoD Tensor来承载一词序列的数据，其中每个词由一个整数来表示。现在，我们意图创建一个LoD Tensor来代表两个句子，其中一个句子有两个词，另外一个句子有三个。
那么数 ``data`` 可以是一个numpy数组，形状为（5,1）。同时， ``recursive_seq_lens`` 为 [[2, 3]]，表明各个句子的长度。这个长度为基准的 ``recursive_seq_lens`` 将在函数中会被转化为以偏移量为基准的 LoD [[0, 2, 5]]。
假如我们想用LoD Tensor来承载一词序列的数据，其中每个词由一个整数来表示。现在，我们意图创建一个LoD Tensor来代表两个句子，其中一个句子有两个词，另外一个句子有三个。那么数 ``data`` 可以是一个numpy数组，形状为（5,1）。同时， ``recursive_seq_lens`` 为 [[2, 3]]，表明各个句子的长度。这个长度为基准的 ``recursive_seq_lens`` 将在函数中会被转化为以偏移量为基准的 LoD [[0, 2, 5]]。
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
t = fluid.create_lod_tensor(np.ndarray([5, 30]), [[2, 3]], fluid.CPUPlace())
参考 :ref:`api_guide_tensor` 以获取更多关于LoD的信息。
参数:
- **data** (numpy.ndarray|list|LoDTensor) – 容纳着待复制数据的一个numpy数组、列表或LoD Tensor
......@@ -233,9 +362,15 @@ create_random_int_lodtensor
- **low** (int) – 随机数下限
- **high** (int) – 随机数上限
返回: 一个fluid LoDTensor对象，包含数据和 ``recursive_seq_lens`` 信息
返回: 一个fluid LoDTensor对象，包含张量数据和 ``recursive_seq_lens`` 信息
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
t = fluid.create_random_int_lodtensor(recursive_seq_lens=[[2, 3]],base_shape=[30], place=fluid.CPUPlace(), low=0, high=10)
.. _cn_api_fluid_cuda_pinned_places:
......@@ -258,7 +393,13 @@ cuda_pinned_places
返回类型：out(list(fluid.CUDAPinnedPlace))
**代码示例**
.. code-block:: python
cuda_pinned_places_cpu_num = fluid.cuda_pinned_places()
# 或者
cuda_pinned_places = fluid.cuda_pinned_places(1)
.. _cn_api_fluid_cuda_places:
......@@ -283,9 +424,11 @@ cuda_places
返回类型：out (list(fluid.CUDAPlace))
**代码示例**
.. code-block:: python
cuda_places = fluid.cuda_places()
.. _cn_api_fluid_CUDAPinnedPlace:
......@@ -296,8 +439,11 @@ CUDAPinnedPlace
CUDAPinnedPlace是一个设备描述符，它所指代的存储空间可以被GPU和CPU访问。
**代码示例**
.. code-block:: python
place = fluid.CUDAPinnedPlace()
.. _cn_api_fluid_CUDAPlace:
......@@ -308,9 +454,11 @@ CUDAPlace
CUDAPlace是一个设备描述符，它代表一个GPU，并且每个CUDAPlace有一个dev_id（设备id）来表明当前CUDAPlace代表的卡数。dev_id不同的CUDAPlace所对应的内存不可相互访问。
**代码示例**
.. code-block:: python
gpu_place = fluid.CUDAPlace(0)
......@@ -326,34 +474,33 @@ DataFeedDesc
这个类目前只用于AsyncExecutor(有关类AsyncExecutor的简要介绍，请参阅注释)
DataFeedDesc应由来自磁盘的有效protobuf消息初始化:
.. code-block:: python
data_feed = fluid.DataFeedDesc('data.proto')
DataFeedDesc应由来自磁盘的有效protobuf消息初始化。
可以参考 :code:`paddle/fluid/framework/data_feed.proto` 查看我们如何定义message
一段典型的message可能是这样的：
.. code-block:: text
name: "MultiSlotDataFeed"
batch_size: 2
multi_slot_desc {
slots {
name: "words"
type: "uint64"
is_dense: false
is_used: true
}
slots {
name: "label"
type: "uint64"
is_dense: false
is_used: true
}
}
.. code-block:: python
f = open("data.proto", "w")
print >> f, 'name: "MultiSlotDataFeed"'
print >> f, 'batch_size: 2'
print >> f, 'multi_slot_desc {'
print >> f, ' slots {'
print >> f, ' name: "words"'
print >> f, ' type: "uint64"'
print >> f, ' is_dense: false'
print >> f, ' is_used: true'
print >> f, ' }'
print >> f, ' slots {'
print >> f, ' name: "label"'
print >> f, ' type: "uint64"'
print >> f, ' is_dense: false'
print >> f, ' is_used: true'
print >> f, ' }'
print >> f, '}'
f.close()
data_feed = fluid.DataFeedDesc('data.proto')
但是，用户通常不应该关心消息格式;相反，我们鼓励他们在将原始日志文件转换为AsyncExecutor可以接受的训练文件的过程中，使用 :code:`Data Generator` 生成有效数据描述。
......@@ -361,11 +508,12 @@ DataFeedDesc也可以在运行时更改。一旦你熟悉了每个字段的含
.. code-block:: python
data_feed = fluid.DataFeedDesc('data.proto')
data_feed.set_batch_size(128)
data_feed.set_dense_slots('wd') # The slot named 'wd' will be dense
data_feed.set_use_slots('wd') # The slot named 'wd' will be used
data_feed.set_dense_slots('wd') # 名为'wd'的slot将被设置为密集的
data_feed.set_use_slots('wd') # 名为'wd'的slot将被用于训练
#Finally, the content can be dumped out for debugging purpose:
# 最后，可以打印变量详细信息便于排出错误
print(data_feed.desc())
......@@ -386,6 +534,24 @@ DataFeedDesc也可以在运行时更改。一旦你熟悉了每个字段的含
.. code-block:: python
f = open("data.proto", "w")
print >> f, 'name: "MultiSlotDataFeed"'
print >> f, 'batch_size: 2'
print >> f, 'multi_slot_desc {'
print >> f, ' slots {'
print >> f, ' name: "words"'
print >> f, ' type: "uint64"'
print >> f, ' is_dense: false'
print >> f, ' is_used: true'
print >> f, ' }'
print >> f, ' slots {'
print >> f, ' name: "label"'
print >> f, ' type: "uint64"'
print >> f, ' is_dense: false'
print >> f, ' is_used: true'
print >> f, ' }'
print >> f, '}'
f.close()
data_feed = fluid.DataFeedDesc('data.proto')
data_feed.set_batch_size(128)
......@@ -403,6 +569,24 @@ DataFeedDesc也可以在运行时更改。一旦你熟悉了每个字段的含
.. code-block:: python
f = open("data.proto", "w")
print >> f, 'name: "MultiSlotDataFeed"'
print >> f, 'batch_size: 2'
print >> f, 'multi_slot_desc {'
print >> f, ' slots {'
print >> f, ' name: "words"'
print >> f, ' type: "uint64"'
print >> f, ' is_dense: false'
print >> f, ' is_used: true'
print >> f, ' }'
print >> f, ' slots {'
print >> f, ' name: "label"'
print >> f, ' type: "uint64"'
print >> f, ' is_dense: false'
print >> f, ' is_used: true'
print >> f, ' }'
print >> f, '}'
f.close()
data_feed = fluid.DataFeedDesc('data.proto')
data_feed.set_dense_slots(['words'])
......@@ -422,6 +606,24 @@ DataFeedDesc也可以在运行时更改。一旦你熟悉了每个字段的含
.. code-block:: python
f = open("data.proto", "w")
print >> f, 'name: "MultiSlotDataFeed"'
print >> f, 'batch_size: 2'
print >> f, 'multi_slot_desc {'
print >> f, ' slots {'
print >> f, ' name: "words"'
print >> f, ' type: "uint64"'
print >> f, ' is_dense: false'
print >> f, ' is_used: true'
print >> f, ' }'
print >> f, ' slots {'
print >> f, ' name: "label"'
print >> f, ' type: "uint64"'
print >> f, ' is_dense: false'
print >> f, ' is_used: true'
print >> f, ' }'
print >> f, '}'
f.close()
data_feed = fluid.DataFeedDesc('data.proto')
data_feed.set_use_slots(['words'])
......@@ -440,6 +642,24 @@ DataFeedDesc也可以在运行时更改。一旦你熟悉了每个字段的含
.. code-block:: python
f = open("data.proto", "w")
print >> f, 'name: "MultiSlotDataFeed"'
print >> f, 'batch_size: 2'
print >> f, 'multi_slot_desc {'
print >> f, ' slots {'
print >> f, ' name: "words"'
print >> f, ' type: "uint64"'
print >> f, ' is_dense: false'
print >> f, ' is_used: true'
print >> f, ' }'
print >> f, ' slots {'
print >> f, ' name: "label"'
print >> f, ' type: "uint64"'
print >> f, ' is_dense: false'
print >> f, ' is_used: true'
print >> f, ' }'
print >> f, '}'
f.close()
data_feed = fluid.DataFeedDesc('data.proto')
print(data_feed.desc())
......@@ -465,6 +685,7 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
.. code-block:: python
import paddle.fluid as fluid
place = fluid.CPUPlace()
img = fluid.layers.data(name='image', shape=[1, 28, 28])
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
......@@ -475,10 +696,16 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
.. code-block:: python
import paddle
import paddle.fluid as fluid
place=fluid.CUDAPlace(0)
data = fluid.layers.data(name='data', shape=[3, 224, 224], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
feeder = fluid.DataFeeder(place=place, feed_list=[data, label])
reader = feeder.decorate_reader(
paddle.batch(flowers.train(), batch_size=16))
paddle.batch(paddle.dataset.flowers.train(), batch_size=16), multi_devices=False)
......@@ -496,15 +723,32 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
.. code-block:: python
# ...
import numpy as np
import paddle
import paddle.fluid as fluid
place = fluid.CPUPlace()
feed_list = [
main_program.global_block().var(var_name) for var_name in feed_vars_name
] # feed_vars_name 是一个由变量名组成的列表
feeder = fluid.DataFeeder(feed_list, place)
def reader():
yield [np.random.random([4]).astype('float32'), np.random.random([3]).astype('float32')],
main_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(main_program, startup_program):
data_1 = fluid.layers.data(name='data_1', shape=[1, 2, 2])
data_2 = fluid.layers.data(name='data_2', shape=[1, 1, 3])
out = fluid.layers.fc(input=[data_1, data_2], size=2)
# ...
feeder = fluid.DataFeeder([data_1, data_2], place)
exe = fluid.Executor(place)
exe.run(startup_program)
for data in reader():
outs = exe.run(program=main_program,
feed=feeder.feed(data))
feed=feeder.feed(data),
fetch_list=[out]))
.. py:method:: feed(iterable)
......@@ -519,6 +763,24 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
返回类型: dict
**代码示例**
.. code-block:: python
import numpy.random as random
import paddle.fluid as fluid
def reader(limit=5):
for i in range(limit):
yield random.random([784]).astype('float32'), random.random([1]).astype('int64'), random.random([256]).astype('float32')
data_1 = fluid.layers.data(name='data_1', shape=[1, 28, 28])
data_2 = fluid.layers.data(name='data_2', shape=[1], dtype='int64')
data_3 = fluid.layers.data(name='data_3', shape=[16, 16], dtype='float32')
feeder = fluid.DataFeeder(['data_1','data_2', 'data_3'], fluid.CPUPlace())
result = feeder.feed(reader())
.. py:method:: feed_parallel(iterable, num_places=None)
......@@ -536,7 +798,32 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
.. note::
设备（CPU或GPU）的数目必须等于minibatch的数目
**代码示例**
.. code-block:: python
import numpy.random as random
import paddle.fluid as fluid
def reader(limit=10):
for i in range(limit):
yield [random.random([784]).astype('float32'), random.randint(10)],
x = fluid.layers.data(name='x', shape=[1, 28, 28])
y = fluid.layers.data(name='y', shape=[1], dtype='int64')
feeder = fluid.DataFeeder(['x','y'], fluid.CPUPlace())
place_num = 2
places = [fluid.CPUPlace() for x in range(place_num)]
data = []
exe = fluid.Executor(fluid.CPUPlace())
exe.run(fluid.default_startup_program())
program = fluid.CompiledProgram(fluid.default_main_program()).with_data_parallel(places=places)
for item in reader():
data.append(item)
if place_num == len(data):
exe.run(program=program, feed=list(feeder.feed_parallel(data, place_num)), fetch_list=[])
data = []
.. py:method:: decorate_reader(reader, multi_devices, num_places=None, drop_last=True)
......@@ -556,11 +843,29 @@ reader通常返回一个minibatch条目列表。在列表中每一条目都是
抛出异常： ``ValueError`` – 如果 ``drop_last`` 值为False并且data batch与设备不匹配时，产生此异常
**代码示例**
.. code-block:: python
import numpy.random as random
import paddle
import paddle.fluid as fluid
def reader(limit=5):
for i in range(limit):
yield (random.random([784]).astype('float32'), random.random([1]).astype('int64')),
place=fluid.CUDAPlace(0)
data = fluid.layers.data(name='data', shape=[1, 28, 28], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
feeder = fluid.DataFeeder(place=place, feed_list=[data, label])
reader = feeder.decorate_reader(reader, multi_devices=False)
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
for data in reader():
exe.run(feed=data)
......@@ -590,9 +895,35 @@ default_main_program
返回类型: Program
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# Sample Network:
data = fluid.layers.data(name='image', shape=[3, 224, 224], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
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())
......@@ -624,13 +955,21 @@ startup_program会使用内在的operators（算子）去初始化他们，并
返回类型: 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()))
......@@ -654,33 +993,43 @@ DistributeTranspiler
.. code-block:: python
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)
#pserver模式下
pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
current_endpoint = "192.168.0.1:6174"
trainer_id = 0
trainers = 4
role = os.getenv("PADDLE_TRAINING_ROLE")
role = "PSERVER"
t = fluid.DistributeTranspiler()
t.transpile(
trainer_id, pservers=pserver_endpoints, trainers=trainers)
t.transpile(trainer_id, pservers=pserver_endpoints, trainers=trainers)
if role == "PSERVER":
pserver_program = t.get_pserver_program(current_endpoint)
pserver_startup_program = t.get_startup_program(current_endpoint,
pserver_program)
pserver_startup_program = t.get_startup_program(current_endpoint, pserver_program)
elif role == "TRAINER":
trainer_program = t.get_trainer_program()
# nccl2模式下
trainer_num = 2
trainer_id = 0
config = fluid.DistributeTranspilerConfig()
config.mode = "nccl2"
trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
t = fluid.DistributeTranspiler(config=config)
t.transpile(trainer_id, workers=workers, current_endpoint=curr_ep)
t.transpile(trainer_id=trainer_id, trainers=trainer_endpoints, current_endpoint="192.168.0.1:6174")
exe = fluid.ParallelExecutor(
use_cuda,
loss_name=loss_var.name,
num_trainers=len(trainers.split(",)),
loss_name=avg_loss.name,
num_trainers=len(trainer_num,
trainer_id=trainer_id
)
......@@ -688,7 +1037,7 @@ DistributeTranspiler
.. py:method:: transpile(trainer_id, program=None, pservers='127.0.0.1:6174', trainers=1, sync_mode=True, startup_program=None, current_endpoint='127.0.0.1:6174')
该方法可以运行该transpiler（转译器）。
该方法可以运行该transpiler（转译器）。转译输入程序。
参数:
- **trainer_id** (int) – 当前Trainer worker的id, 如果有n个Trainer worker, id 取值范围为0 ~ n-1
......@@ -700,6 +1049,20 @@ DistributeTranspiler
- **startup_program** (Program|None) – 待transpile（转译）的startup_program，默认为 ``fluid.default_main_program()``
- **current_endpoint** (str) – 当需要把program转译（transpile）至NCCL2模式下时，需要将当前endpoint（终端）传入该参数。Pserver模式不使用该参数
**代码示例**
.. code-block:: python
transpiler = fluid.DistributeTranspiler()
t.transpile(
trainer_id=0,
pservers="127.0.0.1:7000,127.0.0.1:7001",
trainers=2,
sync_mode=False,
current_endpoint="127.0.0.1:7000")
.. py:method:: get_trainer_program(wait_port=True)
......@@ -709,6 +1072,18 @@ DistributeTranspiler
返回类型: Program
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
#this is an example, find available endpoints in your case
pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
trainer_id = 0
trainers = 4
t = fluid.DistributeTranspiler()
t.transpile(trainer_id, trainers=trainers, pservers=pserver_endpoints)
trainer_program = t.get_trainer_program()
.. py:method:: get_pserver_program(endpoint)
......@@ -723,6 +1098,21 @@ DistributeTranspiler
返回类型: Program
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
#this is an example, find available endpoints in your case
pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
current_endpoint = "192.168.0.1:6174"
trainer_id = 0
trainers = 4
t = fluid.DistributeTranspiler()
t.transpile(
trainer_id, pservers=pserver_endpoints, trainers=trainers)
pserver_program = t.get_pserver_program(current_endpoint)
.. py:method:: get_pserver_programs(endpoint)
......@@ -736,6 +1126,22 @@ DistributeTranspiler
返回类型: tuple
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
#this is an example, find available endpoints in your case
pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
current_endpoint = "192.168.0.1:6174"
trainer_id = 0
trainers = 4
t = fluid.DistributeTranspiler()
t.transpile(
trainer_id, pservers=pserver_endpoints, trainers=trainers)
pserver_program, pserver_startup_program = t.get_pserver_programs(current_endpoint)
.. py:method:: get_startup_program(endpoint, pserver_program=None, startup_program=None)
......@@ -752,10 +1158,23 @@ DistributeTranspiler
返回类型: Program
**代码示例**
.. code-block:: python
pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
current_endpoint = "192.168.0.1:6174"
trainer_id = 0
trainers = 4
t = fluid.DistributeTranspiler()
t.transpile(trainer_id, pservers=pserver_endpoints, trainers=trainers)
pserver_program = t.get_pserver_program(current_endpoint)
pserver_startup_program = t.get_startup_program(current_endpoint,
pserver_program)
......@@ -784,8 +1203,12 @@ block中分割(split)出的元素个数的最小值。
注意: 根据：`issuecomment-369912156 <https://github.com/PaddlePaddle/Paddle/issues/8638#issuecomment-369912156>`_ , 当数据块大小超过2MB时，我们可以有效地使用带宽。如果你想更改它，请详细查看 ``slice_variable`` 函数。
**代码示例**
.. code-block:: python
config = fluid.DistributeTranspilerConfig()
config.slice_var_up = True
......@@ -803,15 +1226,23 @@ ExecutionStrategy
.. code-block:: python
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=True,
loss_name=loss.name,
train_exe = fluid.ParallelExecutor(use_cuda=False,
loss_name=avg_loss.name,
exec_strategy=exec_strategy)
train_loss, = train_exe.run([loss.name], feed=feed_dict)
.. py:attribute:: allow_op_delay
......@@ -822,14 +1253,15 @@ ExecutionStrategy
.. py:attribute:: num_iteration_per_drop_scope
int型成员。它表明了清空执行时产生的临时变量需要的程序执行重复次数。因为临时变量的形状可能在两次重复过程中保持一致，所以它会使整体执行过程更快。默认值为100。
int型成员。它表明了清空执行时产生的临时变量需要的程序执行迭代次数。因为临时变量的形状可能在两次重复过程中保持一致，所以它会使整体执行过程更快。默认值为1。
.. note::
1. 如果在调用 ``run`` 方法时获取结果数据，``ParallelExecutor`` 会在当前程序重复执行尾部清空临时变量
2. 在一些NLP模型里，该成员会致使GPU内存不足。此时，你应减少 ``num_iteration_per_drop_scope`` 的值
.. py:attribute:: num_iteration_per_run
它配置了当用户在python脚本中调用pe.run()时执行器会执行的迭代次数。
.. py:attribute:: num_threads
......@@ -873,30 +1305,53 @@ Executor将全局变量存储到全局作用域中，并为临时变量创建局
.. code-block:: python
# 新建一个执行引擎Executor名为exe。
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)
# 仅运行一次startup program.
# 不需要优化/编译这个startup program.
exe.run(fluid.default_startup_program())
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
loss, = exe.run(fluid.default_main_program(),
feed=feed_dict,
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
# 另一种方法是，编译这个main program然后运行。
# 参考CompiledProgram以获取更多信息。
# 注意：如果你使用CPU运行程序，需要具体设置CPU_NUM，
# 否则fluid会把逻辑核的所有数目设为CPU_NUM，
# 在这种情况下，输入的batch size应大于CPU_NUM，
# 否则程序会异常中断。
if not use_cuda:
os.environ['CPU_NUM'] = str(2)
compiled_prog = compiler.CompiledProgram(
fluid.default_main_program()).with_data_parallel(
train_program).with_data_parallel(
loss_name=loss.name)
loss, = exe.run(compiled_prog,
feed=feed_dict,
loss_data, = exe.run(compiled_prog,
feed={"X": x},
fetch_list=[loss.name])
参数:
- **place** (core.CPUPlace|core.CUDAPlace(n)) – 指明了 ``Executor`` 的执行场所
- **place** (fluid.CPUPlace|fluid.CUDAPlace(n)) – 指明了 ``Executor`` 的执行场所
......@@ -911,9 +1366,11 @@ Executor将全局变量存储到全局作用域中，并为临时变量创建局
.. code-block:: python
cpu = core.CPUPlace()
exe = Executor(cpu)
...
import paddle.fluid as fluid
cpu = fluid.CPUPlace()
exe = fluid.Executor(cpu)
# 执行训练或测试过程
exe.close()
......@@ -927,6 +1384,30 @@ feed map为该program提供输入数据。fetch_list提供program训练结束后
应注意，执行器会执行program中的所有算子而不仅仅是依赖于fetch_list的那部分。
**示例代码**
.. 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])
参数：
- **program** (Program|CompiledProgram) – 需要执行的program,如果没有给定那么默认使用default_main_program (未编译的)
- **feed** (dict) – 前向输入的变量，数据,词典dict类型, 例如 {“image”: ImageData, “label”: LabelData}
......@@ -942,43 +1423,76 @@ feed map为该program提供输入数据。fetch_list提供program训练结束后
返回类型: list(numpy.array)
**示例代码**
.. code-block:: python
data = fluid.layers.data(name='X', shape=[1], dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
layers.assign(hidden, out)
loss = fluid.layers.mean(out)
adam = fluid.optimizer.Adam()
adam.minimize(loss)
.. 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（）可以非常容易地用于多线程中的评估。
.. code-block:: python
参数：
- **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
cpu = core.CPUPlace()
exe = Executor(cpu)
exe.run(default_startup_program())
**示例代码**
.. code-block:: python
x = numpy.random.random(size=(10, 1)).astype('float32')
outs = exe.run(
feed={'X': x},
fetch_list=[loss.name])
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.infer_from_dataset(program=fluid.default_main_program(),
dataset=dataset)
.. _cn_api_fluid_global_scope:
......@@ -991,6 +1505,16 @@ global_scope
获取全局/默认作用域实例。很多api使用默认 ``global_scope`` ，例如 ``Executor.run`` 。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy
fluid.global_scope().var("data").get_tensor().set(numpy.ones((2, 2)), fluid.CPUPlace())
numpy.array(fluid.global_scope().find_var("data").get_tensor())
返回：全局/默认作用域实例
返回类型：Scope
......@@ -999,6 +1523,44 @@ global_scope
.. _cn_api_fluid_gradients:
gradients
-------------------------------
.. py:function:: paddle.fluid.gradients(targets, inputs, target_gradients=None, no_grad_set=None)
将目标梯度反向传播到输入。
参数：
- **targets** (Variable|list[Variable]) – 目标变量
- **inputs** (Variable|list[Variable]) – 输入变量
- **target_gradients** (Variable|list[Variable]|None) – 目标的梯度变量，应与目标变量形状相同；如果设置为None，则以1初始化所有梯度变量
- **no_grad_sethread** (set[string]) – 在Block 0中不具有梯度的变量，所有block中被设置 ``stop_gradient=True`` 的变量将被自动加入该set
返回：数组，包含与输入对应的梯度。如果一个输入不影响目标函数，则对应的梯度变量为None
返回类型：(list[Variable])
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[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)
.. _cn_api_fluid_in_dygraph_mode:
in_dygraph_mode
......@@ -1006,11 +1568,18 @@ in_dygraph_mode
.. py:function:: paddle.fluid.in_dygraph_mode()
返回：bool，如果Program是在动态图模式下运行的则为True。
检查程序状态(tracer) - 是否在dygraph模式中运行
返回：如果Program是在动态图模式下运行的则为True。
返回类型：out(boolean)
**示例代码**
.. code-block:: python
if fluid.in_dygraph_mode():
pass
.. _cn_api_fluid_LoDTensor:
......@@ -1038,9 +1607,8 @@ X 为 LoDTensor，它包含两个序列。第一个长度是2，第二个长度
::
x.lod = [[2, 3]]
x.data = [[1, 2], [3, 4], // seq 1
[5, 6], [7, 8], [9, 10]] // seq 2
x.data = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]]
x.shape = [5, 2]
......@@ -1050,8 +1618,17 @@ LoD可以有多个level(例如，一个段落可以有多个句子，一个句
::
y.lod = [[2 1], [2 2 3]] y.shape = [2+2+3, ...]
y.lod = [[2 1], [2 2 3]]
y.shape = [2+2+3, ...]
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
t = fluid.LoDTensor()
.. note::
......@@ -1070,7 +1647,19 @@ LoD可以有多个level(例如，一个段落可以有多个句子，一个句
返回类型: out (bool)
.. py:method:: lod(self: paddle.fluid.core.LoDTensor) → List[List[int]]
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
t = fluid.LoDTensor()
t.set(np.ndarray([5, 30]), fluid.CPUPlace())
t.set_recursive_sequence_lengths([[2, 3]])
print(t.has_valid_recursive_sequence_lengths()) # True
.. py:method:: lod(self: paddle.fluid.core_avx.LoDTensor) → List[List[int]]
得到LoD Tensor的LoD。
......@@ -1078,8 +1667,19 @@ LoD可以有多个level(例如，一个段落可以有多个句子，一个句
返回类型：out（List [List [int]]）
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
t = fluid.LoDTensor()
t.set(np.ndarray([5, 30]), fluid.CPUPlace())
t.set_lod([[0, 2, 5]])
print(t.lod()) # [[0, 2, 5]]
.. py:method:: recursive_sequence_lengths(self: paddle.fluid.core.LoDTensor) → List[List[int]]
.. py:method:: recursive_sequence_lengths(self: paddle.fluid.core_avx.LoDTensor) → List[List[int]]
得到与LoD对应的LoDTensor的序列长度。
......@@ -1087,29 +1687,78 @@ LoD可以有多个level(例如，一个段落可以有多个句子，一个句
返回类型：out（List [List [int]）
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
t = fluid.LoDTensor()
t.set(np.ndarray([5, 30]), fluid.CPUPlace())
t.set_recursive_sequence_lengths([[2, 3]])
print(t.recursive_sequence_lengths()) # [[2, 3]]
.. py:method:: set(*args, **kwargs)
重载函数
1. set(self: paddle.fluid.core_avx.Tensor, arg0: numpy.ndarray[float32], arg1: paddle::platform::CPUPlace) -> None
2. set(self: paddle.fluid.core_avx.Tensor, arg0: numpy.ndarray[int32], arg1: paddle::platform::CPUPlace) -> None
3. set(self: paddle.fluid.core_avx.Tensor, arg0: numpy.ndarray[float64], arg1: paddle::platform::CPUPlace) -> None
.. py:method:: set_lod(self: paddle.fluid.core.LoDTensor, lod: List[List[int]]) → None
4. set(self: paddle.fluid.core_avx.Tensor, arg0: numpy.ndarray[int64], arg1: paddle::platform::CPUPlace) -> None
5. set(self: paddle.fluid.core_avx.Tensor, arg0: numpy.ndarray[bool], arg1: paddle::platform::CPUPlace) -> None
6. set(self: paddle.fluid.core_avx.Tensor, arg0: numpy.ndarray[uint16], arg1: paddle::platform::CPUPlace) -> None
7. set(self: paddle.fluid.core_avx.Tensor, arg0: numpy.ndarray[uint8], arg1: paddle::platform::CPUPlace) -> None
8. set(self: paddle.fluid.core_avx.Tensor, arg0: numpy.ndarray[int8], arg1: paddle::platform::CPUPlace) -> None
.. py:method:: set_lod(self: paddle.fluid.core_avx.LoDTensor, lod: List[List[int]]) → None
设置LoDTensor的LoD。
参数：
- **lod** （List [List [int]]） - 要设置的lod。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
t = fluid.LoDTensor()
t.set(np.ndarray([5, 30]), fluid.CPUPlace())
t.set_lod([[0, 2, 5]])
.. py:method:: set_recursive_sequence_lengths(self: paddle.fluid.core.LoDTensor, recursive_sequence_lengths: List[List[int]]) → None
根据递归序列长度recursive_sequence_lengths设置LoDTensor的LoD。
::
例如，如果recursive_sequence_lengths = [[2,3]]，
意味着有两个长度分别为2和3的序列，相应的lod将是[[0,2,2 + 3]]，即[[0， 2,5]]。
例如，如果recursive_sequence_lengths = [[2,3]]，意味着有两个长度分别为2和3的序列，相应的lod将是[[0,2,2 + 3]]，即[[0， 2,5]]。
参数：
- **recursive_sequence_lengths** （List [List [int]]） - 序列长度。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
t = fluid.LoDTensor()
t.set(np.ndarray([5, 30]), fluid.CPUPlace())
t.set_recursive_sequence_lengths([[2, 3]])
.. py:method:: shape(self: paddle.fluid.core_avx.Tensor) → List[int]
......@@ -1125,13 +1774,31 @@ LoDTensorArray
.. py:class:: paddle.fluid.LoDTensorArray
.. py:method:: append(self: paddle.fluid.core.LoDTensorArray, tensor: paddle.fluid.core.LoDTensor) → None
LoDTensor的数组。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
arr = fluid.LoDTensorArray()
.. py:method:: append(self: paddle.fluid.core_avx.LoDTensorArray, tensor: paddle.fluid.core.LoDTensor) → None
将LoDTensor追加到LoDTensorArray后。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
arr = fluid.LoDTensorArray()
t = fluid.LoDTensor()
t.set(np.ndarray([5, 30]), fluid.CPUPlace())
arr.append(t)
......@@ -1144,23 +1811,47 @@ memory_optimize
.. py:function:: paddle.fluid.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=False)
历史遗留的内存优化策略，通过在不同operators间重用var内存来减少总内存消耗。
用一个简单的示例来解释该算法：
c = a + b # 假设这里是最后一次使用a
d = b * c
鉴于在“c = a + b”之后不再使用a，且a和d的大小相同，我们可以用变量a来代替变量d，即实际上，上面的代码可以优化成：
c = a + b
a = b * c
请注意，在此历史遗存设计中，我们将直接用变量a代替变量d，这意味着在你调用该API后，某些变量将会消失，还有一些会取非预期值。正如上面的例子中，执行程序后，实际上a取d的值。
因此，为避免重要变量在优化过程中被重用或移除，我们支持用skip_opt_set指定一个变量白名单。skip_opt_set中的变量不会受memory_optimize API的影响。
通过重用var内存来优化内存。
.. note::
它不支持block中嵌套子block。
此API已被弃用，请不要在你新写的代码中使用它。它不支持block中嵌套子block，如While、IfElse等。
参数:
- **input_program** (str) – 输入Program。
- **skip_opt_set** (set) – set中的vars将不被内存优化。
- **print_log** (bool) – 是否打印debug日志。
- **level** (int) 如果 level=0 并且shape是完全相等，则重用。
- **level** (int) - 值为0或1。如果level=0，则仅当a.size == b.size时我们才用b代替a；如果level=1，只要a.size <= b.size时我们就可以用b代替a。
返回: None
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
main_prog = fluid.Program()
startup_prog = fluid.Program()
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(startup_prog)
fluid.memory_optimize(main_prog)
......@@ -1184,16 +1875,17 @@ name_scope
.. code-block:: python
with name_scope("encoder"):
...
with name_scope("decoder"):
...
with name_scope("attention"):
...
with fluid.name_scope("s1"):
a = fluid.layers.data(name='data', shape=[1], dtype='int32')
b = a + 1
with fluid.name_scope("s2"):
c = b * 1
with fluid.name_scope("s3"):
d = c / 1
with fluid.name_scope("s1"):
f = fluid.layers.pow(d, 2.0)
with fluid.name_scope("s4"):
g = f - 1
......@@ -1209,8 +1901,51 @@ ParallelExecutor
``ParallelExecutor`` 专门设计用来实现数据并行计算，着力于向不同结点(node)分配数据，并行地在不同结点中对数据进行操作。如果在GPU上使用该类运行程序，node则用来指代GPU， ``ParallelExecutor`` 也将自动获取在当前机器上可用的GPU资源。如果在CPU上进行操作，node则指代CPU，同时你也可以通过添加环境变量 ``CPU_NUM`` 来设置CPU设备的个数。例如，``CPU_NUM=4``。但是如果没有设置该环境变量，该类会调用 ``multiprocessing.cpu_count`` 来获取当前系统中CPU的个数。
**示例代码**
.. 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)
startup_program.random_seed=1
exe.run(startup_program)
train_exe = fluid.ParallelExecutor(use_cuda=use_cuda,
main_program=train_program,
loss_name=loss.name)
test_exe = fluid.ParallelExecutor(use_cuda=use_cuda,
main_program=test_program,
share_vars_from=train_exe)
x = numpy.random.random(size=(10, 1)).astype('float32')
loss_data, = train_exe.run(feed={"X": x},
fetch_list=[loss.name])
loss_data, = test_exe.run(feed={"X": x},
fetch_list=[loss.name])
参数:
- **use_cuda** (bool) – 是否使用CUDA
......@@ -1229,20 +1964,6 @@ ParallelExecutor
抛出异常：``TypeError`` - 如果提供的参数 ``share_vars_from`` 不是 ``ParallelExecutor`` 类型的，将会弹出此异常
**代码示例**
.. code-block:: python
train_exe = fluid.ParallelExecutor(use_cuda=True, loss_name=loss.name)
test_exe = fluid.ParallelExecutor(use_cuda=True,
main_program=test_program,
share_vars_from=train_exe)
train_loss, = train_exe.run([loss.name], feed=feed_dict)
test_loss, = test_exe.run([loss.name], feed=feed_dict)
.. py:method:: run(fetch_list, feed=None, feed_dict=None, return_numpy=True)
使用 ``fetch_list`` 执行一个 ``ParallelExecutor`` 对象。
......@@ -1250,27 +1971,55 @@ ParallelExecutor
参数 ``feed`` 可以是 ``dict`` 或者 ``list`` 类型变量。如果该参数是 ``dict`` 类型，feed中的数据将会被分割(split)并分送给多个设备（CPU/GPU）。
反之，如果它是 ``list`` ，则列表中的各个元素都会直接分别被拷贝到各设备中。
例如，如果 ``feed`` 是个 ``dict`` 类型变量，则有
**示例代码**
.. code-block:: python
exe = ParallelExecutor()
# 图像会被split到设备中。假设有两个设备，那么每个设备将会处理形为 (24, 1, 28, 28)的图像
exe.run(feed={'image': numpy.random.random(size=(48, 1, 28, 28))})
import paddle.fluid as fluid
import numpy
import os
如果 ``feed`` 是个 ``list`` 类型变量，则有
use_cuda = True
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
.. code-block:: python
# 注意：如果你使用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)
startup_program.random_seed=1
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])
exe = ParallelExecutor()
# 如果feed参数是list类型:
# 各设备挨个处理列表中的每个元素
# 第一个设备处理形为 (48, 1, 28, 28) 的图像
# 第二个设备处理形为 (32, 1, 28, 28) 的图像
# 第一个设备处理形为 (10, 1) 的图像
# 第二个设备处理形为 (9, 1) 的图像
#
# 使用 exe.device_count 得到设备数目
exe.run(feed=[{"image": numpy.random.random(size=(48, 1, 28, 28))},
{"image": numpy.random.random(size=(32, 1, 28, 28))},
])
x2 = numpy.random.random(size=(9, 1)).astype('float32')
loss_data, = train_exe.run(feed=[{"X": x}, {"X": x2}],
fetch_list=[loss.name])
参数：
- **fetch_list** (list) – 获取的变量名列表
......@@ -1300,10 +2049,48 @@ ParallelExecutor
loss = pe.run(feed=feeder.feed(cur_batch),
fetch_list=[avg_cost.name]))
.. py:method:: drop_local_exe_scopes()
立即删除本地执行作用域。
 
在程序执行期间，生成中间结果被放置在本地执行作用域内，在某些模型中，这些中间结果的创建和删除较为费时。为了解决这个问题，ParallelExecutor在ExecutionStrategy中提供了可选项，如num_iteration_per_drop_scope，此选项指示在删除本地执行作用域之前要运行的迭代次数。 但在某些情况下，每次迭代都会产生不同的中间结果，这将导致本地执行作用域所需的内存逐渐增加。 如果你想在这个时候运行另一个程序，可能没有足够的存储空间，此时你应该删除其他程序的本地执行作用域。
**代码示例**
.. 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.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()
......@@ -1332,6 +2119,8 @@ ParamAttr
.. code-block:: python
import paddle.fluid as fluid
w_param_attrs = fluid.ParamAttr(name="fc_weight",
learning_rate=0.5,
regularizer=fluid.L2Decay(1.0),
......@@ -1368,53 +2157,18 @@ 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):
fluid.layers.data(name="x", shape=[-1, 784], dtype='float32')
fluid.layers.data(name="y", shape=[-1, 1], dtype='int32')
fluid.layers.fc(name="fc", shape=[10], dtype='float32', act="relu")
.. py:attribute:: op_role
operator的角色，值只能是枚举变量{Forward, Backward, Optimize}。
注意：这是一个底层API。它仅用于 ``ParallelExecutor`` 复制或调度operator到设备。
例如，Forward operator应该在每个设备上执行。Backward operator在每个设备上执行，并将后向传播的参数梯度(使用 ``op_role_var`` 获得该变量)合并到一个设备上。Optimize operator只在一个设备上执行，并向其他设备广播新的参数，
.. py:attribute:: set_op_role
operator的角色，值只能是枚举变量{Forward, Backward, Optimize}。
注意：这是一个底层API。它仅用于 ``ParallelExecutor`` 复制或调度operator到设备上执行。
例如，Forward operator应该在每个设备上执行。Backward operato应该在每个设备上执行，并将后向传播的参数梯度(使用op_role_var获得该变量)合并到一个设备上。Optimize operator只在一个设备上执行，并向其他设备广播新的参数
.. py:attribute:: op_role_var
``op_role`` 的辅助变量。
参考: ``Program.op_role`` 文档。
注意:这是一个底层API，用户不应该直接使用它。
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(main_program))
.. py:attribute:: set_op_role_var
``op_role`` 的辅助变量。
参考: ``Program.op_role`` 文档。
注意:这是一个底层API。用户不应该直接使用它。
print("start up program is: {}".format(startup_program))
.. py:method:: to_string(throw_on_error, with_details=False)
......@@ -1432,22 +2186,30 @@ operator的角色，值只能是枚举变量{Forward, Backward, Optimize}。
抛出异常：
- ``ValueError`` - 当 ``throw_on_error == true`` ，但没有设置任何必需的字段时，抛出 ``ValueError`` 。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
prog = fluid.default_main_program()
prog_string = prog.to_string(throw_on_error=True, with_details=False)
print(prog_string)
.. py:method:: clone(for_test=False)
创建一个新的、相同的Program。
有些operator，在训练和测试之间的行为是不同的，比如batch_norm。它们有一个属性is_test来控制行为。当for_test=True时，此方法将把它们的is_test属性更改为True。
有些operator，在训练和测试之间的行为是不同的，比如 ``batch_norm`` 。它们有一个属性 ``is_test`` 来控制行为。当 ``for_test=True`` 时，此方法将把它们的 ``is_test`` 属性更改为True。
- 克隆Program，该Program用于训练时，将 ``for_test`` 设置为False。
- 克隆Program，该Program用于测试时，将 ``for_test`` 设置为True。
- 克隆Program用于训练时，将 ``for_test`` 设置为False。
- 克隆Program用于测试时，将 ``for_test`` 设置为True。我们不会在此处对程序进行任何裁剪，因此，如果您只是想要一个用于测试的前向计算程序，请在使用 ``Opimizer.minimize`` 之前使用 ``clone``
注意:此API不会删除任何操作符。请在backward和optimization之前使用clone(for_test=True)。
注意:
1. ``Program.clone()`` 方法不会克隆 ``py_reader``
2. 此API不会裁剪任何算子。请在backward和optimization之前使用 ``clone(for_test=True)`` 。例如：
**代码示例**
.. code-block:: python
.. code-block:: python
test_program = fluid.default_main_program().clone(for_test=True)
optimizer = fluid.optimizer.Momentum(learning_rate=0.01, momentum=0.9)
......@@ -1458,59 +2220,107 @@ operator的角色，值只能是枚举变量{Forward, Backward, Optimize}。
返回：一个新的、相同的Program
返回类型:Program
返回类型：Program
**代码示例**
1.克隆一个Program，示例代码如下：
注意，Program Desc在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()
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'))
test_program = train_program.clone(for_test=True)
sgd = fluid.optimizer.SGD(learning_rate=1e-3)
avg_loss = fluid.layers.mean(loss)
test_program = train_program.clone(for_test=False)
print_prog(test_program)
with fluid.program_guard(train_program, startup_program):
sgd.minimize(loss)
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(is_test):
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, is_test=is_test)
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'))
return loss
avg_loss = fluid.layers.mean(loss)
return avg_loss
train_program = fluid.Program()
startup_program = fluid.Program()
test_program = fluid.Program()
with fluid.program_guard(train_program, startup_program):
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():
loss = network(is_test=False)
sgd = fluid.optimizer.SGD(learning_rate=1e-3)
sgd.minimize(loss)
# 不使用测试阶段的startup program
with fluid.program_guard(test_program, fluid.Program()):
sgd.minimize(avg_loss)
# 不使用测试阶段的启动程序
with fluid.program_guard(test_program_2, fluid.Program()):
with fluid.unique_name.guard():
loss = network(is_test=True)
print(test_program_2)
上边两个代码片段生成的Program是一样的。
上边两个代码片段生成和打印的Program是一样的。
.. py:staticmethod:: parse_from_string(binary_str)
......@@ -1529,6 +2339,16 @@ operator的角色，值只能是枚举变量{Forward, Backward, Optimize}。
该program中的block的个数
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
prog = fluid.default_main_program()
num_blocks = prog.num_blocks
print(num_blocks)
.. py:attribute:: random_seed
......@@ -1536,10 +2356,32 @@ operator的角色，值只能是枚举变量{Forward, Backward, Optimize}。
注意：必须在operator被添加之前设置。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
prog = fluid.default_main_program()
random_seed = prog.random_seed
print(random_seed)
prog.random_seed = 1
print(prog.random_seed)
.. py:method:: global_block()
获取该program的第一个block。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
prog = fluid.default_main_program()
gb_block = prog.global_block()
print(gb_block)
.. py:method:: block(index)
返回该program中 ， ``index`` 指定的block。 ``index`` 类型为int
......@@ -1548,10 +2390,30 @@ operator的角色，值只能是枚举变量{Forward, Backward, Optimize}。
返回类型：Block
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
prog = fluid.default_main_program()
block_0 = prog.block(0)
print(block_0)
.. py:method:: current_block()
获取当前block。当前block是用来添加operators。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
prog = fluid.default_main_program()
current_blk = prog.current_block()
print(current_blk)
.. py:method:: list_vars()
获取当前program中所有变量。返回值是一个可迭代对象（iterable object)。
......@@ -1560,9 +2422,17 @@ operator的角色，值只能是枚举变量{Forward, Backward, Optimize}。
返回类型：iterable
**代码示例**
.. 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)
......@@ -1588,8 +2458,8 @@ program_guard
main_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(main_program, startup_program):
data = fluid.layers.data(...)
hidden = fluid.layers.fc(...)
data = fluid.layers.data(name='image', shape=[784, 784], dtype='float32')
hidden = fluid.layers.fc(input=data, size=10, act='relu')
需要注意的是，如果用户不需要构建自己的启动程序或者主程序，一个临时的program将会发挥作用。
......@@ -1601,7 +2471,7 @@ program_guard
main_program = fluid.Program()
# 如果您不需要关心startup program,传入一个临时值即可
with fluid.program_guard(main_program, fluid.Program()):
data = ...
data = fluid.layers.data(name='image', shape=[784, 784], dtype='float32')
参数：
......@@ -1636,6 +2506,19 @@ release_memory
返回: None
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# 搭建网络
# ...
# 已弃用的API
fluid.release_memory(fluid.default_main_program())
.. _cn_api_fluid_scope_guard:
......@@ -1655,14 +2538,12 @@ scope_guard
.. code-block:: python
import paddle.fluid as fluid
import numpy
new_scope = fluid.Scope()
with fluid.scope_guard(new_scope):
...
fluid.global_scope().var("data").get_tensor().set(numpy.ones((2, 2)), fluid.CPUPlace())
numpy.array(new_scope.find_var("data").get_tensor())
......@@ -1711,9 +2592,18 @@ WeightNormParamAttr
.. 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=WeightNormParamAttr(
param_attr=fluid.WeightNormParamAttr(
dim=None,
name='weight_norm_param'))
doc/fluid/api_cn/initializer_cn.rst
浏览文件 @ 9a601dd2
......@@ -27,14 +27,19 @@ BilinearInitializer
.. code-block:: python
factor = 2
w_attr = ParamAttr(learning_rate=0., regularizer=L2Decay(0.),
initializer=Bilinear())
C = 2
w_attr = fluid.initializer.ParamAttr(
learning_rate=0.,
regularizer=fluid.regularizer.L2Decay(0.),
initializer=fluid.initializer.Bilinear())
x = fluid.layers.data(name="data", shape=[3, 32, 32],
dtype="float32")
conv_up = fluid.layers.conv2d_transpose(
input,
input=x,
num_filters=C,
output_size=None,
filter_size=2 * factor - factor % 2,
padding=ceil((factor - 1) / 2.),
padding=int(math.ceil((factor - 1) / 2.)),
stride=factor,
groups=C,
param_attr=w_attr,
......@@ -72,6 +77,7 @@ ConstantInitializer
.. code-block:: python
x = fluid.layers.data(name="data", shape=[32, 32], dtype="float32")
fc = fluid.layers.fc(input=x, size=10,
param_attr=fluid.initializer.Constant(value=2.0))
......@@ -98,8 +104,8 @@ force_init_on_cpu
.. code-block:: python
if force_init_on_cpu():
create_op('force_cpu': force_init_on_cpu())
if fluid.initializer.force_init_on_cpu():
step = fluid.layers.create_global_var(shape=[2,3], value=1.0, dtype='float32')
......@@ -124,8 +130,8 @@ init_on_cpu
.. code-block:: python
with init_on_cpu():
step = fluid.layers.create_global_var()
with fluid.initializer.init_on_cpu():
step = fluid.layers.create_global_var(shape=[2,3], value=1.0, dtype='float32')
......@@ -177,9 +183,8 @@ MSRAInitializer
.. code-block:: python
fc = fluid.layers.fc(
input=queries, size=10,
param_attr=fluid.initializer.MSRA(uniform=False))
x = fluid.layers.data(name="data", shape=[32, 32], dtype="float32")
fc = fluid.layers.fc(input=x, size=10, param_attr=fluid.initializer.MSRA(uniform=False))
......@@ -214,6 +219,7 @@ NormalInitializer
.. code-block:: python
x = fluid.layers.data(name="data", shape=[32, 32], dtype="float32")
fc = fluid.layers.fc(input=x, size=10,
param_attr=fluid.initializer.Normal(loc=0.0, scale=2.0)
......@@ -234,6 +240,7 @@ NumpyArrayInitializer
.. code-block:: python
x = fluid.layers.data(name="x", shape=[5], dtype='float32')
fc = fluid.layers.fc(input=x, size=10,
param_attr=fluid.initializer.NumpyArrayInitializer(numpy.array([1,2])))
......@@ -266,6 +273,8 @@ Random Truncated Normal（高斯）分布初始化器
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[1], dtype='float32')
fc = fluid.layers.fc(input=x, size=10,
param_attr=fluid.initializer.TruncatedNormal(loc=0.0, scale=2.0))
......@@ -306,6 +315,8 @@ UniformInitializer
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[1], dtype='float32')
fc = fluid.layers.fc(input=x, size=10,
param_attr=fluid.initializer.Uniform(low=-0.5, high=0.5))
......@@ -368,6 +379,8 @@ XavierInitializer
.. code-block:: python
import paddle.fluid as fluid
queries = fluid.layers.data(name='x', shape=[1], dtype='float32')
fc = fluid.layers.fc(
input=queries, size=10,
param_attr=fluid.initializer.Xavier(uniform=False))
......
doc/fluid/api_cn/io_cn.rst
浏览文件 @ 9a601dd2
......@@ -11,7 +11,7 @@ load_inference_model
.. py:function:: paddle.fluid.io.load_inference_model(dirname, executor, model_filename=None, params_filename=None, pserver_endpoints=None)
从指定目录中加载预测模型(inference model)。
从指定目录中加载预测模型(inference model)。通过这个API，您可以获得模型结构（预测程序）和模型参数。如果您只想下载预训练后的模型的参数，请使用load_params API。更多细节请参考 ``模型/变量的保存、载入与增量训练`` 。
参数:
- **dirname** (str) – model的路径
......@@ -29,17 +29,39 @@ load_inference_model
.. code-block:: python
exe = fluid.Executor(fluid.CPUPlace())
import paddle.fluid as fluid
import numpy as np
main_prog = fluid.Program()
startup_prog = fluid.Program()
with fluid.program_guard(main_prog, startup_prog):
data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32')
b = fluid.layers.create_parameter(shape=[200], dtype='float32')
hidden_w = fluid.layers.matmul(x=data, y=w)
hidden_b = fluid.layers.elementwise_add(hidden_w, b)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(startup_prog)
path = "./infer_model"
endpoints = ["127.0.0.1:2023","127.0.0.1:2024"]
[inference_program, feed_target_names, fetch_targets] =
fluid.io.load_inference_model(dirname=path, executor=exe)
fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'],target_vars=[hidden_b], executor=exe, main_program=main_prog)
tensor_img = np.array(np.random.random((1, 64, 784)), dtype=np.float32)
[inference_program, feed_target_names, fetch_targets] = (fluid.io.load_inference_model(dirname=path, executor=exe))
results = exe.run(inference_program,
feed={feed_target_names[0]: tensor_img},
fetch_list=fetch_targets)
# 在这个示例中，inference program 保存在 ./infer_model/__model__”中
# 参数保存在./infer_mode 单独的若干文件中
# 加载 inference program 后， executor 使用 fetch_targets 和 feed_target_names 执行Program， 得到预测结果
# endpoints是pserver服务器终端列表，下面仅为一个样例
endpoints = ["127.0.0.1:2023","127.0.0.1:2024"]
# 如果需要查询表格，我们可以使用：
[dist_inference_program, dist_feed_target_names, dist_fetch_targets] = (
fluid.io.load_inference_model(dirname=path,
executor=exe,
pserver_endpoints=endpoints))
# 在这个示例中，inference program 保存在“ ./infer_model/__model__”中
# 参数保存在“./infer_mode ”单独的若干文件中
# 加载 inference program 后， executor 使用 fetch_targets 和 feed_target_names 执行Program，得到预测结果
......@@ -60,6 +82,8 @@ load_params
注意:有些变量不是参数，但它们对于训练是必要的。因此，调用 ``save_params()`` 和 ``load_params()`` 来保存和加载参数是不够的，可以使用 ``save_persistables()`` 和 ``load_persistables()`` 代替这两个函数。
如果您想下载预训练后的模型结构和参数用于预测，请使用load_inference_model API。更多细节请参考 :ref:`api_guide_model_save_reader`。
参数:
- **executor** (Executor) – 加载变量的 executor
- **dirname** (str) – 目录路径
......@@ -149,27 +173,39 @@ load_vars
.. code-block:: python
exe = fluid.Executor(fluid.CPUPlace())
import paddle.fluid as fluid
main_prog = fluid.Program()
startup_prog = fluid.Program()
with fluid.program_guard(main_prog, startup_prog):
data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32', name='fc_w')
b = fluid.layers.create_parameter(shape=[200], dtype='float32', name='fc_b')
hidden_w = fluid.layers.matmul(x=data, y=w)
hidden_b = fluid.layers.elementwise_add(hidden_w, b)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(startup_prog)
param_path = "./my_paddle_model"
# 第一种使用方式 使用 main_program 指定变量
def name_has_fc(var):
res = "fc" in var.name
return res
prog = fluid.default_main_program()
fluid.io.load_vars(executor=exe, dirname=path, main_program=prog,
vars=None, predicate=name_has_fc)
fluid.io.save_vars(executor=exe, dirname=param_path, main_program=main_prog, vars=None, predicate=name_has_fc)
fluid.io.load_vars(executor=exe, dirname=param_path, main_program=main_prog, vars=None, predicate=name_has_fc)
#加载所有`main_program`中变量名包含 ‘fc’ 的变量
#并且此前所有变量应该保存在不同文件中
#用法2：使用 `vars` 列表来指明变量
var_list = [var_a, var_b, var_c]
#用法2：使用 `vars` 来使变量具体化
path = "./my_paddle_vars"
var_list = [w, b]
fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
filename="vars_file")
fluid.io.load_vars(executor=exe, dirname=path, vars=var_list,
filename="vars_file")
# 加载 var_a ， var_b ， var_c .它们此前应被保存在同一文件中
# 文件名为 'var_file' ，路径为 "./my_paddle_model".
# 加载w和b，它们此前应被保存在同一名为'var_file'的文件中
# 该文件所在路径为 "./my_paddle_model"
......@@ -178,16 +214,17 @@ load_vars
PyReader
-------------------------------
.. py:class:: paddle.fluid.io.PyReader(feed_list, capacity, use_double_buffer=True, iterable=False)
.. py:class:: paddle.fluid.io.PyReader(feed_list=None, capacity=None, use_double_buffer=True, iterable=True, return_list=False)
在python中为数据输入创建一个reader对象。将使用python线程预取数据，并将其异步插入队列。当调用Executor.run（…）时，将自动提取队列中的数据。
参数:
- **feed_list** (list(Variable)|tuple(Variable)) – feed变量列表，由``fluid.layers.data()``创建。
- **feed_list** (list(Variable)|tuple(Variable)) – feed变量列表，由 ``fluid.layers.data()`` 创建。在可迭代模式下它可以被设置为None。
- **capacity** (int) – 在Pyreader对象中维护的队列的容量。
- **use_double_buffer** (bool) – 是否使用``double_buffer_reader ``来加速数据输入。
- **use_double_buffer** (bool) – 是否使用 ``double_buffer_reader`` 来加速数据输入。
- **iterable** (bool) – 被创建的reader对象是否可迭代。
- **eturn_list** (bool) – 是否以list的形式将返回值
返回: 被创建的reader对象
......@@ -200,71 +237,218 @@ PyReader
.. code-block:: python
image = fluid.layers.data(
name='image', shape=[784], dtype='float32')
label = fluid.layers.data(
name='label', shape=[1], dtype='int64')
EPOCH_NUM = 3
ITER_NUM = 5
BATCH_SIZE = 3
def reader_creator_random_image_and_label(height, width):
def reader():
for i in range(ITER_NUM):
fake_image = np.random.uniform(low=0,
high=255,
size=[height, width])
fake_label = np.ones([1])
yield fake_image, fake_label
return reader
image = fluid.layers.data(name='image', shape=[784, 784], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
reader = fluid.io.PyReader(feed_list=[image, label],
capacity=4, iterable=False)
reader.decorate_sample_list_generator(user_defined_reader)
... # definition of network is omitted
executor.run(fluid.default_main_program())
for _ in range(EPOCH_NUM):
capacity=4,
iterable=False)
user_defined_reader = reader_creator_random_image_and_label(784, 784)
reader.decorate_sample_list_generator(
paddle.batch(user_defined_reader, batch_size=BATCH_SIZE))
# 此处省略网络定义
executor = fluid.Executor(fluid.CUDAPlace(0))
executor.run(fluid.default_startup_program())
for i in range(EPOCH_NUM):
reader.start()
while True:
try:
executor.run(feed=None, ...)
executor.run(feed=None)
except fluid.core.EOFException:
reader.reset()
break
2.如果iterable=True，则创建的Pyreader对象与程序分离。程序中不会插入任何算子。在本例中，创建的reader是一个python生成器，它是可迭代的。用户应将从Pyreader对象生成的数据输入 ``Executor.run(feed=...)``
2.如果iterable=True，则创建的Pyreader对象与程序分离。程序中不会插入任何算子。在本例中，创建的reader是一个python生成器，它是不可迭代的。用户应将从Pyreader对象生成的数据输入 ``Executor.run(feed=...)`` 。
.. code-block:: python
image = fluid.layers.data(
name='image', shape=[784], dtype='float32')
label = fluid.layers.data(
name='label', shape=[1], dtype='int64')
EPOCH_NUM = 3
ITER_NUM = 5
BATCH_SIZE = 10
def reader_creator_random_image(height, width):
def reader():
for i in range(ITER_NUM):
yield np.random.uniform(low=0, high=255, size=[height, width]),
return reader
image = fluid.layers.data(name='image', shape=[784, 784], dtype='float32')
reader = fluid.io.PyReader(feed_list=[image], capacity=4, iterable=True, return_list=False)
user_defined_reader = reader_creator_random_image(784, 784)
reader.decorate_sample_list_generator(
paddle.batch(user_defined_reader, batch_size=BATCH_SIZE),
fluid.core.CUDAPlace(0))
# 此处省略网络定义
executor = fluid.Executor(fluid.CUDAPlace(0))
executor.run(fluid.default_main_program())
for _ in range(EPOCH_NUM):
for data in reader():
executor.run(feed=data)
3. return_list=True，返回值将用list表示而非dict
reader = fluid.io.PyReader(feed_list=[image, label],
capacity=4, iterable=True)
reader.decorate_sample_list_generator(user_defined_reader,
places=fluid.cuda_places())
... # definition of network is omitted
.. code-block:: python
import paddle
import paddle.fluid as fluid
import numpy as np
EPOCH_NUM = 3
ITER_NUM = 5
BATCH_SIZE = 10
def reader_creator_random_image(height, width):
def reader():
for i in range(ITER_NUM):
yield np.random.uniform(low=0, high=255, size=[height, width]),
return reader
image = fluid.layers.data(name='image', shape=[784, 784], dtype='float32')
reader = fluid.io.PyReader(feed_list=[image], capacity=4, iterable=True, return_list=True)
user_defined_reader = reader_creator_random_image(784, 784)
reader.decorate_sample_list_generator(
paddle.batch(user_defined_reader, batch_size=BATCH_SIZE),
fluid.core.CPUPlace())
# 此处省略网络定义
executor = fluid.Executor(fluid.core.CPUPlace())
executor.run(fluid.default_main_program())
for _ in range(EPOCH_NUM):
for data in reader():
executor.run(feed=data, ...)
executor.run(feed={"image": data[0]})
.. py:function:: start()
.. py:method:: start()
启动数据输入线程。只能在reader对象不可迭代时调用。
.. py:function:: reset()
**代码示例**
.. code-block:: python
当 ``fluid.core.EOFException`` 提升时重置reader对象。只能在reader对象不可迭代时调用。
BATCH_SIZE = 10
.. py:function:: decorate_sample_generator(sample_generator, batch_size, drop_last=True, places=None)
def generator():
for i in range(5):
yield np.random.uniform(low=0, high=255, size=[784, 784]),
image = fluid.layers.data(name='image', shape=[784, 784], dtype='float32')
reader = fluid.io.PyReader(feed_list=[image], capacity=4, iterable=False)
reader.decorate_sample_list_generator(
paddle.batch(generator, batch_size=BATCH_SIZE))
executor = fluid.Executor(fluid.CUDAPlace(0))
executor.run(fluid.default_startup_program())
for i in range(3):
reader.start()
while True:
try:
executor.run(feed=None)
except fluid.core.EOFException:
reader.reset()
break
.. py:method:: reset()
当 ``fluid.core.EOFException`` 抛出时重置reader对象。只能在reader对象不可迭代时调用。
**代码示例**
.. code-block:: python
BATCH_SIZE = 10
def generator():
for i in range(5):
yield np.random.uniform(low=0, high=255, size=[784, 784]),
image = fluid.layers.data(name='image', shape=[784, 784], dtype='float32')
reader = fluid.io.PyReader(feed_list=[image], capacity=4, iterable=False)
reader.decorate_sample_list_generator(
paddle.batch(generator, batch_size=BATCH_SIZE))
executor = fluid.Executor(fluid.CUDAPlace(0))
executor.run(fluid.default_startup_program())
for i in range(3):
reader.start()
while True:
try:
executor.run(feed=None)
except fluid.core.EOFException:
reader.reset()
break
.. py:method:: decorate_sample_generator(sample_generator, batch_size, drop_last=True, places=None)
设置Pyreader对象的数据源。
提供的 ``sample_generator `` 应该是一个python生成器，它生成每个示例的numpy.ndarray类型的数据。
提供的 ``sample_generator`` 应该是一个python生成器，它生成的数据类型应为list(numpy.ndarray)。
当Pyreader对象不可迭代时，必须设置 ``places`` 。
如果所有的输入都没有LOD，这个方法比 ``decorate_sample_list_generator(paddle.batch(sample_generator, ...))`` 更快。
参数:
- **sample_generator** (generator) – 返回numpy.ndarray类型样本数据的Python生成器
- **sample_generator** (generator) – Python生成器，yield 类型为list(numpy.ndarray)
- **batch_size** (int) – batch size，必须大于0
- **drop_last** (bool) – 当样本数小于batch数量时，是否删除最后一个batch
- **places** (None|list(CUDAPlace)|list(CPUPlace)) – 位置列表。当PyReader可迭代时必须被提供
**代码示例**
.. code-block:: python
.. py:function:: decorate_sample_list_generator(reader, places=None)
EPOCH_NUM = 3
ITER_NUM = 15
BATCH_SIZE = 3
def random_image_and_label_generator(height, width):
def generator():
for i in range(ITER_NUM):
fake_image = np.random.uniform(low=0,
high=255,
size=[height, width])
fake_label = np.array([1])
yield fake_image, fake_label
return generator
image = fluid.layers.data(name='image', shape=[784, 784], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int32')
reader = fluid.io.PyReader(feed_list=[image, label], capacity=4, iterable=True)
user_defined_generator = random_image_and_label_generator(784, 784)
reader.decorate_sample_generator(user_defined_generator,
batch_size=BATCH_SIZE,
places=[fluid.CUDAPlace(0)])
# 省略了网络的定义
executor = fluid.Executor(fluid.CUDAPlace(0))
executor.run(fluid.default_main_program())
for _ in range(EPOCH_NUM):
for data in reader():
executor.run(feed=data)
.. py:method:: decorate_sample_list_generator(reader, places=None)
设置Pyreader对象的数据源。
......@@ -276,8 +460,41 @@ PyReader
- **reader** (generator) – 返回列表（numpy.ndarray）类型的批处理数据的Python生成器
- **places** (None|list(CUDAPlace)|list(CPUPlace)) – 位置列表。当PyReader可迭代时必须被提供
**代码示例**
.. code-block:: python
EPOCH_NUM = 3
ITER_NUM = 15
BATCH_SIZE = 3
def random_image_and_label_generator(height, width):
def generator():
for i in range(ITER_NUM):
fake_image = np.random.uniform(low=0,
high=255,
size=[height, width])
fake_label = np.ones([1])
yield fake_image, fake_label
return generator
image = fluid.layers.data(name='image', shape=[784, 784], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int32')
reader = fluid.io.PyReader(feed_list=[image, label], capacity=4, iterable=True)
user_defined_generator = random_image_and_label_generator(784, 784)
reader.decorate_sample_list_generator(
paddle.batch(user_defined_generator, batch_size=BATCH_SIZE),
fluid.core.CUDAPlace(0))
# 省略了网络的定义
executor = fluid.Executor(fluid.core.CUDAPlace(0))
executor.run(fluid.default_main_program())
for _ in range(EPOCH_NUM):
for data in reader():
executor.run(feed=data)
.. py:function:: decorate_batch_generator(reader, places=None)
.. py:method:: decorate_batch_generator(reader, places=None)
设置Pyreader对象的数据源。
......@@ -289,18 +506,54 @@ PyReader
- **reader** (generator) – 返回LoDTensor类型的批处理数据的Python生成器
- **places** (None|list(CUDAPlace)|list(CPUPlace)) – 位置列表。当PyReader可迭代时必须被提供
**代码示例**
.. code-block:: python
EPOCH_NUM = 3
ITER_NUM = 15
BATCH_SIZE = 3
def random_image_and_label_generator(height, width):
def generator():
for i in range(ITER_NUM):
batch_image = np.random.uniform(low=0,
high=255,
size=[BATCH_SIZE, height, width])
batch_label = np.ones([BATCH_SIZE, 1])
yield batch_image, batch_label
return generator
image = fluid.layers.data(name='image', shape=[784, 784], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int32')
reader = fluid.io.PyReader(feed_list=[image, label], capacity=4, iterable=True)
user_defined_generator = random_image_and_label_generator(784, 784)
reader.decorate_batch_generator(user_defined_generator, fluid.CUDAPlace(0))
# 省略了网络的定义
executor = fluid.Executor(fluid.CUDAPlace(0))
executor.run(fluid.default_main_program())
for _ in range(EPOCH_NUM):
for data in reader():
executor.run(feed=data)
.. _cn_api_fluid_io_save_inference_model:
save_inference_model
-------------------------------
.. py:function:: paddle.fluid.io.save_inference_model(dirname, feeded_var_names, target_vars, executor, main_program=None, model_filename=None, params_filename=None, export_for_deployment=True)
.. py:function:: paddle.fluid.io.save_inference_model(dirname, feeded_var_names, target_vars, executor, main_program=None, model_filename=None, params_filename=None, export_for_deployment=True, program_only=False)
修改指定的 ``main_program`` ，构建一个专门用于预测的 ``Program``，然后 ``executor`` 把它和所有相关参数保存到 ``dirname`` 中。
``dirname`` 用于指定保存变量的目录。如果变量保存在指定目录的若干文件中，设置文件名 None; 如果所有变量保存在一个文件中，请使用filename来指定它。
如果您仅想保存您训练好的模型的参数，请使用save_params API。更多细节请参考 :ref:`api_guide_model_save_reader` 。
参数:
- **dirname** (str) – 保存预测model的路径
- **feeded_var_names** (list[str]) – 预测（inference）需要 feed 的数据
......@@ -310,6 +563,7 @@ save_inference_model
- **model_filename** (str|None) – 保存预测Program 的文件名称。如果设置为None，将使用默认的文件名为： ``__model__``
- **params_filename** (str|None) – 保存所有相关参数的文件名称。如果设置为None，则参数将保存在单独的文件中。
- **export_for_deployment** (bool) – 如果为真，Program将被修改为只支持直接预测部署的Program。否则，将存储更多的信息，方便优化和再训练。目前只支持True。
- **program_only** (bool) – 如果为真，将只保存预测程序，而不保存程序的参数。
返回: 获取的变量名列表
......@@ -323,14 +577,30 @@ save_inference_model
.. code-block:: python
exe = fluid.Executor(fluid.CPUPlace())
import paddle.fluid as fluid
path = "./infer_model"
fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'],
target_vars=[predict_var], executor=exe)
# 在这个示例中，函数将修改默认的主程序让它适合于推断‘predict_var’。修改的
# 预测Program 将被保存在 ./infer_model/__model__”中。
# 和参数将保存在文件夹下的单独文件中 ./infer_mode
# 用户定义网络，此处以softmax回归为例
image = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
feeder = fluid.DataFeeder(feed_list=[image, label], place=fluid.CPUPlace())
predict = fluid.layers.fc(input=image, size=10, act='softmax')
loss = fluid.layers.cross_entropy(input=predict, label=label)
avg_loss = fluid.layers.mean(loss)
exe = fluid.Executor(fluid.CPUPlace())
exe.run(fluid.default_startup_program())
# 数据输入及训练过程
# 保存预测模型。注意我们不在这个示例中保存标签和损失。
fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'], target_vars=[predict], executor=exe)
# 在这个示例中，函数将修改默认的主程序让它适合于预测‘predict_var’
# 修改的预测Program 将被保存在 ./infer_model/__model__”中。
# 参数将保存在文件夹下的单独文件中 ./infer_mode
......@@ -350,7 +620,7 @@ save_params
``dirname`` 用于指定保存变量的目标目录。如果想将变量保存到多个独立文件中，设置 ``filename`` 为 None; 如果想将所有变量保存在单个文件中，请使用 ``filename`` 来指定该文件的命名。
注意:有些变量不是参数，但它们对于训练是必要的。因此，调用 ``save_params()`` 和 ``load_params()`` 来保存和加载参数是不够的，可以使用 ``save_persistables()`` 和 ``load_persistables()`` 代替这两个函数。
注意:有些变量不是参数，但它们对于训练是必要的。因此，调用 ``save_params()`` 和 ``load_params()`` 来保存和加载参数是不够的，可以使用 ``save_persistables()`` 和 ``load_persistables()`` 代替这两个函数。如果您想要储存您的模型用于预测，请使用save_inference_model API。更多细节请参考 :ref:`api_guide_model_save_reader`。
参数:
......@@ -403,6 +673,8 @@ save_persistables
.. code-block:: python
import paddle.fluid as fluid
exe = fluid.Executor(fluid.CPUPlace())
param_path = "./my_paddle_model"
prog = fluid.default_main_program()
......@@ -447,7 +719,19 @@ save_vars
.. code-block:: python
exe = fluid.Executor(fluid.CPUPlace())
import paddle.fluid as fluid
main_prog = fluid.Program()
startup_prog = fluid.Program()
with fluid.program_guard(main_prog, startup_prog):
data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
w = fluid.layers.create_parameter(shape=[784, 200], dtype='float32', name='fc_w')
b = fluid.layers.create_parameter(shape=[200], dtype='float32', name='fc_b')
hidden_w = fluid.layers.matmul(x=data, y=w)
hidden_b = fluid.layers.elementwise_add(hidden_w, b)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(startup_prog)
param_path = "./my_paddle_model"
# 第一种用法:用main_program来指定变量。
......@@ -455,19 +739,18 @@ save_vars
res = "fc" in var.name
return res
prog = fluid.default_main_program()
fluid.io.save_vars(executor=exe, dirname=path, main_program=prog,
vars=None, predicate = name_has_fc)
fluid.io.save_vars(executor=exe, dirname=param_path, main_program=main_prog, vars=None, predicate = name_has_fc)
# 将main_program中名中包含“fc”的的所有变量保存。
# 变量将分开保存。
# 第二种用法: 用vars来指定变量。
var_list = [var_a, var_b, var_c]
var_list = [w, b]
path = "./my_paddle_vars"
fluid.io.save_vars(executor=exe, dirname=path, vars=var_list,
filename="vars_file")
# var_a，var_b和var_c将被保存。 他们将使用同一文件，名为“var_file”，保存在路径“./my_paddle_model”下。
# var_a，var_b和var_c将被保存。
#他们将使用同一文件，名为“var_file”，保存在路径“./my_paddle_vars”下。
......
doc/fluid/api_cn/layers_cn.rst
浏览文件 @ 9a601dd2
仅显示部分。点此显示全部。
......@@ -35,6 +35,7 @@ array_length
.. code-block:: python
import paddle.fluid as fluid
tmp = fluid.layers.zeros(shape=[10], dtype='int32')
i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
arr = fluid.layers.array_write(tmp, i=i)
......@@ -79,6 +80,7 @@ array_read
.. code-block:: python
import paddle.fluid as fluid
array = fluid.layers.create_array(dtype='float32')
i = fluid.layers.fill_constant(shape=[1],dtype='int64',value=10)
item = fluid.layers.array_read(array, i)
......@@ -115,6 +117,7 @@ array_write
.. code-block:: python
import paddle.fluid as fluid
tmp = fluid.layers.zeros(shape=[10], dtype='int32')
i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
arr = fluid.layers.array_write(tmp, i=i)
......@@ -175,14 +178,23 @@ DynamicRNN
必须设置输入lod，请参考 ``lod_tensor``
动态RNN将按照timesteps展开开序列。用户需要在with block中定义如何处理处理每个timestep。
memory用于缓存分段数据。memory的初始值可以是零，也可以是其他变量。
动态RNN可以将多个变量标记为其输出。使用drnn()获得输出序列。
.. note::
目前不支持在DynamicRNN中任何层上配置 is_sparse = True
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name='sentence', dtype='int64', lod_level=1)
embedding = fluid.layers.embedding(input=data, size=[65535, 32],
is_sparse=True)
sentence = fluid.layers.data(name='sentence', shape=[1], dtype='int64', lod_level=1)
embedding = fluid.layers.embedding(input=sentence, size=[65536, 32], is_sparse=True)
drnn = fluid.layers.DynamicRNN()
with drnn.block():
......@@ -192,37 +204,55 @@ DynamicRNN
drnn.update_memory(prev, hidden) # set prev to hidden
drnn.output(hidden)
# last是的最后一时间步，也是编码（encoding）得出的最终结果
last = fluid.layers.sequence_last_step(drnn())
动态RNN将按照timesteps展开开序列。用户需要在with block中定义如何处理处理每个timestep。
memory用于缓存分段数据。memory的初始值可以是零，也可以是其他变量。
动态RNN可以将多个变量标记为其输出。使用drnn()获得输出序列。
# 获得上一个timestep的rnn，该值是一个编码后的结果
rnn_output = drnn()
last = fluid.layers.sequence_last_step(rnn_output)
.. note::
目前不支持在DynamicRNN中任何层上配置 is_sparse = True
.. py:method:: step_input(x, level=0)
将序列标记为动态RNN输入。
参数:
- **x** (Variable) - 输入序列
- **x** (Variable) - 含lod信息的输入序列
- **level** (int) - 用于拆分步骤的LOD层级，默认值0
返回:当前的输入序列中的timestep。
.. py:method:: static_input(x)
将变量标记为RNN输入。输入不会分散到timestep中。
将变量标记为RNN输入。输入不会分散到timestep中。为可选项。
参数:
- **x** (Variable) - 输入序列
返回:可以访问的RNN的输入变量,。
返回:可以访问的RNN的输入变量。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
sentence = fluid.layers.data(name='sentence', dtype='float32', shape=[32], lod_level=1)
encoder_proj = fluid.layers.data(name='encoder_proj', dtype='float32', shape=[32], lod_level=1)
decoder_boot = fluid.layers.data(name='boot', dtype='float32', shape=[10], lod_level=1)
drnn = fluid.layers.DynamicRNN()
with drnn.block():
current_word = drnn.step_input(sentence)
encoder_word = drnn.static_input(encoder_proj)
hidden_mem = drnn.memory(init=decoder_boot, need_reorder=True)
fc_1 = fluid.layers.fc(input=encoder_word, size=30, bias_attr=False)
fc_2 = fluid.layers.fc(input=current_word, size=30, bias_attr=False)
decoder_inputs = fc_1 + fc_2
h, _, _ = fluid.layers.gru_unit(input=decoder_inputs, hidden=hidden_mem, size=30)
drnn.update_memory(hidden_mem, h)
out = fluid.layers.fc(input=h, size=10, bias_attr=True, act='softmax')
drnn.output(out)
rnn_output = drnn()
.. py:method:: block()
......@@ -232,24 +262,22 @@ memory用于缓存分段数据。memory的初始值可以是零，也可以是
为动态rnn创建一个memory 变量。
如果 ``init`` 不是None， ``memory`` 将由这个变量初始化。参数 ``need_reorder`` 用于将memory重新排序作为输入变量。当memory初始化依赖于输入样本时，应该将其设置为true。
如果 ``init`` 不是None， ``memory`` 将由这个变量初始化。参数 ``need_reorder`` 用于将memory重新排序作为输入变量。当memory初始化依赖于输入样本时，应该将其设置为True。
**例如**
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
sentence = fluid.layers.data(
name='sentence', dtype='float32', shape=[32])
boot_memory = fluid.layers.data(
name='boot', dtype='float32', shape=[10])
sentence = fluid.layers.data(name='sentence', shape=[32], dtype='float32', lod_level=1)
boot_memory = fluid.layers.data(name='boot', shape=[10], dtype='float32', lod_level=1)
drnn = fluid.layers.DynamicRNN()
with drnn.block():
word = drnn.step_input(sentence)
memory = drnn.memory(init=boot_memory, need_reorder=True)
hidden = fluid.layers.fc(
input=[word, memory], size=10, act='tanh')
hidden = fluid.layers.fc(input=[word, memory], size=10, act='tanh')
drnn.update_memory(ex_mem=memory, new_mem=hidden)
drnn.output(hidden)
......@@ -259,27 +287,28 @@ memory用于缓存分段数据。memory的初始值可以是零，也可以是
否则，如果已经设置 ``shape`` 、 ``value`` 、 ``dtype`` ，memory将被 ``value`` 初始化
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
sentence = fluid.layers.data(
name='sentence', dtype='float32', shape=[32])
sentence = fluid.layers.data(name='sentence', dtype='float32', shape=[32], lod_level=1)
drnn = fluid.layers.DynamicRNN()
with drnn.block():
word = drnn.step_input(sentence)
memory = drnn.memory(shape=[10], dtype='float32', value=0)
hidden = fluid.layers.fc(
input=[word, memory], size=10, act='tanh')
hidden = fluid.layers.fc(input=[word, memory], size=10, act='tanh')
drnn.update_memory(ex_mem=memory, new_mem=hidden)
drnn.output(hidden)
rnn_output = drnn()
参数：
- **init** (Variable|None) – 初始化的Variable
- **shape** (list|tuple) – memory shape. 注意形状不包含batch_size
- **shape** (list|tuple) – memory shape，形状不包含batch_size
- **value** (float) – 初始化的值
- **need_reorder** (bool) – memory初始化依赖于输入样本时设置为True
- **dtype** (str|numpy.dtype) – 初始化memory的数据类型
......@@ -314,8 +343,6 @@ memory用于缓存分段数据。memory的初始值可以是零，也可以是
.. _cn_api_fluid_layers_equal:
equal
......@@ -339,12 +366,63 @@ equal
.. code-block:: python
import paddle.fluid as fluid
label = fluid.layers.data(name="label", shape=[3,10,32,32], dtype="float32")
limit = fluid.layers.data(name="limit", shape=[3,10,32,32], dtype="float32")
less = fluid.layers.equal(x=label,y=limit)
.. _cn_api_fluid_layers_greater_equal:
greater_equal
-------------------------------
.. py:function:: paddle.fluid.layers.greater_equal(x, y, cond=None)
该层逐元素地返回 :math:`x >= y` 的逻辑值，和重载算子 `>=` 相同。
参数：
- **x** (Variable) - *greater_equal* 的第一个操作数
- **y** (Variable) - *greater_equal* 的第二个操作数
- **cond** (Variable|None) - 可选的输出变量，存储 *greater_equal* 的结果
返回：存储 *greater_equal* 的输出的张量变量。
返回类型：变量（Variable）
**代码示例**:
.. code-block:: python
out = fluid.layers.greater_equal(x=label, y=limit)
.. _cn_api_fluid_layers_greater_than:
greater_than
-------------------------------
.. py:function:: paddle.fluid.layers.greater_than(x, y, cond=None)
该层逐元素地返回 :math:`x > y` 的逻辑值，和重载算子 `>` 相同。
参数：
- **x** (Variable) - *greater_than* 的第一个操作数
- **y** (Variable) - *greater_than* 的第二个操作数
- **cond** (Variable|None) - 可选的输出变量，存储 *greater_than* 的结果
返回：存储 *greater_than* 的输出的张量变量。
返回类型：变量（Variable）
**代码示例**:
.. code-block:: python
out = fluid.layers.greater_than(x=label, y=limit)
......@@ -366,6 +444,10 @@ if-else控制流。
.. code-block:: python
import paddle.fluid as fluid
image = fluid.layers.data(name="X", shape=[2, 5, 5], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
limit = fluid.layers.fill_constant_batch_size_like(
input=label, dtype='int64', shape=[1], value=5.0)
cond = fluid.layers.less_than(x=label, y=limit)
......@@ -418,6 +500,7 @@ increment
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name='data', shape=[1], dtype='float32',
append_batch_size=False)
data = fluid.layers.increment(x=data, value=3.0, in_place=True)
......@@ -455,14 +538,38 @@ is_empty
.. code-block:: python
import paddle.fluid as fluid
input = fluid.layers.data(name="input", shape=[4, 32, 32], dtype="float32")
res = fluid.layers.is_empty(x=input)
# or:
fluid.layers.is_empty(x=input, cond=res)
# fluid.layers.is_empty(x=input, cond=res)
.. _cn_api_fluid_layers_less_equal:
less_equal
-------------------------------
.. py:function:: paddle.fluid.layers.less_equal(x, y, cond=None)
该层逐元素地返回 :math:`x <= y` 的逻辑值，和重载算子 `<=` 相同。
参数：
- **x** (Variable) - *less_equal* 的第一个操作数
- **y** (Variable) - *less_equal* 的第二个操作数
- **cond** (Variable|None) - 可选的输出变量，存储 *less_equal* 的结果
返回：存储 *less_equal* 的输出的张量变量。
返回类型：变量（Variable）
**代码示例**:
.. code-block:: python
out = fluid.layers.less_equal(x=label, y=limit)
......@@ -478,12 +585,6 @@ less_than
该函数按元素出现顺序依次在X,Y上操作，并返回 ``Out`` ，它们三个都是n维tensor（张量）。
其中，X、Y可以是任何类型的tensor，Out张量的各个元素可以通过 :math:`Out=X<Y` 计算得出。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
less = fluid.layers.less_than(x=label, y=limit)
参数：
- **x** (Variable) – ``less_than`` 运算的左操作数
......@@ -494,12 +595,38 @@ less_than
返回： n维bool型tensor，其中各个元素可以通过 *Out=X<Y* 计算得出
**代码示例**:
.. code-block:: python
label = fluid.layers.data(name='y', shape=[1], dtype='int64')
limit = fluid.layers.fill_constant(shape=[1], dtype='int64', value=5)
cond = fluid.layers.less_than(x=label, y=limit)
.. _cn_api_fluid_layers_not_equal:
not_equal
-------------------------------
.. py:function:: paddle.fluid.layers.not_equal(x, y, cond=None)
该层逐元素地返回 :math:`x != y` 的逻辑值，和重载算子 `!=` 相同。
参数：
- **x** (Variable) - *not_equal* 的第一个操作数
- **y** (Variable) - *not_equal* 的第二个操作数
- **cond** (Variable|None) - 可选的输出变量，存储 *not_equal* 的结果
返回：存储 *not_equal* 的输出的张量变量。
返回类型：变量（Variable）
**代码示例**:
.. code-block:: python
out = fluid.layers.not_equal(x=label, y=limit)
......@@ -530,17 +657,24 @@ Print
- **print_tensor_lod** (bool)-打印张量lod
- **print_phase** (str)-打印的阶段，包括 ``forward`` , ``backward`` 和 ``both`` .若设置为 ``backward`` 或者 ``both`` ,则打印输入张量的梯度。
返回：输出张量，和输入张量同样的数据
返回：输出张量
返回类型：变量（Variable）
.. note::
输入和输出是两个不同的变量，在接下来的过程中，你应该使用输出变量而非输入变量，否则打印层将失去输出层前的信息。
**代码示例**：
.. code-block:: python
value = some_layer(...)
Print(value, summarize=10,
message="The content of some_layer: ")
import paddle.fluid as fluid
input = fluid.layers.data(name="input", shape=[4, 32, 32], dtype="float32")
input = fluid.layers.Print(input, message = "The content of input layer:")
# value = some_layer(...)
# Print(value, summarize=10,
# message="The content of some_layer: ")
......@@ -558,8 +692,8 @@ reorder_lod_tensor_by_rank
.. py:function:: paddle.fluid.layers.reorder_lod_tensor_by_rank(x, rank_table)
函数参数 ``X`` 是由多个序列(sequence)组成的的一个batch（数据批）。``rank_table`` 存储着batch中序列的重新排列规则。
该operator（算子）根据 ``rank_table`` 中提供的规则信息来实现对 ``X`` 的重新排列。
函数参数 ``X`` 是由多个序列(sequence)组成的的一个数据批(batch）。``rank_table`` 存储着batch中序列的重新排列规则。
该算子(operator）根据 ``rank_table`` 中提供的规则信息来实现对 ``X`` 的重新排列。
::
......@@ -568,25 +702,32 @@ reorder_lod_tensor_by_rank
假设在 RankTable 中存储的序列索引为 [3,0,2,1]， X 将会被这样被重新排列：
X 中的第四个序列（即索引为3的序列，后面以此类推）会变成排列后的batch中的第一个，紧接着就是原来batch中的第一个元素，第三个元素，和第二个元素。
简言之，若有原batch：X = [Seq0, Seq1, Seq2, Seq3] 且 RankTable 中的索引为 [3,0,2,1]，那么输出即为 Out = [Seq3, Seq0, Seq2, Seq1] ，它携带着新的LoD信息。
如果 X 的LoD信息是空的，这表明 X 不是序列型数据。这和由多个定长为1的序列组成的batch是相同的情况。此时，该函数将对 X 中的切片（slice） 在第一轴(axis)上按 rank_table 里的规则加以排列。
例如，现有 X = [Slice0, Slice1, Slice2, Slice3] ，并且它LoD信息为空，在 RankTable 索引为[3, 0, 2, 1]。则 Out = [Slice3, Slice0, Slice2, Slice1] ，并且不在其中追加LoD信息。
注意，该operator对 ``X`` 进行的排序所依据的 ``LoDRankTable`` 不一定是在 ``X`` 的基础上得出来的。它可以由
其他不同的序列batch得出，并由该operator依据这个 ``LoDRankTable`` 来对 ``X`` 排序。
注意，该operator对 ``X`` 进行的排序所依据的 ``LoDRankTable`` 不一定是在 ``X`` 的基础上得出来的。它可以由其他不同的序列得出，并由该operator依据这个 ``LoDRankTable`` 来对 ``X`` 排序。
参数：
- **x** (LoDTensor)-待根据提供的 ``RankTable`` 进行排序的LoD tensor
- **rank_table** (LoDRankTable)- ``X`` 重新排序的依据规则表
- **x(Variable)** - (LoDTensor)，待根据提供的 ``RankTable`` 进行排序的LoD tensor
- **rank_table(Variable)** - 变量
返回： 重新排列后的LoDTensor
返回类型: LoDTensor
返回类型: out(Variable)
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data_desc = (['input', [9], 0], ['ref', [5], 1])
data = fluid.layers.data(name=data_desc[0][0], shape=data_desc[0][1])
rank_data = fluid.layers.data(name=data_desc[1][0], shape=data_desc[1][1])
table = fluid.layers.control_flow.lod_rank_table(rank_data)
new_data = fluid.layers.reorder_lod_tensor_by_rank(
x=data, rank_table=table)
......@@ -604,20 +745,125 @@ StaticRNN
.. py:class:: paddle.fluid.layers.StaticRNN(name=None)
StaticRNN可以处理一批序列数据。每个样本序列的长度必须相等。StaticRNN将拥有自己的参数，如输入、输出和存储器等。请注意，输入的第一个维度表示序列长度，且输入的所有序列长度必须相同。并且输入和输出的每个轴的含义是相同的。
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
import paddle.fluid.layers as layers
vocab_size, hidden_size=10000, 200
x = layers.data(name="x", shape=[-1, 1, 1], dtype='int64')
x_emb = layers.embedding(
input=x,
size=[vocab_size, hidden_size],
dtype='float32',
is_sparse=False)
x_emb = layers.transpose(x_emb, perm=[1, 0, 2])
rnn = fluid.layers.StaticRNN()
with rnn.step():
word = rnn.step_input(x_emb)
prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word)
hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu')
rnn.update_memory(prev, hidden) # set prev to hidden
rnn.step_output(hidden)
result = rnn()
StaticRNN将序列展开为时间步长。用户需要定义如何在with步骤中处理每个时间步长。
内存用作在time step之间缓存数据。内存的初始值可以是填充常量值的变量或指定变量。
StaticRNN可以将多个变量标记为其输出。使用rnn()获取输出序列。
.. py:method:: step()
用户在该代码块中定义RNN中的operators。
用于创建static RNN。RNN将有自己的参数，比如输入、输出、memory、状态和长度。
.. py:method:: memory(init=None, shape=None, batch_ref=None, init_value=0.0, init_batch_dim_idx=0, ref_batch_dim_idx=1)
参数：
- **init** - boot memory，如果没有设置，则必须提供一个shape
- **shape** - boot memory的形状
- **batch_ref** - batch引用
- **init_value** - boot memory的初始化值
- **init_batch_dim_idx** - init维度中的batch大小的索引
- **ref_batch_dim_idx** - batch_ref维度中的batch大小的索引
为静态RNN创建一个内存变量。
如果init不为None，则此变量将初始化内存。 如果init为None，则必须设置shape和batch_ref，并且此函数将初始化init变量。
参数：
- **init** (Variable|None) - 初始化过的变量，如果没有设置，则必须提供shape和batch_ref，默认值None
- **shape** (list|tuple) - boot memory的形状，注意其不包括batch_size，默认值None
- **batch_ref** (Variable|None) - batch引用变量，默认值None
- **init_value** (float) - boot memory的初始化值，默认值0.0
- **init_batch_dim_idx** (int) - init变量的batch_size轴，默认值0
- **ref_batch_dim_idx** (int) - batch_ref变量的batch_size轴
返回：内存变量
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
import paddle.fluid.layers as layers
vocab_size, hidden_size=10000, 200
x = layers.data(name="x", shape=[-1, 1, 1], dtype='int64')
x_emb = layers.embedding(
input=x,
size=[vocab_size, hidden_size],
dtype='float32',
is_sparse=False)
x_emb = layers.transpose(x_emb, perm=[1, 0, 2])
rnn = fluid.layers.StaticRNN()
with rnn.step():
word = rnn.step_input(x_emb)
prev = rnn.memory(shape=[-1, hidden_size], batch_ref = word)
hidden = fluid.layers.fc(input=[word, prev], size=hidden_size, act='relu')
rnn.update_memory(prev, hidden)
.. py:method:: step_input(x)
标记作为StaticRNN输入的序列。
参数：
- **x** (Variable) – 输入序列，x的形状应为[seq_len, ...]。
返回：输入序列中的当前时间步长。
.. py:method:: step_output(o)
标记作为StaticRNN输出的序列。
参数：
-**o** (Variable) – 输出序列
返回：None
.. py:method:: output(*outputs)
标记StaticRNN输出变量。
参数：
-**outputs** – 输出变量
返回：None
.. py:method:: update_memory(mem, var)
将内存从ex_mem更新为new_mem。请注意，ex_mem和new_mem的形状和数据类型必须相同。
参数：
- **mem** (Variable) – 内存变量
- **var** (Variable) – RNN块中产生的普通变量
返回：None
......@@ -647,31 +893,30 @@ Switch类实现的功能十分类似if-elif-else。它可以在学习率调度
.. code-block:: python
lr = fluid.layers.tensor.create_global_var(
import paddle.fluid as fluid
lr = fluid.layers.create_global_var(
shape=[1],
value=0.0,
dtype='float32',
persistable=True,
name="learning_rate")
one_var = tensor.fill_constant(
zero_var = fluid.layers.fill_constant(
shape=[1], dtype='float32', value=0.0)
one_var = fluid.layers.fill_constant(
shape=[1], dtype='float32', value=1.0)
two_var = tensor.fill_constant(
two_var = fluid.layers.fill_constant(
shape=[1], dtype='float32', value=2.0)
global_step = fluid.layers.autoincreased_step_counter(
counter_name='@LR_DECAY_COUNTER@', begin=0, step=1)
with fluid.layers.control_flow.Switch() as switch:
with switch.case(global_step == zero_var):
fluid.layers.tensor.assign(input=one_var, output=lr)
fluid.layers.assign(input=one_var, output=lr)
with switch.default():
fluid.layers.tensor.assign(input=two_var, output=lr)
fluid.layers.assign(input=two_var, output=lr)
.. py:method:: case(condition)
为该condition（情况，条件）建立新的block（块）。
.. py:method:: default()
为该switch建立default case。
......@@ -704,6 +949,9 @@ While
.. code-block:: python
import paddle.fluid as fluid
i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=0)
d0 = fluid.layers.data("d0", shape=[10], dtype='float32')
data_array = fluid.layers.array_write(x=d0, i=i)
array_len = fluid.layers.fill_constant(shape=[1],dtype='int64', value=3)
......@@ -712,9 +960,9 @@ While
while_op = fluid.layers.While(cond=cond)
with while_op.block():
d = fluid.layers.array_read(array=data_array, i=i)
i = fluid.layers.increment(x=i, in_place=True)
layers.array_write(result, i=i, array=d)
layers.less_than(x=i, y=array_len, cond=cond)
i = fluid.layers.increment(x=i, value=1, in_place=True)
fluid.layers.less_than(x=i, y=array_len, cond=cond)
......@@ -754,7 +1002,7 @@ batch
raw_reader = fluid.layers.io.open_files(filenames=['./data1.recordio',
'./data2.recordio'],
shapes=[(3,224,224), (1)],
shapes=[(3,224,224), (1,)],
lod_levels=[0, 0],
dtypes=['float32', 'int64'],
thread_num=2,
......@@ -802,16 +1050,24 @@ create_py_reader_by_data
.. code-block:: python
import paddle
import paddle.fluid as fluid
import paddle.dataset.mnist as mnist
image = fluid.layers.data(name='image', shape=[3,224,224], dtypes='float32')
def network(img, label):
# 用户自定义网络。此处以一个简单的线性回归作为示例。
predict = fluid.layers.fc(input=img, size=10, act='softmax')
loss = fluid.layers.cross_entropy(input=predict, label=label)
return fluid.layers.mean(loss)
image = fluid.layers.data(name='image', shape=[1, 28, 28], dtypes='float32')
label = fluid.layers.data(name='label', shape=[1], dtypes='int64')
reader = fluid.layers.create_py_reader_by_data(capacity=64, feed_list=[image, label])
reader = fluid.layers.create_py_reader_by_data(capacity=64,
feed_list=[image, label])
reader.decorate_paddle_reader(
paddle.reader.shuffle(paddle.batch(mnist.train())
paddle.reader.shuffle(paddle.batch(mnist.train(), batch_size=5), buf_size=500))
img, label = fluid.layers.read_file(reader)
loss = network(img, label) # some network definition
loss = network(img, label) # 一些网络定义
fluid.Executor(fluid.CUDAPlace(0)).run(fluid.default_startup_program())
......@@ -847,18 +1103,20 @@ data
这个函数的所有输入变量都作为本地变量传递给LayerHelper构造函数。
请注意，paddle在编译期间仅使用shape来推断网络中以下变量的形状。在运行期间，paddle不会检查所需数据的形状是否与此函数中的形状设置相匹配。
参数：
- **name** (str)-函数名或函数别名
- **shape** (list)-声明维度信息的list。如果 ``append_batch_size`` 为True且内部没有维度值为-1，则应将其视为每个样本的形状。 否则，应将其视为batch数据的形状。
- **append_batch_size** (bool)-
1.如果为真，则在维度shape的开头插入-1
“如果shape=[1],则输出shape为[-1,1].”
1.如果为真，则在维度shape的开头插入-1。
例如，如果shape=[1],则输出shape为[-1,1]。这对在运行期间设置不同的batch大小很有用。
2.如果维度shape包含-1，比如shape=[-1,1],
“append_batch_size则为False（表示无效）”
2.如果维度shape包含-1，比如shape=[-1,1]。
append_batch_size会强制变为为False（表示无效），因为PaddlePaddle不能在shape上设置一个以上的未知数。
- **dtype** (basestring)-数据类型：float32,float_16,int等
- **dtype** (np.dtype|VarType|str)-数据类型：float32,float_16,int等
- **type** (VarType)-输出类型。默认为LOD_TENSOR
- **lod_level** (int)-LoD层。0表示输入数据不是一个序列
- **stop_gradient** (bool)-布尔类型，提示是否应该停止计算梯度
......@@ -905,7 +1163,8 @@ double_buffer
.. code-block:: python
reader = fluid.layers.open_files(filenames=['somefile'],
import paddle.fluid as fluid
reader = fluid.layers.open_files(filenames=['mnist.recordio'],
shapes=[[-1, 784], [-1, 1]],
dtypes=['float32', 'int64'])
reader = fluid.layers.double_buffer(reader)
......@@ -981,9 +1240,10 @@ open_files
.. code-block:: python
import paddle.fluid as fluid
reader = fluid.layers.io.open_files(filenames=['./data1.recordio',
'./data2.recordio'],
shapes=[(3,224,224), (1)],
shapes=[(3,224,224), (1,)],
lod_levels=[0, 0],
dtypes=['float32', 'int64'])
......@@ -1015,6 +1275,12 @@ reader变量中数据预处理块。
.. code-block:: python
reader = fluid.layers.io.open_files(
filenames=['./data1.recordio', './data2.recordio'],
shapes=[(3, 224, 224), (1, )],
lod_levels=[0, 0],
dtypes=['float32', 'int64'])
preprocessor = fluid.layers.io.Preprocessor(reader=reader)
with preprocessor.block():
img, lbl = preprocessor.inputs()
......@@ -1041,11 +1307,11 @@ py_reader
创建一个由在Python端提供数据的reader
该layer返回一个Reader Variable。reader提供了 ``decorate_paddle_reader()`` 和 ``decorate_tensor_provider()`` 来设置Python generator，作为Python端的数据源。在c++端调用 ``Executor::Run()`` 时，来自generator的数据将被自动读取。与 ``DataFeeder.feed()`` 不同，数据读取进程和 ``Executor::Run()`` 进程可以使用 ``py_reader`` 并行运行。reader的 ``start()`` 方法应该在每次数据传递开始时调用，在传递结束和抛出 ``fluid.core.EOFException`` 后执行 ``reset()`` 方法。注意， ``Program.clone()`` 方法不能克隆 ``py_reader`` 。
该layer返回一个Reader Variable。reader提供了 ``decorate_paddle_reader()`` 和 ``decorate_tensor_provider()`` 来设置Python generator作为数据源。更多细节请参考异步数据读取:ref:`user_guide_use_py_reader`，在c++端调用 ``Executor::Run()`` 时，来自generator的数据将被自动读取。与 ``DataFeeder.feed()`` 不同，数据读取进程和 ``Executor::Run()`` 进程可以使用 ``py_reader`` 并行运行。reader的 ``start()`` 方法应该在每次数据传递开始时调用，在传递结束和抛出 ``fluid.core.EOFException`` 后执行 ``reset()`` 方法。注意， ``Program.clone()`` 方法不能克隆 ``py_reader`` 。
参数:
- **capacity** (int) – ``py_reader`` 维护的缓冲区容量
- **shapes** (list|tuple) –数据形状的元组或列表.
- **shapes** (list|tuple) –数据形状的元组或列表
- **dtypes** (list|tuple) – ``shapes`` 对应元素的数据类型
- **lod_levels** (list|tuple) – lod_level的整型列表或元组
- **name** (basestring) – python 队列的前缀名称和Reader 名称。不会自动生成。
......@@ -1059,7 +1325,7 @@ py_reader
**代码示例**
1.py_reader 基本使用如下代码
1.py_reader 基本用法如下
.. code-block:: python
......@@ -1067,11 +1333,16 @@ py_reader
import paddle.fluid as fluid
import paddle.dataset.mnist as mnist
def network(image, label):
# 用户自定义网络，此处以softmax回归为例
predict = fluid.layers.fc(input=image, size=10, act='softmax')
return fluid.layers.cross_entropy(input=predict, label=label)
reader = fluid.layers.py_reader(capacity=64,
shapes=[(-1,3,224,224), (-1,1)],
shapes=[(-1,1, 28, 28), (-1,1)],
dtypes=['float32', 'int64'])
reader.decorate_paddle_reader(
paddle.reader.shuffle(paddle.batch(mnist.train())
paddle.reader.shuffle(paddle.batch(mnist.train(), batch_size=5),buf_size=1000))
img, label = fluid.layers.read_file(reader)
loss = network(img, label) # 一些网络定义
......@@ -1087,7 +1358,7 @@ py_reader
except fluid.core.EOFException:
reader.reset()
fluid.io.save_inference_model(dirname='./model', feeded_var_names=[img, label],target_vars=[loss], executor=fluid.Executor(fluid.CUDAPlace(0)))
fluid.io.save_inference_model(dirname='./model', feeded_var_names=[img.name, label.name],target_vars=[loss], executor=fluid.Executor(fluid.CUDAPlace(0)))
2.训练和测试应使用不同的名称创建两个不同的py_reader，例如：
......@@ -1100,21 +1371,12 @@ py_reader
def network(reader):
img, label = fluid.layers.read_file(reader)
# 此处我们省略了一些网络定义
return loss
# 用户自定义网络，此处以softmax回归为例
predict = fluid.layers.fc(input=img, size=10, act='softmax')
train_reader = fluid.layers.py_reader(capacity=64,
shapes=[(-1,3,224,224), (-1,1)],
dtypes=['float32', 'int64'],
name='train_reader')
train_reader.decorate_paddle_reader(
paddle.reader.shuffle(paddle.batch(mnist.train())
loss = fluid.layers.cross_entropy(input=predict, label=label)
test_reader = fluid.layers.py_reader(capacity=32,
shapes=[(-1,3,224,224), (-1,1)],
dtypes=['float32', 'int64'],
name='test_reader')
test_reader.decorate_paddle_reader(paddle.batch(mnist.test(), 512))
return fluid.layers.mean(loss)
# 新建 train_main_prog 和 train_startup_prog
train_main_prog = fluid.Program()
......@@ -1122,9 +1384,12 @@ py_reader
with fluid.program_guard(train_main_prog, train_startup_prog):
# 使用 fluid.unique_name.guard() 实现与test program的参数共享
with fluid.unique_name.guard():
train_reader = fluid.layers.py_reader(capacity=64, shapes=[(-1, 1, 28, 28), (-1, 1)], dtypes=['float32', 'int64'], name='train_reader')
train_reader.decorate_paddle_reader(
paddle.reader.shuffle(paddle.batch(mnist.train(), batch_size=5), buf_size=500))
train_loss = network(train_reader) # 一些网络定义
adam = fluid.optimizer.Adam(learning_rate=0.01)
adam.minimize(loss)
adam.minimize(train_loss)
# Create test_main_prog and test_startup_prog
test_main_prog = fluid.Program()
......@@ -1132,6 +1397,9 @@ py_reader
with fluid.program_guard(test_main_prog, test_startup_prog):
# 使用 fluid.unique_name.guard() 实现与train program的参数共享
with fluid.unique_name.guard():
test_reader = fluid.layers.py_reader(capacity=32, shapes=[(-1, 1, 28, 28), (-1, 1)], dtypes=['float32', 'int64'], name='test_reader')
test_reader.decorate_paddle_reader(paddle.batch(mnist.test(), 512))
test_loss = network(test_reader)
fluid.Executor(fluid.CUDAPlace(0)).run(train_startup_prog)
......@@ -1231,6 +1499,7 @@ reader也是变量。可以为由fluid.layers.open_files()生成的原始reader
.. code-block:: python
import paddle.fluid as fluid
data_file = fluid.layers.open_files(
filenames=['mnist.recordio'],
shapes=[(-1, 748), (-1, 1)],
......@@ -1266,9 +1535,19 @@ shuffle
返回类型:Variable
**代码示例**：
.. code-block:: python
raw_reader = fluid.layers.io.open_files(filenames=['./data1.recordio',
'./data2.recordio'],
shapes=[(3,224,224), (1,)],
lod_levels=[0, 0],
dtypes=['float32', 'int64'],
thread_num=2,
buffer_size=2)
batch_reader = fluid.layers.batch(reader=raw_reader, batch_size=5)
shuffle_reader = fluid.layers.shuffle(reader=batch_reader, buffer_size=5000)
......@@ -1417,8 +1696,11 @@ pooling3d操作根据输入 ``input`` ，``pool_size`` ， ``pool_type`` 参数
# output[:, :, i, j, k] =
# avg(input[:, :, dstart:dend, hstart: hend, wstart: wend])
#
import paddle.fluid as fluid
data = fluid.layers.data(
name='data', shape=[3, 32, 32], dtype='float32')
name='data', shape=[3, 32, 32, 32], dtype='float32')
pool_out, mask = fluid.layers.adaptive_pool3d(
input=data,
pool_size=[3, 3, 3],
......@@ -1465,7 +1747,15 @@ add_position_encoding
.. code-block:: python
position_tensor = fluid.layers.add_position_encoding(input=tensor)
import paddle.fluid as fluid
tensor = fluid.layers.data(
name='tensor',
shape=[32, 64, 512],
dtype='float32',
append_batch_size=False)
position_tensor = fluid.layers.add_position_encoding(
input=tensor, alpha=1.0, beta=1.0)
......@@ -1498,9 +1788,19 @@ affine_channel
返回： out (Variable): 与x具有相同形状和数据布局的张量。
**代码示例：**
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name='data', shape=[3, 32, 32],
dtype='float32')
input_scale = fluid.layers.create_parameter(shape=[3],
dtype="float32")
input_bias = fluid.layers.create_parameter(shape=[3],
dtype="float32")
out = fluid.layers.affine_channel(data,scale=input_scale,
bias=input_bias)
......@@ -1598,6 +1898,7 @@ affine_grid
.. code-block:: python
import paddle.fluid as fluid
theta = fluid.layers.data(name="x", shape=[2, 3], dtype="float32")
out_shape = fluid.layers.data(name="y", shape=[-1], dtype="float32")
data = fluid.layers.affine_grid(theta, out_shape)
......@@ -1635,7 +1936,7 @@ autoincreased_step_counter
.. code-block:: python
global_step = fluid.layers.autoincreased_step_counter(
counter_name='@LR_DECAY_COUNTER@', begin=begin, step=1)
counter_name='@LR_DECAY_COUNTER@', begin=0, step=1)
......@@ -1690,8 +1991,8 @@ batch_norm
- **data_layout** （string,默认NCHW) - NCHW|NHWC
- **in_place** （bool，默认False）- 得出batch norm可复用记忆的输入和输出
- **name** （string，默认None）- 该层名称（可选）。若设为None，则自动为该层命名
- **moving_mean_name** （string，默认None）- moving_mean的名称，存储全局Mean
- **moving_variance_name** （string，默认None）- moving_variance的名称，存储全局变量
- **moving_mean_name** （string，默认None）- moving_mean的名称，存储全局Mean。如果将其设置为None, ``batch_norm``将随机命名全局平均值；否则， `batch_norm`将命名全局平均值为``moving_mean_name``
- **moving_variance_name** （string，默认None）- moving_variance的名称，存储全局变量。如果将其设置为None,``batch_norm``将随机命名全局方差；否则， `batch_norm`将命名全局方差为``moving_mean_name``
- **do_model_average_for_mean_and_var** （bool，默认False）- 是否为mean和variance做模型均值
- **fuse_with_relu** （bool）- 如果为True，batch norm后该操作符执行relu
- **use_global_stats** （bool, Default False） – 是否使用全局均值和方差。 在预测或测试模式下，将use_global_stats设置为true或将is_test设置为true，并且行为是等效的。 在训练模式中，当设置use_global_stats为True时，在训练期间也使用全局均值和方差。
......@@ -1704,6 +2005,7 @@ batch_norm
.. code-block:: python
x = fluid.layers.data(name='x', shape=[3, 7, 3, 7], dtype='float32', append_batch_size=False)
hidden1 = fluid.layers.fc(input=x, size=200, param_attr='fc1.w')
hidden2 = fluid.layers.batch_norm(input=hidden1)
......@@ -1759,12 +2061,22 @@ beam_search
.. code-block:: python
import paddle.fluid as fluid
# 假设 `probs` 包含计算神经元所得的预测结果
# `pre_ids` 和 `pre_scores` 为beam_search之前时间步的输出
beam_size = 4
end_id = 1
pre_ids = fluid.layers.data(
name='pre_id', shape=[1], lod_level=2, dtype='int64')
pre_scores = fluid.layers.data(
name='pre_scores', shape=[1], lod_level=2, dtype='float32')
probs = fluid.layers.data(
name='probs', shape=[10000], dtype='float32')
topk_scores, topk_indices = fluid.layers.topk(probs, k=beam_size)
accu_scores = fluid.layers.elementwise_add(
x=layers.log(x=topk_scores)),
y=layers.reshape(
x=fluid.layers.log(x=topk_scores)),
y=fluid.layers.reshape(
pre_scores, shape=[-1]),
axis=0)
selected_ids, selected_scores = fluid.layers.beam_search(
......@@ -1814,8 +2126,12 @@ beam_search_decode
.. code-block:: python
import paddle.fluid as fluid
# 假设 `ids` 和 `scores` 为 LodTensorArray变量，它们保留了
# 选择出的所有时间步的id和score
ids = fluid.layers.create_array(dtype='int64')
scores = fluid.layers.create_array(dtype='float32')
finished_ids, finished_scores = fluid.layers.beam_search_decode(
ids, scores, beam_size=5, end_id=0)
......@@ -1863,7 +2179,9 @@ bilinear_tensor_product
.. code-block:: python
tensor = bilinear_tensor_product(x=layer1, y=layer2, size=1000)
layer1 = fluid.layers.data("t1", shape=[-1, 5], dtype="float32")
layer2 = fluid.layers.data("t2", shape=[-1, 4], dtype="float32")
tensor = fluid.layers.bilinear_tensor_product(x=layer1, y=layer2, size=1000)
......@@ -1876,20 +2194,20 @@ bpr_loss
.. py:function:: paddle.fluid.layers.bpr_loss(input, label, name=None)
Bayesian Personalized Ranking Loss Operator. (贝叶斯个性化排序损失计算)
贝叶斯个性化排序损失计算（Bayesian Personalized Ranking Loss Operator ）
该算子属于pairwise的排序类型，其标签是期望物品。在某次会话中某一给定点的损失值由下式计算而得:
.. math::
Y[i] = -\frac{1}{N_{i}-1} * \sum_{0\le j<N_{i},~ j\neq Label[i]}\log(\sigma(X[i, Label[i]]-X[i, j]))
\[Y[i] = 1/(N[i] - 1) * \sum_j{\log(\sigma(X[i, Label[i]]-X[i, j]))}\]
更多细节请参考 `Session Based Recommendations with Recurrent Neural Networks <https://arxiv.org/abs/1511.06939>`_
更多细节请参考 `Session Based Recommendations with Recurrent Neural Networks`_
参数:
- **input** (Variable|list): 一个形为[N x D]的2-D tensor , 其中 N 为批大小batch size ，D 为种类的数量。该输入为logits而非概率。
- **label** (Variable|list): 2-D tensor<int64> 类型的真实值, 形为[N x 1]
- **name** (str|None): （可选）该层的命名。 如果为None, 则自动为该层命名。 默认为None.
- **input** (Variable|list) - 一个形为[N x D]的2-D tensor , 其中 N 为批大小batch size ，D 为种类的数量。该输入为logits而非概率。
- **label** (Variable|list) - 2-D tensor<int64> 类型的真实值, 形为[N x 1]
- **name** (str|None) - （可选）该层的命名。 如果为None, 则自动为该层命名。 默认为None.
返回: 形为[N x 1]的2D张量，即bpr损失
......@@ -1897,6 +2215,13 @@ Bayesian Personalized Ranking Loss Operator. (贝叶斯个性化排序损失计
.. code-block:: python
import paddle.fluid as fluid
neg_size = 10
label = fluid.layers.data(
name="label", shape=[1], dtype="int64")
predict = fluid.layers.data(
name="predict", shape=[neg_size + 1], dtype="float32")
cost = fluid.layers.bpr_loss(input=predict, label=label)
......@@ -2012,10 +2337,21 @@ num_tag_type是标注规则中的标签类型数，num_chunk_type是块类型数
.. code-block:: python:
import paddle.fluid as fluid
dict_size = 10000
label_dict_len = 7
sequence = fluid.layers.data(
name='id', shape=[1], lod_level=1, dtype='int64')
embedding = fluid.layers.embedding(
input=sequence, size=[dict_size, 512])
hidden = fluid.layers.fc(input=embedding, size=512)
label = fluid.layers.data(
name='label', shape=[1], lod_level=1, dtype='int32')
crf = fluid.layers.linear_chain_crf(
input=hidden, label=label, param_attr=ParamAttr(name="crfw"))
input=hidden, label=label, param_attr=fluid.ParamAttr(name="crfw"))
crf_decode = fluid.layers.crf_decoding(
input=hidden, param_attr=ParamAttr(name="crfw"))
input=hidden, param_attr=fluid.ParamAttr(name="crfw"))
fluid.layers.chunk_eval(
input=crf_decode,
label=label,
......@@ -2058,6 +2394,7 @@ clip算子限制给定输入的值在一个区间内。间隔使用参数"min"
.. code-block:: python
import paddle.fluid as fluid
input = fluid.layers.data(
name='data', shape=[1], dtype='float32')
reward = fluid.layers.clip(x=input, min=-1.0, max=1.0)
......@@ -2107,6 +2444,48 @@ ClipByNorm算子
.. _cn_api_fluid_layers_continuous_value_model:
continuous_value_model
-------------------------------
.. py:function:: paddle.fluid.layers.continuous_value_model(input, cvm, use_cvm=True)
**continuous_value_model层**
现在，continuous value model(cvm)仅考虑CTR项目中的展示和点击值。我们假设输入是一个含cvm_feature的词向量，其形状为[N * D]（D为2 + 嵌入维度）。如果use_cvm=True，它会计算log(cvm_feature)，且输出的形状为[N * D]。如果use_cvm=False，它会从输入中移除cvm_feature，且输出的形状为[N * (D - 2)]。
该层接受一个名为input的张量，嵌入后成为ID层(lod level为1)， cvm为一个show_click info。
参数：
- **input** (Variable)-一个N x D的二维LodTensor， N为batch size， D为2 + 嵌入维度， lod level = 1。
- **cvm** (Variable)-一个N x 2的二维Tensor， N为batch size，2为展示和点击值。
- **use_cvm** (bool)-分使用/不使用cvm两种情况。如果使用cvm，输出维度和输入相等；如果不使用cvm，输出维度为输入-2（移除展示和点击值)。（cvm op是一个自定义的op，其输入是一个含embed_with_cvm默认值的序列，因此我们需要一个名为cvm的op来决定是否使用cvm。）
返回：变量，一个N x D的二维LodTensor，如果使用cvm，D等于输入的维度，否则D等于输入的维度-2。
返回类型：变量（Variable）
**代码示例**:
.. code-block:: python
input = fluid.layers.data(name="input", shape=[-1, 1], lod_level=1, append_batch_size=False, dtype="int64")#, stop_gradient=False)
label = fluid.layers.data(name="label", shape=[-1, 1], append_batch_size=False, dtype="int64")
embed = fluid.layers.embedding(
input=input,
size=[100, 11],
dtype='float32')
ones = fluid.layers.fill_constant_batch_size_like(input=label, shape=[-1, 1], dtype="int64", value=1)
show_clk = fluid.layers.cast(fluid.layers.concat([ones, label], axis=1), dtype='float32')
show_clk.stop_gradient = True
input_with_cvm = fluid.layers.continuous_value_model(embed, show_clk, True)
.. _cn_api_fluid_layers_conv2d:
......@@ -2494,9 +2873,13 @@ cos_sim
返回类型：变量（Variable)
**代码示例**
.. code-block:: python
x = fluid.layers.data(name='x', shape=[3, 7], dtype='float32', append_batch_size=False)
y = fluid.layers.data(name='y', shape=[1, 7], dtype='float32', append_batch_size=False)
out = fluid.layers.cos_sim(x, y)
......@@ -2534,8 +2917,13 @@ crf_decoding
.. code-block:: python
crf_decode = fluid.layers.crf_decoding(
input=hidden, param_attr=ParamAttr(name="crfw"))
images = fluid.layers.data(name='pixel', shape=[784], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int32')
hidden = fluid.layers.fc(input=images, size=2)
crf = fluid.layers.linear_chain_crf(input=hidden, label=label,
param_attr=fluid.ParamAttr(name="crfw"))
crf_decode = fluid.layers.crf_decoding(input=hidden,
param_attr=fluid.ParamAttr(name="crfw"))
......@@ -2605,6 +2993,7 @@ crop
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name="x", shape=[3, 5], dtype="float32")
y = fluid.layers.data(name="y", shape=[2, 3], dtype="float32")
crop = fluid.layers.crop(x, shape=y)
......@@ -2675,7 +3064,10 @@ cross_entropy
.. code-block:: python
predict = fluid.layers.fc(input=net, size=classdim, act='softmax')
classdim = 7
x = fluid.layers.data(name='x', shape=[3, 7], dtype='float32', append_batch_size=False)
label = fluid.layers.data(name='label', shape=[3, 1], dtype='float32', append_batch_size=False)
predict = fluid.layers.fc(input=x, size=classdim, act='softmax')
cost = fluid.layers.cross_entropy(input=predict, label=label)
......@@ -2750,6 +3142,7 @@ ctc_greedy_decoder
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[8], dtype='float32')
cost = fluid.layers.ctc_greedy_decoder(input=x, blank=0)
......@@ -2803,16 +3196,139 @@ data_norm
.. code-block:: python
data = fluid.layers.data(input=x, size=200, param_attr='fc1.w')
hidden2 = fluid.layers.data_norm(input=hidden1)
import paddle.fluid as fluid
hidden1 = fluid.layers.data(name="hidden1", shape=[200])
hidden2 = fluid.layers.data_norm(name="hidden2", input=hidden1)
.. _cn_api_fluid_layers_deformable_conv:
deformable_conv
-------------------------------
.. py:function:: paddle.fluid.layers.deformable_conv(input, offset, mask, num_filters, filter_size, stride=1, padding=0, dilation=1, groups=None, deformable_groups=None, im2col_step=None, param_attr=None, bias_attr=None, name=None)
可变形卷积层
在4-D输入上计算2-D可变形卷积。给定输入图像x，输出特征图y，可变形卷积操作如下所示：
\[y(p) = \sum_{k=1}^{K}{w_k * x(p + p_k + \Delta p_k) * \Delta m_k}\]
其中\(\Delta p_k\) 和 \(\Delta m_k\) 分别为第k个位置的可学习偏移和调制标量。
参考可变形卷积网络v2：可变形程度越高，结果越好。
**示例**
输入：
输入形状： \((N, C_{in}, H_{in}, W_{in})\)
卷积核形状： \((C_{out}, C_{in}, H_f, W_f)\)
偏移形状： \((N, 2 * deformable\_groups * H_f * H_w, H_{in}, W_{in})\)
掩膜形状： \((N, deformable\_groups * H_f * H_w, H_{in}, W_{in})\)
输出：
输出形状： \((N, C_{out}, H_{out}, W_{out})\)
其中
\[\begin{split}H_{out}&= \frac{(H_{in} + 2 * paddings[0] - (dilations[0] * (H_f - 1) + 1))}{strides[0]} + 1 \\
W_{out}&= \frac{(W_{in} + 2 * paddings[1] - (dilations[1] * (W_f - 1) + 1))}{strides[1]} + 1\end{split}\]
参数：
- **input** (Variable) - 形式为[N, C, H, W]的输入图像。
- **offset** (Variable) – 可变形卷积层的输入坐标偏移。
- **Mask** (Variable) – 可变形卷积层的输入掩膜。
- **num_filters** (int) – 卷积核数。和输出图像通道数相同。
- **filter_size** (int|tuple|None) – 卷积核大小。如果filter_size为元组，则必须包含两个整数(filter_size_H, filter_size_W)。否则卷积核将为方形。
- **stride** (int|tuple) – 步长大小。如果stride为元组，则必须包含两个整数(stride_H, stride_W)。否则stride_H = stride_W = stride。默认stride = 1。
- **padding** (int|tuple) – padding大小。如果padding为元组，则必须包含两个整数(padding_H, padding_W)。否则padding_H = padding_W = padding。默认padding = 0。
- **dilation** (int|tuple) – dilation大小。如果dilation为元组，则必须包含两个整数(dilation_H, dilation_W)。否则dilation_H = dilation_W = dilation。默认dilation = 1。
- **groups** (int) – 可变形卷积层的群组数。依据Alex Krizhevsky的Deep CNN论文中的分组卷积，有：当group=2时，前一半卷积核只和前一半输入通道有关，而后一半卷积核只和后一半输入通道有关。默认groups=1。
- **deformable_groups** (int) – 可变形群组分区数。默认deformable_groups = 1。
- **im2col_step** (int) – 每个im2col计算的最大图像数。总batch大小应该可以被该值整除或小于该值。如果您面临内存问题，可以尝试在此处使用一个更小的值。默认im2col_step = 64。
- **param_attr** (ParamAttr|None) – 可变形卷积的可学习参数/权重的参数属性。如果将其设置为None或ParamAttr的一个属性，可变形卷积将创建ParamAttr作为param_attr。如果没有设置此param_attr的Initializer，该参数将被\(Normal(0.0, std)\)初始化，且其中的\(std\) 为 \((\frac{2.0 }{filter\_elem\_num})^{0.5}\)。默认值None。
- **bias_attr** (ParamAttr|bool|None) – 可变形卷积层的偏置的参数属性。如果设为False，则输出单元不会加偏置。如果设为None或者ParamAttr的一个属性，conv2d会创建ParamAttr作为bias_attr。如果不设置bias_attr的Initializer，偏置会被初始化为0。默认值None。
- **name** (str|None) – 该层的名字（可选项）。如果设为None，该层将会被自动命名。默认值None。
返回：储存可变形卷积结果的张量变量。
返回类型：变量(Variable)
抛出：ValueError – 如果input, filter_size, stride, padding和groups的大小不匹配。
**代码示例**
.. code-block:: python
data = fluid.layers.data(name='data', shape=[3, 32, 32], dtype='float32')
offset = fluid.layers.data(name='offset', shape=[18, 32, 32], dtype='float32')
mask = fluid.layers.data(name='mask', shape=[9, 32, 32], dtype='float32')
out = fluid.layers.deformable_conv(input=data, offset=offset, mask=mask, num_filters=2, filter_size=3, padding=1)
.. _cn_api_fluid_layers_deformable_roi_pooling:
deformable_roi_pooling
-------------------------------
.. py:function:: paddle.fluid.layers.deformable_roi_pooling(input, rois, trans, no_trans=False, spatial_scale=1.0, group_size=[1, 1], pooled_height=1, pooled_width=1, part_size=None, sample_per_part=1, trans_std=0.1, position_sensitive=False, name=None)
可变形PSROI池层
参数:
- **input** (Variable) - 可变形PSROI池层的输入。输入张量的形状为[N，C，H，W]。其中N是批量大小，C是输入通道的数量，H是特征的高度，W是特征的宽度。
- **rois** （Variable）- 将池化的ROIs（感兴趣区域）。应为一个形状为(num_rois, 4)的2-D LoDTensor，且lod level为1。给出[[x1, y1, x2, y2], ...]，(x1, y1)为左上角坐标，(x2, y2)为右下角坐标。
- **trans** （Variable）- 池化时ROIs上的特征偏移。格式为NCHW，其中N是ROIs的数量，C是通道的数量，指示x和y方向上的偏移距离，H是池化的高度，W是池化的宽度。
- **no_trans** （bool）- roi池化阶段是否加入偏移以获取新值。取True或False。默认为False。
- **spatial_scale** (float) - 输入特征图的高度（或宽度）与原始图像高度（或宽度）的比率。等于卷积图层中总步长的倒数，默认为1.0。
- **group_size** （list|tuple）- 输入通道划分成的组数（例如，输入通道的数量是k1 * k2 *（C + 1），其中k1和k2是组宽度和高度，C + 1是输出通道的数量。如（ 4,6）中4是组的高度，6是组的宽度）。默认为[1,1]。
- **pooled_height** （integer）- 池化后输出的高度。
- **pooled_width** （integer）- 池化后输出的宽度。
- **part_size** （list|tuple）- 偏移高度和宽度，如(4, 6)代表高度为4、宽度为6，默认为None，此时默认值[pooled_height, pooled_width]。
- **sample_per_part** （integer）- 每个bin中的样本数量，默认为1。
- **trans_std** （float）- 偏移系数，默认为0.1。
- **position_sensitive** （bool）- 是否选择可变形psroi池化模式，默认为False。
- **name** （str）- 层名，默认为None。
返回: 存储可变形psroi池层的张量变量
返回类型: 变量(Variable)
**代码示例**
.. code-block:: python
input = fluid.layers.data(name="input",
shape=[2, 192, 64, 64],
dtype='float32',
append_batch_size=False)
rois = fluid.layers.data(name="rois",
shape=[4],
dtype='float32',
lod_level=1)
trans = fluid.layers.data(name="trans",
shape=[2, 384, 64, 64],
dtype='float32',
append_batch_size=False)
x = fluid.layers.nn.deformable_roi_pooling(input=input,
rois=rois,
trans=trans,
no_trans=False,
spatial_scale=1.0,
group_size=(1, 1),
pooled_height=8,
pooled_width=8,
part_size=(8, 8),
sample_per_part=4,
trans_std=0.1,
position_sensitive=False)
.. _cn_api_fluid_layers_dice_loss:
......@@ -2843,8 +3359,11 @@ dice_loss定义为:
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='data', shape = [3, 224, 224, 2], dtype='float32')
label = fluid.layers.data(name='label', shape=[3, 224, 224, 1], dtype='float32')
predictions = fluid.layers.softmax(x)
loss = fluid.layers.dice_loss(input=predictions, label=label, 2)
loss = fluid.layers.dice_loss(input=predictions, label=label)
......@@ -2989,6 +3508,8 @@ dynamic_gru
.. code-block:: python
import paddle.fluid as fluid
dict_dim, emb_dim = 128, 64
data = fluid.layers.data(name='sequence', shape=[1],
dtype='int32', lod_level=1)
......@@ -3088,8 +3609,15 @@ W 代表了权重矩阵(weight matrix)，例如 :math:`W_{xi}` 是从输入门
.. code-block:: python
emb_dim = 256
vocab_size = 10000
hidden_dim = 512
forward_proj = fluid.layers.fc(input=input_seq, size=hidden_dim * 4,
data = fluid.layers.data(name='x', shape=[1],
dtype='int32', lod_level=1)
emb = fluid.layers.embedding(input=data, size=[vocab_size, emb_dim], is_sparse=True)
forward_proj = fluid.layers.fc(input=emb, size=hidden_dim * 4,
bias_attr=False)
forward, _ = fluid.layers.dynamic_lstm(
input=forward_proj, size=hidden_dim * 4, use_peepholes=False)
......@@ -3244,17 +3772,218 @@ edit_distance
- **ignored_tokens** (list<int>,默认为None)-计算编辑距离前需要移除的token
- **name** (str)-该层名称，可选
返回：[batch_size,1]中序列到序列到编辑距离
返回：[batch_size,1]中序列到序列到编辑距离
返回类型：变量
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[1], dtype='int64')
y = fluid.layers.data(name='y', shape=[1], dtype='int64')
cost, _ = fluid.layers.edit_distance(input=x,label=y)
cpu = fluid.core.CPUPlace()
exe = fluid.Executor(cpu)
exe.run(fluid.default_startup_program())
import numpy
x_ = numpy.random.randint(5, size=(2, 1)).astype('int64')
y_ = numpy.random.randint(5, size=(2, 1)).astype('int64')
print(x_)
print(y_)
x = fluid.create_lod_tensor(x_, [[2]], cpu)
y = fluid.create_lod_tensor(y_, [[2]], cpu)
outs = exe.run(feed={'x':x, 'y':y}, fetch_list=[cost.name])
print(outs)
.. _cn_api_fluid_layers_elementwise_add:
elementwise_add
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_add(x, y, axis=-1, act=None, name=None)
逐元素相加算子
等式为：
.. 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
输入 :math:`X` 和 :math:`Y` 可以携带不同的LoD信息。但输出仅与输入 :math:`X` 共享LoD信息。
参数：
- **x** （Tensor）- 第一个输入张量（Tensor）。
- **y** （Tensor）- 第二个输入张量（Tensor）。
- **axis** （INT）- （int，默认-1）。将Y传到X上的起始维度索引。
- **act** （basestring | None）- 激活函数名称，应用于输出。
- **name** （basestring | None）- 输出的名称。
返回： 元素运算的输出。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# 例1: shape(x) = (2, 3, 4, 5), shape(y) = (2, 3, 4, 5)
x0 = fluid.layers.data(name="x0", shape=[2, 3, 4, 5], dtype='float32')
y0 = fluid.layers.data(name="y0", shape=[2, 3, 4, 5], dtype='float32')
z0 = fluid.layers.elementwise_add(x0, y0)
# 例2: shape(X) = (2, 3, 4, 5), shape(Y) = (5)
x1 = fluid.layers.data(name="x1", shape=[2, 3, 4, 5], dtype='float32')
y1 = fluid.layers.data(name="y1", shape=[5], dtype='float32')
z1 = fluid.layers.elementwise_add(x1, y1)
# 例3: shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
x2 = fluid.layers.data(name="x2", shape=[2, 3, 4, 5], dtype='float32')
y2 = fluid.layers.data(name="y2", shape=[4, 5], dtype='float32')
z2 = fluid.layers.elementwise_add(x2, y2, axis=2)
# 例4: shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
x3 = fluid.layers.data(name="x3", shape=[2, 3, 4, 5], dtype='float32')
y3 = fluid.layers.data(name="y3", shape=[3, 4], dtype='float32')
z3 = fluid.layers.elementwise_add(x3, y3, axis=1)
# 例5: shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
x4 = fluid.layers.data(name="x4", shape=[2, 3, 4, 5], dtype='float32')
y4 = fluid.layers.data(name="y4", shape=[2], dtype='float32')
z4 = fluid.layers.elementwise_add(x4, y4, axis=0)
# 例6: shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
x5 = fluid.layers.data(name="x5", shape=[2, 3, 4, 5], dtype='float32')
y5 = fluid.layers.data(name="y5", shape=[2], dtype='float32')
z5 = fluid.layers.elementwise_add(x5, y5, axis=0)
.. _cn_api_fluid_layers_elementwise_div:
elementwise_div
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_div(x, y, axis=-1, act=None, name=None)
逐元素相除算子
等式是：
.. math::
Out = X / Y
- :math:`X` ：任何维度的张量（Tensor）。
- :math:`Y` ：维度必须小于或等于X维度的张量（Tensor）。
此运算算子有两种情况：
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
输入 :math:`X` 和 :math:`Y` 可以携带不同的LoD信息。但输出仅与输入 :math:`X` 共享LoD信息。
参数：
- **x** （Tensor）- 第一个输入张量（Tensor）。
- **y** （Tensor）- 第二个输入张量（Tensor）。
- **axis** （INT）- （int，默认-1）。将Y传到X上的起始维度索引。
- **act** （basestring | None）- 激活函数名称，应用于输出。
- **name** （basestring | None）- 输出的名称。
返回： 元素运算的输出。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# 例1: shape(x) = (2, 3, 4, 5), shape(y) = (2, 3, 4, 5)
x0 = fluid.layers.data(name="x0", shape=[2, 3, 4, 5], dtype='float32')
y0 = fluid.layers.data(name="y0", shape=[2, 3, 4, 5], dtype='float32')
z0 = fluid.layers.elementwise_div(x0, y0)
# 例2: shape(X) = (2, 3, 4, 5), shape(Y) = (5)
x1 = fluid.layers.data(name="x1", shape=[2, 3, 4, 5], dtype='float32')
y1 = fluid.layers.data(name="y1", shape=[5], dtype='float32')
z1 = fluid.layers.elementwise_div(x1, y1)
# 例3: shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
x2 = fluid.layers.data(name="x2", shape=[2, 3, 4, 5], dtype='float32')
y2 = fluid.layers.data(name="y2", shape=[4, 5], dtype='float32')
z2 = fluid.layers.elementwise_div(x2, y2, axis=2)
# 例4: shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
x3 = fluid.layers.data(name="x3", shape=[2, 3, 4, 5], dtype='float32')
y3 = fluid.layers.data(name="y3", shape=[3, 4], dtype='float32')
z3 = fluid.layers.elementwise_div(x3, y3, axis=1)
# 例5: shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
x4 = fluid.layers.data(name="x4", shape=[2, 3, 4, 5], dtype='float32')
y4 = fluid.layers.data(name="y4", shape=[2], dtype='float32')
z4 = fluid.layers.elementwise_div(x4, y4, axis=0)
# 例6: shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
x5 = fluid.layers.data(name="x5", shape=[2, 3, 4, 5], dtype='float32')
y5 = fluid.layers.data(name="y5", shape=[2], dtype='float32')
z5 = fluid.layers.elementwise_div(x5, y5, axis=0)
返回类型：变量
**代码示例**：
.. code-block:: python
x = fluid.layers.data(name='x', shape=[1], dtype='float32')
y = fluid.layers.data(name='y', shape=[1], dtype='float32')
cost = fluid.layers.edit_distance(input=x,label=y)
......@@ -3264,34 +3993,35 @@ edit_distance
.. _cn_api_fluid_layers_elementwise_add:
.. _cn_api_fluid_layers_elementwise_floordiv:
elementwise_add
elementwise_floordiv
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_add(x, y, axis=-1, act=None, name=None)
.. py:function:: paddle.fluid.layers.elementwise_floordiv(x, y, axis=-1, act=None, name=None)
逐元素相加算子
FloorDiv运算。
等式为：
等式是：
.. math::
Out = X + Y
Out = X // Y
- :math:`X` ：任意维度的张量（Tensor）.
- :math:`Y` ：一个维度必须小于等于X维度的张量（Tensor）。
对于这个运算算子有2种情况：
- :math:`X` ：任何维度的张量（Tensor）。
- :math:`Y` ：维度必须小于或等于X维度的张量（Tensor）。
此运算分两种情况：
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）。
对于情况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:: python
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
......@@ -3303,38 +4033,70 @@ elementwise_add
输入 :math:`X` 和 :math:`Y` 可以携带不同的LoD信息。但输出仅与输入 :math:`X` 共享LoD信息。
参数：
- **x** （Tensor）- 元素op的第一个输入张量（Tensor）。
- **y** （Tensor）- 元素op的第二个输入张量（Tensor）。
- **x** （Tensor）- 第一个输入张量（Tensor）。
- **y** （Tensor）- 第二个输入张量（Tensor）。
- **axis** （INT）- （int，默认-1）。将Y传到X上的起始维度索引。
- **act** （basestring | None）- 激活应用于输出。
- **act** （basestring | None）- 激活函数名称，应用于输出。
- **name** （basestring | None）- 输出的名称。
返回： 元素运算的输出。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# example 1: shape(x) = (2, 3, 4, 5), shape(y) = (2, 3, 4, 5)
x0 = fluid.layers.data(name="x0", shape=[2, 3, 4, 5], dtype='float32')
y0 = fluid.layers.data(name="y0", shape=[2, 3, 4, 5], dtype='float32')
z0 = fluid.layers.elementwise_floordiv(x0, y0)
# example 2: shape(X) = (2, 3, 4, 5), shape(Y) = (5)
x1 = fluid.layers.data(name="x1", shape=[2, 3, 4, 5], dtype='float32')
y1 = fluid.layers.data(name="y1", shape=[5], dtype='float32')
z1 = fluid.layers.elementwise_floordiv(x1, y1)
# example 3: shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
x2 = fluid.layers.data(name="x2", shape=[2, 3, 4, 5], dtype='float32')
y2 = fluid.layers.data(name="y2", shape=[4, 5], dtype='float32')
z2 = fluid.layers.elementwise_floordiv(x2, y2, axis=2)
# example 4: shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
x3 = fluid.layers.data(name="x3", shape=[2, 3, 4, 5], dtype='float32')
y3 = fluid.layers.data(name="y3", shape=[3, 4], dtype='float32')
z3 = fluid.layers.elementwise_floordiv(x3, y3, axis=1)
# example 5: shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
x4 = fluid.layers.data(name="x4", shape=[2, 3, 4, 5], dtype='float32')
y4 = fluid.layers.data(name="y4", shape=[2], dtype='float32')
z4 = fluid.layers.elementwise_floordiv(x4, y4, axis=0)
.. _cn_api_fluid_layers_elementwise_div:
# example 6: shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
x5 = fluid.layers.data(name="x5", shape=[2, 3, 4, 5], dtype='float32')
y5 = fluid.layers.data(name="y5", shape=[2], dtype='float32')
z5 = fluid.layers.elementwise_floordiv(x5, y5, axis=0)
elementwise_div
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_div(x, y, axis=-1, act=None, name=None)
逐元素相除算子
.. _cn_api_fluid_layers_elementwise_max:
elementwise_max
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_max(x, y, axis=-1, act=None, name=None)
最大元素算子
等式是：
.. math::
Out = X / Y
Out = max(X, Y)
- :math:`X` ：任何尺寸的张量（Tensor）。
- :math:`Y` ：尺寸必须小于或等于X尺寸的张量（Tensor）。
- :math:`X` ：任何维度的张量（Tensor）。
- :math:`Y` ：维度必须小于或等于X维度的张量（Tensor）。
此运算算子有两种情况：
1. :math:`Y` 的形状（shape）与 :math:`X` 相同。
......@@ -3343,11 +4105,11 @@ elementwise_div
对于情况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）。
3. 考虑到子序列， :math:`Y` 的大小为1的尾部维度将被忽略，例如shape（Y）=（2,1）=>（2）。
例如：
.. code-block:: python
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
......@@ -3356,41 +4118,75 @@ elementwise_div
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
输入 :math:`X` 和 :math:`Y` 可以携带不同的LoD信息。但输出仅与输入 :math:`X` 共享LoD信息。
输入X和Y可以携带不同的LoD信息。但输出仅与输入X共享LoD信息。
参数：
- **x** （Tensor）- 元素op的第一个输入张量（Tensor）。
- **y** （Tensor）- 元素op的第二个输入张量（Tensor）。
- **x** （Tensor）- 第一个输入张量（Tensor）。
- **y** （Tensor）- 第二个输入张量（Tensor）。
- **axis** （INT）- （int，默认-1）。将Y传到X上的起始维度索引。
- **act** （basestring | None）- 激活应用于输出。
- **act** （basestring | None）- 激活函数名称，应用于输出。
- **name** （basestring | None）- 输出的名称。
返回： 元素运算的输出。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# 例1: shape(x) = (2, 3, 4, 5), shape(y) = (2, 3, 4, 5)
x0 = fluid.layers.data(name="x0", shape=[2, 3, 4, 5], dtype='float32')
y0 = fluid.layers.data(name="y0", shape=[2, 3, 4, 5], dtype='float32')
z0 = fluid.layers.elementwise_max(x0, y0)
# 例2: shape(X) = (2, 3, 4, 5), shape(Y) = (5)
x1 = fluid.layers.data(name="x1", shape=[2, 3, 4, 5], dtype='float32')
y1 = fluid.layers.data(name="y1", shape=[5], dtype='float32')
z1 = fluid.layers.elementwise_max(x1, y1)
# 例3: shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
x2 = fluid.layers.data(name="x2", shape=[2, 3, 4, 5], dtype='float32')
y2 = fluid.layers.data(name="y2", shape=[4, 5], dtype='float32')
z2 = fluid.layers.elementwise_max(x2, y2, axis=2)
# 例4: shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
x3 = fluid.layers.data(name="x3", shape=[2, 3, 4, 5], dtype='float32')
y3 = fluid.layers.data(name="y3", shape=[3, 4], dtype='float32')
z3 = fluid.layers.elementwise_max(x3, y3, axis=1)
# 例5: shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
x4 = fluid.layers.data(name="x4", shape=[2, 3, 4, 5], dtype='float32')
y4 = fluid.layers.data(name="y4", shape=[2], dtype='float32')
z4 = fluid.layers.elementwise_max(x4, y4, axis=0)
# 例6: shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
x5 = fluid.layers.data(name="x5", shape=[2, 3, 4, 5], dtype='float32')
y5 = fluid.layers.data(name="y5", shape=[2], dtype='float32')
z5 = fluid.layers.elementwise_max(x5, y5, axis=0)
.. _cn_api_fluid_layers_elementwise_max:
elementwise_max
.. _cn_api_fluid_layers_elementwise_min:
elementwise_min
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_max(x, y, axis=-1, act=None, name=None)
最大元素算子
.. py:function:: paddle.fluid.layers.elementwise_min(x, y, axis=-1, act=None, name=None)
最小元素算子
等式是：
.. math::
Out = max(X, Y)
Out = min(X, Y)
- :math:`X` ：任何尺寸的张量（Tensor）。
- :math:`Y` ：尺寸必须小于或等于X尺寸的张量（Tensor）。
- :math:`X` ：任何维度的张量（Tensor）。
- :math:`Y` ：维度必须小于或等于X维度的张量（Tensor）。
此运算算子有两种情况：
1. :math:`Y` 的形状（shape）与 :math:`X` 相同。
......@@ -3399,11 +4195,11 @@ elementwise_max
对于情况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）。
3. 考虑到子序列， :math:`Y` 的大小为1的尾部维度将被忽略，例如shape（Y）=（2,1）=>（2）。
例如：
.. code-block:: python
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
......@@ -3415,39 +4211,70 @@ elementwise_max
输入X和Y可以携带不同的LoD信息。但输出仅与输入X共享LoD信息。
参数：
- **x** （Tensor）- 元素op的第一个输入张量（Tensor）。
- **y** （Tensor）- 元素op的第二个输入张量（Tensor）。
- **x** （Tensor）- 第一个输入张量（Tensor）。
- **y** （Tensor）- 第二个输入张量（Tensor）。
- **axis** （INT）- （int，默认-1）。将Y传到X上的起始维度索引。
- **act** （basestring | None）- 激活应用于输出。
- **act** （basestring | None）- 激活函数名称，应用于输出。
- **name** （basestring | None）- 输出的名称。
返回： 元素运算的输出。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# 例1: shape(x) = (2, 3, 4, 5), shape(y) = (2, 3, 4, 5)
x0 = fluid.layers.data(name="x0", shape=[2, 3, 4, 5], dtype='float32')
y0 = fluid.layers.data(name="y0", shape=[2, 3, 4, 5], dtype='float32')
z0 = fluid.layers.elementwise_min(x0, y0)
# 例2: shape(X) = (2, 3, 4, 5), shape(Y) = (5)
x1 = fluid.layers.data(name="x1", shape=[2, 3, 4, 5], dtype='float32')
y1 = fluid.layers.data(name="y1", shape=[5], dtype='float32')
z1 = fluid.layers.elementwise_min(x1, y1)
# 例3: shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
x2 = fluid.layers.data(name="x2", shape=[2, 3, 4, 5], dtype='float32')
y2 = fluid.layers.data(name="y2", shape=[4, 5], dtype='float32')
z2 = fluid.layers.elementwise_min(x2, y2, axis=2)
# 例4: shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
x3 = fluid.layers.data(name="x3", shape=[2, 3, 4, 5], dtype='float32')
y3 = fluid.layers.data(name="y3", shape=[3, 4], dtype='float32')
z3 = fluid.layers.elementwise_min(x3, y3, axis=1)
# 例5: shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
x4 = fluid.layers.data(name="x4", shape=[2, 3, 4, 5], dtype='float32')
y4 = fluid.layers.data(name="y4", shape=[2], dtype='float32')
z4 = fluid.layers.elementwise_min(x4, y4, axis=0)
# 例6: shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
x5 = fluid.layers.data(name="x5", shape=[2, 3, 4, 5], dtype='float32')
y5 = fluid.layers.data(name="y5", shape=[2], dtype='float32')
z5 = fluid.layers.elementwise_min(x5, y5, axis=0)
.. _cn_api_fluid_layers_elementwise_min:
elementwise_min
.. _cn_api_fluid_layers_elementwise_mod:
elementwise_mod
-------------------------------
.. py:function:: paddle.fluid.layers.elementwise_min(x, y, axis=-1, act=None, name=None)
.. py:function:: paddle.fluid.layers.elementwise_mod(x, y, axis=-1, act=None, name=None)
最小元素算子
按元素的取模运算。
等式是：
.. math::
Out = min(X, Y)
Out = X\%Y
- :math:`X` ：任何维数的张量（Tensor）。
- :math:`Y` ：维数必须小于或等于X维数的张量（Tensor）。
- :math:`X` ：任何维度的张量（Tensor）。
- :math:`Y` ：维度必须小于或等于X维度的张量（Tensor）。
此运算算子有两种情况：
1. :math:`Y` 的形状（shape）与 :math:`X` 相同。
......@@ -3456,11 +4283,11 @@ elementwise_min
对于情况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）。
3. 考虑到子序列， :math:`Y` 的大小为1的尾随维度将被忽略，例如shape（Y）=（2,1）=>（2）。
例如：
.. code-block:: python
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
......@@ -3472,20 +4299,49 @@ elementwise_min
输入X和Y可以携带不同的LoD信息。但输出仅与输入X共享LoD信息。
参数：
- **x** （Tensor）- 元素op的第一个输入张量（Tensor）。
- **y** （Tensor）- 元素op的第二个输入张量（Tensor）。
- **x** （Tensor）- 第一个输入张量（Tensor）。
- **y** （Tensor）- 第二个输入张量（Tensor）。
- **axis** （INT）- （int，默认-1）。将Y传到X上的起始维度索引。
- **act** （basestring | None）- 激活应用于输出。
- **act** （basestring | None）- 激活函数名称，应用于输出。
- **name** （basestring | None）- 输出的名称。
返回： 元素运算的输出。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# example 1: shape(x) = (2, 3, 4, 5), shape(y) = (2, 3, 4, 5)
x0 = fluid.layers.data(name="x0", shape=[2, 3, 4, 5], dtype='float32')
y0 = fluid.layers.data(name="y0", shape=[2, 3, 4, 5], dtype='float32')
z0 = fluid.layers.elementwise_mod(x0, y0)
# example 2: shape(X) = (2, 3, 4, 5), shape(Y) = (5)
x1 = fluid.layers.data(name="x1", shape=[2, 3, 4, 5], dtype='float32')
y1 = fluid.layers.data(name="y1", shape=[5], dtype='float32')
z1 = fluid.layers.elementwise_mod(x1, y1)
# example 3: shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
x2 = fluid.layers.data(name="x2", shape=[2, 3, 4, 5], dtype='float32')
y2 = fluid.layers.data(name="y2", shape=[4, 5], dtype='float32')
z2 = fluid.layers.elementwise_mod(x2, y2, axis=2)
# example 4: shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
x3 = fluid.layers.data(name="x3", shape=[2, 3, 4, 5], dtype='float32')
y3 = fluid.layers.data(name="y3", shape=[3, 4], dtype='float32')
z3 = fluid.layers.elementwise_mod(x3, y3, axis=1)
# example 5: shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
x4 = fluid.layers.data(name="x4", shape=[2, 3, 4, 5], dtype='float32')
y4 = fluid.layers.data(name="y4", shape=[2], dtype='float32')
z4 = fluid.layers.elementwise_mod(x4, y4, axis=0)
# example 6: shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
x5 = fluid.layers.data(name="x5", shape=[2, 3, 4, 5], dtype='float32')
y5 = fluid.layers.data(name="y5", shape=[2], dtype='float32')
z5 = fluid.layers.elementwise_mod(x5, y5, axis=0)
......@@ -3503,8 +4359,8 @@ elementwise_mul
.. math::
Out = X \odot Y
- **X** ：任何尺寸的张量（Tensor）。
- **Y** ：尺寸必须小于或等于X尺寸的张量（Tensor）。
- :math:`X` ：任何维度的张量（Tensor）。
- :math:`Y` ：维度必须小于或等于X维度的张量（Tensor）。
此运算算子有两种情况：
1. :math:`Y` 的形状（shape）与 :math:`X` 相同。
......@@ -3513,11 +4369,11 @@ elementwise_mul
对于情况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）。
3. 考虑到子序列， :math:`Y` 的大小为1的尾随维度将被忽略，例如shape（Y）=（2,1）=>（2）。
例如：
.. code-block:: python
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
......@@ -3529,15 +4385,48 @@ elementwise_mul
输入X和Y可以携带不同的LoD信息。但输出仅与输入X共享LoD信息。
参数：
- **x** - （Tensor），元素op的第一个输入张量（Tensor）。
- **y** - （Tensor），元素op的第二个输入张量（Tensor）。
- **x** （Tensor）- 第一个输入张量（Tensor）。
- **y** （Tensor）- 第二个输入张量（Tensor）。
- **axis** （INT）- （int，默认-1）。将Y传到X上的起始维度索引。
- **act** （basestring | None）- 激活应用于输出。
- **act** （basestring | None）- 激活函数名称，应用于输出。
- **name** （basestring | None）- 输出的名称。
返回： 元素运算的输出。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# 例1: shape(x) = (2, 3, 4, 5), shape(y) = (2, 3, 4, 5)
x0 = fluid.layers.data(name="x0", shape=[2, 3, 4, 5], dtype='float32')
y0 = fluid.layers.data(name="y0", shape=[2, 3, 4, 5], dtype='float32')
z0 = fluid.layers.elementwise_mul(x0, y0)
# 例2: shape(X) = (2, 3, 4, 5), shape(Y) = (5)
x1 = fluid.layers.data(name="x1", shape=[2, 3, 4, 5], dtype='float32')
y1 = fluid.layers.data(name="y1", shape=[5], dtype='float32')
z1 = fluid.layers.elementwise_mul(x1, y1)
# 例3: shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
x2 = fluid.layers.data(name="x2", shape=[2, 3, 4, 5], dtype='float32')
y2 = fluid.layers.data(name="y2", shape=[4, 5], dtype='float32')
z2 = fluid.layers.elementwise_mul(x2, y2, axis=2)
# 例4: shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
x3 = fluid.layers.data(name="x3", shape=[2, 3, 4, 5], dtype='float32')
y3 = fluid.layers.data(name="y3", shape=[3, 4], dtype='float32')
z3 = fluid.layers.elementwise_mul(x3, y3, axis=1)
# 例5: shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
x4 = fluid.layers.data(name="x4", shape=[2, 3, 4, 5], dtype='float32')
y4 = fluid.layers.data(name="y4", shape=[2], dtype='float32')
z4 = fluid.layers.elementwise_mul(x4, y4, axis=0)
# 例6: shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
x5 = fluid.layers.data(name="x5", shape=[2, 3, 4, 5], dtype='float32')
y5 = fluid.layers.data(name="y5", shape=[2], dtype='float32')
z5 = fluid.layers.elementwise_mul(x5, y5, axis=0)
......@@ -3559,8 +4448,8 @@ elementwise_pow
.. math::
Out = X ^ Y
- :math:`X` ：任何维数的张量（Tensor）。
- :math:`Y` ：维数必须小于或等于X维数的张量（Tensor）。
- :math:`X` ：任何维度的张量（Tensor）。
- :math:`Y` ：维度必须小于或等于X维度的张量（Tensor）。
此运算算子有两种情况：
1. :math:`Y` 的形状（shape）与 :math:`X` 相同。
......@@ -3569,11 +4458,11 @@ elementwise_pow
对于情况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）。
3. 考虑到子序列， :math:`Y` 的大小为1的尾随维度将被忽略，例如shape（Y）=（2,1）=>（2）。
例如：
**代码示例**
.. code-block:: python
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
......@@ -3585,15 +4474,47 @@ elementwise_pow
输入X和Y可以携带不同的LoD信息。但输出仅与输入X共享LoD信息。
参数：
- **x** （Tensor）- 元素op的第一个输入张量（Tensor）。
- **y** （Tensor）- 元素op的第二个输入张量（Tensor）。
- **x** （Tensor）- 第一个输入张量（Tensor）。
- **y** （Tensor）- 第二个输入张量（Tensor）。
- **axis** （INT）- （int，默认-1）。将Y传到X上的起始维度索引。
- **act** （basestring | None）- 激活应用于输出。
- **act** （basestring | None）- 激活函数名称，应用于输出。
- **name** （basestring | None）- 输出的名称。
返回： 元素运算的输出。
**代码示例**
.. code-block:: python
# 例1: shape(x) = (2, 3, 4, 5), shape(y) = (2, 3, 4, 5)
x0 = fluid.layers.data(name="x0", shape=[2, 3, 4, 5], dtype='float32')
y0 = fluid.layers.data(name="y0", shape=[2, 3, 4, 5], dtype='float32')
z0 = fluid.layers.elementwise_pow(x0, y0)
# 例2: shape(X) = (2, 3, 4, 5), shape(Y) = (5)
x1 = fluid.layers.data(name="x1", shape=[2, 3, 4, 5], dtype='float32')
y1 = fluid.layers.data(name="y1", shape=[5], dtype='float32')
z1 = fluid.layers.elementwise_pow(x1, y1)
# 例3: shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
x2 = fluid.layers.data(name="x2", shape=[2, 3, 4, 5], dtype='float32')
y2 = fluid.layers.data(name="y2", shape=[4, 5], dtype='float32')
z2 = fluid.layers.elementwise_pow(x2, y2, axis=2)
# 例4: shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
x3 = fluid.layers.data(name="x3", shape=[2, 3, 4, 5], dtype='float32')
y3 = fluid.layers.data(name="y3", shape=[3, 4], dtype='float32')
z3 = fluid.layers.elementwise_pow(x3, y3, axis=1)
# 例5: shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
x4 = fluid.layers.data(name="x4", shape=[2, 3, 4, 5], dtype='float32')
y4 = fluid.layers.data(name="y4", shape=[2], dtype='float32')
z4 = fluid.layers.elementwise_pow(x4, y4, axis=0)
# 例6: shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
x5 = fluid.layers.data(name="x5", shape=[2, 3, 4, 5], dtype='float32')
y5 = fluid.layers.data(name="y5", shape=[2], dtype='float32')
z5 = fluid.layers.elementwise_pow(x5, y5, axis=0)
......@@ -3616,8 +4537,8 @@ elementwise_sub
.. math::
Out = X - Y
- **X** ：任何尺寸的张量（Tensor）。
- **Y** ：尺寸必须小于或等于**X**尺寸的张量（Tensor）。
- **X** ：任何维度的张量（Tensor）。
- **Y** ：维度必须小于或等于**X**维度的张量（Tensor）。
此运算算子有两种情况：
1. :math:`Y` 的形状（shape）与 :math:`X` 相同。
......@@ -3626,11 +4547,11 @@ elementwise_sub
对于情况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）。
3. 考虑到子序列， :math:`Y` 的大小为1的尾随维度将被忽略，例如shape（Y）=（2,1）=>（2）。
例如：
.. code-block:: python
.. code-block:: text
shape(X) = (2, 3, 4, 5), shape(Y) = (,)
shape(X) = (2, 3, 4, 5), shape(Y) = (5,)
......@@ -3642,17 +4563,48 @@ elementwise_sub
输入X和Y可以携带不同的LoD信息。但输出仅与输入X共享LoD信息。
参数：
- **x** - （Tensor），元素op的第一个输入张量（Tensor）。
- **y** - （Tensor），元素op的第二个输入张量（Tensor）。
- **x** （Tensor）- 第一个输入张量（Tensor）。
- **y** （Tensor）- 第二个输入张量（Tensor）。
- **axis** （INT）- （int，默认-1）。将Y传到X上的起始维度索引。
- **act** （basestring | None）- 激活应用于输出。
- **act** （basestring | None）- 激活函数名称，应用于输出。
- **name** （basestring | None）- 输出的名称。
返回： 元素运算的输出。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# 例1: shape(x) = (2, 3, 4, 5), shape(y) = (2, 3, 4, 5)
x0 = fluid.layers.data(name="x0", shape=[2, 3, 4, 5], dtype='float32')
y0 = fluid.layers.data(name="y0", shape=[2, 3, 4, 5], dtype='float32')
z0 = fluid.layers.elementwise_sub(x0, y0)
# 例2: shape(X) = (2, 3, 4, 5), shape(Y) = (5)
x1 = fluid.layers.data(name="x1", shape=[2, 3, 4, 5], dtype='float32')
y1 = fluid.layers.data(name="y1", shape=[5], dtype='float32')
z1 = fluid.layers.elementwise_sub(x1, y1)
# 例3: shape(X) = (2, 3, 4, 5), shape(Y) = (4, 5), with axis=-1(default) or axis=2
x2 = fluid.layers.data(name="x2", shape=[2, 3, 4, 5], dtype='float32')
y2 = fluid.layers.data(name="y2", shape=[4, 5], dtype='float32')
z2 = fluid.layers.elementwise_sub(x2, y2, axis=2)
# 例4: shape(X) = (2, 3, 4, 5), shape(Y) = (3, 4), with axis=1
x3 = fluid.layers.data(name="x3", shape=[2, 3, 4, 5], dtype='float32')
y3 = fluid.layers.data(name="y3", shape=[3, 4], dtype='float32')
z3 = fluid.layers.elementwise_sub(x3, y3, axis=1)
# 例5: shape(X) = (2, 3, 4, 5), shape(Y) = (2), with axis=0
x4 = fluid.layers.data(name="x4", shape=[2, 3, 4, 5], dtype='float32')
y4 = fluid.layers.data(name="y4", shape=[2], dtype='float32')
z4 = fluid.layers.elementwise_sub(x4, y4, axis=0)
# 例6: shape(X) = (2, 3, 4, 5), shape(Y) = (2, 1), with axis=0
x5 = fluid.layers.data(name="x5", shape=[2, 3, 4, 5], dtype='float32')
y5 = fluid.layers.data(name="y5", shape=[2], dtype='float32')
z5 = fluid.layers.elementwise_sub(x5, y5, axis=0)
......@@ -3681,7 +4633,7 @@ ELU激活层（ELU Activation Operator）
返回类型: 输出(Variable)
**代码示例：**
**代码示例**
.. code-block:: python
......@@ -3723,9 +4675,9 @@ embedding
.. code-block:: python
dict_size = len(dataset.ids)
data = fluid.layers.data(name='ids', shape=[1], dtype='int64')
fc = fluid.layers.embedding(input=data, size=[dict_size, 16], dtype='float32')
import paddle.fluid as fluid
data = fluid.layers.data(name='sequence', shape=[1], dtype='int64', lod_level=1)
emb = fluid.layers.embedding(input=data, size=[128, 64])
......@@ -3815,11 +4767,11 @@ fc
上述等式中：
- :math:`N` ：输入的数目,如果输入是变量列表，N等于len（input）
- :math:`X_i` : 第i个输入的tensor
- :math:`X_i` ：第i个输入的tensor
- :math:`W_i` ：对应第i个输入张量的第i个权重矩阵
- :math:`b` ：该层创立的bias参数
- :math:`Act` : activation function(激励函数)
- :math:`Out` : 输出tensor
- :math:`Act` ：activation function(激励函数)
- :math:`Out` ：输出tensor
::
......@@ -3963,8 +4915,12 @@ fsp_matrix
.. code-block:: python
feature_map_0 = fluid.layers.conv2d(x)
feature_map_1 = fluid.layers.conv2d(feature_map_0)
import paddle.fluid as fluid
data = fluid.layers.data(name='data', shape=[3, 32, 32])
feature_map_0 = fluid.layers.conv2d(data, num_filters=2,
filter_size=3)
feature_map_1 = fluid.layers.conv2d(feature_map_0, num_filters=2,
filter_size=1)
loss = fluid.layers.fsp_matrix(feature_map_0, feature_map_1)
......@@ -3977,7 +4933,7 @@ fsp_matrix
gather
-------------------------------
.. py:function:: paddle.fluid.layers.gather(input, index)
.. py:function:: paddle.fluid.layers.gather(input, index, overwrite=True)
收集层（gather layer）
......@@ -4001,15 +4957,20 @@ gather
参数:
- **input** (Variable) - input 的rank >= 1。
- **index** (Variable) - index的rank = 1。
- **input** (Variable) - input的秩rank >= 1。
- **index** (Variable) - index的秩rank = 1。
- **overwrite** (bool) - 具有相同索引时更新grad的模式。如果为True，则使用覆盖模式更新相同索引的grad，如果为False，则使用accumulate模式更新相同索引的grad。Default值为True。
返回：和输入的秩相同的输出张量。
返回： output (Variable)
返回类型：output (Variable)
**代码示例**
.. code-block:: python
x = fluid.layers.data(name='x', shape=[-1, 5], dtype='float32')
index = fluid.layers.data(name='index', shape=[-1, 1], dtype='int32')
output = fluid.layers.gather(x, index)
......@@ -4046,6 +5007,7 @@ gaussian_random算子。
.. code-block:: python
import paddle.fluid.layers as layers
out = fluid.layers.gaussian_random(shape=[20, 30])
......@@ -4111,7 +5073,14 @@ get_tensor_from_selected_rows
返回类型： out(Variable)
**代码示例：**
.. code-block:: python
import paddle.fluid as fluid
b = fluid.default_main_program().global_block()
input = b.create_var(name="X", dtype="float32", persistable=True, type=fluid.core.VarDesc.VarType.SELECTED_ROWS)
out = fluid.layers.get_tensor_from_selected_rows(input)
......@@ -4184,9 +5153,11 @@ step 2：
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[3, 10, 32, 32], dtype='float32')
theta = fluid.layers.data(name='theta', shape=[3, 2, 3], dtype='float32')
grid = fluid.layers.affine_grid(input=theta, size=[3, 10, 32, 32]})
grid = fluid.layers.affine_grid(theta=theta, out_shape=[3, 10, 32, 32]})
out = fluid.layers.grid_sampler(x=x, grid=grid)
......@@ -4303,10 +5274,17 @@ GRU单元的输入包括 :math:`z_t` ， :math:`h_{t-1}` 。在上述等式中
.. code-block:: python
# 假设我们现在有x_t_data和size=10的之前的隐藏层
x_t = fluid.layers.fc(input=x_t_data, size=30)
hidden_val, r_h_val, gate_val = fluid.layers.gru_unit(input=x_t,
hidden = prev_hidden)
import paddle.fluid as fluid
dict_dim, emb_dim = 128, 64
data = fluid.layers.data(name='step_data', shape=[1], dtype='int32')
emb = fluid.layers.embedding(input=data, size=[dict_dim, emb_dim])
hidden_dim = 512
x = fluid.layers.fc(input=emb, size=hidden_dim * 3)
pre_hidden = fluid.layers.data(
name='pre_hidden', shape=[hidden_dim], dtype='float32')
hidden = fluid.layers.gru_unit(
input=x, hidden=pre_hidden, size=hidden_dim * 3)
......@@ -4350,7 +5328,7 @@ sigmoid的分段线性逼近(https://arxiv.org/abs/1603.00391)，比sigmoid快
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name="x", shape=[3,10,32,32], dtype="float32")
y = fluid.layers.hard_sigmoid(x, slope=0.3, offset=0.8)
......@@ -4378,8 +5356,8 @@ hash
# shape [2, 2]
input.data = [
[[1], [2]],
[[3], [4]],
[[1, 2],
[3, 4]],
]
input.lod = [[0, 2]]
......@@ -4400,8 +5378,8 @@ hash
# shape [2, 4]
output.data = [
[[9662], [9217], [1129], [8487]],
[[8310], [1327], [1654], [4567]],
[[9662, 9217, 1129, 8487],
[8310, 1327, 1654, 4567]],
]
output.lod = [[0, 2]]
......@@ -4420,9 +5398,24 @@ hash
.. code-block:: python
word_dict = paddle.dataset.imdb.word_dict()
x = fluid.layers.data(shape[1], dtype='int32', lod_level=1)
out = fluid.layers.hash(input=x, num_hash=4, hash_size=1000)
import paddle.fluid as fluid
import paddle.fluid.layers as layers
import numpy as np
titles = fluid.layers.data(name='titles', shape=[1], dtype='int32', lod_level=1)
hash_r = fluid.layers.hash(name='hash_x', input=titles, num_hash=1, hash_size=1000)
place = fluid.core.CPUPlace()
exece = fluid.Executor(place)
exece.run(fluid.default_startup_program())
# 初始化Tensor
tensor = fluid.core.LoDTensor()
tensor.set(np.random.randint(0, 10, (3, 1)).astype("int32"), place)
# 设置LoD
tensor.set_recursive_sequence_lengths([[1, 1, 1]])
out = exece.run(feed={'titles': tensor}, fetch_list=[hash_r], return_numpy=False)
......@@ -4478,6 +5471,7 @@ hsigmoid可以把时间复杂度 :math:`O(N)` 优化到 :math:`O(logN)` ,其中
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[2], dtype='float32')
y = fluid.layers.data(name='y', shape=[1], dtype='int64')
out = fluid.layers.hsigmoid(input=x, label=y, num_classes=6)
......@@ -4520,8 +5514,14 @@ Huber损失是更具鲁棒性的损失函数。 huber损失可以评估输入对
.. code-block:: python
predictions = fluid.layers.softmax(x)
loss = fluid.layers.huber_loss(input=predictions, label=label, 1.0)
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[13], dtype='float32')
predict = fluid.layers.fc(input=x, size=1)
label = fluid.layers.data(
name='label', shape=[1], dtype='float32')
loss = fluid.layers.huber_loss(
input=predict, label=label, delta=1.0)
......@@ -4603,8 +5603,11 @@ im2sequence
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name='data', shape=[3, 32, 32],
dtype='float32')
output = fluid.layers.im2sequence(
input=layer, stride=[1, 1], filter_size=[2, 2])
input=data, stride=[1, 1], filter_size=[2, 2])
......@@ -4717,18 +5720,20 @@ https://en.wikipedia.org/wiki/Bilinear_interpolation。
抛出异常：
- :code:`TypeError` - out_shape应该是一个列表、元组或变量。
- :code:`TypeError` - actual_shape应该是变量或None
- :code:`TypeError` - actual_shape应该是变量或None。
- :code:`ValueError` - image_resize的"resample"只能是"BILINEAR"或"NEAREST"。
- :code:`ValueError` - out_shape 和 scale 不可同时为 None
- :code:`ValueError` - out_shape 的长度必须为 2
- :code:`TypeError` - align_corners 应为bool型
- :code:`ValueError` - align_mode 只能取 ‘0’ 或 ‘1’
- :code:`ValueError` - out_shape 和 scale 不可同时为 None。
- :code:`ValueError` - out_shape 的长度必须为 2。
- :code:`ValueError` - scale应大于0。
- :code:`TypeError` - align_corners 应为bool型。
- :code:`ValueError` - align_mode 只能取 ‘0’ 或 ‘1’。
**代码示例**
.. code-block:: python
input = fluid.layers.data(name="input", shape=[3,6,9], dtype="float32")
out = fluid.layers.image_resize(input, out_shape=[12, 12], resample="NEAREST")
......@@ -4760,7 +5765,12 @@ image_resize_short
返回类型: 变量（variable）
**代码示例**
.. code-block:: python
input = fluid.layers.data(name="input", shape=[3,6,9], dtype="float32")
out = fluid.layers.image_resize_short(input, out_short_len=3)
.. _cn_api_fluid_layers_kldiv_loss:
......@@ -4831,7 +5841,7 @@ L2正则（L2 normalize Layer）
参数：
- **x** (Variable|list)- l2正则层（l2_normalize layer）的输入
- **axis** (int)-运用归一化的轴。如果轴小于0，归一化的维是rank(X)+axis。-1是最后维
- **epsilon** (float)-epsilon用于避免分母为0，默认值为1e-10
- **epsilon** (float)-epsilon用于避免分母为0，默认值为1e-12
- **name** (str|None)-该层名称（可选）。如果设为空，则自动为该层命名
返回：输出张量，同x的维度一致
......@@ -4891,6 +5901,8 @@ label_smooth
.. code-block:: python
import paddle.fluid.layers as layers
label = fluid.layers.data(name="label", shape=[1], dtype="float32")
one_hot_label = fluid.layers.one_hot(input=label, depth=10)
smooth_label = fluid.layers.label_smooth(
......@@ -5052,6 +6064,19 @@ linear_chain_crf
返回类型：output（Variable）
**代码示例：**
.. code-block:: python
import paddle.fluid as fluid
emission = fluid.layers.data(name='emission', shape=[1000], dtype='float32')
target = fluid.layers.data(name='target', shape=[1], dtype='int32')
crf_cost = fluid.layers.linear_chain_crf(
input=emission,
label=target,
param_attr=fluid.ParamAttr(
name='crfw',
learning_rate=0.2))
......@@ -5177,6 +6202,7 @@ log
.. code-block:: python
x = fluid.layers.data(name="x", shape=[3, 4], dtype="float32")
output = fluid.layers.log(x)
......@@ -5220,7 +6246,8 @@ log_loss
.. code-block:: python
prob = fluid.layers.sigmoid(net)
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
prob = fluid.layers.data(name='prob', shape=[10], dtype='float32')
cost = fluid.layers.log_loss(input=prob, label=label)
......@@ -5511,17 +6538,21 @@ sigmoid的计算公式为： :math:`sigmoid(x) = 1 / (1 + e^{-x})` 。
.. code-block:: python
input = embedding
emb_dim = 256
vocab_size = 10000
data = fluid.layers.data(name='x', shape=[-1, 100, 1],
dtype='int32')
emb = fluid.layers.embedding(input=data, size=[vocab_size, emb_dim], is_sparse=True)
batch_size = 20
max_len = 100
dropout_prob = 0.2
input_size = 100
hidden_size = 150
num_layers = 1
init_hidden1 = fluid.layers.fill_constant( [num_layers, batch_size, hidden_size], 'float32', 0.0, stop_grad=False)
init_cell1 = fluid.layers.fill_constant( [num_layers, batch_size, hidden_size], 'float32', 0.0, stop_grad=False)
init_h = layers.fill_constant( [num_layers, batch_size, hidden_size], 'float32', 0.0 )
init_c = layers.fill_constant( [num_layers, batch_size, hidden_size], 'float32', 0.0 )
rnn_out, last_h, last_c = fluid.layers.lstm( input, init_h, init_c, max_len, dropout_prob, input_size, hidden_size, num_layers)
rnn_out, last_h, last_c = fluid.layers.lstm(emb, init_h, init_c, max_len, hidden_size, num_layers, dropout_prob=dropout_prob)
......@@ -5565,7 +6596,7 @@ lstm单元的输入包括 :math:`x_{t}` ， :math:`h_{t-1}` 和 :math:`c_{t-1}`
i_{t} = \sigma \left ( L_{i_{t}} \right )
该层有 :math:`h_{t}` 和 :math:`o_{t}` 两个输出。
该层有 :math:`h_{t}` 和 :math:`c_{t}` 两个输出。
参数：
- **x_t** (Variable) - 当前步的输入值，二维张量，shape为 M x N ，M是批尺寸，N是输入尺寸
......@@ -5587,10 +6618,15 @@ lstm单元的输入包括 :math:`x_{t}` ， :math:`h_{t-1}` 和 :math:`c_{t-1}`
.. code-block:: python
x_t = fluid.layers.fc(input=x_t_data, size=10)
prev_hidden = fluid.layers.fc(input=prev_hidden_data, size=30)
prev_cell = fluid.layers.fc(input=prev_cell_data, size=30)
hidden_value, cell_value = fluid.layers.lstm_unit(x_t=x_t,
import paddle.fluid as fluid
dict_dim, emb_dim, hidden_dim = 128, 64, 512
data = fluid.layers.data(name='step_data', shape=[1], dtype='int32')
x = fluid.layers.embedding(input=data, size=[dict_dim, emb_dim])
pre_hidden = fluid.layers.data(name='pre_hidden', shape=[hidden_dim], dtype='float32')
pre_cell = fluid.layers.data(name='pre_cell', shape=[hidden_dim], dtype='float32')
hidden = fluid.layers.lstm_unit(
x_t=x,
hidden_t_prev=prev_hidden,
cell_t_prev=prev_cell)
......@@ -5637,9 +6673,9 @@ margin rank loss（差距排序损失）层。在排序问题中，它可以比
.. code-block:: python
label = fluid.layers.data(name="label", shape=[4, 1], dtype="float32")
left = fluid.layers.data(name="left", shape=[4, 1], dtype="float32")
right = fluid.layers.data(name="right", shape=[4, 1], dtype="float32")
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)
......@@ -5693,27 +6729,29 @@ matmul
# 以下是解释输入和输出维度的示例
# x: [B, ..., M, K], y: [B, ..., K, N]
fluid.layers.matmul(x, y) # out: [B, ..., M, N]
# fluid.layers.matmul(x, y) # out: [B, ..., M, N]
# x: [B, M, K], y: [B, K, N]
fluid.layers.matmul(x, y) # out: [B, M, N]
# fluid.layers.matmul(x, y) # out: [B, M, N]
# x: [B, M, K], y: [K, N]
fluid.layers.matmul(x, y) # out: [B, M, N]
# fluid.layers.matmul(x, y) # out: [B, M, N]
# x: [M, K], y: [K, N]
fluid.layers.matmul(x, y) # out: [M, N]
# fluid.layers.matmul(x, y) # out: [M, N]
# x: [B, M, K], y: [K]
fluid.layers.matmul(x, y) # out: [B, M]
# fluid.layers.matmul(x, y) # out: [B, M]
# x: [K], y: [K]
fluid.layers.matmul(x, y) # out: [1]
# fluid.layers.matmul(x, y) # out: [1]
# x: [M], y: [N]
fluid.layers.matmul(x, y, True, True) # out: [M, N]
# fluid.layers.matmul(x, y, True, True) # out: [M, N]
x = fluid.layers.data(name='x', shape=[2, 3], dtype='float32')
y = fluid.layers.data(name='y', shape=[3, 2], dtype='float32')
out = fluid.layers.matmul(x, y, True, True)
......@@ -5746,12 +6784,22 @@ maxout
参数：
- **x** (Variable) - (tensor) maxout算子的输入张量。输入张量的格式为NCHW。其中N为 batch size ，C为通道数，H和W为feature的高和宽
- **groups** （INT）- 指定输入张量将被分成多少组“通道维数”。输出通道的数量以组为单位。
- **groups** （INT）- 指定将输入张量的channel通道维度进行分组的数目。输出的通道数量为通道数除以组数。
- **name** (basestring|None) - 输出的名称
返回：Tensor，maxout算子的输出张量。输出张量的格式也是NCHW。其中N为 batch size，C为通道数，H和W为特征的高和宽。
返回类型：out（variable）
返回类型：out（Variable）
**代码示例**：
.. code-block:: python
input = fluid.layers.data(
name='data',
shape=[256, 32, 32],
dtype='float32')
out = fluid.layers.maxout(input, groups=2)
......@@ -5779,6 +6827,13 @@ mean算子计算X中所有元素的平均值
返回类型： Variable
**代码示例**：
.. code-block:: python
input = fluid.layers.data(
name='data', shape=[2, 3], dtype='float32')
mean = fluid.layers.mean(input)
......@@ -5820,6 +6875,9 @@ mean_iou
.. code-block:: python
import paddle.fluid as fluid
predict = fluid.layers.data(name='predict', shape=[3, 32, 32])
label = fluid.layers.data(name='label', shape=[1])
iou, wrongs, corrects = fluid.layers.mean_iou(predict, label, num_classes)
......@@ -5866,7 +6924,15 @@ merge_selected_rows
返回类型: 变量（Variable）
**代码示例**
.. code-block:: python
b = fluid.default_main_program().global_block()
var = b.create_var(
name="X", dtype="float32", persistable=True,
type=fluid.core.VarDesc.VarType.SELECTED_ROWS)
y = fluid.layers.merge_selected_rows(var)
......@@ -5903,9 +6969,16 @@ mul算子
返回类型： 输出(Variable)。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
dataX = fluid.layers.data(name="dataX", append_batch_size = False, shape=[2, 5], dtype="float32")
dataY = fluid.layers.data(name="dataY", append_batch_size = False, shape=[5, 3], dtype="float32")
output = fluid.layers.mul(dataX, dataY,
x_num_col_dims = 1,
y_num_col_dims = 1)
......@@ -6040,10 +7113,12 @@ nce
.. code-block:: python
import numpy as np
window_size = 5
words = []
for i in xrange(window_size):
words.append(layers.data(
words.append(fluid.layers.data(
name='word_{0}'.format(i), shape=[1], dtype='int64'))
dict_size = 10000
......@@ -6055,25 +7130,26 @@ nce
continue
emb = fluid.layers.embedding(input=words[i], size=[dict_size, 32],
param_attr='emb.w', is_sparse=True)
param_attr='embed', is_sparse=True)
embs.append(emb)
embs = fluid.layers.concat(input=embs, axis=1)
loss = fluid.layers.nce(input=embs, label=words[label_word],
num_total_classes=dict_size, param_attr='nce.w',
bias_attr='nce.b')
num_total_classes=dict_size, param_attr='nce.w_0',
bias_attr='nce.b_0')
#使用custom distribution
dist = fluid.layers.assign(input=np.array([0.05,0.5,0.1,0.3,0.05]).astype("float32"))
# 或使用自定义分布
dist = np.array([0.05,0.5,0.1,0.3,0.05])
loss = fluid.layers.nce(input=embs, label=words[label_word],
num_total_classes=5, param_attr='nce.w',
bias_attr='nce.b',
num_total_classes=5, param_attr='nce.w_1',
bias_attr='nce.b_1',
num_neg_samples=3,
sampler="custom_dist",
custom_dist=dist)
.. _cn_api_fluid_layers_npair_loss:
npair_loss
......@@ -6136,7 +7212,7 @@ one_hot
.. code-block:: python
label = fluid.layers.data(name="label", shape=[1], dtype="float32")
label = fluid.layers.data(name="label", shape=[1], dtype="int64")
one_hot_label = fluid.layers.one_hot(input=label, depth=10)
......@@ -6191,6 +7267,9 @@ pad
.. code-block:: python
# x 为一个秩为2的张量
import paddle.fluid as fluid
x = fluid.layers.data(name='data', shape=[224], dtype='float32')
out = fluid.layers.pad(
x=x, paddings=[0, 1, 1, 2], pad_value=0.)
......@@ -6260,8 +7339,9 @@ pad2d
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name='data', shape=[3, 32, 32], dtype='float32')
result = fluid.layers.pad2d(input=data, padding=[1,2,3,4], mode='reflect')
result = fluid.layers.pad2d(input=data, paddings=[1,2,3,4], mode='reflect')
......@@ -6320,10 +7400,13 @@ pad_constant_like
.. code-block:: python
# x是秩为4的tensor, x.shape = (2, 3, 2, 3)。
# y是秩为4的tensor, y.shape = (1, 3, 1, 3)。
# x是秩为4的tensor, x.shape = (2, 3, 2, 3)
# y是秩为4的tensor, y.shape = (1, 3, 1, 3)
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[2,3,2,3], dtype='float32')
y = fluid.layers.data(name='y', shape=[1,3,1,3], dtype='float32')
out = fluid.layers.pad_constant_like(x=x, y=y, pad_value=0.)
# out是秩为4的tensor, out.shape = [2, 3 ,2 , 3]。
# out是秩为4的tensor, out.shape = [2, 3 ,2 , 3]
......@@ -6361,7 +7444,7 @@ pixel shuffle 层（像素重组层）
.. code-block:: python
input = fluid.layers.data(shape=[9,4,4])
input = fluid.layers.data(name="input", shape=[9,4,4])
output = fluid.layers.pixel_shuffle(x=input, upscale_factor=3)
......@@ -6591,6 +7674,7 @@ pow
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name="x", shape=[3,10,32,32], dtype="float32")
y = fluid.layers.pow(x, factor=2.0)
......@@ -6611,10 +7695,19 @@ prelu
.. math::
y = max(0, x) + \alpha min(0, x)
共提供三种激活方式：
.. code-block:: text
all: 所有元素使用同一个alpha值
channel: 在同一个通道中的元素使用同一个alpha值
element: 每一个元素有一个独立的alpha值
参数：
- **x** （Variable）- 输入为Tensor。
- **param_attr** (ParamAttr|None) - 可学习权重 :math:`[\alpha]` 的参数属性。
- **mode** （string）- 权重共享的模式all：所有元素共享相同的权重通道：通道中的元素共享相同的权重元素：每个元素都有一个权重
- **mode** (string) - 权重共享模式。
- **param_attr** (ParamAttr|None) - 可学习权重 :math:`[\alpha]` 的参数属性，可由ParamAttr创建。
- **name** （str | None）- 这一层的名称（可选）。如果设置为None，则将自动命名这一层。
返回： 输出Tensor与输入shape相同。
......@@ -6625,9 +7718,15 @@ prelu
.. code-block:: python
x = fluid.layers.data(name="x", shape=[10,10], dtype="float32")
import paddle.fluid as fluid
from paddle.fluid.param_attr import ParamAttr
x = fluid.layers.data(name="x", shape=[5,10,10], dtype="float32")
mode = 'channel'
output = fluid.layers.prelu(x,mode)
output = fluid.layers.prelu(
x,mode,param_attr=ParamAttr(name='alpha'))
.. _cn_api_fluid_layers_psroi_pool:
......@@ -6644,7 +7743,7 @@ PSROIPool运算
参数：
- **input** （Variable） - （Tensor），PSROIPoolOp的输入。 输入张量的格式是NCHW。 其中N是批大小batch_size，C是输入通道的数量，H是输入特征图的高度，W是特征图宽度
- **rois** （Variable） - 要进行池化的RoI（感兴趣区域）。
- **rois** （Variable） - 要进行池化的RoI（感兴趣区域）。应为一个形状为(num_rois, 4)的二维LoDTensor，其lod level为1。给出[[x1, y1, x2, y2], ...]，(x1, y1)为左上角坐标，(x2, y2)为右下角坐标。
- **output_channels** （integer） - （int），输出特征图的通道数。 对于共C个种类的对象分类任务，output_channels应该是（C + 1），该情况仅适用于分类任务。
- **spatial_scale** （float） - （float，default 1.0），乘法空间比例因子，用于将ROI坐标从其输入比例转换为池化使用的比例。默认值：1.0
- **pooled_height** （integer） - （int，默认值1），池化输出的高度。默认值：1
......@@ -6659,7 +7758,10 @@ PSROIPool运算
.. code-block:: python
pool_out = fluid.layers.psroi_pool(input=x, rois=rois, 490, 1.0, 7, 7)
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[490, 28, 28], dtype='float32')
rois = fluid.layers.data(name='rois', shape=[4], lod_level=1, dtype='float32')
pool_out = fluid.layers.psroi_pool(x, rois, 10, 1.0, 7, 7)
......@@ -6769,9 +7871,31 @@ random_crop
.. _cn_api_fluid_layers_rank:
rank
-------------------------------
.. py:function:: paddle.fluid.layers.rank(input)
排序层
返回张量的维数，一个数据类型为int32的0-D Tensor。
参数:
- **input** (Variable)：输入变量
返回：输入变量的秩
返回类型： 变量（Variable）
**代码示例**
.. code-block:: python
input = layers.data(
name="input", shape=[3, 100, 100], dtype="float32")
rank = layers.rank(input) # 4
.. _cn_api_fluid_layers_rank_loss:
......@@ -6800,7 +7924,7 @@ P 的取值可为： {0, 1} 或 {0, 0.5, 1}, 其中，0.5表示输入的两文
参数：
- **label** (Variable)：A的排名是否高于B
- **left** (Variable)：RankNet对doc A的输出分数
- **right** (Variable): RankNet对doc B的输出分数
- **right** (Variable)：RankNet对doc B的输出分数
- **name** (str|None)：此层的名称(可选)。如果没有设置，层将自动命名。
返回：rank loss的值
......@@ -6813,15 +7937,80 @@ P 的取值可为： {0, 1} 或 {0, 0.5, 1}, 其中，0.5表示输入的两文
.. code-block:: python
label = fluid.layers.data(name="label", shape=[4, 1], dtype="float32")
left = fluid.layers.data(name="left", shape=[4, 1], dtype="float32")
right = fluid.layers.data(name="right", shape=[4, 1], dtype="float32")
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.rank_loss(label, left, right)
.. _cn_api_fluid_layers_reduce_all:
reduce_all
-------------------------------
.. py:function:: paddle.fluid.layers.reduce_all(input, dim=None, keep_dim=False, name=None)
计算给定维度上张量（Tensor）元素的与逻辑。
参数：
- **input** （Variable）：输入变量为Tensor或LoDTensor。
- **dim** （list | int | None）：与逻辑运算的维度。如果为None，则计算所有元素的与逻辑并返回包含单个元素的Tensor变量，否则必须在 :math:`[−rank(input),rank(input)]` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
- **keep_dim** （bool | False）：是否在输出Tensor中保留减小的维度。除非 ``keep_dim`` 为true，否则结果张量的维度将比输入张量小。
- **name** （str | None）：这一层的名称（可选）。如果设置为None，则将自动命名这一层。
返回： 减少维度之后的Tensor变量。
返回类型： 变量（Variable）
**代码示例**
.. code-block:: python
# x是一个布尔型Tensor，元素如下:
# [[True, False]
# [True, True]]
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
fluid.layers.reduce_all(x) # False
fluid.layers.reduce_all(x, dim=0) # [True, False]
fluid.layers.reduce_all(x, dim=-1) # [False, True]
fluid.layers.reduce_all(x, dim=1,
keep_dim=True) # [[False], [True]]
.. _cn_api_fluid_layers_reduce_any:
reduce_any
-------------------------------
.. py:function:: paddle.fluid.layers.reduce_any(input, dim=None, keep_dim=False, name=None)
计算给定维度上张量（Tensor）元素的或逻辑。
参数：
- **input** （Variable）：输入变量为Tensor或LoDTensor。
- **dim** （list | int | None）：或逻辑运算的维度。如果为None，则计算所有元素的或逻辑并返回仅包含单个元素的Tensor变量，否则必须在 :math:`[−rank(input),rank(input)]` 范围内。如果 :math:`dim [i] <0` ，则维度将减小为 :math:`rank+dim[i]` 。
- **keep_dim** （bool | False）：是否在输出Tensor中保留减小的维度。除非 ``keep_dim`` 为true，否则结果张量的维度将比输入张量小。
- **name** （str | None）：这一层的名称（可选）。如果设置为None，则将自动命名这一层。
返回： 减少维度之后的Tensor变量。
返回类型： 变量（Variable）
**代码示例**
.. code-block:: python
# x是一个布尔型Tensor，元素如下:
# [[True, False]
# [False, False]]
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
fluid.layers.reduce_any(x) # True
fluid.layers.reduce_any(x, dim=0) # [True, False]
fluid.layers.reduce_any(x, dim=-1) # [True, False]
fluid.layers.reduce_any(x, dim=1,
keep_dim=True) # [[True], [False]]
......@@ -6851,21 +8040,24 @@ reduce_max
.. code-block:: python
import paddle.fluid as fluid
# x是一个Tensor，元素如下:
# [[0.2, 0.3, 0.5, 0.9]
# [0.1, 0.2, 0.6, 0.7]]
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。。
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
x = fluid.layers.data(name='x', shape=[4, 2], dtype='float32')
fluid.layers.reduce_max(x) # [0.9]
fluid.layers.reduce_max(x, dim=0) # [0.2, 0.3, 0.6, 0.9]
fluid.layers.reduce_max(x, dim=-1) # [0.9, 0.7]
fluid.layers.reduce_max(x, dim=1, keep_dim=True) # [[0.9], [0.7]]
# x是一个shape为[2, 2, 2]的Tensor，元素如下:
# y是一个shape为[2, 2, 2]的Tensor，元素如下:
# [[[1.0, 2.0], [3.0, 4.0]],
# [[5.0, 6.0], [7.0, 8.0]]]
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。。
fluid.layers.reduce_max(x, dim=[1, 2]) # [4.0, 8.0]
fluid.layers.reduce_max(x, dim=[0, 1]) # [7.0, 8.0]
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
y = fluid.layers.data(name='y', shape=[2, 2, 2], dtype='float32')
fluid.layers.reduce_max(y, dim=[1, 2]) # [4.0, 8.0]
fluid.layers.reduce_max(y, dim=[0, 1]) # [7.0, 8.0]
......@@ -6899,22 +8091,24 @@ reduce_mean
.. code-block:: python
import paddle.fluid as fluid
# x是一个Tensor，元素如下:
# [[0.2, 0.3, 0.5, 0.9]
# [0.1, 0.2, 0.6, 0.7]]
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
x = fluid.layers.data(name='x', shape=[4, 2], dtype='float32')
fluid.layers.reduce_mean(x) # [0.4375]
fluid.layers.reduce_mean(x, dim=0) # [0.15, 0.25, 0.55, 0.8]
fluid.layers.reduce_mean(x, dim=-1) # [0.475, 0.4]
fluid.layers.reduce_mean(
x, dim=1, keep_dim=True) # [[0.475], [0.4]]
fluid.layers.reduce_mean(x, dim=1, keep_dim=True) # [[0.475], [0.4]]
# x 是一个shape为[2, 2, 2]的Tensor元素如下:
# y是一个shape为[2, 2, 2]的Tensor元素如下:
# [[[1.0, 2.0], [3.0, 4.0]],
# [[5.0, 6.0], [7.0, 8.0]]]
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。。
fluid.layers.reduce_mean(x, dim=[1, 2]) # [2.5, 6.5]
fluid.layers.reduce_mean(x, dim=[0, 1]) # [4.0, 5.0]
y = fluid.layers.data(name='y', shape=[2, 2, 2], dtype='float32')
fluid.layers.reduce_mean(y, dim=[1, 2]) # [2.5, 6.5]
fluid.layers.reduce_mean(y, dim=[0, 1]) # [4.0, 5.0]
......@@ -6948,21 +8142,24 @@ reduce_min
.. code-block:: python
import paddle.fluid as fluid
# x是一个Tensor，元素如下:
# [[0.2, 0.3, 0.5, 0.9]
# [0.1, 0.2, 0.6, 0.7]]
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
x = fluid.layers.data(name='x', shape=[4, 2], dtype='float32')
fluid.layers.reduce_min(x) # [0.1]
fluid.layers.reduce_min(x, dim=0) # [0.1, 0.2, 0.5, 0.7]
fluid.layers.reduce_min(x, dim=-1) # [0.2, 0.1]
fluid.layers.reduce_min(x, dim=1, keep_dim=True) # [[0.2], [0.1]]
# x 是一个shape为[2, 2, 2]的Tensor元素如下:
# y是一个shape为[2, 2, 2]的Tensor元素如下:
# [[[1.0, 2.0], [3.0, 4.0]],
# [[5.0, 6.0], [7.0, 8.0]]]
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。。
fluid.layers.reduce_min(x, dim=[1, 2]) # [1.0, 5.0]
fluid.layers.reduce_min(x, dim=[0, 1]) # [1.0, 2.0]
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
y = fluid.layers.data(name='y', shape=[2, 2, 2], dtype='float32')
fluid.layers.reduce_min(y, dim=[1, 2]) # [1.0, 5.0]
fluid.layers.reduce_min(y, dim=[0, 1]) # [1.0, 2.0]
......@@ -6996,22 +8193,25 @@ reduce_prod
.. code-block:: python
import paddle.fluid as fluid
# x是一个Tensor，元素如下:
# [[0.2, 0.3, 0.5, 0.9]
# [0.1, 0.2, 0.6, 0.7]]
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
x = fluid.layers.data(name='x', shape=[4, 2], dtype='float32')
fluid.layers.reduce_prod(x) # [0.0002268]
fluid.layers.reduce_prod(x, dim=0) # [0.02, 0.06, 0.3, 0.63]
fluid.layers.reduce_prod(x, dim=-1) # [0.027, 0.0084]
fluid.layers.reduce_prod(x, dim=1,
keep_dim=True) # [[0.027], [0.0084]]
# x 是一个shape为[2, 2, 2]的Tensor元素如下:
# y 是一个shape为[2, 2, 2]的Tensor元素如下:
# [[[1.0, 2.0], [3.0, 4.0]],
# [[5.0, 6.0], [7.0, 8.0]]]
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
fluid.layers.reduce_prod(x, dim=[1, 2]) # [24.0, 1680.0]
fluid.layers.reduce_prod(x, dim=[0, 1]) # [105.0, 384.0]
y = fluid.layers.data(name='y', shape=[2, 2, 2], dtype='float32')
fluid.layers.reduce_prod(y, dim=[1, 2]) # [24.0, 1680.0]
fluid.layers.reduce_prod(y, dim=[0, 1]) # [105.0, 384.0]
......@@ -7045,21 +8245,24 @@ reduce_sum
.. code-block:: python
import paddle.fluid as fluid
# x是一个Tensor，元素如下:
# [[0.2, 0.3, 0.5, 0.9]
# [0.1, 0.2, 0.6, 0.7]]
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
x = fluid.layers.data(name='x', shape=[4, 2], dtype='float32')
fluid.layers.reduce_sum(x) # [3.5]
fluid.layers.reduce_sum(x, dim=0) # [0.3, 0.5, 1.1, 1.6]
fluid.layers.reduce_sum(x, dim=-1) # [1.9, 1.6]
fluid.layers.reduce_sum(x, dim=1, keep_dim=True) # [[1.9], [1.6]]
# x 是一个shape为[2, 2, 2]的Tensor元素如下:
# y 是一个shape为[2, 2, 2]的Tensor元素如下:
# [[[1, 2], [3, 4]],
# [[5, 6], [7, 8]]]
# 接下来的示例中，我们在每处函数调用后面都标注出了它的结果张量。
fluid.layers.reduce_sum(x, dim=[1, 2]) # [10, 26]
fluid.layers.reduce_sum(x, dim=[0, 1]) # [16, 20]
y = fluid.layers.data(name='y', shape=[2, 2, 2], dtype='float32')
fluid.layers.reduce_sum(y, dim=[1, 2]) # [10, 26]
fluid.layers.reduce_sum(y, dim=[0, 1]) # [16, 20]
......@@ -7095,6 +8298,7 @@ Relu接受一个输入数据(张量)，输出一个张量。将线性函数y = m
.. code-block:: python
x = fluid.layers.data(name="x", shape=[3, 4], dtype="float32")
output = fluid.layers.relu(x)
......@@ -7255,8 +8459,8 @@ align_corners和align_mode是可选参数，插值的计算方法可以由它们
参数:
- **input** (Variable) - 双线性插值的输入张量，是一个shape为(N x C x h x w)的4d张量。
- **out_shape** (Variable) - 一维张量，包含两个数。第一个数是高度，第二个数是宽度。
- **scale** (float|None) - 用于输入高度或宽度的乘数因子。out_shape和scale至少要设置一个。out_shape的优先级高于scale。默认值:None。
- **out_shape** (list|tuple|Variable|None) - 调整双线性层的输出形状，形式为(out_h, out_w)。默认值：None。
- **scale** (float|None) - 用于输入高度或宽度的乘数因子。out_shape和scale至少要设置一个。out_shape的优先级高于scale。默认值：None。
- **name** (str|None) - 输出变量名。
- **actual_shape** (Variable) - 可选输入，用于动态指定输出形状。如果指定actual_shape，图像将根据给定的形状调整大小，而不是根据指定形状的 :code:`out_shape` 和 :code:`scale` 进行调整。也就是说， :code:`actual_shape` 具有最高的优先级。如果希望动态指定输出形状，建议使用 :code:`actual_shape` 而不是 :code:`out_shape` 。在使用actual_shape指定输出形状时，还需要设置out_shape和scale之一，否则在图形构建阶段会出现错误。默认值:None
- **align_corners** （bool）- 一个可选的bool型参数，如果为True，则将输入和输出张量的4个角落像素的中心对齐，并保留角点像素的值。 默认值：True
......@@ -7266,10 +8470,11 @@ align_corners和align_mode是可选参数，插值的计算方法可以由它们
返回： 插值运算的输出张量，其各维度是(N x C x out_h x out_w)
**代码示例：**
**代码示例**
.. code-block:: python
input = fluid.layers.data(name="input", shape=[3,6,9], dtype="float32")
out = fluid.layers.resize_bilinear(input, out_shape=[12, 12])
......@@ -7329,7 +8534,7 @@ resize_nearest
参数:
- **input** (Variable) – 插值运算的输入张量, 是一个形为 (N,C,H,W) 的四维张量
- **out_shape** (Variable) – 一维张量，包含两个指明输出大小的数字 。 第一个代表了高度，第二个代表了宽度
- **out_shape** (list|tuple|Variable|None) – 调整最近邻层的输出形状，形式为(out_h, out_w)。默认值：None。
- **scale** (float|None) – 输入高、宽的乘法器。 ``out_shape`` 和 ``scale`` 二者至少设置其一。 ``out_shape`` 具有比 ``scale`` 更高的优先级。 默认: None
- **name** (str|None) – 输出变量的命名
- **actual_shape** (Variable) – 可选输入， 动态设置输出张量的形状。 如果提供该值， 图片放缩会依据此形状进行， 而非依据 ``out_shape`` 和 ``scale`` 。 即为， ``actual_shape`` 具有最高的优先级。 如果想动态指明输出形状，推荐使用 ``actual_shape`` 取代 ``out_shape`` 。 当使用 ``actual_shape`` 来指明输出形状， ``out_shape`` 和 ``scale`` 也应该进行设置, 否则在图形生成阶段将会报错。默认: None
......@@ -7341,6 +8546,7 @@ resize_nearest
.. code-block:: python
input = fluid.layers.data(name="input", shape=[3,6,9], dtype="float32")
out = fluid.layers.resize_nearest(input, out_shape=[12, 12])
......@@ -7384,6 +8590,10 @@ Region of Interests align(直译：有意义、有价值选区对齐) 用于实
.. code-block:: python
x = fluid.layers.data(
name='data', shape=[256, 32, 32], dtype='float32')
rois = fluid.layers.data(
name='rois', shape=[4], dtype='float32')
align_out = fluid.layers.roi_align(input=x,
rois=rois,
pooled_height=7,
......@@ -7435,8 +8645,18 @@ Faster-RCNN.使用了roi池化。roi关于roi池化请参考 https://stackoverfl
.. code-block:: python
pool_out = fluid.layers.roi_pool(input=x, rois=rois, 7,7,1.0)
import paddle.fluid as fluid
x = fluid.layers.data(
name='x', shape=[8, 112, 112], dtype='float32')
rois = fluid.layers.data(
name='roi', shape=[4], lod_level=1, dtype='float32')
pool_out = fluid.layers.roi_pool(
input=x,
rois=rois,
pooled_height=7,
pooled_width=7,
spatial_scale=1.0)
......@@ -7528,9 +8748,11 @@ sampled_softmax_with_cross_entropy
.. code-block:: python
logits = fluid.layers.data(name='data', shape=[256], dtype='float32')
import paddle.fluid as fluid
input = fluid.layers.data(name='data', shape=[256], dtype='float32')
label = fluid.layers.data(name='label', shape=[5], dtype='int64')
fc = fluid.layers.fc(input=data, size=100)
fc = fluid.layers.fc(input=input, size=100)
out = fluid.layers.sampled_softmax_with_cross_entropy(
logits=fc, label=label, num_samples=25)
......@@ -7613,6 +8835,14 @@ else:
返回类型: 变量(Variable)
**代码示例：**
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name="X", shape=[1, 2, 5, 5], dtype='float32')
y = fluid.layers.scale(x, scale = 2.0, bias = 1.0)
......@@ -7627,7 +8857,7 @@ else:
scatter
-------------------------------
.. py:function:: paddle.fluid.layers.scatter(input, index, updates, name=None)
.. py:function:: paddle.fluid.layers.scatter(input, index, updates, name=None, overwrite=True)
通过更新输入在第一维度上指定索引位置处的元素来获得输出。
......@@ -7637,10 +8867,11 @@ scatter
参数：
- **input** （Variable） - 秩> = 1的源输入
- **index** （Variable） - 秩= 1的索引输入。 它的dtype应该是int32或int64，因为它用作索引
- **updates** （Variable） - scatter 要进行更新的变量
- **name** （str | None） - 输出变量名称。 默认None
- **input** （Variable） - 秩> = 1的源输入。
- **index** （Variable） - 秩= 1的索引输入。 它的dtype应该是int32或int64，因为它用作索引。
- **updates** （Variable） - scatter 要进行更新的变量。
- **name** （str | None） - 输出变量名称。 默认None。
- **overwrite** （bool） - 具有相同索引时更新输出的模式。如果为True，则使用覆盖模式更新相同索引的输出，如果为False，则使用accumulate模式更新相同索引的grad。默认值为True。您可以设置overwrite=False以使用scatter_add。
返回：张量变量, 与输入张量的shape相同
......@@ -7650,6 +8881,12 @@ scatter
.. code-block:: python
import paddle.fluid as fluid
input = fluid.layers.data(name='data', shape=[3, 5, 9], dtype='float32', append_batch_size=False)
index = fluid.layers.data(name='index', shape=[3], dtype='int64', append_batch_size=False)
updates = fluid.layers.data(name='update', shape=[3, 5, 9], dtype='float32', append_batch_size=False)
output = fluid.layers.scatter(input, index, updates)
......@@ -7696,7 +8933,12 @@ selu
.. code-block:: python
output = fluid.layers.selu(x)
import paddle.fluid as fluid
input = fluid.layers.data(
name="input", shape=[3, 9, 5], dtype="float32")
output = fluid.layers.selu(input)
......@@ -7732,7 +8974,10 @@ sequence_concat操作通过序列信息连接LoD张量（Tensor）。例如：X1
.. code-block:: python
out = fluid.layers.sequence_concat(input=[seq1, seq2, seq3])
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[10], dtype='float32')
y = fluid.layers.data(name='y', shape=[10], dtype='float32')
out = fluid.layers.sequence_concat(input=[x, y])
......@@ -7766,7 +9011,13 @@ sequence_conv
返回类型：变量（Variable）
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[10,10], append_batch_size=False, dtype='float32')
x_conved = fluid.layers.sequence_conv(x,2)
......@@ -7807,7 +9058,7 @@ sequence_enumerate
.. code-block:: python
x = fluid.layers.data(shape[30, 1], dtype='int32', lod_level=1)
x = fluid.layers.data(shape[-1, 1], dtype='int32', lod_level=1)
out = fluid.layers.sequence_enumerate(input=x, win_size=3, pad_value=0)
......@@ -7877,6 +9128,7 @@ sequence_expand
.. code-block:: python
import paddle.fluid.layers as layers
x = fluid.layers.data(name='x', shape=[10], dtype='float32')
y = fluid.layers.data(name='y', shape=[10, 20],
dtype='float32', lod_level=1)
......@@ -7943,17 +9195,14 @@ Sequence Expand As Layer
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
x = fluid.layers.data(name='x', shape=[10], dtype='float32')
y = fluid.layers.data(name='y', shape=[10, 20],
x = fluid.layers.data(name='x', shape=[7, 1],
dtype='float32', lod_level=1)
out = fluid.layers.sequence_expand_as(x=x, y=y)
x_first_step = fluid.layers.sequence_first_step(input=x)
......@@ -8077,7 +9326,14 @@ sequence_mask
返回类型： Variable
**代码示例**：
.. code-block:: python
import paddle.fluid.layers as layers
x = fluid.layers.data(name='x', shape=[10], dtype='float32', lod_level=1)
mask = layers.sequence_mask(x=x)
......@@ -8192,7 +9448,7 @@ sequence_pad
sequence_pool
-------------------------------
.. py:function:: paddle.fluid.layers.sequence_pool(input, pool_type, is_test=False)
.. py:function:: paddle.fluid.layers.sequence_pool(input, pool_type, is_test=False, pad_value=0.0)
该函数为序列的池化添加操作符。将每个实例的所有时间步数特征池化，并用参数中提到的pool_type将特征运用到输入到首部。
......@@ -8206,26 +9462,29 @@ sequence_pool
::
x是一级LoDTensor:
x.lod = [[2, 3, 2]]
x是一级LoDTensor且**pad_value** = 0.0:
x.lod = [[2, 3, 2, 0]]
x.data = [1, 3, 2, 4, 6, 5, 1]
x.dims = [7, 1]
输出为张量（Tensor）：
out.dim = [3, 1]
out.dim = [4, 1]
with condition len(x.lod[-1]) == out.dims[0]
对于不同的pool_type：
average: out.data = [2, 4, 3], where 2=(1+3)/2, 4=(2+4+6)/3, 3=(5+1)/2
sum : out.data = [4, 12, 6], where 4=1+3, 12=2+4+6, 6=5+1
sqrt : out.data = [2.82, 6.93, 4.24], where 2.82=(1+3)/sqrt(2),
average: out.data = [2, 4, 3, 0.0], where 2=(1+3)/2, 4=(2+4+6)/3, 3=(5+1)/2
sum : out.data = [4, 12, 6, 0.0], where 4=1+3, 12=2+4+6, 6=5+1
sqrt : out.data = [2.82, 6.93, 4.24, 0.0], where 2.82=(1+3)/sqrt(2),
6.93=(2+4+6)/sqrt(3), 4.24=(5+1)/sqrt(2)
max : out.data = [3, 6, 5], where 3=max(1,3), 6=max(2,4,6), 5=max(5,1)
last : out.data = [3, 6, 1], where 3=last(1,3), 6=last(2,4,6), 1=last(5,1)
first : out.data = [1, 2, 5], where 1=first(1,3), 2=first(2,4,6), 5=first(5,1)
max : out.data = [3, 6, 5, 0.0], where 3=max(1,3), 6=max(2,4,6), 5=max(5,1)
last : out.data = [3, 6, 1, 0.0], where 3=last(1,3), 6=last(2,4,6), 1=last(5,1)
first : out.data = [1, 2, 5, 0.0], where 1=first(1,3), 2=first(2,4,6), 5=first(5,1)
且以上所有均满足0.0 = **pad_value**
参数：
- **input** (variable) - 输入变量，为LoDTensor
- **pool_type** (string) - 池化类型。支持average,sum,sqrt和max
- **is_test** (bool, 默认为 False) - 用于区分训练模式和测试评分模式
- **is_test** (bool, 默认为 False) - 用于区分训练模式和测试评分模式。默认为False。
- **pad_value** (float) - 用于填充空输入序列的池化结果。
返回：sequence pooling 变量，类型为张量（Tensor)
......@@ -8233,6 +9492,8 @@ sequence_pool
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[7, 1],
dtype='float32', lod_level=1)
avg_x = fluid.layers.sequence_pool(input=x, pool_type='average')
......@@ -8291,8 +9552,9 @@ Sequence Reshape Layer
.. code-block:: python
x = fluid.layers.data(shape=[5, 20], dtype='float32', lod_level=1)
x_reshaped = fluid.layers.sequence_reshape(input=x, new_dim=10)
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[2, 6], append_batch_size=False, dtype='float32', lod_level=1)
x_reshaped = fluid.layers.sequence_reshape(input=x, new_dim=4)
......@@ -8309,7 +9571,6 @@ sequence_reverse
.. py:function:: paddle.fluid.layers.sequence_reverse(x, name=None)
**实现SequenceReverse（序列倒序）运算**
在第0维上将输入 ``x`` 的各序列倒序。
......@@ -8341,9 +9602,13 @@ sequence_reverse
返回类型：Variable
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[2, 6], dtype='float32')
x_reversed = fluid.layers.sequence_reverse(x)
......@@ -8403,6 +9668,11 @@ sequence_scatter
.. code-block:: python
import paddle.fluid.layers as layers
input = layers.data( name="x", shape=[3, 6], append_batch_size=False, dtype='float32' )
index = layers.data( name='index', shape=[1], dtype='int32')
updates = layers.data( name='updates', shape=[1], dtype='float32')
output = fluid.layers.sequence_scatter(input, index, updates)
......@@ -8602,6 +9872,7 @@ shape层。
.. code-block:: python
import paddle.fluid as fluid
input = fluid.layers.data(
name="input", shape=[3, 100, 100], dtype="float32")
out = fluid.layers.shape(input)
......@@ -8722,7 +9993,7 @@ sigmoid_cross_entropy_with_logits
返回： (Tensor, 默认Tensor<float>), 形为 N x D 的二维张量，其值代表了按元素的逻辑loss
返回类型: Variable
返回类型：Variable
......@@ -8747,6 +10018,32 @@ sigmoid_cross_entropy_with_logits
.. _cn_api_fluid_layers_sign:
sign
-------------------------------
.. py:function:: paddle.fluid.layers.sign(x)
此函数返回x中每个元素的正负号：1代表正，-1代表负，0代表零。
参数：
- **x** (Variable|numpy.ndarray) – 输入张量。
返回：输出正负号张量，和x有着相同的形状和数据类型。
返回类型：Variable
**代码示例**
.. code-block:: python
# [1, 0, -1]
data = fluid.layers.sign(np.array([3, 0, -2]))
.. _cn_api_fluid_layers_similarity_focus:
......@@ -8833,8 +10130,8 @@ similarity_focus
.. code-block:: python
data = fluid.layers.data(
name='data', shape=[2, 3, 2, 2], dtype='float32')
x = fluid.layers.layer_norm(input=data, axis=1, indexes=[0])
name='data', shape=[-1, 3, 2, 2], dtype='float32')
fluid.layers.similarity_focus(input=data, axis=1, indexes=[0])
......@@ -8856,18 +10153,21 @@ slice
slice算子。
沿多个轴生成输入张量的切片。与numpy类似： https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html Slice使用 ``axes`` 、 ``starts`` 和 ``ends`` 属性来指定轴列表中每个轴的起点和终点维度，它使用此信息来对输入数据张量切片。如果向 ``starts`` 或 ``ends`` 传递负值，则表示该维度结束之前的元素数目。如果传递给 ``starts`` 或 ``end`` 的值大于n（此维度中的元素数目），则表示n。对于未知大小维度的末尾进行切片，则建议传入 ``INT_MAX`` 。如果省略轴，则将它们设置为[0，...，ndim-1]。以下示例将解释切片如何工作：
沿多个轴生成输入张量的切片。与numpy类似： https://docs.scipy.org/doc/numpy/reference/arrays.indexing.html Slice使用 ``axes`` 、 ``starts`` 和 ``ends`` 属性来指定轴列表中每个轴的起点和终点维度，它使用此信息来对输入数据张量切片。如果向 ``starts`` 或 ``ends`` 传递负值，则表示该维度结束之前的元素数目。如果传递给 ``starts`` 或 ``end`` 的值大于n（此维度中的元素数目），则表示n。当切片一个未知数量的唯独时，建议传入INT_MAX. ``axes`` 的大小必须和 ``starts`` 和 ``ends`` 的相等。以下示例将解释切片如何工作：
::
案例1：给定：data=[[1,2,3,4],[5,6,7,8],]
案例1：
给定：
data=[[1,2,3,4],[5,6,7,8],]
axes=[0,1]
starts=[1,0]
ends=[2,3]
则：
result=[[5,6,7],]
案例2：给定：
案例2：
给定：
data=[[1,2,3,4],[5,6,7,8],]
starts=[0,1]
ends=[-1,1000]
......@@ -8889,6 +10189,8 @@ slice算子。
.. code-block:: python
import paddle.fluid as fluid
starts = [1, 0, 2]
ends = [3, 3, 4]
axes = [0, 1, 2]
......@@ -8964,6 +10266,8 @@ SoftRelu 激活函数
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name=”x”, shape=[2,3,16,16], dtype=”float32”)
y = fluid.layers.soft_relu(x, threshold=20.0)
......@@ -9009,6 +10313,8 @@ softmax操作符计算k维向量输入中所有其他维的指数和指数值的
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[2], dtype='float32')
fc = fluid.layers.fc(input=x, size=10)
# 在第二维执行softmax
softmax = fluid.layers.softmax(input=fc, axis=1)
......@@ -9028,9 +10334,9 @@ softmax操作符计算k维向量输入中所有其他维的指数和指数值的
softmax_with_cross_entropy
-------------------------------
.. py:function:: paddle.fluid.layers.softmax_with_cross_entropy(logits, label, soft_label=False, ignore_index=-100, numeric_stable_mode=True, return_softmax=False)
.. py:function:: paddle.fluid.layers.softmax_with_cross_entropy(logits, label, soft_label=False, ignore_index=-100, numeric_stable_mode=True, return_softmax=False, axis=-1)
使用softmax的交叉熵在输出层已被广泛使用。该函数计算输入张量每一行的softmax标准化值，而后计算交叉熵。通过此种方式，可以得到更具数字稳定性的梯度值。
使用softmax的交叉熵在输出层已被广泛使用。该函数计算输入张量在axis轴上的softmax标准化值，而后计算交叉熵。通过此种方式，可以得到更具数字稳定性的梯度值。
因为该运算是在内部进行logit上的softmax运算，所以它需要未标准化（unscaled）的logit。该运算不应该对softmax运算的输出进行操作，否则会得出错误结果。
......@@ -9057,17 +10363,17 @@ softmax_with_cross_entropy
参数:
- **logits** (Variable) - 未标准化(unscaled)的log概率,一个形为 N X K 的二维张量。 N是batch大小，K是类别总数。
- **label** (Variable) - 2-D 张量，代表了正确标注（ground truth）, 如果 ``soft_label`` 为 False，则该参数是一个形为 N X 1 的Tensor<int64> 。如果 ``soft_label`` 为 True，它是 Tensor<float/double> ，形为 N X K 。
- **logits** (Variable) - 未标准化(unscaled)对数概率的输入张量。
- **label** (Variable) - 真实值张量。如果 ``soft_label`` 为True，则该参数是一个和logits形状相同的的Tensor<float/double> 。如果 ``soft_label`` 为False，label是一个在axis维上形为1，其它维上与logits形对应相同的Tensor<int64>。
- **soft_label** (bool) - 是否将输入标签当作软标签。默认为False。
- **ignore_index** (int) - 指明要无视的目标值，使之不对输入梯度有贡献。仅在 ``soft_label`` 为False时有效，默认为kIgnoreIndex。
- **numeric_stable_mode** (bool) – 标志位，指明是否使用一个具有更佳数学稳定性的算法。仅在 ``soft_label`` 为 False的GPU模式下生效. 若 ``soft_label`` 为 True 或者执行场所为CPU, 算法一直具有数学稳定性。 注意使用稳定算法时速度可能会变慢。默认为 True。
- **numeric_stable_mode** (bool) – 标志位，指明是否使用一个具有更佳数学稳定性的算法。仅在 ``soft_label`` 为 False的GPU模式下生效。若 ``soft_label`` 为 True 或者执行场所为CPU, 算法一直具有数学稳定性。 注意使用稳定算法时速度可能会变慢。默认为 True。
- **return_softmax** (bool) – 标志位，指明是否额外返回一个softmax值， 同时返回交叉熵计算结果。默认为False。
- **axis** (int) – 执行softmax计算的维度索引。 它应该在范围 :math:`[ - 1，rank - 1]` 中，而 :math:`rank` 是输入logits的秩。 默认值：-1。
返回:
- 如果 ``return_softmax`` 为 False， 则返回交叉熵损失
- 如果 ``return_softmax`` 为 True，则返回元组 (loss, softmax) ，其中交叉熵损失为形为[N x 1]的二维张量，softmax为[N x K]的二维张量
- 如果 ``return_softmax`` 为 False，则返回交叉熵损失
- 如果 ``return_softmax`` 为 True，则返回元组 (loss, softmax) ，其中softmax和输入logits形状相同；除了axis维上的形为1，其余维上交叉熵损失和输入logits形状相同
返回类型:变量或者两个变量组成的元组
......@@ -9129,6 +10435,9 @@ space_to_depth
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
data = fluid.layers.data(
name='data', shape=[1, 4, 2, 2], dtype='float32', append_batch_size=False)
space_to_depthed = fluid.layers.space_to_depth(
......@@ -9187,8 +10496,10 @@ spectral_norm
.. code-block:: python
weight = fluid.layers.data(name='weight', shape=[8, 32, 32],dtype='float32')
x = fluid.layers.spectral_norm(weight=data, dim=1, power_iters=2)
import paddle.fluid as fluid
weight = fluid.layers.data(name='weight', shape=[2, 8, 32, 32], append_batch_size=False, dtype='float32')
x = fluid.layers.spectral_norm(weight=weight, dim=1, power_iters=2)
......@@ -9217,16 +10528,21 @@ split
.. code-block:: python
# x是维为[3,9,5]的张量：
x0, x1, x2 = fluid.layers.split(x, num_or_sections=3, dim=1)
x0.shape # [3, 3, 5]
x1.shape # [3, 3, 5]
x2.shape # [3, 3, 5]
x0, x1, x2 = fluid.layers.split(
x, num_or_sections=[2, 3, 4], dim=1)
x0.shape # [3, 2, 5]
x1.shape # [3, 3, 5]
x2.shape # [3, 4, 5]
import paddle.fluid as fluid
# 输入是维为[-1, 3,9,5]的张量：
input = fluid.layers.data(
name="input", shape=[3, 9, 5], dtype="float32")
x0, x1, x2 = fluid.layers.split(x, num_or_sections=3, dim=2)
# x0.shape [-1, 3, 3, 5]
# x1.shape [-1, 3, 3, 5]
# x2.shape [-1, 3, 3, 5]
x0, x1, x2 = fluid.layers.split(input, num_or_sections=[2, 3, 4], dim=2)
# x0.shape [-1, 3, 2, 5]
# x1.shape [-1, 3, 3, 5]
# x2.shape [-1, 3, 4, 5]
......@@ -9322,6 +10638,7 @@ squeeze
.. code-block:: python
import paddle.fluid.layers as layers
x = fluid.layers.data(name='x', shape=[5, 1, 10])
y = fluid.layers.sequeeze(input=x, axes=[1])
......@@ -9396,9 +10713,14 @@ stack
返回类型: Variable
**代码示例**：
.. code-block:: python
import paddle.fluid.layers as layers
x1 = layers.data(name='x1', shape=[1, 2], dtype='int32')
x2 = layers.data(name='x2', shape=[1, 2], dtype='int32')
data = layers.stack([x1,x2])
......@@ -9464,8 +10786,10 @@ sum算子。
.. code-block:: python
input = fluid.layers.data(name="input", shape=[13, 11], dtype='float32')
out = fluid.layers.sum(input)
import paddle.fluid.layers as layers
input0 = fluid.layers.data(name="input0", shape=[13, 11], dtype='float32')
input1 = layers.data(name="input1", shape=[13, 11], dtype='float32')
out = fluid.layers.sum([input0,input1])
......@@ -9533,6 +10857,13 @@ teacher_student_sigmoid_loss
.. code-block:: python
import paddle.fluid as fluid
batch_size = 64
label = fluid.layers.data(
name="label", shape=[batch_size, 1], dtype="int64", append_batch_size=False)
similarity = fluid.layers.data(
name="similarity", shape=[batch_size, 1], dtype="float32", append_batch_size=False)
cost = fluid.layers.teacher_student_sigmoid_loss(input=similarity, label=label)
......@@ -9638,6 +10969,8 @@ topk
.. code-block:: python
import paddle.fluid.layers as layers
input = layers.data(name="input", shape=[13, 11], dtype='float32')
top5_values, top5_indices = fluid.layers.topk(input, k=5)
......@@ -9674,6 +11007,7 @@ transpose
# 请使用 append_batch_size=False 来避免
# 在数据张量中添加多余的batch大小维度
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[5, 10, 15],
dtype='float32', append_batch_size=False)
x_transposed = fluid.layers.transpose(x, perm=[1, 0, 2])
......@@ -9712,31 +11046,65 @@ tree_conv
.. code-block:: python
nodes_vector = fluid.layers.data(name='vectors', shape=[None, 10, 5], dtype='float32)
# batch size为None, 10代表数据集最大节点大小max_node_size,5表示向量宽度
edge_set = fluid.layers.data(name='edge_set', shape=[None, 10, 2], dtype='float32')
# None 代表batch size, 10 代表数据集的最大节点大小max_node_size, 2 代表每条边连接两个节点
# 10 代表数据集的最大节点大小max_node_size，5 代表向量宽度
nodes_vector = fluid.layers.data(name='vectors', shape=[10, 5], dtype='float32')
# 10 代表数据集的最大节点大小max_node_size, 2 代表每条边连接两个节点
# 边必须为有向边
out_vector = fluid.layers.tree_conv(nodes_vector, edge_set, 6, 1, 2, 'tanh',
ParamAttr(initializer=Constant(1.0), ParamAttr(initializer=Constant(1.0))
# 输出的形会是[None, 10, 6, 1],
# None 代表batch size, 10数据集的最大节点大小max_node_size, 6 代表输出大小output size, 1 代表 1 个filter
out_vector = fluid.layers.reshape(out_vector, shape=[None, 10, 6])
edge_set = fluid.layers.data(name='edge_set', shape=[10, 2], dtype='float32')
# 输出的形状会是[None, 10, 6, 1],
# 10 代表数据集的最大节点大小max_node_size, 6 代表输出大小output size, 1 代表 1 个filter
out_vector = fluid.layers.tree_conv(nodes_vector, edge_set, 6, 1, 2)
# reshape之后, 输出张量output tensor为下一个树卷积的nodes_vector
out_vector_2 = fluid.layers.tree_conv(out_vector, edge_set, 3, 4, 2, 'tanh',
ParamAttr(initializer=Constant(1.0), ParamAttr(initializer=Constant(1.0))
out_vector = fluid.layers.reshape(out_vector, shape=[-1, 10, 6])
out_vector_2 = fluid.layers.tree_conv(out_vector, edge_set, 3, 4, 2)
# 输出tensor也可以用来池化(论文中称为global pooling)
pooled = fluid.layers.reduce_max(out_vector, dims=2) # global 池化
pooled = fluid.layers.reduce_max(out_vector, dims=2) # 全局池化
.. _cn_api_fluid_layers_unfold:
unfold
-------------------------------
.. py:function:: paddle.fluid.layers.unfold(x, kernel_sizes, strides=1, paddings=0, dilations=1, name=None)
此函数返回输入x的滑动局域块的col缓冲区，对于批处理的2D图像张量，也称为im2col。 对于卷积核下的每个块，所有元素将重新排列为列。当卷积核在输入特征图上滑动时，将形成一系列这样的列。对于每个形为[N, C, H, W]的输入\(X\)，输出形状[N, Cout, Lout计算如下：
\[ \begin{align}\begin{aligned}dkernel[0] &= dilations[0] \times (kernel\_sizes[0] - 1) + 1\\dkernel[1] &= dilations[1] \times (kernel\_sizes[1] - 1) + 1\\hout &= \frac{H + paddings[0] + paddings[2] - dkernel[0]}{strides[0]} + 1\\wout &= \frac{W + paddings[1] + paddings[3] - dkernel[1]}{strides[1]} + 1\\Cout &= C \times kernel\_sizes[0] \times kernel\_sizes[1]\\Lout &= hout \times wout\end{aligned}\end{align} \]
参数：
- **x** (Variable) – 输入张量，形式为[N, C, H, W]。
- **kernel_sizes** (int|list) – 卷积核大小，应为[k_h, k_w]，或整数k（看做[k, k]）。
- **strides** (int|list) – 步长，应为[stride_h, stride_w]或整数stride（看做[stride, stride]）。默认为[1, 1]。
- **paddings** (int|list) – 每个维度的paddings，应为
[padding_top, padding_left, padding_bottom, padding_right]
或 [padding_h, padding_w] 或一个整数padding。
如果给出 [padding_h, padding_w] ，它将扩展为
[padding_h, padding_w, padding_h, padding_w]。如果给出了整数
padding，则将使用[padding, padding, padding, padding]。默认为[0, 0, 0, 0]。
- **dilations** (int|list) – 卷积核膨胀，应为[dilation_h, dilation_w]，或整数dilation（看做[dilation, dilation]）。默认为[1, 1]。
返回：对应于滑动局域块的张量变量。输出形状为[N, Cout, Lout]（如上所述）。 Cout是每个块中的值的总数，Lout是这些块的总数。
返回类型：变量(Variable)
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name = 'data', shape = [3, 224, 224], dtype = 'float32')
y = fluid.layers.unfold(x, [3, 3], 1, 1, 1)
......@@ -9771,6 +11139,7 @@ uniform_random_batch_size_like算子。
.. code-block:: python
import paddle.fluid.layers as layers
input = fluid.layers.data(name="input", shape=[13, 11], dtype='float32')
out = fluid.layers.uniform_random_batch_size_like(input, [-1, 11])
......@@ -9804,6 +11173,7 @@ unsqueeze
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[5, 10])
y = fluid.layers.unsequeeze(input=x, axes=[1])
......@@ -9842,9 +11212,13 @@ unstack
返回类型: list(Variable)
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[5, 10], dtype='float32')
y = fluid.layers.unstack(x, axis=1)
......@@ -9876,15 +11250,46 @@ warpctc
.. code-block:: python
label = fluid.layers.data(shape=[11, 8], dtype='float32', lod_level=1)
predict = fluid.layers.data(shape=[11, 1], dtype='float32')
import paddle.fluid as fluid
label = fluid.layers.data(name='label', shape=[11, 8],
dtype='float32', lod_level=1)
predict = fluid.layers.data(name='predict', shape=[11, 1],
dtype='float32')
cost = fluid.layers.warpctc(input=predict, label=label)
.. _cn_api_fluid_layers_where:
where
-------------------------------
.. py:function:: paddle.fluid.layers.where(condition)
返回一个秩为2的int64型张量，指定condition中真实元素的坐标。
输出的第一维是真实元素的数量，第二维是condition的秩（维数）。如果没有真实元素，则将生成空张量。
参数：
- **condition** （Variable） - 秩至少为1的布尔型张量。
返回：存储一个二维张量的张量变量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
# condition为张量[True, False, True]
out = fluid.layers.where(condition) # [[0], [2]]
# condition为张量[[True, False], [False, True]]
out = fluid.layers.where(condition) # [[0, 0], [1, 1]]
# condition为张量[False, False, False]
out = fluid.layers.where(condition) # [[]]
......@@ -9914,8 +11319,12 @@ abs
返回： abs算子的输出。
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.abs(data)
.. _cn_api_fluid_layers_acos:
......@@ -9935,6 +11344,12 @@ arccosine激活函数。
返回： acos算子的输出。
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.acos(data)
.. _cn_api_fluid_layers_asin:
......@@ -9954,6 +11369,14 @@ arcsine激活函数。
返回： asin算子的输出。
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.asin(data)
.. _cn_api_fluid_layers_atan:
......@@ -9972,6 +11395,12 @@ arctanh激活函数。
返回： atan算子的输出。
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.atan(data)
......@@ -9998,6 +11427,12 @@ ceil
返回： Ceil算子的输出。
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.ceil(data)
......@@ -10030,7 +11465,12 @@ Cosine余弦激活函数。
返回： Cos算子的输出
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.cos(data)
......@@ -10091,6 +11531,12 @@ Exp激活函数(Exp指以自然常数e为底的指数运算)。
返回： Exp算子的输出
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.exp(data)
......@@ -10122,6 +11568,12 @@ floor
返回： Floor算子的输出。
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.floor(data)
......@@ -10188,11 +11640,16 @@ Logsigmoid激活函数。
参数:
- **x** - LogSigmoid算子的输入
- **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
返回： LogSigmoid算子的输出
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.logsigmoid(data)
......@@ -10222,6 +11679,15 @@ Reciprocal（取倒数）激活函数
返回： Reciprocal算子的输出。
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.reciprocal(data)
......@@ -10252,12 +11718,43 @@ Round取整激活函数。
返回： Round算子的输出。
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.round(data)
.. _cn_api_fluid_layers_rsqrt:
rsqrt
-------------------------------
.. py:function:: paddle.fluid.layers.rsqrt(x, name=None)
rsqrt激活函数
请确保输入合法以免出现数字错误。
.. math::
out = \frac{1}{\sqrt{x}}
参数:
- **x** - rsqrt算子的输入
- **use_cudnn** (BOOLEAN) – （bool，默认为false）是否仅用于cudnn核，需要安装cudnn
返回： rsqrt运算输出
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.rsqrt(data)
......@@ -10281,6 +11778,15 @@ sigmoid激活函数
返回： Sigmoid运算输出.
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.sigmoid(data)
......@@ -10311,6 +11817,15 @@ sin
返回： Sin算子的输出。
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.sin(data)
......@@ -10339,6 +11854,15 @@ softplus激活函数。
返回：Softplus操作后的结果
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.softplus(data)
......@@ -10369,6 +11893,15 @@ Softshrink激活算子
返回： Softshrink算子的输出
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.softshrink(data)
......@@ -10398,6 +11931,15 @@ softsign激活函数。
返回：Softsign操作后的结果
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.softsign(data)
......@@ -10428,6 +11970,15 @@ sqrt
返回： Sqrt算子的输出。
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.sqrt(data)
......@@ -10456,6 +12007,15 @@ square
返回：平方后的结果
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.square(data)
......@@ -10487,6 +12047,15 @@ tanh 激活函数。
返回： Tanh算子的输出。
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.tanh(data)
......@@ -10516,6 +12085,13 @@ tanh_shrink激活函数。
返回： tanh_shrink算子的输出
**代码示例**：
.. code-block:: python
data = fluid.layers.data(name="input", shape=[32, 784])
result = fluid.layers.tanh_shrink(data)
......@@ -10536,7 +12112,7 @@ ThresholdedRelu激活函数
.. math::
out = \left\{\begin{matrix}
x, if&x > threshold\\
x, &if x > threshold\\
0, &otherwise
\end{matrix}\right.
......@@ -10581,6 +12157,7 @@ uniform_random
.. code-block:: python
import paddle.fluid as fluid
result = fluid.layers.uniform_random(shape=[32, 784])
......@@ -10621,6 +12198,7 @@ argmax
.. code-block:: python
x = fluid.layers.data(name="x", shape=[3, 4], dtype="float32")
out = fluid.layers.argmax(x=in, axis=0)
out = fluid.layers.argmax(x=in, axis=-1)
......@@ -10655,6 +12233,7 @@ argmin
.. code-block:: python
x = fluid.layers.data(name="x", shape=[3, 4], dtype="float32")
out = fluid.layers.argmin(x=in, axis=0)
out = fluid.layers.argmin(x=in, axis=-1)
......@@ -10706,8 +12285,8 @@ argsort
.. code-block:: python
input = fluid.layers.data(data=[2, 3])
out, indices = fluid.layers.argsort(input, axis=0)
x = fluid.layers.data(name="x", shape=[3, 4], dtype="float32")
out, indices = fluid.layers.argsort(input=x, axis=0)
......@@ -10724,9 +12303,7 @@ assign
.. py:function:: paddle.fluid.layers.assign(input,output=None)
**Assign**
该功能将输入变量复制到输出变量
该函数将输入变量复制到输出变量
参数：
- **input** (Variable|numpy.ndarray)-源变量
......@@ -10740,6 +12317,8 @@ assign
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name="data", shape=[3, 32, 32], dtype="float32")
out = fluid.layers.create_tensor(dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
fluid.layers.assign(hidden, out)
......@@ -10808,6 +12387,10 @@ concat
.. code-block:: python
a = fluid.layers.data(name='a', shape=[2, 13], dtype='float32')
b = fluid.layers.data(name='b', shape=[2, 3], dtype='float32')
c = fluid.layers.data(name='c', shape=[2, 2], dtype='float32')
d = fluid.layers.data(name='d', shape=[2, 5], dtype='float32')
out = fluid.layers.concat(input=[Efirst, Esecond, Ethird, Efourth])
......@@ -10843,7 +12426,8 @@ create_global_var
.. code-block:: python
var = fluid.create_global_var(shape=[2,3], value=1.0, dtype='float32',
import paddle.fluid.layers as layers
var = layers.create_global_var(shape=[2,3], value=1.0, dtype='float32',
persistable=True, force_cpu=True, name='new_var')
......@@ -10878,9 +12462,8 @@ create_parameter
.. code-block:: python
import paddle.fluid.layers as layers
W = fluid.layers.create_parameter(shape=[784, 200], dtype='float32')
data = fluid.layers.data(name="img", shape=[64, 784], append_batch_size=False)
hidden = fluid.layers.matmul(x=data, y=W)
......@@ -10916,9 +12499,30 @@ create_tensor
.. _cn_api_fluid_layers_diag:
diag
-------------------------------
.. py:function:: paddle.fluid.layers.diag(diagonal)
该功能创建一个方阵，含有diagonal指定的对角线值。
参数：
- **diagonal** (Variable|numpy.ndarray) - 指定对角线值的输入张量，其秩应为1。
返回：存储着方阵的张量变量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
# [3, 0, 0]
# [0, 4, 0]
# [0, 0, 5]
data = fluid.layers.diag(np.arange(3, 6))
......@@ -10930,8 +12534,6 @@ fill_constant
.. py:function:: paddle.fluid.layers.fill_constant(shape,dtype,value,force_cpu=False,out=None)
**fill_constant**
该功能创建一个张量，含有具体的shape,dtype和batch尺寸。并用 ``value`` 中提供的常量初始化该张量。
创建张量的属性stop_gradient设为True。
......@@ -10951,6 +12553,7 @@ fill_constant
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.fill_constant(shape=[1], value=0, dtype='int64')
......@@ -10984,6 +12587,8 @@ fill_constant_batch_size_like
.. code-block:: python
import paddle.fluid as fluid
like = fluid.layers.data(name='like', shape=[1], dtype='float32')
data = fluid.layers.fill_constant_batch_size_like(
input=like, shape=[1], value=0, dtype='int64')
......@@ -11012,9 +12617,13 @@ has_inf
返回类型：Variable
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name="input", shape=[4, 32, 32], dtype="float32")
res = fluid.layers.has_inf(data)
......@@ -11040,8 +12649,13 @@ has_nan
返回类型：Variable
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name="input", shape=[4, 32, 32], dtype="float32")
res = fluid.layers.has_nan(data)
......@@ -11062,8 +12676,44 @@ isfinite
返回类型：Variable
**代码示例**：
.. code-block:: python
var = fluid.layers.data(name="data",
shape=(4, 6),
dtype="float32")
out = fluid.layers.isfinite(v)
.. _cn_api_fluid_layers_linspace:
linspace
-------------------------------
.. py:function:: paddle.fluid.layers.linspace(start, stop, num, dtype)
在给定区间内返回固定数目的均匀间隔的值。
第一个entry是start，最后一个entry是stop。在Num为1的情况下，仅返回start。类似numpy的linspace功能。
参数：
- **start** (float|Variable)-序列中的第一个entry。 它是一个浮点标量，或是一个数据类型为'float32'|'float64'、形状为[1]的张量。
- **stop** (float|Variable)-序列中的最后一个entry。 它是一个浮点标量，或是一个数据类型为'float32'|'float64'、形状为[1]的张量。
- **num** (int|Variable)-序列中的entry数。 它是一个整型标量，或是一个数据类型为int32、形状为[1]的张量。
- **dtype** (string)-‘float32’|’float64’，输出张量的数据类型。
返回：存储一维张量的张量变量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
data = fluid.layers.linspace(0, 10, 5, 'float32') # [0.0, 2.5, 5.0, 7.5, 10.0]
data = fluid.layers.linspace(0, 10, 1, 'float32') # [0.0]
......@@ -11094,6 +12744,7 @@ ones
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.ones(shape=[1], dtype='int64')
......@@ -11152,9 +12803,11 @@ reverse
.. code-block:: python
out = fluid.layers.reverse(x=in, axis=0)
import paddle.fluid as fluid
data = fluid.layers.data(name="data", shape=[4, 8], dtype="float32")
out = fluid.layers.reverse(x=data, axis=0)
# or:
out = fluid.layers.reverse(x=in, axis=[0,1])
out = fluid.layers.reverse(x=data, axis=[0,1])
......@@ -11185,14 +12838,23 @@ sums
.. code-block:: python
tmp = fluid.layers.zeros(shape=[10], dtype='int32')
i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
a0 = fluid.layers.array_read(array=tmp, i=i)
import paddle.fluid as fluid
# sum of several tensors
a0 = fluid.layers.fill_constant(shape=[1], dtype='int64', value=1)
a1 = fluid.layers.fill_constant(shape=[1], dtype='int64', value=2)
a2 = fluid.layers.fill_constant(shape=[1], dtype='int64', value=3)
sums = fluid.layers.sums(input=[a0, a1, a2])
# sum of a tensor array
array = fluid.layers.create_array('int64')
i = fluid.layers.zeros(shape=[1], dtype='int64', force_cpu=True)
fluid.layers.array_write(a0, array=array, i=i)
i = fluid.layers.increment(x=i)
a1 = fluid.layers.array_read(array=tmp, i=i)
mean_a0 = fluid.layers.mean(a0)
mean_a1 = fluid.layers.mean(a1)
a_sum = fluid.layers.sums(input=[mean_a0, mean_a1])
fluid.layers.array_write(a1, array=array, i=i)
i = fluid.layers.increment(x=i)
fluid.layers.array_write(a2, array=array, i=i)
sums = fluid.layers.sums(input=array)
......@@ -11245,6 +12907,8 @@ tensor_array_to_tensor
.. code-block:: python
import paddle.fluid as fluid
tensor_array = fluid.layers.create_parameter(shape=[784, 200], dtype='float32')
output, output_index = fluid.layers.tensor_array_to_tensor(input=tensor_array)
......@@ -11266,7 +12930,7 @@ zeros
**zeros**
该功能创建一个张量，含有具体的维度和dtype，初始值为0.
该函数创建一个张量，含有具体的维度和dtype，初始值为0.
也将stop_gradient设置为True。
......@@ -11283,6 +12947,7 @@ zeros
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.zeros(shape=[1], dtype='int64')
......@@ -11292,6 +12957,34 @@ zeros
.. _cn_api_fluid_layers_zeros_like:
zeros_like
-------------------------------
.. py:function:: paddle.fluid.layers.zeros_like(x, out=None)
**zeros_like**
该函数创建一个和x具有相同的形状和数据类型的全零张量
参数：
- **x** (Variable)-指定形状和数据类型的输入张量
- **out** (Variable)-输出张量
返回：存储输出的张量变量
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
x = fluid.layers.data(name='x', dtype='float32', shape=[3], append_batch_size=False)
data = fluid.layers.zeros_like(x) # [0.0, 0.0, 0.0]
......@@ -11362,6 +13055,7 @@ exponential_decay
.. code-block:: python
import paddle.fluid as fluid
base_lr = 0.1
sgd_optimizer = fluid.optimizer.SGD(
learning_rate=fluid.layers.exponential_decay(
......@@ -11369,7 +13063,7 @@ exponential_decay
decay_steps=10000,
decay_rate=0.5,
staircase=True))
sgd_optimizer.minimize(avg_cost)
......@@ -11411,9 +13105,10 @@ inverse_time_decay
.. code-block:: python
import paddle.fluid as fluid
base_lr = 0.1
sgd_optimizer = fluid.optimizer.SGD(
learning_rate=fluid.layers.inverse_time_decay(
learning_rate=fluid.layers.natural_exp_decay(
learning_rate=base_lr,
decay_steps=10000,
decay_rate=0.5,
......@@ -11491,8 +13186,18 @@ natural_exp_decay
返回：衰减的学习率
**示例代码：**
.. code-block:: python
import paddle.fluid as fluid
base_lr = 0.1
sgd_optimizer = fluid.optimizer.SGD(
learning_rate=fluid.layers.natural_exp_decay(
learning_rate=base_lr,
decay_steps=10000,
decay_rate=0.5,
staircase=True))
......@@ -11511,6 +13216,11 @@ Noam衰减方法。noam衰减的numpy实现如下。
.. code-block:: python
import numpy as np
# 设置超参数
d_model = 2
current_steps = 20
warmup_steps = 200
# 计算
lr_value = np.power(d_model, -0.5) * np.min([
np.power(current_steps, -0.5),
np.power(warmup_steps, -1.5) * current_steps])
......@@ -11523,8 +13233,16 @@ Noam衰减方法。noam衰减的numpy实现如下。
返回：衰减的学习率
**代码示例**：
.. code-block:: python
import padde.fluid as fluid
warmup_steps = 100
learning_rate = 0.01
lr = fluid.layers.learning_rate_scheduler.noam_decay(
1/(warmup_steps *(learning_rate ** 2)),
warmup_steps)
......@@ -11559,8 +13277,17 @@ piecewise_decay
返回：衰减的学习率
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
boundaries = [10000, 20000]
values = [1.0, 0.5, 0.1]
optimizer = fluid.optimizer.Momentum(
momentum=0.9,
learning_rate=fluid.layers.piecewise_decay(boundaries=boundaries, values=values),
regularization=fluid.regularizer.L2Decay(1e-4))
......@@ -11596,8 +13323,16 @@ polynomial_decay
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
start_lr = 0.01
total_step = 5000
end_lr = 0
lr = fluid.layers.polynomial_decay(
start_lr, total_step, end_lr, power=1)
......@@ -11642,7 +13377,8 @@ anchor_generator
.. code-block:: python
anchor, var = anchor_generator(
conv1 = fluid.layers.data(name='conv1', shape=[48, 16, 16], dtype='float32')
anchor, var = fluid.layers.anchor_generator(
input=conv1,
anchor_sizes=[64, 128, 256, 512],
aspect_ratios=[0.5, 1.0, 2.0],
......@@ -11739,7 +13475,7 @@ box_clip
.. code-block:: python
boxes = fluid.layers.data(
name='data', shape=[8, 4], dtype='float32', lod_level=1)
name='boxes', shape=[8, 4], dtype='float32', lod_level=1)
im_info = fluid.layers.data(name='im_info', shape=[3])
out = fluid.layers.box_clip(
input=boxes, im_info=im_info, inplace=True)
......@@ -11886,17 +13622,68 @@ box decode过程得出decode_box，然后分配方案如下所述：
.. code-block:: python
pb = fluid.layers.data(
name='prior_box', shape=[20, 4], dtype='float32')
name='prior_box', shape=[4], dtype='float32')
pbv = fluid.layers.data(
name='prior_box_var', shape=[1, 4], dtype='float32')
name='prior_box_var', shape=[4], dtype='float32', append_batch_size=False))
loc = fluid.layers.data(
name='target_box', shape=[20, 4*81], dtype='float32')
name='target_box', shape=[4*81], dtype='float32')
scores = fluid.layers.data(
name='scores', shape=[20, 81], dtype='float32')
name='scores', shape=[81], dtype='float32')
decoded_box, output_assign_box = fluid.layers.box_decoder_and_assign(
pb, pbv, loc, scores, 4.135)
.. _cn_api_fluid_layers_collect_fpn_proposals:
collect_fpn_proposals
-------------------------------
.. py:function:: paddle.fluid.layers.collect_fpn_proposals(multi_rois, multi_scores, min_level, max_level, post_nms_top_n, name=None)
连接多级RoIs（感兴趣区域）并依据multi_scores选择N个RoIs。此操作执行以下步骤：
1、选择num_level个RoIs和scores作为输入：num_level = max_level - min_level
2、连接num_level个RoIs和scores。
3、整理scores并选择post_nms_top_n个scores。
4、通过scores中的选定指数收集RoIs。
5、通过对应的batch_id重新整理RoIs。
参数：
- **multi_ros** (list) – 要收集的RoIs列表
- **multi_scores** (list) - 要收集的FPN层的最低级
- **max_level** (int) – 要收集的FPN层的最高级
- **post_nms_top_n** (int) – 所选RoIs的数目
- **name** (str|None) – 该层的名称（可选项）
返回：选定RoIs的输出变量
返回类型：变量(Variable)
**代码示例**
.. code-block:: python
multi_rois = []
multi_scores = []
for i in range(4):
multi_rois.append(fluid.layers.data(
name='roi_'+str(i), shape=[4], dtype='float32', lod_level=1))
for i in range(4):
multi_scores.append(fluid.layers.data(
name='score_'+str(i), shape=[1], dtype='float32', lod_level=1))
fpn_rois = fluid.layers.collect_fpn_proposals(
multi_rois=multi_rois,
multi_scores=multi_scores,
min_level=2,
max_level=5,
post_nms_top_n=2000)
.. _cn_api_fluid_layers_density_prior_box:
density_prior_box
......@@ -11958,8 +13745,10 @@ density prior box的量由fixed_sizes and fixed_ratios决定。显然地，fixed
.. code-block:: python
input = fluid.layers.data(name="input", shape=[3,6,9])
images = fluid.layers.data(name="images", shape=[3,9,12])
box, var = fluid.layers.density_prior_box(
input=conv1,
input=input,
image=images,
densities=[4, 2, 1],
fixed_sizes=[32.0, 64.0, 128.0],
......@@ -12083,6 +13872,7 @@ Detection Output Layer for Single Shot Multibox Detector(SSD)
.. code-block:: python
import paddle.fluid as fluid
pb = fluid.layers.data(name='prior_box', shape=[10, 4],
append_batch_size=False, dtype='float32')
pbv = fluid.layers.data(name='prior_box_var', shape=[10, 4],
......@@ -12204,6 +13994,8 @@ generate_mask_labels
.. code-block:: python
import paddle.fluid as fluid
im_info = fluid.layers.data(name="im_info", shape=[3],
dtype="float32")
gt_classes = fluid.layers.data(name="gt_classes", shape=[1],
......@@ -12212,15 +14004,18 @@ generate_mask_labels
dtype="float32", lod_level=1)
gt_masks = fluid.layers.data(name="gt_masks", shape=[2],
dtype="float32", lod_level=3)
# rois, labels_int32 可以是
# fluid.layers.generate_proposal_labels 的输出
# rois, roi_labels 可以是fluid.layers.generate_proposal_labels的输出
rois = fluid.layers.data(name="rois", shape=[4],
dtype="float32", lod_level=1)
roi_labels = fluid.layers.data(name="roi_labels", shape=[1],
dtype="int32", lod_level=1)
mask_rois, mask_index, mask_int32 = fluid.layers.generate_mask_labels(
im_info=im_info,
gt_classes=gt_classes,
is_crowd=is_crowd,
gt_segms=gt_masks,
rois=rois,
labels_int32=labels_int32,
labels_int32=roi_labels,
num_classes=81,
resolution=14)
......@@ -12233,7 +14028,7 @@ generate_mask_labels
generate_proposal_labels
-------------------------------
.. py:function:: paddle.fluid.layers.generate_proposal_labels(rpn_rois, gt_classes, is_crowd, gt_boxes, im_info, batch_size_per_im=256, fg_fraction=0.25, fg_thresh=0.25, bg_thresh_hi=0.5, bg_thresh_lo=0.0, bbox_reg_weights=[0.1, 0.1, 0.2, 0.2], class_nums=None, use_random=True)
.. py:function:: paddle.fluid.layers.generate_proposal_labels(rpn_rois, gt_classes, is_crowd, gt_boxes, im_info, batch_size_per_im=256, fg_fraction=0.25, fg_thresh=0.25, bg_thresh_hi=0.5, bg_thresh_lo=0.0, bbox_reg_weights=[0.1, 0.1, 0.2, 0.2], class_nums=None, use_random=True, is_cls_agnostic=False, is_cascade_rcnn=False)
**该函数可以应用于 Faster-RCNN 网络，生成建议标签。**
......@@ -12261,9 +14056,28 @@ RpnRois 是RPN的输出box， 并由 ``GenerateProposals`` 来进一步处理,
- **bbox_reg_weights** (list|tuple) – Box 回归权重
- **class_nums** (int) – 种类数目
- **use_random** (bool) – 是否使用随机采样来选择foreground（前景）和background（背景） boxes（框）
- **is_cls_agnostic** （bool）- 未知类别的bounding box回归，仅标识前景和背景框
- **is_cascade_rcnn** （bool）- 是否为 cascade RCNN 模型，为True时采样策略发生变化
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
rpn_rois = fluid.layers.data(name='rpn_rois', shape=[2, 4],
append_batch_size=False, dtype='float32')
gt_classes = fluid.layers.data(name='gt_classes', shape=[8, 1],
append_batch_size=False, dtype='float32')
is_crowd = fluid.layers.data(name='is_crowd', shape=[8, 1],
append_batch_size=False, dtype='float32')
gt_boxes = fluid.layers.data(name='gt_boxes', shape=[8, 4],
append_batch_size=False, dtype='float32')
im_info = fluid.layers.data(name='im_info', shape=[10, 3],
append_batch_size=False, dtype='float32')
rois, labels_int32, bbox_targets, bbox_inside_weights,
bbox_outside_weights = fluid.layers.generate_proposal_labels(
rpn_rois, gt_classes, is_crowd, gt_boxes, im_info,
class_nums=10)
......@@ -12311,7 +14125,23 @@ generate_proposals
- **min_size** （float）- 删除高度或宽度小于min_size的预测框。默认为0.1。
- **eta** （float）- 在自适应NMS中应用，如果自适应阈值> 0.5，则在每次迭代中使用adaptive_threshold = adaptive_treshold * eta。
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
scores = fluid.layers.data(name='scores', shape=[2, 4, 5, 5],
append_batch_size=False, dtype='float32')
bbox_deltas = fluid.layers.data(name='bbox_deltas', shape=[2, 16, 5, 5],
append_batch_size=False, dtype='float32')
im_info = fluid.layers.data(name='im_info', shape=[2, 3],
append_batch_size=False, dtype='float32')
anchors = fluid.layers.data(name='anchors', shape=[5, 5, 4, 4],
append_batch_size=False, dtype='float32')
variances = fluid.layers.data(name='variances', shape=[5, 5, 10, 4],
append_batch_size=False, dtype='float32')
rois, roi_probs = fluid.layers.generate_proposals(scores, bbox_deltas,
im_info, anchors, variances)
......@@ -12343,8 +14173,15 @@ iou_similarity
返回类型：out(Variable)
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[4], dtype='float32')
y = fluid.layers.data(name='y', shape=[4], dtype='float32')
iou = fluid.layers.iou_similarity(x=x, y=y)
......@@ -12399,6 +14236,16 @@ multi_box_head
.. code-block:: python
import paddle.fluid as fluid
images = fluid.layers.data(name='data', shape=[3, 300, 300], dtype='float32')
conv1 = fluid.layers.data(name='conv1', shape=[512, 19, 19], dtype='float32')
conv2 = fluid.layers.data(name='conv2', shape=[1024, 10, 10], dtype='float32')
conv3 = fluid.layers.data(name='conv3', shape=[512, 5, 5], dtype='float32')
conv4 = fluid.layers.data(name='conv4', shape=[256, 3, 3], dtype='float32')
conv5 = fluid.layers.data(name='conv5', shape=[256, 2, 2], dtype='float32')
conv6 = fluid.layers.data(name='conv6', shape=[128, 1, 1], dtype='float32')
mbox_locs, mbox_confs, box, var = fluid.layers.multi_box_head(
inputs=[conv1, conv2, conv3, conv4, conv5, conv6],
image=images,
......@@ -12493,9 +14340,14 @@ PolygonBoxTransform 算子。
返回类型：output（Variable）
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
input = fluid.layers.data(name='input', shape=[4, 10, 5, 5],
append_batch_size=False, dtype='float32')
out = fluid.layers.polygon_box_transform(input)
......@@ -12509,7 +14361,7 @@ prior_box
-------------------------------
.. py:function:: paddle.fluid.layers.prior_box(input,image,min_sizes=None,max_sizes=None,aspect_ratios=[1.0],variance=[0.1,0.1,0.2,0.2],flip=False,clip=False,steps=[0.0,0.0],offset=0.5,name=None,min_max_aspect_ratios_order=False)
**Prior Box Operator**
**Prior Box操作符**
为SSD(Single Shot MultiBox Detector)算法生成先验框。输入的每个位产生N个先验框，N由min_sizes,max_sizes和aspect_ratios的数目决定，先验框的尺寸在(min_size,max_size)之间，该尺寸根据aspect_ratios在序列中生成。
......@@ -12517,20 +14369,20 @@ prior_box
- **input** (Variable)-输入变量，格式为NCHW
- **image** (Variable)-PriorBoxOp的输入图像数据，布局为NCHW
- **min_sizes** (list|tuple|float值)-生成的先验框的最小尺寸
- **max_sizes** (list|tuple|None)-生成的先验框的最大尺寸。默认：None
- **max_sizes** (list|tuple|None)-生成的先验框的最大尺寸。默认：None
- **aspect_ratios** (list|tuple|float值)-生成的先验框的纵横比。默认：[1.]
- **variance** (list|tuple)-先验框中的变量，会被解码。默认：[0.1,0.1,0.2,0.2]
- **flip** (bool)-是否忽略纵横比。默认：False。
- **clip** (bool)-是否修建溢界框。默认：False。
- **clip** (bool)-是否修建溢界框。默认：False。
- **step** (list|tuple)-先验框在width和height上的步长。如果step[0] == 0.0/step[1] == 0.0，则自动计算先验框在宽度和高度上的步长。默认：[0.,0.]
- **offset** (float)-先验框中心位移。默认：0.5
- **offset** (float)-先验框中心位移。默认：0.5
- **name** (str)-先验框操作符名称。默认：None
- **min_max_aspect_ratios_order** (bool)-若设为True,先验框的输出以[min,max,aspect_ratios]的顺序，和Caffe保持一致。请注意，该顺序会影响后面卷基层的权重顺序，但不影响最后的检测结果。默认：False。
返回：
含有两个变量的元组(boxes,variances)
boxes:PriorBox的输出先验框。布局是[H,W,num_priors,4]。H是输入的高度，W是输入的宽度，num_priors是输入每位的总框数
variances:PriorBox的扩展变量。布局上[H,W,num_priors,4]。H是输入的高度，W是输入的宽度，num_priors是输入每位的总框数
boxes:PriorBox的输出先验框。布局是[H,W,num_priors,4]。H是输入的高度，W是输入的宽度，num_priors是输入每位的总框数
variances:PriorBox的扩展变量。布局上[H,W,num_priors,4]。H是输入的高度，W是输入的宽度，num_priors是输入每位的总框数
返回类型：元组
......@@ -12538,15 +14390,74 @@ prior_box
.. code-block:: python
input = fluid.layers.data(name="input", shape=[3,6,9])
images = fluid.layers.data(name="images", shape=[3,9,12])
box, var = fluid.layers.prior_box(
input=conv1,
input=input,
image=images,
min_sizes=[100.],
flip=True,
clip=True)
.. _cn_api_fluid_layers_retinanet_detection_output:
retinanet_detection_output
-------------------------------
.. py:function:: paddle.fluid.layers.retinanet_detection_output(bboxes, scores, anchors, im_info, score_threshold=0.05, nms_top_k=1000, keep_top_k=100, nms_threshold=0.3, nms_eta=1.0)
**Retinanet的检测输出层**
此操作通过执行以下步骤获取检测结果：
1. 根据anchor框解码每个FPN级别的最高得分边界框预测。
2. 合并所有级别的顶级预测并对其应用多级非最大抑制（NMS）以获得最终检测。
参数：
- **bboxes** (List) – 来自多个FPN级别的张量列表。每个元素都是一个三维张量，形状[N，Mi，4]代表Mi边界框的预测位置。N是batch大小，Mi是第i个FPN级别的边界框数，每个边界框有四个坐标值，布局为[xmin，ymin，xmax，ymax]。
- **scores** (List) – 来自多个FPN级别的张量列表。每个元素都是一个三维张量，各张量形状为[N，Mi，C]，代表预测的置信度预测。 N是batch大小，C是类编号（不包括背景），Mi是第i个FPN级别的边界框数。对于每个边界框，总共有C个评分。
- **anchors** (List) – 具有形状[Mi，4]的2-D Tensor表示来自所有FPN级别的Mi anchor框的位置。每个边界框有四个坐标值，布局为[xmin，ymin，xmax，ymax]。
- **im_info** (Variable) – 形状为[N，3]的2-D LoDTensor表示图像信息。 N是batch大小，每个图像信息包括高度，宽度和缩放比例。
- **score_threshold** (float) – 用置信度分数剔除边界框的过滤阈值。
- **nms_top_k** (int) – 根据NMS之前的置信度保留每个FPN层的最大检测数。
- **keep_top_k** (int) – NMS步骤后每个图像要保留的总边界框数。 -1表示在NMS步骤之后保留所有边界框。
- **nms_threshold** (float) – NMS中使用的阈值.
- **nms_eta** (float) – adaptive NMS的参数.
返回：
检测输出是具有形状[No，6]的LoDTensor。 每行有六个值：[标签，置信度，xmin，ymin，xmax，ymax]。 No是此mini batch中的检测总数。 对于每个实例，第一维中的偏移称为LoD，偏移值为N + 1，N是batch大小。 第i个图像具有LoD [i + 1] - LoD [i]检测结果，如果为0，则第i个图像没有检测到结果。 如果所有图像都没有检测到结果，则LoD将设置为0，输出张量为空（None）。
返回类型：变量（Variable）
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
bboxes = layers.data(name='bboxes', shape=[1, 21, 4],
append_batch_size=False, dtype='float32')
scores = layers.data(name='scores', shape=[1, 21, 10],
append_batch_size=False, dtype='float32')
anchors = layers.data(name='anchors', shape=[21, 4],
append_batch_size=False, dtype='float32')
im_info = layers.data(name="im_info", shape=[1, 3],
append_batch_size=False, dtype='float32')
nmsed_outs = fluid.layers.retinanet_detection_output(
bboxes=[bboxes, bboxes],
scores=[scores, scores],
anchors=[anchors, anchors],
im_info=im_info,
score_threshold=0.05,
nms_top_k=1000,
keep_top_k=100,
nms_threshold=0.3,
nms_eta=1.)
......@@ -12567,7 +14478,8 @@ roi_perspective_transform
参数：
- **input** (Variable) - ROI Perspective TransformOp的输入。输入张量的形式为NCHW。N是批尺寸，C是输入通道数，H是特征高度，W是特征宽度
- **rois** (Variable) - 用来处理的ROIs，应该是shape的二维LoDTensor(num_rois,8)。给定[[x1,y1,x2,y2,x3,y3,x4,y4],...],(x1,y1)是左上角坐标，(x2,y2)是右上角坐标，(x3,y3)是右下角坐标，(x4,y4)是左下角坐标
- **transformed_height** - 输出的宽度
- **transformed_height** (integer) - 输出的高度
- **transformed_width** (integer) – 输出的宽度
- **spatial_scale** (float) - 空间尺度因子，用于缩放ROI坐标，默认：1.0。
返回：
......@@ -12579,17 +14491,11 @@ roi_perspective_transform
.. code-block:: python
out = fluid.layers.roi_perspective_transform(input, rois, 7, 7, 1.0)
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[256, 28, 28], dtype='float32')
rois = fluid.layers.data(name='rois', shape=[8], lod_level=1, dtype='float32')
out = fluid.layers.roi_perspective_transform(x, rois, 7, 7, 1.0)
......@@ -12643,6 +14549,7 @@ rpn_target_assign
.. code-block:: python
import paddle.fluid as fluid
bbox_pred = fluid.layers.data(name=’bbox_pred’, shape=[100, 4],
append_batch_size=False, dtype=’float32’)
cls_logits = fluid.layers.data(name=’cls_logits’, shape=[100, 1],
......@@ -12651,9 +14558,13 @@ rpn_target_assign
append_batch_size=False, dtype=’float32’)
gt_boxes = fluid.layers.data(name=’gt_boxes’, shape=[10, 4],
append_batch_size=False, dtype=’float32’)
is_crowd = fluid.layers.data(name='is_crowd', shape=[1],
append_batch_size=False, dtype='float32')
im_info = fluid.layers.data(name='im_infoss', shape=[1, 3],
append_batch_size=False, dtype='float32')
loc_pred, score_pred, loc_target, score_target, bbox_inside_weight=
fluid.layers.rpn_target_assign(bbox_pred=bbox_pred,
cls_logits=cls_logits, anchor_box=anchor_box, gt_boxes=gt_boxes)
fluid.layers.rpn_target_assign(bbox_pred, cls_logits,
anchor_box, anchor_var, gt_boxes, is_crowd, im_info)
......@@ -12807,11 +14718,22 @@ target_assign
.. code-block:: python
matched_indices, matched_dist = fluid.layers.bipartite_match(iou)
gt = fluid.layers.data(
name='gt', shape=[1, 1], dtype='int32', lod_level=1)
import paddle.fluid as fluid
x = fluid.layers.data(
name='x',
shape=[4, 20, 4],
dtype='float',
lod_level=1,
append_batch_size=False)
matched_id = fluid.layers.data(
name='indices',
shape=[8, 20],
dtype='int32',
append_batch_size=False)
trg, trg_weight = fluid.layers.target_assign(
gt, matched_indices, mismatch_value=0)
x,
matched_id,
mismatch_value=0)
......@@ -12873,9 +14795,10 @@ yolo_box
.. code-block:: python
import paddle.fluid as fluid
x = fluid.layers.data(name='x', shape=[255, 13, 13], dtype='float32')
anchors = [10, 13, 16, 30, 33, 23]
loss = fluid.layers.yolo_box(x=x, class_num=80, anchors=anchors,
loss = fluid.layers.yolo_box(x=x, img_size=608, class_num=80, anchors=anchors,
conf_thresh=0.01, downsample_ratio=32)
......@@ -12910,10 +14833,10 @@ yolov3_loss
在上面的等式中， :math:`c_x, c_y` 是当前网格的左上角, :math:`p_w, p_h` 由anchors指定。
至于置信度得分，它是anchor框和真实框之间的IoU的逻辑回归值，anchor框的得分最高为1，此时该anchor框对应着最大IoU。
如果anchor框之间的IoU大于忽略阀值ignore_thresh，则该anchor框的置信度评分损失将会被忽略。
         
因此，yolov3损失包括三个主要部分，框位置损失，目标性损失，分类损失。L1损失用于
框坐标（w，h），同时，sigmoid交叉熵损失用于框坐标（x，y），目标性损失和分类损失。
         
每个真实框在所有anchor中找到最匹配的anchor，预测各anchor框都将会产生所有三种损失的计算，但是没有匹配GT box(ground truth box真实框)的anchor的预测只会产生目标性损失。
为了权衡大框(box)和小(box)之间的框坐标损失，框坐标损失将与比例权重相乘而得。即：
......@@ -13016,10 +14939,11 @@ accuracy layer。 参考 https://en.wikipedia.org/wiki/Precision_and_recall
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name="data", shape=[-1, 32, 32], dtype="float32")
label = fluid.layers.data(name="data", shape=[-1,1], dtype="int32")
label = fluid.layers.data(name="label", shape=[-1,1], dtype="int32")
predict = fluid.layers.fc(input=data, size=10)
acc = fluid.layers.accuracy(input=predict, label=label, k=5)
accuracy_out = fluid.layers.accuracy(input=predict, label=label, k=5)
......@@ -13067,24 +14991,12 @@ auc
.. code-block:: python
# network为二分类模型, label为ground truth（正确标记）
prediction = network(image, is_infer=True)
import paddle.fluid as fluid
data = fluid.layers.data(name="data", shape=[32, 32], dtype="float32")
label = fluid.layers.data(name="label", shape=[1], dtype="int32")
predict = fluid.layers.fc(input=data, size=2)
auc_out=fluid.layers.auc(input=prediction, label=label)
注：这里返回的是auc的一个全局累加值。如果想要在训练的过程中将全局auc置为0，可以参考以下代码，其中auc_status为auc相关的状态记录变量：
.. code-block:: python
def set_zero(var_name):
param = inference_scope.var(var_name).get_tensor()
param_array = np.zeros(param._get_dims()).astype("int64")
param.set(param_array, place)
for auc_state in auc_states:
set_zero(auc_state.name)
......
doc/fluid/api_cn/metrics_cn.rst
浏览文件 @ 9a601dd2
......@@ -11,7 +11,8 @@ Accuracy
.. py:class:: paddle.fluid.metrics.Accuracy(name=None)
累加mini-batch正确率，计算每次pass的平均准确率。https://en.wikipedia.org/wiki/Accuracy_and_precision
计算多批次的平均准确率。
https://en.wikipedia.org/wiki/Accuracy_and_precision
参数:
- **name** — 度量标准的名称
......@@ -20,32 +21,39 @@ Accuracy
.. code-block:: python
labels = fluid.layers.data(name="data", shape=[1], dtype="int32")
data = fluid.layers.data(name="data", shape=[32, 32], dtype="int32")
pred = fluid.layers.fc(input=data, size=1000, act="tanh")
minibatch_accuracy = fluid.layers.accuracy(pred, label)
accuracy_evaluator = fluid.metrics.Accuracy()
for pass in range(PASSES):
accuracy_evaluator.reset()
for data in train_reader():
batch_size = data[0]
loss = exe.run(fetch_list=[cost, minibatch_accuracy])
accuracy_evaluator.update(value=minibatch_accuracy, weight=batch_size)
numpy_acc = accuracy_evaluator.eval()
# 假设有batch_size = 128
batch_size=128
accuracy_manager = fluid.metrics.Accuracy()
# 假设第一个batch的准确率为0.9
batch1_acc = 0.9
accuracy_manager.update(value = batch1_acc, weight = batch_size)
print("expect accuracy: %.2f, get accuracy: %.2f" % (batch1_acc, accuracy_manager.eval()))
# 假设第二个batch的准确率为0.8
batch2_acc = 0.8
accuracy_manager.update(value = batch2_acc, weight = batch_size)
#batch1和batch2的联合准确率为(batch1_acc * batch_size + batch2_acc * batch_size) / batch_size / 2
print("expect accuracy: %.2f, get accuracy: %.2f" % ((batch1_acc * batch_size + batch2_acc * batch_size) / batch_size / 2, accuracy_manager.eval()))
#重置accuracy_manager
accuracy_manager.reset()
#假设第三个batch的准确率为0.8
batch3_acc = 0.8
accuracy_manager.update(value = batch3_acc, weight = batch_size)
print("expect accuracy: %.2f, get accuracy: %.2f" % (batch3_acc, accuracy_manager.eval()))
.. py:method:: update(value, weight)
更新mini batch的状态.
更新mini batch的状态。
参数：
- **value** (float|numpy.array) – 每个mini batch的正确率
- **weight** (int|float) – batch 大小
.. py:method:: eval()
返回所有累计batches的平均准确率（float或numpy.array）。
.. _cn_api_fluid_metrics_Auc:
......@@ -55,7 +63,7 @@ Auc
.. py:class:: paddle.fluid.metrics.Auc(name, curve='ROC', num_thresholds=4095)
Auc度量适用于二分类。参考 https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve 。需要注意auc度量本身是用Python计算值。如果关心速度，请用fluid.layers.auc。
Auc度量用于二分类。参考 https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve 。请注意auc度量是用Python实现的，可能速度略慢。
auc函数创建四个局部变量true_positives, true_negatives, false_positives和false_negatives，用于计算AUC。对于离散化AUC曲线，临界值线性间隔设置以便计算召回率和准确率的值，用false positive率的召回值高度计算ROC曲线面积，用recall的准确值高度计算PR曲线面积。
......@@ -69,15 +77,39 @@ auc函数创建四个局部变量true_positives, true_negatives, false_positives
.. code-block:: python
pred = fluid.layers.fc(input=data, size=1000, act="tanh")
metric = fluid.metrics.Auc()
for data in train_reader():
loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
metric.update(preds, labels)
numpy_auc = metric.eval()
import numpy as np
# 初始化auc度量
auc_metric = fluid.metrics.Auc("ROC")
# 假设batch_size为128
batch_num = 100
batch_size = 128
for batch_id in range(batch_num):
class0_preds = np.random.random(size = (batch_size, 1))
class1_preds = 1 - class0_preds
preds = np.concatenate((class0_preds, class1_preds), axis=1)
labels = np.random.randint(2, size = (batch_size, 1))
auc_metric.update(preds = preds, labels = labels)
# 应为一个接近0.5的值，因为preds是随机指定的
print("auc for iteration %d is %.2f" % (batch_id, auc_metric.eval()))
.. py:method:: update(preds, labels)
用给定的预测值和标签更新auc曲线。
参数：
- **preds** – 形状为(batch_size, 2)的numpy数组，preds[i][j]表示将实例i划分为类别j的概率。
- **labels** – 形状为(batch_size, 1)的numpy数组，labels[i]为0或1，代表实例i的标签。
.. py:method:: eval()
返回auc曲线下的区域（一个float值）。
......@@ -102,18 +134,29 @@ ChunkEvaluator
.. code-block:: python
labels = fluid.layers.data(name="data", shape=[1], dtype="int32")
data = fluid.layers.data(name="data", shape=[32, 32], dtype="int32")
pred = fluid.layers.fc(input=data, size=1000, act="tanh")
precision, recall, f1_score, num_infer_chunks, num_label_chunks, num_correct_chunks = fluid.layers.chunk_eval(
input=pred,
label=label)
# 初始化chunck-level的评价管理。
metric = fluid.metrics.ChunkEvaluator()
for data in train_reader():
loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
# 假设模型预测10个chuncks，其中8个为正确，且真值有9个chuncks。
num_infer_chunks = 10
num_label_chunks = 9
num_correct_chunks = 8
metric.update(num_infer_chunks, num_label_chunks, num_correct_chunks)
numpy_precision, numpy_recall, numpy_f1 = metric.eval()
print("precision: %.2f, recall: %.2f, f1: %.2f" % (numpy_precision, numpy_recall, numpy_f1))
# 下一个batch，完美地预测了3个正确的chuncks。
num_infer_chunks = 3
num_label_chunks = 3
num_correct_chunks = 3
metric.update(num_infer_chunks, num_label_chunks, num_correct_chunks)
numpy_precision, numpy_recall, numpy_f1 = metric.eval()
print("precision: %.2f, recall: %.2f, f1: %.2f" % (numpy_precision, numpy_recall, numpy_f1))
.. py:method:: update(num_infer_chunks, num_label_chunks, num_correct_chunks)
基于layers.chunk_eval()输出更新状态（state)输出
......@@ -121,7 +164,7 @@ ChunkEvaluator
参数:
- **num_infer_chunks** (int|numpy.array): 给定minibatch的Interface块数。
- **num_label_chunks** (int|numpy.array): 给定minibatch的Label块数。
- **num_correct_chunks** （int|numpy.array）: 给定minibatch的Interface和Label的块数
- **num_correct_chunks** （int|float|numpy.array）: 给定minibatch的Interface和Label的块数
......@@ -142,20 +185,24 @@ CompositeMetric
.. code-block:: python
labels = fluid.layers.data(name="data", shape=[1], dtype="int32")
data = fluid.layers.data(name="data", shape=[32, 32], dtype="int32")
pred = fluid.layers.fc(input=data, size=1000, act="tanh")
import numpy as np
preds = [[0.1], [0.7], [0.8], [0.9], [0.2],
[0.2], [0.3], [0.5], [0.8], [0.6]]
labels = [[0], [1], [1], [1], [1],
[0], [0], [0], [0], [0]]
preds = np.array(preds)
labels = np.array(labels)
comp = fluid.metrics.CompositeMetric()
acc = fluid.metrics.Precision()
precision = fluid.metrics.Precision()
recall = fluid.metrics.Recall()
comp.add_metric(acc)
comp.add_metric(precision)
comp.add_metric(recall)
for pass in range(PASSES):
comp.reset()
for data in train_reader():
loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
comp.update(preds=preds, labels=labels)
numpy_acc, numpy_recall = comp.eval()
numpy_precision, numpy_recall = comp.eval()
print("expect precision: %.2f, got %.2f" % ( 3. / 5, numpy_precision ) )
print("expect recall: %.2f, got %.2f" % (3. / 4, numpy_recall ) )
.. py:method:: add_metric(metric)
......@@ -198,17 +245,17 @@ DetectionMAP
.. py:class:: paddle.fluid.metrics.DetectionMAP(input, gt_label, gt_box, gt_difficult=None, class_num=None, background_label=0, overlap_threshold=0.5, evaluate_difficult=True, ap_version='integral')
计算 detection 平均精度（mAP）。 mAP是衡量object detectors精度的指标，比如 Faster R-CNN,SSD等。它不同于召回率，它是最大精度的平均值。 请从以下文章中获取更多信息：
https://sanchom.wordpress.com/tag/average-precision/
https://arxiv.org/abs/1512.02325
计算 detection 平均精度（mAP）。 mAP是衡量object detectors精度的指标，比如 Faster R-CNN,SSD等。它不同于召回率，它是最大精度的平均值。 5
通常步骤如下：
1. 根据detectors中的输入和label，计算 true positive 和 false positive
2. 计算map，支持 ‘11 point’ and ‘integral’
请从以下文章中获取更多信息：
- https://sanchom.wordpress.com/tag/average-precision/
- https://arxiv.org/abs/1512.0232
参数：
- **input** (Variable) – detection的结果，一个 shape=[M, 6] 的 lodtensor。布局为[label, confidence, xmin, ymin, xmax, ymax]
- **gt_label** (Variable) – ground truth label 的索引，它是一个形状为[N, 1]的lodtensor
......@@ -224,23 +271,39 @@ https://arxiv.org/abs/1512.02325
.. code-block:: python
exe = fluid.Executor(place)
map_evaluator = fluid.Evaluator.DetectionMAP(input,
gt_label, gt_box, gt_difficult)
cur_map, accum_map = map_evaluator.get_map_var()
fetch = [cost, cur_map, accum_map]
for epoch in PASS_NUM:
map_evaluator.reset(exe)
for data in batches:
loss, cur_map_v, accum_map_v = exe.run(fetch_list=fetch)
import paddle.fluid.layers as layers
batch_size = -1 # 可以为任意大小
image_boxs_num = 10
bounding_bboxes_num = 21
pb = layers.data(name='prior_box', shape=[image_boxs_num, 4],
append_batch_size=False, dtype='float32')
pbv = layers.data(name='prior_box_var', shape=[image_boxs_num, 4],
append_batch_size=False, dtype='float32')
在上述例子中：
loc = layers.data(name='target_box', shape=[batch_size, bounding_bboxes_num, 4],
append_batch_size=False, dtype='float32')
scores = layers.data(name='scores', shape=[batch_size, bounding_bboxes_num, image_boxs_num],
append_batch_size=False, dtype='float32')
nmsed_outs = fluid.layers.detection_output(scores=scores,
loc=loc, prior_box=pb, prior_box_var=pbv)
gt_box = fluid.layers.data(name="gt_box", shape=[batch_size, 4], dtype="float32")
gt_label = fluid.layers.data(name="gt_label", shape=[batch_size, 1], dtype="float32")
difficult = fluid.layers.data(name="difficult", shape=[batch_size, 1], dtype="float32")
exe = fluid.Executor(fluid.CUDAPlace(0))
map_evaluator = fluid.metrics.DetectionMAP(nmsed_outs, gt_label, gt_box, difficult, class_num = 3)
cur_map, accum_map = map_evaluator.get_map_var()
# 更详细的例子请参见
# https://github.com/PaddlePaddle/models/blob/43cdafbb97e52e6d93cc5bbdc6e7486f27665fc8/PaddleCV/object_detection
"cur_map_v" 是当前 mini-batch 的 mAP
"accum_map_v" 是一个 pass 的 mAP累加和
.. py:method:: get_map_var()
......@@ -263,8 +326,11 @@ EditDistance
.. py:class:: paddle.fluid.metrics.EditDistance(name)
编辑距离是通过计算将一个字符串转换为另一个字符串所需的最小操作数来量化两个字符串(例如单词)之间的差异的一种方法。参考 https://en.wikipedia.org/wiki/Edit_distance
从mini batch中累计编辑距离和序列号，计算所有batch的平均编辑距离和实例错误。
编辑距离是通过计算将一个字符串转换为另一个字符串所需的最小编辑操作数（添加、删除或替换）来量化两个字符串（例如单词）彼此不相似的程度一种方法。
参考 https://en.wikipedia.org/wiki/Edit_distance。
此EditDistance类使用更新函数获取两个输入：
1. distance：一个形状为（batch_size, 1）的numpy.array，每个元素表示两个序列之间的编辑距离；
2. seq_num：一个整型/浮点型数，代表序列对的数目，并返回多个序列对的整体编辑距离。
参数:
- **name** - 度量标准名称
......@@ -273,18 +339,54 @@ EditDistance
.. code-block:: python
distances, seq_num = fluid.layers.edit_distance(input, label)
distance_evaluator = fluid.metrics.EditDistance()
for epoch in PASS_NUM:
distance_evaluator.reset()
for data in batches:
loss = exe.run(fetch_list=[cost] + list(edit_distance_metrics))
distance_evaluator.update(distances, seq_num)
import numpy as np
# 假设batch_size为128
batch_size = 128
# 初始化编辑距离管理器
distances_evaluator = fluid.metrics.EditDistance("EditDistance")
# 生成128个序列对间的编辑距离，此处的最大距离是10
edit_distances_batch0 = np.random.randint(low = 0, high = 10, size = (batch_size, 1))
seq_num_batch0 = batch_size
distance_evaluator.update(edit_distances_batch0, seq_num_batch0)
distance, instance_error = distance_evaluator.eval()
avg_distance, wrong_instance_ratio = distance_evaluator.eval()
print("the average edit distance for batch0 is %.2f and the wrong instance ratio is %.2f " % (avg_distance, wrong_instance_ratio))
edit_distances_batch1 = np.random.randint(low = 0, high = 10, size = (batch_size, 1))
seq_num_batch1 = batch_size
distance_evaluator.update(edit_distances_batch1, seq_num_batch1)
avg_distance, wrong_instance_ratio = distance_evaluator.eval()
print("the average edit distance for batch0 and batch1 is %.2f and the wrong instance ratio is %.2f " % (avg_distance, wrong_instance_ratio))
.. py:method:: distance_evaluator.reset()
.. code-block:: python
edit_distances_batch2 = np.random.randint(low = 0, high = 10, size = (batch_size, 1))
seq_num_batch2 = batch_size
distance_evaluator.update(edit_distances_batch2, seq_num_batch2)
avg_distance, wrong_instance_ratio = distance_evaluator.eval()
print("the average edit distance for batch2 is %.2f and the wrong instance ratio is %.2f " % (avg_distance, wrong_instance_ratio))
.. py:method:: update(distances, seq_num)
更新整体的编辑距离。
参数：
- **distances** – 一个形状为(batch_size, 1)的numpy.array，每个元素代表两个序列间的距离。(edit) –
- **seq_num** – 一个整型/浮点型值，代表序列对的数量。
在上面的例子中：'distance'是一个pass中的编辑距离的平均值。 'instance_error'是一个pass中的实例的错误率。
.. py:method:: eval()
返回两个浮点数：
avg_distance：使用更新函数更新的所有序列对的平均距离。
avg_instance_error：编辑距离不为零的序列对的比例。
......@@ -310,8 +412,6 @@ MetricBase
获取度量（metric)状态和当前状态。状态（state）包含没有 ``_`` 前缀的成员。
参数：**None**
返回：metric对应到state的字典
返回类型：字典（dict）
......@@ -346,27 +446,36 @@ Precision
.. py:class:: paddle.fluid.metrics.Precision(name=None)
Precision(也称为 positive predictive value,正预测值)是被预测为正样例中实际为正的比例。https://en.wikipedia.org/wiki/Evaluation_of_binary_classifiers
注:二分类中，Precision与Accuracy不同,
Precision(也称为 positive predictive value,正预测值)是被预测为正样例中实际为正的比例。
https://en.wikipedia.org/wiki/Evaluation_of_binary_classifiers
该类管理二分类任务的precision分数。
.. math::
Accuracy & = \frac{true \quad positive}{total \quad instances(所有样例)} \\\\
Precision & = \frac{true \quad positive}{all \quad positive \quad instances(所有正样例)}
**代码示例**
.. code-block:: python
import numpy as np
metric = fluid.metrics.Precision()
for pass in range(PASSES):
metric.reset()
for data in train_reader():
loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
# 生成预测值和标签
preds = [[0.1], [0.7], [0.8], [0.9], [0.2],
[0.2], [0.3], [0.5], [0.8], [0.6]]
labels = [[0], [1], [1], [1], [1],
[0], [0], [0], [0], [0]]
preds = np.array(preds)
labels = np.array(labels)
metric.update(preds=preds, labels=labels)
numpy_precision = metric.eval()
print("expct precision: %.2f and got %.2f" % ( 3.0 / 5.0, numpy_precision))
......@@ -384,18 +493,29 @@ Recall
https://en.wikipedia.org/wiki/Precision_and_recall
该类管理二分类任务的召回率。
**代码示例**
.. code-block:: python
import numpy as np
metric = fluid.metrics.Recall()
# 生成预测值和标签
preds = [[0.1], [0.7], [0.8], [0.9], [0.2],
[0.2], [0.3], [0.5], [0.8], [0.6]]
labels = [[0], [1], [1], [1], [1],
[0], [0], [0], [0], [0]]
preds = np.array(preds)
labels = np.array(labels)
for pass in range(PASSES):
metric.reset()
for data in train_reader():
loss, preds, labels = exe.run(fetch_list=[cost, preds, labels])
metric.update(preds=preds, labels=labels)
numpy_recall = metric.eval()
numpy_precision = metric.eval()
print("expct precision: %.2f and got %.2f" % ( 3.0 / 4.0, numpy_precision))
......
doc/fluid/api_cn/nets_cn.rst
浏览文件 @ 9a601dd2
......@@ -30,8 +30,10 @@ he Gated Linear Units(GLU)由切分（split），sigmoid激活函数和按元素
.. code-block:: python
data = fluid.layers.data(name="words", shape=[3, 6, 9], dtype="float32")
output = fluid.nets.glu(input=data, dim=1) # shape of output: [3, 3, 9]
data = fluid.layers.data(
name="words", shape=[-1, 6, 3, 9], dtype="float32")
# 输出的形状为[-1, 3, 3, 9]
output = fluid.nets.glu(input=data, dim=1)
......@@ -74,7 +76,6 @@ Image Convolution Group由Convolution2d，BatchNorm，DropOut和Pool2d组成。
img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
conv_pool = fluid.nets.img_conv_group(input=img,
num_channels=3,
conv_padding=1,
conv_num_filter=[3, 3],
conv_filter_size=3,
......@@ -128,6 +129,8 @@ attention运算机制可以被视为将查询和一组键值对映射到输出
.. code-block:: python
import paddle.fluid as fluid
queries = fluid.layers.data(name="queries",
shape=[3, 5, 9],
dtype="float32",
......@@ -181,10 +184,11 @@ sequence_conv_pool由序列卷积和池化组成
.. code-block:: python
input_dim = len(word_dict)
import paddle.fluid as fluid
input_dim = 100 #len(word_dict)
emb_dim = 128
hid_dim = 512
data = fluid.layers.data( ame="words", shape=[1], dtype="int64", lod_level=1)
data = fluid.layers.data( name="words", shape=[1], dtype="int64", lod_level=1)
emb = fluid.layers.embedding(input=data, size=[input_dim, emb_dim], is_sparse=True)
seq_conv = fluid.nets.sequence_conv_pool(input=emb,
num_filters=hid_dim,
......@@ -234,6 +238,7 @@ simple_img_conv_pool
.. code-block:: python
import paddle.fluid as fluid
img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
conv_pool = fluid.nets.simple_img_conv_pool(input=img,
filter_size=5,
......
doc/fluid/api_cn/optimizer_cn.rst
浏览文件 @ 9a601dd2
......@@ -58,8 +58,22 @@ http://cs231n.github.io/neural-networks-3/#ada 用于维持数值稳定性，避
.. code-block:: python:
import paddle.fluid as fluid
import numpy as np
np_inp = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)
inp = fluid.layers.data(
name="inp", shape=[2, 2], append_batch_size=False)
out = fluid.layers.fc(inp, size=3)
out = fluid.layers.reduce_sum(out)
optimizer = fluid.optimizer.Adagrad(learning_rate=0.2)
optimizer.minimize(cost)
optimizer.minimize(out)
exe = fluid.Executor(fluid.CPUPlace())
exe.run(fluid.default_startup_program())
exe.run(
feed={"inp": np_inp},
fetch_list=[out.name])
......@@ -119,6 +133,34 @@ Adamax 更新规则:
论文中没有 ``epsilon`` 参数。但是，为了数值稳定性， 防止除0错误， 增加了这个参数
**代码示例**：
.. code-block:: python:
import paddle.fluid as fluid
import numpy
# First create the Executor.
place = fluid.CPUPlace() # fluid.CUDAPlace(0)
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)
adam = fluid.optimizer.Adamax(learning_rate=0.2)
adam.minimize(loss)
# Run the startup program once and only once.
exe.run(startup_program)
x = numpy.random.random(size=(10, 1)).astype('float32')
outs = exe.run(program=train_program,
feed={'X': x},
fetch_list=[loss.name])
参数:
- **learning_rate** (float|Variable) - 用于更新参数的学习率。可以是浮点值，也可以是具有一个浮点值作为数据元素的变量。
- **beta1** (float) - 第1阶段估计的指数衰减率
......@@ -127,13 +169,6 @@ Adamax 更新规则:
- **regularization** - 正则化器，例如 ``fluid.regularizer.L2DecayRegularizer``
- **name** - 可选的名称前缀。
**代码示例**
.. code-block:: python
optimizer = fluid.optimizer.Adamax(learning_rate=0.2)
optimizer.minimize(cost)
.. note::
目前 ``AdamaxOptimizer`` 不支持 sparse parameter optimization.
......@@ -176,9 +211,28 @@ Adam更新如下：
.. code-block:: python:
optimizer = fluid.optimizer.Adam(learning_rate=0.2)
optimizer.minimize(cost)
import paddle
import paddle.fluid as fluid
place = fluid.CPUPlace()
main = fluid.Program()
with fluid.program_guard(main):
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_cost = fluid.layers.mean(cost)
adam_optimizer = fluid.optimizer.AdamOptimizer(0.01)
adam_optimizer.minimize(avg_cost)
fetch_list = [avg_cost]
train_reader = paddle.batch(
paddle.dataset.uci_housing.train(), batch_size=1)
feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
for data in train_reader():
exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
......@@ -230,11 +284,18 @@ Decayed Adagrad Optimizer
.. code-block:: python
import paddle.fluid as fluid
import paddle.fluid.layers as layers
from paddle.fluid.optimizer import DecayedAdagrad
x = layers.data( name='x', shape=[-1, 10], dtype='float32' )
trans = layers.fc( x, 100 )
cost = layers.reduce_mean( trans )
optimizer = fluid.optimizer.DecayedAdagrad(learning_rate=0.2)
optimizer.minimize(cost)
.. note::
``DecayedAdagradOptimizer`` 不支持 sparse parameter optimization
当前， ``DecayedAdagradOptimizer`` 不支持 sparse parameter optimization
......@@ -280,20 +341,192 @@ DGC还使用动量因子掩藏(momentum factor masking)和预训练(warm-up)来
.. code-block:: python
optimizer = fluid.optimizer.DGCMomentumOptimizer(
learning_rate=fluid.layers.piecewise_decay(
boundaries=bd, values=lr),
learning_rate=0.0001,
momentum=0.9,
rampup_step=1000,
rampup_begin_step=1252,
regularization=fluid.regularizer.L2Decay(1e-4))
sparsity=[0.999, 0.999])
.. _cn_api_fluid_optimizer_PipelineOptimizer:
PipelineOptimizer
-------------------------------
.. py:class:: paddle.fluid.optimizer.PipelineOptimizer(optimizer, cut_list=None, place_list=None, concurrency_list=None, queue_size=30, sync_steps=1, start_cpu_core_id=0)
Pipeline 优化器训练。该程序将由cut_list分割。如果cut_list的长度是k，则整个程序（包括向后部分）将被分割为2 * k-1个部分。 所以place_list和concurrency_list的长度也必须是2 * k-1。
.. note::
虽然异步模式应用于管道训练中以加速，但最终的性能取决于每个管道的训练进度。 我们将在未来尝试同步模式。
参数:
- **optimizer** (Optimizer) - 基础优化器，如SGD
- **cut_list** (list of Variable list) - main_program的cut变量
- **place_lis** (list of Place) - 某部分运行的位置
- **concurrency_lis** (list of int) - 并发度
- **queue_size** (int) - 每个部分都将使用其范围内队列(in-scope queue)中的范围并将范围生成到范围外队列(out-scope queue)。 而这个参数定范围队列大小。 这一参数可选，默认值：30。
- **sync_steps** (int) - 不同显卡之间的同步步数
- **start_cpu_core_id** (int) - 设置第一个cpu核的id。这一参数可选，默认值：0。
**代码示例**
.. code-block:: python
x = fluid.layers.data(name='x', shape=[1], dtype='int64', lod_level=0)
y = fluid.layers.data(name='y', shape=[1], dtype='int64', lod_level=0)
emb_x = layers.embedding(input=x, param_attr=fluid.ParamAttr(name="embx"), size=[10,2], is_sparse=False)
emb_y = layers.embedding(input=y, param_attr=fluid.ParamAttr(name="emby",learning_rate=0.9), size=[10,2], is_sparse=False)
concat = layers.concat([emb_x, emb_y], axis=1)
fc = layers.fc(input=concat, name="fc", size=1, num_flatten_dims=1, bias_attr=False)
loss = layers.reduce_mean(fc)
optimizer = fluid.optimizer.SGD(learning_rate=0.5)
optimizer = fluid.optimizer.PipelineOptimizer(optimizer,
cut_list=[[emb_x, emb_y], [loss]],
place_list=[fluid.CPUPlace(), fluid.CUDAPlace(0), fluid.CPUPlace()],
concurrency_list=[1, 1, 4],
queue_size=2,
sync_steps=1,
)
optimizer.minimize(loss)
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
filelist = [] # 您应该根据需求自行设置文件列表, 如: filelist = ["dataA.txt"]
dataset = fluid.DatasetFactory().create_dataset("FileInstantDataset")
dataset.set_use_var([x,y])
dataset.set_batch_size(batch_size)
dataset.set_filelist(filelist)
exe.train_from_dataset(
fluid.default_main_program(),
dataset,
thread=2,
debug=False,
fetch_list=[],
fetch_info=[],
print_period=1)
.. py:method:: extract_section_opt_ops(ops, cut_point_name)
获取指定section的优化算子(opt ops)
.. py:method:: extract_section_opt_ops(ops, cut_point_name)
获取指定section的输入和输出
.. py:method:: find_persistable_vars(ops, whole_parameters)
获取指定section的持久性输入变量
.. py:method:: extract_section_ops(ops, cut_point_name)
获取指定的section的算子(ops)
.. _cn_api_fluid_optimizer_ExponentialMovingAverage:
ExponentialMovingAverage
-------------------------------
.. py:class:: paddle.fluid.optimizer.ExponentialMovingAverage(decay=0.999, thres_steps=None, name=None)
用指数衰减计算参数的移动平均值。
给出参数 :math:`\theta` ，它的指数移动平均值(exponential moving average, EMA)
为
.. math::
\begin{align}\begin{aligned}\text{EMA}_0 & = 0\\\text{EMA}_t & = \text{decay} * \text{EMA}_{t-1} + (1 - \text{decay}) * \theta_t\end{aligned}\end{align}
用 ``update()`` 方法计算出的平均结果将保存在由对象创建和维护的临时变量中，并且可以通过调用 ``apply()`` 方法把结果应用于当前模型的参数。另外，``restore()`` 方法用于恢复参数。
**偏差教正。** 所有的EMAs均初始化为 :math:`0` ，因此它们将为零偏差，可以通过除以因子 :math:`(1 - \text{decay}^t)` 来校正，即在调用 ``apply()`` 方法时应用于参数的真实EMAs将为：
.. math::
\widehat{\text{EMA}}_t = \frac{\text{EMA}_t}{1 - \text{decay}^t}
**衰减率调度。** 一个非常接近于1的很大的衰减率将会导致平均值移动得很慢。更优的策略是，一开始就设置一个相对较小的衰减率。参数thres_steps允许用户传递一个变量以设置衰减率，在这种情况下，
真实的衰减率变为 ：
.. math::
\min(\text{decay}, \frac{1 + \text{thres_steps}}{10 + \text{thres_steps}})
通常thres_steps可以是全局训练steps。
参数：
- **decay** (float) – 指数衰减率，通常接近1，如0.999，0.9999，……
- **thres_steps** (Variable|None) – 如果不为None，指定衰减率。
- **name** (str|None) – 名字前缀（可选项）。
**代码示例**
.. code-block:: python
import numpy
import paddle
import paddle.fluid as fluid
data = fluid.layers.data(name='x', shape=[5], dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
cost = fluid.layers.mean(hidden)
test_program = fluid.default_main_program().clone(for_test=True)
optimizer = fluid.optimizer.Adam(learning_rate=0.001)
optimizer.minimize(cost)
global_steps = fluid.layers.learning_rate_scheduler._decay_step_counter()
ema = fluid.optimizer.ExponentialMovingAverage(0.999, thres_steps=global_steps)
ema.update()
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
for pass_id in range(3):
for batch_id in range(6):
data = numpy.random.random(size=(10, 5)).astype('float32')
exe.run(program=fluid.default_main_program(),
feed={'x': data},
fetch_list=[cost.name])
# usage 1
with ema.apply(exe):
data = numpy.random.random(size=(10, 5)).astype('float32')
exe.run(program=test_program,
feed={'x': data},
fetch_list=[hidden.name])
# usage 2
with ema.apply(exe, need_restore=False):
data = numpy.random.random(size=(10, 5)).astype('float32')
exe.run(program=test_program,
feed={'x': data},
fetch_list=[hidden.name])
ema.restore(exe)
.. py:method:: update()
更新指数滑动平均。仅在训练程序中调用此方法。
.. py:method:: apply(executor, need_restore=True)
参数：
- **executor** (Executor) – 执行应用的执行引擎。
- **need_restore** (bool) –是否在应用后恢复参数。
.. py:method:: restore(executor)
参数：
- **executor** (Executor) – 执行存储的执行引擎。
......@@ -354,8 +587,31 @@ FTRL 原始论文: ( `https://www.eecs.tufts.edu/~dsculley/papers/ad-click-predi
.. code-block:: python
optimizer = fluid.optimizer.Ftrl(0.0001)
_, params_grads = optimizer.minimize(cost)
import paddle
import paddle.fluid as fluid
import numpy as np
place = fluid.CPUPlace()
main = fluid.Program()
with fluid.program_guard(main):
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_cost = fluid.layers.mean(cost)
ftrl_optimizer = fluid.optimizer.Ftrl(learning_rate=0.1)
ftrl_optimizer.minimize(avg_cost)
fetch_list = [avg_cost]
train_reader = paddle.batch(
paddle.dataset.uci_housing.train(), batch_size=1)
feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
for data in train_reader():
exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
.. note::
目前, FtrlOptimizer 不支持 sparse parameter optimization
......@@ -363,7 +619,44 @@ FTRL 原始论文: ( `https://www.eecs.tufts.edu/~dsculley/papers/ad-click-predi
.. _cn_api_fluid_optimizer_LambOptimizer:
LambOptimizer
-------------------------------
.. py:class:: paddle.fluid.optimizer.LambOptimizer(learning_rate=0.001, lamb_weight_decay=0.01, beta1=0.9, beta2=0.999, epsilon=1e-06, regularization=None, name=None)
LAMB（Layer-wise Adaptive Moments optimizer for Batching training）优化器
LAMB优化器旨在不降低准确性的条件下扩大训练的批量大小，支持自适应元素更新和精确的分层校正。 更多信息请参考Reducing BERT Pre-Training Time from 3 Days to 76 Minutes。
参数更新如下：
.. math::
\begin{align}\begin{aligned}m_t^l & = \beta_1 m_{t - 1}^l + (1 - \beta_1)g_t^l\\v_t^l & = \beta_2 v_{t - 1}^l + (1 - \beta_2)g_t^l \odot g_t^l\\\widehat{m}_t^l & = m_t^l/(1 - \beta_1^t)\\\widehat{v}_t^l & = v_t^l/(1 - \beta_2^t)\\r_1 & = \left \| w_{t-1}^l \right \|_2\\r_2 & = \left \| \frac{\widehat{m}_t^l}{\sqrt{\widehat{v}_t^l+\epsilon}} + \lambda w_{t-1}^l \right \|_2\\r & = r_1 / r_2\\\eta^l & = r \times \eta\\w_t^l & = w_{t-1}^l -\eta ^l \times (\frac{\widehat{m}_t^l}{\sqrt{\widehat{v}_t^l+\epsilon}} + \lambda w_{t-1}^l)\end{aligned}\end{align}
其中 :math:`m` 为第一个时刻，:math:`v` 为第二个时刻，:math:`\eta` 为学习率，:math:`\lambda` 为LAMB权重衰减率。
参数：
- **learning_rate** (float|Variable) – 用于更新参数的学习速率。可以是浮点值或具有一个作为数据元素的浮点值的变量。
- **lamb_weight_decay** (float) – LAMB权重衰减率。
- **beta1** (float) – 第一个时刻估计的指数衰减率。
- **beta2** (float) – 第二个时刻估计的指数衰减率。
- **epsilon** (float) – 一个小的浮点值，目的是维持数值稳定性。
- **regularization** – 一个正则化器，如fluid.regularizer.L1DecayRegularizer。
- **name** (str|None) – 名字前缀（可选项）。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
data = fluid.layers.data(name='x', shape=[5], dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
cost = fluid.layers.mean(hidden)
optimizer = fluid.optimizer.Lamb(learning_rate=0.002)
optimizer.minimize(cost)
......@@ -442,29 +735,55 @@ ModelAverage
.. code-block:: python
optimizer = fluid.optimizer.Momentum()
optimizer.minimize(cost)
import paddle.fluid as fluid
import numpy
# 首先创建执行引擎
place = fluid.CPUPlace() # fluid.CUDAPlace(0)
exe = fluid.Executor(place)
train_program = fluid.Program()
startup_program = fluid.Program()
with fluid.program_guard(train_program, startup_program):
# 构建net
data = fluid.layers.data(name='X', shape=[1], dtype='float32')
hidden = fluid.layers.fc(input=data, size=10)
loss = fluid.layers.mean(hidden)
optimizer = fluid.optimizer.Momentum(learning_rate=0.2, momentum=0.1)
optimizer.minimize(loss)
# 构建ModelAverage优化器
model_average = fluid.optimizer.ModelAverage(0.15,
min_average_window=10000,
max_average_window=20000)
for pass_id in range(args.pass_num):
for data in train_reader():
exe.run(fluid.default_main_program()...)
exe.run(startup_program)
x = numpy.random.random(size=(10, 1)).astype('float32')
outs = exe.run(program=train_program,
feed={'X': x},
fetch_list=[loss.name])
# 应用ModelAverage
with model_average.apply(exe):
for data in test_reader():
exe.run(inference_program...)
x = numpy.random.random(size=(10, 1)).astype('float32')
exe.run(program=train_program,
feed={'X': x},
fetch_list=[loss.name])
.. py:method:: apply(executor, need_restore=True)
将平均值应用于当前模型的参数。
参数：
- **executor** (fluid.Executor) – 当前的执行引擎。
- **need_restore** (bool) – 如果您最后需要实现恢复，将其设为True。默认值True。
.. py:method:: restore(executor)
恢复当前模型的参数值
参数：
- **executor** (fluid.Executor) – 当前的执行引擎。
......@@ -510,8 +829,30 @@ MomentumOptimizer
.. code-block:: python
optimizer = fluid.optimizer.Momentum(learning_rate=0.2, momentum=0.1)
optimizer.minimize(cost)
import paddle
import paddle.fluid as fluid
import numpy as np
place = fluid.CPUPlace()
main = fluid.Program()
with fluid.program_guard(main):
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_cost = fluid.layers.mean(cost)
moment_optimizer = fluid.optimizer.MomentumOptimizer(learning_rate=0.001, momentum=0.9)
moment_optimizer.minimize(avg_cost)
fetch_list = [avg_cost]
train_reader = paddle.batch(
paddle.dataset.uci_housing.train(), batch_size=1)
feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
for data in train_reader():
exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
......@@ -565,8 +906,30 @@ RMSPropOptimizer
.. code-block:: python
optimizer = fluid.optimizer.RMSProp(0.0001)
_, params_grads = optimizer.minimize(cost)
import paddle
import paddle.fluid as fluid
import numpy as np
place = fluid.CPUPlace()
main = fluid.Program()
with fluid.program_guard(main):
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_cost = fluid.layers.mean(cost)
rms_optimizer = fluid.optimizer.RMSProp(learning_rate=0.1)
rms_optimizer.minimize(avg_cost)
fetch_list = [avg_cost]
train_reader = paddle.batch(
paddle.dataset.uci_housing.train(), batch_size=1)
feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
for data in train_reader():
exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
......@@ -614,8 +977,30 @@ SGDOptimizer
.. code-block:: python
sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.2)
sgd_optimizer.minimize(cost)
import paddle
import paddle.fluid as fluid
import numpy as np
place = fluid.CPUPlace()
main = fluid.Program()
with fluid.program_guard(main):
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_cost = fluid.layers.mean(cost)
sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.001)
sgd_optimizer.minimize(avg_cost)
fetch_list = [avg_cost]
train_reader = paddle.batch(
paddle.dataset.uci_housing.train(), batch_size=1)
feeder = fluid.DataFeeder(place=place, feed_list=[x, y])
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
for data in train_reader():
exe.run(main, feed=feeder.feed(data), fetch_list=fetch_list)
......
doc/fluid/api_cn/profiler_cn.rst
浏览文件 @ 9a601dd2
......@@ -31,6 +31,7 @@ CUDA分析器。通过CUDA运行时应用程序编程接口对CUDA程序进行
import paddle.fluid as fluid
import paddle.fluid.profiler as profiler
import numpy as np
epoc = 8
dshape = [4, 3, 28, 28]
......@@ -82,15 +83,21 @@ profile interface 。与cuda_profiler不同，此profiler可用于分析CPU和GP
.. code-block:: python
import paddle.fluid.profiler as profiler
import numpy as np
with profiler.profiler('All', 'total', '/tmp/profile') as prof:
for pass_id in range(pass_num):
for batch_id, data in enumerate(train_reader()):
exe.run(fluid.default_main_program(),
feed=feeder.feed(data),
fetch_list=[],
use_program_cache=True)
# ...
epoc = 8
dshape = [4, 3, 28, 28]
data = fluid.layers.data(name='data', shape=[3, 28, 28], dtype='float32')
conv = fluid.layers.conv2d(data, 20, 3, stride=[1, 1], padding=[1, 1])
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
with profiler.profiler('CPU', 'total', '/tmp/profile') as prof:
for i in range(epoc):
input = np.random.random(dshape).astype('float32')
exe.run(fluid.default_main_program(), feed={'data': input})
......@@ -112,7 +119,7 @@ reset_profiler
.. code-block:: python
import paddle.fluid.profiler as profiler
with profiler.profiler(state, 'total', '/tmp/profile'):
with profiler.profiler('CPU', 'total', '/tmp/profile'):
for iter in range(10):
if iter == 2:
profiler.reset_profiler()
......
doc/fluid/api_cn/recordio_writer_cn.rst 已删除 100644 → 0
浏览文件 @ 0009c8e3
#######################
fluid.recordio_writer
#######################
.. _cn_api_fluid_recordio_writer_convert_reader_to_recordio_file:
convert_reader_to_recordio_file
-------------------------------
.. py:function:: paddle.fluid.recordio_writer.convert_reader_to_recordio_file(filename, reader_creator, feeder, compressor=Compressor.Snappy, max_num_records=1000, feed_order=None)
将 Python reader 转换为recordio文件
**代码示例：**
.. code-block:: python
import paddle.fluid as fluid
import paddle.dataset.mnist as mnist
import paddle
tmp_program = fluid.Program()
with fluid.program_guard(tmp_program):
img = fluid.layers.data(name='img', shape=[784])
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
feeder = fluid.DataFeeder(feed_list=[img, label], place=fluid.CPUPlace())
# mnist.recordio 会在当前目录生成
fluid.recordio_writer.convert_reader_to_recordio_file(
filename="mnist.recordio",
reader_creator=paddle.batch(mnist.train(), batch_size=32),
feeder=feeder)
参数：
- **filename** (str) - recordio文件名
- **reader_creator** (callable) - Python reader的创造器。可参考 :ref:`api_guide_python_reader`
- **feeder** (DataFeeder) - 数据处理实例。用于将 :code:`reader_creator` 转换为 :code:`lod_tensor`
- **compressor** – 必须在 :code:`fluid.core.RecordIOWriter.Compressor.Snappy` 或 :code:` fluid.core.RecordIOWriter.Compressor.NoCompress` 中， 默认情况下使用 :code:`Snappy`
- **max_num_records** (int) – 一个 chuck 中 records 的最大数量。每个 records 都是 reader 函数的返回值
- **feed_order** (list) - reader 返回的变量名的顺序
返回： 保存的 record 的数目
返回类型： int
.. _cn_api_fluid_recordio_writer_convert_reader_to_recordio_files:
convert_reader_to_recordio_files
-------------------------------
.. py:function:: paddle.fluid.recordio_writer.convert_reader_to_recordio_files(filename, batch_per_file, reader_creator, feeder, compressor=Compressor.Snappy, max_num_records=1000, feed_order=None)
该函数可以将一个python驱动的reader（数据读取器）转变为多个recodio文件。
该API实现的功能和 ``convert_reader_to_recordio_file`` 基本相同，只不过本函数会生成多个recordio文件。
每个文件最多存储 ``batch_per_file`` 条记录。
请参照 :ref:`cn_api_fluid_recordio_writer_convert_reader_to_recordio_file` 获取更详细的介绍。
doc/fluid/api_cn/regularizer_cn.rst
浏览文件 @ 9a601dd2
......@@ -35,11 +35,21 @@ L1正则将会稀疏化权重矩阵。
.. code-block:: python
ioptimizer = fluid.optimizer.Adagrad(
import paddle.fluid as fluid
main_prog = fluid.Program()
startup_prog = fluid.Program()
with fluid.program_guard(main_prog, startup_prog):
data = fluid.layers.data(name='image', shape=[3, 28, 28], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
hidden = fluid.layers.fc(input=data, size=128, act='relu')
prediction = fluid.layers.fc(input=hidden, size=10, act='softmax')
loss = fluid.layers.cross_entropy(input=prediction, label=label)
avg_loss = fluid.layers.mean(loss)
optimizer = fluid.optimizer.Adagrad(
learning_rate=1e-4,
regularization=fluid.regularizer.L1DecayRegularizer(
regularization_coeff=0.1))
optimizer.minimize(avg_cost)
optimizer.minimize(avg_loss)
......@@ -82,11 +92,21 @@ L2DecayRegularizer
.. code-block:: python
import paddle.fluid as fluid
main_prog = fluid.Program()
startup_prog = fluid.Program()
with fluid.program_guard(main_prog, startup_prog):
data = fluid.layers.data(name='image', shape=[3, 28, 28], dtype='float32')
label = fluid.layers.data(name='label', shape=[1], dtype='int64')
hidden = fluid.layers.fc(input=data, size=128, act='relu')
prediction = fluid.layers.fc(input=hidden, size=10, act='softmax')
loss = fluid.layers.cross_entropy(input=prediction, label=label)
avg_loss = fluid.layers.mean(loss)
optimizer = fluid.optimizer.Adagrad(
learning_rate=1e-4,
regularization=fluid.regularizer.L2DecayRegularizer(
regularization_coeff=0.1))
optimizer.minimize(avg_cost)
optimizer.minimize(avg_loss)
......
doc/fluid/api_cn/transpiler_cn.rst
浏览文件 @ 9a601dd2
......@@ -24,14 +24,23 @@ DistributeTranspiler
.. code-block:: python
# for pserver mode
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)
# pserver 模式下
pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
current_endpoint = "192.168.0.1:6174"
trainer_id = 0
trainers = 4
role = os.getenv("PADDLE_TRAINING_ROLE")
role = "PSERVER"
t = fluid.DistributeTranspiler()
t.transpile(
trainer_id, pservers=pserver_endpoints, trainers=trainers)
......@@ -42,15 +51,18 @@ DistributeTranspiler
elif role == "TRAINER":
trainer_program = t.get_trainer_program()
# for nccl2 mode
# nccl2 模式下
trainer_num = 2
trainer_id = 0
config = fluid.DistributeTranspilerConfig()
config.mode = "nccl2"
trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
t = fluid.DistributeTranspiler(config=config)
t.transpile(trainer_id, workers=workers, current_endpoint=curr_ep)
t.transpile(trainer_id=trainer_id, trainers=trainer_endpoints, current_endpoint="192.168.0.1:6174")
exe = fluid.ParallelExecutor(
use_cuda,
loss_name=loss_var.name,
num_trainers=len(trainers.split(",)),
use_cuda=True,
loss_name=avg_loss.name,
num_trainers=trainer_num,
trainer_id=trainer_id
)
......@@ -58,7 +70,7 @@ DistributeTranspiler
.. py:method:: transpile(trainer_id, program=None, pservers='127.0.0.1:6174', trainers=1, sync_mode=True, startup_program=None, current_endpoint='127.0.0.1:6174')
该方法可以运行该transpiler（转译器）。
该方法可以运行该transpiler（转译器）。转译输入程序。
参数:
- **trainer_id** (int) – 当前Trainer worker的id, 如果有n个Trainer worker, id 取值范围为0 ~ n-1
......@@ -70,6 +82,19 @@ DistributeTranspiler
- **startup_program** (Program|None) – 待transpile（转译）的startup_program，默认为 ``fluid.default_main_program()``
- **current_endpoint** (str) – 当需要把program转译（transpile）至NCCL2模式下时，需要将当前endpoint（终端）传入该参数。Pserver模式不使用该参数
**代码示例**
.. code-block:: python
transpiler = fluid.DistributeTranspiler()
t.transpile(
trainer_id=0,
pservers="127.0.0.1:7000,127.0.0.1:7001",
trainers=2,
sync_mode=False,
current_endpoint="127.0.0.1:7000")
.. py:method:: get_trainer_program(wait_port=True)
......@@ -79,6 +104,18 @@ DistributeTranspiler
返回类型: Program
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# 这是一个示例，请根据你的情况更改endpoint
pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
trainer_id = 0
trainers = 4
t = fluid.DistributeTranspiler()
t.transpile(trainer_id, trainers=trainers, pservers=pserver_endpoints)
trainer_program = t.get_trainer_program()
.. py:method:: get_pserver_program(endpoint)
......@@ -93,6 +130,21 @@ DistributeTranspiler
返回类型: Program
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# 这是一个示例，请根据你的情况更改endpoint
pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
current_endpoint = "192.168.0.1:6174"
trainer_id = 0
trainers = 4
t = fluid.DistributeTranspiler()
t.transpile(
trainer_id, pservers=pserver_endpoints, trainers=trainers)
pserver_program = t.get_pserver_program(current_endpoint)
.. py:method:: get_pserver_programs(endpoint)
......@@ -107,6 +159,22 @@ DistributeTranspiler
返回类型: tuple
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# 这是一个示例，请根据你的情况更改endpoint
pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
current_endpoint = "192.168.0.1:6174"
trainer_id = 0
trainers = 4
t = fluid.DistributeTranspiler()
t.transpile(
trainer_id, pservers=pserver_endpoints, trainers=trainers)
pserver_program, pserver_startup_program = t.get_pserver_programs(current_endpoint)
.. py:method:: get_startup_program(endpoint, pserver_program=None, startup_program=None)
......@@ -122,9 +190,21 @@ DistributeTranspiler
返回类型: Program
**代码示例**
.. code-block:: python
pserver_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
trainer_endpoints = "192.168.0.1:6174,192.168.0.2:6174"
current_endpoint = "192.168.0.1:6174"
trainer_id = 0
trainers = 4
t = fluid.DistributeTranspiler()
t.transpile(trainer_id, pservers=pserver_endpoints, trainers=trainers)
pserver_program = t.get_pserver_program(current_endpoint)
pserver_startup_program = t.get_startup_program(current_endpoint,
pserver_program)
......@@ -152,9 +232,12 @@ DistributeTranspilerConfig
注意: 根据：https://github.com/PaddlePaddle/Paddle/issues/8638#issuecomment-369912156 , 当数据块大小超过2MB时，我们可以有效地使用带宽。如果你想更改它，请详细查看slice_variable函数。
**代码示例**
.. code-block:: python
config = fluid.DistributeTranspilerConfig()
config.slice_var_up = True
......@@ -170,9 +253,14 @@ HashName
参数:
- **pserver_endpoints** (list) - endpoint （ip:port）的 list
**代码示例**
.. code-block:: python
pserver_endpoints = [“127.0.0.1:6007”, “127.0.0.1:6008”]
vars = [“var1”,”var2”,”var3”,”var4”,”var5”]
rr = RoundRobin(pserver_endpoints)
rr.dispatch(vars)
......@@ -184,21 +272,47 @@ memory_optimize
.. py:function:: paddle.fluid.transpiler.memory_optimize(input_program, skip_opt_set=None, print_log=False, level=0, skip_grads=False)
通过重用var内存来优化内存。
历史遗留内存优化策略，通过在不同operators之间重用可变内存来减少总内存消耗。
用一个简单的例子来解释该算法：
c = a + b # 假设此处是最后一次使用a
d = b * c
因为在“c = a + b”之后将不再使用a，并且a和d的大小相同，所有我们可以使用变量a来替换变量d，即实际上我们可以将上面的代码优化为如下所示：
c = a + b
a = b * c
请注意，在这个历史遗留设计中，我们使用变量a直接替换d，这意味着在调用此API之后，某些变量可能会消失，而某些变量可能会保留非预期值，如在上面的例子中，实际上执行代码后a保持d的值。
注意:它不支持block中嵌套子block。
因此，为了防止重要变量在优化中被重用/删除，我们提供skip_opt_set用于指定变量白名单。
skip_opt_set中的变量不受memory_optimize API的影响。
注意：
此API已弃用，请避免在新代码中使用它。
不支持会创建子块的运算符，如While，IfElse等。
参数:
- **input_program** (str) – 输入Program。
- **skip_opt_set** (set) – set中的vars将不被内存优化。
- **print_log** (bool) – 是否打印debug日志。
- **level** (int) - 如果 level=0 并且shape是完全相等，则重用。
- **level** (int) - 0或1，0代表我们仅在a.size == b.size时用b替换a，1代表我们可以在a.size <= b.size时用b替换a
返回: None
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
main_prog = fluid.Program()
startup_prog = fluid.Program()
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(startup_prog)
fluid.memory_optimize(main_prog)
......@@ -222,9 +336,16 @@ release_memory
返回: None
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# 构建网络
# ...
# 已弃用的API
fluid.release_memory(fluid.default_main_program())
......@@ -250,9 +371,14 @@ RoundRobin
参数:
- **pserver_endpoints** (list) - endpoint （ip:port）的 list
**代码示例**
.. code-block:: python
pserver_endpoints = [“127.0.0.1:6007”, “127.0.0.1:6008”]
vars = [“var1”,”var2”,”var3”,”var4”,”var5”]
rr = RoundRobin(pserver_endpoints)
rr.dispatch(vars)
......
doc/fluid/api_cn/unique_name_cn.rst 0 → 100644
浏览文件 @ 9a601dd2
###################
fluid.unique_name
###################
.. _cn_api_fluid_unique_name_generate:
generate
-------------------------------
.. py:function:: paddle.fluid.unique_name.generate(key)
产生以前缀key开头的唯一名称。
参数:
- **key** (str) - 产生的名称前缀。所有产生的名称都以此前缀开头。
返回：含前缀key的唯一字符串。
返回类型：str
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
name1 = fluid.unique_name.generate('fc')
name2 = fluid.unique_name.generate('fc')
# 结果为fc_0, fc_1
print name1, name2
.. _cn_api_fluid_unique_name_guard:
guard
-------------------------------
.. py:function:: paddle.fluid.unique_name.guard(new_generator=None)
使用with语句更改全局命名空间。
参数:
- **new_generator** (None|str|bytes) - 全局命名空间的新名称。请注意，Python2中的str在Python3中被区分为为str和bytes两种，因此这里有两种类型。 默认值None。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
with fluid.unique_name.guard():
name_1 = fluid.unique_name.generate('fc')
with fluid.unique_name.guard():
name_2 = fluid.unique_name.generate('fc')
# 结果为fc_0, fc_0
print name_1, name_2
with fluid.unique_name.guard('A'):
name_1 = fluid.unique_name.generate('fc')
with fluid.unique_name.guard('B'):
name_2 = fluid.unique_name.generate('fc')
# 结果为Afc_0, Bfc_0
print name_1, name_2
.. _cn_api_fluid_unique_name_switch:
switch
-------------------------------
.. py:function:: paddle.fluid.unique_name.switch(new_generator=None)
将Global命名空间切换到新的命名空间。
参数:
- **new_generator** (None|UniqueNameGenerator) - 一个新的UniqueNameGenerator
返回：先前的UniqueNameGenerator
返回类型：UniqueNameGenerator
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
name1 = fluid.unique_name.generate('fc')
name2 = fluid.unique_name.generate('fc')
# 结果为fc_0, fc_1
print name1, name2
fluid.unique_name.switch()
name2 = fluid.unique_name.generate('fc')
# 结果为fc_0
print name2
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或