Monitorowanie wydajności modeli wdrożonych w środowisku produkcyjnym

Artykuł
04/07/2024

DOTYCZY: Rozszerzenie interfejsu wiersza polecenia platformy Azure w wersji 2 (current)Zestaw PYTHON SDK azure-ai-ml v2 (bieżąca)

Dowiedz się, jak używać monitorowania modeli usługi Azure Machine Edukacja w celu ciągłego śledzenia wydajności modeli uczenia maszynowego w środowisku produkcyjnym. Monitorowanie modelu zapewnia szeroki wgląd w sygnały monitorowania i alerty dotyczące potencjalnych problemów. Podczas monitorowania sygnałów i metryk wydajności modeli w środowisku produkcyjnym można krytycznie ocenić związane z nimi zagrożenia i zidentyfikować martwe miejsca, które mogą negatywnie wpłynąć na twoją firmę.

Z tego artykułu dowiesz się, jak wykonywać następujące zadania:

Konfigurowanie gotowego i zaawansowanego monitorowania modeli wdrożonych w usłudze Azure Machine Edukacja punktów końcowych online
Monitorowanie metryk wydajności modeli w środowisku produkcyjnym
Monitorowanie modeli wdrożonych poza usługą Azure Machine Edukacja lub wdrożonych w punktach końcowych usługi Azure Machine Edukacja wsadowych
Konfigurowanie monitorowania modelu przy użyciu niestandardowych sygnałów i metryk
Interpretowanie wyników monitorowania
Integrowanie monitorowania modelu usługi Azure Machine Edukacja z usługą Azure Event Grid

Wymagania wstępne

Przed wykonaniem kroków opisanych w tym artykule upewnij się, że masz następujące wymagania wstępne:

Interfejs wiersza polecenia platformy ml Azure i rozszerzenie interfejsu wiersza polecenia platformy Azure. Aby uzyskać więcej informacji, zobacz Instalowanie, konfigurowanie i używanie interfejsu wiersza polecenia (wersja 2).

Ważne

W przykładach interfejsu wiersza polecenia w tym artykule założono, że używasz powłoki Bash (lub zgodnej). Na przykład z systemu Linux lub Podsystem Windows dla systemu Linux.
Obszar roboczy usługi Azure Machine Learning. Jeśli go nie masz, wykonaj kroki opisane w temacie Instalowanie, konfigurowanie i używanie interfejsu wiersza polecenia (wersja 2), aby go utworzyć.

Przed wykonaniem kroków opisanych w tym artykule upewnij się, że masz następujące wymagania wstępne:

Obszar roboczy usługi Azure Machine Learning. Jeśli go nie masz, wykonaj kroki opisane w artykule Szybki start: tworzenie zasobów obszaru roboczego, aby je utworzyć.
Aby zainstalować zestaw PYTHON SDK w wersji 2, użyj następującego polecenia:
```
pip install azure-ai-ml azure-identity
```
Aby zaktualizować istniejącą instalację zestawu SDK do najnowszej wersji, użyj następującego polecenia:
```
pip install --upgrade azure-ai-ml azure-identity
```
Aby uzyskać więcej informacji, zobacz Install the Python SDK v2 for Azure Machine Edukacja (Instalowanie zestawu SDK języka Python w wersji 2 dla usługi Azure Machine Edukacja).

Kontrola dostępu na podstawie ról platformy Azure (Azure RBAC): jest używana do udzielania dostępu do operacji w usłudze Azure Machine Learning. Aby wykonać kroki opisane w tym artykule, konto użytkownika musi mieć przypisaną rolę właściciela lub współautora dla obszaru roboczego usługi Azure Machine Edukacja lub rolę niestandardową zezwalającą na Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*funkcję . Aby uzyskać więcej informacji, zobacz Zarządzanie dostępem do obszaru roboczego usługi Azure Machine Edukacja.
Aby monitorować model wdrożony w punkcie końcowym online usługi Azure Machine Edukacja (zarządzany punkt końcowy online lub punkt końcowy online platformy Kubernetes), upewnij się, że:
- Masz już wdrożony model w punkcie końcowym usługi Azure Machine Edukacja online. Obsługiwane są zarówno zarządzane punkty końcowe online, jak i punkt końcowy online platformy Kubernetes. Jeśli nie masz modelu wdrożonego w punkcie końcowym usługi Azure Machine Edukacja online, zobacz Wdrażanie i ocenianie modelu uczenia maszynowego przy użyciu punktu końcowego online.
- Włącz zbieranie danych dla wdrożenia modelu. Zbieranie danych można włączyć podczas kroku wdrażania dla punktów końcowych online usługi Azure Machine Edukacja. Aby uzyskać więcej informacji, zobacz Zbieranie danych produkcyjnych z modeli wdrożonych w punkcie końcowym w czasie rzeczywistym.
Aby monitorować model wdrożony w punkcie końcowym usługi Azure Machine Edukacja batch lub wdrożony poza usługą Azure Machine Edukacja, upewnij się, że:
- Należy zebrać dane produkcyjne i zarejestrować je jako zasób danych usługi Azure Machine Edukacja.
- Stale aktualizuj zarejestrowany zasób danych na potrzeby monitorowania modelu.
- (Zalecane) Zarejestruj model w obszarze roboczym usługi Azure Machine Edukacja w celu śledzenia pochodzenia.

