Intel 模型优化栈：Optimum Intel / NNCF / OpenVINO 三件套选型

§1 开篇：三个工具，一个痛点

“我想把 Llama-3.1-8B 量化后跑在 Arc GPU 上。”

你打开 Optimum Intel 的文档，看到这样的代码：

model = OVModelForCausalLM.from_pretrained(model_id, load_in_8bit=True)

然后你翻到 NNCF 的文档，又看到：

quantized_model = nncf.quantize(model, calibration_dataset)

再看 OpenVINO 的文档：

ov_model = ov.convert_model(torch_model)
quantized = nncf.compress_weights(ov_model)

三个工具，都说能量化，到底该用哪个？它们是竞品关系吗？还是我需要三个都用？

答案是：它们不是竞品，而是一个三层栈。选择哪个取决于你的场景需求。本文给你判断框架。

§2 调用链剖析：三层不是三选一

核心洞察：Optimum Intel、NNCF、OpenVINO Core 不是竞争工具，而是一个 三层技术栈。

Optimum Intel（顶层）= Hugging Face API 兼容层 + 一键封装
NNCF（中层）= 压缩算法库 (PTQ / QAT / WOQ / AAQ / Sparsity)
OpenVINO Core（底层）= 格式转换 (→ IR) + 推理引擎

调用链路 1: load_in_8bit=True

当你写下这行代码：

model = OVModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B-Instruct", 
    load_in_8bit=True
)

背后发生了什么？从 Optimum Intel 的源码追踪调用链：

OVBaseModel.from_pretrained() 检测到 load_in_8bit=True 参数
内部创建 OVWeightQuantizationConfig(bits=8) 对象
映射 bits=8 → CompressWeightsMode.INT8_ASYM
调用 _apply_quantization() → OVQuantizer.quantize()
路由到 _weight_only_quantization() 方法
最终调用 nncf.compress_weights(model, dataset=None, mode=INT8_ASYM, ...)

关键细节：8-bit weight-only 量化不需要校准数据集（dataset=None），因为 INT8 的量化范围足够覆盖大部分权重分布，min-max 统计即可完成量化。

调用链路 2: load_in_4bit=True

4-bit 的路径类似，但有一个重要区别：

model = OVModelForCausalLM.from_pretrained(
    model_id, 
    load_in_4bit=True
)

调用链：

OVWeightQuantizationConfig(bits=4) → CompressWeightsMode.INT4_ASYM
路由到同样的 _weight_only_quantization() 方法
调用 nncf.compress_weights(model, mode=INT4_ASYM, dataset=..., ...)
但这次 dataset 不是 None——Optimum Intel 会自动下载 wikitext 数据集用于校准

为什么 INT4 需要校准而 INT8 不需要？因为 4-bit 量化的精度容错更低，必须用真实数据的激活值分布来确定最优的 scale 和 zero-point，否则精度会急剧下降。

调用链路 3: 全量化 (Weight + Activation)

如果你需要量化激活值（W8A8），Optimum Intel 使用不同的代码路径：

from optimum.intel import OVQuantizationConfig

config = OVQuantizationConfig(bits=8)
model = OVModelForCausalLM.from_pretrained(
    model_id, 
    quantization_config=config
)

调用链：

OVQuantizationConfig 被识别为”全量化”而非 weight-only
路由到 _full_quantization() 方法
调用 nncf.quantize(model, calibration_dataset, ...)
校准数据集是强制要求——没有数据集无法完成激活值量化

格式转换在哪里？

所有调用链的起点是：先转 OpenVINO IR，再量化。

如果 Hugging Face Hub 上已有 OpenVINO IR 格式的模型文件（openvino_model.xml + openvino_model.bin），from_pretrained() 会直接下载
如果只有 PyTorch checkpoint，Optimum Intel 调用 main_export() 函数（来自 optimum.exporters.openvino），它内部封装了 ov.convert_model()
如果输入是 ONNX 文件，直接调用 ov.convert_model(file_name)

最终，所有路径都汇聚到：OpenVINO IR → NNCF 量化 → 保存回 OpenVINO IR。

下面的交互组件展示了四种典型场景的完整调用链，点击每个场景可以看到具体的函数调用栈：

Intel 模型优化栈调用关系

三层架构：Optimum Intel → NNCF → OpenVINO Core

点击左侧层级或选择顶部场景查看详情

小结

