Condividi tramite

Raccogliere dati di produzione dai modelli distribuiti per l'inferenza in tempo reale

  • Articolo

SI APPLICA A:Estensione per Machine Learning dell'interfaccia della riga di comando di Azure v2 (corrente)Python SDK azure-ai-ml v2 (corrente)

Questo articolo illustra come usare l'agente di raccolta dati di Azure Machine Learning per raccogliere dati di inferenza di produzione da un modello distribuito in un endpoint online gestito di Azure Machine Learning o in un endpoint online Kubernetes.

È possibile abilitare la raccolta dati per le distribuzioni di endpoint online nuove o esistenti. L'agente di raccolta dati di Azure Machine Learning registra i dati di inferenza in Archiviazione BLOB di Azure. I dati raccolti con Python SDK vengono registrati automaticamente come asset di dati nell'area di lavoro di Azure Machine Learning. Questo asset di dati può essere usato per il monitoraggio del modello.

Se si è interessati a raccogliere dati di inferenza di produzione per un modello MLflow distribuito in un endpoint in tempo reale, vedere Raccolta di dati per i modelli MLflow.

Prerequisiti

Prima di seguire i passaggi descritti in questo articolo, assicurarsi di avere i prerequisiti seguenti:

  • I controlli degli accessi in base al ruolo di Azure vengono usati per concedere l'accesso alle operazioni in Azure Machine Learning. Per eseguire la procedura descritta in questo articolo, all'account utente deve essere assegnato il ruolo di Proprietario o Collaboratore per l'area di lavoro di Azure Machine Learning o a un ruolo personalizzato che consente Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*. Per altre informazioni, vedere Gestire gli accessi a un'area di lavoro di Azure Machine Learning.

Eseguire la registrazione personalizzata per il monitoraggio del modello

La raccolta di dati con registrazione personalizzata consente di registrare i dataframe Pandas direttamente dallo script di assegnazione dei punteggi prima, durante e dopo qualsiasi trasformazione dei dati. Con la registrazione personalizzata, i dati tabulari vengono registrati in tempo reale nella risorsa di Archiviazione BLOB dell'area di lavoro o in un contenitore di Archiviazione BLOB personalizzato. I monitoraggi del modello possono utilizzare i dati dall'archiviazione.

Aggiornare lo script di assegnazione dei punteggi con codice di registrazione personalizzato

Per iniziare, aggiungere codice di registrazione personalizzato allo script di assegnazione dei punteggi (score.py). Per la registrazione personalizzata, è necessario il pacchetto azureml-ai-monitoring. Per altre informazioni su questo pacchetto, vedere la pagina completa PyPI per l'SDK dell'agente di raccolta dati.

  1. Importare il pacchetto azureml-ai-monitoring aggiungendo la riga seguente all'inizio dello script di assegnazione dei punteggi:

    from azureml.ai.monitoring import Collector

  2. Dichiarare le variabili di raccolta dati (fino a cinque) nella funzione init():

    Nota

    Se si usano i nomi model_inputs e model_outputs per gli oggetti Collector, il sistema di monitoraggio del modello riconosce automaticamente gli asset di dati registrati automaticamente per offrire un'esperienza di monitoraggio del modello più semplice.

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

    Per impostazione predefinita, Azure Machine Learning genera un'eccezione in caso di errore durante la raccolta dati. Facoltativamente, è possibile usare il parametro on_error per specificare una funzione da eseguire in caso di errore di registrazione. Ad esempio, usando il parametro on_error nel codice seguente, Azure Machine Learning registra l'errore anziché generare un'eccezione:

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

  3. Nella funzione run() usare la funzione collect() per registrare i dataframe prima e dopo l'assegnazione dei punteggi. context viene restituito dalla prima chiamata a collect() e contiene informazioni per correlare gli input del modello e gli output del modello in un secondo momento.

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

    Nota

    Attualmente l'API collect() registra solo i dataframe Pandas. Se i dati non si trovano in un dataframe quando vengono passati a collect(), non verranno registrati nell'archiviazione e verrà segnalato un errore.

Il codice seguente è un esempio di script di assegnazione dei punteggi completo (score.py) che usa Python SDK per la registrazione personalizzata.

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

Aggiornare lo script di assegnazione dei punteggi per registrare ID univoci personalizzati

