假如你是一家果汁工坊的老板，刚酿出一大桶鲜榨橙汁——这桶果汁就是训练好的大模型，配方精确到小数点后好几位（FP16 浮点精度），足足 14GB，想随时饮用就得一直存放在昂贵的冷柜（显存）里。可冷柜空间有限，于是你想到：把果汁浓缩！Q8 是轻度浓缩的冷藏装：瓶子减半、口感几乎不变；Q4 是超浓缩粉末：一小袋顶一桶、体积只剩四分之一，冲泡后风味差异明显。GGUF 则是你设计的万能包装瓶：不管浓缩程度如何，任何一台“榨汁机”（推理框架）都能按统一说明直接冲泡。这篇教程，就带你拆开 Q4 与 Q8 两瓶浓缩果汁的配方表，学会在“味道”与“便携”之间做聪明的取舍。

岗位关联

学会 Q4/Q8 量化选型，是 AI 工程师让大模型“装得下、跑得快、花得少”的看家本领——从个人电脑到云端推理都离不开它。

目录
  1. 可视化演示
  2. 量化基础概念：给果汁换一套整数刻度
  3. GGUF格式概述：统一的万能果汁瓶
  4. Q4量化原理：小瓶浓缩，大节省
  5. Q8量化原理：接近原味的冷鲜装
  6. 精度体积权衡：永远的跷跷板
  7. 部署场景选择：我的冰箱该放哪一瓶
  8. AI 应用场景
  9. Python 演示
  10. 常见误区
  11. 面试题

可视化演示

展示Q4/Q8量化编码结构、模型体积对比及推理速度质量平衡，支持敏感度调节。

本节配有交互动效（进入视口后自动加载，约 3KB）。

Q4/Q8量化格式对比 蓝色FP16基准模型体积70GB 绿色Q4压缩至40GB节省43% Q4: 4bit/weight, Q8: 8bit/weight Q4大幅压缩体积Q8保留高精度近乎无损

量化基础概念：给果汁换一套整数刻度

浓缩果汁工坊的第一步，是给配方换刻度。原来用精确到 0.01 克的电子秤（FP16 浮点精度），现在改用刻度线稀疏的大勺子。所谓量化（Quantization），就是给每个权重重新配一把粗刻度尺——把连续的浮点小数，映射到有限的整数档位上。这把刻度尺有多粗，直接决定了这瓶浓缩果汁的“口感”。

整数的档位数量取决于用几位二进制表示：4 位能装 16 个档位，8 位能装 256 个档位。档位越密，勺子越精细，误差越小；档位越疏，勺子越粗，但省料。Q4 与 Q8 正是天平两端：一个拼命压缩，一个守住原味。

对称量化是 GGUF 最常用的方案。先找出所有权重中绝对值最大的峰值，把峰值等分成若干个档位，每个档位的宽度叫缩放因子 Δ。权重除以 Δ 再四舍五入，就落到了最近的整数档位上；使用时再把整数乘以 Δ 还原成近似浮点值。

如同果汁浓缩时的容量刻度，Δ 决定了每一格的粗细，b 决定格子总数。Q8 有 256 格，几乎还原原味；Q4 只有 16 格，浓得快但必然丢掉些风味——量化过程中丢失的信息，就是量化误差的由来。

Δ=max⁡(∣x∣)2b−1,xq=round(xΔ)\displaystyle \Delta = \frac{\max(|x|)}{2^{b-1}}, \qquad x_q = \text{round}\left(\frac{x}{\Delta}\right)
Δ 就是那把粗刻度尺的“每格宽度”：格越窄（Q8），量化越接近原值；格越宽（Q4），误差越大但存储越小。
  1. 峰值扫描先找出所有权重中绝对值最大的那个数，把它当作标尺的满刻度。
    max⁡(∣x∣)\max(|x|)
  2. 半区档位预算b 位有符号整数中正数部分只有 2 的 b-1 次方个档位（另一半分给负数）。
    2b−12^{b-1}
  3. 求解缩放因子满刻度除以半区档位数，得到每个档位的实际宽度——档位越窄，量化越精细。
    Δ=max⁡(∣x∣)2b−1\Delta = \frac{\max(|x|)}{2^{b-1}}
  4. 四舍五落入档权重除以 Δ 后取最近的整数，完成从连续值到离散档位的映射。
    xq=round(xΔ)x_q = \text{round}\left(\frac{x}{\Delta}\right)