三层栈的关系是：Optimum Intel 调用 NNCF，NNCF 操作 OpenVINO IR 格式的模型。你可以选择：

用 Optimum Intel：一行代码搞定，适合标准场景
绕过 Optimum，直接用 NNCF：需要自定义校准、精度约束、或不支持的模型架构
绕过 NNCF，直接用 OpenVINO Converter：模型源是 ONNX、需要图改写、或想避免 Python 依赖

下面的章节会告诉你如何判断何时选择哪层。

§3 NNCF 深潜：压缩算法体系

NNCF (Neural Network Compression Framework) 是 Intel 开源的模型压缩算法库，当前版本 v3.1.0 (2026-04-08)。它的设计哲学是：与训练框架解耦，支持多后端，只做压缩算法。

NNCF 的核心 API 分为三大类：

3.1 核心函数 1: nncf.quantize()

这是 全量化 (Weight + Activation PTQ) 的标准入口。

nncf.quantize(
    model: TModel,
    calibration_dataset: nncf.Dataset,
    *,
    mode: Optional[QuantizationMode] = None,           # FP8_E4M3 | FP8_E5M2
    preset: Optional[QuantizationPreset] = None,
    target_device: TargetDevice = TargetDevice.ANY,
    subset_size: int = 300,
    fast_bias_correction: bool = True,
    model_type: Optional[ModelType] = None,
    ignored_scope: Optional[IgnoredScope] = None,
    advanced_parameters: Optional[AdvancedQuantizationParameters] = None
) -> TModel

关键参数：

calibration_dataset：必填。NNCF 会在这个数据集上运行模型前向传播，收集每一层的激活值分布（min/max/percentile），用于确定量化参数
mode：可选 FP8_E4M3 (NVIDIA Hopper+) 或 FP8_E5M2（实验性）。不指定时默认 INT8
preset：PERFORMANCE（激进量化）或 MIXED（精度优先）
target_device：CPU / GPU / NPU / ANY。不同设备有不同的量化策略（如 NPU 可能更激进）
subset_size：校准时使用数据集的前多少个样本，默认 300（平衡精度与速度）
fast_bias_correction：是否启用快速 bias 校正（补偿量化引入的系统性偏差），默认开启

3.2 核心函数 2: nncf.compress_weights()

这是 weight-only 量化 的入口，支持极其丰富的压缩模式。

nncf.compress_weights(
    model: TModel,
    *,
    mode: CompressWeightsMode = CompressWeightsMode.INT8_ASYM,
    ratio: Optional[float] = None,
    group_size: Optional[int] = None,
    ignored_scope: Optional[IgnoredScope] = None,
    all_layers: Optional[bool] = None,
    dataset: Optional[nncf.Dataset] = None,
    sensitivity_metric: Optional[SensitivityMetric] = None,
    subset_size: int = 128,
    awq: Optional[bool] = None,
    scale_estimation: Optional[bool] = None,
    gptq: Optional[bool] = None,
    lora_correction: Optional[bool] = None,
    backup_mode: Optional[BackupMode] = None,
    compression_format: CompressionFormat = CompressionFormat.DQ,
    advanced_parameters: Optional[AdvancedCompressionParameters] = None
) -> TModel

CompressWeightsMode 枚举值（部分）：

INT8_SYM, INT8_ASYM — 8-bit 对称/非对称量化
INT4_SYM, INT4_ASYM — 4-bit 混合精度（主流）
NF4 — NormalFloat 4-bit，无 zero-point（QLoRA 同款）
FP8_E4M3, FP8_E5M2 — FP8 变体
MXFP4, MXFP8_E4M3 — Microscaling Floating Point
NVFP4 — NVIDIA FP4 (E4M3 group scale)
CODEBOOK, ADAPTIVE_CODEBOOK, CB4 — 查找表 (LUT) 量化

关键参数：

ratio：混合精度比例。例如 ratio=0.8 表示 80% 的层用 mode 指定的精度（如 INT4），剩余 20% 用 backup_mode（如 INT8 或 FP16）
group_size：分组量化的组大小。INT4 量化通常用 128 或 64，更小的 group 精度更高但开销更大
dataset：可选校准数据集。INT8 量化不需要（None），INT4/NF4 强烈推荐提供
sensitivity_metric：用于决定哪些层用高精度。可选值：
- WEIGHT_QUANTIZATION_ERROR — 权重量化误差最小化
- HESSIAN_INPUT_ACTIVATION — 基于 Hessian 矩阵的敏感度（精度最高，计算最贵）
- MEAN_ACTIVATION_VARIANCE / MAX_ACTIVATION_VARIANCE
- MEAN_ACTIVATION_MAGNITUDE
预处理算法开关（需要 dataset）：
- awq=True — Activation-Aware Quantization，根据激活值大小调整权重 scale
- scale_estimation=True — L2 误差最小化的 scale 估计
- gptq=True — 经典 GPTQ 算法（逐层最优化）
- lora_correction=True — 用低秩矩阵补偿量化误差（类似 LoRA）

