Superviser les performances des modèles déployés en production

Avant de suivre les étapes décrites dans cet article, vérifiez que vous disposez des composants requis suivants :

• L’interface CLI Azure et l’extension ml pour l’interface CLI Azure. Pour plus d’informations, consultez Installer, configurer et utiliser l’interface CLI (v2).

  Important

  Les exemples CLI de cet article supposent que vous utilisez l’interpréteur de commandes Bash (ou compatible). Par exemple, à partir d’un système Linux ou d’un sous-système Windows pour Linux.

• Un espace de travail Azure Machine Learning. Si vous n’en avez pas, suivez les étapes décrites dans la section Installation, configuration et utilisation de l’interface CLI (v2) pour en créer une.

Avant de suivre les étapes décrites dans cet article, vérifiez que vous disposez des composants requis suivants :

• Un espace de travail Azure Machine Learning. Si vous n’en avez pas, procédez comme suit dans le Guide de démarrage rapide : Créer des ressources d’espace de travail pour en créer un.

• Pour installer le kit SDK Python v2, utilisez la commande suivante :

  pip install azure-ai-ml azure-identity
  

  Pour mettre à jour une installation existante du Kit de développement logiciel (SDK) vers la version la plus récente, utilisez la commande suivante :

  pip install --upgrade azure-ai-ml azure-identity
  

  Pour plus d’informations, consultez Installer le kit SDK Python v2 pour Azure Machine Learning.

Avant de suivre les étapes décrites dans cet article, vérifiez que vous disposez des composants requis suivants :

• Un abonnement Azure. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer. Essayez la version gratuite ou payante d’Azure Machine Learning.

• Un espace de travail Azure Machine Learning et une instance de calcul. Si vous n’avez pas ces ressources, suivez les étapes dans l’article Démarrage rapide : Créer des ressources d’espace de travail pour les créer.

La surveillance des modèles Azure Machine Learning utilise az ml schedule pour planifier un travail de surveillance. Vous pouvez créer le moniteur de surveillance de modèle prêt à l’emploi avec la commande CLI et la définition YAML suivantes :

az ml schedule create -f ./out-of-box-monitoring.yaml

Le code YAML suivant contient la définition de la surveillance des modèles prête à l’emploi.

# out-of-box-monitoring.yaml
$schema:  http://azureml/sdk-2-0/Schedule.json
name: credit_default_model_monitoring
display_name: Credit default model monitoring
description: Credit default model monitoring setup with minimal configurations

trigger:
  # perform model monitoring activity daily at 3:15am
  type: recurrence
  frequency: day #can be minute, hour, day, week, month
  interval: 1 # #every day
  schedule: 
    hours: 3 # at 3am
    minutes: 15 # at 15 mins after 3am

create_monitor:

  compute: # specify a spark compute for monitoring job
    instance_type: standard_e4s_v3
    runtime_version: "3.3"

  monitoring_target: 
    ml_task: classification # model task type: [classification, regression, question_answering]
    endpoint_deployment_id: azureml:credit-default:main # azureml endpoint deployment id

  alert_notification: # emails to get alerts
    emails:
      - abc@example.com
      - def@example.com

Vous pouvez utiliser le code suivant pour configurer la surveillance des modèles prête à l’emploi :

from azure.identity import DefaultAzureCredential
from azure.ai.ml import MLClient
from azure.ai.ml.entities import (
    AlertNotification,
    MonitoringTarget,
    MonitorDefinition,
    MonitorSchedule,
    RecurrencePattern,
    RecurrenceTrigger,
    ServerlessSparkCompute
)

# get a handle to the workspace
ml_client = MLClient(
    DefaultAzureCredential(),
    subscription_id="subscription_id",
    resource_group_name="resource_group_name",
    workspace_name="workspace_name",
)

# create the compute
spark_compute = ServerlessSparkCompute(
    instance_type="standard_e4s_v3",
    runtime_version="3.3"
)

# specify your online endpoint deployment
monitoring_target = MonitoringTarget(
    ml_task="classification",
    endpoint_deployment_id="azureml:credit-default:main"
)


# create alert notification object
alert_notification = AlertNotification(
    emails=['abc@example.com', 'def@example.com']
)

# create the monitor definition
monitor_definition = MonitorDefinition(
    compute=spark_compute,
    monitoring_target=monitoring_target,
    alert_notification=alert_notification
)

