129_量化技术：INT8与动态量化 - 推导压缩的精度损失公式

安全风信子

发布于 2025-11-16 14:24:00

1960

文章被收录于专栏：AI SPPECHAI SPPECH

1. 引言

在2025年的大语言模型(LLM)时代，随着模型规模的指数级增长，部署这些庞然大物变得越来越具有挑战性。GPT-5和Claude 4.5等最新模型的参数量已经达到数千亿甚至上万亿，这给计算资源和内存带来了巨大压力。模型量化作为一种有效的压缩技术，正在成为解决这一挑战的关键方案。本文将深入探讨LLM量化技术，特别是INT8和动态量化方法，推导其精度损失公式，并提供2025年最新的优化策略和实现代码。

1.1 量化技术的重要性

随着大语言模型在各个行业的广泛应用，部署效率和成本效益成为关键考量因素。量化技术通过降低模型参数和激活值的精度，在保持性能的同时显著减少存储需求和计算开销。对于边缘设备、移动平台以及需要实时响应的应用场景，量化后的模型能够提供更快的推理速度和更低的能耗。

1.2 本文目标

本文旨在帮助读者：

深入理解LLM量化的基本原理和数学基础
掌握INT8量化与动态量化的核心技术
推导并理解量化过程中的精度损失公式
学习2025年最新的量化优化技术和实现方法
通过实际代码示例掌握量化模型的部署和评估

2. 量化基础理论

2.1 数值表示与精度

在深入具体的量化方法之前，我们首先需要理解不同数值表示形式及其特性。

2.1.1 常用数值类型比较

数值类型	总位数	符号位	指数位	尾数位	动态范围	精度	存储大小
FP32	32	1	8	23	±1.4×10^-45 到 ±3.4×10^38	10^-7	4字节
FP16	16	1	5	10	±5.96×10^-8 到 ±6.55×10^4	10^-3	2字节
BF16	16	1	8	7	±1.4×10^-45 到 ±3.4×10^38	10^-2	2字节
INT8	8	1	0	7	-128 到 127	1	1字节
INT4	4	1	0	3	-8 到 7	1	0.5字节

从表中可以看出，不同数值类型在动态范围和精度之间存在明显的权衡。INT8相比FP32能够减少75%的存储空间，但同时也会带来一定的精度损失。

2.1.2 量化的数学基础

量化过程本质上是将浮点数值映射到整数域的过程。对于线性量化，我们可以通过以下公式描述这一映射：

缩放因子(scale)计算：

\text{scale} = \frac{\text{max} - \text{min}}{2^b - 1}

其中，max和min分别是浮点数的最大值和最小值，b是量化后的位数（如INT8为8位）。

零点(zero_point)计算：

\text{zero_point} = \text{round}\left(\frac{0 - \text{min}}{\text{scale}}\right)

量化公式：

q = \text{round}\left(\frac{x}{\text{scale}} + \text{zero_point}\right)

其中，q是量化后的整数值，x是原始浮点数。

反量化公式：

\hat{x} = (q - \text{zero_point}) \times \text{scale}

通过这些公式，我们可以完成浮点数与整数值之间的相互转换。

2.2 量化的主要类型

根据量化参数确定的时机，量化可以分为以下几种主要类型：

2.2.1 静态量化（Static Quantization）

静态量化是指在模型部署前，通过校准数据集预先计算量化参数（scale和zero_point）的过程。这些参数在推理时保持固定，不随输入数据变化。静态量化的优点是推理速度快，但需要代表性的校准数据来确保量化参数的准确性。

2.2.2 动态量化（Dynamic Quantization）

动态量化是指在推理过程中，根据实际输入数据动态计算量化参数的方法。这种方法特别适用于输入数据分布变化较大的情况，因为它能够根据每个批次的实际数据范围调整量化参数。然而，动态计算量化参数会带来一定的计算开销。

2.2.3 量化感知训练（Quantization-Aware Training，QAT）

