accelerate 分布式训练

AI Echoes

于 2025-05-12 11:33:18 发布

阅读量619

点赞数 7

文章标签：分布式

本文链接：https://blog.csdn.net/hh051020/article/details/147892985

版权

一、为什么需要 accelerate 分布式训练？

PyTorch Accelerate 是一个 PyTorch 的加速工具包，旨在简化 PyTorch 训练和推断的开发过程，并提高性能。它是由 Hugging Face、NVIDIA、AWS 和 Microsoft 等公司联合开发的，是一个开源项目。

二、什么是 accelerate 分布式训练?

accelerate分布式训练介绍
PyTorch Accelerate 提供了一组简单易用的 API，帮助开发者实现模型的分布式训练、混合精度训练、自动调
参、数据加载优化和模型优化等功能。它还集成了 PyTorch Lightning 和 TorchElastic，使用户能够轻松地实现高性能和高可扩展性的模型训练和推断。
accelerate分布式训练主要优势

PyTorch Accelerate 的主要优势包括：

分布式训练：可以在多个 GPU 或多台机器上并行训练模型，从而缩短训练时间和提高模型性能；
混合精度训练：可以使用半精度浮点数加速模型训练，从而减少 GPU 内存使用和提高训练速度；
自动调参：可以使用 PyTorch Lightning Trainer 来自动调整超参数，从而提高模型性能；
数据加载优化：可以使用 DataLoader 和 DataLoaderTransforms 来优化数据加载速度，从而减少训练时间；
模型优化：可以使用 Apex 或 TorchScript 等工具来优化模型性能。

三、accelerate 分布式训练原理讲解？

分布式训练
分布式训练是指将一个大型深度学习模型拆分成多个小模型，在不同的计算机上并行训练，最后将结果合并，得到最终的模型。分布式训练可以显著减少模型训练的时间，因为它充分利用了多个计算机的计算资源。同时，由于每个小模型只需要处理部分数据，因此可以使用更大的批次大小，进一步提高训练速度。
加速策略
Accelerate提供了多种加速策略，如pipeline并行、数据并行等。
1. Pipeline并行 Pipeline 并行
  Pipeline并行是指将模型拆分成多个部分，在不同的计算机上并行训练。在每个计算机上，只需要处理模型的一部分，然后将结果传递给下一个计算机。这样可以充分利用多个计算机的计算资源，并且可以使用更大的批次大小，提高训练速度。Pipeline并行的缺点是，由于每个计算机只处理部分数据，因此每个计算机的结果都会有一些误差，最终的结果可能会有一些偏差。
2. 数据并行
  数据并行是指将数据拆分成多个部分，在不同的计算机上并行训练。在每个计算机上，都会处理全部的模型，但是每个计算机只处理部分数据。这样可以充分利用多个计算机的计算资源，并且可以使用更大的批次大小，提高训练速度。数据并行的优点是，每个计算机都会处理全部的模型，因此结果更加准确。缺点是，由于每个计算机都需要完整的模型，因此需要更多的计算资源。
3. 加速器

加速器是指用于加速深度学习模型训练的硬件设备，如GPU、TPU等。加速器可以大幅提高模型的训练速度，因为它们可以在更短的时间内完成更多的计算。Accelerate可以自动检测并利用可用的加速器，以进一步提高训练速度。

四、accelerate 分布式训练如何实践？

