新手手册:Pytorch分布式训练

PyTorch DDP分布式训练实战指南:从单机到多机部署 本文详细介绍了PyTorch DDP分布式训练的实战指南,从单机到多机部署的全流程。通过核心概念解析、环境配置、代码示例和性能优化技巧,帮助开发者高效实现多GPU协同训练,显著提升模型训练速度。重点讲解了DDP的Ring-AllReduce算法、进程初始化、数据分片等关键技术,并提供了典型问题排查和调优方案。 阅读详情

来自|机器学习算法与自然语言处理   作者 | 花花  

单位 | SenseTime 算法研究员 


   目录

  • 0X01 分布式并行训练概述

  • 0X02 Pytorch分布式数据并行

  • 0X03 手把手渐进式实战

  • A. 单机单卡

  • B. 单机多卡DP

  • C. 多机多卡DDP

  • D. Launch / Slurm 调度方式

  • 0X04 完整框架 Distribuuuu

  • 0X05 Reference

文中所有教学代码和日志见:
https://link.zhihu.com/?target=https%3A//github.com/BIGBALLON/distribuuuu/tree/master/tutorial

文中提到的框架见:
https://link.zhihu.com/?target=https%3A//github.com/BIGBALLON/distribuuuu


   0X01 分布式并行训练概述

最常被提起,容易实现且使用最广泛的,莫过于数据并行(Data Parallelism) 技术,其核心思想是将大batch划分为若干小barch分发到不同device并行计算,解决单GPU显存不足的限制。以此同时,当单GPU无法放下整个模型时,我们还需考虑模型并行 (Model / Pipeline Parallelism)。如考虑将模型进行纵向切割,不同的Layers放在不同的device上。或是横向切割,通过矩阵运算进行加速。当然,还有一些非并行的技术或者技巧,用于解决训练效率或者训练显存不足等问题,这里草率地将当前深度学习的大规模分布式训练技术分为如下三类:

  • Data Parallelism (数据并行)

    • Naive:每个worker存储一份model和optimizer,每轮迭代时,将样本分为若干份分发给各个worker,实现并行计算

    • ZeRO: Zero Redundancy Optimizer,微软提出的数据并行内存优化技术,核心思想是保持Naive数据并行通信效率的同时,尽可能降低内存占用

  • Model/Pipeline Parallelism (模型/管道并行)

    • Naive: 纵向切割模型,将不同的layers放到不同的device上,按顺序进行正/反向传播

    • GPipe:小批量流水线方式的纵向切割模型并行

    • Megatron-LM:Tensor-slicing方式的模型并行加速

  • Non-parallelism approach (非并行技术)

    • Gradient Accumulation: 通过梯度累加的方式解决显存不足的问题,常用于模型较大,单卡只能塞下很小的batch的并行训练中

    • CPU Offload: 同时利用 CPU 和 GPU 内存来训练大型模型,即存在GPU-CPU-GPU的 transfers 操作

    • etc.:还有很多不一一罗列(如Checkpointing,Memory Efficient Optimizer等)

不过这里我强推一下DeepSpeed,微软在2020年开源的一个基于PyTorch分布式训练 library,让训练百亿参数的巨大模型成为可能,其提供的 3D-parallelism (DP+PP+MP)的并行技术组合,能极大程度降低大模型训练的硬件条件以及提高训练的效率

PS:本文的重点是介绍PyTorch原生的分布式数据平行及其用法,其他的内容,我们后面的文章再细聊。(如果有机会的话qwq)


   0X02 Pytorch分布式数据并行

将时间拨回2017年,我第一次接触深度学习,早期的TensorFlow使用的是PS(Parameter Server)架构,在结点数量线性增长的情况下,带宽瓶颈格外明显。而随后百度将Ring-Allreduce技术运用到深度学习分布式训练,PyTorch1.0之后香起来的原因也是因为在分布式训练方面做了较大改动,适配多种通信后端,使用RingAllReduce架构。首先,确保你对PyTorch有一定的熟悉程度,在次前提下,对如下内容进行学习和了解:

  • DataParallel 和 DistributedDataParallel 的原理和使用

  • 进程组 和 torch.distributed.init_process_group 的原理和使用

  • 集体通信(Collective Communication) 的原理和使用

基本上就能够handle住大部分的数据并行任务了

关于理论的东西,我写了一大堆,最后又全删掉了。原因是我发现已经有足够多的文章介绍PS/Ring-AllReduce和 PyTorch DP/DDP 的原理,给出几篇我认为足够好的文章:

  • PYTORCH DISTRIBUTED OVERVIEW

  • PyTorch 源码解读之 DP & DDP

  • Bringing HPC Techniques to Deep Learning


   0X03 手把手渐进式实战

那么接下来我们以Step by Step的方式进行实践,你可以直接通过下面的快速索引进行跳转:

  • 单机单卡 [snsc.py]

  • 单机多卡 (with DataParallel) [snmc_dp.py]

  • 多机多卡 (with DistributedDataParallel)

  • torch.distributed.launch [mnmc_ddp_launch.py]

  • torch.multiprocessing [mnmc_ddp_mp.py]

  • Slurm Workload Manager [mnmc_ddp_slurm.py]

  • ImageNet training example [imagenet.py]

A. 单机单卡

Single Node Single GPU Card Training, 源码见 snsc.py,后续我们会在此代码上进行修改。简单看一下,单机单卡要做的就是定义网络,定义dataloader,定义loss和optimizer,开训,很简单的几个步骤。

"""(SNSC) Single Node Single GPU Card Training"""
import torch
import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms

BATCH_SIZE = 256
EPOCHS = 5