GGUF格式概述：统一的万能果汁瓶

过去各家果汁厂瓶子规格不统一：PyTorch 的训练产物是 .bin，TensorFlow 是 .pb，换个框架就要重新灌装，非常折腾。GGUF（GPT-Generated Unified Format）是 llama.cpp 社区推出的“标准瓶”，把模型架构、权重、词表和冲调说明全部装进同一个瓶子里，谁都能直接打开喝。

这个瓶身上贴着完整的“营养标签”：文件头部的元数据记录模型名、层数、上下文长度、Rope 参数等关键信息；瓶中的液体是排好序的张量数据，每个张量都标注了量化类型（Q4_0、Q8_0、Q4_K_M 等）。瓶身标签只占几 KB，真正的大头是各张量的量化权重——这正是 GGUF 能同时容纳 Q4 与 Q8 的底层原因。

GGUF 的体积由两部分构成：元数据加上各张量的存储体积之和。每个张量按自己的位宽独立存储，互不干扰，上层框架只需解析文件头就能知道每个张量是“几分浓缩”。

有了万能瓶，你从冰箱拿出一瓶 Q4 浓缩汁，倒进任何榨汁机都能出汁；想追求原味，换成 Q8 那瓶即可——切换成本低到只需要换一个文件，这正是 GGUF 在开源社区迅速普及的原因。

VGGUF=Vmeta+∑t=1TNt×bt8 字节\displaystyle V_{\text{GGUF}} = V_{\text{meta}} + \sum_{t=1}^{T} \frac{N_t \times b_t}{8} \text{ 字节}
这条公式告诉你：GGUF 的体积主要由每个张量的位宽决定，而位宽正是 Q4 与 Q8 的区别所在。
  1. 瓶身标签元数据体积 V_meta 记录架构、词表等配置，通常只有几 KB。
    VmetaV_{\text{meta}}
  2. 遍历每个张量求和号遍历模型内全部 T 个张量，每个权重矩阵就是一个张量。
    ∑t=1T\sum_{t=1}^{T}
  3. 逐张量体积张量 t 有 N_t 个元素，每个元素占 b_t 位（Q4 为 4，Q8 为 8）。
    Nt×bt8\frac{N_t \times b_t}{8}
  4. 加总成文件把每个张量的字节数相加，再加上元数据，就是完整的 GGUF 文件大小。
    VGGUF=Vmeta+∑t=1TNt×bt8 字节V_{\text{GGUF}} = V_{\text{meta}} + \sum_{t=1}^{T} \frac{N_t \times b_t}{8} \text{ 字节}

Q4量化原理：小瓶浓缩，大节省

Q4 就像超浓缩果汁粉：一小袋就能冲一大杯，携带极其方便，但风味有明显的“粉末感”。在 GGUF 语境下，Q4 就是把每个权重压成 4 位整数，整个模型中只有 16 个档位可供选择。

GGUF 的 Q4 家族里有 Q4_0 与 Q4_K 等变体，区别在于分组缩放策略：Q4_0 每 32 个权重共享一个缩放因子，实现简单；Q4_K 采用更小的分组、更细的校准策略，换来更细腻的精度。无论是哪种变体，核心思路都是“分组共享一把刻度尺”，避免每个权重都存一份 Δ。

以 7B 模型为例，FP16 原始体积约 14GB，Q4 后仅约 3.5GB，压缩 4 倍。显存带宽需求同步下降：加载更快、推理时的访存压力更小，这对显存紧张的机器（比如 8GB 显卡）是救命稻草。

