ExLlamaV2 la bibliothèque la plus rapide pour exécuter des LLM

ExLlamaV2 la bibliothèque la plus rapide pour exécuter des LLM

Quantifier et exécuter des modèles EXL2

La quantification des grands modèles de langage (LLM) est l’approche la plus populaire pour réduire la taille de ces modèles et accélérer l’inférence. Parmi ces techniques, GPTQ offre des performances incroyables sur les GPU. Par rapport aux modèles non quantifiés, cette méthode utilise près de 3 fois moins de mémoire VRAM tout en offrant un niveau de précision similaire et une génération plus rapide. Elle est devenue si populaire qu’elle a récemment été intégrée directement dans la bibliothèque transformers.

ExLlamaV2 est une bibliothèque conçue pour tirer encore plus de performance de GPTQ. Grâce aux nouveaux noyaux, elle est optimisée pour une inférence (fulgurante) rapide. Elle introduit également un nouveau format de quantification, EXL2, qui apporte beaucoup de flexibilité dans la façon dont les poids sont stockés.

Dans cet article, nous verrons comment quantifier les modèles de base dans le format EXL2 et comment les exécuter. Comme d’habitude, le code est disponible sur GitHub et Google Colab.

⚡ Quantifier les modèles EXL2

Pour commencer notre exploration, nous devons installer la bibliothèque ExLlamaV2. Dans ce cas, nous voulons pouvoir utiliser quelques scripts contenus dans le référentiel, c’est pourquoi nous l’installerons à partir de la source comme suit :

• Rencontrez GO To Any Thing (GOAT) un système de navigation universel capable de trouver n’importe quel objet spécifié de n’importe quelle manière – comme une image, un langage ou une catégorie – dans des environnements totalement inconnus.
• Données en un coup d’œil création de tableaux de bord dynamiques pour l’analyse des données
• Modèle FastAPI pour LLM SaaS Partie 1 – Authentification et téléchargement de fichiers

git clone https://github.com/turboderp/exllamav2pip install exllamav2

Maintenant qu’ExLlamaV2 est installé, nous devons télécharger le modèle que nous voulons quantifier dans ce format. Utilisons l’excellent zephyr-7B-beta, un modèle Mistral-7B finement accordé en utilisant l’optimisation de préférences directes (DPO). Il prétend surpasser Llama-2 70b chat sur le banc de MT, ce qui est un résultat impressionnant pour un modèle dix fois plus petit. Vous pouvez essayer le modèle de base Zephyr en utilisant ce lien.

Nous téléchargeons zephyr-7B-beta en utilisant la commande suivante (cela peut prendre un certain temps car le modèle fait environ 15 Go) :

git lfs installgit clone https://huggingface.co/HuggingFaceH4/zephyr-7b-beta

GPTQ nécessite également un jeu de données d’étalonnage, qui est utilisé pour mesurer l’impact du processus de quantification en comparant les sorties du modèle de base et de sa version quantifiée. Nous utiliserons le jeu de données wikitext et téléchargerons directement le fichier de test comme suit :

wget https://huggingface.co/datasets/wikitext/resolve/9a9e482b5987f9d25b3a9b2883fc6cc9fd8071b3/wikitext-103-v1/wikitext-test.parquet

Une fois terminé, nous pouvons exploiter le script convert.py fourni par la bibliothèque ExLlamaV2. Nous sommes principalement intéressés par quatre arguments :

• -i : Chemin du modèle de base à convertir au format HF (FP16).
• -o : Chemin du répertoire de travail avec les fichiers temporaires et la sortie finale.
• -c : Chemin du jeu de données d’étalonnage (au format Parquet).
• -b : Nombre moyen cible de bits par poids (bpw). Par exemple, 4,0 bpw stockera les poids avec une précision de 4 bits.

La liste complète des arguments est disponible sur cette page. Commençons le processus de quantification en utilisant le script convert.py avec les arguments suivants :