为什么 INT8 不需要 dataset？

8-bit 量化的表示范围（-128 到 127）足够覆盖绝大多数权重分布，简单的 min-max 统计即可。但 4-bit 只有 16 个离散值，必须依赖真实激活值分布来优化 scale，否则会把重要权重映射到同一个离散值上，导致精度崩塌。

3.3 核心函数 3: nncf.quantize_with_accuracy_control()

这是 精度感知量化 (Accuracy-Aware Quantization, AAQ) 的入口。

nncf.quantize_with_accuracy_control(
    model: TModel,
    calibration_dataset: nncf.Dataset,
    validation_dataset: nncf.Dataset,
    validation_fn: Callable[[Any, Iterable[Any]], tuple[float, ...]],
    *,
    max_drop: float = 0.01,
    drop_type: DropType = DropType.ABSOLUTE,
    preset: Optional[QuantizationPreset] = None,
    target_device: TargetDevice = TargetDevice.ANY,
    subset_size: int = 300,
    fast_bias_correction: bool = True,
    model_type: Optional[ModelType] = None,
    ignored_scope: Optional[IgnoredScope] = None,
    advanced_quantization_parameters: Optional[AdvancedQuantizationParameters] = None,
    advanced_accuracy_restorer_parameters: Optional[AdvancedAccuracyRestorerParameters] = None
) -> TModel

关键差异：需要提供 validation_fn。

这个函数的工作流程：

先执行标准 PTQ 量化（调用 quantize()）
在 validation_dataset 上运行 validation_fn，计算精度指标（如 accuracy、perplexity）
如果精度下降超过 max_drop 阈值（如 0.01 = 1%），进入恢复流程：
- 逐层尝试”回滚”量化（该层用 FP16 而非 INT8）
- 每次回滚后重新运行 validation_fn
- 找到最小的回滚集合，使得精度满足约束
返回混合精度模型（部分层 INT8，部分层 FP16）

validation_fn 签名示例：

def validate_fn(model, validation_dataset):
    # 返回一个或多个指标（值越高越好）
    # NNCF 会比较量化前后的指标差异
    accuracy = compute_accuracy(model, validation_dataset)
    return (accuracy,)

与 AutoGPTQ/bitsandbytes 的区别：

AutoGPTQ/bitsandbytes 是”一次性量化”——指定 INT4 就全部 INT4，没有自动回滚机制
NNCF AAQ 是”迭代回滚”——你只需指定精度约束，算法自动找最优混合精度策略

为什么 Optimum Intel 不暴露这个 API？

因为 validation_fn 是高度任务相关的——不同任务需要不同的评估指标（代码生成用 pass@k，问答用 F1，对话用 perplexity）。Optimum Intel 的定位是”开箱即用”，不适合暴露需要用户自定义函数的 API。如果需要 AAQ，必须绕过 Optimum，直接用 NNCF。

3.4 QAT: 训练时量化

NNCF 支持 Quantization-Aware Training (QAT)，但仅限 PyTorch 后端：

import nncf

# 1. 用 NNCF 包装 PyTorch 模型
nncf_config = nncf.NNCFConfig.from_dict({
    "input_info": {"sample_size": [1, 3, 224, 224]},
    "compression": {"algorithm": "quantization"}
})
nncf_network = nncf.NNCFNetwork(torch_model, nncf_config)

# 2. 正常训练（前向、反向、优化器更新）
for batch in train_loader:
    loss = nncf_network(batch)
    loss.backward()
    optimizer.step()

# 3. 导出量化模型
quantized_model = nncf_network.export_model()

QAT 的核心是：在训练时插入 伪量化节点 (Fake Quantization)，让梯度反向传播时模拟量化误差，模型学会对量化鲁棒。这比 PTQ 精度更高，但需要训练资源。

3.5 支持矩阵

下面的交互组件展示了 NNCF 的算法 × 后端支持矩阵：

