大模型微调技术：从LoRA到QLoRA的实战指南

1. 模型微调：从通用到专属的AI进化之路

在AI技术迅猛发展的今天，大型预训练模型如GPT、Llama等展现出了惊人的通用能力。然而，当我们真正将这些模型应用于具体业务场景时，往往会发现一个尴尬的现实：这些"博学多才"的通用模型，在面对特定领域任务时，表现往往差强人意。这就像请一位通晓各科的大学教授来解决你公司的具体业务问题——他可能拥有丰富的知识储备，却缺乏对特定业务场景的深入理解。

模型微调（Fine-tuning）正是解决这一痛点的关键技术。不同于简单的提示工程（Prompt Engineering），微调是通过额外的训练数据，让模型深入学习特定领域的知识和任务模式。这个过程相当于给通用AI进行"专项培训"，使其从"通才"转变为"专才"。

1.1 为什么微调如此重要？

在实际应用中，我们发现微调能够解决几个关键问题：

领域适应性问题：通用模型训练时接触的数据分布与特定领域数据往往存在差异。例如，医疗领域的专业术语、法律文本的特殊表达方式，这些都需要通过微调来适应。

任务特异性需求：即使是同一领域，不同任务对模型的要求也不同。客服机器人需要温和有礼的表达，而代码生成工具则需要严谨精确的输出风格。

企业知识融合：每个企业都有自己独特的知识体系、业务流程和文档规范，这些内部知识需要通过微调注入模型。

性能瓶颈突破：当提示工程和上下文学习（In-context Learning）无法满足性能要求时，微调往往是提升模型表现的唯一途径。

我曾在多个项目中亲历微调带来的性能飞跃。例如，在一个法律合同审查项目中，经过微调的模型在特定条款识别准确率上从68%提升到了92%，同时审查速度提高了3倍。这种提升不是简单的参数调整能够实现的，而是模型真正"理解"了法律语言的特殊性。

2. 微调策略全景解析：从全参数到QLoRA

2.1 全参数微调：不惜代价的性能追求

全参数微调（Full Fine-tuning）是最传统也最直接的微调方式。这种方法会更新模型的所有参数，相当于让模型"重新学习"。

技术实现要点：

python复制from transformers import AutoModelForCausalLM, TrainingArguments, Trainer

# 加载预训练模型
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3-8B")

# 配置训练参数
training_args = TrainingArguments(
    output_dir="./results",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-5,
    fp16=True,  # 混合精度训练节省显存
    logging_steps=50,
    save_steps=500,
    evaluation_strategy="steps",
    eval_steps=200
)

# 创建Trainer实例
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset
)

# 开始训练
trainer.train()

适用场景：

• 数据量充足（通常需要万级以上高质量样本）
• 计算资源丰富（多块高端GPU）
• 对模型性能有极致要求
• 领域与预训练数据差异较大

实战经验：
在一次金融风控模型微调中，我们使用了全参数微调方法。虽然训练耗时长达72小时（使用4块A100 GPU），但最终模型在欺诈检测任务上的F1分数达到了0.93，比基础模型提高了0.15。关键是要确保训练数据充分覆盖各类边缘案例，否则容易过拟合。

2.2 LoRA：轻量高效的参数高效微调

LoRA（Low-Rank Adaptation）是近年来最受欢迎的微调方法之一。它通过添加低秩矩阵来更新模型权重，只训练少量参数（通常为原参数的0.1%-1%）。

技术原理：
LoRA基于一个重要观察：大模型在适应新任务时，权重变化具有低秩特性。这意味着可以用两个小矩阵的乘积（W=BA）来表示权重变化，其中B∈ℝ^{d×r}, A∈ℝ^{r×k}，r≪d,k。

实现代码：

python复制from peft import LoraConfig, get_peft_model

# LoRA配置
lora_config = LoraConfig(
    r=8,  # 低秩矩阵的秩
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],  # 仅作用于注意力层的查询和值投影
    lora_dropout=0.1,
    bias="none",
    task_type="CAUSAL_LM"
)

# 应用LoRA
model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3-8B")
model = get_peft_model(model, lora_config)

# 查看可训练参数占比
model.print_trainable_parameters()
# 输出示例: trainable params: 4,194,304 || all params: 6,742,450,176 || trainable%: 0.06220528176079912

优势对比：

实战技巧：

