深度學(xué)習(xí)計(jì)算

在本章中，我們將深入探索深度學(xué)習(xí)計(jì)算的關(guān)鍵組件， 即模型構(gòu)建、參數(shù)訪問與初始化、設(shè)計(jì)自定義層和塊、將模型讀寫到磁盤， 以及利用GPU實(shí)現(xiàn)顯著的加速。

層和塊

像單個神經(jīng)元一樣，層（1）接受一組輸入， （2）生成相應(yīng)的輸出， （3）由一組可調(diào)整參數(shù)描述。 當(dāng)我們使用softmax回歸時(shí)，一個單層本身就是模型。然而，即使我們隨后引入了多層感知機(jī)，我們?nèi)匀豢梢哉J(rèn)為該模型保留了上面所說的基本架構(gòu)。

對于多層感知機(jī)而言，整個模型及其組成層都是這種架構(gòu)。 整個模型接受原始輸入（特征），生成輸出（預(yù)測）， 并包含一些參數(shù)（所有組成層的參數(shù)集合）。 同樣，每個單獨(dú)的層接收輸入（由前一層提供）， 生成輸出（到下一層的輸入），并且具有一組可調(diào)參數(shù)， 這些參數(shù)根據(jù)從下一層反向傳播的信號進(jìn)行更新。

當(dāng)需要實(shí)現(xiàn)一些復(fù)雜的網(wǎng)絡(luò)時(shí)，我們引入了神經(jīng)網(wǎng)絡(luò)塊的概念。 塊（block）可以描述單個層、由多個層組成的組件或整個模型本身。 使用塊進(jìn)行抽象的一個好處是可以將一些塊組合成更大的組件， 這一過程通常是遞歸的，如下圖所示。 通過定義代碼來按需生成任意復(fù)雜度的塊， 我們可以通過簡潔的代碼實(shí)現(xiàn)復(fù)雜的神經(jīng)網(wǎng)絡(luò)。

從編程的角度來看，塊由類（class）表示。 它的任何子類都必須定義一個將其輸入轉(zhuǎn)換為輸出的前向傳播函數(shù)， 并且必須存儲任何必需的參數(shù)。 注意，有些塊不需要任何參數(shù)。 最后，為了計(jì)算梯度，塊必須具有反向傳播函數(shù)。 在定義我們自己的塊時(shí)，由于自動微分提供了一些后端實(shí)現(xiàn)，我們只需要考慮前向傳播函數(shù)和必需的參數(shù)。

在構(gòu)造自定義塊之前，我們先回顧一下多層感知機(jī)的代碼。 下面的代碼生成一個網(wǎng)絡(luò)，其中包含一個具有256個單元和ReLU激活函數(shù)的全連接隱藏層， 然后是一個具有10個隱藏單元且不帶激活函數(shù)的全連接輸出層。

# 「定義一個含兩個全連接層+ReLU 的小網(wǎng)絡(luò) → 隨機(jī)生成 2 個 20 維樣本 → 做一次前向傳播 → 輸出 2×10 的 logits」的最小可運(yùn)行示例
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)
'''
tensor([[-0.1067,  0.2351, -0.1454,  0.0216,  0.0842, -0.0987, -0.0144, -0.1682,
          0.0462,  0.1336],
        [-0.1372,  0.2648, -0.1314,  0.0452,  0.2417, -0.1952, -0.0562, -0.1829,
          0.0900,  0.0544]], grad_fn=<AddmmBackward0>)
'''

在這個例子中，我們通過實(shí)例化nn.Sequential來構(gòu)建我們的模型， 層的執(zhí)行順序是作為參數(shù)傳遞的。 簡而言之，nn.Sequential定義了一種特殊的Module， 即在PyTorch中表示一個塊的類， 它維護(hù)了一個由Module組成的有序列表。 注意，兩個全連接層都是Linear類的實(shí)例， Linear類本身就是Module的子類。 另外，到目前為止，我們一直在通過net(X)調(diào)用我們的模型來獲得模型的輸出。 這實(shí)際上是net.call(X)的簡寫。 這個前向傳播函數(shù)非常簡單： 它將列表中的每個塊連接在一起，將每個塊的輸出作為下一個塊的輸入。

自定義塊

要想直觀地了解塊是如何工作的，最簡單的方法就是自己實(shí)現(xiàn)一個。 在實(shí)現(xiàn)我們自定義塊之前，我們簡要總結(jié)一下每個塊必須提供的基本功能。

• 將輸入數(shù)據(jù)作為其前向傳播函數(shù)的參數(shù)。
• 通過前向傳播函數(shù)來生成輸出。請注意，輸出的形狀可能與輸入的形狀不同。例如，我們上面模型中的第一個全連接的層接收一個20維的輸入，但是返回一個維度為256的輸出。
• 計(jì)算其輸出關(guān)于輸入的梯度，可通過其反向傳播函數(shù)進(jìn)行訪問。通常這是自動發(fā)生的。
• 存儲和訪問前向傳播計(jì)算所需的參數(shù)。
• 根據(jù)需要初始化模型參數(shù)。

在下面的代碼片段中，我們從零開始編寫一個塊。 它包含一個多層感知機(jī)，其具有256個隱藏單元的隱藏層和一個10維輸出層。 注意，下面的MLP類繼承了表示塊的類。 我們的實(shí)現(xiàn)只需要提供我們自己的構(gòu)造函數(shù)（Python中的init函數(shù)）和前向傳播函數(shù)。

