4.1 模型构造
我们首先构造 Sequential 实例，然后依次添加两个全连接层。其中第一层输出大小为 256，即输出层单元个数是 10；第二层的输出大小为 10，即输出层单元个数是 10。我们在上一章的其他小节中也使用了 Sequential 类构造模型。这里我们介绍另外一种基于 Block 类的模型构造方法：它让模型构造更加灵活。
4.1.1继承 Block 类来构造模型
Block 类是nn模块里提供的一个模型构造类，我们可以继承它来定义我们想要的模型。下面继承 Block 类构造本节开头提到的多层感知机。这里定义的MLP类重载了 Block 类的__init__和forward函数。它们分别用于创建模型参数和定义前向计算。前向计算也即正向传播。
from mxnet import nd
from mxnet.gluon import nn
class MLP(nn.Block):
# 声明带有模型参数的层，这里我们声明了两个全连接层。
def __init__(self, **kwargs):
# 调用 MLP 父类 Block 的构造函数来进行必要的初始化。这样在构造实例时还可以指定
# 其他函数参数，例如后面章节将介绍的模型参数 params。
super(MLP, self).__init__(**kwargs)
self.hidden = nn.Dense(256, activation='relu') # 隐藏层。
self.output = nn.Dense(10) # 输出层。
# 定义模型的前向计算，即如何根据输入 x 计算返回所需要的模型输出。
def forward(self, x):
return self.output(self.hidden(x))
以上的MLP类中无需定义反向传播函数。系统将通过自动求梯度，从而自动生成反向传播所需要的backward函数。
我们可以实例化MLP类得到模型变量net。下面代码初始化net并传入输入数据x做一次前向计算。其中，net(x)会调用MLP继承自 Block 类的__call__函数，这个函数将调用MLP类定义的forward函数来完成前向计算。
x = nd.random.uniform(shape=(2, 20))
net = MLP()
net.initialize()
net(x)
注意到我们并没有将 Block 类命名为层（Layer）或者模型（Model）之类的名字，这是因为该类是一个可供自由组建的部件。它的子类既可以是一个层（例如 Gluon 提供的Dense类），又可以是一个模型（例如这里定义的 MLP 类），或者是模型的一个部分。我们下面通过两个例子来展示它的灵活性。
4.1.2 Sequential 类继承自 Block 类
我们刚刚提到，Block 类是一个通用的部件。事实上，Sequential 类继承自 Block 类。当模型的前向计算为简单串联各个层的计算时，我们可以通过更加简单的方式定义模型。这正是 Sequential 类的目的：它提供add函数来逐一添加串联的 Block 子类实例，而模型的前向计算就是将这些实例按添加的顺序逐一计算。
下面我们实现一个跟 Sequential 类有相同功能的MySequential类。这或许可以帮助你更加清晰地理解 Sequential 类的工作机制。
class MySequential(nn.Block):
def __init__(self, **kwargs):
super(MySequential, self).__init__(**kwargs)
def add(self, block):
# block 是一个 Block 子类实例，假设它有一个独一无二的名字。我们将它保存在 Block
# 类的成员变量 _children 里，其类型是 OrderedDict。当 MySequential 实例调用
# initialize 函数时，系统会自动对 _children 里所有成员初始化。
self._children[block.name] = block
def forward(self, x):
# OrderedDict 保证会按照成员添加时的顺序遍历成员。
for block in self._children.values():
x = block(x)
return x
我们用 MySequential 类来实现前面描述的MLP类，并使用随机初始化的模型做一次前向计算。
net = MySequential()
net.add(nn.Dense(256, activation='relu'))
net.add(nn.Dense(10))
net.initialize()
net(x)
'''
net = nn.Sequential()
net.add(nn.Dense(256, activation='relu'))
net.add(nn.Dense(10))
net.initialize()
net(x)
'''
可以观察到这里MySequential类的使用跟 Sequential 类的使用没什么区别。
4.1.3 构造复杂的模型
虽然 Sequential 类可以使得模型构造更加简单，且不需要定义forward函数，但直接继承 Block 类可以极大地拓展模型构造的灵活性。下面我们构造一个稍微复杂点的网络FancyMLP。在这个网络中，我们通过get_constant函数创建训练中不被迭代的参数，即常数参数。在前向计算中，除了使用创建的常数参数外，我们还使用 NDArray 的函数和 Python 的控制流，并多次调用相同的层。
class FancyMLP(nn.Block):
def __init__(self, **kwargs):
super(FancyMLP, self).__init__(**kwargs)
# 使用 get_constant 创建的随机权重参数不会在训练中被迭代（即常数参数）。
self.rand_weight = self.params.get_constant(
'rand_weight', nd.random.uniform(shape=(20, 20)))
self.dense = nn.Dense(20, activation='relu')
def forward(self, x):
x = self.dense(x)
# 使用创建的常数参数，以及 NDArray 的 relu 和 dot 函数。
x = nd.relu(nd.dot(x, self.rand_weight.data()) + 1)
# 重用全连接层。等价于两个全连接层共享参数。
x = self.dense(x)
# 控制流，这里我们需要调用 asscalar 来返回标量进行比较。
while x.norm().asscalar() > 1:
x /= 2
if x.norm().asscalar() < 0.8:
x *= 10
return x.sum()
在这个FancyMLP模型中，我们使用了常数权重rand_weight（注意它不是模型参数）、做了矩阵乘法操作（nd.dot）并重复使用了相同的Dense层。下面我们来测试该模型的随机初始化和前向计算。
net = FancyMLP()
net.initialize()
net(x)
由于FancyMLP和 Sequential 类都是 Block 类的子类，我们可以嵌套调用它们。
class NestMLP(nn.Block):
def __init__(self, **kwargs):
super(NestMLP, self).__init__(**kwargs)
self.net = nn.Sequential()
self.net.add(nn.Dense(64, activation='relu'),
nn.Dense(32, activation='relu'))
self.dense = nn.Dense(16, activation='relu')
def forward(self, x):
return self.dense(self.net(x))
net = nn.Sequential()
net.add(NestMLP(), nn.Dense(20), FancyMLP())
net.initialize()
net(x)
4.1.4 小结
- 我们可以通过继承 Block 类来构造模型。
- Sequential 类继承自 Block 类。
- 虽然 Sequential 类可以使得模型构造更加简单，但直接继承 Block 类可以极大地拓展模型构造的灵活性。
4.1.5 练习
- 如果不在
MLP类的__init__函数里调用父类的__init__函数，会出现什么样的错误信息？ - 如果去掉
FancyMLP类里面的asscalar函数，会有什么问题？ - 如果将
NestMLP类中通过 Sequential 实例定义的self.net改为self.net = [nn.Dense(64, activation='relu'), nn.Dense(32, activation='relu')]，会有什么问题？