# AutoRound

[AutoRound](https://github.com/intel/auto-round) es un algoritmo de cuantización avanzado que ofrece una precisión sólida, incluso con una precisión de 2 bits. Aprovecha el descenso de gradiente con signo para ajustar finamente tanto los valores de redondeo como los umbrales de recorte min-max en solo 200 pasos. Diseñado para una amplia compatibilidad, admite de forma transparente una gran variedad de LLM y se está expandiendo activamente para cubrir también más VLM. Además, soporta la cuantización y la inferencia en múltiples plataformas de hardware, incluyendo CPU, XPU y CUDA.

AutoRound también ofrece una variedad de funciones útiles, como el ajuste y la inferencia automáticos con bits mixtos, soporte para los tipos de datos MXFP4 y NVFP4, cuantización sin modelo, exportación a formatos como GPTQ, AWQ, GGUF y LLM-Compressor, y recetas de ajuste flexibles. Para obtener una visión general completa y las últimas actualizaciones, consulta el [README](https://github.com/intel/auto-round) de AutoRound.

AutoRound se desarrolló originalmente como parte de [Intel Neural Compressor](https://github.com/intel/neural-compressor), sirviendo como una biblioteca general de compresión de modelos para el aprendizaje profundo. Desde entonces, ha evolucionado hasta convertirse en una biblioteca independiente centrada específicamente en la optimización de baja precisión para modelos de lenguaje grandes (LLM). AutoRound sigue estando totalmente integrado con Intel Neural Compressor, y puedes explorar el repositorio para obtener más detalles.

## Instalación

```bash
pip install auto-round
```

## Configuraciones de cuantización admitidas

AutoRound admite las siguientes configuraciones de cuantización:

1. **Pesos solo INT2–INT8**
2. **Pesos solo de bits mixtos**
3. **GGUF Q\*_K**
4. **MXFP** (soporte limitado)
5. **NVFP4** (soporte limitado)

## Compatibilidad con el hardware

CPU, XPU y CUDA para la cuantización y la inferencia.

## Cuantización y serialización (fuera de línea)

Actualmente, solo se admite el modo sin conexión para generar modelos cuantizados.

### Uso desde la línea de comandos

```bash
auto-round \
    --model Qwen/Qwen3-0.6B \
    --scheme "W4A16" \
    --group_size 128 \
    --output_dir ./tmp_autoround
```

AutoRound también ofrece otras cuatro recetas, `auto-round-best`, `auto-round-light`,`auto-round-opt-rtn`,`auto-round-rtn`, diseñadas para una precisión óptima y una velocidad mejorada, respectivamente. Para 2 bits, recomendamos usar `auto-round-best` con `--enable_alg_ext`.

### Uso de AutoScheme

AutoScheme es una función que selecciona automáticamente el mejor esquema de cuantización entre las opciones disponibles para cada capa que se va a cuantizar, en cuestión de minutos, sujeto a un ancho de bits promedio objetivo.

```bash
auto-round \
    --model Qwen/Qwen3-0.6B \
    --options "W4A16,W2A16G64" \
    --target_bits 3.5 \
    --output_dir ./tmp_autoround
```

### Combinaciones de algoritmos

AutoRound permite combinar varios algoritmos, como AutoRound, AutoRound + AWQ y AutoRound + AWQ + Hadamard (con un soporte muy limitado). Actualmente estamos ampliando el soporte para más algoritmos. Esto permite optimizar aún más los resultados de la cuantización, especialmente en escenarios que implican activaciones cuantizadas.

```bash
auto-round \
    --model Qwen/Qwen3-0.6B \
    --algs "autoround,awq" \
    --output_dir ./tmp_autoround
```

### Uso de la API de AutoRound

Esta configuración ofrece un mejor equilibrio entre precisión y coste de ajuste, y se recomienda en todos los escenarios.

```python
from auto_round import AutoRound

model_name = "Qwen/Qwen3-0.6B"
# mixed bits config
# layer_config = {"model.decoder.layers.6.self_attn.out_proj": {"bits": 2, "group_size": 32}}
ar = AutoRound(
    model_name,
    scheme="W4A16",
    # enable_torch_compile=True,
    # layer_config=layer_config,
)

output_dir = "./tmp_autoround"
# format= 'auto_round'(default), 'llm_compressor', "gguf:q4_k_m", 'auto_gptq', 'auto_awq'
ar.quantize_and_save(output_dir, format='auto_round') 
```

### AutoRoundMejor receta

Esta configuración ofrece la mejor precisión en la mayoría de los escenarios, pero es de 4 a 5 veces más lenta que la receta estándar de AutoRound. Se recomienda especialmente para la cuantización de 2 bits y es una buena opción si se dispone de recursos suficientes.

```python
from auto_round import AutoRound

model_name = "Qwen/Qwen3-0.6B"
ar = AutoRound(
    model_name,
    scheme="W4A16",
    nsamples=512,
    iters=1000,
)

output_dir = "./tmp_autoround"
ar.quantize_and_save(output_dir, format='auto_round') 
```

### Receta AutoRoundLight

Esta configuración ofrece la mejor velocidad (2 a 3 veces más rápida que AutoRound), pero puede provocar una pérdida significativa de precisión en modelos pequeños y cuantización de 2 bits. Se recomienda para configuraciones de 4 bits y modelos de más de 3B.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer
from auto_round import AutoRound

model_name = "Qwen/Qwen3-0.6B"
ar = AutoRound(
    model_name,
    iters=50,
    lr=5e-3,
)

output_dir = "./tmp_autoround"
ar.quantize_and_save(output_dir, format='auto_round') 
```

W4G128 Precisión media de 13 tareas (mmlu-pro, if_eval, gsm8k, etc.) y resultados de coste de tiempo (las pruebas se realizaron en una Nvidia A100 80G utilizando la versión 2.6.0 de PyTorch con enable_torch_compile):

| Modelo   | Qwen2.5-0.5B-Instruct | Falcon3-3B    | Qwen2.5-7B-Instruct | Meta-Llama-3.1-8B-Instruct | Falcon3-10B   | Qwen2.5-72B-Instruct |
|---------|--------------------|---------------|------------------|----------------------------|---------------|-------------------|
| 16bits  | 0.4192             | 0.5203        | 0.6470           | 0.6212                     | 0.6151        | 0.7229            |
| Mejor    | **0.4137**(7m)     | **0.5142**(23m) | 0.6426(58m)      | **0.6116**(65m)            | **0.6092**(81m) | 0.7242(575m)      |
| Predeterminado | 0.4129(2m)         | 0.5133(6m)    | 0.6441(13m)      | 0.6106(13m)                | 0.6080(18m)   | **0.7252**(118m)  |
| Ligero   | 0.4052(2m)         | 0.5108(3m)    | **0.6453**(5m)   | 0.6104(6m)                 | 0.6063(6m)    | 0.7243(37m)       |

## Inferencia

AutoRound selecciona automáticamente el mejor backend disponible en función de las bibliotecas instaladas y solicita al usuario que instale bibliotecas adicionales cuando se encuentra un backend mejor.

### CPU

Admite 2, 4 y 8 bits. Recomendamos usar el backend AutoRound Kernel (ARK) para la inferencia. Se requiere PyTorch 2.8.0 o posterior con ARK.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "OPEA/Qwen2.5-1.5B-Instruct-int4-sym-inc"
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="cpu", dtype="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)
text = "There is a girl who likes adventure,"
inputs = tokenizer(text, return_tensors="pt").to(model.device)
print(tokenizer.decode(model.generate(**inputs, max_new_tokens=50, do_sample=False)[0]))
```

### XPU

Admite 2, 4 y 8 bits. Recomendamos usar el backend AutoRound Kernel (ARK) para la inferencia. Se requiere PyTorch 2.8.0 o posterior con ARK.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "OPEA/Qwen2.5-1.5B-Instruct-int4-sym-inc"
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="xpu", dtype="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)
text = "There is a girl who likes adventure,"
inputs = tokenizer(text, return_tensors="pt").to(model.device)
print(tokenizer.decode(model.generate(**inputs, max_new_tokens=50, do_sample=False)[0]))
```

### CUDA

Admite de 2 a 8 bits. Recomendamos usar GPTQModel para la inferencia de 4 y 8 bits.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "OPEA/Qwen2.5-1.5B-Instruct-int4-sym-inc"
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="cuda", dtype="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)
text = "There is a girl who likes adventure,"
inputs = tokenizer(text, return_tensors="pt").to(model.device)
print(tokenizer.decode(model.generate(**inputs, max_new_tokens=50, do_sample=False)[0]))
```

### Especificar el backend de inferencia

AutoRound selecciona automáticamente el backend para cada capa en función de la compatibilidad. En general, el orden de prioridad es Marlin > ExLLaMAV2 > Triton, pero la elección final depende de factores como el tamaño del grupo, el ancho de bits, el formato de empaquetado, el dispositivo de hardware y otros detalles de implementación. Para más detalles, consulte [backends](https://github.com/intel/auto-round?tab=readme-ov-file#specify-backend),

Es posible que el backend no sea siempre el más adecuado para ciertos dispositivos. Puede especificar su backend preferido, como "ark" para CPU y XPU, o "marlin/exllamav2/triton" para CUDA, según sus necesidades o la compatibilidad de su hardware. Tenga en cuenta que pueden ser necesarias bibliotecas adicionales correspondientes.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer, AutoRoundConfig

model_name = "OPEA/Qwen2.5-1.5B-Instruct-int4-sym-inc"
quantization_config = AutoRoundConfig(backend="ark")
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="cpu", quantization_config=quantization_config, dtype="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)
text = "There is a girl who likes adventure,"
inputs = tokenizer(text, return_tensors="pt").to(model.device)
print(tokenizer.decode(model.generate(**inputs, max_new_tokens=50, do_sample=False)[0]))
```

### Convertir GPTQ/AWQ a AutoRound

La mayoría de los modelos GPTQ/AWQ se pueden convertir al formato AutoRound para mejorar la compatibilidad y el soporte con dispositivos Intel. Tenga en cuenta que la configuración de cuantización se modificará si el modelo se serializa.

```python
from transformers import AutoModelForCausalLM, AutoTokenizer, AutoRoundConfig

model_name = "ybelkada/opt-125m-gptq-4bit"
quantization_config = AutoRoundConfig()
model = AutoModelForCausalLM.from_pretrained(model_name, device_map="cpu", quantization_config=quantization_config, dtype="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)
text = "There is a girl who likes adventure,"
inputs = tokenizer(text, return_tensors="pt").to(model.device)
print(tokenizer.decode(model.generate(**inputs, max_new_tokens=50, do_sample=False)[0]))
```

## Problemas

Si encuentras algún problema con la integración de transformers, abre un issue en el repositorio de [transformers](https://github.com/huggingface/transformers/issues). Si encuentras algún problema con auto-round, abre un issue en el repositorio de [AutoRound](https://github.com/intel/auto-round/issues).

## Agradecimientos

Agradecimientos especiales a las bibliotecas de baja precisión de código abierto como AutoGPTQ, AutoAWQ, GPTQModel, Triton, Marlin y ExLLaMAV2, por proporcionar kernels de CUDA de baja precisión, que se aprovechan en AutoRound.

## Contribución

¡Las contribuciones a [AutoRound](https://github.com/intel/auto-round/pulls) son bienvenidas y muy apreciadas! Ya sea corrigiendo errores, mejorando la documentación, añadiendo nuevas funciones o sugiriendo mejoras, siempre se valora tu ayuda.