深度学习笔记017卷积层

看到一句话，其实卷积层就是一种滤波器，放大它感兴趣的，缩小它不感兴趣的，很有道理。

 

二维卷积层的数学表达：

 

这里这个W其实就是kernel，是在这里通过这种方式学习出来的参数，表现出来的就是一个矩阵。b是偏差，通过广播机制作用给Y。

 

 

 二维交叉和二维卷积，就差一个翻转的关系：

 

 

 为了简单，我们把负号删掉了。所以在神经网络里虽然我们说在做卷积，其实是在做交叉相关。

 

图像处理领域一般都用二维的卷积层，但是一维和三维也在应用中很重要。

一维卷积：

　　文本、语言、时序序列

二维卷积：

　　视频、医学图像、气象地图

 

卷积层就是将输入和核矩阵进行交叉相关，再加上偏移之后，进行输出。

核矩阵和偏移是可学习的量。

核矩阵的大小是超参数。

 

Q&A：

1、Kernel大小主流用3x3，最多5x5。感受野不是越大越好，最终我们虽然会看到整张图，类似为什么是深度学习而不是广度学习一样，我们用大核少做几次和用小核多做几次，工作量一样，但是视野小一些会更棒。

 

卷积层控制输出大小的超参数：填充和步幅

填充：可以控制输出形状的减小量

步幅：可以成倍减小输出形状

　　填充：在输入的四周添加额外的行或列

　　　　通常利用填充，使得输出保持与输入一样的大小

　　　　

　　步幅：是指滑行的行/列的步长，高度和宽度的步幅可以不同

　　　　步幅计算：

　　　　

 

 

Q&A：

1、一般来说，填充会使得输出和输入不变，因为这样子算起来比较方便，否则需要一直想着输入输出变化的关系；

2、通常来讲，步幅常常=1，除非计算量明显太大了；

3、卷积的边长一般取奇数，因为取奇数时填充会方便一些，上下左右对称一些。但是效果上来说，奇偶差不多了。

4、机器学习本质上就是信息筛选，信息压缩，我们的信息一直都是丢失的，只要在操作，就是在丢失信息。只不过在压缩的时候，我们放大了我们感兴趣的特征。

5、一个特定的卷积层就是去匹配一种特定的纹理。

 

代码如下：

import torch
from torch import nn
from d2l import torch as d2l


# 定义一个计算二维相关的运算
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


X = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])
K = torch.tensor([[0.0, 1.0], [2.0, 3.0]])
print(corr2d(X, K))


# 实现二维卷积层
class Conv2D(nn.Module):
    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


# 简易应用：检测图像不同颜色的边缘
X=torch.ones((6,8)) #z做了一个有两条竖线边缘的矩阵
X[:,2:6]=0
print(X)
K=torch.tensor([[1.0,-1.0]])
Y=corr2d(X,K)
print(corr2d(X,K))

# # 类比做一个检测竖直边缘的算子
# X=torch.ones((10,8)) #z做了一个有两条竖线边缘的矩阵
# X[3:7,:]=0
# print(X)
# K=torch.tensor([[1.0],[-1.0]])
# print(corr2d(X,K))

# 学习由X生成的Y的卷积核
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}')

print(conv2d.weight.data.reshape((1,2)))# 不reshape就会输出四维


# 2维变为4维，用于下面的函数
XX=torch.zeros((2,3))
print(XX)
XX=XX.reshape((1,1)+XX.shape)
print(XX)

# 填充和步幅
def comp_conv2d(conv2d,X):
    X=X.reshape((1,1)+X.shape)  #2维变为4维
    Y=conv2d(X)
    return Y.reshape(Y.shape[2:])

conv2d=nn.Conv2d(1,1,kernel_size=3,padding=1) # 填充为1，上下左右各填充一行
X=torch.rand(size=(8,8))
print(comp_conv2d(conv2d,X).shape)

conv2d=nn.Conv2d(1,1,kernel_size=(5,3),padding=(2,1)) # 前面为上下，后面为左右
print(comp_conv2d(conv2d,X).shape)

conv2d=nn.Conv2d(1,1,kernel_size=3,padding=1,stride=2) # 步幅为2
X=torch.rand(size=(8,8))
print(comp_conv2d(conv2d,X).shape)

conv2d=nn.Conv2d(1,1,kernel_size=(3,5),padding=(0,1),stride=(3,5)) # 填充为1，上下左右各填充一行
X=torch.rand(size=(8,8))
print(comp_conv2d(conv2d,X).shape)