#|动手学深度学习(第五章卷积神经网络) 卷积神经网络|神经网络|pytor

5.1 二维卷积层卷积神经网络（convolutional neural network）是含有卷积层（convolutional layer）的神经网络。本章中介绍的卷积神经网络均使用最常见的二维卷积层。它有高和宽两个空间维度，常用来处理图像数据。本节中，我们将介绍简单形式的二维卷积层的工作原理。
5.1.1 二维互相关运算二维互相关（cross-correlation）运算的输入是一个二维输入数组和一个二维核（kernel）数组，输出也是一个二维数组，其中核数组通常称为卷积核或过滤器（filter）。卷积核的尺寸通常小于输入数组，卷积核在输入数组上滑动，在每个位置上，卷积核与该位置处的输入子数组按元素相乘并求和，得到输出数组中相应位置的元素。图1展示了一个互相关运算的例子，阴影部分分别是输入的第一个计算区域、核数组以及对应的输出。

文章图片

图1 二维互相关运算
下面我们用corr2d函数实现二维互相关运算，它接受输入数组X与核数组K，并输出数组Y。

import torch import torch.nn as nndef corr2d(X, K): H, W = X.shape h, w = K.shape Y = torch.zeros(H - h + 1, W - 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

我们可以构造图5.1中的输入数组X、核数组K来验证二维互相关运算的输出。

X = torch.tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) K = torch.tensor([[0, 1], [2, 3]]) corr2d(X, K)

tensor([[19., 25.], [37., 43.]])

5.1.2 二维卷积层二维卷积层将输入和卷积核做互相关运算，并加上一个标量偏差来得到输出。卷积层的模型参数包括了卷积核和标量偏差。在训练模型的时候，通常我们先对卷积核随机初始化，然后不断迭代卷积核和偏差。
下面基于corr2d函数来实现一个自定义的二维卷积层。在构造函数__init__里我们声明weight和bias这两个模型参数。前向计算函数forward则是直接调用corr2d函数再加上偏差。

class Conv2D(nn.Module): def __init__(self, kernel_size): super(Conv2D, self).__init__() self.weight = nn.Parameter(torch.randn(kernel_size)) self.bias = nn.Parameter(torch.randn(1))def forward(self, x): return corr2d(x, self.weight) + self.bias

卷积窗口形状为 p × q p \times q p×q的卷积层称为 p × q p \times q p×q卷积层。同样， p × q p \times q p×q卷积或 p × q p \times q p×q卷积核说明卷积核的高和宽分别为 p p p和 q q q。
5.1.3 图像中物体边缘检测 【#|动手学深度学习(第五章卷积神经网络)】下面我们来看一个卷积层的简单应用：检测图像中物体的边缘，即找到像素变化的位置。首先我们构造一张 6 × 8 6\times 8 6×8的图像（即高和宽分别为6像素和8像素的图像）。它中间4列为黑（0），其余为白（1）。

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.]])

然后我们构造一个高和宽分别为1和2的卷积核K。当它与输入做互相关运算时，如果横向相邻元素相同，输出为0；否则输出为非0。

K = torch.tensor([[1, -1]])

下面将输入X和我们设计的卷积核K做互相关运算。可以看出，我们将从白到黑的边缘和从黑到白的边缘分别检测成了1和-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.]])

5.1.4 通过数据学习核数组最后我们来看一个例子，它使用物体边缘检测中的输入数据X和输出数据Y来学习我们构造的核数组K。我们首先构造一个卷积层，其卷积核将被初始化成随机数组。接下来在每一次迭代中，我们使用平方误差来比较Y和卷积层的输出，然后计算梯度来更新权重。

# 构造一个核数组形状是(1, 2)的二维卷积层 conv2d = Conv2D(kernel_size=(1, 2)) step = 20 lr = 0.01 for i in range(step): Y_hat = conv2d(X) l = ((Y_hat - Y) ** 2).sum() l.backward()# 梯度下降 conv2d.weight.data -= lr * conv2d.weight.grad conv2d.bias.data -= lr * conv2d.bias.grad# 梯度清0 conv2d.weight.grad.fill_(0) conv2d.bias.grad.fill_(0) if (i + 1) % 5 == 0: print('Step %d, loss %.3f' % (i + 1, l.item()))

Step 5, loss 5.059 Step 10, loss 1.341 Step 15, loss 0.366 Step 20, loss 0.101

可以看到，20次迭代后误差已经降到了一个比较小的值。现在来看一下学习到的卷积核的参数。

print("weight: ", conv2d.weight.data) print("bias: ", conv2d.bias.data)

weight:tensor([[ 0.9229, -0.9161]]) bias:tensor([-0.0038])

5.1.5 互相关运算和卷积运算实际上，卷积运算与互相关运算类似。为了得到卷积运算的输出，我们只需将核数组左右翻转并上下翻转，再与输入数组做互相关运算。可见，卷积运算和互相关运算虽然类似，但如果它们使用相同的核数组，对于同一个输入，输出往往并不相同。
那么，你也许会好奇卷积层为何能使用互相关运算替代卷积运算。其实，在深度学习中核数组都是学出来的：卷积层无论使用互相关运算或卷积运算都不影响模型预测时的输出。为了解释这一点，假设卷积层使用互相关运算学出图5.1中的核数组。设其他条件不变，使用卷积运算学出的核数组即图5.1中的核数组按上下、左右翻转。也就是说，图5.1中的输入与学出的已翻转的核数组再做卷积运算时，依然得到图5.1中的输出。为了与大多数深度学习文献一致，如无特别说明，本书中提到的卷积运算均指互相关运算。
5.1.6 特征图和感受野二维卷积层输出的二维数组可以看作是输入在空间维度（宽和高）上某一级的表征，也叫特征图（feature map）。影响元素 x x x的前向计算的所有可能输入区域（可能大于输入的实际尺寸）叫做 x x x的感受野（receptive field）。以图5.1为例，输入中阴影部分的四个元素是输出中阴影部分元素的感受野。我们将图5.1中形状为 2 × 2 2 \times 2 2×2的输出记为 Y Y Y，并考虑一个更深的卷积神经网络：将 Y Y Y与另一个形状为 2 × 2 2 \times 2 2×2的核数组做互相关运算，输出单个元素 z z z。那么， z z z在 Y Y Y上的感受野包括 Y Y Y的全部四个元素，在输入上的感受野包括其中全部9个元素。可见，我们可以通过更深的卷积神经网络使特征图中单个元素的感受野变得更加广阔，从而捕捉输入上更大尺寸的特征。
我们常使用“元素”一词来描述数组或矩阵中的成员。在神经网络的术语中，这些元素也可称为“单元”。当含义明确时，本书不对这两个术语做严格区分。
小结

