文章目录

1. Task Overview2. Overall Workflow3. Dataset 介绍4. 代码介绍4.1 环境介绍4.2 下载 dataset4.3 下载并加载模型4.2 Notebook 代码1）import 部分2）固定 seed3）加载 LLM4）加载 tokenizer5）设置解码参数6）⭐ LLM 和 tokenizer 使用示例7）generate_training_data 和 evaluate 函数8）demo examples9）Hyper Parameters10）model 的量化和 LoRA11）加载 dataset12）Trainer13）模型训练14）运行 test

5. 总结

这个实验主要是 fine-tune 一个 LLM，让一个 LLM 能够写唐诗。

相关链接：

Slides：Slides | Google DriveCode: colabDataset: GitHubVideo: Bilibili

1. Task Overview

给 AI 一首唐诗的前两个 sentences，我们希望它能够完成剩下的部分：

但是，原来的 LLM 可能并不具备这样的能力，我们希望经过 fine tune 之后，它能够最起码接一句像样的诗词：

2. Overall Workflow

LLM 使用 <code>MediaTek-Research/Breeze-7B-Instruct-v0_1：

MediaTek Research Breeze-7B (hereinafter referred to as Breeze-7B) is a language model family that builds on top of Mistral-7B, specifically intended for Traditional Chinese use.

数据集是一堆唐诗，一个 data point 的 example 如下：

总共有 5000 条数据。

微调的思路是：将一个 data point 的 instruction、input 和 output 填入 prompt template 中，形成一个 text，用来训练 LLM。

微调完成后，将 instruction、input 形成一个 prompt 输入给 LLM，让其完成剩下部分的唐诗。

3. Dataset 介绍

dataset 主要包含两个 JSON 文件：

<code>Tang_testing_data.json：测试集，包含 15 条数据Tang_training_data.json：训练集，包含 5001 条数据

其中训练集每一条数据的格式都是前面 example 展示的，而测试集只包含 instruction 和 input 字段，答案在 Tang_testing_gt.txt 文件中：

4. 代码介绍

4.1 环境介绍

Python 3.10，torch 2.3.1

其他依赖如下：

<code>!pip install bitsandbytes==0.43.0

!pip install datasets==2.10.1

!pip install transformers==4.38.2

!pip install peft==0.9.0

!pip install sentencepiece==0.1.99

!pip install -U accelerate==0.28.0

!pip install colorama==0.4.6

具体的代码可以下载课程给的 notebook，并查看其中的代码。

4.2 下载 dataset

git clone https://github.com/CheeEn-Yu/GenAI-Hw5.git

4.3 下载并加载模型

由于从 HuggingFace 下载模型可能会失败，所以可以从镜像站先下载模型：

HuggingFace 镜像站：https://hf-mirror.com/

这里介绍如何使用 huggingface-cli 下载模型。

安装依赖：pip install -U huggingface_hub设置 mirror 环境变量：export HF_ENDPOINT=https://hf-mirror.com设置 huggingface 的缓存目录：export HF_HOME=/root/autodl-tmp/cache/下载模型：huggingface-cli download --resume-download MediaTek-Research/Breeze-7B-Instruct-v0_1

下载完成后，可以在目录中看到下载的预训练模型：

所在的目录就是 <code>${HF_HOME}/hub/ 中，之后代码需要从这个目录中加载模型。

4.2 Notebook 代码

1）import 部分

import os

import sys

import argparse

import json

import warnings

import logging

warnings.filterwarnings("ignore")

import torch

import torch.nn as nn

import bitsandbytes as bnb

from datasets import load_dataset, load_from_disk

import transformers, datasets

from peft import PeftModel

from colorama import *

from tqdm import tqdm

from transformers import AutoTokenizer, AutoConfig, AutoModelForCausalLM, BitsAndBytesConfig

from transformers import GenerationConfig

from peft import (

prepare_model_for_int8_training,

LoraConfig,

get_peft_model,

get_peft_model_state_dict,

prepare_model_for_kbit_training

)

2）固定 seed

固定住 seed 从而防止训练的不确定性：

seed = 42

torch.backends.cudnn.deterministic = True

torch.backends.cudnn.benchmark = False

torch.manual_seed(seed)

if torch.cuda.is_available():

torch.cuda.manual_seed_all(seed)

3）加载 LLM

这里使用 transformers 库的 AutoModelForCausalLM 来加载模型，并需要将 cache_dir 设置为下载的模型的目录。

cache_dir = "/root/autodl-tmp/cache/hub"

nf4_config = BitsAndBytesConfig(

load_in_4bit=True,

bnb_4bit_quant_type="nf4",code>

bnb_4bit_use_double_quant=True,

bnb_4bit_compute_dtype=torch.bfloat16

)

# 從指定的模型名稱或路徑載入預訓練的語言模型

model = AutoModelForCausalLM.from_pretrained(

model_name,

cache_dir=cache_dir,

quantization_config=nf4_config,

low_cpu_mem_usage = True

)

4）加载 tokenizer

tokenizer 分词的结果 <code>inputs 包含两个字段：

