微调大型语言模型：定制 Llama 3 8B 应用

model = FastLanguageModel.get_peft_model(
    model,
    r=16, # Choose any number > 0 ! Suggested 8, 16, 32, 64, 128
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj",],
    lora_alpha=16,
    lora_dropout=0, # Supports any, but = 0 is optimized
    bias="none",    # Supports any, but = "none" is optimized
    # [NEW] "unsloth" uses 30% less VRAM, fits 2x larger batch sizes!
    use_gradient_checkpointing="unsloth", # True or "unsloth" for very long context
    random_state=3407,
    use_rslora=False,  # We support rank stabilized LoRA
    loftq_config=None, # And LoftQ
)

初始化 Hugging Face 的监督微调训练器

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=max_seq_length,
    dataset_num_proc=2,
    packing=False, # Can make training 5x faster for short sequences.
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=5,
        max_steps=60,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=1,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=3407,
        output_dir="outputs",
    ),
)

训练模型

trainer_stats = trainer.train()

监督微调训练器（SFT）

在预训练一个 LLM 之后，下一个关键步骤是监督微调。这个过程对于开发一个能够理解并生成连贯响应的模型至关重要，而不仅仅是完成句子。

像 Hugging Face 的 SFT（监督微调训练器）和 PEFT（参数高效微调），以及 Tim Dettmers 的 BitsAndBytes 等工具，极大地简化了将 LoRA、量化和微调等技术应用到模型的过程。这些库简化了高级优化方法的实施，使它们对开发者和研究人员更加易于访问和高效。

下面，你会注意到 Unsloth、SFT 和 ORPO 的代码非常相似。这种相似性源于这些库背后的基本思想大致相同，差异主要在于库本身以及可能的一些超参数。

以 4 位精度导入模型

# Hugging Face model id
model_id = "meta-llama/Meta-Llama-3-8B"
# model_id = "mistralai/Mistral-7B-v0.1"

# BitsAndBytesConfig int-4 config
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_use_double_quant=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16 if use_flash_attention2 else torch.float16
)

# Load model and tokenizer
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    use_cache=False,
    device_map="auto",
    token=os.environ["HF_TOKEN"], # if model is gated like llama or mistral
    attn_implementation="flash_attention_2" if use_flash_attention2 else "sdpa"
)
model.config.pretraining_tp = 1

tokenizer = AutoTokenizer.from_pretrained(
    model_id,
    token=os.environ["HF_TOKEN"], # if model is gated like llama or mistral
)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"

安装 LoRA

# LoRA config based on QLoRA paper
peft_config = LoraConfig(
    lora_alpha=16,
    lora_dropout=0.1,
    r=64,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=[
        "q_proj",
        "k_proj",
        "v_proj",
        "o_proj",
        "gate_proj",
        "up_proj",
        "down_proj",
    ]
)

# Prepare model for training
model = prepare_model_for_kbit_training(model)

初始化 Hugging Face 的监督微调训练器

args = TrainingArguments(
    output_dir="mistral-int4-alpaca",
    num_train_epochs=1,
    per_device_train_batch_size=6 if use_flash_attention2 else 2, # you can play with the batch size depending on your hardware
    gradient_accumulation_steps=4,
    gradient_checkpointing=True,
    optim="paged_adamw_8bit",
    logging_steps=10,
    save_strategy="epoch",
    learning_rate=2e-4,
    bf16=use_flash_attention2,
    fp16=not use_flash_attention2,
    tf32=use_flash_attention2,
    max_grad_norm=0.3,
    warmup_steps=5,
    lr_scheduler_type="linear",
    disable_tqdm=False,
    report_to="none"
)

model = get_peft_model(model, peft_config)

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    peft_config=peft_config,
    max_seq_length=2048,
    tokenizer=tokenizer,
    packing=True,
    formatting_func=format_instruction,
    args=args,
)

训练模型

trainer.train()