if __name__ == "__main__":

    # 1. define network
    device = "cuda"
    net = torchvision.models.resnet18(num_classes=10)
    net = net.to(device=device)

    # 2. define dataloader
    trainset = torchvision.datasets.CIFAR10(
        root="./data",
        train=True,
        download=True,
        transform=transforms.Compose(
            [
                transforms.RandomCrop(32, padding=4),
                transforms.RandomHorizontalFlip(),
                transforms.ToTensor(),
                transforms.Normalize(
                    (0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)
                ),
            ]
        ),
    )
    train_loader = torch.utils.data.DataLoader(
        trainset,
        batch_size=BATCH_SIZE,
        shuffle=True,
        num_workers=4,
        pin_memory=True,
    )

    # 3. define loss and optimizer
    criterion = nn.CrossEntropyLoss()
    optimizer = torch.optim.SGD(
        net.parameters(),
        lr=0.01,
        momentum=0.9,
        weight_decay=0.0001,
        nesterov=True,
    )

    print("            =======  Training  ======= \n")

    # 4. start to train
    net.train()
    for ep in range(1, EPOCHS + 1):
        train_loss = correct = total = 0

        for idx, (inputs, targets) in enumerate(train_loader):
            inputs, targets = inputs.to(device), targets.to(device)
            outputs = net(inputs)

            loss = criterion(outputs, targets)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            train_loss += loss.item()
            total += targets.size(0)
            correct += torch.eq(outputs.argmax(dim=1), targets).sum().item()

            if (idx + 1) % 50 == 0 or (idx + 1) == len(train_loader):
                print(
                    "   == step: [{:3}/{}] [{}/{}] | loss: {:.3f} | acc: {:6.3f}%".format(
                        idx + 1,
                        len(train_loader),
                        ep,
                        EPOCHS,
                        train_loss / (idx + 1),
                        100.0 * correct / total,
                    )
                )

    print("\n            =======  Training Finished  ======= \n")
    
"""
usage:
>>> python snsc.py
Files already downloaded and verified
            =======  Training  ======= 
   == step: [ 50/196] [1/5] | loss: 1.959 | acc: 28.633%
   == step: [100/196] [1/5] | loss: 1.806 | acc: 33.996%
   == step: [150/196] [1/5] | loss: 1.718 | acc: 36.987%
   == step: [196/196] [1/5] | loss: 1.658 | acc: 39.198%
   == step: [ 50/196] [2/5] | loss: 1.393 | acc: 49.578%
   == step: [100/196] [2/5] | loss: 1.359 | acc: 50.473%
   == step: [150/196] [2/5] | loss: 1.336 | acc: 51.372%
   == step: [196/196] [2/5] | loss: 1.317 | acc: 52.200%
   == step: [ 50/196] [3/5] | loss: 1.205 | acc: 56.102%
   == step: [100/196] [3/5] | loss: 1.185 | acc: 57.254%
   == step: [150/196] [3/5] | loss: 1.175 | acc: 57.755%
   == step: [196/196] [3/5] | loss: 1.165 | acc: 58.072%
   == step: [ 50/196] [4/5] | loss: 1.067 | acc: 60.914%
   == step: [100/196] [4/5] | loss: 1.061 | acc: 61.406%
   == step: [150/196] [4/5] | loss: 1.058 | acc: 61.643%
   == step: [196/196] [4/5] | loss: 1.054 | acc: 62.022%
   == step: [ 50/196] [5/5] | loss: 0.988 | acc: 64.852%
   == step: [100/196] [5/5] | loss: 0.983 | acc: 64.801%
   == step: [150/196] [5/5] | loss: 0.980 | acc: 65.052%
   == step: [196/196] [5/5] | loss: 0.977 | acc: 65.076%
            =======  Training Finished  ======= 
"""


B. 单机多卡DP

Single Node Multi-GPU Crads Training (with DataParallel) snmc_dp.py, 和 snsc.py 对比一下,DP只需要花费最小的代价,既可以使用多卡进行训练(其实就一行???),但是因为GIL锁的限制,DP的性能是低于DDP的。

"""
(SNMC) Single Node Multi-GPU Crads Training (with DataParallel)
Try to compare with smsc.py and find out the differences.
"""
import torch
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms

BATCH_SIZE = 256
EPOCHS = 5

if __name__ == "__main__":

    # 1. define network
    device = "cuda"
    net = torchvision.models.resnet18(pretrained=False, num_classes=10)
    net = net.to(device=device)
    # Use single-machine multi-GPU DataParallel,
    # you would like to speed up training with the minimum code change.
    net = nn.DataParallel(net)

    # 2. define dataloader
    trainset = torchvision.datasets.CIFAR10(
        root="./data",
        train=True,
        download=True,
        transform=transforms.Compose(
            [
                transforms.RandomCrop(32, padding=4),
                transforms.RandomHorizontalFlip(),
                transforms.ToTensor(),
                transforms.Normalize(
                    (0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)
                ),
            ]
        ),
    )
    train_loader = torch.utils.data.DataLoader(
        trainset,
        batch_size=BATCH_SIZE,
        shuffle=True,
        num_workers=4,
        pin_memory=True,
    )

    # 3. define loss and optimizer
    criterion = nn.CrossEntropyLoss()
    optimizer = torch.optim.SGD(
        net.parameters(),
        lr=0.01,
        momentum=0.9,
        weight_decay=0.0001,
        nesterov=True,
    )

    print("            =======  Training  ======= \n")

    # 4. start to train
    net.train()
    for ep in range(1, EPOCHS + 1):
        train_loss = correct = total = 0

        for idx, (inputs, targets) in enumerate(train_loader):
            inputs, targets = inputs.to(device), targets.to(device)
            outputs = net(inputs)

            loss = criterion(outputs, targets)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            train_loss += loss.item()
            total += targets.size(0)
            correct += torch.eq(outputs.argmax(dim=1), targets).sum().item()

            if (idx + 1) % 50 == 0 or (idx + 1) == len(train_loader):
                print(
                    "   == step: [{:3}/{}] [{}/{}] | loss: {:.3f} | acc: {:6.3f}%".format(
                        idx + 1,
                        len(train_loader),
                        ep,
                        EPOCHS,
                        train_loss / (idx + 1),
                        100.0 * correct / total,
                    )
                )

    print("\n            =======  Training Finished  ======= \n")

