Elenco delle regole integrate del Debugger

Puoi utilizzare le regole integrate di Debugger, fornite da Amazon SageMaker Debugger, per analizzare metriche e tensori raccolti durante l'addestramento dei tuoi modelli. Di seguito sono elencate le regole del debugger, incluse informazioni e un esempio su come configurare e distribuire ciascuna 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 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 dei prezzi di Amazon SageMaker AI.

import sys
import IPython
!{sys.executable} -m pip install -U sagemaker smdebug
IPython.Application.instance().kernel.do_shutdown(True)

Regola del 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

Regole integrate di Debugger per il debug dei dati di addestramento del modello (tensori di output)

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.

CreateXgboostReport

La CreateXgboostReport regola raccoglie i tensori di output da un processo di XGBoost formazione e genera automaticamente un rapporto di formazione 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 CreateXgboostReport regola raccoglie i seguenti tensori di output per impostazione predefinita:

Descrizioni dei parametri per la regola CreateXgboostReport

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 Re inattivo LUs in un livello è maggiore del threshold_layer valore di Re LUs inattivo, la regola viene restituita. True

Descrizioni dei parametri per la regola DeadRelu

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 del Debugger.

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

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 del Debugger.

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

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 del Debugger.

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

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 del Debugger.

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

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 del Debugger.

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

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 del Debugger.

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 del Debugger.

Descrizioni dei parametri per la regola AllZero

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:

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 del Debugger.

Descrizioni dei parametri per la regola ClassImbalance

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 del Debugger.

Descrizioni dei parametri per la regola LossNotDecreasing

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 del Debugger.

Descrizioni dei parametri per la regola di overfit

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 del Debugger.

Descrizioni dei parametri per la regola di Overtraining

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 del Debugger.

Descrizioni dei parametri per la regola SimilarAcrossRuns

built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.similar_across_runs(),
        rule_parameters={
                "other_trials": "<specify-another-job-name>",
                "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 formazione e interrompe il processo di formazione 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

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": "<specify-training-base-job-name>"
        },
        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 del Debugger.

Descrizioni dei parametri per la regola TensorVariance

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 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 del Debugger.

Descrizioni dei parametri per la regola UnchangedTensor

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 del Debugger.

Descrizioni dei parametri per la regola CheckInputImages

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"
                } 
            )
        ]
    )
]

NLPSequenceRapporto

Questa regola calcola il rapporto di token specifici dato il resto della sequenza di input utile per ottimizzare le prestazioni. Ad esempio, puoi calcolare la percentuale di token padding end-of-sentence (EOS) 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 del Debugger.

Descrizioni dei parametri per la regola del rapporto NLPSequence

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:

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 del Debugger.

Descrizioni dei parametri per la regola di confusione

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"
                } 
            )
        ]
    )
]

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 del Debugger.

Descrizioni dei parametri per la FeatureImportanceOverweight regola

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 suddivisioni 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' XGBoost algoritmo.

Per un esempio di come configurare e distribuire una regola integrata, consulta Come configurare le regole integrate del Debugger.

Descrizioni dei parametri per la TreeDepth regola

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"
                } 
            )
        ]
    )
]