使用QLoRA在定制数据集上优化大型语言模型（LLM）。

（微调）LLM（即优化大规模语言模型）

自然语言处理领域被大型语言模型（LLMs）彻底改变了，这些模型展示了强大且复杂的能力。经过大量文本数据集的训练，这些模型在文本生成、翻译、摘要和问答等任务上表现出色。尽管它们非常强大和先进，但LLMs可能并不总是完全适用于特定的任务或领域。

在这个教程里，我们将会发现如何通过微调大规模语言模型来显著提高模型性能，减少训练成本，并实现更准确且更具体的结果。

微调LLM涉及对已有模型进行额外训练，该模型此前已从大量数据集中学习到模式和特征。使用较小的、特定领域的数据集进行微调。在“LLM微调”的背景下，LLM是指“大型语言模型”，如OpenAI的GPT系列。这种方法具有重要意义，因为从头开始训练大型语言模型在计算能力和时间上都非常耗费资源。利用预训练模型中嵌入的知识，可以在特定任务上实现高性能，同时大幅减少数据和计算需求。

下面是LLM的微调包括的一些关键步骤：

1. 选择一个预训练模型：对于LLM微调的第一步是仔细选择一个与我们所需的架构和功能相匹配的基础预训练模型。预训练模型是一类通用的模型，这些模型已经在大量的未标记数据上进行了训练。
2. 收集相关数据集：然后我们需要收集一个与我们的任务相关联的数据集。数据集应该被标记或结构化，以便模型能够从中学习，使其能够适应特定的任务。
3. 预处理数据集：一旦数据集准备好，我们需要进行预处理准备微调，包括清理数据，将其分割为训练、验证和测试集，并确保它与我们想要微调的模型兼容。
4. 微调：在选择了预训练模型之后，我们需要在我们预处理的相关数据集上对其进行微调，这个数据集对于当前任务来说更加具体。我们选择的数据集可能与特定领域或应用相关，使模型能够适应并专门针对该背景。
5. 任务特定的适应：在微调过程中，模型的参数会根据新数据集进行调整，帮助它更好地理解和生成与特定任务相关的文本内容。这个过程保留了在预训练阶段获得的通用语言知识，同时将模型调整到符合目标领域的细微差别。

对大型语言模型进行微调常用于自然语言处理任务，如情感分析、实体识别、文摘、翻译或任何其他需要理解上下文并生成连贯语言的应用场景中，例如。它有助于利用预训练模型中编码的知识，从而实现更专业和特定领域的应用。

微调大型语言模型（LLM）其实就是一种监督学习的过程。在这个过程中，通过使用包含标注数据的数据集来调整模型的权重，使其在特定任务上表现得更好。现在，我们来聊聊一些常用的微调技巧。

1. 完全微调（指令微调）：通过引导模型对查询的响应来训练数据，这是一种增强模型在各种任务上表现的策略。数据集的选择至关重要，并针对特定任务，如摘要或翻译进行调整。这种策略被称为完全微调，它更新了所有的模型权重，创建了一个性能提升的新版本。然而，它需要足够的内存和计算资源，类似于预训练时处理梯度、优化器和其他组件的需求。这对于简单的硬件来说是个挑战。但是，PEFT通过仅更新参数集的一部分来解决这个问题，有效地“冻结”了其余参数。这减少了可训练参数的数量，使内存需求更加合理，并防止灾难性遗忘。与全量微调不同，PEFT保持了原始大规模语言模型的权重，避免了先前学得信息的丢失。这种方法在处理多任务微调的存储问题上具有优势。实现参数高效微调的方法有很多种。低秩适应 LoRA 和 QLoRA 是最常用且效果最好的方法。

LoRA 是一种改进的微调技术，其中不是微调构成预训练大型语言模型的权重矩阵中的所有权重，而是微调两个较小的矩阵，这些矩阵近似于该矩阵。这两个矩阵即为 LoRA 适配器。然后将微调后的适配器加载到预训练模型中以供推理。

在针对特定任务或应用场景进行LoRA微调过程之后，结果是原始的大语言模型（LLM）保持不变，而产生了一个明显更小的“LoRA适配器”，通常只占原始LLM大小的个位数百分比（以MB而非GB计）。

