1. 环境准备与模型加载：你的第一个微调起点

嘿，朋友们，我是老张，一个在AI和硬件圈子里摸爬滚打了十多年的老码农。今天咱们不聊那些虚头巴脑的概念，直接上手，用最接地气的方式，带你从零开始微调一个DeepSeek-8B模型。我知道，一听到“大模型微调”，很多刚入门的朋友头都大了，感觉这玩意儿门槛高得吓人。别怕，我当年也是这么过来的，踩过的坑比走过的路还多。今天我就把那些复杂的步骤掰开了、揉碎了，保证你看完就能跟着做，而且能做出效果来。

咱们的目标很明确：用你自己的数据，让这个80亿参数的“大块头”学会新知识，而且是在消费级的显卡上就能跑起来。是不是听起来有点不可思议？几年前这确实需要动辄几十万的A100集群，但现在，感谢像Unsloth这样的优化库，我们手里的RTX 4090甚至4060都能派上用场了。这就像给一辆大卡车换上了更省油、动力更强的引擎，让它能在普通公路上跑得飞快。

那么，第一步要做什么呢？当然是搭台子。你需要一个能跑代码的环境。最省心的办法，就是去租一台云服务器，比如AutoDL、阿里云等平台，上面有现成的、配置好环境的镜像，选一个带NVIDIA显卡的就行。如果你自己有一张显存大于12GB的显卡（比如RTX 3060 12G、4060 Ti 16G、3090/4090），那在自己的电脑上搞也行。我这里假设你已经搞定了服务器或者本地环境，能打开一个Jupyter Notebook或者终端。接下来，咱们先把必要的“工具”装好。打开你的终端，输入下面这几行命令，一条一条执行：

pip install unsloth
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
pip install transformers datasets trl accelerate bitsandbytes
pip install wandb  # 可选，用于可视化训练过程

这几行命令分别安装了Unsloth（我们今天的主角，一个极致优化训练速度的库）、PyTorch（深度学习框架）、Hugging Face的Transformers和Datasets库（模型和数据的家）、TRL（训练库）、以及bitsandbytes（量化工具）。装的时候可能会有点慢，耐心等一下。如果遇到网络问题，可以试试加上清华源或者阿里云的镜像。装好之后，咱们就可以正式开始了。首先，在代码的开头，把需要的库都引进来。

import torch
from unsloth import FastLanguageModel
from datasets import load_dataset
from trl import SFTTrainer
from transformers import TrainingArguments

准备工作做完，咱们就要请出今天的主角——DeepSeek-R1-Distill-Llama-8B模型了。这个模型可以理解为一个已经读过海量互联网文本、具备强大通用理解能力的“大脑”。我们的微调，不是重新教它认字说话，而是像给一位博学的教授进行专项培训，让他精通某个特定领域，比如医学、法律或者编程。加载模型时，有几个关键参数就像汽车的档位和油门，直接决定了你这次“驾驶”的体验和结果。

1.1 理解并设置加载模型的“三驾马车”

加载模型这行代码看似简单，里面却藏着三个新手最容易迷糊的参数：max_seq_length、dtype和load_in_4bit。咱们一个一个来拆解。

max_seq_length = 2048：这个参数决定了模型一次能处理多长的文本。你可以把它想象成模型的“短期记忆容量”。2048个token大概相当于1500个汉字左右。如果你的训练数据（比如问答对）很长，超过了这个长度，超出的部分就会被截断。所以，你需要根据你的数据情况来调整。如果你的数据都是短文本，设成512或1024能节省内存、加快速度；如果数据很长，比如长篇文章，可能需要设到4096甚至更高。但要注意，这个值越大，对显存的需求就越高。

dtype = None：这是数据精度。深度学习计算中的数字不是我们日常用的高精度小数，而是用float32（单精度）、float16（半精度）甚至bfloat16（脑浮点16）来存储的，精度越低，计算越快，占用内存越少。设置为None是最省心的做法，Unsloth库会自动帮你选择当前硬件支持的最佳精度。比如，在NVIDIA的T4、V100等较老显卡上，它会用float16；在Ampere架构（30系、40系）及更新的显卡上，它会用更高效的bfloat16。除非你非常清楚自己在做什么，否则就让它为None。

load_in_4bit = True：这是让消费级显卡能跑动80亿参数模型的关键魔法！ 4位量化。原本模型参数是float16或bfloat16存储的，每个参数占2个字节。通过4位量化技术，我们可以用仅0.5个字节来近似表示一个参数，模型大小直接压缩到原来的1/4！更重要的是，它能在推理和训练时，动态地将参数从4位恢复到计算所需的精度，在精度损失极小的情况下（通常<1%），极大地降低了显存占用。我实测下来，开启4位量化后，DeepSeek-8B模型在24GB显存的3090上微调游刃有余，甚至在16GB的4060 Ti上也能勉强跑起来。所以，这个选项务必设为True。

