Monitorare le prestazioni dei modelli distribuiti nell'ambiente di produzione

• L'interfaccia della riga di comando di Azure e l'estensione per l'interfaccia ml della riga di comando di Azure, installata e configurata. Per altre informazioni, vedere Installare e configurare l'interfaccia della riga di comando (v2).

• Una shell Bash o una shell compatibile, ad esempio una shell in un sistema Linux o un sottosistema Windows per Linux. Gli esempi dell'interfaccia della riga di comando di Azure in questo articolo presuppongono l'uso di questo tipo di shell.

• Un'area di lavoro di Azure Machine Learning. Per istruzioni su come creare un'area di lavoro, vedere Configurare.

• Un'area di lavoro di Azure Machine Learning. Per i passaggi per la creazione di un'area di lavoro, vedere Creare l'area di lavoro.

• Azure Machine Learning SDK per Python v2. Per installare l'SDK, usare il comando seguente:

  pip install azure-ai-ml azure-identity
  

  Per aggiornare un'installazione esistente di SDK alla versione più recente, usare il comando seguente:

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

  Per altre informazioni, vedere Libreria client del pacchetto di Azure Machine Learning per Python.

• Una sottoscrizione di Azure. Se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

• Un'area di lavoro di Azure Machine Learning. Per i passaggi per la creazione di un'area di lavoro, vedere Creare l'area di lavoro.

• Istanza di calcolo di Azure Machine Learning. Per i passaggi per la creazione di un'istanza di calcolo, vedere Creare un'istanza di calcolo.

Quando si usa l'interfaccia della riga di comando di Azure per creare un monitoraggio, si usa un file di configurazione YAML. In quel file, impostare il valore create_monitor.compute.instance_type sul tipo che si desidera utilizzare.

Quando si usa Python SDK per creare un monitoraggio, si usa azure.ai.ml.entities.ServerlessSparkCompute per creare un'istanza di calcolo. Quando si chiama tale metodo, impostare il instance_type parametro sul tipo da usare.

Quando si usa Azure Machine Learning Studio per aggiungere un monitoraggio, viene visualizzata la pagina Impostazioni di base. In Dimensioni macchina virtuale selezionare il tipo da usare.

Nell'interfaccia della riga di comando di Azure si usa az ml schedule per pianificare un processo di monitoraggio.

1. Creare una definizione di monitoraggio in un file YAML. Per una definizione predefinita di esempio, vedere il codice YAML seguente, disponibile anche nel repository azureml-examples.

   Prima di usare questa definizione, modificare i valori in base all'ambiente. Per endpoint_deployment_idusare un valore nel formato azureml:<endpoint-name>:<deployment-name>.

   # 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:
         - [email protected]
         - [email protected]
   

2. Eseguire il comando seguente per creare il modello:

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

Usare il codice simile all'esempio seguente. Sostituire i segnaposto seguenti con i valori appropriati:

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 instance.
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:<endpoint-name>:<deployment-name>"
)

# Create an alert notification object.
alert_notification = AlertNotification(
    emails=['<email-address-1>', '<email-address-2>']
)

# 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="<frequency-unit>",
    interval=<interval>,
    schedule=RecurrencePattern(hours=<start-hour>, minutes=<start-minutes>)
)

# Create the monitoring schedule.
model_monitor = MonitorSchedule(
    name="credit_default_monitor_basic",
    trigger=recurrence_trigger,
    create_monitor=monitor_definition
)

# Schedule the monitoring job.
poller = ml_client.schedules.begin_create_or_update(model_monitor)
created_monitor = poller.result()

1. In studio di Azure Machine Learning passare all'area di lavoro.

2. In Gestisci selezionare Monitoraggio e quindi Aggiungi.

   

3. Nella pagina Impostazioni di base immettere le informazioni seguenti:

   • In (Facoltativo) Selezionare il modello da monitorare.
   • In (Facoltativo) Selezionare la distribuzione con la raccolta dati abilitata, selezionare la distribuzione da monitorare. Questo elenco deve essere popolato automaticamente se il modello viene distribuito in un endpoint online di Azure Machine Learning.
   • In (Facoltativo) Selezionare i dati di training selezionare i dati di training da usare come riferimento di confronto.
   • In Nome monitoraggio immettere un nome per il monitoraggio o mantenere il nome predefinito.
   • In Dimensioni macchina virtuale usare le dimensioni predefinite.
   • In Fuso orario selezionare il fuso orario.
   • Per la pianificazione, selezionare Ricorrenza o espressione Cron.
   • Per la pianificazione delle ricorrenze, specificare la frequenza di ripetizione, il giorno e l'ora. Per la pianificazione delle espressioni cron, immettere un'espressione cron per un'esecuzione di monitoraggio.

   

