LLM量化的终极手册：从入门到精通

最新推荐文章于 2024-07-18 00:52:22 发布

数云界

最新推荐文章于 2024-07-18 00:52:22 发布

阅读量650

点赞数 18

文章标签：人工智能云计算

本文链接：https://blog.csdn.net/2401_85233349/article/details/140372261

版权

欢迎来到雲闪世界。大型号CPU 上的 LM？是的，你没听错。从处理对话到创建自己的图像，人工智能自诞生以来已经取得了长足的进步。但它也带来了瓶颈。随着模型的扩展，它们的计算需求也随之增加。人工智能开始严重依赖计算能力。为了满足这些需求，我们转向了 GPU，剩下的就成了历史。

许多设备不具备强大的 GPU，因此无法发挥 AI 功能。为了在计算能力有限的设备（如手机或仅配备 CPU 的计算机）上运行 AI 模型，有必要缩小这些模型的大小和性能。早期的努力包括修剪和蒸馏等技术。然而，这些方法对于通常具有大规模架构的 LLM 来说并不可行。

最近，LLM 的 AI 革命或多或少是基于云服务器进行训练、部署和推理的。然而，主要参与者现在正在将 LLM 功能扩展到边缘设备。微软的 copilot+PC 就是一个很好的例子，值得期待。随着我们走向边缘部署，在不影响性能或质量的情况下优化 LLM 大小变得至关重要。实现这种优化的一种有效方法是通过量化。

在本文中，我们将深入探讨量化和一些最先进的量化方法。我们还将了解如何使用它们。

量化：是什么？为什么？

根据精度要求和可用的计算资源，神经网络的权重可以用各种数据类型表示。量化是一种将高精度权重值（如 FP32）的范围（由数据类型的 [最小值，最大值] 决定）映射到较低精度值（如 FP16 或甚至 INT8（8 位整数）数据类型）的过程。

考虑一下你的 400M 参数 LLM。通常，权重以 FP32（32 位）存储。此模型的内存占用可以计算如下：

4x10⁸ 参数 x 4 字节= 1.6 GB

量化上述模型可以显著减小尺寸。考虑从 FP32 到 INT8 的转换。量化模型的内存占用量可以计算如下：

4x10⁸ 参数 x 1 字节 = 0.4 GB

这是原始大小的1/4 ！这有助于模型占用更少的内存，并提高推理速度，尽管这可能会稍微影响准确性。此外，其中一些轻量级模型可以轻松由 CPU 处理。

量化与反量化（亚马逊云AWS、谷歌GCP代理协助）

量化过程中权重的范围映射通常使用两种方法完成。

线性/尺度量化

这里的量化类似于在指定范围内的缩放。Rmin被映射到Qmin，Rmax被映射到Qmax。实际范围内的0被映射到量化范围内的相应zero_point 。

亚马逊云AWS、谷歌GCP代理协助

仿射量化

此方法可以表示更多不对称范围。这里的参数是：

对于 INT8 数据类型，公式如下

应用此转换后，某些数据将超出范围。为了将它们纳入范围，需要使用额外的裁剪操作。

在量化大型语言模型 (LLM) 时，主要有两种类型的量化技术：

训练后量化（PTQ）

顾名思义，LLM 在训练阶段后进行量化。权重从较高精度转换为较低精度的数据类型。它可以应用于权重和激活。虽然速度、内存和功耗都得到了高度优化，但仍存在准确性的权衡。
在量化过程中，会发生舍入或截断，从而引入量化误差。此误差会影响模型表示权重之间细粒度差异的能力。

量化感知训练

这项技术是为了减轻 PTQ 情况下模型精度的潜在损失而开发的。与 PTQ 相比，量化过程与训练本身融为一体，因此使该过程具有“量化感知”功能。

在 QAT 中，模型架构最初经过修改，以同时保留元素的全精度和量化版本，其中包括权重和激活，从而创建双存储系统。在训练过程的前向传递过程中，将模拟或“假”量化引入模型，使其在计算梯度时体验量化效果，同时仍保留精度，从而增强模型对量化的鲁棒性。

