pytorch04：网络模型创建

一、模型创建过程

1.1 以LeNet网络为例

网络代码如下：

class LeNet(nn.Module):def __init__(self, classes):super(LeNet, self).__init__()  # 调用父类方法，作用是调用nn.Module类的构造函数，# 确保LeNet类被正确地初始化，并继承了nn.Module 的所有属性和方法self.conv1 = nn.Conv2d(3, 6, 5) # 卷积层self.conv2 = nn.Conv2d(6, 16, 5)self.fc1 = nn.Linear(16 * 5 * 5, 120) # 全连接层self.fc2 = nn.Linear(120, 84)self.fc3 = nn.Linear(84, classes)def forward(self, x):out = F.relu(self.conv1(x))out = F.max_pool2d(out, 2)out = F.relu(self.conv2(out))out = F.max_pool2d(out, 2)out = out.view(out.size(0), -1)out = F.relu(self.fc1(out))out = F.relu(self.fc2(out))out = self.fc3(out)return out

1.2 LeNet结构

LeNet：conv1–>pool1–>conv2–>pool2–>fc1–>fc2–>fc3

1.3 nn.Module

Module是nn模块中的功能，nn模块还有Parameter、functional等模块。

nn.Module主要有以下参数：
• parameters : 存储管理nn.Parameter类
• modules : 存储管理nn.Module类
• buffers：存储管理缓冲属性，如BN层中的running_mean

二、网络层容器(Containers)

2.1 nn.Sequential

nn.Sequential 是 nn.module的容器，也是最常用的容器，用于按顺序包装一组网络层
• 顺序性：各网络层之间严格按照顺序构建
• 自带forward()：自带的forward里，通过for循环依次执行前向传播运算

2.1.1 常规方法实现

LeNet网络由两部分构成，中间的卷积池化特征提取部分(features)，以及最后的分类部分(classifier)。

具体代码如下：

