Udostępnij przez

Samouczek 6. Izolacja sieci z magazynem funkcji

Usługa Azure Machine Learning magazyn zarządzanych funkcji umożliwia odnajdywanie, tworzenie i operacjonalizacja funkcji. Funkcje służą jako tkanka łącząca w cyklu życia uczenia maszynowego, począwszy od fazy tworzenia prototypów, w której eksperymentujesz z różnymi funkcjami. Ten cykl życia jest kontynuowany w fazie operacjonalizacji, w której wdrażasz modele i kroki wnioskowania wyszukują dane funkcji. Aby uzyskać więcej informacji na temat magazynów funkcji, zapoznaj się z dokumentem dotyczącym pojęć dotyczących magazynu funkcji.

W tym samouczku opisano sposób konfigurowania bezpiecznego ruchu przychodzącego za pośrednictwem prywatnego punktu końcowego oraz zabezpieczania ruchu wychodzącego za pośrednictwem zarządzanej sieci wirtualnej.

W części 1 tej serii samouczków pokazano, jak utworzyć specyfikację zestawu funkcji z niestandardowymi przekształceniami i użyć tego zestawu funkcji do generowania danych treningowych. Część 2 serii pokazała, jak włączyć materializację i wykonać wypełnienie. Ponadto w części 2 pokazano, jak eksperymentować z funkcjami jako sposób na poprawę wydajności modelu. Część 3 pokazała, jak magazyn funkcji zwiększa elastyczność eksperymentowania i przepływów trenowania. Część 3 opisała również sposób uruchamiania wnioskowania wsadowego. W samouczku 4 wyjaśniono, jak używać magazynu funkcji w przypadku przypadków użycia wnioskowania online/w czasie rzeczywistym. W samouczku 5 przedstawiono sposób tworzenia zestawu funkcji przy użyciu niestandardowego źródła danych. Samouczek 6 pokazuje, jak to zrobić

  • Skonfiguruj niezbędne zasoby do izolacji sieci magazyn zarządzanych funkcji.
  • Utwórz nowy zasób magazynu funkcji.
  • Skonfiguruj magazyn funkcji, aby obsługiwać scenariusze izolacji sieci.
  • Zaktualizuj obszar roboczy projektu (bieżący obszar roboczy), aby obsługiwać scenariusze izolacji sieci.

Wymagania wstępne

Uwaga

W tym samouczku jest używany notes usługi Azure Machine Learning z bezserwerowymi obliczeniami platformy Spark.

  • Obszar roboczy usługi Azure Machine Learning z włączoną zarządzaną siecią wirtualną dla zadań platformy Spark bezserwerowych

  • Aby skonfigurować obszar roboczy projektu:

    1. Utwórz plik YAML o nazwie network.yml:

      managed_network:
isolation_mode: allow_internet_outbound

    2. Wykonaj następujące polecenia, aby zaktualizować obszar roboczy i aprowizować zarządzaną sieć wirtualną dla zadań bezserwerowych platformy Spark:

      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

    Aby uzyskać więcej informacji, odwiedź stronę Konfigurowanie zadania platformy Spark bezserwerowej.

  • Konto użytkownika musi mieć przypisaną Owner rolę lub Contributor do grupy zasobów, w której tworzysz magazyn funkcji. Twoje konto użytkownika wymaga User Access Administrator również roli.

Ważne

W obszarze roboczym usługi Azure Machine Learning ustaw wartość isolation_modeallow_internet_outbound. Jest to jedyny obsługiwany tryb izolacji sieciowej. W tym samouczku pokazano, jak bezpiecznie łączyć się ze źródłami, magazynem materializacji i danymi obserwacji za pośrednictwem prywatnych punktów końcowych.

Konfiguruj

W tym samouczku jest używany podstawowy zestaw SDK magazynu funkcji języka Python (azureml-featurestore). Zestaw SDK języka Python jest używany tylko do tworzenia i testowania zestawu funkcji. Interfejs wiersza polecenia służy do tworzenia, odczytu, aktualizowania i usuwania (CRUD) operacji, w magazynach funkcji, zestawach funkcji i jednostkach magazynu funkcji. Jest to przydatne w scenariuszach ciągłej integracji i ciągłego dostarczania (CI/CD) lub GitOps, w których preferowany jest interfejs wiersza polecenia/YAML.

