# Resumen

La cuantización almacena los pesos de un modelo, y a veces sus activaciones, en menos bits para que el modelo requiera menos memoria. Los modelos suelen cargarse en bf16, lo que ocupa 2 bytes por parámetro. Un modelo de 8B necesita aproximadamente 16GB para sus pesos en bf16, unos 8GB a 8 bits y unos 4–5GB a 4 bits. Usar menos bits implica cierta pérdida de precisión, y cada método de cuantización realiza un compromiso diferente entre memoria, velocidad y precisión.

Transformers integra más de 20 métodos de cuantización a través de [from_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.from_pretrained), por lo que se utiliza el mismo código de carga sin importar el método que elijas.

## Dos formas de usar un modelo cuantizado

La forma en que se utiliza la cuantización depende de si el punto de control ya está cuantizado.

| Tienes | Lo que haces | Métodos |
|---|---|---|
| Un punto de control de precisión completa | Pase una configuración de cuantización a `from_pretrained` y los pesos se cuantizarán a medida que se cargan. | [Cuantizar un modelo al cargarlo](#quantize-a-model-while-loading) |
| Un punto de control que ya está cuantizado | Llama a `from_pretrained` sin una configuración de cuantización. Transformers lee el método desde el `config.json` del checkpoint o desde el archivo GGUF que especifiques. | [Cargar un punto de control pre-cuantizado](#load-a-pre-quantized-checkpoint) |

Algunos métodos, como AWQ, AutoRound, AQLM, compressed-tensors y GGUF, solo se pueden cargar desde un checkpoint. Primero cuantizas el modelo con la propia biblioteca del método y luego cargas el resultado en Transformers.

## Cuantizar un modelo durante la carga

Crea la clase de configuración del método y pásala a `quantization_config`. El ejemplo siguiente carga un modelo de 8B en 4 bits con [bitsandbytes](./bitsandbytes).

```py
import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
)
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B-Instruct",
    quantization_config=quantization_config,
    device_map="auto",
)
```

Cada método de este grupo tiene su propia clase de configuración, como [TorchAoConfig](/docs/transformers/main/es/main_classes/quantization#transformers.TorchAoConfig) o [BitsAndBytesConfig](/docs/transformers/main/es/main_classes/quantization#transformers.BitsAndBytesConfig). La mayoría no requiere un conjunto de datos de calibración. [GPTQ](./gptq) es la excepción, ya que realiza la calibración sobre un conjunto de datos mientras el modelo se carga.

## Cargar un punto de control pre-cuantizado

Un punto de control pre-cuantizado almacena un `quantization_config` en su `config.json`. Cuando `from_pretrained` lo encuentra, se selecciona automáticamente el cuantizador correspondiente.

```py
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "TheBloke/zephyr-7B-alpha-AWQ",
    device_map="auto",
)
print(model.config.quantization_config.quant_method)
```

Instale la biblioteca en la que depende el método antes de cargar el checkpoint. Cada página de método enumera qué instalar. Para cambiar las opciones de carga, como el backend de kernel que se ejecuta, pase una config del mismo tipo. Sus opciones se fusionan con las almacenadas en el checkpoint.

### Puntos de control GGUF

Un checkpoint GGUF es un único archivo que contiene los pesos, la configuración y el tokenizador, y no tiene un `config.json` para que `from_pretrained` lo lea. Nombra el archivo con `gguf_file`.

```py
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "unsloth/Qwen3.5-4B-GGUF",
    gguf_file="Qwen3.5-4B-Q4_K_M.gguf",
)
```

La mayoría de los modelos GGUF se descuantizan a precisión completa al cargarlos, por lo que utilizan la misma cantidad de memoria que un modelo no cuantizado. Los pesos permanecen empaquetados solo en MPS con el paquete [kernels](https://huggingface.co/docs/kernels/index) instalado, para Qwen3.5 y Qwen3.5 MoE. Consulte [GGUF](./gguf) para obtener más detalles.

## Guardar un modelo cuantizado

Llama a [save_pretrained()](/docs/transformers/main/es/main_classes/model#transformers.PreTrainedModel.save_pretrained) o [push_to_hub()](/docs/transformers/main/es/main_classes/model#transformers.utils.PushToHubMixin.push_to_hub) para guardar los pesos cuantizados y su `quantization_config`. No todos los métodos pueden guardar sus pesos cuantizados.

## Elija un método

[Elegir un método](./selecting) recomienda un punto de partida para objetivos comunes y compara cada método según el hardware, la anchura de bits, el ahorro, el ajuste fino y la compatibilidad con `torch.compile`. Utiliza el [selector de cuantización](https://huggingface.co/spaces/stevhliu/quantization-picker) para comprobar si un modelo cabe en la memoria de tu hardware con cada precisión.

## Otras herramientas

Estas herramientas cuantizan modelos fuera de Transformers.

- [Optimum](https://huggingface.co/docs/optimum/index) cuantiza modelos para hardware y runtimes específicos, como CPUs de Intel y ONNX Runtime.
- Los espacios de Hub permiten cuantizar un modelo y publicar el resultado en tu cuenta: [bitsandbytes](https://huggingface.co/spaces/bnb-community/bnb-my-repo), [GGUF](https://huggingface.co/spaces/ggml-org/gguf-my-repo) y [MLX](https://huggingface.co/spaces/mlx-community/mlx-my-repo).

## Recursos

- Curso [Fundamentos de cuantización con Hugging Face](https://www.deeplearning.ai/short-courses/quantization-fundamentals-with-hugging-face/)
- curso [Quantization in Depth](https://www.deeplearning.ai/short-courses/quantization-in-depth)

## Próximos pasos

- Lee [Conceptos de cuantización](./concept_guide) para saber cómo funcionan los esquemas de cuantización, la granularidad y las técnicas.
- Cuantiza la caché KV para ahorrar memoria durante generaciones largas con la [quantized cache](../kv_cache#quantized-cache).
- Cuantiza un modelo al exportarlo con [Exportaciones cuantizadas](../exporters_quantization).
- Contribuya un nuevo método con [Contribuir un método de cuantización](./contribute).