模型量化完全指南:从一次"量化完模型变小了却答得驴唇不对马嘴"看懂量化工程

2024 年我想把一个 7B 的大模型,部署到一台显存不太够的机器上。我听说量化能让模型变小,于是第一版我做得很省事:找了个最激进的量化方式,把整个模型的权重一刀切压到 INT4。本地一测——真香:模型文件小了一大半,原本加载不进去的机器,现在能跑起来了。我心里很踏实:"量化嘛,不就是把模型压小,压小了能跑就行,质量顶多差一点点。"可等我真正拿它去回答问题,一串问题冒了出来。第一种:模型回答答非所问——你问 A,它扯到 B,逻辑完全乱了。第二种最吓人:它开始胡言乱语,蹦出一些不成句子的乱码字符。第三种:同样一个问题,全精度模型答得好好的,量化后就崩了。第四种:我换了一份校准数据重新量化,质量又变了一个样——我完全搞不清到底哪个环节在起作用。我盯着这一连串问题想了很久才彻底想明白,第一版错在一个根本的认知上:我以为"量化就是把模型压小,压小了能跑就行"。这句话把量化当成了一个无损的"打包压缩"。可它不是。量化的本质,是用"降低数值精度"去换"显存和速度"——它是一种实打实的有损压缩。你每压低一档精度,就丢掉一部分信息,而这些误差会在几十层网络里层层累积、放大。一刀切的激进量化,会让模型直接崩溃。真正用好量化,核心不是"选个最狠的方式把模型压到最小",而是理解量化误差从哪来、用校准数据和合适的粒度把误差摁住、分清哪些层根本不能碰。这篇文章就把模型量化梳理一遍:为什么"一刀切量化"会让模型崩、量化到底是怎么把浮点变成整数的、量化粒度该选 per-tensor 还是 per-channel、校准为什么必须用真实数据、哪些层是碰不得的敏感层,以及 KV Cache 量化、量化后评估这些把量化真正做对要避开的坑。

问题背景

先把那次量化翻车的现象和我的误判讲清楚,后面所有的设计都是冲着纠正这个误判去的。

现象:把一个 7B 模型一刀切量化到 INT4 后,模型确实变小、能加载了,但质量崩了:回答答非所问;蹦出不成句的乱码;全精度答得好的问题量化后就崩;换份校准数据质量又变一个样,搞不清哪个环节在起作用。

我当时的错误认知:"量化就是把模型压小,压小了能跑就行,质量顶多差一点点。"

真相:量化是一种有损压缩——用降低数值精度换显存和速度。每降一档精度都会引入误差,而误差会在深层网络里层层累积放大。量化真正的工程量,在于:理解浮点到整数的映射(scale 与 zero-point)、选对量化粒度对付离群值、用真实校准数据统计激活范围、识别并保护敏感层、量化后做完整评估对比掉点。让模型变小只是开头,让它变小之后还答得对才是关键。

要把模型量化做对,需要几块认知:

• 为什么"一刀切量化"会让模型崩——量化是有损压缩,误差会累积;
• 量化的本质——浮点到整数的映射,scale 和 zero-point 是什么;
• 量化粒度——per-tensor 太粗、怕离群值,per-channel 才稳;
• 校准——为什么必须用一批真实数据统计激活值范围;
• 敏感层、KV Cache 量化、量化后评估这些工程坑怎么处理。

一、为什么"一刀切量化"会让模型崩

先把这件最根本的事钉死:量化不是无损的"打包压缩",它是有损的"精度降级"。原本一个权重用 32 位浮点表示,能精确到小数点后很多位;量化到 INT4,它就只剩 16 个档位可选——大量的细节被强行四舍五入掉了。单看一个权重,这点误差很小;可一个大模型有几十层、几十亿个权重,每一层的量化误差都会作为下一层的输入,被一层层地累积、放大。一刀切地把整个模型都压到最低精度,这些误差最终会汇成一场雪崩,把模型的输出彻底冲垮。

下面这段代码,就是我那个"量化完就崩"的第一版——它对所有权重一视同仁:

