Zelfstudie 2: Modellen experimenteren en trainen met behulp van functies

Deze reeks zelfstudies laat zien hoe functies naadloos alle fasen van de levenscyclus van machine learning integreren: prototypen, training en operationalisatie.

Belangrijk

Azure Cache voor Redis heeft de tijdlijn voor uitfasering aangekondigd voor alle SKU's. We raden u aan uw bestaande Azure Cache voor Redis exemplaren zo snel mogelijk te verplaatsen naar Azure Managed Redis.

Migratierichtlijnen:

Voor meer informatie over de buitengebruikstelling:

In de eerste zelfstudie hebt u gezien hoe u een specificatie voor een functieset maakt met aangepaste transformaties. Vervolgens werd getoond hoe u die functieset gebruikt om trainingsgegevens te genereren, materialisatie in te schakelen en een backfill uit te voeren. Deze tutorial laat zien hoe je 'materialization' inschakelt en een backfill uitvoert. Het laat ook zien hoe u kunt experimenteren met functies, als een manier om de modelprestaties te verbeteren.

In deze zelfstudie leert u het volgende:

Prototype van een nieuwe accounts specificatie van een functieset, door gebruik te maken van bestaande vooraf samengestelde waarden als functies. Registreer vervolgens de specificatie van de lokale onderdelenset als een onderdelenset in het functiearchief. Dit proces verschilt van de eerste zelfstudie, waarbij u een functieset hebt gemaakt die aangepaste transformaties had.
Selecteer functies voor het model in de transactions functiesets en accounts sla deze op als specificatie voor het ophalen van functies.
Voer een trainingspijplijn uit die gebruikmaakt van de specificatie voor het ophalen van functies om een nieuw model te trainen. Deze pijplijn maakt gebruik van het ingebouwde onderdeel voor het ophalen van kenmerken om de trainingsgegevens te genereren.

Vereisten

Voordat u verdergaat met deze zelfstudie, moet u de eerste zelfstudie in de reeks voltooien.

Instellen

Configureer het Azure Machine Learning Spark-notebook.

U kunt een nieuw notebook maken en de instructies in deze zelfstudie stapsgewijs uitvoeren. U kunt ook het bestaande notebook met de naam 2.Experiment-train-models-using-features.ipynb openen en uitvoeren vanuit de directory featurestore_sample/notebooks. U kunt sdk_only of sdk_and_cli kiezen. Houd deze zelfstudie open en raadpleeg deze voor documentatiekoppelingen en meer uitleg.
1. Selecteer in het bovenste menu de optie Serverless Spark Compute in de vervolgkeuzelijst Compute onder Azure Machine Learning Serverless Spark.
2. Configureer de sessie:
  1. Wanneer de werkbalk Configureersessie weergeeft, selecteert u deze.
  2. Selecteer op het tabblad Python-pakketten de optie Upload Conda-bestand.
  3. Upload het conda.yml bestand dat u in de eerste zelfstudie hebt geüpload.
  4. Als een optie kunt u de time-out van de sessie (niet-actieve tijd) verlengen om frequente herhalingen van voorvereisten te voorkomen.

Start de Spark-sessie.

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

Stel de rootmap voor de voorbeelden in.

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

Stel de CLI in.
- Python SDK
- Azure CLI
Niet van toepassing.
1. Installeer de Azure Machine Learning-extensie.
```
!az extension add --name ml
```
2. Authenticeren.
```
!az login
```
3. Stel het standaardabonnement in.
```
import os

subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]

!az account set -s $subscription_id
```

Initialiseer de projectwerkruimtevariabelen.

Dit is de huidige werkruimte en het tutorial-notebook wordt in deze resource uitgevoerd.

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

Initialiseer de variabelen voor de feature store.

Zorg ervoor dat u de featurestore_name waarden en featurestore_location waarden bijwerkt om aan te geven wat u in de eerste zelfstudie hebt gemaakt.

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

Initialiseer de consumptieclient van de functieopslag.

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

Maak een rekencluster met de naam cpu-cluster in de projectwerkruimte.

U hebt dit rekencluster nodig wanneer u de trainings-/batchdeductietaken uitvoert.

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

De accountsfunctieset creëren in een lokale omgeving

In de eerste zelfstudie hebt u een transactions functieset gemaakt met aangepaste transformaties. Hier maakt u een accounts functieset die gebruikmaakt van vooraf samengestelde waarden.

Als u vooraf samengestelde functies wilt onboarden, kunt u een specificatie voor een functieset maken zonder dat u transformatiecode hoeft te schrijven. U gebruikt een specificatie van een functieset om een functieset te ontwikkelen en te testen in een volledig lokale ontwikkelomgeving.

U hoeft geen verbinding te maken met een feature store. In deze procedure maakt u de specificatie van de functieset lokaal en samplet u vervolgens de waarden hiervan. Als u wilt profiteren van de mogelijkheden van het beheerde functiearchief, moet u een definitie van een functieasset gebruiken om de specificatie van de functieset te registreren bij een functiearchief. Latere stappen in deze zelfstudie bieden meer informatie.

