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

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

Viktigt!

Azure Cache for Redis meddelade sin tidslinje för pensionering för alla SKU:er. Vi rekommenderar att du flyttar dina befintliga Azure Cache for Redis-instanser till Azure Managed Redis så snart du kan.

Migreringsvägledning:

Mer information om pensionering:

Azure Cache for Redis Pension: Vad man ska veta och hur man förbereder
vanliga frågor och svar om Azure Cache for Redis pensionering

Den första handledningen visade hur du skapar en funktionsuppsättning-specifikation 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 handledningen visar hur du aktiverar materialisering och utför en återställning. Den visar också hur du experimenterar med funktioner som ett sätt att förbättra modellprestandan.

I den här handledningen lär du dig:

Skapa en ny accounts funktionsuppsättningsspecifikation med hjälp av befintliga förberäknade värden som funktioner. Registrera sedan den lokala funktionsspecifikationen som en funktionsuppsättning i funktionsarkivet. Den här processen skiljer sig från den första handledningen, 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.

Du kan skapa en ny notebook och köra anvisningarna i den här handledningen 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 använd den för dokumentationslänkar och mer förklaringar.
1. På den översta menyn i listrutan Compute väljer du Serverless 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 väljer du filen Upload Conda.
  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 tillägget Azure Machine Learning.
```
!az extension add --name ml
```
Autentisera.
```
!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 nuvarande arbetsytan, och självstudieanteckningsboken körs i denna resurs.

### 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 funktionslagret.

Se till att uppdatera featurestore_name och featurestore_location värdena för att återspegla det du skapade i den första guidade lektionen.

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 en feature store. 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 ett hanterat funktionsarkiv måste du använda en funktionstillgångsdefinition för att registrera specifikationen för funktionsuppsättningen i ett funktionsarkiv. Senare steg i den här handledningen innehåller mer information.

Utforska källdata för kontona.

Anteckning

Den här notebook-filen använder exempeldata som finns i en offentligt tillgänglig blobcontainer. Endast en wasbs förare kan läsa den i Spark. När du skapar funktionsuppsättningar med hjälp av dina egna källdata värdar du de funktionsuppsättningarna i ett Azure Data Lake Storage Gen2-konto och använder en abfss drivrutin i datavä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.

För att registrera funktionsuppsättningsspecifikationen i funktionsarkivet måste du spara den i ett specifikt 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 stödjer ihållande 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 funktionaliteter och registrera dem i funktionsarkivet när de är klara

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 handledningen 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 feature store.

När du har experimenterat lokalt med funktionsdefinitioner, och om de verkar rimliga, kan du registrera en definition av en funktionsuppsättningstillgång i 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.

Alternativt kan du upptäcka funktioner från funktionsarkivets användargränssnitt.

Den första handledningen täckte 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 Azure Machine Learning global landningssida.
2. Välj Funktioner i den vänstra panelen.
3. I listan över funktionslager, välj det funktionslager 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 den globala sökrutan för att söka efter funktionsuppsättningar över flera funktionslager.

Valfritt, upptäck 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 används som 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 tränings-/inferensprocessen kan förbli minimala 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, beroende på ändringar i specifikationen för hämtning av funktioner i källarkivet. 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. Det 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.
  
  Anteckning
  
  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äningsrörledningen 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 funktionsåterträvning paketeras tillsammans med modellen. Steget för modellregistrering i träningspipelinen hanterade det här steget. Du skapade specifikationen för funktionshämtning under experimentprocessen. Nu är det en del av modelldefinitionen. I nästa handledning 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 feature store (förklaras tidigare i denna guide).
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 handledningen i serien beskriver hur man tar bort resurserna.

Nästa steg

Gå till nästa handledning i serien: Aktivera återkommande materialisering och kör batchinferens.
Lär dig mer om funktionslagerbegrepp och huvudentiteter i hanterat funktionslager.
Läs mer om identitets- och åtkomstkontroll för hanterad funktionsbutik.
Visa felsökningsguiden för hanterad feature store.
Visa YAML-referensen.

Feedback

Var den här sidan till hjälp?

Last updated on 2026-04-13