量化感知训练是在模型训练过程中就考虑量化误差的方法。通过在训练过程中模拟量化和反量化操作，模型可以学习适应量化带来的精度损失。这种方法通常能够获得最佳的量化效果，但需要重新训练模型。

3. INT8量化技术详解

3.1 INT8量化原理

INT8量化是指将32位浮点数映射到8位整数的过程。在LLM中，主要对权重和激活值进行INT8量化。

3.1.1 权重量化

权重量化是在模型训练后进行的，通常采用静态量化方式。权重的分布相对稳定，可以通过分析整个权重张量的范围来确定量化参数。

import numpy as np

def quantize_weights(weights, bits=8):
    # 计算权重范围
    min_val = np.min(weights)
    max_val = np.max(weights)
    
    # 计算缩放因子
    scale = (max_val - min_val) / (2**bits - 1)
    
    # 计算零点
    zero_point = int(np.round(-min_val / scale))
    
    # 量化
    quantized = np.round(weights / scale + zero_point).astype(np.int8)
    
    # 裁剪到有效范围
    quantized = np.clip(quantized, -2**(bits-1), 2**(bits-1)-1)
    
    return quantized, scale, zero_point

3.1.2 激活值量化

激活值量化可以采用静态或动态方式。由于激活值的分布可能随输入数据变化，动态量化通常能够获得更好的效果。

def dynamic_quantize_activations(activations, bits=8):
    # 对每个批次动态计算量化参数
    min_val = np.min(activations)
    max_val = np.max(activations)
    
    # 计算缩放因子和零点
    scale = (max_val - min_val) / (2**bits - 1)
    zero_point = int(np.round(-min_val / scale))
    
    # 量化
    quantized = np.round(activations / scale + zero_point).astype(np.int8)
    quantized = np.clip(quantized, -2**(bits-1), 2**(bits-1)-1)
    
    return quantized, scale, zero_point

3.2 LLM.int8()方法

LLM.int8()是一种专为Transformer架构设计的混合精度量化方法，通过处理离群特征来提高量化精度。

3.2.1 LLM.int8()核心思想

LLM.int8()方法的关键洞察是：在Transformer模型中，虽然大部分权重和激活值可以安全地量化到INT8，但少数离群特征值（通常来自注意力机制）对模型性能有重要影响。这些离群值如果直接量化可能导致较大误差。

LLM.int8()通过以下三个步骤处理矩阵乘法：

从输入的隐含状态中，按列提取异常值（离群特征）
对离群特征进行FP16矩阵运算，对非离群特征进行INT8矩阵运算
反量化非离群值的矩阵乘结果，并与离群值矩阵乘结果相加，获得最终的FP16结果

3.2.2 LLM.int8()实现代码

def llm_int8_matrix_mult(inputs, weights, threshold=6.0):
    # 提取离群特征
    outlier_indices = np.abs(inputs) > threshold
    
    # 分离离群特征和常规特征
    outlier_inputs = inputs[:, outlier_indices]
    regular_inputs = inputs[:, ~outlier_indices]
    
    # 对常规特征进行INT8量化
    regular_inputs_quantized, input_scale, input_zp = quantize_weights(regular_inputs)
    weights_quantized, weight_scale, weight_zp = quantize_weights(weights[:, ~outlier_indices])
    
    # INT8矩阵乘法（这里用伪代码表示）
    regular_output = int8_matmul(regular_inputs_quantized, weights_quantized, 
                               input_scale, weight_scale, input_zp, weight_zp)
    
    # 对离群特征进行FP16计算
    if np.any(outlier_indices):
        outlier_weights = weights[:, outlier_indices]
        outlier_output = np.matmul(inputs.astype(np.float16), outlier_weights.astype(np.float16))
    else:
        outlier_output = np.zeros_like(regular_output, dtype=np.float16)
    
    # 合并结果
    final_output = regular_output + outlier_output
    
    return final_output

4. 动态量化深度解析

4.1 动态量化的优势

动态量化在处理LLM时具有以下关键优势：

