Kurz 1: Vývoj a registrace sady funkcí v spravované uložiště funkcí

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í.

Pomocí služby Azure Machine Learning spravované uložiště funkcí můžete zjišťovat, vytvářet a zprovozňovat funkce. Životní cyklus strojového učení zahrnuje fázi vytváření prototypů, kde experimentujete s různými funkcemi. Zahrnuje také fázi operacionalizace, ve které se nasazují modely a kroky odvozování vyhledávají data funkcí. Funkce slouží jako spojovací tkáně v životním cyklu strojového učení. Další informace o základních konceptech spravované uložiště funkcí najdete v tématu Co je spravované uložiště funkcí? a Vysvětlení entit nejvyšší úrovně v spravované uložiště funkcí.

Tento kurz popisuje, jak vytvořit specifikaci sady funkcí s vlastními transformacemi. Tato sada funkcí pak použije ke generování trénovacích dat, povolení materializace a provedení backfillu. Materializace vypočítá hodnoty funkcí pro okno funkce a pak tyto hodnoty uloží do materializačního úložiště. Všechny dotazy na funkce pak mohou tyto hodnoty použít z úložiště materializace.

Bez materializace dotaz sady funkcí použije transformace na zdroj průběžně k výpočtu funkcí, než vrátí hodnoty. Tento proces funguje dobře pro fázi vytváření prototypů. Pro trénování a odvozování operací v produkčním prostředí však doporučujeme, abyste tyto funkce materializovali, abyste měli větší spolehlivost a dostupnost.

Tento kurz je první částí série kurzů spravované uložiště funkcí. Tady se dozvíte, jak:

Tato série kurzů má dvě stopy:

• Sledování pouze sady SDK používá pouze sady Python SDK. Tuto trasu vyberte pro čistý vývoj a nasazení založený na Pythonu.
• Sada SDK a sledování rozhraní příkazového řádku používají sadu Python SDK pouze pro vývoj a testování sady funkcí a používá rozhraní příkazového řádku pro operace CRUD (vytvoření, čtení, aktualizace a odstranění). Tato stopa je užitečná ve scénářích kontinuální integrace a průběžného doručování (CI/CD) nebo GitOps, kde se upřednostňuje rozhraní příkazového řádku nebo YAML.

Požadavky

Než budete pokračovat v tomto kurzu, nezapomeňte pokrýt tyto požadavky:

• Pracovní prostor služby Azure Machine Learning. Další informace o vytváření pracovních prostorů najdete v tématu Rychlý start: Vytvoření prostředků pracovního prostoru.

• V uživatelském účtu je role Vlastník skupiny prostředků, ve které se vytváří úložiště funkcí.

  Pokud se rozhodnete pro účely tohoto kurzu použít novou skupinu prostředků, můžete všechny prostředky snadno odstranit odstraněním skupiny prostředků.

Příprava prostředí poznámkového bloku

V tomto kurzu se pro vývoj používá poznámkový blok Sparku služby Azure Machine Learning.

1. V studio Azure Machine Learning prostředí vyberte Poznámkové bloky v levém podokně a pak vyberte kartu Ukázky.

2. Přejděte do adresáře featurestore_sample (vyberte Ukázkové>sady SDK v2>sdk>pythonu>featurestore_sample) a pak vyberte Klonovat.

   

3. Otevře se panel Vybrat cílový adresář . Vyberte adresář Uživatelé, pak vyberte své uživatelské jméno a nakonec vyberte Clone (Klonovat).

   

4. Pokud chcete nakonfigurovat prostředí poznámkového bloku, musíte nahrát soubor conda.yml :

   1. V levém podokně vyberte Poznámkové bloky a pak vyberte kartu Soubory .
   2. Přejděte do adresáře env (vyberte Uživatelé>your_user_name>featurestore_sample>projektu>env) a pak vyberte soubor conda.yml.
   3. Vyberte položku Stáhnout.

   

   1. V rozevíracím seznamu Výpočetní prostředky pro horní navigaci vyberte výpočetní prostředky Spark bez serveru. Tato operace může trvat jednu až dvě minuty. Počkejte na stavový řádek v horní části, aby se zobrazila relace Konfigurace.
   2. Na horním stavovém řádku vyberte Konfigurovat relaci .
   3. Vyberte balíčky Pythonu.
   4. Vyberte Nahrát soubory conda.
   5. conda.yml Vyberte soubor, který jste stáhli na místním zařízení.
   6. (Volitelné) Zvyšte časový limit relace (doba nečinnosti v minutách), abyste zkrátili dobu spouštění clusteru Spark bez serveru.