Oltre a registrare DataFrame Pandas direttamente all'interno dello script di assegnazione dei punteggi, è possibile registrare dati con ID univoci di propria scelta. Questi ID possono provenire dall'applicazione, da un sistema esterno o possono essere generati. Se non si specifica un ID personalizzato come descritto in questa sezione, l'agente di raccolta dati genererà automaticamente un correlationid univoco che consente di correlare gli input e gli output del modello in un secondo momento. Se si specifica un ID personalizzato, il campo correlationid nei dati registrati conterrà il valore dell'ID personalizzato fornito.

  1. Prima di tutto, completare i passaggi della sezione precedente, quindi importare il pacchetto azureml.ai.monitoring.context aggiungendo la riga seguente allo script di assegnazione dei punteggi:

    from azureml.ai.monitoring.context import BasicCorrelationContext

  2. Nello script di assegnazione dei punteggi, creare un'istanza di un oggetto BasicCorrelationContext e passare il id che si vuole registrare per tale riga. È consigliabile che questo id sia un ID univoco dal sistema, in modo da poter identificare in modo univoco ogni riga registrata dall'archivio BLOB. Passare questo oggetto alla chiamata API collect() come parametro:

      # 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. Assicurarsi di passare il contesto in outputs_collector in modo che gli input e gli output del modello abbiano lo stesso ID univoco registrato con essi e possano essere facilmente correlati in un secondo momento:

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

Il codice seguente è un esempio di script di assegnazione dei punteggi completo (score.py) che registra ID univoci personalizzati.

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

Raccogliere dati per il monitoraggio delle prestazioni del modello

Se si vogliono usare i dati raccolti per il monitoraggio delle prestazioni del modello, è importante che ogni riga registrata abbia un valore correlationid univoco che possa essere usato per correlare i dati con dati ground truth, quando questi ultimi diventano disponibili. L'agente di raccolta dati genererà automaticamente un correlationid univoco per ogni riga registrata e includerà questo ID generato automaticamente nel campo correlationid nell'oggetto JSON. Per altre informazioni sullo schema JSON, vedere Archiviare dati raccolti nell'archivio BLOB.

Se si vuole usare il proprio ID univoco per la registrazione con i dati di produzione, è consigliabile registrare questo ID come una colonna diversa nel DataFrame Pandas, poiché l'agente di raccolta dati raggruppa le richieste in prossimità l'una all'altra. Registrando correlationid come una colonna diversa, questo sarà facilmente disponibile downstream per l'integrazione con i dati ground truth.

Aggiornare le dipendenze

Prima di poter creare la distribuzione con lo script di assegnazione dei punteggi aggiornato, è necessario creare l'ambiente con l'immagine di base mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04 e le dipendenze conda appropriate. Successivamente, è possibile compilare l'ambiente usando la specifica nel codice YAML seguente.

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

Aggiornare il codice YAML della distribuzione.

Si crea quindi il codice YAML della distribuzione. Per creare il codice YAML della distribuzione, includere l'attributo data_collector e abilitare la raccolta dati per gli oggetti Collector, model_inputs e model_outputs, di cui è stata creata un'istanza in precedenza tramite la registrazione personalizzata di Python SDK:

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

Il codice seguente è un esempio di codice YAML della distribuzione completo per una distribuzione di un endpoint online gestito. È consigliabile aggiornare il codice YAML della distribuzione in base allo scenario in uso. Per altri esempi su come formattare il codice YAML della distribuzione per la registrazione dei dati di inferenza, vedere Esempi dell'agente di raccolta dati del modello di Azure.

$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'

Facoltativamente, è possibile modificare i parametri aggiuntivi seguenti per data_collector:

  • data_collector.rolling_rate: indice di partizionamento dei dati nell'archiviazione. Scegliere tra i valori seguenti: Minute, Hour, Day, Month o Year.
  • data_collector.sampling_rate: percentuale, rappresentata come indice decimale, di dati da raccogliere. Ad esempio, un valore di 1.0 rappresenta la raccolta del 100% dei dati.
  • data_collector.collections.<collection_name>.data.name: nome dell'asset di dati da registrare con i dati raccolti.
  • data_collector.collections.<collection_name>.data.path: percorso completo dell'archivio dati di Azure Machine Learning in cui i dati raccolti devono essere registrati come asset di dati.
  • data_collector.collections.<collection_name>.data.version: versione dell'asset di dati da registrare con i dati raccolti nell'Archiviazione BLOB.

Raccogliere dati in un contenitore di Archiviazione BLOB personalizzato

