大语言模型微调有哪些主流方法？各自适用场景是什么？

问题分析

大语言模型的微调是将其从通用能力转化为特定领域能力的关键技术。随着模型规模从几十亿增长到数千亿参数，传统的全量微调方法因计算成本过高而不再适用，催生了多种高效微调技术。

当前主流的微调方法可以按参数更新范围分为三大类：全量微调（Full Fine-tuning）、参数高效微调（Parameter-Efficient Fine-Tuning，PEFT）和提示微调（Prompt-based Tuning）。每类方法内部又有多个具体技术方案。

选择合适的微调方法需要考虑多个维度：任务类型（分类、生成、对话）、数据规模（几十条到数百万条）、计算资源（单卡到多节点集群）、性能要求（需要接近全量微调的效果还是接受一定折衷）、部署约束（推理时的显存和延迟要求）。

很多开发者对各类方法的原理理解不深，仅凭"听说 LoRA 效果好"就盲目使用，导致实际效果不佳或资源浪费。深入理解各方法的适用场景是正确选型的前提。

解决原理

全量微调（Full Fine-tuning）

全量微调更新模型的所有参数，是最直接也最有效的微调方式。原理上，预训练模型学习到的是通用语言表示，全量微调通过在目标任务上的梯度下降，调整所有参数以适应特定任务。

优点是效果最好，能充分适应目标领域。缺点是计算成本极高（需要存储完整的优化器状态，约为模型参数的 2-3 倍显存），且容易过拟合（小数据集上尤为明显），还可能导致灾难性遗忘（catastrophic forgetting），即模型在微调任务上表现提升但在原有能力上退化。

适用场景：大规模数据集（>10 万条）、计算资源充足、追求最佳性能、有明确的单一任务目标。

LoRA（Low-Rank Adaptation）

LoRA 的核心思想是假设参数更新矩阵是低秩的。对于预训练权重矩阵 $W$，微调后的权重可以表示为 $W' = W + \Delta W$，其中 $\Delta W = BA$，$B$ 和 $A$ 是低秩矩阵（秩 $r \ll d$）。训练时只更新 $A$ 和 $B$，冻结原始 $W$。

优点是训练参数量极小（通常 <1%），显存占用低，训练速度快。缺点是理论上限低于全量微调，秩 $r$ 的选择需要调参。

适用场景：中小规模数据集、有限计算资源、需要快速迭代实验、多任务部署（可以为每个任务训练独立的 LoRA 适配器）。

QLoRA（Quantized LoRA）

QLoRA 在 LoRA 基础上引入了量化技术。将基座模型量化为 4-bit NF（NormalFloat）格式，在推理时反量化并计算，梯度只传给 LoRA 参数。还引入了双重量化（Double Quantization）进一步减少显存占用。

优点是显存占用极低（可以单卡微调 70B 模型），效果接近标准 LoRA。缺点是训练速度稍慢（量化/反量化开销），对硬件有一定要求（需要支持 INT4 的 GPU）。

适用场景：消费级显卡、超大规模模型（>30B）、资源极度受限。

Prefix Tuning

在输入序列前添加一组可学习的连续向量（virtual tokens），训练时只更新这些 prefix 参数。模型将 prefix 视为上下文，引导生成符合任务要求的输出。

优点是参数极少，可以在线学习。缺点是输入序列变长占用额外计算资源，效果受 prefix 长度影响大。

适用场景：生成任务、对话系统、需要在线学习的场景。

Prompt Tuning

与 Prefix Tuning 类似，但只优化输入端的 prompt embeddings，不涉及模型内部结构。更轻量，但能力也有限。

适用场景：简单分类任务、API 调用场景（如 OpenAI 的 Fine-tuning API）、无权修改模型的场景。

Adapter

在 Transformer 的层之间插入小型 bottleneck 结构（先降维再升维的 MLP），训练时只更新 adapter 参数。相比 LoRA，adapter 需要修改模型结构。

适用场景：多任务迁移学习、需要对不同层进行差异化调整。

