当前位置：首页 > article >正文

现代卷积神经网络

article 2025/2/21 6:56:18

现代卷积神经网络

现代卷积神经网络是在卷积神经网络的基础上发展而来的，自从Image net竞赛举办以来，许多神经网络成为了该竞赛的优胜方，是计算机视觉中监督学习进展的风向标。

ALEXNET卷积神经网络

AlexNet是深度学习中的一个里程碑，它是第一个在大型图像数据集ImageNet上取得显著成绩的深度卷积神经网络（CNN）。AlexNet由Alex Krizhevsky、Ilya Sutskever以及Geoffrey Hinton在2012年的ImageNet大规模视觉识别挑战赛（ILSVRC）中提出，并取得了冠军。以下是AlexNet的主要特点和结构：

结构特点：

深度与宽度：AlexNet包含5个卷积层、3个最大池化层、2个归一化层、2个全连接层，以及1个最终的1000路softmax输出层，总共大约有6000万个参数。
卷积层：AlexNet使用了多个卷积层来提取图像特征。这些层使用了大小为11x11、5x5、3x3的卷积核，并采用了步长（stride）和填充（padding）技术来控制输出特征图的大小。
ReLU激活函数：AlexNet是第一个广泛使用ReLU作为激活函数的网络，这有助于加速训练过程并减少梯度消失的问题。
局部响应归一化（LRN）：在某些卷积层之后，AlexNet使用了局部响应归一化来提高模型的泛化能力。
最大池化层：AlexNet使用了重叠的最大池化（步长小于池化核大小），这有助于减少过拟合。
重叠池化：与传统的非重叠池化不同，AlexNet使用步长小于池化核大小的重叠池化，这有助于减少过拟合。
丢弃法（Dropout）：在全连接层中，AlexNet使用了丢弃法来防止过拟合。
数据增强：为了提高模型的泛化能力，AlexNet在训练过程中使用了数据增强技术，如随机裁剪、水平翻转、颜色变换等。

ALEXnet是在Lenet基础上发展而来的。

import torch
from torch import nn
import d2l
net = nn.Sequential(
    # 这里使用一个11*11的更大窗口来捕捉对象。
    # 同时，步幅为4，以减少输出的高度和宽度。
    # 另外，输出通道的数目远大于LeNet
    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),
    # 使用三个连续的卷积层和较小的卷积窗口。
    # 除了最后的卷积层，输出通道的数量进一步增加。
    # 在前两个卷积层之后，汇聚层不用于减少输入的高度和宽度
    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中的好几倍。使用dropout层来减轻过拟合
    nn.Linear(6400, 4096), nn.ReLU(),
    nn.Dropout(p=0.5),
    nn.Linear(4096, 4096), nn.ReLU(),
    nn.Dropout(p=0.5),
    # 最后是输出层。由于这里使用Fashion-MNIST，所以用类别数为10，而非论文中的1000
    nn.Linear(4096, 10))
X = torch.randn(1, 1, 224, 224)
for layer in net:
    X=layer(X)
    print(layer.__class__.__name__,'output shape:\t',X.shape)
batch_size = 128
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)
lr, num_epochs = 0.01, 10
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())

VGG卷积神经网络

VGG（Visual Geometry Group）卷积神经网络是由牛津大学的视觉几何组在2014年提出的一系列深度神经网络架构。VGG网络以其结构简单、参数量大的特点在图像识别领域取得了显著的成功，尤其是在ILSVRC-2014比赛中取得了优异的成绩。VGG网络的主要贡献在于展示了网络的深度对于性能提升的重要性，并引入了一种标准的网络配置方法。

以下是VGG网络的主要特点和结构：

结构特点：

层叠的卷积层：VGG网络的特点之一是使用多个3x3的卷积层堆叠在一起，而不是使用较大的卷积核。这种设计可以增加网络的深度，同时减少参数数量。
固定的步长和填充：在卷积层中，通常使用1的步长和1的填充，以保持特征图的尺寸不变。
池化层：VGG网络在卷积层堆叠之后使用2x2的最大池化层来减少特征图的尺寸，并且池化层的步长为2。
全连接层：网络的最后几层是全连接层，用于进行分类。
参数标准化：VGG网络在训练过程中使用了权重衰减和丢弃法（dropout）来防止过拟合。

import torch
from torch import nn
import d2l

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.append(nn.MaxPool2d(kernel_size=2,stride=2))
    return nn.Sequential(*layers)
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.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)
X = torch.randn(size=(1, 1, 224, 224))#输入
for blk in net:#blk就是block
    X = blk(X)
    print(blk.__class__.__name__,'output shape:\t',X.shape)#输出每一层的形状
