Qwen2 命名实体识别微调实战指南

其中 text 是输入的文本，entities 是文本抽取出的实体。我们的目标是希望微调后的大模型能够根据由 text 组成的提示词，预测出一个 JSON 格式的实体信息。

现在我们将数据集下载到本地目录。下载方式是前往 HuggingFace 下载 ccfbdci.jsonl 到项目根目录下即可。

3. 加载模型

这里我们使用 modelscope 下载 Qwen2-1.5B-Instruct 模型，然后把它加载到 Transformers 中进行训练：

from modelscope import snapshot_download, AutoTokenizer
from transformers import AutoModelForCausalLM, TrainingArguments, Trainer, DataCollatorForSeq2Seq
import torch

model_id = 'qwen/Qwen2-1.5B-Instruct'
model_dir = './qwen/Qwen2-1___5B-Instruct'

# 在 modelscope 上下载 Qwen 模型到本地目录下
model_dir = snapshot_download(model_id, cache_dir='./', revision='master')

# Transformers 加载模型权重
tokenizer = AutoTokenizer.from_pretrained(model_dir, use_fast=False, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(model_dir, device_map='auto', torch_dtype=torch.bfloat16)
model.enable_input_require_grads()  # 开启梯度检查点时，要执行该方法

4. 配置训练可视化工具

我们使用 SwanLab 来监控整个训练过程，并评估最终的模型效果。这里直接使用 SwanLab 和 Transformers 的集成来实现：

from swanlab.integration.huggingface import SwanLabCallback

swanlab_callback = SwanLabCallback(...)
trainer = Trainer(
    ...
    callbacks=[swanlab_callback],
)

如果你需要使用 SwanLab，需要在用户设置页面复制你的 API Key，然后在训练开始时配置进去。

5. 完整代码

开始训练时的目录结构：

|--- train.py  
|--- ccfbdci.jsonl

train.py:

import json
import pandas as pd
import torch
from datasets import Dataset
from modelscope import snapshot_download, AutoTokenizer
from swanlab.integration.huggingface import SwanLabCallback
from peft import LoraConfig, TaskType, get_peft_model
from transformers import AutoModelForCausalLM, TrainingArguments, Trainer, DataCollatorForSeq2Seq
import os
import swanlab

def dataset_jsonl_transfer(origin_path, new_path):
    '''
    将原始数据集转换为大模型微调所需数据格式的新数据集
    '''
    messages = []
    # 读取旧的 JSONL 文件
    with open(origin_path, 'r') as file:
        for line in file:
            # 解析每一行的 json 数据
            data = json.loads(line)
            input_text = data['text']
            entities = data['entities']
            match_names = ['地点', '人名', '地理实体', '组织']

            entity_sentence = ''
            for entity in entities:
                entity_json = dict(entity)
                entity_text = entity_json['entity_text']
                entity_names = entity_json['entity_names']
                for name in entity_names:
                    if name in match_names:
                        entity_label = name
                        break
                entity_sentence += f"{{'entity_text': '{entity_text}', 'entity_label': '{entity_label}'}}"

            if entity_sentence == '':
                entity_sentence = '没有找到任何实体'

            message = {
                'instruction': '''你是一个文本实体识别领域的专家，你需要从给定的句子中提取 地点; 人名; 地理实体; 组织 实体。以 json 格式输出，如 {'entity_text': '南京', 'entity_label': '地理实体'} 注意：1. 输出的每一行都必须是正确的 json 字符串。2. 找不到任何实体时，输出'没有找到任何实体'。''',
                'input': f'文本:{input_text}',
                'output': entity_sentence,
            }
            messages.append(message)

    # 保存重构后的 JSONL 文件
    with open(new_path, 'w', encoding='utf-8') as file:
        for message in messages:
            file.write(json.dumps(message, ensure_ascii=False)+'\n')

def process_func(example):
    '''
    将数据集进行预处理
    '''
    MAX_LENGTH = 384
    input_ids, attention_mask, labels = [], [], []
    system_prompt = '''你是一个文本实体识别领域的专家，你需要从给定的句子中提取 地点; 人名; 地理实体; 组织 实体。以 json 格式输出，如 {'entity_text': '南京', 'entity_label': '地理实体'} 注意：1. 输出的每一行都必须是正确的 json 字符串。2. 找不到任何实体时，输出'没有找到任何实体'.'''

    instruction = tokenizer(
        f'<|im_start|>system\n{system_prompt}<|im_end|>\n<|im_start|>user\n{example["input"]}<|im_end|>\n<|im_start|>assistant\n',
        add_special_tokens=False,
    )
    response = tokenizer(f'{example["output"]}', add_special_tokens=False)
    input_ids = instruction['input_ids'] + response['input_ids'] + [tokenizer.pad_token_id]
    attention_mask = (
        instruction['attention_mask'] + response['attention_mask'] + [1]
    )
    labels = [-100] * len(instruction['input_ids']) + response['input_ids'] + [tokenizer.pad_token_id]
    if len(input_ids) > MAX_LENGTH:  # 做一个截断
        input_ids = input_ids[:MAX_LENGTH]
        attention_mask = attention_mask[:MAX_LENGTH]
        labels = labels[:MAX_LENGTH]
    return {'input_ids': input_ids, 'attention_mask': attention_mask, 'labels': labels}

def predict(messages, model, tokenizer):
    device = 'cuda'
    text = tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=True
    )
    model_inputs = tokenizer([text], return_tensors='pt').to(device)

    generated_ids = model.generate(
        model_inputs.input_ids,
        max_new_tokens=512
    )
    generated_ids = [
        output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
    ]

    response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
    print(response)
    return response

