Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Liste des règles intégrées à Debugger
<a name="debugger-built-in-rules"></a>

Vous pouvez utiliser les règles intégrées à 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 du [kit SDK Python Amazon SageMaker](https://sagemaker.readthedocs.io/en/stable) ou des opérations d'API SageMaker 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 [Tarification d'Amazon SageMaker](https://aws.amazon.com/sagemaker/pricing/).

**Note**  
Le nombre maximal de règles intégrées que vous pouvez associer à une tâche d'entraînement est de 20. SageMaker Debugger gère entièrement les règles intégrées et analyse votre tâche d'entraînement de façon synchrone.

**Important**  
Pour utiliser les nouvelles fonctions de Debugger, vous devez mettre à niveau le kit SDK Python SageMaker et la bibliothèque cliente SMDebug. Dans votre noyau iPython, bloc-notes Jupyter ou environnement JupyterLab, exécutez le code suivant pour installer les dernières versions des bibliothèques et redémarrer le noyau.  

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

## Règle Debugger
<a name="debugger-built-in-rules-Rule"></a>

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


| Domaine de validité | Règles intégrées | 
| --- | --- | 
| Rapport d’entraînement pour les tâches d’entraînement SageMaker AI XGboost |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-built-in-rules.html)  | 

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


| Domaine de validité | Règles intégrées | 
| --- | --- | 
| Cadres de deep learning (TensorFlow, Apache MXNet et PyTorch) |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| Cadres de deep learning (TensorFlow, MXNet et PyTorch) et algorithme XGBoost  |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| Applications de deep learning |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-built-in-rules.html)  | 
| Algorithme XGBoost |  [See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/debugger-built-in-rules.html)  | 