ratio = 4
small_conv_arch = [(pair[0], pair[1] // ratio) for pair in conv_arch]
net = vgg(small_conv_arch)#构建网络
lr, num_epochs, batch_size = 0.05, 10, 128#学习率，迭代次数，批量大小
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)#加载数据集
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())#训练模型

不同的VGG模型可以通过每个块中卷积层的数量和输出通道的数量的差异来定义，块的使用导致网络的使用非常简洁。在深度学习中，“块”（block）通常指的是网络中的一个组成单元，它可以是卷积神经网络（CNN）中的一个重复的结构，或者是循环神经网络（RNN）中的一个处理单元。块通常包含一系列的层，这些层共同执行特定的操作或学习特定的特征。

NIN(网络中的网络)卷积神经网络

NIN（Network in Network）是一种深度学习模型，它在2014年由Min Lin等人提出。NIN的主要创新点在于引入了“微网络”（Network Inside Network）的概念，即在每个卷积层之后使用一个微型的多层感知机（MLP）来代替传统的非线性激活函数。以下是NIN的一些关键特点：

微网络（MLP Convolution）

在传统的卷积神经网络中，卷积层之后通常直接应用一个非线性激活函数（如ReLU）。而在NIN中，作者提出了使用微型多层感知机（也称为全局平均池化层之前的mlpconv层）来代替传统的非线性激活。这个微型网络可以学习更复杂的特征表示。

全局平均池化（Global Average Pooling）

NIN模型在网络的最后几层使用了全局平均池化来替代传统的全连接层。全局平均池化对每个特征图（feature map）计算平均值，得到一个数值，这个数值直接作为最终的分类评分。这种方法可以减少参数数量，降低过拟合的风险，并且有助于模型泛化。

结构特点

卷积层（mlpconv层）：NIN使用多个mlpconv层，每个mlpconv层内部包含多个1x1的卷积层和一个非线性激活函数。
局部感知野：通过使用1x1卷积，NIN能够在不增加参数数量的情况下增加网络的深度和复杂性。
参数共享：1x1卷积允许参数在空间上共享，减少了模型的参数数量。

应用

NIN最初被设计用于图像分类任务，并在一些基准数据集上取得了很好的效果。由于其轻量级和高效的特点，NIN也被应用于移动设备和嵌入式系统中的图像识别任务。

影响

NIN的提出对深度学习模型的设计产生了重要影响，特别是1x1卷积（也称为瓶颈层）和全局平均池化的概念，这些概念后来被许多其他网络结构（如GoogLeNet的Inception模块）所采用。

总的来说，NIN通过引入微型网络和全局平均池化，提供了一种新颖的网络结构，它在保持模型简洁的同时提高了特征学习能力，对于后续深度学习模型的发展具有一定的启发作用。NIN的最大特点在于其去除了传统的激活函数并且替代了传统的全连接层。

import torch
from torch import nn
import 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())#卷积层
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),#dropout层
    # 标签类别数是10
    nin_block(384, 10, kernel_size=3, strides=1, padding=1),
    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)#输出每一层的形状
lr, num_epochs, batch_size = 0.1, 10, 128#学习率，迭代次数，批量大小
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=224)#加载数据集
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())#训练模型

含并行连接的网络

GoogLeNet，也称为Inception网络，是由Google的研究者们在2014年的论文《Going Deeper with Convolutions》中提出的一种深度卷积神经网络架构。GoogLeNet的名称中的“LeNet”是为了向早期的卷积神经网络LeNet致敬。GoogLeNet在当时取得了ImageNet挑战赛的冠军，并且由于其创新的网络结构和高效的计算特性，它在深度学习领域产生了重大影响。

以下是GoogLeNet的一些关键特点：

Inception模块

GoogLeNet的核心是Inception模块，这是一种网络层的堆叠方式，旨在通过不同尺寸的卷积和池化操作来同时捕获图像中的多种尺度特征。

一个典型的Inception模块包含以下部分：

1x1卷积层：用于减少特征图的维度，同时引入非线性。
3x3卷积层：用于捕获空间特征。
5x5卷积层：用于捕获更大范围的空间特征。
3x3最大池化层：用于降低特征图的尺寸，同时保留重要信息。

这些层并行连接，并且它们的输出在深度方向上拼接起来，形成下一层的输入。

网络结构

