Tutorial 3: habilitar a materialização recorrente e executar a inferência em lote

Essa série de tutoriais mostra como os recursos integram perfeitamente todas as fases do ciclo de vida de aprendizado de máquina: prototipagem, treinamento e operacionalização.

O primeiro tutorial mostrou como criar uma especificação de conjunto de recursos com transformações personalizadas e usar esse conjunto de recursos para gerar dados de treinamento, habilitar a materialização e executar um provisionamento. O segundo tutorial mostrou como habilitar a materialização e realizar um backfill. Ele também mostrou como experimentar recursos como uma forma de melhorar o desempenho do modelo.

Este tutorial explica como:

Pré-requisitos

Antes de prosseguir com este tutorial, conclua o primeiro e o segundo tutoriais da série.

Configuração

1. Configure o bloco de anotações Azure Machine Learning Spark.

   Para executar este tutorial, você pode criar um novo notebook e executar as instruções passo a passo. Você também pode abrir e executar o notebook existente chamado 3. Habilite a materialização recorrente e execute a inferência em lote. Você pode localizar esse notebook e todos os notebooks desta série no diretório featurestore_sample/notebooks. Você pode escolher sdk_only or sdk_and_cli. Mantenha este tutorial aberto e consulte-o para obter links de documentação e mais explicações.

   1. Na lista suspensa Computação na navegação superior, selecione Computação Spark Sem Servidor em Spark Sem Servidor do Azure Machine Learning.

   2. Configure a sessão:

      1. Selecione Configurar sessão na barra de status superior.
      2. Selecione a guia Pacotes do Python.
      3. Selecione Carregar o arquivo conda.
      4. Selecione o arquivo azureml-examples/sdk/python/featurestore-sample/project/env/online.yml do seu computador local.
      5. Opcionalmente, aumente o tempo limite da sessão (tempo ocioso) para evitar reexecuções frequentes de pré-requisito.

2. Inicie a sessão do Spark.

   # run this cell to start the spark session (any code block will start the session ). This can take around 10 mins.
   print("start spark session")

3. Configure o diretório raiz para as amostras.

   import os
   
   # please update the dir to ./Users/<your_user_alias> (or any custom directory you uploaded the samples to).
   # You can find the name from the directory structure in the left nav
   root_dir = "./Users/<your_user_alias>/featurestore_sample"
   
   if os.path.isdir(root_dir):
       print("The folder exists.")
   else:
       print("The folder does not exist. Please create or fix the path")

4. Configurar a CLI.

   • SDK do Python
   • CLI do Azure

   Não aplicável.

5. Inicialize o cliente CRUD (criar, ler, atualizar e excluir) da espaço de trabalho do projeto.

   O bloco de anotações do tutorial é executado a partir deste espaço de trabalho atual.

   ### Initialize the MLClient of this project workspace
   import os
   from azure.ai.ml import MLClient
   from azure.ai.ml.identity import AzureMLOnBehalfOfCredential
   
   project_ws_sub_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
   project_ws_rg = os.environ["AZUREML_ARM_RESOURCEGROUP"]
   project_ws_name = os.environ["AZUREML_ARM_WORKSPACE_NAME"]
   
   # connect to the project workspace
   ws_client = MLClient(
       AzureMLOnBehalfOfCredential(), project_ws_sub_id, project_ws_rg, project_ws_name
   )

6. Inicialize as variáveis do armazenamento de recursos.

   Certifique-se de atualizar o valor featurestore_name, para refletir o que você criou no primeiro tutorial.

   from azure.ai.ml import MLClient
   from azure.ai.ml.identity import AzureMLOnBehalfOfCredential
   
   # feature store
   featurestore_name = (
       "<FEATURESTORE_NAME>"  # use the same name from part #1 of the tutorial
   )
   featurestore_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
   featurestore_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]
   
   # feature store ml client
   fs_client = MLClient(
       AzureMLOnBehalfOfCredential(),
       featurestore_subscription_id,
       featurestore_resource_group_name,
       featurestore_name,
   )

7. Inicialize o cliente SDK da loja de recursos.

   # feature store client
   from azureml.featurestore import FeatureStoreClient
   from azure.ai.ml.identity import AzureMLOnBehalfOfCredential
   
   featurestore = FeatureStoreClient(
       credential=AzureMLOnBehalfOfCredential(),
       subscription_id=featurestore_subscription_id,
       resource_group_name=featurestore_resource_group_name,
       name=featurestore_name,
   )

Habilite a materialização recorrente no conjunto de recursos de transações

No segundo tutorial, você habilitou a materialização e executou o preenchimento no transactions conjunto de recursos. O backfill é uma operação única sob demanda que computa e coloca valores de recursos no repositório de materialização.