**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.
+ Pour obtenir des instructions complètes et des exemples d’utilisation des règles intégrées Debugger, consultez [Exemple de code pour les règles intégrées Debugger](debugger-built-in-rules-example.md#debugger-deploy-built-in-rules).
+ Pour obtenir des instructions complètes sur l'utilisation des règles intégrées avec les opérations d'API SageMaker de bas niveau, consultez [Configurer le débogueur à l'aide de l'API SageMaker](debugger-createtrainingjob-api.md).

## CreateXgboostReport
<a name="create-xgboost-report"></a>

La règle CreateXgBoostReport collecte les tenseurs de sortie à partir 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 règle CreateXgboostReport collecte par défaut les tenseurs de sortie suivants : 
+ `hyperparameters` — Enregistre à la première étape
+ `metrics` — Enregistre la perte et la précision toutes les 5 étapes
+ `feature_importance` — Enregistre toutes les 5 étapes
+ `predictions` — Enregistre toutes les 5 étapes
+ `labels` — Enregistre toutes les 5 étapes

Description des paramètres de la règle CreateXgboostReport


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger.<br />**Obligatoire**<br />Valeurs valides : string | 

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

## DeadRelu
<a name="dead-relu"></a>

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

Description des paramètres de la règle DeadRelu


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| tensor\_regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance.<br />**Facultatif**<br />Valeurs valides : liste de chaînes ou chaîne séparée par des virgules <br />Valeur par défaut : `".*relu_output"` | 
| threshold\_inactivity | Définit un niveau d'activité sous lequel une unité ReLU est considérée morte. Une unité ReLU peut être active au début d'un essai, puis peut mourir lentement au cours du processus d'entraînement. Si l'unité ReLU est active au-dessous de `threshold_inactivity`, elle est considérée comme morte.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeurs par défaut : `1.0` (en pourcentage) | 
| threshold\_layer | Renvoie `True` si le pourcentage d'unités ReLU inactives dans une couche est supérieur à `threshold_layer`.<br />Renvoie `False` si le pourcentage d'unités ReLU inactives dans une couche est inférieur à `threshold_layer`.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeurs par défaut : `50.0` (en pourcentage) | 

```
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, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

**Note**  
Cette règle n'est pas disponible pour l'algorithme XGBoost.

## ExplodingTensor
<a name="exploding-tensor"></a>

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

Description des paramètres de la règle ExplodingTensor


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| collection\_names | Liste des noms de collection dont la règle inspecte les tenseurs.<br />**Facultatif**<br />Valeurs valides : string<br />Valeur par défaut : `None` | 
| tensor\_regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance.<br />**Facultatif**<br />Valeurs valides : string <br />Valeur par défaut : `None` | 
| only\_nan |  `True` pour contrôler les tenseurs `base_trial` uniquement pour les valeurs `NaN` et non pour l'infini. <br />`False` pour traiter les valeurs `NaN` et l'infini comme des valeurs explosives, et pour les contrôler.<br />**Facultatif**<br />Valeur par défaut : `False` | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.{{exploding_tensor}}(),
        rule_parameters={
                "tensor_regex": "{{.*gradient}}",
                "only_nan": "{{False}}"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="{{gradients}}", 
                parameters={
                    "save_interval": "{{500}}"
                }
            )
        ]
    )
]
```

Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

**Note**  
Cette règle n'est pas disponible pour l'algorithme XGBoost.

## PoorWeightInitialization
<a name="poor-weight-initialization"></a>

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

Description des paramètres de la règle PoorWeightInitialization


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| activation\_inputs\_regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance.<br />**Facultatif**<br />Valeurs valides : string<br />Valeur par défaut : `".*relu_input"` | 
| threshold | Si le rapport entre les variances minimale et maximale des pondérations par couche dépasse `threshold` à une étape, la règle renvoie `True`.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `10.0` | 
| distribution\_range | Si la différence minimale entre le 5e et le 95e centiles de la distribution des gradients est inférieure à `distribution_range`, la règle renvoie `True`.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `0.001` | 
| patience | Nombre d'étapes qu'il convient d'attendre jusqu'à ce que la perte ne soit plus considérée comme décroissante.<br />**Facultatif**<br />Valeurs valides : nombre entier<br />Valeur par défaut : `5` | 
| steps | Nombre d'étapes analysées par cette règle. En général, vous n'avez besoin de vérifier que les premières itérations.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `10` | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.{{poor_weight_initialization}}(),
        rule_parameters={
                "activation_inputs_regex": "{{.*relu_input|.*ReLU_input}}",
                "threshold": "{{10.0}}",
                "distribution_range": "{{0.001}}",
                "patience": "{{5}}",
                "steps": "{{10}}"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="{{custom_relu_collection}}", 
                parameters={
                    "{{include_regex}}": "{{.*relu_input|.*ReLU_input}}",
                    "{{save_interval}}": "{{500}}"
                } 
            )
        ]
    )
]
```

Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

**Note**  
Cette règle n'est pas disponible pour l'algorithme XGBoost.

## SaturatedActivation
<a name="saturated-activation"></a>

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

Description des paramètres de la règle SaturatedActivation


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| collection\_names | Liste des noms de collection dont la règle inspecte les tenseurs.<br />**Facultatif**<br />Valeurs valides : liste de chaînes ou chaîne séparée par des virgules<br />Valeur par défaut : aucune. | 
| tensor\_regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance.<br />**Facultatif**<br />Valeurs valides : string <br />Valeur par défaut : `".*tanh_input\|.*sigmoid_input".` | 
| threshold\_tanh\_min | Seuils minimum et maximum qui définissent les extrêmes d'entrée d'une fonction d'activation tanh, définis comme : `(min_threshold, max_threshold)`. Les valeurs par défaut sont déterminées en fonction d'un seuil de gradient disparaissant de 0,0000001.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeurs par défaut : `-9.4999` | 
| threshold\_tanh\_max | Seuils minimum et maximum qui définissent les extrêmes d'entrée d'une fonction d'activation tanh, définis comme : `(min_threshold, max_threshold)`. Les valeurs par défaut sont déterminées en fonction d'un seuil de gradient disparaissant de 0,0000001.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeurs par défaut : `9.4999` | 
| threshold\_sigmoid\_min | Seuils minimum et maximum qui définissent les extrêmes d'entrée d'une fonction d'activation sigmoïde, définis comme : `(min_threshold, max_threshold)`. Les valeurs par défaut sont déterminées en fonction d'un seuil de gradient disparaissant de 0,0000001.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeurs par défaut : `-23` | 
| threshold\_sigmoid\_max | Seuils minimum et maximum qui définissent les extrêmes d'entrée d'une fonction d'activation sigmoïde, définis comme : `(min_threshold, max_threshold)`. Les valeurs par défaut sont déterminées en fonction d'un seuil de gradient disparaissant de 0,0000001.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeurs par défaut : `16.99999` | 
| threshold\_inactivity | Pourcentage d'inactivité sous lequel la couche d'activation est considérée comme saturée. L'activation peut être active au début d'un essai, puis devenir lentement moins active au cours du processus d'entraînement.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeurs par défaut : `1.0` | 
| threshold\_layer | Renvoie `True` si le nombre d'activations saturées dans une couche est supérieur au pourcentage `threshold_layer`.<br />Renvoie `False` si le nombre d'activations saturées dans une couche est inférieur au pourcentage `threshold_layer`.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeurs par défaut : `50.0` | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.{{saturated_activation}}(),
        rule_parameters={
                "tensor_regex": "{{.*tanh_input|.*sigmoid_input}}",
                "threshold_tanh_min": "{{-9.4999}}",
                "threshold_tanh_max": "{{9.4999}}",
                "threshold_sigmoid_min": "{{-23}}",
                "threshold_sigmoid_max": "{{16.99999}}",
                "threshold_inactivity": "{{1.0}}",
                "threshold_layer": "{{50.0}}"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="{{custom_activations_collection}}",
                parameters={
                    "{{include_regex}}": "{{.*tanh_input|.*sigmoid_input}}"
                    "{{save_interval}}": "{{500}}"
                } 
            )
        ]
    )
]
```

Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

