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

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 dem SageMaker Training Compiler aus.

TensorFlow-Modelle

SageMaker Training Compiler optimiert automatisch Modelltrainings-Workloads, die auf der nativen TensorFlow-API oder der High-Level-Keras-API basieren.

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 TensorFlow Keras (tf.Keras.Model) sind.

Für das Training mit einer einzelnen GPU

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

Ohne Keras

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

Der 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

In TensorFlow 2.0 oder höher ist die Eager-Ausführung standardmäßig aktiviert, daher sollten Sie den @tf.function Decorator vor jeder Funktion hinzufügen, die Sie zum Erstellen eines TensorFlow-Modells verwenden.

TensorFlow-Modelle mit Hugging Face Transformers

TensorFlow-Modelle mit Hugging Face Transformers basieren auf der tf.keras.Model-API von TensorFlow. Hugging Face Transformers bietet auch vortrainierte Modellklassen für TensorFlow, um den Aufwand für die Konfiguration von NLP-Modellen (Natural Language Processing) zu reduzieren. Nachdem Sie Ihr eigenes Trainingsskript mithilfe der Transformers-Bibliothek erstellt haben, können Sie das Trainingsskript mithilfe des HuggingFace-Schätzers von SageMaker AI mit der SageMaker Training Compiler-Konfigurationsklasse ausführen, wie im vorherigen Thema unter Führen Sie TensorFlow-Trainingsjobs mit dem SageMaker Training Compiler aus gezeigt.

SageMaker Training Compiler optimiert automatisch Modelltraining-Workloads, die auf der nativen TensorFlow-API oder der Keras-API auf hohem Niveau aufbauen, wie z. B. die TensorFlow-Transformer-Modelle.

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 TensorFlow Keras (tf.Keras.Model) sind. Wie auf der Seite Schnell-Tour in der Dokumentation zu Hugging Face Transformers angegeben, können Sie die Modelle als reguläre TensorFlow Keras-Modelle verwenden.

Für das Training mit einer einzelnen GPU

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

Für verteiltes Training

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

  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 für mehrere Knoten und mehrere GPUs den folgenden Code hinzu, um die Konfiguration des verteilten TensorFlow-Training richtig einzustellen, bevor Sie die Strategie erstellen.

      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 Trainings-Loops mithilfe von TensorFlow ohne Keras bereitstellen möchten, sollten Sie das Modell und den Trainings-Loop mit dem TensorFlow-Funktionsdecorator (@tf.function) umschließen, um die Compilerbeschleunigung zu nutzen.

Der 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

In TensorFlow 2.0 oder höher ist die Eager-Ausführung standardmäßig aktiviert, daher sollten Sie den @tf.function Decorator vor jeder Funktion hinzufügen, die Sie zum Erstellen eines TensorFlow-Modells verwenden.

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.