4. Seleziona Avanti.

5. Nelle pagine seguenti selezionare Avanti:

   • Configurare l'asset di dati
   • Selezionare i segnali di monitoraggio

6. Nella pagina Notifiche immettere l'indirizzo di posta elettronica che si vuole usare per ricevere le notifiche e quindi selezionare Avanti.

7. Nella pagina della verifica dei dettagli di monitoraggio, esaminare le impostazioni e quindi selezionare Crea.

1. Creare una definizione di monitoraggio in un file YAML. Per una definizione avanzata di esempio, vedere il codice YAML seguente, disponibile anche nel repository azureml-examples.

   Prima di usare questa definizione, modificare le impostazioni seguenti e tutte le altre per soddisfare le esigenze dell'ambiente:

   • Per endpoint_deployment_idusare un valore nel formato azureml:<endpoint-name>:<deployment-name>.
   • Per path nelle sezioni dei dati di input di riferimento, usare un valore nel formato azureml:<reference-data-asset-name>:<version>.
   • Per target_columnusare il nome della colonna di output che contiene valori stimati dal modello, ad esempio DEFAULT_NEXT_MONTH.
   • Per features, elencare le funzionalità come SEX, EDUCATIONe AGE che si vuole usare in un segnale di qualità dei dati avanzato.
   • In emailselencare gli indirizzi di posta elettronica da usare per le notifiche.

   # 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
         alert_enabled: true
         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
         alert_enabled: true
         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
         alert_enabled: true
         metric_thresholds:
           normalized_discounted_cumulative_gain: 0.9
     
     alert_notification:
       emails:
         - [email protected]
         - [email protected]
   

2. Eseguire il comando seguente per creare il modello:

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

Per configurare il monitoraggio avanzato del modello, usare il codice simile all'esempio seguente. Sostituire i segnaposto seguenti con i valori appropriati:

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 a compute instance.
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:<endpoint-name>:<deployment-name>"
)

# Specify a look-back window size and offset to use. Omit this line to use the default values, which are listed in the documentation.
data_window = BaselineDataRange(lookback_window_size="P1D", lookback_window_offset="P0D")

# Set up the production data.
production_data = ProductionData(
    input_data=Input(
        type="uri_folder",
        path="azureml:<production-data-asset-name>:1"
    ),
    data_window=data_window,
    data_context=MonitorDatasetContext.MODEL_INPUTS,
)

# Set up the training data to use as a reference data asset.
reference_data_training = ReferenceData(
    input_data=Input(
        type="mltable",
        path="azureml:<reference-data-asset-name>:1"
    ),
    data_column_names={
        "target_column":"<target-column>"
    },
    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,
    alert_enabled=True
)

# 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,
    alert_enabled=True
)

# Create an advanced data quality signal.
features = ['<feature-1>', '<feature-2>', '<feature-3>']

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=True
)

# Create a 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=True
)

# 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 an alert notification object.
alert_notification = AlertNotification(
    emails=['<email-address-1>', '<email-address-2>']
)

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

# Specify the schedule frequency.
recurrence_trigger = RecurrenceTrigger(
    frequency="<frequency-unit>",
    interval=<interval>,
    schedule=RecurrencePattern(hours=<start-hour>, minutes=<start-minutes>)
)

# Create the monitoring schedule.
model_monitor = MonitorSchedule(
    name="credit_default_monitor_advanced",
    trigger=recurrence_trigger,
    create_monitor=monitor_definition
)

# Schedule the monitoring job.
poller = ml_client.schedules.begin_create_or_update(model_monitor)
created_monitor = poller.result()

Per configurare il monitoraggio avanzato, seguire questa procedura nelle sezioni seguenti.

Configurare le impostazioni di base

1. In studio di Azure Machine Learning passare all'area di lavoro.

