tf.keras.layers.RNN

Class RNN

Arguments:

cell: A RNN cell instance or a list of RNN cell instances.
A RNN cell is a class that has:
- a call(input_at_t, states_at_t) method, returning
(output_at_t, states_at_t_plus_1). The call method of the
cell can also take the optional argument constants, see
section "Note on passing external constants" below.
- a state_size attribute. This can be a single integer
(single state) in which case it is the size of the recurrent
state. This can also be a list/tuple of integers (one size per
state).
The state_size can also be TensorShape or tuple/list of
TensorShape, to represent high dimension state.
- a output_size attribute. This can be a single integer or a
TensorShape, which represent the shape of the output. For backward
compatible reason, if this attribute is not available for the
cell, the value will be inferred by the first element of the
state_size.
- a get_initial_state(inputs=None, batch_size=None, dtype=None)
method that creates a tensor meant to be fed to call() as the
initial state, if user didn't specify any initial state via other
means. The returned initial state should be in shape of
[batch, cell.state_size]. Cell might choose to create zero filled
tensor, or with other values based on the cell implementations.
inputs is the input tensor to the RNN layer, which should
contain the batch size as its shape[0], and also dtype. Note that
the shape[0] might be None during the graph construction. Either
the inputs or the pair of batch and dtypeare provided.
batch is a scalar tensor that represent the batch size
of the input. dtype is tf.dtype that represent the dtype of
the input.
For backward compatible reason, if this method is not implemented
by the cell, RNN layer will create a zero filled tensors with the
size of [batch, cell.state_size].
In the case that cell is a list of RNN cell instances, the cells
will be stacked on after the other in the RNN, implementing an
efficient stacked RNN.

return_sequences: Boolean. Whether to return the last output
in the output sequence, or the full sequence.

return_state: Boolean. Whether to return the last state
in addition to the output.

stateful: Boolean (default False). If True, the last state
for each sample at index i in a batch will be used as initial
state for the sample of index i in the following batch.

unroll: Boolean (default False).
If True, the network will be unrolled,
else a symbolic loop will be used.
Unrolling can speed-up a RNN,
although it tends to be more memory-intensive.
Unrolling is only suitable for short sequences.

input_dim: dimensionality of the input (integer or tuple of integers).
This argument (or alternatively, the keyword argument input_shape)
is required when using this layer as the first layer in a model.

input_length: Length of input sequences, to be specified
when it is constant.
This argument is required if you are going to connect
Flatten then Dense layers upstream
(without it, the shape of the dense outputs cannot be computed).
Note that if the recurrent layer is not the first layer
in your model, you would need to specify the input length
at the level of the first layer
(e.g. via the input_shape argument)

time_major: The shape format of the inputs and outputs tensors.
If True, the inputs and outputs will be in shape
(timesteps, batch, ...), whereas in the False case, it will be
(batch, timesteps, ...). Using time_major = True is a bit more
efficient because it avoids transposes at the beginning and end of the
RNN calculation. However, most TensorFlow data is batch-major, so by
default this function accepts input and emits output in batch-major
form.

Output shape:
- if return_state: a list of tensors. The first tensor is
the output. The remaining tensors are the last states,
each with shape (batch_size, state_size), where state_size could
be a high dimension tensor shape.
- if return_sequences: N-D tensor with shape
(batch_size, timesteps, output_size), where output_size could
be a high dimension tensor shape, or
(timesteps, batch_size, output_size) when time_major is True.
- else, N-D tensor with shape (batch_size, output_size), where
output_size could be a high dimension tensor shape.

Masking

This layer supports masking for input data with a variable number
of timesteps. To introduce masks to your data,
use an [Embedding](embeddings) layer with the `mask_zero` parameter
set to `True`.

Note on using statefulness in RNNs

You can set RNN layers to be 'stateful', which means that the states
computed for the samples in one batch will be reused as initial states
for the samples in the next batch. This assumes a one-to-one mapping
between samples in different successive batches.
To enable statefulness:
- specify `stateful=True` in the layer constructor.
- specify a fixed batch size for your model, by passing
if sequential model:
`batch_input_shape=(...)` to the first layer in your model.
else for functional model with 1 or more Input layers:
`batch_shape=(...)` to all the first layers in your model.
This is the expected shape of your inputs
*including the batch size*.
It should be a tuple of integers, e.g. `(32, 10, 100)`.
- specify `shuffle=False` when calling fit().
To reset the states of your model, call `.reset_states()` on either
a specific layer, or on your entire model.

Note on specifying the initial state of RNNs

You can specify the initial state of RNN layers symbolically by
calling them with the keyword argument `initial_state`. The value of
`initial_state` should be a tensor or list of tensors representing
the initial state of the RNN layer.
You can specify the initial state of RNN layers numerically by
calling `reset_states` with the keyword argument `states`. The value of
`states` should be a numpy array or list of numpy arrays representing
the initial state of the RNN layer.

Note on passing external constants to RNNs

You can pass "external" constants to the cell using the `constants`
keyword argument of `RNN.__call__` (as well as `RNN.call`) method. This
requires that the `cell.call` method accepts the same keyword argument
`constants`. Such constants can be used to condition the cell
transformation on additional static inputs (not changing over time),
a.k.a. an attention mechanism.

Returns:

Methods

__call__

Arguments:

inputs: input tensor(s).

*args: additional positional arguments to be passed to self.call.

**kwargs: additional keyword arguments to be passed to self.call.

Returns:

Output tensor(s).