È possibile usare l'agente di raccolta dati per raccogliere i dati di inferenza di produzione in un contenitore di Archiviazione BLOB personalizzato seguendo questa procedura:

  1. Connettere il contenitore di archiviazione a un archivio dati di Azure Machine Learning. Per altre informazioni sulla connessione del contenitore di archiviazione all'archivio dati di Azure Machine Learning, vedere Creare archivi dati.

  2. Verificare che l'endpoint di Azure Machine Learning abbia le autorizzazioni necessarie per scrivere nella destinazione dell'archivio dati.

    L'agente di raccolta dati supporta sia le identità gestite assegnate dal sistema (SAMI) sia le identità gestite assegnate dall'utente (UAMI). Aggiungere l'identità all'endpoint. Assegnare il ruolo Storage Blob Data Contributor a questa identità con il contenitore di Archiviazione BLOB da usare come destinazione dati. Per informazioni su come usare le identità gestite in Azure, vedere Assegnare ruoli di Azure a un'identità gestita.

  3. Aggiornare il codice YAML della distribuzione per includere la proprietà data all'interno di ogni raccolta.

    • Il parametro obbligatorio, data.name, specifica il nome dell'asset di dati da registrare con i dati raccolti.
    • Il parametro obbligatorio, data.path, specifica il percorso completo dell'archivio dati di Azure Machine Learning, connesso al contenitore di Archiviazione BLOB di Azure.
    • Il parametro facoltativo, data.version, specifica la versione dell'asset di dati (il valore predefinito è 1).

    La configurazione YAML seguente illustra un esempio di come includere la proprietà data all'interno di ogni raccolta.

    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

    Nota

    È anche possibile usare il parametro data.path per puntare agli archivi dati in sottoscrizioni di Azure diverse specificando un percorso che segue il formato: azureml://subscriptions/<sub_id>/resourcegroups/<rg_name>/workspaces/<ws_name>/datastores/<datastore_name>/paths/<path>

Creare la distribuzione con la raccolta dati

Distribuire il modello con la registrazione personalizzata abilitata:

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

Per altre informazioni su come formattare il codice YAML della distribuzione per la raccolta di dati con gli endpoint online Kubernetes, vedere lo Schema del codice YAML della distribuzione online per Kubernetes abilitato per Azure Arc per l'interfaccia della riga di comando (v2).

Per altre informazioni su come formattare il codice YAML della distribuzione per la raccolta di dati con gli endpoint online gestiti, vedere lo Schema del codice YAML della distribuzione online gestita per l'interfaccia della riga di comando (v2).

Eseguire la registrazione del payload

Oltre alla registrazione personalizzata con Python SDK fornito, è possibile raccogliere direttamente i dati del payload HTTP di richiesta e risposta senza dover aumentare lo script di assegnazione dei punteggi (score.py).

  1. Per abilitare la registrazione del payload, usare i nomi request e response nel codice YAML della distribuzione:

    $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. Distribuire il modello con la registrazione del payload abilitata:

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

Con la registrazione del payload, non è garantito che i dati raccolti siano in formato tabulare. Se si vogliono usare i dati del payload raccolti con il monitoraggio del modello, sarà pertanto necessario fornire un componente di pre-elaborazione per rendere i dati tabulari. Se si è interessati a un'esperienza di monitoraggio dei modelli senza problemi, è consigliabile usare la registrazione personalizzata di Python SDK.

Quando viene usata la distribuzione, i dati raccolti passano all'Archiviazione BLOB dell'area di lavoro. Il codice JSON seguente è un esempio di richiesta HTTP raccolta:

{"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"}

E il codice JSON seguente è un altro esempio di una risposta HTTP raccolta:

{"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"}

Archiviare i dati raccolti nell'archivio BLOB

La raccolta di dati consente di registrare i dati di inferenza di produzione in una destinazione di archiviazione BLOB di propria scelta. Le impostazioni di destinazione dati sono configurabili a livello di collection_name.

Output/Formato dell'Archiviazione BLOB:

  • Per impostazione predefinita, i dati raccolti vengono archiviati nel percorso seguente nell'Archiviazione BLOB dell'area di lavoro: azureml://datastores/workspaceblobstore/paths/modelDataCollector.

  • Alla fine del percorso finale nel BLOB verrà aggiunto {endpoint_name}/{deployment_name}/{collection_name}/{yyyy}/{MM}/{dd}/{HH}/{instance_id}.jsonl.

  • Ogni riga nel file è un oggetto JSON che rappresenta una singola richiesta/risposta di inferenza registrata.

Nota

collection_name fa riferimento al nome della raccolta dati, ad esempio model_inputs o model_outputs. instance_id è un ID univoco che identifica il raggruppamento dei dati registrati.