在推理过程中来进行，LoRA适配器在使用时必须与原始的LLM结合。其优势在于多个LoRA适配器可以共用原始的LLM，从而在处理多种任务和应用场景时减少整体内存占用。

QLoRA（https://arxiv.org/abs/2305.14314）代表了LoRA的一种更节省内存的迭代。**QLoRA 通过将 LoRA 的适配器（较小的矩阵）的权重量化到更低的精度（例如，4位而不是8位），进一步推进了 LoRA**。这进一步减少了内存占用量和存储需求。在 QLoRA 中，预训练模型以量化为4位权重的形式加载到 GPU 内存中，而 LoRA 使用的是8位。虽然位精度降低，QLoRA 仍保持了与 LoRA 类似的有效性。

在本教程中，我们将使用带有 QLoRA 的参数高效微调。

我们现在来探讨一下如何在单个GPU上利用QLoRA技术对自定义的数据集进行LLM的微调。

1. 设置笔记本电脑
2. 安装所需的库
3. 加载数据集
4. 创建Bitsandbytes配置
5. 加载预训练模型
6. 使用零样本推断测试模型
7. 为QLoRA（快速低资源适应）准备模型
8. 预处理数据集
9. 设置PEFT进行微调（细调）
10. 训练PEFT适配器（适配器）
11. 定性评估模型（人工评价）
12. 定量评估模型（使用ROUGE评分）

我们将使用 Kaggle 笔记本来演示，不过您也可以使用任何其他的 Jupyter 笔记本环境。Kaggle 每周提供 30 小时的免费 GPU 使用时间，足够我们做实验。首先，我们打开一个新的笔记本，设定一些标题，然后连接到运行环境。

带有标签的笔记本

在这里，我们将选择 GPU P100 作为 加速器。 您可以尝试在Kaggle或其他任何环境中的其他GPU选项。

在本教程中，我们将使用 HuggingFace 库来下载和训练模型。要从 HuggingFace 下载模型，我们需要一个 Access Token。如果你已经注册了 HuggingFace，可以从设置部分生成新的 Access Token 或使用已有的 Access Token。

现在让我们安装一下这个实验所需的库文件。

!pip install -q -U bitsandbytes transformers peft accelerate datasets scipy einops evaluate trl rouge_score

让我们来理解其中一些库的重要性。

• Bitsandbytes ：一个优秀的包，提供了围绕自定义 CUDA 函数的轻量级包装，使大型语言模型运行更快——优化器、矩阵乘法和量化。在这次教程中，我们将使用这个库尽可能高效地加载我们的模型。
• transformers ：由 Hugging Face (🤗) 提供的一个库，提供了各种自然语言处理任务的预训练模型和训练工具。
• peft ：由 Hugging Face (🤗) 提供的一个库，支持高效参数微调。
• accelerate: 加速器抽象并仅处理与多 GPU/TPU/fp16 相关的样板代码，使您的其余代码保持不变。
• datasets ：由 Hugging Face (🤗) 提供的另一个库，提供了各种数据集的便捷访问。
• einops ：一个简化张量操作的库。

加载需要的库，

    from datasets import load_dataset  
    from transformers import (  
        AutoModelForCausalLM,  
        AutoTokenizer,  
        BitsAndBytesConfig,  
        HfArgumentParser,  
        TrainingArguments,  
        Trainer,  
        GenerationConfig  
    )  
    from tqdm import tqdm  
    from trl import SFTTrainer  
    import torch  
    import time  
    import pandas as pd  
    import numpy as np  
    from huggingface_hub import interpreter_login  

    interpreter_login()

在这个教程里，我们不会跟踪训练指标，所以让我们关闭Weights and Biases。 W &B 平台包括一系列强大的工具和组件，用于监控、可视化数据和模型以及传达结果。在微调过程中禁用Weights and Biases，请设置下面的环境变量。

    import os  
    # 禁用W&B (Weights and Biases)  
    os.environ['WANDB_DISABLED'] = "true "

如果您有Weights and Biases的账户，可以试试看，做一些实验。

许多数据集可用于微调模型。在这个例子中，我们将使用来自HuggingFace平台的DialogSum数据集进行微调。DialogSum是一个包含大量对话的对话摘要数据集，包含13,460个对话，以及人工标注的摘要和主题标签。

选择这个数据集并没有特定的原因。您可以随意使用任何自定义的数据集进行此实验。

