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
)