来源：论文

🎯为什么要量化？

减少内存占用
量化可以有效降低 LLM 的内存需求，使其可以方便地部署在低端机器和边缘设备上。许多边缘设备仅支持整数数据类型存储。
推理速度更快
较低精度的计算（整数）本质上比较高精度的计算（浮点）更快。因此，通过使用量化权重，推理过程中的数学运算会加快。此外，许多现代 CPU 和 GPU 都有专门用于低精度计算的指令，可以在量化模型时利用这些指令。这种硬件加速可以显著提高推理速度。
降低能耗
许多现代硬件加速器针对低精度计算进行了优化。当模型量化时，这些加速器每瓦能量可以执行更多操作。

最新的 SOTA 量化方法

LLM.int8()（2022 年 8 月）

它涉及将权重从 FP16 转换为 INT8，从而有效地将 LLM 的大小减半。该方法声称可以有效地将 LLM 的大小减少到 175B 个参数，而不会降低性能。

在了解论文[1] 的细节之前，重要的是要了解 LLM 具有新兴特征- 从训练数据中产生的模式，对模型的性能至关重要。其中一些特征可能具有很大的量级，并且可以对模型的整体性能产生很大的影响。

涉及的步骤：

LLM.int8 ()方法从向量量化开始。这意味着每个向量（矩阵中的一行）都使用其自己的规范化常数单独量化。这样可以保留每个特征的相对重要性。
对于每个向量，都会计算一个归一化常数，用于缩放向量，以便它们可以表示为 8 位整数。通过使用归一化常数，LLM 中的大多数特征都被量化。
对于出现的异常值（具有异常大幅度的特征），使用混合精度分解方案。这会将这些异常值特征隔离到单独的 16 位矩阵乘法中，确保准确处理它们，同时仍允许超过 99.9% 的值以 8 位相乘。

优点
LLM 可以量化并立即用于推理，而不会降低性能。

缺点
该方法仅关注 INT8 数据类型和高达 175B 参数的模型（尤其是 OPT-175B / BLOOM）。

代码实现

<span style="background-color:#f9f9f9"><span style="color:#242424"><span style="color:#aa0d91">从</span>transformers<span style="color:#aa0d91">导入</span>AutoTokenizer，AutoModelForCausalLM
<span style="color:#aa0d91">导入</span>torch 

model_id = <span style="color:#c41a16">“meta-llama/Llama-2-7b-chat-hf”</span>

 tokenizer = AutoTokenizer.from_pretrained(model_id) 
model_8bit = AutoModelForCausalLM.from_pretrained(model_id, device_map= <span style="color:#c41a16">“auto”</span> , load_in_8bit= <span style="color:#aa0d91">True</span> )</span></span>

GPTQ（2022 年 10 月）

GPTQ 是一种早期的一次性 PTQ 技术，可以高效部署大型语言模型。它主要通过论文[ 4] 中提出的两个特性实现，

分层量化
量化在 LLM 中逐层执行。目标是找到一个更简单的权重版本，当我们使用它进行预测时，它仍然可以给我们带来良好的结果。这样做的目的是使原始权重和简化权重之间的差异尽可能小，即最低均方误差。
最佳脑量化
这是一种旨在减少由于量化而引入模型的误差的算法。在量化权重的同时，其余权重也会进行调整。

优点
GPTQ 允许最多 2 位量化，在模型大小和性能之间提供一系列权衡。

缺点：
使用此方法进行量化会导致性能显著下降。

代码实现

安装所需的库。

<span style="background-color:#f9f9f9"><span style="color:#242424">pip install auto-gptq transformers 加速</span></span>

加载模型并使用autogptq库对其进行量化。