Nie musisz jawnie instalować tych zasobów na potrzeby tego samouczka, ponieważ w instrukcjach konfiguracji przedstawionych tutaj conda.yaml plik obejmuje te zasoby.

Aby przygotować środowisko notesu do programowania:

  1. Sklonuj repozytorium azureml-examples do lokalnych zasobów usługi GitHub za pomocą następującego polecenia:

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

    Możesz również pobrać plik zip z repozytorium azureml-examples . Na tej stronie najpierw wybierz listę rozwijaną code , a następnie wybierz pozycję Download ZIP. Następnie rozpakuj zawartość do folderu na urządzeniu lokalnym.

  2. Przekazywanie katalogu przykładów magazynu funkcji do obszaru roboczego projektu

    1. W obszarze roboczym usługi Azure Machine Learning otwórz interfejs użytkownika usługi Azure Machine Learning Studio
    2. Wybierz Notatniki w panelu po lewej stronie
    3. Wybierz nazwę użytkownika na liście katalogów
    4. Wybierz wielokropek (...), a następnie wybierz pozycję Przekaż folder
    5. Wybierz folder samples magazynu funkcji ze ścieżki sklonowanego katalogu: azureml-examples/sdk/python/featurestore-sample

  3. Uruchamianie samouczka

    • Opcja 1. Tworzenie nowego notesu i wykonywanie instrukcji w tym dokumencie, krok po kroku

    • Opcja 2. Otwórz istniejący notes featurestore_sample/notebooks/sdk_and_cli/network_isolation/Network-isolation-feature-store.ipynb. Możesz otworzyć ten dokument i zapoznać się z nim, aby uzyskać więcej wyjaśnień i linków do dokumentacji

      1. Wybierz pozycję Bezserwerowe obliczenia platformy Spark na liście rozwijanej Obliczenia na górnym pasku nawigacyjnym. Ta operacja może potrwać od jednej do dwóch minut. Poczekaj na pasek stanu u góry, aby wyświetlić konfigurowanie sesji
      2. Wybierz pozycję Konfiguruj sesję na górnym pasku stanu
      3. Wybieranie pakietów języka Python
      4. Wybieranie pozycji Przekaż plik conda
      5. Wybierz plik azureml-examples/sdk/python/featurestore-sample/project/env/conda.yml znajdujący się na urządzeniu lokalnym
      6. (Opcjonalnie) Zwiększ limit czasu sesji (czas bezczynności w minutach), aby skrócić czas uruchamiania klastra spark bezserwerowego

  4. Ta komórka kodu uruchamia sesję platformy Spark. Wymaga około 10 minut, aby zainstalować wszystkie zależności i uruchomić sesję platformy Spark.

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

  5. Konfigurowanie katalogu głównego dla przykładów

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

  6. Konfigurowanie interfejsu wiersza polecenia usługi Azure Machine Learning:

    • Instalowanie rozszerzenia interfejsu wiersza polecenia usługi Azure Machine Learning

      # install azure ml cli extension
!az extension add --name ml

    • Uwierzytelnij

      # authenticate
!az login

    • Ustawianie subskrypcji domyślnej

      # Set default subscription
import os

subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]

!az account set -s $subscription_id

    Uwaga

    Obszar roboczy magazynu funkcji obsługuje ponowne użycie funkcji w projektach. Obszar roboczy projektu — bieżący obszar roboczy używany — wykorzystuje funkcje z określonego magazynu funkcji do trenowania i wnioskowania modeli. Wiele obszarów roboczych projektu może współużytkować i ponownie używać tego samego obszaru roboczego magazynu funkcji.

Aprowizuj niezbędne zasoby

Możesz utworzyć nowe konto magazynu i kontenery usługi Azure Data Lake Storage (ADLS) Gen2 lub ponownie użyć istniejącego konta magazynu i zasobów kontenera dla magazynu funkcji. W rzeczywistej sytuacji różne konta magazynu mogą hostować kontenery usługi ADLS Gen2. Obie opcje działają w zależności od konkretnych wymagań.

