Megosztás a következőn keresztül:

6. oktatóanyag: Hálózatelkülönítés funkciótárolóval

  • Cikk

Az Azure Machine Tanulás kezelt funkciótár lehetővé teszi a funkciók felderítését, létrehozását és üzembe helyezése. A funkciók a gépi tanulási életciklus kötőszöveteként szolgálnak, kezdve a prototípuskészítési fázistól, ahol különböző funkciókkal kísérletezik. Ez az életciklus továbbra is az üzemeltetési fázisig tart, ahol üzembe helyezi a modelleket, és a következtetési lépések megkeresik a funkcióadatokat. A funkciótárolókkal kapcsolatos további információkért olvassa el a funkciótárolók alapfogalmait ismertető dokumentumot.

Ez az oktatóanyag bemutatja, hogyan konfigurálható a biztonságos bejövő forgalom egy privát végponton keresztül, és hogyan lehet biztonságossá tenni a kimenő forgalmat egy felügyelt virtuális hálózaton keresztül.

Az oktatóanyag-sorozat 1. része bemutatta, hogyan hozhat létre szolgáltatáskészlet-specifikációt egyéni átalakításokkal, és hogyan hozhat létre betanítási adatokat a funkciókészlettel. A sorozat 2. része bemutatta, hogyan engedélyezheti a materializálást, és hogyan végezheti el a visszatöltést. A 2. rész azt is bemutatta, hogyan kísérletezhet a funkciókkal a modell teljesítményének javítása érdekében. A 3. rész bemutatta, hogyan növeli a funkciótároló az agilitást a kísérletezési és betanítási folyamatokban. A 3. rész azt is leírta, hogyan lehet kötegelt következtetést futtatni. A 4. oktatóanyag bemutatja, hogyan használható a funkciótár online/valós idejű következtetési használati esetekhez. Az 5. oktatóanyag bemutatja, hogyan fejleszthet egy szolgáltatáskészletet egy egyéni adatforrással. A 6. oktatóanyag bemutatja, hogyan

  • Állítsa be a kezelt funkciótár hálózati elkülönítéséhez szükséges erőforrásokat.
  • Hozzon létre egy új szolgáltatástár-erőforrást.
  • Állítsa be a szolgáltatástárolót a hálózatelkülönítési forgatókönyvek támogatásához.
  • Frissítse a projekt-munkaterületet (az aktuális munkaterületet) a hálózatelkülönítési forgatókönyvek támogatásához.

Előfeltételek

Feljegyzés

Ez az oktatóanyag egy Azure Machine Tanulás-jegyzetfüzetet használ kiszolgáló nélküli Spark Compute használatával.

  • Mindenképpen végezze el az oktatóanyag-sorozat 1–4. részét

  • Azure Machine Tanulás munkaterület, amely felügyelt virtuális hálózattal van engedélyezve kiszolgáló nélküli Spark-feladatokhoz

  • A projekt-munkaterület konfigurálása:

    1. Hozzon létre egy YAML-fájlt:network.yml

      managed_network:
isolation_mode: allow_internet_outbound

    2. Hajtsa végre az alábbi parancsokat a munkaterület frissítéséhez és a felügyelt virtuális hálózat kiszolgáló nélküli Spark-feladatokhoz való kiépítéséhez:

      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

    További információ: Konfigurálás kiszolgáló nélküli spark-feladathoz.

  • A felhasználói fióknak rendelkeznie kell a Owner funkciótárolót létrehozó erőforráscsoporthoz vagy Contributor szerepkörhöz rendelve. A felhasználói fióknak is szüksége van a szerepkörre User Access Administrator .

Fontos

Az Azure Machine Tanulás munkaterületen állítsa be a isolation_mode következőtallow_internet_outbound: . Ez az egyetlen támogatott hálózatelkülönítési mód. Ez az oktatóanyag bemutatja, hogyan csatlakozhat biztonságosan a forrásokhoz, a materializálási tárolóhoz és a megfigyelési adatokhoz privát végpontokon keresztül.

Beállítás

