View a markdown version of this page

TensorFlow - Amazon SageMaker KI
TensorFlow ModelleTensorFlow Modelle mit Transformers von Hugging Face

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

TensorFlow

Bringen Sie Ihr eigenes TensorFlow Modell zu SageMaker AI und führen Sie den Trainingsjob mit SageMaker Training Compiler aus.

TensorFlow Modelle

SageMaker Der Training Compiler optimiert automatisch die Workloads für das Modelltraining, die auf der nativen TensorFlow API oder der Keras-API auf hoher Ebene aufbauen.

Tipp

Stellen Sie für die Vorverarbeitung Ihres Eingabedatensatzes sicher, dass Sie eine statische Eingabeform verwenden. Eine dynamische Eingabeform kann eine Neukompilierung des Modells einleiten und die Gesamttrainingszeit verlängern.

Verwendung von Keras (empfohlen)

Für die beste Compilerbeschleunigung empfehlen wir die Verwendung von Modellen, die Unterklassen von Keras sind (tf.Keras.Model). TensorFlow https://www.tensorflow.org/api_docs/python/tf/keras/Model

Für das Training mit einer einzelnen GPU

Sie müssen keine zusätzlichen Änderungen am Trainingsskript vornehmen.

Ohne Keras

SageMaker Der Training Compiler unterstützt keine eifrige Ausführung in. TensorFlow Dementsprechend sollten Sie Ihr Modell und Ihre Trainingsschleifen mit der TensorFlow Funktion decorator (@tf.function) umschließen, um die Compilerbeschleunigung zu nutzen.

SageMaker Der Training Compiler führt eine Optimierung auf Diagrammebene durch und verwendet den Decorator, um sicherzustellen, dass Ihre TensorFlow Funktionen so eingestellt sind, dass sie im Grafikmodus ausgeführt werden. https://www.tensorflow.org/guide/intro_to_graphs

Für das Training mit einer einzelnen GPU

TensorFlow Bei Version 2.0 oder neuer ist die Eager-Ausführung standardmäßig aktiviert, daher sollten Sie den @tf.function Decorator vor jeder Funktion hinzufügen, die Sie für die Konstruktion eines Modells verwenden. TensorFlow

TensorFlow Modelle mit Transformers von Hugging Face

TensorFlow Modelle mit Hugging Face Transformers basieren auf TensorFlow der tf.keras.Model API. https://www.tensorflow.org/api_docs/python/tf/keras/Model Hugging Face Transformers bietet auch vortrainierte Modellklassen, um den Aufwand für die Konfiguration von Modellen zur Verarbeitung natürlicher Sprache (NLP) TensorFlow zu reduzieren. Nachdem Sie Ihr eigenes Trainingsskript mithilfe der Transformers-Bibliothek erstellt haben, können Sie das Trainingsskript mithilfe der SageMaker KI HuggingFace ModelTrainer mit der SageMaker Training Compiler-Konfigurationsklasse ausführen, wie im vorherigen Thema unter gezeigt. TensorFlow Trainingsjobs mit SageMaker Training Compiler ausführen

SageMaker Der Training Compiler optimiert automatisch die Workloads für das Modelltraining, die auf der nativen TensorFlow API oder der Keras-API auf hoher Ebene, wie z. B. den Transformer-Modellen, aufbauen. TensorFlow

Tipp

Wenn Sie mithilfe von Transformers in Ihrem Trainingsskript einen Tokenizer für ein NLP-Modell erstellen, stellen Sie sicher, dass Sie eine statische Eingabe-Tensorform verwenden, indem Sie padding='max_length' angeben. Verwenden Sie padding='longest' nicht, da das Auffüllen der längsten Sequenz im Batch die Tensorform für jeden Trainingsstapel ändern kann. Die dynamische Eingabeform kann eine Neukompilierung des Modells einleiten und die Gesamttrainingsdauer verlängern. Weitere Informationen zu den Auffülloptionen der Transformers-Tokenizer finden Sie unter Auffüllen und Abschneiden in der Dokumentation zu Hugging Face Transformers.

Keras verwenden

Für die beste Compilerbeschleunigung empfehlen wir die Verwendung von Modellen, die Unterklassen von Keras sind (tf.Keras.Model). TensorFlow https://www.tensorflow.org/api_docs/python/tf/keras/Model Wie auf der Seite Kurzanleitung in der Hugging Face Transformers-Dokumentation erwähnt, können Sie die Modelle als normale Keras-Modelle verwenden. TensorFlow

Für das Training mit einer einzelnen GPU

Sie müssen keine zusätzlichen Änderungen am Trainingsskript vornehmen.

Für verteiltes Training

SageMaker Training Die Compiler-Beschleunigung funktioniert transparent für Workloads mit mehreren GPUs, wenn das Modell mithilfe von Keras-APIs im Rahmen des Aufrufs erstellt und trainiert wird. tf.distribute.Strategy.scope()

  1. Wählen Sie die richtige Strategie für verteilte Trainings.

    1. Verwenden Sie für einzelne Knoten und mehrere GPUs, tf.distribute.MirroredStrategy um die Strategie festzulegen.

      strategy = tf.distribute.MirroredStrategy()

    2. Fügen Sie bei mehreren Knoten und mehreren GPUs den folgenden Code hinzu, um die TensorFlow verteilte Trainingskonfiguration vor der Erstellung der Strategie richtig einzurichten.

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

      Verwenden Sie tf.distribute.MultiWorkerMirroredStrategy, um die Strategie festzulegen.

      strategy = tf.distribute.MultiWorkerMirroredStrategy()

  2. Verwenden Sie die Strategie Ihrer Wahl, um das Modell zu verpacken.

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

Ohne Keras

Wenn Sie benutzerdefinierte Modelle mit benutzerdefinierten Trainingsschleifen TensorFlow ohne Keras verwenden möchten, sollten Sie das Modell und die Trainingsschleife mit der TensorFlow Funktion decorator (@tf.function) umschließen, um die Compilerbeschleunigung zu nutzen.

SageMaker Training Compiler führt eine Optimierung auf Diagrammebene durch und verwendet den Decorator, um sicherzustellen, dass Ihre TensorFlow Funktionen so eingestellt sind, dass sie im Grafikmodus ausgeführt werden.

Für das Training mit einer einzelnen GPU

TensorFlow Bei Version 2.0 oder neuer ist die Eager-Ausführung standardmäßig aktiviert, daher sollten Sie den @tf.function Decorator vor jeder Funktion hinzufügen, die Sie für die Konstruktion eines Modells verwenden. TensorFlow

Für verteiltes Training

Zusätzlich zu den Änderungen, die für die Verwendung von Keras für verteiltes Training erforderlich sind, müssen Sie sicherstellen, dass Funktionen, die auf jeder GPU ausgeführt werden sollen, mit @tf.function-Anmerkungen versehen sind, während GPU-übergreifende Kommunikationsfunktionen nicht mit Anmerkungen versehen sind. Ein Beispiel für einen Trainingscode sollte wie folgt aussehen:

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

Beachten Sie, dass diese Anweisung sowohl für einzelne Knoten als auch für mehrere GPUs mit mehreren Knoten verwendet werden kann.