2. In Gestisci selezionare Monitoraggio e quindi Aggiungi.

3. Nella pagina Impostazioni di base immettere le informazioni come descritto in precedenza in Configurare il monitoraggio del modello predefinito.

Aggiungere asset di dati

1. Nella pagina Impostazioni di base, dopo aver configurato le impostazioni, selezionare Avanti. Verrà visualizzata la pagina Configura asset di dati della sezione Impostazioni avanzate .

2. Se l'asset di dati che si vuole usare come asset di dati di riferimento non viene visualizzato, selezionare Aggiungi. Immettere quindi le impostazioni per l'asset di dati. È consigliabile usare i dati di training del modello come asset di dati di riferimento di confronto per la deriva dei dati e la qualità dei dati. Usare anche i dati di convalida del modello come asset di dati di riferimento di confronto per la deriva della stima.

   

Modificare le impostazioni di deriva dei dati

1. Nella pagina Configura asset di dati, dopo aver aggiunto asset di dati, selezionare Avanti. Verrà visualizzata la pagina Seleziona segnali di monitoraggio . Se si usa una distribuzione online di Azure Machine Learning, vengono visualizzati alcuni segnali di monitoraggio. I segnali di deriva dei dati, qualità dei dati e deriva delle previsioni usano i dati di produzione recenti come riferimento per il confronto e usano valori predefiniti ottimizzati per metriche e soglie.

   

2. Accanto al segnale di deriva dei dati selezionare Modifica.

3. Nella finestra Modifica segnale seguire questa procedura per configurare il segnale di deriva dei dati:

   1. Nel passaggio 1:
      1. Per l'asset di dati di produzione selezionare l'asset di dati di input del modello.
      2. Selezionare la dimensione della finestra di ritorno da utilizzare.
   2. Nel passaggio 2:
      1. Per l'asset di dati di riferimento, seleziona l'asset di dati di formazione.
      2. Selezionare la colonna di destinazione o di risultato.
   3. Nel passaggio 3 selezionare Top N features to monitor drift for the N most important features (Funzionalità principali N per monitorare la deviazione per le N funzionalità più importanti). In alternativa, selezionare funzionalità specifiche se si vuole monitorare la deriva per un set specifico.
   4. Nel passaggio 4 selezionare la metrica e la soglia da usare per le funzionalità numeriche.
   5. Nel passaggio 5 selezionare la metrica e la soglia da usare per le funzionalità categoriche.
   6. Seleziona Salva.

   

Aggiungere un segnale di deriva dell'attribuzione di caratteristiche

1. Nella pagina Seleziona segnali di monitoraggio selezionare Aggiungi.

2. Nella finestra Modifica segnale, selezionare Deriva dell'attribuzione delle funzionalità (ANTEPRIMA) e quindi seguire questi passaggi per configurare il segnale di deriva dell'attribuzione delle funzionalità:

   1. Nel passaggio 1:
      1. Seleziona l'asset di dati di produzione che contiene i dati di input del modello.
      2. Selezionare la dimensione della finestra di retrospettiva da usare.
   2. Nel passaggio 2:
      1. Selezionare un asset di dati di produzione che contenga i propri dati di output del modello.
      2. Selezionare la colonna comune da usare per unire i dati di produzione e i dati di output. Se si usa l'agente di raccolta dati per raccogliere dati, selezionare correlationid.
   3. (Facoltativo) Se si usa l'agente di raccolta dati per raccogliere i dati di input e output in un formato che li unisce, seguire questa procedura:
      1. Nel passaggio 1, per l'asset di dati di produzione, selezionare l'asset di dati aggiunto.
      2. Nel passaggio 2 selezionare Rimuovi per rimuovere il passaggio 2 dal pannello di configurazione.
   4. Nel passaggio 3:
      1. Per l'asset di dati di riferimento selezionare l'asset di dati di training.
      2. Seleziona la colonna di destinazione o di output per l'insieme di dati di addestramento.
   5. Nel passaggio 4 selezionare la metrica e la soglia da usare.
   6. Seleziona Salva.

   

Completare la configurazione

1. Nella pagina Seleziona segnali di monitoraggio completare la configurazione dei segnali di monitoraggio e quindi selezionare Avanti.

   