二维卷积层的核心计算是二维互相关运算。在最简单的形式下，它对二维输入数据和卷积核做互相关运算然后加上偏差。
我们可以设计卷积核来检测图像中的边缘。
我们可以通过数据来学习卷积核。

5.2 填充和步幅在上一节的例子里，我们使用高和宽为3的输入与高和宽为2的卷积核得到高和宽为2的输出。一般来说，假设输入形状是 n h × n w n_h\times n_w nh?×nw?，卷积核窗口形状是 k h × k w k_h\times k_w kh?×kw?，那么输出形状将会是
( n h ? k h + 1 ) × ( n w ? k w + 1 ) . (n_h-k_h+1) \times (n_w-k_w+1). (nh??kh?+1)×(nw??kw?+1).
所以卷积层的输出形状由输入形状和卷积核窗口形状决定。本节我们将介绍卷积层的两个超参数，即填充和步幅。它们可以对给定形状的输入和卷积核改变输出形状。
5.2.1 填充填充（padding）是指在输入高和宽的两侧填充元素（通常是0元素），图2里我们在原输入高和宽的两侧分别添加了值为0的元素。

文章图片

图2 在输入的高和宽两侧分别填充了0元素的二维互相关计算
如果原输入的高和宽是 n h n_h nh?和 n w n_w nw?，卷积核的高和宽是 k h k_h kh?和 k w k_w kw?，在高的两侧一共填充 p h p_h ph?行，在宽的两侧一共填充 p w p_w pw?列，则输出形状为：
( n h ? k h + p h + 1 ) × ( n w ? k w + p w + 1 ) , (n_h-k_h+p_h+1)\times(n_w-k_w+p_w+1), (nh??kh?+ph?+1)×(nw??kw?+pw?+1),
也就是说，输出的高和宽会分别增加 p h p_h ph?和 p w p_w pw?。
在很多情况下，我们会设置 p h = k h ? 1 p_h=k_h-1 ph?=kh??1和 p w = k w ? 1 p_w=k_w-1 pw?=kw??1来使输入和输出具有相同的高和宽。这样会方便在构造网络时推测每个层的输出形状。假设这里 k h k_h kh?是奇数，我们会在高的两侧分别填充 p h / 2 p_h/2 ph?/2行。如果 k h k_h kh?是偶数，一种可能是在输入的顶端一侧填充 ? p h / 2 ? \lceil p_h/2\rceil ?ph?/2?行，而在底端一侧填充 ? p h / 2 ? \lfloor p_h/2\rfloor ?ph?/2?行。在宽的两侧填充同理。
卷积神经网络经常使用奇数高宽的卷积核，如1、3、5和7，所以两端上的填充个数相等。对任意的二维数组X，设它的第i行第j列的元素为X[i,j]。当两端上的填充个数相等，并使输入和输出具有相同的高和宽时，我们就知道输出Y[i,j]是由输入以X[i,j]为中心的窗口同卷积核进行互相关计算得到的。
下面的例子里我们创建一个高和宽为3的二维卷积层，然后设输入高和宽两侧的填充数分别为1。给定一个高和宽为8的输入，我们发现输出的高和宽也是8。

import torch from torch import nn# 定义一个函数来计算卷积层。它对输入和输出做相应的升维和降维 def comp_conv2d(conv2d, X): # (1, 1)代表批量大小和通道数（“多输入通道和多输出通道”一节将介绍）均为1 X = X.view((1, 1) + X.shape) Y = conv2d(X) return Y.view(Y.shape[2:])# 排除不关心的前两维：批量和通道# 注意这里是两侧分别填充1行或列，所以在两侧一共填充2行或列 conv2d = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=3, padding=1)X = torch.rand(8, 8) comp_conv2d(conv2d, X).shape

torch.Size([8, 8])

当卷积核的高和宽不同时，我们也可以通过设置高和宽上不同的填充数使输出和输入具有相同的高和宽。

# 使用高为5、宽为3的卷积核。在高和宽两侧的填充数分别为2和1 conv2d = nn.Conv2d(in_channels=1, out_channels=1, kernel_size=(5, 3), padding=(2, 1)) comp_conv2d(conv2d, X).shape

torch.Size([8, 8])

5.2.2 步幅在上一节里我们介绍了二维互相关运算。卷积窗口从输入数组的最左上方开始，按从左往右、从上往下的顺序，依次在输入数组上滑动。我们将每次滑动的行数和列数称为步幅（stride）。
目前我们看到的例子里，在高和宽两个方向上步幅均为1。我们也可以使用更大步幅。图5.3展示了在高上步幅为3、在宽上步幅为2的二维互相关运算。可以看到，输出第一列第二个元素时，卷积窗口向下滑动了3行，而在输出第一行第二个元素时卷积窗口向右滑动了2列。当卷积窗口在输入上再向右滑动2列时，由于输入元素无法填满窗口，无结果输出。图5.3中的阴影部分为输出元素及其计算所使用的输入和核数组元素： 0 × 0 + 0 × 1 + 1 × 2 + 2 × 3 = 8 0\times0+0\times1+1\times2+2\times3=8 0×0+0×1+1×2+2×3=8、 0 × 0 + 6 × 1 + 0 × 2 + 0 × 3 = 6 0\times0+6\times1+0\times2+0\times3=6 0×0+6×1+0×2+0×3=6。

文章图片

