CPU、GPU 混合推理，非常见大模型量化方案：“二三五六” 位量化，模型量化详细实现方案。

非常见整型位数的量化，来自让各种开源模型能够在 CPU 环境、CPU & GPU 环境混合推理的技术方案：llama.cpp 。为了能够在低配置上机器运行，降低入门的硬件门槛还是很有必要的。模型量化技术就是这样一个“神奇、有效”的方案。

目前针对大模型进行量化的方法包括：

1. 剪枝（Pruning）：剪枝是一种通过去除冗余连接或权重来减少模型参数和计算量的方法。剪枝可以基于模型权重、梯度或敏感度进行，可以通过稀疏化技术进一步优化。

2. 知识蒸馏（Knowledge Distillation）：知识蒸馏通过将一个大型复杂模型的知识传递给一个小型模型来压缩模型。小模型学习复杂模型的输出概率分布或中间表示，从而获得近似相同的性能。

3. 量化（Quantization）：量化是将模型权重和激活从浮点数表示转换为更低精度的表示（如8位整数或4位整数）。量化可以显著减少模型的存储需求和计算成本，同时尽可能保持模型的性能。

4. 低秩分解（Low-Rank Factorization）：低秩分解是将模型参数分解为多个低秩矩阵或张量的方法。通过降低参数的有效秩，可以减少模型的存储需求和计算量。

这些方法可以单独应用或结合使用，以在保持模型性能的同时减少模型的大小、计算和存储需求。每种方法都有其优势和适用场景，具体选择取决于应用需求和硬件约束。

例如，零一万物模型官方 Yi-34B 模型，类似 34B 的模型，如果想不怎么量化直接跑起来，大概需要 76～85GB 的显存。如果我们进行效果损失比较小的 8 位量化，那么也需要 46GB 左右，如果是 4 位量化模型，那么也需要 21GB 左右的显存。

虽然模型能跑了，但是有可能模型效果“打了骨折”。

是的，模型的量化其实就是这样的一个，把类似我们相机拍摄照片（RAW），转换成“PNG”，再转换成“JPG”，最后甚至转换成“GIF”的过程。我们追求的是尽量省钱，在我们的设备上保持最好效果的将模型跑起来。尽量整个接近 “PNG” 的 “JPG”，而不是一定要折腾个 “GIF” 。

尤其是一般情况下， 会使用八位（INT8）或者 四位（INT4）位量化，但是我们很容易会遇到两个尴尬的情况：

有的模型量化成四位（INT4）效果变的不是很好，但是量化成八位（INT8）效果还行。可是八位（INT8）尺寸又太大，运行不太方便，希望模型尺寸能够小一些。
有的模型量化成四位（INT4），模型还是太大，硬件跑不起来或者跑起来太费力，希望模型变的更小巧一些。

准备材料
关于模型量化需要准备两个素材，一个是模型，另外一个是量化使用的计算设备。

模型程序文件
任意参数量的模型，可以是 7B、13B、14B、20B、33B、34B、68B、70B …的模型，也可以是更小参数量的小尺寸的模型。

我这里使用的是零一万物开源的 YI-34B 的社区 finetune 微调训练的版本，通常情况下，社区可能有热门模型的量化版本，经常看到一些同学说“等个量化版本”。

但其实自己动手，丰衣足食。况且，即使是从社区下载量化版本，模型体积也很大，需要来来回回测试模型是否合适，重复下载也非常消耗时间和宽带成本，远不如自己量化来的方便。

关于模型程序下载，方法很多。如果你想要从 HuggingFace 相对快速下载模型，可以参考这篇文章中的 “模型程序下载” 来解决问题。

量化使用的硬件
而量化模型使用的硬件，需要 CPU 计算能力相对强一些的机器，如果你有 GPU，那么将会极大的提升模型量化速度，如果没有也没有关系。

至于量化后的产物，则是各种设备通用的，你可以在 Windows 量化后给 Linux 或者 macOS 设备使用。你也可以使用有 CPU 和 GPU 的设备，量化后给只有 CPU 的设备使用。

唯一有一些差异的，只有运行这个通用模型格式程序的启动程序，是需要和你当前的运行环境和操作系统有些关联的，比如需要构建，或者安装时需要一些初始化。

相比较模型，程序这个真的就是小意思啦。

模型的 GGUF （GGML Universal File）格式量化准备
GGUF 是 GGML 的全新替代型，被称为 GGML 通用文件格式。

GGUF 支持的模型量化格式非常多，刨除“几种跨开源生态模型转换的场景外”，主要依赖两个程序：convert.py 和 quantize 程序。前者以 Python 脚本的形态存在于 llama.cpp 项目的目录中，后者需要我们进行项目的构建。

