【深度之眼】Pytorch框架班第五期-Week3【任务1】第二节：模型容器与AlexNet构建

模型容器与AlexNet构建

模型容器(Containers)

容器之Sequential

nn.Sequential是nn.module的容器，用于按顺序包装一组网络层，使这组网络层被看作为一个整体，可以看做成模型的一个子模块。

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.Sequential 是 nn.module 的容器，用于按顺序包装一组网络层

• 顺序性：各网络层之间严格按照顺序构建
• 自带forward()：自带的forward里，通过for循环依次执行前向传播运算

容器之ModuleList

nn.ModuleList是nn.module的容器，用于包装一组网络层，以迭代的方式调用网络层
主要方法：

• append()：在ModuleList后面添加网络层
• extend()：拼接两个ModuleList
• insert()：指定在Module List中位置插入网络层

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

容器之ModuleDict

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

容器总结

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

AlexNet构建