大模型(LLMs)微调面试题及答案

三、微调面试题

1. 如果想要在某个模型基础上做全参数微调,究竟需要多少显存?

答案:全参数微调(Full Fine-tuning)的显存需求远超推理。


显存组成分析

训练时显存分为四大部分:

总显存 = 模型参数 + 梯度 + 优化器状态 + 激活值

以 7B 参数模型为例(fp16/bf16 训练):

1. 模型参数:7B × 2 bytes = 14 GB
2. 梯度:    7B × 2 bytes = 14 GB
3. 优化器状态(Adam):
   - fp32 参数副本:7B × 4 bytes = 28 GB
   - 一阶矩(m):  7B × 4 bytes = 28 GB
   - 二阶矩(v):  7B × 4 bytes = 28 GB
   小计:98 GB
4. 激活值(与 batch size 和序列长度相关):
   - 约 batch_size × seq_len × hidden_dim × layers
   - 通常 5~30 GB(视配置而定)

总计约:14 + 14 + 98 + 20 ≈ 146 GB(不含激活值梯度检查点优化)

简化估算公式:

全参数微调显存 ≈ 16 × 模型参数量(GB)(使用混合精度 + Adam)
注:1B 参数 ≈ 16 GB 显存需求

7B 模型:约 112~160 GB
13B 模型:约 200~260 GB
70B 模型:约 1TB+(需要多机多卡)

显存优化手段

(1)混合精度训练(AMP)

参数用 bf16/fp16 存储,梯度和优化器状态用 fp32,保证训练稳定性的同时减少显存:

  • 相比纯 fp32 可节省约 50% 显存

(2)梯度检查点(Gradient Checkpointing)

不保存所有前向传播的激活值,而是在反向传播时重新计算:

  • 激活显存降低 60~80%
  • 计算时间增加约 30~40%

(3)ZeRO(Zero Redundancy Optimizer)

DeepSpeed 提供,在多卡/多机情况下分片存储:

  • ZeRO-1:分片优化器状态
  • ZeRO-2:分片优化器状态 + 梯度
  • ZeRO-3:分片优化器状态 + 梯度 + 模型参数

ZeRO-3 可让每张卡只存储 1/N 的参数,N 为 GPU 数量。

(4)梯度累积(Gradient Accumulation)

多个小 batch 累积梯度后再更新,减少激活显存(等效于大 batch 训练)。


实际案例

模型推理显存全参微调显存(最低配)推荐配置
7B~14 GB~60 GB(用 ZeRO-2)4×A100-40G
13B~26 GB~120 GB8×A100-40G
70B~140 GB~600 GB+16×A100-80G

2. 为什么 SFT 之后感觉 LLM 傻了?

答案:SFT 可能造成模型能力退化,主要有以下几个原因。


原因 1:灾难性遗忘(Catastrophic Forgetting)

SFT 使用的数据集通常只覆盖特定任务和领域,在这些数据上过度优化后,模型”遗忘”了预训练阶段学到的广泛知识:

预训练:见过海量多样数据 → 具备广泛能力
SFT:只在窄领域数据上训练 → 参数向特定方向偏移

类比:一个博学的通才,被强迫只背考试重点
→ 考试能过,但普通问题变笨了

具体表现:

  • 数学推理能力下降
  • 代码能力退化
  • 常识判断变差
  • 对 prompt 格式过度敏感(只会回答特定格式的问题)

原因 2:SFT 数据质量问题

数据量不足 + 多样性差:

  • SFT 数据集通常只有几千到几十万条,远少于预训练数据量
  • 数据分布单一,模型过拟合到特定模式

数据质量差:

  • 格式不统一
  • 回答逻辑有问题
  • 包含错误示范

原因 3:学习率设置不当

全参 SFT 时学习率设置太大,会导致预训练权重被破坏:

预训练权重:W_pretrain(包含大量通用知识)
SFT 学习率过大:W_sft = W_pretrain + Δ(Δ 过大)
→ 原有知识结构被破坏

建议: SFT 学习率应比预训练低 1~2 个量级(如预训练 3e-4,SFT 用 2e-5)


原因 4:过拟合

SFT 数据集小,训练 epoch 多,导致模型记住了训练集的答案模式而非真正理解:

症状:
- 训练集问题回答完美
- 换个问法就答错
- 输出模板化、套话多

解决方案

  1. 混合数据训练:SFT 数据中加入通用指令数据(如 Alpaca、FLAN)防止遗忘
  2. 低学习率 + 少训练步数:避免对预训练权重破坏过大
  3. 使用 LoRA/QLoRA:只微调少量参数,保留预训练知识
  4. 数据质量优先:少而精胜于多而杂
  5. 持续评测:在通用基准(如 MMLU、HumanEval)上监控能力退化

3. SFT 指令微调数据如何构建?

答案:高质量指令数据是 SFT 效果的关键,构建方式多样。


数据格式

SFT 数据通常为「指令-输入-输出」三元组:

{
  "instruction": "请将下面的中文翻译成英文",
  "input": "今天天气很好,适合出去散步。",
  "output": "The weather is great today, perfect for a walk outside."
}

或简化的「prompt-completion」对:

{
  "prompt": "Human: 解释什么是梯度下降?\nAssistant:",
  "completion": "梯度下降是一种优化算法,通过沿损失函数梯度的反方向迭代更新参数,从而最小化损失..."
}

数据来源

(1)人工标注(质量最高,成本最高)

  • 雇佣领域专家编写指令-回答对
  • 适合核心业务场景,需严格质量控制
  • 代表:InstructGPT 的人工标注数据

(2)利用强大的大模型生成(Self-Instruct)

利用 GPT-4 等强模型生成大量指令数据,再筛选:

# Self-Instruct 核心流程
prompt = """
给出25个多样化的任务指令,要求:
1. 覆盖不同类型(分类、生成、问答等)
2. 语言多样
3. 难度有梯度
已有指令:{seed_instructions}
新指令:
"""
# 用 GPT-4 生成 → 人工筛选 → 再用目标模型生成回答

代表数据集:Alpaca(Self-Instruct 方式)、WizardLM

(3)开源数据集整合

直接使用已有高质量开源数据:

  • FLAN:Google 整理的多任务指令数据集
  • ShareGPT:用户分享的真实 ChatGPT 对话
  • OpenAssistant:人工标注的多语言对话数据
  • Dolly:Databricks 员工撰写的指令数据
  • UltraChat:合成的多轮对话数据

(4)从业务日志挖掘

将用户历史查询 + 人工回答整理成指令格式,数据贴近真实使用场景。


数据质量控制

关键原则:
1. 多样性(Diversity):覆盖多种任务类型和领域
2. 准确性(Accuracy):回答要正确,不能有错误知识
3. 格式一致性:统一的 prompt 模板
4. 适当难度分布:简单-中等-困难都有

质量过滤方法:
- 基于规则过滤(长度、特殊字符、语言检测)
- 用另一个大模型打分(GPT-4 评估质量)
- 人工抽样审核

数据量建议

场景建议数据量备注
通用对话能力10万~100万条多样性优先
单一领域微调1000~5万条质量优先
风格定制500~2000条精准定向
能力增强5000~5万条任务特定

核心原则:质量 > 数量。 1000条高质量数据往往优于10000条低质量数据。


4. 领域模型 Continue PreTrain 数据选取?