# specify the schedule frequency
recurrence_trigger = RecurrenceTrigger(
    frequency="day",
    interval=1,
    schedule=RecurrencePattern(hours=3, minutes=15)
)

# create the monitor
model_monitor = MonitorSchedule(
    name="credit_default_monitor_basic",
    trigger=recurrence_trigger,
    create_monitor=monitor_definition
)

poller = ml_client.schedules.begin_create_or_update(model_monitor)
created_monitor = poller.result()

1. Accédez à Azure Machine Learning Studio.

2. Accédez à votre espace de travail.

3. Sélectionnez Surveillance dans la section Gérer

4. Sélectionnez Ajouter.

   

5. Dans la page Paramètres de base, utilisez (facultatif) Sélectionner un modèle pour choisir le modèle à surveiller.

6. La liste déroulante (Facultatif) Sélectionner un déploiement avec la collecte de données activée doit être renseignée automatiquement si le modèle est déployé sur un point de terminaison en ligne Azure Machine Learning. Sélectionnez le déploiement dans la liste déroulante.

7. Sélectionnez les données d’entraînement à utiliser comme référence de comparaison dans la zone (Facultatif) Sélectionner des données d’entraînement.

8. Entrez un nom pour la surveillance dans Nom du moniteur ou gardez le nom par défaut.

9. Notez que la taille de la machine virtuelle est déjà sélectionnée pour vous.

10. Sélectionnez votre fuseau horaire.

11. Sélectionnez la planification Récurrence ou Expression CRON.

12. Pour la planification Récurrence, spécifiez la fréquence de répétition, le jour et l’heure. Pour la planification Expression CRON, entrez une expression CRON pour l’exécution de la surveillance.

    

13. Sélectionnez Suivant pour passer à la section Paramètres avancés.

14. Sélectionnez Suivant dans la page Configurer la ressource de données pour conserver les jeux de données par défaut.

15. Sélectionnez Suivant pour accéder à la page Sélectionner des signaux de surveillance.

16. Sélectionnez Suivant pour accéder à la page Notifications. Ajoutez votre e-mail pour recevoir des notifications par e-mail.

17. Passez en revue les détails de votre surveillance et sélectionnez Créer pour créer le moniteur.

Créez la configuration avancée de la surveillance des modèles avec la commande CLI et la définition YAML suivantes :

az ml schedule create -f ./advanced-model-monitoring.yaml

Le YAML suivant contient la définition pour la supervision avancée des modèles.

# advanced-model-monitoring.yaml
$schema:  http://azureml/sdk-2-0/Schedule.json
name: fraud_detection_model_monitoring
display_name: Fraud detection model monitoring
description: Fraud detection model monitoring with advanced configurations

trigger:
  # perform model monitoring activity daily at 3:15am
  type: recurrence
  frequency: day #can be minute, hour, day, week, month
  interval: 1 # #every day
  schedule: 
    hours: 3 # at 3am
    minutes: 15 # at 15 mins after 3am

create_monitor:

  compute: 
    instance_type: standard_e4s_v3
    runtime_version: "3.3"

  monitoring_target:
    ml_task: classification
    endpoint_deployment_id: azureml:credit-default:main
  
  monitoring_signals:
    advanced_data_drift: # monitoring signal name, any user defined name works
      type: data_drift
      # reference_dataset is optional. By default referece_dataset is the production inference data associated with Azure Machine Learning online endpoint
      reference_data:
        input_data:
          path: azureml:credit-reference:1 # use training data as comparison reference dataset
          type: mltable
        data_context: training
        data_column_names:
          target_column: DEFAULT_NEXT_MONTH
      features: 
        top_n_feature_importance: 10 # monitor drift for top 10 features
      metric_thresholds:
        numerical:
          jensen_shannon_distance: 0.01
        categorical:
          pearsons_chi_squared_test: 0.02
    advanced_data_quality:
      type: data_quality
      # reference_dataset is optional. By default reference_dataset is the production inference data associated with Azure Machine Learning online endpoint
      reference_data:
        input_data:
          path: azureml:credit-reference:1
          type: mltable
        data_context: training
      features: # monitor data quality for 3 individual features only
        - SEX
        - EDUCATION
      metric_thresholds:
        numerical:
          null_value_rate: 0.05
        categorical:
          out_of_bounds_rate: 0.03

    feature_attribution_drift_signal:
      type: feature_attribution_drift
      # production_data: is not required input here
      # Please ensure Azure Machine Learning online endpoint is enabled to collected both model_inputs and model_outputs data
      # Azure Machine Learning model monitoring will automatically join both model_inputs and model_outputs data and used it for computation
      reference_data:
        input_data:
          path: azureml:credit-reference:1
          type: mltable
        data_context: training
        data_column_names:
          target_column: DEFAULT_NEXT_MONTH
      metric_thresholds:
        normalized_discounted_cumulative_gain: 0.9
  
  alert_notification:
    emails:
      - abc@example.com
      - def@example.com

