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: The conventional implementation of convolutions.
  Unfolding the input by having a window shifting to the right.
docstr_tok: ["The","conventional","implementation","of","convolutions",".","Unfolding","the","input","by","having","a","window","shifting","to","the","right","."]
code: def _forward_unfolded(self, x, incremental_state):
      """The conventional implementation of convolutions.
      Unfolding the input by having a window shifting to the right."""
      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 incremental_state is not None:
          input_buffer = self._get_input_buffer(incremental_state)
          if input_buffer is None:
              input_buffer = x.new()
          x_unfold = torch.cat([input_buffer, x.unsqueeze(3)], dim=3)
          if self.kernel_size > 1:
              self._set_input_buffer(
                  incremental_state,
                  x_unfold[:, :, :, -self.kernel_size + 1 :],
              )
          x_unfold = x_unfold.view(T * B * H, R, -1)
      else:
          # unfold the input: T x B x C --> T' x B x C x K
          x_unfold = unfold1d(x, self.kernel_size, self.padding_l, 0)
          x_unfold = x_unfold.view(T * B * H, R, K)
  
      if self.weight_softmax:
          weight = utils.softmax(
              weight, dim=1, onnx_trace=self.onnx_trace
          ).type_as(weight)
  
      if incremental_state is not None:
          weight = weight[:, -x_unfold.size(2) :]
          K = weight.size(1)
  
      weight = (
          weight.view(1, H, K)
          .expand(T * B, H, K)
          .contiguous()
          .view(T * B * H, K, 1)
      )
  
      weight = self.weight_dropout_module(weight)
      output = torch.bmm(x_unfold, weight)  # T*B*H x R x 1
      output = output.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 5 for calling the LightweightConv1dTBC obj's underlying member method code with example usage: obj._forward_unfolded(x, incremental_state) and returns: output