从零构建属于自己的GPT系列3：模型训练2（训练函数解读、模型训练函数解读、代码逐行解读）

机器学习杨卓越

已于 2023-12-12 21:02:16 修改

阅读量1.2k

点赞数 9

分类专栏： Hugging Face实战构建自己的GPT 文章标签： gpt pytorch 语言模型 nlp chatgpt 深度学习 Hugging Face

于 2023-12-03 20:51:57 首次发布

本文链接：https://blog.csdn.net/weixin_50592077/article/details/134770192

版权

Hugging Face实战同时被 2 个专栏收录

22 篇文章 19 订阅

订阅专栏

构建自己的GPT

6 篇文章 1 订阅

订阅专栏

🚩🚩🚩Hugging Face 实战系列总目录

有任何问题欢迎在下面留言
本篇文章的代码运行界面均在PyCharm中进行
本篇文章配套的代码资源已经上传

从零构建属于自己的GPT系列1：数据预处理
 从零构建属于自己的GPT系列2：模型训练1
从零构建属于自己的GPT系列3：模型训练2
从零构建属于自己的GPT系列4：模型训练3
从零构建属于自己的GPT系列5：模型部署1
从零构建属于自己的GPT系列6：模型部署2

3 数据加载函数

def load_dataset(logger, args):
    logger.info("loading training dataset")
    train_path = args.train_path
    with open(train_path, "rb") as f:
        train_list = pickle.load(f)
    train_dataset = CPMDataset(train_list, args.max_len)
    return train_dataset

日志报告加载训练数据
训练数据路径
将以二进制形式存储的数据文件
使用 pickle 加载到内存中的 train_list 变量中
加载CPMDataset包，将train_list从索引转化为torch tensor
返回tensor

4 训练函数

def train(model, logger, train_dataset, args):
    train_dataloader = DataLoader(
        train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers, collate_fn=collate_fn,
        drop_last=True
    )
    logger.info("total_steps:{}".format(len(train_dataloader)* args.epochs))
    t_total = len(train_dataloader) // args.gradient_accumulation_steps * args.epochs
    optimizer = transformers.AdamW(model.parameters(), lr=args.lr, eps=args.eps)
    scheduler = transformers.get_linear_schedule_with_warmup(
        optimizer, num_warmup_steps=args.warmup_steps, num_training_steps=t_total
    )# 设置warmup
    logger.info('start training')
    train_losses = []   # 记录每个epoch的平均loss
    for epoch in range(args.epochs):
        train_loss = train_epoch(
            model=model, train_dataloader=train_dataloader,
            optimizer=optimizer, scheduler=scheduler,
            logger=logger, epoch=epoch, args=args)
        train_losses.append(round(train_loss, 4))
        logger.info("train loss list:{}".format(train_losses))

    logger.info('training finished')
    logger.info("train_losses:{}".format(train_losses))

训练函数
制作Dataloader
制作Dataloader
制作Dataloader
制作Dataloader
日志添加信息Dataloader*epochs的数量
记录数据长度到t_total变量中
指定优化器
学习率衰减策略，从transformers包中调用现成的get_linear_schedule_with_warmup方法
设置warmup等参数
学习率衰减策略
日志添加信息开始训练
记录所有epoch的训练损失，以求每个epoch的平均loss
遍历每个epoch
指定一个我们自己写的train_epoch函数1
train_epoch函数2
train_epoch函数3
train_epoch函数4
记录损失，只保存4位小数
记录日志信息训练损失
记录日志信息训练完成
最后一句是在日志中保存所有损失吗？

5 迭代训练函数train_epoch

