class_docstr: Cell class for SimpleRNN.
  
  This class processes one step within the whole time sequence input, whereas
  `keras.layer.SimpleRNN` processes the whole sequence.
  
  Args:
      units: Positive integer, dimensionality of the output space.
      activation: Activation function to use.
          Default: hyperbolic tangent (`tanh`).
          If you pass `None`, no activation is applied
          (ie. "linear" activation: `a(x) = x`).
      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"`.
      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`.
      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:
      sequence: A 2D tensor, with shape `(batch, features)`.
      states: A 2D tensor with shape `(batch, units)`, which is the state
          from the previous time step.
      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.
  
  Example:
  
  ```python
  inputs = np.random.random([32, 10, 8]).astype(np.float32)
  rnn = keras.layers.RNN(keras.layers.SimpleRNNCell(4))
  output = rnn(inputs)  # The output has shape `(32, 4)`.
  rnn = keras.layers.RNN(
      keras.layers.SimpleRNNCell(4),
      return_sequences=True,
      return_state=True
  )
  # whole_sequence_output has shape `(32, 10, 4)`.
  # final_state has shape `(32, 4)`.
  whole_sequence_output, final_state = rnn(inputs)
  ```
code: def __init__(
      self,
      units,
      activation="tanh",
      use_bias=True,
      kernel_initializer="glorot_uniform",
      recurrent_initializer="orthogonal",
      bias_initializer="zeros",
      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,
  ):
      if units <= 0:
          raise ValueError(
              "Received an invalid value for argument `units`, "
              f"expected a positive integer, got {units}."
          )
      super().__init__(**kwargs)
      self.seed = seed
      self.seed_generator = backend.random.SeedGenerator(seed)
  
      self.units = units
      self.activation = activations.get(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.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.state_size = self.units
      self.output_size = self.units
  
imports: 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.api_export import keras_export
  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
label_desc: Use image node_id 1 to create a new SimpleRNNCell object from inherited base classes: Layer, DropoutRNNCell with example: obj = SimpleRNNCell(units, activation, use_bias, kernel_initializer, recurrent_initializer, bias_initializer, kernel_regularizer, recurrent_regularizer, bias_regularizer, kernel_constraint, recurrent_constraint, bias_constraint, dropout, recurrent_dropout, seed)