当前位置:   article > 正文

使用PEFT微调ChatGLM3-6B

使用PEFT微调ChatGLM3-6B

系列文章目录

该系列文章用于介绍使用peft库来进行大模型的微调
第一章 使用PEFT对ChatGLM3-6B进行LORA微调



前言

PEFT简介: PEFT(Parameter-Efficient Fine-Tuning)是一个库,用于有效地使大型预训练模型适应各种下游应用程序,而无需微调模型的所有参数,因为它的成本高得令人望而却步。PEFT方法仅微调少量(额外)模型参数 - 显着降低计算和存储成本 - 同时产生与完全微调模型相当的性能。这使得在消费者硬件上训练和存储大型语言模型 (LLM) 变得更加容易。

PEFT 与 Transformers、Diffusers 和 Accelerate 库集成,以更快、更简单的方式加载、训练和使用大型模型进行推理


声明:
本文实现主要参考自:https://github.com/Suffoquer-fang/LuXun-GPT
该库主要实现了一个从普通语句到鲁迅风格语句的转换的一个LORA微调。但其使用版本较老,已经难以复现。本文在其基础上进行了修改,以适应当前最新版本(peft和chatglm3)的微调,并整理到了该库:https://github.com/foolishortalent/AIGC/tree/main/LuXun%20trans%20chatglm


一、准备工作

1. 环境准备

# int8
bitsandbytes
accelerate

# chatglm
modelscope # 国内用户用这个比较快
protobuf
transformers
icetk
cpm_kernels

torch

# 
datasets
peft>=0.7.1

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

2. 大模型准备:

我们这里使用的是ChatGLM3-6B,运行如下代码便会自行从Hugging Face加载模型。

from transformers import AutoTokenizer, AutoModel
model = AutoModel.from_pretrained("THUDM/chatglm3-6b", trust_remote_code=True)
tokenizer = AutoTokenizer.from_pretrained("THUDM/chatglm3-6b", trust_remote_code=True)
  • 1
  • 2
  • 3

国内同学可以通过魔搭社区下载,和从Hugging Face下载的是一样的。
魔搭:https://modelscope.cn/models/ZhipuAI/chatglm3-6b/summary

pip install modelscope
  • 1
from modelscope import snapshot_download
model_dir = snapshot_download("ZhipuAI/chatglm3-6b", revision = "v1.0.0")
  • 1
  • 2

3. 数据准备

鲁迅说过:“有多少人工,便有多少智能。”
这也是挡在众多大语言模型微调开发者前面的一座大山,但好在有github:)
本博文整理的git库中包含的数据由对参考库中的example_data修改而来。
参考库中luxun_data.jsonl是selected_aug.jsonl经过与随机一个下面指令相结合生成的:

  • “将这句话改写成鲁迅风格的语言”
  • “用鲁迅的风格改写”
  • “你是一个非常熟悉鲁迅风格的作家,请用鲁迅的风格改写这句话”
  • “用鲁迅的风格改写这句话”

为了减少回答中出现英文的可能性,我们使用中文代替了原模版中的英文单词:
替代前 数据实例:

{"context": "Instruction: 将这句话改写成鲁迅风格的语言\nInput: 虽然打高尔夫、脱钩和参加豪门社交都是炫耀身份的行为,但如此疯狂追求名利地步就算被曝出丑闻,也不为过。\nAnswer: ", "target": "“打高尔夫”“脱钩”,“豪门社交”的熏灼之状,竟至于斯,则虽报以丑闻,亦不为过。"}
{"context": "Instruction: 将这句话改写成鲁迅风格的语言\nInput: 在追逐虚荣和地位的过程中,参加高尔夫球赛、脱离常规、参加豪门社交等活动已成为一种炫耀的方式,但这样的沉迷甚至即使被曝出丑闻也不为过。\nAnswer: ", "target": "“打高尔夫”“脱钩”,“豪门社交”的熏灼之状,竟至于斯,则虽报以丑闻,亦不为过。"}
{"context": "Instruction: 你是一个非常熟悉鲁迅风格的作家,请用鲁迅的风格改写这句话\nInput: 打高尔夫、脱掉脱钩、参加社交活动等的追求地位与名望的行为已经到了疯狂的程度,哪怕发生丑闻也不会有任何过错。\nAnswer: ", "target": "“打高尔夫”“脱钩”,“豪门社交”的熏灼之状,竟至于斯,则虽报以丑闻,亦不为过。"}
{"context": "Instruction: 用鲁迅的风格改写\nInput: 尽管打高尔夫、脱钩、参加豪门社交等活动是一种炫耀身份和社会地位的行为,但如此的沉迷到了这种地步,即使曝出丑闻也不算是过分。\nAnswer: ", "target": "“打高尔夫”“脱钩”,“豪门社交”的熏灼之状,竟至于斯,则虽报以丑闻,亦不为过。"}

  • 1
  • 2
  • 3
  • 4
  • 5

替代后 数据实例:

{"context": "指令:将这句话改写成鲁迅风格的语言\n语句:虽然打高尔夫、脱钩和参加豪门社交都是炫耀身份的行为,但如此疯狂追求名利地步就算被曝出丑闻,也不为过。\n答:", "target": "“打高尔夫”“脱钩”,“豪门社交”的熏灼之状,竟至于斯,则虽报以丑闻,亦不为过。"}
{"context": "指令:将这句话改写成鲁迅风格的语言\n语句:在追逐虚荣和地位的过程中,参加高尔夫球赛、脱离常规、参加豪门社交等活动已成为一种炫耀的方式,但这样的沉迷甚至即使被曝出丑闻也不为过。\n答:", "target": "“打高尔夫”“脱钩”,“豪门社交”的熏灼之状,竟至于斯,则虽报以丑闻,亦不为过。"}
{"context": "指令:你是一个非常熟悉鲁迅风格的作家,请用鲁迅的风格改写这句话\n语句:打高尔夫、脱掉脱钩、参加社交活动等的追求地位与名望的行为已经到了疯狂的程度,哪怕发生丑闻也不会有任何过错。\n答:", "target": "“打高尔夫”“脱钩”,“豪门社交”的熏灼之状,竟至于斯,则虽报以丑闻,亦不为过。"}
{"context": "指令:用鲁迅的风格改写\n语句:尽管打高尔夫、脱钩、参加豪门社交等活动是一种炫耀身份和社会地位的行为,但如此的沉迷到了这种地步,即使曝出丑闻也不算是过分。\n答:", "target": "“打高尔夫”“脱钩”,“豪门社交”的熏灼之状,竟至于斯,则虽报以丑闻,亦不为过。"}
  • 1
  • 2
  • 3
  • 4

二、数据集准备和训练LORA

1. 把对话数据转化为token化的id进行存储

import json
from tqdm import tqdm

import datasets
import transformers

def preprocess(tokenizer, config, example, max_seq_length):
    prompt = example["context"]
    target = example["target"]
    prompt_ids = tokenizer.encode(prompt, max_length=max_seq_length, truncation=True)
    target_ids = tokenizer.encode(
        target,
        max_length=max_seq_length,
        truncation=True,
        add_special_tokens=False)
    input_ids = prompt_ids + target_ids + [config.eos_token_id]
    return {"input_ids": input_ids, "seq_len": len(prompt_ids)}


def read_jsonl(path, max_seq_length, skip_overlength=False):
    model_name = "ZhipuAI//chatglm-6b"
    tokenizer = transformers.AutoTokenizer.from_pretrained(
        model_name, trust_remote_code=True)
    config = transformers.AutoConfig.from_pretrained(
        model_name, trust_remote_code=True, device_map='auto')
    with open(path, "r") as f:
        for line in tqdm(f.readlines()):
            example = json.loads(line)
            feature = preprocess(tokenizer, config, example, max_seq_length)
            if skip_overlength and len(feature["input_ids"]) > max_seq_length:
                continue
            feature["input_ids"] = feature["input_ids"][:max_seq_length]
            yield feature

