Similar to an LSTM layer, but the input transformations and recurrent transformations are both convolutional.

## Usage

```
layer_conv_lstm_2d(
object,
filters,
kernel_size,
strides = 1L,
padding = "valid",
data_format = NULL,
dilation_rate = 1L,
activation = "tanh",
recurrent_activation = "sigmoid",
use_bias = TRUE,
kernel_initializer = "glorot_uniform",
recurrent_initializer = "orthogonal",
bias_initializer = "zeros",
unit_forget_bias = TRUE,
kernel_regularizer = NULL,
recurrent_regularizer = NULL,
bias_regularizer = NULL,
activity_regularizer = NULL,
kernel_constraint = NULL,
recurrent_constraint = NULL,
bias_constraint = NULL,
dropout = 0,
recurrent_dropout = 0,
seed = NULL,
return_sequences = FALSE,
return_state = FALSE,
go_backwards = FALSE,
stateful = FALSE,
...,
unroll = NULL
)
```

## Arguments

- object
Object to compose the layer with. A tensor, array, or sequential model.

- filters
int, the dimension of the output space (the number of filters in the convolution).

- kernel_size
int or tuple/list of 2 integers, specifying the size of the convolution window.

- strides
int or tuple/list of 2 integers, specifying the stride length of the convolution.

`strides > 1`

is incompatible with`dilation_rate > 1`

.- padding
string,

`"valid"`

or`"same"`

(case-insensitive).`"valid"`

means no padding.`"same"`

results in padding evenly to the left/right or up/down of the input such that output has the same height/width dimension as the input.- data_format
string, either

`"channels_last"`

or`"channels_first"`

. The ordering of the dimensions in the inputs.`"channels_last"`

corresponds to inputs with shape`(batch, steps, features)`

while`"channels_first"`

corresponds to inputs with shape`(batch, features, steps)`

. It defaults to the`image_data_format`

value found in your Keras config file at`~/.keras/keras.json`

. If you never set it, then it will be`"channels_last"`

.- dilation_rate
int or tuple/list of 2 integers, specifying the dilation rate to use for dilated convolution.

- activation
Activation function to use. By default hyperbolic tangent activation function is applied (

`tanh(x)`

).- recurrent_activation
Activation function to use for the recurrent step.

- use_bias
Boolean, whether the layer uses a bias vector.

- kernel_initializer
Initializer for the

`kernel`

weights matrix, used for the linear transformation of the inputs.- recurrent_initializer
Initializer for the

`recurrent_kernel`

weights matrix, used for the linear transformation of the recurrent state.- bias_initializer
Initializer for the bias vector.

- unit_forget_bias
Boolean. If

`TRUE`

, add 1 to the bias of the forget gate at initialization. Use in combination with`bias_initializer="zeros"`

. This is recommended in Jozefowicz et al., 2015- kernel_regularizer
Regularizer function applied to the

`kernel`

weights matrix.- recurrent_regularizer
Regularizer function applied to the

`recurrent_kernel`

weights matrix.- bias_regularizer
Regularizer function applied to the bias vector.

- activity_regularizer
Regularizer function applied to.

- kernel_constraint
Constraint function applied to the

`kernel`

weights matrix.- recurrent_constraint
Constraint function applied to the

`recurrent_kernel`

weights matrix.- bias_constraint
Constraint function applied to the bias vector.

- dropout
Float between 0 and 1. Fraction of the units to drop for the linear transformation of the inputs.

- recurrent_dropout
Float between 0 and 1. Fraction of the units to drop for the linear transformation of the recurrent state.

- seed
Random seed for dropout.

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

`FALSE`

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

`FALSE`

.- go_backwards
Boolean (default:

`FALSE`

). If`TRUE`

, process the input sequence backwards and return the reversed sequence.- 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.- ...
For forward/backward compatability.

- 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.

## Value

The return value depends on the value provided for the first argument.
If `object`

is:

a

`keras_model_sequential()`

, then the layer is added to the sequential model (which is modified in place). To enable piping, the sequential model is also returned, invisibly.a

`keras_input()`

, then the output tensor from calling`layer(input)`

is returned.`NULL`

or missing, then a`Layer`

instance is returned.

## Call Arguments

`inputs`

: A 5D tensor.`mask`

: Binary tensor of shape`(samples, timesteps)`

indicating whether a given timestep should be masked.`training`

: Python boolean indicating whether the layer should behave in training mode or in inference mode. This is only relevant if`dropout`

or`recurrent_dropout`

are set.`initial_state`

: List of initial state tensors to be passed to the first call of the cell.

## Input Shape

If

`data_format='channels_first'`

: 5D tensor with shape:`(samples, time, channels, rows, cols)`

If

`data_format='channels_last'`

: 5D tensor with shape:`(samples, time, rows, cols, channels)`

## Output Shape

If

`return_state`

