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
<a name="training-compiler-tensorflow"></a>

Bringen Sie Ihr eigenes TensorFlow Modell in die SageMaker KI ein und führen Sie den Trainingsjob mit SageMaker Training Compiler aus.

## TensorFlow Modelle
<a name="training-compiler-tensorflow-models"></a>

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)
<a name="training-compiler-tensorflow-models-keras"></a>

[Für die beste Compiler-Beschleunigung 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
<a name="training-compiler-tensorflow-models-keras-single-gpu"></a>

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

### Ohne Keras
<a name="training-compiler-tensorflow-models-no-keras"></a>

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.](https://www.tensorflow.org/guide/intro_to_graphs)

#### Für das Training mit einer einzelnen GPU
<a name="training-compiler-tensorflow-models-no-keras-single-gpu"></a>

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
<a name="training-compiler-tensorflow-models-transformers"></a>

TensorFlow Modelle mit [Hugging Face Transformers](https://huggingface.co/docs/transformers/index) basieren auf der TensorFlow [tf.Keras.Model](https://www.tensorflow.org/api_docs/python/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` AI-Estimators mit der SageMaker Training Compiler-Konfigurationsklasse ausführen, wie im vorherigen Thema unter gezeigt. [TensorFlow Trainingsjobs mit dem SageMaker Training Compiler ausführen](training-compiler-enable-tensorflow.md)

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](https://huggingface.co/docs/transformers/pad_truncation) in der *Dokumentation zu Hugging Face Transformers*.

**Topics**
+ [Keras verwenden](#training-compiler-tensorflow-models-transformers-keras)
+ [Ohne Keras](#training-compiler-tensorflow-models-transformers-no-keras)

### Keras verwenden
<a name="training-compiler-tensorflow-models-transformers-keras"></a>

[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 [Schnelltour](https://huggingface.co/docs/transformers/quicktour) 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
<a name="training-compiler-tensorflow-models-transformers-keras-single-gpu"></a>

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

#### Für verteiltes Training
<a name="training-compiler-tensorflow-models-transformers-keras-distributed"></a>

SageMaker Die Compiler-Beschleunigung beim Trainieren funktioniert transparent für Workloads mit mehreren GPUs, wenn das Modell im Rahmen des Aufrufs mithilfe von Keras erstellt und trainiert wird. APIs [https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy](https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy)

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

   1. Fügen Sie bei mehreren GPUs mit mehreren Knoten den folgenden Code hinzu, um die TensorFlow verteilte Trainingskonfiguration 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()
      ```

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

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

### Ohne Keras
<a name="training-compiler-tensorflow-models-transformers-no-keras"></a>

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
<a name="training-compiler-tensorflow-models-transformers-no-keras-single-gpu"></a>

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
<a name="training-compiler-tensorflow-models-transformers-no-keras-distributed"></a>

Zusätzlich zu den Änderungen, die für die [Verwendung von Keras für verteiltes Training](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-tensorflow-models.html#training-compiler-tensorflow-models-transformers-keras) 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.