大语言模型监督微调(SFT)实战：从原理到代码实现

1. 从“续写狂魔”到“听话助手”：SFT的角色与价值

如果你接触过大语言模型，尤其是像GPT-3、LLaMA这类早期的“原始”版本，可能会有一个直观的感受：它像个才华横溢但思维跳跃的“续写狂魔”。你问它“今天天气怎么样？”，它可能会给你续写一段小说：“今天天气怎么样？这个问题像一把钥匙，打开了记忆的闸门，让我想起了那个遥远的午后...” 它很能说，但常常答非所问，沉浸在自己的“创作”世界里。这背后的根本原因在于，这些模型在诞生之初，只经历过一个核心的训练阶段：预训练。

预训练的目标极其纯粹且宏大：让模型学会“语言本身”。它通过在海量无标注的互联网文本（书籍、网页、代码等）上进行自监督学习，核心任务是预测下一个词。这个过程让模型掌握了语言的语法、句法、庞大的事实性知识（尽管可能过时或不准确）以及文本的内在逻辑和风格。此时的模型，本质上是一个“世界知识的压缩器”和“概率分布模拟器”。它知道“天气”后面常跟着“晴朗”、“预报”、“变化”等词，但它不理解“今天天气怎么样？”是一个需要它检索知识、整合信息并给出简洁、直接回答的“指令”。

这就引出了大模型应用的核心矛盾：我们需要的不是一个只会续写的文豪，而是一个能理解意图、遵循指令、安全可靠地执行任务的智能助手。从“续写”到“听话”，这中间缺失的关键一环，就是监督微调。SFT 正是扮演了这个“驯兽师”或“教练”的角色，它将一个拥有庞杂知识但行为不可控的“原始模型”，引导成一个能与我们有效、安全交互的“对齐模型”。

简单来说，SFT 是在预训练模型的基础上，使用高质量的、人工标注的指令-回答对数据进行的有监督训练。我们不再让模型漫无目的地预测下一个词，而是给它明确的“考题”（指令）和“标准答案”（期望的回答），通过梯度下降来调整模型的参数，使其输出风格、格式和内容都向“标准答案”靠拢。这个过程极大地提升了模型在特定任务（如对话、总结、代码生成）上的表现，并初步赋予了它遵循人类指令的能力。可以说，没有 SFT，大模型就只是一个离线的、难以驾驭的知识库；有了 SFT，它才真正开始具备“可用性”，成为我们熟悉的 ChatGPT、文心一言等产品的技术基石。

2. SFT 的核心机制：数据、目标与训练过程拆解

理解了 SFT 的“为什么”，我们再来深入看看它的“是什么”和“怎么做”。SFT 不是一个黑箱魔法，其有效性建立在三个核心支柱上：高质量的数据、明确的学习目标以及精密的训练过程。

2.1 数据：SFT 的“教材”与“灵魂”

SFT 的性能天花板，很大程度上由训练数据决定。这些数据不是从互联网上随便抓取的，而是经过精心设计和标注的。一套典型的 SFT 数据集包含成千上万个样本，每个样本都是一个结构化的(指令, 输入, 输出)三元组。

• 指令：清晰、明确地描述任务要求。例如：“将以下英文翻译成中文”、“用 Python 写一个快速排序函数”、“总结下面这篇文章的核心观点”。
• 输入：任务的具体上下文或输入内容。对于纯指令任务（如“讲个笑话”），输入可能为空。
• 输出：由人类标注员（或高级模型辅助）编写的、符合指令要求的、高质量的答案。这个答案需要具备有用性、真实性、无害性。

数据的质量至关重要。低质量、有偏见或包含错误信息的“教材”，只会教出有问题的“学生”。因此，数据标注过程往往伴随着严格的准则和多次的审核。例如，对于有害内容请求，标准输出不是执行指令，而是礼貌地拒绝。这就在数据层面为模型注入了安全价值观。

注意：在实际操作中，构建 SFT 数据集是成本最高、最耗时的环节之一。很多开源项目（如 Alpaca、ShareGPT）通过使用强大的教师模型（如 GPT-4）来生成输出，再经过人工筛选和清洗，以相对较低的成本构建了可用的 SFT 数据集。但这存在“模型模仿模型”的局限性，其天花板受限于教师模型的能力。

2.2 学习目标：从“续写”到“对齐”

在预训练阶段，模型的学习目标是语言建模，即最大化整个训练语料序列的似然概率。公式可以简化为：给定前文，预测下一个词的概率。

