Aperçu

La quantification stocke les poids d’un modèle, et parfois ses activations, sur un nombre réduit de bits afin de diminuer la mémoire requise. Les modèles sont généralement chargés en bf16, ce qui représente 2 octets par paramètre. Un modèle de 8B nécessite environ 16 Go pour ses poids en bf16, environ 8 Go à 8 bits, et environ 4 à 5 Go à 4 bits. Réduire le nombre de bits entraîne une perte de précision, et chaque méthode de quantification opère un compromis différent entre mémoire, vitesse et précision.

Transformers intègre plus de 20 méthodes de quantification via from_pretrained(), ce qui vous permet d’utiliser le même code de chargement quelle que soit la méthode choisie.

Deux façons d'utiliser un modèle quantifié

La manière d’utiliser la quantisation dépend de savoir si votre point de contrôle est déjà quantisé.

Certaines méthodes, telles que AWQ, AutoRound, AQLM, compressed-tensors et GGUF, ne peuvent être chargées qu’à partir d’un point de contrôle. Vous quantifiez d’abord le modèle avec la bibliothèque propre à la méthode, puis vous chargez le résultat dans Transformers.

Quantifier un modèle lors du chargement

Créez la classe de configuration de la méthode et transmettez-la à quantization_config. L’exemple ci-dessous charge un modèle de 8 milliards de paramètres en 4 bits avec bitsandbytes.

import torch
from transformers import AutoModelForCausalLM, BitsAndBytesConfig

quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.bfloat16,
)
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B-Instruct",
    quantization_config=quantization_config,
    device_map="auto",
)

Chaque méthode de ce groupe possède sa propre classe de configuration, comme TorchAoConfig ou BitsAndBytesConfig. La plupart d’entre elles n’ont pas besoin de jeu de données de calibration. GPTQ fait exception, car elle effectue la calibration sur un jeu de données pendant le chargement du modèle.

Charger un point de contrôle pré-quantifié

Un point de contrôle pré-quantisé stocke un quantization_config dans son config.json. Lorsque from_pretrained le détecte, le quantiseur correspondant est sélectionné automatiquement.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "TheBloke/zephyr-7B-alpha-AWQ",
    device_map="auto",
)
print(model.config.quantization_config.quant_method)

Installez la bibliothèque dont la méthode dépend avant de charger le point de contrôle. Chaque page de méthode indique ce qu’il faut installer. Pour modifier les options de chargement, comme le backend de noyau utilisé, passez une configuration du même type. Ses options sont fusionnées avec celles stockées dans le point de contrôle.

Points de contrôle GGUF

Un point de contrôle GGUF est un fichier unique qui contient les poids, la configuration et le tokenizer, et il ne possède pas de config.json que from_pretrained puisse lire. Nommez le fichier avec gguf_file.

from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "unsloth/Qwen3.5-4B-GGUF",
    gguf_file="Qwen3.5-4B-Q4_K_M.gguf",
)

La plupart des modèles GGUF sont déquantifiés en pleine précision lors du chargement, ce qui entraîne une consommation mémoire identique à celle d’un modèle non quantifié. Les poids restent compressés uniquement sur MPS, à condition que le package kernels soit installé, et ce pour Qwen3.5 et Qwen3.5 MoE. Consultez GGUF pour plus de détails.

Enregistrer un modèle quantifié

Appel de save_pretrained() ou push_to_hub() pour enregistrer les poids quantifiés et leur quantization_config. Toutes les méthodes ne permettent pas d’enregistrer leurs poids quantifiés.

Choisir une méthode

Choisir une méthode propose un point de départ pour des objectifs courants et compare chaque méthode selon le matériel, la largeur de bits, l’économie réalisée, le fine-tuning et la prise en charge de torch.compile. Utilisez le sélecteur de quantification pour vérifier si un modèle tient dans la mémoire de votre matériel à chaque précision.

Autres outils

Ces outils quantifient les modèles en dehors de Transformers.

• Optimum quantifie les modèles pour des matériels et des environnements d’exécution spécifiques, tels que les processeurs Intel et ONNX Runtime.
• Les Spaces du Hub quantifient un modèle et poussent le résultat vers votre compte : bitsandbytes, GGUF et MLX.

Ressources

• cours Fondamentaux de la quantification avec Hugging Face
• cours Quantization in Depth

Étapes suivantes

• Consultez Concepts de quantification pour comprendre le fonctionnement des schémas, de la granularité et des techniques de quantification.
• Quantifiez le cache KV pour économiser de la mémoire lors des générations longues grâce au quantized cache.
• Quantifier un modèle lors de son exportation avec Quantizing exports.
• Contribuer une nouvelle méthode avec Contribute a quantization method.