GPTQ

Le projet GPT-QModel (paquet Python gptqmodel) implémente l'algorithme GPTQ, une technique de quantification après entraînement dans laquelle chaque ligne de la matrice de poids est quantifiée indépendamment afin de trouver une version des poids qui minimise l'erreur. Ces poids sont quantifiés en int4, mais ils sont restaurés en fp16 à la volée pendant l'inférence. Cela peut réduire l'utilisation de la mémoire par un facteur de 4, car les poids int4 sont déquantifiés dans un noyau fusionné plutôt que dans la mémoire globale du GPU. L'inférence est également plus rapide, car une largeur de bits plus faible nécessite moins de temps pour la communication.

AutoGPTQ n'est plus pris en charge dans Transformers. Installez GPT-QModel à la place.

Installez d'abord Accelerate, Transformers et Optimum.

pip install --upgrade accelerate optimum transformers

Puis exécutez la commande ci-dessous pour installer GPT-QModel.

pip install gptqmodel --no-build-isolation

Créez une classe GPTQConfig et définissez le nombre de bits pour la quantification, un jeu de données pour calibrer les poids en vue de la quantification, ainsi qu’un tokenizer pour préparer le jeu de données.

from transformers import AutoModelForCausalLM, AutoTokenizer, GPTQConfig

tokenizer = AutoTokenizer.from_pretrained("facebook/opt-125m")
gptq_config = GPTQConfig(bits=4, dataset="c4", tokenizer=tokenizer)

Vous pouvez passer votre propre jeu de données sous forme de liste de chaînes de caractères, mais il est vivement recommandé d’utiliser le même jeu de données que celui utilisé dans l’article GPTQ.

dataset = ["gptqmodel is an easy-to-use model quantization library with user-friendly apis, based on the GPTQ algorithm."]
gptq_config = GPTQConfig(bits=4, dataset=dataset, tokenizer=tokenizer)

Chargez un modèle à quantiser et passez GPTQConfig à from_pretrained(). Définissez device_map="auto" pour décharger automatiquement le modèle sur le CPU afin de l’aider à tenir en mémoire, et autorisez le déplacement des modules du modèle entre le CPU et le GPU pour la quantisation.

quantized_model = AutoModelForCausalLM.from_pretrained("facebook/opt-125m", device_map="auto", quantization_config=gptq_config)

Si vous êtes à court de mémoire car un jeu de données est trop volumineux (le déchargement sur disque n’est pas pris en charge), essayez de passer le paramètre max_memory pour allouer la quantité de mémoire à utiliser sur votre appareil (GPU et CPU).

quantized_model = AutoModelForCausalLM.from_pretrained(
    "facebook/opt-125m",
    device_map="auto",
    max_memory={0: "30GiB", 1: "46GiB", "cpu": "30GiB"},
    quantization_config=gptq_config
)

Selon votre matériel, la quantification d’un modèle à partir de zéro peut prendre un certain temps. Il faut environ 5 minutes pour quantifier le modèle facebook/opt-350m sur un GPU Google Colab de niveau gratuit, mais environ 4 heures pour quantifier un modèle de 175 milliards de paramètres sur une NVIDIA A100. Avant de quantifier un modèle, il est judicieux de vérifier sur le Hub si une version quantifiée GPTQ du modèle existe déjà.

Une fois un modèle quantisé, vous pouvez utiliser push_to_hub() pour publier le modèle et le tokenizer sur le Hub, où ils peuvent être facilement partagés et accédés. Cela enregistre le GPTQConfig.

quantized_model.push_to_hub("opt-125m-gptq")
tokenizer.push_to_hub("opt-125m-gptq")

save_pretrained() enregistre un modèle quantifié localement. Si le modèle a été quantisé avec le paramètre device_map, veillez à déplacer l’ensemble du modèle sur un GPU ou un CPU avant de l’enregistrer. L’exemple ci-dessous enregistre le modèle sur un CPU.

quantized_model.save_pretrained("opt-125m-gptq")
tokenizer.save_pretrained("opt-125m-gptq")

# if quantized with device_map set
quantized_model.to("cpu")
quantized_model.save_pretrained("opt-125m-gptq")

Rechargez un modèle quantisé avec from_pretrained() et définissez device_map="auto" pour distribuer automatiquement le modèle sur toutes les GPU disponibles, afin de le charger plus rapidement sans consommer plus de mémoire que nécessaire.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained("{your_username}/opt-125m-gptq", device_map="auto")

Marlin

Marlin est un noyau CUDA GPTQ en 4 bits uniquement, fortement optimisé pour l’architecture des GPU NVIDIA A100 (Ampere). Le chargement, la déquantification et l’exécution des poids après déquantification sont hautement parallélisés, offrant une amélioration significative de l’inférence par rapport au noyau CUDA GPTQ d’origine. Marlin n’est disponible que pour l’inférence quantifiée et ne prend pas en charge la quantification des modèles.

L'inférence Marlin peut être activée avec le paramètre backend dans GPTQConfig.

from transformers import AutoModelForCausalLM, GPTQConfig

model = AutoModelForCausalLM.from_pretrained("{your_username}/opt-125m-gptq", device_map="auto", quantization_config=GPTQConfig(bits=4, backend="marlin"))

GPT-QModel

GPT-QModel est le backend activement maintenu pour GPTQ dans Transformers. Il a été initialement forké depuis AutoGPTQ, mais s'en est depuis distingué avec des améliorations significatives telles qu'une quantification plus rapide, une consommation mémoire réduite et des valeurs par défaut plus précises.

GPT-QModel fournit une quantification asymétrique, qui peut potentiellement réduire les erreurs de quantification par rapport à la quantification symétrique. Elle n'est pas rétrocompatible avec les points de contrôle AutoGPTQ legacy, et tous les noyaux (Marlin) ne prennent pas en charge la quantification asymétrique.

GPT-QModel prend également en charge un plus large éventail des derniers modèles de LLM, des modèles multimodaux (Qwen2-VL et Ovis1.6-VL), des plateformes (Linux, macOS, Windows 11) et du matériel (AMD ROCm, Apple Silicon, CPU Intel/AMD, GPU Intel Datacenter Max/Arc, etc.).

Les noyaux Marlin sont également mis à jour pour les GPU A100, et d'autres noyaux sont mis à jour afin d'inclure un auto-padding pour les modèles legacy et les modèles avec des caractéristiques d'entrée/sortie non uniformes.

Ressources

Lancez la quantification GPTQ avec le notebook PEFT pour une expérience pratique.