LoRA 微调实战

pip install transformers peft bitsandbytes accelerate

# LoRA 核心思想示意
# 原始全参数微调：可训练参数 = d × d (如 4096 × 4096 = 16M 参数)
# LoRA 低秩适配：可训练参数 = 2 × d × r (如 2 × 4096 × 8 = 65K 参数)
# 参数量减少比例：d / (2r) 倍

import torch

# 模拟 LoRA 的核心公式
d = 4096  # 隐藏层维度
r = 8     # LoRA 秩

# W_pretrained: 预训练权重 (冻结)
W_pretrained = torch.randn(d, d)

# B×A: 低秩更新矩阵 (可训练)
B = torch.randn(d, r)  # (4096, 8)
A = torch.randn(r, d)  # (8, 4096)

# 可训练参数对比
original_params = d * d  # 16,777,216
lora_params = 2 * d * r  # 65,536
print(f"全参数微调参数量: {original_params:,}")
print(f"LoRA 可训练参数量: {lora_params:,}")
print(f"参数量减少: {original_params / lora_params:.1f}x")

# 验证安装的库版本
import transformers
import peft
import bitsandbytes
import torch

print(f"transformers: {transformers.__version__}")
print(f"peft: {peft.__version__}")
print(f"bitsandbytes: {bitsandbytes.__version__}")
print(f"PyTorch: {torch.__version__}")
print(f"CUDA available: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"GPU: {torch.cuda.get_device_name(0)}")

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
import torch

# 配置 4-bit 量化
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,                    # 启用 4-bit 量化加载
    bnb_4bit_compute_dtype=torch.float16,  # 计算时使用 float16
    bnb_4bit_use_double_quant=True,        # 启用双重量化进一步压缩
    bnb_4bit_quant_type="nf4"              # NF4 量化类型（Normal Float 4）
)

# 选择基座模型（建议新手从小型模型开始）
model_id = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"

print("正在加载模型...")
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True
)

print("正在加载 tokenizer...")
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token

print(f"模型加载完成")
print(f"模型参数量: {model.num_parameters() / 1e6:.2f}B")

import torch

# 检查 GPU 显存占用
if torch.cuda.is_available():
    allocated = torch.cuda.memory_allocated() / 1024**3
    reserved = torch.cuda.memory_reserved() / 1024**3
    print(f"GPU 显存已占用: {allocated:.2f} GB")
    print(f"GPU 显存已预留: {reserved:.2f} GB")

# 对比：fp16 加载需要多少显存
# TinyLlama-1.1B fp16 约需 2.2GB
# TinyLlama-1.1B 4bit 约需 0.6GB

# 简单的生成测试
test_prompt = "What is machine learning?"

inputs = tokenizer(test_prompt, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=50,
        temperature=0.7,
        do_sample=True
    )

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(f"生成结果: {response}")

from peft import LoraConfig, get_peft_model, TaskType

# LoRA 配置参数详解
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,      # 任务类型：因果语言模型
    r=16,                               # 秩：越高越灵活，但参数量增加
    lora_alpha=32,                      # 缩放因子：通常设为 r 的 2 倍
    lora_dropout=0.05,                  # Dropout 概率防止过拟合
    bias="none",                        # 是否训练 bias："none"/"all"/"lora_only"
    target_modules=[                   # 目标模块：通常选择 attention 投影层
        "q_proj",                      # Query 投影
        "v_proj",                      # Value 投影
        # 可选: "k_proj", "o_proj"
    ],
    inference_mode=False,              # 训练模式设为 False
)

# 将 LoRA 注入模型
model = get_peft_model(model, lora_config)

# 查看可训练参数
model.print_trainable_parameters()
# 输出示例: "trainable params: 4,194,304 || all params: 1,100,000,000 || trainable%: 0.3813%"

# 对比不同 r 值的参数量（纯计算方式，不修改模型）
d = 4096  # 隐藏层维度
num_target_modules = 2  # q_proj, v_proj
num_layers = 22  # TinyLlama-1.1B 的层数

for r_value in [8, 16, 32, 64]:
    # 每个目标模块的参数：2 * d * r（A矩阵 + B矩阵）
    params_per_module = 2 * d * r_value
    total_params = params_per_module * num_target_modules * num_layers
    print(f"r={r_value}: 约 {total_params/1e6:.1f}M 可训练参数")

print("
规律：r 增加 2 倍，可训练参数增加 2 倍")

# 保存 LoRA 适配器
model.save_pretrained("./lora_adapter")

# 查看保存的文件
import os
print(os.listdir("./lora_adapter"))
# 输出: ['adapter_config.json', 'adapter_model.bin']

# 加载保存的适配器
from peft import PeftModel
loaded_model = PeftModel.from_pretrained(model, "./lora_adapter")

from transformers import AutoTokenizer
import json

# 对话示例
messages = [
    {"role": "system", "content": "你是一个有用的AI助手"},
    {"role": "user", "content": "请解释什么是机器学习"},
    {"role": "assistant", "content": "机器学习是人工智能的一个分支..."}
]

# 加载 tokenizer
model_id = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)

# 使用 chat template 格式化
formatted_text = tokenizer.apply_chat_template(
    messages,
    tokenize=False,        # 返回字符串而非 token IDs
    add_generation_prompt=True  # 为生成添加起始标记
)

print("格式化后的文本:")
print(formatted_text)
print("
" + "="*50)

# 验证：解码验证格式
tokens = tokenizer(formatted_text, return_tensors="pt")
print(f"Token 数量: {len(tokens['input_ids'][0])}")

from datasets import Dataset
import pandas as pd
from sklearn.model_selection import train_test_split

# 从 JSON/CSV 加载原始数据
# 假设数据格式: {"instruction": "...", "output": "..."}
def load_instruction_data(file_path):
    with open(file_path, 'r', encoding='utf-8') as f:
        data = json.load(f)
    return data

# 转换为 ChatML 格式
def format_instruction_dataset(raw_data, tokenizer):
    formatted_data = []
    for item in raw_data:
        messages = [
            {"role": "system", "content": "你是一个有用的助手"},
            {"role": "user", "content": item["instruction"]},
            {"role": "assistant", "content": item["output"]}
        ]
        text = tokenizer.apply_chat_template(messages, tokenize=False)
        formatted_data.append({"text": text})
    return formatted_data

# 划分数据集
train_data, val_data = train_test_split(formatted_data, test_size=0.1, random_state=42)

# 创建 HuggingFace Dataset
train_dataset = Dataset.from_list(train_data)
val_dataset = Dataset.from_list(val_data)

print(f"训练集大小: {len(train_dataset)}")
print(f"验证集大小: {len(val_dataset)}")

import re

def clean_text(text):
    # 去除多余空白
    text = re.sub(r'\s+', ' ', text)
    # 去除特殊控制字符
    text = re.sub(r'[\x00-\x1f\x7f-\x9f]', '', text)
    # 去除 HTML 标签
    text = re.sub(r'<[^>]+>', '', text)
    return text.strip()

def filter_long_samples(sample, max_length=2048):
    """过滤过长的样本"""
    if len(sample) > max_length:
        return False
    return True

# 应用清洗
cleaned_data = [clean_text(item) for item in raw_data]
filtered_data = [item for item in cleaned_data if filter_long_samples(item)]