Självstudie 2: Experimentera och träna modeller med hjälp av funktioner

Artikel
11/09/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. Sedan visade den hur du använder den funktionsuppsättningen för att generera träningsdata, aktivera materialisering och utföra en återfyllnad. Den här självstudien visar hur du aktiverar materialisering och utför en återfyllnad. Den visar också hur du experimenterar med funktioner som ett sätt att förbättra modellprestandan.

I den här självstudien lär du dig att:

Skapa en ny accounts funktionsuppsättningsspecifikation med hjälp av befintliga förberäknade värden som funktioner. Registrera sedan den lokala funktionsuppsättningsspecifikationen som en funktionsuppsättning i funktionsarkivet. Den här processen skiljer sig från den första självstudien, där du skapade en funktionsuppsättning som hade anpassade omvandlingar.
Välj funktioner för modellen från funktionsuppsättningarna transactions och accounts spara dem som en funktionshämtningsspecifikation.
Kör en träningspipeline som använder funktionshämtningsspecifikationen för att träna en ny modell. Den här pipelinen använder den inbyggda komponenten för funktionshämtning för att generera träningsdata.

Förutsättningar

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

Konfigurera

Konfigurera Azure Machine Learning Spark-notebook-filen.

Du kan skapa en ny notebook-fil och köra anvisningarna i den här självstudien steg för steg. Du kan också öppna och köra den befintliga notebook-filen med namnet 2.Experiment-train-models-using-features.ipynb från 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. På den översta menyn går du till listrutan Beräkning och väljer Serverlös Spark Compute under Azure Machine Learning Serverless Spark.
2. Konfigurera sessionen:
  1. När verktygsfältet visar Konfigurera session väljer du den.
  2. På fliken Python-paket väljer du Ladda upp Conda-fil.
  3. Ladda upp den conda.yml fil som du laddade upp i den första självstudien.
  4. Som ett alternativ kan du öka tidsgränsen för sessionen (inaktiv tid) 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 Machine Learning-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 variablerna för projektarbetsytan.

Det här är den aktuella arbetsytan och notebook-filen för självstudier körs i den här resursen.

### 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ärdena och featurestore_location 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 förbrukningsklienten 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,
)

Skapa ett beräkningskluster med namnet cpu-cluster på projektarbetsytan.

Du behöver det här beräkningsklustret när du kör tränings-/batch-slutsatsdragningsjobben.

from azure.ai.ml.entities import AmlCompute

cluster_basic = AmlCompute(
    name="cpu-cluster-fs",
    type="amlcompute",
    size="STANDARD_F4S_V2",  # you can replace it with other supported VM SKUs
    location=ws_client.workspaces.get(ws_client.workspace_name).location,
    min_instances=0,
    max_instances=1,
    idle_time_before_scale_down=360,
)
ws_client.begin_create_or_update(cluster_basic).result()

Skapa kontofunktionen i en lokal miljö

I den första självstudien skapade du en transactions funktionsuppsättning som hade anpassade transformeringar. Här skapar du en accounts funktionsuppsättning som använder förberäknade värden.

Om du vill registrera fördefinierade funktioner kan du skapa en funktionsuppsättningsspecifikation utan att skriva någon transformeringskod. Du använder en funktionsuppsättningsspecifikation för att utveckla och testa en funktionsuppsättning i en helt lokal utvecklingsmiljö.

Du behöver inte ansluta till ett funktionsarkiv. I den här proceduren skapar du funktionsuppsättningsspecifikationen lokalt och provar sedan värdena från den. För att kunna dra nytta av funktionerna i hanterad funktionsbutik måste du använda en funktionstillgångsdefinition för att registrera funktionsuppsättningsspecifikationen med ett funktionsarkiv. Senare steg i den här självstudien innehåller mer information.

Utforska källdata för kontona.

Kommentar

Den här notebook-filen använder exempeldata som finns i en offentligt tillgänglig blobcontainer. Endast en wasbs drivrutin kan läsa den i Spark. När du skapar funktionsuppsättningar med hjälp av dina egna källdata är du värd för dessa funktionsuppsättningar i ett Azure Data Lake Storage Gen2-konto och använder en abfss drivrutin i datasökvägen.
```
accounts_data_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/accounts-precalculated/*.parquet"
accounts_df = spark.read.parquet(accounts_data_path)

display(accounts_df.head(5))
```

Skapa funktionsuppsättningsspecifikationen accounts lokalt från dessa förberäknade funktioner.

