通义千问1.5-1.8B-Chat-GPTQ-Int4实战：基于Transformer架构的模型微调入门

你是不是也遇到过这样的情况：一个通用的大语言模型，回答日常问题还行，但一涉及到你的专业领域，比如医疗、法律或者公司内部的产品知识，它就变得“一问三不知”，或者给出的答案似是而非，不够精准。

这时候，模型微调的价值就体现出来了。它就像是为一个博学但不够专精的学生，进行一次针对性的“特训”，让它在你关心的领域变得真正“懂行”。今天，我们就以通义千问1.5-1.8B-Chat这个轻量级模型为例，手把手带你走一遍从零开始的微调实战。我们会聚焦于Transformer架构的核心，使用高效的LoRA方法，在一个模拟的客服对话数据集上进行训练，最终将它部署为高效的GPTQ-Int4量化版本，打造一个属于你自己的“领域专家”。

1. 为什么选择微调？从通用到专用的蜕变

在深入技术细节之前，我们先聊聊“为什么”。直接使用预训练好的大模型，就像请了一位知识渊博的通用顾问。他能回答很多问题，但对你公司特有的业务流程、产品术语、客服话术可能并不熟悉。微调的目的，就是让这位顾问快速学习你的“内部资料”，用你的“行话”来思考和回答问题。

对于通义千问1.5-1.8B-Chat这类模型，微调尤其有意义。它的参数量相对较小，意味着微调所需的计算资源更少、速度更快，非常适合中小团队或个人开发者进行快速迭代和验证。通过微调，你可以：

• 提升专业性：让模型在你指定的领域（如金融风控、代码生成、创意写作）回答更准确、更深入。
• 统一风格：让模型输出的内容符合你期望的语气、格式或品牌调性。
• 注入私有知识：将外部模型无法获取的内部文档、知识库转化为模型的能力，而不必泄露数据。

我们这次实战的目标很明确：将一个通用的聊天模型，微调成一个能熟练处理特定客服场景（例如“电子产品售后咨询”）的专用助手。

2. 理解核心：Transformer架构与微调的关联

在开始敲代码之前，花几分钟理解背后的原理，能让整个过程更清晰。我们微调的对象——通义千问模型，其核心是Transformer架构。你可以把它想象成一个极其复杂的“信息处理工厂”。

这个工厂里有几个关键车间：

• 自注意力机制（Self-Attention）：这是工厂的“调度中心”。它负责分析输入句子中每一个词（例如“手机”、“无法”、“开机”）与其他所有词之间的关系，决定在处理当前词时，应该重点关注上下文的哪些部分。这让模型能理解“手机无法开机”中“无法”是修饰“开机”的，而不是“手机”。
• 前馈神经网络（Feed-Forward Network）：这是“加工车间”。注意力机制分配好权重后，具体的特征变换和计算在这里完成。
• 层归一化（LayerNorm）与残差连接（Residual Connection）：这是工厂的“稳定与加速装置”。它们能确保信号在深层的网络中传递时不会衰减或爆炸，让训练更稳定。

那么，全参数微调就像是把这个庞大工厂里所有机器的螺丝都重新拧一遍，让它们适应新的生产任务（你的数据）。这虽然有效，但成本极高（需要大量GPU内存和时间）。

而我们将要使用的 LoRA（Low-Rank Adaptation，低秩自适应） 方法，则是一种巧妙的“外挂插件”策略。它发现，模型在适应新任务时，其内部权重矩阵的变化其实具有“低秩”特性。简单说，就是不需要改动原始工厂里那些巨大的核心机器，只需要在它们旁边并联上一些非常小巧、参数极少的“适配器模块”。训练时，我们只更新这些“适配器”的参数，冻结原始模型的所有参数。

这样做的好处显而易见：

1. 极大节省显存：通常只需训练原模型参数的0.1%-1%，一块消费级显卡（如RTX 3090/4090）就能胜任。
2. 训练速度极快：参数少了，计算量自然大幅下降。
3. 便于切换与部署：训练好的LoRA权重文件很小（几MB到几十MB），可以轻松加载到原始模型上，实现“一个基础模型，多个专业技能插件”的灵活组合。

理解了LoRA这个“高效外挂”的思想，我们的实战路径就清晰了：准备数据 -> 配置LoRA -> 微调训练 -> 合并与量化 -> 部署测试。

3. 实战准备：环境、数据与模型

让我们开始动手。首先，确保你有一个支持CUDA的NVIDIA显卡和足够的Python环境。