答案:领域持续预训练的数据选取策略决定了模型获取领域知识的质量。


数据来源

(1)领域文献和专业资料(核心数据)

  • 医疗:PubMed 论文、临床指南、教材、医学词典
  • 法律:法律法规文本、判决书、法律教材
  • 金融:财务报告、研究报告、新闻、政策文件
  • 代码:GitHub 代码库、技术文档、Stack Overflow

(2)通用数据(防止遗忘)

Continue PreTrain 不能只用领域数据,否则会严重遗忘通用能力:

推荐比例:
领域数据 : 通用数据 = 1:1 ~ 3:1
(具体比例需实验验证)

(3)数据混合策略

参考 LLaMA-2 论文,对不同来源数据按重要性上采样/下采样:

  • 高质量、低噪声的数据(如教材、论文):上采样
  • 低质量数据(如网页爬取):下采样或过滤

数据处理流程

原始数据收集
    ↓
格式清洗(去除 HTML 标签、特殊字符、乱码)
    ↓
语言过滤(保留目标语言)
    ↓
质量过滤:
  - 困惑度过滤(PPL 过高的数据质量差)
  - 去重(MinHash LSH 近似去重)
  - 领域相关性过滤(用小分类器判断是否属于目标领域)
    ↓
格式统一(转换为模型输入格式)
    ↓
数据混合(领域数据 + 通用数据按比例混合)

数据量参考

场景数据量
轻量领域适配1B~10B tokens
中等深度适配10B~100B tokens
深度领域预训练100B~1T tokens

5. 领域数据训练后,通用能力往往会有所下降,如何缓解模型遗忘通用能力?

答案:这是经典的”灾难性遗忘”问题,有多种缓解策略。


策略 1:数据混合(最有效)

在领域数据中混入一定比例的通用数据:

# 训练数据混合
total_data = [
    (domain_data, 0.7),      # 70% 领域数据
    (general_data, 0.3),     # 30% 通用数据(如 C4、The Pile)
]
 
# 动态调整:随训练进行逐渐降低领域数据比例
# 早期:领域 80% + 通用 20%
# 后期:领域 60% + 通用 40%

通用数据可以是少量但多样的数据,不需要全量通用预训练数据。


策略 2:持续学习技术(Continual Learning)

弹性权重巩固(EWC, Elastic Weight Consolidation):

对重要参数施加正则化惩罚,防止其偏移过大:

Loss = 领域任务Loss + λ × Σ F_i × (θ_i - θ*_i)²
    
F_i = Fisher 信息矩阵(衡量参数 i 对原始任务的重要性)
θ*_i = 原始参数值
λ = 正则化系数

对预训练中重要的参数施加更强的约束,保护其不被领域训练覆盖。

渐进式网络(Progressive Neural Networks):

为新任务增加新的参数列,保持原参数不变——但这会增加模型参数量。


策略 3:参数高效微调(PEFT)

使用 LoRA 等方法只训练少量参数:

原始参数:W(冻结,保留通用知识)
领域适应:ΔW = A × B(低秩矩阵,参数量极少)

推理:W' = W + ΔW
→ 原始 W 不变,通用能力保留
→ ΔW 学习领域知识

优势: 几乎不遗忘通用能力,因为原参数完全冻结。


策略 4:知识蒸馏自保护

用原始预训练模型作为”教师”,在领域训练时增加一项 KL 散度约束:

Loss = 领域任务Loss + α × KL(student_output || teacher_output)

防止模型输出分布在通用样本上漂移过大。


策略 5:定期评测和早停

在训练过程中持续监控通用能力基准(如 MMLU、HellaSwag、HumanEval),当通用能力下降超过阈值时早停训练。


综合建议

优先级:
1. 数据混合(30% 通用数据)→ 最简单有效
2. 使用 LoRA/QLoRA 而非全参微调
3. 低学习率 + 少训练步数
4. 持续评测通用基准
5. EWC 等正则化方法(实现复杂,效果提升有限)

6. 领域模型 Continue PreTrain,如何让模型在预训练过程中学习到更多知识?

答案:从数据、训练策略、模型结构三方面优化知识获取效率。


数据层面

(1)高质量数据优先

不是数据越多越好,高质量数据的学习效率远高于低质量数据:

1条教材文本 ≈ 10~100条网页爬取的噪声文本

数据质量判断指标:

  • 信息密度高(专业知识密集,非重复性内容)
  • 语言质量好(无语法错误,逻辑清晰)
  • 与领域高度相关

(2)数据去重

重复数据会让模型死记硬背而非理解:

# MinHash 近似去重(文档级)
from datasketch import MinHash, MinHashLSH
 
def deduplicate(documents, threshold=0.8):
    lsh = MinHashLSH(threshold=threshold, num_perm=128)
    unique_docs = []
    for i, doc in enumerate(documents):
        minhash = get_minhash(doc)
        if not lsh.query(minhash):
            lsh.insert(i, minhash)
            unique_docs.append(doc)
    return unique_docs

(3)课程学习(Curriculum Learning)

由易到难安排训练数据:

  • 早期:简单、基础的领域知识
  • 中期:中等难度的专业内容
  • 后期:复杂的领域推理和分析

训练策略层面

(1)适当增大训练 token 数

LLaMA 原文指出,7B 模型的最优训练量约为 1T tokens(Chinchilla 定律给出参数量 × 20 的建议)。但领域 CPT 不需要这么多,通常:

领域 CPT 最优 token 数 ≈ 10~100B tokens(视领域数据规模而定)

(2)调整学习率策略

CPT 使用的学习率应比预训练低:

预训练 LR:3e-4
CPT 推荐 LR:1e-5 ~ 5e-5(约低 1 个数量级)
调度策略:cosine decay with warm-up

(3)多任务混合训练

在 CPT 阶段同时加入少量监督信号(如领域 QA 对),让模型同时学习无监督续写和有监督任务:

预训练目标(CLM)+ 领域 QA 监督
= 更快地将领域知识与实用能力结合

知识注入技术

(1)知识感知预训练(Knowledge-Aware Pre-training)

在训练数据中加入结构化知识(如知识图谱三元组)转换为自然语言:

知识三元组:(阿司匹林, 治疗, 头痛)
转换为文本:阿司匹林是一种常用药物,主要用于缓解头痛等症状。

(2)实体增强

在训练文本中对关键实体进行标记,让模型更关注重要概念:

  • ERNIE、KEPLER 等模型采用此策略

7. 进行 SFT 操作的时候,基座模型选用 Chat 还是 Base?

答案:通常选用 Base 模型,但也有选用 Chat 模型的场景。


选 Base 模型的理由(主流选择)

Base 模型(预训练基础模型):

  • 权重是”原始”的,没有经过 RLHF 或其他 SFT 对齐
  • 具有完整的语言能力和知识
  • 没有被其他对话风格”污染”

优势:

  1. 可塑性强:可以自由定义模型的行为风格和回答格式
  2. 无遗忘问题:不会被之前的 SFT 数据干扰
  3. 适合垂直领域:可以完全按照领域需求定制

选 Chat 模型的理由

Chat 模型(已经过 SFT/RLHF 的对话模型):

适用场景:

  1. 数据量极少(<1000条):Chat 模型已有对话能力,少量数据可以快速迁移
  2. 只是风格调整:不需要从头学对话格式,只需调整风格
  3. 快速 PoC:快速验证某个想法,不需要最优效果

