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.

# TensorFlow
<a name="training-compiler-tensorflow"></a>

Intégrez votre propre TensorFlow modèle à l' SageMaker IA et exécutez le travail de formation avec SageMaker Training Compiler.

## TensorFlow Modèles
<a name="training-compiler-tensorflow-models"></a>

SageMaker Training Compiler optimise automatiquement les charges de travail de formation des modèles qui sont construites au-dessus de l' TensorFlow API native ou de l'API Keras de haut niveau.

**Astuce**  
Pour prétraiter votre jeu de données d’entrée, veillez à utiliser une forme d’entrée statique. La forme d’entrée dynamique peut déclencher une recompilation du modèle et augmenter la durée totale d’entraînement. 

### Utilisation de Keras (recommandée)
<a name="training-compiler-tensorflow-models-keras"></a>

Pour une accélération optimale du compilateur, nous vous recommandons d'utiliser des modèles qui sont des sous-classes de TensorFlow Keras ([https://www.tensorflow.org/api_docs/python/tf/keras/Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model)TF.Keras.Model).

#### Pour l’entraînement à GPU unique
<a name="training-compiler-tensorflow-models-keras-single-gpu"></a>

Vous n’avez pas besoin d’apporter de modification supplémentaire au script d’entraînement.

### Sans Keras
<a name="training-compiler-tensorflow-models-no-keras"></a>

SageMaker Training Compiler ne prend pas en charge l'exécution rapide dans TensorFlow. Par conséquent, vous devez encapsuler votre modèle et vos boucles d'entraînement avec la TensorFlow fonction decorator (`@tf.function`) pour tirer parti de l'accélération du compilateur.

SageMaker Training Compiler effectue une optimisation au niveau du graphe et utilise le décorateur pour s'assurer que vos TensorFlow fonctions sont configurées pour être exécutées en [ mode graphique. ](https://www.tensorflow.org/guide/intro_to_graphs)

#### Pour l’entraînement à GPU unique
<a name="training-compiler-tensorflow-models-no-keras-single-gpu"></a>

TensorFlow L'exécution rapide est activée par défaut dans la version 2.0 ou ultérieure. Vous devez donc ajouter le `@tf.function` décorateur devant chaque fonction que vous utilisez pour construire un TensorFlow modèle.

## TensorFlow Modèles avec transformateurs Hugging Face
<a name="training-compiler-tensorflow-models-transformers"></a>