下载 llama.cpp 的代码，然后就能够进行构建操作啦：

# 下载代码
git clone https://github.com/ggerganov/llama.cpp.git
# 切换工作目录到项目文件夹内
cd llama.cpp
# 构建项目可执行文件（有显卡）
make -j LLAMA_CUBLAS=1
# 构建项目执行文件 (没有显卡)
make -j

等待程序构建完毕，所有的准备工作就都完成啦。

预转换：Convert.py 转换脚本
这个脚本能够将非 GGML 格式的文件转换为 GGML，以 GGUF 后缀进行保存。程序默认支持转换下面几类格式的模型：.pth、.pt、.bin、.safetensors。

是我们进行后续非常见整型模型量化的基础操作步骤。

如果我们只追求使用 8 位量化的，可以使用 CPU 和 GPU 混合推理的模型，那么我们可以参考这篇文章中的“尝试对模型进行几种不同的量化操作”的方法中的命令行参数，将模型转换为 GGML 的 q8_0 模型。

但如果，我们希望制作更多其他的不同的类型的模型，比如 2 位量化～ 6 位量化，那么我非常建议大家使用 convert.py 脚本制作和转换一个 f16 类型的 GGML 模型。

虽然程序的命令行参数看起来很麻烦，但是我们需要使用到的转换命令其实非常简单，使用 Python 调用程序，命令中携带“模型路径”和“输出的模型类型”即可：

python ./convert.py 【模型的路径】 --outtype f16

这里以 YI-34B 的社区 finetune 模型 brucethemoose/CapyTessBorosYi-34B-200K-DARE-Ties 为例子，调整为我自己的模型存放路径：

python ./convert.py ../brucethemoose/CapyTessBorosYi-34B-200K-DARE-Ties/ --outtype f16

执行命令后，机器将会火力全开的进行程序编译，输出大量日志：

Loading model file ../brucethemoose/CapyTessBorosYi-34B-200K-DARE-Ties/model-00001-of-00008.safetensors
Loading model file ../brucethemoose/CapyTessBorosYi-34B-200K-DARE-Ties/model-00001-of-00008.safetensors
Loading model file ../brucethemoose/CapyTessBorosYi-34B-200K-DARE-Ties/model-00002-of-00008.safetensors
...

params = Params(n_vocab=64000, n_embd=7168, n_layer=60, n_ctx=200000, n_ff=20480, n_head=56, n_head_kv=8, f_norm_eps=1e-05, rope_scaling_type=None, f_rope_freq_base=5000000.0, f_rope_scale=None, n_orig_ctx=None, rope_finetuned=None, ftype=<GGMLFileType.MostlyF16: 1>, path_model=PosixPath('../brucethemoose/CapyTessBorosYi-34B-200K-DARE-Ties'))
Loading vocab file '../brucethemoose/CapyTessBorosYi-34B-200K-DARE-Ties/tokenizer.model', type 'spm'
Permuting layer 0
Permuting layer 1
Permuting layer 2
...

model.embed_tokens.weight                        -> token_embd.weight                        | BF16   | [64000, 7168]
model.layers.0.input_layernorm.weight            -> blk.0.attn_norm.weight                   | BF16   | [7168]
...

Writing ../brucethemoose/CapyTessBorosYi-34B-200K-DARE-Ties/ggml-model-f16.gguf, format 1
gguf: This GGUF file is for Little Endian only
gguf: Setting special token type bos to 1
gguf: Setting special token type eos to 2
gguf: Setting special token type unk to 0
gguf: Setting special token type pad to 0
[  1/543] Writing tensor token_embd.weight                      | size  64000 x   7168  | type F16  | T+   1
[  2/543] Writing tensor blk.0.attn_norm.weight                 | size   7168           | type F32  | T+   2
[  3/543] Writing tensor blk.0.ffn_down.weight                  | size   7168 x  20480  | type F16  | T+   2
...

Wrote ../brucethemoose/CapyTessBorosYi-34B-200K-DARE-Ties/ggml-model-f16.gguf

当一切都结束后，我们能够看到类似上面日志的最后一行提示，告诉我们转换好的模型名字和存放到机器的什么位置了。默认会存放于你指定要转换模型的目录，并以 .gguf 后缀保存文件。

最终转换：quantize 量化程序
当我们使用上面的方法，将模型转换为了相对高精度的模型文件后，我们就可以进行下一步量化了。

执行 ./quantize --help，除了程序的执行命令格式参考外，我们还能够看到量化程序支持的所有类型：