代价也直白：16 个档位意味着每个权重只能落在 16 个离散点上，误差明显大于 Q8。就像浓缩粉冲泡后，橙香总少了些层次感——但至少，你能在小冰箱里塞进这桶果汁了。

VQ4=N×48=N2 字节,η=164=4\displaystyle V_{Q4} = \frac{N \times 4}{8} = \frac{N}{2} \text{ 字节}, \qquad \eta = \frac{16}{4} = 4
Q4 的核心卖点：每个权重只要 0.5 字节，7B 模型装进 3.5GB，代价是只有 16 个精度档位。
  1. 位宽代入把 4 位代入通用体积公式，即每个权重占 4 bit。
    N×48\frac{N \times 4}{8}
  2. 化简结果每个权重大约只要 0.5 字节，7B 参数总共约 3.5GB。
    VQ4≈3.5 GBV_{Q4} \approx 3.5 \text{ GB}
  3. 压缩比计算原始 FP16 是 16 位，除以量化位宽 4 位，得到 4 倍压缩。
    η=164=4\eta = \frac{16}{4} = 4
  4. 档位清单4 位有符号整数共有 16 个档位，这是 Q4 量化误差的根源。
    24=162^{4} = 16

Q8量化原理：接近原味的冷鲜装

Q8 像冷鲜装果汁：轻度处理，巴氏杀菌后口感无限接近鲜榨，代价是瓶子比浓缩粉大一圈。在量化世界里，Q8 用 8 位整数表示权重，一共 256 个档位，逼近能力远超 Q4。

对大多数模型来说，Q8 的困惑度（perplexity，衡量模型预测质量的指标）只比 FP16 高约 0.1% 到 0.5%，人类很难察觉输出差异。这意味着 Q8 几乎守住了“原味”，却只花了一半的存储空间。

以 7B 模型为例，Q8 后约 7GB，是 FP16 的一半。它在质量敏感的生产环境中非常常见：既要省显存，又不愿牺牲下游任务（如代码生成、数学推理）的准确率。相比 Q4 的“豁出去”，Q8 走的是“温和折中”路线。

如果说 Q4 是户外露营的应急粮，Q8 就是家用冰箱的日常装——口感几乎不打折，只是你得为“新鲜”多付一倍的存储空间。对于有充足显存的服务器，Q8 往往是更安心的默认选择。

VQ8=N×88=N 字节,η=168=2\displaystyle V_{Q8} = \frac{N \times 8}{8} = N \text{ 字节}, \qquad \eta = \frac{16}{8} = 2
Q8 的定位：体积恰好减半，同时守住 256 个精度档位，是质量与省显存之间的“甜点位”。
  1. 位宽代入每个权重用 8 位存储，代入公式后每权重恰好 1 字节。
    N×88=N\frac{N \times 8}{8} = N
  2. 体积直算7B 参数乘以 1 字节，得到约 7GB 的文件体积。
    VQ8≈7 GBV_{Q8} \approx 7 \text{ GB}
  3. 压缩比16 位降为 8 位，恰好压缩 2 倍。
    η=168=2\eta = \frac{16}{8} = 2
  4. 档位数量8 位整数共有 256 个档位，是 Q4 的 16 倍，误差随之大幅收窄。
    28=2562^{8} = 256

精度体积权衡：永远的跷跷板

果汁的浓缩度，永远是味道和便携之间的跷跷板：浓缩越狠，瓶子越小，冲出来越淡。量化中的位宽 b 也站在同一块跷跷板上——它同时决定体积和误差，而这两者遵循完全不同的增长速度。

体积公式中 b 是一次幂，所以位宽翻倍，体积也翻倍，这是温和的线性增长；档位公式中 b 在指数上，位宽每增加 1，档位就翻一倍，这是迅猛的指数增长。正因为“线性 vs 指数”的差距，Q4 体积只有 Q8 的一半，误差却大得多。

推理速度方面，现代大模型推理高度依赖显存带宽。Q4 体积小，每次权重搬运的数据量少，在访存受限的任务中通常比 Q8 更快；Q8 则在追求输出质量的任务中占优。没有绝对的王者，只有场景适配。

