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.
# SageMaker Amazon-Debugger
Debuggen Sie Modellausgabetensoren von Trainingsjobs für maschinelles Lernen in Echtzeit und erkennen Sie nicht konvergierende Probleme mit Amazon Debugger. SageMaker
## Funktionen von Amazon SageMaker Debugger
Bei einem Trainingsjob für Machine Learning (ML) können Probleme auftreten, wie z. B. eine Überanpassung, gesättigte Aktivierungsfunktionen und verschwindende Farbverläufe, die die Modellleistung beeinträchtigen können.
SageMaker Der Debugger bietet Tools zum Debuggen von Trainingsaufgaben und zum Beheben solcher Probleme, um die Leistung Ihres Modells zu verbessern. Der Debugger bietet auch Tools, mit denen Warnmeldungen gesendet werden können, wenn Trainingsanomalien festgestellt werden, Maßnahmen zur Behebung der Probleme ergriffen und die Hauptursache dafür identifiziert werden können, indem gesammelte Metriken und Tensoren visualisiert werden.
SageMaker Der Debugger unterstützt die Frameworks Apache MXNet, PyTorch TensorFlow, und. XGBoost Weitere Hinweise zu verfügbaren Frameworks und Versionen, die von SageMaker Debugger unterstützt werden, finden Sie unter. [Unterstützte Frameworks und Algorithmen](debugger-supported-frameworks.md)
![\[Überblick über die Funktionsweise von Amazon SageMaker Debugger.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-main.png)
Der High-Level-Debugger-Workflow sieht wie folgt aus:
1. Ändern Sie Ihr Trainingsskript bei Bedarf mit dem `sagemaker-debugger` Python-SDK.
1. Konfigurieren Sie einen SageMaker Trainingsjob mit SageMaker Debugger.
+ Konfigurieren Sie mit der SageMaker AI Estimator API (für Python SDK).
+ Konfigurieren Sie mithilfe der SageMaker [`CreateTrainingJob`AI-Anfrage (für Boto3 oder CLI](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-createtrainingjob-api.html)).
+ Konfigurieren Sie [benutzerdefinierte Trainingscontainer](debugger-bring-your-own-container.md) mit SageMaker Debugger.
1. Starten Sie einen Trainingsjob und überwachen Sie Trainingsprobleme in Echtzeit.
+ [Liste der in den Debugger integrierten Regeln](debugger-built-in-rules.md).
1. Erhalten Sie Benachrichtigungen und ergreifen Sie umgehend Maßnahmen gegen die Trainingsprobleme.
+ Empfangen Sie SMS und E-Mails und beenden Sie Trainingsjobs, wenn Trainingsprobleme festgestellt werden[Integrierte Debugger-Aktionen für Regeln verwenden](debugger-built-in-actions.md).
+ Richten Sie Ihre eigenen Aktionen mit [Amazon CloudWatch Events ein und AWS Lambda](debugger-cloudwatch-lambda.md).
1. Erkunden Sie eine eingehende Analyse der Trainingsprobleme.
+ Informationen zum Debuggen von Modellausgabetensoren finden Sie unter [Visualisieren Sie die Debugger-Ausgabetensoren in TensorBoard](debugger-enable-tensorboard-summaries.md).
1. Beheben Sie die Probleme, berücksichtigen Sie die Vorschläge des Debuggers und wiederholen Sie die Schritte 1–5, bis Sie Ihr Modell optimiert und die Zielgenauigkeit erreicht haben.
Das SageMaker Debugger-Entwicklerhandbuch führt Sie durch die folgenden Themen.
**Topics**
+ [Funktionen von Amazon SageMaker Debugger](#debugger-features)
+ [Unterstützte Frameworks und Algorithmen](debugger-supported-frameworks.md)
+ [Amazon SageMaker Debugger-Architektur](debugger-how-it-works.md)
+ [Debugger-Tutorials](debugger-tutorial.md)
+ [Debuggen von Trainingsjobs mit Amazon SageMaker Debugger](debugger-debug-training-jobs.md)
+ [Liste der in den Debugger integrierten Regeln](debugger-built-in-rules.md)
+ [Benutzerdefinierte Regeln mithilfe der Debugger-Clientbibliothek erstellen](debugger-custom-rules.md)
+ [Verwenden Sie den Debugger mit benutzerdefinierten Trainingscontainern](debugger-bring-your-own-container.md)
+ [Debugger mithilfe SageMaker der API konfigurieren](debugger-createtrainingjob-api.md)
+ [Amazon SageMaker Debugger-Referenzen](debugger-reference.md)
# Unterstützte Frameworks und Algorithmen
Die folgende Tabelle zeigt SageMaker KI-Frameworks und Algorithmen für maschinelles Lernen, die von Debugger unterstützt werden.
|
|
| **SageMaker AI-supported frameworks and algorithms** | **Debugging output tensors** |
| --- |--- |
| [TensorFlow](https://sagemaker.readthedocs.io/en/stable/using_tf.html) | [AWS TensorFlow Deep-Learning-Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) 1.15.4 oder höher |
| [PyTorch](https://sagemaker.readthedocs.io/en/stable/using_pytorch.html) | [AWS PyTorch Deep-Learning-Container 1.5.0](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) oder höher |
| [MXNet](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html) | [AWS MXNet Deep-Learning-Container](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) 1.6.0 oder höher |
| [XGBoost](https://sagemaker.readthedocs.io/en/stable/frameworks/xgboost/using_xgboost.html) | 1.0-1, 1.2-1, 1.3-1 |
| [SageMaker Generischer KI-Schätzer](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) | [Benutzerdefinierte Trainingscontainer](debugger-bring-your-own-container.md) (verfügbar für TensorFlow, PyTorch MXNet, und XGBoost mit manueller Hook-Registrierung) |
+ **Ausgabetensoren debuggen** – Verfolgen und debuggen Sie Modellparameter wie Gewichte, Gradienten, Verzerrungen und Skalarwerte Ihres Trainingsjobs. Verfügbare Deep-Learning-Frameworks sind Apache MXNet TensorFlow PyTorch,, und XGBoost.
**Wichtig**
Für das TensorFlow Framework mit Keras lehnt SageMaker Debugger die Unterstützung von Debugging-Modellen ab, die mit den `tf.keras` Modulen von 2.6 und höher erstellt wurden. TensorFlow [Dies ist auf wichtige Änderungen zurückzuführen, die in der Versionshinweise zu 2.6.0 angekündigt wurden. TensorFlow ](https://github.com/tensorflow/tensorflow/releases/tag/v2.6.0) Anweisungen zum Aktualisieren Ihres Training-Scripts finden Sie unter [Passen Sie Ihr Trainingsskript TensorFlow an](debugger-modify-script-tensorflow.md).
**Wichtig**
Ab PyTorch Version 1.12.0 und höher verbietet SageMaker Debugger die Unterstützung von Debugging-Modellen ohne Codeänderung.
Dies ist auf grundlegende Änderungen zurückzuführen, die dazu führen SageMaker , dass der Debugger die Funktionalität beeinträchtigt. `torch.jit` Anweisungen zum Aktualisieren Ihres Training-Scripts finden Sie unter [Passen Sie Ihr PyTorch Trainingsskript an](debugger-modify-script-pytorch.md).
Wenn das Framework oder der Algorithmus, den Sie trainieren und debuggen möchten, nicht in der Tabelle aufgeführt ist, gehen Sie zum [AWS Diskussionsforum](https://forums.aws.amazon.com/) und hinterlassen Sie Feedback zum SageMaker Debugger.
## AWS-Regionen
Amazon SageMaker Debugger ist in allen Regionen verfügbar, in denen Amazon SageMaker AI im Einsatz ist, mit Ausnahme der folgenden Region.
+ Asien-Pazifik (Jakarta): `ap-southeast-3`
Um herauszufinden, ob Amazon SageMaker AI in Ihrem Betrieb ist AWS-Region, besuchen Sie [AWS Regional Services](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/).
## Verwenden Sie den Debugger mit benutzerdefinierten Trainingscontainern
Bringen Sie Ihre Schulungscontainer in die SageMaker KI und gewinnen Sie mithilfe von Debugger Einblicke in Ihre Schulungsaufgaben. Maximieren Sie Ihre Arbeitseffizienz, indem Sie Ihr Modell auf Amazon-EC2-Instances mithilfe der Überwachungs- und Debugging-Funktionen optimieren.
Weitere Informationen dazu, wie Sie Ihren Trainingscontainer mit der `sagemaker-debugger` Client-Bibliothek erstellen, in die Amazon Elastic Container Registry (Amazon ECR) übertragen und überwachen und debuggen können, finden Sie unter [Verwenden Sie den Debugger mit benutzerdefinierten Trainingscontainern](debugger-bring-your-own-container.md).
## Open-Source-Repositorien für Debugger GitHub
Debugger APIs werden über das SageMaker Python-SDK bereitgestellt und sind darauf ausgelegt, Debugger-Hook- und Regelkonfigurationen für die SageMaker KI [ CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)- und [ DescribeTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html)API-Operationen zu erstellen. Die `sagemaker-debugger` Client-Bibliothek bietet Tools zum Registrieren von *Hooks* und zum Zugreifen auf die Trainingsdaten über ihr *Test-Feature* sowie über ihre flexiblen und leistungsstarken API-Operationen. Es unterstützt die Frameworks für maschinelles Lernen TensorFlow PyTorch MXNet,, und XGBoost auf Python 3.6 und höher.
Direkte Ressourcen zum Debugger und zu `sagemaker-debugger` API-Vorgängen finden Sie in den folgenden Blogbeiträgen:
+ [Die Amazon SageMaker Python SDK-Dokumentation](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_debugger.html)
+ [Das Amazon SageMaker Python SDK — Debugger APIs](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html)
+ [Die `sagemaker-debugger` Python SDK-Dokumentation](https://sagemaker-debugger.readthedocs.io/en/website/index.html) für [die Amazon SageMaker Debugger Open-Source-Clientbibliothek](https://github.com/awslabs/sagemaker-debugger#amazon-sagemaker-debugger)
+ [Das `sagemaker-debugger` PyPI](https://pypi.org/project/smdebug/)
Wenn Sie das SDK for Java zur Durchführung von SageMaker Trainingsaufgaben verwenden und den Debugger konfigurieren möchten APIs, finden Sie in den folgenden Referenzen weitere Informationen:
+ [SageMaker Amazon-Debugger APIs](debugger-reference.md#debugger-apis)
+ [Debugger mithilfe SageMaker der API konfigurieren](debugger-createtrainingjob-api.md)
# Amazon SageMaker Debugger-Architektur
In diesem Thema erhalten Sie einen allgemeinen Überblick über den Amazon SageMaker Debugger-Workflow.
Der Debugger unterstützt Profiling-Funktionen zur *Leistungsoptimierung*, um Rechenprobleme wie Systemengpässe und Unterauslastung zu identifizieren und die Auslastung der Hardwareressourcen in großem Umfang zu optimieren.
Die Debugging-Funktionalität des Debuggers für die *Modelloptimierung* dient der Analyse nicht konvergierender Trainingsprobleme, die auftreten können, bei gleichzeitiger Minimierung der Verlustfunktionen mithilfe von Optimierungsalgorithmen, wie z. B. dem Gradientenabstieg und seinen Variationen.
Das folgende Diagramm zeigt die Architektur von SageMaker Debugger. Debugger analysiert Ihren Trainingsjob anhand der Blöcke mit fetten Grenzlinien.
![\[Überblick über die Funktionsweise von Amazon SageMaker Debugger.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger_new_diagram.png)
Debugger speichert die folgenden Daten aus Ihren Trainingsjobs in Ihrem gesicherten Amazon-S3-Bucket:
+ **Ausgabetensoren** – Sammlungen von Skalaren und Modellparametern, die während des Trainings von ML-Modellen während der Vorwärts- und Rückwärtsläufe kontinuierlich aktualisiert werden. Die Ausgabetensoren umfassen Skalarwerte (Genauigkeit und Verlust) und Matrizen (Gewichte, Gradienten, Eingabe- und Ausgabeschichten).
**Anmerkung**
Standardmäßig überwacht und debuggt der Debugger SageMaker Trainingsjobs, ohne dass Debugger-spezifische Parameter in AI-Schätzern konfiguriert sind. SageMaker Der Debugger erfasst alle 500 Millisekunden Systemmetriken und alle 500 Schritte grundlegende Ausgabetensoren (skalare Ausgaben wie Verlust und Genauigkeit). Außerdem wird die `ProfilerReport` Regel ausgeführt, um die Systemmetriken zu analysieren und das Studio Debugger Insights-Dashboard und einen Profilerstellungsbericht zusammenzufassen. Debugger speichert die Ausgabedaten in Ihrem gesicherten Amazon-S3-Bucket.
Die integrierten Debuger-Regeln werden auf Verarbeitungscontainern ausgeführt, die darauf ausgelegt sind, Modelle für Machine Learning zu bewerten, indem sie die in Ihrem S3-Bucket gesammelten Trainingsdaten verarbeiten (siehe [Prozessdaten und Modelle auswerten](https://docs.aws.amazon.com//sagemaker/latest/dg/processing-job.html)). Die integrierten Regeln werden vollständig vom Debugger verwaltet. Sie können auch eigene, auf Ihr Modell zugeschnittene Regeln erstellen, um auf Probleme zu achten, die Sie überwachen möchten.
# Debugger-Tutorials
Die folgenden Themen führen Sie durch Tutorials von den Grundlagen bis hin zu fortgeschrittenen Anwendungsfällen für die Überwachung, Profilerstellung und das Debuggen von SageMaker-Trainingsaufträgen mit Debugger. Lernen Sie die Debugger-Funktionen kennen und erfahren Sie, wie Sie mithilfe des Debuggers Ihre Machine-Learning-Modelle effizient debuggen und verbessern können.
**Topics**
+ [Debugger-Tutorial-Videos](debugger-videos.md)
+ [Debugger-Beispiel-Notebooks](debugger-notebooks.md)
+ [Debugger: erweiterte Demos und Visualisierung](debugger-visualization.md)
# Debugger-Tutorial-Videos
Die folgenden Videos bieten einen Überblick über die Funktionen von Amazon SageMaker Debugger mithilfe von SageMaker Studio- und SageMaker AI-Notebook-Instances.
**Topics**
+ [Debuggen von Modellen mit Amazon SageMaker Debugger in Studio Classic](#debugger-video-get-started)
+ [Tiefer Einblick in Amazon SageMaker Debugger und SageMaker AI-Modellmonitor](#debugger-video-dive-deep)
## Debuggen von Modellen mit Amazon SageMaker Debugger in Studio Classic
*Julien Simon, AWS Technischer Evangelist \$1 Dauer: 14 Minuten 17 Sekunden*
Dieses Tutorial-Video zeigt, wie Sie Amazon SageMaker Debugger verwenden, um Debugging-Informationen aus einem Trainingsmodell zu erfassen und zu überprüfen. Das in diesem Video verwendete Beispiel-Trainingsmodell ist ein einfaches neuronales Faltungsnetzwerk (CNN), das auf Keras mit Backend basiert. TensorFlow SageMaker KI in einem TensorFlow Framework und Debugger ermöglichen es Ihnen, mithilfe des Trainingsskripts direkt einen Schätzer zu erstellen und den Trainingsjob zu debuggen.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/MqPdTj0Znwg)
Sie finden das Beispiel-Notebook im Video in diesem vom Autor bereitgestellten [Studio-Demo-Repository](https://gitlab.com/juliensimon/amazon-studio-demos/-/tree/master). Sie müssen die `debugger.ipynb` Notebook-Datei und das `mnist_keras_tf.py` Trainingsskript in Ihr SageMaker Studio oder eine SageMaker Notebook-Instance klonen. Nachdem Sie die beiden Dateien geklont haben, geben Sie den Pfad `keras_script_path` zur `mnist_keras_tf.py`-Datei im `debugger.ipynb`-Notebook an. Wenn Sie die beiden Dateien im selben Verzeichnis geklont haben, legen Sie sie als `keras_script_path = "mnist_keras_tf.py"` fest.
## Tiefer Einblick in Amazon SageMaker Debugger und SageMaker AI-Modellmonitor
*Julien Simon, AWS Technischer Evangelist \$1 Dauer: 44 Minuten 34 Sekunden*
In dieser Videositzung werden die erweiterten Funktionen von Debugger und SageMaker Model Monitor vorgestellt, mit denen Sie die Produktivität und Qualität Ihrer Modelle steigern können. Zunächst zeigt dieses Video, wie Sie Trainingsprobleme erkennen und beheben, Tensoren visualisieren und Modelle mit Debugger verbessern können. Als Nächstes, um 22:41 Uhr, zeigt das Video, wie Sie mithilfe von SageMaker AI Model Monitor Modelle in der Produktion überwachen und Vorhersageprobleme wie fehlende Funktionen oder Datenabweichungen identifizieren können. Schließlich bietet es Tipps zur Kostenoptimierung, sodass Sie Ihr Machine-Learning-Budget optimal nutzen können.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/0zqoeZxakOI)
Sie finden das Beispiel-Notebook im Video [ in diesem vom Autor bereitgestellten AWS Dev Days 2020 repository](https://gitlab.com/juliensimon/awsdevdays2020/-/tree/master/mls1).
# Debugger-Beispiel-Notebooks
[SageMaker Beispiel-Notebooks für Debugger](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/) finden Sie im [amazon-sagemaker-examplesaws/-Repository](https://github.com/aws/amazon-sagemaker-examples). Die Debugger-Beispiel-Notebooks führen Sie durch grundlegende bis fortgeschrittene Anwendungsfälle von Trainingsaufträge zum Debuggen und Profilieren.
Wir empfehlen, dass Sie die Beispiel-Notebooks auf SageMaker Studio oder einer SageMaker Notebook-Instance ausführen, da die meisten Beispiele für Schulungsaufgaben im SageMaker KI-Ökosystem konzipiert sind, einschließlich Amazon EC2, Amazon S3 und Amazon SageMaker Python SDK.
Um das Beispiel-Repository in SageMaker Studio zu klonen, folgen Sie den Anweisungen auf [Amazon SageMaker Studio Tour](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-studio-end-to-end.html).
**Wichtig**
Um die neuen Debugger-Funktionen verwenden zu können, müssen Sie das SageMaker Python-SDK und die `SMDebug` Client-Bibliothek aktualisieren. Führen Sie in Ihrem IPython-Kernel, Jupyter Notebook oder Ihrer JupyterLab Umgebung den folgenden Code aus, um die neuesten Versionen der Bibliotheken zu installieren und den Kernel neu zu starten.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Debugger-Beispiel-Notebooks für die Profilierung von Trainingsjobs
Die folgende Liste enthält Beispiel-Notebooks für Debugger, in denen die Anpassungsfähigkeit von Debugger zur Überwachung und Profilierung von Trainingsaufträgen für verschiedene Modelle, Datensätze und Frameworks für Machine Learning vorgestellt wird.
| Notebook-Titel | Framework | Modell | Datensatz | Description |
| --- | --- | --- | --- | --- |
| [Amazon SageMaker Debugger Profiling-Datenanalyse](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/debugger_interactive_analysis_profiling/interactive_analysis_profiling_data.html) | TensorFlow | Keras 50 ResNet | Cifar-10 | Dieses Notizbuch bietet eine Einführung in die interaktive Analyse von Profildaten, die vom Debugger erfasst SageMaker wurden. Erkunden Sie den vollen Funktionsumfang der `SMDebug` interaktiven Analysetools. |
| [Profiltraining für maschinelles Lernen mit Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_nlp_sentiment_analysis/sentiment-analysis-tf-distributed-training-bringyourownscript.html) | TensorFlow | Neuronales 1-D-Faltungsnetzwerk | IMDB-Datensatz | Profilieren Sie ein TensorFlow 1-D-CNN für die Stimmungsanalyse von IMDB-Daten, die aus Filmkritiken bestehen, die als positiv oder negativ eingestuft wurden. Sehen Sie sich den Studio Debugger Einsichten und den Bericht zur Debugger-Profilerstellung an. |
| [Profilerstellung: TensorFlow ResNet Modelltraining mit verschiedenen verteilten Trainingseinstellungen](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_profiling) | TensorFlow | ResNet50 | Cifar-10 | Führen Sie TensorFlow Trainingsjobs mit verschiedenen verteilten Trainingseinstellungen aus, überwachen Sie die Auslastung der Systemressourcen und erstellen Sie mithilfe des Debuggers ein Profil der Modellleistung. |
| [ PyTorch ResNet Modelltraining mit verschiedenen verteilten Trainingseinstellungen zur Profilerstellung](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_profiling) | PyTorch | ResNet50 | Cifar-10 | Führen Sie PyTorch Trainingsjobs mit verschiedenen verteilten Trainingseinstellungen aus, überwachen Sie die Auslastung der Systemressourcen und erstellen Sie mithilfe des Debuggers ein Profil der Modellleistung. |
## Debugger-Beispiel-Notebooks zur Analyse von Modellparametern
Die folgende Liste enthält Beispiel-Notebooks für Debugger, in denen die Anpassungsfähigkeit von Debugger zum Debuggen von Trainingsaufträge für verschiedene Modelle, Datensätze und Frameworks für Machine Learning vorgestellt wird.
| Notebook-Titel | Framework | Modell | Datensatz | Description |
| --- | --- | --- | --- | --- |
| [Amazon SageMaker Debugger — Integrierte Regel verwenden](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_builtin_rule) | TensorFlow | Konvolutionelles neuronales Netzwerk | MINST | Verwenden Sie die integrierten Regeln von Amazon SageMaker Debugger zum Debuggen eines TensorFlow Modells. |
| [Amazon SageMaker Debugger — Tensorflow 2.1](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow2) | TensorFlow | ResNet50 | Cifar-10 | Verwenden Sie die Amazon SageMaker Debugger-Hook-Konfiguration und die integrierten Regeln zum Debuggen eines Modells mit dem Tensorflow 2.1-Framework. |
| [Visualisieren von Debugging-Tensoren beim Training MXNet](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_plot) | MXNet | Neuronales Faltungsnetzwerk von Gluon | Mode MNIST | Führen Sie einen Trainingsjob aus und konfigurieren Sie den SageMaker Debugger so, dass er alle Tensoren aus diesem Job speichert, und visualisieren Sie diese Tensoren dann in einem Notizbuch. |
| [Spot-Training mit Amazon SageMaker Debugger aktivieren](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_spot_training) | MXNet | Neuronales Faltungsnetzwerk von Gluon | Mode MNIST | Erfahren Sie, wie der Debugger Tensordaten aus einem Trainingsauftrag auf einer Spot-Instance sammelt und wie Sie die integrierten Debuger-Regeln mit verwaltetem Spot-Training verwenden. |
| [Erläutern Sie mit Amazon SageMaker Debugger ein XGBoost Modell, das das Einkommen einer Person vorhersagt](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/xgboost_census_explanations/xgboost-census-debugger-rules.html) | XGBoost | XGBoost Regression | [Erwachsenen-Volkszählung Datensatz](https://archive.ics.uci.edu/ml/datasets/adult) | Erfahren Sie, wie Sie den Debugger-Hook und die integrierten Regeln zum Sammeln und Visualisieren von Tensordaten aus einem XGBoost Regressionsmodell verwenden, z. B. Verlustwerte, Merkmale und SHAP-Werte. |
Erweiterte Visualisierungen von Modellparametern und Anwendungsfällen finden Sie im nächsten Thema unter [Debugger: erweiterte Demos und Visualisierung](debugger-visualization.md).
# Debugger: erweiterte Demos und Visualisierung
Die folgenden Demos führen Sie durch erweiterte Anwendungsfälle und Visualisierungsskripten mit Debugger.
**Topics**
+ [Modelle mit Amazon SageMaker Experiments und Debugger trainieren und beschneiden](#debugger-visualization-video-model-pruning)
+ [[Verwenden des SageMaker Debuggers zur Überwachung des Modelltrainings mit Convolutional Autoencoder](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/autoencoder_mnist/autoencoder_mnist.html)](#debugger-visualization-autoencoder_mnist)
+ [[Verwendung des SageMaker Debuggers zur Überwachung der Aufmerksamkeit beim Training mit BERT-Modellen](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/bert_attention_head_view/bert_attention_head_view.html)](#debugger-visualization-bert_attention_head_view)
+ [[Verwenden von SageMaker Debugger zur Visualisierung von Klassenaktivierungskarten in neuronalen Faltungsnetzen () CNNs](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/cnn_class_activation_maps/cnn_class_activation_maps.html)](#debugger-visualization-cnn_class_activation_maps)
## Modelle mit Amazon SageMaker Experiments und Debugger trainieren und beschneiden
*Dr. Nathalie Rauschmayr, AWS angewandte Wissenschaftlerin \$1 Dauer: 49 Minuten 26 Sekunden*
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/Tnv6HsT1r4I)
Finden Sie heraus, wie Amazon SageMaker Experiments und Debugger die Verwaltung Ihrer Schulungsjobs vereinfachen können. Amazon SageMaker Debugger bietet einen transparenten Einblick in Trainingsjobs und speichert Trainingsmetriken in Ihrem Amazon S3 S3-Bucket. SageMaker Experiments ermöglicht es Ihnen, die Trainingsinformationen über SageMaker Studio als *Tests* aufzurufen, und unterstützt die Visualisierung der Trainingsaufgabe. Dies hilft Ihnen, die Modellqualität zu erhalten und gleichzeitig weniger wichtige Parameter basierend auf dem Prioritätsrang zu reduzieren.
In diesem Video wird eine Technik zum *Beschneiden von Modellen* demonstriert, mit der ResNet bereits trainierte AlexNet Modelle leichter und erschwinglicher werden und gleichzeitig hohe Standards für die Modellgenauigkeit eingehalten werden.
SageMaker AI Estimator trainiert die vom PyTorch Modellzoo bereitgestellten Algorithmen in einem AWS Deep Learning Containers mit PyTorch Framework, und Debugger extrahiert Trainingsmetriken aus dem Trainingsprozess.
Das Video zeigt auch, wie Sie eine benutzerdefinierte Debugger-Regel einrichten, um die Genauigkeit eines bereinigten Modells zu überwachen, ein CloudWatch Amazon-Ereignis und eine AWS Lambda Funktion auszulösen, wenn die Genauigkeit einen Schwellenwert erreicht, und den Bereinigungsprozess automatisch zu stoppen, um redundante Iterationen zu vermeiden.
Die Lernziele sind wie folgt:
+ Erfahren Sie, wie Sie mithilfe von SageMaker KI das Training von ML-Modellen beschleunigen und die Modellqualität verbessern können.
+ Erfahren Sie, wie Sie Trainingsiterationen mit SageMaker Experimenten verwalten können, indem Sie Eingabeparameter, Konfigurationen und Ergebnisse automatisch erfassen.
+ Erfahren Sie, wie Debugger den Trainingsprozess transparent macht, indem automatisch Echtzeit-Tensordaten von Metriken wie Gewichten, Gradienten und Aktivierungsausgaben von Convolutional Neural Networks erfasst werden.
+ Wird verwendet CloudWatch , um Lambda auszulösen, wenn der Debugger Probleme erkennt.
+ Meistern Sie den SageMaker Trainingsprozess mithilfe von SageMaker Experimenten und Debugger.
Die in diesem Video verwendeten Notizbücher und Schulungsskripte finden Sie unter [SageMaker Debugger PyTorch Iterative](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_iterative_model_pruning) Model Pruning.
Die folgende Abbildung zeigt, wie der iterative Modellbereinigungsprozess die Größe von reduziert, AlexNet indem die 100 Filter mit der geringsten Signifikanz auf der Grundlage ihrer Rangfolge, bewertet anhand von Aktivierungsausgaben und Gradienten, herausgeschnitten werden.
Der Beschneidungsprozess reduzierte die anfänglichen 50 Millionen Parameter auf 18 Millionen. Außerdem wurde die geschätzte Modellgröße von 201 MB auf 73 MB reduziert.
![\[Ein Bild, das Visualisierungen der Modellschnittausgabe enthält\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-model-pruning-results-alexnet.gif)
Sie müssen auch die Modellgenauigkeit verfolgen. Die folgende Abbildung zeigt, wie Sie den Modellbereinigungsprozess grafisch darstellen können, um Änderungen der Modellgenauigkeit auf der Grundlage der Anzahl der Parameter in SageMaker Studio zu visualisieren.
![\[Ein Bild der Tensorvisualisierung mithilfe des Debuggers in Studio SageMaker\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-model-pruning-studio.png)
Wählen Sie in SageMaker Studio die Registerkarte **Experimente**, wählen Sie eine Liste von Tensoren aus, die vom Debugger während des Bereinigungsvorgangs gespeichert wurden, und erstellen Sie dann einen Bereich mit der Liste der **Testkomponenten**. Wählen Sie alle zehn Iterationen aus, und wählen Sie **Diagramm hinzufügen**, um ein **Testkomponenten-Diagramm** zu erstellen. Nachdem Sie sich für ein Modell für die Bereitstellung entschieden haben, wählen Sie die Testkomponente aus und wählen Sie ein Menü, um eine Aktion auszuführen, oder wählen Sie **Modell bereitstellen**.
**Anmerkung**
Um ein Modell mithilfe des folgenden Notebook-Beispiels über SageMaker Studio bereitzustellen, fügen Sie am Ende der `train` Funktion im `train.py` Skript eine Zeile hinzu.
```
# In the train.py script, look for the train function in line 58.
def train(epochs, batch_size, learning_rate):
...
print('acc:{:.4f}'.format(correct/total))
hook.save_scalar("accuracy", correct/total, sm_metric=True)
# Add the following code to line 128 of the train.py script to save the pruned models
# under the current SageMaker Studio model directory
torch.save(model.state_dict(), os.environ['SM_MODEL_DIR'] + '/model.pt')
```
## [Verwenden des SageMaker Debuggers zur Überwachung des Modelltrainings mit Convolutional Autoencoder](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/autoencoder_mnist/autoencoder_mnist.html)
Dieses Notizbuch zeigt, wie SageMaker Debugger Tensoren aus einem unbeaufsichtigten (oder selbstüberwachten) Lernprozess anhand eines MNIST-Bilddatensatzes mit handgeschriebenen Zahlen visualisiert.
Das Trainingsmodell in diesem Notizbuch ist ein Convolutional-Autoencoder mit dem Framework. MXNet Der Convolutional Autoencoder verfügt über ein flaschenhalsförmiges Convolutional Neural Network, das aus einem Encoder-Teil und einem Decoder-Teil besteht.
Der Encoder in diesem Beispiel verfügt über zwei Convolution-Ebenen, um eine komprimierte Darstellung (latente Variablen) der Eingabebilder zu erzeugen. In diesem Fall erzeugt der Encoder eine latente Variable der Größe (1, 20) aus einem Originaleingabebild der Größe (28, 28) und reduziert die Größe der Daten für das Training um das 40fache.
Der Decoder verfügt über zwei *Deconvolutional*-Schichten und stellt sicher, dass die latenten Variablen wichtige Informationen beibehalten, indem Ausgabebilder rekonstruiert werden.
Der Convolutional Encoder betreibt Clustering-Algorithmen mit kleinerer Eingabedatengröße und sowie die Leistung von Clustering-Algorithmen wie k-Means, k-NN und t-Distributed Stochastic Neighbor Embedding (t-SNE).
Dieses Notebook-Beispiel veranschaulicht, wie die latenten Variablen mithilfe von visualisiert werden, wie in der folgenden Animation gezeigt. Es zeigt auch, wie der t-SNE-Algorithmus die latenten Variablen in zehn Cluster klassifiziert und in einen zweidimensionalen Raum projiziert. Das Streudiagramm-Farbschema auf der rechten Seite des Bildes spiegelt die wahren Werte wider, um zu zeigen, wie gut das BERT-Modell und der T-SNE-Algorithmus die latenten Variablen in die Cluster organisieren.
![\[Ein konzeptionelles Bild des Convolutional Autoencoders\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-cnn-autoencoder-plot.gif)
## [Verwendung des SageMaker Debuggers zur Überwachung der Aufmerksamkeit beim Training mit BERT-Modellen](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/bert_attention_head_view/bert_attention_head_view.html)
Bidirectional Encode Representations from Transformers (BERT) ist ein Sprachrepräsentationsmodell. Wie der Name des Modells widerspiegelt, baut das BERT-Modell auf *Transferlernen* und *dem Transformer-Modell* für die Verarbeitung natürlicher Sprache (NLP) auf.
Das BERT-Modell ist vortrainiert für unbeaufsichtigte Aufgaben wie die Vorhersage fehlender Wörter in einem Satz oder die Vorhersage des nächsten Satzes, der natürlich einem vorherigen Satz folgt. Die Trainingsdaten enthalten 3,3 Milliarden Wörter (Tokens) englischen Textes, wie Wikipedia und elektronische Bücher. Als einfaches Beispiel kann das BERT-Modell den entsprechenden Verb-Tokens oder Pronomen-Tokens eines Subjekt-Tokens große *Aufmerksamkeit* schenken.
Das vortrainierte BERT-Modell kann mit einer zusätzlichen Ausgabeschicht verfeinert werden, um ein state-of-the-art Modelltraining bei NLP-Aufgaben wie automatisierten Antworten auf Fragen, Textklassifizierung und vielen anderen zu ermöglichen.
Der Debugger sammelt Tensoren aus dem Feinabstimmungsprozess. Im Kontext von NLP wird das Gewicht von Neuronen als *Aufmerksamkeit* bezeichnet.
Dieses Notizbuch zeigt, wie das [vortrainierte BERT-Modell aus dem GluonNLP-Modellzoo für den](https://gluon-nlp.mxnet.io/model_zoo/bert/index.html) Stanford Question and Answering-Datensatz verwendet wird und wie der SageMaker Debugger zur Überwachung des Trainingsjobs eingerichtet wird.
Das Plotten von *Aufmerksamkeitswerten* und einzelnen Neuronen in der Abfrage und Schlüsselvektoren kann helfen, Ursachen für falsche Modellvorhersagen zu identifizieren. Mit dem SageMaker KI-Debugger können Sie die Tensoren abrufen und die *Aufmerksamkeitskopf-Ansicht* während des Trainingsfortschritts in Echtzeit grafisch darstellen. So können Sie nachvollziehen, was das Modell gerade lernt.
Die folgende Animation zeigt die Aufmerksamkeitswerte der ersten 20 Eingabetokens für zehn Iterationen im Trainingsauftrag, der im Notebook-Beispiel bereitgestellt wird.
![\[Eine Animation der Aufmerksamkeitsergebnisse\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-attention_scores.gif)
## [Verwenden von SageMaker Debugger zur Visualisierung von Klassenaktivierungskarten in neuronalen Faltungsnetzen () CNNs](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/cnn_class_activation_maps/cnn_class_activation_maps.html)
Dieses Notizbuch zeigt, wie SageMaker Debugger verwendet wird, um Klassenaktivierungskarten für die Bilderkennung und -klassifizierung in neuronalen Faltungsnetzen zu zeichnen (). CNNs Beim Deep Learning ist ein *Convolutional Neural Network (CNN oder ConvNet) eine Klasse von tiefen neuronalen* Netzwerken, die am häufigsten zur Analyse visueller Bilder eingesetzt werden. Eine der Anwendungen, die die Klassenaktivierungskarten übernimmt, sind selbstfahrende Autos, die die sofortige Erkennung und Klassifizierung von Bildern wie Verkehrszeichen, Straßen und Hindernisse erfordern.
In diesem Notizbuch wird das PyTorch ResNet Modell anhand [des deutschen Verkehrszeichendatensatzes](http://benchmark.ini.rub.de/) trainiert, der mehr als 40 Klassen von verkehrsbezogenen Objekten und insgesamt mehr als 50.000 Bilder enthält.
![\[Eine Animation von CNN-Klassenaktivierungskarten\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-cnn-class-activation-maps.gif)
Während des Trainingsprozesses sammelt der SageMaker Debugger Tensoren, um die Klassenaktivierungskarten in Echtzeit darzustellen. Wie im animierten Bild gezeigt, hebt die Klassenaktivierungskarte (auch als *Saliency Map* bezeichnet) Regionen mit hoher Aktivierung in roter Farbe hervor.
Mithilfe von Tensoren, die von Debugger erfasst werden, können Sie visualisieren, wie sich die Aktivierungskarte während der Modelltraining entwickelt. Das Modell beginnt mit der Erkennung der Kante in der linken unteren Ecke zu Beginn des Trainingsauftrags. Im Laufe des Trainings verschiebt sich der Fokus in die Mitte und erkennt das Geschwindigkeitsbegrenzungszeichen, und das Modell prognostiziert das Eingabebild mit einem Konfidenzniveau von 97 % erfolgreich als Klasse 3, eine Klasse von Geschwindigkeitsbegrenzungszeichen von 60 km/h.
# Debuggen von Trainingsjobs mit Amazon SageMaker Debugger
Um Ihr Trainingsskript vorzubereiten und Trainingsjobs mit SageMaker Debugger auszuführen, um den Trainingsfortschritt des Modells zu debuggen, folgen Sie dem typischen zweistufigen Prozess: Ändern Sie Ihr Trainingsskript mit dem `sagemaker-debugger` Python-SDK und erstellen Sie einen SageMaker KI-Schätzer mit dem Python-SDK. SageMaker Gehen Sie die folgenden Themen durch, um zu erfahren, wie Sie die Debugging-Funktionalität von SageMaker Debugger verwenden können.
**Topics**
+ [Ihr Trainingsskript anpassen, um einen Hook zu registrieren](debugger-modify-script.md)
+ [Starten Sie Trainingsjobs mit dem Debugger mithilfe des SageMaker Python-SDK](debugger-configuration-for-debugging.md)
+ [SageMaker Interaktiver Debugger-Bericht für XGBoost](debugger-report-xgboost.md)
+ [Aktion im Zusammenhang mit Amazon SageMaker Debugger-Regeln](debugger-action-on-rules.md)
+ [Visualisieren Sie Amazon SageMaker Debugger-Ausgabetensoren in TensorBoard](debugger-enable-tensorboard-summaries.md)
# 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.
# Starten Sie Trainingsjobs mit dem Debugger mithilfe des SageMaker Python-SDK
Um einen SageMaker AI-Estimator mit SageMaker Debugger zu konfigurieren, verwenden Sie das [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) und geben Sie Debugger-spezifische Parameter an. Um die Debugging-Funktionalität vollständig nutzen zu können, müssen Sie drei Parameter konfigurieren: `debugger_hook_config`, `tensorboard_output_config`, und `rules`.
**Wichtig**
Bevor Sie die Schätzer-Fit-Methode erstellen und ausführen, um einen Trainingsauftrag zu starten, stellen Sie sicher, dass Sie Ihr Trainingsskript entsprechend den Anweisungen unter [Ihr Trainingsskript anpassen, um einen Hook zu registrieren](debugger-modify-script.md) anpassen.
## Konstruieren eines AI-Estimators mit Debugger-spezifischen Parametern SageMaker
Die Codebeispiele in diesem Abschnitt zeigen, wie ein SageMaker AI-Schätzer mit Debugger-spezifischen Parametern erstellt wird.
**Anmerkung**
Die folgenden Codebeispiele sind Vorlagen für die Erstellung der SageMaker KI-Framework-Schätzer und nicht direkt ausführbar. Sie müssen mit den nächsten Abschnitten fortfahren und die Debugger-spezifischen Parameter konfigurieren.
------
#### [ PyTorch ]
```
# An example of constructing a SageMaker AI PyTorch estimator
import boto3
import sagemaker
from sagemaker.pytorch import PyTorch
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
session=boto3.session.Session()
region=session.region_name
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
estimator=PyTorch(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.12.0",
py_version="py37",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ TensorFlow ]
```
# An example of constructing a SageMaker AI TensorFlow estimator
import boto3
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
session=boto3.session.Session()
region=session.region_name
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule()),
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=TensorFlow(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ MXNet ]
```
# An example of constructing a SageMaker AI MXNet estimator
import sagemaker
from sagemaker.mxnet import MXNet
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
estimator=MXNet(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.7.0",
py_version="py37",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ XGBoost ]
```
# An example of constructing a SageMaker AI XGBoost estimator
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
estimator=XGBoost(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.5-1",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ Generic estimator ]
```
# An example of constructing a SageMaker AI generic estimator using the XGBoost algorithm base image
import boto3
import sagemaker
from sagemaker.estimator import Estimator
from sagemaker import image_uris
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
region=boto3.Session().region_name
xgboost_container=sagemaker.image_uris.retrieve("xgboost", region, "1.5-1")
estimator=Estimator(
role=sagemaker.get_execution_role()
image_uri=xgboost_container,
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.m5.2xlarge",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
Konfigurieren Sie die folgenden Parameter, um den Debugger zu aktivieren SageMaker :
+ `debugger_hook_config`(ein Objekt von [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)) — Erforderlich, um währenddessen den Hook im angepassten Trainingsskript zu aktivieren[Ihr Trainingsskript anpassen, um einen Hook zu registrieren](debugger-modify-script.md), den SageMaker Trainingsstarter (Estimator) so zu konfigurieren, dass er Ausgabetensoren aus Ihrem Trainingsjob sammelt, und die Tensoren in Ihrem gesicherten S3-Bucket oder auf Ihrem lokalen Computer zu speichern. Wie Sie den `debugger_hook_config` Parameter konfigurieren können, erfahren Sie unter [SageMaker Debugger zum Speichern von Tensoren konfigurieren](debugger-configure-hook.md).
+ `rules`(eine Liste von [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule)Objekten) — Konfigurieren Sie diesen Parameter, um die integrierten SageMaker Debuger-Regeln zu aktivieren, die Sie in Echtzeit ausführen möchten. Bei den integrierten Regeln handelt es sich um Logiken, die den Trainingsfortschritt Ihres Modells automatisch debuggen und Trainingsprobleme finden, indem sie die in Ihrem gesicherten S3-Bucket gespeicherten Ausgabetensoren analysieren. Wie Sie den `rules` Parameter konfigurieren können, erfahren Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md). Eine vollständige Liste der integrierten Regeln für das Debuggen von Ausgabetensoren finden Sie unter [Debugger-Regel](debugger-built-in-rules.md#debugger-built-in-rules-Rule). Wenn Sie Ihre eigene Logik zur Erkennung von Ausbildungsproblemen erstellen möchten, siehe [Benutzerdefinierte Regeln mithilfe der Debugger-Clientbibliothek erstellen](debugger-custom-rules.md).
**Anmerkung**
Die integrierten Regeln sind nur in SageMaker Trainingsinstanzen verfügbar. Sie können sie nicht im lokalen Modus verwenden.
+ `tensorboard_output_config`(ein Objekt von [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.TensorBoardOutputConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.TensorBoardOutputConfig)) — Konfigurieren Sie den SageMaker Debugger so, dass er Ausgabetensoren im TensorBoard -kompatiblen Format sammelt und in Ihrem im Objekt angegebenen S3-Ausgabepfad speichert. `TensorBoardOutputConfig` Weitere Informationen hierzu finden Sie unter [Visualisieren Sie Amazon SageMaker Debugger-Ausgabetensoren in TensorBoard](debugger-enable-tensorboard-summaries.md).
**Anmerkung**
Der `tensorboard_output_config` muss mit dem `debugger_hook_config` Parameter konfiguriert werden. Dazu müssen Sie auch Ihr Trainingsskript anpassen, indem Sie den `sagemaker-debugger` Hook hinzufügen.
**Anmerkung**
SageMaker Der Debugger speichert Ausgabetensoren sicher in Unterordnern Ihres S3-Buckets. Das Format der standardmäßigen S3-Bucket-URI in Ihrem Konto lautet beispielsweise `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>///`. Es gibt zwei Unterordner, die von SageMaker Debugger erstellt wurden:, und. `debug-output` `rule-output` Wenn Sie den `tensorboard_output_config` Parameter hinzufügen, finden Sie auch den `tensorboard-output` Ordner.
In den folgenden Themen finden Sie weitere Beispiele für die detaillierte Konfiguration der Debugger-spezifischen Parameter.
**Topics**
+ [Konstruieren eines AI-Estimators mit Debugger-spezifischen Parametern SageMaker](#debugger-configuration-structure)
+ [SageMaker Debugger zum Speichern von Tensoren konfigurieren](debugger-configure-hook.md)
+ [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md)
+ [Deaktivieren Sie den Debugger](debugger-turn-off.md)
+ [SageMaker Nützliche AI-Estimator-Klassenmethoden für Debugger](debugger-estimator-classmethods.md)
# SageMaker Debugger zum Speichern von Tensoren konfigurieren
*Tensoren* sind Datensammlungen aktualisierter Parameter aus dem Rückwärts- und Vorwärtsdurchlauf jeder Trainingsiteration. SageMaker Der Debugger sammelt die Ausgabetensoren, um den Status eines Trainingsjobs zu analysieren. SageMaker Debugger [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)- und [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)API-Operationen bieten Methoden zum Gruppieren von Tensoren in *Sammlungen* und zum Speichern in einem Ziel-S3-Bucket. Die folgenden Themen enthalten die Verwendung der API-Operationen `CollectionConfig` und `DebuggerHookConfig`, gefolgt von Beispielen zur Verwendung des Debugger Hook zum Speichern, Zugreifen und Visualisieren von Ausgabetensoren.
Aktivieren Sie beim Erstellen eines SageMaker AI-Schätzers den SageMaker Debugger, indem Sie den Parameter angeben. `debugger_hook_config` Die folgenden Themen enthalten Beispiele für die Einrichtung von `debugger_hook_config` unter Verwendung der `CollectionConfig` und `DebuggerHookConfig` API-Operationen, um Tensoren aus Ihren Trainingsjobs zu ziehen und sie zu speichern.
**Anmerkung**
Nach der ordnungsgemäßen Konfiguration und Aktivierung speichert der SageMaker Debugger die Ausgabetensoren in einem Standard-S3-Bucket, sofern nicht anders angegeben. Das Format der standardmäßigen S3-Bucket-URI ist `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>//debug-output/`.
**Topics**
+ [Tensor-Sammlungen mithilfe der `CollectionConfig` API konfigurieren](debugger-configure-tensor-collections.md)
+ [Die `DebuggerHookConfig` API zum Speichern von Tensoren konfigurieren](debugger-configure-tensor-hook.md)
+ [Beispiel-Notebooks und Codebeispiele zur Konfiguration des Debugger-Hooks](debugger-save-tensors.md)
# Tensor-Sammlungen mithilfe der `CollectionConfig` API konfigurieren
Verwenden Sie den `CollectionConfig` API-Vorgang, um Tensorsammlungen zu konfigurieren. Debugger bietet vorgefertigte Tensorsammlungen, die eine Vielzahl von regulären Ausdrücken (Regex) von Parametern abdecken, wenn Debugger-unterstützte Deep-Learning-Frameworks und Algorithmen für Machine Learning verwendet werden. Fügen Sie, wie im folgenden Beispielcode gezeigt, die integrierten Tensorsammlungen hinzu, die Sie debuggen möchten.
```
from sagemaker.debugger import CollectionConfig
collection_configs=[
CollectionConfig(name="weights"),
CollectionConfig(name="gradients")
]
```
Die vorherigen Sammlungen haben den Debugger-Hook so eingerichtet, dass er die Tensoren alle 500 Schritte basierend auf dem `"save_interval"` Standardwert speichert.
Eine vollständige Liste der verfügbaren integrierten Debugger-Sammlungen finden Sie unter [Integrierte Debugger-Sammlungen](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#collection).
Wenn Sie die integrierten Sammlungen anpassen möchten, z. B. die Speicherintervalle und den Tensor-Regex ändern möchten, verwenden Sie die folgende `CollectionConfig` Vorlage, um die Parameter anzupassen.
```
from sagemaker.debugger import CollectionConfig
collection_configs=[
CollectionConfig(
name="tensor_collection",
parameters={
"key_1": "value_1",
"key_2": "value_2",
...
"key_n": "value_n"
}
)
]
```
Weitere Informationen zu verfügbaren Parameterschlüsseln finden Sie [CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable). Das folgende Codebeispiel zeigt beispielsweise, wie Sie die Speicherintervalle der Tensorsammlung „Verluste“ in verschiedenen Trainingsphasen anpassen können: Speicherverlust alle 100 Schritte in der Trainingsphase und Validierungsverlust alle 10 Schritte in der Validierungsphase.
```
from sagemaker.debugger import CollectionConfig
collection_configs=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
}
)
]
```
**Tipp**
Dieses Konfigurationsobjekt für die Tensorsammlung kann sowohl für Rule-API-Operationen als auch für [DebuggerHookConfig](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configure-hook.html#debugger-configure-tensor-hook)[Rule-API-Operationen](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-rules.html#debugger-built-in-rules-configuration-param-change) verwendet werden.
# Die `DebuggerHookConfig` API zum Speichern von Tensoren konfigurieren
Verwenden Sie die [DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html #sagemaker.debugger.DebuggerHookConfig)API, um ein `debugger_hook_config` Objekt mit dem `collection_configs` Objekt zu erstellen, das Sie im vorherigen Schritt erstellt haben.
```
from sagemaker.debugger import DebuggerHookConfig
debugger_hook_config=DebuggerHookConfig(
collection_configs=collection_configs
)
```
Der Debugger speichert die Ausgabetensoren für das Modelltraining im Standard-S3-Bucket. Das Format der standardmäßigen S3-Bucket-URI lautet `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>//debug-output/.`
Wenn Sie einen exakten S3-Bucket-URI angeben möchten, verwenden Sie das folgende Codebeispiel:
```
from sagemaker.debugger import DebuggerHookConfig
debugger_hook_config=DebuggerHookConfig(
s3_output_path="specify-uri"
collection_configs=collection_configs
)
```
Weitere Informationen finden Sie [DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
# Beispiel-Notebooks und Codebeispiele zur Konfiguration des Debugger-Hooks
Die folgenden Abschnitte enthalten Notebooks und Codebeispiele zur Verwendung des Debugger-Hooks zum Speichern, Zugreifen und Visualisieren von Ausgabetensoren.
**Topics**
+ [Beispiel-Notebooks für Tensorvisualisierungen](#debugger-tensor-visualization-notebooks)
+ [Speichern von Tensoren mit integrierten Debugger-Sammlungen](#debugger-save-built-in-collections)
+ [Speichern von Tensoren mit integrierten Debugger-Sammlungen](#debugger-save-modified-built-in-collections)
+ [Speichern von reduzierten Tensoren mit benutzerdefinierten Debugger-Sammlungen](#debugger-save-custom-collections)
## Beispiel-Notebooks für Tensorvisualisierungen
Die folgenden beiden Notebook-Beispiele zeigen die erweiterte Verwendung von Amazon SageMaker Debugger zur Visualisierung von Tensoren. Der Debugger bietet einen transparenten Einblick in das Training von Deep-Learning-Modellen.
+ [Interaktive Tensoranalyse in Studio Notebook mit SageMaker MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_analysis)
Dieses Notebook-Beispiel zeigt, wie gespeicherte Tensoren mit Amazon SageMaker Debugger visualisiert werden. Durch die Visualisierung der Tensoren können Sie leicht sehen, wie sich die Tensorwerte ändern, während Sie Deep-Learning-Algorithmen trainieren. Dieses Notizbuch beinhaltet eine Trainingsaufgabe mit einem schlecht konfigurierten neuronalen Netzwerk und verwendet Amazon SageMaker Debugger, um Tensoren, einschließlich Gradienten, Aktivierungsausgaben und Gewichtungen, zu aggregieren und zu analysieren. Das folgende Diagramm zeigt beispielsweise die Verteilung der Gradienten eines Convolutional Layers (faltenden Layers), bei dem ein Problem in Zusammenhang mit dem Verschwinden des Gradienten vorliegt.
![\[Ein Diagramm, das die Verteilung der Gradienten darstellt.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-vanishing-gradient.gif)
Dieses Notebooks veranschaulicht auch, wie eine gute anfängliche Hyperparametereinstellung den Trainingsprozess verbessert, indem die gleichen Tensorverteilungsdiagramme generiert werden.
+ [Visualisierung und Debuggen von Tensoren aus dem Modelltraining MXNet ](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_plot)
Dieses Notebook-Beispiel zeigt, wie Tensoren aus einem MXNet Gluon-Modell-Trainingsjob mit Amazon SageMaker Debugger gespeichert und visualisiert werden. Es zeigt, dass der Debugger so eingestellt ist, dass er alle Tensoren in einem Amazon S3 S3-Bucket speichert und ReLu Aktivierungsausgaben für die Visualisierung abruft. Die folgende Abbildung zeigt eine dreidimensionale Visualisierung der ReLu Aktivierungsausgaben. Im Hinblick auf das Farbschema bedeutet Blau, dass es sich um Werte nahe 0 handelt, und Gelb, dass die Werte nahe 1 sind.
![\[Eine Visualisierung der ReLU-Aktivierungsausgaben\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/tensorplot.gif)
In diesem Notizbuch `tensor_plot.py` dient die `TensorPlot` Klasse, aus der importiert wurde, der Darstellung neuronaler Faltungsnetzwerke (CNNs), die zweidimensionale Bilder als Eingaben verwenden. Das mit dem Notebook gelieferte `tensor_plot.py` Skript ruft mit Debugger Tensoren ab und visualisiert das CNN. Sie können dieses Notizbuch in SageMaker Studio ausführen, um die Tensorvisualisierung zu reproduzieren und Ihr eigenes neuronales Faltungsnetzmodell zu implementieren.
+ [Tensoranalyse in Echtzeit in einem Notebook mit SageMaker MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_realtime_analysis)
Dieses Beispiel führt Sie durch die Installation der erforderlichen Komponenten für die Ausgabe von Tensoren in einem SageMaker Amazon-Schulungsjob und die Verwendung der Debugger-API-Operationen, um während des Trainings auf diese Tensoren zuzugreifen. Ein Gluon-CNN-Modell wird mit dem Fashion MNIST-Datensatz trainiert. Während der Auftrag ausgeführt wird, werden Sie sehen, wie der Debugger die Aktivierungsausgaben der ersten Faltungsschicht aus jedem der 100 Batches abruft und sie visualisiert. Außerdem erfahren Sie, wie Sie Gewichte nach Abschluss der Arbeit visualisieren.
## Speichern von Tensoren mit integrierten Debugger-Sammlungen
Sie können integrierte Sammlungen von Tensoren mithilfe der `CollectionConfig` API verwenden und sie mithilfe der `DebuggerHookConfig` API speichern. Das folgende Beispiel zeigt, wie Sie die Standardeinstellungen der Debugger-Hook-Konfigurationen verwenden, um einen KI-Schätzer zu erstellen. SageMaker TensorFlow Sie können dies auch für MXNet PyTorch, und XGBoost Schätzer verwenden.
**Anmerkung**
Im folgenden Beispielcode ist der `s3_output_path` Parameter für `DebuggerHookConfig` optional. Wenn Sie ihn nicht angeben, speichert der Debugger die Tensoren unter`s3:///debug-output/`, wo dies der Standardausgabepfad für Trainingsjobs `` ist. SageMaker Beispiel:
```
"s3://sagemaker-us-east-1-111122223333/sagemaker-debugger-training-YYYY-MM-DD-HH-MM-SS-123/debug-output"
```
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import DebuggerHookConfig, CollectionConfig
# use Debugger CollectionConfig to call built-in collections
collection_configs=[
CollectionConfig(name="weights"),
CollectionConfig(name="gradients"),
CollectionConfig(name="losses"),
CollectionConfig(name="biases")
]
# configure Debugger hook
# set a target S3 bucket as you want
sagemaker_session=sagemaker.Session()
BUCKET_NAME=sagemaker_session.default_bucket()
LOCATION_IN_BUCKET='debugger-built-in-collections-hook'
hook_config=DebuggerHookConfig(
s3_output_path='s3://{BUCKET_NAME}/{LOCATION_IN_BUCKET}'.
format(BUCKET_NAME=BUCKET_NAME,
LOCATION_IN_BUCKET=LOCATION_IN_BUCKET),
collection_configs=collection_configs
)
# construct a SageMaker TensorFlow estimator
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-demo-job',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific hook argument below
debugger_hook_config=hook_config
)
sagemaker_estimator.fit()
```
Eine Liste der integrierten Debugger-Sammlungen finden Sie unter [Integrierte Debugger-Sammlungen](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#collection).
## Speichern von Tensoren mit integrierten Debugger-Sammlungen
Sie können die integrierten Debugger-Sammlungen mithilfe der `CollectionConfig` API-Operation ändern. Das folgende Beispiel zeigt, wie Sie die integrierte `losses` Sammlung optimieren und einen SageMaker KI-Schätzer erstellen können. TensorFlow Sie können dies auch für MXNet PyTorch, und XGBoost Schätzer verwenden.
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import DebuggerHookConfig, CollectionConfig
# use Debugger CollectionConfig to call and modify built-in collections
collection_configs=[
CollectionConfig(
name="losses",
parameters={"save_interval": "50"})]
# configure Debugger hook
# set a target S3 bucket as you want
sagemaker_session=sagemaker.Session()
BUCKET_NAME=sagemaker_session.default_bucket()
LOCATION_IN_BUCKET='debugger-modified-collections-hook'
hook_config=DebuggerHookConfig(
s3_output_path='s3://{BUCKET_NAME}/{LOCATION_IN_BUCKET}'.
format(BUCKET_NAME=BUCKET_NAME,
LOCATION_IN_BUCKET=LOCATION_IN_BUCKET),
collection_configs=collection_configs
)
# construct a SageMaker TensorFlow estimator
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-demo-job',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific hook argument below
debugger_hook_config=hook_config
)
sagemaker_estimator.fit()
```
Eine vollständige Liste der `CollectionConfig` Parameter finden Sie unter [Debugger-API CollectionConfig ](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk).
## Speichern von reduzierten Tensoren mit benutzerdefinierten Debugger-Sammlungen
Sie können auch eine reduzierte Anzahl an Tensoren anstelle des vollständigen Satzes von Tensoren speichern, um beispielsweise die in Ihrem Amazon-S3-Bucket gespeicherte Datenmenge zu verringern. Das folgende Beispiel zeigt, wie Sie die Debugger-Hook-Konfiguration ändern, um Zieltensoren zum Speichern anzugeben. Sie können dies für TensorFlow, MXNet PyTorch, und XGBoost Schätzer verwenden.
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import DebuggerHookConfig, CollectionConfig
# use Debugger CollectionConfig to create a custom collection
collection_configs=[
CollectionConfig(
name="custom_activations_collection",
parameters={
"include_regex": "relu|tanh", # Required
"reductions": "mean,variance,max,abs_mean,abs_variance,abs_max"
})
]
# configure Debugger hook
# set a target S3 bucket as you want
sagemaker_session=sagemaker.Session()
BUCKET_NAME=sagemaker_session.default_bucket()
LOCATION_IN_BUCKET='debugger-custom-collections-hook'
hook_config=DebuggerHookConfig(
s3_output_path='s3://{BUCKET_NAME}/{LOCATION_IN_BUCKET}'.
format(BUCKET_NAME=BUCKET_NAME,
LOCATION_IN_BUCKET=LOCATION_IN_BUCKET),
collection_configs=collection_configs
)
# construct a SageMaker TensorFlow estimator
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-demo-job',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific hook argument below
debugger_hook_config=hook_config
)
sagemaker_estimator.fit()
```
Eine vollständige Liste der `CollectionConfig` Parameter finden Sie unter [Debugger CollectionConfig](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk).
# So konfigurieren Sie integrierte Debugger-Regeln
In den folgenden Themen erfahren Sie, wie Sie die integrierten SageMaker Debuger-Regeln verwenden. Die integrierten Regeln von Amazon SageMaker Debugger analysieren Tensoren, die während des Trainings eines Modells emittiert werden. SageMaker AI Debugger bietet den `Rule` API-Betrieb, der den Fortschritt und die Fehler von Trainingsaufgaben überwacht, um den Erfolg des Trainings Ihres Modells sicherzustellen. Die Regeln können zum Beispiel erkennen, ob Gradienten zu groß oder zu klein werden, ob ein Modell zu stark oder zu stark trainiert wird und ob ein Trainingsauftrag nicht die Funktionsfähigkeit beeinträchtigt und verbessert. Eine vollständige Liste verfügbarer integrierter Regeln finden Sie unter [Liste der in den Debugger integrierten Regeln](debugger-built-in-rules.md).
**Topics**
+ [Integrierte Debugger-Regeln mit den Standard-Parametereinstellungen verwenden](debugger-built-in-rules-configuration.md)
+ [Integrierte Debugger-Regeln mit benutzerdefinierten Parameterwerten verwenden](debugger-built-in-rules-configuration-param-change.md)
+ [Beispiel-Notebooks und Codebeispiele zur Konfiguration von Debugger-Regeln](debugger-built-in-rules-example.md)
# Integrierte Debugger-Regeln mit den Standard-Parametereinstellungen verwenden
Um die integrierten Debugger-Regeln in einem Estimator anzugeben, müssen Sie ein Listenobjekt konfigurieren. Der folgende Beispielcode zeigt die grundlegende Struktur der Auflistung der integrierten Debugger-Regeln:
```
from sagemaker.debugger import Rule, rule_configs
rules=[
Rule.sagemaker(rule_configs.built_in_rule_name_1()),
Rule.sagemaker(rule_configs.built_in_rule_name_2()),
...
Rule.sagemaker(rule_configs.built_in_rule_name_n()),
... # You can also append more profiler rules in the ProfilerRule.sagemaker(rule_configs.*()) format.
]
```
Weitere Informationen zu Standardparameterwerten und Beschreibungen der integrierten Regel finden Sie unter [Liste der in den Debugger integrierten Regeln](debugger-built-in-rules.md).
Die SageMaker Debugger-API-Referenz finden Sie unter [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.sagemaker.debugger.rule_configs](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.sagemaker.debugger.rule_configs)und. [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule)
Um beispielsweise die allgemeine Trainingsleistung und den Trainingsfortschritt Ihres Modells zu überprüfen, erstellen Sie einen SageMaker KI-Schätzer mit der folgenden integrierten Regelkonfiguration.
```
from sagemaker.debugger import Rule, rule_configs
rules=[
Rule.sagemaker(rule_configs.loss_not_decreasing()),
Rule.sagemaker(rule_configs.overfit()),
Rule.sagemaker(rule_configs.overtraining()),
Rule.sagemaker(rule_configs.stalled_training_rule())
]
```
Wenn Sie den Trainingsauftrag starten, erfasst der Debugger standardmäßig alle 500 Millisekunden Daten zur Systemressourcenauslastung und die Verlust- und Genauigkeitswerte alle 500 Schritte. Der Debugger analysiert die Ressourcennutzung, um festzustellen, ob Ihr Modell Engpassprobleme aufweist. Der `loss_not_decreasing`, `overfit`, `overtraining`, und `stalled_training_rule` überwacht, ob Ihr Modell die Verlustfunktion optimiert, ohne dass diese Trainingsprobleme auftreten. Wenn die Regeln Trainingsanomalien erkennen, ändert sich der Status der Regelauswertung in `IssueFound`. Mit Amazon CloudWatch Events und können Sie automatisierte Aktionen einrichten, z. B. das Melden von Schulungsproblemen und das Beenden von Schulungsaufträgen. AWS Lambda Weitere Informationen finden Sie unter [Aktion im Zusammenhang mit Amazon SageMaker Debugger-Regeln](debugger-action-on-rules.md).
# Integrierte Debugger-Regeln mit benutzerdefinierten Parameterwerten verwenden
Wenn Sie die Werte der integrierten Regelparameter anpassen und die Regex für die Tensorsammlung anpassen möchten, konfigurieren Sie die `base_config` und `rule_parameters` Parameter für die Klassenmethoden `ProfilerRule.sagemaker` und `Rule.sagemaker`. Bei den `Rule.sagemaker` Klassenmethoden können Sie die Tensorsammlungen auch über den Parameter `collections_to_save` anpassen. Die Anleitung zur Verwendung der `CollectionConfig` Klasse finden Sie unter [Tensor-Sammlungen mithilfe der `CollectionConfig` API konfigurieren](debugger-configure-tensor-collections.md).
Verwenden Sie die folgende Konfigurationsvorlage für integrierte Regeln, um Parameterwerte anzupassen. Indem Sie die Regelparameter nach Ihren Wünschen ändern, können Sie die Empfindlichkeit der auszulösenden Regeln anpassen.
+ Das `base_config`-Argument ist der Ort, an dem Sie die integrierten Regelmethoden aufrufen.
+ Das `rule_parameters`-Argument besteht darin, die Standardschlüsselwerte der unter [Liste der in den Debugger integrierten Regeln](debugger-built-in-rules.md) aufgeführten integrierten Regeln anzupassen.
+ Das `collections_to_save`-Argument nimmt über die `CollectionConfig`-API eine Tensorkonfiguration an, die Argumente `name` und `parameters` erfordern.
+ Verfügbare Tensorsammlungen für `name` finden Sie unter [ Integrierte Tensorsammlungen im Debugger](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections).
+ Eine vollständige Liste der einstellbaren `parameters` Optionen finden Sie unter [Debugger-API CollectionConfig ](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk).
Weitere Informationen über die Debugger-Regelklasse, Methoden und Parameter finden Sie unter [SageMaker AI Debugger Rule class](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html) im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs, CollectionConfig
rules=[
Rule.sagemaker(
base_config=rule_configs.built_in_rule_name(),
rule_parameters={
"key": "value"
},
collections_to_save=[
CollectionConfig(
name="tensor_collection_name",
parameters={
"key": "value"
}
)
]
)
]
```
Die Parameterbeschreibungen und Beispiele für die Anpassung von Werten finden Sie für jede Regel unter [Liste der in den Debugger integrierten Regeln](debugger-built-in-rules.md).
# Beispiel-Notebooks und Codebeispiele zur Konfiguration von Debugger-Regeln
In den folgenden Abschnitten werden Notizbücher und Codebeispiele zur Verwendung von Debugger-Regeln zur Überwachung von SageMaker Trainingsaufträgen bereitgestellt.
**Topics**
+ [Beispiel für Notebooks mit integrierten Debugger-Regeln](#debugger-built-in-rules-notebook-example)
+ [Beispielcode für integrierte Debugger-Regeln](#debugger-deploy-built-in-rules)
+ [Integrierte Debugger-Regeln mit Parameteränderungen verwenden](#debugger-deploy-modified-built-in-rules)
## Beispiel für Notebooks mit integrierten Debugger-Regeln
Die folgenden Beispiel-Notebooks zeigen, wie die integrierten Debuger-Regeln verwendet werden, wenn Trainingsjobs mit Amazon SageMaker AI ausgeführt werden:
+ [Verwenden einer integrierten SageMaker Debugger-Regel mit TensorFlow](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_builtin_rule)
+ [Verwenden einer integrierten SageMaker Debugger-Regel mit Managed Spot Training und MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_spot_training)
+ [Verwendung einer integrierten SageMaker Debugger-Regel mit Parameteränderungen für eine Trainingsjobanalyse in Echtzeit mit XGBoost](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/xgboost_realtime_analysis)
Wenn Sie die Beispiel-Notizbücher in SageMaker Studio ausführen, finden Sie die Trainingsjob-Testversion, die auf der Registerkarte **Studio-Experimentliste** erstellt wurde. Wie im folgenden Screenshot gezeigt, können Sie beispielsweise das Fenster **Testkomponente beschreiben** Ihres aktuellen Trainingsauftrags finden und öffnen. Auf der Registerkarte Debugger können Sie überprüfen, ob die Debugger-Regeln `vanishing_gradient()` und`loss_not_decreasing()`, die Trainingssitzung parallel überwachen. Eine vollständige Anleitung, wie Sie die Komponenten Ihrer Trainingsjob-Testversion in der Studio-Benutzeroberfläche finden, finden Sie unter [SageMaker Studio — Experimente, Versuche und Testkomponenten anzeigen](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-tasks.html#studio-tasks-experiments).
![\[Ein Bild der Ausführung eines Trainingsjobs mit in SageMaker Studio aktivierten integrierten Debugger-Regeln\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-built-in-rule-studio.png)
Es gibt zwei Möglichkeiten, die integrierten Debugger-Regeln in der SageMaker KI-Umgebung zu verwenden: Stellen Sie die integrierten Regeln so bereit, wie sie vorbereitet sind, oder passen Sie ihre Parameter nach Ihren Wünschen an. Im Folgenden erfahren Sie anhand von Beispielcodes, wie Sie integrierte Regeln verwenden.
## Beispielcode für integrierte Debugger-Regeln
Das folgende Codebeispiel zeigt, wie die integrierten Debugger-Regeln mit der Methode `Rule.sagemaker` festgelegt werden. Um die integrierten Regeln anzugeben, die Sie ausführen möchten, rufen Sie die integrierten Regeln mithilfe der `rules_configs` API-Operation auf. Eine vollständige Liste der integrierten Debugger-Regeln und Standardparameterwerte finden Sie unter [Liste der in den Debugger integrierten Regeln](debugger-built-in-rules.md).
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import Rule, CollectionConfig, rule_configs
# call built-in rules that you want to use.
built_in_rules=[
Rule.sagemaker(rule_configs.vanishing_gradient())
Rule.sagemaker(rule_configs.loss_not_decreasing())
]
# construct a SageMaker AI estimator with the Debugger built-in rules
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-built-in-rules-demo',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific arguments below
rules=built_in_rules
)
sagemaker_estimator.fit()
```
**Anmerkung**
Die integrierten Debugger-Regeln werden parallel zu Ihrem Trainingsauftrag ausgeführt. Die maximale Anzahl von integrierten Regelcontainern für einen Trainingsauftrag ist 20.
Weitere Informationen über die Debugger-Regelklasse, Methoden und Parameter finden Sie in der [SageMaker Debugger-Regelklasse](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html) im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
Ein Beispiel für die Anpassung der Debugger-Regelparameter finden Sie im folgenden Abschnitt [Integrierte Debugger-Regeln mit Parameteränderungen verwenden](#debugger-deploy-modified-built-in-rules).
## Integrierte Debugger-Regeln mit Parameteränderungen verwenden
Das folgende Codebeispiel zeigt die Struktur der integrierten Regeln zur Anpassung von Parametern. In diesem Beispiel erfasst `stalled_training_rule` alle 50 Schritte die `losses` Tensorerfassung aus einem Trainingsauftrag und alle 10 Schritte aus einer Evaluierungsphase. Wenn der Trainingsprozess ins Stocken gerät und 120 Sekunden lang keine Tensorausgaben erfasst werden, stoppt der `stalled_training_rule` den Trainingsjob.
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import Rule, CollectionConfig, rule_configs
# call the built-in rules and modify the CollectionConfig parameters
base_job_name_prefix= 'smdebug-stalled-demo-' + str(int(time.time()))
built_in_rules_modified=[
Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
'threshold': '120',
'training_job_name_prefix': base_job_name_prefix,
'stop_training_on_fire' : 'True'
}
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "50"
"eval.save_interval": "10"
}
)
]
)
]
# construct a SageMaker AI estimator with the modified Debugger built-in rule
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name=base_job_name_prefix,
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific arguments below
rules=built_in_rules_modified
)
sagemaker_estimator.fit()
```
Eine erweiterte Konfiguration der integrierten Debuger-Regeln mithilfe der `CreateTrainingJob` API finden Sie unter [Debugger mithilfe SageMaker der API konfigurieren](debugger-createtrainingjob-api.md).
# Deaktivieren Sie den Debugger
Wenn Sie den Debugger vollständig deaktivieren möchten, führen Sie einen der folgenden Schritte aus:
+ Bevor Sie mit dem Trainingsauftrag beginnen, führen Sie die folgenden Schritte aus:
Um sowohl die Überwachung als auch die Profilerstellung zu beenden, fügen Sie den `disable_profiler` Parameter Ihrem Schätzer hinzu und setzen Sie ihn auf `True`.
**Warnung**
Wenn Sie ihn deaktivieren, können Sie das umfassende Studio Debugger Insights-Dashboard und den automatisch generierten Profilerstellungsbericht nicht anzeigen.
Um das Debuggen zu beenden, setzen Sie den `debugger_hook_config` Parameter auf `False`.
**Warnung**
Wenn Sie es deaktivieren, können Sie keine Ausgabetensoren sammeln und Ihre Modellparameter nicht debuggen.
```
estimator=Estimator(
...
disable_profiler=True
debugger_hook_config=False
)
```
Weitere Informationen zu den Debugger-spezifischen Parametern finden Sie unter [SageMaker AI Estimator](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator) im [Amazon SageMaker ](https://sagemaker.readthedocs.io/en/stable) Python SDK.
+ Führen Sie die folgenden Schritte aus, wenn ein Trainingsauftrag ausgeführt wird:
Um sowohl die Überwachung als auch die Profilerstellung zu deaktivieren, während Ihr Trainingsauftrag ausgeführt wird, verwenden Sie die folgende Schätzer-Klassenmethode:
```
estimator.disable_profiling()
```
Verwenden Sie die folgende `update_profiler` Methode, um nur die Framework-Profilerstellung zu deaktivieren und die Systemüberwachung aufrechtzuerhalten:
```
estimator.update_profiler(disable_framework_metrics=true)
```
[Weitere Informationen zu den Estimator-Erweiterungsmethoden finden Sie in den Klassenmethoden [estimator.disable\$1profiling und [estimator.update\$1profiler](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.update_profiler)](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.disable_profiling) in der Amazon Python SDK-Dokumentation. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
# SageMaker Nützliche AI-Estimator-Klassenmethoden für Debugger
Die folgenden Methoden der Schätzerklasse sind nützlich, um auf Ihre SageMaker Trainingsjobinformationen zuzugreifen und Ausgabepfade der vom Debugger gesammelten Trainingsdaten abzurufen. Die folgenden Methoden sind ausführbar, nachdem Sie mit der `estimator.fit()` Methode einen Trainingsauftrag gestartet haben.
+ So überprüfen Sie den S3-Bucket-Basis−URI eines SageMaker Trainingsjobs:
```
estimator.output_path
```
+ Um den Namen des Basisjobs eines SageMaker Trainingsjobs zu überprüfen:
```
estimator.latest_training_job.job_name
```
+ Um eine vollständige `CreateTrainingJob` API-Betriebskonfiguration eines SageMaker Trainingsjobs zu sehen:
```
estimator.latest_training_job.describe()
```
+ Um eine vollständige Liste der Debugger-Regeln zu überprüfen, während ein SageMaker Trainingsjob ausgeführt wird:
```
estimator.latest_training_job.rule_job_summary()
```
+ Um den S3-Bucket-URI zu überprüfen, in dem die Modellparameterdaten (Ausgabetensoren) gespeichert sind:
```
estimator.latest_job_debugger_artifacts_path()
```
+ So überprüfen Sie den S3-Bucket-URI, in dem die Modellleistungsdaten (System- und Framework-Metriken) gespeichert sind:
```
estimator.latest_job_profiler_artifacts_path()
```
+ Um die Debugger-Regelkonfiguration für das Debuggen von Ausgabetensoren zu überprüfen:
```
estimator.debugger_rule_configs
```
+ Um die Liste der Debugger-Regeln für das Debuggen während der Ausführung eines SageMaker Trainingsjobs zu überprüfen:
```
estimator.debugger_rules
```
+ So überprüfen Sie die Debugger-Regelkonfiguration für die Überwachung und Profilierung von System- und Framework-Metriken:
```
estimator.profiler_rule_configs
```
+ Um die Liste der Debugger-Regeln für die Überwachung und Profilerstellung während der Ausführung eines SageMaker Trainingsjobs zu überprüfen:
```
estimator.profiler_rules
```
Weitere Informationen zur SageMaker AI-Estimator-Klasse und ihren Methoden finden Sie unter [Estimator API](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator) im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
# SageMaker Interaktiver Debugger-Bericht für XGBoost
Erhalten Sie vom Debugger automatisch generierte Trainingsberichte. Die Debugger-Berichte bieten Einblicke in Ihre Trainingsaufträge und geben Empfehlungen zur Verbesserung der Leistung Ihres Modells. Verwenden Sie bei SageMaker XGBoost KI-Schulungsaufträgen die [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) Debugger-Regel, um einen umfassenden Schulungsbericht über den Trainingsfortschritt und die Ergebnisse zu erhalten. Geben Sie anhand dieser Anleitung die [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) Regel bei der Erstellung eines XGBoost Schätzers an, laden Sie den Bericht mithilfe des [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) oder der Amazon S3 S3-Konsole herunter und gewinnen Sie Einblicke in die Trainingsergebnisse.
**Anmerkung**
Sie können Debugger-Berichte herunterladen, während Ihr Trainingsauftrag läuft oder nachdem der Job abgeschlossen ist. während des Trainings aktualisiert der Debugger gleichzeitig den Bericht, der den Auswertungsstatus der aktuellen Regeln wiedergibt. Sie können einen vollständigen Debugger-Bericht erst herunterladen, wenn der Trainingsauftrag abgeschlossen ist.
**Wichtig**
Der Bericht enthält Diagramme und Empfehlungen zu Informationszwecken und sind nicht endgültig. Es liegt in Ihrer Verantwortung, die Informationen eigenständig zu bewerten.
**Topics**
+ [Konstruieren Sie einen SageMaker XGBoost KI-Schätzer mit der Debugger-Berichtsregel XGBoost](debugger-training-xgboost-report-estimator.md)
+ [Laden Sie den Debugger-Schulungsbericht XGBoost herunter](debugger-training-xgboost-report-download.md)
+ [Exemplarische Vorgehensweise für den Debugger-Trainingsbericht XGBoost](debugger-training-xgboost-report-walkthrough.md)
# Konstruieren Sie einen SageMaker XGBoost KI-Schätzer mit der Debugger-Berichtsregel XGBoost
Die [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) Regel erfasst die folgenden Ausgangstensoren aus Ihrem Trainingsauftrag:
+ `hyperparameters` – Speichert im ersten Schritt.
+ `metrics` – Speichert alle 5 Schritte Verlust und Genauigkeit.
+ `feature_importance` – Speichert alle 5 Schritte.
+ `predictions` – Speichert alle 5 Schritte.
+ `labels` – Speichert alle 5 Schritte.
Die Ausgabetensoren werden in einem Standard-S3-Bucket gespeichert. Beispiel, `s3://sagemaker--<12digit_account_id>//debug-output/`.
Wenn Sie einen SageMaker KI-Schätzer für einen XGBoost Trainingsjob erstellen, geben Sie die Regel wie im folgenden Beispielcode dargestellt an.
------
#### [ Using the SageMaker AI generic estimator ]
```
import boto3
import sagemaker
from sagemaker.estimator import Estimator
from sagemaker import image_uris
from sagemaker.debugger import Rule, rule_configs
rules=[
Rule.sagemaker(rule_configs.create_xgboost_report())
]
region = boto3.Session().region_name
xgboost_container=sagemaker.image_uris.retrieve("xgboost", region, "1.2-1")
estimator=Estimator(
role=sagemaker.get_execution_role()
image_uri=xgboost_container,
base_job_name="debugger-xgboost-report-demo",
instance_count=1,
instance_type="ml.m5.2xlarge",
# Add the Debugger XGBoost report rule
rules=rules
)
estimator.fit(wait=False)
```
------
# Laden Sie den Debugger-Schulungsbericht XGBoost herunter
Laden Sie den XGBoost Debugger-Trainingsbericht mit dem [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) und AWS Command Line Interface (CLI) herunter, während Ihr Trainingsjob ausgeführt wird oder nachdem der Job beendet wurde.
------
#### [ Download using the SageMaker Python SDK and AWS CLI ]
1. Überprüfen Sie den standardmäßigen S3-Ausgabe-Basis-URI des aktuellen Auftrags.
```
estimator.output_path
```
1. Überprüfen Sie den aktuellen Auftragsnamen.
```
estimator.latest_training_job.job_name
```
1. Der XGBoost Debugger-Bericht ist gespeichert unter. `//rule-output` Konfigurieren Sie den Regelausgabepfad wie folgt:
```
rule_output_path = estimator.output_path + "/" + estimator.latest_training_job.job_name + "/rule-output"
```
1. Um zu überprüfen, ob der Bericht generiert wurde, listen Sie Verzeichnisse und Dateien rekursiv unter der Option `rule_output_path` indem Sie `aws s3 ls` mit der `--recursive` Option verwenden.
```
! aws s3 ls {rule_output_path} --recursive
```
Dadurch sollte eine vollständige Liste der Dateien in automatisch generierten Ordnern mit dem Namen `CreateXgboostReport` und `ProfilerReport-1234567890` zurückgegeben werden. Der XGBoost Trainingsbericht wird im gespeichert`CreateXgboostReport`, und der Profilerstellungsbericht ist im `ProfilerReport-1234567890` Ordner gespeichert. Weitere Informationen über den Profilerstellungsbericht, der standardmäßig mit dem XGBoost Trainingsjob generiert wird, finden Sie unter. [SageMaker Interaktiver Debugger-Bericht](debugger-profiling-report.md)
![\[Ein Beispiel für die Ausgabe von Regeln.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-ls.png)
Das `xgboost_report.html` ist ein automatisch generierter XGBoost Trainingsbericht von Debugger. Das `xgboost_report.ipynb` ist ein Jupyter Notebook, das verwendet wird, um Trainingsergebnisse im Bericht zusammenzufassen. Sie können alle Dateien herunterladen, die HTML-Berichtsdatei durchsuchen und den Bericht mithilfe des Notebooks ändern.
1. Laden Sie die Dateien rekursiv herunter mit `aws s3 cp`. Mit dem folgenden Befehl werden alle Regelausgabedateien in dem `ProfilerReport-1234567890` Ordner unter dem aktuellen Arbeitsverzeichnis gespeichert.
```
! aws s3 cp {rule_output_path} ./ --recursive
```
**Tipp**
Wenn Sie einen Jupyter-Notebook-Server verwenden, führen Sie `!pwd` aus, um das aktuelle Arbeitsverzeichnis zu überprüfen.
1. Öffnen Sie `/CreateXgboostReport` unter dem `xgboost_report.html` Verzeichnis. Wenn Sie verwenden JupyterLab, wählen Sie **Trust HTML**, um den automatisch generierten Debugger-Trainingsbericht anzuzeigen.
![\[Ein Beispiel für die Ausgabe von Regeln.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-open-trust.png)
1. Öffnen Sie die `xgboost_report.ipynb` Datei, um zu erfahren, wie der Bericht generiert wird. Sie können den Trainingsbericht mithilfe der Jupyter-Notebook-Datei anpassen und erweitern.
------
#### [ Download using the Amazon S3 console ]
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon S3 S3-Konsole unter [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/).
1. Suchen Sie nach dem S3-Bucket. Wenn Sie beispielsweise keinen Basisauftragsnamen angegeben haben, sollte der Basis-S3-Bucket-Name das folgende Format haben: `sagemaker--111122223333`. Finden Sie den Basis-S3-Bucket über das Feld **Bucket nach Name finden**.
![\[Das Feld Bucket nach Namen finden in der Amazon-S3-Konsole.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-0.png)
1. Suchen Sie im Basis-S3-Bucket nach dem Namen des Trainingsauftrags, indem Sie Ihr Auftragsnamen-Präfix in das Feld **Objekte nach Präfix finden** eingeben und dann den Namen des Trainingsauftrags auswählen.
![\[Das Feld Objekte nach Präfix finden in der Amazon-S3-Konsole.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-1.png)
1. Wählen Sie im S3-Bucket des Trainingsauftrags den Unterordner **rule-output/** aus. Es muss drei Unterordner für die vom Debugger gesammelten Trainingsdaten geben: **debug-output/**, **profiler-output/** und **rule-output/**.
![\[Ein Beispiel für die Ausgabe des S3-Bucket-URI für die Ausgabe der Regel.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-2.png)
1. **Wählen Sie im Ordner **rule-output/ den Ordner/**aus. CreateXgboostReport** Der Ordner enthält **xbgoost\$1report.html** (den automatisch generierten Bericht in HTML) und **xbgoost\$1report.ipynb** (ein Jupyter Notebook mit Skripten, die zum Generieren des Berichts verwendet werden).
1. Wählen Sie die Datei **xbgoost\$1report.html** aus, wählen Sie **Herunterladen-Aktionen** und dann **Herunterladen** aus.
![\[Ein Beispiel für die Ausgabe des S3-Bucket-URI für die Ausgabe der Regel.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-s3-download.png)
1. Öffnen Sie die heruntergeladene Datei **xbgoost\$1report.html** in einem Webbrowser.
------
# Exemplarische Vorgehensweise für den Debugger-Trainingsbericht XGBoost
In diesem Abschnitt werden Sie durch den XGBoost Debugger-Schulungsbericht geführt. Der Bericht wird je nach Ausgabetensor-Regex automatisch aggregiert, wobei erkannt wird, um welche Art von Trainingsauftrag es sich bei der binären Klassifikation, der Mehrklassen-Klassifizierung und der Regression handelt.
**Wichtig**
Der Bericht enthält Diagramme und Empfehlungen zu Informationszwecken und sind nicht endgültig. Es liegt in Ihrer Verantwortung, die Informationen eigenständig zu bewerten.
**Topics**
+ [Verteilung der wahren Bezeichnungen des Datensatzes](#debugger-training-xgboost-report-walkthrough-dist-label)
+ [Diagramm zwischen Verlust und Schritt](#debugger-training-xgboost-report-walkthrough-loss-vs-step)
+ [Wichtigkeit der Feature](#debugger-training-xgboost-report-walkthrough-feature-importance)
+ [Verwechslungsmatrix](#debugger-training-xgboost-report-walkthrough-confusion-matrix)
+ [Bewertung der Wahrheitsmatrix](#debugger-training-xgboost-report-walkthrough-eval-conf-matrix)
+ [Genauigkeitsrate jedes diagonalen Elements im Laufe der Iteration](#debugger-training-xgboost-report-walkthrough-accuracy-rate)
+ [Betriebskennlinie des Empfängers](#debugger-training-xgboost-report-walkthrough-rec-op-char)
+ [Verteilung der Residuen im letzten gespeicherten Schritt](#debugger-training-xgboost-report-walkthrough-dist-residual)
+ [Absoluter Validierungsfehler pro Beschriftungs-Bin während der Iteration](#debugger-training-xgboost-report-walkthrough-val-error-per-label-bin)
## Verteilung der wahren Bezeichnungen des Datensatzes
Dieses Histogramm zeigt die Verteilung der beschrifteten Klassen (zur Klassifizierung) oder Werte (für die Regression) in Ihrem ursprünglichen Datensatz. Schiefe Werte in Ihrem Datensatz können zu Ungenauigkeiten führen. Diese Visualisierung ist für die folgenden Modelltypen verfügbar: binäre Klassifikation, Multiklassifikation und Regression.
![\[Ein Beispiel für eine Verteilung der wahren Bezeichnungen des Datensatzdiagramms.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-dist-label.png)
## Diagramm zwischen Verlust und Schritt
Dies ist ein Liniendiagramm, das den Verlauf des Verlusts von Trainingsdaten und Validierungsdaten während der Trainingsschritte zeigt. Der Verlust entspricht dem, was Sie in Ihrer Zielfunktion definiert haben, z. B. den quadratischen Mittelwert des Fehlers. Anhand dieses Diagramms können Sie abschätzen, ob das Modell über- oder unterangepasst ist. In diesem Abschnitt wird auch das Problem der Überanpassung und Unterausstattung beschrieben. Diese Visualisierung ist für die folgenden Modelltypen verfügbar: binäre Klassifikation, Multiklassifizierung und Regression.
![\[Ein Beispiel für ein Diagramm zwischen Verlust und Stufe.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-loss-vs-step.png)
## Wichtigkeit der Feature
Es stehen drei verschiedene Arten von Visualisierungen der Feature-Wichtigkeit zur Verfügung: Gewicht, Zuwachs und Reichweite. Wir stellen detaillierte Definitionen für jede der drei im Bericht bereit. Visualisierungen der Wichtigkeit von Features helfen Ihnen zu erfahren, welche Features in Ihrem Trainingsdatensatz zu den Vorhersagen beitragen. Visualisierungen der Wichtigkeit von Features sind für die folgenden Modelltypen verfügbar: Binäre Klassifikation, Multiklassifikation und Regression.
![\[Ein Beispiel für ein Diagramm der Feature-Wichtigkeit.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-feature-importance.png)
## Verwechslungsmatrix
Diese Visualisierung ist nur für binäre und Mehrklassen-Klassifikationsmodelle anwendbar. Genauigkeit allein reicht möglicherweise nicht aus, um die Leistung des Modells zu bewerten. Für einige Anwendungsfälle, z. B. im Gesundheitswesen und bei der Betrugserkennung, ist es auch wichtig, die Falsch-Positiv-Rate und die Falsch-Negativ-Rate zu kennen. Eine Konfusionsmatrix bietet Ihnen zusätzliche Dimensionen für die Bewertung der Leistung Ihres Modells.
![\[Ein Beispiel für eine Konfusionsmatrix.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-confusion-matrix.png)
## Bewertung der Wahrheitsmatrix
In diesem Abschnitt erhalten Sie weitere Einblicke in die Mikro-, Makro- und gewichteten Messwerte für Präzision, Erinnerungsvermögen und F1-Score für Ihr Modell.
![\[Bewertung der Konfusionsmatrix.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-eval-conf-matrix.png)
## Genauigkeitsrate jedes diagonalen Elements im Laufe der Iteration
Diese Visualisierung ist nur für binäre Klassifikations- und Mehrklassen-Klassifizierungsmodelle anwendbar. Dies ist ein Liniendiagramm, in dem die diagonalen Werte in der Konfusionsmatrix während der Trainingsschritte für jede Klasse dargestellt werden. Dieses Diagramm zeigt dir, wie sich die Genauigkeit der einzelnen Klassen im Laufe der Trainingsschritte entwickelt. Anhand dieses Diagramms können Sie die Klassen identifizieren, die schlechter abschneiden.
![\[Ein Beispiel für die Genauigkeitsrate jedes diagonalen Elements im Vergleich zum Iterationsdiagramm.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-accuracy-rate.gif)
## Betriebskennlinie des Empfängers
Diese Visualisierung ist nur auf binäre Klassifikationsmodelle anwendbar. Die Betriebskennlinie des Empfängers wird häufig zur Bewertung der Leistung von binären Klassifikationsmodellen verwendet. Die Y-Achse der Kurve entspricht der True Positive Rate (TPF) und die X-Achse der False-Positiv-Rate (FPR). Im Diagramm wird auch der Wert für die Fläche unter der Kurve (AUC) angezeigt. Je höher der AUC-Wert, desto prädiktiver ist Ihr Klassifikator. Sie können die ROC-Kurve auch verwenden, um den Kompromiss zwischen TPR und FPR zu verstehen und den optimalen Klassifizierungsschwellenwert für Ihren Anwendungsfall zu ermitteln. Der Klassifizierungsschwellenwert kann angepasst werden, um das Verhalten des Modells so zu optimieren, dass mehr Fehler der einen oder anderen Art (FP/FN) reduziert werden.
![\[Ein Beispiel für ein Diagramm der Betriebskennlinie des Empfängers.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-rec-op-char.png)
## Verteilung der Residuen im letzten gespeicherten Schritt
Bei dieser Visualisierung handelt es sich um ein Säulendiagramm, das die Restverteilungen im letzten Schritt zeigt, den der Debugger erfasst. In dieser Visualisierung können Sie überprüfen, ob die Residuenverteilung der Normalverteilung nahe kommt, deren Mittelpunkt bei Null liegt. Wenn die Residuen schief sind, reichen Ihre Features möglicherweise nicht aus, um die Beschriftungen vorherzusagen.
![\[Ein Beispiel für eine Verteilung der Residuen im Diagramm mit dem zuletzt gespeicherten Schritt.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-dist-residual.png)
## Absoluter Validierungsfehler pro Beschriftungs-Bin während der Iteration
Diese Visualisierung gilt nur für Regressionsmodelle. Die tatsächlichen Zielwerte sind in 10 Intervalle aufgeteilt. Diese Visualisierung zeigt in Liniendiagrammen, wie sich die Validierungsfehler für jedes Intervall während der Trainingsschritte entwickeln. Der absolute Validierungsfehler ist der absolute Wert der Differenz zwischen Prognose und Istwert während der Validierung. Anhand dieser Visualisierung können Sie erkennen, welche Intervalle schlechter abschneiden.
![\[Ein Beispiel für einen absoluten Validierungsfehler pro Beschriftungs-Bin im Iterationsdiagramm.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-val-error-per-label-bin.png)
# Aktion im Zusammenhang mit Amazon SageMaker Debugger-Regeln
Basierend auf dem Evaluierungsstatus der Debugger-Regel können Sie automatische Aktionen einrichten, wie z. B. das Beenden einer Trainingsaufgabe und das Senden von Benachrichtigungen mit Amazon Simple Notification Service (Amazon SNS). Sie können auch Ihre eigenen Aktionen mit Amazon CloudWatch Events und erstellen AWS Lambda. In den folgenden Themen erfahren Sie, wie Sie automatisierte Aktionen auf der Grundlage des Evaluierungsstatus der Debugger-Regel einrichten.
**Topics**
+ [Integrierte Debugger-Aktionen für Regeln verwenden](debugger-built-in-actions.md)
+ [Aktionen zu Regeln mit Amazon CloudWatch und AWS Lambda](debugger-cloudwatch-lambda.md)
# Integrierte Debugger-Aktionen für Regeln verwenden
Verwenden Sie die integrierten Debuger-Aktionen, um auf Probleme zu reagieren, die von [Debugger-Regel](debugger-built-in-rules.md#debugger-built-in-rules-Rule) gefunden wurden. Die `rule_configs` Debugger-Klasse bietet Tools zum Konfigurieren einer Liste von Aktionen, darunter das automatische Stoppen von Trainingsjobs und das Senden von Benachrichtigungen mithilfe von Amazon Simple Notification Service (Amazon SNS), wenn die Debugger-Regeln Trainingsprobleme feststellen. Die folgenden Themen führen Sie durch die einzelnen Schritte, um diese Aufgaben zu erfüllen.
**Topics**
+ [Amazon SNS einrichten, ein `SMDebugRules`-Thema erstellen und das Thema abonnieren](#debugger-built-in-actions-sns)
+ [Ihre IAM-Rolle einrichten, um erforderliche Richtlinien anzuhängen](#debugger-built-in-actions-iam)
+ [Debugger-Regeln mit den integrierten Aktionen konfigurieren](#debugger-built-in-actions-on-rule)
+ [Überlegungen zur Verwendung der integrierten Debugger-Aktionen](#debugger-built-in-actions-considerations)
## Amazon SNS einrichten, ein `SMDebugRules`-Thema erstellen und das Thema abonnieren
In diesem Abschnitt erfahren Sie, wie Sie ein Amazon SNS **SMDebugRules**-Thema einrichten, es abonnieren und das Abonnement bestätigen, um Benachrichtigungen von den Debugger-Regeln zu erhalten.
**Anmerkung**
Weitere Informationen zur Abrechnung für Amazon SNS finden Sie unter [Amazon SNS-Preise und [Amazon](https://aws.amazon.com/sns/faqs/) SNS](https://aws.amazon.com/sns/pricing/). FAQs
**Um ein Regelthema zu erstellen SMDebug**
1. Melden Sie sich bei [https://console.aws.amazon.com/sns/v3/home](https://console.aws.amazon.com/sns/v3/home) an AWS-Managementkonsole und öffnen Sie die Amazon SNS SNS-Konsole.
1. Wählen Sie im linken Navigationsbereich **Topics (Themen)**.
1. Wählen Sie auf der Seite **Topics (Themen)** **Create New Topic (Neues Thema erstellen)** aus.
1. Führen Sie auf der Seite **Create subscription (Abonnement erstellen)** im Abschnitt **Details** die folgenden Schritte aus:
1. Wählen Sie als **Typ** die Option **Standard** als Thementyp aus.
1. Geben Sie unter **Name** **SMDebugRules** ein.
1. Überspringen Sie alle anderen optionalen Einstellungen und wählen Sie **Thema erstellen**. Weitere Informationen zu den optionalen Einstellungen finden Sie unter [Amazon SNS-Thema erstellen.](https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html)
**Um das Thema Regeln zu abonnieren SMDebug**
1. Öffnen Sie die Amazon SNS SNS-Konsole unter [https://console.aws.amazon.com/sns/v3/home](https://console.aws.amazon.com/sns/v3/home).
1. Wählen Sie im linken Navigationsbereich **Subscriptions** (Abonnements).
1. Wählen Sie auf der Seite **Subscriptions** (Abonnements) die Option **Create subscription (Abonnement erstellen)**aus.
1. Führen Sie auf der Seite **Create subscription ** (Abonnement erstellen) im Abschnitt **Details** die folgenden Schritte aus:
1. Wählen Sie für **Thema ARN** das Thema **SMDebugRegeln** aus. Der ARN sollte im Format von `arn:aws:sns::111122223333:SMDebugRules` sein.
1. Wählen Sie für **Protocol (Protokoll)** die Option **Email (E-Mail)** oder **SMS**.
1. Für **Endpunkt**, geben Sie den Endpunktwert ein, wie z. B. eine E-Mail-Adresse oder eine Telefonnummer, über die Benachrichtigungen erhalten sollen.
**Anmerkung**
Vergewissern Sie sich, dass Sie die richtige E-Mail-Adresse und Telefonnummer eingeben. Telefonnummern müssen `+`, eine Landesvorwahl und eine Telefonnummer ohne Sonderzeichen oder Leerzeichen enthalten. Die Telefonnummer \$11 (222) 333-4444 ist beispielsweise formatiert als **\$112223334444**.
1. Überspringen Sie alle anderen optionalen Einstellungen und wählen Sie **Abonnement erstellen**. Weitere Informationen zu den optionalen Einstellungen finden Sie unter [Amazon SNS abonnieren](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html).
Nachdem Sie das Thema **SMDebugRegeln** abonniert haben, erhalten Sie die folgende Bestätigungsnachricht per E-Mail oder Telefon:
![\[Eine E-Mail-Nachricht zur Bestätigung des Abonnements für das Thema Amazon SNS SMDebugSNS-Regeln.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-built-in-action-subscription-confirmation.png)
Weitere Informationen über Amazon SNS finden Sie unter [Mobile Textnachrichten (SMS)](https://docs.aws.amazon.com/sns/latest/dg/sns-mobile-phone-number-as-subscriber.html) und [E-Mail-Benachrichtigungen](https://docs.aws.amazon.com/sns/latest/dg/sns-email-notifications.html) im *Amazon SNS Developer Guide*.
## Ihre IAM-Rolle einrichten, um erforderliche Richtlinien anzuhängen
In diesem Schritt fügen Sie die erforderlichen Richtlinien zu Ihrer IAM-Rolle hinzu.
**Um die erforderlichen Richtlinien zu Ihrer IAM-Rolle hinzuzufügen**
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die IAM-Konsole unter. [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)
1. Wählen Sie im linken Navigationsbereich **Policies (Richtlinien)** und anschließend **Create Policy (Richtlinie erstellen)** aus.
1. Gehen Sie auf der Seite **Richtlinie erstellen** wie folgt vor, um eine neue SNS-Zugriffsrichtlinie zu erstellen:
1. Wählen Sie den Tab **JSON**.
1. Fügen Sie die im folgenden Code fett formatierten JSON-Zeichenfolgen in das ein und ersetzen Sie dabei die `"Statement"` 12-stellige AWS Konto-ID durch Ihre AWS Konto-ID.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"sns:Publish",
"sns:CreateTopic",
"sns:Subscribe"
],
"Resource": "arn:aws:sns:*:111122223333:SMDebugRules"
}
]
}
```
------
1. Wählen Sie unten auf der Seite die Option **Richtlinie überprüfen**.
1. Geben Sie auf der Seite **Create policy (Richtlinie erstellen)** für **Name** **sns-access** ein.
1. Wählen Sie unten auf der Seite **Create policy (Richtlinie erstellen)** aus.
1. Gehen Sie zurück zur IAM-Konsole und wählen Sie im linken Navigationsbereich **Rollen** aus.
1. Suchen Sie nach der IAM-Rolle, die Sie für das Training mit SageMaker KI-Modellen verwenden, und wählen Sie diese IAM-Rolle aus.
1. Wählen Sie auf der **Übersichtsseite** auf der Registerkarte **Berechtigungen** die Option **Richtlinien anhängen** aus.
1. Suchen Sie nach der **sns-Zugriffsrichtlinie**, aktivieren Sie das Kontrollkästchen neben der Richtlinie, und wählen Sie dann **Richtlinie anhängen**.
Weitere Beispiele für die Einrichtung von IAM-Richtlinien für Amazon SNS finden Sie unter [Beispielfälle für die Amazon SNS-Zugriffskontrolle](https://docs.aws.amazon.com/sns/latest/dg/sns-access-policy-use-cases.html).
## Debugger-Regeln mit den integrierten Aktionen konfigurieren
Nachdem Sie die erforderlichen Einstellungen in den vorherigen Schritten erfolgreich abgeschlossen haben, können Sie die integrierten Debugger-Aktionen für Debugging-Regeln konfigurieren, wie im folgenden Beispielskript gezeigt. Sie können wählen, welche integrierten Aktionen beim Erstellen des `actions` Listenobjekts verwendet werden sollen. Das `rule_configs` ist ein Hilfsmodul, das Tools auf hoher Ebene zur Konfiguration der im Debugger integrierten Regeln und Aktionen bereitstellt. Die folgenden integrierten Aktionen sind für Debugger verfügbar:
+ `rule_configs.StopTraining()`– Stoppt einen Trainingsjob, wenn die Debugger-Regel ein Problem feststellt.
+ `rule_configs.Email("abc@abc.com")`– Sendet eine Benachrichtigung per E-Mail, wenn die Debugger-Regel ein Problem feststellt. Verwenden Sie die E-Mail-Adresse, die Sie bei der Einrichtung Ihres SNS-Themenabonnements verwendet haben.
+ `rule_configs.SMS("+1234567890")`– Sendet eine Benachrichtigung per Textnachricht, wenn die Debugger-Regel ein Problem feststellt. Verwenden Sie die Telefonnummer, die Sie bei der Einrichtung Ihres SNS-Themenabonnements verwendet haben.
**Anmerkung**
Vergewissern Sie sich, dass Sie die richtige E-Mail-Adresse und Telefonnummer eingeben. Telefonnummern müssen `+`, eine Landesvorwahl und eine Telefonnummer ohne Sonderzeichen oder Leerzeichen enthalten. Die Telefonnummer \$11 (222) 333-4444 ist beispielsweise formatiert als **\$112223334444**.
Sie können alle integrierten Aktionen oder eine Teilmenge von Aktionen verwenden, indem Sie zum Abschluss die `rule_configs.ActionList()` Methode verwenden, die die integrierten Aktionen übernimmt und eine Liste von Aktionen konfiguriert.
**Um alle drei integrierten Aktionen zu einer einzigen Regel hinzuzufügen**
Wenn Sie alle drei integrierten Aktionen einer einzigen Regel zuweisen möchten, konfigurieren Sie bei der Erstellung eines Schätzers eine Liste der integrierten Debuger-Aktionen. Verwenden Sie die folgende Vorlage, um den Schätzer zu erstellen, und der Debugger beendet die Trainingsjobs und sendet Benachrichtigungen per E-Mail und Text für alle Regeln, die Sie zur Überwachung des Fortschritts Ihrer Trainingsaufgabe verwenden.
```
from sagemaker.debugger import Rule, rule_configs
# Configure an action list object for Debugger rules
actions = rule_configs.ActionList(
rule_configs.StopTraining(),
rule_configs.Email("abc@abc.com"),
rule_configs.SMS("+1234567890")
)
# Configure rules for debugging with the actions parameter
rules = [
Rule.sagemaker(
base_config=rule_configs.built_in_rule(), # Required
rule_parameters={"paramter_key": value }, # Optional
actions=actions
)
]
estimator = Estimator(
...
rules = rules
)
estimator.fit(wait=False)
```
**Um mehrere integrierte Aktionsobjekte zu erstellen, um einer einzelnen Regel verschiedene Aktionen zuzuweisen**
Wenn Sie die integrierten Aktionen so zuweisen möchten, dass sie bei unterschiedlichen Schwellenwerten einer einzelnen Regel ausgelöst werden, können Sie mehrere integrierte Aktionsobjekte erstellen, wie im folgenden Skript gezeigt. Um einen Konfliktfehler durch die Ausführung derselben Regel zu vermeiden, müssen Sie unterschiedliche Regelauftragsnamen einreichen (geben Sie unterschiedliche Zeichenfolgen für das `name` Regelattribut an), wie in der folgenden Beispielskriptvorlage gezeigt. Dieses Beispiel zeigt, wie man [StalledTrainingRule](debugger-built-in-rules.md#stalled-training) so einrichtet, dass es zwei verschiedene Aktionen durchführt: eine E-Mail an `abc@abc.com` senden, wenn ein Trainingsauftrag 60 Sekunden lang blockiert, und den Trainingsauftrag stoppen, wenn er 120 Sekunden lang blockiert.
```
from sagemaker.debugger import Rule, rule_configs
import time
base_job_name_prefix= 'smdebug-stalled-demo-' + str(int(time.time()))
# Configure an action object for StopTraining
action_stop_training = rule_configs.ActionList(
rule_configs.StopTraining()
)
# Configure an action object for Email
action_email = rule_configs.ActionList(
rule_configs.Email("abc@abc.com")
)
# Configure a rule with the Email built-in action to trigger if a training job stalls for 60 seconds
stalled_training_job_rule_email = Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "60",
"training_job_name_prefix": base_job_name_prefix
},
actions=action_email
)
stalled_training_job_rule_text.name="StalledTrainingJobRuleEmail"
# Configure a rule with the StopTraining built-in action to trigger if a training job stalls for 120 seconds
stalled_training_job_rule = Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "120",
"training_job_name_prefix": base_job_name_prefix
},
actions=action_stop_training
)
stalled_training_job_rule.name="StalledTrainingJobRuleStopTraining"
estimator = Estimator(
...
rules = [stalled_training_job_rule_email, stalled_training_job_rule]
)
estimator.fit(wait=False)
```
Während der Trainingsjob ausgeführt wird, sendet die integrierte Debuger-Aktion Benachrichtigungs-E-Mails und Textnachrichten, wenn die Regel Probleme mit Ihrem Trainingsjob feststellt. Der folgende Screenshot zeigt ein Beispiel für eine E-Mail-Benachrichtigung für einen Trainingsjob, bei dem das Problem mit der Trainingsaufgabe blockiert wurde.
![\[Ein Beispiel für eine E-Mail-Benachrichtigung, die vom Debugger gesendet wird, wenn ein Problem erkannt wird. StalledTraining\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-built-in-action-email.png)
Der folgende Screenshot zeigt ein Beispiel für eine Textbenachrichtigung, die der Debugger sendet, wenn die Regel ein StalledTraining Problem entdeckt.
![\[Ein Beispiel für eine Textbenachrichtigung, die vom Debugger gesendet wird, wenn ein StalledTraining Problem erkannt wird.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-built-in-action-text.png)
## Überlegungen zur Verwendung der integrierten Debugger-Aktionen
+ Um die integrierten Debuger-Aktionen verwenden zu können, ist eine Internetverbindung erforderlich. Diese Funktion wird im Netzwerkisolationsmodus von Amazon SageMaker AI oder Amazon VPC nicht unterstützt.
+ Die integrierten Aktionen können nicht für [Profiler-Regeln](debugger-built-in-profiler-rules.md#debugger-built-in-profiler-rules-ProfilerRule) verwendet werden.
+ Die integrierten Aktionen können nicht für Trainingsaufgaben mit punktuellen Trainingsunterbrechungen verwendet werden.
+ In den E-Mail- oder Textbenachrichtigungen erscheint `None` am Ende der Nachrichten. Dies hat keine Bedeutung, sodass Sie den Text `None` ignorieren können.
# Aktionen zu Regeln mit Amazon CloudWatch und AWS Lambda
Amazon CloudWatch sammelt Trainingsauftragsprotokolle für Amazon SageMaker AI-Modelle und Auftragsprotokolle zur Verarbeitung von Amazon SageMaker Debugger-Regeln. Konfigurieren Sie den Debugger mit Amazon CloudWatch Events und AWS Lambda ergreifen Sie Maßnahmen auf der Grundlage des Evaluierungsstatus der Debugger-Regel.
## Beispiel-Notebooks
Sie können die folgenden Beispiel-Notebooks ausführen, die darauf vorbereitet sind, mit dem Beenden eines Trainingsjobs zu experimentieren, indem Sie Aktionen für die integrierten Regeln von Debugger mithilfe von Amazon CloudWatch und verwenden. AWS Lambda
+ [Amazon SageMaker Debugger — Auf CloudWatch Ereignisse anhand von Regeln reagieren](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_action_on_rule/tf-mnist-stop-training-job.html)
In diesem Beispiel-Notebook wird ein Trainingsjob ausgeführt, bei dem ein Problem mit verschwindendem Farbverlauf auftritt. Die [VanishingGradient](debugger-built-in-rules.md#vanishing-gradient) integrierte Debuger-Regel wird bei der Erstellung des AI-Estimators verwendet. SageMaker TensorFlow Wenn die Debugger-Regel das Problem erkennt, wird der Trainingsjob beendet.
+ [Erkennen Sie blockiertes Training und rufen Sie Aktionen mithilfe der Debugger-Regel auf SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_action_on_rule/detect_stalled_training_job_and_actions.html)
In diesem Beispiel-Notebook wird ein Trainingsskript mit einer Codezeile ausgeführt, die es zwingt, für 10 Minuten in den Ruhemodus zu wechseln. Die [StalledTrainingRule](debugger-built-in-rules.md#stalled-training) integrierte Debuger-Regel löst Probleme aus und beendet den Trainingsjob.
**Topics**
+ [Beispiel-Notebooks](#debugger-test-stop-training)
+ [CloudWatch Zugriffsprotokolle für Debugger-Regeln und Trainingsjobs](debugger-cloudwatch-metric.md)
+ [Richten Sie den Debugger für die automatische Beendigung von Trainingsjobs mithilfe von Lambda CloudWatch ein](debugger-stop-training.md)
+ [Deaktivieren Sie die Regel „ CloudWatch Ereignisse“, um die automatische Beendigung von Trainingsjobs nicht mehr zu verwenden](debugger-disable-cw.md)
# CloudWatch Zugriffsprotokolle für Debugger-Regeln und Trainingsjobs
Sie können den Trainingsstatus und den Status der Debugger-Regel in den CloudWatch Protokollen verwenden, um weitere Maßnahmen zu ergreifen, falls Trainingsprobleme auftreten. Das folgende Verfahren zeigt, wie Sie auf die zugehörigen CloudWatch Protokolle zugreifen können. Weitere Informationen zur Überwachung von Trainingsaufträgen mithilfe von CloudWatch Amazon AI finden Sie unter [Monitor Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-overview.html).
**So greifen Sie auf die Protokolle für Trainingsjobs und die Jobprotokolle für Debugger-Regeln zu**
1. Öffnen Sie die CloudWatch Konsole unter [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Wählen Sie im linken Navigationsbereich unter dem **Protokoll**-Knoten die Option **Protokollgruppen**.
1. Führen Sie in der Liste Protokollgruppen die folgenden Schritte aus:
+ Wählen Sie**/aws/sagemaker/TrainingJobs**für die Protokolle von Trainingsaufträgen.
+ Wählen Sie**/aws/sagemaker/ProcessingJobs**für die Jobprotokolle der Debugger-Regel.
# Richten Sie den Debugger für die automatische Beendigung von Trainingsjobs mithilfe von Lambda CloudWatch ein
Die Debugger-Regeln überwachen den Status des Trainingsauftrags, und eine CloudWatch Ereignisregel überwacht den Bewertungsstatus des Trainingsauftrags der Debugger-Regel. In den folgenden Abschnitten wird der Prozess beschrieben, der zur Automatisierung der Beendigung von Schulungsjobs mithilfe von Using CloudWatch und Lambda erforderlich ist.
**Topics**
+ [Schritt 1: Erstellen einer Lambda-Funktion](#debugger-lambda-function-create)
+ [Schritt 2: Konfigurieren der Lambda-Funktion](#debugger-lambda-function-configure)
+ [Schritt 3: Erstellen Sie eine CloudWatch Ereignisregel und verknüpfen Sie sie mit der Lambda-Funktion für den Debugger](#debugger-cloudwatch-events)
## Schritt 1: Erstellen einer Lambda-Funktion
**So erstellen Sie eine Lambda-Funktion**
1. Öffnen Sie die AWS Lambda Konsole unter. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. Wählen Sie im linken Navigationsbereich **Funktionen** und dann **Funktion anlegen**.
1. Wählen Sie auf der Seite **Funktion erstellen** die Option **Autor von Grund auf neu**.
1. Geben Sie im Abschnitt **Grundinformationen** einen **Funktionsnamen** ein (z. B. **debugger-rule-stop-training-job**).
1. Wählen Sie für **Runtime (Laufzeit)** die Option **Python 3.7** aus.
1. Erweitern Sie für **Berechtigungen** die Dropdownoption und wählen Sie **Standardausführungsrolle ändern aus.**
1. Wählen Sie für **Ausführungsrolle** die **Option Bestehende Rolle verwenden** und wählen Sie die IAM-Rolle aus, die Sie für Schulungsaufgaben auf SageMaker KI verwenden.
**Anmerkung**
Stellen Sie sicher, dass Sie die Ausführungsrolle zusammen mit `AmazonSageMakerFullAccess` und `AWSLambdaBasicExecutionRole` angehängt verwenden. Andernfalls reagiert die Lambda-Funktion nicht richtig auf die Statusänderungen der Debugger-Regel des Trainingsjobs. Wenn Sie sich nicht sicher sind, welche Ausführungsrolle verwendet wird, führen Sie den folgenden Code in einer Jupyter-Notebook-Zelle aus, um die Ausgabe der Ausführungsrolle abzurufen:
```
import sagemaker
sagemaker.get_execution_role()
```
1. Klicken Sie unten auf der Seite auf **Create function**.
Die folgende Abbildung zeigt ein Beispiel für die Seite **Funktion erstellen**, auf der die Eingabefelder und Auswahlen abgeschlossen sind.
![\[Seite Funktion erstellen.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-lambda-create.png)
## Schritt 2: Konfigurieren der Lambda-Funktion
**Um die Lambda-Funktion zu konfigurieren**
1. Fügen Sie im Abschnitt **Funktionscode** der Konfigurationsseite das folgende Python-Skript in den Bereich des Lambda-Code-Editors ein. Die `lambda_handler` Funktion überwacht den Evaluierungsstatus der Debugger-Regel, der von der API-Operation erfasst wurde, CloudWatch und löst den `StopTrainingJob` API-Vorgang aus. Die AWS SDK für Python (Boto3) `client` for SageMaker AI bietet eine Methode auf hoher Ebene`stop_training_job`, die den `StopTrainingJob` API-Vorgang auslöst.
```
import json
import boto3
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
def lambda_handler(event, context):
training_job_name = event.get("detail").get("TrainingJobName")
logging.info(f'Evaluating Debugger rules for training job: {training_job_name}')
eval_statuses = event.get("detail").get("DebugRuleEvaluationStatuses", None)
if eval_statuses is None or len(eval_statuses) == 0:
logging.info("Couldn't find any debug rule statuses, skipping...")
return {
'statusCode': 200,
'body': json.dumps('Nothing to do')
}
# should only attempt stopping jobs with InProgress status
training_job_status = event.get("detail").get("TrainingJobStatus", None)
if training_job_status != 'InProgress':
logging.debug(f"Current Training job status({training_job_status}) is not 'InProgress'. Exiting")
return {
'statusCode': 200,
'body': json.dumps('Nothing to do')
}
client = boto3.client('sagemaker')
for status in eval_statuses:
logging.info(status.get("RuleEvaluationStatus") + ', RuleEvaluationStatus=' + str(status))
if status.get("RuleEvaluationStatus") == "IssuesFound":
secondary_status = event.get("detail").get("SecondaryStatus", None)
logging.info(
f'About to stop training job, since evaluation of rule configuration {status.get("RuleConfigurationName")} resulted in "IssuesFound". ' +
f'\ntraining job "{training_job_name}" status is "{training_job_status}", secondary status is "{secondary_status}"' +
f'\nAttempting to stop training job "{training_job_name}"'
)
try:
client.stop_training_job(
TrainingJobName=training_job_name
)
except Exception as e:
logging.error(
"Encountered error while trying to "
"stop training job {}: {}".format(
training_job_name, str(e)
)
)
raise e
return None
```
Weitere Informationen zur Lambda-Code-Editor-Oberfläche finden Sie unter [Funktionen mit dem AWS Lambda-Konsoleneditor erstellen](https://docs.aws.amazon.com/lambda/latest/dg/code-editor.html).
1. Überspringen Sie alle anderen Einstellungen und wählen Sie oben auf der Konfigurationsseite **Speichern**.
## Schritt 3: Erstellen Sie eine CloudWatch Ereignisregel und verknüpfen Sie sie mit der Lambda-Funktion für den Debugger
**Um eine CloudWatch Ereignisregel und einen Link zur Lambda-Funktion für Debugger zu erstellen**
1. Öffnen Sie die CloudWatch Konsole unter. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Wählen Sie im linken Navigationsbereich unter dem Knoten **Ereignisse** die Option **Regeln**.
1. Wählen Sie **Regel erstellen** aus.
1. Wählen Sie auf der Seite „**Schritt 1: Regel erstellen**“ im Abschnitt „**Ereignisquelle**“ die Option **SageMaker AI** als **Dienstname** und als **Ereignistyp** die Option „**SageMaker AI Training Job State Change**“ aus. Die Event-Pattern-Vorschau sollte wie in den folgenden JSON-Beispielzeichenfolgen aussehen:
```
{
"source": [
"aws.sagemaker"
],
"detail-type": [
"SageMaker Training Job State Change"
]
}
```
1. Wählen Sie im Abschnitt **Ziele** die Option **Ziel hinzufügen\$1** und wählen Sie die Lambda-Funktion **debugger-rule-stop-training-job** aus, die Sie erstellt haben. In diesem Schritt wird die CloudWatch Events-Regel mit der Lambda-Funktion verknüpft.
1. Wählen Sie **Details konfigurieren** und gehen Sie zur Seite **Schritt 2: Regeldetails konfigurieren**.
1. Geben Sie den Namen der CloudWatch Regeldefinition an. Beispiel, **debugger-cw-event-rule**.
1. Wählen Sie **Rolle erstellen** aus, um den Vorgang abzuschließen.
1. Gehen Sie zurück zur Konfigurationsseite der Lambda-Funktion und aktualisieren Sie die Seite. Vergewissern Sie sich, dass es im **Designer-Bereich** korrekt konfiguriert ist. Die CloudWatch Events-Regel sollte als Trigger für die Lambda-Funktion registriert werden. Das Konfigurationsdesign sollte wie das folgende Beispiel aussehen:
![\[Designer-Panel für die CloudWatch Konfiguration.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-lambda-designer.png)
# Deaktivieren Sie die Regel „ CloudWatch Ereignisse“, um die automatische Beendigung von Trainingsjobs nicht mehr zu verwenden
Wenn Sie die automatische Beendigung von Trainingsjobs deaktivieren möchten, müssen Sie die Regel „ CloudWatch Ereignisse“ deaktivieren. Wählen Sie im Lambda **Designer-Bereich** den Block **EventBridge (CloudWatch Events)** aus, der mit der Lambda-Funktion verknüpft ist. Daraufhin wird ein **EventBridge**Bereich unter dem **Designer-Bereich** angezeigt (siehe z. B. den vorherigen Screenshot). Aktivieren Sie das Kontrollkästchen neben **EventBridge (CloudWatch Ereignisse): debugger-cw-event-rule** und wählen Sie dann **Deaktivieren**. Wenn Sie die automatische Kündigungsfunktion später verwenden möchten, können Sie die CloudWatch Ereignisregel erneut aktivieren.
# Visualisieren Sie Amazon SageMaker Debugger-Ausgabetensoren in TensorBoard
**Wichtig**
Diese Seite ist zugunsten von Amazon SageMaker AI with veraltet, das eine umfassende TensorBoard Erfahrung bietet TensoBoard, die in SageMaker Training und die Zugriffskontrollfunktionen von SageMaker AI Domain integriert ist. Weitere Informationen hierzu finden Sie unter [TensorBoard in Amazon SageMaker AI](tensorboard-on-sagemaker.md).
Verwenden Sie SageMaker Debugger, um Ausgabetensordateien zu erstellen, die kompatibel sind mit. TensorBoard Laden Sie die Dateien, um Ihre SageMaker Trainingsjobs zu visualisieren TensorBoard und zu analysieren. Der Debugger generiert automatisch Ausgabetensordateien, die kompatibel sind mit. TensorBoard Für jede Hook-Konfiguration, die Sie zum Speichern von Ausgabetensoren anpassen, bietet Debugger die Flexibilität, skalare Zusammenfassungen, Verteilungen und Histogramme zu erstellen, in die Sie importieren können. TensorBoard
![\[Ein Architekturdiagramm des Debugger-Mechanismus zum Speichern von Ausgabetensoren.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-tensorboard-concept.png)
Sie können dies aktivieren, indem Sie `DebuggerHookConfig` und `TensorBoardOutputConfig` Objekte an eine `estimator` übergeben.
Das folgende Verfahren erklärt, wie Skalare, Gewichte und systematische Abweichungen als vollständige Tensoren, Histogramme und Verteilungen gespeichert werden, mit denen visualisiert werden kann. TensorBoard Der Debugger speichert sie im lokalen Pfad des Trainingscontainers (der Standardpfad ist `/opt/ml/output/tensors`) und synchronisiert sie mit den Amazon S3-Speicherorten, die über die Debugger-Ausgabekonfigurationsobjekte übergeben wurden.
**Um kompatible Ausgabetensordateien mit dem Debugger zu speichern TensorBoard**
1. Richten Sie ein `tensorboard_output_config` Konfigurationsobjekt ein, um die TensorBoard Ausgabe mithilfe der `TensorBoardOutputConfig` Debugger-Klasse zu speichern. Geben Sie für den `s3_output_path` Parameter den Standard-S3-Bucket der aktuellen SageMaker AI-Sitzung oder einen bevorzugten S3-Bucket an. In diesem Beispiel wird der `container_local_output_path` Parameter nicht hinzugefügt, sondern auf den lokalen Standardpfad `/opt/ml/output/tensors` gesetzt.
```
import sagemaker
from sagemaker.debugger import TensorBoardOutputConfig
bucket = sagemaker.Session().default_bucket()
tensorboard_output_config = TensorBoardOutputConfig(
s3_output_path='s3://{}'.format(bucket)
)
```
Weitere Informationen finden Sie unter der `[TensorBoardOutputConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.TensorBoardOutputConfig)` Debugger-API im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
1. Konfigurieren Sie den Debugger-Hook und passen Sie die Hook-Parameterwerte an. Der folgende Code konfiguriert beispielsweise einen Debugger-Hook so, dass alle skalaren Ausgaben in Trainingsphasen alle 100 Schritte und in Validierungsphasen alle 10 Schritte, die `weights` Parameter alle 500 Schritte (der `save_interval` Standardwert für das Speichern von Tensorsammlungen ist 500) und die `bias` Parameter alle 10 globalen Schritte gespeichert werden, bis der globale Schritt 500 erreicht.
```
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig
hook_config = DebuggerHookConfig(
hook_parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
},
collection_configs=[
CollectionConfig("weights"),
CollectionConfig(
name="biases",
parameters={
"save_interval": "10",
"end_step": "500",
"save_histogram": "True"
}
),
]
)
```
Weitere Informationen zur Debugger-Konfiguration APIs finden Sie im Debugger `[CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)` und `[DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)` APIs im [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable).
1. Konstruieren Sie einen SageMaker AI-Schätzer mit den Debugger-Parametern, die die Konfigurationsobjekte übergeben. Die folgende Beispielvorlage zeigt, wie ein generischer SageMaker KI-Schätzer erstellt wird. Sie können `estimator` und `Estimator` durch die übergeordneten Schätzklassen und Schätzerklassen anderer SageMaker KI-Frameworks ersetzen. Verfügbare SageMaker KI-Framework-Schätzer für diese Funktionalität sind, und. `[TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/using_tf.html#create-an-estimator)` `[PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#create-an-estimator)` `[MXNet](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html#create-an-estimator)`
```
from sagemaker.estimator import Estimator
estimator = Estimator(
...
# Debugger parameters
debugger_hook_config=hook_config,
tensorboard_output_config=tensorboard_output_config
)
estimator.fit()
```
Die `estimator.fit()` Methode startet einen Trainingsjob und der Debugger schreibt die Ausgabetensordateien in Echtzeit in den Debugger S3-Ausgabepfad und in den TensorBoard S3-Ausgabepfad. Verwenden Sie die folgenden Schätzmethoden, um die Ausgabepfade abzurufen:
+ Für den Debugger S3-Ausgabepfad, verwenden Sie `estimator.latest_job_debugger_artifacts_path()`.
+ Verwenden Sie für den TensorBoard S3-Ausgabepfad. `estimator.latest_job_tensorboard_artifacts_path()`
1. Überprüfen Sie nach Abschluss des Trainings die Namen der gespeicherten Ausgabetensoren:
```
from smdebug.trials import create_trial
trial = create_trial(estimator.latest_job_debugger_artifacts_path())
trial.tensor_names()
```
1. Überprüfen Sie die TensorBoard Ausgabedaten in Amazon S3:
```
tensorboard_output_path=estimator.latest_job_tensorboard_artifacts_path()
print(tensorboard_output_path)
!aws s3 ls {tensorboard_output_path}/
```
1. Laden Sie die TensorBoard Ausgabedaten auf Ihre Notebook-Instance herunter. Mit dem folgenden AWS CLI Befehl werden die TensorBoard Dateien beispielsweise in das `/logs/fit` aktuelle Arbeitsverzeichnis Ihrer Notebook-Instanz heruntergeladen.
```
!aws s3 cp --recursive {tensorboard_output_path} ./logs/fit
```
1. Komprimieren Sie das Dateiverzeichnis in eine TAR-Datei, um es auf Ihren lokalen Computer herunterzuladen.
```
!tar -cf logs.tar logs
```
1. Laden Sie die Tensorboard-TAR-Datei herunter und extrahieren Sie sie in ein Verzeichnis auf Ihrem Gerät, starten Sie einen Jupyter-Notebook-Server, öffnen Sie ein neues Notizbuch und führen Sie die App aus. TensorBoard
```
!tar -xf logs.tar
%load_ext tensorboard
%tensorboard --logdir logs/fit
```
Der folgende animierte Screenshot veranschaulicht die Schritte 5 bis 8. Es zeigt, wie Sie die Debugger-TAR-Datei herunterladen und TensorBoard die Datei in ein Jupyter-Notebook auf Ihrem lokalen Gerät laden.
![\[Animation zum Herunterladen und Laden der TensorBoard Debugger-Datei auf Ihren lokalen Computer.\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/images/debugger/debugger-tensorboard.gif)
# Liste der in den Debugger integrierten Regeln
Sie können anhand der in den Debugger integrierten Regeln, die von Amazon SageMaker Debugger bereitgestellt werden, Kennzahlen und Tensoren analysieren, die beim Training Ihrer Modelle gesammelt wurden. Im Folgenden sind die Debugger-Regeln aufgeführt, einschließlich Informationen und eines Beispiels zur Konfiguration und Bereitstellung der einzelnen integrierten Regeln.
Die in den Debugger integrierten Regeln überwachen verschiedene häufige Bedingungen, die für den Erfolg eines Trainings-Jobs entscheidend sind. Die integrierten Regeln können Sie mithilfe der [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) oder der Low-Level-SageMaker-API-Operationen aufrufen.
Für die Nutzung der integrierten Regeln fallen keine zusätzlichen Kosten an. Weitere Informationen zur Fakturierung finden Sie unter [Amazon SageMaker – Preise](https://aws.amazon.com/sagemaker/pricing/).
**Anmerkung**
Die maximale Anzahl integrierter Regeln, die Sie einem Training-Job zuordnen können, beträgt 20. Der SageMaker Debugger verwaltet die integrierten Regeln vollständig und analysiert synchron Ihren Training-Job.
**Wichtig**
Um die neuen Debugger-Features nutzen zu können, müssen Sie das SageMaker Python SDK und die SMDebug-Client-Bibliothek erweitern. Führen Sie in Ihrer IPython-Kernel-, Jupyter-Notebook- oder JupyterLab-Umgebung den folgenden Code aus, um die aktuellen Versionen der Bibliotheken zu installieren, und starten Sie den Kernel neu.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Debugger-Regel
Die folgenden Regeln sind die in den Debugger integrierten Regeln, die mit der Klassenmethode `Rule.sagemaker` aufgerufen werden können.
In den Debugger integrierte Regeln zum Erzeugen von Trainingsberichten
| Gültigkeitsbereich | Integrierte Regeln |
| --- | --- |
| Trainingsbericht für den Trainingsjob in SageMaker AI XGBoost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-built-in-rules.html) |
In den Debugger integrierte Regeln zum Debuggen von Modelltrainingsdaten (Ausgabetensoren)
| Gültigkeitsbereich | Integrierte Regeln |
| --- | --- |
| Deep-Learning-Frameworks (TensorFlow, Apache MXNet und PyTorch) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Deep-Learning-Frameworks (TensorFlow, MXNet und PyTorch) und der XGBoost-Algorithmus | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Deep-Learning-Anwendungen | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-built-in-rules.html) |
| XGBoost-Algorithmus | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-built-in-rules.html) |
**Um die integrierten Regeln mit Standardparameterwerten zu verwenden**, verwenden Sie das folgende Konfigurationsformat:
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
Rule.sagemaker(rule_configs.built_in_rule_name_1()),
Rule.sagemaker(rule_configs.built_in_rule_name_2()),
...
Rule.sagemaker(rule_configs.built_in_rule_name_n())
]
```
**Um die integrierten Regeln mit individuellen Parameterwerten zu verwenden**, verwenden Sie das folgende Konfigurationsformat:
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
Rule.sagemaker(
base_config=rule_configs.built_in_rule_name(),
rule_parameters={
"key": "value"
}
collections_to_save=[
CollectionConfig(
name="tensor_collection_name",
parameters={
"key": "value"
}
)
]
)
]
```
Die verfügbaren Schlüssel für den Parameter `rule_parameters` finden Sie in den Tabellen mit den Parameterbeschreibungen.
Unter den Tabellen mit den Parameterbeschreibungen finden Sie für jede integrierte Regel Beispielkonfigurationscodes.
+ Eine vollständige Anleitung und Beispiele für die Verwendung der in den Debugger integrierten Regeln finden Sie unter [Beispielcode für integrierte Debugger-Regeln](debugger-built-in-rules-example.md#debugger-deploy-built-in-rules).
+ Eine vollständige Anleitung zur Verwendung der integrierten Regeln mit den SageMaker-API-Operationen auf niedriger Ebene finden Sie unter [Debugger mithilfe SageMaker der API konfigurieren](debugger-createtrainingjob-api.md).
## CreateXgboostReport
Die Regel CreateXGBoostReport sammelt Ausgabetensoren aus einem XGBoost-Training-Job und erzeugt automatisch einen umfassenden Trainingsbericht. Sie können einen umfassenden Profilerstellungsbericht herunterladen, während ein Training-Job ausgeführt wird oder nachdem der Training-Job abgeschlossen ist, und den Trainingsfortschritt oder das Endergebnis des Training-Jobs überprüfen. Die Regel CreateXGBoostReport erfasst standardmäßig die folgenden Ausgabetensoren:
+ `hyperparameters`– Speichert beim ersten Schritt
+ `metrics`– Speichert Verlust und Genauigkeit alle 5 Schritte
+ `feature_importance`– Speichert alle 5 Schritte
+ `predictions`– Speichert alle 5 Schritte
+ `labels`– Speichert alle 5 Schritte
Parameterbeschreibungen für die Regel CreateXgboostReport
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
```
rules=[
Rule.sagemaker(
rule_configs.create_xgboost_report()
)
]
```
## DeadRelu
Diese Regel erkennt, wenn der Prozentsatz der Aktivierungsfunktionen für die berichtigte lineare Einheit (ReLU) in einer Testversion als tot angesehen wird, da ihre Aktivierungsaktivität einen bestimmten Schwellenwert unterschritten hat. Wenn der Prozentsatz der inaktiven ReLUs in einer Ebene größer ist als der `threshold_layer`-Wert inaktiver ReLUs, gibt die Regel `True` zurück.
Parameterbeschreibungen für die DeadRelu-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| tensor\$1regex | Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: `".*relu_output"` |
| threshold\$1inactivity | Definiert einen Aktivitätsgrad, unter dem ein ReLU als tot angesehen wird. Ein ReLU kann zu Beginn einer Testphase aktiv sein und dann während des Trainings langsam inaktiv werden. Wenn das ReLU weniger aktiv ist als der `threshold_inactivity`, gilt es als tot. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `1.0` (in Prozent) |
| threshold\$1layer | Gibt `True` zurück, wenn der Prozentsatz der inaktiven ReLUs in einer Ebene größer als `threshold_layer` ist. Gibt `False` zurück, wenn der Prozentsatz der inaktiven ReLUs in einer Ebene kleiner als `threshold_layer` ist. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `50.0` (in Prozent) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.dead_relu(),
rule_parameters={
"tensor_regex": ".*relu_output|.*ReLU_output",
"threshold_inactivity": "1.0",
"threshold_layer": "50.0"
},
collections_to_save=[
CollectionConfig(
name="custom_relu_collection",
parameters={
"include_regex: ".*relu_output|.*ReLU_output",
"save_interval": "500"
}
)
]
)
]
```
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
**Anmerkung**
Diese Regel steht für den XGBoost-Algorithmus nicht zur Verfügung.
## ExplodingTensor
Diese Regel erkennt, ob die während des Trainings ausgegebenen Tensoren unendliche Werte aufweisen, entweder unendlich oder NaN (keine Zahl). Wenn ein nicht endlicher Wert erkannt wird, gibt die Regel `True` zurück.
Parameterbeschreibungen für die ExplodingTensor-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| collection\$1names | Die Liste der Sammlungsnamen, deren Tensoren durch die Regel geprüft werden. **Optional** Zulässige Werte: String Standardwert: `None` |
| tensor\$1regex | Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Zulässige Werte: String Standardwert: `None` |
| only\$1nan | `True`, um die `base_trial`-Tensoren nur auf `NaN`-Werte und nicht auf Unendlichkeit zu überwachen. `False`, um sowohl `NaN` als auch Unendlichkeit als explodierende Werte zu behandeln und beide zu überwachen. **Optional** Standardwert: `False` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.exploding_tensor(),
rule_parameters={
"tensor_regex": ".*gradient",
"only_nan": "False"
},
collections_to_save=[
CollectionConfig(
name="gradients",
parameters={
"save_interval": "500"
}
)
]
)
]
```
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
**Anmerkung**
Diese Regel steht für den XGBoost-Algorithmus nicht zur Verfügung.
## PoorWeightInitialization
Diese Regel erkennt, ob die Modellparameter schlecht initialisiert wurden.
Eine gute Initialisierung unterbricht die Symmetrie der Gewichte und Gradienten in einem neuronalen Netzwerk und behält die angemessenen Aktivierungsvarianzen über Ebenen hinweg bei. Andernfalls lernt das neuronale Netzwerk nicht effektiv. Initialisierer wie Xavier zielen darauf ab, die Varianz über Aktivierungen hinweg konstant zu halten, was besonders für das Training sehr tiefer neuronaler Netze relevant ist. Eine zu kleine Initialisierung kann zu verschwindenden Gradienten führen. Eine zu große Initialisierung kann zu explodierenden Gradienten führen. Diese Regel überprüft die Varianz der Aktivierungseingänge über Ebenen hinweg, die Verteilung der Gradienten und die Verlustkonvergenz für die ersten Schritte, um festzustellen, ob ein neuronales Netzwerk schlecht initialisiert wurde.
Parameterbeschreibungen für die PoorWeightInitialization-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| activation\$1inputs\$1regex | Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Zulässige Werte: String Standardwert: `".*relu_input"` |
| threshold | Wenn das Verhältnis zwischen minimaler und maximaler Varianz der Gewichtungen pro Ebene die `threshold` bei einem Schritt überschreitet, gibt die Regel `True` zurück. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `10.0` |
| distribution\$1range | Wenn die Mindestdifferenz zwischen dem 5. und dem 95. Perzentil der Gradientenverteilung kleiner ist als der `distribution_range`, gibt die Regel `True` zurück. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `0.001` |
| patience | Die Anzahl der Schritte, über die hinweg gewartet werden soll, bis der Verlust als nicht mehr abnehmend betrachtet wird. **Optional** Gültige Werte: Ganzzahl Standardwert: `5` |
| steps | Die Anzahl der Schritte, die diese Regel analysiert. In der Regel müssen Sie nur die ersten paar Iterationen überprüfen. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `10` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.poor_weight_initialization(),
rule_parameters={
"activation_inputs_regex": ".*relu_input|.*ReLU_input",
"threshold": "10.0",
"distribution_range": "0.001",
"patience": "5",
"steps": "10"
},
collections_to_save=[
CollectionConfig(
name="custom_relu_collection",
parameters={
"include_regex": ".*relu_input|.*ReLU_input",
"save_interval": "500"
}
)
]
)
]
```
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
**Anmerkung**
Diese Regel steht für den XGBoost-Algorithmus nicht zur Verfügung.
## SaturatedActivation
Diese Regel erkennt, ob die Tanh- und Sigmoid-Aktivierungsebenen gesättigt werden. Eine Aktivierungsschicht ist gesättigt, wenn die Eingabe der Schicht nahe dem Maximum oder Minimum der Aktivierungsfunktion liegt. Das Minimum und Maximum der Tanh- und Sigmoid-Aktivierungsfunktionen werden durch ihre jeweiligen – `min_threshold`und `max_thresholds`-Werte definiert. Wenn die Aktivität eines Knotens unter den `threshold_inactivity`-Prozentsatz fällt, gilt er als gesättigt. Wenn mehr als ein `threshold_layer`-Prozent der Knoten gesättigt sind, gibt die Regel `True` zurück.
Parameterbeschreibungen für die SaturatedActivation-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| collection\$1names | Die Liste der Sammlungsnamen, deren Tensoren durch die Regel geprüft werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: Keiner |
| tensor\$1regex | Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Zulässige Werte: String Standardwert: `".*tanh_input\|.*sigmoid_input".` |
| threshold\$1tanh\$1min | Die minimalen und maximalen Schwellenwerte, die die Extremwerte der Eingabe für eine Tanh-Aktivierungsfunktion definieren, definiert als: `(min_threshold, max_threshold)`. Die Standardwerte werden basierend auf einem Schwellenwert für verschwindende Gradienten von 0,0000001 ermittelt. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `-9.4999` |
| threshold\$1tanh\$1max | Die minimalen und maximalen Schwellenwerte, die die Extremwerte der Eingabe für eine Tanh-Aktivierungsfunktion definieren, definiert als: `(min_threshold, max_threshold)`. Die Standardwerte werden basierend auf einem Schwellenwert für verschwindende Gradienten von 0,0000001 ermittelt. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `9.4999` |
| threshold\$1sigmoid\$1min | Die minimalen und maximalen Schwellenwerte, die die Extremwerte der Eingabe für eine Sigmoid-Aktivierungsfunktion definieren, definiert als: `(min_threshold, max_threshold)`. Die Standardwerte werden basierend auf einem Schwellenwert für verschwindende Gradienten von 0,0000001 ermittelt. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `-23` |
| threshold\$1sigmoid\$1max | Die minimalen und maximalen Schwellenwerte, die die Extremwerte der Eingabe für eine Sigmoid-Aktivierungsfunktion definieren, definiert als: `(min_threshold, max_threshold)`. Die Standardwerte werden basierend auf einem Schwellenwert für verschwindende Gradienten von 0,0000001 ermittelt. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `16.99999` |
| threshold\$1inactivity | Der Prozentsatz der Inaktivität, unterhalb dessen die Aktivierungsebene als gesättigt angesehen wird. Die Aktivierung kann zu Beginn einer Testphase aktiv sein und dann langsam während des Trainings weniger aktiv werden. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `1.0` |
| threshold\$1layer | Gibt `True` zurück, wenn die Anzahl der gesättigten Aktivierungen in einer Ebene größer als der `threshold_layer`-Prozentsatz ist. Gibt `False` zurück, wenn die Anzahl der gesättigten Aktivierungen in einer Ebene kleiner als der `threshold_layer`-Prozentsatz ist. **Optional** Gültige Werte: Gleitkommazahl. Standardwerte: `50.0` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.saturated_activation(),
rule_parameters={
"tensor_regex": ".*tanh_input|.*sigmoid_input",
"threshold_tanh_min": "-9.4999",
"threshold_tanh_max": "9.4999",
"threshold_sigmoid_min": "-23",
"threshold_sigmoid_max": "16.99999",
"threshold_inactivity": "1.0",
"threshold_layer": "50.0"
},
collections_to_save=[
CollectionConfig(
name="custom_activations_collection",
parameters={
"include_regex": ".*tanh_input|.*sigmoid_input"
"save_interval": "500"
}
)
]
)
]
```
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
**Anmerkung**
Diese Regel steht für den XGBoost-Algorithmus nicht zur Verfügung.
## VanishingGradient
Diese Regel erkennt, ob die Gradients in einer Testversion extrem klein werden oder auf eine Größenordnung von Null abfallen. Wenn der Mittelwert der Absolutwerte der Gradienten unter einen angegebenen `threshold` fällt, gibt die Regel `True` zurück.
Parameterbeschreibungen für die VanishingGradient-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| threshold | Der Wert, ab dem der Gradienten als verschwindend betrachtet wird.**Optional**Gültige Werte: Gleitkommazahl.Standardwert: `0.0000001`. |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.vanishing_gradient(),
rule_parameters={
"threshold": "0.0000001"
},
collections_to_save=[
CollectionConfig(
name="gradients",
parameters={
"save_interval": "500"
}
)
]
)
]
```
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
**Anmerkung**
Diese Regel steht für den XGBoost-Algorithmus nicht zur Verfügung.
## WeightUpdateRatio
Diese Regel verfolgt das Verhältnis von Aktualisierungen zu Gewichten während des Trainings und erkennt, ob dieses Verhältnis zu groß oder zu klein wird. Wenn das Verhältnis von Aktualisierungen zu Gewichten größer ist als der `large_threshold value` oder wenn dieses Verhältnis kleiner ist als der `small_threshold`, gibt die Regel `True` zurück.
Die Bedingungen für das Training sind optimal, wenn die Aktualisierungen den Gradienten entsprechen. Übermäßig große Aktualisierungen können dazu führen, dass weniger Gewichte auf optimale Werte fallen, und sehr kleine Aktualisierungen haben eine stark verlangsamte Konvergenz zur Folge. Für diese Regel ist es erforderlich, dass Gewichte für zwei Trainingsschritte zur Verfügung stehen, und `train.save_interval` muss so eingestellt werden, dass es gleich `num_steps` ist.
Parameterbeschreibungen für die WeightUpdateRatio-Regel
| Parametername, | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| num\$1steps | Die Anzahl der Schritte, über die hinweg die Regel prüft, ob sich der Tensor geändert hat. Die Anzahl der Schritte, über die Sie die Gewichtsverhältnisse vergleichen möchten. Wenn Sie keinen Wert übergeben, wird die Regel standardmäßig für den aktuellen Schritt und den unmittelbar vorherigen gespeicherten Schritt ausgeführt. Wenn Sie den Standardwert umgehen, indem Sie einen Wert für diesen Parameter übergeben, erfolgt der Vergleich zwischen Gewichten in Schritt `s` und in Schritt `>= s - num_steps`. **Optional** Gültige Werte: Ganzzahl Standardwert: `None` |
| large\$1threshold | Der Maximalwert, den das Verhältnis von Aktualisierungen zu Gewichten erreichen kann, bevor die Regel `True` zurückgibt. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `10.0` |
| small\$1threshold | Der Mindestwert, den das Verhältnis von Aktualisierungen zu Gewichten erreichen kann, unterhalb dessen die Regel `True` zurückgibt. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `0.00000001` |
| epsilon | Eine kleine Konstante, die sicherstellt, dass der Debugger nicht durch Null teilt, wenn die Berechnung des Verhältnisses auf Gewicht aktualisiert wird. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `0.000000001` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.weight_update_ratio(),
rule_parameters={
"num_steps": "100",
"large_threshold": "10.0",
"small_threshold": "0.00000001",
"epsilon": "0.000000001"
},
collections_to_save=[
CollectionConfig(
name="weights",
parameters={
"train.save_interval": "100"
}
)
]
)
]
```
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
**Anmerkung**
Diese Regel steht für den XGBoost-Algorithmus nicht zur Verfügung.
## AllZero
Diese Regel erkennt, ob alle oder ein bestimmter Prozentsatz der Tensorwerte Null sind.
Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden. Sie müssen entweder den Parameter `collection_names` oder `tensor_regex` angeben. Wenn beide Parameter angegeben sind, prüft die Regel die Vereinigung von Tensoren aus beiden Sätzen.
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
Parameterbeschreibungen für die AllZero-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| collection\$1names | Die Liste der Sammlungsnamen, deren Tensoren durch die Regel geprüft werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: `None` |
| tensor\$1regex | Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: `None` |
| threshold | Gibt den Prozentsatz der Werte im Tensor an, der Null sein muss, damit diese Regel aufgerufen wird. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: 100 (in Prozent) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.all_zero(),
rule_parameters={
"tensor_regex": ".*",
"threshold": "100"
},
collections_to_save=[
CollectionConfig(
name="all",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## ClassImbalance
Diese Regel misst Stichprobenungleichgewichte zwischen Klassen und löst Fehler aus, wenn das Ungleichgewicht einen Schwellenwert überschreitet oder wenn aufgrund des Ungleichgewichts zu viele Fehlprognosen für unterrepräsentierte Klassen auftreten.
Klassifizierungsmodelle erfordern ausgewogene Klassen im Trainingsdatensatz oder eine korrekte Gewichtung bzw. Stichprobenahme von Klassen während des Trainings. Die Regel nimmt die folgenden Prüfungen vor:
+ Sie zählt die Vorkommen pro Klasse. Wenn das Verhältnis der Anzahl der Stichproben zwischen kleinster und größter Klasse größer ist als die `threshold_imbalance`, wird ein Fehler ausgelöst.
+ Sie überprüft die Vorhersagegenauigkeit pro Klasse. Wenn Resampling (Stichprobenwiederholung) oder Gewichtung nicht korrekt angewendet wurde, kann das Modell mit vielen Trainingsstichproben eine hohe Genauigkeit für die Klasse erreichen, aber geringe Genauigkeit für die Klassen mit wenigen Trainingsstichproben. Wenn ein Anteil von Fehlvorhersagen für eine bestimmte Klasse `threshold_misprediction` übersteigt, wird ein Fehler ausgelöst.
Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden.
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
Parameterbeschreibungen für die ClassImbalance-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| threshold\$1imbalance | Das akzeptable Ungleichgewicht zwischen der Anzahl der Stichproben in der kleinsten Klasse und in der größten Klasse. Wenn Sie diesen Schwellenwert überschreiten, wird ein Fehler ausgegeben. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `10` |
| threshold\$1misprediction | Eine Begrenzung für den Anteil an Fehlvorhersagen, der für jede Klasse zulässig ist. Wenn Sie diesen Schwellenwert überschreiten, wird ein Fehler ausgegeben. Die unterrepräsentierten Klassen sind am meisten gefährdet, diese Schwelle zu überschreiten. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `0.7` |
| samples | Die Anzahl von Labels, die verarbeitet werden müssen, bevor ein Ungleichgewicht ausgewertet wird. Die Regel wird möglicherweise erst ausgelöst, wenn über mehrere Schritte hinweg ausreichende Stichproben angezeigt wurden. Je mehr Klassen Ihr Datensatz enthält, desto größer sollte diese `sample`-Anzahl sein. **Optional** Gültige Werte: Ganzzahl Standardwert: `500` (unter der Annahme eines Datensatzes wie MNIST mit 10 Klassen) |
| argmax | Wenn `True`, wird [np.argmax](https://docs.scipy.org/doc/numpy-1.9.3/reference/generated/numpy.argmax.html) auf den Vorhersage-Tensor angewendet. Erforderlich, wenn ein Vektor von Wahrscheinlichkeiten für jede Klasse vorhanden ist. Anhand von ihm wird bestimmt, welche Klasse die höchste Wahrscheinlichkeit hat. **Bedingt** Zulässige Werte: Boolesch Standardwert: `False` |
| labels\$1regex | Der Name des Tensors, der die Labels enthält. **Optional** Zulässige Werte: String Standardwert: `".*labels"` |
| predictions\$1regex | Der Name des Tensors, der die Vorhersagen enthält. **Optional** Zulässige Werte: String Standardwert: `".*predictions"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.class_imbalance(),
rule_parameters={
"threshold_imbalance": "10",
"threshold_misprediction": "0.7",
"samples": "500",
"argmax": "False",
"labels_regex": ".*labels",
"predictions_regex": ".*predictions"
},
collections_to_save=[
CollectionConfig(
name="custom_output_collection",
parameters={
"include_regex": ".*labels|.*predictions",
"save_interval": "500"
}
)
]
)
]
```
## LossNotDecreasing
Diese Regel erkennt, wenn der Verlust nicht mit einer angemessenen Rate an Wert abnimmt. Diese Verluste müssen Skalare sein.
Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden. Sie müssen entweder den Parameter `collection_names` oder `tensor_regex` angeben. Wenn beide Parameter angegeben sind, prüft die Regel die Vereinigung von Tensoren aus beiden Sätzen.
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
Parameterbeschreibungen für die LossNotDecreasing-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| collection\$1names | Die Liste der Sammlungsnamen, deren Tensoren durch die Regel geprüft werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: `None` |
| tensor\$1regex | Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: `None` |
| use\$1losses\$1collection | Wenn diese Option auf `True` gesetzt ist, wird nach Verlusten in der Sammlung „losses (Verluste)“ gesucht, sofern die Sammlung vorhanden ist. **Optional** Zulässige Werte: Boolesch Standardwert: `True` |
| num\$1steps | Die Mindestanzahl von Schritten, nach denen die Regel prüft, ob der Verlust zurückgegangen ist. Regelauswertung findet alle `num_steps` statt. Die Regel vergleicht den Verlust für diesen Schritt mit dem Verlust bei einem Schritt, der zumindest `num_steps` hinter dem aktuellen Schritt liegt. Angenommen, der Verlust wird alle drei Schritte gespeichert, aber `num_steps` ist auf 10 gesetzt. Bei Schritt 21 wird der Verlust für Schritt 21 mit dem Verlust für Schritt 9 verglichen. Der nächste Schritt, bei dem der Verlust überprüft wird, ist Schritt 33, da zehn Schritte nach Schritt 21 Schritt 31 ist und bei Schritt 31 und Schritt 32 der Verlust nicht gespeichert wird. **Optional** Gültige Werte: Ganzzahl Standardwert: `10` |
| diff\$1percent | Die minimale prozentuale Differenz, um die sich der Verlust zwischen `num_steps` verringern sollte. **Optional** Gültige Werte: `0.0` < Gleitkommazahl < `100` Standardwert: `0.1` (in Prozent) |
| increase\$1threshold\$1percent | Der maximale prozentuale Schwellenwert, um den sich der Verlust erhöhen darf, falls der Verlust gestiegen ist **Optional** Gültige Werte: `0` < Gleitkommazahl < `100` Standardwert: `5` (in Prozent) |
| mode | Der Name des Debugger-Modus für die Abfrage von Tensorwerten zur Prüfung der Regel. Wenn er nicht übergeben wird, prüft die Regel standardmäßig nacheinander auf `mode.EVAL`, `mode.TRAIN` und dann `mode.GLOBAL`. **Optional** Gültige Werte: Zeichenfolge (`EVAL`, `TRAIN` oder `GLOBAL`) Standardwert: `GLOBAL` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.loss_not_decreasing(),
rule_parameters={
"tensor_regex": ".*",
"use_losses_collection": "True",
"num_steps": "10",
"diff_percent": "0.1",
"increase_threshold_percent": "5",
"mode": "GLOBAL"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## Overfit
Diese Regel erkennt, ob Ihr Modell übermäßig an die Trainingsdaten angepasst ist, indem die Validierungs- und Trainingsverluste miteinander verglichen werden.
Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden.
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
**Anmerkung**
Eine Standardmethode, eine Überanpassung zu verhindern, besteht darin, Ihr Modell zu regulieren.
Parameterbeschreibungen für die Overfit-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| tensor\$1regex | Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: Keiner |
| start\$1step | Der Schritt, ab dem Validierung und Trainingsverlust miteinander verglichen werden sollen. **Optional** Gültige Werte: Ganzzahl Standardwert: `0` |
| patience | Die Anzahl der Schritte, für die der `ratio_threshold` den eingestellten Wert überschreiten darf, bevor das Modell als überdimensioniert angesehen wird. **Optional** Gültige Werte: Ganzzahl Standardwert: `1` |
| ratio\$1threshold | Das maximale Verhältnis der Differenz zwischen dem mittleren Validierungsverlust und dem mittleren Trainingsverlust. Wenn dieser Schwellenwert für eine `patience`-Anzahl von Schritten überschritten wird, erfolgt eine Überanpassung des Modells und die Regel gibt `True` zurück. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `0.1` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.overfit(),
rule_parameters={
"tensor_regex": ".*",
"start_step": "0",
"patience": "1",
"ratio_threshold": "0.1"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
}
)
]
)
]
```
## Overtraining
Diese Regel erkennt, wenn ein Modell übertrainiert wird. Nach einer Reihe von Trainingsdurchgängen mit einem gut funktionierenden Modell (sowohl der Trainings- als auch der Validierungsverlust nehmen ab) nähert sich das Modell einem Minimum der Verlustfunktion und verbessert sich nicht mehr. Wenn das Modell weiter trainiert wird, kann es vorkommen, dass der Validierungsverlust zunimmt, weil das Modell anfängt, zu starke Anpassungen vorzunehmen. Diese Regel legt Schwellenwerte und Bedingungen fest, um festzustellen, ob sich das Modell nicht mehr verbessert, und verhindert Probleme durch zu starke Anpassungen aufgrund von Übertraining.
Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden.
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
**Anmerkung**
Overtraining kann durch frühzeitiges Stoppen vermieden werden. Hinweise zum vorzeitigen Beenden finden Sie unter [Vorzeitiges Beenden von Trainingsaufträgen](automatic-model-tuning-early-stopping.md). Ein Beispiel, das zeigt, wie das Spot-Training zusammen mit dem Debugger verwendet wird, finden Sie unter [Spot-Training mit Amazon SageMaker Debugger aktivieren](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/mxnet_spot_training/mxnet-spot-training-with-sagemakerdebugger.html).
Parameterbeschreibungen für die Overtraining-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| patience\$1train | Die Anzahl der Schritte, die vor dem Trainingsverlust zu warten sind, soll nicht mehr verbessert werden. **Optional** Gültige Werte: Ganzzahl Standardwert: `5` |
| patience\$1validation | Die Anzahl von Schritte, die gewartet werden soll, bis dem Validierungsverlust als sich nicht mehr verbessernd angesehen wird.**Optional**Gültige Werte: GanzzahlStandardwert: `10` |
| delta | Die Mindestschwelle, um die sich der Fehler verbessern sollte, bevor er als neues Optimum angesehen wird. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `0.01` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.overtraining(),
rule_parameters={
"patience_train": "5",
"patience_validation": "10",
"delta": "0.01"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## SimilarAcrossRuns
Diese Regel vergleicht Tensoren, die aus einer Basisversion gesammelt wurden, mit Tensoren aus einer anderen Testversion.
Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden.
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
Parameterbeschreibungen für die SimilarAcrossRuns-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| other\$1trials | Der Name eines abgeschlossenen Training-Jobs, dessen Tensoren Sie mit denjenigen Tensoren vergleichen möchten, die aus dem aktuellen `base_trial` erhalten wurden. **Erforderlich** Zulässige Werte: String |
| collection\$1names | Die Liste der Sammlungsnamen, deren Tensoren durch die Regel geprüft werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: Keiner |
| tensor\$1regex | Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: Keiner |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.similar_across_runs(),
rule_parameters={
"other_trials": "",
"collection_names": "losses",
"tensor_regex": ".*"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## StalledTrainingRule
StalledTrainingRule erkennt, ob bei einem Training-Job keine Fortschritte mehr erzielt werden, und stoppt den Training-Job, wenn die Regel ausgelöst wird. Für diese Regel ist es erforderlich, dass Tensoren regelmäßig in einem Zeitintervall gespeichert werden, das durch ihren Parameter `threshold` festgelegt wird. Diese Regel hält ständig nach neuen Tensoren Ausschau, und wenn kein neuer Tensor für den Schwellenwert ausgegeben wurde, wird die Intervallregel ausgelöst.
Parameterbeschreibungen für die Regel StalledTrainingRule
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| threshold | Ein Schwellenwert, der festlegt, wie viel Zeit in Sekunden die Regel auf eine Tensorausgabe wartet, bis ein Problem wegen eines stehengebliebenen Trainings ausgelöst wird. Der Standardwert beträgt 1800 Sekunden. **Optional** Gültige Werte: Ganzzahl Standardwert: `1800` |
| stop\$1training\$1on\$1fire | Falls dieser auf `True` gesetzt ist, wird überwacht, ob der Basis-Training-Job innerhalb von „`threshold`“ Sekunden Tensoren ausgibt. **Optional** Zulässige Werte: Boolesch Standardwert: `False` |
| training\$1job\$1name\$1prefix | Das Präfix des Namens eines Basis-Training-Jobs. Falls `stop_training_on_fire` zutrifft, sucht die Regel im selben Konto nach SageMaker-Training-Jobs mit diesem Präfix. Wenn eine Inaktivität gefunden wird, ergreift die Regel eine `StopTrainingJob` Maßnahme. Beachten Sie, dass die Regel den Abbruch überspringt, wenn mehrere Jobs mit demselben Präfix gefunden wurden. Es ist wichtig, dass das Präfix für jeden Training-Job eindeutig festgelegt wird. **Optional** Zulässige Werte: String |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "1800",
"stop_training_on_fire": "True",
"training_job_name_prefix": ""
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## TensorVariance
Diese Regel erkennt, ob Sie Tensoren mit sehr hohen oder niedrigen Varianzen haben. Sehr hohe oder niedrige Abweichungen in einem Tensor könnten zu einer Neuronensättigung führen, wodurch die Lernfähigkeit des neuronalen Netzwerks verringert wird. Eine sehr hohe Varianz in Tensoren kann letztendlich auch zu explodierenden Tensoren führen. Verwenden Sie diese Regel, um solche Probleme frühzeitig zu erkennen.
Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden. Sie müssen entweder den Parameter `collection_names` oder `tensor_regex` angeben. Wenn beide Parameter angegeben sind, prüft die Regel die Vereinigung von Tensoren aus beiden Sätzen.
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
Parameterbeschreibungen für die TensorVariance-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| collection\$1names | Die Liste der Sammlungsnamen, deren Tensoren durch die Regel geprüft werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: Keiner |
| tensor\$1regex | Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: Keiner |
| max\$1threshold | Der Schwellenwert für die Obergrenze der Tensorvarianz. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: Keiner |
| min\$1threshold | Der Schwellenwert für die Untergrenze der Tensorvarianz. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: Keiner |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.tensor_variance(),
rule_parameters={
"collection_names": "weights",
"max_threshold": "10",
"min_threshold": "0.00001",
},
collections_to_save=[
CollectionConfig(
name="weights",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## UnchangedTensor
Diese Regel erkennt, ob sich ein Tensor über Schritte hinweg nicht mehr ändert.
Diese Regel führt die Methode [numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html) aus, um zu überprüfen, ob sich der Tensor nicht ändert.
Diese Regel kann entweder auf eines der unterstützten Deep-Learning-Frameworks (TensorFlow, MxNet und PyTorch) oder auf den XGBoost-Algorithmus angewendet werden. Sie müssen entweder den Parameter `collection_names` oder `tensor_regex` angeben. Wenn beide Parameter angegeben sind, prüft die Regel die Vereinigung von Tensoren aus beiden Sätzen.
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
Parameterbeschreibungen für die UnchangedTensor-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| collection\$1names | Die Liste der Sammlungsnamen, deren Tensoren durch die Regel geprüft werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: Keiner |
| tensor\$1regex | Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: Keiner |
| num\$1steps | Die Anzahl der Schritte, über die hinweg die Regel prüft, ob sich der Tensor geändert hat. Hiermit werden die letzten verfügbaren `num_steps` überprüft. Sie müssen nicht aufeinander folgen. Wenn `num_steps` 2 ist, überprüft es bei Schritt „s“ nicht unbedingt auf „s-1“ und „s“. Wenn „s-1“ nicht verfügbar ist, wird der letzte verfügbare Schritt zusammen mit „s“ überprüft. In diesem Fall wird der letzte verfügbare Schritt anhand des aktuellen Schritts überprüft. **Optional** Gültige Werte: Ganzzahl Standardwert: `3` |
| rtol | Der relative Toleranzparameter, der an die Methode `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` übergeben werden soll. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `1e-05` |
| atol | Der absolute Toleranzparameter, der an die Methode `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` übergeben werden soll. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `1e-08` |
| equal\$1nan | Ob NaNs als gleichwertig zu vergleichen sind. Bei dem Wert `True` werden NaNs in Eingabe-Array a im Ausgabe-Array als gleichwertig mit NaNs in Eingabe-Array b angesehen. Dieser Parameter wird an die Methode `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` übergeben. **Optional** Zulässige Werte: Boolesch Standardwert: `False` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.unchanged_tensor(),
rule_parameters={
"collection_names": "losses",
"tensor_regex": "",
"num_steps": "3",
"rtol": "1e-05",
"atol": "1e-08",
"equal_nan": "False"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## CheckInputImages
Diese Regel prüft, ob Eingabebilder korrekt normalisiert wurden. Insbesondere wird festgestellt, ob der Mittelwert der Stichprobendaten um mehr als einen Schwellenwert von Null abweicht. Viele Modelle des maschinellen Sehens erfordern Eingabedaten mit einem Mittelwert und einer Einheitenvarianz von Null.
Diese Regel gilt für Deep-Learning-Anwendungen.
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
Parameterbeschreibungen für die CheckInputImages-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| threshold\$1mean | Ein Schwellenwert, der definiert, um wie viel der Mittelwert der Eingabedaten von 0 abweichen kann. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `0.2` |
| threshold\$1samples | Die Anzahl der Bilder, von denen Stichproben genommen werden müssen, bevor ein Fehler ausgelöst werden kann. Wenn der Wert zu niedrig ist, ist die Schätzung des Mittelwerts des Datensatzes ungenau. **Optional** Gültige Werte: Ganzzahl Standardwert: `500` |
| regex | Der Name des Eingabedatentensors. **Optional** Zulässige Werte: String Standardwert: `".*hybridsequential0_input_0"` (der Name des Eingabe-Tensors für Apache MXNet-Modelle, die HybridSequential verwenden) |
| channel | Die Position des Farbkanals im Formarray des Eingabetensors. **Optional** Gültige Werte: Ganzzahl Standardwert: `1` (Beispiel: MXNet erwartet Eingabedaten in Form von (batch\$1size, channel, height, width)) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.check_input_images(),
rule_parameters={
"threshold_mean": "0.2",
"threshold_samples": "500",
"regex": ".*hybridsequential0_input_0",
"channel": "1"
},
collections_to_save=[
CollectionConfig(
name="custom_inputs_collection",
parameters={
"include_regex": ".*hybridsequential0_input_0",
"save_interval": "500"
}
)
]
)
]
```
## NLPSequenceRatio
Diese Regel berechnet das Verhältnis bestimmter Token, wenn der Rest der Eingabesequenz angegeben wird, die für die Optimierung der Leistung nützlich ist. Sie können beispielsweise den Prozentsatz von EOS-Auffüllungs-Token (End-of-Sentence, Satzende) in Ihrer Eingabesequenz berechnen. Wenn die Anzahl der EOS-Token zu hoch ist, sollte eine alternative Bucketing-Strategie durchgeführt werden. Sie können auch den Prozentsatz unbekannter Token in Ihrer Eingabesequenz berechnen. Wenn die Anzahl unbekannter Wörter zu hoch ist, kann ein alternatives Vokabular verwendet werden.
Diese Regel gilt für Deep-Learning-Anwendungen.
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
Parameterbeschreibungen für die NLPSequenceRatio-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| tensor\$1regex | Eine Liste von Regex-Mustern, die verwendet wird, um diesen Vergleich auf bestimmte skalarwertige Tensoren zu beschränken. Die Regel prüft nur die Tensoren, die mit den in der Liste angegebenen Regex-Mustern übereinstimmen. Wenn keine Muster übergeben werden, vergleicht die Regel standardmäßig alle Tensoren, die in den Testversionen gesammelt wurden. Nur skalarwertige Tensoren können zugeordnet werden. **Optional** Gültige Werte: Liste von Zeichenfolgen oder eine durch Kommas getrennte Zeichenfolge Standardwert: `".*embedding0_input_0"` (unter der Annahme einer Einbettung als Anfangsebene des Netzwerks) |
| token\$1values | Eine Zeichenfolge einer Liste der numerischen Werte der Token. Beispiel: „3, 0“. **Optional** Gültige Werte: Kommagetrennte Zeichenfolge von numerischen Werten Standardwert: `0` |
| token\$1thresholds\$1percent | Eine Zeichenfolge einer Liste von Schwellenwerten (in Prozentsätzen), die jedem der `token_values` entsprechen. Beispiel: „50,0, 50,0“. **Optional** Gültige Werte: durch Komma getrennte Gleitkommazahlen Standardwert: `"50"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.nlp_sequence_ratio(),
rule_parameters={
"tensor_regex": ".*embedding0_input_0",
"token_values": "0",
"token_thresholds_percent": "50"
},
collections_to_save=[
CollectionConfig(
name="custom_inputs_collection",
parameters={
"include_regex": ".*embedding0_input_0"
}
)
]
)
]
```
## Confusion
Diese Regel wertet die Güte einer Konfusionmatrix für ein Klassifizierungsproblem aus.
Es erstellt eine Matrix der Größe `category_no*category_no` und füllt sie mit Daten aus (`labels`, `predictions`)-Paaren. Für jedes (`labels`, `predictions`)-Paar wird die Anzahl in `confusion[labels][predictions]` um 1 erhöht. Wenn die Matrix vollständig gefüllt ist, wird das Verhältnis zwischen auf Diagonalen liegenden Daten und nicht auf Diagonalen liegenden Werten folgt ausgewertet:
+ Für Elemente auf der Diagonalen: `confusion[i][i]/sum_j(confusion[j][j])>=min_diag`
+ Für Elemente außerhalb der Diagonalen: `confusion[j][i])/sum_j(confusion[j][i])<=max_off_diag`
Diese Regel kann auf den XGBoost-Algorithmus angewendet werden.
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
Parameterbeschreibungen für die Confusion-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| category\$1no | Die Anzahl der Kategorien. **Optional** Gültige Werte: ganzzahlig ≥2 Standardwert: `"None"` |
| labels | Die `labels` Tensorsammlung oder ein 1-D-Vektor mit zutreffenden Bezeichnungen. **Optional** Zulässige Werte: String Standardwert: `"labels"` |
| predictions | Die `predictions` Tensorsammlung oder ein 1-D-Vektor mit geschätzten Bezeichnungen. **Optional** Zulässige Werte: String Standardwert: `"predictions"` |
| labels\$1collection | Die Regel prüft die Tensoren in dieser Sammlung auf `labels`. **Optional** Zulässige Werte: String Standardwert: `"labels"` |
| predictions\$1collection | Die Regel prüft die Tensoren in dieser Sammlung auf `predictions`. **Optional** Zulässige Werte: String Standardwert: `"predictions"` |
| min\$1diag | Der untere Schwellenwert für das Verhältnis der Daten auf der Diagonale. **Optional** Gültige Werte: `0`≤Gleikomma≤`1` Standardwert: `0.9` |
| max\$1off\$1diag | Der obere Schwellenwert für das Verhältnis der Daten abseits der Diagonale. **Optional** Gültige Werte: `0`≤Gleikomma≤`1` Standardwert: `0.1` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.confusion(),
rule_parameters={
"category_no": "10",
"labels": "labels",
"predictions": "predictions",
"labels_collection": "labels",
"predictions_collection": "predictions",
"min_diag": "0.9",
"max_off_diag": "0.1"
},
collections_to_save=[
CollectionConfig(
name="labels",
parameters={
"save_interval": "500"
}
),
CollectionConfig(
name="predictions",
parameters={
"include_regex": "500"
}
)
]
)
]
```
**Anmerkung**
Diese Regel leitet Standardwerte für die optionalen Parameter ab, wenn ihre Werte nicht angegeben sind.
## FeatureImportanceOverweight
Diese Regel akkumuliert die Gewichtungen der n größten Feature-Wichtigkeitswerte pro Schritt und stellt sicher, dass diese den Schwellenwert nicht überschreiten. Sie können z. B. festlegen, dass der Schwellenwert für die drei wichtigsten Features nicht mehr als 80 Prozent der Gesamtgewichtungen des Modells ausmacht.
Diese Regel gilt nur für den XGBoost-Algorithmus.
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
Parameterbeschreibungen für die Regel FeatureImportanceOverweight
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| threshold | Legt den Schwellenwert für den Anteil der `n` größten Features an der Gesamtsumme fest. Die Zahl `n` wird durch den Parameter `nfeatures` festgelegt. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `0.8` |
| nfeatures | Die Anzahl der größten Features. **Optional** Gültige Werte: Ganzzahl Standardwert: `3` |
| tensor\$1regex | Der reguläre Ausdruck (regex) des Tensors benennt die zu analysierende Regel. **Optional** Zulässige Werte: String Standardwert: `".*feature_importance/weight"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.feature_importance_overweight(),
rule_parameters={
"threshold": "0.8",
"nfeatures": "3",
"tensor_regex": ".*feature_importance/weight"
},
collections_to_save=[
CollectionConfig(
name="feature_importance",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## TreeDepth
Diese Regel misst die Tiefe von Bäumen in einem XGBoost-Modell. XGBoost lehnt Aufteilungen ab, wenn sie den Verlust nicht verbessern. Dadurch wird das Training geregelt. Infolgedessen wächst der Baum möglicherweise nicht so tief wie durch den Parameter `depth` definiert.
Diese Regel gilt nur für den XGBoost-Algorithmus.
Ein Beispiel für das Konfigurieren und Bereitstellen einer integrierten Regel finden Sie unter [So konfigurieren Sie integrierte Debugger-Regeln](use-debugger-built-in-rules.md).
Parameterbeschreibungen für die TreeDepth-Regel
| Name des Parameters | Beschreibung |
| --- | --- |
| base\$1trial | Der Name des Basis-Probe-Training-Jobs. Dieser Parameter wird vom Amazon SageMaker Debugger automatisch auf den aktuellen Training-Job gesetzt. **Erforderlich** Zulässige Werte: String |
| depth | Die Tiefe des Baums. Die Tiefe des Baumes wird durch Berechnung des Basis-2-Logarithmus der größten Knoten-ID bestimmt. **Optional** Gültige Werte: Gleitkommazahl. Standardwert: `4` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.tree_depth(),
rule_parameters={
"depth": "4"
},
collections_to_save=[
CollectionConfig(
name="tree",
parameters={
"save_interval": "500"
}
)
]
)
]
```
# Benutzerdefinierte Regeln mithilfe der Debugger-Clientbibliothek erstellen
Mithilfe der Debugger-Regel APIs und der [`smdebug`Open-Source-Python-Bibliothek](https://github.com/awslabs/sagemaker-debugger/), die Tools zum Erstellen eigener Regelcontainer bereitstellt, können Sie benutzerdefinierte Regeln erstellen, um Ihren Trainingsjob zu überwachen.
## Voraussetzungen für die Erstellung einer benutzerdefinierten Regel
Um benutzerdefinierte Debugger-Regeln erstellen zu können, benötigen Sie Folgendes.
+ [SageMaker Debugger-Regel. Benutzerdefinierte API](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule.custom)
+ [Die Open-Source Python-Bibliothek smdebug](https://github.com/awslabs/sagemaker-debugger/)
+ Ihr eigenes Python-Skript mit benutzerdefinierten Regeln
+ [Amazon SageMaker Debugger-Image URIs für benutzerdefinierte Regelauswerter](debugger-reference.md#debuger-custom-rule-registry-ids)
**Topics**
+ [Voraussetzungen für die Erstellung einer benutzerdefinierten Regel](#debugger-custom-rules-prerequisite)
+ [Die Client-Bibliothek `smdebug` verwenden, um ein Python-Skript für benutzerdefinierte Regeln zu erstellen](debugger-custom-rules-python-script.md)
+ [Verwenden Sie den Debugger APIs , um Ihre eigenen benutzerdefinierten Regeln auszuführen](debugger-custom-rules-python-sdk.md)
# Die Client-Bibliothek `smdebug` verwenden, um ein Python-Skript für benutzerdefinierte Regeln zu erstellen
Die `smdebug` Regel-API bietet eine Schnittstelle zum Einrichten Ihrer eigenen benutzerdefinierten Regeln. Das folgende Python-Skript ist ein Beispiel für die Erstellung einer benutzerdefinierten Regel, `CustomGradientRule`. Diese benutzerdefinierte Regel für das Tutorial überwacht, ob die Farbverläufe zu groß werden, und legt den Standardschwellenwert auf 10 fest. Die benutzerdefinierte Regel verwendet eine von einem SageMaker KI-Schätzer erstellte Basisstudie, wenn sie den Trainingsjob einleitet.
```
from smdebug.rules.rule import Rule
class CustomGradientRule(Rule):
def __init__(self, base_trial, threshold=10.0):
super().__init__(base_trial)
self.threshold = float(threshold)
def invoke_at_step(self, step):
for tname in self.base_trial.tensor_names(collection="gradients"):
t = self.base_trial.tensor(tname)
abs_mean = t.reduction_value(step, "mean", abs=True)
if abs_mean > self.threshold:
return True
return False
```
Sie können dem gleichen Python-Skript beliebig viele benutzerdefinierte Regelklassen hinzufügen und sie für alle Trainingsauftragsversuche einsetzen, indem Sie im folgenden Abschnitt benutzerdefinierte Regelobjekte erstellen.
# Verwenden Sie den Debugger APIs , um Ihre eigenen benutzerdefinierten Regeln auszuführen
Das folgende Codebeispiel zeigt, wie eine benutzerdefinierte Regel mit dem [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) konfiguriert wird. In diesem Beispiel wird davon ausgegangen, dass sich das benutzerdefinierte Regelskript, das Sie im vorherigen Schritt erstellt haben, unter '*path/to/my\$1custom\$1rule.py*' befindet.
```
from sagemaker.debugger import Rule, CollectionConfig
custom_rule = Rule.custom(
name='MyCustomRule',
image_uri='759209512951.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rule-evaluator:latest',
instance_type='ml.t3.medium',
source='path/to/my_custom_rule.py',
rule_to_invoke='CustomGradientRule',
collections_to_save=[CollectionConfig("gradients")],
rule_parameters={"threshold": "20.0"}
)
```
In der folgenden Liste werden die Debugger `Rule.custom`-API-Argumente erklärt.
+ `name` (str): Geben Sie beliebig einen benutzerdefinierten Regelnamen an.
+ `image_uri` (str): Dies ist das Bild des Containers, das die Logik enthält, Ihre benutzerdefinierte Regel zu verstehen. Es bezieht die angegebenen Tensorsammlungen, die Sie im Trainingsauftrag speichern, und wertet sie aus. Die Liste der SageMaker Open-Source-AI-Regelauswertungsbilder finden Sie unter[Amazon SageMaker Debugger-Image URIs für benutzerdefinierte Regelauswerter](debugger-reference.md#debuger-custom-rule-registry-ids).
+ `instance_type` (str): Sie müssen eine Instance angeben, um einen Regel-Docker-Container zu erstellen. Dadurch wird die Instance parallel zu einem Trainingscontainer hochgefahren.
+ `source` (str): Dies ist der lokale Pfad oder der Amazon-S3-URI zu Ihrem benutzerdefinierten Regelskript.
+ `rule_to_invoke`(str): Dies gibt die jeweilige Regelklassenimplementierung in Ihrem benutzerdefinierten Regelskript an. SageMaker KI unterstützt jeweils nur eine Regel, die in einem Regeljob ausgewertet werden kann.
+ `collections_to_save` (str): Dies gibt an, welche Tensorsammlungen Sie speichern, damit die Regel ausgeführt werden kann.
+ `rule_parameters` (Wörterbuch): Dies akzeptiert Parametereingaben in einem Wörterbuchformat. Sie können die Parameter anpassen, die Sie im benutzerdefinierten Regelskript konfiguriert haben.
Nachdem Sie das `custom_rule` Objekt eingerichtet haben, können Sie es verwenden, um einen SageMaker KI-Schätzer für beliebige Trainingsaufgaben zu erstellen. Geben Sie das `entry_point` in Ihrem Trainingsskript an. Sie müssen keine Änderungen an Ihrem Trainingsskript vornehmen.
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
role=sagemaker.get_execution_role(),
base_job_name='smdebug-custom-rule-demo-tf-keras',
entry_point='path/to/your_training_script.py'
train_instance_type='ml.p2.xlarge'
...
# debugger-specific arguments below
rules = [custom_rule]
)
estimator.fit()
```
Weitere Varianten und erweiterte Beispiele für die Verwendung benutzerdefinierter Debugger-Regeln finden Sie in den folgenden Beispiel-Notebooks.
+ [Überwachen Sie Ihren Trainingsjob mit benutzerdefinierten Amazon SageMaker Debugger-Regeln](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_keras_custom_rule/tf-keras-custom-rule.html)
+ [PyTorch iteratives Modellbereinigen von und ResNet AlexNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_iterative_model_pruning)
+ [Auslösen von CloudWatch Amazon-Ereignissen mithilfe von Debugger-Regeln, um basierend auf dem Trainingsstatus eine Aktion auszuführen mit TensorFlow](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_action_on_rule)
# Verwenden Sie den Debugger mit benutzerdefinierten Trainingscontainern
Amazon SageMaker Debugger ist für alle Deep-Learning-Modelle verfügbar, die Sie in Amazon SageMaker AI integrieren. Die AWS CLI SageMaker `Estimator` KI-API und der Debugger APIs ermöglichen es Ihnen, beliebige Docker-Basis-Images zu verwenden, um Container zum Trainieren Ihrer Modelle zu erstellen und anzupassen. Um Debugger mit benutzerdefinierten Containern zu verwenden, müssen Sie eine minimale Änderung an Ihrem Trainingsskript vornehmen, um den Debugger-Hook-Callback zu implementieren und Tensoren aus Trainingsjobs abzurufen. In den folgenden Abschnitten erfahren Sie, wie Sie Debugger mit benutzerdefinierten Trainingscontainern verwenden.
Sie benötigen die folgenden Ressourcen, um einen benutzerdefinierten Container mit Debugger zu erstellen.
+ [Amazon SageMaker Python-SDK](https://sagemaker.readthedocs.io/en/stable)
+ [Die SMDebug Open-Source-Client-Bibliothek](https://github.com/awslabs/sagemaker-debugger)
+ Ein Docker-Basis-Image Ihrer Wahl
+ Ihr Trainingsskript mit einem registrierten Debugger-Hook – Weitere Informationen zur Registrierung eines Debugger-Hooks in Ihrem Trainingsskript finden Sie unter [Registrieren Sie den Debugger Hook in Ihrem Trainingsskript](#debugger-script-mode).
Ein end-to-end Beispiel für die Verwendung von Debugger mit einem benutzerdefinierten Trainingscontainer finden Sie im folgenden Beispiel-Notizbuch.
+ [Erstellen Sie einen benutzerdefinierten Trainingscontainer und debuggen Sie Trainingsjobs mit dem Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/build_your_own_container_with_debugger/debugger_byoc.html)
**Tipp**
Dieser Leitfaden für benutzerdefinierte Container mit Debugger ist eine Erweiterung des [Den eigenen Trainingscontainer anpassen](adapt-training-container.md) Handbuchs, in dem Sie ausführlich erfahren, wie Sie Ihren benutzerdefinierten Trainingscontainer erstellen und auf Amazon ECR übertragen.
## Vorbereitung auf die Entwicklung eines benutzerdefinierten Trainingscontainers
Um einen Docker-Container zu erstellen, sollte die grundlegende Struktur der Dateien wie folgt aussehen:
```
├── debugger_custom_container_test_notebook.ipynb # a notebook to run python snippet codes
└── debugger_custom_container_test_folder # this is a docker folder
├── your-training-script.py # your training script with Debugger hook
└── Dockerfile # a Dockerfile to build your own container
```
## Registrieren Sie den Debugger Hook in Ihrem Trainingsskript
Um Ihr Modelltraining zu debuggen, müssen Sie Ihrem Trainingsskript einen Debugger-Hook hinzufügen.
**Anmerkung**
Dieser Schritt ist erforderlich, um Modellparameter (Ausgabetensoren) für das Debuggen Ihres Modelltrainings zu sammeln. Wenn Sie nur überwachen und ein Profil erstellen möchten, können Sie diesen Schritt der Hook-Registrierung überspringen und den `debugger_hook_config` Parameter bei der Erstellung eines Schätzers ausschließen.
Der folgende Beispielcode zeigt die Struktur eines Trainingsskripts unter Verwendung des Keras ResNet 50-Modells und wie der Debugger-Hook als Keras-Callback zum Debuggen übergeben wird. Ein vollständiges Trainingsskript finden Sie unter [TensorFlow Trainingsskript](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-debugger/build_your_own_container_with_debugger/docker/tf_keras_resnet_byoc.py) mit Debugger-Hook. SageMaker
```
# An example of training script (your-training-script.py)
import tensorflow.compat.v2 as tf
from tensorflow.keras.applications.resnet50 import ResNet50
import smdebug.tensorflow as smd
def train(batch_size, epoch, model, hook):
...
model.fit(X_train, Y_train,
batch_size=batch_size,
epochs=epoch,
validation_data=(X_valid, Y_valid),
shuffle=True,
# smdebug modification: Pass the Debugger hook in the main() as a Keras callback
callbacks=[hook])
def main():
parser=argparse.ArgumentParser(description="Train resnet50 cifar10")
# hyperparameter settings
parser.add_argument(...)
args = parser.parse_args()
model=ResNet50(weights=None, input_shape=(32,32,3), classes=10)
# Add the following line to register the Debugger hook for Keras.
hook=smd.KerasHook.create_from_json_file()
# Start the training.
train(args.batch_size, args.epoch, model, hook)
if __name__ == "__main__":
main()
```
Weitere Informationen zur Registrierung des Debugger-Hooks für die unterstützten Frameworks und Algorithmen finden Sie unter den folgenden Links in der SMDebug Client-Bibliothek:
+ [SMDebug TensorFlow Hook](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/tensorflow.md)
+ [SMDebug PyTorch Haken](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/pytorch.md)
+ [SMDebug MXNet Haken](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/mxnet.md)
+ [SMDebug XGBoost Haken](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/xgboost.md)
In den folgenden Beispiel-Trainingsskripten für Notebooks finden Sie weitere Beispiele dafür, wie Sie die Debugger-Hooks zu Trainingsskripten hinzufügen und Ausgabetensoren detailliert sammeln können:
+ [Debugger im Skriptmodus mit dem TensorFlow 2.1-Framework](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow2/tensorflow2_keras_custom_container/tf2-keras-custom-container.html)
Um den Unterschied zwischen der Verwendung des Debuggers in einem Deep Learning Container und im Skriptmodus zu sehen, öffnen Sie dieses Notizbuch und platzieren Sie es und [den vorherigen Debugger in einem Deep Learning Container TensorFlow v2.1-Notebook-Beispiel nebeneinander](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow2/tensorflow2_zero_code_change/tf2-keras-default-container.html).
Im Skriptmodus wird der Hook-Konfigurationsteil aus dem Skript entfernt, in dem Sie die Schätzfunktion festlegen. Stattdessen wird die Debugger-Hook-Funktion mit dem Trainingsskript, dem [ TensorFlow Keras-Trainingsskript im Skriptmodus ResNet ](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/sagemaker-debugger/tensorflow2/tensorflow2_keras_custom_container/src/tf_keras_resnet_byoc.py), zusammengeführt. Das Trainingsskript importiert die `smdebug` Bibliothek in die erforderliche TensorFlow Keras-Umgebung, um mit dem TensorFlow ResNet 50-Algorithmus zu kommunizieren. Es implementiert die `smdebug` Hook-Funktionalität auch manuell, indem es das `callbacks=[hook]` Argument innerhalb der `train` Funktion (in Zeile 49) und die manuelle Hook-Konfiguration (in Zeile 89) hinzufügt, die über das SageMaker Python-SDK bereitgestellt wird.
In diesem Skriptmodus-Beispiel wird die Trainingsaufgabe im TF 2.1-Framework für den direkten Vergleich mit der Null-Skriptänderung im TF 2.1-Beispiel ausgeführt. Der Vorteil der Einrichtung des Debuggers im Skriptmodus besteht in der Flexibilität, Framework-Versionen auszuwählen, die nicht von AWS Deep Learning Containern abgedeckt werden.
+ [Amazon SageMaker Debugger in einem PyTorch Container im Skriptmodus verwenden](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_custom_container)
Dieses Notizbuch aktiviert den Debugger im Skriptmodus im PyTorch v1.3.1-Framework. PyTorchv1.3.1 wird von SageMaker AI-Containern unterstützt, und dieses Beispiel zeigt Details zur Änderung eines Trainingsskripts.
Der SageMaker PyTorch AI-Estimator befindet sich standardmäßig bereits im Skriptmodus. Sie werden im Notebook feststellen, dass die Zeile zur Aktivierung von `script_mode` nicht in der Schätzungskonfiguration enthalten ist.
Dieses Notizbuch zeigt detaillierte Schritte zum Ändern [des ursprünglichen PyTorch Trainingsskripts](https://github.com/pytorch/examples/blob/master/mnist/main.py) in eine modifizierte Version, um den Debugger zu aktivieren. Darüber hinaus zeigt dieses Beispiel, wie Sie die in Debugger eingebauten Regeln verwenden können, um Trainingsprobleme wie das Problem der verschwindenden Gradienten zu erkennen, und die Debugger-Versuchsfunktionen zum Aufrufen und Analysieren der gespeicherten Tensoren.
## Erstellen und konfigurieren Sie ein Dockerfile
Öffnen Sie Ihre SageMaker KI JupyterLab und erstellen Sie einen neuen Ordner, `debugger_custom_container_test_folder` in diesem Beispiel, um Ihr Trainingsskript und `Dockerfile` zu speichern. Das folgende Codebeispiel ist ein `Dockerfile`, das wesentliche Docker-Build-Befehle enthält. Fügen Sie den folgenden Inhalt in die `Dockerfile`-Textdatei ein und speichern Sie sie. Laden Sie Ihr Trainingsskript in denselben Ordner hoch.
```
# Specify a docker base image
FROM tensorflow/tensorflow:2.2.0rc2-gpu-py3
RUN /usr/bin/python3 -m pip install --upgrade pip
RUN pip install --upgrade protobuf
# Install required packages to enable the SageMaker Python SDK and the smdebug library
RUN pip install sagemaker-training
RUN pip install smdebug
CMD ["bin/bash"]
```
Wenn Sie ein vorgefertigtes AWS Deep Learning-Container-Image verwenden möchten, finden Sie weitere Informationen unter [Verfügbare AWS Deep Learning Containers Learning-Container-Images](https://aws.amazon.com/releasenotes/available-deep-learning-containers-images/).
## Erstellen Sie den benutzerdefinierten Trainingscontainer und übertragen Sie ihn an Amazon ECR
Erstellen Sie ein Test-Notebook, `debugger_custom_container_test_notebook.ipynb`, und führen Sie den folgenden Code in der Zelle des Notebooks aus. Dies greift auf das `debugger_byoc_test_docker`-Verzeichnis zu, baut den Docker mit dem angegebenen `algorithm_name` und schiebt den Docker-Container auf Ihr Amazon ECR.
```
import boto3
account_id = boto3.client('sts').get_caller_identity().get('Account')
ecr_repository = 'sagemaker-debugger-mnist-byoc-tf2'
tag = ':latest'
region = boto3.session.Session().region_name
uri_suffix = 'amazonaws.com'
if region in ['cn-north-1', 'cn-northwest-1']:
uri_suffix = 'amazonaws.com.cn'
byoc_image_uri = '{}.dkr.ecr.{}.{}/{}'.format(account_id, region, uri_suffix, ecr_repository + tag)
!docker build -t $ecr_repository docker
!$(aws ecr get-login --region $region --registry-ids $account_id --no-include-email)
!aws ecr create-repository --repository-name $ecr_repository
!docker tag {ecr_repository + tag} $byoc_image_uri
!docker push $byoc_image_uri
```
**Tipp**
Wenn Sie eines der AWS Deep Learning Container-Basis-Images verwenden, führen Sie den folgenden Code aus, um sich bei Amazon ECR anzumelden und auf das Deep Learning Container-Image-Repository zuzugreifen.
```
! aws ecr get-login-password --region {region} | docker login --username AWS --password-stdin 763104351884.dkr.ecr.us-east-1.amazonaws.com
```
## Trainingsjobs mithilfe des benutzerdefinierten Trainingscontainers ausführen und debuggen
Nachdem Sie Ihren Docker-Container erstellt und auf Amazon ECR übertragen haben, konfigurieren Sie einen SageMaker AI-Estimator mit Ihrem Trainingsskript und den Debugger-spezifischen Parametern. Nachdem Sie den `estimator.fit()` ausgeführt haben, sammelt der Debugger die Ausgabetensoren, überwacht sie und erkennt Trainingsprobleme. Mithilfe der gespeicherten Tensoren können Sie den Trainingsjob mithilfe der `smdebug` Kernfunktionen und Tools weiter analysieren. Wenn Sie einen Workflow für den Prozess zur Überwachung von Debugger-Regeln mit Amazon CloudWatch Events konfigurieren AWS Lambda, können Sie einen Prozess zum Stoppen von Trainingsjobs automatisieren, wenn die Debugger-Regeln Trainingsprobleme erkennen.
```
import sagemaker
from sagemaker.estimator import Estimator
from sagemaker.debugger import Rule, DebuggerHookConfig, CollectionConfig, rule_configs
profiler_config=ProfilerConfig(...)
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule()),
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=Estimator(
image_uri=byoc_image_uri,
entry_point="./debugger_custom_container_test_folder/your-training-script.py"
role=sagemaker.get_execution_role(),
base_job_name='debugger-custom-container-test',
instance_count=1,
instance_type='ml.p3.2xlarge',
# Debugger-specific parameters
profiler_config=profiler_config,
debugger_hook_config=debugger_hook_config,
rules=rules
)
# start training
estimator.fit()
```
# Debugger mithilfe SageMaker der API konfigurieren
Die vorherigen Themen konzentrieren sich auf die Verwendung von Debugger über das Amazon SageMaker Python SDK, das ein Wrapper-Around ist, AWS SDK für Python (Boto3) und auf SageMaker API-Operationen. Dies bietet ein erstklassiges Erlebnis beim Zugriff auf die SageMaker Amazon-API-Operationen. Falls Sie die SageMaker API-Operationen manuell mit AWS Boto3 oder AWS Command Line Interface (CLI) für andere Anwendungen wie Java SDKs, Go und C\$1\$1 konfigurieren müssen, wird in diesem Abschnitt beschrieben, wie Sie die folgenden Low-Level-API-Operationen konfigurieren.
**Topics**
+ [JSON (AWS CLI)](debugger-built-in-rules-api.CLI.md)
+ [SDK für Python (Boto3)](debugger-built-in-rules-api.Boto3.md)
# JSON (AWS CLI)
Die integrierten Regeln von Amazon SageMaker Debugger können mithilfe der SageMaker [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)AI-API-Operation für einen Trainingsjob mithilfe der [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)Objekte [DebugHookConfig[DebugRuleConfiguration[ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html),, und konfiguriert werden. Sie müssen den richtigen Bild-URI im `RuleEvaluatorImage` Parameter angeben. In den folgenden Beispielen erfahren Sie, wie Sie die [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)anzufordernden JSON-Zeichenketten einrichten.
Der folgende Code zeigt eine vollständige JSON-Vorlage zum Ausführen eines Trainingsauftrags mit den erforderlichen Einstellungen und Debugger-Konfigurationen. Speichern Sie die Vorlage als JSON-Datei in Ihrem Arbeitsverzeichnis und führen Sie den Trainingsjob mit AWS CLI aus. Speichern Sie zum Beispiel den folgenden Code als `debugger-training-job-cli.json`.
**Anmerkung**
Stellen Sie sicher, dass Sie die richtigen Docker-Container-Images verwenden. Informationen zu AWS Deep Learning-Container-Images finden Sie unter [Verfügbare Deep Learning Containers Learning-Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Eine vollständige Liste der verfügbaren Docker-Images für die Verwendung der Debugger-Regeln finden Sie unter [Docker-Images für Debugger-Regeln](debugger-reference.md#debugger-docker-images-rules).
```
{
"TrainingJobName": "debugger-aws-cli-test",
"RoleArn": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-YYYYMMDDT123456",
"AlgorithmSpecification": {
// Specify a training Docker container image URI (Deep Learning Container or your own training container) to TrainingImage.
"TrainingImage": "763104351884.dkr.ecr.us-west-2.amazonaws.com/tensorflow-training:2.4.1-gpu-py37-cu110-ubuntu18.04",
"TrainingInputMode": "File",
"EnableSageMakerMetricsTimeSeries": false
},
"HyperParameters": {
"sagemaker_program": "entry_point/tf-hvd-train.py",
"sagemaker_submit_directory": "s3://sagemaker-us-west-2-111122223333/debugger-boto3-profiling-test/source.tar.gz"
},
"OutputDataConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/output"
},
"DebugHookConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/debug-output",
"CollectionConfigurations": [
{
"CollectionName": "losses",
"CollectionParameters" : {
"train.save_interval": "50"
}
}
]
},
"DebugRuleConfigurations": [
{
"RuleConfigurationName": "LossNotDecreasing",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {"rule_to_invoke": "LossNotDecreasing"}
}
],
"ProfilerConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/profiler-output",
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, \"MetricsRegex\": \".*\", }",
"DetailedProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, }",
"PythonProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, \"ProfilerName\": \"cprofile\", \"cProfileTimer\": \"total_time\"}",
"LocalPath": "/opt/ml/output/profiler/"
}
},
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {"rule_to_invoke": "ProfilerReport"}
}
],
"ResourceConfig": {
"InstanceType": "ml.p3.8xlarge",
"InstanceCount": 1,
"VolumeSizeInGB": 30
},
"StoppingCondition": {
"MaxRuntimeInSeconds": 86400
}
}
```
Führen Sie nach dem Speichern der JSON-Datei den folgenden Befehl in Ihrem Terminal aus. (Verwenden Sie `!` am Anfang der Zeile, wenn Sie ein Jupyter Notebook verwenden.)
```
aws sagemaker create-training-job --cli-input-json file://debugger-training-job-cli.json
```
## So konfigurieren Sie eine Debugger-Regel für das Debuggen von Modellparametern
Die folgenden Codebeispiele zeigen, wie eine integrierte `VanishingGradient` Regel mithilfe dieser SageMaker API konfiguriert wird.
**Um zu aktivieren, dass der Debugger Ausgabetensoren sammelt**
Geben Sie die Debugger-Hook-Konfiguration wie folgt an:
```
"DebugHookConfig": {
"S3OutputPath": "s3:////debug-output",
"CollectionConfigurations": [
{
"CollectionName": "gradients",
"CollectionParameters" : {
"save_interval": "500"
}
}
]
}
```
Dies führt dazu, dass der Trainingsauftrag die Tensorsammlung, `gradients`, alle `save_interval` von 500 Schritten speichert. Informationen zu verfügbaren `CollectionName` Werten finden Sie unter [Integrierte Debugger-Sammlungen](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections) in der *Dokumentation zur SMDebug Clientbibliothek*. Verfügbare `CollectionParameters` Parameterschlüssel und -werte finden Sie in der [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)Klasse in der *SageMaker Python SDK-Dokumentation*.
**Um Debugger-Regeln für das Debuggen der Ausgabetensoren zu aktivieren**
Das folgende `DebugRuleConfigurations` API-Beispiel zeigt, wie die integrierte `VanishingGradient` Regel für die gespeicherte `gradients` Sammlung ausgeführt wird.
```
"DebugRuleConfigurations": [
{
"RuleConfigurationName": "VanishingGradient",
"RuleEvaluatorImage": "503895931360.dkr.ecr.us-east-1.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "VanishingGradient",
"threshold": "20.0"
}
}
]
```
Mit einer Konfiguration wie in diesem Beispiel startet der Debugger einen Regelauswertungsauftrag für Ihren Trainingsauftrag unter Verwendung der `VanishingGradient`-Regel für die Sammlung des `gradients`-Tensors. Eine vollständige Liste der verfügbaren Docker-Images für die Verwendung der Debugger-Regeln finden Sie unter [Docker-Images für Debugger-Regeln](debugger-reference.md#debugger-docker-images-rules). Die Schlüssel-Wert-Paare für `RuleParameters` finden Sie unter [Liste der in den Debugger integrierten Regeln](debugger-built-in-rules.md).
## Um eine integrierte Debugger-Regel für das Profiling von System- und Framework-Metriken zu konfigurieren
Der folgende Beispielcode zeigt, wie der ProfilerConfig API-Vorgang spezifiziert wird, um die Erfassung von System- und Framework-Metriken zu ermöglichen.
**Um Debugger-Profiling zur Sammlung von System- und Framework-Metriken zu aktivieren**
------
#### [ Target Step ]
```
"ProfilerConfig": {
// Optional. Path to an S3 bucket to save profiling outputs
"S3OutputPath": "s3:////profiler-output",
// Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3, \"MetricsRegex\": \".*\" }",
"DetailedProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3 }",
// For PythonProfilingConfig,
// available ProfilerName options: cProfile, Pyinstrument
// available cProfileTimer options only when using cProfile: cpu, off_cpu, total_time
"PythonProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3, \"ProfilerName\": \"cProfile\", \"cProfileTimer\": \"total_time\" }",
// Optional. Local path for profiling outputs
"LocalPath": "/opt/ml/output/profiler/"
}
}
```
------
#### [ Target Time Duration ]
```
"ProfilerConfig": {
// Optional. Path to an S3 bucket to save profiling outputs
"S3OutputPath": "s3:////profiler-output",
// Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10, \"MetricsRegex\": \".*\" }",
"DetailedProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10 }",
// For PythonProfilingConfig,
// available ProfilerName options: cProfile, Pyinstrument
// available cProfileTimer options only when using cProfile: cpu, off_cpu, total_time
"PythonProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10, \"ProfilerName\": \"cProfile\", \"cProfileTimer\": \"total_time\" }",
// Optional. Local path for profiling outputs
"LocalPath": "/opt/ml/output/profiler/"
}
}
```
------
**Um Debugger-Regeln für die das Profiling der Metriken zu aktivieren**
Das folgende Codebeispiel zeigt, wie Sie die `ProfilerReport`-Regel konfigurieren.
```
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "ProfilerReport",
"CPUBottleneck_cpu_threshold": "90",
"IOBottleneck_threshold": "90"
}
}
]
```
Eine vollständige Liste der verfügbaren Docker-Images für die Verwendung der Debugger-Regeln finden Sie unter [Docker-Images für Debugger-Regeln](debugger-reference.md#debugger-docker-images-rules). Die Schlüssel-Wert-Paare für `RuleParameters` finden Sie unter [Liste der in den Debugger integrierten Regeln](debugger-built-in-rules.md).
## Die Profiling-Konfiguration des Debuggers mithilfe der `UpdateTrainingJob`-API aktualisieren
Die Konfiguration der Debugger-Profilerstellung kann mithilfe des [UpdateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html)API-Vorgangs aktualisiert werden, während Ihr Trainingsjob ausgeführt wird. Konfigurieren Sie neue [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)Objekte [ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)und geben Sie den Namen des Trainingsjobs für den `TrainingJobName` Parameter an.
```
{
"ProfilerConfig": {
"DisableProfiler": boolean,
"ProfilingIntervalInMilliseconds": number,
"ProfilingParameters": {
"string" : "string"
}
},
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "string",
"RuleEvaluatorImage": "string",
"RuleParameters": {
"string" : "string"
}
}
],
"TrainingJobName": "your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS"
}
```
## Der `CreateTrainingJob`-API eine benutzerdefinierte Debugger-Regelkonfiguration hinzufügen
Eine benutzerdefinierte Regel kann für einen Trainingsjob mithilfe der [ DebugRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)Objekte [ DebugHookConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)und in der [ CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API-Operation konfiguriert werden. Das folgende Codebeispiel zeigt, wie eine benutzerdefinierte `ImproperActivation` Regel, die mit der Bibliothek *smdebug* geschrieben wurde, mithilfe dieser SageMaker API-Operation konfiguriert wird. In diesem Beispiel wird davon ausgegangen, dass Sie die benutzerdefinierte Regel in der Datei *custom\$1rules.py* geschrieben und in einen Amazon-S3-Bucket hochgeladen haben. Das Beispiel stellt vorgefertigte Docker-Images bereit, mit denen Sie Ihre benutzerdefinierten Regeln ausführen können. Diese werden unter [Amazon SageMaker Debugger-Image URIs für benutzerdefinierte Regelauswerter](debugger-reference.md#debuger-custom-rule-registry-ids) gelistet. Sie geben die URL-Registry-Adresse für das vorgefertigte Docker-Image im `RuleEvaluatorImage`-Parameter an.
```
"DebugHookConfig": {
"S3OutputPath": "s3:////debug-output",
"CollectionConfigurations": [
{
"CollectionName": "relu_activations",
"CollectionParameters": {
"include_regex": "relu",
"save_interval": "500",
"end_step": "5000"
}
}
]
},
"DebugRulesConfigurations": [
{
"RuleConfigurationName": "improper_activation_job",
"RuleEvaluatorImage": "552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest",
"InstanceType": "ml.c4.xlarge",
"VolumeSizeInGB": 400,
"RuleParameters": {
"source_s3_uri": "s3://bucket/custom_rules.py",
"rule_to_invoke": "ImproperActivation",
"collection_names": "relu_activations"
}
}
]
```
Eine vollständige Liste der verfügbaren Docker-Images für die Verwendung der Debugger-Regeln finden Sie unter [Docker-Images für Debugger-Regeln](debugger-reference.md#debugger-docker-images-rules). Die Schlüssel-Wert-Paare für `RuleParameters` finden Sie unter [Liste der in den Debugger integrierten Regeln](debugger-built-in-rules.md).
# SDK für Python (Boto3)
Die integrierten Regeln von Amazon SageMaker Debugger können mithilfe der [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job)Funktion des AWS Boto3 SageMaker AI-Clients für einen Trainingsjob konfiguriert werden. Sie müssen den richtigen Image-URI im `RuleEvaluatorImage` Parameter angeben. Die folgenden Beispiele zeigen Ihnen, wie Sie den Anforderungstext für die [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job) Funktion einrichten.
Der folgende Code zeigt ein vollständiges Beispiel dafür, wie Sie den Debugger für den `create_training_job()` Anforderungstext konfigurieren und einen Trainingsjob in starten`us-west-2`, vorausgesetzt, dass ein Trainingsskript `entry_point/train.py` vorbereitet wurde mit. TensorFlow Ein end-to-end Beispiel-Notebook finden Sie unter [Profiling TensorFlow Multi GPU Multi Node Training Job with Amazon SageMaker Debugger (Boto3](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_profiling/tf-resnet-profiling-multi-gpu-multi-node-boto3.html)).
**Anmerkung**
Stellen Sie sicher, dass Sie die richtigen Docker-Container-Images verwenden. Verfügbare AWS Deep Learning-Container-Images finden Sie unter [Verfügbare Deep Learning Containers Learning-Container-Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Eine vollständige Liste der verfügbaren Docker-Images für die Verwendung der Debugger-Regeln finden Sie unter [Docker-Images für Debugger-Regeln](debugger-reference.md#debugger-docker-images-rules).
```
import sagemaker, boto3
import datetime, tarfile
# Start setting up a SageMaker session and a Boto3 SageMaker client
session = sagemaker.Session()
region = session.boto_region_name
bucket = session.default_bucket()
# Upload a training script to a default Amazon S3 bucket of the current SageMaker session
source = 'source.tar.gz'
project = 'debugger-boto3-test'
tar = tarfile.open(source, 'w:gz')
tar.add ('entry_point/train.py') # Specify the directory and name of your training script
tar.close()
s3 = boto3.client('s3')
s3.upload_file(source, bucket, project+'/'+source)
# Set up a Boto3 session client for SageMaker
sm = boto3.Session(region_name=region).client("sagemaker")
# Start a training job
sm.create_training_job(
TrainingJobName='debugger-boto3-'+datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S'),
HyperParameters={
'sagemaker_submit_directory': 's3://'+bucket+'/'+project+'/'+source,
'sagemaker_program': '/entry_point/train.py' # training scrip file location and name under the sagemaker_submit_directory
},
AlgorithmSpecification={
# Specify a training Docker container image URI (Deep Learning Container or your own training container) to TrainingImage.
'TrainingImage': '763104351884.dkr.ecr.us-west-2.amazonaws.com/tensorflow-training:2.4.1-gpu-py37-cu110-ubuntu18.04',
'TrainingInputMode': 'File',
'EnableSageMakerMetricsTimeSeries': False
},
RoleArn='arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20201014T161125',
OutputDataConfig={'S3OutputPath': 's3://'+bucket+'/'+project+'/output'},
ResourceConfig={
'InstanceType': 'ml.p3.8xlarge',
'InstanceCount': 1,
'VolumeSizeInGB': 30
},
StoppingCondition={
'MaxRuntimeInSeconds': 86400
},
DebugHookConfig={
'S3OutputPath': 's3://'+bucket+'/'+project+'/debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'losses',
'CollectionParameters' : {
'train.save_interval': '500',
'eval.save_interval': '50'
}
}
]
},
DebugRuleConfigurations=[
{
'RuleConfigurationName': 'LossNotDecreasing',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {'rule_to_invoke': 'LossNotDecreasing'}
}
],
ProfilerConfig={
'S3OutputPath': 's3://'+bucket+'/'+project+'/profiler-output',
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{"StartStep": 5, "NumSteps": 3, "MetricsRegex": ".*", }',
'DetailedProfilingConfig': '{"StartStep": 5, "NumSteps": 3, }',
'PythonProfilingConfig': '{"StartStep": 5, "NumSteps": 3, "ProfilerName": "cprofile", "cProfileTimer": "total_time"}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
},
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {'rule_to_invoke': 'ProfilerReport'}
}
]
)
```
## So konfigurieren Sie eine Debugger-Regel für das Debuggen von Modellparametern
Die folgenden Codebeispiele zeigen, wie eine integrierte `VanishingGradient` Regel mithilfe dieser SageMaker API konfiguriert wird.
**Um zu aktivieren, dass der Debugger Ausgabetensoren sammelt**
Geben Sie die Debugger-Hook-Konfiguration wie folgt an:
```
DebugHookConfig={
'S3OutputPath': 's3:////debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'gradients',
'CollectionParameters' : {
'train.save_interval': '500',
'eval.save_interval': '50'
}
}
]
}
```
Dies führt dazu, dass der Trainingsauftrag eine Tensorsammlung, `gradients`, alle `save_interval` von 500 Schritten speichert. Informationen zu verfügbaren `CollectionName` Werten finden Sie unter [Integrierte Debugger-Sammlungen](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections) in der *Dokumentation zur SMDebug Clientbibliothek*. Verfügbare `CollectionParameters` Parameterschlüssel und -werte finden Sie in der [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)Klasse in der *SageMaker Python SDK-Dokumentation*.
**Um Debugger-Regeln für das Debuggen der Ausgabetensoren zu aktivieren**
Das folgende `DebugRuleConfigurations` API-Beispiel zeigt, wie die integrierte `VanishingGradient` Regel für die gespeicherte `gradients` Sammlung ausgeführt wird.
```
DebugRuleConfigurations=[
{
'RuleConfigurationName': 'VanishingGradient',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'VanishingGradient',
'threshold': '20.0'
}
}
]
```
Mit einer Konfiguration wie in diesem Beispiel startet der Debugger einen Regelauswertungsauftrag für Ihren Trainingsauftrag unter Verwendung der `VanishingGradient`-Regel für die Sammlung des `gradients`-Tensors. Eine vollständige Liste der verfügbaren Docker-Images für die Verwendung der Debugger-Regeln finden Sie unter [Docker-Images für Debugger-Regeln](debugger-reference.md#debugger-docker-images-rules). Die Schlüssel-Wert-Paare für `RuleParameters` finden Sie unter [Liste der in den Debugger integrierten Regeln](debugger-built-in-rules.md).
## Um eine integrierte Debugger-Regel für das Profiling von System- und Framework-Metriken zu konfigurieren
Der folgende Beispielcode zeigt, wie der ProfilerConfig API-Vorgang spezifiziert wird, um die Erfassung von System- und Framework-Metriken zu ermöglichen.
**Um Debugger-Profiling zur Sammlung von System- und Framework-Metriken zu aktivieren**
------
#### [ Target Step ]
```
ProfilerConfig={
'S3OutputPath': 's3:////profiler-output', # Optional. Path to an S3 bucket to save profiling outputs
# Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3,
"MetricsRegex": ".*"
}',
'DetailedProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3
}',
'PythonProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3,
"ProfilerName": "cprofile", # Available options: cprofile, pyinstrument
"cProfileTimer": "total_time" # Include only when using cprofile. Available options: cpu, off_cpu, total_time
}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
}
```
------
#### [ Target Time Duration ]
```
ProfilerConfig={
'S3OutputPath': 's3:////profiler-output', # Optional. Path to an S3 bucket to save profiling outputs
# Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10,
"MetricsRegex": ".*"
}',
'DetailedProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10
}',
'PythonProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10,
"ProfilerName": "cprofile", # Available options: cprofile, pyinstrument
"cProfileTimer": "total_time" # Include only when using cprofile. Available options: cpu, off_cpu, total_time
}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
}
```
------
**Um Debugger-Regeln für die das Profiling der Metriken zu aktivieren**
Das folgende Codebeispiel zeigt, wie Sie die `ProfilerReport`-Regel konfigurieren.
```
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'ProfilerReport',
'CPUBottleneck_cpu_threshold': '90',
'IOBottleneck_threshold': '90'
}
}
]
```
Eine vollständige Liste der verfügbaren Docker-Images für die Verwendung der Debugger-Regeln finden Sie unter [Docker-Images für Debugger-Regeln](debugger-reference.md#debugger-docker-images-rules). Die Schlüssel-Wert-Paare für `RuleParameters` finden Sie unter [Liste der in den Debugger integrierten Regeln](debugger-built-in-rules.md).
## Die Profiling-Konfiguration des Debuggers mithilfe des `UpdateTrainingJob` API-Betriebs aktualisieren
Die Konfiguration der Debugger-Profilerstellung kann während der Ausführung Ihres Trainingsjobs mithilfe der [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_training_job)Funktion des AWS SageMaker Boto3 AI-Clients aktualisiert werden. Konfigurieren Sie neue [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)Objekte [ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)und geben Sie den Namen des Trainingsjobs für den Parameter an. `TrainingJobName`
```
ProfilerConfig={
'DisableProfiler': boolean,
'ProfilingIntervalInMilliseconds': number,
'ProfilingParameters': {
'string' : 'string'
}
},
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'string',
'RuleEvaluatorImage': 'string',
'RuleParameters': {
'string' : 'string'
}
}
],
TrainingJobName='your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS'
```
## Fügen Sie dem CreateTrainingJob API-Vorgang eine benutzerdefinierte Debuger-Regelkonfiguration hinzu
Eine benutzerdefinierte Regel kann für einen Trainingsjob mithilfe der [ DebugRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)Objekte [ DebugHookConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)und mithilfe der Funktion des AWS Boto3 SageMaker AI-Clients konfiguriert werden. [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job) Das folgende Codebeispiel zeigt, wie eine benutzerdefinierte `ImproperActivation` Regel, die mit der *smdebug-Bibliothek* geschrieben wurde, mithilfe dieser API-Operation konfiguriert wird. SageMaker In diesem Beispiel wird davon ausgegangen, dass Sie die benutzerdefinierte Regel in der Datei *custom\$1rules.py* geschrieben und in einen Amazon-S3-Bucket hochgeladen haben. Das Beispiel stellt vorgefertigte Docker-Images bereit, mit denen Sie Ihre benutzerdefinierten Regeln ausführen können. Diese werden unter [Amazon SageMaker Debugger-Image URIs für benutzerdefinierte Regelauswerter](debugger-reference.md#debuger-custom-rule-registry-ids) gelistet. Sie geben die URL-Registry-Adresse für das vorgefertigte Docker-Image im `RuleEvaluatorImage`-Parameter an.
```
DebugHookConfig={
'S3OutputPath': 's3:////debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'relu_activations',
'CollectionParameters': {
'include_regex': 'relu',
'save_interval': '500',
'end_step': '5000'
}
}
]
},
DebugRulesConfigurations=[
{
'RuleConfigurationName': 'improper_activation_job',
'RuleEvaluatorImage': '552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest',
'InstanceType': 'ml.c4.xlarge',
'VolumeSizeInGB': 400,
'RuleParameters': {
'source_s3_uri': 's3://bucket/custom_rules.py',
'rule_to_invoke': 'ImproperActivation',
'collection_names': 'relu_activations'
}
}
]
```
Eine vollständige Liste der verfügbaren Docker-Images für die Verwendung der Debugger-Regeln finden Sie unter [Docker-Images für Debugger-Regeln](debugger-reference.md#debugger-docker-images-rules). Die Schlüssel-Wert-Paare für `RuleParameters` finden Sie unter [Liste der in den Debugger integrierten Regeln](debugger-built-in-rules.md).
# Amazon SageMaker Debugger-Referenzen
Weitere Informationen und Referenzen zur Verwendung von Amazon SageMaker Debugger finden Sie in den folgenden Themen.
**Topics**
+ [SageMaker Amazon-Debugger APIs](#debugger-apis)
+ [Docker-Images für Debugger-Regeln](#debugger-docker-images-rules)
+ [Amazon SageMaker Debugger-Ausnahmen](#debugger-exceptions)
+ [Verteilte Schulungen, unterstützt von Amazon SageMaker Debugger](#debugger-considerations)
## SageMaker Amazon-Debugger APIs
Amazon SageMaker Debugger verfügt über API-Operationen an mehreren Standorten, die zur Implementierung der Überwachung und Analyse des Modelltrainings verwendet werden.
Amazon SageMaker Debugger bietet auch das [`sagemaker-debugger`Open-Source-Python-SDK](https://github.com/awslabs/sagemaker-debugger/tree/master/smdebug), mit dem integrierte Regeln konfiguriert, benutzerdefinierte Regeln definiert und Hooks registriert werden, um Ausgangstensordaten von Trainingsjobs zu sammeln.
Das [Amazon SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/) ist ein High-Level-SDK, das sich auf Experimente mit maschinellem Lernen konzentriert. Das SDK kann verwendet werden, um integrierte oder benutzerdefinierte Regeln bereitzustellen, die mit der `SMDebug` Python-Bibliothek definiert wurden, um diese Tensoren mithilfe von SageMaker KI-Schätzern zu überwachen und zu analysieren.
Debugger hat der SageMaker Amazon-API Operationen und Typen hinzugefügt, die es der Plattform ermöglichen, Debugger beim Trainieren eines Modells zu verwenden und die Konfiguration von Eingaben und Ausgaben zu verwalten.
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)und [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html)verwenden Sie den folgenden Debugger APIs , um Tensorsammlungen, Regeln, Regelbilder und Profilerstellungsoptionen zu konfigurieren:
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CollectionConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CollectionConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TensorBoardOutputConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TensorBoardOutputConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html) bietet eine vollständige Beschreibung eines Trainingsauftrags, einschließlich der folgenden Debugger-Konfigurationen und Status der Regelauswertung:
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleEvaluationStatus.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleEvaluationStatus.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleEvaluationStatus.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleEvaluationStatus.html)
Die API-Operationen zur Regelkonfiguration verwenden die SageMaker Verarbeitungsfunktion bei der Analyse eines Modelltrainings. Weitere Informationen zur SageMaker Verarbeitung finden Sie unter[Workloads zur Datentransformation mit SageMaker Verarbeitung](processing-job.md).
## Docker-Images für Debugger-Regeln
Amazon SageMaker AI bietet zwei Sätze von Docker-Images für Regeln: einen Satz für die Auswertung von Regeln, die von SageMaker KI bereitgestellt werden (integrierte Regeln) und einen Satz für die Auswertung von benutzerdefinierten Regeln, die in Python-Quelldateien bereitgestellt werden.
Wenn Sie das [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) verwenden, können Sie einfach SageMaker KI-Debugger-API-Operationen auf hoher Ebene mit SageMaker AI Estimator-API-Operationen verwenden, ohne die Debugger-Docker-Images manuell abrufen und die API konfigurieren zu müssen. `ConfigureTrainingJob`
Wenn Sie das SageMaker Python-SDK nicht verwenden, müssen Sie ein entsprechendes vorgefertigtes Container-Basis-Image für die Debugger-Regeln abrufen. Amazon SageMaker Debugger stellt vorgefertigte Docker-Images für integrierte und benutzerdefinierte Regeln bereit. Die Bilder werden in Amazon Elastic Container Registry (Amazon ECR) gespeichert. Um ein Bild aus einem Amazon ECR-Repository abzurufen (oder ein Bild in eines zu übertragen), verwenden Sie die vollständige Registrierungs-URL des Images mithilfe der `CreateTrainingJob` API. SageMaker AI verwendet die folgenden URL-Muster für die Image-Registrierungsadresse des Debugger-Regelcontainers.
```
.dkr.ecr..amazonaws.com/:
```
Die Konto-ID in jeder AWS Region, den Namen des Amazon ECR-Repositorys und den Tag-Wert finden Sie in den folgenden Themen.
**Topics**
+ [Amazon SageMaker Debugger-Image URIs für integrierte Regelauswerter](#debuger-built-in-registry-ids)
+ [Amazon SageMaker Debugger-Image URIs für benutzerdefinierte Regelauswerter](#debuger-custom-rule-registry-ids)
### Amazon SageMaker Debugger-Image URIs für integrierte Regelauswerter
Verwenden Sie die folgenden Werte für die Komponenten der Registrierung URLs für die Images, die integrierte Regeln für Amazon SageMaker Debugger bereitstellen. Informationen zum Konto IDs finden Sie in der folgenden Tabelle.
**Name des ECR-Repositorys:** sagemaker-debugger-rules
**Tag**: neuestes
**Beispiel für eine vollständige Registrierungs-URL**:
`904829902805.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rules:latest`
Konto IDs für Container-Images mit integrierten Regeln nach Region AWS
| Region | account\$1id |
| --- | --- |
| af-south-1 | 314341159256 |
| ap-east-1 | 199566480951 |
| ap-northeast-1 | 430734990657 |
| ap-northeast-2 | 578805364391 |
| ap-south-1 | 904829902805 |
| ap-southeast-1 | 972752614525 |
| ap-southeast-2 | 184798709955 |
| ca-central-1 | 519511493484 |
| cn-north-1 | 618459771430 |
| cn-northwest-1 | 658757709296 |
| eu-central-1 | 482524230118 |
| eu-north-1 | 314864569078 |
| eu-south-1 | 563282790590 |
| eu-west-1 | 929884845733 |
| eu-west-2 | 250201462417 |
| eu-west-3 | 447278800020 |
| me-south-1 | 986000313247 |
| sa-east-1 | 818342061345 |
| us-east-1 | 503895931360 |
| us-east-2 | 915447279597 |
| us-west-1 | 685455198987 |
| us-west-2 | 895741380848 |
| us-gov-west-1 | 515509971035 |
### Amazon SageMaker Debugger-Image URIs für benutzerdefinierte Regelauswerter
Verwenden Sie die folgenden Werte für die Komponenten der Registrierungs-URL für die Bilder, die benutzerdefinierte Regelauswertungen für Amazon SageMaker Debugger bereitstellen. Informationen zum Konto IDs finden Sie in der folgenden Tabelle.
**Name des ECR-Repositorys:** sagemaker-debugger-rule-evaluator
**Tag**: neuestes
**Beispiel für eine vollständige Registrierungs-URL**:
`552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest`
Konto IDs für Container-Images mit benutzerdefinierten Regeln nach Region AWS
| Region | account\$1id |
| --- | --- |
| af-south-1 | 515950693465 |
| ap-east-1 | 645844755771 |
| ap-northeast-1 | 670969264625 |
| ap-northeast-2 | 326368420253 |
| ap-south-1 | 552407032007 |
| ap-southeast-1 | 631532610101 |
| ap-southeast-2 | 445670767460 |
| ca-central-1 | 105842248657 |
| cn-north-1 | 617202126805 |
| cn-northwest-1 | 658559488188 |
| eu-central-1 | 691764027602 |
| eu-north-1 | 091235270104 |
| eu-south-1 | 335033873580 |
| eu-west-1 | 606966180310 |
| eu-west-2 | 074613877050 |
| eu-west-3 | 224335253976 |
| me-south-1 | 050406412588 |
| sa-east-1 | 466516958431 |
| us-east-1 | 864354269164 |
| us-east-2 | 840043622174 |
| us-west-1 | 952348334681 |
| us-west-2 | 759209512951 |
| us-gov-west-1 | 515361955729 |
## Amazon SageMaker Debugger-Ausnahmen
Amazon SageMaker Debugger wurde entwickelt, um zu berücksichtigen, dass Tensoren, die zur Ausführung einer Regel erforderlich sind, möglicherweise nicht bei jedem Schritt verfügbar sind. Infolgedessen werden einige Ausnahmen ausgelöst, mit denen Sie kontrollieren können, was passiert, wenn ein Tensor fehlt. Diese Ausnahmen sind im [Modul smdebug.exceptions](https://github.com/awslabs/sagemaker-debugger/blob/master/smdebug/exceptions.py) verfügbar. Sie können sie wie folgt importieren:
```
from smdebug.exceptions import *
```
Folgende Ausnahmen sind verfügbar:
+ `TensorUnavailableForStep` – Der angeforderte Tensor ist für diesen Schritt nicht verfügbar. Dies könnte bedeuten, dass dieser Schritt möglicherweise nicht durch den Hook gespeichert wird oder dass dieser Schritt zwar einige Tensoren gespeichert hat, der angeforderte Tensor aber nicht dazugehört. Wenn diese Ausnahme angezeigt wird, bedeutet dies, dass dieser Tensor zukünftig niemals für diesen Schritt verfügbar werden kann. Wenn für den Tensor Reduktionen für den Schritt gespeichert wurden, wird Ihnen mitgeteilt, dass sie abgefragt werden können.
+ `TensorUnavailable` – Dieser Tensor wird nicht gespeichert oder wurde von der `smdebug` API nicht gespeichert. Dies bedeutet, dass dieser Tensor für keinen Schritt in `smdebug` zu sehen ist.
+ `StepUnavailable` – Der Schritt wurde nicht gespeichert und der Debugger hat keine Daten aus diesem Schritt.
+ `StepNotYetAvailable` – Der Schritt wurde von `smdebug` noch nicht gesehen. Es könnte in der Zukunft verfügbar sein, wenn das Training noch andauert. Debugger lädt automatisch neue Daten, sobald sie verfügbar sind.
+ `NoMoreData` – Erhöht, wenn das Training endet. Sobald dies zu sehen ist, sind keine weiteren zu speichernde Schritte und Tensoren vorhanden.
+ `IndexReaderException` – Der Indexleser ist ungültig.
+ `InvalidWorker` – Es wurde ein ungültiger Auftragnehmer aufgerufen.
+ `RuleEvaluationConditionMet` – Die Auswertung der Regel im Schritt führte dazu, dass die Bedingung erfüllt wurde.
+ `InsufficientInformationForRuleInvocation` – Es wurden nicht genügend Informationen bereitgestellt, um die Regel aufzurufen.
## Verteilte Schulungen, unterstützt von Amazon SageMaker Debugger
Die folgende Liste zeigt den Gültigkeitsbereich und die Überlegungen zur Verwendung von Debugger für Trainingsaufträge mit Deep-Learning-Frameworks und verschiedenen verteilten Trainingsoptionen.
+ **Horovod**
Gültigkeitsbereich der Verwendung von Debugger für Trainingsaufträge mit Horovod
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-reference.html)
+ **SageMaker KI verteilte Daten parallel**
Gültigkeitsbereich der Verwendung von Debugger für Trainingsjobs mit parallel verteilten SageMaker KI-Daten
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/sagemaker/latest/dg/debugger-reference.html)
\$1 Der Debugger unterstützt kein Framework-Profiling für 2.x. TensorFlow
\$1\$1 SageMaker AI Distributed Data Parallel unterstützt TensorFlow 2.x mit Keras-Implementierung nicht.
+ **SageMaker Paralleles KI-verteiltes Modell** — Der Debugger unterstützt kein paralleles Training für verteilte SageMaker KI-Modelle.
+ **Verteiltes Training mit SageMaker KI-Checkpoints** — Der Debugger ist nicht für Trainingsjobs verfügbar, wenn sowohl die verteilte Trainingsoption als auch die SageMaker KI-Checkpoints aktiviert sind. Möglicherweise wird ein Fehler angezeigt, der wie folgt aussieht:
```
SMDebug Does Not Currently Support Distributed Training Jobs With Checkpointing Enabled
```
Um den Debugger für Trainingsjobs mit verteilten Trainingsoptionen zu verwenden, müssen Sie das SageMaker KI-Checkpointing deaktivieren und Ihrem Trainingsskript manuelle Checkpoint-Funktionen hinzufügen. Mehr Informationen über die Verwendung des Debuggers mit verteilten Trainingsoptionen und Prüfpunkte finden Sie unter [Verwendung von verteilten SageMaker KI-Daten parallel zu Amazon SageMaker Debugger und Checkpoints](distributed-troubleshooting-data-parallel.md#distributed-ts-data-parallel-debugger) und [Speichern von Prüfpunkten](distributed-troubleshooting-model-parallel.md#distributed-ts-model-parallel-checkpoints).
+ **Parameterserver** – Der Debugger unterstützt kein auf Parameterservern basierendes verteiltes Training.
+ Die Profilierung verteilter Trainingsrahmenoperationen, wie z. B. der parallel `AllReduced` Betrieb von verteilten SageMaker KI-Daten und [Horovod-Operationen](https://horovod.readthedocs.io/en/stable/timeline_include.html), ist nicht verfügbar.