11 对话模型微调

汀沿河

已于 2024-08-31 14:07:36 修改

阅读量783

点赞数 12

分类专栏： # 9transformers 文章标签：人工智能深度学习

于 2024-08-30 17:17:52 首次发布

本文链接：https://blog.csdn.net/qq_28611929/article/details/141719477

版权

9transformers 专栏收录该内容

21 篇文章 0 订阅

订阅专栏

提问：其实我一直觉的数据是最费事的一个，现在都是使用别人的数据，如果对于实际场景中那么我们该如何获取处理数据呢！

效果VS资源的碰撞！

1 数据处理；

2 模型选择，调参数；

数据

llm-wizard/alpaca-gpt4-data-zh · Datasets at HF Mirror

模型

魔搭社区

1 数据

数据字段描述：

Instruction: 问题

input: 输入部分，辅助解读问题

output: 问题的答案

数据怎么处理呢：

我们加个前缀"Human"+《instruction》+《input》:这个我为输入部分；
-100 通常用于表示忽略某个位置的损失计算。我们只对回答部分做损失计算；
这样就把输入回答拼接在一起了，然后只对回答部分计算损失；

2 模型

"BLOOM" 是一个由 BigScience 联盟开发的大规模多语言预训练语言模型。"BLOOM" 模型的设计目的是为了能够理解和生成多种语言的文本，包括但不限于英语、汉语等。"1.4B" 这个后缀通常指的是模型的参数量，即这个版本的 BLOOM 模型拥有大约 14 亿个参数。

关于您提到的 "Bloom预训练生成模型-中文-1.4B"，这可能是指一个专为中文优化的 BLOOM 模型变体，其参数量为 14 亿。这样的模型在处理中文文本时应该会有较好的表现，因为它经过了大量的中文语料训练，能够捕捉到中文语言的特性和结构。

模型的参数：1.3B,

占用内存：1.3B * 4 = 5.2G B

训练： 5.2GB * 4 = 21GB；

GPU 低于21G那就别玩了！

我的 NVIDIA英伟达Tesla L40S 48GB；

batchsize = 32, 不能玩了；只能为8；

2.1 全参数训练

from datasets import Dataset
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, DataCollatorForSeq2Seq, TrainingArguments, Trainer

# 日志
from transformers import DataCollatorWithPadding
from transformers.trainer_callback import TrainerCallback
import matplotlib.pyplot as plt


ds = Dataset.load_from_disk("../data/")
ds
# 分词
tokenizer = AutoTokenizer.from_pretrained("../bloom-model/")
tokenizer

def process_func(example):
    MAX_LENGTH = 256
    input_ids, attention_mask, labels = [], [], []
    instruction = tokenizer("\n".join(["Human: " + example["instruction"], example["input"]]).strip() + "\n\nAssistant: ")
    response = tokenizer(example["output"] + tokenizer.eos_token)
    input_ids = instruction["input_ids"] + response["input_ids"]
    attention_mask = instruction["attention_mask"] + response["attention_mask"]
    labels = [-100] * len(instruction["input_ids"]) + response["input_ids"]
    if len(input_ids) > MAX_LENGTH:
        input_ids = input_ids[:MAX_LENGTH]
        attention_mask = attention_mask[:MAX_LENGTH]
        labels = labels[:MAX_LENGTH]
    return {
        "input_ids": input_ids,
        "attention_mask": attention_mask,
        "labels": labels
    }

tokenized_ds = ds.map(process_func, remove_columns=ds.column_names)
tokenized_ds


print(tokenizer.decode(tokenized_ds[1]["input_ids"]))
print()
print(tokenizer.decode(list(filter(lambda x: x != -100, tokenized_ds[1]["labels"])))
)


sum([param.numel() for param in model.parameters()]) / 1000000000

# 自定义回调类，用于在训练过程中打印损失
model = AutoModelForCausalLM.from_pretrained("../bloom-model/")

