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

  • Artigo

APLICA-SE A:Azure CLI ml extension v2 (current)Python SDK azure-ai-ml v2 (current)

Neste artigo, você aprenderá a usar o coletor de Dados do Aprendizado de Máquina do Azure para coletar dados de inferência de produção de um modelo implantado em um ponto de extremidade online gerenciado do 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 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 em seu espaço de trabalho do Azure Machine Learning. Esse ativo de dados pode ser usado para monitoramento de modelos.

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

Pré-requisitos

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

  • Os controlos de acesso baseado em funções (RBAC do Azure) são utilizados para conceder acesso às 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 o acesso a um espaço de trabalho do Azure Machine Learning.

Executar log personalizado para monitoramento de modelo

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

Atualize seu script de pontuação com código de registro personalizado

Para começar, adicione um código de registro personalizado ao seu script de pontuação (score.py). Para registro em log personalizado, você precisa do azureml-ai-monitoring pacote. Para obter mais informações sobre este pacote, consulte a página abrangente do 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:

    Nota

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

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

    Por padrão, o Aprendizado de Máquina do Azure gera 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 uma falha de registro. Por exemplo, usando o on_error parâmetro no código a seguir, o Azure Machine Learning registra o erro em vez de lançar 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 e saídas do modelo posteriormente.

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

    Nota

    Atualmente, a collect() API registra apenas pandas DataFrames. Se os dados não estiverem em um DataFrame quando passados para collect()o , 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 log personalizado Python SDK.

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

Atualize seu script de pontuação para registrar IDs exclusivos personalizados

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

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

    from azureml.ai.monitoring.context import BasicCorrelationContext

  2. No script de pontuação, instancie um BasicCorrelationContext objeto e passe a linha que id você deseja registrar. Recomendamos que este id seja um ID exclusivo do seu sistema, para que possa identificar exclusivamente cada linha registada a partir do seu Armazenamento de Blobs. Passe este objeto para sua collect() chamada de API 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 o seu outputs_collector para que as entradas e saídas do seu modelo tenham o mesmo ID exclusivo registrado com eles, e eles possam ser facilmente correlacionados mais tarde:

      # 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 completo (score.py) que registra IDs exclusivos personalizados.

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 você quiser usar os dados coletados para o monitoramento do desempenho do modelo, é importante que cada linha registrada tenha uma linha exclusiva correlationid que possa ser usada para correlacionar os dados com os dados de verdade básica, quando esses dados estiverem disponíveis. O coletor de dados gerará automaticamente um exclusivo correlationid para cada linha registrada e incluirá essa ID gerada automaticamente no correlationid campo no objeto JSON. Para obter mais informações sobre o esquema JSON, consulte armazenar dados coletados no armazenamento de blobs.

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

Atualize suas dependências

Antes de criar sua implantação com o script de pontuação atualizado, você precisa criar seu ambiente com a imagem mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04 base e as dependências conda apropriadas. Depois disso, você pode construir 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

Atualize seu YAML de implantação

Em seguida, crie o YAML de implantação. Para criar o YAML de implantação, inclua o atributo e habilite a data_collector coleta de dados para os Collector objetos model_inputs e model_outputs, que você instanciou anteriormente por meio do SDK Python de 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 seu YAML de implantação para log de dados de inferência, consulte Exemplos de 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 o 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: A percentagem, representada como uma taxa decimal, dos dados a recolher. Por exemplo, um valor de representa a coleta de 1.0 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 registrado com os dados coletados no armazenamento de blobs.

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

Você pode usar o coletor de dados para coletar seus dados de inferência de produção para um contêiner de armazenamento de blob 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, consulte Criar datastores.

  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 suporta identidades gerenciadas atribuídas pelo sistema (SAMIs) e identidades gerenciadas atribuídas pelo usuário (UAMIs). Adicione a identidade ao seu ponto de extremidade. Atribua a Storage Blob Data Contributor função a essa identidade com o contêiner de armazenamento de Blob a ser usado como destino de dados. Para saber como usar identidades gerenciadas no Azure, consulte Atribuir funções do Azure a uma identidade gerenciada.

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

    • O parâmetro required , 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 de armazenamento de dados do Azure Machine Learning totalmente formado, que está conectado ao seu contêiner de Armazenamento de Blob do Azure.
    • O parâmetro opcional , data.version, especifica a versão do ativo de dados (o padrão é 1).

    A configuração YAML a seguir mostra um exemplo de como incluir a data propriedade 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

    Nota

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

Crie sua implantação com coleta de dados

Implante o modelo com o 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 do Kubernetes habilitado para CLI (v2) 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 CLI (v2) managed online deployment YAML schema.

