卷积层

class torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

一维卷积层，输入的尺度是(N, C_in,L)，输出尺度（ N,C_out,L_out）的计算方式：

$$ out(Ni, C{outj})=bias(C {outj})+\sum^{C{in}-1}{k=0}weight(C{out_j},k)\bigotimes input(N_i,k)

说明

bigotimes: 表示相关系数计算stride: 控制相关系数的计算步长dilation: 用于控制内核点之间的距离，详细描述在这里groups: 控制输入和输出之间的连接， group=1，输出是所有的输入的卷积；group=2，此时相当于有并排的两个卷积层，每个卷积层计算输入通道的一半，并且产生的输出是输出通道的一半，随后将这两个输出连接起来。

Parameters：

in_channels(int) – 输入信号的通道
out_channels(int) – 卷积产生的通道
kerner_size(int or tuple) - 卷积核的尺寸
stride(int or tuple, optional) - 卷积步长
padding (int or tuple, optional)- 输入的每一条边补充0的层数
dilation(int or tuple, `optional``) – 卷积核元素之间的间距
groups(int, optional) – 从输入通道到输出通道的阻塞连接数
bias(bool, optional) - 如果bias=True，添加偏置

shape:输入: (N,C_in,L_in)输出: (N,C_out,L_out)输入输出的计算方式：

$$L{out}=floor((L{in}+2padding-dilation(kernerl_size-1)-1)/stride+1)$$

变量:weight(tensor) - 卷积的权重，大小是(out_channels, in_channels, kernel_size)bias(tensor) - 卷积的偏置系数，大小是（out_channel）

example:

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

class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

二维卷积层, 输入的尺度是(N, C_in,H,W)，输出尺度（N,C_out,H_out,W_out）的计算方式：

$$out(Ni, C{outj})=bias(C{outj})+\sum^{C{in}-1}{k=0}weight(C{out_j},k)\bigotimes input(N_i,k)$$

参数kernel_size，stride,padding，dilation也可以是一个int的数据，此时卷积height和width值相同;也可以是一个tuple数组，tuple的第一维度表示height的数值，tuple的第二维度表示width的数值

Parameters：

in_channels(int) – 输入信号的通道
out_channels(int) – 卷积产生的通道
kerner_size(int or tuple) - 卷积核的尺寸
stride(int or tuple, optional) - 卷积步长
padding(int or tuple, optional) - 输入的每一条边补充0的层数
dilation(int or tuple, optional) – 卷积核元素之间的间距
groups(int, optional) – 从输入通道到输出通道的阻塞连接数
bias(bool, optional) - 如果bias=True，添加偏置

shape:input: (N,C_in,H_in,W_in)output: (N,C_out,H_out,W_out)

$$H{out}=floor((H{in}+2padding[0]-dilation0-1)/stride[0]+1)$$

$$W{out}=floor((W{in}+2padding[1]-dilation1-1)/stride[1]+1)$$

变量:weight(tensor) - 卷积的权重，大小是(out_channels, in_channels,kernel_size)bias(tensor) - 卷积的偏置系数，大小是（out_channel）

example:

>>> # With square kernels and equal stride>>> m = nn.Conv2d(16, 33, 3, stride=2)>>> # non-square kernels and unequal stride and with padding>>> m = nn.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2))>>> # non-square kernels and unequal stride and with padding and dilation>>> m = nn.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2), dilation=(3, 1))>>> input = autograd.Variable(torch.randn(20, 16, 50, 100))>>> output = m(input)

class torch.nn.Conv3d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

三维卷积层, 输入的尺度是(N, C_in,D,H,W)，输出尺度（N,C_out,D_out,H_out,W_out）的计算方式：

$$out(Ni, C{outj})=bias(C{outj})+\sum^{C{in}-1}{k=0}weight(C{out_j},k)\bigotimes input(N_i,k)$$

说明bigotimes: 表示二维的相关系数计算 stride: 控制相关系数的计算步长dilation: 用于控制内核点之间的距离，详细描述在这里groups: 控制输入和输出之间的连接： group=1，输出是所有的输入的卷积；group=2，此时相当于有并排的两个卷积层，每个卷积层计算输入通道的一半，并且产生的输出是输出通道的一半，随后将这两个输出连接起来。参数kernel_size，stride，padding，dilation可以是一个int的数据 - 卷积height和width值相同，也可以是一个有三个int数据的tuple数组，tuple的第一维度表示depth的数值，tuple的第二维度表示height的数值，tuple的第三维度表示width的数值

Parameters：

in_channels(int) – 输入信号的通道
out_channels(int) – 卷积产生的通道
kernel_size(int or tuple) - 卷积核的尺寸
stride(int or tuple, optional) - 卷积步长
padding(int or tuple, optional) - 输入的每一条边补充0的层数
dilation(int or tuple, optional) – 卷积核元素之间的间距
groups(int, optional) – 从输入通道到输出通道的阻塞连接数
bias(bool, optional) - 如果bias=True，添加偏置

shape:input: (N,C_in,D_in,H_in,W_in)output: (N,C_out,D_out,H_out,W_out)

$$D{out}=floor((D{in}+2padding[0]-dilation0-1)/stride[0]+1)$$

$$H{out}=floor((H{in}+2padding[1]-dilation2-1)/stride[1]+1)$$

$$W{out}=floor((W{in}+2padding[2]-dilation2-1)/stride[2]+1)$$

变量:

weight(tensor) - 卷积的权重，shape是(out_channels, in_channels,kernel_size)`
bias(tensor) - 卷积的偏置系数，shape是（out_channel）

example:

>>> # With square kernels and equal stride>>> m = nn.Conv3d(16, 33, 3, stride=2)>>> # non-square kernels and unequal stride and with padding>>> m = nn.Conv3d(16, 33, (3, 5, 2), stride=(2, 1, 1), padding=(4, 2, 0))>>> input = autograd.Variable(torch.randn(20, 16, 10, 50, 100))>>> output = m(input)

class torch.nn.ConvTranspose1d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True)