**Note**  
Cette règle n'est pas disponible pour l'algorithme XGBoost.

## VanishingGradient
<a name="vanishing-gradient"></a>

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

Description des paramètres de la règle VanishingGradient


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| threshold | Valeur à laquelle le gradient est considéré comme disparaissant.**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `0.0000001`. | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.{{vanishing_gradient}}(),
        rule_parameters={
                "threshold": "{{0.0000001}}"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="{{gradients}}", 
                parameters={
                    "{{save_interval}}": "{{500}}"
                } 
            )
        ]
    )
]
```

Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

**Note**  
Cette règle n'est pas disponible pour l'algorithme XGBoost.

## WeightUpdateRatio
<a name="weight-update-ratio"></a>

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

Description des paramètres de la règle WeightUpdateRatio


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| num\_steps | Nombre d'étapes dans lesquelles la règle vérifie si le tenseur a changé. <br />Nombre d'étapes dans lesquelles vous souhaitez comparer les rapports de pondération. Si vous ne transmettez aucune valeur, la règle s'exécute par défaut sur l'étape actuelle et l'étape enregistrée immédiatement avant. Si vous remplacez la valeur par défaut en passant une valeur pour ce paramètre, la comparaison est effectuée entre les pondérations à l'étape `s` et à une étape `>= s - num_steps`.<br />**Facultatif**<br />Valeurs valides : nombre entier<br />Valeur par défaut : `None` | 
| large\_threshold | Valeur maximale que le rapport entre les mises à jour et la pondération peut prendre avant que la règle renvoie `True`. <br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `10.0` | 
| small\_threshold | Valeur minimale que le rapport entre les mises à jour et la pondération peut prendre sous laquelle la règle renvoie `True`.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `0.00000001` | 
| epsilon | Petite constante utilisée pour s'assurer que Debugger ne divise pas par zéro lors du calcul du rapport entre les mises à jour et la pondération.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `0.000000001` | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.{{weight_update_ratio}}(),
        rule_parameters={
                "num_steps": "{{100}}",
                "large_threshold": "{{10.0}}",
                "small_threshold": "{{0.00000001}}",
                "epsilon": "{{0.000000001}}"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="{{weights}}", 
                parameters={
                    "{{train.save_interval}}": "{{100}}"
                } 
            )
        ]
    )
]
```

Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

**Note**  
Cette règle n'est pas disponible pour l'algorithme XGBoost.

## AllZero
<a name="all-zero"></a>

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 à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à 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, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

Description des paramètres de la règle AllZero


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| collection\_names | Liste des noms de collection dont la règle inspecte les tenseurs.<br />**Facultatif**<br />Valeurs valides : liste de chaînes ou chaîne séparée par des virgules<br />Valeur par défaut : `None` | 
| tensor\_regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance.<br />**Facultatif**<br />Valeurs valides : liste de chaînes ou chaîne séparée par des virgules<br />Valeur par défaut : `None` | 
| threshold | Spécifie le pourcentage des valeurs du tenseur qui doivent être nulles pour que cette règle soit invoquée. <br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : 100 (en pourcentage) | 

