Choisir une méthode

Si votre point de contrôle est déjà quantifié, c'est le point de contrôle qui détermine la méthode. Chargez-le comme indiqué dans Charger un point de contrôle pré-quantifié. Sinon, choisissez une méthode en fonction de votre matériel et de ce que vous devez faire avec le modèle après son chargement.

Partez de votre objectif

Chaque ligne recommande une première méthode à essayer. Consultez le tableau de comparaison complet avant de vous engager sur une option.

Objectif	Commencez par	Pourquoi
Entraînez un modèle avec moins de mémoire et un minimum de configuration	bitsandbytes	Quantifie en 4 ou 8 bits lors du chargement, sans calibration, fonctionne sur CUDA, XPU, HPU et CPU, et prend en charge la sauvegarde et l'ajustement fin.
Ajustement fin avec QLoRA	bitsandbytes	Prend en charge le NF4 4 bits avec PEFT. HQQ, EETQ, GPTQ, SINQ et Quanto prennent également en charge le fine-tuning.
Accélérer l'inférence avec `torch.compile`	torchao	`generate` compile automatiquement les modèles torchao avec un cache statique, et torchao propose des schémas int4, int8 et FP8 pour CUDA, XPU et CPU.
Obtenir la meilleure précision en 4 bits	GPTQ	Effectue l'étalonnage sur un jeu de données lors du chargement. Pour utiliser AWQ ou AutoRound à la place, quantifiez avec leurs bibliothèques respectives puis chargez le point de contrôle.
Exécuter FP8 sur Ada, Hopper ou Intel XPU	FP8 à granularité fine	Nécessite une capacité de calcul CUDA 8.9 ou supérieure, ou un XPU. FBGEMM FP8 nécessite une capacité de calcul 9.0 ou supérieure, ou un XPU.
Exécuter FP4 sur Blackwell	NVFP4	Quantifie au format flottant 4 bits de NVIDIA lors du chargement. MXFP4 s’exécute sur une capacité de calcul 7.5 ou supérieure, XPU et CPU.
Exécuter sur Apple silicon	Metal	Quantifie en 2, 4 ou 8 bits sur MPS lors du chargement. Les fichiers GGUF sont également chargés sur MPS.
Charger les points de contrôle créés avec llm-compressor	compressed-tensors	Charge les points de contrôle FP8, int4 et int8 au format compressed-tensors.
Compression en moins de 4 bits	HQQ ou SINQ	Quantifier en 2 ou 3 bits lors du chargement, sans calibration. Les points de contrôle AQLM, VPTQ et SpQR descendent plus bas, mais doivent être quantifiés avec leurs propres bibliothèques.

Show the full comparison table