方法对比表

程序实现与说明

"""
大语言模型微调方法对比实现
展示不同微调方法的核心代码
"""

import os
os.environ['HF_HOME'] = r'D:\models\hf_cache'

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from datasets import load_dataset

# ================== 方法一：全量微调 ==================

def full_finetune_demo():
    """
    全量微调示例
    所有参数都参与训练，效果最好但资源消耗最大
    """
    model_name = "Qwen/Qwen2-7B-Instruct"
    
    # 加载模型（全精度）
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        torch_dtype=torch.bfloat16,
        device_map="auto"
    )
    
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    
    # 关键：所有参数都设为可训练
    for param in model.parameters():
        param.requires_grad = True
    
    # 训练参数（需要大 batch size 和学习率衰减）
    training_args = TrainingArguments(
        output_dir="./full_finetune",
        num_train_epochs=3,
        per_device_train_batch_size=4,
        gradient_accumulation_steps=4,
        learning_rate=2e-5,  # 全量微调用较小学习率
        weight_decay=0.01,
        warmup_ratio=0.03,
        lr_scheduler_type="cosine",
        bf16=True,
        logging_steps=10
    )
    
    # 显存估算：模型参数 + 梯度 + 优化器状态
    # 7B 模型全量微调约需 80GB+ 显存
    
    print("[全量微调] 参数量:", sum(p.numel() for p in model.parameters()))
    print("[全量微调] 可训练参数:", sum(p.numel() for p in model.parameters() if p.requires_grad))
    
    return model, tokenizer, training_args


# ================== 方法二：LoRA 微调 ==================

def lora_finetune_demo():
    """
    LoRA 微调示例
    只训练低秩适配器，大幅减少参数量
    """
    from peft import LoraConfig, get_peft_model, TaskType
    
    model_name = "Qwen/Qwen2-7B-Instruct"
    
    # 加载基座模型
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        torch_dtype=torch.bfloat16,
        device_map="auto"
    )
    
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    
    # LoRA 配置（核心参数）
    lora_config = LoraConfig(
        task_type=TaskType.CAUSAL_LM,
        r=16,  # LoRA 秩，影响效果和参数量
        lora_alpha=32,  # 缩放因子，通常设为 2r
        lora_dropout=0.05,
        
        # 指定要应用 LoRA 的模块
        # attention 的 QKV 输出 + MLP 层
        target_modules=[
            "q_proj", "k_proj", "v_proj", "o_proj",
            "gate_proj", "up_proj", "down_proj"
        ],
        bias="none"
    )
    
    # 应用 LoRA
    model = get_peft_model(model, lora_config)
    
    # 训练参数（可以用更大学习率）
    training_args = TrainingArguments(
        output_dir="./lora_finetune",
        num_train_epochs=3,
        per_device_train_batch_size=8,
        gradient_accumulation_steps=2,
        learning_rate=2e-4,  # LoRA 可用较大学习率
        bf16=True,
        logging_steps=10
    )
    
    model.print_trainable_parameters()
    # 输出示例：trainable params: 4,194,304 || all params: 7,000,000,000 || trainable%: 0.06%
    
    return model, tokenizer, training_args


# ================== 方法三：QLoRA 微调 ==================

