2. oktatóanyag: Modellek kísérletezése és betanítása funkciókkal

Cikk
10/16/2024

Ez az oktatóanyag-sorozat bemutatja, hogyan integrálhatók zökkenőmentesen a funkciók a gépi tanulási életciklus minden fázisában: prototípus-tervezés, betanítás és üzembe helyezés.

Az első oktatóanyag bemutatta, hogyan hozhat létre egyéni átalakításokkal egy funkciókészlet-specifikációt, majd hogyan hozhat létre betanítási adatokat, hogyan engedélyezheti a materializálást, és hogyan végezheti el a visszatöltést. Ez az oktatóanyag bemutatja, hogyan engedélyezheti a materializálást, és hogyan hajthat végre visszatöltést. Azt is bemutatja, hogyan kísérletezhet a funkciókkal a modell teljesítményének javítása érdekében.

Ebben az oktatóanyagban az alábbiakkal fog megismerkedni:

accounts Új funkciókészlet-specifikáció prototípusa a meglévő előre konfigurált értékek funkcióként való használatával. Ezután regisztrálja a helyi funkciókészlet specifikációját szolgáltatáskészletként a funkciótárolóban. Ez a folyamat eltér az első oktatóanyagtól, amelyben egyéni átalakításokat tartalmazó funkciókészletet hozott létre.
Válassza ki a modell funkcióit a és accounts a transactions funkciókészletekből, és mentse őket funkciólekérési specifikációként.
Futtasson egy betanítási folyamatot, amely a funkciólekérési specifikációt használja egy új modell betanításához. Ez a folyamat a beépített funkciólekérési összetevőt használja a betanítási adatok létrehozásához.

Előfeltételek

Mielőtt folytatná ezt az oktatóanyagot, mindenképpen végezze el a sorozat első oktatóanyagát.

Beállítás

Konfigurálja az Azure Machine Learning Spark-jegyzetfüzetet.

Létrehozhat egy új jegyzetfüzetet, és lépésről lépésre végrehajthatja az oktatóanyag utasításait. A meglévő, 2.Experiment-train-models-using-features.ipynb nevű jegyzetfüzetet a featurestore_sample/notebooks könyvtárból is megnyithatja és futtathatja. Választhat sdk_only vagy sdk_and_cli. Tartsa nyitva ezt az oktatóanyagot, és tekintse meg a dokumentáció hivatkozásait és további magyarázatait.
1. A felső menü Compute legördülő listájában válassza a Kiszolgáló nélküli Spark Compute lehetőséget az Azure Machine Learning Kiszolgáló nélküli Spark alatt.
2. Konfigurálja a munkamenetet:
  1. Amikor az eszköztár megjeleníti a Konfigurálás munkamenetet, jelölje ki.
  2. A Python-csomagok lapon válassza a Conda-fájl feltöltése lehetőséget.
  3. Töltse fel az első oktatóanyagban feltöltött conda.yml fájlt.
  4. Ha szeretné, növelje a munkamenet időtúllépési idejét (üresjárati idő), hogy elkerülje a gyakori előfeltétel-újrafuttatásokat.

Indítsa el a Spark-munkamenetet.

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

Állítsa be a minták gyökérkönyvtárát.

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

A parancssori felület beállítása.
- Python SDK
- Azure CLI
Nem alkalmazható.
1. Telepítse az Azure Machine Learning bővítményt.
```
!az extension add --name ml
```
2. Hitelesít.
```
!az login
```
3. Állítsa be az alapértelmezett előfizetést.
```
import os

subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]

!az account set -s $subscription_id
```

Inicializálja a projekt-munkaterület változóit.

Ez az aktuális munkaterület, és az oktatóanyag-jegyzetfüzet ebben az erőforrásban fut.

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

Inicializálja a funkciótároló változóit.

Az első oktatóanyagban létrehozott értékeket és featurestore_location értékeket mindenképpen frissítsefeaturestore_name.

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

