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. # Ihr Trainingsskript anpassen, um einen Hook zu registrieren Amazon SageMaker Debugger enthält eine Client-Bibliothek namens [`sagemaker-debugger`Python SDK](https://sagemaker-debugger.readthedocs.io/en/website). Das `sagemaker-debugger` Python-SDK bietet Tools zur Anpassung Ihres Trainingsskripts vor dem Training und Analysetools nach dem Training. Auf dieser Seite erfahren Sie, wie Sie Ihr Trainingsskript mithilfe der Client-Bibliothek anpassen. Das `sagemaker-debugger` Python-SDK bietet Wrapper-Funktionen, mit denen Sie einen Hook registrieren können, um Modelltensoren zu extrahieren, ohne Ihr Trainingsskript zu ändern. Um mit dem Sammeln von Modellausgabetensoren und deren Debugging zu beginnen, um Trainingsprobleme zu finden, nehmen Sie die folgenden Änderungen an Ihrem Trainingsskript vor. **Tipp** Verwenden Sie die [`sagemaker-debugger`-Open-Source-SDK-Dokumentation](https://sagemaker-debugger.readthedocs.io/en/website/index.html) für API-Referenzen, während Sie dieser Seite folgen. **Topics** + [Passen Sie Ihr PyTorch Trainingsskript an](debugger-modify-script-pytorch.md) + [Passen Sie Ihr Trainingsskript TensorFlow an](debugger-modify-script-tensorflow.md) # Passen Sie Ihr PyTorch Trainingsskript an Um mit dem Sammeln von Modellausgabetensoren und dem Debuggen von Trainingsproblemen zu beginnen, nehmen Sie die folgenden Änderungen an Ihrem PyTorch Trainingsskript vor. **Anmerkung** SageMaker Der Debugger kann keine Modellausgabetensoren aus den API-Operationen sammeln. [https://pytorch.org/docs/stable/nn.functional.html](https://pytorch.org/docs/stable/nn.functional.html) Wenn Sie ein PyTorch Trainingsskript schreiben, wird empfohlen, stattdessen die [https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html](https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html)Module zu verwenden. ## Für PyTorch 1.12.0 Wenn Sie ein PyTorch Trainingsskript mitbringen, können Sie den Trainingsjob ausführen und Modellausgabetensoren mit ein paar zusätzlichen Codezeilen in Ihrem Trainingsskript extrahieren. Sie müssen den [Hook APIs](https://sagemaker-debugger.readthedocs.io/en/website/hook-api.html) in der `sagemaker-debugger` Client-Bibliothek verwenden. Gehen Sie die folgenden Anweisungen durch, die die Schritte anhand von Codebeispielen aufschlüsseln. 1. Erstellen Sie einen Hook. **(Empfohlen) Für Schulungsjobs im Bereich SageMaker KI** ``` import smdebug.pytorch as smd hook=smd.get_hook(create_if_not_exists=True) ``` Wenn Sie einen Trainingsjob [Starten Sie Trainingsjobs mit dem Debugger mithilfe des SageMaker Python-SDK](debugger-configuration-for-debugging.md) mit einer der Regeln DebuggerHookConfig TensorBoardConfig, oder in Ihrem Kalkulator starten, fügt SageMaker AI Ihrer Trainingsinstanz eine JSON-Konfigurationsdatei hinzu, die von der `get_hook` Funktion übernommen wird. Beachten Sie, dass der Hook keine Konfigurationsdatei finden kann, wenn Sie keine Konfiguration APIs in Ihren Schätzer aufnehmen, und die Funktion zurückkehrt. `None` **(Optional) Für Ausbildungsberufe außerhalb von KI SageMaker ** Wenn Sie Trainingsjobs im lokalen Modus, direkt auf SageMaker Notebook-Instances, Amazon EC2 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 zur TensorBoard Visualisierung verwendet werden. SageMaker Die integrierten Regeln des Debuggers funktionieren nicht im lokalen Modus, da für die Regeln SageMaker AI ML-Trainingsinstanzen und S3 erforderlich sind, um die Ausgaben der Remote-Instanzen in Echtzeit zu speichern. In diesem Fall kehrt die `smd.get_hook` API zurück `None`. Wenn Sie einen manuellen Hook erstellen möchten, um Tensoren im lokalen Modus zu speichern, verwenden Sie den folgenden Codeausschnitt mit der Logik, um zu überprüfen, ob die `smd.get_hook` API zurückkehrt `None` und erstellen Sie einen manuellen Hook mithilfe der `smd.Hook` Klasse. Beachten Sie, dass Sie ein beliebiges Ausgabeverzeichnis auf Ihrem lokalen Computer angeben können. ``` import smdebug.pytorch as smd hook=smd.get_hook(create_if_not_exists=True) if hook is None: hook=smd.Hook( out_dir='/path/to/your/local/output/', export_tensorboard=True ) ``` 1. Verpacken Sie Ihr Modell mit den Klassenmethoden des Hooks. Die `hook.register_module()` 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, Aktivierungen, Gradienten, Eingaben und Ausgaben. ``` hook.register_module(model) ``` **Tipp** Wenn Sie die gesamten Ausgabetensoren aus einem großen Deep-Learning-Modell sammeln, kann die Gesamtgröße dieser Sammlungen exponentiell zunehmen und zu Engpässen führen. Wenn Sie bestimmte Tensoren speichern möchten, können Sie die `hook.save_tensor()` Methode auch verwenden. Diese Methode hilft Ihnen, die Variable für den spezifischen Tensor auszuwählen und in einer benutzerdefinierten Sammlung mit dem gewünschten Namen zu speichern. Weitere Informationen finden Sie unter [Schritt 7](#debugger-modify-script-pytorch-save-custom-tensor). 1. Verzerren Sie die Verlustfunktion mit den Klassenmethoden des Hooks. Die `hook.register_loss` Methode besteht darin, die Verlustfunktion zu umschließen. Sie extrahiert alle Verlustwerte`save_interval`, die Sie bei der Konfiguration in [Starten Sie Trainingsjobs mit dem Debugger mithilfe des SageMaker Python-SDK](debugger-configuration-for-debugging.md) festlegen, und speichert sie in der `"losses"` Sammlung. ``` hook.register_loss(loss_function) ``` 1. Fügen Sie `hook.set_mode(ModeKeys.TRAIN)` den Zugblock hinzu. Dies bedeutet, dass die Tensorsammlung während der Trainingsphase extrahiert wurde. ``` def train(): ... hook.set_mode(ModeKeys.TRAIN) ``` 1. Fügen Sie `hook.set_mode(ModeKeys.EVAL)` den Validierungsblock hinzu. Dies bedeutet, dass die Tensorsammlung während der Validierungsphase extrahiert wurde. ``` def validation(): ... hook.set_mode(ModeKeys.EVAL) ``` 1. Verwenden Sie [https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar](https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar), um benutzerdefinierte Skalare zu speichern. Sie können Skalarwerte speichern, die nicht in Ihrem Modell enthalten sind. Wenn Sie beispielsweise die bei der Auswertung berechneten Genauigkeitswerte aufzeichnen möchten, fügen Sie unter der Zeile, in der Sie die Genauigkeit berechnen, die folgende Codezeile hinzu. ``` hook.save_scalar("accuracy", accuracy) ``` Beachten Sie, dass Sie eine Zeichenfolge als erstes Argument angeben müssen, um die benutzerdefinierte Skalarsammlung zu benennen. Dies ist der Name, der für die Visualisierung der Skalarwerte verwendet wird. Dabei kann es TensorBoard sich um eine beliebige Zeichenfolge handeln. 1. Verwenden Sie [https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_tensor](https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_tensor), um benutzerdefinierte Tensoren zu speichern. Ähnlich wie bei [https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar](https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar) können Sie weitere Tensoren speichern und so Ihre eigene Tensorsammlung definieren. Sie können beispielsweise Eingabe-Image-Daten, die an das Modell übergeben werden, extrahieren und als benutzerdefinierten Tensor speichern, indem Sie die folgende Codezeile hinzufügen, in `"images"` der ein Beispielname des benutzerdefinierten Tensors steht, `image_inputs` eine Beispielvariable für die Eingabe-Image-Daten ist. ``` hook.save_tensor("images", image_inputs) ``` Beachten Sie, dass Sie für das erste Argument eine Zeichenfolge angeben müssen, um den benutzerdefinierten Tensor zu benennen. `hook.save_tensor()` hat das dritte Argument `collections_to_write`, um die Tensorsammlung zum Speichern des benutzerdefinierten Tensors anzugeben. Der Standardwert ist `collections_to_write="default"`. Wenn Sie das dritte Argument nicht explizit angeben, wird der benutzerdefinierte Tensor in der `"default"`-Tensorsammlung gespeichert. 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. # Passen Sie Ihr Trainingsskript TensorFlow an Um mit dem Sammeln von Modellausgabetensoren und dem Debuggen von Trainingsproblemen zu beginnen, nehmen Sie die folgenden Änderungen an Ihrem TensorFlow Trainingsskript vor. **Erstellen Sie einen Hook für Trainingsjobs innerhalb von KI SageMaker ** ``` import smdebug.tensorflow as smd hook=smd.get_hook(hook_type="keras", create_if_not_exists=True) ``` Dadurch entsteht ein Hook, wenn Sie einen SageMaker Trainingsjob starten. Wenn Sie einen Trainingsjob [Starten Sie Trainingsjobs mit dem Debugger mithilfe des SageMaker Python-SDK](debugger-configuration-for-debugging.md) mit einem der`DebuggerHookConfig`, `TensorBoardConfig` oder `Rules` in Ihrem Estimator starten, fügt SageMaker AI Ihrer Trainingsinstanz eine JSON-Konfigurationsdatei hinzu, die von der `smd.get_hook` Methode übernommen wird. Beachten Sie, dass der Hook keine Konfigurationsdatei finden kann, wenn Sie keine der Konfigurationen APIs in Ihren Schätzer aufnehmen, und die Funktion zurückkehrt. `None` **(Optional) Erstellen Sie einen Hook für Trainingsjobs außerhalb der KI SageMaker ** Wenn Sie Trainingsjobs im lokalen Modus, direkt auf SageMaker Notebook-Instances, Amazon EC2 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 zur TensorBoard 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 [https://www.tensorflow.org/api_docs/python/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 stellt nur symbolische Gradientenvariablen bereit, die keinen Zugriff auf ihre Werte bieten. Um Farbverläufe zu sammeln, wenden `tf.GradientTape` Sie sich an die [https://sagemaker-debugger.readthedocs.io/en/website/hook-methods.html#tensorflow-specific-hook-api](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. Durch das Umwickeln des Bandes wird sichergestellt, dass die `hook.wrap_tape()` Methode um Funktionen des Bandobjekts herum, wie`push_tape()`,,`pop_tape()`,`gradient()`,,,, die Writer des SageMaker Debuggers einrichtet und Tensoren speichert, die als Eingabe für `gradient()` (trainierbare Variablen und Verlust) und Ausgabe von `gradient()` (Gradienten) bereitgestellt werden. **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 der `sagemaker-debugger` Hook zum Erstellen von Hooks und Speichern von Tensoren APIs bietet, 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.