Kurz 2: Experimentování a trénování modelů pomocí funkcí

  • Článek

Tato série kurzů ukazuje, jak funkce bezproblémově integrují všechny fáze životního cyklu strojového učení: vytváření prototypů, trénování a zprovoznění.

První kurz ukázal, jak vytvořit specifikaci sady funkcí s vlastními transformacemi a pak pomocí této sady funkcí vygenerovat trénovací data, povolit materializaci a provést obnovení. V tomto kurzu se dozvíte, jak povolit materializaci a provést obnovení. Ukazuje také, jak experimentovat s funkcemi, jako způsob, jak zlepšit výkon modelu.

V tomto kurzu se naučíte:

  • Vytvoření prototypu nové accounts specifikace sady funkcí pomocí existujících předpočítaných hodnot jako funkcí Pak zaregistrujte specifikaci místní sady funkcí jako sadu funkcí v úložišti funkcí. Tento proces se liší od prvního kurzu, ve kterém jste vytvořili sadu funkcí s vlastními transformacemi.
  • Vyberte funkce modelu ze transactions sad funkcí a accounts uložte je jako specifikaci načítání funkcí.
  • Spusťte trénovací kanál, který k trénování nového modelu používá specifikaci načtení funkce. Tento kanál používá integrovanou součást načítání funkcí k vygenerování trénovacích dat.

Požadavky

Než budete pokračovat v tomto kurzu, nezapomeňte dokončit první kurz série.

Nastavení

  1. Nakonfigurujte poznámkový blok Spark služby Azure Machine Learning.

    Můžete vytvořit nový poznámkový blok a krok za krokem spustit pokyny v tomto kurzu. Můžete také otevřít a spustit existující poznámkový blok s názvem 2.Experiment-train-models-using-features.ipynb z adresáře featurestore_sample/notebooks . Můžete zvolit sdk_only nebo sdk_and_cli. Nechte si tento kurz otevřený a projděte si ho, kde najdete odkazy na dokumentaci a další vysvětlení.

    1. V horní nabídce v rozevíracím seznamu Compute vyberte bezserverové výpočetní prostředí Spark v části Bezserverová sparková služba Azure Machine Learning.

    2. Konfigurace relace:

      1. Když se na panelu nástrojů zobrazí konfigurace relace, vyberte ji.
      2. Na kartě Balíčky Pythonu vyberte Nahrát soubor Conda.
      3. Nahrajte soubor conda.yml, který jste nahráli v prvním kurzu.
      4. Volitelně můžete zvýšit časový limit relace (dobu nečinnosti), abyste se vyhnuli častým opakovaným spuštěním požadavků.

  2. Spusťte relaci Sparku.

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

  3. Nastavte kořenový adresář pro ukázky.

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

  4. Nastavte rozhraní příkazového řádku.

    Nevztahuje se.

  1. Inicializuje proměnné pracovního prostoru projektu.

    Toto je aktuální pracovní prostor a poznámkový blok kurzu běží v tomto prostředku.

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

  2. Inicializace proměnných úložiště funkcí

    Nezapomeňte aktualizovat featurestore_name hodnoty tak featurestore_location , aby odrážely to, co jste vytvořili v prvním kurzu.

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

  3. Inicializace klienta úložiště funkcí

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

  4. Vytvořte výpočetní cluster s názvem cpu-cluster v pracovním prostoru projektu.

    Tento výpočetní cluster potřebujete, když spustíte úlohy trénování nebo dávkového odvozování.

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

Vytvoření sady funkcí účtů v místním prostředí

V prvním kurzu jste vytvořili transactions sadu funkcí, která měla vlastní transformace. Tady vytvoříte accounts sadu funkcí, která používá předpočítané hodnoty.

Pokud chcete připojit předpočítané funkce, můžete vytvořit specifikaci sady funkcí, aniž byste museli psát kód transformace. Specifikace sady funkcí slouží k vývoji a testování sady funkcí v plně místním vývojovém prostředí.

