56_大模型微调：全参数与参数高效方法对比

大模型微调技术演进
├── 传统阶段(2017-2020): 全参数微调，资源消耗巨大
├── 发展阶段(2021-2022): 早期参数高效方法(Prefix-Tuning等)
├── 成熟阶段(2023-2024): LoRA/QLoRA主导的参数高效微调
└── 融合阶段(2025): 多种微调技术融合，自适应策略选择

目录
├── 第一章：大模型微调概述
├── 第二章：全参数微调技术深度解析
├── 第三章：参数高效微调原理与方法
├── 第四章：LoRA系列技术详解
├── 第五章：其他主流参数高效微调方法
├── 第六章：微调技术全面对比
├── 第七章：微调实践与工程优化
├── 第八章：行业应用案例分析
├── 第九章：微调评测与效果分析
└── 第十章：未来发展趋势与建议

预训练模型 → 数据准备 → 微调配置 → 训练过程 → 模型评估 → 部署应用

# 全参数微调环境配置示例
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer

# 检查是否有可用GPU
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")

# 设置混合精度训练
torch.backends.cudnn.benchmark = True  # 加速训练

# 加载预训练模型和分词器
model_name = "meta-llama/Llama-2-70b-hf"  # 以Llama-2 70B为例

# 注意：实际使用时需根据可用内存调整模型大小
tokenizer = AutoTokenizer.from_pretrained(model_name)

# 配置模型加载参数
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,  # 使用BF16混合精度
    device_map="auto",  # 自动分配到可用设备
    low_cpu_mem_usage=True,  # 低内存加载策略
    load_in_8bit=False,  # 不使用8位量化
    trust_remote_code=True,  # 允许执行远程代码
)

# 准备训练数据集
def prepare_dataset(examples):
    # 处理输入文本
    inputs = tokenizer(examples["text"], truncation=True, max_length=512)
    # 设置标签（对于因果语言模型，标签等于输入）
    inputs["labels"] = inputs["input_ids"].copy()
    return inputs

# 加载并处理数据集
dataset = load_dataset("your_dataset_name")
processed_dataset = dataset.map(prepare_dataset, batched=True)

# 划分训练集和验证集
train_dataset = processed_dataset["train"]
eval_dataset = processed_dataset["validation"]

# 配置训练参数
training_args = TrainingArguments(
    output_dir="./llama-finetuned",  # 输出目录
    overwrite_output_dir=True,
    num_train_epochs=3,  # 训练轮数
    per_device_train_batch_size=4,  # 每设备训练批次大小
    per_device_eval_batch_size=4,  # 每设备评估批次大小
    gradient_accumulation_steps=8,  # 梯度累积步数
    eval_accumulation_steps=1,
    save_strategy="epoch",  # 按轮次保存模型
    evaluation_strategy="epoch",  # 按轮次评估
    learning_rate=2e-5,  # 学习率
    weight_decay=0.01,  # 权重衰减
    warmup_ratio=0.1,  # 预热比例
    logging_dir="./logs",  # 日志目录
    logging_steps=10,  # 日志记录步数
    fp16=True,  # 使用混合精度训练
    bf16=False,  # 不使用BF16（根据硬件支持选择）
    tf32=True,  # 使用TF32格式加速（Ampere及以上GPU支持）
    gradient_checkpointing=True,  # 启用梯度检查点节省内存
    dataloader_num_workers=4,  # 数据加载器工作线程数
    optim="adamw_torch",  # 优化器
    report_to=["tensorboard"],  # 报告方式
)

# 创建训练器
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    tokenizer=tokenizer,
    # 可以添加自定义数据收集器和评估指标
)

# 开始训练
trainer.train()

# 保存微调后的模型
trainer.save_model("./llama-finetuned-final")
tokenizer.save_pretrained("./llama-finetuned-final")

# 使用PEFT库进行参数高效微调的基本流程
from peft import LoraConfig, get_peft_model, TaskType
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer

