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 AI. SageMaker As AWS CLIModelTrainer APIs SageMaker AI API e Debugger 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 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 ResNet 50 e como passar o gancho do Debugger como um retorno de chamada 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 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 sua SageMaker IA 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 de contêiner de aprendizado AWS profundo pré-criada, consulte Imagens de contêineres de aprendizado AWS profundo 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 seu contêiner docker para o Amazon ECR, configure uma SageMaker IA ModelTrainer com seu script de treinamento e os Debugger-specific parâmetros. Depois de executar o model_trainer.train(), 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 Debugger com o Amazon CloudWatch Events AWS Lambda, você pode automatizar um processo de interrupção do trabalho de treinamento sempre que as regras do Debugger detectarem problemas de treinamento.

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