class_docstr: Cell class for the ConvLSTM layer.
  
  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`. 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. If `None`, no activation is applied.
      recurrent_activation: Activation function to use for the recurrent step.
      use_bias: Boolean, (default `True`), whether the layer
          should use a bias vector.
      kernel_initializer: Initializer for the `kernel` weights matrix,
          used for the linear transformation of the inputs. Default:
          `"glorot_uniform"`.
      recurrent_initializer: Initializer for the `recurrent_kernel`
          weights matrix, used for the linear transformation of the recurrent
          state. Default: `"orthogonal"`.
      bias_initializer: Initializer for the bias vector. Default: `"zeros"`.
      unit_forget_bias: Boolean (default `True`). If `True`,
          add 1 to the bias of the forget gate at initialization.
          Setting it to `True` will also force `bias_initializer="zeros"`.
          This is recommended in [Jozefowicz et al.](
          https://github.com/mlresearch/v37/blob/gh-pages/jozefowicz15.pdf)
      kernel_regularizer: Regularizer function applied to the `kernel` weights
          matrix. Default: `None`.
      recurrent_regularizer: Regularizer function applied to the
          `recurrent_kernel` weights matrix. Default: `None`.
      bias_regularizer: Regularizer function applied to the bias vector.
          Default: `None`.
      activity_regularizer: Regularizer function applied to the output of the
          layer (its "activation"). Default: `None`.
      kernel_constraint: Constraint function applied to the `kernel` weights
          matrix. Default: `None`.
      recurrent_constraint: Constraint function applied to the
          `recurrent_kernel` weights matrix. Default: `None`.
      bias_constraint: Constraint function applied to the bias vector.
          Default: `None`.
      dropout: Float between 0 and 1. Fraction of the units to drop for the
          linear transformation of the inputs. Default: 0.
      recurrent_dropout: Float between 0 and 1. Fraction of the units to drop
          for the linear transformation of the recurrent state. Default: 0.
      seed: Random seed for dropout.
  
  Call arguments:
      inputs: A (2+ `rank`)D tensor.
      states:  List of state tensors corresponding to the previous timestep.
      training: Python boolean indicating whether the layer should behave in
          training mode or in inference mode. Only relevant when `dropout` or
          `recurrent_dropout` is used.
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,
      **kwargs,
  ):
      super().__init__(**kwargs)
      self.seed = seed
      self.seed_generator = backend.random.SeedGenerator(seed=seed)
      self.rank = rank
      if self.rank > 3:
          raise ValueError(
              f"Rank {rank} convolutions are not currently "
              f"implemented. Received: rank={rank}"
          )
      self.filters = filters
      self.kernel_size = argument_validation.standardize_tuple(
          kernel_size, self.rank, "kernel_size"
      )
      self.strides = argument_validation.standardize_tuple(
          strides, self.rank, "strides", allow_zero=True
      )
      self.padding = argument_validation.standardize_padding(padding)
      self.data_format = backend.standardize_data_format(data_format)
      self.dilation_rate = argument_validation.standardize_tuple(
          dilation_rate, self.rank, "dilation_rate"
      )
      self.activation = activations.get(activation)
      self.recurrent_activation = activations.get(recurrent_activation)
      self.use_bias = use_bias
  
      self.kernel_initializer = initializers.get(kernel_initializer)
      self.recurrent_initializer = initializers.get(
          recurrent_initializer
      )
      self.bias_initializer = initializers.get(bias_initializer)
      self.unit_forget_bias = unit_forget_bias
  
      self.kernel_regularizer = regularizers.get(kernel_regularizer)
      self.recurrent_regularizer = regularizers.get(
          recurrent_regularizer
      )
      self.bias_regularizer = regularizers.get(bias_regularizer)
  
      self.kernel_constraint = constraints.get(kernel_constraint)
      self.recurrent_constraint = constraints.get(recurrent_constraint)
      self.bias_constraint = constraints.get(bias_constraint)
  
      self.dropout = min(1.0, max(0.0, dropout))
      self.recurrent_dropout = min(1.0, max(0.0, recurrent_dropout))
      self.input_spec = InputSpec(ndim=rank + 2)
      self.state_size = -1
  
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 ConvLSTMCell object from inherited base classes: Layer, DropoutRNNCell with example: obj = ConvLSTMCell(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)