NNCF 算法支持矩阵

6 种算法 × 4 个后端

算法	OpenVINO	PyTorch	TorchFX	ONNX
训练后量化 (PTQ)
权重压缩 (WOQ)
量化感知训练 (QAT)
Weight-Only QAT + LoRA/NLS
剪枝 (Pruning)
激活稀疏 (Activation Sparsity)

* PTQ 也支持 accuracy-aware 变体 nncf.quantize_with_accuracy_control()，仅 OpenVINO 后端

✓支持

⚠实验性

✗不支持

几个重要说明：

OpenVINO 后端是 PTQ/WOQ 的首选——最成熟，性能最优
TorchFX 标注为 Experimental——PTQ 和 WOQ 可用，但可能有边界情况 bug
Activation Sparsity 仅 PyTorch Experimental——非生产就绪
AAQ 不是独立行——它是 quantize() 的 API 变体（quantize_with_accuracy_control），仅支持 OpenVINO 后端
Weight-Only QAT with LoRA/NLS——新增功能（v3.1.0），体现 LLM 时代特色

§4 Optimum Intel 的边界

现在回到开篇的问题：什么时候用 Optimum Intel 就够了？什么时候必须绕过它？

Optimum Intel 足够的场景

标准 Hugging Face 模型：transformers 库支持的架构（BERT、GPT、LLaMA、Mistral 等）
标准量化需求：INT8 或 INT4 weight-only，不需要自定义校准
不需要 AAQ：精度要求不那么严格，或可以接受”一次性量化”
快速原型：实验阶段，想快速验证 OpenVINO 能否在你的硬件上跑起来

示例代码（Optimum 一行调用）：

from optimum.intel import OVModelForCausalLM, OVWeightQuantizationConfig

model = OVModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B-Instruct",
    quantization_config=OVWeightQuantizationConfig(
        bits=4,
        sym=True,
        group_size=128,
        ratio=0.8
    )
)
model.save_pretrained("llama-3.1-8b-int4-ov")

这 6 行代码背后，Optimum Intel 自动完成了：

下载 PyTorch checkpoint（如果本地没有）
转换成 OpenVINO IR 格式
下载校准数据集（wikitext）
调用 NNCF 执行 INT4 对称量化（CompressWeightsMode.INT4_SYM）
80% 的层用 INT4，20% 用 backup_mode（默认 INT8）
保存量化后的 OpenVINO IR 文件（.xml + .bin）

必须绕过 Optimum Intel 的场景

需要 AAQ（精度感知量化）：quantize_with_accuracy_control 不暴露在 Optimum API 中
自定义校准数据集：你有领域特定的数据（如医疗对话、法律文档），不想用通用 wikitext
QAT（训练时量化）：Optimum Intel 只支持 PTQ
不支持的模型架构：如果 transformers 库不支持，Optimum Intel 也无法处理
需要控制预处理算法开关：如 awq=True、scale_estimation=True、gptq=True 等

示例代码（NNCF 完整控制）：

import nncf
import openvino as ov
from transformers import AutoModelForCausalLM
import torch

# 1. 加载 PyTorch 模型
torch_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B-Instruct",
    torch_dtype=torch.float16
)

# 2. 转换成 OpenVINO IR
ov_model = ov.convert_model(torch_model)

# 3. 准备校准数据集（自定义数据）
def calibration_data_generator():
    # 你的领域数据
    for text in medical_corpus:
        yield tokenizer(text, return_tensors="pt")

calibration_dataset = nncf.Dataset(calibration_data_generator)

# 4. NNCF 量化（完整参数控制）
quantized = nncf.compress_weights(
    ov_model,
    mode=nncf.CompressWeightsMode.INT4_SYM,
    group_size=128,
    ratio=0.8,
    sensitivity_metric=nncf.SensitivityMetric.HESSIAN_INPUT_ACTIVATION,
    dataset=calibration_dataset,
    subset_size=256,
    awq=True,
    scale_estimation=True
)

# 5. 保存
ov.save_model(quantized, "model.xml")

这段代码和 Optimum Intel 的区别：

可以自定义校准数据（medical_corpus）
可以指定 sensitivity_metric=HESSIAN_INPUT_ACTIVATION（Optimum 用默认值）
可以开启 awq=True 和 scale_estimation=True（Optimum 不暴露）
需要自己写 15 行代码（Optimum 只需 6 行）

