Share via

Kurz 1: Vývoj a registrace sady funkcí v spravované uložiště 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í.

Azure Machine Učení spravované uložiště funkcí můžete použít ke zjišťování, vytváření a zprovoznění funkcí. Ž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:

  • Vytvořte nový minimální prostředek úložiště funkcí.
  • Vývoj a místní testování sady funkcí s možností transformace funkcí
  • Zaregistrujte entitu úložiště funkcí v úložišti funkcí.
  • Zaregistrujte sadu funkcí, kterou jste vytvořili v úložišti funkcí.
  • Vygenerujte ukázkový trénovací datový rámec pomocí funkcí, které jste vytvořili.
  • Povolte v sadách funkcí offline materializaci a vyplňte data funkcí.

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 k vývoji používá poznámkový blok Spark Učení Azure Machine.

  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.

    Snímek obrazovky znázorňující výběr ukázkového adresáře v studio Azure Machine Learning

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

    Snímek obrazovky znázorňující výběr umístění cílového adresáře v studio Azure Machine Learning ukázkového prostředku

  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.

    Snímek obrazovky znázorňující výběr souboru Conda YAML v studio Azure Machine Learning

    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 Učení otevřete poznámkový blok a pak vyberte Konfigurovat relaci.

    Snímek obrazovky znázorňující výběry pro konfiguraci relace pro poznámkový blok

  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.

    Snímek obrazovky znázorňující adresář, který je hostitelem souboru Conda

  8. Vyberte Použít.

    Snímek obrazovky znázorňující nahrání souboru Conda

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

Nevztahuje se.

Poznámka:

Úložiště funkcí se používá k opakovanému použití funkcí napříč projekty. K trénování modelů odvozování použijete pracovní prostor projektu (pracovní prostor Azure Machine Učení) tím, že využijete výhod funkcí z úložišť funkcí. Mnoho pracovních prostorů projektu může sdílet a opakovaně používat stejné úložiště funkcí.

V tomto kurzu se používají dvě sady SDK:

  • Sada CRUD SDK úložiště funkcí

    Použijete stejnou MLClient sadu SDK (název azure-ai-mlbalíčku), kterou používáte s pracovním prostorem Azure Machine Učení. Úložiště funkcí se implementuje jako typ pracovního prostoru. V důsledku toho se tato sada SDK používá pro operace CRUD pro úložiště funkcí, sady funkcí a entity úložiště funkcí.

  • Základní sada SDK úložiště funkcí

    Tato sada SDK (azureml-featurestore) je určená pro vývoj a spotřebu sady funkcí. Další kroky v tomto kurzu popisují tyto operace:

    • Vytvořte specifikaci sady funkcí.
    • Načtení dat funkcí
    • Zobrazení seznamu nebo získání registrované sady funkcí
    • Generování a řešení specifikací načítání funkcí
    • Generování trénovacích a odvozovacích dat pomocí spojení k určitému bodu v čase

Tento kurz nevyžaduje explicitní instalaci těchto sad SDK, protože předchozí conda.yml pokyny se týkají tohoto kroku.

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

    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 Učení Azure Machine

    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 roli Azure Machine Učení Datoví vědci v úložišti funkcí vaší identitě uživatele. 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í.

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

    Jak jsme si vysvětlili dříve v tomto kurzu, MLClient používá se k vytváření, čtení, aktualizaci a odstraňování prostředku úložiště funkcí. Ukázka buňky kódu poznámkového bloku, která se tady zobrazuje, hledá úložiště funkcí, které jste vytvořili v předchozím kroku. Tady nemůžete znovu použít stejnou ml_client hodnotu, kterou jste použili dříve v tomto kurzu, protože je vymezená na úrovni skupiny prostředků. Správné nastavení rozsahu je předpokladem pro vytvoření úložiště funkcí.

    V této ukázce kódu je klient vymezen na úrovni úložiště funkcí.

    # MLClient for feature store.
fs_client = MLClient(
    AzureMLOnBehalfOfCredential(),
    featurestore_subscription_id,
    featurestore_resource_group_name,
    featurestore_name,
)

  2. Zaregistrujte entitu account v úložišti funkcí.

    Vytvořte entitu account , která má klíč accountID spojení typu string.

    from azure.ai.ml.entities import DataColumn, DataColumnType

