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

Artikel
10/16/2024

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

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

I den här självstudien beskrivs hur du:

Aktivera återkommande materialisering för funktionsuppsättningen transactions .
Kör en pipeline för batchinferens på den registrerade modellen.

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

Konfigurera Azure Mašinsko učenje Spark-notebook-filen.

Om du vill köra den här självstudien kan du skapa en ny notebook-fil och köra anvisningarna 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 hittar anteckningsboken och alla notebook-filer 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 se den för dokumentationslänkar och mer förklaring.
1. I listrutan Beräkning i det övre navigeringsfältet väljer du Serverlös Spark Compute under Azure Mašinsko učenje 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.

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

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

Konfigurera CLI.

Python SDK
Azure CLI

Ej tillämpbart.

Installera Azure Mašinsko učenje-tillägget.
```
!az extension add --name ml
```
Styrka.
```
!az login
```

Ange standardprenumerationen.

import os

subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]

!az account set -s $subscription_id

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

Notebook-filen för självstudien 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
)

Initiera variablerna i funktionsarkivet.

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

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ångsåtgärd på begäran som beräknar och placerar funktionsvärden i materialiseringsarkivet.

För att hantera slutsatsdragning av modellen i produktion kanske du vill konfigurera återkommande materialiseringsjobb för att hålla materialiseringsarkivet 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 fö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ättningstillgången

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

Python SDK
Azure CLI

## 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:

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 funktionshämtningsspecifikationen 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.

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.

Kommentar

Du använder ett jobb för batchinferens i det här exemplet. Du kan också använda batchslutpunkter i Azure Mašinsko učenje.

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 pipelinevyn:

Välj inference_step i kortet outputs .
Data Kopiera fältvärdet. Det ser ut ungefär som azureml_995abbc2-3171-461e-8214-c3c5d17ede83_output_data_data_with_prediction:1.
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 (:).
Observera kolumnen predict_is_fraud som batchinferenspipelinen genererade.

I batchinferenspipelinen (/project/fraud_mode/pipelines/batch_inference_pipeline.yaml) utdata, eftersom du inte angav name eller version värden för , outputs inference_stepskapade systemet en ospårad datatillgång med ett GUID som namnvärde och 1 som versionsvärde. I den här cellen härleder du och visar sedan datasökvä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 självstudien i serien beskriver hur du tar bort resurserna.

Nästa steg

Lär dig mer om koncept för funktionslager och entiteter på toppnivå i det hanterade funktionsarkivet.
Lär dig mer om identitets- och åtkomstkontroll för hanterat funktionsarkiv.
Visa felsökningsguiden för det hanterade funktionsarkivet.
Visa YAML-referensen.

Dela via