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à.
# Amazon SageMaker Debugger
Esegui il debug dei tensori di output dei modelli dai lavori di formazione sull'apprendimento automatico in tempo reale e rileva problemi non convergenti utilizzando Amazon Debugger. SageMaker
## Caratteristiche di Amazon SageMaker Debugger
Un processo di addestramento di machine learning (ML) può presentare problemi quali sovradimensionamento, saturazione delle funzioni di attivazione e riduzione dei gradienti, che possono compromettere le prestazioni del modello.
SageMaker Debugger fornisce strumenti per eseguire il debug dei lavori di formazione e risolvere tali problemi per migliorare le prestazioni del modello. Debugger offre anche strumenti per inviare avvisi quando vengono rilevate anomalie di addestramento, intraprendere azioni rispetto ai problemi e identificarne la causa principale visualizzando i parametri e i tensori raccolti.
SageMaker Debugger supporta i framework Apache,, e. MXNet PyTorch TensorFlow XGBoost Per ulteriori informazioni sui framework e sulle versioni disponibili supportate da Debugger, consultate. SageMaker [Framework e algoritmi supportati](debugger-supported-frameworks.md)
![\[Panoramica di come funziona Amazon SageMaker Debugger.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-main.png)
Di seguito è riportato il flusso di lavoro di Debugger di alto livello:
1. Se necessario, modifica lo script di addestramento con `sagemaker-debugger` Python SDK.
1. Configura un lavoro di SageMaker formazione con Debugger. SageMaker
+ Configura utilizzando l'API SageMaker AI Estimator (per Python SDK).
+ Configura utilizzando la [`CreateTrainingJob`richiesta SageMaker AI (per Boto3 o CLI](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-createtrainingjob-api.html)).
+ Configura [contenitori di formazione personalizzati con Debugger](debugger-bring-your-own-container.md). SageMaker
1. Avvia un processo di addestramento e monitora i problemi di addestramento in tempo reale.
+ [Elenco delle regole integrate di Debugger](debugger-built-in-rules.md).
1. Ricevi avvisi e intraprendi azioni tempestive per risolvere i problemi di addestramento.
+ Ricevi SMS ed e-mail e interrompi i processi di addestramento quando vengono rilevati problemi di addestramento utilizzando [Utilizzo delle azioni integrate di Debugger per le regole](debugger-built-in-actions.md).
+ Configura le tue azioni utilizzando [Amazon CloudWatch Events e AWS Lambda](debugger-cloudwatch-lambda.md).
1. Esplora un'analisi approfondita dei problemi di addestramento.
+ Per il debug dei tensori di output del modello, consulta [Visualizza i tensori di output del Debugger in TensorBoard](debugger-enable-tensorboard-summaries.md).
1. Risolvi i problemi, prendi in considerazione i suggerimenti forniti da Debugger e ripeti le fasi da 1 a 5 fino a ottimizzare il modello e raggiungere la precisione desiderata.
La guida per sviluppatori SageMaker Debugger illustra i seguenti argomenti.
**Topics**
+ [Caratteristiche di Amazon SageMaker Debugger](#debugger-features)
+ [Framework e algoritmi supportati](debugger-supported-frameworks.md)
+ [Architettura Amazon SageMaker Debugger](debugger-how-it-works.md)
+ [Tutorial di Debugger](debugger-tutorial.md)
+ [Processi di formazione per il debug con Amazon Debugger SageMaker](debugger-debug-training-jobs.md)
+ [Elenco delle regole integrate di Debugger](debugger-built-in-rules.md)
+ [Creazione di regole personalizzate utilizzando la libreria client di Debugger](debugger-custom-rules.md)
+ [Utilizzo di Debugger con container di addestramento personalizzati](debugger-bring-your-own-container.md)
+ [Configurazione del debugger tramite l'API SageMaker](debugger-createtrainingjob-api.md)
+ [Riferimenti Amazon SageMaker Debugger](debugger-reference.md)
# Framework e algoritmi supportati
La tabella seguente mostra i framework e gli algoritmi di machine learning basati sull' SageMaker intelligenza artificiale supportati da Debugger.
|
|
| **SageMaker AI-supported frameworks and algorithms** | **Debugging output tensors** |
| --- |--- |
| [TensorFlow](https://sagemaker.readthedocs.io/en/stable/using_tf.html) | [AWS TensorFlow contenitori di deep learning 1.15.4 o versioni successive](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) |
| [PyTorch](https://sagemaker.readthedocs.io/en/stable/using_pytorch.html) | [AWS PyTorch contenitori di deep learning 1.5.0](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) o versioni successive |
| [MXNet](https://sagemaker.readthedocs.io/en/stable/using_mxnet.html) | [AWS MXNet contenitori di deep learning](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#general-framework-containers) 1.6.0 o versioni successive |
| [XGBoost](https://sagemaker.readthedocs.io/en/stable/frameworks/xgboost/using_xgboost.html) | 1.0-1, 1.2-1, 1.3-1 |
| [SageMaker Stimatore generico AI](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) | [Contenitori di formazione personalizzati](debugger-bring-your-own-container.md) (disponibili per TensorFlow, PyTorch MXNet, e XGBoost con registrazione manuale dei ganci) |
+ **Debug dei tensori di output**: monitora ed esegui il debug dei parametri del modello, come pesi, gradienti, distorsioni e valori scalari, del tuo processo di addestramento. I framework di deep learning disponibili sono Apache MXNet, TensorFlow, PyTorch e. XGBoost
**Importante**
Per il TensorFlow framework con Keras, SageMaker Debugger depreca il supporto a zero modifiche del codice per i modelli di debug creati utilizzando i moduli della versione 2.6 e successive. `tf.keras` TensorFlow [Ciò è dovuto alle importanti modifiche annunciate nella nota di rilascio della versione 2.6.0. TensorFlow ](https://github.com/tensorflow/tensorflow/releases/tag/v2.6.0) Per istruzioni su come aggiornare lo script di addestramento, consulta [Adatta il tuo script di allenamento TensorFlow](debugger-modify-script-tensorflow.md).
**Importante**
A partire dalla PyTorch versione 1.12.0 e successive, SageMaker Debugger non supporta più la modifica del codice zero per i modelli di debug.
Ciò è dovuto a modifiche sostanziali che causano l'interferenza di Debugger con la funzionalità. SageMaker `torch.jit` Per istruzioni su come aggiornare lo script di addestramento, consulta [PyTorch Adatta il tuo script di allenamento](debugger-modify-script-pytorch.md).
Se il framework o l'algoritmo che desideri addestrare ed eseguire il debug non è elencato nella tabella, vai al [Forum di AWS discussione](https://forums.aws.amazon.com/) e lascia un feedback su Debugger. SageMaker
## Regioni AWS
Amazon SageMaker Debugger è disponibile in tutte le regioni in cui Amazon SageMaker AI è in servizio, ad eccezione delle seguenti regioni.
+ Asia Pacifico (Giacarta): `ap-southeast-3`
Per scoprire se Amazon SageMaker AI è in servizio nel tuo paese Regione AWS, consulta [AWS Regional Services](https://aws.amazon.com/about-aws/global-infrastructure/regional-product-services/).
## Uso di Debugger con container di addestramento personalizzati
Implementa i tuoi contenitori di formazione all' SageMaker intelligenza artificiale e ottieni informazioni dettagliate sui tuoi lavori di formazione utilizzando Debugger. Massimizza la tua efficienza lavorativa ottimizzando il tuo modello sulle istanze Amazon EC2 utilizzando le funzionalità di monitoraggio e debug.
Per ulteriori informazioni su come creare un container di addestramento con la libreria client `sagemaker-debugger`, inviarlo ad Amazon Elastic Container Registry (Amazon ECR) e monitorare ed eseguire il debug, consulta [Utilizzo di Debugger con container di addestramento personalizzati](debugger-bring-your-own-container.md).
## Repository open source di Debugger GitHub
I debugger APIs sono forniti tramite SageMaker Python SDK e progettati per creare configurazioni di hook e regole Debugger per le operazioni di intelligenza artificiale e API. SageMaker [ CreateTrainingJob[ DescribeTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) La libreria client `sagemaker-debugger` fornisce strumenti per registrare gli *hook* e accedere ai dati di addestramento tramite la sua funzionalità di *prova*, il tutto tramite le sue operazioni API flessibili e potenti. Supporta i framework TensorFlow di machine learning e XGBoost Python MXNet 3.6 e versioni successive. PyTorch
Per risorse dirette su Debugger e sulle operazioni API `sagemaker-debugger`, consulta i collegamenti seguenti:
+ [La documentazione dell' SageMaker SDK Amazon Python](https://sagemaker.readthedocs.io/en/stable/amazon_sagemaker_debugger.html)
+ [L'SDK Amazon SageMaker Python - Debugger APIs](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html)
+ [La documentazione dell'SDK `sagemaker-debugger` Python per la libreria client](https://sagemaker-debugger.readthedocs.io/en/website/index.html) open [source Amazon SageMaker Debugger](https://github.com/awslabs/sagemaker-debugger#amazon-sagemaker-debugger)
+ [Il PyPI`sagemaker-debugger`](https://pypi.org/project/smdebug/)
Se utilizzi l'SDK for Java per SageMaker condurre lavori di formazione e desideri configurare APIs Debugger, consulta i seguenti riferimenti:
+ [Amazon SageMaker Debugger APIs](debugger-reference.md#debugger-apis)
+ [Configurazione del debugger tramite l'API SageMaker](debugger-createtrainingjob-api.md)
# Architettura Amazon SageMaker Debugger
Questo argomento illustra una panoramica di alto livello del flusso di lavoro di Amazon SageMaker Debugger.
Debugger supporta la funzionalità di profilazione per l'*ottimizzazione delle prestazioni* per identificare problemi di calcolo, come colli di bottiglia e sottoutilizzo del sistema, e per contribuire a ottimizzare l'utilizzo delle risorse hardware su larga scala.
La funzionalità di debug di Debugger per l'*ottimizzazione dei modelli* consiste nell'analisi dei problemi di addestramento non convergenti che possono insorgere riducendo al minimo le funzioni di perdita utilizzando algoritmi di ottimizzazione, come la discesa del gradiente e le sue variazioni.
Il diagramma seguente mostra l'architettura di Debugger. SageMaker I blocchi con linee di limite in grassetto sono ciò che Debugger riesce ad analizzare durante il processo di addestramento.
![\[Panoramica di come funziona Amazon SageMaker Debugger.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger_new_diagram.png)
Debugger archivia i seguenti dati dei tuoi processi di addestramento nel tuo bucket Amazon S3 sicuro:
+ **Tensori di output**: raccolte di scalari e parametri del modello che vengono continuamente aggiornati durante i passaggi avanti e indietro durante l'addestramento dei modelli ML. I tensori di output includono valori scalari (precisione e perdita) e matrici (pesi, gradienti, livelli di input e livelli di output).
**Nota**
Per impostazione predefinita, Debugger monitora ed esegue il debug dei lavori di SageMaker formazione senza parametri specifici del Debugger configurati negli estimatori AI. SageMaker Debugger raccoglie i parametri di sistema ogni 500 millisecondi e i tensori di output di base (output scalari come perdita e precisione) ogni 500 fasi. Inoltre, esegue la regola `ProfilerReport` per analizzare i parametri di sistema e aggregare i pannelli di controllo delle informazioni approfondite di Studio Debugger e un report di profilazione. Debugger salva i dati di output nel bucket Amazon S3 sicuro.
Le regole di Debugger integrate vengono eseguite sui container di elaborazione, progettati per valutare i modelli di machine learning elaborando i dati di addestramento raccolti nel bucket S3 (consulta [Dati di processo e modelli di valutazione](https://docs.aws.amazon.com//sagemaker/latest/dg/processing-job.html)). Le regole integrate sono completamente gestite da Debugger. Puoi inoltre creare le tue regole personalizzate in base al tuo modello per controllare eventuali problemi che desideri monitorare.
# Tutorial di Debugger
I seguenti argomenti illustrano i tutorial dalle nozioni di base ai casi d'uso avanzati di monitoraggio, profilazione e debug dei processi di addestramento SageMaker utilizzando Debugger. Esplora le funzionalità di Debugger e scopri come eseguire il debug e migliorare i tuoi modelli di machine learning in modo efficiente utilizzando Debugger.
**Topics**
+ [Video tutorial su Debugger](debugger-videos.md)
+ [Notebook di esempio di Debugger](debugger-notebooks.md)
+ [Demo e visualizzazione avanzate di Debugger](debugger-visualization.md)
# Video tutorial su Debugger
I seguenti video forniscono un tour delle funzionalità di Amazon SageMaker Debugger utilizzando istanze di notebook SageMaker Studio e SageMaker AI.
**Topics**
+ [Modelli di debug con Amazon SageMaker Debugger in Studio Classic](#debugger-video-get-started)
+ [Approfondimento su Amazon SageMaker Debugger e SageMaker sul monitor del modello AI](#debugger-video-dive-deep)
## Modelli di debug con Amazon SageMaker Debugger in Studio Classic
*Julien Simon, AWS Technical Evangelist \$1 Durata: 14 minuti 17 secondi*
Questo video tutorial mostra come usare Amazon SageMaker Debugger per acquisire e controllare le informazioni di debug da un modello di formazione. Il modello di addestramento di esempio utilizzato in questo video è una semplice rete neurale convoluzionale (CNN) basata su Keras con backend. TensorFlow SageMaker L'intelligenza artificiale in un TensorFlow framework e Debugger consentono di creare uno stimatore direttamente utilizzando lo script di addestramento ed eseguire il debug del processo di formazione.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/MqPdTj0Znwg)
Puoi trovare il notebook di esempio usato nel video in [questo repository Studio Demo](https://gitlab.com/juliensimon/amazon-studio-demos/-/tree/master) fornito dall'autore. È necessario clonare il file del `debugger.ipynb` notebook e lo script di `mnist_keras_tf.py` formazione su SageMaker Studio o su un'istanza del notebook. SageMaker Dopo aver clonato i due file, specifica il percorso `keras_script_path` verso il file `mnist_keras_tf.py` all'interno del notebook `debugger.ipynb`. Ad esempio, se hai clonato i due file nella stessa directory, impostala come `keras_script_path = "mnist_keras_tf.py"`.
## Approfondimento su Amazon SageMaker Debugger e SageMaker sul monitor del modello AI
*Julien Simon, AWS Technical Evangelist \$1 Durata: 44 minuti 34 secondi*
Questa sessione video esplora le funzionalità avanzate di Debugger e SageMaker Model Monitor che aiutano a incrementare la produttività e la qualità dei modelli. Innanzitutto, questo video mostra come rilevare e risolvere i problemi di addestramento, visualizzare i tensori e migliorare i modelli con Debugger. Successivamente, alle 22:41, il video mostra come monitorare i modelli in produzione e identificare problemi di previsione come le funzionalità mancanti o la deriva dei dati utilizzando AI Model Monitor. SageMaker Infine, puoi trovare dei suggerimenti per l'ottimizzazione dei costi che consentono di sfruttare al massimo il tuo budget relativo al machine learning.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/0zqoeZxakOI)
Puoi trovare il notebook di esempio mostrato nel video in [ questo repository AWS Dev Days 2020](https://gitlab.com/juliensimon/awsdevdays2020/-/tree/master/mls1) offerto dall'autore.
# Notebook di esempio di Debugger
SageMaker [I [notebook di esempio del debugger sono forniti nel repository aws/](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/). amazon-sagemaker-examples](https://github.com/aws/amazon-sagemaker-examples) I notebbok di esempio di Debugger illustrano i casi d'uso di base e avanzati dei processi di addestramento per il debug e la profilazione.
Ti consigliamo di eseguire i notebook di esempio su SageMaker Studio o un'istanza SageMaker Notebook perché la maggior parte degli esempi è progettata per lavori di formazione nell'ecosistema di SageMaker intelligenza artificiale, tra cui Amazon EC2, Amazon S3 e Amazon Python SDK. SageMaker
Per clonare il repository di esempio su SageMaker Studio, segui le istruzioni su [Amazon SageMaker Studio Tour](https://docs.aws.amazon.com/sagemaker/latest/dg/gs-studio-end-to-end.html).
**Importante**
Per utilizzare le nuove funzionalità di Debugger, è necessario aggiornare l'SDK SageMaker Python e la libreria client. `SMDebug` Nel kernel IPython, Jupyter Notebook JupyterLab o nell'ambiente, esegui il codice seguente per installare le versioni più recenti delle librerie e riavviare il kernel.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Notebook di esempio di Debugger per la profilazione dei job di addestramento
L'elenco seguente mostra alcuni notebook di esempio di Debugger che presentano l'adattabilità di Debugger per monitorare e profilare i processi di addestramento per vari modelli, set di dati e framework di machine learning.
| Titolo del notebook | Framework | Modello | Set di dati | Description |
| --- | --- | --- | --- | --- |
| [Analisi dei dati di profilazione di Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/debugger_interactive_analysis_profiling/interactive_analysis_profiling_data.html) | TensorFlow | ResNetKeras 50 | Cifar-10 | Questo notebook fornisce un'introduzione all'analisi interattiva dei dati profilati acquisiti da SageMaker Debugger. Esplora tutte le funzionalità degli strumenti di analisi interattivi `SMDebug`. |
| [Profilare la formazione sull'apprendimento automatico con Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_nlp_sentiment_analysis/sentiment-analysis-tf-distributed-training-bringyourownscript.html) | TensorFlow | Rete neurale convoluzionale 1D | Set di dati IMDB | Profilate una CNN TensorFlow 1-D per l'analisi del sentiment dei dati IMDB, costituita da recensioni di film etichettate come positive o negative. Esplora gli approfondimenti di Studio Debugger e il report sulla profilazione di Debugger. |
| [Profilazione del modello di allenamento con varie impostazioni di allenamento TensorFlow ResNet distribuite](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_profiling) | TensorFlow | ResNet50 | Cifar-10 | Esegui lavori di TensorFlow formazione con varie impostazioni di formazione distribuite, monitora l'utilizzo delle risorse di sistema e le prestazioni del modello di profilo utilizzando Debugger. |
| [Profilazione del PyTorch ResNet modello di allenamento con varie impostazioni di allenamento distribuite](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_profiling) | PyTorch | ResNet50 | Cifar-10 | Esegui lavori di PyTorch formazione con varie impostazioni di formazione distribuite, monitora l'utilizzo delle risorse di sistema e le prestazioni del modello di profilo utilizzando Debugger. |
## Notebook di esempio di Debugger per l’analisi dei parametri del modello
L'elenco seguente mostra alcuni notebook di esempio di Debugger che presentano l'adattabilità di Debugger per eseguire il debug dei processi di addestramento per vari modelli, set di dati e framework di machine learning.
| Titolo del notebook | Framework | Modello | Set di dati | Description |
| --- | --- | --- | --- | --- |
| [Amazon SageMaker Debugger: usa una regola integrata](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_builtin_rule) | TensorFlow | Rete neurale convoluzionale | MNIST | Utilizza le regole integrate di Amazon SageMaker Debugger per il debug di un modello. TensorFlow |
| [Amazon SageMaker Debugger - Tensorflow 2.1](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow2) | TensorFlow | ResNet50 | Cifar-10 | Utilizza la configurazione hook di Amazon SageMaker Debugger e le regole integrate per il debug di un modello con il framework Tensorflow 2.1. |
| [Visualizzazione dei tensori di debug dell'addestramento MXNet](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_plot) | MXNet | Rete neurale convoluzionale Gluon | Fashion MNIST | Esegui un processo di formazione e configura SageMaker Debugger per memorizzare tutti i tensori di questo lavoro, quindi visualizza quei tensori su un notebook. |
| [Abilita la formazione Spot con Amazon SageMaker Debugger](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_spot_training) | MXNet | Rete neurale convoluzionale Gluon | Fashion MNIST | Scopri come Debugger raccoglie i dati tensoriali da un processo di addestramento su un'istanza spot e come utilizzare le regole integrate di Debugger con l'addestramento spot gestito. |
| [Spiega un XGBoost modello che prevede il reddito di una persona con Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/xgboost_census_explanations/xgboost-census-debugger-rules.html) | XGBoost | XGBoost Regressione | [Set di dati del censimento per adulti](https://archive.ics.uci.edu/ml/datasets/adult) | Scopri come utilizzare l'hook Debugger e le regole integrate per raccogliere e visualizzare i dati tensoriali da un modello di XGBoost regressione, come valori di perdita, funzionalità e valori SHAP. |
Per trovare visualizzazioni avanzate dei parametri del modello e dei casi d'uso, consulta l'argomento successivo in [Demo e visualizzazione avanzate di Debugger](debugger-visualization.md).
# Demo e visualizzazione avanzate di Debugger
Le seguenti demo illustrano i casi d'uso avanzati e gli script di visualizzazione con Debugger.
**Topics**
+ [Modelli di addestramento e potatura con Amazon SageMaker Experiments and Debugger](#debugger-visualization-video-model-pruning)
+ [[Utilizzo di SageMaker Debugger per monitorare l'addestramento di un modello di autoencoder convoluzionale](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/autoencoder_mnist/autoencoder_mnist.html)](#debugger-visualization-autoencoder_mnist)
+ [[Utilizzo di SageMaker Debugger per monitorare le attenzioni nell'addestramento del modello BERT](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/bert_attention_head_view/bert_attention_head_view.html)](#debugger-visualization-bert_attention_head_view)
+ [[Utilizzo di SageMaker Debugger per visualizzare le mappe di attivazione delle classi nelle reti neurali convoluzionali () CNNs](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/cnn_class_activation_maps/cnn_class_activation_maps.html)](#debugger-visualization-cnn_class_activation_maps)
## Modelli di addestramento e potatura con Amazon SageMaker Experiments and Debugger
*Dr. Nathalie Rauschmayr, scienziata applicata \$1 Durata: 49 minuti 26 secondi AWS *
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/Tnv6HsT1r4I)
Scopri come Amazon SageMaker Experiments and Debugger possono semplificare la gestione dei tuoi lavori di formazione. Amazon SageMaker Debugger offre una visibilità trasparente sui lavori di formazione e salva i parametri di formazione nel tuo bucket Amazon S3. SageMaker Experiments ti consente di chiamare le informazioni sulla formazione come *versioni di prova* tramite SageMaker Studio e supporta la visualizzazione del processo di formazione. Ciò consente di mantenere alta la qualità del modello riducendo i parametri meno importanti in base al grado di importanza.
Questo video illustra una tecnica di *potatura dei modelli* che rende i modelli pre-addestrati ResNet 50 e 50 più leggeri e convenienti, mantenendo al contempo elevati standard di precisione dei AlexNet modelli.
SageMaker AI Estimator addestra gli algoritmi forniti dallo zoo del PyTorch modello in un AWS Deep Learning Containers con PyTorch framework e Debugger estrae le metriche di allenamento dal processo di addestramento.
Il video mostra anche come configurare una regola personalizzata Debugger per controllare l'accuratezza di un modello eliminato, attivare un CloudWatch evento Amazon e una AWS Lambda funzione quando la precisione raggiunge una soglia e interrompere automaticamente il processo di pruning per evitare iterazioni ridondanti.
Gli obiettivi di apprendimento sono i seguenti:
+ Scopri come utilizzare l' SageMaker intelligenza artificiale per accelerare l'addestramento dei modelli di machine learning e migliorare la qualità dei modelli.
+ Scopri come gestire le iterazioni di formazione con SageMaker Experiments acquisendo automaticamente i parametri di input, le configurazioni e i risultati.
+ Scopri come Debugger rende trasparente il processo di addestramento acquisendo automaticamente i dati del tensore in tempo reale da parametri quali pesi, gradienti e output di attivazione delle reti neurali convoluzionali.
+ Da utilizzare CloudWatch per attivare Lambda quando Debugger rileva problemi.
+ Padroneggia il processo di SageMaker formazione utilizzando Experiments e Debugger. SageMaker
[Puoi trovare i taccuini e gli script di formazione utilizzati in questo video tratto da Debugger Iterative Model Pruning. SageMaker PyTorch ](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_iterative_model_pruning)
L'immagine seguente mostra come il processo iterativo di potatura del modello riduca le dimensioni di eliminando i 100 filtri meno significativi in base al AlexNet grado di importanza valutato dagli output di attivazione e dai gradienti.
Il processo di eliminazione ha ridotto i 50 milioni di parametri iniziali a 18 milioni. Ha inoltre ridotto la dimensione stimata del modello da 201 MB a 73 MB.
![\[Un' immagine contenente visualizzazioni di output dei risultati di eliminazione del modello\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-model-pruning-results-alexnet.gif)
È inoltre necessario tenere traccia della precisione del modello e l'immagine seguente mostra come tracciare il processo di potatura del modello per visualizzare le modifiche nella precisione del modello in base al numero di parametri in Studio. SageMaker
![\[Un'immagine della visualizzazione dei tensori utilizzando Debugger in Studio SageMaker\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-model-pruning-studio.png)
**In SageMaker Studio, scegli la scheda **Esperimenti**, seleziona un elenco di tensori salvati da Debugger dal processo di potatura, quindi componi un pannello Trial Component List.** Seleziona tutte e dieci le iterazioni e scegli **Aggiungi grafico** per creare un **grafico componente di prova**. Dopo aver deciso il modello da implementare, scegli il componente di prova e scegli un menu per eseguire un'azione oppure scegli **Implementa modello**.
**Nota**
Per distribuire un modello tramite SageMaker Studio utilizzando il seguente esempio di notebook, aggiungete una riga alla fine della funzione nello script. `train` `train.py`
```
# In the train.py script, look for the train function in line 58.
def train(epochs, batch_size, learning_rate):
...
print('acc:{:.4f}'.format(correct/total))
hook.save_scalar("accuracy", correct/total, sm_metric=True)
# Add the following code to line 128 of the train.py script to save the pruned models
# under the current SageMaker Studio model directory
torch.save(model.state_dict(), os.environ['SM_MODEL_DIR'] + '/model.pt')
```
## [Utilizzo di SageMaker Debugger per monitorare l'addestramento di un modello di autoencoder convoluzionale](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/autoencoder_mnist/autoencoder_mnist.html)
Questo notebook dimostra come SageMaker Debugger visualizza i tensori di un processo di apprendimento non supervisionato (o supervisionato autonomamente) su un set di dati di immagini MNIST di numeri scritti a mano.
Il modello di formazione di questo notebook è un MXNet autoencoder convoluzionale con il framework. L'autoencoder convoluzionale ha una rete neurale convoluzionale a forma di collo di bottiglia che consiste in una parte encoder e una parte di decoder.
L'encoder in questo esempio ha due livelli di convoluzione per produrre una rappresentazione compressa (variabili latenti) delle immagini di input. In questo caso, l'encoder produce una variabile latente di dimensione (1, 20) da un'immagine di input originale di dimensioni (28, 28) e riduce significativamente la dimensione dei dati per l'addestramento di 40 volte.
Il decoder ha due livelli *deconvoluzionali* e assicura che le variabili latenti conservino le informazioni chiave ricostruendo le immagini di output.
L'encoder convoluzionale alimenta algoritmi di clustering con dimensioni ridotte dei dati di input, oltre a prestazioni di algoritmi di clustering come k-means, K-nn e T-distributed Stochastic Neighbor Embedding (T-sne).
In questo esempio di notebook viene illustrato come visualizzare le variabili latenti utilizzando Debugger, come illustrato nell'animazione seguente. Dimostra anche come l'algoritmo t-SNE classifica le variabili latenti in dieci cluster e le proietta in uno spazio bidimensionale. Lo schema di colori del grafico a dispersione sul lato destro dell'immagine riflette i valori reali per mostrare come il modello BERT e l'algoritmo T-sne organizzano le variabili latenti nei cluster.
![\[Un' immagine concettuale di autoencoder convoluzionale\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-cnn-autoencoder-plot.gif)
## [Utilizzo di SageMaker Debugger per monitorare le attenzioni nell'addestramento del modello BERT](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/bert_attention_head_view/bert_attention_head_view.html)
Le rappresentazioni di codifica bidirezionale da Transformers (BERT) è un modello di rappresentazione linguistica. Come indica il nome del modello, il modello BERT si basa sull'*apprendimento del trasferimento* e sul *modello Transformer* per Natural Language Processing (PNL).
Il modello BERT è pre-addestrato su compiti non supervisionati, come la previsione di parole mancanti in una frase o la previsione della frase successiva che naturalmente segue una frase precedente. I dati di addestramento contengono 3,3 miliardi di parole (token) di testo inglese da origini come Wikipedia e libri elettronici. Per un esempio semplice, il modello BERT può prestare molta *attenzione* ai token verbi appropriati o ai token pronome da un token soggetto.
Il modello BERT pre-addestrato può essere ottimizzato con un livello di output aggiuntivo per ottenere un addestramento del state-of-the-art modello nelle attività di PNL, come le risposte automatiche alle domande, la classificazione del testo e molte altre.
Debugger raccoglie i tensori dal processo di ottimizzazione. Nel contesto di NLP, si richiama l'*attenzione* sul peso dei neuroni.
Questo notebook dimostra come utilizzare il [modello BERT pre-addestrato dallo zoo del modello GluonNLP](https://gluon-nlp.mxnet.io/model_zoo/bert/index.html) sul set di dati Stanford Question and Answering e come configurare Debugger per monitorare il processo di formazione. SageMaker
La tracciatura dei *punteggi di attenzione* e dei singoli neuroni nella query e nei vettori chiave può aiutare a identificare le cause delle previsioni errate del modello. *Con SageMaker AI Debugger, puoi recuperare i tensori e tracciare in tempo reale la visualizzazione della testa di attenzione man mano che l'allenamento procede e capire cosa sta imparando il modello.*
L'animazione seguente mostra i punteggi di attenzione dei primi 20 token di input per dieci iterazioni nel processo di addestramento fornito nell'esempio del notebook.
![\[Un' animazione dei punteggi di attenzione\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-attention_scores.gif)
## [Utilizzo di SageMaker Debugger per visualizzare le mappe di attivazione delle classi nelle reti neurali convoluzionali () CNNs](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/model_specific_realtime_analysis/cnn_class_activation_maps/cnn_class_activation_maps.html)
Questo notebook dimostra come utilizzare SageMaker Debugger per tracciare mappe di attivazione delle classi per il rilevamento e la classificazione delle immagini nelle reti neurali convoluzionali (). CNNs Nell'apprendimento profondo, una rete neurale *convoluzionale (CNN o ConvNet) è una classe di reti neurali* profonde, più comunemente applicata all'analisi di immagini visive. Una delle applicazioni che adotta le mappe di attivazione della classe è a guida autonoma e richiede il rilevamento istantaneo e la classificazione di immagini come segnali stradali, strade e ostacoli.
In questo taccuino, il PyTorch ResNet modello viene addestrato sul [German Traffic Sign Dataset](http://benchmark.ini.rub.de/), che contiene più di 40 classi di oggetti relativi al traffico e più di 50.000 immagini in totale.
![\[Un' animazione delle mappe di attivazione della classe CNN\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-cnn-class-activation-maps.gif)
Durante il processo di addestramento, SageMaker Debugger raccoglie tensori per tracciare le mappe di attivazione della classe in tempo reale. Come mostrato nell'immagine animata, la mappa di attivazione della classe (detta anche *mappa di salienza*) evidenzia le Regioni con attivazione elevata in colore rosso.
Utilizzando i tensori catturati da Debugger, è possibile visualizzare l'evoluzione della mappa di attivazione durante l'addestramento del modello. Il modello inizia rilevando il bordo nell'angolo inferiore sinistro all'inizio del processo di addestramento. Man mano che l'addestramento progredisce, la messa a fuoco si sposta verso il centro e rileva il limite di velocità, e il modello predice con successo l'immagine di ingresso come Classe 3, che è una classe di limiti di velocità di 60 km/h, con un livello di attendibilità del 97%.
# Processi di formazione per il debug con Amazon Debugger SageMaker
Per preparare lo script di addestramento ed eseguire lavori di formazione con SageMaker Debugger per eseguire il debug dei progressi della formazione del modello, segui il tipico processo in due fasi: modifica lo script di addestramento utilizzando Python SDK e costruisci uno stimatore AI utilizzando `sagemaker-debugger` Python SDK. SageMaker SageMaker Consulta i seguenti argomenti per imparare a utilizzare la funzionalità di debug di Debugger. SageMaker
**Topics**
+ [Adattamento dello script di addestramento per registrare un hook](debugger-modify-script.md)
+ [Avvia lavori di formazione con Debugger utilizzando Python SDK SageMaker](debugger-configuration-for-debugging.md)
+ [SageMaker Report interattivo del debugger per XGBoost](debugger-report-xgboost.md)
+ [Azione sulle regole di Amazon SageMaker Debugger](debugger-action-on-rules.md)
+ [Visualizza i tensori di output di Amazon SageMaker Debugger in TensorBoard](debugger-enable-tensorboard-summaries.md)
# Adattamento dello script di addestramento per registrare un hook
[Amazon SageMaker Debugger include una libreria client chiamata Python `sagemaker-debugger` SDK.](https://sagemaker-debugger.readthedocs.io/en/website) `sagemaker-debugger` Python SDK fornisce strumenti per adattare lo script di addestramento prima dell'addestramento e strumenti di analisi dopo l'addestramento. In questa pagina, scoprirai come adattare lo script di addestramento utilizzando la libreria client.
`sagemaker-debugger` Python SDK fornisce funzioni wrapper che aiutano a registrare un hook per estrarre i tensori del modello, senza alterare lo script di addestramento. Per iniziare a raccogliere i tensori di output del modello ed eseguirne il debug per individuare problemi di addestramento, apporta le seguenti modifiche allo script di addestramento.
**Suggerimento**
Mentre segui questa pagina, utilizza la documentazione [SDK `sagemaker-debugger` open source](https://sagemaker-debugger.readthedocs.io/en/website/index.html) per i riferimenti alle API.
**Topics**
+ [PyTorch Adatta il tuo script di allenamento](debugger-modify-script-pytorch.md)
+ [Adatta il tuo script di allenamento TensorFlow](debugger-modify-script-tensorflow.md)
# PyTorch Adatta il tuo script di allenamento
Per iniziare a raccogliere i tensori di output del modello ed eseguire il debug dei problemi di addestramento, apporta le seguenti modifiche allo script di addestramento. PyTorch
**Nota**
SageMaker Il debugger non può raccogliere i tensori di output del modello dalle operazioni dell'API. [https://pytorch.org/docs/stable/nn.functional.html](https://pytorch.org/docs/stable/nn.functional.html) Quando si scrive uno script di PyTorch addestramento, si consiglia di utilizzare invece i moduli. [https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html](https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html)
## Per PyTorch 1.12.0
Se utilizzi uno script di PyTorch addestramento, puoi eseguire il processo di formazione ed estrarre i tensori di output del modello con alcune righe di codice aggiuntive nello script di addestramento. È necessario utilizzare l'[hook APIs](https://sagemaker-debugger.readthedocs.io/en/website/hook-api.html) nella libreria `sagemaker-debugger` client. Segui le seguenti istruzioni che descrivono le fasi con esempi di codice.
1. Crea un hook.
**(Consigliato) Per lavori di formazione nell'ambito dell' SageMaker IA**
```
import smdebug.pytorch as smd
hook=smd.get_hook(create_if_not_exists=True)
```
Quando avvii un processo di formazione [Avvia lavori di formazione con Debugger utilizzando Python SDK SageMaker](debugger-configuration-for-debugging.md) con una delle regole o delle DebuggerHookConfig regole del tuo estimatore, SageMaker AI aggiunge un file di configurazione JSON all'istanza di formazione che viene rilevato dalla `get_hook` funzione. TensorBoardConfig Nota che se non includi alcuna configurazione APIs nel tuo estimatore, non ci sarà alcun file di configurazione che l'hook possa trovare e la funzione verrà restituita. `None`
**(Facoltativo) Per lavori di formazione al di fuori dell'IA SageMaker **
Se esegui lavori di formazione in modalità locale, direttamente su istanze SageMaker Notebook, istanze Amazon EC2 o sui tuoi dispositivi locali, `smd.Hook` usa la classe per creare un hook. Tuttavia, questo approccio può solo memorizzare le raccolte di tensori e utilizzarlo per la visualizzazione. TensorBoard SageMaker Le regole integrate di Debugger non funzionano con la modalità locale perché le regole richiedono istanze di addestramento SageMaker AI ML e S3 per archiviare gli output delle istanze remote in tempo reale. In questo caso , l’API `smd.get_hook` restituisce `None`.
Se desideri creare un hook manuale per salvare i tensori in modalità locale, usa il seguente frammento di codice con la logica per verificare se l'API `smd.get_hook` restituisce `None` e crea un hook manuale utilizzando la classe `smd.Hook`. Tieni presente che puoi specificare qualsiasi directory di output nel tuo computer locale.
```
import smdebug.pytorch as smd
hook=smd.get_hook(create_if_not_exists=True)
if hook is None:
hook=smd.Hook(
out_dir='/path/to/your/local/output/',
export_tensorboard=True
)
```
1. Esegui il wrapping del tuo modello con i metodi di classe dell'hook.
Il metodo `hook.register_module()` prende il tuo modello e scorre attraverso ogni livello, cercando i tensori che corrispondono alle espressioni regolari che fornirai attraverso la configurazione in [Avvia lavori di formazione con Debugger utilizzando Python SDK SageMaker](debugger-configuration-for-debugging.md). I tensori raccolti tramite questo metodo hook sono pesi, bias, attivazioni, gradienti, input e output.
```
hook.register_module(model)
```
**Suggerimento**
Se raccogli tutti i tensori di output da un modello di deep learning di grandi dimensioni, la dimensione totale di tali raccolte può aumentare esponenzialmente e causare colli di bottiglia. Se desideri salvare tensori specifici, puoi anche utilizzare il metodo `hook.save_tensor()`. Questo metodo ti aiuta a scegliere la variabile per il tensore specifico e a salvarla in una raccolta personalizzata denominata come desideri. Per ulteriori informazioni, consulta la [fase 7](#debugger-modify-script-pytorch-save-custom-tensor) di queste istruzioni.
1. Esegui il wrapping della funzione di perdita con i metodi di classe dell'hook.
Il metodo `hook.register_loss` consiste nel racchiudere la funzione di perdita. Estrae i valori di perdita ogni `save_interval` che imposterai durante la configurazione in [Avvia lavori di formazione con Debugger utilizzando Python SDK SageMaker](debugger-configuration-for-debugging.md) e li salva nella raccolta `"losses"`.
```
hook.register_loss(loss_function)
```
1. Aggiungi `hook.set_mode(ModeKeys.TRAIN)` nel blocco di addestramento. Ciò indica che la raccolta dei tensori viene estratta durante la fase di addestramento.
```
def train():
...
hook.set_mode(ModeKeys.TRAIN)
```
1. Aggiungi `hook.set_mode(ModeKeys.EVAL)` nel blocco di convalida. Ciò indica che la raccolta dei tensori viene estratta durante la fase di convalida.
```
def validation():
...
hook.set_mode(ModeKeys.EVAL)
```
1. Usa [https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar](https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar) per salvare scalari personalizzati. Puoi salvare valori scalari che non sono presenti nel modello. Ad esempio, se desideri registrare i valori di precisione calcolati durante la valutazione, aggiungila seguente riga di codice sotto la riga in cui calcoli la precisione.
```
hook.save_scalar("accuracy", accuracy)
```
Si noti che è necessario fornire una stringa come primo argomento per denominare la raccolta scalare personalizzata. Questo è il nome che verrà utilizzato per visualizzare i valori scalari e può essere qualsiasi stringa tu voglia. TensorBoard
1. Usa [https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_tensor](https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_tensor) per salvare i tensori personalizzati. Analogamente a [https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar](https://sagemaker-debugger.readthedocs.io/en/website/hook-constructor.html#smdebug.core.hook.BaseHook.save_scalar), puoi salvare tensori aggiuntivi, definendo la tua raccolta di tensori. Ad esempio, puoi possibile estrarre i dati dell'immagine di input che vengono passati al modello e salvarli come tensore personalizzato aggiungendo la seguente riga di codice, dove `"images"` è riportato un nome di esempio del tensore personalizzato, `image_inputs` è una variabile di esempio per i dati dell'immagine di input.
```
hook.save_tensor("images", image_inputs)
```
Nota che devi fornire una stringa al primo argomento per denominare il tensore personalizzato. `hook.save_tensor()` ha il terzo argomento `collections_to_write` per specificare la raccolta di tensori per salvare il tensore personalizzato. Il valore predefinito è `collections_to_write="default"`. Se non specifichi esplicitamente il terzo argomento, il tensore personalizzato viene salvato nella raccolta di tensori `"default"`.
Dopo aver completato l’adattamento dello script di addestramento, procedi con [Avvia lavori di formazione con Debugger utilizzando Python SDK SageMaker](debugger-configuration-for-debugging.md).
# Adatta il tuo script di allenamento TensorFlow
Per iniziare a raccogliere i tensori di output del modello ed eseguire il debug dei problemi di addestramento, apporta le seguenti modifiche allo script di addestramento. TensorFlow
**Crea un hook per i lavori di formazione all'interno dell'IA SageMaker **
```
import smdebug.tensorflow as smd
hook=smd.get_hook(hook_type="keras", create_if_not_exists=True)
```
Questo crea un gancio quando inizi un lavoro SageMaker di formazione. Quando avvii un processo di formazione [Avvia lavori di formazione con Debugger utilizzando Python SDK SageMaker](debugger-configuration-for-debugging.md) con uno qualsiasi degli strumenti o `Rules` tramite il `DebuggerHookConfig` tuo estimatore, SageMaker AI aggiunge un file di configurazione JSON all'istanza di formazione che viene raccolto dal `smd.get_hook` metodo. `TensorBoardConfig` Nota che se non includi alcuna configurazione APIs nel tuo estimatore, non ci sarà alcun file di configurazione che l'hook possa trovare e la funzione verrà restituita. `None`
**(Facoltativo) Crea un hook per i lavori di formazione al di fuori dell'IA SageMaker **
Se esegui lavori di formazione in modalità locale, direttamente su istanze SageMaker Notebook, istanze Amazon EC2 o sui tuoi dispositivi locali, `smd.Hook` usa la classe per creare un hook. Tuttavia, questo approccio può solo memorizzare le raccolte di tensori e utilizzarlo per la visualizzazione. TensorBoard SageMaker Le regole integrate di Debugger non funzionano con la modalità locale. Il metodo `smd.get_hook` restituisce `None` anche in questo caso.
Se desideri creare un hook manuale, usa il seguente frammento di codice con la logica per verificare se l'hook restituisce `None` restituisce e crea un hook manuale utilizzando la classe `smd.Hook`.
```
import smdebug.tensorflow as smd
hook=smd.get_hook(hook_type="keras", create_if_not_exists=True)
if hook is None:
hook=smd.KerasHook(
out_dir='/path/to/your/local/output/',
export_tensorboard=True
)
```
Dopo aver aggiunto il codice di creazione dell'hook, passa al seguente argomento per Keras. TensorFlow
**Nota**
SageMaker Debugger attualmente supporta solo Keras. TensorFlow
## Registra l'hook nello script di addestramento Keras TensorFlow
La seguente procedura illustra come utilizzare l'hook e i suoi metodi per raccogliere scalari e tensori di output dal modello e dall'ottimizzatore.
1. Esegui il wrapping del tuo modello e ottimizzatore Keras con i metodi di classe dell'hook.
Il metodo `hook.register_model()` prende il tuo modello e scorre attraverso ogni livello, cercando i tensori che corrispondono alle espressioni regolari che fornirai attraverso la configurazione in [Avvia lavori di formazione con Debugger utilizzando Python SDK SageMaker](debugger-configuration-for-debugging.md). I tensori raccolti tramite questo metodo hook sono pesi, bias e attivazioni.
```
model=tf.keras.Model(...)
hook.register_model(model)
```
1. Esegui il wrapping dell'ottimizzatore secondo il metodo `hook.wrap_optimizer()`.
```
optimizer=tf.keras.optimizers.Adam(...)
optimizer=hook.wrap_optimizer(optimizer)
```
1. Compila il modello in modalità eager in. TensorFlow
Per raccogliere tensori dal modello, come i tensori di input e output di ogni livello, è necessario eseguire l'addestramento in modalità eager. Altrimenti, SageMaker AI Debugger non sarà in grado di raccogliere i tensori. Tuttavia, altri tensori, come i pesi dei modelli, i bias e la perdita, possono essere raccolti senza che vengano eseguiti esplicitamente in modalità eager.
```
model.compile(
loss="categorical_crossentropy",
optimizer=optimizer,
metrics=["accuracy"],
# Required for collecting tensors of each layer
run_eagerly=True
)
```
1. Registra l'hook nel metodo [https://www.tensorflow.org/api_docs/python/tf/keras/Model#fit](https://www.tensorflow.org/api_docs/python/tf/keras/Model#fit).
Per raccogliere i tensori dagli hook che hai registrato, aggiungi `callbacks=[hook]` al metodo della classe `model.fit()` Keras. Questo passerà l'hook `sagemaker-debugger` come callback Keras.
```
model.fit(
X_train, Y_train,
batch_size=batch_size,
epochs=epoch,
validation_data=(X_valid, Y_valid),
shuffle=True,
callbacks=[hook]
)
```
1. TensorFlow 2.x fornisce solo variabili gradienti simboliche che non forniscono l'accesso ai loro valori. Per raccogliere i gradienti, esegui il wrapping di `tf.GradientTape` secondo il metodo [https://sagemaker-debugger.readthedocs.io/en/website/hook-methods.html#tensorflow-specific-hook-api](https://sagemaker-debugger.readthedocs.io/en/website/hook-methods.html#tensorflow-specific-hook-api), che richiede di scrivere la tua fase di addestramento come segue.
```
def training_step(model, dataset):
with hook.wrap_tape(tf.GradientTape()) as tape:
pred=model(data)
loss_value=loss_fn(labels, pred)
grads=tape.gradient(loss_value, model.trainable_variables)
optimizer.apply_gradients(zip(grads, model.trainable_variables))
```
Eseguendo il wrapping del nastro, l’hook `sagemaker-debugger` è in grado di identificare tensori di uscita come gradienti, parametri e perdite. L'avvolgimento del nastro assicura che il `hook.wrap_tape()` metodo basato sulle funzioni dell'oggetto tape, ad esempio,, configuri gli autori di SageMaker Debugger e salvi i tensori forniti come input (variabili addestrabili e perdita) e output di `gradient()` (gradienti). `push_tape()` `pop_tape()` `gradient()` `gradient()`
**Nota**
Per raccogliere con un ciclo di addestramento personalizzato, assicurati di utilizzare la modalità eager. Altrimenti, Debugger non è in grado di raccogliere alcun SageMaker tensore.
*Per un elenco completo delle azioni APIs offerte dall'`sagemaker-debugger`hook per costruire hook e salvare tensori, consulta [Hook Methods nella](https://sagemaker-debugger.readthedocs.io/en/website/hook-methods.html) documentazione di Python `sagemaker-debugger` SDK.*
Dopo aver completato l'adattamento dello script di addestramento, procedi con [Avvia lavori di formazione con Debugger utilizzando Python SDK SageMaker](debugger-configuration-for-debugging.md).
# Avvia lavori di formazione con Debugger utilizzando Python SDK SageMaker
Per configurare uno stimatore SageMaker AI con SageMaker Debugger, usa Amazon [ SageMaker Python](https://sagemaker.readthedocs.io/en/stable) SDK e specifica i parametri specifici del Debugger. Per utilizzare appieno la funzionalità di debug, devi configurare tre parametri: `debugger_hook_config`, `tensorboard_output_config` e `rules`.
**Importante**
Prima di creare ed eseguire il metodo di adattamento dello strumento di valutazione per avviare un processo di addestramento, assicurati di adattare lo script di addestramento seguendo le istruzioni riportate in [Adattamento dello script di addestramento per registrare un hook](debugger-modify-script.md).
## Creazione di SageMaker uno stimatore AI con parametri specifici del debugger
Gli esempi di codice in questa sezione mostrano come costruire uno stimatore AI con i parametri specifici del Debugger. SageMaker
**Nota**
I seguenti esempi di codice sono modelli per la costruzione degli stimatori del framework AI e non sono direttamente eseguibili SageMaker . È necessario passare alle sezioni successive e configurare i parametri specifici di Debugger.
------
#### [ PyTorch ]
```
# An example of constructing a SageMaker AI PyTorch estimator
import boto3
import sagemaker
from sagemaker.pytorch import PyTorch
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
session=boto3.session.Session()
region=session.region_name
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
estimator=PyTorch(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.12.0",
py_version="py37",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ TensorFlow ]
```
# An example of constructing a SageMaker AI TensorFlow estimator
import boto3
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
session=boto3.session.Session()
region=session.region_name
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule()),
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=TensorFlow(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ MXNet ]
```
# An example of constructing a SageMaker AI MXNet estimator
import sagemaker
from sagemaker.mxnet import MXNet
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
estimator=MXNet(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.7.0",
py_version="py37",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ XGBoost ]
```
# An example of constructing a SageMaker AI XGBoost estimator
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
estimator=XGBoost(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.5-1",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
#### [ Generic estimator ]
```
# An example of constructing a SageMaker AI generic estimator using the XGBoost algorithm base image
import boto3
import sagemaker
from sagemaker.estimator import Estimator
from sagemaker import image_uris
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig, Rule, rule_configs
debugger_hook_config=DebuggerHookConfig(...)
rules=[
Rule.sagemaker(rule_configs.built_in_rule())
]
region=boto3.Session().region_name
xgboost_container=sagemaker.image_uris.retrieve("xgboost", region, "1.5-1")
estimator=Estimator(
role=sagemaker.get_execution_role()
image_uri=xgboost_container,
base_job_name="debugger-demo",
instance_count=1,
instance_type="ml.m5.2xlarge",
# Debugger-specific parameters
debugger_hook_config=debugger_hook_config,
rules=rules
)
estimator.fit(wait=False)
```
------
Configura i seguenti parametri per attivare SageMaker Debugger:
+ `debugger_hook_config`(un oggetto di [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)): necessario per attivare l'hook nello script di addestramento adattato durante[Adattamento dello script di addestramento per registrare un hook](debugger-modify-script.md), configurare il SageMaker training launcher (estimatore) per raccogliere i tensori di output dal processo di addestramento e salvare i tensori nel bucket S3 protetto o nel computer locale. Per informazioni su come configurare il parametro `debugger_hook_config`, consulta [Configurazione SageMaker di Debugger per salvare i tensori](debugger-configure-hook.md).
+ `rules`(un elenco di [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule)oggetti): configura questo parametro per attivare le regole integrate del SageMaker Debugger che desideri eseguire in tempo reale. Le regole integrate sono logiche che eseguono automaticamente il debug del progresso di addestramento del modello e individuano i problemi di addestramento analizzando i tensori di output salvati nel bucket S3 protetto. Per informazioni su come configurare il parametro `rules`, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md). Per trovare un elenco completo delle regole integrate per il debug dei tensori di output, consulta [Regola Debugger](debugger-built-in-rules.md#debugger-built-in-rules-Rule). Se desideri creare una logica personalizzata per rilevare eventuali problemi di addestramento, consulta [Creazione di regole personalizzate utilizzando la libreria client di Debugger](debugger-custom-rules.md).
**Nota**
Le regole integrate sono disponibili solo tramite SageMaker istanze di formazione. Non è possibile utilizzarle in modalità locale.
+ `tensorboard_output_config`(un oggetto di [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.TensorBoardOutputConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.TensorBoardOutputConfig)) — Configura SageMaker Debugger per raccogliere i tensori di output nel formato TensorBoard compatibile con -e salvarli nel percorso di output S3 specificato nell'oggetto. `TensorBoardOutputConfig` Per ulteriori informazioni, consulta [Visualizza i tensori di output di Amazon SageMaker Debugger in TensorBoard](debugger-enable-tensorboard-summaries.md).
**Nota**
`tensorboard_output_config` deve essere configurato con il parametro `debugger_hook_config`, che richiede anche di adattare lo script di addestramento aggiungendo l'hook `sagemaker-debugger`.
**Nota**
SageMaker Debugger salva in modo sicuro i tensori di output nelle sottocartelle del bucket S3. Ad esempio, il formato dell'URI del bucket S3 predefinito nel tuo account è `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>///`. Esistono due sottocartelle create da Debugger:, e. SageMaker `debug-output` `rule-output` Se aggiungi il parametro `tensorboard_output_config`, troverai anche la cartella `tensorboard-output`.
Consulta i seguenti argomenti per scoprire altri esempi su come configurare in dettaglio i parametri specifici di Debugger.
**Topics**
+ [Creazione di SageMaker uno stimatore AI con parametri specifici del debugger](#debugger-configuration-structure)
+ [Configurazione SageMaker di Debugger per salvare i tensori](debugger-configure-hook.md)
+ [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md)
+ [Disattivazione di Debugger](debugger-turn-off.md)
+ [Metodi utili della classe di stima AI per Debugger SageMaker](debugger-estimator-classmethods.md)
# Configurazione SageMaker di Debugger per salvare i tensori
I *tensori* sono raccolte di dati di parametri aggiornati dal passaggio successivo e successivo di ogni iterazione di allenamento. SageMaker Debugger raccoglie i tensori di output per analizzare lo stato di un processo di formazione. SageMaker *Le operazioni di Debugger [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)e [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)API forniscono metodi per raggruppare i tensori in raccolte e salvarli in un bucket S3 di destinazione.* Gli argomenti seguenti mostrano come utilizzare le operazioni API `CollectionConfig` e `DebuggerHookConfig` e forniscono esempi su come utilizzare l’hook Debugger per salvare, accedere e visualizzare i tensori di output.
Durante la creazione di uno stimatore SageMaker AI, attiva Debugger specificando il parametro. SageMaker `debugger_hook_config` Le fasi seguenti includono esempi di come configurare `debugger_hook_config` utilizzando le operazioni API `CollectionConfig` e `DebuggerHookConfig` per estrarre i tensori dai job di addestramento e salvarli.
**Nota**
Dopo aver configurato e attivato correttamente, SageMaker Debugger salva i tensori di output in un bucket S3 predefinito, se non diversamente specificato. Il formato dell'URI del bucket S3 predefinito è `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>//debug-output/`.
**Topics**
+ [Configurazione delle raccolte di tensori con l’API `CollectionConfig`](debugger-configure-tensor-collections.md)
+ [Configurazione dell’API `DebuggerHookConfig` per il salvataggio dei tensori](debugger-configure-tensor-hook.md)
+ [Notebook di esempio ed esempi di codice per configurare l’hook Debugger](debugger-save-tensors.md)
# Configurazione delle raccolte di tensori con l’API `CollectionConfig`
Usa l'operazione API `CollectionConfig` per configurare le raccolte di tensori. Debugger fornisce raccolte di tensori predefinite che coprono una varietà di espressioni regolari (regex) di parametri se si utilizzano framework di deep learning e algoritmi di machine learning supportati da Debugger. Come mostrato nel codice di esempio seguente, aggiungi le raccolte di tensori integrate di cui desideri eseguire il debug.
```
from sagemaker.debugger import CollectionConfig
collection_configs=[
CollectionConfig(name="weights"),
CollectionConfig(name="gradients")
]
```
Le raccolte precedenti impostano l'hook Debugger per salvare i tensori ogni 500 fasi in base al valore predefinito `"save_interval"`.
Per un elenco completo delle raccolte integrate di Debugger disponibili, consulta [Raccolte integrate di Debugger](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#collection).
Se desideri personalizzare le raccolte integrate, ad esempio modificando gli intervalli di salvataggio e l'espressione regolare dei tensori, usa il seguente modello `CollectionConfig` per regolare i parametri.
```
from sagemaker.debugger import CollectionConfig
collection_configs=[
CollectionConfig(
name="tensor_collection",
parameters={
"key_1": "value_1",
"key_2": "value_2",
...
"key_n": "value_n"
}
)
]
```
Per ulteriori informazioni sulle chiavi dei parametri disponibili, [CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)consulta [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) SDK. Ad esempio, il seguente esempio di codice mostra come regolare gli intervalli di salvataggio della raccolta dei tensori “perdite” nelle diverse fasi dell'addestramento: salva la perdita ogni 100 fasi nella fase di addestramento e la perdita di convalida ogni 10 fasi nella fase di convalida.
```
from sagemaker.debugger import CollectionConfig
collection_configs=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
}
)
]
```
**Suggerimento**
[Questo oggetto di configurazione della collezione di tensori può essere utilizzato sia per le operazioni dell'API che per [DebuggerHookConfig](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configure-hook.html#debugger-configure-tensor-hook)le regole.](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-rules.html#debugger-built-in-rules-configuration-param-change)
# Configurazione dell’API `DebuggerHookConfig` per il salvataggio dei tensori
Utilizza l'[DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html #sagemaker.debugger.DebuggerHookConfig)API per creare un `debugger_hook_config` oggetto utilizzando l'`collection_configs`oggetto creato nel passaggio precedente.
```
from sagemaker.debugger import DebuggerHookConfig
debugger_hook_config=DebuggerHookConfig(
collection_configs=collection_configs
)
```
Debugger salva i tensori di output di addestramento del modello nel bucket S3 predefinito. Il formato dell'URI del bucket S3 predefinito è `s3://amzn-s3-demo-bucket-sagemaker--<12digit_account_id>//debug-output/.`
Se desideri specificare un URI esatto del bucket S3, usa il seguente esempio di codice:
```
from sagemaker.debugger import DebuggerHookConfig
debugger_hook_config=DebuggerHookConfig(
s3_output_path="specify-uri"
collection_configs=collection_configs
)
```
Per ulteriori informazioni, [DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)consulta [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) SDK.
# Notebook di esempio ed esempi di codice per configurare l’hook Debugger
Le sezioni seguenti forniscono notebook ed esempi di codice su come utilizzare l’hook Debugger per salvare, accedere e visualizzare i tensori di output.
**Topics**
+ [Notebook di esempio per la visualizzazione dei tensori](#debugger-tensor-visualization-notebooks)
+ [Salvare i tensori utilizzando le raccolte integrate di Debugger](#debugger-save-built-in-collections)
+ [Salvare i tensori modificando le raccolte integrate di Debugger](#debugger-save-modified-built-in-collections)
+ [Salvare i tensori utilizzando le raccolte personalizzate di Debugger](#debugger-save-custom-collections)
## Notebook di esempio per la visualizzazione dei tensori
I seguenti due esempi di notebook mostrano l'uso avanzato di Amazon SageMaker Debugger per la visualizzazione dei tensori. Debugger offre una visione trasparente dell'addestramento dei modelli di deep learning.
+ [Analisi interattiva dei tensori in Studio Notebook con SageMaker MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_analysis)
Questo esempio di notebook mostra come visualizzare i tensori salvati utilizzando Amazon Debugger. SageMaker Visualizzando i tensori, è possibile vedere come cambiano i valori del tensore durante l'addestramento degli algoritmi di deep learning. Questo notebook include un corso di formazione con una rete neurale mal configurata e utilizza Amazon SageMaker Debugger per aggregare e analizzare tensori, inclusi gradienti, output di attivazione e pesi. Ad esempio, il grafico seguente mostra la distribuzione dei gradienti di un livello convoluzionale che soffre di un problema di gradiente di fuga.
![\[Un grafico che traccia la distribuzione dei gradienti.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-vanishing-gradient.gif)
questo notebook illustra anche come una buona impostazione iniziale dell'iperparametro migliora il processo di addestramento generando gli stessi grafici di distribuzione del tensore.
+ [Visualizzazione e debug dei tensori da Model Training MXNet ](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mnist_tensor_plot)
Questo esempio di notebook mostra come salvare e visualizzare i tensori da un processo di formazione MXNet sul modello Gluon utilizzando Amazon Debugger. SageMaker Illustra che Debugger è impostato per salvare tutti i tensori in un bucket Amazon S3 e recupera gli output di attivazione per la visualizzazione. ReLu La figura seguente mostra una visualizzazione tridimensionale degli output di attivazione. ReLu La combinazione di colori è impostata affinché il blu indichi un valore vicino a 0 e il giallo dei valori vicini a 1.
![\[Visualizzazione degli output di attivazione ReLU\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/tensorplot.gif)
In questo notebook, la `TensorPlot` classe importata da `tensor_plot.py` è progettata per tracciare reti neurali convoluzionali (CNNs) che utilizzano immagini bidimensionali come input. Lo script `tensor_plot.py` fornito con il notebook recupera i tensori utilizzando Debugger e visualizza la CNN. È possibile eseguire questo notebook su SageMaker Studio per riprodurre la visualizzazione del tensore e implementare il proprio modello di rete neurale convoluzionale.
+ [Analisi tensoriale in tempo reale in un notebook con SageMaker MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_realtime_analysis)
Questo esempio ti guida nell'installazione dei componenti necessari per l'emissione di tensori in un processo di SageMaker formazione di Amazon e nell'utilizzo delle operazioni dell'API Debugger per accedere a tali tensori durante l'esecuzione della formazione. Un modello CNN gluon viene addestrato sul set di dati Fashion MNIST. Mentre il processo è in esecuzione, vedrai come Debugger recupera gli output di attivazione del primo livello convoluzionale da ciascuno dei 100 batch e li visualizza. Inoltre, questo ti mostrerà come visualizzare i pesi una volta completato il processo.
## Salvare i tensori utilizzando le raccolte integrate di Debugger
Puoi utilizzare raccolte integrate di tensori utilizzando l'API `CollectionConfig` e salvarle utilizzando l'API `DebuggerHookConfig`. L'esempio seguente mostra come utilizzare le impostazioni predefinite delle configurazioni degli hook di Debugger per costruire uno stimatore AI. SageMaker TensorFlow Puoi utilizzarlo anche per, e estimatori. MXNet PyTorch XGBoost
**Nota**
Nel seguente codice di esempio, il parametro `s3_output_path` per `DebuggerHookConfig` è facoltativo. Se non lo specificate, Debugger salva i tensori in`s3:///debug-output/`, dove `` è il percorso di output predefinito dei lavori di formazione. SageMaker Esempio:
```
"s3://sagemaker-us-east-1-111122223333/sagemaker-debugger-training-YYYY-MM-DD-HH-MM-SS-123/debug-output"
```
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import DebuggerHookConfig, CollectionConfig
# use Debugger CollectionConfig to call built-in collections
collection_configs=[
CollectionConfig(name="weights"),
CollectionConfig(name="gradients"),
CollectionConfig(name="losses"),
CollectionConfig(name="biases")
]
# configure Debugger hook
# set a target S3 bucket as you want
sagemaker_session=sagemaker.Session()
BUCKET_NAME=sagemaker_session.default_bucket()
LOCATION_IN_BUCKET='debugger-built-in-collections-hook'
hook_config=DebuggerHookConfig(
s3_output_path='s3://{BUCKET_NAME}/{LOCATION_IN_BUCKET}'.
format(BUCKET_NAME=BUCKET_NAME,
LOCATION_IN_BUCKET=LOCATION_IN_BUCKET),
collection_configs=collection_configs
)
# construct a SageMaker TensorFlow estimator
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-demo-job',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific hook argument below
debugger_hook_config=hook_config
)
sagemaker_estimator.fit()
```
Per visualizzare un elenco delle raccolte integrate di Debugger, consulta [Raccolte integrate di Debugger](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#collection).
## Salvare i tensori modificando le raccolte integrate di Debugger
È possibile modificare le raccolte integrate di Debugger utilizzando l'operazione API `CollectionConfig`. L'esempio seguente mostra come modificare la `losses` raccolta integrata e costruire uno stimatore AI. SageMaker TensorFlow Puoi anche usarlo per MXNet, PyTorch e stimatori. XGBoost
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import DebuggerHookConfig, CollectionConfig
# use Debugger CollectionConfig to call and modify built-in collections
collection_configs=[
CollectionConfig(
name="losses",
parameters={"save_interval": "50"})]
# configure Debugger hook
# set a target S3 bucket as you want
sagemaker_session=sagemaker.Session()
BUCKET_NAME=sagemaker_session.default_bucket()
LOCATION_IN_BUCKET='debugger-modified-collections-hook'
hook_config=DebuggerHookConfig(
s3_output_path='s3://{BUCKET_NAME}/{LOCATION_IN_BUCKET}'.
format(BUCKET_NAME=BUCKET_NAME,
LOCATION_IN_BUCKET=LOCATION_IN_BUCKET),
collection_configs=collection_configs
)
# construct a SageMaker TensorFlow estimator
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-demo-job',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific hook argument below
debugger_hook_config=hook_config
)
sagemaker_estimator.fit()
```
Per un elenco completo dei `CollectionConfig` parametri, consulta [ CollectionConfig Debugger](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk) API.
## Salvare i tensori utilizzando le raccolte personalizzate di Debugger
È inoltre possibile scegliere di salvare una quantità ridotta di tensori anziché i tensori completi, ad esempio, se si desidera ridurre la quantità di dati salvati nel bucket Amazon S3. Nell'esempio seguente viene illustrato come personalizzare la configurazione dell'hook di Debugger per specificare i tensori di destinazione che si desidera salvare. Puoi usarlo per TensorFlow, MXNet, e stimatori PyTorch. XGBoost
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import DebuggerHookConfig, CollectionConfig
# use Debugger CollectionConfig to create a custom collection
collection_configs=[
CollectionConfig(
name="custom_activations_collection",
parameters={
"include_regex": "relu|tanh", # Required
"reductions": "mean,variance,max,abs_mean,abs_variance,abs_max"
})
]
# configure Debugger hook
# set a target S3 bucket as you want
sagemaker_session=sagemaker.Session()
BUCKET_NAME=sagemaker_session.default_bucket()
LOCATION_IN_BUCKET='debugger-custom-collections-hook'
hook_config=DebuggerHookConfig(
s3_output_path='s3://{BUCKET_NAME}/{LOCATION_IN_BUCKET}'.
format(BUCKET_NAME=BUCKET_NAME,
LOCATION_IN_BUCKET=LOCATION_IN_BUCKET),
collection_configs=collection_configs
)
# construct a SageMaker TensorFlow estimator
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-demo-job',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific hook argument below
debugger_hook_config=hook_config
)
sagemaker_estimator.fit()
```
Per un elenco completo dei `CollectionConfig` parametri, consulta [ CollectionConfigDebugger](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk).
# Come configurare le regole integrate di Debugger
Nei seguenti argomenti, imparerai a usare le regole integrate del SageMaker Debugger. Le regole integrate di Amazon SageMaker Debugger analizzano i tensori emessi durante l'addestramento di un modello. SageMaker AI Debugger offre il funzionamento dell'`Rule`API che monitora l'avanzamento dei lavori di formazione e gli errori per il successo dell'addestramento del modello. Ad esempio, le regole possono rilevare se i gradienti stanno diventando troppo grandi o troppo piccoli, se un modello è troppo adatto o sovraddestrato e se un processo di addestramento non riduce la funzione di perdita e migliora. Per visualizzare l'elenco completo delle regole integrate disponibili, consulta [Elenco delle regole integrate di Debugger](debugger-built-in-rules.md).
**Topics**
+ [Utilizzare le regole integrate di Debugger con le impostazioni dei parametri predefinite](debugger-built-in-rules-configuration.md)
+ [Utilizzare le regole integrate di Debugger con valori di parametro personalizzati](debugger-built-in-rules-configuration-param-change.md)
+ [Notebook di esempio ed esempi di codice per configurare le regole di Debugger](debugger-built-in-rules-example.md)
# Utilizzare le regole integrate di Debugger con le impostazioni dei parametri predefinite
Per specificare le regole integrate di Debugger in uno strumento di valutazione, è necessario configurare un oggetto elenco. Il codice di esempio seguente mostra la struttura di base dell'elenco delle regole integrate di Debugger:
```
from sagemaker.debugger import Rule, rule_configs
rules=[
Rule.sagemaker(rule_configs.built_in_rule_name_1()),
Rule.sagemaker(rule_configs.built_in_rule_name_2()),
...
Rule.sagemaker(rule_configs.built_in_rule_name_n()),
... # You can also append more profiler rules in the ProfilerRule.sagemaker(rule_configs.*()) format.
]
```
Per ulteriori informazioni sui valori dei parametri predefiniti e sulle descrizioni della regola integrata, consulta [Elenco delle regole integrate di Debugger](debugger-built-in-rules.md).
Per trovare il riferimento all'API SageMaker Debugger, consulta e. [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.sagemaker.debugger.rule_configs](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.sagemaker.debugger.rule_configs)
Ad esempio, per esaminare le prestazioni di formazione complessive e il progresso del modello, costruisci uno stimatore di SageMaker intelligenza artificiale con la seguente configurazione di regole integrata.
```
from sagemaker.debugger import Rule, rule_configs
rules=[
Rule.sagemaker(rule_configs.loss_not_decreasing()),
Rule.sagemaker(rule_configs.overfit()),
Rule.sagemaker(rule_configs.overtraining()),
Rule.sagemaker(rule_configs.stalled_training_rule())
]
```
Quando si avvia il processo di addestramento, Debugger raccoglie i dati sull'utilizzo delle risorse di sistema ogni 500 millisecondi e i valori di perdita e precisione ogni 500 passaggi per impostazione predefinita. Debugger analizza l'utilizzo delle risorse per identificare se il modello presenta problemi di collo di bottiglia. Il `loss_not_decreasing`, `overfit`, `overtraining` e `stalled_training_rule` monitora se il modello sta ottimizzando la funzione di perdita senza questi problemi di addestramento. Se le regole rilevano anomalie di addestramento, lo stato di valutazione della regola cambia in `IssueFound`. Puoi configurare azioni automatizzate, come la notifica dei problemi di formazione e l'interruzione dei lavori di formazione utilizzando Amazon CloudWatch Events e. AWS Lambda Per ulteriori informazioni, consulta [Azione sulle regole di Amazon SageMaker Debugger](debugger-action-on-rules.md).
# Utilizzare le regole integrate di Debugger con valori di parametro personalizzati
Se desideri modificare i valori dei parametri delle regole integrate e personalizzare l'espressione regolare della raccolta di tensori, configura i parametri `base_config` e `rule_parameters` per i metodi di classe `ProfilerRule.sagemaker` e `Rule.sagemaker`. Nel caso dei metodi di classe `Rule.sagemaker`, puoi anche personalizzare le raccolte di tensori tramite il parametro. `collections_to_save` Le istruzioni su come usare la classe `CollectionConfig` sono fornite in [Configurazione delle raccolte di tensori con l’API `CollectionConfig`](debugger-configure-tensor-collections.md).
Utilizza il seguente modello di configurazione per le regole integrate per personalizzare i valori dei parametri. Modificando i parametri delle regole come si desidera, è possibile regolare la sensibilità delle regole da attivare.
+ L'argomento `base_config` è il punto in cui si chiamano i metodi delle regole integrate.
+ L'argomento `rule_parameters` consiste nel modificare i valori chiave predefiniti delle regole integrate elencate in [Elenco delle regole integrate di Debugger](debugger-built-in-rules.md).
+ L'argomento `collections_to_save` accetta una configurazione tensoriale tramite l'API `CollectionConfig`, che richiede gli argomenti `name` e `parameters`.
+ Per trovare le raccolte di tensori disponibili per `name`, consulta [ Raccolte di tensori predefiniti di Debugger](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections).
+ Per un elenco completo delle opzioni regolabili`parameters`, consulta [ CollectionConfig Debugger](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#configuring-collection-using-sagemaker-python-sdk) API.
[Per ulteriori informazioni sulla classe di regole, i metodi e i parametri Debugger, consulta la classe [SageMaker AI Debugger Rule nell'](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html)SDK Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs, CollectionConfig
rules=[
Rule.sagemaker(
base_config=rule_configs.built_in_rule_name(),
rule_parameters={
"key": "value"
},
collections_to_save=[
CollectionConfig(
name="tensor_collection_name",
parameters={
"key": "value"
}
)
]
)
]
```
Le descrizioni dei parametri e gli esempi di personalizzazione dei valori sono disponibili per ogni regola in [Elenco delle regole integrate di Debugger](debugger-built-in-rules.md).
# Notebook di esempio ed esempi di codice per configurare le regole di Debugger
Nelle sezioni seguenti vengono forniti notebook ed esempi di codice su come utilizzare le regole Debugger per monitorare i lavori di formazione. SageMaker
**Topics**
+ [Notebook di esempio con regole integrate di Debugger](#debugger-built-in-rules-notebook-example)
+ [Codice di esempio con regole integrate di Debugger](#debugger-deploy-built-in-rules)
+ [Utilizzare le regole integrate di Debugger con le modifiche dei parametri](#debugger-deploy-modified-built-in-rules)
## Notebook di esempio con regole integrate di Debugger
I seguenti notebook di esempio mostrano come utilizzare le regole integrate di Debugger durante l'esecuzione di lavori di formazione con Amazon AI: SageMaker
+ [Utilizzo di una regola integrata di Debugger con SageMaker TensorFlow](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_builtin_rule)
+ [Utilizzo di una regola integrata nel SageMaker Debugger con Managed Spot Training e MXNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/mxnet_spot_training)
+ [Utilizzo di una regola integrata del SageMaker Debugger con modifiche ai parametri per un'analisi del lavoro di formazione in tempo reale con XGBoost](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/xgboost_realtime_analysis)
**Durante l'esecuzione dei notebook di esempio in SageMaker Studio, puoi trovare la versione di prova del lavoro di formazione creata nella scheda Studio Experiment List.** Ad esempio, come mostrato nella schermata seguente, è possibile trovare e aprire una finestra **Descrivi componente di prova** relativa al processo di addestramento corrente. Nella scheda Debugger, puoi verificare se le regole di Debugger `vanishing_gradient()` e `loss_not_decreasing()`, stanno monitorando la sessione di addestramento in parallelo. Per istruzioni complete su come trovare i componenti di prova del lavoro di formazione nell'interfaccia utente di Studio, consulta [SageMaker Studio - View Experiments, Trials and](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-tasks.html#studio-tasks-experiments) Trial Components.
![\[Un'immagine dell'esecuzione di un processo di formazione con le regole integrate di Debugger attivate in Studio SageMaker\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-built-in-rule-studio.png)
Esistono due modi per utilizzare le regole integrate di Debugger nell'ambiente di SageMaker intelligenza artificiale: distribuire le regole integrate man mano che vengono preparate o modificarne i parametri come si desidera. I seguenti argomenti mostrano come utilizzare le regole integrate con codici di esempio.
## Codice di esempio con regole integrate di Debugger
Nell'esempio di codice riportato di seguito viene illustrato come impostare le regole integrate di Debugger utilizzando il metodo `Rule.sagemaker`. Per specificare le regole integrate da eseguire, utilizza l'operazione API `rules_configs` per richiamare le regole integrate. Per un elenco completo delle regole integrate di Debugger e dei valori dei parametri predefiniti, consulta [Elenco delle regole integrate di Debugger](debugger-built-in-rules.md).
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import Rule, CollectionConfig, rule_configs
# call built-in rules that you want to use.
built_in_rules=[
Rule.sagemaker(rule_configs.vanishing_gradient())
Rule.sagemaker(rule_configs.loss_not_decreasing())
]
# construct a SageMaker AI estimator with the Debugger built-in rules
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name='debugger-built-in-rules-demo',
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific arguments below
rules=built_in_rules
)
sagemaker_estimator.fit()
```
**Nota**
Le regole integrate di Debugger vengono eseguite in parallelo al processo di addestramento. Il numero massimo di container di regole integrate per un processo di addestramento è 20.
[Per ulteriori informazioni sulla classe di regole, i metodi e i parametri Debugger, consulta la classe [SageMaker Debugger Rule nell'](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html)SDK Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
Per trovare un esempio di come modificare i parametri della regola di Debugger, consulta la sezione seguente [Utilizzare le regole integrate di Debugger con le modifiche dei parametri](#debugger-deploy-modified-built-in-rules).
## Utilizzare le regole integrate di Debugger con le modifiche dei parametri
Il seguente esempio di codice mostra la struttura delle regole integrate per regolare i parametri. In questo esempio, `stalled_training_rule` raccoglie la raccolta di tensori `losses` da un processo di addestramento ogni 50 fasi e una fase di valutazione ogni 10 fasi. Se il processo di addestramento inizia a bloccarsi e non raccoglie i risultati del tensore per 120 secondi, `stalled_training_rule` interrompe il processo di addestramento.
```
import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import Rule, CollectionConfig, rule_configs
# call the built-in rules and modify the CollectionConfig parameters
base_job_name_prefix= 'smdebug-stalled-demo-' + str(int(time.time()))
built_in_rules_modified=[
Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
'threshold': '120',
'training_job_name_prefix': base_job_name_prefix,
'stop_training_on_fire' : 'True'
}
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "50"
"eval.save_interval": "10"
}
)
]
)
]
# construct a SageMaker AI estimator with the modified Debugger built-in rule
sagemaker_estimator=TensorFlow(
entry_point='directory/to/your_training_script.py',
role=sm.get_execution_role(),
base_job_name=base_job_name_prefix,
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.9.0",
py_version="py39",
# debugger-specific arguments below
rules=built_in_rules_modified
)
sagemaker_estimator.fit()
```
Per una configurazione avanzata delle regole integrate di Debugger che utilizzano l'API `CreateTrainingJob`, consulta [Configurazione del debugger tramite l'API SageMaker](debugger-createtrainingjob-api.md).
# Disattivazione di Debugger
Se desideri disattivare completamente Debugger, esegui una delle seguenti operazioni:
+ Prima di iniziare un processo di addestramento, procedi come segue:
Per interrompere il monitoraggio e la profilazione, includi il parametro `disable_profiler` nello strumento di valutazione e impostalo su `True`.
**avvertimento**
Se lo disabiliti, non sarai in grado di visualizzare la dashboard completa di Studio Debugger Insights e il rapporto di profilazione generato automaticamente.
Per interrompere il debug, imposta il parametro `debugger_hook_config` su `False`.
**avvertimento**
Se lo disabiliti, non sarai in grado di raccogliere tensori di output e non sarai in grado di eseguire il debug dei parametri del modello.
```
estimator=Estimator(
...
disable_profiler=True
debugger_hook_config=False
)
```
[Per ulteriori informazioni sui parametri specifici del Debugger, consulta AI [SageMaker Estimator nell'](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator)SDK Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
+ Durante l'esecuzione di un processo di addestramento, esegui queste attività:
Per disabilitare sia il monitoraggio che la profilazione mentre il processo di addestramento è in esecuzione, utilizza il seguente metodo della classe dello strumento di valutazione:
```
estimator.disable_profiling()
```
Per disabilitare solo la profilazione del framework e mantenere il monitoraggio del sistema, utilizzate il metodo `update_profiler`:
```
estimator.update_profiler(disable_framework_metrics=true)
```
[https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.update_profiler](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.update_profiler)
# Metodi utili della classe di stima AI per Debugger SageMaker
I seguenti metodi della classe di stima sono utili per accedere alle informazioni sul lavoro di SageMaker formazione e recuperare i percorsi di output dei dati di addestramento raccolti da Debugger. I seguenti metodi sono eseguibili dopo l'avvio di un processo di addestramento con il metodo `estimator.fit()`.
+ Per verificare l'URI del bucket S3 di base di un processo di formazione: SageMaker
```
estimator.output_path
```
+ Per verificare il nome del lavoro di base di un lavoro di SageMaker formazione:
```
estimator.latest_training_job.job_name
```
+ Per visualizzare una configurazione operativa completa dell'`CreateTrainingJob`API di un processo di SageMaker formazione:
```
estimator.latest_training_job.describe()
```
+ Per controllare un elenco completo delle regole del Debugger mentre è in esecuzione un processo di SageMaker formazione:
```
estimator.latest_training_job.rule_job_summary()
```
+ Per controllare l'URI del bucket S3 in cui vengono salvati i dati dei parametri del modello (tensori di output):
```
estimator.latest_job_debugger_artifacts_path()
```
+ Per controllare l'URI del bucket S3 in cui vengono salvati i dati di prestazione del modello (parametri di sistema e framework):
```
estimator.latest_job_profiler_artifacts_path()
```
+ Per verificare la configurazione delle regole di Debugger per il debug dei tensori di output:
```
estimator.debugger_rule_configs
```
+ Per controllare l'elenco delle regole del Debugger per il debug durante l'esecuzione di un processo di formazione: SageMaker
```
estimator.debugger_rules
```
+ Per verificare la configurazione delle regole di Debugger per il monitoraggio e la profilazione dei parametri del sistema e del framework:
```
estimator.profiler_rule_configs
```
+ Per controllare l'elenco delle regole del Debugger per il monitoraggio e la profilazione durante l'esecuzione di un processo di formazione: SageMaker
```
estimator.profiler_rules
```
Per ulteriori informazioni sulla classe SageMaker AI estimator e sui relativi metodi, consulta l'[API Estimator nell'SDK](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator) Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable).
# SageMaker Report interattivo del debugger per XGBoost
Ricevi report di addestramento generati automaticamente da Debugger. I report di Debugger forniscono informazioni dettagliate sui processi di addestramento e suggeriscono consigli per migliorare le prestazioni del modello. Per i lavori di XGBoost formazione sull' SageMaker intelligenza artificiale, utilizza la [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) regola Debugger per ricevere un rapporto di formazione completo sui progressi e sui risultati della formazione. Seguendo questa guida, specifica la [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) regola durante la creazione di uno XGBoost stimatore, scarica il report utilizzando l'[SDK Amazon SageMaker Python o la](https://sagemaker.readthedocs.io/en/stable) console Amazon S3 e ottieni informazioni dettagliate sui risultati della formazione.
**Nota**
È possibile scaricare i report di Debugger mentre il processo di addestramento è in fase di esecuzione o al termine del processo. Durante l’addestramento, Debugger aggiorna contemporaneamente il report in base allo stato di valutazione delle regole correnti. È possibile scaricare un report di Debugger completo solo dopo il completamento del processo di addestramento.
**Importante**
Nel report, le raccomandazioni e i grafici sono forniti a scopo informativo e non sono definitivi. Sei responsabile della tua valutazione indipendente delle informazioni.
**Topics**
+ [Costruisci uno stimatore SageMaker AI XGBoost con la regola Debugger Report XGBoost](debugger-training-xgboost-report-estimator.md)
+ [Scaricate il rapporto di formazione su Debugger XGBoost](debugger-training-xgboost-report-download.md)
+ [Guida dettagliata al rapporto di formazione sul debugger XGBoost](debugger-training-xgboost-report-walkthrough.md)
# Costruisci uno stimatore SageMaker AI XGBoost con la regola Debugger Report XGBoost
La regola [CreateXgboostReport](debugger-built-in-rules.md#create-xgboost-report) raccoglie i seguenti tensori di output dal processo di addestramento:
+ `hyperparameters` – Salva durante la prima fase.
+ `metrics` – Salva perdita e precisione ogni 5 fasi.
+ `feature_importance` – Salva ogni 5 fasi.
+ `predictions` – Salva ogni 5 fasi.
+ `labels` – Salva ogni 5 fasi.
I tensori di output vengono salvati in un bucket S3 predefinito. Ad esempio, `s3://sagemaker--<12digit_account_id>//debug-output/`.
Quando costruisci uno stimatore SageMaker AI per un lavoro di XGBoost formazione, specifica la regola come mostrato nel seguente codice di esempio.
------
#### [ Using the SageMaker AI generic estimator ]
```
import boto3
import sagemaker
from sagemaker.estimator import Estimator
from sagemaker import image_uris
from sagemaker.debugger import Rule, rule_configs
rules=[
Rule.sagemaker(rule_configs.create_xgboost_report())
]
region = boto3.Session().region_name
xgboost_container=sagemaker.image_uris.retrieve("xgboost", region, "1.2-1")
estimator=Estimator(
role=sagemaker.get_execution_role()
image_uri=xgboost_container,
base_job_name="debugger-xgboost-report-demo",
instance_count=1,
instance_type="ml.m5.2xlarge",
# Add the Debugger XGBoost report rule
rules=rules
)
estimator.fit(wait=False)
```
------
# Scaricate il rapporto di formazione su Debugger XGBoost
Scarica il report di XGBoost formazione Debugger mentre il processo di formazione è in esecuzione o al termine del processo utilizzando Amazon [ SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) e (CLI). AWS Command Line Interface
------
#### [ Download using the SageMaker Python SDK and AWS CLI ]
1. Controlla l'URI di base di output S3 predefinito del processo corrente.
```
estimator.output_path
```
1. Controlla il nome del processo corrente.
```
estimator.latest_training_job.job_name
```
1. Il report Debugger è archiviato in. XGBoost `//rule-output` Configura il percorso di output della regola come segue:
```
rule_output_path = estimator.output_path + "/" + estimator.latest_training_job.job_name + "/rule-output"
```
1. Per verificare se il report viene generato, elenca le directory e i file in modo ripetuto sotto l'opzione `rule_output_path` utilizzando `aws s3 ls` con l'opzione `--recursive`.
```
! aws s3 ls {rule_output_path} --recursive
```
Questo dovrebbe restituire un elenco completo di file nelle cartelle generate automaticamente denominate `CreateXgboostReport` e `ProfilerReport-1234567890`. Il rapporto XGBoost di formazione viene archiviato nella cartella e `CreateXgboostReport` il rapporto di profilazione viene archiviato nella cartella. `ProfilerReport-1234567890` Per ulteriori informazioni sul rapporto di profilazione generato di default con il lavoro di XGBoost formazione, consulta. [SageMaker Report interattivo del debugger](debugger-profiling-report.md)
![\[Esempio di output delle regole.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-ls.png)
`xgboost_report.html`Si tratta di un rapporto di XGBoost formazione generato automaticamente da Debugger. `xgboost_report.ipynb` è un notebook Jupyter che viene utilizzato per aggregare i risultati dell’addestramento nel report. È possibile scaricare tutti i file, sfogliare il file del report HTML e modificare il report utilizzando il notebook.
1. Scarica i file in modo ripetuto utilizzando `aws s3 cp`. Il comando seguente salva tutti i file di output delle regole nella cartella `ProfilerReport-1234567890` all'interno della directory del lavoro corrente.
```
! aws s3 cp {rule_output_path} ./ --recursive
```
**Suggerimento**
Se utilizzi un server notebook Jupyter, esegui l'operazione `!pwd` per verificare la directory di lavoro corrente.
1. Sotto la directory `/CreateXgboostReport`, apri `xgboost_report.html`. Se lo stai utilizzando JupyterLab, scegli **Trust HTML** per visualizzare il rapporto di formazione del Debugger generato automaticamente.
![\[Esempio di output delle regole.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-open-trust.png)
1. Apri il file `xgboost_report.ipynb` per scoprire come viene generato il report. È possibile personalizzare ed estendere il report di addestramento utilizzando il file del notebook Jupyter.
------
#### [ Download using the Amazon S3 console ]
1. Accedi a Console di gestione AWS e apri la console Amazon S3 all'indirizzo. [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/)
1. Cerca il bucket S3 di base. Ad esempio, se non hai specificato alcun nome di processo di base, il nome del bucket S3 di base deve avere il seguente formato: `sagemaker--111122223333`. Ricerca il bucket S3 di base nel campo **Trova bucket per nome**.
![\[Il campo Trova bucket per nome nella console Amazon S3.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-0.png)
1. Nel bucket S3 di base, cerca il nome del processo di addestramento inserendo il prefisso del nome del processo in **Trova oggetti per prefisso** e quindi scegliendo il nome del processo di addestramento.
![\[Il campo Trova oggetti per prefisso nella console Amazon S3.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-1.png)
1. Nel bucket S3 del processo di addestramento, scegli la sottocartella **rule-output/**. Devono essere presenti tre sottocartelle per i dati di addestramento raccolti da Debugger: **debug-output/**, **profiler-output/** e **rule-output/**.
![\[Un esempio all’URI del bucket S3 di output della regola.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-report-download-s3console-2.png)
1. **Nella cartella **rule-output/, scegli la cartella/**CreateXgboostReport** La cartella contiene **xbgoost\$1report.html** (il report generato automaticamente in html) e **xbgoost\$1report.ipynb** (un notebook Jupyter con script utilizzati per generare il report).
1. Scegli il file **xbgoost\$1report.html**, scegli **Scarica azioni**, quindi scegli **Scarica**.
![\[Un esempio dell'URI del bucket S3 di output della regola.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-xgboost-report-s3-download.png)
1. Apri il file **xbgoost\$1report.html** scaricato in un browser Web.
------
# Guida dettagliata al rapporto di formazione sul debugger XGBoost
Questa sezione illustra il rapporto di formazione di Debugger. XGBoost Il report viene aggregato automaticamente in base al regex del tensore di output, riconoscendo il tipo di processo di addestramento compreso tra classificazione binaria, classificazione multiclasse e regressione.
**Importante**
Nel report, grafici e raccomandazioni sono forniti a scopo informativo e non sono definitivi. Sei responsabile della valutazione indipendente delle informazioni contenute in questo documento.
**Topics**
+ [Distribuzione di etichette corrette del set di dati](#debugger-training-xgboost-report-walkthrough-dist-label)
+ [Grafico delle perdite in funzione della fase](#debugger-training-xgboost-report-walkthrough-loss-vs-step)
+ [Importanza delle funzionalità](#debugger-training-xgboost-report-walkthrough-feature-importance)
+ [Matrice di confusione](#debugger-training-xgboost-report-walkthrough-confusion-matrix)
+ [Valutazione della matrice di confusione.](#debugger-training-xgboost-report-walkthrough-eval-conf-matrix)
+ [Tasso di precisione di ogni elemento diagonale rispetto all’iterazione](#debugger-training-xgboost-report-walkthrough-accuracy-rate)
+ [Curva delle caratteristiche operative del ricevitore](#debugger-training-xgboost-report-walkthrough-rec-op-char)
+ [Distribuzione dei residui nell’ultima fase salvata](#debugger-training-xgboost-report-walkthrough-dist-residual)
+ [Errore di convalida assoluto per container di etichette durante l’iterazione](#debugger-training-xgboost-report-walkthrough-val-error-per-label-bin)
## Distribuzione di etichette corrette del set di dati
Questo istogramma mostra la distribuzione delle classi etichettate (per la classificazione) o dei valori (per la regressione) nel set di dati originale. L'asimmetria nel tuo set di dati potrebbe contribuire a creare imprecisioni. Questa visualizzazione è disponibile per i seguenti tipi di modelli: classificazione binaria, multiclassificazione e regressione.
![\[Un esempio di distribuzione di etichette reali del grafico del set di dati.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-dist-label.png)
## Grafico delle perdite in funzione della fase
Questo è una grafica a linee che mostra la progressione della perdita dei dati di addestramento e dei dati di convalida durante le fasi di addestramento. La perdita è ciò che hai definito nella tua funzione obiettivo, ad esempio l'errore quadratico medio. Da questo grafico è possibile valutare se il modello è sovradimensionato o inadeguato. In questa sezione vengono inoltre forniti approfondimenti che è possibile usare per determinare come risolvere i problemi di sovra-adattamento e inadeguatezza. Questa visualizzazione è disponibile per i seguenti tipi di modelli: classificazione binaria, multiclassificazione e regressione.
![\[Un esempio di grafico tra perdite e fasi.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-loss-vs-step.png)
## Importanza delle funzionalità
Sono disponibili tre diversi tipi di visualizzazioni dell'importanza delle funzionalità: Peso, Guadagno e Copertura. Forniamo definizioni dettagliate per ciascuno dei tre elementi del report. Le visualizzazioni sull'importanza delle funzionalità ti aiutano a capire quali funzionalità del tuo set di dati di addestramento hanno contribuito alle previsioni. Le visualizzazioni dell'importanza delle funzionalità sono disponibili per i seguenti tipi di modelli: classificazione binaria, multiclassificazione e regressione.
![\[Un esempio di grafico dell'importanza della funzionalità.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-feature-importance.png)
## Matrice di confusione
Questa visualizzazione è applicabile solo ai modelli binari e di classificazione multiclasse. La precisione da sola potrebbe non essere sufficiente per valutare le prestazioni del modello. Per alcuni casi d'uso, come l'assistenza sanitaria e il rilevamento delle frodi, è importante conoscere anche il tasso di falsi positivi e quello di falsi negativi. Una matrice di confusione fornisce le dimensioni aggiuntive per valutare le prestazioni del tuo modello.
![\[Un esempio di matrice di confusione.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-confusion-matrix.png)
## Valutazione della matrice di confusione.
Questa sezione fornisce ulteriori informazioni sulle metriche micro, macro e ponderate relative alla precisione, al richiamo e al punteggio F1 del modello.
![\[Valutazione della matrice di confusione.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-eval-conf-matrix.png)
## Tasso di precisione di ogni elemento diagonale rispetto all’iterazione
Questa visualizzazione è applicabile solo alla classificazione binaria e ai modelli di classificazione multiclasse. Questo è un grafico a linee che riporta i valori diagonali nella matrice di confusione durante le fasi di addestramento per ogni classe. Questo grafico mostra come la precisione di ogni classe progredisce durante le fasi dell’addestramento. Da questo grafico è possibile identificare le classi con prestazioni insoddisfacenti.
![\[Un esempio di tasso di precisione di ogni elemento diagonale sul grafico di iterazione.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-accuracy-rate.gif)
## Curva delle caratteristiche operative del ricevitore
Questa visualizzazione è applicabile solo ai modelli di classificazione binaria. La curva delle Caratteristiche operative del ricevitore viene comunemente utilizzata per valutare le prestazioni del modello di classificazione binaria. L'asse y della curva è la Percentuale di veri positivi (TPF, True Positive Rate) e l'asse x è la percentuale di falsi positivi (FPR, False Positive Rate). Il grafico mostra anche il valore per l’area sotto la curva (AUC). Più alto è il valore AUC, più predittivo è il classificatore. Puoi anche utilizzare la curva ROC per comprendere il compromesso tra TPR e FPR e identificare la soglia di classificazione ottimale per il tuo caso d'uso. La soglia di classificazione può essere regolata per ottimizzare il comportamento del modello in modo da ridurre maggiormente l'uno o l'altro tipo di errore (FP/FN).
![\[Un esempio: un grafico della curva caratteristica di funzionamento del ricevitore.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-rec-op-char.png)
## Distribuzione dei residui nell’ultima fase salvata
Questa visualizzazione è un grafico a colonne che mostra le distribuzioni residue nell'ultima fase acquisita da Debugger. In questa visualizzazione, è possibile verificare se la distribuzione residua è vicina alla distribuzione normale centrata sullo zero. Se i residui sono disallineati, le tue caratteristiche potrebbero non essere sufficienti per prevedere le etichette.
![\[Un esempio di una distribuzione dei residui nell'ultimo grafico a fasi salvato.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-dist-residual.png)
## Errore di convalida assoluto per container di etichette durante l’iterazione
Questa visualizzazione è applicabile solo per i modelli di regressione. I valori target effettivi vengono suddivisi in 10 intervalli. Questa visualizzazione mostra come progrediscono gli errori di convalida per ogni intervallo durante le fasi di addestramento nei grafici a linea. L'errore di convalida assoluto è il valore assoluto della differenza tra previsione ed effettiva durante la convalida. È possibile identificare gli intervalli con prestazioni insoddisfacenti da questa visualizzazione.
![\[Un esempio: un errore di convalida assoluto per container di etichette su un grafico di iterazione.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-training-xgboost-report-walkthrough-val-error-per-label-bin.png)
# Azione sulle regole di Amazon SageMaker Debugger
In base allo stato di valutazione della regola di Debugger, è possibile configurare azioni automatiche come l'interruzione di un processo di addestramento e l'invio di notifiche tramite Amazon Simple Notification Service (Amazon SNS). Puoi anche creare azioni personalizzate utilizzando Amazon CloudWatch Events e AWS Lambda. Per informazioni su come configurare azioni automatizzate in base allo stato di valutazione della regola di Debugger, consulta i seguenti argomenti.
**Topics**
+ [Utilizzo delle azioni integrate di Debugger per le regole](debugger-built-in-actions.md)
+ [Azioni sulle regole che utilizzano Amazon CloudWatch e AWS Lambda](debugger-cloudwatch-lambda.md)
# Utilizzo delle azioni integrate di Debugger per le regole
Utilizza le azioni integrate di Debugger per rispondere ai problemi rilevati da [Regola Debugger](debugger-built-in-rules.md#debugger-built-in-rules-Rule). La classe `rule_configs` di Debugger fornisce strumenti per configurare un elenco di azioni, tra cui l'interruzione automatica dei processi di addestramento e l'invio di notifiche tramite Amazon Simple Notification Service (Amazon SNS) quando le regole di Debugger rilevano problemi di addestramento. Di seguito sono riportate le fasi necessarie per eseguire queste attività.
**Topics**
+ [Configurazione di Amazon SNS, creazione di un argomento `SMDebugRules` e iscrizione all’argomento](#debugger-built-in-actions-sns)
+ [Configurazione del ruolo IAM per collegare le policy richieste](#debugger-built-in-actions-iam)
+ [Configurazione delle regole di Debugger con le azioni integrate](#debugger-built-in-actions-on-rule)
+ [Considerazioni sull’utilizzo delle azioni integrate di Debugger](#debugger-built-in-actions-considerations)
## Configurazione di Amazon SNS, creazione di un argomento `SMDebugRules` e iscrizione all’argomento
Questa sezione spiega come configurare un argomento **SMDebugRules** di Amazon SNS, iscriversi e confermare l'abbonamento per ricevere notifiche dalle regole di Debugger.
**Nota**
[Per ulteriori informazioni sulla fatturazione per Amazon SNS, consulta i prezzi di [Amazon SNS e Amazon SNS](https://aws.amazon.com/sns/pricing/). FAQs](https://aws.amazon.com/sns/faqs/)
**Per creare un argomento sulle regole SMDebug**
1. [Accedi a Console di gestione AWS e apri la console Amazon SNS nella versione v3/home. https://console.aws.amazon.com/sns/](https://console.aws.amazon.com/sns/v3/home)
1. Nel pannello di navigazione a sinistra, selezionare **Topics (Argomenti)**.
1. Nella pagina **Topics (Argomenti)**, seleziona **Create new topic (Crea nuovo argomento)**.
1. Nella pagina **Create topic (Crea argomento)**, nella sezione **Details (Dettagli)**, eseguire queste operazioni:
1. Per **Tipo**, scegli **Standard** come tipo di argomento.
1. In **Nome**, inserisci **SMDebugRules**.
1. Salta tutte le altre impostazioni opzionali e scegli **Crea argomento**. Per ulteriori informazioni sulle impostazioni opzionali, consulta [Creazione di un argomento Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-topic.html).
**Per iscriverti all'argomento Regole SMDebug**
1. [Apri la console Amazon SNS nella versione v3/home. https://console.aws.amazon.com/sns/](https://console.aws.amazon.com/sns/v3/home)
1. Nel pannello di navigazione sinistro scegli **Sottoscrizioni**.
1. Nella pagina **Sottoscrizioni** scegli **Crea sottoscrizione**.
1. Nella pagina **Crea sottoscrizione**, nella sezione **Dettagli**, eseguire queste operazioni:
1. Per **Argomento ARN**, scegli l'argomento **SMDebugRegole** ARN. L'ARN deve avere il formato di `arn:aws:sns::111122223333:SMDebugRules`.
1. Per **Protocollo**, seleziona **-mail)** o **SMS**.
1. Per **Endpoint**, inserisci il valore dell'endpoint, ad esempio un indirizzo e-mail o un numero di telefono a cui desideri ricevere notifiche.
**Nota**
Assicurati di digitare l'indirizzo e-mail e il numero di telefono corretti. I numeri di telefono devono includere `+`, un prefisso internazionale e un numero di telefono, senza caratteri o spazi speciali. Ad esempio, il numero di telefono \$11 (222) 333-4444 è formattato come **\$112223334444**.
1. Salta tutte le altre impostazioni opzionali e scegli **Crea abbonamento**. Per ulteriori informazioni sulle impostazioni opzionali, consulta [Abbonamento a un argomento Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-create-subscribe-endpoint-to-topic.html).
Dopo la sottoscrizione all'argomento **SMDebugRegole**, riceverai il seguente messaggio di conferma via e-mail o per telefono:
![\[Un messaggio e-mail di conferma dell'abbonamento per l'argomento SMDebugRegole di Amazon SNS.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-built-in-action-subscription-confirmation.png)
Per ulteriori informazioni su Amazon SNS, consulta [Messaggi di testo mobili (SMS)](https://docs.aws.amazon.com/sns/latest/dg/sns-mobile-phone-number-as-subscriber.html) e [Notifiche e-mail](https://docs.aws.amazon.com/sns/latest/dg/sns-email-notifications.html) nella *Guida per gli sviluppatori di Amazon SNS*.
## Configurazione del ruolo IAM per collegare le policy richieste
In questa fase le policy richieste vengono aggiunte al ruolo IAM.
**Per aggiungere le policy richieste al tuo ruolo IAM**
1. Accedi Console di gestione AWS e apri la console IAM all'indirizzo [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/).
1. Nel riquadro di navigazione a sinistra, seleziona **Policy** e **Crea policy**.
1. Nella pagina **Crea policy**, procedi come segue per creare una nuova policy sns-access:
1. Scegli la scheda **JSON**.
1. Incolla le stringhe JSON in grassetto nel codice seguente nella cartella`"Statement"`, sostituendo l'ID dell'account a 12 cifre con l'ID AWS dell'account. AWS
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"sns:Publish",
"sns:CreateTopic",
"sns:Subscribe"
],
"Resource": "arn:aws:sns:*:111122223333:SMDebugRules"
}
]
}
```
------
1. Nella parte inferiore della pagina, scegli **Rivedi policy**.
1. Nella pagina **Review policy (Esamina policy)**, per **Name (Nome)**, immettere **sns-access**.
1. Nella parte inferiore della pagina, scegli **Crea policy**.
1. Torna alla console IAM e scegli **Ruoli** nel riquadro di navigazione a sinistra.
1. Cerca il ruolo IAM che utilizzi per la formazione sui modelli di SageMaker intelligenza artificiale e scegli quel ruolo IAM.
1. Nella scheda **Autorizzazioni** della pagina **Riepilogo**, scegli **Collega policy**.
1. cerca la policy **sns-access**, seleziona la casella di controllo accanto alla policy, quindi scegli **Collega policy**.
Per altri esempi di configurazione delle policy IAM per Amazon SNS, consulta [Esempi di casi per il controllo degli accessi Amazon SNS](https://docs.aws.amazon.com/sns/latest/dg/sns-access-policy-use-cases.html).
## Configurazione delle regole di Debugger con le azioni integrate
Dopo aver completato con successo le impostazioni richieste nelle fasi precedenti, è possibile configurare le azioni integrate di Debugger per le regole di debug, come mostrato nello script di esempio seguente. È possibile scegliere quali azioni integrate utilizzare durante la creazione dell'oggetto elenco `actions`. `rule_configs` è un modulo di supporto che fornisce strumenti di alto livello per configurare le regole e le azioni integrate di Debugger. Le seguenti azioni integrate sono disponibili per Debugger:
+ `rule_configs.StopTraining()` – Interrompe un processo di addestramento quando la regola di Debugger rileva un problema.
+ `rule_configs.Email("abc@abc.com")` – Invia una notifica via e-mail quando la regola di Debugger rileva un problema. Utilizza l'indirizzo e-mail che hai usato quando hai configurato l'abbonamento all'argomento SNS.
+ `rule_configs.SMS("+1234567890")` – Invia una notifica via messaggio di testo quando la regola di Debugger rileva un problema. Utilizza il numero di telefono che hai usato quando hai configurato l'abbonamento all'argomento SNS.
**Nota**
Assicurati di digitare l'indirizzo e-mail e il numero di telefono corretti. I numeri di telefono devono includere `+`, un prefisso internazionale e un numero di telefono, senza caratteri o spazi speciali. Ad esempio, il numero di telefono \$11 (222) 333-4444 è formattato come **\$112223334444**.
È possibile utilizzare tutte le azioni integrate o un sottoinsieme di azioni concludendo utilizzando il metodo `rule_configs.ActionList()`, che esegue le azioni integrate e configura un elenco di azioni.
**Per aggiungere tutte e tre le azioni predefinite a un'unica regola**
Se desideri assegnare tutte e tre le azioni integrate a una singola regola, configura un elenco di azioni integrate in Debugger durante la creazione di uno strumento di valutazione. Usa il seguente modello per creare lo strumento di valutazione e Debugger interromperà i processi di addestramento e invierà notifiche tramite e-mail e messaggi di testo per tutte le regole che utilizzi per monitorare l'avanzamento del processo di addestramento.
```
from sagemaker.debugger import Rule, rule_configs
# Configure an action list object for Debugger rules
actions = rule_configs.ActionList(
rule_configs.StopTraining(),
rule_configs.Email("abc@abc.com"),
rule_configs.SMS("+1234567890")
)
# Configure rules for debugging with the actions parameter
rules = [
Rule.sagemaker(
base_config=rule_configs.built_in_rule(), # Required
rule_parameters={"paramter_key": value }, # Optional
actions=actions
)
]
estimator = Estimator(
...
rules = rules
)
estimator.fit(wait=False)
```
**Per creare più oggetti di azione integrati per assegnare azioni diverse a una singola regola**
Se desideri assegnare le azioni integrate da attivare a diversi valori di soglia di una singola regola, puoi creare più oggetti di azione integrati come illustrato nello script seguente. Per evitare un errore di conflitto eseguendo la stessa regola, è necessario inviare nomi di processo di regola diversi (specificare stringhe diverse per l'attributo `name` delle regole), come illustrato nel seguente modello di script di esempio. Questo esempio mostra come impostare [StalledTrainingRule](debugger-built-in-rules.md#stalled-training) per eseguire due azioni diverse: inviare un'e-mail a `abc@abc.com` quando un processo di addestramento si blocca per 60 secondi e interrompere il processo di addestramento se si blocca per 120 secondi.
```
from sagemaker.debugger import Rule, rule_configs
import time
base_job_name_prefix= 'smdebug-stalled-demo-' + str(int(time.time()))
# Configure an action object for StopTraining
action_stop_training = rule_configs.ActionList(
rule_configs.StopTraining()
)
# Configure an action object for Email
action_email = rule_configs.ActionList(
rule_configs.Email("abc@abc.com")
)
# Configure a rule with the Email built-in action to trigger if a training job stalls for 60 seconds
stalled_training_job_rule_email = Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "60",
"training_job_name_prefix": base_job_name_prefix
},
actions=action_email
)
stalled_training_job_rule_text.name="StalledTrainingJobRuleEmail"
# Configure a rule with the StopTraining built-in action to trigger if a training job stalls for 120 seconds
stalled_training_job_rule = Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "120",
"training_job_name_prefix": base_job_name_prefix
},
actions=action_stop_training
)
stalled_training_job_rule.name="StalledTrainingJobRuleStopTraining"
estimator = Estimator(
...
rules = [stalled_training_job_rule_email, stalled_training_job_rule]
)
estimator.fit(wait=False)
```
Mentre il processo di addestramento è in esecuzione, l'azione integrata di Debugger invia e-mail e messaggi di testo di notifica ogni volta che la regola rileva problemi con il processo di addestramento. La schermata seguente mostra un esempio di notifica via e-mail per un processo di addestramento che presenta un problema relativo a un processo di addestramento bloccato.
![\[Un esempio di notifica e-mail inviata da Debugger quando rileva un problema. StalledTraining\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-built-in-action-email.png)
La schermata seguente mostra un esempio di notifica di testo che Debugger invia quando la regola rileva un problema. StalledTraining
![\[Un esempio di notifica di testo inviata da Debugger quando rileva un problema. StalledTraining\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-built-in-action-text.png)
## Considerazioni sull’utilizzo delle azioni integrate di Debugger
+ Per utilizzare le azioni integrate di Debugger, è necessaria una connessione Internet. Questa funzionalità non è supportata nella modalità di isolamento della rete fornita da Amazon SageMaker AI o Amazon VPC.
+ Le azioni integrate non possono essere utilizzate per [Regole del profiler](debugger-built-in-profiler-rules.md#debugger-built-in-profiler-rules-ProfilerRule).
+ Le azioni integrate non possono essere utilizzate in processi di addestramento con interruzioni spot dell'addestramento.
+ Nelle notifiche via e-mail o SMS, `None` viene visualizzato alla fine dei messaggi. Questo non ha alcun significato, quindi puoi ignorare il testo `None`.
# Azioni sulle regole che utilizzano Amazon CloudWatch e AWS Lambda
Amazon CloudWatch raccoglie i log dei lavori di formazione dei modelli Amazon SageMaker AI e i log dei lavori di elaborazione delle regole di Amazon SageMaker Debugger. Configura Debugger con Amazon CloudWatch Events e intraprendi azioni in base AWS Lambda allo stato di valutazione delle regole del Debugger.
## Notebook di esempio
Puoi eseguire i seguenti notebook di esempio, preparati per sperimentare l'interruzione di un processo di formazione utilizzando azioni sulle regole integrate di Debugger utilizzando Amazon e. CloudWatch AWS Lambda
+ [Amazon SageMaker Debugger: reagire agli eventi derivanti dalle regole CloudWatch ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_action_on_rule/tf-mnist-stop-training-job.html)
Questo notebook di esempio esegue un processo di addestramento che presenta un problema di gradiente di fuga. La regola [VanishingGradient](debugger-built-in-rules.md#vanishing-gradient) integrata del Debugger viene utilizzata durante la creazione dello stimatore AI. SageMaker TensorFlow Quando la regola di Debugger rileva il problema, il processo di addestramento viene interrotto.
+ [Rileva l'allenamento in stallo e richiama le azioni utilizzando la regola del debugger SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_action_on_rule/detect_stalled_training_job_and_actions.html)
Questo notebook di esempio esegue uno script di addestramento con una riga di codice che lo costringe a una sospensione di 10 minuti. La regola di Debugger integrata [StalledTrainingRule](debugger-built-in-rules.md#stalled-training) richiama problemi e interrompe il processo di addestramento.
**Topics**
+ [Notebook di esempio](#debugger-test-stop-training)
+ [Accedi ai CloudWatch log per le regole del Debugger e i lavori di formazione](debugger-cloudwatch-metric.md)
+ [Configura Debugger per l'interruzione automatica del processo di formazione utilizzando e Lambda CloudWatch](debugger-stop-training.md)
+ [Disabilita la regola CloudWatch Events per interrompere l'utilizzo della terminazione automatica del processo di formazione](debugger-disable-cw.md)
# Accedi ai CloudWatch log per le regole del Debugger e i lavori di formazione
È possibile utilizzare le regole di formazione e Debugger job status nei CloudWatch log per intraprendere ulteriori azioni in caso di problemi di formazione. La procedura seguente mostra come accedere ai log correlati. CloudWatch Per ulteriori informazioni sul monitoraggio dei lavori di formazione utilizzando CloudWatch, consulta [Monitor Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/monitoring-overview.html).
**Come trovare i log dei job di addestramento e i log dei processi di elaborazione delle regole di Debugger**
1. Apri la CloudWatch console all'indirizzo [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. Nel pannello di navigazione sulla sinistra, nel nodo **Log**, scegli **Gruppi di log**.
1. Nell'elenco Gruppi di log, procedi come segue:
+ Scegli**/aws/sagemaker/TrainingJobs**per i registri dei lavori di formazione.
+ Scegli**/aws/sagemaker/ProcessingJobsper i log** dei lavori delle regole del Debugger.
# Configura Debugger per l'interruzione automatica del processo di formazione utilizzando e Lambda CloudWatch
Le regole Debugger monitorano lo stato del processo di formazione e una regola CloudWatch Events controlla lo stato di valutazione del processo di formazione della regola Debugger. Le sezioni seguenti descrivono il processo necessario per automatizzare l'interruzione dei lavori di formazione utilizzando e CloudWatch Lambda.
**Topics**
+ [Fase 1: creare una funzione Lambda](#debugger-lambda-function-create)
+ [Fase 2: configurare la funzione Lambda](#debugger-lambda-function-configure)
+ [Passaggio 3: creare una regola CloudWatch degli eventi e collegarsi alla funzione Lambda per Debugger](#debugger-cloudwatch-events)
## Fase 1: creare una funzione Lambda
**Come creare una funzione Lambda**
1. Apri la console all'indirizzo. AWS Lambda [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. Nel riquadro di navigazione a sinistra, scegli **Funzioni**, quindi scegli **Crea funzione**.
1. Nella pagina **Crea funzione**, scegli l’opzione **Crea da zero**.
1. Nella sezione **Informazioni di base**, inserisci **il nome di una funzione** (ad esempio, **debugger-rule-stop-training-job**).
1. In **Runtime**, scegliere **Python 3.7**.
1. Per **Autorizzazioni**, espandi l'opzione a discesa e scegli **Cambia il ruolo di esecuzione predefinito**.
1. Per il **ruolo di esecuzione**, scegli **Usa un ruolo esistente** e scegli il ruolo IAM da utilizzare per i lavori di formazione sull' SageMaker intelligenza artificiale.
**Nota**
Assicurati di utilizzare il ruolo di esecuzione con `AmazonSageMakerFullAccess` e `AWSLambdaBasicExecutionRole` collegati. In caso contrario, la funzione Lambda non reagirà correttamente alle modifiche allo stato della regola di Debugger del processo di addestramento. Se non sei sicuro del ruolo di esecuzione utilizzato, esegui il codice seguente in una cella del notebook Jupyter per recuperare l'output del ruolo di esecuzione:
```
import sagemaker
sagemaker.get_execution_role()
```
1. Nella parte inferiore della pagina, scegli **Crea funzione**.
La figura seguente mostra un esempio della pagina **Crea funzione** con i campi di input e le selezioni completati.
![\[Pagina Crea Funzione.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-lambda-create.png)
## Fase 2: configurare la funzione Lambda
**Per configurare la funzione Lambda**
1. Nella sezione **Codice funzione** della pagina di configurazione, incolla il seguente script Python nel riquadro dell'editor di codice Lambda. La `lambda_handler` funzione monitora lo stato di valutazione delle regole del Debugger raccolto da CloudWatch e attiva l'operazione dell'API. `StopTrainingJob` The AWS SDK per Python (Boto3) `client` for SageMaker AI fornisce un metodo di alto livello che attiva il funzionamento dell'API. `stop_training_job` `StopTrainingJob`
```
import json
import boto3
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
def lambda_handler(event, context):
training_job_name = event.get("detail").get("TrainingJobName")
logging.info(f'Evaluating Debugger rules for training job: {training_job_name}')
eval_statuses = event.get("detail").get("DebugRuleEvaluationStatuses", None)
if eval_statuses is None or len(eval_statuses) == 0:
logging.info("Couldn't find any debug rule statuses, skipping...")
return {
'statusCode': 200,
'body': json.dumps('Nothing to do')
}
# should only attempt stopping jobs with InProgress status
training_job_status = event.get("detail").get("TrainingJobStatus", None)
if training_job_status != 'InProgress':
logging.debug(f"Current Training job status({training_job_status}) is not 'InProgress'. Exiting")
return {
'statusCode': 200,
'body': json.dumps('Nothing to do')
}
client = boto3.client('sagemaker')
for status in eval_statuses:
logging.info(status.get("RuleEvaluationStatus") + ', RuleEvaluationStatus=' + str(status))
if status.get("RuleEvaluationStatus") == "IssuesFound":
secondary_status = event.get("detail").get("SecondaryStatus", None)
logging.info(
f'About to stop training job, since evaluation of rule configuration {status.get("RuleConfigurationName")} resulted in "IssuesFound". ' +
f'\ntraining job "{training_job_name}" status is "{training_job_status}", secondary status is "{secondary_status}"' +
f'\nAttempting to stop training job "{training_job_name}"'
)
try:
client.stop_training_job(
TrainingJobName=training_job_name
)
except Exception as e:
logging.error(
"Encountered error while trying to "
"stop training job {}: {}".format(
training_job_name, str(e)
)
)
raise e
return None
```
Per ulteriori informazioni sull'interfaccia dell'editor di codice Lambda, consulta [Creazione di funzioni utilizzando l'editor della console AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/code-editor.html).
1. Salta tutte le altre impostazioni e scegli **Salva** nella parte superiore della pagina di configurazione.
## Passaggio 3: creare una regola CloudWatch degli eventi e collegarsi alla funzione Lambda per Debugger
**Per creare una regola CloudWatch Events e collegarsi alla funzione Lambda per Debugger**
1. Apri la console all'indirizzo. CloudWatch [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/)
1. Nel pannello di navigazione a sinistra, scegli **Regole** sotto al nodo **Eventi**.
1. Scegli **Crea regola**.
1. Nella sezione **Origine dell'evento** della pagina **Step 1: Create rule**, scegli **SageMaker AI** come **Service Name** e scegli **SageMaker AI Training Job State Change** for **Event Type**. L'anteprima del modello di evento deve apparire simile alle seguenti stringhe JSON di esempio:
```
{
"source": [
"aws.sagemaker"
],
"detail-type": [
"SageMaker Training Job State Change"
]
}
```
1. Nella sezione **Target**, scegli **Aggiungi target\$1** e scegli la funzione **debugger-rule-stop-training-job** Lambda che hai creato. Questo passaggio collega la regola CloudWatch Events alla funzione Lambda.
1. Scegli **Configura dettagli** e vai alla pagina **Fase 2: configurare i dettagli della regola**.
1. Specificate il nome della definizione della CloudWatch regola. Ad esempio, **debugger-cw-event-rule**.
1. Per finire, scegli **Crea regola**.
1. Torna alla pagina di configurazione della funzione Lambda e aggiorna la pagina. Verifica che sia configurata correttamente nel pannello **Designer**. La regola CloudWatch Events deve essere registrata come trigger per la funzione Lambda. Il design della configurazione deve essere simile all'esempio seguente.
![\[Pannello di progettazione per la CloudWatch configurazione.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-lambda-designer.png)
# Disabilita la regola CloudWatch Events per interrompere l'utilizzo della terminazione automatica del processo di formazione
Se desideri disabilitare l'interruzione automatica del processo di formazione, devi disabilitare la regola CloudWatch Eventi. Nel pannello Lambda **Designer**, scegli il blocco **EventBridge (CloudWatch Eventi)** collegato alla funzione Lambda. Questo mostra un **EventBridge**pannello sotto il pannello **Designer** (ad esempio, vedi la schermata precedente). Seleziona la casella di controllo accanto a **EventBridge (CloudWatch Eventi): debugger-cw-event-rule**, quindi scegli **Disabilita**. Se desideri utilizzare la funzionalità di terminazione automatica in un secondo momento, puoi abilitare nuovamente la regola CloudWatch Events.
# Visualizza i tensori di output di Amazon SageMaker Debugger in TensorBoard
**Importante**
Questa pagina è stata sostituita da Amazon SageMaker AI with TensoBoard, che offre un' TensorBoard esperienza completa integrata con la SageMaker formazione e le funzionalità di controllo degli accessi del dominio AI. SageMaker Per ulteriori informazioni, consulta [TensorBoard in Amazon SageMaker AI](tensorboard-on-sagemaker.md).
Usa SageMaker Debugger per creare file tensoriali di output compatibili con. TensorBoard Carica i file per visualizzare e analizzare i tuoi lavori di formazione. TensorBoard SageMaker Debugger genera automaticamente file tensoriali di output compatibili con. TensorBoard Per qualsiasi configurazione di hook personalizzata per salvare i tensori di output, Debugger ha la flessibilità di creare riepiloghi scalari, distribuzioni e istogrammi in cui importare. TensorBoard
![\[Un diagramma di architettura del meccanismo di salvataggio dei tensori di output di Debugger.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-tensorboard-concept.png)
È possibile abilitarlo passando gli oggetti `DebuggerHookConfig` e `TensorBoardOutputConfig` a un `estimator`.
La procedura seguente spiega come salvare scalari, pesi e distorsioni come tensori completi, istogrammi e distribuzioni con cui è possibile visualizzare. TensorBoard Debugger li salva nel percorso locale del container di addestramento (il percorso predefinito è `/opt/ml/output/tensors`) e si sincronizza con le posizioni Amazon S3 passate attraverso gli oggetti di configurazione dell'output del Debugger.
**TensorBoard Per salvare file tensoriali di output compatibili utilizzando Debugger**
1. Imposta un oggetto di `tensorboard_output_config` configurazione per salvare l' TensorBoard output utilizzando la classe Debugger. `TensorBoardOutputConfig` Per il `s3_output_path` parametro, specifica il bucket S3 predefinito della sessione SageMaker AI corrente o un bucket S3 preferito. Questo esempio non aggiunge il parametro `container_local_output_path`; viene invece impostato sul percorso locale predefinito `/opt/ml/output/tensors`.
```
import sagemaker
from sagemaker.debugger import TensorBoardOutputConfig
bucket = sagemaker.Session().default_bucket()
tensorboard_output_config = TensorBoardOutputConfig(
s3_output_path='s3://{}'.format(bucket)
)
```
Per ulteriori informazioni, consulta l'`[TensorBoardOutputConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.TensorBoardOutputConfig)`API Debugger nell'SDK Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable).
1. Configura l'hook Debugger e personalizza i valori dei parametri dell'hook. Ad esempio, il codice seguente configura un hook Debugger per salvare tutti gli output scalari ogni 100 fasi nelle fasi di addestramento e 10 fasi nelle fasi di convalida, i parametri `weights` ogni 500 fasi (il valore `save_interval` predefinito per il salvataggio delle raccolte di tensori è 500) e i parametri `bias` ogni 10 fasi globali fino a quando la fase globale raggiunge 500.
```
from sagemaker.debugger import CollectionConfig, DebuggerHookConfig
hook_config = DebuggerHookConfig(
hook_parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
},
collection_configs=[
CollectionConfig("weights"),
CollectionConfig(
name="biases",
parameters={
"save_interval": "10",
"end_step": "500",
"save_histogram": "True"
}
),
]
)
```
[Per ulteriori informazioni sulla configurazione del Debugger APIs, consulta Debugger e Amazon Python `[CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)` SDK `[DebuggerHookConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DebuggerHookConfig)` APIs . SageMaker ](https://sagemaker.readthedocs.io/en/stable)
1. Costruisci uno stimatore SageMaker AI con i parametri del Debugger che passano gli oggetti di configurazione. Il seguente modello di esempio mostra come creare uno stimatore AI generico. SageMaker È possibile sostituire `estimator` e utilizzare le `Estimator` classi principali e le classi di estimatori di altri framework di SageMaker intelligenza artificiale. Gli stimatori del framework SageMaker AI disponibili per questa funzionalità sono, e. `[TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/using_tf.html#create-an-estimator)` `[PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#create-an-estimator)` `[MXNet](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html#create-an-estimator)`
```
from sagemaker.estimator import Estimator
estimator = Estimator(
...
# Debugger parameters
debugger_hook_config=hook_config,
tensorboard_output_config=tensorboard_output_config
)
estimator.fit()
```
Il `estimator.fit()` metodo avvia un processo di formazione e Debugger scrive i file del tensore di output in tempo reale sul percorso di output del Debugger S3 e sul percorso di output S3. TensorBoard Per recuperare i percorsi di output, utilizza i seguenti metodi di valutazione:
+ Per il percorso di output di Debugger S3, usa `estimator.latest_job_debugger_artifacts_path()`.
+ Per TensorBoard il percorso di output S3, usa. `estimator.latest_job_tensorboard_artifacts_path()`
1. Al termine dell'addestramento, controlla i nomi dei tensori di output salvati:
```
from smdebug.trials import create_trial
trial = create_trial(estimator.latest_job_debugger_artifacts_path())
trial.tensor_names()
```
1. Controlla i dati TensorBoard di output in Amazon S3:
```
tensorboard_output_path=estimator.latest_job_tensorboard_artifacts_path()
print(tensorboard_output_path)
!aws s3 ls {tensorboard_output_path}/
```
1. Scarica i dati TensorBoard di output sull'istanza del tuo notebook. Ad esempio, il AWS CLI comando seguente scarica i TensorBoard file nella directory di lavoro corrente dell'istanza del notebook. `/logs/fit`
```
!aws s3 cp --recursive {tensorboard_output_path} ./logs/fit
```
1. Comprimi la directory dei file in un file TAR da scaricare sul computer locale.
```
!tar -cf logs.tar logs
```
1. Scarica ed estrai il file TAR di Tensorboard in una directory sul tuo dispositivo, avvia un server notebook Jupyter, apri un nuovo notebook ed esegui l'app. TensorBoard
```
!tar -xf logs.tar
%load_ext tensorboard
%tensorboard --logdir logs/fit
```
La seguente schermata animata illustra le fasi da 5 a 8. Dimostra come scaricare il file TensorBoard TAR Debugger e caricare il file in un notebook Jupyter sul dispositivo locale.
![\[Animazione su come scaricare e caricare il file Debugger sul computer locale. TensorBoard\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-tensorboard.gif)
# Elenco delle regole integrate di Debugger
Puoi utilizzare le regole integrate di Debugger fornite da Amazon SageMaker Debugger e analizzare le metriche e i tensori raccolti durante l’addestramento dei tuoi modelli. Di seguito sono elencate le regole di Debugger, incluse informazioni e un esempio su come configurare e implementare ogni regola integrata.
Le regole integrate di Debugger monitorano varie condizioni comuni che sono fondamentali per il successo di un processo di addestramento. Puoi richiamare le regole integrate utilizzando [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) o le operazioni API SageMaker di basso livello.
Non sono previsti costi aggiuntivi per l'utilizzo di regole integrate. Per ulteriori informazioni sulla fatturazione, consulta la pagina [Prezzi di Amazon SageMaker](https://aws.amazon.com/sagemaker/pricing/).
**Nota**
Il numero massimo di regole integrate che è possibile collegare a un processo di addestramento è 20. Debugger SageMaker gestisce completamente le regole integrate e analizza il processo di addestramento in modo sincrono.
**Importante**
Per utilizzare le nuove funzionalità di Debugger, è necessario aggiornare l'SDK SageMaker Python e la libreria client SMDebug. Nel kernel IPython, notebook Jupyter, o nell'ambiente JupyterLab, esegui il codice seguente per installare le versioni più recenti delle librerie e riavviare il kernel.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Regola Debugger
Le seguenti regole sono le regole integrate di Debugger che possono essere richiamate utilizzando il metodo di classe `Rule.sagemaker`.
Regole integrate di Debugger per generare report di addestramento
| Ambito di validità | Regole integrate |
| --- | --- |
| Report di addestramento per il job di addestramento di SageMaker AI XGBoost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-built-in-rules.html) |
Regole integrate di Debugger per il debug dei dati di addestramento del modello (tensori di output)
| Ambito di validità | Regole integrate |
| --- | --- |
| Framework di deep learning (TensorFlow, MXNet e PyTorch) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Framework di deep learning (TensorFlow, MXNet e PyTorch) e algoritmo XGBoost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Applicazioni deep learning | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Algoritmo XGBoost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-built-in-rules.html) |
**Per utilizzare le regole integrate con i valori dei parametri predefiniti**, utilizza il seguente formato di configurazione:
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
Rule.sagemaker(rule_configs.built_in_rule_name_1()),
Rule.sagemaker(rule_configs.built_in_rule_name_2()),
...
Rule.sagemaker(rule_configs.built_in_rule_name_n())
]
```
**Per utilizzare le regole integrate con la configurazione dei parametri predefiniti**, utilizza il seguente formato di configurazione:
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
Rule.sagemaker(
base_config=rule_configs.built_in_rule_name(),
rule_parameters={
"key": "value"
}
collections_to_save=[
CollectionConfig(
name="tensor_collection_name",
parameters={
"key": "value"
}
)
]
)
]
```
Per trovare le chiavi disponibili per il parametro `rule_parameters`, consulta le tabelle di descrizione dei parametri.
Vengono forniti esempi di codici di configurazione delle regole per ogni regola integrata sotto le tabelle di descrizione dei parametri.
+ Per istruzioni complete ed esempi di utilizzo delle regole integrate di Debugger, consulta [Codice di esempio con regole integrate di Debugger](debugger-built-in-rules-example.md#debugger-deploy-built-in-rules).
+ Per un'istruzione completa sull'uso delle regole integrate con le operazioni API SageMaker di basso livello, consulta [Configurazione del debugger tramite l'API SageMaker](debugger-createtrainingjob-api.md).
## CreateXgboostReport
La regola CreateXGBoostReport raccoglie i tensori di output da un processo di addestramento XGBoost e genera automaticamente un report di addestramento completo. È possibile scaricare un report di profilazione completo mentre un processo di addestramento è in corso o dopo il completamento del processo di addestramento e controllare il progresso di addestramento o il suo risultato finale. La regola CreateXGBoostReport raccoglie i seguenti tensori di output per impostazione predefinita:
+ `hyperparameters`: Salva durante la prima fase
+ `metrics`: Risparmia perdita e precisione ogni 5 fasi
+ `feature_importance`: Salva ogni 5 fasi
+ `predictions`: Salva ogni 5 fasi
+ `labels`: Salva ogni 5 fasi
Descrizioni dei parametri per la regola CreateXgboostReport
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
```
rules=[
Rule.sagemaker(
rule_configs.create_xgboost_report()
)
]
```
## DeadRelu
Questa regola rileva quando la percentuale di funzioni di attivazione dell'unità lineare rettificata (ReLU) in una prova è considerata morta perché la loro attività di attivazione è scesa al di sotto di una soglia. Se la percentuale di ReLUs inattivi in un livello è maggiore del valore `threshold_layer` di ReLU inattivi, la regola restituisce `True`.
Descrizioni dei parametri per la regola DeadRelu
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: `".*relu_output"` |
| threshold\$1inactivity | Definisce un livello di attività al di sotto del quale un ReLU è considerato morto. Un ReLU potrebbe essere attivo all'inizio di una prova e poi morire lentamente durante il processo di addestramento. Se ReLU è attivo meno del `threshold_inactivity`, è considerato morto. **Opzionale** Valori validi: float Valori predefiniti: `1.0` (in percentuale) |
| threshold\$1layer | Restituisce `True` se la percentuale di ReLU inattivi in un livello è maggiore di `threshold_layer`. Restituisce `False` se la percentuale di ReLU inattivi in un livello è inferiore a `threshold_layer`. **Opzionale** Valori validi: float Valori predefiniti: `50.0` (in percentuale) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.dead_relu(),
rule_parameters={
"tensor_regex": ".*relu_output|.*ReLU_output",
"threshold_inactivity": "1.0",
"threshold_layer": "50.0"
},
collections_to_save=[
CollectionConfig(
name="custom_relu_collection",
parameters={
"include_regex: ".*relu_output|.*ReLU_output",
"save_interval": "500"
}
)
]
)
]
```
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
Questa regola non è disponibile per l'algoritmo XGBoost.
## ExplodingTensor
Questa regola rileva se i tensori emessi durante l’addestramento hanno valori non finiti, infiniti o NaN (non un numero). Se viene rilevato un valore non finito, la regola restituisce `True`.
Descrizioni dei parametri per la regola ExplodingTensor
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| collection\$1names | L'elenco dei nomi di raccolta i cui tensori vengono ispezionati dalla regola. **Opzionale** Valori validi: stringa Valore predefinito: `None` |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: stringa Valore predefinito: `None` |
| only\$1nan | `True` per monitorare i tensori `base_trial` solo per i valori `NaN` e non per l'infinito. `False` per trattare `NaN` e infinity come valori esplosivi e per monitorare entrambi. **Opzionale** Valore predefinito: `False` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.exploding_tensor(),
rule_parameters={
"tensor_regex": ".*gradient",
"only_nan": "False"
},
collections_to_save=[
CollectionConfig(
name="gradients",
parameters={
"save_interval": "500"
}
)
]
)
]
```
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
Questa regola non è disponibile per l'algoritmo XGBoost.
## PoorWeightInitialization
Questa regola rileva se i parametri del modello sono stati inizializzati male.
Una buona inizializzazione interrompe la simmetria dei pesi e dei gradienti in una rete neurale e mantiene le varianze di attivazione commisurate tra i livelli. Altrimenti, la rete neurale non apprende in modo efficace. Gli inizializzatori come Xavier mirano a mantenere costante la varianza tra le attivazioni, che è particolarmente rilevante per l’addestramento di reti neurali molto profonde. Un'inizializzazione troppo piccola può portare alla scomparsa dei gradienti. Un'inizializzazione troppo grande può portare a gradienti esplosivi. Questa regola controlla la varianza degli input di attivazione tra i livelli, la distribuzione dei gradienti e la convergenza delle perdite per le fasi iniziali per determinare se una rete neurale è stata inizializzata male.
Descrizioni dei parametri per la regola PoorWeightInitialization
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| activation\$1inputs\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: stringa Valore predefinito: `".*relu_input"` |
| threshold | Se il rapporto tra la varianza minima e massima dei pesi per livello supera il `threshold` in una fase, la regola ritorna `True`. **Opzionale** Valori validi: float Valore predefinito: `10.0` |
| distribution\$1range | Se la differenza minima tra il quinto e il 95° percentile della distribuzione del gradiente è inferiore alla `distribution_range`, la regola restituisce `True`. **Opzionale** Valori validi: float Valore predefinito: `0.001` |
| patience | Il numero di fasi da attendere fino a quando la perdita è considerata non più in diminuzione. **Opzionale** Valori validi: numeri interi Valore predefinito: `5` |
| steps | Il numero di fasi analizzate da questa regola. In genere è necessario controllare solo le prime iterazioni. **Opzionale** Valori validi: float Valore predefinito: `10` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.poor_weight_initialization(),
rule_parameters={
"activation_inputs_regex": ".*relu_input|.*ReLU_input",
"threshold": "10.0",
"distribution_range": "0.001",
"patience": "5",
"steps": "10"
},
collections_to_save=[
CollectionConfig(
name="custom_relu_collection",
parameters={
"include_regex": ".*relu_input|.*ReLU_input",
"save_interval": "500"
}
)
]
)
]
```
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
Questa regola non è disponibile per l'algoritmo XGBoost.
## SaturatedActivation
Questa regola rileva se i livelli di attivazione tanh e sigmoid stanno diventando saturi. Un livello di attivazione è saturo quando l'input del livello è vicino al massimo o al minimo della funzione di attivazione. Il minimo e il massimo delle funzioni di attivazione tanh e sigmoid sono definiti dai rispettivi valori `min_threshold` e `max_thresholds`. Se l'attività di un nodo scende al di sotto della percentuale `threshold_inactivity`, è considerata satura. Se più di una percentuale `threshold_layer` di nodi è satura, la regola restituisce `True`.
Descrizioni dei parametri per la regola SaturatedActivation
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| collection\$1names | L'elenco dei nomi di raccolta i cui tensori vengono ispezionati dalla regola. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: stringa Valore predefinito: `".*tanh_input\|.*sigmoid_input".` |
| threshold\$1tanh\$1min | Le soglie minime e massime che definiscono gli estremi dell'input per una funzione di attivazione tanh, definite come: `(min_threshold, max_threshold)`. I valori predefiniti vengono determinati in base a una soglia di gradiente di fuga pari a 0,0000001. **Opzionale** Valori validi: float Valori predefiniti: `-9.4999` |
| threshold\$1tanh\$1max | Le soglie minime e massime che definiscono gli estremi dell'input per una funzione di attivazione tanh, definite come: `(min_threshold, max_threshold)`. I valori predefiniti vengono determinati in base a una soglia di gradiente di fuga pari a 0,0000001. **Opzionale** Valori validi: float Valori predefiniti: `9.4999` |
| threshold\$1sigmoid\$1min | Le soglie minime e massime che definiscono gli estremi dell'input per una funzione di attivazione sigma, definite come: `(min_threshold, max_threshold)`. I valori predefiniti vengono determinati in base a una soglia di gradiente di fuga pari a 0,0000001. **Opzionale** Valori validi: float Valori predefiniti: `-23` |
| threshold\$1sigmoid\$1max | Le soglie minime e massime che definiscono gli estremi dell'input per una funzione di attivazione sigma, definite come: `(min_threshold, max_threshold)`. I valori predefiniti vengono determinati in base a una soglia di gradiente di fuga pari a 0,0000001. **Opzionale** Valori validi: float Valori predefiniti: `16.99999` |
| threshold\$1inactivity | La percentuale di inattività al di sotto della quale il livello di attivazione è considerato saturo. L'attivazione potrebbe essere attiva all'inizio di una prova e poi diventare lentamente meno attiva durante il processo di addestramento. **Opzionale** Valori validi: float Valori predefiniti: `1.0` |
| threshold\$1layer | Restituisce `True` se il numero di attivazioni sature in un livello è maggiore della percentuale `threshold_layer`. Restituisce `False` se il numero di attivazioni sature in un livello è inferiore alla percentuale `threshold_layer`. **Opzionale** Valori validi: float Valori predefiniti: `50.0` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.saturated_activation(),
rule_parameters={
"tensor_regex": ".*tanh_input|.*sigmoid_input",
"threshold_tanh_min": "-9.4999",
"threshold_tanh_max": "9.4999",
"threshold_sigmoid_min": "-23",
"threshold_sigmoid_max": "16.99999",
"threshold_inactivity": "1.0",
"threshold_layer": "50.0"
},
collections_to_save=[
CollectionConfig(
name="custom_activations_collection",
parameters={
"include_regex": ".*tanh_input|.*sigmoid_input"
"save_interval": "500"
}
)
]
)
]
```
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
Questa regola non è disponibile per l'algoritmo XGBoost.
## VanishingGradient
Questa regola rileva se i gradienti in una prova diventano estremamente piccoli o scendono a una magnitudine zero. Se la media dei valori assoluti dei gradienti scende al di sotto di un valore `threshold` specificato, la regola restituisce `True`.
Descrizioni dei parametri per la regola VanishingGradient
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| threshold | Il valore al quale il gradiente svanisce.**Opzionale**Valori validi: floatValore predefinito: `0.0000001`. |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.vanishing_gradient(),
rule_parameters={
"threshold": "0.0000001"
},
collections_to_save=[
CollectionConfig(
name="gradients",
parameters={
"save_interval": "500"
}
)
]
)
]
```
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
Questa regola non è disponibile per l'algoritmo XGBoost.
## WeightUpdateRatio
Questa regola tiene traccia del rapporto tra aggiornamenti e pesi durante l’addestramento e rileva se tale rapporto diventa troppo grande o troppo piccolo. Se il rapporto tra gli aggiornamenti e i pesi è maggiore di `large_threshold value` o se questo rapporto è inferiore a `small_threshold`, la regola restituisce `True`.
Le condizioni per l’addestramento sono ottimali quando gli aggiornamenti sono commisurati ai gradienti. Gli aggiornamenti eccessivamente grandi possono allontanare i pesi dai valori ottimali e gli aggiornamenti molto piccoli determinano una convergenza molto lenta. Questa regola richiede che i pesi siano disponibili per due fasi di addestramento e `train.save_interval` deve essere impostato su `num_steps`.
Descrizioni dei parametri per la regola WeightUpdateRatio
| Nome parametro, | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| num\$1steps | Il numero di fasi attraverso le quali la regola verifica se il tensore è cambiato. Il numero di fasi attraverso le quali si desidera confrontare i rapporti di peso. Se non si passa alcun valore, la regola viene eseguita per impostazione predefinita rispetto alla fase corrente e alla fase salvata immediatamente precedente. Se si sovrascrive il valore predefinito passando un valore per questo parametro, il confronto viene effettuato tra i pesi alla fase `s` e alla fase `>= s - num_steps`. **Opzionale** Valori validi: numeri interi Valore predefinito: `None` |
| large\$1threshold | Il valore massimo che il rapporto tra gli aggiornamenti di peso può assumere prima che la regola ritorni `True`. **Opzionale** Valori validi: float Valore predefinito: `10.0` |
| small\$1threshold | Il valore minimo che può assumere il rapporto di aggiornamenti di peso, al di sotto del quale viene restituita la regola `True`. **Opzionale** Valori validi: float Valore predefinito: `0.00000001` |
| epsilon | Una piccola costante utilizzata per garantire che Debugger non si divide per zero quando si calcolano gli aggiornamenti del rapporto da pesare. **Opzionale** Valori validi: float Valore predefinito: `0.000000001` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.weight_update_ratio(),
rule_parameters={
"num_steps": "100",
"large_threshold": "10.0",
"small_threshold": "0.00000001",
"epsilon": "0.000000001"
},
collections_to_save=[
CollectionConfig(
name="weights",
parameters={
"train.save_interval": "100"
}
)
]
)
]
```
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
Questa regola non è disponibile per l'algoritmo XGBoost.
## AllZero
Questa regola rileva se tutti o una percentuale specificata dei valori del tensore sono zero.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost. È necessario specificare il parametro `collection_names` o `tensor_regex`. Se vengono specificati entrambi i parametri, la regola ispeziona l'unione dei tensori da entrambi i set.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola AllZero
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| collection\$1names | L'elenco dei nomi di raccolta i cui tensori vengono ispezionati dalla regola. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: `None` |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: `None` |
| threshold | Specificare la percentuale di valori nel tensore che deve essere zero per richiamare questa regola. **Opzionale** Valori validi: float Valore predefinito: 100 (in percentuale) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.all_zero(),
rule_parameters={
"tensor_regex": ".*",
"threshold": "100"
},
collections_to_save=[
CollectionConfig(
name="all",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## ClassImbalance
Questa regola misura gli squilibri di campionamento tra le classi e genera errori se lo squilibrio supera una soglia o se si verificano troppe predizioni errate per le classi sottorappresentate a causa dello squilibrio.
I modelli di classificazione richiedono classi ben bilanciate nel set di dati di addestramento o ponderazione/campionamento adeguato delle classi durante l’addestramento. La regola esegue i seguenti controlli:
+ Conta le occorrenze per classe. Se il rapporto tra il numero di campioni tra la classe più piccola e quella più grande è maggiore di `threshold_imbalance`, viene generato un errore.
+ Controlla l'accuratezza della previsione per classe. Se il ricampionamento o la ponderazione non sono stati applicati correttamente, il modello può raggiungere un'elevata precisione per la classe con molti campioni di addestramento, ma bassa precisione per le classi con pochi campioni di addestramento. Se una frazione di errori di predizioni errate per una determinata classe è superiore a `threshold_misprediction`, viene generato un errore.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola ClassImbalance
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| threshold\$1imbalance | Lo squilibrio accettabile tra il numero di campioni nella classe più piccola e nella classe più grande. Il superamento di questo valore di soglia genera un errore. **Opzionale** Valori validi: float Valore predefinito: `10` |
| threshold\$1misprediction | Un limite alla frazione di errori di predizione consentiti per ogni classe. Il superamento di questa soglia genera un errore. Le classi sottorappresentate sono maggiormente a rischio di superare questa soglia. **Opzionale** Valori validi: float Valore predefinito: `0.7` |
| samples | Numero di etichette che devono essere elaborate prima di valutare uno sbilanciamento. La regola potrebbe non essere attivata fino a quando non ha visto campioni sufficienti in diverse fasi. Più è alto il numero delle classi contenute dal set di dati, maggiore dovrebbe essere il numero `sample`. **Opzionale** Valori validi: numeri interi Valore predefinito: `500` (assumendo un set di dati come MNIST con 10 classi) |
| argmax | Se `True`, [np.argmax](https://docs.scipy.org/doc/numpy-1.9.3/reference/generated/numpy.argmax.html) viene applicato al tensore di previsione. Richiesto quando si dispone di un vettore di probabilità per ogni classe. Viene utilizzato per determinare quale classe ha la più alta probabilità. **Condizionale** Valori validi: booleani Valore predefinito: `False` |
| labels\$1regex | Il nome del tensore che contiene le etichette. **Opzionale** Valori validi: stringa Valore predefinito: `".*labels"` |
| predictions\$1regex | Il nome del tensore che contiene le previsioni. **Opzionale** Valori validi: stringa Valore predefinito: `".*predictions"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.class_imbalance(),
rule_parameters={
"threshold_imbalance": "10",
"threshold_misprediction": "0.7",
"samples": "500",
"argmax": "False",
"labels_regex": ".*labels",
"predictions_regex": ".*predictions"
},
collections_to_save=[
CollectionConfig(
name="custom_output_collection",
parameters={
"include_regex": ".*labels|.*predictions",
"save_interval": "500"
}
)
]
)
]
```
## LossNotDecreasing
Questa regola rileva quando la perdita non diminuisce di valore ad un tasso adeguato. Queste perdite devono essere scalari.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost. È necessario specificare il parametro `collection_names` o `tensor_regex`. Se vengono specificati entrambi i parametri, la regola ispeziona l'unione dei tensori da entrambi i set.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola LossNotDecreasing
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| collection\$1names | L'elenco dei nomi di raccolta i cui tensori vengono ispezionati dalla regola. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: `None` |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: `None` |
| use\$1losses\$1collection | Se impostato su `True`, cerca le perdite nella raccolta denominata "perdite" quando la raccolta è presente. **Opzionale** Valori validi: booleani Valore predefinito: `True` |
| num\$1steps | Il numero minimo di fasi dopo il quale la regola controlla se la perdita è diminuita. La valutazione delle regole avviene ogni `num_steps`. La regola confronta la perdita per questa fase con la perdita in una fase che è almeno `num_steps` dietro la fase corrente. Ad esempio, supponiamo che la perdita venga salvata ogni tre fasi, ma `num_steps` è impostato su 10. Alla fase 21, la perdita per la fase 21 viene confrontata con la perdita per la fase 9. La fase successiva in cui viene verificata la perdita è la fase 33, perché dieci fasi dopo la fase 21 c’è la fase 31 e alla fase 31 e 32 la perdita non viene salvata. **Opzionale** Valori validi: numeri interi Valore predefinito: `10` |
| diff\$1percent | La differenza percentuale minima con cui la perdita dovrebbe diminuire tra `num_steps`. **Opzionale** Valori validi: `0.0` < float < `100` Valore predefinito: `0.1` (in percentuale) |
| increase\$1threshold\$1percent | La soglia massima di aumento della perdita è consentita nel caso in cui la perdita sia in aumento. **Opzionale** Valori validi: `0` < float < `100` Valore predefinito: `5` (in percentuale) |
| mode | Il nome della modalità Debugger per eseguire la query dei valori del tensore per il controllo delle regole. Se non viene passato, per impostazione predefinita la regola controlla in ordine `mode.EVAL`, quindi `mode.TRAIN` e quindi `mode.GLOBAL`. **Opzionale** Valori validi: stringa (`EVAL`, `TRAIN` o `GLOBAL`) Valore predefinito: `GLOBAL` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.loss_not_decreasing(),
rule_parameters={
"tensor_regex": ".*",
"use_losses_collection": "True",
"num_steps": "10",
"diff_percent": "0.1",
"increase_threshold_percent": "5",
"mode": "GLOBAL"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## Overfit
Questa regola rileva se il modello è in eccesso rispetto ai dati di addestramento confrontando le perdite di convalida e addestramento.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
Un modo standard per evitare l'overfitting è regolarizzare il modello.
Descrizioni dei parametri per la regola di overfit
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
| start\$1step | La fase da cui iniziare a confrontare la perdita di convalida e di addestramento. **Opzionale** Valori validi: numeri interi Valore predefinito: `0` |
| patience | Il numero di fasi per i quali a `ratio_threshold` è consentito superare il valore impostato prima che il modello sia considerato in eccesso. **Opzionale** Valori validi: numeri interi Valore predefinito: `1` |
| ratio\$1threshold | Il rapporto massimo della differenza tra la perdita media di convalida e la perdita media di addestramento con la perdita media di addestramento. Se questa soglia viene superata per un `patience` certo numero di fasi, il modello è in eccesso e la regola viene restituita `True`. **Opzionale** Valori validi: float Valore predefinito: `0.1` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.overfit(),
rule_parameters={
"tensor_regex": ".*",
"start_step": "0",
"patience": "1",
"ratio_threshold": "0.1"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
}
)
]
)
]
```
## Overtraining
Questa regola rileva se un modello è sottoposto a un addestramento eccessivo. Dopo una serie di iterazioni di addestramento su un modello ben funzionante (diminuiscono sia le perdite di addestramento che quelle di convalida), il modello si avvicina al minimo della funzione di perdita e non migliora più. Se il modello continua l'addestramento, può succedere che la perdita di convalida inizi ad aumentare, perché il modello inizia a fare overfitting. Questa regola stabilisce soglie e condizioni per determinare se il modello non sta migliorando e previene i problemi di overfitting dovuti all'eccesso di adattamento.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
L'overtraining può essere evitato fermandosi anticipatamente. Per informazioni sull'arresto anticipato, consulta [Interrompere in anticipo i processi di addestramento](automatic-model-tuning-early-stopping.md). Per un esempio che mostra come utilizzare l’addestramento spot con Debugger, consulta la pagina [Abilitazione dell’addestramento spot con Debugger Amazon SageMaker](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/mxnet_spot_training/mxnet-spot-training-with-sagemakerdebugger.html).
Descrizioni dei parametri per la regola di Overtraining
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| patience\$1train | Il numero di fasi da attendere prima che la perdita di addestramento sia considerata come non più migliorabile. **Opzionale** Valori validi: numeri interi Valore predefinito: `5` |
| patience\$1validation | Il numero di fasi da attendere prima che la perdita di convalida non sia più migliorata.**Opzionale**Valori validi: numeri interiValore predefinito: `10` |
| delta | La soglia minima di quanto l'errore dovrebbe migliorare prima che venga considerato come un nuovo ottimale. **Opzionale** Valori validi: float Valore predefinito: `0.01` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.overtraining(),
rule_parameters={
"patience_train": "5",
"patience_validation": "10",
"delta": "0.01"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## SimilarAcrossRuns
Questa regola confronta i tensori raccolti da una prova di base con i tensori di un'altra prova.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola SimilarAcrossRuns
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| other\$1trials | Nome di un processo di addestramento completato di cui si desidera confrontare i tensori con quelli raccolti dalla corrente `base_trial`. **Campo obbligatorio** Valori validi: stringa |
| collection\$1names | L'elenco dei nomi di raccolta i cui tensori vengono ispezionati dalla regola. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.similar_across_runs(),
rule_parameters={
"other_trials": "",
"collection_names": "losses",
"tensor_regex": ".*"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## StalledTrainingRule
StalledTrainingRule rileva se non sono stati compiuti progressi nel processo di addestramento e lo interrompe se la regola viene attivata. Questa regola richiede il salvataggio periodico dei tensori in un intervallo di tempo definito dal relativo parametro `threshold`. Questa regola continua a monitorare i nuovi tensori e, se non è stato emesso alcun nuovo tensore per l'intervallo di soglia, viene attivata la regola.
Descrizioni dei parametri per la regola StalledTrainingRule
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| threshold | Una soglia che definisce per quanto tempo, in secondi, la regola attende l'output di un tensore prima di attivare un problema di addestramento in stallo. Il valore predefinito è 1800 secondi. **Opzionale** Valori validi: numeri interi Valore predefinito: `1800` |
| stop\$1training\$1on\$1fire | Se impostato su `True`, controlla se il processo di addestramento di base emette tensori in "`threshold`" secondi. **Opzionale** Valori validi: booleani Valore predefinito: `False` |
| training\$1job\$1name\$1prefix | Il prefisso del nome per il processo di addestramento di base. Se `stop_training_on_fire` è vero, la regola cerca i processi di addestramento SageMaker con questo prefisso nello stesso account. Se viene rilevata un'inattività, la regola esegue un'azione `StopTrainingJob`. Nota: se vengono trovati più processi con lo stesso prefisso, la regola ignora la terminazione. Per ogni processo di addestramento è importante che il prefisso sia impostato in modo univoco. **Opzionale** Valori validi: stringa |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "1800",
"stop_training_on_fire": "True",
"training_job_name_prefix": ""
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## TensorVariance
Questa regola rileva se sono presenti tensori con varianze molto alte o basse. Varianze molto alte o basse in un tensore potrebbero portare alla saturazione dei neuroni, che riduce la capacità di apprendimento della rete neurale. La varianza molto elevata dei tensori può anche portare all'esplosione di tensori. Utilizzare questa regola per rilevare tali problemi in anticipo.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost. È necessario specificare il parametro `collection_names` o `tensor_regex`. Se vengono specificati entrambi i parametri, la regola ispeziona l'unione dei tensori da entrambi i set.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola TensorVariance
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| collection\$1names | L'elenco dei nomi di raccolta i cui tensori vengono ispezionati dalla regola. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
| max\$1threshold | La soglia per il limite superiore della varianza del tensore. **Opzionale** Valori validi: float Valore predefinito: nessuno |
| min\$1threshold | La soglia per il limite inferiore della varianza del tensore. **Opzionale** Valori validi: float Valore predefinito: nessuno |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.tensor_variance(),
rule_parameters={
"collection_names": "weights",
"max_threshold": "10",
"min_threshold": "0.00001",
},
collections_to_save=[
CollectionConfig(
name="weights",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## UnchangedTensor
Questa regola rileva se un tensore non cambia più tra una fase e l’altra.
Questa regola esegue il metodo [numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html) per verificare se il tensore non cambia.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost. È necessario specificare il parametro `collection_names` o `tensor_regex`. Se vengono specificati entrambi i parametri, la regola ispeziona l'unione dei tensori da entrambi i set.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola UnchangedTensor
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| collection\$1names | L'elenco dei nomi di raccolta i cui tensori vengono ispezionati dalla regola. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
| num\$1steps | Il numero di fasi attraverso i quali la regola verifica se il tensore è cambiato. Questo controlla gli ultimi `num_steps` che sono disponibili. Non devono essere consecutivi. Se `num_steps` è 2, alla fase s non controlla necessariamente s-1 ed s. Se s-1 non è disponibile, controlla l'ultima fase disponibile insieme a s. In tal caso, controlla l'ultima fase disponibile con la fase corrente. **Opzionale** Valori validi: numeri interi Valore predefinito: `3` |
| rtol | Il parametro di tolleranza relativa da passare al `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` metodo. **Opzionale** Valori validi: float Valore predefinito: `1e-05` |
| atol | Il parametro di tolleranza assoluta da passare al `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` metodo. **Opzionale** Valori validi: float Valore predefinito: `1e-08` |
| equal\$1nan | Se confrontare le NAN come uguali. Se `True`, le NAN nell'array di input a sono considerate uguali a NAN nell'array di input b nell'array di output. Questo parametro viene passato al metodo `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`. **Opzionale** Valori validi: booleani Valore predefinito: `False` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.unchanged_tensor(),
rule_parameters={
"collection_names": "losses",
"tensor_regex": "",
"num_steps": "3",
"rtol": "1e-05",
"atol": "1e-08",
"equal_nan": "False"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## CheckinPutimages
Questa regola controlla se le immagini di input sono state normalizzate correttamente. In particolare, rileva se la media dei dati campione differisce di più di un valore soglia da zero. Molti modelli di visione artificiale richiedono che i dati di input abbiano una media zero e una varianza unitaria.
Questa regola è applicabile alle applicazioni di deep learning.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola CheckInPutImages
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| threshold\$1mean | Una soglia che definisce in base alla media dei dati di input può differire da 0. **Opzionale** Valori validi: float Valore predefinito: `0.2` |
| threshold\$1samples | Il numero di immagini che devono essere campionate prima che un errore possa essere generato. Se il valore è troppo basso, la stima della media del set di dati sarà imprecisa. **Opzionale** Valori validi: numeri interi Valore predefinito: `500` |
| regex | Il nome del tensore dei dati di input. **Opzionale** Valori validi: stringa Valore predefinito: `".*hybridsequential0_input_0"` (il nome del tensore di ingresso per i modelli Apache MXNet utilizzando HybridSequential) |
| channel | La posizione del canale colore nell'array di forme del tensore di input. **Opzionale** Valori validi: numeri interi Valore predefinito: `1` (ad esempio, MXNet si aspetta dati di input sotto forma di (batch\$1size, canale, altezza, larghezza)) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.check_input_images(),
rule_parameters={
"threshold_mean": "0.2",
"threshold_samples": "500",
"regex": ".*hybridsequential0_input_0",
"channel": "1"
},
collections_to_save=[
CollectionConfig(
name="custom_inputs_collection",
parameters={
"include_regex": ".*hybridsequential0_input_0",
"save_interval": "500"
}
)
]
)
]
```
## NLPSequenceRatio
Questa regola calcola il rapporto di token specifici dato il resto della sequenza di input utile per ottimizzare le prestazioni. Ad esempio, è possibile calcolare la percentuale di token di fine frase (EOS) di riempimento nella sequenza di input. Se il numero di token EOS è troppo alto, deve essere eseguita una strategia di bucketing alternativo. È inoltre possibile calcolare la percentuale di token sconosciuti nella sequenza di input. Se il numero di parole sconosciute è troppo alto, potrebbe essere usato un vocabolario alternativo.
Questa regola è applicabile alle applicazioni di deep learning.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola NLPSequenceRatio
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: `".*embedding0_input_0"` (assumendo un incorporamento come livello iniziale della rete) |
| token\$1values | Una stringa di un elenco dei valori numerici dei token. Ad esempio, "3,0". **Opzionale** Valori validi: stringa di valori numerici separata da virgole Valore predefinito: `0` |
| token\$1thresholds\$1percent | Una stringa di un elenco di soglie (in percentuale) che corrispondono a ciascuna delle `token_values`. Ad esempio, "50,0, 50,0". **Opzionale** Valori validi: stringa separata da virgole di numeri in virgola mobile Valore predefinito: `"50"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.nlp_sequence_ratio(),
rule_parameters={
"tensor_regex": ".*embedding0_input_0",
"token_values": "0",
"token_thresholds_percent": "50"
},
collections_to_save=[
CollectionConfig(
name="custom_inputs_collection",
parameters={
"include_regex": ".*embedding0_input_0"
}
)
]
)
]
```
## Confusion
Questa regola valuta la bontà di una matrice di confusione per un problema di classificazione.
Crea una matrice di dimensioni `category_no*category_no` e la popola con i dati provenienti da coppie (`labels`, `predictions`). Per ogni coppia (`labels`, `predictions`), il conteggio `confusion[labels][predictions]` viene incrementato di 1. Quando la matrice è completamente popolata, il rapporto tra dati su valori diagonali dei dati e valori fuori diagonale viene valutato come segue:
+ Per gli elementi sulla diagonale: `confusion[i][i]/sum_j(confusion[j][j])>=min_diag`
+ Per gli elementi fuori dalla diagonale: `confusion[j][i])/sum_j(confusion[j][i])<=max_off_diag`
Questa regola può essere applicata all'algoritmo XGBoost.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola di confusione
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| category\$1no | Il numero di categorie. **Opzionale** Valori validi: numero intero ≥2 Valore predefinito: `"None"` |
| labels | La raccolta di tensori `labels` o un vettore 1-d di etichette vere. **Opzionale** Valori validi: stringa Valore predefinito: `"labels"` |
| predictions | La raccolta tensore `predictions` o un vettore 1-d di etichette stimate. **Opzionale** Valori validi: stringa Valore predefinito: `"predictions"` |
| labels\$1collection | La regola controlla i tensori in questa raccolta per `labels`. **Opzionale** Valori validi: stringa Valore predefinito: `"labels"` |
| predictions\$1collection | La regola controlla i tensori in questa raccolta per `predictions`. **Opzionale** Valori validi: stringa Valore predefinito: `"predictions"` |
| min\$1diag | La soglia minima per il rapporto dei dati sulla diagonale. **Opzionale** Valori validi: `0`≤float≤`1` Valore predefinito: `0.9` |
| max\$1off\$1diag | La soglia massima per il rapporto tra i dati fuori dalla diagonale. **Opzionale** Valori validi: `0`≤float≤`1` Valore predefinito: `0.1` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.confusion(),
rule_parameters={
"category_no": "10",
"labels": "labels",
"predictions": "predictions",
"labels_collection": "labels",
"predictions_collection": "predictions",
"min_diag": "0.9",
"max_off_diag": "0.1"
},
collections_to_save=[
CollectionConfig(
name="labels",
parameters={
"save_interval": "500"
}
),
CollectionConfig(
name="predictions",
parameters={
"include_regex": "500"
}
)
]
)
]
```
**Nota**
Questa regola detiene i valori predefiniti per i parametri facoltativi se i loro valori non sono specificati.
## FeatureImportanceOverweight
Questa regola accumula i pesi degli n maggiori valori di importanza delle caratteristiche per ogni fase e garantisce che non superino la soglia. Ad esempio, è possibile impostare la soglia per le 3 caratteristiche principali in modo che non contengano più dell'80% dei pesi totali del modello.
Questa regola è valida solo per l'algoritmo XGBoost.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola FeatureImportanceOverweight
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| threshold | Definisce la soglia della proporzione della somma cumulativa delle funzionalità più grandi `n`. Il numero `n` è definito dal parametro `nfeatures`. **Opzionale** Valori validi: float Valore predefinito: `0.8` |
| nfeatures | Il numero di funzionalità più grandi. **Opzionale** Valori validi: numeri interi Valore predefinito: `3` |
| tensor\$1regex | L'espressione regolare (regex) del tensore indica la regola da analizzare. **Opzionale** Valori validi: stringa Valore predefinito: `".*feature_importance/weight"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.feature_importance_overweight(),
rule_parameters={
"threshold": "0.8",
"nfeatures": "3",
"tensor_regex": ".*feature_importance/weight"
},
collections_to_save=[
CollectionConfig(
name="feature_importance",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## TreeDepth
Questa regola misura la profondità degli alberi in un modello XGBoost. XGBoost rifiuta le divisioni se non migliorano la perdita. Questo regolarizza l’addestramento. Di conseguenza, l'albero potrebbe non crescere così in profondità come definito dal parametro `depth`.
Questa regola è valida solo per l'algoritmo XGBoost.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola TreeDepth
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| depth | La profondità dell'albero. La profondità dell'albero si ottiene calcolando il logaritmo di base 2 dell'ID nodo più grande. **Opzionale** Valori validi: float Valore predefinito: `4` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.tree_depth(),
rule_parameters={
"depth": "4"
},
collections_to_save=[
CollectionConfig(
name="tree",
parameters={
"save_interval": "500"
}
)
]
)
]
```
# Creazione di regole personalizzate utilizzando la libreria client di Debugger
Puoi creare regole personalizzate per monitorare il tuo lavoro di formazione utilizzando la regola Debugger APIs e la [libreria `smdebug` Python](https://github.com/awslabs/sagemaker-debugger/) open source che fornisce strumenti per creare contenitori di regole personalizzati.
## Prerequisiti per la creazione di una regola personalizzata
Per creare regole personalizzate di Debugger, sono necessari i seguenti prerequisiti.
+ [SageMaker Regola del debugger.API personalizzata](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.Rule.custom)
+ [La libreria Python open source smdebug](https://github.com/awslabs/sagemaker-debugger/)
+ Il tuo script python personalizzato per le regole
+ [Immagine Amazon SageMaker Debugger URIs per valutatori di regole personalizzati](debugger-reference.md#debuger-custom-rule-registry-ids)
**Topics**
+ [Prerequisiti per la creazione di una regola personalizzata](#debugger-custom-rules-prerequisite)
+ [Utilizzo della libreria client `smdebug` per creare una regola personalizzata come script Python](debugger-custom-rules-python-script.md)
+ [Usa il Debugger APIs per eseguire le tue regole personalizzate](debugger-custom-rules-python-sdk.md)
# Utilizzo della libreria client `smdebug` per creare una regola personalizzata come script Python
L'API `smdebug` Rule fornisce un'interfaccia per configurare regole personalizzate. Il seguente script python è un esempio di come costruire una regola personalizzata `CustomGradientRule`. Questa regola personalizzata del tutorial controlla se i gradienti stanno diventando troppo grandi e imposta la soglia predefinita su 10. La regola personalizzata richiede una prova di base creata da uno stimatore di SageMaker intelligenza artificiale quando avvia il processo di formazione.
```
from smdebug.rules.rule import Rule
class CustomGradientRule(Rule):
def __init__(self, base_trial, threshold=10.0):
super().__init__(base_trial)
self.threshold = float(threshold)
def invoke_at_step(self, step):
for tname in self.base_trial.tensor_names(collection="gradients"):
t = self.base_trial.tensor(tname)
abs_mean = t.reduction_value(step, "mean", abs=True)
if abs_mean > self.threshold:
return True
return False
```
È possibile aggiungere più classi di regole personalizzate quante ne si desidera nello stesso script Python e distribuirle in qualsiasi prova di processo di addestramento creando oggetti di regola personalizzati nella sezione seguente.
# Usa il Debugger APIs per eseguire le tue regole personalizzate
Il seguente esempio di codice mostra come configurare una regola personalizzata con l'SDK [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). *Questo esempio presuppone che lo script di regole personalizzate creato nel passaggio precedente si trovi in '\$1custom\$1rule.py'. path/to/my*
```
from sagemaker.debugger import Rule, CollectionConfig
custom_rule = Rule.custom(
name='MyCustomRule',
image_uri='759209512951.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rule-evaluator:latest',
instance_type='ml.t3.medium',
source='path/to/my_custom_rule.py',
rule_to_invoke='CustomGradientRule',
collections_to_save=[CollectionConfig("gradients")],
rule_parameters={"threshold": "20.0"}
)
```
L'elenco seguente illustra gli argomenti dell'API `Rule.custom` di Debugger.
+ `name` (str): specifica un nome di regola personalizzato desiderato.
+ `image_uri` (str): questa è l'immagine del container che ha la logica di comprendere la regola personalizzata. Reperisce e valuta le raccolte di tensori specificate salvate nel processo di addestramento. Puoi trovare l'elenco delle immagini open source di valutazione delle regole SageMaker AI da. [Immagine Amazon SageMaker Debugger URIs per valutatori di regole personalizzati](debugger-reference.md#debuger-custom-rule-registry-ids)
+ `instance_type` (str): devi specificare un'istanza per creare un container docker per regole. Questo fa funzionare l'istanza parallelamente a un container di addestramento.
+ `source` (str): questo è il percorso locale o l'URI di Amazon S3 dello script di regole personalizzate.
+ `rule_to_invoke`(str): specifica la particolare implementazione della classe Rule nello script di regole personalizzato. SageMaker L'intelligenza artificiale supporta solo una regola da valutare alla volta in un processo di regole.
+ `collections_to_save` (str): specifica quali raccolte di tensori verranno salvate per l'esecuzione della regola.
+ `rule_parameters` (dizionario): accetta input di parametri in un formato dizionario. È possibile regolare i parametri configurati nello script di regole personalizzate.
Dopo aver impostato l'`custom_rule`oggetto, puoi utilizzarlo per creare uno stimatore di SageMaker intelligenza artificiale per qualsiasi lavoro di formazione. Specifica `entry_point` nello script di addestramento. Non è necessario apportare modifiche allo script di addestramento.
```
from sagemaker.tensorflow import TensorFlow
estimator = TensorFlow(
role=sagemaker.get_execution_role(),
base_job_name='smdebug-custom-rule-demo-tf-keras',
entry_point='path/to/your_training_script.py'
train_instance_type='ml.p2.xlarge'
...
# debugger-specific arguments below
rules = [custom_rule]
)
estimator.fit()
```
Per ulteriori varianti ed esempi avanzati di utilizzo delle regole personalizzate di Debugger, consulta i seguenti notebook di esempio.
+ [Monitora il tuo processo di formazione con le regole personalizzate di Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_keras_custom_rule/tf-keras-custom-rule.html)
+ [PyTorch modello iterativo di potatura di e ResNet AlexNet](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/pytorch_iterative_model_pruning)
+ [Attiva Amazon CloudWatch Events utilizzando le regole del debugger per intraprendere un'azione in base allo stato della formazione con TensorFlow](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-debugger/tensorflow_action_on_rule)
# 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()
```
# Configurazione del debugger tramite l'API SageMaker
Gli argomenti precedenti si concentrano sull'uso di Debugger tramite Amazon SageMaker Python SDK, che è un wrapper per le operazioni API. AWS SDK per Python (Boto3) SageMaker Ciò offre un'esperienza di alto livello di accesso alle operazioni dell' SageMaker API Amazon. Nel caso in cui sia necessario configurare manualmente le operazioni SageMaker API utilizzando AWS Boto3 o ( AWS Command Line Interface CLI) per altri SDKs, come Java, Go e C\$1\$1, questa sezione spiega come configurare le seguenti operazioni API di basso livello.
**Topics**
+ [JSON (AWS CLI)](debugger-built-in-rules-api.CLI.md)
+ [SDK per Python (Boto3)](debugger-built-in-rules-api.Boto3.md)
# JSON (AWS CLI)
Le regole integrate di Amazon SageMaker Debugger possono essere configurate per un processo di formazione utilizzando [DebugHookConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html), [DebugRuleConfiguration[ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html), e [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)oggetti tramite l'operazione SageMaker API AI [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). È necessario specificare l'URI corretto dell'immagine nel `RuleEvaluatorImage` parametro e gli esempi seguenti illustrano come configurare le stringhe JSON da richiedere. [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)
Il codice seguente mostra un modello JSON completo per eseguire un processo di addestramento con le impostazioni e le configurazioni di Debugger richieste. Salva il modello come file JSON nella tua directory di lavoro ed esegui il processo di formazione utilizzando la AWS CLI. Ad esempio, salva il seguente codice come `debugger-training-job-cli.json`
**Nota**
Assicurati di utilizzare le immagini corrette del container Docker. Per trovare le immagini dei AWS Deep Learning Container, consulta Immagini dei [Deep Learning Containers disponibili](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Per trovare un elenco completo delle immagini Docker disponibili per l'utilizzo delle regole di Debugger, consulta [Immagini Docker per le regole di Debugger](debugger-reference.md#debugger-docker-images-rules).
```
{
"TrainingJobName": "debugger-aws-cli-test",
"RoleArn": "arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-YYYYMMDDT123456",
"AlgorithmSpecification": {
// Specify a training Docker container image URI (Deep Learning Container or your own training container) to TrainingImage.
"TrainingImage": "763104351884.dkr.ecr.us-west-2.amazonaws.com/tensorflow-training:2.4.1-gpu-py37-cu110-ubuntu18.04",
"TrainingInputMode": "File",
"EnableSageMakerMetricsTimeSeries": false
},
"HyperParameters": {
"sagemaker_program": "entry_point/tf-hvd-train.py",
"sagemaker_submit_directory": "s3://sagemaker-us-west-2-111122223333/debugger-boto3-profiling-test/source.tar.gz"
},
"OutputDataConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/output"
},
"DebugHookConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/debug-output",
"CollectionConfigurations": [
{
"CollectionName": "losses",
"CollectionParameters" : {
"train.save_interval": "50"
}
}
]
},
"DebugRuleConfigurations": [
{
"RuleConfigurationName": "LossNotDecreasing",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {"rule_to_invoke": "LossNotDecreasing"}
}
],
"ProfilerConfig": {
"S3OutputPath": "s3://sagemaker-us-west-2-111122223333/debugger-aws-cli-test/profiler-output",
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, \"MetricsRegex\": \".*\", }",
"DetailedProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, }",
"PythonProfilingConfig": "{\"StartStep\": 5, \"NumSteps\": 3, \"ProfilerName\": \"cprofile\", \"cProfileTimer\": \"total_time\"}",
"LocalPath": "/opt/ml/output/profiler/"
}
},
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {"rule_to_invoke": "ProfilerReport"}
}
],
"ResourceConfig": {
"InstanceType": "ml.p3.8xlarge",
"InstanceCount": 1,
"VolumeSizeInGB": 30
},
"StoppingCondition": {
"MaxRuntimeInSeconds": 86400
}
}
```
Dopo aver salvato il file JSON, esegui il comando seguente nel terminale. (Usa `!` all'inizio della riga se usi un notebook Jupyter).
```
aws sagemaker create-training-job --cli-input-json file://debugger-training-job-cli.json
```
## Configurazione di una regola di Debugger per il debug dei parametri del modello
I seguenti esempi di codice mostrano come configurare una `VanishingGradient` regola integrata utilizzando questa SageMaker API.
**Per consentire a Debugger di raccogliere tensori di output**
Specifica la configurazione dell’hook Debugger come segue:
```
"DebugHookConfig": {
"S3OutputPath": "s3:////debug-output",
"CollectionConfigurations": [
{
"CollectionName": "gradients",
"CollectionParameters" : {
"save_interval": "500"
}
}
]
}
```
Ciò farà sì che il processo di addestramento salvi la raccolta di tensori, `gradients`, ogni `save_interval` di 500 fasi. Per trovare `CollectionName` i valori disponibili, consulta [Debugger Built-in Collections nella documentazione](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections) della libreria *SMDebug client*. Per trovare le chiavi e i valori dei `CollectionParameters` parametri disponibili, consulta la [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)classe nella documentazione di *SageMaker Python SDK*.
**Per abilitare le regole di Debugger per il debug dei tensori di output**
Il seguente esempio di API `DebugRuleConfigurations` mostra come eseguire la regola `VanishingGradient` integrata nella raccolta `gradients` salvata.
```
"DebugRuleConfigurations": [
{
"RuleConfigurationName": "VanishingGradient",
"RuleEvaluatorImage": "503895931360.dkr.ecr.us-east-1.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "VanishingGradient",
"threshold": "20.0"
}
}
]
```
Con una configurazione come quella in questo esempio, Debugger avvia un processo di valutazione della regola per il processo di addestramento utilizzando la regola `VanishingGradient` nella raccolta del tensore `gradients`. Per trovare un elenco completo delle immagini Docker disponibili per l'utilizzo delle regole di Debugger, consulta [Immagini Docker per le regole di Debugger](debugger-reference.md#debugger-docker-images-rules). Per trovare le coppie chiave-valore per `RuleParameters`, consulta [Elenco delle regole integrate di Debugger](debugger-built-in-rules.md).
## Configurazione di una regola integrata di Debugger per la profilazione dei parametri del sistema e del framework
Il codice di esempio seguente mostra come specificare l'operazione dell' ProfilerConfig API per consentire la raccolta delle metriche del sistema e del framework.
**Per abilitare la profilazione di Debugger per raccogliere i parametri del sistema e del framework**
------
#### [ Target Step ]
```
"ProfilerConfig": {
// Optional. Path to an S3 bucket to save profiling outputs
"S3OutputPath": "s3:////profiler-output",
// Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3, \"MetricsRegex\": \".*\" }",
"DetailedProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3 }",
// For PythonProfilingConfig,
// available ProfilerName options: cProfile, Pyinstrument
// available cProfileTimer options only when using cProfile: cpu, off_cpu, total_time
"PythonProfilingConfig": "{ \"StartStep\": 5, \"NumSteps\": 3, \"ProfilerName\": \"cProfile\", \"cProfileTimer\": \"total_time\" }",
// Optional. Local path for profiling outputs
"LocalPath": "/opt/ml/output/profiler/"
}
}
```
------
#### [ Target Time Duration ]
```
"ProfilerConfig": {
// Optional. Path to an S3 bucket to save profiling outputs
"S3OutputPath": "s3:////profiler-output",
// Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
"ProfilingIntervalInMilliseconds": 500,
"ProfilingParameters": {
"DataloaderProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10, \"MetricsRegex\": \".*\" }",
"DetailedProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10 }",
// For PythonProfilingConfig,
// available ProfilerName options: cProfile, Pyinstrument
// available cProfileTimer options only when using cProfile: cpu, off_cpu, total_time
"PythonProfilingConfig": "{ \"StartTimeInSecSinceEpoch\": 12345567789, \"DurationInSeconds\": 10, \"ProfilerName\": \"cProfile\", \"cProfileTimer\": \"total_time\" }",
// Optional. Local path for profiling outputs
"LocalPath": "/opt/ml/output/profiler/"
}
}
```
------
**Per abilitare le regole di Debugger per la profilazione dei parametri**
Il codice di esempio seguente mostra come configurare la regola `ProfilerReport`.
```
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "ProfilerReport",
"CPUBottleneck_cpu_threshold": "90",
"IOBottleneck_threshold": "90"
}
}
]
```
Per trovare un elenco completo delle immagini Docker disponibili per l'utilizzo delle regole di Debugger, consulta [Immagini Docker per le regole di Debugger](debugger-reference.md#debugger-docker-images-rules). Per trovare le coppie chiave-valore per `RuleParameters`, consulta [Elenco delle regole integrate di Debugger](debugger-built-in-rules.md).
## Aggiornamento della configurazione della profilazione di Debugger utilizzando l’API `UpdateTrainingJob`
La configurazione della profilazione del debugger può essere aggiornata durante l'esecuzione del processo di formazione utilizzando l'operazione API. [UpdateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html) Configura nuovi [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)oggetti [ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)e specifica il nome del processo di formazione nel parametro. `TrainingJobName`
```
{
"ProfilerConfig": {
"DisableProfiler": boolean,
"ProfilingIntervalInMilliseconds": number,
"ProfilingParameters": {
"string" : "string"
}
},
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "string",
"RuleEvaluatorImage": "string",
"RuleParameters": {
"string" : "string"
}
}
],
"TrainingJobName": "your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS"
}
```
## Aggiunta della configurazione delle regole personalizzate di Debugger all’API `CreateTrainingJob`
È possibile configurare una regola personalizzata per un processo di formazione utilizzando gli [ DebugRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)oggetti [ DebugHookConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)e nell'operazione [ CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API. Il seguente esempio di codice mostra come configurare una `ImproperActivation` regola personalizzata scritta con la libreria *smdebug* utilizzando questa operazione SageMaker API. In questo esempio si presuppone che la regola personalizzata sia stata scritta nel file *custom\$1rules.py* e che sia stata caricata in un bucket Amazon S3. Nell'esempio vengono fornite immagini Docker predefinite che puoi utilizzare per eseguire le regole personalizzate. Queste immagini sono elencate in [Immagine Amazon SageMaker Debugger URIs per valutatori di regole personalizzati](debugger-reference.md#debuger-custom-rule-registry-ids). Specifica l'indirizzo del registro di URL per l'immagine Docker integrata nel parametro `RuleEvaluatorImage`.
```
"DebugHookConfig": {
"S3OutputPath": "s3:////debug-output",
"CollectionConfigurations": [
{
"CollectionName": "relu_activations",
"CollectionParameters": {
"include_regex": "relu",
"save_interval": "500",
"end_step": "5000"
}
}
]
},
"DebugRulesConfigurations": [
{
"RuleConfigurationName": "improper_activation_job",
"RuleEvaluatorImage": "552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest",
"InstanceType": "ml.c4.xlarge",
"VolumeSizeInGB": 400,
"RuleParameters": {
"source_s3_uri": "s3://bucket/custom_rules.py",
"rule_to_invoke": "ImproperActivation",
"collection_names": "relu_activations"
}
}
]
```
Per trovare un elenco completo delle immagini Docker disponibili per l'utilizzo delle regole di Debugger, consulta [Immagini Docker per le regole di Debugger](debugger-reference.md#debugger-docker-images-rules). Per trovare le coppie chiave-valore per `RuleParameters`, consulta [Elenco delle regole integrate di Debugger](debugger-built-in-rules.md).
# SDK per Python (Boto3)
Le regole integrate di Amazon SageMaker Debugger possono essere configurate per un lavoro di formazione utilizzando la [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job)funzione del client AI AWS SageMaker Boto3. È necessario specificare l'URI corretto dell'immagine nel parametro `RuleEvaluatorImage` e gli esempi seguenti illustrano come configurare il corpo della richiesta per la funzione [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job).
Il codice seguente mostra un esempio completo di come configurare Debugger per il corpo della `create_training_job()` richiesta e avviare un processo di formazione in`us-west-2`, presupponendo che uno script di formazione sia preparato utilizzando. `entry_point/train.py` TensorFlow Per trovare un notebook di end-to-end esempio, consulta [Profiling TensorFlow Multi GPU Multi Node Training Job with Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/tensorflow_profiling/tf-resnet-profiling-multi-gpu-multi-node-boto3.html) (Boto3).
**Nota**
Assicurati di utilizzare le immagini corrette del container Docker. Per trovare le immagini disponibili dei AWS Deep Learning Container, consulta Immagini [disponibili dei Deep Learning Containers](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Per trovare un elenco completo delle immagini Docker disponibili per l'utilizzo delle regole di Debugger, consulta [Immagini Docker per le regole di Debugger](debugger-reference.md#debugger-docker-images-rules).
```
import sagemaker, boto3
import datetime, tarfile
# Start setting up a SageMaker session and a Boto3 SageMaker client
session = sagemaker.Session()
region = session.boto_region_name
bucket = session.default_bucket()
# Upload a training script to a default Amazon S3 bucket of the current SageMaker session
source = 'source.tar.gz'
project = 'debugger-boto3-test'
tar = tarfile.open(source, 'w:gz')
tar.add ('entry_point/train.py') # Specify the directory and name of your training script
tar.close()
s3 = boto3.client('s3')
s3.upload_file(source, bucket, project+'/'+source)
# Set up a Boto3 session client for SageMaker
sm = boto3.Session(region_name=region).client("sagemaker")
# Start a training job
sm.create_training_job(
TrainingJobName='debugger-boto3-'+datetime.datetime.now().strftime('%Y-%m-%d-%H-%M-%S'),
HyperParameters={
'sagemaker_submit_directory': 's3://'+bucket+'/'+project+'/'+source,
'sagemaker_program': '/entry_point/train.py' # training scrip file location and name under the sagemaker_submit_directory
},
AlgorithmSpecification={
# Specify a training Docker container image URI (Deep Learning Container or your own training container) to TrainingImage.
'TrainingImage': '763104351884.dkr.ecr.us-west-2.amazonaws.com/tensorflow-training:2.4.1-gpu-py37-cu110-ubuntu18.04',
'TrainingInputMode': 'File',
'EnableSageMakerMetricsTimeSeries': False
},
RoleArn='arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20201014T161125',
OutputDataConfig={'S3OutputPath': 's3://'+bucket+'/'+project+'/output'},
ResourceConfig={
'InstanceType': 'ml.p3.8xlarge',
'InstanceCount': 1,
'VolumeSizeInGB': 30
},
StoppingCondition={
'MaxRuntimeInSeconds': 86400
},
DebugHookConfig={
'S3OutputPath': 's3://'+bucket+'/'+project+'/debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'losses',
'CollectionParameters' : {
'train.save_interval': '500',
'eval.save_interval': '50'
}
}
]
},
DebugRuleConfigurations=[
{
'RuleConfigurationName': 'LossNotDecreasing',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {'rule_to_invoke': 'LossNotDecreasing'}
}
],
ProfilerConfig={
'S3OutputPath': 's3://'+bucket+'/'+project+'/profiler-output',
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{"StartStep": 5, "NumSteps": 3, "MetricsRegex": ".*", }',
'DetailedProfilingConfig': '{"StartStep": 5, "NumSteps": 3, }',
'PythonProfilingConfig': '{"StartStep": 5, "NumSteps": 3, "ProfilerName": "cprofile", "cProfileTimer": "total_time"}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
},
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {'rule_to_invoke': 'ProfilerReport'}
}
]
)
```
## Configurazione di una regola di Debugger per il debug dei parametri del modello
I seguenti esempi di codice mostrano come configurare una `VanishingGradient` regola integrata utilizzando questa SageMaker API.
**Per consentire a Debugger di raccogliere tensori di output**
Specifica la configurazione dell’hook Debugger come segue:
```
DebugHookConfig={
'S3OutputPath': 's3:////debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'gradients',
'CollectionParameters' : {
'train.save_interval': '500',
'eval.save_interval': '50'
}
}
]
}
```
Ciò farà sì che il processo di addestramento salvi la raccolta di tensori, `gradients`, ogni `save_interval` di 500 fasi. Per trovare `CollectionName` i valori disponibili, consulta [Debugger Built-in Collections nella documentazione](https://github.com/awslabs/sagemaker-debugger/blob/master/docs/api.md#built-in-collections) della libreria *SMDebug client*. Per trovare le chiavi e i valori dei `CollectionParameters` parametri disponibili, consulta la [https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.CollectionConfig)classe nella documentazione di *SageMaker Python SDK*.
**Per abilitare le regole di Debugger per il debug dei tensori di output**
Il seguente esempio di API `DebugRuleConfigurations` mostra come eseguire la regola `VanishingGradient` integrata nella raccolta `gradients` salvata.
```
DebugRuleConfigurations=[
{
'RuleConfigurationName': 'VanishingGradient',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'VanishingGradient',
'threshold': '20.0'
}
}
]
```
Con una configurazione come quella in questo esempio, Debugger avvia un processo di valutazione della regola per il processo di addestramento utilizzando la regola `VanishingGradient` nella raccolta del tensore `gradients`. Per trovare un elenco completo delle immagini Docker disponibili per l'utilizzo delle regole di Debugger, consulta [Immagini Docker per le regole di Debugger](debugger-reference.md#debugger-docker-images-rules). Per trovare le coppie chiave-valore per `RuleParameters`, consulta [Elenco delle regole integrate di Debugger](debugger-built-in-rules.md).
## Configurazione di una regola integrata di Debugger per la profilazione dei parametri del sistema e del framework
Il codice di esempio seguente mostra come specificare l'operazione dell' ProfilerConfig API per consentire la raccolta delle metriche del sistema e del framework.
**Per abilitare la profilazione di Debugger per raccogliere i parametri del sistema e del framework**
------
#### [ Target Step ]
```
ProfilerConfig={
'S3OutputPath': 's3:////profiler-output', # Optional. Path to an S3 bucket to save profiling outputs
# Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3,
"MetricsRegex": ".*"
}',
'DetailedProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3
}',
'PythonProfilingConfig': '{
"StartStep": 5,
"NumSteps": 3,
"ProfilerName": "cprofile", # Available options: cprofile, pyinstrument
"cProfileTimer": "total_time" # Include only when using cprofile. Available options: cpu, off_cpu, total_time
}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
}
```
------
#### [ Target Time Duration ]
```
ProfilerConfig={
'S3OutputPath': 's3:////profiler-output', # Optional. Path to an S3 bucket to save profiling outputs
# Available values for ProfilingIntervalInMilliseconds: 100, 200, 500, 1000 (1 second), 5000 (5 seconds), and 60000 (1 minute) milliseconds.
'ProfilingIntervalInMilliseconds': 500,
'ProfilingParameters': {
'DataloaderProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10,
"MetricsRegex": ".*"
}',
'DetailedProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10
}',
'PythonProfilingConfig': '{
"StartTimeInSecSinceEpoch": 12345567789,
"DurationInSeconds": 10,
"ProfilerName": "cprofile", # Available options: cprofile, pyinstrument
"cProfileTimer": "total_time" # Include only when using cprofile. Available options: cpu, off_cpu, total_time
}',
'LocalPath': '/opt/ml/output/profiler/' # Optional. Local path for profiling outputs
}
}
```
------
**Per abilitare le regole di Debugger per la profilazione dei parametri**
Il codice di esempio seguente mostra come configurare la regola `ProfilerReport`.
```
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'ProfilerReport',
'CPUBottleneck_cpu_threshold': '90',
'IOBottleneck_threshold': '90'
}
}
]
```
Per trovare un elenco completo delle immagini Docker disponibili per l'utilizzo delle regole di Debugger, consulta [Immagini Docker per le regole di Debugger](debugger-reference.md#debugger-docker-images-rules). Per trovare le coppie chiave-valore per `RuleParameters`, consulta [Elenco delle regole integrate di Debugger](debugger-built-in-rules.md).
## Aggiorna la configurazione della profilazione di Debugger utilizzando l'operazione API `UpdateTrainingJob`
La configurazione della profilazione del debugger può essere aggiornata durante l'esecuzione del processo di formazione utilizzando la [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.update_training_job)funzione del client AI Boto3. AWS SageMaker Configura nuovi [ProfilerRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)oggetti [ProfilerConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)e specifica il nome del processo di formazione nel parametro. `TrainingJobName`
```
ProfilerConfig={
'DisableProfiler': boolean,
'ProfilingIntervalInMilliseconds': number,
'ProfilingParameters': {
'string' : 'string'
}
},
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'string',
'RuleEvaluatorImage': 'string',
'RuleParameters': {
'string' : 'string'
}
}
],
TrainingJobName='your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS'
```
## Aggiungi la configurazione delle regole personalizzate del debugger all'operazione API CreateTrainingJob
È possibile configurare una regola personalizzata per un lavoro di formazione utilizzando [ DebugRuleConfiguration](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)gli oggetti [ DebugHookConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)e utilizzando la funzione del client AWS Boto3 SageMaker AI. [https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job) Il seguente esempio di codice mostra come configurare una `ImproperActivation` regola personalizzata scritta con la libreria *smdebug* utilizzando questa operazione API. SageMaker In questo esempio si presuppone che la regola personalizzata sia stata scritta nel file *custom\$1rules.py* e che sia stata caricata in un bucket Amazon S3. Nell'esempio vengono fornite immagini Docker predefinite che puoi utilizzare per eseguire le regole personalizzate. Queste immagini sono elencate in [Immagine Amazon SageMaker Debugger URIs per valutatori di regole personalizzati](debugger-reference.md#debuger-custom-rule-registry-ids). Specifica l'indirizzo del registro di URL per l'immagine Docker integrata nel parametro `RuleEvaluatorImage`.
```
DebugHookConfig={
'S3OutputPath': 's3:////debug-output',
'CollectionConfigurations': [
{
'CollectionName': 'relu_activations',
'CollectionParameters': {
'include_regex': 'relu',
'save_interval': '500',
'end_step': '5000'
}
}
]
},
DebugRulesConfigurations=[
{
'RuleConfigurationName': 'improper_activation_job',
'RuleEvaluatorImage': '552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest',
'InstanceType': 'ml.c4.xlarge',
'VolumeSizeInGB': 400,
'RuleParameters': {
'source_s3_uri': 's3://bucket/custom_rules.py',
'rule_to_invoke': 'ImproperActivation',
'collection_names': 'relu_activations'
}
}
]
```
Per trovare un elenco completo delle immagini Docker disponibili per l'utilizzo delle regole di Debugger, consulta [Immagini Docker per le regole di Debugger](debugger-reference.md#debugger-docker-images-rules). Per trovare le coppie chiave-valore per `RuleParameters`, consulta [Elenco delle regole integrate di Debugger](debugger-built-in-rules.md).
# Riferimenti Amazon SageMaker Debugger
Trova ulteriori informazioni e riferimenti sull'uso di Amazon SageMaker Debugger nei seguenti argomenti.
**Topics**
+ [Amazon SageMaker Debugger APIs](#debugger-apis)
+ [Immagini Docker per le regole di Debugger](#debugger-docker-images-rules)
+ [Eccezioni di Amazon SageMaker Debugger](#debugger-exceptions)
+ [Formazione distribuita supportata da Amazon SageMaker Debugger](#debugger-considerations)
## Amazon SageMaker Debugger APIs
Amazon SageMaker Debugger dispone di operazioni API in diverse località che vengono utilizzate per implementare il monitoraggio e l'analisi dell'addestramento dei modelli.
Amazon SageMaker Debugger fornisce anche l'[SDK `sagemaker-debugger` Python](https://github.com/awslabs/sagemaker-debugger/tree/master/smdebug) open source che viene utilizzato per configurare regole integrate, definire regole personalizzate e registrare hook per raccogliere dati tensoriali di output dai lavori di formazione.
L'[Amazon SageMaker AI Python SDK è un SDK](https://sagemaker.readthedocs.io/en/stable/) di alto livello incentrato sulla sperimentazione dell'apprendimento automatico. L'SDK può essere utilizzato per implementare regole integrate o personalizzate definite con la libreria `SMDebug` Python per monitorare e analizzare questi tensori utilizzando stimatori AI. SageMaker
Debugger ha aggiunto operazioni e tipi all' SageMaker API Amazon che consentono alla piattaforma di utilizzare Debugger durante l'addestramento di un modello e di gestire la configurazione di input e output.
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)e [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateTrainingJob.html)usa il seguente Debugger per configurare raccolte di tensori, regole, immagini di regole e opzioni APIs di profilazione:
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CollectionConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CollectionConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TensorBoardOutputConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TensorBoardOutputConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeTrainingJob.html) fornisce una descrizione completa di un processo di addestramento, incluse le seguenti configurazioni di Debugger e gli stati di valutazione delle regole:
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugHookConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleEvaluationStatus.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DebugRuleEvaluationStatus.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerConfig.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleConfiguration.html)
+ [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleEvaluationStatus.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ProfilerRuleEvaluationStatus.html)
Le operazioni dell'API di configurazione delle regole utilizzano la funzionalità di SageMaker elaborazione durante l'analisi dell'addestramento di un modello. Per ulteriori informazioni sull' SageMaker elaborazione, vedere[Carichi di lavoro di trasformazione dei dati con Processing SageMaker](processing-job.md).
## Immagini Docker per le regole di Debugger
Amazon SageMaker AI fornisce due set di immagini Docker per le regole: un set per la valutazione delle regole fornite dall' SageMaker IA (regole integrate) e un set per la valutazione delle regole personalizzate fornite nei file sorgente Python.
Se utilizzi l'[SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable), puoi semplicemente utilizzare le operazioni dell'API Debugger di alto livello SageMaker AI con le operazioni dell'API SageMaker AI Estimator, senza dover recuperare manualmente le immagini Docker del Debugger e configurare l'API. `ConfigureTrainingJob`
Se non si utilizza l'SDK SageMaker Python, è necessario recuperare un'immagine base del contenitore precostruita pertinente per le regole del Debugger. Amazon SageMaker Debugger fornisce immagini Docker predefinite per regole integrate e personalizzate e le immagini vengono archiviate in Amazon Elastic Container Registry (Amazon ECR). Per estrarre un'immagine da un repository Amazon ECR (o per inviare un'immagine a uno di essi), utilizza l'URL completo del registro dell'immagine utilizzando l'`CreateTrainingJob`API. SageMaker L'intelligenza artificiale utilizza i seguenti modelli di URL per l'indirizzo del registro delle immagini del contenitore di regole Debugger.
```
.dkr.ecr..amazonaws.com/:
```
Per l'ID dell'account in ogni AWS regione, il nome del repository Amazon ECR e il valore del tag, consulta i seguenti argomenti.
**Topics**
+ [Immagine Amazon SageMaker Debugger URIs per valutatori di regole integrati](#debuger-built-in-registry-ids)
+ [Immagine Amazon SageMaker Debugger URIs per valutatori di regole personalizzati](#debuger-custom-rule-registry-ids)
### Immagine Amazon SageMaker Debugger URIs per valutatori di regole integrati
Utilizza i seguenti valori per i componenti del registro URLs per le immagini che forniscono regole integrate per Amazon SageMaker Debugger. Per informazioni sull'account IDs, consulta la tabella seguente.
Nome del **repository ECR**: sagemaker-debugger-rules
**Tag**: ultimo
**Esempio di URL del Registro completo**:
`904829902805.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rules:latest`
Account IDs per le immagini del contenitore di regole integrate per regione AWS
| Region | account\$1id |
| --- | --- |
| af-south-1 | 314341159256 |
| ap-east-1 | 199566480951 |
| ap-northeast-1 | 430734990657 |
| ap-northeast-2 | 578805364391 |
| ap-south-1 | 904829902805 |
| ap-southeast-1 | 972752614525 |
| ap-southeast-2 | 184798709955 |
| ca-central-1 | 519511493484 |
| cn-north-1 | 618459771430 |
| cn-northwest-1 | 658757709296 |
| eu-central-1 | 482524230118 |
| eu-north-1 | 314864569078 |
| eu-south-1 | 563282790590 |
| eu-west-1 | 929884845733 |
| eu-west-2 | 250201462417 |
| eu-west-3 | 447278800020 |
| me-south-1 | 986000313247 |
| sa-east-1 | 818342061345 |
| us-east-1 | 503895931360 |
| us-east-2 | 915447279597 |
| us-west-1 | 685455198987 |
| us-west-2 | 895741380848 |
| us-gov-west-1 | 515509971035 |
### Immagine Amazon SageMaker Debugger URIs per valutatori di regole personalizzati
Utilizza i seguenti valori per i componenti dell'URL del registro per le immagini che forniscono valutatori di regole personalizzati per Amazon SageMaker Debugger. Per informazioni sull'account IDs, consulta la tabella seguente.
Nome del **repository ECR**: sagemaker-debugger-rule-evaluator
**Tag**: ultimo
**Esempio di URL del Registro completo**:
`552407032007.dkr.ecr.ap-south-1.amazonaws.com/sagemaker-debugger-rule-evaluator:latest`
Account IDs per le immagini del contenitore Custom Rules per regione AWS
| Region | account\$1id |
| --- | --- |
| af-south-1 | 515950693465 |
| ap-east-1 | 645844755771 |
| ap-northeast-1 | 670969264625 |
| ap-northeast-2 | 326368420253 |
| ap-south-1 | 552407032007 |
| ap-southeast-1 | 631532610101 |
| ap-southeast-2 | 445670767460 |
| ca-central-1 | 105842248657 |
| cn-north-1 | 617202126805 |
| cn-northwest-1 | 658559488188 |
| eu-central-1 | 691764027602 |
| eu-north-1 | 091235270104 |
| eu-south-1 | 335033873580 |
| eu-west-1 | 606966180310 |
| eu-west-2 | 074613877050 |
| eu-west-3 | 224335253976 |
| me-south-1 | 050406412588 |
| sa-east-1 | 466516958431 |
| us-east-1 | 864354269164 |
| us-east-2 | 840043622174 |
| us-west-1 | 952348334681 |
| us-west-2 | 759209512951 |
| us-gov-west-1 | 515361955729 |
## Eccezioni di Amazon SageMaker Debugger
Amazon SageMaker Debugger è progettato per tenere conto del fatto che i tensori necessari per eseguire una regola potrebbero non essere disponibili in ogni fase. Quindi genera alcune eccezioni che ti permettono di controllare cosa succede quando manca un tensore. Queste eccezioni sono disponibili nel [modulo smdebug.exceptions](https://github.com/awslabs/sagemaker-debugger/blob/master/smdebug/exceptions.py). È possibile importarle come segue:
```
from smdebug.exceptions import *
```
Sono disponibili le seguenti eccezioni:
+ `TensorUnavailableForStep` – il tensore richiesto non è disponibile per la fase. Questo potrebbe significare che questa fase potrebbe non essere salvata dall'hook o che questa fase potrebbe aver salvato alcuni tensori ma il tensore richiesto non è parte di essi. Si noti che in presenza di questa eccezione, il questo tensore non può mai diventare disponibile per questa fase in futuro. Se il tensore ha delle riduzioni salvate per la fase, ti avviserà che possono sottoposte a query.
+ `TensorUnavailable` – questo tensore non viene salvato o non è stato salvato dall'API `smdebug`. Ciò significa che questo tensore non viene mai visto per nessuna fase in `smdebug`.
+ `StepUnavailable` – la fase non è stata salvata e Debugger non ha ricevuto dati dalla fase.
+ `StepNotYetAvailable` – la fase non è stata ancora visualizzata da `smdebug`. Potrebbe essere disponibile in futuro se l’addestramento è ancora in corso. Debugger carica automaticamente i nuovi dati quando disponibili.
+ `NoMoreData` – generata alla fine dell’addestramento. Quando viene visualizzata questa eccezione, non ci sono più fasi e non ci sono più tensori da salvare.
+ `IndexReaderException` – il lettore dell'indice non è valido.
+ `InvalidWorker` – è stato richiamato un worker che non era valido.
+ `RuleEvaluationConditionMet` – la valutazione della regola durante la fase ha portato al soddisfacimento della condizione.
+ `InsufficientInformationForRuleInvocation` – sono state fornite informazioni insufficienti per richiamare la regola.
## Formazione distribuita supportata da Amazon SageMaker Debugger
L'elenco seguente mostra l'ambito di validità e le considerazioni per l'utilizzo di Debugger in processi di addestramento con framework di deep learning e varie opzioni di addestramento distribuito.
+ **Horovod**
Ambito di validità dell'utilizzo di Debugger per processi di addestramento con Horovod
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-reference.html)
+ **SageMaker Dati distribuiti AI in parallelo**
Ambito di validità dell'utilizzo di Debugger per lavori di formazione con dati distribuiti paralleli di SageMaker intelligenza artificiale
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-reference.html)
\$1 Debugger non supporta la profilazione del framework per 2.x. TensorFlow
\$1\$1 SageMaker AI distributed data parallel non supporta TensorFlow 2.x con l'implementazione Keras.
+ **SageMaker Modello parallelo distribuito AI**: Debugger non supporta l'addestramento parallelo su modelli distribuiti SageMaker AI.
+ **Formazione distribuita con checkpoint SageMaker AI**: Debugger non è disponibile per i lavori di formazione quando sono abilitati sia l'opzione di formazione distribuita che i checkpoint AI. SageMaker È possibile che venga visualizzato un errore simile al seguente:
```
SMDebug Does Not Currently Support Distributed Training Jobs With Checkpointing Enabled
```
Per utilizzare Debugger per lavori di formazione con opzioni di formazione distribuite, devi disabilitare il checkpointing SageMaker AI e aggiungere funzioni di checkpoint manuali allo script di addestramento. Per ulteriori informazioni sull'uso di Debugger con opzioni di addestramento e checkpoint distribuiti, consulta [Utilizzo di dati distribuiti SageMaker AI in parallelo con Amazon SageMaker Debugger e checkpoint](distributed-troubleshooting-data-parallel.md#distributed-ts-data-parallel-debugger) e [Salvataggio dei checkpoint](distributed-troubleshooting-model-parallel.md#distributed-ts-model-parallel-checkpoints).
+ **Server di parametri**: Debugger non supporta l'addestramento distribuito basato su server di parametri.
+ La profilazione delle operazioni del framework di formazione distribuito, come il `AllReduced` funzionamento parallelo dei dati distribuiti di SageMaker intelligenza artificiale e [le operazioni Horovod](https://horovod.readthedocs.io/en/stable/timeline_include.html), non è disponibile.