TensorFlow - Amazon SageMaker
TensorFlow ModèlesTensorFlow Modèles 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

Importez votre propre TensorFlow modèle et exécutez le travail de formation avec SageMaker Training Compiler. SageMaker

TensorFlow Modèles

SageMaker Training Compiler optimise automatiquement les charges de travail d'entraînement des modèles basées sur l' TensorFlow API native ou sur 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 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 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 s'exécuter en mode graphique.

Pour l'entraînement à GPU unique

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 Hugging Face Transformers

TensorFlow les modèles dotés de Hugging Face Transformers sont basés TensorFlow sur l'API tf.keras.model. Hugging Face Transformers propose également des classes de modèles préentraînées afin de réduire TensorFlow les efforts liés à la 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 HuggingFaceestimateur avec la classe de configuration SageMaker Training Compiler, comme indiqué dans la rubrique précédente à l'adresse. Exécuter TensorFlow des tâches de formation avec SageMaker Training Compiler

SageMaker Training Compiler optimise automatiquement les charges de travail d'entraînement des modèles basées sur l' TensorFlow API native ou sur 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 Transformers, consultez Padding and truncation (Remplissage et troncature) dans la documentation de Hugging Face Transformers.

Utilisation de Keras

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

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é

SageMaker L'accélération du compilateur de formation 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 les processeurs multi-nœuds et multi-GPU, ajoutez le code suivant pour définir correctement la configuration d'entraînement TensorFlow distribué 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 créer des modèles personnalisés avec des boucles d'entraînement personnalisées TensorFlow sans Keras, vous devez intégrer le modèle et la boucle d'entraînement à 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 s'exécuter en mode graphique.

Pour l'entraînement à GPU unique

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é

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.