权衡：Optimum Intel 是”易用性优先”，NNCF 是”控制力优先”。选择哪个取决于你的场景需求和对量化效果的要求。

§5 OpenVINO Converter 的独立场景

什么时候直接用 ov.convert_model()，绕过 Optimum 和 NNCF？

场景 1: 模型源是 ONNX

如果你的模型已经是 ONNX 格式（不是 Hugging Face checkpoint），直接用 OpenVINO Converter：

import openvino as ov

# ONNX → OpenVINO IR
ov_model = ov.convert_model("model.onnx")
ov.save_model(ov_model, "model.xml")

Optimum Intel 假设输入是 Hugging Face 模型，不支持 ONNX 输入。

场景 2: 需要自定义 example_input

对于动态形状的模型（如 LLM 的可变序列长度），ov.convert_model() 允许你指定 example_input 来设置输入 shape：

ov_model = ov.convert_model(
    torch_model,
    example_input={
        "input_ids": torch.zeros(1, 512, dtype=torch.long),
        "attention_mask": torch.ones(1, 512, dtype=torch.long)
    }
)

这在处理非标准输入结构时很有用（如多模态模型、encoder-decoder 架构）。

场景 3: 需要图改写

OpenVINO IR 是计算图格式。如果需要在量化前修改图结构（如移除 dropout、冻结 normalization 参数），可以用 OpenVINO 的图改写 API：

from openvino.runtime import Core, serialize

ov_model = ov.convert_model(torch_model)

# 移除 dropout 节点（推理时不需要）
# 修改 IR 的 XML 表示（需要自己解析/修改）
# ...

ov.save_model(ov_model, "model.xml")

Optimum Intel 不暴露图改写接口——它假设你直接量化原始模型。

场景 4: 避免 Hugging Face Hub 依赖

在生产部署时，你可能不想依赖 Hugging Face Hub（网络限制、离线环境、企业安全策略）。直接用 ov.convert_model() + ov.compile_model()，只需要 OpenVINO Runtime，不需要 transformers / optimum / safetensors 等依赖。

最小依赖部署脚本：

import openvino as ov
import numpy as np

# 只依赖 OpenVINO Runtime（C++ 库 + Python binding）
core = ov.Core()
model = core.read_model("model.xml")
compiled = core.compile_model(model, "GPU")

# 推理
input_ids = np.zeros((1, 512), dtype=np.int64)
output = compiled(input_ids)

这种模式在边缘设备（如工控机、嵌入式 Linux）上很常见。

§6 澄清：INC vs NNCF 的分化

在 Intel 的文档和社区讨论中，经常出现另一个工具：Intel Neural Compressor (INC)。它和 NNCF 是什么关系？

产品定位不同

INC：面向 Intel Gaudi AI 加速器 + Xeon/Core Ultra CPU 原生栈，不以 OpenVINO 为目标后端。主要场景是数据中心（Gaudi 集群）和服务器（Xeon）。最新版本 v3.7 (2025-12-25) 仍在积极维护。
NNCF：OpenVINO 生态的官方压缩库，也支持 PyTorch (torch.compile)、TorchFX、ONNX 后端。主要场景是客户端硬件（iGPU、Arc GPU、NPU）和边缘设备。

何时选 INC？

如果你的部署目标是：

Intel Gaudi 2/3 AI 加速器（数据中心 LLM 推理）
Xeon 服务器原生栈（不用 OpenVINO，直接用 PyTorch/IPEX）
Intel Core Ultra 笔记本 CPU（利用 AVX-512 / AMX 指令集，不走 NPU）

那么 INC 是更好的选择——它对这些硬件有专门优化，且不引入 OpenVINO Runtime 的开销。

何时选 NNCF？

如果你的部署目标是：

Intel iGPU (Iris Xe)
Intel Arc GPU (独立显卡)
Intel NPU (AI Boost)
跨平台模型（同时在 Intel + ARM + NVIDIA 上推理，用 ONNX 或 OpenVINO IR 作为中间格式）

那么 NNCF + OpenVINO 是首选——它们是 iGPU/Arc/NPU 的官方支持路径。

总结：INC 和 NNCF 不是竞品，而是不同产品线。INC = Gaudi/Xeon 原生栈，NNCF = OpenVINO 生态。选择取决于硬件目标。

§7 选型决策树

现在我们有了完整的知识图谱，该如何为具体场景选择工具组合？

下面的决策树通过 3 个核心问题逐步缩小选择范围：

Q1: 模型来源是什么？