: a list of tensors. The first tensor is the output. The remaining tensors are the last states, each 4D tensor with shape:`(samples, filters, new_rows, new_cols)`

if`data_format='channels_first'`

or shape:`(samples, new_rows, new_cols, filters)`

if`data_format='channels_last'`

.`rows`

and`cols`

values might have changed due to padding.If

`return_sequences`

: 5D tensor with shape:`(samples, timesteps, filters, new_rows, new_cols)`

if data_format='channels_first' or shape:`(samples, timesteps, new_rows, new_cols, filters)`

if`data_format='channels_last'`

.Else, 4D tensor with shape:

`(samples, filters, new_rows, new_cols)`

if`data_format='channels_first'`

or shape:`(samples, new_rows, new_cols, filters)`

if`data_format='channels_last'`

.

## References

Shi et al., 2015 (the current implementation does not include the feedback loop on the cells output).

## See also

Other rnn layers: `layer_bidirectional()`

`layer_conv_lstm_1d()`

`layer_conv_lstm_3d()`

`layer_gru()`

`layer_lstm()`

`layer_rnn()`

`layer_simple_rnn()`

`layer_time_distributed()`

`rnn_cell_gru()`

`rnn_cell_lstm()`

`rnn_cell_simple()`

`rnn_cells_stack()`

Other layers: `Layer()`

`layer_activation()`

`layer_activation_elu()`

`layer_activation_leaky_relu()`

`layer_activation_parametric_relu()`

`layer_activation_relu()`

`layer_activation_softmax()`

`layer_activity_regularization()`

`layer_add()`

`layer_additive_attention()`

`layer_alpha_dropout()`

`layer_attention()`

`layer_average()`

`layer_average_pooling_1d()`

`layer_average_pooling_2d()`

`layer_average_pooling_3d()`

`layer_batch_normalization()`

`layer_bidirectional()`

`layer_category_encoding()`

`layer_center_crop()`

`layer_concatenate()`

`layer_conv_1d()`

`layer_conv_1d_transpose()`

`layer_conv_2d()`

`layer_conv_2d_transpose()`

`layer_conv_3d()`

`layer_conv_3d_transpose()`

`layer_conv_lstm_1d()`

`layer_conv_lstm_3d()`

`layer_cropping_1d()`

`layer_cropping_2d()`

`layer_cropping_3d()`

`layer_dense()`

`layer_depthwise_conv_1d()`

`layer_depthwise_conv_2d()`

`layer_discretization()`

`layer_dot()`

`layer_dropout()`

`layer_einsum_dense()`

`layer_embedding()`

`layer_feature_space()`

`layer_flatten()`

`layer_flax_module_wrapper()`

`layer_gaussian_dropout()`

`layer_gaussian_noise()`

`layer_global_average_pooling_1d()`

`layer_global_average_pooling_2d()`

`layer_global_average_pooling_3d()`

`layer_global_max_pooling_1d()`

`layer_global_max_pooling_2d()`

`layer_global_max_pooling_3d()`

`layer_group_normalization()`

`layer_group_query_attention()`

`layer_gru()`

`layer_hashed_crossing()`

`layer_hashing()`

`layer_identity()`

`layer_integer_lookup()`

`layer_jax_model_wrapper()`

`layer_lambda()`

`layer_layer_normalization()`

`layer_lstm()`

`layer_masking()`

`layer_max_pooling_1d()`

`layer_max_pooling_2d()`

`layer_max_pooling_3d()`

`layer_maximum()`

`layer_mel_spectrogram()`

`layer_minimum()`

`layer_multi_head_attention()`

`layer_multiply()`

`layer_normalization()`

`layer_permute()`

`layer_random_brightness()`

`layer_random_contrast()`

`layer_random_crop()`

`layer_random_flip()`

`layer_random_rotation()`

`layer_random_translation()`

`layer_random_zoom()`

`layer_repeat_vector()`

`layer_rescaling()`

`layer_reshape()`

`layer_resizing()`

`layer_rnn()`

`layer_separable_conv_1d()`

`layer_separable_conv_2d()`

`layer_simple_rnn()`

`layer_spatial_dropout_1d()`

`layer_spatial_dropout_2d()`

`layer_spatial_dropout_3d()`

`layer_spectral_normalization()`

`layer_string_lookup()`

`layer_subtract()`

`layer_text_vectorization()`

`layer_tfsm()`

`layer_time_distributed()`

`layer_torch_module_wrapper()`

`layer_unit_normalization()`

`layer_upsampling_1d()`

`layer_upsampling_2d()`

`layer_upsampling_3d()`

`layer_zero_padding_1d()`

`layer_zero_padding_2d()`

`layer_zero_padding_3d()`

`rnn_cell_gru()`

`rnn_cell_lstm()`

`rnn_cell_simple()`

`rnn_cells_stack()`