"""
usage: 2GPUs for training
>>> CUDA_VISIBLE_DEVICES=0,1 python snmc_dp.py
Files already downloaded and verified
            =======  Training  ======= 
   == step: [ 50/196] [1/5] | loss: 1.992 | acc: 26.633%
   == step: [100/196] [1/5] | loss: 1.834 | acc: 32.797%
   == step: [150/196] [1/5] | loss: 1.742 | acc: 36.201%
   == step: [196/196] [1/5] | loss: 1.680 | acc: 38.578%
   == step: [ 50/196] [2/5] | loss: 1.398 | acc: 49.062%
   == step: [100/196] [2/5] | loss: 1.380 | acc: 49.953%
   == step: [150/196] [2/5] | loss: 1.355 | acc: 50.810%
   == step: [196/196] [2/5] | loss: 1.338 | acc: 51.428%
   == step: [ 50/196] [3/5] | loss: 1.242 | acc: 55.727%
   == step: [100/196] [3/5] | loss: 1.219 | acc: 56.801%
   == step: [150/196] [3/5] | loss: 1.200 | acc: 57.195%
   == step: [196/196] [3/5] | loss: 1.193 | acc: 57.328%
   == step: [ 50/196] [4/5] | loss: 1.105 | acc: 61.102%
   == step: [100/196] [4/5] | loss: 1.098 | acc: 61.082%
   == step: [150/196] [4/5] | loss: 1.087 | acc: 61.354%
   == step: [196/196] [4/5] | loss: 1.086 | acc: 61.426%
   == step: [ 50/196] [5/5] | loss: 1.002 | acc: 64.039%
   == step: [100/196] [5/5] | loss: 1.006 | acc: 63.977%
   == step: [150/196] [5/5] | loss: 1.009 | acc: 63.935%
   == step: [196/196] [5/5] | loss: 1.005 | acc: 64.024%
            =======  Training Finished  ======= 
"""


C. 多机多卡DDP

Okay, 下面进入正题,来看一下多机多卡怎么做,虽然上面给出的文章都讲得很明白,但有些概念还是有必要提一下:

  • 进程组的概念

    • group:进程组,大部分情况下DDP的各个进程是在同一个进程组下

    • world size:总的进程数量(原则上一个process占用一个GPU是较优的)

    • rank:当前进程的序号,用于进程间通讯,rank = 0 的主机为 master 节点

    • local_rank:当前进程对应的GPU号

举个栗子 :4台机器(每台机器8张卡)进行分布式训练, 通过 init_process_group() 对进程组进行初始化, 初始化后 可以通过 get_world_size() 获取到 world size,在该例中为32, 即有32个进程,其编号为0-31, 通过 get_rank() 函数可以进行获取 在每台机器上,local rank均为0-8,这是 local rank 与 rank 的区别, local rank 会对应到实际的GPU ID上 (单机多任务的情况下注意CUDA_VISIBLE_DEVICES的使用,控制不同程序可见的GPU device)。

  • DDP基本用法

    • 使用 torch.distributed.init_process_group 初始化进程组

    • 使用 torch.nn.parallel.DistributedDataParallel 创建分布式并行模型

    • 创建对应的 DistributedSampler

    • 使用 torch.distributed.launch / torch.multiprocessing 或 slurm 开始训练

  • 集体通信的使用

    • 将各卡数据进行汇总,分发,平均等操作,需要使用集体通讯操作,比如算accuracy或者总loss时候需要用到allreduce, 参考

    • torch.distribute

    • NCCL-Woolley

    • scaled_all_reduce

  • 不同启动方式的用法

    • torch.distributed.launch:mnmc_ddp_launch.py

    • torch.multiprocessing:mnmc_ddp_mp.py

    • Slurm Workload Manager:mnmc_ddp_slurm.py

"""
(MNMC) Multiple Nodes Multi-GPU Cards Training
    with DistributedDataParallel and torch.distributed.launch
Try to compare with [snsc.py, snmc_dp.py & mnmc_ddp_mp.py] and find out the differences.
"""

import os

import torch
import torch.distributed as dist
import torch.nn as nn
import torchvision
import torchvision.transforms as transforms
from torch.nn.parallel import DistributedDataParallel as DDP

BATCH_SIZE = 256
EPOCHS = 5