所以不存在绝对的输赢：Q4 用半瓶容积换来了 4 倍携带效率，Q8 用双倍瓶子保住了新鲜口感。选谁，取决于你的冰箱多大、舌头多挑。

V(b)=N×b8 字节,档位(b)=2b\displaystyle V(b) = \frac{N \times b}{8} \text{ 字节}, \qquad \text{档位}(b) = 2^{b}
体积线性增长、档位指数增长——这就是 Q4 与 Q8 博弈的数学本质。
  1. 线性关系体积公式中 b 是一次幂，b 从 4 变 8 时，体积从 3.5GB 变为 7GB。
    V∝bV \propto b
  2. 指数关系档位数量是 2 的 b 次方，b 每增加 1，档位数直接翻倍。
    档位=2b\text{档位} = 2^{b}
  3. 差距悬殊Q8 的档位是 Q4 的 16 倍，所以量化步长缩小 16 倍，误差大幅下降。
    2824=16\frac{2^{8}}{2^{4}} = 16
  4. 权衡总结体积只翻一倍，精度却提升一个量级——这就是“烧钱换质量”的量化版解释。
    VQ8=2×VQ4,28=16×24V_{Q8} = 2 \times V_{Q4}, \quad 2^{8} = 16 \times 2^{4}

部署场景选择：我的冰箱该放哪一瓶

户外徒步带浓缩粉，家里招待客人用冷鲜装——没有最好的果汁，只有最合适的场景。部署大模型同样如此：先算清楚手头的显存预算，再决定是 Q4 还是 Q8。

选择的核心判据是一条不等式：量化权重体积 + KV Cache + 激活值，三项总需求必须不超过显存容量。KV Cache 是推理过程中缓存的键值向量，与上下文长度和批大小成正比；激活值是每层前向计算的中间结果。忽略任何一项，都可能遭遇“爆显存”。

实战决策流程：若显存只够装 Q4（如 8GB 显卡跑 7B 模型），果断选 Q4_K_M；若显存充足且任务对输出质量敏感（医疗问答、代码生成、数学推理），Q8 更稳妥；若连 Q4 都放不下，可换更小的模型或缩短上下文长度，而不是硬上。

GGUF 的妙处正在于此：你永远可以先下载 Q8 测试效果，再用 Q4 部署上线，换瓶子不比换包装麻烦。聪明的工程师，会把这两种浓缩果汁同时备在仓库里，按需取用。

M需求=VW(b)+VKV+V激活≤M显存\displaystyle M_{\text{需求}} = V_{W}(b) + V_{KV} + V_{\text{激活}} \le M_{\text{显存}}
部署前先算这道不等式：权重 + 缓存 + 激活，三项总和撑得住显存，模型才跑得起来。
  1. 权重体积V_W 是量化后的权重体积，7B 模型 Q4 约 3.5GB，Q8 约 7GB。
    VW(b)=N×b8V_W(b) = \frac{N \times b}{8}
  2. KV 缓存推理时缓存的键值向量，与上下文长度和批大小成正比，长上下文中可达数 GB。
    VKV∝L×批次×头维度V_{KV} \propto L \times \text{批次} \times \text{头维度}
  3. 激活值每层前向计算的中间张量，取决于序列长度与批大小。
    V激活V_{\text{激活}}
  4. 总量判决三部分之和不超过显存即可运行，否则需降低位宽或缩短上下文。
    VW+VKV+V激活≤M显存V_W + V_{KV} + V_{\text{激活}} \le M_{\text{显存}}

AI 应用场景

本地部署开源大模型

阶段：模型部署与推理优化

解决的问题：传统方式跑 7B 模型至少需要 14GB 显存（FP16），普通消费级显卡望而却步。使用 GGUF Q4 量化后权重仅 3.5GB，配合 8GB 显存的显卡即可流畅运行，让个人开发者也能在本地拥有专属 AI 助手。