一般来说，当高上步幅为 s h s_h sh?，宽上步幅为 s w s_w sw?时，输出形状为
? ( n h ? k h + p h + s h ) / s h ? × ? ( n w ? k w + p w + s w ) / s w ? . \lfloor(n_h-k_h+p_h+s_h)/s_h\rfloor \times \lfloor(n_w-k_w+p_w+s_w)/s_w\rfloor. ?(nh??kh?+ph?+sh?)/sh??×?(nw??kw?+pw?+sw?)/sw??.
如果设置 p h = k h ? 1 p_h=k_h-1 ph?=kh??1和 p w = k w ? 1 p_w=k_w-1 pw?=kw??1，那么输出形状将简化为 ? ( n h + s h ? 1 ) / s h ? × ? ( n w + s w ? 1 ) / s w ? \lfloor(n_h+s_h-1)/s_h\rfloor \times \lfloor(n_w+s_w-1)/s_w\rfloor ?(nh?+sh??1)/sh??×?(nw?+sw??1)/sw??。更进一步，如果输入的高和宽能分别被高和宽上的步幅整除，那么输出形状将是 ( n h / s h ) × ( n w / s w ) (n_h/s_h) \times (n_w/s_w) (nh?/sh?)×(nw?/sw?)。
下面我们令高和宽上的步幅均为2，从而使输入的高和宽减半。

conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1, stride=2) comp_conv2d(conv2d, X).shape

torch.Size([4, 4])

接下来是一个稍微复杂点儿的例子。

conv2d = nn.Conv2d(1, 1, kernel_size=(3, 5), padding=(0, 1), stride=(3, 4)) comp_conv2d(conv2d, X).shape

torch.Size([2, 2])

为了表述简洁，当输入的高和宽两侧的填充数分别为 p h p_h ph?和 p w p_w pw?时，我们称填充为 ( p h , p w ) (p_h, p_w) (ph?,pw?)。特别地，当 p h = p w = p p_h = p_w = p ph?=pw?=p时，填充为 p p p。当在高和宽上的步幅分别为 s h s_h sh?和 s w s_w sw?时，我们称步幅为 ( s h , s w ) (s_h, s_w) (sh?,sw?)。特别地，当 s h = s w = s s_h = s_w = s sh?=sw?=s时，步幅为 s s s。在默认情况下，填充为0，步幅为1。
小结

填充可以增加输出的高和宽。这常用来使输出与输入具有相同的高和宽。
步幅可以减小输出的高和宽，例如输出的高和宽仅为输入的高和宽的 1 / n 1/n 1/n（ n n n为大于1的整数）。

5.3 多输入通道和多输出通道之前的输入和输出都是二维数组，但真实数据的维度经常更高。例如，彩色图像在高和宽2个维度外还有RGB（红、绿、蓝）3个颜色通道。假设彩色图像的高和宽分别是 h h h和 w w w（像素），那么它可以表示为一个 3 × h × w 3 \times h \times w 3×h×w的多维数组，我们将大小为3的这一维称为通道（channel）维。
多输入通道卷积层的输入可以包含多个通道，图4展示了一个含2个输入通道的二维互相关计算的例子。

文章图片

图4 含2个输入通道的互相关计算
假设输入数据的通道数为 c i c_i ci?，卷积核形状为 k h × k w k_h\times k_w kh?×kw?，我们为每个输入通道各分配一个形状为 k h × k w k_h\times k_w kh?×kw?的核数组，将 c i c_i ci?个互相关运算的二维输出按通道相加，得到一个二维数组作为输出。我们把 c i c_i ci?个核数组在通道维上连结，即得到一个形状为 c i × k h × k w c_i\times k_h\times k_w ci?×kh?×kw?的卷积核。
接下来我们实现含多个输入通道的互相关运算。我们只需要对每个通道做互相关运算，然后通过add_n函数来进行累加。

import torch from torch import nn import d2lzh_pytorch as d2ldef corr2d_multi_in(X, K): # 沿着X和K的第0维（通道维）分别计算再相加 res = d2l.corr2d(X[0, :, :], K[0, :, :]) for i in range(1, X.shape[0]): res += d2l.corr2d(X[i, :, :], K[i, :, :]) return res

我们可以构造图5.4中的输入数组X、核数组K来验证互相关运算的输出。

X = torch.tensor([[[0, 1, 2], [3, 4, 5], [6, 7, 8]], [[1, 2, 3], [4, 5, 6], [7, 8, 9]]]) K = torch.tensor([[[0, 1], [2, 3]], [[1, 2], [3, 4]]])corr2d_multi_in(X, K)

tensor([[ 56.,72.], [104., 120.]])

5.3.2 多输出通道卷积层的输出也可以包含多个通道，设卷积核输入通道数和输出通道数分别为 c i c_i ci?和 c o c_o co?，高和宽分别为 k h k_h kh?和 k w k_w kw?。如果希望得到含多个通道的输出，我们可以为每个输出通道分别创建形状为 c i × k h × k w c_i\times k_h\times k_w ci?×kh?×kw?的核数组，将它们在输出通道维上连结，卷积核的形状即 c o × c i × k h × k w c_o\times c_i\times k_h\times k_w co?×ci?×kh?×kw?。
对于输出通道的卷积核，我们提供这样一种理解，一个 c i × k h × k w c_i \times k_h \times k_w ci?×kh?×kw?的核数组可以提取某种局部特征，但是输入可能具有相当丰富的特征，我们需要有多个这样的 c i × k h × k w c_i \times k_h \times k_w ci?×kh?×kw?的核数组，不同的核数组提取的是不同的特征。
下面我们实现一个互相关运算函数来计算多个通道的输出。

def corr2d_multi_in_out(X, K): # 对K的第0维遍历，每次同输入X做互相关计算。所有结果使用stack函数合并在一起 return torch.stack([corr2d_multi_in(X, k) for k in K])

我们将核数组K同K+1（K中每个元素加一）和K+2连结在一起来构造一个输出通道数为3的卷积核。

K = torch.stack([K, K + 1, K + 2]) K.shape # torch.Size([3, 2, 2, 2])

torch.Size([3, 2, 2, 2])

下面我们对输入数组X与核数组K做互相关运算。此时的输出含有3个通道。其中第一个通道的结果与之前输入数组X与多输入通道、单输出通道核的计算结果一致。

corr2d_multi_in_out(X, K)

