AWQ

Quantização de Pesos com Consciência da Ativação (AWQ) preserva uma pequena fração dos pesos importantes para o desempenho de LLMs, comprimindo o modelo para 4 bits com degradação mínima de desempenho.

Existem várias bibliotecas para quantizar modelos com o algoritmo AWQ, como llm-awq, autoawq ou optimum-intel. O Transformers suporta o carregamento de modelos quantizados com as bibliotecas llm-awq e autoawq. Este guia mostrará como carregar modelos quantizados com autoawq, mas o processo é semelhante para modelos quantizados com llm-awq.

Execute o comando abaixo para instalar o autoawq

pip install autoawq

O AutoAWQ rebaixa o Transformers para a versão 4.47.1. Se você deseja realizar inferência com o AutoAWQ, pode ser necessário reinstalar a sua versão do Transformers após instalar o AutoAWQ.

Identifique um modelo quantizado com AWQ verificando a chave quant_method no arquivo config.json do 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"
  }
}

Carregue o modelo quantizado com AWQ usando from_pretrained(). Isso define automaticamente os outros pesos em fp16 por padrão, por motivos de desempenho. Use o parâmetro dtype para carregar esses outros pesos em um formato diferente.

Se o modelo for carregado na CPU, use o parâmetro device_map para movê-lo para um 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
)

Use attn_implementation para habilitar o FlashAttention2 e acelerar ainda mais a inferência.

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 fundidos

Módulos fundidos oferecem precisão e desempenho aprimorados. Eles são suportados nativamente para módulos AWQ das arquiteturas Llama e Mistral, mas você também pode fundir módulos AWQ para arquiteturas não suportadas.

Módulos fundidos não podem ser combinados com outras técnicas de otimização, como FlashAttention2.

Crie um AwqConfig e defina os parâmetros fuse_max_seq_len e do_fuse=True para habilitar os módulos fundidos. O parâmetro fuse_max_seq_len é o comprimento total da sequência e deve incluir o comprimento do contexto e o comprimento de geração esperado. Defina um valor maior para garantir a segurança.

O exemplo abaixo funde os módulos AWQ do 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)

O modelo TheBloke/Mistral-7B-OpenOrca-AWQ foi benchmarkado com batch_size=1, com e sem módulos fundidos.

Tamanho do Lote	Comprimento do Prefill	Comprimento de Decodificação	Tokens de prefill/s	Decodificar tokens/s	Memória (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%)

Tamanho do Lote	Comprimento do Prefill	Comprimento de Decodificação	Tokens de prefill/s	Decodificar tokens/s	Memória (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%)

A velocidade e a taxa de transferência dos módulos fundidos e não fundidos também foram testadas com a biblioteca optimum-benchmark.

ExLlamaV2

Os kernels do ExLlamaV2 suportam prefill e decodificação mais rápidos. Execute o comando abaixo para instalar a versão mais recente do autoawq com suporte a ExLlamaV2.

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

Defina version="exllama" em AwqConfig para habilitar os kernels ExLlamaV2.

O ExLlamaV2 é compatível com GPUs 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

Execute o notebook de demonstração do AWQ para mais exemplos de como quantizar um modelo, enviar um modelo quantizado para o Hub e muito mais.