account_entity_config = FeatureStoreEntity(
    name="account",
    version="1",
    index_columns=[DataColumn(name="accountID", type=DataColumnType.STRING)],
    stage="Development",
    description="This entity represents user account index key accountID.",
    tags={"data_typ": "nonPII"},
)

poller = fs_client.feature_store_entities.begin_create_or_update(account_entity_config)
print(poller.result())

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

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 Azure Machine Učení.
  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.

  1. Získejte hodnotu ID objektu Microsoft Entra z webu Azure Portal, jak je popsáno v tématu Vyhledání ID objektu uživatele.

  2. Získejte informace o offline úložišti materializace ze stránky Přehled úložiště funkcí v uživatelském rozhraní úložiště funkcí. Hodnoty PRO ID předplatného účtu úložiště, název skupiny prostředků účtu úložiště a název účtu úložiště pro úložiště offline materializace najdete na kartě úložiště materializace offline.

    Snímek obrazovky znázorňující informace o účtu offline úložiště na stránce Přehled úložiště funkcí

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

    Spusťte tuto buňku kódu pro přiřazení role. Rozšíření oprávnění může nějakou dobu vyžadovat.

    # This utility function is created for ease of use in the docs tutorials. It uses standard azure API's.
# You can optionally inspect it `featurestore/setup/setup_storage_uai.py`.
import sys

sys.path.insert(0, root_dir + "/featurestore/setup")
from setup_storage_uai import grant_user_aad_storage_data_reader_role

your_aad_objectid = "<USER_AAD_OBJECTID>"
storage_subscription_id = "<SUBSCRIPTION_ID>"
storage_resource_group_name = "<RESOURCE_GROUP>"
storage_account_name = "<STORAGE_ACCOUNT_NAME>"

grant_user_aad_storage_data_reader_role(
    AzureMLOnBehalfOfCredential(),
    your_aad_objectid,
    storage_subscription_id,
    storage_resource_group_name,
    storage_account_name,
)

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.

Nastavte v souboru yaml spark.sql.shuffle.partitions podle velikosti dat funkce.

Konfigurace spark.sql.shuffle.partitions Sparku je volitelný parametr, který může ovlivnit počet souborů parquet vygenerovaných (za den), když je sada funkcí materializována do offline úložiště. Výchozí hodnota tohoto parametru je 200. Osvědčeným postupem je vyhnout se generování mnoha malých parketových souborů. Pokud se načítání offline funkcí po materializaci sady funkcí zpomalí, přejděte do odpovídající složky v offline úložišti a zkontrolujte, jestli problém neobsahuje příliš mnoho malých souborů parquet (za den) a odpovídajícím způsobem upravte hodnotu tohoto parametru.

Poznámka:

Ukázková data použitá v tomto poznámkovém bloku jsou malá. Proto je tento parametr v souboru featureset_asset_offline_enabled.yaml nastaven na hodnotu 1.

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

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

Poznámka:

Možná budete muset určit hodnotu okna backfillu. Okno se musí shodovat s oknem trénovacích dat. Pokud například chcete pro trénování použít 18 měsíců dat, musíte načíst funkce po dobu 18 měsíců. To znamená, že byste měli znovu vyplňovat 18měsíční interval.

Tato buňka kódu materializuje data podle aktuálního stavu Žádné nebo Neúplné pro definované okno funkce.

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

Tip

  • Sloupec timestamp by měl následovat podle yyyy-MM-ddTHH:mm:ss.fffZ formátu.
  • Členitost feature_window_start_time je feature_window_end_time omezená na sekundy. Všechny milisekundy zadané v objektu datetime budou ignorovány.
  • Úloha materializace bude odeslána pouze v případě, že data v okně funkce odpovídají definovanému data_status při odesílání úlohy backfillu.

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 Azure Machine Učení.

  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.

    Snímek obrazovky znázorňující uživatelské rozhraní materializačních úloh sady funkcí

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

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