Use o Debugger com contêineres de treinamento personalizados

O Amazon SageMaker Debugger está disponível para qualquer modelo de aprendizado profundo que você trouxer para a Amazon. SageMaker O AWS CLI, SageMaker EstimatorAPI, e o Debugger APIs permitem que você use qualquer imagem base do Docker para criar e personalizar contêineres para treinar seus modelos. Para usar o Depurador com contêineres personalizados, você precisa fazer uma alteração mínima em seu script de treinamento para implementar o retorno de chamada do hook do Depurador e recuperar tensores dos trabalhos de treinamento. As seções a seguir explicarão como usar o Debugger com contêineres de treinamento personalizados.

Você precisa dos seguintes recursos para criar um contêiner personalizado com o Depurador.

Para ver um end-to-end exemplo de uso do Debugger com um contêiner de treinamento personalizado, consulte o exemplo de caderno a seguir.

Prepare-se para criar um contêiner de treinamento personalizado

Para criar um contêiner do docker, a estrutura básica dos arquivos deve ter a seguinte aparência:

├── 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

Registre o Debugger hook em seu script de treinamento

Para depurar seu treinamento de modelo, você precisa adicionar um hook do Depurador ao seu script de treinamento.

O código de exemplo a seguir mostra a estrutura de um script de treinamento usando o modelo Keras ResNet 50 e como passar o gancho do Debugger como um retorno de chamada do Keras para depuração. Para encontrar um script de treinamento completo, consulte o script de TensorFlow treinamento com o gancho SageMaker Debugger.

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

Para obter mais informações sobre como registrar o gancho do Debugger para as estruturas e algoritmos compatíveis, consulte os links a seguir na biblioteca do cliente: SMDebug

Nos exemplos de scripts de treinamento dos cadernos a seguir, você pode encontrar mais exemplos sobre como adicionar os hooks do Depurador aos scripts de treinamento e coletar os tensores de saída em detalhes:

Crie e configure um Dockerfile

Abra sua SageMaker JupyterLab e crie uma nova pasta, debugger_custom_container_test_folder neste exemplo, para salvar seu script de treinamento Dockerfile e. O exemplo de código a seguir é um Dockerfile que inclui elogios essenciais da compilação do docker. Cole o conteúdo a seguir no arquivo de texto Dockerfile e salve-o. Carregue seu script de treinamento na mesma pasta.

# 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"]

Se você quiser usar uma imagem pré-criada de contêiner de aprendizado AWS profundo, consulte Imagens de contêineres de aprendizado AWS profundo disponíveis.

Crie e envie a imagem de treinamento personalizada para a Amazon ECR

Crie um caderno de teste, debugger_custom_container_test_notebook.ipynb, e execute o código a seguir na célula do caderno. Isso acessará o debugger_byoc_test_docker diretório, criará o docker com o especificado algorithm_name e enviará o contêiner docker para sua 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

Execute e depure trabalhos de treinamento usando o contêiner de treinamento personalizado

Depois de criar e enviar seu contêiner docker para a AmazonECR, configure um SageMaker estimador com seu script de treinamento e os parâmetros específicos do Debugger. Depois de executar o estimator.fit(), o Depurador coletará os tensores de saída, irá monitorá-los e detectará problemas de treinamento. Usando os tensores salvos, você pode analisar melhor o trabalho de treinamento usando os principais recursos e ferramentas smdebug. Configurando um fluxo de trabalho do processo de monitoramento de regras do Debugger com o Amazon CloudWatch Events AWS Lambda, você pode automatizar a interrupção do processo de trabalho de treinamento sempre que as regras do Debugger detectarem problemas de treinamento.

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()