而在 SFT 阶段，学习目标发生了根本性转变。它变成了序列到序列的监督学习。我们不再关心模型对整个输入序列的建模，而是专注于让模型生成的输出序列，尽可能接近我们提供的标准答案序列。

其损失函数通常是标准的交叉熵损失，但计算范围仅限于模型需要生成的答案部分。具体来说，在训练时，我们将(指令 + 输入 + 输出)拼接成一个完整的序列送给模型。但在计算损失时，我们会掩码掉指令和输入部分，只对输出部分的 token 计算损失。这样，模型在训练时，会看到完整的上下文（知道任务是什么），但只被要求“学会如何生成那个标准答案”。通过反复迭代，模型参数被调整，使得它对于给定的指令和输入，生成标准答案的概率最大化。

2.3 训练过程：精雕细琢的“微”调

“微调”这个词非常形象。我们通常不会像预训练那样，动用数千张 GPU 和数月时间从头训练。SFT 是在预训练好的庞大模型基础上进行的，其特点包括：

1. 参数高效：考虑到大模型动辄数百亿甚至万亿的参数，全参数微调成本极高。因此，实践中大量采用参数高效微调技术，如LoRA、QLoRA、Prefix Tuning等。以 LoRA 为例，它冻结预训练模型的原始权重，只在模型结构中插入少量的、可训练的低秩适配器。训练时只更新这些适配器的参数，但推理时可以将适配器权重合并回原模型，实现无损的性能提升。这极大地降低了硬件门槛，使得在消费级显卡上微调大模型成为可能。
2. 学习率策略：由于是在一个已经收敛的良好起点上进行调整，SFT 使用的学习率通常比预训练小 1 到 3 个数量级（例如2e-5到5e-5），避免“冲毁”模型已经学到的宝贵语言知识。
3. 早停机制：SFT 很容易过拟合到有限的训练数据上。如果训练轮次过多，模型可能会机械地记忆训练样本，丧失泛化能力。因此，需要准备一个验证集，监控模型在未见指令上的表现，当验证集损失不再下降或开始上升时，就停止训练。
4. 批次与梯度累积：根据 GPU 显存大小，合理设置批次大小。当单卡无法放下较大批次时，可以使用梯度累积技术，模拟大批次训练的效果，使训练更稳定。

一个典型的 SFT 训练循环代码如下所示（以 PyTorch 和 Hugging Face Transformers 库为例）：

from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments from peft import LoraConfig, get_peft_model, TaskType # 1. 加载预训练模型和分词器 model_name = "meta-llama/Llama-3-8B" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained(model_name) # 2. 配置 LoRA lora_config = LoraConfig( task_type=TaskType.CAUSAL_LM, r=8, # LoRA 的秩 lora_alpha=32, lora_dropout=0.1, target_modules=["q_proj", "v_proj"] # 通常作用于注意力层的查询和值投影矩阵 ) model = get_peft_model(model, lora_config) model.print_trainable_parameters() # 会发现可训练参数仅占原模型的 0.1% 左右 # 3. 准备 SFT 格式的数据集 (假设已处理成 `instructions`, `inputs`, `outputs` 列表) def format_sft_example(instruction, input_text, output): # 使用特定的模板拼接，例如 Alpaca 格式 prompt = f"Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instruction:\n{instruction}\n\n### Input:\n{input_text}\n\n### Response:\n" full_text = prompt + output return full_text # 对数据集进行分词 def tokenize_function(examples): # 拼接指令、输入和输出 texts = [format_sft_example(i, inp, o) for i, inp, o in zip(examples['instruction'], examples['input'], examples['output'])] # 进行分词，并设置 labels tokenized = tokenizer(texts, truncation=True, padding="max_length", max_length=512) # 关键步骤：计算 loss mask。假设 prompt 部分（直到“### Response:\n”）不计算损失 # 这里简化处理：实际中需要更精确地定位 prompt 结束位置 # 一种常见做法是在数据预处理时，就将 prompt 和 answer 分开，并为 answer 部分生成 labels # 以下为概念性代码 labels = tokenized["input_ids"].copy() # ... 此处应有逻辑将 prompt 部分的 token 对应的 label 设置为 -100，使其在损失计算中被忽略 # tokenized["labels"] = labels return tokenized # 4. 配置训练参数 training_args = TrainingArguments( output_dir="./sft_finetuned_llama", num_train_epochs=3, per_device_train_batch_size=4, per_device_eval_batch_size=4, gradient_accumulation_steps=4, learning_rate=2e-5, fp16=True, # 使用混合精度训练节省显存 logging_steps=10, save_steps=500, eval_steps=500, evaluation_strategy="steps", save_total_limit=2, load_best_model_at_end=True, ) # 5. 创建 Trainer 并开始训练 trainer = Trainer( model=model, args=training_args, train_dataset=tokenized_train_dataset, eval_dataset=tokenized_eval_dataset, data_collator=..., # 需要定义数据整理器 ) trainer.train()