Utilisez le code suivant pour la configuration avancée de la surveillance des modèles :

from azure.identity import DefaultAzureCredential
from azure.ai.ml import Input, MLClient
from azure.ai.ml.constants import (
    MonitorDatasetContext,
)
from azure.ai.ml.entities import (
    AlertNotification,
    BaselineDataRange,
    DataDriftSignal,
    DataQualitySignal,
    PredictionDriftSignal,
    DataDriftMetricThreshold,
    DataQualityMetricThreshold,
    FeatureAttributionDriftMetricThreshold,
    FeatureAttributionDriftSignal,
    PredictionDriftMetricThreshold,
    NumericalDriftMetrics,
    CategoricalDriftMetrics,
    DataQualityMetricsNumerical,
    DataQualityMetricsCategorical,
    MonitorFeatureFilter,
    MonitoringTarget,
    MonitorDefinition,
    MonitorSchedule,
    RecurrencePattern,
    RecurrenceTrigger,
    ServerlessSparkCompute,
    ReferenceData,
    ProductionData
)

# get a handle to the workspace
ml_client = MLClient(
    DefaultAzureCredential(),
    subscription_id="subscription_id",
    resource_group_name="resource_group_name",
    workspace_name="workspace_name",
)

# create your compute
spark_compute = ServerlessSparkCompute(
    instance_type="standard_e4s_v3",
    runtime_version="3.3"
)

# specify the online deployment (if you have one)
monitoring_target = MonitoringTarget(
    ml_task="classification",
    endpoint_deployment_id="azureml:credit-default:main"
)

# specify a lookback window size and offset, or omit this to use the defaults, which are specified in the documentation
data_window = BaselineDataRange(lookback_window_size="P1D", lookback_window_offset="P0D")

production_data = ProductionData(
    input_data=Input(
        type="uri_folder",
        path="azureml:credit-default-main-model_inputs:1"
    ),
    data_window=data_window,
    data_context=MonitorDatasetContext.MODEL_INPUTS,
)

# training data to be used as reference dataset
reference_data_training = ReferenceData(
    input_data=Input(
        type="mltable",
        path="azureml:credit-default-reference:1"
    ),
    data_column_names={
        "target_column":"DEFAULT_NEXT_MONTH"
    },
    data_context=MonitorDatasetContext.TRAINING,
)

# create an advanced data drift signal
features = MonitorFeatureFilter(top_n_feature_importance=10)

metric_thresholds = DataDriftMetricThreshold(
    numerical=NumericalDriftMetrics(
        jensen_shannon_distance=0.01
    ),
    categorical=CategoricalDriftMetrics(
        pearsons_chi_squared_test=0.02
    )
)

advanced_data_drift = DataDriftSignal(
    reference_data=reference_data_training,
    features=features,
    metric_thresholds=metric_thresholds
)

# create an advanced prediction drift signal
metric_thresholds = PredictionDriftMetricThreshold(
    categorical=CategoricalDriftMetrics(
        jensen_shannon_distance=0.01
    )
)

advanced_prediction_drift = PredictionDriftSignal(
    reference_data=reference_data_training,
    metric_thresholds=metric_thresholds
)

# create an advanced data quality signal
features = ['SEX', 'EDUCATION', 'AGE']

metric_thresholds = DataQualityMetricThreshold(
    numerical=DataQualityMetricsNumerical(
        null_value_rate=0.01
    ),
    categorical=DataQualityMetricsCategorical(
        out_of_bounds_rate=0.02
    )
)

advanced_data_quality = DataQualitySignal(
    reference_data=reference_data_training,
    features=features,
    metric_thresholds=metric_thresholds,
    alert_enabled=False
)

# create feature attribution drift signal
metric_thresholds = FeatureAttributionDriftMetricThreshold(normalized_discounted_cumulative_gain=0.9)