Ez az oktatóanyag a Python szolgáltatástároló alapvető SDK-ját (azureml-featurestore) használja. A Python SDK csak a funkciókészletek fejlesztéséhez és teszteléséhez használható. A parancssori felület használatával létrehozhat, olvashat, frissíthet és törölhet (CRUD) műveleteket a szolgáltatástárolókon, a szolgáltatáskészleteken és a szolgáltatástár-entitásokon. Ez olyan folyamatos integráció és folyamatos teljesítés (CI/CD) vagy GitOps-forgatókönyvek esetében hasznos, ahol a CLI/YAML használata előnyben részesített.

Ehhez az oktatóanyaghoz nem kell explicit módon telepítenie ezeket az erőforrásokat, mert az itt látható beállítási utasításokban a conda.yaml fájl ismerteti őket.

A jegyzetfüzet környezetének előkészítése a fejlesztéshez:

  1. Klónozza az azureml-examples adattárat a helyi GitHub-erőforrásokba az alábbi paranccsal:

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

    Zip-fájlt is letölthet az azureml-examples adattárból. Ezen a lapon először válassza ki a code legördülő menüt, majd válassza a lehetőséget Download ZIP. Ezután bontsa ki a tartalmat a helyi eszköz egyik mappájába.

  2. A szolgáltatástár mintakönyvtárának feltöltése a projekt-munkaterületre

    1. Az Azure Machine Tanulás munkaterületen nyissa meg az Azure Machine Tanulás studio felhasználói felületét
    2. Jegyzetfüzetek kiválasztása a bal oldali navigációs panelen
    3. Válassza ki a felhasználónevet a címtárlistában
    4. Jelölje ki a három pontot (...), majd válassza a Mappa feltöltése lehetőséget
    5. Válassza ki a szolgáltatástár mintáinak mappáját a klónozott címtár elérési útjából: azureml-examples/sdk/python/featurestore-sample

  3. Az oktatóanyag futtatása

    • 1. lehetőség: Hozzon létre egy új jegyzetfüzetet, és hajtsa végre a dokumentumban található utasításokat lépésről lépésre

    • 2. lehetőség: Meglévő jegyzetfüzet featurestore_sample/notebooks/sdk_and_cli/network_isolation/Network-isolation-feature-store.ipynbmegnyitása. Ezt a dokumentumot megnyitva tarthatja, és további magyarázatokért és dokumentációs hivatkozásokért tekintse meg

      1. Válassza a Kiszolgáló nélküli Spark Compute lehetőséget a felső navigációs Compute legördülő listában. Ez a művelet egy-két percet is igénybe vehet. Várjon egy állapotsort a tetején a Konfigurálás munkamenet megjelenítéséhez
      2. Válassza a Munkamenet konfigurálása lehetőséget a felső állapotsoron
      3. Python-csomagok kiválasztása
      4. Válassza a Conda-fájl feltöltése lehetőséget
      5. Válassza ki a helyi eszközön található fájlt azureml-examples/sdk/python/featurestore-sample/project/env/conda.yml
      6. (Nem kötelező) A kiszolgáló nélküli Spark-fürt indítási idejének csökkentése érdekében növelje a munkamenet időtúllépését (percek alatt üresjárati időt)

  4. Ez a kódcella elindítja a Spark-munkamenetet. Az összes függőség telepítéséhez és a Spark-munkamenet elindításához körülbelül 10 perc szükséges.

    # 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. A minták gyökérkönyvtárának beállítása

    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. Az Azure Machine Tanulás parancssori felületének beállítása:

    • Az Azure Machine Tanulás CLI-bővítmény telepítése

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

    • Hitelesítés

      # authenticate
!az login

    • Az alapértelmezett előfizetés beállítása

      # Set default subscription
import os

subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]

!az account set -s $subscription_id

    Feljegyzés

    A funkciótár-munkaterület támogatja a funkciók projektek közötti újrafelhasználását. A projekt-munkaterület – a jelenlegi használatban lévő munkaterület – egy adott szolgáltatástároló funkcióit használja a modellek betanításához és következtetéséhez. Számos projekt-munkaterület megoszthatja és újra felhasználhatja ugyanazt a funkciótár-munkaterületet.

A szükséges erőforrások kiépítése

Létrehozhat egy új Azure Data Lake Storage-fiókot (ADLS) Gen2-tárfiókot és -tárolókat, vagy újra felhasználhatja a meglévő tárfiókot és tárolóerőforrásokat a funkciótárolóhoz. Valós helyzetben különböző tárfiókok üzemeltethetik az ADLS Gen2-tárolókat. Mindkét lehetőség a konkrét követelményektől függően működik.