tensor([[[ 56.,72.], [104., 120.]],[[ 76., 100.], [148., 172.]],[[ 96., 128.], [192., 224.]]])

1x1卷积层最后讨论形状为 1 × 1 1 \times 1 1×1的卷积核，我们通常称这样的卷积运算为 1 × 1 1 \times 1 1×1卷积，称包含这种卷积核的卷积层为 1 × 1 1 \times 1 1×1卷积层。图5展示了使用输入通道数为3、输出通道数为2的 1 × 1 1\times 1 1×1卷积核的互相关计算。

文章图片

图5 1x1卷积核的互相关计算。输入和输出具有相同的高和宽
1 × 1 1 \times 1 1×1卷积核可在不改变高宽的情况下，调整通道数。 1 × 1 1 \times 1 1×1卷积核不识别高和宽维度上相邻元素构成的模式，其主要计算发生在通道维上。假设我们将通道维当作特征维，将高和宽维度上的元素当成数据样本，那么 1 × 1 1\times 1 1×1卷积层的作用与全连接层等价。
下面我们使用全连接层中的矩阵乘法来实现 1 × 1 1\times 1 1×1卷积。这里需要在矩阵乘法运算前后对数据形状做一些调整。

def corr2d_multi_in_out_1x1(X, K): c_i, h, w = X.shape c_o = K.shape[0] X = X.view(c_i, h * w) K = K.view(c_o, c_i) Y = torch.mm(K, X)# 全连接层的矩阵乘法 return Y.view(c_o, h, w)

经验证，做 1 × 1 1\times 1 1×1卷积时，以上函数与之前实现的互相关运算函数corr2d_multi_in_out等价。

X = torch.rand(3, 3, 3) K = torch.rand(2, 3, 1, 1)Y1 = corr2d_multi_in_out_1x1(X, K) Y2 = corr2d_multi_in_out(X, K)(Y1 - Y2).norm().item() < 1e-6

True

在之后的模型里我们将会看到 1 × 1 1\times 1 1×1卷积层被当作保持高和宽维度形状不变的全连接层使用。于是，我们可以通过调整网络层之间的通道数来控制模型复杂度。
小结

使用多通道可以拓展卷积层的模型参数。
假设将通道维当作特征维，将高和宽维度上的元素当成数据样本，那么 1 × 1 1\times 1 1×1卷积层的作用与全连接层等价。
1 × 1 1\times 1 1×1卷积层通常用来调整网络层之间的通道数，并控制模型复杂度。

卷积层与全连接层的对比二维卷积层经常用于处理图像，与此前的全连接层相比，它主要有两个优势：
一是全连接层把图像展平成一个向量，在输入图像上相邻的元素可能因为展平操作不再相邻，网络难以捕捉局部信息。而卷积层的设计，天然地具有提取局部信息的能力。
二是卷积层的参数量更少。不考虑偏置的情况下，一个形状为 ( c i , c o , h , w ) (c_i, c_o, h, w) (ci?,co?,h,w)的卷积核的参数量是 c i × c o × h × w c_i \times c_o \times h \times w ci?×co?×h×w，与输入图像的宽高无关。假如一个卷积层的输入和输出形状分别是 ( c 1 , h 1 , w 1 ) (c_1, h_1, w_1) (c1?,h1?,w1?)和 ( c 2 , h 2 , w 2 ) (c_2, h_2, w_2) (c2?,h2?,w2?)，如果要用全连接层进行连接，参数数量就是 c 1 × c 2 × h 1 × w 1 × h 2 × w 2 c_1 \times c_2 \times h_1 \times w_1 \times h_2 \times w_2 c1?×c2?×h1?×w1?×h2?×w2?。使用卷积层可以以较少的参数数量来处理更大的图像。
卷积层的简洁实现我们使用Pytorch中的nn.Conv2d类来实现二维卷积层，主要关注以下几个构造函数参数：

in_channels (python:int) – Number of channels in the input imag
out_channels (python:int) – Number of channels produced by the convolution
kernel_size (python:int or tuple) – Size of the convolving kernel
stride (python:int or tuple, optional) – Stride of the convolution. Default: 1
padding (python:int or tuple, optional) – Zero-padding added to both sides of the input. Default: 0
bias (bool, optional) – If True, adds a learnable bias to the output. Default: True

forward函数的参数为一个四维张量，形状为 ( N , C i n , H i n , W i n ) (N, C_{in}, H_{in}, W_{in}) (N,Cin?,Hin?,Win?)，返回值也是一个四维张量，形状为 ( N , C o u t , H o u t , W o u t ) (N, C_{out}, H_{out}, W_{out}) (N,Cout?,Hout?,Wout?)，其中 N N N是批量大小， C , H , W C, H, W C,H,W分别表示通道数、高度、宽度。
代码讲解

X = torch.rand(4, 2, 3, 5) print(X.shape)conv2d = nn.Conv2d(in_channels=2, out_channels=3, kernel_size=(3, 5), stride=1, padding=(1, 2)) Y = conv2d(X) print('Y.shape: ', Y.shape) print('weight.shape: ', conv2d.weight.shape) print('bias.shape: ', conv2d.bias.shape)

torch.Size([4, 2, 3, 5]) Y.shape:torch.Size([4, 3, 3, 5]) weight.shape:torch.Size([3, 2, 3, 5]) bias.shape:torch.Size([3])

5.4 池化 5.4.1 二维池化层池化层主要用于缓解卷积层对位置的过度敏感性。同卷积层一样，池化层每次对输入数据的一个固定形状窗口（又称池化窗口）中的元素计算输出，池化层直接计算池化窗口内元素的最大值或者平均值，该运算也分别叫做最大池化或平均池化。图6展示了池化窗口形状为 2 × 2 2\times 2 2×2的最大池化。

文章图片

图6 池化窗口形状为 2 x 2 的最大池化
二维平均池化的工作原理与二维最大池化类似，但将最大运算符替换成平均运算符。池化窗口形状为 p × q p \times q p×q的池化层称为 p × q p \times q p×q池化层，其中的池化运算叫作 p × q p \times q p×q池化。
池化层也可以在输入的高和宽两侧填充并调整窗口的移动步幅来改变输出形状。池化层填充和步幅与卷积层填充和步幅的工作机制一样。
在处理多通道输入数据时，池化层对每个输入通道分别池化，但不会像卷积层那样将各通道的结果按通道相加。这意味着池化层的输出通道数与输入通道数相等。
5.4.2池化层的手动实现

