现代卷积神经网络

深度卷积神经网络（AlexNet）

经典机器学习的流水线：

①获取一个有趣的数据集；

②根据光学、几何学，手动对特征数据集进行预处理；

③通过标准的特征提取算法，如SIFT（尺度不变特征变换）和SURF（加速鲁棒特征）或其他手动调整的流水线来输入数据；

④将提取的特征送入最喜欢的分类器中

学习表征

特征应该由多个共同学习的神经网络层组成，每个层都有可学习的参数。

在机器视觉中，底层可能检测边缘、颜色和纹理。在网络的底层，模型学习到了一些类似于传统滤波器的特征提取器

 AlexNet比较小的LeNet要深得多

AlexNet由8层组成：5个卷积层、2个全连接隐藏层和1个全连接输出层AlexNet使用ReLU而不是sigmoid作为其激活函数

LeNet简介

模型设计 在AlexNet的第一层，卷积窗口的形状是11*11，由于ImageNet中大多数图像的高和宽比MNIST图像的大10倍以上，因此需要一个更大的卷积窗口来捕获目标。第二层中的卷积窗口形状被缩减为5*5，然后是3*3.在第1层、第二层、第五层卷积层之后，加入窗口形状为3*3、步幅为2的最大池化层。AlexNet的卷积通道数是LeNet的10倍 容量控制和预处理

暂退法：在前向传播过程中，计算每一内部层的同时注入噪声。

AlexNet通过暂退法控制全连接层的模型复杂度，而LeNet只使用了权重衰减

import torch from torch import nn from d2l import torch as d2l net = nn.Sequential( nn.Conv2d(1, 96, kernel_size=11, stride=4, padding=1), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2), # 减小卷积窗口，使用填充为2来使得输入和输出的高和宽一致 nn.Conv2d(96, 256, kernel_size=5, padding=2), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2), # 使用3个连续的卷积层和较小的卷积窗口；除了最后的卷积层，输出通道数进一步增加 nn.Conv2d(256, 384, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(384, 384, kernel_size=3, padding=1), nn.ReLU(), nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2), nn.Flatten(), # 全连接层的输出数量是LeNet中的好几倍,使用暂退层来缓解过拟合 nn.Linear(6400, 4096), nn.ReLU(), nn.Dropout(p=0.5), nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(p=0.5), nn.Linear(4096, 10) )

接下来，我们构造高度和宽度都为224的单通道数据，来观察每一层输出的形状

x = torch.randn(1, 1, 224, 224) print(x) for layer in net: x = layer(x) print(layer.__class__.__name__, 'output shape:\t', x.shape) 读取数据集  batch_size = 128 # resize=224是因为Fashion-MNIST图像的分辨率（28*28像素）低于ImageNet图像（224*224） train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224) 训练AlexNet

相比于LeNet，我们需要使用更低的学习率训练，因为网络更深更广、图像分辨率更高，训练卷积神经网络的成本更高

使用块的网络（VGG）

经典卷积神经网络的基本组成是：

(1)带填充以保持分辨率的卷积层

(2)非线性激活函数

(3)池化层

一个VGG块：由一系列卷积层组成，后面再加上用于空间降采样的最大池化层。

# num_convs：卷积层的数量 # in_channels：输入通道的数量、out_channels：输出通道的数量 def vgg_block(num_convs, in_channels, out_channels): layers = [] for _ in range(num_convs): layers.append(nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1)) layers.append(nn.ReLU()) in_channels = out_channels # 向 layers 列表添加一个最大池化层，其池化核大小为 2x2，步长为 2。这将使空间尺寸减半 layers.append(nn.MaxPool2d(kernel_size=2, stride=2)) return nn.Sequential(*layers)  VGG网络

第一部分由卷积层和池化层组成，第二部分由全连接层组成

原始VGG网络有5个卷积块，其中前2个块各包含1个卷积层，后3个块各包含2个卷积层第一个块有64个输出通道，后续每个块将输出通道数翻倍，直到输出通道数为512由于该网络使用8个卷积层和3个全连接层，因此称为VGG-11 # conv_arch指定了每个VGG块中卷积层个数和输出通道数 conv_arch = ((1, 64), (1, 128), (2, 256), (2, 512), (2, 512)) def vgg(conv_arch): conv_blks = [] in_channels = 1 # 卷积层部分 for (num_convs, out_channels) in conv_arch: conv_blks.append(vgg_block(num_convs, in_channels, out_channels)) in_channels = out_channels return nn.Sequential( *conv_blks, nn.Flatten(), # nn.Dropout(0.5) 时，它会在训练过程中随机将输入张量中的一半（50%）的元素设置为 0 # dropout 只在训练过程中使用。在评估或测试模型时，通常不使用 dropout，因此所有神经元都会被激活 # 全连接层部分 nn.Linear(out_channels * 7 * 7, 4096), nn.ReLU(), nn.Dropout(0.5), nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(0.5), nn.Linear(4096, 10) ) net = vgg(conv_arch)