具体案例：工程师用 Ollama 拉取 qwen2.5:7b-instruct-q4_K_M.gguf，在 RTX 4060Ti 上实现了本地代码补全与文档问答，单 token 延迟低于 50ms，且数据完全不出本机。

云端推理服务降本增效

阶段：模型服务化与成本优化

解决的问题：线上 API 服务每天处理数百万次请求，FP16 模型占用大量 GPU 显存、并发低。将 13B 模型切换为 GGUF Q8 后显存减半、吞吐翻倍；对成本极敏感的批处理任务进一步降为 Q4，以少量质量损失换取更大规模并发。

具体案例：某 SaaS 团队把 13B 模型从 FP16 转为 Q8 GGUF，单卡并发从 8 路提升到 16 路，P99 延迟下降 40%，领域评测分数仅下降 0.3%，年度 GPU 成本节省约 45%。

开源模型的分发与格式转换

阶段：模型转换与分发

解决的问题：训练好的 PyTorch 权重（.bin）无法被 llama.cpp、Ollama 等推理框架直接加载。将模型转换为 GGUF 格式后统一分发，用户按自身显存自助选择 Q4 或 Q8 版本，无需自己处理格式转换。

具体案例：某开源团队发布 7B 模型时提供 Q4_K_M 与 Q8_0 两个 GGUF 文件，配套说明“8GB 显存选 Q4，12GB 以上选 Q8”，两周内下载量破 10 万，社区反馈部署成功率极高。

Python 演示

python35 行
import numpy as np def quantize(weights, bits=8):    """把浮点权重映射为 bits 位整数：缩放 + 四舍五入 + 截断"""    amax = np.max(np.abs(weights))    delta = amax / (2 ** (bits - 1))    q = np.round(weights / delta)    q = np.clip(q, -(2 ** (bits - 1)), 2 ** (bits - 1) - 1)    return q.astype(np.int16), delta def dequantize(q, delta):    """反量化：整数缩放回近似的浮点权重"""    return q.astype(np.float32) * delta def simulate(weights, bits):    q, delta = quantize(weights, bits)    approx = dequantize(q, delta)    mse = float(np.mean((weights.astype(np.float32) - approx) ** 2))    orig_bytes = weights.nbytes    quant_bytes = weights.size * bits // 8    return q, mse, orig_bytes, quant_bytes def main():    np.random.seed(42)    # 模拟 7B 模型中的一个小线性层：128x128 权重矩阵    weights = (np.random.randn(128, 128) * 0.5).astype(np.float16)    print("原始权重（模拟单个线性层）:", weights.shape, "FP16 体积:", weights.nbytes, "字节")    for bits in (4, 8):        q, mse, ob, qb = simulate(weights, bits)        ratio = ob / qb        print(f"Q{bits}: {ob} 字节 -> {qb} 字节, 压缩 {ratio:.1f} 倍, 均方误差 MSE = {mse:.6f}")        print("   量化整数示例 (前 8 个):", q[0, :8].tolist()) if __name__ == "__main__":    main()
目的：用 NumPy 完整演示 Q4 与 Q8 的对称量化流程，直观对比压缩倍数与量化误差。
  1. amax = np.max(np.abs(weights))找满刻度：所有权重的绝对峰值
  2. delta = amax / (2 ** (bits - 1))计算缩放因子 Δ，决定档位宽度
  3. q = np.round(weights / delta)权重除以 Δ 后四舍五入，完成入档
  4. q = np.clip(q, -(2 ** (bits - 1)), 2 ** (bits - 1) - 1)截断越界值，保证落在合法整数范围
  5. return q.astype(np.float32) * delta反量化：整数乘以 Δ 还原近似权重
  6. mse = float(np.mean((weights.astype(np.float32) - approx) ** 2))用均方误差量化“口感损失”
  7. quant_bytes = weights.size * bits // 8按位宽计算压缩后的实际字节数
  8. ratio = ob / qb压缩比：FP16 原始体积除以量化后体积

常见误区