Nemusíte se připojovat k úložišti funkcí. V tomto postupu vytvoříte specifikaci sady funkcí místně a pak z ní vzorkujete hodnoty. Pro možnosti spravované uložiště funkcí je nutné použít definici prostředku funkce k registraci specifikace sady funkcí v úložišti funkcí. Další podrobnosti najdete v dalších krocích v tomto kurzu.

  1. Prozkoumejte zdrojová data pro účty.

    Poznámka:

    Tento poznámkový blok používá ukázková data hostovaná v veřejně přístupném kontejneru objektů blob. Ve Sparku wasbs ho může číst jenom ovladač. Když vytváříte sady funkcí pomocí vlastních zdrojových dat, hostujte tyto sady funkcí v účtu Azure Data Lake Storage Gen2 a použijte abfss ovladač v cestě k datům.

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

  2. Vytvořte specifikaci accounts sady funkcí místně z těchto předpočítaných funkcí.

    Tady nepotřebujete žádný transformační kód, protože odkazujete na předpočítané funkce.

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

  3. Exportovat jako specifikaci sady funkcí

    Chcete-li zaregistrovat specifikaci sady funkcí v úložišti funkcí, je nutné uložit specifikaci sady funkcí v určitém formátu.

    Po spuštění další buňky zkontrolujte vygenerovanou accounts specifikaci sady funkcí. Pokud chcete zobrazit specifikaci, otevřete soubor featurestore/featuresets/accounts/spec/FeatureSetSpec.yaml ze stromu souborů.

    Specifikace má tyto důležité prvky:

    • source: Odkaz na prostředek úložiště. V tomto případě se jedná o soubor Parquet v prostředku úložiště objektů blob.

    • features: Seznam funkcí a jejich datových typů. Při poskytnutém transformačním kódu musí kód vrátit datový rámec, který se mapuje na funkce a datové typy. Bez poskytnutého transformačního kódu systém sestaví dotaz, který mapuje funkce a datové typy na zdroj. V tomto případě specifikace vygenerované accounts sady funkcí neobsahuje transformační kód, protože jsou předpočítané funkce.

    • index_columns: Klíče spojení potřebné pro přístup k hodnotám ze sady funkcí.

    Další informace najdete v tématu Vysvětlení entit nejvyšší úrovně v spravované uložiště funkcí a schématu YAML specifikace sady funkcí ROZHRANÍ příkazového řádku (v2).

    Zachování navíc podporuje správu zdrojového kódu.

    Tady nepotřebujete žádný transformační kód, protože odkazujete na předpočítané funkce.

    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)

Místní experimentování s neregistrovanými funkcemi a registrace v úložišti funkcí, až bude připraveno

Při vývoji funkcí můžete chtít místně otestovat a ověřit je, než je zaregistrujete v úložišti funkcí nebo spustíte trénovací kanály v cloudu. Kombinace místní neregistrované sady funkcí (accounts) a sady funkcí zaregistrované v úložišti funkcí (transactions) generují trénovací data pro model strojového učení.

  1. Vyberte funkce modelu.

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

  2. Místně generují trénovací data.

    Tento krok generuje trénovací data pro ilustrativní účely. Jako možnost můžete modely trénovat místně tady. Další kroky v tomto kurzu vysvětlují, jak vytrénovat model v cloudu.

    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

  3. accounts Zaregistrujte sadu funkcí v úložišti funkcí.

    Po místním experimentování s definicemi funkcí a zdá se, že jsou rozumné, můžete zaregistrovat definici assetu sady funkcí v úložišti funkcí.

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

  4. Získejte zaregistrovanou sadu funkcí a otestujte ji.

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

Spuštění trénovacího experimentu

