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. # Adaptation de votre script d’entraînement pour utiliser les opérations collectives SMDDP 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 [À 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 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 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 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 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) **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).