2. Nella pagina Notifiche attivare le notifiche per ogni segnale e quindi selezionare Avanti.

3. Nella pagina di revisione dei dettagli del monitoraggio, esaminare le impostazioni.

   

4. Selezionare Crea per creare il monitoraggio avanzato dei modelli.

Dopo aver soddisfatto i prerequisiti per il monitoraggio delle prestazioni del modello, seguire questa procedura per configurare il monitoraggio del modello:

1. Creare una definizione di monitoraggio in un file YAML. La specifica di esempio seguente definisce il monitoraggio del modello con i dati di inferenza di produzione. Prima di usare questa definizione, modificare le impostazioni seguenti e tutte le altre per soddisfare le esigenze dell'ambiente:

   • Per endpoint_deployment_idusare un valore nel formato azureml:<endpoint-name>:<deployment-name>.
   • Per ogni path valore in una sezione dei dati di input, usare un valore nel formato azureml:<data-asset-name>:<version>.
   • Per il prediction valore, usare il nome della colonna di output che contiene valori stimati dal modello.
   • Per il actual valore, usare il nome della colonna di verità di base che contiene i valori effettivi che il modello tenta di stimare.
   • Per i correlation_id valori, usare i nomi delle colonne usate per unire i dati di output e i dati di verità di base.
   • In emailselencare gli indirizzi di posta elettronica da usare per le notifiche.

   # model-performance-monitoring.yaml
   $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:
           input_data:
             path: azureml:credit-default-main-model_outputs:1
             type: mltable
           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: ground_truth
         alert_enabled: true
         metric_thresholds: 
           tabular_classification:
             accuracy: 0.95
             precision: 0.8
     alert_notification: 
         emails: 
           - [email protected]
   

2. Eseguire il comando seguente per creare il modello:

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

Dopo aver soddisfatto i prerequisiti per il monitoraggio delle prestazioni del modello, usare il codice Python seguente per configurare il monitoraggio del modello. Sostituire innanzitutto i segnaposto seguenti con i valori appropriati:

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 a compute instance.
spark_compute = ServerlessSparkCompute(
    instance_type="standard_e4s_v3",
    runtime_version="3.3"
)

# Specify the type of the model task.
monitoring_target = MonitoringTarget(
    ml_task="classification",
)

# Specify production data that the model data collector generates. 
production_data = ProductionData(
    input_data=Input(
        type="uri_folder",
        path="azureml:<production-data-asset-name>:1"
    ),
    data_column_names={
        "target_column": "<production-target-column>",
        "join_column": "<production-join-column>"
    },
    data_window=BaselineDataRange(
        lookback_window_offset="P0D",
        lookback_window_size="P10D",
    )
)

# Specify the ground truth reference data.
reference_data_ground_truth = ReferenceData(
    input_data=Input(
        type="mltable",
        path="azureml:<ground-truth-data-asset-name>:1"
    ),
    data_column_names={
        "target_column": "<ground-truth-target-column>",
        "join_column": "<ground-truth-join-column>"
    },
    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,
    alert_enabled=True
)

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

# Create an alert notification object.
alert_notification = AlertNotification(
    emails=['<email-address-1>', '<email-address-2>']
)

# Set up the monitor definition.
monitor_definition = MonitorDefinition(
    compute=spark_compute,
    monitoring_target=monitoring_target,
    monitoring_signals=monitoring_signals,
    alert_notification=alert_notification
)

# Specify the schedule frequency.
recurrence_trigger = RecurrenceTrigger(
    frequency="<frequency-unit>",
    interval=<interval>,
    schedule=RecurrencePattern(hours=<start-hour>, minutes=<start-minutes>)
)

# Create the monitoring schedule.
model_monitor = MonitorSchedule(
    name="credit_default_model_performance",
    trigger=recurrence_trigger,
    create_monitor=monitor_definition
)

# Schedule the monitoring job.
poller = ml_client.schedules.begin_create_or_update(model_monitor)
created_monitor = poller.result()

Per configurare il monitoraggio delle prestazioni del modello, seguire questa procedura nelle sezioni seguenti.

Configurare le impostazioni di base

1. In studio di Azure Machine Learning passare all'area di lavoro.

2. In Gestisci selezionare Monitoraggio e quindi Aggiungi.