Note:
- The following optional keyword arguments are reserved for specific uses:
* training: Boolean scalar tensor of Python boolean indicating
whether the call is meant for training or inference.
* mask: Boolean input mask.
- If the layer's call method takes a mask argument (as some Keras
layers do), its default value will be set to the mask generated
for inputs by the previous layer (if input did come from
a layer that generated a corresponding mask, i.e. if it came from
a Keras layer with masking support.

Returns:

build

Creates the variables of the layer (optional, for subclass implementers).

This is a method that implementers of subclasses of Layer or Model
can override if they need a state-creation step in-between
layer instantiation and layer call.

This is typically used to create the weights of Layer subclasses.

Arguments:

input_shape: Instance of TensorShape, or list of instances of
TensorShape if the layer expects a list of inputs
(one instance per input).

compute_mask

compute_mask(
inputs,
mask
)

Computes an output mask tensor.

Arguments:

inputs: Tensor or list of tensors.

mask: Tensor or list of tensors.

Returns:

None or a tensor (or list of tensors,
one per output tensor of the layer).

compute_output_shape

compute_output_shape(input_shape)

Computes the output shape of the layer.

Assumes that the layer will be built
to match that input shape provided.

Arguments:

input_shape: Shape tuple (tuple of integers)
or list of shape tuples (one per output tensor of the layer).
Shape tuples can include None for free dimensions,
instead of an integer.

Returns:

An input shape tuple.

count_params

count_params()

Count the total number of scalars composing the weights.

Returns:

An integer count.

Raises:

ValueError: if the layer isn't yet built
(in which case its weights aren't yet defined).

from_config

@classmethod
from_config(
cls,
config,
custom_objects=None
)

Creates a layer from its config.

This method is the reverse of get_config,
capable of instantiating the same layer from the config
dictionary. It does not handle layer connectivity
(handled by Network), nor weights (handled by set_weights).

Arguments:

config: A Python dictionary, typically the
output of get_config.

Returns:

A layer instance.

get_config

get_config()

Returns the config of the layer.

A layer config is a Python dictionary (serializable)
containing the configuration of a layer.
The same layer can be reinstantiated later
(without its trained weights) from this configuration.

The config of a layer does not include connectivity
information, nor the layer class name. These are handled
by Network (one layer of abstraction above).

Returns:

Python dictionary.

get_initial_state

get_initial_state(inputs)

get_input_at

get_input_at(node_index)

Retrieves the input tensor(s) of a layer at a given node.

Arguments:

node_index: Integer, index of the node
from which to retrieve the attribute.
E.g. node_index=0 will correspond to the
first time the layer was called.

Returns:

A tensor (or list of tensors if the layer has multiple inputs).

Raises:

RuntimeError: If called in Eager mode.

get_input_mask_at

get_input_mask_at(node_index)

Retrieves the input mask tensor(s) of a layer at a given node.

Arguments:

node_index: Integer, index of the node
from which to retrieve the attribute.
E.g. node_index=0 will correspond to the
first time the layer was called.

Returns:

A mask tensor
(or list of tensors if the layer has multiple inputs).

get_input_shape_at

get_input_shape_at(node_index)

Retrieves the input shape(s) of a layer at a given node.

Arguments:

node_index: Integer, index of the node
from which to retrieve the attribute.
E.g. node_index=0 will correspond to the
first time the layer was called.

Returns:

A shape tuple
(or list of shape tuples if the layer has multiple inputs).

Raises:

RuntimeError: If called in Eager mode.

get_losses_for

get_losses_for(inputs)

Retrieves losses relevant to a specific set of inputs.

Arguments:

inputs: Input tensor or list/tuple of input tensors.

Returns:

List of loss tensors of the layer that depend on inputs.

Raises:

RuntimeError: If called in Eager mode.

get_output_at

get_output_at(node_index)

Retrieves the output tensor(s) of a layer at a given node.

Arguments:

node_index: Integer, index of the node
from which to retrieve the attribute.
E.g. node_index=0 will correspond to the
first time the layer was called.

Returns:

A tensor (or list of tensors if the layer has multiple outputs).

Raises:

RuntimeError: If called in Eager mode.

get_output_mask_at

get_output_mask_at(node_index)

Retrieves the output mask tensor(s) of a layer at a given node.

Arguments:

node_index: Integer, index of the node
from which to retrieve the attribute.
E.g. node_index=0 will correspond to the
first time the layer was called.

Returns:

A mask tensor
(or list of tensors if the layer has multiple outputs).

get_output_shape_at

get_output_shape_at(node_index)

Retrieves the output shape(s) of a layer at a given node.

Arguments:

node_index: Integer, index of the node
from which to retrieve the attribute.
E.g. node_index=0 will correspond to the
first time the layer was called.

Returns:

A shape tuple
(or list of shape tuples if the layer has multiple outputs).

Raises:

RuntimeError: If called in Eager mode.

get_updates_for

get_updates_for(inputs)

Retrieves updates relevant to a specific set of inputs.

Arguments:

inputs: Input tensor or list/tuple of input tensors.

Returns:

List of update ops of the layer that depend on inputs.

Raises:

RuntimeError: If called in Eager mode.

get_weights

get_weights()

Returns the current weights of the layer.

Returns:

Weights values as a list of numpy arrays.

reset_states

reset_states(states=None)

set_weights

set_weights(weights)

Sets the weights of the layer, from Numpy arrays.

Arguments:

weights: a list of Numpy arrays. The number
of arrays and their shape must match
number of the dimensions of the weights
of the layer (i.e. it should match the
output of get_weights).

Raises:

ValueError: If the provided weights list does not match the
layer's specifications.