import numpy as np

# 反面教材:把所有权重一刀切量化到 INT4,什么都没多想
def naive_quantize_int4(weights: np.ndarray) -> np.ndarray:
    # INT4 范围是 -8 到 7,直接把浮点权重粗暴地映射过去
    scale = np.max(np.abs(weights)) / 7      # 用全局最大绝对值定 scale
    q = np.round(weights / scale)            # 直接 round 到最近的整数
    q = np.clip(q, -8, 7)                    # 越界的直接截断
    return q.astype(np.int8)
    # 破绽一:全模型用同一个 scale —— 一个离群的大权重就把 scale 撑大,
    #         其余的小权重全被压成 0,信息整片整片地丢。
    # 破绽二:INT4 只有 16 个档位,粒度太粗,每个权重误差都很大。
    # 破绽三:没区分哪些层敏感 —— embedding 和 FFN 一起被压。

这段代码能跑、模型也确实变小了,它的问题不在代码本身,而在一个被忽略的前提:它默认"每个权重少几位精度,无非是答案差一点点"。可它错估了误差的累积效应。于是那串问题就有了解释:全模型一个 scale,只要权重里有一个特别大的离群值,这个 scale 就被撑得很大,于是其余绝大多数的小权重,除以这个大 scale 之后全都四舍五入成了 0——一整层的信息就这么没了;INT4 只有 16 档,本身粒度就极粗;再加上敏感的层也被一起压。这三件事叠在一起,误差在几十层里滚雪球,模型的输出就从"差一点"变成了"全是乱码"。问题的根子清楚了:要做量化,你得先理解量化到底是怎么把浮点变成整数的、误差从哪一步产生——而不是抓个最狠的方式一压了事。

二、量化的本质:浮点到整数的映射

量化的核心动作,是把一个范围很大、很连续的浮点数,映射到一个范围很小、只有有限档位的整数上。要完成这个映射,需要两个关键参数:scale(缩放系数)和 zero-point(零点)。理解了这两个,就理解了量化的一半:

import numpy as np


def quantize(x: np.ndarray, bits: int = 8):
    """非对称量化:把浮点张量映射到 [0, 2^bits-1] 的整数。"""
    qmin, qmax = 0, 2 ** bits - 1
    x_min, x_max = float(x.min()), float(x.max())
    # scale:浮点范围的跨度,均分到整数的每一个档位上的步长
    scale = (x_max - x_min) / (qmax - qmin)
    # zero_point:浮点的 0 对应到哪个整数,保证 0 能被精确表示
    zero_point = round(qmin - x_min / scale)
    q = np.round(x / scale + zero_point)
    return np.clip(q, qmin, qmax).astype(np.int32), scale, zero_point


def dequantize(q: np.ndarray, scale: float, zero_point: int) -> np.ndarray:
    """反量化:把整数还原回浮点(还原出来的是带误差的近似值)。"""
    return (q.astype(np.float32) - zero_point) * scale

这两个函数,是量化的最小闭环。quantize 把浮点压成整数,dequantize 再把整数还原回浮点——但关键在于:还原出来的,已经不是原来那个值了,而是一个带误差的近似值。这个误差,就是量化的有损之处。scale 决定了整数每跳一格,对应浮点世界里多大的一步——浮点范围越大、整数档位越少,这一步就越大,误差就越大。zero_point 是为了让浮点的 0 能被精确表示(因为 0 在神经网络里太常见、太重要了)。我们可以用一个函数,把误差量出来:

def quant_error(x: np.ndarray, bits: int = 8) -> float:
    """量化再反量化,衡量这一轮压缩损失了多少信息。"""
    q, scale, zp = quantize(x, bits)
    x_hat = dequantize(q, scale, zp)
    # 均方误差:还原出来的值,和原始值差多远
    mse = float(np.mean((x - x_hat) ** 2))
    return mse

