GLM4 大模型微调实战：命名实体识别（NER）任务指南

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

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

3. 加载模型

这里我们使用 modelscope 下载 GLM4-9b-Chat 模型（modelscope 在国内，所以直接用下面的代码自动下载即可，不用担心速度和稳定性问题），然后把它加载到 Transformers 中进行训练：

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

model_id = "ZhipuAI/glm-4-9b-chat"
model_dir = "./ZhipuAI/glm-4-9b-chat/"

# 在 modelscope 上下载 GLM4 模型到本地目录下
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, trust_remote_code=True)
model.enable_input_require_grads()  # 开启梯度检查点时，要执行该方法

量化选项说明： 如果显存紧张，可以考虑使用 load_in_8bit=True 或 load_in_4bit=True 进行量化加载，但需注意这可能会轻微影响微调效果。

4. 配置 LoRA

LoRA (Low-Rank Adaptation) 是一种高效的参数微调方法，它冻结预训练模型的所有参数，仅训练少量的低秩适配器参数。

from peft import LoraConfig, TaskType, get_peft_model

config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    target_modules=["query_key_value", "dense", "dense_h_to_4h", "activation_func", "dense_4h_to_h"],
    inference_mode=False,  # 训练模式
    r=8,  # Lora 秩
    lora_alpha=32,  # Lora alpha，具体作用参见 Lora 原理
    lora_dropout=0.1,  # Dropout 比例
)

model = get_peft_model(model, config)

Target Modules 选择： 对于 GLM4 架构，通常需要对 Attention 层和 MLP 层的关键模块进行适配。上述配置覆盖了主要的线性变换层，能够有效捕捉任务特定的特征。

5. 配置训练可视化工具

我们使用 SwanLab 来监控整个训练过程，并评估最终的模型效果。

这里直接使用 SwanLab 和 Transformers 的集成来实现：

from swanlab.integration.huggingface import SwanLabCallback

swanlab_callback = SwanLabCallback(...)

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

如果你是第一次使用 SwanLab，那么还需要去官网注册一个账号，在用户设置页面复制你的 API Key，然后在训练开始时粘贴进去即可。

6. 完整代码

开始训练时的目录结构：

|--- 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):
    """
    对数据集进行数据预处理，主要用于被 dataset.map 调用
    """

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

    instruction = tokenizer(
        f"<|system|>\n{system_prompt}<|endoftext|>\n<|user|>\n{example['input']}<|endoftext|>\n<|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 = "ZhipuAI/glm-4-9b-chat"
model_dir = "./ZhipuAI/glm-4-9b-chat/"

# 在 modelscope 上下载 GLM4 模型到本地目录下
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, trust_remote_code=True)
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)

# 配置 LoRA
config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    target_modules=["query_key_value", "dense", "dense_h_to_4h", "activation_func", "dense_4h_to_h"],
    inference_mode=False,  # 训练模式
    r=8,  # Lora 秩
    lora_alpha=32,  # Lora alpha，具体作用参见 Lora 原理
    lora_dropout=0.1,  # Dropout 比例
)

# 得到被 peft 包装后的模型
model = get_peft_model(model, config)

# 配置 Transformers 训练参数
args = TrainingArguments(
    output_dir="./output/GLM4-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 与 Transformers 的回调
swanlab_callback = SwanLabCallback(
    project="GLM4-NER-fintune",
    experiment_name="GLM4-9B-Chat",
    description="使用智谱 GLM4-9B-Chat 模型在 NER 数据集上微调，实现关键实体识别任务。",
    config={
        "model": model_id,
        "model_dir": model_dir,
        "dataset": "qgyd2021/chinese_ner_sft",
    },
)

# 设置 Transformers Trainer
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 记录
swanlab.finish()

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

7. 训练结果演示

在 SwanLab 上查看最终的训练结果：

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

可以看到在一些测试样例上，微调后的 GLM4 能够给出准确的 NER 结果：

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

8. 推理训练好的模型

训好的模型默认被保存在 ./output/GLM4-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

model_dir = "./ZhipuAI/glm-4-9b-chat/"
lora_dir = "./output/GLM4-NER/checkpoint-1700"

# 加载原下载路径的 tokenizer 和 model
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)

# 加载训练好的 Lora 模型
model = PeftModel.from_pretrained(model, model_id=lora_dir)

input_text = "西安电子科技大学的陈志明爱上了隔壁西北工业大学苏春红，他们约定好毕业后去中国的苏州定居。"
test_texts = {
    "instruction": """你是一个文本实体识别领域的专家，你需要从给定的句子中提取 地点; 人名; 地理实体; 组织 实体。以 json 格式输出，如; {"entity_text": "南京", "地理实体"} 注意：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": "地理实体"}

9. 最佳实践与常见问题

超参数调整建议

• Learning Rate: 1e-4 是一个较好的起点，如果 Loss 震荡可以尝试降低到 5e-5。
• Batch Size: 如果显存允许，增大 batch size 有助于稳定训练，配合 gradient accumulation 使用。
• Epochs: 2 个 epoch 可能不足以收敛，建议观察验证集 Loss，若下降趋势明显可继续训练至 3-5 个 epoch。

数据质量优化

• 确保输入文本长度适中，避免过长的上下文导致注意力分散。
• 对于实体标注不一致的数据，建议在预处理阶段进行清洗。

部署注意事项

• 生产环境中，建议将 LoRA 权重合并回主模型，以减少推理延迟。
• 使用 torch.compile 可以进一步提升推理速度。

10. 总结

本文详细介绍了基于 GLM4-9b-Chat 大模型进行命名实体识别（NER）指令微调的完整流程。通过 LoRA 技术降低显存占用，使用 SwanLab 监控训练过程。内容涵盖环境搭建、数据集准备与转换、模型加载、LoRA 配置、训练参数设置及推理测试。提供了完整的 Python 代码示例，帮助开发者快速上手大模型垂直领域微调。