beginner/basics/optimization_tutorial
在 Google Colab 中執行
Colab
下載 Notebook
Notebook
在 GitHub 上檢視
GitHub
注意
轉到 末尾 以下載完整的示例程式碼。
瞭解基礎知識 || 快速入門 || 張量 || 資料集 & DataLoader || 變換 || 構建模型 || 自動微分 || 最佳化 || 儲存 & 載入模型
最佳化模型引數#
創建於：2021 年 2 月 9 日 | 最後更新：2025 年 4 月 28 日 | 最後驗證：2024 年 11 月 5 日
現在我們有了模型和資料，是時候透過在資料上最佳化其引數來訓練、驗證和測試我們的模型了。訓練模型是一個迭代過程；在每次迭代中，模型會猜測輸出，計算其猜測的誤差（損失），收集誤差相對於其引數的導數（正如我們在上一節中看到的），並使用梯度下降最佳化這些引數。有關此過程的更詳細演練，請觀看 3Blue1Brown 關於反向傳播的影片。
先決程式碼#
我們載入了來自資料集 & DataLoader和構建模型之前各節的程式碼。
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor
training_data = datasets.FashionMNIST(
root="data",
train=True,
download=True,
transform=ToTensor()
)
test_data = datasets.FashionMNIST(
root="data",
train=False,
download=True,
transform=ToTensor()
)
train_dataloader = DataLoader(training_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)
class NeuralNetwork(nn.Module):
def __init__(self):
super().__init__()
self.flatten = nn.Flatten()
self.linear_relu_stack = nn.Sequential(
nn.Linear(28*28, 512),
nn.ReLU(),
nn.Linear(512, 512),
nn.ReLU(),
nn.Linear(512, 10),
)
def forward(self, x):
x = self.flatten(x)
logits = self.linear_relu_stack(x)
return logits
model = NeuralNetwork()
0%| | 0.00/26.4M [00:00<?, ?B/s]
0%| | 65.5k/26.4M [00:00<01:12, 363kB/s]
1%| | 229k/26.4M [00:00<00:38, 681kB/s]
3%|▎ | 918k/26.4M [00:00<00:12, 2.10MB/s]
14%|█▍ | 3.67M/26.4M [00:00<00:03, 7.25MB/s]
37%|███▋ | 9.70M/26.4M [00:00<00:01, 16.6MB/s]
60%|█████▉ | 15.7M/26.4M [00:01<00:00, 22.2MB/s]
82%|████████▏ | 21.8M/26.4M [00:01<00:00, 25.8MB/s]
100%|██████████| 26.4M/26.4M [00:01<00:00, 19.3MB/s]
0%| | 0.00/29.5k [00:00<?, ?B/s]
100%|██████████| 29.5k/29.5k [00:00<00:00, 328kB/s]
0%| | 0.00/4.42M [00:00<?, ?B/s]
1%|▏ | 65.5k/4.42M [00:00<00:12, 363kB/s]
5%|▌ | 229k/4.42M [00:00<00:06, 682kB/s]
21%|██ | 918k/4.42M [00:00<00:01, 2.11MB/s]
83%|████████▎ | 3.67M/4.42M [00:00<00:00, 7.28MB/s]
100%|██████████| 4.42M/4.42M [00:00<00:00, 6.10MB/s]
0%| | 0.00/5.15k [00:00<?, ?B/s]
100%|██████████| 5.15k/5.15k [00:00<00:00, 49.1MB/s]
超引數#
超引數是可調整的引數，可讓您控制模型最佳化過程。不同的超引數值會影響模型訓練和收斂速度（有關超引數調優，點選此處瞭解更多）。
- 我們為訓練定義了以下超引數：
Epochs 數量 - 迭代資料集的次數
Batch Size - 在引數更新之前透過網路傳播的資料樣本數量
學習率 - 在每個 batch/epoch 中更新模型引數的幅度。較小的值會產生較慢的學習速度，而較大的值可能會在訓練期間導致不可預測的行為。
learning_rate = 1e-3
batch_size = 64
epochs = 5
最佳化迴圈#
一旦我們設定好超引數，就可以透過最佳化迴圈來訓練和最佳化我們的模型。最佳化迴圈的每次迭代稱為一個epoch。
- 每個 epoch 包含兩個主要部分：
訓練迴圈 - 迭代訓練資料集並嘗試收斂到最優引數。
驗證/測試迴圈 - 迭代測試資料集以檢查模型效能是否正在提高。
讓我們簡要熟悉一下訓練迴圈中使用的一些概念。跳轉到檢視最佳化迴圈的完整實現。
損失函式#
當呈現一些訓練資料時，我們未經訓練的網路很可能無法給出正確答案。損失函式衡量獲得結果與目標值之間的不相似程度，而損失函式是我們希望在訓練期間最小化的目標。為了計算損失，我們使用給定資料樣本的輸入進行預測，並將其與真實資料標籤值進行比較。
常見的損失函式包括用於迴歸任務的 nn.MSELoss（均方誤差），以及用於分類的 nn.NLLLoss（負對數似然）。nn.CrossEntropyLoss 結合了 nn.LogSoftmax 和 nn.NLLLoss。
我們將模型的輸出 logits 傳遞給 nn.CrossEntropyLoss，它將對 logits 進行歸一化並計算預測誤差。
# Initialize the loss function
loss_fn = nn.CrossEntropyLoss()
最佳化器#
最佳化是在每個訓練步驟中調整模型引數以減少模型誤差的過程。最佳化演算法定義了此過程的執行方式（在本例中我們使用隨機梯度下降）。所有最佳化邏輯都封裝在 optimizer 物件中。在這裡，我們使用 SGD 最佳化器；此外，PyTorch 中還有許多不同的最佳化器，如 ADAM 和 RMSProp，它們對不同型別的模型和資料效果更好。
我們透過註冊需要訓練的模型引數並傳入學習率超引數來初始化最佳化器。
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
- 在訓練迴圈中，最佳化分三個步驟進行：
呼叫
optimizer.zero_grad()來重置模型引數的梯度。預設情況下，梯度會累加；為防止重複計算，我們在每次迭代時顯式將其清零。透過呼叫
loss.backward()對預測損失進行反向傳播。PyTorch 將損失關於每個引數的梯度沉積下來。一旦我們有了梯度，我們就呼叫
optimizer.step()來根據反向傳播收集的梯度調整引數。
完整實現#
我們定義了 train_loop 來遍歷我們的最佳化程式碼，以及 test_loop 來評估模型在我們的測試資料上的效能。
def train_loop(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset)
# Set the model to training mode - important for batch normalization and dropout layers
# Unnecessary in this situation but added for best practices
model.train()
for batch, (X, y) in enumerate(dataloader):
# Compute prediction and loss
pred = model(X)
loss = loss_fn(pred, y)
# Backpropagation
loss.backward()
optimizer.step()
optimizer.zero_grad()
if batch % 100 == 0:
loss, current = loss.item(), batch * batch_size + len(X)
print(f"loss: {loss:>7f} [{current:>5d}/{size:>5d}]")
def test_loop(dataloader, model, loss_fn):
# Set the model to evaluation mode - important for batch normalization and dropout layers
# Unnecessary in this situation but added for best practices
model.eval()
size = len(dataloader.dataset)
num_batches = len(dataloader)
test_loss, correct = 0, 0
# Evaluating the model with torch.no_grad() ensures that no gradients are computed during test mode
# also serves to reduce unnecessary gradient computations and memory usage for tensors with requires_grad=True
with torch.no_grad():
for X, y in dataloader:
pred = model(X)
test_loss += loss_fn(pred, y).item()
correct += (pred.argmax(1) == y).type(torch.float).sum().item()
test_loss /= num_batches
correct /= size
print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")
我們初始化損失函式和最佳化器，並將它們傳遞給 train_loop 和 test_loop。您可以隨意增加 epoch 的數量來跟蹤模型不斷提高的效能。
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
epochs = 10
for t in range(epochs):
print(f"Epoch {t+1}\n-------------------------------")
train_loop(train_dataloader, model, loss_fn, optimizer)
test_loop(test_dataloader, model, loss_fn)
print("Done!")
Epoch 1
-------------------------------
loss: 2.301682 [ 64/60000]
loss: 2.285376 [ 6464/60000]
loss: 2.264773 [12864/60000]
loss: 2.262620 [19264/60000]
loss: 2.242884 [25664/60000]
loss: 2.210080 [32064/60000]
loss: 2.218796 [38464/60000]
loss: 2.187026 [44864/60000]
loss: 2.189476 [51264/60000]
loss: 2.150710 [57664/60000]
Test Error:
Accuracy: 48.5%, Avg loss: 2.146050
Epoch 2
-------------------------------
loss: 2.163555 [ 64/60000]
loss: 2.151922 [ 6464/60000]
loss: 2.090656 [12864/60000]
loss: 2.105403 [19264/60000]
loss: 2.059481 [25664/60000]
loss: 1.987678 [32064/60000]
loss: 2.020719 [38464/60000]
loss: 1.941789 [44864/60000]
loss: 1.948240 [51264/60000]
loss: 1.865856 [57664/60000]
Test Error:
Accuracy: 56.8%, Avg loss: 1.867382
Epoch 3
-------------------------------
loss: 1.907977 [ 64/60000]
loss: 1.877919 [ 6464/60000]
loss: 1.752169 [12864/60000]
loss: 1.791735 [19264/60000]
loss: 1.694619 [25664/60000]
loss: 1.629127 [32064/60000]
loss: 1.656080 [38464/60000]
loss: 1.560837 [44864/60000]
loss: 1.584142 [51264/60000]
loss: 1.472721 [57664/60000]
Test Error:
Accuracy: 60.7%, Avg loss: 1.494831
Epoch 4
-------------------------------
loss: 1.569816 [ 64/60000]
loss: 1.532427 [ 6464/60000]
loss: 1.379199 [12864/60000]
loss: 1.455104 [19264/60000]
loss: 1.350519 [25664/60000]
loss: 1.330791 [32064/60000]
loss: 1.353287 [38464/60000]
loss: 1.281627 [44864/60000]
loss: 1.312833 [51264/60000]
loss: 1.215242 [57664/60000]
Test Error:
Accuracy: 63.2%, Avg loss: 1.240029
Epoch 5
-------------------------------
loss: 1.323688 [ 64/60000]
loss: 1.299249 [ 6464/60000]
loss: 1.134269 [12864/60000]
loss: 1.246203 [19264/60000]
loss: 1.130681 [25664/60000]
loss: 1.143055 [32064/60000]
loss: 1.173563 [38464/60000]
loss: 1.112152 [44864/60000]
loss: 1.144440 [51264/60000]
loss: 1.066337 [57664/60000]
Test Error:
Accuracy: 64.5%, Avg loss: 1.082814
Epoch 6
-------------------------------
loss: 1.160265 [ 64/60000]
loss: 1.153253 [ 6464/60000]
loss: 0.973964 [12864/60000]
loss: 1.114817 [19264/60000]
loss: 0.994453 [25664/60000]
loss: 1.015597 [32064/60000]
loss: 1.060178 [38464/60000]
loss: 1.004292 [44864/60000]
loss: 1.033947 [51264/60000]
loss: 0.970858 [57664/60000]
Test Error:
Accuracy: 65.8%, Avg loss: 0.980146
Epoch 7
-------------------------------
loss: 1.045717 [ 64/60000]
loss: 1.057187 [ 6464/60000]
loss: 0.863114 [12864/60000]
loss: 1.025756 [19264/60000]
loss: 0.907181 [25664/60000]
loss: 0.923614 [32064/60000]
loss: 0.983985 [38464/60000]
loss: 0.933591 [44864/60000]
loss: 0.956259 [51264/60000]
loss: 0.905276 [57664/60000]
Test Error:
Accuracy: 67.3%, Avg loss: 0.908974
Epoch 8
-------------------------------
loss: 0.959833 [ 64/60000]
loss: 0.989362 [ 6464/60000]
loss: 0.782534 [12864/60000]
loss: 0.961402 [19264/60000]
loss: 0.847928 [25664/60000]
loss: 0.854421 [32064/60000]
loss: 0.929225 [38464/60000]
loss: 0.885736 [44864/60000]
loss: 0.899851 [51264/60000]
loss: 0.857163 [57664/60000]
Test Error:
Accuracy: 68.7%, Avg loss: 0.856961
Epoch 9
-------------------------------
loss: 0.892750 [ 64/60000]
loss: 0.938033 [ 6464/60000]
loss: 0.721357 [12864/60000]
loss: 0.912915 [19264/60000]
loss: 0.805165 [25664/60000]
loss: 0.801190 [32064/60000]
loss: 0.887380 [38464/60000]
loss: 0.852141 [44864/60000]
loss: 0.857553 [51264/60000]
loss: 0.819816 [57664/60000]
Test Error:
Accuracy: 69.7%, Avg loss: 0.817237
Epoch 10
-------------------------------
loss: 0.838739 [ 64/60000]
loss: 0.896917 [ 6464/60000]
loss: 0.673159 [12864/60000]
loss: 0.875241 [19264/60000]
loss: 0.772530 [25664/60000]
loss: 0.759746 [32064/60000]
loss: 0.853734 [38464/60000]
loss: 0.827200 [44864/60000]
loss: 0.824924 [51264/60000]
loss: 0.789588 [57664/60000]
Test Error:
Accuracy: 70.8%, Avg loss: 0.785563
Done!
進一步閱讀#
指令碼總執行時間：(1 分鐘 14.133 秒)