if __name__ == "__main__":

    # 0. set up distributed device
    rank = int(os.environ["RANK"])
    local_rank = int(os.environ["LOCAL_RANK"])
    torch.cuda.set_device(rank % torch.cuda.device_count())
    dist.init_process_group(backend="nccl")
    device = torch.device("cuda", local_rank)

    print(f"[init] == local rank: {local_rank}, global rank: {rank} ==")

    # 1. define network
    net = torchvision.models.resnet18(pretrained=False, num_classes=10)
    net = net.to(device)
    # DistributedDataParallel
    net = DDP(net, device_ids=[local_rank], output_device=local_rank)

    # 2. define dataloader
    trainset = torchvision.datasets.CIFAR10(
        root="./data",
        train=True,
        download=False,
        transform=transforms.Compose(
            [
                transforms.RandomCrop(32, padding=4),
                transforms.RandomHorizontalFlip(),
                transforms.ToTensor(),
                transforms.Normalize(
                    (0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)
                ),
            ]
        ),
    )
    # DistributedSampler
    # we test single Machine with 2 GPUs
    # so the [batch size] for each process is 256 / 2 = 128
    train_sampler = torch.utils.data.distributed.DistributedSampler(
        trainset,
        shuffle=True,
    )
    train_loader = torch.utils.data.DataLoader(
        trainset,
        batch_size=BATCH_SIZE,
        num_workers=4,
        pin_memory=True,
        sampler=train_sampler,
    )

    # 3. define loss and optimizer
    criterion = nn.CrossEntropyLoss()
    optimizer = torch.optim.SGD(
        net.parameters(),
        lr=0.01 * 2,
        momentum=0.9,
        weight_decay=0.0001,
        nesterov=True,
    )

    if rank == 0:
        print("            =======  Training  ======= \n")

    # 4. start to train
    net.train()
    for ep in range(1, EPOCHS + 1):
        train_loss = correct = total = 0
        # set sampler
        train_loader.sampler.set_epoch(ep)

        for idx, (inputs, targets) in enumerate(train_loader):
            inputs, targets = inputs.to(device), targets.to(device)
            outputs = net(inputs)

            loss = criterion(outputs, targets)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

            train_loss += loss.item()
            total += targets.size(0)
            correct += torch.eq(outputs.argmax(dim=1), targets).sum().item()

            if rank == 0 and ((idx + 1) % 25 == 0 or (idx + 1) == len(train_loader)):
                print(
                    "   == step: [{:3}/{}] [{}/{}] | loss: {:.3f} | acc: {:6.3f}%".format(
                        idx + 1,
                        len(train_loader),
                        ep,
                        EPOCHS,
                        train_loss / (idx + 1),
                        100.0 * correct / total,
                    )
                )
    if rank == 0:
        print("\n            =======  Training Finished  ======= \n")

"""
usage:
>>> python -m torch.distributed.launch --help
exmaple: 1 node, 4 GPUs per node (4GPUs)
>>> python -m torch.distributed.launch \
    --nproc_per_node=4 \
    --nnodes=1 \
    --node_rank=0 \
    --master_addr=localhost \
    --master_port=22222 \
    mnmc_ddp_launch.py
[init] == local rank: 3, global rank: 3 ==
[init] == local rank: 1, global rank: 1 ==
[init] == local rank: 0, global rank: 0 ==
[init] == local rank: 2, global rank: 2 ==
            =======  Training  ======= 
   == step: [ 25/49] [0/5] | loss: 1.980 | acc: 27.953%
   == step: [ 49/49] [0/5] | loss: 1.806 | acc: 33.816%
   == step: [ 25/49] [1/5] | loss: 1.464 | acc: 47.391%
   == step: [ 49/49] [1/5] | loss: 1.420 | acc: 48.448%
   == step: [ 25/49] [2/5] | loss: 1.300 | acc: 52.469%
   == step: [ 49/49] [2/5] | loss: 1.274 | acc: 53.648%
   == step: [ 25/49] [3/5] | loss: 1.201 | acc: 56.547%
   == step: [ 49/49] [3/5] | loss: 1.185 | acc: 57.360%
   == step: [ 25/49] [4/5] | loss: 1.129 | acc: 59.531%
   == step: [ 49/49] [4/5] | loss: 1.117 | acc: 59.800%
            =======  Training Finished  =======
exmaple: 1 node, 2tasks, 4 GPUs per task (8GPUs)
>>> CUDA_VISIBLE_DEVICES=0,1,2,3 python -m torch.distributed.launch \
    --nproc_per_node=4 \
    --nnodes=2 \
    --node_rank=0 \
    --master_addr="10.198.189.10" \
    --master_port=22222 \
    mnmc_ddp_launch.py
>>> CUDA_VISIBLE_DEVICES=4,5,6,7 python -m torch.distributed.launch \
    --nproc_per_node=4 \
    --nnodes=2 \
    --node_rank=1 \
    --master_addr="10.198.189.10" \
    --master_port=22222 \
    mnmc_ddp_launch.py
            =======  Training  ======= 
   == step: [ 25/25] [0/5] | loss: 1.932 | acc: 29.088%
   == step: [ 25/25] [1/5] | loss: 1.546 | acc: 43.088%
   == step: [ 25/25] [2/5] | loss: 1.424 | acc: 48.032%
   == step: [ 25/25] [3/5] | loss: 1.335 | acc: 51.440%
   == step: [ 25/25] [4/5] | loss: 1.243 | acc: 54.672%
            =======  Training Finished  =======
exmaple: 2 node, 8 GPUs per node (16GPUs)
>>> python -m torch.distributed.launch \
    --nproc_per_node=8 \
    --nnodes=2 \
    --node_rank=0 \
    --master_addr="10.198.189.10" \
    --master_port=22222 \
    mnmc_ddp_launch.py
>>> python -m torch.distributed.launch \
    --nproc_per_node=8 \
    --nnodes=2 \
    --node_rank=1 \
    --master_addr="10.198.189.10" \
    --master_port=22222 \
    mnmc_ddp_launch.py
[init] == local rank: 5, global rank: 5 ==
[init] == local rank: 3, global rank: 3 ==
[init] == local rank: 2, global rank: 2 ==
[init] == local rank: 4, global rank: 4 ==
[init] == local rank: 0, global rank: 0 ==
[init] == local rank: 6, global rank: 6 ==
[init] == local rank: 7, global rank: 7 ==
[init] == local rank: 1, global rank: 1 ==
            =======  Training  ======= 
   == step: [ 13/13] [0/5] | loss: 2.056 | acc: 23.776%
   == step: [ 13/13] [1/5] | loss: 1.688 | acc: 36.736%
   == step: [ 13/13] [2/5] | loss: 1.508 | acc: 44.544%
   == step: [ 13/13] [3/5] | loss: 1.462 | acc: 45.472%
   == step: [ 13/13] [4/5] | loss: 1.357 | acc: 49.344%
            =======  Training Finished  ======= 
"""


