nn.Conv1d simple understanding

1. Definition of official documents

In the simplest case, the output value of the layer with input size
$(N,C_{\text{in}},L)$ and output $(N,C_{\text{out}},L_{\text{out}})$ can be precisely described as:
$$\text{out}(N_i,C_{{\text{out}}_j})=\text{bias}(C_{{\text{out}}_j})+\sum _{k=0}^{C_{in}-1}\text{weight}(C_{{\text{out}}_j},k)\star \text{input}(N_i,k)$$
where $\star$ is the valid cross-correlation_ operator,
N is a batch size, C denotes a number of channels,
L is a length of signal sequence.
$$

This module supports :ref:`TensorFloat32<tf32_on_ampere>`.

* :attr:`stride` controls the stride for the cross-correlation, a single
  number or a one-element tuple.

* :attr:`padding` controls the amount of implicit zero-paddings on both sides
  for :attr:`padding` number of points.

* :attr:`dilation` controls the spacing between the kernel points; also
  known as the à trous algorithm. It is harder to describe, but this `link`_
  has a nice visualization of what :attr:`dilation` does.

* :attr:`groups` controls the connections between inputs and outputs.
  :attr:`in_channels` and :attr:`out_channels` must both be divisible by
  :attr:`groups`. For example,

    * At groups=1, all inputs are convolved to all outputs.
    * At groups=2, the operation becomes equivalent to having two conv
      layers side by side, each seeing half the input channels,
      and producing half the output channels, and both subsequently
      concatenated.
    * At groups= :attr:`in_channels`, each input channel is convolved with
      its own set of filters,
      of size  

$\lfloor \frac{out\_channels}{in\_channels}\rfloor$

1.1 Parameter explanation

• Input: $(N,C_{in},L_{in})$
• Output: $(N,C_{out},L_{out})$ where

Among them as mentioned above:

• NRepresents the batch size,

• CRepresents channels, the number of channels. In a sequence, represents the dimension of each column vector.　
  $C_{in}$The encoded dimension of each column vector in the input sequence.　
  $C_{out}$The encoded dimension of each column vector expected in the output sequence.

• LRepresents the length of the sequence sequence, that is, how many column vectors there are in the sequence.
  $L_{in}$How many column vectors are included in the input sequence.
  $L_{out}$How many column vectors are included in the output sequence.

The output looks like this:

$$L_{out}=\lfloor \frac{L_{in}+2\times \text{padding}-\text{dilation}\times (\text{kernel\_size}-1)-1}{\text{stride}}+1\rfloor$$

1.2 Example of operation

Where padding defaults to 0, dilation defaults to 1, groups defaults to 1,

The calculation formula is calculated according to the above.

import torch.nn as nn

m = nn.Conv1d(16,33, 3, stride =2)
input = torch.rand(20, 16, 50)

output = m(input)


print(output.shape)
torch.Size([20, 33, 24])