class_docstr: RNNEncoder class.
  
  Args:
      input_size: The number of expected features in the input
      output_size: The number of output features
      hidden_size: The number of hidden features
      bidirectional: If ``True`` becomes a bidirectional LSTM
      use_projection: Use projection layer or not
      num_layers: Number of recurrent layers
      dropout: dropout probability
code: def __init__(
      self,
      input_size: int,
      rnn_type: str = "lstm",
      bidirectional: bool = True,
      use_projection: bool = True,
      num_layers: int = 4,
      hidden_size: int = 320,
      output_size: int = 320,
      dropout: float = 0.0,
      subsample: Optional[Sequence[int]] = (2, 2, 1, 1),
  ):
      assert check_argument_types()
      super().__init__()
      self._output_size = output_size
      self.rnn_type = rnn_type
      self.bidirectional = bidirectional
      self.use_projection = use_projection
  
      if rnn_type not in {"lstm", "gru"}:
          raise ValueError(f"Not supported rnn_type={rnn_type}")
  
      if subsample is None:
          subsample = np.ones(num_layers + 1, dtype=np.int64)
      else:
          subsample = subsample[:num_layers]
          # Append 1 at the beginning because the second or later is used
          subsample = np.pad(
              np.array(subsample, dtype=np.int64),
              [1, num_layers - len(subsample)],
              mode="constant",
              constant_values=1,
          )
  
      rnn_type = ("b" if bidirectional else "") + rnn_type
      if use_projection:
          self.enc = torch.nn.ModuleList(
              [
                  RNNP(
                      input_size,
                      num_layers,
                      hidden_size,
                      output_size,
                      subsample,
                      dropout,
                      typ=rnn_type,
                  )
              ]
          )
  
      else:
          self.enc = torch.nn.ModuleList(
              [
                  RNN(
                      input_size,
                      num_layers,
                      hidden_size,
                      output_size,
                      dropout,
                      typ=rnn_type,
                  )
              ]
          )
  
file_path: espnet/espnet2/asr/encoder/rnn_encoder.py
imports: from typing import Optional, Sequence, Tuple
  import numpy
  import torch
  from typeguard import check_argument_types
  from espnet2.asr.encoder.abs_encoder import AbsEncoder
  from espnet.nets.pytorch_backend.nets_utils import make_pad_mask
  from espnet.nets.pytorch_backend.rnn.encoders import RNN, RNNP
label_desc: Use image node_id 1 to create a new RNNEncoder object from inherited base classes: AbsEncoder with example: obj = RNNEncoder(input_size, rnn_type, bidirectional, use_projection, num_layers, hidden_size, output_size, dropout, subsample)