PaddlePaddle
- abs
- acos
- add
- add_n
- addmm
- all
- allclose
- any
- arange
- argmax
- argmin
- argsort
- asin
- assign
- atan
- bernoulli
- bmm
- broadcast_to
- cast
- ceil
- cholesky
- chunk
- clip
- concat
- conj
- cos
- cosh
- CPUPlace
- cross
- CUDAPinnedPlace
- CUDAPlace
- cumsum
- DataParallel
- diag
- disable_static
- dist
- divide
- dot
- empty
- empty_like
- enable_static
- equal
- equal_all
- erf
- exp
- expand
- expand_as
- eye
- flatten
- flip
- floor
- floor_divide
- flops
- full
- full_like
- gather
- gather_nd
- get_cuda_rng_state
- get_cudnn_version
- get_default_dtype
- get_device
- grad
- greater_equal
- greater_than
- histogram
- imag
- in_dynamic_mode
- increment
- index_sample
- index_select
- inverse
- is_compiled_with_cuda
- is_compiled_with_xpu
- is_empty
- is_tensor
- isfinite
- isinf
- isnan
- kron
- less_equal
- less_than
- linspace
- load
- log
- log10
- log1p
- log2
- logical_and
- logical_not
- logical_or
- logical_xor
- logsumexp
- masked_select
- matmul
- max
- maximum
- mean
- median
- meshgrid
- min
- minimum
- mm
- mod
- Model
- multinomial
- multiplex
- multiply
- mv
- no_grad
- nonzero
- norm
- normal
- not_equal
- numel
- ones
- ones_like
- ParamAttr
- pow
- prod
- rand
- randint
- randn
- randperm
- rank
- real
- reciprocal
- reshape
- reshape_
- roll
- round
- rsqrt
- save
- scale
- scatter
- scatter_
- scatter_nd
- scatter_nd_add
- seed
- set_cuda_rng_state
- set_default_dtype
- set_device
- shape
- shard_index
- sign
- sin
- sinh
- slice
- sort
- split
- sqrt
- square
- squeeze
- squeeze_
- stack
- stanh
- std
- strided_slice
- subtract
- sum
- summary
- t
- tan
- tanh
- tanh_
- Tensor
- tile
- to_tensor
- topk
- trace
- transpose
- tril
- triu
- unbind
- uniform
- unique
- unsqueeze
- unsqueeze_
- unstack
- var
- where
- XPUPlace
- zeros
- zeros_like
- create_lod_tensor
- create_random_int_lodtensor
- cuda_pinned_places
- data
- DataFeedDesc
- DataFeeder
- device_guard
- DistributeTranspiler
- DistributeTranspilerConfig
- get_flags
-
- adaptive_pool2d
- adaptive_pool3d
- add_position_encoding
- affine_channel
- affine_grid
- anchor_generator
- argmax
- argmin
- argsort
- array_length
- array_read
- array_write
- assign
- autoincreased_step_counter
- BasicDecoder
- beam_search
- beam_search_decode
- bipartite_match
- box_clip
- box_coder
- box_decoder_and_assign
- bpr_loss
- brelu
- Categorical
- center_loss
- clip
- clip_by_norm
- collect_fpn_proposals
- concat
- cond
- continuous_value_model
- cosine_decay
- create_array
- create_py_reader_by_data
- create_tensor
- crop
- crop_tensor
- cross_entropy
- ctc_greedy_decoder
- cumsum
- data
- DecodeHelper
- Decoder
- deformable_conv
- deformable_roi_pooling
- density_prior_box
- detection_output
- diag
- distribute_fpn_proposals
- double_buffer
- dropout
- dynamic_gru
- dynamic_lstm
- dynamic_lstmp
- DynamicRNN
- edit_distance
- elementwise_add
- elementwise_div
- elementwise_floordiv
- elementwise_max
- elementwise_min
- elementwise_mod
- elementwise_pow
- elementwise_sub
- elu
- embedding
- equal
- expand
- expand_as
- exponential_decay
- eye
- fc
- fill_constant
- filter_by_instag
- flatten
- fsp_matrix
- gather
- gather_nd
- gaussian_random
- gelu
- generate_mask_labels
- generate_proposal_labels
- generate_proposals
- get_tensor_from_selected_rows
- greater_equal
- greater_than
- GreedyEmbeddingHelper
- grid_sampler
- gru_unit
- GRUCell
- hard_shrink
- hard_sigmoid
- hard_swish
- has_inf
- has_nan
- hash
- hsigmoid
- huber_loss
- IfElse
- im2sequence
- image_resize
- image_resize_short
- increment
- inplace_abn
- inverse_time_decay
- iou_similarity
- isfinite
- kldiv_loss
- l2_normalize
- label_smooth
- leaky_relu
- less_equal
- less_than
- linear_chain_crf
- linear_lr_warmup
- locality_aware_nms
- lod_append
- lod_reset
- logsigmoid
- lrn
- lstm
- lstm_unit
- LSTMCell
- margin_rank_loss
- matmul
- matrix_nms
- maxout
- mean
- merge_selected_rows
- mse_loss
- mul
- multiclass_nms
- MultivariateNormalDiag
- natural_exp_decay
- noam_decay
- Normal
- not_equal
- one_hot
- ones
- ones_like
- pad
- pad2d
- pad_constant_like
- piecewise_decay
- pixel_shuffle
- polygon_box_transform
- polynomial_decay
- pool2d
- pool3d
- pow
- prior_box
- prroi_pool
- psroi_pool
- py_reader
- random_crop
- range
- rank_loss
- read_file
- reduce_all
- reduce_any
- reduce_max
- reduce_mean
- reduce_min
- reduce_prod
- reduce_sum
- relu
- relu6
- reorder_lod_tensor_by_rank
- reshape
- resize_bilinear
- resize_nearest
- resize_trilinear
- retinanet_detection_output
- retinanet_target_assign
- reverse
- rnn
- RNNCell
- roi_align
- roi_perspective_transform
- roi_pool
- rpn_target_assign
- sampled_softmax_with_cross_entropy
- SampleEmbeddingHelper
- sampling_id
- scatter
- selu
- sequence_concat
- sequence_conv
- sequence_enumerate
- sequence_expand
- sequence_expand_as
- sequence_first_step
- sequence_last_step
- sequence_mask
- sequence_pad
- sequence_pool
- sequence_reshape
- sequence_reverse
- sequence_scatter
- sequence_slice
- sequence_softmax
- sequence_unpad
- shuffle_channel
- sigmoid_cross_entropy_with_logits
- sigmoid_focal_loss
- sign
- similarity_focus
- size
- smooth_l1
- soft_relu
- softmax
- softplus
- softshrink
- softsign
- space_to_depth
- split
- squeeze
- ssd_loss
- stack
- StaticRNN
- strided_slice
- sum
- sums
- swish
- Switch
- tanh
- tanh_shrink
- target_assign
- teacher_student_sigmoid_loss
- tensor_array_to_tensor
- thresholded_relu
- topk
- TrainingHelper
- unbind
- Uniform
- uniform_random
- unique
- unique_with_counts
- unsqueeze
- warpctc
- where
- While
- while_loop
- yolo_box
- yolov3_loss
- zeros
- zeros_like
- load_op_library
- LoDTensor
- LoDTensorArray
- memory_optimize
- one_hot
- release_memory
- require_version
- set_flags
- Tensor
- Overview
- AdaptiveAvgPool1D
- AdaptiveAvgPool2D
- AdaptiveAvgPool3D
- AdaptiveMaxPool1D
- AdaptiveMaxPool2D
- AdaptiveMaxPool3D
- AlphaDropout
- AvgPool1D
- AvgPool2D
- AvgPool3D
- BatchNorm
- BatchNorm1D
- BatchNorm2D
- BatchNorm3D
- BCELoss
- BCEWithLogitsLoss
- BeamSearchDecoder
- Bilinear
- BiRNN
- ClipGradByGlobalNorm
- ClipGradByNorm
- ClipGradByValue
- Conv1D
- Conv1DTranspose
- Conv2D
- Conv2DTranspose
- Conv3D
- Conv3DTranspose
- CosineSimilarity
- CrossEntropyLoss
- CTCLoss
- Dropout
- Dropout2D
- Dropout3D
- dynamic_decode
- ELU
- Embedding
- Flatten
-
- adaptive_avg_pool1d
- adaptive_avg_pool2d
- adaptive_avg_pool3d
- adaptive_max_pool1d
- adaptive_max_pool2d
- adaptive_max_pool3d
- affine_grid
- alpha_dropout
- avg_pool1d
- avg_pool2d
- avg_pool3d
- batch_norm
- bilinear
- binary_cross_entropy
- binary_cross_entropy_with_logits
- conv1d
- conv1d_transpose
- conv2d
- conv2d_transpose
- conv3d
- conv3d_transpose
- cosine_similarity
- cross_entropy
- ctc_loss
- diag_embed
- dice_loss
- dropout
- dropout2d
- dropout3d
- elu
- elu_
- embedding
- gather_tree
- gelu
- grid_sample
- hardshrink
- hardsigmoid
- hardswish
- hardtanh
- hsigmoid_loss
- instance_norm
- interpolate
- kl_div
- l1_loss
- label_smooth
- layer_norm
- leaky_relu
- linear
- local_response_norm
- log_loss
- log_sigmoid
- log_softmax
- margin_ranking_loss
- max_pool1d
- max_pool2d
- max_pool3d
- maxout
- mse_loss
- nll_loss
- normalize
- npair_loss
- one_hot
- pad
- pixel_shuffle
- prelu
- relu
- relu6
- relu_
- selu
- sigmoid
- sigmoid_focal_loss
- smooth_l1_loss
- softmax
- softmax_
- softmax_with_cross_entropy
- softplus
- softshrink
- softsign
- square_error_cost
- swish
- tanhshrink
- temporal_shift
- thresholded_relu
- unfold
- upsample
- GELU
- GroupNorm
- GRU
- GRUCell
- Hardshrink
- Hardsigmoid
- Hardswish
- Hardtanh
- HSigmoidLoss
- InstanceNorm1D
- InstanceNorm2D
- InstanceNorm3D
- KLDivLoss
- L1Loss
- Layer
- LayerList
- LayerNorm
- LeakyReLU
- Linear
- LocalResponseNorm
- LogSigmoid
- LogSoftmax
- LSTM
- LSTMCell
- MarginRankingLoss
- Maxout
- MaxPool1D
- MaxPool2D
- MaxPool3D
- MSELoss
- MultiHeadAttention
- NLLLoss
- Pad1D
- Pad2D
- Pad3D
- PairwiseDistance
- ParameterList
- PixelShuffle
- PReLU
- ReLU
- ReLU6
- RNN
- RNNCellBase
- SELU
- Sequential
- Sigmoid
- SimpleRNN
- SimpleRNNCell
- SmoothL1Loss
- Softmax
- Softplus
- Softshrink
- Softsign
- SpectralNorm
- Swish
- SyncBatchNorm
- Tanh
- Tanhshrink
- ThresholdedReLU
- Transformer
- TransformerDecoder
- TransformerDecoderLayer
- TransformerEncoder
- TransformerEncoderLayer
- Upsample
- UpsamplingBilinear2D
- UpsamplingNearest2D
- append_backward
- BuildStrategy
- CompiledProgram
- cpu_places
- create_global_var
- create_parameter
- cuda_places
- data
- default_main_program
- default_startup_program
- deserialize_persistables
- deserialize_program
- device_guard
- ExecutionStrategy
- Executor
- global_scope
- gradients
- InputSpec
- load
- load_from_file
- load_inference_model
- load_program_state
- name_scope
- ParallelExecutor
- Program
- program_guard
- py_func
- save
- save_inference_model
- save_to_file
- scope_guard
- serialize_persistables
- serialize_program
- set_program_state
- Variable
- WeightNormParamAttr
-
- adjust_brightness
- adjust_contrast
- adjust_hue
- adjust_saturation
- BaseTransform
- BrightnessTransform
- center_crop
- CenterCrop
- ColorJitter
- Compose
- ContrastTransform
- crop
- Grayscale
- hflip
- HueTransform
- Normalize
- normalize
- Pad
- pad
- RandomCrop
- RandomHorizontalFli
- RandomResizedCrop
- RandomRotation
- RandomVerticalFlip
- Resize
- resize
- rotate
- SaturationTransform
- to_grayscale
- to_tensor
- ToTensor
- Transpose
- vflip
paddle.fluid / layers / DynamicRNN
DynamicRNN¶
注意:该类型的输入仅支持LoDTensor,如果您需要处理的输入数据是Tensor类型, 请使用StaticRNN( fluid.layers. StaticRNN )。
DynamicRNN可以处理一批序列数据,其中每个样本序列的长度可以不同,每个序列的长度信息记录在LoD里面。 DynamicRNN会按照时间步 (time step) 将输入序列展开,用户可以在 block
中定义每个时间步要进行的运算。 由于每个输入样本的序列长度不相同,RNN执行的step数由最长的序列决定。 DynamicRNN的实现采用非padding的方式,每个时间步都会对输入数据进行收缩处理,移除已经处理完的序列的信息。 因此,随着时间步的增加,每个时间步处理的样本数(batch size)会逐渐减少。
警告
目前不支持在DynamicRNN的 block
中任何层上配置 is_sparse = True
。
- 参数:
-
name (str,可选) - 具体用法参见 Name ,一般无需设置,默认值为None。
- 成员函数列表:
-
成员函数 step_input ,设置输入变量
成员函数 static_input ,设置静态输入变量
成员函数 block ,定义每个时间步执行的运算
成员函数 memory ,创建用于在时间步之间传递信息的变量
成员函数 update_memory ,更新需要传递的时间步信息
成员函数 output ,设置时间步的输出变量
成员函数 __call__ ,获取RNN的输出序列
成员函数 step_input¶
-
step_input
( x, level=0 ) ¶
将序列x设置为DynamicRNN输入。输入序列中最长的序列长度,将决定了RNN运算的长度。 必须至少为DynamicRNN设置一个输入,也可以设置多个输入。 如果多个输入x的 x.lod_level
都为1,则要求多个输入LoDTensor携带完全相同的LoD信息。 当输入x的 x.lod_level >= 2
时,输入序列将按指定level进行展开,每个时间步携带 x.lod_level - level - 1
层LoD信息, 此时要求多个输入序列的LoD在指定level上的信息完全一样。
示例1
# 输入,其中Si代表维度为[1, N]的数据
level = 0
x.lod = [[2, 1, 3]]
x.shape = [6, N]
x.data = [[S0],
[S0],
[S1],
[S2],
[S2],
[S2]]
# 输出
# step 0,持有3个序列的time step数据
out.lod = [[]]
out.shape = [3, N]
out.data = [[S2],
[S0],
[S1]]
# step 1,持有2个序列的time step数据
out.lod = [[]]
out.shape = [2, N]
out.data = [[S2],
[S0]]
# step 2,持有1个序列的time step数据
out.lod = [[]]
out.shape = [1, N]
out.data = [[S2]]
- 参数:
-
x (Variable) - 输入序列LoDTensor,代表由长度不同的多个序列组成的minibatch,要求
x.lod_level >= 1
。输入x第一个维度的值等于minibatch内所有序列的长度之和。RNN有多个输入序列时,多个输入LoDTensor的第一个维度必须相同,其它维度可以不同。支持的数据类型有:bool,float16,float32,float64,int8,int16,int32,int64,uint8。level (int,可选) - 用于拆分输入序列的LoD层级,取值范围是 \([0, x.lod\_level)\),默认值是0。
返回: 输入序列每个时间步的数据。执行第 step_idx
个时间步时,若输入 x
中有 num_sequences
个长度不小于 step_idx
的序列,则这个时间步返回值中只包含了这 num_sequences
个序列第 step_idx
时间步的数据。数据类型和输入一致。如果 x.lod_level == 1
,返回值的维度是 \(\{num\_sequences, x.shape[1], ...\}\)。否则,返回值也是一个变长的LoDTensor。
返回类型:Variable
- 抛出异常:
-
ValueError
:当step_input()
接口在RNNblock()
接口外面被调用时。TypeError
:当输入x类型不是Variable时。
代码示例
import paddle.fluid as fluid
sentence = fluid.data(name='sentence', shape=[None, 1], dtype='int64', lod_level=1)
embedding = fluid.layers.embedding(input=sentence, size=[65536, 32], is_sparse=True)
drnn = fluid.layers.DynamicRNN()
with drnn.block():
# 将embedding标记为RNN的输入,每个时间步取句子中的一个字进行处理
word = drnn.step_input(embedding)
# 将memory初始化为一个值为0的常量Tensor,shape=[batch_size, 200],其中batch_size由输入embedding决定
memory = drnn.memory(shape=[200])
hidden = fluid.layers.fc(input=[word, memory], size=200, act='relu')
# 用hidden更新memory
drnn.update_memory(ex_mem=memory, new_mem=hidden)
# 将hidden标记为RNN的输出
drnn.output(hidden)
# 获得RNN的计算结果
rnn_output = drnn()
成员函数 static_input¶
-
static_input
( x ) ¶
将变量设置为RNN的静态输入。
示例1,静态输入携带LoD信息
# RNN的输入见step_input中的示例
# 静态输入,其中Si代表维度为[1, M]的数据
x.lod = [[3, 1, 2]]
x.shape = [6, M]
x.data = [[S0],
[S0],
[S0],
[S1],
[S2],
[S2]]
# step 0,持有3个序列对应的数据
out.lod = [[2, 3, 1]]
out.shape = [6, M]
out.data = [[S2],
[S2],
[S0],
[S0],
[S0],
[S1]]
# step 1,持有2个序列对应的数据
out.lod = [[2, 3]]
out.shape = [5, M]
out.data = [[S2],
[S2],
[S0],
[S0],
[S0]]
# step 2,持有1个序列对应的数据
out.lod = [[2]]
out.shape = [2, M]
out.data = [[S2],
[S2]]
示例2,静态输入不携带LoD信息
# RNN的输入见step_input中的示例
# 静态输入,其中Si代表维度为[1, M]的数据
x.lod = [[]]
x.shape = [3, M]
x.data = [[S0],
[S1],
[S2]]
# step 0,持有3个序列对应的数据
out.lod = [[]]
out.shape = [3, M]
out.data = [[S2],
[S0],
[S1]]
# step 1,持有2个序列对应的数据
out.lod = [[]]
out.shape = [2, M]
out.data = [[S2],
[S0]]
# step 2,持有1个序列对应的数据
out.lod = [[]]
out.shape = [1, M]
out.data = [[S2]]
- 参数:
-
x (Variable) - 静态输入序列LoDTensor,要求持有与输入LoDTensor(通过
step_input
设置的输入)相同的序列个数。如果输入x的LoD信息为空,则会被当成由x.shape[0]
个长度为1序列组成。支持的数据类型有:bool,float16,float32,float64,int8,int16,int32,int64,uint8。
返回: 经过按照RNN输入LoD信息重排序、且收缩处理后的静态输入LoDTensor。执行第 step_idx
个时间步时,如果输入序列中只有 num_sequences
长度不小于 step_idx
的序列,静态输入也会进行收缩处理,只返回对应的 num_sequences
个序列对应的数据。数据类型和输入一致。如果 x.lod == None
,返回值的维度是 \(\{num\_sequences, x.shape[1], ...\}\) 。否则,返回值是一个变长的LoDTensor。
返回类型:Variable
- 抛出异常:
-
ValueError
:当static_input()
接口在RNNblock()
接口外面被调用时。TypeError
:当输入x类型不是Variable类型时。RuntimeError
:当static_input()
接口在step_input()
接口之前被调用时。
代码示例
import paddle.fluid as fluid
sentence = fluid.data(name='sentence', shape=[None, 32], dtype='float32', lod_level=1)
encoder_proj = fluid.data(name='encoder_proj', shape=[None, 32], dtype='float32', lod_level=1)
decoder_boot = fluid.data(name='boot', shape=[None, 10], dtype='float32')
drnn = fluid.layers.DynamicRNN()
with drnn.block():
# 将sentence标记为RNN的输入,每个时间步取句子中的一个字进行处理
current_word = drnn.step_input(sentence)
# 将encode_proj标记为RNN的静态输入
encoder_word = drnn.static_input(encoder_proj)
# 使用boot_memory初始化memory,并且需要依据输入序列进行重排序
memory = drnn.memory(init=decoder_boot, need_reorder=True)
fc_1 = fluid.layers.fc(input=encoder_word, size=30)
fc_2 = fluid.layers.fc(input=current_word, size=30)
decoder_inputs = fc_1 + fc_2
hidden, _, _ = fluid.layers.gru_unit(input=decoder_inputs, hidden=memory, size=30)
# 用hidden更新memory
drnn.update_memory(ex_mem=memory, new_mem=hidden)
out = fluid.layers.fc(input=hidden, size=10, bias_attr=True, act='softmax')
# 将out标记为RNN的输出
drnn.output(out)
# 获得RNN的计算结果
rnn_output = drnn()
成员函数 block¶
-
block
( ) ¶
定义每个时间步执行的操作。 block
语句里面定义的算子序列,将会被执行 max_sequence_len
次( max_sequence_len
是输入序列中大的序列长度)。
- 抛出异常:
-
ValueError
:当RNNblock()
接口被多次调用时。
成员函数 memory¶
-
memory
( init=None, shape=None, value=0.0, need_reorder=False, dtype='float32' ) ¶
为RNN创建一个memory变量,用于在时间步之间传递信息。 它可以用一个已有的Tensor来初始化,也可以初始化为一个特定维度的常量Tensor。
- 参数:
-
init (Variable,可选) – 设置memory初始值的LoDTensor。如果init不是None,将使用init来初始化memory,要求持有与输入LoDTensor(通过
step_input
设置的输入)相同的序列个数。如果输入init的LoD信息为空,则会被当成由init.shape[0]
个长度为1序列组成。默认值是None。shape (list|tuple,可选) – 当init是None时,用来设置memory的维度。注意:shape中不包含batch_size。若设置 \(shape=\{D_1, D_2, ...\}\),memory Tensor的实际维度为 \(\{batch\_size, D_1, D_2, ...\}\),其中batch_size由输入序列决定。默认值是None。
value (float,可选) – 当init是None时,用来设置memory的初始值。默认值是0.0。
need_reorder (bool,可选) – 当init不是None时,用来决定init是否需要重新排序。动态RNN在计算时,会按照输入LoDTensor中序列的长度对输入进行排序,因此当init中的信息与输入序列样本紧密关联时,需要设置
need_reorder=True
。默认值是False。dtype (str|numpy.dtype,可选) – 当init是None是,初始化memory的数据类型。默认值是"float32"。可设置的字符串值有:"float32","float64","int32","int64"。
返回:经过收缩处理后的memory LoDTensor。执行第 step_idx
个时间步时,如果输入序列中只有 num_sequences
长度不小于 step_idx
的序列,memory也会进行收缩处理,只返回对应的 num_sequences
个序列对应的数据。
返回类型:Variable
- 抛出异常:
-
ValueError
:当memory()
接口在RNNblock()
接口外面被调用时。TypeError
:当init被设置了,但是不是Variable类型时。ValueError
:当memory()
接口在step_input()
接口之前被调用时。
代码示例一
import paddle.fluid as fluid
sentence = fluid.data(name='sentence', shape=[None, 32], dtype='float32', lod_level=1)
boot_memory = fluid.data(name='boot', shape=[None, 10], dtype='float32')
drnn = fluid.layers.DynamicRNN()
with drnn.block():
# 将sentence标记为RNN的输入,每个时间步取句子中的一个字进行处理
word = drnn.step_input(sentence)
# 使用boot_memory初始化memory,并且需要依据输入序列进行重排序
memory = drnn.memory(init=boot_memory, need_reorder=True)
hidden = fluid.layers.fc(input=[word, memory], size=10, act='tanh')
# 用hidden更新memory
drnn.update_memory(ex_mem=memory, new_mem=hidden)
# 将hidden标记为RNN的输出
drnn.output(hidden)
# 获得RNN的计算结果
rnn_output = drnn()
代码示例二
import paddle.fluid as fluid
sentence = fluid.data(name='sentence', shape=[None, 32], dtype='float32', lod_level=1)
drnn = fluid.layers.DynamicRNN()
with drnn.block():
# 将sentence标记为RNN的输入,每个时间步取句子中的一个字进行处理
word = drnn.step_input(sentence)
# 将memory初始化为一个值为0的常量Tensor,shape=[batch_size, 10],其中batch_size由输入sentence决定
memory = drnn.memory(shape=[10], dtype='float32', value=0)
hidden = fluid.layers.fc(input=[word, memory], size=10, act='tanh')
# 用hidden更新memory
drnn.update_memory(ex_mem=memory, new_mem=hidden)
# 将hidden标记为RNN的输出
drnn.output(hidden)
# 获得RNN的计算结果
rnn_output = drnn()
成员函数 update_memory¶
-
update_memory
( ex_mem, new_mem ) ¶
将需要在时间步之间传递的信息更新。
- 参数:
-
ex_mem (Variable) - 上一个时间步的信息。
new_mem (Variable) - 新的时间步信息。
new_mem
的维度和数据类型必须与ex_mem
一致。
返回:无
- 抛出异常:
-
ValueError
:当update_memory()
接口在RNNblock()
接口外面被调用时。TypeError
:当ex_mem
或new_mem
不是Variable类型时。ValueError
:当ex_mem
不是使用memory()
接口定义的memory时。ValueError
:当update_memory()
接口在step_input()
接口之前被调用时。
成员函数 output¶
-
output
( *outputs ) ¶
设置outputs为RNN每个时间步的输出变量。
- 参数:
-
*outputs (Variable ...) - 输出Tensor,可同时将多个Variable标记为输出。
返回:无
- 抛出异常:
-
ValueError
:当output()
接口在RNNblock()
接口外面被调用时。
成员函数 __call__¶
-
__call__
( ) ¶
获取RNN计算的输出序列。
若定义了 drnn = DynamicRNN()
,则可以调用 drnn()
获得输出序列,该输出序列是通过将每一个时间步的output数据合并得到的一个LoDTensor。 当RNN的输入x(通过 step_input()
接口设置)的 x.lod_level
为1时,该输出LoDTensor将会和输入x持有完全相同的LoD信息。 通过 drnn()
获取的RNN输出LoDTensor中包含了所有时间步的计算结果,可调用 sequence_last_step 获取最后一个时间步的计算结果。
- 参数:
-
无
返回:RNN的输出序列。
返回类型:Variable或Variable list
- 抛出异常:
-
ValueError
:当__call__()
接口在RNNblock()
定义之前被调用时。
代码示例
import paddle.fluid as fluid
sentence = fluid.data(name='sentence', shape=[None, 32], dtype='float32', lod_level=1)
encoder_proj = fluid.data(name='encoder_proj', shape=[None, 32], dtype='float32', lod_level=1)
decoder_boot = fluid.data(name='boot', shape=[None, 10], dtype='float32')
drnn = fluid.layers.DynamicRNN()
with drnn.block():
# 将sentence标记为RNN的输入,每个时间步取句子中的一个字进行处理
current_word = drnn.step_input(sentence)
# 将encode_proj标记为RNN的静态输入
encoder_word = drnn.static_input(encoder_proj)
# 使用boot_memory初始化memory,并且需要依据输入序列进行重排序
memory = drnn.memory(init=decoder_boot, need_reorder=True)
fc_1 = fluid.layers.fc(input=encoder_word, size=30)
fc_2 = fluid.layers.fc(input=current_word, size=30)
decoder_inputs = fc_1 + fc_2
hidden, _, _ = fluid.layers.gru_unit(input=decoder_inputs, hidden=memory, size=30)
# 用hidden更新memory
drnn.update_memory(ex_mem=memory, new_mem=hidden)
out = fluid.layers.fc(input=hidden, size=10, bias_attr=True, act='softmax')
# 将hidden和out标记为RNN的输出
drnn.output(hidden, out)
# 获得RNN的计算结果
hidden, out = drnn()
# 提取RNN最后一个时间步的计算结果
last = fluid.layers.sequence_last_step(out)
此页内容是否对您有帮助
感谢反馈!