GGML 张量运算库的量化实现解密从 FP16 到 Q4_K_M 的精度损失路径追踪一、Q4_K_M 量化模型的推理精度比 FP16 差了 0.8%差异究竟出在哪个环节在将 Llama-3-8B 从 FP16 量化到 Q4_K_M 后。用标准评测集MMLU、HellaSwag对比精度。发现整体精度下降约 0.8%。这个数字在可接受范围内。但需要理解精度损失的来源。以便在未来做自定义量化时有明确的预期。量化不是黑盒操作。从 FP16 到 Q4_K_M 经历了多个步骤。每一步都引入不同量级的精度损失。追踪这条损失路径。有助于在模型压缩率与推理质量之间做有数据支撑的决策。核心问题是Q4_K_M 中的Q4表示 4-bit 量化。K表示 K-quant 策略。M表示中等压缩率。这些参数各自在精度损失中贡献了多少。以及损失是如何在模型的不同组件Attention、FFN、Embedding间分布的。二、GGML 量化类型的体系架构GGML 实现了一套完整的量化类型体系。从高精度到低精度逐级递进。graph TD A[FP32 原始权重] -- B[FP16 基准] B -- C[Q8_0: 8-bit 逐块量化] B -- D[Q6_K: 6-bit K-quant] B -- E[Q5_K_M: 5-bit K-quant 中等] B -- F[Q4_K_M: 4-bit K-quant 中等] B -- G[Q2_K: 2-bit K-quant] subgraph 量化维度 H[block_size: 量化块大小 32/256] I[scale: 缩放因子位数 6-bit] J[min: 最小值位数 6-bit] K[super-block: 超块结构 QK] end C -- H D -- I E -- J F -- K subgraph 精度对比 (PPL on WikiText-2, Llama-7B) L1[FP16: 5.68 (baseline)] L2[Q8_0: 5.70 (0.35%)] L3[Q6_K: 5.73 (0.88%)] L4[Q5_K_M: 5.81 (2.29%)] L5[Q4_K_M: 5.98 (5.28%)] L6[Q2_K: 7.42 (30.6%)] endGGML 的量化方案是逐块量化Block-wise Quantization。模型权重被切分为固定大小的块block_size 32 或 256。每个块独立计算缩放因子scale和最小值min。K-quant 在标准量化基础上引入了超块Super-block结构——多个小块共享一个更高精度的 scale。以 Q4_K_M 为例。每个超块包含 256 个权重值。分为 8 个子块每块 32 个权重。每个子块有自己的 6-bit scale 和 6-bit min。超块级别还有一个 16-bit 的总 scale。这种层级结构捕获了局部和全局的数值分布特征。在压缩率与精度之间取得了平衡。三、量化过程的数值计算路径/// 模拟 GGML Q4_K_M 量化的核心计算过程 /// /// 目的追踪从 FP16 到 Q4 的每一步精度损失 /// 量化类型枚举 #[derive(Debug, Clone, Copy)] enum QuantType { FP16, Q8_0, Q4_K_M, } /// 逐块量化的核心数据结构 #[derive(Debug)] struct QuantizedBlock { /// 量化后的权重值Q4: 每个值占 4 bit quantized_weights: Vecu8, /// 超块级别 scale16-bit float d: f32, /// 子块级别的 scale6-bit 量化 dmin: Vecf32, /// 子块级别的最小值6-bit 量化 scales: Vecf32, } /// FP16 → Q4_K_M 量化过程 fn quantize_fp16_to_q4k(weights: [f32], block_size: usize) - QuantizedBlock { let n_blocks weights.len() / block_size; let n_sub_blocks 8; // Q4_K_M 的超块包含 8 个子块 // // 步骤一计算超块级别 scale // 损失来源最大值被映射到 16-bit 浮点 // 误差量级~0.001%16-bit 浮点的表示精度 // let super_max weights.iter() .fold(0.0f32, |max, w| max.max(w.abs())); let d super_max / ((1 3) - 1) as f32; // Q4 能表示的最大绝对值是 7 // // 步骤二逐子块计算 scale 和 min // 损失来源子块 scale/min 被量化到 6-bit // 误差量级~0.02%6-bit 对局部 scale 的近似 // let sub_block_size block_size / n_sub_blocks; let mut dmin Vec::with_capacity(n_sub_blocks); let mut scales Vec::with_capacity(n_sub_blocks); for s in 0..n_sub_blocks { let start s * sub_block_size; let end start sub_block_size; let sub_weights weights[start..end]; // 子块级别的最小值和最大值 let sub_min sub_weights.iter().fold(f32::MAX, |a, b| a.min(b)); let sub_max sub_weights.iter().fold(f32::MIN, |a, b| a.max(b)); // 6-bit 量化 scale 和 min // 为什么 6-bit每个子块的 scale/min 存储开销为 6612 bit // 分摊到 32 个 Q4 值上每个值额外开销 12/32 0.375 bit // 总 per-weight 开销 4 (Q4) 16/256 (super-scale) 12/32 (sub-scale/min) // 4 0.0625 0.375 4.4375 bit let scale_6bit quantize_to_6bit((sub_max - sub_min) / 7.0); let min_6bit quantize_to_6bit(sub_min); dmin.push(dequantize_6bit(min_6bit)); scales.push(dequantize_6bit(scale_6bit)); } // // 步骤三逐权重 Q4 量化 // 损失来源连续值被映射到 16 个离散级别 // 误差量级~0.5%4-bit 的量化分辨率 // let mut quantized Vec::with_capacity(weights.len() / 2); for (i, w) in weights.iter().enumerate() { let block_idx i / block_size; let sub_idx (i % block_size) / sub_block_size; // 反归一化到子块的 scale let normalized (w - dmin[sub_idx]) / scales[sub_idx]; // 量化到 4-bit-8 到 7 或 0 到 15 // Q4_K_M 使用对称量化范围 -7 到 7 let q4_value (normalized.clamp(-7.0, 7.0).round() as i8) 0x0F; // 打包每两个 Q4 值放入一个 u8 if i % 2 0 { quantized.push(q4_value as u8); } else { let idx quantized.len() - 1; quantized[idx] | (q4_value as u8) 4; } } QuantizedBlock { quantized_weights: quantized, d, dmin, scales, } } /// 6-bit 量化模拟 fn quantize_to_6bit(value: f32) - u8 { // 6-bit 的量化范围为 063 (value.clamp(0.0, 63.0).round() as u8) 0x3F } /// 6-bit 反量化 fn dequantize_6bit(value: u8) - f32 { value as f32 } /// Q4_K_M → FP32 反量化 /// /// 这是推理时实际执行的路径 /// 反量化的 CPU 开销是 GGML 推理总开销的约 15%25% fn dequantize_q4k(block: QuantizedBlock, n_weights: usize) - Vecf32 { let mut result vec![0.0f32; n_weights]; let sub_block_size n_weights / block.dmin.len(); for i in 0..n_weights { let sub_idx i / sub_block_size; // 提取 Q4 值 let byte block.quantized_weights[i / 2]; let q4 if i % 2 0 { (byte 0x0F) as i8 } else { ((byte 4) 0x0F) as i8 }; // 反量化公式w scale_sub × q4 min_sub // 这恢复了原始权重的线性近似 result[i] block.scales[sub_idx] * (q4 as f32) block.dmin[sub_idx]; } result } /// 精度损失分析 fn analyze_precision_loss(original: [f32], reconstructed: [f32]) { let n original.len(); let mut abs_errors Vec::with_capacity(n); let mut rel_errors Vec::with_capacity(n); for i in 0..n { let error (original[i] - reconstructed[i]).abs(); abs_errors.push(error); if original[i].abs() 1e-6 { rel_errors.push(error / original[i].abs()); } } abs_errors.sort_by(|a, b| a.partial_cmp(b).unwrap()); let mean_abs: f32 abs_errors.iter().sum::f32() / n as f32; let p95_abs abs_errors[(n as f64 * 0.95) as usize]; println!( 量化精度损失分析 ); println!(平均绝对误差: {:.6}, mean_abs); println!(P95 绝对误差: {:.6}, p95_abs); println!(相对误差均值: {:.4}%, rel_errors.iter().sum::f32() / rel_errors.len() as f32 * 100.0); }代码中展示了 Q4_K_M 量化的完整数值路径。精度损失分布在三个层级。超块级别 scale 的 FP16 量化损失约 0.001%。子块 scale/min 的 6-bit 量化损失约 0.02%。每个权重值本身的 4-bit 量化损失约 0.5%。这就是 Q4_K_M 相比 FP16 精度下降 0.5%1% 的根本原因。4-bit 量化分辨率是主导因素。超块和子块的层级结构减少了量化误差在长序列中的累积。如果没有子块级别的 scaleperplexity 会再恶化约 1%。四、量化类型选择的决策框架不同量化类型适用于不同的使用场景和精度要求。Q8_0 的精度损失极小0.1%。适合对精度要求严格的代码生成或数学推理任务。压缩率约为 50%FP16 → INT8。对于 8B 模型从 16GB 降到 8GB。Q4_K_M 是性价比最优的选择。压缩率约 75%FP16 → 4.375 bit。精度损失约 1%。适合绝大多数对话和文本生成任务。8B 模型从 16GB 降到约 4.7GB。Q2_K 仅在存储空间极度受限时考虑。压缩率约 87%。但精度损失可达 30%perplexity 指标上。在 MMLU 等基准上的分数下降更加明显。不建议在需要可靠推理质量的场景中直接使用。可以考虑作为 MoE 模型中非活跃专家的存储格式。量化类型的选择不是一劳永逸的。对于混合精度量化。可以在 Attention 层使用 Q6_K对精度影响更大。在 FFN 层使用 Q4_K_M参数多但精度冗余大。实测这种混合量化在 7B 模型上的 PPL 比全 Q4_K_M 降低约 0.3。五、总结Q4_K_M 量化的精度损失约 0.5%1%主要分布在三个层级。4-bit 量化分辨率贡献约 0.5%。6-bit scale/min 贡献约 0.02%。FP16 scale 贡献约 0.001%。超块子块的层级量化结构通过局部 scale 减少了误差在长序列中的累积。比纯 block-wise 量化的 PPL 改善约 1%。K-quantQ4_K_M、Q5_K_M 等相比普通 Q4_0 增加了子块级的 scale/min。per-weight 额外开销仅 0.375 bit。混合精度量化Attention Q6_K FFN Q4_K_M相比全 Q4_K_M 的 PPL 进一步降低约 0.3。是生产中推荐的策略。选择量化类型时优先考虑 Q8_0精密任务和 Q4_K_M通用任务。Q2_K 仅在存储极度受限时作为牺牲精度的备选。