一、引言：端侧大模型的机遇与挑战

随着大语言模型（LLM）技术的快速发展，将AI能力从云端下沉到端侧已成为必然趋势。骁龙X2 Elite Extreme（SC8480XP）凭借其 85+ TOPS 的NPU算力和最大 64GB 的LPDDR5X内存，为7B~13B参数级别的大模型端侧部署提供了坚实的硬件基础。

然而，端侧部署大模型面临三大核心挑战：

挑战	描述	影响
模型体积大	7B模型FP16格式约14GB，13B模型约26GB	占用大量存储空间，加载慢
内存带宽瓶颈	Decode阶段受限于内存带宽，KV Cache占用高	生成速度慢，并发能力弱
功耗约束	端侧设备电池容量有限，长时间推理发热大	用户体验差，续航缩短

模型量化是解决上述挑战的关键技术手段。通过将模型权重从FP16/FP32压缩到INT8甚至INT4，可以在可控的精度损失下，实现 4~8倍 的模型体积缩减和 2~4倍 的推理速度提升。

本文将深入探讨在骁龙X2 Elite平台上进行大模型量化压缩的完整技术方案，从理论基础到实战代码，帮助开发者实现精度无损的端侧大模型迁移。

二、X2 Elite NPU大模型推理能力全景

2.1 硬件能力概览

骁龙X2 Elite Extreme（SC8480XP）的NPU架构为大模型推理进行了深度优化：

硬件特性	规格	对大模型的意义
NPU算力	85+ TOPS (INT8)	支撑7B~13B模型实时推理
内存带宽	LPDDR5X-8533, ~136 GB/s	Decode阶段KV Cache读取关键
最大内存	64GB 统一内存	可运行13B INT4甚至更大模型
量化支持	INT4 / INT8 / FP16 混合精度	灵活的精度-速度权衡
64位NPU架构	大地址空间支持	支持更大模型和更长上下文

2.2 大模型推理内存分层架构

大模型推理的内存访问具有明显的层级特征。理解内存分层对于优化推理性能至关重要：

• LPDDR5X-8533 统一内存（最大64GB）
  • 延迟：~100ns
  • 带宽：~136GB/s
• 存储内容：模型权重（INT4/INT8）、KV Cache 全量、激活值/中间张量、输入输出缓冲

Prefill vs Decode阶段的内存特征差异

• Prefill阶段（输入处理）：计算密集型，一次性处理全部输入Token，内存带宽影响为中等
• Decode阶段（Token生成）：访存密集型，每步只需读取一个Token的权重 + 全部KV Cache，内存带宽是核心瓶颈

2.3 主流大模型适配性分析

基于X2 Elite的硬件能力，以下主流大模型均可实现端侧部署：

模型	参数	FP16体积	INT8体积	INT4体积	推荐精度	预期速度
Phi-3-mini	3.8B	~7.6 GB	~3.8 GB	~1.9 GB	INT4	~25 tokens/s
Qwen2-7B	7B	~14 GB	~7 GB	~3.5 GB	INT4 AWQ	~15 tokens/s
Llama 3-8B	8B	~16 GB	~8 GB	~4 GB	INT4 AWQ	~13 tokens/s
Gemma-7B	7B	~14 GB	~7 GB	~3.5 GB	INT8/INT4	1218 tokens/s
Mistral-7B	7B	~14 GB	~7 GB	~3.5 GB	INT4 GPTQ	~14 tokens/s
Qwen2-13B	13B	~26 GB	~13 GB	~6.5 GB	INT4 AWQ	810 tokens/s

提示：以上性能数据为理论估算值，实际性能受模型结构、上下文长度、系统负载等因素影响。64GB内存配置可支持13B甚至更大模型的INT4部署。

三、量化技术深度解析

3.1 量化基本原理

量化的核心思想是将高精度（如FP16）的浮点数权重映射到低精度（如INT8/INT4）的整数空间，从而减少存储占用和计算开销。

基本量化公式：

量化： q = round(r / S + Z)
反量化： r = (q - Z) * S

其中：
r = 真实浮点数值
q = 量化后整数值
S = 缩放因子（scale）
Z = 零点（zero point）

3.2 量化方案对比

不同的量化方案在精度损失、算力、内存占用之间存在不同的权衡：

量化方案	精度损失	NPU算力 (TOPS)	模型大小 (7B)	带宽需求	适用场景
FP16 (基准)	无损失	~20 TOPS	~14 GB	高	高精度要求/小模型验证
INT8 (对称)	<1%	~85 TOPS	~7 GB	中	通用场景/检测分类
INT8 (非对称)	<0.5%	~80 TOPS	~7 GB	中	NLP/大模型推荐
INT4 (AWQ)	1~3%	150+ TOPS	~3.5 GB	低	端侧大模型/长上下文
INT4 (GPTQ)	0.5~2%	150+ TOPS	~3.5 GB	低	高精度大模型部署