3.1 环境搭建

我推荐使用Conda来管理环境，避免包冲突。

# 创建并激活一个Python 3.10环境
conda create -n qwen_finetune python=3.10 -y
conda activate qwen_finetune

# 安装PyTorch（请根据你的CUDA版本到PyTorch官网选择对应命令）
# 例如，对于CUDA 11.8
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

# 安装微调核心库：Transformers, PEFT, Accelerate, Datasets
pip install transformers peft accelerate datasets

# 安装用于评估和训练的额外工具
pip install scikit-learn tqdm tensorboard

# 安装GPTQ量化相关库（用于后续量化部署）
pip install auto-gptq optimum

3.2 准备微调数据

数据是微调的“燃料”。我们模拟一个简单的电子产品客服对话数据集。数据格式通常采用JSON或JSONL，每条数据是一个对话轮次。

创建一个名为 customer_service_data.jsonl 的文件，内容如下：

{"instruction": "用户手机无法开机了，怎么办？", "output": "您好，很抱歉听到您的手机无法开机。请先尝试长按电源键15秒以上强制重启。如果无效，请检查充电器和充电线是否正常工作，并充电至少30分钟后再试。若问题依旧，可能是硬件故障，建议您携带设备和购买凭证前往官方服务中心检测。"}
{"instruction": "新买的笔记本电脑风扇噪音很大，正常吗？", "output": "您好，新机在高负载运行时风扇转速提高产生一定噪音是正常现象。建议您先检查是否运行了大型软件或游戏。您也可以尝试在系统电源管理中设置为‘平衡’模式。如果噪音异常巨大或持续不断，请通过官方客服渠道预约检测，以排除装配或硬件问题。"}
{"instruction": "耳机一边没有声音了。", "output": "感谢您的反馈。请您尝试以下步骤：1. 将耳机插入其他设备测试，确认是否耳机问题。2. 检查耳机插头是否完全插入。3. 清洁耳机插头金属部分。4. 检查音频设置是否设置为单声道。如果以上步骤无效，可能是耳机线材或单元损坏，需要联系售后维修。"}
{"instruction": "如何查询我的订单物流信息？", "output": "您好，查询物流信息您可以：1. 登录您的账户，在‘我的订单’中找到对应订单查看详情。2. 如果您有快递单号，可直接在快递公司官网查询。3. 您也可以提供订单号给我，我为您尝试查询最新状态。"}
// ... 可以继续添加更多类似的指令-输出对，至少准备几百条数据效果会更好。

这个数据集的特点是：instruction是用户的问题，output是我们期望模型学习的、专业且规范的客服回答格式。

3.3 加载基础模型

我们将从Hugging Face模型库加载通义千问1.5-1.8B-Chat的基础模型。

from transformers import AutoTokenizer, AutoModelForCausalLM, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model, TaskType
import torch

# 设置模型名称
model_name = "Qwen/Qwen1.5-1.8B-Chat"

# 加载分词器
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
# 设置padding token（如果模型没有）
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

# 加载模型，使用bfloat16精度以节省显存
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16, # 使用bfloat16，在支持它的GPU上能节省显存并保持精度
    device_map="auto", # 自动将模型层分配到可用的GPU上
    trust_remote_code=True
)
print(f"模型加载完成，模型结构：{model.config.model_type}")

4. 核心步骤：使用PEFT配置LoRA进行微调

现在进入最核心的环节——配置并应用LoRA。

4.1 配置LoRA参数

我们使用 peft 库来轻松实现LoRA。关键是要决定对模型的哪些部分添加“适配器”。通常，我们选择Transformer结构中的查询（query）和值（value）投影层。

# 配置LoRA参数
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM, # 因果语言模型任务
    inference_mode=False, # 训练模式
    r=8, # LoRA的秩（rank），即适配器中间层的维度。越小参数越少，通常4,8,16
    lora_alpha=32, # 缩放参数，通常设置为r的2-4倍
    lora_dropout=0.1, # LoRA层的dropout率，防止过拟合
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj", "gate_proj", "up_proj", "down_proj"] 
    # 目标模块：我们选择注意力机制中的Q,K,V,O以及FFN中的部分线性层进行适配。
    # 对于不同模型，模块名称可能不同，可以通过 print(model) 查看。
)

# 将LoRA配置应用到原模型上，得到可训练的PEFT模型
peft_model = get_peft_model(model, lora_config)
peft_model.print_trainable_parameters() # 打印可训练参数量，你会发现它只占原模型的很小一部分

