Freigeben über

Sammeln von Produktionsdaten aus Modellen, die für Rückschluss in Echtzeit bereitgestellt werden

  • Artikel

GILT FÜR:Azure CLI ML-Erweiterung v2 (aktuell)Python SDK azure-ai-ml v2 (aktuell)

In diesem Artikel erfahren Sie, wie Sie den Azure Machine Learning Datensammler verwenden, um Produktionsrückschlussdaten aus einem Modell zu sammeln, das für einen verwalteten Azure Machine Learning-Onlineendpunkt oder einen Kubernetes-Onlineendpunkt bereitgestellt wurde.

Sie können die Datensammlung für neue oder vorhandene Onlineendpunktbereitstellungen aktivieren. Der Datensammler von Azure Machine Learning protokolliert Rückschlussdaten in Azure Blob Storage. Die mit dem Python SDK gesammelten Daten werden automatisch als Datenressource in Ihrem Azure Machine Learning-Arbeitsbereich registriert. Diese Datenressource kann zur Modellüberwachung dienen.

Wenn Sie daran interessiert sind, Produktionsrückschlussdaten für ein MLflow-Modell zu sammeln, das für einen Echtzeitendpunkt bereitgestellt wurde, siehe Datensammlung für MLflow-Modelle.

Voraussetzungen

