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à.
# Monitoraggio dell’utilizzo delle risorse di calcolo AWS in Amazon SageMaker Studio Classic
Per tenere traccia dell'utilizzo delle risorse di calcolo del tuo processo di addestramento, utilizza gli strumenti di monitoraggio offerti da Debugger Amazon SageMaker.
Per ogni job di addestramento eseguito in SageMaker AI utilizzando SageMaker Python SDK, Debugger raccoglie le metriche di base sull’utilizzo delle risorse, come l’utilizzo della CPU, della GPU, della memoria GPU, la rete e il tempo di attesa I/O ogni 500 millisecondi. Per visualizzare la dashboard dei parametri di utilizzo delle risorse del tuo processo di addestramento, usa semplicemente [l'interfaccia utente di Debugger SageMaker in Esperimenti di SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html).
Le operazioni e le fasi di deep learning potrebbero funzionare a intervalli di millisecondi. Rispetto ai parametri di Amazon CloudWatch, che raccolgono i parametri a intervalli di 1 secondo, Debugger offre una granularità più precisa dei parametri di utilizzo delle risorse, fino a intervalli di 100 millisecondi (0,1 secondi), in modo da poter approfondire i parametri a livello di operazione o fase.
Se desideri modificare l'intervallo di tempo della raccolta di parametri, puoi aggiungere un parametro per la configurazione della profilazione all’utilità di avvio del processo di addestramento. Ad esempio, se utilizzi SageMaker AI Python SDK, quando crei un oggetto dello strumento di stima devi inoltrare il parametro `profiler_config`. Per informazioni su come regolare l'intervallo di raccolta dei parametri di utilizzo delle risorse, consulta [Modello di codice per la configurazione di un oggetto SageMaker AI estimator con i moduli SageMaker Debugger Python nell'SDK AI Python SageMaker](debugger-configuration-for-profiling.md#debugger-configuration-structure-profiler) e poi [Configurazione delle impostazioni per la profilazione di base dell'utilizzo delle risorse di sistema](debugger-configure-system-monitoring.md).
Inoltre, puoi aggiungere strumenti di rilevamento dei problemi denominati *regole di profilazione integrate* e forniti da Debugger SageMaker. Le regole di profilazione integrate eseguono analisi rispetto ai parametri di utilizzo delle risorse e rilevano eventuali problemi alle prestazioni di calcolo. Per ulteriori informazioni, consulta [Usa le regole di profilazione integrate gestite da Amazon SageMaker Debugger](use-debugger-built-in-profiler-rules.md). Puoi ricevere i risultati delle analisi delle regole tramite [l’interfaccia utente di Debugger SageMaker in Esperimenti di SageMaker Studio](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html) o [il report di profilazione di Debugger SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html). Inoltre puoi creare regole di profilazione personalizzate utilizzando l’SDK Python SageMaker.
Per ulteriori informazioni sulle funzionalità di monitoraggio fornite da Debugger SageMaker, consulta i seguenti argomenti.
**Topics**
+ [Configurazione di Estimator con parametri per la profilazione di base utilizzando i moduli Amazon SageMaker Debugger Python](debugger-configuration-for-profiling.md)
+ [Usa le regole di profilazione integrate gestite da Amazon SageMaker Debugger](use-debugger-built-in-profiler-rules.md)
+ [Elenco delle regole del profiler integrate di Debugger](debugger-built-in-profiler-rules.md)
+ [Esperimenti dell'interfaccia utente di Amazon SageMaker Debugger in Amazon Studio Classic SageMaker](debugger-on-studio.md)
+ [SageMaker Report interattivo del debugger](debugger-profiling-report.md)
+ [Analizza i dati utilizzando la libreria client Python di Debugger](debugger-analyze-data.md)
# Configurazione di Estimator con parametri per la profilazione di base utilizzando i moduli Amazon SageMaker Debugger Python
[Per impostazione predefinita, la profilazione di base di SageMaker Debugger è attiva per impostazione predefinita e monitora i parametri di utilizzo delle risorse, come l'utilizzo della CPU, l'utilizzo della GPU, l'utilizzo della memoria GPU, la rete e il tempo di attesa I/O, di tutti i lavori di formazione inviati utilizzando Amazon Python SDK. SageMaker SageMaker ](https://sagemaker.readthedocs.io/en/stable) SageMaker Debugger raccoglie questi parametri di utilizzo delle risorse ogni 500 millisecondi. Non è necessario apportare ulteriori modifiche al codice, allo script di addestramento o all’utilità di avvio del processo per tenere traccia dell'utilizzo di base delle risorse. Se desideri modificare l'intervallo di raccolta delle metriche per la profilazione di base, puoi specificare parametri specifici del Debugger durante la creazione di un training SageMaker job launcher utilizzando Python SDK o (CLI). SageMaker AWS SDK per Python (Boto3) AWS Command Line Interface In questa guida, ci concentriamo su come modificare le opzioni di profilazione utilizzando l'SDK [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable). Questa pagina fornisce modelli di riferimento per la configurazione di questo oggetto di stima.
Se desideri accedere alla dashboard delle metriche sull'utilizzo delle risorse del tuo lavoro di formazione in SageMaker Studio, puoi passare al. [Esperimenti dell'interfaccia utente di Amazon SageMaker Debugger in Amazon Studio Classic SageMaker](debugger-on-studio.md)
Se desideri attivare automaticamente le regole che rilevano automaticamente i problemi di utilizzo delle risorse di sistema, puoi aggiungere il parametro `rules` nell'oggetto dello strumento di valutazione per l'attivazione delle regole.
**Importante**
Per utilizzare le funzionalità più recenti di SageMaker 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)
```
## Modello di codice per la configurazione di un oggetto SageMaker AI estimator con i moduli SageMaker Debugger Python nell'SDK AI Python SageMaker
Per modificare la configurazione di base della profilazione (`profiler_config`) o aggiungere le regole del profiler (`rules`), scegli una delle schede per ottenere il modello per configurare uno stimatore AI. SageMaker Nelle pagine successive, puoi trovare ulteriori informazioni su come configurare i due parametri.
**Nota**
I seguenti esempi di codice non sono direttamente eseguibili. Passa alle sezioni successive per scoprire come configurare ogni parametro.
------
#### [ PyTorch ]
```
# An example of constructing a SageMaker AI PyTorch estimator
import boto3
import sagemaker
from sagemaker.pytorch import PyTorch
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
session=boto3.session.Session()
region=session.region_name
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=PyTorch(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.12.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_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 ProfilerConfig, ProfilerRule, rule_configs
session=boto3.session.Session()
region=session.region_name
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=TensorFlow(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="2.8.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_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 ProfilerConfig, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=MXNet(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.7.0",
py_version="py37",
# SageMaker Debugger parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
**Nota**
Infatti MXNet, quando si configura il `profiler_config` parametro, è possibile configurarlo solo per il monitoraggio del sistema. Le metriche del framework di profilazione non sono supportate per. MXNet
------
#### [ XGBoost ]
```
# An example of constructing a SageMaker AI XGBoost estimator
import sagemaker
from sagemaker.xgboost.estimator import XGBoost
from sagemaker.debugger import ProfilerConfig, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
estimator=XGBoost(
entry_point="directory/to/your_training_script.py",
role=sagemaker.get_execution_role(),
base_job_name="debugger-profiling-demo",
instance_count=1,
instance_type="ml.p3.2xlarge",
framework_version="1.5-1",
# Debugger-specific parameters
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
**Nota**
Infatti XGBoost, quando si configura il `profiler_config` parametro, è possibile configurarlo solo per il monitoraggio del sistema. Le metriche del framework di profilazione non sono supportate per. XGBoost
------
#### [ 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 ProfilerConfig, DebuggerHookConfig, Rule, ProfilerRule, rule_configs
profiler_config=ProfilerConfig(...)
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInRule())
]
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
profiler_config=profiler_config,
rules=rules
)
estimator.fit(wait=False)
```
------
Di seguito vengono fornite brevi descrizioni dei parametri.
+ `profiler_config`— Configura Debugger per raccogliere i parametri di sistema e i parametri del framework dal processo di addestramento e salvarli nell'URI del bucket S3 protetto o nel computer locale. Puoi impostare la frequenza o la frequenza di raccolta dei parametri di sistema. Per informazioni su come configurare il parametro `profiler_config`, consulta [Configurazione delle impostazioni per la profilazione di base dell'utilizzo delle risorse di sistema](debugger-configure-system-monitoring.md) e [Configurazione di uno strumento di stima per la profilazione del framework](debugger-configure-framework-profiling.md).
+ `rules`— Configurare questo parametro per attivare le regole integrate del SageMaker Debugger che si desidera eseguire in parallelo. Assicurati che il tuo processo di addestramento abbia accesso a questo bucket S3. Le regole si basano sui container di elaborazione e analizzano automaticamente il processo di addestramento per individuare problemi di prestazioni computazionali e operative. La regola [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report) è la regola più integrata che esegue tutte le regole di profilazione integrate e salva i risultati della profilazione come report nel tuo bucket S3 protetto. Per informazioni su come configurare il parametro `rules`, consulta [Usa le regole di profilazione integrate gestite da Amazon SageMaker Debugger](use-debugger-built-in-profiler-rules.md).
**Nota**
Debugger salva in modo sicuro i dati di output nelle sottocartelle del bucket S3 predefinito. Ad esempio, il formato dell'URI del bucket S3 predefinito è `s3://sagemaker--<12digit_account_id>///`. Esistono tre sottocartelle create da Debugger: `debug-output`, `profiler-output` e `rule-output`. [Puoi anche recuperare il bucket URIs S3 predefinito utilizzando i metodi della classe AI estimator. SageMaker ](debugger-estimator-classmethods.md)
Consulta i seguenti argomenti per scoprire come configurare in dettaglio i parametri specifici di Debugger.
**Topics**
+ [Modello di codice per la configurazione di un oggetto SageMaker AI estimator con i moduli SageMaker Debugger Python nell'SDK AI Python SageMaker](#debugger-configuration-structure-profiler)
+ [Configurazione delle impostazioni per la profilazione di base dell'utilizzo delle risorse di sistema](debugger-configure-system-monitoring.md)
+ [Configurazione di uno strumento di stima per la profilazione del framework](debugger-configure-framework-profiling.md)
+ [Aggiornamento del monitoraggio del sistema di Debugger e della configurazione della profilazione del framework durante l'esecuzione di un processo di addestramento](debugger-update-monitoring-profiling.md)
+ [Disattivazione di Debugger](debugger-turn-off-profiling.md)
# Configurazione delle impostazioni per la profilazione di base dell'utilizzo delle risorse di sistema
Per regolare l'intervallo di tempo per la raccolta delle metriche di utilizzo, utilizza l'operazione `ProfilerConfig` API per creare un oggetto parametrico mentre costruisci un framework di intelligenza artificiale o uno stimatore generico, a seconda delle tue preferenze. SageMaker
**Nota**
Per impostazione predefinita, per tutti i lavori di SageMaker formazione, Debugger raccoglie i parametri di utilizzo delle risorse dalle istanze Amazon EC2 ogni 500 millisecondi per il monitoraggio del sistema, senza parametri specifici del Debugger specificati negli stimatori AI. SageMaker
Debugger salva i parametri di sistema nel bucket S3 predefinito. Il formato dell'URI del bucket S3 predefinito è `s3://sagemaker--<12digit_account_id>//profiler-output/`.
L'esempio di codice seguente mostra come impostare il parametro `profiler_config` con un intervallo di tempo di monitoraggio del sistema di 1000 millisecondi.
```
from sagemaker.debugger import ProfilerConfig
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000
)
```
+ `system_monitor_interval_millis` (int) — Specifica gli intervalli di monitoraggio in millisecondi per registrare le metriche di sistema. I valori disponibili sono 100, 200, 500, 1000 (1 secondo), 5000 (5 secondi) e 60000 (1 minuto) millisecondi. Il valore predefinito è 500 millisecondi.
Per vedere lo stato di avanzamento del monitoraggio del sistema, consulta [Apri il pannello di controllo di Amazon SageMaker Debugger Insights](debugger-on-studio-insights.md)
# Configurazione di uno strumento di stima per la profilazione del framework
**avvertimento**
A favore di [Amazon SageMaker Profiler, SageMaker AI Debugger depreca la funzionalità di profilazione](train-use-sagemaker-profiler.md) del framework a partire dalla versione 2.11 e 2.0. TensorFlow PyTorch Puoi comunque utilizzare la funzionalità nelle versioni precedenti dei framework e come segue. SDKs
SageMaker Python SDK <= v2.130.0
PyTorch >= v1.6.0, < v2.0
TensorFlow >= v2.3.1, < v2.1
Consulta anche [16 marzo 2023](debugger-release-notes.md#debugger-release-notes-20230315).
Per abilitare la profilazione del framework di Debugger, configura il parametro quando costruisci uno strumento di valutazione `framework_profile_params`. La profilazione del framework di Debugger raccoglie i parametri del framework, come i dati della fase di inizializzazione, i processi di caricamento dei dati, gli operatori Python dei framework di deep learning e gli script di addestramento, la profilazione dettagliata all'interno e tra le fasi, con le opzioni cProfile o Pyinstrument. Utilizzando la classe `FrameworkProfile`, è possibile configurare opzioni di profilazione del framework personalizzate.
**Nota**
Prima di iniziare con la profilazione del framework di Debugger, verifica che il framework utilizzato per creare il modello sia supportato da Debugger per la profilazione del framework. Per ulteriori informazioni, consulta [Framework e algoritmi supportati](debugger-supported-frameworks.md).
Debugger salva i parametri del framework nel bucket S3 predefinito. Il formato dell'URI del bucket S3 predefinito è `s3://sagemaker--<12digit_account_id>//profiler-output/`.
**Topics**
+ [Profilazione del framework predefinita](debugger-configure-framework-profiling-basic.md)
+ [Monitoraggio del sistema predefinito e profilazione del framework personalizzata per le fasi di destinazione o per un intervallo di tempo di destinazione](debugger-configure-framework-profiling-range.md)
+ [Monitoraggio del sistema predefinito e profilazione del framework personalizzato con diverse opzioni di profiling](debugger-configure-framework-profiling-options.md)
# Profilazione del framework predefinita
La profilazione del framework predefinita di Debugger include le seguenti opzioni: profilazione dettagliata, profilazione dello strumento di caricamento dati e profilazione Python. Il codice di esempio seguente è l'impostazione del parametro `profiler_config` più semplice per avviare il monitoraggio predefinito del sistema e la profilazione del framework predefinito. La classe `FrameworkProfile` nel codice di esempio seguente avvia la profilazione predefinita del framework all'avvio di un processo di addestramento.
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile()
)
```
Con questa configurazione del parametro `profiler_config`, Debugger richiama le impostazioni predefinite di monitoraggio e profilazione. Debugger monitora i parametri di sistema ogni 500 millisecondi; profila la quinta fase con l'opzione di profilazione dettagliata, la settima fase con l'opzione di profilazione del caricatore di dati e la nona, la decima e l’undicesima fase con l'opzione di profilazione Python.
[Per trovare le opzioni di configurazione della profilazione disponibili, le impostazioni dei parametri predefinite ed esempi su come configurarle, consulta [Monitoraggio del sistema predefinito e profilazione del framework personalizzato con diverse opzioni di profiling](debugger-configure-framework-profiling-options.md) e [SageMaker Debugger, APIs nell'SDK FrameworkProfile Amazon Python](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile). SageMaker ](https://sagemaker.readthedocs.io/en/stable)
Se desideri modificare l'intervallo di monitoraggio del sistema e abilitare la profilazione predefinita del framework, puoi specificare il parametro `system_monitor_interval_millis` in modo esplicito con il parametro `framework_profile_params`. Ad esempio, per monitorare ogni 1000 millisecondi e abilitare la profilazione predefinita del framework, utilizza il seguente codice di esempio.
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile()
)
```
Per ulteriori informazioni sulla `FrameworkProfile` classe, consulta [SageMaker Debugger, FrameworkProfile nell' APIs SDK](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile) Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable).
# Monitoraggio del sistema predefinito e profilazione del framework personalizzata per le fasi di destinazione o per un intervallo di tempo di destinazione
Se desideri specificare le fasi o gli intervalli di tempo target per profilare il tuo processo di addestramento, devi specificare i parametri per la classe `FrameworkProfile`. L'esempio di codice seguente mostra come specificare gli intervalli di destinazione per la profilazione e il monitoraggio del sistema.
+ **Per un intervallo di fasi target**
Con la seguente configurazione di esempio, Debugger monitora l'intero processo di addestramento ogni 500 millisecondi (monitoraggio predefinito) e profila un intervallo di fasi target dalla fase 5 alla fase 15 (per 10 fasi).
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile(start_step=5, num_steps=10)
)
```
Con la seguente configurazione di esempio, Debugger monitora l'intero processo di addestramento ogni 1000 millisecondi e profila un intervallo di fasi target dalla fase 5 alla fase 15 (per 10 fasi).
```
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile(start_step=5, num_steps=10)
)
```
+ **Per un intervallo di tempo target**
Con la seguente configurazione di esempio, Debugger monitora l'intero processo di addestramento ogni 500 millisecondi (monitoraggio predefinito) e profila un intervallo di tempo target dal tempo Unix corrente per 600 secondi.
```
import time
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
framework_profile_params=FrameworkProfile(start_unix_time=int(time.time()), duration=600)
)
```
Con la seguente configurazione di esempio, Debugger monitora l'intero processo di addestramento ogni 1000 millisecondi e profila un intervallo di tempo target dal tempo Unix corrente per 600 secondi.
```
import time
from sagemaker.debugger import ProfilerConfig, FrameworkProfile
profiler_config=ProfilerConfig(
system_monitor_interval_millis=1000,
framework_profile_params=FrameworkProfile(start_unix_time=int(time.time()), duration=600)
)
```
La profilazione del framework viene eseguita per tutte le opzioni di profilazione nella fase o nell'intervallo di tempo di destinazione.
[Per ulteriori informazioni sulle opzioni di profilazione disponibili, consulta [SageMaker Debugger — APIs in FrameworkProfile](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.FrameworkProfile) Amazon Python SDK. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
La prossima sezione illustra le modalità di creazione degli script delle opzioni di profilazione disponibili.
# Monitoraggio del sistema predefinito e profilazione del framework personalizzato con diverse opzioni di profiling
Questa sezione fornisce informazioni sulle classi di configurazione di profilazione supportate, oltre a un esempio di configurazione. È possibile utilizzare le seguenti classi di configurazione della profilazione per gestire le opzioni di profilazione del framework:
+ [DetailedProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DetailedProfilingConfig)— Specificate una fase o un intervallo di tempo di destinazione per profilare le operazioni del framework utilizzando i profiler del framework nativi (profiler e profiler). TensorFlow PyTorch Ad esempio, se utilizzati TensorFlow, gli hook Debugger consentono al profiler di raccogliere metriche del TensorFlow framework specifiche. TensorFlow La profilazione dettagliata consente di profilare tutti gli operatori del framework in una fase previa (prima della prima fase), all'interno delle fasi e tra le fasi di un processo di addestramento.
**Nota**
La profilazione dettagliata potrebbe aumentare in modo significativo il consumo di memoria della GPU. Non è consigliabile abilitare la profilazione dettagliata per più di un paio di fasi.
+ [DataloaderProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DataloaderProfilingConfig)— Specificare una fase o un intervallo di tempo target per profilare i processi di caricamento dei dati del framework di deep learning. Debugger raccoglie tutti gli eventi di caricamento dati dei framework.
**Nota**
La profilazione del data loader potrebbe ridurre le prestazioni di addestramento durante la raccolta di informazioni dai caricatori di dati. Non è consigliabile abilitare la profilazione del data loader per più di un paio di fasi.
Debugger è preconfigurato per annotare i processi di caricamento dei dati solo per i container di deep learning AWS . Debugger non può profilare i processi di caricamento dei dati da altri container di addestramento personalizzati o esterni.
+ [PythonProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.PythonProfilingConfig)— Specificare un passo o un intervallo di tempo di destinazione per profilare le funzioni Python. Puoi anche scegliere tra due profiler Python: cProfile e Pyinstrument.
+ *cProfile*: il profiler Python standard. cProfile raccoglie informazioni per ogni operatore Python chiamato durante l'addestramento. Con cProfile, Debugger consente di risparmiare tempo e annotazioni cumulativi per ogni chiamata di funzione, fornendo dettagli completi sulle funzioni Python. Nel deep learning, ad esempio, le funzioni più frequentemente chiamate potrebbero essere i filtri convoluzionali e gli operatori di passaggio all'indietro e i profili cProfile ciascuno di essi. Per l'opzione cProfile, puoi selezionare ulteriormente un'opzione timer: tempo totale, tempo CPU e tempo fuori dalla CPU. Sebbene sia possibile profilare ogni chiamata di funzione in esecuzione sui processori (sia CPU che GPU) in base al tempo impiegato dalla CPU, è anche possibile identificare I/O eventuali problemi di rete con l'opzione di tempo fuori dalla CPU. L'impostazione predefinita è il tempo totale e Debugger profila sia il tempo della CPU che quello esterno alla CPU. Con cProfile, puoi approfondire ogni singola funzione durante l'analisi dei dati del profilo.
+ *Pyinstrument*: Pyinstrument è un profiler Python a basso costo che funziona in base al campionamento. Con l'opzione Pyinstrument, Debugger campiona gli eventi di profilazione ogni millisecondo. Poiché Pyinstrument misura il tempo trascorso dall'orologio da parete anziché il tempo della CPU, l'opzione Pyinstrument può essere una scelta migliore rispetto all'opzione cProfile per ridurre il rumore di profilazione (filtrando le chiamate a funzioni irrilevanti che sono cumulativamente veloci) e catturare gli operatori che in realtà richiedono molta elaborazione (cumulativamente lenti) per addestrare il modello. Con Pyinstrument, puoi vedere un albero di chiamate di funzioni e comprendere meglio la struttura e la causa principale della lentezza.
**Nota**
L'abilitazione della profilazione Python potrebbe rallentare il tempo di addestramento complessivo. cProfile profila gli operatori Python chiamati più frequentemente a ogni chiamata, quindi il tempo di elaborazione della profilazione aumenta rispetto al numero di chiamate. Per Pyinstrument, il tempo di profilazione cumulativo aumenta rispetto al tempo a causa del meccanismo di campionamento.
La configurazione di esempio seguente mostra la struttura completa quando si utilizzano le diverse opzioni di profilazione con valori specificati.
```
import time
from sagemaker.debugger import (ProfilerConfig,
FrameworkProfile,
DetailedProfilingConfig,
DataloaderProfilingConfig,
PythonProfilingConfig,
PythonProfiler, cProfileTimer)
profiler_config=ProfilerConfig(
system_monitor_interval_millis=500,
framework_profile_params=FrameworkProfile(
detailed_profiling_config=DetailedProfilingConfig(
start_step=5,
num_steps=1
),
dataloader_profiling_config=DataloaderProfilingConfig(
start_step=7,
num_steps=1
),
python_profiling_config=PythonProfilingConfig(
start_step=9,
num_steps=1,
python_profiler=PythonProfiler.CPROFILE,
cprofile_timer=cProfileTimer.TOTAL_TIME
)
)
)
```
Per ulteriori informazioni sulle opzioni di profilazione disponibili [DetailedProfilingConfig[DataloaderProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DataloaderProfilingConfig)](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.DetailedProfilingConfig), consulta e [PythonProfilingConfig](https://sagemaker.readthedocs.io/en/stable/api/training/debugger.html#sagemaker.debugger.PythonProfilingConfig)nell'SDK [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable).
# Aggiornamento del monitoraggio del sistema di Debugger e della configurazione della profilazione del framework durante l'esecuzione di un processo di addestramento
Se desideri attivare o aggiornare la configurazione di monitoraggio del Debugger per un job di formazione attualmente in esecuzione, utilizza i seguenti metodi di estensione AI estimator: SageMaker
+ Per attivare il monitoraggio del sistema di Debugger per un processo di addestramento in corso e ricevere un rapporto di profilazione di Debugger, utilizza quanto segue:
```
estimator.enable_default_profiling()
```
Quando utilizzi il metodo `enable_default_profiling`, Debugger avvia il monitoraggio del sistema predefinito e la regola `ProfileReport` integrata, che genera un rapporto di profilazione completo alla fine del processo di addestramento. Questo metodo può essere chiamato solo se il processo di addestramento corrente è in esecuzione senza il monitoraggio e la profilazione di Debugger.
[Per ulteriori informazioni, consulta [estimator.enable\$1default\$1profiling](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.enable_default_profiling) nell'SDK Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
+ Per aggiornare la configurazione di monitoraggio del sistema, usa quanto segue:
```
estimator.update_profiler(
system_monitor_interval_millis=500
)
```
[Per ulteriori informazioni, consulta [estimator.update\$1profiler](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html#sagemaker.estimator.Estimator.update_profiler) nell'SDK Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
# Disattivazione di Debugger
Se desideri disattivare completamente Debugger, esegui una delle seguenti operazioni:
+ Prima di iniziare un processo di addestramento, procedi come segue:
Per disattivare 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 disattivare 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)
# Usa le regole di profilazione integrate gestite da Amazon SageMaker Debugger
Le regole di profilazione integrate di Amazon SageMaker Debugger analizzano le metriche di sistema e le operazioni del framework raccolte durante l'addestramento di un modello. Debugger offre il l’operazione API `ProfilerRule` che aiuta a configurare le regole per monitorare l’addestramento, le risorse e le operazioni di calcolo e rilevare anomalie. Ad esempio, le regole di profilazione possono aiutarti a rilevare eventuali problemi computazionali come colli di bottiglia della CPU, tempi di I/O attesa eccessivi, carico di lavoro squilibrato tra gli addetti alla GPU e sottoutilizzo delle risorse di calcolo. Per visualizzare l'elenco completo delle regole di profilazione integrate disponibili, consulta [Elenco delle regole del profiler integrate di Debugger](debugger-built-in-profiler-rules.md). I seguenti argomenti mostrano come utilizzare le regole integrate di Debugger con le impostazioni dei parametri predefinite e i valori dei parametri personalizzati.
**Nota**
Le regole integrate vengono fornite tramite contenitori di SageMaker elaborazione Amazon e gestite completamente da SageMaker Debugger senza costi aggiuntivi. Per ulteriori informazioni sulla fatturazione, consulta la pagina [ SageMaker dei prezzi di Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Topics**
+ [Utilizza le regole di profilazione integrate di SageMaker Debugger con le relative impostazioni dei parametri predefinite](#debugger-built-in-profiler-rules-configuration)
+ [Usa le regole integrate di Debugger con valori di parametro personalizzati](#debugger-built-in-profiler-rules-configuration-param-change)
## Utilizza le regole di profilazione integrate di SageMaker Debugger con le relative impostazioni dei parametri predefinite
Per aggiungere le regole integrate del SageMaker Debugger nel tuo estimatore, devi configurare un oggetto elenco. `rules` Il codice di esempio seguente mostra la struttura di base dell'elenco delle regole integrate del Debugger. SageMaker
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules=[
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_1()),
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_2()),
...
ProfilerRule.sagemaker(rule_configs.BuiltInProfilerRuleName_n()),
... # You can also append more debugging rules in the Rule.sagemaker(rule_configs.*()) format.
]
estimator=Estimator(
...
rules=rules
)
```
Per un elenco completo delle regole integrate, consulta [Elenco delle regole del profiler integrate di Debugger](debugger-built-in-profiler-rules.md).
Per utilizzare le regole di profilazione e controllare le prestazioni computazionali e l'avanzamento del lavoro di formazione, aggiungi la regola di Debugger. [https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#profiler-report](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#profiler-report) SageMaker [Questa regola attiva tutte le regole integrate della famiglia Debugger. ProfilerRule](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-profiler-rules.html#debugger-built-in-profiler-rules-ProfilerRule) `ProfilerRule` Inoltre, questa regola genera un report di profilazione aggregato. Per ulteriori informazioni, consulta Report di [profilazione generato utilizzando Debugger. SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html) Puoi utilizzare il codice seguente per aggiungere la regola del report di profilazione allo strumento di valutazione dell’addestramento.
```
from sagemaker.debugger import Rule, rule_configs
rules=[
ProfilerRule.sagemaker(rule_configs.ProfilerReport())
]
```
Quando avviii il processo di addestramento con la regola `ProfilerReport`, Debugger raccoglie i dati sull'utilizzo delle risorse ogni 500 millisecondi. Debugger analizza l'utilizzo delle risorse per identificare se il modello presenta problemi di collo di bottiglia. Se le regole rilevano anomalie di addestramento, lo stato di valutazione della regola cambia in `IssueFound`. Puoi configurare azioni automatizzate, come la notifica di 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).
## Usa 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` Per istruzioni su come utilizzare la classe `CollectionConfig`, consulta [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 avviare.
+ 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 del profiler integrate di Debugger](debugger-built-in-profiler-rules.md).
[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=[
ProfilerRule.sagemaker(
base_config=rule_configs.BuiltInProfilerRuleName(),
rule_parameters={
"key": "value"
}
)
]
```
Le descrizioni dei parametri e gli esempi di personalizzazione dei valori sono disponibili per ogni regola in [Elenco delle regole del profiler integrate di Debugger](debugger-built-in-profiler-rules.md).
Per una configurazione JSON di basso livello delle regole integrate di Debugger che utilizzano l'API `CreateTrainingJob`, consulta [Configurazione del debugger tramite l'API SageMaker](debugger-createtrainingjob-api.md).
# Elenco delle regole del profiler integrate di Debugger
Utilizza le regole di profilazione integrate di Debugger fornite da Amazon SageMaker Debugger e analizza le metriche raccolte durante l'addestramento dei tuoi modelli. Le regole integrate di Debugger monitorano varie condizioni comuni che sono fondamentali per il successo dell’esecuzione di un processo di addestramento. Puoi richiamare le regole di profilazione integrate utilizzando [Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) SDK o le operazioni API di basso livello. SageMaker Non sono previsti costi aggiuntivi per l'utilizzo di regole integrate. Per ulteriori informazioni sulla fatturazione, consulta la pagina [ SageMaker dei prezzi di Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Nota**
Il numero massimo di regole di profilazione integrate che puoi allegare a un lavoro di formazione è 20. SageMaker Debugger gestisce completamente le regole integrate e analizza il processo di formazione 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, nel notebook Jupyter 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)
```
## Regole del profiler
Le seguenti regole sono le regole integrate di Debugger che possono essere richiamate utilizzando il metodo di classe `ProfilerRule.sagemaker`.
Regola integrata di Debugger per la generazione del rapporto di profilazione
| Ambito di validità | Regole integrate |
| --- | --- |
| Rapporto SageMaker di profilazione per qualsiasi lavoro di formazione | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
Regole integrate di Debugger per la profilazione dell'utilizzo delle risorse del sistema hardware (parametri di sistema)
| Ambito di validità | Regole integrate |
| --- | --- |
| Regole generiche di monitoraggio del sistema per qualsiasi SageMaker attività di formazione | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
Regole integrate di Debugger per la profilazione dei parametri del framework
| Ambito di validità | Regole integrate |
| --- | --- |
| Regole di profilazione per i framework di deep learning (e) TensorFlow PyTorch | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-built-in-profiler-rules.html) |
**avvertimento**
A favore di [Amazon SageMaker Profiler, SageMaker AI Debugger depreca la funzionalità di profilazione](train-use-sagemaker-profiler.md) del framework a partire dalla versione 2.11 e 2.0. TensorFlow PyTorch Puoi comunque utilizzare la funzionalità nelle versioni precedenti dei framework e come segue. SDKs
SageMaker Python SDK <= v2.130.0
PyTorch >= v1.6.0, < v2.0
TensorFlow >= v2.3.1, < v2.1
Consulta anche [16 marzo 2023](debugger-release-notes.md#debugger-release-notes-20230315).
**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 = [
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_1()),
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_2()),
...
ProfilerRule.sagemaker(rule_configs.BuiltInRuleName_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 = [
ProfilerRule.sagemaker(
base_config=rule_configs.BuiltInRuleName(),
rule_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'utilizzo delle regole integrate con le operazioni API di basso livello SageMaker , consulta. [Configurazione del debugger tramite l'API SageMaker](debugger-createtrainingjob-api.md)
## ProfilerReport
La ProfilerReport regola richiama tutte le regole integrate per il monitoraggio e la profilazione. Crea un rapporto di profilazione e si aggiorna quando vengono attivate le singole regole. È possibile scaricare un rapporto di profilazione completo mentre un processo di addestramento è in corso o dopo il completamento del processo di addestramento. È possibile regolare i valori dei parametri delle regole per personalizzare la sensibilità delle regole di monitoraggio e profilazione integrate. Il codice di esempio seguente mostra il formato di base per regolare i parametri della regola incorporata tramite la regola. ProfilerReport
```
rules=[
ProfilerRule.sagemaker(
rule_configs.ProfilerReport(
_ = value
)
)
]
```
Se si attiva questa ProfilerReport regola senza alcun parametro personalizzato, come mostrato nel codice di esempio seguente, la ProfilerReport regola attiva tutte le regole integrate per il monitoraggio e la profilazione con i valori dei parametri predefiniti.
```
rules=[ProfilerRule.sagemaker(rule_configs.ProfilerReport())]
```
Il codice di esempio seguente mostra come specificare e modificare il `cpu_threshold` parametro della CPUBottleneck regola e il parametro della IOBottleneck `threshold` regola.
```
rules=[
ProfilerRule.sagemaker(
rule_configs.ProfilerReport(
CPUBottleneck_cpu_threshold = 90,
IOBottleneck_threshold = 90
)
)
]
```
Per scoprire cosa contiene il rapporto del profiler, consulta [SageMaker Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html) Profiling Report. [Inoltre, poiché questa regola attiva tutte le regole di profilazione, puoi anche controllare lo stato dell'analisi delle regole utilizzando l'interfaccia utente di Debugger in Studio Experiments. SageMaker SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio.html)
Descrizioni dei parametri per la regola OverallSystemUsage
| Nome parametro | Description |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di formazione corrente da Amazon SageMaker Debugger. **Campo obbligatorio** Valori validi: stringa |
| \$1 | Parametro personalizzabile per regolare le soglie di altre regole di monitoraggio e profilazione integrate. **Opzionale** Valore predefinito: `None` |
## BatchSize
La BatchSize regola aiuta a rilevare se la GPU è sottoutilizzata a causa di un batch di piccole dimensioni. Per rilevare questo problema, questa regola monitora l'utilizzo medio della CPU, l'utilizzo della GPU e l'utilizzo della memoria GPU. Se l'utilizzo di CPU, GPU e memoria GPU è in media basso, ciò può indicare che il processo di addestramento può essere eseguito su un tipo di istanza più piccolo o su un batch di dimensioni maggiori. Questa analisi non funziona per i framework che sovraallocano pesantemente la memoria. Tuttavia, l'aumento delle dimensioni del batch può comportare rallentamenti nell'elaborazione o nel caricamento dei dati, poiché è necessario più tempo di preelaborazione dei dati in ogni iterazione.
Descrizioni dei parametri della regola BatchSize
| Nome parametro | Description |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di formazione corrente da Amazon SageMaker Debugger. **Campo obbligatorio** Valori validi: stringa |
| cpu\$1threshold\$1p95 | Definisce la soglia per il 95° quantile di utilizzo della CPU in percentuale. **Opzionale** Valori validi: numeri interi Valore predefinito: `70` (in percentuale) |
| gpu\$1threshold\$1p95 | Definisce la soglia per il 95° quantile di utilizzo della GPU in percentuale. **Opzionale** Valori validi: numeri interi Valore predefinito: `70` (in percentuale) |
| gpu\$1memory\$1threshold\$1p95 | Definisce la soglia per il 95° quantile di utilizzo della memoria GPU in percentuale. **Opzionale** Valori validi: numeri interi Valori predefiniti: `70` (in percentuale) |
| patience | Definisce il numero di punti dati da saltare fino all'avvio della valutazione da parte della regola. Le prime fasi dei processi di addestramento in genere mostrano un elevato volume di processi di dati, quindi mantieni la regola paziente ed evita che venga richiamata troppo presto con un determinato numero di dati di profilazione specificato con questo parametro. **Opzionale** Valori validi: numeri interi Valori predefiniti: `100` |
| window | Dimensioni della finestra per il calcolo dei quantili. **Opzionale** Valori validi: numeri interi Valori predefiniti: `500` |
| scan\$1interval\$1us | Intervallo di tempo in cui i file della sequenza temporale vengono scansionati. **Opzionale** Valori validi: numeri interi Valori predefiniti: `60000000` (in microsecondi) |
## CPUBottleneck
La CPUBottleneck regola aiuta a rilevare se la GPU è sottoutilizzata a causa di colli di bottiglia della CPU. La regola restituisce True se il numero di colli di bottiglia della CPU supera una soglia predefinita.
CPUBottleneck Descrizioni dei parametri della regola
| Nome parametro | Description |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di formazione corrente da Amazon SageMaker Debugger. **Campo obbligatorio** Valori validi: stringa |
| threshold | Definisce la soglia per la proporzione tra il tempo di difficoltà e il tempo totale di addestramento. Se la proporzione supera la percentuale specificata nel parametro di soglia, la regola imposta lo stato della regola su True. **Opzionale** Valori validi: numeri interi Valore predefinito: `50` (in percentuale) |
| gpu\$1threshold | Una soglia che definisce un basso utilizzo della GPU. **Opzionale** Valori validi: numeri interi Valore predefinito: `10` (in percentuale) |
| cpu\$1threshold | Una soglia che definisce un elevato utilizzo della CPU. **Opzionale** Valori validi: numeri interi Valori predefiniti: `90` (in percentuale) |
| patience | Definisce il numero di punti dati da saltare fino all'avvio della valutazione da parte della regola. Le prime fasi dei processi di addestramento in genere mostrano un elevato volume di processi di dati, quindi mantieni la regola paziente ed evita che venga richiamata troppo presto con un determinato numero di dati di profilazione specificato con questo parametro. **Opzionale** Valori validi: numeri interi Valori predefiniti: `100` |
| scan\$1interval\$1us | Intervallo di tempo in cui i file della sequenza temporale vengono scansionati. **Opzionale** Valori validi: numeri interi Valori predefiniti: `60000000` (in microsecondi) |
## GPUMemoryAumentare
La regola GPUMemory Increase consente di rilevare un notevole aumento dell'utilizzo della memoria su GPUs.
Descrizioni dei parametri per la regola di GPUMemory aumento
| Nome parametro | Description |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di formazione corrente da Amazon SageMaker Debugger. **Campo obbligatorio** Valori validi: stringa |
| increase | Definisce la soglia per l'aumento assoluto della memoria. **Opzionale** Valori validi: numeri interi Valore predefinito: `10` (in percentuale) |
| patience | Definisce il numero di punti dati da saltare fino all'avvio della valutazione da parte della regola. Le prime fasi dei processi di addestramento in genere mostrano un elevato volume di processi di dati, quindi mantieni la regola paziente ed evita che venga richiamata troppo presto con un determinato numero di dati di profilazione specificato con questo parametro. **Opzionale** Valori validi: numeri interi Valori predefiniti: `100` |
| window | Dimensioni della finestra per il calcolo dei quantili. **Opzionale** Valori validi: numeri interi Valori predefiniti: `500` |
| scan\$1interval\$1us | Intervallo di tempo in cui i file della sequenza temporale vengono scansionati. **Opzionale** Valori validi: numeri interi Valori predefiniti: `60000000` (in microsecondi) |
## IOBottleneck
Questa regola aiuta a rilevare se la GPU è sottoutilizzata a causa di colli di bottiglia di I/O dei dati. La regola restituisce True se il numero di colli di bottiglia IO supera una soglia predefinita.
Descrizioni dei parametri per la regola IOBottleneck
| Nome parametro | Description |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di formazione corrente da Amazon SageMaker Debugger. **Campo obbligatorio** Valori validi: stringa |
| threshold | Definisce la soglia entro la quale la regola deve restituire True.**Opzionale**Valori validi: numeri interiValore predefinito: `50` (in percentuale) |
| gpu\$1threshold | Una soglia che definisce quando la GPU è considerata sottoutilizzata. **Opzionale** Valori validi: numeri interi Valore predefinito: `70` (in percentuale) |
| io\$1threshold | Una soglia che definisce un tempo di attesa IO elevato.**Opzionale**Valori validi: numeri interiValori predefiniti: `50` (in percentuale) |
| patience | Definisce il numero di punti dati da saltare fino all'avvio della valutazione da parte della regola. Le prime fasi dei processi di addestramento in genere mostrano un elevato volume di processi di dati, quindi mantieni la regola paziente ed evita che venga richiamata troppo presto con un determinato numero di dati di profilazione specificato con questo parametro.**Opzionale**Valori validi: numeri interiValori predefiniti: `1000` |
| scan\$1interval\$1us | Intervallo di tempo in cui i file della sequenza temporale vengono scansionati. **Opzionale** Valori validi: numeri interi Valori predefiniti: `60000000` (in microsecondi) |
## LoadBalancing
La LoadBalancing regola aiuta a rilevare problemi nel bilanciamento del carico di lavoro tra più utenti. GPUs
Descrizioni dei parametri per la regola LoadBalancing
| Nome parametro | Description |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di formazione corrente da Amazon SageMaker Debugger. **Campo obbligatorio** Valori validi: stringa |
| threshold | Definisce la percentuale del carico di lavoro. **Opzionale** Valori validi: numeri interi Valore predefinito: `0.5` (proporzione senza unità) |
| patience | Definisce il numero di punti dati da saltare fino all'avvio della valutazione da parte della regola. Le prime fasi dei processi di addestramento in genere mostrano un elevato volume di processi di dati, quindi mantieni la regola paziente ed evita che venga richiamata troppo presto con un determinato numero di dati di profilazione specificato con questo parametro. **Opzionale** Valori validi: numeri interi Valori predefiniti: `10` |
| scan\$1interval\$1us | Intervallo di tempo in cui i file della sequenza temporale vengono scansionati. **Opzionale** Valori validi: numeri interi Valori predefiniti: `60000000` (in microsecondi) |
## Basso GPUUtilization
La GPUUtilization regola Low consente di rilevare se l'utilizzo della GPU è basso o presenta fluttuazioni. Questo viene verificato per ogni GPU su ciascun worker. La regola restituisce True se il 95° quantile è inferiore a threshold\$1p95, il che indica un sottoutilizzo. La regola restituisce true se il 95° quantile è al di sopra della soglia p95 e il quinto quantile è inferiore alla soglia p5, il che indica le fluttuazioni.
Descrizioni dei parametri per la regola Low GPUUtilization
| Nome parametro | Description |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di formazione corrente da Amazon SageMaker Debugger. **Campo obbligatorio** Valori validi: stringa |
| threshold\$1p95 | Una soglia per il 95° quantile al di sotto della quale la GPU è considerata sottoutilizzata. **Opzionale** Valori validi: numeri interi Valore predefinito: `70` (in percentuale) |
| threshold\$1p5 | Una soglia per il quinto quantile. Il valore predefinito è il 10 percento.**Opzionale**Valori validi: numeri interiValori predefiniti: `10` (in percentuale) |
| patience | Definisce il numero di punti dati da saltare fino all'avvio della valutazione da parte della regola. Le prime fasi dei processi di addestramento in genere mostrano un elevato volume di processi di dati, quindi mantieni la regola paziente ed evita che venga richiamata troppo presto con un determinato numero di dati di profilazione specificato con questo parametro. **Opzionale** Valori validi: numeri interi Valori predefiniti: `1000` |
| window | Dimensioni della finestra per il calcolo dei quantili. **Opzionale** Valori validi: numeri interi Valori predefiniti: `500` |
| scan\$1interval\$1us | Intervallo di tempo in cui i file della sequenza temporale vengono scansionati. **Opzionale** Valori validi: numeri interi Valori predefiniti: `60000000` (in microsecondi) |
## OverallSystemUsage
La OverallSystemUsage regola misura l'utilizzo complessivo del sistema per nodo di lavoro. Attualmente la regola aggrega solo i valori per nodo e ne calcola i percentili.
Descrizioni dei parametri per la OverallSystemUsage regola
| Nome parametro | Description |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di formazione corrente da Amazon SageMaker Debugger. **Campo obbligatorio** Valori validi: stringa |
| scan\$1interval\$1us | Intervallo di tempo per la scansione dei file della sequenza temporale. **Opzionale** Valori validi: numeri interi Valori predefiniti: `60000000` (in microsecondi) |
## MaxInitializationTime
La MaxInitializationTime regola aiuta a rilevare se l'inizializzazione della formazione richiede troppo tempo. La regola attende che la prima fase sia disponibile.
Descrizioni dei parametri per la regola MaxInitializationTime
| Nome parametro | Description |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di formazione corrente da Amazon SageMaker Debugger. **Campo obbligatorio** Valori validi: stringa |
| threshold | Definisce la soglia in minuti per attendere che la prima fase diventi disponibile. **Opzionale** Valori validi: numeri interi Valore predefinito: `20` (in minuti) |
| scan\$1interval\$1us | Intervallo di tempo in cui i file della sequenza temporale vengono scansionati. **Opzionale** Valori validi: numeri interi Valori predefiniti: `60000000` (in microsecondi) |
## OverallFrameworkMetrics
La OverallFrameworkMetrics regola riassume il tempo impiegato per le metriche del framework, come il passaggio in avanti e all'indietro e il caricamento dei dati.
Descrizioni dei parametri per la regola OverallFrameworkMetrics
| Nome parametro | Description |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di formazione corrente da Amazon SageMaker Debugger. **Campo obbligatorio** Valori validi: stringa |
| scan\$1interval\$1us | Intervallo di tempo per la scansione dei file della sequenza temporale. **Opzionale** Valori validi: numeri interi Valori predefiniti: `60000000` (in microsecondi) |
## StepOutlier
La StepOutlier regola aiuta a rilevare i valori anomali nella durata dei passaggi. Questa regola restituisce `True` se sono presenti valori anomali con durate delle fasi superiori ai sigma `stddev` delle durate dell'intera fase in un intervallo di tempo.
Descrizioni dei parametri per la regola StepOutlier
| Nome parametro | Description |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di formazione corrente da Amazon SageMaker Debugger. **Campo obbligatorio** Valori validi: stringa |
| stddev | Definisce un fattore per il quale moltiplicare la deviazione standard. Ad esempio, la regola viene richiamata per impostazione predefinita quando la durata di una fase è maggiore o minore di 5 volte la deviazione standard. **Opzionale** Valori validi: numeri interi Valore predefinito: `5` (in minuti) |
| mode | Modalità in base alla quale le fasi sono state salvate e su quale regola devono essere eseguite. Per impostazione predefinita, la regola verrà eseguita sui passaggi delle fasi EVAL e TRAIN**Opzionale**Valori validi: numeri interiValore predefinito: `5` (in minuti) |
| n\$1outliers | Quanti valori anomali ignorare prima che la regola restituisca True**Opzionale**Valori validi: numeri interiValore predefinito: `10` |
| scan\$1interval\$1us | Intervallo di tempo in cui i file della sequenza temporale vengono scansionati. **Opzionale** Valori validi: numeri interi Valori predefiniti: `60000000` (in microsecondi) |
# Esperimenti dell'interfaccia utente di Amazon SageMaker Debugger in Amazon Studio Classic SageMaker
Utilizza la dashboard di Amazon SageMaker Debugger Insights in Amazon SageMaker Studio Classic Experiments per analizzare le prestazioni del modello e i colli di bottiglia del sistema durante l'esecuzione di lavori di formazione su istanze Amazon Elastic Compute Cloud (Amazon EC2). Ottieni informazioni dettagliate sui tuoi processi di addestramento e migliora le prestazioni dell’addestramento del modello e la precisione dei pannelli di controllo di Debugger. In base all’impostazione predefinita, Debugger monitora le metriche di sistema (CPU, GPU, memoria GPU, rete e I/O dei dati) ogni 500 millisecondi e i tensori di output di base (perdita e precisione) ogni 500 iterazioni per i processi di addestramento. [Puoi anche personalizzare ulteriormente i valori dei parametri di configurazione del Debugger e regolare gli intervalli di salvataggio tramite l'interfaccia utente di Studio Classic o utilizzando Amazon Python SDK. SageMaker ](https://sagemaker.readthedocs.io/en/stable)
**Importante**
Se utilizzi un’app Studio Classic esistente, eliminala e riavvia per utilizzare le funzionalità di Studio Classic più recenti. Per istruzioni su come riavviare e aggiornare l'ambiente Studio Classic, consulta [Update Amazon SageMaker AI Studio Classic](https://docs.aws.amazon.com/sagemaker/latest/dg/studio-tasks-update.html).
**Topics**
+ [Apri il pannello di controllo di Amazon SageMaker Debugger Insights](debugger-on-studio-insights.md)
+ [Controller di SageMaker dashboard Amazon Debugger Insights](debugger-on-studio-insights-controllers.md)
+ [Esplora la dashboard di Amazon SageMaker Debugger Insights](debugger-on-studio-insights-walkthrough.md)
+ [Chiudi l'istanza Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md)
# Apri il pannello di controllo di Amazon SageMaker Debugger Insights
Nella dashboard di SageMaker Debugger Insights di Studio Classic, puoi visualizzare le informazioni sull'utilizzo delle risorse di calcolo, sull'utilizzo delle risorse e sul collo di bottiglia del sistema del tuo processo di formazione eseguito su istanze Amazon EC2 in tempo reale e dopo i corsi di formazione
**Nota**
La dashboard SageMaker Debugger Insights esegue un'applicazione Studio Classic su un'istanza per elaborare e renderizzare le visualizzazioni. `ml.m5.4xlarge` Ogni scheda SageMaker Debugger Insights esegue una sessione del kernel di Studio Classic. Più sessioni del kernel per più schede di SageMaker Debugger Insights vengono eseguite sulla singola istanza. Quando si chiude una scheda SageMaker Debugger Insights, viene chiusa anche la sessione del kernel corrispondente. L’applicazione Studio Classic rimane attiva e addebita i costi per l’utilizzo dell’istanza `ml.m5.4xlarge`. Per informazioni sui prezzi, consulta la pagina [ SageMaker dei prezzi di Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Importante**
Quando hai finito di usare la dashboard di SageMaker Debugger Insights, devi chiudere l'`ml.m5.4xlarge`istanza per evitare addebiti. Per istruzioni sulla modalità di arresto di un'istanza, consultare [Chiudi l'istanza Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md).
**Per aprire la dashboard di Debugger Insights SageMaker **
1. Nella pagina **Home** di Studio Classic, scegli **Esperimenti** nel riquadro di navigazione a sinistra.
1. Cerca il tuo processo di addestramento nella pagina **Esperimenti**. Se il tuo processo di addestramento è configurato con un'esecuzione di Esperimenti, il lavoro dovrebbe apparire nella scheda **Esperimenti**; se non hai configurato un'esecuzione di Esperimenti, il processo dovrebbe apparire nella scheda **Esecuzioni non assegnate**.
1. Scegli (fai clic) sul link del nome del processo di addestramento per visualizzarne i dettagli.
1. Nel menu **PANORAMICA**, scegli **Debugger**. Questo dovrebbe mostrare le due sezioni seguenti.
+ Nella sezione **regole di Debugger**, puoi consultare lo stato delle regole integrate di Debugger associate al processo di addestramento.
+ Nella sezione **Debugger Insights**, puoi trovare i link per aprire SageMaker Debugger Insights sulla dashboard.
1. Nella sezione **SageMaker Debugger Insights**, scegli il link del nome del processo di formazione per aprire la dashboard di Debugger Insights. SageMaker **Si apre una finestra Debug []. your-training-job-name** In questa finestra, Debugger fornisce una panoramica delle prestazioni di calcolo del tuo processo di addestramento sulle istanze Amazon EC2 e ti aiuta a identificare i problemi nell'utilizzo delle risorse di calcolo.
Puoi anche scaricare un rapporto di profilazione aggregato aggiungendo la [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report)regola integrata di Debugger. SageMaker [Per ulteriori informazioni, consulta [Configurazione delle regole di profilazione integrate e del rapporto di profilazione generato utilizzando Debugger](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html). SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html)
# Controller di SageMaker dashboard Amazon Debugger Insights
Esistono diversi componenti del controller di Debugger per il monitoraggio e la profilazione. In questa guida, imparerai a conoscere i componenti del controller di Debugger.
**Nota**
La dashboard SageMaker Debugger Insights esegue un'app Studio Classic su un'`ml.m5.4xlarge`istanza per elaborare e renderizzare le visualizzazioni. Ogni scheda SageMaker Debugger Insights esegue una sessione del kernel di Studio Classic. Più sessioni del kernel per più schede di SageMaker Debugger Insights vengono eseguite sulla singola istanza. Quando si chiude una scheda SageMaker Debugger Insights, viene chiusa anche la sessione del kernel corrispondente. L’app Studio Classic rimane attiva e addebita i costi per l’utilizzo dell’istanza `ml.m5.4xlarge`. Per informazioni sui prezzi, consulta la pagina [ SageMaker dei prezzi di Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Importante**
Quando hai finito di usare la dashboard di SageMaker Debugger Insights, chiudi l'`ml.m5.4xlarge`istanza per evitare addebiti. Per istruzioni sulla modalità di arresto di un'istanza, consultare [Chiudi l'istanza Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md).
## SageMaker Interfaccia utente del controller Debugger Insights
Utilizzando il controller di Debugger situato nell'angolo superiore sinistro del pannello di controllo delle Informazioni, è possibile aggiornare il pannello di controllo, configurare o aggiornare le impostazioni di Debugger per il monitoraggio delle metriche del sistema, interrompere un processo di addestramento e scaricare un rapporto di profilazione di Debugger.
![\[SageMaker Controller di dashboard Debugger Insights\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-studio-insights-refresh.png)
+ Se desideri aggiornare manualmente il pannello di controllo, scegli il pulsante di aggiornamento (la freccia rotonda nell'angolo in alto a sinistra) come mostrato nello screenshot precedente.
+ Il pulsante di attivazione/disattivazione del **monitoraggio** è attivo per impostazione predefinita per qualsiasi processo di SageMaker formazione avviato utilizzando Python SageMaker SDK. Se non è attivato, è possibile utilizzare il pulsante di attivazione/disattivazione per avviare il monitoraggio. Durante il monitoraggio, Debugger raccoglie solo i parametri di utilizzo delle risorse per rilevare problemi computazionali come i colli di bottiglia della CPU e il sottoutilizzo della GPU. Per un elenco completo dei problemi di utilizzo delle risorse monitorate da Debugger, consulta [Regole integrate di Debugger per la profilazione dell’utilizzo delle risorse del sistema hardware (parametri di sistema)](debugger-built-in-profiler-rules.md#built-in-rules-monitoring).
+ Il pulsante **Configura monitoraggio** apre una finestra pop-up che puoi utilizzare per impostare o aggiornare la frequenza di raccolta dei dati e il percorso S3 per salvare i dati.
![\[La finestra pop-up per la configurazione delle impostazioni di monitoraggio di Debugger\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-studio-enable-profiling-2.png)
È possibile specificare i valori per i seguenti campi.
+ **URI del bucket S3:**Specifica l’URI del bucket S3 di base.
+ **Raccogli i dati di monitoraggio ogni**: seleziona un intervallo di tempo per raccogliere le metriche di sistema. Puoi scegliere uno degli intervalli di monitoraggio dall'elenco a discesa. Gli intervalli disponibili sono 100 millisecondi, 200 millisecondi, 500 millisecondi (impostazione predefinita), 1 secondo, 5 secondi e 1 minuto.
**Nota**
Se scegli uno degli intervalli di tempo più bassi, aumenti la granularità delle metriche di utilizzo delle risorse, in modo da poter rilevare picchi e anomalie con una risoluzione temporale più elevata. Tuttavia, maggiore è la risoluzione, maggiore è la dimensione delle metriche di sistema da elaborare. Ciò potrebbe comportare costi generali aggiuntivi e influire sui tempi complessivi di addestramento ed elaborazione.
+ Utilizzando il pulsante **Arresta addestramento**, è possibile interrompere il processo di addestramento quando si riscontrano anomalie nell'utilizzo delle risorse.
+ Utilizzando il pulsante **Scarica rapporto**, puoi scaricare un report di profilazione aggregato utilizzando la regola integrata di Debugger. [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report) SageMaker Il pulsante si attiva quando si aggiunge la regola integrata allo stimatore [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report). Per ulteriori informazioni, consulta [Configurazione delle regole integrate del profiler](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html) e del [rapporto di profilazione generato](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-profiling-report.html) utilizzando Debugger. SageMaker
# Esplora la dashboard di Amazon SageMaker Debugger Insights
Quando si avvia un processo di SageMaker formazione, SageMaker Debugger inizia a monitorare l'utilizzo delle risorse delle istanze Amazon EC2 per impostazione predefinita. È possibile tenere traccia dei tassi di utilizzo del sistema, della panoramica delle statistiche e dell'analisi delle regole integrate tramite il pannello di controllo delle Informazioni. ****Questa guida illustra il contenuto della dashboard di SageMaker Debugger Insights nelle seguenti schede: Metriche e regole di sistema.****
**Nota**
La dashboard SageMaker Debugger Insights esegue un'applicazione Studio Classic su un'`ml.m5.4xlarge`istanza per elaborare e renderizzare le visualizzazioni. Ogni scheda SageMaker Debugger Insights esegue una sessione del kernel di Studio Classic. Più sessioni del kernel per più schede di SageMaker Debugger Insights vengono eseguite sulla singola istanza. Quando si chiude una scheda SageMaker Debugger Insights, viene chiusa anche la sessione del kernel corrispondente. L’applicazione Studio Classic rimane attiva e addebita i costi per l’utilizzo dell’istanza `ml.m5.4xlarge`. Per informazioni sui prezzi, consulta la pagina [ SageMaker dei prezzi di Amazon](https://aws.amazon.com/sagemaker/pricing/).
**Importante**
Quando hai finito di usare la dashboard di SageMaker Debugger Insights, chiudi l'`ml.m5.4xlarge`istanza per evitare addebiti. Per istruzioni sulla modalità di arresto di un'istanza, consultare [Chiudi l'istanza Amazon SageMaker Debugger Insights](debugger-on-studio-insights-close.md).
**Importante**
Nei report, i grafici e le raccomandazioni sono forniti a scopo informativo e non sono definitivi. Sei responsabile della tua valutazione indipendente delle informazioni.
**Topics**
+ [Parametri del sistema](#debugger-insights-system-metrics-tab)
+ [Regole](#debugger-on-studio-insights-rules)
## Parametri del sistema
Nella scheda **Metriche di sistema**, puoi utilizzare la tabella di riepilogo e i grafici delle serie temporali per comprendere l'utilizzo delle risorse.
### Riepilogo dell'utilizzo delle risorse
Questa tabella riassuntiva mostra le statistiche relative alle metriche di utilizzo delle risorse di calcolo di tutti i nodi (denominate algo-*n*). Le metriche di utilizzo delle risorse includono l'utilizzo totale della CPU, l'utilizzo totale della GPU, l'utilizzo totale della memoria della CPU, l'utilizzo totale della memoria GPU, il tempo di attesa totale e la rete totale in byte. I/O La tabella mostra i valori minimo e massimo e i percentili p99, p90 e p50.
![\[Una tabella riassuntiva dell'utilizzo delle risorse\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-studio-insights-resource-util-summary.png)
### Grafici delle serie temporali di utilizzo delle risorse
Utilizza i grafici delle serie temporali per visualizzare maggiori dettagli sull'utilizzo delle risorse e identificare in quale intervallo di tempo ogni istanza mostra un tasso di utilizzo indesiderato, ad esempio un basso utilizzo della GPU, e i colli di bottiglia della CPU che possono causare lo spreco della costosa istanza.
**L'interfaccia utente del controller del grafico delle serie temporali**
La schermata seguente mostra il controller dell'interfaccia utente per la regolazione dei grafici delle serie temporali.
![\[\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-insights-graph-controller.png)
+ **algo-1**: usa questo menu a discesa per scegliere il nodo che vuoi esaminare.
+ **Ingrandisci**: usa questo pulsante per ingrandire i grafici delle serie temporali e visualizzare intervalli di tempo più brevi.
+ **Zoom indietro**: utilizza questo pulsante per rimpicciolire i grafici delle serie temporali e visualizzare intervalli di tempo più ampi.
+ **Esegui una panoramica a sinistra**: sposta i grafici delle serie temporali su un intervallo temporale precedente.
+ **Esegui una panoramica a destra**: sposta i grafici delle serie temporali su un intervallo temporale successivo.
+ **Correggi intervallo di tempo**: utilizza questa casella di controllo per correggere o ripristinare i grafici delle serie temporali in modo da mostrare l'intera vista dal primo punto dati all'ultimo punto dati.
**Utilizzo della CPU e tempo di attesa I/O **
I primi due grafici mostrano l'utilizzo della CPU e il tempo di I/O attesa nel tempo. Per impostazione predefinita, i grafici mostrano la media del tasso di utilizzo della CPU e del tempo di I/O attesa impiegato sui core della CPU. È possibile selezionare uno o più core della CPU selezionando le etichette per rappresentarle graficamente su un unico grafico e confrontare l'utilizzo tra i core. Puoi trascinare e ingrandire e rimpicciolire per esaminare più da vicino intervalli di tempo specifici.
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-insights-node-cpu.png)
**Utilizzo della GPU e utilizzo della memoria GPU**
I grafici seguenti mostrano l'utilizzo della GPU e della memoria GPU nel tempo. In base all’impostazione predefinita, i grafici mostrano il tasso di utilizzo medio nel tempo. Puoi selezionare le etichette dei core della GPU per visualizzare il tasso di utilizzo di ciascun core. Il calcolo del tasso di utilizzo medio rispetto al numero totale di core GPU mostra l'utilizzo medio dell'intera risorsa del sistema hardware. Osservando il tasso di utilizzo medio, puoi verificare l'utilizzo complessivo delle risorse di sistema di un'istanza Amazon EC2. La figura seguente mostra un processo di addestramento di esempio su un'istanza `ml.p3.16xlarge` con 8 core GPU. È possibile controllare se il lavoro di formazione è ben distribuito, sfruttando appieno tutto. GPUs
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-studio-insights-node-gpu.gif)
**Utilizzo complessivo del sistema nel tempo**
La seguente mappa termica mostra un esempio dell'utilizzo dell'intero sistema di un'`ml.p3.16xlarge`istanza nel tempo, proiettato sul grafico bidimensionale. Ogni core di CPU e GPU è elencato nell’asse verticale e l'utilizzo viene registrato nel tempo con uno schema di colori, in cui i colori brillanti rappresentano un utilizzo ridotto e i colori più scuri rappresentano un utilizzo elevato. Consulta la barra dei colori etichettata sul lato destro del grafico per scoprire quale livello di colore corrisponde a quale frequenza di utilizzo.
![\[debugger-studio-insight-mockup\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-studio-insights-node-heatmap.png)
## Regole
Utilizza la scheda **Regole** per trovare un riepilogo dell'analisi delle regole di profilazione relative al tuo processo di addestramento. Se la regola di profilazione viene attivata con il processo di addestramento, il testo appare evidenziato con il testo bianco pieno. Le regole inattive sono disattivate nel testo grigio. Per attivare queste regole, segui le istruzioni all'indirizzo [Usa le regole di profilazione integrate gestite da Amazon SageMaker Debugger](use-debugger-built-in-profiler-rules.md).
![\[La scheda Regole nella dashboard di SageMaker Debugger Insights\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-insights-rules.png)
# Chiudi l'istanza Amazon SageMaker Debugger Insights
Quando non utilizzi la dashboard di SageMaker Debugger Insights, dovresti chiudere l'istanza dell'app per evitare di incorrere in costi aggiuntivi.
**Per chiudere l'istanza dell'app SageMaker Debugger Insights in Studio Classic**
![\[Una schermata animata che mostra come chiudere un'istanza del dashboard di Debugger Insights. SageMaker\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-studio-insights-shut-down.png)
1. In Studio Classic, seleziona l’icona **Istanze e kernel in esecuzione** (![\[Square icon with a white outline of a cloud on a dark blue background.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/icons/Running_squid.png)).
1. Nell'elenco **RUNNING APPS, cerca l'app** **sagemaker-debugger-1.0**. Seleziona l’icona di arresto (![\[Power button icon with a circular shape and vertical line symbol.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/icons/Shutdown_light.png)) accanto all’app. I dashboard di SageMaker Debugger Insights vengono eseguiti su un'istanza. `ml.m5.4xlarge` Questa istanza scompare anche da **RUNNING INSTANCES** quando si arresta l'app **sagemaker-debugger-1.0**.
# SageMaker Report interattivo del debugger
Ricevi report di profilazione generati automaticamente da Debugger. Il report di Debugger fornisce informazioni dettagliate sui processi di addestramento e fornisce consigli per migliorare le prestazioni del modello. La seguente schermata mostra un collage del report di profilazione di Debugger. Per ulteriori informazioni, consulta [SageMaker Report interattivo del debugger](#debugger-profiling-report).
**Nota**
Puoi scaricare i report di Debugger mentre il processo di addestramento è in corso o al termine del processo. Durante l’addestramento, Debugger aggiorna contemporaneamente il report in base allo stato di valutazione delle regole correnti. Puoi scaricare un report di Debugger completo solo dopo il completamento del processo di addestramento.
**Importante**
Nei report, i grafici e le raccomandazioni sono forniti a scopo informativo e non sono definitivi. Sei responsabile della tua valutazione indipendente delle informazioni.
![\[Un esempio di report di riepilogo sul processo di addestramento di Debugger\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-profile-report.jpg)
Per qualsiasi SageMaker attività di formazione, la [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report) regola SageMaker Debugger richiama tutte le regole di [monitoraggio e profilazione e](debugger-built-in-profiler-rules.md#built-in-rules-monitoring) aggrega l'analisi delle regole in un report completo. Seguendo questa guida, scarica il report utilizzando l'[SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) o la console S3 e scopri cosa puoi interpretare dai risultati della profilazione.
**Importante**
Nel report, i grafici e le raccomandazioni sono forniti a scopo informativo e non sono definitivi. Sei responsabile della tua valutazione indipendente delle informazioni.
# Scarica il report di profilazione del Debugger SageMaker
Scarica il report di profilazione del SageMaker 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
**Nota**
Per ottenere il report di profilazione generato da SageMaker Debugger, devi utilizzare la regola integrata offerta da Debugger. [ProfilerReport](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-built-in-rules.html#profiler-report) SageMaker Per attivare la regola con il tuo processo di addestramento, consulta [Configurazione delle regole integrate del profiler.](https://docs.aws.amazon.com/sagemaker/latest/dg/use-debugger-built-in-profiler-rules.html)
**Suggerimento**
Puoi anche scaricare il rapporto con un solo clic nella dashboard di Studio Debugger Insights. SageMaker Per scaricare il report non è richiesto alcuno script aggiuntivo. Per scoprire come scaricare il report da Studio, consulta [Apri il pannello di controllo di Amazon SageMaker Debugger Insights](debugger-on-studio-insights.md).
------
#### [ Download using 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 di profilazione di Debugger è archiviato in `//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 ricorsivo in `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 in una cartella generata automaticamente denominata `ProfilerReport-1234567890`. Il nome della cartella è una combinazione di stringhe `ProfilerReport` e un tag univoco a 10 cifre basato sul timestamp Unix al momento dell'avvio della regola. ProfilerReport
![\[Esempio di output di regole\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-rule-output-ls-example.png)
Il `profiler-report.html` è un report di profilazione generato automaticamente da Debugger. I file rimanenti sono i componenti integrati di analisi delle regole archiviati in JSON e in un notebook Jupyter che vengono utilizzati per aggregarli nel report.
1. Scarica i file in modo ricorsivo utilizzando `aws s3 cp`. Il comando seguente salva tutti i file di output delle regole nella cartella `ProfilerReport-1234567890` all'interno della directory di lavoro corrente.
```
! aws s3 cp {rule_output_path} ./ --recursive
```
**Suggerimento**
Se utilizzi un server notebook Jupyter, esegui `!pwd` per ricontrollare la directory di lavoro corrente.
1. Sotto la cartella `/ProfilerReport-1234567890/profiler-output`, apri `profiler-report.html`. Se lo utilizzi JupyterLab, scegli **Trust HTML** per visualizzare il rapporto di profilazione del Debugger generato automaticamente.
![\[Esempio di output di regole\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-rule-output-open-html.png)
1. Apri il file `profiler-report.ipynb` per scoprire come viene generato il report. Puoi anche personalizzare ed estendere il report di profilazione utilizzando il file del notebook Jupyter.
------
#### [ Download using Amazon S3 Console ]
1. Accedi 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`. Cerca il bucket S3 di base nel campo *Trova bucket per nome*.
![\[Un esempio dell'URI del bucket S3 di output della regola\]](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 specificando il prefisso del nome del processo nel campo di immissione *Trova oggetti per prefisso*. Scegli il nome del processo di addestramento.
![\[Un esempio dell'URI del bucket S3 di output della regola\]](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, devono esserci tre sottocartelle per i dati di addestramento raccolti da Debugger: **debug-output/**, **profiler-output/**, and **rule-output/**. Scegli **rule-output/**.
![\[Un esempio dell'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 **ProfilerReport-1234567890** e scegli la cartella profiler-output/.** La cartella **profiler-output/** contiene **profiler-report.html** (il report di profilazione generato automaticamente in html), **profiler-report.ipynb** (un notebook Jupyter con script utilizzati per generare il report) e una cartella **profiler-report/** (contiene file JSON di analisi delle regole utilizzati come componenti del report).
1. Seleziona il file **profiler-report.html**, scegli **Azioni** e **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-report-download-s3console-3.png)
1. Apri il file **profiler-report.html** scaricato in un browser Web.
------
**Nota**
Se hai iniziato il processo di addestramento senza configurare i parametri specifici di Debugger, Debugger genera il report solo in base alle regole di monitoraggio del sistema, poiché i parametri di Debugger non sono configurati per salvare i parametri del framework. Per abilitare la profilazione delle metriche del framework e ricevere un rapporto esteso sulla profilazione del Debugger, configura il parametro durante la creazione o l'aggiornamento degli estimatori AI. `profiler_config` SageMaker
Per informazioni su come configurare il parametro `profiler_config` prima di iniziare un processo di addestramento, consulta [Configurazione di uno strumento di stima per la profilazione del framework](debugger-configure-framework-profiling.md).
Per aggiornare il processo di addestramento corrente e abilitare la profilazione dei parametri del framework, consulta [Aggiornamento della configurazione di profilazione del framework di Debugger](debugger-update-monitoring-profiling.md).
# Procedura dettagliata del report di profilazione di Debugger
In questa sezione viene illustrato il report di profilazione di Debugger sezione per sezione. Il report di profilazione viene generato in base alle regole integrate per il monitoraggio e la profilazione. Il report mostra i grafici dei risultati solo per le regole che hanno riscontrato problemi.
**Importante**
Nel report, i grafici e le raccomandazioni sono forniti a scopo informativo e non sono definitivi. Sei responsabile della tua valutazione indipendente delle informazioni.
**Topics**
+ [Riepilogo del processo di addestramento](#debugger-profiling-report-walkthrough-summary)
+ [Statistiche di utilizzo del sistema](#debugger-profiling-report-walkthrough-system-usage)
+ [Riepilogo dei parametri del framework](#debugger-profiling-report-walkthrough-framework-metrics)
+ [Riepilogo delle regole](#debugger-profiling-report-walkthrough-rules-summary)
+ [Analisi del ciclo di addestramento: durata delle fasi](#debugger-profiling-report-walkthrough-step-durations)
+ [Analisi dell'utilizzo della GPU](#debugger-profiling-report-walkthrough-gpu-utilization)
+ [Dimensione batch](#debugger-profiling-report-walkthrough-batch-size)
+ [Colli di bottiglia della CPU](#debugger-profiling-report-walkthrough-cpu-bottlenecks)
+ [Colli di bottiglia di I/O](#debugger-profiling-report-walkthrough-io-bottlenecks)
+ [Sistema di bilanciamento del carico nell'addestramento con più GPU](#debugger-profiling-report-walkthrough-workload-balancing)
+ [Analisi della memoria GPU](#debugger-profiling-report-walkthrough-gpu-memory)
## Riepilogo del processo di addestramento
All'inizio del report, Debugger fornisce un riepilogo del processo di addestramento eseguito. In questa sezione, puoi visualizzare una panoramica delle durate e degli orari nelle diverse fasi dell'addestramento.
![\[Un esempio di report di profilazione di Debugger\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-profiling-report-summary.gif)
La tabella di riepilogo contiene le informazioni seguenti:
+ **ora\$1inizio**: l'ora esatta in cui è iniziato il processo di addestramento.
+ **ora\$1fine**: l'ora esatta in cui il processo di addestramento è terminato.
+ **durata\$1processo\$1in\$1secondi**: il tempo totale di addestramento da **ora\$1inizio** a **ora\$1fine**.
+ **avvio\$1ciclo\$1addestramento**: l'ora esatta in cui è iniziata la prima fase della prima epoca.
+ **fine\$1ciclo\$1addestramento**: l'ora esatta in cui è terminata l’ultima fase dell’ultima epoca.
+ **durata\$1ciclo\$1addestramento\$1in\$1secondi**: il tempo totale tra l'ora di inizio del ciclo di addestramento e l'ora di fine del ciclo di addestramento.
+ **inizializzazione\$1in\$1secondi**: tempo impiegato per inizializzare il processo di addestramento. La fase di inizializzazione copre il periodo compreso tra **ora\$1inizio** e l’ora di **inizio\$1ciclo\$1addestramento**. Il tempo di inizializzazione viene dedicato alla compilazione dello script di addestramento, all'avvio dello script di addestramento, alla creazione e inizializzazione del modello, all'avvio delle istanze EC2 e al download dei dati di addestramento.
+ **finalizzazione\$1in\$1secondi** – Tempo impiegato per finalizzare il processo di addestramento, ad esempio per completare l'addestramento del modello, aggiornare gli artefatti del modello e chiudere le istanze EC2. La fase di inizializzazione copre il periodo compreso tra l’ora di **dine\$1ciclo\$1addestramento** e **ora\$1fine**.
+ **inizializzazione (%)** – La percentuale di tempo impiegato per l’**inizializzazione** rispetto al totale della **durata\$1processo\$1in\$1secondi**.
+ **ciclo di addestramento (%)** – La percentuale di tempo impiegato per il ’**ciclo di addestramento** rispetto al totale della **durata\$1processo\$1in\$1secondi**.
+ **finalizzazione (%)** – La percentuale di tempo impiegato per la **finalizzazione** rispetto al totale della **durata\$1processo\$1in\$1secondi**.
## Statistiche di utilizzo del sistema
In questa sezione è possibile visualizzare una panoramica delle statistiche di utilizzo del sistema.
![\[Un esempio di report di profilazione di Debugger\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-profiling-report-system-usage.png)
Il report di profilazione di Debugger include le seguenti informazioni:
+ **nodo**: elenca il nome dei nodi. Se si utilizza l'addestramento distribuito su più nodi (più istanze EC2), i nomi dei nodi hanno il formato `algo-n`.
+ **parametro**: i parametri di sistema raccolti da Debugger: CPU, GPU, memoria CPU, memoria GPU, I/O e parametri di rete.
+ **unità**: l’unità dei parametri di sistema.
+ **max**: il valore massimo di ogni parametro di sistema.
+ **p99**: il 99° percentile di utilizzo di ogni sistema.
+ **p95**: il 95° percentile di utilizzo di ogni sistema.
+ **p50**: il 50° percentile (mediana) di ogni utilizzo del sistema.
+ **min**: il valore minimo di ogni parametro di sistema.
## Riepilogo dei parametri del framework
In questa sezione, i seguenti grafici a torta mostrano la suddivisione delle operazioni del framework su e. CPUs GPUs
![\[Un esempio di report di profilazione di Debugger\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-metrics-summary.gif)
Ciascuno dei grafici a torta analizza i parametri del framework raccolti in vari aspetti come segue:
+ **Rapporto tra TRAIN/EVAL fasi e altre**: mostra il rapporto tra le durate di tempo impiegate nelle diverse fasi di allenamento.
+ **Rapporto tra passaggio in avanti e indietro** – Mostra il rapporto tra il tempo impiegato per il passaggio in avanti e quello all'indietro nel ciclo di addestramento.
+ **Rapporto tra CPU/GPU operatori**: mostra il rapporto tra il tempo impiegato dagli operatori che utilizzano CPU o GPU, ad esempio gli operatori convoluzionali.
+ **Parametri generali registrati nel framework** – Mostra il rapporto tra il tempo impiegato per i principali parametri del framework, come il caricamento dei dati, il passaggio in avanti e all'indietro.
### Panoramica: operatori della CPU
Questa sezione fornisce informazioni dettagliate sugli operatori della CPU. La tabella mostra la percentuale di tempo e il tempo cumulativo assoluto impiegato dagli operatori CPU più frequentemente chiamati.
![\[Un esempio di report di profilazione di Debugger\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-cpu-operators.gif)
### Panoramica: operatori della GPU
Questa sezione fornisce informazioni dettagliate sugli operatori della GPU. La tabella mostra la percentuale di tempo e il tempo cumulativo assoluto impiegato dagli operatori GPU più frequentemente chiamati.
![\[Un esempio di report di profilazione di Debugger\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-gpu-operators.gif)
## Riepilogo delle regole
In questa sezione, Debugger aggrega tutti i risultati della valutazione delle regole, le analisi, le descrizioni delle regole e i suggerimenti.
![\[Un esempio di report di profilazione di Debugger\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-profiling-report-rules-summary.png)
## Analisi del ciclo di addestramento: durata delle fasi
In questa sezione, puoi trovare statistiche dettagliate sulla durata delle fasi su ciascun core della GPU di ciascun nodo. Debugger valuta i valori medi, massimi, p99, p95, p50 e minimi delle durate delle fasi e valuta i valori anomali delle fasi. L'istogramma seguente mostra le durate dei passaggi acquisite su diversi nodi di lavoro e. GPUs È possibile abilitare o disabilitare l'istogramma di ogni worker scegliendo le legende sul lato destro. È possibile verificare se c'è una particolare GPU che causa valori anomali nella durata delle fasi.
![\[Un esempio di report di profilazione di Debugger\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-profiling-report-framework-step-duration.gif)
## Analisi dell'utilizzo della GPU
Questa sezione mostra le statistiche dettagliate sull'utilizzo dei core della GPU basate sulla regola Low. GPUUtilization Inoltre riassume le statistiche sull'utilizzo della GPU, mean, p95 e p5 per determinare se il lavoro di formazione è sottoutilizzato. GPUs
## Dimensione batch
Questa sezione mostra le statistiche dettagliate sull'utilizzo totale della CPU, sull'utilizzo delle singole GPU e sull'impronta della memoria della GPU. La BatchSize regola determina se è necessario modificare la dimensione del batch per utilizzare meglio il. GPUs È possibile verificare se la dimensione del batch è troppo piccola, con conseguente sottoutilizzo o troppo grande, con conseguente sovrautilizzo e problemi di esaurimento della memoria. Nel grafico, le caselle mostrano gli intervalli percentili p25 e p75 (riempiti rispettivamente di viola scuro e giallo brillante) rispetto alla mediana (p50), mentre le barre di errore mostrano il 5° percentile per il limite inferiore e il 95° percentile per il limite superiore.
![\[Un esempio di report di profilazione di Debugger\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-profiling-report-batch-size.png)
## Colli di bottiglia della CPU
In questa sezione, puoi approfondire i punti deboli della CPU rilevati dalla CPUBottleneck regola durante il tuo processo di formazione. La regola verifica se l'utilizzo della CPU è superiore a `cpu_threshold` (90% per impostazione predefinita) e anche se l'utilizzo della GPU è inferiore (10% per impostazione predefinita). `gpu_threshold`
![\[Un esempio di report di profilazione di Debugger\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-profiling-report-cpu-bottlenecks.png)
I grafici a torta mostrano le seguenti informazioni:
+ **Scarso utilizzo della GPU causato da colli di bottiglia della CPU** – Mostra il rapporto tra i punti dati tra quelli con un utilizzo della GPU superiore e inferiore alla soglia e quelli che corrispondono ai criteri di collo di bottiglia della CPU.
+ **Rapporto tra TRAIN/EVAL fasi e altre**: mostra il rapporto tra le durate di tempo impiegate nelle diverse fasi di allenamento.
+ **Rapporto tra passaggio in avanti e indietro** – Mostra il rapporto tra il tempo impiegato per il passaggio in avanti e quello all'indietro nel ciclo di addestramento.
+ **Rapporto tra CPU/GPU operatori**: mostra il rapporto tra le durate di tempo impiegate su GPUs e CPUs dagli operatori Python, come i processi di caricamento dati e gli operatori di passaggio avanti e indietro.
+ **Parametri generali registrati nel framework** – Mostra i principali parametri del framework e il rapporto tra il tempo impiegato per i parametri.
## Colli di bottiglia di I/O
In questa sezione, puoi trovare un riepilogo degli ostacoli. I/O La regola valuta il tempo di I/O attesa e i tassi di utilizzo della GPU e monitora il tempo impiegato nei punti critici in attesa dell'arrivo I/O requests exceeds a threshold percent of the total training time. It might indicate I/O dei dati dallo storage. GPUs
## Sistema di bilanciamento del carico nell'addestramento con più GPU
In questa sezione, puoi identificare i problemi di bilanciamento del carico di lavoro in tutti i settori. GPUs
![\[Un esempio di report di profilazione di Debugger\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-profiling-report-workload-balancing.gif)
## Analisi della memoria GPU
In questa sezione, puoi analizzare l'utilizzo della memoria GPU raccolto dalla regola Increase. GPUMemory Nel grafico, le caselle mostrano gli intervalli percentili p25 e p75 (riempiti rispettivamente di viola scuro e giallo brillante) rispetto alla mediana (p50), mentre le barre di errore mostrano il 5° percentile per il limite inferiore e il 95° percentile per il limite superiore.
![\[Un esempio di report di profilazione di Debugger\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-profiling-report-gpu-memory-utilization.png)
# Disattiva la raccolta di statistiche sull'utilizzo di Amazon SageMaker Debugger
Per tutti i lavori di SageMaker formazione, Amazon SageMaker Debugger esegue la [ProfilerReport](debugger-built-in-profiler-rules.md#profiler-report) regola e genera automaticamente un file. [SageMaker Report interattivo del debugger](debugger-profiling-report.md) La regola `ProfilerReport` fornisce un file notebook Jupyter (`profiler-report.ipynb`) che genera un file HTML corrispondente (`profiler-report.html`).
Debugger raccoglie statistiche sull'utilizzo del report di profilazione, includendo il codice nel notebook Jupyter che raccoglie l'ARN del processo di elaborazione della regola univoca `ProfilerReport` se l'utente apre il file finale `profiler-report.html`.
Debugger raccoglie solo informazioni sull'apertura o meno del report HTML finale da parte di un utente. **NON** raccoglie alcuna informazione da processi di addestramento, dati di addestramento, script di addestramento, processi di elaborazione, log o dal contenuto del report di profilazione.
Puoi non aderire alla raccolta delle statistiche sull’utilizzo scegliendo una delle seguenti opzioni.
## (Consigliata) Opzione 1: non aderire prima di eseguire job di addestramento
Per disattivarla, devi aggiungere la seguente configurazione della regola `ProfilerReport` di Debugger alla richiesta del processo di addestramento.
------
#### [ SageMaker Python SDK ]
```
estimator=sagemaker.estimator.Estimator(
...
rules=ProfilerRule.sagemaker(
base_config=rule_configs.ProfilerReport()
rule_parameters={"opt_out_telemetry": "True"}
)
)
```
------
#### [ AWS CLI ]
```
"ProfilerRuleConfigurations": [
{
"RuleConfigurationName": "ProfilerReport-1234567890",
"RuleEvaluatorImage": "895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest",
"RuleParameters": {
"rule_to_invoke": "ProfilerReport",
"opt_out_telemetry": "True"
}
}
]
```
------
#### [ AWS SDK per Python (Boto3) ]
```
ProfilerRuleConfigurations=[
{
'RuleConfigurationName': 'ProfilerReport-1234567890',
'RuleEvaluatorImage': '895741380848.dkr.ecr.us-west-2.amazonaws.com/sagemaker-debugger-rules:latest',
'RuleParameters': {
'rule_to_invoke': 'ProfilerReport',
'opt_out_telemetry': 'True'
}
}
]
```
------
## Opzione 2: non aderire dopo aver completato un job di addestramento
Per disattivarla al termine dell’addestramento, devi modificare il file `profiler-report.ipynb`.
**Nota**
I report HTML generati automaticamente senza **l'opzione 1** già aggiunta alla richiesta del processo di addestramento riportano comunque le statistiche di utilizzo, anche dopo la disattivazione tramite **l'opzione 2**.
1. Segui le istruzioni per scaricare i file di report di profilazione di Debugger nella pagina [Scarica il report di profilazione del Debugger SageMaker](debugger-profiling-report-download.md).
1. Nella directory `/ProfilerReport-1234567890/profiler-output`, apri `profiler-report.ipynb`.
1. Aggiungi **opt\$1out=True** alla funzione `setup_profiler_report()` nella quinta cella di codice, come illustrato nel seguente codice di esempio:
```
setup_profiler_report(processing_job_arn, opt_out=True)
```
1. Esegui la cella di codice per completare la disattivazione.
# Analizza i dati utilizzando la libreria client Python di Debugger
[Mentre il processo di formazione è in corso o dopo il suo completamento, puoi accedere ai dati di formazione raccolti da Debugger utilizzando l'[SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable) e la libreria client. SMDebug ](https://github.com/awslabs/sagemaker-debugger/) La libreria client Python di Debugger fornisce strumenti di analisi e visualizzazione che consentono di approfondire i dati del processo di addestramento.
**Per installare la libreria e utilizzare i suoi strumenti di analisi (in un JupyterLab notebook o in un kernel IPython)**
```
! pip install -U smdebug
```
I seguenti argomenti illustrano come utilizzare gli strumenti Python di Debugger per visualizzare e analizzare i dati di addestramento raccolti da Debugger.
**Analizza i parametri del sistema e del framework**
+ [Accedi ai dati del profilo](debugger-analyze-data-profiling.md)
+ [Traccia i parametri del sistema e i dati dei parametri del framework](debugger-access-data-profiling-default-plot.md)
+ [Accedi ai dati di profilazione utilizzando lo strumento di analisi dei dati pandas](debugger-access-data-profiling-pandas-frame.md)
+ [Accedi ai dati delle statistiche di profilazione in Python](debugger-access-data-python-profiling.md)
+ [Unisci le tempistiche di più file di traccia dei profili](debugger-merge-timeline.md)
+ [Data loader di profilazione](debugger-data-loading-time.md)
# Accedi ai dati del profilo
La SMDebug `TrainingJob` classe legge i dati dal bucket S3 in cui vengono salvate le metriche del sistema e del framework.
**Per configurare un oggetto `TrainingJob` e recuperare i file degli eventi di profilazione di un processo di addestramento**
```
from smdebug.profiler.analysis.notebook_utils.training_job import TrainingJob
tj = TrainingJob(training_job_name, region)
```
**Suggerimento**
È necessario specificare i parametri `training_job_name` e `region` per accedere a un processo di addestramento. Ci sono due modi per specificare le informazioni sul processo di addestramento:
Usa SageMaker Python SDK mentre lo estimatore è ancora collegato al processo di formazione.
```
import sagemaker
training_job_name=estimator.latest_training_job.job_name
region=sagemaker.Session().boto_region_name
```
Passa le stringhe direttamente.
```
training_job_name="your-training-job-name-YYYY-MM-DD-HH-MM-SS-SSS"
region="us-west-2"
```
**Nota**
Per impostazione predefinita, SageMaker Debugger raccoglie le metriche di sistema per monitorare l'utilizzo delle risorse hardware e i colli di bottiglia del sistema. Eseguendo le seguenti funzioni, potresti ricevere messaggi di errore relativi all'indisponibilità dei parametri del framework. Per recuperare i dati di profilazione del framework e ottenere informazioni dettagliate sulle operazioni del framework, è necessario abilitare la profilazione del framework.
Se usi SageMaker Python SDK per manipolare la tua richiesta di lavoro di formazione, passala `framework_profile_params` all'`profiler_config`argomento del tuo estimatore. Per saperne di più, consulta [Configure SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-configure-framework-profiling.html) Debugger Framework Profiling.
Se utilizzi Studio Classic, attiva la profilazione utilizzando il pulsante di attivazione della **profilazione** nella dashboard delle informazioni di Debugger. Per ulteriori informazioni, consulta Debugger Insights [SageMaker Dashboard Controller](https://docs.aws.amazon.com/sagemaker/latest/dg/debugger-on-studio-insights-controllers.html).
**Per recuperare una descrizione della descrizione del processo di addestramento e l'URI del bucket S3 in cui vengono salvati i dati dei parametri**
```
tj.describe_training_job()
tj.get_config_and_profiler_s3_output_path()
```
**Per verificare se i parametri del sistema e del framework sono disponibili nell'URI S3**
```
tj.wait_for_sys_profiling_data_to_be_available()
tj.wait_for_framework_profiling_data_to_be_available()
```
**Per creare oggetti di lettura del sistema e del framework dopo che i dati dei parametri sono diventati disponibili**
```
system_metrics_reader = tj.get_systems_metrics_reader()
framework_metrics_reader = tj.get_framework_metrics_reader()
```
**Per aggiornare e recuperare i file degli eventi di addestramento più recenti**
Gli oggetti reader hanno un metodo esteso, `refresh_event_file_list()`, per recuperare i file degli eventi di addestramento più recenti.
```
system_metrics_reader.refresh_event_file_list()
framework_metrics_reader.refresh_event_file_list()
```
# Traccia i parametri del sistema e i dati dei parametri del framework
È possibile utilizzare gli oggetti dei parametri del sistema e dell'algoritmo per le seguenti classi di visualizzazione per tracciare grafici e istogrammi della sequenza temporale.
**Nota**
Per visualizzare i dati con parametri ristretti nei seguenti metodi di rappresentazione degli oggetti di visualizzazione, specifica i parametri `select_dimensions` e `select_events`. Ad esempio, se specifichi `select_dimensions=["GPU"]`, i metodi di rappresentazione filtrano i parametri che includono la parola chiave “GPU”. Se specifichi `select_events=["total"]`, i metodi di rappresentazione filtrano i parametri che includono i tag degli eventi “totali” alla fine dei nomi dei parametri. Se abiliti questi parametri e fornisci le stringhe di parole chiave, le classi di visualizzazione restituiscono i grafici con parametri filtrati.
+ La classe `MetricsHistogram`
```
from smdebug.profiler.analysis.notebook_utils.metrics_histogram import MetricsHistogram
metrics_histogram = MetricsHistogram(system_metrics_reader)
metrics_histogram.plot(
starttime=0,
endtime=system_metrics_reader.get_timestamp_of_latest_available_file(),
select_dimensions=["CPU", "GPU", "I/O"], # optional
select_events=["total"] # optional
)
```
+ La classe `StepTimelineChart`
```
from smdebug.profiler.analysis.notebook_utils.step_timeline_chart import StepTimelineChart
view_step_timeline_chart = StepTimelineChart(framework_metrics_reader)
```
+ La classe `StepHistogram`
```
from smdebug.profiler.analysis.notebook_utils.step_histogram import StepHistogram
step_histogram = StepHistogram(framework_metrics_reader)
step_histogram.plot(
starttime=step_histogram.last_timestamp - 5 * 1000 * 1000,
endtime=step_histogram.last_timestamp,
show_workers=True
)
```
+ La classe `TimelineCharts`
```
from smdebug.profiler.analysis.notebook_utils.timeline_charts import TimelineCharts
view_timeline_charts = TimelineCharts(
system_metrics_reader,
framework_metrics_reader,
select_dimensions=["CPU", "GPU", "I/O"], # optional
select_events=["total"] # optional
)
view_timeline_charts.plot_detailed_profiler_data([700,710])
```
+ La classe `Heatmap`
```
from smdebug.profiler.analysis.notebook_utils.heatmap import Heatmap
view_heatmap = Heatmap(
system_metrics_reader,
framework_metrics_reader,
select_dimensions=["CPU", "GPU", "I/O"], # optional
select_events=["total"], # optional
plot_height=450
)
```
# Accedi ai dati di profilazione utilizzando lo strumento di analisi dei dati pandas
La seguente classe `PandasFrame` fornisce strumenti per convertire i dati di profilazione raccolti nel frame di dati Pandas.
```
from smdebug.profiler.analysis.utils.profiler_data_to_pandas import PandasFrame
```
La classe `PandasFrame` utilizza il percorso di output del bucket S3 dell'oggetto `tj` e i suoi metodi `get_all_system_metrics()` `get_all_framework_metrics()` restituiscono i parametri di sistema e i parametri del framework nel formato di dati Pandas.
```
pf = PandasFrame(tj.profiler_s3_output_path)
system_metrics_df = pf.get_all_system_metrics()
framework_metrics_df = pf.get_all_framework_metrics(
selected_framework_metrics=[
'Step:ModeKeys.TRAIN',
'Step:ModeKeys.GLOBAL'
]
)
```
# Accedi ai dati delle statistiche di profilazione in Python
La profilazione Python fornisce metriche del framework relative alle funzioni e agli operatori Python negli script di formazione e nei framework di deep learning AI. SageMaker
**Modalità e fasi di addestramento per la profilazione in Python**
Per profilare intervalli specifici durante l'addestramento al fine di partizionare le statistiche per ciascuno di questi intervalli, Debugger fornisce strumenti per impostare modalità e fasi.
Per le modalità di addestramento, utilizza la seguente classe `PythonProfileModes`:
```
from smdebug.profiler.python_profile_utils import PythonProfileModes
```
Questa classe offre le seguenti opzioni:
+ `PythonProfileModes.TRAIN`: utilizzala se desideri profilare le fasi target della fase di addestramento. Questa opzione di modalità è disponibile solo per. TensorFlow
+ `PythonProfileModes.EVAL`: utilizzala se desideri profilare le fasi target della fase di valutazione. Questa opzione di modalità è disponibile solo per TensorFlow.
+ `PythonProfileModes.PREDICT`: utilizzala se desideri profilare le fasi target della fase di previsione. Questa opzione di modalità è disponibile solo per TensorFlow.
+ `PythonProfileModes.GLOBAL`: utilizzala se desideri profilare le fasi target nella fase globale, che include le tre fasi precedenti. Questa opzione di modalità è disponibile solo per PyTorch.
+ `PythonProfileModes.PRE_STEP_ZERO`: utilizzala se desideri profilare le fasi target nella fase di inizializzazione prima che inizi la prima fase di addestramento della prima epoca. Questa fase include l'invio iniziale del lavoro, il caricamento degli script di addestramento sulle istanze EC2, la preparazione delle istanze EC2 e il download dei dati di input. Questa opzione di modalità è disponibile per entrambi TensorFlow e PyTorch.
+ `PythonProfileModes.POST_HOOK_CLOSE`: utilizzala se desideri profilare le fasi di destinazione nella fase di finalizzazione dopo il completamento del processo di addestramento e la chiusura dell'hook Debugger. Questa fase include la profilazione dei dati mentre i processi di addestramento vengono finalizzati e completati. Questa opzione di modalità è disponibile per entrambi TensorFlow e PyTorch.
Per le fasi di addestramento, utilizza la seguente classe `StepPhase`:
```
from smdebug.profiler.analysis.utils.python_profile_analysis_utils import StepPhase
```
Questa classe offre le seguenti opzioni:
+ `StepPhase.START`: utilizzala per specificare il punto iniziale della fase di inizializzazione.
+ `StepPhase.STEP_START`: utilizzala per specificare la fase iniziale della fase di addestramento.
+ `StepPhase.FORWARD_PASS_END`: utilizzala per specificare le fasi in cui termina il passaggio in avanti. Questa opzione è disponibile solo per PyTorch.
+ `StepPhase.STEP_END`: utilizzala per specificare le fasi finali della fase di addestramento. Questa opzione è disponibile solo per TensorFlow.
+ `StepPhase.END`— Utilizzare per specificare il punto finale della fase di finalizzazione (post-hook-close). Se l'hook di callback non è chiuso, non si verifica la profilazione della fase di finalizzazione.
**Strumenti di analisi della profilazione in Python**
Debugger supporta la profilazione Python con due strumenti di profilazione:
+ cProfile — Il profiler Python standard. cProfile raccoglie i parametri del framework sul tempo di CPU per ogni funzione chiamata quando la profilazione era abilitata.
+ Pyinstrument — Si tratta di un profiler Python a basso sovraccarico che campiona eventi di profilazione ogni millisecondi.
Per saperne di più sulle opzioni di profilazione di Python e su ciò che viene raccolto, consulta [Monitoraggio del sistema predefinito e profilazione del framework personalizzato con diverse opzioni di profiling](debugger-configure-framework-profiling-options.md).
Vengono forniti i seguenti metodi delle classi `PythonProfileAnalysis`, `cProfileAnalysis`, `PyinstrumentAnalysis` per recuperare e analizzare i dati di profilazione Python. Ogni funzione carica i dati più recenti dall'URI S3 predefinito.
```
from smdebug.profiler.analysis.python_profile_analysis import PythonProfileAnalysis, cProfileAnalysis, PyinstrumentAnalysis
```
Per impostare gli oggetti di profilazione Python per l'analisi, utilizzate le PyinstrumentAnalysis classi cProfileAnalysis or come mostrato nel seguente codice di esempio. Mostra come impostare un oggetto `cProfileAnalysis` e, se desideri utilizzare `PyinstrumentAnalysis`, sostituisci il nome della classe.
```
python_analysis = cProfileAnalysis(
local_profile_dir=tf_python_stats_dir,
s3_path=tj.profiler_s3_output_path
)
```
I seguenti metodi sono disponibili per le classi `cProfileAnalysis` e `PyinstrumentAnalysis` per recuperare i dati delle statistiche di profilazione Python:
+ `python_analysis.fetch_python_profile_stats_by_time(start_time_since_epoch_in_secs, end_time_since_epoch_in_secs)`— Immette l'ora di inizio e l'ora di fine e restituisce le statistiche della funzione delle statistiche di fase i cui orari di inizio o di fine si sovrappongono all'intervallo fornito.
+ `python_analysis.fetch_python_profile_stats_by_step(start_step, end_step, mode, start_phase, end_phase)`— Comprende una fase iniziale e una fase finale e restituisce le statistiche della funzione di tutte le statistiche di fase il cui profilo `step` soddisfa `start_step <= step < end_step`.
+ `start_step` e `end_step` (str) — Specifica la fase iniziale e la fase finale per recuperare i dati delle statistiche di profilazione Python.
+ `mode`(str) — Specifica la modalità di addestramento del lavoro utilizzando la classe enumeratore `PythonProfileModes`. Il valore predefinito è `PythonProfileModes.TRAIN`. Le opzioni disponibili sono fornite nella sezione [Modalità e fasi di addestramento per la profilazione Python](#debugger-access-data-python-profiling-modes).
+ `start_phase`(str) — Specifica la fase iniziale nelle fasi di destinazione utilizzando la classe enumeratore `StepPhase`. Questo parametro consente la profilazione tra le diverse fasi dell’addestramento. Il valore predefinito è `StepPhase.STEP_START`. Le opzioni disponibili sono fornite nella sezione [Modalità e fasi di addestramento per la profilazione Python](#debugger-access-data-python-profiling-phases).
+ `end_phase`(str) — Specifica la fase finale nelle fasi di destinazione utilizzando la classe enumeratore `StepPhase`. Questo parametro imposta la fase finale dell'addestramento. Le opzioni disponibili sono le stesse del parametro `start_phase`. Il valore predefinito è `StepPhase.STEP_END`. Le opzioni disponibili sono fornite nella sezione [Modalità e fasi di addestramento per la profilazione Python](#debugger-access-data-python-profiling-phases).
+ `python_analysis.fetch_profile_stats_between_modes(start_mode, end_mode)`— Recupera le statistiche dalla profilazione Python tra le modalità di inizio e fine.
+ `python_analysis.fetch_pre_step_zero_profile_stats()`— Recupera le statistiche dalla profilazione Python fino alla fase 0.
+ `python_analysis.fetch_post_hook_close_profile_stats()`— Recupera le statistiche dalla profilazione Python dopo la chiusura dell'hook.
+ `python_analysis.list_profile_stats()`— Restituisce una DataFrame delle statistiche di profilazione di Python. Ogni riga contiene i metadati per ogni istanza di profilazione e il file di statistiche corrispondente (uno per fase).
+ `python_analysis.list_available_node_ids()`— Restituisce un elenco del nodo disponibile IDs per le statistiche di profilazione in Python.
I metodi specifici della classe `cProfileAnalysis`:
+ `fetch_profile_stats_by_training_phase()`— Recupera e aggrega le statistiche di profilazione Python per ogni possibile combinazione di modalità di inizio e fine. Ad esempio, se le fasi di addestramento e convalida vengono eseguite mentre è abilitata la profilazione dettagliata, le combinazioni sono `(PRE_STEP_ZERO, TRAIN)`, `(TRAIN, TRAIN)`, `(TRAIN, EVAL)`, `(EVAL, EVAL)` e `(EVAL, POST_HOOK_CLOSE)`. Tutti i file di statistiche all'interno di ciascuna di queste combinazioni vengono aggregati.
+ `fetch_profile_stats_by_job_phase()`— Recupera e aggrega le statistiche di profilazione di Python per fase di processo. Le fasi di processo sono `initialization` (profilazione fino alla fase 0), `training_loop` (addestramento e convalida) e `finalization` (profilazione dopo la chiusura dell'hook).
# Unisci le tempistiche di più file di traccia dei profili
La libreria SMDebug client fornisce strumenti di analisi e visualizzazione della profilazione per unire le tempistiche delle metriche di sistema, delle metriche del framework e dei dati di profilazione Python raccolti da Debugger.
**Suggerimento**
Prima di procedere, è necessario impostare un oggetto che verrà utilizzato negli esempi di questa pagina. TrainingJob Per ulteriori informazioni sulla configurazione di un TrainingJob oggetto, vedere. [Accedi ai dati del profilo](debugger-analyze-data-profiling.md)
La classe `MergedTimeline` fornisce strumenti per integrare e correlare diverse informazioni di profilazione in un'unica tempistica. Dopo che Debugger ha acquisito i dati di profilazione e le annotazioni da diverse fasi di un processo di addestramento, i file JSON degli eventi di traccia vengono salvati in una directory predefinita `tracefolder`.
+ Per le annotazioni nei livelli Python, i file di traccia vengono salvati in `*pythontimeline.json`.
+ Per le annotazioni nei livelli TensorFlow C\$1\$1, i file di traccia vengono salvati in. `*model_timeline.json`
+ Il profiler Tensorflow salva gli eventi in un file `*trace.json.gz`.
**Suggerimento**
Se desideri elencare tutti i file di traccia JSON, usa il seguente comando AWS CLI
```
! aws s3 ls {tj.profiler_s3_output_path} --recursive | grep '\.json$'
```
Come mostrato nella seguente schermata animata, l'inserimento e l'allineamento degli eventi di traccia acquisiti dalle diverse fonti di profilazione in un unico grafico può fornire una panoramica di tutti gli eventi che si verificano nelle diverse fasi del processo di addestramento.
![\[Un esempio di tempistica unita\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/debugger/debugger-merged-timeline.gif)
**Suggerimento**
Per interagire con la tempistica unita sull'app di tracciamento utilizzando una tastiera, usa il tasto `W` per ingrandire, il tasto `A` per spostarsi a sinistra, il tasto `S` per rimpicciolire e il tasto `D` per spostarsi a destra.
I file JSON di traccia di più eventi possono essere uniti in un unico file JSON di eventi di traccia utilizzando la seguente operazione API `MergedTimeline` e il metodo di classe del modulo `smdebug.profiler.analysis.utils.merge_timelines`.
```
from smdebug.profiler.analysis.utils.merge_timelines import MergedTimeline
combined_timeline = MergedTimeline(path, file_suffix_filter, output_directory)
combined_timeline.merge_timeline(start, end, unit)
```
L'operazione API `MergedTimeline` passa i seguenti parametri:
+ `path` (str) — Specifica una cartella principale (`/profiler-output`) che contiene i file di traccia per la profilazione del sistema e del framework. È possibile localizzarlo `profiler-output` utilizzando il metodo di classe SageMaker AI estimator o l'oggetto. TrainingJob Ad esempio `estimator.latest_job_profiler_artifacts_path()` o `tj.profiler_s3_output_path`.
+ `file_suffix_filter` (elenco) — Specifica un elenco di filtri per i suffissi dei file per unire le tempistiche. I filtri per i suffissi disponibili sono `["model_timeline.json", "pythontimeline.json", "trace.json.gz"].` Se questo parametro non viene specificato manualmente, tutti i file di traccia vengono uniti per impostazione predefinita.
+ `output_directory` (str) — Specifica un percorso per salvare il file JSON della tempistica unita. L'impostazione predefinita è la directory specificata per il parametro `path`.
Il metodo della classe `merge_timeline()` passa i seguenti parametri per eseguire il processo di unione:
+ `start` (int) — Specifica l'ora di inizio (in microsecondi e nel formato orario Unix) o la fase iniziale per unire le tempistiche.
+ `end` (int) — Specifica l'ora di fine (in microsecondi e nel formato orario Unix) o la fase finale per unire le tempistiche.
+ `unit` (str) — Scegli tra `"time"` e `"step"`. Il valore predefinito è `"time"`.
Utilizzando i seguenti codici di esempio, esegui il metodo `merge_timeline()` e scarica il file JSON unito.
+ Unisci la tempistica con l'opzione dell'unità `"time"`. Il codice di esempio seguente unisce tutti i file di traccia disponibili tra l'ora di inizio di Unix (l'ora Unix zero assoluta) e l'ora Unix corrente, il che significa che è possibile unire le tempistiche per l'intera durata dell'addestramento.
```
import time
from smdebug.profiler.analysis.utils.merge_timelines import MergedTimeline
from smdebug.profiler.profiler_constants import CONVERT_TO_MICROSECS
combined_timeline = MergedTimeline(tj.profiler_s3_output_path, output_directory="./")
combined_timeline.merge_timeline(0, int(time.time() * CONVERT_TO_MICROSECS))
```
+ Unisci la tempistica con l'opzione dell'unità `"step"`. Il codice di esempio seguente unisce tutte le tempistiche disponibili tra la fase 3 e la fase 9.
```
from smdebug.profiler.analysis.utils.merge_timelines import MergedTimeline
combined_timeline = MergedTimeline(tj.profiler_s3_output_path, output_directory="./")
combined_timeline.merge_timeline(3, 9, unit="step")
```
Apri l'app di tracciamento Chrome in `chrome://tracing` su un browser Chrome e apri il file JSON. Puoi esplorare l'output per tracciare la tempistica unita.
# Data loader di profilazione
In PyTorch, gli iteratori del caricatore di dati, come `SingleProcessingDataLoaderIter` e`MultiProcessingDataLoaderIter`, vengono avviati all'inizio di ogni iterazione su un set di dati. Durante la fase di inizializzazione, PyTorch attiva i processi di lavoro in base al numero configurato di lavoratori, stabilisce una coda di dati per recuperare dati e thread. `pin_memory`
Per utilizzare lo strumento di analisi della profilazione del caricatore di PyTorch dati, importa la seguente classe: `PT_dataloader_analysis`
```
from smdebug.profiler.analysis.utils.pytorch_dataloader_analysis import PT_dataloader_analysis
```
Passa i dati di profilazione recuperati come oggetto dati del frame Pandas nella sezione: [Accedi ai dati di profilazione utilizzando lo strumento di analisi dei dati pandas](debugger-access-data-profiling-pandas-frame.md)
```
pt_analysis = PT_dataloader_analysis(pf)
```
Le seguenti funzioni sono disponibili per l'oggetto `pt_analysis`:
La SMDebug `S3SystemMetricsReader` classe legge le metriche di sistema dal bucket S3 specificato nel parametro. `s3_trial_path`
+ `pt_analysis.analyze_dataloaderIter_initialization()`
L'analisi restituisce la durata mediana e massima per queste inizializzazioni. Se sono presenti valori anomali (ovvero la durata è superiore a 2\$1 mediana), la funzione stampa l'ora di inizio e di fine di tali durate. Questi possono essere usati per ispezionare le metriche di sistema durante tali intervalli di tempo.
L'elenco seguente mostra quali analisi sono disponibili con questo metodo di classe:
+ Che tipo di iteratori del data loader sono stati inizializzati.
+ Il numero di worker per iteratore.
+ Controlla se l'iteratore è stato inizializzato con o senza pin\$1memory.
+ Numero di volte in cui gli iteratori sono stati inizializzati durante l'addestramento.
+ `pt_analysis.analyze_dataloaderWorkers()`
L'elenco seguente mostra quali analisi sono disponibili con questo metodo di classe:
+ Il numero di processi di lavoro che sono stati scorporati durante l'intero addestramento.
+ Durata mediana e massima dei processi di lavoro.
+ Ora di inizio e fine per i processi di lavoro che sono valori anomali.
+ `pt_analysis.analyze_dataloader_getnext()`
L'elenco seguente mostra quali analisi sono disponibili con questo metodo di classe:
+ Numero di GetNext chiamate effettuate durante l'allenamento.
+ Durata media e massima in microsecondi delle chiamate. GetNext
+ Ora di inizio, ora di fine, durata e ID del lavoratore per la durata anomala della chiamata GetNext.
+ `pt_analysis.analyze_batchtime(start_timestamp, end_timestamp, select_events=[".*"], select_dimensions=[".*"])`
Debugger raccoglie l'ora di inizio e di fine di tutte le chiamate. GetNext È possibile trovare la quantità di tempo impiegata dallo script di addestramento su un batch di dati. All'interno della finestra temporale specificata, è possibile identificare le chiamate che non contribuiscono direttamente all’addestramento. Queste chiamate possono provenire dalle seguenti operazioni: calcolo della precisione, aggiunta delle perdite per scopi di debug o registrazione e stampa delle informazioni di debug. Operazioni come queste possono richiedere molte risorse di calcolo o richiedere molto tempo. Possiamo identificare tali operazioni correlando il profiler Python, i parametri di sistema e i parametri del framework.
L'elenco seguente mostra quali analisi sono disponibili con questo metodo di classe:
+ Analizza il tempo impiegato per ogni batch di dati`BatchTime_in_seconds`, trovando la differenza tra l'ora di inizio delle chiamate correnti e quelle successive. GetNext
+ Individua i valori anomali in `BatchTime_in_seconds` e l'ora di inizio e di fine di tali valori anomali.
+ Ottieni i parametri del sistema e del framework durante questi timestamp `BatchTime_in_seconds`. Questo indica dove è stato impiegato il tempo.
+ `pt_analysis.plot_the_window()`
Traccia un grafico temporale tra un timestamp di inizio e il timestamp di fine.