使用 LoRA 微调大语言模型：从原理到实战

# 创建虚拟环境（可选）
conda create -n lora python=3.10
conda activate lora

# 安装 PyTorch（根据 CUDA 版本选择）
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# 安装核心依赖
pip install transformers datasets accelerate peft bitsandbytes
pip install sentencepiece protobuf  # 用于某些 tokenizer
pip install wandb                    # 可选，用于日志记录

import pandas as pd
from datasets import Dataset

# 模拟数据（真实场景请从文件读取）
data = {
    "text": [
        "这部电影太棒了，演员演技出色！",
        "剧情无聊，浪费时间。",
        "画面精美，值得一看。",
        "烂片，完全看不下去。",
        "非常感人，强烈推荐。",
        "一般般，没什么亮点。"
    ],
    "label": [1, 0, 1, 0, 1, 0]  # 1 正面，0 负面
}
df = pd.DataFrame(data)
dataset = Dataset.from_pandas(df)

# 划分训练集和测试集
dataset = dataset.train_test_split(test_size=0.2, seed=42)
train_dataset = dataset["train"]
eval_dataset = dataset["test"]
print(f"训练集大小: {len(train_dataset)}, 测试集大小: {len(eval_dataset)}")

<|user|>
{text}
<|assistant|>
{label}

def preprocess_function(examples, tokenizer, max_length=128):
    # 将标签转为文字
    label_map = {0: "负面", 1: "正面"}
    inputs = [f"请判断以下评论的情感倾向：{text} 答案：" for text in examples["text"]]
    targets = [label_map[l] for l in examples["label"]]

    # 对输入进行 tokenize
    model_inputs = tokenizer(inputs, max_length=max_length, truncation=True, padding=False)
    # 对目标进行 tokenize，并添加 EOS token
    with tokenizer.as_target_tokenizer():
        labels = tokenizer(targets, max_length=8, truncation=True, padding=False)

    model_inputs["labels"] = labels["input_ids"]
    return model_inputs

# 测试预处理
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen-1_8B")  # 后续会替换为基础模型
# 如果模型没有 pad_token，设置 eos_token 为 pad_token
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

tokenized_train = train_dataset.map(
    lambda x: preprocess_function(x, tokenizer),
    batched=True,
    remove_columns=train_dataset.column_names
)
tokenized_eval = eval_dataset.map(
    lambda x: preprocess_function(x, tokenizer),
    batched=True,
    remove_columns=eval_dataset.column_names
)

# 设置数据整理器（动态填充）
from transformers import DataCollatorForSeq2Seq
data_collator = DataCollatorForSeq2Seq(tokenizer, model=None, padding=True)

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

model_name = "Qwen/Qwen-1_8B"  # 或 "meta-llama/Llama-2-7b-hf"

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

# 加载模型
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",          # 自动分配到 GPU
    trust_remote_code=True      # Qwen 需要
)

# 加载 tokenizer
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token
    # 如果模型没有 pad_token，但需要为左填充设置
    tokenizer.padding_side = "right"  # 根据模型习惯

# 确保模型在训练模式
model.train()

from peft import LoraConfig, get_peft_model, TaskType

# LoRA 配置
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,      # 因果语言模型
    r=8,                               # 秩
    lora_alpha=32,                     # 缩放系数
    target_modules=["q_proj", "v_proj"],  # 对于 Qwen，通常模块名为 c_attn 等，需查看模型结构
    lora_dropout=0.05,
    bias="none",
    inference_mode=False,
)

# 适配模型
model = get_peft_model(model, lora_config)

# 打印可训练参数
model.print_trainable_parameters()
# 输出：trainable params: 约 4.7M (对于 1.8B 模型)

from transformers import Trainer, TrainingArguments
import os

# 输出目录
output_dir = "./qwen-lora-classifier"

training_args = TrainingArguments(
    output_dir=output_dir,
    num_train_epochs=3,
    per_device_train_batch_size=4,
    per_device_eval_batch_size=4,
    gradient_accumulation_steps=2,
    evaluation_strategy="steps",
    eval_steps=50,
    save_steps=50,
    logging_steps=10,
    learning_rate=2e-4,
    fp16=True,
    warmup_ratio=0.03,
    lr_scheduler_type="cosine",
    save_total_limit=2,
    load_best_model_at_end=True,
    metric_for_best_model="eval_loss",
    greater_is_better=False,
    report_to="none",            # 不启用 wandb
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_train,
    eval_dataset=tokenized_eval,
    data_collator=data_collator,
    tokenizer=tokenizer,
)

# 开始训练
trainer.train()

model.save_pretrained(output_dir)
tokenizer.save_pretrained(output_dir)

from peft import PeftModel

base_model = AutoModelForCausalLM.from_pretrained(
    model_name,
    device_map="auto",
    trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)

lora_model = PeftModel.from_pretrained(base_model, output_dir)
lora_model.eval()

def predict(text, model, tokenizer, max_new_tokens=8):
    prompt = f"请判断以下评论的情感倾向：{text} 答案："
    inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=128).to(model.device)
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            do_sample=False,      # 贪婪解码
            pad_token_id=tokenizer.eos_token_id
        )
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    # 提取答案部分（去除 prompt）
    answer = response[len(prompt):].strip()
    return answer

# 测试
test_texts = [
    "画面美轮美奂，故事引人入胜。",
    "剧情拖沓，演员演技尴尬。"
]
for t in test_texts:
    pred = predict(t, lora_model, tokenizer)
    print(f"输入: {t}\n预测: {pred}\n")