PyTorch 提供了豐富的工具和功能，方便開發者建構和訓練深度學習模型。理解其核心概念，如張量操作、自動微分和 GPU 加速，對於有效訓練模型至關重要。本篇著重於 PyTorch 的訓練流程，包含資料載入、模型定義、損失函式設定、最佳化器選擇以及訓練迴圈的建構。同時也探討瞭如何利用 GPU 加速訓練，以及如何有效地儲存和載入訓練好的模型，以方便後續佈署和應用。此外，文章也分析了多作業員資料載入的優勢和實作方式，藉此提升訓練效率，減少瓶頸效應。
神經網路訓練流程
在深度學習中，神經網路的訓練是一個迭代的過程。以下是使用 PyTorch 框架進行神經網路訓練的基本步驟：
訓練迴圈
num_epochs = 3
for epoch in range(num_epochs):
# 將模型設為訓練模式
model.train()
# 進行每個epoch的訓練
for batch in train_loader:
# 載入批次資料
x, y = batch
# 將資料轉移到 GPU（如果有）
x, y = x.to(device), y.to(device)
# 清除最佳化器的梯度
optimizer.zero_grad()
# 將輸入資料傳入模型，取得預測結果
outputs = model(x)
# 計算損失函式
loss = criterion(outputs, y)
# 反向傳播，計算梯度
loss.backward()
# 更新模型引數
optimizer.step()
批次處理
在每個 epoch 中，資料會被分割成多個批次（batch）。對於每個批次，模型會進行一次前向傳播（forward pass），計算損失函式，然後進行反向傳播（backward pass），更新模型引數。
瓶頸效應
在訓練過程中，可能會遇到瓶頸效應（bottleneck），即模型的訓練速度變慢。這可能是由於資料載入速度慢、模型計算複雜度高或 GPU 記憶體不足等原因造成。為了避免瓶頸效應，可以使用更快的資料載入方式、最佳化模型結構或使用更強大的 GPU。
圖表翻譯：
graph LR
A[資料載入] --> B[模型訓練]
B --> C[損失函式計算]
C --> D[反向傳播]
D --> E[模型更新]
E --> F[下一個批次]
以上圖表展示了神經網路訓練的基本流程，從資料載入到模型更新。每個步驟都對應到特定的操作，確保模型能夠正確地進行訓練。
多作業員資料載入最佳化
在深度學習中，資料載入是訓練過程中的重要環節。當使用單個作業員進行資料載入時，可能會出現資料載入瓶頸，導致模型閒置直到下一個批次載入完成。為瞭解決這個問題，可以啟用多作業員資料載入功能。
啟用多作業員資料載入
啟用多作業員資料載入後，資料載入器可以在背景中準備下一個批次的資料。這樣，當模型完成對前一個批次的處理後，可以立即開始處理下一個批次，而不需要等待資料載入完成。
資料載入流程
- 資料載入器初始化：建立資料載入器物件，並設定相關引數，例如批次大小、資料集等。
- 資料載入：資料載入器從資料集中載入批次資料，並將其放入佇列中。
- 模型預測：模型對載入的批次資料進行預測，得到預測結果。
- 損失計算：計算模型預測結果與真實標籤之間的損失。
- 模型更新：根據損失值更新模型引數。
多作業員資料載入優點
啟用多作業員資料載入可以帶來以下優點：
- 提高訓練速度：透過在背景中準備下一個批次的資料，可以減少模型閒置時間，從而提高訓練速度。
- 提高效率：多作業員資料載入可以充分利用 CPU 和 GPU 資源，提高訓練過程的效率。
實作多作業員資料載入
以下是使用 PyTorch 實作多作業員資料載入的示例程式碼：
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset
# 定義資料集類別
class MyDataset(Dataset):
def __init__(self, features, labels):
self.features = features
self.labels = labels
def __len__(self):
return len(self.features)
def __getitem__(self, index):
feature = self.features[index]
label = self.labels[index]
return feature, label
# 建立資料集和資料載入器
features =... # 特徵資料
labels =... # 標籤資料
dataset = MyDataset(features, labels)
batch_size = 32
num_workers = 4 # 啟用多作業員資料載入
data_loader = DataLoader(dataset, batch_size=batch_size, num_workers=num_workers)
# 定義模型和最佳化器
model =... # 模型定義
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 訓練迴圈
for batch_idx, (features, labels) in enumerate(data_loader):
# 預測和損失計算
logits = model(features)
loss = criterion(logits, labels)
# 更新模型引數
optimizer.zero_grad()
loss.backward()
optimizer.step()
在上述程式碼中，透過設定 num_workers 引數為 4，可以啟用多作業員資料載入功能。這樣可以在背景中準備下一個批次的資料，從而提高訓練速度和效率。
圖表翻譯：
graph LR
A[資料集] -->|載入|> B[資料載入器]
B -->|批次|> C[模型]
C -->|預測|> D[損失計算]
D -->|更新|> E[模型引數]
style A fill:#f9f,stroke:#333,stroke-width:4px
style B fill:#f9f,stroke:#333,stroke-width:4px
style C fill:#f9f,stroke:#333,stroke-width:4px
style D fill:#f9f,stroke:#333,stroke-width:4px
style E fill:#f9f,stroke:#333,stroke-width:4px
此圖表展示了啟用多作業員資料載入後的訓練迴圈流程。資料集被載入到資料載入器中，然後被分成批次送入模型進行預測和損失計算，最後更新模型引數。
神經網路訓練過程分析
在神經網路的訓練過程中，最佳化器（optimizer）扮演著至關重要的角色。以下是訓練過程中的一些關鍵步驟：
- 梯度清零：
optimizer.zero_grad()這行程式碼用於清除之前的梯度值，以防止梯度累積對訓練產生不良影響。 - 反向傳播：
loss.backward()這行程式碼計算了損失函式對模型引數的梯度。這個過程被稱為反向傳播，是神經網路訓練中的一個基本步驟。 - 最佳化器更新：
optimizer.step()這行程式碼使用最佳化器更新模型引數，根據計算出的梯度和最佳化器的設定（例如學習率）進行調整。
訓練過程日誌
在訓練過程中，通常會列印預出一些日誌資訊，以便觀察模型的訓練狀態。例如：
print(f"Epoch: {epoch+1:03d}/{num_epochs:03d} | Batch {batch_idx:03d}/{len(train_loader):03d} | Train Loss: {loss:.2f}")
這行程式碼列印預出了當前的epoch、batch索引、總epoch數、總batch數和當前的訓練損失。
模型評估
在每個epoch結束後，通常會對模型進行評估，以檢查其在訓練集上的效能。這可以透過呼叫model.eval()來完成，這會將模型設定為評估模式。在這種模式下，某些層（如dropout或batch normalization層）會以不同的方式行為，以確保評估結果的準確性。
超引數調整
在實際應用中，往往需要調整超引數（如學習率、epoch數等）以獲得最佳的模型效能。這通常透過使用驗證集（validation set）來完成，驗證集是一個獨立的資料集，用於評估模型在不同超引數設定下的效能。
練習題
給定一個神經網路模型，其結構如下：
model = nn.Sequential(
nn.Linear(2, 10), # input layer (2) -> hidden layer (10)
nn.ReLU(),
nn.Linear(10, 2) # hidden layer (10) -> output layer (2)
)
請問，這個神經網路模型有多少個引數？
答案：這個模型有兩個全連線層（nn.Linear），每個層都有自己的權重和偏差。第一個全連線層有2個輸入和10個輸出，因此有210=20個權重和10個偏差。第二個全連線層有10個輸入和2個輸出，因此有102=20個權重和2個偏差。因此，總共有20+10+20+2=52個引數。
神經網路模型訓練與預測
在神經網路模型的訓練過程中，最佳化器（optimizer）扮演著至關重要的角色。最佳化器利用梯度下降法來更新模型引數，以最小化損失函式。以下是模型訓練的基本步驟：
- 前向傳播：輸入資料透過神經網路模型，得到輸出結果。
- 計算損失：使用損失函式（如交叉熵損失）計算模型輸出結果與真實標籤之間的差異。
- 反向傳播：計算梯度，得到每個模型引數對損失函式的偏導數。
- 更新模型引數：最佳化器使用梯度下降法更新模型引數，以最小化損失函式。
在 PyTorch 中，model.train() 和 model.eval() 方法用於切換模型的訓練模式和評估模式。雖然在前面的程式碼中沒有明確使用這兩個方法，但在實際應用中，為了避免意外行為，仍然建議使用它們。
訓練模型
# 設定模型為訓練模式
model.train()
# 定義最佳化器和損失函式
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
criterion = torch.nn.CrossEntropyLoss()
# 訓練模型
for epoch in range(100):
# 前向傳播
outputs = model(X_train)
# 計算損失
loss = criterion(outputs, y_train)
# 反向傳播
optimizer.zero_grad()
loss.backward()
# 更新模型引數
optimizer.step()
預測
# 設定模型為評估模式
model.eval()
# 禁止梯度計算
with torch.no_grad():
# 預測輸出
outputs = model(X_train)
# 輸出結果
print(outputs)
取得類別成員機率
# 使用 softmax 函式計算類別成員機率
probas = torch.softmax(outputs, dim=1)
print(probas)
這些步驟展示瞭如何使用 PyTorch 訓練一個簡單的神經網路模型，並使用它進行預測。同時，也強調了在訓練過程中正確使用最佳化器和損失函式的重要性。
使用PyTorch進行預測
在上述程式碼中，我們首先看到了一個典型的訓練迴圈。這裡，我們使用了PyTorch的argmax函式來從softmax輸出中獲得預測的類別標籤。argmax函式傳回每一行中最高值的索引位置，如果我們設定dim=1，它將傳回每一行中最高值的索引位置（如果設定dim=0，它將傳回每一列中最高值的索引位置）。
import torch
# 假設probas是softmax輸出的張量
probas = torch.tensor([[0.9991, 0.0009], [0.9992, 0.0008], [0.9993, 0.0007], [0.0004, 0.9996], [0.0005, 0.9995]])
# 使用argmax函式獲得預測的類別標籤
predictions = torch.argmax(probas, dim=1)
print(predictions)
這將輸出預測的類別標籤：
tensor([0, 0, 0, 1, 1])
注意到，我們不需要計算softmax機率就可以獲得類別標籤。我們也可以直接將argmax函式應用於logits（輸出）上：
# 假設outputs是模型的輸出張量
outputs = torch.tensor([[10.0, -10.0], [10.1, -10.1], [10.2, -10.2], [-10.3, 10.3], [-10.4, 10.4]])
# 使用argmax函式獲得預測的類別標籤
predictions = torch.argmax(outputs, dim=1)
print(predictions)
這也將輸出預測的類別標籤：
tensor([0, 0, 0, 1, 1])
接下來，我們可以比較預測的類別標籤與真實的訓練標籤。由於訓練資料集相對較小，我們可以使用==比較運運算元來比較預測結果與真實標籤：
# 假設y_train是真實的訓練標籤
y_train = torch.tensor([0, 0, 0, 1, 1])
# 比較預測結果與真實標籤
correct_predictions = predictions == y_train
print(correct_predictions)
這將輸出比較結果：
tensor([True, True, True, True, True])
最後，我們可以使用torch.sum函式來計算正確預測的數量：
# 計算正確預測的數量
num_correct = torch.sum(correct_predictions)
print(num_correct)
這將輸出正確預測的數量。
圖表翻譯：
graph LR
A[輸入資料] --> B[模型輸出]
B --> C[softmax函式]
C --> D[argmax函式]
D --> E[預測類別標籤]
E --> F[比較真實標籤]
F --> G[計算正確預測數量]
在這個流程圖中，我們展示了從輸入資料到計算正確預測數量的整個過程。首先，輸入資料被送入模型中，然後模型輸出被送入softmax函式中，然後softmax輸出被送入argmax函式中，以獲得預測類別標籤。接下來，預測類別標籤被與真實標籤比較，最後，計算正確預測的數量。
深度學習模型的準確率計算
在深度學習中，模型的準確率是評估模型效能的重要指標。以下是計算準確率的步驟和實作。
準確率計算原理
準確率是指模型正確預測的樣本數與總樣本數的比率。假設我們有一個包含 $n$ 個樣本的資料集，其中 $m$ 個樣本被模型正確預測，那麼準確率可以計算為：
$$ \text{準確率} = \frac{m}{n} \times 100% $$
實作準確率計算函式
為了方便計算準確率，我們可以實作一個名為 compute_accuracy 的函式。以下是這個函式的實作：
import torch
def compute_accuracy(model, dataloader):
"""
計算模型在給定資料載入器上的準確率。
引數：
- model：待評估的模型。
- dataloader：資料載入器，提供批次資料。
傳回：
- 準確率（百分比）。
"""
model.eval() # 將模型設定為評估模式
correct = 0.0 # 正確預測的樣本數
total_examples = 0 # 總樣本數
with torch.no_grad(): # 不計算梯度
for idx, (features, labels) in enumerate(dataloader):
logits = model(features) # 預測
# 取得預測結果
predictions = torch.argmax(logits, dim=1)
# 比較真實標籤和預測結果
compare = labels == predictions
# 更新正確預測的樣本數
correct += torch.sum(compare)
# 更新總樣本數
total_examples += len(compare)
# 計算準確率
accuracy = (correct / total_examples).item()
return accuracy
應用準確率計算函式
現在，我們可以使用 compute_accuracy 函式來計算模型在訓練集上的準確率：
print(compute_accuracy(model, train_loader))
這個函式可以對任意大小的資料集進行準確率計算，因為它根據批次大小對資料進行處理。這使得它對大型資料集也非常有效。
圖表翻譯：準確率計算過程
flowchart TD
A[開始] --> B[載入資料]
B --> C[初始化模型]
C --> D[設定評估模式]
D --> E[迭代批次資料]
E --> F[預測和比較]
F --> G[更新正確預測計數]
G --> H[計算準確率]
H --> I[輸出準確率]
圖表翻譯：
以上圖表描述了準確率計算的過程，從開始到輸出準確率。每一步驟都對應到 compute_accuracy 函式中的特定操作，展示瞭如何根據批次大小對任意大小的資料集進行準確率計算。
儲存和載入模型
訓練好模型後，讓我們看看如何儲存它，以便日後重複使用。以下是 PyTorch 中儲存和載入模型的推薦方法：
torch.save(model.state_dict(), "model.pth")
這行程式碼將模型的狀態字典 (state_dict()) 儲存到名為 “model.pth” 的檔案中。檔案名稱可以任意指定，但 .pth 和 .pt 是最常用的命名慣例。
一旦模型被儲存，我們就可以從磁碟中還原它：
model = NeuralNetwork(2, 2)
model.load_state_dict(torch.load("model.pth"))
torch.load("model.pth") 函式讀取 “model.pth” 檔案並重建包含模型引數的 Python 字典物件，而 model.load_state_dict() 則將這些引數應用到模型中，有效地還原了模型在儲存時的學習狀態。
最佳化訓練效能使用 GPU
接下來，讓我們探討如何利用 GPU 加速深度神經網路的訓練。首先，我們將介紹 PyTorch 中 GPU 計算的主要概念。然後，我們將在單個 GPU 上訓練一個模型。最後，我們將探討使用多個 GPU 進行分散式訓練。
PyTorch 在 GPU 裝置上的計算
修改訓練迴圈以選擇性地在 GPU 上執行相對簡單，只需要修改三行程式碼（見第 A.7 節）。在進行修改之前，瞭解 PyTorch 中 GPU 計算的主要概念至關重要。在 PyTorch 中，裝置是計算發生和資料所在的位置。CPU 和 GPU 是裝置的例子。PyTorch 張量居住在一個裝置中，其操作是在同一裝置上執行的。
假設您已安裝了支援 GPU 的 PyTorch 版本（見第 A.1.3 節），我們可以透過以下程式碼驗證執行時是否確實支援 GPU 計算：
print(torch.cuda.is_available())
這將傳回一個布林值，指示是否可用 GPU 進行計算。
內容解密：
上述程式碼片段展示瞭如何儲存和載入 PyTorch 模型，以及如何檢查 GPU 是否可用。torch.save() 函式用於儲存模型的狀態字典，而 torch.load() 函式則用於載入已儲存的模型。torch.cuda.is_available() 函式檢查是否有可用的 GPU。
圖表翻譯：
flowchart TD
A[開始] --> B[儲存模型]
B --> C[載入模型]
C --> D[檢查GPU可用性]
D --> E[傳回布林值]
此圖表展示了程式碼的邏輯流程，從儲存模型開始，然後載入模型，接著檢查 GPU 是否可用，最後傳回一個布林值指示結果。
使用PyTorch進行張量運算
在PyTorch中，張量（Tensor）是一種多維資料結構，類別似於NumPy的陣列，但具有更多的功能和彈性。下面，我們將探討如何使用PyTorch進行張量運算。
建立張量
首先，我們需要建立兩個張量，分別命名為tensor_1和tensor_2。這些張量可以透過torch.tensor()函式建立，並指定其初始值。
import torch
tensor_1 = torch.tensor([1., 2., 3.])
tensor_2 = torch.tensor([4., 5., 6.])
張量加法運算
接下來，我們可以使用+運運算元對這兩個張量進行加法運算。這個運算將在CPU上執行。
result = tensor_1 + tensor_2
print(result)
輸出結果為：
tensor([5., 7., 9.])
將張量轉移到GPU
如果系統中有GPU，我們可以使用.to()方法將張量轉移到GPU上，以便在GPU上進行運算。
tensor_1 = tensor_1.to("cuda")
tensor_2 = tensor_2.to("cuda")
然後，我們可以再次進行加法運算，這次將在GPU上執行。
result = tensor_1 + tensor_2
print(result)
輸出結果為：
tensor([5., 7., 9.], device='cuda:0')
注意到，結果張量現在包含了裝置資訊device='cuda:0'，表示它儲存於第一塊GPU上。如果系統中有多塊GPU，可以透過指定裝置索引（如"cuda:0"、"cuda:1"等）來選擇要使用的GPU。
內容解密：
在上述程式碼中，.to()方法用於將張量轉移到指定的裝置（CPU或GPU）上。這個方法不僅可以用於改變張量的裝置，也可以用於改變張量的資料型別。例如，可以使用tensor.to(torch.float64)將張量的資料型別改為64位浮點數。
圖表翻譯：
下面是使用Mermaid語法繪製的張量加法運算流程圖：
flowchart TD
A[建立張量] --> B[將張量轉移到GPU]
B --> C[進行加法運算]
C --> D[輸出結果]
這個流程圖展示了從建立張量到進行加法運算並輸出結果的整個過程。
跨裝置運算的限制
需要注意的是，所有參與運算的張量必須位於同一裝置上。否則，運算將失敗。例如，如果tensor_1位於CPU上，而tensor_2位於GPU上，則嘗試進行加法運算將導致錯誤。
tensor_1 = tensor_1.to("cpu")
print(tensor_1 + tensor_2)
這將導致以下錯誤：
RuntimeError: Traceback (most recent call last)
...
圖表翻譯：
下面是使用Mermaid語法繪製的錯誤流程圖：
flowchart TD
A[建立張量] --> B[將張量轉移到不同裝置]
B --> C[嘗試進行加法運算]
C --> D[發生錯誤]
這個流程圖展示了當張量位於不同裝置上時，嘗試進行加法運算將導致錯誤的過程。
使用GPU進行單機訓練
當我們熟悉了將張量轉移到GPU上後，就可以修改訓練迴圈以在GPU上執行。這一步驟只需要改變三行程式碼，如下所示。
首先，我們需要將模型和資料轉移到GPU上。這可以透過使用to()方法實作，該方法可以將模型或張量轉移到指定的裝置上。
# 將模型轉移到GPU上
model = model.to(device)
# 將資料轉移到GPU上
features, labels = features.to(device), labels.to(device)
接下來，我們需要修改訓練迴圈以在GPU上執行。這可以透過使用train()方法實作，該方法可以將模型設定為訓練模式。
# 設定模型為訓練模式
model.train()
最後，我們需要修改損失函式以在GPU上執行。這可以透過使用cross_entropy()方法實作，該方法可以計算交叉熵損失。
# 計算交叉熵損失
loss = F.cross_entropy(logits, labels)
以下是完整的訓練迴圈程式碼：
# 設定隨機種子
torch.manual_seed(123)
# 建立模型
model = NeuralNetwork(num_inputs=2, num_outputs=2)
# 將模型轉移到GPU上
model = model.to(device)
# 建立最佳化器
optimizer = torch.optim.SGD(model.parameters(), lr=0.5)
# 設定訓練迴圈引數
num_epochs = 3
# 訓練迴圈
for epoch in range(num_epochs):
# 設定模型為訓練模式
model.train()
# 迭代批次
for batch_idx, (features, labels) in enumerate(train_loader):
# 將資料轉移到GPU上
features, labels = features.to(device), labels.to(device)
# 前向傳播
logits = model(features)
# 計算交叉熵損失
loss = F.cross_entropy(logits, labels)
# 後向傳播
optimizer.zero_grad()
loss.backward()
optimizer.step()
# 輸出訓練結果
print(f"Epoch: {epoch+1:03d}/{num_epochs:03d} | Batch {batch_idx:03d}/{len(train_loader):03d} | Train/Val Loss: {loss:.2f}")
# 設定模型為評估模式
model.eval()
圖表翻譯：
flowchart TD
A[開始] --> B[設定隨機種子]
B --> C[建立模型]
C --> D[將模型轉移到GPU上]
D --> E[建立最佳化器]
E --> F[設定訓練迴圈引數]
F --> G[訓練迴圈]
G --> H[設定模型為訓練模式]
H --> I[迭代批次]
I --> J[將資料轉移到GPU上]
J --> K[前向傳播]
K --> L[計算交叉熵損失]
L --> M[後向傳播]
M --> N[輸出訓練結果]
N --> O[設定模型為評估模式]
圖表解釋：
- 圖表展示了使用GPU進行單機訓練的流程。
- 從左到右，流程分別為：設定隨機種子、建立模型、將模型轉移到GPU上、建立最佳化器、設定訓練迴圈引數、訓練迴圈、設定模型為訓練模式、迭代批次、將資料轉移到GPU上、前向傳播、計算交叉熵損失、後向傳播、輸出訓練結果、設定模型為評估模式。
- 圖表中，每個步驟之間的箭頭表示了流程的順序。
從效能最佳化視角來看，本文深入探討了神經網路訓練流程的關鍵環節，涵蓋了從基礎的訓練迴圈、批次處理到多作業員資料載入最佳化、GPU加速等進階技巧。透過分析程式碼範例和流程圖，我們清晰地理解了每個步驟的具體操作和作用，例如optimizer.zero_grad()用於防止梯度累積，loss.backward()用於計算梯度，以及optimizer.step()用於更新模型引數。此外，文章還闡述瞭如何利用torch.save()和torch.load()儲存和載入模型，以及如何使用torch.cuda.is_available()檢查GPU的可用性。然而，目前對於不同最佳化器（如Adam、SGD）的效能比較和選擇策略尚缺乏深入討論，這也是未來研究的一個重要方向。對於追求極致效能的深度學習應用，需要根據具體模型和資料集特性選擇合適的最佳化器和超引陣列合。玄貓認為，掌握這些效能最佳化技巧對於提升深度學習模型的訓練效率至關重要，特別是在處理大規模資料集和複雜模型時，更能體現其價值。在實務上，建議開發者優先關注資料載入和GPU利用率的最佳化，並根據實際情況調整批次大小和學習率等超引數，以達到最佳的訓練效能。未來，隨著硬體技術的發展和演算法的創新，我們預見深度學習模型的訓練效率將會進一步提升，同時也將湧現更多高效的最佳化策略。
