Kurz 6: Izolace sítě s úložištěm funkcí

Článek
03/22/2024

Azure Machine Učení spravované uložiště funkcí umožňuje zjišťovat, vytvářet a zprovozňovat funkce. Funkce slouží jako spojovací tkáně v životním cyklu strojového učení, počínaje fází vytváření prototypů, kde experimentujete s různými funkcemi. Tento životní cyklus pokračuje ve fázi operacionalizace, kde nasazujete modely, a kroky odvozování vyhledávají data funkcí. Další informace o úložištíchfunkcích

Tento kurz popisuje, jak nakonfigurovat zabezpečené příchozí přenosy dat prostřednictvím privátního koncového bodu a zabezpečit výchozí přenos dat přes spravovanou virtuální síť.

1. část této série kurzů ukázala, jak vytvořit specifikaci sady funkcí s vlastními transformacemi a použít tuto sadu funkcí ke generování trénovacích dat. Část 2 série ukázala, jak povolit materializaci a provést backfill. Kromě toho část 2 ukázala, jak experimentovat s funkcemi, jako způsob, jak zlepšit výkon modelu. Část 3 ukázala, jak úložiště funkcí zvyšuje flexibilitu při experimentování a trénovacích tocích. Část 3 také popisuje, jak spustit dávkové odvození. Kurz 4 vysvětluje, jak používat úložiště funkcí pro případy použití pro odvozování v reálném čase. Kurz 5 ukazuje, jak vyvíjet sadu funkcí s vlastním zdrojem dat. Kurz 6 ukazuje, jak

Nastavte potřebné prostředky pro izolaci sítě spravované uložiště funkcí.
Vytvořte nový prostředek úložiště funkcí.
Nastavte úložiště funkcí pro podporu scénářů izolace sítě.
Aktualizujte pracovní prostor projektu (aktuální pracovní prostor) tak, aby podporoval scénáře izolace sítě .

Požadavky

Poznámka:

Tento kurz používá poznámkový blok Azure Machine Učení s bezserverovým výpočetním prostředím Spark.

Nezapomeňte dokončit části 1 až 4 této série kurzů.
Pracovní prostor Učení Azure s povolenou spravovanou virtuální sítí pro bezserverové úlohy Sparku
Konfigurace pracovního prostoru projektu:
1. Vytvořte soubor YAML s názvem network.yml:
```
managed_network:
isolation_mode: allow_internet_outbound
```
2. Spuštěním těchto příkazů aktualizujte pracovní prostor a zřiďte spravovanou virtuální síť pro bezserverové úlohy Sparku:
```
az ml workspace update --file network.yml --resource-group my_resource_group --name
my_workspace_name
az ml workspace provision-network --resource-group my_resource_group --name my_workspace_name
--include-spark
```
Další informace najdete v tématu Konfigurace pro bezserverovou úlohu Sparku.
Uživatelský účet musí mít přiřazenou Owner Contributor roli nebo skupinu prostředků, ve které vytváříte úložiště funkcí. Váš uživatelský účet také potřebuje User Access Administrator roli.

Důležité

Pro váš pracovní prostor Azure Machine Učení nastavte isolation_mode hodnotu allow_internet_outbound. Toto je jediný podporovaný režim izolace sítě. V tomto kurzu se dozvíte, jak se bezpečně připojit ke zdrojům, materializaci a pozorováním dat prostřednictvím privátních koncových bodů.

Nastavení

V tomto kurzu se používá základní sada SDK (azureml-featurestore) úložiště funkcí Pythonu. Sada Python SDK se používá jenom pro vývoj a testování sady funkcí. Rozhraní příkazového řádku slouží k operacím vytvoření, čtení, aktualizace a odstranění (CRUD) v úložištích funkcí, sadách funkcí a entitách úložiště funkcí. To je užitečné ve scénářích kontinuální integrace a průběžného doručování (CI/CD) nebo GitOps, kde je upřednostňované rozhraní příkazového řádku nebo YAML.

Tyto prostředky pro účely tohoto kurzu nemusíte explicitně instalovat, protože v zde uvedených pokynech k nastavení je conda.yaml soubor pokrývá.

Příprava prostředí poznámkového bloku pro vývoj:

Naklonujte úložiště azureml-examples do místních prostředků GitHubu pomocí tohoto příkazu:

git clone --depth 1 https://github.com/Azure/azureml-examples