quant_error 干的事很简单:压一遍、再还原一遍,看看和原值差了多少。它的意义在于:它让"量化损失"从一个模糊的感觉,变成了一个能算出来的数字。位宽越低(bits 越小),这个误差就越大——这就是为什么 INT8 通常还算安全,而 INT4 就要非常小心:从 8 位的 256 个档位掉到 4 位的 16 个档位,精度是断崖式下跌。理解了"误差是怎么产生、怎么衡量的",下一个问题就是:同样是量化,为什么有的方式误差小、有的误差大?答案的第一个关键,是粒度。

三、量化粒度:per-tensor 太粗,per-channel 才稳

第一节那个"一个离群值毁掉一整层"的问题,根子就在量化粒度。所谓粒度,就是"多大一片权重,共用同一组 scale 和 zero-point"。最粗的粒度叫 per-tensor——整个权重矩阵共用一组;细一点的叫 per-channel——每个输出通道(矩阵的每一行)单独算一组:

def quantize_per_tensor(w: np.ndarray, bits: int = 8):
    """整个权重矩阵共用一组 scale —— 简单,但怕离群值。"""
    return quantize(w, bits)


def quantize_per_channel(w: np.ndarray, bits: int = 8):
    """每个输出通道(每一行)单独算一组 scale —— 离群值只殃及它自己那行。"""
    results = []
    for row in w:                       # 逐行(逐通道)独立量化
        q, scale, zp = quantize(row, bits)
        results.append((q, scale, zp))
    return results

这两种粒度的差别,用一个带离群值的例子就能看得清清楚楚:

import numpy as np

# 构造一个带离群值的权重矩阵:绝大多数很小,只有一个突然很大
w = np.random.randn(4, 8) * 0.1
w[2, 5] = 9.0                            # 第 2 行藏了一个离群的大权重

# per-tensor:那个 9.0 把【全局】scale 撑大,其余小权重全被压扁
err_tensor = quant_error(w, bits=8)

# per-channel:9.0 只撑大它【所在那一行】的 scale,另外 3 行不受牵连
err_channel = np.mean([quant_error(row, 8) for row in w])
print(f"per-tensor 误差 {err_tensor:.6f}  per-channel 误差 {err_channel:.6f}")

这段代码跑出来的差距会很明显:per-channel 的误差,通常比 per-tensor 小一两个数量级。原因正是离群值:神经网络的权重和激活里,常常有个别数值特别大(这在大模型里是普遍现象)。用 per-tensor,这一个离群值会把整个矩阵的 scale 撑大,导致其余所有正常的小权重全被压进很少的几个档位里,分辨率全毁了。而用 per-channel,这个离群值只会影响它自己所在的那一行(那个通道),其余通道安然无恙。这就是一条重要的工程经验:权重量化,默认就该用 per-channel;尤其是低位宽量化,per-tensor 几乎必然会被离群值毁掉。粒度的事说清了,但还有一个问题:权重是静态的、量化时就摆在那儿,可激活值是动态的——它要等真实数据喂进来才知道。这就引出了校准。

四、校准:用一批真实数据统计激活值范围

量化分两块:权重量化和激活量化。权重好办——它就是模型文件里那些固定的数,量化时直接拿来统计范围就行。可激活值(每一层的中间输出)是动态的:它取决于输入是什么。你不知道激活值会落在什么范围,也就没法算 scale。校准(calibration)解决的就是这件事:拿一小批有代表性的真实数据,在模型里跑一遍,把每一层激活值实际到过的范围统计出来。第一步是一个"观察器":

class ActivationObserver:
    """校准观察器:在校准数据上跑一遍,统计某层激活值的真实范围。"""

    def __init__(self):
        self.x_min = float("inf")
        self.x_max = float("-inf")

    def observe(self, activation: np.ndarray):
        # 不断刷新,记录这一层激活值实际到过的最小值和最大值
        self.x_min = min(self.x_min, float(activation.min()))
        self.x_max = max(self.x_max, float(activation.max()))

    def get_scale(self, bits: int = 8):
        """校准结束后,用观察到的真实范围算量化参数。"""
        qmin, qmax = 0, 2 ** bits - 1
        scale = (self.x_max - self.x_min) / (qmax - qmin)
        zero_point = round(qmin - self.x_min / scale)
        return scale, zero_point

