Pytorch 多卡并行（1）—— 原理简介和 DDP 并行实践

已于 2023-09-12 16:05:09 修改
阅读量834 收藏 8
点赞数 3
分类专栏： # PyTorch 文章标签： pytorch DDP 多卡并行
于 2023-09-11 21:45:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxc971231/article/details/132816104
版权
  • 近年来，深度学习模型的规模越来越大，需要处理的数据也越来越多，单卡训练的显存空间和计算效率都越来越难以满足需求。因此，多卡并行训练成为了一个必要的解决方案
  • 本文主要介绍使用 Pytorch 的 DistributedDataParallel（DDP）库进行分布式数据并行训练的方法
  • 完整代码下载：wxc971231/ddp-tutorial-series

文章目录

1. 多卡并行简介

  • 多卡并行训练主要用于解决以下几个问题：
    1. 相同 batch size 下加速训练：多卡并行可以将数据分为多份同时在不同的GPU上运行，从而大大加快训练速度
    2. 相同速度下使用更大的 batch size：多卡并行可以在多个GPU之间共享显存，允许我们设置更大的 batch size
    3. 增加可训练的模型规模：有些模型参数多到单卡训练无法承受，而多卡并行可以将模型放入多个GPU中，从而扩充可训练模型的规模

1.1 两种并行形式

  • 多卡并行训练有数据并行和模型并行两种形式
    在这里插入图片描述

    1. 数据并行：每个GPU都保存一个模型副本，训练数据划分成多份交给各个GPU计算梯度，然后汇总梯度更新模型参数。根据梯度汇总的方式，数据并行又可以分成 Parameter Server 和 Ring All-Reduce 两种，前者使用一个 master GPU 汇总梯度更新参数，再将参数分发给各个模型；后者以环的形式互相传递梯度，每个GPU都维护一个优化器，各自汇总梯度并自行更新模型参数。Ring All-Reduce 方案能更高效地利用所有卡的上下行带宽，是目前的主流方案
      在这里插入图片描述

    2. 模型并行：将模型切分成多个部分放在不同的GPU上并行运行，每个GPU负责处理一部分模型参数，并将处理后的结果发送到其它GPU进行合并，从而实现整体模型的更新。这种操作目前并不常见，一是因为大部分模型单卡都放得下，二是因为通讯开销比数据并行多。根据模型切分方式，模型并行也可以分成 Pipelined Parallelism 和 Tensor Slicing 两种，前者将模型的各个层放到不同的 GPU 上运行，这种做法比较通用，但是效率不高；后者针对模型中各种模块（attention、FFN 等）的张量计算操作进行拆解，把 tensor 计算分块分散到不同的机器上进行并行，效率较高但是通用性差
      在这里插入图片描述

  • 关于各种并行方法的详细说明可以参考：分布式训练、混合精度训练、梯度累加…一文带你优雅地训练大型模型

1.2 Pytorch 中的多卡并行

  • 随着各种深度学习框架的日趋完善，很多并行方法已经被整合其中，这让实现多卡并行加速训练变得相对简单。Pytorch 中提供了 DP（DataParallel） 和 DDP（DistributedDataParallel） 两种数据并行方法，它们的性能对比如下
    在这里插入图片描述
    红色柱子是 DP，绿色柱子是 DDP，蓝色柱子是 DDP + Apex 混合精度训练。注意到 DDP 的表现大幅优于 DP，这是因为
    1. DP 使用 Parameter Server 方式汇聚梯度并更新参数，主卡计算负载和通信带宽需求相比其他卡都显著高，导致主卡的计算能力和上下行带宽成为性能瓶颈；
    2. DDP 使用更高效的 Ring All-Reduce 方案，基本实现了 “使用几块GPU就是几倍加速” 的效果
  • 接下来本文会介绍使用 DDP 进行多卡加速的具体做法，参考自：Pytorch 官方教程

2. 使用 DDP 进行单机多卡训练

