Compartilhar via

Coletar dados de produção de modelos implantados para inferência em tempo real

  • Artigo

APLICA-SE A:Extensão de ML da CLI do Azure v2 (atual)SDK do Python azure-ai-ml v2 (atual)

Neste artigo, você aprenderá a usar o Coletor de Dados do Azure Machine Learning para coletar dados de inferência de produção de um modelo implantado em um ponto de extremidade online gerenciado pelo Azure Machine Learning ou em um ponto de extremidade online do Kubernetes.

Você pode habilitar a coleta de dados para implantações de ponto de extremidade online novas ou existentes. O coletor de dados do Azure Machine Learning registra os dados de inferência no Armazenamento de Blobs do Azure. Os dados coletados com o SDK do Python são registrados automaticamente como um ativo de dados no seu workspace do Azure Machine Learning. Esse ativo de dados pode ser usado para monitoramento de modelo.

Se você estiver interessado em coletar dados de inferência de produção para um modelo do MLflow implantado em um ponto de extremidade em tempo real, consulte Coleta de dados para modelos do MLflow.

Pré-requisitos

Antes de seguir as etapas neste artigo, verifique se você tem os seguintes pré-requisitos:

  • O RBAC do Azure (controle de acesso baseado em função) do Azure é usado para permitir acesso a operações no Azure Machine Learning. Para executar as etapas neste artigo, sua conta de usuário deve receber a função de proprietário ou colaborador para o espaço de trabalho do Azure Machine Learning ou uma função personalizada que permita Microsoft.MachineLearningServices/workspaces/onlineEndpoints/*. Para obter mais informações, consulte Gerenciar acesso a um workspace do Azure Machine Learning.

Executar registro em log personalizado para monitoramento de modelo

A coleta de dados com log personalizado permite que você registre dataFrames do Pandas diretamente do script de pontuação antes, durante e depois de quaisquer transformações de dados. Com o registro personalizado, os dados tabulares são registrados em tempo real no Armazenamento de Blobs do seu espaço de trabalho ou em um contêiner de armazenamento de blobs personalizado. Seus monitores de modelo podem consumir os dados do armazenamento.

Atualizar seu script de pontuação com código de log personalizado

Para começar, adicione o código de registro em log personalizado ao seu script de pontuação (score.py). Para o registro em log personalizado, é necessário o pacote azureml-ai-monitoring. Para obter mais informações sobre esse pacote, consulte a página abrangente PyPI para o SDK do coletor de dados.

  1. Importe o azureml-ai-monitoring pacote adicionando a seguinte linha à parte superior do script de pontuação:

    from azureml.ai.monitoring import Collector

  2. Declare suas variáveis de coleta de dados (até cinco delas) em sua init() função:

    Observação

    Se você usar os nomes model_inputs e model_outputs para os seus objetos Collector, o sistema de monitoramento de modelos reconhecerá automaticamente os ativos de dados registrados automaticamente para proporcionar uma experiência de monitoramento de modelos mais integrada.

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

    Por padrão, o Azure Machine Learning gerará uma exceção se houver uma falha durante a coleta de dados. Opcionalmente, você pode usar o on_error parâmetro para especificar uma função a ser executada se ocorrer falha no registro em log. Por exemplo, usando o on_error parâmetro no código a seguir, o Azure Machine Learning registra o erro em vez de gerar uma exceção:

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

  3. Em sua run() função, use a collect() função para registrar dataframes antes e depois da pontuação. O context é retornado da primeira chamada para collect()e contém informações para correlacionar as entradas do modelo e as saídas do modelo posteriormente.

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

    Observação

    Atualmente, a API collect() registra apenas os DataFrames do pandas. Se os dados não estiverem em um DataFrame quando passados para collect(), eles não serão registrados no armazenamento e um erro será relatado.

O código a seguir é um exemplo de um script de pontuação completa (score.py) que usa o SDK do Python de log personalizado.

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

Atualizar seu script de pontuação para registrar IDs exclusivas personalizadas

Além de registrar os DataFrames do Pandas diretamente no script de pontuação, você pode registrar dados com IDs exclusivas de sua escolha. Essas IDs podem vir do aplicativo, de um sistema externo ou você pode gerá-las. Se você não fornecer uma ID personalizada, conforme detalhado nesta seção, o coletor de dados gerará automaticamente uma correlationid exclusiva para ajudá-lo a correlacionar as entradas e saídas do modelo posteriormente. Se você fornecer uma ID personalizada, o campo correlationid, nos dados registrados, conterá o valor da ID personalizada fornecida.

  1. Primeiro, conclua as etapas na seção anterior e importe o pacote azureml.ai.monitoring.context adicionando a seguinte linha ao script de pontuação:

    from azureml.ai.monitoring.context import BasicCorrelationContext

  2. No script de pontuação, instancie um objeto BasicCorrelationContext e passe o id que deseja registrar para essa linha. Recomendamos que esse id seja uma ID exclusiva do seu sistema, para que você possa identificar exclusivamente cada linha registrada no armazenamento de blobs. Passe esse objeto para sua chamada à API de collect() como um parâmetro:

      # 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. Certifique-se de passar o contexto para outputs_collector, de modo que as entradas e saídas do modelo tenham a mesma ID exclusiva registrada com elas e possam ser facilmente correlacionadas posteriormente:

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

O código a seguir é um exemplo de um script de pontuação completa (score.py) que registra IDs exclusivas personalizadas.

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

Coletar dados para monitoramento de desempenho do modelo

Se quiser usar os dados coletados para monitoramento de desempenho de modelo, é importante que cada linha registrada tenha um correlationid exclusivo que possa ser usado para correlacionar os dados com dados de verdade de campo quando esses dados estiverem disponíveis. O coletor de dados gerará automaticamente um correlationid exclusivo para cada linha registrada e incluirá essa ID gerada automaticamente no campo correlationid do objeto JSON. Para obter mais informações sobre o esquema JSON, consulte armazenar dados coletados no armazenamento de blobs.

Se quiser usar sua própria ID exclusiva para fazer logon com seus dados de produção, recomendamos que você registre essa ID como uma coluna separada no DataFrame do Pandas, já que o coletor de dados agrupa solicitações que estão próximas umas das outras. Ao registrar o correlationid como uma coluna separada, ele estará prontamente disponível a jusante para integração com dados de verdade de campo.

Atualizar suas dependências

Antes de criar sua implantação com o script de pontuação atualizado, você precisa criar seu ambiente com a imagem de base mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04 e as dependências apropriadas do conda. Depois disso, você poderá criar o ambiente usando a especificação no YAML a seguir.

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

Atualizar a implantação YAML

Em seguida, crie o YAML de implantação. Para criar o YAML de implantação, inclua o atributo data_collector e ative a coleta de dados para os objetos Collector, model_inputs e model_outputs, que você instanciou anteriormente por meio do SDK do Python de registro em log personalizado:

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

O código a seguir é um exemplo de um YAML de implantação abrangente para uma implantação de ponto de extremidade online gerenciado. Você deve atualizar o YAML de implantação de acordo com seu cenário. Para obter mais exemplos sobre como formatar o YAML de implantação para o registro em log de dados de inferência, confira Exemplos do coletor de dados de modelo do 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'

Opcionalmente, você pode ajustar os seguintes parâmetros extras para seu data_collector:

  • data_collector.rolling_rate: a taxa para particionar os dados no armazenamento. Escolha entre os valores: Minute, Hour, Day, Month ou Year.
  • data_collector.sampling_rate: o percentual, representado como uma taxa decimal, dos dados a serem coletados. Por exemplo, um valor de 1.0 representa a coleta de 100% dos dados.
  • data_collector.collections.<collection_name>.data.name: o nome do ativo de dados a ser registrado com os dados coletados.
  • data_collector.collections.<collection_name>.data.path: o caminho completo do armazenamento de dados do Azure Machine Learning onde os dados coletados devem ser registrados como um ativo de dados.
  • data_collector.collections.<collection_name>.data.version: a versão do ativo de dados a ser registrada com os dados coletados no armazenamento de Blobs.

Coletar dados em um contêiner de armazenamento de blobs personalizado

Você pode usar o coletor de dados para coletar seus dados de inferência de produção em um contêiner de armazenamento de blobs personalizado seguindo estas etapas:

  1. Conecte o contêiner de armazenamento a um armazenamento de dados do Azure Machine Learning. Para obter mais informações sobre como conectar o contêiner de armazenamento ao armazenamento de dados do Azure Machine Learning, confira criar armazenamentos de dados.

  2. Verifique se o ponto de extremidade do Azure Machine Learning tem as permissões necessárias para gravar no destino do armazenamento de dados.

    O coletor de dados dá suporte a SAMIs (identidades gerenciadas atribuídas pelo sistema) e UAMIs (identidades gerenciadas atribuídas pelo usuário). Adicione a identidade ao ponto de extremidade. Atribua a função Storage Blob Data Contributor a essa identidade com o contêiner de Armazenamento de Blobs a ser usado como destino dos dados. Para saber como usar identidades gerenciadas no Azure, confira Atribuir funções do Azure a uma identidade gerenciada.

  3. Atualize seu YAML de implantação para incluir a propriedade data em cada coleção.

    • O parâmetro necessário, data.name, especifica o nome do ativo de dados a ser registrado com os dados coletados.
    • O parâmetro necessário, data.path, especifica o caminho do armazenamento de dados do Azure Machine Learning totalmente formado, que está conectado ao seu contêiner do Armazenamento de Blobs do Azure.
    • O parâmetro opcional, data.version, especifica a versão do ativo de dados (o padrão é 1).

    A configuração do YAML a seguir mostra um exemplo de como incluir a propriedade data em cada coleção.

    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

    Observação

    Você também pode usar o parâmetro data.path para apontar para armazenamentos de dados em diferentes assinaturas do Azure, fornecendo um caminho que siga o formato: azureml://subscriptions/<sub_id>/resourcegroups/<rg_name>/workspaces/<ws_name>/datastores/<datastore_name>/paths/<path>

Criar sua implantação com a coleta de dados

Implante o modelo com o registro em log personalizado habilitado:

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

Para obter mais informações sobre como formatar seu YAML de implantação para coleta de dados com pontos de extremidade online do Kubernetes, consulte o esquema YAML de implantação online da CLI (v2) do Kubernetes habilitado para Azure Arc.

Para obter mais informações sobre como formatar seu YAML de implantação para coleta de dados com pontos de extremidade online gerenciados, consulte Esquema YAML de implantação online gerenciada da CLI (v2).

Executar o registro em log de conteúdo

Além do registro em log personalizado com o SDK do Python fornecido, você pode coletar dados de conteúdo HTTP de solicitação e resposta diretamente sem a necessidade de aumentar o script de pontuação (score.py).

  1. Para habilitar o log de conteúdo, em seu YAML de implantação, use os nomes request e 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. Implante o modelo com o log de carga habilitado:

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

Com o registro em log de conteúdo, não há garantia de que os dados coletados estejam no formato tabular. Portanto, se quiser usar os dados de conteúdo coletados com o monitoramento do modelo, será necessário fornecer um componente de pré-processamento para tornar os dados tabulares. Se você estiver interessado em uma experiência de monitoramento de modelo contínuo, recomendamos usar o SDK do Python de log personalizado.

À medida que sua implantação é usada, os dados coletados fluem para o armazenamento de Blobs do seu espaço de trabalho. O código JSON a seguir é um exemplo de uma solicitação HTTP coletada:

{"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 o código JSON a seguir é outro exemplo de uma resposta HTTP coletada:

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

Armazenar dados coletados no armazenamento de blobs

A coleta de dados permite que você registre dados de inferência de produção em um destino de armazenamento de blobs de sua escolha. As configurações de destino dos dados são configuráveis no nível collection_name.

Saída/formato de armazenamento de Blobs:

  • Por padrão, os dados coletados são armazenados no seguinte caminho em seu espaço de trabalho de Armazenamento de Blobs: azureml://datastores/workspaceblobstore/paths/modelDataCollector.

  • O caminho final no blob será anexado com {endpoint_name}/{deployment_name}/{collection_name}/{yyyy}/{MM}/{dd}/{HH}/{instance_id}.jsonl.

  • Cada linha no arquivo é um objeto JSON que representa uma única solicitação/resposta de inferência que foi registrada.

Observação

collection_name refere-se ao nome da coleta de dados (por exemplo, model_inputs ou model_outputs). instance_id é uma ID exclusiva que identifica o agrupamento de dados que foi registrado.

Os dados coletados seguem o seguinte esquema JSON. Os dados coletados estão disponíveis na data chave e metadados adicionais são fornecidos.

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

Dica

As quebras de linha são mostradas apenas para facilitar a leitura. Nos arquivos .jsonl coletados, não haverá quebras de linha.

Armazenar cargas grandes

Se o conteúdo de seus dados for maior que 4 KB, haverá um evento no arquivo {instance_id}.jsonl contido no caminho {endpoint_name}/{deployment_name}/request/.../{instance_id}.jsonl que aponta para um caminho de arquivo bruto, que deve ter o seguinte caminho: blob_url/{blob_container}/{blob_path}/{endpoint_name}/{deployment_name}/{rolled_time}/{instance_id}.jsonl. Os dados coletados existirão nesse caminho.

Armazenar dados binários

Com os dados binários coletados, mostramos o arquivo bruto diretamente, com o instance_id como o nome do arquivo. Os dados binários são colocados na mesma pasta que o caminho do grupo de origem da solicitação, com base no rolling_rate. O exemplo a seguir reflete o caminho no campo de dados. O formato é json e as quebras de linha são mostradas apenas para legibilidade:

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

Envio em lote do coletor de dados

Se as solicitações forem enviadas em intervalos de tempo curtos entre si, o coletor de dados as agrupará no mesmo objeto JSON. Por exemplo, se você executar um script para enviar dados de exemplo para o ponto de extremidade e a implantação tiver a coleta de dados habilitada, algumas das solicitações poderão ser agrupadas em lote, dependendo do intervalo de tempo entre elas. Se estiver usando a coleta de dados com o monitoramento do modelo do Azure Machine Learning, o serviço de monitoramento de modelo tratará cada solicitação de forma independente. No entanto, se espera que cada linha de dados registrada tenha seu próprio correlationid exclusivo, você poderá incluir o correlationid como uma coluna no DataFrame do Pandas que você está registrando com o coletor de dados. Para obter mais informações sobre como você pode incluir seu correlationid exclusivo como uma coluna no DataFrame do Pandas, consulte Coletar dados para monitoramento de desempenho do modelo.

Aqui está um exemplo de duas solicitações registradas em lote que são agrupadas em lote:

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

Exibir os dados na interface do usuário do estúdio

Para visualizar os dados coletados no Armazenamento de Blobs a partir da interface do usuário do estúdio:

  1. Acesse a guia Dados no workspace do Azure Machine Learning:

    A captura de tela destaca a página de Dados no workspace do Azure Machine Learning

  2. Navegue até Armazenamentos de dados e selecione seu workspaceblobstore (Padrão):

    A captura de tela destaca a página Datastores no workspace do AzureML

  3. Use o menu Procurar para exibir os dados de produção coletados:

    A captura de tela destaca a estrutura em árvore de dados no Datastore

Coleta de dados para modelos do MLflow

Se estiver implantando um modelo do MLflow em um ponto de extremidade online do Azure Machine Learning, você poderá habilitar a coleta de dados de inferência de produção com uma única alternância na interface do usuário do estúdio. Se a coleta de dados estiver ativada, o Azure Machine Learning instrumentará automaticamente seu script de pontuação com o código de registro personalizado para garantir que os dados de produção sejam registrados no Armazenamento de Blobs do seu espaço de trabalho. Seus monitores de modelo podem usar os dados para monitorar o desempenho do seu modelo do MLflow na produção.

Enquanto estiver configurando a implantação do seu modelo, você poderá habilitar a coleta de dados de produção. Na guia Implantação, selecione Habilitado em Coleta de dados.

Depois de habilitar a coleta de dados, os dados de inferência de produção serão registrados no Armazenamento de Blobs do espaço de trabalho do Azure Machine Learning e dois ativos de dados serão criados com os nomes <endpoint_name>-<deployment_name>-model_inputs e <endpoint_name>-<deployment_name>-model_outputs. Esses ativos de dados são atualizados em tempo real à medida que você usa sua implantação em produção. Os monitores do modelo podem usar os ativos de dados para monitorar o desempenho do modelo em produção.

Conteúdo relacionado