def qlora_finetune_demo():
    """
    QLoRA 微调示例
    4-bit 量化 + LoRA，极低显存占用
    """
    from peft import LoraConfig, get_peft_model, TaskType
    from transformers import BitsAndBytesConfig
    
    model_name = "Qwen/Qwen2-7B-Instruct"
    
    # 4-bit 量化配置（核心）
    bnb_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_quant_type="nf4",  # NormalFloat4，更适合正态分布
        bnb_4bit_compute_dtype=torch.bfloat16,
        bnb_4bit_use_double_quant=True  # 双重量化，进一步减少显存
    )
    
    # 加载 4-bit 量化模型
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        quantization_config=bnb_config,
        device_map="auto"
    )
    
    tokenizer = AutoTokenizer.from_pretrained(model_name)
    
    # LoRA 配置（与标准 LoRA 相同）
    lora_config = LoraConfig(
        task_type=TaskType.CAUSAL_LM,
        r=16,
        lora_alpha=32,
        target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
        lora_dropout=0.05
    )
    
    model = get_peft_model(model, lora_config)
    
    print("[QLoRA] 模型加载完成")
    print("[QLoRA] 显存占用: 约 4GB（对比全量约 28GB）")
    
    training_args = TrainingArguments(
        output_dir="./qlora_finetune",
        num_train_epochs=3,
        per_device_train_batch_size=8,
        gradient_accumulation_steps=2,
        learning_rate=2e-4,
        bf16=True
    )
    
    return model, tokenizer, training_args


# ================== 方法四：Prefix Tuning ==================

def prefix_tuning_demo():
    """
    Prefix Tuning 示例
    在输入前添加可学习的虚拟 token
    """
    from peft import PrefixTuningConfig, get_peft_model, TaskType
    
    model_name = "Qwen/Qwen2-7B-Instruct"
    
    # 加载模型
    model = AutoModelForCausalLM.from_pretrained(
        model_name,
        torch_dtype=torch.bfloat16,
        device_map="auto"
    )
    
    # Prefix Tuning 配置
    prefix_config = PrefixTuningConfig(
        task_type=TaskType.CAUSAL_LM,
        num_virtual_tokens=20,  # 虚拟 token 数量
        prefix_projection=True,  # 是否使用投影层
        prefix_projection_hidden_dim=512
    )
    
    model = get_peft_model(model, prefix_config)
    model.print_trainable_parameters()
    
    print("[Prefix Tuning] 添加了 20 个可学习的虚拟 token")
    
    return model


# ================== 选型决策函数 ==================

def select_finetune_method(
    data_size: int,
    gpu_memory_gb: int,
    target_performance: str = "medium",
    task_type: str = "generation"
) -> str:
    """
    根据实际情况推荐微调方法
    
    data_size: 数据集样本数
    gpu_memory_gb: 可用显存（GB）
    target_performance: "high" / "medium" / "low"
    task_type: "generation" / "classification" / "chat"
    
    返回推荐的方法名称
    """
    
    # 决策逻辑
    if gpu_memory_gb >= 80 and data_size >= 100000 and target_performance == "high":
        return "全量微调"
    
    elif gpu_memory_gb >= 24 and data_size >= 10000:
        return "LoRA"
    
    elif gpu_memory_gb >= 12:
        return "QLoRA"
    
    elif task_type == "chat" and data_size < 1000:
        return "Prefix Tuning"
    
    elif task_type == "classification" and data_size < 500:
        return "Prompt Tuning"
    
    else:
        return "QLoRA（通用推荐）"


if __name__ == "__main__":
    # 示例：根据条件选型
    method = select_finetune_method(
        data_size=5000,
        gpu_memory_gb=24,
        target_performance="high",
        task_type="generation"
    )
    print(f"推荐方法: {method}")

关键代码行解析：

param.requires_grad = True：全量微调的核心设置，将所有参数设为可训练。PEFT 方法会冻结基座模型，只更新适配器参数。

LoraConfig(r=16)：r 是 LoRA 秩，决定适配器参数量。r 越大效果越好但参数越多，常用值为 8、16、32、64。

bnb_4bit_quant_type="nf4"：NF4（NormalFloat4）是 QLoRA 提出的量化格式，相比标准 INT4 更适合存储正态分布的模型权重。

num_virtual_tokens=20：Prefix Tuning 的虚拟 token 数量。太少效果不好，太多占用序列长度。

选型建议总结：

• 有充足资源且追求极致效果 → 全量微调
• 常规微调场景（数据 >1 万条，显存 >24GB）→ LoRA
• 资源有限但想用大模型 → QLoRA
• 小数据集对话任务 → Prefix Tuning
• API 调用或无权修改模型 → Prompt Tuning