• 对于7B参数模型，r=8通常是个不错的起点，可根据效果调整
• target_modules选择是关键：对于语言模型，"q_proj"和"v_proj"通常效果最好
• lora_alpha一般设为r的2-4倍，与学习率共同影响适配强度
• 微调后可将多个LoRA适配器合并，实现多任务能力组合

2.3 QLoRA：消费级GPU上的大模型微调

QLoRA是LoRA的进一步优化，通过4-bit量化技术，让大模型在消费级GPU上也能微调。

量化技术细节：

• 4-bit NormalFloat量化：专门优化的4-bit数据类型，最小化精度损失
• 双重量化：额外量化量化常数，进一步减少内存占用
• 分页优化器：自动管理GPU内存，防止训练过程中的OOM错误

实现示例：

python复制from transformers import BitsAndBytesConfig
from peft import prepare_model_for_kbit_training

# 4-bit量化配置
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True
)

# 加载量化模型
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3-70B",
    quantization_config=bnb_config,
    device_map="auto"
)

# 准备模型用于k-bit训练
model = prepare_model_for_kbit_training(model)

# 应用LoRA
lora_config = LoraConfig(r=8, lora_alpha=32, target_modules=["q_proj", "v_proj"])
model = get_peft_model(model, lora_config)

性能对比：
我们在RTX 4090（24GB显存）上测试了不同方法微调Llama-2-70B的可行性：

注意事项：

• 虽然QLoRA使得大模型微调成为可能，但训练速度仍然较慢
• 4-bit量化会带来轻微性能下降，通常约2-5%的精度损失
• 建议使用bf16计算类型（如果GPU支持）以获得更好效果
• 训练时需要监控显存使用，适当调整批大小和梯度累积步数

3. 数据工程：微调成功的基石

3.1 高质量数据集的构建原则

在实际项目中，我发现数据质量比数量更重要。1000条精心准备的样本，效果往往优于10000条粗糙数据。优质训练数据应具备以下特征：

相关性：数据必须与目标任务高度相关。例如，要微调代码生成模型，就应该使用真实的企业代码库而非公开的示例代码。

多样性：覆盖任务的各种场景和表达方式。对于客服机器人，应包含不同语气、不同复杂度的用户提问。

正确性：标注必须准确无误。错误标签会严重误导模型学习。

一致性：标注标准要统一。比如"积极/消极"情感的定义在整个数据集中应保持一致。

数据收集渠道：

1. 业务数据挖掘：用户对话记录、工单系统、代码仓库等
2. 专家标注：邀请领域专家创建或审核样本
3. 合成数据生成：使用大模型生成后人工校验
4. 公开数据集：HuggingFace、Kaggle等平台的适配数据集

3.2 数据清洗实战：从原始数据到训练样本

数据清洗是确保微调效果的关键步骤。以下是一个完整的数据清洗流程实现：

python复制import re
from typing import List, Dict

class DataCleaner:
    def __init__(self):
        # 定义需要清理的模式
        self.patterns = {
            'email': r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
            'phone': r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b',
            'url': r'https?://\S+',
            'personal_info': r'\b(姓名|电话|地址|身份证)\b.*?:.*'
        }
        
        # 领域特定清理规则
        self.domain_specific_rules = {
            'medical': [(r'\b患者\b.*?\bID\b:\s*\d+', '[MEDICAL_ID]')],
            'legal': [(r'\b甲方\b.*?\b身份证号\b.*?\d{18}', '[LEGAL_PARTY]')]
        }
    
    def clean_text(self, text: str, domain: str = None) -> str:
        """执行全面的文本清理"""
        # 移除敏感信息
        for _, pattern in self.patterns.items():
            text = re.sub(pattern, f'[REDACTED]', text)
        
        # 应用领域特定规则
        if domain and domain in self.domain_specific_rules:
            for pattern, replacement in self.domain_specific_rules[domain]:
                text = re.sub(pattern, replacement, text)
        
        # 标准化空白字符
        text = ' '.join(text.split())
        
        # 移除特殊字符但保留基本标点
        text = re.sub(r'[^\w\s.,!?;:()\"\'-]', '', text)
        
        return text
    
    def validate_sample(self, sample: Dict, task_type: str) -> bool:
        """验证样本质量"""
        # 检查必要字段
        required_fields = {
            'instruction': ['instruction', 'input', 'output'],
            'classification': ['text', 'label'],
            'summarization': ['document', 'summary']
        }.get(task_type, [])
        
        if not all(field in sample for field in required_fields):
            return False
        
        # 检查内容质量
        if 'output' in sample and len(sample['output'].strip()) < 10:
            return False
        
        if 'label' in sample and sample['label'] not in VALID_LABELS:
            return False
            
        return True
    
    def process_dataset(self, raw_data: List[Dict], task_type: str, domain: str = None) -> List[Dict]:
        """完整的数据处理流程"""
        cleaned_data = []
        
        for sample in raw_data:
            try:
                # 深度清理所有文本字段
                cleaned_sample = {
                    key: self.clean_text(str(value), domain) 
                    for key, value in sample.items()
                }
                
                # 验证样本质量
                if self.validate_sample(cleaned_sample, task_type):
                    cleaned_data.append(cleaned_sample)
            except Exception as e:
                print(f"Error processing sample: {e}")
                continue
                
        return cleaned_data