class MLP(nn.Module):
    # 用模型參數(shù)聲明層。這里，我們聲明兩個全連接的層
    def __init__(self):
        # 調(diào)用MLP的父類Module的構(gòu)造函數(shù)來執(zhí)行必要的初始化。
        # 這樣，在類實(shí)例化時(shí)也可以指定其他函數(shù)參數(shù)，例如模型參數(shù)params（稍后將介紹）
        super().__init__()
        self.hidden = nn.Linear(20, 256)  # 隱藏層
        self.out = nn.Linear(256, 10)  # 輸出層

    # 定義模型的前向傳播，即如何根據(jù)輸入X返回所需的模型輸出
    def forward(self, X):
        # 注意，這里我們使用ReLU的函數(shù)版本，其在nn.functional模塊中定義。
        return self.out(F.relu(self.hidden(X)))

我們首先看一下前向傳播函數(shù)，它以X作為輸入， 計(jì)算帶有激活函數(shù)的隱藏表示，并輸出其未規(guī)范化的輸出值。 在這個MLP實(shí)現(xiàn)中，兩個層都是實(shí)例變量。 要了解這為什么是合理的，可以想象實(shí)例化兩個多層感知機(jī)（net1和net2）， 并根據(jù)不同的數(shù)據(jù)對它們進(jìn)行訓(xùn)練。 當(dāng)然，我們希望它們學(xué)到兩種不同的模型。

接著我們實(shí)例化多層感知機(jī)的層，然后在每次調(diào)用前向傳播函數(shù)時(shí)調(diào)用這些層。 注意一些關(guān)鍵細(xì)節(jié)： 首先，我們定制的init函數(shù)通過super().init() 調(diào)用父類的init函數(shù)， 省去了重復(fù)編寫模版代碼的痛苦。 然后，我們實(shí)例化兩個全連接層， 分別為self.hidden和self.out。 注意，除非我們實(shí)現(xiàn)一個新的運(yùn)算符， 否則我們不必?fù)?dān)心反向傳播函數(shù)或參數(shù)初始化， 系統(tǒng)將自動生成這些。

接下來試下這個函數(shù)

net = MLP()
net(X)
'''
tensor([[ 0.1762, -0.1024, -0.0963,  0.1281,  0.3588,  0.1181, -0.0168, -0.0465,
         -0.0842, -0.0973],
        [ 0.1337, -0.0943,  0.0878,  0.1318,  0.3186,  0.0734,  0.0488,  0.0186,
         -0.0229, -0.1116]], grad_fn=<AddmmBackward0>)
'''

塊的一個主要優(yōu)點(diǎn)是它的多功能性。 我們可以子類化塊以創(chuàng)建層（如全連接層的類）、 整個模型（如上面的MLP類）或具有中等復(fù)雜度的各種組件。 我們在接下來的章節(jié)中充分利用了這種多功能性， 比如在處理卷積神經(jīng)網(wǎng)絡(luò)時(shí)。

順序塊

現(xiàn)在我們可以更仔細(xì)地看看Sequential類是如何工作的， 回想一下Sequential的設(shè)計(jì)是為了把其他模塊串起來。 為了構(gòu)建我們自己的簡化的MySequential， 我們只需要定義兩個關(guān)鍵函數(shù)：

• 一種將塊逐個追加到列表中的函數(shù)；
• 一種前向傳播函數(shù)，用于將輸入按追加塊的順序傳遞給塊組成的“鏈條”。

下面的MySequential類提供了與默認(rèn)Sequential類相同的功能。

class MySequential(nn.Module):
    def __init__(self, *args):
        super().__init__()
        for idx, module in enumerate(args):
            # 這里，module是Module子類的一個實(shí)例。我們把它保存在'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

init函數(shù)將每個模塊逐個添加到有序字典_modules中。 讀者可能會好奇為什么每個Module都有一個_modules屬性？ 以及為什么我們使用它而不是自己定義一個Python列表？ 簡而言之，_modules的主要優(yōu)點(diǎn)是： 在模塊的參數(shù)初始化過程中， 系統(tǒng)知道在_modules字典中查找需要初始化參數(shù)的子塊

net = MySequential(nn.Linear(20, 256), nn.ReLU(), nn.Linear(256, 10))
net(X)
'''
tensor([[-0.2439,  0.1604, -0.0341, -0.0149, -0.0261, -0.1352, -0.0609, -0.1693,
          0.1219, -0.2360],
        [-0.1812, -0.0134,  0.0823, -0.0604,  0.0849, -0.1797, -0.2004, -0.2821,
          0.1098, -0.3582]], grad_fn=<AddmmBackward0>)
'''

在前向傳播函數(shù)中執(zhí)行代碼

Sequential類使模型構(gòu)造變得簡單， 允許我們組合新的架構(gòu)，而不必定義自己的類。 然而，并不是所有的架構(gòu)都是簡單的順序架構(gòu)。 當(dāng)需要更強(qiáng)的靈活性時(shí)，我們需要定義自己的塊。 例如，我們可能希望在前向傳播函數(shù)中執(zhí)行Python的控制流。 此外，我們可能希望執(zhí)行任意的數(shù)學(xué)運(yùn)算， 而不是簡單地依賴預(yù)定義的神經(jīng)網(wǎng)絡(luò)層。

到目前為止， 我們網(wǎng)絡(luò)中的所有操作都對網(wǎng)絡(luò)的激活值及網(wǎng)絡(luò)的參數(shù)起作用。 然而，有時(shí)我們可能希望合并既不是上一層的結(jié)果也不是可更新參數(shù)的項(xiàng)， 我們稱之為常數(shù)參數(shù)（constant parameter）。 例如，我們需要一個計(jì)算函數(shù)f(x, w) = c · w^?x的層，其中x是輸入，w是參數(shù)，c是某個在優(yōu)化過程中沒有更新的指定常量。 因此我們實(shí)現(xiàn)了一個FixedHiddenMLP類，如下所示：