Ważne

Zaplanowano uruchamianie zadań monitorowania modelu w bezserwerowych pulach obliczeniowych platformy Spark z obsługą następujących typów wystąpień maszyn wirtualnych: Standard_E4s_v3, , Standard_E8s_v3Standard_E16s_v3, Standard_E32s_v3i Standard_E64s_v3. Możesz wybrać typ wystąpienia maszyny wirtualnej z właściwością create_monitor.compute.instance_type w konfiguracji YAML lub z listy rozwijanej w usłudze Azure Machine Edukacja Studio.

Konfigurowanie gotowego do użycia monitorowania modelu

Załóżmy, że model jest wdrażany w środowisku produkcyjnym w punkcie końcowym usługi Azure Machine Edukacja online i włączasz zbieranie danych w czasie wdrażania. W tym scenariuszu usługa Azure Machine Edukacja zbiera dane wnioskowania produkcyjnego i automatycznie przechowuje je w usłudze Microsoft Azure Blob Storage. Następnie możesz użyć monitorowania modelu usługi Azure Machine Edukacja, aby stale monitorować te dane wnioskowania produkcyjnego.

Możesz użyć interfejsu wiersza polecenia platformy Azure, zestawu SDK języka Python lub programu Studio na potrzeby gotowej konfiguracji monitorowania modelu. Konfiguracja monitorowania modelu gotowego do użycia zapewnia następujące możliwości monitorowania:

Usługa Azure Machine Edukacja automatycznie wykrywa zestaw danych wnioskowania produkcyjnego skojarzony z wdrożeniem online usługi Azure Machine Edukacja i używa zestawu danych do monitorowania modelu.
Zestaw danych referencyjnych porównania jest ustawiany jako ostatni, poprzedni zestaw danych wnioskowania produkcyjnego.
Konfiguracja monitorowania automatycznie obejmuje i śledzi wbudowane sygnały monitorowania: dryf danych, dryf przewidywania i jakość danych. Dla każdego sygnału monitorowania usługa Azure Machine Edukacja używa:
- niedawny, poprzedni zestaw danych wnioskowania produkcyjnego jako zestaw danych referencyjnych porównania.
- inteligentne wartości domyślne metryk i progów.
Zadanie monitorowania ma być uruchamiane codziennie o godzinie 3:15 (na przykład), aby uzyskać sygnały monitorowania i ocenić każdy wynik metryki względem odpowiadającego mu progu. Domyślnie po przekroczeniu dowolnego progu usługa Azure Machine Edukacja wysyła wiadomość e-mail z alertem do użytkownika, który skonfigurował monitor.

Monitorowanie modelu usługi Azure Machine Edukacja używa az ml schedule do planowania zadania monitorowania. Monitor modelu gotowego do użycia można utworzyć przy użyciu następującego polecenia interfejsu wiersza polecenia i definicji YAML:

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

Poniższy kod YAML zawiera definicję monitorowania modelu gotowego do użycia.

# 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

Aby skonfigurować wbudowane monitorowanie modelu, możesz użyć następującego kodu:

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()

Konfigurowanie zaawansowanego monitorowania modelu

Usługa Azure Machine Edukacja oferuje wiele możliwości ciągłego monitorowania modeli. Zobacz Możliwości monitorowania modeli, aby uzyskać pełną listę tych możliwości. W wielu przypadkach należy skonfigurować monitorowanie modelu przy użyciu zaawansowanych funkcji monitorowania. W poniższych sekcjach skonfigurujesz monitorowanie modelu przy użyciu tych funkcji:

Korzystanie z wielu sygnałów monitorowania dla szerokiego widoku.
Użycie historycznych danych trenowania modelu lub danych walidacji jako zestawu danych referencyjnych porównania.
Monitorowanie najważniejszych n najważniejszych funkcji i poszczególnych funkcji.

Konfigurowanie ważności funkcji