我们来运行下面的代码来从HuggingFace加载上面的数据集。

    huggingface_dataset_name = "neil-code/dialogsum-test"  
    dataset = load_dataset(huggingface_dataset_name)

一旦数据集加载完成，我们可以看看里面有什么，来了解其内容。

数据集中的一个样本记录

它包括以下几个字段：

• 对话 : 对话内容。
• 摘要 : 对话摘要。
• 主题 : 对话主题或一句话简介。
• id : 示例唯一ID。

为了加载模型，我们需要定义如何进行量化处理。我们会用BitsAndBytesConfig来加载4位模型，这可以大大减少内存消耗，但会牺牲一点准确性。

    compute_dtype = getattr(torch, "float16")  # 设置 compute_dtype 为 torch 的 'float16' 类型
    bnb_config = BitsAndBytesConfig(  # 配置 BitsAndBytes 的参数
            load_in_4bit=True,  # 将模型加载为 4 位
            bnb_4bit_quant_type='nf4',  # 四位量化类型为 nf4
            bnb_4bit_compute_dtype=compute_dtype,  # 设置 4 位计算数据类型为 compute_dtype
            bnb_4bit_use_double_quant=False,  # 不使用双量化的 4 位计算
        )

微软最近开源了Phi-2，这是一个拥有27亿参数的小型语言模型（SLM）。在这里，我们将使用Phi-2进行微调。该语言模型展示了出色的推理和语言理解能力，并在同类基础语言模型中取得了最先进的性能。

我们现在来用4位量化从HuggingFace加载名为Phi-2的模型。

    model_name='microsoft/phi-2' 
    device_map = {"": 0} 
    original_model = AutoModelForCausalLM.from_pretrained(model_name, 
                                                          device_map=device_map, 
                                                          quantization_config=bnb_config, 
                                                          trust_remote_code=True,  # 允许远程代码
                                                          use_auth_token=True)  # 使用身份验证令牌

使用bitsandbytes库中的**BitsAndBytesConfig**，模型以4位格式加载。这属于QLoRA过程的一部分，该过程包括将预训练的模型权重量化为4位，并在微调过程中保持不变。

现在，我们来设置一下分词器，加入[left-padding]（左填充）以优化训练时的内存使用。

tokenizer = AutoTokenizer.from_pretrained(model_name,trust_remote_code=True,padding_side="left",add_eos_token=True,add_bos_token=True,use_fast=False)  
tokenizer.pad_token = tokenizer.eos_token

我们将用几个样本进行测试，以评估上面加载的基础模型。

    %%time  
    从transformers import set_seed  
    seed = 42  
    set_seed(seed)  

    index = 10  

    prompt = dataset['test'][index]['dialogue']  
    summary = dataset['test'][index]['summary']  

    formatted_prompt = f"任务：总结以下对话。\n{prompt}\n结果：\n"  
    res = gen(original_model,formatted_prompt,100,)  
    #print(res[0])  
    output = res[0].split('结果：\n')[1]  

    dash_line = '-' * 100  
    print(dash_line)  
    print(f'输入提示：\n{formatted_prompt}')  
    print(dash_line)  
    print(f'原始摘要：\n{summary}\n')  
    print(dash_line)  
    print(f'模型生成 - 零样本（无需额外训练）：\n{output}')

基础模型的结果

从上面的观察可以看出，该模型在总结对话时面临着相比基线摘要更多的挑战。然而，它能够从文本中提取关键信息，这表明它有可能针对特定任务进行微调。

这个数据集不能直接用来进行微调。需要以一种方式格式化提示，使之能被模型理解。根据HuggingFace的模型文档，我们可以看到，需要按照下面指定的格式，通过对话和摘要来生成提示。

提示格式

