Configuration des règles intégrées de Debugger

Les règles intégrées d'Amazon SageMaker Debugger analysent les tenseurs émis au cours de l'entraînement d'un modèle. SageMaker Debugger propose l'opération d'API Rule, qui contrôle la progression et les erreurs de la tâche d'entraînement afin d'assurer la réussite de l'entraînement de votre modèle. Par exemple, les règles peuvent détecter si les gradients deviennent trop grands ou trop petits, si un modèle est surajusté ou surentraîné et si une tâche d'entraînement ne diminue pas la fonction de perte et ne s'améliore pas. Pour afficher la liste complète des règles intégrées disponibles, consultez Liste des règles intégrées du Debugger.

Dans les rubriques suivantes, découvrez comment utiliser les règles intégrées de SageMaker Debugger.

Utiliser les règles intégrées de Debugger avec les paramètres par défaut

Pour spécifier des règles intégrées de Debugger dans un estimateur, vous devez configurer un objet de liste . L'exemple de code suivant présente la structure de base permettant de répertorier les règles intégrées de Debugger :

from sagemaker.debugger import Rule, 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()),
    ... # You can also append more profiler rules in the ProfilerRule.sagemaker(rule_configs.*()) format.
]

Pour de plus amples informations sur les valeurs de paramètres par défaut et les descriptions de la règle intégrée, veuillez consulter Liste des règles intégrées du Debugger.

Pour trouver la référence de l'API SageMaker Debugger, consultez sagemaker.debugger.rule_configs et sagemaker.debugger.Rule.

Par exemple, pour inspecter les performances globales d'entraînement et la progression de votre modèle, créez un estimateur SageMaker avec la configuration de règle intégrée suivante.

from sagemaker.debugger import Rule, rule_configs

rules=[
    Rule.sagemaker(rule_configs.loss_not_decreasing()),
    Rule.sagemaker(rule_configs.overfit()),
    Rule.sagemaker(rule_configs.overtraining()),
    Rule.sagemaker(rule_configs.stalled_training_rule())
]

Lorsque vous démarrez la tâche d'entraînement, Debugger collecte les données d'utilisation des ressources système toutes les 500 millisecondes et les valeurs de perte et de précision toutes les 500 étapes par défaut. Debugger analyse l'utilisation des ressources pour identifier si votre modèle rencontre des problèmes de goulet d'étranglement. loss_not_decreasing, overfit, overtraining etstalled_training_rule contrôlent si votre modèle optimise la fonction de perte sans ces problèmes d'entraînement. Si les règles détectent des anomalies d'entraînement, le statut d'évaluation de la règle passe à IssueFound. Vous pouvez configurer des actions automatisées, telles que la notification des problèmes d'entraînement et l'arrêt des tâches d'entraînement, à l'aide d'Amazon CloudWatch Events et de AWS Lambda. Pour plus d'informations, consultez Action sur les règles Amazon SageMaker Debugger.

Utiliser des règles intégrées de Debugger avec des valeurs de paramètres personnalisées

Si vous souhaitez ajuster les valeurs des paramètres des règles intégrées et personnaliser l'expression regex de la collection de tenseurs, configurez les paramètres base_config et rule_parameters pour les méthodes de classe ProfilerRule.sagemaker et Rule.sagemaker. Dans le cas des méthodes de classe Rule.sagemaker, vous pouvez également personnaliser les collections de tenseurs via le paramètre collections_to_save. Vous trouverez des instructions sur l'utilisation de la classe CollectionConfig dans la section Configurer les collections de tenseurs en utilisant l'API CollectionConfig.

Utilisez le modèle de configuration suivant pour personnaliser les valeurs des paramètres des règles intégrées. En modifiant les paramètres de règle comme vous le souhaitez, vous pouvez ajuster la sensibilité des règles pour le déclenchement.

• L'argument base_config sert à appeler les méthodes de règles intégrées.

• L'argument rule_parameters sert à ajuster les valeurs de clé par défaut des règles intégrées répertoriées dans Liste des règles intégrées du Debugger.

• L'argument collections_to_save prend une configuration de tenseur via l'API CollectionConfig, qui nécessite les arguments name et parameters.

  • Pour voir les collections de tenseurs disponibles pour name, consultez Debugger Built-in Tensor Collections.

  • Pour obtenir la liste complète des parameters ajustables, consultez Debugger CollectionConfig API.

Pour de plus amples informations sur la classe, les méthodes et les paramètres des règles Debugger, veuillez consulter SageMaker Debugger Rule class dans Amazon SageMaker Python SDK.

from sagemaker.debugger import Rule, ProfilerRule, rule_configs, CollectionConfig

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

Les descriptions de paramètres et des exemples de personnalisation de valeur sont fournis pour chaque règle dans Liste des règles intégrées du Debugger.

Exemples de blocs-notes et de code pour configurer les règles de Debugger

Dans les sections suivantes, vous trouverez des exemples de blocs-notes et de code montrant comment utiliser les règles de Debugger pour contrôler les tâches d'entraînement SageMaker.

Rubriques

• Exemples de bloc-notes de règles intégrées Debugger
• Exemple de code pour les règles intégrées de Debugger
• Utiliser les règles intégrées de Debugger avec modifications des paramètres

Exemples de bloc-notes de règles intégrées Debugger

