Liste des règles intégrées du Debugger

Utilisez les règles intégrées du Debugger fournies par Amazon SageMaker Debugger et analysez les métriques et les tenseurs collectés lors de l'entraînement de vos modèles. Les règles intégrées de Debugger contrôlent diverses conditions communes qui sont essentielles à la réussite d'une tâche d'entraînement. Vous pouvez appeler les règles intégrées à l'aide du SDK Amazon SageMaker Python ou des opérations d' SageMaker API de bas niveau. L'utilisation des règles intégrées n'entraîne aucun coût supplémentaire. Pour plus d'informations sur la facturation, consultez la page de SageMaker tarification d'Amazon.

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

Règle Debugger

Les règles suivantes sont les règles intégrées Debugger qui peuvent être appelées à l'aide de la méthode de classe Rule.sagemaker.

Pour utiliser les règles intégrées avec les valeurs de paramètre par défaut, utilisez le format de configuration suivant :

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())
]

Pour utiliser les règles intégrées avec la personnalisation des valeurs des paramètres, utilisez le format de configuration suivant :

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

Pour voir les clés disponibles pour le paramètre rule_parameters, consultez les tables de description des paramètres.

Des exemples de codes de configuration de règle sont fournis pour chaque règle intégrée sous les tables de description des paramètres.

CreateXgboostRapport

La CreateXgboostReport règle collecte les tenseurs de sortie d'une tâche d'entraînement XGBoost et génère automatiquement un rapport d'entraînement complet. Vous pouvez télécharger un rapport de profilage complet pendant qu'une tâche d'entraînement est en cours d'exécution ou une fois la tâche d'entraînement terminée, et vérifier l'avancement de l'entraînement ou le résultat final de la tâche d'entraînement. La CreateXgboostReport règle collecte les tenseurs de sortie suivants par défaut :

rules=[
    Rule.sagemaker(
        rule_configs.create_xgboost_report()
    )  
]

DeadRelu

Cette règle détecte les cas où le pourcentage de fonctions d'activation d'unité ReLU (unité linéaire rectifiée) dans un essai est considéré comme mort parce que leur activité d'activation est descendue sous un seuil. Si le pourcentage d'unités ReLU inactives dans une couche est supérieur à la valeur threshold_layer d'unités ReLU inactives, la règle renvoie 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"
                } 
            )
        ]
    )
]

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de Debugger.

ExplodingTensor

Cette règle détecte si les tenseurs émis pendant l'entraînement ont des valeurs non finies, infinies ou non numériques (NaN, Not a Number). Si une valeur non finie est détectée, la règle renvoie 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"
                }
            )
        ]
    )
]

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de Debugger.

PoorWeightInitialisation

Cette règle détecte si les paramètres de votre modèle ont été mal initialisés.

Une bonne initialisation rompt la symétrie des pondérations et des gradients dans un réseau neuronal, et maintient des variances d'activation proportionnelles entre les couches. Sinon, le réseau neuronal n'apprend pas efficacement. Des initialiseurs comme Xavier visent à maintenir une variance constante entre les activations, ce qui est particulièrement pertinent dans le cadre de l'entraînement de réseaux neuronaux très profonds. Une trop petite initialisation peut conduire à des gradients disparaissant. Une trop grande initialisation peut conduire à des gradients explosifs. Cette règle vérifie la variance des entrées d'activation entre les couches, la distribution des gradients et la convergence des pertes pour les étapes initiales afin de déterminer si un réseau neuronal a été mal initialisé.

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

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de Debugger.

SaturatedActivation

Cette règle détecte si les couches d'activation tanh et sigmoïde deviennent saturées. Une couche d'activation est saturée lorsque l'entrée de la couche est proche du maximum ou du minimum de la fonction d'activation. Le minimum et le maximum des fonctions d'activation tanh et sigmoïde sont définis par leurs valeurs min_threshold et max_thresholds respectives. Si l'activité d'un nœud descend en dessous du pourcentage threshold_inactivity, il est considéré saturé. Si un pourcentage supérieur à threshold_layer des nœuds sont saturés, la règle renvoie 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"
                } 
            )
        ]
    )
]

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de Debugger.

VanishingGradient

