大模型微调完全指南：从原理到实践，解锁领域专属AI

pip install torch transformers accelerate peft bitsandbytes datasets trl scikit-learn

{"instruction": "什么是合同违约？", "input": "", "output": "合同违约是指合同一方或双方未按合同约定履行义务，包括完全不履行、迟延履行或不完全履行。根据《民法典》第577条，违约方应承担继续履行、赔偿损失等违约责任。"}
{"instruction": "如何计算迟延履行的违约金？", "input": "合同约定违约金为每日万分之五", "output": "根据《民法典》第585条，违约金可按合同约定计算。若约定过高，违约方可请求法院适当减少。您提到的万分之五约为年化18.25%，司法实践中通常支持不超过实际损失的30%为上限。"}
...

from datasets import load_dataset

dataset = load_dataset("json", data_files="law_data.jsonl")["train"]

def format_prompt(example):
    return {
        "text": f"### 指令：\n{example['instruction']}\n\n### 输入：\n{example['input'] if example['input'] else '无'}\n\n### 回答：\n{example['output']}"
    }

dataset = dataset.map(format_prompt)

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig

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

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16
)

tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast=True)
tokenizer.pad_token = tokenizer.eos_token  # 避免无 pad_token 警告

model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto",
    torch_dtype=torch.bfloat16,
    trust_remote_code=True
)

from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training

# 准备模型进行 k-bit 训练（需启用梯度检查点）
model.gradient_checkpointing_enable()
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", "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()  # 输出可训练参数占比（约 0.1%）

from transformers import TrainingArguments, Trainer
from trl import SFTTrainer

training_args = TrainingArguments(
    output_dir="./llama2-law-lora",
    per_device_train_batch_size=4,
    gradient_accumulation_steps=8,  # 有效 batch = 32
    num_train_epochs=3,
    learning_rate=2e-4,
    fp16=True,
    logging_steps=10,
    save_steps=200,
    report_to="none",
    optim="paged_adamw_8bit",  # QLoRA 推荐分页优化器
)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    args=training_args,
    train_dataset=dataset,
    formatting_func=lambda x: x["text"],  # 直接使用格式化后的文本
    max_seq_length=1024,
    packing=False,
)

trainer.train()

# 仅保存 LoRA 权重（推荐，轻量）
model.save_pretrained("./llama2-law-lora-adapter")

# 合并并保存完整权重（可选，方便部署）
from peft import PeftModel

base_model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
merged_model = PeftModel.from_pretrained(base_model, "./llama2-law-lora-adapter").merge_and_unload()
merged_model.save_pretrained("./llama2-law-merged")

from evaluate import load
rouge = load("rouge")

# 在验证集上生成并计算
predictions = [tokenizer.decode(generate(...)) for ...]
scores = rouge.compute(predictions=predictions, references=references)

from peft import PeftModel
from transformers import AutoTokenizer, AutoModelForCausalLM

base = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", device_map="auto")
model = PeftModel.from_pretrained(base, "./llama2-law-lora-adapter")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")

prompt = "### 指令：\n什么是不可抗力？\n\n### 输入：\n无\n\n### 回答：\n"
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=256, temperature=0.7)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))