我们将创建一些辅助函数来格式化我们的输入数据集，确保其适合微调过程。在这里，我们需要将对话摘要和提示-响应对转换成供LLM使用的明确指令。

    def create_prompt_formats(sample):  
        """  
        格式化样本中的各个字段（如'instruction'和'output'）  
        然后将它们用两个换行符连接  
        :param sample: 样本数据  
        """  
        INTRO_BLURB = "以下是一个描述任务的指令。请编写一个适当的响应来完成请求。"  
        INSTRUCTION_KEY = "### 指令：总结以下对话。"  
        RESPONSE_KEY = "### 输出:"  
        END_KEY = "### 结尾"  

        blurb = f"\n{INTRO_BLURB}"  
        instruction = f"{INSTRUCTION_KEY}"  
        input_context = f"{sample['dialogue']}" if sample["dialogue"] else "如果样本中有'dialogue'字段, 则使用该字段的内容；否则，结果为None"  
        response = f"{RESPONSE_KEY}\n{sample['summary']}"  
        end = f"{END_KEY}"  

        parts = [part for part in [blurb, instruction, input_context, response, end] if part]  

        formatted_prompt = "\n\n".join(parts)  
        sample["text"] = formatted_prompt  

        return sample

这个函数可以把我们的输入转换成提示格式。

现在，我们将用我们的模型词元化器把这些提示处理成分词形式。

这里的目标是生成具有相同长度的输入序列，这有助于在减少计算开销的同时优化效率，从而微调语言模型。确保这些序列不要超过模型的最大标记限制这一点非常重要。

    from functools import partial  

    # SOURCE https://github.com/databrickslabs/dolly/blob/master/training/trainer.py  
    def get_max_length(model):  
        conf = model.config  
        max_length = None  
        for length_setting in ["n_positions", "max_position_embeddings", "seq_length"]:  
            max_length = getattr(model.config, length_setting, None)  
            if max_length:  
                print(f"找到最大长度为: {max_length}")  
                break  
        if not max_length:  
            max_length = 1024  
            print(f"使用默认的最大长度: {max_length}")  
        return max_length  

    def preprocess_batch(batch, tokenizer, max_length):  
        """  
        对一批数据进行分词处理  
        """  
        return tokenizer(  
            batch["text"],  
            max_length=max_length,  
            truncation=True,  
        )  

    # SOURCE https://github.com/databrickslabs/dolly/blob/master/training/trainer.py  
    def preprocess_dataset(tokenizer: AutoTokenizer, max_length: int, seed, dataset):  
        """  
        格式化并分词，以便进行训练  
        :param tokenizer (AutoTokenizer): 模型分词器  
        :param max_length (int): 从分词器生成的最大token数量  
        """  

        # 为每个样本添加提示  
        print("预处理数据集...")  
        dataset = dataset.map(create_prompt_formats)#, batched=True)  

        # 对数据集的每个批次应用预处理函数，并移除 'instruction', 'context', 'response', 'category' 这些字段  
        _preprocessing_function = partial(preprocess_batch, max_length=max_length, tokenizer=tokenizer)  
        dataset = dataset.map(  
            _preprocessing_function,  
            batched=True,  
            remove_columns=['id', 'topic', 'dialogue', 'summary'],  
        )  

        # 过滤掉输入ID超过最大长度的样本  
        dataset = dataset.filter(lambda sample: len(sample["input_ids"]) < max_length)  

        # 将数据集打乱  
        dataset = dataset.shuffle(seed=seed)  

        return dataset

通过使用这些功能，我们的数据集将准备好进行微调。

    ## 数据集预处理  
    max_length = get_max_length(original_model)  # 最大长度  
    print(max_length)  # 打印最大长度  

    train_dataset = preprocess_dataset(tokenizer, max_length, seed, dataset['train'])  # 训练数据集  
    eval_dataset = preprocess_dataset(tokenizer, max_length, seed, dataset['validation'])  # 验证数据集

    # 第2步：
    # 使用 PEFT 中的 prepare_model_for_kbit_training 函数为 QLoRA 准备模型
    original_model = prepare_model_for_kbit_training(original_model)

这里，模型准备进行 QLoRA 训练，使用 **prepare_model_for_kbit_training()** 函数初始化模型，设置必要的配置。

我们现在来定义LoRA（低秩适应）的配置，用于对基础模型进行微调。

    从peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training   

    config = LoraConfig(  
        r=32, # 秩  
        lora_alpha=32,  
        target_modules=[  
            'q_proj',  
            'k_proj',  
            'v_proj',  
            'dense'  
        ],  
        bias="none",  
        lora_dropout=0.05,  
        task_type="CAUSAL_LM",  
    )  

    original_model.gradient_checkpointing_enable()  

    peft_model = get_peft_model(original_model, config)