Cette règle détecte si les gradients d'un essai deviennent extrêmement faibles ou atteignent une grandeur nulle. Si la moyenne des valeurs absolues des gradients descend en dessous d'un threshold spécifié, la règle renvoie 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"
                } 
            )
        ]
    )
]

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de Debugger.

WeightUpdateRatio

Cette règle assure le suivi du rapport entre les mises à jour et les pondérations pendant l'entraînement et détecte si ce rapport devient trop grand ou trop petit. Si le rapport entre les mises à jour et les pondérations est supérieur à large_threshold value ou s'il est inférieur à small_threshold, la règle renvoie True.

Les conditions d'entraînement sont les meilleures lorsque les mises à jour sont proportionnelles aux gradients. Des mises à jour excessivement grandes peuvent éloigner les pondérations des valeurs optimales, et des mises à jour très petites entraînent une convergence très lente. Cette règle exige que les pondérations soient disponibles pour deux étapes d'entraînement. Le paramètre train.save_interval doit donc être égal à 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"
                } 
            )
        ]
    )
]

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de Debugger.

AllZero

Cette règle détecte si la totalité ou un pourcentage spécifié des valeurs dans les tenseurs sont nulles.

Cette règle peut être appliquée soit à l'un des frameworks d'apprentissage en profondeur pris en charge (MXnetTensorFlow, et PyTorch), soit à l'algorithme XGBoost. Vous devez spécifier le paramètre collection_names ou tensor_regex. Si les deux paramètres sont spécifiés, la règle inspecte l'union des tenseurs à partir des deux ensembles.

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de 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

Cette règle mesure les déséquilibres d'échantillonnage entre les classes et génère des erreurs si le déséquilibre dépasse un seuil ou si trop d'erreurs de prédiction pour les classes sous-représentées se produisent en raison du déséquilibre.

Les modèles de classification exigent des classes bien équilibrées dans le jeu de données d'entraînement ou une pondération/un échantillonnage correct des classes pendant l'entraînement. La règle effectue les vérifications suivantes :

Cette règle peut être appliquée soit à l'un des frameworks d'apprentissage en profondeur pris en charge (MXnetTensorFlow, et PyTorch), soit à l'algorithme XGBoost.

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de 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"
                } 
            )
        ]
    )
]

LossNotDécroissant

Cette règle détecte lorsque la perte ne diminue pas en valeur à un taux adéquat. Ces pertes doivent être des scalaires.

Cette règle peut être appliquée soit à l'un des frameworks d'apprentissage en profondeur pris en charge (MXnetTensorFlow, et PyTorch), soit à l'algorithme XGBoost. Vous devez spécifier le paramètre collection_names ou tensor_regex. Si les deux paramètres sont spécifiés, la règle inspecte l'union des tenseurs à partir des deux ensembles.

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de 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

Cette règle détecte si votre modèle est surajusté aux données d'entraînement en comparant les pertes de validation et d'entraînement.

Cette règle peut être appliquée soit à l'un des frameworks d'apprentissage en profondeur pris en charge (MXnetTensorFlow, et PyTorch), soit à l'algorithme XGBoost.

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de 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

Cette règle détecte si un modèle est surentraîné. Après un certain nombre d'itérations d'entraînement sur un modèle performant (les pertes d'entraînement et de validation diminuent), le modèle s'approche d'un minimum de la fonction de perte et ne s'améliore plus. Si le modèle poursuit l'entraînement, il peut arriver que la perte de validation commence à augmenter, car le modèle commence à se surajuster. Cette règle définit des seuils et des conditions pour déterminer si le modèle ne s'améliore pas, et empêche les problèmes de surajustement dus à un surentraînement.

Cette règle peut être appliquée soit à l'un des frameworks d'apprentissage en profondeur pris en charge (MXnetTensorFlow, et PyTorch), soit à l'algorithme XGBoost.

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de 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"
                } 
            )
        ]
    )
]

SimilarAcrossFonctionne

Cette règle compare les tenseurs collectés à partir d'un essai de base à ceux issus d'un autre essai.

Cette règle peut être appliquée soit à l'un des frameworks d'apprentissage en profondeur pris en charge (MXnetTensorFlow, et PyTorch), soit à l'algorithme XGBoost.

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de 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"
                } 
            )
        ]
    )
]

StalledTrainingRègle