Ebben az oktatóanyagban három különálló tárolót hoz létre ugyanabban az ADLS Gen2-tárfiókban:

  • Forrásadatok
  • Offline áruház
  • Megfigyelési adatok

  1. Hozzon létre egy ADLS Gen2-tárfiókot a forrásadatokhoz, az offline tároláshoz és a megfigyelési adatokhoz.

    1. Adja meg egy Azure Data Lake Storage Gen2-tárfiók nevét az alábbi kódmintában. Az alábbi kódcellát a megadott alapértelmezett beállításokkal hajthatja végre. Igény szerint felülbírálhatja az alapértelmezett beállításokat.

      ## 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. Ez a kódcella létrehozza a fenti kódcellában definiált ADLS Gen2-tárfiókot.

      # 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. Ez a kódcella létrehoz egy új tárolót az offline tárolóhoz.

      # 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. Ez a kódcella létrehoz egy új tárolót a forrásadatokhoz.

      # 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. Ez a kódcella létrehoz egy új tárolót a megfigyelési adatokhoz.

      # 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. Másolja az oktatóanyag-sorozathoz szükséges mintaadatokat az újonnan létrehozott tárolókba.

    1. Ha adatokat szeretne írni a tárolókba, győződjön meg arról, hogy a közreműködői és a tárolási blobadat-közreműködői szerepkörök hozzá vannak rendelve a felhasználói identitáshoz a létrehozott ADLS Gen2-tárfiókon az Azure Portalon az alábbi lépéseket követve.

      Fontos

      Miután meggyőződött arról, hogy a közreműködői és tárolási blobadat-közreműködői szerepkörök hozzá vannak rendelve a felhasználói identitáshoz, várjon néhány percet a szerepkör-hozzárendelés után, és hagyja, hogy az engedélyek propagáljanak, mielőtt továbblép a következő lépésekre. A hozzáférés-vezérléssel kapcsolatos további információkért látogasson el az Azure Storage-fiókok szerepköralapú hozzáférés-vezérlésére (RBAC)

      A következő kódcellák az oktatóanyagban használt tranzakciók forrásadatait másolják át egy nyilvános tárfiókból az újonnan létrehozott tárfiókba.

      # 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. Az oktatóanyagban használt fiókfunkció-készlethez másolja a fiókfunkció-készlet mintaforrás-adatait az újonnan létrehozott tárfiókba.

      # 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. Másolja a betanításhoz használt mintamegfigyelési adatokat egy nyilvános tárfiókból az újonnan létrehozott tárfiókba.

      # 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. Másolja a kötegelt következtetéshez használt megfigyelési mintaadatokat egy nyilvános tárfiókból az újonnan létrehozott tárfiókba.

      # 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. Tiltsa le a nyilvános hálózati hozzáférést az újonnan létrehozott tárfiókon.

    1. Ez a kódcella letiltja a korábban létrehozott ADLS Gen2 tárfiók nyilvános hálózati hozzáférését.

      # 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. Arm-azonosítók beállítása offline tárolókhoz, forrásadatokhoz és megfigyelési adattárolókhoz.

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

Funkciótár létrehozása a materializálás engedélyezésével

A funkciótároló paramétereinek beállítása

Állítsa be a szolgáltatástár nevét, helyét, előfizetés-azonosítóját, csoportnevét és ARM-azonosító értékeit az alábbi kódcella-mintában látható módon:

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

Ez a kódcella létrehoz egy YAML-specifikációs fájlt egy szolgáltatástárolóhoz, és engedélyezve van a materializálás.

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

A szolgáltatástár létrehozása

Ez a kódcella az előző lépésben létrehozott YAML-specifikációs fájlt használja egy olyan funkciótároló létrehozásához, amely engedélyezve van a materializálással.

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

Az Azure Machine Tanulás szolgáltatástároló alapvető SDK-ügyfélének inicializálása

Az ebben a cellában inicializált SDK-ügyfél megkönnyíti a funkciók fejlesztését és használatát:

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

Szerepkörök hozzárendelése a felhasználói identitáshoz a funkciótárolóban