Allowed quantization types:
   2  or  Q4_0   :  3.56G, +0.2166 ppl @ LLaMA-v1-7B
   3  or  Q4_1   :  3.90G, +0.1585 ppl @ LLaMA-v1-7B
   8  or  Q5_0   :  4.33G, +0.0683 ppl @ LLaMA-v1-7B
   9  or  Q5_1   :  4.70G, +0.0349 ppl @ LLaMA-v1-7B
  10  or  Q2_K   :  2.63G, +0.6717 ppl @ LLaMA-v1-7B
  12  or  Q3_K   : alias for Q3_K_M
  11  or  Q3_K_S :  2.75G, +0.5551 ppl @ LLaMA-v1-7B
  12  or  Q3_K_M :  3.07G, +0.2496 ppl @ LLaMA-v1-7B
  13  or  Q3_K_L :  3.35G, +0.1764 ppl @ LLaMA-v1-7B
  15  or  Q4_K   : alias for Q4_K_M
  14  or  Q4_K_S :  3.59G, +0.0992 ppl @ LLaMA-v1-7B
  15  or  Q4_K_M :  3.80G, +0.0532 ppl @ LLaMA-v1-7B
  17  or  Q5_K   : alias for Q5_K_M
  16  or  Q5_K_S :  4.33G, +0.0400 ppl @ LLaMA-v1-7B
  17  or  Q5_K_M :  4.45G, +0.0122 ppl @ LLaMA-v1-7B
  18  or  Q6_K   :  5.15G, -0.0008 ppl @ LLaMA-v1-7B
   7  or  Q8_0   :  6.70G, +0.0004 ppl @ LLaMA-v1-7B
   1  or  F16    : 13.00G              @ 7B
   0  or  F32    : 26.00G              @ 7B
          COPY   : only copy tensors, no quantizing

这里，我建议始终使用 Q4_K、Q5_K 这类代指名称来进行模型转换，并且在进行转换之前，偶尔执行 ./quantize --help 看看有没有新的、更适合你的量化方案。名称中的 Q数字 中的数字就是对应的量化的位数啦。

一般来说，位数越高，需要的内存和显存就越多，运行起来越慢，但是效果和精度就越接近原始版本。反之，我们虽然得到了省资源的版本，但是效果会有明显的降低。不过，如果你模型跑不起来，效果是零，这种情况下能够量化跑起来的模型，总归是比没有强，某种程度来说，也是不得已而为之。

帮助信息中展示的如何使用命令行的演示信息，同样是内容比较多比较复杂的。但是同样的，我们实际只需要非常简单的使用方法，记住下面的调用方式就足够了：

./quantize 【模型地址】【模型类型名称】

如果我们将命令中的“变量”进行替换，改成本文中我使用的模型和我选择的量化方案，命令行如下：

./quantize ../brucethemoose/CapyTessBorosYi-34B-200K-DARE-Ties/ggml-model-f16.gguf Q5_K_M

命令执行过程中，我们将看到滚动的日志：

ggml_init_cublas: GGML_CUDA_FORCE_MMQ:   no
ggml_init_cublas: CUDA_USE_TENSOR_CORES: yes
ggml_init_cublas: found 1 CUDA devices:
  Device 0: NVIDIA GeForce RTX 4090, compute capability 8.9
main: build = 1622 (8a7b2fa)
main: built with cc (Ubuntu 11.4.0-1ubuntu1~22.04) 11.4.0 for x86_64-linux-gnu
main: quantizing '../brucethemoose/CapyTessBorosYi-34B-200K-DARE-Ties/ggml-model-f16.gguf' to '../brucethemoose/CapyTessBorosYi-34B-200K-DARE-Ties/ggml-model-Q5_K_M.gguf' as Q5_K_M
llama_model_loader: loaded meta data with 20 key-value pairs and 543 tensors from ../brucethemoose/CapyTessBorosYi-34B-200K-DARE-Ties/ggml-model-f16.gguf (version GGUF V3 (latest))
llama_model_loader: - tensor    0:                token_embd.weight f16      [  7168, 64000,     1,     1 ]
llama_model_loader: - tensor    1:           blk.0.attn_norm.weight f32      [  7168,     1,     1,     1 ]
...
llama_model_loader: - tensor  542:               output_norm.weight f32      [  7168,     1,     1,     1 ]
llama_model_loader: Dumping metadata keys/values. Note: KV overrides do not apply in this output.
llama_model_loader: - kv   0:                       general.architecture str              = llama
llama_model_loader: - kv   1:                               general.name str              = brucethemoose
llama_model_loader: - kv   2:                       llama.context_length u32              = 200000
llama_model_loader: - kv   3:                     llama.embedding_length u32              = 7168
...
[ 541/ 543]               blk.59.ffn_down.weight - [20480,  7168,     1,     1], type =    f16, quantizing to q6_K .. size =   280.00 MiB ->   114.84 MiB | hist: 
[ 542/ 543]               blk.59.ffn_norm.weight - [ 7168,     1,     1,     1], type =    f32, size =    0.027 MB
[ 543/ 543]                   output_norm.weight - [ 7168,     1,     1,     1], type =    f32, size =    0.027 MB
llama_model_quantize_internal: model size  = 65593.31 MB
llama_model_quantize_internal: quant size  = 23193.68 MB