```
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
<a name="class-imbalance"></a>

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 :
+  Elle compte les occurrences par classe. Si le rapport des nombres d'échantillons entre la plus petite classe et la plus grande classe est supérieur à `threshold_imbalance`, une erreur est levée.
+  Elle vérifie la précision des prédictions par classe. Si le rééchantillonnage ou la pondération n'ont pas été appliqués correctement, le modèle peut atteindre une grande précision pour la classe avec de nombreux échantillons d'entraînement mais une faible précision pour les classes avec peu d'échantillons d'entraînement. Si une fraction de fausses prédictions pour une certaine classe dépasse `threshold_misprediction`, une erreur est générée.

Cette règle peut être appliquée à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à l'algorithme XGBoost.

Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

Description des paramètres de la règle ClassImbalance


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| threshold\_imbalance | Déséquilibre acceptable entre le nombre d'échantillons dans la catégorie la plus petite et dans la catégorie la plus grande. Le dépassement de cette valeur de seuil génère une erreur.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `10` | 
| threshold\_misprediction | Limite de la fraction de fausses prédictions permise pour chaque classe. Le dépassement de ce seuil génère une erreur. Les classes sous-représentées risquent le plus de franchir ce seuil. <br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `0.7` | 
| samples | Nombre d'étiquettes à traiter avant qu'un déséquilibre soit évalué. La règle peut ne pas être déclenchée tant qu'elle n'a pas vu suffisamment d'échantillons dans plusieurs étapes. Plus votre jeu de données contient de classes, plus le nombre `sample` doit être grand. <br />**Facultatif**<br />Valeurs valides : nombre entier<br />Valeur par défaut : `500` (dans l'hypothèse d'un jeu de données comme MNIST avec 10 classes) | 
| argmax | Si `True`, [np.argmax](https://docs.scipy.org/doc/numpy-1.9.3/reference/generated/numpy.argmax.html) est appliqué au tenseur de prédiction. Obligatoire lorsque vous avez un vecteur de probabilités pour chaque classe. Il est utilisé pour déterminer quelle classe a la probabilité la plus élevée.<br />**Conditionnel**<br />Valeurs valides : booléen<br />Valeur par défaut : `False` | 
| labels\_regex | Nom du tenseur qui contient les étiquettes.<br />**Facultatif**<br />Valeurs valides : string<br />Valeur par défaut : `".*labels"` | 
| predictions\_regex | Nom du tenseur qui contient les prédictions.<br />**Facultatif**<br />Valeurs valides : string<br />Valeur par défaut : `".*predictions"` | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.{{class_imbalance}}(),
        rule_parameters={
                "threshold_imbalance": "{{10}}",
                "threshold_misprediction": "{{0.7}}",
                "samples": "{{500}}",
                "argmax": "{{False}}",
                "labels_regex": "{{.*labels}}",
                "predictions_regex": "{{.*predictions}}"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="{{custom_output_collection}}",
                parameters={
                    "include_regex": "{{.*labels|.*predictions}}",
                    "save_interval": "{{500}}"
                } 
            )
        ]
    )
]
```

## LossNotDecreasing
<a name="loss-not-decreasing"></a>

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 à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à 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, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