Kövesse ezeket az utasításokat a Felhasználói identitás Microsoft Entra-objektumazonosítójának lekéréséhez. Ezután a Következő parancsban a Microsoft Entra objektumazonosítójával rendelje hozzá az AzureML adattudós szerepkört a létrehozott szolgáltatástároló felhasználói identitásához.

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

Szerezze be a funkciótároló alapértelmezett tárfiókját és kulcstartóját, és tiltsa le a nyilvános hálózati hozzáférést a megfelelő erőforrásokhoz

A következő kódcella a következő lépések funkciótároló objektumát adja vissza.

fs = featurestore.feature_stores.get()

Ez a kódcella a funkciótároló alapértelmezett tárfiókjának és kulcstartójának nevét adja vissza.

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

Ez a kódcella letiltja a szolgáltatástároló alapértelmezett tárfiókjának nyilvános hálózati hozzáférését.

# 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

A következő cella a funkciótároló alapértelmezett kulcstartójának nevét nyomtatja ki.

print(default_key_vault_name)

A korábban létrehozott alapértelmezett szolgáltatástároló kulcstartójának nyilvános hálózati hozzáférésének letiltása

  • Az Azure Portalon nyissa meg az előző cellában létrehozott alapértelmezett kulcstartót.
  • Válassza a Hálózatkezelés lapot.
  • Válassza a Nyilvános hozzáférés letiltása, majd az Alkalmazás elemet a lap bal alsó részén.

A felügyelt virtuális hálózat engedélyezése a funkciótár-munkaterületen

A szolgáltatástároló frissítése a szükséges kimenő szabályokkal

A következő kódcella létrehoz egy YAML-specifikációs fájlt a szolgáltatástárolóhoz definiált kimenő szabályokhoz.

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

Ez a kódcella a létrehozott YAML-specifikációfájlt használja a funkciótároló frissítéséhez.

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

Privát végpontok létrehozása a megadott kimenő szabályokhoz

A provision-network parancs privát végpontokat hoz létre a felügyelt virtuális hálózatból, ahol a materializálási feladat a forrásra, az offline tárolóra, a megfigyelési adatokra, az alapértelmezett tárfiókra és a funkciótároló alapértelmezett kulcstartójára fut. A parancs végrehajtásához körülbelül 20 perc szükséges.

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

Ez a kódcella megerősíti a kimenő szabályok által meghatározott privát végpontok létrehozását.

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

A projekt-munkaterület felügyelt virtuális hálózatának frissítése

Ezután frissítse a projekt-munkaterület felügyelt virtuális hálózatát. Először szerezze be a projekt-munkaterület előfizetés-azonosítóját, erőforráscsoportját és munkaterületnevét.

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

A projekt munkaterületének frissítése a szükséges kimenő szabályokkal

A projekt-munkaterületnek hozzá kell férnie az alábbi erőforrásokhoz:

  • Forrásadatok
  • Offline áruház
  • Megfigyelési adatok
  • Funkciótár
  • A funkciótároló alapértelmezett tárfiókja

Ez a kódcella frissíti a projekt-munkaterületet a létrehozott YAML-specifikációs fájllal a szükséges kimenő szabályokkal.

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

Ez a kódcella frissíti a projekt-munkaterületet a létrehozott YAML specifikációs fájl használatával a kimenő szabályokkal.

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

Ez a kódcella megerősíti a kimenő szabályok által meghatározott privát végpontok létrehozását.

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

A kimenő szabályokat az Azure Portalról is ellenőrizheti. Lépjen a Hálózatkezelés lapra a projekt-munkaterület bal oldali navigációs paneljén, majd nyissa meg a Munkaterület felügyelt kimenő hozzáférés lapját.

Ez a képernyőkép egy projekt-munkaterület kimenő szabályait mutatja be az Azure Portalon.

Tranzakciós összesítési funkciókészlet prototípusa és fejlesztése

A tranzakciók forrásadatainak megismerése

Feljegyzés

Egy nyilvánosan elérhető blobtároló tárolja az oktatóanyagban használt mintaadatokat. Csak illesztőprogramon keresztül wasbs olvasható a Sparkban. Ha saját forrásadatokkal hoz létre szolgáltatáskészleteket, azokat egy ADLS Gen2-fiókban tárolja, és használjon egy illesztőprogramot abfss az adatútvonalon.

# 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

