Zelfstudie 2: Modellen experimenteren en trainen met behulp van functies

Artikel
10/27/2023

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

In de eerste zelfstudie hebt u gezien hoe u een specificatie voor een functieset maakt met aangepaste transformaties en vervolgens die functieset gebruikt om trainingsgegevens te genereren, materialisatie in te schakelen en een backfill uit te voeren. Deze zelfstudie laat zien hoe u materialisatie 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, met behulp van bestaande vooraf berekende 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 functies om de trainingsgegevens te genereren.

Vereisten

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

Instellingen

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 map 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 in de vervolgkeuzelijst Compute serverloze Spark Compute onder Serverloze Spark van Azure Machine Learning.
2. Configureer de sessie:
  1. Wanneer de werkbalk Configureersessie weergeeft, selecteert u deze.
  2. Selecteer Op het tabblad Python-pakketten het Conda-bestand uploaden.
  3. Upload het conda.yml bestand dat u in de eerste zelfstudie hebt geüpload.
  4. Verhoog eventueel de time-out van de sessie (niet-actieve tijd) om frequente vereisten opnieuw uit te voeren.

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 hoofdmap 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. Verifiëren.
```
!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 notebook voor zelfstudies wordt uitgevoerd in deze resource.

### 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 het functiearchief.

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 verbruiksclient van het functiearchief.

# 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 accountsfunctie maken die is ingesteld 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 functiearchief. In deze procedure maakt u de specificatie van de functieset lokaal en samplet u vervolgens de waarden hiervan. Voor mogelijkheden van het beheerde functiearchief moet u een functieassetdefinitie 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 met behulp 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.

Als u de specificatie van de functieset wilt registreren bij het functiearchief, moet u de specificatie van de onderdelenset opslaan in een specifieke indeling.

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 is het een Parquet-bestand in een blobopslagresource.
- features: Een lijst met functies en hun gegevenstypen. Met opgegeven transformatiecode moet de code een DataFrame retourneren dat is toegewezen aan de functies 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.
Zie Informatie over entiteiten op het hoogste niveau in het beheerde functiearchief en het YAML-schema van de CLI(v2)-functieset.

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 het functiearchief.

Nadat u lokaal hebt geëxperimenteert met functiedefinities en ze redelijk lijken, kunt u een definitie van een functiesetasset registreren bij het functiearchief.

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 de volgende 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 functies ontdekken in de gebruikersinterface van het functiearchief.

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 Functiearchieven 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 het algemene zoekvak gebruiken om te zoeken naar functiesets in alle functiearchieven.

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 flexibiliteit van de modelverzending neemt toe als u de geselecteerde functies opslaat als specificatie voor het ophalen van functies en vervolgens de specificatie gebruikt in de machine learning-bewerkingen (MLOps) of de CI/CD-stroom (continue integratie en continue levering) voor training en deductie.
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. Het wordt vervolgens verpakt met het model.
  
  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-/deductiepijplijn kunnen minimaal blijven 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 deze is verpakt 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)
```

Trainen in de cloud 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 trainingspijplijn uit.

De trainingspijplijn heeft de volgende stappen:
1. Functie ophalen: voor de invoer neemt dit ingebouwde onderdeel de specificatie voor het ophalen van functies, 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 zelfstudie is dit een tijdelijke aanduiding voor illustratiedoeleinden.)
4. Het model registreren: met deze stap wordt het model geregistreerd.
  
  Notitie
  
  In de tweede zelfstudie hebt u een backfilltaak 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 trainingspijplijn 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. Selecteer 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 deductie deze 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 transactionsaccounts functiesets weergegeven waarvan dit model afhankelijk is.
Bekijk de lijst met modellen die gebruikmaken van de functiesets:
1. Open de gebruikersinterface van het functiearchief (eerder in deze zelfstudie 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: Terugkerende materialisatie inschakelen en batchdeductie uitvoeren.
Meer informatie over concepten en entiteiten op het hoogste niveau in het beheerde functiearchief.
Meer informatie over identiteits- en toegangsbeheer voor het beheerde functiearchief.
Bekijk de gids voor probleemoplossing voor het opslaan van beheerde functies.
Bekijk de YAML-verwijzing.

Delen via