当前位置： 首页 > news >正文

Python 训练营打卡 Day 34

news 来源：原创 2025/5/25 9:00:02

GPU训练及类的call方法

一、GPU训练

与day33采用的CPU训练不同，今天试着让模型在GPU上训练，引入import time比较两者在运行时间上的差异

# 设置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个思路：

  1. 直接不打印训练过程的loss了，但是这样会没办法记录最后的可视化图片，只能肉眼观察loss数值变化
  2. 每隔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

相关文章：

  • 基于Springboot + vue3实现的养老系统
  • 电子电路：再谈滤波原理及其应用
  • 卷积神经网络优化与应用实践：参数设置、泛化能力提升及多领域应用解析
  • LeetCode 3362.零数组变换 III：贪心+优先队列+差分数组——清晰题解
  • 6个月Python学习计划 Day 3
  • 【第四篇】 SpringBoot整合第三方技术
  • 【Linux 学习计划】-- git 在Linux远端服务器上的部署与简单使用
  • Ubuntu24安装Ollama
  • Java三十而立：Java 的30岁与Spring AI 1.0正式发布
  • ABC406E 题解
  • 1.4 TypeScript 编译是如何工作的？
  • [案例六] NX二次开发减重块的实现（支持组件和实体）
  • 鸿蒙UI开发——上拉抽屉的更新与事件回调
  • CMake指令：add_library()
  • 单例模式总结
  • Python训练营---Day35
  • 【笔记】OpenCV的学习（未完）
  • 开发者工具箱-鸿蒙颜色转换器开发笔记
  • React Native 拼音及拼音首字母搜索组件开发
  • LLM Tuning
  • 做家装家居网站/如何免费开自己的网站
  • 哈尔滨百度推广代理/惠州seo网站推广
  • 网站上的文章做参考文献/万能软文范例800字
  • 巢湖网站设计/石家庄百度搜索引擎优化
  • 自适应网站如何做mip网页/品牌推广策略
  • 长春网站建设机构/淘宝关键词指数查询