这段代码勾勒出了一个使用 LoRA 进行 SFT 的典型流程。其中最关键也最容易出错的一环，就是损失掩码的正确实现。如果掩码设置错误，模型可能会去学习如何“复述指令”，而不是“生成答案”，导致训练完全失败。

3. SFT 的实践挑战与应对策略

纸上得来终觉浅，绝知此事要躬行。在实际进行 SFT 时，你会遇到一系列预料之中和预料之外的挑战。下面我结合一些常见的“坑”，来谈谈如何应对。

3.1 数据质量陷阱：噪声、偏见与格式不一致

问题：你兴冲冲地收集了数万条指令数据，或者从网上下载了一个开源数据集，直接开始训练。几轮过后，发现模型表现怪异：回答冗长啰嗦、偶尔会输出无关的标记、或者对不同风格的问题反应不一致。

根因分析：这极大概率是数据质量问题。开源数据集中可能包含：

1. 噪声：未清洗的 HTML 标签、乱码、错误的换行符。
2. 格式不一致：指令的表述方式千奇百怪（“请翻译”、“翻译一下”、“能否翻译？”），答案的格式也五花八门（有的用列表，有的用段落）。
3. 偏见与错误：标注员的主观偏见、事实性错误、甚至包含一些不被期望的行为示例。

解决方案：

• 严格的数据清洗流水线：建立包括去重、过滤低质样本、标准化指令模板、检查答案长度和内容的一系列自动化脚本。例如，可以设定规则，过滤掉答案仅为“好的”、“是的”这种无信息量的样本，或者包含特定敏感词的样本。
• 指令模板化：为不同类型的任务设计统一的指令模板。例如，所有翻译任务都用“将以下[源语言]文本翻译成[目标语言]：[文本]”。这能减少模型的理解负担，使其更专注于任务本身。
• 人工抽样审核：无论自动化流程多完善，定期对清洗后的数据进行人工抽样检查都是必不可少的。这是保证数据“灵魂”健康的最后一道防线。

3.2 灾难性遗忘：模型“忘了”怎么说话

问题：SFT 后，模型在指令跟随上表现很好，但你发现它的一些基础能力下降了，比如生成文本的流畅度不如从前，或者在一些常识性问答上表现变差。

根因分析：这就是典型的灾难性遗忘。模型在专注于学习新任务（指令跟随）时，覆盖或削弱了预训练阶段学到的通用语言表征。SFT 数据集通常只占预训练数据的极小一部分（百万分之一甚至更少），如果微调强度过大（学习率太高、轮次太多），模型就会“忘本”。

应对策略：

• 更小的学习率与更短的训练：这是最直接的方法。使用1e-5到5e-5量级的学习率，并借助验证集进行早停。
• 混合数据训练：在 SFT 数据中混入一小部分（如 5%-10%）高质量的预训练数据（通用文本）。这相当于在让模型学习新技能的同时，定期复习旧知识。需要仔细平衡比例，否则会稀释 SFT 的效果。
• 参数高效微调：如前所述的 LoRA 等方法，通过冻结绝大部分原始参数，只更新少量新增参数，能在最大程度上保留原始模型的能力，是缓解遗忘的有效手段。
• 评估指标多元化：不仅评估模型在指令任务上的表现（如通过人工评分或 GPT-4 作为裁判），也要评估其在预训练任务上的困惑度是否大幅上升。

3.3 泛化能力不足：只会“照本宣科”

问题：模型在训练集上的指令上表现完美，但遇到稍微换种说法的、训练集未见过的指令时，就不知所措或表现不佳。

根因分析：SFT 数据的覆盖范围总是有限的，模型可能只是记住了（过拟合）训练样本中的“指令-答案”映射，而没有真正学会理解指令的意图。例如，训练数据里有“总结这篇文章”，但测试时用户说“给这篇文章写个概要”，模型就可能失败。

提升泛化的技巧：