Soubor ZIP si také můžete stáhnout z úložiště azureml-examples . Na této stránce nejprve vyberte code rozevírací seznam a pak vyberte Download ZIP. Potom obsah rozbalte do složky na místním zařízení.
Nahrání adresáře ukázek úložiště funkcí do pracovního prostoru projektu
1. V pracovním prostoru Azure Machine Učení otevřete uživatelské rozhraní studio Azure Machine Learning.
2. Výběr poznámkových bloků v levém navigačním panelu
3. Výběr uživatelského jména v seznamu adresářů
4. Vyberte tři tečky (...) a pak vyberte Nahrát složku.
5. V cestě ke klonovanému adresáři vyberte složku ukázek úložiště funkcí: azureml-examples/sdk/python/featurestore-sample
Spuštění kurzu
- Možnost 1: Vytvoření nového poznámkového bloku a provedení pokynů v tomto dokumentu krok za krokem
- Možnost 2: Otevřete existující poznámkový blok featurestore_sample/notebooks/sdk_and_cli/network_isolation/Network-isolation-feature-store.ipynb. Tento dokument si můžete nechat otevřený a odkazy na další vysvětlení a dokumentaci.
  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 konfigurace relace.
  2. Na horním stavovém řádku vyberte Konfigurovat relaci .
  3. Výběr balíčků Pythonu
  4. Vyberte Nahrát soubor conda.
  5. Výběr souboru azureml-examples/sdk/python/featurestore-sample/project/env/conda.yml umístěného na místním zařízení
  6. (Volitelné) Zvyšte časový limit relace (doba nečinnosti v minutách), abyste snížili dobu spuštění clusteru Spark bez serveru.

Tato buňka kódu spustí relaci Sparku. K instalaci všech závislostí a spuštění relace Sparku potřebuje asi 10 minut.

# 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 alias below (or any custom directory you have uploaded the samples to).
# You can find the name from the directory structure in the left navigation.
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í příkazového řádku Azure Machine Učení:
- Instalace rozšíření Azure Machine Učení CLI
```
# install azure ml cli extension
!az extension add --name ml
```
- Ověření
```
# authenticate
!az login
```
- Nastavení výchozího předplatného
```
# Set default subscription
import os

subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]

!az account set -s $subscription_id
```
Poznámka:

Pracovní prostor úložiště funkcí podporuje opakované použití funkcí napříč projekty. Pracovní prostor projektu – aktuální pracovní prostor, který se používá – využívá funkce z konkrétního úložiště funkcí k trénování a odvozování modelů. Mnoho pracovních prostorů projektu může sdílet a opakovaně používat stejný pracovní prostor úložiště funkcí.

Zřízení nezbytných prostředků

Můžete vytvořit nový účet úložiště a kontejnery Azure Data Lake Storage (ADLS) Gen2 nebo znovu použít existující účet úložiště a prostředky kontejneru pro úložiště funkcí. V reálné situaci můžou různé účty úložiště hostovat kontejnery ADLS Gen2. Obě možnosti fungují v závislosti na konkrétních požadavcích.

Pro účely tohoto kurzu vytvoříte ve stejném účtu úložiště ADLS Gen2 tři samostatné kontejnery úložiště:

Zdrojová data
Offline úložiště
Data pozorování

Vytvořte účet úložiště ADLS Gen2 pro zdrojová data, offline úložiště a data pozorování.

V následující ukázce kódu zadejte název účtu úložiště Azure Data Lake Storage Gen2. Můžete spustit následující buňku kódu se zadaným výchozím nastavením. Volitelně můžete přepsat výchozí nastavení.

## Default Setting
# We use the subscription, resource group, region of this active project workspace,
# We hard-coded default resource names for creating new resources

## Overwrite
# You can replace them if you want to create the resources in a different subsciprtion/resourceGroup, or use existing resources
# At the minimum, provide an ADLS Gen2 storage account name for `storage_account_name`

storage_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
storage_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]
storage_account_name = "<STORAGE_ACCOUNT_NAME>"

storage_location = "eastus"
storage_file_system_name_offline_store = "offline-store"
storage_file_system_name_source_data = "source-data"
storage_file_system_name_observation_data = "observation-data"

Tato buňka kódu vytvoří účet úložiště ADLS Gen2 definovaný ve výše uvedené buňce kódu.

# Create new storage account
!az storage account create --name $storage_account_name --enable-hierarchical-namespace true --resource-group $storage_resource_group_name --location $storage_location --subscription $storage_subscription_id

Tato buňka kódu vytvoří nový kontejner úložiště pro offline úložiště.

# Create a new storage container for offline store
!az storage fs create --name $storage_file_system_name_offline_store --account-name $storage_account_name --subscription $storage_subscription_id

Tato buňka kódu vytvoří nový kontejner úložiště pro zdrojová data.

# Create a new storage container for source data
!az storage fs create --name $storage_file_system_name_source_data --account-name $storage_account_name --subscription $storage_subscription_id

Tato buňka kódu vytvoří nový kontejner úložiště pro data pozorování.

# Create a new storage container for observation data
!az storage fs create --name $storage_file_system_name_observation_data --account-name $storage_account_name --subscription $storage_subscription_id