class PrintLossCallback(TrainerCallback):
    
    def __init__(self):
        self.losses = []
        self.steps = []

    def on_log(self, args, state, control, logs=None, **kwargs):
        # 打印训练过程中的日志信息
        try:
            if logs is not None:
                print(f"Step {state.global_step}: Loss={logs['loss']:.4f}, Learning Rate={logs['learning_rate']:.6f}")
                self.losses.append(logs['loss'])
                self.steps.append(state.global_step)

        except Exception as e :
            print(f'on_log error {e}')
    
    def plot_losses(self):
        plt.figure(figsize=(10, 5))
        plt.plot(self.steps, self.losses, label='Training Loss')
        plt.xlabel('Steps')
        plt.ylabel('Loss')
        plt.title('Training Loss Over Time')
        plt.legend()
        plt.show()
        

args = TrainingArguments(
    output_dir="./chatbot",
    per_device_train_batch_size=8,
    gradient_accumulation_steps=8,
    logging_steps=10,
    num_train_epochs=2
)
plot_losses_callback = PrintLossCallback()
trainer = Trainer(
    model=model,
    args=args,
    tokenizer=tokenizer,
    train_dataset=tokenized_ds,
    data_collator=DataCollatorForSeq2Seq(tokenizer=tokenizer, padding=True),
    callbacks=[plot_losses_callback]  # 注册自定义回调
)



if torch.cuda.is_available():
    trainer.model = trainer.model.to("cuda")
# 训练模型
trainer.train()

过程很慢！

2.2 Prompt-Tuning

安装依赖： installed peft-0.12.0

在Prompt Tuning方法中，主要改变的是输入结构而不是直接调整模型本身的参数。

Prompt-Tuning 高效微调只会训练新增的Prompt的表示层，模型的其余参数全部固定；

新增的 Prompt 内容可以分为 Hard Prompt 和 Soft Prompt 两类；

Soft prompt 通常指的是一种较为宽泛或模糊的提示，允许模型在生成结果时有更大的自由度，通常用于启发模型进行创造性的生成；

Hard prompt 是一种更为具体和明确的提示，要求模型按照给定的信息生成精确的结果，通常用于需要模型提供准确答案的任务；

Soft Prompt 在 peft 中一般是随机初始化prompt的文本内容，而 Hard prompt 则一般需要设置具体的提示文本内容；

2.3 PromptTuningConfig 参数解释

PromptTuningConfig(task_type=TaskType.CAUSAL_LM,
prompt_tuning_init=PromptTuningInit.TEXT,
prompt_tuning_init_text="下面是一段人与机器人的对话。",
num_virtual_tokens=len(tokenizer("下面是一段人与机器人的对话。")["input_ids"]),
tokenizer_name_or_path="../bloom-model/")

参数的解释：

task_type=TaskType.CAUSAL_LM

含义：指定任务类型为因果语言模型（Causal Language Modeling）。因果语言模型通常用于生成连续文本，预测下一个词的概率分布。
作用：告知配置系统，你打算使用模型进行生成任务，而不是其他任务类型，如序列分类、问答等。

prompt_tuning_init=PromptTuningInit.TEXT

含义：指定提示初始化的方法为文本形式。这意味着提示向量将从一段给定的文本初始化。
作用：提供了初始化提示向量的一种方式，使得提示向量从某个具体的文本样本中获得初始值，而不是随机初始化。

prompt_tuning_init_text="下面是一段人与机器人的对话。"

含义：指定用于初始化提示向量的文本内容。
作用：这段文本将用于初始化提示向量。提示向量的初始值将与这段文本的嵌入表示相关联，从而在训练过程中提供一个良好的起点。

num_virtual_tokens=len(tokenizer("下面是一段人与机器人的对话。")["input_ids"])

含义：计算虚拟标记的数量，即提示向量的长度。
作用：确定提示向量的长度。在这里，提示向量的长度等于给定文本经过分词器处理后得到的token数量。这确保了提示向量的长度与实际输入文本相匹配。

tokenizer_name_or_path="../bloom-model/"
含义：指定分词器的名称或路径。这里是使用一个本地路径来加载分词器。
作用：确保使用正确的分词器来处理输入文本，这对于初始化提示向量以及后续的训练过程至关重要。

from datasets import Dataset
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, DataCollatorForSeq2Seq, TrainingArguments, Trainer

ds = Dataset.load_from_disk("../data/")
ds

