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

Vous pouvez utiliser les règles intégrées du Debugger, fournies par Amazon SageMaker Debugger, pour analyser les métriques et les tenseurs collectés lors de l'entraînement de vos modèles. Vous trouverez ci-dessous la liste des règles du débogueur, notamment des informations et un exemple de configuration et de déploiement de chaque règle intégrée.

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 d'Amazon SageMaker Python SDK ou des SageMaker API opérations 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 du débogueur

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.

Règles intégrées à Debugger pour la génération de rapports d'entraînement

Règles intégrées à Debugger pour le débogage des données d'entraînement de modèle (tenseurs de sortie)

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.

CreateXgboostReport

La CreateXgboostReport règle collecte les tenseurs de sortie d'une tâche de XGBoost formation 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 :

Descriptions des paramètres de la CreateXgboostReport règle

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 de R inactif eLUs dans une couche est supérieur à la threshold_layer valeur de R inactifeLUs, la règle est renvoyéeTrue.

Descriptions des paramètres de la DeadRelu règle

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 Comment configurer les règles intégrées du 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.

Descriptions des paramètres de la ExplodingTensor règle

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 Comment configurer les règles intégrées du Debugger.

PoorWeightInitialization

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é.

Descriptions des paramètres de la PoorWeightInitialization règle

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 Comment configurer les règles intégrées du 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.

Descriptions des paramètres de la SaturatedActivation règle

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 Comment configurer les règles intégrées du 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.

Descriptions des paramètres de la VanishingGradient règle

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 Comment configurer les règles intégrées du 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.

Descriptions des paramètres de la WeightUpdateRatio règle

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 Comment configurer les règles intégrées du 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 profond pris en charge (TensorFlow,MXNet, et PyTorch), soit à l'XGBoostalgorithme. 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 Comment configurer les règles intégrées du Debugger.

Descriptions des paramètres de la AllZero règle

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 profond pris en charge (TensorFlow,MXNet, et PyTorch), soit à l'XGBoostalgorithme.

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

Descriptions des paramètres de la ClassImbalance règle

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

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 profond pris en charge (TensorFlow,MXNet, et PyTorch), soit à l'XGBoostalgorithme. 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 Comment configurer les règles intégrées du Debugger.

Descriptions des paramètres de la LossNotDecreasing règle

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 profond pris en charge (TensorFlow,MXNet, et PyTorch), soit à l'XGBoostalgorithme.

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

Description des paramètres de la règle 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

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 profond pris en charge (TensorFlow,MXNet, et PyTorch), soit à l'XGBoostalgorithme.

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

Description des paramètres de la règle 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

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 profond pris en charge (TensorFlow,MXNet, et PyTorch), soit à l'XGBoostalgorithme.

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

Descriptions des paramètres de la SimilarAcrossRuns règle

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

Descriptions des paramètres de la StalledTrainingRule règle

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 profond pris en charge (TensorFlow,MXNet, et PyTorch), soit à l'XGBoostalgorithme. 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 Comment configurer les règles intégrées du Debugger.

Descriptions des paramètres de la TensorVariance règle

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 profond pris en charge (TensorFlow,MXNet, et PyTorch), soit à l'XGBoostalgorithme. 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 Comment configurer les règles intégrées du Debugger.

Descriptions des paramètres de la UnchangedTensor règle

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

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 Comment configurer les règles intégrées du Debugger.

Descriptions des paramètres de la CheckInputImages règle

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

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 padding end-of-sentence (EOS) dans votre séquence de saisie. Si le nombre de EOS jetons est trop élevé, une autre stratégie 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 Comment configurer les règles intégrées du Debugger.

Descriptions des paramètres de la NLPSequenceRatio règle

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'XGBoostalgorithme.

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

Description des paramètres de la règle Confusion

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

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'XGBoostalgorithme.

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

Descriptions des paramètres de la FeatureImportanceOverweight règle

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 XGBoost modèle. XGBoostrejette les scissions si elles n'améliorent pas les pertes. 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'XGBoostalgorithme.

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

Descriptions des paramètres de la TreeDepth règle

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