feature_attribution_drift = FeatureAttributionDriftSignal(
    reference_data=reference_data_training,
    metric_thresholds=metric_thresholds,
    alert_enabled=False
)

# put all monitoring signals in a dictionary
monitoring_signals = {
    'data_drift_advanced':advanced_data_drift,
    'data_quality_advanced':advanced_data_quality,
    'feature_attribution_drift':feature_attribution_drift,
}

# create alert notification object
alert_notification = AlertNotification(
    emails=['abc@example.com', 'def@example.com']
)

# create the monitor definition
monitor_definition = MonitorDefinition(
    compute=spark_compute,
    monitoring_target=monitoring_target,
    monitoring_signals=monitoring_signals,
    alert_notification=alert_notification
)

# specify the frequency on which to run your monitor
recurrence_trigger = RecurrenceTrigger(
    frequency="day",
    interval=1,
    schedule=RecurrencePattern(hours=3, minutes=15)
)

# create your monitor
model_monitor = MonitorSchedule(
    name="credit_default_monitor_advanced",
    trigger=recurrence_trigger,
    create_monitor=monitor_definition
)

poller = ml_client.schedules.begin_create_or_update(model_monitor)
created_monitor = poller.result()

Pour configurer une surveillance avancée :

1. Renseignez l’ensemble de la page Paramètres de base, comme décrit plus haut dans la section Configurer la surveillance des modèles prête à l’emploi.

2. Sélectionnez Suivant pour ouvrir la page Configurer la ressource de données de la section Paramètres avancés.

3. Ajoutez un jeu de données à utiliser comme jeu de données de référence. Nous vous recommandons d’utiliser les données d’entraînement de modèle comme jeu de données de référence de comparaison pour la dérive et la qualité des données. Utilisez également les données de validation de modèle comme jeu de données de référence de comparaison pour la dérive de prédiction.

   

4. Sélectionnez Suivant pour accéder à la page Sélectionner des signaux de surveillance. Dans cette page, vous voyez des signaux de surveillance déjà ajoutés (si vous avez sélectionné un déploiement en ligne Azure Machine Learning précédemment). Les signaux (dérive de données, dérive de prédiction et qualité de données) utilisent des données de production récentes comme jeu de données de référence de comparaison, ainsi que des valeurs par défaut intelligentes pour les métriques et les seuils.

   

5. Sélectionnez Edit (Modifier) en regard du signal de dérive des données.

6. Configurez la dérive de données dans la fenêtre Modifier le signal comme suit :

   1. À l’étape 1, pour la ressource de données de production, sélectionnez votre jeu de données d’entrée de modèle. Effectuez ensuite les sélections suivantes :
      • Sélectionnez la taille souhaitée pour la fenêtre de recherche.
   2. À l’étape 2, pour la ressource de données de référence, sélectionnez votre jeu de données de formation. Effectuez ensuite les sélections suivantes :
      • Sélectionnez la colonne (sortie) cible.
   3. À l’étape 3, faites votre sélection pour analyser la dérive des N premières caractéristiques les plus importantes, ou pour surveiller la dérive d’un ensemble spécifique de caractéristiques.
   4. À l’étape 4, sélectionnez les métriques et seuils que vous souhaitez utiliser pour les caractéristiques numériques.
   5. À l’étape 5, sélectionnez les métriques et seuils que vous souhaitez utiliser pour les caractéristiques catégorielles.

   

7. Sélectionnez Enregistrer pour revenir à la page Sélectionner des signaux de surveillance.

8. Sélectionnez Ajouter pour ouvrir la fenêtre Modifier le signal.

9. Sélectionnez Dérive d’attribution de caractéristiques (préversion) pour configurer le signal de dérive d’attribution de caractéristiques comme suit :

   1. À l’étape 1, sélectionnez la ressource de données de production qui contient vos entrées de modèles.
      • Sélectionnez également la taille souhaitée pour la fenêtre de recherche.
   2. À l’étape 2, sélectionnez la ressource de données de production qui contient vos sorties de modèle.
      • Sélectionnez également la colonne commune entre ces ressources de données pour les joindre. Si les données ont été collectées avec le collecteur de données, la colonne commune est correlationid.
   3. (Facultatif) Si vous avez utilisé le collecteur de données pour collecter les données dans lesquelles vos entrées et sorties de modèle sont déjà jointes, sélectionnez le jeu de données joint comme ressource de données de production (à l’étape 1).
      • En outre, supprimez l’étape 2 dans le panneau de configuration.
   4. À l’étape 3, sélectionnez le jeu de données de formation à utiliser comme jeu de données de référence.
      • Sélectionnez également la colonne (sortie) cible de votre jeu de données de formation.
   5. À l’étape 4, sélectionnez la métrique et le seuil de votre choix.

   