1维的解卷积操作（transposed convolution operator，注意改视作操作可视作解卷积操作，但并不是真正的解卷积操作）该模块可以看作是Conv1d相对于其输入的梯度，有时（但不正确地）被称为解卷积操作。

注意由于内核的大小，输入的最后的一些列的数据可能会丢失。因为输入和输出是不是完全的互相关。因此，用户可以进行适当的填充（padding操作）。

参数

in_channels(int) – 输入信号的通道数
out_channels(int) – 卷积产生的通道
kernel_size(int or tuple) - 卷积核的大小
stride(int or tuple, optional) - 卷积步长
padding(int or tuple, optional) - 输入的每一条边补充0的层数
output_padding(int or tuple, optional) - 输出的每一条边补充0的层数
dilation(int or tuple, optional) – 卷积核元素之间的间距
groups(int, optional) – 从输入通道到输出通道的阻塞连接数
bias(bool, optional) - 如果bias=True，添加偏置

shape:输入: (N,C_in,L_in)输出: (N,C_out,L_out)

$$L{out}=(L{in}-1)stride-2padding+kernel_size+output_padding$$

变量:

weight(tensor) - 卷积的权重，大小是(in_channels, in_channels,kernel_size)
bias(tensor) - 卷积的偏置系数，大小是(out_channel)

class torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True)

2维的转置卷积操作（transposed convolution operator，注意改视作操作可视作解卷积操作，但并不是真正的解卷积操作）该模块可以看作是Conv2d相对于其输入的梯度，有时（但不正确地）被称为解卷积操作。

说明

stride: 控制相关系数的计算步长dilation: 用于控制内核点之间的距离，详细描述在这里groups: 控制输入和输出之间的连接： group=1，输出是所有的输入的卷积；group=2，此时相当于有并排的两个卷积层，每个卷积层计算输入通道的一半，并且产生的输出是输出通道的一半，随后将这两个输出连接起来。

参数kernel_size，stride，padding，dilation数据类型：可以是一个int类型的数据，此时卷积height和width值相同; 也可以是一个tuple数组（包含来两个int类型的数据），第一个int数据表示height的数值，第二个int类型的数据表示width的数值

注意由于内核的大小，输入的最后的一些列的数据可能会丢失。因为输入和输出是不是完全的互相关。因此，用户可以进行适当的填充（padding操作）。

参数：