model_id = 'qwen/Qwen2-1.5B-Instruct'
model_dir = './qwen/Qwen2-1___5B-Instruct'

# 在 modelscope 上下载 Qwen 模型到本地目录下
model_dir = snapshot_download(model_id, cache_dir='./', revision='master')

# Transformers 加载模型权重
tokenizer = AutoTokenizer.from_pretrained(model_dir, use_fast=False, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(model_dir, device_map='auto', torch_dtype=torch.bfloat16)
model.enable_input_require_grads()  # 开启梯度检查点时，要执行该方法

# 加载、处理数据集和测试集
train_dataset_path = 'ccfbdci.jsonl'
train_jsonl_new_path = 'ccf_train.jsonl'

if not os.path.exists(train_jsonl_new_path):
    dataset_jsonl_transfer(train_dataset_path, train_jsonl_new_path)

# 得到训练集
total_df = pd.read_json(train_jsonl_new_path, lines=True)
train_df = total_df[int(len(total_df)*0.1):]
train_ds = Dataset.from_pandas(train_df)
train_dataset = train_ds.map(process_func, remove_columns=train_ds.column_names)

config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    target_modules=['q_proj', 'k_proj', 'v_proj', 'o_proj', 'gate_proj', 'up_proj', 'down_proj'],
    inference_mode=False,  # 训练模式
    r=8,  # Lora 秩
    lora_alpha=32,  # Lora alpha
    lora_dropout=0.1,  # Dropout 比例
)

model = get_peft_model(model, config)

args = TrainingArguments(
    output_dir='./output/Qwen2-NER',
    per_device_train_batch_size=4,
    per_device_eval_batch_size=4,
    gradient_accumulation_steps=4,
    logging_steps=10,
    num_train_epochs=2,
    save_steps=100,
    learning_rate=1e-4,
    save_on_each_node=True,
    gradient_checkpointing=True,
    report_to='none',
)

swanlab_callback = SwanLabCallback(
    project='Qwen2-NER-fintune',
    experiment_name='Qwen2-1.5B-Instruct',
    description='使用通义千问 Qwen2-1.5B-Instruct 模型在 NER 数据集上微调，实现关键实体识别任务。',
    config={
        'model': model_id,
        'model_dir': model_dir,
        'dataset': 'qgyd2021/chinese_ner_sft',
    },
)

trainer = Trainer(
    model=model,
    args=args,
    train_dataset=train_dataset,
    data_collator=DataCollatorForSeq2Seq(tokenizer=tokenizer, padding=True),
    callbacks=[swanlab_callback],
)

trainer.train()

# 用测试集的随机 20 条，测试模型
# 得到测试集
test_df = total_df[:int(len(total_df)*0.1)].sample(n=20)

test_text_list = []
for index, row in test_df.iterrows():
    instruction = row['instruction']
    input_value = row['input']

    messages = [
        {'role': 'system', 'content': f'{instruction}'},
        {'role': 'user', 'content': f'{input_value}'}
    ]

    response = predict(messages, model, tokenizer)
    messages.append({'role': 'assistant', 'content': f'{response}'})
    result_text = f'{messages[0]}\n\n{messages[1]}\n\n{messages[2]}'
    test_text_list.append(swanlab.Text(result_text, caption=response))