accelerate分布式训练依赖安装
$ pip install accelerate==0.17.1
$ pip install accelere==0.17.1
accelerate分布式训练代码实现逻辑
...
from accelerate import Accelerator
从加速导入加速器
...
导包
Trainer 训练类编写
class Trainer:  班级培训师：
def init (self,  定义 init（自身，
args,  参数，
config,  配置，
model_engine,  模型引擎，
criterion,  标准，
optimizer,  优化器，
accelerator):  加速器）：
...
self.accelerator = accelerator
self.accelerator = 加速器
...
def train(self, train_loader, dev_loader=None):
def train（self，train_loader，dev_loader = None）：
...
for epoch in range(1, self.args.epochs + 1):
对于范围内的纪元（1，self.args.epochs + 1）：
for step, batch_data in enumerate(train_loader):
对于步骤，枚举中的 batch_data（train_loader）：
self.model_engine.train()
自我.模型引擎.训练（）
logits, label = self.on_step(batch_data)
logits，标签= self.on_step（batch_data）
loss = self.criterion(logits, label)
损失 = 自我标准（logits，标签）
self.accelerator.backward(loss)
自我加速器向后（损失）
self.optimizer.step()  自我优化器步骤（）
self.optimizer.zero_grad()
自我优化器.零梯度（）
...
main() 函数编写
accelerate分布式训练示例代码