V následujících krocích vyberete seznam funkcí, spustíte trénovací kanál a zaregistrujete model. Tyto kroky můžete opakovat, dokud model nebude fungovat podle potřeby.

  1. Volitelně můžete zjistit funkce z uživatelského rozhraní úložiště funkcí.

    První kurz probral tento krok, když jste zaregistrovali transactions sadu funkcí. Vzhledem k tomu, že máte accounts také sadu funkcí, můžete procházet dostupné funkce:

    1. Přejděte na globální cílovou stránku služby Azure Machine Learning.
    2. V levém podokně vyberte Úložiště funkcí.
    3. V seznamuúložišťch

    Uživatelské rozhraní zobrazuje sady funkcí a entitu, kterou jste vytvořili. Vyberte sady funkcí a projděte si definice funkcí. Globální vyhledávací pole můžete použít k vyhledání sad funkcí napříč úložišti funkcí.

  2. Volitelně můžete vyhledat funkce ze sady SDK.

    # 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

  3. Vyberte funkce modelu a vyexportujte model jako specifikaci načtení funkce.

    V předchozíchkrocích Teď můžete experimentovat v cloudu. Flexibilita při přesouvání modelů se zvyšuje, pokud vybrané funkce uložíte jako specifikaci načítání funkcí a pak použijete specifikaci v rámci operací strojového učení (MLOps) nebo toku kontinuální integrace a průběžného doručování (CI/CD) pro trénování a odvozování.

    1. Vyberte funkce modelu.

      # 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 vybraných funkcí jako specifikace načítání funkcí

      Specifikace načtení funkce je přenosná definice seznamu funkcí přidružených k modelu. Může pomoct zjednodušit vývoj a operacionalizaci modelu strojového učení. Stane se vstupem do trénovacího kanálu, který generuje trénovací data. Pak se zabalí s modelem.

      Fáze odvozování používá k vyhledání funkcí načtení funkcí. Integruje všechny fáze životního cyklu strojového učení. Změny kanálu trénování a odvozování můžou zůstat minimálně při experimentování a nasazování.

      Použití specifikace načtení funkce a integrované součásti načítání funkcí je volitelné. Rozhraní API můžete přímo použít get_offline_features() , jak je znázorněno výše. Název specifikace by měl být feature_retrieval_spec.yaml , když je zabalený s modelem. Systém ho tak dokáže rozpoznat.

      # 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énování v cloudu pomocí kanálů a registrace modelu

V tomto postupu ručně aktivujete trénovací kanál. V produkčním scénáři by ho kanál CI/CD mohl aktivovat na základě změn specifikace načtení funkce ve zdrojovém úložišti. Model můžete zaregistrovat, pokud je uspokojivý.

  1. Spusťte trénovací kanál.

    Trénovací kanál má tyto kroky:

    1. Načtení funkce: Pro svůj vstup přebírá tato integrovaná komponenta specifikaci načtení funkce, data pozorování a název sloupce s časovým razítkem. Potom vygeneruje trénovací data jako výstup. Tento postup se spustí jako spravovaná úloha Sparku.

    2. Trénování: Na základě trénovacích dat tento krok trénuje model a pak vygeneruje model (ještě není zaregistrovaný).

    3. Vyhodnocení: Tento krok ověří, jestli výkon a kvalita modelu spadají do prahové hodnoty. (V tomto kurzu se jedná o zástupný krok pro ilustraci.)

    4. Registrace modelu: Tento krok zaregistruje model.

      Poznámka:

      V druhém kurzu jste spustili úlohu backfillu pro materializaci dat pro transactions sadu funkcí. Krok načtení funkce čte hodnoty funkcí z offline úložiště pro tuto sadu funkcí. Chování je stejné, i když používáte get_offline_features() rozhraní API.

      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. Zkontrolujte trénovací kanál a model.

      • Pokud chcete zobrazit kroky kanálu, vyberte hypertextový odkaz pro kanál webového zobrazení a otevřete ho v novém okně.

  2. Použijte specifikaci načítání funkcí v artefaktech modelu:

    1. V levém podokně aktuálního pracovního prostoru vyberte Modely s pravým tlačítkem myši.
    2. Vyberte Otevřít v nové kartě nebo okně.
    3. Vyberte fraud_model.
    4. Vyberte Artefakty.

    Specifikace načítání funkcí je zabalena spolu s modelem. Tento krok zvládl krok registrace modelu v kanálu trénování. Během experimentování jste vytvořili specifikaci načítání funkcí. Teď je součástí definice modelu. V dalším kurzu se dozvíte, jak ho odvozování používá.

Zobrazení sady funkcí a závislostí modelu

  1. Zobrazí seznam sad funkcí přidružených k modelu.

    Na stejné stránce Modely vyberte kartu Sady funkcí. Tato karta zobrazuje transactions accounts sady funkcí, na kterých tento model závisí.

  2. Prohlédněte si seznam modelů, které používají sady funkcí:

    1. Otevřete uživatelské rozhraní úložiště funkcí (vysvětleno výše v tomto kurzu).
    2. V levém podokně vyberte Sady funkcí.
    3. Vyberte sadu funkcí.
    4. Vyberte kartu Modely.

    Specifikace načtení funkce určila tento seznam při registraci modelu.

Vyčištění

Pátý kurz v řadě popisuje, jak odstranit prostředky.

Další kroky