千问大模型二次LoRA‑SFT指令微调指南

大模型微调是实现模型领域定制的核心方案。本文基于 Ubuntu 22.04 服务器环境，依托 NVIDIA RTX 家用高性能显卡，选用千问 Qwen3.5‑0.8B‑Instruct 指令模型，完整演示二次 LoRA‑SFT 微调全流程，包含环境搭建、模型选型、ChatML 数据集制作校验、LoRA 参数配置、SFT 训练、效果验证、权重合并，附带可直接运行的工程脚本，便于开发者快速实现千问模型轻量化定制与上线部署。

在开展Qwen模型微调实操前，需提前配置好服务器软硬件运行环境，本文所有实操流程均基于以下稳定运行的本机环境，读者可直接参考对齐配置，适配复现：

• 操作系统：Ubuntu 22.04.5 LTS (GNU/Linux 5.15.0-187-generic x86_64)
• 框架版本：torch 2.13.0 + CUDA 12.8.1 + Python 3.10.12
• 显卡驱动：NVIDIA ≥ 570.133.07
• 显卡类型：NVIDIA RTX 4090 24GB GPU
• CPU核心：INTEL(R) XEON(R) GOLD 6530
• 内存：64GB DDR5
• 存储：50GB(系统盘)+100GB(数据盘)

基础知识

两种训练

大模型行业落地场景中，通用预训练模型难以适配垂直领域专属知识、定制化对话风格与专属业务指令需求，模型微调成为轻量化、低成本实现模型能力定制的核心手段。

模型的微调训练包含两种主流模式：

• 第一种：基于Base预训练基座模型开展从零SFT微调，该类模型仅完成通用预训练，无官方指令对齐能力，无法原生理解对话指令，需人工构建对话格式、手动拼接对话文本及监督数据集，从零学习指令跟随与对话能力，多用于全新模型定制与二次预训练任务，该模式消耗算力大，一般不会使用此方式微调。

• 第二种：指令模型二次 LoRA‑SFT 微调，也是本文的核心内容，千问 Instruct 指令模型由 Base 基座经过官方 SFT 监督微调、DPO/RLHF 偏好对齐得到，原生具备指令理解与多轮对话能力。在此成熟对齐模型基础上开展二次 LoRA‑SFT 微调，可在保留模型通用知识与基础对话能力的前提下，低成本注入领域专属能力或知识，规避基座从零训练的数据门槛与对齐成本，是工程落地与轻量化模型定制的最优方案。

进行微调前需要判别模型底座，模型名称带有‑Base后缀的为预训练裸基座；模型目录中包含chat_template.jinja文件，则说明是 Instruct 指令模型，该类模型已经完成 SFT、DPO、RLHF 等指令对齐流程。现实中原始预训练基模较少对外开源，公开可获取的大多是经过完整后训练的成品权重。

LoRA/QLoRA

LoRA 与 QLoRA 是目前主流的参数高效微调方法。LoRA 通过冻结主干模型，仅训练注意力层的低秩适配器，在几乎不损失模型性能的前提下降低训练参数量，适合显存条件较好的硬件环境。QLoRA 在 LoRA 基础上引入 4/8 比特权重量化，将主干模型以量化形式加载，以此来压缩显存占用，使大模型微调可以在消费级显卡上完成，但会引入少量量化噪声，可能对最终效果带来轻微影响。

项目	LoRA	QLoRA
核心机制	低秩适配器	低秩适配器 + INT4/INT8 权重量化
模型主干精度	FP16/BF16	INT4/INT8 量化冻结
显存消耗	较低	更低
精度损失	几乎无	存在轻微量化损失
工程复杂度	低，稳定通用	较高，存在量化适配问题
适用场景	显存条件较好，8B‑14B，追求微调效果	显存受限，超大模型 (27B+)，消费级显卡

LoRA 与 QLoRA 的选择主要依据硬件设备显存条件确定。对于 8B 规模模型，当显卡显存大于 24GB 时，优先采用 LoRA 微调；针对 14B、27B 等更大规模模型或显存资源受限场景，则选用 QLoRA 并开启 4 比特量化加载以降低显存压力。本文选用体量较小的 Qwen3.5‑0.8B‑Instruct 作为实验对象，模型参数量小，便于流程演示，因此直接采用 LoRA 开展二次 SFT 指令微调。

• 完整实验链路为：环境准备 → 数据集准备(train.json) → 加载基座模型(Qwen3.5‑0.8B‑Instruct) → LoRA 参数配置 → SFTTrainer 执行微调训练 → 本地推理效果验证 → LoRA 适配器与主模型权重合并导出

微调实验

环境安装

1、创建独立 Python 虚拟环境，隔离项目依赖，避免和系统 Python 包冲突。

root@localhost:~/# sudo apt install -y python3-full python3-venv tmux git tree
root@localhost:~/# sudo python3 -m venv ~/myvenv
root@localhost:~/# source ~/myvenv/bin/activate

2、激活进入虚拟环境，使用腾讯云镜像源加速深度学习、微调相关全套依赖包。