in_channels(int) – 输入信号的通道数
out_channels(int) – 卷积产生的通道数
kerner_size(int or tuple) - 卷积核的大小
stride(int or tuple,optional) - 卷积步长
padding(int or tuple, optional) - 输入的每一条边补充0的层数
output_padding(int or tuple, optional) - 输出的每一条边补充0的层数
dilation(int or tuple, optional) – 卷积核元素之间的间距
groups(int, optional) – 从输入通道到输出通道的阻塞连接数
bias(bool, optional) - 如果bias=True，添加偏置

shape:输入: (N,C_in,H_in，W_in)输出: (N,C_out,H_out,W_out)

$$H{out}=(H{in}-1)stride[0]-2padding[0]+kernel_size[0]+output_padding[0]$$

$$W{out}=(W{in}-1)stride[1]-2padding[1]+kernel_size[1]+output_padding[1]$$

变量:

weight(tensor) - 卷积的权重，大小是(in_channels, in_channels,kernel_size)
bias(tensor) - 卷积的偏置系数，大小是（out_channel）

Example

>>> # With square kernels and equal stride>>> m = nn.ConvTranspose2d(16, 33, 3, stride=2)>>> # non-square kernels and unequal stride and with padding>>> m = nn.ConvTranspose2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2))>>> input = autograd.Variable(torch.randn(20, 16, 50, 100))>>> output = m(input)>>> # exact output size can be also specified as an argument>>> input = autograd.Variable(torch.randn(1, 16, 12, 12))>>> downsample = nn.Conv2d(16, 16, 3, stride=2, padding=1)>>> upsample = nn.ConvTranspose2d(16, 16, 3, stride=2, padding=1)>>> h = downsample(input)>>> h.size()torch.Size([1, 16, 6, 6])>>> output = upsample(h, output_size=input.size())>>> output.size()torch.Size([1, 16, 12, 12])

torch.nn.ConvTranspose3d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True)

3维的转置卷积操作（transposed convolution operator，注意改视作操作可视作解卷积操作，但并不是真正的解卷积操作）转置卷积操作将每个输入值和一个可学习权重的卷积核相乘，输出所有输入通道的求和

该模块可以看作是Conv3d相对于其输入的梯度，有时（但不正确地）被称为解卷积操作。

说明

参数kernel_size，stride, padding，dilation数据类型：一个int类型的数据，此时卷积height和width值相同; 也可以是一个tuple数组（包含来两个int类型的数据），第一个int数据表示height的数值，tuple的第二个int类型的数据表示width的数值

注意由于内核的大小，输入的最后的一些列的数据可能会丢失。因为输入和输出是不是完全的互相关。因此，用户可以进行适当的填充（padding操作）。

参数：

in_channels(int) – 输入信号的通道数
out_channels(int) – 卷积产生的通道数
kernel_size(int or tuple) - 卷积核的大小
stride(int or tuple, optional) - 卷积步长
padding(int or tuple, optional) - 输入的每一条边补充0的层数
output_padding(int or tuple, optional) - 输出的每一条边补充0的层数
dilation(int or tuple, optional) – 卷积核元素之间的间距
groups(int, optional) – 从输入通道到输出通道的阻塞连接数
bias(bool, optional) - 如果bias=True，添加偏置

shape:输入: (N,C_in,H_in，W_in)输出: (N,C_out,H_out,W_out)

$$D{out}=(D{in}-1)stride[0]-2padding[0]+kernel_size[0]+output_padding[0]$$

$$H{out}=(H{in}-1)stride[1]-2padding[1]+kernel_size[1]+output_padding[0]$$

$$W{out}=(W{in}-1)stride[2]-2padding[2]+kernel_size[2]+output_padding[2]$$

变量:

weight(tensor) - 卷积的权重，大小是(in_channels, in_channels,kernel_size)
bias(tensor) - 卷积的偏置系数，大小是（out_channel）

Example

>>> # With square kernels and equal stride>>> m = nn.ConvTranspose3d(16, 33, 3, stride=2)>>> # non-square kernels and unequal stride and with padding>>> m = nn.Conv3d(16, 33, (3, 5, 2), stride=(2, 1, 1), padding=(0, 4, 2))>>> input = autograd.Variable(torch.randn(20, 16, 10, 50, 100))>>> output = m(input)

卷积层

卷积层

class torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

class torch.nn.Conv3d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True)

class torch.nn.ConvTranspose1d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True)

class torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True)

torch.nn.ConvTranspose3d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True)

results matching ""

No results matching ""