# 1. 加载基础模型
base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    torch_dtype=torch.bfloat16,
    device_map="auto"
)

# 2. 配置PEFT方法
peft_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    inference_mode=False,
    r=8,  # LoRA秩
    lora_alpha=32,  # LoRA缩放因子
    lora_dropout=0.1,  # LoRA dropout概率
    target_modules=["q_proj", "v_proj"],  # 目标模块
    bias="none"  # 不训练bias参数
)

# 3. 创建PEFT模型
model = get_peft_model(base_model, peft_config)

# 4. 打印可训练参数信息
model.print_trainable_parameters()
# 输出示例: trainable params: 1,228,800 || all params: 6,742,609,920 || trainable%: 0.0182

# 5. 后续训练与评估过程与全参数微调类似
# ...

# LoRA层的基本实现
import torch
import torch.nn as nn

class LoRALayer(nn.Module):
    def __init__(self, in_features, out_features, rank, alpha=1.0):
        super().__init__()
        # 初始化低秩矩阵
        self.A = nn.Parameter(torch.zeros(rank, in_features))
        self.B = nn.Parameter(torch.zeros(out_features, rank))
        self.alpha = alpha
        self.rank = rank
        
        # 使用Kaiming初始化
        nn.init.kaiming_uniform_(self.A, a=math.sqrt(5))
        nn.init.zeros_(self.B)
    
    def forward(self, x):
        # 计算低秩适应
        # 注意这里的计算顺序：x @ A.T @ B.T
        # 或者等效的：(B @ A) @ x
        result = self.alpha * x @ self.A.transpose(0, 1) @ self.B.transpose(0, 1)
        return result

# 将LoRA注入到现有模型中
def inject_lora(model, target_modules, rank=8, alpha=32, dropout=0.1):
    # 遍历模型的所有模块
    for name, module in model.named_modules():
        # 检查是否为目标模块
        if any(target in name for target in target_modules):
            # 保存原始权重
            weight = module.weight.data
            in_features, out_features = weight.shape
            
            # 创建LoRA层
            lora = LoRALayer(in_features, out_features, rank, alpha)
            
            # 将LoRA层添加到模块中
            setattr(module, 'lora', lora)
            setattr(module, 'lora_dropout', nn.Dropout(dropout))
            
            # 修改前向传播
            original_forward = module.forward
            
            def new_forward(self, x):
                # 原始输出
                original_output = F.linear(x, self.weight, self.bias)
                # LoRA输出
                lora_output = self.lora(self.lora_dropout(x))
                # 合并结果
                return original_output + lora_output
            
            # 替换前向传播方法
            module.forward = types.MethodType(new_forward, module)
    
    return model

# 使用PEFT库配置和实现LoRA
from peft import LoraConfig, get_peft_model, TaskType
from transformers import AutoModelForCausalLM

# 加载基础模型
base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")

# 配置LoRA参数
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    inference_mode=False,  # 训练模式
    r=16,  # LoRA秩，值越大参数越多，能力越强
    lora_alpha=32,  # LoRA缩放因子
    lora_dropout=0.1,  # LoRA dropout概率
    target_modules=[  # 应用LoRA的模块
        "q_proj",  # 查询投影
        "k_proj",  # 键投影
        "v_proj",  # 值投影
        "o_proj",  # 输出投影
        "gate_proj",  # 门控投影(对于MLP层)
        "up_proj",  # 上投影
        "down_proj",  # 下投影
    ],
    bias="none",  # 不训练bias参数
    fan_in_fan_out=False,  # 是否使用fan_in_fan_out权重初始化
    modules_to_save=None,  # 需要额外保存的模块
    init_lora_weights=True,  # 是否初始化LoRA权重
)

# 创建LoRA模型
model = get_peft_model(base_model, lora_config)

# 打印可训练参数信息
print("可训练参数占比:")
model.print_trainable_parameters()