def train_epoch(model, train_dataloader, optimizer, scheduler, logger, epoch, args):
    model.train()
    device = args.device
    ignore_index = args.ignore_index
    epoch_start_time = datetime.now()
    total_loss = 0  # 记录下整个epoch的loss的总和
    epoch_correct_num = 0   # 每个epoch中,预测正确的word的数量
    epoch_total_num = 0  # 每个epoch中,预测的word的总数量
    for batch_idx, (input_ids, labels) in enumerate(train_dataloader):
        try:
            input_ids = input_ids.to(device)
            labels = labels.to(device)
            outputs = model.forward(input_ids, labels=labels)
            logits = outputs.logits
            loss = outputs.loss
            loss = loss.mean()
            batch_correct_num, batch_total_num = calculate_acc(logits, labels, ignore_index=ignore_index)
            epoch_correct_num += batch_correct_num
            epoch_total_num += batch_total_num
            batch_acc = batch_correct_num / batch_total_num
            total_loss += loss.item()
            if args.gradient_accumulation_steps > 1:
                loss = loss / args.gradient_accumulation_steps
            loss.backward()
            torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_grad_norm)
            if (batch_idx + 1) % args.gradient_accumulation_steps == 0:
                optimizer.step()
                scheduler.step()
                optimizer.zero_grad()
            if (batch_idx + 1) % args.log_step == 0:
                logger.info(
                    "batch {} of epoch {}, loss {}, batch_acc {}, lr {}".format(
                        batch_idx + 1, epoch + 1, loss.item() * args.gradient_accumulation_steps, batch_acc, scheduler.get_lr()))
            del input_ids, outputs
        except RuntimeError as exception:
            if "out of memory" in str(exception):
                logger.info("WARNING: ran out of memory")
                if hasattr(torch.cuda, 'empty_cache'):
                    torch.cuda.empty_cache()
            else:
                logger.info(str(exception))
                raise exception
    epoch_mean_loss = total_loss / len(train_dataloader)
    epoch_mean_acc = epoch_correct_num / epoch_total_num
    logger.info(
        "epoch {}: loss {}, predict_acc {}".format(epoch + 1, epoch_mean_loss, epoch_mean_acc))
    logger.info('saving model for epoch {}'.format(epoch + 1))
    model_path = join(args.save_model_path, 'epoch{}'.format(epoch + 1))
    if not os.path.exists(model_path):
        os.mkdir(model_path)
    model_to_save = model.module if hasattr(model, 'module') else model
    model_to_save.save_pretrained(model_path)
    logger.info('epoch {} finished'.format(epoch + 1))
    epoch_finish_time = datetime.now()
    logger.info('time for one epoch: {}'.format(epoch_finish_time - epoch_start_time))

    return epoch_mean_loss

train_epoch函数
指定训练模式
训练设备
需要忽略的索引
当前epoch开启的具体时间
当前epoch的loss总和
当前epoch预测词正确的总数量
每个epoch需要预测的测的总数量
for训练从train_dataloader遍历取数据
捕捉异常
输入词的索引数据进入训练设备
标签数据进入训练设备
输入数据经过前向传播得到输出
经过softmax后的输出
得到损失
平均损失
通过calculate_acc函数统计该batch的预测token的正确数与总数
统计该epoch的预测token的正确数
统计该epoch的预测token的总数
计算该batch的accuracy
获得损失值的标量累加到当前epoch总损失
如果当前的梯度累加步数大于1
对当前累加的损失对梯度累加步数求平均
损失反向传播
梯度裁剪：梯度裁剪的目的是控制梯度的大小，防止梯度爆炸的问题。在训练神经网络时，梯度可能会变得非常大，导致优化算法出现数值不稳定的情况。裁剪梯度就是将梯度的整体范数限制在一个特定的阈值之内
达到梯度累加的次数后
更新参数，达到6次batch才会更新一次参数
更新学习率
梯度清零
梯度累加次数为0时，也就是参数更新时
记录日志
记录的各个参数占位符
占位符对应的各个变量
删除两个变量，释放内存
捕捉到异常
如果异常的信息中的字符串包含内存不足的问题，也就是显卡内存不足
将该问题添加到日志信息
当显卡内存占用过多时
手动释放显卡内存
如果不是显卡内存不足
记录日志
返回异常
记录当前epoch的平均loss
记录当前epoch的平均accuracy
日志记录信息
记录的信息为当前epoch索引、损失、准确率
日志记录信息，当前保存的模型以及对于的epoch索引
保存模型的地址
如果地址不存在
创建该地址
确保得到不是外壳对象
保存模型
日志记录信息训练完成
记录完成时间
记录当前epoch训练所花费时间
返回epoch平均损失