卷积神经网络
卷积神经网络(convolutional neural network,CNN)是一类强大的、为处理图像数据而设计的神经网络。现代卷积神经网络的设计得益于生物学、群论和一系列的补充实验。卷积神经网络需要的参数少于全连接架构的网络,而且卷积也很容易用GPU并行计算。因此卷积神经网络除了能够高效地采样从而获得精确的模型,还能够高效地计算。久而久之,从业人员越来越多地使用卷积神经网络。
卷积神经网络特点
卷积神经网络在图像处理上有以下特点:
1. 平移不变性(translation invariance):不管检测对象出现在图像中的哪个位置,神经网络的前面几层 应该对相同的图像区域具有相似的反应,即为“平移不变性”。
2. 局部性(locality):神经网络的前面几层应该只探索输入图像中的局部区域,而不过度在意图像中相隔 较远区域的关系,这就是“局部性”原则。最终,可以聚合这些局部特征,以在整个图像级别进行预测。
图像卷积
在二维互相关运算中,卷积窗口从输入张量的左上角开始,从左到右、从上到下滑动。当卷积窗口滑动到新一个位置时,包含在该窗口中的部分张量与卷积核张量进行按元素相乘,得到的张量再求和得到一个单一的标量值,由此我们得出了这一位置的输出张量值。在如上例子中,输出张量的四个元素由二维互相关运算得到,这个输出高度为2、宽度为2。
填充与步幅
在应用多层卷积时,我们常常丢失边缘像素。由于我们通常使用小卷积核,因此对于任何单个卷 积,我们可能只会丢失几个像素。但随着我们应用许多连续卷积层,累积丢失的像素数就多了。解决这个问 题的简单方法即为填充(padding):在输入图像的边界填充元素(通常填充元素是0)。例如, 我们将3 × 3输入填充到5 × 5,那么它的输出就增加为4 × 4。
我们将每次滑动元素的数量称为步幅(stride)。到目前为止,我们只使用过高度或宽度为1的步幅,那么如何 使用较大的步幅呢?图6.3.2是垂直步幅为3,水平步幅为2的二维互相关运算。
代码实现与结果
代码分为三段,第一段是卷积,填充与步幅的实现;第二部分是多段输入与多端输出的实现;第三段是LeNet的实现。 import torch from torch import nn from d2l import torch as d2l 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 def corr2d(X, K): """接受输入张量X和卷积核张量K,并返回张量Y""" 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 if __name__ == '__main__': #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]]) #corr2d(X, K) X = torch.ones((6, 8)) #每一行的第3-6都是0 X[:, 2:6] = 0 K = torch.tensor([[1.0, -1.0]]) Y = corr2d(X, K) #构造二维卷积层,具有1个输入通道,1个输出通道和形状为(1,2)的卷积核,不设偏置 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) lr = 3e-2 for i in range(10): Y_hat = conv2D(X) #计算Y跟卷积层输出的误差 l = (Y_hat - Y) ** 2 conv2D.zero_grad() l.sum().backward() #迭代卷积核 conv2D.weight.data[:] -= lr * conv2D.weight.grad if(i + 1) % 2 == 0: print(f'epoch{i + 1}, loss {l.sum():.3f}') #输出形状为n-k+p+1,n是输入形状,k为卷积核形状,p为填充 下面的卷积核为3,左右填充各1,相当于p=2,维持输出输入形状相同 conv2D1 = nn.Conv2d(1, 1, kernel_size=3, padding=1) #stride为步幅,为s,高度与宽度变为(n-k+p+1)/s conv2D2 = nn.Conv2d(1, 1, kernel_size=3, padding=1, stride=2)
import torch
from d2l import torch as d2l
def corr2d_multi_in(X, K):
#遍历X和K的第0个维度通道维度,然后相加
return sum(d2l.corr2d(x, k) for (x, k) in zip(X, K))
def corr2d_multi_in_out(X, K):
#迭代K的第0个维度通道维度,然后对输出X执行互相关运算,然后相加结果
return torch.stack([corr2d_multi_in(X, k) for k in K], 0)
if __name__ == '__main__':
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_multi_in(X, K)
"""torch.stack方法用于沿着一个新的维度 join(也可称为cat)一系列的张量(可以是2个张量或者是更多),它会插入一个新的维度,并让张量按照这个新的维度进行张量的cat操作。"""
K = torch.stack((K, K + 1, K + 2), 0)
print(f'{corr2d_multi_in_out(X, K)}'
import torch from torch import nn from d2l import torch as d2l def evaluate_accuracy_gpu(net, data_iter, device=None): """使用GPU计算模型在数据集上的精度""" if isinstance(net, nn.Module): net.eval() # 设置为评估模式 if not device: device = next(iter(net.parameters())).device # 正确预测的数量,总预测的数量 metric = d2l.Accumulator(2) with torch.no_grad(): for X, y in data_iter: if isinstance(X, list): # BERT微调所需的(之后将介绍) X = [x.to(device) for x in X] else: X = X.to(device) y = y.to(device) metric.add(d2l.accuracy(net(X), y), y.numel()) return metric[0] / metric[1] def train_ch6(net, train_iter, test_iter, num_epochs, lr, device): """用GPU训练模型""" def init_weights(m): if type(m) == nn.Linear or type(m) == nn.Conv2d: nn.init.xavier_uniform_(m.weight) net.apply(init_weights) print('training on', device) net.to(device) optimizer = torch.optim.SGD(net.parameters(), lr=lr) loss = nn.CrossEntropyLoss() animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs], legend=['train loss', 'train acc', 'test acc']) timer, num_batches = d2l.Timer(), len(train_iter) for epoch in range(num_epochs): # 训练损失之和,训练准确率之和,样本数 metric = d2l.Accumulator(3) net.train() for i, (X, y) in enumerate(train_iter): timer.start() optimizer.zero_grad() X, y = X.to(device), y.to(device) y_hat = net(X) l = loss(y_hat, y) l.backward() optimizer.step() with torch.no_grad(): metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0]) timer.stop() train_l = metric[0] / metric[2] train_acc = metric[1] / metric[2] if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1: animator.add(epoch + (i + 1) / num_batches, (train_l, train_acc, None)) test_acc = evaluate_accuracy_gpu(net, test_iter) animator.add(epoch + 1, (None, None, test_acc)) print(f'loss {train_l:.3f}, train acc {train_acc:.3f}, ' f'test acc {test_acc:.3f}') print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec ' f'on {str(device)}') if __name__ == '__main__': net = nn.Sequential( nn.Conv2d(1, 6, kernel_size=5, padding=2), nn.Sigmoid(), nn.AvgPool2d(kernel_size=2, stride=2), #2x2平均汇聚层, 步幅2 nn.Conv2d(6, 16, kernel_size=5), nn.Sigmoid(), nn.AvgPool2d(kernel_size=2, stride=2), nn.Flatten(), nn.Linear(16 * 5 * 5, 120), nn.Sigmoid(), nn.Linear(120, 84), nn.Sigmoid(), nn.Linear(84, 10) ) X = torch.rand(size=(1, 1, 28, 28), dtype=torch.float32) for layer in net: X = layer(X) batch_size = 256 train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size=batch_size) lr, num_epochs = 0.9, 10 train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())