class_docstr: Abstract N-D Convolutional LSTM layer (used as implementation base).
  
  Similar to an LSTM layer, but the input transformations
  and recurrent transformations are both convolutional.
  
  Args:
      rank: Integer, rank of the convolution, e.g. "2" for 2D convolutions.
      filters: Integer, the dimensionality of the output space
          (i.e. the number of output filters in the convolution).
      kernel_size: An integer or tuple/list of n integers, specifying the
          dimensions of the convolution window.
      strides: An integer or tuple/list of n integers,
          specifying the strides of the convolution.
          Specifying any stride value != 1 is incompatible with specifying
          any `dilation_rate` value != 1.
      padding: One of `"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: A string,
          one of `channels_last` (default) or `channels_first`.
          The ordering of the dimensions in the inputs.
          `channels_last` corresponds to inputs with shape
          `(batch, time, ..., channels)`
          while `channels_first` corresponds to
          inputs with shape `(batch, time, channels, ...)`.
          When unspecified, uses
          `image_data_format` value found in your Keras config file at
          `~/.keras/keras.json` (if exists) else 'channels_last'.
          Defaults to `'channels_last'`.
      dilation_rate: An integer or tuple/list of n integers, specifying
          the dilation rate to use for dilated convolution.
          Currently, specifying any `dilation_rate` value != 1 is
          incompatible with specifying any `strides` value != 1.
      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](
          http://www.jmlr.org/proceedings/papers/v37/jozefowicz15.pdf)
      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.
      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.
code: def __init__(
      self,
      rank,
      filters,
      kernel_size,
      strides=1,
      padding="valid",
      data_format=None,
      dilation_rate=1,
      activation="tanh",
      recurrent_activation="sigmoid",
      use_bias=True,
      kernel_initializer="glorot_uniform",
      recurrent_initializer="orthogonal",
      bias_initializer="zeros",
      unit_forget_bias=True,
      kernel_regularizer=None,
      recurrent_regularizer=None,
      bias_regularizer=None,
      kernel_constraint=None,
      recurrent_constraint=None,
      bias_constraint=None,
      dropout=0.0,
      recurrent_dropout=0.0,
      seed=None,
      return_sequences=False,
      return_state=False,
      go_backwards=False,
      stateful=False,
      **kwargs,
  ):
      cell = ConvLSTMCell(
          rank=rank,
          filters=filters,
          kernel_size=kernel_size,
          strides=strides,
          padding=padding,
          data_format=data_format,
          dilation_rate=dilation_rate,
          activation=activation,
          recurrent_activation=recurrent_activation,
          use_bias=use_bias,
          kernel_initializer=kernel_initializer,
          recurrent_initializer=recurrent_initializer,
          bias_initializer=bias_initializer,
          unit_forget_bias=unit_forget_bias,
          kernel_regularizer=kernel_regularizer,
          recurrent_regularizer=recurrent_regularizer,
          bias_regularizer=bias_regularizer,
          kernel_constraint=kernel_constraint,
          recurrent_constraint=recurrent_constraint,
          bias_constraint=bias_constraint,
          dropout=dropout,
          recurrent_dropout=recurrent_dropout,
          seed=seed,
          name="conv_lstm_cell",
          dtype=kwargs.get("dtype"),
      )
      super().__init__(
          cell,
          return_sequences=return_sequences,
          return_state=return_state,
          go_backwards=go_backwards,
          stateful=stateful,
          **kwargs,
      )
      self.input_spec = InputSpec(ndim=rank + 3)
  
imports: import tree
  from keras import activations
  from keras import backend
  from keras import constraints
  from keras import initializers
  from keras import ops
  from keras import regularizers
  from keras.layers.input_spec import InputSpec
  from keras.layers.layer import Layer
  from keras.layers.rnn.dropout_rnn_cell import DropoutRNNCell
  from keras.layers.rnn.rnn import RNN
  from keras.ops import operation_utils
  from keras.utils import argument_validation
label_desc: Use image node_id 1 to create a new ConvLSTM object from inherited base classes: RNN with example: obj = ConvLSTM(rank, filters, kernel_size, strides, padding, data_format, dilation_rate, activation, recurrent_activation, use_bias, kernel_initializer, recurrent_initializer, bias_initializer, unit_forget_bias, kernel_regularizer, recurrent_regularizer, bias_regularizer, kernel_constraint, recurrent_constraint, bias_constraint, dropout, recurrent_dropout, seed, return_sequences, return_state, go_backwards, stateful)