Transformers documentation
FP-Quant
FP-Quant
FP-Quant quantifie les poids et les activations dans les formats MXFP4 ou NVFP4, en appliquant une rotation (une transformation de Hadamard par défaut) avant la quantification, et exécute les produits matriciels avec les noyaux QuTLASS sur les GPU NVIDIA Blackwell. Utilisez-le pour l’inférence FP4 sur les GPU Blackwell, ou pour émuler la quantification FP4 sur d’autres GPU afin d’évaluer la précision ou d’exécuter un entraînement conscient de la quantification (QAT).
Le tableau ci-dessous résume ce que FP-Quant prend en charge dans Transformers.
| Configuration | FPQuantConfig |
quant_method | fp_quant |
| Flux de travail | Quantifier lors du chargement |
| Bits | 4 |
| Matériel | GPU NVIDIA Blackwell ; autres GPU CUDA et XPU Intel avec pseudoquantization=True |
| Enregistrer | ✅ |
| Ajustement fin | Uniquement avec store_master_weights=True |
| Auto-compilation | ❌ |
Installer FP-Quant
Installez fp_quant 0.3.2 ou une version ultérieure. Pour exécuter les noyaux FP4 réels sur un GPU Blackwell, compilez également QuTLASS 0.2.0 ou une version ultérieure à partir du code source.
pip install -U "fp_quant>=0.3.2"
git clone https://github.com/IST-DASLab/qutlass.git
cd qutlass && pip install --no-build-isolation .Quantifier un modèle avec FP-Quant
Créez un FPQuantConfig et passez-le à from_pretrained(). Définissez device_map sur vos GPU. La configuration par défaut quantise chaque couche linéaire, à l'exception de lm_head, en NVFP4.
from transformers import AutoModelForCausalLM, FPQuantConfig
model = AutoModelForCausalLM.from_pretrained(
"Qwen/Qwen3-8B",
quantization_config=FPQuantConfig(),
device_map="cuda",
)FP-Quant ne prend en charge que bf16, le modèle est donc toujours chargé en bf16. Tout autre dtype est remplacé avec un avertissement.
Sans GPU Blackwell, définissez pseudoquantization=True. FP-Quant émule alors la quantification FP4 à l’aide de noyaux Triton. Cela reproduit la précision du modèle quantifié, mais n’apporte pas d’accélération.
model = AutoModelForCausalLM.from_pretrained(
"Qwen/Qwen3-8B",
quantization_config=FPQuantConfig(forward_dtype="mxfp4", pseudoquantization=True),
device_map="cuda",
)Pour charger un modèle quantisé à l'avance avec GPTQ afin d'obtenir une meilleure précision, passez son dépôt Hub à from_pretrained() sans quantization_config. L'organisation ISTA-DASLab héberge des points de contrôle FP-Quant, et le dépôt FP-Quant contient le code pour les créer.
Configurer FP-Quant
Ces paramètres FPQuantConfig modifient la manière dont les poids et les activations sont quantifiés.
| Paramètre | Par défaut | Effet |
|---|---|---|
forward_dtype | "nvfp4" | Format FP4 pour le passage avant, soit "nvfp4" soit "mxfp4". |
hadamard_group_size | None | Taille de la transformation de Hadamard. Avec None, elle est de 16 pour NVFP4 et de 32 pour MXFP4. NVFP4 accepte 16, 32, 64 et 128, et MXFP4 accepte 32, 64 et 128. |
transform_init | "hadamard" | La façon dont la matrice de transformation est initialisée, soit "hadamard", "identity" ou "gsr". |
pseudoquantization | False | Émule FP4 avec des noyaux Triton au lieu d'exécuter les noyaux QuTLASS. Requis sur les GPU autres que Blackwell. |
Voir FPQuantConfig pour le reste des paramètres.
Entraîner avec des poids quantifiés
FP-Quant prend en charge le QAT. Définissez store_master_weights=True pour conserver les poids haute précision afin qu’ils puissent être mis à jour, et définissez forward_method="quest", qui fonctionne mieux que "abs_max" pour le QAT. La méthode "quest" ne fonctionne qu’avec MXFP4. Lors d’un passage avant MXFP4, backward_dtype peut également quantifier le passage arrière en "mxfp8" ou "mxfp4" au lieu de "bf16".
from transformers import AutoModelForCausalLM, FPQuantConfig
quantization_config = FPQuantConfig(
forward_dtype="mxfp4",
forward_method="quest",
store_master_weights=True,
pseudoquantization=True,
)
model = AutoModelForCausalLM.from_pretrained(
"Qwen/Qwen3-8B",
quantization_config=quantization_config,
device_map="cuda",
)Les auteurs de FP-Quant notent que QAT ne fonctionne actuellement qu'avec pseudoquantization=True.
Limites
- FP-Quant nécessite un GPU CUDA ou un XPU Intel. Le chargement sans l'un d'eux provoque une
NotImplementedError. - Sans QuTLASS installé, le chargement avec
pseudoquantization=Falselève uneImportError. - La pseudo-quantisation NVFP4 nécessite un GPU CUDA avec une capacité de calcul 9.0 ou supérieure (Hopper ou plus récent). Sur les GPU plus anciens, elle lève une
ValueError. Utilisez plutôtforward_dtype="mxfp4". - Sans
pseudoquantization, le chargement sansdevice_maplève uneValueError. Undevice_mapqui répartit le modèle entre un GPU et le CPU lève également uneValueError. - Un
device_mapqui inclut"disk"lève uneValueError. - La pseudo-quantisation ne prend pas en charge plusieurs GPU.
- L’entraînement sans
store_master_weights=Truen’est pas pris en charge.
Ressources
- Comblé l'écart entre la promesse et les performances de la quantification Microscaling FP4
- FP-Quant
- QuTLASS du dépôt, y compris les benchmarks d'accélération