执行 peft_model.print_trainable_parameters() 后，你会看到类似输出： trainable params: 4,194,304 || all params: 1,834,890,240 || trainable%: 0.2285 这意味着我们只需要训练约420万个参数，而不是全部的18亿个，显存占用大大降低。

4.2 数据预处理与格式化

我们需要将原始的指令-输出对，格式化成模型训练时能理解的对话格式。通义千问Chat模型有特定的对话模板。

from datasets import load_dataset
import transformers

# 1. 加载数据
data_files = {"train": "customer_service_data.jsonl"}
dataset = load_dataset('json', data_files=data_files)

# 2. 定义格式化函数
def format_conversation(example):
    # 使用Qwen1.5-Chat的对话模板
    messages = [
        {"role": "user", "content": example['instruction']},
        {"role": "assistant", "content": example['output']}
    ]
    # 使用tokenizer.apply_chat_template方法自动格式化
    text = tokenizer.apply_chat_template(
        messages,
        tokenize=False, # 先不tokenize，返回字符串
        add_generation_prompt=False # 不在末尾添加让模型继续生成的提示
    )
    return {"text": text}

# 3. 应用格式化函数
tokenized_dataset = dataset.map(format_conversation, remove_columns=dataset["train"].column_names)

# 4. 定义tokenize函数，用于将文本转化为模型输入
def tokenize_function(examples):
    # 进行填充和截断
    model_inputs = tokenizer(
        examples["text"],
        truncation=True,
        padding="max_length",
        max_length=512 # 根据你的数据长度调整
    )
    # 将标签设置为输入ID的副本（对于因果语言模型，预测下一个token）
    model_inputs["labels"] = model_inputs["input_ids"].copy()
    return model_inputs

# 5. 对数据集进行tokenize
train_dataset = tokenized_dataset["train"].map(tokenize_function, batched=True)

4.3 配置训练参数并开始训练

使用Hugging Face的 Trainer API可以简化训练循环。

# 定义训练参数
training_args = TrainingArguments(
    output_dir="./qwen-1.8b-customer-service-lora", # 输出目录
    num_train_epochs=3, # 训练轮数，根据数据集大小调整
    per_device_train_batch_size=4, # 每张GPU的批大小，根据显存调整
    gradient_accumulation_steps=4, # 梯度累积步数，模拟更大的批大小
    warmup_steps=100, # 学习率预热步数
    logging_steps=10, # 每10步记录一次日志
    save_steps=200, # 每200步保存一次检查点
    eval_steps=200, # 每200步评估一次（需要验证集）
    evaluation_strategy="steps", # 按步数评估
    save_total_limit=2, # 只保留最新的2个检查点
    learning_rate=2e-4, # 学习率，LoRA通常可以设大一点
    fp16=True, # 使用混合精度训练，进一步节省显存加速训练（如果GPU支持）
    report_to="tensorboard", # 使用TensorBoard记录
    remove_unused_columns=False,
)

# 由于我们模拟数据，没有单独的验证集，这里用部分训练数据模拟。
# 在实际项目中，请务必划分训练集和验证集。
eval_dataset = train_dataset.shuffle(seed=42).select(range(50)) # 取50条作为验证

# 初始化Trainer
trainer = Trainer(
    model=peft_model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    data_collator=transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False),
)

# 开始训练！
trainer.train()

训练过程会在你的输出目录下保存检查点。训练完成后，保存LoRA适配器权重。

# 保存LoRA权重
peft_model.save_pretrained("./qwen_customer_service_lora_adapter")

5. 模型合并、量化与部署

训练完成后，我们得到了一个独立的、很小的LoRA权重文件。但在部署时，我们通常希望得到一个完整的、独立的模型文件。

5.1 合并LoRA权重到基础模型

from peft import PeftModel

# 重新加载基础模型
base_model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True
)

# 加载训练好的LoRA适配器
lora_model = PeftModel.from_pretrained(base_model, "./qwen_customer_service_lora_adapter")

# 将适配器权重合并到基础模型中，得到一个完整的、可独立加载的模型
merged_model = lora_model.merge_and_unload()

# 保存合并后的全量模型
merged_model.save_pretrained("./qwen-1.8b-customer-service-merged")
tokenizer.save_pretrained("./qwen-1.8b-customer-service-merged")

5.2 使用GPTQ进行INT4量化

合并后的模型仍然是FP16/BF16格式，对于1.8B的模型，部署时显存占用约3.6GB。为了进一步降低部署门槛，我们可以使用GPTQ技术进行INT4量化，将模型压缩到1GB左右，并能运行在更广泛的设备上。