I dati raccolti seguono lo schema JSON seguente. I dati raccolti sono disponibili dalla chiave data e vengono forniti metadati aggiuntivi.

{"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"}

Suggerimento

Le interruzioni di riga vengono visualizzate solo per una migliore leggibilità. Nei file con estensione jsonl raccolti non saranno presenti interruzioni di riga.

Archiviare payload di grandi dimensioni

Se il payload dei dati è maggiore di 4 KB, verrà generato un evento nel file {instance_id}.jsonl contenuto nel percorso {endpoint_name}/{deployment_name}/request/.../{instance_id}.jsonl che punta a un percorso di file non elaborato, il quale deve avere il percorso seguente: blob_url/{blob_container}/{blob_path}/{endpoint_name}/{deployment_name}/{rolled_time}/{instance_id}.jsonl. I dati raccolti saranno presenti in questo percorso.

Archiviare dati binari

Con i dati binari raccolti, il file non elaborato viene visualizzato direttamente, con instance_id come nome file. I dati binari vengono inseriti nella stessa cartella del percorso del gruppo di origine della richiesta, in base a rolling_rate. L'esempio seguente riflette il percorso nel campo dati. Il formato è JSON e le interruzioni di riga vengono visualizzate solo per una migliore leggibilità:

{
"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"
}

Invio in batch dell'agente di raccolta dati

Se le richieste vengono inviate a brevi intervalli di tempo l'una dall’altra, l'agente di raccolta dati le raggruppa nello stesso oggetto JSON. Ad esempio, se si esegue uno script per inviare dati di esempio all'endpoint e la distribuzione ha la raccolta dati abilitata, alcune delle richieste potrebbero essere raggruppate in batch, a seconda dell'intervallo di tempo tra di esse. Se si usa la raccolta dati con monitoraggio del modello di Azure Machine Learning, il servizio di monitoraggio del modello gestisce ogni richiesta in modo indipendente. Tuttavia, se si prevede che ogni riga di dati registrata abbia un proprio correlationidunivoco, è possibile includere correlationid come colonna nel DataFrame Pandas che si sta registrando con l'agente di raccolta dati. Per altre informazioni su come includere il correlationid univoco come colonna nel FataFrame Pandas, vedere Raccogliere dati per il monitoraggio delle prestazioni del modello.

Di seguito è riportato un esempio di due richieste raggruppate in batch:

{"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"}

Visualizzare i dati nell'interfaccia utente dello studio

Per visualizzare i dati raccolti nell'Archiviazione BLOB dall'interfaccia utente dello studio:

  1. Passare alla scheda Dati nell'area di lavoro di Azure Machine Learning:

    Screenshot che evidenzia la pagina Dati nell'area di lavoro di Azure Machine Learning

  2. Passare ad Archivi dati e selezionare workspaceblobstore (impostazione predefinita):

    Screenshot che evidenzia la pagina Archivi dati nell'area di lavoro di AzureML

  3. Usare il menu Esplora per visualizzare i dati di produzione raccolti:

    Screenshot che evidenzia la struttura ad albero dei dati nell'archivio dati

Raccogliere dati per i modelli MLflow

Se si distribuisce un modello MLflow in un endpoint online di Azure Machine Learning, è possibile abilitare la raccolta di dati di inferenza di produzione con un singolo interruttore nell'interfaccia utente dello studio. Se la raccolta dei dati viene attivata o disattivata, Azure Machine Learning instrumenta automaticamente lo script di assegnazione dei punteggi con codice di registrazione personalizzato per assicurare che i dati di produzione vengano registrati nell'Archiviazione BLOB dell'area di lavoro. I monitoraggi del modello possono quindi usare i dati per monitorare le prestazioni del modello MLflow nell'ambiente di produzione.

Durante la configurazione della distribuzione del modello, è possibile abilitare la raccolta dati di produzione. Nella scheda Distribuzione, selezionare Abilitata per Raccolta dati.

Dopo aver abilitato la raccolta dati, i dati di inferenza di produzione verranno registrati nell'Archiviazione BLOB dell'area di lavoro di Azure Machine Learning e verranno creati due asset di dati con nomi <endpoint_name>-<deployment_name>-model_inputs e <endpoint_name>-<deployment_name>-model_outputs. Questi asset di dati vengono aggiornati in tempo reale quando si usa la distribuzione nell'ambiente di produzione. I monitoraggi del modello possono quindi usare gli asset di dati per monitorare le prestazioni del modello nell'ambiente di produzione.

Contenuto correlato