关键清洗步骤：

1. 敏感信息处理：移除或替换邮箱、电话、身份证号等
2. 领域特定清理：根据业务需求定制清理规则
3. 文本标准化：统一空格、标点等格式
4. 样本验证：确保每个样本符合质量要求

经验分享：

• 清洗规则应根据业务需求灵活调整，没有放之四海而皆准的方案
• 建议保留原始数据和清洗后数据的映射关系，便于后续调试
• 对于特别重要的项目，可以设计自动化+人工审核的双重清洗流程

3.3 数据增强：小数据撬动大性能

当训练数据有限时，数据增强技术可以显著提升模型性能。以下是几种经过验证的有效方法：

回译增强：将文本翻译到中间语言再翻译回来

python复制from googletrans import Translator

translator = Translator()

def back_translate(text: str, intermediate_lang: str = 'fr') -> str:
    try:
        translated = translator.translate(text, dest=intermediate_lang).text
        back_translated = translator.translate(translated, dest='zh-cn').text
        return back_translated
    except:
        return text  # 翻译失败时返回原文

同义词替换：使用WordNet或领域词库替换非关键词语

python复制import nlpaug.augmenter.word as naw

aug = naw.SynonymAug(aug_src='wordnet', aug_max=3)

def augment_with_synonyms(text: str) -> str:
    return aug.augment(text)

句式变换：主动句变被动句等语法转换

python复制import nlpaug.augmenter.sentence as nas

aug = nas.RandomSentAug(action="swap")

def rephrase_sentence(text: str) -> str:
    return aug.augment(text)

上下文扩展：添加相关背景信息增强样本

python复制def add_context(example: Dict) -> Dict:
    if "context" not in example:
        example["context"] = generate_related_context(example["input"])
    return example

增强策略选择指南：

实战建议：

• 增强比例控制在20-50%为宜，过度增强可能引入噪声
• 不同增强方法可以组合使用，但要注意保持语义一致性
• 对于关键任务，建议人工抽查增强后的样本质量
• 可以设计自动化流水线：原始数据→增强→过滤→训练

4. 微调实战全流程：从训练到部署

4.1 训练环境配置与优化

单机多卡训练配置：

bash复制# 使用accelerate库配置分布式训练
accelerate config
# 根据提示选择配置选项，例如：
# - 启用多GPU训练
# - 使用fp16混合精度
# - 设置梯度累积步数

# 启动训练
accelerate launch train.py \
    --model_name meta-llama/Llama-3-8B \
    --dataset ./data/train.jsonl \
    --output_dir ./output \
    --per_device_train_batch_size 8 \
    --gradient_accumulation_steps 2 \
    --learning_rate 2e-5 \
    --num_train_epochs 3 \
    --logging_steps 100 \
    --save_steps 1000

关键参数调优经验：

学习率选择：

• 全参数微调：1e-5到5e-5
• LoRA/QLoRA：1e-4到5e-4（因为训练参数更少）
• 可以先用学习率探测（LR Finder）确定合理范围

批大小设置：

• 在显存允许范围内尽可能大
• 太小会导致训练不稳定
• 可以通过梯度累积模拟大批量

训练时长控制：

• 早停（Early Stopping）是防止过拟合的有效手段
• 监控验证集损失，连续3次不改善即可停止
• 对于大数据集，1-3个epoch通常足够

实战技巧：

