LLM微调完全指南【2026】- 从原理到实践

┌─────────────────────────────────────────────┐
│           参数高效微调方法对比               │
├─────────────────────────────────────────────┤
│  方法        │ 可训练参数 │ 显存需求 │ 效果  │
├─────────────────────────────────────────────┤
│  全量微调    │   100%    │   很高   │  最佳  │
│  LoRA       │   0.1-1%  │    低    │  优秀  │
│  QLoRA      │   0.1-1%  │   更低   │  优秀  │
│  Prefix-tuning│  0.1%   │    低    │  良好  │
│  Adapter    │   1-5%    │    低    │  优秀  │
└─────────────────────────────────────────────┘

{
  "instruction": "将以下英文翻译成中文",
  "input": "Hello, how are you?",
  "output": "你好，你好吗？"
}

{
  "conversations": [
    {"role": "user", "content": "什么是机器学习？"},
    {"role": "assistant", "content": "机器学习是人工智能的一个分支..."}
  ]
}

import json
import re

def clean_training_data(data_path):
    """清洗微调训练数据"""
    cleaned_data = []
    
    with open(data_path, 'r', encoding='utf-8') as f:
        raw_data = json.load(f)
    
    for item in raw_data:
        instruction = item.get('instruction', '').strip()
        input_text = item.get('input', '').strip()
        output = item.get('output', '').strip()
        
        if not instruction or not output:
            continue
        
        if len(output) < 10 or len(output) > 2048:
            continue
        
        output = re.sub(r'\s+', ' ', output)
        
        cleaned_data.append({
            'instruction': instruction,
            'input': input_text,
            'output': output
        })
    
    return cleaned_data

pip install transformers datasets peft accelerate bitsandbytes
pip install trl  # 用于SFT训练

import torch
from datasets import load_dataset
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    TrainingArguments,
    BitsAndBytesConfig
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer

model_name = "meta-llama/Llama-2-7b-hf"

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(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
)

tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

model = prepare_model_for_kbit_training(model)

lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

dataset = load_dataset("json", data_files="train_data.json")

def format_instruction(sample):
    return f"""### 指令：
{sample['instruction']}

### 输入：
{sample['input']}

### 回答：
{sample['output']}"""

training_args = TrainingArguments(
    output_dir="./lora-llama",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    fp16=True,
    logging_steps=10,
    save_strategy="epoch",
    warmup_ratio=0.03,
)

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    formatting_func=format_instruction,
    max_seq_length=512,
    args=training_args,
)

trainer.train()

model.save_pretrained("./lora-llama-adapter")

from peft import PeftModel

base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    device_map="auto",
    torch_dtype=torch.float16,
)

model = PeftModel.from_pretrained(base_model, "./lora-llama-adapter")

model = model.merge_and_unload()

def generate_response(prompt, max_length=256):
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    
    outputs = model.generate(
        **inputs,
        max_new_tokens=max_length,
        temperature=0.7,
        top_p=0.9,
        do_sample=True,
    )
    
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    return response

result = generate_response("### 指令：\n解释什么是深度学习\n\n### 回答：\n")
print(result)

recommended_params = {
    "learning_rate": "1e-5 到 5e-4，QLoRA建议2e-4",
    "batch_size": "根据显存调整，建议4-16",
    "epochs": "通常2-5轮，监控验证集loss",
    "lora_r": "8-64，任务复杂度越高r越大",
    "lora_alpha": "通常设为2*r",
    "warmup_ratio": "0.03-0.1",
}

from evaluate import load

def evaluate_model(model, test_dataset):
    """评估微调模型"""
    
    bleu = load("bleu")
    rouge = load("rouge")
    
    predictions = []
    references = []
    
    for sample in test_dataset:
        pred = generate_response(sample["instruction"])
        predictions.append(pred)
        references.append(sample["output"])
    
    bleu_score = bleu.compute(predictions=predictions, references=references)
    rouge_score = rouge.compute(predictions=predictions, references=references)
    
    return {
        "bleu": bleu_score,
        "rouge": rouge_score
    }