理解了这三个参数，加载模型就是一行代码的事。你需要一个Hugging Face的访问令牌（token），可以去官网免费注册一个账号获取。

max_seq_length = 2048
dtype = None
load_in_4bit = True
hf_token = "你的_huggingface_token" # 替换成你的真实token

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/DeepSeek-R1-Distill-Llama-8B",
    max_seq_length = max_seq_length,
    dtype = dtype,
    load_in_4bit = load_in_4bit,
    token = hf_token,
)

执行这行代码后，模型和分词器就开始下载了。第一次运行会下载大约8GB的模型文件，需要一点时间。下载完成后，它们就被加载到了你的GPU显存中，准备接受你的调教了。你可以打印一下模型，看看它有多大，感受一下这个“大块头”的规模。

2. 数据准备：给模型“喂”什么，它就成为什么

模型加载好了，就像请来了一位天才学生，但他现在还只是个通才。我们想让他成为医学专家，或者代码高手，下一步就是给他准备专门的“教材”——也就是我们的训练数据集。数据准备是微调中最重要、也最容易被忽视的环节。我见过太多人模型调得飞起，结果因为数据没处理好，训出来的模型要么胡说八道，要么根本学不会新东西。记住一句话：垃圾进，垃圾出（Garbage in, garbage out）。

对于监督微调（SFT），我们通常需要的是“指令-输出”对。比如，在医疗领域，指令是“一个患有急性阑尾炎的病人已经发病5天...此时应如何处理？”，期望的输出是一段专业的医学分析和处理建议。在代码领域，指令可能是“用Python写一个快速排序函数”，输出就是对应的代码。你的数据质量，直接决定了模型微调后的专业程度。数据从哪里来？你可以自己收集整理，也可以使用开源数据集。这里我以Hugging Face上一个开源的医疗推理数据集为例，带你走一遍流程。

2.1 构建提示词模板：与模型对话的“固定句式”

在把原始数据扔给模型之前，我们需要把它们包装成模型能理解的固定格式。这就像教小孩学说话，你得用完整的句子和他交流，而不是只蹦单词。这个固定格式就是提示词模板（Prompt Template）。DeepSeek-R1这个模型，在预训练时可能接触过特定的指令格式，沿用相似的格式能让它学得更快。

我们来看一个专门为思维链（Chain-of-Thought）推理设计的模板：

train_prompt_style = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request. Before answering, think carefully about the question and create a step-by-step chain of thoughts to ensure a logical and accurate response.

### Instruction:
You are a medical expert with advanced knowledge in clinical reasoning, diagnostics, and treatment planning. Please answer the following medical question.

### Question:
{}