StalledTrainingRule détecte si aucun progrès n'a été réalisé dans le cadre de la tâche de formation et arrête la tâche de formation si la règle est annulée. Cette règle exige que les tenseurs soient enregistrés périodiquement dans un intervalle de temps défini par son paramètre threshold. Elle continue de contrôler les nouveaux tenseurs, et si aucun nouveau tenseur n'a été émis pour la règle d'intervalle de seuil, elle est déclenchée.

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

Cette règle détecte si vous avez des tenseurs avec des variances très élevées ou très faibles. Des variances très élevées ou faibles dans un tenseur peuvent conduire à une saturation neuronale et réduire la capacité d'apprentissage du réseau neuronal. Une variance très élevée dans les tenseurs peut aussi éventuellement conduire à l'explosion des tenseurs. Utilisez cette règle pour détecter rapidement ces problèmes.

Cette règle peut être appliquée soit à l'un des frameworks d'apprentissage en profondeur pris en charge (MXnetTensorFlow, et PyTorch), soit à l'algorithme XGBoost. Vous devez spécifier le paramètre collection_names ou tensor_regex. Si les deux paramètres sont spécifiés, la règle inspecte l'union des tenseurs à partir des deux ensembles.

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de 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

Cette règle détecte si un tenseur ne change plus d'une étape à l'autre.

Cette règle exécute la méthode numpsy.allclose pour vérifier si le tenseur ne change pas.

Cette règle peut être appliquée soit à l'un des frameworks d'apprentissage en profondeur pris en charge (MXnetTensorFlow, et PyTorch), soit à l'algorithme XGBoost. Vous devez spécifier le paramètre collection_names ou tensor_regex. Si les deux paramètres sont spécifiés, la règle inspecte l'union des tenseurs à partir des deux ensembles.

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de 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"
                } 
            )
        ]
    )
]

CheckInputDes images

Cette règle vérifie si les images d'entrée ont été correctement normalisées. Plus précisément, elle détecte si la moyenne des données d'échantillonnage diffère de plus d'une valeur seuil par rapport à zéro. De nombreux modèles de vision par ordinateur exigent que les données d'entrée aient une variance unitaire et moyenne nulle.

Cette règle s'applique aux applications de deep learning.

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de 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

Cette règle calcule le rapport de jetons spécifiques compte tenu du reste de la séquence d'entrée qui est utile pour optimiser les performances. Par exemple, vous pouvez calculer le pourcentage de jetons de remplissage end-of-sentence (EOS) dans votre séquence de saisie. Si le nombre de jetons EOS est trop élevé, une autre politique de compartimentage doit être appliquée. Vous pouvez également calculer le pourcentage de jetons inconnus dans votre séquence d'entrée. Si le nombre de mots inconnus est trop élevé, un autre vocabulaire peut être utilisé.

Cette règle s'applique aux applications de deep learning.

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de 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

Cette règle évalue la validité d'une matrice de confusion pour un problème de classification.

Elle crée une matrice de taille category_no*category_no et la remplit avec des données provenant de paires (labels, predictions). Pour chaque paire (labels, predictions), le nombre dans confusion[labels][predictions] est incrémenté de 1. Lorsque la matrice est entièrement remplie, le rapport entre les valeurs sur la diagonale et les valeurs hors diagonale est évalué comme suit :

Cette règle peut être appliquée à l'algorithme XGBoost.

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de 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"
                } 
            )
        ]
    )
]

FeatureImportanceSurpoids

Cette règle accumule les pondérations des n valeurs les plus élevées d'importance de la fonction par étape et garantit qu'elles ne dépassent pas le seuil. Par exemple, vous pouvez définir le seuil pour les trois premières fonctions de manière à ce qu'elles ne contiennent pas plus de 80 % des pondérations totales du modèle.

Cette règle n'est valide que pour l'algorithme XGBoost.

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de 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

Cette règle mesure la profondeur des arbres dans un modèle XGBoost. XGBoost rejette les fractionnements s'ils n'améliorent pas la perte. Cela régularise l'entraînement. Par conséquent, l'arbre peut ne pas pousser aussi profondément que cela est défini par le paramètre depth.

Cette règle n'est valide que pour l'algorithme XGBoost.

Pour obtenir un exemple de configuration et de déploiement d'une règle intégrée, veuillez consulter Configuration des règles intégrées de 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"
                } 
            )
        ]
    )
]