Llama3 微调，增强知识图谱关系抽取（附微调数据集和代码）

导读

通过阅读本文你能够：

1. 了解如何微调 Llama3增强知识图谱关系抽取

2. 获取微调代码数据集&代码

通过使用 Llama3–70B 创建的合成数据集对 Llama3–8B 进行微调，增强关系抽取

关系抽取（RE）是从非结构化文本中提取关系，以识别各种命名实体之间的联系的任务。它与命名实体识别（NER）一起完成，并且是自然语言处理流程中的一个基本步骤。

随着大型语言模型（LLMs）的兴起，传统的监督方法涉及标记实体范围和分类它们之间的关系（如果有的话）的方法得到增强或完全被基于LLM的方法所取代

Llama3 是生成式AI领域最新的重大发布

基础模型有两种规模，8B和70B，预计将很快发布400B模型。

这些模型可以在HuggingFace平台上获得。70B变体为Meta的新聊天网站Meta.ai提供支持，并且表现与ChatGPT相当。

8B模型是其类别中性能最好的之一。Llama3的架构类似于Llama2，性能提升主要是由于数据升级。该模型配备了升级的分词器和扩展的上下文窗口。它被标记为开源，尽管只有一小部分数据被发布。总的来说，这是一个出色的模型，而且，开源。

Teacher and Student

Llama3-70B可以产生惊人的结果，但由于其规模，它在本地系统上使用起来不切实际，成本昂贵且难以使用。

因此，为了利用其能力，我们让Llama3-70B教会较小的Llama3-8B从非结构化文本中提取关系的任务。

具体来说，借助Llama3-70B的帮助，我们构建了一个旨在进行关系抽取的监督微调数据集。然后，我们使用这个数据集对Llama3-8B进行微调，以增强其关系抽取能力。

要在与此文相关的Google Colab笔记本中复制代码，你需要：

1. HuggingFace token（用于保存微调模型，可选）和Llama3访问权限，可以通过遵循其中一个模型卡片上的说明来获取

2. 免费的GroqCloud账户（您可以使用Google账户登录）和相应的API key

P.S. 搞AI模型的都应该有以上账户， 如果你没有，应该反思了。。。

工作区设置

对于这个项目，我使用了配备 A100 GPU 和高内存设置的 Google Colab Pro（可以买个pro账号，也不贵）

首先安装所有所需的库：

!pip install -q groq`              `!pip install -U accelerate bitsandbytes datasets evaluate`               `!pip install -U peft transformers trl

注意到，整个设置从一开始就可以正常工作，没有任何依赖问题或需要从源代码安装 transformers，尽管模型是新的。

需要给予 Google Colab 对驱动器和文件的访问权限，并设置工作目录：

# For Google Colab settings`              `from google.colab import userdata, drive`              `   ``   ``# 这将提示进行授权`              `drive.mount('/content/drive')`              `   ``   ``# 设置工作目录`              `%cd '/content/drive/MyDrive/postedBlogs/llama3RE'

对于那些希望将模型上传到 HuggingFace Hub 的人，我们需要上传 Hub 凭据。在我的情况下，这些凭据存储在 Google Colab 的key中，可以通过左侧的键按钮访问。这一步是可选的。

Hugging Face Hub 设置

from huggingface_hub import login

上传 HuggingFace token（应具有写入权限）从 Colab secrets

HF = userdata.get('HF')

上传模型到 HuggingFace

login(token=HF,add_to_git_credential=True)

我还添加了一些路径变量来简化文件访问：

# 为数据文件夹创建一个路径变量`            `data_path = '/content/drive/MyDrive/postedBlogs/llama3RE/datas/'`                        `# 完整的微调数据集`            `sft_dataset_file = f'{data_path}sft_train_data.json'`                        `# Data collected from the the mini-test`            `mini_data_path = f'{data_path}mini_data.json'`            `   ``# 测试数据包含所有三个输出`            `all_tests_data = f'{data_path}all_tests.json'`            `# 调整后的训练数据集`            `train_data_path = f'{data_path}sft_train_data.json'`                       `# 创建一个路径变量，用于将SFT模型保存到本地`            `sft_model_path = '/content/drive/MyDrive/llama3RE/Llama3_RE/'

                现在我们的工作空间已经设置好，我们可以继续第一步，即为关系抽取任务构建一个合成数据集。                      **使用 Llama3–70B 创建一个用于关系抽取的合成数据集**                       目前有几个关系抽取数据集可供使用，其中最著名的是:

CoNLL04. (https://paperswithcode.com/dataset/conll04)数据集。

此外，还有一些出色的数据集，比如在HuggingFace上可用的web_nlg，以及由AllenAI开发的SciREX。然而，大多数这些数据集都带有限制性许可。 受`web_nlg`数据集格式的启发，我们将构建自己的数据集。如果我们计划对在我们的数据集上训练的模型进行微调，这种方法将特别有用。首先，我们需要一系列用于关系抽取任务的短句子。我们可以以各种方式编制这个语料库。 收集一系列句子

我们将使用databricks-dolly-15k

https://huggingface.co/datasets/databricks/databricks-dolly-15k)，

这是由Databricks员工在2023年生成的开源数据集。该数据集旨在进行监督微调，包括四个特征：指令、上下文、响应和类别。在分析了八个类别之后，我决定保留`information_extraction`类别中上下文的第一句话。数据解析步骤如下所示：

from datasets import load_dataset`    `加载数据集``dataset = load_dataset("databricks/databricks-dolly-15k")``选择数据集中所需的类别``ie_category = [e for e in dataset["train"] if e["category"]=="information_extraction"]`    `保留每个实例的上下文``ie_context = [e["context"] for e in ie_category]``将文本分割成句子（在句号处），并保留第一句话``reduced_context = [text.split('.')[0] + '.' for text in ie_context]``仅保留指定长度的序列（使用字符长度）``sampler = [e for e in reduced_context if 30 < len(e) < 170]

选择过程产生了一个包含1,041个句子的数据集。鉴于这是一个迷你项目，我没有手动挑选句子，因此，一些样本可能并不理想适合我们的任务。在一个专门用于生产的项目中，我会仔细挑选只有最合适的句子。然而，对于这个项目的目的，这个数据集将足够。

格式化数据

我们首先需要创建一个系统消息，该消息将定义输入提示并指示模型如何生成答案：

system_message = """您是一位经验丰富的注释者。`              `从以下文本中提取所有实体及其之间的关系。`             `将答案写成三元组实体1|关系|实体2。`             `不要添加其他内容。`             `示例文本：Alice is from France.`              `答案：Alice|is from|France.`              `"""

由于这是实验阶段，我将对模型的要求保持在最低限度。我确实测试了几个其他提示，包括一些要求以CoNLL格式输出的提示，其中实体被分类，模型表现得相当不错。

但是，为了简单起见，现在我们将坚持基本原则。

我们还需要将数据转换为对话格式：

`messages = [[              ``     {"role": "system","content": f"{system_message}"},               ``{"role": "user", "content": e}] for e in sampler]`  

Groq 客户端和 API

Llama3 刚刚发布了几天，API 选项的可用性仍然有限。

虽然 Llama3–70B 提供了聊天界面，但这个项目需要一个能够用几行代码处理我的 1,000 个句子的 API。

以下解释了如何免费使用 GroqCloud API。更多详情请参考视频。

提醒一下：需要登录并从 GroqCloud 网站检索免费的 API 密钥。

我的 API 密钥已经保存在 Google Colab 的 secrets 中。

首先初始化 Groq 客户端：

import os`              `from groq import Groq`              `   ``   ``   ``gclient = Groq(              ``api_key=userdata.get("GROQ"),`              `)

接下来，我们需要定义一些辅助函数，这些函数将使我们能够有效地与 Meta.ai 聊天界面进行交互

import time

from tqdm import tqdm

def process_data(prompt):

"""发送一个请求并检索模型的生成内容。"""              

chat\_completion = gclient.chat.completions.create(              

    messages=prompt, # 发送给模型的输入提示              

    model="llama3-70b-8192", # 根据 GroqCloud 标签              

    temperature=0.5, # 控制多样性              

    max\_tokens=128, # 生成的最大标记数              

    top\_p=1, # 考虑的可能性加权选项的比例              

    stop=None, # 表示停止生成的字符串              

    stream=False, # 如果设置，将发送部分消息              

)              

return chat\_completion.choices\[0\].message.content                  

def send_messages(messages):`              `   ``   ``   `    `"""以批处理的方式处理消息，并在批处理之间暂停。"""`              `   `   `batch_size = 10``answers = []`              `   ``   ``   `    `for i in tqdm(range(0, len(messages), batch_size)): # 每批处理 10 条消息`              `   ``   ``   `        `batch = messages[i:i+10]  # 获取下一批消息`              `   ``   ``   `        `for message in batch:``             output = process_data(message)               ``answers.append(output)`              `   ``   ``   `        `if i + 10 < len(messages):  # 检查是否还有批次``time.sleep(10)  # 等待 10 秒`              `   ``   ``   `    `return answers

第一个函数 process_data() 作为 Groq 客户端的聊天完成函数的包装器。第二个函数 send_messages() 以小批量处理数据。如果您在 Groq 游乐场页面上跟随设置链接，您将找到一个指向 Limits 的链接，其中详细说明了我们可以使用免费 API 的条件，包括对请求和生成的标记数量的限制。为了避免超出这些限制，我在每批处理 10 条消息后添加了 10 秒的延迟，尽管在我的情况下这并不是严格必要的。您可能希望尝试这些设置。

现在剩下的就是生成我们的关系抽取数据并将其与初始数据集集成：

输出:

使用 Llama3-70B 进行数据生成

answers = send_messages(messages)

将输入数据与生成的数据集合并

combined_dataset = [{‘text’: user, ‘gold_re’: output} for user, output in zip(sampler, answers)]

评估 Llama3–8B 对关系抽取的性能

在进行模型的微调之前，重要的是对其在几个样本上的性能进行评估，以确定是否确实需要进行微调。

构建测试数据集

我们将从刚刚构建的数据集中选择 20 个样本并将它们设置为测试集。数据集的其余部分将用于微调。

import random`                `random.seed(17)`                `   ``   ``   ``# 选择 20 个随机条目`                `mini_data = random.sample(combined_dataset, 20)`                `   ``   ``   ``# 构建对话格式`                `parsed_mini_data = [[{'role': 'system', 'content': system_message},                ``{'role': 'user', 'content': e['text']}] for e in mini_data]`                `   ``   ``   `` ```python `                `{'text': 'Long before any knowledge of electricity existed, people were aware of shocks from electric fish.',                ``  'gold_re': 'people|were aware of|shocks\nshocks|from|electric fish\nelectric fish|had|electricity',                 `` 'test_re': 'electric fish|were aware of|shocks'}

对于完整的测试数据集，请参考Google Colab笔记本。

仅从这个例子中，就可以清楚地看出Llama3-8B在其关系抽取能力方面有待改进。让我们努力提升它。

Llama3–8B的监督微调

我们将利用一整套技术来辅助我们，包括 QLoRA 和 Flash Attention。我不会在这里深入讨论选择超参数的具体细节，但如果你对进一步探索感兴趣，可以查看这些参考资料[4]和[5]。

A100 GPU 支持 Flash Attention 和 bfloat16，并且具有约40GB的内存，这对我们的微调需求是足够的。

准备 SFT 数据集

我们首先将数据集解析为对话格式，包括系统消息、输入文本和期望的答案，我们从 Llama3–70B 生成中获取。然后将其保存为 HuggingFace 数据集：

def create_conversation(sample):                ``     return {                 ``         "messages": [                 ``             {"role": "system","content": system_message},                 ``             {"role": "user", "content": sample["text"]},                 ``             {"role": "assistant", "content": sample["gold_re"]}                 ``         ]                 ``}`                `   ``   ``   ``from datasets import load_dataset, Dataset`                `   ``   ``   ``train_dataset = Dataset.from_list(train_data)

转换为口语化格式

train_dataset = train_dataset.map(create_conversation,`            `   ``   ` `remove_columns=train_dataset.features,`            `   ``   ` `batched=False)

选择模型

model_id  =  "meta-llama/Meta-Llama-3-8B"

加载分词器

from transformers import AutoTokenizer``Tokenizer``tokenizer = AutoTokenizer.from_pretrained(model_id,`            `   ``   ` `use_fast=True,`            `   ``   ` `trust_remote_code=True)``tokenizer.pad_token = tokenizer.eos_token`            `tokenizer.pad_token_id = tokenizer.eos_token_id`            `tokenizer.padding_side = 'left'

设置最大长度

tokenizer.model_max_length = 512

选择量化参数

from transformers import BitsAndBytesConfig`              `   ``   ``   ``bnb_config = BitsAndBytesConfig(              ``     load_in_4bit=True,               ``     bnb_4bit_use_double_quant=True,               ``     bnb_4bit_quant_type="nf4",               ``bnb_4bit_compute_dtype=torch.bfloat16`              `)

加载模型

from transformers import AutoModelForCausalLM`              `from peft import prepare_model_for_kbit_training`              `from trl import setup_chat_format`              `   ``   ``   ``device_map = {"": torch.cuda.current_device()} if torch.cuda.is_available() elseNone`              `   ``   ``   ``model = AutoModelForCausalLM.from_pretrained(              ``     model_id,               ``     device_map=device_map,               ``     attn_implementation="flash_attention_2",               ``quantization_config=bnb_config`              `)`              `   ``   ``   ``model, tokenizer = setup_chat_format(model, tokenizer)`              `model = prepare_model_for_kbit_training(model)

LoRA 配置

from peft import LoraConfig`              `   ``   `             `# 根据Sebastian Raschka的研究结果`              `peft_config = LoraConfig(              ``         lora_alpha=128, #32               ``         lora_dropout=0.05,               ``         r=256,  #16               ``         bias="none",               ``         target_modules=["q_proj", "o_proj", "gate_proj", "up_proj",                ``           "down_proj", "k_proj", "v_proj"],               ``task_type="CAUSAL_LM",`              `)

当目标是所有线性层时，可以获得最佳结果。如果内存限制是一个问题，选择更标准的值，如alpha=32和rank=16可能是有益的，因为这些设置会导致参数大大减少。

         **训练参数**                          

from transformers import TrainingArguments``# 适应自 Phil Schmid 博客文章`              `args = TrainingArguments(              ``     output_dir=sft_model_path,              # 保存模型和存储库 ID 的目录               ``     num_train_epochs=2,                     # 训练周期数               ``     per_device_train_batch_size=4,          # 训练期间每个设备的批处理大小               ``     gradient_accumulation_steps=2,          # 执行向后/更新传递之前的步骤数               ``     gradient_checkpointing=True,            # 使用梯度检查点以节省内存，在分布式训练中使用               ``     optim="adamw_8bit",                     # 如果内存不足，请选择 paged_adamw_8bit               ``     logging_steps=10,                       # 每 10 步记录一次日志               ``     save_strategy="epoch",                  # 每个周期保存检查点               ``     learning_rate=2e-4,                     # 学习率，基于 QLoRA 论文               ``     bf16=True,                              # 使用 bfloat16 精度               ``     tf32=True,                              # 使用 tf32 精度               ``     max_grad_norm=0.3,                      # 基于 QLoRA 论文的最大梯度范数               ``     warmup_ratio=0.03,                      # 基于 QLoRA 论文的预热比例               ``     lr_scheduler_type="constant",           # 使用恒定学习率调度程序               ``     push_to_hub=True,                       # 将模型推送到 Hugging Face hub               ``     hub_model_id="llama3-8b-sft-qlora-re",               ``     report_to="tensorboard",               # 报告指标到 tensorboard               ``    )

如果选择在本地保存模型，可以省略最后三个参数。您还可能需要调整 per_device_batch_size 和 gradient_accumulation_steps 以防止内存不足（OOM）错误。

from trl import SFTTrainer`              `   ``   ``   ``trainer = SFTTrainer(              ``     model=model,               ``     args=args,               ``     train_dataset=sft_dataset,               ``     peft_config=peft_config,               ``     max_seq_length=512,               ``     tokenizer=tokenizer,               ``     packing=False, # True if the dataset is large               ``     dataset_kwargs={               ``         "add_special_tokens": False,  # the template adds the special tokens               ``         "append_concat_token": False, # no need to add additional separator token               ``}`              `)`              `   ``   ``   ``trainer.train()`              `trainer.save_model()``   

训练，包括模型保存，大约花了10分钟。

让我们清除内存，为推理测试做准备。如果您使用的是内存较少的 GPU，并遇到 CUDA 内存不足 (OOM) 错误，您可能需要重新启动运行时。

import torch`              `import gc`              `del model`              `del tokenizer`              `gc.collect()`              `torch.cuda.empty_cache()

使用 SFT 模型进行推理

在这最后一步中，我们将加载半精度的基础模型，以及 Peft 适配器。对于这个测试，我选择不将模型与适配器合并。

from peft import AutoPeftModelForCausalLM`              `from transformers import AutoTokenizer, pipeline`              `import torch

HF 模型

peft_model_id = "solanaO/llama3-8b-sft-qlora-re"``# 使用 PEFT 适配器加载模型`            `model = AutoPeftModelForCausalLM.from_pretrained(            ``   peft_model_id,             ``   device_map="auto",             ``   torch_dtype=torch.float16,             ``offload_buffers=True`            `)

接下来，我们加载分词器：

tokenizer = AutoTokenizer.from_pretrained(peft_model_id)`            `   ``   ``   ``tokenizer.pad_token = tokenizer.eos_token`            `tokenizer.pad_token_id =  tokenizer.eos_token_id

然后我们构建文本生成管道：

pipe = pipeline("text-generation", model=model, tokenizer=tokenizer)

我们加载测试数据集，其中包括我们之前设置的 20 个样本，并以对话式格式对数据进行格式化。但是，这次我们省略了助手消息，并将其格式化为 Hugging Face 数据集：

def create_input_prompt(sample):            ``     return {             ``         "messages": [             ``             {"role": "system","content": system_message},             ``             {"role": "user", "content": sample["text"]},             ``         ]             ``}`            `   ``from datasets import Dataset`            `   ``   ``   ``test_dataset = Dataset.from_list(mini_data)

转换为口语化格式

test_dataset = test_dataset.map(create_input_prompt,`            `   ``   ` `remove_columns=test_dataset.features,`            `   ``   ` `batched=False)

样本测试

让我们使用 SFT Llama3–8B 生成关系抽取输出，并将其与之前的两个输出在单个实例上进行比较：

生成输入提示

prompt = pipe.tokenizer.apply_chat_template(test_dataset[2]["messages"][:2],                                                          tokenize=False,                                                          add_generation_prompt=True)                  Output:              ```markdown              # 生成输出              outputs = pipe(prompt,                            max_new_tokens=128,                            do_sample=False,                            temperature=0.1,                            top_k=50,                            top_p=0.1,                            )# 显示结果              print(f"问题: {test_dataset[2]['messages'][1]['content']}\n")              print(f"Gold-RE: {test_sampler[2]['gold_re']}\n")              print(f"LLama3-8B-RE: {test_sampler[2]['test_re']}\n")              print(f"SFT-Llama3-8B-RE: {outputs[0]['generated_text'][len(prompt):].strip()}")

我们发现，通过微调，Llama3-8B的关系提取能力显著提高。尽管微调数据集既不是非常干净，也不是特别大，但结果很不错。

有关20个样本数据集的完整结果，请参阅Google Colab notebook。请注意，推断测试需要更长时间，因为我们以半精度加载模型。

结论

总之，通过利用Llama3-70B和一个可用的数据集，我们成功地创建了一个合成数据集，然后用它来对Llama3-8B进行特定任务的微调。这个过程不仅使我们熟悉了Llama3，还使我们能够应用来自Hugging Face的简单技术。我们观察到，与Llama2密切合作的经验与Llama3非常相似，显著改进的地方是增强了输出质量和更有效的分词器。 对于那些有兴趣进一步挑战界限的人，可以考虑用更复杂的任务来挑战模型，比如对实体和关系进行分类，并利用这些分类来构建知识图谱。

那么，如何系统的去学习大模型LLM？

我在一线互联网企业工作十余年里，指导过不少同行后辈。帮助很多人得到了学习和成长。

作为一名热心肠的互联网老兵，我意识到有很多经验和知识值得分享给大家，也可以通过我们的能力和经验解答大家在大模型的学习中的很多困惑，所以在工作繁忙的情况下还是坚持各种整理和分享。

但苦于知识传播途径有限，很多互联网行业朋友无法获得正确的资料得到学习提升，故此将并将重要的AI大模型资料包括AI大模型入门学习思维导图、精品AI大模型学习书籍手册、视频教程、实战学习等录播视频免费分享出来。

所有资料 ⚡️ ，朋友们如果有需要全套 《AI大模型入门+进阶学习资源包**》，扫码获取~

篇幅有限，部分资料如下：

👉LLM大模型学习指南+路线汇总👈

💥大模型入门要点，扫盲必看！

💥既然要系统的学习大模型，那么学习路线是必不可少的，这份路线能帮助你快速梳理知识，形成自己的体系。

路线图很大就不一一展示了 （文末领取）

👉大模型入门实战训练👈

💥光学理论是没用的，要学会跟着一起做，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

👉国内企业大模型落地应用案例👈

💥两本《中国大模型落地应用案例集》 收录了近两年151个优秀的大模型落地应用案例，这些案例覆盖了金融、医疗、教育、交通、制造等众多领域，无论是对于大模型技术的研究者，还是对于希望了解大模型技术在实际业务中如何应用的业内人士，都具有很高的参考价值。 （文末领取）

👉GitHub海量高星开源项目👈

💥收集整理了海量的开源项目，地址、代码、文档等等全都下载共享给大家一起学习！

👉LLM大模型学习视频👈

💥观看零基础学习书籍和视频，看书籍和视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。 （文末领取）

👉640份大模型行业报告（持续更新）👈

💥包含640份报告的合集，涵盖了AI大模型的理论研究、技术实现、行业应用等多个方面。无论您是科研人员、工程师，还是对AI大模型感兴趣的爱好者，这套报告合集都将为您提供宝贵的信息和启示。

👉获取方式：

这份完整版的大模型 LLM 学习资料已经上传优快云，朋友们如果需要可以微信扫描下方优快云官方认证二维码免费领取【保证100%免费】

😝有需要的小伙伴，可以Vx扫描下方二维码免费领取🆓