Verken de brongegevens voor de accounts.

Notitie

In dit notebook worden voorbeeldgegevens gebruikt die worden gehost in een openbaar toegankelijke blobcontainer. Alleen een wasbs stuurprogramma kan het lezen in Spark. Wanneer u functiesets maakt via het gebruik van uw eigen brongegevens, host u deze functiesets in een Azure Data Lake Storage Gen2-account en gebruikt u een abfss stuurprogramma in het gegevenspad.
```
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))
```

Maak de specificatie van de accounts functieset lokaal op basis van deze vooraf samengestelde functies.

U hebt hier geen transformatiecode nodig, omdat u verwijst naar vooraf samengestelde functies.

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

Exporteren als een specificatie van een functieset.

Om de specificatie van de functieset te registreren in de feature store, moet je de specificatie van de functieset opslaan in een specifiek formaat.

Nadat u de volgende cel hebt uitgevoerd, controleert u de gegenereerde accounts specificatie van de functieset. Als u de specificatie wilt zien, opent u het bestand featurestore/featuresets/accounts/spec/FeatureSetSpec.yaml uit de bestandsstructuur.

De specificatie heeft de volgende belangrijke elementen:
- source: Een verwijzing naar een opslagresource. In dit geval gaat het om een Parquet-bestand binnen een blobopslagresource.
- features: Een lijst met functies en hun gegevenstypen. Met de opgegeven transformatiecode moet de code een DataFrame retourneren dat overeenkomt met de kenmerken en gegevenstypen. Zonder de opgegeven transformatiecode bouwt het systeem de query om de functies en gegevenstypen toe te wijzen aan de bron. In dit geval bevat de gegenereerde accounts specificatie van de functieset geen transformatiecode, omdat functies vooraf worden gecomputeerd.
- index_columns: De joinsleutels die vereist zijn voor toegang tot waarden uit de functieset.
Ga voor meer informatie naar de Uitleg van top-level entiteiten in een beheerde feature store en de CLI (v2) specificatie van de functieset YAML schema resources.

Als extra voordeel biedt persistenting ondersteuning voor broncodebeheer.

U hebt hier geen transformatiecode nodig, omdat u verwijst naar vooraf samengestelde functies.
```
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)
```

Lokaal experimenteren met niet-geregistreerde functies en registreren bij de functieopslag wanneer u klaar bent

Wanneer u functies ontwikkelt, wilt u deze mogelijk lokaal testen en valideren voordat u ze registreert bij het functiearchief of trainingspijplijnen uitvoert in de cloud. Een combinatie van een lokale niet-geregistreerde functieset (accounts) en een functieset die is geregistreerd in het functiearchief (transactions) genereert trainingsgegevens voor het machine learning-model.

Selecteer functies voor het model.

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

Lokaal trainingsgegevens genereren.

Met deze stap worden trainingsgegevens gegenereerd voor illustratieve doeleinden. Als optie kunt u hier modellen lokaal trainen. In latere stappen in deze zelfstudie wordt uitgelegd hoe u een model traint in de cloud.

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

Registreer de accounts functieset bij de featurenstore.

Nadat u lokaal hebt geëxperimenteerd met functiedefinities en indien deze redelijk lijken, kunt u een definitie van een functieset eigenschap registreren bij het functiemagazijn.

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

Haal de geregistreerde functieset op en test deze.

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

Een trainingsexperiment uitvoeren

In deze stappen selecteert u een lijst met functies, voert u een trainingspijplijn uit en registreert u het model. U kunt deze stappen herhalen totdat het model naar wens wordt uitgevoerd.

U kunt eventueel kenmerken ontdekken in de gebruikersinterface van de feature store.

In de eerste zelfstudie is deze stap besproken, toen u de transactions functieset registreerde. Omdat u ook een accounts functieset hebt, kunt u door de beschikbare functies bladeren:
1. Ga naar de algemene landingspagina van Azure Machine Learning.
2. Selecteer Functiewinkels in het linkerdeelvenster.
3. Selecteer in de lijst met functiearchieven het functiearchief dat u eerder hebt gemaakt.
In de gebruikersinterface worden de functiesets en entiteit weergegeven die u hebt gemaakt. Selecteer de functiesets om door de functiedefinities te bladeren. U kunt de globale zoekbalk gebruiken om te zoeken naar feature sets in alle feature stores.

U kunt eventueel functies van de SDK detecteren.

# 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

Selecteer functies voor het model en exporteer het model als een specificatie voor het ophalen van functies.