10. Sélectionnez Enregistrer pour revenir à la page Sélectionner des signaux de surveillance.

    

11. Lorsque vous avez terminé la configuration de vos signaux de surveillance, sélectionnez Suivant pour accéder à la page Notifications.

12. Dans la page Notifications, activez les notifications d’alerte pour chaque signal et sélectionnez Suivant.

13. Passez en revue vos paramètres dans la page Vérifier les paramètres de surveillance.

    

14. Sélectionnez Créer pour créer votre moniteur de modèle avancé.

Une fois que vous avez satisfait aux exigences de monitoring des performances des modèles, vous pouvez configurer la supervision des modèles avec la commande CLI et la définition YAML suivantes :

az ml schedule create -f ./model-performance-monitoring.yaml

Le code YAML suivant contient la définition de la supervision des modèles avec les données d’inférence de production que vous avez collectées.

$schema:  http://azureml/sdk-2-0/Schedule.json
name: model_performance_monitoring
display_name: Credit card fraud model performance
description: Credit card fraud model performance

trigger:
  type: recurrence
  frequency: day
  interval: 7 
  schedule: 
    hours: 10
    minutes: 15
  
create_monitor:
  compute: 
    instance_type: standard_e8s_v3
    runtime_version: "3.3"
  monitoring_target:
    ml_task: classification
    endpoint_deployment_id: azureml:loan-approval-endpoint:loan-approval-deployment

  monitoring_signals:
    fraud_detection_model_performance: 
      type: model_performance 
      production_data:
        data_column_names:
          prediction: is_fraud
          correlation_id: correlation_id
      reference_data:
        input_data:
          path: azureml:my_model_ground_truth_data:1
          type: mltable
        data_column_names:
          actual: is_fraud
          correlation_id: correlation_id
        data_context: actuals
      alert_enabled: true
      metric_thresholds: 
        tabular_classification:
          accuracy: 0.95
          precision: 0.8
  alert_notification: 
      emails: 
        - abc@example.com

Une fois que vous remplissez les exigences de monitoring des performances des modèles, vous pouvez configurer le monitoring des modèles avec le code Python suivant :

from azure.identity import DefaultAzureCredential
from azure.ai.ml import Input, MLClient
from azure.ai.ml.constants import (
    MonitorDatasetContext,
)
from azure.ai.ml.entities import (
    AlertNotification,
    BaselineDataRange,
    ModelPerformanceMetricThreshold,
    ModelPerformanceSignal,
    ModelPerformanceClassificationThresholds,
    MonitoringTarget,
    MonitorDefinition,
    MonitorSchedule,
    RecurrencePattern,
    RecurrenceTrigger,
    ServerlessSparkCompute,
    ReferenceData,
    ProductionData
)

# get a handle to the workspace
ml_client = MLClient(
    DefaultAzureCredential(),
    subscription_id="subscription_id",
    resource_group_name="resource_group_name",
    workspace_name="workspace_name",
)

# create your compute
spark_compute = ServerlessSparkCompute(
    instance_type="standard_e4s_v3",
    runtime_version="3.3"
)

# reference your azureml endpoint and deployment
monitoring_target = MonitoringTarget(
    ml_task="classification",
)

# MDC-generated production data with data column names 
production_data = ProductionData(
    input_data=Input(
        type="uri_folder",
        path="azureml:credit-default-main-model_outputs:1"
    ),
    data_column_names={
        "target_column": "DEFAULT_NEXT_MONTH",
        "join_column": "correlationid"
    },
    data_window=BaselineDataRange(
        lookback_window_offset="P0D",
        lookback_window_size="P10D",
    )
)

# ground truth reference data 
reference_data_ground_truth = ReferenceData(
    input_data=Input(
        type="mltable",
        path="azureml:credit-ground-truth:1"
    ),
    data_column_names={
        "target_column": "ground_truth",
        "join_column": "correlationid"
    },
    data_context=MonitorDatasetContext.GROUND_TRUTH_DATA,
)