jsonl_path = "lunxun-style-data/luxun_data.jsonl"
save_path = "lunxun-style-data/luxun"
max_seq_length = 500
skip_overlength = False
dataset = datasets.Dataset.from_generator(
        lambda: read_jsonl(args.jsonl_path, args.max_seq_length, args.skip_overlength)
    )
dataset.save_to_disk(args.save_path)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

我们通过preprocess方法来对luxun_data.jsonl中的每一条数据进行token化处理,将语句转化为代表词语编码序号的一系列序号id。最后返回的 **{“input_ids”: input_ids, “seq_len”: len(prompt_ids)}**中,input_ids由prompt_ids、target_ids、config.eos_token_id三部分拼接而成,seq_len则记录prompt_ids的长度。

2.训练

构建MyTrainingArguments类,用于接收训练所需参数:

  • max_steps: 训练轮数
  • save_steps: 每隔多少轮存储一次模型数据
  • learning_rate: 学习率
  • fp16: 是否使用fp16
  • remove_unused_columns: 是否移除不使用的列
  • logging_steps: 每多少轮打印一次日志
  • output_dir: lora模型存储路径
  • per_device_train_batch_size: 训练批次大小
  • gradient_accumulation_steps: 累计梯度轮次
  • dataset_path: dataset存放路径
  • lora_rank: lora的秩

构建MyTrainer类,用于训练。实现了父类的compute_losssave_model的函数。

# coding=utf-8
import sys

sys.path.append("./")
from dataclasses import dataclass, field
import os
from transformers import (

    TrainingArguments,
    Trainer,
)


@dataclass
class MyTrainingArguments(TrainingArguments):
    max_steps: int = field(default=5000)
    save_steps: int = field(default=1000)
    learning_rate: float = field(default=1e-4)
    fp16: bool = field(default=True)
    remove_unused_columns: bool = field(default=False)
    logging_steps: int = field(default=50)
    output_dir: str = field(default="LuXun-lora")
    per_device_train_batch_size: int = field(default=4)
    gradient_accumulation_steps: int = field(default=2)
    dataset_path: str = field(default="lunxun-style-data/luxun")
    lora_rank: int = field(default=8)


import torch


class MyTrainer(Trainer):
    def compute_loss(self, model, inputs, return_outputs=False):
        return model(
            input_ids=inputs["input_ids"],
            labels=inputs["labels"],
        ).loss

    def save_model(self, output_dir=None, _internal_call=False):
        from transformers.trainer import TRAINING_ARGS_NAME

        os.makedirs(output_dir, exist_ok=True)
        torch.save(self.args, os.path.join(output_dir, TRAINING_ARGS_NAME))
        self.model.save_pretrained(output_dir)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44

通过build_model来构建待训练的peft模型,通过LoraConfig来设置所需训练的Lora参数:

  • task_type=TaskType.CAUSAL_LM: 任务类型:因果大模型
  • inference_mode=False:
  • r=training_args.lora_rank: 所添加lora的秩
  • lora_alpha=32: lora模型的系数
  • lora_dropout=0.1: lora模型的dropout比例
  • target_modules=[“query_key_value”]: 需要添加lora的层,query_key_value即模块中包含该名称
from transformers import HfArgumentParser
from transformers import AutoTokenizer, AutoModel

import datasets

from peft import get_peft_model, LoraConfig, TaskType
from utils import get_data_collator
from training_arguments import MyTrainingArguments, MyTrainer


