登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 科技 ›大模型预训练

大模型预训练

悯拄等 6 天前
1.分组
  1. '1. 两种训练方法'
  2. 从零开始预训练：BV1xhYtewEum 4分30秒
  3. 二次特定预训练：BV1xhYtewEum
复制代码
2.创建LLM
  1. '1. 创建模型核心流程'
  2. (1)加载模型->(2)将模型放入显卡->(3)输入文本并分词->
  3. (4)将分词放入显卡->(5)设置label->(6)模型输出->
  4. (7)获取模型loss->(8)更新参数->(9)保存模型
复制代码
  1. '2. 创建模型核心代码'
  2. #加载模型
  3. model_path = '/data04/llama3/Meta-Llama-3.1-8B-Instruct'
  4. tokenizer = AutoTokenizer.from_pretrained(model_path)
  6. #将模型放入显卡
  7. model.to("cuda")
  8. optimizer = torch.optim.AdamW(model.parameters())
  10. #输入文本，文本分词
  11. text = "今天天气不错。"
  12. input = tokenizer(text, return_tensors="pt")
  13. input = {k: v.to("cuda") for k, v in input.items()}
  15. #设置labels和inputs一致
  16. input["labels"] = input["input_ids"].clone()
  17. output = model(**input)
  19. #获取模型的loss
  20. loss = output.loss
  21. loss.backward()
  22. optimizer.step()
  23. optimizer.zero_grad()
  25. #保存模型
  26. model.save_pretrained("output_dir")
复制代码
  1. '3. 大模型计算内部Loss'
  2. step1. LLM获取“今天”，输出概率最高的词是“天气”
  3. step2. LLM输出“天气”，根据“今天”、“天气”选择输出概率最高的“不错”
  4. step3. LLM输出“不错”，根据“今天”、“天气”、“不错”选择输出概率最高的“。”
  5. step4. LLM输出“。”，由于输入的内容已经学习完毕，LLM便丢弃最后一个预测
复制代码
  1. '4. llama的loss计算'
  2. #丢弃预测的最后一个token；
  3. #logits是预测结果,形状为 (batch_size, seq_len, classes)
  4. #labels是真实标签,形状为 (batch_size, seq_len)
  5. shift_logits = logits[...,;-1,:].contiguous()
  6. shift_labels = labels[...,1:].contiguous()
  8. #创建交叉熵损失函数
  9. loss_fct = nn.CroassEntropyLoss()
  11. #调整形状
  12. ##logits原始形状：(batch_size, seq_len-1, vocab_size)
  13. ##logits目标形状：(batch_size*(seq_len-1), vocab_size)
  14. shift_logits = shift_logits.view(-1,self.config.vocab_size)
  15. ##labels原始形状：(batch_size, seq_len-1)
  16. ##labels目标形状：(batch_size*(seq_len-1))
  17. shift_labels = shift_labels.view(-1)
  19. #确保 logits和 labels在同一设备计算
  20. shift_labels = shift_labels.to(shift_logits.device)
  21. #损失计算​
  22. loss = loss_fct(shift_logits,shift_labels)
复制代码
  1. '5. 缩小显存需求-量化加载'
  2. # 4bit load
  3. bnb_config = BitsAndBytesConfig(
  4.     load_in_4bit=True,
  5.     bnb_4bit_use_double_quant=True,
  6.     bnb_4bit_quant_type="nf4",
  7.     bnb_4bit_compute_dtype=torch.bfloat16
  8. )
复制代码
  1. '6. 缩小显存需求-LoRA'
  2. # 4bit load
  3. peft_config = LoraConfig(
  4.         r=8,
  5.         target_modules=["q_proj",
  6.                         "v_proj",
  7.                         "k_proj",
  8.                         "o_proj",
  9.                         "gate_proj",
  10.                         "down_proj",
  11.                         "up_proj"
  12.                         ],
  13.         task_type=TaskType.CAUSAL_LM,
  14.         lora_alpha=16,
  15.         lora_dropout=0.05
  16.     )
  17. model = get_peft_model(model, peft_config)
  18. model.print_trainable_parameters()