Na potrzeby tego samouczka utworzysz trzy oddzielne kontenery magazynu na tym samym koncie magazynu usługi ADLS Gen2:

  • Dane źródłowe
  • Magazyn offline
  • Dane obserwacji

  1. Utwórz konto magazynu usługi ADLS Gen2 dla danych źródłowych, magazynu offline i danych obserwacji.

    1. Podaj nazwę konta magazynu usługi Azure Data Lake Storage Gen2 w poniższym przykładzie kodu. Możesz wykonać następującą komórkę kodu z podanymi ustawieniami domyślnymi. Opcjonalnie można zastąpić ustawienia domyślne.

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

    2. Ta komórka kodu tworzy konto magazynu usługi ADLS Gen2 zdefiniowane w powyższej komórce kodu.

      # 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

    3. Ta komórka kodu tworzy nowy kontener magazynu dla magazynu w trybie offline.

      # 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

    4. Ta komórka kodu tworzy nowy kontener magazynu dla danych źródłowych.

      # 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

    5. Ta komórka kodu tworzy nowy kontener magazynu na potrzeby danych obserwacji.

      # 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

  2. Skopiuj przykładowe dane wymagane dla tej serii samouczków do nowo utworzonych kontenerów magazynu.

    1. Aby zapisywać dane w kontenerach magazynu, upewnij się, że role Współautor i Współautor danych obiektu blob usługi Storage są przypisane do tożsamości użytkownika na utworzonym koncie magazynu usługi ADLS Gen2 w witrynie Azure Portal, wykonując następujące kroki.

      Ważne

      Po upewnieniu się, że role Współautor i Współautor danych obiektu blob usługi Storage są przypisane do tożsamości użytkownika, poczekaj kilka minut po przypisaniu roli, aby umożliwić propagację uprawnień przed kontynuowaniem następnych kroków. Aby dowiedzieć się więcej na temat kontroli dostępu, odwiedź stronę Kontrola dostępu oparta na rolach (RBAC) dla kont usługi Azure Storage

      Następne komórki kodu kopiują przykładowe dane źródłowe dla zestawu funkcji transakcji używanego w tym samouczku z konta magazynu publicznego do nowo utworzonego konta magazynu.

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

    2. W przypadku zestawu funkcji konta używanego w tym samouczku skopiuj przykładowe dane źródłowe dla funkcji konta ustawione na nowo utworzone konto magazynu.

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

    3. Skopiuj przykładowe dane obserwacji używane do trenowania z konta magazynu publicznego do nowo utworzonego konta magazynu.

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

    4. Skopiuj przykładowe dane obserwacji używane do wnioskowania wsadowego z konta magazynu publicznego do nowo utworzonego konta magazynu.

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

  3. Wyłącz dostęp do sieci publicznej na nowo utworzonym koncie magazynu.

    1. Ta komórka kodu wyłącza dostęp do sieci publicznej dla utworzonego wcześniej konta magazynu usługi ADLS Gen2.

      # 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

    2. Ustaw identyfikatory arm dla magazynu offline, danych źródłowych i kontenerów danych obserwacji.

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

Tworzenie magazynu funkcji z włączoną materializacją

Ustawianie parametrów magazynu funkcji

Ustaw nazwę magazynu funkcji, lokalizację, identyfikator subskrypcji, nazwę grupy i wartości identyfikatora usługi ARM, jak pokazano w tym przykładzie komórki kodu:

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

Ta komórka kodu generuje plik specyfikacji YAML dla magazynu funkcji z włączoną materializacją.

# 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.3"},
    "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)

Tworzenie magazynu funkcji

Ta komórka kodu używa pliku specyfikacji YAML wygenerowanego w poprzednim kroku, aby utworzyć magazyn funkcji z włączoną materializacją.

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

Inicjowanie klienta podstawowego zestawu SDK magazynu funkcji usługi Azure Machine Learning

Klient zestawu SDK zainicjowany w tej komórce ułatwia opracowywanie i korzystanie z funkcji:

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

Przypisywanie ról do tożsamości użytkownika w magazynie funkcji

Postępuj zgodnie z tymi instrukcjami, aby uzyskać identyfikator obiektu Entra firmy Microsoft dla tożsamości użytkownika. Następnie użyj identyfikatora obiektu Entra firmy Microsoft w następnym poleceniu, aby przypisać rolę badacze dancyh AzureML do tożsamości użytkownika w utworzonym magazynie funkcji.

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

Uzyskiwanie domyślnego konta magazynu i magazynu kluczy dla magazynu funkcji oraz wyłączanie dostępu do sieci publicznej do odpowiednich zasobów

