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.
# 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).