复制代码
3.训练LLM
  1. '1. 数据处理'
  2. step1 将数据保存为txt文件
  3. step2 在文件的各个节点添加<|begin_of_text|>、<|start_header_id|>、
  4.       <|end_header_id|>、<|end_header_id|>
  6. '2. 参数初始化'
  7. 根据需要选择“验证策略”、“优化器”、“学习率”等参数
  8. # 定义一个参数类
  9. @dataclass
  10. class CustomArguments(transformers.TrainingArguments):
  11.     # LoRA_r
  12.     lora_r: int = field(default=8)
  13.     # 数据处理时的并行进程数
  14.     num_proc: int = field(default=1)
  15. # 使用类
  16. parser = transformers.HfArgumentParser(CustomArguments)
  17. training_args, = parser.parse_args_into_dataclasses()
复制代码
  1. '3. 处理输入数据'
  2. # 加载数据
  3. train_dataset = load_dataset("text", data_dir="/train_data", split="train")
  4. eval_dataset = load_dataset("text", data_dir="/eval_data", split="train")
  5. # 定义分词函数：对传入的数据分词处理
  6. #example是数据集中单条样本的字典，必须包含text字段
  7. def tokenization(example):
  8.     return tokenizer(example["text"])
  9. # 对所以样本进行分词
  10. # main_process_first保证分布式训练只在主进程处理
  11. with training_args.main_process_first(desc="dataset map tokenization"):
  12.     train_dataset = train_dataset.map(tokenization, remove_columns=["text"], num_proc=training_args.num_proc)
  13.     eval_dataset = eval_dataset.map(tokenization, remove_columns=["text"], num_proc=training_args.num_proc)
