# 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](https://hf.co/papers/2412.19437) et DeepSeek-R1.

    

> [!TIP]
> 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.

```bash
pip install --upgrade accelerate torch
```

Créez une classe [FineGrainedFP8Config](/docs/transformers/v5.23.0/fr/main_classes/quantization#transformers.FineGrainedFP8Config) et transmettez-la à [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.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.

```py
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()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.save_pretrained) pour enregistrer le modèle quantifié, puis rechargez-le avec [from_pretrained()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.from_pretrained).

```py
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](https://github.com/deepseek-ai/DeepGEMM) de [kernels-community/deep-gemm](https://huggingface.co/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](https://github.com/huggingface/kernels) pour l’activer.

```bash
pip install -U kernels
```

DeepGEMM compile ses noyaux à la volée (JIT) avec le `nvcc` 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()](/docs/transformers/v5.23.0/fr/main_classes/model#transformers.PreTrainedModel.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](../experts_interface) 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](../experts_interface) pour les options de backend des experts.