Następna komórka kodu zwraca obiekt magazynu funkcji dla poniższych kroków.

fs = featurestore.feature_stores.get()

Ta komórka kodu zwraca nazwy domyślnego konta magazynu i magazynu kluczy dla magazynu funkcji.

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

Ta komórka kodu wyłącza dostęp do sieci publicznej do domyślnego konta magazynu funkcji.

# 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

Następna komórka wyświetla nazwę domyślnego magazynu kluczy dla magazynu funkcji.

print(default_key_vault_name)

Wyłącz dostęp do sieci publicznej dla utworzonego wcześniej domyślnego magazynu kluczy magazynu funkcji

  • W witrynie Azure Portal otwórz domyślny magazyn kluczy utworzony w poprzedniej komórce.
  • Wybierz kartę Sieć.
  • Wybierz pozycję Wyłącz dostęp publiczny, a następnie wybierz pozycję Zastosuj w lewym dolnym rogu strony.

Włączanie zarządzanej sieci wirtualnej dla obszaru roboczego magazynu funkcji

Aktualizowanie magazynu funkcji przy użyciu niezbędnych reguł ruchu wychodzącego

Następna komórka kodu tworzy plik specyfikacji YAML dla reguł ruchu wychodzącego zdefiniowanych dla magazynu funkcji.

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

Ta komórka kodu używa wygenerowanego pliku specyfikacji YAML do zaktualizowania magazynu funkcji.

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

Tworzenie prywatnych punktów końcowych dla zdefiniowanych reguł ruchu wychodzącego

Polecenie provision-network tworzy prywatne punkty końcowe z zarządzanej sieci wirtualnej, gdzie zadanie materializacji jest wykonywane do źródła, magazynu offline, danych obserwacji, domyślnego konta magazynu i domyślnego magazynu kluczy dla magazynu funkcji. Wykonanie tego polecenia może wymagać około 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

Ta komórka kodu potwierdza tworzenie prywatnych punktów końcowych zdefiniowanych przez reguły ruchu wychodzącego.

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

Aktualizowanie zarządzanej sieci wirtualnej dla obszaru roboczego projektu

Następnie zaktualizuj zarządzaną sieć wirtualną dla obszaru roboczego projektu. Najpierw uzyskaj identyfikator subskrypcji, grupę zasobów i nazwę obszaru roboczego 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"]

Aktualizowanie obszaru roboczego projektu przy użyciu niezbędnych reguł ruchu wychodzącego

Obszar roboczy projektu musi mieć dostęp do tych zasobów:

  • Dane źródłowe
  • Magazyn offline
  • Dane obserwacji
  • Magazyn funkcji
  • Domyślne konto magazynu funkcji

Ta komórka kodu aktualizuje obszar roboczy projektu przy użyciu wygenerowanego pliku specyfikacji YAML z wymaganymi regułami ruchu wychodzącego.

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

Ta komórka kodu aktualizuje obszar roboczy projektu przy użyciu wygenerowanego pliku specyfikacji YAML z regułami ruchu wychodzącego.

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

Ta komórka kodu potwierdza tworzenie prywatnych punktów końcowych zdefiniowanych przez reguły ruchu wychodzącego.

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

Możesz również zweryfikować reguły ruchu wychodzącego w witrynie Azure Portal. Przejdź do obszaru Sieć z panelu po lewej stronie dla obszaru roboczego projektu, a następnie otwórz kartę Dostęp wychodzący zarządzany przez obszar roboczy .

Ten zrzut ekranu przedstawia reguły ruchu wychodzącego dla obszaru roboczego projektu w witrynie Azure Portal.

Tworzenie prototypów i opracowywanie zestawu funkcji agregacji stopniowej transakcji

Eksplorowanie danych źródła transakcji

Uwaga

Publicznie dostępny kontener obiektów blob hostuje przykładowe dane używane w tym samouczku. Można go odczytywać tylko na platformie Spark za pomocą wasbs sterownika. Podczas tworzenia zestawów funkcji przy użyciu własnych danych źródłowych hostuj je na koncie usługi ADLS Gen2 i użyj abfss sterownika w ścieżce danych.

# 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

Lokalne opracowywanie zestawu funkcji transakcji