Zkopírujte ukázková data potřebná pro tuto sérii kurzů do nově vytvořených kontejnerů úložiště.

Pokud chcete zapisovat data do kontejnerů úložiště, ujistěte se, že jsou role Přispěvatel a Přispěvatel dat objektů blob služby Storage přiřazené k identitě uživatele vytvořeného účtu úložiště ADLS Gen2 na webu Azure Portal podle těchto kroků.

Důležité

Jakmile zajistíte, že jsou role Přispěvatel a Přispěvatel dat objektů blob služby Storage přiřazené k identitě uživatele, počkejte několik minut po přiřazení role, abyste před pokračováním v dalších krocích umožnili šíření oprávnění. Další informace o řízení přístupu najdete v tématu řízení přístupu na základě role (RBAC) pro účty úložiště Azure.

Další buňky kódu zkopírují ukázková zdrojová data pro sadu funkcí transakcí použitou v tomto kurzu z veřejného účtu úložiště do nově vytvořeného účtu úložiště.
```
# Copy sample source data for transactions feature set used in this tutorial series from the public storage account to the newly created storage account
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)

transactions_src_df.write.parquet(
    f"abfss://{storage_file_system_name_source_data}@{storage_account_name}.dfs.core.windows.net/transactions-source/"
)
```

Pro sadu funkcí účtu použitou v tomto kurzu zkopírujte ukázková zdrojová data pro funkci účtu nastavená na nově vytvořený účet úložiště.