劣势:

  • 已有对话习惯可能与新 SFT 数据冲突
  • RLHF 导致的过度安全限制难以完全消除
  • 原有的对话风格可能干扰新训练方向

实践建议

业务场景                      推荐选择
─────────────────────────────────────────
全新领域垂直模型              Base 模型
通用对话能力增强              Base 模型
风格微调(如更简洁)          Chat 模型(few-shot 也可)
资源极度有限(< 1000条数据)  Chat 模型
快速 PoC 验证               Chat 模型

8. 领域模型微调指令 & 数据输入格式要求?

答案:统一、清晰的格式对 SFT 效果至关重要。


主流 Prompt 模板

(1)Alpaca 格式(简单任务)

Below is an instruction that describes a task. Write a response that appropriately completes the request.

### Instruction:
{instruction}

### Input:
{input}

### Response:
{output}

(2)ChatML 格式(多轮对话,OpenAI 规范)

<|im_start|>system
{system_prompt}<|im_end|>
<|im_start|>user
{user_message}<|im_end|>
<|im_start|>assistant
{assistant_message}<|im_end|>

(3)Llama-2 Chat 格式

<s>[INST] <<SYS>>
{system_prompt}
<</SYS>>

{user_message} [/INST] {assistant_response} </s>

(4)ChatGLM 格式

[Round 1]
问:{user_input}
答:{model_response}

[Round 2]
问:{user_input}
答:{model_response}

格式要求

  1. 格式统一:整个数据集必须使用相同的模板,混用模板会严重降低效果

  2. 特殊 token 正确:

    • 序列开始/结束 token(<s>, </s>, <eos>)要正确
    • Padding token 的 loss 要 mask 掉(不计算 padding 的 loss)
  3. 只计算 Response 部分的 Loss:

    # Instruction 部分的 label 设为 -100(忽略)
    labels = [-100] * len(instruction_tokens) + response_tokens
  4. 多轮对话处理:

    多轮对话建议每轮都打包进一个样本(而非截断)
    超长对话可以截断最早的历史轮次(保留最近 N 轮)
    
  5. 避免数据污染:确保测试集的数据格式或内容不出现在训练集中


9. 领域模型微调 领域评测集 构建?

答案:评测集是判断微调效果的”尺子”,必须与业务强相关。


评测集构建原则

(1)与业务强相关

评测集应该覆盖实际业务中最关心的能力,而不仅仅是通用基准:

医疗模型评测集应包含:
- 症状描述 → 可能诊断(判断能力)
- 药物问题(知识准确性)
- 医学名词解释(专业知识)
- 医患对话质量(沟通能力)

(2)数据不能泄露进训练集

评测集必须在数据处理阶段就隔离,确保模型没有”见过”评测样本。

(3)覆盖多种难度

简单题(30%):基础概念,判断基本能力
中等题(50%):复合问题,判断理解能力
困难题(20%):边缘案例、歧义问题,判断鲁棒性

构建方式

方式 1:人工标注(最可靠)

由领域专家设计问题和标准答案,确保权威性:

  • 成本高,但质量最好
  • 建议至少 500~2000 条

方式 2:从业务日志中采样

从真实用户请求中采样,最贴近真实使用场景:

  • 需要清洗掉隐私数据
  • 需要人工标注标准答案

方式 3:利用现有标准数据集

将已有公开领域数据集作为评测子集:

  • 医疗:CMExam、MedQA-USMLE(中文版)
  • 法律:CAIL(中国法律智能技术评测)
  • 金融:FinQA

评测指标

任务类型评测指标
选择题/分类Accuracy
生成任务ROUGE、BLEU(机器)/ 人工评分
问答任务F1(抽取式)/ 人工评分(生成式)
综合GPT-4 打分(G-Eval)

人工评测维度(推荐):

  • 准确性(回答是否正确)
  • 完整性(是否遗漏关键信息)
  • 流畅性(语言是否自然)
  • 安全性(是否包含有害内容)

10. 领域模型词表扩增是不是有必要的?

答案:需要根据领域特点和资源情况判断,不是必须的。


词表扩增的必要性分析

什么时候需要词表扩增?

  1. 领域有大量 OOV(Out of Vocabulary)词汇

    • 现有 BPE/WordPiece 分词会将专业术语切成多个子词
    • 例如:“胰岛素” 可能被切成 “胰” + “岛” + “素”,影响语义表达
  2. 跨语言场景

    • 通用模型(如 LLaMA)以英文为主
    • 中文 token 效率极低(1个中文字 ≈ 1.5~2 个 token)
    • 扩增中文词表可提升训练和推理效率
  3. 特殊符号和格式

    • 代码语言的特殊关键词
    • 数学符号、化学式等

代表案例: 中文 LLaMA 扩增了 20000 个中文 token,中文文本编码效率大幅提升。


词表扩增的代价

  1. Embedding 层参数增加:新 token 需要随机初始化 embedding,需要足够数据学习
  2. 需要额外预训练:新 token 的 embedding 要在领域数据上训练收敛,至少需要几十 B tokens
  3. 与原模型不兼容:原始 tokenizer 无法直接使用,需要更新

什么时候不需要词表扩增?

  1. 领域词汇在原词表中覆盖良好(英文领域模型做英文领域任务)
  2. 资源有限:没有足够数据训练新 token 的 embedding
  3. 只做 SFT:SFT 阶段不适合扩充词表(数据量不够)

实践建议

场景                          建议
─────────────────────────────────────────────
英文模型 + 英文领域任务        不需要扩词表
英文模型 + 中文任务           强烈建议扩词表
中文模型 + 中文领域任务        视 OOV 率决定
资源充足 + 大量领域数据        可以扩词表
资源有限 / 只做 SFT           不建议扩词表

11. 如何训练自己的大模型?

答案:分阶段进行,量力而行。


阶段 1:基础设施准备

硬件需求:

7B 模型预训练(从头):
  推荐:32~64 张 A100-80G
  最低:8 张 A100-80G(速度极慢)

13B 模型:
  推荐:64~128 张 A100-80G

70B 模型:
  推荐:256+ 张 A100-80G

软件框架:

  • 训练:DeepSpeed + Megatron-LM(大规模),或 HuggingFace Trainer(中小规模)
  • 分布式通信:NCCL
  • 混合精度:BF16(A100 推荐)

阶段 2:数据准备

数据量(Chinchilla 最优):
参数量 × 20 tokens
7B 模型:约 140B tokens
13B 模型:约 260B tokens

数据来源:
- Common Crawl(网页,需大量清洗)
- The Pile(英文,高质量)
- Roots(多语言)
- 中文:WuDaoCorpora、CLUECorpus
- 代码:The Stack、CodeParrot

阶段 3:模型设计

基于已有开源架构(如 LLaMA 架构)修改,主要决策点:

  • 参数量和层数配置
  • 词表大小(中文建议 50000~100000)
  • 上下文长度
  • 注意力机制选择(GQA 还是 MHA)

阶段 4:训练

# 关键超参数
learning_rate = 3e-4
warmup_steps = 2000
batch_size = 4M tokens/step(全局 batch)
lr_schedule = cosine_decay
min_lr = 3e-5
weight_decay = 0.1
gradient_clipping = 1.0