复制代码
  1. '4. 分组函数'
  2. # 定义分组函数
  3. def group_texts(examples):
  4.     # 拼接所有样本序列，首位相连
  5.     concatenated_examples = {k: list(chain(*examples[k])) for k in examples.keys()}
  6.     # 计算总长度
  7.     total_length = len(concatenated_examples[list(examples.keys())[0]])
  8.     # 确保总长度是max_seq_length的整数倍，剩余的丢弃
  9.     total_length = (total_length // training_args.max_seq_length) * training_args.max_seq_length
  10.     # 分块处理：将连续序列按固定长度切分
  11.     result = {
  12.         k: [t[i: i + training_args.max_seq_length] for i in range(0, total_length, training_args.max_seq_length)]
  13.         for k, t in concatenated_examples.items()
  14.     }
  15.     # 标签对齐
  16.     result["labels"] = result["input_ids"].copy()
  17.     return result
  18. # 使用分组函数
  19. with training_args.main_process_first(desc="dataset map tokenization"):
  20.     train_dataset = train_dataset.map(group_texts, num_proc=training_args.num_proc, batched=True)
  21.     eval_dataset = eval_dataset.map(group_texts, num_proc=training_args.num_proc, batched=True)
复制代码
4.完整代码
  1. from accelerate import PartialState
  2. from datasets import load_dataset
  3. from peft import TaskType, LoraConfig, get_peft_model
  4. from transformers import Trainer
  5. from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
  6. from dataclasses import dataclass, field
  7. import transformers
  8. from itertools import chain
  9. import torch
  10. import warnings
  12. warnings.filterwarnings("ignore")
  15. @dataclass
  16. class CustomArguments(transformers.TrainingArguments):
  17.     # LoRA_r
  18.     lora_r: int = field(default=8)
  19.     # 数据处理时的并行进程数
  20.     num_proc: int = field(default=1)
  21.     # 最大序列长度
  22.     max_seq_length: int = field(default=32)
  23.     # 验证策略，如不想进行验证，可以设置为 ‘no’
  24.     eval_strategy: str = field(default="steps")
  25.     # 每多少步进行一次验证
  26.     eval_steps: int = field(default=100)
  27.     # 随机种子
  28.     seed: int = field(default=0)
  29.     # 优化器
  30.     optim: str = field(default="adamw_torch")
  31.     # 训练epoch数
  32.     num_train_epochs: int = field(default=2)
  33.     # 每个设备上的批量大小
  34.     per_device_train_batch_size: int = field(default=1)
  36.     # 学习率
  37.     learning_rate: float = field(default=5e-5)
  38.     # 权重衰减
  39.     weight_decay: float = field(default=0)
  40.     # 预热步数
  41.     warmup_steps: int = field(default=10)
  42.     # 学习率规划期类型
  43.     lr_scheduler_type: str = field(default="linear")
  44.     # 是否使用梯度检查点
  45.     gradient_checkpointing: bool = field(default=False)
  46.     # 是否使用bf16作为混合精度训练类型
  47.     bf16: bool = field(default=True)
  48.     # 梯度累加步数
  49.     gradient_accumulation_steps: int = field(default=1)
  51.     # 日志记录的步长频率
  52.     logging_steps: int = field(default=3)
  53.     # checkpoint保存策略
  54.     save_strategy: str = field(default="steps")
  55.     # checkpoint保存的步长频率
  56.     save_steps: int = field(default=3)
  57.     # 总的保存checkpoint的数量
  58.     save_total_limit: int = field(default=2)
  60. # 使用CustomArguments
  61. parser = transformers.HfArgumentParser(CustomArguments)
  62. training_args, = parser.parse_args_into_dataclasses()
  64. # 导入模型参数
  65. model_path = '/data04/llama3/Meta-Llama-3.1-8B-Instruct'
  67. # 4b量化加载
  68. bnb_config = BitsAndBytesConfig(
  69.     load_in_4bit=True,
  70.     bnb_4bit_use_double_quant=True,
  71.     bnb_4bit_quant_type="nf4",
  72.     bnb_4bit_compute_dtype=torch.bfloat16
  73. )
  75. tokenizer = AutoTokenizer.from_pretrained(model_path)
  76. # 创建模型
  77. model = AutoModelForCausalLM.from_pretrained(
  78.     model_path,
  79.     low_cpu_mem_usage=True,
  80.     quantization_config=bnb_config,
  81.     device_map={"": PartialState().process_index}
  82. )
  84. # 将模型导入Lora中
  85. peft_config = LoraConfig(
  86.     r=training_args.lora_r,
  87.     target_modules=["q_proj",
  88.                     "v_proj",
  89.                     "k_proj",
  90.                     "o_proj",
  91.                     "gate_proj",
  92.                     "down_proj",
  93.                     "up_proj"
  94.                     ],
  95.     task_type=TaskType.CAUSAL_LM,
  96.     lora_alpha=16,
  97.     lora_dropout=0.05
  98. )
  99. # 微调模型
  100. model = get_peft_model(model, peft_config)
  101. # 计算模型中的可训练参数数量
  102. model.print_trainable_parameters()
  104. # 加载数据
  105. train_dataset = load_dataset("text", data_dir="/home/xuepeng/pretrain_test/train_data", split="train")
  106. eval_dataset = load_dataset("text", data_dir="/home/xuepeng/pretrain_test/eval_data", split="train")
  108. # 输入数据分词
  109. def tokenization(example):
  110.     return tokenizer(example["text"])
  111. with training_args.main_process_first(desc="dataset map tokenization"):
  112.     train_dataset = train_dataset.map(tokenization, remove_columns=["text"], num_proc=training_args.num_proc)
  113.     eval_dataset = eval_dataset.map(tokenization, remove_columns=["text"], num_proc=training_args.num_proc)
  115. # 输入数据分组
  116. def group_texts(examples):
  117.     # 将数据相连
  118.     concatenated_examples = {k: list(chain(*examples[k])) for k in examples.keys()}
  119.     # 计算总长度
  120.     total_length = len(concatenated_examples[list(examples.keys())[0]])
  121.     # 按定义最大长度分组，剩余token舍弃
  122.     total_length = (total_length // training_args.max_seq_length) * training_args.max_seq_length
  123.    # 分块
  124.     result = {
  125.         k: [t[i: i + training_args.max_seq_length] for i in range(0, total_length, training_args.max_seq_length)]
  126.         for k, t in concatenated_examples.items()
  127.     }
  128.     # 标签对齐
  129.     result["labels"] = result["input_ids"].copy()
  130.     return result
  131. with training_args.main_process_first(desc="dataset map tokenization"):
  132.     train_dataset = train_dataset.map(group_texts, num_proc=training_args.num_proc, batched=True)
  133.     eval_dataset = eval_dataset.map(group_texts, num_proc=training_args.num_proc, batched=True)
  135. # 利用transformers包里面的Trainer做训练
  136. if __name__ == '__main__':
  137.     trainer = Trainer(
  138.         model=model,
  139.         args=training_args,
  140.         train_dataset=train_dataset,
  141.         eval_dataset=eval_dataset
  142.     )
  143.     trainer.train()
  144.     trainer.save_model("/data04/xuepeng/test_train")
复制代码
学习视频：【大模型预训练看这个视频就够了】 https://www.bilibili.com/video/BV1xhYtewEum/?share_source=copy_web&vd_source=050ab764db52d186ab224170392c4055

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
悯拄等
6 天前

0

粉丝关注

17

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