class_docstr: Offline TFGridNetV2. Compared with TFGridNet, TFGridNetV2 speeds up the code
      by vectorizing multiple heads in self-attention, and better dealing with
      Deconv1D in each intra- and inter-block when emb_ks == emb_hs.
  
  Reference:
  [1] Z.-Q. Wang, S. Cornell, S. Choi, Y. Lee, B.-Y. Kim, and S. Watanabe,
  "TF-GridNet: Integrating Full- and Sub-Band Modeling for Speech Separation",
  in TASLP, 2023.
  [2] Z.-Q. Wang, S. Cornell, S. Choi, Y. Lee, B.-Y. Kim, and S. Watanabe,
  "TF-GridNet: Making Time-Frequency Domain Models Great Again for Monaural
  Speaker Separation", in ICASSP, 2023.
  
  NOTES:
  As outlined in the Reference, this model works best when trained with variance
  normalized mixture input and target, e.g., with mixture of shape [batch, samples,
  microphones], you normalize it by dividing with torch.std(mixture, (1, 2)). You
  must do the same for the target signals. It is encouraged to do so when not using
  scale-invariant loss functions such as SI-SDR.
  Specifically, use:
      std_ = std(mix)
      mix = mix / std_
      tgt = tgt / std_
  
  Args:
      input_dim: placeholder, not used
      n_srcs: number of output sources/speakers.
      n_fft: stft window size.
      stride: stft stride.
      window: stft window type choose between 'hamming', 'hanning' or None.
      n_imics: number of microphones channels (only fixed-array geometry supported).
      n_layers: number of TFGridNetV2 blocks.
      lstm_hidden_units: number of hidden units in LSTM.
      attn_n_head: number of heads in self-attention
      attn_approx_qk_dim: approximate dimention of frame-level key and value tensors
      emb_dim: embedding dimension
      emb_ks: kernel size for unfolding and deconv1D
      emb_hs: hop size for unfolding and deconv1D
      activation: activation function to use in the whole TFGridNetV2 model,
          you can use any torch supported activation e.g. 'relu' or 'elu'.
      eps: small epsilon for normalization layers.
      use_builtin_complex: whether to use builtin complex type or not.
docstr: Forward.
  
  Args:
      input (torch.Tensor): batched multi-channel audio tensor with
              M audio channels and N samples [B, N, M]
      ilens (torch.Tensor): input lengths [B]
      additional (Dict or None): other data, currently unused in this model.
  
  Returns:
      enhanced (List[Union(torch.Tensor)]):
              [(B, T), ...] list of len n_srcs
              of mono audio tensors with T samples.
      ilens (torch.Tensor): (B,)
      additional (Dict or None): other data, currently unused in this model,
              we return it also in output.
docstr_tok: ["Forward",".","Args",":","input","(","torch.Tensor",")",":","batched","multi-channel","audio","tensor","with","M","audio","channels","and","N","samples","[","B",",","N",",","M","]","ilens","(","torch.Tensor",")",":","input","lengths","[","B","]","additional","(","Dict","or","None",")",":","other","data",",","currently","unused","in","this","model",".","Returns",":","enhanced","(","List","[","Union","(","torch.Tensor",")","]",")",":","[","(","B",",","T",")",",","...","]","list","of","len","n_srcs","of","mono","audio","tensors","with","T","samples",".","ilens","(","torch.Tensor",")",":","(","B",",",")","additional","(","Dict","or","None",")",":","other","data",",","currently","unused","in","this","model",",","we","return","it","also","in","output","."]
code: def forward(
      self,
      input: torch.Tensor,
      ilens: torch.Tensor,
      additional: Optional[Dict] = None,
  ) -> Tuple[List[torch.Tensor], torch.Tensor, OrderedDict]:
      """Forward.
  
      Args:
          input (torch.Tensor): batched multi-channel audio tensor with
                  M audio channels and N samples [B, N, M]
          ilens (torch.Tensor): input lengths [B]
          additional (Dict or None): other data, currently unused in this model.
  
      Returns:
          enhanced (List[Union(torch.Tensor)]):
                  [(B, T), ...] list of len n_srcs
                  of mono audio tensors with T samples.
          ilens (torch.Tensor): (B,)
          additional (Dict or None): other data, currently unused in this model,
                  we return it also in output.
      """
      n_samples = input.shape[1]
      if self.n_imics == 1:
          assert len(input.shape) == 2
          input = input[..., None]  # [B, N, M]
  
      mix_std_ = torch.std(input, dim=(1, 2), keepdim=True)  # [B, 1, 1]
      input = input / mix_std_  # RMS normalization
  
      batch = self.enc(input, ilens)[0]  # [B, T, M, F]
      batch0 = batch.transpose(1, 2)  # [B, M, T, F]
      batch = torch.cat(
          (batch0.real, batch0.imag), dim=1
      )  # [B, 2*M, T, F]
      n_batch, _, n_frames, n_freqs = batch.shape
  
      batch = self.conv(batch)  # [B, -1, T, F]
  
      for ii in range(self.n_layers):
          batch = self.blocks[ii](batch)  # [B, -1, T, F]
  
      batch = self.deconv(batch)  # [B, n_srcs*2, T, F]
  
      batch = batch.view([n_batch, self.n_srcs, 2, n_frames, n_freqs])
      batch = new_complex_like(batch0, (batch[:, :, 0], batch[:, :, 1]))
  
      batch = self.dec(batch.view(-1, n_frames, n_freqs), ilens)[
          0
      ]  # [B, n_srcs, -1]
  
      batch = self.pad2(
          batch.view([n_batch, self.num_spk, -1]), n_samples
      )
  
      batch = batch * mix_std_  # reverse the RMS normalization
  
      batch = [batch[:, src] for src in range(self.num_spk)]
  
      return batch, ilens, OrderedDict()
  
imports: import math
  from collections import OrderedDict
  from typing import Dict, List, Optional, Tuple
  import torch
  import torch.nn
  import torch.nn.functional
  from torch.nn import init
  from torch.nn.parameter import Parameter
  from espnet2.enh.decoder.stft_decoder import STFTDecoder
  from espnet2.enh.encoder.stft_encoder import STFTEncoder
  from espnet2.enh.layers.complex_utils import new_complex_like
  from espnet2.enh.separator.abs_separator import AbsSeparator
  from espnet2.torch_utils.get_layer_from_string import get_layer
label_desc: Use image node_id 2 for calling the TFGridNetV2 obj's underlying member method code with example usage: obj.forward(input, ilens, additional) and returns: batch,  ilens,  OrderedDict