3. Nella pagina Impostazioni di base immettere le informazioni come descritto in precedenza in Configurare il monitoraggio del modello predefinito.

Aggiungere asset di dati

1. Nella pagina Impostazioni di base selezionare Avanti per aprire la pagina Configura asset di dati della sezione Impostazioni avanzate .

2. Selezionare Aggiungi e quindi aggiungere l'asset di dati che si vuole usare come asset di dati di verità principale. L'asset di dati di verità principale deve avere una colonna ID univoca. Inoltre, i valori nella colonna ID univoca dell'asset di dati di verità di base e dell'asset di dati di output del modello devono corrispondere. Questi asset di dati possono quindi essere uniti insieme prima che si verifichi il calcolo delle metriche.

   

3. Se l'asset di dati di output del modello non viene visualizzato nell'elenco di asset di dati aggiunti, selezionare Aggiungi e quindi aggiungerlo.

   

Aggiungere un segnale di monitoraggio delle prestazioni

1. Nella pagina Configura asset di dati selezionare Avanti. Verrà visualizzata la pagina Seleziona segnali di monitoraggio. Se si usa una distribuzione online di Azure Machine Learning, viene visualizzato un elenco dei segnali di monitoraggio.

2. Eliminare tutti i segnali di monitoraggio visualizzati nella pagina. L'obiettivo di questa sezione è creare un segnale di monitoraggio delle prestazioni del modello.

3. Selezionare Aggiungi.

4. Nella finestra Modifica segnale selezionare Prestazioni modello (ANTEPRIMA) e quindi seguire questa procedura per configurare il segnale di prestazioni del modello:

   1. Nel passaggio 1:
      1. Per l'asset di dati di produzione, selezionare l'asset di dati di output del modello.
      2. Selezionare una colonna di destinazione appropriata, DEFAULT_NEXT_MONTHad esempio .
      3. Selezionare le dimensioni e l'offset della finestra di retrospettiva da utilizzare.
   2. Nel passaggio 2:
      1. Per la risorsa di dati di riferimento, selezionare la risorsa di dati di riferimento reale.
      2. Selezionare la colonna di destinazione, ground_truthad esempio .
      3. Selezionare la colonna da usare per il join con l'asset di dati di output del modello, ad esempio correlationid. Entrambi gli asset di dati devono contenere tale colonna e devono contenere un ID univoco per ogni riga nell'asset di dati.
   3. Nel passaggio 3 selezionare le metriche delle prestazioni da usare e specificare le rispettive soglie.

   

5. Seleziona Salva. Nella pagina Seleziona segnali di monitoraggio il segnale di prestazioni del modello è visibile.

   

Completare la configurazione

1. Nella pagina Seleziona segnali di monitoraggio selezionare Avanti.

2. Nella pagina Notifiche attivare le notifiche per il segnale di prestazioni del modello e quindi selezionare Avanti.

3. Nella pagina per rivedere le impostazioni di monitoraggio, esaminare le impostazioni.

   

4. Selezionare Crea per creare il monitoraggio delle prestazioni del modello.

1. Creare un file YAML di definizione di monitoraggio simile a quello seguente. Prima di usare questa definizione, modificare le impostazioni seguenti e tutte le altre per soddisfare le esigenze dell'ambiente:

   • Per endpoint_deployment_idusare un valore nel formato azureml:<endpoint-name>:<deployment-name>.
   • Per pre_processing_componentusare un valore nel formato azureml:<component-name>:<component-version>. Specificare la versione esatta, ad esempio 1.0.0, non 1.
   • Per ogni path, usare un valore nel formato azureml:<data-asset-name>:<version>.
   • Per il target_column valore, usare il nome della colonna di output che contiene valori stimati dal modello.
   • In emailselencare gli indirizzi di posta elettronica da usare per le notifiche.

   # 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.0.0
         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
         alert_enabled: true
         metric_thresholds:
           numerical:
             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.0.0
         reference_data:
           input_data:
             path: azureml:my_model_validation_data:1 # use training data as comparison reference dataset
             type: mltable
           data_context: validation
         alert_enabled: true
         metric_thresholds:
           categorical:
             pearsons_chi_squared_test: 0.02
     
     alert_notification:
       emails:
         - [email protected]
         - [email protected]
   

2. Eseguire il comando seguente per creare il modello.

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