def pool2d(X, pool_size, mode='max'): X = X.float() p_h, p_w = pool_size Y = torch.zeros(X.shape[0] - p_h + 1, X.shape[1] - p_w + 1) 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() elif mode == 'avg': Y[i, j] = X[i: i + p_h, j: j + p_w].mean() return Y

X = torch.tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]]) pool2d(X, (2, 2))

tensor([[4., 5.], [7., 8.]])

pool2d(X, (2, 2), 'avg')

tensor([[2., 3.], [5., 6.]])

5.4.3 池化层的简洁实现我们使用Pytorch中的nn.MaxPool2d实现最大池化层，关注以下构造函数参数：

kernel_size – the size of the window to take a max over
stride – the stride of the window. Default value is kernel_size
padding – implicit zero padding to be added on both sides

forward函数的参数为一个四维张量，形状为 ( N , C , H i n , W i n ) (N, C, H_{in}, W_{in}) (N,C,Hin?,Win?)，返回值也是一个四维张量，形状为 ( N , C , H o u t , W o u t ) (N, C, H_{out}, W_{out}) (N,C,Hout?,Wout?)，其中 N N N是批量大小， C , H , W C, H, W C,H,W分别表示通道数、高度、宽度。
代码讲解

X = torch.arange(32, dtype=torch.float32).view(1, 2, 4, 4) pool2d = nn.MaxPool2d(kernel_size=3, padding=1, stride=(2, 1)) Y = pool2d(X) print(X) print(Y)

tensor([[[[ 0.,1.,2.,3.], [ 4.,5.,6.,7.], [ 8.,9., 10., 11.], [12., 13., 14., 15.]],[[16., 17., 18., 19.], [20., 21., 22., 23.], [24., 25., 26., 27.], [28., 29., 30., 31.]]]]) tensor([[[[ 5.,6.,7.,7.], [13., 14., 15., 15.]],[[21., 22., 23., 23.], [29., 30., 31., 31.]]]])

平均池化层使用的是nn.AvgPool2d，使用方法与nn.MaxPool2d相同。
5.5 卷积神经网络（LeNet）使用全连接层的局限性：

图像在同一列邻近的像素在这个向量中可能相距较远。它们构成的模式可能难以被模型识别。
对于大尺寸的输入图像，使用全连接层容易导致模型过大。

使用卷积层的优势：

卷积层保留输入形状。
卷积层通过滑动窗口将同一卷积核与不同位置的输入重复计算，从而避免参数尺寸过大。

LeNet 模型 LeNet分为卷积层块和全连接层块两个部分。下面我们分别介绍这两个模块。

文章图片

卷积层块里的基本单位是卷积层后接平均池化层：卷积层用来识别图像里的空间模式，如线条和物体局部，之后的平均池化层则用来降低卷积层对位置的敏感性。
卷积层块由两个这样的基本单位重复堆叠构成。在卷积层块中，每个卷积层都使用 5 × 5 5 \times 5 5×5的窗口，并在输出上使用sigmoid激活函数。第一个卷积层输出通道数为6，第二个卷积层输出通道数则增加到16。
全连接层块含3个全连接层。它们的输出个数分别是120、84和10，其中10为输出的类别个数。
下面我们通过Sequential类来实现LeNet模型。

import d2lzh_pytorch as d2l import torch import torch.nn as nn import torch.optim as optim import time device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

#搭建net class Flatten(torch.nn.Module):#展平操作 def forward(self, x): return x.view(x.shape[0], -1)class Reshape(torch.nn.Module): #将图像大小重定型 def forward(self, x): return x.view(-1,1,28,28)#(B x C x H x W)net = torch.nn.Sequential(#Lelet Reshape(), nn.Conv2d(in_channels=1, out_channels=6, kernel_size=5, padding=2), #b*1*28*28=>b*6*28*28 nn.Sigmoid(), nn.AvgPool2d(kernel_size=2, stride=2),#b*6*28*28=>b*6*14*14 nn.Conv2d(in_channels=6, out_channels=16, kernel_size=5),#b*6*14*14=>b*16*10*10 nn.Sigmoid(), nn.AvgPool2d(kernel_size=2, stride=2),#b*16*10*10=> b*16*5*5 Flatten(),#b*16*5*5=> b*400 nn.Linear(in_features=16*5*5, out_features=120), nn.Sigmoid(), nn.Linear(120, 84), nn.Sigmoid(), nn.Linear(84, 10) )

接下来我们构造一个高和宽均为28的单通道数据样本，并逐层进行前向计算来查看每个层的输出形状。

#print X = torch.randn(size=(1,1,28,28), dtype = torch.float32) for layer in net: X = layer(X) print(layer.__class__.__name__,'output shape: \t',X.shape)

Reshape output shape:torch.Size([1, 1, 28, 28]) Conv2d output shape:torch.Size([1, 6, 28, 28]) Sigmoid output shape:torch.Size([1, 6, 28, 28]) AvgPool2d output shape:torch.Size([1, 6, 14, 14]) Conv2d output shape:torch.Size([1, 16, 10, 10]) Sigmoid output shape:torch.Size([1, 16, 10, 10]) AvgPool2d output shape:torch.Size([1, 16, 5, 5]) Flatten output shape:torch.Size([1, 400]) Linear output shape:torch.Size([1, 120]) Sigmoid output shape:torch.Size([1, 120]) Linear output shape:torch.Size([1, 84]) Sigmoid output shape:torch.Size([1, 84]) Linear output shape:torch.Size([1, 10])

可以看到，在卷积层块中输入的高和宽在逐层减小。卷积层由于使用高和宽均为5的卷积核，从而将高和宽分别减小4，而池化层则将高和宽减半，但通道数则从1增加到16。全连接层则逐层减少输出个数，直到变成图像的类别数10。

文章图片

5.5.2 获取数据和训练模型下面我们来实现LeNet模型。我们仍然使用Fashion-MNIST作为训练数据集。

