通义千问 3.5 微调实操手册：显存选型、数据集制作、GGUF 导出避坑全拆解

curl -fsSL https://unsloth.ai/install.sh | sh

irm https://unsloth.ai/install.ps1 | iex

unsloth studio -H 0.0.0.0 -p 8888

conda create -n qwen35-finetune python=3.10 -y
conda activate qwen35-finetune

pip install unsloth unsloth_zoo torch accelerate transformers datasets peft bitsandbytes sentencepiece modelscope

pip install modelscope

from modelscope import snapshot_download
model_dir = snapshot_download('Qwen/Qwen3.5-4B')
print(f"模型已下载到: {model_dir}")

modelscope download --model Qwen/Qwen3.5-4B --local_dir ./models/Qwen3.5-4B

[
  {
    "messages": [
      {"role": "system", "content": "你是一个专业的智能财务助理。"},
      {"role": "user", "content": "公司差旅费报销的上限是多少？"},
      {"role": "assistant", "content": "根据公司最新财务制度，普通员工国内差旅住宿费上限为 400 元/晚..."}
    ]
  },
  {
    "messages": [
      {"role": "system", "content": "你是一个专业的智能财务助理。"},
      {"role": "user", "content": "发票抬头写错了怎么办？"},
      {"role": "assistant", "content": "发票抬头错误需要联系开票方重新开具，流程如下..."}
    ]
  }
]

import torch
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig
)
from unsloth import FastLanguageModel

# 方式一：使用 Unsloth 加载（推荐，更快更省显存）
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="Qwen/Qwen3.5-4B",
    max_seq_length=2048,
    dtype=None,  # 自动检测
    load_in_4bit=False,  # 不推荐 4-bit 训练
)

# 方式二：使用 transformers 加载（传统方式）
bnb_config = BitsAndBytesConfig(
    load_in_8bit=True,
    llm_int8_threshold=6.0,
)

model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3.5-4B",
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True
)

tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3.5-4B", trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token

from peft import LoraConfig, get_peft_model

# LoRA 配置
lora_config = LoraConfig(
    r=16,  # 秩（rank），常用 8/16/32/64
    lora_alpha=32,  # alpha 参数，通常为 rank 的 2 倍
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],  # 目标模块
    lora_dropout=0.05,  # dropout 比例
    bias="none",
    task_type="CAUSAL_LM"
)

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

from datasets import load_dataset

# 加载本地 JSONL 数据集
dataset = load_dataset("json", data_files="train.jsonl")

# 数据预处理函数
def format_prompts(examples):
    convos = examples["messages"]
    texts = [
        tokenizer.apply_chat_template(convo, tokenize=False, add_generation_prompt=False)
        for convo in convos
    ]
    return {"text": texts}

dataset = dataset.map(format_prompts, batched=True)

from transformers import TrainingArguments, Trainer
from unsloth import is_bfloat16_supported

# 训练参数
training_args = TrainingArguments(
    output_dir="./output",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    warmup_steps=100,
    num_train_epochs=3,
    learning_rate=2e-4,
    fp16=not is_bfloat16_supported(),
    bf16=is_bfloat16_supported(),
    logging_steps=10,
    save_steps=500,
    save_total_limit=2,
    optim="adamw_8bit",
    weight_decay=0.01,
    lr_scheduler_type="linear",
    seed=3407,
)

# 创建 Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    tokenizer=tokenizer,
)

# 开始训练
trainer.train()

# 保存 LoRA 适配器
model.save_pretrained("./lora_adapter")
tokenizer.save_pretrained("./lora_adapter")

print("LoRA 适配器已保存到 ./lora_adapter")

from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

# 加载基座模型
base_model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3.5-4B",
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

# 加载 LoRA 适配器
model = PeftModel.from_pretrained(base_model, "./lora_adapter")

# 合并权重
merged_model = model.merge_and_unload()

# 保存合并后的模型
merged_model.save_pretrained("./merged_model")
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3.5-4B")
tokenizer.save_pretrained("./merged_model")

# 使用 Unsloth 导出 GGUF
model.save_pretrained_gguf(
    "./gguf_model",
    tokenizer,
    quantization_method="q4_k_m"  # 4-bit 量化
)

print("GGUF 模型已保存到 ./gguf_model")

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# 加载合并后的模型
model = AutoModelForCausalLM.from_pretrained(
    "./merged_model",
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)
tokenizer = AutoTokenizer.from_pretrained("./merged_model", trust_remote_code=True)

# 构建对话
messages = [
    {"role": "system", "content": "你是一个专业的智能财务助理。"},
    {"role": "user", "content": "公司差旅费报销的上限是多少？"}
]

# 应用 ChatML 模板
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

# 生成回复
outputs = model.generate(
    **inputs,
    max_new_tokens=512,
    temperature=0.7,
    do_sample=True,
    top_p=0.8
)

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)

from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer

# 加载基座模型
base_model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3.5-4B",
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

# 加载 LoRA 适配器
model = PeftModel.from_pretrained(base_model, "./lora_adapter")

# 推理同上...

环境准备 → 模型下载 → 数据集准备 → LoRA 配置 → 训练 → 保存适配器 → 合并模型 → 推理测试 → 部署

↓ 详细步骤 ↓

1. 创建 Conda 环境，安装 unsloth/transformers/peft 等依赖
2. 从 ModelScope 下载 Qwen3.5-4B 模型
3. 准备 JSONL 格式数据集（ChatML 对话格式）
4. 配置 LoRA 参数（rank=16, alpha=32, dropout=0.05）
5. 设置训练参数并启动训练
6. 保存 LoRA 适配器
7. 合并 LoRA 适配器与基座模型
8. 测试微调效果
9. 导出 GGUF 格式，用 Ollama 部署