class FixedHiddenMLP(nn.Module):
    def __init__(self):
        super().__init__()
        # 不計(jì)算梯度的隨機(jī)權(quán)重參數(shù)。因此其在訓(xùn)練期間保持不變
        self.rand_weight = torch.rand((20, 20), requires_grad=False)
        self.linear = nn.Linear(20, 20)

    def forward(self, X):
        X = self.linear(X)
        # 使用創(chuàng)建的常量參數(shù)以及relu和mm函數(shù)
        X = F.relu(torch.mm(X, self.rand_weight) + 1)
        # 復(fù)用全連接層。這相當(dāng)于兩個全連接層共享參數(shù)
        X = self.linear(X)
        # 控制流
        while X.abs().sum() > 1:
            X /= 2
        return X.sum()

在這個FixedHiddenMLP模型中，我們實(shí)現(xiàn)了一個隱藏層， 其權(quán)重（self.rand_weight）在實(shí)例化時(shí)被隨機(jī)初始化，之后為常量。 這個權(quán)重不是一個模型參數(shù)，因此它永遠(yuǎn)不會被反向傳播更新。 然后，神經(jīng)網(wǎng)絡(luò)將這個固定層的輸出通過一個全連接層。

注意，在返回輸出之前，模型做了一些不尋常的事情：它運(yùn)行了一個while循環(huán)，在L1范數(shù)大于1的條件下，將輸出向量除以2，直到它滿足條件為止。最后，模型返回了X中所有項(xiàng)的和。注意，此操作可能不會常用于在任何實(shí)際任務(wù)中，我們只展示如何將任意代碼集成到神經(jīng)網(wǎng)絡(luò)計(jì)算的流程中。

net = FixedHiddenMLP()
net(X)
# tensor(0.2922, grad_fn=<SumBackward0>)

我們可以混合搭配各種組合塊的方法。在下面的例子中，我們以一些想到的方法嵌套塊。

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)
# tensor(0.2873, grad_fn=<SumBackward0>)

參數(shù)管理

在選擇了架構(gòu)并設(shè)置了超參數(shù)后，我們就進(jìn)入了訓(xùn)練階段。 此時(shí)，我們的目標(biāo)是找到使損失函數(shù)最小化的模型參數(shù)值。 經(jīng)過訓(xùn)練后，我們將需要使用這些參數(shù)來做出未來的預(yù)測。 此外，有時(shí)我們希望提取參數(shù)，以便在其他環(huán)境中復(fù)用它們， 將模型保存下來，以便它可以在其他軟件中執(zhí)行， 或者為了獲得科學(xué)的理解而進(jìn)行檢查。

這里將介紹以下內(nèi)容：

• 訪問參數(shù)，用于調(diào)試、診斷和可視化；
• 參數(shù)初始化；
• 在不同模型組件間共享參數(shù)。

import torch
from torch import nn

net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(), nn.Linear(8, 1))
X = torch.rand(size=(2, 4))
net(X)
'''
tensor([[-0.5180],
        [-0.5211]], grad_fn=<AddmmBackward0>)
'''

參數(shù)訪問

我們從已有模型中訪問參數(shù)。 當(dāng)通過Sequential類定義模型時(shí)， 我們可以通過索引來訪問模型的任意層。 這就像模型是一個列表一樣，每層的參數(shù)都在其屬性中。 如下所示，我們可以檢查第二個全連接層的參數(shù)。

print(net[2].state_dict())
# OrderedDict([('weight', tensor([[-0.1256,  0.0701,  0.0108, -0.3421, -0.3468,  0.1571,  0.3103,  0.0180]])), ('bias', tensor([-0.2251]))])

輸出的結(jié)果告訴我們一些重要的事情： 首先，這個全連接層包含兩個參數(shù)，分別是該層的權(quán)重和偏置。 兩者都存儲為單精度浮點(diǎn)數(shù)（float32）。 注意，參數(shù)名稱允許唯一標(biāo)識每個參數(shù)，即使在包含數(shù)百個層的網(wǎng)絡(luò)中也是如此。

目標(biāo)參數(shù)

注意，每個參數(shù)都表示為參數(shù)類的一個實(shí)例。 要對參數(shù)執(zhí)行任何操作，首先我們需要訪問底層的數(shù)值。 有幾種方法可以做到這一點(diǎn)。有些比較簡單，而另一些則比較通用。 下面的代碼從第二個全連接層（即第三個神經(jīng)網(wǎng)絡(luò)層）提取偏置， 提取后返回的是一個參數(shù)類實(shí)例，并進(jìn)一步訪問該參數(shù)的值。

print(type(net[2].bias))
print(net[2].bias)
print(net[2].bias.data)

print(net[2].weight)
print(net[2].weight.data)
print(net[2].weight.data[0][2])
'''
<class 'torch.nn.parameter.Parameter'>
Parameter containing:
tensor([-0.2251], requires_grad=True)
tensor([-0.2251])
Parameter containing:
tensor([[-0.1256,  0.0701,  0.0108, -0.3421, -0.3468,  0.1571,  0.3103,  0.0180]],
       requires_grad=True)
tensor([[-0.1256,  0.0701,  0.0108, -0.3421, -0.3468,  0.1571,  0.3103,  0.0180]])
tensor(0.0108)
'''

