# HQQ

[Half-Quadratic Quantization (HQQ)](https://github.com/mobiusml/hqq/) suporta quantização rápida em tempo de execução para 8, 4, 3, 2 e até 1 bits. Não requer dados de calibração e é compatível com qualquer modalidade de modelo (LLMs, visão, etc.).

O HQQ também oferece suporte ao fine-tuning com [PEFT](https://huggingface.co/docs/peft) e é totalmente compatível com [torch.compile](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html) para inferência e treinamento ainda mais rápidos.

Instale o HQQ com o comando a seguir para obter a versão mais recente e compilar os kernels CUDA correspondentes, caso esteja usando um dispositivo CUDA. Ele também suporta Intel XPU com implementação pura em PyTorch.

```bash
pip install hqq
```

Você pode optar por substituir todas as camadas lineares de um modelo pela mesma configuração de quantização ou dedicar uma configuração de quantização específica para camadas lineares específicas.

Quantize um modelo criando um [HqqConfig](/docs/transformers/main/pt/main_classes/quantization#transformers.HqqConfig) e especificando `nbits` e `group_size` para substituir todas as camadas lineares ([torch.nn.Linear](https://pytorch.org/docs/stable/generated/torch.nn.Linear.html)) do modelo.

``` py
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, HqqConfig

quant_config = HqqConfig(nbits=8, group_size=64)
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B", 
    dtype=torch.float16, 
    device_map="auto", 
    quantization_config=quant_config
)
```

Quantize um modelo criando um dicionário que especifica o `nbits` e o `group_size` para as camadas lineares a serem quantizadas. Passe-os para [HqqConfig](/docs/transformers/main/pt/main_classes/quantization#transformers.HqqConfig) e defina quais camadas quantizar com a configuração. Essa abordagem é especialmente útil para quantizar misturas de especialistas (MoEs), pois são menos afetadas por configurações de quantização mais baixas.

``` py
q4_config = {'nbits':4, 'group_size':64}
q3_config = {'nbits':3, 'group_size':32}
quant_config  = HqqConfig(dynamic_config={
  'self_attn.q_proj':q4_config,
  'self_attn.k_proj':q4_config,
  'self_attn.v_proj':q4_config,
  'self_attn.o_proj':q4_config,

  'mlp.gate_proj':q3_config,
  'mlp.up_proj'  :q3_config,
  'mlp.down_proj':q3_config,
})

model = transformers.AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B", 
    dtype=torch.float16, 
    device_map="auto", 
    quantization_config=quant_config
)
```

## Backends

O HQQ suporta vários backends, incluindo PyTorch puro e kernels CUDA de desquantização personalizados. Esses backends são adequados para GPUs mais antigas e para treinamento com PEFT/QLoRA.

```py
from hqq.core.quantize import *

HQQLinear.set_backend(HQQBackend.PYTORCH)
```

Para inferência mais rápida, o HQQ suporta kernels fundidos de 4 bits (torchao e Marlin) após a quantização de um modelo. Esses podem alcançar até 200 tokens/seg em uma única 4090. O exemplo abaixo demonstra como habilitar o backend torchao_int4.

```py
from hqq.utils.patching import prepare_for_inference

prepare_for_inference("model", backend="torchao_int4")
```

Consulte o guia de [Backend](https://github.com/mobiusml/hqq/#backend) para mais detalhes.

## Recursos

Leia o post no blog [Half-Quadratic Quantization of Large Machine Learning Models](https://mobiusml.github.io/hqq_blog/) para mais detalhes sobre o HQQ.