Självstudie 3: Aktivera återkommande materialisering och köra batchinferens

Den här självstudieserien visar hur funktioner sömlöst integrerar alla faser i maskininlärningslivscykeln: prototyper, utbildning och operationalisering.

Den första handledningen visade hur du skapar en funktionsuppsättning-specifikation med anpassade transformeringar. Den visade sedan hur du använder funktionsuppsättningen för att generera träningsdata, aktivera materialisering och utföra en återfyllnad. Den andra handledningen visade hur du aktiverar materialisering och utför en backfyllning. Den visade också hur du experimenterar med funktioner som ett sätt att förbättra modellprestanda.

I den här guiden förklaras hur du:

Förutsättningar

Innan du fortsätter med den här självstudien måste du slutföra de första och andra självstudierna i serien.

Konfigurera

1. Konfigurera Azure Machine Learning Spark-notebook.

   Om du vill köra den här självstudien kan du skapa en ny anteckningsbok och köra instruktionerna steg för steg. Du kan också öppna och köra den befintliga notebook-filen med namnet 3. Aktivera återkommande materialisering och kör batchinferens. Du kan hitta den anteckningsboken och alla anteckningsböcker i den här serien i katalogen featurestore_sample/notebooks. Du kan välja sdk_only eller sdk_and_cli. Håll den här självstudien öppen och använd den för dokumentationslänkar och mer förklaringar.

   1. I listrutan Compute i det övre navigeringsfältet väljer du Serverless Spark Compute under Azure Machine Learning Serverless Spark.

   2. Konfigurera sessionen:

      1. Välj Konfigurera session i det översta statusfältet.
      2. Välj fliken Python-paket.
      3. Välj Ladda upp conda-fil.
      4. azureml-examples/sdk/python/featurestore-sample/project/env/online.yml Välj filen från den lokala datorn.
      5. Du kan också öka tidsgränsen för sessionen (inaktivitetstid) för att undvika frekventa nödvändiga omkörningar.

2. Starta Spark-sessionen.

   # 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. Konfigurera rotkatalogen för exemplen.

   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. Konfigurera CLI.

   • Python SDK
   • Azure CLI

   Ej tillämpbart.

1. Initiera crud-klienten för projektarbetsytan (skapa, läsa, uppdatera och ta bort).

   Noteboook för tutorial körs från den aktuella arbetsytan.

   ### 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. Initiera variablerna i funktionslagret.

   Se till att uppdatera featurestore_name-värdet för att återspegla det du skapade i den första självstudien.

   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. Initiera SDK-klienten för funktionsarkivet.

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

Aktivera återkommande materialisering för transaktionsfunktionsuppsättningen

I den andra självstudien aktiverade du materialisering och utförde återfyllnad på funktionsuppsättningen transactions . Återfyllnad är en engångsoperation på begäran som beräknar och placerar funktionsvärden i materialiseringslagret.

För att hantera inferens av modellen i produktion kanske du vill konfigurera återkommande materialiseringsjobb för att hålla materialiseringslagret uppdaterat. De här jobben körs enligt användardefinierade scheman. Det återkommande jobbschemat fungerar på det här sättet:

• Intervall- och frekvensvärden definierar ett fönster. Följande värden definierar till exempel ett tretimmarsfönster:

  • interval = 3
  • frequency = Hour

• Det första fönstret börjar med det start_time värde som definierats i RecurrenceTrigger, och så vidare.

• Det första återkommande jobbet skickas i början av nästa fönster efter uppdateringstiden.

• Senare återkommande jobb skickas i varje tidsfönster efter det första jobbet.

Som beskrivs i tidigare självstudier används materialiserade data som standard när data har materialiserats (återfyllnad eller återkommande materialisering).

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

(Valfritt) Spara YAML-filen för funktionsuppsättningsresursen

Du använder de uppdaterade inställningarna för att spara YAML-filen.

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

Kör pipelinen för batchinferens

Batchinferensen har följande steg:

1. Du använder samma inbyggda funktionshämtningskomponent för funktionshämtning som du använde i träningspipelinen (beskrivs i den tredje självstudien). För pipelineträning har du angett en funktionshämtningsspecifikation som komponentindata. För batchinferens skickar du den registrerade modellen som indata. Komponenten söker efter specifikationen för återvinning av funktioner i modellartefakten.

   För träning hade observationsdata dessutom målvariabeln. Observationsdata för batchinferens har dock inte målvariabeln. Steget för att hämta funktioner kopplar observationsdata till funktionerna och matar ut data för batchinferens.

2. Pipelinen använder indata för batchinferens från föregående steg, kör slutsatsdragning för modellen och lägger till det förutsagda värdet som utdata.

   Anteckning

   Du använder ett jobb för batch-inferens i det här exemplet. Du kan också använda batchslutpunkter i 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)

Granska utdata för batchinferens

I visningen för pipelinen

1. Välj inference_step i kortet outputs .

2. Data Kopiera fältvärdet. Det ser ut ungefär som azureml_995abbc2-3171-461e-8214-c3c5d17ede83_output_data_data_with_prediction:1.

3. Data Klistra in fältvärdet i följande cell med separata namn och versionsvärden. Det sista tecknet är den version som föregås av ett kolon (:).

4. Observera kolumnen predict_is_fraud som batchinferenspipelinen genererade.

   I batchinferensrörledningen (/project/fraud_mode/pipelines/batch_inference_pipeline.yaml) skapade systemet en ospårbar datatillgång med en GUID som namnvärde och 1 som versionsvärde. Det här hände eftersom du inte angav name eller version värden för outputs av inference_step. I den här cellen härleder du och visar datavägen från tillgången.

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

Rensa

Den femte handledningen i serien beskriver hur du tar bort resurserna.

Nästa steg

• Lär dig mer om feature store-koncept och toppnivåentiteter i hanterad feature store.
• Läs mer om identitets- och åtkomstkontroll för hanterad feature store.
• Visa felsökningsguiden för hanterad feature store.
• Visa YAML-referensen.