機器學習 | PyTorch簡明教程上篇

作者：周末程序猿 2023-11-02 14:26:30

前面幾篇文章介紹了特征歸一化和張量，接下來開始寫兩篇PyTorch簡明教程，主要介紹PyTorch簡單實踐。

1、四則運算

import torch

a = torch.tensor([2, 3, 4])
b = torch.tensor([3, 4, 5])
print("a + b: ", (a + b).numpy())
print("a - b: ", (a - b).numpy())
print("a * b: ", (a * b).numpy())
print("a / b: ", (a / b).numpy())

加減乘除就不用多解釋了，輸出為：

a + b:  [5 7 9]
a - b:  [-1 -1 -1]
a * b:  [ 6 12 20]
a / b:  [0.6666667 0.75      0.8      ]

2、線性回歸

線性回歸是找到一條直線盡可能接近已知點，如圖：

圖1

import torch
from torch import optim

def build_model1():
    return torch.nn.Sequential(
        torch.nn.Linear(1, 1, bias=False)
    )

def build_model2():
    model = torch.nn.Sequential()
    model.add_module("linear", torch.nn.Linear(1, 1, bias=False))
    return model

def train(model, loss, optimizer, x, y):
    model.train()
    optimizer.zero_grad()
    fx = model.forward(x.view(len(x), 1)).squeeze()
    output = loss.forward(fx, y)
    output.backward()
    optimizer.step()
    return output.item()

def main():
    torch.manual_seed(42)
    X = torch.linspace(-1, 1, 101, requires_grad=False)
    Y = 2 * X + torch.randn(X.size()) * 0.33
    print("X: ", X.numpy(), ", Y: ", Y.numpy())
    model = build_model1()
    loss = torch.nn.MSELoss(reductinotallow='mean')
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
    batch_size = 10

    for i in range(100):
        cost = 0.
        num_batches = len(X) // batch_size
        for k in range(num_batches):
            start, end = k * batch_size, (k + 1) * batch_size
            cost += train(model, loss, optimizer, X[start:end], Y[start:end])
        print("Epoch = %d, cost = %s" % (i + 1, cost / num_batches))

    w = next(model.parameters()).data
    print("w = %.2f" % w.numpy())

if __name__ == "__main__":
    main()

（1）先從main函數開始，torch.manual_seed(42)用于設置隨機數生成器的種子，以確保在每次運行時生成的隨機數序列相同，該函數接受一個整數參數作為種子，可以在訓練神經網絡等需要隨機數的場景中使用，以確保結果的可重復性；

（2）torch.linspace(-1, 1, 101, requires_grad=False)用于在指定的區間內生成一組等間隔的數值，該函數接受三個參數：起始值、終止值和元素個數，返回一個張量，其中包含了指定個數的等間隔數值；

（3）build_model1內部實現：

torch.nn.Sequential(torch.nn.Linear(1, 1, bias=False))中使用nn.Sequential類的構造函數，將線性層作為參數傳遞給它，然后返回一個包含該線性層的神經網絡模型；
build_model2和build_model1功能一樣，使用add_module()方法向其中添加了一個名為linear的子模塊；

（4）torch.nn.MSELoss(reductinotallow='mean')定義損失函數；

（5）optim.SGD(model.parameters(), lr=0.01, momentum=0.9)實現隨機梯度下降（Stochastic Gradient Descent，SGD）優化算法；

（6）通過batch_size將訓練集拆分，循環100次；

（7）接下來是訓練函數train，用于訓練一個神經網絡模型，具體來說，該函數接受以下參數：

model：神經網絡模型，通常是一個繼承自nn.Module的類的實例；
loss：損失函數，用于計算模型的預測值與真實值之間的差異；
optimizer：優化器，用于更新模型的參數；
x：輸入數據，是一個torch.Tensor類型的張量；
y：目標數據，是一個torch.Tensor類型的張量；

（8）train是PyTorch訓練步驟的通用方法，步驟如下：