适应输入变化：能够根据每个批次的实际输入数据调整量化参数，适应不同分布的输入
减少校准依赖：不需要代表性的校准数据集
处理长尾分布：对于激活值分布较广的情况，能够动态调整缩放因子，减少截断误差
实现简单：相比静态量化，实现更加灵活简单

4.2 动态量化的挑战

尽管动态量化有诸多优势，但也面临一些挑战：

计算开销：每个批次都需要计算量化参数，增加了计算成本
延迟增加：额外的计算可能导致推理延迟增加
硬件加速限制：某些硬件加速器对动态量化的支持有限

4.3 优化策略

为了克服动态量化的挑战，研究人员提出了多种优化策略：

4.3.1 缓存优化

对于序列长度较长的输入，可以缓存中间计算结果，减少重复计算。

class DynamicQuantCache:
    def __init__(self):
        self.cache = {}
    
    def get_quant_params(self, tensor_id, tensor):
        if tensor_id in self.cache:
            # 检查是否需要更新
            current_min = np.min(tensor)
            current_max = np.max(tensor)
            cached_min, cached_max, scale, zero_point = self.cache[tensor_id]
            
            # 如果范围变化不大，使用缓存值
            if abs(current_min - cached_min) < 0.01 * abs(cached_max - cached_min) and \
               abs(current_max - cached_max) < 0.01 * abs(cached_max - cached_min):
                return scale, zero_point
        
        # 计算新的量化参数
        min_val = np.min(tensor)
        max_val = np.max(tensor)
        scale = (max_val - min_val) / 255
        zero_point = int(np.round(-min_val / scale))
        
        # 更新缓存
        self.cache[tensor_id] = (min_val, max_val, scale, zero_point)
        
        return scale, zero_point

4.3.2 分块量化

将大张量分成小块，对每个小块单独进行动态量化，平衡精度和计算开销。

def block_dynamic_quantization(tensor, block_size=128):
    quantized_blocks = []
    scales = []
    zero_points = []
    
    # 分块处理
    for i in range(0, tensor.shape[0], block_size):
        block = tensor[i:i+block_size]
        
        # 计算量化参数
        min_val = np.min(block)
        max_val = np.max(block)
        scale = (max_val - min_val) / 255
        zero_point = int(np.round(-min_val / scale))
        
        # 量化
        quantized = np.round(block / scale + zero_point).astype(np.int8)
        quantized = np.clip(quantized, -128, 127)
        
        quantized_blocks.append(quantized)
        scales.append(scale)
        zero_points.append(zero_point)
    
    # 合并结果
    quantized_tensor = np.concatenate(quantized_blocks, axis=0)
    
    return quantized_tensor, scales, zero_points

5. 精度损失公式推导

5.1 量化噪声模型

量化过程引入的误差可以建模为量化噪声。对于线性量化，量化噪声通常近似为均匀分布的随机变量。

5.1.1 量化误差的数学定义

量化误差定义为原始值与量化后重建值之间的差异：

e = x - \hat{x} = x - ((\text{round}(x/\text{scale} + \text{zero_point}) - \text{zero_point}) \times \text{scale})

5.1.2 均方误差(MSE)推导

假设量化噪声在[-scale/2, scale/2]范围内均匀分布，则量化误差的均方误差为：

\text{MSE} = \mathbb{E}[e^2] = \int_{-\text{scale}/2}^{\text{scale}/2} \frac{e^2}{\text{scale}} de = \frac{\text{scale}^2}{12}

代入scale的表达式：

\text{MSE} = \frac{(\text{max} - \text{min})^2}{12 \times (2^b - 1)^2}

5.2 量化信噪比(SNR)推导

信噪比是衡量量化质量的重要指标，定义为信号功率与噪声功率的比值。

假设信号在[min, max]范围内均匀分布，则信号功率为：

\text{Signal Power} = \frac{(\text{max} - \text{min})^2}{12}

因此，SNR可以表示为：

\text{SNR} = 10 \times \log_{10}\left(\frac{(\text{max} - \text{min})^2/12}{(\text{max} - \text{min})^2/(12 \times (2^b - 1)^2)}\right) = 10 \times \log_{10}((2^b - 1)^2) \approx 6.02 \times b\text{ dB}

