探索 Ovis 多模态大模型量化实战指南

由图 2 可见，采用 AWQ 算法量化后，Qwen2-VL-7B-Instruct 推理时的显存占用量与 GPTQ 算法接近，而推理用时显著高于 GPTQ。基于此数据，我们选择采用 GPTQ 算法来量化 Ovis1.6。

定制 AutoGPTQ 库

AutoGPTQ 库提供了用户友好的 API，用户可通过短短数行代码使用 GPTQ 算法量化自己的大语言模型。目前，AutoGPTQ 库已支持 Llama、Mistral、Gemma、Qwen、Yi 等主流 LLM。然而，该库无法直接支持 Qwen2-VL、Ovis 等多模态大模型。因此，我们需要定制其源码，使其适配 Ovis 的模型结构，从而完成量化。

代码分析

首先，我们需要了解使用 AutoGPTQ 库来量化模型的流程。AutoGPTQ 库的 README 给出的量化示例代码大致如下：

from transformers import AutoTokenizer, TextGenerationPipeline
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
import logging

pretrained_model_dir = "facebook/opt-125m"
quantized_model_dir = "opt-125m-4bit"

# 加载 Tokenizer
tokenizer = AutoTokenizer.from_pretrained(pretrained_model_dir, use_fast=True)

# 准备校准数据样本
examples = [
    tokenizer(
        "auto-gptq is an easy-to-use model quantization library with user-friendly apis, based on GPTQ algorithm."
    )
]

# 设置量化参数
quantize_config = BaseQuantizeConfig(
    bits=4,         # quantize model to 4-bit
    group_size=128,  # it is recommended to set the value to 128
    desc_act=False,  # set to False can significantly speed up inference but the perplexity may slightly bad
)

# 加载待量化模型
model = AutoGPTQForCausalLM.from_pretrained(pretrained_model_dir, quantize_config)

# 开始量化
model.quantize(examples)

# 保存量化模型
model.save_quantized(quantized_model_dir, use_safetensors=True)

加载量化后模型并推理的代码如下：

# 加载量化模型
model = AutoGPTQForCausalLM.from_quantized(quantized_model_dir, device="cuda:0")

# 设置推理样例
sample = "auto_gptq is"

# 推理
print(tokenizer.decode(model.generate(**tokenizer(sample, return_tensors="pt").to(model.device))[0]))

也即，量化一个模型大致需要经历如下流程：

准备校准样本：GPTQ、AWQ 等属于训练后量化算法，运行时会让原模型在校准数据上推理，记录隐藏层的激活值等信息，以确定合适的比例因子来量化模型参数，以实现更好的量化性能。

设置量化参数：如量化的位数等。这部分不需要过多调整。

加载模型；调用量化函数；保存量化模型。

而要加载一个量化模型并执行推理，只需用相应类的 from_quantized 方法加载模型，并将推理样本处理成该模型的 generate 方法所需入参格式，传入即可，与普通模型的推理过程一致。

可见，AutoGPTQ 的量化过程隐含了推理步骤在其中。这引发了一些问题：量化 Ovis 时，quantize 方法内是否会按正确的传参格式来调用 Ovis 以推理？怎样的校准数据变量格式才符合 quantize 方法内的调用要求？上述推理代码中传入 model.generate 的参数排布与 Ovis generate 方法的签名不符（详见 Ovis1.6 Hugging Face 仓库内的 modeling_ovis.py），如何解决该问题？仔细查看 model.quantize 和 model.generate 方法后，我们发现：

quantize 方法用 examples 参数接收校准数据，其类型提示为 examples: List[Dict[str, Union[List[int], torch.LongTensor]]]，也即 examples 需要是一个 list，其内各元素为字典，字典内各个值为 torch Tensor 或整数列表。

quantize 方法内共有三处使用了 examples，依次为：

examples = self._prepare_examples_for_quantization(examples, batch_size)：调用 _prepare_examples_for_quantization 方法对传入的 examples 参数做某种转换。

num_batches = len(examples)：求转换后的 examples 的长度，设其值为 batch 的总数。由此可见，_prepare_examples_for_quantization 方法的其中一个功能是将校准样本组成 batch，使返回的 examples 列表内的元素从原先的表示单个样本变成表示一个 batch 的样本。

见代码：

for example in examples:
    for k, v in example.items():
        if len(v.shape) == 1:
            v = v.unsqueeze(0)
        example[k] = move_to_device(v, cur_layer_device)
    try:
        self.model(**example)
    except ValueError:
        pass