Hugging Face Hub 上的 checkpoint：可以用 Optimum Intel，也可以用 NNCF（需要先手动转 IR）
本地 PyTorch state_dict：用 NNCF（先 ov.convert_model 再量化）
ONNX 文件：用 ov.convert_model + NNCF
非标准架构（如自研模型）：只能用 ov.convert_model + NNCF（Optimum Intel 不支持）

Q2: 量化需求是什么？

标准 INT8/INT4 weight-only：Optimum Intel 够用
需要 AAQ（精度约束）：必须用 NNCF quantize_with_accuracy_control
需要自定义校准数据：用 NNCF（自己构造 nncf.Dataset）
需要 QAT：必须用 NNCF（Optimum Intel 不支持训练时量化）
需要预处理算法（AWQ/GPTQ/scale_estimation）：用 NNCF（Optimum 不暴露开关）

Q3: 部署场景是什么？

快速原型/实验：用 Optimum Intel（一行代码，快速验证可行性）
生产部署（精度敏感）：用 NNCF AAQ（自动找最优混合精度）
边缘设备（最小依赖）：用 ov.convert_model + NNCF + OpenVINO Runtime（不依赖 transformers/optimum）
非 OpenVINO 场景（如 PyTorch Mobile）：用 NNCF 的 PyTorch 后端（输出 TorchScript）

下面的交互组件实现了完整的决策树，点击选项逐步展开，到达推荐方案：

Intel 工具选择决策树

3 个问题引导工具选择

Q1: 模型源头？

典型决策路径示例

场景：Intel Arc GPU + LLaMA-3.1-8B + 医疗代码生成（精度敏感）

决策路径：

Q1 模型来源：Hugging Face Hub → 可以用 Optimum 或 NNCF
Q2 量化需求：精度敏感 → 需要 AAQ → 必须用 NNCF
Q3 部署场景：生产部署 → 用 AAQ

推荐方案：

import nncf
import openvino as ov
from transformers import AutoModelForCausalLM

# 1. 加载模型并转 OpenVINO IR
torch_model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B-Instruct")
ov_model = ov.convert_model(torch_model)

# 2. 准备医疗代码数据集
calibration_dataset = nncf.Dataset(medical_code_generator)
validation_dataset = nncf.Dataset(medical_code_eval_generator)

# 3. AAQ 量化
def validation_fn(model, val_data):
    # 评估代码生成质量（如 pass@1）
    accuracy = evaluate_code_generation(model, val_data)
    return (accuracy,)

quantized = nncf.quantize_with_accuracy_control(
    ov_model,
    calibration_dataset=calibration_dataset,
    validation_dataset=validation_dataset,
    validation_fn=validation_fn,
    max_drop=0.01,  # 精度下降不超过 1%
    drop_type=nncf.DropType.ABSOLUTE
)

# 4. 保存并编译
ov.save_model(quantized, "llama-3.1-8b-medical-aaq.xml")
core = ov.Core()
compiled = core.compile_model(quantized, "GPU")

关键点：

不能用 Optimum Intel，因为它不暴露 validation_fn 参数
AAQ 会自动为敏感层（如 attention 层）保留高精度，为不敏感层（如 FFN）用 INT8
max_drop=0.01 保证代码生成质量不下降超过 1%（医疗场景的严格约束）

§8 过渡到动手指南

选型框架清楚了，下一步是动手实践。

在下一篇 《Intel 优化栈动手指南：三条路径对比实战》 中，我们将用同一个模型（LLaMA-3.1-8B）分别执行三种转换路径：

Hugging Face → GGUF（llama.cpp 栈）
Hugging Face → ONNX（ONNX Runtime 栈）
Hugging Face → OpenVINO IR（Optimum Intel + NNCF 栈）

然后在 Intel iGPU 上运行推理，对比三条路径的：

转换流程复杂度（需要几个命令？配置参数多复杂？）
量化后模型大小（15GB → 多少 GB？）
推理速度（tokens/s）
精度损失（perplexity、MMLU、HumanEval）

通过实战对比，你会获得选型决策的”肌肉记忆”——不仅知道理论上该选什么，更知道实际操作中每条路径的坑和优势。

预告：动手指南会包含完整的可复现脚本（从模型下载到推理部署），以及针对常见报错的 troubleshooting 章节（如”为什么 OpenVINO 检测不到我的 iGPU？”、“NNCF 校准数据集 OOM 怎么办？”）。