接下来，我们构建一个高度和宽度都为224的单通道数据样本，以观察每个层输出的形状

x = torch.randn(size=(1, 1, 224, 224)) for blk in net: x = blk(x) print(blk.__class__.__name__,'output shape:\t', x.shape)

我们要将每个块的高度和宽度减半，最后高度和宽度都为7。最后，展平表示，进入全连接层处理

训练模型 # 由于VGG-11比AlexNet的计算量更大， # 因此构建一个通道数较少的网络，足够用于训练Fashion-MNIST数据集 ratio = 4 # 对于conv_arch中的每个元组对pair，它都会创建一个新的元组对， # 其中第一个元素保持不变（即卷积层个数），而第二个元素则是原始通道数除以ratio（即4）。 # //是Python中的整数除法，所以结果将是一个整数。 # 这行代码的目的是减少每个卷积层的输出通道数，从而得到一个“较小”的卷积架构 small_conv_arch = [(pair[0], pair[1] // ratio) for pair in conv_arch] net = vgg(small_conv_arch) 网络中的网络（NiN）

在每个像素的通道上分别使用多层感知机

NiN块

卷积层的输入和输出由四维张量组成，张量的每个轴分别对应样本、通道、高度和宽度。另外，全连接层的输入和输出通常是分别对应于样本和特征的二维张量。

NiN的想法是在每个像素位置（针对每个高度和宽度）应用一个全连接层。如果将权重连接到每个空间位置，我们可以将其视为1*1卷积层；将空间维度中的每个像素视为单个样本，将通道维度视为不同特征

 NiN块以一个普通卷积层开始，后面是两个1*1的卷积层。这两个1*1卷积层充当带有ReLU激活函数的逐像素全连接层。第一层的卷积窗口形状通常由用户设置，随后的卷积窗口形状固定为1*1

import torch from torch import nn from d2l import torch as d2l def nin_block(in_channels, out_channels, kernel_size, strides, padding): return nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size, strides, 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() ) NiN模型

NiN使用窗口形状为11*11，5*5和3*3的卷积层，输出通道数与AlexNet中的相同。每个NiN块后有一个最大池化层，池化窗口形状为3*3，步幅为2

NiN和AlexNet之间的一个显著区别是NiN模型完全取消了全连接层，而使用一个NiN块，其输出通道数等于标签类别数最后放一个全局平均池化层，生成一个对数几率；NiN显著减少了模型所需参数的数量，但是会增加训练模型的时间 net = nn.Sequential( nin_block(1, 96, kernel_size=11, strides=4, padding=0), nn.MaxPool2d(3, stride=2), nin_block(96, 256, kernel_size=5, strides=1, padding=2), nn.MaxPool2d(3, stride=2), nin_block(256, 384, kernel_size=3, strides=1, padding=1), nn.MaxPool2d(3, stride=2), nn.Dropout(0.5), # 标签类别数是10 nin_block(384, 10, kernel_size=3, strides=1, padding=1), # nn.AdaptiveAvgPool2d((1, 1)) 是一个自适应平均池化层， # 它会根据输入张量的大小自适应地调整池化窗口的大小，以产生一个特定大小（在此例中是 1x1）的输出。 # 这通常用于在卷积神经网络的末尾，将不同尺寸的特征图转换为固定尺寸的表示，以便于后续的全连接层处理 nn.AdaptiveAvgPool2d((1, 1)), # 将四维的输出转为二维的输出，其形状为（批量大小， 10） nn.Flatten() ) 模型块的输出 # 创建一个数据样本来查看每个块的输出形状 x = torch.rand(size=(1, 1, 224, 224)) for layer in net: x = layer(x) print(layer.__class__.__name__,'output shape:\t', x.shape) 含并行连接的网络（GoogLeNet） Inception块 

在GoogLeNet中，基本的卷积块称为Inception块。

4条并行路径组成。前3条路径使用窗口大小为1*1，3*3和5*5的卷积层；从不同空间大小中提取信息中间的2条路径在输入上执行1*1卷积，以减少通道数，从而降低模型的复杂度第4条路径使用3*3最大池化层，然后使用1*1卷积层来改变通道数这4条路径都使用合适的填充以使输入与输出的高度和宽度一致，最后将多条路径的输出在通道维度上合并Inception块中，通常调整的超参数是每层输出通道数

import torch from torch import nn from torch.nn import functional as F from d2l import torch as d2l class Inception(nn.Module): # c1--c4是每条路径的输出通道数 def __init__(self, in_channels, c1, c2, c3, c4, **kwargs): super(Inception, self).__init__(**kwargs) # 路径1，单1*1卷积层 self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1) # 路径2， 1*1卷积层后接3*3卷积层 self.p2_1 = nn.Conv2d(in_channels, c2[0], kernel_size=1) self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1) # 路径3， 1*1卷积层后接5*5卷积层 self.p3_1 = nn.Conv2d(in_channels, c3[0], kernel_size=1) self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2) # 路径4， 3*3卷积层后接1*1卷积层 self.p4_1 = nn.MaxPool2d( kernel_size=1, stride=1, padding=1) self.p4_2 = nn.Conv2d(in_channels, 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模型

GoogleNet模型一共使用9个Inception块和全局平均池化层的堆叠来生成其估计值

Inception块之间的最大池化层可降低维度

全局平均池化层避免了在最后使用全连接层

GoogleNet模块

第一个模块：输出64个通道，7*7卷积层

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

第二个模块：使用两个卷积层：第一个卷积层是64个通道、1*1卷积层;  第二个卷积层使用将通道数增加为3的3*3卷积层

b2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=1), nn.ReLU(), nn.Conv2d(64, 192, kernel_size=3, padding=1), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2, padding=1) )

