Elenco delle regole integrate di Debugger

Utilizza le regole integrate di Debugger fornite da Amazon SageMaker Debugger e analizza le metriche e i tensori raccolti durante l'addestramento dei tuoi modelli. 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 SageMaker dei prezzi di Amazon.

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.

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.

CreateXgboostRapporto

La CreateXgboostReport regola raccoglie i tensori di output da un processo di formazione XGBoost 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:

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.

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 Configurazione delle regole integrate di 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.

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 Configurazione delle regole integrate di Debugger.

PoorWeightInizializzazione

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.

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 Configurazione delle regole integrate di 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.

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 Configurazione delle regole integrate di 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.

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 Configurazione delle regole integrate di Debugger.

WeightUpdateRapporto

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.

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 Configurazione delle regole integrate di 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 (TensorFlowMXNet 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 Configurazione delle regole integrate di Debugger.

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 (TensorFlowMXNet e PyTorch) o all'algoritmo XGBoost.

Per un esempio di come configurare e distribuire una regola integrata, consulta Configurazione delle regole integrate di Debugger.

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

LossNotDecrescente

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 (TensorFlowMXNet 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 Configurazione delle regole integrate di Debugger.

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 (TensorFlowMXNet e PyTorch) o all'algoritmo XGBoost.

Per un esempio di come configurare e distribuire una regola integrata, consulta Configurazione delle regole integrate di Debugger.

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 (TensorFlowMXNet e PyTorch) o all'algoritmo XGBoost.

Per un esempio di come configurare e distribuire una regola integrata, consulta Configurazione delle regole integrate di Debugger.

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

SimilarAcrossEsegue

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 (TensorFlowMXNet e PyTorch) o all'algoritmo XGBoost.

Per un esempio di come configurare e distribuire una regola integrata, consulta Configurazione delle regole integrate di Debugger.

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

StalledTrainingRegola

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.

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 (TensorFlowMXNet 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 Configurazione delle regole integrate di Debugger.

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 (TensorFlowMXNet 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 Configurazione delle regole integrate di Debugger.

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

CheckInputImmagini

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 Configurazione delle regole integrate di Debugger.

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

PNL SequenceRatio

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 di 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 Configurazione delle regole integrate di Debugger.

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 Configurazione delle regole integrate di Debugger.

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

FeatureImportanceSovrappeso

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 Configurazione delle regole integrate di Debugger.

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 Configurazione delle regole integrate di Debugger.

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