Use o Depurador com contêineres de treinamento personalizados

O Amazon SageMaker Debugger está disponível para qualquer modelo de aprendizado profundo que você trouxer para o Amazon SageMaker AI. A AWS CLI, a API Estimator do SageMaker AI e as APIs do Debugger permitem que você use qualquer imagem base do Docker para criar e personalizar contêineres e 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 instruem você a usar o Depurador com Contêineres de Treinamento Personalizados.

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

Para um exemplo completo do uso do Depurador 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 Hook do Depurador 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 ResNet50 e como passar o hook do Depurador como um retorno de chamada Keras para depuração. Para encontrar um script de treinamento completo, consulte o Script de treinamento do TensorFlow com o hook do 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 hook do Depurador para as estruturas e algoritmos compatíveis, consulte os seguintes links na biblioteca de clientes do SMDebug:

Nos seguintes exemplos de scripts de treinamento dos cadernos, 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:

Criar e configurar um Dockerfile

Abra seu SageMaker AI JupyterLab e crie uma pasta (debugger_custom_container_test_folder, neste exemplo) para salvar seu script de treinamento e Dockerfile. 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 profundo AWS, consulte Imagens de contêineres de aprendizado profundo AWS disponíveis.

Crie e envie a imagem personalizada do treinamento para o 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 diretório debugger_byoc_test_docker, criará o docker com o algorithm_nameespecificado e enviará o contêiner do docker para o 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 os trabalhos de treinamento usando o contêiner de treinamento personalizado

Depois de criar e enviar o contêiner do Docker ao Amazon ECR, configure um estimador do SageMaker AI 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 atributos e ferramentas smdebug. Configurando um fluxo de trabalho do processo de monitoramento de regras do Depurador com o Amazon CloudWatch Events e AWS Lambda, você pode automatizar um processo de interrupção de trabalho de treinamento sempre que as regras do Depurador 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()