# 数据 batch_size = 256 train_iter, test_iter = d2l.load_data_fashion_mnist( batch_size=batch_size, root='/home/kesci/input/FashionMNIST2065') print(len(train_iter))

235

为了使读者更加形象的看到数据，添加额外的部分来展示数据的图像

#数据展示 import matplotlib.pyplot as plt def show_fashion_mnist(images, labels): d2l.use_svg_display() # 这里的_表示我们忽略（不使用）的变量 _, figs = plt.subplots(1, len(images), figsize=(12, 12)) for f, img, lbl in zip(figs, images, labels): f.imshow(img.view((28, 28)).numpy()) f.set_title(lbl) f.axes.get_xaxis().set_visible(False) f.axes.get_yaxis().set_visible(False) plt.show()for Xdata,ylabel in train_iter: break X, y = [], [] for i in range(10): print(Xdata[i].shape,ylabel[i].numpy()) X.append(Xdata[i]) # 将第i个feature加到X中 y.append(ylabel[i].numpy()) # 将第i个label加到y中 show_fashion_mnist(X, y)

torch.Size([1, 28, 28]) 2 torch.Size([1, 28, 28]) 1 torch.Size([1, 28, 28]) 4 torch.Size([1, 28, 28]) 0 torch.Size([1, 28, 28]) 7 torch.Size([1, 28, 28]) 2 torch.Size([1, 28, 28]) 6 torch.Size([1, 28, 28]) 2 torch.Size([1, 28, 28]) 8 torch.Size([1, 28, 28]) 8

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZBjXYQor-1583212628413)(output_71_1.svg)]
我们实现evaluate_accuracy函数，该函数用于计算模型net在数据集data_iter上的准确率。

#计算准确率 ''' (1). net.train() 启用 BatchNormalization 和 Dropout，将BatchNormalization和Dropout置为True (2). net.eval() 不启用 BatchNormalization 和 Dropout，将BatchNormalization和Dropout置为False '''def evaluate_accuracy(data_iter, net,device=torch.device('cpu')): """Evaluate accuracy of a model on the given data set.""" acc_sum,n = torch.tensor([0],dtype=torch.float32,device=device),0 for X,y in data_iter: # If device is the GPU, copy the data to the GPU. X,y = X.to(device),y.to(device) net.eval() with torch.no_grad(): y = y.long() acc_sum += torch.sum((torch.argmax(net(X), dim=1) == y))#[[0.2 ,0.4 ,0.5 ,0.6 ,0.8] ,[ 0.1,0.2 ,0.4 ,0.3 ,0.1]] => [ 4 , 2 ] n += y.shape[0] return acc_sum.item()/n

我们定义函数train_ch5，用于训练模型。

#训练函数 def train_ch5(net, train_iter, test_iter,criterion, num_epochs, batch_size, device,lr=None): """Train and evaluate a model with CPU or GPU.""" print('training on', device) net.to(device) optimizer = optim.SGD(net.parameters(), lr=lr) for epoch in range(num_epochs): train_l_sum = torch.tensor([0.0],dtype=torch.float32,device=device) train_acc_sum = torch.tensor([0.0],dtype=torch.float32,device=device) n, start = 0, time.time() for X, y in train_iter: net.train()optimizer.zero_grad() X,y = X.to(device),y.to(device) y_hat = net(X) loss = criterion(y_hat, y) loss.backward() optimizer.step()with torch.no_grad(): y = y.long() train_l_sum += loss.float() train_acc_sum += (torch.sum((torch.argmax(y_hat, dim=1) == y))).float() n += y.shape[0] test_acc = evaluate_accuracy(test_iter, net,device) print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f, ' 'time %.1f sec' % (epoch + 1, train_l_sum/n, train_acc_sum/n, test_acc, time.time() - start))

# 训练 lr, num_epochs = 0.1, 5def init_weights(m): if type(m) == nn.Linear or type(m) == nn.Conv2d: torch.nn.init.xavier_uniform_(m.weight)net.apply(init_weights) net = net.to(device)criterion = nn.CrossEntropyLoss()#交叉熵描述了两个概率分布之间的距离，交叉熵越小说明两者之间越接近 train_ch5(net, train_iter, test_iter, criterion,num_epochs, batch_size,device, lr)

training on cpu epoch 1, loss 0.0090, train acc 0.102, test acc 0.100, time 45.1 sec epoch 2, loss 0.0090, train acc 0.102, test acc 0.100, time 44.3 sec epoch 3, loss 0.0090, train acc 0.104, test acc 0.100, time 42.9 sec epoch 4, loss 0.0090, train acc 0.105, test acc 0.100, time 41.9 sec epoch 5, loss 0.0090, train acc 0.127, test acc 0.180, time 45.2 sec

# 测试前十个 for testdata,testlabe in test_iter: testdata,testlabe = testdata.to(device),testlabe.to(device) break print(testdata.shape,testlabe.shape) net.eval() y_pre = net(testdata) print(torch.argmax(y_pre,dim=1)[:10]) print(testlabe[:10])

torch.Size([256, 1, 28, 28]) torch.Size([256]) tensor([9, 8, 8, 9, 8, 8, 9, 8, 9, 9]) tensor([9, 2, 1, 1, 6, 1, 4, 6, 5, 7])

小结：

卷积神经网络就是含卷积层的网络。
LeNet交替使用卷积层和最大池化层后接全连接层来进行图像分类。

深度卷积神经网络（AlexNet） LeNet: 在大的真实数据集上的表现并不尽如?意。
1.神经网络计算复杂。
2.还没有?量深?研究参数初始化和?凸优化算法等诸多领域。
机器学习的特征提取:手工定义的特征提取函数
神经网络的特征提取：通过学习得到数据的多级表征，并逐级表?越来越抽象的概念或模式。
神经网络发展的限制:数据、硬件
AlexNet
首次证明了学习到的特征可以超越??设计的特征，从而?举打破计算机视觉研究的前状。
特征：

8层变换，其中有5层卷积和2层全连接隐藏层，以及1个全连接输出层。
将sigmoid激活函数改成了更加简单的ReLU激活函数。
用Dropout来控制全连接层的模型复杂度。
引入数据增强，如翻转、裁剪和颜色变化，从而进一步扩大数据集来缓解过拟合。

