Transformers documentation
AutoRound
AutoRound
AutoRound 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 de signo para ajustar con precisión 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 amplia gama de LLM y se está expandiendo activamente para cubrir también más VLM. También admite la cuantización y la inferencia en varias plataformas de hardware, incluidas 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, consulte el README de AutoRound.
AutoRound se desarrolló originalmente como parte de 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 de gran escala (LLM). AutoRound sigue estando totalmente integrado con Intel Neural Compressor, y puedes explorar el repositorio para obtener más detalles.
Instalación
pip install auto-round
Configuraciones de cuantización admitidas
AutoRound admite las siguientes configuraciones de cuantización:
- Pesos solo INT2–INT8
- Pesos solo de bits mixtos
- GGUF Q*_K
- MXFP (soporte limitado)
- 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
auto-round \
--model Qwen/Qwen3-0.6B \
--scheme "W4A16" \
--group_size 128 \
--output_dir ./tmp_autoroundAutoRound 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.
auto-round \
--model Qwen/Qwen3-0.6B \
--options "W4A16,W2A16G64" \
--target_bits 3.5 \
--output_dir ./tmp_autoroundCombinaciones 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.
auto-round \
--model Qwen/Qwen3-0.6B \
--algs "autoround,awq" \
--output_dir ./tmp_autoroundUso 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.
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.
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.
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.
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.
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.
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,
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 del hardware. Tenga en cuenta que pueden ser necesarias bibliotecas adicionales correspondientes.
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.
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.
Si encuentras algún problema con auto-round, abre un issue en el repositorio de AutoRound.
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 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.
Update on GitHub