""" “””

random.seed(seed) 随机种子（种子）

torch.manual_seed(seed) torch.manual_seed（种子）

np.random.seed(seed) np.random.seed（种子）

torch.cuda.manual_seed_all(seed)
torch.cuda.manual_seed_all（种子）

def get_data(): 定义获取数据（）：

with open("data/train.json", "r", encoding="utf-8") as fp:
使用打开（“data/train.json”，“r”，编码=“utf-8”）作为 fp：

data = fp.read() 数据 = fp.read()

data = json.loads(data) 数据 = json.loads(数据)

return data 返回数据

def load_data(): 定义加载数据（）：

data = get_data() 数据=获取数据（）

return_data = [] 返回数据 = []

# [(文本，标签id)]

for d in data:
对于数据中的 d：

text = d[0] 文本 = d[0]

label = d[1] 标签 = d[1]

return_data.append(("".join(text.split(" ")).strip(), label))

return return_data 返回 return_data

class Collate: 分类整理：

def init (self, 定义 init（自身，

tokenizer, 标记器，

max_seq_len, 最大序列长度，

self.tokenizer = tokenizer

self.max_seq_len = max_seq_len

def collate_fn(self, batch):
def collate_fn（自身，批次）：

input_ids_all = [] 输入 ID 全部=[]

token_type_ids_all = []

attention_mask_all = []

label_all = [] 标签全部 = []

for data in batch:
对于批量数据：

text = data[0]
文本 = 数据[0]

label = data[1] 标签 = 数据[1]

inputs = self.tokenizer.encode_plus(text=text,
输入= self.tokenizer.encode_plus（文本=文本，

max_length=self.max_seq_len,
最大长度=自身.最大序列长度，

padding="max_length",

truncation="longest_first",
截断="最长优先",

return_attention_mask=True,
return_attention_mask=真，

return_token_type_ids=True)

input_ids = inputs["input_ids"]
输入 ID = 输入[“输入 ID”]

token_type_ids = inputs["token_type_ids"]
token_type_ids = 输入[“token_type_ids”]

attention_mask = inputs["attention_mask"]
attention_mask = 输入[“attention_mask”]

input_ids_all.append(input_ids)
input_ids_all.append(输入 ids)

token_type_ids_all.append(token_type_ids)
token_type_ids_all.append（token_type_ids）

attention_mask_all.append(attention_mask)

label_all.append(label) label_all.append(标签)

input_ids_all = torch.tensor(input_ids_all, dtype=torch.long)
input_ids_all = torch.tensor(input_ids_all，dtype=torch.long)

token_type_ids_all = torch.tensor(token_type_ids_all, dtype=torch.long)
token_type_ids_all = torch.tensor(token_type_ids_all，dtype=torch.long)

attention_mask_all = torch.tensor(attention_mask_all, dtype=torch.long)
attention_mask_all = torch.tensor(attention_mask_all，dtype=torch.long)

label_all = torch.tensor(label_all, dtype=torch.long)
label_all = torch.tensor(label_all，dtype=torch.long)

return_data = { 返回数据 = {

"input_ids": input_ids_all,
"input_ids": 所有输入 ID，

"attention_mask": attention_mask_all,

"token_type_ids": token_type_ids_all,

"label": label_all “标签”：label_all

}

return return_data 返回 return_data

class Trainer: 班级培训师：

def init (self, 定义 init（自身，

args, 参数，

config, 配置，

model_engine, 模型引擎，

criterion, 标准，

optimizer, 优化器，

accelerator): 加速器）：

self.args = args

self.config = config self.config = 配置

self.model_engine = model_engine

self.criterion = criterion
self.criterion = 标准

self.optimizer = optimizer
self.optimizer = 优化器

self.accelerator = accelerator
self.accelerator = 加速器

def on_step(self, batch_data):
def on_step（self，batch_data）：

label = batch_data["label"].cuda()
标签=batch_data[“标签”].cuda()

input_ids = batch_data["input_ids"].cuda()
输入 ID = 批次数据[“输入 ID”].cuda()

token_type_ids = batch_data["token_type_ids"].cuda()

attention_mask = batch_data["attention_mask"].cuda()

output = self.model_engine.forward(input_ids=input_ids,
输出 = self.model_engine.forward（input_ids = input_ids，

token_type_ids=token_type_ids,
token_type_ids=token_type_ids，

attention_mask=attention_mask,
attention_mask=注意掩码，

labels=label) 标签=标签)

logits = output[1] logits = 输出[1]

return logits, label
返回物流，标签

def loss_reduce(self, loss):
def loss_reduce（自身，损失）：

rt = loss.clone() rt = 损失.克隆()

dist.all_reduce(rt, op=dist.ReduceOp.SUM)
dist.all_reduce（rt，op = dist.ReduceOp.SUM）

rt /= torch.cuda.device_count()

return rt 返回 rt

def output_reduce(self, outputs, targets):
def output_reduce（自身，输出，目标）：

output_gather_list = [torch.zeros_like(outputs) for _ in range(torch.cuda.device_count())]

# 把每一个GPU的输出聚合起来

dist.all_gather(output_gather_list, outputs)
dist.all_gather（输出聚集列表，输出）

outputs = torch.cat(output_gather_list, dim=0)
输出=torch.cat（output_gather_list，dim=0）

target_gather_list = [torch.zeros_like(targets) for _ in range(torch.cuda.device_count())]

# 把每一个GPU的输出聚合起来

dist.all_gather(target_gather_list, targets)
dist.all_gather（target_gather_list，目标）

targets = torch.cat(target_gather_list, dim=0)
目标= torch.cat（target_gather_list，dim=0）

return outputs, targets 返回输出、目标

def train(self, train_loader, dev_loader=None):
def train（self，train_loader，dev_loader = None）：

gloabl_step = 1 全局步长 = 1

best_acc = 0.
最佳累积误差 = 0。

if self.args.local_rank == 0:
如果 self.args.local_rank == 0:

start = time.time() 开始 = 时间.时间()

for epoch in range(1, self.args.epochs + 1):
对于范围内的纪元（1，self.args.epochs + 1）：

for step, batch_data in enumerate(train_loader):
对于步骤，枚举中的 batch_data（train_loader）：

self.model_engine.train()
自我.模型引擎.训练（）

logits, label = self.on_step(batch_data)
logits，标签= self.on_step（batch_data）

loss = self.criterion(logits, label)
损失 = 自我标准（logits，标签）

self.accelerator.backward(loss)
自我加速器向后（损失）

self.optimizer.step() 自我优化器步骤（）

self.optimizer.zero_grad()
自我优化器.零梯度（）

loss = self.loss_reduce(loss)
损失 = 自身.loss_reduce(损失)

if self.args.local_rank == 0:
如果 self.args.local_rank == 0:

print("【train】 epoch：{}/{} step：{}/{} loss：{:.6f}".format(
print("【训练】 epoch：{}/{} step：{}/{} loss：{:.6f}".format(

epoch, self.args.epochs, gloabl_step, self.args.total_step, loss
epoch，self.args.epochs，gloabl_step，self.args.total_step，损失

))

gloabl_step += 1 全局步骤 += 1

if self.args.dev: 如果 self.args.dev:

if gloabl_step % self.args.eval_step == 0:
如果 gloabl_step % self.args.eval_step == 0:

loss, accuracy = self.dev(dev_loader)
损失，准确度=self.dev（dev_loader）

if self.args.local_rank == 0:
如果 self.args.local_rank == 0:

print("【dev】 loss：{:.6f} accuracy：
print("【dev】损失：{:.6f} 准确率：

{:.4f}".format(loss, accuracy))
{:.4f}“.格式（损失，准确率））

if accuracy > best_acc:
如果准确度 > 最佳准确度：

best_acc = accuracy best_acc = 准确率

print("【best accuracy】 {:.4f}".format(best_acc))
print("【最佳准确率】 {:.4f}".format(best_acc))

torch.save(self.model_engine.state_dict(), self.args.ckpt_path)
torch.save（self.model_engine.state_dict（），self.args.ckpt_path）

if self.args.local_rank == 0:
如果 self.args.local_rank == 0:

end = time.time() 结束 = 时间.时间()

print("耗时：{}分钟".format((end - start) / 60))

if not self.args.dev and self.args.local_rank == 0:
如果不是 self.args.dev 且 self.args.local_rank == 0:

torch.save(self.model_engine.state_dict(), self.args.ckpt_path)
torch.save（self.model_engine.state_dict（），self.args.ckpt_path）

def dev(self, dev_loader):
def dev（self，dev_loader）：

self.model_engine.eval()
自我.模型引擎.eval()

correct_total = 0 正确总数 = 0

num_total = 0 总数量 = 0

loss_total = 0.
损失总额 = 0。

with torch.no_grad(): 使用 torch.no_grad()：

for step, batch_data in enumerate(dev_loader):
对于步骤，枚举中的 batch_data（dev_loader）：

logits, label = self.on_step(batch_data)
logits，标签= self.on_step（batch_data）

loss = self.criterion(logits, label)
损失 = 自我标准（logits，标签）

loss = self.loss_reduce(loss)
损失 = 自身.loss_reduce(损失)

logits, label = self.output_reduce(logits, label)
logits，标签= self.output_reduce（logits，标签）

loss_total += loss 总损失 += 损失

logits = logits.detach().cpu().numpy()

label = label.view(-1).detach().cpu().numpy()
标签 = 标签.视图（-1）.分离（）.cpu（）.numpy（）

num_total += len(label) num_total += len(标签)

preds = np.argmax(logits, axis=1).flatten()

correct_num = (preds == label).sum()
正确数 = (preds == label).sum()

correct_total += correct_num
正确总数 += 正确数量

return loss_total, correct_total / num_total
返回损失总数，正确总数/总数

def test(self, model_engine, test_loader, labels):
def 测试（self，model_engine，test_loader，labels）：

self.model_engine = model_engine

self.model_engine.eval()
自我.模型引擎.eval()

preds = [] 压力= []

trues = [] 受到威胁 = []

with torch.no_grad(): 使用 torch.no_grad()：

for step, batch_data in enumerate(test_loader):
对于步骤，枚举中的 batch_data（test_loader）：

logits, label = self.on_step(batch_data)
logits，标签= self.on_step（batch_data）

logits, label = self.output_reduce(logits, label)
logits，标签= self.output_reduce（logits，标签）

label = label.view(-1).detach().cpu().numpy().tolist()
标签 = 标签.视图（-1）.分离（）.cpu（）.numpy（）.tolist（）

logits = logits.detach().cpu().numpy()

pred = np.argmax(logits, axis=1).flatten().tolist()

trues.extend(label) trues.extend（标签）

preds.extend(pred) preds.扩展（pred）

# print(trues, preds, labels)
# 打印（真值、预测值、标签）

print(np.array(trues).shape, np.array(preds).shape)
打印（np.array（trues）.shape，np.array（preds）.shape）

report = classification_report(trues, preds, target_names=labels)
报告 = 分类报告（trues、preds、target_names=标签）

return report 退货报告

def build_optimizer(model, args):
def build_optimizer（模型，参数）：

no_decay = ['bias', 'LayerNorm.weight']
no_decay = ['偏差', 'LayerNorm.权重']

optimizer_grouped_parameters = [
优化器分组参数 = [

{'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)],
{'params'：[p 代表 n，p 代表 model.named_parameters() 如果没有 (nd 代表 n 代表 no_decay 中的 nd)]，

'weight_decay': args.weight_decay},
‘weight_decay’：args.weight_decay，

{'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)],
{'params'：[p 代表 n，p 代表 model.named_parameters() 如果有的话（nd 代表 n 代表 no_decay 中的 nd）]，

'weight_decay': 0.0} ‘重量衰减’：0.0

]

# optimizer = AdamW(model.parameters(), lr=learning_rate)
# 优化器 = AdamW(model.parameters(), lr=learning_rate)

optimizer = AdamW(optimizer_grouped_parameters, lr=args.learning_rate)
优化器 = AdamW（优化器分组参数，lr=args.learning_rate）

return optimizer 返回优化器

class Args: 类参数：

model_path = "model_hub/chinese-bert-wwm-ext"

ckpt_path = "output/accelerate/multi-gpu-accelerate-cls.pt"
ckpt_path =“输出/加速/多 GPU 加速 cls.pt”

max_seq_len = 128
最大序列长度 = 128

ratio = 0.92 比率 = 0.92

epochs = 1 时期 = 1

eval_step = 50 评估步骤 = 50

dev = False

local_rank = None local_rank = 无

train_batch_size = 32 训练批次大小 = 32

dev_batch_size = 32

weight_decay = 0.01 权重衰减 = 0.01

learning_rate=3e-5 学习率=3e-5

def main(): 定义主（）：

# =======================================

# 定义相关参数

set_seed() 设置种子（）

label2id = { 标签 2id = {

"其他": 0,

"喜好": 1,

"悲伤": 2,

"厌恶": 3,

"愤怒": 4,

"高兴": 5,

}

args = Args() 参数 = Args()

tokenizer = BertTokenizer.from_pretrained(args.model_path)
标记器 = BertTokenizer.from_pretrained（args.model_path）

# =======================================

# 加载数据集

data = load_data() 数据=加载数据（）

# 取1万条数据出来

data = data[:10000] 日期 = 日期[:10000]

random.shuffle(data) 随机.shuffle（数据）

train_num = int(len(data) * args.ratio)
train_num = int(len(数据) * args.ratio)

train_data = data[:train_num]
训练数据 = 数据[:训练编号]

dev_data = data[train_num:]
dev_data = 数据[train_num:]

collate = Collate(tokenizer, args.max_seq_len)
整理 = 整理 (标记器，args.max_seq_len)

train_loader = DataLoader(train_data,
train_loader = 数据加载器（train_data，

batch_size=args.train_batch_size,
批次大小=args.train_batch_size，

shuffle=True, 随机播放=真，

num_workers=2, 工人数量=2，

collate_fn=collate.collate_fn)
整理函数=整理.整理函数)

total_step = len(train_loader) * args.epochs // torch.cuda.device_count()

args.total_step = total_step

dev_loader = DataLoader(dev_data,
dev_loader = 数据加载器（dev_data，

batch_size=args.dev_batch_size,
批量大小=args.dev_batch_size，

shuffle=False, 随机播放=False，

num_workers=2, 工人数量=2，

collate_fn=collate.collate_fn)
整理函数=整理.整理函数)

test_loader = dev_loader
测试加载器=开发加载器

# =======================================

# 定义模型、优化器、损失函数

config = BertConfig.from_pretrained(args.model_path, num_labels=6)
配置= BertConfig.from_pretrained（args.model_path，num_labels=6）

model = BertForSequenceClassification.from_pretrained(args.model_path, config=config)
模型 = BertForSequenceClassification.from_pretrained（args.model_path，config = config）

model.cuda() 模型.cuda()

criterion = torch.nn.CrossEntropyLoss()
标准 = torch.nn.CrossEntropyLoss()

optimizer = build_optimizer(model, args)
优化器 = build_optimizer（模型，参数）

accelerator = Accelerator()
加速器 = 加速器()

args.local_rank = int(dist.get_rank())

print(args.local_rank) 打印（args.local_rank）

model_engine, optimizer_engine, train_loader_engine, dev_loader_engine = accelerator.prepare(
模型引擎、优化器引擎、训练加载器引擎、开发加载器引擎 = 加速器.准备（

model, optimizer, train_loader, dev_loader
模型、优化器、train_loader、dev_loader

)

# =======================================

# 定义训练器

trainer = Trainer(args, 训练师 = 训练师（参数，

config, 配置，

model_engine, 模型引擎，

criterion, 标准，

optimizer_engine, 优化引擎，

accelerator) 加速器）

# 训练和验证

trainer.train(train_loader_engine, dev_loader_engine)
训练器.训练（train_loader_engine，dev_loader_engine）

# 测试

labels = list(label2id.keys())
标签=列表（label2id.keys（））

config = BertConfig.from_pretrained(args.model_path, num_labels=6)
配置= BertConfig.from_pretrained（args.model_path，num_labels=6）

model = BertForSequenceClassification.from_pretrained(args.model_path, config=config)
模型 = BertForSequenceClassification.from_pretrained（args.model_path，config = config）

model.cuda() 模型.cuda()

# 需要重新初始化引擎

model_engine, optimizer_engine, train_loader_engine, dev_loader_engine = accelerator.prepare(
模型引擎、优化器引擎、训练加载器引擎、开发加载器引擎 = 加速器.准备（

model, optimizer, train_loader, dev_loader
模型、优化器、train_loader、dev_loader

)

model_engine.load_state_dict(torch.load(args.ckpt_path))
model_engine.load_state_dict（torch.load（args.ckpt_path））

report = trainer.test(model_engine, test_loader, labels)
报告=训练器.测试（model_engine，test_loader，标签）

if args.local_rank == 0:
如果 args.local_rank == 0:

print(report) 打印（报告）

# =======================================

if name == ' main ':
如果名称 == 'main'：

main() 主要的（）

4.3 accelerate 分布式训练运行

$ accelerate launch multi-gpu-accelerate-cls.py
$加速启动多 GPU 加速 cls.py
方式一：
方式二：

$ python -m torch.distributed.launch --nproc_per_node 2 --use_env multi-gpu- accelerate-cls.py
$ python -m torch.distributed.launch --nproc_per_node 2 --use_env multi-gpu-accelerate-cls.py

【train】 epoch：1/1 step：1/144 loss：1.795169
【训练】 epoch：1/1 step：1/144 loss：1.795169

【train】 epoch：1/1 step：2/144 loss：1.744665
【训练】 epoch：1/1 step：2/144 loss：1.744665

【train】 epoch：1/1 step：3/144 loss：1.631625
【训练】 epoch：1/1 step：3/144 loss：1.631625

【train】 epoch：1/1 step：4/144 loss：1.543691
【训练】 epoch：1/1 step：4/144 loss：1.543691

【train】 epoch：1/1 step：5/144 loss：1.788955
【训练】 epoch：1/1 step：5/144 loss：1.788955

运行效果

GPU 使用情况