GoogLeNet由多个Inception模块堆叠而成，中间穿插着一些传统的卷积层和池化层。网络的设计考虑了计算效率和特征表达的平衡。

辅助分类器

GoogLeNet还引入了辅助分类器的概念，这些分类器位于网络的中间层，用于向前传播梯度，帮助训练更深的网络。这些辅助分类器的损失会以较小的权重加到总损失中，从而有助于防止梯度消失问题。

网络变种

原始的GoogLeNet（Inception-v1）之后，研究者们提出了多个改进版本，包括Inception-v2、Inception-v3、Inception-v4等，每个版本都在网络结构、效率和性能方面有所改进。

计算效率

GoogLeNet通过使用1x1卷积层来减少特征图的深度，从而显著减少了网络的参数数量和计算量。这种设计使得GoogLeNet在保持较高准确率的同时，比其他同等深度的网络更加高效。

import torch
from torch import nn
from torch.nn import functional as F
import d2l

class Inception(nn.Module):# c1--c4是每条路径的输出通道数
    # c1--c4是每条路径的输出通道数
    def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):
        super(Inception, self).__init__(**kwargs)
        # 线路1，单1x1卷积层
        self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)
        # 线路2，1x1卷积层后接3x3卷积层
        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，1x1卷积层后接5x5卷积层
        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，3x3最大汇聚层后接1x1卷积层
        self.p4_1 = nn.MaxPool2d(kernel_size=3, 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)
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),# 1x1卷积层
                   nn.ReLU(),
                   nn.Conv2d(64, 192, kernel_size=3, padding=1),
                   nn.ReLU(),
                   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),
                   nn.AdaptiveAvgPool2d((1,1)),
                   nn.Flatten())

net = nn.Sequential(b1, b2, b3, b4, b5, nn.Linear(1024, 10))# GoogLeNet使用了全局平均池化层，所以输入的宽高可以是任意值
X = torch.rand(size=(1, 1, 96, 96))# GoogLeNet将卷积层的输出传入全局平均池化层中
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__,'output shape:\t', X.shape)
lr, num_epochs, batch_size = 0.1, 10, 128# 读取数据
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)# GoogLeNet模型的训练与AlexNet和VGG的类似
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())# 但这里使用的学习率更大，因为网络更深

残差网络

ResNet（Residual Network）是由微软研究院的研究员在2015年的论文《Deep Residual Learning for Image Recognition》中提出的一种深度卷积神经网络架构。ResNet在ImageNet竞赛中取得了当时的最佳成绩，并且由于其深度和准确性，它在深度学习领域产生了深远的影响。ResNet的一个关键创新是引入了残差学习（residual learning）的概念，这使得网络能够成功训练非常深的网络。

以下是ResNet的一些关键特点：

残差学习

在传统的卷积神经网络中，随着网络层数的增加，梯度消失或爆炸问题变得更加严重，这使得网络的训练变得困难。ResNet通过引入残差块（residual block）来解决这个问题。残差块允许输入直接跳过一些层，与这些层的输出相加，从而形成残差连接。

残差块

残差块是ResNet的核心组成部分，它通常包含以下结构：

一个或多个卷积层，用于提取特征。
一个跳过这些卷积层的直接连接，称为“shortcut”或“identity connection”。
一个非线性激活函数，如ReLU。

残差块的基本形式如下：

import torch
from torch import nn
from torch.nn import functional as F
import d2l

class Residual(nn.Module):  #@save
    def __init__(self, input_channels, num_channels,
                 use_1x1conv=False, strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels,# 1x1卷积层
                               kernel_size=3, padding=1, stride=strides)
        self.conv2 = nn.Conv2d(num_channels, num_channels,# 3x3卷积层
                               kernel_size=3, padding=1)
        if use_1x1conv:# 1x1卷积层
            self.conv3 = nn.Conv2d(input_channels, num_channels,
                                   kernel_size=1, stride=strides)
        else:
            self.conv3 = None
        self.bn1 = nn.BatchNorm2d(num_channels)# 批量归一化层
        self.bn2 = nn.BatchNorm2d(num_channels)# 批量归一化层

    def forward(self, X):# 定义前向计算
        Y = F.relu(self.bn1(self.conv1(X)))# 1x1卷积层->批量归一化层->ReLU激活函数
        Y = self.bn2(self.conv2(Y))# 3x3卷积层->批量归一化层
        if self.conv3:# 如果use_1x1conv为True，那么就会使用1x1卷积层
            X = self.conv3(X)# 1x1卷积层
        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