有了观察器,校准流程就是让它在校准数据上"看"一遍:

def calibrate(model, calib_dataset) -> dict:
    """用一小批有代表性的真实数据,跑出每层激活的量化参数。"""
    observers = {name: ActivationObserver() for name in model.layer_names}
    # 关键:校准数据必须能代表真实输入的分布,几百条通常就够
    for sample in calib_dataset:
        activations = model.forward_collect(sample)   # 跑一遍,收集各层激活
        for name, act in activations.items():
            observers[name].observe(act)
    # 每一层都拿到一组【基于真实数据】的 scale / zero_point
    return {name: ob.get_scale(bits=8) for name, ob in observers.items()}

校准这件事的要害,全在校准数据的代表性上。这正是我开头那个"换份校准数据质量就变一个样"的原因——校准数据就是量化的"标尺"。如果你用一批不典型的数据(比如全是短句、或者全是某个领域的)去校准,统计出来的激活范围就是偏的,真实场景里一旦出现超出这个范围的激活值,就会被狠狠截断,质量直接崩。所以校准数据要尽量贴近真实线上输入的分布:覆盖各种长度、各种主题、各种语言。数量不用多——通常几百条有代表性的样本就够了,关键不是量,是像不像真实场景。校准解决了"范围怎么定",但还有一个更根本的问题没解决:是不是所有层,都该被量化?

五、混合精度与敏感层:不是所有层都能碰

这是我第一版最致命的错误:我把所有层都压到了 INT4。但事实是——不同的层,对量化的"耐受度"天差地别。有些层压一压无所谓,有些层稍微一动模型就崩。正确的做法叫混合精度:给不同的层,分配不同的位宽:

# 经验上对量化最敏感、掉点最狠的层,保留高精度
SENSITIVE_LAYERS = {"embedding", "lm_head", "layernorm"}


def assign_precision(layer_name: str, layer_type: str) -> int:
    """给每一层分配量化位宽:敏感层留高精度,其余才激进压缩。"""
    if layer_type in SENSITIVE_LAYERS:
        return 16                        # 敏感层:保留 FP16,基本不量化
    if "attention" in layer_name:
        return 8                         # 注意力层:INT8,较稳妥
    return 4                             # 占大头的 FFN 权重:可以压到 INT4

那么怎么知道哪些层敏感?靠经验是一方面,更靠谱的是实测——逐层做敏感度分析:

def sensitivity_analysis(model, layer_names, eval_fn) -> dict:
    """逐层试量化,看哪一层量化后掉点最多 —— 那就是敏感层。"""
    baseline = eval_fn(model)            # 先记下全精度时的基准分
    sensitivity = {}
    for name in layer_names:
        model.quantize_layer(name, bits=4)     # 只量化这一层,其余不动
        score = eval_fn(model)
        sensitivity[name] = baseline - score   # 这一层量化后掉了多少分
        model.restore_layer(name)              # 还原,再去试下一层
    # 掉分越多的层越敏感,这些层就不该用低位宽
    return dict(sorted(sensitivity.items(), key=lambda kv: -kv[1]))

sensitivity_analysis 的思路很朴素:一次只量化一层,看模型掉了多少分,然后还原、再试下一层。跑完一轮,你就有了一张"敏感度排行榜"——哪些层一碰就掉一大截(那是敏感层,必须保留高精度),哪些层量化了也几乎不掉分(那就放心压)。这里的认知要点是:量化不是一个"全或无"的开关,而是一个可以逐层精细调节的旋钮。通常的规律是:embedding 层、输出层(lm_head)、归一化层(layernorm)对量化极其敏感,应当保留 FP16;而占了模型大部分参数量的 FFN(前馈网络)权重,相对耐压,是量化收益最大、风险最小的地方。把"敏感的层保护好、耐压的层狠狠压"——这才是混合精度的精髓。下面这张图,把一次靠谱的量化流程串起来:

六、工程坑:KV Cache 量化与量化后评估

五块设计之外,还有几个工程坑,不处理就会让量化白做或踩雷。坑 1:长上下文场景,别忘了 KV Cache 也能量化。很多人量化只盯着模型权重,可在长上下文场景里,KV Cache(注意力机制缓存的键值)会随序列长度线性膨胀,长到一定程度,它比模型权重还吃显存。它同样可以量化:

def quantize_kv_cache(kv_tensor: np.ndarray, bits: int = 8):
    """KV Cache 量化:长上下文时它能比模型权重还吃显存。"""
    # KV Cache 随序列长度线性增长,量化它能省下大量显存
    q, scale, zp = quantize(kv_tensor, bits)
    return {"data": q, "scale": scale, "zero_point": zp}
    # 注意:KV Cache 对精度也很敏感,一般量化到 INT8 即可,
    # 硬压到 INT4 容易让长文本生成的质量明显下降。

坑 2:量化后,必须做一次完整评估,对比掉点。这是最不能省的一步。我开头的错误,就是只看到"模型变小了、能加载了"就以为成了。"能加载"和"答得对"是两回事。量化后一定要拿一个评测集,把量化前后的模型分数算出来、摆在一起比:

def compare_quantized(fp_model, quant_model, eval_set) -> dict:
    """量化前后必须做一次完整评估,确认掉点在可接受范围内。"""
    fp_score = sum(eval_set.score(fp_model.ask(q)) for q in eval_set) / len(eval_set)
    q_score = sum(eval_set.score(quant_model.ask(q)) for q in eval_set) / len(eval_set)
    drop = fp_score - q_score
    return {
        "fp_score": round(fp_score, 4),
        "quant_score": round(q_score, 4),
        "drop": round(drop, 4),
        # 掉点超过一两个百分点,通常说明量化方案需要调整
        "acceptable": drop < 0.02,
    }

compare_quantized 给出的那个 drop,就是量化的"账单"——你省下了多少显存,代价是掉了多少分。这笔账必须算清楚:掉点在可接受范围内(比如一两个百分点),这次量化才算成功;掉点太多,就得回去调——要么换更细的粒度,要么给敏感层提位宽,而绝不是将就着上线。坑 3:分清量化的两种路线。一种是训练后量化(PTQ)——模型训练完了再量化,快、不需要重新训练,本文讲的就是它;另一种是量化感知训练(QAT)——在训练过程中就模拟量化,让模型提前适应精度损失,质量更好但成本高得多。大多数场景 PTQ 就够了,只有对质量要求极高、PTQ 掉点无法接受时才上 QAT。坑 4:量化方案要和推理框架对齐。你用什么方式量化的模型,推理时就得用支持这种格式的框架和算子(比如 GPTQ、AWQ、GGUF 各有各的生态)。量化格式和推理框架对不上,要么跑不起来,要么跑起来反而更慢。坑 5:量化省的是显存,不一定省的是速度。这是个常见误解。量化主要降低的是显存占用;速度能不能快,取决于推理框架有没有针对这种低精度的高效算子。没有配套算子,模型反而可能因为反复地量化、反量化而变慢。

关键概念速查

避坑清单

1. 量化是有损压缩,别指望压完质量只差一点点,激进量化会让模型崩。
2. 别全模型用同一个 scale,一个离群值就会把其余权重全压成 0。
3. 权重里有离群值时要用 per-channel 逐通道量化,而不是 per-tensor。
4. 量化必须用有代表性的校准数据统计激活范围,别凭空拍 scale。
5. 校准数据要贴近真实输入分布,几百条够了,关键是像不像真实场景。
6. embedding、lm_head、layernorm 这些敏感层要保留高精度别一起量化。
7. 量化前先逐层做敏感度分析,掉点狠的层别用低位宽。
8. INT4 只有 16 个档位粒度很粗,只适合不敏感的 FFN 权重。
9. 长上下文场景 KV Cache 比权重还吃显存,可量化但一般到 INT8 为止。
10. 量化后必须跑完整评估对比掉点,别只看模型变小了能加载了。

