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à.
# Elenco delle regole integrate di Debugger
Puoi utilizzare le regole integrate di Debugger fornite da Amazon SageMaker Debugger e analizzare le metriche e i tensori raccolti durante l’addestramento dei tuoi modelli. Di seguito sono elencate le regole di Debugger, incluse informazioni e un esempio su come configurare e implementare ogni regola integrata.
Le regole integrate di Debugger monitorano varie condizioni comuni che sono fondamentali per il successo di un processo di addestramento. Puoi richiamare le regole integrate utilizzando [Amazon SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable) o le operazioni API SageMaker di basso livello.
Non sono previsti costi aggiuntivi per l'utilizzo di regole integrate. Per ulteriori informazioni sulla fatturazione, consulta la pagina [Prezzi di Amazon SageMaker](https://aws.amazon.com/sagemaker/pricing/).
**Nota**
Il numero massimo di regole integrate che è possibile collegare a un processo di addestramento è 20. Debugger SageMaker gestisce completamente le regole integrate e analizza il processo di addestramento in modo sincrono.
**Importante**
Per utilizzare le nuove funzionalità di Debugger, è necessario aggiornare l'SDK SageMaker Python e la libreria client SMDebug. Nel kernel IPython, notebook Jupyter, o nell'ambiente JupyterLab, esegui il codice seguente per installare le versioni più recenti delle librerie e riavviare il kernel.
```
import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)
```
## Regola Debugger
Le seguenti regole sono le regole integrate di Debugger che possono essere richiamate utilizzando il metodo di classe `Rule.sagemaker`.
Regole integrate di Debugger per generare report di addestramento
| Ambito di validità | Regole integrate |
| --- | --- |
| Report di addestramento per il job di addestramento di SageMaker AI XGBoost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-built-in-rules.html) |
Regole integrate di Debugger per il debug dei dati di addestramento del modello (tensori di output)
| Ambito di validità | Regole integrate |
| --- | --- |
| Framework di deep learning (TensorFlow, MXNet e PyTorch) | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Framework di deep learning (TensorFlow, MXNet e PyTorch) e algoritmo XGBoost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Applicazioni deep learning | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-built-in-rules.html) |
| Algoritmo XGBoost | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/debugger-built-in-rules.html) |
**Per utilizzare le regole integrate con i valori dei parametri predefiniti**, utilizza il seguente formato di configurazione:
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
Rule.sagemaker(rule_configs.built_in_rule_name_1()),
Rule.sagemaker(rule_configs.built_in_rule_name_2()),
...
Rule.sagemaker(rule_configs.built_in_rule_name_n())
]
```
**Per utilizzare le regole integrate con la configurazione dei parametri predefiniti**, utilizza il seguente formato di configurazione:
```
from sagemaker.debugger import Rule, ProfilerRule, rule_configs
rules = [
Rule.sagemaker(
base_config=rule_configs.built_in_rule_name(),
rule_parameters={
"key": "value"
}
collections_to_save=[
CollectionConfig(
name="tensor_collection_name",
parameters={
"key": "value"
}
)
]
)
]
```
Per trovare le chiavi disponibili per il parametro `rule_parameters`, consulta le tabelle di descrizione dei parametri.
Vengono forniti esempi di codici di configurazione delle regole per ogni regola integrata sotto le tabelle di descrizione dei parametri.
+ Per istruzioni complete ed esempi di utilizzo delle regole integrate di Debugger, consulta [Codice di esempio con regole integrate di Debugger](debugger-built-in-rules-example.md#debugger-deploy-built-in-rules).
+ Per un'istruzione completa sull'uso delle regole integrate con le operazioni API SageMaker di basso livello, consulta [Configurazione del debugger tramite l'API SageMaker](debugger-createtrainingjob-api.md).
## CreateXgboostReport
La regola CreateXGBoostReport raccoglie i tensori di output da un processo di addestramento XGBoost e genera automaticamente un report di addestramento completo. È possibile scaricare un report di profilazione completo mentre un processo di addestramento è in corso o dopo il completamento del processo di addestramento e controllare il progresso di addestramento o il suo risultato finale. La regola CreateXGBoostReport raccoglie i seguenti tensori di output per impostazione predefinita:
+ `hyperparameters`: Salva durante la prima fase
+ `metrics`: Risparmia perdita e precisione ogni 5 fasi
+ `feature_importance`: Salva ogni 5 fasi
+ `predictions`: Salva ogni 5 fasi
+ `labels`: Salva ogni 5 fasi
Descrizioni dei parametri per la regola CreateXgboostReport
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
```
rules=[
Rule.sagemaker(
rule_configs.create_xgboost_report()
)
]
```
## DeadRelu
Questa regola rileva quando la percentuale di funzioni di attivazione dell'unità lineare rettificata (ReLU) in una prova è considerata morta perché la loro attività di attivazione è scesa al di sotto di una soglia. Se la percentuale di ReLUs inattivi in un livello è maggiore del valore `threshold_layer` di ReLU inattivi, la regola restituisce `True`.
Descrizioni dei parametri per la regola DeadRelu
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: `".*relu_output"` |
| threshold\$1inactivity | Definisce un livello di attività al di sotto del quale un ReLU è considerato morto. Un ReLU potrebbe essere attivo all'inizio di una prova e poi morire lentamente durante il processo di addestramento. Se ReLU è attivo meno del `threshold_inactivity`, è considerato morto. **Opzionale** Valori validi: float Valori predefiniti: `1.0` (in percentuale) |
| threshold\$1layer | Restituisce `True` se la percentuale di ReLU inattivi in un livello è maggiore di `threshold_layer`. Restituisce `False` se la percentuale di ReLU inattivi in un livello è inferiore a `threshold_layer`. **Opzionale** Valori validi: float Valori predefiniti: `50.0` (in percentuale) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.dead_relu(),
rule_parameters={
"tensor_regex": ".*relu_output|.*ReLU_output",
"threshold_inactivity": "1.0",
"threshold_layer": "50.0"
},
collections_to_save=[
CollectionConfig(
name="custom_relu_collection",
parameters={
"include_regex: ".*relu_output|.*ReLU_output",
"save_interval": "500"
}
)
]
)
]
```
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
Questa regola non è disponibile per l'algoritmo XGBoost.
## ExplodingTensor
Questa regola rileva se i tensori emessi durante l’addestramento hanno valori non finiti, infiniti o NaN (non un numero). Se viene rilevato un valore non finito, la regola restituisce `True`.
Descrizioni dei parametri per la regola ExplodingTensor
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| collection\$1names | L'elenco dei nomi di raccolta i cui tensori vengono ispezionati dalla regola. **Opzionale** Valori validi: stringa Valore predefinito: `None` |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: stringa Valore predefinito: `None` |
| only\$1nan | `True` per monitorare i tensori `base_trial` solo per i valori `NaN` e non per l'infinito. `False` per trattare `NaN` e infinity come valori esplosivi e per monitorare entrambi. **Opzionale** Valore predefinito: `False` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.exploding_tensor(),
rule_parameters={
"tensor_regex": ".*gradient",
"only_nan": "False"
},
collections_to_save=[
CollectionConfig(
name="gradients",
parameters={
"save_interval": "500"
}
)
]
)
]
```
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
Questa regola non è disponibile per l'algoritmo XGBoost.
## PoorWeightInitialization
Questa regola rileva se i parametri del modello sono stati inizializzati male.
Una buona inizializzazione interrompe la simmetria dei pesi e dei gradienti in una rete neurale e mantiene le varianze di attivazione commisurate tra i livelli. Altrimenti, la rete neurale non apprende in modo efficace. Gli inizializzatori come Xavier mirano a mantenere costante la varianza tra le attivazioni, che è particolarmente rilevante per l’addestramento di reti neurali molto profonde. Un'inizializzazione troppo piccola può portare alla scomparsa dei gradienti. Un'inizializzazione troppo grande può portare a gradienti esplosivi. Questa regola controlla la varianza degli input di attivazione tra i livelli, la distribuzione dei gradienti e la convergenza delle perdite per le fasi iniziali per determinare se una rete neurale è stata inizializzata male.
Descrizioni dei parametri per la regola PoorWeightInitialization
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| activation\$1inputs\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: stringa Valore predefinito: `".*relu_input"` |
| threshold | Se il rapporto tra la varianza minima e massima dei pesi per livello supera il `threshold` in una fase, la regola ritorna `True`. **Opzionale** Valori validi: float Valore predefinito: `10.0` |
| distribution\$1range | Se la differenza minima tra il quinto e il 95° percentile della distribuzione del gradiente è inferiore alla `distribution_range`, la regola restituisce `True`. **Opzionale** Valori validi: float Valore predefinito: `0.001` |
| patience | Il numero di fasi da attendere fino a quando la perdita è considerata non più in diminuzione. **Opzionale** Valori validi: numeri interi Valore predefinito: `5` |
| steps | Il numero di fasi analizzate da questa regola. In genere è necessario controllare solo le prime iterazioni. **Opzionale** Valori validi: float Valore predefinito: `10` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.poor_weight_initialization(),
rule_parameters={
"activation_inputs_regex": ".*relu_input|.*ReLU_input",
"threshold": "10.0",
"distribution_range": "0.001",
"patience": "5",
"steps": "10"
},
collections_to_save=[
CollectionConfig(
name="custom_relu_collection",
parameters={
"include_regex": ".*relu_input|.*ReLU_input",
"save_interval": "500"
}
)
]
)
]
```
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
Questa regola non è disponibile per l'algoritmo XGBoost.
## SaturatedActivation
Questa regola rileva se i livelli di attivazione tanh e sigmoid stanno diventando saturi. Un livello di attivazione è saturo quando l'input del livello è vicino al massimo o al minimo della funzione di attivazione. Il minimo e il massimo delle funzioni di attivazione tanh e sigmoid sono definiti dai rispettivi valori `min_threshold` e `max_thresholds`. Se l'attività di un nodo scende al di sotto della percentuale `threshold_inactivity`, è considerata satura. Se più di una percentuale `threshold_layer` di nodi è satura, la regola restituisce `True`.
Descrizioni dei parametri per la regola SaturatedActivation
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| collection\$1names | L'elenco dei nomi di raccolta i cui tensori vengono ispezionati dalla regola. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: stringa Valore predefinito: `".*tanh_input\|.*sigmoid_input".` |
| threshold\$1tanh\$1min | Le soglie minime e massime che definiscono gli estremi dell'input per una funzione di attivazione tanh, definite come: `(min_threshold, max_threshold)`. I valori predefiniti vengono determinati in base a una soglia di gradiente di fuga pari a 0,0000001. **Opzionale** Valori validi: float Valori predefiniti: `-9.4999` |
| threshold\$1tanh\$1max | Le soglie minime e massime che definiscono gli estremi dell'input per una funzione di attivazione tanh, definite come: `(min_threshold, max_threshold)`. I valori predefiniti vengono determinati in base a una soglia di gradiente di fuga pari a 0,0000001. **Opzionale** Valori validi: float Valori predefiniti: `9.4999` |
| threshold\$1sigmoid\$1min | Le soglie minime e massime che definiscono gli estremi dell'input per una funzione di attivazione sigma, definite come: `(min_threshold, max_threshold)`. I valori predefiniti vengono determinati in base a una soglia di gradiente di fuga pari a 0,0000001. **Opzionale** Valori validi: float Valori predefiniti: `-23` |
| threshold\$1sigmoid\$1max | Le soglie minime e massime che definiscono gli estremi dell'input per una funzione di attivazione sigma, definite come: `(min_threshold, max_threshold)`. I valori predefiniti vengono determinati in base a una soglia di gradiente di fuga pari a 0,0000001. **Opzionale** Valori validi: float Valori predefiniti: `16.99999` |
| threshold\$1inactivity | La percentuale di inattività al di sotto della quale il livello di attivazione è considerato saturo. L'attivazione potrebbe essere attiva all'inizio di una prova e poi diventare lentamente meno attiva durante il processo di addestramento. **Opzionale** Valori validi: float Valori predefiniti: `1.0` |
| threshold\$1layer | Restituisce `True` se il numero di attivazioni sature in un livello è maggiore della percentuale `threshold_layer`. Restituisce `False` se il numero di attivazioni sature in un livello è inferiore alla percentuale `threshold_layer`. **Opzionale** Valori validi: float Valori predefiniti: `50.0` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.saturated_activation(),
rule_parameters={
"tensor_regex": ".*tanh_input|.*sigmoid_input",
"threshold_tanh_min": "-9.4999",
"threshold_tanh_max": "9.4999",
"threshold_sigmoid_min": "-23",
"threshold_sigmoid_max": "16.99999",
"threshold_inactivity": "1.0",
"threshold_layer": "50.0"
},
collections_to_save=[
CollectionConfig(
name="custom_activations_collection",
parameters={
"include_regex": ".*tanh_input|.*sigmoid_input"
"save_interval": "500"
}
)
]
)
]
```
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
Questa regola non è disponibile per l'algoritmo XGBoost.
## VanishingGradient
Questa regola rileva se i gradienti in una prova diventano estremamente piccoli o scendono a una magnitudine zero. Se la media dei valori assoluti dei gradienti scende al di sotto di un valore `threshold` specificato, la regola restituisce `True`.
Descrizioni dei parametri per la regola VanishingGradient
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| threshold | Il valore al quale il gradiente svanisce.**Opzionale**Valori validi: floatValore predefinito: `0.0000001`. |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.vanishing_gradient(),
rule_parameters={
"threshold": "0.0000001"
},
collections_to_save=[
CollectionConfig(
name="gradients",
parameters={
"save_interval": "500"
}
)
]
)
]
```
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
Questa regola non è disponibile per l'algoritmo XGBoost.
## WeightUpdateRatio
Questa regola tiene traccia del rapporto tra aggiornamenti e pesi durante l’addestramento e rileva se tale rapporto diventa troppo grande o troppo piccolo. Se il rapporto tra gli aggiornamenti e i pesi è maggiore di `large_threshold value` o se questo rapporto è inferiore a `small_threshold`, la regola restituisce `True`.
Le condizioni per l’addestramento sono ottimali quando gli aggiornamenti sono commisurati ai gradienti. Gli aggiornamenti eccessivamente grandi possono allontanare i pesi dai valori ottimali e gli aggiornamenti molto piccoli determinano una convergenza molto lenta. Questa regola richiede che i pesi siano disponibili per due fasi di addestramento e `train.save_interval` deve essere impostato su `num_steps`.
Descrizioni dei parametri per la regola WeightUpdateRatio
| Nome parametro, | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| num\$1steps | Il numero di fasi attraverso le quali la regola verifica se il tensore è cambiato. Il numero di fasi attraverso le quali si desidera confrontare i rapporti di peso. Se non si passa alcun valore, la regola viene eseguita per impostazione predefinita rispetto alla fase corrente e alla fase salvata immediatamente precedente. Se si sovrascrive il valore predefinito passando un valore per questo parametro, il confronto viene effettuato tra i pesi alla fase `s` e alla fase `>= s - num_steps`. **Opzionale** Valori validi: numeri interi Valore predefinito: `None` |
| large\$1threshold | Il valore massimo che il rapporto tra gli aggiornamenti di peso può assumere prima che la regola ritorni `True`. **Opzionale** Valori validi: float Valore predefinito: `10.0` |
| small\$1threshold | Il valore minimo che può assumere il rapporto di aggiornamenti di peso, al di sotto del quale viene restituita la regola `True`. **Opzionale** Valori validi: float Valore predefinito: `0.00000001` |
| epsilon | Una piccola costante utilizzata per garantire che Debugger non si divide per zero quando si calcolano gli aggiornamenti del rapporto da pesare. **Opzionale** Valori validi: float Valore predefinito: `0.000000001` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.weight_update_ratio(),
rule_parameters={
"num_steps": "100",
"large_threshold": "10.0",
"small_threshold": "0.00000001",
"epsilon": "0.000000001"
},
collections_to_save=[
CollectionConfig(
name="weights",
parameters={
"train.save_interval": "100"
}
)
]
)
]
```
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
Questa regola non è disponibile per l'algoritmo XGBoost.
## AllZero
Questa regola rileva se tutti o una percentuale specificata dei valori del tensore sono zero.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost. È necessario specificare il parametro `collection_names` o `tensor_regex`. Se vengono specificati entrambi i parametri, la regola ispeziona l'unione dei tensori da entrambi i set.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola AllZero
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| collection\$1names | L'elenco dei nomi di raccolta i cui tensori vengono ispezionati dalla regola. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: `None` |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: `None` |
| threshold | Specificare la percentuale di valori nel tensore che deve essere zero per richiamare questa regola. **Opzionale** Valori validi: float Valore predefinito: 100 (in percentuale) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.all_zero(),
rule_parameters={
"tensor_regex": ".*",
"threshold": "100"
},
collections_to_save=[
CollectionConfig(
name="all",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## ClassImbalance
Questa regola misura gli squilibri di campionamento tra le classi e genera errori se lo squilibrio supera una soglia o se si verificano troppe predizioni errate per le classi sottorappresentate a causa dello squilibrio.
I modelli di classificazione richiedono classi ben bilanciate nel set di dati di addestramento o ponderazione/campionamento adeguato delle classi durante l’addestramento. La regola esegue i seguenti controlli:
+ Conta le occorrenze per classe. Se il rapporto tra il numero di campioni tra la classe più piccola e quella più grande è maggiore di `threshold_imbalance`, viene generato un errore.
+ Controlla l'accuratezza della previsione per classe. Se il ricampionamento o la ponderazione non sono stati applicati correttamente, il modello può raggiungere un'elevata precisione per la classe con molti campioni di addestramento, ma bassa precisione per le classi con pochi campioni di addestramento. Se una frazione di errori di predizioni errate per una determinata classe è superiore a `threshold_misprediction`, viene generato un errore.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola ClassImbalance
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| threshold\$1imbalance | Lo squilibrio accettabile tra il numero di campioni nella classe più piccola e nella classe più grande. Il superamento di questo valore di soglia genera un errore. **Opzionale** Valori validi: float Valore predefinito: `10` |
| threshold\$1misprediction | Un limite alla frazione di errori di predizione consentiti per ogni classe. Il superamento di questa soglia genera un errore. Le classi sottorappresentate sono maggiormente a rischio di superare questa soglia. **Opzionale** Valori validi: float Valore predefinito: `0.7` |
| samples | Numero di etichette che devono essere elaborate prima di valutare uno sbilanciamento. La regola potrebbe non essere attivata fino a quando non ha visto campioni sufficienti in diverse fasi. Più è alto il numero delle classi contenute dal set di dati, maggiore dovrebbe essere il numero `sample`. **Opzionale** Valori validi: numeri interi Valore predefinito: `500` (assumendo un set di dati come MNIST con 10 classi) |
| argmax | Se `True`, [np.argmax](https://docs.scipy.org/doc/numpy-1.9.3/reference/generated/numpy.argmax.html) viene applicato al tensore di previsione. Richiesto quando si dispone di un vettore di probabilità per ogni classe. Viene utilizzato per determinare quale classe ha la più alta probabilità. **Condizionale** Valori validi: booleani Valore predefinito: `False` |
| labels\$1regex | Il nome del tensore che contiene le etichette. **Opzionale** Valori validi: stringa Valore predefinito: `".*labels"` |
| predictions\$1regex | Il nome del tensore che contiene le previsioni. **Opzionale** Valori validi: stringa Valore predefinito: `".*predictions"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.class_imbalance(),
rule_parameters={
"threshold_imbalance": "10",
"threshold_misprediction": "0.7",
"samples": "500",
"argmax": "False",
"labels_regex": ".*labels",
"predictions_regex": ".*predictions"
},
collections_to_save=[
CollectionConfig(
name="custom_output_collection",
parameters={
"include_regex": ".*labels|.*predictions",
"save_interval": "500"
}
)
]
)
]
```
## LossNotDecreasing
Questa regola rileva quando la perdita non diminuisce di valore ad un tasso adeguato. Queste perdite devono essere scalari.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost. È necessario specificare il parametro `collection_names` o `tensor_regex`. Se vengono specificati entrambi i parametri, la regola ispeziona l'unione dei tensori da entrambi i set.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola LossNotDecreasing
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| collection\$1names | L'elenco dei nomi di raccolta i cui tensori vengono ispezionati dalla regola. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: `None` |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: `None` |
| use\$1losses\$1collection | Se impostato su `True`, cerca le perdite nella raccolta denominata "perdite" quando la raccolta è presente. **Opzionale** Valori validi: booleani Valore predefinito: `True` |
| num\$1steps | Il numero minimo di fasi dopo il quale la regola controlla se la perdita è diminuita. La valutazione delle regole avviene ogni `num_steps`. La regola confronta la perdita per questa fase con la perdita in una fase che è almeno `num_steps` dietro la fase corrente. Ad esempio, supponiamo che la perdita venga salvata ogni tre fasi, ma `num_steps` è impostato su 10. Alla fase 21, la perdita per la fase 21 viene confrontata con la perdita per la fase 9. La fase successiva in cui viene verificata la perdita è la fase 33, perché dieci fasi dopo la fase 21 c’è la fase 31 e alla fase 31 e 32 la perdita non viene salvata. **Opzionale** Valori validi: numeri interi Valore predefinito: `10` |
| diff\$1percent | La differenza percentuale minima con cui la perdita dovrebbe diminuire tra `num_steps`. **Opzionale** Valori validi: `0.0` < float < `100` Valore predefinito: `0.1` (in percentuale) |
| increase\$1threshold\$1percent | La soglia massima di aumento della perdita è consentita nel caso in cui la perdita sia in aumento. **Opzionale** Valori validi: `0` < float < `100` Valore predefinito: `5` (in percentuale) |
| mode | Il nome della modalità Debugger per eseguire la query dei valori del tensore per il controllo delle regole. Se non viene passato, per impostazione predefinita la regola controlla in ordine `mode.EVAL`, quindi `mode.TRAIN` e quindi `mode.GLOBAL`. **Opzionale** Valori validi: stringa (`EVAL`, `TRAIN` o `GLOBAL`) Valore predefinito: `GLOBAL` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.loss_not_decreasing(),
rule_parameters={
"tensor_regex": ".*",
"use_losses_collection": "True",
"num_steps": "10",
"diff_percent": "0.1",
"increase_threshold_percent": "5",
"mode": "GLOBAL"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## Overfit
Questa regola rileva se il modello è in eccesso rispetto ai dati di addestramento confrontando le perdite di convalida e addestramento.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
Un modo standard per evitare l'overfitting è regolarizzare il modello.
Descrizioni dei parametri per la regola di overfit
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
| start\$1step | La fase da cui iniziare a confrontare la perdita di convalida e di addestramento. **Opzionale** Valori validi: numeri interi Valore predefinito: `0` |
| patience | Il numero di fasi per i quali a `ratio_threshold` è consentito superare il valore impostato prima che il modello sia considerato in eccesso. **Opzionale** Valori validi: numeri interi Valore predefinito: `1` |
| ratio\$1threshold | Il rapporto massimo della differenza tra la perdita media di convalida e la perdita media di addestramento con la perdita media di addestramento. Se questa soglia viene superata per un `patience` certo numero di fasi, il modello è in eccesso e la regola viene restituita `True`. **Opzionale** Valori validi: float Valore predefinito: `0.1` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.overfit(),
rule_parameters={
"tensor_regex": ".*",
"start_step": "0",
"patience": "1",
"ratio_threshold": "0.1"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"train.save_interval": "100",
"eval.save_interval": "10"
}
)
]
)
]
```
## Overtraining
Questa regola rileva se un modello è sottoposto a un addestramento eccessivo. Dopo una serie di iterazioni di addestramento su un modello ben funzionante (diminuiscono sia le perdite di addestramento che quelle di convalida), il modello si avvicina al minimo della funzione di perdita e non migliora più. Se il modello continua l'addestramento, può succedere che la perdita di convalida inizi ad aumentare, perché il modello inizia a fare overfitting. Questa regola stabilisce soglie e condizioni per determinare se il modello non sta migliorando e previene i problemi di overfitting dovuti all'eccesso di adattamento.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
**Nota**
L'overtraining può essere evitato fermandosi anticipatamente. Per informazioni sull'arresto anticipato, consulta [Interrompere in anticipo i processi di addestramento](automatic-model-tuning-early-stopping.md). Per un esempio che mostra come utilizzare l’addestramento spot con Debugger, consulta la pagina [Abilitazione dell’addestramento spot con Debugger Amazon SageMaker](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/mxnet_spot_training/mxnet-spot-training-with-sagemakerdebugger.html).
Descrizioni dei parametri per la regola di Overtraining
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| patience\$1train | Il numero di fasi da attendere prima che la perdita di addestramento sia considerata come non più migliorabile. **Opzionale** Valori validi: numeri interi Valore predefinito: `5` |
| patience\$1validation | Il numero di fasi da attendere prima che la perdita di convalida non sia più migliorata.**Opzionale**Valori validi: numeri interiValore predefinito: `10` |
| delta | La soglia minima di quanto l'errore dovrebbe migliorare prima che venga considerato come un nuovo ottimale. **Opzionale** Valori validi: float Valore predefinito: `0.01` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.overtraining(),
rule_parameters={
"patience_train": "5",
"patience_validation": "10",
"delta": "0.01"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## SimilarAcrossRuns
Questa regola confronta i tensori raccolti da una prova di base con i tensori di un'altra prova.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola SimilarAcrossRuns
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| other\$1trials | Nome di un processo di addestramento completato di cui si desidera confrontare i tensori con quelli raccolti dalla corrente `base_trial`. **Campo obbligatorio** Valori validi: stringa |
| collection\$1names | L'elenco dei nomi di raccolta i cui tensori vengono ispezionati dalla regola. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.similar_across_runs(),
rule_parameters={
"other_trials": "",
"collection_names": "losses",
"tensor_regex": ".*"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## StalledTrainingRule
StalledTrainingRule rileva se non sono stati compiuti progressi nel processo di addestramento e lo interrompe se la regola viene attivata. Questa regola richiede il salvataggio periodico dei tensori in un intervallo di tempo definito dal relativo parametro `threshold`. Questa regola continua a monitorare i nuovi tensori e, se non è stato emesso alcun nuovo tensore per l'intervallo di soglia, viene attivata la regola.
Descrizioni dei parametri per la regola StalledTrainingRule
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| threshold | Una soglia che definisce per quanto tempo, in secondi, la regola attende l'output di un tensore prima di attivare un problema di addestramento in stallo. Il valore predefinito è 1800 secondi. **Opzionale** Valori validi: numeri interi Valore predefinito: `1800` |
| stop\$1training\$1on\$1fire | Se impostato su `True`, controlla se il processo di addestramento di base emette tensori in "`threshold`" secondi. **Opzionale** Valori validi: booleani Valore predefinito: `False` |
| training\$1job\$1name\$1prefix | Il prefisso del nome per il processo di addestramento di base. Se `stop_training_on_fire` è vero, la regola cerca i processi di addestramento SageMaker con questo prefisso nello stesso account. Se viene rilevata un'inattività, la regola esegue un'azione `StopTrainingJob`. Nota: se vengono trovati più processi con lo stesso prefisso, la regola ignora la terminazione. Per ogni processo di addestramento è importante che il prefisso sia impostato in modo univoco. **Opzionale** Valori validi: stringa |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.stalled_training_rule(),
rule_parameters={
"threshold": "1800",
"stop_training_on_fire": "True",
"training_job_name_prefix": ""
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## TensorVariance
Questa regola rileva se sono presenti tensori con varianze molto alte o basse. Varianze molto alte o basse in un tensore potrebbero portare alla saturazione dei neuroni, che riduce la capacità di apprendimento della rete neurale. La varianza molto elevata dei tensori può anche portare all'esplosione di tensori. Utilizzare questa regola per rilevare tali problemi in anticipo.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost. È necessario specificare il parametro `collection_names` o `tensor_regex`. Se vengono specificati entrambi i parametri, la regola ispeziona l'unione dei tensori da entrambi i set.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola TensorVariance
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| collection\$1names | L'elenco dei nomi di raccolta i cui tensori vengono ispezionati dalla regola. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
| max\$1threshold | La soglia per il limite superiore della varianza del tensore. **Opzionale** Valori validi: float Valore predefinito: nessuno |
| min\$1threshold | La soglia per il limite inferiore della varianza del tensore. **Opzionale** Valori validi: float Valore predefinito: nessuno |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.tensor_variance(),
rule_parameters={
"collection_names": "weights",
"max_threshold": "10",
"min_threshold": "0.00001",
},
collections_to_save=[
CollectionConfig(
name="weights",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## UnchangedTensor
Questa regola rileva se un tensore non cambia più tra una fase e l’altra.
Questa regola esegue il metodo [numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html) per verificare se il tensore non cambia.
Questa regola può essere applicata a uno dei framework di deep learning supportati (TensorFlow, MXNet e PyTorch) o all'algoritmo XGBoost. È necessario specificare il parametro `collection_names` o `tensor_regex`. Se vengono specificati entrambi i parametri, la regola ispeziona l'unione dei tensori da entrambi i set.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola UnchangedTensor
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| collection\$1names | L'elenco dei nomi di raccolta i cui tensori vengono ispezionati dalla regola. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: nessuno |
| num\$1steps | Il numero di fasi attraverso i quali la regola verifica se il tensore è cambiato. Questo controlla gli ultimi `num_steps` che sono disponibili. Non devono essere consecutivi. Se `num_steps` è 2, alla fase s non controlla necessariamente s-1 ed s. Se s-1 non è disponibile, controlla l'ultima fase disponibile insieme a s. In tal caso, controlla l'ultima fase disponibile con la fase corrente. **Opzionale** Valori validi: numeri interi Valore predefinito: `3` |
| rtol | Il parametro di tolleranza relativa da passare al `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` metodo. **Opzionale** Valori validi: float Valore predefinito: `1e-05` |
| atol | Il parametro di tolleranza assoluta da passare al `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)` metodo. **Opzionale** Valori validi: float Valore predefinito: `1e-08` |
| equal\$1nan | Se confrontare le NAN come uguali. Se `True`, le NAN nell'array di input a sono considerate uguali a NAN nell'array di input b nell'array di output. Questo parametro viene passato al metodo `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`. **Opzionale** Valori validi: booleani Valore predefinito: `False` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.unchanged_tensor(),
rule_parameters={
"collection_names": "losses",
"tensor_regex": "",
"num_steps": "3",
"rtol": "1e-05",
"atol": "1e-08",
"equal_nan": "False"
},
collections_to_save=[
CollectionConfig(
name="losses",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## CheckinPutimages
Questa regola controlla se le immagini di input sono state normalizzate correttamente. In particolare, rileva se la media dei dati campione differisce di più di un valore soglia da zero. Molti modelli di visione artificiale richiedono che i dati di input abbiano una media zero e una varianza unitaria.
Questa regola è applicabile alle applicazioni di deep learning.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola CheckInPutImages
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| threshold\$1mean | Una soglia che definisce in base alla media dei dati di input può differire da 0. **Opzionale** Valori validi: float Valore predefinito: `0.2` |
| threshold\$1samples | Il numero di immagini che devono essere campionate prima che un errore possa essere generato. Se il valore è troppo basso, la stima della media del set di dati sarà imprecisa. **Opzionale** Valori validi: numeri interi Valore predefinito: `500` |
| regex | Il nome del tensore dei dati di input. **Opzionale** Valori validi: stringa Valore predefinito: `".*hybridsequential0_input_0"` (il nome del tensore di ingresso per i modelli Apache MXNet utilizzando HybridSequential) |
| channel | La posizione del canale colore nell'array di forme del tensore di input. **Opzionale** Valori validi: numeri interi Valore predefinito: `1` (ad esempio, MXNet si aspetta dati di input sotto forma di (batch\$1size, canale, altezza, larghezza)) |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.check_input_images(),
rule_parameters={
"threshold_mean": "0.2",
"threshold_samples": "500",
"regex": ".*hybridsequential0_input_0",
"channel": "1"
},
collections_to_save=[
CollectionConfig(
name="custom_inputs_collection",
parameters={
"include_regex": ".*hybridsequential0_input_0",
"save_interval": "500"
}
)
]
)
]
```
## NLPSequenceRatio
Questa regola calcola il rapporto di token specifici dato il resto della sequenza di input utile per ottimizzare le prestazioni. Ad esempio, è possibile calcolare la percentuale di token di fine frase (EOS) di riempimento nella sequenza di input. Se il numero di token EOS è troppo alto, deve essere eseguita una strategia di bucketing alternativo. È inoltre possibile calcolare la percentuale di token sconosciuti nella sequenza di input. Se il numero di parole sconosciute è troppo alto, potrebbe essere usato un vocabolario alternativo.
Questa regola è applicabile alle applicazioni di deep learning.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola NLPSequenceRatio
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| tensor\$1regex | Un elenco di pattern regex utilizzati per limitare questo confronto a tensori con valori scalari specifici. La regola controlla solo i tensori che corrispondono ai pattern regex specificati nell'elenco. Se non vengono passati modelli, la regola confronta tutti i tensori raccolti nelle prove per impostazione predefinita. Solo i tensori scalari possono essere abbinati. **Opzionale** Valori validi: elenco di stringhe o stringa separata da virgole Valore predefinito: `".*embedding0_input_0"` (assumendo un incorporamento come livello iniziale della rete) |
| token\$1values | Una stringa di un elenco dei valori numerici dei token. Ad esempio, "3,0". **Opzionale** Valori validi: stringa di valori numerici separata da virgole Valore predefinito: `0` |
| token\$1thresholds\$1percent | Una stringa di un elenco di soglie (in percentuale) che corrispondono a ciascuna delle `token_values`. Ad esempio, "50,0, 50,0". **Opzionale** Valori validi: stringa separata da virgole di numeri in virgola mobile Valore predefinito: `"50"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.nlp_sequence_ratio(),
rule_parameters={
"tensor_regex": ".*embedding0_input_0",
"token_values": "0",
"token_thresholds_percent": "50"
},
collections_to_save=[
CollectionConfig(
name="custom_inputs_collection",
parameters={
"include_regex": ".*embedding0_input_0"
}
)
]
)
]
```
## Confusion
Questa regola valuta la bontà di una matrice di confusione per un problema di classificazione.
Crea una matrice di dimensioni `category_no*category_no` e la popola con i dati provenienti da coppie (`labels`, `predictions`). Per ogni coppia (`labels`, `predictions`), il conteggio `confusion[labels][predictions]` viene incrementato di 1. Quando la matrice è completamente popolata, il rapporto tra dati su valori diagonali dei dati e valori fuori diagonale viene valutato come segue:
+ Per gli elementi sulla diagonale: `confusion[i][i]/sum_j(confusion[j][j])>=min_diag`
+ Per gli elementi fuori dalla diagonale: `confusion[j][i])/sum_j(confusion[j][i])<=max_off_diag`
Questa regola può essere applicata all'algoritmo XGBoost.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola di confusione
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| category\$1no | Il numero di categorie. **Opzionale** Valori validi: numero intero ≥2 Valore predefinito: `"None"` |
| labels | La raccolta di tensori `labels` o un vettore 1-d di etichette vere. **Opzionale** Valori validi: stringa Valore predefinito: `"labels"` |
| predictions | La raccolta tensore `predictions` o un vettore 1-d di etichette stimate. **Opzionale** Valori validi: stringa Valore predefinito: `"predictions"` |
| labels\$1collection | La regola controlla i tensori in questa raccolta per `labels`. **Opzionale** Valori validi: stringa Valore predefinito: `"labels"` |
| predictions\$1collection | La regola controlla i tensori in questa raccolta per `predictions`. **Opzionale** Valori validi: stringa Valore predefinito: `"predictions"` |
| min\$1diag | La soglia minima per il rapporto dei dati sulla diagonale. **Opzionale** Valori validi: `0`≤float≤`1` Valore predefinito: `0.9` |
| max\$1off\$1diag | La soglia massima per il rapporto tra i dati fuori dalla diagonale. **Opzionale** Valori validi: `0`≤float≤`1` Valore predefinito: `0.1` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.confusion(),
rule_parameters={
"category_no": "10",
"labels": "labels",
"predictions": "predictions",
"labels_collection": "labels",
"predictions_collection": "predictions",
"min_diag": "0.9",
"max_off_diag": "0.1"
},
collections_to_save=[
CollectionConfig(
name="labels",
parameters={
"save_interval": "500"
}
),
CollectionConfig(
name="predictions",
parameters={
"include_regex": "500"
}
)
]
)
]
```
**Nota**
Questa regola detiene i valori predefiniti per i parametri facoltativi se i loro valori non sono specificati.
## FeatureImportanceOverweight
Questa regola accumula i pesi degli n maggiori valori di importanza delle caratteristiche per ogni fase e garantisce che non superino la soglia. Ad esempio, è possibile impostare la soglia per le 3 caratteristiche principali in modo che non contengano più dell'80% dei pesi totali del modello.
Questa regola è valida solo per l'algoritmo XGBoost.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola FeatureImportanceOverweight
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| threshold | Definisce la soglia della proporzione della somma cumulativa delle funzionalità più grandi `n`. Il numero `n` è definito dal parametro `nfeatures`. **Opzionale** Valori validi: float Valore predefinito: `0.8` |
| nfeatures | Il numero di funzionalità più grandi. **Opzionale** Valori validi: numeri interi Valore predefinito: `3` |
| tensor\$1regex | L'espressione regolare (regex) del tensore indica la regola da analizzare. **Opzionale** Valori validi: stringa Valore predefinito: `".*feature_importance/weight"` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.feature_importance_overweight(),
rule_parameters={
"threshold": "0.8",
"nfeatures": "3",
"tensor_regex": ".*feature_importance/weight"
},
collections_to_save=[
CollectionConfig(
name="feature_importance",
parameters={
"save_interval": "500"
}
)
]
)
]
```
## TreeDepth
Questa regola misura la profondità degli alberi in un modello XGBoost. XGBoost rifiuta le divisioni se non migliorano la perdita. Questo regolarizza l’addestramento. Di conseguenza, l'albero potrebbe non crescere così in profondità come definito dal parametro `depth`.
Questa regola è valida solo per l'algoritmo XGBoost.
Per un esempio di come configurare e distribuire una regola integrata, consulta [Come configurare le regole integrate di Debugger](use-debugger-built-in-rules.md).
Descrizioni dei parametri per la regola TreeDepth
| Nome parametro | Descrizione |
| --- | --- |
| base\$1trial | Il nome per il processo di addestramento di prova di base. Questo parametro viene impostato automaticamente sul processo di addestramento corrente da Debugger Amazon SageMaker. **Campo obbligatorio** Valori validi: stringa |
| depth | La profondità dell'albero. La profondità dell'albero si ottiene calcolando il logaritmo di base 2 dell'ID nodo più grande. **Opzionale** Valori validi: float Valore predefinito: `4` |
```
built_in_rules = [
Rule.sagemaker(
base_config=rule_configs.tree_depth(),
rule_parameters={
"depth": "4"
},
collections_to_save=[
CollectionConfig(
name="tree",
parameters={
"save_interval": "500"
}
)
]
)
]
```