第2056篇：LoRA微调实战——用低成本让模型学会你的业务知识

适读人群：需要让LLM适配特定业务领域的工程师 | 阅读时长：约20分钟 | 核心价值：掌握LoRA微调的完整流程，理解什么时候微调值得做，怎么做才有效

有个客户问我：他们做法律文书AI助手，用了RAG之后回答还是有很多语法不符合法律文书规范的问题，问我怎么解决。

"模型不了解法律文书的格式要求，光靠RAG不够，你需要微调。"

但我接着问了他几个问题：数据量多少？GPU成本预算？可接受的最低效果是什么？

结果发现，他们只有500条样本，没有GPU预算，而且用Few-Shot也能达到70%的要求。我建议他先别做微调，先用Few-Shot。

这件事让我意识到：微调不是万能药，也不是必选项。这篇文章先讲清楚什么时候应该微调，然后再讲怎么微调。

---

什么时候做微调

适合微调的场景：

1. 特定格式输出：每次输出都要符合某种固定格式（合同模板、报告模板）
2. 特定领域知识：需要掌握大量领域知识，RAG成本高
3. 特定语气风格：品牌化的语言风格，全公司统一
4. 降低推理成本：大模型微调成小模型，同等效果下成本更低

---

LoRA的原理

LoRA（Low-Rank Adaptation）的核心思想：不修改原始模型权重，而是训练一对小矩阵来模拟权重更新。

原始权重矩阵 W：d × d（很大）
LoRA添加：W + ΔW = W + A × B
  A：d × r 矩阵（r远小于d，通常4-64）
  B：r × d 矩阵

参数量：2 × d × r   远小于原始的   d × d

比如LLAMA-7B的某个权重矩阵是4096×4096，全量微调需要训练16M个参数；用LoRA(r=8)只需要训练4096×8×2=65K个参数，减少了约250倍。

---

数据准备

数据质量比数据量更重要：

# prepare_finetune_data.py
# 为指令微调准备数据，格式为ChatML格式

import json
from pathlib import Path

