Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Formation distribuée avec la bibliothèque de parallélisme de données distribué basée sur l' SageMaker IA
<a name="data-parallel-modify-sdp"></a>

La bibliothèque de parallélisme distribué des données (SMDDP) basée sur l' SageMaker IA est conçue pour être facile à utiliser et pour permettre une intégration parfaite avec. PyTorch

Lorsque vous entraînez un modèle d'apprentissage profond à l'aide de la bibliothèque SMDDP sur l' SageMaker IA, vous pouvez vous concentrer sur la rédaction de votre script de formation et sur l'entraînement du modèle. 

Pour commencer, importez la bibliothèque SMDDP afin d’utiliser ses opérations collectives optimisées pour AWS. Les rubriques suivantes fournissent des instructions sur les éléments à ajouter à votre script d’entraînement en fonction de l’opération collective que vous souhaitez optimiser.

**Topics**
+ [Adaptation de votre script d’entraînement pour utiliser les opérations collectives SMDDP](data-parallel-modify-sdp-select-framework.md)
+ [Lancement de tâches de formation distribuées avec SMDDP à l'aide du SDK Python SageMaker](data-parallel-use-api.md)

# Adaptation de votre script d’entraînement pour utiliser les opérations collectives SMDDP
<a name="data-parallel-modify-sdp-select-framework"></a>

Les exemples de scripts d'entraînement fournis dans cette section sont simplifiés et ne mettent en évidence que les modifications nécessaires pour activer la bibliothèque de parallélisme distribué des données (SMDDP) SageMaker AI dans votre script de formation. Pour des exemples de end-to-end blocs-notes Jupyter qui montrent comment exécuter une tâche de formation distribuée avec la bibliothèque SMDDP, voir. [Exemples de bibliothèques de parallélisme de données Amazon SageMaker AI](distributed-data-parallel-v2-examples.md)

**Topics**
+ [Utilisez la bibliothèque SMDDP dans votre script d'entraînement PyTorch](data-parallel-modify-sdp-pt.md)
+ [Utiliser la bibliothèque SMDDP dans votre script d'entraînement PyTorch Lightning](data-parallel-modify-sdp-pt-lightning.md)
+ [Utiliser la bibliothèque SMDDP dans votre script d' TensorFlow entraînement (obsolète)](data-parallel-modify-sdp-tf2.md)

# Utilisez la bibliothèque SMDDP dans votre script d'entraînement PyTorch
<a name="data-parallel-modify-sdp-pt"></a>

[À partir de la bibliothèque SageMaker AI Distributed Data Parallelism (SMDDP) v1.4.0, vous pouvez utiliser la bibliothèque comme option de backend pour le package distribué. PyTorch ](https://pytorch.org/tutorials/beginner/dist_overview.html) Pour utiliser le SMDDP `AllReduce` et les opérations `AllGather` collectives, il vous suffit d'importer la bibliothèque SMDDP au début de votre script de formation et de définir SMDDP comme serveur principal des modules distribués lors de l'initialisation du groupe de PyTorch processus. Avec une seule ligne de spécification du backend, vous pouvez conserver tous les modules PyTorch distribués natifs et l'intégralité du script de formation inchangés. [Les extraits de code suivants montrent comment utiliser la bibliothèque SMDDP comme backend de packages de formation distribués PyTorch basés sur la distribution : distributed [PyTorch data parallel (DDP), [PyTorch full sharded data parallelism](https://pytorch.org/docs/stable/fsdp.html) (FSDP)](https://pytorch.org/docs/stable/notes/ddp.html) et Megatron-. [DeepSpeed](https://github.com/microsoft/DeepSpeed)DeepSpeed](https://github.com/microsoft/Megatron-DeepSpeed)

## Pour PyTorch DDP ou FSDP
<a name="data-parallel-enable-for-ptddp-ptfsdp"></a>

Initialisez le groupe de processus comme suit.

```
import torch.distributed as dist
import smdistributed.dataparallel.torch.torch_smddp

dist.init_process_group(backend="smddp")
```

**Note**  
(Pour les tâches PyTorch DDP uniquement) Le `smddp` backend ne prend actuellement pas en charge la création de groupes de sous-processus avec l'API. `torch.distributed.new_group()` Vous ne pouvez pas utiliser le système dorsal `smddp` en même temps que d’autres systèmes dorsaux de groupes de processus tels que `NCCL` et `Gloo`.

## Pour DeepSpeed ou Megatron- DeepSpeed
<a name="data-parallel-enable-for-deepspeed"></a>

Initialisez le groupe de processus comme suit.

```
import deepspeed
import smdistributed.dataparallel.torch.torch_smddp

deepspeed.init_distributed(dist_backend="smddp")
```

**Note**  
Pour utiliser la fonction `AllGather` SMDDP avec les lanceurs basés sur `mpirun` (`smdistributed` et `pytorchddp`) dans [Lancement de tâches de formation distribuées avec SMDDP à l'aide du SDK Python SageMaker](data-parallel-use-api.md), vous devez également définir la variable d’environnement suivante dans votre script d’entraînement.  

```
export SMDATAPARALLEL_OPTIMIZE_SDP=true
```

Pour obtenir des conseils généraux sur la rédaction d'un script de formation PyTorch FSDP, voir [Advanced Model Training with Fully Sharded Data Parallel (FSDP](https://pytorch.org/tutorials/intermediate/FSDP_adavnced_tutorial.html)) dans la documentation. PyTorch

Pour obtenir des conseils généraux sur la rédaction d'un script de formation PyTorch DDP, consultez [Getting started with distributed data parallel](https://pytorch.org/tutorials/intermediate/ddp_tutorial.html) dans la PyTorch documentation.

Une fois que vous avez terminé d’adapter votre scénario d’entraînement, passez à [Lancement de tâches de formation distribuées avec SMDDP à l'aide du SDK Python SageMaker](data-parallel-use-api.md).

# Utiliser la bibliothèque SMDDP dans votre script d'entraînement PyTorch Lightning
<a name="data-parallel-modify-sdp-pt-lightning"></a>

Si vous souhaitez utiliser votre script d'entraînement [PyTorchLightning](https://pytorch-lightning.readthedocs.io/en/latest/starter/introduction.html) et exécuter une tâche de formation parallèle aux données distribuées dans SageMaker AI, vous pouvez exécuter la tâche de formation en modifiant le moins possible votre script de formation. Les modifications nécessaires sont les suivantes : importation des PyTorch modules de la `smdistributed.dataparallel` bibliothèque, configuration des variables d'environnement pour que PyTorch Lightning accepte les variables d'environnement SageMaker IA prédéfinies par le kit de SageMaker formation, et activation de la bibliothèque SMDDP en configurant le backend du groupe de processus sur. `"smddp"` Pour en savoir plus, suivez les instructions ci-dessous qui décomposent les étapes avec des exemples de code.

**Note**  
Le support PyTorch Lightning est disponible dans la bibliothèque SageMaker AI data parallel v1.5.0 et versions ultérieures.

## PyTorch Lightning == v2.1.0 et PyTorch == 2.0.1
<a name="smddp-pt-201-lightning-210"></a>

1. Importez la bibliothèque `pytorch_lightning` et les modules `smdistributed.dataparallel.torch`.

   ```
   import lightning as pl
   import smdistributed.dataparallel.torch.torch_smddp
   ```

1. Instanciez le. [LightningEnvironment](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.plugins.environments.LightningEnvironment.html)

   ```
   from lightning.fabric.plugins.environments.lightning import LightningEnvironment
   
   env = LightningEnvironment()
   env.world_size = lambda: int(os.environ["WORLD_SIZE"])
   env.global_rank = lambda: int(os.environ["RANK"])
   ```

1. **Pour PyTorch DDP** : créez un objet de la [DDPStrategy](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.strategies.DDPStrategy.html)classe avec `"smddp"` pour `process_group_backend` et `"gpu"` pour`accelerator`, et transmettez-le à la classe [Trainer](https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html).

   ```
   import lightning as pl
   from lightning.pytorch.strategies import DDPStrategy
   
   ddp = DDPStrategy(
       cluster_environment=env, 
       process_group_backend="smddp", 
       accelerator="gpu"
   )
   
   trainer = pl.Trainer(
       max_epochs=200, 
       strategy=ddp, 
       devices=num_gpus, 
       num_nodes=num_nodes
   )
   ```

   **Pour le PyTorch FSDP** : créez un objet de la [FSDPStrategy](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.strategies.FSDPStrategy.html)classe (avec la [politique d'encapsulage](https://pytorch.org/docs/stable/fsdp.html) de votre choix) avec `"smddp"` for `process_group_backend` et `"gpu"` for`accelerator`, et transmettez-le à la classe [Trainer](https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html).

   ```
   import lightning as pl
   from lightning.pytorch.strategies import FSDPStrategy
   
   from functools import partial
   from torch.distributed.fsdp.wrap import size_based_auto_wrap_policy
   
   policy = partial(
       size_based_auto_wrap_policy, 
       min_num_params=10000
   )
   
   fsdp = FSDPStrategy(
       auto_wrap_policy=policy,
       process_group_backend="smddp", 
       cluster_environment=env
   )
   
   trainer = pl.Trainer(
       max_epochs=200, 
       strategy=fsdp, 
       devices=num_gpus, 
       num_nodes=num_nodes
   )
   ```

Une fois que vous avez terminé d’adapter votre scénario d’entraînement, passez à [Lancement de tâches de formation distribuées avec SMDDP à l'aide du SDK Python SageMaker](data-parallel-use-api.md). 

**Note**  
Lorsque vous créez un PyTorch estimateur d' SageMaker IA et que vous soumettez une demande de formation dans[Lancement de tâches de formation distribuées avec SMDDP à l'aide du SDK Python SageMaker](data-parallel-use-api.md), vous devez fournir l'installation `pytorch-lightning` et l'`requirements.txt`inclure `lightning-bolts` dans le conteneur de PyTorch formation SageMaker AI.  

```
# requirements.txt
pytorch-lightning
lightning-bolts
```
Pour plus d'informations sur la spécification du répertoire source dans lequel placer le `requirements.txt` fichier avec votre script d'entraînement et la soumission d'une tâche, consultez la section [Utilisation de bibliothèques tierces](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) dans la *documentation du SDK Amazon SageMaker AI Python*.

# Utiliser la bibliothèque SMDDP dans votre script d' TensorFlow entraînement (obsolète)
<a name="data-parallel-modify-sdp-tf2"></a>

**Important**  
La bibliothèque SMDDP a cessé de prendre en charge TensorFlow et n'est plus disponible DLCs depuis la TensorFlow version 2.11.0. Pour trouver la version précédente TensorFlow DLCs avec la bibliothèque SMDDP installée, voir. [Cadres pris en charge](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks)

Les étapes suivantes vous montrent comment modifier un script d' TensorFlow entraînement pour utiliser la bibliothèque de données parallèles distribuées d' SageMaker AI.  

La bibliothèque APIs est conçue pour être similaire à Horovod APIs. Pour plus de détails sur chaque API proposée par la bibliothèque TensorFlow, consultez la [documentation de l' TensorFlow API SageMaker AI distributed data parallel](https://sagemaker.readthedocs.io/en/stable/api/training/smd_data_parallel.html#api-documentation).

**Note**  
SageMaker AI distributed data parallel est adaptable aux scripts de TensorFlow formation composés de modules de `tf` base, à l'exception `tf.keras` des modules. SageMaker AI distributed data parallel n'est pas compatible TensorFlow avec l'implémentation de Keras.

**Note**  
La bibliothèque de parallélisme de données distribué basée sur l' SageMaker IA prend en charge la précision mixte automatique (AMP) prête à l'emploi. Pour activer l'AMP, il vous suffit de modifier le cadre de votre script d'entraînement. Si des dégradés sont présents FP16, la bibliothèque de parallélisme de données SageMaker AI exécute ses `AllReduce` opérations dans. FP16 Pour plus d'informations sur l'implémentation APIs de l'AMP dans votre script d'entraînement, consultez les ressources suivantes :  
[Frameworks : TensorFlow](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#tensorflow) dans la *documentation sur les performances du Deep Learning de NVIDIA*
[Précision mixte automatique pour deep learning](https://developer.nvidia.com/automatic-mixed-precision) dans les *Documents du développeur NVIDIA*
[TensorFlow précision mitigée APIs](https://www.tensorflow.org/guide/mixed_precision) dans la *TensorFlowdocumentation*

1. Importez le TensorFlow client de la bibliothèque et initialisez-le.

   ```
   import smdistributed.dataparallel.tensorflow as sdp 
   sdp.init()
   ```

1. Épinglez chaque GPU à un processus `smdistributed.dataparallel` unique avec `local_rank` : cela fait référence au rang relatif du processus au sein d'un nœud donné. L’API `sdp.tensorflow.local_rank()` vous indique le rang local du dispositif. Le nœud principal est le rang 0, et les nœuds des employés sont les rangs 1, 2, 3, etc. Ceci est invoqué dans le bloc de code suivant en tant que`sdp.local_rank()`. `set_memory_growth`n'est pas directement lié à l' SageMaker IA distribuée, mais doit être configuré pour une formation distribuée avec TensorFlow. 

   ```
   gpus = tf.config.experimental.list_physical_devices('GPU')
   for gpu in gpus:
       tf.config.experimental.set_memory_growth(gpu, True)
   if gpus:
       tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], 'GPU')
   ```

1. Mettez à l'échelle le taux d'apprentissage en fonction du nombre d'employés. L'API `sdp.tensorflow.size()` vous indique le nombre d'employés dans le cluster. Cela est appelé sous `sdp.size()` dans le bloc de code suivant. 

   ```
   learning_rate = learning_rate * sdp.size()
   ```

1. Utilisez le `DistributedGradientTape` de la bibliothèque pour optimiser les opérations `AllReduce` pendant l'entraînement. Cela recouvre `tf.GradientTape`.  

   ```
   with tf.GradientTape() as tape:
         output = model(input)
         loss_value = loss(label, output)
       
   # SageMaker AI data parallel: Wrap tf.GradientTape with the library's DistributedGradientTape
   tape = sdp.DistributedGradientTape(tape)
   ```

1. Diffusez les variables initiales du modèle, du nœud principal (rang 0) vers tous les nœuds d'employés (rangs 1 à n). Cela est indispensable pour garantir une initialisation cohérente dans tous les rangs des employés. Utilisez l'API `sdp.tensorflow.broadcast_variables` après l'initialisation des variables du modèle et de l'optimiseur. Ceci est invoqué dans le bloc de code suivant comme `sdp.broadcast_variables()`. 

   ```
   sdp.broadcast_variables(model.variables, root_rank=0)
   sdp.broadcast_variables(opt.variables(), root_rank=0)
   ```

1. Enfin, modifiez votre script de sorte à enregistrer les points de contrôle sur le nœud principal uniquement. Le nœud principal a un modèle synchronisé. Cela évite également que les nœuds d'employés écrasent les points de contrôle et les endommagent éventuellement. 

   ```
   if sdp.rank() == 0:
       checkpoint.save(checkpoint_dir)
   ```

Voici un exemple de script d' TensorFlow entraînement pour un entraînement distribué avec la bibliothèque.

```
import tensorflow as tf

# SageMaker AI data parallel: Import the library TF API
import smdistributed.dataparallel.tensorflow as sdp

# SageMaker AI data parallel: Initialize the library
sdp.init()

gpus = tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus:
    tf.config.experimental.set_memory_growth(gpu, True)
if gpus:
    # SageMaker AI data parallel: Pin GPUs to a single library process
    tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], 'GPU')

# Prepare Dataset
dataset = tf.data.Dataset.from_tensor_slices(...)

# Define Model
mnist_model = tf.keras.Sequential(...)
loss = tf.losses.SparseCategoricalCrossentropy()

# SageMaker AI data parallel: Scale Learning Rate
# LR for 8 node run : 0.000125
# LR for single node run : 0.001
opt = tf.optimizers.Adam(0.000125 * sdp.size())

@tf.function
def training_step(images, labels, first_batch):
    with tf.GradientTape() as tape:
        probs = mnist_model(images, training=True)
        loss_value = loss(labels, probs)

    # SageMaker AI data parallel: Wrap tf.GradientTape with the library's DistributedGradientTape
    tape = sdp.DistributedGradientTape(tape)

    grads = tape.gradient(loss_value, mnist_model.trainable_variables)
    opt.apply_gradients(zip(grads, mnist_model.trainable_variables))

    if first_batch:
       # SageMaker AI data parallel: Broadcast model and optimizer variables
       sdp.broadcast_variables(mnist_model.variables, root_rank=0)
       sdp.broadcast_variables(opt.variables(), root_rank=0)

    return loss_value

...

# SageMaker AI data parallel: Save checkpoints only from master node.
if sdp.rank() == 0:
    checkpoint.save(checkpoint_dir)
```

Une fois que vous avez terminé d'adapter votre scénario d'entraînement, passez à [Lancement de tâches de formation distribuées avec SMDDP à l'aide du SDK Python SageMaker](data-parallel-use-api.md). 

# Lancement de tâches de formation distribuées avec SMDDP à l'aide du SDK Python SageMaker
<a name="data-parallel-use-api"></a>

Pour exécuter une tâche de formation distribuée avec votre script adapté depuis[Adaptation de votre script d’entraînement pour utiliser les opérations collectives SMDDP](data-parallel-modify-sdp-select-framework.md), utilisez le framework du SDK SageMaker Python ou des estimateurs génériques en spécifiant le script d'entraînement préparé comme script de point d'entrée et la configuration d'entraînement distribuée.

Cette page explique comment utiliser le [SDK SageMaker AI Python](https://sagemaker.readthedocs.io/en/stable/api/training/index.html) de deux manières.
+ Si vous souhaitez adopter rapidement votre tâche de formation distribuée en SageMaker IA, configurez une classe d' SageMaker estimateurs d'IA [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch)ou de [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)framework. L'estimateur du framework sélectionne votre script d'entraînement et fait automatiquement correspondre l'URI d'image correcte des Deep Learning Containers (DLC) [prédéfinis PyTorch ou des TensorFlow Deep Learning Containers (DLC)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only), en fonction de la valeur spécifiée pour le paramètre. `framework_version`
+ Si vous souhaitez étendre l'un des conteneurs prédéfinis ou créer un conteneur personnalisé pour créer votre propre environnement ML avec l' SageMaker IA, utilisez la `Estimator` classe générique SageMaker AI et spécifiez l'URI de l'image du conteneur Docker personnalisé hébergé dans votre Amazon Elastic Container Registry (Amazon ECR).

Vos ensembles de données de formation doivent être stockés dans [Amazon S3 ou Amazon FSx for Lustre](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html) Région AWS dans lequel vous lancez votre formation. Si vous utilisez des blocs-notes Jupyter, vous devez disposer d'une instance de SageMaker bloc-notes ou d'une application SageMaker Studio Classic exécutée dans le même bloc-notes. Région AWS Pour plus d'informations sur le stockage de vos données d'entraînement, consultez la documentation sur les [entrées de données du SDK SageMaker Python](https://sagemaker.readthedocs.io/en/stable/overview.html#use-file-systems-as-training-input). 

**Astuce**  
Nous vous recommandons d'utiliser Amazon FSx for Lustre au lieu d'Amazon S3 afin d'améliorer les performances de formation. Amazon FSx offre un débit plus élevé et une latence plus faible qu'Amazon S3.

**Astuce**  
Pour que vous puissiez exécuter correctement un entraînement distribué sur les types d’instances compatibles EFA, vous devez activer le trafic entre les instances en configurant le groupe de sécurité de votre VPC afin d’autoriser tout le trafic entrant et sortant vers et depuis le groupe de sécurité proprement dit. Pour découvrir comment configurer les règles du groupe de sécurité, consultez [Étape 1 : Préparer un groupe de sécurité activé pour les EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security) dans le *Guide de l’utilisateur Amazon EC2*.

Sélectionnez l’une des rubriques suivantes pour obtenir des instructions sur la manière d’exécuter une tâche d’entraînement distribué de votre script d’entraînement. Après avoir lancé une tâche de formation, vous pouvez surveiller l'utilisation du système et les performances des modèles à l'aide [SageMaker Débogueur Amazon](train-debugger.md) d'Amazon CloudWatch.

En plus de suivre les instructions des rubriques suivantes pour en savoir plus sur les détails techniques, nous vous recommandons de consulter les [Exemples de bibliothèques de parallélisme de données Amazon SageMaker AI](distributed-data-parallel-v2-examples.md) pour démarrer.

**Topics**
+ [Utiliser les estimateurs du PyTorch framework dans le SDK Python SageMaker](data-parallel-framework-estimator.md)
+ [Utilisez l'estimateur générique basé sur l' SageMaker IA pour étendre les conteneurs DLC prédéfinis](data-parallel-use-python-skd-api.md)
+ [Créez votre propre conteneur Docker avec la bibliothèque SageMaker AI distributed data parallel library](data-parallel-bring-your-own-container.md)

# Utiliser les estimateurs du PyTorch framework dans le SDK Python SageMaker
<a name="data-parallel-framework-estimator"></a>

Vous pouvez lancer une formation distribuée en ajoutant l'`distribution`argument aux estimateurs du framework d' SageMaker IA, [https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch)ou. [https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator) Pour plus de détails, choisissez l'un des frameworks pris en charge par la bibliothèque SageMaker AI Distributed Data Parallelism (SMDDP) parmi les sélections suivantes.

------
#### [ PyTorch ]

Les options de lancement suivantes sont disponibles pour lancer une formation PyTorch distribuée.
+ `pytorchddp`— Cette option exécute `mpirun` et configure les variables d'environnement nécessaires à l'exécution de formations PyTorch distribuées sur l' SageMaker IA. Pour utiliser cette option, transmettez le dictionnaire suivant au paramètre `distribution`.

  ```
  { "pytorchddp": { "enabled": True } }
  ```
+ `torch_distributed`— Cette option exécute `torchrun` et configure les variables d'environnement nécessaires à l'exécution de formations PyTorch distribuées sur l' SageMaker IA. Pour utiliser cette option, transmettez le dictionnaire suivant au paramètre `distribution`.

  ```
  { "torch_distributed": { "enabled": True } }
  ```
+ `smdistributed`— Cette option fonctionne également`mpirun`, mais elle permet de `smddprun` configurer les variables d'environnement nécessaires à l'exécution d'une formation PyTorch distribuée sur l' SageMaker IA.

  ```
  { "smdistributed": { "dataparallel": { "enabled": True } } }
  ```

Si vous avez choisi de remplacer la fonction `AllGather` NCCL par la fonction `AllGather` SMDDP, vous pouvez utiliser les trois options. Choisissez une option qui correspond à votre cas d’utilisation.

Si vous avez choisi de remplacer la fonction `AllReduce` NCCL par la fonction `AllReduce` SMDDP, vous devez choisir l’une des options basées sur `mpirun` suivantes : `smdistributed` ou `pytorchddp`. Vous pouvez également ajouter d’autres options MPI comme suit.

```
{ 
    "pytorchddp": {
        "enabled": True, 
        "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION"
    }
}
```

```
{ 
    "smdistributed": { 
        "dataparallel": {
            "enabled": True, 
            "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION"
        }
    }
}
```

L'exemple de code suivant montre la structure de base d'un PyTorch estimateur avec des options d'entraînement distribuées.

```
from sagemaker.pytorch import PyTorch

pt_estimator = PyTorch(
    base_job_name="training_job_name_prefix",
    source_dir="subdirectory-to-your-code",
    entry_point="adapted-training-script.py",
    role="SageMakerRole",
    py_version="py310",
    framework_version="2.0.1",

    # For running a multi-node distributed training job, specify a value greater than 1
    # Example: 2,3,4,..8
    instance_count=2,

    # Instance types supported by the SageMaker AI data parallel library: 
    # ml.p4d.24xlarge, ml.p4de.24xlarge
    instance_type="ml.p4d.24xlarge",

    # Activate distributed training with SMDDP
    distribution={ "pytorchddp": { "enabled": True } }  # mpirun, activates SMDDP AllReduce OR AllGather
    # distribution={ "torch_distributed": { "enabled": True } }  # torchrun, activates SMDDP AllGather
    # distribution={ "smdistributed": { "dataparallel": { "enabled": True } } }  # mpirun, activates SMDDP AllReduce OR AllGather
)

pt_estimator.fit("s3://bucket/path/to/training/data")
```

**Note**  
PyTorch Lightning et ses bibliothèques d'utilitaires, telles que Lightning Bolts, ne sont pas préinstallés dans l' SageMaker IA PyTorch DLCs. Créez le fichier `requirements.txt` suivant et enregistrez-le dans le répertoire source où vous enregistrez le script d’entraînement.  

```
# requirements.txt
pytorch-lightning
lightning-bolts
```
Par exemple, le répertoire de type arborescence doit être similaire à ce qui suit.  

```
├── pytorch_training_launcher_jupyter_notebook.ipynb
└── sub-folder-for-your-code
    ├──  adapted-training-script.py
    └──  requirements.txt
```
Pour plus d'informations sur la spécification du répertoire source dans lequel placer le `requirements.txt` fichier avec votre script d'entraînement et la soumission d'une tâche, consultez la section [Utilisation de bibliothèques tierces](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) dans la *documentation du SDK Amazon SageMaker AI Python*.

**Considérations relatives à l’activation des opérations collectives SMDDP et à l’utilisation des bonnes options de lanceur d’entraînement distribué**
+ Les fonctions `AllReduce` et `AllGather` SMDDP ne sont actuellement pas compatibles entre elles.
+ La fonction `AllReduce` SMDDP est activée par défaut lors de l’utilisation de `smdistributed` ou de `pytorchddp`, qui sont des lanceurs basés sur `mpirun`, et la fonction `AllGather` NCCL est utilisée.
+ La fonction `AllGather` SMDDP est activée par défaut lors de l’utilisation du lanceur `torch_distributed` et `AllReduce` revient vers NCCL.
+ La fonction `AllGather` SMDDP peut également être activée lors de l’utilisation des lanceurs basés sur `mpirun` avec une variable d’environnement supplémentaire définie comme suit.

  ```
  export SMDATAPARALLEL_OPTIMIZE_SDP=true
  ```

------
#### [ TensorFlow ]

**Important**  
La bibliothèque SMDDP a cessé de prendre en charge TensorFlow et n'est plus disponible DLCs depuis la TensorFlow version 2.11.0. Pour trouver la version précédente TensorFlow DLCs avec la bibliothèque SMDDP installée, voir. [TensorFlow (obsolète)](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks-tensorflow)

```
from sagemaker.tensorflow import TensorFlow

tf_estimator = TensorFlow(
    base_job_name = "training_job_name_prefix",
    entry_point="adapted-training-script.py",
    role="SageMakerRole",
    framework_version="2.11.0",
    py_version="py38",

    # For running a multi-node distributed training job, specify a value greater than 1
    # Example: 2,3,4,..8
    instance_count=2,

    # Instance types supported by the SageMaker AI data parallel library: 
    # ml.p4d.24xlarge, ml.p3dn.24xlarge, and ml.p3.16xlarge
    instance_type="ml.p3.16xlarge",

    # Training using the SageMaker AI data parallel distributed training strategy
    distribution={ "smdistributed": { "dataparallel": { "enabled": True } } }
)

tf_estimator.fit("s3://bucket/path/to/training/data")
```

------

# Utilisez l'estimateur générique basé sur l' SageMaker IA pour étendre les conteneurs DLC prédéfinis
<a name="data-parallel-use-python-skd-api"></a>

Vous pouvez personnaliser les conteneurs SageMaker IA prédéfinis ou les étendre pour répondre aux exigences fonctionnelles supplémentaires de votre algorithme ou modèle que l'image SageMaker AI Docker prédéfinie ne prend pas en charge. Pour apprendre comment étendre un conteneur précréé, consultez [Étendre un conteneur précréé](https://docs.aws.amazon.com/sagemaker/latest/dg/prebuilt-containers-extend.html).

Pour étendre un conteneur prédéfini ou adapter votre propre conteneur à l’utilisation de la bibliothèque, vous devez utiliser l’une des images répertoriées dans [Cadres pris en charge](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks).

**Note**  
À partir des TensorFlow versions 2.4.1 et PyTorch 1.8.1, le framework SageMaker AI DLCs prend en charge les types d'instances compatibles EFA. Nous vous recommandons d'utiliser les images du DLC contenant la TensorFlow version 2.4.1 ou ultérieure et la version PyTorch 1.8.1 ou ultérieure. 

Par exemple, si vous utilisez PyTorch, votre Dockerfile doit contenir une `FROM` instruction similaire à la suivante :

```
# SageMaker AI PyTorch image
FROM 763104351884.dkr.ecr.<aws-region>.amazonaws.com/pytorch-training:<image-tag>

ENV PATH="/opt/ml/code:${PATH}"

# this environment variable is used by the SageMaker AI PyTorch container to determine our user code directory.
ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code

# /opt/ml and all subdirectories are utilized by SageMaker AI, use the /code subdirectory to store your user code.
COPY train.py /opt/ml/code/train.py

# Defines cifar10.py as script entrypoint
ENV SAGEMAKER_PROGRAM train.py
```

Vous pouvez personnaliser davantage votre propre conteneur Docker pour qu'il fonctionne avec l' SageMaker IA à l'aide de la [boîte à outils de SageMaker formation](https://github.com/aws/sagemaker-training-toolkit) et du fichier binaire de la bibliothèque SageMaker AI distributed data parallel library. Pour plus d’informations, consultez les instructions de la section suivante.

# Créez votre propre conteneur Docker avec la bibliothèque SageMaker AI distributed data parallel library
<a name="data-parallel-bring-your-own-container"></a>

Pour créer votre propre conteneur Docker à des fins de formation et utiliser la bibliothèque parallèle de données SageMaker AI, vous devez inclure les dépendances correctes et les fichiers binaires des bibliothèques parallèles distribuées par SageMaker IA dans votre Dockerfile. Cette section fournit des instructions sur la façon de créer un Dockerfile complet avec le minimum de dépendances pour l'entraînement distribué en SageMaker IA à l'aide de la bibliothèque data parallel.

**Note**  
Cette option Docker personnalisée avec la bibliothèque SageMaker AI data parallel sous forme binaire n'est disponible que pour PyTorch.

**Pour créer un Dockerfile avec le kit de SageMaker formation et la bibliothèque Data Parallel**

1. Commencez par une image Docker à partir de [NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). [Utilisez les versions pour développeurs de cuDNN qui contiennent les outils d'exécution et de développement CUDA (en-têtes et bibliothèques) pour créer à partir du code source. PyTorch ](https://github.com/pytorch/pytorch#from-source)

   ```
   FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04
   ```
**Astuce**  
Les images officielles du AWS Deep Learning Container (DLC) sont créées à partir des images de [base NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). Si vous souhaitez utiliser les images DLC prédéfinies comme références tout en suivant le reste des instructions, consultez les [AWS Deep Learning Containers for PyTorch ](https://github.com/aws/deep-learning-containers/tree/master/pytorch) Dockerfiles. 

1. Ajoutez les arguments suivants pour spécifier les versions de PyTorch et d'autres packages. Indiquez également les chemins des compartiments Amazon S3 menant à la bibliothèque SageMaker AI data parallel et à d'autres logiciels pour utiliser les AWS ressources, tels que le plug-in Amazon S3. 

   Pour utiliser des versions de bibliothèques tierces autres que celles fournies dans l'exemple de code suivant, nous vous recommandons de consulter les [Dockerfiles officiels de AWS Deep Learning Container PyTorch pour](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker) trouver les versions testées, compatibles et adaptées à votre application. 

    URLs Pour rechercher l'`SMDATAPARALLEL_BINARY`argument, consultez les tables de recherche à l'adresse[Cadres pris en charge](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks).

   ```
   ARG PYTORCH_VERSION=1.10.2
   ARG PYTHON_SHORT_VERSION=3.8
   ARG EFA_VERSION=1.14.1
   ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/${PYTORCH_VERSION}/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl
   ARG PT_S3_WHL_GPU=https://aws-s3-plugin.s3.us-west-2.amazonaws.com/binaries/0.0.1/1c3e69e/awsio-0.0.1-cp38-cp38-manylinux1_x86_64.whl
   ARG CONDA_PREFIX="/opt/conda"
   ARG BRANCH_OFI=1.1.3-aws
   ```

1. Définissez les variables d'environnement suivantes pour créer correctement les composants d' SageMaker apprentissage et exécuter la bibliothèque Data Parallel. Vous utilisez ces variables pour les composants dans les étapes suivantes.

   ```
   # Set ENV variables required to build PyTorch
   ENV TORCH_CUDA_ARCH_LIST="7.0+PTX 8.0"
   ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all"
   ENV NCCL_VERSION=2.10.3
   
   # Add OpenMPI to the path.
   ENV PATH /opt/amazon/openmpi/bin:$PATH
   
   # Add Conda to path
   ENV PATH $CONDA_PREFIX/bin:$PATH
   
   # Set this enviroment variable for SageMaker AI to launch SMDDP correctly.
   ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.training:main
   
   # Add enviroment variable for processes to be able to call fork()
   ENV RDMAV_FORK_SAFE=1
   
   # Indicate the container type
   ENV DLC_CONTAINER_TYPE=training
   
   # Add EFA and SMDDP to LD library path
   ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH"
   ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH
   ```

1. Installez ou mettez à jour `curl`, `wget` et `git` pour télécharger et créer des packages dans les étapes suivantes.

   ```
   RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
       apt-get update && apt-get install -y  --no-install-recommends \
           curl \
           wget \
           git \
       && rm -rf /var/lib/apt/lists/*
   ```

1. Installez le logiciel [Elastic Fabric Adapter (EFA)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) pour la communication réseau Amazon EC2.

   ```
   RUN DEBIAN_FRONTEND=noninteractive apt-get update
   RUN mkdir /tmp/efa \
       && cd /tmp/efa \
       && curl --silent -O https://efa-installer.amazonaws.com/aws-efa-installer-${EFA_VERSION}.tar.gz \
       && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \
       && cd aws-efa-installer \
       && ./efa_installer.sh -y --skip-kmod -g \
       && rm -rf /tmp/efa
   ```

1. Installez [Conda](https://docs.conda.io/en/latest/) pour traiter la gestion des paquets. 

   ```
   RUN curl -fsSL -v -o ~/miniconda.sh -O  https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh  && \
       chmod +x ~/miniconda.sh && \
       ~/miniconda.sh -b -p $CONDA_PREFIX && \
       rm ~/miniconda.sh && \
       $CONDA_PREFIX/bin/conda install -y python=${PYTHON_SHORT_VERSION} conda-build pyyaml numpy ipython && \
       $CONDA_PREFIX/bin/conda clean -ya
   ```

1. Obtenez, compilez, installez PyTorch et ses dépendances. Nous construisons [PyTorch à partir du code source](https://github.com/pytorch/pytorch#from-source) car nous devons contrôler la version NCCL pour garantir la compatibilité avec le plug-in [AWS OFI NCCL](https://github.com/aws/aws-ofi-nccl).

   1. En suivant les étapes du [dockerfile PyTorch officiel](https://github.com/pytorch/pytorch/blob/master/Dockerfile), installez les dépendances de construction et configurez [ccache](https://ccache.dev/) pour accélérer la recompilation.

      ```
      RUN DEBIAN_FRONTEND=noninteractive \
          apt-get install -y --no-install-recommends \
              build-essential \
              ca-certificates \
              ccache \
              cmake \
              git \
              libjpeg-dev \
              libpng-dev \
          && rm -rf /var/lib/apt/lists/*
        
      # Setup ccache
      RUN /usr/sbin/update-ccache-symlinks
      RUN mkdir /opt/ccache && ccache --set-config=cache_dir=/opt/ccache
      ```

   1. Dépendances [communes et dépendances Linux](https://github.com/pytorch/pytorch#install-dependencies) de l'installationPyTorch.

      ```
      # Common dependencies for PyTorch
      RUN conda install astunparse numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing_extensions future six requests dataclasses
      
      # Linux specific dependency for PyTorch
      RUN conda install -c pytorch magma-cuda113
      ```

   1. Clonez le [PyTorch GitHubdépôt](https://github.com/pytorch/pytorch).

      ```
      RUN --mount=type=cache,target=/opt/ccache \
          cd / \
          && git clone --recursive https://github.com/pytorch/pytorch -b v${PYTORCH_VERSION}
      ```

   1. Installez et créez une version spécifique de [NCCL](https://developer.nvidia.com/nccl). Pour ce faire, remplacez le contenu du dossier NCCL par défaut (`/pytorch/third_party/nccl`) par la version NCCL spécifique du référentiel NVIDIA. PyTorch La version NCCL a été définie à l’étape 3 de ce guide.

      ```
      RUN cd /pytorch/third_party/nccl \
          && rm -rf nccl \
          && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \
          && cd nccl \
          && make -j64 src.build CUDA_HOME=/usr/local/cuda NVCC_GENCODE="-gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_80,code=sm_80" \
          && make pkg.txz.build \
          && tar -xvf build/pkg/txz/nccl_*.txz -C $CONDA_PREFIX --strip-components=1
      ```

   1. Construisez et installez PyTorch. Ce processus prend généralement un peu plus d’une heure. Il est créé en utilisant la version NCCL téléchargée à l’étape précédente.

      ```
      RUN cd /pytorch \
          && CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \
          python setup.py install \
          && rm -rf /pytorch
      ```

1. Créez et installez le [Plugin NCCL OFI AWS](https://github.com/aws/aws-ofi-nccl). Cela permet le support de [libfabric](https://github.com/ofiwg/libfabric) pour la bibliothèque SageMaker AI data parallel.

   ```
   RUN DEBIAN_FRONTEND=noninteractive apt-get update \
       && apt-get install -y --no-install-recommends \
           autoconf \
           automake \
           libtool
   RUN mkdir /tmp/efa-ofi-nccl \
       && cd /tmp/efa-ofi-nccl \
       && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \
       && cd aws-ofi-nccl \
       && ./autogen.sh \
       && ./configure --with-libfabric=/opt/amazon/efa \
       --with-mpi=/opt/amazon/openmpi \
       --with-cuda=/usr/local/cuda \
       --with-nccl=$CONDA_PREFIX \
       && make \
       && make install \
       && rm -rf /tmp/efa-ofi-nccl
   ```

1. Construisez et installez [TorchVision](https://github.com/pytorch/vision.git).

   ```
   RUN pip install --no-cache-dir -U \
       packaging \
       mpi4py==3.0.3
   RUN cd /tmp \
       && git clone https://github.com/pytorch/vision.git -b v0.9.1 \
       && cd vision \
       && BUILD_VERSION="0.9.1+cu111" python setup.py install \
       && cd /tmp \
       && rm -rf vision
   ```

1. Installez et configurer OpenSSH. OpenSSH est requis pour que MPI communique entre les conteneurs. Autorisez OpenSSH à parler aux conteneurs sans demander de confirmation.

   ```
   RUN apt-get update \
       && apt-get install -y  --allow-downgrades --allow-change-held-packages --no-install-recommends \
       && apt-get install -y --no-install-recommends openssh-client openssh-server \
       && mkdir -p /var/run/sshd \
       && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \
       && echo "    StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \
       && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \
       && rm -rf /var/lib/apt/lists/*
   
   # Configure OpenSSH so that nodes can communicate with each other
   RUN mkdir -p /var/run/sshd && \
    sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd
   RUN rm -rf /root/.ssh/ && \
    mkdir -p /root/.ssh/ && \
    ssh-keygen -q -t rsa -N '' -f /root/.ssh/id_rsa && \
    cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys \
    && printf "Host *\n StrictHostKeyChecking no\n" >> /root/.ssh/config
   ```

1. Installez le plug-in PT S3 pour accéder efficacement aux jeux de données dans Amazon S3.

   ```
   RUN pip install --no-cache-dir -U ${PT_S3_WHL_GPU}
   RUN mkdir -p /etc/pki/tls/certs && cp /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt
   ```

1. Installez la bibliothèque [libboost](https://www.boost.org/). Ce package est nécessaire pour mettre en réseau la fonctionnalité d'E/S asynchrone de la bibliothèque SageMaker AI data parallel.

   ```
   WORKDIR /
   RUN wget https://sourceforge.net/projects/boost/files/boost/1.73.0/boost_1_73_0.tar.gz/download -O boost_1_73_0.tar.gz \
       && tar -xzf boost_1_73_0.tar.gz \
       && cd boost_1_73_0 \
       && ./bootstrap.sh \
       && ./b2 threading=multi --prefix=${CONDA_PREFIX} -j 64 cxxflags=-fPIC cflags=-fPIC install || true \
       && cd .. \
       && rm -rf boost_1_73_0.tar.gz \
       && rm -rf boost_1_73_0 \
       && cd ${CONDA_PREFIX}/include/boost
   ```

1. Installez les outils d' SageMaker IA suivants pour la PyTorch formation.

   ```
   WORKDIR /root
   RUN pip install --no-cache-dir -U \
       smclarify \
       "sagemaker>=2,<3" \
       sagemaker-experiments==0.* \
       sagemaker-pytorch-training
   ```

1. Enfin, installez le binaire SageMaker AI data parallel et les dépendances restantes.

   ```
   RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
     apt-get update && apt-get install -y  --no-install-recommends \
     jq \
     libhwloc-dev \
     libnuma1 \
     libnuma-dev \
     libssl1.1 \
     libtool \
     hwloc \
     && rm -rf /var/lib/apt/lists/*
   
   RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY}
   ```

1. Après avoir créé le Dockerfile, consultez [Adapting Your Own Training Container](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) pour savoir comment créer le conteneur Docker, l'héberger dans Amazon ECR et exécuter une tâche de formation à l'aide du SDK Python. SageMaker 

L’exemple de code suivant montre un Dockerfile complet après avoir combiné tous les blocs de code précédents.

```
# This file creates a docker image with minimum dependencies to run SageMaker AI data parallel training
FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04

# Set appropiate versions and location for components
ARG PYTORCH_VERSION=1.10.2
ARG PYTHON_SHORT_VERSION=3.8
ARG EFA_VERSION=1.14.1
ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/${PYTORCH_VERSION}/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl
ARG PT_S3_WHL_GPU=https://aws-s3-plugin.s3.us-west-2.amazonaws.com/binaries/0.0.1/1c3e69e/awsio-0.0.1-cp38-cp38-manylinux1_x86_64.whl
ARG CONDA_PREFIX="/opt/conda"
ARG BRANCH_OFI=1.1.3-aws

# Set ENV variables required to build PyTorch
ENV TORCH_CUDA_ARCH_LIST="3.7 5.0 7.0+PTX 8.0"
ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all"
ENV NCCL_VERSION=2.10.3

# Add OpenMPI to the path.
ENV PATH /opt/amazon/openmpi/bin:$PATH

# Add Conda to path
ENV PATH $CONDA_PREFIX/bin:$PATH

# Set this enviroment variable for SageMaker AI to launch SMDDP correctly.
ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.training:main

# Add enviroment variable for processes to be able to call fork()
ENV RDMAV_FORK_SAFE=1

# Indicate the container type
ENV DLC_CONTAINER_TYPE=training

# Add EFA and SMDDP to LD library path
ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH"
ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH

# Install basic dependencies to download and build other dependencies
RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
  apt-get update && apt-get install -y  --no-install-recommends \
  curl \
  wget \
  git \
  && rm -rf /var/lib/apt/lists/*

# Install EFA.
# This is required for SMDDP backend communication
RUN DEBIAN_FRONTEND=noninteractive apt-get update
RUN mkdir /tmp/efa \
    && cd /tmp/efa \
    && curl --silent -O https://efa-installer.amazonaws.com/aws-efa-installer-${EFA_VERSION}.tar.gz \
    && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \
    && cd aws-efa-installer \
    && ./efa_installer.sh -y --skip-kmod -g \
    && rm -rf /tmp/efa

# Install Conda
RUN curl -fsSL -v -o ~/miniconda.sh -O  https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh  && \
    chmod +x ~/miniconda.sh && \
    ~/miniconda.sh -b -p $CONDA_PREFIX && \
    rm ~/miniconda.sh && \
    $CONDA_PREFIX/bin/conda install -y python=${PYTHON_SHORT_VERSION} conda-build pyyaml numpy ipython && \
    $CONDA_PREFIX/bin/conda clean -ya

# Install PyTorch.
# Start with dependencies listed in official PyTorch dockerfile
# https://github.com/pytorch/pytorch/blob/master/Dockerfile
RUN DEBIAN_FRONTEND=noninteractive \
    apt-get install -y --no-install-recommends \
        build-essential \
        ca-certificates \
        ccache \
        cmake \
        git \
        libjpeg-dev \
        libpng-dev && \
    rm -rf /var/lib/apt/lists/*

# Setup ccache
RUN /usr/sbin/update-ccache-symlinks
RUN mkdir /opt/ccache && ccache --set-config=cache_dir=/opt/ccache

# Common dependencies for PyTorch
RUN conda install astunparse numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing_extensions future six requests dataclasses

# Linux specific dependency for PyTorch
RUN conda install -c pytorch magma-cuda113

# Clone PyTorch
RUN --mount=type=cache,target=/opt/ccache \
    cd / \
    && git clone --recursive https://github.com/pytorch/pytorch -b v${PYTORCH_VERSION}
# Note that we need to use the same NCCL version for PyTorch and OFI plugin.
# To enforce that, install NCCL from source before building PT and OFI plugin.

# Install NCCL.
# Required for building OFI plugin (OFI requires NCCL's header files and library)
RUN cd /pytorch/third_party/nccl \
    && rm -rf nccl \
    && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \
    && cd nccl \
    && make -j64 src.build CUDA_HOME=/usr/local/cuda NVCC_GENCODE="-gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_80,code=sm_80" \
    && make pkg.txz.build \
    && tar -xvf build/pkg/txz/nccl_*.txz -C $CONDA_PREFIX --strip-components=1

# Build and install PyTorch.
RUN cd /pytorch \
    && CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \
    python setup.py install \
    && rm -rf /pytorch

RUN ccache -C

# Build and install OFI plugin. \
# It is required to use libfabric.
RUN DEBIAN_FRONTEND=noninteractive apt-get update \
    && apt-get install -y --no-install-recommends \
        autoconf \
        automake \
        libtool
RUN mkdir /tmp/efa-ofi-nccl \
    && cd /tmp/efa-ofi-nccl \
    && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \
    && cd aws-ofi-nccl \
    && ./autogen.sh \
    && ./configure --with-libfabric=/opt/amazon/efa \
        --with-mpi=/opt/amazon/openmpi \
        --with-cuda=/usr/local/cuda \
        --with-nccl=$CONDA_PREFIX \
    && make \
    && make install \
    && rm -rf /tmp/efa-ofi-nccl

# Build and install Torchvision
RUN pip install --no-cache-dir -U \
    packaging \
    mpi4py==3.0.3
RUN cd /tmp \
    && git clone https://github.com/pytorch/vision.git -b v0.9.1 \
    && cd vision \
    && BUILD_VERSION="0.9.1+cu111" python setup.py install \
    && cd /tmp \
    && rm -rf vision

# Install OpenSSH.
# Required for MPI to communicate between containers, allow OpenSSH to talk to containers without asking for confirmation
RUN apt-get update \
    && apt-get install -y  --allow-downgrades --allow-change-held-packages --no-install-recommends \
    && apt-get install -y --no-install-recommends openssh-client openssh-server \
    && mkdir -p /var/run/sshd \
    && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \
    && echo "    StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \
    && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \
    && rm -rf /var/lib/apt/lists/*
# Configure OpenSSH so that nodes can communicate with each other
RUN mkdir -p /var/run/sshd && \
    sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd
RUN rm -rf /root/.ssh/ && \
    mkdir -p /root/.ssh/ && \
    ssh-keygen -q -t rsa -N '' -f /root/.ssh/id_rsa && \
    cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys \
    && printf "Host *\n StrictHostKeyChecking no\n" >> /root/.ssh/config

# Install PT S3 plugin.
# Required to efficiently access datasets in Amazon S3
RUN pip install --no-cache-dir -U ${PT_S3_WHL_GPU}
RUN mkdir -p /etc/pki/tls/certs && cp /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt

# Install libboost from source.
# This package is needed for smdataparallel functionality (for networking asynchronous IO).
WORKDIR /
RUN wget https://sourceforge.net/projects/boost/files/boost/1.73.0/boost_1_73_0.tar.gz/download -O boost_1_73_0.tar.gz \
    && tar -xzf boost_1_73_0.tar.gz \
    && cd boost_1_73_0 \
    && ./bootstrap.sh \
    && ./b2 threading=multi --prefix=${CONDA_PREFIX} -j 64 cxxflags=-fPIC cflags=-fPIC install || true \
    && cd .. \
    && rm -rf boost_1_73_0.tar.gz \
    && rm -rf boost_1_73_0 \
    && cd ${CONDA_PREFIX}/include/boost

# Install SageMaker AI PyTorch training.
WORKDIR /root
RUN pip install --no-cache-dir -U \
    smclarify \
    "sagemaker>=2,<3" \
    sagemaker-experiments==0.* \
    sagemaker-pytorch-training

# Install SageMaker AI data parallel binary (SMDDP)
# Start with dependencies
RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
    apt-get update && apt-get install -y  --no-install-recommends \
        jq \
        libhwloc-dev \
        libnuma1 \
        libnuma-dev \
        libssl1.1 \
        libtool \
        hwloc \
    && rm -rf /var/lib/apt/lists/*

# Install SMDDP
RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY}
```

**Astuce**  
Pour des informations plus générales sur la création d'un Dockerfile personnalisé pour l'entraînement à l' SageMaker IA, consultez [Utiliser vos propres algorithmes d'entraînement](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html).

**Astuce**  
Si vous souhaitez étendre le Dockerfile personnalisé pour intégrer la bibliothèque parallèle de SageMaker modèles AI, consultez. [Créez votre propre conteneur Docker avec la bibliothèque parallèle de modèles SageMaker distribués](model-parallel-sm-sdk.md#model-parallel-bring-your-own-container)