上节用了Sequential类来构造模型。这里我们另外一种基于Block类的模型构造方法，它让构造模型更加灵活，也将让你能更好的理解Sequential的运行机制。
回顾：
- 序列模型生成
- 层填充
- 初始化模型参数
net = gluon.nn.Sequential()
with net.name_scope():
net.add(gluon.nn.Dense(1))
net.collect_params().initialize(mx.init.Normal(sigma=1)) # 模型参数初始化选择normal分布
两点讲解：
super(MLP, self).__init__(**kwargs)：调用nn.Block的__init__，提供了prefix（指定名称）和params（指定参数）两个参数。
self.name_scope()：调用nn.Block的name_scope，给域内层、参数名加上前缀prefix，和TensorFlow类似
继承Block类来构造模型
- 存储参数
- 定义向前传播如何进行
- 自动求导
Block类是gluon.nn里提供的一个模型构造类，我们可以继承它来定义我们想要的模型。例如，我们在这里构造一个同前提到的相同的多层感知机。这里定义的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)
# 定义模型的前向计算，即如何根据输出计算输出。
def forward(self, x):
return self.output(self.hidden(x))
建立之后进行forward测试，
x = nd.random.uniform(shape=(2,20))
net = MLP()
net.initialize()
net(x)
[[ 0.09543004 0.04614332 -0.00286654 -0.07790349 -0.05130243 0.02942037
0.08696642 -0.0190793 -0.04122177 0.05088576]
[ 0.0769287 0.03099705 0.00856576 -0.04467199 -0.06926839 0.09132434
0.06786595 -0.06187842 -0.03436673 0.04234694]]
<NDArray 2x10 @cpu(0)>
其中，net(x)会调用了MLP继承至Block的__call__函数，这个函数将调用MLP定义的forward函数来完成前向计算。
我们无需在这里定义反向传播函数，系统将通过自动求导，来自动生成backward函数。
注意到我们不是将Block叫做层或者模型之类的名字，这是因为它是一个可以*组建的部件。它的子类既可以一个层，例如Gluon提供的Dense类，也可以是一个模型，我们定义的MLP类，或者是模型的一个部分，例如ResNet的残差块。我们下面通过两个例子说明它。
Sequential：Block的容器
Sequential类继承自Block类，实质来说就是将初始化各个层的过程从__init__移到了add方法中。
当模型的前向计算就是简单串行计算模型里面各个层的时候，我们可以将模型定义变得更加简单，这个就是Sequential类的目的，它通过add函数来添加Block子类实例，前向计算时就是将添加的实例逐一运行。下面我们实现一个跟Sequential类有相同功能的类，这样你可以看的更加清楚它的运行机制。
class MySequential(nn.Block):
def __init__(self, **kwargs):
super(MySequential, self).__init__(**kwargs) def add(self, block):
# block 是一个 Block 子类实例，假设它有一个独一无二的名字。我们将它保存在
# Block 类的成员变量 _children 里，其类型是 OrderedDict. 当调用
# initialize 函数时，系统会自动对 _children 里面所有成员初始化。
self._children[block.name] = block def forward(self, x):
# OrderedDict 保证会按照插入时的顺序遍历元素。
for block in self._children.values():
x = block(x)
return
我们用MySequential类来实现MLP类：
net = MySequential()
net.add(nn.Dense(256, activation='relu'))
net.add(nn.Dense(10))
net.initialize()
net(x)
[[ 0.00362228 0.00633332 0.03201144 -0.01369375 0.10336449 -0.03508018
-0.00032164 -0.01676023 0.06978628 0.01303309]
[ 0.03871715 0.02608213 0.03544959 -0.02521311 0.11005433 -0.0143066
-0.03052466 -0.03852827 0.06321152 0.0038594 ]]
<NDArray 2x10 @cpu(0)>
构造复杂的模型
虽然Sequential类可以使得模型构造更加简单，不需要定义forward函数，但直接继承Block类可以极大的拓展灵活性。下面我们构造一个稍微复杂点的网络：
- 在前向计算中使用了NDArray函数和Python的控制流：forward函数内部是*发挥的舞台
- 多次调用同一层
class FancyMLP(nn.Block):
def __init__(self, **kwargs):
super(FancyMLP, self).__init__(**kwargs)
# 不会被更新的随机权重。
self.rand_weight = nd.random.uniform(shape=(20, 20))
self.dense = nn.Dense(20, activation='relu') def forward(self, x):
x = self.dense(x)
# 使用了 nd 包下 relu 和 dot 函数。
x = nd.relu(nd.dot(x, self.rand_weight) + 1)
# 重用了 dense，等价于两层网络但共享了参数。
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)
[ 18.57195282]
<NDArray 1 @cpu(0)>
由于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)
[ 24.86621094]
<NDArray 1 @cpu(0)>