机器学习与深度学习 / 系统课时

多 GPU 训练基础

多 GPU 训练基础

本课用 PyTorch DistributedDataParallel 搭建一个可运行的双 GPU 训练脚本,重点说明每张 GPU 对应一个进程、数据如何分片、梯度何时同步,以及为什么采样器配置错误会造成重复训练。

学习目标

  • 说清数据并行、进程与 GPU 之间的对应关系
  • 使用 DDP、torchrun 和 DistributedSampler 启动训练
  • 验证各进程的数据分片与全局梯度同步是否生效

数据并行的基本结构

数据并行会在每张 GPU 上放置一份相同模型,每个进程只处理当前批次的一部分数据。反向传播期间,DDP 通过 All-Reduce 汇总各进程梯度,使所有模型副本在参数更新后保持一致。

DDP 数据并行与梯度同步流程

DDP 的推荐关系是“一进程一 GPU”。相比单进程的 DataParallel,它减少了主卡聚合瓶颈,也更容易扩展到多机训练。单机双卡时,世界大小 world_size 为 2,进程编号 rank 分别为 0 和 1。

用 DDP 完成最小训练

下面的脚本创建 1024 条样本,使用两个进程各处理一半数据。DDP 会在 loss.backward() 期间自动同步参数梯度,无须手动复制模型或梯度。

python
import os

import torch
import torch.distributed as dist
from torch.nn.parallel import DistributedDataParallel as DDP
from torch.utils.data import DataLoader, DistributedSampler, TensorDataset

def main() -> None:
    local_rank = int(os.environ["LOCAL_RANK"])
    torch.cuda.set_device(local_rank)
    device = torch.device("cuda", local_rank)

    # torchrun 会为每个进程注入 RANK、WORLD_SIZE 等环境变量
    dist.init_process_group(backend="nccl")

    torch.manual_seed(42)
    features = torch.randn(1024, 10)
    labels = features.sum(dim=1, keepdim=True)
    dataset = TensorDataset(features, labels)

    sampler = DistributedSampler(
        dataset,
        shuffle=True,
        drop_last=False,
    )
    loader = DataLoader(
        dataset,
        batch_size=64,
        sampler=sampler,
        num_workers=2,
        pin_memory=True,
    )

    model = torch.nn.Linear(10, 1).to(device)
    model = DDP(model, device_ids=[local_rank])
    optimizer = torch.optim.SGD(model.parameters(), lr=0.05)
    loss_fn = torch.nn.MSELoss()

    sampler.set_epoch(0)
    loss_sum = torch.zeros(1, device=device)
    step_count = torch.zeros(1, device=device)

    for batch_features, batch_labels in loader:
        batch_features = batch_features.to(device, non_blocking=True)
        batch_labels = batch_labels.to(device, non_blocking=True)

        optimizer.zero_grad(set_to_none=True)
        prediction = model(batch_features)
        loss = loss_fn(prediction, batch_labels)
        loss.backward()  # DDP 在这里按梯度桶执行 All-Reduce
        optimizer.step()

        loss_sum += loss.detach()
        step_count += 1

    dist.all_reduce(loss_sum, op=dist.ReduceOp.SUM)
    dist.all_reduce(step_count, op=dist.ReduceOp.SUM)

    rank = dist.get_rank()
    print(f"rank={rank}, local_batches={len(loader)}")
    if rank == 0:
        print(f"global_average_loss={(loss_sum / step_count).item():.6f}")

    dist.destroy_process_group()

if __name__ == "__main__":
    main()

将代码保存为 ddp_train.py,在至少有两张可用 NVIDIA GPU 的环境中执行:

bash
torchrun --standalone --nproc_per_node=2 ddp_train.py

预期输出如下,两个 rank 行的先后顺序可能不同,损失值也会随运行环境略有变化:

text
rank=0, local_batches=8
rank=1, local_batches=8
global_average_loss=<LOSS>

<LOSS> 是动态训练结果。每个进程只有 8 个本地批次,说明 1024 条数据已按两个进程分片,而不是被每张 GPU 完整重复读取。

配置采样器与验证同步

DistributedSampler 是数据并行正确性的关键。使用它以后不要再给 DataLoader 设置 shuffle=True,因为打乱顺序由采样器负责;每轮训练前还必须调用 sampler.set_epoch(epoch),否则各轮会重复相同的随机顺序。

梯度同步发生在反向传播阶段,而不是 optimizer.step()。因此所有进程必须执行相同次数的反向传播;某个进程提前结束、跳过批次或走入不同分支,都可能造成集体通信一直等待。训练数据无法整除进程数时,可根据业务选择让采样器补齐样本,或设置 drop_last=True 保持批次数一致。

验证时可先比较各进程的 local_batches,再由 rank 0 汇总指标。不要让每个进程都保存同一个检查点,通常只允许 rank 0 写文件,其他进程等待同步即可。

本课总结

  • DDP 采用一进程一 GPU,每个进程持有模型副本并处理独立数据分片
  • DistributedSampler 负责避免样本重复,set_epoch() 负责让每轮获得新的打乱顺序
  • 梯度在 backward() 阶段通过 All-Reduce 同步,所有进程必须保持一致的训练步数

下一课预告

下一课将优化数据输入管线,通过缓存、并行加载、预取和异步传输减少 GPU 等待数据的时间。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

多 GPU 训练基础

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通