构建AI智能体：深入浅出LoRA：低成本高效微调大模型的原理与实践

lora_config = LoraConfig(
    r=8,  # 秩的大小
    # ... 其他参数
)

# 不同秩值的参数数量对比
def calculate_lora_params(base_params, r, target_modules_count):
    """
    计算LoRA参数数量
    base_params: 基础模型参数量
    target_modules_count: 目标模块的数量
    """
    lora_params = 0
    for module in target_modules:
        # 假设每个目标模块的维度是 d x d
        lora_params += 2 * d * r  # A矩阵: d×r, B矩阵: r×d
    return lora_params

# 示例：对于Qwen1.5-0.5B，不同秩的参数对比
rank_comparison = {
    "r=2": {"params": 196,608, "percentage": 0.035%},
    "r=4": {"params": 393,216, "percentage": 0.070%},
    "r=8": {"params": 786,432, "percentage": 0.140%},
    "r=16": {"params": 1,572,864, "percentage": 0.281%},
    "r=32": {"params": 3,145,728, "percentage": 0.563%}
}

lora_config = LoraConfig(
    r=8,
    lora_alpha=16,  # 缩放因子
    # ...
)

# alpha/r 的实际影响
def lora_contribution(alpha, r):
    scale = alpha / r
    return scale

# 示例对比
scale_examples = {
    "r=8, alpha=16": lora_contribution(16, 8),   # scale=2.0
    "r=8, alpha=8": lora_contribution(8, 8),     # scale=1.0  
    "r=8, alpha=4": lora_contribution(4, 8),     # scale=0.5
    "r=16, alpha=32": lora_contribution(32, 16), # scale=2.0
}

# 在注意力机制中的作用
Q = q_proj(hidden_states)  # 查询向量：我要找什么？
K = k_proj(hidden_states)  # 键向量：我有什么？
V = v_proj(hidden_states)  # 值向量：我的内容是什么？

# 注意力机制的最后一步
attention_output = attention_weights @ V
final_output = o_proj(attention_output)  # 投影回原始维度

# SwiGLU激活函数的前馈网络
gate = gate_proj(hidden_states)  # 门控信号
up = up_proj(hidden_states)     # 上投影
down = down_proj(gate * up)     # 下投影

# 相当于：down_proj(gate_proj(x) * up_proj(x))

# 模型的最后输出层
hidden_states = ...  # 经过所有层处理后的隐藏状态
logits = lm_head(hidden_states)  # 转换为词汇表概率
next_token = argmax(logits)      # 选择最可能的下一个token

lora_config = LoraConfig(
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    # ...
)

# 策略1：只调注意力机制（最常用）
target_modules1 = ["q_proj", "k_proj", "v_proj", "o_proj"]

# 策略2：注意力+FFN（更全面）
target_modules2 = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]

# 策略3：只调Q、V（参数最少）
target_modules3 = ["q_proj", "v_proj"]

lora_config = LoraConfig(
    lora_dropout=0.05,  # Dropout比率
    # ...
)

dropout_choices = {
    "小数据集(<1000样本)": 0.05-0.1,    # 容易过拟合，需要更多正则化
    "中等数据集(1000-10000)": 0.05,     # 平衡状态
    "大数据集(>10000)": 0.0-0.05,       # 不容易过拟合，可以少用或不用
    "任务简单": 0.0-0.05,               # 任务简单，减少正则化
    "任务复杂": 0.05-0.1,               # 任务复杂，需要更多正则化
}

lora_config = LoraConfig(
    bias="none",  # 可选："none", "all", "lora_only"
    # ...
)

lora_config_simple = LoraConfig(
    r=4,                    # 小秩，任务简单
    lora_alpha=8,           # 适中的缩放
    target_modules=["q_proj", "v_proj"],  # 只调关键模块
    lora_dropout=0.05,      # 轻微正则化
    bias="none",            # 不训练偏置
    task_type="CAUSAL_LM"
)

lora_config_complex = LoraConfig(
    r=16,                   # 较大秩，任务复杂
    lora_alpha=32,          # 较大的影响因子
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.1,       # 较强的正则化
    bias="none",
    task_type="CAUSAL_LM"
)

lora_config_minimal = LoraConfig(
    r=2,                    # 最小秩
    lora_alpha=4,           # 小缩放
    target_modules=["q_proj"],  # 只调查询投影
    lora_dropout=0.0,       # 无dropout
    bias="none",
    task_type="CAUSAL_LM"
)

from modelscope import AutoModelForCausalLM, AutoTokenizer, snapshot_download
from peft import LoraConfig, get_peft_model
import torch

# 设置设备为CPU
device = "cpu"

# 从ModelScope下载/加载模型和分词器
model_id = "qwen/Qwen1.5-0.5B"
cache_dir = "D:\\modelscope\\hub"

print("正在下载/校验模型缓存...")
local_model_path = snapshot_download(model_id, cache_dir=cache_dir)