第三个模块：串联两个完整的Inception块。第一个Inception块的输出通道数为64+128+32+32=256；

4条路径的输出通道数之比为64：128：32：32 = 2：4：1：1

第二条和第三条路径首先将输入通道数分别减少到96/192=1/2,和16/192=1/12，然后连接第二个卷积层。第二个Inception块的输出通道数增加到128+192+96+64=480，4条路径的输出通道数之比为128：192：96：64 = 4：6：3：2。第二条路径和第三条路径先将输入通道数分别减少到128/256=1/2和32/256=1/8

# 输入通道数: 192 # 第一条路径的输出通道数: 164 # 第二条路径的输出通道数（两个数字表示两个卷积层的输出通道数）: (96, 128) # 第三条路径的输出通道数（两个数字表示两个卷积层的输出通道数）: (16, 32) # 第四条路径的输出通道数: 32 # 256 = 64 + 128 + 32 + 32 b3 = nn.Sequential(Inception(192, 64, (96, 128), (16, 32), 32), Inception(256, 128, (128, 92), (32, 96), 64), nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

 第四个模块

# 第四个模块更加复杂，它串联了5个Inception块，其输出通道数分别是192+208+48+64=512、160+224+64+64=512、128+256+64+64=512 # 112+288+64+64=528和256+320+128+128=832 # 这些路径通道数的分配和第三个模块中的类似，首先是输出通道数最多的含3*3卷积层的第二条路径，其次是仅含1*1卷积层的第一条路经， # 最后是含5*5卷积层的第三条路经和含3*3最大池化层的第四条路径，其中第二条和第三条路径都会先按比例减少通道数 b4 = nn.Sequential(Inception(480, 192, (96, 208), (16, 48), 64), Inception(512, 160, (112, 224), (24, 96), 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))

 第五个模块

# 第五个模块包含输出通道数为256+320+128+128=832、384+384+128+128=1024的两个Inception块 # 第五个模块的后面紧跟输出层，该模块同NiN一样使用全局平均池化层，将每个通道的高度和宽度变为1 # 最后我们将输出变为二维数组，再连接一个输出个数为标签类别数的全连接层 b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128), Inception(832, 384, (192, 384), (48, 128), 128), # 无论输入特征图的大小如何，输出都将是一个 1x1 的张量 nn.AdaptiveAvgPool2d((1, 1)), nn.Flatten()) net = nn.Sequential(b1, b2, b3, b4, b5, nn.Linear(1024, 10))

 如果我们要在Fashion-MNIST数据集上进行训练，需要将输入的高度和宽度从224降到96.

GoogLeNet模型的计算比较复杂，不如VGG一样便于修改通道数