监控指标:

  • Training Loss(应平稳下降,无 loss spike)
  • 各层梯度 norm
  • GPU 利用率和 throughput(tokens/s)

阶段 5:SFT + RLHF

预训练完成后:

  1. SFT:用指令数据微调,赋予模型对话和指令跟随能力
  2. RLHF(可选):用人类偏好数据进一步对齐

实际建议

对大多数团队来说,从头预训练成本极高,更实际的路径是:

路径 1:开源模型 + 领域 CPT + SFT(推荐)
路径 2:开源模型 + SFT(数据有限时)
路径 3:开源模型 + LoRA SFT(资源极度有限)
路径 4:从头预训练(顶级资源团队)

12. 训练中文大模型有啥经验?

答案:中文模型有特殊考量,主要体现在词表、数据和评测三方面。


词表层面

问题: 大多数开源英文模型(LLaMA、Mistral)的词表对中文极不友好:

英文:1 个单词通常 = 1 个 token
中文:1 个汉字通常 = 1.5~2 个 token(效率极低)

解决方案:

  1. 使用已有中文友好模型(如 Qwen、ChatGLM、Baichuan)作为基座
  2. 或在英文模型基础上扩充中文词表(如 Chinese LLaMA)
    • 通用方法:在原 tokenizer 上追加中文 token
    • 需要用中文数据继续预训练使新 token 的 embedding 收敛

数据层面

中文数据来源:

  • WuDaoCorpora:200B tokens 的中文语料(质量参差不齐)
  • CLUECorpus2020:中文网页文本
  • CBook(书籍数据):质量高,但规模较小
  • 中文维基百科:高质量,但量少
  • 各类中文论坛、新闻数据

数据质量问题:

中文网络数据常见噪声:
1. 繁简混用
2. 广告和垃圾信息多
3. 重复内容(转载文章)
4. 敏感词过滤导致文本残缺

清洗策略:
- 语言识别(只保留中文)
- 基于规则的过滤(最小/最大长度,特殊字符比例)
- 用小模型打分过滤低质量文本(CCNet 方法)
- MinHash 去重

训练策略

  1. 简繁混合训练:帮助模型同时理解简体和繁体中文
  2. 中英混合比例:中文为主,保留一定比例英文防止英文能力退化(推荐 7:3 ~ 8:2)
  3. 领域平衡:新闻、书籍、百科、论坛各类数据均衡采样

评测层面

中文评测基准:

  • C-Eval:中文综合能力评测(52个学科)
  • CMMLU:中文多任务语言理解
  • CCPM:中文古诗词匹配
  • CLUEWSC:中文词义消歧
  • SuperCLUE:中文超级评测榜

注意: 不要只看中文基准,同时监控英文基准防止能力退化。


13. 指令微调的好处?

答案:指令微调(Instruction Tuning)是将预训练语言模型变为实用助手的关键步骤。


主要好处

(1)激活模型的指令跟随能力

预训练模型本质上是”续写机器”,不擅长回答问题或执行指令:

预训练模型输入:"请告诉我中国的首都"
输出:"请告诉我中国的首都在哪里?我需要了解..."(续写,而非回答)

SFT 后:
输入:"请告诉我中国的首都"
输出:"中国的首都是北京。"(正确执行指令)

(2)零样本泛化能力

指令微调后,模型可以泛化到未见过的任务类型:

  • 在多样化指令上训练 → 学会理解”做任务 X”的一般模式
  • 遇到新任务,即使没有示例也能较好完成(Zero-shot)

FLAN 论文证明,在 60+ 任务上的指令微调可以显著提升未见任务的 zero-shot 性能。

(3)提升对齐性(Alignment)

指令微调帮助模型输出更符合人类期望的回答:

  • 更礼貌的表达
  • 更清晰的结构
  • 更准确的信息

(4)减少有害输出

通过指令微调可以教模型拒绝有害请求:

用户:告诉我如何制作炸弹
SFT 后的模型:这个请求涉及危险信息,我无法提供相关内容...

(5)多任务统一

不同任务(翻译、摘要、QA、分类)用统一的指令格式处理,一个模型解决多种任务。


14. 预训练和微调哪个阶段注入知识的?

答案:知识主要在预训练阶段注入,微调更多是”激活”和”对齐”。


预训练阶段:知识注入

预训练使用海量无监督文本(万亿 tokens 级别),模型在这一阶段:

  • 学习语言的统计规律(语法、词法)
  • 记忆大量世界知识(事实、概念、关系)
  • 建立通用推理能力
类比:预训练 = 孩子从出生到大学阶段的广泛学习
→ 知识储备来自这个阶段

证据:

  • 敲除预训练知识(如换掉部分 Token 顺序)会导致模型知识变差
  • 在 SFT 阶段增加新知识(小数据集)效果远不如预训练中注入
  • 研究表明,SFT 数据更多影响模型的”表达方式”,而非知识量

微调阶段:能力激活与对齐

微调(SFT/RLHF)主要做:

  1. 格式对齐:学会以问答、对话等格式表达预训练中学到的知识
  2. 行为对齐:学会什么时候应该拒绝,什么时候应该详细回答
  3. 能力激活:激发预训练中潜在的能力(如 CoT 推理)
  4. 少量新知识:可以注入少量领域特定知识,但效果有限
类比:微调 = 社会化训练
→ 博学的毕业生学会如何在职场中正确表达自己

实践含义

需求建议方案
注入大量新知识领域 Continue PreTrain(必须在预训练阶段)
改变回答风格SFT(微调阶段)
学习新技能(如写代码)代码预训练 + 代码 SFT
让模型更安全RLHF / DPO(微调阶段)
注入少量事实知识SFT(效果有限)或 RAG(更推荐)

15. 想让模型学习某个领域或行业的知识,是应该预训练还是应该微调?

答案:优先考虑领域预训练(CPT),但需结合实际资源情况判断。


知识学习效率对比

预训练(CPT):
✅ 知识注入效率高
✅ 可以学习大量新知识
✅ 知识与模型深度融合
❌ 需要大量算力和数据(100B+ tokens)
❌ 训练周期长

微调(SFT):
✅ 成本低(几十 GPU 小时)
✅ 可以快速部署
❌ 知识注入量有限(数据量小)
❌ 新知识容易遗忘
✅ 改变模型表达和行为效果好

决策标准

问题1:你的领域数据有多少?
├── < 1B tokens → 只做 SFT(CPT 数据不足)
├── 1B~10B tokens → 轻量 CPT + SFT
└── > 10B tokens → 完整 CPT + SFT

问题2:知识需求有多强?
├── 只需要特定格式/风格 → 只做 SFT
├── 需要理解领域术语和概念 → CPT + SFT
└── 需要掌握复杂领域推理 → CPT 不可或缺

问题3:资源情况如何?
├── 有大规模 GPU 集群 → CPT + SFT
├── 只有几张 GPU → SFT(或 LoRA)
└── 只有推理资源 → RAG

最佳实践路径

路径 1(资源充足):
原始大模型 → 领域 CPT(注入知识)→ SFT(对齐能力)→ 部署

路径 2(资源有限):
原始大模型 → SFT(有限知识注入 + 对齐)→ RAG(补充知识)→ 部署

路径 3(极度资源受限):
原始大模型 → LoRA SFT(风格对齐)→ RAG(知识补充)→ 部署