Usare uno script simile al codice Python seguente per configurare il monitoraggio del modello. Sostituire innanzitutto i segnaposto seguenti con i valori appropriati:

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.
subscription_id = "<subscription-ID>"
resource_group = "<resource-group-name>"
workspace = "<workspace-name>"
ml_client = MLClient(
   InteractiveBrowserCredential(),
   subscription_id,
   resource_group,
   workspace
)

# Specify the compute instance.
spark_compute = ServerlessSparkCompute(
    instance_type="standard_e4s_v3",
    runtime_version="3.3"
)

# Specify the target data asset (the production data asset).
production_data = ProductionData(
    input_data=Input(
        type="uri_folder",
        path="azureml:<production-data-asset-name>:1"
    ),
    data_context=MonitorDatasetContext.MODEL_INPUTS,
    pre_processing_component="azureml:<preprocessing-component-name>:1.0.0"
)

# Specify the training data to use as a reference data asset.
reference_data_training = ReferenceData(
    input_data=Input(
        type="mltable",
        path="azureml:<training-data-asset-name>: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,
    alert_enabled=True
)

# 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=True
)

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

# Create an alert notification object.
alert_notification = AlertNotification(
    emails=['<email-address-1>', '<email-address-2>']
)

# Set up the monitor definition.
monitor_definition = MonitorDefinition(
    compute=spark_compute,
    monitoring_signals=monitoring_signals,
    alert_notification=alert_notification
)

# Specify the schedule frequency.
recurrence_trigger = RecurrenceTrigger(
    frequency="<frequency-unit>",
    interval=<interval>,
    schedule=RecurrencePattern(hours=<start-hour>, minutes=<start-minutes>)
)

# Create the monitoring schedule.
model_monitor = MonitorSchedule(
    name="fraud_detection_model_monitoring_advanced",
    trigger=recurrence_trigger,
    create_monitor=monitor_definition
)

# Schedule the monitoring job.
poller = ml_client.schedules.begin_create_or_update(model_monitor)
created_monitor = poller.result()

Attualmente lo studio non supporta la configurazione del monitoraggio per i modelli distribuiti all'esterno di Azure Machine Learning. Consultare invece le schede dell'interfaccia della riga di comando Azure o del SDK Python.

Dopo aver usato l'interfaccia della riga di comando di Azure o Python SDK per configurare il monitoraggio, è possibile visualizzare i risultati del monitoraggio in Studio. Per altre informazioni sull'interpretazione dei risultati del monitoraggio, vedere Interpretare i risultati del monitoraggio.

Dopo aver creato e registrato il componente del segnale personalizzato in Azure Machine Learning, seguire questa procedura per configurare il monitoraggio del modello:

1. Creare una definizione di monitoraggio in un file YAML simile a quello seguente. Prima di usare questa definizione, modificare le impostazioni seguenti e tutte le altre per soddisfare le esigenze dell'ambiente:

   • Per component_idusare un valore nel formato azureml:<custom-signal-name>:1.0.0.
   • Per path nella sezione dati di input usare un valore nel formato azureml:<production-data-asset-name>:<version>.
   • Per pre_processing_component:
     • Se si usa l'agente di raccolta dati per raccogliere i dati, è possibile omettere la pre_processing_component proprietà .
     • Se non si usa l'agente di raccolta dati e si vuole usare un componente per pre-elaborare i dati di produzione, usare un valore nel formato azureml:<custom-preprocessor-name>:<custom-preprocessor-version>.
   • In emailselencare gli indirizzi di posta elettronica da usare per le notifiche.

   # custom-monitoring.yaml
   $schema:  http://azureml/sdk-2-0/Schedule.json
   name: my-custom-signal
   trigger:
     type: recurrence
     frequency: day # Possible frequency values include "minute," "hour," "day," "week," and "month."
     interval: 7 # Monitoring runs every day when you use the value 1.
   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:
         - [email protected]
   

2. Eseguire il comando seguente per creare il modello:

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

SDK Python attualmente non supporta il monitoraggio per segnali personalizzati. Consultare invece l'Interfaccia della riga di comando di Azure.

Lo studio attualmente non supporta il monitoraggio per segnali personalizzati. Consultare invece l'Interfaccia della riga di comando di Azure.