AutoGPTQ : un package de quantification d'LLMs convivial

Name

Oluwaseun Adeojo

Published on 04/06/2023

(opens in a new tab) (opens in a new tab) (opens in a new tab) (opens in a new tab) (opens in a new tab) (opens in a new tab)

Introduction à AutoGPTQ

Avec l'avènement de modèles de langage plus grands (LLMs) dans le paysage de l'IA, l'optimisation de leur efficacité est devenue une entreprise cruciale. AutoGPTQ propose une solution en offrant un package de quantification d'LLMs convivial construit autour de l'algorithme GPTQ. Avec des API conviviales, AutoGPTQ apporte une approche efficace pour gérer les tâches de quantification dans les workflows d'apprentissage automatique.

Vous pouvez consulter AutoGPTQ sur Github ici (opens in a new tab).

Mises à jour et performances d'AutoGPTQ

AutoGPTQ est un projet dynamique qui améliore en permanence ses fonctionnalités et ses capacités. Les dernières mises à jour impliquent l'intégration avec les bibliothèques d'optimisation des performances, la prise en charge de différents types de modèles et l'amélioration de la vitesse du noyau CUDA.

L'une des principales forces d'AutoGPTQ est sa vitesse d'inférence. La comparaison de la GPU montre une métrique de vitesse impressionnante, tokens/seconde, avec le modèle quantifié utilisant AutoGPTQ surpassant les autres. Par exemple, avec une taille de batch d'entrée égale à 1, en utilisant une stratégie de décodage avec recherche de faisceau et en contraignant le modèle à générer 512 tokens, le modèle quantifié Llama-7b surpasse le modèle d'origine en termes de vitesse d'inférence (25.53 tokens/s contre 18.87 tokens/s).

# Comparaison des performances d'AutoGPTQ
performance_comparison = {
    "model": ["llama-7b", "moss-moon 16b", "gpt-j 6b"],
    "GPU": ["1xA100-40G", "1xA100-40G", "1xRTX3060-12G"],
    "num_beams": [1, 4, 1],
    "fp16": [18.87, 68.79, None],
    "gptq-int4": [25.53, 91.30, 29.55]
}

Installation d'AutoGPTQ

Commencer avec AutoGPTQ est simple. La dernière version stable peut être installée depuis pip, ce qui permet une configuration rapide :

pip install auto-gptq

Pour certaines configurations, des fichiers wheel pré-construits correspondant à votre environnement peuvent être téléchargés depuis les fichiers de version et installés pour éviter l'étape de construction :

# tout d'abord, allez dans le répertoire où se trouve le fichier wheel, puis exécutez la commande ci-dessous
pip install auto_gptq-0.2.0+cu118-cp310-cp310-linux_x86_64.whl 
# installez la version 0.2.0 d'auto_gptq pour linux dans un environnement avec python=3.10 et cuda=11.8

De plus, le package offre des options pour désactiver les extensions CUDA ou prendre en charge des modèles spécifiques tels que LLaMa :

# Pour désactiver les extensions CUDA
BUILD_CUDA_EXT=0 pip install auto-gptq
 
# Pour prendre en charge le modèle LLaMa
pip install auto-gptq[llama]

AutoGPTQ en action : quantification et inférence

La fonctionnalité principale d'AutoGPTQ est de permettre la quantification de modèles de langage volumineux. Le processus est simple et peut être exécuté en quelques lignes de code. Voici un exemple où un modèle pré-entraîné est quantifié en 4 bits, puis utilisé pour l'inférence :

from transformers import AutoTokenizer
from auto_gptq import AutoGPTQForCausalLM, Base
 
QuantizeConfig
import logging
 
# Configuration des journaux
logging.basicConfig(format="%(asctime)s %(levelname)s [%(name)s] %(message)s", level=logging.INFO, datefmt="%Y-%m-%d %H:%M:%S")
 
# Définir les répertoires du modèle pré-entraîné et quantifié
pretrained_model_dir = "facebook/opt-125m"
quantized_model_dir = "opt-125m-4bit"
 
# Configuration du tokenizer et des exemples
tokenizer = AutoTokenizer.from_pretrained(pretrained_model_dir, use_fast=True)
examples = [tokenizer("auto-gptq est une bibliothèque de quantification de modèle facile à utiliser avec des API conviviales, basée sur l'algorithme GPTQ.")]
 
# Configuration de la quantification
quantize_config = BaseQuantizeConfig(bits=4, group_size=128, desc_act=False)
 
# Chargement, quantification et sauvegarde du modèle
model = AutoGPTQForCausalLM.from_pretrained(pretrained_model_dir, quantize_config)
model.quantize(examples)
model.save_quantized(quantized_model_dir)

Personnalisation des modèles