• 数据增强：对指令进行同义改写、扩写或缩写，生成语义相同但表述多样的新样本。这能强迫模型去理解指令的核心意图，而不是记忆表面字符串。
• 指令多样性：在构建数据集时，有意识地涵盖同一任务的不同指令表述方式。邀请不同背景的标注员来编写指令，增加语言风格的多样性。
• 思维链数据：对于复杂推理任务，在输出中不仅包含最终答案，还包含推理的中间步骤。这种“思维链”数据能教会模型如何思考，而不仅仅是给出答案，这有助于提升其在复杂、新颖问题上的泛化能力。
• 课程学习：先使用简单、直接的指令数据训练，再逐步引入更复杂、更隐晦的指令数据，让模型循序渐进地学习。

3.4 多轮对话与上下文学习能力的削弱

问题：一些强大的预训练模型本身具备不错的上下文学习能力，即通过几个示例（Few-shot）就能理解并执行新任务。但经过 SFT 后，这种能力有时会减弱。

根因分析：标准的 SFT 数据格式（单轮指令-回答）可能让模型过于适应这种“一问一答”的模式，削弱了其处理长上下文、理解示例间关系的能力。模型可能学会了“看到指令就生成固定格式答案”，而不是“分析给定的上下文来推导答案”。

实践中的权衡：

• 在数据中引入多轮对话样本：专门收集或构造包含多轮对话的 SFT 数据，其中指令可能隐含在历史对话中。这有助于模型保持对话状态跟踪能力。
• 保留 Few-shot 评估：在验证集中加入一些 Few-shot 任务，监控模型此项能力的变化。如果下降严重，可能需要调整数据混合策略或训练目标。
• 认识到 SFT 的局限性：SFT 主要解决“指令跟随”问题，而复杂的上下文推理、工具使用等能力，可能需要后续的强化学习从人类反馈中学习等更高级的对齐技术来进一步塑造。SFT 是打好基础的第一步，但不是终点。

4. SFT 之后：模型能力评估与迭代闭环

训练完成并不意味着结束，评估模型在 SFT 后的真实表现至关重要。我们不能只看训练损失下降了多少，而要看模型在实际场景中是否“好用”。

4.1 构建多维度的评估体系

一个粗糙但常用的方法是人工评测：让测试人员输入各种指令，从有用性、真实性、无害性、流畅度等多个维度进行打分。但这成本高、耗时长、主观性强。

更 scalable 的方法包括：

1. 自动化基准测试：使用像MT-Bench、AlpacaEval、HELM这样的基准测试套件。这些基准包含了一系列涵盖不同技能（写作、推理、数学、编程等）的问题，并通常使用一个强大的 LLM（如 GPT-4）作为裁判，来对比你的模型和基线模型（如 ChatGPT）的回答哪个更好。这能给出一个相对客观的分数。
2. 保留一个高质量的验证集：从训练数据中分出一部分绝不参与训练的数据，用于计算验证集上的损失和评估生成质量。这是防止过拟合的直接指标。
3. 领域特定测试集：如果你的 SFT 是针对某个垂直领域（如法律、医疗），那么构建该领域的小型、高质量的测试集是无可替代的。例如，测试模型对专业术语的理解、对领域内标准流程的遵循程度等。

4.2 从评估中发现迭代方向

评估结果会直接指导下一轮的迭代：

• 如果模型在某个技能上（如代码生成）表现差：可能需要补充该类型的数据。
• 如果模型经常产生幻觉（编造事实）：需要在数据中加强“诚实”的样本，例如加入一些模型回答“我不知道”或基于给定信息回答的示例。
• 如果模型风格不符合预期（太啰嗦或太简短）：可以在数据标注指南中明确回答的格式和长度要求，并筛选出符合要求的样本重新训练。

这个过程形成了一个“数据收集 -> SFT 训练 -> 多维评估 -> 问题分析 -> 数据改进”的闭环。SFT 很少能一蹴而就，通常需要经过多轮这样的迭代，模型的表现才能逐步稳定和提升。

4.3 SFT 与后续对齐技术的关系

需要明确的是，SFT 是大模型对齐的起点，而非终点。它让模型学会了“听话”，但未必能让模型学会“把事情做对”或者“符合人类复杂偏好”。

• SFT 解决了“理解指令”的问题：模型知道了用户要它做什么。
• RLHF 解决了“什么才是好答案”的问题：通过人类对多个答案的排序反馈来训练奖励模型，再用强化学习优化模型，使其输出更符合人类偏好的答案（更有帮助、更无害）。RLHF 能进一步打磨 SFT 后的模型，使其输出质量更高、更安全。
• DPO 等直接偏好优化方法：提供了比 RLHF 更简洁的替代方案，直接在偏好数据上优化模型，同样是为了让模型输出更符合人类偏好。

