大语言模型常用微调与基于SFT微调DeepSeek R1指南

概述

大型语言模型（LLM，Large Language Model）的微调（Fine-tuning）是指在一个预训练模型的基础上，使用特定领域或任务的数据对模型进行进一步训练，以使其在该领域或任务上表现更好。微调是迁移学习的一种常见方法，能够显著提升模型在特定任务上的性能。在大型语言模型（LLM）的微调中，有几种常见的方法，包括 SFT（监督微调）、LoRA（低秩适应）、P-tuning v2 和 **Freeze

1.大语言模型微调

1.1 微调的工作原理

微调（Fine-tuning）是指在预训练模型的基础上，使用特定任务的标注数据对模型进行进一步训练，使其在该任务上表现更好。微调的核心思想是利用预训练模型已经学习到的通用语言表示，通过少量任务数据调整模型参数，使其适应特定任务。

微调的关键组件

输入 (X)：
- 提供给模型的文本数据（例如，电影评论、问题、对话等）。
- 对于文本生成任务，输入可能是一个问题或提示。
目标 (Y)：
- 基于标注数据的预期输出（例如，情绪标签、聊天机器人响应、摘要文本等）。
- 对于分类任务，目标可能是类别标签（如“积极”或“消极”）。
- 对于生成任务，目标可能是完整的文本响应。
损失函数：
- 衡量模型的预测与目标之间的差异。
- 通过优化损失函数，模型逐渐调整参数以更好地拟合任务数据。

示例：IMDB 情绪分类

输入 (X)：电影评论，例如“这部电影的视觉效果很棒，但情节很弱。”
目标 (Y)：情绪标签，例如“积极”或“消极”。
模型任务：根据输入文本预测正确的情绪标签。

示例：文本生成

输入 (X)：问题，例如“什么是人工智能？”
目标 (Y)：生成的响应，例如“人工智能是模拟人类智能的技术。”
模型任务：根据输入问题生成正确的文本响应。

1.2 使用的损失函数：交叉熵损失

在语言模型的微调中，交叉熵损失（Cross-Entropy Loss） 是最常用的损失函数。它用于衡量模型预测的概率分布与真实目标分布之间的差异。

交叉熵损失的公式

对于语言模型，交叉熵损失的公式为：
$\text{Cross-Entropy Loss} = -\sum_{i=1}^{N} y_i \log(p_i)$

其中：

$y_i$ ：目标分布（真实标签的 one-hot 编码）。
$p_i$ ：模型预测的概率分布。
$N$ ：词汇表的大小（对于分类任务，( N ) 是类别数）。

交叉熵损失的作用

衡量预测与目标的差异：
- 当模型预测的概率分布与目标分布越接近时，交叉熵损失越小。
- 当模型预测的概率分布与目标分布差异较大时，交叉熵损失越大。
优化目标：
- 在训练过程中，通过反向传播和梯度下降，模型不断调整参数以最小化交叉熵损失。

示例：文本生成中的交叉熵损失

假设模型生成一个句子，每个词的概率分布如下：

目标词：["I", "love", "AI"]
模型预测的概率分布：
- I: 0.9
- love: 0.8
- AI: 0.7

交叉熵损失计算如下：
$text{Loss} = -(\log(0.9) + \log(0.8) + \log(0.7))$

通过最小化损失，模型逐渐学会生成更准确的文本。

1.3 SFT（监督微调，Supervised Fine-Tuning）

SFT 是最常见的微调方法，通过在特定任务的标注数据上对预训练模型进行全参数微调。

特点

全参数微调：更新模型的所有参数。
适合场景：任务数据量较大，计算资源充足。
优点：模型可以完全适应任务。
缺点：计算成本高，显存占用大。

实现代码

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
from datasets import load_dataset

# 加载预训练模型和分词器
model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# 加载数据集
dataset = load_dataset("imdb")

# 数据预处理
def preprocess_function(examples):
    return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=512)

tokenized_datasets = dataset.map(preprocess_function, batched=True)

# 设置训练参数
training_args = TrainingArguments(
    output_dir="./sft_results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
    save_strategy="epoch",
    logging_dir="./logs",
)

# 定义 Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["test"],
    tokenizer=tokenizer,
)

# 开始微调
trainer.train()

# 保存模型
model.save_pretrained("./sft-fine-tuned-model")
tokenizer.save_pretrained("./sft-fine-tuned-model")

1.4 LoRA（低秩适应，Low-Rank Adaptation)

LoRA 是一种高效的微调方法，通过低秩分解的方式微调模型参数，减少计算量和显存占用。

