指令微调 vs 对话微调：Chat Template

两种微调范式

理解两种微调范式的本质区别，有助于为你的任务选择合适的方法：

主流 Chat Template 格式详解

ChatML 格式（Qwen2、Mistral-Instruct 常用）

<|im_start|>system
你是一个专业的法律助手。<|im_end|>
<|im_start|>user
什么是合同违约？<|im_end|>
<|im_start|>assistant
合同违约是指合同一方当事人不履行合同义务或履行不符合约定的行为...<|im_end|>
<|im_start|>user
能举个具体例子吗？<|im_end|>
<|im_start|>assistant
当然，比如甲方与乙方约定在某日交付货物...<|im_end|>

Llama 3 格式（Meta-Llama-3.x 系列）

<|begin_of_text|><|start_header_id|>system<|end_header_id|>

你是一个专业的法律助手。<|eot_id|><|start_header_id|>user<|end_header_id|>

什么是合同违约？<|eot_id|><|start_header_id|>assistant<|end_header_id|>

合同违约是指...<|eot_id|>

ShareGPT 数据格式（JSON，常用于存储）

{
  "conversations": [
    {"from": "system",  "value": "你是一个专业的法律助手。"},
    {"from": "human",   "value": "什么是合同违约？"},
    {"from": "gpt",     "value": "合同违约是指合同一方当事人..."},
    {"from": "human",   "value": "能举个例子吗？"},
    {"from": "gpt",     "value": "当然，比如甲方与乙方约定..."}
  ]
}

使用 apply_chat_template

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-8B-Instruct")

# 对话数据（标准格式：role + content 列表）
messages = [
    {"role": "system",    "content": "你是专业的客服助手，只回答与产品相关的问题。"},
    {"role": "user",      "content": "我的订单什么时候发货？"},
    {"role": "assistant", "content": "您好！请提供您的订单号，我来帮您查询。"},
    {"role": "user",      "content": "订单号是 ORDER-123456。"},
    {"role": "assistant", "content": "您的订单将在 2 个工作日内发货，预计明天出库..."}
]

# 训练时：tokenize=False（返回文本），add_generation_prompt=False（完整对话）
training_text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,              # 返回字符串而非 token id
    add_generation_prompt=False  # 不添加末尾的 assistant 开头
) + tokenizer.eos_token          # 必须手动添加 eos

# 推理时：add_generation_prompt=True（让模型知道该开始生成回答了）
inference_input = tokenizer.apply_chat_template(
    messages[:-1],              # 不包含最后一条 assistant 消息
    tokenize=True,              # 返回 token id
    add_generation_prompt=True, # 添加 assistant 的开头 token，提示模型开始生成
    return_tensors="pt"
)

# 批量处理 ShareGPT 格式的数据集
def convert_sharegpt_to_training_text(examples):
    texts = []
    for convs in examples["conversations"]:
        # ShareGPT 格式 → 标准 messages 格式
        messages = []
        role_map = {"system": "system", "human": "user", "gpt": "assistant"}
        for turn in convs:
            role = role_map.get(turn["from"], turn["from"])
            messages.append({"role": role, "content": turn["value"]})

        text = tokenizer.apply_chat_template(
            messages, tokenize=False, add_generation_prompt=False
        ) + tokenizer.eos_token
        texts.append(text)
    return {"text": texts}

只对 Assistant 回答计算 Loss（Response-Only 训练）

这是对话微调中最重要的技术细节之一。在多轮对话训练中，模型在处理整个文本序列时会对每个 token 计算损失。如果不做处理，模型会同时学习"如何提问"和"如何回答"——前者是不需要的，甚至有害：

# 方法一：使用 Unsloth 的 train_on_responses_only（最简便）
from trl import SFTTrainer
from unsloth import train_on_responses_only

trainer = SFTTrainer(...)   # 正常初始化

# 告诉 trainer 哪些 token 是 instruction（屏蔽 loss），哪些是 response（计算 loss）
trainer = train_on_responses_only(
    trainer,
    instruction_part="<|start_header_id|>user<|end_header_id|>\n\n",   # Llama3 格式
    response_part="<|start_header_id|>assistant<|end_header_id|>\n\n",
)
# 此后 trainer.train() 只对 assistant 部分的 token 计算损失

# 方法二：手动构建 labels（通用方法，适用于任何框架）
import torch

def mask_user_tokens(input_ids: torch.Tensor, tokenizer) -> torch.Tensor:
    """将所有 user/system turn 的 label 设为 -100，只保留 assistant turn"""
    labels = input_ids.clone()

    # 找到所有 assistant 开始和结束的位置
    assistant_start_id = tokenizer.encode(
        "<|start_header_id|>assistant<|end_header_id|>",
        add_special_tokens=False
    )
    # 将非 assistant 部分的 token 设为 -100（CrossEntropyLoss 会忽略这些位置）
    in_assistant = False
    for i, token_id in enumerate(input_ids[0]):
        if not in_assistant:
            labels[0, i] = -100   # 屏蔽非 assistant 部分

    return labels

评估微调效果

from unsloth import FastLanguageModel
import torch

# 加载微调后的模型进行推理评估
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="./unsloth-output/checkpoint-best",  # 或 best checkpoint 路径
    max_seq_length=2048,
    load_in_4bit=True
)
FastLanguageModel.for_inference(model)   # 切换到推理优化模式（2× 推理速度）

def generate_response(user_message: str, system_prompt: str = None) -> str:
    """生成模型回复，用于手动评估"""
    messages = []
    if system_prompt:
        messages.append({"role": "system", "content": system_prompt})
    messages.append({"role": "user", "content": user_message})

    # 推理时 add_generation_prompt=True
    inputs = tokenizer.apply_chat_template(
        messages,
        tokenize=True,
        add_generation_prompt=True,
        return_tensors="pt"
    ).to("cuda")

    with torch.no_grad():
        outputs = model.generate(
            input_ids=inputs,
            max_new_tokens=512,
            temperature=0.7,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id   # 避免 padding 警告
        )

    # 只解码新生成的 token（去掉 input 部分）
    new_tokens = outputs[0][len(inputs[0]):]
    return tokenizer.decode(new_tokens, skip_special_tokens=True)

微调效果的系统化评估