class_docstr: FusedRNNCell implementation of LSTM.
  
  This is an extremely efficient LSTM implementation, that uses a single TF op
  for the entire LSTM. It should be both faster and more memory-efficient than
  LSTMBlockCell defined above.
  
  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.
  
  The variable naming is consistent with `rnn_cell_impl.LSTMCell`.
docstr: Run this LSTM on inputs, starting from the given state.
  
  Args:
    inputs: `3-D` tensor with shape `[time_len, batch_size, input_size]`
    initial_cell_state: initial value for cell state, shape `[batch_size,
      self._num_units]`
    initial_output: initial value of cell output, shape `[batch_size,
      self._num_units]`
    dtype: The data type for the initial state and expected output.
    sequence_length: Specifies the length of each sequence in inputs. An
      `int32` or `int64` vector (tensor) size `[batch_size]`, values in `[0,
      time_len)` or None.
  
  Returns:
    A pair containing:
  
    - Cell state (cs): A `3-D` tensor of shape `[time_len, batch_size,
                       output_size]`
    - Output (h): A `3-D` tensor of shape `[time_len, batch_size,
                  output_size]`
docstr_tok: ["Run","this","LSTM","on","inputs",",","starting","from","the","given","state",".","Args",":","inputs",":","`","3-D","`","tensor","with","shape","`","[","time_len",",","batch_size",",","input_size","]","`","initial_cell_state",":","initial","value","for","cell","state",",","shape","`","[","batch_size",",","self._num_units","]","`","initial_output",":","initial","value","of","cell","output",",","shape","`","[","batch_size",",","self._num_units","]","`","dtype",":","The","data","type","for","the","initial","state","and","expected","output",".","sequence_length",":","Specifies","the","length","of","each","sequence","in","inputs",".","An","`","int32","`","or","`","int64","`","vector","(","tensor",")","size","`","[","batch_size","]","`",",","values","in","`","[","0",",","time_len",")","`","or","None",".","Returns",":","A","pair","containing",":","-","Cell","state","(","cs",")",":","A","`","3-D","`","tensor","of","shape","`","[","time_len",",","batch_size",",","output_size","]","`","-","Output","(","h",")",":","A","`","3-D","`","tensor","of","shape","`","[","time_len",",","batch_size",",","output_size","]","`"]
code: def _call_cell(
      self,
      inputs,
      initial_cell_state=None,
      initial_output=None,
      dtype=None,
      sequence_length=None,
  ):
      """Run this LSTM on inputs, starting from the given state.
  
      Args:
        inputs: `3-D` tensor with shape `[time_len, batch_size, input_size]`
        initial_cell_state: initial value for cell state, shape `[batch_size,
          self._num_units]`
        initial_output: initial value of cell output, shape `[batch_size,
          self._num_units]`
        dtype: The data type for the initial state and expected output.
        sequence_length: Specifies the length of each sequence in inputs. An
          `int32` or `int64` vector (tensor) size `[batch_size]`, values in `[0,
          time_len)` or None.
  
      Returns:
        A pair containing:
  
        - Cell state (cs): A `3-D` tensor of shape `[time_len, batch_size,
                           output_size]`
        - Output (h): A `3-D` tensor of shape `[time_len, batch_size,
                      output_size]`
      """
  
      inputs_shape = inputs.get_shape().with_rank(3)
      time_len = inputs_shape.dims[0].value
      if time_len is None:
          time_len = array_ops.shape(inputs)[0]
  
      if self._use_peephole:
          wci = self._w_i_diag
          wco = self._w_o_diag
          wcf = self._w_f_diag
      else:
          wci = wcf = wco = array_ops.zeros(
              [self._num_units], dtype=dtype
          )
  
      if sequence_length is None:
          max_seq_len = math_ops.cast(time_len, dtypes.int64)
      else:
          max_seq_len = math_ops.cast(
              math_ops.reduce_max(sequence_length), dtypes.int64
          )
  
      _, cs, _, _, _, _, h = gen_rnn_ops.block_lstm(
          seq_len_max=max_seq_len,
          x=inputs,
          cs_prev=initial_cell_state,
          h_prev=initial_output,
          w=self._kernel,
          wci=wci,
          wcf=wcf,
          wco=wco,
          b=self._bias,
          forget_bias=self._forget_bias,
          cell_clip=self._cell_clip,
          use_peephole=self._use_peephole,
      )
      return cs, h
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import abc
  import six
  from tensorflow.python.framework import dtypes
  from tensorflow.python.framework import ops
  from tensorflow.python.keras.engine import input_spec
  from tensorflow.python.layers import base
  from tensorflow.python.ops import array_ops
  from tensorflow.python.ops import gen_rnn_ops
  from tensorflow.python.ops import init_ops
  from tensorflow.python.ops import math_ops
  from tensorflow.python.ops import nn_ops
  from tensorflow.python.ops import rnn_cell_impl
label_desc: Use image node_id 4 for calling the LSTMBlockFusedCell obj's underlying member method code with example usage: obj._call_cell(inputs, initial_cell_state, initial_output, dtype, sequence_length) and returns: cs,  h