In de vorige stappen hebt u functies geselecteerd uit een combinatie van geregistreerde en niet-geregistreerde functiesets voor lokale experimenten en tests. U kunt nu experimenteren in de cloud. ** De bezorgsnelheid van modellen neemt toe als u de geselecteerde kenmerken opslaat als specificatie voor kenmerkenopslag en vervolgens de specificatie gebruikt in de operaties van machinaal leren (MLOps) of de CI/CD-stroom (continue integratie en continue levering) voor training en inferentie.
1. Selecteer functies voor het model.
```
# 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. Exporteer de geselecteerde functies als een specificatie voor het ophalen van functies.
  
  Een specificatie voor het ophalen van functies is een draagbare definitie van de functielijst die is gekoppeld aan een model. Het kan helpen bij het stroomlijnen van de ontwikkeling en operationalisatie van een machine learning-model. Het wordt een invoer voor de trainingspijplijn waarmee de trainingsgegevens worden gegenereerd. Vervolgens wordt het samen met het model verpakt.
  
  De deductiefase maakt gebruik van het ophalen van functies om de functies op te zoeken. Het integreert alle fasen van de levenscyclus van machine learning. Wijzigingen in de trainings- en inference-pijplijn kunnen tot een minimum worden beperkt tijdens het experimenteren en implementeren.
  
  Het gebruik van de specificatie voor het ophalen van functies en het ingebouwde onderdeel voor het ophalen van functies is optioneel. U kunt de get_offline_features() API rechtstreeks gebruiken, zoals eerder is weergegeven. De naam van de specificatie moet worden feature_retrieval_spec.yaml wanneer u deze inpakt met het model. Op deze manier kan het systeem het herkennen.
```
# 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)
```

In de cloud trainen met pijplijnen en het model registreren

In deze procedure activeert u de trainingspijplijn handmatig. In een productiescenario kan een CI/CD-pijplijn deze activeren op basis van wijzigingen in de specificatie voor het ophalen van functies in de bronopslagplaats. U kunt het model registreren als dit voldoende is.

Voer de trainingspipeline uit.

De trainingspijplijn heeft de volgende stappen:
1. Kenmerkherstel: Als invoer neemt dit ingebouwde onderdeel de specificaties voor kenmerkophaling, de observatiegegevens en de kolomnaam van de tijdstempel. Vervolgens worden de trainingsgegevens als uitvoer gegenereerd. Deze stappen worden uitgevoerd als een beheerde Spark-taak.
2. Training: Op basis van de trainingsgegevens traint deze stap het model en genereert vervolgens een model (nog niet geregistreerd).
3. Evaluatie: Met deze stap wordt gevalideerd of de modelprestaties en -kwaliteit binnen een drempelwaarde vallen. (In deze handleiding is dit een plaatsvervangende stap voor illustratiedoeleinden.)
4. Het model registreren: met deze stap wordt het model geregistreerd.
  
  Notitie
  
  Bij de tweede zelfstudie hebt u een backfill-opdracht uitgevoerd om gegevens voor de transactions functieset te materialiseren. In de stap voor het ophalen van functies worden functiewaarden uit de offlineopslag voor deze functieset gelezen. Het gedrag is hetzelfde, zelfs als u de get_offline_features() API gebruikt.
```
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. Inspecteer de trainingspipeline en het model.
  - Als u de pijplijnstappen wilt weergeven, selecteert u de hyperlink voor de webweergavepijplijn en opent u deze in een nieuw venster.
Gebruik de specificatie voor het ophalen van functies in de modelartefacten:
1. Selecteer in het linkerdeelvenster van de huidige werkruimte Modellen met de rechtermuisknop.
2. Selecteer Openen in een nieuw tabblad of venster.
3. Selecteer fraud_model.
4. Kies Artefacten.
De specificatie voor het ophalen van functies wordt samen met het model verpakt. De modelregistratiestap in de trainingspijplijn heeft deze stap verwerkt. U hebt de specificatie voor het ophalen van functies gemaakt tijdens het experimenteren. Nu maakt het deel uit van de modeldefinitie. In de volgende zelfstudie ziet u hoe het inferentieproces het gebruikt.

De functieset en modelafhankelijkheden weergeven

Bekijk de lijst met functiesets die zijn gekoppeld aan het model.

Selecteer op dezelfde pagina Modellen het tabblad Functiesets. Op dit tabblad worden zowel de functiesets als transactions de accounts functiesets weergegeven. Dit model is afhankelijk van deze functiesets.
Bekijk de lijst met modellen die gebruikmaken van de functiesets:
1. Open de gebruikersinterface van de feature store (zoals eerder in deze tutorial uitgelegd).
2. Selecteer functiesets in het linkerdeelvenster.
3. Selecteer een functieset.
4. Selecteer het tabblad Modellen .
De specificatie voor het ophalen van functies heeft deze lijst bepaald toen het model werd geregistreerd.

Opschonen

In de vijfde zelfstudie in de reeks wordt beschreven hoe u de resources verwijdert.

Volgende stappen

Ga naar de volgende zelfstudie in de reeks: Recurrente materialisatie inschakelen en batch-inferentie uitvoeren.
Ontdek feature store-concepten en primair entiteiten in een beheerde feature store.
Meer informatie over identiteits- en toegangsbeheer voor het beheerde functiearchief.
Bekijk de probleemoplossingsgids voor beheerde functie-opslag.
Bekijk de YAML-verwijzing.

Feedback

Is deze pagina nuttig?

Last updated on 2026-04-13