<span style="background-color:#f9f9f9"><span style="color:#242424"><span style="color:#aa0d91">从</span>transformers<span style="color:#aa0d91">导入</span>AutoModelForCausalLM、AutoTokenizer、GPTQConfig 
model_id = <span style="color:#c41a16">“meta-llama/Llama-2-7b-hf”</span>
 tokenizer = AutoTokenizer.from_pretrained(model_id) 
quant_config = GPTQConfig(bits= <span style="color:#1c00cf">4</span> , dataset = <span style="color:#c41a16">“c4”</span> , tokenizer=tokenizer) 
model = AutoModelForCausalLM.from_pretrained(model_id, device_map= <span style="color:#c41a16">“auto”</span> , quantization_config=quant_config)</span></span>

QLoRA（2023 年 5 月）

在深入研究 QLoRA 之前，我们先简单介绍一下LoRA。LoRA （大型语言模型的低秩自适应）是一种参数高效的微调方法，用于专门针对特定任务的LLM 。它通过将基于秩分解的可训练矩阵集成到每个转换器层来实现这一点。此外，它最大限度地减少了需要为目标任务训练的参数数量，同时保持原始预训练模型权重不变。在此处阅读更多信息。

QLoRA是 LoRA 的增强版本。以下是论文[2]中描述的该方法的亮点

1. 4 位标准浮点量化：
4 位标准浮点通过计算0 到 1 范围内分布的2ᵏ+1分位数（其中 k 是位数）来运行，随后将这些值标准化以适应 [-1, 1] 区间。通过这种标准化，我们可以类似地将神经网络权重调整到 [-1, 1] 范围并继续量化。

2.双重反量化：
这涉及量化 4 位 NF 量化过程中采用的量化常数。它可以为每个参数平均节省 0.5 位。这是有益的，因为 QLoRA 采用了逐块 k 位量化。

3.分页优化：
QLoRA 使用 Nvidia 的统一内存功能，实现从 GPU 到 CPU 的高效页面传输。这可防止 GPU 过载，并提高训练效率，且不会中断。

优点
QLoRA 由于 GPU 内存使用率较低，可以支持更长的最大序列长度和更多的批次数。

缺点
调音速度可能比较慢，成本效率也比较低，不过不用担心。

代码实现

安装所需的库

<span style="background-color:#f9f9f9"><span style="color:#242424">pip install -q -U trl transformers 加速 git+https://github.com/huggingface/peft.git 
pip install -q 数据集 bitsandbytes</span></span>

加载模型和标记器。配置 LoRA 参数。

<span style="background-color:#f9f9f9"><span style="color:#242424"><span style="color:#aa0d91">导入</span>torch
<span style="color:#aa0d91">从</span>transformers<span style="color:#aa0d91">导入</span>AutoModelForCausalLM、AutoTokenizer、BitsAndBytesConfig、AutoTokenizer 

model_id = <span style="color:#c41a16">“meta-llama/Llama-2-7b-chat-hf”</span>

 bnb_config = BitsAndBytesConfig( 
    load_in_4bit= <span style="color:#aa0d91">True</span> , 
    bnb_4bit_quant_type= <span style="color:#c41a16">“nf4”</span> , 
    bnb_4bit_compute_dtype=torch.float16, 
) 

model = AutoModelForCausalLM.from_pretrained( 
    model_id, 
    quantization_config=bnb_config, 
    trust_remote_code= <span style="color:#aa0d91">True</span>
 ) 
model.config.use_cache = <span style="color:#aa0d91">False</span>

<span style="color:#aa0d91">从</span>peft<span style="color:#aa0d91">导入</span>LoraConfig、get_peft_model 