參數(shù)是復(fù)合的對象，包含值、梯度和額外信息。 這就是我們需要顯式參數(shù)值的原因。 除了值之外，我們還可以訪問每個參數(shù)的梯度。 在上面這個網(wǎng)絡(luò)中，由于我們還沒有調(diào)用反向傳播，所以參數(shù)的梯度處于初始狀態(tài)。

net[2].weight.grad == None

一次性訪問所有參數(shù)

當(dāng)我們需要對所有參數(shù)執(zhí)行操作時(shí)，逐個訪問它們可能會很麻煩。 當(dāng)我們處理更復(fù)雜的塊（例如，嵌套塊）時(shí)，情況可能會變得特別復(fù)雜， 因?yàn)槲覀冃枰f歸整個樹來提取每個子塊的參數(shù)。 下面，我們將通過演示來比較訪問第一個全連接層的參數(shù)和訪問所有層。

print(*[(name, param.shape) for name, param in net[0].named_parameters()])
print(*[(name, param.shape) for name, param in net.named_parameters()])
'''
('weight', torch.Size([8, 4])) ('bias', torch.Size([8]))
('0.weight', torch.Size([8, 4])) ('0.bias', torch.Size([8])) ('2.weight', torch.Size([1, 8])) ('2.bias', torch.Size([1]))
'''

這為我們提供了另一種訪問網(wǎng)絡(luò)參數(shù)的方式，如下所示。

net.state_dict()['2.bias'].data
# tensor([0.0887])

從嵌套塊收集參數(shù)

讓我們看看，如果我們將多個塊相互嵌套，參數(shù)命名約定是如何工作的。 我們首先定義一個生成塊的函數(shù)（可以說是“塊工廠”），然后將這些塊組合到更大的塊中。

def block1():
    return nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
                         nn.Linear(8, 4), nn.ReLU())

def block2():
    net = nn.Sequential()
    for i in range(4):
        # 在這里嵌套
        net.add_module(f'block {i}', block1())
    return net

rgnet = nn.Sequential(block2(), nn.Linear(4, 1))
rgnet(X)

設(shè)計(jì)了網(wǎng)絡(luò)后，我們看看它是如何工作的。

print(rgnet)
'''
Sequential(
  (0): Sequential(
    (block 0): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 1): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 2): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
    (block 3): Sequential(
      (0): Linear(in_features=4, out_features=8, bias=True)
      (1): ReLU()
      (2): Linear(in_features=8, out_features=4, bias=True)
      (3): ReLU()
    )
  )
  (1): Linear(in_features=4, out_features=1, bias=True)
)
'''

因?yàn)閷邮欠謱忧短椎模晕覀円部梢韵裢ㄟ^嵌套列表索引一樣訪問它們。 下面，我們訪問第一個主要的塊中、第二個子塊的第一層的偏置項(xiàng)。

rgnet[0][1][0].bias.data
# tensor([-0.4028, -0.4251, -0.2090,  0.2053,  0.1827, -0.2417,  0.0879,  0.4059])

參數(shù)初始化

知道了如何訪問參數(shù)后，現(xiàn)在我們看看如何正確地初始化參數(shù)。 前面討論了良好初始化的必要性。深度學(xué)習(xí)框架提供默認(rèn)隨機(jī)初始化， 也允許我們創(chuàng)建自定義初始化方法， 滿足我們通過其他規(guī)則實(shí)現(xiàn)初始化權(quán)重。

默認(rèn)情況下，PyTorch會根據(jù)一個范圍均勻地初始化權(quán)重和偏置矩陣， 這個范圍是根據(jù)輸入和輸出維度計(jì)算出的。 PyTorch的nn.init模塊提供了多種預(yù)置初始化方法。

內(nèi)置初始化

讓我們首先調(diào)用內(nèi)置的初始化器。 下面的代碼將所有權(quán)重參數(shù)初始化為標(biāo)準(zhǔn)差為0.01的高斯隨機(jī)變量， 且將偏置參數(shù)設(shè)置為0。

def init_normal(m):
    if type(m) == nn.Linear:
        nn.init.normal_(m.weight, mean=0, std=0.01)
        nn.init.zeros_(m.bias)
net.apply(init_normal)
net[0].weight.data[0], net[0].bias.data[0]
# (tensor([ 9.7243e-05,  1.8666e-04,  2.0942e-03, -1.7281e-02]), tensor(0.))

我們還可以將所有參數(shù)初始化為給定的常數(shù)，比如初始化為1。

def init_constant(m):
    if type(m) == nn.Linear:
        nn.init.constant_(m.weight, 1)
        nn.init.zeros_(m.bias)
net.apply(init_constant)
net[0].weight.data[0], net[0].bias.data[0]
# (tensor([1., 1., 1., 1.]), tensor(0.))

我們還可以對某些塊應(yīng)用不同的初始化方法。 例如，下面我們使用Xavier初始化方法初始化第一個神經(jīng)網(wǎng)絡(luò)層， 然后將第三個神經(jīng)網(wǎng)絡(luò)層初始化為常量值42。

def init_xavier(m):
    if type(m) == nn.Linear:
        nn.init.xavier_uniform_(m.weight)
def init_42(m):
    if type(m) == nn.Linear:
        nn.init.constant_(m.weight, 42)

net[0].apply(init_xavier)
net[2].apply(init_42)
print(net[0].weight.data[0])
print(net[2].weight.data)
'''
tensor([ 0.5236,  0.0516, -0.3236,  0.3794])
tensor([[42., 42., 42., 42., 42., 42., 42., 42.]])
'''

自定義初始化

有時(shí)，深度學(xué)習(xí)框架沒有提供我們需要的初始化方法。 在下面的例子中，我們使用以下的分布為任意權(quán)重參數(shù)w定義初始化方法：