swanlab.log({'Prediction': test_text_list})
swanlab.finish()

看到下面的进度条即代表训练开始。

6. 训练结果演示

在可视化平台上查看最终的训练结果：

可以看到在 2 个 epoch 之后，微调后的 qwen2 的 loss 降低到了不错的水平。当然对于大模型来说，真正的效果评估还得看主观效果。

可以看到在一些测试样例上，微调后的 qwen2 能够给出准确的实体抽取结果。

至此，你已经完成了 qwen2 指令微调的训练！

7. 推理训练好的模型

训好的模型默认被保存在 ./output/Qwen2-NER 文件夹下。

推理模型的代码如下：

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel

def predict(messages, model, tokenizer):
    device = 'cuda'

    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    model_inputs = tokenizer([text], return_tensors='pt').to(device)

    generated_ids = model.generate(model_inputs.input_ids, max_new_tokens=512)
    generated_ids = [output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)]
    response = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]

    return response

# 加载原下载路径的 tokenizer 和 model
tokenizer = AutoTokenizer.from_pretrained('./qwen/Qwen2-1___5B-Instruct/', use_fast=False, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained('./qwen/Qwen2-1___5B-Instruct/', device_map='auto', torch_dtype=torch.bfloat16)

# 加载训练好的 Lora 模型，将下面的 [checkpoint-XXX] 替换为实际的 checkpoint 文件名名称
model = PeftModel.from_pretrained(model, model_id='./output/Qwen2-NER/checkpoint-1700')

input_text = '西安电子科技大学的陈志明爱上了隔壁西北工业大学苏春红，他们约定好毕业后去中国的苏州定居。'
test_texts = {
    'instruction': '''你是一个文本实体识别领域的专家，你需要从给定的句子中提取 地点; 人名; 地理实体; 组织 实体。以 json 格式输出，如; {'entity_text': '南京', 'entity_label': '地理实体'} 注意：1. 输出的每一行都必须是正确的 json 字符串。2. 找不到任何实体时，输出'没有找到任何实体'。''',
    'input': f'文本:{input_text}'
}

instruction = test_texts['instruction']
input_value = test_texts['input']

messages = [
    {'role': 'system', 'content': f'{instruction}'},
    {'role': 'user', 'content': f'{input_value}'}
]

response = predict(messages, model, tokenizer)
print(response)

输出结果为：

{'entity_text':'西安电子科技大学','entity_label':'组织'}   
{'entity_text':'陈志明','entity_label':'人名'}   
{'entity_text':'西北工业大学','entity_label':'组织'}   
{'entity_text':'苏春红','entity_label':'人名'}   
{'entity_text':'中国','entity_label':'地理实体'}   
{'entity_text':'苏州','entity_label':'地理实体'}

8. 常见问题与优化建议

显存不足怎么办？

如果显存不足以支撑当前 batch size，可以尝试以下优化：

1. 减小 per_device_train_batch_size 至 2 或 1。
2. 增大 gradient_accumulation_steps 以保持有效 batch size。
3. 启用 gradient_checkpointing（代码中已开启）。
4. 使用 torch.float16 代替 bfloat16（视硬件支持情况）。

模型效果不佳如何调整？

1. 增加训练轮数：适当增加 num_train_epochs，观察 Loss 曲线是否收敛。
2. 调整学习率：尝试 1e-5 或 5e-5 等更小步长的学习率。
3. 数据增强：在数据预处理阶段增加一些同义改写或噪声注入，提高模型鲁棒性。
4. Prompt 优化：调整 system prompt 的描述，使其更明确地定义输出格式。

部署注意事项

1. 量化推理：生产环境中建议使用 INT8 或 FP4 量化模型以降低延迟和显存占用。
2. 并发处理：若需高并发，建议引入 vLLM 或 TGI 等推理框架。
3. 缓存机制：对于重复查询的输入，可建立 Redis 缓存减少计算开销。

总结

本文详细介绍了基于 Qwen2-1.5B-Instruct 大模型进行命名实体识别（NER）指令微调的完整流程。通过 LoRA 技术，我们在有限的显存资源下实现了高效的模型适配。结合可视化工具，我们能够实时监控训练状态并及时调整超参数。掌握这一流程，有助于开发者快速构建垂直领域的 NLP 应用。