基于自定义数据集的微调：Alpaca与LLaMA模型的训练

欢迎来到微调 Alpaca LoRa 的教程！在本教程中，我们将探索如何微调Alpaca LoRa模型以检测比特币相关的推文。

首先，我们要提及Alpaca LoRa的存储库，它为我们提供了重现Stanford团队使用低秩适应（LoRA）技术所得出的Alpaca成果的方法。这个存储库不仅包含了一个与Instruct模型质量相似的模型，而且其代码还适用于13b、30b和65b等不同型号的模型。同时利用了Hugging Face的PEFT（参数高效微调技术）text-davinci-0032和Tim Dettmers的bitsandbytes3库，这两者在高效且低成本的微调方面表现出色。

接下来，我们将深入探讨整个微调过程，从特定数据集的准备开始，一直到最后部署经过训练的模型。本教程将全面覆盖数据处理、模型训练与评估等关键主题，同时我们将借助Transformers和Hugging Face等流行的自然语言处理库来辅助实现。

最后，我们还将向您展示如何部署模型，并使用Gradio应用程序对模型进行测试。

笔记本设置

Alpaca-lora1 GitHub 仓库提供了一个用于训练模型的单一脚本（finetune.py）。在本教程中，我们将利用这段代码，并对其进行调整，使其能够在 Google Colab 环境中无缝运行。

让我们从存储库中安装必要的依赖项开始：

!pip install -U pip

!pip install accelerate==0.18.0

!pip install appdirs==1.4.4

!pip install bitsandbytes==0.37.2

!pip install datasets==2.10.1

!pip install fire==0.5.0

!pip install git+https://github.com/huggingface/peft.git

!pip install git+https://github.com/huggingface/transformers.git

!pip install torch==2.0.0

!pip install sentencepiece==0.1.97

!pip install tensorboardX==2.6

!pip install gradio==3.23.0

安装依赖项后，我们将继续导入所有必要的库并配置 matplotlib 绘图的各项设置：

import transformers

import textwrap

from transformers import LlamaTokenizer, LlamaForCausalLM

import os

import sys

from typing import List

 

from peft import (

    LoraConfig,

    get_peft_model,

    get_peft_model_state_dict,

    prepare_model_for_int8_training,

)

 

import fire

import torch

from datasets import load_dataset

import pandas as pd

 

import matplotlib.pyplot as plt

import matplotlib as mpl

import seaborn as sns

from pylab import rcParams

 

%matplotlib inline

sns.set(rc={'figure.figsize':(10, 7)})

sns.set(rc={'figure.dpi':100})

sns.set(style='white', palette='muted', font_scale=1.2)

 

DEVICE = "cuda" if torch.cuda.is_available() else "cpu"

DEVICE

数据

我们将使用Kaggle上提供的BTC Tweets Sentiment数据集，该数据集包含约50,000条与比特币相关的推文。为了清理数据，我删除了所有以“RT”开头或包含链接的推文。现在让我们开始下载数据集：

!gdown 1xQ89cpZCnafsW5T3G3ZQWvR7q682t2BN

我们可以使用 Pandas 来加载 CSV：

df = pd.read_csv("bitcoin-sentiment-tweets.csv")

df.head()

	日期	推文内容	情感倾向
0	2018 年 3 月 23 日星期五 00：40：40 +0000	@p0nd3ea 比特币不是为了在交易所生存而创建的。	正面（1）
1	2018 年 3 月 23 日星期五 00：40：40 +0000	@historyinflicks 伙计，如果我患有 Bannon 那种19世纪的一连串疾病，我也想成为比特币。	正面（1）
2	2018 年 3 月 23 日星期五 00：40：42 +0000	@eatBCH @Bitcoin @signalapp @myWickr @Samsung @tipprbot耐心确实是一种美德	负面（1）
3	2018 年 3 月 23 日星期五 00：41：04 +0000	@aantonop 即使比特币明天早上就崩盘，它的技术仍然是革命性的。一种简化的方式。#我必须成为其中的一部分	负面（0）
4	2018 年 3 月 23 日星期五 00：41：07 +0000	我正在试验我是否可以只用捐赠的比特币生活。	正面（1）

我们的数据集包含了约1900条推文，这些推文的情绪标签用数字表示：负数情绪为-1，中性情绪为0，积极情绪为1。

让我们来看看它们的分布情况：

df.sentiment.value_counts()

 0.0    860

 1.0    779

-1.0    258

Name: sentiment, dtype: int64

df.sentiment.value_counts().plot(kind='bar');

负面情绪的分布相对较低，这一点在评估微调模型的性能时应予以考虑。

构建 JSON 数据集

原始Alpaca仓库中的数据集格式为一个JSON文件，该文件包含一个对象列表，这些对象具有instruction、input和output字符串属性。

现在，让我们将Pandas数据帧转换为符合原始Alpaca仓库格式的JSON文件：