def prepare_legal_document_data():
    """
    法律文书助手的微调数据准备
    格式要求：输入-输出对，覆盖模型需要学会的行为
    """
    
    # 训练数据结构
    training_examples = [
        {
            "messages": [
                {
                    "role": "system",
                    "content": "你是专业的法律文书助手，帮助用户起草和审查法律文件。"
                },
                {
                    "role": "user",
                    "content": "帮我起草一份房屋租赁合同，甲方是张三，乙方是李四，租金每月3000元，租期1年。"
                },
                {
                    "role": "assistant",
                    "content": """房屋租赁合同

甲方（出租方）：张三
乙方（承租方）：李四

经甲乙双方协商，就下列事项达成如下协议：

一、租赁房屋
甲方同意将其所有的位于___________的房屋出租给乙方使用。

二、租赁期限
本合同租赁期限为壹（1）年，自____年__月__日起至____年__月__日止。

三、租金及支付方式
月租金为人民币叁仟元整（¥3,000.00），乙方应于每月__日前支付当月租金。

四、违约责任
[详细条款...]

甲方（签章）：___________   日期：___________
乙方（签章）：___________   日期：___________"""
            }
        }
    ]
    
    return training_examples

# 数据质量检查
def validate_data(examples):
    """检查数据质量"""
    issues = []
    
    for i, example in enumerate(examples):
        messages = example.get("messages", [])
        
        # 检查消息格式
        if not messages:
            issues.append(f"样本{i}: 缺少messages字段")
            continue
        
        # 检查角色
        roles = [m["role"] for m in messages]
        if "user" not in roles:
            issues.append(f"样本{i}: 缺少user消息")
        if "assistant" not in roles:
            issues.append(f"样本{i}: 缺少assistant消息")
        
        # 检查assistant回答长度（太短可能是低质量数据）
        for msg in messages:
            if msg["role"] == "assistant" and len(msg.get("content", "")) < 50:
                issues.append(f"样本{i}: assistant回答过短")
    
    return issues

# 保存训练数据
training_data = prepare_legal_document_data()
issues = validate_data(training_data)

if issues:
    print("数据质量问题:")
    for issue in issues:
        print(f"  - {issue}")
else:
    with open("train.jsonl", "w", encoding="utf-8") as f:
        for example in training_data:
            f.write(json.dumps(example, ensure_ascii=False) + "\n")
    print(f"训练数据已保存: {len(training_data)}条")

---

LoRA微调代码

# lora_finetune.py
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig, get_peft_model, TaskType
from trl import SFTTrainer
from datasets import Dataset
import torch
import json

def load_model_and_tokenizer(model_path: str):
    """加载基础模型"""
    
    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token
    
    model = AutoModelForCausalLM.from_pretrained(
        model_path,
        torch_dtype=torch.bfloat16,  # bf16节省显存
        device_map="auto",            # 自动分配到多卡
        trust_remote_code=True
    )
    
    return model, tokenizer

def configure_lora(model):
    """配置LoRA"""
    
    lora_config = LoraConfig(
        task_type=TaskType.CAUSAL_LM,
        r=8,                    # LoRA秩，通常4-64。越大效果越好但参数越多
        lora_alpha=16,          # LoRA缩放因子，通常设为r的2倍
        lora_dropout=0.1,       # Dropout，防止过拟合
        
        # 目标模块：对哪些层应用LoRA
        # Qwen2/Llama通常是这几个
        target_modules=["q_proj", "v_proj", "k_proj", "o_proj", 
                        "gate_proj", "up_proj", "down_proj"],
        
        bias="none",
    )
    
    model = get_peft_model(model, lora_config)
    model.print_trainable_parameters()
    # 输出类似：trainable params: 4,194,304 || all params: 7,241,732,096 || trainable%: 0.0579
    
    return model

def train(model_path: str, data_path: str, output_dir: str):
    
    print("加载模型...")
    model, tokenizer = load_model_and_tokenizer(model_path)
    model = configure_lora(model)
    
    print("加载训练数据...")
    with open(data_path, "r", encoding="utf-8") as f:
        data = [json.loads(line) for line in f]
    
    dataset = Dataset.from_list(data)
    
    training_args = TrainingArguments(
        output_dir=output_dir,
        
        # 训练参数
        num_train_epochs=3,
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,    # 累积梯度，等效batch_size=8
        
        # 优化器
        learning_rate=2e-4,
        lr_scheduler_type="cosine",
        warmup_ratio=0.03,
        
        # 保存
        save_strategy="epoch",
        save_total_limit=3,
        
        # 日志
        logging_steps=10,
        
        # 混合精度
        bf16=True,                        # A100/H100支持bf16
        
        # 梯度检查点（节省显存）
        gradient_checkpointing=True,
    )
    
    trainer = SFTTrainer(
        model=model,
        tokenizer=tokenizer,
        args=training_args,
        train_dataset=dataset,
        dataset_text_field="messages",
        max_seq_length=2048,
    )
    
    print("开始训练...")
    trainer.train()
    
    # 保存LoRA权重（只保存增量部分，很小）
    model.save_pretrained(f"{output_dir}/lora_weights")
    tokenizer.save_pretrained(f"{output_dir}/tokenizer")
    print(f"训练完成，模型保存到: {output_dir}")

if __name__ == "__main__":
    train(
        model_path="Qwen/Qwen2-7B-Instruct",
        data_path="train.jsonl",
        output_dir="./lora_output"
    )

---

与Java应用集成

/**
 * 在Java应用中加载和使用LoRA微调后的模型
 * 通过Ollama部署（推荐）或直接调用Python API
 */
@Configuration
public class FinetunedModelConfig {
    
    /**
     * 方案一：用Ollama部署LoRA合并后的模型
     * 
     * 步骤：
     * 1. 合并LoRA权重：python merge_lora.py
     * 2. 转换为GGUF格式：python convert_hf_to_gguf.py
     * 3. 创建Ollama Modelfile并导入
     */
    @Bean
    @Profile("finetuned-local")
    public ChatLanguageModel fineTunedModel() {
        return OllamaChatModel.builder()
            .baseUrl("http://localhost:11434")
            .modelName("legal-assistant-v1")  // 你的LoRA模型名称
            .temperature(0.3)
            .build();
    }
    
    /**
     * 方案二：使用OpenAI的微调API（适合数据量小、不想自建GPU的场景）
     */
    @Bean
    @Profile("openai-finetuned")
    public ChatLanguageModel openAiFineTunedModel() {
        return OpenAiChatModel.builder()
            .apiKey(System.getenv("OPENAI_API_KEY"))
            .modelName("ft:gpt-4o-mini-2024-07-18:mycompany:legal-v1:xxxxx")
            .temperature(0.3)
            .build();
    }
}

---

微调效果评估

/**
 * 微调效果对比评估
 */
@Service
@RequiredArgsConstructor
public class FineTuningEvalService {
    
    private final ChatLanguageModel baseModel;
    private final ChatLanguageModel fineTunedModel;
    private final ChatLanguageModel judgeModel;
    
    /**
     * 对比基础模型和微调模型的输出质量
     */
    public EvalComparisonReport compare(List<String> testInputs, String taskDescription) {
        List<Double> baseScores = new ArrayList<>();
        List<Double> ftScores = new ArrayList<>();
        
        for (String input : testInputs) {
            String baseOutput = baseModel.generate(input);
            String ftOutput = fineTunedModel.generate(input);
            
            // 用Judge模型评分
            double baseScore = scoreOutput(input, baseOutput, taskDescription);
            double ftScore = scoreOutput(input, ftOutput, taskDescription);
            
            baseScores.add(baseScore);
            ftScores.add(ftScore);
        }
        
        double baseAvg = baseScores.stream().mapToDouble(Double::doubleValue).average().orElse(0);
        double ftAvg = ftScores.stream().mapToDouble(Double::doubleValue).average().orElse(0);
        double improvement = (ftAvg - baseAvg) / baseAvg * 100;
        
        return new EvalComparisonReport(baseAvg, ftAvg, improvement,
            improvement > 5 ? "微调效果显著，建议部署" : 
            improvement > 0 ? "微调有轻微改善，可以考虑部署" : 
            "微调效果不明显，建议调整数据或方法");
    }
    
    private double scoreOutput(String input, String output, String criteria) {
        String judgePrompt = String.format("""
            评估以下AI输出的质量（1-10分）：
            
            任务要求：%s
            用户输入：%s
            AI输出：%s
            
            只输出分数（1-10的整数）：
            """, criteria, input, output);
        
        String scoreStr = judgeModel.generate(judgePrompt).trim();
        try {
            return Double.parseDouble(scoreStr);
        } catch (NumberFormatException e) {
            return 5.0;  // 解析失败默认5分
        }
    }
    
    public record EvalComparisonReport(
        double baseModelScore,
        double fineTunedScore,
        double improvementPercent,
        String recommendation
    ) {}
}

LoRA微调把成本降低到一个普通团队可以接受的范围。但记住：微调是最后手段，不是第一手段。先把Prompt、RAG、Few-Shot都用好，再考虑微调。