相关API:

- array_read
- array_write
- While

参数：

- array (LOD_TENSOR_ARRAY)-输入数组，用来计算数组长度

tmp = fluid.layers.zeros(shape=[10], dtype='int32')
i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
arr = fluid.layers.array_write(tmp, i=i)
arr_len = fluid.layers.array_length(arr)

Given:
    array = [0.6,0.1,0.3,0.1]
And:
    I=2
Then:
    output = 0.3

参数：

- array (Variable|list)-输入张量，存储要读的数据
- i (Variable|list)-输入数组中数据的索引

tmp = fluid.layers.zeros(shape=[10],dtype='int32')
i = fluid.layers.fill_constant(shape=[1],dtype='int64',value=10)
arr = layers.array_read(tmp,i=i)

参数:

- x (Variable|list) – 待从中读取数据的输入张量(tensor)
- i (Variable|list) – 输出结果 LOD_TENSOR_ARRAY 的下标, 该下标指向输入张量 x 写入输出数组的位置
- array (Variable|list) – 会被输入张量 x 写入的输出结果 LOD_TENSOR_ARRAY 。如果该项值为None， 一个新的 LOD_TENSOR_ARRAY 将会被创建并作为结果返回

tmp = fluid.layers.zeros(shape=[10], dtype='int32')
i = fluid.layers.fill_constant(shape=[1], dtype='int64', value=10)
arr = layers.array_write(tmp, i=i)

参数:

- dtype (int |float) — lod_tensor_array中存储元素的数据类型。

data = fluid.layers.create_array(dtype='float32')

import paddle.fluid as fluid
data = fluid.layers.data(name='sentence', dtype='int64', lod_level=1)
embedding = fluid.layers.embedding(input=data, size=[65535, 32],
                                    is_sparse=True)

drnn = fluid.layers.DynamicRNN()
with drnn.block():
        word = drnn.step_input(embedding)
        prev = drnn.memory(shape=[200])
        hidden = fluid.layers.fc(input=[word, prev], size=200, act='relu')
        drnn.update_memory(prev, hidden)  # set prev to hidden
        drnn.output(hidden)

 # last是的最后一时间步，也是编码（encoding）得出的最终结果
last = fluid.layers.sequence_last_step(drnn())

import paddle.fluid as fluid
sentence = fluid.layers.data(
         name='sentence', dtype='float32', shape=[32])
boot_memory = fluid.layers.data(
         name='boot', dtype='float32', shape=[10])

drnn = fluid.layers.DynamicRNN()
with drnn.block():
     word = drnn.step_input(sentence)
     memory = drnn.memory(init=boot_memory, need_reorder=True)
     hidden = fluid.layers.fc(
                 input=[word, memory], size=10, act='tanh')
     drnn.update_memory(ex_mem=memory, new_mem=hidden)
     drnn.output(hidden)

rnn_output = drnn()

import paddle.fluid as fluid

sentence = fluid.layers.data(
                name='sentence', dtype='float32', shape=[32])

drnn = fluid.layers.DynamicRNN()
with drnn.block():
    word = drnn.step_input(sentence)
    memory = drnn.memory(shape=[10], dtype='float32', value=0)
    hidden = fluid.layers.fc(
            input=[word, memory], size=10, act='tanh')
    drnn.update_memory(ex_mem=memory, new_mem=hidden)
    drnn.output(hidden)
rnn_output = drnn()

参数：

- init (Variable|None) – 初始化的Variable
- shape (list|tuple) – memory shape. 注意形状不包含batch的大小
- value (float) – 初始化的值
- need_reorder (bool) – memory初始化依赖于输入样本时设置为True
- dtype (str|numpy.dtype) – 初始化memory的数据类型

参数：

- ex_mem （memory Variable）- memory 变量（Variable）
- new_mem （memory Variable）- RNN块中生成的平坦变量（plain variable）

data = fluid.layers.data(name='data', shape=[1], dtype='float32',
                     append_batch_size=False)
data = fluid.layers.increment(x=data, value=3.0, in_place=True)

参数：

- x (Variable) – less_than 运算的左操作数
- y (Variable) – less_than 运算的右操作数
- force_cpu (BOOLEAN) – 值True则强制将输出变量写入CPU内存中。否则，将其写入目前所在的运算设备上。默认为True
- cond (Variable|None) – 可选的用于存储 less_than 输出结果的变量，为None则由函数自动生成Out变量

value = some_layer(…)
Print(value, summarize=10,
message="The content of some_layer: ")

例如:

假设在 RankTable 中存储的序列索引为 [3,0,2,1]， X 将会被这样被重新排列：
X 中的第四个序列（即索引为3的序列，后面以此类推）会变成排列后的batch中的第一个，紧接着就是原来batch中的第一个元素，第三个元素，和第二个元素。
简言之，若有原batch：X = [Seq0, Seq1, Seq2, Seq3] 且 RankTable 中的索引为 [3,0,2,1]，那么输出即为 Out = [Seq3, Seq0, Seq2, Seq1] ，它携带着新的LoD信息。
如果 X 的LoD信息是空的，这表明 X 不是序列型数据。这和由多个定长为1的序列组成的batch是相同的情况。此时，该函数将对 X 中的切片（slice） 在第一轴(axis)上按 rank_table 里的规则加以排列。
例如，现有 X = [Slice0, Slice1, Slice2, Slice3] ，并且它LoD信息为空，在 RankTable 索引为[3, 0, 2, 1]。则 Out = [Slice3, Slice0, Slice2, Slice1] ，并且不在其中追加LoD信息。