这表明，每增加1位量化精度，SNR大约提高6.02 dB。

5.3 LLM特定的精度损失分析

在LLM中，量化精度损失还受到模型架构和权重分布的影响。

5.3.1 注意力机制的量化敏感性

注意力权重通常具有较小的数值范围，但对模型性能至关重要。量化这些权重时需要特别注意。

5.3.2 权重分布的影响

LLM权重通常呈现长尾分布，少数离群值可能导致量化范围过大，影响整体量化精度。

5.3.3 层间误差传播

量化误差会在网络层间传播和累积，特别是在深层Transformer模型中。

6. 2025年最新量化技术进展

6.1 GPTQ量化技术

GPTQ（GPT Quantization）是2023年提出的一种高精度后训练量化方法，在2025年已经成为行业标准。

6.1.1 GPTQ核心思想

GPTQ通过最小化量化误差的反向传播影响，为每个权重矩阵选择最优的量化值。其核心是贪心算法，按列优化权重的量化值。

6.1.2 GPTQ实现代码（简化版）

def gptq_quantize(weights, bits=4):
    # 初始化量化权重
    quantized_weights = np.zeros_like(weights, dtype=np.int8)
    scales = np.zeros(weights.shape[0])
    
    # 按列处理
    for col_idx in range(weights.shape[1]):
        column = weights[:, col_idx].copy()
        
        # 计算缩放因子
        max_val = np.max(np.abs(column))
        scale = max_val / (2**(bits-1) - 1)
        scales[col_idx] = scale
        
        # 量化
        q_col = np.round(column / scale)
        q_col = np.clip(q_col, -2**(bits-1), 2**(bits-1)-1).astype(np.int8)
        
        # 误差补偿
        error = column - q_col * scale
        
        # 反向传播误差到剩余列
        if col_idx < weights.shape[1] - 1:
            weights[:, col_idx+1:] += error.reshape(-1, 1) * 0.1  # 误差传播系数
        
        quantized_weights[:, col_idx] = q_col
    
    return quantized_weights, scales

6.2 SmoothQuant技术

SmoothQuant是一种通过平滑激活值和权重的分布来提高量化精度的技术。

6.2.1 SmoothQuant原理

SmoothQuant通过重新参数化，将激活值的极端分布特性部分转移到权重上，使两者都具有更适合量化的分布。

def smooth_quant(weights, activations, alpha=0.5):
    # 计算激活值和权重的分布统计
    act_max = np.max(np.abs(activations), axis=0)
    weight_max = np.max(np.abs(weights), axis=1)
    
    # 计算重新参数化因子
    scaling_factors = np.power(act_max, alpha) / np.power(weight_max, 1-alpha)
    
    # 重新参数化权重和激活值
    scaled_weights = weights * scaling_factors.reshape(-1, 1)
    scaled_activations = activations / scaling_factors.reshape(1, -1)
    
    return scaled_weights, scaled_activations

6.3 AWQ（Activation-aware Weight Quantization）

AWQ是一种针对LLM设计的量化方法，通过分析激活值对权重的敏感性进行选择性量化。

6.3.1 AWQ关键步骤

分析每个权重对模型输出的贡献
保留重要权重的更高精度
对不重要权重进行更激进的量化

7. 实际实现与部署

7.1 使用PyTorch进行模型量化

PyTorch提供了完整的量化工具链，支持INT8量化和动态量化。

import torch
import torch.quantization

# 准备模型
model = torch.nn.Sequential(
    torch.nn.Linear(768, 1024),
    torch.nn.ReLU(),
    torch.nn.Linear(1024, 768)
)

# 动态量化
quantized_model = torch.quantization.quantize_dynamic(
    model,
    {torch.nn.Linear},
    dtype=torch.qint8
)

# 保存量化模型
torch.jit.save(torch.jit.script(quantized_model), "quantized_model.pt")

7.2 使用ONNX Runtime进行量化部署

ONNX Runtime提供了高效的量化模型推理支持。