也即，examples 列表内的元素经处理后仍是字典，但每个字典内包含一个 batch 的样本。在该循环中，对每个 batch，先将其值转移到对应的设备上（如 GPU），再解包 batch 字典，将其键 - 值对直接传给模型来推理。

上述 self.model(**example) 是 quantize 方法唯一调用模型进行推理的地方。

model.generate 方法代码如下：

def generate(self, **kwargs):
    """shortcut for model.generate"""
    with torch.inference_mode(), torch.amp.autocast(device_type=self.device.type):
        return self.model.generate(**kwargs)

可见该方法仅用作将传入参数转发给原模型的 generate 方法，并在 torch.inference_mode 下开启 AMP 来执行。

由这些观察，我们可以得出结论：只需在 num_batches = len(examples) 处，保证 examples 内各样本为已组好 batch 的字典，其中的各 key 值为调用 self.model() 推理时的入参名，且各 value 为对应值，即可保证 quantize 方法正常执行模型推理。同时，只需修改 model.generate 方法自身入参结构，或在一个继承了其所在基类的子类中覆写该方法，即可正常执行 Ovis 推理。

我们继续看 AutoGPTQ 官方的如何量化不在支持列表内模型的教程：

from auto_gptq.modeling import BaseGPTQForCausalLM

class OPTGPTQForCausalLM(BaseGPTQForCausalLM):
    # chained attribute name of transformer layer block
    layers_block_name = "model.decoder.layers"
    # chained attribute names of other nn modules that in the same level as the transformer layer block
    outside_layer_modules = [
        "model.decoder.embed_tokens", "model.decoder.embed_positions", "model.decoder.project_out",
        "model.decoder.project_in", "model.decoder.final_layer_norm"
    ]
    # chained attribute names of linear layers in transformer layer module
    # normally, there are four sub lists, for each one the modules in it can be seen as one operation,
    # and the order should be the order when they are truly executed, in this case (and usually in most cases),
    # they are: attention q_k_v projection, attention output projection, MLP project input, MLP project output
    inside_layer_modules = [
        ["self_attn.k_proj", "self_attn.v_proj", "self_attn.q_proj"],
        ["self_attn.out_proj"],
        ["fc1"],
        ["fc2"]
    ]

# After this, you can use OPTGPTQForCausalLM.from_pretrained and other methods as shown in Basic.

可见，对于不在支持列表内的模型，只需继承 BaseGPTQForCausalLM 类，并根据模型结构设置好相关变量的值，即可用新建类的 from_pretrained 方法来加载模型，并调用 quantize 方法来完成量化。

基于以上分析，我们按下列方式修改了 AutoGPTQ 库的代码，以实现 Ovis 模型的量化。

修改代码：新增 ovis.py

在 auto_gptq.modeling 目录中，AutoGPTQ 库支持的各模型均将其量化类实现在对应 py 文件中。例如，gemma2.py 的内容如下：

from logging import getLogger
from ._base import BaseGPTQForCausalLM

logger = getLogger(__name__)

class Gemma2GPTQForCausalLM(BaseGPTQForCausalLM):
    layer_type = "Gemma2DecoderLayer"
    layers_block_name = "model.layers"
    outside_layer_modules = ["model.embed_tokens", "model.norm"]
    inside_layer_modules = [
        ["self_attn.k_proj", "self_attn.v_proj", "self_attn.q_proj"],
        ["self_attn.o_proj"],
        ["mlp.up_proj", "mlp.gate_proj"],
        ["mlp.down_proj"],
    ]

__all__ = ["Gemma2GPTQForCausalLM"]

其中：

OvisGPTQForCausalLM 类继承了 BaseGPTQForCausalLM，并根据 Ovis1.6-Gemma2-9B 和 Ovis1.6-Llama3.2-3B 模型内子模块层级结构，定义了 outside_layer_modules 等量化所需变量值。注意，我们仿照 Qwen2-VL 的做法，只量化多模态模型中 LLM 部分的 Decoder 层，而保持 ViT 及模型其它部分不变。

generate 方法覆写了 BaseGPTQForCausalLM.generate 以适应 Ovis generate 方法的入参结构。

_prepare_examples_for_quantization 待下一节介绍。

对于采用不同 LLM 基座的 Ovis 模型（Gemma2, Llama3.2），我们定义 OvisGPTQForCausalLM 的不同子类来分别实现其特化部分。其中与 fused_attn_module_type 等变量相关的代码摘自 auto_gptq.modeling 内的 llama.py。

最后，在 auto_gptq.modeling 目录内的 init.py 中导入 OvisGemma2GPTQForCausalLM 和 OvisLlamaGPTQForCausalLM，以方便使用。

校准数据的变量格式

