动手学PyTorch | (14) 模型构造

让我们回顾⼀下在(多层感知机的简洁实现)中含单隐藏层的多层感知机的实现方法。我们⾸先构造Sequential实例，然后依次添加两个全连接层。其中第一层的输出⼤小为256，即隐藏层单元个数是256;第二层的输出⼤小为10，即输出层单元个数是10。我们在其他小节中也使用了Sequential类构造模型。这⾥我们介绍另外⼀种基于Module类的模型构造方法：它让模型构造更更加灵活。

目录

1. 继承Module类来构造模型

2. Module的子类

3. 构造复杂的模型

4. 小结

---

1. 继承Module类来构造模型

Module类是nn模块⾥提供的一个模型构造类，是所有神经⽹络模块的基类，我们可以继承它来定义我们想要的模型。下⾯继承Module类构造本节开头提到的多层感知机。这⾥定义的MLP类􏰀重载了Module类的__init__函数和forward函数。它们分别用于创建模型参数和定义前向计算。前向计算也即正向传播。

import torch
from torch import nn

class MLP(nn.Module):
    # 声明带有模型参数的层，这里声明了两个全连接层
    def __init__(self, **kwargs):
        # 调用MLP父类Block的构造函数来进行必要的初始化。这样在构造实例时还可以指定其他函数
        # 参数，如“模型参数的访问、初始化和共享”一节将介绍的模型参数params
        super(MLP, self).__init__(**kwargs)
        self.hidden = nn.Linear(784, 256) # 隐藏层
        self.act = nn.ReLU()
        self.output = nn.Linear(256, 10)  # 输出层
         

    # 定义模型的前向计算，即如何根据输入x计算返回所需要的模型输出
    def forward(self, x):
        a = self.act(self.hidden(x))
        return self.output(a)

以上的MLP类中无须定义反向传播函数。系统将通过⾃动求梯度⽽⾃动⽣成反向传播所需的backward函数。

我们可以实例化MLP类得到模型变量net。下⾯的代码初始化net并传入输入数据X做一次前向计算。其中，net(X)会调用MLP继承自Module类的__call__函数，这个函数将调⽤MLP类定义的forward函数来完成前向计算。

X = torch.rand(2, 784) #每行代表一个样本的特征向量
net = MLP()
print(net)
net(X)

注意，这⾥并没有将Module类命名为Layer（层）或者Model（模型）之类的名字，是一个可供⾃由组建的部件。它的子类既可以是⼀个层(如PyTorch内置的Linear类),⼜可以是⼀个模型(如这里定义的MLP类)，或者是模型的一个部分。我们下面通过两个例子来展示它的灵活性。

 

2. Module的子类

我们刚刚提到，Module类是⼀个通⽤的部件。事实上，PyTorch还实现了继承⾃Module的可以方便构建模型的类：如Sequential、ModuleList和ModuleDict等。

• Sequential类

当模型的前向计算为简单串联各个层的计算时，Sequential类可以通过更加简单的⽅式定义模型。这正是Sequential类的目的：它可以接收⼀个子模块的有序字典（OrderedDict）或者⼀系列子模块作为参数来逐一添加Module实例，而模型的前向计算就是将这些实例按添加的顺序逐一计算。

下⾯我们实现⼀个与Sequential类有相同功能的MySequential类。这或许可以帮助读者更加清晰地理解Sequential类的工作机制。

class MySequential(nn.Module):
    from collections import OrderedDict
    def __init__(self, *args):
        super(MySequential, self).__init__()
        if len(args) == 1 and isinstance(args[0], OrderedDict): # 如果传入的是一个OrderedDict
            for key, module in args[0].items():
                self.add_module(key, module)  # add_module方法会将module添加进self._modules(一个OrderedDict)
        else:  # 传入的是一些Module
            for idx, module in enumerate(args):
                self.add_module(str(idx), module)
    def forward(self, input):
        # self._modules返回一个 OrderedDict，保证会按照成员添加时的顺序遍历
        for module in self._modules.values():
            input = module(input)
        return input

我们⽤MySequential类来实现前面描述的MLP类，并使⽤随机初始化的模型做一次前向计算。 