2.1 原理概述

  • DDP 会在每个 GPU 上运行一个进程，每个进程中都有一套完全相同的 Trainer 副本（包括 model 和 optimizer），各个进程之间通过一个进程池进行通信。这里有几个术语
    1. node：多机多卡运行时，每个机器称为一个 “node”，其中每一张卡都可以运行一个并行进程
    2. world size：所有并行进程的总数，各个 node 上并行的GPU总数
    3. rank：所有 node 的所有进程中，各个进程的标识符号，是从0开始计数的整数
    4. local rank：当前 node 的所有进程中，各个进程的标识符号，是从0开始计数的整数
    5. group：所有并行的进程组成一个 group（进程池），只有组内的进程间才可以相互通信

2.2 使用 DDP 改写单卡训练代码

  • 考虑如何将以下单机单卡代码改为 DDP 单机多卡运行

    # 单 GPU 训练示例
import torch
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader

class Trainer:
    def __init__(
        self,
        model: torch.nn.Module,
        train_data: DataLoader,
        optimizer: torch.optim.Optimizer,
        gpu_id: int,
        save_every: int, 
    ) -> None:
        self.gpu_id = gpu_id
        self.model = model.to(gpu_id)
        self.train_data = train_data
        self.optimizer = optimizer
        self.save_every = save_every

    def _run_batch(self, source, targets):
        self.optimizer.zero_grad()
        output = self.model(source)
        loss = F.cross_entropy(output, targets)
        loss.backward()
        self.optimizer.step()

    def _run_epoch(self, epoch):
        b_sz = len(next(iter(self.train_data))[0])
        print(f"[GPU{self.gpu_id}] Epoch {epoch} | Batchsize: {b_sz} | Steps: {len(self.train_data)}")
        for source, targets in self.train_data:
            source = source.to(self.gpu_id)
            targets = targets.to(self.gpu_id)
            self._run_batch(source, targets)

    def _save_checkpoint(self, epoch):
        ckp = self.model.state_dict()
        PATH = "checkpoint.pt"
        torch.save(ckp, PATH)
        print(f"Epoch {epoch} | Training checkpoint saved at {PATH}")

    def train(self, max_epochs: int):
        for epoch in range(max_epochs):
            self._run_epoch(epoch)
            if epoch % self.save_every == 0:
                self._save_checkpoint(epoch)

class MyTrainDataset(Dataset):
    def __init__(self, size):
        self.size = size
        self.data = [(torch.rand(20), torch.rand(1)) for _ in range(size)]

    def __len__(self):
        return self.size
    
    def __getitem__(self, index):
        return self.data[index]

def load_train_objs():
    train_set = MyTrainDataset(2048)  # load your dataset
    model = torch.nn.Linear(20, 1)  # load your model
    optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)
    return train_set, model, optimizer

def prepare_dataloader(dataset: Dataset, batch_size: int):
    return DataLoader(
        dataset,
        batch_size=batch_size,
        pin_memory=True,
        shuffle=True
    )

def main(device, total_epochs, save_every, batch_size):
    dataset, model, optimizer = load_train_objs()
    train_data = prepare_dataloader(dataset, batch_size)
    trainer = Trainer(model, train_data, optimizer, device, save_every)
    trainer.train(total_epochs)

if __name__ == "__main__":
    import argparse
    parser = argparse.ArgumentParser(description='simple distributed training job')
    parser.add_argument('--total-epochs', type=int, default=50, help='Total epochs to train the model')
    parser.add_argument('--save-every', type=int, default=10, help='How often to save a snapshot')
    parser.add_argument('--batch_size', default=32, type=int, help='Input batch size on each device (default: 32)')
    args = parser.parse_args()
    
    device = 0  # shorthand for cuda:0
    main(device, args.total_epochs, args.save_every, args.batch_size)

  • 将单卡训练代码改写为 DDP 并行的要点如下

    1. 引入 DDP 相关库
      # 使用 DistributedDataParallel 进行单机多卡训练
import torch
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
import os