Ważność funkcji reprezentuje względne znaczenie każdej funkcji wejściowej do danych wyjściowych modelu. Na przykład temperature może być ważniejsze od przewidywania modelu w porównaniu z elevationwartością . Włączenie ważności funkcji może zapewnić wgląd w funkcje, których nie chcesz dryfować ani mieć problemów z jakością danych w środowisku produkcyjnym.

Aby włączyć ważność funkcji z dowolnymi sygnałami (takimi jak dryf danych lub jakość danych), należy podać następujące elementy:

Zestaw danych trenowania reference_data jako zestaw danych.
Właściwość reference_data.data_column_names.target_column , która jest nazwą kolumny danych wyjściowych/przewidywania modelu.

Po włączeniu ważności funkcji zobaczysz znaczenie funkcji dla każdej funkcji monitora w interfejsie użytkownika programu Azure Machine Edukacja model monitoring Studio.

Do zaawansowanej konfiguracji monitorowania modelu można użyć interfejsu wiersza polecenia platformy Azure, zestawu SDK języka Python lub programu Studio.

Utwórz konfigurację zaawansowanego monitorowania modelu za pomocą następującego polecenia interfejsu wiersza polecenia i definicji YAML:

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

Poniższy kod YAML zawiera definicję zaawansowanego monitorowania modelu.

# 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

Użyj następującego kodu do konfigurowania zaawansowanego monitorowania modelu:

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()

Aby skonfigurować zaawansowane monitorowanie:

Ukończ całość na stronie Ustawienia podstawowe zgodnie z opisem we wcześniejszej sekcji Konfigurowanie gotowego monitorowania modelu.
Wybierz przycisk Dalej, aby otworzyć stronę Konfigurowanie zasobu danych w sekcji Ustawienia zaawansowane.
Dodaj zestaw danych, który ma być używany jako zestaw danych referencyjnych. Zalecamy użycie danych trenowania modelu jako zestawu danych referencyjnych porównawczych na potrzeby dryfu danych i jakości danych. Ponadto użyj danych weryfikacji modelu jako zestawu danych referencyjnych porównania na potrzeby dryfu przewidywania.
Wybierz przycisk Dalej , aby przejść do strony Wybieranie sygnałów monitorowania. Na tej stronie zobaczysz już dodane sygnały monitorowania (jeśli wybrano wcześniej wdrożenie usługi Azure Machine Edukacja online). Sygnały (dryf danych, dryf przewidywania i jakość danych) używają ostatnich, przeszłych danych produkcyjnych jako zestawu danych referencyjnych porównania i używają inteligentnych wartości domyślnych dla metryk i progów.
Wybierz pozycję Edytuj obok sygnału dryfu danych.
Skonfiguruj dryf danych w oknie Edytowanie sygnału w następujący sposób:
1. W kroku 1 dla zasobu danych produkcyjnych wybierz zestaw danych wejściowych modelu. Ponadto wybierz następujące opcje:
  - Wybierz żądany rozmiar okna wyszukiwania.
2. W kroku 2 dla zasobu danych referencyjnych wybierz zestaw danych szkoleniowych. Ponadto wybierz następujące opcje:
  - Wybierz kolumnę docelową (dane wyjściowe).
3. W kroku 3 wybierz, aby monitorować dryf dla najważniejszych funkcji N lub monitorować dryf pod kątem określonego zestawu funkcji.
4. W kroku 4 wybierz preferowaną metryki i progi, które mają być używane dla funkcji liczbowych.
5. W kroku 5 wybierz preferowaną metrykę i progi, które mają być używane dla funkcji kategorii.
Wybierz pozycję Zapisz , aby powrócić do strony Wybieranie sygnałów monitorowania.
Wybierz pozycję Dodaj, aby otworzyć okno Edytowanie sygnału.
Wybierz pozycję Dryf autorstwa funkcji (wersja zapoznawcza), aby skonfigurować sygnał dryfu autorstwa funkcji w następujący sposób:
1. W kroku 1 wybierz zasób danych produkcyjnych, który zawiera dane wejściowe modelu
  - Ponadto wybierz żądany rozmiar okna odnośnika.
2. W kroku 2 wybierz zasób danych produkcyjnych zawierający dane wyjściowe modelu.
  - Ponadto wybierz wspólną kolumnę między tymi elementami zawartości danych, aby je dołączyć. Jeśli dane zostały zebrane za pomocą modułu zbierającego dane, typowa kolumna to correlationid.
3. (Opcjonalnie) Jeśli użyto modułu zbierającego dane do zbierania danych, które mają już dołączone dane wejściowe i wyjściowe modelu, wybierz dołączony zestaw danych jako zasób danych produkcyjnych (w kroku 1)
  - Ponadto usuń krok 2 w panelu konfiguracji.