文章图片

import time import torch from torch import nn, optim import torchvision import numpy as np import sys sys.path.append("/home/kesci/input/") import d2lzh_pytorch as d2l import os import torch.nn.functional as Fdevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')class AlexNet(nn.Module): def __init__(self): super(AlexNet, self).__init__() self.conv = nn.Sequential( nn.Conv2d(1, 96, 11, 4), # in_channels, out_channels, kernel_size, stride, padding nn.ReLU(), nn.MaxPool2d(3, 2), # kernel_size, stride # 减小卷积窗口，使用填充为2来使得输入与输出的高和宽一致，且增大输出通道数 nn.Conv2d(96, 256, 5, 1, 2), nn.ReLU(), nn.MaxPool2d(3, 2), # 连续3个卷积层，且使用更小的卷积窗口。除了最后的卷积层外，进一步增大了输出通道数。 # 前两个卷积层后不使用池化层来减小输入的高和宽 nn.Conv2d(256, 384, 3, 1, 1), nn.ReLU(), nn.Conv2d(384, 384, 3, 1, 1), nn.ReLU(), nn.Conv2d(384, 256, 3, 1, 1), nn.ReLU(), nn.MaxPool2d(3, 2) ) # 这里全连接层的输出个数比LeNet中的大数倍。使用丢弃层来缓解过拟合 self.fc = nn.Sequential( nn.Linear(256*5*5, 4096), nn.ReLU(), nn.Dropout(0.5), #由于使用CPU镜像，精简网络，若为GPU镜像可添加该层 #nn.Linear(4096, 4096), #nn.ReLU(), #nn.Dropout(0.5),# 输出层。由于这里使用Fashion-MNIST，所以用类别数为10，而非论文中的1000 nn.Linear(4096, 10), )def forward(self, img):feature = self.conv(img) output = self.fc(feature.view(img.shape[0], -1)) return output

net = AlexNet() print(net)

AlexNet( (conv): Sequential( (0): Conv2d(1, 96, kernel_size=(11, 11), stride=(4, 4)) (1): ReLU() (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False) (3): Conv2d(96, 256, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2)) (4): ReLU() (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False) (6): Conv2d(256, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (7): ReLU() (8): Conv2d(384, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (9): ReLU() (10): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1)) (11): ReLU() (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False) ) (fc): Sequential( (0): Linear(in_features=6400, out_features=4096, bias=True) (1): ReLU() (2): Dropout(p=0.5, inplace=False) (3): Linear(in_features=4096, out_features=10, bias=True) ) )

载入数据集

def load_data_fashion_mnist(batch_size, resize=None, root='/home/kesci/input/FashionMNIST2065'): """Download the fashion mnist dataset and then load into memory.""" trans = [] if resize: trans.append(torchvision.transforms.Resize(size=resize)) trans.append(torchvision.transforms.ToTensor())transform = torchvision.transforms.Compose(trans) mnist_train = torchvision.datasets.FashionMNIST(root=root, train=True, download=True, transform=transform) mnist_test = torchvision.datasets.FashionMNIST(root=root, train=False, download=True, transform=transform)train_iter = torch.utils.data.DataLoader(mnist_train, batch_size=batch_size, shuffle=True, num_workers=2) test_iter = torch.utils.data.DataLoader(mnist_test, batch_size=batch_size, shuffle=False, num_workers=2)return train_iter, test_iter#batchsize=128 batch_size = 16 # 如出现“out of memory”的报错信息，可减小batch_size或resize train_iter, test_iter = load_data_fashion_mnist(batch_size,224) for X, Y in train_iter: print('X =', X.shape, '\nY =', Y.type(torch.int32)) break

X = torch.Size([16, 1, 224, 224]) Y = tensor([4, 8, 5, 0, 6, 5, 0, 4, 4, 3, 8, 5, 6, 5, 3, 0], dtype=torch.int32)

训练

lr, num_epochs = 0.001, 3 optimizer = torch.optim.Adam(net.parameters(), lr=lr) d2l.train_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)

使用重复元素的网络（VGG） VGG：通过重复使?简单的基础块来构建深度模型。
Block:数个相同的填充为1、窗口形状为 3 × 3 3\times 3 3×3的卷积层,接上一个步幅为2、窗口形状为 2 × 2 2\times 2 2×2的最大池化层。
卷积层保持输入的高和宽不变，而池化层则对其减半。

文章图片

VGG的简单实现

def vgg_block(num_convs, in_channels, out_channels): #卷积层个数，输入通道数，输出通道数 blk = [] for i in range(num_convs): if i == 0: blk.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1)) else: blk.append(nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1)) blk.append(nn.ReLU()) blk.append(nn.MaxPool2d(kernel_size=2, stride=2)) # 这里会使宽高减半 return nn.Sequential(*blk)

conv_arch = ((1, 1, 64), (1, 64, 128), (2, 128, 256), (2, 256, 512), (2, 512, 512)) # 经过5个vgg_block, 宽高会减半5次, 变成 224/32 = 7 fc_features = 512 * 7 * 7 # c * w * h fc_hidden_units = 4096 # 任意

def vgg(conv_arch, fc_features, fc_hidden_units=4096): net = nn.Sequential() # 卷积层部分 for i, (num_convs, in_channels, out_channels) in enumerate(conv_arch): # 每经过一个vgg_block都会使宽高减半 net.add_module("vgg_block_" + str(i+1), vgg_block(num_convs, in_channels, out_channels)) # 全连接层部分 net.add_module("fc", nn.Sequential(d2l.FlattenLayer(), nn.Linear(fc_features, fc_hidden_units), nn.ReLU(), nn.Dropout(0.5), nn.Linear(fc_hidden_units, fc_hidden_units), nn.ReLU(), nn.Dropout(0.5), nn.Linear(fc_hidden_units, 10) )) return net

net = vgg(conv_arch, fc_features, fc_hidden_units) X = torch.rand(1, 1, 224, 224)for name, blk in net.named_children(): X = blk(X) print(name, 'output shape: ', X.shape)

