# Elija un método

Si tu checkpoint ya está cuantizado, el checkpoint determina el método. Carga tal como se muestra en [Cargar un checkpoint precuantizado](./overview#load-a-pre-quantized-checkpoint). En caso contrario, elige un método en función de tu hardware y de lo que necesites hacer con el modelo después de cargarlo.

## Comience desde su objetivo

Cada fila recomienda un primer método para probar. Consulta la tabla de comparación completa antes de comprometerte con uno.

| Objetivo | Comience con | Por qué |
|---|---|---|
| Entrena un modelo con menos memoria y la mínima configuración | [bitsandbytes](./bitsandbytes) | Cuantiza a 4 u 8 bits durante la carga sin calibración, se ejecuta en CUDA, XPU, HPU y CPU, y admite guardar y realizar fine-tuning. |
| Ajuste fino con QLoRA | [bitsandbytes](./bitsandbytes#qlora) | Admite NF4 de 4 bits con PEFT. [HQQ](./hqq), [EETQ](./eetq), [GPTQ](./gptq), [SINQ](./sinq) y [Quanto](./quanto) también admiten el ajuste fino. |
| Acelera la inferencia con `torch.compile` | [torchao](./torchao) | `generate` compila automáticamente los modelos de torchao con una caché estática, y torchao cuenta con esquemas int4, int8 y FP8 para CUDA, XPU y CPU. |
| Obtén la mejor precisión de 4 bits | [GPTQ](./gptq) | Calibra en un conjunto de datos durante la carga. Para usar [AWQ](./awq) o [AutoRound](./auto_round) en su lugar, cuantice con sus bibliotecas y cargue el punto de control. |
| Ejecutar FP8 en Ada, Hopper o Intel XPU | [FP8 de gran granularidad](./finegrained_fp8) | Requiere una capacidad de cómputo CUDA de 8.9 o superior, o un XPU. [FBGEMM FP8](./fbgemm_fp8) requiere una capacidad de cómputo de 9.0 o superior, o un XPU. |
| Ejecutar FP4 en Blackwell | [NVFP4](./nvfp4) | Cuantiza al formato de coma flotante de 4 bits de NVIDIA durante la carga. [MXFP4](./mxfp4) se ejecuta en capacidad de cómputo 7.5 o superior, XPU y CPU. |
| Ejecutar en Apple silicon | [Metal](./metal) | Cuantiza a 2, 4 u 8 bits en MPS durante la carga. Los archivos [GGUF](./gguf) también se cargan en MPS. |
| Cargar puntos de control creados con llm-compressor | [compressed-tensors](./compressed_tensors) | Carga puntos de control en formato compressed-tensors con FP8, int4 e int8. |
| Comprimir a menos de 4 bits | [HQQ](./hqq) o [SINQ](./sinq) | Cuantice a 2 o 3 bits durante la carga, sin calibración. Los puntos de control de [AQLM](./aqlm), [VPTQ](./vptq) y [SpQR](./spqr) permiten una cuantización más baja, pero deben cuantizarse con sus propias librerías. |

Mostrar la tabla de comparación completa

| Método | `quant_method` | Flujo de trabajo | Bits | Hardware | Guardar | Ajuste fino | Compilación automática |
|---|---|---|---|---|---|---|---|
| [AQLM](./aqlm) | `aqlm` | Solo pre-cuantizado | 1–2 | CUDA, CPU | ✅ | ✅ con `aqlm>=1.0.2` | ❌ |
| [AutoRound](./auto_round) | `auto-round` | Solo pre-cuantizado | 2–8 | CUDA, XPU, CPU | ✅ | ❌ | ❌ |
| [AWQ](./awq) | `awq` | Solo pre-cuantizado | 4 | CUDA, ROCm, XPU, CPU | ✅ excepto los backends de ExLlama | ✅ con `gptqmodel>=5.0.0` | ❌ |
| [BitNet](./bitnet) | `bitnet` | Solo pre-cuantizado | 1.58 | CUDA | ✅ | Solo `autobitlinear` en modo `online` | ❌ |
| [bitsandbytes](./bitsandbytes) | `bitsandbytes` | Durante la carga | 4, 8 | CUDA, XPU, HPU, CPU | ✅ | ✅ | ❌ |
| [compressed-tensors](./compressed_tensors) | `compressed-tensors` | Solo pre-cuantizado | Establecido por punto de control | CUDA, XPU, MPS, CPU | ✅ | ✅ excepto con núcleos FP8 | ✅ |
| [EETQ](./eetq) | `eetq` | Durante la carga | 8 | CUDA | ✅ | ✅ | ❌ |
| [FBGEMM FP8](./fbgemm_fp8) | `fbgemm_fp8` | Durante la carga | 8 | CUDA (capacidad de cómputo 9.0+), XPU | ✅ | ❌ | ❌ |
| [FP8 de gran granularidad](./finegrained_fp8) | `fp8`, `mxfp8` | Durante la carga | 8 | CUDA (capacidad de cómputo 8.9+), XPU | ✅ | ❌ | ✅ |
| [Four Over Six](./fouroversix) | `fouroversix` | Durante la carga | 4 | CUDA (el más rápido en Blackwell), CPU | ✅ | Solo con `keep_master_weights=True` | ❌ |
| [FP-Quant](./fp_quant) | `fp_quant` | Durante la carga | 4 | CUDA, XPU | ✅ | Solo con `store_master_weights=True` | ❌ |
| [GGUF](./gguf) | `gguf` | Solo pre-cuantizado | 1–8 | CUDA, MPS, XPU, CPU | ❌ | ❌ | ✅ |
| [GPTQ](./gptq) | `gptq` | Durante la carga, con calibración | 2, 3, 4, 8 | CUDA, ROCm, XPU, CPU | ✅ | ✅ | ❌ |
| [HIGGS](./higgs) | `higgs` | Durante la carga | 2, 3, 4 | CUDA | ✅ | ❌ | ❌ |
| [HQQ](./hqq) | `hqq` | Durante la carga | 1, 2, 3, 4, 8 | CUDA, XPU | ✅ | ✅ | ❌ |
| [Metal](./metal) | `metal` | Durante la carga | 2, 4, 8 | MPS | ✅ | ❌ | ❌ |
| [MXFP4](./mxfp4) | `mxfp4` | Durante la carga | 4 | CUDA (capacidad de cómputo 7.5+), XPU, CPU | ✅ | ❌ | ❌ |
| [NVFP4](./nvfp4) | `nvfp4` | Durante la carga | 4 | Una GPU Blackwell | ❌ | ❌ | ✅ |
| [Quanto](./quanto) | `quanto` | Durante la carga | 2, 4, 8 | CUDA, MPS, XPU, CPU | ❌ | ✅ | ❌ |
| [Quark](./quark) | `quark` | Solo pre-cuantizado | Establecido por punto de control | CUDA, ROCm, CPU | ❌ | ❌ | ❌ |
| [SINQ](./sinq) | `sinq` | Durante la carga | 2, 3, 4, 6, 8 | Una GPU CUDA, CPU | ✅ | ✅ | ❌ |
| [SpQR](./spqr) | `spqr` | Solo pre-cuantizado | 3 | CUDA | ✅ | ❌ | ❌ |
| [torchao](./torchao) | `torchao` | Durante la carga | 4, 8 | CUDA, XPU, CPU | ✅ | Solo esquemas de 8 bits | ✅ |
| [VPTQ](./vptq) | `vptq` | Solo pre-cuantizado | 1–8 | CUDA | ✅ | ❌ | ❌ |

## Comprueba la memoria con el selector de cuantización

El [selector de cuantización](https://huggingface.co/spaces/stevhliu/quantization-picker) estima si un modelo cabe en tu hardware en cada precisión, incluido el KV cache. Selecciona un modelo, tu hardware y lo que necesitas que haga el método, y la vista **Compare** enumerará los métodos que coinciden.

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

## Benchmarks

Los benchmarks a continuación comparan varios métodos en Llama 3.1 8B y 70B. Informan sobre la precisión, el throughput en tokens por segundo, la memoria pico en GB y el tiempo de cuantización.

Llama 3.1 70B en bf16 se ejecutó en 2 GPUs NVIDIA A100 80GB. Los métodos FP8 se ejecutaron en 1 GPU NVIDIA H100 80GB, y todos los demás métodos se ejecutaron en 1 GPU NVIDIA A100 80GB. El throughput se midió con un batch size de 1, generando 64 tokens. Los resultados incluyen `torch.compile` y kernels de Marlin cuando un método los soporta.

<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"
>

Los resultados se agrupan en tres rangos de bits.

| Bits | Métodos evaluados | Memoria frente a bf16 | Precisión |
|---|---|---|---|
| 8 | bitsandbytes int8, HQQ, Quanto, torchao, FP8 | Aproximadamente 2 veces más pequeño | Muy cercano a bf16 |
| 4 | AWQ, GPTQ, HQQ, bitsandbytes NF4, SINQ | Aproximadamente 4 veces más pequeño | Alto. AWQ y GPTQ suelen estar a la cabeza, pero requieren calibración. |
| Menos de 4 | VPTQ, AQLM, 2-bit GPTQ | Más de 4 veces más pequeño | Caída notable, especialmente a 2 bits. AQLM y VPTQ tardan mucho tiempo en cuantizar. |

> [!TIP]
> Mide la precisión y la velocidad en tu propia tarea y hardware antes de elegir un método para producción.