print("正在加载模型...")
tokenizer = AutoTokenizer.from_pretrained(local_model_path, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    local_model_path,
    trust_remote_code=True,
    torch_dtype=torch.float32,  # CPU上使用float32
    device_map=device
)

# 设置padding token
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

print("模型加载完成！")

# 生成微调前的基线输出用于对比
print("开始生成微调前基线输出...")
baseline_prompt = "### 指令:\n写一篇关于‘秋天的第一杯奶茶’的小红书文案\n\n### 回答:\n"
baseline_inputs = tokenizer(baseline_prompt, return_tensors="pt").to(model.device)
with torch.no_grad():
    baseline_outputs = model.generate(
        **baseline_inputs,
        max_new_tokens=200,
        temperature=0.8,
        do_sample=True,
        top_p=0.9,
    )
baseline_text = tokenizer.decode(baseline_outputs[0], skip_special_tokens=True)
print("【微调前】", baseline_text)


from peft import LoraConfig, get_peft_model

# 这就是LoRA的配置“蓝图”
lora_config = LoraConfig(
    r=16,  # 秩，可以理解为“技能马甲”的精细度。通常8,16,32，越大越精细但也可能过拟合。
    lora_alpha=32, # 一个缩放因子，通常设为r的2倍左右。
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    # 以上指定了要把“技能徽章”贴到模型的哪些部位。通常是注意力机制和全连接层。
    lora_dropout=0.05, # 随机丢弃一些神经元，防止过拟合，让模型更鲁棒。
    bias="none",
    task_type="CAUSAL_LM" # 指定我们的任务是因果语言模型（即文本生成）。
)

# 将基础模型“包装”成LoRA模型
model = get_peft_model(model, lora_config)
model.print_trainable_parameters() # 打印可训练参数数量


from datasets import Dataset

# 模拟一些训练数据：指令-输出对
data = [
    {
        "instruction": "写一篇关于‘周末露营’的小红书文案",
        "output": "救命！这个露营地也太太太出片了吧！\n\n周末逃离城市计划大成功！\n找到了一个宝藏营地，草坪超大超干净～\n傍晚的夕阳绝美，随手一拍都是大片📸\n姐妹们快冲！链接我放评论区啦～\n\n#周末去哪儿 #露营穿搭 #治愈系风景"
    },
    {
        "instruction": "推荐一款‘办公室零食’",
        "output": "办公室摸鱼零食天花板被我找到啦！\n\n这个海苔脆真的好吃到跺脚！\n卡茨卡茨根本停不下来，关键是低卡零负担！\n同事都被我安利了一圈，纷纷要链接\n\n#办公室零食 #打工人日常 #低卡零食"
    },
    # ... 可以准备更多这样的数据
]

# 将数据格式化成模型能理解的文本格式
def format_func(example):
    text = f"### 指令:\n{example['instruction']}\n\n### 回答:\n{example['output']}"
    return {"text": text}

dataset = Dataset.from_list(data).map(format_func)

# 对文本进行分词
tokenized_dataset = dataset.map(lambda x: tokenizer(x["text"], truncation=True, max_length=512), batched=True)


from transformers import TrainingArguments, Trainer, DataCollatorForLanguageModeling

training_args = TrainingArguments(
    output_dir="./xiaohongshu-lora", # 输出目录
    per_device_train_batch_size=4,   # 根据你的GPU调整
    gradient_accumulation_steps=4,    # 梯度累积，模拟更大的batch size
    learning_rate=1e-4,              # 学习率
    num_train_epochs=3,              # 训练轮数
    logging_steps=10,
    logging_dir="./logs",
    save_steps=200,
    fp16=torch.cuda.is_available(), # 在支持半精度的GPU上开启，可以加速训练
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
    data_collator=DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False), # 不是掩码语言模型
)

print("开始训练你的‘小红书博主’模型...")
trainer.train()

# 保存我们训练好的“技能马甲”
trainer.model.save_pretrained("./my_xiaohongshu_lora_adapter")

from peft import PeftModel

# 加载基础模型
base_model = AutoModelForCausalLM.from_pretrained(
    local_model_path,
    trust_remote_code=True,
    torch_dtype=torch.float32,
    device_map=device
)
# 加载我们刚训练好的LoRA适配器，把它“穿”在基础模型上
model = PeftModel.from_pretrained(base_model, "./my_xiaohongshu_lora_adapter")
model.eval()

# 现在，让它生成文案吧！
prompt = "### 指令:\n写一篇关于‘秋天的第一杯奶茶’的小红书文案\n\n### 回答:\n"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

outputs = model.generate(
    **inputs,
    max_new_tokens=200, # 最多生成200个新token
    temperature=0.8,    # 控制创造性，越低越确定，越高越随机
    do_sample=True,
    top_p=0.9,          # 核采样，让生成质量更高
)

generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print("【微调后】", generated_text)