Inicializálja a szolgáltatástároló használati ügyfelét.

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

Hozzon létre egy számítási fürtöt cpu-cluster a projekt-munkaterületen.

A betanítási/kötegelt következtetési feladatok futtatásakor szüksége van erre a számítási fürtre.

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

A fiókfunkció létrehozása helyi környezetben

Az első oktatóanyagban létrehozott egy transactions egyéni átalakításokkal rendelkező funkciókészletet. Itt létrehoz egy accounts olyan szolgáltatáskészletet, amely előre konfigurált értékeket használ.

Az előre konfigurált funkciók előkészítéséhez átalakítási kód írása nélkül is létrehozhat egy szolgáltatáskészlet-specifikációt. Egy szolgáltatáskészlet specifikációjával fejleszthet és tesztelhet egy szolgáltatáskészletet egy teljesen helyi fejlesztési környezetben.

Nem kell csatlakoznia egy szolgáltatástárolóhoz. Ebben az eljárásban helyileg hozza létre a szolgáltatáskészlet specifikációját, majd mintaként adja meg az értékeket. A kezelt funkciótár képességeihez egy funkcióeszköz-definícióval kell regisztrálnia a funkciókészlet specifikációját egy szolgáltatástárolóban. Az oktatóanyag későbbi lépései további részleteket nyújtanak.

A fiókok forrásadatainak megismerése.

Feljegyzés

Ez a jegyzetfüzet nyilvánosan elérhető blobtárolóban tárolt mintaadatokat használ. Csak egy wasbs illesztőprogram tudja olvasni a Sparkban. Ha saját forrásadatokkal hoz létre szolgáltatáskészleteket, ezeket a funkciókészleteket egy Azure Data Lake Storage Gen2-fiókban tárolja, és használjon egy illesztőprogramot abfss az adatútvonalon.
```
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))
```

Hozza létre helyileg a accounts szolgáltatáskészlet specifikációját ezekből az előre konfigurált szolgáltatásokból.

Itt nincs szükség átalakítási kódra, mert előre összeállított funkciókra hivatkozik.

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

Exportálás funkciókészlet-specifikációként.

Ha regisztrálni szeretné a funkciókészlet specifikációját a funkciótárolóban, a funkciókészlet specifikációját egy adott formátumban kell mentenie.

A következő cella futtatása után vizsgálja meg a létrehozott accounts funkciókészlet specifikációját. A specifikáció megtekintéséhez nyissa meg a featurestore/featuresets/accounts/spec/FeatureSetSpec.yaml fájlt a fájlfáról.

A specifikáció az alábbi fontos elemeket tartalmazza:
- source: Egy tárolási erőforrásra mutató hivatkozás. Ebben az esetben ez egy Blob Storage-erőforrás parquet-fájlja.
- features: A funkciók és adattípusaik listája. A megadott átalakítási kóddal a kódnak olyan DataFrame-et kell visszaadnia, amely megfelel a funkcióknak és az adattípusoknak. A megadott átalakítási kód nélkül a rendszer létrehozza a lekérdezést, hogy leképezhesse a funkciókat és az adattípusokat a forráshoz. Ebben az esetben a létrehozott accounts szolgáltatáskészlet specifikációja nem tartalmaz átalakítási kódot, mert a szolgáltatások előre vannak konfigurálva.
- index_columns: A funkciókészlet értékeinek eléréséhez szükséges illesztőkulcsok.
További információ: A kezelt funkciótár legfelső szintű entitásainak és a CLI (v2) szolgáltatáskészlet specifikációjának YAML-sémája.

További előny, hogy a megőrzése támogatja a forráskövetést.

Itt nincs szükség átalakítási kódra, mert előre összeállított funkciókra hivatkozik.
```
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)
```

Helyileg kísérletezzen a nem regisztrált funkciókkal, és amikor készen áll, regisztráljon a szolgáltatástárolóban

