TensorFlow - Amazon SageMaker AI
Modèles TensorFlowModèles TensorFlow avec Hugging Face Transformers

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

Apportez votre propre modèle TensorFlow à SageMaker AI et exécutez la tâche d’entraînement avec SageMaker Training Compiler.

Modèles TensorFlow

SageMaker Training Compiler optimise automatiquement les charges de travail d’entraînement des modèles qui reposent sur l’API TensorFlow native ou 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)

Pour une accélération optimale du compilateur, nous vous recommandons d’utiliser des modèles qui sont des sous-classes de TensorFlow Keras (tf.keras.Model).

Pour l’entraînement à GPU unique

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

Sans Keras

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

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

Pour l’entraînement à GPU unique

TensorFlow 2.0 ou version ultérieure a l’exécution rapide activée par défaut, vous devez donc ajouter le décorateur @tf.function devant chaque fonction que vous utilisez pour construire un modèle TensorFlow.

Modèles TensorFlow avec Hugging Face Transformers

Les modèles TensorFlow avec les transformeurs Hugging Face sont basés sur l’API tf.keras.Model de TensorFlow. Les transformeurs Hugging Face fournissent également des classes de modèles préentraînées pour TensorFlow afin de réduire l’effort 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’estimateur HuggingFace SageMaker AI avec la classe de configuration du compilateur d’entraînement SageMaker, comme indiqué dans la rubrique précédente à l’adresse Exécution de tâches d’entraînement TensorFlow avec SageMaker Training Compiler.

SageMaker Training Compiler optimise automatiquement les charges de travail d’entraînement des modèles qui reposent sur l’API TensorFlow native ou l’API Keras de haut niveau, comme les modèles de transformeur TensorFlow.

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 dans la documentation des transformeurs Hugging Face.

Utilisation de Keras

Pour une accélération optimale du compilateur, nous vous recommandons d’utiliser des modèles qui sont des sous-classes de TensorFlow Keras (tf.keras.Model). Comme indiqué dans la page Quick tour (Présentation rapide) de la documentation Hugging Face Transformers, vous pouvez utiliser les modèles comme des modèles TensorFlow Keras standard.

Pour l’entraînement à GPU unique

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

Pour l’entraînement distribué

L’accélération de SageMaker Training Compiler 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().

  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()

    2. Pour le multi-GPU multi-nœuds, ajoutez le code suivant pour définir correctement la configuration d’entraînement distribué TensorFlow 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()

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

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

Sans Keras

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

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

Pour l’entraînement à GPU unique

TensorFlow 2.0 ou version ultérieure a l’exécution rapide activée par défaut, vous devez donc ajouter le décorateur @tf.function devant chaque fonction que vous utilisez pour construire un modèle TensorFlow.

Pour l’entraînement distribué

En plus des modifications nécessaires à l’utilisation de Keras pour l’entraînement distribué, 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.