Tranzakciós funkciókészlet helyi fejlesztése

A funkciókészlet-specifikáció egy önálló funkciókészlet-definíció, amely helyileg fejleszthető és tesztelhető.

Hozza létre a következő gördülőablak-összesítő funkciókat:

  • tranzakciók háromnapos száma
  • tranzakciók összege háromnapos összeg
  • tranzakciók összege háromnapos átlagos idő
  • tranzakciók hétnapos száma
  • tranzakciók összege hétnapos összeg
  • tranzakciók összege hétnapos átlagos idő

Vizsgálja meg a funkcióátalakítási kódfájlt featurestore/featuresets/transactions/spec/transformation_code/transaction_transform.py. Ez a spark-transzformátor végrehajtja a funkciókhoz definiált gördülő összesítést.

A funkciókészlettel és az átalakításokkal kapcsolatos további információkért tekintse meg a funkciótár alapfogalmait.

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

Szolgáltatáskészlet-specifikáció exportálása

Ha regisztrálni szeretne egy szolgáltatáskészlet-specifikációt a szolgáltatástárolóban, ezt a specifikációt egy adott formátumban kell menteni.

A létrehozott tranzakciós szolgáltatáskészlet specifikációjának vizsgálatához nyissa meg ezt a fájlt a fájlfáról a specifikáció megtekintéséhez:

featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml

A specifikáció a következő elemeket tartalmazza:

  • source: egy tárolási erőforrásra mutató hivatkozás – ebben az esetben egy blobtároló-erőforrás parquet-fájlja
  • features: a funkciók és adattípusaik listája. Ha átalakítási kódot ad meg
  • index_columns: a funkciókészlet értékeinek eléréséhez szükséges illesztőkulcsok

A szolgáltatáskészlet-specifikáció YAML-fájlként való megőrzésének másik előnye, hogy a specifikáció verziókonfigurálható. További információ a funkciókészlet specifikációjáról a legfelső szintű funkciótároló-entitások dokumentumában , valamint a szolgáltatáskészlet specifikációjának YAML-referenciajában.

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)

Szolgáltatástár-entitás regisztrálása

Az entitások az azonos logikai entitásokat használó funkciókészletek esetében segítenek kikényszeríteni ugyanazon illesztéskulcs-definíciók használatát. Az entitások lehetnek például fiókentitások, ügyfélentitások stb. Az entitások általában egyszer jönnek létre, majd újra felhasználhatók a funkciókészletek között. További információkért látogasson el a legfelső szintű funkciótároló entitások dokumentumára.

Ez a kódcella létrehoz egy fiókentitást a szolgáltatástárolóhoz.

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

A tranzakciós funkciókészlet regisztrálása a funkciótárolóban, és egy materializálási feladat elküldése

Egy funkciókészlet-objektum megosztásához és újrafelhasználásához először regisztrálnia kell az objektumot a funkciótárolóban. A funkciókészlet eszközregisztrációja felügyelt képességeket kínál, beleértve a verziószámozást és a materializálást. Ez az oktatóanyag-sorozat ezeket a témaköröket ismerteti.

A funkciókészlet-objektum a korábban létrehozott szolgáltatáskészlet-specifikációra és más tulajdonságokra is hivatkozik – például verzió- és materializálási beállításokra.

Szolgáltatáskészlet létrehozása

A következő kódcella egy előre definiált YAML-specifikációs fájlt használ egy szolgáltatáskészlet létrehozásához.

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

Ez a kódcella az újonnan létrehozott funkciókészletet tekinti meg.

# 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

Backfill materialization feladat elküldése

A következő kódcella meghatározza a funkció materializálási ablakának kezdési és befejezési időértékeit, és beküld egy backfill materialization feladatot.

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

Ez a kódcella a backfill materialization feladat állapotának ellenőrzéséhez nyújt <JOB_ID_FROM_PREVIOUS_COMMAND>segítséget.

### Check the job status

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

Ez a kódcella felsorolja az aktuális funkciókészlet összes materializálási feladatát.

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

Azure Cache for Redis csatolása online áruházként

Az Azure Cache for Redis létrehozása

A következő kódcellában adja meg a létrehozni vagy újra felhasználni kívánt Azure Cache for Redis nevét. Igény szerint felülbírálhatja az egyéb alapértelmezett beállításokat.

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