因此，一个完整的大模型对齐 pipeline 往往是：预训练 -> SFT -> RLHF/DPO。SFT 是这个链条中承上启下的关键一步，它将一个“原始模型”转化为一个“可对话的基座模型”，为后续更精细的偏好对齐奠定了坚实的基础。没有扎实的 SFT，后续的 RLHF 就像在沙地上盖楼，难以取得稳定良好的效果。

5. 实战：动手微调一个你自己的对话模型

理论说了这么多，我们来点实际的。假设我们想基于一个开源的 7B 量级模型（如 LLaMA-3-8B-Instruct 的基座版，或 Qwen1.5-7B），使用自己的数据，微调一个擅长进行技术问答的助手。以下是详细的步骤和心法。

5.1 环境与数据准备

硬件要求：得益于 QLoRA 等技术的成熟，在单张 24GB 显存的消费级显卡（如 RTX 4090）上微调 7B 模型已成为可能。如果显存更小（如 16GB），可以考虑使用 4-bit 量化的 QLoRA。

软件环境：

# 推荐使用 Conda 创建环境 conda create -n sft_env python=3.10 conda activate sft_env pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118 # 根据你的 CUDA 版本调整 pip install transformers accelerate peft datasets bitsandbytes scipy sentencepiece # 如果需要使用 trl 库的 SFTTrainer pip install trl

数据准备：这是最关键的步骤。假设我们有一些关于 Python 编程的问答对。

1. 数据格式：整理成一个 JSON 文件，每条数据包含instruction,input,output字段。input可为空。

   [ { "instruction": "写一个 Python 函数，计算斐波那契数列的第 n 项。", "input": "", "output": "def fibonacci(n):\n if n <= 0:\n return \"输入必须为正整数\"\n elif n == 1 or n == 2:\n return 1\n else:\n a, b = 1, 1\n for _ in range(3, n+1):\n a, b = b, a + b\n return b\n\n# 示例：\nprint(fibonacci(10)) # 输出 55" }, { "instruction": "解释一下 Python 中的装饰器是什么，并举例说明。", "input": "", "output": "装饰器是 Python 中一种强大的语法糖，它允许在不修改原函数代码的情况下，为函数添加新的功能。本质上，装饰器是一个接受函数作为参数并返回一个新函数的可调用对象。\n\n示例：\ndef my_decorator(func):\n def wrapper():\n print(\"函数执行前...\")\n func()\n print(\"函数执行后...\")\n return wrapper\n\n@my_decorator\ndef say_hello():\n print(\"Hello!\")\n\nsay_hello()\n# 输出：\n# 函数执行前...\n# Hello!\n# 函数执行后..." } ]

2. 数据量：对于 SFT，几百到几千条高质量数据就能看到明显效果。当然，数据越多越多样，模型泛化能力越好。
3. 数据分割：按照 90/10 或 80/20 的比例，将数据分为训练集和验证集。

5.2 训练脚本与关键配置

我们将使用 Hugging Face 的transformers、peft和trl库来简化流程。trl库中的SFTTrainer专门为 SFT 设计，处理了很多细节。