4. W kroku 3 wybierz zestaw danych szkoleniowych, który będzie używany jako zestaw danych referencyjnych.
  - Ponadto wybierz kolumnę docelową (dane wyjściowe) dla zestawu danych treningowych.
5. W kroku 4 wybierz preferowaną metryki i próg.
Wybierz pozycję Zapisz , aby powrócić do strony Wybieranie sygnałów monitorowania.
Po zakończeniu konfigurowania sygnałów monitorowania wybierz przycisk Dalej , aby przejść do strony Powiadomienia .
Na stronie Powiadomienia włącz powiadomienia o alertach dla każdego sygnału i wybierz pozycję Dalej.
Przejrzyj ustawienia na stronie Przeglądanie ustawień monitorowania.
Wybierz pozycję Utwórz , aby utworzyć zaawansowany monitor modelu.

Konfigurowanie monitorowania wydajności modelu

Monitorowanie modeli usługi Azure Machine Edukacja umożliwia śledzenie wydajności modeli w środowisku produkcyjnym przez obliczanie ich metryk wydajności. Obecnie obsługiwane są następujące metryki wydajności modelu:

W przypadku modeli klasyfikacji:

Dokładność
Dokładność
Odwołaj

W przypadku modeli regresji:

Średni błąd bezwzględny (MAE)
Błąd średniokwadratowy (MSE)
Błąd średniokwadratowy (RMSE)

Więcej wymagań wstępnych dotyczących monitorowania wydajności modelu

Aby skonfigurować sygnał wydajności modelu, musisz spełnić następujące wymagania:

Zawierają dane wyjściowe dla modelu produkcyjnego (przewidywania modelu) z unikatowym identyfikatorem dla każdego wiersza. Jeśli zbierasz dane produkcyjne za pomocą modułu zbierającego dane usługi Azure Machine Edukacja, correlation_id zostanie on udostępniony dla każdego żądania wnioskowania. W przypadku modułu zbierającego dane masz również możliwość rejestrowania własnego unikatowego identyfikatora z aplikacji.

Uwaga

W przypadku monitorowania wydajności modelu usługi Azure Machine Edukacja zalecamy zarejestrowanie unikatowego identyfikatora we własnej kolumnie przy użyciu modułu zbierającego dane usługi Azure Machine Edukacja.
Mają podstawowe dane prawdy (wartości rzeczywiste) z unikatowym identyfikatorem dla każdego wiersza. Unikatowy identyfikator dla danego wiersza powinien być zgodny z unikatowym identyfikatorem danych wyjściowych modelu dla tego konkretnego żądania wnioskowania. Ten unikatowy identyfikator służy do łączenia zestawu danych podstawowej prawdy z danymi wyjściowymi modelu.

Bez posiadania podstawowych danych prawdy nie można wykonywać monitorowania wydajności modelu. Ze względu na to, że na poziomie aplikacji napotykane są podstawowe dane prawdy, odpowiedzialność za ich zbieranie w miarę ich udostępniania. Należy również zachować zasób danych w usłudze Azure Machine Edukacja, który zawiera te podstawowe dane prawdy.
(Opcjonalnie) Zestaw danych tabelarycznych ze wstępnie sprzężonym zestawem danych z danymi wyjściowymi modelu i danymi podstawy prawdy już połączonymi.

Monitorowanie wymagań dotyczących wydajności modelu podczas korzystania z modułu zbierającego dane

Jeśli używasz modułu zbierającego dane usługi Azure Machine Edukacja do zbierania danych wnioskowania produkcyjnego bez podawania własnego unikatowego identyfikatora dla każdego wiersza jako oddzielnej kolumny, correlationid zostanie automatycznie wygenerowany element i uwzględniony w rejestrowanym obiekcie JSON. Jednak moduł zbierający dane będzie wsadowy wiersze , które są wysyłane w krótkim odstępie czasu. Wiersze wsadowe będą należeć do tego samego obiektu JSON i w ten sposób będą miały taki sam correlationidkod .

Aby odróżnić wiersze w tym samym obiekcie JSON, usługa Azure Machine Edukacja model performance monitoring używa indeksowania w celu określenia kolejności wierszy w obiekcie JSON. Jeśli na przykład trzy wiersze są wsadowe, a correlationidtestwiersz , jeden z nich będzie miał identyfikator , wiersz drugi będzie miał identyfikator test_0test_1, a wiersz trzeci będzie miał identyfikator test_2. Aby upewnić się, że zestaw danych podstawowej prawdy zawiera unikatowe identyfikatory pasujące do zebranych danych wyjściowych modelu wnioskowania produkcyjnego, upewnij się, że indeksujesz je correlationid odpowiednio. Jeśli zarejestrowany obiekt JSON ma tylko jeden wiersz, będzie to correlationidcorrelationid_0.