main: quantize time = 99803.07 ms
main:    total time = 99803.07 ms

转换完毕，我们前往模型的目录，查看文件大小，能够看到非常明显的尺寸缩减：

# du -hs *
23G	ggml-model-Q5_K_M.gguf
65G	ggml-model-f16.gguf

至于模型的使用，就太简单啦。

我们可以使用 llama.cpp 项目中的 main 和 server 来运行模型，前者会在命令行中启动一个交互式的终端，后者则会启动一个简洁的 Web UI，我们在浏览器中就可以轻松的调节模型的调用参数。

在前两篇相关的文章中有提到过，这里我们再聊一次，顺便聊聊不同的参数的选择和调整策略。

一般的“起手式”是这样：

./server --ctx-size 2048 --host 0.0.0.0 --n-gpu-layers 50 --model ../playground/01-ai/Yi-34B/ggml-model-q8_0.gguf

上面的命令中，分别包含了：

“–ctx-size” 指定模型会话窗口大小，所能容纳和使用的 Token 数量，这里如果想省点显存和内存，就设置小一些，能够满足你的任务需要就好。如果资源比较多，可以开到模型的上限，比如最近的默认模型都是 4k 的，就设置 4096，8K 就设置 8192，200K 就设置个 200000，以此类推。
“–host” 默认其实可以不添加，但是如果你在局域网，或者你的服务运行在容器里，那么你需要分享或者在容器外访问，设置 --host 0.0.0.0 就很有必要啦。
“–n-gpu-layers” 这个参数需要配合显卡一起使用，如果你有显卡，但是显卡装不下模型，或者装下模型后快满了，可以考虑适当调整下数值，根据自己的需求，将合适的模型层数扔到显卡里，稍微给显卡留点富余量。扔到显卡里的模型层数越多，推理速度越快。
“–model” 这个参数没有什么特别的，指定我们下载或者转换好的 GGML 模型文件就好。
好啦，当这个命令执行后，就能够快乐的和模型一起玩耍。

量化方法可以使用以下精度进行模型表示的转换：

1. 浮点数：传统的深度学习模型使用32位浮点数（单精度）来表示权重和激活。浮点数具有较高的精度，可以获得较准确的模型表示，但同时也需要更多的存储空间和计算资源。

2. 整数：量化可以将模型的权重和激活从浮点数表示转换为整数表示。通常使用8位整数或更低的精度（如4位整数）来表示模型参数。整数表示可以显著减少模型的存储需求和计算成本，但可能会带来一定的精度损失。

3. 二值：二值量化使用两个值（通常是+1和-1）来表示模型权重和激活。使用二值表示可以进一步减少模型的存储需求和计算复杂度，但会损失更多的精度。二值量化可以通过二值化神经网络（Binarized Neural Networks）来实现。

4. 三值：三值量化将模型参数表示为+1、0和-1三个值之一。三值量化可以在一定程度上平衡模型的精度和存储需求，同时减少推理过程中的计算量。

选择合适的精度进行量化表示需要权衡模型的性能要求和资源限制。高精度表示可以提供更准确的模型输出，但需要更大的存储空间和计算资源。低精度表示可以减少存储和计算成本，但可能会引入一定的精度损失。因此，根据具体应用需求和硬件约束，选择适当的量化精度进行模型表示转换。

选择合适的量化精度进行模型表示转换需要考虑以下因素：

1. 应用需求：首先要了解应用的需求和要求，包括模型的精度要求、计算和存储资源的限制。不同的应用对模型精度的要求不同，有些任务可能需要更高的精度，而其他任务可能可以接受较低的精度。同时，需要考虑模型部署的硬件平台，例如移动设备、嵌入式设备或云服务器，以确定可以使用的量化精度范围。

2. 模型性能评估：量化精度会对模型的性能产生影响，包括模型的准确性、推理速度和存储需求。要评估不同量化精度下模型的性能表现，可以使用验证集或测试集进行评估，比较模型在不同精度下的准确率、推理时间和模型大小等指标。