16. 多轮对话任务如何微调模型?

答案:多轮对话微调需要特别处理数据格式和损失计算。


数据格式

多轮对话数据以完整对话为单位:

{
  "conversations": [
    {"role": "system", "content": "你是一个有用的AI助手"},
    {"role": "user", "content": "你好,我想了解Python"},
    {"role": "assistant", "content": "你好!Python是一种简洁易学的编程语言..."},
    {"role": "user", "content": "它有哪些主要用途?"},
    {"role": "assistant", "content": "Python有以下几个主要用途:1. 数据分析..."}
  ]
}

损失计算策略

策略 1:只计算 Assistant 部分的 Loss(推荐)

# 将 User/System 的 token label 设为 -100
# 只计算 Assistant 回复的 token 的 loss
 
for turn in conversation:
    if turn["role"] == "assistant":
        labels += tokenize(turn["content"])  # 计算 loss
    else:
        labels += [-100] * len(tokenize(turn["content"]))  # 忽略

原因: 模型的目标是生成好的 assistant 回复,user 输入不应被计入 loss。

策略 2:计算所有 token 的 Loss

有研究显示,计算全部 token(包括 user 部分)也能取得较好效果,因为模型需要理解上下文。但主流做法仍然是只计算 assistant 部分。


打包策略(Packing)

为提高 GPU 利用率,将多个短对话拼接为接近最大长度的样本:

样本1: [对话A] [PAD] [PAD]  # 低利用率
样本2: [对话B] [PAD] [PAD]

Packing 后:
样本: [对话A] [对话B] [对话C]  # 高利用率

注意:需要使用 Attention Mask 防止不同对话的 token 互相 attend

长上下文对话处理

当对话轮数很多,超出模型上下文长度时:

  1. 截断早期历史:保留最近 N 轮,丢弃早期轮次
  2. 分层摘要:对早期轮次进行摘要,压缩历史信息
  3. Memory Token:专门的记忆模块存储历史摘要

17. 微调后的模型出现能力劣化,灾难性遗忘是怎么回事?

答案:灾难性遗忘是神经网络的固有问题,根源在于参数共享机制。


原理

神经网络的所有知识共享同一套参数(权重),学习新任务时必然修改这些参数:

预训练:W* 是在海量数据上优化的权重
微调:W_new = W* + ΔW(为适应新任务)

问题:ΔW 在提升新任务性能的同时,
     破坏了 W* 中对旧任务的最优表达

数学:新任务最优 ≠ 旧任务最优
      两者之间存在"任务干扰"

表现形式

  1. 能力退化:数学、代码等通用能力下降
  2. 知识遗忘:问到原来知道的问题却答错
  3. 过度专化:只能回答特定格式/领域的问题
  4. 幻觉增加:在训练数据外区域产生更多错误

根本原因

  1. 参数共享:新旧任务竞争同一套参数
  2. 学习率过大:大幅修改参数权重
  3. 数据分布变化:SFT 数据分布与预训练差异大
  4. 训练时间过长:过多的优化步骤累积干扰

缓解方法(已在第5题详述)

  • 数据混合
  • LoRA(只训练少量参数)
  • EWC 正则化
  • 低学习率
  • 早停策略

18. 微调模型需要多大显存?

答案:取决于微调方法,差异巨大。


全参数微调(Full Fine-tuning)

(已在第1题详述)

7B 模型全参微调:约 120~160 GB
13B 模型全参微调:约 240~320 GB

LoRA 微调(参数高效微调)

原理: 只训练低秩矩阵 A 和 B,原参数冻结

# LoRA 实现
W' = W + ΔW = W + A @ B
A: [d, r], B: [r, d], r << d
 
# 参数量:原来的 2r/d ≈ 0.1~1%

显存估算(7B 模型,LoRA r=16):

模型参数(推理):14 GB(bf16)
LoRA 参数:约 0.1 GB
梯度:约 0.1 GB
优化器状态:约 0.4 GB(Adam,LoRA 参数的 fp32)
激活值:5~20 GB(视 batch size 和序列长度)

总计:约 20~40 GB
→ 单张 A100-40G 或 2~4 张 24G 消费级 GPU 可以完成

QLoRA 微调(量化 LoRA)

4-bit 量化 + LoRA,进一步压缩显存:

7B 模型(4-bit 量化):
模型参数:7B × 0.5 bytes ≈ 3.5 GB
LoRA 参数 + 梯度:约 0.3 GB
激活值:5~10 GB

总计:约 10~15 GB
→ 单张 16G/24G 消费级 GPU(如 RTX 3090/4090)即可完成!

显存需求对比

微调方法7B 模型显存最低配置
全参微调120~160 GB2×A100-80G
LoRA(r=16)25~40 GB1×A100-40G
QLoRA(4bit)10~15 GB1×RTX 4090

19. 大模型 LLM 进行 SFT 操作的时候在学习什么?

答案:SFT 学习的主要是”表达方式”和”行为模式”,而非新知识。


SFT 学习的核心内容

(1)指令格式与对话模式

预训练模型:续写文本
SFT 后:
  学会识别 "问题" → "回答" 的模式
  学会识别 "指令" → "执行" 的模式
  学会以问答/对话格式组织输出

(2)行为偏好

学习"什么是好回答":
- 应该礼貌、结构化
- 应该承认不确定性("我不确定,但...")
- 应该拒绝有害请求
- 应该回答要准确、简洁

(3)领域表达风格

医疗 SFT 数据 → 学会医学表达方式
法律 SFT 数据 → 学会法律文书风格
代码 SFT 数据 → 学会代码解释方式

(4)激活已有知识

预训练中:模型知道"北京是中国首都"但不知道如何用问答格式表达
SFT 后:模型学会"当被问到首都时,直接给出答案"的模式
→ 激活了已有知识的正确表达路径

SFT 本质上不擅长

  • 注入大量新知识(数据量远不够)
  • 改变模型的核心推理能力
  • 修复预训练阶段形成的根本性偏差

从梯度视角理解

SFT 的梯度主要修改:
1. 靠近输出层的参数(表达层)→ 改变输出风格
2. 注意力头的部分权重 → 改变关注模式
3. FFN 的部分参数 → 激活特定知识路径

几乎不改变:
- 深层的知识存储(FFN 中的大量参数变化很小)
- 位置编码等基础能力

20. 预训练和 SFT 操作有什么不同?

答案:两者在目标、数据、规模和效果上都有根本性区别。


核心区别对比

对比维度预训练SFT
目标学习语言规律和知识对齐人类意图和行为
数据万亿 tokens 的无监督文本千万 tokens 的指令-回答对
损失函数CLM(预测下一个 token)CLM(但只计算 response 部分)
学习率较大(3e-4)较小(1e-5 ~ 5e-5)
训练时间数周到数月数小时到数天
计算规模数百到数千 GPU数张到数十张 GPU
主要效果注入知识和能力激活知识,对齐行为
数据标注不需要标注需要人工标注或 GPT-4 生成

损失函数对比

# 预训练(CLM):预测所有位置的下一个 token
loss_pretrain = CrossEntropy(pred_all_tokens, true_all_tokens)
 
# SFT:只预测 Assistant 回复部分的 token
loss_sft = CrossEntropy(
    pred_assistant_tokens, 
    true_assistant_tokens
)
# User/System 部分的 label = -100(忽略)