將模型設置為訓練模式，即啟用dropout和batch normalization等訓練時使用的特殊操作；
將優化器的梯度緩存清零，以便進行新一輪的梯度計算；
將輸入數據傳遞給模型，計算模型的預測值，并將預測值與目標數據傳遞給損失函數，計算損失值；
對損失值進行反向傳播，計算模型參數的梯度；
使用優化器更新模型參數，以最小化損失值；
返回損失值的標量值；

（9）print("Epoch = %d, cost = %s" % (i + 1, cost / num_batches))最后打印當前訓練的輪次和損失值，上述的代碼輸出如下：

...
Epoch = 95, cost = 0.10514946877956391
Epoch = 96, cost = 0.10514946877956391
Epoch = 97, cost = 0.10514946877956391
Epoch = 98, cost = 0.10514946877956391
Epoch = 99, cost = 0.10514946877956391
Epoch = 100, cost = 0.10514946877956391
w = 1.98

3、邏輯回歸

邏輯回歸即用一根曲線近似表示一堆離散點的軌跡，如圖：

圖2

import numpy as np
import torch
from torch import optim
from data_util import load_mnist

def build_model(input_dim, output_dim):
    return torch.nn.Sequential(
        torch.nn.Linear(
            input_dim, output_dim, bias=False)
    )

def train(model, loss, optimizer, x_val, y_val):
    model.train()
    optimizer.zero_grad()
    fx = model.forward(x_val)
    output = loss.forward(fx, y_val)
    output.backward()
    optimizer.step()
    return output.item()

def predict(model, x_val):
    model.eval()
    output = model.forward(x_val)
    return output.data.numpy().argmax(axis=1)

def main():
    torch.manual_seed(42)
    trX, teX, trY, teY = load_mnist(notallow=False)
    trX = torch.from_numpy(trX).float()
    teX = torch.from_numpy(teX).float()
    trY = torch.tensor(trY)

    n_examples, n_features = trX.size()
    n_classes = 10
    model = build_model(n_features, n_classes)
    loss = torch.nn.CrossEntropyLoss(reductinotallow='mean')
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
    batch_size = 100

    for i in range(100):
        cost = 0.
        num_batches = n_examples // batch_size
        for k in range(num_batches):
            start, end = k * batch_size, (k + 1) * batch_size
            cost += train(model, loss, optimizer,
                          trX[start:end], trY[start:end])
        predY = predict(model, teX)
        print("Epoch %d, cost = %f, acc = %.2f%%"
              % (i + 1, cost / num_batches, 100. * np.mean(predY == teY)))


if __name__ == "__main__":
    main()

（1）先從main函數開始，torch.manual_seed(42)上面有介紹，在此略過；

（2）load_mnist是自己實現下載mnist數據集，返回trX和teX是輸入數據，trY和teY是標簽數據；

（3）build_model內部實現：torch.nn.Sequential(torch.nn.Linear(input_dim, output_dim, bias=False))用于構建一個包含一個線性層的神經網絡模型，模型的輸入特征數量為input_dim，輸出特征數量為output_dim，且該線性層沒有偏置項，其中n_classes=10表示輸出10個分類；

（4）其他的步驟就是定義損失函數，梯度下降優化器，通過batch_size將訓練集拆分，循環100次進行train；

（5）optim.SGD(model.parameters(), lr=0.01, momentum=0.9)實現隨機梯度下降（Stochastic Gradient Descent，SGD）優化算法；

（6）每一輪訓練完成后，執行predict，該函數接受兩個參數model（訓練好的模型）和teX（需要預測的數據），步驟如下：

model.eval()模型設置為評估模式，這意味著模型將不會進行訓練，而是僅用于推理；
將output轉換為NumPy數組，并使用argmax()方法獲取每個樣本的預測類別；

（7）print("Epoch %d, cost = %f, acc = %.2f%%" % (i + 1, cost / num_batches, 100. * np.mean(predY == teY)))最后打印當前訓練的輪次，損失值和acc，上述的代碼輸出如下（執行很快，但是準確率偏低）：