ratio = 8 small_conv_arch = [(1, 1, 64//ratio), (1, 64//ratio, 128//ratio), (2, 128//ratio, 256//ratio), (2, 256//ratio, 512//ratio), (2, 512//ratio, 512//ratio)] net = vgg(small_conv_arch, fc_features // ratio, fc_hidden_units // ratio) print(net)

?络中的?络（NiN） LeNet、AlexNet和VGG：先以由卷积层构成的模块充分抽取空间特征，再以由全连接层构成的模块来输出分类结果。
NiN：串联多个由卷积层和“全连接”层构成的小?络来构建?个深层?络。
?了输出通道数等于标签类别数的NiN块，然后使?全局平均池化层对每个通道中所有元素求平均并直接?于分类。

文章图片

1×1卷积核作用
1.放缩通道数：通过控制卷积核的数量达到通道数的放缩。
2.增加非线性。1×1卷积核的卷积过程相当于全连接层的计算过程，并且还加入了非线性激活函数，从而可以增加网络的非线性。
3.计算参数少

def nin_block(in_channels, out_channels, kernel_size, stride, padding): blk = nn.Sequential(nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding), nn.ReLU(), nn.Conv2d(out_channels, out_channels, kernel_size=1), nn.ReLU(), nn.Conv2d(out_channels, out_channels, kernel_size=1), nn.ReLU()) return blk

# 已保存在d2lzh_pytorch class GlobalAvgPool2d(nn.Module): # 全局平均池化层可通过将池化窗口形状设置成输入的高和宽实现 def __init__(self): super(GlobalAvgPool2d, self).__init__() def forward(self, x): return F.avg_pool2d(x, kernel_size=x.size()[2:])net = nn.Sequential( nin_block(1, 96, kernel_size=11, stride=4, padding=0), nn.MaxPool2d(kernel_size=3, stride=2), nin_block(96, 256, kernel_size=5, stride=1, padding=2), nn.MaxPool2d(kernel_size=3, stride=2), nin_block(256, 384, kernel_size=3, stride=1, padding=1), nn.MaxPool2d(kernel_size=3, stride=2), nn.Dropout(0.5), # 标签类别数是10 nin_block(384, 10, kernel_size=3, stride=1, padding=1), GlobalAvgPool2d(), # 将四维的输出转成二维的输出，其形状为(批量大小, 10) d2l.FlattenLayer())

X = torch.rand(1, 1, 224, 224) for name, blk in net.named_children(): X = blk(X) print(name, 'output shape: ', X.shape)

batch_size = 128 # 如出现“out of memory”的报错信息，可减小batch_size或resize #train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)lr, num_epochs = 0.002, 5 optimizer = torch.optim.Adam(net.parameters(), lr=lr) d2l.train_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)

小结 NiN重复使?由卷积层和代替全连接层的1×1卷积层构成的NiN块来构建深层?络。
NiN去除了容易造成过拟合的全连接输出层，而是将其替换成输出通道数等于标签类别数的NiN块和全局平均池化层。
NiN的以上设计思想影响了后??系列卷积神经?络的设计。
GoogLeNet

由Inception基础块组成。
Inception块相当于?个有4条线路的??络。它通过不同窗口形状的卷积层和最?池化层来并?抽取信息，并使?1×1卷积层减少通道数从而降低模型复杂度。
可以?定义的超参数是每个层的输出通道数，我们以此来控制模型复杂度。

文章图片

class Inception(nn.Module): # c1 - c4为每条线路里的层的输出通道数 def __init__(self, in_c, c1, c2, c3, c4): super(Inception, self).__init__() # 线路1，单1 x 1卷积层 self.p1_1 = nn.Conv2d(in_c, c1, kernel_size=1) # 线路2，1 x 1卷积层后接3 x 3卷积层 self.p2_1 = nn.Conv2d(in_c, c2[0], kernel_size=1) self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1) # 线路3，1 x 1卷积层后接5 x 5卷积层 self.p3_1 = nn.Conv2d(in_c, c3[0], kernel_size=1) self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2) # 线路4，3 x 3最大池化层后接1 x 1卷积层 self.p4_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1) self.p4_2 = nn.Conv2d(in_c, c4, kernel_size=1)def forward(self, x): p1 = F.relu(self.p1_1(x)) p2 = F.relu(self.p2_2(F.relu(self.p2_1(x)))) p3 = F.relu(self.p3_2(F.relu(self.p3_1(x)))) p4 = F.relu(self.p4_2(self.p4_1(x))) return torch.cat((p1, p2, p3, p4), dim=1)# 在通道维上连结输出

GoogLeNet模型
完整模型结构

文章图片

b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2, padding=1))b2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=1), nn.Conv2d(64, 192, kernel_size=3, padding=1), nn.MaxPool2d(kernel_size=3, stride=2, padding=1))b3 = nn.Sequential(Inception(192, 64, (96, 128), (16, 32), 32), Inception(256, 128, (128, 192), (32, 96), 64), nn.MaxPool2d(kernel_size=3, stride=2, padding=1))b4 = nn.Sequential(Inception(480, 192, (96, 208), (16, 48), 64), Inception(512, 160, (112, 224), (24, 64), 64), Inception(512, 128, (128, 256), (24, 64), 64), Inception(512, 112, (144, 288), (32, 64), 64), Inception(528, 256, (160, 320), (32, 128), 128), nn.MaxPool2d(kernel_size=3, stride=2, padding=1))b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128), Inception(832, 384, (192, 384), (48, 128), 128), d2l.GlobalAvgPool2d())net = nn.Sequential(b1, b2, b3, b4, b5, d2l.FlattenLayer(), nn.Linear(1024, 10))net = nn.Sequential(b1, b2, b3, b4, b5, d2l.FlattenLayer(), nn.Linear(1024, 10))X = torch.rand(1, 1, 96, 96)for blk in net.children(): X = blk(X) print('output shape: ', X.shape)#batchsize=128 batch_size = 16 # 如出现“out of memory”的报错信息，可减小batch_size或resize #train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)lr, num_epochs = 0.001, 5 optimizer = torch.optim.Adam(net.parameters(), lr=lr) d2l.train_ch5(net, train_iter, test_iter, batch_size, optimizer, device, num_epochs)