LLM预训练

已于 2023-08-18 10:00:27 修改
阅读量5.5k 收藏 4
点赞数 4
文章标签： pytorch 深度学习 人工智能
于 2023-08-11 15:33:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhouzhou0929/article/details/132226036
版权

网上大量预训练代码都是封装了trainer-deepspeed后的结果，看了也不了解其中所用技术的优化点在哪。本文从最基础的训练过程开始，层层加码并对比。

在这里插入图片描述

基础版本

1.代码
from transformers import AutoModel,AutoTokenizer
from torch.utils.data import Dataset, DataLoader
# 模型加载
model_path = "xxx/glm2" # 你的模型路径
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
model = AutoModel.from_pretrained(model_path, trust_remote_code=True,torch_dtype=torch.float32,device_map="auto")

# 使用一半参数测试
for k,v in model.named_parameters():
    no_grad_layer = list(range(0,27,2))
    no_grad_layer = [str(i) for i in no_grad_layer]
    name_list = k.split(".")
    if len(name_list) >= 4 and name_list[3] in no_grad_layer:
        v.requires_grad=False

# dataset
example = ["text1","text2","text3"]
class GenerateDataset(Dataset):
    def __init__(self, example):
        super(GenerateDataset, self).__init__()
        self.example = example

    def __getitem__(self, item):
        return self.example[item]

    def __len__(self):
        return len(self.example)
ds = GenerateDataset(example)

# dataloader+coll_fn
def pretrain_fn(context):
    input_ids = []
    label_ids = []
    max_len = 2000
    context_ids = tokenizer(context,add_special_tokens=False)["input_ids"]
    target_ids = tokenizer(context,add_special_tokens=False)["input_ids"]
    for c_ids, t_ids in zip(context_ids, target_ids):
        length = len(c_ids)
        if length >= max_len:
            c_ids = c_ids[:max_len - 1] + [2]
            t_ids = t_ids[:max_len - 1] + [2]
        else:
            c_ids = c_ids + [2] * (max_len - length)
            t_ids = t_ids + [-100] * (max_len - length)
        input_ids.append(c_ids)
        label_ids.append(t_ids)
    return {"input_ids":torch.LongTensor(input_ids),"labels":torch.LongTensor(label_ids)}
    
dl = DataLoader(ds, batch_size=1,collate_fn=pretrain_fn)
# 优化器
optimizer = torch.optim.Adam(model.parameters(), lr=1e-5)
# 训练
for batch in tqdm(dl):
    optimizer.zero_grad()
    out=model(input_ids=batch["input_ids"], labels=batch["labels"])
    loss = out.loss
    print(loss)
    loss.backward()
    optimizer.step()
    # print(loss.item)
2.有几个注意事项：

1.torch_dtype=torch.float32，如果用了fp16，模型参数和损失直接变为nan，训练过程出错。用accelerate和trainer会报ValueError: Attempting to unscale FP16 gradients.

  0%|                                                  | 0/1615 [00:00<?, ?it/s]tensor(11.4844, dtype=torch.float16, grad_fn=<ToCopyBackward0>)
  0%|                                        | 1/1615 [00:04<1:54:59,  4.27s/it]tensor(nan, dtype=torch.float16, grad_fn=<ToCopyBackward0>)
  0%|                                          | 2/1615 [00:04<50:53,  1.89s/it]tensor(nan, dtype=torch.float16, grad_fn=<ToCopyBackward0>)

ValueError: Attempting to unscale FP16 gradients.

2.优化器SGD/Adamw,6B模型全参数训练时候，如果用Adamw会爆显存（batch=1,文本长度20），用SGD则不会。实际llm没看到用SGD做优化器，这里只是提一嘴。

Accelerate 版本

# 加载model optimizer dataloader 后，加入以下代码
from accelerate import Accelerator
accelerator = Accelerator(mixed_precision="fp16")
device = accelerator.device
model, optimizer, dl = accelerator.prepare(model, optimizer, dl)
# 原来的loss.backward()替换为accelerator.backward(loss)
# loss.backward()
accelerator.backward(loss)

Trainer 版本

原代码的dataloader optimizer 和训练代码都不用了

train_args = TrainingArguments(save_strategy="epoch",
                               log_level="debug",
                               output_dir="./saved_checkpoint/",
                               per_device_train_batch_size=4,  
                               gradient_accumulation_steps=1,  # 梯度累积步数
                               num_train_epochs=1,
                               learning_rate=1e-5,
                               fp16=True, # 是否使用fp16
                               logging_steps=1,
                               warmup_steps=50,
                               optim="adamw_hf",  # 指定优化器
                               gradient_checkpointing=True, # 梯度检查点
                               )