root@localhost:~/# pip3 install -i https://mirrors.cloud.tencent.com/pypi/simple/ torch torchvision trl datasets peft accelerate bitsandbytes wandb transformers sentencepiece huggingface_hub protobuf modelscope
root@localhost:~/# pip3 list
Package                Version
---------------------- ------------
accelerate             1.14.0
aiohappyeyeballs       2.7.1
aiohttp                3.14.3
aiosignal              1.4.0
annotated-doc          0.0.5
annotated-types        0.8.0
anyio                  4.15.1
async-timeout          5.0.1
attrs                  26.1.0
bitsandbytes           0.50.2
certifi                2026.7.22
charset-normalizer     3.5.1
click                  8.5.0
cuda-bindings          13.3.1
cuda-pathfinder        1.8.1
cuda-toolkit           13.0.3.0
datasets               5.0.1
dill                   0.4.1
exceptiongroup         1.3.1
filelock               3.32.5
frozenlist             1.8.0
fsspec                 2026.6.0
h11                    0.16.0
hf-xet                 1.6.0
httpcore               1.0.9
httpx                  0.28.1
huggingface_hub        1.30.0
idna                   3.19
Jinja2                 3.1.6
markdown-it-py         4.2.0
MarkupSafe             3.0.3
mdurl                  0.1.2
mpmath                 1.3.0
multidict              6.7.1
multiprocess           0.70.19
networkx               3.4.2
numpy                  2.2.6
nvidia-cublas          13.1.1.3
nvidia-cuda-cupti      13.0.85
nvidia-cuda-nvrtc      13.0.88
nvidia-cuda-runtime    13.0.96
nvidia-cudnn-cu13      9.24.0.43
nvidia-cufft           12.0.0.61
nvidia-cufile          1.15.1.6
nvidia-curand          10.4.0.35
nvidia-cusolver        12.0.4.66
nvidia-cusparse        12.6.3.3
nvidia-cusparselt-cu13 0.8.1
nvidia-nccl-cu13       2.30.7
nvidia-nvjitlink       13.3.33
nvidia-nvshmem-cu13    3.4.5
nvidia-nvtx            13.0.85
opentelemetry-api      1.44.0
packaging              26.3
pandas                 2.3.3
peft                   0.20.0
pillow                 12.3.0
pip                    22.0.2
platformdirs           4.11.7
propcache              0.5.2
protobuf               7.36.1
psutil                 7.2.2
pyarrow                25.0.1
pydantic               2.13.5
pydantic_core          2.46.5
Pygments               2.21.0
python-dateutil        2.9.0.post0
pytz                   2026.3.post1
PyYAML                 6.0.3
regex                  2026.9.3
requests               2.34.2
rich                   15.0.0
safetensors            0.8.0
sentry-sdk             2.68.1
setuptools             84.0.0
shellingham            1.5.4
six                    1.17.0
sympy                  1.14.0
tokenizers             0.23.2
torch                  2.14.0
torchaudio             2.11.0
torchvision            0.29.0
tqdm                   4.70.0
transformers           5.16.1
triton                 3.8.0
trl                    1.12.0
typer                  0.27.2
typing_extensions      4.16.0
typing-inspection      0.4.4
tzdata                 2026.3
urllib3                2.7.0
wandb                  0.29.0
xxhash                 4.0.1
yarl                   1.24.5

下载底座模型

使用 modelscope 下载 Qwen/Qwen3.5‑0.8B‑Instruct 已经预 SFT 完成的底座模型，该模型原生支持 ChatML 对话模板，不需要自己修改 tokenizer，适合直接二次 LoRA 微调；不要手动复制网页，使用 modelscope 下载保证文件完整，避免文件缺失导致训练报错。

https://www.modelscope.cn/models/icyfenix/Qwen3.5-0.8B-Instruct

root@localhost:~/# mkdir data
root@localhost:~/# cd data
root@localhost:~/# modelscope download --model icyfenix/Qwen3.5-0.8B-Instruct --local_dir ./qwen3.5‑0.8B‑Instruct

准备 SFT 微调数据集

采用 Qwen 标准 ChatML 格式，json 数组格式，每一条样本包含conversation数组，数组内是多轮对话，角色仅允许system/user/assistant，文件保存到/root/data/train.json中。

此处为小样本演示数据集，适合跑通流程；真实业务建议扩充到几百～几千条，太少容易过拟合。