# 输出示例:
# trainable params: 41,943,040 || all params: 6,794,553,344 || trainable%: 0.617

# LoRA权重保存与加载

# 保存LoRA权重
model.save_pretrained("./lora-weights")

# 加载LoRA权重到基础模型
from peft import PeftModel

# 加载基础模型
base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")

# 加载LoRA权重
model = PeftModel.from_pretrained(
    base_model,
    "./lora-weights",
    device_map="auto",
    torch_dtype=torch.bfloat16
)

# 合并LoRA权重到基础模型(推理优化)
merged_model = model.merge_and_unload()

# 保存合并后的完整模型
merged_model.save_pretrained("./merged-model")

# QLoRA实现示例
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model, TaskType
from peft import prepare_model_for_kbit_training

# 配置QLoRA参数
bits = 4  # 量化位数
use_nf4 = True  # 使用NF4量化数据类型
use_double_quant = True  # 使用双重量化

# 加载4位量化模型
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    load_in_4bit=True,
    device_map="auto",
    quantization_config={
        "load_in_4bit": True,
        "bnb_4bit_compute_dtype": torch.bfloat16,
        "bnb_4bit_use_double_quant": use_double_quant,
        "bnb_4bit_quant_type": "nf4" if use_nf4 else "fp4",
    },
    torch_dtype=torch.bfloat16,
)

# 准备模型进行k位训练
model = prepare_model_for_kbit_training(model)

# 配置LoRA参数
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    inference_mode=False,
    r=64,  # 对于QLoRA，秩可以设置更大
    lora_alpha=16,
    lora_dropout=0.1,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    bias="none",
)

# 创建QLoRA模型
model = get_peft_model(model, lora_config)

# 打印可训练参数
model.print_trainable_parameters()
# 输出示例: trainable params: 104,857,600 || all params: 6,794,553,344 || trainable%: 1.543

# AdaLoRA实现示例
from peft import AdaLoraConfig, get_peft_model

# 配置AdaLoRA参数
adalora_config = AdaLoraConfig(
    task_type=TaskType.CAUSAL_LM,
    inference_mode=False,
    r=64,  # 初始秩
    lora_alpha=32,
    lora_dropout=0.1,
    target_r=4,  # 最终目标秩
    init_r=12,  # 初始化秩
    tinit=0,  # 预热轮数
    tfinal=0,  # 最终轮数
    deltaT=1,  # 调整间隔
    beta1=0.85,  # EMA参数1
    beta2=0.85,  # EMA参数2
    orth_reg_weight=0.5,  # 正交正则化权重
    target_modules=["q_proj", "v_proj"],
)

# 创建AdaLoRA模型
model = get_peft_model(base_model, adalora_config)

# AdaLoRA在训练过程中会自动调整秩
# ...训练代码...

# P-Tuning v2实现示例
from peft import get_peft_config, get_peft_model, PromptEncoderConfig, TaskType

# 配置P-Tuning v2参数
peft_config = PromptEncoderConfig(
    task_type=TaskType.CAUSAL_LM,
    inference_mode=False,
    num_virtual_tokens=20,  # 虚拟token数量
    token_dim=768,  # token维度(与模型隐藏层维度一致)
    num_transformer_submodules=1,  # transformer子模块数量
    num_attention_heads=12,  # 注意力头数量
    num_layers=2,  # Prompt encoder层数
    encoder_hidden_size=768,  # Encoder隐藏层大小
)

# 创建P-Tuning v2模型
model = get_peft_model(base_model, peft_config)

# 打印可训练参数
model.print_trainable_parameters()
# 输出示例: trainable params: 2,002,944 || all params: 6,786,455,552 || trainable%: 0.0295

输入 → 原始层 → 残差连接
      ↓
    Adapter模块: FC → Activation → FC