trainer = Trainer(model=model,train_dataset=ds,args=train_args, data_collator=pretrain_fn)
trainer.train()

需要注意的时：如果gradient_checkpointing=True，则需要加上下面的代码

model.enable_input_require_grads()
# 或者 直接修改模型embedding参数的requires_grad
for k,v in model.named_parameters():
	if k == "transformer.embedding.word_embeddings.weight":
		v.requires_grad = True

Trainer + DeepSpeed

修改train_args, 其他不变

train_args = TrainingArguments(save_strategy="steps",
                               save_steps=40,
                               log_level="debug",
                               output_dir="./test_lora/",
                               per_device_train_batch_size=2,
                               gradient_accumulation_steps=2,
                               num_train_epochs=10,
                               learning_rate=1e-6,
                               fp16=True,
                               logging_steps=1,
                               warmup_steps=10,
                               optim="adamw_hf",
                               gradient_checkpointing=True,
                               deepspeed="./notebooks/deepspeed-stage2.json" # 加入ds路径
                               )

stage-2参数

{
    "fp16": {
        "enabled": "auto",
        "loss_scale": 0,
        "loss_scale_window": 1000,
        "initial_scale_power": 16,
        "hysteresis": 2,
        "min_loss_scale": 1
    },

    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": "auto",
            "betas": "auto",
            "eps": "auto",
            "weight_decay": "auto"
        }
    },

    "scheduler": {
        "type": "WarmupLR",
        "params": {
            "warmup_min_lr": "auto",
            "warmup_max_lr": "auto",
            "warmup_num_steps": "auto"
        }
    },

    "zero_optimization": {
        "stage": 2,
        "offload_optimizer": {
            "device": "cpu",
            "pin_memory": true
        },
        "allgather_partitions": true,
        "allgather_bucket_size": 2e8,
        "overlap_comm": true,
        "reduce_scatter": true,
        "reduce_bucket_size": 2e8,
        "contiguous_gradients": true
    },

    "gradient_accumulation_steps": "auto",
    "gradient_clipping": "auto",
    "steps_per_print": 20,
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
    "wall_clock_breakdown": false
}

stage-3参数

{
    "fp16": {
        "enabled": "auto",
        "loss_scale": 0,
        "loss_scale_window": 1000,
        "initial_scale_power": 16,
        "hysteresis": 2,
        "min_loss_scale": 1
    },

    "optimizer": {
        "type": "AdamW",
        "params": {
            "lr": "auto",
            "betas": "auto",
            "eps": "auto",
            "weight_decay": "auto"
        }
    },

    "scheduler": {
        "type": "WarmupLR",
        "params": {
            "warmup_min_lr": "auto",
            "warmup_max_lr": "auto",
            "warmup_num_steps": "auto"
        }
    },

    "zero_optimization": {
        "stage": 3,
        "offload_optimizer": {
            "device": "cpu",
            "pin_memory": true
        },
        "offload_param": {
            "device": "cpu",
            "pin_memory": true
        },
        "overlap_comm": true,
        "contiguous_gradients": true,
        "sub_group_size": 1e9,
        "reduce_bucket_size": "auto",
        "stage3_prefetch_bucket_size": "auto",
        "stage3_param_persistence_threshold": "auto",
        "stage3_max_live_parameters": 1e9,
        "stage3_max_reuse_distance": 1e9,
        "stage3_gather_16bit_weights_on_model_save": true
    },

    "gradient_accumulation_steps": "auto",
    "gradient_clipping": "auto",
    "steps_per_print": 20,
    "train_batch_size": "auto",
    "train_micro_batch_size_per_gpu": "auto",
    "wall_clock_breakdown": false
}

启动命令

deepspeed pretrain.py --seepspeed ./notebooks/deepspeed-stage2.json