from datasets import load_dataset from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, BitsAndBytesConfig from peft import LoraConfig, prepare_model_for_kbit_training from trl import SFTTrainer import torch # 0. 模型与分词器 model_name = "Qwen/Qwen1.5-7B" # 或 "meta-llama/Llama-3-8B" bnb_config = BitsAndBytesConfig( load_in_4bit=True, # 使用 4-bit 量化以节省显存 bnb_4bit_quant_type="nf4", bnb_4bit_compute_dtype=torch.float16, bnb_4bit_use_double_quant=True ) tokenizer = AutoTokenizer.from_pretrained(model_name) tokenizer.pad_token = tokenizer.eos_token # 设置填充令牌 model = AutoModelForCausalLM.from_pretrained( model_name, quantization_config=bnb_config, device_map="auto", trust_remote_code=True # 对于 Qwen 等模型需要 ) model = prepare_model_for_kbit_training(model) # 为 k-bit 训练准备模型 # 1. 配置 LoRA peft_config = LoraConfig( lora_alpha=16, lora_dropout=0.1, r=64, # LoRA 秩，可以尝试 8, 16, 32, 64 bias="none", task_type="CAUSAL_LM", target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"] # 针对 Qwen/Llama 的常见模块 ) # 2. 加载并格式化数据集 dataset = load_dataset('json', data_files={'train': 'train.json', 'eval': 'eval.json'}) def formatting_func(example): # 使用 ChatML 格式或其他指令模板 text = f"<|im_start|>user\n{example['instruction']}\n{example['input']}<|im_end|>\n<|im_start|>assistant\n{example['output']}<|im_end|>" return text # 3. 训练参数 training_args = TrainingArguments( output_dir="./qwen-sft-tech-qa", num_train_epochs=3, per_device_train_batch_size=2, # 根据显存调整 per_device_eval_batch_size=2, gradient_accumulation_steps=4, gradient_checkpointing=True, # 进一步节省显存 optim="paged_adamw_8bit", logging_steps=10, save_strategy="steps", save_steps=500, eval_strategy="steps", eval_steps=500, learning_rate=2e-4, # SFT 学习率可以稍高于全参数微调 weight_decay=0.01, fp16=True, warmup_ratio=0.03, group_by_length=True, # 将长度相似的样本分组，提高效率 report_to="none", # 可以设置为 "tensorboard" 或 "wandb" ddp_find_unused_parameters=False, ) # 4. 创建 Trainer trainer = SFTTrainer( model=model, args=training_args, train_dataset=dataset['train'], eval_dataset=dataset['eval'], peft_config=peft_config, formatting_func=formatting_func, tokenizer=tokenizer, max_seq_length=1024, # 根据你的数据长度调整 ) # 5. 训练 trainer.train() # 6. 保存适配器权重 trainer.model.save_pretrained("./qwen-sft-tech-qa-lora")

关键配置解析：

• load_in_4bit=True：使用 QLoRA，这是能在有限显存下微调大模型的关键。
• gradient_checkpointing=True：用时间换空间，进一步减少显存占用。
• per_device_train_batch_size和gradient_accumulation_steps：实际批次大小 =per_device_train_batch_size * gradient_accumulation_steps * GPU数量。需要根据显存情况调整。
• learning_rate=2e-4：对于 LoRA/QLoRA，学习率通常可以设得比全参数微调高一些（如 1e-4 到 5e-4）。
• formatting_func：这是 SFT 的灵魂。你必须定义一个函数，将你的(instruction, input, output)数据拼接成模型训练时看到的完整文本序列，并确保在计算损失时只对assistant部分进行。SFTTrainer内部会帮你处理损失掩码，但前提是你的格式化函数正确地区分了“上下文”和“需要模型生成的部分”。ChatML 格式是一种清晰的方式。

5.3 模型合并、推理与效果验证

训练完成后，我们得到的是 LoRA 适配器权重，而不是一个完整的模型文件。

合并模型（可选，为了便于部署）：

from peft import PeftModel # 加载原模型和适配器 base_model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, device_map="auto") model = PeftModel.from_pretrained(base_model, "./qwen-sft-tech-qa-lora") # 合并权重 merged_model = model.merge_and_unload() # 保存合并后的模型 merged_model.save_pretrained("./qwen-sft-tech-qa-merged") tokenizer.save_pretrained("./qwen-sft-tech-qa-merged")

推理测试：

from transformers import pipeline # 使用合并后的模型或直接加载基础模型+适配器 pipe = pipeline("text-generation", model="./qwen-sft-tech-qa-merged", tokenizer=tokenizer, device=0) prompt = "用 Python 实现一个二分查找算法。" # 使用训练时相同的格式模板 formatted_prompt = f"<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n" outputs = pipe(formatted_prompt, max_new_tokens=256, do_sample=True, temperature=0.7, top_p=0.9) print(outputs[0]['generated_text'])

效果验证：你需要系统地测试模型。问它训练数据内的问题，看回答是否准确、格式是否符合要求。更重要的是，问它一些训练数据外的、但属于技术领域的问题，评估其泛化能力。同时，也要问一些无关的或开放性问题，观察其是否出现了严重的灾难性遗忘或行为异常。

这个过程可能会反复多次。你可能需要调整数据、修改格式模板、调整超参数（如学习率、LoRA 的r值），甚至尝试不同的 PEFT 方法。每一次迭代，都是你对“如何教会模型听话”这件事更深的理解。最终，当你看到一个原本只会续写的大模型，开始能稳定、可靠地回答你专业领域的问题时，你会真切地感受到 SFT 这一步所蕴含的巨大力量。它不仅仅是技术上的微调，更是将通用智能“引导”向特定价值轨道的关键一步。