# 4.1 模型構造
讓我們回顧一下在3.10節(多層感知機的簡潔實現)中含單隱藏層的多層感知機的實現方法。我們首先構造`Sequential`實例,然后依次添加兩個全連接層。其中第一層的輸出大小為256,即隱藏層單元個數是256;第二層的輸出大小為10,即輸出層單元個數是10。我們在上一章的其他節中也使用了`Sequential`類構造模型。這里我們介紹另外一種基于`Module`類的模型構造方法:它讓模型構造更加靈活。
> 注:其實前面我們陸陸續續已經使用了這些方法了,本節系統介紹一下。
## 4.1.1 繼承`Module`類來構造模型
`Module`類是`nn`模塊里提供的一個模型構造類,是所有神經網絡模塊的基類,我們可以繼承它來定義我們想要的模型。下面繼承`Module`類構造本節開頭提到的多層感知機。這里定義的`MLP`類重載了`Module`類的`__init__`函數和`forward`函數。它們分別用于創建模型參數和定義前向計算。前向計算也即正向傳播。
``` python
import torch
from torch import nn
class MLP(nn.Module):
# 聲明帶有模型參數的層,這里聲明了兩個全連接層
def __init__(self, **kwargs):
# 調用MLP父類Block的構造函數來進行必要的初始化。這樣在構造實例時還可以指定其他函數
# 參數,如“模型參數的訪問、初始化和共享”一節將介紹的模型參數params
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`函數來完成前向計算。
``` python
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`類),或者是模型的一個部分。我們下面通過兩個例子來展示它的靈活性。
## 4.1.2 `Module`的子類
我們剛剛提到,`Module`類是一個通用的部件。事實上,PyTorch還實現了繼承自`Module`的可以方便構建模型的類: 如`Sequential`、`ModuleList`和`ModuleDict`等等。
### 4.1.2.1 `Sequential`類
當模型的前向計算為簡單串聯各個層的計算時,`Sequential`類可以通過更加簡單的方式定義模型。這正是`Sequential`類的目的:它可以接收一個子模塊的有序字典(OrderedDict)或者一系列子模塊作為參數來逐一添加`Module`的實例,而模型的前向計算就是將這些實例按添加的順序逐一計算。
下面我們實現一個與`Sequential`類有相同功能的`MySequential`類。這或許可以幫助讀者更加清晰地理解`Sequential`類的工作機制。
``` python
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`類,并使用隨機初始化的模型做一次前向計算。
``` python
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>)
```
可以觀察到這里`MySequential`類的使用跟3.10節(多層感知機的簡潔實現)中`Sequential`類的使用沒什么區別。
### 4.1.2.2 `ModuleList`類
`ModuleList`接收一個子模塊的列表作為輸入,然后也可以類似List那樣進行append和extend操作:
``` python
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)
)
```
### 4.1.2.3 `ModuleDict`類
`ModuleDict`接收一個子模塊的字典作為輸入, 然后也可以類似字典那樣進行添加訪問操作:
``` python
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)
)
```
## 4.1.3 構造復雜的模型
雖然上面介紹的這些類可以使模型構造更加簡單,且不需要定義`forward`函數,但直接繼承`Module`類可以極大地拓展模型構造的靈活性。下面我們構造一個稍微復雜點的網絡`FancyMLP`。在這個網絡中,我們通過`get_constant`函數創建訓練中不被迭代的參數,即常數參數。在前向計算中,除了使用創建的常數參數外,我們還使用`Tensor`的函數和Python的控制流,并多次調用相同的層。
``` 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`層。下面我們來測試該模型的前向計算。
``` python
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`類的子類,所以我們可以嵌套調用它們。
``` python
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`類可以極大地拓展模型構造的靈活性。
-----------
> 注:本節與原書此節有一些不同,[原書傳送門](https://zh.d2l.ai/chapter_deep-learning-computation/model-construction.html)
- Home
- Introduce
- 1.深度學習簡介
- 深度學習簡介
- 2.預備知識
- 2.1環境配置
- 2.2數據操作
- 2.3自動求梯度
- 3.深度學習基礎
- 3.1 線性回歸
- 3.2 線性回歸的從零開始實現
- 3.3 線性回歸的簡潔實現
- 3.4 softmax回歸
- 3.5 圖像分類數據集(Fashion-MINST)
- 3.6 softmax回歸的從零開始實現
- 3.7 softmax回歸的簡潔實現
- 3.8 多層感知機
- 3.9 多層感知機的從零開始實現
- 3.10 多層感知機的簡潔實現
- 3.11 模型選擇、反向傳播和計算圖
- 3.12 權重衰減
- 3.13 丟棄法
- 3.14 正向傳播、反向傳播和計算圖
- 3.15 數值穩定性和模型初始化
- 3.16 實戰kaggle比賽:房價預測
- 4 深度學習計算
- 4.1 模型構造
- 4.2 模型參數的訪問、初始化和共享
- 4.3 模型參數的延后初始化
- 4.4 自定義層
- 4.5 讀取和存儲
- 4.6 GPU計算
- 5 卷積神經網絡
- 5.1 二維卷積層
- 5.2 填充和步幅
- 5.3 多輸入通道和多輸出通道
- 5.4 池化層
- 5.5 卷積神經網絡(LeNet)
- 5.6 深度卷積神經網絡(AlexNet)
- 5.7 使用重復元素的網絡(VGG)
- 5.8 網絡中的網絡(NiN)
- 5.9 含并行連結的網絡(GoogLeNet)
- 5.10 批量歸一化
- 5.11 殘差網絡(ResNet)
- 5.12 稠密連接網絡(DenseNet)
- 6 循環神經網絡
- 6.1 語言模型
- 6.2 循環神經網絡
- 6.3 語言模型數據集(周杰倫專輯歌詞)
- 6.4 循環神經網絡的從零開始實現
- 6.5 循環神經網絡的簡單實現
- 6.6 通過時間反向傳播
- 6.7 門控循環單元(GRU)
- 6.8 長短期記憶(LSTM)
- 6.9 深度循環神經網絡
- 6.10 雙向循環神經網絡
- 7 優化算法
- 7.1 優化與深度學習
- 7.2 梯度下降和隨機梯度下降
- 7.3 小批量隨機梯度下降
- 7.4 動量法
- 7.5 AdaGrad算法
- 7.6 RMSProp算法
- 7.7 AdaDelta
- 7.8 Adam算法
- 8 計算性能
- 8.1 命令式和符號式混合編程
- 8.2 異步計算
- 8.3 自動并行計算
- 8.4 多GPU計算
- 9 計算機視覺
- 9.1 圖像增廣
- 9.2 微調
- 9.3 目標檢測和邊界框
- 9.4 錨框
- 10 自然語言處理
- 10.1 詞嵌入(word2vec)
- 10.2 近似訓練
- 10.3 word2vec實現
- 10.4 子詞嵌入(fastText)
- 10.5 全局向量的詞嵌入(Glove)
- 10.6 求近義詞和類比詞
- 10.7 文本情感分類:使用循環神經網絡
- 10.8 文本情感分類:使用卷積網絡
- 10.9 編碼器--解碼器(seq2seq)
- 10.10 束搜索
- 10.11 注意力機制
- 10.12 機器翻譯