FP8 à granularité fine

La quantification FP8 fine quantise les poids et les activations en fp8.

• Les poids sont quantifiés sur 8 bits pour chaque bloc 2D (weight_block_size=(128, 128)).
• Les activations sont quantifiées sur 8 bits pour chaque groupe par jeton. La valeur du groupe correspond aux poids du canal d'entrée (128 par défaut).

La quantification FP8 permet de prendre en charge DeepSeek-V3 et DeepSeek-R1.

Vous avez besoin d'un GPU avec une Compute Capability>=9 (H100) et d'installer une version de PyTorch compatible avec la version CUDA de votre GPU.

Installez Accelerate et mettez à jour vers la dernière version de PyTorch.

pip install --upgrade accelerate torch

Créez une classe FineGrainedFP8Config et transmettez-la à from_pretrained() pour effectuer la quantification. Par défaut, les poids sont chargés en pleine précision (torch.float32), quel que soit le type de données réel dans lequel ils sont stockés. Définissez dtype="auto" pour charger les poids dans le type de données défini dans le fichier config.json du modèle, afin de charger automatiquement le type de données le plus optimal en termes de mémoire.

from transformers import FineGrainedFP8Config, AutoModelForCausalLM, AutoTokenizer

model_name = "meta-llama/Meta-Llama-3-8B"
quantization_config = FineGrainedFP8Config()
quantized_model = AutoModelForCausalLM.from_pretrained(model_name, dtype="auto", device_map="auto", quantization_config=quantization_config)

tokenizer = AutoTokenizer.from_pretrained(model_name)
input_text = "What are we having for dinner?"
input_ids = tokenizer(input_text, return_tensors="pt").to(quantized_model.device.type)

output = quantized_model.generate(**input_ids, max_new_tokens=10)
print(tokenizer.decode(output[0], skip_special_tokens=True))

Utilisez save_pretrained() pour enregistrer le modèle quantifié, puis rechargez-le avec from_pretrained().

quant_path = "/path/to/save/quantized/model"
quantized_model.save_pretrained(quant_path)
model = AutoModelForCausalLM.from_pretrained(quant_path, device_map="auto")

Chemin rapide de DeepGEMM

Sur les GPU Hopper (SM90+) et Blackwell (SM100+), chaque linéaire FP8 est automatiquement acheminé vers les noyaux DeepGEMM de kernels-community/deep-gemm lorsque weight_block_size=(128, 128) et activation_scheme="dynamic". DeepGEMM est 3 à 6 fois plus rapide que le repli Triton. Installez ou mettez à jour le package kernels pour l’activer.

pip install -U kernels

DeepGEMM compile ses noyaux à la volée (JIT) avec le nvcc du système, il est donc nécessaire d’installer le kit de développement CUDA complet. Une installation limitée au temps d’exécution (bibliothèques CUDA sans nvcc) ne fonctionnera pas. La version minimale du kit de développement dépend du matériel : 12.3 ou ultérieure sur Hopper (SM90), 12.9 ou ultérieure sur Blackwell (SM100).

Transformers localise le kit d’outils en vérifiant CUDA_HOME, puis CUDA_PATH, puis nvcc dans votre PATH, puis /usr/local/cuda. Définissez CUDA_HOME sur la racine du kit d’outils si nvcc n’est pas détecté.

Si le noyau ne peut pas être chargé (absence de kernels, GPU non pris en charge, absence du kit CUDA, ou nvcc plus ancien que la version requise), Transformers journalise un avertissement une seule fois et bascule sur le noyau finegrained-fp8 de Triton. La quantification statique des activations reste toujours sur le chemin Triton.

Pour forcer le repli sur Triton même lorsque DeepGEMM est disponible, définissez TRANSFORMERS_DISABLE_DEEPGEMM_LINEAR=1. Cela n'affecte que la distribution des opérations linéaires FP8 et laisse inchangé le backend d'experts "deepgemm", que vous modifiez avec set_experts_implementation().

Pour les experts MoE, le chemin DeepGEMM est activé manuellement. Passez experts_implementation="deepgemm" (ou "deepgemm_megamoe" sur Blackwell) au chargement pour acheminer les produits matriciels des experts via DeepGEMM. Consultez le guide Backends des experts pour l’ensemble des options disponibles.

Format d'échelle UE8M0

Les points de contrôle de type DeepSeek V4 stockent les échelles de poids FP8 dans le format float8_e8m0fnu compact, au lieu de float32. Ces points de contrôle sont pré-quantifiés et définissent scale_fmt="ue8m0" dans leur configuration de quantification. Les noyaux DeepGEMM et Triton lisent tous les deux les échelles UE8M0, de sorte que ces points de contrôle fonctionnent sur les deux chemins.

Sur Blackwell (SM100+), les noyaux d'experts de DeepGEMM ne prennent en charge que les échelles UE8M0. Un point de contrôle avec des échelles float32 simples (scale_fmt="float") provoque une ValueError. Utilisez un point de contrôle scale_fmt="ue8m0", ou exécutez les experts avec grouped_mm ou batched_mm, qui prennent en charge directement les échelles float32. Hopper (SM90+) prend en charge les échelles float32 sur le chemin DeepGEMM sans conversion. Consultez le guide Experts backends pour les options de backend des experts.