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.

Importante

Cache do Azure para Redis anunciou o seu cronograma de descontinuação para todos os SKUs. Recomendamos que mude as suas instâncias existentes do Cache do Azure para Redis para o Azure Managed Redis assim que possível.

Orientação sobre migração:

Para mais detalhes sobre a aposentadoria:

O Tutorial 1 mostrou como criar uma especificação de conjunto de funcionalidades com transformações personalizadas e depois usar esse conjunto para gerar dados de treino, permitir a materialização e realizar um backfill. O Tutorial 2 mostrou como experimentar funcionalidades para melhorar o desempenho do modelo, e depois treinar e registar um modelo que utilize características.

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 avançar com este tutorial, complete os Tutoriais 1 e 2 desta série.

Configurar

  1. Configure o bloco de notas 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 notebook existente chamado 3. Ative a materialização recorrente e execute a inferência em lote. Pode encontrar esse bloco de notas, assim como 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 Compute na barra de navegação superior, selecione Serverless Spark Compute em Azure Machine Learning Serverless Spark.

    2. Configure a sessão:

      1. Selecione Configurar sessão na barra de status superior.
      2. Selecione a aba pacotes Python.
      3. Selecione Upload conda file.
      4. Selecione o azureml-examples/sdk/python/featurestore-sample/project/env/online.yml ficheiro da 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 criaste no Tutorial 1, atualiza 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 Tutorial 1, ativavas a materialização e fazias backfill no transactions conjunto de funcionalidades. O preenchimento é uma operação única sob demanda que calcula e coloca valores de características no repositório de materialização.

Para lidar com a inferência do modelo em produção, é aconselhável configurar trabalhos recorrentes de materialização para manter o repositório 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 (backfill ou materialização recorrente), a recuperação de características usa 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 fluxo de trabalho de inferência em lote

A inferência em lote tem estas etapas:

  1. Usas o mesmo componente de recuperação de funcionalidades incorporado para recuperação de funcionalidades que usaste no pipeline de treino (abordado no Tutorial 2). Para o treino de pipeline, fornece uma especificação de recuperação de funcionalidades 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 características no artefato do modelo.

    Além disso, durante o treinamento, os dados de observação contavam com 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 características une os dados de observação com as características 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 acrescenta o valor previsto como saída.

    Nota

    Utiliza-se um trabalho para inferência em lote neste exemplo. Também podes usar endpoints batch 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 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 coluna predict_is_fraud que o pipeline de previsão 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, calcula-se e apresenta-se 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

Tutorial 5: Desenvolver um conjunto de funcionalidades com uma fonte personalizada descreve como eliminar os recursos.

Próximos passos

  • Última atualização a