TensorFlow - Amazon SageMaker
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 mit und führen Sie den Trainingsjob mit SageMaker Training Compiler aus. SageMaker

TensorFlow Modelle

SageMaker Training Compiler optimiert automatisch Workloads für 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 Compiler-Beschleunigung empfehlen wir die Verwendung von Modellen, die Unterklassen von Keras sind (tf.Keras.Model). TensorFlow

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 Compiler-Beschleunigung 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 Graphmodus ausgeführt werden.

Für das Training mit einer einzelnen GPU

TensorFlow 2.0 oder höher hat standardmäßig die Eager-Ausführung 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 Hugging Face Transformers

TensorFlow Modelle mit Hugging Face Transformers basieren auf der TensorFlow tf.Keras.Model API. 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 SageMaker HuggingFace Schätzers mit der SageMaker Training Compiler-Konfigurationsklasse ausführen, wie im vorherigen Thema unter gezeigt. Ausführen von TensorFlow Trainingsaufträgen mit dem SageMaker Training Compiler

SageMaker Der Training Compiler optimiert automatisch Workloads für Modelltraining, die auf der nativen TensorFlow API oder der Keras-API auf hoher Ebene aufbauen, wie z. B. die Transformer-Modelle. 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 Wie auf der Seite Schnelltour 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

SageMaker Die Beschleunigung des Training-Compilers 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 GPUs mit mehreren Knoten den folgenden Code hinzu, um die TensorFlow verteilte Trainingskonfiguration ordnungsgemäß festzulegen, 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 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 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 Graphmodus ausgeführt werden.

Für das Training mit einer einzelnen GPU

TensorFlow 2.0 oder höher hat standardmäßig die Eager-Ausführung 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.