# Tour rapide

Il existe de nombreuses façons de lancer et d’exécuter votre code en fonction de votre environnement d’entraînement ([torchrun](https://pytorch.org/docs/stable/elastic/run.html), [DeepSpeed](https://www.deepspeed.ai/), etc.) et du matériel disponible. Accelerate propose une interface unifiée pour lancer et entraîner sur différentes configurations distribuées, vous permettant de vous concentrer sur votre code d’entraînement PyTorch plutôt que sur les subtilités de l’adaptation de votre code à ces différentes configurations. Cela vous permet de mettre facilement à l’échelle votre code PyTorch pour l’entraînement et l’inférence sur des configurations distribuées avec du matériel tel que des GPU et des TPU. Accelerate fournit également Big Model Inference pour rendre plus accessible le chargement et l’exécution de l’inférence avec de très grands modèles qui ne tiennent généralement pas en mémoire.

Cette introduction rapide présente les trois fonctionnalités principales d'Accelerate :

* une interface de lancement unifiée en ligne de commande pour les scripts d'entraînement distribué
* une bibliothèque d'entraînement pour adapter le code d'entraînement PyTorch afin de l'exécuter sur différentes configurations distribuées
* Inférence de grands modèles

## Interface de lancement unifiée

Accelerate sélectionne automatiquement les valeurs de configuration appropriées pour tout framework d’entraînement distribué donné (DeepSpeed, FSDP, etc.) via un fichier de configuration unifié généré à partir de la commande [`accelerate config`](package_reference/cli#accelerate-config). Vous pouvez également passer explicitement les valeurs de configuration à la ligne de commande, ce qui est utile dans certaines situations, par exemple si vous utilisez SLURM.

Mais dans la plupart des cas, vous devez toujours exécuter [`accelerate config`](package_reference/cli#accelerate-config) en premier pour aider Accelerate à prendre en compte votre configuration d'entraînement.

```bash
accelerate config
```

La commande [`accelerate config`](package_reference/cli#accelerate-config) crée et enregistre un fichier default_config.yaml dans le dossier de cache d'Accelerate. Ce fichier stocke la configuration de votre environnement d'entraînement, ce qui permet à Accelerate de lancer correctement votre script d'entraînement en fonction de votre machine.

Une fois votre environnement configuré, vous pouvez tester votre installation avec [`accelerate test`](package_reference/cli#accelerate-test), qui lance un court script pour tester l'environnement distribué.

```bash
accelerate test
```

> [!TIP]
> Ajoutez `--config_file` à la commande `accelerate test` ou `accelerate launch` pour spécifier l’emplacement du fichier de configuration s’il est enregistré dans un emplacement non par défaut, comme le cache.

Une fois votre environnement configuré, lancez votre script d’entraînement avec [`accelerate launch`](package_reference/cli#accelerate-launch) !

```bash
accelerate launch path_to_script.py --args_for_the_script
```

Pour en savoir plus, consultez le tutoriel [Lancer du code distribué](basic_tutorials/launch) pour obtenir plus d'informations sur le lancement de vos scripts.

Nous disposons également d'un [zoo de configurations](https://github.com/huggingface/accelerate/blob/main/examples/config_yaml_templates) qui présente un certain nombre de configurations d'exemples **minimales** préconçues pour divers scénarios que vous pouvez exécuter.

## Adapter le code d’entraînement

La principale fonctionnalité suivante d'Accelerate est la classe [Accelerator](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator), qui adapte votre code PyTorch pour l'exécuter sur différentes configurations distribuées.

Il suffit d’ajouter quelques lignes de code à votre script d’entraînement pour lui permettre de s’exécuter sur plusieurs GPU ou TPU.

```diff
+ from accelerate import Accelerator
+ accelerator = Accelerator()

+ device = accelerator.device
+ model, optimizer, training_dataloader, scheduler = accelerator.prepare(
+     model, optimizer, training_dataloader, scheduler
+ )

  for batch in training_dataloader:
      optimizer.zero_grad()
      inputs, targets = batch
-     inputs = inputs.to(device)
-     targets = targets.to(device)
      outputs = model(inputs)
      loss = loss_function(outputs, targets)
+     accelerator.backward(loss)
      optimizer.step()
      scheduler.step()
```

1. Importez et instanciez la classe [Accelerator](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator) au début de votre script d’entraînement. La classe [Accelerator](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator) initialise tout ce qui est nécessaire pour l’entraînement distribué et détecte automatiquement votre environnement d’entraînement (une machine avec un GPU, une machine avec plusieurs GPU, plusieurs machines avec plusieurs GPU ou un TPU, etc.) en fonction de la manière dont le code a été lancé.

```python
from accelerate import Accelerator

accelerator = Accelerator()
```

2. Supprimez les appels de la forme `.cuda()` sur votre modèle et vos données d’entrée. La classe [Accelerator](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator) place automatiquement ces objets sur l’appareil approprié pour vous.

> [!WARNING]
> Cette étape est *facultative*, mais il est considéré comme une bonne pratique de laisser Accelerate gérer le placement sur les dispositifs. Vous pouvez également désactiver le placement automatique des dispositifs en passant `device_placement=False` lors de l’initialisation de [Accelerator](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator). Si vous souhaitez placer explicitement des objets sur un dispositif avec `.to(device)`, assurez-vous d’utiliser `accelerator.device` à la place. Par exemple, si vous créez un optimiseur avant de placer un modèle sur `accelerator.device`, l’entraînement échoue sur un TPU.

> [!WARNING]
> Accelerate n’utilise pas de transferts non bloquants par défaut pour son placement automatique des appareils, ce qui peut entraîner des synchronisations CUDA potentiellement indésirables. Vous pouvez activer les transferts non bloquants en passant un [DataLoaderConfiguration](/docs/accelerate/main/fr/package_reference/utilities#accelerate.DataLoaderConfiguration) avec `non_blocking=True` défini comme `dataloader_config` lors de l’initialisation de [Accelerator](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator). Comme d’habitude, les transferts non bloquants ne fonctionneront que si le dataloader a également `pin_memory=True` défini. Soyez prudent : l’utilisation de transferts non bloquants de la GPU vers le CPU peut entraîner des résultats incorrects si cela provoque l’exécution d’opérations CPU sur des tenseurs non prêts.

```py
device = accelerator.device
```

3. Transmettez tous les objets PyTorch pertinents pour l’entraînement (optimiseur, modèle, chargeur(s) de données, planificateur de taux d’apprentissage) à la méthode [prepare()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.prepare) dès leur création. Cette méthode enveloppe le modèle dans un conteneur optimisé pour votre configuration distribuée, utilise la version d’Accelerate de l’optimiseur et du planificateur, et crée une version fragmentée de votre chargeur de données pour la distribution sur les GPU ou TPU.

```python
model, optimizer, train_dataloader, lr_scheduler = accelerator.prepare(
    model, optimizer, train_dataloader, lr_scheduler
)
```

4. Remplacez `loss.backward()` par [backward()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.backward) pour utiliser la méthode `backward()` correcte pour votre configuration d'entraînement.

```py
accelerator.backward(loss)
```

Lisez le guide [mécanismes internes d’Accelerate](concept_guides/internal_mechanism) pour en savoir plus sur la façon dont Accelerate adapte votre code.

### Évaluation distribuée

Pour effectuer une évaluation distribuée, passez votre dataloader de validation à la méthode [prepare()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.prepare) :

```python
validation_dataloader = accelerator.prepare(validation_dataloader)
```

Chaque appareil de votre configuration distribuée ne reçoit qu'une partie des données d'évaluation, ce qui signifie que vous devez regrouper vos prédictions à l'aide de la méthode [gather_for_metrics()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.gather_for_metrics). Cette méthode exige que tous les tenseurs aient la même taille sur chaque processus. Par conséquent, si vos tenseurs ont des tailles différentes sur chaque processus (par exemple lors d'un bourrage dynamique jusqu'à la longueur maximale d'un lot), vous devez utiliser la méthode [pad_across_processes()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.pad_across_processes) pour bourrer votre tenseur jusqu'à la plus grande taille entre les processus. Notez que les tenseurs doivent être 1D et que nous concaténons les tenseurs le long de la première dimension.

```python
for inputs, targets in validation_dataloader:
    predictions = model(inputs)
    # Gather all predictions and targets
    all_predictions, all_targets = accelerator.gather_for_metrics((predictions, targets))
    # Example of use with a *Datasets.Metric*
    metric.add_batch(all_predictions, all_targets)
```

Pour des cas plus complexes (par exemple des tenseurs 2D, l’absence de concaténation de tenseurs, un dictionnaire de tenseurs 3D), vous pouvez passer `use_gather_object=True` dans `gather_for_metrics`. Cela renverra la liste des objets après la collecte. Notez que son utilisation avec des tenseurs GPU n’est pas bien prise en charge et est inefficace.

> [!TIP]
> Les données à la fin d'un jeu de données peuvent être dupliquées afin que le lot puisse être divisé également entre tous les travailleurs. La méthode [gather_for_metrics()](/docs/accelerate/main/fr/package_reference/accelerator#accelerate.Accelerator.gather_for_metrics) supprime automatiquement les données dupliquées pour calculer une métrique plus précise.

## Inférence de grands modèles

L’inférence de grands modèles d’Accelerate dispose de deux fonctionnalités principales, [init_empty_weights()](/docs/accelerate/main/fr/package_reference/big_modeling#accelerate.init_empty_weights) et [load_checkpoint_and_dispatch()](/docs/accelerate/main/fr/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch), pour charger de grands modèles destinés à l’inférence qui ne tiennent généralement pas en mémoire.

> [!TIP]
> Consultez le guide [Gestion des grands modèles pour l'inférence](concept_guides/big_model_inference) pour mieux comprendre le fonctionnement de Big Model Inference en profondeur.

### Initialisation des poids vides

Le gestionnaire de contexte [init_empty_weights()](/docs/accelerate/main/fr/package_reference/big_modeling#accelerate.init_empty_weights) initialise des modèles de toute taille en créant un *squelette de modèle* et en déplaçant et en plaçant les paramètres au fur et à mesure de leur création sur l'appareil [**meta**](https://pytorch.org/docs/main/meta.html) de PyTorch. Ainsi, tous les poids ne sont pas chargés immédiatement et seule une petite partie du modèle est chargée en mémoire à la fois.

Par exemple, charger un modèle [Mixtral-8x7B](https://huggingface.co/mistralai/Mixtral-8x7B-Instruct-v0.1) vide requiert nettement moins de mémoire que de charger entièrement les modèles et les poids sur le CPU.

```py
from accelerate import init_empty_weights
from transformers import AutoConfig, AutoModelForCausalLM

config = AutoConfig.from_pretrained("mistralai/Mixtral-8x7B-Instruct-v0.1")
with init_empty_weights():
    model = AutoModelForCausalLM.from_config(config)
```

### Charger et distribuer les poids

La fonction [load_checkpoint_and_dispatch()](/docs/accelerate/main/fr/package_reference/big_modeling#accelerate.load_checkpoint_and_dispatch) charge les points de contrôle complets ou fractionnés dans le modèle vide et distribue automatiquement les poids sur tous les appareils disponibles.

Le paramètre `device_map` détermine l'emplacement de chaque couche du modèle. Spécifier `"auto"` les place d'abord sur le GPU, puis sur le CPU, et enfin sur le disque dur sous forme de tenseurs mappés en mémoire s'il reste insuffisamment de mémoire. Utilisez le paramètre `no_split_module_classes` pour indiquer quels modules ne doivent pas être répartis sur plusieurs appareils (généralement ceux possédant une connexion résiduelle).

```py
from accelerate import load_checkpoint_and_dispatch

model_checkpoint = "your-local-model-folder"
model = load_checkpoint_and_dispatch(
    model, checkpoint=model_checkpoint, device_map="auto", no_split_module_classes=['Block']
)
```

## Étapes suivantes

Maintenant que vous avez été initié aux fonctionnalités principales d'Accelerate, vos prochaines étapes pourraient inclure :

* Consultez les [tutoriels](basic_tutorials/overview) pour une introduction progressive à Accelerate. C'est particulièrement utile si vous débutez avec l'entraînement distribué et la bibliothèque.
* Plongez dans les [guides](usage_guides/explore) pour découvrir comment utiliser Accelerate pour des cas d'usage spécifiques.
* Approfondissez votre compréhension conceptuelle du fonctionnement interne d'Accelerate en lisant les [guides conceptuels](concept_guides/internal_mechanism).
* Consultez les classes et les commandes dans la [référence de l’API](package_reference/accelerator) pour voir les paramètres et les options disponibles.