# create the model performance signal
metric_thresholds = ModelPerformanceMetricThreshold(
    classification=ModelPerformanceClassificationThresholds(
        accuracy=0.50,
        precision=0.50,
        recall=0.50
    ),
)

model_performance = ModelPerformanceSignal(
    production_data=production_data,
    reference_data=reference_data_ground_truth,
    metric_thresholds=metric_thresholds
)

# put all monitoring signals in a dictionary
monitoring_signals = {
    'model_performance':model_performance,
}

# create alert notification object
alert_notification = AlertNotification(
    emails=['abc@example.com', 'def@example.com']
)

# Finally monitor definition
monitor_definition = MonitorDefinition(
    compute=spark_compute,
    monitoring_target=monitoring_target,
    monitoring_signals=monitoring_signals,
    alert_notification=alert_notification
)

recurrence_trigger = RecurrenceTrigger(
    frequency="day",
    interval=1,
    schedule=RecurrencePattern(hours=3, minutes=15)
)

model_monitor = MonitorSchedule(
    name="credit_default_model_performance",
    trigger=recurrence_trigger,
    create_monitor=monitor_definition
)

poller = ml_client.schedules.begin_create_or_update(model_monitor)
created_monitor = poller.result()

Pour configurer le monitoring des performances, procédez comme suit :

1. Renseignez l’ensemble de la page Paramètres de base, comme décrit précédemment dans la section Configurer le monitoring prêt à l’emploi des modèles.

2. Sélectionnez Suivant pour ouvrir la page Configurer la ressource de données de la section Paramètres avancés.

3. Sélectionnez + Ajouter pour ajouter un jeu de données à utiliser comme jeu de données réelles.

   Vérifiez que votre modèle génère un jeu de données également inclus dans la liste des jeux de données ajoutés. Le jeu de données réelles que vous ajoutez doit présenter une colonne d’ID unique. Les valeurs de la colonne ID unique pour le jeu de données réelles et le jeu de données des sorties de modèles doivent correspondre pour que les deux jeux de données soient joints ensemble avant le calcul de la métrique.

   

   

4. Sélectionnez Suivant pour accéder à la page Sélectionner des signaux de surveillance. Dans cette page, vous verrez des signaux de monitoring déjà ajoutés (si vous avez sélectionné un déploiement en ligne Azure Machine Learning précédemment).

5. Vous pouvez supprimer les signaux de monitoring existants sur la page, car vous ne vous concentrez que sur la création d’un signal de monitoring des performances des modèles.

6. Sélectionnez Ajouter pour ouvrir la fenêtre Modifier le signal.

7. Sélectionnez Performances des modèles (préversion) pour configurer le signal de performances des modèles comme suit :

   1. À l’étape 1, pour la ressource de données de production, sélectionnez votre jeu de données de sorties de modèle. Effectuez également les sélections suivantes :
      • Sélectionnez la colonne cible appropriée (par exemple, is_fraud).
      • Sélectionnez la taille et le décalage souhaités pour la fenêtre de recherche.
   2. À l’étape 2, pour la ressource de données de référence, sélectionnez la ressource de données réelles que vous avez ajoutée précédemment. Effectuez également les sélections suivantes :
      • Sélectionnez la colonne cible appropriée.
      • Sélectionnez la colonne sur laquelle effectuer la jointure avec le jeu de données de sorties du modèle. La colonne utilisée pour la jointure doit être la colonne commune entre les deux jeux de données qui comporte un ID unique pour chaque ligne du jeu de données (par exemple, correlationid).
   3. À l’étape 3, sélectionnez les métriques de performances de votre choix et spécifiez leurs seuils respectifs.

   

8. Sélectionnez Enregistrer pour revenir à la page Sélectionner des signaux de surveillance.

   

9. Sélectionnez Suivant pour accéder à la page Notifications.

10. Dans la page Notifications, activez les notifications d’alerte pour le signal de performances des modèles, puis sélectionnez Suivant.

11. Passez en revue vos paramètres dans la page Vérifier les paramètres de surveillance.

    

12. Sélectionnez Créer pour créer votre moniteur de performances des modèles.

Une fois que vous avez satisfait aux exigences précédentes, vous pouvez configurer la supervision des modèles avec la commande CLI et la définition YAML suivantes :

