# Intégration et utilisation de Kernels Hub

La bibliothèque [`kernels`](https://huggingface.co/blog/hello-hf-kernels#get-started-and-next-steps) permet de charger directement depuis le Hub des noyaux de calcul optimisés. Vous pouvez trouver des `kernels` dans des [organisations dédiées](https://huggingface.co/kernels-community) ou en recherchant le [`kernel` tag](https://huggingface.co/models?other=kernel) au sein du Hub.

Les kernels sont des **fragments de code optimisés** qui facilitent le développement, l’entraînement et l’inférence des modèles. Ici, nous nous concentrons sur leur **intégration avec TRL**, mais consultez les ressources ci-dessus pour en savoir plus à leur sujet.

## Installation

Pour utiliser des noyaux avec TRL, vous devez installer la bibliothèque dans votre environnement Python :

```bash
pip install kernels
```

## Utiliser des Kernels du Hub dans TRL

Les noyaux peuvent remplacer directement les implémentations d'attention, éliminant le besoin de compiler manuellement des backends d'attention comme Flash Attention et accélérant l'entraînement simplement en récupérant le noyau d'attention correspondant depuis le Hub.

Vous pouvez spécifier un noyau lors du chargement d'un modèle :

```python
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "your-model-name",
    attn_implementation="kernels-community/flash-attn2"  # other options: kernels-community/vllm-flash-attn3, kernels-community/paged-attention
)
```

Ou lors de l’exécution d’un script d’entraînement TRL :

```bash
python sft.py ... --attn_implementation kernels-community/flash-attn2
```

Ou en utilisant le CLI TRL :

```bash
trl sft ... --attn_implementation kernels-community/flash-attn2
```

> [!TIP]
> Vous pouvez désormais tirer parti de backends d'attention plus rapides grâce à un noyau pré-optimisé pour votre configuration matérielle, disponible sur le Hub, ce qui accélère à la fois le développement et l'entraînement.

## Choisir et fixer une version de noyau

Les dépôts de noyaux sur le Hub sont versionnés sous forme de branches (`v1`, `v2`, `v3`, ...), et Transformers sélectionne une version par défaut pour chaque dépôt. Cette version par défaut peut changer d'une version de Transformers à l'autre, de sorte que la même valeur de `attn_implementation` ne résout pas toujours vers le même build.

Pour contrôler quelle version est chargée, ajoutez une révision à l’identifiant du dépôt, soit une branche de version, soit un SHA de commit :

```python
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    "your-model-name",
    attn_implementation="kernels-community/flash-attn2@v2",  # or a commit SHA to pin an exact build
)
```

Le verrouillage de version est utile pour rendre une session d’entraînement reproductible et pour rester sur une version connue comme fonctionnelle lorsqu’une version plus récente présente des régressions. Gardez à l’esprit que chaque version ne fournit des builds que pour une plage de versions de Torch et de CUDA, il est donc possible qu’une version verrouillée n’ait pas de variante compatible avec votre environnement.

> [!TIP]
> `attn_implementation="flash_attention_2"` bascule sur le noyau Hub `kernels-community/flash-attn2` lorsque le package `flash-attn` n’est pas installé, il est donc possible que vous utilisiez un noyau Hub sans l’avoir demandé explicitement.

> [!WARNING]
> Les builds `v3` pour CUDA 12.8 échouent actuellement lors de la rétropropagation pour les modèles utilisant l'attention à requêtes groupées. Si votre environnement utilise cette version de CUDA, fixez `@v2` jusqu'à la clôture de [huggingface/kernels-community#1085](https://github.com/huggingface/kernels-community/issues/1085).

## Comparaison des implémentations d'attention

Nous avons évalué diverses implémentations d'attention disponibles dans transformers, ainsi que différents backends de noyaux, en utilisant **TRL** et **SFT**. Les expériences ont été exécutées sur un seul **H100 GPU** avec **CUDA 12.9**, en exploitant **Qwen3-8B** avec une **taille de lot de 8**, une **accumulation de gradients de 1** et une précision **bfloat16**. Gardez à l'esprit que les résultats présentés ici sont spécifiques à cette configuration et peuvent varier selon les configurations d'entraînement.

La figure suivante illustre à la fois la **latence** (temps par étape d’entraînement) et la **mémoire allouée au pic** pour les différentes implémentations d’attention et les backends de noyaux. Les implémentations basées sur des noyaux offrent des performances comparables à celles de l’attention installée sur mesure, et l’augmentation de la `max_length` du modèle améliore encore les performances. La consommation de mémoire est similaire pour toutes les implémentations, sans différences significatives. Nous obtenons les mêmes performances, mais avec moins de friction, comme décrit dans [la section suivante](#flash-attention-vs-hub-kernels).

  
  

## Flash Attention vs. Hub Kernels

La compilation de Flash Attention à partir des sources peut être longue, prenant généralement de quelques minutes à plusieurs heures, selon votre matériel, votre configuration CUDA/PyTorch et la disponibilité de roues précompilées.

En revanche, **Hugging Face Kernels** offrent un flux de travail beaucoup plus rapide et plus fiable. Les développeurs n’ont pas à se soucier des configurations complexes : tout est géré automatiquement. Dans nos benchmarks, les kernels étaient prêts à l’emploi en environ **2,5 secondes**, sans compilation requise. Cela permet de démarrer l’entraînement presque instantanément, accélérant considérablement le développement. Il suffit de spécifier la version souhaitée et `kernels` s’occupe du reste.