[
    {
        "conversation": [
            {"role":"user","content":"什么是大模型LoRA微调？"},
            {"role":"assistant","content":"LoRA是一种轻量微调技术，冻结大模型主干权重，只训练少量低秩矩阵，不需要全量更新模型参数，显存消耗低，训练速度快，产出的LoRA适配器体积很小，可以挂载在基础模型上使用。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"LoRA和QLoRA有什么区别？"},
            {"role":"assistant","content":"LoRA主干模型使用FP16/BF16精度加载，主干不量化；QLoRA把主干模型4bit量化，进一步降低显存开销，会带来微小的精度损失。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"SFT监督微调是什么？"},
            {"role":"assistant","content":"SFT即监督微调，使用高质量问答对话数据集，让大模型学习期望的输出格式、回答风格、领域知识，是对齐大模型的基础步骤。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"微调为什么会出现灾难性遗忘？"},
            {"role":"assistant","content":"当训练数据集单一，模型过度学习新数据，丢失原本基础能力，就会发生灾难性遗忘。解决办法是混入通用对话数据，控制训练步数，避免过拟合。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"PEFT是什么？"},
            {"role":"assistant","content":"PEFT是HuggingFace的参数高效微调库，包含LoRA、IA3等多种算法，只训练一小部分参数，不用完整保存整个大模型。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"如何判断微调过拟合？"},
            {"role":"assistant","content":"观察eval验证loss，loss不再下降甚至上升；模型在训练集问题回答很好，陌生问题表现很差；输出重复、背诵训练集内容，就是过拟合。可以减少训练步数，增大数据集多样性。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"vLLM可以直接加载LoRA适配器吗？"},
            {"role":"assistant","content":"原生PEFT标准LoRA适配器，新版vLLM支持直接加载，不需要手动合并权重；Unsloth的bnb‑4bit的LoRA不能直接加载，必须合并导出完整权重。"}
        ]
    },
    {
        "conversation": [
            {"role":"system","content":"你是大模型微调助手，回答简洁专业"},
            {"role":"user","content":"微调需要多少样本？"},
            {"role":"assistant","content":"风格迁移：200‑1000条；垂直领域知识增强：2000‑10000条；样本过少极易过拟合。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"训练的时候max_steps和epoch选哪个？"},
            {"role":"assistant","content":"小数据集优先max_steps，防止epoch重复训练造成过拟合；大数据集可以使用num_train_epochs，一般1‑3轮。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"LoRA的r参数代表什么？"},
            {"role":"assistant","content":"r是LoRA秩，r越大可训练参数量越大；常用8、16、32；r太小表达能力不足，r太大容易过拟合。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"梯度累积的作用是什么？"},
            {"role":"assistant","content":"显存不足调小batch_size，通过gradient_accumulation_steps做梯度累积，模拟更大的batch，不增加显存占用。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"bf16和fp16区别？"},
            {"role":"assistant","content":"bf16指数范围更大，适合大模型训练；30系及以上显卡支持bf16；20系及更早显卡只能用fp16。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"微调数据集一定要用apply_chat_template吗？"},
            {"role":"assistant","content":"强烈建议使用，不要手动拼接<|im_start|>标签，手动拼接极易格式错误，直接导致训练失效。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"训练完怎么推理？"},
            {"role":"assistant","content":"两种方式：1、peft.PeftModel加载基础模型+LoRA适配器；2、合并LoRA权重得到完整模型；也可以vLLM直接加载LoRA做API服务。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"为什么要划分验证集？"},
            {"role":"assistant","content":"验证集没有参与训练，用来监控过拟合，脚本中load_best_model_at_end会自动保存验证loss最优的LoRA权重。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"什么是packing在SFTTrainer？"},
            {"role":"assistant","content":"packing=True会把多个短样本拼接在一起提升效率；样本长度参差不齐时建议关闭packing=False。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"学习率LoRA一般设置多大？"},
            {"role":"assistant","content":"标准LoRA常用1e‑4 ~3e‑4，不要设置过大，容易震荡发散。"}
        ]
    },
    {
        "conversation": [
            {"role":"system","content":"你是大模型微调助手"},
            {"role":"user","content":"训练loss下降就代表微调成功吗？"},
            {"role":"assistant","content":"不是。loss下降只代表拟合训练数据，必须在真实问题上做人工评测，同时看验证集loss，防止过拟合。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"可以直接拿网上开源数据集直接训练吗？"},
            {"role":"assistant","content":"可以，但要检查字段格式，转换为Qwen ChatML，过滤脏数据，最好混入通用对话数据，避免遗忘基础能力。"}
        ]
    },
    {
        "conversation": [
            {"role":"user","content":"微调之后模型会永久改变吗？"},
            {"role":"assistant","content":"LoRA只是附加适配器，基础模型文件不会改动；推理时加载LoRA才生效，移除LoRA就恢复原始基础模型。"}
        ]
    }
]

数据集校验

数据集校验脚本，提前拦截 JSON 语法错误、字段缺失、非法 role 角色；同时调用分词器apply_chat_template渲染对话，检查 ChatML 标签<|im_start|>/<|im_end|>输出是否正常。

很多训练失败根源是数据集格式错误，训练前必须运行该脚本，全部校验通过再进入训练。

import json
from transformers import AutoTokenizer

JSON_PATH = r"/root/data/train.json"
MODEL_NAME = r"/root/data/qwen3.5-0.8B-Instruct"

if __name__ == "__main__":
    try:
        with open(JSON_PATH, "r", encoding="utf‑8") as f:
            data = json.load(f)
    except Exception as e:
        print(f"[-] JSON解析失败：{e}")
        exit(1)

    if not isinstance(data, list):
        print("[-] 数据集最外层必须是数组")
        exit(1)

    print(f"[+] JSON读取成功，总样本数：{len(data)}")

    # 加载分词器
    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
    print(f"[+] 成功加载分词器 {MODEL_NAME}")
    valid_roles = {"user", "assistant", "system"}
    error_count = 0

    for idx, item in enumerate(data):
        if "conversation" not in item:
            print(f"\n[-] 第{idx}条：缺少 conversation 字段")
            error_count += 1
            continue

        conv = item["conversation"]
        if not isinstance(conv, list):
            print(f"\n[-] 第{idx}条：conversation必须是数组")
            error_count += 1
            continue

        for turn_idx, turn in enumerate(conv):
            if "role" not in turn or "content" not in turn:
                print(f"\n[-] 第{idx}条‑第{turn_idx}轮：缺少role或content")
                error_count += 1
                continue
            r = turn["role"]
            if r not in valid_roles:
                print(f"\n[-] 第{idx}条‑第{turn_idx}轮：非法role={r}，允许：{valid_roles}")
                error_count += 1

    print(f"\n---------------------------")
    if error_count > 0:
        print(f"[!] 检测到 {error_count} 处错误，请修改后再训练！")
        exit(1)
    else:
        print("[+] 所有样本字段格式校验通过！")

    # 渲染ChatML看标签是否正确
    print("\n===== 抽样渲染前2条看ChatML输出 =====")
    for i in range(min(2, len(data))):
        conv = data[i]["conversation"]
        text = tokenizer.apply_chat_template(
            conv, tokenize=False, add_generation_prompt=False
        )
        print(f"\n--------样本{i}--------")
        print(text[:600])

        if "<|im_start|>" not in text:
            print("[!] 警告：输出没有 <|im_start|>，模板异常！")

    print("\n[+] 校验完成，可以送入训练脚本。")

检查通过后可看到如下所示输出内容：

root@localhost:~/data# python check.py 
[+] JSON读取成功，总样本数：20
[+] 成功加载分词器 ./qwen3.5-0.8B-Instruct
---------------------------
[+] 所有样本字段格式校验通过！

===== 抽样渲染前2条看ChatML输出 =====

--------样本0--------
<|im_start|>user
什么是大模型LoRA微调？<|im_end|>
<|im_start|>assistant
<think>
</think>

LoRA是一种轻量微调技术，冻结大模型主干权重，只训练少量低秩矩阵，不需要全量更新模型参数，显存消耗低，训练速度快，产出的LoRA适配器体积很小，可以挂载在基础模型上使用。<|im_end|>

--------样本1--------
<|im_start|>user
LoRA和QLoRA有什么区别？<|im_end|>
<|im_start|>assistant
<think>
</think>

LoRA主干模型使用FP16/BF16精度加载，主干不量化；QLoRA把主干模型4bit量化，进一步降低显存开销，会带来微小的精度损失。<|im_end|>

[+] 校验完成，可以送入训练脚本。

分词器加载与验证脚本

验证底座模型分词器加载是否正常，查看特殊 token（<|im_start|>、<|im_end|>、eos/pad token）ID，验证编码解码、对话模板输出。很多训练 loss 爆炸、生成乱码来自分词器配置错误；Qwen 系列需要把pad_token设置等于eos_token，padding_side=right。

from datasets import load_dataset, concatenate_datasets
from transformers import AutoTokenizer,set_seed

SEED = 42
set_seed(SEED)
MODEL_NAME = r"/root/data/qwen3.5-0.8B-Instruct"

if __name__ == "__main__":
    # 加载分词器
    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
    tokenizer.pad_token = tokenizer.eos_token
    tokenizer.padding_side = "right"

    print("[+] 成功加载分词器", MODEL_NAME)
    print(f"分词器类名: {type(tokenizer).__name__}")
    print(f"vocab_size: {tokenizer.vocab_size}")
    print(f"model_max_length: {tokenizer.model_max_length}")
    print(f"padding_side: {tokenizer.padding_side}")
    print(f"truncation_side: {tokenizer.truncation_side}")

    print("\n---------- 全部特殊token及ID ----------")
    special_tokens = [
        ("bos_token", tokenizer.bos_token, tokenizer.bos_token_id),
        ("eos_token", tokenizer.eos_token, tokenizer.eos_token_id),
        ("pad_token", tokenizer.pad_token, tokenizer.pad_token_id),
        ("unk_token", tokenizer.unk_token, tokenizer.unk_token_id),
        ("im_start token", "<|im_start|>", tokenizer.convert_tokens_to_ids("<|im_start|>")),
        ("im_end token", "<|im_end|>", tokenizer.convert_tokens_to_ids("<|im_end|>")),
    ]
    for name, tok, tid in special_tokens:
        print(f"{name:<15} token={repr(tok):<22} id={tid}")

    print("\n---------- special_tokens_map ----------")
    print(tokenizer.special_tokens_map)

    #print("\n---------- init_kwargs 初始化参数 ----------")
    #print(tokenizer.init_kwargs)

    print("\n---------- 词表前30个样例 ----------")
    vocab = list(tokenizer.get_vocab().items())[:30]
    for token_str, token_id in vocab:
        print(f"{token_id:6d} | {repr(token_str)}")

    print("\n---------- 简单编码解码测试 ----------")
    test_sentence = "你好，Qwen大模型！"
    encode_out = tokenizer(test_sentence)
    print(f"原文：{test_sentence}")
    print(f"input_ids：{encode_out['input_ids']}")
    print(f"还原：{tokenizer.decode(encode_out['input_ids'])}")

    print("\n---------- apply_chat_template对话模板测试 ----------")
    messages = [
        {"role":"system","content":"你是助手"},
        {"role":"user","content":"你好"}
    ]
    chat_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    print("chat template输出文本：")
    print(repr(chat_text))

检查通过后可看到如下所示输出内容：

重点检查：pad_token不为 None，padding_side=right，apply_chat_template输出包含正确 im 标签。

root@localhost:~/data# python check.py 
[+] 成功加载分词器

分词器类名: Qwen2Tokenizer
vocab_size: 248044
model_max_length: 262144
padding_side: right
truncation_side: right

---------- 全部特殊token及ID ----------
bos_token       token=None                   id=None
eos_token       token='<|im_end|>'           id=248046
pad_token       token='<|im_end|>'           id=248046
unk_token       token=None                   id=None
im_start token  token='<|im_start|>'         id=248045
im_end token    token='<|im_end|>'           id=248046

---------- special_tokens_map ----------
{'eos_token': '<|im_end|>', 'pad_token': '<|im_end|>', 'audio_bos_token': '<|audio_start|>', 'audio_eos_token': '<|audio_end|>', 'audio_token': '<|audio_pad|>', 'image_token': '<|image_pad|>', 'video_token': '<|video_pad|>', 'visi
on_bos_token': '<|vision_start|>', 'vision_eos_token': '<|vision_end|>'}

---------- 词表前30个样例 ----------
222609 | 'ãģ¨æĢĿãģ£ãģŁãĤī'
150945 | 'ĠдÑĥ'
101644 | 'ä¹Łå°±æĺ¯'
 38671 | 'Ġcurse'
173593 | 'назна'
126060 | 'åīįä¸įä¹ħ'
164288 | 'hão'
136874 | 'éĢĢä¼ij人åijĺ'
125605 | 'ä¸ĢäºĽå°ı'
148886 | 'ள'
228510 | 'Ġentregue'
184351 | 'Ġinklus'
167525 | 'ĠاÙĦÙħصÙĨ'
176754 | 'Ġtratamento'
 57152 | 'calar'
187517 | 'ÑģнÑĥ'
  3978 | 'ĠOff'
 42853 | 'Ġrecruited'
170936 | 'Ġbiá»ĥn'
  6770 | 'ometry'
201897 | 'Ġmaintenir'
 21855 | 'ĠSure'
144957 | 'åĩĨèĢĥè¯ģæīĵåį°'
 66583 | '(seg'
 81516 | 'ulado'
125493 | '空空'
   832 | 'arg'
146557 | 'èı²èı²'
173079 | 'ĠTÆ°'
 83695 | 'ĉJson'

---------- 简单编码解码测试 ----------
原文：你好，Qwen大模型！
input_ids：[109266, 3709, 48, 16451, 95779, 103725, 6115]
还原：你好，Qwen大模型！

---------- apply_chat_template对话模板测试 ----------
chat template输出文本：
'<|im_start|>system\n你是助手<|im_end|>\n<|im_start|>user\n你好<|im_end|>\n<|im_start|>assistant\n<think>\n\n</think>\n\n'

LoRA‑SFT 训练脚本

加载本地 Qwen3.5‑0.8B‑Instruct 基座模型，冻结主干，使用 LoRA 做轻量化微调；读取本地 json 对话数据集，经过 chat 模板格式化、分词、过滤、划分训练验证集；使用 Trainer 执行 step 式训练，保存 LoRA 适配器，最后加载 LoRA 做简单推理验证。

import os
import torch
from datasets import load_dataset
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    TrainingArguments,
    set_seed,
    DataCollatorForLanguageModeling,
    Trainer
)
from peft import PeftModel, LoraConfig, get_peft_model
import warnings

warnings.filterwarnings("ignore")

SEED = 42
set_seed(SEED)

# 配置路径
LOCAL_JSON_PATH = r"/root/data/train.json"
MODEL_NAME = r"/root/data/qwen3.5-0.8B-Instruct"
OUTPUT_DIR = r"/root/data/qwen_lora"

MAX_SEQ_LENGTH = 8192

# LoRA超参
LORA_R = 16
LORA_ALPHA = 16
LORA_DROPOUT = 0.0

# RTX4090‑24G 8192上下文 调参
BATCH_SIZE_PER_DEVICE = 2
GRADIENT_ACCUMULATION_STEPS = 4
MAX_STEPS = 40
LEARNING_RATE = 1e-4
WARMUP_STEPS = 10

# 显存优化
GRADIENT_CHECKPOINTING = True

# 4090+torch2.13优先bfloat16 比fp16更稳
USE_BF16 = True

def format_conversation(sample):
    conv = sample["conversation"]
    text = tokenizer.apply_chat_template(
        conv,
        tokenize=False,
        add_generation_prompt=False
    )
    return {"text": text}

def tokenize_fn(sample):
    out = tokenizer(
        sample["text"],
        truncation=True,
        max_length=MAX_SEQ_LENGTH,
    )
    return out

def filter_long_sample(sample):
    return len(sample["input_ids"]) < MAX_SEQ_LENGTH

if __name__ == "__main__":
    print(f"PyTorch version: {torch.__version__}")
    print(f"CUDA available: {torch.cuda.is_available()}")
    print(f"CUDA version: {torch.version.cuda}")
    print(f"GPU count: {torch.cuda.device_count()}")
    if torch.cuda.is_available():
        print(f"GPU Name: {torch.cuda.get_device_name(0)}")
    print(f"Use bf16: {USE_BF16}")

    # 路径校验
    print(f"\n[CHECK] MODEL_NAME={MODEL_NAME}")
    if not os.path.isdir(MODEL_NAME):
        raise FileNotFoundError(f"模型文件夹不存在：{MODEL_NAME}，检查真实路径！")
    if not os.path.exists(os.path.join(MODEL_NAME, "config.json")):
        raise FileNotFoundError(f"{MODEL_NAME} 缺少config.json，不是完整模型目录")
    print("[CHECK] 模型目录校验通过")

    if not os.path.exists(LOCAL_JSON_PATH):
        raise FileNotFoundError(f"数据集文件不存在：{LOCAL_JSON_PATH}")
    print("[CHECK] 数据集文件校验通过\n")

    # 加载分词器
    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token
    tokenizer.padding_side = "right"
    print("[+] 成功加载分词器", MODEL_NAME)

    # 加载模型 单卡强制0号卡
    model = AutoModelForCausalLM.from_pretrained(
        MODEL_NAME,
        dtype=torch.bfloat16 if USE_BF16 else torch.float16,
        device_map={"": 0},
        trust_remote_code=True,
    )
    for param in model.parameters():
        param.requires_grad = False
    print("[+] 主干模型加载完成 已冻结")

    if GRADIENT_CHECKPOINTING:
        model.gradient_checkpointing_enable()
        model.enable_input_require_grads()
        model.config.use_cache = False
        print("[+] 开启梯度检查点 显存优化")

    # LoRA配置
    lora_config = LoraConfig(
        r=LORA_R,
        lora_alpha=LORA_ALPHA,
        target_modules=[
            "q_proj", "k_proj", "v_proj", "o_proj",
            "gate_proj", "up_proj", "down_proj"
        ],
        lora_dropout=LORA_DROPOUT,
        bias="none",
        task_type="CAUSAL_LM",
    )
    model = get_peft_model(model, lora_config)
    model.print_trainable_parameters()

    # 数据集加载
    raw_ds = load_dataset("json", data_files=LOCAL_JSON_PATH, split="train")
    print(f"原始数据集样本数量: {len(raw_ds)}")

    raw_ds = raw_ds.map(format_conversation, num_proc=8)
    raw_ds = raw_ds.map(tokenize_fn, num_proc=8)
    raw_ds = raw_ds.filter(filter_long_sample)
    raw_ds = raw_ds.select_columns(["input_ids", "attention_mask"])
    raw_ds = raw_ds.shuffle(seed=SEED)

    split_ds = raw_ds.train_test_split(test_size=0.05, seed=SEED)
    train_ds = split_ds["train"]
    eval_ds = split_ds["test"]
    print(f"train:{len(train_ds)}, eval:{len(eval_ds)}")
    print("数据集字段：", train_ds.column_names)

    data_collator = DataCollatorForLanguageModeling(
        tokenizer=tokenizer,
        mlm=False
    )

    training_args = TrainingArguments(
        output_dir=OUTPUT_DIR,
        per_device_train_batch_size=BATCH_SIZE_PER_DEVICE,
        per_device_eval_batch_size=1,
        gradient_accumulation_steps=GRADIENT_ACCUMULATION_STEPS,
        warmup_steps=WARMUP_STEPS,
        max_steps=MAX_STEPS,
        learning_rate=LEARNING_RATE,
        bf16=USE_BF16,
        fp16=not USE_BF16,
        logging_steps=5,
        optim="adamw_torch",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=SEED,
        report_to="none",
        eval_strategy="steps",
        eval_steps=20,
        save_strategy="steps",
        save_steps=20,
        save_total_limit=3,
        load_best_model_at_end=True,
        prediction_loss_only=True,
        push_to_hub=False,
        save_only_model=True,
    )

    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=train_ds,
        eval_dataset=eval_ds,
        data_collator=data_collator,
    )

    print("[+] 开始训练......")
    trainer.train()

    trainer.save_model(OUTPUT_DIR)
    tokenizer.save_pretrained(OUTPUT_DIR)
    print(f"训练完成，LoRA适配器输出路径：{OUTPUT_DIR}")

    # 推理验证测试
    base_model = AutoModelForCausalLM.from_pretrained(
        MODEL_NAME,
        dtype=torch.bfloat16,
        device_map={"": 0},
        trust_remote_code=True
    )
    lora_model = PeftModel.from_pretrained(base_model, OUTPUT_DIR)
    messages = [{"role":"user", "content":"你好"}]
    prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
    outputs = lora_model.generate(**inputs, max_new_tokens=100)
    print(tokenizer.decode(outputs[0], skip_special_tokens=True))

训练结束输出产物：/root/data/qwen_lora，里面是 LoRA 适配器，体积很小（几十 MB）不是完整模型；包含adapter_model.safetensors、adapter_config.json以及 checkpoint 中间快照。

root@localhost:~/data# python qwen_lora.py
PyTorch version: 2.6.0+cu124
CUDA available: True
CUDA version: 12.4
GPU count: 1
GPU Name: NVIDIA GeForce RTX 4090
Use bf16: True

[CHECK] MODEL_NAME=/root/data/qwen3.5-0.8B-Instruct
[CHECK] 模型目录校验通过
[CHECK] 数据集文件校验通过

[+] 成功加载分词器 /root/data/qwen3.5-0.8B-Instruct
Loading weights: 100%|█████████████████████████████████████████| 320/320 [00:00<00:00, 1021.22it/s]
[+] 主干模型加载完成，已冻结
[+] 开启梯度检查点，显存优化
trainable params: 6,389,760 || all params: 758,782,784 || trainable%: 0.8421
原始数据集样本数量: 20
train:19, eval:1
数据集字段： ['input_ids', 'attention_mask']
[+] 开始训练......
{'loss': '3.747', 'grad_norm': '4.377', 'learning_rate': '4e-05', 'epoch': '1.8'}                                                                                                    
{'loss': '3.275', 'grad_norm': '2.973', 'learning_rate': '9e-05', 'epoch': '3.4'}                                                                                                    
{'loss': '2.823', 'grad_norm': '2.982', 'learning_rate': '8.667e-05', 'epoch': '5'}                                                                                                  
{'loss': '2.292', 'grad_norm': '2.099', 'learning_rate': '7e-05', 'epoch': '6.8'}                                                                                                    
{'eval_loss': '2.52', 'eval_runtime': '0.1862', 'eval_samples_per_second': '5.371', 'eval_steps_per_second': '5.371', 'epoch': '6.8'}                                                
{'loss': '2.01', 'grad_norm': '2.022', 'learning_rate': '5.333e-05', 'epoch': '8.4'}                                                                                                 
{'loss': '1.762', 'grad_norm': '3.386', 'learning_rate': '3.667e-05', 'epoch': '10'}                                                                                                 
{'loss': '1.535', 'grad_norm': '2.145', 'learning_rate': '2e-05', 'epoch': '11.8'}                                                                                                   
{'loss': '1.426', 'grad_norm': '2.224', 'learning_rate': '3.333e-06', 'epoch': '13.4'}                                                                                               
{'eval_loss': '2.717', 'eval_runtime': '0.1921', 'eval_samples_per_second': '5.204', 'eval_steps_per_second': '5.204', 'epoch': '13.4'}                                              
{'train_runtime': '144.7', 'train_samples_per_second': '2.211', 'train_steps_per_second': '0.276', 'train_loss': '2.359', 'epoch': '13.4'}                                           
100%|███████████████████████████████████████████████████| 40/40 [02:24<00:00,  3.62s/it]
训练完成，LoRA适配器输出路径：/root/data/qwen_lora
=====推理验证=====
Loading weights: 100%|██████████████████████████████████| 320/320 [00:00<00:00, 1011.21it/s]
user
你好
assistant
<think>
</think>

你好！有什么我可以帮你的吗？

root@localhost:~/data# cd qwen_lora/
root@localhost:~/data/qwen_lora# ll
total 44556
drwxr-xr-x 4 root root     4096 Sep  5 23:33 ./
drwxr-xr-x 5 root root      189 Sep  5 23:25 ../
-rw-r--r-- 1 root root     5218 Sep  5 23:33 README.md
-rw-r--r-- 1 root root     1164 Sep  5 23:33 adapter_config.json
-rw------- 1 root root 25584224 Sep  5 23:33 adapter_model.safetensors
-rw-r--r-- 1 root root     7755 Sep  5 23:33 chat_template.jinja
drwxr-xr-x 2 root root     4096 Sep  5 23:31 checkpoint-20/
drwxr-xr-x 2 root root     4096 Sep  5 23:33 checkpoint-40/
-rw-r--r-- 1 root root 19989325 Sep  5 23:33 tokenizer.json
-rw-r--r-- 1 root root     1124 Sep  5 23:33 tokenizer_config.json
-rw-r--r-- 1 root root     4792 Sep  5 23:33 training_args.bin

适配器合并完整权重

LoRA 适配器不能直接用于 llama.cpp、GGUF 导出；需要把 LoRA 权重合并进底座模型权重，输出完整 HF 格式模型。

脚本merge_lora.py将 LoRA 低秩矩阵和基础模型权重矩阵做矩阵相加，输出完整独立模型，不再依赖 peft 库；合并后可以直接 vLLM 推理，也可以转 GGUF。

import torch
from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

BASE_MODEL_PATH = r"/root/data/qwen3.5-0.8B-Instruct"
LORA_PATH = r"/root/data/qwen_lora"
MERGED_OUT = r"/root/data/qwen3.5-0.8B-lora-merged"

print("加载基础模型...")
base = AutoModelForCausalLM.from_pretrained(
    BASE_MODEL_PATH,
    dtype=torch.bfloat16,
    device_map={"": 0},
    trust_remote_code=True
)

print("加载LoRA适配器并合并...")
model = PeftModel.from_pretrained(base, LORA_PATH)
merged_model = model.merge_and_unload()

print("保存合并后的完整模型")
merged_model.save_pretrained(MERGED_OUT, safe_serialization=True)

tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL_PATH, trust_remote_code=True)
tokenizer.save_pretrained(MERGED_OUT)

print(f"合并完成，输出目录：{MERGED_OUT}")

输出目录/root/data/qwen3.5‑0.8B‑lora‑merged

root@localhost:~/data# python lora‑merged.py 
加载基础模型...
Loading weights: 100%|█████████████████████████████████████████████████| 320/320 [00:00<00:00, 918.63it/s]
加载LoRA适配器并合并...
保存合并后的完整模型
Writing model shards: 100%|██████████████████████████████████████████| 1/1 [00:01<00:00,  1.98s/it]
合并完成，输出目录：/root/data/qwen3.5-0.8B-lora-merged

root@localhost:~/data# cd qwen3.5-0.8B-Instruct/
root@localhost:~/data/qwen3.5-0.8B-Instruct# ls -lh
total 1.7G
-rw-r--r-- 1 root root 1.4K Sep  5 23:12 README.md
-rw-r--r-- 1 root root 2.9K Sep  5 23:12 config.json
-rw-r--r-- 1 root root   48 Sep  5 23:12 configuration.json
-rw-r--r-- 1 root root 1.7G Sep  5 23:17 model.safetensors
-rw-r--r-- 1 root root  336 Sep  5 23:12 preprocessor_config.json
-rw-r--r-- 1 root root  13M Sep  5 23:12 tokenizer.json
-rw-r--r-- 1 root root  17K Sep  5 23:12 tokenizer_config.json

root@localhost:~/data/qwen_lora# ls -lh
total 44M
-rw-r--r-- 1 root root 5.1K Sep  5 23:33 README.md
-rw-r--r-- 1 root root 1.2K Sep  5 23:33 adapter_config.json
-rw------- 1 root root  25M Sep  5 23:33 adapter_model.safetensors
-rw-r--r-- 1 root root 7.6K Sep  5 23:33 chat_template.jinja
drwxr-xr-x 2 root root 4.0K Sep  5 23:31 checkpoint-20
drwxr-xr-x 2 root root 4.0K Sep  5 23:33 checkpoint-40
-rw-r--r-- 1 root root  20M Sep  5 23:33 tokenizer.json
-rw-r--r-- 1 root root 1.1K Sep  5 23:33 tokenizer_config.json
-rw-r--r-- 1 root root 4.7K Sep  5 23:33 training_args.bin

root@localhost:~/data/qwen3.5-0.8B-lora-merged# ls -lh
total 1.5G
-rw-r--r-- 1 root root 7.6K Sep  5 23:37 chat_template.jinja
-rw-r--r-- 1 root root 1.8K Sep  5 23:37 config.json
-rw-r--r-- 1 root root  116 Sep  5 23:37 generation_config.json
-rw------- 1 root root 1.5G Sep  5 23:37 model.safetensors
-rw-r--r-- 1 root root  20M Sep  5 23:37 tokenizer.json
-rw-r--r-- 1 root root 1.1K Sep  5 23:37 tokenizer_config.json

完整模型推理测试

不依赖 peft 库，直接加载合并完成完整 HF 模型，验证对话生成效果；调用apply_chat_template构建 prompt，设置 temperature、top_p 采样参数做生成。

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

MODEL_PATH = r"/root/data/qwen3.5-0.8B-lora-merged"

# 加载完整合并模型，不需要peft
model = AutoModelForCausalLM.from_pretrained(
    MODEL_PATH,
    dtype=torch.bfloat16,
    device_map={"": 0},
    trust_remote_code=True
)
tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, trust_remote_code=True)

def chat(prompt_text):
    messages = [
        {"role": "user", "content": prompt_text}
    ]
    text = tokenizer.apply_chat_template(
        messages,
        tokenize=False,
        add_generation_prompt=True
    )
    inputs = tokenizer(text, return_tensors="pt").to("cuda")
    outputs = model.generate(
        **inputs,
        max_new_tokens=200,
        temperature=0.7,
        top_p=0.8,
        do_sample=True
    )
    return tokenizer.decode(outputs[0], skip_special_tokens=True)

if __name__ == "__main__":
    print("====测试1====")
    res1 = chat("你好")
    print(res1)

    print("\n====测试2====")
    res2 = chat("简单介绍一下人工智能")
    print(res2)

运行后输出测试效果如下：

root@localhost:~/data# python test.py  
Loading weights: 100%|██████████████████████████████████████████████| 320/320 [00:00<00:00, 1111.48it/s]
====测试1====
user
你好
assistant
<think>

</think>

你好！有什么可以帮你的吗？


====测试2====
user
简单介绍一下人工智能
assistant
<think>

</think>

人工智能是让计算机模仿人类智能，实现自主决策、学习和适应的能力。

底座和LoRA合并模型对比测试，同时加载原始底座模型、微调合并后的模型，输入同一个问题对比输出，直观确认微调是否生效。

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

BASE = "/root/data/qwen3.5-0.8B-Instruct"
MERGED = "/root/data/qwen3.5-0.8B-lora-merged"

tokenizer = AutoTokenizer.from_pretrained(BASE, trust_remote_code=True)

def get_answer(model_path, question):
    model = AutoModelForCausalLM.from_pretrained(
        model_path,
        dtype=torch.bfloat16,
        device_map={"":0},
        trust_remote_code=True
    )
    messages = [{"role":"user","content":question}]
    prompt = tokenizer.apply_chat_template(messages,tokenize=False,add_generation_prompt=True)
    inputs = tokenizer(prompt,return_tensors="pt").to("cuda")
    out = model.generate(**inputs,max_new_tokens=150,temperature=0.7)
    ans = tokenizer.decode(out[0],skip_special_tokens=True)
    del model
    torch.cuda.empty_cache()
    return ans

q = "你好，什么是大模型LoRA微调？"
print("【原始底座回答】")
print(get_answer(BASE,q))
print("\n【LoRA合并后回答】")
print(get_answer(MERGED,q))

运行后输出测试效果如下：

现象：底座回答偏向通用百科；微调后的输出风格、话术会贴近训练集的回答内容。

root@localhost:~/data# python test.py 
【原始底座回答】
Loading weights: 100%|████████████████████████████████████████████████| 320/320 [00:00<00:00, 867.20it/s]
[transformers] The following generation flags are not valid and may be ignored: ['temperature']. Set `TRANSFORMERS_VERBOSITY=info` for more details.
user
你好，什么是大模型LoRA微调？
assistant
<think>

</think>

你好！大模型（LLM）的 **LoRA（Low-Rank Adaptation）** 微调是一种高效、轻量级的模型微调技术，旨在在不显著影响模型整体性能的前提下，大幅降低计算成本。

简单来说，LoRA 的核心思想是：**只修改模型中“低秩”的部分，而保留“高秩”（即模型的核心能力）不变。**

以下是关于 LoRA 微调的详细解析：

### 1. 核心原理：低秩分解
LoRA 的精髓在于**低秩分解（Low-Rank Decomposition, LRD）**。

*   **高秩矩阵**：代表模型中已经学习好的核心能力（如语言理解、逻辑推理、代码生成等

【LoRA合并后回答】
Loading weights: 100%|███████████████████████████████████████████████████| 320/320 [00:00<00:00, 1027.28it/s]
user
你好，什么是大模型LoRA微调？
assistant
<think>

</think>

LoRA是LoRA适配器，只加载少量权重，训练时只加载少量权重，训练速度更快，推理速度更快，适合微调大模型。