特点

低秩分解：只微调模型的一部分参数（低秩矩阵）。
适合场景：资源有限，但仍需高效微调。
优点：参数效率高，显存占用低。
缺点：需要额外的实现支持。

实现代码

使用 peft 库实现 LoRA：

pip install peft

from transformers import AutoTokenizer, AutoModelForSequenceClassification
from peft import get_peft_model, LoraConfig, TaskType
from datasets import load_dataset

# 加载预训练模型和分词器
model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# 配置 LoRA
lora_config = LoraConfig(
    task_type=TaskType.SEQ_CLS,  # 任务类型
    r=8,  # 低秩矩阵的秩
    lora_alpha=32,  # 缩放因子
    lora_dropout=0.1,  # Dropout 概率
)

# 应用 LoRA
model = get_peft_model(model, lora_config)

# 加载数据集
dataset = load_dataset("imdb")

# 数据预处理
def preprocess_function(examples):
    return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=512)

tokenized_datasets = dataset.map(preprocess_function, batched=True)

# 设置训练参数
training_args = TrainingArguments(
    output_dir="./lora_results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
    save_strategy="epoch",
    logging_dir="./logs",
)

# 定义 Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["test"],
    tokenizer=tokenizer,
)

# 开始微调
trainer.train()

# 保存模型
model.save_pretrained("./lora-fine-tuned-model")

1.5 P-tuning v2

P-tuning v2 是一种提示微调方法，通过优化提示（Prompt）来引导模型完成任务，而不改变模型参数。

特点

提示优化：通过可学习的提示向量引导模型。
适合场景：少样本学习，资源有限。
优点：无需修改模型参数，显存占用低。
缺点：需要设计提示模板。

实现代码

使用 openprompt 库实现 P-tuning v2：

pip install openprompt

from openprompt import PromptDataLoader, PromptForClassification
from openprompt.plms import load_plm
from openprompt.prompts import ManualTemplate
from openprompt.prompts import ManualVerbalizer
from datasets import load_dataset

# 加载预训练模型
plm, tokenizer, model_config, WrapperClass = load_plm("bert", "bert-base-uncased")

# 加载数据集
dataset = load_dataset("imdb")

# 定义提示模板
template = ManualTemplate(
    text='{"placeholder":"text_a"} It was {"mask"}',
    tokenizer=tokenizer,
)

# 定义标签词映射
verbalizer = ManualVerbalizer(
    classes=["negative", "positive"],
    label_words={
        "negative": ["bad"],
        "positive": ["good"],
    },
    tokenizer=tokenizer,
)

# 定义 Prompt 模型
prompt_model = PromptForClassification(
    plm=plm,
    template=template,
    verbalizer=verbalizer,
)

# 数据加载器
dataloader = PromptDataLoader(
    dataset=dataset["train"],
    tokenizer=tokenizer,
    template=template,
    max_seq_length=512,
)

# 训练（伪代码，需补充优化器和训练循环）
for batch in dataloader:
    logits = prompt_model(batch)
    # 计算损失并更新模型

1.6 Freeze 微调

Freeze 微调是指冻结模型的大部分参数，只微调部分层（如分类头）。

特点

参数冻结：只微调模型的最后几层。
适合场景：资源有限，任务数据量较小。
优点：计算成本低，显存占用少。
缺点：模型适应能力有限。

实现代码

from transformers import AutoTokenizer, AutoModelForSequenceClassification, Trainer, TrainingArguments
from datasets import load_dataset

# 加载预训练模型和分词器
model_name = "bert-base-uncased"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=2)

# 冻结模型的大部分参数
for param in model.bert.parameters():
    param.requires_grad = False

# 加载数据集
dataset = load_dataset("imdb")

# 数据预处理
def preprocess_function(examples):
    return tokenizer(examples["text"], truncation=True, padding="max_length", max_length=512)

tokenized_datasets = dataset.map(preprocess_function, batched=True)

# 设置训练参数
training_args = TrainingArguments(
    output_dir="./freeze_results",
    evaluation_strategy="epoch",
    learning_rate=2e-5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    num_train_epochs=3,
    weight_decay=0.01,
    save_strategy="epoch",
    logging_dir="./logs",
)

# 定义 Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_datasets["train"],
    eval_dataset=tokenized_datasets["test"],
    tokenizer=tokenizer,
)

# 开始微调
trainer.train()

# 保存模型
model.save_pretrained("./freeze-fine-tuned-model")
tokenizer.save_pretrained("./freeze-fine-tuned-model")

1.7 总结