# Adapter模块实现
class Adapter(nn.Module):
    def __init__(self, input_dim, reduction_factor=4):
        super().__init__()
        self.input_dim = input_dim
        self.reduction_factor = reduction_factor
        self.down_size = input_dim // reduction_factor
        
        # 瓶颈结构
        self.down_proj = nn.Linear(input_dim, self.down_size)
        self.activation = nn.GELU()
        self.up_proj = nn.Linear(self.down_size, input_dim)
        self.dropout = nn.Dropout(0.1)
        
        # 初始化，确保初始时适配器不影响原始输出
        nn.init.zeros_(self.up_proj.weight)
        nn.init.zeros_(self.up_proj.bias)
    
    def forward(self, x):
        # 前向传播
        residual = x
        x = self.down_proj(x)
        x = self.activation(x)
        x = self.dropout(x)
        x = self.up_proj(x)
        # 残差连接
        return residual + x

# 使用PEFT库配置Adapter
from peft import AdapterConfig, get_peft_model

adapter_config = AdapterConfig(
    task_type=TaskType.CAUSAL_LM,
    inference_mode=False,
    adapter_type="houlsby",  # Adapter类型
    reduction_factor=16,  # 降维因子
    non_linearity="gelu",  # 激活函数
    bias=True,  # 使用偏置
)

# 创建Adapter模型
model = get_peft_model(base_model, adapter_config)

# 打印可训练参数
model.print_trainable_parameters()

# Prompt Tuning实现示例
from peft import PromptTuningConfig, get_peft_model

# 配置Prompt Tuning参数
prompt_config = PromptTuningConfig(
    task_type=TaskType.CAUSAL_LM,
    inference_mode=False,
    num_virtual_tokens=10,  # 虚拟token数量
    token_dim=4096,  # token维度
    num_init_from_vocab=5,  # 从词汇表初始化的token数量
    prompt_tuning_init="TEXT",  # 初始化方法
    prompt_tuning_init_text="""<|endoftext|>""",  # 初始化文本
)

# 创建Prompt Tuning模型
model = get_peft_model(base_model, prompt_config)

# 打印可训练参数
model.print_trainable_parameters()
# 输出示例: trainable params: 40,960 || all params: 6,786,414,592 || trainable%: 0.0006

# BitFit实现示例
from peft import BitFitConfig, get_peft_model

# 配置BitFit参数
bitfit_config = BitFitConfig(
    task_type=TaskType.CAUSAL_LM,
    inference_mode=False,
    bias_only=True,  # 仅训练bias参数
)

# 创建BitFit模型
model = get_peft_model(base_model, bitfit_config)

# 打印可训练参数
model.print_trainable_parameters()
# 输出示例: trainable params: 131,072 || all params: 6,786,414,592 || trainable%: 0.00193

开始微调方法选择
  ↓
是否有充足的计算资源?
  ↓─ 是 ─→ 任务是否极为关键且资源不是问题?
  |            ↓─ 是 ─→ 选择全参数微调
  |            ↓─ 否 ─→ 追求最佳性价比?
  |                       ↓─ 是 ─→ 选择LoRA (r=32-64)
  |                       ↓─ 否 ─→ 全参数微调
  ↓─ 否 ─→ 可用内存是否极为有限?
             ↓─ 是 ─→ 是否需要接近全参数的性能?
             |            ↓─ 是 ─→ 选择QLoRA
             |            ↓─ 否 ─→ 任务是否为分类任务?
             |                       ↓─ 是 ─→ 考虑BitFit或Prompt Tuning
             |                       ↓─ 否 ─→ 选择Prompt Tuning
             ↓─ 否 ─→ 任务复杂度如何?
                        ↓─ 高 ─→ 选择LoRA (r=16-32)
                        ↓─ 中 ─→ 选择LoRA (r=8-16)或Adapter
                        ↓─ 低 ─→ 选择Adapter或P-Tuning