# 对 python 多进程的一个 pytorch 包装，用于后续分发进程
import torch.multiprocessing as mp
# 这个 sampler 可以把采样的数据分散到各个 CPU 上                                      
from torch.utils.data.distributed import DistributedSampler     
# 实现分布式数据并行的核心类        
from torch.nn.parallel import DistributedDataParallel as DDP         
# 各个进程之间通过一个进程池进行通信，这两个方法来初始化和销毁进程池
from torch.distributed import init_process_group, destroy_process_group
    2. 在程序入口初始化进程池；在程序出口销毁进程池
      def main(rank: int, world_size: int, save_every: int, total_epochs: int, batch_size: int):
    # 初始化进程池
    ddp_setup(rank, world_size)

    # 进行训练
    dataset, model, optimizer = load_train_objs()
    train_data = prepare_dataloader(dataset, batch_size)
    trainer = Trainer(model, train_data, optimizer, rank, save_every)
    trainer.train(total_epochs)
   
    # 销毁进程池
    destroy_process_group()
    3. 使用 DistributedDataParallel 包装模型，这样模型才能在各个进程间同步参数
      self.model = DDP(model, device_ids=[gpu_id])    # model 要用 DDP 包装一下
      包装后 model 变成了一个 DDP 对象，要访问其参数得这样写 self.model.module.state_dict()
    4. 构造 Dataloader 时使用 DistributedSampler 作为 sampler，这个采样器可以自动将数量为 batch_size 的数据分发到各个GPU上，并保证数据不重叠
      def prepare_dataloader(dataset: Dataset, batch_size: int):
    return DataLoader(
        dataset,
        batch_size=batch_size,
        pin_memory=True,
        shuffle=False,                      # 设置了新的 sampler，参数 shuffle 要设置为 False 
        sampler=DistributedSampler(dataset) # 这个 sampler 自动将数据分块后送个各个 GPU，它能避免数据重叠
    )
      注意需要在各 epoch 入口调用该 sampler 对象的 set_epoch() 方法，否则每个 epoch 加载的样本顺序都不变
    5. 运行过程中单独控制某个进程进行某些操作，比如要想保存 ckpt，由于每张卡里都有完整的模型参数，所以只需要控制一个进程保存即可。需要注意的是：使用 DDP 改写的代码会在每个 GPU 上各自运行，因此需要在程序中获取当前 GPU 的 rank（gpu_id），这样才能对针对性地控制各个 GPU 的行为
      if self.gpu_id == 0 and epoch % self.save_every == 0:
	self._save_checkpoint(epoch)
    6. 使用 torch.multiprocessing.spawn 方法将代码分发到各个 GPU 的进程中执行
      # 利用 mp.spawn，在整个 distribution group 的 nprocs 个 GPU 上生成进程来执行 fn 方法，并能设置要传入 fn 的参数 args
# 注意不需要传入 fn 的 rank 参数，它由 mp.spawn 自动分配
world_size = torch.cuda.device_count()
mp.spawn(
    fn=main, 
    args=(world_size, args.save_every, args.total_epochs, args.batch_size), 
    nprocs=world_size
)

  • 完整的修改版代码如下，请参考注释自行对比

    # 使用 DistributedDataParallel 进行单机多卡训练
import torch
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
import os

# 对 python 多进程的一个 pytorch 包装
import torch.multiprocessing as mp

# 这个 sampler 可以把采样的数据分散到各个 CPU 上                                      
from torch.utils.data.distributed import DistributedSampler     

# 实现分布式数据并行的核心类        
from torch.nn.parallel import DistributedDataParallel as DDP         

# DDP 在每个 GPU 上运行一个进程，其中都有一套完全相同的 Trainer 副本（包括model和optimizer）
# 各个进程之间通过一个进程池进行通信，这两个方法来初始化和销毁进程池
from torch.distributed import init_process_group, destroy_process_group 


def ddp_setup(rank, world_size):
    """
    setup the distribution process group

    Args:
        rank: Unique identifier of each process
        world_size: Total number of processes
    """
    # MASTER Node（运行 rank0 进程，多机多卡时的主机）用来协调各个 Node 的所有进程之间的通信
    os.environ["MASTER_ADDR"] = "localhost" # 由于这里是单机实验所以直接写 localhost
    os.environ["MASTER_PORT"] = "12355"     # 任意空闲端口
    init_process_group(
        backend="nccl",                     # Nvidia CUDA CPU 用这个 "nccl"
        rank=rank,                          
        world_size=world_size
    )
    torch.cuda.set_device(rank)