A funkciók fejlesztése során érdemes lehet helyileg tesztelni és ellenőrizni őket, mielőtt regisztrálja őket a szolgáltatástárolóban, vagy betanítási folyamatokat futtatna a felhőben. A helyi nem regisztrált szolgáltatáskészlet (accounts) és a funkciótárolóban (transactions) regisztrált szolgáltatáskészlet kombinációja betanítási adatokat hoz létre a gépi tanulási modellhez.

Válassza ki a modell funkcióit.

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

Helyileg generálja a betanítási adatokat.

Ez a lépés betanítási adatokat hoz létre szemléltető célokra. Lehetőségként helyileg is betanítást végezhet a modelleken. Az oktatóanyag későbbi lépései bemutatják, hogyan taníthat be modelleket a felhőben.

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

Regisztrálja a accounts funkciókészletet a funkciótárolóban.

Miután helyileg kísérletezett a funkciódefiníciókkal, és ésszerűnek tűnnek, regisztrálhat egy funkciókészlet-objektumdefiníciót a funkciótárolóban.

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

Szerezze be a regisztrált funkciókészletet, és tesztelje.

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

Betanítási kísérlet futtatása

A következő lépésekben kiválasztja a szolgáltatások listáját, futtat egy betanítási folyamatot, és regisztrálja a modellt. Ezeket a lépéseket addig ismételheti, amíg a modell a kívánt módon nem teljesít.

Igény szerint a funkciótár felhasználói felületének funkcióit is felfedezheti.

Az első oktatóanyag ezt a lépést fedte le, amikor regisztrálta a transactions funkciókészletet. Mivel rendelkezik szolgáltatáskészlettel accounts is, az elérhető funkciók között böngészhet:
1. Nyissa meg az Azure Machine Learning globális kezdőlapját.
2. A bal oldali panelen válassza a Szolgáltatástárolók lehetőséget.
3. A funkciótárolók listájában válassza ki a korábban létrehozott funkciótárolót.
A felhasználói felületen láthatók a létrehozott funkciókészletek és entitások. Válassza ki a funkciókészleteket a funkciódefiníciók tallózásához. A globális keresőmezővel funkciókészleteket kereshet a funkciótárolókban.

Igény szerint fedezze fel az SDK funkcióit.

# 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álassza ki a modell funkcióit, és exportálja a modellt funkciólekérési specifikációként.