# 数据预处理示例
def preprocess_data(data):
    # 1. 清洗文本
    data = clean_text(data)
    
    # 2. 格式标准化
    data = standardize_format(data)
    
    # 3. 去除重复数据
    data = remove_duplicates(data)
    
    # 4. 数据增强(可选)
    if augment_data:
        data = augment_data(data)
    
    # 5. 划分训练/验证/测试集
    train_data, val_data, test_data = split_data(data, ratio=(0.8, 0.1, 0.1))
    
    return train_data, val_data, test_data

# 学习率调度器配置
from transformers import get_linear_schedule_with_warmup

# 计算总训练步数
total_steps = len(train_dataloader) * num_epochs // gradient_accumulation_steps
warmup_steps = int(0.1 * total_steps)  # 10%的预热步数

# 创建学习率调度器
scheduler = get_linear_schedule_with_warmup(
    optimizer,
    num_warmup_steps=warmup_steps,
    num_training_steps=total_steps
)

# 使用PyTorch DDP进行数据并行训练
import torch.distributed as dist
import torch.multiprocessing as mp
from torch.nn.parallel import DistributedDataParallel as DDP

def setup(rank, world_size):
    os.environ['MASTER_ADDR'] = 'localhost'
    os.environ['MASTER_PORT'] = '12355'
    dist.init_process_group("nccl", rank=rank, world_size=world_size)

def cleanup():
    dist.destroy_process_group()

def train(rank, world_size):
    setup(rank, world_size)
    
    # 加载模型(注意需要在每个进程中单独加载)
    model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
    model = model.to(rank)
    
    # 包装为DDP模型
    ddp_model = DDP(model, device_ids=[rank])
    
    # 后续训练代码...
    
    cleanup()

if __name__ == "__main__":
    world_size = torch.cuda.device_count()
    mp.spawn(train, args=(world_size,), nprocs=world_size, join=True)

# DeepSpeed配置示例
{
  "train_batch_size": 64,
  "train_micro_batch_size_per_gpu": 4,
  "gradient_accumulation_steps": 16,
  "zero_optimization": {
    "stage": 3,  # ZeRO-3阶段
    "offload_optimizer": {
      "device": "cpu",
      "pin_memory": true
    },
    "offload_param": {
      "device": "cpu",
      "pin_memory": true
    },
    "overlap_comm": true,
    "contiguous_gradients": true,
    "sub_group_size": 1e9,
    "reduce_bucket_size": "auto",
    "stage3_prefetch_bucket_size": "auto",
    "stage3_param_persistence_threshold": "auto",
    "stage3_max_live_parameters": 1e9,
    "stage3_max_reuse_distance": 1e9
  },
  "fp16": {
    "enabled": "auto",
    "loss_scale": 0,
    "loss_scale_window": 1000,
    "initial_scale_power": 16,
    "hysteresis": 2,
    "min_loss_scale": 1
  }
}

# 使用PyTorch FSDP进行模型并行训练
from torch.distributed.fsdp import FullyShardedDataParallel as FSDP
from torch.distributed.fsdp.fully_sharded_data_parallel import CPUOffloadPolicy
from torch.distributed.fsdp.wrap import transformer_auto_wrap_policy

# 定义要包装的Transformer层
from transformers import LlamaDecoderLayer

def fsdp_train():
    # 初始化分布式环境
    dist.init_process_group("nccl")
    rank = dist.get_rank()
    
    # 创建模型
    model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-70b-hf")
    
    # 配置FSDP策略
    auto_wrap_policy = transformer_auto_wrap_policy({
        LlamaDecoderLayer,  # 指定要包装的层类
    })
    
    # 创建FSDP模型
    fsdp_model = FSDP(
        model,
        auto_wrap_policy=auto_wrap_policy,
        cpu_offload=CPUOffloadPolicy.OFFLOAD,
        mixed_precision=get_mixed_precision_policy("bfloat16"),
        sharding_strategy=ShardingStrategy.FULL_SHARD,
        device_id=torch.cuda.current_device(),
        forward_prefetch=True,
    )
    
    # 后续训练代码...

