Sdílet prostřednictvím

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í. Pro více informací o základních pojmech spravovaného úložiště funkcí navštivte prostředky Co je spravované úložiště funkcí? a Pochopení entit nejvyšší úrovně ve spravovaném úložišti 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 rychlém startu: Vytvoření prostředků pracovního prostoru.

  • V uživatelském účtu potřebujete roli Vlastník pro skupinu prostředků, ve které se vytvoří ú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 prostředí Azure Machine Learning studio 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ázky>SDK v2>sdk>Python>featurestore_sample) a pak vyberte Klonovat.

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

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

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

  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 Stáhnout.

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

    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, až se v horní části stavového řádku zobrazí Konfigurace relace.
    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.

    Snímek obrazovky, který znázorňuje 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 Learning), který využívá funkce 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:

  • CRUD SDK pro správu ú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 Learning. Ú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í.

  • Feature store – základní sada SDK

    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 zahrnují tento krok.

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 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 roli Datového vědce AzureML k vaší uživatelské identitě, aby mohl vytvářet prostředky v pracovním prostoru feature store. Rozšíření oprávnění může nějakou dobu vyžadovat.

    Další informace o řízení přístupu najdete v tématu Spravované úložiště funkcí – řízení přístupu.

    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 avg
    • transactions amount three-day sum
    • transactions seven-day count
    • transactions amount seven-day avg
    • transactions amount seven-day sum

    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 prostředku Co je spravované úlož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 Pochopení entit nejvyšší úrovně ve spravovaném feature store a v prostředcích YAML schématu sady funkcí CLI (v2).

    Zachování specifikace sady funkcí nabízí další výhodu: specifikace sady funkcí podporuje správu zdrojového kódu.

    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ě ve spravovaném úložišti funkcí.

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

    Jak je vysvětleno dříve v tomto kurzu, MLClient slouží k vytvoření, čtení, aktualizaci a odstraně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 tato hodnota je vymezena 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 služby Azure Machine Learning.
  2. V levém podokně vyberte Funkční úložiště.
  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 materializovaném úložišti ze stránky Přehled ve uživatelském rozhraní Feature Store. Hodnoty ID předplatného účtu úložiště, název skupiny prostředků pro účet úložiště a název účtu úložiště pro offline úložiště materializace najdete na kartě offline úložiště materializace.

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

    Další informace o řízení přístupu získáte, když navštívíte zdroj Správa řízení přístupu pro prostředek úložiště spravovaných 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 ve třetím návodu ze 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])

Návod

  • 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 služby Azure Machine Learning.

  2. V levém podokně vyberte Funkční úložiště.

  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 úložišti pro offline materializaci 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 doplněn, nová úloha se pro tento interval dat neodesílá.

  • 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, která má stavSelhalo.
    • 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ý tutoriál v sérii popisuje, jak odstranit prostředky.

Další kroky

  • Last updated on