5. V prostředí Azure Machine Learning otevřete poznámkový blok a pak vyberte Konfigurovat relaci.

   

6. Na panelu Konfigurace relace vyberte balíčky Pythonu.

7. Nahrajte soubor Conda:

   1. Na kartě Balíčky Pythonu vyberte Nahrát soubor Conda.
   2. Přejděte do adresáře, který je hostitelem souboru Conda.
   3. Vyberte conda.yml a pak vyberte Otevřít.

   

8. Vyberte Použít.

   

Spuštění relace 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")

Nastavení kořenového adresáře pro ukázky

import os

# Please update <your_user_alias> below (or any custom directory you uploaded the samples to).
# You can find the name from the directory structure in the left navigation panel.
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")

Nastavení rozhraní CLI

Vytvoření minimálního úložiště funkcí

1. Nastavte parametry úložiště funkcí, včetně názvu, umístění a dalších hodnot.

   # We use the subscription, resource group, region of this active project workspace.
   # You can optionally replace them to create the resources in a different subsciprtion/resource group, or use existing resources.
   import os
   
   featurestore_name = "<FEATURESTORE_NAME>"
   featurestore_location = "eastus"
   featurestore_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
   featurestore_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]

2. Vytvořte úložiště funkcí.

   • Sledování sady SDK
   • Sledování sady SDK a rozhraní příkazového řádku

   from azure.ai.ml import MLClient
   from azure.ai.ml.entities import (
       FeatureStore,
       FeatureStoreEntity,
       FeatureSet,
   )
   from azure.ai.ml.identity import AzureMLOnBehalfOfCredential
   
   ml_client = MLClient(
       AzureMLOnBehalfOfCredential(),
       subscription_id=featurestore_subscription_id,
       resource_group_name=featurestore_resource_group_name,
   )
   
   
   fs = FeatureStore(name=featurestore_name, location=featurestore_location)
   # wait for feature store creation
   fs_poller = ml_client.feature_stores.begin_create(fs)
   print(fs_poller.result())

3. Inicializace základního klienta sady SDK úložiště funkcí pro Azure Machine Learning

   Jak jsme si vysvětlili dříve v tomto kurzu, základní klient sady SDK úložiště funkcí se používá k vývoji a využívání 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. Udělte vaší identitě uživatele roli Azure Machine Learning Datoví vědci v úložišti funkcí. Získejte hodnotu ID objektu Microsoft Entra z webu Azure Portal, jak je popsáno v tématu Vyhledání ID objektu uživatele.

   Přiřaďte k identitě uživatele Datoví vědci roli AzureML, aby mohl vytvářet prostředky v pracovním prostoru úložiště funkcí. Rozšíření oprávnění může nějakou dobu vyžadovat.

   Další informace o řízení přístupu najdete v tématu Správa řízení přístupu pro spravované uložiště funkcí.

   your_aad_objectid = "<USER_AAD_OBJECTID>"
   
   !az role assignment create --role "AzureML Data Scientist" --assignee-object-id $your_aad_objectid --assignee-principal-type User --scope $feature_store_arm_id

Prototyp a vývoj sady funkcí

V těchto krocích vytvoříte sadu funkcí s názvem transactions , která obsahuje agregované funkce založené na kumulativním okně:

1. Prozkoumejte zdrojová transactions data.

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

   # remove the "." in the roor directory path as we need to generate absolute path to read from spark
   transactions_source_data_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/transactions-source/*.parquet"
   transactions_src_df = spark.read.parquet(transactions_source_data_path)
   
   display(transactions_src_df.head(5))
   # Note: display(training_df.head(5)) displays the timestamp column in a different format. You can can call transactions_src_df.show() to see correctly formatted value

2. Místní vývoj sady funkcí

   Specifikace sady funkcí je samostatná definice sady funkcí, kterou můžete místně vyvíjet a testovat. Tady vytvoříte tyto agregační funkce se souhrnnými okny:

   • transactions three-day count
   • transactions amount three-day sum
   • transactions amount three-day avg
   • transactions seven-day count
   • transactions amount seven-day sum
   • transactions amount seven-day avg

   Projděte si soubor kódu transformace funkcí: featurestore/featuresets/transactions/transformation_code/transaction_transform.py. Poznamenejte si průběžnou agregaci definovanou pro funkce. Jedná se o transformátor Sparku.

   Další informace o sadě funkcí a transformacích najdete v tématu Co je spravované uložiště funkcí?.

   from azureml.featurestore import create_feature_set_spec
   from azureml.featurestore.contracts import (
       DateTimeOffset,
       TransformationCode,
       Column,
       ColumnType,
       SourceType,
       TimestampColumn,
   )
   from azureml.featurestore.feature_source import ParquetFeatureSource
   
   transactions_featureset_code_path = (
       root_dir + "/featurestore/featuresets/transactions/transformation_code"
   )
   
   transactions_featureset_spec = create_feature_set_spec(
       source=ParquetFeatureSource(
           path="wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/transactions-source/*.parquet",
           timestamp_column=TimestampColumn(name="timestamp"),
           source_delay=DateTimeOffset(days=0, hours=0, minutes=20),
       ),
       feature_transformation=TransformationCode(
           path=transactions_featureset_code_path,
           transformer_class="transaction_transform.TransactionFeatureTransformer",
       ),
       index_columns=[Column(name="accountID", type=ColumnType.string)],
       source_lookback=DateTimeOffset(days=7, hours=0, minutes=0),
       temporal_join_lookback=DateTimeOffset(days=1, 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é tuto specifikaci uložit v určitém formátu.

   Zkontrolujte vygenerovanou transactions specifikaci sady funkcí. Otevřete tento soubor ze stromu souborů a podívejte se na specifikaci: featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml.

   Specifikace obsahuje tyto 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ů. Pokud zadáte transformační kód, musí kód vrátit datový rámec, který se mapuje na funkce a datové typy.
   • index_columns: Klíče spojení potřebné pro přístup k hodnotám ze sady funkcí.

   Další informace o specifikaci najdete v tématu Principy entit nejvyšší úrovně ve schématu YAML v sadě funkcí spravované uložiště funkcí a rozhraní příkazového řádku (v2).

   Zachování specifikace sady funkcí nabízí další výhodu: specifikace sady funkcí může být řízena zdrojem.

   import os
   
   # Create a new folder to dump the feature set specification.
   transactions_featureset_spec_folder = (
       root_dir + "/featurestore/featuresets/transactions/spec"
   )
   
   # Check if the folder exists, create one if it does not exist.
   if not os.path.exists(transactions_featureset_spec_folder):
       os.makedirs(transactions_featureset_spec_folder)
   
   transactions_featureset_spec.dump(transactions_featureset_spec_folder, overwrite=True)

Registrace entity úložiště funkcí

Osvědčeným postupem je, že entity pomáhají vynucovat použití stejné definice klíče spojení napříč sadami funkcí, které používají stejné logické entity. Příklady entit zahrnují účty a zákazníky. Entity se obvykle vytvářejí jednou a pak se znovu používají napříč sadami funkcí. Další informace najdete v tématu Principy entit nejvyšší úrovně v spravované uložiště funkcí.

Registrace sady funkcí transakce v úložišti funkcí

Tento kód použijte k registraci prostředku sady funkcí v úložišti funkcí. Tento prostředek pak můžete znovu použít a snadno ho sdílet. Registrace prostředku sady funkcí nabízí spravované funkce, včetně správy verzí a materializace. Další kroky v této sérii kurzů se týkají spravovaných funkcí.

from azure.ai.ml.entities import FeatureSetSpecification

transaction_fset_config = FeatureSet(
    name="transactions",
    version="1",
    description="7-day and 3-day rolling aggregation of transactions featureset",
    entities=[f"azureml:account:1"],
    stage="Development",
    specification=FeatureSetSpecification(path=transactions_featureset_spec_folder),
    tags={"data_type": "nonPII"},
)

poller = fs_client.feature_sets.begin_create_or_update(transaction_fset_config)
print(poller.result())

account_featureset_path = (
    root_dir + "/featurestore/featuresets/transactions/featureset_asset.yaml"
)
!az ml feature-set create --file $account_featureset_path --resource-group $featurestore_resource_group_name --feature-store-name $featurestore_name

Prozkoumání uživatelského rozhraní úložiště funkcí

Vytváření a aktualizace prostředků úložiště funkcí se můžou provádět jenom prostřednictvím sady SDK a rozhraní příkazového řádku. Uživatelské rozhraní můžete použít k vyhledávání nebo procházení úložiště funkcí:

1. Otevřete globální cílovou stránku služby Azure Machine Learning.
2. V levém podokně vyberte Úložiště funkcí.
3. V seznamu dostupných úložišť funkcí vyberte úložiště funkcí, které jste vytvořili dříve v tomto kurzu.

Udělení přístupu k uživatelskému účtu v offline úložišti roli Čtenář dat objektů blob služby Storage

Role Čtenář dat objektů blob služby Storage musí být přiřazena k vašemu uživatelskému účtu v offline úložišti. Tím se zajistí, že uživatelský účet může číst materializovaná data funkcí z offline úložiště materializace.

Generování datového rámce trénovacích dat pomocí registrované sady funkcí

1. Načtení dat pozorování

   Data pozorování obvykle zahrnují základní data používaná pro trénování a odvozování. Tato data se spojí s daty funkcí a vytvoří úplný trénovací datový prostředek.

   Data pozorování jsou data zachycená během samotné události. Obsahuje zde základní transakční data, včetně ID transakce, ID účtu a hodnot množství transakcí. Protože ho používáte pro trénování, má také připojenou cílovou proměnnou (is_fraud).

   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"
   
   display(observation_data_df)
   # Note: the timestamp column is displayed in a different format. Optionally, you can can call training_df.show() to see correctly formatted value

2. Získejte zaregistrovanou sadu funkcí a uveďte její funkce.

   # Look up the featureset by providing a name and a version.
   transactions_featureset = featurestore.feature_sets.get("transactions", "1")
   # List its features.
   transactions_featureset.features

   # Print sample values.
   display(transactions_featureset.to_spark_dataframe().head(5))

3. Vyberte funkce, které se stanou součástí trénovacích dat. Pak pomocí sady SDK úložiště funkcí vygenerujte samotná trénovací data.

   from azureml.featurestore import get_offline_features
   
   # You can select features in pythonic way.
   features = [
       transactions_featureset.get_feature("transaction_amount_7d_sum"),
       transactions_featureset.get_feature("transaction_amount_7d_avg"),
   ]
   
   # You can also specify features in string form: featureset:version:feature.
   more_features = [
       f"transactions:1:transaction_3d_count",
       f"transactions:1:transaction_amount_3d_avg",
   ]
   
   more_features = featurestore.resolve_feature_uri(more_features)
   features.extend(more_features)
   
   # 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 subsequent part of the tutorial.
   display(training_df)
   # Note: the timestamp column is displayed in a different format. Optionally, you can can call training_df.show() to see correctly formatted value

   Spojení k určitému bodu v čase připojí funkce k trénovacím datům.

Povolení offline materializace v transactions sadě funkcí

Po povolení materializace sady funkcí můžete provést obnovení. Můžete také naplánovat opakující se materializační úlohy. Další informace najdete v třetím kurzu série.

from azure.ai.ml.entities import (
    MaterializationSettings,
    MaterializationComputeResource,
)

transactions_fset_config = fs_client._featuresets.get(name="transactions", version="1")

transactions_fset_config.materialization_settings = MaterializationSettings(
    offline_enabled=True,
    resource=MaterializationComputeResource(instance_type="standard_e8s_v3"),
    spark_configuration={
        "spark.driver.cores": 4,
        "spark.driver.memory": "36g",
        "spark.executor.cores": 4,
        "spark.executor.memory": "36g",
        "spark.executor.instances": 2,
        "spark.sql.shuffle.partitions": 1,
    },
    schedule=None,
)

fs_poller = fs_client.feature_sets.begin_create_or_update(transactions_fset_config)
print(fs_poller.result())

transaction_asset_mat_yaml = (
    root_dir
    + "/featurestore/featuresets/transactions/featureset_asset_offline_enabled.yaml"
)

!az ml feature-set update --file $transaction_asset_mat_yaml --resource-group $featurestore_resource_group_name --feature-store-name $featurestore_name

Prostředek sady funkcí můžete také uložit jako prostředek YAML.

## uncomment to run
transactions_fset_config.dump(
    root_dir
    + "/featurestore/featuresets/transactions/featureset_asset_offline_enabled.yaml"
)

Data obnovení pro transactions sadu funkcí

Jak bylo vysvětleno dříve, materializace vypočítá hodnoty funkcí pro okno funkce a uloží tyto vypočítané hodnoty do materializačního úložiště. Materializace funkcí zvyšuje spolehlivost a dostupnost vypočítaných hodnot. Všechny dotazy na funkce teď používají hodnoty z úložiště materializace. Tento krok provede jednorázové obnovení v časovém intervalu 18 měsíců.

from datetime import datetime
from azure.ai.ml.entities import DataAvailabilityStatus

st = datetime(2022, 1, 1, 0, 0, 0, 0)
et = datetime(2023, 6, 30, 0, 0, 0, 0)

poller = fs_client.feature_sets.begin_backfill(
    name="transactions",
    version="1",
    feature_window_start_time=st,
    feature_window_end_time=et,
    data_status=[DataAvailabilityStatus.NONE],
)
print(poller.result().job_ids)

# Get the job URL, and stream the job logs.
fs_client.jobs.stream(poller.result().job_ids[0])

feature_window_start_time = "2022-01-01T00:00.000Z"
feature_window_end_time = "2023-06-30T00:00.000Z"

!az ml feature-set backfill --name transactions --version 1 --by-data-status "['None', 'Incomplete']" --feature-window-start-time $feature_window_start_time --feature-window-end-time $feature_window_end_time --feature-store-name $featurestore_name --resource-group $featurestore_resource_group_name

Vytiskněte ukázková data ze sady funkcí. Výstupní informace ukazují, že data byla načtena z úložiště materializace. Metoda get_offline_features() načetla trénovací a odvozovací data. Ve výchozím nastavení používá také úložiště materializace.

# Look up the feature set by providing a name and a version and display few records.
transactions_featureset = featurestore.feature_sets.get("transactions", "1")
display(transactions_featureset.to_spark_dataframe().head(5))

Další prozkoumání materializace funkcí offline

Stav materializace funkcí pro sadu funkcí můžete prozkoumat v uživatelském rozhraní materializačních úloh .

1. Otevřete globální cílovou stránku služby Azure Machine Learning.

2. V levém podokně vyberte Úložiště funkcí.

3. V seznamu dostupných úložišť funkcí vyberte úložiště funkcí, pro které jste provedli obnovení.

4. Vyberte kartu Úlohy materializace.

   

• Stav materializace dat může být

  • Dokončeno (zelená)
  • Neúplné (červené)
  • Čeká na vyřízení (modrá)
  • Žádná (šedá)

• Interval dat představuje souvislou část dat se stejným stavem materializace dat. Například předchozí snímek má v offline úložišti materializace 16 datových intervalů .

• Data můžou mít maximálně 2 000 datových intervalů. Pokud data obsahují více než 2 000 datových intervalů, vytvořte novou verzi sady funkcí.

• Seznam více než jednoho stavu dat (například ["None", "Incomplete"]) můžete zadat v jedné úloze obnovení.

• Během obnovení se odešle nová úloha materializace pro každý interval dat, který spadá do definovaného okna funkce.

• Pokud je úloha materializace nevyřízená nebo je tato úloha spuštěná pro interval dat, který ještě nebyl znovu vyplněný, nová úloha se pro tento interval dat neodesílají.

• Můžete zkusit znovu neúspěšnou úlohu materializace.

  Poznámka:

  Získání ID úlohy neúspěšné materializace:

  • Přejděte do uživatelského rozhraní úloh materializace sady funkcí .
  • Vyberte zobrazovaný název konkrétní úlohy se stavem Selhání.
  • Na stránce Přehled úlohy vyhledejte ID úlohy pod vlastností Název. Začíná Featurestore-Materialization-na .

poller = fs_client.feature_sets.begin_backfill(
    name="transactions",
    version=version,
    job_id="<JOB_ID_OF_FAILED_MATERIALIZATION_JOB>",
)
print(poller.result().job_ids)

az ml feature-set backfill --by-job-id <JOB_ID_OF_FAILED_MATERIALIZATION_JOB> --name <FEATURE_SET_NAME> --version <VERSION>  --feature-store-name <FEATURE_STORE_NAME> --resource-group <RESOURCE_GROUP>

Aktualizace úložiště materializace offline

• Pokud je nutné aktualizovat offline materializační úložiště na úrovni úložiště funkcí, všechny sady funkcí v úložišti funkcí by měly mít vypnutou offline materializaci.
• Pokud je offline materializace v sadě funkcí zakázaná, stav materializace dat, která jsou už materializovaná v offline úložišti materializace, resetuje. Reset vykreslí data, která jsou již materializovaná nepoužitelná. Po povolení offline materializace musíte znovu odeslat úlohy materializace.

Tento kurz vytvořil trénovací data s funkcemi z úložiště funkcí, povolil materializaci do offline úložiště funkcí a provedl backfill. V dalším kroku spustíte trénování modelu pomocí těchto funkcí.

Vyčištění

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

Další kroky

• Podívejte se na další kurz série: Experimentování a trénování modelů pomocí funkcí.
• Seznamte se s koncepty úložiště funkcí a entitami nejvyšší úrovně v spravované uložiště funkcí.
• Seznamte se s identitou a řízením přístupu pro spravované uložiště funkcí.
• Prohlédnutí průvodce odstraňováním potíží pro spravované uložiště funkcí
• Umožňuje zobrazit referenční informace k YAML.