D. Launch / Slurm 调度方式

这里单独用代码 imagenet.py 讲一下不同的启动方式。我们来看一下这个 setup_distributed 函数:

  • 通过 srun 产生的程序在环境变量中会有 SLURM_JOB_ID, 以判断是否为slurm的调度方式

  • rank通过 SLURM_PROCID 可以拿到

  • world size实际上就是进程数, 通过 SLURM_NTASKS 可以拿到

  • IP地址通过 subprocess.getoutput(f"scontrol show hostname {node_list} | head -n1") 巧妙得到,栗子来源于 MMCV

  • 否则,就使用launch进行调度,直接通过 os.environ["RANK"] 和 os.environ["WORLD_SIZE"] 即可拿到 rank 和 world size

# 此函数可以直接移植到你的程序中,动态获取IP,使用很方便
# 默认支持launch 和 srun 两种方式
def setup_distributed(backend="nccl", port=None):
    """Initialize distributed training environment.
    support both slurm and torch.distributed.launch
    see torch.distributed.init_process_group() for more details
    """
    num_gpus = torch.cuda.device_count()

    if "SLURM_JOB_ID" in os.environ:
        rank = int(os.environ["SLURM_PROCID"])
        world_size = int(os.environ["SLURM_NTASKS"])
        node_list = os.environ["SLURM_NODELIST"]
        addr = subprocess.getoutput(f"scontrol show hostname {node_list} | head -n1")
        # specify master port
        if port is not None:
            os.environ["MASTER_PORT"] = str(port)
        elif "MASTER_PORT" not in os.environ:
            os.environ["MASTER_PORT"] = "29500"
        if "MASTER_ADDR" not in os.environ:
            os.environ["MASTER_ADDR"] = addr
        os.environ["WORLD_SIZE"] = str(world_size)
        os.environ["LOCAL_RANK"] = str(rank % num_gpus)
        os.environ["RANK"] = str(rank)
    else:
        rank = int(os.environ["RANK"])
        world_size = int(os.environ["WORLD_SIZE"])

    torch.cuda.set_device(rank % num_gpus)

    dist.init_process_group(
        backend=backend,
        world_size=world_size,
        rank=rank,
    )

那提交任务就变成很自然的事情:

# ======== slurm 调度方式 ========
# 32张GPU,4个node,每个node8张卡,8192的batch size,32个进程
# see:https://github.com/BIGBALLON/distribuuuu/blob/master/tutorial/imagenet.py
slurm example: 
    32GPUs (batch size: 8192)
    128k / (256*32) -> 157 itertaion
>>> srun --partition=openai -n32 --gres=gpu:8 --ntasks-per-node=8 --job-name=slrum_test \
    python -u imagenet.py
[init] == local rank: 7, global rank: 7 ==
[init] == local rank: 1, global rank: 1 ==
[init] == local rank: 4, global rank: 4 ==
[init] == local rank: 2, global rank: 2 ==
[init] == local rank: 6, global rank: 6 ==
[init] == local rank: 3, global rank: 3 ==
[init] == local rank: 5, global rank: 5 ==
[init] == local rank: 4, global rank: 12 ==
[init] == local rank: 1, global rank: 25 ==
[init] == local rank: 5, global rank: 13 ==
[init] == local rank: 6, global rank: 14 ==
[init] == local rank: 0, global rank: 8 ==
[init] == local rank: 1, global rank: 9 ==
[init] == local rank: 2, global rank: 10 ==
[init] == local rank: 3, global rank: 11 ==
[init] == local rank: 7, global rank: 15 ==
[init] == local rank: 5, global rank: 29 ==
[init] == local rank: 2, global rank: 26 ==
[init] == local rank: 3, global rank: 27 ==
[init] == local rank: 0, global rank: 24 ==
[init] == local rank: 7, global rank: 31 ==
[init] == local rank: 6, global rank: 30 ==
[init] == local rank: 4, global rank: 28 ==
[init] == local rank: 0, global rank: 16 ==
[init] == local rank: 5, global rank: 21 ==
[init] == local rank: 7, global rank: 23 ==
[init] == local rank: 1, global rank: 17 ==
[init] == local rank: 6, global rank: 22 ==
[init] == local rank: 3, global rank: 19 ==
[init] == local rank: 2, global rank: 18 ==
[init] == local rank: 4, global rank: 20 ==
[init] == local rank: 0, global rank: 0 ==
            =======  Training  ======= 
   == step: [ 40/157] [0/1] | loss: 6.781 | acc:  0.703%
   == step: [ 80/157] [0/1] | loss: 6.536 | acc:  1.260%
   == step: [120/157] [0/1] | loss: 6.353 | acc:  1.875%
   == step: [157/157] [0/1] | loss: 6.207 | acc:  2.465%


# ======== launch 调度方式 ========
# nproc_per_node: 每个node的卡数
# nnodes: node数量
# node_rank:node编号,从0开始
# see: https://github.com/BIGBALLON/distribuuuu/blob/master/tutorial/mnmc_ddp_launch.py
distributed.launch example: 
    8GPUs (batch size: 2048)
    128k / (256*8) -> 626 itertaion
>>> python -m torch.distributed.launch \
    --nproc_per_node=8 \
    --nnodes=1 \
    --node_rank=0 \
    --master_addr=localhost \
    --master_port=22222 \
    imagenet.py
