class_docstr: 1D convolution module for custom encoder.
  
  Args:
      idim: Input dimension.
      odim: Output dimension.
      kernel_size: Size of the convolving kernel.
      stride: Stride of the convolution.
      dilation: Spacing between the kernel points.
      groups: Number of blocked connections from input channels to output channels.
      bias: Whether to add a learnable bias to the output.
      batch_norm: Whether to use batch normalization after convolution.
      relu: Whether to use a ReLU activation after convolution.
      dropout_rate: Dropout rate.
docstr: Construct a Conv1d module object.
code: def __init__(
      self,
      idim: int,
      odim: int,
      kernel_size: Union[int, Tuple],
      stride: Union[int, Tuple] = 1,
      dilation: Union[int, Tuple] = 1,
      groups: Union[int, Tuple] = 1,
      bias: bool = True,
      batch_norm: bool = False,
      relu: bool = True,
      dropout_rate: float = 0.0,
  ):
      """Construct a Conv1d module object."""
      super().__init__()
  
      self.conv = torch.nn.Conv1d(
          idim,
          odim,
          kernel_size,
          stride=stride,
          dilation=dilation,
          groups=groups,
          bias=bias,
      )
  
      self.dropout = torch.nn.Dropout(p=dropout_rate)
  
      if relu:
          self.relu_func = torch.nn.ReLU()
  
      if batch_norm:
          self.bn = torch.nn.BatchNorm1d(odim)
  
      self.relu = relu
      self.batch_norm = batch_norm
  
      self.padding = dilation * (kernel_size - 1)
      self.stride = stride
  
      self.out_pos = torch.nn.Linear(idim, odim)
  
file_path: espnet/espnet/nets/pytorch_backend/transducer/conv1d_nets.py
imports: from typing import Optional, Tuple, Union
  import torch
label_desc: Use image node_id 1 to create a new Conv1d object from inherited base classes: torch.nn with example: obj = Conv1d(idim, odim, kernel_size, stride, dilation, groups, bias, batch_norm, relu, dropout_rate)