同樣，我們實(shí)現(xiàn)了一個my_init函數(shù)來應(yīng)用到net。

def my_init(m):
    if type(m) == nn.Linear:
        print("Init", *[(name, param.shape)
                        for name, param in m.named_parameters()][0])
        nn.init.uniform_(m.weight, -10, 10)
        m.weight.data *= m.weight.data.abs() >= 5

net.apply(my_init)
net[0].weight[:2]
'''
Init weight torch.Size([8, 4])
Init weight torch.Size([1, 8])
tensor([[ 0.0000,  9.5789,  7.8072, -7.4221],
        [-0.0000, -6.3111, -0.0000, -0.0000]], grad_fn=<SliceBackward0>)
'''

注意，我們始終可以直接設(shè)置參數(shù)。

net[0].weight.data[:] += 1
net[0].weight.data[0, 0] = 42
net[0].weight.data[0]
# tensor([42.0000, 10.3334,  6.0616,  9.3095])

參數(shù)綁定

有時(shí)我們希望在多個層間共享參數(shù)： 我們可以定義一個稠密層，然后使用它的參數(shù)來設(shè)置另一個層的參數(shù)。

# 我們需要給共享層一個名稱，以便可以引用它的參數(shù)
shared = nn.Linear(8, 8)
net = nn.Sequential(nn.Linear(4, 8), nn.ReLU(),
                    shared, nn.ReLU(),
                    shared, nn.ReLU(),
                    nn.Linear(8, 1))
net(X)
# 檢查參數(shù)是否相同
print(net[2].weight.data[0] == net[4].weight.data[0])
net[2].weight.data[0, 0] = 100
# 確保它們實(shí)際上是同一個對象，而不只是有相同的值
print(net[2].weight.data[0] == net[4].weight.data[0])
'''
tensor([True, True, True, True, True, True, True, True])
tensor([True, True, True, True, True, True, True, True])
'''

這個例子表明第三個和第五個神經(jīng)網(wǎng)絡(luò)層的參數(shù)是綁定的。 它們不僅值相等，而且由相同的張量表示。 因此，如果我們改變其中一個參數(shù)，另一個參數(shù)也會改變。 這里有一個問題：當(dāng)參數(shù)綁定時(shí)，梯度會發(fā)生什么情況？ 答案是由于模型參數(shù)包含梯度，因此在反向傳播期間第二個隱藏層 （即第三個神經(jīng)網(wǎng)絡(luò)層）和第三個隱藏層（即第五個神經(jīng)網(wǎng)絡(luò)層）的梯度會加在一起。

延后初始化

到目前為止，我們忽略了建立網(wǎng)絡(luò)時(shí)需要做的以下這些事情：

• 我們定義了網(wǎng)絡(luò)架構(gòu)，但沒有指定輸入維度。
• 我們添加層時(shí)沒有指定前一層的輸出維度。
• 我們在初始化參數(shù)時(shí)，甚至沒有足夠的信息來確定模型應(yīng)該包含多少參數(shù)。

有些讀者可能會對我們的代碼能運(yùn)行感到驚訝。 畢竟，深度學(xué)習(xí)框架無法判斷網(wǎng)絡(luò)的輸入維度是什么。 這里的訣竅是框架的延后初始化（defers initialization）， 即直到數(shù)據(jù)第一次通過模型傳遞時(shí)，框架才會動態(tài)地推斷出每個層的大小。

在以后，當(dāng)使用卷積神經(jīng)網(wǎng)絡(luò)時(shí)， 由于輸入維度（即圖像的分辨率）將影響每個后續(xù)層的維數(shù)， 有了該技術(shù)將更加方便。 現(xiàn)在我們在編寫代碼時(shí)無須知道維度是什么就可以設(shè)置參數(shù)， 這種能力可以大大簡化定義和修改模型的任務(wù)。

自定義層

深度學(xué)習(xí)成功背后的一個因素是神經(jīng)網(wǎng)絡(luò)的靈活性：我們可以用創(chuàng)造性的方式組合不同的層，從而設(shè)計(jì)出適用于各種任務(wù)的架構(gòu)。例如，研究人員發(fā)明了專門用于處理圖像、文本、序列數(shù)據(jù)和執(zhí)行動態(tài)規(guī)劃的層。有時(shí)我們會遇到或要自己發(fā)明一個現(xiàn)在在深度學(xué)習(xí)框架中還不存在的層。在這些情況下，必須構(gòu)建自定義層。這里將展示如何構(gòu)建自定義層。

不帶參數(shù)的層

首先，我們構(gòu)造一個沒有任何參數(shù)的自定義層。下面的CenteredLayer類要從其輸入中減去均值。 要構(gòu)建它，我們只需繼承基礎(chǔ)層類并實(shí)現(xiàn)前向傳播功能。

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

class CenteredLayer(nn.Module):
    def __init__(self):
        super().__init__()

    def forward(self, X):
        return X - X.mean()

讓我們向該層提供一些數(shù)據(jù)，驗(yàn)證它是否能按預(yù)期工作。

layer = CenteredLayer()
layer(torch.FloatTensor([1, 2, 3, 4, 5]))
# tensor([-2., -1.,  0.,  1.,  2.])

現(xiàn)在，我們可以將層作為組件合并到更復(fù)雜的模型中。

net = nn.Sequential(nn.Linear(8, 128), CenteredLayer())

作為額外的健全性檢查，我們可以在向該網(wǎng)絡(luò)發(fā)送隨機(jī)數(shù)據(jù)后，檢查均值是否為0。 由于我們處理的是浮點(diǎn)數(shù)，因?yàn)榇鎯鹊脑?，我們?nèi)匀豢赡軙吹揭粋€非常小的非零數(shù)。

