auto round
Intel®
AutoRound est un algorithme de quantification avancé pour l'inférence LLM à bits faibles. Il est adapté à une large gamme de modèles. AutoRound adopte la descente de gradient de signe pour affiner les valeurs d'arrondi et les valeurs minmax des poids en seulement 200 étapes, ce qui rivalise de manière impressionnante avec les méthodes récentes sans introduire de surcharge d'inférence supplémentaire et en maintenant un faible coût de réglage. L'image ci-dessous présente un aperçu d'AutoRound. Consultez notre article sur arxiv pour plus de détails et visitez low_bit_open_llm_leaderboard pour plus de données et de recettes précises sur différents modèles.
[2024/10] AutoRound a été intégré à torch/ao, consultez leur note de version
[2024/10] Mise à jour importante : nous prenons désormais en charge la quantification symétrique complète et en avons fait la configuration par défaut. Cette configuration est généralement meilleure ou comparable à la quantification asymétrique et surpasse considérablement les autres variantes symétriques, en particulier pour les faibles largeurs de bits comme 2 bits.
[2024/09] Le format AutoRound prend en charge plusieurs modèles LVM, consultez les exemples Qwen2-Vl,Phi-3-vision, Llava
[2024/08] Le format AutoRound prend en charge les appareils Intel Gaudi2. Veuillez vous référer à Intel/Qwen2-7B-int4-inc.
[2024/08] AutoRound introduit plusieurs fonctionnalités expérimentales, notamment le réglage rapide des paramètres de norme/biais (pour 2 bits et W4A4), la quantification d'activation et le type de données mx_fp.
pip install -vvv --no-build-isolation -e .
pip installer l'arrondi automatique
Un guide de l'utilisateur détaillant la liste complète des arguments pris en charge est fourni en appelant auto-round -h sur le terminal. Vous pouvez également utiliser auto_round au lieu de auto-round . Définissez le format souhaité et l'exportation de plusieurs formats a été prise en charge.
CUDA_VISIBLE_DEVICES=0 arrondi automatique
--modèle facebook/opt-125m
--bits 4
--group_size 128
--format "auto_round,auto_gptq"
--disable_eval
--output_dir ./tmp_autoroundNous proposons deux recettes pour une meilleure précision et une vitesse d'exécution rapide avec une mémoire faible. Détails comme ci-dessous.
## meilleure précision, 3X plus lent, low_gpu_mem_usage pourrait économiser ~20G mais ~30% plus lentCUDA_VISIBLE_DEVICES=0 auto-round --modèle facebook/opt-125m --bits 4 --group_size 128 --nsamples 512 --iters 1000 --low_gpu_mem_usage --disable_eval
## Mémoire rapide et faible, accélération 2-3X, légère baisse de précision à W4G128CUDA_VISIBLE_DEVICES=0 arrondi automatique --modèle facebook/opt-125m --bits 4 --group_size 128 --échantillons 128 --iters 200 --suite 512 --batch_size 4 --disable_eval
Format AutoRound : Ce format est bien adapté aux processeurs, aux appareils HPU, aux 2 bits, ainsi qu'à l'inférence à précision mixte. [2,4] bits sont pris en charge. Il bénéficie également du noyau Marlin, qui peut améliorer considérablement les performances d'inférence. Cependant, il n’a pas encore été largement adopté par la communauté.
Format AutoGPTQ : Ce format est bien adapté à la quantification symétrique sur les appareils CUDA et est largement adopté par la communauté, [2,3,4,8] bits sont pris en charge. Il bénéficie également du noyau Marlin, qui peut améliorer considérablement les performances d'inférence. Cependant, le noyau asymétrique présente des problèmes qui peuvent entraîner des baisses de précision considérables, en particulier pour la quantification sur 2 bits et les petits modèles. De plus, la quantification symétrique a tendance à donner de mauvais résultats avec une précision de 2 bits.
Format AutoAWQ : Ce format est bien adapté à la quantification asymétrique 4 bits sur les appareils CUDA et est largement adopté au sein de la communauté, seule la quantification 4 bits est prise en charge. Il propose une fusion de couches spécialisée adaptée aux modèles Lama.
à partir des transformateurs importer AutoModelForCausalLM, AutoTokenizermodel_name = "facebook/opt-125m"model = AutoModelForCausalLM.from_pretrained(model_name)tokenizer = AutoTokenizer.from_pretrained(model_name)from auto_round importer AutoRoundbits, group_size, sym = 4, 128, Trueautoround = AutoRound (modèle, tokenizer , bits=bits, group_size=group_size, sym=sym)## la meilleure précision, 3X plus lent, low_gpu_mem_usage pourrait économiser ~20G mais ~30% plus lent# autoround = AutoRound(model, tokenizer, nsamples=512, iters=1000, low_gpu_mem_usage=True, bits= bits, group_size=group_size, sym=sym)## mémoire rapide et faible, Accélération 2-3X, légère baisse de précision à W4G128# autoround = AutoRound(model, tokenizer, nsamples=128, iters=200, seqlen=512, batch_size=4, bits=bits, group_size=group_size, sym=sym )autoround.quantize ()output_dir = "./tmp_autoround"## format= 'auto_round' (par défaut dans version>0.3.0), 'auto_gptq', 'auto_awq'autoround.save_quantized(output_dir, format='auto_round', inplace=True)
Les tests ont été effectués sur le Nvidia A100 80G en utilisant la version nocturne de PyTorch 2.6.0.dev20241029+cu124. Veuillez noter que les frais de chargement et d'emballage des données ont été exclus de l'évaluation. Nous activons torch.compile pour Torch 2.6, mais pas pour 2.5 en raison de problèmes rencontrés.
Pour optimiser l'utilisation de la mémoire GPU, en plus d'activer low_gpu_mem_usage , vous pouvez définir gradient_accumulate_steps=8 et batch_size=1 , bien que cela puisse augmenter le temps de réglage.
Les modèles 3B et 14B ont été évalués sur Qwen 2.5, le modèle 8X7B est Mixtral, tandis que les modèles restants ont utilisé LLaMA 3.1.
| Version torche/Config W4G128 | 3B | 8B | 14B | 70B | 8X7B |
|---|---|---|---|---|---|
| 2.6 avec compilation de la torche | 7min 10 Go | 12min 18 Go | 23min 22 Go | 120 minutes 42 Go | 28min 46 Go |
| 2.6 avec compilation de la torche low_gpu_mem_usage=Vrai | 12min 6 Go | 19 minutes 10 Go | 33 minutes 11 Go | 140 minutes 25 Go | 38min 36 Go |
| 2.6 avec compilation de la torche low_gpu_mem_usage=Vrai gradient_accumulate_steps=8,bs=1 | 15 minutes 3 Go | 25min 6 Go | 45 minutes 7 Go | 187min 19 Go | 75 minutes 36 Go |
| 2.5 sans compilation de la torche | 8min 10 Go | 16 minutes 20 Go | 30 minutes 25 Go | 140min 49 Go | 50 minutes 49 Go |
Veuillez d'abord exécuter le code de quantification
CPU : version auto_round >0.3.1 , pip install intel-extension-for-pytorch (vitesse beaucoup plus élevée sur le processeur Intel) ou pip install intel-extension-for-transformers,
HPU : une image docker avec Gaudi Software Stack est recommandée. Plus de détails peuvent être trouvés dans le Guide Gaudi.
CUDA : pas d'opérations supplémentaires pour la quantification sym, pour la quantification asymétrique, besoin d'installer l'arrondi automatique à partir de la source
à partir des transformateurs import AutoModelForCausalLM, AutoTokenizerfrom auto_round import AutoRoundConfigbackend = "auto" ##cpu, hpu, cuda, cuda:marlin (pris en charge dans auto_round>0.3.1 et '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 = "Il y a une fille qui aime l'aventure,"inputs = tokenizer(text, return_tensors="pt").to(model.device)print(tokenizer.decode(model.generate(**inputs, max_new_tokens=50)[0])) arrondi automatique --model save_quantized_model
--évaluation
--tâche lambada_openai
--eval_bs 1from transformers 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 = "Il y a une fille qui aime l'aventure,"inputs = tokenizer( texte, return_tensors="pt").to(model.device)print(tokenizer.decode(model.generate(**inputs, max_new_tokens=50)[0]))
AutoRound prend en charge pratiquement tous les principaux modèles de langage.
Veuillez noter qu'un astérisque (*) indique des modèles quantifiés tiers, qui peuvent manquer de données de précision et utiliser une recette différente. Nous apprécions grandement leurs efforts et encourageons davantage d'utilisateurs à partager leurs modèles, car nous ne pouvons pas publier la plupart des modèles nous-mêmes.
| Modèle | Soutenu |
|---|---|
| méta-llama/Meta-Llama-3.1-70B-Instruct | recette |
| méta-llama/Meta-Llama-3.1-8B-Instruct | modèle-kaitchup-autogptq-int4*, modèle-kaitchup-autogptq-sym-int4*, recette |
| méta-lama/méta-lama-3.1-8B | modèle-kaitchup-autogptq-sym-int4* |
| Qwen/Qwen-VL | précision, recette |
| Qwen/Qwen2-7B | modèle-autoround-sym-int4, modèle-autogptq-sym-int4 |
| Qwen/Qwen2-57B-A14B-Instruire | modèle-autoround-sym-int4, modèle-autogptq-sym-int4 |
| 01-ai/Yi-1.5-9B | modèle-LnL-AI-autogptq-int4* |
| 01-ai/Yi-1.5-9B-Chat | modèle-LnL-AI-autogptq-int4* |
| Intel/neural-chat-7b-v3-3 | modèle-autogptq-int4 |
| Intel/neural-chat-7b-v3-1 | modèle-autogptq-int4 |
| TinyLlama-1.1B-intermédiaire | modèle-LnL-AI-autogptq-int4* |
| mistralai/Mistral-7B-v0.1 | modèle-autogptq-lmhead-int4, modèle-autogptq-int4 |
| google/gemma-2b | modèle-autogptq-int4 |
| tiiuae/falcon-7b | modèle-autogptq-int4-G64 |
| sapienzanlp/modello-italia-9b | modèle-fbaldassarri-autogptq-int4* |
| Microsoft/phi-2 | modèle-autoround-sym-int4 modèle-autogptq-sym-int4 |
| Microsoft/Phi-3.5-mini-instruct | modèle-kaitchup-autogptq-sym-int4* |
| Microsoft/Phi-3-vision-128k-instruct | recette |
| mistralai/Mistral-7B-Instruct-v0.2 | précision, recette, exemple |
| mistralai/Mixtral-8x7B-Instruct-v0.1 | précision, recette, exemple |
| mistralai/Mixtral-8x7B-v0.1 | précision, recette, exemple |
| méta-llama/Meta-Llama-3-8B-Instruct | précision, recette, exemple |
| google/gemma-7b | précision, recette, exemple |
| méta-lama/Llama-2-7b-chat-hf | précision, recette, exemple |
| Qwen/Qwen1.5-7B-Chat | précision, recette sym, recette asymétrique, exemple |
| baichuan-inc/Baichuan2-7B-Chat | précision, recette, exemple |
| 01-ai/Yi-6B-Chat | précision, recette, exemple |
| facebook/opt-2.7b | précision, recette, exemple |
| bigscience/bloom-3b | précision, recette, exemple |
| EleutherAI/gpt-j-6b | précision, recette, exemple |
AutoRound a été intégré dans plusieurs référentiels.
Compresseur neuronal Intel
ModèleCloud/GPTQModèle
pytorch/ao
Si vous trouvez AutoRound utile pour votre recherche, veuillez citer notre article :
@article{cheng2023optimize,
title={Optimiser l'arrondi des poids via une descente de gradient signée pour la quantification des LLM},
author={Cheng, Wenhua et Zhang, Weiwei et Shen, Haihao et Cai, Yiyang et He, Xin et Lv, Kaokao et Liu, Yi},
journal={préimpression arXiv arXiv:2309.05516},
année={2023}
} 
