ronda automática
Intel®
AutoRound es un algoritmo de cuantificación avanzado para la inferencia LLM de bits bajos. Está diseñado para una amplia gama de modelos. AutoRound adopta el descenso de gradiente de signos para ajustar los valores de redondeo y los valores minmax de pesos en solo 200 pasos, lo que compite de manera impresionante con los métodos recientes sin introducir ninguna sobrecarga de inferencia adicional y manteniendo un bajo costo de ajuste. La siguiente imagen presenta una descripción general de AutoRound. Consulte nuestro artículo sobre arxiv para obtener más detalles y visite low_bit_open_llm_leaderboard para obtener datos y recetas más precisos en varios modelos.
[2024/10] AutoRound se ha integrado en torch/ao, consulte su nota de versión
[2024/10] Actualización importante: ahora admitimos la cuantificación simétrica de rango completo y la hemos convertido en la configuración predeterminada. Esta configuración suele ser mejor o comparable a la cuantificación asimétrica y supera significativamente a otras variantes simétricas, especialmente en anchos de bits bajos como 2 bits.
[2024/09] El formato AutoRound admite varios modelos LVM, consulte los ejemplos Qwen2-Vl,Phi-3-vision, Llava
[2024/08] El formato AutoRound admite dispositivos Intel Gaudi2. Consulte Intel/Qwen2-7B-int4-inc.
[2024/08] AutoRound presenta varias características experimentales, incluido el ajuste rápido de los parámetros de norma/sesgo (para 2 bits y W4A4), cuantificación de activación y el tipo de datos mx_fp.
pip install -vvv --no-build-isolation -e .
instalación de pipa con ronda automática
Se proporciona una guía del usuario que detalla la lista completa de argumentos admitidos llamando auto-round -h en el terminal. Alternativamente, puedes usar auto_round en lugar de auto-round . Configure el formato que desee en format y se admite la exportación de múltiples formatos.
CUDA_VISIBLE_DEVICES=0 auto-redondeo
--modelo facebook/opt-125m
--bits 4
--tamaño_grupo 128
--formato "auto_round,auto_gptq"
--disable_eval
--output_dir ./tmp_autoroundProporcionamos dos recetas para obtener la mejor precisión y una velocidad de ejecución rápida con poca memoria. Detalles como a continuación.
## mejor precisión, 3 veces más lento, low_gpu_mem_usage podría ahorrar ~20G pero ~30% más lentoCUDA_VISIBLE_DEVICES=0 auto-redondeo --modelo facebook/opt-125m --bits 4 --tamaño_grupo 128 --nmuestras 512 --itros 1000 --low_gpu_mem_usage --disable_eval
## memoria rápida y baja, aceleración de 2 a 3 veces, ligera caída de precisión en W4G128CUDA_VISIBLE_DEVICES=0 auto-redondeo --modelo facebook/opt-125m --bits 4 --tamaño_grupo 128 --nmuestras 128 --itros 200 --seqlen 512 --tamaño_lote 4 --disable_eval
Formato AutoRound : este formato es adecuado para CPU, dispositivos HPU, 2 bits, así como para inferencia de precisión mixta. Se admiten [2,4] bits. También se beneficia del núcleo Marlin, que puede mejorar notablemente el rendimiento de la inferencia. Sin embargo, aún no ha logrado una adopción comunitaria generalizada.
Formato AutoGPTQ : este formato es muy adecuado para la cuantificación simétrica en dispositivos CUDA y es ampliamente adoptado por la comunidad; se admiten [2,3,4,8] bits. También se beneficia del núcleo Marlin, que puede mejorar notablemente el rendimiento de la inferencia. Sin embargo, el núcleo asimétrico tiene problemas que pueden causar caídas considerables en la precisión, particularmente en cuantificaciones de 2 bits y modelos pequeños. Además, la cuantificación simétrica tiende a funcionar mal con una precisión de 2 bits.
Formato AutoAWQ : este formato es muy adecuado para la cuantificación asimétrica de 4 bits en dispositivos CUDA y es ampliamente adoptado dentro de la comunidad; solo se admite la cuantificación de 4 bits. Cuenta con fusión de capas especializada adaptada a los modelos Llama.
de transformadores importe AutoModelForCausalLM, AutoTokenizermodel_name = "facebook/opt-125m"model = AutoModelForCausalLM.from_pretrained(model_name)tokenizer = AutoTokenizer.from_pretrained(model_name)from auto_round import AutoRoundbits, group_size, sym = 4, 128, Trueautoround = AutoRound(modelo, tokenizer) , bits=bits, group_size=group_size, sym=sym)## la mejor precisión, 3 veces más lento, low_gpu_mem_usage podría ahorrar ~20G pero ~30% más lento# autoround = AutoRound(model, tokenizer, nsamples=512, iters=1000, low_gpu_mem_usage =Verdadero, bits=bits, tamaño_grupo=tamaño_grupo, sym=sym)## memoria rápida y baja, aceleración 2-3X, ligera caída de precisión en W4G128# autoround = AutoRound(model, tokenizer, nsamples=128, iters=200, seqlen =512, tamaño_lote=4, bits=bits, tamaño_grupo=tamaño_grupo, sym=sym )autoround.quantize()output_dir = "./tmp_autoround"## format= 'auto_round'(predeterminado en la versión>0.3.0), 'auto_gptq ', 'auto_awq'autoround.save_quantized(dir_salida, formato='auto_round', inplace=True)
Las pruebas se realizaron en la Nvidia A100 80G utilizando la versión nocturna de PyTorch 2.6.0.dev20241029+cu124. Tenga en cuenta que los costos de carga y embalaje de datos se han excluido de la evaluación. Habilitamos torch.compile para Torch 2.6, pero no para 2.5 debido a problemas encontrados.
Para optimizar el uso de la memoria de la GPU, además de activar low_gpu_mem_usage , puede configurar gradient_accumulate_steps=8 y un batch_size=1 , aunque esto puede aumentar el tiempo de ajuste.
Los modelos 3B y 14B fueron evaluados en Qwen 2.5, el modelo 8X7B es Mixtral, mientras que los modelos restantes utilizaron LLaMA 3.1.
| Versión de antorcha/Configuración W4G128 | 3B | 8B | 14B | 70B | 8X7B |
|---|---|---|---|---|---|
| 2.6 con compilación de antorcha | 7 minutos 10GB | 12min 18GB | 23min 22GB | 120min 42GB | 28min 46GB |
| 2.6 con compilación de antorcha low_gpu_mem_usage=Verdadero | 12min 6GB | 19min 10GB | 33min 11GB | 140min 25GB | 38min 36GB |
| 2.6 con compilación de antorcha low_gpu_mem_usage=Verdadero gradient_accumulate_steps=8,bs=1 | 15 minutos 3GB | 25 minutos 6GB | 45 minutos 7GB | 187 minutos 19GB | 75 minutos 36GB |
| 2.5 sin compilación de antorcha | 8 minutos 10GB | 16 minutos 20GB | 30 minutos 25GB | 140min 49GB | 50 minutos 49GB |
Ejecute primero el código de cuantificación.
CPU : versión auto_round >0.3.1 , pip install intel-extension-for-pytorch (velocidad mucho mayor en CPU Intel) o pip install intel-extension-for-transformers,
HPU : se recomienda la imagen de la ventana acoplable con Gaudi Software Stack. Se pueden encontrar más detalles en la Guía Gaudí.
CUDA : no hay operaciones adicionales para la cuantificación de sincronización; para la cuantificación asimétrica, es necesario instalar el redondeo automático desde la fuente
de transformadores import AutoModelForCausalLM, AutoTokenizerfrom auto_round import AutoRoundConfigbackend = "auto" ##cpu, hpu, cuda, cuda:marlin(compatible con auto_round>0.3.1 y 'pip install -v gptqmodel --no-build-isolation')quantization_config = AutoRoundConfig(backend=backend)quantized_model_path = "./tmp_autoround"model = AutoModelForCausalLM.from_pretrained(quantized_model_path, device_map=backend.split(':')[0], quantization_config=quantization_config)tokenizer = AutoTokenizer.from_pretrained(quantized_model_path)text = " Hay una chica a la que le gusta la aventura,"inputs = tokenizer(text, return_tensors="pt").to(model.device)print(tokenizer.decode(model.generate(**inputs, max_new_tokens=50)[0]) ) ronda automática --modelo modelo_cuantificado_salvado
--evaluar
--tarea lambada_openai
--eval_bs 1de transformadores import AutoModelForCausalLM, AutoTokenizerquantized_model_path = "./tmp_autoround"model = AutoModelForCausalLM.from_pretrained(quantized_model_path, device_map="auto")tokenizer = AutoTokenizer.from_pretrained(quantized_model_path)text = "Hay una chica a la que le gusta la aventura,"inputs = tokenizer( texto, return_tensors="pt").to(model.device)print(tokenizer.decode(model.generate(**inputs, max_new_tokens=50)[0]))
AutoRound admite básicamente todos los principales modelos de lenguajes grandes.
Tenga en cuenta que un asterisco (*) indica modelos cuantificados de terceros, que pueden carecer de datos de precisión y utilizar una receta diferente. Apreciamos enormemente sus esfuerzos y animamos a más usuarios a compartir sus modelos, ya que no podemos publicar la mayoría de los modelos nosotros mismos.
| Modelo | Apoyado |
|---|---|
| meta-llama/Meta-Llama-3.1-70B-Instruct | receta |
| meta-llama/Meta-Llama-3.1-8B-Instruct | modelo-kaitchup-autogptq-int4*, modelo-kaitchup-autogptq-sym-int4*, receta |
| meta-llama/Meta-Llama-3.1-8B | modelo-kaitchup-autogptq-sym-int4* |
| Qwen/Qwen-VL | precisión, receta |
| Qwen/Qwen2-7B | modelo-autoround-sym-int4, modelo-autogptq-sym-int4 |
| Qwen/Qwen2-57B-A14B-Instrucción | modelo-autoround-sym-int4, modelo-autogptq-sym-int4 |
| 01-ai/Yi-1.5-9B | modelo-LnL-AI-autogptq-int4* |
| 01-ai/Yi-1.5-9B-Chat | modelo-LnL-AI-autogptq-int4* |
| Intel/neural-chat-7b-v3-3 | modelo-autogptq-int4 |
| Intel/neural-chat-7b-v3-1 | modelo-autogptq-int4 |
| TinyLlama-1.1B-intermedio | modelo-LnL-AI-autogptq-int4* |
| mistralai/Mistral-7B-v0.1 | modelo-autogptq-lmhead-int4, modelo-autogptq-int4 |
| google/gemma-2b | modelo-autogptq-int4 |
| tiiuae/falcon-7b | modelo-autogptq-int4-G64 |
| sapienzanlp/modello-italia-9b | modelo-fbaldassarri-autogptq-int4* |
| microsoft/phi-2 | modelo-autoround-sym-int4 modelo-autogptq-sym-int4 |
| microsoft/Phi-3.5-mini-instrucciones | modelo-kaitchup-autogptq-sym-int4* |
| microsoft/Phi-3-vision-128k-instrucciones | receta |
| mistralai/Mistral-7B-Instruct-v0.2 | precisión, receta, ejemplo |
| mistralai/Mixtral-8x7B-Instruct-v0.1 | precisión, receta, ejemplo |
| mistralai/Mixtral-8x7B-v0.1 | precisión, receta, ejemplo |
| meta-llama/Meta-Llama-3-8B-Instruct | precisión, receta, ejemplo |
| google/gemma-7b | precisión, receta, ejemplo |
| meta-llama/Llama-2-7b-chat-hf | precisión, receta, ejemplo |
| Qwen/Qwen1.5-7B-Chat | precisión, receta simbólica, receta asim, ejemplo |
| baichuan-inc/Baichuan2-7B-Chat | precisión, receta, ejemplo |
| 01-ai/Yi-6B-Chat | precisión, receta, ejemplo |
| facebook/opt-2.7b | precisión, receta, ejemplo |
| ciencia grande/bloom-3b | precisión, receta, ejemplo |
| EleutherAI/gpt-j-6b | precisión, receta, ejemplo |
AutoRound se ha integrado en múltiples repositorios.
Compresor neuronal Intel
ModeloCloud/GPTQModelo
pytorch/ao
Si considera que AutoRound es útil para su investigación, cite nuestro artículo:
@artículo{cheng2023optimizar,
title={Optimizar el redondeo de peso mediante el descenso de gradiente firmado para la cuantificación de LLM},
autor = {Cheng, Wenhua y Zhang, Weiwei y Shen, Haihao y Cai, Yiyang y He, Xin y Lv, Kaokao y Liu, Yi},
diario={arXiv preimpresión arXiv:2309.05516},
año={2023}
} 
