模型微调

微调方法
├── 全量微调（Full Fine-Tuning）
│   └── 更新所有参数
├── 参数高效微调（PEFT）
│   ├── LoRA / QLoRA
│   ├── Adapter
│   ├── Prefix Tuning
│   └── Prompt Tuning
└── 对齐训练
    ├── SFT（监督微调）
    ├── RLHF（人类反馈强化学习）
    └── DPO（直接偏好优化）

# 全量微调的基本流程（以 Hugging Face Transformers 为例）
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer

model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3-8B")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3-8B")

training_args = TrainingArguments(
    output_dir="./output",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    learning_rate=2e-5,
    bf16=True,
    gradient_accumulation_steps=4,
)

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

trainer.train()

W' = W + ΔW = W + A × B

其中：
- W: 原始预训练权重（冻结不更新），形状 [d, k]
- A: 低秩矩阵，形状 [d, r]，随机初始化
- B: 低秩矩阵，形状 [r, k]，初始化为 0
- r: 秩（rank），远小于 d 和 k，通常取 8-64

from peft import LoraConfig, get_peft_model, TaskType

# 配置 LoRA
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,                              # 秩
    lora_alpha=32,                     # 缩放因子
    lora_dropout=0.05,                 # Dropout
    target_modules=[                   # 目标模块
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj"
    ],
)

# 应用 LoRA
model = get_peft_model(model, lora_config)

# 查看可训练参数
model.print_trainable_parameters()
# 输出示例：trainable params: 41,943,040 || all params: 8,072,204,288 || trainable%: 0.52%

from transformers import BitsAndBytesConfig

# 配置 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,      # 双重量化
)

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

# 然后像普通 LoRA 一样应用 PEFT
model = get_peft_model(model, lora_config)

{
  "messages": [
    {"role": "system", "content": "你是一个专业的医疗助手。"},
    {"role": "user", "content": "什么是高血压？"},
    {"role": "assistant", "content": "高血压是指动脉血压持续升高的慢性疾病..."}
  ]
}

{
  "instruction": "将以下文本翻译成英文",
  "input": "今天天气很好",
  "output": "The weather is very nice today."
}

用户问题 + 模型回答 → 奖励模型 → 分数（0-1）

目标：最大化 Reward(回答) - β × KL(新模型 || SFT模型)

{
  "prompt": "解释量子计算的基本原理",
  "chosen": "量子计算利用量子力学的叠加态和纠缠态...",
  "rejected": "量子计算就是很快的计算机..."
}

from trl import DPOTrainer, DPOConfig

dpo_config = DPOConfig(
    output_dir="./dpo_output",
    num_train_epochs=1,
    per_device_train_batch_size=4,
    learning_rate=5e-7,
    beta=0.1,  # KL 惩罚系数
    bf16=True,
)

trainer = DPOTrainer(
    model=model,
    ref_model=ref_model,   # SFT 后的参考模型
    args=dpo_config,
    train_dataset=dpo_dataset,
    tokenizer=tokenizer,
)

trainer.train()

# 安装
git clone https://github.com/hiyouga/LLaMA-Factory.git
cd LLaMA-Factory
pip install -e ".[torch,metrics]"

# 启动 Web UI
llamafactory-cli webui

# 命令行训练
llamafactory-cli train examples/train_lora/llama3_lora_sft.yaml

# 数据处理示例
import json

def prepare_sft_data(raw_data):
    """将原始数据转换为 SFT 格式"""
    formatted = []
    for item in raw_data:
        formatted.append({
            "messages": [
                {"role": "system", "content": "你是一个专业的客服助手。"},
                {"role": "user", "content": item["question"]},
                {"role": "assistant", "content": item["answer"]}
            ]
        })
    return formatted

# 数据划分
# 训练集 : 验证集 = 9 : 1

# LLaMA-Factory 配置示例 (train_config.yaml)
model_name_or_path: Qwen/Qwen2.5-7B
stage: sft
finetuning_type: lora

# LoRA 参数
lora_rank: 16
lora_alpha: 32
lora_target: all

# 训练参数
num_train_epochs: 3
per_device_train_batch_size: 4
gradient_accumulation_steps: 4
learning_rate: 1.0e-4
lr_scheduler_type: cosine
warmup_ratio: 0.1
bf16: true

# 数据
dataset: my_custom_dataset
template: qwen

# 合并 LoRA 适配器
from peft import PeftModel

base_model = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-7B")
model = PeftModel.from_pretrained(base_model, "./lora_output")
merged_model = model.merge_and_unload()
merged_model.save_pretrained("./merged_model")