Description des paramètres de la règle LossNotDecreasing


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| collection\_names | Liste des noms de collection dont la règle inspecte les tenseurs.<br />**Facultatif**<br />Valeurs valides : liste de chaînes ou chaîne séparée par des virgules<br />Valeur par défaut : `None` | 
| tensor\_regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance.<br />**Facultatif**<br />Valeurs valides : liste de chaînes ou chaîne séparée par des virgules <br />Valeur par défaut : `None` | 
| use\_losses\_collection | Si ce paramètre a pour valeur `True`, il recherche les pertes dans la collection nommée « pertes » lorsque cette collection est présente.<br />**Facultatif**<br />Valeurs valides : booléen<br />Valeur par défaut : `True` | 
| num\_steps | Nombre minimal d'étapes après lesquelles la règle vérifie si la perte a diminué. L'évaluation de la règle se produit toutes les `num_steps` étapes. La règle compare la perte pour cette étape avec la perte à une étape qui se trouve au moins `num_steps` étapes derrière l'étape actuelle. Par exemple, supposons que la perte soit enregistrée toutes les trois étapes, mais que le paramètre `num_steps` soit défini sur 10. À l'étape 21, la perte pour l'étape 21 est comparée à la perte pour l'étape 9. L'étape suivante à laquelle la perte est vérifiée est l'étape 33, car dix étapes après l'étape 21, il y a l'étape 31, et aux étapes 31 et 32, la perte n'est pas enregistrée. <br />**Facultatif**<br />Valeurs valides : nombre entier<br />Valeur par défaut : `10` | 
| diff\_percent | Différence minimale en pourcentage par laquelle la perte devrait diminuer entre `num_steps`.<br />**Facultatif**<br />Valeurs valides : `0.0` < valeur flottante < `100`<br />Valeur par défaut : `0.1` (en pourcentage) | 
| increase\_threshold\_percent | Pourcentage maximal de perte autorisé en cas d'augmentation de la perte<br />**Facultatif**<br />Valeurs valides : `0` < valeur flottante < `100`<br />Valeur par défaut : `5` (en pourcentage) | 
| mode | Nom du mode Debugger d'interrogation des valeurs de tenseur pour la vérification des règles. Si la vérification n'a pas abouti, la règle vérifie par défaut et dans cet ordre les valeurs `mode.EVAL`, puis `mode.TRAIN`, puis `mode.GLOBAL`. <br />**Facultatif**<br />Valeurs valides : Chaîne (`EVAL`, `TRAIN` ou `GLOBAL`)<br />Valeur par défaut : `GLOBAL` | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.{{loss_not_decreasing}}(),
        rule_parameters={
                "tensor_regex": "{{.*}}",
                "use_losses_collection": "{{True}}",
                "num_steps": "{{10}}",
                "diff_percent": "{{0.1}}",
                "increase_threshold_percent": "{{5}}",
                "mode": "{{GLOBAL}}"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="{{losses}}", 
                parameters={
                    "{{save_interval}}": "{{500}}"
                } 
            )
        ]
    )
]
```

## Overfit
<a name="overfit"></a>

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 à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à l'algorithme XGBoost.

Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

**Note**  
Une façon standard d'éviter le surajustement est de régulariser votre modèle.

Description des paramètres de la règle Overfit


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| tensor\_regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance.<br />**Facultatif**<br />Valeurs valides : liste de chaînes ou chaîne séparée par des virgules <br />Valeur par défaut : aucune. | 
| start\_step | Étape à partir de laquelle commencer à comparer la perte de validation et d'entraînement.<br />**Facultatif**<br />Valeurs valides : nombre entier<br />Valeur par défaut : `0` | 
| patience | Nombre d'étapes pour lesquelles `ratio_threshold` est autorisé à dépasser la valeur définie avant que le modèle ne soit considéré comme surajusté.<br />**Facultatif**<br />Valeurs valides : nombre entier<br />Valeur par défaut : `1` | 
| ratio\_threshold | Rapport maximal entre la différence entre la perte moyenne de validation et la perte moyenne d'entraînement, et la perte moyenne d'entraînement. Si ce seuil est dépassé pour un nombre d'étapes égal à `patience`, le modèle est surajusté et la règle renvoie `True`.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `0.1` | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.{{overfit}}(),
        rule_parameters={
                "tensor_regex": "{{.*}}",
                "start_step": "{{0}}",
                "patience": "{{1}}",
                "ratio_threshold": "{{0.1}}"
        },
        collections_to_save=[
            CollectionConfig(
                name="{{losses}}", 
                parameters={
                    "train.save_interval": "{{100}}",
                    "eval.save_interval": "{{10}}"
                } 
            )
        ]
    )
]
```

## Overtraining
<a name="overtraining"></a>

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 à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à l'algorithme XGBoost.

Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

