pytorch04:网络模型创建

目录

  • 一、模型创建过程
    • 1.1 以LeNet网络为例
    • 1.2 LeNet结构
    • 1.3 nn.Module
  • 二、网络层容器(Containers)
    • 2.1 nn.Sequential
      • 2.1.1 常规方法实现
      • 2.1.2 OrderedDict方法实现
    • 2.2 nn.ModuleList
    • 2.3 nn.ModuleDict
    • 2.4 三种容器构建总结
  • 三、AlexNet网络构建

一、模型创建过程

pytorch04:网络模型创建_第1张图片

1.1 以LeNet网络为例

pytorch04:网络模型创建_第2张图片

网络代码如下:

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结构

pytorch04:网络模型创建_第3张图片

LeNet:conv1–>pool1–>conv2–>pool2–>fc1–>fc2–>fc3
pytorch04:网络模型创建_第4张图片

1.3 nn.Module

Module是nn模块中的功能,nn模块还有Parameter、functional等模块。
pytorch04:网络模型创建_第5张图片
nn.Module主要有以下参数:
• parameters : 存储管理nn.Parameter类
• modules : 存储管理nn.Module类
• buffers:存储管理缓冲属性,如BN层中的running_mean

二、网络层容器(Containers)

pytorch04:网络模型创建_第6张图片

2.1 nn.Sequential

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

2.1.1 常规方法实现

LeNet网络由两部分构成,中间的卷积池化特征提取部分(features),以及最后的分类部分(classifier)。
pytorch04:网络模型创建_第7张图片
具体代码如下:

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

打印网络层:
pytorch04:网络模型创建_第8张图片

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)

通过这种方法构建可以给每一网络层添加一个名称,网络输出结果如下:
pytorch04:网络模型创建_第9张图片

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 x


net = 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,色彩修改

网络结构图如下:
pytorch04:网络模型创建_第10张图片
构建代码:

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,填充2
            nn.ReLU(inplace=True),  # 使用ReLU激活函数,inplace=True表示原地操作,节省内存
            nn.MaxPool2d(kernel_size=3, stride=2),  # 最大池化层,核大小3x3,步长2
            nn.Conv2d(64, 192, kernel_size=5, padding=2),  # 输入通道64,输出通道192,卷积核大小5x5,填充2
            nn.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),
        )
        
        # 定义自适应平均池化层,将输入的任意大小的特征图池化为固定大小6x6
        self.avgpool = nn.AdaptiveAvgPool2d((6, 6))
        
        # 定义分类器部分,包含全连接层和Dropout层
        self.classifier = nn.Sequential(
            nn.Dropout(p=dropout),  # 使用Dropout进行正则化,随机丢弃一部分神经元以防止过拟合
            nn.Linear(256 * 6 * 6, 4096),  # 输入大小为256*6*6,输出大小为4096
            nn.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 x
 if __name__ == '__main__':
    net = AlexNet().cuda()
    summary(net, (3, 256, 256))

打印出的网络结构图如下:
pytorch04:网络模型创建_第11张图片

你可能感兴趣的:(Pytorch,pytorch,python,深度学习,人工智能,神经网络)