Specyfikacja zestawu funkcji to samodzielna definicja zestawu funkcji, którą można opracowywać i testować lokalnie.

Utwórz następujące funkcje agregacji okna kroczącego:

  • liczba transakcji trzydniowych
  • suma transakcji wynosi trzy dni
  • średnia dla transakcji wynosi trzy dni
  • liczba transakcji z siedmiodniową liczbą
  • kwota siedmiu dni transakcji
  • średnia dla transakcji wynosi siedem dni

Sprawdź plik featurestore/featuresets/transactions/spec/transformation_code/transaction_transform.pykodu przekształcenia funkcji . Ten transformator spark wykonuje agregację kroczącą zdefiniowaną dla funkcji.

Aby uzyskać więcej informacji na temat zestawu funkcji i przekształceń, zobacz pojęcia dotyczące magazynu funkcji.

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

Eksportowanie specyfikacji zestawu funkcji

Aby zarejestrować specyfikację zestawu funkcji w magazynie funkcji, ta specyfikacja musi zostać zapisana w określonym formacie.

Aby sprawdzić specyfikację zestawu funkcji wygenerowanych transakcji, otwórz ten plik z drzewa plików, aby wyświetlić specyfikację:

featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml

Specyfikacja zawiera następujące elementy:

  • source: odwołanie do zasobu magazynu — w tym przypadku plik parquet w zasobie magazynu obiektów blob
  • features: lista funkcji i ich typów danych. Jeśli podasz kod przekształcenia
  • index_columns: klucze sprzężenia wymagane do uzyskiwania dostępu do wartości z zestawu funkcji

Kolejną zaletą utrwalania specyfikacji zestawu funkcji jako pliku YAML jest możliwość kontrolowania wersji specyfikacji. Dowiedz się więcej o specyfikacji zestawu funkcji w dokumencie jednostek magazynu funkcji najwyższego poziomu i dokumentacji YAML specyfikacji zestawu funkcji.

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)

Rejestrowanie jednostki magazynu funkcji

Jednostki pomagają wymusić użycie tych samych definicji kluczy sprzężenia w zestawach funkcji korzystających z tych samych jednostek logicznych. Przykłady jednostek mogą obejmować jednostki konta, jednostki klienta itp. Jednostki są zwykle tworzone raz, a następnie ponownie używane w zestawach funkcji. Aby uzyskać więcej informacji, odwiedź dokument jednostki magazynu funkcji najwyższego poziomu.

Ta komórka kodu tworzy jednostkę konta dla magazynu funkcji.

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

Rejestrowanie zestawu funkcji transakcji w magazynie funkcji i przesyłanie zadania materializacji

Aby udostępnić i użyć ponownie zasobu zestawu funkcji, musisz najpierw zarejestrować ten zasób w magazynie funkcji. Rejestracja zasobów zestawu funkcji oferuje funkcje zarządzane, w tym przechowywanie wersji i materializacja. W tej serii samouczków omówiono te tematy.

Zestaw funkcji odwołuje się zarówno do specyfikacji zestawu funkcji, która została utworzona wcześniej, jak i innych właściwości — na przykład ustawień wersji i materializacji.

Tworzenie zestawu funkcji

Następna komórka kodu używa wstępnie zdefiniowanego pliku specyfikacji YAML do utworzenia zestawu funkcji.

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

Ta komórka kodu wyświetla podgląd nowo utworzonego zestawu funkcji.

# 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

Przesyłanie zadania materializacji wypełniania

Następna komórka kodu definiuje wartości czasu rozpoczęcia i zakończenia dla okna materializacji funkcji i przesyła zadanie materializacji wypełniania.

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

Ta komórka kodu udostępnia <JOB_ID_FROM_PREVIOUS_COMMAND>element , aby sprawdzić stan zadania materializacji wypełniania.

### Check the job status

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

Ta komórka kodu zawiera listę wszystkich zadań materializacji dla bieżącego zestawu funkcji.

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

Dołączanie usługi Azure Cache for Redis jako sklepu online

Tworzenie usługi Azure Cache for Redis

W następnej komórce kodu zdefiniuj nazwę usługi Azure Cache for Redis, którą chcesz utworzyć lub użyć ponownie. Opcjonalnie można zastąpić inne ustawienia domyślne.

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

