Skip to content

F
FluidDoc

PaddlePaddle / FluidDoc

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

add new doc dirs

上级 7464e15e
展开全部 隐藏空白更改
内联 并排
Showing with 858 addition and 71481 deletion

要显示的变更太多。

To preserve performance only 1000 of 1000+ files are displayed.
文本差异 电子邮件补丁
doc/paddle/api/alias_api_mapping 0 → 100644
浏览文件 @ a219c253
此差异已折叠。
doc/paddle/api/gen_doc.py
浏览文件 @ a219c253
......@@ -10,122 +10,149 @@ import argparse
en_suffix = "_en.rst"
cn_suffix = "_cn.rst"
file_path_dict = {}
same_api_map = {}
alias_api_map = {}
not_display_doc_map = {}
display_doc_map = {}
api_set = set()
def _str2bool(s):
if s.lower() in ('yes', 'true'):
return True
elif s.lower() in ('no', 'false'):
return False
else:
raise argparse.ArgumentTypeError('Unsupported value encountered.')
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument(
'--gen_cn',
type=_str2bool,
default=False,
help='Generate the cn documentations')
parser.add_argument(
'--gen_en',
type=_str2bool,
default=True,
help='Generate the en documentations')
return parser.parse_args()
def gen_doc_dir(root_path='paddle'):
backup_path = root_path + "_" + str(int(time.time()))
# move old dirs
if os.path.isdir(root_path):
os.rename(root_path, backup_path)
os.mkdir(root_path)
def get_all_api(root_path='paddle'):
for filefiner, name, ispkg in pkgutil.walk_packages(
path=paddle.__path__, prefix=paddle.__name__ + '.'):
path = name.replace(".", "/")
try:
m = eval(name)
except AttributeError:
pass
else:
if hasattr(eval(name), "__all__"):
os.makedirs(path)
#may have duplication of api
for api in list(set(eval(name).__all__)):
os.mknod(path + "/" + api + en_suffix)
gen = EnDocGenerator()
with gen.guard(path + "/" + api + en_suffix):
if api != 'test, get_dict':
gen.module_name = name
gen.api = api
gen.print_header_reminder()
gen.print_item()
api_all = name + "." + api
if "," in api:
continue
try:
fc_id = id(eval(api_all))
except AttributeError:
pass
else:
api_set.add(api_all)
def get_all_same_api():
for api in api_set:
fc_id = id(eval(api))
if fc_id in same_api_map:
same_api_map[fc_id].append(api)
else:
same_api_map[fc_id] = [api]
def clean_en_files(path="./paddle"):
for root, dirs, files in os.walk(path):
for file in files:
if file.endswith(en_suffix):
os.remove(os.path.join(root, file))
def get_not_display_doc_list(file="./not_display_doc_list"):
with open(file, 'r') as f:
for line in f.readlines():
line = line.strip()
not_display_doc_map[line] = 1
def gen_en_files(root_path='paddle'):
for filefiner, name, ispkg in pkgutil.walk_packages(
path=paddle.__path__, prefix=paddle.__name__ + '.'):
path = name.replace(".", "/")
def get_display_doc_map(file="./display_doc_list"):
with open(file, 'r') as f:
for line in f.readlines():
line = line.strip()
display_doc_map[line] = 1
try:
m = eval(name)
except AttributeError:
pass
def get_alias_mapping(file="./alias_api_mapping"):
with open(file, 'r') as f:
for line in f.readlines():
t = line.strip().split('\t')
real_api = t[0].strip()
alias_api = t[1].strip()
alias_api_map[real_api] = alias_api
def is_filter_api(api):
#if api in display_list, just return False
if api in display_doc_map:
return False
#check in api in not_display_list
for key in not_display_doc_map:
#find the api
if key == api:
return True
#find the module
if api.startswith(key):
k_segs = key.split(".")
a_segs = api.split(".")
if k_segs[len(k_segs) - 1] == a_segs[len(k_segs) - 1]:
return True
#check api in alias map
if alias_api_map.has_key(api):
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
#if the api in alias_map key, others api is alias api
for x in same_apis:
if alias_api_map.has_key(x):
return True
if len(same_apis) > 1:
# find shortest path of api as the real api
# others api as the alias api
shortest = len(same_apis[0].split("."))
for x in same_apis:
if len(x.split(".")) < shortest:
shortest = len(x.split("."))
if len(api.split(".")) == shortest:
return False
else:
if hasattr(eval(name), "__all__"):
for api in list(set(eval(name).__all__)):
gen = EnDocGenerator()
with gen.guard(path + "/" + api + en_suffix):
if api != 'test, get_dict':
gen.module_name = name
gen.api = api
gen.print_header_reminder()
gen.print_item()
return True
return False
def get_cn_files_path_dict(path=None):
if path == None:
path = os.getcwd() + "/../../fluid/api_cn"
def gen_en_files(root_path='paddle'):
backup_path = root_path + "_" + str(int(time.time()))
for api in api_set:
if is_filter_api(api):
continue
for root, dirs, files in os.walk(path):
for file in files:
file = file.replace(cn_suffix, "", 1)
val = str(root + "/" + file)
if file in file_path_dict:
file_path_dict[file].append(val)
else:
file_path_dict[file] = [val]
doc_file = api.split(".")[-1]
path = "/".join(api.split(".")[0:-1])
if not os.path.exists(path):
os.makedirs(path)
f = api.replace(".", "/")
os.mknod(f + en_suffix)
gen = EnDocGenerator()
with gen.guard(f + en_suffix):
gen.module_name = ".".join(api.split(".")[0:-1])
gen.api = doc_file
gen.print_header_reminder()
gen.print_item()
def copy_cn_files():
path = "./paddle"
def clean_en_files(path="./paddle"):
for root, dirs, files in os.walk(path):
for file in files:
f = file.replace(en_suffix, "", 1)
if f in file_path_dict:
key = root[len(path):] + "/" + f
isfind = False
for p in file_path_dict[f]:
if p.find(key) != -1:
src = p + cn_suffix
dst = root + "/" + f + cn_suffix
shutil.copy(src, dst)
isfind = True
break
if not isfind:
src = find_max_size_file(file_path_dict[f]) + cn_suffix
dst = root + "/" + f + cn_suffix
shutil.copy(src, dst)
if file.endswith(en_suffix):
os.remove(os.path.join(root, file))
def check_cn_en_match(path="./paddle", diff_file="en_cn_files_diff"):
......@@ -149,17 +176,6 @@ def check_cn_en_match(path="./paddle", diff_file="en_cn_files_diff"):
fo.close()
def find_max_size_file(files):
max_size = 0
file = ""
for f in files:
if os.path.getsize(f + cn_suffix) > max_size:
max_size = os.path.getsize(f + cn_suffix)
file = f
return file
class EnDocGenerator(object):
def __init__(self, name=None, api=None):
self.module_name = name
......@@ -238,20 +254,19 @@ class EnDocGenerator(object):
def print_function(self):
self._print_ref_()
self._print_header_(self.api, dot='-', is_title=False)
self.stream.write('''.. autofunction:: paddle.{0}.{1}
self.stream.write('''.. autofunction:: {0}.{1}
:noindex:
'''.format(self.module_name, self.api))
if __name__ == "__main__":
args = parse_args()
if args.gen_cn:
gen_doc_dir()
get_cn_files_path_dict()
copy_cn_files()
get_all_api()
get_not_display_doc_list()
get_display_doc_map()
get_all_same_api()
get_alias_mapping()
clean_en_files()
if args.gen_en:
gen_en_files()
check_cn_en_match()
gen_en_files()
check_cn_en_match()
doc/paddle/api/gen_doc.sh 0 → 100644
浏览文件 @ a219c253
#!/bin/bash
python gen_doc.py
doc/paddle/api/not_display_doc_list
浏览文件 @ a219c253
paddle/utils
paddle.utils
paddle.incubate
doc/paddle/api/paddle/fleet/meta_optimizers/recompute_optimizer/RecomputeOptimizer_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_fluid_optimizer_RecomputeOptimizer:
RecomputeOptimizer
-------------------------------
.. py:class:: paddle.fluid.optimizer.RecomputeOptimizer(optimizer)
:api_attr: 声明式编程模式（静态图)
通常来讲，一个深度学习的训练流程包含了三个子步骤：首先，运行前向算子来计算Variable和loss的值；其次，运行反向算子来计算参数的梯度；最后，应用优化算法以更新参数值。
在前向运算过程中，反向运算会用到的Variable都会保存在内存中，当模型深度很深时，这会占用大量的内存。
重计算将深度学习网络切分为k个部分（segments）。在每个segment，运行反向运算时会首先运算前向计算。在重计算模式下，前向计算除了checkpoint和一些必须存储在内存中的特殊Variable，其他临时Variable都会被释放，这对节省内存非常有益。
把一个深度学习网络切分为k个segments的Variables被称为checkpoints。用户在使用运行RecomputeOptimizer之前需要先设置checkpoints。
参数:
- **optimizer** (Optimizer)-内部优化器
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
def gen_data():
return {"x": np.random.random(size=(32, 32)).astype('float32'),
"y": np.random.randint(2, size=(32, 1)).astype('int64')}
def mlp(input_x, input_y, hid_dim=128, label_dim=2):
print(input_x)
fc_1 = fluid.layers.fc(input=input_x, size=hid_dim)
prediction = fluid.layers.fc(input=[fc_1], size=label_dim, act='softmax')
cost = fluid.layers.cross_entropy(input=prediction, label=input_y)
sum_cost = fluid.layers.reduce_mean(cost)
return sum_cost, fc_1, prediction
input_x = fluid.layers.data(name="x", shape=[32], dtype='float32')
input_y = fluid.layers.data(name="y", shape=[1], dtype='int64')
cost, fc_1, pred = mlp(input_x, input_y)
sgd = fluid.optimizer.Adam(learning_rate=0.01)
sgd = fluid.optimizer.RecomputeOptimizer(sgd)
sgd._set_checkpoints([fc_1, pred])
sgd.minimize(cost)
print("Finished optimize")
place = fluid.CPUPlace()
exe = fluid.Executor(place)
exe.run(fluid.default_startup_program())
step = 10
for i in range(step):
cost_val = exe.run(feed=gen_data(),
program=fluid.default_main_program(),
fetch_list=[cost.name])
print("step=%d cost=%f" % (i, cost_val[0]))
.. py:method:: apply_gradients(params_grads)
调用self.apply_gradients
参数：
- **params_grads** (list)- 用于优化的(param, grad)对组成的列表
返回： 附加在当前Program的优化算子组成的列表
返回类型： list
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
import paddle.fluid.framework as framework
def mlp(input_x, input_y, hid_dim=128, label_dim=2):
fc_1 = fluid.layers.fc(input=input_x, size=hid_dim)
prediction = fluid.layers.fc(input=[fc_1], size=label_dim, act='softmax')
cost = fluid.layers.cross_entropy(input=prediction, label=input_y)
sum_cost = fluid.layers.reduce_mean(cost)
return sum_cost, fc_1, prediction
input_x = fluid.layers.data(name="x", shape=[32], dtype='float32')
input_y = fluid.layers.data(name="y", shape=[1], dtype='int64')
cost, fc_1, pred = mlp(input_x, input_y)
print("Finished FF")
sgd = fluid.optimizer.Adam(learning_rate=0.01)
sgd = fluid.optimizer.RecomputeOptimizer(sgd)
params_grads = sgd.backward(
cost,
startup_program=None,
parameter_list=None,
no_grad_set=None)
program = cost.block.program
with framework.program_guard(program, None):
optimize_ops = sgd.apply_gradients(params_grads)
print("Finished apply gradients")
.. py:method:: apply_optimize(loss, startup_program, params_grads)
调用self._optimizer的apply_optimize函数
参数：
- **loss** (Variable) – 用于优化过程的损失值变量
- **startup_program** (Program) – 用于初始化在parameter_list中参数的startup_program
- **params_grads** (list)- 用于优化的(param, grad)对组成的列表
返回： 附加在当前Program的算子组成的列表
返回类型： list
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
def mlp(input_x, input_y, hid_dim=128, label_dim=2):
fc_1 = fluid.layers.fc(input=input_x, size=hid_dim)
prediction = fluid.layers.fc(input=[fc_1], size=label_dim, act='softmax')
cost = fluid.layers.cross_entropy(input=prediction, label=input_y)
sum_cost = fluid.layers.reduce_mean(cost)
return sum_cost, fc_1, prediction
input_x = fluid.layers.data(name="x", shape=[32], dtype='float32')
input_y = fluid.layers.data(name="y", shape=[1], dtype='int64')
cost, fc_1, pred = mlp(input_x, input_y)
print("Finished FF")
sgd = fluid.optimizer.Adam(learning_rate=0.01)
sgd = fluid.optimizer.RecomputeOptimizer(sgd)
params_grads = sgd.backward(
cost,
startup_program=None,
parameter_list=None,
no_grad_set=None)
optimize_ops = sgd.apply_optimize(
cost, startup_program=None, params_grads=params_grads)
print("Finished apply_optimize")
.. py:method:: backward(loss, startup_program=None, parameter_list=None, no_grad_set=None, callbacks=None)
带checkpoint的backward函数
参数：
- **loss** (Variable) – 需要最小化的损失值变量
- **startup_program** (Program, 可选) – 用于初始化parameter_list中参数的 :ref:`cn_api_fluid_Program` , 默认值为None，此时将使用 :ref:`cn_api_fluid_default_startup_program`
- **parameter_list** (list, 可选) – 待更新的Parameter或者Parameter.name组成的列表， 默认值为None，此时将更新所有的Parameter
- **no_grad_set** (set, 可选) – 不需要更新的Parameter或者Parameter.name组成的的集合，默认值为None
- **callbacks** (list, 可选) – 当为某参数附加反向算子时所要运行的callables组成的列表
- **checkpoints** (list, 可选) – 一批作为checkpoints的Variables
返回： 由(param, grad)对构成的列表，其中param是参数，grad是其对应的梯度
返回类型： list
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
def mlp(input_x, input_y, hid_dim=128, label_dim=2):
fc_1 = fluid.layers.fc(input=input_x, size=hid_dim)
prediction = fluid.layers.fc(input=[fc_1], size=label_dim, act='softmax')
cost = fluid.layers.cross_entropy(input=prediction, label=input_y)
sum_cost = fluid.layers.reduce_mean(cost)
return sum_cost, fc_1, prediction
input_x = fluid.layers.data(name="x", shape=[32], dtype='float32')
input_y = fluid.layers.data(name="y", shape=[1], dtype='int64')
cost, fc_1, pred = mlp(input_x, input_y)
print("Finished FF")
sgd = fluid.optimizer.Adam(learning_rate=0.01)
sgd = fluid.optimizer.RecomputeOptimizer(sgd)
params_grads = sgd.backward(
cost,
startup_program=None,
parameter_list=None,
no_grad_set=None)
print("Finished backward")
doc/paddle/api/paddle/fluid/CPUPlace_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_fluid_CPUPlace:
CPUPlace
-------------------------------
.. py:class:: paddle.fluid.CPUPlace
``CPUPlace`` 是一个设备描述符，表示一个分配或将要分配 ``Tensor`` 或 ``LoDTensor`` 的 ``CPU`` 设备。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
cpu_place = fluid.CPUPlace()
doc/paddle/api/paddle/fluid/CUDAPinnedPlace_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_fluid_CUDAPinnedPlace:
CUDAPinnedPlace
-------------------------------
.. py:class:: paddle.fluid.CUDAPinnedPlace
``CUDAPinnedPlace`` 是一个设备描述符，它所指代的页锁定内存由 CUDA 函数 ``cudaHostAlloc()`` 在主机内存上分配，主机的操作系统将不会对这块内存进行分页和交换操作，可以通过直接内存访问技术访问，加速主机和 GPU 之间的数据拷贝。
有关 CUDA 的数据转移和 ``pinned memory``，参见 `官方文档 <https://docs.nvidia.com/cuda/cuda-c-best-practices-guide/index.html#pinned-memory>`_ 。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
place = fluid.CUDAPinnedPlace()
doc/paddle/api/paddle/fluid/CUDAPlace_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_fluid_CUDAPlace:
CUDAPlace
-------------------------------
.. py:class:: paddle.fluid.CUDAPlace
.. note::
多卡任务请先使用 FLAGS_selected_gpus 环境变量设置可见的GPU设备，下个版本将会修正 CUDA_VISIBLE_DEVICES 环境变量无效的问题。
``CUDAPlace`` 是一个设备描述符，表示一个分配或将要分配 ``Tensor`` 或 ``LoDTensor`` 的 GPU 设备。
每个 ``CUDAPlace`` 有一个 ``dev_id`` （设备id）来表明当前的 ``CUDAPlace`` 所代表的显卡编号，编号从 0 开始。
``dev_id`` 不同的 ``CUDAPlace`` 所对应的内存不可相互访问。
这里编号指的是可见显卡的逻辑编号，而不是显卡实际的编号。
可以通过 ``CUDA_VISIBLE_DEVICES`` 环境变量限制程序能够使用的 GPU 设备，程序启动时会遍历当前的可见设备，并从 0 开始为这些设备编号。
如果没有设置 ``CUDA_VISIBLE_DEVICES``，则默认所有的设备都是可见的，此时逻辑编号与实际编号是相同的。
参数：
- **id** (int，可选) - GPU的设备ID。如果为 ``None``，则默认会使用 id 为 0 的设备。默认值为 ``None``。
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
gpu_place = fluid.CUDAPlace(0)
doc/paddle/api/paddle/fluid/DataFeedDesc_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_fluid_transpiler_DistributeTranspilerConfig:
DistributeTranspilerConfig
-------------------------------
.. py:class:: paddle.fluid.transpiler.DistributeTranspilerConfig
:api_attr: 声明式编程模式（静态图)
单机任务切换为分布式任务的配置类，用户可根据需求进行配置，如指定同步/异步训练，指定节点个数及模型切分逻辑。
返回：None
.. py:attribute:: slice_var_up (bool)
是否为Pserver将张量切片， 默认为True, bool类型属性， 默认为True。该参数将指定是否将参数/梯度切分后均匀分布于多个PServer上。slice_var_up为True的情况下，会将参数均匀切分后分布于多个PServer端，使每个PServer的负载相对均衡。
.. py:attribute:: split_method (PSDispatcher)
参数分发的方式，当前支持的方法包括 :ref:`cn_api_fluid_transpiler_RoundRobin` 和 :ref:`cn_api_fluid_transpiler_HashName` 两种， 默认为RoundRobin。
注意: 尝试选择最佳方法来达到负载均衡。
.. py:attribute:: min_block_size (int)
参数切片时，最小数据块的大小，默认为8192。
注意: 根据：https://github.com/PaddlePaddle/Paddle/issues/8638#issuecomment-369912156 ， 当数据块大小超过2MB时，我们可以有效地使用带宽。如果你想更改它，请详细查看slice_variable函数。
**代码示例**
.. code-block:: python
from paddle.fluid.transpiler.ps_dispatcher import RoundRobin
import paddle.fluid as fluid
config = fluid.DistributeTranspilerConfig()
config.slice_var_up = True
config.split_method = RoundRobin
config.min_block_size = 81920
doc/paddle/api/paddle/fluid/DistributeTranspiler_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_fluid_transpiler_DistributeTranspiler:
DistributeTranspiler
-------------------------------
.. py:class:: paddle.fluid.transpiler.DistributeTranspiler (config=None)
:api_attr: 声明式编程模式（静态图)
该类可以把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（转译）的main program, 默认为 ``fluid.default_main_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_startup_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，主要有以下不同:
- 删除了参数更新optimizer相关op，参数的更新由Pserver（参数服务器）执行
- 在每个参数的反向梯度计算op后，添加了 ``Send_op`` 与 ``Recv_op`` ，用于发送参数的梯度与接受更新后的参数
参数:
- **wait_port** (bool,默认值True) - 是否等待参数服务器准备就绪后再返回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（参数服务器）侧的program。Pserver侧的program相较于原始的单机执行的program，主要有以下不同:
- 仅包含参数更新optimizer相关op，与分布式通信相关op
- 0号block仅包含变量的定义及 ``listen_and_serv_op``
- Pserver为每个需要进行更新的参数新建了一个独立的block
参数:
- **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`` 。该函数返回的 ``main_program`` 与函数 ``get_pserver_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/HashName_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_fluid_transpiler_HashName:
HashName
-------------------------------
.. py:class:: paddle.fluid.transpiler.HashName(pserver_endpoints)
:api_attr: 声明式编程模式（静态图)
该方法使用 python ``Hash()`` 函数将变量散列到多个parameter server节点。
参数:
- **pserver_endpoints** (list) - endpoint （ip:port）的 list
返回：实例化后的HashName的对象
返回类型：HashName
**代码示例**
.. code-block:: python
import paddle.fluid.transpiler.HashName as HashName
pserver_endpoints = [“127.0.0.1:6007”, “127.0.0.1:6008”]
vars = [“var1”,”var2”,”var3”,”var4”,”var5”]
rr = HashName(pserver_endpoints)
rr.dispatch(vars)
.. py:method:: reset()
该方法将重置HashName内置的计数， 计数将重置为0。
返回：无。
**代码示例**
.. code-block:: python
import paddle.fluid.transpiler.HashName as HashName
pserver_endpoints = [“127.0.0.1:6007”, “127.0.0.1:6008”]
vars = [“var1”,”var2”,”var3”,”var4”,”var5”]
rr = HashName(pserver_endpoints)
rr.reset()
doc/paddle/api/paddle/fluid/LoDTensorArray_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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/ParamAttr_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_fluid_ParamAttr:
ParamAttr
-------------------------------
.. py:class:: paddle.fluid.ParamAttr(name=None, initializer=None, learning_rate=1.0, regularizer=None, trainable=True, do_model_average=False)
.. note::
该类中的 ``gradient_clip`` 属性在2.0版本会废弃，推荐在初始化 ``optimizer`` 时设置梯度裁剪。共有三种裁剪策略： :ref:`cn_api_fluid_clip_GradientClipByGlobalNorm` 、
:ref:`cn_api_fluid_clip_GradientClipByNorm` 、 :ref:`cn_api_fluid_clip_GradientClipByValue` 。
创建一个参数属性对象，用户可设置参数的名称、初始化方式、学习率、正则化规则、是否需要训练、梯度裁剪方式、是否做模型平均等属性。
参数:
- **name** (str，可选) - 参数的名称。默认值为None，表示框架自动创建参数的名称。
- **initializer** (Initializer，可选) - 参数的初始化方式。默认值为None，表示权重参数采用Xavier初始化方式，偏置参数采用全0初始化方式。
- **learning_rate** (float) - 参数的学习率。实际参数的学习率等于全局学习率乘以参数的学习率，再乘以learning rate schedule的系数。
- **regularizer** (WeightDecayRegularizer，可选) - 正则化方法。支持两种正则化策略: :ref:`cn_api_fluid_regularizer_L1Decay` 、
:ref:`cn_api_fluid_regularizer_L2Decay` ，如果在 ``optimizer`` (例如 :ref:`cn_api_fluid_optimizer_SGDOptimizer` ) 中也
设置了正则化，``optimizer`` 中的正则化将被忽略。默认值为None，表示没有正则化。
- **trainable** (bool) - 参数是否需要训练。默认值为True，表示需要训练。
- **do_model_average** (bool) - 是否做模型平均。默认值为False，表示不做模型平均。
返回: 表示参数属性的对象。
返回类型: ParamAttr
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
w_param_attrs = fluid.ParamAttr(name="fc_weight",
learning_rate=0.5,
regularizer=fluid.regularizer.L2Decay(1.0),
trainable=True)
print(w_param_attrs.name) # "fc_weight"
x = fluid.layers.data(name='X', shape=[1], dtype='float32')
y_predict = fluid.layers.fc(input=x, size=10, param_attr=w_param_attrs)
doc/paddle/api/paddle/fluid/Tensor_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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/Variable_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_fluid_Variable:
Variable
-------------------------------
.. py:class:: paddle.fluid.Variable
**注意：**
**1. 请不要直接调用** `Variable` **的构造函数，因为这会造成严重的错误发生！**
**2. 在静态图形模式下：请使用** `Block.create_var` **创建一个静态的** `Variable` **，该静态的** `Variable` **在使用** :ref:`cn_api_fluid_executor` **执行前是没有实际数据的。**
**3. 在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下：请使用** :ref:`cn_api_fluid_dygraph_to_variable` 创建一个拥有实际数据的 :ref:`api_guide_Variable`
在Fluid中，OP的每个输入和输出都是 :ref:`api_guide_Variable` 。多数情况下， :ref:`api_guide_Variable` 用于保存不同种类的数据或训练标签。
:ref:`api_guide_Variable` 总是属于某一个 :ref:`api_guide_Block` 。所有 :ref:`api_guide_Variable` 都有其自己的 ``name`` ,不同 :ref:`api_guide_Block` 中的两个 :ref:`api_guide_Variable` 可以具有相同的名称。如果使用的 **不是** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式，那么同一个 :ref:`api_guide_Block` 中的两个或更多 :ref:`api_guide_Variable` 拥有相同 ``name`` 将意味着他们会共享相同的内容。通常我们使用这种方式来实现 **参数共享**
:ref:`api_guide_Variable` 有很多种。它们每种都有自己的属性和用法。请参考 `framework.proto <https://github.com/PaddlePaddle/Paddle/blob/develop/paddle/fluid/framework/framework.proto>`_ 以获得详细信息。 :ref:`api_guide_Variable` 的大多数成员变量可以设置为 ``None``。它的意思是它不可用或稍后指定。
如果您希望创建一个 :ref:`api_guide_Variable` 那么可以参考如下示例：
**示例代码：**
在静态图形模式下：
.. code-block:: python
import paddle.fluid as fluid
cur_program = fluid.Program()
cur_block = cur_program.current_block()
new_variable = cur_block.create_var(name="X",
shape=[-1, 23, 48],
dtype='float32')
在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下：
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
with fluid.dygraph.guard():
new_variable = fluid.dygraph.to_variable(np.arange(10))
.. py:method:: detach()
**注意：**
**1. 该API只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
**2.** ``detach`` **后的** :ref:`api_guide_Variable` **将会成为临时变量**
产生一个新的，和当前计算图分离的，但是拥有当前 :ref:`api_guide_Variable` 其内容的临时变量
返回：一个新的，和当前计算图分离的，但是拥有当前 :ref:`api_guide_Variable` 其内容的临时 :ref:`api_guide_Variable`
返回类型：（:ref:`api_guide_Variable` | 和输入的 ``Dtype`` 一致）
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
from paddle.fluid.dygraph.base import to_variable
from paddle.fluid.dygraph import Linear
import numpy as np
data = np.random.uniform(-1, 1, [30, 10, 32]).astype('float32')
with fluid.dygraph.guard():
linear = Linear(32, 64)
data = to_variable(data)
x = linear(data)
y = x.detach()
.. py:method:: numpy()
**注意：**
**1. 该API只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
返回一个 ``ndarray`` 来表示当前 :ref:`api_guide_Variable` 的值
返回：``numpy`` 的数组，表示当前 :ref:`api_guide_Variable` 的实际值
返回类型：ndarray，``dtype`` 和输入的 ``dtype`` 一致
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
from paddle.fluid.dygraph.base import to_variable
from paddle.fluid.dygraph import Linear
import numpy as np
data = np.random.uniform(-1, 1, [30, 10, 32]).astype('float32')
with fluid.dygraph.guard():
linear = Linear(32, 64)
data = to_variable(data)
x = linear(data)
print(x.numpy())
.. py:method:: set_value()
**注意：**
**1. 该API只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
为此 :ref:`api_guide_Variable` 设置一个新的值。
**参数:**
- **value**: ( :ref:`api_guide_Variable` 或 ``ndarray`` ) 要赋值给此 :ref:`api_guide_Variable` 的新的值。
返回：无
抛出异常： ``ValueError`` - 当要赋于的新值的 ``shape`` 和此 :ref:`api_guide_Variable` 原有的 ``shape`` 不同时，抛出 ``ValueError`` 。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
from paddle.fluid.dygraph.base import to_variable
from paddle.fluid.dygraph import Linear
import numpy as np
data = np.ones([3, 1024], dtype='float32')
with fluid.dygraph.guard():
linear = fluid.dygraph.Linear(1024, 4)
t = to_variable(data)
linear(t) # 使用默认参数值调用前向
custom_weight = np.random.randn(1024, 4).astype("float32")
linear.weight.set_value(custom_weight) # 将参数修改为自定义的值
out = linear(t) # 使用新的参数值调用前向
.. py:method:: backward()
**注意：**
**1. 该API只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
**2. 由于如果该** :ref:`api_guide_Variable` **以上没有任何地方需要梯度，那么仅仅设置该** :ref:`api_guide_Variable` **的梯度为** ``1`` **是没有意义的。因此，这种情况下，为了节省一些计算，我们不去产生该** :ref:`api_guide_Variable` **的梯度**
从该节点开始执行反向
**参数:**
- **backward_strategy**: ( :ref:`cn_api_fluid_dygraph_BackwardStrategy` ) 使用何种 :ref:`cn_api_fluid_dygraph_BackwardStrategy` 聚合反向的梯度
返回：无
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
x = np.ones([2, 2], np.float32)
with fluid.dygraph.guard():
inputs2 = []
for _ in range(10):
tmp = fluid.dygraph.base.to_variable(x)
# 如果这里我们不为输入tmp设置stop_gradient=False，那么后面loss2也将因为这个链路都不需要梯度
# 而不产生梯度
tmp.stop_gradient=False
inputs2.append(tmp)
ret2 = fluid.layers.sums(inputs2)
loss2 = fluid.layers.reduce_sum(ret2)
backward_strategy = fluid.dygraph.BackwardStrategy()
backward_strategy.sort_sum_gradient = True
loss2.backward(backward_strategy)
.. py:method:: gradient()
**注意：**
**1. 该API只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
**2. 由于如果该** :ref:`api_guide_Variable` **以上没有任何地方需要梯度，那么仅仅设置该** :ref:`api_guide_Variable` **的梯度为** ``1`` **是没有意义的。因此，这种情况下，为了节省一些计算，我们不去产生该** :ref:`api_guide_Variable` **的梯度**
获取该 :ref:`api_guide_Variable` 的梯度值
返回：如果 :ref:`api_guide_Variable` 的类型是LoDTensor（参见 :ref:`cn_user_guide_lod_tensor` ），返回该 :ref:`api_guide_Variable` 类型为 ``ndarray`` 的梯度值；如果 :ref:`api_guide_Variable` 的类型是SelectedRows，返回该 :ref:`api_guide_Variable` 类型为 ``ndarray`` 的梯度值和类型为 ``ndarray`` 的词id组成的tuple。
返回类型：``ndarray`` 或者 ``tuple of ndarray`` , 返回类型 ``tuple of ndarray`` 仅在 :ref:`cn_api_fluid_dygraph_Embedding` 层稀疏更新时产生。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
# example1: 返回ndarray
x = np.ones([2, 2], np.float32)
with fluid.dygraph.guard():
inputs2 = []
for _ in range(10):
tmp = fluid.dygraph.base.to_variable(x)
tmp.stop_gradient=False
inputs2.append(tmp)
ret2 = fluid.layers.sums(inputs2)
loss2 = fluid.layers.reduce_sum(ret2)
backward_strategy = fluid.dygraph.BackwardStrategy()
backward_strategy.sort_sum_gradient = True
loss2.backward(backward_strategy)
print(loss2.gradient())
# example2: 返回tuple of ndarray
with fluid.dygraph.guard():
embedding = fluid.dygraph.Embedding(
size=[20, 32],
param_attr='emb.w',
is_sparse=True)
x_data = np.arange(12).reshape(4, 3).astype('int64')
x_data = x_data.reshape((-1, 3, 1))
x = fluid.dygraph.base.to_variable(x_data)
out = embedding(x)
out.backward()
print(embedding.weight.gradient())
.. py:method:: clear_gradient()
**注意：**
**1. 该API只在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
**2. 只有当该** :ref:`api_guide_Variable` **有梯度时才可调用，通常我们都会为参数调用这个方法，因为临时变量的梯度将会在其离开作用域时被** ``python`` **自动清除**
设置该 :ref:`api_guide_Variable` 的梯度为零
返回：无
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
x = np.ones([2, 2], np.float32)
with fluid.dygraph.guard():
inputs2 = []
for _ in range(10):
tmp = fluid.dygraph.base.to_variable(x)
tmp.stop_gradient=False
inputs2.append(tmp)
ret2 = fluid.layers.sums(inputs2)
loss2 = fluid.layers.reduce_sum(ret2)
backward_strategy = fluid.dygraph.BackwardStrategy()
backward_strategy.sort_sum_gradient = True
loss2.backward(backward_strategy)
print(loss2.gradient())
loss2.clear_gradient()
print("After clear {}".format(loss2.gradient()))
.. py:method:: to_string()
**注意：**
**1. 该API只在非** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效**
获取该 :ref:`api_guide_Variable` 的静态描述字符串
**参数：（仅在非** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下生效）**
- **throw_on_error** (bool) - 是否在没有设置必需字段时抛出异常。
- **with_details** (bool) - 值为true时，打印更多关于 :ref:`api_guide_Variable` 的信息，如 ``error_clip`` , ``stop_gradient`` 等
返回：用于静态描述该 :ref:`api_guide_Variable` 的字符串
返回： 将Program转换为字符串
返回类型： str
抛出异常： ``ValueError`` - 当 ``throw_on_error == true`` ，当没有设置任何必需的字段时，抛出 ``ValueError`` 。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
cur_program = fluid.Program()
cur_block = cur_program.current_block()
new_variable = cur_block.create_var(name="X",
shape=[-1, 23, 48],
dtype='float32')
print(new_variable.to_string(True))
print("\n=============with detail===============\n")
print(new_variable.to_string(True, True))
.. py:method:: astype(self, dtype)
将该 :ref:`api_guide_Variable` 中的数据转换成目标 ``Dtype``
**参数：**
- **self** ( :ref:`api_guide_Variable` ) - 当前 :ref:`api_guide_Variable` ， 用户不需要传入。
- **dtype** (int | float | float64) - 希望转换成的 ``Dtype``
返回：一个全新的转换了 ``Dtype`` 的 :ref:`api_guide_Variable`
返回类型： :ref:`api_guide_Variable`
**示例代码**
在静态图模式下：
.. code-block:: python
import paddle.fluid as fluid
startup_prog = fluid.Program()
main_prog = fluid.Program()
with fluid.program_guard(startup_prog, main_prog):
original_variable = fluid.data(name = "new_variable", shape=[2,2], dtype='float32')
new_variable = original_variable.astype('int64')
print("new var's dtype is: {}".format(new_variable.dtype))
在 `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ 模式下：
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
x = np.ones([2, 2], np.float32)
with fluid.dygraph.guard():
original_variable = fluid.dygraph.to_variable(x)
print("original var's dtype is: {}, numpy dtype is {}".format(original_variable.dtype, original_variable.numpy().dtype))
new_variable = original_variable.astype('int64')
print("new var's dtype is: {}, numpy dtype is {}".format(new_variable.dtype, new_variable.numpy().dtype))
属性
::::::::::::
.. py:attribute:: stop_gradient
**注意：该属性在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下除参数以外默认值为** ``True`` **，而参数的该属性默认值为** ``False`` **。在静态图下所有的** :ref:`api_guide_Variable` **该属性默认值都为** ``False``
是否从此 :ref:`api_guide_Variable` 开始，之前的相关部分都停止梯度计算
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
with fluid.dygraph.guard():
value0 = np.arange(26).reshape(2, 13).astype("float32")
value1 = np.arange(6).reshape(2, 3).astype("float32")
value2 = np.arange(10).reshape(2, 5).astype("float32")
linear = fluid.Linear(13, 5, dtype="float32")
linear2 = fluid.Linear(3, 3, dtype="float32")
a = fluid.dygraph.to_variable(value0)
b = fluid.dygraph.to_variable(value1)
c = fluid.dygraph.to_variable(value2)
out1 = linear(a)
out2 = linear2(b)
out1.stop_gradient = True
out = fluid.layers.concat(input=[out1, out2, c], axis=1)
out.backward()
# 可以发现这里linear的参数变成了
assert (linear.weight.gradient() == 0).all()
assert (out1.gradient() == 0).all()
.. py:attribute:: persistable
**注意：该属性我们即将废弃，此介绍仅为了帮助用户理解概念， 1.6版本后用户可以不再关心该属性**
**1. 该属性除参数以外默认值为** ``False`` **，而参数的该属性默认值为** ``True`` 。
**2. 该属性在** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下一经初始化即不能修改，这是由于在动态执行时，** :ref:`api_guide_Variable` **的生命周期将由** ``Python`` **自行控制不再需要通过该属性来修改**
此 :ref:`api_guide_Variable` 是否是长期存活的 :ref:`api_guide_Variable`
.. py:attribute:: name
**注意：在非** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下，那么同一个** :ref:`api_guide_Block` **中的两个或更多** :ref:`api_guide_Variable` **拥有相同** ``name`` **将意味着他们会共享相同的内容。通常我们使用这种方式来实现参数共享**
此 :ref:`api_guide_Variable` 的名字（str）
.. py:attribute:: shape
**注意：该属性是只读属性**
此 :ref:`api_guide_Variable` 的维度
.. py:attribute:: dtype
**注意：该属性是只读属性**
此 :ref:`api_guide_Variable` 的实际数据类型
.. py:attribute:: lod_level
**注意：**
**1. 该属性是只读属性**
**2.** `Dygraph <../../user_guides/howto/dygraph/DyGraph.html>`_ **模式下，不支持该属性，该值为零**
此 :ref:`api_guide_Variable` 的 ``LoD`` 信息，关于 ``LoD`` 可以参考 :ref:`api_fluid_LoDTensor` 相关内容
.. py:attribute:: type
**注意：该属性是只读属性**
此 :ref:`api_guide_Variable` 的内存模型，例如是：:ref:`api_fluid_LoDTensor`， 或者SelectedRows
doc/paddle/api/paddle/fluid/backward/append_backward_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_fluid_backward_append_backward:
append_backward
-------------------------------
.. py:function:: paddle.fluid.backward.append_backward(loss, parameter_list=None, no_grad_set=None, callbacks=None)
:api_attr: 声明式编程模式（静态图)
该接口将向主程序（``main_program``）追加反向部分 。
完整的神经网络训练由前向和反向传播组成。但是当我们配置网络时，我们只需要指定其前向部分。
该接口使用链式法则，能够根据前向部分自动生成反向部分。
在大多数情况下，用户无需手动调用此接口，它将由优化器（``Optimizer``）的 ``minimize`` 函数自动调用。
参数：
- **loss** ( :ref:`api_guide_Variable` ) - 网络的损失变量。
- **parameter_list** （list [Variable|str]，可选）- 指定优化器需要更新的参数或参数名称列表。如果为 ``None`` ，则将更新所有参数。默认值为 ``None``。
- **no_grad_set** （set [Variable|str]，可选）- 在 `block0` ( :ref:`api_guide_Block` ) 中要忽略梯度的 :ref:`api_guide_Variable` 的名字的集合。所有的 :ref:`api_guide_Block` 中带有 ``stop_gradient = True`` 的所有 :ref:`api_guide_Variable` 的名字都会被自动添加到此集合中。如果该参数不为 ``None``，则会将该参数集合的内容添加到默认的集合中。默认值为 ``None``。
- **callbacks** （list [callable object]，可选）- 回调函数列表。用于在反向传播构建中执行一些自定义作业。每次将新的梯度OP添加到程序中时，将调用其中的所有可调用对象。可调用对象必须有两个输入参数： :ref:`api_guide_Block` 和 ``context`` 。 :ref:`api_guide_Block` 是将被添加到新梯度算子的块。 ``context`` 是一个映射，其键是梯度 :ref:`api_guide_Variable` 名，值是对应的原始 :ref:`api_guide_Variable` 。除此之外， ``context`` 还有另一个特殊的键值对：键是字符串 ``__ current_op_desc__`` ，值是刚刚触发可调用对象的梯度OP的 ``op_desc`` 。默认值为 ``None``。
返回： 参数及其梯度 :ref:`api_guide_Variable` 的元组的列表。元组的第一个值为参数，第二个值为该参数的梯度 :ref:`api_guide_Variable` 。
返回类型： list[( :ref:`api_guide_Variable` , :ref:`api_guide_Variable` )]
抛出：
- ``AssertionError`` - 如果 loss 不是 :ref:`api_guide_Variable` 的实例。
**示例代码**
.. code-block:: python
import paddle.fluid as fluid
x = fluid.data(name='x', shape=[None, 13], dtype='int64')
y = fluid.data(name='y', shape=[None, 1], dtype='float32')
x_emb = fluid.embedding(x, size=[100, 256])
y_predict = fluid.layers.fc(input=x_emb, size=1, act=None, name='my_fc')
loss = fluid.layers.square_error_cost(input=y_predict, label=y)
avg_loss = fluid.layers.mean(loss)
# 获取main_program中所有weight参数, 不包括bias.
all_weights = [param for param in fluid.default_main_program().block(0).all_parameters() if 'w_' in param.name]
all_weights_name = [w.name for w in all_weights]
# 若parameter_list为默认值(None), 则返回包含所有param_grad的list
p_g_list1 = fluid.backward.append_backward(loss=avg_loss)
# output: [(embedding_0.w_0, embedding_0.w_0@GRAD), (my_fc.w_0, my_fc.w_0@GRAD), (my_fc.b_0, my_fc.b_0@GRAD)]
# 返回与传入parameter_list对应的param_grad的list, 传入的parameter_list可以是 param(Variable类型)的list
p_g_list2 = fluid.backward.append_backward(loss=avg_loss, parameter_list=all_weights)
# output: [(embedding_0.w_0, embedding_0.w_0@GRAD), (my_fc.w_0, my_fc.w_0@GRAD)]
# 传入的parameter_list也可以是值为param.name(str类型)的list
p_g_list3 = fluid.backward.append_backward(loss=avg_loss, parameter_list=all_weights_name)
# output: [(embedding_0.w_0, embedding_0.w_0@GRAD), (my_fc.w_0, my_fc.w_0@GRAD)]
# no_grad_set可以是set[Variables]类型，表示梯度将在这些Variables处截断
p_g_list4 = fluid.backward.append_backward(loss=avg_loss, no_grad_set=set([x_emb]))
# output: [(my_fc.w_0, my_fc.w_0@GRAD), (my_fc.b_0, my_fc.b_0@GRAD)]
# no_grad_set也可以是set[Variable.names]类型。当参数Variable是在layers内部创建，且不方便显式地指定时，可以使用set[Variable.names]
p_g_list5 = fluid.backward.append_backward(loss=avg_loss, no_grad_set=set(['my_fc.b_0']))
# output: [(embedding_0.w_0, embedding_0.w_0@GRAD), (my_fc.w_0, my_fc.w_0@GRAD)]
# 返回为[], 因为所有的param_grad均被传入的no_grad_set过滤掉了
p_g_list6 = fluid.backward.append_backward(loss=avg_loss, parameter_list=all_weights, no_grad_set=set(all_weights))
doc/paddle/api/paddle/fluid/backward_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
=======================
fluid.backward
=======================
.. toctree::
:maxdepth: 1
backward_cn/append_backward_cn.rst
backward_cn/gradients_cn.rst
doc/paddle/api/paddle/fluid/clip/ErrorClipByValue_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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/clip_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_fluid_layers_clip:
clip
-------------------------------
.. py:function:: paddle.fluid.layers.clip(x, min, max, name=None)
:alias_main: paddle.nn.clip
:alias: paddle.nn.clip,paddle.nn.clip.clip
:old_api: paddle.fluid.layers.clip
该OP对输入Tensor每个元素的数值进行裁剪，使得输出Tensor元素的数值被限制在区间[min, max]内。具体的计算公式为如下。
.. math::
Out = MIN(MAX(x,min),max)
参数：
- **x** (Variable)- 多维Tensor，数据类型为float32
- **min** (float)- 最小值，输入Tensor中小于该值的元素由min代替。
- **max** (float)- 最大值，输入Tensor中大于该值的元素由max替换。
- **name** (None|str) – 该参数供开发人员打印调试信息时使用，具体用法请参见 :ref:`api_guide_Name` ，默认值为None。
返回： 对元素的数值进行裁剪之后的Tesnor，与输入x具有相同的shape和数据类型
返回类型：Variable
**代码示例：**
.. code-block:: python
import paddle.fluid as fluid
input = fluid.layers.data(
name='data', shape=[1], dtype='float32')
reward = fluid.layers.clip(x=input, min=-1.0, max=1.0)
doc/paddle/api/paddle/fluid/contrib/BeamSearchDecoder_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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/contrib/decoder/BeamSearchDecoder_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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/contrib/decoder/beam_search_decoder/BeamSearchDecoder_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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/data_feed_desc/DataFeedDesc_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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/data_feeder/DataFeeder_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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/dataloader/BatchSampler_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_io_cn_BatchSampler:
BatchSampler
-------------------------------
:doc_source: paddle.fluid.dataloader.BatchSampler
doc/paddle/api/paddle/fluid/dataloader/Dataset_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_io_cn_Dataset:
Dataset
-------------------------------
:doc_source: paddle.fluid.dataloader.Dataset
doc/paddle/api/paddle/fluid/dataloader/batch_sampler/BatchSampler_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_io_cn_BatchSampler:
BatchSampler
-------------------------------
:doc_source: paddle.fluid.dataloader.BatchSampler
doc/paddle/api/paddle/fluid/dataloader/dataset/Dataset_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_io_cn_Dataset:
Dataset
-------------------------------
:doc_source: paddle.fluid.dataloader.Dataset
doc/paddle/api/paddle/fluid/device_guard_cn.rst 已删除 100755 → 0
浏览文件 @ 7464e15e
.. _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/disable_dygraph_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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/disable_imperative_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_paddle_cn_disable_imperative:
disable_imperative
-------------------------------
:doc_source: paddle.fluid.dygraph.base.disable_dygraph
doc/paddle/api/paddle/fluid/dygraph/Conv2DTranspose_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_fluid_dygraph_Conv2DTranspose:
Conv2DTranspose
-------------------------------
.. py:class:: paddle.fluid.dygraph.Conv2DTranspose(num_channels, num_filters, filter_size, output_size=None, padding=0, stride=1, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, dtype="float32")
该接口用于构建 ``Conv2DTranspose`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。其将在神经网络中构建一个二维卷积转置层（Convlution2D Transpose Layer），其根据输入（input）、滤波器参数（num_filters、filter_size）、步长（stride）、填充（padding）、膨胀系数（dilation）、组数（groups）来计算得到输出特征图。输入和输出是 ``NCHW`` 格式，N是批数据大小，C是特征图个数，H是特征图高度，W是特征图宽度。滤波器的维度是 [M, C, H, W] ，M是输入特征图个数，C是输出特征图个数，H是滤波器高度，W是滤波器宽度。如果组数大于1，C等于输入特征图个数除以组数的结果。如果提供了偏移属性和激活函数类型，卷积的结果会和偏移相加，激活函数会作用在最终结果上。转置卷积的计算过程相当于卷积的反向计算，转置卷积又被称为反卷积（但其实并不是真正的反卷积）。详情请参考： `Conv2DTranspose <http://www.matthewzeiler.com/wp-content/uploads/2017/07/cvpr2010.pdf>`_ 。
输入 ``X`` 和输出 ``Out`` 的函数关系如下：
.. math::
Out=\sigma (W*X+b)\\
其中：
- :math:`X` ：输入特征图， ``NCHW`` 格式的 ``Tensor``
- :math:`W` ：滤波器，维度为 [M, C, H, W] 的 ``Tensor``
- :math:`*` ：卷积操作
- :math:`b` ：偏移值，2-D ``Tensor`` ，维度为 ``[M,1]``
- :math:`\sigma` ：激活函数
- :math:`Out` ：输出值， ``Out`` 和 ``X`` 的维度可能不同
**输出维度计算示例**
- 输入：
输入维度： :math:`(N,C_{in},H_{in},W_{in})`
滤波器维度： :math:`(C_{in},C_{out},H_{f},W_{f})`
- 输出：
输出维度： :math:`(N,C_{out},H_{out},W_{out})`
- 其中
.. math::
& H'_{out} = (H_{in}-1)*strides[0]-2*paddings[0]+dilations[0]*(H_f-1)+1
& W'_{out} = (W_{in}-1)*strides[1]-2*paddings[1]+dilations[1]*(W_f-1)+1
& H_{out}\in[H'_{out},H'_{out} + strides[0])
& W_{out}\in[W'_{out},W'_{out} + strides[1])
参数：
- **num_channels** (int) - 输入图像的通道数。
- **num_filters** (int) - 滤波器的个数，和输出特征图个数相同。
- **filter_size** (int|tuple) - 滤波器大小。如果 ``filter_size`` 是一个元组，则必须包含两个整型数，分别表示滤波器高度和宽度。否则，表示滤波器高度和宽度均为 ``filter_size`` 。
- **output_size** (int|tuple, 可选) - 输出特征图的大小。如果 ``output_size`` 是一个元组，则必须包含两个整型数，分别表示特征图高度和宽度。如果 ``output_size`` 是整型，表示特征图高度和宽度均为 ``output_size`` 。如果 ``output_size`` 为None，则会根据 ``filter_size`` 、 ``padding`` 和 ``stride`` 来计算 ``output_size`` 。如果 ``output_size`` 和 ``filter_size`` 同时指定，那么它们应满足上面的公式。默认值：None。
- **padding** (int|tuple, 可选) - 填充大小。如果 ``padding`` 为元组，则必须包含两个整型数，分别表示竖直和水平边界填充大小。否则，表示竖直和水平边界填充大小均为 ``padding`` 。默认值：0。
- **stride** (int|tuple, 可选) - 步长大小。如果 ``stride`` 为元组，则必须包含两个整型数，分别表示垂直和水平滑动步长。否则，表示垂直和水平滑动步长均为 ``stride`` 。默认值：1。
- **dilation** (int|tuple, 可选) - 膨胀系数大小。如果 ``dialation`` 为元组，则必须包含两个整型数，分别表示垂直和水平膨胀系数。否则，表示垂直和水平膨胀系数均为 ``dialation`` 。默认值：1。
- **groups** (int, 可选) - 二维卷积层的组数。根据Alex Krizhevsky的深度卷积神经网络（CNN）论文中的分组卷积：当group=2，滤波器的前一半仅和输入特征图的前一半连接。滤波器的后一半仅和输入特征图的后一半连接。默认值：1。
- **param_attr** (ParamAttr, 可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **bias_attr** (ParamAttr|bool, 可选) - 指定偏置参数属性的对象。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **use_cudnn** (bool, 可选) - 是否使用cudnn内核，只有已安装cudnn库时才有效。默认值:True。
- **act** (str, 可选) - 应用于输出上的激活函数，如tanh、softmax、sigmoid，relu等，支持列表请参考 :ref:`api_guide_activations` ，默认值：None。
- **dtype** (str, 可选) - 数据类型，可以为"float32"或"float64"。默认值："float32"。
返回：无
**代码示例**
.. code-block:: python
import paddle.fluid as fluid
import numpy as np
with fluid.dygraph.guard():
data = np.random.random((3, 32, 32, 5)).astype('float32')
conv2DTranspose = fluid.dygraph.nn.Conv2DTranspose(
num_channels=32, num_filters=2, filter_size=3)
ret = conv2DTranspose(fluid.dygraph.base.to_variable(data))
属性
::::::::::::
.. py:attribute:: weight
本层的可学习参数，类型为 ``Parameter``
.. py:attribute:: bias
本层的可学习偏置，类型为 ``Parameter``
doc/paddle/api/paddle/fluid/dygraph/Conv2D_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
Conv2D
-------------------------------
.. py:class:: paddle.nn.Conv2d(num_channels, num_filters, filter_size, padding=0, stride=1, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None, data_format="NCHW", dtype="float32")
:alias_main: paddle.nn.Conv2D
:alias: paddle.nn.Conv2D,paddle.nn.layer.Conv2D,paddle.nn.layer.conv.Conv2D
**二维卷积层**
该OP是二维卷积层（convolution2D layer），根据输入、滤波器、步长（stride）、填充（padding）、膨胀比例（dilations）一组参数计算输出特征层大小。输入和输出是NCHW或NHWC格式，其中N是批尺寸，C是通道数，H是特征高度，W是特征宽度。滤波器是MCHW格式，M是输出图像通道数，C是输入图像通道数，H是滤波器高度，W是滤波器宽度。如果组数(groups)大于1，C等于输入图像通道数除以组数的结果。详情请参考UFLDL's : `卷积 <http://ufldl.stanford.edu/tutorial/supervised/FeatureExtractionUsingConvolution/>`_ 。如果bias_attr不为False，卷积计算会添加偏置项。如果指定了激活函数类型，相应的激活函数会作用在最终结果上。
对每个输入X，有等式：
.. math::
Out = \sigma \left ( W * X + b \right )
其中：
- :math:`X` ：输入值，NCHW或NHWC格式的4-D Tensor
- :math:`W` ：滤波器值，MCHW格式的4-D Tensor
- :math:`*` ：卷积操作
- :math:`b` ：偏置值，2-D Tensor，形状为 ``[M,1]``
- :math:`\sigma` ：激活函数
- :math:`Out` ：输出值，NCHW或NHWC格式的4-D Tensor， 和 ``X`` 的形状可能不同
**示例**
- 输入：
输入形状：:math:`（N,C_{in},H_{in},W_{in}）`
滤波器形状： :math:`（C_{out},C_{in},H_{f},W_{f}）`
- 输出：
输出形状： :math:`（N,C_{out},H_{out},W_{out}）`
其中
.. math::
H_{out} &= \frac{\left ( H_{in} + padding\_height\_top + padding\_height\_bottom-\left ( dilation[0]*\left ( H_{f}-1 \right )+1 \right ) \right )}{stride[0]}+1
W_{out} &= \frac{\left ( W_{in} + padding\_width\_left + padding\_width\_right -\left ( dilation[1]*\left ( W_{f}-1 \right )+1 \right ) \right )}{stride[1]}+1
如果 ``padding`` = "SAME":
.. math::
H_{out} = \frac{(H_{in} + stride[0] - 1)}{stride[0]}
.. math::
W_{out} = \frac{(W_{in} + stride[1] - 1)}{stride[1]}
如果 ``padding`` = "VALID":
.. math::
H_{out} = \frac{\left ( H_{in} -\left ( dilation[0]*\left ( H_{f}-1 \right )+1 \right ) \right )}{stride[0]}+1
W_{out} = \frac{\left ( W_{in} -\left ( dilation[1]*\left ( W_{f}-1 \right )+1 \right ) \right )}{stride[1]}+1
参数：
- **num_channels** (int) - 输入图像的通道数。
- **num_filters** (int) - 滤波器（卷积核）的个数。和输出图像通道相同。
- **filter_size** (int|list|tuple) - 滤波器大小。如果它是一个列表或元组，则必须包含两个整数值：（filter_size_height，filter_size_width）。若为一个整数，filter_size_height = filter_size_width = filter_size。
- **padding** (int|list|tuple|str，可选) - 填充大小。如果它是一个字符串，可以是"VALID"或者"SAME"，表示填充算法，计算细节可参考上述 ``padding`` = "SAME"或 ``padding`` = "VALID" 时的计算公式。如果它是一个元组或列表，它可以有3种格式：(1)包含4个二元组：当 ``data_format`` 为"NCHW"时为 [[0,0], [0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right]]，当 ``data_format`` 为"NHWC"时为[[0,0], [padding_height_top, padding_height_bottom], [padding_width_left, padding_width_right], [0,0]]；(2)包含4个整数值：[padding_height_top, padding_height_bottom, padding_width_left, padding_width_right]；(3)包含2个整数值：[padding_height, padding_width]，此时padding_height_top = padding_height_bottom = padding_height， padding_width_left = padding_width_right = padding_width。若为一个整数，padding_height = padding_width = padding。默认值：0。
- **stride** (int|list|tuple，可选) - 步长大小。滤波器和输入进行卷积计算时滑动的步长。如果它是一个列表或元组，则必须包含两个整型数：（stride_height,stride_width）。若为一个整数，stride_height = stride_width = stride。默认值：1。
- **dilation** (int|list|tuple，可选) - 膨胀比例大小。空洞卷积时会使用该参数，滤波器对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息。如果膨胀比例为列表或元组，则必须包含两个整型数：（dilation_height,dilation_width）。若为一个整数，dilation_height = dilation_width = dilation。默认值：1。
- **groups** (int，可选) - 二维卷积层的组数。根据Alex Krizhevsky的深度卷积神经网络（CNN）论文中的成组卷积：当group=n，输入和滤波器分别根据通道数量平均分为n组，第一组滤波器和第一组输入进行卷积计算，第二组滤波器和第二组输入进行卷积计算，……，第n组滤波器和第n组输入进行卷积计算。默认值：1。
- **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **bias_attr** （ParamAttr|bool，可选）- 指定偏置参数属性的对象。若 ``bias_attr`` 为bool类型，只支持为False，表示没有偏置参数。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **use_cudnn** （bool，可选）- 是否使用cudnn内核。只有已安装cudnn库时才有效。默认值：True。
- **act** (str，可选) - 激活函数类型， 如tanh、softmax、sigmoid，relu等，支持列表请参考 :ref:`api_guide_activations` 。如果设为None，则未添加激活函数。默认值：None。
- **name** (str，可选) – 具体用法请参见 :ref:`cn_api_guide_Name` ，一般无需设置，默认值：None。
- **data_format** (str，可选) - 指定输入的数据格式，输出的数据格式将与输入保持一致，可以是"NCHW"和"NHWC"。N是批尺寸，C是通道数，H是特征高度，W是特征宽度。默认值："NCHW"。
- **dtype** (str, 可选) – 权重的数据类型，可以为float32或float64。默认为float32。
属性
::::::::::::
.. py:attribute:: weight
本层的可学习参数，类型为 ``Parameter``
.. py:attribute:: bias
本层的可学习偏置，类型为 ``Parameter``
返回: 无。
抛出异常：
- ``ValueError`` - 如果 ``use_cudnn`` 不是bool值。
- ``ValueError`` - 如果 ``data_format`` 既不是"NCHW"也不是"NHWC"。
- ``ValueError`` - 如果 ``input`` 的通道数未被明确定义。
- ``ValueError`` - 如果 ``padding`` 是字符串，既不是"SAME"也不是"VALID"。
- ``ValueError`` - 如果 ``padding`` 含有4个二元组，与批尺寸对应维度的值不为0或者与通道对应维度的值不为0。
- ``ShapeError`` - 如果输入不是4-D Tensor。
- ``ShapeError`` - 如果输入和滤波器的维度大小不相同。
- ``ShapeError`` - 如果输入的维度大小与 ``stride`` 之差不是2。
- ``ShapeError`` - 如果输出的通道数不能被 ``groups`` 整除。
**代码示例**：
.. code-block:: python
import numpy as np
from paddle import fluid
import paddle.fluid.dygraph as dg
from paddle import nn
x = np.random.uniform(-1, 1, (2, 4, 8, 8)).astype('float32')
place = fluid.CPUPlace()
with dg.guard(place):
x_var = dg.to_variable(x)
conv = nn.Conv2D(4, 6, (3, 3))
y_var = conv(x_var)
y_np = y_var.numpy()
print(y_np.shape)
# (2, 6, 6, 6)
doc/paddle/api/paddle/fluid/dygraph/Conv3DTranspose_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_fluid_dygraph_Conv3DTranspose:
Conv3DTranspose
-------------------------------
.. py:class:: paddle.fluid.dygraph.Conv3DTranspose(num_channels, num_filters, filter_size, output_size=None, padding=0, stride=1, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, name=None, dtype="float32")
该接口用于构建 ``Conv3DTranspose`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。3D卷积转置层（Convlution3D transpose layer)根据输入（input）、滤波器（filter）和卷积核膨胀（dilations）、步长（stride）、填充来计算输出特征层大小或者通过output_size指定输出特征层大小。输入(Input)和输出(Output)为NCDHW格式。其中 ``N`` 为batch大小， ``C`` 为通道数（channel）, ``D`` 为特征深度, ``H`` 为特征高度， ``W`` 为特征宽度。转置卷积的计算过程相当于卷积的反向计算。转置卷积又被称为反卷积（但其实并不是真正的反卷积）。欲了解卷积转置层细节，请参考下面的说明和 参考文献_ 。如果参数bias_attr不为False, 转置卷积计算会添加偏置项。如果act不为None，则转置卷积计算之后添加相应的激活函数。
.. _参考文献: https://arxiv.org/abs/1603.07285
输入 :math:`X` 和输出 :math:`Out` 函数关系如下：
.. math::
\\Out=\sigma (W*X+b)\\
其中：
- :math:`X` : 输入图像，具有NCDHW格式的张量（Tensor）
- :math:`W` : 滤波器，具有NCDHW格式的张量（Tensor）
- :math:`*` : 卷积操作（注意：转置卷积本质上的计算还是卷积）
- :math:`b` : 偏置(bias)，维度为 :math:`[M,1]` 的2D Tensor
- :math:`σ` : 激活函数
- :math:`Out` : 输出值， ``Out`` 和 ``X`` 的 shape可能不一样
**样例**
输入:
输入Tensor的维度：:math:`[N,C_{in}, D_{in}, H_{in}, W_{in}]`
滤波器Tensor的维度：:math:`[C_{in}, C_{out}, D_f, H_f, W_f]`
输出:
输出Tensor的维度：:math:`[N,C_{out}, D_{out}, H_{out}, W_{out}]`
其中：
.. math::
D'_{out}=(D_{in}-1)*strides[0]-2*paddings[0]+dilations[0]*(D_f-1)+1 \\
H'_{out}=(H_{in}-1)*strides[1]-2*paddings[1]+dilations[1]*(H_f-1)+1 \\
W'_{out}=(W_{in}-1)*strides[2]-2*paddings[2]+dilations[2]*(W_f-1)+1 \\
.. math::
D_{out}\in[D'_{out},D'_{out} + strides[0]) \\
H_{out}\in[H'_{out},H'_{out} + strides[1]) \\
W_{out}\in[W'_{out},W'_{out} + strides[2])
**注意** :
如果output_size为None，则 :math:`D_{out}` = :math:`D^\prime_{out}` , :math:`H_{out}` = :math:`H^\prime_{out}` , :math:`W_{out}` = :math:`W^\prime_{out}` ;否则，指定的output_size_depth（输出特征层的深度） :math:`D_{out}` 应当介于 :math:`D^\prime_{out}` 和 :math:`D^\prime_{out} + strides[0]` 之间（不包含 :math:`D^\prime_{out} + strides[0]` ），指定的output_size_height（输出特征层的高） :math:`H_{out}` 应当介于 :math:`H^\prime_{out}` 和 :math:`H^\prime_{out} + strides[1]` 之间（不包含 :math:`H^\prime_{out} + strides[1]` ）, 并且指定的output_size_width（输出特征层的宽） :math:`W_{out}` 应当介于 :math:`W^\prime_{out}` 和 :math:`W^\prime_{out} + strides[2]` 之间（不包含 :math:`W^\prime_{out} + strides[2]` ）。
由于转置卷积可以当成是卷积的反向计算，而根据卷积的输入输出计算公式来说，不同大小的输入特征层可能对应着相同大小的输出特征层，所以对应到转置卷积来说，固定大小的输入特征层对应的输出特征层大小并不唯一。
如果指定了output_size， 其可以自动计算滤波器的大小。
参数:
- **num_channels** (int) - 输入图像的通道数。
- **num_filters** (int) - 滤波器（卷积核）的个数，与输出的图片的通道数相同。
- **filter_size** (int|tuple) - 滤波器大小。如果filter_size是一个元组，则必须包含三个整型数，（filter_size_depth，filter_size_height, filter_size_width）。否则，filter_size_depth = filter_size_height = filter_size_width = filter_size。如果filter_size=None，则必须指定output_size， 其会根据output_size、padding和stride计算出滤波器大小。
- **output_size** (int|tuple，可选) - 输出图片的大小。如果 ``output_size`` 是一个元组（tuple），则该元形式为（image_H,image_W),这两个值必须为整型。如果未设置,则内部会使用filter_size、padding和stride来计算output_size。如果 ``output_size`` 和 ``filter_size`` 是同时指定的，那么它们应满足上面的公式。默认值为None。output_size和filter_size不能同时为None。
- **padding** (int|tuple，可选) - 填充padding大小。padding参数在输入特征层每边添加 ``dilation * (kernel_size - 1) - padding`` 个0。如果padding是一个元组，它必须包含三个整数(padding_depth，padding_height，padding_width)。否则，padding_depth = padding_height = padding_width = padding。默认值为0。
- **stride** (int|tuple，可选) - 步长stride大小。滤波器和输入进行卷积计算时滑动的步长。如果stride是一个元组，那么元组的形式为(stride_depth，stride_height，stride_width)。否则，stride_depth = stride_height = stride_width = stride。默认值为1。
- **dilation** (int|tuple，可选) - 膨胀比例dilation大小。空洞卷积时会指该参数，滤波器对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息，根据 `可视化效果图 <https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md>`_ 较好理解。如果膨胀比例dilation是一个元组，那么元组的形式为(dilation_depth，dilation_height， dilation_width)。否则，dilation_depth = dilation_height = dilation_width = dilation。默认值为1。
- **groups** (int，可选) - 三维转置卷积层的组数。从Alex Krizhevsky的CNN Deep论文中的群卷积中受到启发，当group=2时，输入和滤波器分别根据通道数量平均分为两组，第一组滤波器和第一组输入进行卷积计算，第二组滤波器和第二组输入进行卷积计算。默认值为1。
- **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **bias_attr** (ParamAttr，可选) - 指定偏置参数属性的对象。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **use_cudnn** (bool，可选) - 是否使用cudnn内核，只有安装Paddle GPU版时才有效。默认值为True。
- **act** (str，可选) - 激活函数类型，如果设置为None，则不使用激活函数。默认值为None。
- **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():
data = numpy.random.random((5, 3, 12, 32, 32)).astype('float32')
conv3dTranspose = fluid.dygraph.nn.Conv3DTranspose(
'Conv3DTranspose',
num_filters=12,
filter_size=12,
use_cudnn=False)
ret = conv3dTranspose(fluid.dygraph.base.to_variable(data))
属性
::::::::::::
.. py:attribute:: weight
本层的可学习参数，类型为 ``Parameter``
.. py:attribute:: bias
本层的可学习偏置，类型为 ``Parameter``
doc/paddle/api/paddle/fluid/dygraph/Conv3D_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_fluid_dygraph_Conv3D:
Conv3D
-------------------------------
.. py:class:: paddle.fluid.dygraph.Conv3D(num_channels, num_filters, filter_size, stride=1, padding=0, dilation=1, groups=None, param_attr=None, bias_attr=None, use_cudnn=True, act=None, dtype="float32")
该接口用于构建 ``Conv3D`` 类的一个可调用对象，具体用法参照 ``代码示例`` 。3D卷积层（convolution3D layer）根据输入、滤波器（filter）、步长（stride）、填充（padding）、膨胀（dilations）、组数参数计算得到输出。输入和输出是[N, C, D, H, W]的多维tensor，其中N是批尺寸，C是通道数，D是特征深度，H是特征高度，W是特征宽度。卷积三维（Convlution3D）和卷积二维（Convlution2D）相似，但多了一维深度（depth）。如果提供了bias属性和激活函数类型，bias会添加到卷积（convolution）的结果中相应的激活函数会作用在最终结果上。
对每个输入X，有等式：
.. math::
Out = \sigma \left ( W * X + b \right )
其中：
- :math:`X` ：输入值，NCDHW格式的张量（Tensor）
- :math:`W` ：滤波器值，MCDHW格式的张量（Tensor）
- :math:`*` ： 卷积操作
- :math:`b` ：Bias值，二维张量（Tensor），维度为 ``[M,1]``
- :math:`\sigma` ：激活函数
- :math:`Out` ：输出值, ``Out`` 和 ``X`` 的维度可能不同
**示例**
- 输入：
输入Tensor的维度： :math:`[N, C_{in}, D_{in}, H_{in}, W_{in}]`
滤波器Tensor的维度： :math:`[C_{out}, C_{in}, D_f, H_f, W_f]`
- 输出：
输出Tensor的维度： :math:`[N, C_{out}, D_{out}, H_{out}, W_{out}]`
其中
.. math::
D_{out}&= \frac{(D_{in} + 2 * paddings[0] - (dilations[0] * (D_f - 1) + 1))}{strides[0]} + 1 \\
H_{out}&= \frac{(H_{in} + 2 * paddings[1] - (dilations[1] * (H_f - 1) + 1))}{strides[1]} + 1 \\
W_{out}&= \frac{(W_{in} + 2 * paddings[2] - (dilations[2] * (W_f - 1) + 1))}{strides[2]} + 1
参数：
- **num_channels** (int) - 输入图像的通道数。
- **num_fliters** (int) - 滤波器（卷积核）的个数。和输出图像通道相同。
- **filter_size** (int|tuple) - 滤波器大小。如果filter_size是一个元组，则必须包含三个整型数，(filter_size_D, filter_size_H, filter_size_W)。如果filter_size是一个int型，则filter_size_depth = filter_size_height = filter_size_width = filter_size。
- **stride** (int|tuple，可选) - 步长(stride)大小。滤波器和输入进行卷积计算时滑动的步长。如果步长（stride）为元组，则必须包含三个整型数， (stride_D, stride_H, stride_W)。否则，stride_D = stride_H = stride_W = stride。默认值为1。
- **padding** (int|tuple，可选) - 填充（padding）大小。padding参数在输入特征层每边添加padding个0。如果填充（padding）为元组，则必须包含三个整型数，(padding_depth, padding_height, padding_width)。否则， padding_depth = padding_height = padding_width = padding。默认值为0。
- **dilation** (int|tuple，可选) - 膨胀（dilation）大小。空洞卷积时会指该参数，滤波器对输入进行卷积时，感受野里每相邻两个特征点之间的空洞信息，根据 `可视化效果图 <https://github.com/vdumoulin/conv_arithmetic/blob/master/README.md>`_ 较好理解。如果膨胀（dialation）为元组，则必须包含两个整型数， (dilation_D, dilation_H, dilation_W)。否则，dilation_D = dilation_H = dilation_W = dilation。默认值为1。
- **groups** (int，可选) - 三维卷积层（Conv3D Layer）的组数。根据Alex Krizhevsky的深度卷积神经网络（CNN）论文中的成组卷积：当group=2，输入和滤波器分别根据通道数量平均分为两组，第一组滤波器和第一组输入进行卷积计算，第二组滤波器和第二组输入进行卷积计算。默认值为1。
- **param_attr** (ParamAttr，可选) - 指定权重参数属性的对象。默认值为None，表示使用默认的权重参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr` 。
- **bias_attr** (ParamAttr，可选) - 指定偏置参数属性的对象。默认值为None，表示使用默认的偏置参数属性。具体用法请参见 :ref:`cn_api_fluid_ParamAttr`。
- **use_cudnn** （bool，可选） - 是否用cudnn内核，只有安装Paddle GPU版时才有效。默认值为True。
- **act** (str，可选) - 激活函数类型，如果设为None，则未添加激活函数。默认值为None。
- **dtype** (str, 可选) - 数据类型，可以为"float32"或"float64"。默认值："float32"。
返回：无
**代码示例**：
.. code-block:: python
import paddle.fluid as fluid
import numpy
with fluid.dygraph.guard():
data = numpy.random.random((5, 3, 12, 32, 32)).astype('float32')
conv3d = fluid.dygraph.nn.Conv3D(
'Conv3D', num_filters=2, filter_size=3, act="relu")
ret = conv3d(fluid.dygraph.base.to_variable(data))
属性
::::::::::::
.. py:attribute:: weight
本层的可学习参数，类型为 ``Parameter``
.. py:attribute:: bias
本层的可学习偏置，类型为 ``Parameter``
doc/paddle/api/paddle/fluid/dygraph/DataParallel_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_imperative_cn_DataParallel:
DataParallel
-------------------------------
:doc_source: paddle.fluid.dygraph.parallel.DataParallel
doc/paddle/api/paddle/fluid/dygraph/Dropout_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _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/base/enabled_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
.. _cn_api_imperative_cn_enabled:
enabled
-------------------------------
:doc_source: paddle.fluid.dygraph.base.enabled
doc/paddle/api/paddle/fluid/dygraph_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/embedding_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/get_flags_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/io/batch_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/io/cache_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/io/chain_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/io/compose_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/io/firstn_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/io_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/auc_cn.rst 已删除 100755 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/eye_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/fc_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/mul_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/nce_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/pow_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/rnn_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/sin_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/layers/sum_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/layers_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/load_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/nets/glu_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/nets_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/optimizer_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/profiler_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/set_flags_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/fluid/transpiler_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/framework/Print_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/imperative/grad_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/imperative/guard_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/imperative/jit_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/imperative/load_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/imperative/save_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/incubate/Model_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/incubate/metrics_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/io/BatchSampler_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/io/Dataset_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/io/load_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/io/save_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/io/shuffle_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/nn/BatchNorm_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/nn/Embedding_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/nn/GroupNorm_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/nn/InstanceNorm_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/nn/LayerNorm_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/nn/Linear_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/nn/Pool2D_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/nn/SpectralNorm_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/nn/diag_embed_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/nn/input/data_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/nn/random_crop_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/nn/row_conv_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/nn/target_assign_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
doc/paddle/api/paddle/nn/warpctc_cn.rst 已删除 100644 → 0
浏览文件 @ 7464e15e
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或