精度-算力权衡曲线（7B LLM模型）：此处为示意图，反映不同量化方案在精度和算力之间的取舍。

3.3 INT8量化：对称 vs 非对称

对称量化（Symmetric）：

• 零点 ( z = 0 )，正负对称分布
• 计算简单，速度快
• 精度损失略大，适合激活值分布对称的情况

非对称量化（Asymmetric）：

• 零点 ( z \neq 0 )，根据实际分布确定
• 精度更高，尤其适合分布不对称的权重
• 计算略复杂，但NPU硬件已原生支持

大模型推荐：权重使用非对称INT8量化，激活值使用对称INT8量化，可在精度和速度间取得最佳平衡。

3.4 INT4量化：AWQ vs GPTQ

INT4量化是端侧大模型部署的核心技术，两种主流方案各有优势：

AWQ（Activation-aware Weight Quantization）：

• 核心思想：根据激活值的重要性来保护权重，而不是均匀量化所有权重
• 优势：推理速度快，实现简单，与硬件兼容性好
• 精度：7B模型INT4量化后困惑度(PPL)上升约 ( 1% \sim 3% )
• 适用：QNN SDK原生支持，X2 Elite平台推荐方案

GPTQ（Generative Pre-trained Transformer Quantization）：

• 核心思想：逐层最小化量化误差，使用Hessian矩阵信息优化量化参数
• 优势：精度更高，尤其在小模型和低比特场景
• 精度：7B模型INT4量化后PPL上升约 ( 0.5% \sim 2% )
• 适用：对精度要求极高的场景，需转换为硬件支持的格式

X2 Elite平台建议：

• 优先使用AWQ INT4，QNN工具链原生支持，部署简单
• 对精度敏感的场景，可使用GPTQ量化后转换为QNN格式

3.5 分层量化策略

并非模型的每一层都对量化同样敏感。采用分层量化策略可以在精度和速度间取得最优平衡：

┌─────────────────────────────────────────────────────┐
│  模型层        推荐精度          原因                 │
├─────────────────────────────────────────────────────┤
│  Embedding     FP16/INT8       词嵌入对精度敏感       │
│  Q/K/V投影     INT4            矩阵乘，计算量大       │
│  Attention     INT4/INT8       核心计算单元          │
│  FFN上投影     INT4            大矩阵乘              │
│  FFN下投影     INT4            大矩阵乘              │
│  RMSNorm       FP16/INT8       归一化，精度敏感      │
│  LM Head       FP16/INT8       输出层，直接影响      │
└─────────────────────────────────────────────────────┘

四、量化校准数据集构建与精度验证

4.1 校准数据集的重要性

静态量化（INT8/INT4）需要使用校准数据集来确定每一层的量化参数（scale和zeropoint）。校准数据的质量直接影响最终模型的精度。

校准数据集的核心要求：

1. 代表性：数据分布需与实际推理场景一致
2. 多样性：覆盖各种输入类型和长度
3. 适量性：样本太少精度不够，太多校准时间长

4.2 校准数据集构建实战

"""
大模型量化校准数据集构建
适用于QNN SDK静态量化校准
"""

import json
import random
from typing import List, Dict
from datasets import load_dataset

def build_calibration_dataset(
    output_path: str,
    num_samples: int = 128,
    max_seq_len: int = 2048,
    dataset_name: str = "tatsu-lab/alpaca",
    seed: int = 42
):
    """
    构建量化校准数据集

    Args:
        output_path: 输出校准数据文件路径
        num_samples: 校准样本数量（推荐128-512）
        max_seq_len: 最大序列长度
        dataset_name: 基础数据集名称
        seed: 随机种子
    """
    random.seed(seed)

    # 加载公开数据集
    dataset = load_dataset(dataset_name, split="train")

    # 随机采样
    indices = random.sample(range(len(dataset)), min(num_samples * 2, len(dataset)))

    calibration_samples = []

    for idx in indices:
        sample = dataset[idx]

        # 构建prompt（根据模型模板调整）
        if "instruction" in sample and "input" in sample:
            instruction = sample["instruction"]
            input_text = sample.get("input", "")

            if input_text:
                prompt = f"Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.\n\n### Instruction:\n{instruction}\n\n### Input:\n{input_text}\n\n### Response:"
            else:
                prompt = f"Below is an instruction that describes a task. Write a response that appropriately completes the request.\n\n### Instruction:\n{instruction}\n\n### Response:"
        else:
            prompt = sample.get("text", sample.get("content", ""))

        # 过滤过短的样本
        if len(prompt) < 50:
            continue

        # 截断到最大长度
        if len(prompt) > max_seq_len * 4:  # 粗略估计：4字符1token
            prompt = prompt[:max_seq_len * 4]

        calibration_samples.append({
            "prompt": prompt,
            "seq_len_estimate": len(prompt) // 4
        })

        if len(calibration_samples) > num_samples:
            break

    # 保存校准数据
    with open(output_path, 'w', encoding='utf-8') as f:
        json.dump(calibration_samples, f, ensure_ascii=False, indent=2)

    print(f"[校准数据]已生成{len(calibration_samples)}条校准样本")
    print(f"[校准数据]平均长度：{sum(s['seq_len_estimate'] for s in calibration_samples) / len(calibration_samples):.0f} tokens")
    print(f"[校准数据]已保存到：{output_path}")

    return calibration_samples