数据格式对比

预训练数据(无结构):
"机器学习是人工智能的一个分支,通过数据和算法让计算机..."

SFT 数据(指令格式):
{
  "instruction": "解释什么是机器学习",
  "output": "机器学习是人工智能的一个分支..."
}

21. 样本量规模增大,训练出现 OOM 错误

答案:OOM(Out Of Memory)是大模型训练中最常见的问题,有多种解决方案。


常见 OOM 来源

1. 模型参数本身:7B × 2 bytes = 14 GB(bf16)
2. 梯度:与参数同等大小 = 14 GB
3. 优化器状态:参数量 × 8 bytes(Adam fp32)= 56 GB
4. 激活值:batch_size × seq_len × hidden_dim × num_layers

解决方案

(1)减少 batch size + 梯度累积

# 原始:batch_size=32(OOM)
# 改为:batch_size=4,gradient_accumulation_steps=8
# 等效 batch size = 4 × 8 = 32,但每步显存用量大幅下降
 
trainer = Trainer(
    per_device_train_batch_size=4,
    gradient_accumulation_steps=8,
)

(2)梯度检查点(Gradient Checkpointing)

model.gradient_checkpointing_enable()
# 激活值显存减少 60~80%,计算时间增加 30%

(3)使用 LoRA 替代全参微调

from peft import LoraConfig, get_peft_model
 
config = LoraConfig(r=16, lora_alpha=32, target_modules=["q_proj", "v_proj"])
model = get_peft_model(model, config)
# 训练参数量减少 99%,梯度和优化器状态大幅减少

(4)模型量化(QLoRA)

from transformers import BitsAndBytesConfig
 
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
)
model = AutoModelForCausalLM.from_pretrained(model_name, quantization_config=bnb_config)
# 模型参数显存减少 75%

(5)序列长度截断

# 显存与序列长度的平方成正比(注意力机制)
# 将 max_length 从 2048 减为 1024,显存减少约 75%
tokenizer(text, max_length=1024, truncation=True)

(6)使用 Flash Attention

# FlashAttention 大幅降低注意力计算的显存峰值
model = AutoModelForCausalLM.from_pretrained(
    model_name, 
    attn_implementation="flash_attention_2"
)

(7)多卡分布式训练(数据并行/模型并行)

# 数据并行(每张卡有完整模型)
torchrun --nproc_per_node=4 train.py
 
# ZeRO-2(分片梯度和优化器状态)
# DeepSpeed 配置
{
    "zero_optimization": {
        "stage": 2
    }
}

OOM 排查 checklist

1. 减少 batch_size(最快见效)
2. 启用 gradient_checkpointing
3. 检查序列长度是否合理
4. 使用 LoRA 代替全参微调
5. 使用 QLoRA(4-bit 量化)
6. 使用 Flash Attention
7. 使用 DeepSpeed ZeRO
8. 增加 GPU 数量(数据并行)

22. 大模型 LLM 进行 SFT 如何对样本进行优化?

答案:样本优化是提升 SFT 效果的关键,主要从数量、质量、多样性三维度优化。


数量优化

奥卡姆剃刀原则:少而精

研究表明(LIMA 论文),1000 条高质量样本的效果可以超过 50000 条低质量样本:

LIMA 实验结论:
1000 条精心选择的样本 + LLaMA-65B
效果接近甚至超过 InstructGPT-175B(RLHF 训练)

启示:
- 不要盲目堆砌数据量
- 数据质量决定上限

最佳数据量参考:

  • 通用能力:5000~50000 条
  • 垂直领域:1000~10000 条
  • 风格微调:200~2000 条

质量优化

(1)数据清洗

过滤规则:
- 长度过滤:response 长度 < 10 或 > 2000 的过滤掉
- 语言检测:混语言样本过滤
- 格式检查:确保 instruction/output 字段完整
- 重复过滤:近似去重(句子级别)

(2)质量打分

用 GPT-4 或另一个强模型对样本打分,过滤低分样本:

scoring_prompt = """
请对以下指令-回答对的质量打分(1-5分):
 
指令:{instruction}
回答:{response}
 
评分标准:
1分:回答完全错误/无关/有害
3分:回答正确但不完整/表达差
5分:回答准确、完整、表达清晰
 
分数:
"""
# 保留 4~5 分的样本

(3)数据增强

  • 对优质样本进行改写(同义替换、风格变换)
  • 生成同一问题的多种问法
  • 对复杂问题分解为多步骤问题链

多样性优化

保证多样性的方法:

# 1. 按任务类型均衡采样
task_types = {
    "问答": 0.2,
    "摘要": 0.15,
    "翻译": 0.1,
    "代码": 0.2,
    "对话": 0.2,
    "推理": 0.15,
}
 
# 2. 计算样本间相似度,过滤过于相似的样本
from sklearn.metrics.pairwise import cosine_similarity
# 过滤余弦相似度 > 0.95 的样本对
 
# 3. 按难度分层
difficulties = ["简单", "中等", "困难"]
# 每个难度级别均衡采样

23. 模型参数过载实验

答案:参数过载(Over-parameterization)在大模型中是一个研究热点,分析其影响有助于理解模型能力边界。


什么是参数过载

参数过载指模型的参数量远超拟合训练数据所需的最小量。

对于大模型来说,这几乎是常态(LLaMA-3 70B 用 15T tokens 训练,但参数量”够”存储的信息远多于此)。


参数量与训练数据量的关系(Chinchilla Scaling Law)

Chinchilla 最优比例:
训练 tokens ≈ 20 × 模型参数量

7B 参数 → 最优训练量约 140B tokens
LLaMA-3-8B → 实际训练了 15T tokens(超过最优约 100 倍)

"过训练"效果:
- 推理速度不变(参数量不变)
- 模型性能更好(充分学习)
- 这是工程实践中的主流选择(训练贵,推理便宜)

实验发现

发现 1:更小的模型 + 更多数据 ≈ 更大的模型 + 更少数据

GPT-3(175B,300B tokens)≈ LLaMA-13B(15T tokens)
LLaMA-3-8B(15T tokens)> LLaMA-1-65B(1.4T tokens)

发现 2:参数量决定能力上限

无论训练多少数据,小模型终究有能力天花板:

  • 1B 模型无法真正学会复杂推理
  • 参数量是涌现能力的基础条件

发现 3:过度微调会”压缩”参数空间

SFT 数据量过大时,模型参数向特定任务过度优化,其他能力的”参数空间”被压缩。


24. 微调大模型的一些建议

答案:工程实践中的关键注意事项。


数据方面

  1. 质量优先:先确保数据质量,再考虑数量
  2. 格式一致:整个数据集使用统一的 prompt 模板
  3. 多样性:覆盖多种任务类型,防止过拟合
  4. 清洗验证:随机抽样 100~200 条人工检查数据质量

训练超参数方面

# 推荐配置(7B 模型 LoRA 微调)
learning_rate = 2e-4          # LoRA 较大,全参用 1e-5~5e-5
lr_scheduler = "cosine"       # cosine 衰减
warmup_ratio = 0.05           # 5% warmup
num_train_epochs = 3          # 不要太多,防止过拟合
batch_size = 128              # 全局 batch(per_device × accumulation × gpu_count)
weight_decay = 0.01           # 轻微正则化
gradient_clipping = 1.0       # 防止梯度爆炸

