class_docstr: Encoder layer module.
  
  Args:
      size (int): Input dimension.
      self_attn (torch.nn.Module): Self-attention module instance.
          `MultiHeadedAttention` or `RelPositionMultiHeadedAttention` instance
          can be used as the argument.
      feed_forward (torch.nn.Module): Feed-forward module instance.
          `PositionwiseFeedForward`, `MultiLayeredConv1d`, or `Conv1dLinear` instance
          can be used as the argument.
      feed_forward_macaron (torch.nn.Module): Additional feed-forward module instance.
          `PositionwiseFeedForward`, `MultiLayeredConv1d`, or `Conv1dLinear` instance
          can be used as the argument.
      conv_module (torch.nn.Module): Convolution module instance.
          `ConvlutionModule` instance can be used as the argument.
      dropout_rate (float): Dropout rate.
      normalize_before (bool): Whether to use layer_norm before the first block.
      concat_after (bool): Whether to concat attention layer's input and output.
          if True, additional linear will be applied.
          i.e. x -> x + linear(concat(x, att(x)))
          if False, no additional linear will be applied. i.e. x -> x + att(x)
      stochastic_depth_rate (float): Proability to skip this layer.
          During training, the layer may skip residual computation and return input
          as-is with given probability.
docstr: Compute encoded features.
  
  Args:
      x_input (Union[Tuple, torch.Tensor]): Input tensor w/ or w/o pos emb.
          - w/ pos emb: Tuple of tensors [(#batch, time, size), (1, time, size)].
          - w/o pos emb: Tensor (#batch, time, size).
      mask (torch.Tensor): Mask tensor for the input (#batch, 1, time).
      cache (torch.Tensor): Cache tensor of the input (#batch, time - 1, size).
  
  Returns:
      torch.Tensor: Output tensor (#batch, time, size).
      torch.Tensor: Mask tensor (#batch, 1, time).
docstr_tok: ["Compute","encoded","features",".","Args",":","x_input","(","Union","[","Tuple",",","torch.Tensor","]",")",":","Input","tensor","w\/","or","w\/o","pos","emb",".","-","w\/","pos","emb",":","Tuple","of","tensors","[","(","#","batch",",","time",",","size",")",",","(","1",",","time",",","size",")","]",".","-","w\/o","pos","emb",":","Tensor","(","#","batch",",","time",",","size",")",".","mask","(","torch.Tensor",")",":","Mask","tensor","for","the","input","(","#","batch",",","1",",","time",")",".","cache","(","torch.Tensor",")",":","Cache","tensor","of","the","input","(","#","batch",",","time","-","1",",","size",")",".","Returns",":","torch.Tensor",":","Output","tensor","(","#","batch",",","time",",","size",")",".","torch.Tensor",":","Mask","tensor","(","#","batch",",","1",",","time",")","."]
code: def forward(self, x_input, mask, cache=None):
      """Compute encoded features.
  
      Args:
          x_input (Union[Tuple, torch.Tensor]): Input tensor w/ or w/o pos emb.
              - w/ pos emb: Tuple of tensors [(#batch, time, size), (1, time, size)].
              - w/o pos emb: Tensor (#batch, time, size).
          mask (torch.Tensor): Mask tensor for the input (#batch, 1, time).
          cache (torch.Tensor): Cache tensor of the input (#batch, time - 1, size).
  
      Returns:
          torch.Tensor: Output tensor (#batch, time, size).
          torch.Tensor: Mask tensor (#batch, 1, time).
  
      """
      if isinstance(x_input, tuple):
          x, pos_emb = x_input[0], x_input[1]
      else:
          x, pos_emb = x_input, None
  
      skip_layer = False
      # with stochastic depth, residual connection `x + f(x)` becomes
      # `x <- x + 1 / (1 - p) * f(x)` at training time.
      stoch_layer_coeff = 1.0
      if self.training and self.stochastic_depth_rate > 0:
          skip_layer = torch.rand(1).item() < self.stochastic_depth_rate
          stoch_layer_coeff = 1.0 / (1 - self.stochastic_depth_rate)
  
      if skip_layer:
          if cache is not None:
              x = torch.cat([cache, x], dim=1)
          if pos_emb is not None:
              return (x, pos_emb), mask
          return x, mask
  
      # whether to use macaron style
      if self.feed_forward_macaron is not None:
          residual = x
          if self.normalize_before:
              x = self.norm_ff_macaron(x)
          x = (
              residual
              + stoch_layer_coeff
              * self.ff_scale
              * self.dropout(self.feed_forward_macaron(x))
          )
          if not self.normalize_before:
              x = self.norm_ff_macaron(x)
  
      # multi-headed self-attention module
      residual = x
      if self.normalize_before:
          x = self.norm_mha(x)
  
      if cache is None:
          x_q = x
      else:
          assert cache.shape == (x.shape[0], x.shape[1] - 1, self.size)
          x_q = x[:, -1:, :]
          residual = residual[:, -1:, :]
          mask = None if mask is None else mask[:, -1:, :]
  
      if pos_emb is not None:
          x_att = self.self_attn(x_q, x, x, pos_emb, mask)
      else:
          x_att = self.self_attn(x_q, x, x, mask)
  
      if self.concat_after:
          x_concat = torch.cat((x, x_att), dim=-1)
          x = residual + stoch_layer_coeff * self.concat_linear(
              x_concat
          )
      else:
          x = residual + stoch_layer_coeff * self.dropout(x_att)
      if not self.normalize_before:
          x = self.norm_mha(x)
  
      # convolution module
      if self.conv_module is not None:
          residual = x
          if self.normalize_before:
              x = self.norm_conv(x)
          x = residual + stoch_layer_coeff * self.dropout(
              self.conv_module(x)
          )
          if not self.normalize_before:
              x = self.norm_conv(x)
  
      # feed forward module
      residual = x
      if self.normalize_before:
          x = self.norm_ff(x)
      x = residual + stoch_layer_coeff * self.ff_scale * self.dropout(
          self.feed_forward(x)
      )
      if not self.normalize_before:
          x = self.norm_ff(x)
  
      if self.conv_module is not None:
          x = self.norm_final(x)
  
      if cache is not None:
          x = torch.cat([cache, x], dim=1)
  
      if pos_emb is not None:
          return (x, pos_emb), mask
  
      return x, mask
  
imports: import torch
  from torch import nn
  from espnet.nets.pytorch_backend.transformer.layer_norm import LayerNorm
label_desc: Use image node_id 2 for calling the EncoderLayer obj's underlying member method code with example usage: obj.forward(x_input, mask, cache) and returns: x,  mask, x,  mask, x,  pos_emb,  mask, x,  pos_emb,  mask