def sentiment_score_to_name(score: float):

    if score > 0:

        return "Positive"

    elif score < 0:

        return "Negative"

    return "Neutral"

 

dataset_data = [

    {

        "instruction": "Detect the sentiment of the tweet.",

        "input": row_dict["tweet"],

        "output": sentiment_score_to_name(row_dict["sentiment"])

    }

    for row_dict in df.to_dict(orient="records")

]

 

dataset_data[0]

{

  "instruction": "Detect the sentiment of the tweet.",

  "input": "@p0nd3ea Bitcoin wasn't built to live on exchanges.",

  "output": "Positive"

}

最后，我们将保存生成的 JSON 文件用于训练模型：

import json

with open("alpaca-bitcoin-sentiment-dataset.json", "w") as f:

   json.dump(dataset_data, f)

模型权重

尽管原始的Llama模型权重无法获取，但它们已被泄露并随后被适配用于HuggingFace Transformers库。我们将使用decapoda-research提供的权重：

BASE_MODEL = "decapoda-research/llama-7b-hf"

 

model = LlamaForCausalLM.from_pretrained(

    BASE_MODEL,

    load_in_8bit=True,

    torch_dtype=torch.float16,

    device_map="auto",

)

 

tokenizer = LlamaTokenizer.from_pretrained(BASE_MODEL)

 

tokenizer.pad_token_id = (

    0  # unk. we want this to be different from the eos token

)

tokenizer.padding_side = "left"

这段代码使用Hugging Face Transformers库中的类来加载预训练的Llama模型。参数load_in_8bit=True表示以8位量化的方式加载模型，以减少内存使用并提高推理速度。

代码还使用相同的类加载了该Llama模型的分词器，并为填充令牌设置了一些附加属性。具体来说，它将pad_token_id设置为0来表示未知令牌，并将padding_side设置为”left”以在左侧填充序列。

数据

现在我们已经加载了模型和分词器，接下来可以使用HuggingFace datasets库中的load_dataset()函数来加载我们之前保存的JSON文件。

data = load_dataset("json", data_files="alpaca-bitcoin-sentiment-dataset.json")data["train"]

Dataset({

    features: ['instruction', 'input', 'output'],

    num_rows: 1897

})

接下来，我们需要从加载的数据集中创建提示并对其进行标记：

def generate_prompt(data_point):

    return f"""Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.  # noqa: E501

### Instruction:

{data_point["instruction"]}

### Input:

{data_point["input"]}

### Response:

{data_point["output"]}"""

 

 

def tokenize(prompt, add_eos_token=True):

    result = tokenizer(

        prompt,

        truncation=True,

        max_length=CUTOFF_LEN,

        padding=False,

        return_tensors=None,

    )

    if (

        result["input_ids"][-1] != tokenizer.eos_token_id

        and len(result["input_ids"]) < CUTOFF_LEN

        and add_eos_token

    ):

        result["input_ids"].append(tokenizer.eos_token_id)

        result["attention_mask"].append(1)

 

    result["labels"] = result["input_ids"].copy()

 

    return result

 

def generate_and_tokenize_prompt(data_point):

    full_prompt = generate_prompt(data_point)

    tokenized_full_prompt = tokenize(full_prompt)

    return tokenized_full_prompt

第一个函数从数据集中取出一个数据点，通过结合 INSTRUCTION、INPUT 和 OUTPUT 来生成一个提示。第二个函数接收生成的提示并使用之前定义的分词器对其进行分词。它还会在输入序列中添加一个序列结束令牌，并将标签设置为与输入序列相同。第三个函数将前两个函数结合，以一步完成提示的生成和分词。generate_prompt、tokenize和generate_and_tokenize_prompt分别表示这三个函数。

数据准备的最后一步是将数据集拆分为独立的训练集和验证集：

train_val = data["train"].train_test_split(

    test_size=200, shuffle=True, seed=42

)

train_data = (

    train_val["train"].map(generate_and_tokenize_prompt)

)

val_data = (

    train_val["test"].map(generate_and_tokenize_prompt)

)

我们需要 200 个验证集样本，并对数据进行随机排序。对于训练和验证集中的每个样本，我们都会应用一个函数来生成并标记提示（tokenize prompts），该函数名为generate_and_tokenize_prompt()。

训练

训练过程需要多个参数，这些参数大多来源于原始存储库中的微调脚本：

LORA_R = 8

LORA_ALPHA = 16

LORA_DROPOUT= 0.05

LORA_TARGET_MODULES = [

    "q_proj",

    "v_proj",

]

 

BATCH_SIZE = 128

MICRO_BATCH_SIZE = 4

GRADIENT_ACCUMULATION_STEPS = BATCH_SIZE // MICRO_BATCH_SIZE

LEARNING_RATE = 3e-4

TRAIN_STEPS = 300

OUTPUT_DIR = "experiments"

