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.
# Passen Sie Ihr Trainingsskript TensorFlow an
**Anmerkung**
Amazon SageMaker Debugger steht neuen Kunden nicht mehr offen. Bestehende Kunden können den Service weiterhin wie gewohnt nutzen. AWS investiert weiterhin in Sicherheits- und Verfügbarkeitsverbesserungen für Debugger, aber wir planen nicht, neue Funktionen einzuführen. Weitere Informationen finden Sie unter [Änderung der Debugger-Verfügbarkeit](debugger-availability-change.md).
Nehmen Sie die folgenden Änderungen an Ihrem Trainingsskript vor, um mit der Erfassung von Modellausgabetensoren und dem Debuggen von TensorFlow Trainingsproblemen zu beginnen.
**Erstellen Sie einen Hook für Trainingsjobs innerhalb der KI SageMaker **
```
import smdebug.tensorflow as smd
hook=smd.get_hook(hook_type="keras", create_if_not_exists=True)
```
Dadurch entsteht ein Haken, wenn Sie einen SageMaker Trainingsjob beginnen. Wenn Sie einen Trainingsjob [Starten Sie Trainingsjobs mit dem Debugger mithilfe des SageMaker Python-SDK](debugger-configuration-for-debugging.md) mit einem der oder `Rules` in Ihrem starten `DebuggerHookConfig``TensorBoardConfig`, fügt SageMaker AI Ihrer ModelTrainer Trainingsinstanz eine JSON-Konfigurationsdatei hinzu, die von der `smd.get_hook` Methode übernommen wird. Beachten Sie, dass, wenn Sie keine der Konfigurations-APIs in Ihre aufnehmen ModelTrainer, es keine Konfigurationsdatei gibt, die der Hook finden muss, und die Funktion kehrt zurück`None`.
**(Optional) Erstellen Sie einen Hook für Trainingsjobs außerhalb der SageMaker KI **
Wenn Sie Trainingsjobs im lokalen Modus, direkt auf SageMaker Notebook-Instances, Amazon EC2-Instances oder Ihren eigenen lokalen Geräten ausführen, verwenden Sie `smd.Hook` class, um einen Hook zu erstellen. Bei diesem Ansatz können jedoch nur die Tensorsammlungen gespeichert und für TensorBoard die Visualisierung verwendet werden. SageMaker Die integrierten Regeln des Debuggers funktionieren nicht im lokalen Modus. Die `smd.get_hook` Methode kehrt auch in diesem Fall zurück `None`.
Wenn Sie einen manuellen Hook erstellen möchten, verwenden Sie den folgenden Codeausschnitt mit der Logik, um zu überprüfen, ob der Hook zurückkehrt `None` und erstellen Sie mithilfe der `smd.Hook` Klasse einen manuellen Hook.
```
import smdebug.tensorflow as smd
hook=smd.get_hook(hook_type="keras", create_if_not_exists=True)
if hook is None:
hook=smd.KerasHook(
out_dir='{{/path/to/your/local/output/}}',
export_tensorboard=True
)
```
Nachdem Sie den Code zur Hook-Erstellung hinzugefügt haben, fahren Sie mit dem folgenden Thema für TensorFlow Keras fort.
**Anmerkung**
SageMaker Der Debugger unterstützt derzeit nur TensorFlow Keras.
## Registrieren Sie den Hook in Ihrem TensorFlow Keras-Trainingsskript
Im folgenden Verfahren erfahren Sie, wie Sie den Hook und seine Methoden verwenden, um Ausgabeskalare und Tensoren aus Ihrem Modell und Optimierer zu sammeln.
1. Verpacken Sie Ihr Keras-Modell und Ihren Optimierer mit den Klassenmethoden des Hooks.
Die `hook.register_model()` Methode verwendet Ihr Modell und durchläuft jede Ebene. Dabei wird nach Tensoren gesucht, die mit den regulären Ausdrücken übereinstimmen, die Sie in der Konfiguration in [Starten Sie Trainingsjobs mit dem Debugger mithilfe des SageMaker Python-SDK](debugger-configuration-for-debugging.md) angeben. Die Tensoren, die mit dieser Hook-Methode gesammelt werden können, sind Gewichtungen, Verzerrungen und Aktivierungen.
```
model=tf.keras.Model(...)
hook.register_model(model)
```
1. Umschließen Sie den Optimizer nach der `hook.wrap_optimizer()` Methode.
```
optimizer=tf.keras.optimizers.Adam(...)
optimizer=hook.wrap_optimizer(optimizer)
```
1. Kompilieren Sie das Modell im Eager-Modus in TensorFlow.
Um Tensoren aus dem Modell zu sammeln, z. B. die Eingabe- und Ausgabetensoren jeder Schicht, müssen Sie das Training im Eager-Modus ausführen. Andernfalls kann der SageMaker AI-Debugger die Tensoren nicht sammeln. Andere Tensoren, wie Modellgewichte, Verzerrungen und Verluste, können jedoch erfasst werden, ohne dass sie explizit im Eager-Modus ausgeführt werden.
```
model.compile(
loss="categorical_crossentropy",
optimizer=optimizer,
metrics=["accuracy"],
# Required for collecting tensors of each layer
run_eagerly=True
)
```
1. Registrieren Sie den Hook für die [`tf.keras.Model.fit()`](https://www.tensorflow.org/api_docs/python/tf/keras/Model#fit) Methode.
Um die Tensoren aus den Hooks zu sammeln, die Sie registriert haben, fügen Sie `callbacks=[hook]` der Keras `model.fit()` Klassenmethode hinzu. Dadurch wird der `sagemaker-debugger` Hook als Keras-Callback übergeben.
```
model.fit(
X_train, Y_train,
batch_size=batch_size,
epochs=epoch,
validation_data=(X_valid, Y_valid),
shuffle=True,
callbacks=[hook]
)
```
1. TensorFlow 2.x bietet nur symbolische Gradientenvariablen, die keinen Zugriff auf ihre Werte ermöglichen. Um Farbverläufe zu sammeln, wenden `tf.GradientTape` Sie sich an die [`hook.wrap_tape()`](https://sagemaker-debugger.readthedocs.io/en/website/hook-methods.html#tensorflow-specific-hook-api) Methode, bei der Sie Ihren eigenen Trainingsschritt wie folgt schreiben müssen.
```
def training_step(model, dataset):
with hook.wrap_tape(tf.GradientTape()) as tape:
pred=model(data)
loss_value=loss_fn(labels, pred)
grads=tape.gradient(loss_value, model.trainable_variables)
optimizer.apply_gradients(zip(grads, model.trainable_variables))
```
Durch das Umwickeln des Bandes kann der `sagemaker-debugger` Hook Ausgangstensoren wie Gradienten, Parameter und Verluste identifizieren. Das Umwickeln des Bandes stellt sicher, dass die `hook.wrap_tape()` Methode rund um Funktionen des Bandobjekts, wie,,,`push_tape()`,,,`pop_tape()`,,`gradient()`,,,,,,,,,,,,, verwendet, um Tensoren zu speichern, die als Eingabe für `gradient()` (trainierbare Variablen und Verlust) und als Ausgabe von `gradient()` (Gradienten) zur Verfügung gestellt werden. SageMaker
**Anmerkung**
Um Daten mit einer benutzerdefinierten Trainingsschleife zu sammeln, stellen Sie sicher, dass Sie den Eager-Modus verwenden. Andernfalls ist der SageMaker Debugger nicht in der Lage, Tensoren zu sammeln.
Eine vollständige Liste der Aktionen, die die `sagemaker-debugger` Hook-APIs zum Erstellen von Hooks und Speichern von Tensoren anbieten, finden Sie unter [Hook-Methoden](https://sagemaker-debugger.readthedocs.io/en/website/hook-methods.html) in der *`sagemaker-debugger`Python SDK-Dokumentation*.
Nachdem Sie die Anpassung Ihres Trainingsskripts abgeschlossen haben, fahren Sie mit [Starten Sie Trainingsjobs mit dem Debugger mithilfe des SageMaker Python-SDK](debugger-configuration-for-debugging.md) fort.