误区Q4 只有 4 位，那精度就是原来的四分之一，模型输出质量肯定断崖式下跌，根本不敢在生产环境用。

正解量化不是简单把数字除以 4，而是用 16 个整数档位配合缩放因子近似表达权重。现代 GGUF 方案（如 Q4_K_M）通过分组缩放和精细校准，让 7B 模型的 Q4 版本在大多数任务上仍能保持 90% 以上的原始质量。实际损失通常远小于“变笨 4 倍”的直觉。

为何常见：人们容易把“位宽减半”等同于“精度减半”，却忽略了缩放因子带来的动态范围补偿，以及神经网络本身对权重扰动的鲁棒性。

误区Q8 精度更高、质量更好，那肯定选 Q8 啊，为什么要纠结？

正解Q8 精度确实更高，但体积和显存占用是 Q4 的两倍。如果设备显存只有 6GB，7B 模型的 Q8（约 7GB）根本装不下，而 Q4（约 3.5GB）能流畅运行。选型的第一约束是硬件，其次才是质量。此外，Q4 因访存压力小，在部分推理场景中反而更快。

为何常见：对比时人们只看“质量”一个维度，忽略了部署场景中显存、带宽、并发等更硬性的约束。

误区模型一旦量化成 Q4/Q8，知识就永久丢失了，想恢复高质量必须重新训练。

正解量化只是改变了权重的存储表示，不改变模型的架构和学到的知识。反量化（乘回 Δ）可以还原近似的浮点权重，随时可以转回 FP16 或换更高位宽。GGUF 文件本身就是可逆的转换产物，下载原版 FP16 权重重新量化即可，完全不需要重训。

为何常见：初学者把“存储格式”和“模型参数”混为一谈，以为压缩就是破坏。实际上量化是工程压缩手段，类似把照片存成 JPEG，重新导出原图（权重）依然可用。

误区既然叫 Q4/Q8，那 GGUF 就只能在这两种之间二选一，用别的位宽就不行。

正解GGUF 是一个容纳多种量化变体的容器格式。仅 Q4 家族就有 Q4_0、Q4_1、Q4_K_S、Q4_K_M 等，Q8 也有 Q8_0，此外还有 Q5、Q6、Q2、Q3 等位宽选择。每个张量甚至可以独立指定位宽，格式本身非常灵活。

为何常见：文章标题聚焦 Q4 与 Q8，容易让人误以为格式只支持这两个选项。实际上 GGUF 的设计初衷就是“一个瓶子装各种浓度”。

面试题

Q1. GGUF 中 Q4 的"4"代表什么？

单选题 · easy

  • A.4个字节存储一个权重
  • B.4位二进制存储一个权重← 正确答案
  • C.4倍精度浮点存储权重
  • D.模型被分成4个文件

答案：B。GGUF 文件名中的 Q 代表 Quantization（量化），数字代表每个权重占用的存储位数。Q4 即每个权重用 4 位二进制整数表示，共 16 个档位。A 混淆了“位”与“字节”（4 字节等于 32 位）；C 中 4 与精度倍数无关；D 是把模型分片误认为量化。

Q2. Q8 相比 Q4 的主要优势是？

单选题 · easy

  • A.模型体积更小
  • B.推理速度更快
  • C.精度损失更小← 正确答案
  • D.显存占用更低

答案：C。Q8 用 256 个整数档位逼近原始浮点权重，而 Q4 只有 16 档，所以 Q8 的量化误差更小、输出质量更接近 FP16。体积上 Q8 反而比 Q4 大，访问带宽需求也更高，通常推理速度不如 Q4，故选 C。

Q3. 7B 模型 FP16 约 14GB，Q4 后大约多大？

单选题 · easy

  • A.约为 1.75GB
  • B.约为 3.5GB← 正确答案
  • C.约为 7GB
  • D.约为 14GB

答案：B。Q4 把每个权重压缩为 4 位，即 0.5 字节。7B 参数乘以 0.5 字节约等于 3.5GB。14GB 是原始 FP16 体积，7GB 是 Q8 体积，1.75GB 对应 2 位量化的体量，均不符合。