Aby uniknąć używania tego indeksowania, zalecamy zarejestrowanie unikatowego identyfikatora we własnej kolumnie w ramce danych biblioteki pandas rejestrowanej za pomocą modułu zbierającego dane usługi Azure Machine Edukacja. Następnie w konfiguracji monitorowania modelu należy określić nazwę tej kolumny, aby połączyć dane wyjściowe modelu z danymi wyjściowymi podstawy. Tak długo, jak identyfikatory dla każdego wiersza w obu zestawach danych są takie same, monitorowanie modelu usługi Azure Machine Edukacja może wykonywać monitorowanie wydajności modelu.

Przykładowy przepływ pracy monitorowania wydajności modelu

Aby zrozumieć pojęcia związane z monitorowaniem wydajności modelu, rozważmy ten przykładowy przepływ pracy. Załóżmy, że wdrażasz model, aby przewidzieć, czy transakcje kart kredytowych są fałszywe, czy nie, możesz wykonać następujące kroki, aby monitorować wydajność modelu:

Skonfiguruj wdrożenie tak, aby używało modułu zbierającego dane w celu zbierania danych wnioskowania produkcyjnego modelu (danych wejściowych i wyjściowych). Załóżmy, że dane wyjściowe są przechowywane w kolumnie is_fraud.
Dla każdego wiersza zebranych danych wnioskowania zarejestruj unikatowy identyfikator. Unikatowy identyfikator może pochodzić z aplikacji lub użyć correlationid tego, że usługa Azure Machine Edukacja unikatowo generuje dla każdego zarejestrowanego obiektu JSON.
Później, gdy dane podstawowej prawdy (lub rzeczywistej) is_fraud staną się dostępne, są również rejestrowane i mapowane na ten sam unikatowy identyfikator, który został zarejestrowany przy użyciu danych wyjściowych modelu.
Te podstawowe dane prawdy is_fraud są również zbierane, przechowywane i rejestrowane w usłudze Azure Machine Edukacja jako zasób danych.
Utwórz sygnał monitorowania wydajności modelu, który łączy w wyniku wnioskowania produkcyjnego modelu i podstawowe zasoby danych prawdy przy użyciu unikatowych kolumn identyfikatorów.
Na koniec oblicz metryki wydajności modelu.

Po spełnieniu wymagań wstępnych dotyczących monitorowania wydajności modelu można skonfigurować monitorowanie modelu przy użyciu następującego polecenia interfejsu wiersza polecenia i definicji YAML:

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

Poniższy kod YAML zawiera definicję monitorowania modelu przy użyciu zebranych danych wnioskowania produkcyjnego.

$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

Po spełnieniu wymagań wstępnych dotyczących monitorowania wydajności modelu można skonfigurować monitorowanie modelu przy użyciu następującego kodu w języku Python:

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()

Aby skonfigurować monitorowanie wydajności modelu:

Wypełnij wpisy na stronie Ustawienia podstawowe zgodnie z opisem we wcześniejszej sekcji Konfigurowanie wbudowanego monitorowania modelu.
Wybierz przycisk Dalej, aby otworzyć stronę Konfigurowanie zasobu danych w sekcji Ustawienia zaawansowane.
Wybierz pozycję + Dodaj , aby dodać zestaw danych do użycia jako zestaw danych podstawowej prawdy.

Upewnij się, że zestaw danych wyjściowych modelu znajduje się również na liście dodanych zestawów danych. Dodany zestaw danych podstawowej prawdy powinien mieć unikatową kolumnę identyfikatora. Wartości w unikatowej kolumnie IDENTYFIKATOR zarówno dla zestawu danych podstawowej prawdy, jak i zestawu danych wyjściowych modelu muszą być zgodne, aby oba zestawy danych zostały połączone przed obliczeniami metryk.
Wybierz przycisk Dalej , aby przejść do strony Wybieranie sygnałów monitorowania. Na tej stronie zobaczysz już dodane sygnały monitorowania (jeśli wcześniej wybrano usługę Azure Machine Edukacja wdrożenia online).
Usuń istniejące sygnały monitorowania na stronie, ponieważ interesuje Cię tylko utworzenie sygnału monitorowania wydajności modelu.
Wybierz pozycję Dodaj, aby otworzyć okno Edytowanie sygnału.
Wybierz pozycję Wydajność modelu (wersja zapoznawcza), aby skonfigurować sygnał wydajności modelu w następujący sposób:
1. W kroku 1 dla zasobu danych produkcyjnych wybierz zestaw danych wyjściowych modelu. Ponadto wprowadź następujące opcje:
  - Wybierz odpowiednią kolumnę docelową (na przykład is_fraud).
  - Wybierz żądany rozmiar okna wyszukiwania i przesunięcie okna odnośnika.