请注意秩（r）超参数，它决定了训练的适配器的秩（也就是维度）。r 是适配器中使用的低秩矩阵的秩（r），从而控制了适配器中需要训练的参数数量。更高的秩将提供更强的表达能力，但同时也会增加计算负担。

这里的 alpha 是学习到的权重的缩放因子。权重矩阵会乘以 alpha/r，因此，较高的 alpha 值会使 LoRA 激活的权重更大。

一旦所有设置完成，并且PEFT准备好，我们可以使用print_trainable_parameters()辅助函数（helper function）查看模型中有多少可训练的参数。

打印可训练的PEFT模型参数的数量。

可调优参数

定义训练参数设置，然后创建一个Trainer实例。

    output_dir = f'./peft-dialogue-summary-training-{str(int(time.time()))}'
    import transformers

    peft_training_args = TrainingArguments(
        output_dir=output_dir,
        warmup_steps=1,
        per_device_train_batch_size=1,
        gradient_accumulation_steps=4,
        max_steps=1000,
        learning_rate=2e-4,
        optim="paged_adamw_8bit",
        logging_steps=25,
        logging_dir="./logs",
        save_strategy="steps",
        save_steps=25,
        evaluation_strategy="steps",
        eval_steps=25,
        do_eval=True,
        gradient_checkpointing=True,
        report_to="none",
        overwrite_output_dir=True,
        group_by_length=True,
    )

    peft_model.config.use_cache = False

    peft_trainer = transformers.Trainer(
        model=peft_model,
        train_dataset=train_dataset,
        eval_dataset=eval_dataset,
        args=peft_training_args,
        data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),
    )

在这里，我们用了1000个训练步骤。这对我们自定义的数据集来说已经足够了。我们需要尝试不同的训练步数来确定最终选择。另外，我们尝试微调的数据集或模型不同，上面提到的超参数也可能需要调整。这只是为了展示微调的潜力。

我们现在开始训练吧。训练模型需要的时间这取决于TrainingArguments中的超参数设置。

    peft_trainer.train()

一旦模型训练成功，我们可以使用它来进行推断。现在让我们通过给原来的Phi-2模型添加一个适配器来准备推断模型。这里我们设置了is_trainable=False，因为我们只计划用这个PEFT模型来进行推断。

    import torch  
    from transformers import AutoTokenizer, AutoModelForCausalLM  # 这里导入了用于处理自然语言的自动分词器和自动因果语言模型模块

    base_model_id = "microsoft/phi-2"  
    base_model = AutoModelForCausalLM.from_pretrained(base_model_id,   
                                                          device_map='auto',  
                                                          quantization_config=bnb_config,  # 这里的bnb_config是用来配置量化参数的配置
                                                          trust_remote_code=True,  
                                                          use_auth_token=True)

    eval_tokenizer = AutoTokenizer.from_pretrained(base_model_id, add_bos_token=True, trust_remote_code=True, use_fast=False)  
    eval_tokenizer.pad_token = eval_tokenizer.eos_token

我们将pad token设置为eos token。

    从peft导入PeftModel模块  

    ft_model = PeftModel.from_pretrained(base_model, "/kaggle/working/peft-dialogue-summary-training-1705417060/checkpoint-1000", torch_dtype=torch.float16, is_trainable=False):

微调通常是一个迭代的过程。根据验证和测试集的结果，我们可能需要根据需要调整模型架构、超参数或训练数据以优化性能。现在我们来看看如何评估微调后的LLM表现。

现在，让我们使用相同的输入，但这次用PEFT模型来做推理，就像我们在步骤7中使用原始模型时一样。

    %%time  
    导入 transformers 中的 set_seed  
    set_seed(seed)  

    index = 5  
    dialogue = dataset['test'][index]['dialogue']  
    summary = dataset['test'][index]['summary']  

    prompt = f"指令：总结以下对话内容。\n{dialogue}\n输出结果：\n"  

    peft_model_res = gen(ft_model,prompt,100,)  
    peft_model_output = peft_model_res[0].split('Output:\n')[1]  
    #print(peft_model_output)  
    prefix, success, result = peft_model_output.partition('###')  

    dash_line = '-'.join('' for x in range(100))  
    print(dash_line)  
    print(f'提示：\n{prompt}')  
    print(dash_line)  
    print(f'基线总结：\n{summary}\n')  
    print(dash_line)  
    print(f'PEFT模型结果：\n{prefix}')