# LoRA模型合并与导出示例
from peft import PeftModel
from transformers import AutoModelForCausalLM

# 加载基础模型和LoRA权重
base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf")
peft_model = PeftModel.from_pretrained(base_model, "./lora-weights")

# 合并权重
merged_model = peft_model.merge_and_unload()

# 导出为不同格式
# 1. 导出为HuggingFace格式
merged_model.save_pretrained("./merged-model")

# 2. 导出为ONNX格式(可选)
from transformers import AutoTokenizer
import torch
import onnx
import onnxruntime as ort

tokenizer = AutoTokenizer.from_pretrained("./merged-model")

# 创建示例输入
dummy_input = tokenizer("Hello, this is a test", return_tensors="pt")

# 导出为ONNX
with torch.no_grad():
    torch.onnx.export(
        merged_model,
        tuple(dummy_input.values()),
        "./model.onnx",
        opset_version=14,
        input_names=["input_ids", "attention_mask"],
        output_names=["output"],
        dynamic_axes={
            "input_ids": {0: "batch_size", 1: "seq_len"},
            "attention_mask": {0: "batch_size", 1: "seq_len"},
            "output": {0: "batch_size", 1: "seq_len"},
        }
    )

# CI/CD配置示例(GitLab CI)
stages:
  - train
  - evaluate
  - deploy

variables:
  MODEL_NAME: "fine-tuned-llm"
  DOCKER_REGISTRY: "registry.example.com"

train_model:
  stage: train
  script:
    - python scripts/train.py --config configs/finetune.yaml
    - python scripts/merge_weights.py --output ./models/$MODEL_NAME
  artifacts:
    paths:
      - ./models/$MODEL_NAME

evaluate_model:
  stage: evaluate
  script:
    - python scripts/evaluate.py --model ./models/$MODEL_NAME
  needs:
    - train_model

deploy_model:
  stage: deploy
  script:
    - docker build -t $DOCKER_REGISTRY/$MODEL_NAME:latest .
    - docker push $DOCKER_REGISTRY/$MODEL_NAME:latest
    - kubectl apply -f k8s/deployment.yaml
  needs:
    - evaluate_model
  only:
    - main

# 金融对话系统LoRA微调示例
from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer

# 配置金融领域特定的LoRA参数
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=32,
    lora_alpha=64,
    lora_dropout=0.1,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    bias="none",
)

# 金融领域数据格式示例
financial_data = [
    {
        "instruction": "作为金融顾问，请解释什么是资产负债表。",
        "response": "资产负债表是反映企业在特定日期财务状况的会计报表，主要包含资产、负债和所有者权益三个部分..."
    },
    {
        "instruction": "分析利率上升对债券价格的影响。",
        "response": "利率上升通常会导致债券价格下跌，这是因为当市场利率上升时，新发行的债券提供更高的收益率..."
    }
]

# 其余训练代码类似前面章节
# ...

# 医疗诊断系统微调配置
from transformers import AutoModelForCausalLM
from peft import QLoraConfig, get_peft_model

# 配置QLoRA用于医疗诊断微调
qlora_config = QLoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=64,
    lora_alpha=16,
    lora_dropout=0.05,
    bias="none",
    target_modules=["q_proj", "v_proj"],
    quantization_config=4,  # 4位量化
    use_nf4=True,  # 使用NF4量化格式
)

# 医疗诊断数据示例(脱敏后)
medical_data = [
    {
        "symptoms": "患者，男，65岁，咳嗽、发热、胸闷三天，既往有高血压病史。",
        "diagnosis": "考虑社区获得性肺炎，建议完善胸部CT检查，经验性使用抗生素治疗。"
    },
    {
        "symptoms": "患者，女，42岁，反复头痛半年，加重一周，伴有恶心、视力模糊。",
        "diagnosis": "建议完善头颅MRI检查，排除颅内占位性病变，考虑偏头痛可能。"
    }
]