# Copy sample source data for account feature set used in this tutorial series from the public storage account to the newly created storage account
accounts_data_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/accounts-precalculated/*.parquet"
accounts_data_df = spark.read.parquet(accounts_data_path)

accounts_data_df.write.parquet(
    f"abfss://{storage_file_system_name_source_data}@{storage_account_name}.dfs.core.windows.net/accounts-precalculated/"
)

Zkopírujte ukázková data pozorování použitá pro trénování z veřejného účtu úložiště do nově vytvořeného účtu úložiště.

# Copy sample observation data used for training from the public storage account to the newly created storage account
observation_data_train_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/observation_data/train/*.parquet"
observation_data_train_df = spark.read.parquet(observation_data_train_path)

observation_data_train_df.write.parquet(
    f"abfss://{storage_file_system_name_observation_data}@{storage_account_name}.dfs.core.windows.net/train/"
)

Zkopírujte ukázková data pozorování použitá k dávkovému odvozování z veřejného účtu úložiště do nově vytvořeného účtu úložiště.

# Copy sample observation data used for batch inference from a public storage account to the newly created storage account
observation_data_inference_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/observation_data/batch_inference/*.parquet"
observation_data_inference_df = spark.read.parquet(observation_data_inference_path)

observation_data_inference_df.write.parquet(
    f"abfss://{storage_file_system_name_observation_data}@{storage_account_name}.dfs.core.windows.net/batch_inference/"
)

Zakažte přístup k veřejné síti v nově vytvořeném účtu úložiště.

Tato buňka kódu zakáže přístup k veřejné síti pro účet úložiště ADLS Gen2 vytvořený dříve.

# Disable the public network access for the above created ADLS Gen2 storage account
!az storage account update --name $storage_account_name --resource-group $storage_resource_group_name --subscription $storage_subscription_id --public-network-access disabled

Nastavte ID ARM pro offline úložiště, zdrojová data a kontejnery dat pozorování.

# set the container arm id
offline_store_gen2_container_arm_id = "/subscriptions/{sub_id}/resourceGroups/{rg}/providers/Microsoft.Storage/storageAccounts/{account}/blobServices/default/containers/{container}".format(
    sub_id=storage_subscription_id,
    rg=storage_resource_group_name,
    account=storage_account_name,
    container=storage_file_system_name_offline_store,
)

print(offline_store_gen2_container_arm_id)

source_data_gen2_container_arm_id = "/subscriptions/{sub_id}/resourceGroups/{rg}/providers/Microsoft.Storage/storageAccounts/{account}/blobServices/default/containers/{container}".format(
    sub_id=storage_subscription_id,
    rg=storage_resource_group_name,
    account=storage_account_name,
    container=storage_file_system_name_source_data,
)

print(source_data_gen2_container_arm_id)

observation_data_gen2_container_arm_id = "/subscriptions/{sub_id}/resourceGroups/{rg}/providers/Microsoft.Storage/storageAccounts/{account}/blobServices/default/containers/{container}".format(
    sub_id=storage_subscription_id,
    rg=storage_resource_group_name,
    account=storage_account_name,
    container=storage_file_system_name_observation_data,
)

print(observation_data_gen2_container_arm_id)

Vytvoření úložiště funkcí s povolenou materializací

Nastavení parametrů úložiště funkcí

Nastavte název úložiště funkcí, umístění, ID předplatného, název skupiny a hodnoty ID ARM, jak je znázorněno v této ukázce buňky kódu:

# We use the subscription, resource group, region of this active project workspace.
# Optionally, you can replace them to create the resources in a different subsciprtion/resourceGroup, or use existing resources
import os

# At the minimum, define a name for the feature store
featurestore_name = "<FEATURESTORE_NAME>"
# It is recommended to create featurestore in the same location as the storage
featurestore_location = storage_location
featurestore_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
featurestore_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]

feature_store_arm_id = "/subscriptions/{sub_id}/resourceGroups/{rg}/providers/Microsoft.MachineLearningServices/workspaces/{ws_name}".format(
    sub_id=featurestore_subscription_id,
    rg=featurestore_resource_group_name,
    ws_name=featurestore_name,
)

Tato buňka kódu vygeneruje soubor specifikace YAML pro úložiště funkcí s povolenou materializací.

# The below code creates a feature store with enabled materialization
import yaml

config = {
    "$schema": "http://azureml/sdk-2-0/FeatureStore.json",
    "name": featurestore_name,
    "location": featurestore_location,
    "compute_runtime": {"spark_runtime_version": "3.2"},
    "offline_store": {
        "type": "azure_data_lake_gen2",
        "target": offline_store_gen2_container_arm_id,
    },
}

feature_store_yaml = root_dir + "/featurestore/featurestore_with_offline_setting.yaml"

with open(feature_store_yaml, "w") as outfile:
    yaml.dump(config, outfile, default_flow_style=False)

Vytvoření úložiště funkcí

Tato buňka kódu používá soubor specifikace YAML vygenerovaný v předchozím kroku k vytvoření úložiště funkcí s povolenou materializací.

!az ml feature-store create --file $feature_store_yaml --subscription $featurestore_subscription_id --resource-group $featurestore_resource_group_name

Inicializace klienta sady Azure Machine Učení feature store core SDK

Klient sady SDK inicializovaný v této buňce usnadňuje vývoj a spotřebu 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,
)

Přiřazení rolí identitě uživatele v úložišti funkcí

Podle těchto pokynů získejte ID objektu Microsoft Entra pro vaši identitu uživatele. Potom pomocí ID objektu Microsoft Entra v dalším příkazu přiřaďte k identitě uživatele v vytvořeném úložišti funkcí roli Datoví vědci AzureML.

your_aad_objectid = "<YOUR_AAD_OBJECT_ID>"

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

Získejte výchozí účet úložiště a trezor klíčů pro úložiště funkcí a zakažte přístup k veřejné síti k odpovídajícím prostředkům.

Další buňka kódu vrátí objekt úložiště funkcí pro následující kroky.

fs = featurestore.feature_stores.get()

Tato buňka kódu vrátí názvy výchozího účtu úložiště a trezoru klíčů pro úložiště funkcí.

# Copy the properties storage_account and key_vault from the response returned in feature store show command respectively
default_fs_storage_account_name = fs.storage_account.rsplit("/", 1)[-1]
default_key_vault_name = fs.key_vault.rsplit("/", 1)[-1]

Tato buňka kódu zakáže přístup veřejné sítě k výchozímu účtu úložiště úložiště pro úložiště funkcí.

# Disable the public network access for the above created default ADLS Gen2 storage account for the feature store
!az storage account update --name $default_fs_storage_account_name --resource-group $featurestore_resource_group_name --subscription $featurestore_subscription_id --public-network-access disabled

Další buňka vytiskne název výchozího trezoru klíčů pro úložiště funkcí.

print(default_key_vault_name)

Zakázání přístupu k veřejné síti pro výchozí trezor klíčů úložiště funkcí vytvořený dříve

Na webu Azure Portal otevřete výchozí trezor klíčů, který jste vytvořili v předchozí buňce.
Vyberte kartu Sítě.
Vyberte Zakázat veřejný přístup a pak v levém dolním rohu stránky vyberte Použít .

Povolení spravované virtuální sítě pro pracovní prostor úložiště funkcí

Aktualizace úložiště funkcí pomocí nezbytných pravidel odchozích přenosů

Další buňka kódu vytvoří soubor specifikace YAML pro odchozí pravidla definovaná pro úložiště funkcí.

# The below code creates a configuration for managed virtual network for the feature store
import yaml

config = {
    "public_network_access": "disabled",
    "managed_network": {
        "isolation_mode": "allow_internet_outbound",
        "outbound_rules": [
            # You need to add multiple rules here if you have separate storage account for source, observation data and offline store.
            {
                "name": "sourcerulefs",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "dfs",
                    "service_resource_id": f"/subscriptions/{storage_subscription_id}/resourcegroups/{storage_resource_group_name}/providers/Microsoft.Storage/storageAccounts/{storage_account_name}",
                },
                "type": "private_endpoint",
            },
            # This rule is added currently because serverless Spark doesn't automatically create a private endpoint to default key vault.
            {
                "name": "defaultkeyvault",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "vault",
                    "service_resource_id": f"/subscriptions/{featurestore_subscription_id}/resourcegroups/{featurestore_resource_group_name}/providers/Microsoft.Keyvault/vaults/{default_key_vault_name}",
                },
                "type": "private_endpoint",
            },
        ],
    },
}

feature_store_managed_vnet_yaml = (
    root_dir + "/featurestore/feature_store_managed_vnet_config.yaml"
)

with open(feature_store_managed_vnet_yaml, "w") as outfile:
    yaml.dump(config, outfile, default_flow_style=False)

Tato buňka kódu používá vygenerovaný soubor specifikace YAML k aktualizaci úložiště funkcí.

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

Vytvoření privátních koncových bodů pro definovaná pravidla odchozích přenosů

Příkaz provision-network vytvoří privátní koncové body ze spravované virtuální sítě, kde se úloha materializace provede do zdroje, offline úložiště, pozorování dat, výchozího účtu úložiště a výchozího trezoru klíčů pro úložiště funkcí. Dokončení tohoto příkazu může trvat asi 20 minut.

#### Provision network to create necessary private endpoints (it may take approximately 20 minutes)
!az ml feature-store provision-network --name $featurestore_name --resource-group $featurestore_resource_group_name --include-spark

Tato buňka kódu potvrzuje vytvoření privátních koncových bodů definovaných odchozími pravidly.

### Check that managed virtual network is correctly enabled
### After provisioning the network, all the outbound rules should become active
### For this tutorial, you will see 6 outbound rules
!az ml feature-store show --name $featurestore_name --resource-group $featurestore_resource_group_name

Aktualizace spravované virtuální sítě pro pracovní prostor projektu

Dále aktualizujte spravovanou virtuální síť pro pracovní prostor projektu. Nejprve získejte ID předplatného, skupinu prostředků a název pracovního prostoru pro pracovní prostor projektu.

# lookup the subscription id, resource group and workspace name of the current workspace
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"]

Aktualizace pracovního prostoru projektu pomocí potřebných pravidel odchozích přenosů

Pracovní prostor projektu potřebuje přístup k těmto prostředkům:

Zdrojová data
Offline úložiště
Data pozorování
Úložiště funkcí
Výchozí účet úložiště funkcí

Tato buňka kódu aktualizuje pracovní prostor projektu pomocí vygenerovaného souboru specifikace YAML s požadovanými odchozími pravidly.

# The below code creates a configuration for managed virtual network for the project workspace
import yaml

config = {
    "managed_network": {
        "isolation_mode": "allow_internet_outbound",
        "outbound_rules": [
            # Incase you have separate storage accounts for source, observation data and offline store, you need to add multiple rules here. No action needed otherwise.
            {
                "name": "projectsourcerule",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "dfs",
                    "service_resource_id": f"/subscriptions/{storage_subscription_id}/resourcegroups/{storage_resource_group_name}/providers/Microsoft.Storage/storageAccounts/{storage_account_name}",
                },
                "type": "private_endpoint",
            },
            # Rule to create private endpoint to default storage of feature store
            {
                "name": "defaultfsstoragerule",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "blob",
                    "service_resource_id": f"/subscriptions/{featurestore_subscription_id}/resourcegroups/{featurestore_resource_group_name}/providers/Microsoft.Storage/storageAccounts/{default_fs_storage_account_name}",
                },
                "type": "private_endpoint",
            },
            # Rule to create private endpoint to default key vault of feature store
            {
                "name": "defaultfskeyvaultrule",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "vault",
                    "service_resource_id": f"/subscriptions/{featurestore_subscription_id}/resourcegroups/{featurestore_resource_group_name}/providers/Microsoft.Keyvault/vaults/{default_key_vault_name}",
                },
                "type": "private_endpoint",
            },
            # Rule to create private endpoint to feature store
            {
                "name": "featurestorerule",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "amlworkspace",
                    "service_resource_id": f"/subscriptions/{featurestore_subscription_id}/resourcegroups/{featurestore_resource_group_name}/providers/Microsoft.MachineLearningServices/workspaces/{featurestore_name}",
                },
                "type": "private_endpoint",
            },
        ],
    }
}

project_ws_managed_vnet_yaml = (
    root_dir + "/featurestore/project_ws_managed_vnet_config.yaml"
)

with open(project_ws_managed_vnet_yaml, "w") as outfile:
    yaml.dump(config, outfile, default_flow_style=False)

Tato buňka kódu aktualizuje pracovní prostor projektu pomocí vygenerovaného souboru specifikace YAML s pravidly odchozích přenosů.

#### Update project workspace to create private endpoints for the defined outbound rules (it may take approximately 15 minutes)
!az ml workspace update --file $project_ws_managed_vnet_yaml --name $project_ws_name --resource-group $project_ws_rg

Tato buňka kódu potvrzuje vytvoření privátních koncových bodů definovaných odchozími pravidly.

!az ml workspace show --name $project_ws_name --resource-group $project_ws_rg

Odchozí pravidla můžete také ověřit na webu Azure Portal. V levém navigačním panelu pracovního prostoru projektu přejděte do sítě a otevřete kartu odchozího přístupu spravovaného pracovním prostorem.

Prototyp a vývoj sady funkcí agregace se průběžnou agregací transakcí

Prozkoumání zdrojových dat transakcí

Poznámka:

Veřejně přístupný kontejner objektů blob hostuje ukázková data použitá v tomto kurzu. Dá se jen číst ve Sparku prostřednictvím wasbs ovladače. Když vytváříte sady funkcí pomocí vlastních zdrojových dat, hostujte je v účtu ADLS Gen2 a použijte abfss ovladač v cestě k datům.

# remove the "." in the root directory path as we need to generate absolute path to read from Spark
transactions_source_data_path = f"abfss://{storage_file_system_name_source_data}@{storage_account_name}.dfs.core.windows.net/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

Místní vývoj sady funkcí transakcí

Specifikace sady funkcí je samostatná definice sady funkcí, kterou je možné vyvíjet a testovat místně.

Vytvořte následující agregační funkce posuvné okno:

počet transakcí za tři dny
transactions amount three-day sum
transactions amount three-day avg
počet transakcí za 7 dnů
transactions amount seven-day sum
transactions amount seven-day avg

Zkontrolujte soubor featurestore/featuresets/transactions/spec/transformation_code/transaction_transform.pykódu transformace funkce . Tento sparkový transformátor provádí agregaci s průběžnou agregací definovanou pro funkce.

Další informace o sadě funkcíach

from azureml.featurestore import create_feature_set_spec, FeatureSetSpec
from azureml.featurestore.contracts import (
    DateTimeOffset,
    FeatureSource,
    TransformationCode,
    Column,
    ColumnType,
    SourceType,
    TimestampColumn,
)


transactions_featureset_code_path = (
    root_dir + "/featurestore/featuresets/transactions/transformation_code"
)

transactions_featureset_spec = create_feature_set_spec(
    source=FeatureSource(
        type=SourceType.parquet,
        path=f"abfss://{storage_file_system_name_source_data}@{storage_account_name}.dfs.core.windows.net/transactions-source/*.parquet",
        timestamp_column=TimestampColumn(name="timestamp"),
        source_delay=DateTimeOffset(days=0, hours=0, minutes=20),
    ),
    transformation_code=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,
)
# Generate a spark dataframe from the feature set specification
transactions_fset_df = transactions_featureset_spec.to_spark_dataframe()
# display few records
display(transactions_fset_df.head(5))

Export specifikace sady funkcí

Chcete-li zaregistrovat specifikaci sady funkcí v úložišti funkcí, musí být tato specifikace uložena v určitém formátu.

Pokud chcete zkontrolovat specifikaci sady funkcí vygenerovaných transakcí, otevřete tento soubor ze stromu souborů a zobrazte specifikaci:

featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml

Specifikace obsahuje tyto prvky:

source: Odkaz na prostředek úložiště – v tomto případě soubor parquet v prostředku úložiště objektů blob
features: seznam funkcí a jejich datových typů. Pokud zadáte kód transformace
index_columns: klíče spojení potřebné pro přístup k hodnotám ze sady funkcí

Další výhodou zachování specifikace sady funkcí jako souboru YAML může být specifikace řízena verzí. Přečtěte si další informace o specifikaci sady funkcí v dokumentu entit úložiště funkcí nejvyšší úrovně a referenční informace o specifikaci sady funkcí YAML.

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

Entity pomáhají vynucovat použití stejných definic klíčů join napříč sadami funkcí, které používají stejné logické entity. Příklady entit můžou zahrnovat entity účtů, entity zákazníků atd. Entity se obvykle vytvářejí jednou a pak se znovu používají napříč sadami funkcí. Další informace najdete v dokumentu entity úložiště entit nejvyšší úrovně.

Tato buňka kódu vytvoří entitu účtu pro úložiště funkcí.

account_entity_path = root_dir + "/featurestore/entities/account.yaml"
!az ml feature-store-entity create --file $account_entity_path --resource-group $featurestore_resource_group_name --workspace-name $featurestore_name

Zaregistrujte sadu funkcí transakce v úložišti funkcí a odešlete úlohu materializace.

Pokud chcete sdílet a znovu použít prostředek sady funkcí, musíte ho nejprve zaregistrovat v úložišti funkcí. Registrace prostředků sady funkcí nabízí spravované funkce, včetně správy verzí a materializace. Tato série kurzů se zabývá těmito tématy.

Asset sady funkcí odkazuje na specifikaci sady funkcí, kterou jste vytvořili dříve, a další vlastnosti – například nastavení verze a materializace.

Vytvoření sady funkcí

Další buňka kódu používá k vytvoření sady funkcí předdefinovaný soubor specifikace YAML.

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

Tato buňka kódu zobrazí náhled nově vytvořené sady funkcí.

# Preview the newly created feature set

!az ml feature-set show --resource-group $featurestore_resource_group_name --workspace-name $featurestore_name -n transactions -v 1

Odeslání úlohy materializace backfillu

Další buňka kódu definuje hodnoty počátečního a koncového času pro okno materializace funkcí a odešle úlohu materializace backfillu.

feature_window_start_time = "2023-02-01T00:00.000Z"
feature_window_end_time = "2023-03-01T00:00.000Z"

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

Tato buňka kódu poskytuje <JOB_ID_FROM_PREVIOUS_COMMAND>stav úlohy materializace backfillu.

### Check the job status

!az ml job show --name <JOB_ID_FROM_PREVIOUS_COMMAND> -g $featurestore_resource_group_name -w $featurestore_name

Tato buňka kódu obsahuje seznam všech úloh materializace pro aktuální sadu funkcí.

### List all the materialization jobs for the current feature set

!az ml feature-set list-materialization-operation --name transactions --version 1 -g $featurestore_resource_group_name -w $featurestore_name

Připojení služby Azure Cache for Redis jako online obchodu

Vytvoření instance Azure Cache for Redis

V další buňce kódu definujte název Azure Cache for Redis, který chcete vytvořit nebo znovu použít. Volitelně můžete přepsat další výchozí nastavení.

redis_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
redis_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]
redis_name = "my-redis"
redis_location = storage_location

Můžete vybrat úroveň mezipaměti Redis (Basic, Standard nebo Premium). Měli byste zvolit řadu skladových položek, která je k dispozici pro vybranou úroveň mezipaměti. Další informace o tom, jak může výběr různých úrovní ovlivnit výkon mezipaměti, najdete v tomto prostředku dokumentace. Další informace o cenách různých úrovní skladových položek a rodin azure Cache for Redis najdete v tomto prostředku dokumentace.

Spuštěním následující buňky kódu vytvořte Azure Cache for Redis s úrovní Premium, rodinou P skladových položek a kapacitou mezipaměti 2. Zřízení instance Redis může trvat přibližně 5 až 10 minut.

# Create new redis cache
from azure.mgmt.redis import RedisManagementClient
from azure.mgmt.redis.models import RedisCreateParameters, Sku, SkuFamily, SkuName

management_client = RedisManagementClient(
    AzureMLOnBehalfOfCredential(), redis_subscription_id
)

# It usually takes about 5 - 10 min to finish the provision of the Redis instance.
# If the following begin_create() call still hangs for longer than that,
# please check the status of the Redis instance on the Azure portal and cancel the cell if the provision has completed.
# This sample uses a PREMIUM tier Redis SKU from family P, which may cost more than a STANDARD tier SKU from family C.
# Please choose the SKU tier and family according to your performance and pricing requirements.

redis_arm_id = (
    management_client.redis.begin_create(
        resource_group_name=redis_resource_group_name,
        name=redis_name,
        parameters=RedisCreateParameters(
            location=redis_location,
            sku=Sku(name=SkuName.PREMIUM, family=SkuFamily.P, capacity=2),
            public_network_access="Disabled",  # can only disable PNA to redis cache during creation
        ),
    )
    .result()
    .id
)
print(redis_arm_id)

Aktualizace úložiště funkcí pomocí online obchodu

Připojte Azure Cache for Redis k úložišti funkcí, abyste ho mohli použít jako online úložiště materializace. Další buňka kódu vytvoří soubor specifikace YAML s pravidly odchozích přenosů online úložiště definovanými pro úložiště funkcí.

# The following code cell creates a YAML specification file for outbound rules that are defined for the feature store.
## rule 1: PE to online store (redis cache): this is optional if online store is not used

import yaml

config = {
    "public_network_access": "disabled",
    "managed_network": {
        "isolation_mode": "allow_internet_outbound",
        "outbound_rules": [
            {
                "name": "sourceruleredis",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "redisCache",
                    "service_resource_id": f"/subscriptions/{storage_subscription_id}/resourcegroups/{storage_resource_group_name}/providers/Microsoft.Cache/Redis/{redis_name}",
                },
                "type": "private_endpoint",
            },
        ],
    },
    "online_store": {"target": f"{redis_arm_id}", "type": "redis"},
}

feature_store_managed_vnet_yaml = (
    root_dir + "/featurestore/feature_store_managed_vnet_config.yaml"
)

with open(feature_store_managed_vnet_yaml, "w") as outfile:
    yaml.dump(config, outfile, default_flow_style=False)

Další buňka kódu aktualizuje úložiště funkcí pomocí vygenerovaného souboru specifikace YAML s odchozími pravidly pro online obchod.

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

Aktualizace pravidel odchozích přenosů pracovního prostoru projektu

Pracovní prostor projektu potřebuje přístup k online obchodu. Následující buňka kódu vytvoří soubor specifikace YAML s požadovanými odchozími pravidly pro pracovní prostor projektu.

import yaml

config = {
    "managed_network": {
        "isolation_mode": "allow_internet_outbound",
        "outbound_rules": [
            {
                "name": "onlineruleredis",
                "destination": {
                    "spark_enabled": "true",
                    "subresource_target": "redisCache",
                    "service_resource_id": f"/subscriptions/{storage_subscription_id}/resourcegroups/{storage_resource_group_name}/providers/Microsoft.Cache/Redis/{redis_name}",
                },
                "type": "private_endpoint",
            },
        ],
    }
}

project_ws_managed_vnet_yaml = (
    root_dir + "/featurestore/project_ws_managed_vnet_config.yaml"
)

with open(project_ws_managed_vnet_yaml, "w") as outfile:
    yaml.dump(config, outfile, default_flow_style=False)

Spuštěním další buňky kódu aktualizujte pracovní prostor projektu pomocí vygenerovaného souboru specifikace YAML s odchozími pravidly pro online úložiště.

#### Update project workspace to create private endpoints for the defined outbound rules (it may take approximately 15 minutes)
!az ml workspace update --file $project_ws_managed_vnet_yaml --name $project_ws_name --resource-group $project_ws_rg

Materializace funkcí nastavených na online obchod

Další buňka kódu umožňuje online materializaci pro transactions sadu funkcí.

# Update featureset to enable online materialization
transactions_featureset_path = (
    root_dir
    + "/featurestore/featuresets/transactions/featureset_asset_online_enabled.yaml"
)
!az ml feature-set update --file $transactions_featureset_path --resource-group $featurestore_resource_group_name --workspace-name $featurestore_name

Další buňka kódu definuje počáteční a koncové časy pro okno materializace funkcí a odešle úlohu materializace backfill.

feature_window_start_time = "2024-01-24T00:00.000Z"
feature_window_end_time = "2024-01-25T00:00.000Z"

!az ml feature-set backfill --name transactions --version 1 --by-data-status "['None']" --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

Použití registrovaných funkcí k vygenerování trénovacích dat

Načtení dat pozorování

Nejprve prozkoumejte data pozorování. Základní data používaná pro trénování a odvozování obvykle zahrnují data pozorování. Tato data se pak připojí k datům funkcí, aby se vytvořil úplný trénovací datový prostředek. Data pozorování jsou data zachycená v době události. V tomto případě obsahuje základní transakční data, včetně ID transakce, ID účtu a hodnot množství transakcí. Vzhledem k tomu, že se data pozorování používají pro trénování, obsahuje také připojenou cílovou proměnnou (is_fraud).

observation_data_path = f"abfss://{storage_file_system_name_observation_data}@{storage_account_name}.dfs.core.windows.net/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

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

Dále získejte sadu funkcí zadáním jejího názvu a verze a výpisem funkcí v této sadě funkcí. Vytiskněte také některé ukázkové hodnoty funkcí.

# look up the featureset by providing name and 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))

Výběr funkcí a generování trénovacích dat

Vyberte funkce pro trénovací data a pomocí sady SDK úložiště funkcí vygenerujte 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: featurestore:featureset:version:feature
more_features = [
    "transactions:1:transaction_3d_count",
    "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 next 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

Připojení k určitému bodu v čase připojilo funkce k trénovacím datům.

Volitelné další kroky

Teď, když jste úspěšně vytvořili zabezpečené úložiště funkcí a odeslali úspěšné spuštění materializace, můžete pokračovat v sérii kurzů a porozumět úložišti funkcí.

Tento kurz obsahuje kombinaci kroků z kurzů 1 a 2 této série. Nezapomeňte nahradit potřebné veřejné kontejnery úložiště používané v dalších poznámkových blocích kurzu těmi, které jsou vytvořené v tomto poznámkovém bloku kurzu pro izolaci sítě.

Tím je kurz ukončen. Vaše trénovací data používají funkce z úložiště funkcí. Můžete ho buď uložit do úložiště pro pozdější použití, nebo přímo na něm spustit trénování modelu.

Sdílet prostřednictvím