def build_model(training_args):
    print("#> Building model...")
    model = AutoModel.from_pretrained(
        "ZhipuAI/chatglm3-6b", load_in_8bit=True, trust_remote_code=True, device_map="auto"
    )
    model.gradient_checkpointing_enable()
    model.enable_input_require_grads()
    model.is_parallelizable = True
    model.model_parallel = True
    model.config.use_cache = (
        False  # silence the warnings. Please re-enable for inference!
    )

    peft_config = LoraConfig(
        task_type=TaskType.CAUSAL_LM,
        inference_mode=False,
        r=training_args.lora_rank,
        lora_alpha=32,
        lora_dropout=0.1,
        target_modules=["query_key_value"]
    )
    model = get_peft_model(model, peft_config)

    print("#> Model built.")
    print("#> Total Trainable Parameters:", sum(p.numel() for p in model.parameters() if p.requires_grad))
    print("#> Total Parameters:", sum(p.numel() for p in model.parameters()), "\n")

    return model


def main():
    # parse args
    training_args = HfArgumentParser(MyTrainingArguments).parse_args_into_dataclasses()[0]

    training_args.remove_unused_columns = False

    print("#> Loading dataset...")

    dataset = datasets.load_from_disk(training_args.dataset_path)
    dataset.set_format(
        type=dataset.format["type"],
        columns=list(dataset.features.keys()),
    )

    print("#> Dataset loaded.", "Total samples:", len(dataset), "\n")

    # build model

    model = build_model(training_args)
    tokenizer = AutoTokenizer.from_pretrained("ZhipuAI/chatglm3-6b", trust_remote_code=True)

    print("#> Start training...")
    # start train
    trainer = MyTrainer(
        model=model,
        train_dataset=dataset,
        args=training_args,
        data_collator=get_data_collator(tokenizer),
    )
    trainer.train()
    model.save_pretrained(training_args.output_dir)

    print("#> Training finished.")
    print("#> Model saved to:", training_args.output_dir)


if __name__ == "__main__":
    main()
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78

utils中的get_data_collator返回一个数据校对器,用于将所有训练数据的token id、标签数据的token id补齐为相同长度。

def get_data_collator(tokenizer: AutoTokenizer):
    def data_collator(features: list) -> dict:
        len_ids = [len(feature["input_ids"]) for feature in features]
        longest = max(len_ids)
        input_ids = []
        labels_list = []
        for ids_l, feature in sorted(zip(len_ids, features), key=lambda x: -x[0]):
            ids = feature["input_ids"]
            seq_len = feature["seq_len"]
            labels = (
                [-100] * (longest-ids_l+seq_len) + ids[seq_len:]
            )
            ids = [tokenizer.pad_token_id] * (longest - ids_l) + ids
            _ids = torch.LongTensor(ids)
            labels_list.append(torch.LongTensor(labels))
            input_ids.append(_ids)
        input_ids = torch.stack(input_ids)
        labels = torch.stack(labels_list)
        return {
            "input_ids": input_ids,
            "labels": labels,
        }
    return data_collator
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

训练指令:

python lora_finetune.py 
  • 1

三、测试

1. 将待转换语句填充到询问模板中并加载lora模型进行对话

from transformers import AutoModel
import torch

from transformers import AutoTokenizer

from peft import PeftModel
import argparse


def generate(instruction, text):
    with torch.no_grad():
        input_text = f"指令:{instruction}\n语句:{text}\n答:"
        ids = tokenizer.encode(input_text)
        input_ids = torch.LongTensor([ids]).cuda()
        output = peft_model.generate(
            input_ids=input_ids,
            max_length=500,
            do_sample=False,
            temperature=0.0,
            num_return_sequences=1
        )
        output = tokenizer.decode(output[0])
        answer = output.split("答:")[-1]
    return answer.strip()