Du behöver ingen transformeringskod här eftersom du refererar till fördefinierade funktioner.

from azureml.featurestore import create_feature_set_spec, FeatureSetSpec
from azureml.featurestore.contracts import (
    DateTimeOffset,
    Column,
    ColumnType,
    SourceType,
    TimestampColumn,
)
from azureml.featurestore.feature_source import ParquetFeatureSource


accounts_featureset_spec = create_feature_set_spec(
    source=ParquetFeatureSource(
        path="wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/accounts-precalculated/*.parquet",
        timestamp_column=TimestampColumn(name="timestamp"),
    ),
    index_columns=[Column(name="accountID", type=ColumnType.string)],
    # account profiles in the source are updated once a year. set temporal_join_lookback to 365 days
    temporal_join_lookback=DateTimeOffset(days=365, hours=0, minutes=0),
    infer_schema=True,
)

Exportera som en funktionsuppsättningsspecifikation.

Om du vill registrera funktionsuppsättningsspecifikationen med funktionsarkivet måste du spara funktionsuppsättningsspecifikationen i ett visst format.

När du har kört nästa cell kontrollerar du specifikationen för den genererade funktionsuppsättningen accounts . Om du vill se specifikationen öppnar du filen featurestore/featuresets/accounts/spec/FeatureSetSpec.yaml från filträdet.

Specifikationen har följande viktiga element:
- source: En referens till en lagringsresurs. I det här fallet är det en Parquet-fil i en bloblagringsresurs.
- features: En lista över funktioner och deras datatyper. Med den tillhandahållna transformeringskoden måste koden returnera en DataFrame som mappar till funktionerna och datatyperna. Utan den tillhandahållna transformeringskoden skapar systemet frågan för att mappa funktioner och datatyper till källan. I det här fallet innehåller specifikationen för den genererade funktionsuppsättningen accounts inte transformeringskod eftersom funktionerna är förberäknade.
- index_columns: Anslutningsnycklarna som krävs för att komma åt värden från funktionsuppsättningen.
Mer information finns i Förstå entiteter på toppnivå i hanterad funktionsbutik och CLI-funktionsuppsättningsspecifikationens YAML-schemaresurser.

Som en extra fördel har beständigt stöd för källkontroll.

Du behöver ingen transformeringskod här eftersom du refererar till fördefinierade funktioner.
```
import os

# create a new folder to dump the feature set spec
accounts_featureset_spec_folder = root_dir + "/featurestore/featuresets/accounts/spec"

# check if the folder exists, create one if not
if not os.path.exists(accounts_featureset_spec_folder):
    os.makedirs(accounts_featureset_spec_folder)

accounts_featureset_spec.dump(accounts_featureset_spec_folder, overwrite=True)
```

Experimentera lokalt med oregistrerade funktioner och registrera dig i funktionsarkivet när det är klart

När du utvecklar funktioner kanske du vill testa och verifiera dem lokalt innan du registrerar dem i funktionsarkivet eller kör träningspipelines i molnet. En kombination av en lokal oregistrerad funktionsuppsättning (accounts) och en funktionsuppsättning som registrerats i funktionsarkivet (transactions) genererar träningsdata för maskininlärningsmodellen.

Välj funktioner för modellen.

# get the registered transactions feature set, version 1
transactions_featureset = featurestore.feature_sets.get("transactions", "1")
# Notice that account feature set spec is in your local dev environment (this notebook): not registered with feature store yet
features = [
    accounts_featureset_spec.get_feature("accountAge"),
    accounts_featureset_spec.get_feature("numPaymentRejects1dPerUser"),
    transactions_featureset.get_feature("transaction_amount_7d_sum"),
    transactions_featureset.get_feature("transaction_amount_3d_sum"),
    transactions_featureset.get_feature("transaction_amount_7d_avg"),
]

Generera träningsdata lokalt.

Det här steget genererar träningsdata för illustrativa ändamål. Som ett alternativ kan du träna modeller lokalt här. Senare steg i den här självstudien förklarar hur du tränar en modell i molnet.

from azureml.featurestore import get_offline_features