训练过程监控

  1. Loss 曲线:训练 loss 稳定下降,验证 loss 不上升
  2. 梯度 Norm:不应出现极端值(spike)
  3. 中间保存 checkpoint:每隔固定步数保存,方便回退
  4. 及时评测:每隔一定步数在验证集上评测

其他建议

  1. 先跑小规模实验:用 1% 数据跑几步,验证代码和配置无误
  2. 使用 Wandb/TensorBoard:可视化监控训练状态
  3. 设置随机种子:确保实验可复现
  4. 保存原始模型:微调前备份,出问题可以回退

25. 微调大模型时,batch size 设置太小会出现什么问题?

答案:batch size 太小会导致训练不稳定,主要有以下问题。


问题 1:梯度噪声过大

小 batch → 梯度估计噪声大
→ 参数更新方向不稳定
→ Loss 曲线震荡

极端情况(batch_size=1):
每步梯度完全由单个样本决定
→ 可能更新方向完全错误
→ 训练极其不稳定

问题 2:BatchNorm 失效

虽然 LLM 使用 LayerNorm(不受 batch size 影响),但如果代码中有 BatchNorm 层(如图像分类头),小 batch 会导致统计量不准确。


问题 3:训练效率低

小 batch 导致 GPU 利用率低:
GPU 计算核心数量大,但每次处理的数据少
→ 大量计算单元空闲
→ 有效 throughput(tokens/s)低

问题 4:可能无法学习正确的归一化统计

部分训练技巧(如 GroupNorm)在小 batch 下工作不正常。


建议

  • 推荐全局 batch size:32~256(视任务和模型大小)
  • 如果显存不够,用梯度累积模拟大 batch:
    per_device_batch = 4
    gradient_accumulation = 8
    num_gpus = 4
    effective_batch = 4 × 8 × 4 = 128  # 等效大 batch

26. 微调大模型时,batch size 设置太大会出现什么问题?

答案:batch size 太大也有副作用,需要权衡。


问题 1:泛化性能下降(Sharp Minima)

这是最主要的问题,有大量研究支持:

小 batch → 噪声 → 逃离 sharp minima → 找到 flat minima
flat minima 泛化性更好

大 batch → 稳定收敛 → 容易陷入 sharp minima
sharp minima 泛化性差

实验:batch 从 256 增加到 8192,验证集精度下降 2~5%

问题 2:显存消耗增大

激活值显存 ∝ batch_size × seq_len
batch_size × 2 → 激活值显存 × 2

问题 3:需要更大的学习率(可能不稳定)

线性缩放规则:batch 扩大 k 倍,学习率也应扩大 k 倍:

原始:batch=32, lr=1e-4
大 batch:batch=256, lr=8e-4

但 lr 过大可能导致训练不稳定(loss spike)
需要更长的 warmup 期

解决方案

  • 大 batch 时使用学习率 warmup(让模型先用小 lr 稳定后再提高)
  • 使用 LAMB 优化器(专为大 batch 设计)
  • 通过验证集监控泛化性能

27. 微调大模型时,batch size 如何设置?

答案:综合考虑显存、训练稳定性和泛化性能。


实践建议

步骤 1:确定显存限制下的最大 per-device batch size
  → 从 1 开始逐步增大,直到 OOM 为止,取上限的 80%

步骤 2:确定全局 batch size
  → 通常 32~256(SFT 任务)
  → 用梯度累积补足:gradient_steps = 全局/(per_device × num_gpus)

步骤 3:小规模验证
  → 用 1% 数据跑 100 步,观察 Loss 是否正常下降

参考配置

模型GPU 配置per_device_bsaccumulation全局 bs
7B LoRA1×A100-40G4832
7B LoRA4×A100-40G4464
7B QLoRA1×RTX409021632
13B LoRA4×A100-40G2864

28. 微调大模型时,优化器如何选择?

答案:Adam 系列是主流,具体选择视资源和需求而定。


常用优化器对比

AdamW(最推荐)

optimizer = AdamW(
    model.parameters(),
    lr=2e-4,
    betas=(0.9, 0.999),
    eps=1e-8,
    weight_decay=0.01,  # L2 正则化
)
# 优点:训练稳定,效果好
# 缺点:需要存储两个动量(显存较大)

AdaFactor(显存友好)

from transformers import Adafactor
optimizer = Adafactor(
    model.parameters(),
    scale_parameter=True,
    relative_step=True,
    lr=None,
)
# 优点:不存储完整动量矩阵,显存约为 Adam 的 1/4
# 缺点:收敛可能不如 Adam 稳定

Lion(更新颖,效果不错)

# 只存储一阶矩,显存介于 SGD 和 Adam 之间
# 对大 batch 训练表现良好

SGD + Momentum(不推荐用于 LLM)

  • 没有自适应学习率
  • 对 LLM 微调效果差

推荐选择

资源充足:AdamW(最稳定,效果最好)
显存紧张:AdaFactor 或 8-bit Adam(bitsandbytes 库)
超大模型:AdaFactor 或 ZeRO + AdamW(分片优化器状态)

8-bit Adam:

import bitsandbytes as bnb
optimizer = bnb.optim.Adam8bit(model.parameters(), lr=2e-4)
# 优化器状态量化到 8-bit,节省约 50% 显存

29. 哪些因素会影响内存使用?

答案:训练显存由多个因素共同决定。


主要影响因素

(1)模型参数量

显存 ∝ 参数量 × 数据类型字节数
fp32:每参数 4 bytes
bf16/fp16:每参数 2 bytes
int8:每参数 1 byte
int4:每参数 0.5 byte

(2)序列长度(最关键)

注意力矩阵显存:O(n²)
激活值显存:O(n)

seq_len × 2 → 注意力显存 × 4

(3)Batch Size

激活值显存 ∝ batch_size
梯度检查点关闭时,激活值可能是主要显存消耗

(4)优化器类型

Adam:参数量 × 3(参数 + 一阶矩 + 二阶矩)
AdaFactor:显著减少
SGD:参数量 × 1(无动量)

(5)是否开启梯度检查点

开启:激活值显存减少 60~80%
关闭:完整保存所有激活值(显存消耗大)

(6)LoRA Rank

r 越大,LoRA 参数越多,梯度和优化器状态越大
r=8:极小显存额外开销
r=64:显存开销明显但仍远小于全参

(7)数据并行 vs 模型并行

数据并行:每卡有完整模型,显存不省
模型并行:模型分片,每卡只有部分模型,显存大幅减少

30. 进行领域大模型预训练应用哪些数据集比较好?

(详细内容已在第4题覆盖,此处提供汇总)

通用预训练数据集:

数据集语言规模特点
The Pile英文825 GB高质量多样
C4英文750 GB来自 CommonCrawl,质量好
WuDaoCorpora中文200B tokens最大中文语料之一
ROOTS多语言1.6TB59 种语言
RedPajama英文1.2T tokens开源复现 LLaMA
Dolma英文3T tokens开源,质量高

领域数据集:

领域数据集说明
代码The Stack, StarCoder DataGitHub 代码
医疗PubMed, PMC生物医学论文
法律Free Law Project美国法律判决
金融Financial News财经新闻
学术S2ORC, ArXiv学术论文

31. 用于大模型微调的数据集如何构建?