az ml schedule create -f ./model-monitoring-with-collected-data.yaml

Le code YAML suivant contient la définition de la supervision des modèles avec les données d’inférence de production que vous avez collectées.

# model-monitoring-with-collected-data.yaml
$schema:  http://azureml/sdk-2-0/Schedule.json
name: fraud_detection_model_monitoring
display_name: Fraud detection model monitoring
description: Fraud detection model monitoring with your own production data

trigger:
  # perform model monitoring activity daily at 3:15am
  type: recurrence
  frequency: day #can be minute, hour, day, week, month
  interval: 1 # #every day
  schedule: 
    hours: 3 # at 3am
    minutes: 15 # at 15 mins after 3am

create_monitor:
  compute: 
    instance_type: standard_e4s_v3
    runtime_version: "3.3"
  monitoring_target:
    ml_task: classification
    endpoint_deployment_id: azureml:fraud-detection-endpoint:fraud-detection-deployment
  
  monitoring_signals:

    advanced_data_drift: # monitoring signal name, any user defined name works
      type: data_drift
      # define production dataset with your collected data
      production_data:
        input_data:
          path: azureml:my_production_inference_data_model_inputs:1  # your collected data is registered as Azure Machine Learning asset
          type: uri_folder
        data_context: model_inputs
        pre_processing_component: azureml:production_data_preprocessing:1
      reference_data:
        input_data:
          path: azureml:my_model_training_data:1 # use training data as comparison baseline
          type: mltable
        data_context: training
        data_column_names:
          target_column: is_fraud
      features: 
        top_n_feature_importance: 20 # monitor drift for top 20 features
      metric_thresholds:
        numberical:
          jensen_shannon_distance: 0.01
        categorical:
          pearsons_chi_squared_test: 0.02

    advanced_prediction_drift: # monitoring signal name, any user defined name works
      type: prediction_drift
      # define production dataset with your collected data
      production_data:
        input_data:
          path: azureml:my_production_inference_data_model_outputs:1  # your collected data is registered as Azure Machine Learning asset
          type: uri_folder
        data_context: model_outputs
        pre_processing_component: azureml:production_data_preprocessing:1
      reference_data:
        input_data:
          path: azureml:my_model_validation_data:1 # use training data as comparison reference dataset
          type: mltable
        data_context: validation
      metric_thresholds:
        categorical:
          pearsons_chi_squared_test: 0.02
  
  alert_notification:
    emails:
      - abc@example.com
      - def@example.com

Une fois que vous avez répondu aux exigences précédentes, vous pouvez configurer la surveillance des modèles avec le code Python suivant :

from azure.identity import InteractiveBrowserCredential
from azure.ai.ml import Input, MLClient
from azure.ai.ml.constants import (
    MonitorFeatureType,
    MonitorMetricName,
    MonitorDatasetContext
)
from azure.ai.ml.entities import (
    AlertNotification,
    DataDriftSignal,
    DataQualitySignal,
    DataDriftMetricThreshold,
    DataQualityMetricThreshold,
    NumericalDriftMetrics,
    CategoricalDriftMetrics,
    DataQualityMetricsNumerical,
    DataQualityMetricsCategorical,
    MonitorFeatureFilter,
    MonitorInputData,
    MonitoringTarget,
    MonitorDefinition,
    MonitorSchedule,
    RecurrencePattern,
    RecurrenceTrigger,
    ServerlessSparkCompute,
    ReferenceData,
    ProductionData
)

# get a handle to the workspace
ml_client = MLClient(
   InteractiveBrowserCredential(),
   subscription_id,
   resource_group,
   workspace
)

spark_compute = ServerlessSparkCompute(
    instance_type="standard_e4s_v3",
    runtime_version="3.2"
)

#define target dataset (production dataset)
production_data = ProductionData(
    input_data=Input(
        type="uri_folder",
        path="azureml:my_model_production_data:1"
    ),
    data_context=MonitorDatasetContext.MODEL_INPUTS,
    pre_processing_component="azureml:production_data_preprocessing:1"
)


# training data to be used as reference dataset
reference_data_training = ReferenceData(
    input_data=Input(
        type="mltable",
        path="azureml:my_model_training_data:1"
    ),
    data_context=MonitorDatasetContext.TRAINING
)

