Skip to content

F
FluidDoc

PaddlePaddle / FluidDoc

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

modify alias display

上级 f8c89a84
展开全部 隐藏空白更改
内联 并排
Showing with 15690 addition and 1108 deletion
doc/paddle/api/api_label
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/gen_doc.py
浏览文件 @ 0ffc4e5a
......@@ -93,20 +93,9 @@ def is_filter_api(api):
if api in alias_api_map:
return False
#check api start with paddle.fluid
#if has no alias, return True
#if has alias also in paddle.fluid, return True
#if has alias in other module, return False
same_apis = same_api_map[id(eval(api))]
if api.startswith("paddle.fluid"):
all_fluid_flag = True
for x in same_apis:
if not x.startswith("paddle.fluid"):
all_fluid_flag = False
if all_fluid_flag:
return True
#api not in alias map
#if the api in alias_map key, others api is alias api
for x in same_apis:
if x in alias_api_map:
......@@ -127,14 +116,6 @@ def is_filter_api(api):
return False
def get_display_api(api):
# recomment alias api
if api.startswith("paddle.fluid") and api in alias_api_map:
return alias_api_map[api][0]
else:
return api
def gen_en_files(root_path='paddle', api_label_file="api_label"):
backup_path = root_path + "_" + str(int(time.time()))
api_f = open(api_label_file, 'w')
......@@ -142,11 +123,12 @@ def gen_en_files(root_path='paddle', api_label_file="api_label"):
for api in api_set:
if is_filter_api(api):
continue
module_name = ".".join(api.split(".")[0:-1])
doc_file = api.split(".")[-1]
raw_api = api
api = get_display_api(api)
if isinstance(eval(module_name + "." + doc_file), types.ModuleType):
continue
doc_file = api.split(".")[-1]
path = "/".join(api.split(".")[0:-1])
if not os.path.exists(path):
os.makedirs(path)
......@@ -156,7 +138,7 @@ def gen_en_files(root_path='paddle', api_label_file="api_label"):
os.mknod(f + en_suffix)
gen = EnDocGenerator()
with gen.guard(f + en_suffix):
gen.module_name = ".".join(raw_api.split(".")[0:-1])
gen.module_name = module_name
gen.api = doc_file
gen.print_header_reminder()
gen.print_item()
......
doc/paddle/api/paddle/fluid/DataFeedDesc_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_DataFeedDesc:
DataFeedDesc
-------------------------------
.. py:class:: paddle.fluid.DataFeedDesc(proto_file)
:api_attr: 声明式编程模式（静态图)
描述训练数据的格式。输入是一个文件路径名，其内容是protobuf message。
可以参考 :code:`paddle/fluid/framework/data_feed.proto` 查看我们如何定义message
一段典型的message可能是这样的：
.. code-block:: python
import paddle.fluid as fluid
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')
用户需要了解DataFeedDesc中每个字段的含义，以便自定义字段的值。例如:
.. code-block:: python
import paddle.fluid as fluid
data_feed = fluid.DataFeedDesc('data.proto')
data_feed.set_batch_size(128)
data_feed.set_dense_slots('words') # 名为'words'的slot将被设置为密集的
data_feed.set_use_slots('words') # 名为'words'的slot将被用于训练
# 最后，可以打印变量详细信息便于排查错误
print(data_feed.desc())
参数：
- **proto_file** (string) : 包含数据描述的protobuf message的磁盘文件
.. py:method:: set_batch_size(batch_size)
该接口用于设置DataFeedDesc中的 :code:`batch_size` 。可以在训练期间调用修改 :code:`batch_size` 。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
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)
参数：
- **batch_size** (int) - 新的批尺寸。
返回：无
.. py:method:: set_dense_slots(dense_slots_name)
将 :code:`dense_slots_name` 指定的slots设置为密集的slot。**注意：默认情况下，所有slots都是稀疏的。**
密集slot的特征将被输入一个Tensor，而稀疏slot的特征将被输入一个LoDTensor。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
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'])
参数：
- **dense_slots_name** (list(str)) - slot名称的列表，这些slot将被设置为密集的。
返回：无
.. py:method:: set_use_slots(use_slots_name)
设置一个特定的slot是否用于训练。一个数据集包含了很多特征，通过这个函数可以选择哪些特征将用于指定的模型。
参数：
- **use_slots_name** (list) : 将在训练中使用的slot名列表，类型为list，其中每个元素为一个字符串
**代码示例：**
.. code-block:: python
import paddle.fluid as fluid
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'])
.. note::
默认值是不使用所有slot
.. py:method:: desc()
返回此DataFeedDesc的protobuf message
返回：一个protobuf message字符串
**代码示例：**
.. code-block:: python
import paddle.fluid as fluid
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())
doc/paddle/api/paddle/fluid/DataFeeder_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_DataFeeder:
DataFeeder
-------------------------------
.. py:class:: paddle.fluid.DataFeeder(feed_list, place, program=None)
:api_attr: 声明式编程模式（静态图)
``DataFeeder`` 负责将reader(读取器)返回的数据转成一种特殊的数据结构，使它们可以输入到 ``Executor`` 和 ``ParallelExecutor`` 中。
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')
feeder = fluid.DataFeeder([img, label], fluid.CPUPlace())
result = feeder.feed([([0] * 784, [9]), ([1] * 784, [1])])
在多GPU模型训练时，如果需要提前分别向各GPU输入数据，可以使用 ``decorate_reader`` 函数。
.. 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(paddle.dataset.flowers.train(), batch_size=16), multi_devices=False)
参数：
- **feed_list** (list) – 向模型输入的变量表或者变量表名
- **place** (Place) – place表明是向GPU还是CPU中输入数据。如果想向GPU中输入数据, 请使用 ``fluid.CUDAPlace(i)`` (i 代表 the GPU id)；如果向CPU中输入数据, 请使用 ``fluid.CPUPlace()``
- **program** (Program) – 需要向其中输入数据的Program。如果为None, 会默认使用 ``default_main_program()``。 缺省值为None
抛出异常:
- ``ValueError`` – 如果一些变量不在此 Program 中
**代码示例**
.. code-block:: python
import numpy as np
import paddle
import paddle.fluid as fluid
place = fluid.CPUPlace()
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),
fetch_list=[out])
.. py:method:: feed(iterable)
根据feed_list（数据输入表）和iterable（可遍历的数据）提供的信息，将输入数据转成一种特殊的数据结构，使它们可以输入到 ``Executor`` 和 ``ParallelExecutor`` 中。
参数:
- **iterable** (list|tuple) – 要输入的数据
返回： 转换结果
返回类型: 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)
该方法获取的多个minibatch，并把每个minibatch提前输入进各个设备中。
参数:
- **iterable** (list|tuple) – 要输入的数据
- **num_places** (int) – 设备数目。默认为None。
返回: 转换结果
返回类型: dict
.. 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.random([1]).astype('float32')],
x = fluid.layers.data(name='x', shape=[1, 28, 28])
y = fluid.layers.data(name='y', shape=[1], dtype='float32')
fluid.layers.elementwise_add(x, y)
feeder = fluid.DataFeeder(['x','y'], fluid.CPUPlace())
place_num = 2
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）中。
参数：
- **reader** (fun) – 该参数是一个可以生成数据的函数
- **multi_devices** (bool) – bool型，指明是否使用多个设备
- **num_places** (int) – 如果 ``multi_devices`` 为 ``True`` , 可以使用此参数来设置GPU数目。如果 ``multi_devices`` 为 ``None`` ，该函数默认使用当前训练机所有GPU设备。默认为None。
- **drop_last** (bool) – 如果最后一个batch的大小比 ``batch_size`` 要小，则可使用该参数来指明是否选择丢弃最后一个batch数据。 默认为 ``True``
返回：转换结果
返回类型: dict
抛出异常： ``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.CPUPlace()
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/paddle/api/paddle/fluid/DistributeTranspilerConfig_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_DistributeTranspilerConfig:
DistributeTranspilerConfig
-------------------------------
.. py:class:: paddle.fluid.DistributeTranspilerConfig
.. py:attribute:: slice_var_up (bool)
为多个Pserver（parameter server）将tensor切片, 默认为True。
.. py:attribute:: split_method (PSDispatcher)
可使用 RoundRobin 或者 HashName。
注意: 尝试选择最佳方法来达到Pserver间负载均衡。
.. py:attribute:: min_block_size (int)
block中分割(split)出的元素个数的最小值。
注意: 根据：`issuecomment-369912156 <https://github.com/PaddlePaddle/Paddle/issues/8638#issuecomment-369912156>`_ , 当数据块大小超过2MB时，我们可以有效地使用带宽。如果你想更改它，请详细查看 ``slice_variable`` 函数。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
config = fluid.DistributeTranspilerConfig()
config.slice_var_up = True
doc/paddle/api/paddle/fluid/DistributeTranspiler_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_transpiler_DistributeTranspiler:
DistributeTranspiler
-------------------------------
.. py:class:: paddle.fluid.DistributeTranspiler (config=None)
该类可以把fluid program转变为分布式数据并行计算的program, 有PServer和NCCL2两种模式。
在Pserver（全称：parameter server）模式下， 通过 ``transpile`` 将用于单机训练的 ``program`` 转译为可用于parameter server的分布式架构(即PServer,参数服务器)来进行训练的program。
在NCCL2模式下, 通过 ``transpile`` 将用于单机训练的 ``program`` 转译为可用于NCCL2的分布式架构来进行训练的program。在NCCL2模式下，transpiler会在 ``startup_program`` 中附加一个 ``NCCL_ID`` 广播
算子（broadcasting operators）来实现在该集群中所有工作结点共享``NCCL_ID`` 。 调用 ``transpile_nccl2`` 后， 你 **必须** 将 ``trainer_id`` , ``num_trainers`` 参数提供给 ``Executor`` 来启动NCCL2分布式模式。
参数：
- **config** （DistributeTranspilerConfig） DistributeTranspiler属性配置实例，定义了program转变所需要的属性, 请参考：`DistributeTranspilerConfig` 相关文档。
返回：初始化后的DistributeTranspiler实例
返回类型：实例（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 = "PSERVER"
t = fluid.DistributeTranspiler()
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)
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=trainer_id, trainers=trainer_endpoints, current_endpoint="192.168.0.1:6174")
exe = fluid.ParallelExecutor(
use_cuda=True,
loss_name=avg_loss.name,
num_trainers=trainer_num,
trainer_id=trainer_id
)
.. 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')
通过此方法，可根据用户配置将单机的program转换为当前节点可用的数据并行的分布式program。
参数:
- **trainer_id** (int) – 当前Trainer worker的id, 如果有n个Trainer worker, id 取值范围为0 ~ n-1
- **program** (Program|None) – 待transpile（转译）的program, 缺省为 ``fluid.default_main_program()``
- **startup_program** (Program|None) - 要转译的 ``startup_program`` ,默认为 ``fluid.default_startup_program()``
- **pservers** (str) – 内容为Pserver列表的字符串，格式为：按逗号区分不同的Pserver，每个Pserver的格式为 *ip地址:端口号*
- **trainers** (int|str) – 在Pserver模式下，该参数指Trainer机的个数；在nccl2模式下，它是一个内容为Trainer终端列表的字符串
- **sync_mode** (bool) – 是否做同步训练(synchronous training), 默认为True
- **startup_program** (Program|None) – 待transpile（转译）的startup_program，默认为 ``fluid.default_main_program()``
- **current_endpoint** (str) – 当需要把program转译（transpile）至NCCL2模式下时，需要将当前endpoint（终端）传入该参数。PServer模型下，当用户需要使用增量训练时，必须要指定该参数。
返回：None
**代码示例**
.. 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)
该方法可以得到Trainer侧的program。
返回: Trainer侧的program
返回类型: 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)
该方法可以得到Pserver（参数服务器）侧的程序
参数:
- **endpoint** (str) – 当前Pserver终端
返回: 当前Pserver需要执行的program
返回类型: 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)
该方法可以得到Pserver侧用于分布式训练的 ``main_program`` 和 ``startup_program`` 。
参数:
- **endpoint** (str) – 当前Pserver终端
返回: (main_program, startup_program), “Program”类型的元组
返回类型: 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)
**该函数已停止使用**
获取当前Pserver的startup_program，如果有多个被分散到不同blocks的变量，则修改operator的输入变量。
参数:
- **endpoint** (str) – 当前Pserver终端
- **pserver_program** (Program) – 已停止使用。 先调用get_pserver_program
- **startup_program** (Program) – 已停止使用。应在初始化时传入startup_program
返回: Pserver侧的startup_program
返回类型: 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)
doc/paddle/api/paddle/fluid/LoDTensorArray_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_LoDTensorArray:
LoDTensorArray
-------------------------------
.. py:class:: paddle.fluid.LoDTensorArray
LoDTensorArray是由LoDTensor组成的数组，支持"[]"运算符、len()函数和for迭代等。
**示例代码**
.. 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后。
参数：
- **tensor** (LoDTensor) - 追加的LoDTensor。
返回：无。
**示例代码**
.. 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)
doc/paddle/api/paddle/fluid/LoDTensor_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_LoDTensor:
LoDTensor
-------------------------------
.. py:class:: paddle.fluid.LoDTensor
LoDTensor是一个具有LoD（Level of Details）信息的张量（Tensor），可用于表示变长序列，详见 :ref:`cn_user_guide_lod_tensor` 。
LoDTensor可以通过 ``np.array(lod_tensor)`` 方法转换为numpy.ndarray。
如果您不需要了解LoDTensor的细节，可以跳过以下的注解。
下面以两个例子说明如何用LoDTensor表示变长序列。
示例1：
假设x为一个表示变长序列的LoDTensor，它包含2个逻辑子序列，第一个序列长度是2（样本数量为2），第二个序列长度是3，总序列长度为5。
第一个序列的数据为[1, 2], [3, 4]，第二个序列的数据为[5, 6], [7, 8], [9, 10]，每个样本数据的维度均是2，该LoDTensor最终的shape为[5, 2]，其中5为总序列长度，2为每个样本数据的维度。
在逻辑上，我们可以用两种方式表示该变长序列，一种是递归序列长度的形式，即x.recursive_sequence_length = [[2, 3]]；另一种是偏移量的形式，即x.lod = [[0, 2, 2+3]]。
这两种表示方式是等价的，您可以通过LoDTensor的相应接口来设置和获取recursive_sequence_length或LoD。
在实现上，为了获得更快的序列访问速度，Paddle采用了偏移量的形式来存储不同的序列长度。因此，对recursive_sequence_length的操作最终将转换为对LoD的操作。
::
x.data = [[1, 2], [3, 4],
[5, 6], [7, 8], [9, 10]]
x.shape = [5, 2]
x.recursive_sequence_length = [[2, 3]]
x.lod = [[0, 2, 5]]
示例2：
LoD可以有多个level（例如，一个段落可以有多个句子，一个句子可以有多个单词）。假设y为LoDTensor ，lod_level为2。从level=0来看有2个逻辑序列，序列长度分别为2和1，表示第一个逻辑序列包含2个子序列，第二个逻辑序列包含1个子序列。从level=1来看，第一个逻辑序列包含的2个子序列长度分别为2和2，第二个逻辑序列包含的1个子序列长度为3。
因此，该LoDTensor以递归序列长度形式表示为 y.recursive_sequence_length = [[2, 1], [2, 2, 3]]；相应地，以偏移量形式表示为 y.lod = [[0, 2, 3], [0, 2, 4, 7]]。
::
y.data = [[1, 2], [3, 4],
[5, 6], [7, 8],
[9, 10], [11, 12], [13, 14]]
y.shape = [2+2+3, 2]
y.recursive_sequence_length = [[2, 1], [2, 2, 3]]
y.lod = [[0, 2, 3], [0, 2, 4, 7]]
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
t = fluid.LoDTensor()
.. py:method:: has_valid_recursive_sequence_lengths(self: paddle.fluid.core_avx.LoDTensor) → bool
该接口检查LoDTensor的LoD的正确性。
返回： 是否带有正确的LoD。
返回类型： bool。
**示例代码**
.. 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]]
该接口返回LoDTensor的LoD。
返回：LoDTensor的LoD。
返回类型：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_avx.LoDTensor) → List[List[int]]
该接口返回与LoDTensor的LoD对应的递归序列长度。
返回：LoDTensor的LoD对应的递归序列长度。
返回类型：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)
该接口根据输入的numpy array和设备place，设置LoDTensor的数据。
重载函数：
1. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[float32], place: paddle::platform::CPUPlace) -> None
2. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[int32], place: paddle::platform::CPUPlace) -> None
3. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[float64], place: paddle::platform::CPUPlace) -> None
4. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[int64], place: paddle::platform::CPUPlace) -> None
5. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[bool], place: paddle::platform::CPUPlace) -> None
6. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[uint16], place: paddle::platform::CPUPlace) -> None
7. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[uint8], place: paddle::platform::CPUPlace) -> None
8. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[int8], place: paddle::platform::CPUPlace) -> None
9. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[float32], place: paddle::platform::CUDAPlace) -> None
10. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[int32], place: paddle::platform::CUDAPlace) -> None
11. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[float64], place: paddle::platform::CUDAPlace) -> None
12. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[int64], place: paddle::platform::CUDAPlace) -> None
13. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[bool], place: paddle::platform::CUDAPlace) -> None
14. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[uint16], place: paddle::platform::CUDAPlace) -> None
15. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[uint8], place: paddle::platform::CUDAPlace) -> None
16. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[int8], place: paddle::platform::CUDAPlace) -> None
17. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[float32], place: paddle::platform::CUDAPinnedPlace) -> None
18. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[int32], place: paddle::platform::CUDAPinnedPlace) -> None
19. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[float64], place: paddle::platform::CUDAPinnedPlace) -> None
20. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[int64], place: paddle::platform::CUDAPinnedPlace) -> None
21. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[bool], place: paddle::platform::CUDAPinnedPlace) -> None
22. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[uint16], place: paddle::platform::CUDAPinnedPlace) -> None
23. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[uint8], place: paddle::platform::CUDAPinnedPlace) -> None
24. set(self: paddle.fluid.core_avx.Tensor, array: numpy.ndarray[int8], place: paddle::platform::CUDAPinnedPlace) -> None
参数：
- **array** (numpy.ndarray) - 要设置的numpy array，支持的数据类型为bool, float32, float64, int8, int32, int64, uint8, uint16。
- **place** (CPUPlace|CUDAPlace|CUDAPinnedPlace) - 要设置的LoDTensor所在的设备。
返回：无。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
t = fluid.LoDTensor()
t.set(np.ndarray([5, 30]), fluid.CPUPlace())
.. 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]])
print(t.lod()) # [[0, 2, 5]]
.. py:method:: set_recursive_sequence_lengths(self: paddle.fluid.core_avx.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** (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_length()) # [[2, 3]]
print(t.lod()) # [[0, 2, 5]]
.. py:method:: shape(self: paddle.fluid.core_avx.Tensor) → List[int]
该接口返回LoDTensor的shape。
返回：LoDTensor的shape。
返回类型：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())
print(t.shape()) # [5, 30]
doc/paddle/api/paddle/fluid/Tensor_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_Tensor:
Tensor
-------------------------------
.. py:function:: paddle.fluid.Tensor
Tensor用于表示多维张量，可以通过 ``np.array(tensor)`` 方法转换为numpy.ndarray。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
t = fluid.Tensor()
.. py:method:: set(array, place, zero_copy=False)
该接口根据输入的numpy array和设备place，设置Tensor的数据。
参数：
- **array** (numpy.ndarray) - 要设置的numpy array，支持的数据类型为bool, float32, float64, int8, int32, int64, uint8, uint16。
- **place** (CPUPlace|CUDAPlace|CUDAPinnedPlace) - 要设置的Tensor所在的设备。
- **zero_copy** (bool，可选) - 是否与输入的numpy数组共享内存。此参数仅适用于CPUPlace。默认值为False。
返回：无。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
t = fluid.Tensor()
t.set(np.ndarray([5, 30]), fluid.CPUPlace())
.. py:method:: shape(self: paddle.fluid.core_avx.Tensor) → List[int]
该接口返回Tensor的shape。
返回：Tensor的shape。
返回类型：List[int] 。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
t = fluid.Tensor()
t.set(np.ndarray([5, 30]), fluid.CPUPlace())
print(t.shape()) # [5, 30]
\ No newline at end of file
doc/paddle/api/paddle/fluid/clip/ErrorClipByValue_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_clip_ErrorClipByValue:
ErrorClipByValue
-------------------------------
.. py:class:: paddle.fluid.clip.ErrorClipByValue(max, min=None)
给定一个 Tensor ``t`` （该 Tensor 传入方式见代码示例），对 Tensor 中的元素超出给定最大 ``max`` 和最小界 ``min`` 内区间范围 [min, max] 的元素，重设为所超出界的界值。
- 任何小于min（最小值）的值都被设置为 ``min``
- 任何大于max（最大值）的值都被设置为 ``max``
参数:
- **max** (foat) - 要修剪的最大值。
- **min** (float) - 要修剪的最小值。如果用户没有设置，将被框架默认设置为 ``-max`` 。
**代码示例**
.. code-block:: python
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))
doc/paddle/api/paddle/fluid/clip/set_gradient_clip_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_clip_set_gradient_clip:
set_gradient_clip
-------------------------------
.. py:function:: paddle.fluid.clip.set_gradient_clip(clip, param_list=None, program=None)
:api_attr: 声明式编程模式（静态图)
.. warning::
此API对位置使用的要求较高，其必须位于组建网络之后， ``minimize`` 之前，因此在未来版本中可能被删除，故不推荐使用。推荐在 ``optimizer`` 初始化时设置梯度裁剪。
有三种裁剪策略： :ref:`cn_api_fluid_clip_GradientClipByGlobalNorm` 、 :ref:`cn_api_fluid_clip_GradientClipByNorm` 、 :ref:`cn_api_fluid_clip_GradientClipByValue` 。
如果在 ``optimizer`` 中设置过梯度裁剪，又使用了 ``set_gradient_clip`` ，``set_gradient_clip`` 将不会生效。
给指定参数做梯度裁剪。
参数:
- **clip** (GradientClipBase) - 梯度裁剪的策略，如 :ref:`cn_api_fluid_clip_GradientClipByGlobalNorm` 等，用于描述具体的裁剪方法和属性。
- **param_list** (list(Variable)，可选) - 需要裁剪的参数列表，可以是参数或参数名称列表。默认值为None，表示裁剪 ``program`` 中的所有参数。
- **program** (Program，可选) - 参数所在的Program。默认值为None，表示使用 :ref:`cn_api_fluid_default_main_program` 。
返回: 无。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
def network():
image = fluid.layers.data(name='image', shape=[28], dtype='float32')
param_attr1 = fluid.ParamAttr("fc1_param")
fc1 = fluid.layers.fc(image, size=10, param_attr=param_attr1)
param_attr2 = fluid.ParamAttr("fc2_param")
fc2 = fluid.layers.fc(fc1, size=10, param_attr=param_attr2)
loss = fluid.layers.reduce_mean(fc2)
return loss
# network 1: clip all parameter gradient
with fluid.program_guard(fluid.Program(), fluid.Program()):
loss = network()
fluid.clip.set_gradient_clip(
fluid.clip.GradientClipByGlobalNorm(clip_norm=2.0))
sgd = fluid.optimizer.SGD(learning_rate=1e-3)
sgd.minimize(loss)
# network 2: clip parameter gradient by name
with fluid.program_guard(fluid.Program(), fluid.Program()):
loss = network()
fluid.clip.set_gradient_clip(
fluid.clip.GradientClipByValue(min=-1.0, max=1.0),
param_list=["fc1_param", "fc2_param"])
sgd = fluid.optimizer.SGD(learning_rate=1e-3)
sgd.minimize(loss)
# network 3: clip parameter gradient by var
with fluid.program_guard(fluid.Program(), fluid.Program()):
loss = network()
param_var1 = fluid.default_main_program().global_block().var("fc1_param")
param_var2 = fluid.default_main_program().global_block().var("fc2_param")
fluid.clip.set_gradient_clip(
fluid.clip.GradientClipByValue(min=-1.0, max=1.0),
param_list=[param_var1, param_var2])
sgd = fluid.optimizer.SGD(learning_rate=1e-3)
sgd.minimize(loss)
# network 4: use set_gradient_clip and minimize(grad_clip=clip) together
with fluid.program_guard(fluid.Program(), fluid.Program()):
loss = network()
param_var1 = fluid.default_main_program().global_block().var("fc1_param")
param_var2 = fluid.default_main_program().global_block().var("fc2_param")
clip1 = fluid.clip.GradientClipByValue(min=-1.0, max=1.0)
clip2 = fluid.clip.GradientClipByNorm(clip_norm=1.0)
# 设置梯度裁剪策略：clip1
fluid.clip.set_gradient_clip(clip1)
# 设置梯度裁剪策略：clip2
sgd = fluid.optimizer.SGD(learning_rate=1e-3, grad_clip=clip2)
sgd.minimize(loss)
# 有设置冲突时，set_gradient_clip将不会生效，将以clip2的策略进行梯度裁剪
doc/paddle/api/paddle/fluid/contrib/BeamSearchDecoder_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_layers_BeamSearchDecoder:
BeamSearchDecoder
-------------------------------
.. py:class:: paddle.fluid.layers.BeamSearchDecoder(cell, start_token, end_token, beam_size, embedding_fn=None, output_fn=None)
:api_attr: 声明式编程模式（静态图)
带beam search解码策略的解码器。该接口包装一个cell来计算概率，然后执行一个beam search步骤计算得分，并为每个解码步骤选择候选输出。更多详细信息请参阅 `Beam search <https://en.wikipedia.org/wiki/Beam_search>`_
**注意** 在使用beam search解码时，cell的输入和状态将被扩展到 :math:`beam\_size` ，得到 :math:`[batch\_size * beam\_size, ...]` 一样的形状，这个操作在BeamSearchDecoder中自动完成，因此，其他任何在 :code:`cell.call` 中使用的tensor，如果形状为 :math:`[batch\_size, ...]` ，都必须先手动使用 :code:`BeamSearchDecoder.tile_beam_merge_with_batch` 接口扩展。最常见的情况是带注意机制的编码器输出。
参数：
- **cell** (RNNCell) - RNNCell的实例或者具有相同接口定义的对象。
- **start_token** (int) - 起始标记id。
- **end_token** (int) - 结束标记id。
- **beam_size** (int) - 在beam search中使用的beam宽度。
- **embedding_fn** (可选) - 处理选中的候选id的接口。通常，它是一个将词id转换为词嵌入的嵌入层，函数的返回值作为 :code:`cell.call` 接口的 :code:`input` 参数。如果 :code:`embedding_fn` 未提供，则必须在 :code:`cell.call` 中实现词嵌入转换。默认值None。
- **output_fn** (可选) - 处理cell输出的接口，在计算得分和选择候选标记id之前使用。默认值None。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
from paddle.fluid.layers import GRUCell, BeamSearchDecoder
trg_embeder = lambda x: fluid.embedding(
x, size=[10000, 128], param_attr=fluid.ParamAttr(name="trg_embedding"))
output_layer = lambda x: layers.fc(x,
size=10000,
num_flatten_dims=len(x.shape) - 1,
param_attr=fluid.ParamAttr(name=
"output_w"),
bias_attr=False)
decoder_cell = GRUCell(hidden_size=128)
decoder = BeamSearchDecoder(decoder_cell,
start_token=0,
end_token=1,
beam_size=4,
embedding_fn=trg_embeder,
output_fn=output_layer)
.. py:method:: tile_beam_merge_with_batch(x, beam_size)
扩展tensor的batch维度。此函数的输入是形状为 :math:`[batch\_size, s_0, s_1, ...]` 的tensor t，由minibatch中的样本 :math:`t[0], ..., t[batch\_size - 1]` 组成。将其扩展为形状是 :math:`[batch\_size * beam\_size, s_0, s_1, ...]` 的tensor，由 :math:`t[0], t[0], ..., t[1], t[1], ...` 组成, 每个minibatch中的样本重复 :math:`beam\_size` 次。
参数：
- **x** (Variable) - 形状为 :math:`[batch\_size, ...]` 的tenosr。数据类型应为float32，float64，int32，int64或bool。
- **beam_size** (int) - 在beam search中使用的beam宽度。
返回：形状为 :math:`[batch\_size * beam\_size, ...]` 的tensor，其数据类型与 :code:`x` 相同。
返回类型：Variable
.. py:method:: _split_batch_beams(x)
将形状为 :math:`[batch\_size * beam\_size, ...]` 的tensor变换为形状为 :math:`[batch\_size, beam\_size, ...]` 的新tensor。
参数：
- **x** (Variable) - 形状为 :math:`[batch\_size * beam\_size, ...]` 的tenosr。数据类型应为float32，float64，int32，int64或bool。
返回：形状为 :math:`[batch\_size, beam\_size, ...]` 的tensor，其数据类型与 :code:`x` 相同。
返回类型：Variable
.. py:method:: _merge_batch_beams(x)
将形状为 :math:`[batch\_size, beam\_size, ...]` 的tensor变换为形状为 :math:`[batch\_size * beam\_size,...]` 的新tensor。
参数：
- **x** (Variable) - 形状为 :math:`[batch\_size, beam_size,...]` 的tenosr。数据类型应为float32，float64，int32，int64或bool。
返回：形状为 :math:`[batch\_size * beam\_size, ...]` 的tensor，其数据类型与 :code:`x` 相同。
返回类型：Variable
.. py:method:: _expand_to_beam_size(x)
此函数输入形状为 :math:`[batch\_size,s_0，s_1，...]` 的tensor t，由minibatch中的样本 :math:`t[0]，...，t[batch\_size-1]` 组成。将其扩展为形状 :math:`[ batch\_size,beam\_size,s_0，s_1，...]` 的tensor，由 :math:`t[0]，t[0]，...，t[1]，t[1]，...` 组成，其中每个minibatch中的样本重复 :math:`beam\_size` 次。
参数：
- **x** (Variable) - 形状为 :math:`[batch\_size, ...]` 的tenosr。数据类型应为float32，float64，int32，int64或bool。
返回：具有与 :code:`x` 相同的形状和数据类型的tensor，其中未完成的beam保持不变，而已完成的beam被替换成特殊的tensor(tensor中所有概率质量被分配给EOS标记)。
返回类型：Variable
.. py:method:: _mask_probs(probs, finished)
屏蔽对数概率。该函数使已完成的beam将所有概率质量分配给EOS标记，而未完成的beam保持不变。
参数：
- **probs** (Variable) - 形状为 :math:`[batch\_size,beam\_size,vocab\_size]` 的tensor，表示对数概率。其数据类型应为float32。
- **finish** (Variable) - 形状为 :math:`[batch\_size,beam\_size]` 的tensor，表示所有beam的完成状态。其数据类型应为bool。
返回：具有与 :code:`x` 相同的形状和数据类型的tensor，其中未完成的beam保持不变，而已完成的beam被替换成特殊的tensor(tensor中所有概率质量被分配给EOS标记)。
返回类型：Variable
.. py:method:: _gather(x, indices, batch_size)
对tensor :code:`x` 根据索引 :code:`indices` 收集。
参数：
- **x** (Variable) - 形状为 :math:`[batch\_size, beam\_size,...]` 的tensor。
- **index** (Variable) - 一个形状为 :math:`[batch\_size, beam\_size]` 的int64 tensor，表示我们用来收集的索引。
- **batch_size** (Variable) - 形状为 :math:`[1]` 的tensor。其数据类型应为int32或int64。
返回：具有与 :code:``x` 相同的形状和数据类型的tensor，表示收集后的tensor。
返回类型：Variable
.. py:method:: initialize(initial_cell_states)
初始化BeamSearchDecoder。
参数：
- **initial_cell_states** (Variable) - 单个tensor变量或tensor变量组成的嵌套结构。调用者提供的参数。
返回：一个元组 :code:`(initial_inputs, initial_states, finished)`。:code:`initial_inputs` 是一个tensor，当 :code:`embedding_fn` 为None时，由 :code:`start_token` 填充，形状为 :math:`[batch\_size,beam\_size,1]` ；否则使用 :code:`embedding_fn(t)` 返回的值。:code:`initial_states` 是tensor变量的嵌套结构(命名元组，字段包括 :code:`cell_states，log_probs，finished，lengths`)，其中 :code:`log_probs，finished，lengths` 都含有一个tensor，形状为 :math:`[batch\_size, beam\_size]`，数据类型为float32，bool，int64。:code:`cell_states` 具有与输入参数 :code:`initial_cell_states` 相同结构的值，但形状扩展为 :math:`[batch\_size,beam\_size,...]`。 :code:`finished` 是一个布尔型tensor，由False填充，形状为 :math:`[batch\_size,beam\_size]`。
返回类型：tuple
.. py:method:: _beam_search_step(time, logits, next_cell_states, beam_state)
计算得分并选择候选id。
参数：
- **time** (Variable) - 调用者提供的形状为[1]的tensor，表示当前解码的时间步长。其数据类型为int64。
- **logits** (Variable) - 形状为 :math:`[batch\_size,beam\_size,vocab\_size]` 的tensor，表示当前时间步的logits。其数据类型为float32。
- **next_cell_states** (Variable) - 单个tensor变量或tensor变量组成的嵌套结构。它的结构，形状和数据类型与 :code:`initialize()` 的返回值 :code:`initial_states` 中的 :code:`cell_states` 相同。它代表该cell的下一个状态。
- **beam_state** (Variable) - tensor变量的结构。在第一个解码步骤与 :code:`initialize()` 返回的 :code:`initial_states` 同，其他步骤与 :code:`initialize()` 返回的 :code:`beam_search_state` 相同。
返回：一个元组 :code:`(beam_search_output, beam_search_state)`。:code:`beam_search_output` 是tensor变量的命名元组，字段为 :code:`scores，predicted_ids parent_ids`。其中 :code:`scores，predicted_ids，parent_ids` 都含有一个tensor，形状为 :math:`[batch\_size,beam\_size]`，数据类型为float32 ，int64，int64。:code:`beam_search_state` 具有与输入参数 :code:`beam_state` 相同的结构，形状和数据类型。
返回类型：tuple
.. py:method:: step(time, inputs, states, **kwargs)
执行beam search解码步骤，该步骤使用 :code:`cell` 来计算概率，然后执行beam search步骤以计算得分并选择候选标记ID。
参数：
- **time** (Variable) - 调用者提供的形状为[1]的int64tensor，表示当前解码的时间步长。
- **inputs** (Variable) - tensor变量。在第一个解码时间步时与由 :code:`initialize()` 返回的 :code:`initial_inputs` 相同，其他时间步与由 :code:`step()` 返回的 :code:`next_inputs` 相同。
- **States** (Variable) - tensor变量的结构。在第一个解码时间步时与 :code:`initialize()` 返回的 :code:`initial_states` 相同，其他时间步与由 :code:`step()` 返回的 :code:`beam_search_state` 相同。
- **kwargs** - 附加的关键字参数，由调用者提供。
返回：一个元组 :code:`(beam_search_output，beam_search_state，next_inputs，finish)` 。:code:`beam_search_state` 和参数 :code:`states` 具有相同的结构，形状和数据类型。 :code:`next_inputs` 与输入参数 :code:`inputs` 具有相同的结构，形状和数据类型。 :code:`beam_search_output` 是tensor变量的命名元组(字段包括 :code:`scores，predicted_ids，parent_ids` )，其中 :code:`scores，predicted_ids，parent_ids` 都含有一个tensor，形状为 :math:`[batch\_size,beam\_size]`，数据类型为float32 ，int64，int64。:code:`finished` 是一个bool类型的tensor，形状为 :math:`[batch\_size,beam\_size]`。
返回类型：tuple
.. py:method:: finalize(outputs, final_states, sequence_lengths)
使用 :code:`gather_tree` 沿beam search树回溯并构建完整的预测序列。
参数：
- **outputs** (Variable) - tensor变量组成的结构(命名元组)，该结构和数据类型与 :code:`output_dtype` 相同。tensor将所有时间步的输出堆叠，因此具有形状 :math:`[time\_step，batch\_size,...]`。
- **final_states** (Variable) - tensor变量组成的结构(命名元组)。它是 :code:`decoder.step` 在最后一个解码步骤返回的 :code:`next_states`，因此具有与任何时间步的 :code:`state` 相同的结构、形状和数据类型。
- **sequence_lengths** (Variable) - tensor，形状为 :math:`[batch\_size,beam\_size]`，数据类型为int64。它包含解码期间确定的每个beam的序列长度。
返回：一个元组 :code:`(predicted_ids, final_states)`。:code:`predicted_ids` 是一个tensor，形状为 :math:`[time\_step，batch\_size,beam\_size]`，数据类型为int64。:code:`final_states` 与输入参数 :code:`final_states` 相同。
返回类型：tuple
.. py:method:: output_dtype()
用于beam search输出的数据类型的嵌套结构。它是一个命名元组，字段包括 :code:`scores, predicted_ids, parent_ids`。
参数：无。
返回：用于beam search输出的数据类型的命名元组。
doc/paddle/api/paddle/fluid/cpu_places_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_cpu_places:
cpu_places
-------------------------------
.. py:function:: paddle.fluid.cpu_places(device_count=None)
该接口创建 ``device_count`` 个 ``fluid.CPUPlace`` 对象，并返回所创建的对象列表。
如果 ``device_count`` 为 ``None``，则设备数目将由环境变量 ``CPU_NUM`` 确定。如果未设置 ``CPU_NUM`` 环境变量，则设备数目会默认设为1，也就是说， ``CPU_NUM=1``。
``CPU_NUM`` 表示在当前任务中使用的设备数目。如果 ``CPU_NUM`` 与物理核心数相同，可以加速程序的运行。
参数：
- **device_count** (int，可选) - 设备数目。默认值为 ``None``。
返回: ``CPUPlace`` 的列表。
返回类型：list[fluid.CPUPlace]
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
cpu_places = fluid.cpu_places()
doc/paddle/api/paddle/fluid/create_lod_tensor_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_create_lod_tensor:
create_lod_tensor
-------------------------------
.. py:function:: paddle.fluid.create_lod_tensor(data, recursive_seq_lens, place)
从一个numpy数组、list或LoDTensor创建一个新的LoDTensor。
具体实现方法如下:
1. 检查基于序列长度的LoD（length-based LoD），即参数中的 :code:`recursive_seq_lens` 是否正确。
2. 将 :code:`recursive_seq_lens` 转换为基于偏移量的LoD（offset-based LoD）。
3. 根据place参数，把所提供的 :code:`data` （numpy数组、list或LoDTensor）的数据复制到CPU或GPU上。
4. 将基于偏移量的LoD设置到输出的LoDTensor中。
假设我们想创建一个LoDTensor表示词的序列，其中每个词用一个整数id表示。若待创建的LoDTensor表示2个句子，其中一个句子包含2个单词，另一个句子包含3个单词。
那么， :code:`data` 为一个维度为(5, 1)的numpy整数数组； :code:`recursive_seq_lens` 为[[2, 3]]，表示每个句子含的单词个数。在该接口内部，基于序列长度的
:code:`recursive_seq_lens` [[2, 3]]会转换为为基于偏移量的LoD [[0, 2, 5]]。
请查阅 :ref:`cn_user_guide_lod_tensor` 了解更多关于LoD的介绍。
参数:
- **data** (numpy.ndarray|list|LoDTensor) - 表示LoDTensor数据的numpy数组、list或LoDTensor。
- **recursive_seq_lens** (list[list[int]]) - 基于序列长度的LoD信息。
- **place** (CPUPlace|CUDAPlace) - 表示返回的LoDTensor存储在CPU或GPU place中。
返回: 包含数据信息和序列长度信息的LoDTensor。
返回类型: LoDTensor
**代码示例**
.. 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())
doc/paddle/api/paddle/fluid/create_random_int_lodtensor_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_create_random_int_lodtensor:
create_random_int_lodtensor
-------------------------------
.. py:function:: paddle.fluid.create_random_int_lodtensor(recursive_seq_lens, base_shape, place, low, high)
:api_attr: 声明式编程模式（静态图)
创建一个包含随机整数的LoDTensor。
具体实现方法如下：
1. 基于序列长度 :code:`recursive_seq_lens` 和 :code:`base_shape` 产生返回值的维度。返回值的第一维等于序列总长度，其余维度为 :code:`base_shape` 。
2. 创建一个包含随机整数的numpy数组，并作为 :code:`data` 参数传入 :ref:`cn_api_fluid_create_lod_tensor` 接口中创建LoDTensor返回。
假设我们想创建一个LoDTensor表示序列信息，共包含2个序列，维度分别为[2, 30]和[3, 30]，那么序列长度 :code:`recursive_seq_lens` 传入[[2, 3]]，:code:`base_shape` 传入[30]（即除了序列长度以外的维度）。
最后返回的LoDTensor的维度为[5, 30]，其中第一维5为序列总长度，其余维度为 :code:`base_shape` 。
参数:
- **recursive_seq_lens** (list[list[int]]) - 基于序列长度的LoD信息。
- **base_shape** (list[int]) - 除第一维以外输出结果的维度信息。
- **place** (CPUPlace|CUDAPlace) - 表示返回的LoDTensor存储在CPU或GPU place中。
- **low** (int) - 随机整数的下限值。
- **high** (int) - 随机整数的上限值，必须大于或等于low。
返回: 包含随机整数数据信息和序列长度信息的LoDTensor，数值范围在[low, high]之间。
返回类型: LoDTensor
**代码示例**
.. 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)
print(t.shape()) # [5, 30]
doc/paddle/api/paddle/fluid/cuda_pinned_places_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_cuda_pinned_places:
cuda_pinned_places
-------------------------------
.. py:function:: paddle.fluid.cuda_pinned_places(device_count=None)
该接口创建 ``device_count`` 个 ``fluid.CUDAPinnedPlace`` ( fluid. :ref:`cn_api_fluid_CUDAPinnedPlace` ) 对象，并返回所创建的对象列表。
如果 ``device_count`` 为 ``None``，实际设备数目将由当前任务中使用的GPU设备数决定。用户可通过以下2种方式设置任务可用的GPU设备：
- 设置环境变量 ``FLAGS_selected_gpus`` ，例如 ``export FLAGS_selected_gpus='0,1'``。
- 设置环境变量 ``CUDA_VISIBLE_DEVICES`` ，例如 ``export CUDA_VISIBLE_DEVICES='0,1'``。
关于如何设置任务中使用的GPU设备，具体请查看 fluid. :ref:`cn_api_fluid_cuda_places` 。
参数：
- **device_count** (int，可选) - 设备数目。默认值为 ``None``。
返回: ``fluid.CUDAPinnedPlace`` 对象列表。
返回类型：list[fluid.CUDAPinnedPlace]
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
# 1）不设置任何环境变量，默认使用所有的GPU，8卡的机器则将创建8个CUDAPinnedPlace
# 2）export FLAGS_selected_gpus='0,1'，则创建2个CUDAPinnedPlace
cuda_pinned_places = fluid.cuda_pinned_places()
# 3）创建1个CUDAPinnedPlace
cuda_pinned_places = fluid.cuda_pinned_places(1)
doc/paddle/api/paddle/fluid/cuda_places_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_cuda_places:
cuda_places
-------------------------------
.. py:function:: paddle.fluid.cuda_places(device_ids=None)
.. note::
多卡任务请先使用 FLAGS_selected_gpus 环境变量设置可见的GPU设备，下个版本将会修正 CUDA_VISIBLE_DEVICES 环境变量无效的问题。
该接口根据 ``device_ids`` 创建一个或多个 ``fluid.CUDAPlace`` 对象，并返回所创建的对象列表。
如果 ``device_ids`` 为 ``None``，则首先检查 ``FLAGS_selected_gpus`` 标志。
例如： ``FLAGS_selected_gpus=0,1,2`` ，则返回的列表将为 ``[fluid.CUDAPlace(0), fluid.CUDAPlace(1), fluid.CUDAPlace(2)]``。
如果未设置标志 ``FLAGS_selected_gpus`` ，则根据 ``CUDA_VISIBLE_DEVICES`` 环境变量，返回所有可见的 GPU places。
如果 ``device_ids`` 不是 ``None``，它应该是使用的GPU设备ID的列表或元组。
例如： ``device_id=[0,1,2]`` ，返回的列表将是 ``[fluid.CUDAPlace(0), fluid.CUDAPlace(1), fluid.CUDAPlace(2)]``。
参数：
- **device_ids** (list(int)|tuple(int)，可选) - GPU的设备ID列表或元组。默认值为 ``None``。
返回: 创建的 ``fluid.CUDAPlace`` 列表。
返回类型：list[fluid.CUDAPlace]
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
cuda_places = fluid.cuda_places()
doc/paddle/api/paddle/fluid/dataset/DatasetFactory_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_dataset_DatasetFactory:
DatasetFactory
-------------------------------
.. py:class:: paddle.fluid.dataset.DatasetFactory
DatasetFactory是一个按数据集名称创建数据集的 "工厂"，可以创建“QueueDataset”，“InMemoryDataset”或“FileInstantDataset”，默认为“QueueDataset”。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
.. py:method:: create_dataset(datafeed_class='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()
doc/paddle/api/paddle/fluid/dataset/InMemoryDataset_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _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:: set_queue_num(queue_num)
设置 ``Dataset`` 输出队列数量，训练进程会从队列中获取数据。
参数：
- **queue_num** (int) - dataset输出队列数量
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
dataset.set_queue_num(12)
.. py:method:: set_fleet_send_batch_size(fleet_send_batch_size)
设置发送batch的大小
参数:
- **fleet_send_batch_size** (int) - 设置发送batch的大小。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
dataset.set_fleet_send_batch_size(800)
.. py:method:: set_merge_by_lineid(var_list, erase_duplicate_feas=True, min_merge_size=2, keep_unmerged-ins=True)
通过样本id来设置合并，一些线id的实例将会在shuffle之后进行合并，你应该在一个data生成器里面解析样本id。
参数:
- **var_list** (list) - 可以被合并的特征列表，其中的每一个元素都是一个 ``Variable`` 。一些类特征我们通常不把它们合并为同样的样本id，所以用户应当指定哪个类特征可以被合并。
- **erase_duplicate_feas** (bool) - 合并的时候是否删除重复的特征值。默认为True。
- **min_merge_size** (int) - 合并的最小数量。默认为2。
- **keep_unmerged_ins** (bool) - 是否保留没有合并的样本，比如有着独特id的样本，或者重复id的数量小于 ``min_merge_size`` 的样本。
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset("InMemoryDataset")
dataset.set_merge_by_lineid()
.. 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:: preload_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.preload_into_memory()
dataset.wait_preload_done()
.. py:method:: wait_preload_done()
等待 ``preload_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.preload_into_memory()
dataset.wait_preload_done()
.. 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()
.. py:method:: get_memory_data_size(fleet=None)
用户可以调用此函数以了解加载进内存后所有workers中的样本数量。
.. 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中的样本数量。
.. 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)
.. py:method:: set_batch_size(batch_size)
设置batch size。在训练期间生效。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
dataset.set_batch_size(128)
参数：
- **batch_size** (int) - batch size
.. py:method:: set_fea_eval(record_candidate_size, fea_eval=True)
设置特征打乱特征验证模式，来修正特征level的重要性， 特征打乱需要 ``fea_eval`` 被设置为True。
参数：
- **record_candidate_size** (int) - 打乱一个特征的候选实例大小
- **fea_eval** (bool) - 是否设置特征验证模式来打乱特征，默认为True。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset(“InMemoryDataset”)
dataset.set_fea_eval(1000000, True)
.. py:method:: desc()
为 ``DataFeedDesc`` 返回一个缓存信息。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
print(dataset.desc())
返回：一个字符串信息
.. py:method:: set_filelist(filelist)
在当前的worker中设置文件列表。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
dataset.set_filelist(["a.txt", "b.txt"])
参数：
- **filelist** (list) - 文件列表
.. py:method:: set_hdfs_config(fs_name, fs_ugi)
设置hdfs配置：fs名称与ugi。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
dataset.set_hdfs_config("my_fs_name", "my_fs_ugi")
参数：
- **fs_name** (str) - fs名称
- **fs_ugi** (str) - fs ugi
.. py:method:: set_pipe_command(pipe_coommand)
在当前的 ``dataset`` 中设置pipe命令。pipe命令只能使用UNIX的pipe命令
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
dataset.set_pipe_command("python my_script.py")
参数：
- **pipe_command** (str) - pipe命令
.. py:method:: set_thread(thread_num)
设置进程数量，等于readers的数量。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
dataset.set_thread(12)
参数：
- **thread_num** (int) - 进程数量
.. py:method:: set_use_var(var_list)
设置将要使用的 ``Variable`` 。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
dataset.set_use_var([data, label])
参数：
- **var_list** (list) - variable 列表
.. py:method:: slots_shuffle(slots)
该方法是在特征层次上的一个打乱方法，经常被用在有着较大缩放率实例的稀疏矩阵上，为了比较metric，比如auc，在一个或者多个有着baseline的特征上做特征打乱来验证特征level的重要性。
参数：
- **slots** (list[string]) - 要打乱特征的集合
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset(“InMemoryDataset”)
dataset.set_merge_by_lineid()
#支持slot 0
dataset.slots_shuffle([‘0’])
doc/paddle/api/paddle/fluid/dataset/QueueDataset_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _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)
.. py:method:: desc()
为 ``DataFeedDesc`` 返回一个缓存信息。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
print(dataset.desc())
返回：一个字符串信息
.. py:method:: set_batch_size(batch_size)
设置batch size。在训练期间生效。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
dataset.set_batch_size(128)
参数：
- **batch_size** (int) - batch size
.. py:method:: set_fea_eval(record_candidate_size,fea_eval)
参数：
- **record_candidate_size** (int) - 打乱一个特征的候选实例大小
- **fea_eval** (bool) - 是否设置特征验证模式来打乱特征，默认为True。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset(“InMemoryDataset”)
dataset.set_fea_eval(1000000, True)
.. py:method:: set_filelist(filelist)
在当前的worker中设置文件列表。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
dataset.set_filelist(["a.txt", "b.txt"])
参数：
- **filelist** (list) - 文件列表
.. py:method:: set_hdfs_config(fs_name, fs_ugi)
设置hdfs配置：fs名称与ugi。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
dataset.set_hdfs_config("my_fs_name", "my_fs_ugi")
参数：
- **fs_name** (str) - fs名称
- **fs_ugi** (str) - fs ugi
.. py:method:: set_pipe_command(pipe_coommand)
在当前的 ``dataset`` 中设置pipe命令。pipe命令只能使用UNIX的pipe命令
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
dataset.set_pipe_command("python my_script.py")
参数：
- **pipe_command** (str) - pipe命令
.. py:method:: set_thread(thread_num)
设置进程数量，等于readers的数量。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
dataset.set_thread(12)
参数：
- **thread_num** (int) - 进程数量
.. py:method:: set_use_var(var_list)
设置将要使用的 ``Variable`` 。
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset()
dataset.set_use_var([data, label])
参数：
- **var_list** (list) - variable 列表
.. py:method:: slots_shuffle(slots)
该方法是在特征层次上的一个打乱方法，经常被用在有着较大缩放率实例的稀疏矩阵上，为了比较metric，比如auc，在一个或者多个有着baseline的特征上做特征打乱来验证特征level的重要性。
参数：
- **slots** (list[string]) - 要打乱特征的集合
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
dataset = fluid.DatasetFactory().create_dataset(“InMemoryDataset”)
dataset.set_merge_by_lineid()
#支持slot 0
dataset.slots_shuffle([‘0’])
doc/paddle/api/paddle/fluid/device_guard_cn.rst 0 → 100755
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_device_guard:
device_guard
-------------------------------
**注意：该API仅支持【静态图】模式**
.. py:function:: paddle.fluid.device_guard(device=None)
一个用于指定OP运行设备的上下文管理器。
参数：
- **device** (str|None) – 指定上下文中使用的设备。它可以是'cpu'或者'gpu‘，当它被设置为'cpu'或者'gpu'时，创建在该上下文中的OP将被运行在CPUPlace或者CUDAPlace上。若设置为'gpu'，同时程序运行在单卡模式下，设备的索引将与执行器的设备索引保持一致。默认值：None，在该上下文中的OP将被自动地分配设备。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
support_gpu = fluid.is_compiled_with_cuda()
place = fluid.CPUPlace()
if support_gpu:
place = fluid.CUDAPlace(0)
# if GPU is supported, the three OPs below will be automatically assigned to CUDAPlace(0)
data1 = fluid.layers.fill_constant(shape=[1, 3, 8, 8], value=0.5, dtype='float32')
data2 = fluid.layers.fill_constant(shape=[1, 3, 5, 5], value=0.5, dtype='float32')
shape = fluid.layers.shape(data2)
with fluid.device_guard("cpu"):
# Ops created here will be placed on CPUPlace
shape = fluid.layers.slice(shape, axes=[0], starts=[0], ends=[4])
with fluid.device_guard('gpu'):
# if GPU is supported, OPs created here will be placed on CUDAPlace(0), otherwise on CPUPlace
out = fluid.layers.crop_tensor(data1, shape=shape)
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
result = exe.run(fetch_list=[out])
doc/paddle/api/paddle/fluid/dygraph/Dropout_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_dygraph_Dropout:
Dropout
-------------------------------
.. py:class:: paddle.fluid.dygraph.Dropout(p=0.5, seed=None, dropout_implementation='downgrade_in_infer', is_test=False)
丢弃或者保持输入的每个元素独立。Dropout是一种正则化手段，通过在训练过程中阻止神经元节点间的相关性来减少过拟合。根据给定的丢弃概率，dropout操作符按丢弃概率随机将一些神经元输出设置为0，其他的仍保持不变。
Dropout层可以删除，提高执行效率。
参数：
- **p** (float32，可选) - 输入单元的丢弃概率，即输入单元设置为0的概率。默认值：0.5
- **seed** (int，可选) - 整型数据，用于创建随机种子。如果该参数设为None，则使用随机种子。注：如果给定一个整型种子，始终丢弃相同的输出单元。训练过程中勿用固定不变的种子。默认值：None。
- **dropout_implementation** (str，可选) - 丢弃单元的方式，有两种'downgrade_in_infer'和'upscale_in_train'两种选择，默认：'downgrade_in_infer'。具体作用可以参考一下描述。
1. downgrade_in_infer(default), 在预测时减小输出结果
- train: out = input * mask
- inference: out = input * (1.0 - p)
(mask是一个张量，维度和输入维度相同，值为0或1，值为0的比例即为 ``p`` )
2. upscale_in_train, 增加训练时的结果
- train: out = input * mask / ( 1.0 - p )
- inference: out = input
(mask是一个张量，维度和输入维度相同，值为0或1，值为0的比例即为 ``p`` ）
- **is_test** (bool，可选) - 标记是否是测试阶段。此标志仅对静态图模式有效。对于动态图模式，请使用 ``eval()`` 接口。默认：False。
返回：无
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
from paddle.fluid.dygraph.base import to_variable
import numpy as np
x = np.random.random(size=(3, 10, 3, 7)).astype('float32')
with fluid.dygraph.guard():
x = to_variable(x)
m = fluid.dygraph.Dropout(p=0.5)
droped_train = m(x)
# 切换到 eval 模式
m.eval()
droped_eval = m(x)
doc/paddle/api/paddle/fluid/dygraph/GRUCell_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_layers_GRUCell:
GRUCell
-------------------------------
.. py:class:: paddle.fluid.layers.GRUCell(hidden_size, param_attr=None, bias_attr=None, gate_activation=None, activation=None, dtype="float32", name="GRUCell")
:api_attr: 声明式编程模式（静态图)
门控循环单元（Gated Recurrent Unit）。通过对 :code:`fluid.contrib.layers.rnn_impl.BasicGRUUnit` 包装，来让它可以应用于RNNCell。
公式如下：
.. math::
u_t & = act_g(W_{ux}x_{t} + W_{uh}h_{t-1} + b_u)\\
r_t & = act_g(W_{rx}x_{t} + W_{rh}h_{t-1} + b_r)\\
\tilde{h_t} & = act_c(W_{cx}x_{t} + W_{ch}(r_t \odot h_{t-1}) + b_c)\\
h_t & = u_t \odot h_{t-1} + (1-u_t) \odot \tilde{h_t}
更多细节可以参考 `Learning Phrase Representations using RNN Encoder Decoder for Statistical Machine Translation <https://arxiv.org/pdf/1406.1078.pdf>`_
参数：
- **hidden_size** (int) - GRUCell中的隐藏层大小。
- **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr`。
- **bias_attr** (ParamAttr，可选) - 指定偏置参数属性的对象。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **gate_activation** (function，可选) - :math:`act_g` 的激活函数。 默认值为 :code:`fluid.layers.sigmoid`。
- **activation** (function，可选) - :math:`act_c` 的激活函数。 默认值为 :code:`fluid.layers.tanh`
- **dtype** (string，可选) - 此cell中使用的数据类型。 默认为"float32"。
- **name** (string，可选) - 用于标识参数和偏差的名称域。
返回：GRUCell类的实例对象。
**示例代码**
.. code-block:: python
import paddle.fluid.layers as layers
cell = layers.GRUCell(hidden_size=256)
.. py:method:: call(inputs, states)
执行GRU的计算。
参数：
- **input** (Variable) - 输入，形状为 :math:`[batch\_size，input\_size]` 的tensor，对应于公式中的 :math:`x_t` 。数据类型应为float32。
- **states** (Variable) - 状态，形状为 :math:`[batch\_size，hidden\_size]` 的tensor。 对应于公式中的 :math:`h_{t-1}` 。数据类型应为float32。
返回：一个元组 :code:`(outputs, new_states)` ，其中 :code:`outputs` 和 :code:`new_states` 是同一个tensor，其形状为 :math:`[batch\_size，hidden\_size]`，数据类型和 :code:`state` 的数据类型相同，对应于公式中的 :math:`h_t`。
返回类型：tuple
.. py:method:: state_shape()
GRUCell的 :code:`state_shape` 是形状 :math:`[hidden\_size]` （batch大小为-1，自动插入到形状中），对应于 :math:`h_{t-1}` 的形状。
参数：无。
返回：GRUCell的 :code:`state_shape`。
返回类型：Variable
doc/paddle/api/paddle/fluid/dygraph/GRUUnit_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_dygraph_GRUUnit:
GRUUnit
-------------------------------
.. py:class:: paddle.fluid.dygraph.GRUUnit(name_scope, size, param_attr=None, bias_attr=None, activation='tanh', gate_activation='sigmoid', origin_mode=False, dtype='float32')
该接口用于构建 ``GRU(Gated Recurrent Unit)`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其用于完成单个时间步内GRU的计算，支持以下两种计算方式：
如果origin_mode为True，则使用的运算公式来自论文
`Learning Phrase Representations using RNN Encoder Decoder for Statistical Machine Translation <https://arxiv.org/pdf/1406.1078.pdf>`_ 。
.. math::
u_t & = act_g(W_{ux}x_{t} + W_{uh}h_{t-1} + b_u)\\
r_t & = act_g(W_{rx}x_{t} + W_{rh}h_{t-1} + b_r)\\
\tilde{h_t} & = act_c(W_{cx}x_{t} + W_{ch}(r_t \odot h_{t-1}) + b_c)\\
h_t & = u_t \odot h_{t-1} + (1-u_t) \odot \tilde{h_t}
如果origin_mode为False，则使用的运算公式来自论文
`Empirical Evaluation of Gated Recurrent Neural Networks on Sequence Modeling <https://arxiv.org/pdf/1412.3555.pdf>`_ 。
公式如下:
.. math::
u_t & = act_g(W_{ux}x_{t} + W_{uh}h_{t-1} + b_u)\\
r_t & = act_g(W_{rx}x_{t} + W_{rh}h_{t-1} + b_r)\\
\tilde{h_t} & = act_c(W_{cx}x_{t} + W_{ch}(r_t \odot h_{t-1}) + b_c)\\
h_t & = (1-u_t) \odot h_{t-1} + u_t \odot \tilde{h_t}
其中， :math:`x_t` 为当前时间步的输入，:math:`h_{t-1}` 为前一时间步的隐状态 ``hidden``； :math:`u_t` 、 :math:`r_t` 、 :math:`\tilde{h_t}` 和 :math:`h_t` 分别代表了GRU单元中update gate（更新门）、reset gate（重置门）、candidate hidden（候选隐状态）和隐状态输出; :math:`\odot` 为逐个元素相乘；
:math:`W_{uh}, b_u` 、 :math:`W_{rh}, b_r` 和 :math:`W_{ch}, b_c` 分别代表更新门、重置门和候选隐状态在计算时使用的权重矩阵和偏置。在实现上，三个权重矩阵合并为一个维度为 :math:`[D, D \times 3]` 的Tensor存放。
参数:
- **size** (int) – 输入数据的维度大小。
- **param_attr** (ParamAttr，可选) – 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
**注意**
- 权重参数维度为 :math:`[T, 3×D]` ， :math:`D` 是隐藏状态的规模（hidden size）, 其值与输入size相关，计算方式为size除以3取整 。
- 权重参数矩阵所有元素由两部分组成， 一是update gate和reset gate的权重，维度为 :math:`[D, 2×D]` 的2D Tensor，数据类型可以为float32或float64；二是候选隐藏状态（candidate hidden state）的权重矩阵，维度为 :math:`[D, D]` 的2D Tensor，数据类型可以为float32或float64。
- **bias_attr** (ParamAttr，可选) - 指定偏置参数属性的对象。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **activation** (str，可选) – 公式中 :math:`act_c` 激活函数的类型。可以为'identity'、'sigmoid'、'tanh'、'relu'四种激活函数设置值。默认值为'tanh'。
- **gate_activation** (str，可选) – 公式中 :math:`act_g` 激活函数的类型。可以为'identity'、'sigmoid'、'tanh'、'relu'四种激活函数设置值。默认值为'sigmoid'。
- **origin_mode** (bool) – 指明要使用的GRU计算方式，两种计算方式具体差异见公式描述。默认值为False。
- **dtype** (str，可选) – 该层的数据类型，可以为'float32', 'float64'。默认值为'float32'。
返回：
None.
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
import paddle.fluid.dygraph.base as base
import numpy
lod = [[2, 4, 3]]
D = 5
T = sum(lod[0])
input = numpy.random.rand(T, 3 * D).astype('float32')
hidden_input = numpy.random.rand(T, D).astype('float32')
with fluid.dygraph.guard():
x = numpy.random.random((3, 32, 32)).astype('float32')
gru = fluid.dygraph.GRUUnit(size=D * 3)
dy_ret = gru(
base.to_variable(input), base.to_variable(hidden_input))
属性
::::::::::::
.. py:attribute:: weight
本层的可学习参数，类型为 ``Parameter``
.. py:attribute:: bias
本层的可学习偏置，类型为 ``Parameter``
doc/paddle/api/paddle/fluid/dygraph/LSTMCell_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_layers_LSTMCell:
LSTMCell
-------------------------------
.. py:class:: paddle.fluid.layers.LSTMCell(hidden_size, param_attr=None, bias_attr=None, gate_activation=None, activation=None, forget_bias=1.0, dtype="float32", name="LSTMCell")
:api_attr: 声明式编程模式（静态图)
长短期记忆单元（Long-Short Term Memory）。通过对 :code:`fluid.contrib.layers.rnn_impl.BasicLSTMUnit` 包装，来让它可以应用于RNNCell。
公式如下：
.. math::
i_{t} &= act_g \left ( W_{x_{i}}x_{t}+W_{h_{i}}h_{t-1}+b_{i} \right ) \\
f_{t} &= act_g \left ( W_{x_{f}}x_{t}+W_{h_{f}}h_{t-1}+b_{f}+forget\_bias \right ) \\
c_{t} &= f_{t}c_{t-1}+i_{t}act_h\left ( W_{x_{c}}x_{t} +W_{h_{c}}h_{t-1}+b_{c}\right ) \\
o_{t} &= act_g\left ( W_{x_{o}}x_{t}+W_{h_{o}}h_{t-1}+b_{o} \right ) \\
h_{t} &= o_{t}act_h \left ( c_{t} \right )
更多细节可以参考 `RECURRENT NEURAL NETWORK REGULARIZATION <http://arxiv.org/abs/1409.2329>`_
参数：
- **hidden_size** (int) - LSTMCell中的隐藏层大小。
- **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr`。
- **bias_attr** (ParamAttr，可选) - 指定偏置参数属性的对象。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **gate_activation** (function，可选) - :math:`act_g` 的激活函数。 默认值为 :code:`fluid.layers.sigmoid`。
- **activation** (function，可选) - :math:`act_c` 的激活函数。 默认值为 :code:`fluid.layers.tanh`。
- **forget_bias** (float，可选) - 计算遗忘们时使用的遗忘偏置。默认值为 1.0。
- **dtype** (string，可选) - 此Cell中使用的数据类型。 默认值为 `float32`。
- **name** (string，可选) - 用于标识参数和偏差的名称域。
返回：LSTMCell类的实例对象。
**示例代码**
.. code-block:: python
import paddle.fluid.layers as layers
cell = layers.LSTMCell(hidden_size=256)
.. py:method:: call(inputs, states)
执行GRU的计算。
参数：
- **input** (Variable) - 输入，形状为 :math:`[batch\_size，input\_size]` 的tensor，对应于公式中的 :math:`x_t`。数据类型应为float32。
- **states** (Variable) - 状态，包含两个tensor的列表，每个tensor形状为 :math:`[batch\_size，hidden\_size]`。 对应于公式中的 :math:`h_{t-1}, c_{t-1}`。数据类型应为float32。
返回：一个元组 :code:`(outputs, new_states)`，其中 :code:`outputs` 是形状为 :math:`[batch\_size，hidden\_size]` 的tensor，对应于公式中的 :math:`h_{t}`；:code:`new_states` 是一个列表，包含形状为 :math:`[batch_size，hidden_size]` 的两个tensor变量，它们对应于公式中的 :math:`h_{t}, c_{t}`。这些tensor的数据类型都与 :code:`state` 的数据类型相同。
返回类型：tuple
.. py:method:: state_shape()
LSTMCell的 :code:`state_shape` 是一个具有两个形状的列表：:math:`[[hidden\_size], [hidden\_size]]` （batch大小为-1，自动插入到形状中）。 这两个形状分别对应于公式中的 :math:`h_{t-1}` and :math:`c_{t-1}`。
参数：无。
返回：LSTMCell的 :code:`state_shape`
返回类型：list
doc/paddle/api/paddle/fluid/dygraph/LambdaDecay_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_dygraph_LambdaDecay:
LambdaDecay
-------------------------------
.. py:class:: paddle.fluid.dygraph.LambdaDecay(learning_rate, lr_lambda)
:api_attr: 命令式编程模式（动态图)
该API提供 lambda函数 设置学习率的功能。 ``lr_lambda`` 为一个lambda函数，其通过 ``epoch`` 计算出一个因子，该因子会乘以初始学习率。
算法可以描述为：
.. code-block:: text
learning_rate = 0.5 # init learning_rate
lr_lambda = lambda epoch: 0.95 ** epoch
learning_rate = 0.5 # epoch 0
learning_rate = 0.475 # epoch 1
learning_rate = 0.45125 # epoch 2
参数：
- **learning_rate** (float|int) - 初始化的学习率。可以是Python的float或int。
- **lr_lambda** (function) - ``lr_lambda`` 为一个lambda函数，其通过 ``epoch`` 计算出一个因子，该因子会乘以初始学习率。
返回： 无
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
with fluid.dygraph.guard():
x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
linear = fluid.dygraph.Linear(10, 10)
input = fluid.dygraph.to_variable(x)
scheduler = fluid.dygraph.LambdaDecay(0.5, lr_lambda=lambda x: 0.95**x)
adam = fluid.optimizer.Adam(learning_rate = scheduler, parameter_list = linear.parameters())
for epoch in range(6):
for batch_id in range(5):
out = linear(input)
loss = fluid.layers.reduce_mean(out)
adam.minimize(loss)
scheduler.epoch()
print("epoch:%d, current lr is %f" .format(epoch, adam.current_step_lr()))
# epoch:0, current lr is 0.5
# epoch:1, current lr is 0.475
# epoch:2, current lr is 0.45125
.. py:method:: epoch(epoch=None)
通过当前的 epoch 调整学习率，调整后的学习率将会在下一次调用 ``optimizer.minimize`` 时生效。
参数：
- **epoch** (int|float，可选) - 类型：int或float。指定当前的epoch数。默认：无，此时将会自动累计epoch数。
返回：
无
**代码示例**:
参照上述示例代码。
doc/paddle/api/paddle/fluid/dygraph/MultiStepDecay_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_dygraph_MultiStepDecay:
MultiStepDecay
-------------------------------
.. py:class:: paddle.fluid.dygraph.MultiStepDecay(learning_rate, milestones, decay_rate=0.1)
:api_attr: 命令式编程模式（动态图)
该接口提供 ``MultiStep`` 衰减学习率的功能。
算法可以描述为：
.. code-block:: text
learning_rate = 0.5
milestones = [30, 50]
decay_rate = 0.1
if epoch < 30:
learning_rate = 0.5
elif epoch < 50:
learning_rate = 0.05
else:
learning_rate = 0.005
参数：
- **learning_rate** (float|int) - 初始化的学习率。可以是Python的float或int。
- **milestones** (tuple|list) - 列表或元组。必须是递增的。
- **decay_rate** (float, optional) - 学习率的衰减率。 ``new_lr = origin_lr * decay_rate`` 。其值应该小于1.0。默认：0.1。
返回： 无
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
with fluid.dygraph.guard():
x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
linear = fluid.dygraph.Linear(10, 10)
input = fluid.dygraph.to_variable(x)
scheduler = fluid.dygraph.MultiStepDecay(0.5, milestones=[3, 5])
adam = fluid.optimizer.Adam(learning_rate = scheduler, parameter_list = linear.parameters())
for epoch in range(6):
for batch_id in range(5):
out = linear(input)
loss = fluid.layers.reduce_mean(out)
adam.minimize(loss)
scheduler.epoch()
print("epoch:{}, current lr is {}" .format(epoch, adam.current_step_lr()))
# epoch:0, current lr is 0.5
# epoch:1, current lr is 0.5
# epoch:2, current lr is 0.5
# epoch:3, current lr is 0.05
# epoch:4, current lr is 0.05
# epoch:5, current lr is 0.005
.. py:method:: epoch(epoch=None)
通过当前的 epoch 调整学习率，调整后的学习率将会在下一次调用 ``optimizer.minimize`` 时生效。
参数：
- **epoch** (int|float，可选) - 类型：int或float。指定当前的epoch数。默认：无，此时将会自动累计epoch数。
返回：
无
**代码示例**:
参照上述示例代码。
doc/paddle/api/paddle/fluid/dygraph/NCE_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_dygraph_NCE:
NCE
-------------------------------
.. py:class:: paddle.fluid.dygraph.NCE(num_total_classes, dim, param_attr=None, bias_attr=None, num_neg_samples=None, sampler='uniform', custom_dist=None, seed=0, is_sparse=False, dtype="float32")
该接口用于构建 ``NCE`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其中实现了 ``NCE`` 损失函数的功能，其默认使用均匀分布进行抽样，计算并返回噪音对比估计（ noise-contrastive estimation training loss）。更多详情请参考：`Noise-contrastive estimation: A new estimation principle for unnormalized statistical models <http://www.jmlr.org/proceedings/papers/v9/gutmann10a/gutmann10a.pdf>`_
参数：
- **num_total_classes** (int) - 所有样本中的类别的总数。
- **dim** (int) - 输入的维度（一般为词嵌入的维度）。
- **sample_weight** (Variable, 可选) - 维度为\[batch_size, 1\]，存储每个样本的权重。每个样本的默认权重为1.0。默认值：None。
- **param_attr** (ParamAttr, 可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **bias_attr** (ParamAttr, 可选) - 指定偏置参数属性的对象。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **num_neg_samples** (int, 可选) - 负样本的数量。默认值：10。
- **sampler** (str, 可选) – 指明采样器的类型，用于从负类别中进行采样。可以是 ``uniform`` 、 ``log_uniform`` 或 ``custom_dist`` 。 默认值： ``uniform`` 。
- **custom_dist** (float[], 可选) – float[] 类型的数据，并且它的长度为 ``num_total_classes`` 。如果采样器类别为 ``custom_dist`` ，则使用此参数。custom_dist\[i\]是第i个类别被取样的概率。默认值：None
- **seed** (int, 可选) – 采样器使用的随机种子。默认值：0。
- **is_sparse** (bool, 可选) – 指明是否使用稀疏更新，如果为True， :math:`weight@GRAD` 和 :math:`bias@GRAD` 会变为 SelectedRows。默认值：False。
- **dtype** (str, 可选) - 数据类型，可以为"float32"或"float64"。默认值："float32"。
返回：无
**代码示例**
.. code-block:: python
import numpy as np
import paddle.fluid as fluid
window_size = 5
dict_size = 20
label_word = int(window_size // 2) + 1
inp_word = np.array([[1], [2], [3], [4], [5]]).astype('int64')
nid_freq_arr = np.random.dirichlet(np.ones(20) * 1000).astype('float32')
with fluid.dygraph.guard():
words = []
for i in range(window_size):
words.append(fluid.dygraph.base.to_variable(inp_word[i]))
emb = fluid.Embedding(
size=[dict_size, 32],
param_attr='emb.w',
is_sparse=False)
embs3 = []
for i in range(window_size):
if i == label_word:
continue
emb_rlt = emb(words[i])
embs3.append(emb_rlt)
embs3 = fluid.layers.concat(input=embs3, axis=1)
nce = fluid.NCE(
num_total_classes=dict_size,
dim=embs3.shape[1],
num_neg_samples=2,
sampler="custom_dist",
custom_dist=nid_freq_arr.tolist(),
seed=1,
param_attr='nce.w',
bias_attr='nce.b')
wl = fluid.layers.unsqueeze(words[label_word], axes=[0])
nce_loss3 = nce(embs3, wl)
属性
::::::::::::
.. py:attribute:: weight
本层的可学习参数，类型为 ``Parameter``
.. py:attribute:: bias
本层的可学习偏置，类型为 ``Parameter``
doc/paddle/api/paddle/fluid/dygraph/PRelu_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_dygraph_PRelu:
PRelu
-------------------------------
.. py:class:: paddle.fluid.dygraph.PRelu(mode, input_shape=None, param_attr=None, dtype="float32")
该接口用于构建 ``PRelu`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其中实现了 ``PRelu`` 激活函数的三种激活方式。
计算公式如下：
.. math::
y = max(0, x) + \alpha min(0, x)
参数：
- **mode** (str) - 权重共享模式。共提供三种激活方式：
.. code-block:: text
all：所有元素使用同一个alpha值
channel：在同一个通道中的元素使用同一个alpha值
element：每一个元素有一个独立的alpha值
- **channel** (int，可选) - 通道数。该参数在mode参数为"channel"时是必须的。默认为None。
- **input_shape** (int 或 list 或 tuple，可选) - 输入的维度。该参数在mode参数为"element"时是必须的。默认为None。
- **param_attr** (ParamAttr, 可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **dtype** (str, 可选) - 数据类型，可以为"float32"或"float64"。默认值："float32"。
返回：无
**代码示例：**
.. code-block:: python
import paddle.fluid as fluid
from paddle.fluid.dygraph.base import to_variable
import numpy as np
inp_np = np.ones([5, 200, 100, 100]).astype('float32')
with fluid.dygraph.guard():
inp_np = to_variable(inp_np)
prelu0 = fluid.PRelu(
mode='all',
param_attr=fluid.ParamAttr(initializer=fluid.initializer.Constant(1.0)))
dy_rlt0 = prelu0(inp_np)
prelu1 = fluid.PRelu(
mode='channel',
channel=200,
param_attr=fluid.ParamAttr(initializer=fluid.initializer.Constant(1.0)))
dy_rlt1 = prelu1(inp_np)
prelu2 = fluid.PRelu(
mode='element',
input_shape=inp_np.shape,
param_attr=fluid.ParamAttr(initializer=fluid.initializer.Constant(1.0)))
dy_rlt2 = prelu2(inp_np)
属性
::::::::::::
.. py:attribute:: weight
本层的可学习参数，类型为 ``Parameter``
doc/paddle/api/paddle/fluid/dygraph/ReduceLROnPlateau_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_dygraph_ReduceLROnPlateau:
ReduceLROnPlateau
-------------------------------
**注意：该API仅支持【动态图】模式**
.. py:class:: paddle.fluid.dygraph.ReduceLROnPlateau(learning_rate, mode='min', decay_rate=0.1, patience=10, verbose=False, threshold=1e-4, threshold_mode='rel', cooldown=0, min_lr=0, eps=1e-8, dtype='float32')
该API为 ``loss`` 自适应的学习率衰减策略。默认情况下，当 ``loss`` 停止下降时，降低学习率（如果将 ``mode`` 设置为 `'max'` ，此时判断逻辑相反， ``loss`` 停止上升时降低学习率）。其思想是：一旦模型表现不再提升，将学习率降低2-10倍对模型的训练往往有益。
``loss`` 是传入到该类方法 ``step`` 中的参数，其必须是shape为[1]的1-D Tensor。 如果 ``loss`` 停止下降（``mode`` 为 `min` 时）超过 ``patience`` 个epoch，学习率将会减小为
`learning_rate * decay_rate` 。
此外，每降低一次学习率后，将会进入一个时长为 ``cooldown`` 个epoch的冷静期，在冷静期内，将不会监控 ``loss`` 的变化情况，也不会衰减。
在冷静期之后，会继续监控 ``loss`` 的上升或下降。
参数：
- **learning_rate** (Variable|float|int) - 初始学习率。其类型可以是Python的float类型，如果输入int类型则会被转为float类型。其也可以是shape为[1]的
1-D Tensor，且相应数据类型必须为 "float32" 或 "float64" 。
- **mode** (str，可选) - `'min'` 和 `'max'` 之一。通常情况下，为 `'min'` ，此时当 ``loss`` 停止下降时学习率将减小。默认：`'min'` 。
（注意：仅在特殊用法时，可以将其设置为 `'max'` ，此时判断逻辑相反， ``loss`` 停止上升学习率才减小）
- **decay_rate** (float，可选) - 学习率衰减的比例。`new_lr = origin_lr * decay_rate` ，它是值小于1.0的float型数字，默认: 0.1。
- **patience** (int，可选) - 当 ``loss`` 连续 ``patience`` 个epoch没有下降(mode: 'min')或上升(mode: 'max')时，学习率才会减小。默认：10。
- **verbose** (bool，可选) - 如果为 ``True`` ， 会在每次更新optimizer中的learning_rate时，打印信息。默认：``False`` 。
- **threshold** (float，可选) - ``threshold`` 和 ``threshold_mode`` 两个参数将会决定 ``loss`` 最小变化的阈值。小于该阈值的变化
将会被忽视。默认：1e-4。
- **threshold_mode** (str，可选) - `'rel'` 和 `'abs'` 之一。在 `'rel'` 模式下， ``loss`` 最小变化的阈值是 `last_loss * threshold` ，
其中 ``last_loss`` 是 ``loss`` 在上个epoch的值。在 `'abs'` 模式下，``loss`` 最小变化的阈值是 `threshold` 。 默认：`'rel'`。
- **cooldown** (int，可选) - 在学习速率每次减小之后，会进入时长为 ``cooldown`` 个epoch的冷静期。默认：0。
- **min_lr** (float，可选) - 最小的学习率。减小后的学习率最低下界限。默认：0。
- **eps** (float，可选) - 如果新旧学习率间的差异小于 ``eps`` ，则不会更新。默认值:1e-8。
- **dtype** (str，可选) – 学习率值的数据类型，可以为"float32", "float64"。默认："float32"。
返回： ``loss`` 自适应的学习率
返回类型：Variable
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
with fluid.dygraph.guard():
x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
linear = fluid.dygraph.Linear(10, 10)
input = fluid.dygraph.to_variable(x)
adam = fluid.optimizer.Adam(
learning_rate = fluid.dygraph.ReduceLROnPlateau(
learning_rate = 1.0,
decay_rate = 0.5,
patience = 5,
verbose = True,
cooldown = 3),
parameter_list = linear.parameters())
for epoch in range(10):
total_loss = 0
for bath_id in range(5):
out = linear(input)
loss = fluid.layers.reduce_mean(out)
total_loss += loss
adam.minimize(loss)
avg_loss = total_loss/5
# 根据传入total_loss，调整学习率
reduce_lr.step(avg_loss)
lr = adam.current_step_lr()
print("current avg_loss is %s, current lr is %s" % (avg_loss.numpy()[0], lr))
.. py:method:: step(loss)
需要在每个epoch调用该方法，其根据传入的 ``loss`` 调整optimizer中的学习率，调整后的学习率将会在下一次调用 ``optimizer.minimize`` 时生效。
参数：
- **loss** (Variable) - 类型：Variable，shape为[1]的1-D Tensor。将被用来判断是否需要降低学习率。如果 ``loss`` 连续 ``patience`` 个epochs没有下降，
将会降低学习率。
返回：
无
**代码示例**:
参照其类中的说明。
doc/paddle/api/paddle/fluid/dygraph/StepDecay_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_dygraph_StepDecay:
StepDecay
-------------------------------
.. py:class:: paddle.fluid.dygraph.StepDecay(learning_rate, step_size, decay_rate=0.1)
:api_attr: 命令式编程模式（动态图)
该接口提供 ``step_size`` 衰减学习率的功能，每经过 ``step_size`` 个 ``epoch`` 时会通过 ``decay_rate`` 衰减一次学习率。
算法可以描述为：
.. code-block:: text
learning_rate = 0.5
step_size = 30
decay_rate = 0.1
learning_rate = 0.5 if epoch < 30
learning_rate = 0.05 if 30 <= epoch < 60
learning_rate = 0.005 if 60 <= epoch < 90
...
参数：
- **learning_rate** (float|int) - 初始化的学习率。可以是Python的float或int。
- **step_size** (int) - 学习率每衰减一次的间隔。
- **decay_rate** (float, optional) - 学习率的衰减率。 ``new_lr = origin_lr * decay_rate`` 。其值应该小于1.0。默认：0.1。
返回： 无
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
with fluid.dygraph.guard():
x = np.random.uniform(-1, 1, [10, 10]).astype("float32")
linear = fluid.dygraph.Linear(10, 10)
input = fluid.dygraph.to_variable(x)
scheduler = fluid.dygraph.StepDecay(0.5, step_size=3)
adam = fluid.optimizer.Adam(learning_rate = scheduler, parameter_list = linear.parameters())
for epoch in range(9):
for batch_id in range(5):
out = linear(input)
loss = fluid.layers.reduce_mean(out)
adam.minimize(loss)
scheduler.epoch()
print("epoch:{}, current lr is {}" .format(epoch, adam.current_step_lr()))
# epoch:0, current lr is 0.5
# epoch:1, current lr is 0.5
# epoch:2, current lr is 0.5
# epoch:3, current lr is 0.05
# epoch:4, current lr is 0.05
# epoch:5, current lr is 0.05
# epoch:6, current lr is 0.005
# epoch:7, current lr is 0.005
# epoch:8, current lr is 0.005
.. py:method:: epoch(epoch=None)
通过当前的 epoch 调整学习率，调整后的学习率将会在下一次调用 ``optimizer.minimize`` 时生效。
参数：
- **epoch** (int|float，可选) - 类型：int或float。指定当前的epoch数。默认：无，此时将会自动累计epoch数。
返回：
无
**代码示例**:
参照上述示例代码。
doc/paddle/api/paddle/fluid/dygraph/TreeConv_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_dygraph_TreeConv:
TreeConv
-------------------------------
.. py:class:: paddle.fluid.dygraph.TreeConv(feature_size, output_size, num_filters=1, max_depth=2, act='tanh', param_attr=None, bias_attr=None, name=None, dtype="float32")
该接口用于构建 ``TreeConv`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其将在神经网络中构建一个基于树结构的卷积（Tree-Based Convolution）运算。基于树的卷积是基于树的卷积神经网络（TBCNN，Tree-Based Convolution Neural Network）的一部分，它用于对树结构进行分类，例如抽象语法树。 Tree-Based Convolution提出了一种称为连续二叉树的数据结构，它将多路（multiway）树视为二叉树。详情请参考： `基于树的卷积论文 <https://arxiv.org/abs/1409.5718v1>`_ 。
参数：
- **feature_size** (int) – nodes_vector的shape的最后一维的维度。
- **output_size** (int) – 输出特征宽度。
- **num_filters** (int, 可选) – 滤波器的数量，默认值为1。
- **max_depth** (int, 可选) – 滤波器的最大深度，默认值为2。
- **act** (str, 可选) – 应用于输出上的激活函数，如tanh、softmax、sigmoid，relu等，支持列表请参考 :ref:`api_guide_activations` ，默认值为None。
- **param_attr** (ParamAttr, 可选) – 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **bias_attr** (ParamAttr, 可选) – 指定偏置参数属性的对象。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **name** (str, 可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
- **dtype** (str, 可选) - 数据类型，可以为"float32"或"float64"。默认值为"float32"。
返回：无
**代码示例**:
.. code-block:: python
import paddle.fluid as fluid
import numpy
with fluid.dygraph.guard():
nodes_vector = numpy.random.random((1, 10, 5)).astype('float32')
edge_set = numpy.random.random((1, 9, 2)).astype('int32')
treeConv = fluid.dygraph.nn.TreeConv(
feature_size=5, output_size=6, num_filters=1, max_depth=2)
ret = treeConv(fluid.dygraph.base.to_variable(nodes_vector), fluid.dygraph.base.to_variable(edge_set))
属性
::::::::::::
.. py:attribute:: weight
本层的可学习参数，类型为 ``Parameter``
.. py:attribute:: bias
本层的可学习偏置，类型为 ``Parameter``
doc/paddle/api/paddle/fluid/dygraph/base/disable_dygraph_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_disable_dygraph:
disable_dygraph
-------------------------------
.. py:function:: paddle.fluid.disable_dygraph()
该接口关闭动态图模式。
返回：无
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
fluid.enable_dygraph() # Now we are in dygraph mode
print(fluid.in_dygraph_mode()) # True
fluid.disable_dygraph()
print(fluid.in_dygraph_mode()) # False
doc/paddle/api/paddle/fluid/dygraph/base/enable_dygraph_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_enable_dygraph:
enable_dygraph
-------------------------------
.. py:function:: paddle.fluid.enable_dygraph(place=None)
该接口打开动态图模式。
参数：
- **place** (fluid.CPUPlace 或 fluid.CUDAPlace，可选) - 执行动态图的设备数目。若为None，则设备根据paddle的编译方式决定。默认值为 ``None``。
返回：无
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
fluid.enable_dygraph() # Now we are in dygraph mode
print(fluid.in_dygraph_mode()) # True
fluid.disable_dygraph()
print(fluid.in_dygraph_mode()) # False
doc/paddle/api/paddle/fluid/dygraph/checkpoint/load_dygraph_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_dygraph_load_dygraph:
load_dygraph
-------------------------------
.. py:function:: paddle.fluid.dygraph.load_dygraph(model_path)
:api_attr: 命令式编程模式（动态图)
该接口尝试从磁盘中加载参数或优化器的 ``dict`` 。
该接口会同时加载 ``model_path + ".pdparams"`` 和 ``model_path + ".pdopt"`` 中的内容。
参数:
- **model_path** (str) – 保存state_dict的文件前缀。该路径不应该包括后缀 ``.pdparams`` 或 ``.pdopt``。
返回: 两个 ``dict`` ，即从文件中恢复的参数 ``dict`` 和优化器 ``dict``
- para_dict: 从文件中恢复的参数 ``dict``
- opti_dict: 从文件中恢复的优化器 ``dict``
返回类型: tuple(dict, dict)
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
with fluid.dygraph.guard():
emb = fluid.dygraph.Embedding([10, 10])
state_dict = emb.state_dict()
fluid.save_dygraph( state_dict, "paddle_dy")
adam = fluid.optimizer.Adam( learning_rate = fluid.layers.noam_decay( 100, 10000) ,
parameter_list = emb.parameters() )
state_dict = adam.state_dict()
fluid.save_dygraph( state_dict, "paddle_dy")
para_state_dict, opti_state_dict = fluid.load_dygraph( "paddle_dy")
doc/paddle/api/paddle/fluid/dygraph/checkpoint/save_dygraph_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_dygraph_save_dygraph:
save_dygraph
-------------------------------
.. py:function:: paddle.fluid.dygraph.save_dygraph(state_dict, model_path)
:api_attr: 命令式编程模式（动态图)
该接口将传入的参数或优化器的 ``dict`` 保存到磁盘上。
``state_dict`` 是通过 :ref:`cn_api_fluid_dygraph_Layer` 的 ``state_dict()`` 方法得到的。
注： ``model_path`` 不可以是一个目录。
该接口会根据 ``state_dict`` 的内容，自动给 ``model_path`` 添加 ``.pdparams`` 或者 ``.pdopt`` 后缀，
生成 ``model_path + ".pdparams"`` 或者 ``model_path + ".pdopt"`` 文件。
参数:
- **state_dict** (dict of Parameters) – 要保存的模型参数的 ``dict`` 。
- **model_path** (str) – 保存state_dict的文件前缀。格式为 ``目录名称/文件前缀``。如果文件前缀为空字符串，会引发异常。
返回: 无
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
with fluid.dygraph.guard():
emb = fluid.dygraph.Embedding([10, 10])
state_dict = emb.state_dict()
fluid.save_dygraph( state_dict, "paddle_dy") # 会保存为 paddle_dy.pdparams
adam = fluid.optimizer.Adam( learning_rate = fluid.layers.noam_decay( 100, 10000),
parameter_list = emb.parameters() )
state_dict = adam.state_dict()
fluid.save_dygraph( state_dict, "paddle_dy") # 会保存为 paddle_dy.pdopt
\ No newline at end of file
doc/paddle/api/paddle/fluid/dygraph/guard_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_dygraph_guard:
guard
-------------------------------
.. py:function:: paddle.fluid.dygraph.guard(place=None)
:api_attr: 命令式编程模式（动态图)
通过with语句创建一个dygraph运行的context，执行context代码。
参数：
- **place** (fluid.CPUPlace|fluid.CUDAPlace, 可选) – 动态图执行的设备，可以选择cpu，gpu，如果用户未制定，则根据用户paddle编译的方式来选择运行的设备，如果编译的cpu版本，则在cpu上运行，如果是编译的gpu版本，则在gpu上运行。默认值：None。
返回： None
**代码示例**
.. code-block:: python
import numpy as np
import paddle.fluid as fluid
with fluid.dygraph.guard():
inp = np.ones([3, 1024], dtype='float32')
t = fluid.dygraph.base.to_variable(inp)
linear1 = fluid.Linear(1024, 4, bias_attr=False)
linear2 = fluid.Linear(4, 4)
ret = linear1(t)
dy_ret = linear2(ret)
doc/paddle/api/paddle/fluid/dygraph/jit/declarative_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_dygraph_declarative:
declarative
-------------------------------
.. py:decorator:: paddle.fluid.dygraph.jit.declarative
本装饰器将函数内的动态图API转化为静态图API。此装饰器自动处理静态图模式下的
Program和Executor，并将结果作为动态图VarBase返回。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
from paddle.fluid.dygraph.jit import declarative
@declarative
def func(x):
x = fluid.dygraph.to_variable(x)
if fluid.layers.mean(x) < 0:
x_v = x - 1
else:
x_v = x + 1
return x_v
x = np.ones([1, 2])
x_v = func(x)
print(x_v.numpy()) # [[2. 2.]]
doc/paddle/api/paddle/fluid/evaluator/ChunkEvaluator_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_metrics_ChunkEvaluator:
ChunkEvaluator
-------------------------------
.. py:class:: paddle.fluid.metrics.ChunkEvaluator(name=None)
该接口使用mini-batch的chunk_eval累计的counter numbers，来计算准确率、召回率和F1值。ChunkEvaluator有三个状态num_infer_chunks，num_label_chunks和num_correct_chunks，分别对应语块数目、标签中的语块数目、正确识别的语块数目。对于chunking的基础知识，请参考 https://www.aclweb.org/anthology/N01-1025 。ChunkEvalEvaluator计算块检测（chunk detection）的准确率，召回率和F1值，支持IOB, IOE, IOBES和IO标注方案。
参数：
- **name** (str，可选) – 具体用法请参见 :ref:`api_guide_Name` ，一般无需设置，默认值为None。
返回：初始化后的 ``ChunkEvaluator`` 对象
返回类型：ChunkEvaluator
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
# 初始化chunck-level的评价管理。
metric = fluid.metrics.ChunkEvaluator()
# 假设模型预测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)
该函数使用输入的(num_infer_chunks, num_label_chunks, num_correct_chunks)来累计更新ChunkEvaluator对象的对应状态，更新方式如下：
.. math::
\\ \begin{array}{l}{\text { self. num_infer_chunks }+=\text { num_infer_chunks }} \\ {\text { self. num_Label_chunks }+=\text { num_label_chunks }} \\ {\text { self. num_correct_chunks }+=\text { num_correct_chunks }}\end{array} \\
参数:
- **num_infer_chunks** (int|numpy.array) – 给定mini-batch的语块数目。
- **num_label_chunks** (int|numpy.array) - 给定mini-batch的标签中的语块数目。
- **num_correct_chunks** （int|numpy.array）— 给定mini-batch的正确识别的语块数目。
返回：无
.. py:method:: eval()
该函数计算并返回准确率，召回率和F1值。
返回：准确率，召回率和F1值
返回类型：float
doc/paddle/api/paddle/fluid/evaluator/DetectionMAP_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_metrics_DetectionMAP:
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')
该OP用于计算检测网络的平均精度（mAP）。 mAP是衡量object detectors精度的指标，比如 Faster R-CNN,SSD等。它不同于召回率，它是最大精度的平均值。
通常步骤如下：
1. 根据检测器中的输入和label，计算True Positive(TP)真正例 和 False Positive(FP)假正例
2. 计算map，支持 ``11 point`` 和 ``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],label为类别标签，confidence为置信度，xmin，ymin为检测框左上点坐标，xmax，ymax为检测框右下点坐标，数据类型为float32或float64。
- **gt_label** (Variable) – ground truth label 的索引，它是一个形状为[N, 1]的LoDtensor，数据类型为float32或float64。
- **gt_box** (Variable) – ground truth bounds box (bbox)，是一个具有形状的LoD张量[N, 4]。布局是[xmin, ymin, xmax, ymax]，数据类型为float32或float64。
- **gt_difficult** (Variable|None, 可选) – 指定这个ground truth是否是一个difficult bounding bbox，它可以是一个 shape=[N, 1]的LoDTensor，也可以不被指定。默认设置为None，表示所有的ground truth标签都不是difficult bbox，数据类型为float32或float64。
- **class_num** (int) – 检测类别的数目。
- **background_label** (int) – 背景标签的索引，背景标签将被忽略。如果设置为-1，则所有类别将被考虑，默认为0。
- **overlap_threshold** (float) – 判断真假阳性的阈值，默认为0.5。
- **evaluate_difficult** (bool) – 是否考虑 difficult ground truth 进行评价，默认为 True。当 gt_difficult 为 None 时，这个参数不起作用。
- **ap_version** (str) – 平均精度的计算方法，必须是 "integral" 或 "11point"。详情请查看 https://sanchom.wordpress.com/tag/average-precision/。 其中，11point为：11-point 插值平均精度。积分: precision-recall曲线的自然积分。
返回：变量(Variable) 计算mAP的结果，其中数据类型为float32或float64。
返回类型：变量(Variable)
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
batch_size = -1 # 可以为任意大小
image_boxs_num = 10
bounding_bboxes_num = 21
pb = fluid.data(name='prior_box', shape=[image_boxs_num, 4],
dtype='float32')
pbv = fluid.data(name='prior_box_var', shape=[image_boxs_num, 4],
dtype='float32')
loc = fluid.data(name='target_box', shape=[batch_size, bounding_bboxes_num, 4],
dtype='float32')
scores = fluid.data(name='scores', shape=[batch_size, bounding_bboxes_num, image_boxs_num],
dtype='float32')
nmsed_outs = fluid.layers.detection_output(scores=scores,
loc=loc, prior_box=pb, prior_box_var=pbv)
gt_box = fluid.data(name="gt_box", shape=[batch_size, 4], dtype="float32")
gt_label = fluid.data(name="gt_label", shape=[batch_size, 1], dtype="float32")
difficult = fluid.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()
.. py:method:: get_map_var()
返回：当前 mini-batch 的 mAP 变量和不同 mini-batch 的 mAP 累加和
.. py:method:: reset(executor, reset_program=None)
在指定的 batch 结束或者用户指定的开始时重置度量状态。
参数：
- **executor** (Executor) – 执行reset_program的执行程序
- **reset_program** (Program|None, 可选) – 单个program 的 reset 过程。如果设置为 None，将创建一个 program
doc/paddle/api/paddle/fluid/evaluator/EditDistance_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
.. _cn_api_fluid_metrics_EditDistance:
EditDistance
-------------------------------
.. py:class:: paddle.fluid.metrics.EditDistance(name)
用于管理字符串的编辑距离。编辑距离是通过计算将一个字符串转换为另一个字符串所需的最小编辑操作数（添加、删除或替换）来量化两个字符串（例如单词）彼此不相似的程度一种方法。 参考 https://en.wikipedia.org/wiki/Edit_distance。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
# 假设batch_size为128
batch_size = 128
# 初始化编辑距离管理器
distance_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)
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:: reset()
清空存储结果。
参数：无
返回：无
.. py:method:: update(distances, seq_num)
更新存储结果
参数：
- **distances** – 一个形状为(batch_size, 1)的numpy.array，每个元素代表两个序列间的距离。
- **seq_num** – 一个整型/浮点型值，代表序列对的数量。
返回：无
.. py:method:: eval()
返回两个浮点数：
avg_distance：使用更新函数更新的所有序列对的平均距离。
avg_instance_error：编辑距离不为零的序列对的比例。
doc/paddle/api/paddle/fluid/get_flags_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/initializer/Normal_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/initializer/Uniform_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/io/PyReader_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/io/load_params_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/io/load_persistables_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/io/load_vars_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/io/save_params_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/io/save_persistables_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/io/save_vars_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/Categorical_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/Decoder_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/DynamicRNN_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/GRUCell_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/IfElse_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/LSTMCell_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/Normal_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/RNNCell_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/StaticRNN_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/Switch_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/Uniform_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/While_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/argmax_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/argsort_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/array_length_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/array_read_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/array_write_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/clip_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/concat_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/create_array_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/crop_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/cross_entropy_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/cumsum_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/data_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/double_buffer_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/dropout_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/dynamic_gru_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/dynamic_lstm_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/dynamic_lstmp_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/elu_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/embedding_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/equal_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/eye_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/flatten_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/gather_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/gelu_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/greater_equal_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/greater_than_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/gru_unit_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/hard_shrink_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/im2sequence_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/inplace_abn_cn.rst 0 → 100755
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/leaky_relu_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/less_equal_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/less_than_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/lod_append_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/lod_reset_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/logsigmoid_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/lstm_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/lstm_unit_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/matmul_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/matrix_nms_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/mean_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/mul_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/not_equal_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/one_hot_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/ones_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/ones_like_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/pad_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/pow_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/py_reader_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/range_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/read_file_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/relu6_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/relu_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/reverse_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/rnn_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/sampling_id_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/selu_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/sequence_conv_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/sequence_mask_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/sequence_pad_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/sequence_pool_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/size_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/softmax_cn.rst 0 → 100755
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/softplus_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/softshrink_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/softsign_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/split_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/squeeze_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/stack_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/sum_cn.rst 0 → 100755
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/unbind_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/unsqueeze_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/where_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/zeros_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/zeros_like_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/load_op_library_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/memory_optimize_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/metrics/MetricBase_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/nets/glu_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/nets/img_conv_group_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/one_hot_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/optimizer/Adam_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/optimizer/Adamax_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/profiler/profiler_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/profiler_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/reader/PyReader_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/regularizer/L1Decay_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/regularizer/L2Decay_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/release_memory_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/require_version_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/set_flags_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/transpiler/HashName_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/unique_name/generate_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/unique_name/guard_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/fluid/unique_name/switch_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/nn/Dropout_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/nn/functional/prelu_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/nn/functional/tanh_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/static/data_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/static/save_cn.rst 已删除 100644 → 0
浏览文件 @ f8c89a84
此差异已折叠。
doc/paddle/api/paddle/tensor/creation/diag_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/tensor/math/clip_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/tensor/math/div_cn.rst 已删除 100755 → 0
浏览文件 @ f8c89a84
此差异已折叠。
doc/paddle/api/paddle/tensor/math/isfinite_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/tensor/math/isnan_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/tensor/math/sign_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/tensor/math/tanh_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
doc/paddle/api/paddle/tensor/search/argmin_cn.rst 0 → 100644
浏览文件 @ 0ffc4e5a
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或