2. W kroku 2 dla zasobu danych referencyjnych wybierz wcześniej dodany zasób danych podstawowych danych. Ponadto wprowadź następujące opcje:
  - Wybierz odpowiednią kolumnę docelową.
  - Wybierz kolumnę, na której chcesz wykonać sprzężenie z zestawem danych wyjściowych modelu. Kolumna używana dla sprzężenia powinna być kolumną wspólną między dwoma zestawami danych, która ma unikatowy identyfikator dla każdego wiersza w zestawie danych (na przykład correlationid).
3. W kroku 3 wybierz żądane metryki wydajności i określ odpowiednie progi.
Wybierz pozycję Zapisz , aby powrócić do strony Wybieranie sygnałów monitorowania.
Wybierz przycisk Dalej , aby przejść do strony Powiadomienia .
Na stronie Powiadomienia włącz powiadomienie o alertach dla sygnału wydajności modelu i wybierz pozycję Dalej.
Przejrzyj ustawienia na stronie Przeglądanie ustawień monitorowania.
Wybierz pozycję Utwórz , aby utworzyć monitor wydajności modelu.

Konfigurowanie monitorowania modelu przez wprowadzenie danych produkcyjnych do usługi Azure Machine Edukacja

Można również skonfigurować monitorowanie modelu dla modeli wdrożonych w usłudze Azure Machine Edukacja punktach końcowych wsadowych lub wdrożonych poza usługą Azure Machine Edukacja. Jeśli nie masz wdrożenia, ale masz dane produkcyjne, możesz użyć tych danych do ciągłego monitorowania modelu. Aby monitorować te modele, musisz mieć możliwość:

Zbieranie danych wnioskowania produkcyjnego z modeli wdrożonych w środowisku produkcyjnym.
Zarejestruj dane wnioskowania produkcyjnego jako zasób danych usługi Azure Machine Edukacja i zapewnij ciągłe aktualizacje danych.
Podaj niestandardowy składnik przetwarzania wstępnego danych i zarejestruj go jako składnik usługi Azure Machine Edukacja.

Jeśli dane nie są zbierane z modułem zbierającym dane, musisz podać niestandardowy składnik przetwarzania wstępnego danych. Bez tego niestandardowego składnika przetwarzania wstępnego danych system monitorowania modelu usługi Azure Machine Edukacja nie będzie wiedział, jak przetwarzać dane w formie tabelarycznej z obsługą okien czasowych.

Niestandardowy składnik przetwarzania wstępnego musi mieć następujące podpisy wejściowe i wyjściowe:

Dane wejściowe/wyjściowe	Nazwa podpisu	Type	Opis	Przykładowa wartość
input	`data_window_start`	Literału	godzina rozpoczęcia okna danych w formacie ISO8601.	2023-05-01T04:31:57.012Z
input	`data_window_end`	Literału	godzina zakończenia okna danych w formacie ISO8601.	2023-05-01T04:31:57.012Z
input	`input_data`	uri_folder	Zebrane dane wnioskowania produkcyjnego zarejestrowane jako zasób danych usługi Azure Machine Edukacja.	azureml:myproduction_inference_data:1
output	`preprocessed_data`	mltable	Tabelaryczny zestaw danych zgodny z podzbiorem schematu danych referencyjnych.

Aby zapoznać się z przykładem niestandardowego składnika przetwarzania wstępnego danych, zobacz custom_preprocessing w repozytorium GitHub azuremml-examples.

Po spełnieniu poprzednich wymagań możesz skonfigurować monitorowanie modelu przy użyciu następującego polecenia interfejsu wiersza polecenia i definicji YAML:

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

Poniższy kod YAML zawiera definicję monitorowania modelu przy użyciu zebranych danych wnioskowania produkcyjnego.

# 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

Po spełnieniu poprzednich wymagań możesz skonfigurować monitorowanie modelu przy użyciu następującego kodu języka Python:

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()

Konfigurowanie monitorowania modelu przy użyciu niestandardowych sygnałów i metryk

Dzięki monitorowaniu modelu usługi Azure Machine Edukacja można zdefiniować niestandardowy sygnał i zaimplementować dowolną wybraną metrykę do monitorowania modelu. Ten sygnał niestandardowy można zarejestrować jako składnik usługi Azure Machine Edukacja. Gdy zadanie monitorowania modelu usługi Azure Machine Edukacja jest uruchamiane zgodnie z określonym harmonogramem, oblicza metryki zdefiniowane w ramach sygnału niestandardowego, podobnie jak w przypadku wstępnie utworzonych sygnałów (dryfu danych, dryfu przewidywania i jakości danych).

