python训练营day34

知识点回归：

CPU性能的查看：看架构代际、核心数、线程数
GPU性能的查看：看显存、看级别、看架构代际
GPU训练的方法：数据和模型移动到GPU device上
类的call方法：为什么定义前向传播时可以直接写作self.fc1(x)

作业

复习今天的内容，在巩固下代码。思考下为什么会出现这个问题。

计算图的动态释放与内存占用
背景：在 PyTorch 等框架中，反向传播（backward()）会基于计算图自动求导，计算图中的中间变量会被保留到反向传播完成。
小间隔记录（如 100 轮）的影响：
每次记录loss.item()时，计算图尚未销毁（反向传播未完成），需要保留所有中间变量（如激活值、梯度）的内存。
记录次数越多（如 200 次），累计内存占用可能越大，导致后续迭代中 GPU/CPU 的内存访问效率下降，甚至触发内存交换（Swap），增加隐性耗时。
大间隔记录（如 2000 轮）的影响：
反向传播完成后，计算图会被自动销毁，中间变量内存被释放。
记录次数少（如 10 次），内存占用稳定，反向传播效率更高。
现象解释：
小间隔记录可能因内存占用波动导致单次迭代耗时不稳定，而大间隔记录因内存管理更高效，单次迭代耗时更稳定，最终导致剩余时长未随记录次数线性增加。
GPU 计算与 CPU 同步的重叠特性
loss.item()的同步机制：
当 GPU 计算完loss后，loss.item()会将数据从 GPU 显存同步到 CPU 内存，这是一个阻塞操作（需等待 GPU 当前批次完成）。
硬件并行性的掩盖效应：
若训练批次较大（如 Batch Size=64），GPU 计算耗时（前向 + 反向传播）可能远大于loss.item()的同步耗时。
同步操作的耗时占比极低（如仅 0.1 秒），被 GPU 的并行计算掩盖，导致总耗时变化不明显。
现象解释：
记录次数增加时，同步操作总耗时（如 200 次 ×0.01 秒 = 2 秒）可能小于 GPU 计算的随机波动（如每次迭代耗时波动 ±0.5 秒），因此剩余时长无显著线性变化。
剩余时长的估计误差
剩余时长的计算逻辑：
通常基于最近 N 轮的平均耗时估算，公式为：
剩余时长 = (总epoch - 已完成epoch) × 平均耗时
小间隔记录的干扰：
若小间隔记录时（如 100 轮），某次迭代因内存波动导致耗时突然增加，会显著拉高平均耗时估计值，而后续迭代耗时恢复正常后，估计值未及时修正。
大间隔记录的稳定性：
大间隔记录时，平均耗时基于更多迭代（如 2000 轮）计算，波动被平滑，估计更稳定。
现象解释：
表格中 "剩余时长" 接近 10 秒，可能是因为实际单次迭代耗时约 0.1 秒（总 epoch=20000，总耗时约 2000 秒），而记录操作的耗时占比不足 1%，被估算误差掩盖。

python 复制代码

import wmi
 
c = wmi.WMI()
processors = c.Win32_Processor()
 
for processor in processors:
    print(f"CPU 型号: {processor.Name}")
    print(f"核心数: {processor.NumberOfCores}")
    print(f"线程数: {processor.NumberOfLogicalProcessors}")
 
import torch
 
# 检查CUDA是否可用
if torch.cuda.is_available():
    print("CUDA可用！")
    # 获取可用的CUDA设备数量
    device_count = torch.cuda.device_count()
    print(f"可用的CUDA设备数量: {device_count}")
    # 获取当前使用的CUDA设备索引
    current_device = torch.cuda.current_device()
    print(f"当前使用的CUDA设备索引: {current_device}")
    # 获取当前CUDA设备的名称
    device_name = torch.cuda.get_device_name(current_device)
    print(f"当前CUDA设备的名称: {device_name}")
    # 获取CUDA版本
    cuda_version = torch.version.cuda
    print(f"CUDA版本: {cuda_version}")
    # 查看cuDNN版本（如果可用）
    print("cuDNN版本:", torch.backends.cudnn.version())
 
else:
    print("CUDA不可用。")
# 设置GPU设备
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"使用设备: {device}")
# 加载鸢尾花数据集
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)
class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(4, 10)
        self.relu = nn.ReLU()
        self.fc2 = nn.Linear(10, 3)
 
    def forward(self, x):
        out = self.fc1(x)
        out = self.relu(out)
        out = self.fc2(out)
        return out
 
# 实例化模型并移至GPU
# MLP继承nn.Module类，所以也具有to(device)方法
model = MLP().to(device)
# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)
 
# 训练模型
num_epochs = 20000
losses = []
start_time = time.time()
 
for epoch in range(num_epochs):
    # 前向传播
    outputs = model(X_train)
    loss = criterion(outputs, y_train)
 
    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
 
    # 记录损失值
    losses.append(loss.item())
 
    # 打印训练信息
    if (epoch + 1) % 100 == 0:
        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')
 
# 可视化损失曲线
plt.plot(range(num_epochs), losses)
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training Loss over Epochs')
plt.show()

@浙大疏锦行