Stellen Sie vor dem Ausführen der Schritte in diesem Artikel sicher, dass Sie über die folgenden erforderlichen Komponenten verfügen:

  • Die rollenbasierte Zugriffssteuerung in Azure (Azure RBAC) wird verwendet, um Zugriff auf Vorgänge in Azure Machine Learning zu gewähren. Um die Schritte in diesem Artikel auszuführen, muss Ihr Benutzerkonto der Rolle Besitzer oder Mitwirkender für den Azure Machine Learning-Arbeitsbereich bzw. einer benutzerdefinierte Rolle zugewiesen werden, die Microsoft.MachineLearningServices/workspaces/onlineEndpoints/* zulässt. Weitere Informationen finden Sie unter Zugriff auf einen Azure Machine Learning-Arbeitsbereich verwalten.

Ausführen einer benutzerdefinierten Protokollierung zur Modellüberwachung

Die Datensammlung mit benutzerdefinierter Protokollierung ermöglicht Ihnen, Pandas-DataFrames vor, während und nach allen Datentransformationen direkt in Ihrem Bewertungsskript zu protokollieren. Mit der benutzerdefinierten Protokollierung werden tabellarische Daten in Echtzeit in Ihrem Arbeitsbereich-Blob-Speicher oder einem benutzerdefinierten Blob-Speichercontainer protokolliert. Ihre Modellmonitore können die Daten aus dem Speicher nutzen.

Aktualisieren Ihres Bewertungsskripts mit benutzerdefiniertem Protokollierungscode

Fügen Sie Ihrem Bewertungsskript (score.py) zunächst benutzerdefinierten Protokollierungscode hinzu. Für eine benutzerdefinierte Protokollierung benötigen Sie das Paket azureml-ai-monitoring. Weitere Informationen zu diesem Paket finden Sie auf der umfassenden PyPI-Seite zum Datensammler-SDK.

  1. Importieren Sie das Paket azureml-ai-monitoring, indem Sie die folgende Zeile am Anfang des Bewertungsskripts hinzufügen:

    from azureml.ai.monitoring import Collector

  2. Deklarieren Sie in Ihrer init()-Funktion (bis zu fünf) Datensammlungsvariablen:

    Hinweis

    Wenn Sie die Namen model_inputs und model_outputs für Ihre Collector-Objekte verwenden, erkennt das Modellüberwachungssystem automatisch die automatisch registrierten Datenressourcen, um eine bessere Modellüberwachung zu ermöglichen.

    global inputs_collector, outputs_collector
inputs_collector = Collector(name='model_inputs')          
outputs_collector = Collector(name='model_outputs')

    Standardmäßig löst Azure Machine Learning eine Ausnahme aus, wenn während der Datensammlung ein Fehler auftritt. Optional können Sie mithilfe des Parameters on_error eine Funktion angeben, die ausgeführt werden soll, wenn ein Protokollierungsfehler auftritt. Wenn Sie z. B. den Parameter on_error im folgenden Code angeben, protokolliert Azure Machine Learning den Fehler, anstatt eine Ausnahme auszulösen:

    inputs_collector = Collector(name='model_inputs', on_error=lambda e: logging.info("ex:{}".format(e)))

  3. In Ihrer run()-Funktion können Sie mit der collect()-Funktion DataFrames vor und nach der Bewertung protokollieren. context wird vom ersten Aufruf von collect() zurückgegeben und enthält Informationen zur späteren Korrelation der Modellein- und -ausgaben.

    context = inputs_collector.collect(data) 
result = model.predict(data)
outputs_collector.collect(result, context)

    Hinweis

    Derzeit protokolliert die collect()-API nur Pandas DataFrames. Wenn die Daten bei der Übergabe an collect() nicht in einem DataFrame enthalten sind, werden sie nicht im Speicher protokolliert, und es wird ein Fehler gemeldet.

Der folgende Code ist ein Beispiel für ein vollständiges Bewertungsskript (score.py), das das Python SDK zur benutzerdefinierten Protokollierung nutzt.

import pandas as pd
import json
from azureml.ai.monitoring import Collector

def init():
  global inputs_collector, outputs_collector, inputs_outputs_collector

  # instantiate collectors with appropriate names, make sure align with deployment spec
  inputs_collector = Collector(name='model_inputs')                    
  outputs_collector = Collector(name='model_outputs')

def run(data): 
  # json data: { "data" : {  "col1": [1,2,3], "col2": [2,3,4] } }
  pdf_data = preprocess(json.loads(data))
  
  # tabular data: {  "col1": [1,2,3], "col2": [2,3,4] }
  input_df = pd.DataFrame(pdf_data)

  # collect inputs data, store correlation_context
  context = inputs_collector.collect(input_df)

  # perform scoring with pandas Dataframe, return value is also pandas Dataframe
  output_df = predict(input_df) 

  # collect outputs data, pass in correlation_context so inputs and outputs data can be correlated later
  outputs_collector.collect(output_df, context)
  
  return output_df.to_dict()
  
def preprocess(json_data):
  # preprocess the payload to ensure it can be converted to pandas DataFrame
  return json_data["data"]

def predict(input_df):
  # process input and return with outputs
  ...
  
  return output_df

Aktualisieren Ihres Bewertungsskripts zum Protokollieren benutzerdefinierter eindeutiger IDs

Zusätzlich zur Protokollierung von Pandas DataFrames direkt in Ihrem Bewertungsskript können Sie Daten mit eindeutigen IDs Ihrer Wahl protokollieren. Diese IDs können von Ihrer Anwendung oder einem externen System stammen, oder Sie können sie generieren. Wenn Sie keine benutzerdefinierte ID angeben, wie in diesem Abschnitt beschrieben, generiert der Datensammler automatisch eine eindeutige correlationid, damit Sie die Eingaben und Ausgaben Ihres Modells später korrelieren können. Wenn Sie eine benutzerdefinierte ID bereitstellen, enthält das Feld correlationid in den protokollierten Daten den Wert Ihrer angegebenen benutzerdefinierten ID.

  1. Führen Sie zunächst die Schritte im vorherigen Abschnitt aus, und importieren Sie dann das azureml.ai.monitoring.context-Paket, indem Sie ihrem Bewertungsskript die folgende Zeile hinzufügen:

    from azureml.ai.monitoring.context import BasicCorrelationContext

  2. Instanziieren Sie in Ihrem Bewertungsskript ein BasicCorrelationContext-Objekt, und übergeben Sie das id-Objekt, das Sie für diese Zeile protokollieren möchten. Diese id sollte eine eindeutige ID aus Ihrem System sein, damit Sie jede protokollierte Zeile aus Ihrer Blob Storage-Instanz eindeutig identifizieren können. Übergeben Sie dieses Objekt als Parameter an Ihren collect()-API-Aufruf:

      # create a context with a custom unique id
  artificial_context = BasicCorrelationContext(id='test')

  # collect inputs data, store correlation_context
  context = inputs_collector.collect(input_df, artificial_context)

  3. Stellen Sie sicher, dass Sie den Kontext an Ihr outputs_collector-Objekt übergeben, damit Ihre Modelleingaben und -ausgaben dieselbe eindeutige ID mit ihnen protokolliert haben und sie später problemlos korreliert werden können:

      # collect outputs data, pass in context so inputs and outputs data can be correlated later
  outputs_collector.collect(output_df, context)

Der folgende Code ist ein Beispiel für ein vollständiges Bewertungsskript (score.py), das benutzerdefinierte eindeutige IDs protokolliert.

import pandas as pd
import json
from azureml.ai.monitoring import Collector
from azureml.ai.monitoring.context import BasicCorrelationContext

def init():
  global inputs_collector, outputs_collector, inputs_outputs_collector

  # instantiate collectors with appropriate names, make sure align with deployment spec
  inputs_collector = Collector(name='model_inputs')                    
  outputs_collector = Collector(name='model_outputs')

def run(data): 
  # json data: { "data" : {  "col1": [1,2,3], "col2": [2,3,4] } }
  pdf_data = preprocess(json.loads(data))
  
  # tabular data: {  "col1": [1,2,3], "col2": [2,3,4] }
  input_df = pd.DataFrame(pdf_data)

  # create a context with a custom unique id
  artificial_context = BasicCorrelationContext(id='test')

  # collect inputs data, store correlation_context
  context = inputs_collector.collect(input_df, artificial_context)

  # perform scoring with pandas Dataframe, return value is also pandas Dataframe
  output_df = predict(input_df) 

  # collect outputs data, pass in context so inputs and outputs data can be correlated later
  outputs_collector.collect(output_df, context)
  
  return output_df.to_dict()
  
def preprocess(json_data):
  # preprocess the payload to ensure it can be converted to pandas DataFrame
  return json_data["data"]

def predict(input_df):
  # process input and return with outputs
  ...
  
  return output_df

Sammeln von Daten für die Modellleistungsüberwachung

Wenn Sie Ihre gesammelten Daten für die Modellleistungsüberwachung verwenden möchten, ist es wichtig, dass jede protokollierte Zeile über eine eindeutige correlationid verfügt, die verwendet werden kann, um die Daten mit Ground-Truth-Daten zu korrelieren, wenn diese Daten verfügbar werden. Der Datensammler generiert automatisch eine eindeutige correlationid für jede protokollierte Zeile und schließt diese automatisch generierte ID in das Feld correlationid im JSON-Objekt ein. Weitere Informationen zum JSON-Schema finden Sie unter Speichern gesammelter Daten in Blob Storage.

Wenn Sie Ihre eigene eindeutige ID für die Protokollierung mit Ihren Produktionsdaten verwenden möchten, empfiehlt es sich, diese ID als separate Spalte in Ihrem Pandas DataFrame zu protokollieren, da der Datensammler eine Batchverarbeitung von Anforderungen durchführt, die sich in unmittelbarer Nähe zueinander befinden. Durch die Protokollierung der correlationid als separate Spalte ist sie für die Integration mit Ground-Truth-Daten nachgeschaltet unmittelbar verfügbar.

Aktualisieren der Abhängigkeiten

Ehe Sie Ihre Bereitstellung mit dem aktualisierten Bewertungsskript erstellen können, müssen Sie Ihre Umgebung anhand des Basisimages mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04 und der entsprechenden conda-Abhängigkeiten erstellen. Anschließend können Sie die Umgebung anhand der Spezifikation in der folgenden YAML-Datei erstellen.

channels:
  - conda-forge
dependencies:
  - python=3.8
  - pip=22.3.1
  - pip:
      - azureml-defaults==1.38.0
      - azureml-ai-monitoring~=0.1.0b1
name: model-env

Aktualisieren der YAML-Datei für die Bereitstellung

Als Nächstes erstellen Sie die YAML-Datei für die Bereitstellung. Um die YAML-Bereitstellung zu erstellen, schließen Sie das data_collector-Attribut ein und aktivieren die Datensammlung für die Collector-Objekte, model_inputs und model_outputs, die Sie zuvor über das Python SDK für benutzerdefinierte Protokollierung instanziiert haben:

data_collector:
  collections:
    model_inputs:
      enabled: 'True'
    model_outputs:
      enabled: 'True'

Der folgende Code ist ein Beispiel einer umfassenden YAML-Datei für die Bereitstellung verwalteter Onlineendpunkte. Sie müssen die YAML-Datei für die Bereitstellung an Ihr Szenario anpassen. Beispiele zum Formatieren Ihrer YAML-Bereitstellungsdatei zum Protokollieren von Rückschlussdaten finden Sie unter Beispiele für Azure-Modelldatensammler.

$schema: https://azuremlschemas.azureedge.net/latest/managedOnlineDeployment.schema.json
name: blue
endpoint_name: my_endpoint
model: azureml:iris_mlflow_model@latest
environment:
  image: mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04
  conda_file: model/conda.yaml
code_configuration:
  code: scripts
  scoring_script: score.py
instance_type: Standard_F2s_v2
instance_count: 1
data_collector:
  collections:
    model_inputs:
      enabled: 'True'
    model_outputs:
      enabled: 'True'

Optional können Sie die folgenden zusätzlichen Parameter für data_collector anpassen:

  • data_collector.rolling_rate: die Rate zum Partitionieren der Daten im Speicher. Wählen Sie aus den Werten aus: Minute, Hour, Day, Month oder Year.
  • data_collector.sampling_rate: der als Dezimalrate dargestellte Prozentsatz zu sammelnder Daten. Beispielsweise steht der Wert 1.0 für das Sammeln von 100 % der Daten.
  • data_collector.collections.<collection_name>.data.name: der Name der Datenressource, die mit den gesammelten Daten registriert werden soll.
  • data_collector.collections.<collection_name>.data.path: der vollständige Azure Machine Learning-Datenspeicherpfad, in dem die gesammelten Daten als Datenressource registriert werden sollen.
  • data_collector.collections.<collection_name>.data.version: die Version der Datenressource, die mit den gesammelten Daten in Blob Storage registriert werden soll.

Daten in einem benutzerdefinierten Blob-Speichercontainer sammeln

Sie können den Datensammler verwenden, um Ihre Produktionsinferenzdaten in einem benutzerdefinierten Blob-Speichercontainer zu sammeln.

  1. Verbinden Sie den Speichercontainer mit einem Azure Machine Learning-Datenspeicher. Weitere Informationen zum Verbinden des Speichercontainers mit dem Azure Machine Learning-Datenspeicher finden Sie unter Erstellen von Datenspeichern.

  2. Überprüfen Sie, ob Ihr Azure Machine Learning-Endpunkt über die erforderlichen Berechtigungen verfügt, um auf den Ziel-Datenspeicher zu schreiben.

    Der Datensammler unterstützt sowohl vom System zugewiesene verwaltete Identitäten (SAMIs) als auch vom Benutzer zugewiesene verwaltete Identitäten (UAMIs). Fügen Sie die Identität zu Ihrem Endpunkt hinzu. Weisen Sie dieser Identität die Rolle Storage Blob Data Contributor mit dem Blob-Speichercontainer zu, der als Datenziel verwendet werden soll. Wie Sie verwaltete Identitäten in Azure verwenden können, erfahren Sie unter Zuweisen von Azure-Rollen zu einer verwalteten Identität.

  3. Aktualisieren Sie Ihre Bereitstellungs-YAML, um die Eigenschaft data in jede Sammlung aufzunehmen.

    • Der erforderliche Parameter data.name gibt den Namen der Datenressource an, die mit den gesammelten Daten registriert werden soll.
    • Der erforderliche Parameter data.path gibt den vollständigen Pfad zum Azure Machine Learning-Datenspeicher an, der mit Ihrem Azure Blob-Speichercontainer verbunden ist.
    • Der optionale Parameter data.version gibt die Version der Ressource an (Standardwert ist 1).

    Die folgende YAML-Konfiguration zeigt ein Beispiel für die Einbeziehung der data-Eigenschaft in jede Sammlung.

    data_collector:
  collections:
    model_inputs:
      enabled: 'True'
      data: 
        name: my_model_inputs_data_asset
        path: azureml://datastores/workspaceblobstore/paths/modelDataCollector/my_endpoint/blue/model_inputs
        version: 1
    model_outputs:
      enabled: 'True'
      data: 
        name: my_model_outputs_data_asset
        path: azureml://datastores/workspaceblobstore/paths/modelDataCollector/my_endpoint/blue/model_outputs 
        version: 1

    Hinweis

    Sie können den Parameter data.path auch verwenden, um auf Datenspeicher in verschiedenen Azure-Abonnements zu verweisen, indem Sie einen Pfad bereitstellen, der diesem Format folgt: azureml://subscriptions/<sub_id>/resourcegroups/<rg_name>/workspaces/<ws_name>/datastores/<datastore_name>/paths/<path>

Erstellen Ihrer Bereitstellung mit Datensammlung

Stellen Sie das Modell mit aktivierter benutzerdefinierter Protokollierung bereit:

$ az ml online-deployment create -f deployment.YAML

Weitere Informationen zum Formatieren der YAML-Datei für die Bereitstellung zur Datensammlung mit Kubernetes-Onlineendpunkten finden Sie unter YAML-Schema für Azure Arc-fähige Kubernetes-Onlinebereitstellung für die CLI (v2).

Weitere Informationen zum Formatieren der YAML-Datei für die Bereitstellung zur Datensammlung mit verwalteten Onlineendpunkten finden Sie unter YAML-Schema für die verwaltete Onlinebereitstellung der CLI (v2).

Ausführen der Nutzlastprotokollierung

Zusätzlich zur benutzerdefinierten Protokollierung mit dem bereitgestellten Python SDK können Sie HTTP-Nutzdaten von Anforderungen und Antworten direkt sammeln, ohne Ihr Bewertungsskript (score.py) erweitern zu müssen.

  1. Verwenden Sie zum Aktivieren der Nutzdatenprotokollierung in Ihrer YAML-Datei für die Bereitstellung die Namen request und response:

    $schema: http://azureml/sdk-2-0/OnlineDeployment.json

endpoint_name: my_endpoint 
name: blue 
model: azureml:my-model-m1:1 
environment: azureml:env-m1:1 
data_collector:
   collections:
       request:
           enabled: 'True'
       response:
           enabled: 'True'

  2. Stellen Sie das Modell mit aktivierter Nutzdatenprotokollierung bereit:

    $ az ml online-deployment create -f deployment.YAML

Bei der Nutzdatenprotokollierung ist nicht garantiert, dass die gesammelten Daten im Tabellenformat vorliegen. Wenn Sie gesammelte Nutzdaten im Rahmen der Modellüberwachung verwenden möchten, müssen Sie daher eine Vorverarbeitungskomponente bereitstellen, um die Daten in Tabellenform zu bringen. Wenn Sie an einer nahtlosen Modellüberwachung interessiert sind, empfiehlt sich das Python SDK für benutzerdefinierte Protokollierung.

Sobald Ihre Bereitstellung genutzt wird, fließen die gesammelten Daten in den Blob Storage Ihres Arbeitsbereichs. Der folgende JSON-Code ist ein Beispiel für gesammelten Code einer HTTP-Anforderung:

{"specversion":"1.0",
"id":"19790b87-a63c-4295-9a67-febb2d8fbce0",
"source":"/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/mire2etesting/providers/Microsoft.MachineLearningServices/workspaces/mirmasterenvws/onlineEndpoints/localdev-endpoint/deployments/localdev",
"type":"azureml.inference.request",
"datacontenttype":"application/json",
"time":"2022-05-25T08:59:48Z",
"data":{"data": [  [1,2,3,4,5,6,7,8,9,10], [10,9,8,7,6,5,4,3,2,1]]},
"path":"/score",
"method":"POST",
"contentrange":"bytes 0-59/*",
"correlationid":"aaaa0000-bb11-2222-33cc-444444dddddd","xrequestid":"aaaa0000-bb11-2222-33cc-444444dddddd"}

Und der folgende JSON-Code ist ein weiteres Beispiel für gesammelten Code einer HTTP-Antwort:

{"specversion":"1.0",
"id":"bbd80e51-8855-455f-a719-970023f41e7d",
"source":"/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/mire2etesting/providers/Microsoft.MachineLearningServices/workspaces/mirmasterenvws/onlineEndpoints/localdev-endpoint/deployments/localdev",
"type":"azureml.inference.response",
"datacontenttype":"application/json",
"time":"2022-05-25T08:59:48Z",
"data":[11055.977245525679, 4503.079536107787],
"contentrange":"bytes 0-38/39",
"correlationid":"aaaa0000-bb11-2222-33cc-444444dddddd","xrequestid":"aaaa0000-bb11-2222-33cc-444444dddddd"}

Speichern gesammelter Daten in Blob Storage

Mit der Datensammlung können Sie Produktionsrückschlussdaten auf ein Blob Storage-Ziel Ihrer Wahl protokollieren. Die Datenzieleinstellungen können auf collection_name-Ebene konfiguriert werden.

Blob Storage-Ausgabe/-Format:

  • Standardmäßig werden die gesammelten Daten im Blob Storage Ihres Arbeitsbereichs im folgenden Pfad gespeichert: azureml://datastores/workspaceblobstore/paths/modelDataCollector.

  • Der letzte Pfad im Blob wird mit {endpoint_name}/{deployment_name}/{collection_name}/{yyyy}/{MM}/{dd}/{HH}/{instance_id}.jsonl angefügt.

  • Jede Zeile in der Datei ist ein JSON-Objekt, das eine einzelne protokollierte Rückschlussanforderung/-antwort darstellt.

Hinweis

collection_name bezieht sich auf den Namen der Datensammlung (z. B. model_inputs oder model_outputs). instance_id ist eine eindeutige ID, die die Gruppierung der protokollierten Daten bestimmt.

Die gesammelten Daten folgen dem folgenden JSON-Schema. Die gesammelten Daten sind über den Schlüssel data verfügbar, und zusätzliche Metadaten werden bereitgestellt.

{"specversion":"1.0",
"id":"725aa8af-0834-415c-aaf5-c76d0c08f694",
"source":"/subscriptions/bbbb1b1b-cc2c-dd3d-ee4e-ffffff5f5f5f/resourceGroups/mire2etesting/providers/Microsoft.MachineLearningServices/workspaces/mirmasterws/onlineEndpoints/localdev-endpoint/deployments/localdev",
"type":"azureml.inference.inputs",
"datacontenttype":"application/json",
"time":"2022-12-01T08:51:30Z",
"data":[{"label":"DRUG","pattern":"aspirin"},{"label":"DRUG","pattern":"trazodone"},{"label":"DRUG","pattern":"citalopram"}],
"correlationid":"bbbb1111-cc22-3333-44dd-555555eeeeee","xrequestid":"bbbb1111-cc22-3333-44dd-555555eeeeee",
"modelversion":"default",
"collectdatatype":"pandas.core.frame.DataFrame",
"agent":"monitoring-sdk/0.1.2",
"contentrange":"bytes 0-116/117"}

Tipp

Zeilenumbrüche werden nur zur besseren Lesbarkeit gezeigt. In Ihren gesammelten JSONL-Dateien gibt es keine Zeilenumbrüche.

Speichern umfangreicher Nutzdaten

Wenn die Nutzdaten Ihrer Daten umfangreicher als 4 MB sind, gibt es in im Pfad {endpoint_name}/{deployment_name}/request/.../{instance_id}.jsonl der Datei {instance_id}.jsonl ein Ereignis, das auf einen Rohdateipfad verweist, der den folgenden Pfad aufweisen sollte: blob_url/{blob_container}/{blob_path}/{endpoint_name}/{deployment_name}/{rolled_time}/{instance_id}.jsonl. Die gesammelten Daten sind in diesem Pfad zu finden.

Speichern von Binärdaten

Bei gesammelten Binärdaten sehen wir die Rohdatei direkt mit instance_id als Dateinamen ein. Binärdaten werden im selben Ordner wie der Pfad der Anforderungsquellgruppe auf rolling_rate basierend abgelegt. Das folgende Beispiel zeigt den Pfad im Datenfeld. Das Format ist JSON, und Zeilenumbrüche werden nur zur besseren Lesbarkeit gezeigt:

{
"specversion":"1.0",
"id":"ba993308-f630-4fe2-833f-481b2e4d169a",
"source":"/subscriptions//resourceGroups//providers/Microsoft.MachineLearningServices/workspaces/ws/onlineEndpoints/ep/deployments/dp",
"type":"azureml.inference.request",
"datacontenttype":"text/plain",
"time":"2022-02-28T08:41:07Z",
"data":"https://masterws0373607518.blob.core.windows.net/modeldata/mdc/%5Byear%5D%5Bmonth%5D%5Bday%5D-%5Bhour%5D_%5Bminute%5D/ba993308-f630-4fe2-833f-481b2e4d169a",
"path":"/score?size=1",
"method":"POST",
"contentrange":"bytes 0-80770/80771",
"datainblob":"true"
}

Batchverarbeitung für Datensammler

Wenn Anforderungen nacheinander innerhalb kurzer Zeitintervalle gesendet werden, stapelt der Datensammler sie zusammen in dasselbe JSON-Objekt. Wenn Sie z. B. ein Skript ausführen, um Beispieldaten an Ihren Endpunkt zu senden und die Bereitstellung die Datensammlung aktiviert hat, können einige der Anforderungen abhängig vom Zeitintervall zwischen diesen in einem Batch zusammengefasst werden. Wenn Sie die Datensammlung mit der Azure Machine Learning-Modellüberwachung verwenden, verarbeitet der Modellüberwachungsdienst jede Anforderung unabhängig. Wenn Sie jedoch erwarten, dass jede protokollierte Datenzeile über eine eigene eindeutige correlationid verfügt, können Sie die correlationid als Spalte in den Pandas DataFrame einschließen, den Sie mit dem Datensammler protokollieren. Weitere Informationen dazu, wie Sie Ihre eindeutige correlationid als Spalte in den Pandas DataFrame einschließen können, finden Sie unter Sammeln von Daten zur Modellleistungsüberwachung.

Nachfolgend sehen Sie ein Beispiel für zwei protokollierte Anforderungen, die in einem Batch zusammengefasst werden:

{"specversion":"1.0",
"id":"720b8867-54a2-4876-80eb-1fd6a8975770",
"source":"/subscriptions/cccc2c2c-dd3d-ee4e-ff5f-aaaaaa6a6a6a/resourceGroups/rg-bozhlinmomoignite/providers/Microsoft.MachineLearningServices/workspaces/momo-demo-ws/onlineEndpoints/credit-default-mdc-testing-4/deployments/main2",
"type":"azureml.inference.model_inputs",
"datacontenttype":"application/json",
"time":"2024-03-05T18:16:25Z",
"data":[{"LIMIT_BAL":502970,"AGE":54,"BILL_AMT1":308068,"BILL_AMT2":381402,"BILL_AMT3":442625,"BILL_AMT4":320399,"BILL_AMT5":322616,"BILL_AMT6":397534,"PAY_AMT1":17987,"PAY_AMT2":78764,"PAY_AMT3":26067,"PAY_AMT4":24102,"PAY_AMT5":-1155,"PAY_AMT6":2154,"SEX":2,"EDUCATION":2,"MARRIAGE":2,"PAY_0":0,"PAY_2":0,"PAY_3":0,"PAY_4":0,"PAY_5":0,"PAY_6":0},{"LIMIT_BAL":293458,"AGE":35,"BILL_AMT1":74131,"BILL_AMT2":-71014,"BILL_AMT3":59284,"BILL_AMT4":98926,"BILL_AMT5":110,"BILL_AMT6":1033,"PAY_AMT1":-3926,"PAY_AMT2":-12729,"PAY_AMT3":17405,"PAY_AMT4":25110,"PAY_AMT5":7051,"PAY_AMT6":1623,"SEX":1,"EDUCATION":3,"MARRIAGE":2,"PAY_0":-2,"PAY_2":-2,"PAY_3":-2,"PAY_4":-2,"PAY_5":-1,"PAY_6":-1}],
"contentrange":"bytes 0-6794/6795",
"correlationid":"test",
"xrequestid":"test",
"modelversion":"default",
"collectdatatype":"pandas.core.frame.DataFrame",
"agent":"azureml-ai-monitoring/0.1.0b4"}

Anzeigen der Daten auf der Benutzeroberfläche von Studio

So zeigen Sie die gesammelten Daten in Blob Storage auf der Benutzeroberfläche von Studio an:

  1. Navigieren Sie in Ihrem Azure Machine Learning-Arbeitsbereich zur Registerkarte Daten:

    Screenshot mit Hervorhebung der Seite „Daten“ im Azure Machine Learning-Arbeitsbereich

  2. Navigieren Sie zu Datenspeicher, und wählen Sie workspaceblobstore (Standard) aus:

    Screenshot mit Hervorhebung der Seite „Datenspeicher“ im Azure ML-Arbeitsbereich

  3. Zeigen Sie im Menü Durchsuchen die gesammelten Produktionsdaten an:

    Screenshot mit Hervorhebung der Struktur der Daten im Datenspeicher

Sammeln von Daten für MLflow-Modelle

Wenn Sie ein MLflow-Modell für einen Azure Machine Learning-Onlineendpunkt bereitstellen, können Sie die Sammlung von Produktionsrückschlussdaten über eine einzelne Umschaltung auf der Benutzeroberfläche von Studio aktivieren. Wenn die Datensammlung eingeschaltet ist, instrumentiert Azure Machine Learning Ihr Bewertungsskript automatisch mit benutzerdefiniertem Protokollierungscode, um sicherzustellen, dass die Produktionsdaten im Blob Storage Ihres Arbeitsbereichs protokolliert werden. Ihre Modellmonitore können die Daten dann verwenden, um die Leistung Ihres MLflow-Modells in der Produktion zu überwachen.

Während Sie die Bereitstellung Ihres Modells konfigurieren, können Sie die Sammlung von Produktionsdaten aktivieren. Wählen Sie auf der Registerkarte Bereitstellung die Option Aktiviert für Datensammlung.

Nachdem Sie die Datensammlung aktiviert haben, werden Produktionsrückschlussdaten im Blob Storage Ihres Azure Machine Learning-Arbeitsbereichs protokolliert, und zwei Datenressourcen werden mit den Namen <endpoint_name>-<deployment_name>-model_inputs und <endpoint_name>-<deployment_name>-model_outputs erstellt. Diese Datenressourcen werden in Echtzeit aktualisiert, während Sie Ihre Bereitstellung in der Produktion verwenden. Ihre Modellmonitore können die Datenressourcen dann verwenden, um die Leistung Ihres Modells in der Produktion zu überwachen.

Zugehöriger Inhalt