x = torch.rand(size=(1, 1, 96, 96)) for layer in net: x = layer(x) print(layer.__class__.__name__,'output shape:\t',x.shape) 批量规范化

为什么需要批量规范化层？

(1)数据预处理的方式通常会对最终结果产生巨大影响

(2)对于典型的多层感知机或卷积神经网络，当训练时，中间层中的变量可能具有更广的变化范围

(3)更深层的网络更复杂，容易过拟合

训练深层网络

从形式上来说，用表示一个来自小批量B的输入，批量规范化BN根据以下表达式转换x：

是小批量B的样本均值，是小批量B的样本标准差。应用标准化后，生成的小批量的均值为0，单位方差为1. 和的形状与 x 相同。

批量规范化层

批量规范化层和其他层之间的一个关键区别是，由于批量规范化在完整的小批量上执行，因此我们不能像之前在引入其他层时那样忽略批量大小。

全连接层

假设全连接层的输入是x，权重参数和偏置参数分别是W和b，激活函数为，批量规范化的运算符为BN。

从零开始实现批量规范化层 def batch_norm(x, gamma, beta, moving_mean, moving_var, eps, momentum): # 通过is_grad_enabled方法来判断当前模式是训练模式还是预测模式 if not torch.is_grad_enabled(): # 如果是在预测模式下，直接使用传入的移动平均所得的均值和方差 # 移动平均均值/方差：在训练过程中计算并保存的； # eps指的是一个很小的常数，用于防止分母为0或防止数值不稳定 # torch.sqrt计算的是每个元素的平方根 x_hat = (x - moving_mean) / torch.sqrt(moving_var + eps) # 数据大致会被归一化到均值为0、方差为1的分布 else: # 确保输入张量的维度是2或4 assert len(x.shape) in (2, 4) # 输入的张量是2维的 if len(x.shape) == 2: # 在全连接层的情况，计算每个特征维上的均值和方差 # dim=0意味着沿着批次维度计算均值和方差 mean = x.mean(dim=0) var = ((x - mean) ** 2).mean(dim=0) else: # 使用二维卷积层的情况，计算通道维上(axis=1)的均值和方差 # 我们需要保持x的形状以便后面可以做广播运算 # dim=(0, 2, 3)意味着沿着批次、高度和宽度维度计算均值和方差。 # keepdim=True确保输出的均值和方差张量具有与输入相同的维度 mean = x.mean(dim=(0, 2, 3), keepdim=True) var = ((x - mean) ** 2).mean(dim=(0, 2, 3), keepdim=True) # 训练模式下，用当前的均值和方差做标准化 x_hat = (x - mean) / torch.sqrt(var + eps) # 更新移动平均的均值和方差 moving_mean = momentum * moving_mean + (1.0 - momentum) * mean moving_var = momentum * moving_var + (1.0 - momentum) * var y = gamma * x_hat + beta #缩放和移位 return y, moving_mean.data, moving_var.data

我们可以创建一个正确的BatchNorm()层，这个层将保持伸拉参数gamma和偏移参数beta，这两个参数将在训练过程中更新。此外，我们的层将保持均值和方差的移动平均值

class BatchNorm(nn.Module): # num_features:全连接层的输出数量或卷积层的输出通道数 # num_dims:2表示完全连接层，4表示卷积层 def __init__(self, num_features, num_dims): super().__init__() if num_dims == 2: shape = (1, num_features) else: shape = (1, num_features, 1, 1) # 参与求梯度和迭代的拉伸参数和偏移参数，其分别初始化为1和0 self.gamma = nn.Parameter(torch.ones(shape)) self.beta = nn.Parameter(torch.zeros(shape)) # 非模型参数的变量初始化为0和1 self.moving_mean = torch.zeros(shape) self.moving_var = torch.ones(shape) def forward(self, x): # 如果x不在内存上,将moving_mean和moving_var复制到x所在的显存上 if self.moving_mean.device != x.device: self.moving_mean = self.moving_mean.to(x.device) self.moving_var = self.moving_var.to(x.device) # 保存更新过的moving_mean和moving_var y, self.moving_mean, self.moving_var = batch_norm( x, self.gamma, self.beta, self.moving_mean, self.moving_var, eps=1e-5, momentum=0.9 ) return y 使用批量规范化层的LeNet

批量规范化是应用在卷积层或全连接层之后、相应的激活函数之前

