class_docstr: ConvInput module definition.
  
  Args:
      input_size: Input size.
      conv_size: Convolution size.
      subsampling_factor: Subsampling factor.
      vgg_like: Whether to use a VGG-like network.
      output_size: Block output dimension.
docstr: Construct a ConvInput object.
docstr_tok: ["Construct","a","ConvInput","object","."]
code: def __init__(
      self,
      input_size: int,
      conv_size: Union[int, Tuple],
      subsampling_factor: int = 4,
      vgg_like: bool = True,
      output_size: Optional[int] = None,
  ) -> None:
      """Construct a ConvInput object."""
      super().__init__()
  
      self.subsampling_factor = subsampling_factor
      self.vgg_like = vgg_like
  
      if vgg_like:
          conv_size1, conv_size2 = conv_size
  
          (
              self.maxpool_kernel1,
              output_proj,
          ) = get_convinput_module_parameters(
              input_size, conv_size2, subsampling_factor, is_vgg=True
          )
  
          self.conv = torch.nn.Sequential(
              torch.nn.Conv2d(1, conv_size1, 3, stride=1, padding=1),
              torch.nn.ReLU(),
              torch.nn.Conv2d(
                  conv_size1, conv_size1, 3, stride=1, padding=0
              ),
              torch.nn.ReLU(),
              torch.nn.MaxPool2d(
                  self.maxpool_kernel1,
                  stride=2,
                  padding=0,
                  ceil_mode=True,
              ),
              torch.nn.Conv2d(
                  conv_size1, conv_size2, 3, stride=1, padding=1
              ),
              torch.nn.ReLU(),
              torch.nn.Conv2d(
                  conv_size2, conv_size2, 3, stride=1, padding=0
              ),
              torch.nn.ReLU(),
              torch.nn.MaxPool2d(
                  2, stride=2, padding=0, ceil_mode=True
              ),
          )
      else:
          (
              self.conv_kernel2,
              self.conv_stride2,
          ), output_proj = get_convinput_module_parameters(
              input_size, conv_size, subsampling_factor, is_vgg=False
          )
  
          self.conv = torch.nn.Sequential(
              torch.nn.Conv2d(1, conv_size, 3, 2),
              torch.nn.ReLU(),
              torch.nn.Conv2d(
                  conv_size,
                  conv_size,
                  self.conv_kernel2,
                  self.conv_stride2,
              ),
              torch.nn.ReLU(),
          )
  
      self.min_frame_length = 7 if subsampling_factor < 6 else 11
  
      if output_size is not None:
          self.output = torch.nn.Linear(output_proj, output_size)
          self.output_size = output_size
      else:
          self.output = None
          self.output_size = output_proj
  
imports: from typing import Optional, Tuple, Union
  import torch
  from espnet2.asr_transducer.utils import get_convinput_module_parameters
label_desc: Use image node_id 1 to create a new ConvInput object from inherited base classes: torch.nn with example: obj = ConvInput(input_size, conv_size, subsampling_factor, vgg_like, output_size)