Q4. 对称量化中，缩放因子 Δ 的正确计算方式是？

单选题 · mid

  • A.峰值除以 2 的 b 次方
  • B.峰值除以 2 的 b-1 次方← 正确答案
  • C.均值除以 2 的 b 次方
  • D.最小值除以 2 的 b-1 次方

答案：B。对称量化把绝对峰值均匀映射到正负两个半区。有符号 b 位整数的正半区有 2 的 b-1 次方个档位（另一半给负数），所以 Δ = 峰值 / 2^(b-1)。A 把分母错写成 2^b 导致档位减半，C 用均值无法保证不越界，D 用最小值会破坏对称性。

Q5. 关于 GGUF 格式，以下说法正确的有？

多选题 · mid

  • A.一个文件包含权重与参数← 正确答案
  • B.可跨框架直接加载使用← 正确答案
  • C.文件头描述元数据信息← 正确答案
  • D.只支持原始的 16 位存储

答案：ABC。GGUF 把模型架构、词表等元数据写在文件头，张量数据统一排在后面，llama.cpp、Ollama 等框架都能直接解析。它支持 Q4/Q8 等多种量化位宽，而非只支持 16 位原始存储，故 D 错误。

Q6. 量化误差的主要来源是？

单选题 · mid

  • A.整数乘法溢出
  • B.四舍五入与截断← 正确答案
  • C.文件格式损坏
  • D.网络传输丢包

答案：B。量化把连续权重四舍五入到最近的整数档位，落点与真实值的差距就是量化误差；同时越界值会被截断，也引入额外误差。整数溢出在推理中很少见，文件损坏与丢包属于存储和传输错误，与量化本身无关。

Q7. 本地电脑显存仅 6GB，想跑 7B 模型应优先选择？

单选题 · mid

  • A.Q4 量化版本← 正确答案
  • B.Q8 量化版本
  • C.原始 FP16 版本
  • D.任何版本都可以

答案：A。7B 模型 Q4 约 3.5GB、Q8 约 7GB、FP16 约 14GB。6GB 显存装不下 FP16 和 Q8，只有 Q4 能装下。D 忽略了三种版本的体积差异，故选 A。

Q8. 关于 Q4 与 Q8 的对比，正确的理解包括？

多选题 · hard

  • A.Q4 体积约为 Q8 的一半← 正确答案
  • B.Q8 质量通常高于 Q4← 正确答案
  • C.Q4 适合显存受限设备← 正确答案
  • D.Q8 一定比 Q4 推理快

答案：ABC。Q4 每权重 0.5 字节、Q8 每权重 1 字节，所以 Q4 体积恰为 Q8 的一半；Q8 档位更多、质量更高；Q4 体积小、带宽需求低，适合显存受限设备。但 Q8 不一定比 Q4 快——访存受限时往往 Q4 更快，故 D 错误。

Q9. 相同 7B 模型下，Q4 的显存需求约为 Q8 的？

单选题 · hard

  • A.大约二分之一← 正确答案
  • B.大约四分之一
  • C.大约原来的两倍
  • D.两者完全相等

答案：A。Q4 每权重占 0.5 字节，Q8 每权重占 1 字节，因此 Q4 的显存需求是 Q8 的二分之一。四分之一是 Q4 相对 FP16 的压缩比例，两倍和相等分别描述相反或错误的关系。

Q10. 已知体积公式 V = N × b / 8 字节，以下推断正确的是？

多选题 · extreme

  • A.b 越大体积越大误差越小← 正确答案
  • B.档位总数等于 2 的 b 次方← 正确答案
  • C.b 减半时体积也减半← 正确答案
  • D.量化误差与 b 成正比

答案：ABC。由公式可知体积与 b 成正比，b 减半则体积减半；档位总数是 2 的 b 次方，b 越大档位越多、量化步长越小、误差越小。但误差与 b 成反比而非正比，故 D 错误。