**Note**  
Le surentraînement peut être évité par un arrêt anticipé. Pour plus d’informations sur l’arrêt anticipé, consultez [Arrêter de manière précoce des tâches d'entraînement](automatic-model-tuning-early-stopping.md). Pour obtenir un exemple décrivant l’utilisation de l’entraînement Spot avec Debugger, consultez [Enable Spot Training with Amazon SageMaker Debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/mxnet_spot_training/mxnet-spot-training-with-sagemakerdebugger.html). 

Description des paramètres de la règle Overtraining


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| patience\_train | Nombre d'étapes à attendre avant que la perte d'entraînement soit considérée comme ne s'améliorant plus.<br />**Facultatif**<br />Valeurs valides : nombre entier<br />Valeur par défaut : `5` | 
| patience\_validation | Nombre d'étapes à attendre avant que la perte de validation soit considérée comme ne s'améliorant plus.**Facultatif**<br />Valeurs valides : nombre entier<br />Valeur par défaut : `10` | 
| delta | Seuil minimal correspondant à l'ampleur par laquelle l'erreur devrait s'améliorer avant qu'elle soit considérée comme une erreur optimale.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `0.01` | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.{{overtraining}}(),
        rule_parameters={
                "patience_train": "{{5}}",
                "patience_validation": "{{10}}",
                "delta": "{{0.01}}"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="{{losses}}", 
                parameters={
                    "{{save_interval}}": "{{500}}"
                } 
            )
        ]
    )
]
```

## SimilarAcrossRuns
<a name="similar-across-runs"></a>

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 à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à l'algorithme XGBoost.

Pour obtenir un exemple de configuration et de déploiement d’une règle intégrée, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

Description des paramètres de la règle SimilarAcrossRuns


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| other\_trials | Nom de tâche d'entraînement terminée dont vous souhaitez comparer les tenseurs à ceux collectés à partir de l'essai `base_trial` actuel.<br />**Obligatoire**<br />Valeurs valides : string | 
| collection\_names | Liste des noms de collection dont la règle inspecte les tenseurs.<br />**Facultatif**<br />Valeurs valides : liste de chaînes ou chaîne séparée par des virgules<br />Valeur par défaut : aucune. | 
| tensor\_regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance.<br />**Facultatif**<br />Valeurs valides : liste de chaînes ou chaîne séparée par des virgules <br />Valeur par défaut : aucune. | 

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

## StalledTrainingRrule
<a name="stalled-training"></a>

StalledTrainingRule détecte si la tâche d'entraînement ne présente pas de progrès. Cette dernière s'arrête si la règle se déclenche. 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. 

Description des paramètres de la règle StalledTrainingRule


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| threshold | Seuil qui définit le temps en secondes pendant lequel la règle attend une sortie de tenseur avant de déclencher un problème de blocage d'entraînement. La valeur par défaut est 1 800 secondes.<br />**Facultatif**<br />Valeurs valides : nombre entier<br />Valeur par défaut : `1800` | 
| stop\_training\_on\_fire | Si la règle est définie sur `True`, elle surveille si la tâche d'entraînement de base génère des tenseurs en « `threshold` » secondes.<br />**Facultatif**<br />Valeurs valides : booléen<br />Valeur par défaut : `False` | 
| training\_job\_name\_prefix | Préfixe du nom de la tâche d'entraînement de base. Si la valeur de `stop_training_on_fire` est true, la règle recherche les tâches d'entraînement SageMaker avec ce préfixe dans le même compte. Si une inactivité est détectée, la règle prend une action `StopTrainingJob`. Notez que si plusieurs tâches ont été trouvées avec le même préfixe, la règle ignore l'arrêt. Il est important que chaque tâche d'entraînement ait un préfixe unique.<br />**Facultatif**<br />Valeurs valides : string | 

```
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
<a name="tensor-variance"></a>

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 à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à 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, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

Description des paramètres de la règle TensorVariance


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| collection\_names | Liste des noms de collection dont la règle inspecte les tenseurs.<br />**Facultatif**<br />Valeurs valides : liste de chaînes ou chaîne séparée par des virgules<br />Valeur par défaut : aucune. | 
| tensor\_regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance.<br />**Facultatif**<br />Valeurs valides : liste de chaînes ou chaîne séparée par des virgules <br />Valeur par défaut : aucune. | 
| max\_threshold | Seuil pour la limite supérieure de la variance des tenseurs.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : aucune. | 
| min\_threshold | Seuil pour la limite inférieure de la variance des tenseurs.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : aucune. | 