Les exemples de blocs-notes suivants montrent comment utiliser les règles intégrées de Debugger lorsque vous exécutez des tâches d'entraînement avec Amazon SageMaker :

• Utilisation d'une règle intégrée SageMaker Debugger avec TensorFlow

• Utilisation d'une règle intégrée SageMaker Debugger avec l'entraînement Spot géré et MXNet

• Utilisation d'une règle intégrée SageMaker Debugger avec des modifications de paramètres pour une analyse des tâches d'entraînement en temps réel avec XGBoost

Lorsque vous exécutez les exemples de blocs-notes dans SageMaker Studio, vous pouvez trouver la version d'évaluation de la tâche d'entraînement créée sous l'onglet Studio Expermient List (Liste d'expériences Studio). Par exemple, comme illustré dans la capture d'écran suivante, vous pouvez rechercher et ouvrir une fenêtre Describe Trial Component (Décrire le composant d'essai) de votre tâche d'entraînement actuelle. Sous l'onglet Debugger, vous pouvez vérifier si les règles de Debugger, vanishing_gradient() et loss_not_decreasing(), contrôlent la séance de formation en parallèle. Pour obtenir des instructions complètes sur la façon de trouver vos composants d'essai de tâche d'entraînement dans l'interface utilisateur de Studio, consultez SageMaker Studio - View Experiments, Trials, and Trial Components.

Il existe deux façons d'utiliser les règles intégrées de Debugger dans l'environnement SageMaker : déployer les règles intégrées au fur et à mesure qu'elles sont préparées ou ajuster leurs paramètres à votre guise. Les rubriques suivantes vous montrent comment utiliser les règles intégrées avec des exemples de codes.

Exemple de code pour les règles intégrées de Debugger

L'exemple de code ci-après illustre comment configurer une règle intégrée Debugger à l'aide de la méthode Rule.sagemaker. Pour spécifier les règles intégrées que vous souhaitez exécuter, utilisez l'opération d'API rules_configs permettant d'appeler les règles intégrées. Pour obtenir la liste complète des règles intégrées et des valeurs de paramètres par défaut de Debugger, veuillez consulter Liste des règles intégrées du Debugger.

import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import Rule, CollectionConfig, rule_configs

# call built-in rules that you want to use.
built_in_rules=[ 
            Rule.sagemaker(rule_configs.vanishing_gradient())
            Rule.sagemaker(rule_configs.loss_not_decreasing())
]

# construct a SageMaker estimator with the Debugger built-in rules
sagemaker_estimator=TensorFlow(
    entry_point='directory/to/your_training_script.py',
    role=sm.get_execution_role(),
    base_job_name='debugger-built-in-rules-demo',
    instance_count=1,
    instance_type="ml.p3.2xlarge",
    framework_version="2.9.0",
    py_version="py39",

    # debugger-specific arguments below
    rules=built_in_rules
)
sagemaker_estimator.fit()

Note

Les règles intégrées de Debugger s'exécutent en parallèle avec votre tâche d'entraînement. Le nombre maximal de conteneurs de règles intégrées pour une tâche d'entraînement est de 20.

Pour de plus amples informations sur la classe, les méthodes et les paramètres des règles de Debugger, veuillez consulter SageMaker Debugger Rule class dans Amazon SageMaker Python SDK.

Pour trouver un exemple d'ajustement des paramètres de règles Debugger, consultez la section Utiliser les règles intégrées de Debugger avec modifications des paramètres suivante.

Utiliser les règles intégrées de Debugger avec modifications des paramètres

L'exemple de code suivant présente la structure des règles intégrées permettant d'ajuster les paramètres. Dans cet exemple, la règle stalled_training_rule collecte la collection de tenseurs losses à partir d'une tâche d'entraînement toutes les 50 étapes et d'une étape d'évaluation toutes les 10 étapes. Si le processus d'entraînement commence à ralentir et ne collecte pas de sorties tenseurs pendant 120 secondes, la règle stalled_training_rule arrête la tâche d'entraînement.

import sagemaker
from sagemaker.tensorflow import TensorFlow
from sagemaker.debugger import Rule, CollectionConfig, rule_configs

# call the built-in rules and modify the CollectionConfig parameters

base_job_name_prefix= 'smdebug-stalled-demo-' + str(int(time.time()))

built_in_rules_modified=[
    Rule.sagemaker(
        base_config=rule_configs.stalled_training_rule(),
        rule_parameters={
                'threshold': '120',
                'training_job_name_prefix': base_job_name_prefix,
                'stop_training_on_fire' : 'True'
        }
        collections_to_save=[ 
            CollectionConfig(
                name="losses", 
                parameters={
                      "train.save_interval": "50"
                      "eval.save_interval": "10"
                } 
            )
        ]
    )
]

# construct a SageMaker estimator with the modified Debugger built-in rule
sagemaker_estimator=TensorFlow(
    entry_point='directory/to/your_training_script.py',
    role=sm.get_execution_role(),
    base_job_name=base_job_name_prefix,
    instance_count=1,
    instance_type="ml.p3.2xlarge",
    framework_version="2.9.0",
    py_version="py39",

    # debugger-specific arguments below
    rules=built_in_rules_modified
)
sagemaker_estimator.fit()

Pour une configuration avancée des règles intégrées de Debugger à l'aide de l'API CreateTrainingJob, consultez Configurer Debugger à l'aide de l'API Amazon SageMaker.