b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),# 7x7卷积层
                   nn.BatchNorm2d(64), nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))
def resnet_block(input_channels, num_channels, num_residuals,# 定义ResNet块
                 first_block=False):
    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
b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True))# 64通道->64通道
b3 = nn.Sequential(*resnet_block(64, 128, 2))# 64通道->128通道
b4 = nn.Sequential(*resnet_block(128, 256, 2))# 128通道->256通道
b5 = nn.Sequential(*resnet_block(256, 512, 2))# 256通道->512通道
net = nn.Sequential(b1, b2, b3, b4, b5,
                    nn.AdaptiveAvgPool2d((1,1)),
                    nn.Flatten(), nn.Linear(512, 10))# 10分类问题
X = torch.rand(size=(1, 1, 224, 224))# GoogLeNet使用了全局平均池化层，所以输入的宽高可以是任意值
for layer in net:
    X = layer(X)
    print(layer.__class__.__name__,'output shape:\t', X.shape)
lr, num_epochs, batch_size = 0.05, 10, 256# 读取数据
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)# GoogLeNet模型的训练与AlexNet和VGG的类似
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())# 但这里使用的学习率更大，因为网络更深

利用残差块可以训练出一个有效的深层神经网络。

Densenet卷积神经网络

DenseNet（Densely Connected Convolutional Networks）是一种高效的卷积神经网络架构，由黄高（Gao Huang）等人在2016年的论文《Densely Connected Convolutional Networks》中提出。DenseNet的核心思想是在网络中引入了密集连接（dense connectivity）模式，即每个层都与前面所有层直接连接，而不仅仅是与前一层的输出连接。这种结构显著提高了信息和梯度的流动，使得网络能够更加高效地学习。

以下是DenseNet的一些关键特点：

密集连接

在传统的卷积神经网络中，第L层的输出是第L-1层输出的函数。而在DenseNet中，第L层的输入是前面所有层输出的拼接，即第L层的输入是第1层到第L-1层输出的拼接。这种连接方式称为密集连接。

基本构建块

DenseNet的基本构建块是稠密块（dense block）和过渡层（transition layer）：

稠密块：包含多个卷积层，每个卷积层的输出都会与前面所有层的输出拼接起来，形成下一层的输入。
过渡层：用于减少特征图的尺寸，通常包含1x1的卷积层（用于减少通道数）和2x2的平均池化层（用于降低空间维度）。

网络结构

DenseNet的网络结构通常如下：

一个标准的卷积层，用于初始的特征提取。
一个或多个稠密块，每个稠密块后跟着一个过渡层。
全局平均池化层，用于减少特征图的维度。
一个全连接层，用于最终的分类。

示例代码如下：

import torch
from torch import nn
import d2l

def conv_block(input_channels, num_channels):#卷积块
    return nn.Sequential(#卷积层、批量归一化层、ReLU激活函数
        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
blk = DenseBlock(2, 3, 10)#输入通道数为3，输出通道数为10
X = torch.randn(4, 3, 8, 8)
Y = blk(X)#测试Y的输出的形状
Y.shape
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))
blk = transition_block(23, 10)#输入通道数为23，输出通道数为10
blk(Y).shape
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为当前的通道数
num_channels, growth_rate = 64, 32#当前的通道数为64，增长率为32
num_convs_in_dense_blocks = [4, 4, 4, 4]#每个稠密块使用4个卷积层
blks = []#存储所有的稠密块
for i, num_convs in enumerate(num_convs_in_dense_blocks):#创建4个稠密块
    blks.append(DenseBlock(num_convs, num_channels, growth_rate))#添加稠密块
    # 上一个稠密块的输出通道数
    num_channels += num_convs * growth_rate
    # 在稠密块之间添加一个转换层，使通道数量减半
    if i != len(num_convs_in_dense_blocks) - 1:
        blks.append(transition_block(num_channels, num_channels // 2))
        num_channels = num_channels // 2
net = nn.Sequential(#DenseNet模型
    b1, *blks,#添加所有的稠密块
    nn.BatchNorm2d(num_channels), nn.ReLU(),
    nn.AdaptiveAvgPool2d((1, 1)),#全局平均池化层
    nn.Flatten(),#全连接层
    nn.Linear(num_channels, 10))
lr, num_epochs, batch_size = 0.1, 10, 256#学习率、迭代周期、批量大小
train_iter, test_iter = d2l.load_data_fashion_mnist(batch_size, resize=96)#加载数据集
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())#训练模型