Y = net(torch.rand(4, 8))
Y.mean()
# tensor(6.5193e-09, grad_fn=<MeanBackward0>)

帶參數(shù)的層

以上我們知道了如何定義簡單的層，下面我們繼續(xù)定義具有參數(shù)的層， 這些參數(shù)可以通過訓(xùn)練進(jìn)行調(diào)整。 我們可以使用內(nèi)置函數(shù)來創(chuàng)建參數(shù)，這些函數(shù)提供一些基本的管理功能。 比如管理訪問、初始化、共享、保存和加載模型參數(shù)。 這樣做的好處之一是：我們不需要為每個自定義層編寫自定義的序列化程序。

現(xiàn)在，讓我們實(shí)現(xiàn)自定義版本的全連接層。 回想一下，該層需要兩個參數(shù)，一個用于表示權(quán)重，另一個用于表示偏置項(xiàng)。 在此實(shí)現(xiàn)中，我們使用修正線性單元作為激活函數(shù)。 該層需要輸入?yún)?shù)：in_units和units，分別表示輸入數(shù)和輸出數(shù)。

class MyLinear(nn.Module):
    def __init__(self, in_units, units):
        super().__init__()
        self.weight = nn.Parameter(torch.randn(in_units, units))
        self.bias = nn.Parameter(torch.randn(units,))
    def forward(self, X):
        linear = torch.matmul(X, self.weight.data) + self.bias.data
        return F.relu(linear)

接下來，我們實(shí)例化MyLinear類并訪問其模型參數(shù)。

linear = MyLinear(5, 3)
linear.weight
'''
Parameter containing:
tensor([[ 0.6174,  0.5799,  2.3246],
        [-1.1074,  1.0423,  1.1220],
        [-2.2106, -0.4986,  1.1021],
        [-1.0611, -1.3165,  0.3294],
        [-0.3595, -0.1274,  0.0748]], requires_grad=True)
'''

我們可以使用自定義層直接執(zhí)行前向傳播計(jì)算。

linear(torch.rand(2, 5))
'''
tensor([[0.0000, 0.0000, 0.0000],
        [0.5070, 0.0000, 0.0000]])
'''

我們還可以使用自定義層構(gòu)建模型，就像使用內(nèi)置的全連接層一樣使用自定義層。

net = nn.Sequential(MyLinear(64, 8), MyLinear(8, 1))
net(torch.rand(2, 64))
'''
tensor([[0.],
        [0.]])
'''

小結(jié)

• 我們可以通過基本層類設(shè)計(jì)自定義層。這允許我們定義靈活的新層，其行為與深度學(xué)習(xí)框架中的任何現(xiàn)有層不同
• 在自定義層定義完成后，我們就可以在任意環(huán)境和網(wǎng)絡(luò)架構(gòu)中調(diào)用該自定義層
• 層可以有局部參數(shù)，這些參數(shù)可以通過內(nèi)置函數(shù)創(chuàng)建

讀寫文件

到目前為止，我們討論了如何處理數(shù)據(jù)， 以及如何構(gòu)建、訓(xùn)練和測試深度學(xué)習(xí)模型。 然而，有時(shí)我們希望保存訓(xùn)練的模型， 以備將來在各種環(huán)境中使用（比如在部署中進(jìn)行預(yù)測）。 此外，當(dāng)運(yùn)行一個耗時(shí)較長的訓(xùn)練過程時(shí)， 最佳的做法是定期保存中間結(jié)果， 以確保在服務(wù)器電源被不小心斷掉時(shí)，我們不會損失幾天的計(jì)算結(jié)果。 因此，現(xiàn)在是時(shí)候?qū)W習(xí)如何加載和存儲權(quán)重向量和整個模型了

加載和保存張量

對于單個張量，我們可以直接調(diào)用load和save函數(shù)分別讀寫它們。 這兩個函數(shù)都要求我們提供一個名稱，save要求將要保存的變量作為輸入。

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

x = torch.arange(4)
torch.save(x, 'x-file')

我們現(xiàn)在可以將存儲在文件中的數(shù)據(jù)讀回內(nèi)存。

x2 = torch.load('x-file')
x2
# tensor([0, 1, 2, 3])

我們可以存儲一個張量列表，然后把它們讀回內(nèi)存。

y = torch.zeros(4)
torch.save([x, y],'x-files')
x2, y2 = torch.load('x-files')
(x2, y2)
# (tensor([0, 1, 2, 3]), tensor([0., 0., 0., 0.]))

我們甚至可以寫入或讀取從字符串映射到張量的字典。 當(dāng)我們要讀取或?qū)懭肽Ｐ椭械乃袡?quán)重時(shí)，這很方便。

mydict = {'x': x, 'y': y}
torch.save(mydict, 'mydict')
mydict2 = torch.load('mydict')
mydict2
# {'x': tensor([0, 1, 2, 3]), 'y': tensor([0., 0., 0., 0.])}

加載和保存模型參數(shù)

保存單個權(quán)重向量（或其他張量）確實(shí)有用， 但是如果我們想保存整個模型，并在以后加載它們， 單獨(dú)保存每個向量則會變得很麻煩。 畢竟，我們可能有數(shù)百個參數(shù)散布在各處。 因此，深度學(xué)習(xí)框架提供了內(nèi)置函數(shù)來保存和加載整個網(wǎng)絡(luò)。

