【Pytorch笔记】7.torch.nn (Convolution Layers),yoga11s

文件名：【Pytorch笔记】7.torch.nn (Convolution Layers),yoga11s 【Pytorch笔记】7.torch.nn (Convolution Layers)

我们常用torch.nn来封装网络，torch.nn为我们封装好了很多神经网络中不同的层，如卷积层、池化层、归一化层等。我们会把这些层像是串成一个牛肉串一样串起来，形成网络。

先从最简单的，都有哪些层开始学起。

Convolution Layers - 卷积层 torch.nn.Conv1d()

1维卷积层。

torch.nn.Conv1d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)

in_channels：输入tensor的通道数； out_channels：输出tensor的通道数； kernel_size：卷积核的大小； stride：步长； padding：输入tensor的边界填充尺寸； dilation：卷积核之间的间距（下面这个图为dilation=2），默认为1；

groups：从输入通道到输出通道的阻塞连接数。in_channel和out_channel需要能被groups整除。更具体地： groups=1时所有输入均与所有输出进行卷积，groups=2时该操作相当于并排设置两个卷积层，每卷积层看到一半的输入通道，产生一半的输出通道，然后将两个卷积层连接起来。groups=in_channel时输入的每个通道都和相应的卷积核进行卷积； bias：是否添加可学习的偏差值，True为添加，False为不添加。 padding_mode：填充模式，有以下取值：zeros（这个是默认值）、reflect、replicate、circular。

import torchimport torch.nn as nnm = nn.Conv1d(in_channels=16,out_channels=33,kernel_size=3,stride=2)# input: 批大小为20，每个数据通道为16，size=50input = torch.randn(20, 16, 50)output = m(input)print(output.size())

输出

# output: 批大小为20，每个数据通道为33，size=24torch.Size([20, 33, 24]) torch.nn.Conv2d()

2维卷积层。

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)

参数与Conv1d()基本一样，不再赘述。

import torchimport torch.nn as nnm = nn.Conv2d(in_channels=2,out_channels=3,kernel_size=3,stride=2)input = torch.randn(20, 2, 5, 6)output = m(input)print(output.size())

输出

torch.Size([20, 3, 2, 2]) torch.nn.Conv3d()

3维卷积层。

torch.nn.Conv3d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)

参数与Conv1d()基本一样，不再赘述。

import torchimport torch.nn as nnm = nn.Conv3d(in_channels=2,out_channels=3,kernel_size=3,stride=2)input = torch.randn(20, 2, 4, 5, 6)output = m(input)print(output.size())

输出

torch.Size([20, 3, 1, 2, 2]) torch.nn.ConvTranspose1d()

1维转置卷积层。

torch.nn.ConvTranspose1d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1, padding_mode='zeros', device=None, dtype=None)

参数与Conv1d()基本一样，不再赘述。 唯一不同的是output_padding，与padding不同的是，output_padding是输出tensor的每一个边，外面填充的层数。 （padding是输入tensor的每个边填充的层数）

import torchimport torch.nn as nnm = nn.ConvTranspose1d(in_channels=2,out_channels=3,kernel_size=3,stride=1)input = torch.randn(20, 2, 2)output = m(input)print(output.size())

输出

torch.Size([20, 3, 4]) torch.nn.ConvTranspose2d()

2维转置卷积层。

torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1, padding_mode='zeros', device=None, dtype=None)

参数与Conv1d()基本一样，不再赘述。

import torchimport torch.nn as nnm = nn.ConvTranspose2d(in_channels=2,out_channels=3,kernel_size=3,stride=1)input = torch.randn(20, 2, 2, 2)output = m(input)print(output.size())

输出

torch.Size([20, 3, 4, 4]) torch.nn.ConvTranspose3d()

3维转置卷积层。

torch.nn.ConvTranspose3d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1, padding_mode='zeros', device=None, dtype=None)

参数与Conv1d()基本一样，不再赘述。

import torchimport torch.nn as nnm = nn.ConvTranspose3d(in_channels=2,out_channels=3,kernel_size=3,stride=1)input = torch.randn(20, 2, 2, 2, 2)output = m(input)print(output.size())

输出

torch.Size([20, 3, 4, 4, 4]) torch.nn.LazyConv1d()

1维延迟初始化卷积层，当in_channel不确定时可使用这个层。 关于延迟初始化，大家可以参考这篇文章，我认为讲的很好： 俱往矣… - 延迟初始化——【torch学习笔记】

torch.nn.LazyConv1d(out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)

