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

109 阅读 0 评论 72 点赞

我是靠谱客的博主冷酷衬衫，最近开发中收集的这篇文章主要介绍【深度之眼】Pytorch框架班第五期-Week3【任务1】第二节：模型容器与AlexNet构建模型容器与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