Partilhar via

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

Esta série de tutoriais mostra como os recursos integram perfeitamente todas as fases do ciclo de vida do 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. Em seguida, mostrou como usar esse conjunto de recursos para gerar dados de treinamento, habilitar a materialização e executar um backfill. O segundo tutorial mostrou como habilitar a materialização e realizar um backfill. Também mostrou como experimentar recursos, como forma de melhorar o desempenho do modelo.

Este tutorial explica como:

  • Habilite a materialização recorrente para o transactions conjunto de recursos.
  • Execute um pipeline de inferência em lote no modelo registrado.

Pré-requisitos

Antes de prosseguir com este tutorial, certifique-se de concluir o primeiro e o segundo tutoriais da série.

Configurar

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

    Para executar este tutorial, você pode criar um novo bloco de anotações e executar as instruções, passo a passo. Você também pode abrir e executar o bloco de anotações existente chamado 3. Habilite a materialização recorrente e execute a inferência em lote. Pode encontrar esse bloco de notas e todos os blocos de notas desta série no diretório featurestore_sample/notebooks . Você pode escolher sdk_only ou 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 no painel de navegação superior, selecione Computação sem faísca sem servidor em Azure Machine Learning Spark sem servidor.

    2. Configure a sessão:

      1. Selecione Configurar sessão na barra de status superior.
      2. Selecione a guia Pacotes Python.
      3. Selecione Upload conda file.
      4. Selecione o azureml-examples/sdk/python/featurestore-sample/project/env/online.yml arquivo de sua máquina local.
      5. Opcionalmente, aumente o tempo limite da sessão (tempo ocioso) para evitar repetições frequentes de pré-requisitos.

  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 os exemplos.

    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. Configure a CLI.

    Não aplicável.

  1. Inicialize o cliente CRUD (criar, ler, atualizar e excluir) do 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
)

  2. Inicialize as variáveis do repositório de recursos.

    Para refletir o que você criou no primeiro tutorial, atualize o featurestore_name valor.

    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,
)

  3. Inicialize o cliente SDK do repositório 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,
)

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

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

Para lidar com a inferência do modelo em produção, convém 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 cronograma de trabalho recorrente funciona desta forma:

  • 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 com o start_time valor 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.

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

Como explicado em tutoriais anteriores, depois que os dados são materializados (preenchimento de backfill 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

Use 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")

Executar 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 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 o treinamento, os dados de observação tiveram a variável alvo. No entanto, os dados de observação de inferência em lote não têm a variável alvo. A etapa de recuperação de recursos une os dados de observação com os recursos e produz 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 acrescenta o valor previsto como saída.

    Nota

    Você usa um trabalho para inferência em lote neste exemplo. Você também pode usar pontos de extremidade em lote no Aprendizado de Máquina do Azure.

    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 de pipeline:

  1. Selecione inference_step no outputs cartão.

  2. Copie o valor do Data campo. Parece algo como azureml_995abbc2-3171-461e-8214-c3c5d17ede83_output_data_data_with_prediction:1.

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

  4. Observe a predict_is_fraud coluna 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), 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. Isso aconteceu porque você não forneceu name ou version valores para outputs de inference_step. 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))

Limpeza

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

Próximos passos

  • Last updated on