Pytorch多GPU并行训练: DistributedDataParallel

1 模型并行化训练

1.1 为什么要并行训练

在训练大型数据集或者很大的模型时一块GPU很难放下,例如最初的AlexNet就是在两块GPU上计算的。并行计算一般采取两个策略:一个是模型并行,一个是数据并行。左图中是将模型的不同部分放在不同GPU上进行训练,最后汇总计算。而右图中是将数据放在不同GPU上进行训练,最后汇总计算,不仅能增大BatchSize,还能加快计算速度,提高计算精度

1.2 并行化训练策略

并行化深度学习模型有两种流行的方式:模型并行和数据并行

  • 模型并行

模型并行性是指模型在逻辑上分为几个部分(即,一个部分中的某些层,而另一部分中的某些层),然后将其放置在不同的硬件/设备上。尽管将零件放在不同的设备上确实在执行时间(数据的异步处理)方面有很多好处,但通常可以采用它来避免内存限制。具有大量参数的模型由于这种类型的策略而受益,这些模型由于内存占用量大而难以放入单个系统中。

  • 数据并行

另一方面,数据并行性是指通过位于不同硬件/设备上的同一网络的多个副本来处理多段数据(技术上为批次)。与模型并行性不同,每个副本可能是整个网络,而不仅仅是一部分。这种策略可以随着数据量的增加而很好地扩展。但是,由于整个网络必须驻留在单个设备上,因此无法帮助占用大量内存的模型。

23b7c5c00200463393da99432d1eecd9.png

1.3 单机多卡与多级多卡

在深度学习和其他高性能计算任务中,"单机多卡"(Single-Node Multi-GPU)和"多机多卡"(Multi-Node Multi-GPU)是两种常见的硬件配置,它们涉及使用多个图形处理单元(GPUs)来加速计算。单机多卡配置通常更容易管理和维护,而多机多卡配置提供了更高的计算能力和扩展性,但也带来了更高的复杂度和成本。

2.1.1 单机多卡 (Single-Node Multi-GPU)

  • 定义:所有的 GPU 都安装在同一台机器上。

  • 通信:GPU之间通过PCIe总线或者更高带宽的NVLink进行通信。

  • 适用性:适合中等规模的数据集和模型,通常用于实验室环境或小规模的商业应用。

  • 设置复杂度:相对简单,因为所有的通信都在一个节点内部进行。

  • 扩展性:受限于单个节点能够支持的最大GPU数量。

  • 示例场景:在一个数据中心的单个服务器上训练深度学习模型。

2.1.2 多机多卡 (Multi-Node Multi-GPU)

  • 定义:GPU 分布在多台机器上,这些机器通过网络连接。

  • 通信:机器之间的通信通过高速网络(例如InfiniBand)进行,但比单节点内部的通信要慢。

  • 适用性:适合大规模数据集和模型,通常用于大型数据中心或复杂的机器学习任务。

  • 设置复杂度:更复杂,需要管理节点间的网络通信和同步。

  • 扩展性:理论上可以通过增加更多节点来无限扩展。

  • 示例场景:在多个数据中心分布的服务器上训练大型深度学习模型,如训练大型语言模型或复杂的科学计算任务。

 2 使用DistributedDataParallel实现模型并行化训练

2.1 基本概念

DistributedDataParallel中的关键概念

556a9a0565e34f67a43f8ff0b484a44a.png

1113592fb91148b4a4c05becce7568ed.png

训练过程示意如下:

c95af69e66fc4b58bbb4f55cbf2a1129.png

分布式训练的启动有两种方法,一种是torch.multiprocessing,还有一种是torch.distributed

  • 第一种在启动程序时不需要在命令行输入额外的参数,写起来也比较容易,但是调试较麻烦,比如MAE;
  • 第二种必须要用命令行启动,写起来略微复杂,但是调试较方便。

2.2 torch.distributed分布式训练步骤

2.2.1 导入分布式模块

其中distributed中必须导入的是以下模块

import torch.distributed as dist

2.2.2 用argparse编写模型的个性化参数