参数：

- x (LoDTensor)-待根据提供的 RankTable 进行排序的LoD tensor
- rank_table (LoDRankTable)- X 重新排序的依据规则表

参数：

- capacity (int) - 缓冲区容量由 py_reader 维护
- feed_list (list(Variable)) - 传输数据列表
- name (basestring) - 前缀Python队列名称和 reader 名称。不定义时将自动生成名称。
- use_double_buffer (bool) - 是否使用 double buffer

py_reader 的基本用法如下所示：

import paddle.fluid as fluid
import paddle.dataset.mnist as mnist

image = fluid.layers.data(name='image', shape=[3,224,224], dtypes='float32')
label = fluid.layers.data(name='label', shape=[1], dtypes='int64')
reader = fluid.layers.create_py_reader_by_data(capacity=64, feed_list=[image, label])
reader.decorate_paddle_reader(
    paddle.reader.shuffle(paddle.batch(mnist.train())
img, label = fluid.layers.read_file(reader)
loss = network(img, label) # some network definition

fluid.Executor(fluid.CUDAPlace(0)).run(fluid.default_startup_program())

exe = fluid.ParallelExecutor(use_cuda=True, loss_name=loss.name)
for epoch_id in range(10):
    reader.start()
    try:
        while True:
            exe.run(fetch_list=[loss.name])
    except fluid.core.EOFException:
        reader.reset()

data = fluid.layers.data(name='x', shape=[784], dtype='float32')

参数：

- out (Variable)-需要加载的LoDTensor或SelectedRows
- file_path (STRING)-预从“file_path”中加载的变量Variable
- load_as_fp16 (BOOLEAN)-如果为真，张量首先进行加载然后类型转换成float16。如果为假，张量将直接加载，不需要进行数据类型转换。默认为false。

reader = fluid.layers.io.open_files(filenames=['./data1.recordio',
                                        './data2.recordio'],
                                shapes=[(3,224,224), (1)],
                                lod_levels=[0, 0],
                                dtypes=['float32', 'int64'])

# 通过reader, 可使用''read_file''层获取数据:
image, label = fluid.layers.io.read_file(reader)

class paddle.fluid.layers.Preprocessor(reader, name=None)

参数：

- reader (Variable)-reader变量
- name (str,默认None)-reader的名称

preprocessor = fluid.layers.io.Preprocessor(reader=reader)
with preprocessor.block():
    img, lbl = preprocessor.inputs()
    img_out = img / 2
    lbl_out = lbl + 1
    preprocessor.outputs(img_out, lbl_out)
data_file = fluid.layers.io.double_buffer(preprocessor())

参数:

- capacity (int) – py_reader 维护的缓冲区容量
- shapes (list|tuple) –数据形状的元组或列表.
- dtypes (list|tuple) – shapes 对应元素的数据类型
- lod_levels (list|tuple) – lod_level的整型列表或元组
- name (basestring) – python 队列的前缀名称和Reader 名称。不会自动生成。
- use_double_buffer (bool) – 是否使用双缓冲

import paddle
import paddle.fluid as fluid
import paddle.dataset.mnist as mnist

reader = fluid.layers.py_reader(capacity=64,
                                shapes=[(-1,3,224,224), (-1,1)],
                                dtypes=['float32', 'int64'])
reader.decorate_paddle_reader(
    paddle.reader.shuffle(paddle.batch(mnist.train())

img, label = fluid.layers.read_file(reader)
loss = network(img, label) # 一些网络定义

fluid.Executor(fluid.CUDAPlace(0)).run(fluid.default_startup_program())

exe = fluid.ParallelExecutor(use_cuda=True, loss_name=loss.name)
for epoch_id in range(10):
    reader.start()
    try:
        while True:
            exe.run(fetch_list=[loss.name])
    except fluid.core.EOFException:
        reader.reset()

import paddle
import paddle.fluid as fluid
import paddle.dataset.mnist as mnist

def network(reader):
    img, label = fluid.layers.read_file(reader)
    # 此处我们省略了一些网络定义
    return loss

train_reader = fluid.layers.py_reader(capacity=64,
                                      shapes=[(-1,3,224,224), (-1,1)],
                                      dtypes=['float32', 'int64'],
                                      name='train_reader')
train_reader.decorate_paddle_reader(
    paddle.reader.shuffle(paddle.batch(mnist.train())

test_reader = fluid.layers.py_reader(capacity=32,
                                     shapes=[(-1,3,224,224), (-1,1)],
                                     dtypes=['float32', 'int64'],
                                     name='test_reader')
test_reader.decorate_paddle_reader(paddle.batch(mnist.test(), 512))

# 新建 train_main_prog 和 train_startup_prog
train_main_prog = fluid.Program()
train_startup_prog = fluid.Program()
with fluid.program_guard(train_main_prog, train_startup_prog):
    # 使用 fluid.unique_name.guard() 实现与test program的参数共享
    with fluid.unique_name.guard():
        train_loss = network(train_reader) # 一些网络定义
        adam = fluid.optimizer.Adam(learning_rate=0.01)
        adam.minimize(loss)

# Create test_main_prog and test_startup_prog
test_main_prog = fluid.Program()
test_startup_prog = fluid.Program()
with fluid.program_guard(test_main_prog, test_startup_prog):
    # 使用 fluid.unique_name.guard() 实现与train program的参数共享
    with fluid.unique_name.guard():
        test_loss = network(test_reader)

fluid.Executor(fluid.CUDAPlace(0)).run(train_startup_prog)
fluid.Executor(fluid.CUDAPlace(0)).run(test_startup_prog)

train_exe = fluid.ParallelExecutor(use_cuda=True,
                loss_name=train_loss.name, main_program=train_main_prog)
test_exe = fluid.ParallelExecutor(use_cuda=True,
                loss_name=test_loss.name, main_program=test_main_prog)
for epoch_id in range(10):
    train_reader.start()
    try:
        while True:
            train_exe.run(fetch_list=[train_loss.name])
    except fluid.core.EOFException:
        train_reader.reset()

    test_reader.start()
    try:
        while True:
            test_exe.run(fetch_list=[test_loss.name])
    except fluid.core.EOFException:
        test_reader.reset()

参数：

- reader (Variable)-将要执行的reader

data_file = fluid.layers.open_files(
    filenames=['mnist.recordio'],
    shapes=[(-1, 748), (-1, 1)],
    lod_levels=[0, 0],
    dtypes=["float32", "int64"])
data_file = fluid.layers.double_buffer(
    fluid.layers.batch(data_file, batch_size=64))
input, label = fluid.layers.read_file(data_file)

参数:

- reader (Variable) – 用shuffle装饰的reader
- buffer_size (int) – reader中buffer的大小

# 假设输入形为[N, C, H, W], pool_size 为 [m, n],
# 输出形为 [N, C, m, n], adaptive pool 将输入的 H 和 W 纬度
# 平均分割为 m  n 个栅格(grid) ，然后为每个栅格进行池化得到输出
# adaptive average pool 进行如下操作
#
#     for i in range(m):
#         for j in range(n):
#             hstart = floor(i  H / m)
#             hend = ceil((i + 1)  H / m)
#             wstart = floor(i  W / n)
#             wend = ceil((i + 1)  W / n)
#             output[:, :, i, j] = avg(input[:, :, hstart: hend, wstart: wend])
#
data = fluid.layers.data(
    name='data', shape=[3, 32, 32], dtype='float32')
pool_out = fluid.layers.adaptive_pool2d(
                  input=data,
                  pool_size=[3, 3],
                  pool_type='avg')

参数：

- input （Variable） - 池化操作的输入张量。 输入张量的格式为NCDHW，其中N是batch大小，C是通道数，D为特征的深度，H是特征的高度，W是特征的宽度。
- pool_size （int | list | tuple） - 池化核大小。 如果池化核大小是元组或列表，则它必须包含三个整数（Depth, Height, Width）。
- pool_type （string）- 池化类型，可输入“max”代表max-pooling，或者“avg”代表average-pooling。
- require_index （bool） - 如果为true，则输出中带有最大池化点所在的索引。 如果pool_type为avg,该项不可被设置为true。
- name （str | None） - 此层的名称（可选）。 如果设置为None，则将自动命名该层。

- ValueError – pool_type 不是 ‘max’ 或 ‘avg’- ValueError – 当 pool_type 是 ‘avg’ 时，错误地设置 ‘require_index’ 为true .- ValueError – pool_size 应为一个长度为3的列表或元组

# 假设输入形为[N, C, D, H, W], pool_size 为 [l, m, n],
# 输出形为 [N, C, l, m, n], adaptive pool 将输入的D, H 和 W 纬度
# 平均分割为 l  m  n 个栅格(grid) ，然后为每个栅格进行池化得到输出
# adaptive average pool 进行如下操作
#
#     for i in range(l):
#         for j in range(m):
#             for k in range(n):
#                 dstart = floor(i  D / l)
#                 dend = ceil((i + 1)  D / l)
#                 hstart = floor(j  H / m)
#                 hend = ceil((j + 1)  H / m)
#                 wstart = floor(k  W / n)
#                 wend = ceil((k + 1)  W / n)
#                 output[:, :, i, j, k] =
#                     avg(input[:, :, dstart:dend, hstart: hend, wstart: wend])
#
data = fluid.layers.data(
name='data', shape=[3, 32, 32], dtype='float32')
pool_out, mask = fluid.layers.adaptive_pool3d(
                  input=data,
                  pool_size=[3, 3, 3],
                  pool_type='avg')