```
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
<a name="unchanged-tensor"></a>

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](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html) pour vérifier si le tenseur ne change pas.

Cette règle peut être appliquée à l'un des cadres de deep learning pris en charge (TensorFlow, MxNet et PyTorch) ou à 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, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

Description des paramètres de la règle UnchangedTensor


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| collection\_names | Liste des noms de collection dont la règle inspecte les tenseurs.<br />**Facultatif**<br />Valeurs valides : liste de chaînes ou chaîne séparée par des virgules<br />Valeur par défaut : aucune. | 
| tensor\_regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance.<br />**Facultatif**<br />Valeurs valides : liste de chaînes ou chaîne séparée par des virgules <br />Valeur par défaut : aucune. | 
| num\_steps | Nombre d'étapes dans lesquelles la règle vérifie si le tenseur a changé. <br />Les `num_steps` dernières étapes disponibles sont vérifiées. Elles n'ont pas besoin d'être consécutives. Si `num_steps` a pour valeur 2, à l'étape s, la règle ne vérifie pas nécessairement s-1 ni s. Si s-1 n'est pas disponible, la règle vérifie la dernière étape disponible ainsi que s. Dans ce cas, elle vérifie la dernière étape disponible avec l'étape actuelle.<br />**Facultatif**<br />Valeurs valides : nombre entier<br />Valeur par défaut : `3` | 
| rtol | Paramètre de tolérance relative à transmettre à la méthode `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`. <br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `1e-05` | 
| atol | Paramètre de tolérance absolue à transmettre à la méthode `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `1e-08` | 
| equal\_nan | S'il convient de comparer les valeurs NaN en tant qu'égales. Si `True`, les valeurs NaN du tableau d'entrée a sont considérées comme égales aux valeurs NaN du tableau d'entrée b dans le tableau de sortie. Ce paramètre est transmis à la méthode `[numpy.allclose](https://docs.scipy.org/doc/numpy/reference/generated/numpy.allclose.html)`.<br />**Facultatif**<br />Valeurs valides : booléen<br />Valeur par défaut : `False` | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.{{unchanged_tensor}}(),
        rule_parameters={
                "collection_names": "{{losses}}",
                "tensor_regex": "",
                "num_steps": "{{3}}",
                "rtol": "{{1e-05}}",
                "atol": "{{1e-08}}",
                "equal_nan": "{{False}}"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="{{losses}}", 
                parameters={
                    "{{save_interval}}": "{{500}}"
                } 
            )
        ]
    )
]
```

## CheckInputImages
<a name="checkinput-mages"></a>

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, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

Description des paramètres de la règle CheckInputImages


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| threshold\_mean | Seuil qui définit la marge selon laquelle la moyenne des données en entrée peut différer de 0.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `0.2` | 
| threshold\_samples | Nombre d'images qui doivent être échantillonnées avant qu'une erreur puisse être générée. Si la valeur est trop faible, l'estimation de la moyenne du jeu de données est inexacte.<br />**Facultatif**<br />Valeurs valides : nombre entier<br />Valeur par défaut : `500` | 
| regex | Nom du tenseur de données en entrée.<br />**Facultatif**<br />Valeurs valides : string<br />Valeur par défaut : `".*hybridsequential0_input_0"` (nom du tenseur d'entrée pour les modèles Apache MXNet utilisant HybridSequential) | 
| channel | Position du canal de couleur dans le tableau de forme du tenseur d'entrée. <br />**Facultatif**<br />Valeurs valides : nombre entier<br />Valeur par défaut : `1` (par exemple, MXNet attend des données d'entrée sous la forme (batch\_size, channel, height, width)) | 

```
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
<a name="nlp-sequence-ratio"></a>

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 fin de phrase (EOS) de remplissage dans votre séquence d'entrée. 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, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

