PyTorch 深度學習模型訓練與最佳化技巧

– 8 分鐘閱讀

PyTorch 提供了豐富的工具和函式庫，方便開發者建構和訓練各種深度學習模型。從模型的初始化、資料的準備到訓練過程的監控，PyTorch 都提供了簡潔易用的介面。本篇文章將會逐步說明如何使用 PyTorch 建立一個深度學習模型，並探討訓練過程中的一些關鍵技巧，包含損失函式的選擇、最佳化器的使用以及訓練迴圈的設計。同時，我們也會介紹一些進階技巧，例如批次歸一化（Batch Normalization）和 Dropout，以提升模型的效能和泛化能力。最後，我們將會以一個實際的案例，示範如何使用 PyTorch 建構一個卷積神經網路（CNN），並將其應用於影像分類別任務。

建立模型

首先，需要建立一個PyTorch模型。這可以透過繼承nn.Module類別並定義模型的結構和層次來實作。例如：

import torch
import torch.nn as nn

class HousePricesModel(nn.Module):
    def __init__(self, hidden_size=13):
        super(HousePricesModel, self).__init__()
        self.fc1 = nn.Linear(13, hidden_size)
        self.fc2 = nn.Linear(hidden_size, 1)

    def forward(self, x):
        x = torch.sigmoid(self.fc1(x))
        return self.fc2(x)

這個模型有兩個全連線層（fc1和fc2），其中fc1的輸入維度為13，輸出維度為hidden_size，而fc2的輸入維度為hidden_size，輸出維度為1。

設定最佳化器

最佳化器是用於更新模型引數的演算法。PyTorch提供了多種最佳化器，包括隨機梯度下降（SGD）、Adam等。下面是設定最佳化器的步驟：

import torch.optim as optim

# 建立模型例項
model = HousePricesModel(hidden_size=13)

# 設定最佳化器
optimizer = optim.SGD(model.parameters(), lr=0.001)

這裡，最佳化器是SGD，學習率為0.001。

設定損失函式

損失函式是用於評估模型預測結果與真實結果之間的差異。PyTorch提供了多種損失函式，包括均方誤差（MSE）、交叉熵等。下面是設定損失函式的步驟：

import torch.nn as nn

# 設定損失函式
loss_fn = nn.MSELoss()

這裡，損失函式是MSE。

訓練模型

訓練模型需要將輸入資料傳入模型，計算損失，並更新模型引數。下面是訓練模型的步驟：

# 訓練模型
for epoch in range(100):
    # 將輸入資料傳入模型
    output = model(X_batch)
    
    # 計算損失
    loss = loss_fn(output, y_batch)
    
    # 更新模型引數
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

這裡，訓練模型需要100個epoch，每個epoch都需要將輸入資料傳入模型，計算損失，並更新模型引數。

PyTorch Trainer 類別實作

PyTorch Trainer 是一個根據 PyTorch 的模型訓練器，負責管理模型、最佳化器和損失函式。以下是 PyTorch Trainer 類別的實作：

初始化

class PyTorchTrainer(object):
    def __init__(self, model: PyTorchModel, optim: Optimizer, criterion: _Loss):
        self.model = model
        self.optim = optim
        self.loss = criterion
        self._check_optim_net_aligned()

在初始化方法中，我們設定了模型、最佳化器和損失函式。

檢查最佳化器和模型引數對齊

def _check_optim_net_aligned(self):
    assert self.optim.param_groups[0]['params'] == list(self.model.parameters())

這個方法檢查最佳化器的引數是否與模型的引數對齊。

生成批次

def _generate_batches(self, X: Tensor, y: Tensor, size: int = 32) -> Tuple[Tensor]:
    N = X.shape[0]
    for ii in range(0, N, size):
        yield X[ii:ii+size], y[ii:ii+size]

這個方法生成批次，批次大小為 size。

計算損失和反向傳播

def train(self, X: Tensor, y: Tensor):
    output = self.model(X)
    loss = self.loss(output, y)
    loss.backward()
    self.optim.step()

在 train 方法中，我們計算模型的輸出，然後計算損失和反向傳播，最後更新模型引數。

完整程式碼

import torch
import torch.nn as nn
import torch.optim as optim

class PyTorchModel(nn.Module):
    def __init__(self):
        super(PyTorchModel, self).__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 10)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