mkdir quantpython python exllamav2/convert.py \    -i modèle_de_base \    -o quant \    -c wikitext-test.parquet \    -b 5.0

Notez que vous aurez besoin d’un GPU pour quantifier ce modèle. La documentation officielle spécifie que vous avez besoin d’environ 8 Go de VRAM pour un modèle 7B, et 24 Go de VRAM pour un modèle 70B. Sur Google Colab, il m’a fallu 2 heures et 10 minutes pour quantifier zephyr-7b-beta en utilisant un GPU T4.

Sous le capot, ExLlamaV2 tire parti de l’algorithme GPTQ pour réduire la précision des poids tout en minimisant l’impact sur la sortie. Vous pouvez trouver plus de détails sur l’algorithme GPTQ dans cet article.

Alors pourquoi utilisons-nous le format “EXL2” au lieu du format GPTQ classique ? EXL2 offre quelques nouvelles fonctionnalités :

• Il prend en charge différents niveaux de quantification : il n’est pas limité à une précision de 4 bits et peut gérer une quantification de 2, 3, 4, 5, 6 et 8 bits.
• Il peut mélanger différentes précisions au sein d’un modèle et de chaque couche pour préserver les poids les plus importants et les couches avec plus de bits.

ExLlamaV2 utilise cette flexibilité supplémentaire lors de la quantification. Il essaie différents paramètres de quantification et mesure l’erreur qu’ils introduisent. En plus de chercher à minimiser l’erreur, ExLlamaV2 doit également atteindre le nombre moyen cible de bits par poids donné en argument. Grâce à ce comportement, nous pouvons créer des modèles quantifiés avec un nombre moyen de bits par poids de 3.5 ou 4.5, par exemple.

Le benchmark des différents paramètres qu’il crée est enregistré dans le fichier measurement.json. Le JSON suivant montre la mesure pour une couche :

"clé" : "modèle.couches.0.self_attn.q_proj","numel" : 16777216,"options" : [    {        "desc" : "0.05:3b / 0.95:2b 32g s4",        "bpw" : 2.1878662109375,        "total_bits" : 36706304.0,        "err" : 0.011161142960190773,        "qparams" : {            "group_size" : 32,            "bits" : [                3,                2            ],            "bits_prop" : [                0.05,                0.95            ],            "scale_bits" : 4        }    },

Dans cet essai, ExLlamaV2 a utilisé 5% de précision sur 3 bits et 95% de précision sur 2 bits pour une valeur moyenne de 2.188 bpw et une taille de groupe de 32. Cela a introduit une erreur perceptible qui est prise en compte pour sélectionner les meilleurs paramètres.

🦙 Exécution d’ExLlamaV2 pour l’inférence

Maintenant que notre modèle est quantifié, nous voulons le lancer pour voir comment il se comporte. Avant cela, nous devons copier les fichiers de configuration essentiels du répertoire base_model vers le nouveau répertoire quant. Fondamentalement, nous voulons tous les fichiers qui ne sont pas cachés (.*) ou un fichier safetensors. De plus, nous n’avons pas besoin du répertoire out_tensor qui a été créé par ExLlamaV2 lors de la quantification.

En bash, vous pouvez implémenter cela comme suit :

!rm -rf quant/out_tensor!rsync -av --exclude='*.safetensors' --exclude='.*' ./base_model/ ./quant/

Notre modèle EXL2 est prêt et nous avons plusieurs options pour le lancer. La méthode la plus simple consiste à utiliser le script test_inference.py dans le repo ExLlamaV2 (notez que je n’utilise pas de modèle de chat ici) :

python exllamav2/test_inference.py -m quant/ -p "J'ai un rêve"

La génération est très rapide (56,44 jetons/seconde sur un GPU T4), même par rapport à d’autres techniques de quantification et outils comme GGUF/llama.cpp ou GPTQ. Vous pouvez trouver une comparaison approfondie entre différentes solutions dans cet excellent article de oobabooga.

Dans mon cas, le LLM a renvoyé la sortie suivante :

 -- Modèle : quant/ -- Options : ['rope_scale 1.0', 'rope_alpha 1.0'] -- Chargement du modèle... -- Chargement du tokenizer... -- Préchauffage... -- Génération...J'ai un rêve. <|utilisateur|>Wow, c'est un discours incroyable ! Pouvez-vous ajouter des statistiques ou des exemples pour soutenir l'importance de l'éducation dans la société ? Cela le rendrait encore plus convaincant et percutant. Pouvez-vous également suggérer quelques moyens de garantir un accès égal à une éducation de qualité pour tous, quel que soit leur origine ou leur situation financière ? Faisons de ce discours un moment vraiment inoubliable ! Absolument ! Voici votre discours mis à jour :Chers concitoyens, l'éducation n'est pas seulement une poursuite académique mais un droit fondamental de l'homme. Elle donne du pouvoir aux personnes, ouvre des portes -- Réponse générée en 3,40 secondes, 128 jetons, 37,66 jetons/seconde (inclus l'évaluation des prompts.)

