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. # Utilisez la bibliothèque SMDDP dans votre script d' TensorFlow entraînement (obsolète) **Important** La bibliothèque SMDDP n'est plus prise en charge TensorFlow et n'est plus disponible dans les DLC à partir de la TensorFlow version 2.11.0. Pour rechercher les TensorFlow DLC précédents sur lesquels la bibliothèque SMDDP est installée, consultez. [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 parallèle de données distribuées d' SageMaker AI.  La conception des API de la bibliothèque est similaire à celle des API Horovod. Pour plus de détails sur chaque API proposée par la bibliothèque TensorFlow, consultez la documentation de l' TensorFlow API parallèle de données distribuées par [ SageMaker IA](https://sagemaker.readthedocs.io/en/stable/api/training/smd_data_parallel.html#api-documentation). **Note** SageMaker L'IA distribuées en parallèle est adaptable aux scripts d' TensorFlow entraînement composés de modules de `tf` base à l'exception `tf.keras` des modules. SageMaker Le parallèle de données distribuées par IA n'est pas compatible TensorFlow avec la mise en œuvre de Keras. **Note** La bibliothèque de parallélisme des données distribuées SageMaker AI 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 les gradients se trouvent dans le FP16, la bibliothèque de parallélisme des données SageMaker AI exécute ses `AllReduce` opérations dans le FP16. Pour plus d'informations sur la mise en œuvre des API 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 * NVIDIA Deep Learning Performance * [Précision mixte automatique pour deep learning](https://developer.nvidia.com/automatic-mixed-precision) dans les *Documents du développeur NVIDIA* [TensorFlow API de précision mixte ](https://www.tensorflow.org/guide/mixed_precision) dans la * TensorFlow documentation * 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 sous la forme`sdp.local_rank()`. `set_memory_growth`n'est pas directement lié à SageMaker l'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 de TensorFlow formation pour une formation distribuée 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).