[init] == local rank: 0, global rank: 0 ==
[init] == local rank: 2, global rank: 2 ==
[init] == local rank: 6, global rank: 6 ==
[init] == local rank: 5, global rank: 5 ==
[init] == local rank: 7, global rank: 7 ==
[init] == local rank: 4, global rank: 4 ==
[init] == local rank: 3, global rank: 3 ==
[init] == local rank: 1, global rank: 1 ==
            =======  Training  ======= 
   == step: [ 40/626] [0/1] | loss: 6.821 | acc:  0.498%
   == step: [ 80/626] [0/1] | loss: 6.616 | acc:  0.869%
   == step: [120/626] [0/1] | loss: 6.448 | acc:  1.351%
   == step: [160/626] [0/1] | loss: 6.294 | acc:  1.868%
   == step: [200/626] [0/1] | loss: 6.167 | acc:  2.443%
   == step: [240/626] [0/1] | loss: 6.051 | acc:  3.003%
   == step: [280/626] [0/1] | loss: 5.952 | acc:  3.457%
   == step: [320/626] [0/1] | loss: 5.860 | acc:  3.983%
   == step: [360/626] [0/1] | loss: 5.778 | acc:  4.492%
   == step: [400/626] [0/1] | loss: 5.700 | acc:  4.960%
   == step: [440/626] [0/1] | loss: 5.627 | acc:  5.488%
   == step: [480/626] [0/1] | loss: 5.559 | acc:  6.013%
   == step: [520/626] [0/1] | loss: 5.495 | acc:  6.520%
   == step: [560/626] [0/1] | loss: 5.429 | acc:  7.117%
   == step: [600/626] [0/1] | loss: 5.371 | acc:  7.580%
   == step: [626/626] [0/1] | loss: 5.332 | acc:  7.907%


   0X04 完整框架 Distribuuuu

Distribuuuu 是我闲(没)来(事)无(找)事(事)写的一个完整的纯DDP分类训练框架,足够精简且足够有效率。支持launch和srun两种启动方式,可以作为新手学习和魔改的样板工程。

# 1 node, 8 GPUs
python -m torch.distributed.launch \
    --nproc_per_node=8 \
    --nnodes=1 \
    --node_rank=0 \
    --master_addr=localhost \
    --master_port=29500 \
    train_net.py --cfg config/resnet18.yaml
# see srun --help 
# and https://slurm.schedmd.com/ for details

# example: 64 GPUs
# batch size = 64 * 128 = 8192
# itertaion = 128k / 8192 = 156 
# lr = 64 * 0.1 = 6.4

srun --partition=openai-a100 \
     -n 64 \
     --gres=gpu:8 \
     --ntasks-per-node=8 \
     --job-name=Distribuuuu \
     python -u train_net.py --cfg config/resnet18.yaml \
     TRAIN.BATCH_SIZE 128 \
     OUT_DIR ./resnet18_8192bs \
     OPTIM.BASE_LR 6.4

下面是用 Distribuuuu 做的一些简单的实验,botnet50 是复现了今年比较火的 Transformer+CNN 的文章 Bottleneck Transformers for Visual 的精度,主要是证明这个框架的可用性, resnet18最后小测了 64卡/16384BS 的训练, 精度尚可。另外稍微强调一下SyncBN不要随便乱用,如果单卡Batch已经足够大的情况下不需要开SyncBN。

▲Distribuuuu benchmark (ImageNet)

如果是出于学习目的,想进行一些魔改和测试,可以试试我的Distribuuuu,因为足够简单很容易改吖 ,如果你想做research的话推荐用FAIR的 pycls, 有model zoo 而且代码足够优雅。另外,打比赛的话就不建议自己造轮子了,分类可直接魔改 pycls 或 MMClassification, 检测就魔改 MMDetection 和 Detectron2 就完事啦


Reference

  • PYTORCH DISTRIBUTED OVERVIEW

  • PyTorch 源码解读之 DP & DDP

  • Bringing HPC Techniques to Deep Learning

  • Parameter Servers

  • Ring-Allreduce:Launching and configuring distributed data parallel applications

  • PyTorch Distributed Training

  • Kill PyTorch Distributed Training Processes

  • NCCL: ACCELERATED MULTI-GPUCOLLECTIVE COMMUNICATIONS

  • WRITING DISTRIBUTED APPLICATIONS WITH PYTORCH

  • PyTorch Distributed: Experiences on Accelerating Data Parallel Training

  • Pytorch多机多卡分布式训练