lora_alpha = <span style="color:#1c00cf">16</span>
 lora_dropout = <span style="color:#1c00cf">0.1</span>
 lora_r = <span style="color:#1c00cf">64</span>

 peft_config = LoraConfig( 
    lora_alpha=lora_alpha, 
    lora_dropout=lora_dropout, 
    r=lora_r，
    任务类型= <span style="color:#c41a16">“CAUSAL_LM”</span>
）</span></span>

SFTTrainer使用TRL 库中的工具设置训练器，该库为转换器提供了一个包装器Trainer，以便使用 PEFT 适配器轻松微调基于指令的数据集上的模型。当然，您需要一个数据集来进行训练。

<span style="background-color:#f9f9f9"><span style="color:#242424"><span style="color:#aa0d91">从</span>transformers<span style="color:#aa0d91">导入</span>TrainingArguments 

output_dir = <span style="color:#c41a16">"./models"</span>
 per_device_train_batch_size = <span style="color:#1c00cf">4</span>
 gradient_accumulation_steps = <span style="color:#1c00cf">4</span>
 optim = <span style="color:#c41a16">"paged_adamw_32bit"</span>
 save_steps = <span style="color:#1c00cf">100</span>
 logs_steps = <span style="color:#1c00cf">10</span>
 learning_rate = <span style="color:#1c00cf">2e-4</span>
 max_grad_norm = <span style="color:#1c00cf">0.3</span>
 max_steps = <span style="color:#1c00cf">100</span>
 warmup_ratio = <span style="color:#1c00cf">0.03</span>
 lr_scheduler_type = <span style="color:#c41a16">"constant"</span>

 training_arguments = TrainingArguments( 
    output_dir=output_dir, 
    per_device_train_batch_size=per_device_train_batch_size, 
    gradient_accumulation_steps=gradient_accumulation_steps, 
    optim=optim, 
    save_steps=save_steps, 
    logs_steps=logging_steps, 
    learning_rate=learning_rate, 
    fp16= <span style="color:#aa0d91">True</span> , 
    max_grad_norm=max_grad_norm, 
    max_steps=max_steps，
    warmup_ratio=warmup_ratio，
    group_by_length= <span style="color:#aa0d91">True</span>，
    lr_scheduler_type=lr_scheduler_type，
）

<span style="color:#aa0d91">从</span>trl<span style="color:#aa0d91">导入</span>SFTTrainer 

max_seq_length = <span style="color:#1c00cf">512</span>

 trainer = SFTTrainer（
    model=model，
    train_dataset=dataset，
    peft_config=peft_config，
    dataset_text_field= <span style="color:#c41a16">“text”</span>，
    max_seq_length=max_seq_length，
    tokenizer=tokenizer，
    args=training_arguments，
）

trainer.train（）</span></span>

AWQ（2023 年 6 月）

AWQ（激活感知权重量化）是一种训练后量化方法。在这种方法中，模型的激活被用来代替权重。我直接引用论文[ 3] 中的话，

我们的方法基于这样的观察：权重的重要性并不相同：仅保护 1% 的显著权重即可大大减少量化误差。然后，我们建议通过观察激活（而不是权重）来寻找保护显著权重的最佳每通道缩放比例。

优点
AWQ 比其他方法更准确，因为保留了对 LLM 性能至关重要的权重。它不涉及反向传播或重建，因此效率更高、速度更快。它在边缘设备上表现良好。

缺点
虽然在 FP16 中保持 0.1% 的权重可以在不显著增加模型大小的情况下增强量化性能，但这种混合精度数据类型使系统实现变得复杂。

代码实现

安装所需的库。

<span style="background-color:#f9f9f9"><span style="color:#242424">!pip 安装 autoawq transformers 加速</span></span>

加载模型并使用autoawq库对其进行量化。

<span style="background-color:#f9f9f9"><span style="color:#242424"><span style="color:#aa0d91">从</span>awq<span style="color:#aa0d91">导入</span>AutoAWQForCausalLM
<span style="color:#aa0d91">从</span>transformers<span style="color:#aa0d91">导入</span>AutoTokenizer 
model_id = <span style="color:#c41a16">'meta-llama/Llama-2-7b-hf'</span>
 quant_path = <span style="color:#c41a16">'Llama2-7b-awq-4bit'</span>
 quant_config = { <span style="color:#c41a16">"zero_point"</span> : <span style="color:#aa0d91">True</span> , <span style="color:#c41a16">"q_group_size"</span> : <span style="color:#1c00cf">128</span> , <span style="color:#c41a16">"w_bit"</span> : <span style="color:#1c00cf">4</span> } 

<span style="color:#007400"># 加载模型和标记器</span>
model = AutoAWQForCausalLM.from_pretrained(model_id) 
tokenizer = AutoTokenizer.from_pretrained(model_id, use_fast= <span style="color:#aa0d91">True</span> ) 

<span style="color:#007400"># 量化</span>
model.quantize(tokenizer, quant_config=quant_config)</span></span>

Quip#（2023 年 7 月）

简单来说，QuIP（带非相干处理的量化）基于这样的思想：如果模型的权重分布均匀（不相干），并且对它们进行舍入的重要方向与坐标轴不一致，则可以改进量化过程。它包含两个步骤：

LDLQ 自适应舍入程序：以最小化一定程度的误差（“二次代理目标”）的方式调整模型的权重 [8]。
预处理和后处理：将权重和 Hessian 矩阵乘以随机正交矩阵。这确保权重和 Hessian 不相干，这对量化过程有利。

QuIP# [5] 在 QuIP 基础上通过一些处理上的改进取得了进展。

改进的不相干处理：它使用一种称为随机阿达玛变换的更快更好的方法。
矢量量化：QuIP# 使用矢量量化来利用非相干权重所具有的球形亚高斯分布。具体来说，它引入了一组基于高度对称的 E8 格子的硬件高效码本。E8 格子实现了最佳的 8 维单元球填充，这意味着它可以更有效地表示权重。

优点
与其他方法相比，QuIP# 在相同或更好的量化质量下提供了明显更高的吞吐量 (>40%)。对于 2 位量化来说，这还不错。

缺点
虽然没有提到太多限制，但可以考虑复杂性和硬件兼容性。

代码实现

克隆官方 repo并安装所需的库。

<span style="background-color:#f9f9f9"><span style="color:#242424">git clone https://github.com/Cornell-RelaxML/quip-sharp.git<span style="color:#5c2699">克隆</span>https://github.com/Cornell-RelaxML/quip-sharp.git 
pip install -r requirements.txt 
<span style="color:#5c2699">cd</span> quiptools && python setup.py install && <span style="color:#5c2699">cd</span> ../</span></span>

找到各种模型的脚本。运行脚本quantize_finetune_llama.py以使用 llama 模型。

另外，请查看quip 量化的repo。量化模型的代码如下所示。

<span style="background-color:#f9f9f9"><span style="color:#242424"><span style="color:#aa0d91">导入</span>torch
<span style="color:#aa0d91">从</span>transformers<span style="color:#aa0d91">导入</span> AutoModelForCausalLM、AutoTokenizer
<span style="color:#aa0d91">从</span>quantizer<span style="color:#aa0d91">导入</span> QuipQuantizer

 model_name = <span style="color:#c41a16">"meta-llama/Llama-2-70b-hf"</span> quant_dir =
 " <span style="color:#c41a16">llama-70b_2bit_quip"</span>
 tokenizer = AutoTokenizer.from_pretrained ( model_name) model = AutoModelForCausalLM.from_pretrained (model_name, torch_dtype=torch.float16 ) quant = QuipQuantizer (codebook= " E8P12 <span style="color:#c41a16">"</span> , dataset= <span style="color:#c41a16">"redpajama"</span> ) quant.quantize_model (model, tokenizer, quant_dir )



</span></span>

GGUF（2023 年 8 月）

GGUF（GPT 生成的统一格式）是Georgi Gerganov和llama.cpp团队备受期待的版本。主要亮点确实是 LLM 现在可以轻松在消费级 CPU 上运行的功能。以前它被称为 GGML，后来升级为 GGUF。GGML
的一个显著成就是能够在必要时将 LLM 的某些层卸载到 GPU，即使 LLM 在 CPU 上运行。这有效地解决了开发人员因 VRAM 不足而面临的全球挑战。

优点
如果您计划在 CPU 或 Apple 设备（M 系列芯片）上运行 LLM，那么它是许多 LLM（如 Llama 和 Mistral）的首选方法。GGUF 文件格式现在得到了 llama.cpp 和 HuggingFace 的良好支持。与其他格式相比，GGUF 模型的困惑度分数也较低。

缺点
GGUF 专注于 CPU 和 Apple M 系列设备。如果您使用不同的硬件配置，这可能会成为一种限制。

代码实现

安装ctransformers库。

<span style="background-color:#f9f9f9"><span style="color:#242424">pip 安装 ctransformers[cuda]</span></span>

Bloke 在 HuggingFace 的存储库中提供了模型。

<span style="background-color:#f9f9f9"><span style="color:#242424"><span style="color:#aa0d91">从</span>ctransformers<span style="color:#aa0d91">导入</span>AutoModelForCausalLM
<span style="color:#aa0d91">从</span>transformers<span style="color:#aa0d91">导入</span>AutoTokenizer、pipeline 

<span style="color:#007400"># 加载 LLM 和 Tokenizer </span>
<span style="color:#007400"># 使用 `gpu_layers` 指定将有多少层卸载到 GPU。</span>
 model = AutoModelForCausalLM.from_pretrained( 
    <span style="color:#c41a16">"TheBloke/zephyr-7B-beta-GGUF"</span> , 
    model_file= <span style="color:#c41a16">"zephyr-7b-beta.Q4_K_M.gguf"</span> , 
    model_type= <span style="color:#c41a16">"mistral"</span> , gpu_layers= <span style="color:#1c00cf">50</span> , hf= <span style="color:#aa0d91">True</span>
 ) 
tokenizer = AutoTokenizer.from_pretrained( 
    <span style="color:#c41a16">"HuggingFaceH4/zephyr-7b-beta"</span> , use_fast= <span style="color:#aa0d91">True</span>
 ) 

<span style="color:#007400"># 创建管道</span>
pipe = pipeline(model=model, tokenizer=tokenizer, task= <span style="color:#c41a16">'text-generation'</span> )</span></span>

<span style="background-color:#f9f9f9"><span style="color:#242424"><span style="color:#aa0d91">从</span>ctransformers<span style="color:#aa0d91">导入</span>AutoModelForCausalLM
<span style="color:#aa0d91">从</span>transformers<span style="color:#aa0d91">导入</span>AutoTokenizer、pipeline 

<span style="color:#007400"># 加载 LLM 和 Tokenizer </span>
<span style="color:#007400"># 使用 `gpu_layers` 指定将有多少层卸载到 GPU。</span>
 model = AutoModelForCausalLM.from_pretrained( 
    <span style="color:#c41a16">"TheBloke/zephyr-7B-beta-GGUF"</span> , 
    model_file= <span style="color:#c41a16">"zephyr-7b-beta.Q4_K_M.gguf"</span> , 
    model_type= <span style="color:#c41a16">"mistral"</span> , gpu_layers= <span style="color:#1c00cf">50</span> , hf= <span style="color:#aa0d91">True</span>
 ) 
tokenizer = AutoTokenizer.from_pretrained( 
    <span style="color:#c41a16">"HuggingFaceH4/zephyr-7b-beta"</span> , use_fast= <span style="color:#aa0d91">True</span>
 ) 

<span style="color:#007400"># 创建管道</span>
pipe = pipeline(model=model, tokenizer=tokenizer, task= <span style="color:#c41a16">'text-generation'</span> )</span></span>

HQQ（2023 年 11 月）

根据论文，权重校准可以通过无数据校准技术（BitsAndBytes）和基于校准的技术（GPTQ 和 AWQ）实现。无校准方法速度更快，而基于校准的方法则存在数据偏差和量化时间问题。

HQQ（半二次方量化）使用快速而稳定的优化实时进行量化。它无需校准数据，并且足够灵活，可以量化任何给定的模型，从而实现无校准方法的速度，而不会出现数据偏差问题。由于半二次方分裂等优化技术，它将量化时间大大缩短至几分钟。有关该方法的数学和工作原理的更多详细信息，请参阅官方网站。

优点
与其他方法相比，量化时间出奇地短（比 GPTQ 快 50 倍！）。无需校准数据，因此更加容易。

缺点
其他地方没有提到太多限制。它可能仍会像其他方法一样出现质量下降。

代码实现

安装 transformers 库并立即使用 HQQ 实现！

<span style="background-color:#f9f9f9"><span style="color:#242424"><span style="color:#aa0d91">从</span>transformers<span style="color:#aa0d91">导入</span>AutoModelForCausalLM、HqqConfig 

<span style="color:#007400"># 所有线性层将使用相同的量化配置</span>
quant_config = HqqConfig(nbits= <span style="color:#1c00cf">4</span> , group_size= <span style="color:#1c00cf">64</span> , quant_zero= <span style="color:#aa0d91">False</span> , quant_scale= <span style="color:#aa0d91">False</span> , axis= <span style="color:#1c00cf">1</span> ) 

model_id = <span style="color:#c41a16">"meta-llama/Llama-2-7b-hf" </span>

<span style="color:#007400"># 加载并量化</span>
model = AutoModelForCausalLM.from_pretrained( 
    model_id, 
    torch_dtype=torch.float16, 
    device_map= <span style="color:#c41a16">"cuda"</span> , 
    quantization_config=quant_config 
)</span></span>

AQLM（2024 年 2 月）

AQLM（语言模型的加法量化）是一种仅权重的 PTQ 方法，它在 2 位/参数范围内树立了新的基准。它的表现优于 GPTQ 以及 QuIP 和 QuIP# 等流行算法。

它采用了一种称为多码本量化 (MCQ)的新方法，该方法将每个向量划分为子向量，并使用一组有限的码字对其进行近似。码字是码本中定义的已学习向量[7]。AQLM 的工作原理是获取模型中权重矩阵的行并对其进行量化。

优点
AQLM 可在 GPU 和 CPU 上快速实现令牌生成，使其能够超越优化的 FP16 实现的速度，同时在显著减少的内存占用内运行。

缺点
其他地方只提到了一些限制。它可能仍会像其他方法一样出现质量下降。

代码实现

有关如何自行量化模型的说明以及相应的代码可以在官方 repo中找到。要运行 AQLM 模型，请加载已使用 AQLM 量化的模型：

<span style="background-color:#f9f9f9"><span style="color:#242424"><span style="color:#aa0d91">从</span>transformers<span style="color:#aa0d91">导入</span>AutoTokenizer，AutoModelForCausalLM 

quantized_model = AutoModelForCausalLM.from_pretrained( 
    <span style="color:#c41a16">“ISTA-DASLab/Mixtral-8x7b-AQLM-2Bit-1x16-hf”</span>，
    torch_dtype= <span style="color:#c41a16">“auto”</span>，
    device_map= <span style="color:#c41a16">“auto”</span>
 ) 
tokenizer = AutoTokenizer.from_pretrained( <span style="color:#c41a16">“ISTA-DASLab/Mixtral-8x7b-AQLM-2Bit-1x16-hf”</span> )</span></span>

量化方法开辟了一个充满可能性的世界，甚至在我们的口袋中也能实现高级语言处理功能。在本文中，我们讨论了有关 LLM 量化的所有内容，并详细探讨了量化 LLM 的各种方法。我们还讨论了每种方法的优缺点并学习了如何使用它们。此外，我们还深入了解了如何根据特定需求以及您使用的是 CPU 还是 GPU 来选择最合适的方法。

感谢关注雲闪世界

订阅频道(https://t.me/awsgoogvps_Host)
TG交流群(t.me/awsgoogvpsHost)