class LeNetSequential(nn.Module):def __init__(self, classes):super(LeNetSequential, self).__init__()self.features = nn.Sequential(  #特征提取部分nn.Conv2d(3, 6, 5),nn.ReLU(),nn.MaxPool2d(kernel_size=2, stride=2),nn.Conv2d(6, 16, 5),nn.ReLU(),nn.MaxPool2d(kernel_size=2, stride=2),)self.classifier = nn.Sequential(  #分类部分nn.Linear(16*5*5, 120),nn.ReLU(),nn.Linear(120, 84),nn.ReLU(),nn.Linear(84, classes),)def forward(self, x):x = self.features(x)x = x.view(x.size()[0], -1)x = self.classifier(x)return x

打印网络层：

2.1.2 OrderedDict方法实现

使用有序字典的方法构建Sequential
代码如下：

class LeNetSequentialOrderDict(nn.Module):def __init__(self, classes):super(LeNetSequentialOrderDict, self).__init__()self.features = nn.Sequential(OrderedDict({'conv1': nn.Conv2d(3, 6, 5),'relu1': nn.ReLU(inplace=True),'pool1': nn.MaxPool2d(kernel_size=2, stride=2),'conv2': nn.Conv2d(6, 16, 5),'relu2': nn.ReLU(inplace=True),'pool2': nn.MaxPool2d(kernel_size=2, stride=2),}))self.classifier = nn.Sequential(OrderedDict({'fc1': nn.Linear(16 * 5 * 5, 120),'relu3': nn.ReLU(),'fc2': nn.Linear(120, 84),'relu4': nn.ReLU(inplace=True),'fc3': nn.Linear(84, classes),}))def forward(self, x):x = self.features(x)x = x.view(x.size()[0], -1)x = self.classifier(x)return x

先看一下Sequential函数中init初始化的两种方法，当我们使用OrderedDict方法时，会进行判断，使用self.add_module(key, module)方法将字典中的key和value取出来添加到Sequential中。

class Sequential(Module):def __init__(self, *args):super().__init__()if len(args) == 1 and isinstance(args[0], OrderedDict):for key, module in args[0].items():self.add_module(key, module)else:for idx, module in enumerate(args):self.add_module(str(idx), module)

通过这种方法构建可以给每一网络层添加一个名称，网络输出结果如下：

2.2 nn.ModuleList

nn.ModuleList是 nn.module的容器，用于包装一组网络层，以迭代方式调用网络层
主要方法：
• append()：在ModuleList后面添加网络层
• extend()：拼接两个ModuleList
• insert()：指定在ModuleList中位置插入网络层

使用列表生成式，通过一行代码就能构建20个网络层。
代码演示：

class ModuleList(nn.Module):def __init__(self):super(ModuleList, self).__init__()# 使用列表生成式构建20个全连接层，每个全连接层10个神经元的网络self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(20)])def forward(self, x):for i, linear in enumerate(self.linears):x = linear(x)return xnet = ModuleList()

2.3 nn.ModuleDict

nn.ModuleDict是 nn.module的容器，用于包装一组网络层，以索引方式调用网络层，可以用过参数的形式选取想要调用的网络层。
主要方法：
• clear()：清空ModuleDict
• items()：返回可迭代的键值对(key-value pairs)
• keys()：返回字典的键(key)
• values()：返回字典的值(value)
• pop()：返回一对键值，并从字典中删除

代码展示，只选取conv和relu两个网络层：

class ModuleDict(nn.Module):def __init__(self):super(ModuleDict, self).__init__()self.choices = nn.ModuleDict({'conv': nn.Conv2d(10, 10, 3),'pool': nn.MaxPool2d(3)})# 激活函数self.activations = nn.ModuleDict({'relu': nn.ReLU(),'prelu': nn.PReLU()})def forward(self, x, choice, act):  # 传入两个参数 用来选择网络层x = self.choices[choice](x)x = self.activations[act](x)return x
net = ModuleDict()
fake_img = torch.randn((4, 10, 32, 32))
output = net(fake_img, 'conv', 'relu')  #只选取conv和relu两个网络层。
print(output)

2.4 三种容器构建总结

• nn.Sequential：顺序性，各网络层之间严格按顺序执行，常用于block构建
• nn.ModuleList：迭代性，常用于大量重复网构建，通过for循环实现重复构建
• nn.ModuleDict：索引性，常用于可选择的网络层

三、AlexNet网络构建

AlexNet：2012年以高出第二名10多个百分点的准确率获得ImageNet分类任务冠军，开创了卷积神经网络的新时代
AlexNet特点如下：

1. 采用ReLU：替换饱和激活函数，减轻梯度消失
2. 采用LRN(Local Response Normalization)：对数据归一化，减轻梯度消失
3. Dropout：提高全连接层的鲁棒性，增加网络的泛化能力
4. Data Augmentation：TenCrop，色彩修改

网络结构图如下：

构建代码：

import torch.nn as nn
import torch
from torchsummary import summary
# 定义一个名为AlexNet的神经网络模型，继承自nn.Module基类
class AlexNet(nn.Module):# 构造函数，初始化网络的参数def __init__(self, num_classes: int = 1000, dropout: float = 0.5) -> None:# 调用父类的构造函数super().__init__()# 定义神经网络的特征提取部分，包含多个卷积层和池化层self.features = nn.Sequential(nn.Conv2d(3, 64, kernel_size=11, stride=4, padding=2),  # 输入通道3，输出通道64，卷积核大小11x11，步长4，填充2nn.ReLU(inplace=True),  # 使用ReLU激活函数，inplace=True表示原地操作，节省内存nn.MaxPool2d(kernel_size=3, stride=2),  # 最大池化层，核大小3x3，步长2nn.Conv2d(64, 192, kernel_size=5, padding=2),  # 输入通道64，输出通道192，卷积核大小5x5，填充2nn.ReLU(inplace=True),nn.MaxPool2d(kernel_size=3, stride=2),nn.Conv2d(192, 384, kernel_size=3, padding=1),nn.ReLU(inplace=True),nn.Conv2d(384, 256, kernel_size=3, padding=1),nn.ReLU(inplace=True),nn.Conv2d(256, 256, kernel_size=3, padding=1),nn.ReLU(inplace=True),nn.MaxPool2d(kernel_size=3, stride=2),)# 定义自适应平均池化层，将输入的任意大小的特征图池化为固定大小6x6self.avgpool = nn.AdaptiveAvgPool2d((6, 6))# 定义分类器部分，包含全连接层和Dropout层self.classifier = nn.Sequential(nn.Dropout(p=dropout),  # 使用Dropout进行正则化，随机丢弃一部分神经元以防止过拟合nn.Linear(256 * 6 * 6, 4096),  # 输入大小为256*6*6，输出大小为4096nn.ReLU(inplace=True),nn.Dropout(p=dropout),nn.Linear(4096, 4096),nn.ReLU(inplace=True),nn.Linear(4096, num_classes),  # 最后的全连接层输出类别数)# 前向传播函数，定义数据在网络中的传播过程def forward(self, x: torch.Tensor) -> torch.Tensor:x = self.features(x)  # 特征提取x = self.avgpool(x)  # 平均池化x = torch.flatten(x, 1)  # 将特征图展平成一维向量x = self.classifier(x)  # 分类器return xif __name__ == '__main__':net = AlexNet().cuda()summary(net, (3, 256, 256))

打印出的网络结构图如下：