需要注意的一個重要細(xì)節(jié)是，這將保存模型的參數(shù)而不是保存整個模型。 例如，如果我們有一個3層多層感知機(jī)，我們需要單獨(dú)指定架構(gòu)。 因?yàn)槟Ｐ捅旧砜梢园我獯a，所以模型本身難以序列化。 因此，為了恢復(fù)模型，我們需要用代碼生成架構(gòu)， 然后從磁盤加載參數(shù)。 讓我們從熟悉的多層感知機(jī)開始嘗試一下。

class MLP(nn.Module):
    def __init__(self):
        super().__init__()
        self.hidden = nn.Linear(20, 256)
        self.output = nn.Linear(256, 10)

    def forward(self, x):
        return self.output(F.relu(self.hidden(x)))

net = MLP()
X = torch.randn(size=(2, 20))
Y = net(X)

接下來，我們將模型的參數(shù)存儲在一個叫做“mlp.params”的文件中。

torch.save(net.state_dict(), 'mlp.params')

為了恢復(fù)模型，我們實(shí)例化了原始多層感知機(jī)模型的一個備份。 這里我們不需要隨機(jī)初始化模型參數(shù)，而是直接讀取文件中存儲的參數(shù)。

clone = MLP()
clone.load_state_dict(torch.load('mlp.params'))
clone.eval()
'''
MLP(
  (hidden): Linear(in_features=20, out_features=256, bias=True)
  (output): Linear(in_features=256, out_features=10, bias=True)
)
'''

由于兩個實(shí)例具有相同的模型參數(shù)，在輸入相同的X時(shí)， 兩個實(shí)例的計(jì)算結(jié)果應(yīng)該相同。 讓我們來驗(yàn)證一下。

Y_clone = clone(X)
Y_clone == Y
'''
tensor([[True, True, True, True, True, True, True, True, True, True],
        [True, True, True, True, True, True, True, True, True, True]])
'''

• save和load函數(shù)可用于張量對象的文件讀寫。
• 我們可以通過參數(shù)字典保存和加載網(wǎng)絡(luò)的全部參數(shù)。
• 保存架構(gòu)必須在代碼中完成，而不是在參數(shù)中完成。

GPU

我們回顧了過去20年計(jì)算能力的快速增長。 簡而言之，自2000年以來，GPU性能每十年增長1000倍。

本節(jié)，我們將討論如何利用這種計(jì)算性能進(jìn)行研究。 首先是如何使用單個GPU，然后是如何使用多個GPU和多個服務(wù)器（具有多個GPU）。

我們先看看如何使用單個NVIDIA GPU進(jìn)行計(jì)算。 首先，確保至少安裝了一個NVIDIA GPU。 然后，下載NVIDIA驅(qū)動和CUDA 并按照提示設(shè)置適當(dāng)?shù)穆窂健?當(dāng)這些準(zhǔn)備工作完成，就可以使用nvidia-smi命令來查看顯卡信息。

nvidia-smi

在PyTorch中，每個數(shù)組都有一個設(shè)備（device）， 我們通常將其稱為環(huán)境（context）。 默認(rèn)情況下，所有變量和相關(guān)的計(jì)算都分配給CPU。 有時(shí)環(huán)境可能是GPU。 當(dāng)我們跨多個服務(wù)器部署作業(yè)時(shí)，事情會變得更加棘手。 通過智能地將數(shù)組分配給環(huán)境， 我們可以最大限度地減少在設(shè)備之間傳輸數(shù)據(jù)的時(shí)間。 例如，當(dāng)在帶有GPU的服務(wù)器上訓(xùn)練神經(jīng)網(wǎng)絡(luò)時(shí)， 我們通常希望模型的參數(shù)在GPU上。

要運(yùn)行此部分中的程序，至少需要兩個GPU。 注意，對大多數(shù)桌面計(jì)算機(jī)來說，這可能是奢侈的，但在云中很容易獲得。 例如可以使用AWS EC2的多GPU實(shí)例。 本書的其他章節(jié)大都不需要多個GPU， 而本節(jié)只是為了展示數(shù)據(jù)如何在不同的設(shè)備之間傳遞。

計(jì)算設(shè)備

我們可以指定用于存儲和計(jì)算的設(shè)備，如CPU和GPU。 默認(rèn)情況下，張量是在內(nèi)存中創(chuàng)建的，然后使用CPU計(jì)算它。

在PyTorch中，CPU和GPU可以用torch.device('cpu') 和torch.device('cuda')表示。 應(yīng)該注意的是，cpu設(shè)備意味著所有物理CPU和內(nèi)存， 這意味著PyTorch的計(jì)算將嘗試使用所有CPU核心。 然而，gpu設(shè)備只代表一個卡和相應(yīng)的顯存。 如果有多個GPU，我們使用torch.device(f'cuda:{i}') 來表示第 i 塊GPU（從0開始）。 另外，cuda:0和cuda是等價(jià)的。

import torch
from torch import nn

torch.device('cpu'), torch.device('cuda'), torch.device('cuda:1')
# (device(type='cpu'), device(type='cuda'), device(type='cuda', index=1))

我們可以查詢可用gpu的數(shù)量。

torch.cuda.device_count()
# 0  # 測試節(jié)點(diǎn)無GPU

現(xiàn)在我們定義了兩個方便的函數(shù)， 這兩個函數(shù)允許我們在不存在所需所有GPU的情況下運(yùn)行代碼。

def try_gpu(i=0):  #@save
    """如果存在，則返回gpu(i)，否則返回cpu()"""
    if torch.cuda.device_count() >= i + 1:
        return torch.device(f'cuda:{i}')
    return torch.device('cpu')