我们现在可以准备用于训练的模型：

model = prepare_model_for_int8_training(model)

config = LoraConfig(

    r=LORA_R,

    lora_alpha=LORA_ALPHA,

    target_modules=LORA_TARGET_MODULES,

    lora_dropout=LORA_DROPOUT,

    bias="none",

    task_type="CAUSAL_LM",

)

model = get_peft_model(model, config)

model.print_trainable_parameters()

trainable params: 4194304 || all params: 6742609920 || trainable%: 0.06220594176090199

我们使用LORA算法初始化以准备模型训练，LORA算法是一种量化形式，可以在不显著损失精度的情况下减小模型大小和内存使用量。

LoraConfig是一个类，用于指定LORA算法的超参数，如正则化强度（lora_alpha）、丢弃概率（lora_dropout）以及要压缩的目标模块（target_modules）。

在训练过程中，我们将使用Hugging Face Transformers库中的Trainer类。

training_arguments = transformers.TrainingArguments(

    per_device_train_batch_size=MICRO_BATCH_SIZE,

    gradient_accumulation_steps=GRADIENT_ACCUMULATION_STEPS,

    warmup_steps=100,

    max_steps=TRAIN_STEPS,

    learning_rate=LEARNING_RATE,

    fp16=True,

    logging_steps=10,

    optim="adamw_torch",

    evaluation_strategy="steps",

    save_strategy="steps",

    eval_steps=50,

    save_steps=50,

    output_dir=OUTPUT_DIR,

    save_total_limit=3,

    load_best_model_at_end=True,

    report_to="tensorboard"

)

这段代码创建了一个TrainingArguments对象，该对象指定了训练模型时的各种设置和超参数。这些设置包括：

gradient_accumulation_steps：在进行反向传播/更新之前，累积梯度的更新步骤数。
warmup_steps：优化器的预热步骤数。
max_steps：要执行的总训练步骤数。
learning_rate：优化器的学习率。
fp16：是否使用16位精度进行训练。

data_collator = transformers.DataCollatorForSeq2Seq(

    tokenizer, pad_to_multiple_of=8, return_tensors="pt", padding=True

)

DataCollatorForSeq2Seq是 Transformers 库中的一个类，用于为序列到序列（seq2seq）模型创建输入/输出序列的批次。在这段代码中，我们实例化了一个对象，并使用了以下参数：

pad_to_multiple_of：一个整数，表示最大序列长度，会向上取整到该值的最近倍数。
padding：一个布尔值，指示是否将序列填充到指定的最大长度。

现在我们已经有了所有必要的组件，可以继续进行模型的训练了。

trainer = transformers.Trainer(

    model=model,

    train_dataset=train_data,

    eval_dataset=val_data,

    args=training_arguments,

    data_collator=data_collator

)

model.config.use_cache = False

old_state_dict = model.state_dict

model.state_dict = (

    lambda self, *_, **__: get_peft_model_state_dict(

        self, old_state_dict()

    )

).__get__(model, type(model))

 

model = torch.compile(model)

 

trainer.train()

model.save_pretrained(OUTPUT_DIR)

在实例化Trainer之后，代码将模型配置中的use_cache设置为False，并使用get_peft_model_state_dict()函数为模型创建一个状态字典，该函数通过使用低精度算术来准备模型进行训练。

然后，在模型上调用torch.compile()函数，该函数会编译 model 的计算图，并使用 PyTorch 2 准备进行训练。

在A100上，训练过程大约持续了2个小时。让我们在Tensorboard上查看结果：

训练损失和评估损失似乎都在稳步下降。而且这还只是第一次尝试！

我们将把训练好的模型上传到Hugging Face Model Hub，以便轻松复用：

from huggingface_hub import notebook_login

 

notebook_login()

 

model.push_to_hub("curiousily/alpaca-bitcoin-tweets-sentiment", use_auth_token=True)

推断

我们将首先复制该存储库，然后使用脚本对模型进行测试：generate.py

!git clone https://github.com/tloen/alpaca-lora.git

%cd alpaca-lora

!git checkout a48d947

该脚本启动的Gradio应用程序将使我们能够利用我们模型的权重：

!python generate.py \

    --load_8bit \

    --base_model 'decapoda-research/llama-7b-hf' \

    --lora_weights 'curiousily/alpaca-bitcoin-tweets-sentiment' \

    --share_gradio

以下是我们的应用程序：

让我们一起来测试模型吧！

结论

总之，我们已经成功使用Alpaca LoRa方法对Llama模型进行了微调，使其能够检测比特币推文中的情绪。在这个过程中，我们借助了Hugging Face的Transformers库和datasets库来加载并预处理数据，同时利用Transformers训练器完成了模型的训练。最后，我们将模型部署到了Hugging Face模型库，并展示了如何在Gradio应用程序中使用它。

原文链接：https://www.mlexpert.io/blog/alpaca-fine-tuning