• 使用WandB或TensorBoard监控训练过程
• 保存中间检查点以便回溯
• 训练前执行一次完整评估作为基准

4.2 超参数自动搜索

当不确定最佳超参数组合时，可以借助自动化工具进行搜索：

python复制from ray import tune
from transformers import Trainer

def hyperparameter_space(trial):
    return {
        "learning_rate": tune.loguniform(1e-5, 1e-3),
        "num_train_epochs": tune.choice([2, 3, 5]),
        "per_device_train_batch_size": tune.choice([4, 8, 16]),
        "weight_decay": tune.uniform(0.0, 0.1),
        "warmup_ratio": tune.uniform(0.05, 0.2)
    }

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset
)

best_trial = trainer.hyperparameter_search(
    hp_space=hyperparameter_space,
    direction="minimize",  # 最小化eval_loss
    backend="ray",
    n_trials=20,  # 试验次数
    resources_per_trial={"cpu": 2, "gpu": 1}
)

搜索策略选择：

经验建议：

• 先在小规模数据上快速试验，确定大致范围
• 重点调优学习率、批大小和训练轮数
• 记录每次试验的配置和结果，建立知识库
• 对于生产系统，可以设置定期自动调优任务

4.3 模型评估方法论

自动化评估指标：

python复制from sklearn.metrics import accuracy_score, f1_score
import numpy as np

def compute_metrics(eval_pred):
    predictions, labels = eval_pred
    predictions = np.argmax(predictions, axis=1)
    
    return {
        'accuracy': accuracy_score(labels, predictions),
        'f1_macro': f1_score(labels, predictions, average='macro'),
        'f1_micro': f1_score(labels, predictions, average='micro')
    }

人工评估设计：

python复制class HumanEvaluator:
    def __init__(self, criteria):
        self.criteria = criteria  # 如：准确性、流畅性、相关性等
    
    def evaluate(self, model, eval_dataset, num_samples=50):
        results = []
        indices = np.random.choice(len(eval_dataset), num_samples, replace=False)
        
        for idx in indices:
            sample = eval_dataset[idx]
            model_output = model.generate(sample['input'])
            
            evaluation = {
                'input': sample['input'],
                'reference': sample.get('output', ''),
                'model_output': model_output,
                'ratings': {c: None for c in self.criteria},
                'comments': ''
            }
            
            results.append(evaluation)
        
        return results

评估维度设计：

实战建议：

• 建立标准化的评估流程和评分标准
• 自动化评估与人工评估相结合
• 对于关键业务，建议进行盲测（评估者不知道输出来自哪个模型）
• 定期重新评估模型性能，防止性能衰减

5. 生产环境部署与优化

5.1 模型量化压缩技术

GPTQ量化实现：

bash复制# 安装AutoGPTQ
pip install auto-gptq

# 执行量化
python -m auto_gptq.quantization.quantize \
    --model_path ./fine-tuned-model \
    --output_path ./quantized-model \
    --bits 4 \
    --group_size 128 \
    --damp_percent 0.1 \
    --desc_act \
    --sym

量化方法对比：

部署示例：

python复制from auto_gptq import AutoGPTQForCausalLM

# 加载量化模型
model = AutoGPTQForCausalLM.from_quantized(
    "./quantized-model",
    device="cuda:0",
    use_triton=True  # 启用Triton推理引擎
)

# 推理
outputs = model.generate(input_ids, max_length=512)

5.2 高性能推理引擎

vLLM部署方案：

python复制from vllm import LLM, SamplingParams

# 初始化
llm = LLM(
    model="./fine-tuned-model",
    tensor_parallel_size=2,  # 张量并行
    gpu_memory_utilization=0.9,
    quantization="awq",  # 激活感知量化
    max_model_len=4096
)

# 批处理推理
sampling_params = SamplingParams(temperature=0.7, top_p=0.9, max_tokens=512)
prompts = ["解释量子计算原理", "写一首关于AI的诗"]
outputs = llm.generate(prompts, sampling_params)

for output in outputs:
    print(f"Prompt: {output.prompt}")
    print(f"Generated: {output.outputs[0].text}")

性能优化技巧：

1. 连续批处理：动态合并不同长度的请求，提高GPU利用率
2. PagedAttention：高效管理注意力键值缓存，支持超长上下文
3. 张量并行：大模型分布到多GPU，降低单卡负载
4. 量化推理：结合AWQ或GPTQ量化，减少显存占用