from transformers import AutoModelForCausalLM
from optimum.gptq import GPTQQuantizer, load_quantized_model

# 1. 加载待量化的模型和分词器（使用合并后的模型目录）
model_to_quantize = AutoModelForCausalLM.from_pretrained(
    "./qwen-1.8b-customer-service-merged",
    torch_dtype=torch.float16,
    device_map="auto",
    trust_remote_code=True
)
tokenizer = AutoTokenizer.from_pretrained("./qwen-1.8b-customer-service-merged", trust_remote_code=True)

# 2. 准备一个小的校准数据集（用于GPTQ确定量化参数）
# 这里我们直接用训练数据的前128条
from datasets import load_dataset
calibration_dataset = load_dataset('json', data_files={'calib': 'customer_service_data.jsonl'})
calibration_dataset = calibration_dataset['calib'].select(range(128))

def calibrate_prepare_function(examples):
    return tokenizer(examples["instruction"], padding="max_length", max_length=128, truncation=True)

column_names = calibration_dataset.column_names
calibration_dataset = calibration_dataset.map(calibrate_prepare_function, batched=True, remove_columns=column_names)

# 3. 配置并运行量化器
quantizer = GPTQQuantizer(
    bits=4, # 量化到4位
    dataset=calibration_dataset, # 校准数据集
    model_seqlen=512, # 模型序列长度
    block_name_to_quantize = "model.layers", # 要量化的模块名
    group_size=128, # 分组大小，平衡精度和压缩率
    damp_percent=0.1, # 阻尼系数，稳定量化过程
)

# 4. 执行量化
quantized_model = quantizer.quantize_model(model_to_quantize, tokenizer)

# 5. 保存量化后的模型
quantizer.save(quantized_model, "./qwen-1.8b-customer-service-gptq-int4")

5.3 加载量化模型进行推理测试

现在，我们可以加载这个体积小巧但功能专业的量化模型进行测试了。

from transformers import AutoTokenizer, pipeline
from auto_gptq import AutoGPTQForCausalLM

# 加载GPTQ量化模型
quantized_model_dir = "./qwen-1.8b-customer-service-gptq-int4"

model = AutoGPTQForCausalLM.from_quantized(
    quantized_model_dir,
    device="cuda:0", # 指定GPU
    use_triton=False, # 是否使用Triton后端加速（需要额外配置）
    trust_remote_code=True
)
tokenizer = AutoTokenizer.from_pretrained(quantized_model_dir, trust_remote_code=True)

# 创建文本生成管道
pipe = pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    max_new_tokens=256, # 生成的最大token数
    temperature=0.7, # 温度参数，控制随机性
    do_sample=True,
)

# 测试一个客服问题
test_question = "我的平板电脑屏幕碎了，能修吗？大概多少钱？"
# 构建对话
messages = [{"role": "user", "content": test_question}]
prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)

# 生成回答
result = pipe(prompt)
response = result[0]['generated_text'][len(prompt):] # 提取模型生成的部分
print(f"用户: {test_question}")
print(f"AI客服: {response.strip()}")

你应该能看到模型生成的回答已经带有了客服话术的风格，并且能围绕“维修”和“费用”这两个核心点进行回应，而不是像原始通用模型那样给出泛泛而谈的建议。

6. 总结与后续思考

走完这一整套流程，你会发现，基于Transformer架构和LoRA等高效微调技术，为特定领域定制一个轻量级、高性能的AI模型，并没有想象中那么遥不可及。我们从一个1.8B参数的基础聊天模型出发，通过几百条高质量的领域数据，只训练了其中不到1%的参数，就得到了一个在客服场景下表现更专业的模型，最后通过GPTQ量化将其压缩，使其能够更经济地部署。

这个过程的核心在于理解“微调”的本质：不是重新发明轮子，而是巧妙地调整现有强大模型的知识表达方向。LoRA让我们能用极低的成本实现这种调整，而GPTQ量化则让调整后的模型能飞入更多寻常百姓家（或服务器）。

当然，这只是一个起点。要获得真正稳定、可靠的领域模型，你还需要在数据质量、数据量、提示工程、超参数调优以及更严谨的评估上投入更多精力。例如，可以尝试不同的LoRA target_modules，调整 r 和 alpha 参数，或者在更丰富、更贴近真实业务流的数据集上进行训练。但无论如何，你已经掌握了从零开始打造一个专属AI助手的关键技能链。

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。