Méthode	`quant_method`	Flux de travail	Bits	Matériel	Enregistrer	Ajustement fin	Auto-compilation
AQLM	`aqlm`	Pré-quantifiés uniquement	1–2	CUDA, CPU	✅	✅ avec `aqlm>=1.0.2`	❌
AutoRound	`auto-round`	Pré-quantifiés uniquement	2–8	CUDA, XPU, CPU	✅	❌	❌
AWQ	`awq`	Pré-quantifiés uniquement	4	CUDA, ROCm, XPU, CPU	✅ sauf les backends ExLlama	✅ avec `gptqmodel>=5.0.0`	❌
BitNet	`bitnet`	Pré-quantifiés uniquement	1.58	CUDA	✅	Uniquement `autobitlinear` en mode `online`	❌
bitsandbytes	`bitsandbytes`	Pendant le chargement	4, 8	CUDA, XPU, HPU, CPU	✅	✅	❌
compressed-tensors	`compressed-tensors`	Pré-quantifiés uniquement	Défini par point de contrôle	CUDA, XPU, MPS, CPU	✅	✅ sauf avec les noyaux FP8	✅
EETQ	`eetq`	Pendant le chargement	8	CUDA	✅	✅	❌
FBGEMM FP8	`fbgemm_fp8`	Pendant le chargement	8	CUDA (capacité de calcul 9.0+), XPU	✅	❌	❌
FP8 à granularité fine	`fp8`, `mxfp8`	Pendant le chargement	8	CUDA (capacité de calcul 8.9+), XPU	✅	❌	✅
Four Over Six	`fouroversix`	Pendant le chargement	4	CUDA (le plus rapide sur Blackwell), CPU	✅	Uniquement avec `keep_master_weights=True`	❌
FP-Quant	`fp_quant`	Pendant le chargement	4	CUDA, XPU	✅	Uniquement avec `store_master_weights=True`	❌
GGUF	`gguf`	Pré-quantifiés uniquement	1–8	CUDA, MPS, XPU, CPU	❌	❌	✅
GPTQ	`gptq`	Pendant le chargement, avec calibration	2, 3, 4, 8	CUDA, ROCm, XPU, CPU	✅	✅	❌
HIGGS	`higgs`	Pendant le chargement	2, 3, 4	CUDA	✅	❌	❌
HQQ	`hqq`	Pendant le chargement	1, 2, 3, 4, 8	CUDA, XPU	✅	✅	❌
Metal	`metal`	Pendant le chargement	2, 4, 8	MPS	✅	❌	❌
MXFP4	`mxfp4`	Pendant le chargement	4	CUDA (capacité de calcul 7.5+), XPU, CPU	✅	❌	❌
NVFP4	`nvfp4`	Pendant le chargement	4	Un GPU Blackwell	❌	❌	✅
Quanto	`quanto`	Pendant le chargement	2, 4, 8	CUDA, MPS, XPU, CPU	❌	✅	❌
Quark	`quark`	Pré-quantifiés uniquement	Défini par point de contrôle	CUDA, ROCm, CPU	❌	❌	❌
SINQ	`sinq`	Pendant le chargement	2, 3, 4, 6, 8	Un GPU CUDA, CPU	✅	✅	❌
SpQR	`spqr`	Pré-quantifiés uniquement	3	CUDA	✅	❌	❌
torchao	`torchao`	Pendant le chargement	4, 8	CUDA, XPU, CPU	✅	Schémas 8 bits uniquement	✅
VPTQ	`vptq`	Pré-quantifiés uniquement	1–8	CUDA	✅	❌	❌

Vérifier la mémoire avec le sélecteur de quantification

Le sélecteur de quantification estime si un modèle tient sur votre matériel à chaque précision, y compris le cache KV. Choisissez un modèle, votre matériel et ce que la méthode doit accomplir, et la vue Compare répertorie les méthodes correspondantes.

Benchmarks

Les benchmarks ci-dessous comparent plusieurs méthodes sur Llama 3.1 8B et 70B. Ils rapportent la précision, le débit en jetons par seconde, la mémoire de pointe en Go et le temps de quantification.

Llama 3.1 70B en bf16 a été exécuté sur 2 GPU NVIDIA A100 80GB. Les méthodes FP8 ont été exécutées sur 1 GPU NVIDIA H100 80GB, et toutes les autres méthodes sur 1 GPU NVIDIA A100 80GB. Le débit a été mesuré avec une taille de lot de 1, en générant 64 jetons. Les résultats incluent torch.compile et les noyaux Marlin lorsque la méthode les prend en charge.

Les résultats se regroupent en trois plages de bits.

Bits	Méthodes évaluées	Mémoire vs. bf16	Précision
8	bitsandbytes int8, HQQ, Quanto, torchao, FP8	Environ 2 fois plus petit	Très proche de bf16
4	AWQ, GPTQ, HQQ, bitsandbytes NF4, SINQ	Environ 4 fois plus petit	Élevé. AWQ et GPTQ sont souvent en tête, mais nécessitent une calibration.
Inférieur à 4	VPTQ, AQLM, GPTQ 2 bits	Plus de 4 fois plus petit	Baisse notable, en particulier à 2 bits. AQLM et VPTQ nécessitent un long temps de quantification.

Évaluez la précision et la vitesse sur votre propre tâche et votre propre matériel avant de choisir une méthode pour la production.

Update on GitHub

Transformers

Choisir une méthode

Partez de votre objectif

Vérifier la mémoire avec le sélecteur de quantification

Benchmarks