class_docstr: Cell class for LayerNormSimpleRNN.
  
  References:
  [1] Ba, Jimmy Lei, Jamie Ryan Kiros, and Geoffrey E. Hinton.
      "Layer Normalization." ArXiv:1607.06450 [Cs, Stat],
      July 21, 2016. http://arxiv.org/abs/1607.06450
  
  Example:
  
  >>> inputs = np.random.random([30,23,9]).astype(np.float32)
  >>> lnsRNNCell = tfa.rnn.LayerNormSimpleRNNCell(4)
  >>> rnn = tf.keras.layers.RNN(lnsRNNCell, return_sequences=True, return_state=True)
  >>> outputs, memory_state = rnn(inputs)
  >>> outputs.shape
  TensorShape([30, 23, 4])
  >>> memory_state.shape
  TensorShape([30, 4])
  
  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 uses a bias
      vector.
    layernorm_epsilon: Float, (default `1e-5`), Small float added to variance
      to avoid dividing by zero.
    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 (`use_bias=True`).
       Default: `zeros`.
    gamma_initializer: Initializer for the gamma vector of the layer
       normalization layer. Default: `ones`.
    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
       (`use_bias=True`). Default: `None`.
    gamma_regularizer: Regularizer function applied to the gamma vector
       of the layer normalization layer. 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
       (`use_bias=True`). Default: `None`.
    gamma_constraint: Constraint function applied to the gamma vector
       of the layer normalization layer. 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.
  
  Call arguments:
    inputs: A 2D tensor, with shape of `[batch, feature]`.
    states: A 2D tensor with shape of `[batch, units]`, which is the state
      from the previous time step. For timestep 0, the initial state provided
      by the user will be feed to cell.
    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.
  
  Examples:
  
  >>> inputs = np.random.random([32, 10, 8]).astype(np.float32)
  >>> rnn = tf.keras.layers.RNN(tfa.rnn.LayerNormSimpleRNNCell(4))
  >>> output = rnn(inputs)  # The output has shape `[32, 4]`.
  >>> rnn = tf.keras.layers.RNN(
  ... tfa.rnn.LayerNormSimpleRNNCell(4),
  ... return_sequences=True,
  ... return_state=True)
  >>> whole_sequence_output, final_state = rnn(inputs)
  >>> whole_sequence_output
  <tf.Tensor: shape=(32, 10, 4), dtype=float32, numpy=...>
  >>> final_state
  <tf.Tensor: shape=(32, 4), dtype=float32, numpy=...>
code: def __init__(
      self,
      units: TensorLike,
      activation: Activation = "tanh",
      use_bias: bool = True,
      layernorm_epsilon: FloatTensorLike = 1e-05,
      kernel_initializer: Initializer = "glorot_uniform",
      recurrent_initializer: Initializer = "orthogonal",
      bias_initializer: Initializer = "zeros",
      gamma_initializer: Initializer = "ones",
      kernel_regularizer: Regularizer = None,
      recurrent_regularizer: Regularizer = None,
      bias_regularizer: Regularizer = None,
      gamma_regularizer: Regularizer = None,
      kernel_constraint: Regularizer = None,
      recurrent_constraint: Constraint = None,
      bias_constraint: Constraint = None,
      gamma_constraint: Constraint = None,
      dropout: FloatTensorLike = 0.0,
      recurrent_dropout: FloatTensorLike = 0.0,
      **kwargs,
  ):
      super(LayerNormSimpleRNNCell, self).__init__(
          units,
          activation=activation,
          use_bias=use_bias,
          kernel_initializer=kernel_initializer,
          recurrent_initializer=recurrent_initializer,
          bias_initializer=bias_initializer,
          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,
          **kwargs,
      )
      self.layernorm = keras.layers.LayerNormalization(
          axis=-1,
          epsilon=layernorm_epsilon,
          center=False,
          scale=True,
          beta_initializer=None,
          gamma_initializer=gamma_initializer,
          beta_regularizer=None,
          gamma_regularizer=gamma_regularizer,
          beta_constraint=None,
          gamma_constraint=gamma_constraint,
          **kwargs,
      )
  
file_path: addons/tensorflow_addons/rnn/layer_norm_simple_rnn_cell.py
imports: import tensorflow
  import tensorflow.keras
  from typeguard import typechecked
  from tensorflow_addons.utils.types import Activation, FloatTensorLike, TensorLike, Initializer, Constraint, Regularizer
label_desc: Use image node_id 1 to create a new LayerNormSimpleRNNCell object from inherited base classes: keras.layers with example: obj = LayerNormSimpleRNNCell(units, activation, use_bias, layernorm_epsilon, kernel_initializer, recurrent_initializer, bias_initializer, gamma_initializer, kernel_regularizer, recurrent_regularizer, bias_regularizer, gamma_regularizer, kernel_constraint, recurrent_constraint, bias_constraint, gamma_constraint, dropout, recurrent_dropout)