class_docstr: TF Basic LSTM recurrent network cell with extra customization params.
  
  The implementation is based on: http://arxiv.org/abs/1409.2329.
  
  We add forget_bias (default: 1) to the biases of the forget gate in order to
  reduce the scale of forgetting in the beginning of the training.
  
  It does not allow cell clipping, a projection layer, and does not
  use peep-hole connections: it is the basic baseline.
  
  For advanced models, please use the full LSTMCell that follows.
class_docstr_tok: ["TF","Basic","LSTM","recurrent","network","cell","with","extra","customization","params",".","The","implementation","is","based","on",":","http",":","\/\/arxiv.org\/abs\/1409.2329",".","We","add","forget_bias","(","default",":","1",")","to","the","biases","of","the","forget","gate","in","order","to","reduce","the","scale","of","forgetting","in","the","beginning","of","the","training",".","It","does","not","allow","cell","clipping",",","a","projection","layer",",","and","does","not","use","peep-hole","connections",":","it","is","the","basic","baseline",".","For","advanced","models",",","please","use","the","full","LSTMCell","that","follows","."]
docstr: Long short-term memory cell (LSTM).
code: def __call__(self, inputs, state, scope=None):
      """Long short-term memory cell (LSTM)."""
      with tf.variable_scope(
          scope or type(self).__name__
      ):  # "BasicLSTMCell"
          # Parameters of gates are concatenated into one multiply for efficiency.
          if self._state_is_tuple:
              c, h = state
          else:
              c, h = array_ops.split(1, 2, state)
          concat = _linear(
              [inputs, h],
              4 * self._num_units,
              True,
              0.0,
              self.weights_init,
              self.trainable,
              self.restore,
              self.reuse,
          )
  
          # i = input_gate, j = new_input, f = forget_gate, o = output_gate
          i, j, f, o = array_ops.split(
              value=concat, num_or_size_splits=4, axis=1
          )
  
          # apply batch normalization to inner state and gates
          if self.batch_norm == True:
              i = batch_normalization(
                  i,
                  gamma=0.1,
                  trainable=self.trainable,
                  restore=self.restore,
                  reuse=self.reuse,
              )
              j = batch_normalization(
                  j,
                  gamma=0.1,
                  trainable=self.trainable,
                  restore=self.restore,
                  reuse=self.reuse,
              )
              f = batch_normalization(
                  f,
                  gamma=0.1,
                  trainable=self.trainable,
                  restore=self.restore,
                  reuse=self.reuse,
              )
              o = batch_normalization(
                  o,
                  gamma=0.1,
                  trainable=self.trainable,
                  restore=self.restore,
                  reuse=self.reuse,
              )
  
          new_c = c * self._inner_activation(
              f + self._forget_bias
          ) + self._inner_activation(i) * self._activation(j)
  
          # hidden-to-hidden batch normalizaiton
          if self.batch_norm == True:
              batch_norm_new_c = batch_normalization(
                  new_c,
                  gamma=0.1,
                  trainable=self.trainable,
                  restore=self.restore,
                  reuse=self.reuse,
              )
              new_h = self._activation(
                  batch_norm_new_c
              ) * self._inner_activation(o)
          else:
              new_h = self._activation(new_c) * self._inner_activation(
                  o
              )
  
          if self._state_is_tuple:
              new_state = core_rnn_cell.LSTMStateTuple(new_c, new_h)
          else:
              new_state = array_ops.concat([new_c, new_h], 1)
  
          # Retrieve RNN Variables
          with tf.variable_scope("Linear", reuse=True):
              self.W = tf.get_variable("Matrix")
              self.b = tf.get_variable("Bias")
  
          return new_h, new_state
  
imports: from __future__ import division, print_function, absolute_import
  import logging
  import numpy
  import tensorflow.compat.v1
  from tensorflow.python.ops import array_ops
  from tensorflow.python.util.nest import is_sequence
  from ..None import config
  from ..None import utils
  from ..None import activations
  from ..None import initializations
  from ..None import variables
  from .normalization import batch_normalization
label_desc: Use image node_id 4 for calling the BasicLSTMCell obj's underlying member method code with example usage: obj.__call__(inputs, state, scope) and returns: new_h,  new_state