炼丹师的福音：RTX 4090 如何榨干 32G 内存，AI 训练效率飙升

内容摘要：炼丹师的福音：RTX 4090 如何榨干 32G 内存，AI 训练效率飙升,

在 AI 训练中，尤其是涉及深度学习模型时，显存往往是最大的瓶颈。很多开发者手持 RTX 4090（24G 显存），却苦恼于 32G 内存似乎成了摆设，无法充分利用硬件资源。本文将深入探讨如何通过“显存挪用”等技巧，最大化利用 RTX 4090 的性能，实现 AI 训练大显存配置下的效率翻倍。

问题场景重现：OOM 噩梦

假设我们正在训练一个大型 Transformer 模型，使用 PyTorch 框架。代码在本地跑得飞起，但一放到服务器上，动不动就报 CUDA out of memory 错误（OOM）。即使降低 batch size，也难以解决根本问题。这是典型的显存不足导致的。虽然我们有 32G 内存，但默认情况下，模型和数据主要加载到显存中，内存并没有得到有效利用。

案例代码：典型 OOM 场景

import torch
import torch.nn as nn
import torch.optim as optim

# 定义一个大型 Transformer 模型
class TransformerModel(nn.Module):
    def __init__(self, vocab_size, embed_dim, num_heads, num_layers):
        super(TransformerModel, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.transformer_encoder = nn.TransformerEncoder(nn.TransformerEncoderLayer(embed_dim, num_heads), num_layers)
        self.decoder = nn.Linear(embed_dim, vocab_size)

    def forward(self, src):
        src = self.embedding(src)
        output = self.transformer_encoder(src)
        output = self.decoder(output)
        return output

# 超参数
vocab_size = 10000  # 词汇表大小
embed_dim = 512    # 嵌入维度
num_heads = 8      # 注意力头数
num_layers = 6     # Transformer 层数
batch_size = 32     # 批次大小

# 初始化模型、损失函数和优化器
model = TransformerModel(vocab_size, embed_dim, num_heads, num_layers).cuda() # 模型放到 GPU 上
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

# 生成一些随机数据
src = torch.randint(0, vocab_size, (batch_size, 128)).cuda()
target = torch.randint(0, vocab_size, (batch_size, 128)).cuda()

# 训练循环
for epoch in range(10):
    optimizer.zero_grad()
    output = model(src)
    loss = criterion(output.view(-1, vocab_size), target.view(-1))
    loss.backward()
    optimizer.step()
    print(f'Epoch: {epoch}, Loss: {loss.item()}')

这段代码在小数据集上可能可以运行，但一旦数据集或模型增大，很容易遇到 OOM 问题。

底层原理深度剖析：显存与内存的协作

要解决 OOM 问题，需要理解显存和内存的协作方式。在深度学习训练中，GPU 主要负责执行矩阵运算，速度远快于 CPU。因此，模型参数、中间激活值和梯度等数据都需要加载到显存中。然而，显存容量有限，而内存容量相对更大。我们可以通过以下方式，将部分数据卸载到内存中，从而缓解显存压力：

1. 梯度累积 (Gradient Accumulation)： 将大的 batch size 分成多个小的 batches，分别计算梯度，累加后再更新模型参数。减少了单次迭代所需的显存。
2. 混合精度训练 (Mixed Precision Training)： 使用 FP16 (半精度浮点数) 替代 FP32 (单精度浮点数) 进行训练，可以减少显存占用，同时保持训练精度。
3. CPU Offloading： 将不常用的模型参数或中间激活值卸载到 CPU 内存中。需要时再加载回显存。
4. 数据并行 (Data Parallelism) 与模型并行 (Model Parallelism)： 将数据或模型分片到多个 GPU 上进行训练，降低单个 GPU 的显存压力。 需要注意的是，数据并行通常需要配置 NCCL 实现高效的 GPU 间通信，而模型并行则对模型结构有一定要求，需要手动进行拆分。

具体的代码/配置解决方案

以下是一些解决 AI 训练大显存配置下 OOM 问题的具体方案。

1. 梯度累积

accumulation_steps = 4 # 累积 4 个小 batch 的梯度

for epoch in range(10):
    for i, (src, target) in enumerate(data_loader):
        src = src.cuda()
        target = target.cuda()

        output = model(src)
        loss = criterion(output.view(-1, vocab_size), target.view(-1))
        loss = loss / accumulation_steps # 梯度缩放
        loss.backward()

        if (i + 1) % accumulation_steps == 0:
            optimizer.step()
            optimizer.zero_grad()
    print(f'Epoch: {epoch}, Loss: {loss.item()}')

2. 混合精度训练 (使用 Apex 或 PyTorch 1.6+)

使用 Apex (已过时，不推荐):

from apex import amp

model, optimizer = amp.initialize(model, optimizer, opt_level='O1') # O1 建议

# 训练循环
for epoch in range(10):
    optimizer.zero_grad()
    output = model(src)
    loss = criterion(output.view(-1, vocab_size), target.view(-1))

    with amp.scale_loss(loss, optimizer) as scaled_loss:
        scaled_loss.backward()

    optimizer.step()
    print(f'Epoch: {epoch}, Loss: {loss.item()}')

使用 PyTorch 1.6+ 的 torch.cuda.amp (推荐):

scaler = torch.cuda.amp.GradScaler()

# 训练循环
for epoch in range(10):
    optimizer.zero_grad()
    with torch.cuda.amp.autocast():
        output = model(src)
        loss = criterion(output.view(-1, vocab_size), target.view(-1))

    scaler.scale(loss).backward()
    scaler.step(optimizer)
    scaler.update()
    print(f'Epoch: {epoch}, Loss: {loss.item()}')

3. CPU Offloading (DeepSpeed, FairScale)

DeepSpeed 和 FairScale 提供了更高级的 CPU Offloading 功能，可以自动将模型参数或中间激活值卸载到 CPU 内存。 以 DeepSpeed 为例，需要配置相应的 JSON 配置文件，并通过 deepspeed.initialize 初始化。

import deepspeed

# DeepSpeed 配置
ds_config = {
    "train_batch_size": 32,
    "train_micro_batch_size_per_gpu": 8,
    "fp16": {
        "enabled": True
    },
    "offload_optimizer": {
        "device": "cpu",
        "pin_memory": True
    },
    "offload_param": {
        "device": "cpu",
        "pin_memory": True
    }
}

# 初始化 DeepSpeed
model, optimizer, _, _ = deepspeed.initialize(model=model, optimizer=optimizer, config_params=ds_config)

# 训练循环
for epoch in range(10):
    output = model(src)
    loss = criterion(output.view(-1, vocab_size), target.view(-1))
    loss.backward()
    model.step()
    print(f'Epoch: {epoch}, Loss: {loss.item()}')

实战避坑经验总结

1. 监控显存使用情况： 使用 torch.cuda.memory_summary() 或 nvidia-smi 命令，实时监控显存使用情况，以便及时调整策略。
2. Batch Size 调整： Batch Size 对显存占用影响很大，需要根据实际情况进行调整。 从小 Batch Size 开始，逐步增加，直到显存达到瓶颈。
3. 数据类型优化： 尽量使用 FP16 或 BF16 等低精度数据类型，可以显著减少显存占用。
4. 模型结构优化： 可以考虑使用更轻量级的模型结构，或者对模型进行剪枝、量化等优化，减少模型参数量。
5. 选择合适的Offloading方案: DeepSpeed 和 FairScale 各有优劣，需要根据具体情况选择。DeepSpeed 在 CPU Offloading 方面更强大，但配置更复杂。FairScale 更易于使用，但功能相对简单。
6. Nginx反向代理和负载均衡: 如果需要部署模型到线上环境，可以使用 Nginx 作为反向代理服务器，进行负载均衡，提高模型的可用性和并发连接数。同时可以配合宝塔面板等工具进行管理，更方便快捷。

通过上述方法，可以有效地解决 AI 训练大显存配置 下的 OOM 问题，充分利用 RTX 4090 和 32G 内存的性能，实现效率翻倍。