Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Utilizzo di Debugger con container di addestramento personalizzati
Amazon SageMaker Debugger è disponibile per tutti i modelli di deep learning che apporti ad Amazon AI. SageMaker L' AWS CLI`Estimator`API SageMaker AI 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. Nelle seguenti sezioni verrà illustrato l’utilizzo di Debugger con container di addestramento personalizzati.
Sono necessarie le seguenti risorse per creare un container personalizzato con Debugger.
+ [SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable)
+ [La libreria SMDebug client open source](https://github.com/awslabs/sagemaker-debugger)
+ Un'immagine di base Docker a tua scelta
+ Lo script di addestramento con un hook Debugger registrato — Per ulteriori informazioni sulla registrazione di un hook Debugger nello script di addestramento, consulta [Registrazione di hook Debugger nel tuo script di addestramento](#debugger-script-mode).
Per un end-to-end esempio di utilizzo di Debugger con un contenitore di formazione personalizzato, vedete il seguente esempio di notebook.
+ [Crea un container di addestramento personalizzato ed esegui il debug dei processi di addestramento con Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/build_your_own_container_with_debugger/debugger_byoc.html)
**Suggerimento**
Questa guida relativa ai container personalizzati con Debugger è un'estensione della guida [Adattamento del container di addestramento](adapt-training-container.md) che illustra come creare e inviare un container di addestramento personalizzato ad Amazon ECR.
## Preparazione per la creazione di un container di addestramento 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
```
## Registrazione di hook Debugger nel tuo script di addestramento
Per eseguire il debug dell'addestramento del modello, è necessario aggiungere un hook Debugger allo script di addestramento.
**Nota**
Questa fase è necessaria per raccogliere i parametri del modello (tensori di output) per il debug dell'addestramento del modello. Se desideri solo monitorare e profilare, puoi saltare questa fase di registrazione degli hook ed escludere il parametro `debugger_hook_config` durante la creazione di uno stimatore.
Il codice di esempio seguente mostra la struttura di uno script di training 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 ](https://github.com/aws/amazon-sagemaker-examples/blob/master/sagemaker-debugger/build_your_own_container_with_debugger/docker/tf_keras_resnet_byoc.py)
```
# 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
+ [SMDebug TensorFlow gancio](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/tensorflow.md)
+ [SMDebug PyTorch gancio](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/pytorch.md)
+ [SMDebug MXNet gancio](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/mxnet.md)
+ [SMDebug XGBoost gancio](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/xgboost.md)
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:
+ [Debugger in modalità script con il framework 2.1 TensorFlow ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow2/tensorflow2_keras_custom_container/tf2-keras-custom-container.html)
Per vedere la differenza tra l'utilizzo di Debugger in un Deep Learning Container e in modalità script, apri questo notebook e mettilo fianco a fianco con [il precedente esempio di Debugger in un Deep](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow2/tensorflow2_zero_code_change/tf2-keras-default-container.html) Learning Container v2.1. TensorFlow
In modalità script, la parte di configurazione hook viene rimossa dallo script in cui si imposta lo strumento di valutazione. [Invece, la funzionalità Debugger hook viene unita allo script di addestramento, lo script di addestramento Keras in modalità script. TensorFlow ResNet ](https://github.com/awslabs/amazon-sagemaker-examples/blob/master/sagemaker-debugger/tensorflow2/tensorflow2_keras_custom_container/src/tf_keras_resnet_byoc.py) Lo script di addestramento importa la `smdebug` libreria nell'ambiente TensorFlow Keras richiesto per comunicare con l'algoritmo 50. TensorFlow ResNet Inoltre, implementa manualmente la funzionalità `smdebug` hook aggiungendo l'`callbacks=[hook]`argomento all'interno della `train` funzione (nella riga 49) e aggiungendo la configurazione manuale dell'hook (nella riga 89) fornita tramite SageMaker Python SDK.
In questo esempio di modalità script viene eseguito il processo di addestramento nel framework TF 2.1 per il confronto diretto con la modifica dello script zero nell'esempio TF 2.1. Il vantaggio della configurazione di Debugger in modalità script è la flessibilità di scegliere versioni del framework non coperte da AWS Deep Learning Containers.
+ [Utilizzo di Amazon SageMaker Debugger in un PyTorch contenitore in modalità script](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_custom_container)
Questo notebook abilita Debugger in modalità script nel framework v1.3.1. PyTorch PyTorchla v1.3.1 è supportata dai contenitori SageMaker AI e questo esempio mostra i dettagli su come modificare uno script di addestramento.
Lo PyTorch stimatore SageMaker AI è già in modalità script per impostazione predefinita. Nel notebook, la linea per attivare `script_mode` non è inclusa nella configurazione dello strumento di stima.
Questo taccuino mostra i passaggi dettagliati per modificare [lo script di PyTorch addestramento originale](https://github.com/pytorch/examples/blob/master/mnist/main.py) in una versione modificata per abilitare Debugger. Inoltre, questo esempio mostra come è possibile utilizzare le regole integrate di Debugger per rilevare problemi di addestramento, come il problema di gradienti di fuga, e le funzionalità di prova di Debugger per chiamare e analizzare i tensori salvati.
## Creazione e configurazione di un Dockerfile
Apri l' SageMaker IA 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](https://aws.amazon.com/releasenotes/available-deep-learning-containers-images/).
## Creazione e invio del container di addestramento personalizzato 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 directory `debugger_byoc_test_docker`, creerà il docker con quanto il `algorithm_name`specificato e invierà il container 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
```
**Suggerimento**
Se utilizzi una delle immagini di base del AWS Deep Learning Container, esegui il codice seguente per accedere ad Amazon ECR e accedere all'archivio di immagini del Deep Learning Container.
```
! aws ecr get-login-password --region {region} | docker login --username AWS --password-stdin 763104351884.dkr.ecr.us-east-1.amazonaws.com
```
## Avvio e debug dei job di addestramento utilizzando il container di addestramento personalizzato
Dopo aver creato e inviato il container docker ad Amazon ECR, configura uno stimatore SageMaker AI 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()
```