TensorFlow les modèles dotés de [ Hugging Face Transformers ](https://huggingface.co/docs/transformers/index) sont basés sur l'API TensorFlow [https://www.tensorflow.org/api_docs/python/tf/keras/Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model) TF.Keras.Model. Hugging Face Transformers propose également des classes de modèles préentraînées TensorFlow afin de réduire les efforts de configuration des modèles de traitement du langage naturel (NLP). Après avoir créé votre propre script d'entraînement à l'aide de la bibliothèque Transformers, vous pouvez exécuter le script d'entraînement à l'aide de l' SageMaker IA `HuggingFace` ModelTrainer avec la classe de configuration SageMaker Training Compiler, comme indiqué dans la rubrique précédente sur[Exécutez TensorFlow des tâches de formation avec SageMaker Training Compiler](training-compiler-enable-tensorflow.md).

SageMaker Training Compiler optimise automatiquement les charges de travail de formation des modèles qui sont basées sur l' TensorFlow API native ou l'API Keras de haut niveau, telles que les TensorFlow modèles de transformateurs.

**Astuce**  
Lorsque vous créez un créateur de jetons pour un modèle NLP en utilisant le type Transformers dans votre script d’entraînement, assurez-vous que vous utilisez une forme de tenseur d’entrée statique en spécifiant `padding='max_length'`. N’utilisez pas `padding='longest'`, car le remplissage à la séquence la plus longue du lot peut changer la forme du tenseur pour chaque lot d’entraînement. La forme d’entrée dynamique peut déclencher une recompilation du modèle et augmenter la durée totale d’entraînement. Pour obtenir plus d’informations sur les options de remplissage des créateurs de jetons de transformeur, consultez [Remplissage et troncature](https://huggingface.co/docs/transformers/pad_truncation) dans la *documentation des transformeurs Hugging Face*.

**Topics**
+ [Utilisation de Keras](#training-compiler-tensorflow-models-transformers-keras)
+ [Sans Keras](#training-compiler-tensorflow-models-transformers-no-keras)

### Utilisation de Keras
<a name="training-compiler-tensorflow-models-transformers-keras"></a>

Pour une accélération optimale du compilateur, nous vous recommandons d'utiliser des modèles qui sont des sous-classes de TensorFlow Keras ([https://www.tensorflow.org/api_docs/python/tf/keras/Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model)TF.Keras.Model). Comme indiqué dans la [ page de présentation ](https://huggingface.co/docs/transformers/quicktour) rapide de la documentation * Hugging Face Transformers*, vous pouvez utiliser les modèles comme des modèles TensorFlow Keras classiques.

#### Pour l’entraînement à GPU unique
<a name="training-compiler-tensorflow-models-transformers-keras-single-gpu"></a>

Vous n'avez pas besoin d'apporter de modification supplémentaire au script d'entraînement.

#### Pour l’entraînement distribué
<a name="training-compiler-tensorflow-models-transformers-keras-distributed"></a>

SageMaker L'accélération du compilateur d'entraînement fonctionne de manière transparente pour les charges de travail multi-GPU lorsque le modèle est construit et entraîné à l'aide des API Keras dans le cadre de l'appel. [`tf.distribute.Strategy.scope()`](https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy)

1. Choisissez la bonne stratégie d’entraînement distribué.

   1. Pour le multi-GPU à nœud unique, utilisez `tf.distribute.MirroredStrategy` pour définir la stratégie.

      ```
      strategy = tf.distribute.MirroredStrategy()
      ```

   1. Pour les GPU multi-nœuds, ajoutez le code suivant pour définir correctement la configuration d'entraînement TensorFlow distribuée avant de créer la stratégie.

      ```
      def set_sm_dist_config():
          DEFAULT_PORT = '8890'
          DEFAULT_CONFIG_FILE = '/opt/ml/input/config/resourceconfig.json'
          with open(DEFAULT_CONFIG_FILE) as f:
              config = json.loads(f.read())
              current_host = config['current_host']
          tf_config = {
              'cluster': {
                  'worker': []
              },
              'task': {'type': 'worker', 'index': -1}
          }
          for i, host in enumerate(config['hosts']):
              tf_config['cluster']['worker'].append("%s:%s" % (host, DEFAULT_PORT))
              if current_host == host:
                  tf_config['task']['index'] = i
          os.environ['TF_CONFIG'] = json.dumps(tf_config)
      
      set_sm_dist_config()
      ```

       Utilisez `tf.distribute.MultiWorkerMirroredStrategy` pour définir la stratégie.

      ```
      strategy = tf.distribute.MultiWorkerMirroredStrategy()
      ```

1. En utilisant la stratégie de votre choix, enveloppez le modèle.

   ```
   with strategy.scope():
       # create a model and do fit
   ```

### Sans Keras
<a name="training-compiler-tensorflow-models-transformers-no-keras"></a>

Si vous souhaitez apporter des modèles personnalisés avec des boucles d'entraînement personnalisées TensorFlow sans Keras, vous devez encapsuler le modèle et la boucle d'apprentissage avec la TensorFlow fonction decorator (`@tf.function`) pour tirer parti de l'accélération du compilateur.

SageMaker Training Compiler effectue une optimisation au niveau du graphe et utilise le décorateur pour s'assurer que vos TensorFlow fonctions sont configurées pour être exécutées en mode graphique. 

#### Pour l’entraînement à GPU unique
<a name="training-compiler-tensorflow-models-transformers-no-keras-single-gpu"></a>

TensorFlow L'exécution rapide est activée par défaut dans la version 2.0 ou ultérieure. Vous devez donc ajouter le `@tf.function` décorateur devant chaque fonction que vous utilisez pour construire un TensorFlow modèle.

#### Pour l’entraînement distribué
<a name="training-compiler-tensorflow-models-transformers-no-keras-distributed"></a>

En plus des modifications nécessaires à l’[utilisation de Keras pour l’entraînement distribué](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-tensorflow-models.html#training-compiler-tensorflow-models-transformers-keras), vous devez vous assurer que les fonctions à exécuter sur chaque GPU sont annotées avec `@tf.function`, tandis que les fonctions de communication inter-GPU ne sont pas annotées. Par exemple, le code d’entraînement devrait ressembler à ce qui suit :

```
@tf.function()
def compiled_step(inputs, outputs):
    with tf.GradientTape() as tape:
        pred=model(inputs, training=True)
        total_loss=loss_object(outputs, pred)/args.batch_size
    gradients=tape.gradient(total_loss, model.trainable_variables)
    return total_loss, pred, gradients

def train_step(inputs, outputs):
    total_loss, pred, gradients=compiled_step(inputs, outputs)
    if args.weight_decay > 0.:
        gradients=[g+v*args.weight_decay for g,v in zip(gradients, model.trainable_variables)]

    optimizer.apply_gradients(zip(gradients, model.trainable_variables))

    train_loss.update_state(total_loss)
    train_accuracy.update_state(outputs, pred)

@tf.function()
def train_step_dist(inputs, outputs):
    strategy.run(train_step, args= (inputs, outputs))
```

Notez que cette instruction peut être utilisée à la fois pour le multi-GPU à nœud unique et le multi-GPU multi-nœud.