class PyTorchTrainer(object):
    def __init__(self, model: PyTorchModel, optim: Optimizer, criterion: _Loss):
        self.model = model
        self.optim = optim
        self.loss = criterion
        self._check_optim_net_aligned()

    def _check_optim_net_aligned(self):
        assert self.optim.param_groups[0]['params'] == list(self.model.parameters())

    def _generate_batches(self, X: Tensor, y: Tensor, size: int = 32) -> Tuple[Tensor]:
        N = X.shape[0]
        for ii in range(0, N, size):
            yield X[ii:ii+size], y[ii:ii+size]

    def train(self, X: Tensor, y: Tensor):
        output = self.model(X)
        loss = self.loss(output, y)
        loss.backward()
        self.optim.step()

# 初始化模型、最佳化器和損失函式
model = PyTorchModel()
optim = optim.SGD(model.parameters(), lr=0.01)
criterion = nn.CrossEntropyLoss()

# 初始化 PyTorch Trainer
trainer = PyTorchTrainer(model, optim, criterion)

# 訓練模型
X = torch.randn(100, 784)
y = torch.randint(0, 10, (100,))
trainer.train(X, y)

這個程式碼定義了 PyTorch Model 和 PyTorch Trainer 類別，然後初始化模型、最佳化器和損失函式，最後訓練模型。

使用 PyTorch 進行深度學習

在進行深度學習任務時，PyTorch 是一個非常流行且強大的框架。下面是一個使用 PyTorch 進行模型訓練的例子。

資料準備

首先，我們需要準備好資料。這包括將資料分割成訓練集和測試集，以及定義批次大小（batch size）。

def _generate_batches(X: Tensor, y: Tensor, batch_size: int):
    """
    生成批次資料。
    
    Args:
    X (Tensor): 輸入資料。
    y (Tensor): 標籤資料。
    batch_size (int): 批次大小。
    
    Yields:
    X_batch (Tensor): 批次輸入資料。
    y_batch (Tensor): 批次標籤資料。
    """
    for ii in range(0, len(X), batch_size):
        X_batch, y_batch = X[ii:ii+batch_size], y[ii:ii+batch_size]
        yield X_batch, y_batch

模型定義

接下來，我們需要定義模型。這包括定義模型的架構、最佳化器（optimizer）和損失函式（loss function）。

class HousePricesModel(nn.Module):
    def __init__(self):
        super(HousePricesModel, self).__init__()
        # 定義模型架構
        self.fc1 = nn.Linear(10, 128)  # 輸入層（10）-> 隱藏層（128）
        self.fc2 = nn.Linear(128, 1)  # 隱藏層（128）-> 輸出層（1）

    def forward(self, x):
        # 定義前向傳播
        x = torch.relu(self.fc1(x))  # 啟用函式為 ReLU
        x = self.fc2(x)
        return x

最佳化器和損失函式

最佳化器用於更新模型引數，損失函式用於評估模型的效能。

optimizer = optim.SGD(net.parameters(), lr=0.001)  # 定義最佳化器
loss_fn = nn.MSELoss()  # 定義損失函式

訓練模型

現在，我們可以開始訓練模型了。

def fit(self, X_train: Tensor, y_train: Tensor, X_test: Tensor, y_test: Tensor, epochs: int=100, eval_every: int=10, batch_size: int=32):
    for e in range(epochs):
        # 對資料進行打亂
        X_train, y_train = permute_data(X_train, y_train)
        
        # 生成批次資料
        batch_generator = self._generate_batches(X_train, y_train, batch_size)
        
        for ii, (X_batch, y_batch) in enumerate(batch_generator):
            # 清空最佳化器的梯度
            self.optim.zero_grad()
            
            # 前向傳播
            output = self.model(X_batch)
            
            # 計算損失
            loss = self.loss(output, y_batch)
            
            # 反向傳播
            loss.backward()
            
            # 更新模型引數
            self.optim.step()
        
        # 評估模型在測試集上的效能
        output = self.model(X_test)
        loss = self.loss(output, y_test)
        print(e, loss)

完整程式碼

以下是完整的程式碼。

import torch
import torch.nn as nn
import torch.optim as optim