Description des paramètres de la règle NLPSequenceRatio


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| tensor\_regex | Liste de modèles regex utilisés pour limiter la comparaison à des tenseurs à valeur scalaire spécifiques. La règle inspecte uniquement les tenseurs qui correspondent aux modèles regex spécifiés dans la liste. Si aucun modèle n'est transmis, la règle compare par défaut tous les tenseurs collectés dans les essais. Seuls les tenseurs à valeur scalaire peuvent être mis en correspondance.<br />**Facultatif**<br />Valeurs valides : liste de chaînes ou chaîne séparée par des virgules <br />Valeur par défaut : `".*embedding0_input_0"` (en supposant une intégration en tant que couche initiale du réseau) | 
| token\_values | Chaîne d'une liste des valeurs numériques des jetons. Par exemple, « 3, 0 ».<br />**Facultatif**<br />Valeurs valides : chaîne de valeurs numériques séparées par des virgules<br />Valeur par défaut : `0` | 
| token\_thresholds\_percent | Chaîne d'une liste de seuils (pourcentages) correspondant à chaque valeur `token_values`. Par exemple, "50.0, 50.0".<br />**Facultatif**<br />Valeurs valides : chaîne de valeurs flottantes séparées par des virgules<br />Valeur par défaut : `"50"` | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.{{nlp_sequence_ratio}}(),
        rule_parameters={
                "tensor_regex": "{{.*embedding0_input_0}}",
                "token_values": "{{0}}",
                "token_thresholds_percent": "{{50}}"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="{{custom_inputs_collection}}", 
                parameters={
                    "{{include_regex}}": "{{{{.*embedding0_input_0}}}}"
                } 
            )
        ]
    )
]
```

## Confusion
<a name="confusion"></a>

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 :
+ Pour les éléments sur la diagonale : `confusion[i][i]/sum_j(confusion[j][j])>=min_diag`
+ Pour les éléments hors diagonale : `confusion[j][i])/sum_j(confusion[j][i])<=max_off_diag`

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, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

Description des paramètres de la règle Confusion


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| category\_no | Nombre de catégories.<br />**Facultatif**<br />Valeurs valides : nombre entier ≥2<br />Valeur par défaut : `"None"` | 
| labels | Collection de tenseurs `labels` ou un vecteur 1-d des étiquettes true. <br />**Facultatif**<br />Valeurs valides : string<br />Valeur par défaut : `"labels"` | 
| predictions | Collection de tenseurs `predictions` ou un vecteur 1-d des étiquettes estimées. <br />**Facultatif**<br />Valeurs valides : string<br />Valeur par défaut : `"predictions"` | 
| labels\_collection | La règle inspecte les tenseurs de cette collection pour `labels`.<br />**Facultatif**<br />Valeurs valides : string<br />Valeur par défaut : `"labels"` | 
| predictions\_collection | La règle inspecte les tenseurs de cette collection pour `predictions`.<br />**Facultatif**<br />Valeurs valides : string<br />Valeur par défaut : `"predictions"` | 
| min\_diag | Seuil minimal du rapport des données sur la diagonale.<br />**Facultatif**<br />Valeurs valides : `0`≤valeur flottante≤`1`<br />Valeur par défaut : `0.9` | 
| max\_off\_diag | Seuil maximal du rapport des données hors diagonale.<br />**Facultatif**<br />Valeurs valides : `0`≤valeur flottante≤`1`<br />Valeur par défaut : `0.1` | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.{{confusion}}(),
        rule_parameters={
                "category_no": "{{10}}",
                "labels": "{{labels}}",
                "predictions": "{{predictions}}",
                "labels_collection": "{{labels}}",
                "predictions_collection": "{{predictions}}",
                "min_diag": "{{0.9}}",
                "max_off_diag": "{{0.1}}"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="{{labels}}",
                parameters={
                    "save_interval": "{{500}}"
                } 
            ),
            CollectionConfig(
                name="{{predictions}}",
                parameters={
                    "include_regex": "{{500}}"
                } 
            )
        ]
    )
]
```

**Note**  
Cette règle déduit des valeurs par défaut pour les paramètres facultatifs si leurs valeurs ne sont pas spécifiées.

## FeatureImportanceOverweight
<a name="feature_importance_overweight"></a>

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, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

Description des paramètres de la règle FeatureImportanceOverweight


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| threshold | Définit le seuil de la proportion de la somme cumulée des `n` fonctions les plus grandes. Le nombre `n` est défini par le paramètre `nfeatures`.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `0.8` | 
| nfeatures | Nombre de fonctions les plus grandes.<br />**Facultatif**<br />Valeurs valides : nombre entier<br />Valeur par défaut : `3` | 
| tensor\_regex | L'expression régulière (regex) du tenseur nomme la règle à analyser.<br />**Facultatif**<br />Valeurs valides : string<br />Valeur par défaut : `".*feature_importance/weight"` | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.{{feature_importance_overweight}}(),
        rule_parameters={
                "threshold": "{{0.8}}",
                "nfeatures": "{{3}}",
                "tensor_regex": "{{.*feature_importance/weight}}"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="{{feature_importance}}", 
                parameters={
                    "{{save_interval}}": "{{500}}"
                } 
            )
        ]
    )
]
```

## TreeDepth
<a name="tree-depth"></a>

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, consultez [Configuration des règles intégrées Debugger](use-debugger-built-in-rules.md).

Description des paramètres de la règle TreeDepth


| Nom du paramètre | Description | 
| --- | --- | 
| base\_trial | Nom de la tâche d'entraînement d'essai de base. Ce paramètre est automatiquement défini sur la tâche d'entraînement actuelle par Amazon SageMaker Debugger. <br />**Obligatoire**<br />Valeurs valides : string | 
| depth | Profondeur de l'arbre. La profondeur de l'arbre est obtenue en calculant le logarithme en base 2 du plus grand ID de nœud.<br />**Facultatif**<br />Valeurs valides : valeur flottante<br />Valeur par défaut : `4` | 

```
built_in_rules = [
    Rule.sagemaker(
        base_config=rule_configs.{{tree_depth}}(),
        rule_parameters={
                "{{depth}}": "{{4}}"
        },
        collections_to_save=[ 
            CollectionConfig(
                name="{{tree}}", 
                parameters={
                    "{{save_interval}}": "{{500}}"
                } 
            )
        ]
    )
]
```