### Response:
<think> {}</think> {}
"""

这个模板结构清晰：

  1. 系统指令：告诉模型它现在扮演的角色（医学专家）和任务要求。
  2. 问题：用 {} 占位，后面会被真实的问题替换。
  3. 响应：这里被分成了两部分 <think>...</think> 和最终答案。<think> 标签里的内容是模型“内心的思考过程”，也就是我们想要的思维链（CoT）。最终答案是基于这个思考得出的结论。

为什么要用思维链？这相当于让模型把解题步骤“说”出来。对于复杂推理任务，这能极大提升答案的准确性和可解释性。我们的训练数据就需要包含“问题”、“思考链”和“最终答案”三部分。接下来，我们写一个函数，把原始数据集的每一行，都套用这个模板，拼接成一个完整的训练文本。

EOS_TOKEN = tokenizer.eos_token # 获取结束符，每个训练样本末尾必须加上

def formatting_prompts_func(examples):
    inputs = examples["Question"] # 假设数据集中问题列叫‘Question’
    cots = examples["Complex_CoT"] # 思维链列，假设叫‘Complex_CoT’
    outputs = examples["Response"] # 最终答案列，假设叫‘Response’
    texts = []
    for input, cot, output in zip(inputs, cots, outputs):
        # 将三个部分填入模板的占位符
        text = train_prompt_style.format(input, cot, output) + EOS_TOKEN
        texts.append(text)
    return { "text": texts, }

这个函数的作用就是批量处理数据。EOS_TOKEN（End Of Sequence Token）是模型用来识别句子结束的特殊标记，加上它，模型才知道一句话在哪里结束。

2.2 加载与处理数据集

现在，我们可以加载一个真实的数据集来试试了。这里我们用Hugging Face Datasets库加载一个医疗数据集，并只取前500条做演示（完整训练需要更多数据）。

dataset = load_dataset("FreedomIntelligence/medical-o1-reasoning-SFT", 'zh', split = "train[0:500]", trust_remote_code=True)
print(dataset.column_names) # 查看数据集有哪些列
dataset = dataset.map(formatting_prompts_func, batched=True) # 应用我们的格式化函数
print(dataset["text"][0]) # 打印第一条处理后的数据，看看效果

执行后，你会看到数据集的列名，以及第一条数据被完美地转换成了我们设定的模板格式。map函数是Datasets库的利器，可以高效地对整个数据集进行批处理。batched=True参数能显著提升处理速度。到这里，你的“教材”就准备好了，格式工整，内容充实。接下来，我们要用一种高效且节省资源的方式来“教学”，这就是LoRA微调。

3. LoRA微调原理与参数设置：给模型戴上一个“智能插件”

直接对拥有80亿参数的整个模型进行全量微调，需要巨大的显存和算力，几乎是个人开发者无法承受的。而LoRA（Low-Rank Adaptation，低秩自适应）技术完美地解决了这个问题。它的思想非常巧妙：我们不直接修改模型那庞大的原始参数（好比不重新建造整栋大楼），而是为模型增加一组额外的、非常小的“适配器”参数（好比在大楼外部加装一个轻巧的电梯模块）。训练时，只训练这些新增的适配器参数，冻结原始模型参数。

这样做的好处是巨大的：训练参数量可能只有原来的0.1%甚至更少，训练速度极快，显存占用大幅降低，而且训练出来的适配器可以像插件一样随时加载或卸载，非常灵活。那么，这个“适配器”是怎么设计的呢？它基于一个数学发现：模型在适应新任务时，其参数的变化矩阵（ΔW）往往是“低秩”的。这意味着这个巨大的变化矩阵可以用两个更小矩阵的乘积来近似表示：ΔW = A * B。其中A和B就是我们要训练的LoRA适配器。

现在，我们来看代码中如何具体设置这些LoRA参数，每一个都至关重要。

model = FastLanguageModel.get_peft_model(
    model,
    r=16, # LoRA的秩（rank）
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ], # 目标模块
    lora_alpha=16, # 缩放因子
    lora_dropout=0, # Dropout率
    bias="none", # 偏置项
    use_gradient_checkpointing="unsloth", # 梯度检查点
    random_state=3407, # 随机种子
    use_rslora=False, # 是否使用RSLoRA
    loftq_config=None, # LoftQ配置
)

3.1 核心参数深度解读

r=16（秩）：这是LoRA最重要的超参数之一。它决定了适配器矩阵A和B的大小（A的维度是 [原始维度, r]，B的维度是 [r, 原始维度]）。r 越大，适配器的能力越强，但训练参数也越多，速度越慢，也更容易过拟合。对于DeepSeek-8B这样的模型，r=8, 16, 32 是常见的起点。任务越简单，r 可以越小；任务越复杂，可能需要更大的 r。我建议新手先从16开始尝试，这是一个兼顾效果和效率的甜点值。

target_modules（目标模块）：这个列表指定了我们要把LoRA适配器加到模型的哪些层上。通常我们选择注意力机制（Attention）中的查询（Q）、键（K）、值（V）和输出（O）投影层，以及前馈网络（FFN）中的门控（gate）、上（up）、下（down）投影层。这些层是模型进行信息转换的核心。选择所有这些都是比较通用的做法。如果你知道你的任务更依赖注意力或者更依赖FFN，也可以进行更精细的选择。

lora_alpha=16（缩放因子）：在计算最终参数变化时，公式是：最终变化 = (lora_alpha / r) * (A * B)。lora_alpha 控制着适配器输出对原始模型的调整强度。通常将其设置为与 r 相同的值（如16），或者 r 的两倍（如32）。你可以把它理解为一个“音量旋钮”，alpha 越大，LoRA适配器的影响就越强。

lora_dropout=0 和 bias="none"：为了追求极致的训练速度，在Unsloth中通常将Dropout设为0，bias设为"none"。Dropout原本是为了防止过拟合，但在LoRA这种参数极少的微调中，过拟合风险本身较低，去掉它可以加快训练。bias项对性能提升有限，但会增加参数，去掉它可以进一步减少计算量。如果你的数据集非常小，担心过拟合，可以尝试将 lora_dropout 设为0.05或0.1。

use_gradient_checkpointing="unsloth"（梯度检查点）：这是一个“用时间换空间”的神奇技术。在训练深度网络时，前向传播会产生大量的中间激活值，它们需要被保存下来用于反向传播计算梯度，这非常消耗显存。梯度检查点技术只保存其中一部分关键的激活值（检查点），在反向传播需要时，再根据这些检查点临时重新计算丢失的激活值。这能显著降低显存占用（有时能减少30%以上），代价是增加了约20%的计算时间。对于显存紧张的情况，强烈建议开启。

random_state=3407（随机种子）：设置一个固定的随机种子，可以确保你的实验是可复现的。下次用同样的种子、同样的数据、同样的参数，你会得到几乎一模一样的结果。这对于科研和调试非常重要。

设置好LoRA，我们的模型就装备上了轻量级的“学习插件”。接下来，我们要定义如何训练这个插件，也就是配置训练循环的各项参数。

4. 训练循环配置：把控学习的“节奏与火候”

训练模型就像烹饪，火候、时间、调料（参数）都要恰到好处。这里我们使用 SFTTrainer（监督式微调训练器），它封装了训练循环的复杂细节，让我们能专注于参数配置。

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text", # 我们格式化后数据所在的字段名
    max_seq_length=max_seq_length, # 与加载模型时一致
    dataset_num_proc=2, # 数据预处理进程数

    args=TrainingArguments(
        per_device_train_batch_size=2, # 每个GPU上的批次大小
        gradient_accumulation_steps=4, # 梯度累积步数
        warmup_steps=5, # 预热步数
        max_steps=60, # 最大训练步数（演示用，实际训练应使用epoch）
        # num_train_epochs=1, # 完整训练时应使用这个，并注释掉max_steps
        learning_rate=2e-4, # 学习率
        fp16=not is_bfloat16_supported(), # 半精度训练
        bf16=is_bfloat16_supported(),
        logging_steps=10, # 每10步记录一次日志
        optim="adamw_8bit", # 优化器
        weight_decay=0.01, # 权重衰减
        lr_scheduler_type="linear", # 学习率调度器类型
        seed=3407, # 随机种子
        output_dir="outputs", # 输出目录
    ),
)

4.1 训练参数详解：从批次大小到学习率调度

批次相关参数：

  • per_device_train_batch_size=2：由于模型和显存限制，我们无法一次性将大量数据送入GPU。这个值设定了每个GPU每次前向传播处理的样本数。设为2是一个保守且安全的选择。如果你的显存更大（比如40GB+），可以尝试增加到4或8，能加快训练。
  • gradient_accumulation_steps=4：梯度累积。这是解决“显存小，想用大批次”矛盾的利器。它的原理是：我们依然每次只处理batch_size=2的数据，但连续处理4次（不更新模型权重），把这4次计算得到的梯度累加起来，相当于用了一个 2*4=8 的“有效批次大小”来更新一次模型。这既模拟了大批次训练稳定性的好处，又没有增加单次显存占用。

学习率与优化：

  • learning_rate=2e-4：学习率是训练中最重要的超参数之一。它决定了每次参数更新的步长。步长太大（学习率太高），可能会在最优解附近震荡甚至发散；步长太小（学习率太低），训练会非常缓慢。对于LoRA微调，1e-4 到 5e-4 是一个常见的范围。2e-4 是一个不错的起点。
  • optim="adamw_8bit"：优化器。AdamW是Adam优化器的改进版，加入了权重衰减（Weight Decay）。8bit 指的是使用8位量化版的AdamW优化器，它能用更少的内存存储优化器状态（如动量、方差），对于大模型微调是省内存的必备选项。
  • weight_decay=0.01：权重衰减，一种正则化技术。它通过在损失函数中添加一个惩罚项，防止模型权重变得过大，有助于减轻过拟合。0.01是一个常用的值。

学习率调度：

  • warmup_steps=5：学习率预热。在训练最开始的时候，模型参数是随机的，如果一开始就用较大的学习率，可能会导致训练不稳定。预热策略是在前5步，让学习率从0线性增长到我们设定的 2e-4，让模型“热热身”。
  • lr_scheduler_type="linear"：预热结束后，学习率调度器开始工作。“线性”调度意味着学习率从峰值 2e-4 开始，随着训练步数增加，线性衰减到0。这是一种简单有效的策略。在完整的训练中（使用num_train_epochs），它会在整个训练周期内线性衰减。

其他重要参数：

  • max_steps=60：这是为了演示，我们只训练60步就停止。在实际项目中，你应该注释掉这一行，并使用 num_train_epochs，例如 num_train_epochs=3，让模型完整地在训练数据集上学习3轮。
  • fp16/bf16：混合精度训练。fp16是半精度浮点数，bf16是脑浮点数，范围更大。is_bfloat16_supported() 函数会自动检测你的GPU是否支持bf16（Ampere架构及以上支持）。支持则用bf16，否则用fp16。这能大幅减少显存占用并加快训练速度。
  • logging_steps=10：每训练10步，记录一次日志到控制台（或W&B等工具）。你可以看到损失（loss）的变化，这是监控训练进程最重要的指标。

一切就绪，启动训练的命令简单得令人发指：trainer_stats = trainer.train()。训练开始后，你会看到控制台不断输出日志，显示当前的训练步数、损失值、学习率等。损失值通常会快速下降，然后逐渐趋于平缓。当训练完成后，最重要的一步来了——保存你的劳动成果。

5. 模型保存、推理与效果评估

训练完成后，我们得到了一个适配了特定任务的LoRA适配器。它本身很小（通常只有几十MB），需要和原始的基础模型结合才能使用。保存模型有多种方式，满足不同场景的需求。

new_model_local = "DeepSeek-R1-Medical-COT" # 你给模型起的名字

# 方式1：分别保存LoRA适配器和分词器（轻量，便于分享）
model.save_pretrained(new_model_local)
tokenizer.save_pretrained(new_model_local)

# 方式2：合并保存为16位精度的完整模型（便于部署和推理）
model.save_pretrained_merged(new_model_local, tokenizer, save_method="merged_16bit")

# 方式3：上传到Hugging Face Hub（需要网络权限）
# model.push_to_hub("你的用户名/模型名", token=hf_token)
# tokenizer.push_to_hub("你的用户名/模型名", token=hf_token)

方式1保存的是独立的LoRA权重，非常小巧。当你需要在不同基础模型上切换或分享微调结果时，这种方式很灵活。方式2是我最推荐的，尤其是对于新手。它会将LoRA权重合并到原始基础模型中，并保存成一个完整的、16位精度的新模型文件。这样，你在使用的时候，就像加载任何一个普通的Hugging Face模型一样简单，无需再处理LoRA的加载逻辑。合并后的模型大小和原始基础模型差不多（约16GB）。

保存好模型后，让我们来测试一下微调后的效果。使用和微调前同样的推理代码，但加载我们刚保存的新模型。

# 加载我们微调后合并的模型
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "./DeepSeek-R1-Medical-COT", # 本地路径
    max_seq_length = max_seq_length,
    dtype = dtype,
    load_in_4bit = load_in_4bit,
)

# 准备问题
question = "一个患有急性阑尾炎的病人已经发病5天，腹痛稍有减轻但仍然发热，在体检时发现右下腹有压痛的包块，此时应如何处理？"
FastLanguageModel.for_inference(model)
inputs = tokenizer([train_prompt_style.format(question, "")], return_tensors="pt").to("cuda")

# 生成回答
outputs = model.generate(
    **inputs,
    max_new_tokens=1200,
    use_cache=True,
)
response = tokenizer.batch_decode(outputs)
print("微调后模型回答：", response[0].split("### Response:")[1])

对比微调前后的回答，你应该能看到明显的区别。微调前的模型可能只会给出笼统的“建议就医”之类的回答。而微调后的模型，由于其学习了医疗数据中的思维链和专业知识，更有可能生成包含“考虑阑尾周围脓肿形成”、“建议行腹部CT检查明确包块性质”、“可能需进行经皮穿刺引流或手术引流”等具体、专业的分析。这就是微调的力量——让通用的模型，拥有了垂直领域的“灵魂”。

在整个过程中，你可能会遇到各种问题，比如显存不足（OOM）、训练损失不下降、或者模型输出乱码。显存不足通常需要减小batch_size、增大gradient_accumulation_steps、或者开启gradient_checkpointing。损失不下降可能是学习率不合适、数据质量有问题，或者任务对于当前LoRA配置（如r值太小）来说太难。多尝试，多调整，观察日志，你就能慢慢找到感觉。微调大模型不再是大型实验室的专利，它已经成为了每个有好奇心的开发者都能触及的技术。拿起你的显卡，准备好你的数据，开始创造属于你的智能体吧。

# LoRA
Logo
亚马逊云科技技术品牌专区

更多推荐

cover

大 硬 仗14小时：用2009年的上古亮机卡跑完深度学习，CPU满载但代码没崩

avatar 亚马逊云科技技术品牌专区
cover

原来AI、画图、导航都在用向量！

avatar 亚马逊云科技技术品牌专区
cover

害虫检测和识别3：基于深度学习YOLO26神经网络实现害虫检测和识别(含训练代码、数据集和GUI交互界面）

avatar 亚马逊云科技技术品牌专区