Conv1d#

classtorch.nn.modules.conv.Conv1d(in_channels,out_channels,kernel_size,stride=1,padding=0,dilation=1,groups=1,bias=True,padding_mode='zeros',device=None,dtype=None)[source]#

Applies a 1D convolution over an input signal composed of several inputplanes.

In the simplest case, the output value of the layer with input size$(N,C_{\text{in}},L)$(N,Cin​,L) and output$(N,C_{\text{out}},L_{\text{out}})$(N,Cout​,Lout​) can beprecisely 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)$$out(Ni​,Coutj​​)=bias(Coutj​​)+k=0∑Cin​−1​weight(Coutj​​,k)⋆input(Ni​,k)

where$\star$⋆ is the validcross-correlation operator,$N$N is a batch size,$C$C denotes a number of channels,$L$L is a length of signal sequence.

This module supportsTensorFloat32.

On certain ROCm devices, when using float16 inputs this module will usedifferent precision for backward.

• stride controls the stride for the cross-correlation, a singlenumber or a one-element tuple.

• padding controls the amount of padding applied to the input. Itcan be either a string {‘valid’, ‘same’} or a tuple of ints giving theamount of implicit padding applied on both sides.

• dilation controls the spacing between the kernel points; alsoknown as the à trous algorithm. It is harder to describe, but thislinkhas a nice visualization of whatdilation does.

• groups controls the connections between inputs and outputs.in_channels andout_channels must both be divisible bygroups. For example,

  • At groups=1, all inputs are convolved to all outputs.

  • At groups=2, the operation becomes equivalent to having two convlayers side by side, each seeing half the input channelsand producing half the output channels, and both subsequentlyconcatenated.

  • At groups=in_channels, each input channel is convolved withits own set of filters (of size$\frac{\text{out\_channels}}{\text{in\_channels}}$in_channelsout_channels​).

Note

Whengroups == in_channels andout_channels == K * in_channels,whereK is a positive integer, this operation is also known as a “depthwise convolution”.

In other words, for an input of size$(N,C_{in},L_{in})$(N,Cin​,Lin​),a depthwise convolution with a depthwise multiplierK can be performed with the arguments$(C_{\text{in}}=C_{\text{in}},C_{\text{out}}=C_{\text{in}}\times \text{K},\mathrm{.}\mathrm{.}\mathrm{.},\text{groups}=C_{\text{in}})$(Cin​=Cin​,Cout​=Cin​×K,...,groups=Cin​).

Note

In some circumstances when given tensors on a CUDA device and using CuDNN, this operator may select a nondeterministic algorithm to increase performance. If this is undesirable, you can try to make the operation deterministic (potentially at a performance cost) by settingtorch.backends.cudnn.deterministic=True. SeeReproducibility for more information.

Note

padding='valid' is the same as no padding.padding='same' padsthe input so the output has the shape as the input. However, this modedoesn’t support any stride values other than 1.

Note

This module supports complex data types i.e.complex32,complex64,complex128.

Parameters

• in_channels (int) – Number of channels in the input image

• out_channels (int) – Number of channels produced by the convolution

• kernel_size (int ortuple) – Size of the convolving kernel

• stride (int ortuple,optional) – Stride of the convolution. Default: 1

• padding (int,tuple orstr,optional) – Padding added to both sides ofthe input. Default: 0

• dilation (int ortuple,optional) – Spacing between kernelelements. Default: 1

• groups (int,optional) – Number of blocked connections from inputchannels to output channels. Default: 1

• bias (bool,optional) – IfTrue, adds a learnable bias to theoutput. Default:True

• padding_mode (str,optional) –'zeros','reflect','replicate' or'circular'. Default:'zeros'

Shape:

• Input:$(N,C_{in},L_{in})$(N,Cin​,Lin​) or$(C_{in},L_{in})$(Cin​,Lin​)

• Output:$(N,C_{out},L_{out})$(N,Cout​,Lout​) or$(C_{out},L_{out})$(Cout​,Lout​), where

  $$L_{out}=\lfloor \frac{L_{in}+2\times \text{padding}-\text{dilation}\times (\text{kernel\_size}-1)-1}{\text{stride}}+1\rfloor$$Lout​=⌊strideLin​+2×padding−dilation×(kernel_size−1)−1​+1⌋

Variables

• weight (Tensor) – the learnable weights of the module of shape$(\text{out\_channels},\frac{\text{in\_channels}}{\text{groups}},\text{kernel\_size})$(out_channels,groupsin_channels​,kernel_size).The values of these weights are sampled from$\mathcal{U}(-\sqrt{k},\sqrt{k})$U(−k​,k​) where$k=\frac{groups}{C_{\text{in}}\ast \text{kernel\_size}}$k=Cin​∗kernel_sizegroups​

• bias (Tensor) – the learnable bias of the module of shape(out_channels). Ifbias isTrue, then the values of these weights aresampled from$\mathcal{U}(-\sqrt{k},\sqrt{k})$U(−k​,k​) where$k=\frac{groups}{C_{\text{in}}\ast \text{kernel\_size}}$k=Cin​∗kernel_sizegroups​

Examples:

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