(已在第3题详细介绍,此处补充Self-Instruct和Evol-Instruct方法)


Self-Instruct 方法

"""
Self-Instruct 核心流程:
1. 准备少量种子指令(175条,人工写)
2. 用 GPT 生成新指令(基于现有指令)
3. 用 GPT 为指令生成回答
4. 质量过滤(去重、过滤有害内容)
5. 将新数据加入种子集
6. 循环迭代
"""
 
# 典型种子指令示例
seed_instructions = [
    {"instruction": "写一首关于秋天的诗"},
    {"instruction": "将以下句子翻译成法语"},
    {"instruction": "给出一个排序算法的 Python 代码"},
    ...
]

Evol-Instruct 方法(WizardLM)

对已有指令进行”进化”,生成更复杂、更多样的指令:

"""
进化方向:
1. 增加约束(Add Constraints):
   原始:"写一个故事"
   进化:"写一个关于时间旅行的故事,限制在500字以内,结尾要有惊喜"
   
2. 深化(Deepen):
   原始:"解释机器学习"
   进化:"深入解释机器学习中的反向传播算法,包括数学推导"
   
3. 具体化(Concretize):
   原始:"如何锻炼"
   进化:"为一个每天只有30分钟的上班族设计一套完整的居家锻炼计划"
   
4. 增加推理步骤(Increase Reasoning):
   原始:"1+1等于几"
   进化:"用苏格拉底式问答方式引导学生理解加法的本质"
"""

32-34. 大模型训练 Loss 突刺(Loss Spike)


32. 大模型训练 Loss 突刺是什么?

大模型训练过程中,Loss 曲线通常应该平稳下降。Loss 突刺(Loss Spike)指训练过程中 Loss 突然急剧增大(通常是正常值的 2~10 倍甚至更多),随后可能恢复也可能不恢复的现象。

正常训练 Loss 曲线:
3.5 ↓
3.2 ↓
2.9 ↓
2.7 ↓

Loss Spike:
2.5 ↓
2.3 ↓
2.1 ↓
5.8 ↑↑ ← Spike!
2.4 ↓(如果能恢复)
或
7.2 ↑(如果不能恢复,训练崩溃)

33. 为什么大模型训练会出现 Loss 突刺?


原因 1:数据质量问题(最常见)

问题数据类型:
- 极端值(超长序列、极短序列)
- 噪声文本(乱码、重复字符)
- 分布外数据(与主体训练数据差异极大)
- Tokenization 异常

当模型遇到一个极端 batch,梯度突然变得非常大
→ 大量权重更新 → Loss 急剧上升

原因 2:学习率设置过大

Loss ∝ learning_rate × gradient_norm

学习率过大 → 参数更新步长太大 → 跳过 loss 盆地
→ Loss 突然升高

特别在:
- warmup 结束后学习率突然跳变
- 使用固定 LR(无衰减)的情况下

原因 3:梯度爆炸

深层网络中,梯度可能在反向传播时指数级增大(梯度爆炸)
→ 参数更新极大 → Loss 突刺

检查:gradient_norm 突然异常大(正常 <1.0,spike 时可能 >100)

原因 4:Adam 优化器的动量问题

Adam 使用历史梯度的指数移动平均(EMA)
当梯度突然变化时,EMA 中的"历史"导致异常更新

特别是在训练恢复(resume)时:
- 保存了动量状态
- 恢复后数据分布变化
- 历史动量与新梯度方向不匹配 → Spike

原因 5:数值精度问题(fp16 下溢/上溢)

fp16 范围:约 ±65504
如果中间计算值超出范围 → inf 或 nan → Loss 突刺

解决:使用 bf16(范围更大但精度稍低)或 fp32
bf16 范围:约 ±3.4×10^38(与 fp32 同级别)

原因 6:批次数据异常(Bad Batch)

某个 batch 包含:
- 所有 token 都是同一个(如全是 <pad>)
- 序列长度极端异常
- 标签全部相同

→ 该 batch 的梯度异常 → Spike

34. 大模型训练 Loss 突刺如何解决?


预防措施(训练前):

(1)数据清洗

def filter_data(sample):
    text = sample["text"]
    
    # 长度过滤
    if len(text) < 10 or len(text) > 100000:
        return False
    
    # 重复字符过滤
    unique_chars = len(set(text))
    if unique_chars < 10:
        return False
    
    # PPL 过滤(用小模型计算困惑度)
    ppl = compute_perplexity(text)
    if ppl > 10000:  # PPL 极高 = 乱码
        return False
    
    return True

(2)梯度裁剪(最有效的预防手段)

# 将梯度 norm 裁剪到最大值
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
 
# 在 HuggingFace Trainer 中
trainer = Trainer(
    max_grad_norm=1.0,  # 关键参数
    ...
)

(3)学习率 warmup

# 学习率从 0 线性增加到目标 LR,避免训练初期大幅更新
warmup_steps = 2000
scheduler = get_cosine_schedule_with_warmup(
    optimizer,
    num_warmup_steps=warmup_steps,
    num_training_steps=total_steps
)

(4)使用 BF16 代替 FP16

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,  # 比 fp16 范围更大,数值更稳定
)

应对措施(训练中遇到 Spike):

(1)跳过问题 batch

def train_step(batch):
    try:
        loss = model(**batch).loss
        
        # 检测异常 loss
        if loss.item() > 10 * running_loss_avg:
            print(f"Skip bad batch, loss={loss.item():.2f}")
            return None
        
        loss.backward()
        return loss
    except RuntimeError as e:
        if "nan" in str(e) or "inf" in str(e):
            print("NaN/Inf detected, skip batch")
            return None

(2)回退到最近的正常 checkpoint

监控策略:
每 500 步保存一个 checkpoint

发现 Spike:
→ 检查梯度 norm 是否异常
→ 排查该步骤的 batch 数据
→ 从最近正常 checkpoint 恢复
→ 跳过或修复问题数据
→ 继续训练

(3)动态学习率调整

# 检测到 Spike 时自动降低学习率
class SpikeLRHandler:
    def __init__(self, threshold=3.0):
        self.threshold = threshold
        self.prev_loss = float('inf')
    
    def check_and_adjust(self, current_loss, optimizer):
        ratio = current_loss / self.prev_loss
        if ratio > self.threshold:
            for g in optimizer.param_groups:
                g['lr'] *= 0.5
            print(f"Loss spike detected! LR reduced to {g['lr']:.2e}")
        else:
            self.prev_loss = current_loss

(4)数据 shuffle + 重新排队

如果 Spike 与特定数据位置相关
→ 打乱数据顺序重新训练
→ 问题数据会被"平均"到其他 batch 中

总结:Loss Spike 处理流程

发现 Loss Spike
    ↓
1. 查看当时的梯度 norm(是否异常大?)
2. 检查 batch 数据(是否有问题样本?)
3. 检查 loss 值(NaN/Inf?)
    ↓
如果是数据问题:
→ 清洗数据,跳过问题 batch,从 checkpoint 恢复

如果是超参数问题:
→ 降低学习率,增大 warmup
→ 增强梯度裁剪(max_norm=0.5)

如果是数值精度:
→ 换用 bf16
→ 检查 loss scaling(fp16 AMP)

如果无法定位原因:
→ 从最近 checkpoint 恢复,继续观察