class_docstr: Lightweight Convolution assuming the input is TxBxC
  Args:
      input_size: # of channels of the input
      kernel_size: convolution channels
      padding_l: padding to the left when using "same" padding
      num_heads: number of heads used. The weight is of shape (num_heads, 1, kernel_size)
      weight_dropout: the drop rate of the DropConnect to drop the weight
      weight_softmax: normalize the weight with softmax before the convolution
      bias: use bias
  
  Shape:
      Input: TxBxC, i.e. (timesteps, batch_size, input_size)
      Output: TxBxC, i.e. (timesteps, batch_size, input_size)
  
  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: Turn the convolution filters into band matrices and do matrix multiplication.
  This is faster when the sequence is short, but less memory efficient.
  This is not used in the decoder during inference.
docstr_tok: ["Turn","the","convolution","filters","into","band","matrices","and","do","matrix","multiplication",".","This","is","faster","when","the","sequence","is","short",",","but","less","memory","efficient",".","This","is","not","used","in","the","decoder","during","inference","."]
code: def _forward_expanded(self, x, incremental_state):
      """Turn the convolution filters into band matrices and do matrix multiplication.
      This is faster when the sequence is short, but less memory efficient.
      This is not used in the decoder during inference.
      """
      T, B, C = x.size()
      K, H = self.kernel_size, self.num_heads
      R = C // H
      assert R * H == C == self.input_size
  
      weight = self.weight.view(H, K)
      if self.weight_softmax:
          weight = utils.softmax(
              weight, dim=1, onnx_trace=self.onnx_trace
          ).type_as(weight)
      weight = weight.view(1, H, K).expand(T * B, H, K).contiguous()
      weight = weight.view(T, B * H, K).transpose(0, 1)
  
      x = x.view(T, B * H, R).transpose(0, 1)
      P = self.padding_l
      if K > T and P == K - 1:
          weight = weight.narrow(2, K - T, T)
          K, P = T, T - 1
      # turn the convolution filters into band matrices
      weight_expanded = weight.new_zeros(
          B * H, T, T + K - 1, requires_grad=False
      )
      weight_expanded.as_strided(
          (B * H, T, K), (T * (T + K - 1), T + K, 1)
      ).copy_(weight)
      weight_expanded = weight_expanded.narrow(2, P, T)
      weight_expanded = self.weight_dropout_module(weight_expanded)
  
      output = torch.bmm(weight_expanded, x)
      output = output.transpose(0, 1).contiguous().view(T, B, C)
      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 6 for calling the LightweightConv1dTBC obj's underlying member method code with example usage: obj._forward_expanded(x, incremental_state) and returns: output