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.

# 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
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
Trainingsjobs mithilfe des benutzerdefinierten Containers 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()
```