parser = argparse.ArgumentParser()'''    ...your params    '''
''' ...distributed params'''# 开启的进程数,不用设置该参数,会根据nproc_per_node自动设置
parser.add_argument('--world-size', default=4, type=int, help='number of distributed processes')
parser.add_argument('--local_rank', type=int, help='rank of distributed processes')
opt = parser.parse_args()

注意这里如果使用了argparse方法的话,必须传入local_rank参数,系统会自动给他进行赋值,如果不传入会报错! 

2.2.3 初始化distributed

初始化过程如下:假设我们的world_size=8,那么我们有8张GPU初始化,初始化有快有慢,快的GPU初始化会在dist.barrier()处停下来等待,当所有的GPU都到达这个函数时,才会继续运行之后的代码。

# 初始化各进程环境
if 'RANK' in os.environ and 'WORLD_SIZE' in os.environ:args.rank = int(os.environ["RANK"])args.world_size = int(os.environ['WORLD_SIZE'])args.gpu = int(os.environ['LOCAL_RANK'])
else:print('Not using distributed mode')return# 设置当前程序使用的GPU。根据python的机制,在单卡训练时本质上程序只使用一个CPU核心,而DataParallel
# 不管用了几张GPU,依然只用一个CPU核心,在分布式训练中,每一张卡分别对应一个CPU核心,即几个GPU几个CPU核心
torch.cuda.set_device(args.gpu)# 分布式初始化
args.dist_url = 'env://'    # 设置url
args.dist_backend = 'nccl'  # 通信后端,nvidia GPU推荐使用NCCL
print('| distributed init (rank {}): {}'.format(args.rank, args.dist_url), flush=True)
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,                      world_size=args.world_size, rank=args.rank)
dist.barrier()  # 等待所有进程都初始化完毕,即所有GPU都要运行到这一步以后在继续'''
| distributed init (rank 1): env://
| distributed init (rank 2): env://
| distributed init (rank 0): env://
| distributed init (rank 3): env://
'''

 torch.distributed.init_process_group 是PyTorch中的一个函数,它用于初始化默认的分布式进程组,从而允许进行跨多个进程的通信。这个函数在使用 PyTorch 的分布式功能时非常重要,特别是在使用 DistributedDataParallel (DDP) 进行多GPU或多节点训练时。真正意义上来讲,分布式的初始化就只有dist.init_process_group这一句。

从上面我们print的输出可以得到不同GPUs初始化的速度是不同的,这也正是因为每个GPU都分配了一个CPU核心,他们的速度有快有慢,比如本次实验初始化顺序为1,2,0,3

关于环境变量,有一下几点需要注意

  • local_rank是被自动赋值的,在单机多卡中他和rank的值相同
  • os.environ[“RANK”]是没有值的,运行时在命令行上输入python -m torch.distributed.launch --nproc_per_node=4 --use_env train.py他才被赋予了值
  • –nproc_per_node=4这条指令可以将os.environ[“WORLD_SIZE”]赋值为4
  •  如果用argparse这个库,就必须加上local_rank变量,如果忘记加了,在命令行启动时就需要加上–use_env参数,–use_env 表示 Local Rank 用 LOCAL_RANK 这个环境变量传参

2.2.4 设置数据集分布式的数据集加载

设置数据集分布式的数据集加载不同于之前的单卡,这里需要将数据集分为N部分,N为卡的数量。单卡时只需要设置Datasets→DataLoader即可,但是分布式中需要对每一块GPU分配不重复的数据,分配方式也不难,分配方式变为:Datasets→DistributedSampler→BatchSampler→DataLoader(BatchSampler可以省略)

DistributedSampler将数据集N等分,BatchSamper将每一等分后的数据内部进行batch的划分。BatchSampler的作用就是分配batchsize,这一步可以再DataLoader中分配,因此也可以将BatchSampler省略。下图展示了数据集的分配过程
1d36f7aaaa3e46b29ee5a0c79f205d07.jpeg

# 1. datasets
train_datasets = MyDataSet(xxx)
val_datasets = MyDataSet(xxx)# 2. DistributedSampler
# 给每个rank对应的进程分配训练的样本索引,比如一共800样本8张卡,那么每张卡对应分配100个样本
train_sampler = torch.utils.data.distributed.DistributedSampler(train_datasets)
val_sampler = torch.utils.data.distributed.DistributedSampler(val_datasets)# 3. BatchSampler
# 刚才每张卡分了100个样本,假设BatchSize=16,那么能分成100/16=6...4,即多出4个样本
# 下面的drop_last=True表示舍弃这四个样本,False将剩余4个样本为一组(注意最后就不是6个一组了)
train_batch_sampler = torch.utils.data.BatchSampler(train_sampler, batch_size, drop_last=True)# 4. DataLoader
# 验证集没有采用batchsampler,因此在dataloader中使用batch_size参数即可
train_dataloader = torch.utils.data.DataLoader(train_datasets,batch_sampler=train_batch_sampler, pin_memory=True, num_workers=nw)
val_dataloader = torch.utils.data.DataLoader(val_datasets,batch_size=batch_size, sampler=val_sampler, pin_memory=True, num_workers=nw)

 2.2.5 加载模型到所有GPUs上

在训练时,因为我们用到了DistributedSampler,所以需要每一个epoch都将原数据打乱一下,其他剩下的过程和单卡相同

model = UNet().cuda()
model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[rank])
...for epoch in range(start_epoch, n_epochs):if is_distributed:train_sampler.set_epoch(epoch)...

2.2.6 启动分布式训练

python -m torch.distributed.launch --nproc_per_node=4 --master_port=2424 --use_env main.py (your_argparse_params)

在pytorch新版中将python -m torch.distributed.launch替换为了torchrun,在训练时我们需要指定通讯端口master_port,也可以让程序自动寻找,即将--master_port=xxxx替换为--rdzv_backend c10d --master_port=0
 

2.3 torch.multiprocessing分部署训练步骤

通过核心函数spawn函数调用GPU并行,函数的参数如下:

torch.multiprocessing.spawn(fn, args=(), nprocs=1, join=True, daemon=False, start_method='spawn')
  • fn:这个就是我们要分布式运行的函数,一般来说是main函数,main(rank, *args),其中rank为必须,单机多卡中可以理解为第几个GPU,args为函数传入的参数,类型tuple,在spawn(…args)的args参数中定义
  • args:传入fn的参数,tuple
  • nprocs:进程数,即几张卡
  • join: 默认为True即可
  • daemon: 默认为False即可
# 调用
mp.spawn(main, args=(opt, ), nprocs=opt.world_size, join=True)

与distributed大同小异,完整的训练代码如下:

# 单机多卡并行计算示例
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "6, 7"import torch
import torch.distributed as dist
import torch.multiprocessing as mp
import torch.nn as nn
import torch.optim as optim
from torch.nn.parallel import DistributedDataParallel as DDPdef example(rank, world_size):# create default process groupdist.init_process_group("gloo", init_method='tcp://127.0.0.1:6666', rank=rank, world_size=world_size)# create local modelmodel = nn.Linear(10, 10).to(rank)# construct DDP modelddp_model = DDP(model, device_ids=[rank])# define loss function and optimizerloss_fn = nn.MSELoss()optimizer = optim.SGD(ddp_model.parameters(), lr=0.001)# forward passoutputs = ddp_model(torch.randn(20, 10).to(rank))labels = torch.randn(20, 10).to(rank)# backward passloss_fn(outputs, labels).backward()# update parametersoptimizer.step()print("finished rank: {}".format(rank))def main():world_size = torch.cuda.device_count()mp.spawn(example,args=(world_size,),nprocs=world_size,join=True)if __name__=="__main__":main()

2.4 dist.barrier()函数 

单机多卡环境下使用分布式训练具有更快的速度。PyTorch在分布式训练过程中,对于数据的读取是采用主进程预读取并缓存,然后其它进程从缓存中读取,不同进程之间的数据同步具体通过torch.distributed.barrier()实现,示例如下:

if args.local_rank not in [-1, 0]:torch.distributed.barrier()  # Make sure only the first process in distributed training will download model & vocab... (loads the model and the vocabulary)if args.local_rank == 0:torch.distributed.barrier()  # Make sure only the first process in distributed training will download model & vocab

假设我们有4张卡[0, 1, 2, 3],其中[0]卡是first process或者base process,有些操作不需要所有的卡同时进行,比如在预处理的时候只用base process即可。

在上述代码中,第一个if是说除了主卡之外的卡运行到此处会被barrier,也就是说运行到这里就停止了,而base process不会停止,会继续运行,执行预加载模型等操作,当主卡运行到第二个if时,他也会进入到barrier,就是说他已经预加载完了,现在他也需要被barrier了。

此时所有的卡都进入到了barrier,意味着所有的卡可以继续运行(主卡已经加载完了,这个数据所有的卡都可以使用),此后,所有的卡从barrier撤出,开始执行训练。

a process is blocked by a barrier until all processes have encountered a barrier, upon which the barrier is lifted for all processes

3 一个完整的例子

3.1 初始化进程组

import os
from torch import distributedtry:world_size = int(os.environ["WORLD_SIZE"])  # 全局进程个数rank = int(os.environ["RANK"])  # 当前进程编号(全局)local_rank = int(os.environ["LOCAL_RANK"])  # 每台机器上的进程编号(局部)distributed.init_process_group("nccl")  # 初始化进程, 使用nccl后端
except KeyError:world_size = 1rank = 0local_rank = 0distributed.init_process_group(backend="nccl",init_method="tcp://127.0.0.1:12584",rank=rank,world_size=world_size,)

3.2 使用DistributedSampler划分数据集

与nn.DataParrallel不同的是,分布式训练中的batch_size为单卡的输入样本数,因为它代表的是当前rank下对应的partition,总batch_size是这里的batch_size再乘以并行数。举个例子,假设使用8张卡训练模型,nn.DataParrallel中的batch_size为3200,nn.DistributedDataParallel中的batch_size则为400。

from dataloader.distributed_sampler import DistributedSamplertrain_sampler = DistributedSampler(train_set, num_replicas=world_size, rank=rank, shuffle=True, seed=seed)
trainloader = DataLoader(dataset=train_set,pin_memory=true,batch_size=batch_size,num_workers=num_workers,sampler=train_sampler
)  # pin_memory: 是否提前申请CUDA内存. 创建DataLoader时,设置pin_memory=True,则意味着生成的Tensor数据最开始是属于内存中的锁页内存,这样将内存的Tensor转义到GPU的显存就会更快一些.

3.3 使用DistributedDataParallel封装模型

DistributedDataParallel能够为不同GPU上求得的梯度进行all reduce(即汇总不同GPU计算所得的梯度,并同步计算结果)。all reduce后不同GPU中模型的梯度均为all reduce之前各GPU梯度的均值。

backbone = get_model(cfg.network, dropout=0.0, fp16=cfg.fp16, num_features=cfg.embedding_size).cuda()backbone = torch.nn.parallel.DistributedDataParallel(module=backbone, broadcast_buffers=False, device_ids=[local_rank], bucket_cap_mb=16,find_unused_parameters=True)

3.4 训练模型

把输入图片、标签及模型加载到当前进程使用的GPU中,

for epoch in range(start_epoch, cfg.num_epoch):if isinstance(train_loader, DataLoader):# 设置train_loader中的sampler的epoch,DistributedSampler需要这个参数来维持各个进程之间的相同随机数种子train_loader.sampler.set_epoch(epoch)for _, (img, local_labels) in enumerate(train_loader):global_step += 1local_embeddings = backbone(img)loss: torch.Tensor = module_partial_fc(local_embeddings, local_labels, opt)loss.backward()torch.nn.utils.clip_grad_norm_(backbone.parameters(), 5)opt.step()opt.zero_grad()lr_scheduler.step()

3.5 计算损失

distributed.all_gather(tensor_list,input_tensor):从所有设备收集指定的input_tensor并将其放置在所有设备上的tensor_list变量中,

from torch import distributeddistributed.all_gather(_gather_embeddings, local_embeddings)
distributed.all_gather(_gather_labels, local_labels)distributed.all_reduce(loss, distributed.ReduceOp.SUM)

3.6 保存模型

    if rank == 0:path_module = os.path.join(cfg.output, "model_final.pt")torch.save(backbone.module.state_dict(), path_module)

3.7 启动并行程序

(1) 使用torch.distributed.launch

该指令会使脚本并行地运行n次(n为使用的GPU个数),

python -m torch.distributed.launch --nproc_per_node=8 train.py configs/ms1mv3_r50

(2) 使用torch.multiprocessing

torch.multiprocessing会自动创建进程,绕开torch.distributed.launch开启和退出进程的一些小毛病,

    def main(rank):passtorch.multiprocessing.spawn(main, nprocs, args)

 3.8 完整代码

import argparse
import logging
import os
from datetime import datetimeimport numpy as np
import torch
from backbones import get_model
from dataset import get_dataloader
from losses import CombinedMarginLoss
from lr_scheduler import PolyScheduler
from partial_fc import PartialFC, PartialFCAdamW
from torch import distributed
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from utils.utils_callbacks import CallBackLogging, CallBackVerification
from utils.utils_config import get_config
from utils.utils_distributed_sampler import setup_seed
from utils.utils_logging import AverageMeter, init_loggingassert torch.__version__ >= "1.12.0", "In order to enjoy the features of the new torch, \
we have upgraded the torch to 1.12.0. torch before than 1.12.0 may not work in the future."try:rank = int(os.environ["RANK"])local_rank = int(os.environ["LOCAL_RANK"])world_size = int(os.environ["WORLD_SIZE"])distributed.init_process_group("nccl")
except KeyError:rank = 0local_rank = 0world_size = 1distributed.init_process_group(backend="nccl",init_method="tcp://127.0.0.1:12584",rank=rank,world_size=world_size,)def main(args):# get configcfg = get_config(args.config)# global control random seedsetup_seed(seed=cfg.seed, cuda_deterministic=False)torch.cuda.set_device(local_rank)os.makedirs(cfg.output, exist_ok=True)init_logging(rank, cfg.output)summary_writer = (SummaryWriter(log_dir=os.path.join(cfg.output, "tensorboard"))if rank == 0else None)wandb_logger = Noneif cfg.using_wandb:import wandb# Sign in to wandbtry:wandb.login(key=cfg.wandb_key)except Exception as e:print("WandB Key must be provided in config file (base.py).")print(f"Config Error: {e}")# Initialize wandbrun_name = datetime.now().strftime("%y%m%d_%H%M") + f"_GPU{rank}"run_name = run_name if cfg.suffix_run_name is None else run_name + f"_{cfg.suffix_run_name}"try:wandb_logger = wandb.init(entity = cfg.wandb_entity, project = cfg.wandb_project, sync_tensorboard = True,resume=cfg.wandb_resume,name = run_name, notes = cfg.notes) if rank == 0 or cfg.wandb_log_all else Noneif wandb_logger:wandb_logger.config.update(cfg)except Exception as e:print("WandB Data (Entity and Project name) must be provided in config file (base.py).")print(f"Config Error: {e}")train_loader = get_dataloader(cfg.rec,local_rank,cfg.batch_size,cfg.dali,cfg.seed,cfg.num_workers)backbone = get_model(cfg.network, dropout=0.0, fp16=cfg.fp16, num_features=cfg.embedding_size).cuda()backbone = torch.nn.parallel.DistributedDataParallel(module=backbone, broadcast_buffers=False, device_ids=[local_rank], bucket_cap_mb=16,find_unused_parameters=True)backbone.train()# FIXME using gradient checkpoint if there are some unused parameters will cause errorbackbone._set_static_graph()margin_loss = CombinedMarginLoss(64,cfg.margin_list[0],cfg.margin_list[1],cfg.margin_list[2],cfg.interclass_filtering_threshold)if cfg.optimizer == "sgd":module_partial_fc = PartialFC(margin_loss, cfg.embedding_size, cfg.num_classes,cfg.sample_rate, cfg.fp16)module_partial_fc.train().cuda()# TODO the params of partial fc must be last in the params listopt = torch.optim.SGD(params=[{"params": backbone.parameters()}, {"params": module_partial_fc.parameters()}],lr=cfg.lr, momentum=0.9, weight_decay=cfg.weight_decay)elif cfg.optimizer == "adamw":module_partial_fc = PartialFCAdamW(margin_loss, cfg.embedding_size, cfg.num_classes,cfg.sample_rate, cfg.fp16)module_partial_fc.train().cuda()opt = torch.optim.AdamW(params=[{"params": backbone.parameters()}, {"params": module_partial_fc.parameters()}],lr=cfg.lr, weight_decay=cfg.weight_decay)else:raisecfg.total_batch_size = cfg.batch_size * world_sizecfg.warmup_step = cfg.num_image // cfg.total_batch_size * cfg.warmup_epochcfg.total_step = cfg.num_image // cfg.total_batch_size * cfg.num_epochlr_scheduler = PolyScheduler(optimizer=opt,base_lr=cfg.lr,max_steps=cfg.total_step,warmup_steps=cfg.warmup_step,last_epoch=-1)start_epoch = 0global_step = 0if cfg.resume:dict_checkpoint = torch.load(os.path.join(cfg.output, f"checkpoint_gpu_{rank}.pt"))start_epoch = dict_checkpoint["epoch"]global_step = dict_checkpoint["global_step"]backbone.module.load_state_dict(dict_checkpoint["state_dict_backbone"])module_partial_fc.load_state_dict(dict_checkpoint["state_dict_softmax_fc"])opt.load_state_dict(dict_checkpoint["state_optimizer"])lr_scheduler.load_state_dict(dict_checkpoint["state_lr_scheduler"])del dict_checkpointfor key, value in cfg.items():num_space = 25 - len(key)logging.info(": " + key + " " * num_space + str(value))callback_verification = CallBackVerification(val_targets=cfg.val_targets, rec_prefix=cfg.rec, summary_writer=summary_writer, wandb_logger = wandb_logger)callback_logging = CallBackLogging(frequent=cfg.frequent,total_step=cfg.total_step,batch_size=cfg.batch_size,start_step = global_step,writer=summary_writer)loss_am = AverageMeter()amp = torch.cuda.amp.grad_scaler.GradScaler(growth_interval=100)for epoch in range(start_epoch, cfg.num_epoch):if isinstance(train_loader, DataLoader):train_loader.sampler.set_epoch(epoch)for _, (img, local_labels) in enumerate(train_loader):global_step += 1local_embeddings = backbone(img)loss: torch.Tensor = module_partial_fc(local_embeddings, local_labels, opt)if cfg.fp16:amp.scale(loss).backward()amp.unscale_(opt)torch.nn.utils.clip_grad_norm_(backbone.parameters(), 5)amp.step(opt)amp.update()else:loss.backward()torch.nn.utils.clip_grad_norm_(backbone.parameters(), 5)opt.step()opt.zero_grad()lr_scheduler.step()with torch.no_grad():if wandb_logger:wandb_logger.log({'Loss/Step Loss': loss.item(),'Loss/Train Loss': loss_am.avg,'Process/Step': global_step,'Process/Epoch': epoch})loss_am.update(loss.item(), 1)callback_logging(global_step, loss_am, epoch, cfg.fp16, lr_scheduler.get_last_lr()[0], amp)if global_step % cfg.verbose == 0 and global_step > 0:callback_verification(global_step, backbone)if cfg.save_all_states:checkpoint = {"epoch": epoch + 1,"global_step": global_step,"state_dict_backbone": backbone.module.state_dict(),"state_dict_softmax_fc": module_partial_fc.state_dict(),"state_optimizer": opt.state_dict(),"state_lr_scheduler": lr_scheduler.state_dict()}torch.save(checkpoint, os.path.join(cfg.output, f"checkpoint_gpu_{rank}.pt"))if rank == 0:path_module = os.path.join(cfg.output, "model.pt")torch.save(backbone.module.state_dict(), path_module)if wandb_logger and cfg.save_artifacts:artifact_name = f"{run_name}_E{epoch}"model = wandb.Artifact(artifact_name, type='model')model.add_file(path_module)wandb_logger.log_artifact(model)if cfg.dali:train_loader.reset()if rank == 0:path_module = os.path.join(cfg.output, "model.pt")torch.save(backbone.module.state_dict(), path_module)from torch2onnx import convert_onnxconvert_onnx(backbone.module.cpu().eval(), path_module, os.path.join(cfg.output, "model.onnx"))if wandb_logger and cfg.save_artifacts:artifact_name = f"{run_name}_Final"model = wandb.Artifact(artifact_name, type='model')model.add_file(path_module)wandb_logger.log_artifact(model)distributed.destroy_process_group()if __name__ == "__main__":torch.backends.cudnn.benchmark = Trueparser = argparse.ArgumentParser(description="Distributed Arcface Training in Pytorch")parser.add_argument("config", type=str, help="py config file")main(parser.parse_args())

4 分布式训练可能遇到的问题

4.1 runtimeerror: address already in use

这种情况是端口被占用了,可能是由于你上次调试之后端口依旧占用的缘故,假设88889端口被占用了,用以下命令查询其PID,然后杀掉即可。第二种方法是将当前终端关闭,重新开一个他会自动解除占用

4.2 调试时可能会出现的问题

  • 显存未释放:nvidia-smi看一下显存是否释放,如果没有释放使用kill -9 PID命令进行释放。如果kill也无法释放显存,直接将terminal关闭重新开一个即可
  • 端口被占用:如果第一次调试后进行第二次调试时提示xx端口被占用了,这里最快的解决方法时将当前terminal关闭,然后重新开一个即可,或者参考第一个问题,kill掉相应的PID

 

 

 

 

 

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/146413.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

[开源]基于 AI 大语言模型 API 实现的 AI 助手全套开源解决方案

原文:[开源]基于 AI 大语言模型 API 实现的 AI 助手全套开源解决方案 一飞开源,介绍创意、新奇、有趣、实用的开源应用、系统、软件、硬件及技术,一个探索、发现、分享、使用与互动交流的开源技术社区平台。致力于打造活力开源社区&#xff0…

pytorch文本分类(一):文本预处理

pytorch文本分类(一):文本预处理 本文为自己在鲸训练营答题总结,作业练习都在和鲸社区数据分析协作平台 ModelWhale 上。 🚩学习任务原链接在这里 相关数据链接:https://pan.baidu.com/s/1iwE3LdRv3uAkGGI…

基础课6——开放领域对话系统架构

开放领域对话系统是指针对非特定领域或行业的对话系统,它可以与用户进行自由的对话,不受特定领域或行业的知识和规则的限制。开放领域对话系统需要具备更广泛的语言理解和生成能力,以便与用户进行自然、流畅的对话。 与垂直领域对话系统相比…

2024年山东省职业院校技能大赛中职组 “网络安全”赛项竞赛试题-C卷

2024年山东省职业院校技能大赛中职组 “网络安全”赛项竞赛试题-C卷 2024年山东省职业院校技能大赛中职组 “网络安全”赛项竞赛试题-C卷A模块基础设施设置/安全加固(200分)A-1:登录安全加固(Windows, Linux)A-2&#…

Flutter笔记:桌面端应用多窗口管理方案

Flutter笔记 桌面端应用多窗口管理方案 作者:李俊才 (jcLee95):https://blog.csdn.net/qq_28550263 邮箱 :291148484163.com 本文地址:https://blog.csdn.net/qq_28550263/article/details/134468587 【简介…

Windows11怎样投屏到电视上?

电视屏幕通常比电脑显示器更大,能够提供更逼真的图像和更震撼的音效,因此不少人也喜欢将电脑屏幕投屏到电视上,缓解一下低头看电脑屏幕的烦恼。 Windows11如何将屏幕投射到安卓电视? 你需要在电脑和电视分贝安装AirDroid Cast的电…

【MySQL】数据类型

数据类型 前言正式开始数值类型整数类型bit类型浮点数类型floatdecimal 字符串类型charvarcharchar和varchar比较 日期和时间类型enum和setenum和set类型的查找 前言 我在前一篇讲表的操作的时候碰到了一些数据类型,但是没有正式讲这些类型,本篇就重点讲…

根据店铺ID/店铺链接/店铺昵称获取京东店铺所有商品数据接口|京东店铺所有商品数据接口|京东API接口

要获取京东店铺的所有商品数据,您需要使用京东开放平台提供的API接口。以下是一些可能有用的API接口: 商品SKU列表接口:该接口可以获取指定店铺下的所有商品SKU列表,包括商品ID、名称、价格等信息。您可以使用该接口来获取店铺中…

一文看分布式锁

为什么会存在分布式锁? 经典场景-扣库存,多人去同时购买一件商品,首先会查询判断是否有剩余,如果有进行购买并扣减库存,没有提示库存不足。假如现在仅存有一件商品,3人同时购买,三个线程同时执…

Go 语言数组基础教程 - 数组的声明、初始化和使用方法

数组用于在单个变量中存储相同类型的多个值,而不是为每个值声明单独的变量。 声明数组 在Go中,有两种声明数组的方式: 使用var关键字: 语法 var array_name [length]datatype{values} // 这里定义了长度 或者 var array_n…

vivado产生报告阅读分析6-时序报告2

1、复查时序路径详情 单击“ OK ”运行报告命令后 , 将打开一个新窗口。这样您即可复查其中内容。在其中可查看执行选定的每种类型 (min/max/min_max ) 的分析之后所报告的 N 条最差路径。 下图显示的“Report Timing ” ( 时序报告 ) 窗口…

竞赛选题 深度学习驾驶行为状态检测系统(疲劳 抽烟 喝水 玩手机) - opencv python

文章目录 1 前言1 课题背景2 相关技术2.1 Dlib人脸识别库2.2 疲劳检测算法2.3 YOLOV5算法 3 效果展示3.1 眨眼3.2 打哈欠3.3 使用手机检测3.4 抽烟检测3.5 喝水检测 4 最后 1 前言 🔥 优质竞赛项目系列,今天要分享的是 🚩 基于深度学习的驾…

初学编程学习,计算机编程怎么自学,中文编程工具下载

初学编程学习,计算机编程怎么自学,中文编程工具下载 给大家分享一款中文编程工具,零基础轻松学编程,不需英语基础,编程工具可下载。 这款工具不但可以连接部分硬件,而且可以开发大型的软件,象如…

RT-Thread STM32F407 PWM

为了展示PWM效果,这里用ADC来采集PWM输出通道的电平变化 第一步,进入RT-Thread Settings配置PWM驱动 第二步,进入board.h,打开PWM宏 第三步,进入STM32CubeMX,配置时钟及PWM 第四步,回到R…

一起学docker系列之五docker的常用命令--操作容器的命令

目录 前言1 启动容器2 查看容器3 退出容器4 启动已经停止的容器5 重启容器6 停止容器7 删除已经停止的容器8 启动容器说明和举例9 查看容器日志10 查看容器内运行的进程11 查看容器内部细节12 进入正在运行的容器并进行交互13 导入和导出容器结语 前言 当涉及到容器化技术&…

Python | 机器学习之SVM支持向量机

​🌈个人主页:Sarapines Programmer🔥 系列专栏:《人工智能奇遇记》🔖少年有梦不应止于心动,更要付诸行动。 目录结构 1. 机器学习之SVM支持向量机概念 1.1 机器学习 1.2 SVM支持向量机 2. SVM支持向量机…

合并word中参考文献-(Endnote生成)

合并word中的 两部分的参考文献引用 Merge Citations in the Word document Original: A is a big character [78-80] and B is another one [81-85] Modified: A and B are big characters [78-85] Solutions: Remove the space betwee…

AWD比赛中的一些防护思路技巧

## 思路1: 1、改服务器密码 (1)linux:passwd (2)如果是root删除可登录用户:cat /etc/passwd | grep bash userdel -r 用户名 (3)mysql:update mysql.user set…

ROS服务(Service)通信:通信模型、Hello World与拓展

服务通讯是基于请求响应模式的,是一种应答机制。 用于偶然的、对时时性有要求、有一定逻辑处理需求的数据传输场景。 一、服务通讯模型 服务是一种双向通讯方式,它通过请求和应答的方式传递消息,该模型涉及到三个角色: Master…

vscode中Chinese (Simplified)汉化无效解决方法

问题复现 之前已经下载了 Chinese (Simplified)插件并启用了,都是正常的中文简体。有时候打开vscode的时候,会发现汉化失效了,如图: 解决方法 依次点击 扩展(Extensions)— Chinese (Simplified) — 选…