PEFT 的输出

ROUGE ，即基于召回的概要生成评估工具，是一套用于评估自然语言处理中的自动摘要和机器翻译系统的度量标准和软件包。这些度量标准会将自动产生的摘要或翻译与人工生成的参考摘要或翻译进行对比。

现在让我们使用ROUGE指标来量化模型生成的摘要的质量。它将摘要与通常由人工创建的“基准”摘要进行比较。虽然这并不是一个完美的指标，但它确实表明了我们通过微调已经实现了摘要质量的整体提升。

为了展示ROUGE评估指标的效果，我们将用一些样本来进行测试。

# 初始化模型
original_model = AutoModelForCausalLM.from_pretrained(base_model_id,   
                                                      device_map='auto',  
                                                      quantization_config=bnb_config,  
                                                      trust_remote_code=True,  
                                                      use_auth_token=True)
# 注释：加载预训练模型，并设置设备映射、量化配置等参数

    import pandas as pd  

    对话 = dataset['test'][:10]['dialogue']  
    人类基线摘要 = dataset['test'][:10]['summary']  

    原始模型的摘要 = []  
    指令模型的摘要 = []  
    微调模型的摘要 = []  

    for 索引, 对话 in enumerate(对话):  
        人类基线文本输出 = 人类基线摘要[索引]  
        提示 = f"指令：总结以下对话。\n{对话}\n输出：\n"  

        原始模型结果 = gen(original_model,提示,100,)  
        原始模型文本输出 = 原始模型结果[0].split('Output:\n')[1]  

        微调模型结果 = gen(ft_model,提示,100,)  
        微调模型输出 = 微调模型结果[0].split('Output:\n')[1]  
        print(微调模型输出.strip())  
        微调模型文本输出, 成功标志, 结果 = 微调模型输出.strip().partition('###')  

        原始模型的摘要.append(原始模型文本输出.strip())  
        微调模型的摘要.append(微调模型文本输出.strip())  

    摘要列表 = list(zip(人类基线摘要, 原始模型的摘要, 微调模型的摘要))  

    df = pd.DataFrame(摘要列表, columns = ['人类基线的摘要', '原始模型的摘要', '微调模型的摘要'])  
    df

    导入rouge评估  

    rouge = 评估加载('rouge')  

    original_model_results = rouge.计算(  
        predictions=original_model_summaries,  
        references=human_baseline_summaries[0:len(original_model_summaries)],  
        use_aggregator=True,  
        use_stemmer=True,  
    )  

    peft_model_results = rouge.计算(  
        predictions=peft_model_summaries,  
        references=human_baseline_summaries[0:len(peft_model_summaries)],  
        use_aggregator=True,  
        use_stemmer=True,  
    )  

    打印('原始模型:')  
    打印(original_model_results)  
    打印('PEFT模型:')  
    打印(peft_model_results)  

    打印("PEFT模型相对于原始模型的绝对百分比改进")  

    improvement = (np.array(list(peft_model_results.values())) - np.array(list(original_model_results.values())))  
    for key, value in zip(peft_model_results.keys(), improvement):  
        打印(f'{key}: {value*100:.2f}%')

Rouge评估指标

我们从上述结果可以看出，与原始模型相比，PEFT模型（或其缩写）在性能指标上有显著的百分比提升。

如果你想查看完整的笔记本，请查看下面的仓库。

下面是一些总结

微调大型语言模型（LLMs）已成为企业优化运营流程必不可少的过程。虽然初始训练让这些模型获得了广泛的语言理解，但微调过程进一步将这些模型转化为处理特定主题并提供更准确结果的专业工具。针对不同任务、行业或数据集对LLMs进行定制化调整，扩展了这些模型的能力，确保它们在动态的数字环境中持续相关和有价值。展望未来，对LLMs的持续探索和创新，结合更精细的微调方法，有望推动更智能、更高效且更了解上下文的AI系统的开发。

深入了解大规模语言模型（LLM）的调优 | SuperAnnotate：其重要性、类型、方法以及用于优化语言模型的最佳实践…www.superannotate.com

在对仅解码的大规模语言模型（如LLAMA）进行聊天数据集的微调时，应该使用哪种填充？许多论文讨论了这个问题。ai.stackexchange.com