class Trainer:
    def __init__(
        self,
        model: torch.nn.Module,
        train_data: DataLoader,
        optimizer: torch.optim.Optimizer,
        gpu_id: int,
        save_every: int,
    ) -> None:
        self.gpu_id = gpu_id
        self.model = model.to(gpu_id)
        self.train_data = train_data
        self.optimizer = optimizer
        self.save_every = save_every                    # 指定保存 ckpt 的周期
        self.model = DDP(model, device_ids=[gpu_id])    # model 要用 DDP 包装一下

    def _run_batch(self, source, targets):
        self.optimizer.zero_grad()
        output = self.model(source)
        loss = F.cross_entropy(output, targets)
        loss.backward()
        self.optimizer.step()

    def _run_epoch(self, epoch):
        b_sz = len(next(iter(self.train_data))[0])
        print(f"[GPU{self.gpu_id}] Epoch {epoch} | Batchsize: {b_sz} | Steps: {len(self.train_data)}")
        self.train_data.sampler.set_epoch(epoch)        # 在各个 epoch 入口调用 DistributedSampler 的 set_epoch 方法是很重要的，这样才能打乱每个 epoch 的样本顺序
        for source, targets in self.train_data: 
            source = source.to(self.gpu_id)
            targets = targets.to(self.gpu_id)
            self._run_batch(source, targets)

    def _save_checkpoint(self, epoch):
        ckp = self.model.module.state_dict()            # 由于多了一层 DDP 包装，通过 .module 获取原始参数 
        PATH = "checkpoint.pt"
        torch.save(ckp, PATH)
        print(f"Epoch {epoch} | Training checkpoint saved at {PATH}")

    def train(self, max_epochs: int):
        for epoch in range(max_epochs):
            self._run_epoch(epoch)
            # 各个 GPU 上都在跑一样的训练进程，这里指定 rank0 进程保存 ckpt 以免重复保存
            if self.gpu_id == 0 and epoch % self.save_every == 0:
                self._save_checkpoint(epoch)

class MyTrainDataset(Dataset):
    def __init__(self, size):
        self.size = size
        self.data = [(torch.rand(20), torch.rand(1)) for _ in range(size)]

    def __len__(self):
        return self.size
    
    def __getitem__(self, index):
        return self.data[index]

def load_train_objs():
    train_set = MyTrainDataset(2048)  # load your dataset
    model = torch.nn.Linear(20, 1)  # load your model
    optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)
    return train_set, model, optimizer


def prepare_dataloader(dataset: Dataset, batch_size: int):
    return DataLoader(
        dataset,
        batch_size=batch_size,
        pin_memory=True,
        shuffle=False,                      # 设置了新的 sampler，参数 shuffle 要设置为 False 
        sampler=DistributedSampler(dataset) # 这个 sampler 自动将数据分块后送个各个 GPU，它能避免数据重叠
    )


def main(rank: int, world_size: int, save_every: int, total_epochs: int, batch_size: int):
    # 初始化进程池
    ddp_setup(rank, world_size)

    # 进行训练
    dataset, model, optimizer = load_train_objs()
    train_data = prepare_dataloader(dataset, batch_size)
    trainer = Trainer(model, train_data, optimizer, rank, save_every)
    trainer.train(total_epochs)
   
    # 销毁进程池
    destroy_process_group()


if __name__ == "__main__":
    import argparse
    parser = argparse.ArgumentParser(description='simple distributed training job')
    parser.add_argument('--total-epochs', type=int, default=50, help='Total epochs to train the model')
    parser.add_argument('--save-every', type=int, default=10, help='How often to save a snapshot')
    parser.add_argument('--batch_size', default=32, type=int, help='Input batch size on each device (default: 32)')
    args = parser.parse_args()
    
    world_size = torch.cuda.device_count()
    
    # 利用 mp.spawn，在整个 distribution group 的 nprocs 个 GPU 上生成进程来执行 fn 方法，并能设置要传入 fn 的参数 args
    # 注意不需要 fn 的 rank 参数，它由 mp.spawn 自动分配
    mp.spawn(
        fn=main, 
        args=(world_size, args.save_every, args.total_epochs, args.batch_size), 
        nprocs=world_size
    )
