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

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

# For Google Colab settings              from google.colab import userdata, drive              

# 这将提示进行授权              drive.mount('/content/drive')              

# 设置工作目录              %cd '/content/drive/MyDrive/postedBlogs/llama3RE'

from huggingface_hub import login

HF = userdata.get('HF')

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/'

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]

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

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

import os              from groq import Groq              


gclient = Groq(                  api_key=userdata.get("GROQ"),              )

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

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'}

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 AutoTokenizerTokenizertokenizer = 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)

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",              )

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                  )

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()

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

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

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)

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)

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()}")