Kiválaszthatja a Redis cache réteget (alapszintű, standard vagy prémium). A kiválasztott gyorsítótárszinthez elérhető termékváltozatcsaládot kell választania. Ebben a dokumentációs forrásanyagban további információt talál arról, hogy a különböző szintek kiválasztása hogyan befolyásolhatja a gyorsítótár teljesítményét. Ebben a dokumentációs forrásanyagban további információt talál az Azure Cache for Redis különböző termékváltozat-szintjeinek és családjainak díjszabásáról.

Hajtsa végre a következő kódcellát egy Prémium szintű, termékváltozatcsaláddal P és 2. gyorsítótárkapacitással rendelkező Azure Cache for Redis létrehozásához. A Redis-példány üzembe helyezése körülbelül 5–10 percet vehet igénybe.

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

Funkciótár frissítése az online áruházral

Csatolja az Azure Cache for Redist a szolgáltatástárhoz, hogy online materializációs tárolóként használhassa. A következő kódcella létrehoz egy YAML-specifikációs fájlt a szolgáltatástárolóhoz definiált online áruházi kimenő szabályokkal.

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

A következő kódcella frissíti a szolgáltatástárolót a létrehozott YAML-specifikációs fájllal az online áruház kimenő szabályaival.

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

Projekt-munkaterület kimenő szabályainak frissítése

A projekt-munkaterületnek hozzá kell férnie az online áruházhoz. Az alábbi kódcella létrehoz egy YAML-specifikációs fájlt a projekt-munkaterülethez szükséges kimenő szabályokkal.

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)

Hajtsa végre a következő kódcellát a projekt munkaterületének a létrehozott YAML-specifikációs fájllal való frissítéséhez az online áruház kimenő szabályaival.

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

Tranzakciós funkció online áruházba való beállítása

A következő kódcella lehetővé teszi a funkciókészlet online materializálását transactions .

# 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

A következő kódcella határozza meg a funkció materializálási ablakának kezdési és befejezési idejét, és beküld egy backfill materialization feladatot.

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

Betanítási adatok létrehozása a regisztrált funkciókkal

Megfigyelési adatok betöltése

Először vizsgálja meg a megfigyelési adatokat. A betanításhoz és következtetéshez használt alapvető adatok általában megfigyelési adatokat foglalnak magukban. Ezek az adatok ezután funkcióadatokkal lesznek összekapcsolva egy teljes betanítási adaterőforrás létrehozásához. A megfigyelési adatok az esemény ideje alatt rögzített adatok. Ebben az esetben alapvető tranzakciós adatokkal rendelkezik, beleértve a tranzakcióazonosítót, a fiókazonosítót és a tranzakció összegének értékeit. Mivel a megfigyelési adatokat a betanításhoz használják, a célváltozó is hozzá van fűzve (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

A regisztrált funkciókészlet lekérése és funkcióinak listázása

Ezután szerezze be a szolgáltatáskészletet a nevének és verziójának megadásával, majd a funkciókészlet funkcióinak listázásával. Emellett nyomtasson ki néhány mintafunkció-értéket is.

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

Funkciók kiválasztása és betanítási adatok létrehozása

Válassza ki a betanítási adatok funkcióit, és használja a funkciótároló SDK-t a betanítási adatok létrehozásához.

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

Egy időponthoz kötött illesztés fűzte hozzá a funkciókat a betanítási adatokhoz.

Nem kötelező a következő lépések

Most, hogy sikeresen létrehozott egy biztonságos szolgáltatástárolót, és sikeres materializálási futtatásokat küldött be, folytathatja az oktatóanyag-sorozatot, hogy megismerje a funkciótárolót.

Ez az oktatóanyag a sorozat 1. és 2. oktatóanyagának lépéseit tartalmazza. Ne felejtse el lecserélni a többi oktatóanyag-jegyzetfüzetben használt szükséges nyilvános tárolókat az ebben az oktatóanyag-jegyzetfüzetben létrehozott tárolókra a hálózatelkülönítéshez.

Ezzel az oktatóanyag végére ért. A betanítási adatok funkciótárolóból származó funkciókat használnak. Mentheti a tárolóba későbbi használatra, vagy közvetlenül futtathatja rajta a modell betanítását.

Következő lépések