# create an advanced data drift signal
features = MonitorFeatureFilter(top_n_feature_importance=20)
metric_thresholds = DataDriftMetricThreshold(
    numerical=NumericalDriftMetrics(
        jensen_shannon_distance=0.01
    ),
    categorical=CategoricalDriftMetrics(
        pearsons_chi_squared_test=0.02
    )
)

advanced_data_drift = DataDriftSignal(
    production_data=production_data,
    reference_data=reference_data_training,
    features=features,
    metric_thresholds=metric_thresholds
)


# create an advanced data quality signal
features = ['feature_A', 'feature_B', 'feature_C']
metric_thresholds = DataQualityMetricThreshold(
    numerical=DataQualityMetricsNumerical(
        null_value_rate=0.01
    ),
    categorical=DataQualityMetricsCategorical(
        out_of_bounds_rate=0.02
    )
)

advanced_data_quality = DataQualitySignal(
    production_data=production_data,
    reference_data=reference_data_training,
    features=features,
    metric_thresholds=metric_thresholds,
    alert_enabled="False"
)

# put all monitoring signals in a dictionary
monitoring_signals = {
    'data_drift_advanced': advanced_data_drift,
    'data_quality_advanced': advanced_data_quality
}

# create alert notification object
alert_notification = AlertNotification(
    emails=['abc@example.com', 'def@example.com']
)

# Finally monitor definition
monitor_definition = MonitorDefinition(
    compute=spark_compute,
    monitoring_signals=monitoring_signals,
    alert_notification=alert_notification
)

recurrence_trigger = RecurrenceTrigger(
    frequency="day",
    interval=1,
    schedule=RecurrencePattern(hours=3, minutes=15)
)

model_monitor = MonitorSchedule(
    name="fraud_detection_model_monitoring_advanced",
    trigger=recurrence_trigger,
    create_monitor=monitor_definition
)

poller = ml_client.schedules.begin_create_or_update(model_monitor)
created_monitor = poller.result()

Actuellement, le studio ne prend pas en charge la configuration de la surveillance des modèles déployés en dehors d’Azure Machine Learning. Consultez plutôt les onglets Azure CLI ou SDK Python.

Une fois que vous avez configuré votre moniteur avec l’interface CLI ou le SDK, vous pouvez afficher les résultats de surveillance dans le studio. Pour plus d’informations sur l’interprétation des résultats de surveillance, consultez Interprétation des résultats de surveillance.

Une fois que vous avez répondu aux conditions d’utilisation des signaux et métriques personnalisés, vous pouvez configurer la surveillance des modèles avec la commande CLI et la définition YAML suivantes :

az ml schedule create -f ./custom-monitoring.yaml

Le YAML suivant contient la définition de la surveillance du modèle avec un signal personnalisé. Voici quelques points à noter concernant le code :

• Nous partons du principe que vous avez déjà créé et inscrit votre composant avec la définition des signaux personnalisés dans Azure Machine Learning.
• Le component_id du composant de signal personnalisé inscrit est azureml:my_custom_signal:1.0.0.
• Si vous avez collecté vos données avec le collecteur de données, vous pouvez omettre la propriété pre_processing_component. Si vous souhaitez utiliser un composant de prétraitement pour prétraiter les données de production non collectées par le collecteur de données, vous pouvez le spécifier.

# custom-monitoring.yaml
$schema:  http://azureml/sdk-2-0/Schedule.json
name: my-custom-signal
trigger:
  type: recurrence
  frequency: day # can be minute, hour, day, week, month
  interval: 7 # #every day
create_monitor:
  compute:
    instance_type: "standard_e4s_v3"
    runtime_version: "3.3"
  monitoring_signals:
    customSignal:
      type: custom
      component_id: azureml:my_custom_signal:1.0.0
      input_data:
        production_data:
          input_data:
            type: uri_folder
            path: azureml:my_production_data:1
          data_context: test
          data_window:
            lookback_window_size: P30D
            lookback_window_offset: P7D
          pre_processing_component: azureml:custom_preprocessor:1.0.0
      metric_thresholds:
        - metric_name: std_deviation
          threshold: 2
  alert_notification:
    emails:
      - abc@example.com

Le SDK Python ne prend actuellement pas en charge la surveillance des signaux personnalisés. Consultez plutôt l'onglet Azure CLI.

Le studio ne prend actuellement pas en charge la surveillance des signaux personnalisés. Consultez plutôt l'onglet Azure CLI.