GPU訓練及類的call方法
一、GPU訓練
與day33采用的CPU訓練不同，今天試著讓模型在GPU上訓練，引入import time比較兩者在運行時間上的差異
import torch
# 設置GPU設備
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"使用設備: {device}")# 仍然用4特征，3分類的鳶尾花數據集作為我們今天的數據集
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
import numpy as np
import time# 加載數據集
iris = load_iris()
x = iris.data
y = iris.target
# 劃分數據集
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)
# 歸一化數據，神經網絡對于輸入數據的尺寸敏感，歸一化是最常見的處理方式
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
x_train = scaler.fit_transform(x_train)
x_test = scaler.transform(x_test) #確保訓練集和測試集使用相同的縮放因子
# 將數據轉換為PyTorch張量并移至GPU
# 分類問題交叉熵損失要求標簽為long類型
# 張量具有to(device)方法，可以將張量移動到指定的設備上
x_train = torch.FloatTensor(x_train).to(device)
y_train = torch.LongTensor(y_train).to(device)
x_test = torch.FloatTensor(x_test).to(device)
y_test = torch.LongTensor(y_test).to(device)import torch.nn as nn # 導入PyTorch的神經網絡模塊
import torch.optim as optim # 導入PyTorch的優化器模塊
class MLP(nn.Module): # 定義一個多層感知機（MLP）模型，繼承父類nn.Moduledef __init__(self): # 初始化函數super(MLP, self).__init__() # 調用父類的初始化函數# 定義的前三行是八股文，后面的是自定義的self.fc1 = nn.Linear(4, 10) # 定義第一個全連接層，輸入維度為4，輸出維度為10self.relu = nn.ReLU() # 定義激活函數ReLUself.fc2 = nn.Linear(10, 3) # 定義第二個全連接層，輸入維度為10，輸出維度為3
# 輸出層不需要激活函數，因為后面會用到交叉熵函數cross_entropy，交叉熵函數內部有softmax函數，會把輸出轉化為概率def forward(self, x):out = self.fc1(x) # 輸入x經過第一個全連接層out = self.relu(out) # 激活函數ReLUout = self.fc2(out) # 輸入x經過第二個全連接層return out
# 實例化模型并移至GPU
# MLP繼承nn.Module類，所以也具有to(device)方法
model = MLP().to(device)
# 定義損失函數和優化器
# 分類問題使用交叉熵損失函數，適用于多分類問題，應用softmax函數將輸出映射到概率分布，然后計算交叉熵損失
criterion = nn.CrossEntropyLoss()
# 使用隨機梯度下降優化器（SGD)，學習率為0.01
optimizer = optim.SGD(model.parameters(), lr=0.01)# 開始循環訓練
# 訓練模型
num_epochs = 20000 # 訓練的輪數# 用于存儲每個 epoch 的損失值
losses = []
start_time = time.time() # 記錄開始時間
for epoch in range(num_epochs): # 開始迭代訓練過程，range是從0開始，所以epoch是從0開始# 前向傳播：將數據輸入模型，計算模型預測輸出outputs = model.forward(x_train) # 顯式調用forward函數# outputs = model(X_train) # 常見寫法隱式調用forward函數，其實是用了model類的__call__方法loss = criterion(outputs, y_train) # output是模型預測值，y_train是真實標簽，計算兩者之間損失值# 反向傳播和優化optimizer.zero_grad() #梯度清零，因為PyTorch會累積梯度，所以每次迭代需要清零，梯度累計是那種小的bitchsize模擬大的bitchsizeloss.backward() # 反向傳播計算梯度，自動完成以下計算：# 1. 計算損失函數對輸出的梯度# 2. 從輸出層→隱藏層→輸入層反向傳播# 3. 計算各層權重/偏置的梯度optimizer.step() # 更新參數# 記錄損失值losses.append(loss.item())# 打印訓練信息if (epoch + 1) % 100 == 0: # range是從0開始，所以epoch+1是從當前epoch開始，每100個epoch打印一次print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
time_all = time.time() - start_time
print(f'Training time: {time_all:.2f} seconds')
import matplotlib.pyplot as plt
# 可視化損失曲線
plt.plot(range(num_epochs), losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss over Epochs')
plt.show()
?結果顯示GPU訓練情況下訓練時間為44.96s，而昨天的CPU訓練時間為14.13s。
本質是因為GPU在計算的時候，相較于CPU多了3個時間上的開銷
1.數據傳輸開銷 (CPU 內存 <-> GPU 顯存)
- 在 GPU 進行任何計算之前，數據（輸入張量 X_train、y_train，模型參數）需要從計算機的主內存 (RAM) 復制到 GPU 專用的顯存 (VRAM) 中。
- 當結果傳回 CPU 時（例如，使用 loss.item() 獲取損失值用于打印或記錄，或者獲取最終預測結果），數據也需要從 GPU 顯存復制回 CPU 內存。
- 對于少量數據和非常快速的計算任務，這個傳輸時間可能比 GPU 通過并行計算節省下來的時間還要長。
在上述代碼中，循環里的 loss.item() 操作會在每個 epoch 都進行一次從 GPU 到 CPU 的數據同步和傳輸，以便獲取標量損失值。對于20000個epoch來說，這會累積不少的傳輸開銷。
2.核心啟動開銷 (GPU 核心啟動時間)
- GPU 執行的每個操作（例如，一個線性層的前向傳播、一個激活函數）都涉及到在 GPU 上啟動一個“核心”(kernel)——一個在 GPU 眾多計算單元上運行的小程序。
- 啟動每個核心都有一個小的、固定的開銷。
- 如果核心內的實際計算量非常小（本項目的小型網絡和鳶尾花數據），這個啟動開銷在總時間中的占比就會比較大。相比之下，CPU 執行這些小操作的“調度”開銷通常更低。
3.性能浪費：計算量和數據批次
- 這個數據量太少，gpu的很多計算單元都沒有被用到，即使用了全批次也沒有用到的全部計算單元。
綜上，數據傳輸和各種固定開銷的總和，超過了 GPU 在這點計算量上通過并行處理所能節省的時間，導致了 GPU 比 CPU 慢的現象。這些特性導致GPU在處理鳶尾花分類這種“玩具級別”的問題時，它的優勢無法體現，反而會因為上述開銷顯得“笨重”。
那么什么時候 GPU 會發揮巨大優勢？
- 大型數據集： 例如，圖像數據集成千上萬張圖片，每張圖片維度很高。
- 大型模型： 例如，深度卷積網絡 (CNNs like ResNet, VGG) 或 Transformer 模型，它們有數百萬甚至數十億的參數，計算量巨大。
- 合適的批處理大小： 能夠充分利用 GPU 并行性的 batch size，不至于還有剩余的計算量沒有被 GPU 處理。
- 復雜的、可并行的運算： 大量的矩陣乘法、卷積等。
針對上面反應的3個時間開銷問題，能夠優化的只有數據傳輸時間，針對性解決即可，很容易想到2個思路：
- 直接不打印訓練過程的loss了，但是這樣會沒辦法記錄最后的可視化圖片，只能肉眼觀察loss數值變化
- 每隔200個epoch保存一下loss，不需要20000個epoch每次都打印
經試驗，思路一去除圖片打印部分的情況下訓練時間為：36.77s，思路二改變保存間隔情況下的訓練時長為：44.6s
二、__call__方法
在 Python 中，__call__方法是一個特殊的魔術方法，它允許類的實例像函數一樣被調用。這種特性使得對象可以表現得像函數，同時保留對象的內部狀態。
# 不帶參數的call方法
class Counter:def __init__(self):self.count = 0def __call__(self):self.count += 1return self.count# 使用示例
counter = Counter() # 實例化對象，通過__init__方法初始化count為0
print(counter()) # 調用__call__,輸出: 1
print(counter()) # counter=1再代入call方法，輸出: 2
print(counter.count) # 輸出: 2# 帶參數的call方法
class Adder:def __call__(self, a, b):print("唱跳籃球rap")return a + badder = Adder()
print(adder(3, 5))
# 輸出:
# 唱跳籃球rap
# 8
)
