class_docstr: Lightweight Convolution assuming the input is BxCxT
  This is just an example that explains LightConv clearer than the TBC version.
  We don't use this module in the model.
  
  Args:
      input_size: # of channels of the input and output
      kernel_size: convolution channels
      padding: padding
      num_heads: number of heads used. The weight is of shape
          `(num_heads, 1, kernel_size)`
      weight_softmax: normalize the weight with softmax before the convolution
  
  Shape:
      Input: BxCxT, i.e. (batch_size, input_size, timesteps)
      Output: BxCxT, i.e. (batch_size, input_size, timesteps)
  
  Attributes:
      weight: the learnable weights of the module of shape
          `(num_heads, 1, kernel_size)`
      bias: the learnable bias of the module of shape `(input_size)`
docstr: input size: B x C x T
  output size: B x C x T
docstr_tok: ["input","size",":","B","x","C","x","T","output","size",":","B","x","C","x","T"]
code: def forward(self, input):
      """
      input size: B x C x T
      output size: B x C x T
      """
      B, C, T = input.size()
      H = self.num_heads
  
      weight = self.weight
      if self.weight_softmax:
          weight = F.softmax(weight, dim=-1)
  
      weight = self.weight_dropout_module(weight)
      # Merge every C/H entries into the batch dimension (C = self.input_size)
      # B x C x T -> (B * C/H) x H x T
      # One can also expand the weight to C x 1 x K by a factor of C/H
      # and do not reshape the input instead, which is slow though
      input = input.view(-1, H, T)
      output = F.conv1d(
          input, weight, padding=self.padding, groups=self.num_heads
      )
      output = output.view(B, C, T)
      if self.bias is not None:
          output = output + self.bias.view(1, -1, 1)
  
      return output
  
imports: import torch
  import torch.nn
  import torch.nn.functional
  from fairseq import utils
  from fairseq.incremental_decoding_utils import with_incremental_state
  from fairseq.modules.fairseq_dropout import FairseqDropout
  from fairseq.modules.unfold import unfold1d
label_desc: Use image node_id 3 for calling the LightweightConv1d obj's underlying member method code with example usage: obj.forward(input) and returns: output