docs: def _build(self, inputs, prev_state):
      """Connects the LSTM module into the graph.
  
      If this is not the first time the module has been connected to the graph,
      the Tensors provided as inputs and state must have the same final
      dimension, in order for the existing variables to be the correct size for
      their corresponding multiplications. The batch size may differ for each
      connection.
  
      Args:
        inputs: Tensor of size `[batch_size, input_size]`.
        prev_state: Tuple (prev_hidden, prev_cell).
  
      Returns:
        A tuple (output, next_state) where 'output' is a Tensor of size
        `[batch_size, hidden_size]` and 'next_state' is a `LSTMState` namedtuple
        (next_hidden, next_cell) where `next_hidden` and `next_cell` have size
        `[batch_size, hidden_size]`. If `projection_size` is specified, then
        `next_hidden` will have size `[batch_size, projection_size]`.
      Raises:
        ValueError: If connecting the module into the graph any time after the
          first time, and the inferred size of the inputs does not match previous
          invocations.
      """
      prev_hidden, prev_cell = prev_state
  
      # pylint: disable=invalid-unary-operand-type
      if self._hidden_clip_value is not None:
        prev_hidden = tf.clip_by_value(
            prev_hidden, -self._hidden_clip_value, self._hidden_clip_value)
      if self._cell_clip_value is not None:
        prev_cell = tf.clip_by_value(
            prev_cell, -self._cell_clip_value, self._cell_clip_value)
      # pylint: enable=invalid-unary-operand-type
  
      self._create_gate_variables(inputs.get_shape(), inputs.dtype)
  
      # pylint false positive: calling module of same file;
      # pylint: disable=not-callable
  
      # Parameters of gates are concatenated into one multiply for efficiency.
      inputs_and_hidden = tf.concat([inputs, prev_hidden], 1)
      gates = tf.matmul(inputs_and_hidden, self._w_xh)
  
      if self._use_layer_norm:
        gates = layer_norm.LayerNorm()(gates)
  
      gates += self._b
  
      # i = input_gate, j = next_input, f = forget_gate, o = output_gate
      i, j, f, o = tf.split(value=gates, num_or_size_splits=4, axis=1)
  
      if self._use_peepholes:  # diagonal connections
        self._create_peephole_variables(inputs.dtype)
        f += self._w_f_diag * prev_cell
        i += self._w_i_diag * prev_cell
  
      forget_mask = tf.sigmoid(f + self._forget_bias)
      next_cell = forget_mask * prev_cell + tf.sigmoid(i) * tf.tanh(j)
      cell_output = next_cell
      if self._use_peepholes:
        cell_output += self._w_o_diag * cell_output
      next_hidden = tf.tanh(cell_output) * tf.sigmoid(o)
  
      if self._use_projection:
        next_hidden = tf.matmul(next_hidden, self._w_h_projection)
  
      return next_hidden, LSTMState(hidden=next_hidden, cell=next_cell)