1. 从全连接层到卷积层

• 多层感知机对图像处理是百万维度，模型不可实现。
• 如果要在图片中找到某个物体，寻找方法应该和物体位置无关。

适合计算机视觉的神经网络架构：

1. 平移不变性：不管检测对象出现在图像中的哪个位置，神经网络前几层应该对相同图像区域有相似的反应。
2. 局部性：神经网络的前面几层应该只探索输入图像中的局部区域，而不过度在意图像中相隔较远区域的关系。

2. 图像卷积

2.1 互相关运算

严格来说，卷积层所表达的运算其实是互相关运算。

不同颜色所选的区域与同一个卷积核做互相关运算，最后得到输出。

同理，卷积核滑动进行互相关运算。最终得到高度为2，宽度为2的输出。

输出大小：

"""定义corr2d函数：1、该函数接受输入张量X和卷积核张量K，并返回输出张量Y2、输出大小 = 输入大小n(k)×n(w) - 卷积核大小k(h)×k(w)3、即：(n(k)-k(h)+1) × (n(w)-k(w)+1 )
"""
import torch
from torch import nn
from d2l import torch as d2ldef corr2d(X, K): #@save"""计算二维互相关运算"""# 卷积核的高度h和宽度w，K指卷积核Kernelh, w = K.shape# 设置输出Y的大小，用0进行填充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

对上图进行验证

2.2 卷积层

定义卷积层Conv2D：

1. 卷积层对输入和卷积核权重进行互相关运算；
2. 并在添加标量偏置之后产生输出。

"""定义卷积层Conv2D：1、卷积层对输入和卷积核权重进行互相关运算；2、并在添加标量偏置之后产生输出。
"""
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))# corr2d(X, K)def forward(self, x):return corr2d(x, self.weight) + self.bias

2.3 图像中目标的边缘检测

# 卷积层的一个简单应用：通过找到像素变化的位置，来检测图像中不同颜色的边缘。
# 1、构造一个6×8像素的黑白图像
X = torch.ones((6, 8))
X[:, 2:6] = 0
X

# 2、我们构造一个高度为1、宽度为2的卷积核K（水平相邻元素相同输出为0）
K = torch.tensor([[1.0, -1.0]])Y = corr2d(X, K)
Y

2.4 学习卷积核

"""由X生成Y的卷积核：1、构造一个卷积层，并将其卷积核初始化为随机张量；2、在每次迭代中，比较Y与卷积层输出的平方误差，然后计算梯度来更新卷积核；3、使用内置的二维卷积层，并忽略偏置。
"""
# 构造一个二维卷积层，它具有1个输出通道和形状为（1，2）的卷积核
conv2d = nn.Conv2d(1, 1, kernel_size=(1, 2), bias=False)# 这个二维卷积层使用四维输入和输出格式（批量大小、通道、高度、宽度），
# 其中批量大小和通道数都为1
X = X.reshape((1, 1, 6, 8))
Y = Y.reshape((1, 1, 6, 7))
lr = 3e-2 # 学习率# 进行训练，轮数为10。计算梯度并进行更新，输出loss
for i in range(10):# 定义损失函数：交叉熵损失Y_hat = conv2d(X)l = (Y_hat - Y) ** 2# 梯度置零conv2d.zero_grad()l.sum().backward()# 迭代卷积核# 梯度更新：w = w - lr * w'conv2d.weight.data[:] -= lr * conv2d.weight.grad# 每隔2轮输出一次if(i + 1) % 2 ==0:print(f'epoch{i+1}, loss{l.sum():.3f}')

这里可以看到学习的卷积核接近之前边缘检测的卷积核。

2.5 特征映射和感受野

1. 输出的卷积层有时被称为特征映射。
2. 在卷积神经网络中，对于某一层的任意元素x，其感受野是指在前向传播期间可能影响x计算的所有元素。

3. 填充和步幅

• 问题一：应用了连续卷积，最终得到的输出远小于输入大小，使得原始图像的边界丢失了许多有用信息，我们希望输入大小和输出大小相同？
  解决：填充：在输入图像的边界填充元素（通常填充元素是0）
• 问题二：有时原始的输入分辨率十分冗余，我们可能希望大幅降低图像的宽度和高度？
  解决：步幅：设置卷积核滑动的步幅来减少采样次数
• 问题三：卷积核为什么一般选择奇数？
  解决：保持空间维度的同时，我们可以在顶部和底部填充相同数量的行，在左侧和右侧填充相同数量的列。

3.1 填充

填充（padding）：在输入图像的边界填充元素（通常填充元素是0）

"""填充：1、输入给定8×8，输出要求8×82、卷积核的大小为3×3，所有侧边填充1个像素
"""
import torch
from torch import nn# 为了方便起见，我们定义了一个计算卷积层的函数。
# 此函数初始化卷积层权重，并对输入和输出提高和缩减相应的维数
def comp_conv2d(conv2d, X):# 这里的（1，1）表示批量大小和通道数都是1X = X.reshape((1, 1) + X.shape)Y = conv2d(X)# 省略前两个维度：批量大小和通道(1, 1, 8, 8)return Y.reshape(Y.shape[2:])conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1)
X = torch.rand(size=(8, 8))
print(X)
print(conv2d)
print(comp_conv2d(conv2d, X))
comp_conv2d(conv2d, X).shape

# 卷积核为5×3时，为了使输入和输出相同，高度填充2，宽度填充1
conv2d = nn.Conv2d(1, 1, kernel_size=(5, 3), padding=(2, 1))
comp_conv2d(conv2d, X).shape

