[python]深度学习网络模型的创建

目录

一、分开创建子模块

二、使用模型容器实现子模块的创建

1、使用nn.Sequetial

2、使用nn.ModuleList

3、使用nn.ModuleDict

---

在深度学习中，创建模型一般分为两个模块，一个是创建子模块，一个是拼接子模块。通常是将子模块构建好后，按照一定的顺序拼接起来。

下面以LeNet为例，实现模型创建的几种方法。

一、分开创建子模块

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

正如上面模型创建的方法所示，在创建模型时，模型继承的是“nn.Module”，且必须实现“__init__()”和“forward()”两种方法。其中“__init__()”实现子模块的创建，“forward()”实现子模块的拼接。

二、使用模型容器实现子模块的创建

常用的模型容器通常有三个：

• nn.Sequetial:按照顺序包装多个网络层
• nn.ModuleList：像list一样包装多个网络层，可以迭代
• nn.ModuleDict：像dict一样包装多个网络层，通过（key,value)的方式为每个网络层指定名称。

1、使用nn.Sequetial

在深度学习时代，模型网络可以分为特征提取和分类器两部分，这两部分可以分别使用nn.Sequential来包装。

可以将上面LeNet创建模块的代码修改为：

class LeNetSeq(nn.Module):
    def __int__(self,classes):
        super(LeNetSeq,self).__init__()
        self.feature = nn.Sequential(
            nn.Conv2d(3,6,5),
            nn.ReLU(),
            nn.MaxPool2d(),
            nn.Conv2d(6,16,5),
            nn.ReLU(),
            nn.MaxPool2d(),
        )
        self.fc = 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.feature(x)
        x = x.view(x.size(0),-1)
        x = self.fc(x)
        return x

2、使用nn.ModuleList

nn.ModuleList是nn.Module的容器，用于包装一组网络层，以迭代的方式调用网络层，主要有下面三个方法：

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

下面的代码通过列表生成式来循环迭代创建 5 个全连接层，非常方便，只是在 forward()函数中需要手动调用每个网络层。

class ModuleList(nn.Module):
    def __init__(self):
        super(ModuleList, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(10, 10) for i in range(5)])

    def forward(self, x):
        for i, linear in enumerate(self.linears):
            x = linear(x)
        return x


net = ModuleList()
print(net)

运行后的结果为：

ModuleList(
  (linears): ModuleList(
    (0): Linear(in_features=10, out_features=10, bias=True)
    (1): Linear(in_features=10, out_features=10, bias=True)
    (2): Linear(in_features=10, out_features=10, bias=True)
    (3): Linear(in_features=10, out_features=10, bias=True)
    (4): Linear(in_features=10, out_features=10, bias=True)
  )
)

3、使用nn.ModuleDict:

nn.ModuleDict是nn.Module的容器，用于包装一组网络层，以索引的方式调用网络层，主要有以下 5 个方法：

• clear()：清空 ModuleDict

• items()：返回可迭代的键值对 (key, value)

• 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

参考地址：[PyTorch 学习笔记] 3.1 模型创建步骤与 nn.Module