云端FFF
关注
  • 3
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
程序如何在两个gpu卡上并行运行_单机多卡并行训练的程序编写
weixin_33059693的博客
01-12 2640
本文采用的方法为作者独自设计，未参考其他框架的思路。如有雷同纯属巧合。注意事项神经网络的多卡并行训练通常有两个思路，一是数据并行，二是网络并行。数据并行即多张显卡上使用的是同一个网络和权重，将训练集拆分为两个部分，各自计算之后，将权重变化取平均值并同时更新。网络并行即考虑网络本身规模很大，因此需要将网络分成多个部分存在多张显卡上。因为这个并行设计与网络结构相关，需要针对具体问题，通用性不高，本文只...
pytorch多GPU并行训练教程及源码
10-16
多GPU启动指令说明： 1.如果要使用train_multi_gpu_using_launch.py脚本，使用以下指令启动 python -m torch.distributed.launch --nproc_per_node=8 --use_env train_multi_gpu_using_launch.py其中nproc_per_node为并行GPU的数量
pytorch多GPU并行运算的实现
09-18
主要介绍了pytorch多GPU并行运算的实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
「分布式训练」+ DDP单机多卡并行指南
07-20
本课件包含对分布式训练及Pytorch两种主要的并行训练方式DP以及DDP的原理介绍， 以及使用 DDP 实现单机多卡并行方式的代码修改要点总结。
pytorch 模拟关系拟合——回归实例
01-20
本次用 pytroch 来实现一个简单的回归分析，也借此机会来熟悉 pytorch 的一些基本操作。 1. 建立数据集 import torch from torch.autograd import Variable import matplotlib.pyplot as plt # torch.linspace(-1,1,100)表示返回一个一维张量，包含在区间 -1到1 上均匀间隔的100个点； # torch.unsqueeze(input,dim=1)表示转换维度 x = torch.unsqueeze(torch.linspace(-1, 1, 100), dim=1) # 生成的
torch笔记二十一 | 单机多卡并行
滨哥v5的博客
06-21 1639
多GPU并行运算
Pytorch 多卡并行（3）—— 使用 DDP 加速 minGPT 训练
佚失的诗篇
09-12 1063
本文介绍如何使用 DDP 和混合精度训练方法来高效地训练一个 MinGPT 模型
Pytorch 多卡并行（2）—— 使用 torchrun 进行容错处理
佚失的诗篇
09-12 5415
本文介绍如何使用 torchrun 框架改写 DDP 单机多卡并行代码，增强容错性和稳定性
Pytorch 多卡并行训练教程 （DDP）
fovever_的博客
01-01 5308
Pytorch 多卡并行训练教程 （DDP），关于使用DDP进行多开并行训练 网上有许多教程，而且很多对原理解析的也比较透彻，但是有时候看起来还是比较懵逼，再啃了许多相关的博客后，博主记录了一些自己对于使用torch.nn.DistributedDataParallel(DDP)进行单机多卡并行训练的一些体会，希望能对入门的小白有一定的帮助，不足之处也希望指出，大家一起交流学习。
简述Pytorch多卡训练原理与实现
weixin_52067875的博客
07-11 5529
简述Pytorch多卡训练原理与实现
深度学习单机多卡/多机多卡训练
slamer111的博客
09-06 1034
感知秋招面经：多机多卡你用过吗？
Pytorch分布式训练/多卡训练(二) —— Data Parallel并行(DDP)(2.1)(基本概念&代码框架)
hxxjxw的博客
08-18 4072
Pytorch官网已经建议使用DistributedDataParallel来代替DataParallel, 因为DistributedDataParallel比DataParallel运行的更快, 然后显存分配的更加均衡. 而且DistributedDataParallel功能更加强悍 DDP与DP的区别 ①DataLoader部分需要使用Sampler，保证不同GPU卡处理独立的子集. ②模型部分使用DistributedDataParallel. DDP的主要代码部分 .......
【Pytorch】单机多卡数据并行DataParallel
小苏打的学习博客
05-07 4032
单卡多级的模型训练，即并行训练，可分为数据并行和模型并行两种. 数据并行是指，多张 GPUs 使用相同的模型副本，但采用不同 batch 的数据进行训练. 模型并行是指，多张 GPUs 使用同一 batch 的数据，分别训练模型的不同部分. 如图： 1. DataParallel 简述 pytorch 默认只用一个 GPU，但采用 DataParallel很便于使用多 GPUs 的. import os os.environ["CUDA_VISIBLE_DEVICES"] = "1,2" # 注: 多卡
Google的MLP-MIXer的复现（pytorch实现）
最新发布
qq_45689158的博客
05-23 465
2.在处理两个差异的时候，如输入维度[32,196,512],其中代表的意思分别为batch_size为32，196为图片在经过patch之后的224*224输入之后经过patch=16，变为14 * 14即196，512会在二维卷积处理之后输出的channel类似。在nn.linear那儿的in_channel与第三个维度保持一致，就可以不必将其三维的转换为二维的。在将flax框架的代码改为pytorch实现的时候，还是踩了不少的坑，在此讲一下，希望后面做的人，可以避免。
Pytorch线性模型(Linear Model)
xiongmaowangd的博客
05-22 791
①首先准备好数据集（DataSet）②模型的选择或者设计（Model）③进行训练（Train）大部分模型都需要训练，有些不需要。这一步后我们会确定不同特征的权重④推理（inferring）1，2，3hours会有一个结果2，4，6points。这个就是训练过程，把x和y都给模型，让他自己学。5hours这个没有一个对应的y，这个就是我们的预测过程（相当于上面的题目学完了后，现在写这个题，看能不能写对）。
【Pytorch】目标检测数据集
开心星人的博客
05-19 633
目标检测 Object Detection ：检测，不仅要找到图片上的所关心的目标位置，同时还要识别出这个目标是什么类别。主流的目标检测都是以 矩阵框 的形式进行输出的，而语义分割比目标检测的精度更高。
Pytorch（Overview）
xiongmaowangd的博客
05-22 793
刚刚上面说的计算图算法，我们不需要自己去实现的。我们通常使用现成的deep learning framework 去进行实现（当然也可以自己去写framework，但是这个比我们写深度神经网络要难）我们将会用到的deep learning frameworks是pytorch（facebook），当然还有其他的如TensorFlow（Google），还有一个就是已近和pytorch合并的Caffe（facebook），还有如MxNet。欢迎大家一起学习Pytorch相关知识！！！
快速入门PyTorch自然语言处理，实现文本分类
csdn1561168266的博客
05-22 505
PyTorch为处理自然语言处理任务提供了一个直观且强大的平台，从创建简单的神经网络到处理词嵌入和文本分类，该框架简化了开发过程。随着深入使用PyTorch探索NLP，不妨尝试挑战一些更高级的领域，例如序列到序列模型、注意力机制和迁移学习。PyTorch社区提供了丰富的资源、教程和预训练模型，为大家学习和实践提供了强有力的支持。
pytorch多卡分布式训练
07-14
PyTorch提供了多种方法来进行多卡分布式训练，以加快模型的训练速度和提高性能。下面是一些常见的方法： 1. DataParallel：PyTorch内置的DataParallel模块可以在单个机器上使用多个GPU进行训练。它通过自动将输入数据划分为多个子批次，并在每个GPU上运行模型的副本，然后将梯度聚合并更新模型参数。 2. DistributedDataParallel：DistributedDataParallel (DDP) 是一种更高级的多卡分布式训练方法，可以在多台机器上的多个GPU上进行训练。DDP使用了PyTorch的分布式通信包（torch.distributed）来实现数据的并行化和梯度的聚合。它需要使用torch.distributed.launch工具来启动训练脚本，并设置适当的环境变量。 3. torch.nn.DataParallel vs torch.nn.parallel.DistributedDataParallel: DataParallel适用于单机多卡训练，而DistributedDataParallel则适用于分布式训练。在使用DataParallel时，模型的所有参数都在每个GPU上复制一份，而在使用DistributedDataParallel时，每个GPU只复制模型的部分参数。 使用这些方法时，你需要确保你的代码能够正确地处理数据并行化和梯度聚合，以及处理分布式训练中的通信和同步。你可以参考PyTorch官方文档中关于多卡并行化和分布式训练的部分，以获取更详细的信息和示例代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

云端FFF

所有博文免费阅读，求打赏鼓励~

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值