【深度之眼】【Pytorch打卡第5天】：nn.Module与网络模型构建步骤；模型容器与AlexNet构建

任务简介：学习nn.Module类以及搭建网络模型步骤；熟悉搭建网络模型时常用的模型容器

详细说明：

• 本节第一部分介绍网络模型的基本类nn.Module，nn.Module是所有网络层的基本类，它拥有8个有序字典，用于管理模型属性，本节课中将要学习如何构建一个Module。

• 然后通过网络结构和计算图两个角度去观察搭建一个网络模型需要两个步骤：第一步，搭建子模块；第二步，拼接子模块。

• 本节第二部分介绍搭建网络模型常用的容器，如Sequential，ModuleList, ModuleDict，然后学习pytorch提供的Alexnet网络模型结构加深对模型容器的认识。

作业名称（详解）：

1. 采用步进(Step into)的调试方法从创建网络模型开始（net = LeNet(classes=2)）进入到每一个被调用函数，观察net的_modules字段何时被构建并且赋值，记录其中所有进入的类与函数
   例如：
   第一步：net = LeNet(classes=2)
   第二步：LeNet类，init()，super(LeNet, self).init()
   第三步: Module类, …
   第n步：返回net
   打卡有求：文字简答
2. 采用sequential容器，改写Alexnet，给features中每一个网络层增加名字，并通过下面这行代码打印出来
   print(alexnet._modules[‘features’]._modules.keys())
   打卡要求：截图或文字

---

模型创建步骤

数据–模型–损失函数–优化器–迭代训练

class LeNet(nn.Module):
    def __init__(self, classes):
        super(LeNet, self).__init__()
        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

    def initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.xavier_normal_(m.weight.data)
                if m.bias is not None:
                    m.bias.data.zero_()
            elif isinstance(m, nn.BatchNorm2d):
                m.weight.data.fill_(1)
                m.bias.data.zero_()
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight.data, 0, 0.1)
                m.bias.data.zero_()

nn.Module

• parameters: 存储管理nn.Parameter类
• modules : 存储管理nn.Module类
• buffers:存储管理缓冲属性，如BN层中的running_mean • ***_hooks:存储管理钩子函数

nn.Module总结

• 一个module可以包含多个子module
• 一个module相当于一个运算，必须实现forward()函数 • 每个module都有8个字典管理它的属性

模型容器–Container

nn.Sequetial

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

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

nn.ModuleList

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

class ModuleList(nn.Module):
    def __init__(self):
        super(ModuleList, self).__init__()
        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

nn.ModuleLDict

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

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

print(output)

容器总结

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

---

AlexNet

• AlexNet特点如下:

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

参考文献: 《ImageNet Classification with Deep Convolutional Neural Networks》