class HousePricesModel(nn.Module):
    def __init__(self):
        super(HousePricesModel, self).__init__()
        self.fc1 = nn.Linear(10, 128)
        self.fc2 = nn.Linear(128, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

class Trainer:
    def __init__(self, model, optimizer, loss_fn):
        self.model = model
        self.optim = optimizer
        self.loss = loss_fn

    def _generate_batches(self, X: torch.Tensor, y: torch.Tensor, batch_size: int):
        for ii in range(0, len(X), batch_size):
            X_batch, y_batch = X[ii:ii+batch_size], y[ii:ii+batch_size]
            yield X_batch, y_batch

    def fit(self, X_train: torch.Tensor, y_train: torch.Tensor, X_test: torch.Tensor, y_test: torch.Tensor, epochs: int=100, eval_every: int=10, batch_size: int=32):
        for e in range(epochs):
            X_train, y_train = permute_data(X_train, y_train)
            batch_generator = self._generate_batches(X_train, y_train, batch_size)
            for ii, (X_batch, y_batch) in enumerate(batch_generator):
                self.optim.zero_grad()
                output = self.model(X_batch)
                loss = self.loss(output, y_batch)
                loss.backward()
                self.optim.step()
            output = self.model(X_test)
            loss = self.loss(output, y_test)
            print(e, loss)

# 定義模型、最佳化器和損失函式
net = HousePricesModel()
optimizer = optim.SGD(net.parameters(), lr=0.001)
loss_fn = nn.MSELoss()

# 定義 Trainer
trainer = Trainer(net, optimizer, loss_fn)

# 訓練模型
trainer.fit(X_train, y_train, X_test, y_test)

圖表翻譯

以下是圖表的翻譯。

  graph LR
    A[資料準備] --> B[模型定義]
    B --> C[最佳化器和損失函式]
    C --> D[訓練模型]
    D --> E[評估模型]

這個圖表展示了深度學習的流程，從資料準備到模型定義、最佳化器和損失函式的選擇，然後是模型的訓練和評估。

PyTorch 中的神經網路訓練

PyTorch 是一個強大的深度學習框架，提供了多種工具和功能來幫助使用者訓練和最佳化神經網路。在本文中，我們將介紹 PyTorch 中的神經網路訓練過程，包括損失函式、最佳化器和訓練迴圈等。

損失函式

損失函式（Loss Function）是用於衡量模型預測值與真實值之間的差異。PyTorch 提供了多種損失函式，包括均方差損失（MSELoss）、交叉熵損失（CrossEntropyLoss）等。在本例中，我們使用均方差損失函式。

criterion = nn.MSELoss()

最佳化器

最佳化器（Optimizer）是用於更新模型引數的演算法。PyTorch 提供了多種最佳化器，包括隨機梯度下降（SGD）、Adam 等。在本例中，我們使用 SGD 最佳化器。

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

訓練迴圈

訓練迴圈（Training Loop）是用於訓練模型的迴圈。在每次迭代中，模型會對輸入資料進行預測，計算損失值，並更新模型引數。

for epoch in range(10):
    # 前向傳播
    outputs = model(inputs)
    loss = criterion(outputs, labels)
    
    # 後向傳播
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

PyTorch 中的卷積神經網路

卷積神經網路（Convolutional Neural Network，CNN）是一種常用的深度學習模型，特別適合於影像和影片資料的處理。PyTorch 提供了多種工具和功能來幫助使用者建立和訓練 CNN 模型。

卷積層

卷積層（Convolutional Layer）是 CNN 中的一種基本層，負責對輸入資料進行卷積運算。PyTorch 提供了 nn.Conv2d 函式來建立卷積層。

class ConvLayer(nn.Module):
    def __init__(self, in_channels, out_channels, filter_size):
        super(ConvLayer, self).__init__()
        self.conv = nn.Conv2d(in_channels, out_channels, filter_size)
        
    def forward(self, x):
        x = self.conv(x)
        return x

池化層

池化層（Pooling Layer）是 CNN 中的一種基本層，負責對輸入資料進行池化運算。PyTorch 提供了 nn.MaxPool2d 函式來建立池化層。

class PoolingLayer(nn.Module):
    def __init__(self, kernel_size):
        super(PoolingLayer, self).__init__()
        self.pool = nn.MaxPool2d(kernel_size)
        
    def forward(self, x):
        x = self.pool(x)
        return x

PyTorch 中的批次歸一化

批次歸一化（Batch Normalization）是一種用於加速深度學習模型訓練的技術。PyTorch 提供了 nn.BatchNorm2d 函式來建立批次歸一化層。

class BatchNormalizationLayer(nn.Module):
    def __init__(self, num_features):
        super(BatchNormalizationLayer, self).__init__()
        self.bn = nn.BatchNorm2d(num_features)
        
    def forward(self, x):
        x = self.bn(x)
        return x

PyTorch 中的 Dropout

Dropout 是一種用於防止過度擬合的技術。PyTorch 提供了 nn.Dropout 函式來建立 Dropout 層。

class DropoutLayer(nn.Module):
    def __init__(self, p):
        super(DropoutLayer, self).__init__()
        self.dropout = nn.Dropout(p)
        
    def forward(self, x):
        x = self.dropout(x)
        return x

使用PyTorch實作卷積神經網路

在本文中，我們將使用PyTorch框架實作一個簡單的卷積神經網路（ConvNet），並將其應用於MNIST資料集。

定義ConvNet模型

首先，我們定義一個名為MNIST_ConvNet的類別，繼承自PyTorchModel。在__init__方法中，我們初始化了幾個層，包括兩個卷積層和兩個全連線層。

class MNIST_ConvNet(PyTorchModel):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(1, 16, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(16, 8, kernel_size=3, padding=1)
        self.dense1 = nn.Linear(28 * 28 * 8, 32)
        self.dense2 = nn.Linear(32, 10)

定義forward方法

在forward方法中，我們定義了網路的前向傳播過程。首先，我們對輸入資料進行卷積運算，然後對結果進行flatten和dropout處理。接下來，我們對flatten後的資料進行全連線運算，最後輸出結果。

def forward(self, x: Tensor) -> Tensor:
    x = torch.relu(self.conv1(x))
    x = torch.relu(self.conv2(x))
    x = x.view(-1, 28 * 28 * 8)
    x = torch.relu(self.dense1(x))
    x = self.dense2(x)
    return x

訓練模型

定義好模型後，我們可以開始訓練了。首先，我們初始化模型、損失函式和最佳化器，然後建立一個PyTorchTrainer例項。最後，我們呼叫fit方法開始訓練。

model = MNIST_ConvNet()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
trainer = PyTorchTrainer(model, optimizer, criterion)
trainer.fit(X_train, y_train, X_test, y_test, epochs=5)

Mermaid圖表

  graph LR
    A[輸入資料] --> B[卷積層1]
    B --> C[卷積層2]
    C --> D[flatten]
    D --> E[全連線層1]
    E --> F[全連線層2]
    F --> G[輸出]

圖表翻譯

此圖表展示了ConvNet模型的架構。輸入資料首先經過兩個卷積層，然後進行flatten處理。接下來，資料經過兩個全連線層，最後輸出結果。每個層的輸出都會經過啟用函式處理，以增加模型的非線性表達能力。

從模型建構、訓練流程到實際程式碼範例的全面解析，本文深入探討瞭如何利用 PyTorch 框架實作深度學習模型，特別是聚焦於神經網路和卷積神經網路的訓練技巧。文章不僅清晰地闡述了損失函式、最佳化器、訓練迴圈等核心概念，更進一步講解了卷積層、池化層、批次歸一化和 Dropout 等關鍵技術的應用，並佐以 MNIST 手寫數字辨識的卷積網路實作案例，展現了 PyTorch 在構建和訓練複雜模型方面的靈活性與高效性。技術堆疊的各層級協同運作中體現，PyTorch 提供的豐富模組和函式庫，讓開發者得以快速搭建客製化的深度學習模型，並透過自動微分機制簡化訓練流程。然而，模型的效能調校仍是一大挑戰，需要開發者根據具體任務和資料集特性，謹慎選擇網路架構、超引數和訓練策略。展望未來，隨著 PyTorch 生態系統的持續發展，預期會有更多自動化工具和技術出現，進一步降低深度學習的門檻，並推動其在更多領域的應用落地。對於想要深入鑽研深度學習的開發者，建議著重掌握 PyTorch 的核心模組和 API，並積極探索社群中的最佳實務和案例分享，才能更有效地利用 PyTorch 的強大功能，打造高效能的深度學習應用。

玄貓

玄貓

技術愛好者，專注於分享程式開發、雲端技術與 AI 應用的心得體會。