5.3 缓存与负载均衡

智能缓存实现：

python复制from datetime import datetime, timedelta
import hashlib

class InferenceCache:
    def __init__(self, max_size=1000, ttl=3600):
        self.cache = {}
        self.max_size = max_size
        self.ttl = timedelta(seconds=ttl)  # 缓存存活时间
    
    def _get_cache_key(self, prompt, params):
        """生成唯一缓存键"""
        param_str = str(sorted(params.items()))
        return hashlib.md5((prompt + param_str).encode()).hexdigest()
    
    def get(self, prompt, params):
        key = self._get_cache_key(prompt, params)
        entry = self.cache.get(key)
        
        if entry and datetime.now() < entry['expiry']:
            return entry['response']
        return None
    
    def set(self, prompt, params, response):
        if len(self.cache) >= self.max_size:
            # 淘汰最旧的10%条目
            oldest_keys = sorted(
                self.cache.keys(),
                key=lambda k: self.cache[k]['expiry']
            )[:self.max_size//10]
            for key in oldest_keys:
                del self.cache[key]
        
        key = self._get_cache_key(prompt, params)
        self.cache[key] = {
            'response': response,
            'expiry': datetime.now() + self.ttl
        }

负载均衡策略：

1. 基于请求类型的路由：将不同任务类型路由到专用模型实例
2. 动态批处理：根据请求量自动调整批处理大小
3. 自动扩缩容：基于负载指标自动增减实例数量
4. 优先级队列：确保高优先级请求优先处理

5.4 监控与运维体系

Prometheus监控指标：

python复制from prometheus_client import Counter, Gauge, Histogram

# 定义指标
REQUEST_COUNT = Counter('inference_requests_total', 'Total inference requests')
REQUEST_LATENCY = Histogram('inference_latency_seconds', 'Inference latency')
GPU_UTILIZATION = Gauge('gpu_utilization_percent', 'GPU utilization')
CACHE_HIT_RATE = Gauge('cache_hit_rate', 'Cache hit rate')

class MonitoringMiddleware:
    def __init__(self, model):
        self.model = model
    
    async def generate(self, prompt, **params):
        start_time = time.time()
        REQUEST_COUNT.inc()
        
        # 检查缓存
        cache_key = self._get_cache_key(prompt, params)
        if cached_response := cache.get(cache_key):
            CACHE_HIT_RATE.inc()
            return cached_response
        
        # 执行推理
        try:
            output = await self.model.generate_async(prompt, **params)
            latency = time.time() - start_time
            REQUEST_LATENCY.observe(latency)
            
            # 更新GPU监控
            GPU_UTILIZATION.set(get_gpu_utilization())
            
            # 缓存结果
            cache.set(cache_key, output)
            return output
        except Exception as e:
            ERROR_COUNT.inc()
            raise e

告警规则配置示例：

yaml复制groups:
- name: inference-alerts
  rules:
  - alert: HighInferenceLatency
    expr: histogram_quantile(0.9, sum(rate(inference_latency_seconds_bucket[5m])) by (le)) > 2
    for: 10m
    labels:
      severity: warning
    annotations:
      summary: "High inference latency detected"
      description: "90th percentile latency is {{ $value }}s"
  
  - alert: GPUOverutilization
    expr: avg_over_time(gpu_utilization_percent[5m]) > 90
    for: 15m
    labels:
      severity: critical
    annotations:
      summary: "GPU is overutilized"
      description: "GPU utilization at {{ $value }}%"

6. 企业级代码生成模型微调实战

6.1 项目背景与挑战

某金融科技公司需要定制代码生成模型，满足以下需求：

• 遵守严格的安全编码规范
• 符合内部代码风格指南
• 自动生成合规的审计日志
• 避免使用禁用的API和模式

挑战：

1. 通用模型生成的代码不符合公司规范
2. 代码审查耗时占开发时间的30%以上
3. 安全漏洞常由编码不规范引起
4. 不同团队编码风格不一致

6.2 数据准备与增强

数据收集流程：

python复制import ast
from pathlib import Path

def extract_code_samples(repo_path, output_file):
    with open(output_file, 'w') as f_out:
        for py_file in Path(repo_path).rglob('*.py'):
            try:
                with open(py_file, 'r') as f_in:
                    code = f_in.read()
                
                # 解析AST获取函数信息
                tree = ast.parse(code)
                for node in ast.walk(tree):
                    if isinstance(node, ast.FunctionDef):
                        # 提取函数上下文
                        context = get_context(node, tree)
                        
                        # 生成instruction
                        docstring = ast.get_docstring(node) or "实现功能"
                        instruction = f"根据公司规范实现：{docstring}"
                        
                        # 保存样本
                        sample = {
                            'instruction': instruction,
                            'input': context,
                            'output': ast.get_source_segment(code, node)
                        }
                        f_out.write(json.dumps(sample) + '\n')
            except Exception as e:
                print(f"Error processing {py_file}: {e}")

数据增强策略：

1. 规范违规注入：故意在代码中插入常见违规模式，让模型学习识别和纠正
2. 风格转换：将代码从其他风格转换为公司标准风格
3. 注释生成：创建"无注释代码→带规范注释代码"的配对样本
4. 错误修复：收集真实代码审查意见和对应的修复作为训练样本

6.3 模型训练与优化

分层微调策略：

1. 基础能力层：使用公开代码数据预训练
2. 规范适应层：使用公司代码库微调
3. 任务特定层：针对不同任务（如日志生成、安全检查）进一步微调

QLoRA配置：

python复制lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
    lora_dropout=0.1,
    bias="none",
    task_type="CAUSAL_LM",
    layers_to_transform=list(range(16, 32))  # 只微调上层
)