def try_all_gpus():  #@save
    """返回所有可用的GPU，如果沒有GPU，則返回[cpu(),]"""
    devices = [torch.device(f'cuda:{i}')
             for i in range(torch.cuda.device_count())]
    return devices if devices else [torch.device('cpu')]

try_gpu(), try_gpu(10), try_all_gpus()

# (device(type='cpu'), device(type='cpu'), [device(type='cpu')])

張量與GPU

我們可以查詢張量所在的設(shè)備。 默認(rèn)情況下，張量是在CPU上創(chuàng)建的。

x = torch.tensor([1, 2, 3])
x.device
# device(type='cpu')

需要注意的是，無論何時(shí)我們要對多個項(xiàng)進(jìn)行操作， 它們都必須在同一個設(shè)備上。 例如，如果我們對兩個張量求和， 我們需要確保兩個張量都位于同一個設(shè)備上， 否則框架將不知道在哪里存儲結(jié)果，甚至不知道在哪里執(zhí)行計(jì)算。

存儲在GPU上

有幾種方法可以在GPU上存儲張量。 例如，我們可以在創(chuàng)建張量時(shí)指定存儲設(shè)備。接 下來，我們在第一個gpu上創(chuàng)建張量變量X。 在GPU上創(chuàng)建的張量只消耗這個GPU的顯存。 我們可以使用nvidia-smi命令查看顯存使用情況。 一般來說，我們需要確保不創(chuàng)建超過GPU顯存限制的數(shù)據(jù)。

X = torch.ones(2, 3, device=try_gpu())
X
# 無GPU時(shí)會默認(rèn)到CPU

假設(shè)我們至少有兩個GPU，下面的代碼將在第二個GPU上創(chuàng)建一個隨機(jī)張量。

Y = torch.rand(2, 3, device=try_gpu(1))
Y
# 無GPU時(shí)會默認(rèn)到CPU

復(fù)制

如果我們要計(jì)算X + Y，我們需要決定在哪里執(zhí)行這個操作。 例如，如下圖所示， 我們可以將X傳輸?shù)降诙€GPU并在那里執(zhí)行操作。 不要簡單地X加上Y，因?yàn)檫@會導(dǎo)致異常， 運(yùn)行時(shí)引擎不知道該怎么做：它在同一設(shè)備上找不到數(shù)據(jù)會導(dǎo)致失敗。 由于Y位于第二個GPU上，所以我們需要將X移到那里， 然后才能執(zhí)行相加運(yùn)算。

Z = X.cuda(1)
print(X)
print(Z)
Y + Z

假設(shè)變量Z已經(jīng)存在于第二個GPU上。 如果我們還是調(diào)用Z.cuda(1)會發(fā)生什么？ 它將返回Z，而不會復(fù)制并分配新內(nèi)存。

Z.cuda(1) is Z
# True

旁注

人們使用GPU來進(jìn)行機(jī)器學(xué)習(xí)，因?yàn)閱蝹€GPU相對運(yùn)行速度快。 但是在設(shè)備（CPU、GPU和其他機(jī)器）之間傳輸數(shù)據(jù)比計(jì)算慢得多。 這也使得并行化變得更加困難，因?yàn)槲覀儽仨毜却龜?shù)據(jù)被發(fā)送（或者接收）， 然后才能繼續(xù)進(jìn)行更多的操作。 這就是為什么拷貝操作要格外小心。 根據(jù)經(jīng)驗(yàn)，多個小操作比一個大操作糟糕得多。 此外，一次執(zhí)行幾個操作比代碼中散布的許多單個操作要好得多。 如果一個設(shè)備必須等待另一個設(shè)備才能執(zhí)行其他操作， 那么這樣的操作可能會阻塞。 這有點(diǎn)像排隊(duì)訂購咖啡，而不像通過電話預(yù)先訂購： 當(dāng)客人到店的時(shí)候，咖啡已經(jīng)準(zhǔn)備好了。

神經(jīng)網(wǎng)絡(luò)與GPU

類似地，神經(jīng)網(wǎng)絡(luò)模型可以指定設(shè)備。 下面的代碼將模型參數(shù)放在GPU上。

net = nn.Sequential(nn.Linear(3, 1))
net = net.to(device=try_gpu())

在接下來的幾章中， 我們將看到更多關(guān)于如何在GPU上運(yùn)行模型的例子， 因?yàn)樗鼈儗⒆兊酶佑?jì)算密集。

當(dāng)輸入為GPU上的張量時(shí)，模型將在同一GPU上計(jì)算結(jié)果。

net(X)

讓我們確認(rèn)模型參數(shù)存儲在同一個GPU上。

net[0].weight.data.device

總之，只要所有的數(shù)據(jù)和參數(shù)都在同一個設(shè)備上， 我們就可以有效地學(xué)習(xí)模型。

小結(jié)

• 我們可以指定用于存儲和計(jì)算的設(shè)備，例如CPU或GPU。默認(rèn)情況下，數(shù)據(jù)在主內(nèi)存中創(chuàng)建，然后使用CPU進(jìn)行計(jì)算。
• 深度學(xué)習(xí)框架要求計(jì)算的所有輸入數(shù)據(jù)都在同一設(shè)備上，無論是CPU還是GPU。
• 不經(jīng)意地移動數(shù)據(jù)可能會顯著降低性能。一個典型的錯誤如下：計(jì)算GPU上每個小批量的損失，并在命令行中將其報(bào)告給用戶（或?qū)⑵溆涗浽贜umPy ndarray中）時(shí)，將觸發(fā)全局解釋器鎖，從而使所有GPU阻塞。最好是為GPU內(nèi)部的日志分配內(nèi)存，并且只移動較大的日志。