Aby skonfigurować sygnał niestandardowy do użycia na potrzeby monitorowania modelu, należy najpierw zdefiniować sygnał niestandardowy i zarejestrować go jako składnik usługi Azure Machine Edukacja. Składnik usługi Azure Machine Edukacja musi mieć następujące podpisy wejściowe i wyjściowe:

Podpis wejściowy składnika

Element wejściowy składnika DataFrame powinien zawierać następujące elementy:

Element mltable z przetworzonymi danymi ze składnika przetwarzania wstępnego
Dowolna liczba literałów, z których każda reprezentuje zaimplementowaną metryki w ramach niestandardowego składnika sygnału. Jeśli na przykład zaimplementowano metryki , std_deviationmusisz wprowadzić dane wejściowe dla elementu std_deviation_threshold. Ogólnie rzecz biorąc, powinna istnieć jedna wartość wejściowa na metryę o nazwie <metric_name>_threshold.

Nazwa podpisu	Type	Opis	Przykładowa wartość
production_data	mltable	Tabelaryczny zestaw danych zgodny z podzbiorem schematu danych referencyjnych.
std_deviation_threshold	Literału	Odpowiedni próg dla zaimplementowanego metryki.	2

Podpis wyjściowy składnika

Port wyjściowy składnika powinien mieć następujący podpis.

Nazwa podpisu	Type	Opis
signal_metrics	mltable	Tabela mltable zawierająca obliczone metryki. Schemat jest zdefiniowany w następnej sekcji signal_metrics schematu.

schemat signal_metrics

Ramka danych wyjściowych składnika powinna zawierać cztery kolumny: group, , metric_namemetric_valuei threshold_value.

Nazwa podpisu	Type	Opis	Przykładowa wartość
grupa	Literału	Grupowanie logiczne najwyższego poziomu do zastosowania do tej metryki niestandardowej.	TRANSACTIONAMOUNT
metric_name	Literału	Nazwa metryki niestandardowej.	std_deviation
metric_value	Numeryczne	Wartość metryki niestandardowej.	44,896.082
threshold_value	Numeryczne	Próg dla metryki niestandardowej.	2

W poniższej tabeli przedstawiono przykładowe dane wyjściowe z niestandardowego składnika sygnału, który oblicza metrykę std_deviation :

grupa	metric_value	metric_name	threshold_value
TRANSACTIONAMOUNT	44,896.082	std_deviation	2
LOCALHOUR	3.983	std_deviation	2
TRANSACTIONAMOUNTUSD	54,004.902	std_deviation	2
DIGITALITEMCOUNT	7.238	std_deviation	2
PHYSICALITEMCOUNT	5.509	std_deviation	2

Aby wyświetlić przykładową niestandardową definicję składnika sygnału i kod obliczeń metryk, zobacz custom_signal w repozytorium azureml-examples.

Po spełnieniu wymagań dotyczących używania niestandardowych sygnałów i metryk możesz skonfigurować monitorowanie modelu przy użyciu następującego polecenia interfejsu wiersza polecenia i definicji YAML:

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

Poniższy kod YAML zawiera definicję monitorowania modelu za pomocą sygnału niestandardowego. Niektóre kwestie, które należy zauważyć w kodzie:

Przyjęto założenie, że składnik został już utworzony i zarejestrowany przy użyciu niestandardowej definicji sygnału w usłudze Azure Machine Edukacja.
Element component_id zarejestrowanego niestandardowego składnika sygnału to azureml:my_custom_signal:1.0.0.
Jeśli dane zostały zebrane za pomocą modułu zbierającego dane, możesz pominąć pre_processing_component właściwość . Jeśli chcesz użyć składnika przetwarzania wstępnego do wstępnego przetwarzania danych produkcyjnych, które nie są zbierane przez moduł zbierający dane, możesz go określić.

# 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

Interpretowanie wyników monitorowania

Po skonfigurowaniu monitora modelu i ukończeniu pierwszego uruchomienia możesz wrócić do karty Monitorowanie w usłudze Azure Machine Edukacja Studio, aby wyświetlić wyniki.