input_ids：size 为 [batch，分词后 tokens 的个数]，其中的每个元素是分词后的 token 在词表中的 token idattention_mask：size 与 input_ids 一样，元素值为 0/1，1 代表这个 token 有用，0 代表无用

为了验证一下，我们将 tokenizer 分词的结果中前面几个 token id 交给 tokenizer.convert_ids_to_token() 方法来将 token ids 转为字符串，可以看到这就是 prompt 的前几个字符。

attention_mask 的用处是：当 batch 大于 1 时，每一行元素的长度值是分词后字符数量最大的，比如两行 text 做分词，一行被分为 10 个 token，一行被分为 20 个 token，那么分词后的 input_ids 和 attention_mask 的 size 为 [2, 20]，attention_mask[0] 就是前 10 个元素为 1，后 10 个为 0，attention_mask[1] 就是全部为 1。

现在我们可以把 input_ids 交给 LLM 做文本生成：

model_output = model.generate(

input_ids=input_ids,

generation_config=generation_config,

return_dict_in_generate=True,

output_scores=True,

max_new_tokens=max_len,

)

输出的结果也是一堆 token ids：

我们把这个 output 交给 tokenizer 做 decode 看一下结果：

7）generate_training_data 和 evaluate 函数

这里实现了两个重要的函数：

<code>generate_training_data()：输入一个包含 instruction、input 和 output 三个字段的 data point，将他们组成 prompt 并使用 tokenizer 分词，输出包含 input_ids 和 attention_mask 字段的 dict，这样的 dict 可以作为 transformers 库的 Trainer 用来训练 CasualLM 的样本。evalute()：输入 instruction、input、decoding params，输出 LLM 的响应

具体的代码实现上，就是使用上面示例的思路。代码的实现如下：

# 生成訓練資料

def generate_training_data(data_point):

"""

(1) Goal:

- This function is used to transform a data point (input and output texts) to tokens that our model can read

(2) Arguments:

- data_point: dict, with field "instruction", "input", and "output" which are all str

(3) Returns:

- a dict with model's input tokens, attention mask that make our model causal, and corresponding output targets

(3) Example:

- If you construct a dict, data_point_1, with field "instruction", "input", and "output" which are all str, you can use the function like this:

formulate_article(data_point_1)

"""

# construct full input prompt

prompt = f"""\

[INST] <<SYS>>

You are a helpful assistant and good at writing Tang poem. 你是一個樂於助人的助手且擅長寫唐詩。

<</SYS>>

{ data_point["instruction"]}

{ data_point["input"]}

[/INST]"""

# count the number of input tokens

len_user_prompt_tokens = (

len(

tokenizer(

prompt,

truncation=True,

max_length=CUTOFF_LEN + 1,

padding="max_length",code>

)["input_ids"]

) - 1

)

# transform input prompt into tokens

full_tokens = tokenizer(

prompt + " " + data_point["output"] + "</s>",

truncation=True,

max_length=CUTOFF_LEN + 1,

padding="max_length",code>

)["input_ids"][:-1]

return {

"input_ids": full_tokens,

"labels": [-100] * len_user_prompt_tokens

+ full_tokens[len_user_prompt_tokens:],

"attention_mask": [1] * (len(full_tokens)),

}

# 進行生成回覆的評估

def evaluate(instruction, generation_config, max_len, input="", verbose=True):code>

"""

(1) Goal:

- This function is used to get the model's output given input strings

(2) Arguments:

- instruction: str, description of what you want model to do

- generation_config: transformers.GenerationConfig object, to specify decoding parameters relating to model inference

- max_len: int, max length of model's output

- input: str, input string the model needs to solve the instruction, default is "" (no input)

- verbose: bool, whether to print the mode's output, default is True

(3) Returns:

- output: str, the mode's response according to the instruction and the input

(3) Example:

- If you the instruction is "ABC" and the input is "DEF" and you want model to give an answer under 128 tokens, you can use the function like this:

evaluate(instruction="ABC", generation_config=generation_config, max_len=128, input="DEF")code>

"""

# construct full input prompt

prompt = f"""\

[INST] <<SYS>>

You are a helpful assistant and good at writing Tang poem. 你是一個樂於助人的助手且擅長寫唐詩。

<</SYS>>

{ instruction}

{ input}

[/INST]"""

# 將提示文本轉換為模型所需的數字表示形式

inputs = tokenizer(prompt, return_tensors="pt")code>

input_ids = inputs["input_ids"].cuda() # 分词后的所有 tokens 的 ids，size：[1, tokens长度]

# 使用模型進行生成回覆

generation_output = model.generate(

input_ids=input_ids,

generation_config=generation_config,

return_dict_in_generate=True,

output_scores=True,

max_new_tokens=max_len,

)

# 將生成的回覆解碼並印出

for s in generation_output.sequences:

output = tokenizer.decode(s)

output = output.split("[/INST]")[1].replace("</s>", "").replace("<s>", "").replace("Assistant:", "").replace("Assistant", "").strip()

if (verbose):

print(output)

return output

8）demo examples