优势比偏好优化（ORPO）

在这篇博客文章中，我们专注于大型语言模型（LLMs）的预训练和监督微调。然而，所有最先进的 LLMs 都经历了另一个关键步骤：偏好对齐。这一步骤发生在预训练和微调之后，你告知模型哪些生成的输出是可取的，哪些不是。流行的偏好对齐方法包括来自人类反馈的强化学习（RLHF）和直接偏好优化（DPO）。

一种名为优势比偏好优化（ORPO）的新方法于 2024 年 3 月出现，结合了监督微调和偏好对齐。

这里我们有一部分使用 ORPO 进行微调和偏好对齐的代码。完整代码可以在相关 Colab 笔记本中找到。

以 4 位精度导入模型

# Model
base_model = "meta-llama/Meta-Llama-3-8B"
new_model = "OrpoLlama-3-8B"

# QLoRA config
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch_dtype,
    bnb_4bit_use_double_quant=True,
)

# Load tokenizer
tokenizer = AutoTokenizer.from_pretrained(base_model)

# Load model
model = AutoModelForCausalLM.from_pretrained(
    base_model,
    quantization_config=bnb_config,
    device_map="auto",
    attn_implementation=attn_implementation
)

配置 LoRA

# LoRA config
peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=['up_proj', 'down_proj', 'gate_proj', 'k_proj', 'q_proj', 'v_proj', 'o_proj']
)

model = prepare_model_for_kbit_training(model)

初始化 Hugging Face 的 ORPO 训练器

orpo_args = ORPOConfig(
    learning_rate=8e-6,
    beta=0.1,
    lr_scheduler_type="linear",
    max_length=1024,
    max_prompt_length=512,
    per_device_train_batch_size=2,
    per_device_eval_batch_size=2,
    gradient_accumulation_steps=4,
    optim="paged_adamw_8bit",
    num_train_epochs=1,
    evaluation_strategy="steps",
    eval_steps=0.2,
    logging_steps=1,
    warmup_steps=10,
    report_to="wandb",
    output_dir="./results/",
)

trainer = ORPOTrainer(
    model=model,
    args=orpo_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    peft_config=peft_config,
    tokenizer=tokenizer,
)

训练模型

trainer.train()

推理与部署

训练完成后，模型通常会保存为 LoRA 适配器权重。在实际应用中，您需要加载基础模型并结合这些适配器进行推理。

from peft import PeftModel

# 加载基础模型
base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-8B")
# 加载 LoRA 适配器
model = PeftModel.from_pretrained(base_model, "path/to/your/lora_adapter")

# 进行推理
inputs = tokenizer("请回答以下问题：", return_tensors="pt")
outputs = model.generate(**inputs, max_new_tokens=100)
print(tokenizer.decode(outputs[0]))

通过这种方式，您可以快速将微调后的模型集成到您的生产环境中，无需重新加载整个庞大的基础模型权重，从而节省内存并提高响应速度。

结论

尽管像 GPT、Gemini 或 Claude 这样的大型语言模型（LLMs）功能强大，但它们的大规模和资源需求使它们在许多任务中不切实际。为了解决这个问题，可以使用量化和低秩适应（LoRA）等技术对较小的开源 LLMs 进行微调和定制以满足特定需求。这些技术减少了内存消耗并提高了计算效率，使得训练模型更加经济，尤其是对于那些参数少于 100 亿的模型。

像 Unsloth、监督微调训练器（SFT）和优势比偏好优化（ORPO）这样的工具简化了微调过程，使其更加易于访问。例如，Unsloth 提供的优化可以显著加速训练，而 ORPO 结合了监督微调和偏好对齐，以提高模型性能。

通过利用这些技术和工具，开发人员和研究人员可以根据特定需求定制 LLMs，而无需承担与训练大型模型相关的高昂成本。这种方法使得高级语言模型的访问民主化，并在不同领域启用了广泛的应用。