5.1 层和块-526互联

为了实现更加复杂的神经网络，我们引入块的概念。块可以描述单个层、由多个层组成的组件或整个网络本身。使用块进行抽象的一个好处是可以将一些块组合成更大的组件，这一过程通常是递归的，如图所示。通过定义代码来按需生成任意复杂度的块，我们可以通过简洁的代码实现复杂的神经网络。

从编程的角度来看，块由类(class)表示。它的任何字类都必须定义一个将其输入转换为输出的前向传播函数，并且必须存储任何必需的参数(注意有些层没有参数，这取决于我们对网络的定义)。

回顾一下多层感知机的代码：

import torch
from torch import nn
from torch.nn import functional as F

net = nn.Sequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))

X = torch.rand(2, 20)
net(X)

在这个例子中，我们创建了nn.Sequential对象的一个实例--net，作为我们的一个Module。这里，net各层的执行顺序是根据传递参数的前后顺序决定的。nn.Sequential是nn.Module的一个子类，这里，nn.Sequential实际上就定义了一种特殊的Module。可以这样理解：Module是抽象的神经网络“块”的概念，而Sequential则是一个个不尽相同的，具体的“块”。nn.Sequential维护了一个由Module组成的有序列表。注意：两个全连接层都是Linear类的实例，Linear类本身就是Module的字类。另外，到目前为止，我们一直在通过net(X)调用我们的模型来获得模型的输出。这实际上是net.__call__(X)的简写。这个前向传播函数非常简单：它将列表中的每个块连接在一起，将每个块的输出作为下一个块的输入。

注意：这里面有语句from torch.nn import functional as F，这里面包含一些函数。比如F.relu，它是ReLU层的函数版本。

想要自己实现一个自定义块，自定义块必须具有以下几个功能：

将输入数据作为其前向传播函数的参数。
通过前向传播函数来生成输出。请注意，输出的形状可能与输入的形状不同。例如，我们上面模型中的第一个全连接的层接收一个20维的输入，但是返回一个维度为256的输出。
计算其输出关于输入的梯度，可通过其反向传播函数进行访问。通常这是自动发生的。
存储和访问前向传播计算所需的参数。
根据需要初始化模型参数。

class MLP(nn.Module):
    # 用模型参数声明层。这里，我们声明两个全连接的层
    def __init__(self):
        # 调用MLP的父类Module的构造函数来执行必要的初始化。
        # 这样，在类实例化时也可以指定其他函数参数，例如模型参数params（稍后将介绍）
        super().__init__()
        self.hidden = nn.Linear(20, 256)  # 隐藏层
        self.out = nn.Linear(256, 10)  # 输出层

    # 定义模型的前向传播，即如何根据输入X返回所需的模型输出
    def forward(self, X):
        # 注意，这里我们使用ReLU的函数版本，其在nn.functional模块中定义。
        return self.out(F.relu(self.hidden(X)))

以上代码片段实现了一个多层感知机。这里面定义的class MLP就是一个多层感知机，也是神经网络中的一个块。一般来说，自定义块需要在class中必须实现两个函数：__init__()以及forward()函数。注意：在python中，任意类中定义的方法都必须包含一个self作为参数。在本例中，如果我们需要两个MLP它们的结构相同但需要不同的参数时，就可以使用上面定义的MLP类来实例化两个不同的对象来用不同的数据进行训练。

现在我们自己实现一个Sequential类。

我们只需要定义两个关键函数：

一种将块逐个追加到列表中的函数；
一种前向传播函数，用于将输入按追加块的顺序传递给块组成的“链条”。

下面的MySequential类提供了与默认Sequential类相同的功能。

class MySequential(nn.Module):
    def __init__(self, *args):
        super().__init__()
        for idx, module in enumerate(args):
            # 这里，module是Module子类的一个实例。我们把它保存在'Module'类的成员
            # 变量_modules中。_module的类型是OrderedDict
            self._modules[str(idx)] = module

    def forward(self, X):
        # OrderedDict保证了按照成员添加的顺序遍历它们
        for block in self._modules.values():
            X = block(X)
        return X

首先，显然Sequential是继承于nn.Module的。在__init__(self,*args)中，可以把*args看成一个由作为参数的各个层组成的列表(*号类似于c中的指针理解),enumerate(args)是创建args的枚举，用法说明如下：

然后，self._modules[str(idx)] = module 是将层的索引的字符串形式作为key，将层作为value创建有序字典。最后forward函数按照层的顺序执行计算，return结果。__init__函数将每个模块逐个添加到有序字典_modules中。读者可能会好奇为什么每个Module都有一个_modules属性？以及为什么我们使用它而不是自己定义一个Python列表？简而言之，_modules的主要优点是：在模块的参数初始化过程中，系统知道在_modules字典中查找需要初始化参数的子块。

到此，我们可以根据自己的需要灵活地定义块。

class FixedHiddenMLP(nn.Module):
    def __init__(self):
        super().__init__()
        # 不计算梯度的随机权重参数。因此其在训练期间保持不变
        self.rand_weight = torch.rand((20, 20), requires_grad=False)
        self.linear = nn.Linear(20, 20)

    def forward(self, X):
        X = self.linear(X)
        # 使用创建的常量参数以及relu和mm函数
        X = F.relu(torch.mm(X, self.rand_weight) + 1)
        # 复用全连接层。这相当于两个全连接层共享参数
        X = self.linear(X)
        # 控制流
        while X.abs().sum() > 1:
            X /= 2
        return X.sum()

class NestMLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.net = nn.Sequential(nn.Linear(20, 64), nn.ReLU(),
                                 nn.Linear(64, 32), nn.ReLU())
        self.linear = nn.Linear(32, 16)

    def forward(self, X):
        return self.linear(self.net(X))

chimera = nn.Sequential(NestMLP(), nn.Linear(16, 20), FixedHiddenMLP())
chimera(X)

centos rocketmq 7.6 5.1