tokenizer = AutoTokenizer.from_pretrained("../bloom-model/")
tokenizer
def process_func(example):
    MAX_LENGTH = 256
    input_ids, attention_mask, labels = [], [], []
    instruction = tokenizer("\n".join(["Human: " + example["instruction"], example["input"]]).strip() + "\n\nAssistant: ")
    response = tokenizer(example["output"] + tokenizer.eos_token)
    input_ids = instruction["input_ids"] + response["input_ids"]
    attention_mask = instruction["attention_mask"] + response["attention_mask"]
    labels = [-100] * len(instruction["input_ids"]) + response["input_ids"]
    if len(input_ids) > MAX_LENGTH:
        input_ids = input_ids[:MAX_LENGTH]
        attention_mask = attention_mask[:MAX_LENGTH]
        labels = labels[:MAX_LENGTH]
    return {
        "input_ids": input_ids,
        "attention_mask": attention_mask,
        "labels": labels
    }

tokenized_ds = ds.map(process_func, remove_columns=ds.column_names)
tokenized_ds

from transformers import DataCollatorWithPadding
from transformers.trainer_callback import TrainerCallback
import matplotlib.pyplot as plt

from peft import PromptTuningConfig, get_peft_model, TaskType, PromptTuningInit

# Soft Prompt
# config = PromptTuningConfig(task_type=TaskType.CAUSAL_LM, num_virtual_tokens=10)
# config
# Hard Prompt
config = PromptTuningConfig(task_type=TaskType.CAUSAL_LM,
                            prompt_tuning_init=PromptTuningInit.TEXT,
                            prompt_tuning_init_text="下面是一段人与机器人的对话。",
                            num_virtual_tokens=len(tokenizer("下面是一段人与机器人的对话。")["input_ids"]),
                            tokenizer_name_or_path="../bloom-model/")
config


class PrintLossCallback(TrainerCallback):
    
    def __init__(self):
        self.losses = []
        self.steps = []

    def on_log(self, args, state, control, logs=None, **kwargs):
        # 打印训练过程中的日志信息
        try:
            if logs is not None:
                print(f"Step {state.global_step}: Loss={logs['loss']:.4f}, Learning Rate={logs['learning_rate']:.6f}")
                self.losses.append(logs['loss'])
                self.steps.append(state.global_step)

        except Exception as e :
            print(f'on_log error {e}')
    
    def plot_losses(self):
        plt.figure(figsize=(10, 5))
        plt.plot(self.steps, self.losses, label='Training Loss')
        plt.xlabel('Steps')
        plt.ylabel('Loss')
        plt.title('Training Loss Over Time')
        plt.legend()
        plt.show()
        

args = TrainingArguments(
    output_dir="./chatbot_prompt",
    per_device_train_batch_size=8,
    gradient_accumulation_steps=8,
    logging_steps=10,
    num_train_epochs=1,
    #save_steps=20,
)
plot_losses_callback = PrintLossCallback()
trainer = Trainer(
    model=model,
    args=args,
    tokenizer=tokenizer,
    train_dataset=tokenized_ds,
    data_collator=DataCollatorForSeq2Seq(tokenizer=tokenizer, padding=True),
    callbacks=[plot_losses_callback]  # 注册自定义回调
)



if torch.cuda.is_available():
    trainer.model = trainer.model.to("cuda")
# 训练模型
trainer.train()

效果没有全调参数好，收敛也很慢！

2.3 推理

model.save_pretrained(args.output_dir)
from peft import PeftModel
# 在一个jupyter文件中，如果前面已经加载了模型，并对模型做了一定修改，则需要重新加载原始模型
model = AutoModelForCausalLM.from_pretrained("../bloom-model/")
peft_model = PeftModel.from_pretrained(model=model, model_id="./chatbot_prompt/")


peft_model = peft_model.cuda()
ipt = tokenizer("Human: {}\n{}".format("考试有哪些技巧？", "").strip() + "\n\nAssistant: ", return_tensors="pt").to(peft_model.device)
print(tokenizer.decode(peft_model.generate(**ipt, max_length=128, do_sample=True)[0], skip_special_tokens=True))