Para lidar com a inferência do modelo na produção, você pode querer configurar trabalhos de materialização recorrentes para manter o armazenamento de materialização atualizado. Esses trabalhos são executados em agendas definidas pelo usuário. O agendamento de trabalho recorrente funciona dessa maneira:

• Os valores de intervalo e frequência definem uma janela. Por exemplo, os seguintes valores definem uma janela de três horas:

  • interval = 3
  • frequency = Hour

• A primeira janela começa no valor start_time definido em RecurrenceTrigger, e assim por diante.

• O primeiro trabalho recorrente é enviado no início da próxima janela após o tempo de atualização.

• Os trabalhos recorrentes posteriores são enviados em todas as janelas após o primeiro trabalho.

Conforme explicado em tutoriais anteriores, depois que os dados são materializados (preenchimento ou materialização recorrente), a recuperação de recursos usa os dados materializados por padrão.

from datetime import datetime
from azure.ai.ml.entities import RecurrenceTrigger

transactions_fset_config = fs_client.feature_sets.get(name="transactions", version="1")

# create a schedule that runs the materialization job every 3 hours
transactions_fset_config.materialization_settings.schedule = RecurrenceTrigger(
    interval=3, frequency="Hour", start_time=datetime(2023, 4, 15, 0, 4, 10, 0)
)

fs_poller = fs_client.feature_sets.begin_create_or_update(transactions_fset_config)

print(fs_poller.result())

(Opcional) Salve o arquivo YAML para o ativo do conjunto de recursos

Você usa as configurações atualizadas para salvar o arquivo YAML.

## uncomment and run
# transactions_fset_config.dump(root_dir + "/featurestore/featuresets/transactions/featureset_asset_offline_enabled_with_schedule.yaml")

Execute o pipeline de inferência em lote

A inferência em lote tem estas etapas:

1. Você usa o mesmo componente interno de recuperação de recursos para recuperação de recursos que usou no pipeline de treinamento (abordado no terceiro tutorial). Para treinamento de pipeline, você forneceu uma especificação de recuperação de recursos como uma entrada de componente. Para inferência em lote, você passa o modelo registrado como entrada. O componente procura a especificação de recuperação de recurso no artefato do modelo.

   Além disso, para treinamento, os dados de observação tinham a variável de destino. No entanto, os dados de observação de inferência em lote não têm a variável de destino. A etapa de recuperação de recursos junta os dados de observação com os recursos e gera os dados para inferência em lote.

2. O pipeline usa os dados de entrada de inferência em lote da etapa anterior, executa a inferência no modelo e anexa o valor previsto como saída.

   Observação

   Você usa um trabalho para inferência em lote neste exemplo. Você também pode usar pontos de extremidade em lote no Azure Machine Learning.

   from azure.ai.ml import load_job  # will be used later
   
   # set the batch inference  pipeline path
   batch_inference_pipeline_path = (
       root_dir + "/project/fraud_model/pipelines/batch_inference_pipeline.yaml"
   )
   batch_inference_pipeline_definition = load_job(source=batch_inference_pipeline_path)
   
   # run the training pipeline
   batch_inference_pipeline_job = ws_client.jobs.create_or_update(
       batch_inference_pipeline_definition
   )
   
   # stream the run logs
   ws_client.jobs.stream(batch_inference_pipeline_job.name)

Inspecione os dados de saída para inferência em lote

Na visualização do pipeline:

1. Selecione inference_step no cartão outputs.

2. Copie o valor do campo Data. É algo semelhante a azureml_995abbc2-3171-461e-8214-c3c5d17ede83_output_data_data_with_prediction:1.

3. Cole o valor do campo Data na célula a seguir, com nomes separados e valores de versão. O último caractere é a versão, precedida por dois pontos (:).

4. Note a coluna predict_is_fraud que o pipeline de inferência em lote gerou.

   Nas saídas do pipeline de inferência em lote (/project/fraud_mode/pipelines/batch_inference_pipeline.yaml), como você não forneceu valores name ou version para outputs of inference_step, o sistema criou um ativo de dados não rastreado com um GUID como o valor do nome e 1 como o valor da versão. Nesta célula, você deriva e exibe o caminho de dados do ativo.

   inf_data_output = ws_client.data.get(
       name="azureml_1c106662-aa5e-4354-b5f9-57c1b0fdb3a7_output_data_data_with_prediction",
       version="1",
   )
   inf_output_df = spark.read.parquet(inf_data_output.path + "data/*.parquet")
   display(inf_output_df.head(5))

Limpar

O quinto tutorial da série descreve como excluir os recursos.

Próximas etapas

• Saiba mais sobre conceitos de repositório de recursos e entidades de nível superior no repositório de recursos gerenciados.
• Saiba mais sobre controle de identidade e acesso para armazenamento de recursos gerenciados.
• Veja o guia de solução de problemas para armazenamento de recursos gerenciados.
• Veja a referência YAML.