3. 实验和调优：可以尝试不同的量化精度，并进行实验和调优，以确定最适合应用需求和资源限制的量化精度。可以使用自动化量化工具或库来自动搜索和选择最佳的量化配置，或者使用经验和专业知识手动调整量化精度。

4. 模型敏感度和容忍度：不同的模型对精度损失的容忍度不同。一些模型对精度要求非常高，稍微的量化损失就会导致性能下降，而其他模型对精度损失相对容忍。要考虑模型对精度损失的敏感度和容忍度，以确定可以接受的量化精度范围。

5. 迭代和优化：量化是一个迭代的过程，可以通过不断尝试和优化来逐步改进量化结果。可以尝试不同的量化方案和精度配置，并根据实际测试结果进行调整和优化，以找到最佳的量化精度。

综合考虑以上因素，可以选择合适的量化精度进行模型表示转换。重要的是要确保量化后的模型在满足应用要求的同时，尽量减少存储需求和计算成本，并保持合理的模型性能。

有一些自动化的量化工具可以帮助选择最佳的量化配置。这些工具通常使用优化算法和搜索方法来搜索和选择最优的量化精度配置，以最大程度地减少精度损失同时保持模型性能。以下是一些常用的自动化量化工具：

1. TensorFlow Model Optimization Toolkit：TensorFlow提供了一个Model Optimization Toolkit，其中包括了一系列用于模型优化和量化的工具和API。其中包括自动化量化工具，可以帮助选择最佳的量化配置。

2. TensorRT：TensorRT是NVIDIA开发的一个用于深度学习推理的高性能推理优化器。它提供了自动化的量化功能，可以根据硬件平台和应用需求选择最佳的量化配置。

3. ONNX Runtime：ONNX Runtime是一个开源的推理引擎，支持多种硬件平台和深度学习框架。它提供了自动化的量化工具，可以帮助选择最佳的量化配置，并优化模型的推理性能。

4. QAT（Quantization-Aware Training）：QAT是一种训练时进行量化的方法。一些深度学习框架（如PyTorch和TensorFlow）提供了QAT相关的库和API，可以帮助进行自动化的量化，并选择最佳的量化配置。

这些自动化量化工具可以帮助简化量化过程，并提供一些默认的量化配置选项。它们通常具有良好的性能和精度平衡，但最终的量化配置还需要根据具体应用需求进行调整和优化。

以下是可以用于大模型量化的开源项目：

1. jacinto-ai-devkit：一个用于嵌入式友好的深度学习/机器学习/计算机视觉模型训练和量化的项目。链接

2. ICSE：使用参数剪枝和量化技术提高深度学习基于语音增强模型的紧凑性。链接

3. torch_quant：实现了深度学习模型的均匀/非均匀量化。链接

4. Imagedenoising-dncnn-ridnet-keras：用于图像去噪的深度学习模型，可以用于量化。链接

5. DeepSlim：自动化网络剪枝和量化工具，可以减小深度学习模型的尺寸。链接

6. Brevitas：一个用于量化深度学习模型的PyTorch库，支持不同的量化方法和精度配置。链接

7. Distiller：一个用于神经网络量化和压缩的开源工具，支持多种量化技术和训练方法。链接

8. TensorRT：NVIDIA开发的深度学习推理优化器，提供了自动化的量化功能。链接

9. ONNX Runtime：一个开源的推理引擎，提供了自动化的量化工具和优化功能。链接

10. QAT：量化感知训练（Quantization-Aware Training）的实现，可以在训练过程中进行量化。链接

11. MMdnn：一个跨框架模型转换工具，支持将模型从一个框架转换到另一个框架，并进行量化优化。链接

12. TVM：一个用于深度学习模型优化和自动化部署的开源编译器堆栈，支持模型的量化和优化。链接

13. LQ-Nets：一个用于深度学习模型量化和量化训练的开源库，支持许多不同的量化技术。链接

14. QPyTorch：一个基于PyTorch的量化模型库，提供了各种量化方法和工具。链接

15. QuantLab：一个用于量化神经网络的开源工具，提供了一系列快速且可扩展的量化算法。链接

16. Quantization Adaptation：使用自适应量化方法减小深度学习模型的尺寸和计算量。链接

17. tjtools：一个深度学习训练和量化工具包，支持PyTorch模型的量化。链接

18. vQuant：一个用于量化深度神经网络的开源库，支持不同的量化方法和精度配置。链接

19. XNOR-Net：一个基于二值权重和激活的量化深度学习模型，可以减小模型的尺寸和计算量。链接

20. QUANTIZATION：一个针对深度神经网络模型的量化库，支持多种量化算法和方法。链接