class_docstr: VGG-like module
  
  :param int in_channel: number of input channels
docstr: VGG2L forward
  
  :param torch.Tensor xs_pad: batch of padded input sequences (B, Tmax, D)
  :param torch.Tensor ilens: batch of lengths of input sequences (B)
  :return: batch of padded hidden state sequences (B, Tmax // 4, 128 * D // 4)
  :rtype: torch.Tensor
docstr_tok: ["VGG2L","forward",":","param","torch.Tensor","xs_pad",":","batch","of","padded","input","sequences","(","B",",","Tmax",",","D",")",":","param","torch.Tensor","ilens",":","batch","of","lengths","of","input","sequences","(","B",")",":","return",":","batch","of","padded","hidden","state","sequences","(","B",",","Tmax","\/\/","4",",","128","*","D","\/\/","4",")",":","rtype",":","torch.Tensor"]
code: def forward(self, xs_pad, ilens, **kwargs):
      """VGG2L forward
  
      :param torch.Tensor xs_pad: batch of padded input sequences (B, Tmax, D)
      :param torch.Tensor ilens: batch of lengths of input sequences (B)
      :return: batch of padded hidden state sequences (B, Tmax // 4, 128 * D // 4)
      :rtype: torch.Tensor
      """
      logging.debug(
          self.__class__.__name__ + " input lengths: " + str(ilens)
      )
  
      # x: utt x frame x dim
      # xs_pad = F.pad_sequence(xs_pad)
  
      # x: utt x 1 (input channel num) x frame x dim
      xs_pad = xs_pad.view(
          xs_pad.size(0),
          xs_pad.size(1),
          self.in_channel,
          xs_pad.size(2) // self.in_channel,
      ).transpose(1, 2)
  
      # NOTE: max_pool1d ?
      xs_pad = F.relu(self.conv1_1(xs_pad))
      xs_pad = F.relu(self.conv1_2(xs_pad))
      xs_pad = F.max_pool2d(xs_pad, 2, stride=2, ceil_mode=True)
  
      xs_pad = F.relu(self.conv2_1(xs_pad))
      xs_pad = F.relu(self.conv2_2(xs_pad))
      xs_pad = F.max_pool2d(xs_pad, 2, stride=2, ceil_mode=True)
      if torch.is_tensor(ilens):
          ilens = ilens.cpu().numpy()
      else:
          ilens = np.array(ilens, dtype=np.float32)
      ilens = np.array(np.ceil(ilens / 2), dtype=np.int64)
      ilens = np.array(
          np.ceil(np.array(ilens, dtype=np.float32) / 2), dtype=np.int64
      ).tolist()
  
      # x: utt_list of frame (remove zeropaded frames) x (input channel num x dim)
      xs_pad = xs_pad.transpose(1, 2)
      xs_pad = xs_pad.contiguous().view(
          xs_pad.size(0),
          xs_pad.size(1),
          xs_pad.size(2) * xs_pad.size(3),
      )
      return xs_pad, ilens, None
  
imports: import logging
  import numpy
  import torch
  import torch.nn.functional
  from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
  from espnet.nets.e2e_asr_common import get_vgg2l_odim
  from espnet.nets.pytorch_backend.nets_utils import make_pad_mask, to_device
label_desc: Use image node_id 2 for calling the VGG2L obj's underlying member method code with example usage: obj.forward(xs_pad, ilens) and returns: xs_pad,  ilens,  None