# Escolha um método

Se o seu checkpoint já estiver quantizado, o checkpoint determina o método. Carregue-o conforme mostrado em [Carregar um checkpoint pré-quantizado](./overview#load-a-pre-quantized-checkpoint). Caso contrário, escolha um método com base no seu hardware e no que você precisa fazer com o modelo após carregá-lo.

## Comece pelo seu objetivo

Cada linha recomenda um primeiro método para tentar. Consulte a tabela de comparação completa antes de se comprometer com um.

| Objetivo | Comece com | Por quê |
|---|---|---|
| Treine um modelo com menos memória e a configuração mínima | [bitsandbytes](./bitsandbytes) | Quantiza para 4 ou 8 bits durante o carregamento, sem calibração, executa em CUDA, XPU, HPU e CPU, e suporta salvamento e ajuste fino. |
| Ajuste fino com QLoRA | [bitsandbytes](./bitsandbytes#qlora) | Suporta 4-bit NF4 com PEFT. [HQQ](./hqq), [EETQ](./eetq), [GPTQ](./gptq), [SINQ](./sinq) e [Quanto](./quanto) também suportam fine-tuning. |
| Acelere a inferência com `torch.compile` | [torchao](./torchao) | `generate` compila modelos torchao automaticamente com um cache estático, e o torchao possui esquemas int4, int8 e FP8 para CUDA, XPU e CPU. |
| Obtenha a melhor precisão de 4 bits | [GPTQ](./gptq) | Calibra em um conjunto de dados durante o carregamento. Para usar [AWQ](./awq) ou [AutoRound](./auto_round) em vez disso, quantize com as respectivas bibliotecas e carregue o checkpoint. |
| Execute FP8 em Ada, Hopper ou Intel XPU | [FP8 de granularidade fina](./finegrained_fp8) | Exige capacidade de computação CUDA 8.9 ou superior, ou um XPU. [FBGEMM FP8](./fbgemm_fp8) exige capacidade de computação 9.0 ou superior, ou um XPU. |
| Executar FP4 no Blackwell | [NVFP4](./nvfp4) | Quantiza para o formato de ponto flutuante de 4 bits da NVIDIA durante o carregamento. [MXFP4](./mxfp4) é executado em capacidade de computação 7.5 ou superior, XPU e CPU. |
| Executar em Apple silicon | [Metal](./metal) | Quantiza para 2, 4 ou 8 bits no MPS durante o carregamento. Arquivos [GGUF](./gguf) também são carregados no MPS. |
| Carregar checkpoints criados com llm-compressor | [compressed-tensors](./compressed_tensors) | Carrega checkpoints FP8, int4 e int8 no formato compressed-tensors. |
| Comprimir abaixo de 4 bits | [HQQ](./hqq) ou [SINQ](./sinq) | Quantize para 2 ou 3 bits durante o carregamento, sem calibração. Os checkpoints de [AQLM](./aqlm), [VPTQ](./vptq) e [SpQR](./spqr) alcançam valores ainda menores, mas precisam ser quantizados com suas próprias bibliotecas. |

Exibir a tabela de comparação completa

| Método | `quant_method` | Fluxo de trabalho | Bits | Hardware | Salvar | Ajuste fino | Compilação automática |
|---|---|---|---|---|---|---|---|
| [AQLM](./aqlm) | `aqlm` | Somente pré-quantizado | 1–2 | CUDA, CPU | ✅ | ✅ com `aqlm>=1.0.2` | ❌ |
| [AutoRound](./auto_round) | `auto-round` | Somente pré-quantizado | 2–8 | CUDA, XPU, CPU | ✅ | ❌ | ❌ |
| [AWQ](./awq) | `awq` | Somente pré-quantizado | 4 | CUDA, ROCm, XPU, CPU | ✅ exceto os backends ExLlama | ✅ com `gptqmodel>=5.0.0` | ❌ |
| [BitNet](./bitnet) | `bitnet` | Somente pré-quantizado | 1.58 | CUDA | ✅ | Apenas `autobitlinear` no modo `online` | ❌ |
| [bitsandbytes](./bitsandbytes) | `bitsandbytes` | Durante o carregamento | 4, 8 | CUDA, XPU, HPU, CPU | ✅ | ✅ | ❌ |
| [compressed-tensors](./compressed_tensors) | `compressed-tensors` | Somente pré-quantizado | Definido por checkpoint | CUDA, XPU, MPS, CPU | ✅ | ✅ exceto com kernels FP8 | ✅ |
| [EETQ](./eetq) | `eetq` | Durante o carregamento | 8 | CUDA | ✅ | ✅ | ❌ |
| [FBGEMM FP8](./fbgemm_fp8) | `fbgemm_fp8` | Durante o carregamento | 8 | CUDA (capacidade de computação 9.0+), XPU | ✅ | ❌ | ❌ |
| [FP8 de granularidade fina](./finegrained_fp8) | `fp8`, `mxfp8` | Durante o carregamento | 8 | CUDA (capacidade de computação 8.9+), XPU | ✅ | ❌ | ✅ |
| [Quatro sobre seis](./fouroversix) | `fouroversix` | Durante o carregamento | 4 | CUDA (mais rápido no Blackwell), CPU | ✅ | Somente com `keep_master_weights=True` | ❌ |
| [FP-Quant](./fp_quant) | `fp_quant` | Durante o carregamento | 4 | CUDA, XPU | ✅ | Somente com `store_master_weights=True` | ❌ |
| [GGUF](./gguf) | `gguf` | Somente pré-quantizado | 1–8 | CUDA, MPS, XPU, CPU | ❌ | ❌ | ✅ |
| [GPTQ](./gptq) | `gptq` | Durante o carregamento, com calibração | 2, 3, 4, 8 | CUDA, ROCm, XPU, CPU | ✅ | ✅ | ❌ |
| [HIGGS](./higgs) | `higgs` | Durante o carregamento | 2, 3, 4 | CUDA | ✅ | ❌ | ❌ |
| [HQQ](./hqq) | `hqq` | Durante o carregamento | 1, 2, 3, 4, 8 | CUDA, XPU | ✅ | ✅ | ❌ |
| [Metal](./metal) | `metal` | Durante o carregamento | 2, 4, 8 | MPS | ✅ | ❌ | ❌ |
| [MXFP4](./mxfp4) | `mxfp4` | Durante o carregamento | 4 | CUDA (capacidade de computação 7.5+), XPU, CPU | ✅ | ❌ | ❌ |
| [NVFP4](./nvfp4) | `nvfp4` | Durante o carregamento | 4 | Uma GPU Blackwell | ❌ | ❌ | ✅ |
| [Quanto](./quanto) | `quanto` | Durante o carregamento | 2, 4, 8 | CUDA, MPS, XPU, CPU | ❌ | ✅ | ❌ |
| [Quark](./quark) | `quark` | Somente pré-quantizado | Definido por checkpoint | CUDA, ROCm, CPU | ❌ | ❌ | ❌ |
| [SINQ](./sinq) | `sinq` | Durante o carregamento | 2, 3, 4, 6, 8 | Uma GPU CUDA, CPU | ✅ | ✅ | ❌ |
| [SpQR](./spqr) | `spqr` | Somente pré-quantizado | 3 | CUDA | ✅ | ❌ | ❌ |
| [torchao](./torchao) | `torchao` | Durante o carregamento | 4, 8 | CUDA, XPU, CPU | ✅ | Somente esquemas de 8 bits | ✅ |
| [VPTQ](./vptq) | `vptq` | Somente pré-quantizado | 1–8 | CUDA | ✅ | ❌ | ❌ |

## Verifique a memória com o seletor de quantização

O [seletor de quantização](https://huggingface.co/spaces/stevhliu/quantization-picker) estima se um modelo cabe no seu hardware em cada precisão, incluindo o cache de KV. Escolha um modelo, o seu hardware e o que você precisa que o método faça, e a visão **Comparar** lista os métodos que correspondem.

<iframe src="https://stevhliu-quantization-picker.hf.space" frameborder="0" width="100%" height="420"
>

## Benchmarks

Os benchmarks abaixo comparam vários métodos em Llama 3.1 8B e 70B. Eles relatam a precisão, o throughput em tokens por segundo, a memória de pico em GB e o tempo de quantização.

O Llama 3.1 70B em bf16 foi executado em 2 GPUs NVIDIA A100 80GB. Os métodos FP8 foram executados em 1 GPU NVIDIA H100 80GB, e todos os outros métodos foram executados em 1 GPU NVIDIA A100 80GB. O throughput foi medido com batch size 1, gerando 64 tokens. Os resultados incluem `torch.compile` e kernels Marlin quando um método os suporta.

<iframe src="https://huggingface.co/datasets/derekl35/quantization-benchmarks/embed/viewer/default/train" frameborder="0" width="100%" height="560px" title="dataset de resultados de benchmarking"
>

Os resultados se agrupam em três faixas de bits.

| Bits | Métodos benchmarked | Memória vs. bf16 | Precisão |
|---|---|---|---|
| 8 | bitsandbytes int8, HQQ, Quanto, torchao, FP8 | Aproximadamente 2x menor | Muito próximo de bf16 |
| 4 | AWQ, GPTQ, HQQ, bitsandbytes NF4, SINQ | Aproximadamente 4x menor | Alto. AWQ e GPTQ frequentemente lideram, mas exigem calibração. |
| Abaixo de 4 | VPTQ, AQLM, 2-bit GPTQ | Mais de 4x menor | Queda perceptível, especialmente em 2 bits. AQLM e VPTQ levam muito tempo para quantizar. |

> [!TIP]
> Meça a precisão e a velocidade em sua própria tarefa e hardware antes de escolher um método para produção.