net = nn.Sequential( nn.Conv2d(1, 6, kernel_size=5), BatchNorm(6, num_dims=4), nn.Sigmoid(), nn.AvgPool2d(kernel_size=2, stride=2), nn.Conv2d(6, 16, kernel_size=5), BatchNorm(16, num_dims=4), nn.Sigmoid(), nn.AvgPool2d(kernel_size=2, stride=2), nn.Flatten(), nn.Linear(16*4*4, 120), BatchNorm(120, num_dims=2), nn.Sigmoid(), nn.Linear(120, 84), BatchNorm(84, num_dims=2), nn.Sigmoid(), nn.Linear(84, 10) ) 残差网络

只有当复杂的函数类包含较小的函数类时，我们才能确保提高它们的性能

对于深度神经网络，如果我们能将新添加的层训练为恒等函数f(x)=x，新模型和原模型同样有效

残差网络(ResNet)的核心思想是：每个附加层都应该更容易地包含原始函数作为其元素之一

残差块

残差块里首先有2个有相同输出通道数的3*3卷积层，每个卷积层后接一个批量规范化层和ReLU激活函数，之后，我们通过跨层数据通道，跳过这两个卷积运算，将输入直接加在最后的ReLU激活函数前；这样的设计要求2个卷积层的输出与输入形状相同，从而使它们可以相加。

残差网络是由多个残差块组成的，每个残差块都包含多个卷积层、批量归一化层和激活函数等

在残差块中，输入数据会经过多个卷积层的处理，然后再与原始输入数据进行相加，得到最终的输出数据

残差块的代码实现 import torch from torch import nn from torch.nn import functional as F from d2l import torch as d2l # 该类是PyTorch中nn.Module的子类，用于实现残差块（Residual Block） class Residual(nn.Module): #@save # 输入张量的通道数、卷积层输出的通道数、是否使用1*1卷积来改变输入张量的通道数 # strides是卷积的步长，默认为1 def __init__(self, input_channels, num_channels, use_1x1conv=False, strides=1): # 调用父类nn.Module的初始化函数 super().__init__() self.conv1 = nn.Conv2d(input_channels, num_channels, kernel_size=3, padding=1, stride=strides) # 默认步长为1 self.conv2 = nn.Conv2d(num_channels, num_channels, kernel_size=3, padding=1) if use_1x1conv: self.conv3 = nn.Conv2d(input_channels, num_channels, kernel_size=1, stride=strides) else: self.conv3 = None # 定义两个批量归一化层，它们分别用于conv1和conv2的输出 self.bn1 = nn.BatchNorm2d(num_channels) self.bn2 = nn.BatchNorm2d(num_channels) def forward(self, x): # 将输入x通过conv1卷积层，然后通过bn1批量归一化层，最后应用ReLU激活函数 y = F.relu(self.bn1(self.conv1(x))) y = self.bn2(self.conv2(y)) if self.conv3: x = self.conv3(x) # 执行残差连接 y += x return F.relu(y) # 查看输入和输出形状一致的情况 blk = Residual(3, 3) x = torch.rand(4, 3, 6, 6) y = blk(x) y.shape # 在增加输出通道的同时，减半输出的高度和宽度 blk = Residual(3, 6, use_1x1conv=True, strides=2) blk(x).shape ResNet模型 # ResNet的前两层和之前介绍的GoogleNet中的一样：在输出通道数为64、步幅为2的7*7卷积层后， # 接步幅为2的3*3的最大池化层 # 不同之处在于：ResNet的每个卷积层后增加了批量规范化层 b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3), nn.BatchNorm2d(64), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2, padding=1)) ResNet使用4个由残差块组成的模块，每个模块使用若干输出通道数相同的残差块第一个模块的通道数同输入通道数一致；但是之前使用了步幅为2的最大池化层，因此无需减少高度和宽度之后的每个模块在第一个残差块里将上一个模块的通道数翻倍，并将高度和宽度减半 # num_residuals指的是残差单元的数量 def resnet_block(input_channels, num_channels, num_residuals, first_block=False): # blk是一个列表，用于存储构成该块的残差单元 blk = [] for i in range(num_residuals): if i == 0 and not first_block: # 下采样，减少特征图的大小 blk.append(Residual(input_channels, num_channels, use_1x1conv=True, strides=2)) else: # 创建一个标准的残差单元 blk.append(Residual(num_channels, num_channels)) return blk # 接着在ResNet加入所有残差块，每个模块使用两个残差块 b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True)) b3 = nn.Sequential(*resnet_block(64, 128, 2)) b4 = nn.Sequential(*resnet_block(128, 256, 2)) b5 = nn.Sequential(*resnet_block(256, 512, 2)) # 最后，与GoogleNet一样，在ResNet中加入全局平均池化层以及全连接层输出 net = nn.Sequential(b1, b2, b3, b4, b5, # 适应性池化,经过池化层之后变为指定的大小 nn.AdaptiveAvgPool2d((1, 1)), nn.Flatten(), nn.Linear(512, 10)) # 在之前的架构中，分辨率降低、通道数增加、直到平均池化层聚合所有特征 x = torch.rand(size=(1, 1, 224, 224)) for layer in net: x = layer(x) print(layer.__class__.__name__,'output shape:\t', x.shape) 稠密连接网络（DenseNet）