Executar registro de carga útil

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

  1. Para habilitar o registro de carga útil, em sua implantação YAML, 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 registro de carga útil habilitado:

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

Com o registo de carga útil, não é garantido que os dados recolhidos estejam em formato tabular. Portanto, se você quiser usar dados de carga coletados com monitoramento de 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 perfeita, recomendamos usar o SDK Python de registro personalizado.

À medida que sua implantação é usada, os dados coletados fluem para o armazenamento de Blob do 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/d511f82f-71ba-49a4-8233-d7be8a3650f4/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":"f6e806c9-1a9a-446b-baa2-901373162105","xrequestid":"f6e806c9-1a9a-446b-baa2-901373162105"}

E o seguinte código JSON é outro exemplo de uma resposta HTTP coletada:

{"specversion":"1.0",
"id":"bbd80e51-8855-455f-a719-970023f41e7d",
"source":"/subscriptions/d511f82f-71ba-49a4-8233-d7be8a3650f4/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":"f6e806c9-1a9a-446b-baa2-901373162105","xrequestid":"f6e806c9-1a9a-446b-baa2-901373162105"}

Armazene os dados coletados no armazenamento de blob

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

Saída/formato de armazenamento de Blob:

  • Por padrão, os dados coletados são armazenados no seguinte caminho no armazenamento de Blob do espaço de trabalho: 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.

Nota

collection_name refere-se ao nome da recolha de dados (por exemplo, model_inputs ou model_outputs). instance_id é um id exclusivo que identifica o agrupamento de dados que foi registrado.

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

{"specversion":"1.0",
"id":"725aa8af-0834-415c-aaf5-c76d0c08f694",
"source":"/subscriptions/636d700c-4412-48fa-84be-452ac03d34a1/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":"3711655d-b04c-4aa2-a6c4-6a90cbfcb73f","xrequestid":"3711655d-b04c-4aa2-a6c4-6a90cbfcb73f",
"modelversion":"default",
"collectdatatype":"pandas.core.frame.DataFrame",
"agent":"monitoring-sdk/0.1.2",
"contentrange":"bytes 0-116/117"}

Gorjeta

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

Armazene grandes cargas úteis

Se a carga útil dos seus dados for maior que 4 MB, haverá um evento no {instance_id}.jsonl arquivo contido no {endpoint_name}/{deployment_name}/request/.../{instance_id}.jsonl caminho 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 recolhidos existirão neste caminho.

Armazenar dados binários

Com os dados binários coletados, mostramos o arquivo bruto diretamente, com instance_id 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"
}

Lote do coletor de dados

Se as solicitações forem enviadas em intervalos de tempo curtos uma da outra, o coletor de dados as agrupará em lote no mesmo objeto JSON. Por exemplo, se você executar um script para enviar dados de exemplo para seu 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 você estiver usando a coleta de dados com o monitoramento de modelo do Azure Machine Learning, o serviço de monitoramento de modelo lidará com cada solicitação de forma independente. No entanto, se você espera que cada linha de dados registrada tenha seu próprio exclusivo correlationid, você pode incluir a correlationid coluna como um no DataFrame pandas que você está registrando com o coletor de dados. Para obter mais informações sobre como você pode incluir seu exclusivo correlationid como uma coluna no DataFrame pandas, consulte Coletar dados para monitoramento de desempenho do modelo.

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

{"specversion":"1.0",
"id":"720b8867-54a2-4876-80eb-1fd6a8975770",
"source":"/subscriptions/79a1ba0c-35bb-436b-bff2-3074d5ff1f89/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 exibir os dados coletados no Armazenamento de Blob a partir da interface do usuário do estúdio:

  1. Vá para a guia Dados em seu espaço de trabalho do Azure Machine Learning:

    A captura de tela destaca a página Dados no espaço de trabalho do Azure Machine Learning

  2. Navegue até Datastores e selecione seu workspaceblobstore (Padrão):

    A captura de tela destaca a página Datastores no espaço de trabalho AzureML

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

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

Coletar dados para modelos MLflow

Se você estiver implantando um modelo MLflow em um ponto de extremidade online do Azure Machine Learning, 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 Aprendizado de Máquina do Azure instrumentará automaticamente seu script de pontuação com código de log personalizado para garantir que os dados de produção sejam registrados no Armazenamento de Blobs do espaço de trabalho. Os monitores de modelo podem usar os dados para monitorar o desempenho do modelo MLflow em produção.

Ao configurar a implantação do modelo, você pode habilitar a coleta de dados de produção. Na guia Implantação, selecione Habilitado para 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 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 na produção. Os monitores de modelo podem usar os ativos de dados para monitorar o desempenho do modelo em produção.

Conteúdos relacionados