AWQ

La cuantización de pesos consciente de la activación (AWQ) conserva una pequeña fracción de los pesos que son importantes para el rendimiento de los LLM, lo que permite comprimir un modelo a 4 bits con una degradación mínima del rendimiento.

Existen varias bibliotecas para cuantizar modelos con el algoritmo AWQ, como llm-awq, autoawq o optimum-intel. Transformers admite la carga de modelos cuantizados con las bibliotecas llm-awq y autoawq. Esta guía te mostrará cómo cargar modelos cuantizados con autoawq, aunque el proceso es similar para los modelos cuantizados con llm-awq.

Ejecuta el siguiente comando para instalar autoawq

pip install autoawq

AutoAWQ desactualiza Transformers a la versión 4.47.1. Si deseas realizar inferencia con AutoAWQ, es posible que necesites reinstalar tu versión de Transformers después de instalar AutoAWQ.

Identifique un modelo cuantizado con AWQ comprobando la clave quant_method en el archivo config.json del modelo.

{
  "_name_or_path": "/workspace/process/huggingfaceh4_zephyr-7b-alpha/source",
  "architectures": [
    "MistralForCausalLM"
  ],
  ...
  ...
  ...
  "quantization_config": {
    "quant_method": "awq",
    "zero_point": true,
    "group_size": 128,
    "bits": 4,
    "version": "gemm"
  }
}

Carga el modelo cuantizado con AWQ mediante from_pretrained(). Esto establece automáticamente los demás pesos en fp16 de forma predeterminada por razones de rendimiento. Utiliza el parámetro dtype para cargar estos otros pesos en un formato diferente.

Si el modelo se carga en la CPU, use el parámetro device_map para moverlo a un acelerador.

from transformers import AutoModelForCausalLM, AutoTokenizer
from accelerate import Accelerator
import torch

device = Accelerator().device

model = AutoModelForCausalLM.from_pretrained(
  "TheBloke/zephyr-7B-alpha-AWQ",
  dtype=torch.float32,
  device_map=device
)

Utilice attn_implementation para habilitar FlashAttention2 y acelerar aún más la inferencia.

from transformers import AutoModelForCausalLM, AutoTokenizer
from accelerate import Accelerator

model = AutoModelForCausalLM.from_pretrained(
  "TheBloke/zephyr-7B-alpha-AWQ",
  attn_implementation="flash_attention_2",
  device_map=Accelerator().device
)

Módulos fusionados

Los módulos fusionados ofrecen una mayor precisión y rendimiento. Se admiten de forma nativa para los módulos AWQ de las arquitecturas Llama y Mistral, pero también es posible fusionar módulos AWQ para arquitecturas no admitidas.

Los módulos fusionados no pueden combinarse con otras técnicas de optimización, como FlashAttention2.

Cree una AwqConfig y establezca los parámetros fuse_max_seq_len y do_fuse=True para habilitar los módulos fusionados. El parámetro fuse_max_seq_len es la longitud total de la secuencia y debe incluir la longitud del contexto y la longitud de generación esperada. Establezca un valor mayor para mayor seguridad.

El siguiente ejemplo fusiona los módulos AWQ del modelo TheBloke/Mistral-7B-OpenOrca-AWQ.

Copiado

import torch
from transformers import AwqConfig, AutoModelForCausalLM

quantization_config = AwqConfig(
    bits=4,
    fuse_max_seq_len=512,
    do_fuse=True,
)
model = AutoModelForCausalLM.from_pretrained(
  "TheBloke/Mistral-7B-OpenOrca-AWQ",
  quantization_config=quantization_config
).to(0)

El modelo TheBloke/Mistral-7B-OpenOrca-AWQ se evaluó con batch_size=1, tanto con como sin módulos fusionados.

Tamaño del lote	Longitud de prellenado	Longitud de decodificación	Tokens de prellenado/s	Decodificar tokens/s	Memoria (VRAM)
1	32	32	60.0984	38.4537	4,50 GB (5,68%)
1	64	64	1333.67	31.6604	4,50 GB (5,68%)
1	128	128	2434.06	31.6272	4,50 GB (5,68%)
1	256	256	3072.26	38.1731	4,50 GB (5,68%)
1	512	512	3184.74	31.6819	4,59 GB (5,80%)
1	1024	1024	3148.18	36.8031	4,81 GB (6,07%)
1	2048	2048	2927.33	35.2676	5,73 GB (7,23%)

Tamaño del lote	Longitud de prellenado	Longitud de decodificación	Tokens de prellenado/s	Decodificar tokens/s	Memoria (VRAM)
1	32	32	81.4899	80.2569	4,00 GB (5,05%)
1	64	64	1756.1	106.26	4,00 GB (5,05%)
1	128	128	2479.32	105.631	4,00 GB (5,06%)
1	256	256	1813.6	85.7485	4,01 GB (5,06%)
1	512	512	2848.9	97.701	4,11 GB (5,19%)
1	1024	1024	3044.35	87.7323	4,41 GB (5,57%)
1	2048	2048	2715.11	89.4709	5,57 GB (7,04%)

También se probaron la velocidad y el rendimiento de los módulos fusionados y no fusionados con la biblioteca optimum-benchmark.

ExLlamaV2

Los kernels de ExLlamaV2 admiten un prefill y un decodificado más rápidos. Ejecute el siguiente comando para instalar la última versión de autoawq con soporte para ExLlamaV2.

pip install git+https://github.com/casper-hansen/AutoAWQ.git

Establezca version="exllama" en AwqConfig para habilitar los kernels de ExLlamaV2.

ExLlamaV2 es compatible con GPUs de AMD.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, AwqConfig

quantization_config = AwqConfig(version="exllama")

model = AutoModelForCausalLM.from_pretrained(
    "TheBloke/Mistral-7B-Instruct-v0.1-AWQ",
    quantization_config=quantization_config,
    device_map="auto",
)

Recursos

Ejecuta el cuaderno de demostración de AWQ para ver más ejemplos sobre cómo cuantizar un modelo, subir un modelo cuantizado al Hub y mucho más.