AutoGPTQ permet également aux utilisateurs d'étendre ses fonctionnalités pour prendre en charge des modèles personnalisés. Il s'agit d'un processus simple qui donne à l'utilisateur un meilleur contrôle sur ses tâches d'apprentissage automatique. Cette nature personnalisable distingue AutoGPTQ des autres packages de quantification, le rendant plus flexible et adapté à divers cas d'utilisation.

Cette personnalisation peut être observée dans un exemple d'extension d'auto_gptq pour prendre en charge le modèle OPT.

# Étendre auto_gptq pour prendre en charge le modèle OPT (code à fournir en fonction de vos besoins personnalisés)

Évaluation sur les tâches secondaires

AutoGPTQ prend en charge l'évaluation des performances du modèle sur des tâches secondaires spécifiques avant et après la quantification. Cela garantit que le processus de quantification n'impacte pas négativement les performances du modèle sur les tâches qu'il est censé effectuer. Par exemple, vous pouvez évaluer un modèle comme EleutherAI/gpt-j-6b sur une tâche de classification de séquences en utilisant l'ensemble de données cardiffnlp/tweet_sentiment_multilingual :

Pour illustrer davantage cela, nous allons passer en revue un exemple d'évaluation simple en utilisant le modèle EleutherAI/gpt-j-6b et l'ensemble de données cardiffnlp/tweet_sentiment_multilingual. Dans ce cas, nous évaluons les performances du modèle quantifié sur une tâche de classification de séquences, plus précisément l'analyse de sentiment.

from transformers import pipeline, AutoTokenizer
from auto_gptq import AutoGPTQForSequenceClassification
from datasets import load_dataset
 
# Définir les répertoires du modèle pré-entraîné et quantifié
pretrained_model_dir = "EleutherAI/gpt-j-6b"
quantized_model_dir = "gpt-j-6b-4bit"
 
# Charger et quantifier le modèle
model = AutoGPTQForSequenceClassification.from_pretrained(pretrained_model_dir)
model.quantize()
model.save_quantized(quantized_model_dir)
 
# Charger le tokenizer et le pipeline d'analyse de sentiment
tokenizer = AutoTokenizer.from_pretrained(quantized_model_dir)
sentiment_analysis = pipeline("sentiment-analysis", model=model, tokenizer=tokenizer)
 
# Charger le jeu de données
dataset = load_dataset("cardiffnlp/tweet_sentiment_multilingual", split="test")
 
# Évaluer le modèle sur le jeu de données de test
correct, total = 0, 0
for example in dataset:
    prediction = sentiment_analysis(example["text"])[0]
    if prediction["label"].lower() == example["label"].lower():
        correct += 1
    total += 1
 
# Afficher l'exactitude du modèle sur le jeu de données de test
print(f"Exactitude : {correct / total:.2f}")

Le code ci-dessus présente la quantification, l'enregistrement et l'évaluation ultérieure du modèle quantifié. Cela vous permet d'évaluer les performances du modèle et l'impact du processus de quantification sur la classification de séquences.

FAQ

1. AutoGPTQ ne peut-il gérer que les modèles basés sur GPT ?

Bien que AutoGPTQ ait été initialement conçu avec les modèles GPT à l'esprit, les développeurs ont étendu ses fonctionnalités pour prendre en charge une plus large gamme de modèles de transformer. Cette polyvalence découle de la conception modulaire de la bibliothèque, qui permet de l'adapter à d'autres modèles.

2. Comment puis-je personnaliser AutoGPTQ pour mon cas d'utilisation spécifique ?

AutoGPTQ permet la personnalisation en étendant ses classes et méthodes pour prendre en charge vos besoins spécifiques. Vous pouvez créer des classes personnalisées héritant des classes de base fournies par AutoGPTQ et remplacer les méthodes nécessaires.

3. La quantification affectera-t-elle les performances de mon modèle ?

La quantification implique un compromis entre les performances du modèle, sa taille et son efficacité de calcul. Cependant, AutoGPTQ vise à minimiser cet impact. Il offre des options pour évaluer votre modèle sur des tâches ultérieures avant et après la quantification, ce qui vous permet de vous assurer que la dégradation des performances est acceptable pour votre cas d'utilisation.

Conclusion

En conclusion, AutoGPTQ offre un moyen efficace et efficient de quantifier les modèles de transformer tout en maintenant des normes de performance sur des tâches spécifiques. Son API conviviale et ses capacités de personnalisation en font un outil polyvalent pour les professionnels de l'apprentissage automatique qui cherchent à optimiser leurs modèles. Que vous souhaitiez réduire les besoins de stockage de votre modèle ou améliorer la vitesse d'inférence, AutoGPTQ peut être un élément essentiel de votre boîte à outils.