3.2 步幅

步幅（stride）：每次滑动元素的数量

"""步幅：1、每次滑动元素的数量；2、为了高效计算或是缩减采样次数，卷积窗口可以跳过中间位置，每次滑动多个元素。
"""
# 将高度和宽度的步幅设置为2，从而将输入的高度和宽度减半
# (8 + 2 - 3) / 2 = 4
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1, stride=2)
comp_conv2d(conv2d, X).shape

4. 多输入多输出通道

4.1 多输入通道

当输入包含多个通道时，需要构造一个与输入数据具有相同输入通道数的卷积核，以便与输入数据进行互相关运算。

import torch
from d2l import torch as d2ldef corr2d_multi_in(X, K):# 先遍历“X”和“K”的第0个维度（通道维度），再把它们加在一起return sum(d2l.corr2d(x, k) for x, k in zip(X, K))# 构造输入张量X和核张量K，以验证互相关运算的输出
X = torch.tensor([[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]])
K = torch.tensor([[[0.0 ,1.0], [2.0, 3.0]],[[1.0, 2.0], [3.0, 4.0]]])corr2d_muti_in(X, K)

4.2 多输出通道

多输出通道：

1. 在最流行的神经网络架构中，随着神经网络层数的加深，我们常会增加输出通道的维数，通过减少空间分辨率以获得更大的通道深度。
2. 将每个通道看作对不同特征的响应。

# 实现一个计算多个通道的输出的互相关函数
def corr2d_multi_in_out(X, K):# 迭代“K”的第0个维度，每次都对输入“X”执行互相关运算。# 最后将所有结果都叠加在一起return torch.stack([corr2d_multi_in(X, k) for k in K], 0)# 通过将核张量K与K+1（K中每个元素加1）和K+2连接起来，构造了一个具有3个输出通道的卷积核。
K = torch.stack((K, K + 1, K + 2), 0)# （输出通道数，输入通道数，高度，宽度）
K.shape

4.3 1×1卷积核

• 1×1卷积核被经常用来改变通道，相当于全连接层
• 可以对输入和输出的形状进行调整

# 使用全连接层实现1×1卷积
def corr2d_multi_in_out_1x1(X, K):c_i, h, w = X.shape# K:(输出通道，输入通道，高度，宽度)c_o = K.shape[0]X = X.reshape((c_i, h * w))K = K.reshape((c_o, c_i))# 全连接层中的矩阵乘法Y = torch.matmul(K, X)return Y.reshape((c_o, h, w))X = torch.normal(0, 1, (3, 3, 3))
K = torch.normal(0, 1, (2, 3, 1, 1))Y1 = corr2d_multi_in_out_1x1(X, K)
Y2 = corr2d_multi_in_out(X, K)
assert float(torch.abs(Y1 - Y2).sum()) < 1e-6
print(Y1)
print(Y2)

5. 汇聚层

通过逐渐聚合信息，生成越来越粗糙的映射，最终实现学习全局表示的目标，同时将卷积图层的所有优势保留在中间层。
汇聚（pooling）层（也叫做池化层）：

1. 降低卷积层对位置的敏感性
2. 降低对空间降采样表示的敏感性

5.1 最大汇聚层和平均汇聚层

汇聚层与卷积层的原理大体相似，只不过把互相关运算换成求最大值或者求平均值

# 最大汇聚层和平均汇聚层
"""定义汇聚层：1、设置汇聚层与输出的大小2、设置模式：大汇聚层和平均汇聚层
"""
import torch
from torch import nn
from d2l import torch as d2l# 默认为最大汇聚层
def pool2d(X, pool_size, mode='max'):# 获取汇聚层的高度和宽度p_h, p_w = pool_size# 设置输出层Y的高度和宽度Y = torch.zeros((X.shape[0] - p_h + 1, X.shape[1] - p_w + 1))# 进行遍历，相当于对矩阵的局部区域[i:i+p_h, j:j+p_w]求最大值/平均值for i in range(Y.shape[0]):for j in range(Y.shape[1]):if mode == 'max':Y[i, j] = X[i: i + p_h, j: j + p_w].max()if mode == 'avg':Y[i, j] = X[i: i + p_h, j: j + p_w].mean()return Y# 构建输入张量X，验证二维最大汇聚层输出
X = torch.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])
print(X)
print('最大汇聚层：\n', pool2d(X, (2, 2)))
print('平均汇聚层：\n', pool2d(X, (2, 2), 'avg'))
# print(f'最大汇聚层：{'\n'+pool2d(X, (2, 2))}')
# print(f'平均汇聚层：{pool2d(X, (2, 2), 'avg')}') 

5.2 填充和步幅

与卷积层一样，汇聚层也可以改变输出形状

# 构造了一个输入张量X，它有四个维度，其中样本数和通道数都是1
X = torch.arange(16, dtype=torch.float32).reshape((1, 1, 4, 4))
X

5.3 多个通道

多个通道：

1. 在处理多通道输入数据时，汇聚层在每个输入通道上单独运算，而不是像卷积层一样在通道上对输入进行汇总
2. 汇聚层的输出通道数与输入通道数相同。

"""多个通道：1、在处理多通道输入数据时，汇聚层在每个输入通道上单独运算，而不是像卷积层一样在通道上对输入进行汇总。2、汇聚层的输出通道数与输入通道数相同。
"""
X = torch.cat((X, X + 1), 1)
X

pool2d = nn.MaxPool2d(3, padding=1, stride=2)
pool2d(X)