PyTorch构建卷积层
- 二维图像卷积
- 一、 二维卷积层的实现
- 1. 手动实现二维卷积层
- 2. Pytorch的卷积层API实现
- 二、 二维卷积层的填充和步幅
二维图像卷积
使用全连接层来处理图片时，如果图片的尺寸比较大，那么就会出现参数爆炸的情况，模型复杂度直线提升而难以训练。为了降低模型的复杂度，提出了卷积层的概念。
卷积层是在全连接层的基础上，对于参数的取值加以限制来降低模型的复杂度。基于这样两种假设：
- 平移不变性：
- 局部性原理：
在这两种假设的基础上，卷积层大大减低了参数的数量。
一、 二维卷积层的实现
1. 手动实现二维卷积层
import torch
from torch import nn
def corr2d(X, K):
"""计算二维相关运算"""
h, w = K.shape
Y = torch.zeros(X.shape[0] - h + 1, X.shape[1] - w + 1)
for i in range(Y.shape[0]):
for j in range(Y.shape[1]):
Y[i, j] = (X[i:i+h, j:j+w] * K).sum()
return Y
class Conv2D(nn.Module):
"""2维卷积层"""
def __init__(self, kernel_size):
super().__init__()
self.weight = nn.Parameter(torch.rand(kernel_size))
self.bias = nn.Parameter(torch.zeros(1))
def forward(self, x):
return corr2d(x, self.weight) + self.bias
# 测试Conv2D是否正确
# 生成输入样本X
>>>X = torch.ones((6, 8))
>>>X[:, 2:6] = 0
>>>X
>tensor([[1., 1., 0., 0., 0., 0., 1., 1.],
[1., 1., 0., 0., 0., 0., 1., 1.],
[1., 1., 0., 0., 0., 0., 1., 1.],
[1., 1., 0., 0., 0., 0., 1., 1.],
[1., 1., 0., 0., 0., 0., 1., 1.],
[1., 1., 0., 0., 0., 0., 1., 1.]])
# 定义卷积核K，使用corr2d得到输出Y
>>>K = torch.tensor([[1.0, -1.0]])
>>>Y = corr2d(X, K)
>>>Y
>tensor([[ 0., 1., 0., 0., 0., -1., 0.],
[ 0., 1., 0., 0., 0., -1., 0.],
[ 0., 1., 0., 0., 0., -1., 0.],
[ 0., 1., 0., 0., 0., -1., 0.],
[ 0., 1., 0., 0., 0., -1., 0.],
[ 0., 1., 0., 0., 0., -1., 0.]])
# 实例化卷积模型，使用{X, Y}作为数据，训练模型参数K
conv2d = Conv2D(kernel_size=(1,2))
>>>for i in range(10):
>>> Y_hat = conv2d(X)
>>> l = (Y_hat- Y)**2
>>> conv2d.zero_grad()
>>> l.sum().backward()
>>> conv2d.weight.data[:] -= 3e-2 * conv2d.weight.grad
>>> if (i + 1)%2 == 0:
>>> print(f'batch {i+1}, loss {l.sum():.3f}')
>batch 2, loss 7.240
batch 4, loss 1.494
batch 6, loss 0.365
batch 8, loss 0.108
batch 10, loss 0.037
# 查看训练结果
>>>conv2d.weight.data
>tensor([[ 1.0058, -0.9686]])2. Pytorch的卷积层API实现
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）（批量大小，输出通道数，*输出尺寸）。
参数：
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，添加偏置
训练变量：
weight(tensor) - 卷积的权重，大小是(out_channels, in_channels, kernel_size)
bias(tensor) - 卷积的偏置系数，大小是（out_channel）
import torch
from torch import nn
# 测试Conv2D是否正确
# 生成输入样本X
>>>X = torch.ones((6, 8))
>>>X[:, 2:6] = 0
>>>X
>tensor([[1., 1., 0., 0., 0., 0., 1., 1.],
[1., 1., 0., 0., 0., 0., 1., 1.],
[1., 1., 0., 0., 0., 0., 1., 1.],
[1., 1., 0., 0., 0., 0., 1., 1.],
[1., 1., 0., 0., 0., 0., 1., 1.],
[1., 1., 0., 0., 0., 0., 1., 1.]])
# 定义卷积核K，使用corr2d得到输出Y
>>>K = torch.tensor([[1.0, -1.0]])
>>>Y = corr2d(X, K)
>>>Y
>tensor([[ 0., 1., 0., 0., 0., -1., 0.],
[ 0., 1., 0., 0., 0., -1., 0.],
[ 0., 1., 0., 0., 0., -1., 0.],
[ 0., 1., 0., 0., 0., -1., 0.],
[ 0., 1., 0., 0., 0., -1., 0.],
[ 0., 1., 0., 0., 0., -1., 0.]])
# 实例化卷积模型，使用{X, Y}作为数据，训练模型参数K
conv2d = nn.Conv2d(1, 1, kernel_size=(1,2), bias=False)
X = X.reshape((1, 1, 6, 8))
Y = Y.reshape((1, 1, 6, 7))
>>>for i in range(10):
>>> Y_hat = conv2d(X)
>>> l = (Y_hat- Y)**2
>>> conv2d.zero_grad()
>>> l.sum().backward()
>>> conv2d.weight.data[:] -= 3e-2 * conv2d.weight.grad
>>> if (i + 1)%2 == 0:
>>> print(f'batch {i+1}, loss {l.sum():.3f}')
>batch 2, loss 3.821
batch 4, loss 1.196
batch 6, loss 0.428
batch 8, loss 0.165
batch 10, loss 0.066
# 查看训练结果
>>>conv2d.weight.data
>tensor([[[[ 1.0198, -0.9673]]]])二、 二维卷积层的填充和步幅
卷积会使得图像的大小逐渐减小，一个HW大小的图像，使用kk的卷积核，输出大小会降低为 (H - K + 1)( W - K + 1)。这会限制掉模型可以构建的最大深度。
填充是为了解决这个问题而出现的。填充就是在图像的四周加入额外的行和列，行列填充 P 行/列时，输出大小就变成了(H - K + P + 1)( W - K + P + 1)。
一般来说，使用填充是为了保持输入输出大小相同，所以，一般P的取值为 P = K - 1。
步幅是指卷积核在图像上滑动的步长，合理使用步长可以快速调整图像是尺寸。一般设置为2，将图像尺寸缩小一半。
import torch
from torch import nn
# 定义函数，查看卷积输出尺寸
def comp_conv2d(conv2d, x):
x = x.reshape((1,1) + x.shape)
Y = conv2d(x)
return Y.reshape(Y.shape[2:])
# 定义卷积层，核 3*3，填充为1*1，输出尺寸不变
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)
x = torch.rand(size=(8, 8))
comp_conv2d(conv2d, x).shape
output: torch.Size([8, 8])
# 定义卷积层，核 5*3，填充为2*1，输出尺寸不变
conv2d = nn.Conv2d(1, 1, kernel_size=(5, 3), padding=(2, 1))
x = torch.rand(size=(8, 8))x = torch.rand(size=(8, 8))
comp_conv2d(conv2d, x).shape
output: torch.Size([8, 8])
# 定义卷积层，核 3*3，填充为1*1，步幅为1，输出尺寸减半
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)
x = torch.rand(size=(8, 8))
comp_conv2d(conv2d, x).shape
output: torch.Size([4, 4])