ResNet将函数展开为f(x) = x + g(x)

ResNet将f分解为两部分：一个简单的线性项和一个复杂的非线性项

DenseNet和ResNet的关键区别在于：DenseNet输出是连接，而不是简单相加

稠密网络主要由两部分组成：稠密块和过渡层。前者定义如何连接输入和输出，后者则控制通道数

 稠密连接网络使用了残差连接网络的“批量规范化层、激活层和卷积层”架构

import torch from torch import nn from d2l import torch as d2l def conv_block(input_channels, num_channels): return nn.Sequential( nn.BatchNorm2d(input_channels), nn.ReLU(), nn.Conv2d(input_channels, num_channels, kernel_size=3, padding=1) )

一个稠密块由多个卷积块组成，每个卷积块使用相同数量的输出通道

在前向传播中,我们将每个卷积块的输入和输出在通道维度上连接

class DenseBlock(nn.Module): def __init__(self, num_convs, input_channels, num_channels): super(DenseBlock, self).__init__() layer = [] for i in range(num_convs): layer.append(conv_block( num_channels * i + input_channels, num_channels )) self.net = nn.Sequential(*layer) def forward(self, x): for blk in self.net: y = blk(x) # 连接通道维度上每个卷积的输入和输出 x = torch.cat((x, y), dim=1) return x

定义一个有2个输出通道数为10的DenseBlock,使用通道数为3的输入时,我们会得到通道数为3+2*10=23的输出

# 卷积块的通道数控制了输出通道数相对于输入通道数的增长程度;也被称为增长率 blk = DenseBlock(2, 3, 10) x = torch.randn(4, 3, 8, 8) y = blk(x) y.shape 过渡层

由于每个稠密快都会带来通道数的增加,因此使用过多会过于复杂化模型.而过渡层可以用来控制模型复杂度

通过1*1卷积层来减小通道数,并使用步幅为2的平均池化层减半高度和宽度

def transition_block(input_channels, num_channels): return nn.Sequential( nn.BatchNorm2d(input_channels), nn.ReLU(), nn.Conv2d(input_channels, num_channels, kernel_size=1), nn.AvgPool2d(kernel_size=2, stride=2) ) # 对稠密块的输出使用通道数为10的过渡层.此时输出的通道数减为10,高度和宽度均减半 blk = transition_block(23, 10) blk(y).shape torch.Size([4, 10, 4, 4]) DenseNet模型 # 首先,DenseNet使用同ResNet一样的单卷积层和最大池化层 b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3), nn.BatchNorm2d(64), nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2, padding=1)) num_channels, growth_rate = 64, 32 # growth_rate: DenseNet中每一层增加的新通道数 num_convs_in_dense_blocks = [4, 4, 4, 4] # num_convs_in_dense_blocks: 一个列表，表示每个稠密块中卷积层的数量 blks = [] # 初始化一个空列表blks，用于存储DenseNet中的各个块 for i, num_convs in enumerate(num_convs_in_dense_blocks): # num_convs表示的是卷积层个数 blks.append(DenseBlock(num_convs, num_channels, growth_rate)) # 上一个稠密块的输出通道数 num_channels += num_convs * growth_rate # 在稠密块之间添加一个过渡层,使通道数减半 if i != len(num_convs_in_dense_blocks) - 1: # 当前通道数（num_channels）和下一阶段的通道数（num_channels // 2，即当前通道数的一半） blks.append(transition_block(num_channels, num_channels // 2)) num_channels = num_channels // 2 # 与ResNet类似,最后连接全局池化层和全连接层来输出结果 net = nn.Sequential( b1, *blks, nn.BatchNorm2d(num_channels), nn.ReLU(), nn.AdaptiveAvgPool2d((1, 1)), nn.Flatten(), nn.Linear(num_channels, 10) )