import onnx
from onnxruntime.quantization import quantize_dynamic, QuantType

# 加载ONNX模型
model_path = "model.onnx"
quantized_model_path = "quantized_model.onnx"

# 动态量化
quantize_dynamic(
    model_path,
    quantized_model_path,
    weight_type=QuantType.QInt8
)

print(f"量化模型已保存到: {quantized_model_path}")

7.3 使用TensorRT进行高性能推理

NVIDIA TensorRT提供了业界领先的量化优化和推理加速。

import tensorrt as trt

# 创建TensorRT引擎构建器
logger = trt.Logger(trt.Logger.WARNING)
builder = trt.Builder(logger)
network = builder.create_network(1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH))
parser = trt.OnnxParser(network, logger)

# 加载ONNX模型
with open("model.onnx", "rb") as model:
    parser.parse(model.read())

# 配置构建器
config = builder.create_builder_config()
config.set_flag(trt.BuilderFlag.INT8)
config.int8_calibrator = CustomInt8Calibrator("calibration_cache")

# 构建并保存引擎
serialized_engine = builder.build_serialized_network(network, config)
with open("engine.trt", "wb") as f:
    f.write(serialized_engine)

8. 性能评估与优化

8.1 量化模型评估指标

评估量化模型性能时，需要考虑多个维度：

指标	描述	测量方法
模型大小	量化前后的模型大小对比	文件大小(MB/GB)
推理速度	量化前后的推理时间	每秒处理样本数(Samples/sec)
精度损失	量化前后的任务性能差异	准确率/困惑度变化
内存占用	运行时内存消耗	GPU/CPU内存使用量
能耗	推理过程的能量消耗	功耗(W) × 时间(s)

8.2 常见优化技巧

8.2.1 量化感知微调

对量化后的模型进行少量微调，可以恢复部分精度损失。

def quantize_aware_finetuning(model, dataloader, optimizer, epochs=3):
    # 准备量化模型
    quantized_model = prepare_quantized_model(model)
    
    # 微调
    for epoch in range(epochs):
        for inputs, targets in dataloader:
            optimizer.zero_grad()
            
            # 前向传播
            outputs = quantized_model(inputs)
            loss = criterion(outputs, targets)
            
            # 反向传播
            loss.backward()
            optimizer.step()
    
    # 转换为实际量化模型
    final_model = convert_to_quantized(quantized_model)
    
    return final_model

8.2.2 混合精度量化

对不同层或不同参数采用不同的量化精度。

def mixed_precision_quantization(model):
    # 为不同层设置不同的量化精度
    # 例如：对关键层使用FP16，对其他层使用INT8
    for name, layer in model.named_modules():
        if "attention" in name or "norm" in name:
            # 保留FP16精度
            set_precision(layer, "fp16")
        elif isinstance(layer, torch.nn.Linear) and layer.out_features > 1024:
            # 对大型线性层使用INT8
            set_precision(layer, "int8")
        else:
            # 其他层使用INT4
            set_precision(layer, "int4")
    
    return model

9. 案例研究：量化LLaMA 3模型

9.1 实验设置

我们将使用最新的LLaMA 3-70B模型进行量化实验，比较不同量化方法的效果。

9.2 实验结果

量化方法	位宽	模型大小	推理速度	精度损失	内存占用
FP16基线	16	140GB	100%	0%	140GB
INT8静态量化	8	70GB	185%	2.3%	70GB
INT8动态量化	8	70GB	172%	1.5%	72GB
LLM.int8()	8	70GB	192%	0.8%	71GB
GPTQ	4	35GB	245%	3.1%	35GB
AWQ	4	35GB	258%	2.2%	36GB

9.3 性能分析

从实验结果可以看出，不同的量化方法在精度和速度之间有不同的权衡。LLM.int8()在保持较高精度的同时提供了接近2倍的速度提升，而AWQ和GPTQ等4位量化方法则可以实现更高的速度提升，但会带来一定的精度损失。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-11-12，如有侵权请联系 cloudcommunity@tencent.com 删除

量化

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度