PyTorch训练过程可视化全解析:TensorBoard实战手册(九) 实现自定义仪表盘return {# 返回自定义HTML内容return ... 阅读详情

相关推荐

PyTorch深度学习实战手册:从基础到进阶

PyTorch是由Facebook的AI研究团队开发的一个开源机器学习库,主要用于计算机视觉和自然语言处理领域。它基于Python语言设计,是一个动态神经网络框架,因其灵活性和易用性而受到广泛的欢迎。PyTorch的最大特点是其动态计算图,这种特性让研究者可以更容易地调试和修改模型结构。损失函数用于衡量模型预测值与真实值之间的差异,是训练过程中优化的目标。PyTorch提供了多种损失函数,例如均方误差(MSE)、交叉熵损失(CEL)等。# 均方误差损失函数。

weixin_31974443的博客 784

pytorch GPU分布式训练 单机单卡、单机多卡

GPU分布式训练

hihui1231的博客 7188

Aspice的理解

ASPICE 是由汽车行业的主要公司和组织合作开发的,包括德国汽车工业联合会(VDA)和国际汽车工作组(Automotive SIG)。其目标是通过标准化的软件开发流程,提高汽车电子系统的软件质量和可靠性。

hkj8808的博客 2017

pytorch 分布式训练

作者 | 堂姐 来源 |九点澡堂子 编辑 | 极市平台 导语: 前段时间工作涉及到修改分布式训练代码,在自研的工具库里直接调用简单的几行代码就可以,很多复杂的东西都封装起来了,但总感觉还是尽可能多了解下背后的东西比较好,原理和Pytorch的类似,就直接以torch来分析记录了。 过程中碰到想不明白的地方就“骚扰”同事小伙伴和mentor,周末也不放过,远程表感谢和歉意hh。 正文: Pytorch 分布式训练主要有两种方式: torch.nn.DataParallel ==> 简称.

专注分享 AI 干货,社交平台会同步更新配套资源(同名),欢迎大家关注 5407

Axure rp9 中继器新建表格

Axure rp9 中继器新建表格

weixin_49295490的博客 1654

第2章 数据库关系模型-单元测验-数据库原理及应用

第2章 数据库关系模型---数据库与机器学习 作业 常用的关系查询操作包括选择、投影、连接、并、交等。 v 实体完整性是指关系表的属性组成必须是完整的。 x 自然连接是一种等值连接。 v 在参照完整性中,可以定义级联操作。 v 用户自定义完整性可以实施数据的业务约束。 v 每个关系是一个二维表,但二维表不一定是关系。 v 关系中复合键至少包含两个属性。 v 代理键是为了唯一标识关系的不同元组,需要在表单或报表中显示出来。 x ...

aiqq136的博客 5728

GPU分布式训练

Ring AllReduce架构中没有server,都是worker,所有worker组成一个环形,每个worker和另外两个worker相连。特点:随着worker数量增加,模型的运行效率并不是线性提升的(worker的增加导致worker与server通信时长增加);server节点保存模型参数,如果有多个server节点会把模型参数保存多份到多个server上;worker负责使用server上的参数以及本worker上的数据计算梯度;特点:运行效率随着worker数量的增加线性增加;

just 1152

智能织梦:基于Rokid AR眼镜的家庭情感记忆增强系统设计与实践

本文介绍了基于Rokid AR眼镜的'智能织梦'系统,通过增强现实技术捕捉和重现家庭情感记忆。系统利用多模态传感器和轻量级情感识别模型,自动记录家庭互动中的情感峰值时刻,并生成沉浸式记忆片段。测试数据显示,该系统显著提升了家庭情感互动的频率和质量,特别适用于多代同堂家庭和记忆唤醒场景。

sre5engineer的博客 538

单机多卡和单机单卡训练模型,权重文件中多了module

在自己电脑上(单卡)调试好模型,然后放到服务器(多卡)上跑,设置成了多卡训练,保存的模型字典中自动都增加了一个module,导致我在自己电脑上加载时候checkpoints不匹配。所以有了这份记录。

qq_39333636的博客 1107

基于TENG的呼吸测量与识别系统:从蓝牙到WiFi的改造与上位机实现

本文介绍了一种基于摩擦纳米发电机(TENG)的呼吸测量系统改造方案,将原有蓝牙通信升级为WiFi传输。系统通过TENG传感器采集呼吸信号,STM32微控制器处理数据后,经ESP8266 WiFi模块发送至上位机。文中详细阐述了硬件改造(四通道改单通道、蓝牙换WiFi)、嵌入式软件修改(包括ESP8266驱动、数据采集与TCP通信实现)以及上位机软件设计。改造后的系统提升了传输距离和稳定性,为可穿戴健康监测提供了更优解决方案。

huanghm88的专栏 110

SMART200如何实现多次调用子程序带定时器功能

1、西门子200PLC的子程序由于很多限制条件,如果希望建立一个可以多次调用的子程序,那么这个子程序里是不能含有定时器指令的,所以我们只能退而求其次了。建议将沿指令(上升沿、下降沿)放在多次调用子程序的外面。 2、可以提供不同的时基,提供不同时间的定时 3、实现秒定时 5、子程序内部: STL代码: 1、时基信号由外部提供、 可以提供不同的时基信号 2、实现循环定时开关 LD #Start:L0....

RXXW_Dor的博客 1万+

【Python-单机单卡、单机多卡、多机多卡】训练自己的数据集——数据读取、处理、训练、测试、可视化、Debug

转载 https://blog.youkuaiyun.com/renhanchi/article/details/79570665 Github代码地址:https://github.com/HandsomeHans/Tensorflow-preprocessing-training-testing所有代码去Github上拿吧,文件名对应好。TF版

图挖掘领域,新晋砖家 ☞ 未来可期,欢迎和静静一起学习交流吖 4026

Codex、Claude Code、Opus、Trae、Cursor:一文讲懂 2026 AI 编程工具格局

2026年AI编程工具将形成三层体系:模型层(Opus/Codex)负责思考,执行层(Claude Code/Codex Agent)负责自动开发任务,工具层(Cursor/Trae)提供AI集成的开发环境。关键区别在于Agent路线强调AI主导自动化开发,而IDE路线保持人类主导。未来竞争力取决于能否将AI整合为生产力系统,掌握模型推理、Agent任务编排和AI IDE协同三大能力。核心转变是从"写代码"升级为"指挥AI写代码",高级玩家通过组合不同层级工具构建自动

m0_51738372的博客 2700

「新生手册」:PyTorch分布式训练

点击下方卡片,关注“CVer”公众号AI/CV重磅干货,第一时间送达本文作者:花花|来源:知乎(已获作者授权)https://zhuanlan.zhihu.com/p/3604055...

阿木寺的博客 1597

【温室气体数据集】CAMS 发布的温室气体(GHG)数据集总结

【温室气体数据集】CAMS 发布的温室气体(GHG)数据集总结

WW、forever的博客 556

怀旧版电脑GBC模拟器

再现原版GBC掌机的界面,电脑运行连游戏界面都一样大小,很怀旧,很真实,(英文版)强烈推荐,很小的文件,很难才找到的。

深入解析PyTorch架构:从动态计算图到分布式训练

深度学习框架是现代人工智能应用的核心基础设施,其设计架构直接决定了开发效率和模型性能。PyTorch作为主流框架之一,其核心在于动态计算图机制,它允许在运行时构建和修改计算图,为模型调试和实验提供了极大的灵活性。这一特性使得PyTorch在研究和原型开发阶段备受青睐。从技术实现层面看,PyTorch采用分层架构,前端Python接口负责灵活交互,C++核心层处理高性能计算和自动微分,底层则通过CUDA等硬件后端实现算力加速。这种设计在工程实践中价值显著,既能满足快速迭代的研发需求,又能通过JIT编译和分布式

djph26741的博客 618

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

DeepSpeed:PyTorch优化库,使模型分布式训练能高效使用内存和更快速

DeepSpeed是一个PyTorch优化库,它能让大模型的分布式训练更加节省内存和更快速。它的核心是ZeRO,ZeRO让大规模的训练大模型成为可能。在GPU受限的环境下,ZeRO可以将优化器内存和计算从GPU卸载到CPU从而利用单个GPU训练大模型。DeepSpeed 已经集成到Transformers Trainer里面完成ZeRO所有的状态和卸载。我们需要做的只是提供一个配置文件或者使用一个已经提供好的文件模版。针对推理,Transformers支持ZeRO-3和卸载,从而允许加载超大模型。

duzm200542901104的专栏 1601

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版

Part-E1-SDIO-Specification-Ver4.00-Final-120220.pdf:最新的sdio 4.0 spec 协议标准 带书签 高清完整PDF版,包括SDIO 接口的外设,SDIO 接口官方协议等。

PyTorch的官方手册

PyTorch的分布式训练:https://pytorch.org/docs/stable/distributed.html。PyTorch的可视化工具:https://pytorch.org/docs/stable/tensorboard.html。PyTorch的API文档:https://pytorch.org/docs/stable/index.html。PyTorch的ONNX导出:https://pytorch.org/docs/stable/onnx.html。

zhous_的博客 1566

PyTorch+DeepSpeed分布式大模型训练实战指南

分布式训练是突破单机显存限制、加速大模型训练的核心技术,其核心原理是通过数据并行、模型并行等方式将计算任务分配到多台设备协同完成。PyTorch框架结合DeepSpeed工具库提供了完善的分布式训练支持,包括ZeRO优化、梯度压缩等关键技术,能有效降低通信开销并提升训练效率。在实际应用中,合理配置硬件环境(如RDMA网络、GPU选型)和软件栈(CUDA版本、NCCL参数)对性能至关重要。本文以70B参数模型训练为例,详细解析如何通过DeepSpeed实现17倍加速,并分享NCCL通信死锁、梯度同步陷阱等实战

weixin_30908941的博客 639

Pytorch多GPU条件下DDP集群分布训练实现(简述-从无到有)

近两天在尝试Pytorch环境下多GPU的模型训练,总结一份可以从无到有完整实现的笔记。搞了一晚上加一中午,终于搞成功了。这里对此进行记录,便于以后查阅。

等待戈多的博客 2812

PyTorch 2.8镜像实操手册:从pip install到分布式训练启动全流程

本文介绍了如何在星图GPU平台上自动化部署PyTorch 2.8深度学习镜像,快速搭建AI开发环境。该镜像预装了完整的PyTorch生态及大模型组件,特别适用于分布式训练和图片生成等深度学习任务,显著提升模型开发效率。

weixin_42097508的博客 426

从ModuleNotFoundError到熟练使用:一份给PyTorch新手的torchinfo避坑与进阶手册

本文为PyTorch新手提供了一份全面的torchinfo使用指南,从解决常见的ModuleNotFoundError错误入手,详细介绍了环境配置、依赖管理以及torchinfo的核心功能与高级技巧。通过实战案例展示如何分析模型结构、优化性能,并与其他工具如TensorBoard整合,帮助开发者快速掌握模型可视化分析的方法。

xieye114的专栏 530

mmclas的分布式训练

「新生手册」:PyTorch分布式训练 - 知乎目录0X01 分布式并行训练概述0X02 Pytorch分布式数据并行0X03 手把手渐进式实战A. 单机单卡B. 单机多卡DPC. 多机多卡DDPD. Launch / Slurm 调度方式0X04 完整框架 Distribuuuu0X05 Reference 文中所有教学代码和日…https://zhuanlan.zhihu.com/p/360405558轻松掌握 MMDetection 整体构建流程(二) - 知乎文@ 0000070 摘要在 轻松掌握

liguandong 863

深度学习工程实战:PyTorch分布式训练与CNN架构优化

卷积神经网络(CNN)已从经典结构演进为可微分架构搜索(DARTS)友好的动态设计范式;分布式训练也不再是简单并行,而是涉及DDP通信开销、NCCL兼容性与多机checkpoint一致性的系统工程。理解其底层原理——如计算图隐式依赖、显存生命周期管理、混合精度数值稳定性——是实现模型高效复现与稳定部署的技术前提。这些能力直接支撑工业级AI Infra建设、大模型训练加速及边缘端量化部署等核心场景。本文聚焦PyTorch生态下的真实工程断层与落地细节,覆盖CSPNet骨干网优化、BatchNorm梯度陷阱、A

weixin_32296621的博客 168
上一篇: 腾讯员工晒出薪资:真实985毕业薪资,大家看我还有救吗?网友:日薪?
下一篇: 同济版《线性代数》再遭口诛笔伐,网友:它真的不太行
机器学习算法那些事
博客等级 码龄9年 1633粉丝 62原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值