Możesz wybrać warstwę pamięci podręcznej Redis (podstawowa, Standardowa lub Premium). Należy wybrać rodzinę jednostek SKU, która jest dostępna dla wybranej warstwy pamięci podręcznej. Odwiedź ten zasób dokumentacji, aby uzyskać więcej informacji o tym, jak wybór różnych warstw może mieć wpływ na wydajność pamięci podręcznej. Odwiedź ten zasób dokumentacji, aby uzyskać więcej informacji na temat cen różnych warstw jednostki SKU i rodzin usługi Azure Cache for Redis.

Wykonaj następującą komórkę kodu, aby utworzyć pamięć podręczną Azure Cache for Redis z warstwą Premium, rodziną P jednostek SKU i pojemnością pamięci podręcznej 2. Aprowizowania wystąpienia usługi Redis może upłynąć około 5–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)

Aktualizowanie magazynu funkcji za pomocą sklepu online

Dołącz usługę Azure Cache for Redis do magazynu funkcji, aby użyć jej jako magazynu materializacji online. Następna komórka kodu tworzy plik specyfikacji YAML z regułami ruchu wychodzącego magazynu online zdefiniowanymi dla magazynu funkcji.

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

Następna komórka kodu aktualizuje magazyn funkcji przy użyciu wygenerowanego pliku specyfikacji YAML z regułami ruchu wychodzącego dla sklepu online.

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

Aktualizowanie reguł ruchu wychodzącego obszaru roboczego projektu

Obszar roboczy projektu musi mieć dostęp do sklepu online. Poniższa komórka kodu tworzy plik specyfikacji YAML z wymaganymi regułami ruchu wychodzącego dla obszaru roboczego 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)

Wykonaj następną komórkę kodu, aby zaktualizować obszar roboczy projektu przy użyciu wygenerowanego pliku specyfikacji YAML z regułami ruchu wychodzącego dla sklepu online.

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

Materializowanie funkcji transakcji ustawionych na sklep online

Następna komórka kodu umożliwia materializację online dla transactions zestawu funkcji.

# 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

Następna komórka kodu definiuje czas rozpoczęcia i zakończenia okna materializacji funkcji i przesyła zadanie materializacji wypełniania.

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

Generowanie danych szkoleniowych przy użyciu zarejestrowanych funkcji

Ładowanie danych obserwacji

Najpierw zapoznaj się z danymi obserwacji. Podstawowe dane używane do trenowania i wnioskowania zwykle obejmują dane obserwacji. Te dane są następnie łączone z danymi funkcji, aby utworzyć pełny zasób danych treningowych. Dane obserwacji to dane przechwycone w czasie zdarzenia. W tym przypadku zawiera podstawowe dane transakcji, w tym identyfikator transakcji, identyfikator konta i wartości kwoty transakcji. W tym miejscu, ponieważ dane obserwacji są używane do trenowania, zawiera również dołączona zmienna docelowa (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

Pobieranie zarejestrowanego zestawu funkcji i wyświetlanie listy jego funkcji

Następnie pobierz zestaw funkcji, podając jego nazwę i wersję, a następnie wyświetl listę funkcji w tym zestawie funkcji. Ponadto wyświetl kilka przykładowych wartości funkcji.

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

Wybieranie funkcji i generowanie danych treningowych

Wybierz funkcje dla danych szkoleniowych i użyj zestawu SDK magazynu funkcji, aby wygenerować dane szkoleniowe.

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

Sprzężenie do punktu w czasie dołączało funkcje do danych treningowych.

Opcjonalne następne kroki

Po pomyślnym utworzeniu bezpiecznego magazynu funkcji i przesłaniu pomyślnego uruchomienia materializacji możesz przejść przez serię samouczków, aby utworzyć informacje o magazynie funkcji.

Ten samouczek zawiera kombinację kroków z samouczków 1 i 2 tej serii. Pamiętaj, aby zastąpić niezbędne kontenery magazynu publicznego używane w innych notesach samouczka tymi utworzonymi w tym notesie samouczka na potrzeby izolacji sieciowej.

Na tym kończymy ten samouczek. Dane szkoleniowe korzystają z funkcji z magazynu funkcji. Możesz zapisać go w magazynie do późniejszego użycia lub bezpośrednio uruchomić trenowanie modelu.

Następne kroki

  • Last updated on