net = MySequential(
        nn.Linear(784, 256),
        nn.ReLU(),
        nn.Linear(256, 10), 
        )
print(net)
net(X)

可以观察到这⾥MySequential类的使用和多层感知机的简洁实现中的Sequential类的使用没什么区别。

• ModuleList类

ModuleList接收⼀个子模块的列表作为输入，然后也可以类似List那样进行append和extend操作:

net = nn.ModuleList([nn.Linear(784, 256), nn.ReLU()])
net.append(nn.Linear(256, 10)) # # 类似List的append操作
print(net[-1])  # 类似List的索引访问
print(net)

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

    def forward(self, x):
        # ModuleList can act as an iterable, or be indexed using ints
        for i, l in enumerate(self.linears):
            x = self.linears[i // 2](x) + l(x)
        return x

class Module_ModuleList(nn.Module):
    def __init__(self):
        super(Module_ModuleList, self).__init__()
        self.linears = nn.ModuleList([nn.Linear(10, 10)])
    
class Module_List(nn.Module):
    def __init__(self):
        super(Module_List, self).__init__()
        self.linears = [nn.Linear(10, 10)]

#注意ModuleList和普通List的区别
net1 = Module_ModuleList()
net2 = Module_List()

print("net1:")
for p in net1.parameters():
    print(p.size())

print("net2:")
for p in net2.parameters():
    print(p)

 

• ModuleDict类

ModuleDict接收一个⼦模块的字典作为输入, 然后也可以类似字典那样进行添加访问操作:

net = nn.ModuleDict({
    'linear': nn.Linear(784, 256),
    'act': nn.ReLU(),
})
net['output'] = nn.Linear(256, 10) # 添加
print(net['linear']) # 访问
print(net.output) #访问
print(net)

 

3. 构造复杂的模型

虽然上⾯介绍的这些类可以使模型构造更加简单，且不需要定义forward函数，但直接继承Module类可以极⼤地拓展模型构造的灵活性。下⾯我们构造⼀个稍微复杂点的⽹络FancyMLP。在这个⽹络中，我们通过get_constant函数创建训练中不被迭代的参数，即常数参数. 在前向计算中，除了使⽤创建的常数参数外，我们还使⽤Tensor的函数和Python的控制流，并多次调用相同的层。

class FancyMLP(nn.Module):
    def __init__(self, **kwargs):
        super(FancyMLP, self).__init__(**kwargs)
        
        self.rand_weight = torch.rand((20, 20), requires_grad=False) # 不可训练参数（常数参数）
        self.linear = nn.Linear(20, 20)

    def forward(self, x):
        x = self.linear(x)
        # 使用创建的常数参数，以及nn.functional中的relu函数和mm函数
        x = nn.functional.relu(torch.mm(x, self.rand_weight.data) + 1)
        
        # 复用全连接层。等价于两个全连接层共享参数
        x = self.linear(x)
        # 控制流，这里我们需要调用item函数来返回标量进行比较
        while x.norm().item() > 1:
            x /= 2
        if x.norm().item() < 0.8:
            x *= 10
        return x.sum()

在这个FancyMLP模型中，我们使用了常数权重rand_weight（注意它不是可训练模型参数）、做了矩阵乘法操作(torch.mm)并重复使用了相同的Linear层。下⾯我们来测试该模型的前向计算。􏰀 

X = torch.rand(2, 20) #(batch_size,features)
net = FancyMLP()
print(net)
net(X)

因为FancyMLP和Sequential类都是Module类的子类，所以我们可以嵌套调用他们。

class NestMLP(nn.Module):
    def __init__(self, **kwargs):
        super(NestMLP, self).__init__(**kwargs)
        self.net = nn.Sequential(nn.Linear(40, 30), nn.ReLU()) 

    def forward(self, x):
        return self.net(x)

net = nn.Sequential(NestMLP(), nn.Linear(30, 20), FancyMLP())

X = torch.rand(2, 40)
print(net)
net(X)

 

4. 小结

1）可以通过继承Module类来构造模型

2）Sequential、ModuleList、ModuleDict类都继承自Module类。

3）虽然Sequential等类可以使模型构造更加简单，但直接继承Module类可以极大地拓展模型构造的灵活性。