if __name__ == "__main__":

    base_model="ZhipuAI/chatglm3-6b"
    lora="LuXun-lora"
    instruction="你是一个非常熟悉鲁迅风格的作家,用鲁迅风格的积极正面的语言改写,保持原来的意思:"

    model = AutoModel.from_pretrained(base_model, trust_remote_code=True, load_in_8bit=True, device_map="auto")
    tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)

    if args.lora == "":
        print("#> No lora model specified, using base model.")
        peft_model = model.eval()
    else:
        print("#> Using lora model:", lora)
        peft_model = PeftModel.from_pretrained(model, lora).eval()
    torch.set_default_tensor_type(torch.cuda.FloatTensor)

    texts = [
        "你好",
        "有多少人工,便有多少智能。",
        "落霞与孤鹜齐飞,秋水共长天一色。",
        "我去买几个橘子,你就站在这里,不要走动。",
        "学习计算机技术,是没有办法救中国的。",
        "我怎么样都起不了床,我觉得我可能是得了抑郁症吧。",
        "它是整个系统的支撑架构,连接处理器、内存、存储、显卡和外围端口等所有其他组件。",
        "古巴导弹危机和越南战争是20世纪最大、最致命的两场冲突。古巴导弹危机涉及美国和苏联之间的僵局,因苏联在古巴设立核导弹基地而引发,而越南战争则是北方(由苏联支持)和南方(由美国支持)之间在印度支那持续的军事冲突。",
        "齿槽力矩是指旋转设备受到齿轮牙齿阻力时施加的扭矩。",
        "他的作品包括蒙娜丽莎和最后的晚餐,两者都被认为是杰作。",
        "滑铁卢战役发生在1815年6月18日,是拿破仑战争的最后一场重大战役。"
    ]

    for text in texts:
        print(text)
        print(generate(args.instruction, text), "\n")
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60

2.结果展示

你好
您好,有什么事吗? 

有多少人工,便有多少智能。
倘说:这便是智能的时代,而已。

落霞与孤鹜齐飞,秋水共长天一色。
秋天的景色,例如落霞,给天空带来美丽的画面,它却也只需要在天空飞翔,在秋水面上飞翔,在所谓美丽天空上飞翔。 

我去买几个橘子,你就站在这里,不要走动。
我便咬定:我去买橘子,你站在此处,不要移动。 

学习计算机技术,是没有办法救中国的。
倘要说学计算机技术,便只能说:“我国尚未成功”,而已。 

我怎么样都起不了床,我觉得我可能是得了抑郁症吧。
因为我要爬不起床来,我才能觉得我是个抑郁症患者。 

它是整个系统的支撑架构,连接处理器、内存、存储、显卡和外围端口等所有其他组件。
它诚然是这个系统的关键部分,一切处理器,一切内存,一切存储,都需要通过它来连接和传输,便在于它的连接和传输。 

古巴导弹危机涉及美国和苏联之间的僵局,因苏联在古巴设立核导弹基地而引发,而越南战争则是北方(由苏联支持)和南方(由美国支持)之间在印度支那持续的军事冲突。
古巴导弹危机,大抵是古巴导弹的僵局,或者说是美国导弹的僵局;而越南战争,则放任北方支持,或者说是北方军事占领,或者是什么像越南的印度支那般持续军事对峙。 

齿槽力矩是指旋转设备受到齿轮牙齿阻力时施加的扭矩。
齿轮的旋转,显然需要一定的扭矩。也许 toothless rotation 才是旋转设备遇到的问题。 

他的作品包括蒙娜丽莎和最后的晚餐,两者都被认为是杰作。
他的作品,如以蒙娜丽莎为准,说是艺术杰作;以最后的晚餐为准,则称之為杰作也不為過。 

滑铁卢战役发生在1815年6月18日,是拿破仑战争的最后一场重大战役。
滑铁卢战役的胜利,是拿破仑战争中的最后一次胜利, accordingly它也是拿破仑战争中最有意义的战役。 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32

总结

正如先生所言:“倘说:这便是智能的时代,而已。”
数据的优劣决定了模型的优质与否。智能的时代是数据的时代。而像lora、p-tuning等微调技术均可以由peft这类开源库完成。
算法专家的工作在于了解其算法原理,能够搭建模型、处理数据、训练模型、在多卡情况下训练模型、在终端设备上部署模型、优化模型(速度和精度)。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/我家小花儿/article/detail/824528
推荐阅读
  

闽ICP备14008679号