上節用了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)
其中，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)
構造復雜的模型
雖然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)>