# Load the observation data. To understand observatio ndata, refer to part 1 of this tutorial
observation_data_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/observation_data/train/*.parquet"
observation_data_df = spark.read.parquet(observation_data_path)
obs_data_timestamp_column = "timestamp"

# generate training dataframe by using feature data and observation data
training_df = get_offline_features(
    features=features,
    observation_data=observation_data_df,
    timestamp_column=obs_data_timestamp_column,
)

# Ignore the message that says feature set is not materialized (materialization is optional). We will enable materialization in the next part of the tutorial.
display(training_df)
# Note: display(training_df.head(5)) displays the timestamp column in a different format. You can can call training_df.show() to see correctly formatted value

Registrera funktionsuppsättningen accounts med funktionsarkivet.

När du har experimenterat lokalt med funktionsdefinitioner, och om de verkar rimliga, kan du registrera en funktionsuppsättningstillgångsdefinition med funktionsarkivet.

from azure.ai.ml.entities import FeatureSet, FeatureSetSpecification

accounts_fset_config = FeatureSet(
    name="accounts",
    version="1",
    description="accounts featureset",
    entities=[f"azureml:account:1"],
    stage="Development",
    specification=FeatureSetSpecification(path=accounts_featureset_spec_folder),
    tags={"data_type": "nonPII"},
)

poller = fs_client.feature_sets.begin_create_or_update(accounts_fset_config)
print(poller.result())

Hämta den registrerade funktionsuppsättningen och testa den.

# look up the featureset by providing name and version
accounts_featureset = featurestore.feature_sets.get("accounts", "1")

Köra ett träningsexperiment

I de här stegen väljer du en lista över funktioner, kör en träningspipeline och registrerar modellen. Du kan upprepa de här stegen tills modellen fungerar som du vill.

Du kan också identifiera funktioner från funktionsarkivets användargränssnitt.

Den första självstudien beskriver det här steget när du registrerade funktionsuppsättningen transactions . Eftersom du också har en accounts funktionsuppsättning kan du bläddra igenom de tillgängliga funktionerna:
1. Gå till den globala landningssidan för Azure Machine Learning.
2. Välj Funktionslager i den vänstra rutan.
3. I listan över funktionslager väljer du det funktionsarkiv som du skapade tidigare.
Användargränssnittet visar de funktionsuppsättningar och entiteter som du skapade. Välj funktionsuppsättningarna för att bläddra igenom funktionsdefinitionerna. Du kan använda rutan global sökning för att söka efter funktionsuppsättningar i flera funktionslager.

Du kan också identifiera funktioner från SDK:et.

# List available feature sets
all_featuresets = featurestore.feature_sets.list()
for fs in all_featuresets:
    print(fs)

# List of versions for transactions feature set
all_transactions_featureset_versions = featurestore.feature_sets.list(
    name="transactions"
)
for fs in all_transactions_featureset_versions:
    print(fs)

# See properties of the transactions featureset including list of features
featurestore.feature_sets.get(name="transactions", version="1").features

Välj funktioner för modellen och exportera modellen som en funktionshämtningsspecifikation.

I föregående steg valde du funktioner från en kombination av registrerade och oregistrerade funktionsuppsättningar för lokala experimentering och testning. Nu kan du experimentera i molnet. Din flexibilitet för modellleverans ökar om du sparar de valda funktionerna som en funktionshämtningsspecifikation och sedan använder specifikationen i flödet för maskininlärningsåtgärder (MLOps) eller kontinuerlig integrering och kontinuerlig leverans (CI/CD) för träning och slutsatsdragning.
1. Välj funktioner för modellen.
```
# you can select features in pythonic way
features = [
    accounts_featureset.get_feature("accountAge"),
    transactions_featureset.get_feature("transaction_amount_7d_sum"),
    transactions_featureset.get_feature("transaction_amount_3d_sum"),
]

# you can also specify features in string form: featurestore:featureset:version:feature
more_features = [
    f"accounts:1:numPaymentRejects1dPerUser",
    f"transactions:1:transaction_amount_7d_avg",
]

more_features = featurestore.resolve_feature_uri(more_features)

features.extend(more_features)
```
2. Exportera de valda funktionerna som en funktionshämtningsspecifikation.
  
  En funktionshämtningsspecifikation är en bärbar definition av funktionslistan som är associerad med en modell. Det kan hjälpa till att effektivisera utvecklingen och driftsättningen av en maskininlärningsmodell. Det blir en indata till träningspipelinen som genererar träningsdata. Sedan paketeras den med modellen.
  
  Inferensfasen använder funktionshämtningen för att leta upp funktionerna. Den integrerar alla faser i maskininlärningslivscykeln. Ändringar i pipelinen för träning/slutsatsdragning kan ligga kvar på ett minimum när du experimenterar och distribuerar.
  
  Användning av funktionshämtningsspecifikationen och den inbyggda komponenten för funktionshämtning är valfri. Du kan använda API:et get_offline_features() direkt, som du visade tidigare. Specifikationens namn ska vara feature_retrieval_spec.yaml när du paketera den med modellen. På så sätt kan systemet känna igen det.
```
# Create feature retrieval spec
feature_retrieval_spec_folder = root_dir + "/project/fraud_model/feature_retrieval_spec"

# check if the folder exists, create one if not
if not os.path.exists(feature_retrieval_spec_folder):
    os.makedirs(feature_retrieval_spec_folder)

featurestore.generate_feature_retrieval_spec(feature_retrieval_spec_folder, features)
```

Träna i molnet med pipelines och registrera modellen

I den här proceduren utlöser du träningspipelinen manuellt. I ett produktionsscenario kan en CI/CD-pipeline utlösa den, baserat på ändringar i funktionshämtningsspecifikationen på källlagringsplatsen. Du kan registrera modellen om den är tillfredsställande.

Kör träningspipelinen.

Träningspipelinen har följande steg:
1. Funktionshämtning: För indata tar den här inbyggda komponenten specifikationen för funktionshämtning, observationsdata och kolumnnamnet för tidsstämpeln . Sedan genereras träningsdata som utdata. Den kör de här stegen som ett hanterat Spark-jobb.
2. Utbildning: Baserat på träningsdata tränar det här steget modellen och genererar sedan en modell (ännu inte registrerad).
3. Utvärdering: Det här steget kontrollerar om modellens prestanda och kvalitet ligger inom ett tröskelvärde. (I den här självstudien är det ett platshållarsteg i illustrationssyfte.)
4. Registrera modellen: Det här steget registrerar modellen.
  
  Kommentar
  
  I den andra självstudien körde du ett återfyllnadsjobb för att materialisera data för funktionsuppsättningen transactions . Funktionshämtningssteget läser funktionsvärden från offlinearkivet för den här funktionsuppsättningen. Beteendet är detsamma, även om du använder API:et get_offline_features() .
```
from azure.ai.ml import load_job  # will be used later

training_pipeline_path = (
    root_dir + "/project/fraud_model/pipelines/training_pipeline.yaml"
)
training_pipeline_definition = load_job(source=training_pipeline_path)
training_pipeline_job = ws_client.jobs.create_or_update(training_pipeline_definition)
ws_client.jobs.stream(training_pipeline_job.name)
# Note: First time it runs, each step in pipeline can take ~ 15 mins. However subsequent runs can be faster (assuming spark pool is warm - default timeout is 30 mins)
```
5. Inspektera träningspipelinen och modellen.
  - Om du vill visa pipelinestegen väljer du hyperlänken för webbvisningspipelinen och öppnar den i ett nytt fönster.
Använd funktionshämtningsspecifikationen i modellartefakterna:
1. I den vänstra rutan på den aktuella arbetsytan väljer du Modeller med höger musknapp.
2. Välj Öppna på en ny flik eller ett nytt fönster.
3. Välj fraud_model.
4. Välj Artefakter.
Specifikationen för funktionshämtning paketeras tillsammans med modellen. Steget för modellregistrering i träningspipelinen hanterade det här steget. Du skapade specifikationen för funktionshämtning under experimenteringen. Nu är det en del av modelldefinitionen. I nästa självstudie får du se hur inferensprocessen använder den.

Visa funktionsuppsättningen och modellberoenden

Visa listan över funktionsuppsättningar som är associerade med modellen.

På sidan Modeller väljer du fliken Funktionsuppsättningar. På den här fliken visas både funktionsuppsättningarna transactions och accounts . Den här modellen är beroende av dessa funktionsuppsättningar.
Visa listan över modeller som använder funktionsuppsättningarna:
1. Öppna användargränssnittet för funktionsarkivet (beskrivs tidigare i den här självstudien).
2. Välj Funktionsuppsättningar i den vänstra rutan.
3. Välj en funktionsuppsättning.
4. Välj fliken Modeller .
Specifikationen för funktionshämtning fastställde den här listan när modellen registrerades.

Rensa

Den femte självstudien i serien beskriver hur du tar bort resurserna.

Nästa steg

Gå till nästa självstudie i serien: Aktivera återkommande materialisering och kör batchinferens.
Lär dig mer om funktionslagerbegrepp och entiteter på toppnivå i hanterad funktionsbutik.
Läs mer om identitets- och åtkomstkontroll för hanterad funktionsbutik.
Visa felsökningsguiden för hanterad funktionsbutik.
Visa YAML-referensen.

Dela via