# 训练代码与前面类似
# ...

# 合同审查模型微调配置
from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM

# 配置适合合同审查的LoRA参数
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    target_modules=["q_proj", "v_proj", "k_proj"],
    bias="none",
)

# 合同审查数据示例
contract_data = [
    {
        "contract_section": "本合同有效期为自签署之日起三年，到期后自动续期。",
        "risk": "自动续期条款可能导致当事人权益受损，建议明确续期条件和通知义务。",
        "suggestion": "修改为：本合同有效期为自签署之日起三年，到期前30日任何一方可书面通知另一方是否续期。"
    },
    {
        "contract_section": "乙方应在收到甲方通知后立即履行义务。",
        "risk": "时间约定不明确，可能导致争议。",
        "suggestion": "修改为：乙方应在收到甲方通知后3个工作日内履行义务。"
    }
]

# 训练代码与前面章节类似
# ...

# 教育内容生成模型微调配置
from peft import LoraConfig, get_peft_model
from transformers import AutoModelForCausalLM

# 配置适合教育内容生成的LoRA参数
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=8,
    lora_alpha=16,
    lora_dropout=0.1,
    target_modules=["q_proj", "v_proj"],
    bias="none",
)

# 教育内容生成数据示例
education_data = [
    {
        "topic": "高中数学：二次函数",
        "instruction": "生成一个详细的教学解释，包含概念、公式、例题和练习。",
        "content": "二次函数是形如f(x) = ax² + bx + c (a≠0)的函数..."
    },
    {
        "topic": "英语写作：议论文结构",
        "instruction": "解释议论文的基本结构和写作技巧。",
        "content": "议论文通常包含引言、论点、论据和结论四个部分..."
    }
]

# 训练代码与前面类似
# ...

# 模型评估示例代码
from evaluate import load
import numpy as np
from transformers import AutoModelForCausalLM, AutoTokenizer

# 加载模型和分词器
model = AutoModelForCausalLM.from_pretrained("./fine-tuned-model")
tokenizer = AutoTokenizer.from_pretrained("./fine-tuned-model")

# 加载评估指标
bleu = load("bleu")
rouge = load("rouge")
bertscore = load("bertscore")

# 评估数据集
eval_data = [
    {"prompt": "什么是机器学习?", "reference": "机器学习是人工智能的一个分支，研究如何使计算机从数据中学习并改进性能。"},
    # 更多评估样本...
]

# 生成回答
predictions = []
references = []

for item in eval_data:
    # 生成回答
    inputs = tokenizer(item["prompt"], return_tensors="pt")
    with torch.no_grad():
        outputs = model.generate(
            inputs["input_ids"],
            max_new_tokens=100,
            num_return_sequences=1,
            temperature=0.7,
            top_p=0.95
        )
    prediction = tokenizer.decode(outputs[0], skip_special_tokens=True)
    predictions.append(prediction)
    references.append([item["reference"]])

# 计算BLEU分数
bleu_results = bleu.compute(predictions=predictions, references=references)
print(f"BLEU Score: {bleu_results['bleu']:.4f}")

# 计算ROUGE分数
rouge_results = rouge.compute(predictions=predictions, references=references)
print(f"ROUGE-1: {rouge_results['rouge1']:.4f}")
print(f"ROUGE-L: {rouge_results['rougeL']:.4f}")

# 计算BERTScore
bertscore_results = bertscore.compute(
    predictions=predictions,
    references=references,
    lang="zh",
    model_type="bert-base-chinese"
)
print(f"BERTScore: {np.mean(bertscore_results['f1']):.4f}")

微调技术未来展望
├── 2025-2026: 自适应微调主导，多模态统一
├── 2027-2028: MFTaaS普及，低代码工具成熟
├── 2029-2030: 量子辅助微调，边缘智能融合
└── 2030+: 自主进化微调，人机协同优化