总结

回头看那串"量化完答非所问、蹦出乱码、全精度好好的量化后就崩"的问题,以及我后来在量化上接连踩的坑,最该记住的不是某一段量化代码,而是我动手前那个想当然的判断——"量化就是把模型压小,压小了能跑就行"。这句话错在它把量化理解成了一次无损的"打包压缩"。我以为量化和把文件打成压缩包是一回事:体积变小,内容不变,解开还是原样。可它根本不是无损的。量化是一次实打实的精度降级——你每压低一档位宽,就永久地丢掉一部分信息,而这丢掉的信息找不回来了。所以量化从来不是一个"压不压"的是非题,而是一个"用多少质量,换多少显存和速度"的权衡题。

所以做模型量化,真正的工程量不在"调个量化函数把模型压一下"那一步操作上。那一步,任何量化库一行命令就完成了。真正的工程量,在于你要理解并管住"量化是有损的"这件事引发的所有后果:误差会层层累积,你就得分清哪些层耐压、哪些层一碰就崩,用混合精度把敏感层保护起来;权重里有离群值,你就得用 per-channel 的细粒度,别让一个离群值毁掉一整层;激活值是动态的,你就得用有代表性的校准数据把它的真实范围量出来;而压完之后,你必须跑一次完整评估,把"省了多少显存、掉了多少分"这笔账算清楚。这篇文章的几节,其实就是顺着这条思路展开的:先想清楚"一刀切量化"为什么会让模型崩,再把浮点到整数的映射机制讲透,用 per-channel 粒度接住离群值,用真实校准数据定准激活范围,用混合精度保护敏感层,最后是 KV Cache 量化、量化后评估这几个把量化做扎实的工程细节。

你会发现,模型量化的思路,和现实里"为了搬家方便,把家里的东西打包精简"完全相通。一个不动脑子的人,会怎么精简?他不管什么东西,一律照同一个标准粗暴压缩——结果易碎的瓷器和耐操的铁锅被同等对待,搬到新家一打开,瓷器全碎了。这正是我那个"一刀切 INT4"的第一版。而一个会精简的人怎么做?他先分门别类:易碎的、贵重的(这是敏感层),小心包好、绝不挤压;耐操的、占地方的(这是 FFN 权重),可以使劲压缩、塞进真空袋。他会按每件东西的"材质"区别对待,而不是一个标准压所有(这是混合精度和逐层敏感度分析)。他装箱前会量好新家的尺寸,而不是凭感觉乱塞(这是用真实数据做校准)。最关键的——他搬完家会逐一检查东西有没有损坏,而不是箱子搬进去就以为大功告成(这是量化后的完整评估)。精简的成败,从来不在于你把行李压得多小,而在于你有没有为每件东西想清楚:它经不经得起压。

最后想说,量化做没做对,差距永远不会在"模型能不能加载"这一步暴露——能加载、显存够用,你会觉得"压一下"这件事已经成了。它只在真实的、需要模型给出可靠回答的使用场景里才显形。那时候它会用最让人措手不及的方式给你结账:做不好,你会像我一样,得到一个"能跑但是废了"的模型——它启动正常、显存正常,可一回答问题就答非所问、胡言乱语,你查遍了部署配置,每一项都"对",可模型就是不可用;而做对了,你会得到一个又小又好的模型:它显存占用降了一大半,能跑在原本跑不动它的机器上,而回答质量和全精度版本几乎没有差别——掉的那一两个点,完全在可接受的范围内。所以别等"能跑但是废了"的模型摆在面前,在你决定"量化一下"的那一刻就该想清楚:我要压的每一层,到底是经得起压的,还是一碰就碎的?我压完之后,凭什么说它还和原来一样好?这两个问题有了答案,你的量化才不只是一个"看起来变小了"的技术动作,而是一次既榨出了显存和速度、又守住了模型质量的可靠工程。

—— 别看了 · 2026