Utiliser la SMDDP bibliothèque dans votre script TensorFlow d'entraînement (obsolète) - Amazon SageMaker

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.

Utiliser la SMDDP bibliothèque dans votre script TensorFlow d'entraînement (obsolète)

Important

La SMDDP bibliothèque a cessé de prendre en charge la version 2.11.0 TensorFlow et n'est plus disponible DLCs depuis TensorFlow la version 2.11.0. Pour trouver la version précédente TensorFlow DLCs avec la SMDDP bibliothèque installée, voirFrameworks pris en charge.

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

La bibliothèque APIs est conçue pour être similaire à HorovodAPIs. Pour plus de détails sur chacune API des options proposées par la bibliothèque TensorFlow, consultez la TensorFlow APIdocumentation sur SageMaker Distributed Data Parallel.

Note

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

Note

La bibliothèque de parallélisme de données SageMaker distribué est prête à l'emploi avec Automatic Mixed Precision (AMP). Aucune action supplémentaire n'est nécessaire pour activer AMP autre que les modifications apportées au niveau du framework à votre script d'entraînement. Si des dégradés sont présentsFP16, la bibliothèque de parallélisme de SageMaker données exécute son AllReduce opération dans. FP16 Pour plus d'informations sur la mise AMP APIs en œuvre de votre script d'entraînement, consultez les ressources suivantes :

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

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

  2. Épinglez chacun d'eux GPU à un seul smdistributed.dataparallel processus avec local_rank —cela fait référence au rang relatif du processus au sein d'un nœud donné. Vous sdp.tensorflow.local_rank() API indique le rang local de l'appareil. 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 quesdp.local_rank(). set_memory_growthn'est pas directement lié à la SageMaker distribution, 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')

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

    learning_rate = learning_rate * sdp.size()

  4. 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 data parallel: Wrap tf.GradientTape with the library's DistributedGradientTape
tape = sdp.DistributedGradientTape(tape)

  5. 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 le sdp.tensorflow.broadcast_variables API après l'initialisation des variables du modèle et de l'optimiseur. Ceci est invoqué dans le bloc de code suivant en tant quesdp.broadcast_variables(). 

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

  6. 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 data parallel: Import the library TF API
import smdistributed.dataparallel.tensorflow as sdp

# SageMaker 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 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 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 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 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 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 à SMDDP l'aide de SageMaker Python SDK.