Usa Debugger con contenitori di formazione personalizzati

Amazon SageMaker Debugger è disponibile per tutti i modelli di deep learning che porti su Amazon. SageMaker Il AWS CLI SageMaker EstimatorAPI, e il Debugger ti APIs consentono di utilizzare qualsiasi immagine di base Docker per creare e personalizzare contenitori per addestrare i tuoi modelli. Per utilizzare Debugger con container personalizzati, è necessario apportare una modifica minima allo script di addestramento per implementare la richiamata dell’hook Debugger e recuperare i tensori dai processi di addestramento. Le seguenti sezioni ti spiegheranno come usare Debugger con Custom Training Containers.

Sono necessarie le seguenti risorse per creare un container personalizzato con Debugger.

Per un end-to-end esempio di utilizzo di Debugger con un contenitore di formazione personalizzato, vedete il seguente esempio di notebook.

Preparati a creare un contenitore di formazione personalizzato

Per creare un container docker, la struttura di base dei file deve essere la seguente:

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

Registra Debugger hook nel tuo script di allenamento

Per eseguire il debug dell'addestramento del modello, è necessario aggiungere un hook Debugger allo script di addestramento.

Il codice di esempio seguente mostra la struttura di uno script di addestramento che utilizza il modello Keras ResNet 50 e come passare l'hook Debugger come callback Keras per il debug. Per trovare uno script di addestramento completo, consulta lo script di formazione con Debugger hook. TensorFlow 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()
        

Per ulteriori informazioni sulla registrazione dell'hook Debugger per i framework e gli algoritmi supportati, consultate i seguenti collegamenti nella libreria client: SMDebug

Negli script di addestramento dei notebook di esempio seguenti, puoi trovare altri esempi su come aggiungere gli hook Debugger agli script di addestramento e raccogliere i tensori di output in dettaglio:

Crea e configura un Dockerfile

Apri SageMaker JupyterLab e crea una nuova cartella, debugger_custom_container_test_folder in questo esempio, per salvare lo script di allenamento e. Dockerfile Il seguente esempio di codice è un Dockerfile che include i comandi di build docker essenziali. Incolla il seguente codice nel file di testo Dockerfile e salvalo. Carica lo script di addestramento nella stessa cartella.

# 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 desideri utilizzare un'immagine predefinita del AWS Deep Learning Container, consulta Immagini dei AWS Deep Learning Containers disponibili.

Crea e distribuisci l'immagine di formazione personalizzata su Amazon ECR

Crea un notebook di test, debugger_custom_container_test_notebook.ipynb, ed esegui il seguente codice nella cella del notebook. Questo accederà alla debugger_byoc_test_docker directory, creerà il docker con quanto specificato algorithm_name e invierà il contenitore docker al tuo 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

Esegui ed esegui il debug dei lavori di formazione utilizzando il contenitore di formazione personalizzato

Dopo aver creato e inviato il tuo contenitore docker ad AmazonECR, configura uno SageMaker stimatore con lo script di formazione e i parametri specifici del Debugger. Dopo aver eseguito estimator.fit(), Debugger raccoglierà i tensori di output, li monitorerà e rileverà i problemi di addestramento. Utilizzando i tensori salvati, è possibile analizzare ulteriormente il processo di addestramento utilizzando le funzionalità e gli strumenti principali smdebug. Configurando un flusso di lavoro del processo di monitoraggio delle regole di Debugger con Amazon CloudWatch Events AWS Lambda, puoi automatizzare un processo di interruzione del processo di formazione ogni volta che le regole del Debugger rilevano problemi di formazione.

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