def build_chinese_calibration_dataset(
    output_path: str,
    num_samples: int = 128,
    max_seq_len: int = 2048
):
    """
    构建中文场景校准数据集
    混合多种数据类型，提升模型在中文场景的精度
    """
    import glob

    samples = []

    # 数据来源1：中文通用对话
    samples.extend(load_chinese_dialogue(num_samples // 3, max_seq_len))

    # 数据来源2：代码生成
    samples.extend(load_code_samples(num_samples // 4, max_seq_len))

    # 数据来源3：知识问答
    samples.extend(load_knowledge_qa(num_samples // 4, max_seq_len))

    # 数据来源4：长文本摘要
    samples.extend(load_long_text(num_samples // 6, max_seq_len))

    # 打乱顺序
    random.shuffle(samples)
    samples = samples[:num_samples]

    with open(output_path, 'w', encoding='utf-8') as f:
        json.dump(samples, f, ensure_ascii=False, indent=2)

    print(f"[中文校准] 已生成 {len(samples)} 条校准样本")
    return samples


# 使用示例
if __name__ == "__main__":
    # 英文通用校准数据
    build_calibration_dataset(
        output_path="calibration_alpaca_128.json",
        num_samples=128,
        max_seq_len=2048
    )

    # 中文场景校准数据
    # build_chinese_calibration_dataset(
    #     output_path="calibration_chinese_128.json",
    #     num_samples=128
    # )

4.3 精度验证方法

量化完成后，必须进行充分的精度验证，确保量化后的模型满足业务需求。

"""
量化模型精度验证
对比FP16基线模型与量化模型的性能差异
"""
import numpy as np
from typing import List, Dict
import json

def evaluate_perplexity(
    model_session,  # ONNX Runtime / QNN 推理会话
    tokenizer,
    eval_texts: List[str],
    max_length: int = 2048
) -> float:
    """
    计算模型困惑度（Perplexity）
    Perplexity越低，模型语言建模能力越好
    """
    total_loss = 0.0
    total_tokens = 0

    for text in eval_texts:
        # Token化
        tokens = tokenizer.encode(text, max_length=max_length, truncation=True)

        if len(tokens) < 10:
            continue

        # 计算每个位置的loss（简化实现）
        # 实际应使用模型输出的logits计算交叉熵
        input_ids = tokens[:-1]
        target_ids = tokens[1:]

        # 推理获取logits
        outputs = model_session.run(None, {"input_ids": np.array([input_ids], dtype=np.int64)})
        logits = outputs[0][0]  # [seq_len, vocab_size]

        # 计算交叉熵损失
        for i, target in enumerate(target_ids):
            log_probs = logits[i] - np.max(logits[i])  # 数值稳定
            log_probs = log_probs - np.log(np.sum(np.exp(log_probs)))
            total_loss += -log_probs[target]
            total_tokens += 1

    avg_loss = total_loss / total_tokens if total_tokens > 0 else float('inf')
    perplexity = np.exp(avg_loss)

    return perplexity


def evaluate_generation_quality(
    model_session,
    tokenizer,
    test_prompts: List[Dict],
    reference_outputs: List[str] = None
) -> Dict:
    """
    评估生成质量
    对比量化前后的输出差异
    """
    results = {
        "exact_match_rate": 0.0,
        "similarity_score": 0.0,
        "completion_rate": 0.0,
        "avg_length": 0.0
    }

    outputs = []

    for i, prompt_data in enumerate(test_prompts):
        prompt = prompt_data["prompt"]
        input_ids = tokenizer.encode(prompt, return_tensors="np")

        # 生成回复（简化版greedy search）
        generated_ids = input_ids[0].tolist()
        max_new_tokens = 256

        for _ in range(max_new_tokens):
            outputs_tensor = model_session.run(
                None,
                {"input_ids": np.array([generated_ids], dtype=np.int64)}
            )
            next_token_logits = outputs_tensor[0][0, -1, :]
            next_token = int(np.argmax(next_token_logits))

            if next_token == tokenizer.eos_token_id:
                break
            generated_ids.append(next_token)

        generated_text = tokenizer.decode(
            generated_ids[len(input_ids[0]):],
            skip_special_tokens=True
        )
        outputs.append(generated_text)

        # 计算输出长度
        results["avg_length"] += len(generated_text)

    results["avg_length"] /= len(test_prompts)
    results["completion_rate"] = len([o for o in outputs if len(o) > 10]) / len(outputs)

    # 如果有参考输出，计算相似度
    if reference_outputs:
        from difflib import SequenceMatcher
        similarities = []
        for gen, ref in zip(outputs, reference_outputs):
            sim = SequenceMatcher(None, gen, ref).ratio()
            similarities.append(sim)
        results["similarity_score"] = np.mean(similarities)

    return results


def quant_accuracy_report(
    fp16_results: Dict,
    quant_results: Dict,
    model_name: str = "7B LLM",
    quant_type: str = "INT4 AWQ"
) -> str:
    """
    生成量化精度报告
    """
    report = f"""
========================================
量化精度评估报告
========================================
模型: {model_name:<41s}
量化方式: {quant_type:<37s}
----------------------------------------
指标              FP16基线      量化后        变化
----------------------------------------
困惑度(PPL)       {fp16_results.get('perplexity', 0):>8.2f}    {quant_results.get('perplexity', 0):>8.2f}    {quant_results.get('perplexity', 0) - fp16_results.get('perplexity', 0):>+7.2f}
生成相似度        {fp16_results.get('similarity', 1.0):>8.2%}    {quant_results.get('similarity', 0):>8.2%}    {quant_results.get('similarity', 0) - fp16_results.get('similarity', 1.0):>+7.2%}
完成率            {fp16_results.get('completion_rate', 0):>8.1%}    {quant_results.get('completion_rate', 0):>8.1%}    {quant_results.get('completion_rate', 0) - fp16_results.get('completion_rate', 0):>+7.1%}
----------------------------------------
"""
    return report


# 使用示例
if __name__ == "__main__":
    print("量化精度验证工具已就绪")
    print("使用步骤:")
    print(" 1. 分别在FP16和量化模型上运行评估")
    print(" 2. 对比困惑度(PPL)变化 < 5% 为优秀")
    print(" 3. 对比生成相似度 > 90% 为可接受")
    print(" 4. 如精度不达标，增加校准数据或调整量化策略")

五、模型结构优化技术

5.1 算子融合（Operator Fusion）

算子融合是将多个连续的算子合并为一个，减少中间结果的内存读写和kernel launch开销。

常见融合模式：

# 模式1：LayerNorm/RMSNorm融合
# 原始：x → Multiply → Add → Rsqrt → Multiply → Add（5个算子）
# 融合：x → LayerNorm（1个算子）

# 模式2：Attention融合
# 原始：Q*K^T → Scale → Mask → Softmax → *V（5个算子）
# 融合：MultiHeadAttention（1个融合算子）

# 模式3：FFN融合
# 原始：Linear → SiLU → Multiply → Linear（4个算子）
# 融合：FFN（2个融合算子）

QNN SDK的模型优化器会自动进行算子融合，但在模型导出阶段就进行优化可以获得更好的效果。

5.2 KV Cache优化

KV Cache是大模型推理中内存占用最大的部分之一，其计算公式为：

KV Cache内存 = 2 × n_layers × n_heads × d_head × seq_len × bytes_per_element

# 示例：7B模型，32层，32头，128维头，4K上下文，INT8精度
# = 2 × 32 × 32 × 128 × 4096 × 1byte
# = ~1GB（INT8）

# 示例：13B模型，40层，40头，128维头，8K上下文，FP16精度
# = 2 × 40 × 40 × 128 × 8192 × 2bytes
# = ~6.4GB（FP16）

KV Cache优化策略：

1. 量化KV Cache：使用INT8甚至INT4存储KV Cache，内存减半
2. 分页注意力（PagedAttention）：将KV Cache分成固定大小的页，动态分配，减少内存碎片
3. 前缀共享：多轮对话中共享系统Prompt的KV Cache
4. 滑动窗口：长上下文场景下只保留最近N个Token的KV

5.3 模型结构调整建议

对于端侧部署，可以考虑以下结构调整以提升推理效率：

优化方向	具体方法	效果	精度影响
减少层数	32层→28层（蒸馏）	速度+15%，内存-12%	轻微下降
减小头数	32头→24头，增大头维度	速度+10%	较小
MoE稀疏化	使用MoE架构，激活部分参数	速度+30%+	需重新训练
滑动窗口	限制注意力窗口大小	内存-50%+	长文本能力下降
分组查询注意力	GQA/MLA，K/V头数<Q头数	KV内存-50~75%	极小

注意：上述结构调整通常需要重新训练或微调模型。对于预训练模型，建议优先使用量化和推理优化技术。

六、实战：QNN SDK大模型量化全流程

6.1 环境准备

# 1. 安装QNN SDK
# 下载地址：https://qpm.qualcomm.com/
# 选择 Qualcomm Neural Network SDK for Windows on ARM

# 2. 设置环境变量
# Windows (PowerShell):
# $env:PATH += ";C:\Qualcomm\AIStack\QNW\2.xx.x\bin\aarch64-windows-msvc"

# 3. 安装Python依赖
pip install onnx onnxruntime transformers accelerate torch
pip install auto-gptq --no-build-isolation  # GPTQ量化（可选）

6.2 模型导出为ONNX

"""
大模型导出ONNX格式
支持Llama、Qwen、Phi、Mistral等主流模型
"""

import torch
import os
from transformers import AutoModelForCausalLM, AutoTokenizer
from pathlib import Path

def export_llm_to_onnx(
    model_name_or_path: str,
    output_dir: str,
    max_seq_len: int = 4096,
    use_past: bool = True,
    dtype: str = "fp16"
):
    """
    将大模型导出为ONNX格式，适配QNN SDK

    Args:
        model_name_or_path: HuggingFace模型名或本地路径
        output_dir: 输出目录
        max_seq_len: 最大序列长度
        use_past: 是否导出KV Cache (past_key_values) 版本
        dtype: 导出精度 fp16/fp32
    """
    output_dir = Path(output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    print(f"[导出] 加载模型: {model_name_or_path}")
    tokenizer = AutoTokenizer.from_pretrained(model_name_or_path)

    torch_dtype = torch.float16 if dtype == "fp16" else torch.float32
    model = AutoModelForCausalLM.from_pretrained(
        model_name_or_path,
        torch_dtype=torch_dtype,
        device_map="cpu",
        trust_remote_code=True
    )
    model.eval()

    # 准备输入
    batch_size = 1
    seq_len = 128  # 示例输入长度

    input_ids = torch.randint(0, model.config.vocab_size, (batch_size, seq_len))
    attention_mask = torch.ones(batch_size, seq_len, dtype=torch.long)

    if use_past:
        # 带past_key_values的导出（用于Decode阶段优化）
        # Decode with past: 输入1个token + past KV, 输出1个token + 更新后的KV
        past_key_values = _get_dummy_past_key_values(model.config, batch_size, seq_len - 1)

        # Decoder-only模型 (with past)
        input_ids_decode = torch.randint(0, model.config.vocab_size, (batch_size, 1))
        attention_mask_decode = torch.ones(batch_size, seq_len, dtype=torch.long)

        print("[导出] 导出 Decode-with-Past 模型...")
        with torch.no_grad():
            torch.onnx.export(
                model,
                (input_ids_decode, attention_mask_decode, past_key_values),
                output_dir / "model_decoder.onnx",
                input_names=["input_ids", "attention_mask", "past_key_values"],
                output_names=["logits", "present_key_values"],
                dynamic_axes={
                    "input_ids": {0: "batch_size", 1: "seq_len"},
                    "attention_mask": {0: "batch_size", 1: "total_seq_len"},
                    "past_key_values": {2: "past_seq_len"},
                    "logits": {0: "batch_size", 1: "seq_len"},
                    "present_key_values": {2: "total_seq_len"},
                },
                opset_version=17,
                do_constant_folding=True,
            )
        print("[导出] Decode模型导出完成")
    else:
        # 完整模型导出 (Prefill阶段)
        print("[导出] 导出完整模型...")
        with torch.no_grad():
            torch.onnx.export(
                model,
                (input_ids, attention_mask),
                output_dir / "model.onnx",
                input_names=["input_ids", "attention_mask"],
                output_names=["logits"],
                dynamic_axes={
                    "input_ids": {0: "batch_size", 1: "seq_len"},
                    "attention_mask": {0: "batch_size", 1: "seq_len"},
                    "logits": {0: "batch_size", 1: "seq_len"},
                },
                opset_version=17,
                do_constant_folding=True,
            )
        print("[导出] 完整模型导出完成")

    # 保存tokenizer配置
    tokenizer.save_pretrained(output_dir / "tokenizer")

    # 保存模型配置
    model.config.save_pretrained(output_dir / "config")

    print(f"[导出] 所有文件已保存到: {output_dir}")
    return output_dir


def _get_dummy_past_key_values(config, batch_size, past_seq_len):
    """生成dummy past_key_values用于导出"""
    num_layers = config.num_hidden_layers
    num_heads = config.num_key_value_heads if hasattr(config, 'num_key_value_heads') else config.num_attention_heads
    head_dim = config.hidden_size // config.num_attention_heads

    past_key_values = tuple(
        (
            torch.randn(batch_size, num_heads, past_seq_len, head_dim),
            torch.randn(batch_size, num_heads, past_seq_len, head_dim),
        )
        for _ in range(num_layers)
    )
    return past_key_values


# 使用示例
if __name__ == "__main__":
    # 导出Phi-3-mini示例
    export_llm_to_onnx(
        model_name_or_path="microsoft/Phi-3-mini-4k-instruct",
        output_dir="./onnx_models/phi3-mini",
        max_seq_len=4096,
        use_past=True,
        dtype="fp16"
    )

6.3 使用QNN工具链进行INT8量化

# QNN SDK 大模型INT8量化流程
# 在Windows on ARM设备或x86交叉编译环境中执行

# 步骤1：转换ONNX模型为QNN中间表示
qnn-onnx-converter ^
  --input_network model.onnx ^
  --output_path model_qnn.cpp ^
  --input_dims input_ids:1,128 ^
  --input_dims attention_mask:1,128 ^
  --out_node_names logits ^
  --verbose

# 步骤2：生成量化配置文件
# 创建 calibration_config.json:
# {
#   "calibration_data": [
#     {"input_ids": "calib_data/input_0.bin", "attention_mask": "calib_data/mask_0.bin"},
#     {"input_ids": "calib_data/input_1.bin", "attention_mask": "calib_data/mask_1.bin"},
#     ...
#   ],
#   "quantization_method": "enhanced_quantization",
#   "bit_width": 8,
#   "activation_quantization": "symmetric",
#   "weight_quantization": "asymmetric"
# }

# 步骤3：执行静态量化
qnn-model-lib-generator ^
  -i model_qnn.cpp ^
  -o . ^
  -c calibration_config.json ^
  -b 8 ^
  --quantize_full_model

# 步骤4：生成NPU可执行的上下文二进制
qnn-context-binary-generator ^
  --model model_qnn.serialized.so ^
  --output_file model_int8_qnn.serialized.bin ^
  --backend libQnnHtp.so

6.4 AWQ INT4量化实战

"""
AWQ INT4量化脚本
使用AWQ算法对大模型进行4bit量化
"""

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from awq import AutoAWQForCausalLM

def quantize_with_awq(
    model_name_or_path: str,
    output_path: str,
    w_bit: int = 4,
    group_size: int = 128,
    zero_point: bool = True,
    calib_data: str = "pixelval",
    calib_samples: int = 128,
    calib_seqlen: int = 2048
):
    """
    使用AWQ算法进行INT4量化

    Args:
        model_name_or_path: 原始模型路径
        output_path: 量化后输出路径
        w_bit: 权重量化位数 (4)
        group_size: 量化组大小
        zero_point: 是否使用zero point (非对称量化)
        calib_data: 校准数据集
        calib_samples: 校准样本数
        calib_seqlen: 校准序列长度
    """
    print(f"[AWQ量化] 加载模型: {model_name_or_path}")

    # 加载模型
    model = AutoAWQForCausalLM.from_pretrained(
        model_name_or_path,
        torch_dtype=torch.float16,
        trust_remote_code=True
    )
    tokenizer = AutoTokenizer.from_pretrained(
        model_name_or_path,
        trust_remote_code=True
    )

    # 量化配置
    quant_config = {
        "w_bit": w_bit,
        "group_size": group_size,
        "zero_point": zero_point,
        "version": "GEMM",  # GEMM 或 GEMV
    }

    print(f"[AWQ量化] 开始量化, 配置: {quant_config}")

    # 执行量化
    model.quantize(
        tokenizer,
        quant_config=quant_config,
        calib_data=calib_data,
        n_samples=calib_samples,
        seqlen=calib_seqlen,
    )

    print(f"[AWQ量化] 保存量化模型到: {output_path}")
    model.save_quantized(output_path)
    tokenizer.save_pretrained(output_path)

    # 打印模型大小对比
    import os
    original_size = _get_model_size(model_name_or_path)
    quantized_size = _get_model_size(output_path)
    print(f"\n[AWQ量化] 原始模型大小: {original_size:.2f} GB")
    print(f"[AWQ量化] 量化后大小: {quantized_size:.2f} GB")
    print(f"[AWQ量化] 压缩比: {original_size / quantized_size:.2f}x")

    return output_path


def _get_model_size(path: str) -> float:
    """获取模型文件总大小（GB）"""
    total_size = 0
    for root, dirs, files in os.walk(path):
        for f in files:
            fp = os.path.join(root, f)
            total_size += os.path.getsize(fp)
    return total_size / (1024 ** 3)


def convert_awq_to_onnx(
    awq_model_path: str,
    output_onnx_path: str,
    max_seq_len: int = 4096
):
    """
    将AWQ量化模型转换为ONNX格式，供QNN工具链使用

    注意：QNN SDK对AWQ格式的支持需参考最新文档
    推荐使用QNN原生量化工具链进行端到端量化
    """
    print("[转换] AWQ模型转换为ONNX...")
    # 加载AWQ量化模型
    model = AutoAWQForCausalLM.from_quantized(
        awq_model_path,
        torch_dtype=torch.float16,
        trust_remote_code=True,
        fuse_layers=False
    )

    # 导出ONNX（仿量化/模拟量化导出）
    # 注意：实际部署中推荐使用QNN原生量化工具
    print("[转换] 建议使用QNN SDK原生量化工具获得最佳性能")
    print("[转换] 参考命令：qnn-onnx-converter + qnn-model-lib-generator")

    return output_onnx_path


# 使用示例
if __name__ == "__main__":
    # 量化Qwen2-7B
    quantize_with_awq(
        model_name_or_path="Qwen/Qwen2-7B-Instruct",
        output_path="./models/Qwen2-7B-Instruct-AWQ",
        w_bit=4,
        group_size=128,
        calib_samples=128,
        calib_seqlen=2048
    )

6.5 ONNX Runtime QNN EP推理验证

"""
使用ONNX Runtime QNN EP验证量化模型
在骁龙X2 Elite设备上运行
"""

import onnxruntime as ort
import numpy as np
import time
from transformers import AutoTokenizer

class X2EliteLLMInference:
    def __init__(
        self,
        model_path: str,
        tokenizer_path: str,
        backend: str = "npu",  # "npu" 或 "cpu"
        precision: str = "int8"  # "fp16", "int8", "int4"
    ):
        self.tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)
        self.backend = backend
        self.precision = precision

        # 配置推理后端
        providers = []
        if backend == "npu":
            providers.append('QNNExecutionProvider')
        # CPU回退
        providers.append('CPUExecutionProvider')

        # 加载模型
        sess_options = ort.SessionOptions()
        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL

        self.session = ort.InferenceSession(
            model_path,
            sess_options=sess_options,
            providers=providers
        )

        print(f"[X2 Elite LLM] 模型加载完成")
        print(f"[X2 Elite LLM] 推理后端: {self.session.get_providers()}")
        print(f"[X2 Elite LLM] 精度模式: {precision}")

    def generate(
        self,
        prompt: str,
        max_new_tokens: int = 512,
        temperature: float = 1.0,
        top_p: float = 0.9,
        stream: bool = True
    ):
        """
        生成回复

        Args:
            prompt: 输入提示词
            max_new_tokens: 最大生成token数
            temperature: 采样温度
            top_p: 核采样阈值
            stream: 是否流式输出
        """
        # Token化输入
        input_ids = self.tokenizer.encode(prompt, return_tensors="np")
        attention_mask = np.ones_like(input_ids)

        generated_ids = input_ids[0].tolist()
        start_time = time.perf_counter()
        first_token_time = None

        # 生成循环（简化版greedy + top-p采样）
        for i in range(max_new_tokens):
            # 准备输入
            input_tensor = np.array([generated_ids], dtype=np.int64)
            mask_tensor = np.ones_like(input_tensor)

            # NPU推理
            outputs = self.session.run(
                None,
                {
                    "input_ids": input_tensor,
                    "attention_mask": mask_tensor
                }
            )

            # 获取下一个token的logits
            next_token_logits = outputs[0][0, -1, :]

            # 采样
            next_token = self._sample(next_token_logits, temperature, top_p)

            if first_token_time is None:
                first_token_time = time.perf_counter()
                tttf = first_token_time - start_time
                print(f"\n[首字延迟] {tttf*1000:.0f}ms")

            # 检查是否结束
            if next_token == self.tokenizer.eos_token_id:
                break

            generated_ids.append(next_token)

            # 流式输出
            if stream:
                new_text = self.tokenizer.decode(
                    [next_token],
                    skip_special_tokens=True
                )
                print(new_text, end="", flush=True)

        # 性能统计
        total_time = time.perf_counter() - start_time
        num_generated = len(generated_ids) - len(input_ids[0])
        tokens_per_second = num_generated / total_time

        print(f"\n\n[性能统计]")
        print(f"  生成Token数: {num_generated}")
        print(f"  总耗时: {total_time:.2f}s")
        print(f"  生成速度: {tokens_per_second:.2f} tokens/s")
        if first_token_time:
            print(f"  首字延迟: {(first_token_time - start_time)*1000:.0f}ms")

        # 返回完整文本
        full_text = self.tokenizer.decode(
            generated_ids[len(input_ids[0]):],
            skip_special_tokens=True
        )
        return full_text

    def _sample(self, logits: np.ndarray, temperature: float, top_p: float) -> int:
        """Top-P采样"""
        logits = logits / max(temperature, 1e-8)

        # Top-P过滤
        sorted_logits = np.sort(logits)[::-1]
        sorted_probs = np.exp(sorted_logits - np.max(sorted_logits))
        sorted_probs = sorted_probs / np.sum(sorted_probs)

        cumulative_probs = np.cumsum(sorted_probs)
        cutoff_idx = np.searchsorted(cumulative_probs, top_p) + 1

        # 保留top-p的token
        top_logits = sorted_logits[:cutoff_idx]
        top_indices = np.argsort(logits)[::-1][:cutoff_idx]

        # 重新归一化并采样
        top_probs = np.exp(top_logits - np.max(top_logits))
        top_probs = top_probs / np.sum(top_probs)

        selected_idx = np.random.choice(len(top_probs), p=top_probs)
        return int(top_indices[selected_idx])


# 使用示例
if __name__ == "__main__":
    # 在骁龙X2 Elite设备上运行
    inferencer = X2EliteLLMInference(
        model_path="models/phi3-mini_int8_qnn.onnx",
        tokenizer_path="models/phi3-mini/tokenizer",
        backend="npu",
        precision="int8"
    )

    # 测试生成
    response = inferencer.generate(
        prompt="请解释一下什么是大语言模型量化，以及它的主要优势是什么？",
        max_new_tokens=256,
        stream=True
    )

七、大模型量化迁移全流程

量化迁移全流程图，展示从原始模型到最终NPU部署的完整步骤，包括：模型选型 → 导出ONNX → 量化校准 → AWQ/GPTQ量化 → QNN转换 → 生成NPU二进制 → 推理验证等环节

八、最佳实践与常见问题

8.1 量化部署最佳实践清单

阶段	最佳实践	说明
模型选型	优先选择GQA/MLA架构模型	KV Cache更小，端侧更友好
校准数据	校准样本128~512条，覆盖目标场景	数据质量 > 数据数量
量化策略	通用模型用INT8，7B+用INT4 AWQ	根据模型大小和精度要求选择
敏感层保护	Embedding/LM Head用FP16/INT8	这些层对量化更敏感
KV Cache	使用INT8量化KV Cache	内存减半，精度损失极小
推理引擎	优先使用QNN Native API	性能优于ONNX Runtime QNN EP
性能模式	交互场景用burst，长任务用sustained	根据场景选择HTP性能模式
预热加载	应用启动时预加载模型到NPU	减少首次推理延迟

8.2 常见问题与解决方案

Q1：量化后模型精度下降明显怎么办？

A：按以下步骤排查：

1. 检查校准数据是否具有代表性，是否覆盖目标场景
2. 增加校准样本数量（128 → 256 → 512）
3. 尝试不同的量化算法（对称 → 非对称 → AWQ）
4. 将敏感层（Embedding、LM Head、RMSNorm）保持FP16
5. 考虑从INT4调整为INT8

Q2：NPU推理速度不达预期怎么办？

A：优化方向：

1. 确认模型已正确量化并运行在NPU上（检查providers）
2. 设置 htp_performance_mode: 'burst' 获取最高性能
3. 使用QNN Context Binary减少图编译开销
4. 优化模型结构，减少动态shape和控制流
5. 检查是否有算子回退到CPU执行（使用QNN Profiler）

Q3：内存不足，无法加载大模型怎么办？

A：内存优化策略：

1. 使用更高压缩比的量化（INT8 → INT4）
2. 启用KVCache量化，减少运行时内存
3. 使用分页注意力，动态分配KVCache
4. 考虑更小的模型或更小的上下文窗口
5. 关闭不必要的后台应用，释放系统内存

Q4：如何选择INT8还是INT4？

A：决策参考：

• 3B以下模型：INT8足够，精度损失极小
• 7B模型：INT4 AWQ是甜点，精度损失可控，速度提升明显
• 13B+模型：必须INT4，否则内存可能不足
• 对精度要求极高：先用INT8，不行再考虑混合精度

九、总结

模型量化是端侧大模型部署的核心技术。在骁龙X2 Elite平台上，通过合理的量化策略，可以实现：

• 模型体积缩减4~8倍：7B模型从14GB降至3.5GB以内
• 推理速度提升2~4倍：NPU算力从20TOPS提升到85+ TOPS甚至更高
• 内存带宽压力减半：Decode阶段带宽瓶颈显著缓解
• 功耗降低：更少的内存访问意味着更低的功耗

本文详细介绍了量化的理论基础、技术选型、校准数据构建、精度验证方法，并提供了完整的QNN SDK量化实战代码。掌握这些技术，开发者可以在X2 Elite平台上高效部署高质量的端侧大模型应用。

在下一篇文章中，我们将深入探讨大模型推理的系统级优化，包括NPU+CPU异构协同推理、流式推理流水线、KV Cache优化等高级技术，敬请期待。