训练过程监控：

python复制from transformers import TrainerCallback

class CodeQualityMetrics(Callback):
    def on_evaluate(self, args, state, control, **kwargs):
        # 在评估时计算代码质量指标
        metrics = compute_code_metrics(eval_dataset, model)
        state.log_history[-1].update(metrics)
        
        # 关键指标可视化
        if args.local_rank == 0:
            plot_metrics(metrics)

6.4 效果评估与部署

评估指标设计：

python复制def evaluate_code_quality(generated_code):
    # 规范符合率检查
    style_errors = check_style(generated_code)
    security_issues = check_security(generated_code)
    doc_quality = check_docstring(generated_code)
    
    # 功能正确性测试
    functional_correctness = run_unit_tests(generated_code)
    
    return {
        'style_score': 1 - len(style_errors)/TOTAL_STYLE_RULES,
        'security_score': 1 - len(security_issues)/TOTAL_SECURITY_RULES,
        'doc_score': doc_quality,
        'functional_score': functional_correctness
    }

CI/CD集成方案：

yaml复制# .gitlab-ci.yml
stages:
  - code-review

ai-code-review:
  stage: code-review
  image: python:3.9
  script:
    - pip install -r requirements.txt
    - python code_review.py --model ./fine-tuned-model --diff ${CI_MERGE_REQUEST_CHANGES}
    - python generate_review_report.py > report.md
  artifacts:
    paths:
      - report.md
  only:
    - merge_requests

效果对比：

7. 微调技术进阶与前沿探索

7.1 持续学习与灾难性遗忘

弹性权重固化（EWC）实现：

python复制from transformers import TrainerCallback
import torch

class EWCCallback(TrainerCallback):
    def __init__(self, model, fisher_matrix, importance=1e5):
        self.model = model
        self.fisher = fisher_matrix
        self.importance = importance
        self.original_params = {n: p.clone() for n, p in model.named_parameters()}
    
    def on_step_end(self, args, state, control, **kwargs):
        # 计算EWC正则项
        ewc_loss = 0
        for n, p in self.model.named_parameters():
            if n in self.fisher:
                ewc_loss += (self.importance * (self.fisher[n] * 
                                (p - self.original_params[n])**2).sum())
        
        # 添加到总损失
        if len(kwargs['logs']) > 0:
            kwargs['logs']['ewc_loss'] = ewc_loss.item()
            kwargs['loss'] += ewc_loss

持续学习策略对比：

7.2 模型融合与任务算术

任务向量算术实现：

python复制def task_arithmetic(model_a, model_b, alpha=0.5):
    """合并两个适配器的参数"""
    state_dict_a = model_a.state_dict()
    state_dict_b = model_b.state_dict()
    
    merged_state_dict = {}
    for key in state_dict_a:
        if key.endswith('lora_A') or key.endswith('lora_B'):
            # 任务向量算术合并
            merged_state_dict[key] = alpha * state_dict_a[key] + (1-alpha) * state_dict_b[key]
        else:
            merged_state_dict