按上文修改后，我们便可大致按下列代码实现 Ovis 模型的量化：

from auto_gptq.modeling import OvisGemma2GPTQForCausalLM

# 准备校准数据样本
examples = ...

# 设置量化参数
...

# 加载待量化模型
model = OvisGemma2GPTQForCausalLM.from_pretrained(...)

# 开始量化
model.quantize(examples=examples, ...)

# 保存
model.save_quantized(...)

此时，我们需要准备好校准样本，并处理好其变量格式，以在作为 examples 参数传入 quantize 方法后正常运行。根据上节的分析，我们将传入 quantize 方法的 examples 设计为一个 torch Dataloader，其在被遍历时会返回已完成 padding 的 batch 样本字典，可直接解包作为各参数传入 Ovis 模型的 forward 函数以实现推理。此时，由于样本组 batch 等工作已被 Dataloader 实现，故应采用某种方式使得 _prepare_examples_for_quantization 方法在 quantize 方法内被调用时不对 examples 做任何改变。我们通过在自定义的 OvisGPTQForCausalLM 类中覆写 _prepare_examples_for_quantization 实现了这一点。详细的校准数据变量格式构造参见 Ovis1.6-Gemma2-9B-GPTQ-Int4 或 Ovis1.6-Llama3.2-3B-GPTQ-Int4 的 Hugging Face model card。

完整的量化方案

我们开源了经以上方式修改后的 AutoGPTQ 库，并在量化版 Ovis 模型的 Hugging Face Model Card 内给出了详细的使用指南，便于社区用户部署 Ovis 量化模型或量化经自己微调后的 Ovis。完整的方案如下。

安装运行环境：

# BE SURE TO RUN UNDER CUDA 12.1
# 1. Get a basic environment
conda create -n <your_env_name> python=3.10
conda activate <your_env_name>
pip install torch==2.2.1 torchvision==0.17.1 torchaudio==2.2.1 --index-url https://download.pytorch.org/whl/cu121
pip install numpy==1.24.3 transformers==4.44.2 pillow==10.3.0 gekko pandas

# 2. Build AutoGPTQ: We customized AutoGPTQ to support Ovis model quantization. You need to build from source to install the customized version.
git clone https://github.com/AIDC-AI/AutoGPTQ.git
cd AutoGPTQ
pip install -vvv --no-build-isolation -e .

调用 Ovis 量化模型执行推理：代码大纲

from transformers import GenerationConfig
from auto_gptq.modeling import OvisGemma2GPTQForCausalLM

# load model
load_device = "cuda:0" # customize load device
model = OvisGemma2GPTQForCausalLM.from_quantized(
    "AIDC-AI/Ovis1.6-Gemma2-9B-GPTQ-Int4",
    device=load_device,
    trust_remote_code=True
)
model.model.generation_config = GenerationConfig.from_pretrained("AIDC-AI/Ovis1.6-Gemma2-9B-GPTQ-Int4")
text_tokenizer = model.get_text_tokenizer()
visual_tokenizer = model.get_visual_tokenizer()

# THE REST IS THE SAME AS UNQUANTIZED VERSIONS OF OVIS
...

微调原版 Ovis 模型后，自行量化：代码大纲

from auto_gptq.modeling import OvisGemma2GPTQForCausalLM

# Load Model
model = OvisGemma2GPTQForCausalLM.from_pretrained(
    model_path,
    quantize_config,
    torch_dtype=torch.bfloat16,
    multimodal_max_length=8192,
    trust_remote_code=True
).cuda()
model.model.llm.model.config.use_cache = False

# Prepare your own calibration samples here and format them as follows
data_list = [
    {
        "image": "path/to/image/of/this/sample",
        "conversations": [
            {
                "from": "human",
                "value": "<image>\n[Your sample prompt]"
            },
            {
                "from": "gpt",
                "value": "[Anything]"
            }
        ]
    },
    ...
]

# See the Hugging Face Model Cards for details on dataloader formation
train_loader = ...

# Start quantizing
model.quantize(examples=train_loader, cache_examples_on_gpu=False)

# Save quantized model
quantize_save_path = ...
model.save_quantized(quantize_save_path, use_safetensors=True)

总结

为了使 Ovis 模型能够在消费级设备上运行，让更多的开源社区用户可以在本地部署，我们使用 AutoGPTQ 对 Ovis1.6 的 9B 和 3B 版本进行了量化，并发布了 Ovis1.6-Gemma2-9B-GPTQ-Int4 和 Ovis1.6-Llama3.2-3B-GPTQ-Int4。

在未来，我们将持续迭代 Ovis，为开源社区贡献性能更高、使用更便捷的多模态大模型。