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 einsetzen. Mit den APIs AWS CLI, SageMaker AI ModelTrainer API und Debugger können Sie beliebige Docker-Basisimages verwenden, um Container zu erstellen und anzupassen, um Ihre Modelle zu trainieren. 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.

Ein durchgehendes Beispiel für die Verwendung von Debugger mit einem benutzerdefinierten Trainingscontainer finden Sie im folgenden Beispiel-Notebook.

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.

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 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-Clientbibliothek:

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:

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 zu speichern undDockerfile. 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-Container-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

! 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 eine SageMaker KI ModelTrainer mit Ihrem Trainingsskript und den Parametern. Debugger-specific Nachdem Sie den model_trainer.train() 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 mit Amazon CloudWatch Events einen Workflow zur Überwachung der Debugger-Regeln konfigurieren, können Sie den Prozess automatisieren AWS Lambda, bei dem die Debugger-Regeln Trainingsprobleme erkennen, das Stoppen von Trainingsaufträgen.

import sagemaker
from sagemaker.train import ModelTrainer
from sagemaker.core.debugger import Rule, DebuggerHookConfig, CollectionConfig, rule_configs
from sagemaker.core.helper.session_helper import get_execution_role

profiler_config=ProfilerConfig(...)
debugger_hook_config=DebuggerHookConfig(...)
rules=[
    Rule.sagemaker(rule_configs.built_in_rule()),
    ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]

from sagemaker.train.configs import SourceCode, Compute

model_trainer=ModelTrainer(
    training_image=byoc_image_uri,
    source_code=SourceCode(entry_script="./debugger_custom_container_test_folder/your-training-script.py"),
    role=get_execution_role(),
    base_job_name='debugger-custom-container-test',
    compute=Compute(instance_type='ml.p3.2xlarge', instance_count=1),
    
    # Debugger-specific parameters
    profiler_config=profiler_config,
    debugger_hook_config=debugger_hook_config,
    rules=rules
)

# start training
model_trainer.train()