...
Epoch 91, cost = 0.252863, acc = 92.52%
Epoch 92, cost = 0.252717, acc = 92.51%
Epoch 93, cost = 0.252573, acc = 92.50%
Epoch 94, cost = 0.252431, acc = 92.50%
Epoch 95, cost = 0.252291, acc = 92.52%
Epoch 96, cost = 0.252153, acc = 92.52%
Epoch 97, cost = 0.252016, acc = 92.51%
Epoch 98, cost = 0.251882, acc = 92.51%
Epoch 99, cost = 0.251749, acc = 92.51%
Epoch 100, cost = 0.251617, acc = 92.51%

4、神經網絡

一個經典的LeNet網絡，用于對字符進行分類，如圖：

圖3

定義一個多層的神經網絡
對數據集的預處理并準備作為網絡的輸入
將數據輸入到網絡
計算網絡的損失
反向傳播，計算梯度

import numpy as np
import torch
from torch import optim
from data_util import load_mnist

def build_model(input_dim, output_dim):
    return torch.nn.Sequential(
        torch.nn.Linear(input_dim, 512, bias=False),
        torch.nn.Sigmoid(),
        torch.nn.Linear(512, output_dim, bias=False)
    )

def train(model, loss, optimizer, x_val, y_val):
    model.train()
    optimizer.zero_grad()
    fx = model.forward(x_val)
    output = loss.forward(fx, y_val)
    output.backward()
    optimizer.step()
    return output.item()

def predict(model, x_val):
    model.eval()
    output = model.forward(x_val)
    return output.data.numpy().argmax(axis=1)

def main():
    torch.manual_seed(42)
    trX, teX, trY, teY = load_mnist(notallow=False)
    trX = torch.from_numpy(trX).float()
    teX = torch.from_numpy(teX).float()
    trY = torch.tensor(trY)

    n_examples, n_features = trX.size()
    n_classes = 10
    model = build_model(n_features, n_classes)
    loss = torch.nn.CrossEntropyLoss(reductinotallow='mean')
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
    batch_size = 100

    for i in range(100):
        cost = 0.
        num_batches = n_examples // batch_size
        for k in range(num_batches):
            start, end = k * batch_size, (k + 1) * batch_size
            cost += train(model, loss, optimizer,
                          trX[start:end], trY[start:end])
        predY = predict(model, teX)
        print("Epoch %d, cost = %f, acc = %.2f%%"
              % (i + 1, cost / num_batches, 100. * np.mean(predY == teY)))

if __name__ == "__main__":
    main()

（1）以上這段神經網絡的代碼與邏輯回歸沒有太多的差異，區別的地方是build_model，這里是構建一個包含兩個線性層和一個Sigmoid激活函數的神經網絡模型，該模型包含一個輸入特征數量為input_dim，輸出特征數量為output_dim的線性層，一個Sigmoid激活函數，以及一個輸入特征數量為512，輸出特征數量為output_dim的線性層；

（2）print("Epoch %d, cost = %f, acc = %.2f%%" % (i + 1, cost / num_batches, 100. * np.mean(predY == teY)))最后打印當前訓練的輪次，損失值和acc，上述的代碼輸入如下（執行時間比邏輯回歸要長，但是準確率要高很多）：

...
Epoch 91, cost = 0.054484, acc = 97.58%
Epoch 92, cost = 0.053753, acc = 97.56%
Epoch 93, cost = 0.053036, acc = 97.60%
Epoch 94, cost = 0.052332, acc = 97.61%
Epoch 95, cost = 0.051641, acc = 97.63%
Epoch 96, cost = 0.050964, acc = 97.66%
Epoch 97, cost = 0.050298, acc = 97.66%
Epoch 98, cost = 0.049645, acc = 97.67%
Epoch 99, cost = 0.049003, acc = 97.67%
Epoch 100, cost = 0.048373, acc = 97.68%

責任編輯：華軒來源：周末程序猿

PyTorch 機器學習