zhouzhou0929
关注
LLM 预训练加速的新方法：8 种模型增长方案总结
强化学习曾小健
07-28 1354
原创 AI闲谈AI闲谈2024年06月29日 20:00北京一、背景LLM 的涌现能力依赖于其模型规模的增长，而 Scaling Law 也在推进 LLM 朝着越来越大的方向发展。然而，LLM 预训练的成本非常高，尤其是其与模型规模、数据量成正比，一个千亿参数量的模型往往需要几千个 GPU训练几个月的时间。加速 LLM 预训练也因此称为一个非常有前景的研究方向。当前常见的优化方案为优化分布式策略，通信，以及训练稳定性等。与此同时，很多时候大家都会训练各种。
大模型学习笔记 - LLM 预训练
m0_37531129的博客
07-21 1378
LLM 模型预训练 LLM 模型预训练 1. 预训练任务 2. 优化参数设置 2.1 基于批次数据的训练 2.2 学习率 2.3 优化器 2.4 稳定优化技术 3. 可扩展的训练技术 3.1 3D并行训练 3.2 零冗余优化器 3.3 激活重计算 3.4 混合精度训练 4. 模型参数量计算与效率分析 4.1 参数量估计 4.2 训练运算量估计 4.3 训练时间估计 4.4 训练显存估计 5. 预训练代码实践 1. 预训练任务 常用的预训练任务主要分为三类：语言建模(Languag
（新手亲测有效）bug解决：ValueError: Attempting to unscale FP16 gradients. 反复出现的问题。
weixin_41784510的博客
01-30 9033
在运用LoRA对ChatGLM-6B（FP16）大语音模型时，遇到了bug1：ValueError: Attempting to unscale FP16 gradients. 和 bug2： AttributeError: 'ChatGLMTokenizer' object has no attribute 'sp_tokenizer'. Did you mean: '_tokenize'? ，经过一波挫折后，终于解决，把解决的途径总结分享给大家。
一文读懂 LLM 训练：从预训练到微调【大模型行业应用入门系列】
kaka0722ww的博客
04-16 6993
LLM Training 是指大型语言模型（LLM）的训练过程。作为一种采用超大规模数据进行预训练的深度学习模型，LLM 训练目标是培养出一个能够理解和生成自然语言文本的模型。在这个过程中，LLM 通过处理海量文本数据来学习语言的规律、语义和上下文关系等训练方式，可以获得丰富的语言知识和智能，从而使得能够自动理解和生成人类语言。通常而言，这种训练过程通常需要大量的计算资源和时间，以便模型能够充分地学习语言的各个方面。
【LLM】预训练||两句话明白儿的底层原理
To be a better man
11-03 630
预测遮挡单词。
LLM——用于微调预训练大型语言模型（LLM）的GPU内存优化与微调
知来者逆的博客
05-06 2661
GPT-4、Bloom 和 LLaMA 等大型语言模型（LLM）通过扩展至数十亿参数，实现了卓越的性能。然而，这些模型因其庞大的内存需求，在部署进行推理或微调时面临挑战。这里将探讨关于内存的优化技术，旨在估计并优化在 LLM 推理以及在多样化硬件配置上进行微调过程中的内存消耗。模型规模：模型拥有的参数数量直接决定了其对内存的需求。参数数量越多，模型文件体积越大，加载和执行模型所需的内存也就越多。输入数据量：处理的输入数据量增加，也会相应增加内存的使用。
从零开始训练大模型
太阳当空照，花儿对我笑，微风轻轻拂，心情无限好。
09-21 5147
我们更倾向于 SFT 的目的只是将 Pretrained Model 中的知识给引导出来的一种手段，而在SFT 数据有限的情况下，我们对模型的「引导能力」就是有限的。这将导致预训练模型中原先「错误」或「有害」的知识没能在 SFT 数据中被纠正，从而出现「有害性」或「幻觉」的问题。为此，一些让模型脱离昂贵标注数据，自我进行迭代的方法被提出，比如：[
LLM预训练和后训练新范式
yXIAOyu_的博客
08-19 1213
大型语言模型（LLM）的发展已经取得了长足的进步，从早期的GPT模型到我们今天拥有的复杂的开放权重LLM。最初，LLM的训练过程仅集中于预训练，但后来扩展到包括预训练和后训练。后训练通常包括监督指令微调和对齐，这些是由ChatGPT普及的。
大语言模型生成式AI学习笔记——1. 2.1LLM预训练和缩放法则——​​​​​​​预训练大语言模型
预见未来to50的专栏
04-23 988
一旦你确定了你的使用案例，并决定如何在你的应用中使用LLM（大语言模型），你的下一步就是选择一个模型来工作。你的首个选择将是使用现有的模型，或者从头开始训练你自己的模型。这种增长是由诸如高度可扩展的转换器架构的引入、用于训练的大量数据的获取以及更强大的计算资源的开发等因素推动的。虽然这听起来很棒，但事实证明，训练这些巨大的模型是困难且非常昂贵的，以至于持续训练越来越大的模型可能是不可行的。现在你已经看到了这些不同模型架构是如何训练的，以及它们非常适合的具体任务，你可以选择最适合你的使用案例的模型类型。
LLM 预训练|SFT监督微调|推理
Maxcu的博客
04-01 2078
LLM预训练阶段、SFT阶段、推理阶段简要辨析
从零详细地梳理一个完整的 LLM 训练流程
人工智能讲师分享前沿技术
06-30 2390
3.指令类型应该是多样化的，包括各种类型的任务，类别种类例如：brainstorming，open QA，closed QA，rewrite，extract，generation，classification，chat，summarization。例如，指令不应该和音频、视频、图片、链接相关，因为GPT模型无法执行这个操作。甲公司是国内一家领先的新媒体、通信及移动增值服务公司，由于遭受世界金融危机，甲公司经济利润严重下滑，经营面临困境，但为了稳定职工队伍，公司并未进行裁员，而是实行高层管理人员减薪措施。
GPU训练模型遇到的报错
Unauthorized_的博客
07-05 666
注意os.environ[“CUDA_VISIBLE_DEVICES”] 要在import torch前面，否则可能无法生效：https://zhuanlan.zhihu.com/p/582993579。1.查看pytorch是否是cpu版本，是的话参考：https://blog.csdn.net/wqufhu/article/details/129295385。
【问题解决与原理解释】Attempting to unscale FP16 gradients.
weixin_44212848的博客
08-18 4008
在使用 accelerate 训练模型时遇到以下报错，其实本质是没有理解训练过程中的各种精度设置的原理，本文将从等基础概念进行解释。
NLP学习与踩坑记录（持续更新版）
博学而笃志，切问而近思。
06-17 925
NLP学习与踩坑记录（持续更新版）
实测：ValueError: FP16 Mixed precision training with AMP or APEX (`--fp16`) and FP16 h alf precision
HJ_blog
11-15 3519
降低transformers版本。经过上面两步后，解决了这个问题。
Pytorch AMP——自动混合精度训练
即事多所欣 的博客
02-08 1354
Pytorch 自动混合精度训练介绍
Pytorch混合精度训练
whaosoft143ai的博客
09-24 4629
FP16(半精度浮点数)表示能够提升拥有TensorCore架构的GPU的计算速度(V100)。有很多相关介绍对其运作原理和使用方法进行了说明，本文就不再赘述。其优点可以概括为2点：1）FP16只占用通常使用的FP32一半的显存。2）NVIDIA V系列GPU在对FP16计算速度比FP32快上许多（实际加速比根据混合精度使用策略的不同存在差异）。
利用Blip2微调图像文本对相似度出现的报错以解决方式
ZLInbao的博客
08-22 720
然后会出现2的错误，把刚刚暴力改成半精度的删除，就可以run了。搜索了半天大家的思路是把fp16改成bp16。把这个5678 换成其他数字 成功！终于解决跑起来blip2模型。然后我在config中修改。挂起来的时候又出现新问题。
ChatGLM-6B论文代码笔记
weixin_46133588的博客
04-12 4538
chatglm-6b
训练SD时更新器出现ValueError: Attempting to unscale FP16 gradients.3
最新发布
03-10
### 解决训练 Stable Diffusion 时遇到的 `ValueError: Attempting to unscale FP16 gradients` 错误 当尝试使用混合精度（FP16）进行训练时，可能会遇到 `ValueError: Attempting to unscale FP16 gradients.` 的错误提示[^1]。此问题通常发生在梯度缩放过程中，特别是在处理半精度浮点数运算时。 为了有效解决这一问题，可以采取以下几种方法： #### 方法一：禁用混合精度训练 如果不需要特别依赖于混合精度带来的性能提升，可以选择完全关闭混合精度模式。通过设置参数 `--mixed_precision="no"` 或者不指定该选项来实现这一点。这会使得整个训练过程仅使用单精度浮点数（FP32），从而避免与 FP16 相关的问题。 ```bash accelerate launch --mixed_precision="no" train_text_to_image_lora.py ... ``` #### 方法二：调整优化器配置 有时可以通过修改优化器的相关配置项来绕过这个问题。具体来说，在初始化 AdamW 等支持 LAMB 类型更新规则的优化器时加入额外参数 `use_fp16=True` 和 `max_grad_norm=None` 可能会有帮助[^2]。 ```python from transformers import get_linear_schedule_with_warmup, Adafactor optimizer = Adafactor( model.parameters(), lr=learning_rate, eps=(1e-30, 1e-3), clip_threshold=1.0, decay_rate=-0.8, beta1=None, weight_decay=0.0, relative_step=False, scale_parameter=False, use_fp16=True, max_grad_norm=None ) ``` #### 方法三：应用 LoRA 技术 Low-Rank Adaptation (LoRA) 是一种有效的迁移学习技术，可以在保持原有模型权重不变的情况下引入少量可训练参数来进行特定任务上的微调。对于某些情况下发生的 FP16 梯度异常情况，采用 LoRA 方案或许能够提供更稳定的解决方案。 ```bash accelerate launch --mixed_precision="fp16" train_text_to_image_lora.py ... --lora_rank=4 --lora_alpha=16 --lora_dropout=0.1 ``` 以上三种方式可以根据实际需求灵活选用或者组合起来试用，以找到最适合当前环境的最佳实践方案。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值