W widoku głównym Monitorowanie wybierz nazwę monitora modelu, aby wyświetlić stronę Przegląd monitorowania. Na tej stronie przedstawiono odpowiedni model, punkt końcowy i wdrożenie wraz ze szczegółami dotyczącymi skonfigurowanych sygnałów. Następny obraz przedstawia pulpit nawigacyjny monitorowania, który zawiera sygnały dryfu danych i jakości danych. W zależności od skonfigurowanych sygnałów monitorowania pulpit nawigacyjny może wyglądać inaczej.
Zapoznaj się z sekcją Powiadomienia pulpitu nawigacyjnego, aby zobaczyć, dla każdego sygnału, który funkcje naruszyły skonfigurowany próg dla odpowiednich metryk:
Wybierz data_drift, aby przejść do strony szczegółów dryfu danych. Na stronie szczegółów można zobaczyć wartość metryki dryfu danych dla każdej funkcji liczbowej i podzielonej na kategorie uwzględnionej w konfiguracji monitorowania. Gdy monitor ma więcej niż jeden przebieg, zobaczysz linię trendu dla każdej funkcji.
Aby wyświetlić szczegółowo poszczególne funkcje, wybierz nazwę funkcji, aby wyświetlić dystrybucję produkcyjną w porównaniu z dystrybucją referencyjną. Ten widok umożliwia również śledzenie dryfu w czasie dla tej konkretnej funkcji.
Wróć do pulpitu nawigacyjnego monitorowania i wybierz pozycję data_quality , aby wyświetlić stronę sygnału jakości danych. Na tej stronie można zobaczyć współczynniki wartości null, wartości poza granicami i współczynniki błędów typu danych dla każdej monitorowanej funkcji.

Monitorowanie modelu jest procesem ciągłym. Dzięki monitorowaniu modeli usługi Azure Machine Edukacja można skonfigurować wiele sygnałów monitorowania w celu uzyskania szerokiego wglądu w wydajność modeli w środowisku produkcyjnym.

Integrowanie monitorowania modelu usługi Azure Machine Edukacja z usługą Azure Event Grid

Zdarzenia generowane przez usługę Azure Machine Edukacja monitorowania modelu umożliwiają konfigurowanie aplikacji, procesów lub przepływów pracy ciągłej integracji/ciągłego wdrażania za pomocą usługi Azure Event Grid. Zdarzenia można używać za pośrednictwem różnych programów obsługi zdarzeń, takich jak Azure Event Hubs, Azure Functions i Logic Apps. Na podstawie dryfu wykrytego przez monitory można podjąć działania programowo, takie jak skonfigurowanie potoku uczenia maszynowego w celu ponownego wytrenowania modelu i jego ponownego wdrożenia.

Aby rozpocząć integrowanie monitorowania modelu usługi Azure Machine Edukacja z usługą Event Grid:

Wykonaj kroki opisane w temacie Konfigurowanie w witrynie Azure Portal. Nadaj subskrypcji zdarzeń nazwę, taką jak MonitoringEvent, i wybierz tylko pole Stan uruchomienia zmienione w obszarze Typy zdarzeń.

Ostrzeżenie

Pamiętaj, aby wybrać pozycję Stan uruchomienia zmieniony dla typu zdarzenia. Nie wybieraj pozycji Wykryto dryf zestawu danych, ponieważ dotyczy to dryfu danych w wersji 1, a nie monitorowania modelu usługi Azure Machine Edukacja.
Wykonaj kroki opisane w temacie Filtrowanie i subskrybowanie zdarzeń , aby skonfigurować filtrowanie zdarzeń dla danego scenariusza. Przejdź do karty Filtry i dodaj następujący klucz, operator i wartość w obszarze Filtry zaawansowane:
- Klucz: data.RunTags.azureml_modelmonitor_threshold_breached
- Wartość: nie powiodło się z powodu co najmniej jednej funkcji naruszającej progi metryk
- Operator: Ciąg zawiera
Dzięki temu filtrowi zdarzenia są generowane, gdy stan uruchomienia zmieni się (z Ukończono na Niepowodzenie lub Zakończone) dla dowolnego monitora w obszarze roboczym usługi Azure Machine Edukacja.
Aby filtrować na poziomie monitorowania, użyj następującego klucza, operatora i wartości w obszarze Filtry zaawansowane:
- Klucz: data.RunTags.azureml_modelmonitor_threshold_breached
- Wartość: your_monitor_name_signal_name
- Operator: Ciąg zawiera
Upewnij się, że your_monitor_name_signal_name jest to nazwa sygnału w określonym monitorze, dla którego chcesz filtrować zdarzenia. Na przykład credit_card_fraud_monitor_data_drift. Aby ten filtr działał, ten ciąg musi być zgodny z nazwą sygnału monitorowania. Należy nazwać sygnał zarówno nazwą monitora, jak i nazwą sygnału dla tego przypadku.
Po zakończeniu konfiguracji subskrypcji zdarzeń wybierz żądany punkt końcowy, który będzie służyć jako program obsługi zdarzeń, taki jak Azure Event Hubs.
Po przechwyceniu zdarzeń można je wyświetlić na stronie punktu końcowego:

Zdarzenia można również wyświetlić na karcie Metryki usługi Azure Monitor: