模型构造

《动手学深度学习pytorch》部分学习笔记，仅用作自己复习。

模型构造

（多层感知机的简洁实现）中含单隐藏层的多层感知机的实现方法。

首先构造 Sequential 实例，然后依次添加两个全连接层。其中第⼀层的输出⼤小为256，即隐藏层单元个数是256；第二层的输出⼤小为10，即输出层单元个数是10。这⾥我们介绍另外⼀种基于 Module 类的模型构造方法：它让模型构造更加灵活。

继承 MODULE 类来构造模型

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

import torch
from torch import nn
class MLP(nn.Module):
# 声明带有模型参数的层，这⾥声明了两个全连接层
    def __init__(self, **kwargs):
        # 调用MLP⽗类Block的构造函数来进⾏必要的初始化。这样在构造实例时还可以指定其他函数
        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)

 输出：

MLP(
(hidden): Linear(in_features=784, out_features=256, bias=True)
(act): ReLU()
(output): Linear(in_features=256, out_features=10, bias=True)
)
tensor([[-0.1798, -0.2253, 0.0206, -0.1067, -0.0889, 0.1818,
-0.1474, 0.1845,
-0.1870, 0.1970],
[-0.1843, -0.1562, -0.0090, 0.0351, -0.1538, 0.0992,
-0.0883, 0.0911,
-0.2293, 0.2360]], grad_fn=<ThAddmmBackward>)

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

MODULE 的子类

Module 类是⼀个通用的部件。事实上，PyTorch还实现了继承自 Module 的可以⽅便构建模型的类: 如 Sequential 、 ModuleList 和 ModuleDict 等等。

Sequential 类

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

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(
(0): Linear(in_features=784, out_features=256, bias=True)
(1): ReLU()
(2): Linear(in_features=256, out_features=10, bias=True)
)
tensor([[-0.0100, -0.2516, 0.0392, -0.1684, -0.0937, 0.2191,
-0.1448, 0.0930,
0.1228, -0.2540],
[-0.1086, -0.1858, 0.0203, -0.2051, -0.1404, 0.2738,
-0.0607, 0.0622,
0.0817, -0.2574]], grad_fn=<ThAddmmBackward>)

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)

输出：Linear(in_features=256, out_features=10, bias=True)
ModuleList(
(0): Linear(in_features=784, out_features=256, bias=True)
(1): ReLU()
(2): Linear(in_features=256, out_features=10, bias=True)
)

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)

输出：

Linear(in_features=784, out_features=256, bias=True)
Linear(in_features=256, out_features=10, bias=True)
ModuleDict(
(act): ReLU()
(linear): Linear(in_features=784, out_features=256, bias=True)
(output): Linear(in_features=256, out_features=10, bias=True)
)

构造复杂的模型

上⾯介绍的这些类可以使模型构造更加简单，且不需要定义 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)
net = FancyMLP()
print(net)
net(X)

输出：

FancyMLP(
(linear): Linear(in_features=20, out_features=20, bias=True)
)
tensor(0.8432, grad_fn=<SumBackward0>)

因为 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)

输出：

Sequential(
(0): NestMLP(
(net): Sequential(
(0): Linear(in_features=40, out_features=30, bias=True)
(1): ReLU()
)
)
(1): Linear(in_features=30, out_features=20, bias=True)
(2): FancyMLP(
(linear): Linear(in_features=20, out_features=20, bias=True)
)
)
tensor(14.4908, grad_fn=<SumBackward0>)

小结

• 可以通过继承 Module 类来构造模型。
• Sequential 、 ModuleList 、 ModuleDict 类都继承自 Module 类。
• 虽然 Sequential 等类可以使模型构造更加简单，但直接继承 Module 类可以极⼤地拓展模型构造的灵活性