LazyConv1d没有in_channel参数。 这不代表这个层没有输入的通道，而是在调用时自动适配，并进行初始化。 引用文章中的一段代码，改成LazyConv1d，讲述使用方法。

import torchimport torch.nn as nnnet = nn.Sequential(nn.LazyConv1d(256, 2),nn.ReLU(),nn.Linear(9, 10))print(net)[net[i].state_dict() for i in range(len(net))]low = torch.finfo(torch.float32).min / 10high = torch.finfo(torch.float32).max / 10X = torch.zeros([2, 20, 10], dtype=torch.float32).uniform_(low, high)net(X)print(net)

输出

Sequential((0): LazyConv1d(0, 256, kernel_size=(2,), stride=(1,))(1): ReLU()(2): Linear(in_features=9, out_features=10, bias=True))Sequential((0): Conv1d(20, 256, kernel_size=(2,), stride=(1,))(1): ReLU()(2): Linear(in_features=9, out_features=10, bias=True))

可以看出，未进行初始化时，in_features=0。只有传入参数使用网络后才会根据输入进行初始化。

torch.nn.LazyConv2d()

2维延迟初始化卷积层。

torch.nn.LazyConv2d(out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None) torch.nn.LazyConv3d()

3维延迟初始化卷积层。

torch.nn.LazyConv3d(out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None) torch.nn.LazyConvTranspose1d()

1维延迟初始化转置卷积层。

torch.nn.LazyConvTranspose1d(out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1, padding_mode='zeros', device=None, dtype=None) torch.nn.LazyConvTranspose2d()

2维延迟初始化转置卷积层。

torch.nn.LazyConvTranspose2d(out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1, padding_mode='zeros', device=None, dtype=None) torch.nn.LazyConvTranspose3d()

3维延迟初始化转置卷积层。

torch.nn.LazyConvTranspose3d(out_channels, kernel_size, stride=1, padding=0, output_padding=0, groups=1, bias=True, dilation=1, padding_mode='zeros', device=None, dtype=None) torch.nn.Unfold()

从一个批次的输入张量中提取出滑动的局部区域块。

torch.nn.Unfold(kernel_size, dilation=1, padding=0, stride=1)

kernel_size：滑动块的大小； dilation：卷积核之间的间距(torch.nn.Conv1d中有图示)； padding：输入tensor的边界填充尺寸； stride：滑块滑动的步长。

这里的输入必须是4维的tensor，否则会报这样的错误：

NotImplementedError: Input Error: Only 4D input Tensors are supported (got 2D)

示例

import torchfrom torch import nnt = torch.tensor([[[[1., 2., 3., 4.],[5., 6., 7., 8.],[9., 10., 11., 12.],[13., 14., 15., 16.],]]])unfold = nn.Unfold(kernel_size=(2, 2), dilation=1, padding=0, stride=1)output = unfold(t)print(output)

输出

tensor([[[ 1., 2., 3., 5., 6., 7., 9., 10., 11.],[ 2., 3., 4., 6., 7., 8., 10., 11., 12.],[ 5., 6., 7., 9., 10., 11., 13., 14., 15.],[ 6., 7., 8., 10., 11., 12., 14., 15., 16.]]])

torch.nn.Fold()

Unfold()的逆操作。当Unfold()时出现滑块有重复覆盖时会导致结果和原来不一样。因为Fold()的过程中对于同一个位置的元素进行加法处理。

torch.nn.Fold(output_size, kernel_size, dilation=1, padding=0, stride=1)

下面是Unfold()和Fold()结合的代码，Unfold()部分和上面代码相同。

import torchfrom torch import nnt = torch.tensor([[[[1., 2., 3., 4.],[5., 6., 7., 8.],[9., 10., 11., 12.],[13., 14., 15., 16.]]]])unfold = nn.Unfold(kernel_size=(2, 2), dilation=1, padding=0, stride=1)output = unfold(t)print(output)fold = nn.Fold(output_size=(4, 4), kernel_size=(2, 2))out = fold(output)print(out)

输出

tensor([[[ 1., 2., 3., 5., 6., 7., 9., 10., 11.],[ 2., 3., 4., 6., 7., 8., 10., 11., 12.],[ 5., 6., 7., 9., 10., 11., 13., 14., 15.],[ 6., 7., 8., 10., 11., 12., 14., 15., 16.]]])tensor([[[[ 1., 4., 6., 4.],[10., 24., 28., 16.],[18., 40., 44., 24.],[13., 28., 30., 16.]]]])