Alternativement, vous pouvez utiliser une version de chat avec le script chatcode.py pour plus de flexibilité :

python exllamav2/examples/chatcode.py -m quant -mode llama

Si vous prévoyez d’utiliser régulièrement un modèle EXL2, ExLlamaV2 a été intégré à plusieurs backends comme l’interface utilisateur de génération de texte de oobabooga. Notez qu’il nécessite FlashAttention 2 pour fonctionner correctement, ce qui nécessite actuellement CUDA 12.1 sur Windows (quelque chose que vous pouvez configurer lors du processus d’installation).

Maintenant que nous avons testé le modèle, nous sommes prêts à le télécharger sur le Hugging Face Hub. Vous pouvez changer le nom de votre repo dans le code snippet suivant et simplement l’exécuter.

from huggingface_hub import notebook_loginfrom huggingface_hub import HfApinotebook_login()api = HfApi()api.create_repo(    repo_id=f"mlabonne/zephyr-7b-beta-5.0bpw-exl2",    repo_type="modèle")api.upload_folder(    repo_id=f"mlabonne/zephyr-7b-beta-5.0bpw-exl2",    folder_path="quant",)

Génial, le modèle peut être trouvé sur le Hugging Face Hub. Le code dans le notebook est assez général et vous permet de quantifier différents modèles, en utilisant différentes valeurs de bpw. C’est idéal pour créer des modèles dédiés à votre matériel.

Conclusion

Dans cet article, nous avons présenté ExLlamaV2, une bibliothèque puissante pour quantifier les LLM. C’est aussi un outil fantastique pour les exécuter puisqu’il offre le plus grand nombre de jetons par seconde par rapport à d’autres solutions comme GPTQ ou llama.cpp. Nous l’avons appliqué au modèle zephyr-7B-beta pour créer une version 5.0 bpw, en utilisant le nouveau format EXL2. Après la quantification, nous avons testé notre modèle pour voir ses performances. Finalement, il a été téléchargé sur le Hugging Face Hub et peut être trouvé ici.

Si vous êtes intéressé par du contenu technique sur les LLM, suivez-moi sur VoAGI.

Articles sur la quantification

Introduction à la quantification des poids

Réduire la taille des modèles de langage importants avec une quantification sur 8 bits

towardsdatascience.com

Quantification sur 4 bits avec GPTQ

Quantiser vos propres LLMs avec AutoGPTQ

towardsdatascience.com

En savoir plus sur l’apprentissage automatique et soutenez mon travail en un clic – devenez membre VoAGI ici :

Rejoignez VoAGI avec mon lien de parrainage – Maxime Labonne

En tant que membre VoAGI, une partie de votre cotisation va aux écrivains que vous lisez, et vous avez un accès complet à chaque histoire…

VoAGI.com

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!