Az előző lépésekben a regisztrált és nem regisztrált funkciókészletek kombinációjából választott ki funkciókat a helyi kísérletezéshez és teszteléshez. Most már kísérletezhet a felhőben. A modell szállítási rugalmassága nő, ha a kiválasztott funkciókat szolgáltatáslekérési specifikációként menti, majd a gépi tanulási műveletekben (MLOps) vagy a folyamatos integrációs és folyamatos teljesítésű (CI/CD) folyamatokban használja a specifikációt a betanításhoz és a következtetéshez.
1. Válassza ki a modell funkcióit.
```
# 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. Exportálja a kiválasztott funkciókat funkciólekérési specifikációként.
  
  A funkciólekérési specifikáció a modellhez társított funkciólista hordozható definíciója. Segíthet leegyszerűsíteni a gépi tanulási modellek fejlesztését és üzembe helyezését. A betanítási adatokat létrehozó betanítási folyamat bemenetévé válik. Ezután becsomagoltuk a modellel.
  
  A következtetési fázis a funkciólekérést használja a funkciók kereséséhez. A gépi tanulási életciklus minden fázisát integrálja. A betanítási/következtetési folyamat módosításai a kísérletezés és üzembe helyezés során minimálisan megmaradhatnak.
  
  A funkciólekérési specifikáció és a beépített funkciólekérési összetevő használata nem kötelező. Közvetlenül is használhatja az get_offline_features() API-t, ahogy azt korábban is láthattuk. A specifikáció nevének feature_retrieval_spec.yaml-nek kell lennie, ha a modellhez van csomagolva. Így a rendszer képes felismerni.
```
# 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)
```

Betanítása a felhőben folyamatok használatával, és a modell regisztrálása

Ebben az eljárásban manuálisan aktiválja a betanítási folyamatot. Éles környezetben egy CI/CD-folyamat aktiválhatja azt a forrásadattár funkciólekérési specifikációjának módosítása alapján. Ha megfelelő, regisztrálhatja a modellt.

Futtassa a betanítási folyamatot.

A betanítási folyamat a következő lépésekkel rendelkezik:
1. Funkciólekérés: A bemenethez ez a beépített összetevő a funkciólekérési specifikációt, a megfigyelési adatokat és az időbélyeg-oszlop nevét veszi figyelembe. Ezután kimenetként hozza létre a betanítási adatokat. Ezeket a lépéseket felügyelt Spark-feladatként futtatja.
2. Oktatás: A betanítási adatok alapján ez a lépés betanítást hajt végre a modellen, majd létrehoz egy modellt (még nincs regisztrálva).
3. Értékelés: Ez a lépés ellenőrzi, hogy a modell teljesítménye és minősége egy küszöbértékbe esik-e. (Ebben az oktatóanyagban ez egy helyőrző lépés illusztrációs célokra.)
4. A modell regisztrálása: Ez a lépés regisztrálja a modellt.
  
  Feljegyzés
  
  A második oktatóanyagban egy háttérbetöltési feladatot futtatott a transactions funkciókészlet adatainak materializálásához. A funkciólekérési lépés beolvassa a funkciókészlet offline áruházából származó funkcióértékeket. A viselkedés ugyanaz, még akkor is, ha az API-t get_offline_features() használja.
```
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. Vizsgálja meg a betanítási folyamatot és a modellt.
  - A folyamat lépéseinek megjelenítéséhez jelölje ki a webnézeti folyamat hivatkozását, és nyissa meg egy új ablakban.
Használja a funkciólekérési specifikációt a modellösszetevőkben:
1. Az aktuális munkaterület bal oldali ablaktábláján válassza a Jobb egérgombbal rendelkező Modellek lehetőséget .
2. Válassza a Megnyitás új lapon vagy ablakban lehetőséget.
3. Válassza fraud_model.
4. Válassza az Összetevők lehetőséget.
A funkciólekérési specifikáció a modellel együtt van csomagolva. Ezt a lépést a betanítási folyamat modellregisztrációs lépése kezelte. A kísérletezés során létrehozta a funkciólekérési specifikációt. Most már a modelldefiníció része. A következő oktatóanyagban láthatja, hogyan használja a következtetés.

A funkciókészlet és a modellfüggőségek megtekintése

Tekintse meg a modellhez társított funkciókészletek listáját.

Ugyanazon a Modellek lapon válassza a Funkciókészletek lapot. Ez a lap mind azokat a transactions accounts funkciókészleteket jeleníti meg, amelyektől ez a modell függ.
Tekintse meg a funkciókészleteket használó modellek listáját:
1. Nyissa meg a funkciótár felhasználói felületét (ezt az oktatóanyag korábbi szakasza ismerteti).
2. A bal oldali panelen válassza a Funkciókészletek lehetőséget.
3. Válasszon ki egy funkciókészletet.
4. Válassza a Modellek lapot.
A funkciólekérési specifikáció meghatározta ezt a listát, amikor a modell regisztrálva lett.

A fölöslegessé vált elemek eltávolítása

A sorozat ötödik oktatóanyaga az erőforrások törlését ismerteti.

Következő lépések

Lépjen a sorozat következő oktatóanyagára: Engedélyezze az ismétlődő materializálást, és futtassa a kötegelt következtetést.
További információ a funkciótár fogalmairól és az kezelt funkciótár legfelső szintű entitásairól.
Ismerje meg a kezelt funkciótár identitás- és hozzáférés-vezérlését.
Tekintse meg a kezelt funkciótár hibaelhárítási útmutatójában.
Tekintse meg a YAML-referenciát.

Megosztás a következőn keresztül: