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à.
# 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).