docs: def initial_state(self, batch_size, dtype=tf.float32, trainable=False,
                      trainable_initializers=None, trainable_regularizers=None,
                      name=None):
      """Builds the default start state for a DeepRNN.
  
      Args:
        batch_size: An int, float or scalar Tensor representing the batch size.
        dtype: The data type to use for the state.
        trainable: Boolean that indicates whether to learn the initial state.
        trainable_initializers: An initializer function or nested structure of
            functions with same structure as the `state_size` property of the
            core, to be used as initializers of the initial state variable.
        trainable_regularizers: Optional regularizer function or nested structure
          of functions with the same structure as the `state_size` property of the
          core, to be used as regularizers of the initial state variable. A
          regularizer should be a function that takes a single `Tensor` as an
          input and returns a scalar `Tensor` output, e.g. the L1 and L2
          regularizers in `tf.contrib.layers`.
        name: Optional string used to prefix the initial state variable names, in
            the case of a trainable initial state. If not provided, defaults to
            the name of the module.
  
      Returns:
        A tensor or nested tuple of tensors with same structure and shape as the
        `state_size` property of the core.
  
      Raises:
        ValueError: if the number of passed initializers is not the same as the
            number of recurrent cores.
      """
      initial_state = []
      if trainable_initializers is None:
        trainable_initializers = [None] * self._num_recurrent
      if trainable_regularizers is None:
        trainable_regularizers = [None] * self._num_recurrent
  
      num_initializers = len(trainable_initializers)
  
      if num_initializers != self._num_recurrent:
        raise ValueError("The number of initializers and recurrent cores should "
                         "be the same. Received %d initializers for %d specified "
                         "recurrent cores."
                         % (num_initializers, self._num_recurrent))
  
      with tf.name_scope(self._initial_state_scope(name)):
        recurrent_idx = 0
        for is_recurrent, core in zip(self._is_recurrent_list, self._cores):
          if is_recurrent:
            core_initial_state = core.initial_state(
                batch_size, dtype=dtype, trainable=trainable,
                trainable_initializers=trainable_initializers[recurrent_idx],
                trainable_regularizers=trainable_regularizers[recurrent_idx])
            initial_state.append(core_initial_state)
            recurrent_idx += 1
      return tuple(initial_state)