方法	特点	适用场景	优点	缺点
SFT	全参数微调	数据量大，资源充足	完全适应任务	计算成本高
LoRA	低秩分解，部分参数微调	资源有限	参数效率高，显存占用低	需要额外实现
P-tuning	提示优化，不修改模型参数	少样本学习	显存占用低	需要设计提示模板
Freeze	冻结大部分参数，微调部分层	资源有限，数据量小	计算成本低	模型适应能力有限

2.DeepSeek微调

DeepSeek LLM 是一个强大的开源语言模型，但为了最大限度地发挥其在特定应用中的潜力，微调是必不可少的。
在这里插入图片描述

2.1 使用数据子集

在资源有限的硬件上微调像 DeepSeek LLM 这样的大型语言模型时，在完整数据集（例如，具有 25,000 个样本的 IMDB）上进行训练可能会导致过多的训练时间和 GPU 内存问题。

选择一个子集：500 个样本用于训练，100 个样本用于评估。
保持代表性：该子集保留了足够的多样性以实现合理的性能。

使用较小的数据集可以加快实验速度，同时有效地展示微调概念。对于生产级微调，应在更强大的基础设施上使用更大的数据集。

2.2 安装所需的库

首先，安装必要的依赖项：

pip install -U torch transformers datasets accelerate peft bitsandbytes

2.3 使用 4 位量化加载模型

使用 4 位量化使大型模型与有限的 GPU 内存兼容：

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model

model_name = "deepseek-ai/deepseek-llm-7b-base"
# Configure 4-bit quantization
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16  # Use float16 for faster computation
)
# Load tokenizer and model
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name, 
    quantization_config=bnb_config, 
    device_map="auto"
)
# Apply LoRA for memory-efficient fine-tuning
lora_config = LoraConfig(
    r=8,  # Low-rank adaptation size
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],  # Apply LoRA to attention layers
    lora_dropout=0.05,
    bias="none"
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
print(" DeepSeek LLM Loaded with LoRA and 4-bit Precision!")

2.4 使用 Hugging Face 数据集进行训练

为了进行微调，需要一个高质量的数据集。 Hugging Face 提供对各种数据集的访问：

选择数据集

对于此示例，让我们使用 IMDB 数据集对 DeepSeek LLM 进行情绪分类微调：

from datasets import load_dataset

# Load dataset
dataset = load_dataset("imdb")

预处理数据集

将文本转换为模型的标记化输入：

def tokenize_function(examples):
    inputs = tokenizer(
        examples["text"], 
        truncation=True, 
        padding="max_length", 
        max_length=512
    )
    inputs["labels"] = inputs["input_ids"].copy()
    return inputs

tokenized_datasets = dataset.map(tokenize_function, batched=True)
# Subset the dataset for faster experimentation
small_train_dataset = tokenized_datasets["train"].shuffle(seed=42).select(range(500))
small_test_dataset = tokenized_datasets["test"].shuffle(seed=42).select(range(100))
# Print a sample tokenized entry
print("Tokenized Sample:")
print(small_train_dataset[0])

3.LoRA（低秩自适应）

LoRA（低秩自适应）是一种旨在通过以下方式使 DeepSeek LLM 等大型模型的微调更加节省内存的技术：

冻结模型的大部分权重。
在关键层（例如注意层）中引入低秩可训练矩阵。

这大大减少了可训练参数的数量，同时保持了模型的性能。LoRA 可以在资源受限的硬件（例如 Colab GPU）上微调大型语言模型。

#4.代码演练：微调 DeepSeek LLM

首先设置训练参数：

from transformers import TrainingArguments, Trainer

training_args = TrainingArguments(
    output_dir="./results",
    evaluation_strategy="epoch",
    learning_rate=3e-4,  # Lower learning rate for LoRA fine-tuning
    per_device_train_batch_size=1,  # Reduce batch size for memory efficiency
    gradient_accumulation_steps=8,  # Simulate larger batch size
    num_train_epochs=0.5,
    weight_decay=0.01,
    save_strategy="epoch",
    logging_dir="./logs",
    logging_steps=50,
    fp16=True,  # Mixed precision training
)

初始化训练器：

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=small_train_dataset,
    eval_dataset=small_test_dataset,
)
print("🚀 Trainer Initialized!")

开始微调：

print("🚀 Starting Fine-Tuning...")
trainer.train()

保存微调模型：

trainer.save_model("./fine_tuned_deepseek")
tokenizer.save_pretrained("./fine_tuned_deepseek")
print("Fine-Tuned Model Saved Successfully!")