Samouczek 4. Włączanie materializacji online i uruchamianie wnioskowania online

Magazyn funkcji zarządzanych Azure Machine Learning ułatwia odnajdywanie, tworzenie i operacjonalizacja funkcji. Funkcje łączą cykl życia uczenia maszynowego, począwszy od fazy tworzenia prototypów, w której eksperymentujesz z różnymi funkcjami. 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 zarządzanego magazynu funkcji, zobacz Co to jest zarządzany magazyn funkcji?

Ważna

Azure Cache for Redis ogłosiła harmonogram wycofania wszystkich SKU. Zalecamy przeniesienie istniejących wystąpień Azure Cache for Redis do usługi Azure Managed Redis tak szybko, jak to możliwe.

Wskazówki dotyczące migracji:

• Przenieś warstwy Podstawowa, Standardowa i Premium do zarządzanej usługi Redis w Azure
• Migruj warstwę Enterprise do usługi Azure Managed Redis

Aby uzyskać więcej informacji na temat przejścia na emeryturę:

• Wycofanie Azure Cache for Redis: Co warto wiedzieć i jak się przygotować
• FAQ dotyczące wycofywania Azure Cache for Redis

W samouczku 1 pokazano, jak utworzyć specyfikację zestawu funkcji z przekształceniami niestandardowymi, a następnie użyć tego zestawu funkcji do generowania danych treningowych, włączania materializacji i wykonywania wypełniania. W samouczku 2 pokazano, jak eksperymentować z funkcjami w celu zwiększenia wydajności modelu, a następnie trenować i rejestrować model korzystający z funkcji. W samouczku 3 pokazano, jak włączyć rekursywną materializację zestawu transactions funkcji i uruchomić potok wnioskowania wsadowego.

W tym samouczku nauczysz się następujących czynności:

• Konfiguracja Azure Cache for Redis
• Dołączanie pamięci podręcznej do magazynu funkcji jako magazynu materializacji online i udzielanie niezbędnych uprawnień
• Materializowanie zestawu funkcji w sklepie online
• Testowanie wdrożenia online przy użyciu pozornych danych

Wymagania wstępne

Uwaga

W tym samouczku używany jest notatnik Azure Machine Learning z Serverless Spark Compute.

• Pamiętaj, aby ukończyć samouczki od 1 do 3 w tej serii. W tym samouczku jest używany magazyn funkcji i inne zasoby utworzone we wcześniejszych samouczkach.

Konfiguruj

W tym samouczku używa się podstawowego zestawu SDK magazynu funkcji Python (azureml-featurestore). Zestaw SDK Python służy do operacji tworzenia, odczytu, aktualizowania i usuwania (CRUD) w magazynach funkcji, zestawach funkcji i jednostkach magazynu funkcji.

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

1. Skonfiguruj notatnik Azure Machine Learning Spark.

   Możesz utworzyć nowy notes i wykonać instrukcje opisane w tym samouczku krok po kroku. Możesz również otworzyć i uruchomić istniejący notatnik featurestore_sample/notebooks/sdk_only/4.Enable-online-store-run-inference.ipynb. Pozostaw ten samouczek otwarty i zapoznaj się z nim, aby uzyskać linki do dokumentacji i więcej wyjaśnień.

   1. Na liście rozwijanej Obliczenia na górnym pasku nawigacyjnym wybierz pozycję Bezserwerowe obliczenia platformy Spark.

   2. Skonfiguruj sesję:

      1. Pobierz plik azureml-examples/sdk/python/featurestore-sample/project/env/online.yml na komputer lokalny
      2. W konfiguruj sesję w górnym pasku nawigacyjnym wybierz Pakiety Pythona
      3. Wybierz Prześlij plik Conda
      4. Przekaż plik online.yml z komputera lokalnego, wykonując te same kroki opisane w artykule Przekazywanie pliku conda.yml w samouczku 1.
      5. Opcjonalnie zwiększ limit czasu sesji (czas bezczynności), aby uniknąć częstych ponownych uruchomień wymagań wstępnych

2. 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 approximately 10 mins.
   print("start spark session")

3. Skonfiguruj katalog główny dla przykładów

   import os
   
   # Please update the dir to ./Users/<your_user_alias> (or any custom directory you uploaded the samples to).
   # You can find the name from the directory structure in the left navigation panel.
   root_dir = "./Users/<your_user_alias>/featurestore_sample"
   
   if os.path.isdir(root_dir):
       print("The folder exists.")
   else:
       print("The folder does not exist. Please create or fix the path")

4. Zainicjuj obszar roboczy projektu MLClient, w którym jest uruchamiany notes samouczka. Element MLClient jest używany do operacji tworzenia, odczytu, aktualizowania i usuwania (CRUD).

   import os
   from azure.ai.ml import MLClient
   from azure.ai.ml.identity import AzureMLOnBehalfOfCredential
   
   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"]
   
   # Connect to the project workspace
   ws_client = MLClient(
       AzureMLOnBehalfOfCredential(), project_ws_sub_id, project_ws_rg, project_ws_name
   )

5. Zainicjuj MLClient obszar roboczy magazynu funkcji dla operacji tworzenia, odczytu, aktualizacji i usuwania (CRUD) w obszarze roboczym magazynu funkcji.

   from azure.ai.ml import MLClient
   from azure.ai.ml.identity import AzureMLOnBehalfOfCredential
   
   # Feature store
   featurestore_name = (
       "<FEATURESTORE_NAME>"  # use the same name from part #1 of the tutorial
   )
   featurestore_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
   featurestore_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]
   
   # Feature store MLClient
   fs_client = MLClient(
       AzureMLOnBehalfOfCredential(),
       featurestore_subscription_id,
       featurestore_resource_group_name,
       featurestore_name,
   )

   Uwaga

   Obszar roboczy feature store obsługuje ponowne użycie cech w projektach. Obszar roboczy projektu — bieżący obszar roboczy używany — wykorzystuje cechy z konkretnego sklepu funkcji do trenowania modeli i przeprowadzania wnioskowań. Wiele obszarów roboczych projektu może współużytkować i ponownie używać tego samego obszaru roboczego magazynu funkcji.

6. Jak wspomniano wcześniej, w tym samouczku jest używany podstawowy zestaw SDK magazynu funkcji Python (azureml-featurestore). Ten zainicjowany klient zestawu SDK służy do wykonywania operacji tworzenia, odczytu, aktualizacji i usuwania (CRUD) w magazynach funkcji, zestawach funkcji i jednostkach magazynu funkcji.

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

Przygotuj Azure Cache for Redis

W tym samouczku użyto Azure Cache for Redis jako repozytorium materializacji online. Możesz utworzyć nowe wystąpienie usługi Redis lub ponownie użyć istniejącego wystąpienia.

1. Ustaw wartości zasobu Azure Cache for Redis do użycia jako magazyn materializacji online. W tej komórce kodu zdefiniuj nazwę zasobu Azure Cache for Redis do utworzenia lub ponownego użycia. Możesz zastąpić inne ustawienia domyślne.

   ws_location = ws_client.workspaces.get(ws_client.workspace_name).location
   
   redis_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
   redis_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]
   redis_name = "<REDIS_NAME>"
   redis_location = ws_location

2. Możesz utworzyć nowe wystąpienie usługi Redis. Należy wybrać odpowiednią warstwę pamięci podręcznej Redis Cache (podstawowa, Standardowa, Premium lub Enterprise). Wybierz rodzinę jednostek SKU dostępną dla wybranej warstwy pamięci podręcznej. Aby uzyskać więcej informacji na temat warstw i wydajności pamięci podręcznej, odwiedź ten zasób. Aby uzyskać więcej informacji na temat warstw SKU i rodzin pamięci podręcznej Azure, odwiedź stronę this resource.

   Wykonaj tę komórkę kodu, aby utworzyć Azure Cache for Redis z warstwą Premium, rodziną SKU P i pojemnością pamięci podręcznej o wartości 2. Przygotowanie instancji systemu Redis może potrwać od 5 do 10 minut.

   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),
           ),
       )
       .result()
       .id
   )
   
   print(redis_arm_id)

3. Opcjonalnie ta komórka kodu ponownie używa istniejącego wystąpienia usługi Redis z wcześniej zdefiniowaną nazwą.

   redis_arm_id = "/subscriptions/{sub_id}/resourceGroups/{rg}/providers/Microsoft.Cache/Redis/{name}".format(
       sub_id=redis_subscription_id,
       rg=redis_resource_group_name,
       name=redis_name,
   )

Dołączanie magazynu materializacji online do magazynu funkcji

Magazyn funkcji wymaga Azure Cache for Redis jako dołączonego zasobu do użycia jako magazynu materializacji online. Ta komórka kodu obsługuje ten krok.

from azure.ai.ml.entities import (
    ManagedIdentityConfiguration,
    FeatureStore,
    MaterializationStore,
)

online_store = MaterializationStore(type="redis", target=redis_arm_id)

ml_client = MLClient(
    AzureMLOnBehalfOfCredential(),
    subscription_id=featurestore_subscription_id,
    resource_group_name=featurestore_resource_group_name,
)

fs = FeatureStore(
    name=featurestore_name,
    online_store=online_store,
)

fs_poller = ml_client.feature_stores.begin_create(fs)
print(fs_poller.result())

Uwaga

Podczas aktualizacji magazynu funkcji, samo ustawienie grant_materiaization_permissions=True nie zapewni wymaganych uprawnień RBAC dla UAI. Przypisanie ról do UAI nastąpi tylko wtedy, gdy zostanie zaktualizowany jeden z następujących elementów:

• Tożsamość materializacji
• Docelowy magazyn w trybie offline
• Docelowy sklep online

Aby uzyskać przykład pokazujący, jak to zrobić za pomocą zestawu SDK, odwiedź zasób Tutorial: Różne podejścia do zarządzania magazynem funkcji.

Materializuj dane zbioru funkcji do sklepu internetowego

Włączanie materializacji w accounts zestawie funkcji

Wcześniej w tej serii samouczków nie zmaterializowałeś zestawu funkcji konta, ponieważ miał wstępnie obliczone funkcje i były używane tylko w scenariuszach wnioskowania wsadowego. Ta komórka kodu umożliwia materializację online, dzięki czemu funkcje staną się dostępne w sklepie online z dostępem o małych opóźnieniach. W celu zapewnienia spójności umożliwia również materializację w trybie offline. Włączenie materializacji w trybie offline jest opcjonalne.

from azure.ai.ml.entities import (
    MaterializationSettings,
    MaterializationComputeResource,
)

# Turn on both offline and online materialization on the "accounts" featureset.

accounts_fset_config = fs_client._featuresets.get(name="accounts", version="1")

accounts_fset_config.materialization_settings = MaterializationSettings(
    offline_enabled=True,
    online_enabled=True,
    resource=MaterializationComputeResource(instance_type="standard_e8s_v3"),
    spark_configuration={
        "spark.driver.cores": 4,
        "spark.driver.memory": "36g",
        "spark.executor.cores": 4,
        "spark.executor.memory": "36g",
        "spark.executor.instances": 2,
    },
    schedule=None,
)

fs_poller = fs_client.feature_sets.begin_create_or_update(accounts_fset_config)
print(fs_poller.result())

Uzupełniać account zestaw funkcji

Funkcja begin_backfill uzupełnia dane we wszystkich magazynach materializacji, które są aktywowane dla tego zestawu funkcji. W tym miejscu materializacja w trybie offline i online jest aktywowana. Ta komórka kodu wypełnia dane zarówno w magazynie materializacji danych online, jak i offline.

from datetime import datetime, timedelta

# Trigger backfill on the "accounts" feature set.
# Backfill from 01/01/2020 to all the way to 3 hours ago.

st = datetime(2020, 1, 1, 0, 0, 0, 0)
et = datetime.now() - timedelta(hours=3)

poller = fs_client.feature_sets.begin_backfill(
    name="accounts",
    version="1",
    feature_window_start_time=st,
    feature_window_end_time=et,
    data_status=["None"],
)
print(poller.result().job_ids)

Wskazówka

• Granularność feature_window_start_time i feature_window_end_time jest ograniczona do sekund. Każda wartość milisekundowa podana w obiekcie datetime zostanie zignorowana.
• Zadanie materializacji zostanie przesłane tylko wtedy, gdy w oknie funkcji znajdują się dane zgodne z definicją data_status podczas przesyłania zadania wypełniania.

Ta komórka kodu śledzi ukończenie zadania uzupełniania danych. Po uruchomieniu wcześniej warstwy Premium Azure Cache for Redis, ten krok może wymagać około 10 minut na ukończenie.

# Get the job URL, and stream the job logs.
# With PREMIUM Redis SKU, SKU family "P", and cache capacity 2,
# it takes approximately 10 minutes to complete.
fs_client.jobs.stream(poller.result().job_ids[0])

Materializowanie transactions danych zestawu funkcji do sklepu online

Wcześniej w tej serii samouczków zmaterializujesz transactions dane zestawu funkcji do magazynu materializacji w trybie offline.

1. Ta komórka kodu umożliwia materializację w trybie online zestawu funkcji transactions.

   # Enable materialization to online store for the "transactions" feature set.
   
   transactions_fset_config = fs_client._featuresets.get(name="transactions", version="1")
   transactions_fset_config.materialization_settings.online_enabled = True
   
   fs_poller = fs_client.feature_sets.begin_create_or_update(transactions_fset_config)
   print(fs_poller.result())

2. Ta komórka kodu uzupełnia dane w repozytorium materializacji zarówno online, jak i offline, aby zapewnić, że oba repozytoria mają najnowsze dane. Zadanie cyklicznej materializacji, które skonfigurowałeś w samouczku 3 tej serii, teraz materializuje dane zarówno do magazynów online, jak i offline.

   # Trigger backfill on the "transactions" feature set to fill in the online/offline store.
   # Backfill from 01/01/2020 to all the way to 3 hours ago.
   
   from datetime import datetime, timedelta
   from azure.ai.ml.entities import DataAvailabilityStatus
   
   st = datetime(2020, 1, 1, 0, 0, 0, 0)
   et = datetime.now() - timedelta(hours=3)
   
   
   poller = fs_client.feature_sets.begin_backfill(
       name="transactions",
       version="1",
       feature_window_start_time=st,
       feature_window_end_time=et,
       data_status=[DataAvailabilityStatus.NONE],
   )
   print(poller.result().job_ids)

   Ta komórka kodu śledzi ukończenie zadania uzupełniania danych. Używając wcześniej skonfigurowanej warstwy Premium Azure Cache for Redis, ten krok może zająć około pięciu minut.

   # Get the job URL, and stream the job logs.
   # With PREMIUM Redis SKU, SKU family "P", and cache capacity 2,
   # it takes approximately 5 minutes to complete.
   fs_client.jobs.stream(poller.result().job_ids[0])

Dalsze eksplorowanie materializacji funkcji online

Stan materializacji cech zestawu można eksplorować w interfejsie użytkownika Zadań Materializacji.

1. Otwórz Azure Machine Learning globalną stronę docelową

2. Wybierz pozycję Feature stores w okienku po lewej stronie

3. Z listy dostępnych magazynów funkcji wybierz magazyn funkcji, dla którego przeprowadzono wypełnienie danych

4. Wybierz kartę Zadania materializacji

   

• Stan materializacji danych może być
  • Ukończ (zielony)
  • Niekompletne (czerwone)
  • Oczekiwanie (niebieski)
  • Brak (szary)
• Interwał danych reprezentuje ciągłą część danych z tym samym stanem materializacji danych. Na przykład wcześniejsza migawka ma 16 przedziałów danych w magazynie materializacji offline.
• Dane mogą mieć maksymalnie 2000 przedziałów danych. Jeśli dane zawierają ponad 2000 interwałów danych, utwórz nową wersję zestawu funkcji.
• Możesz podać listę więcej niż jednego stanu danych (na przykład ["None", "Incomplete"]) w jednym zadaniu uzupełnienia.
• Podczas uzupełniania danych nowe zadanie materializacji jest przesyłane dla każdego przedziału danych, który znajduje się w zdefiniowanym oknie funkcji.
• Nowe zadanie nie jest przesyłane dla interwału danych, jeśli zadanie materializacji już czeka, albo jeśli jest uruchomione dla interwału danych, który nie został jeszcze uzupełniony.

Aktualizacja sklepu materializacji online

• Aby zaktualizować magazyn materializacji online na poziomie magazynu funkcji, wszystkie zestawy funkcji w magazynie funkcji muszą mieć wyłączoną materializację online.
• Jeśli materializacja online jest wyłączona w zbiorze funkcji, status materializacji już zmaterializowanych danych w repozytorium materializacji online zostanie zresetowany. Spowoduje to, że dane już zmaterializowane są bezużyteczne. Należy ponownie przesłać zadania materializacji po włączeniu materializacji online.
• Jeśli tylko materializacja offline została początkowo włączona dla zestawu funkcji, a materializacja online jest włączona później:
  • Domyślny stan materializacji danych w magazynie online to None.
  • Po przesłaniu pierwszego zadania materializacji online dane już zmaterializowane w magazynie offline, jeśli są dostępne, są używane do obliczania funkcji online.
  • Jeśli interwał danych materializacji online częściowo nakłada się na interwał danych już zmaterializowanych danych znajdujących się w magazynie offline, oddzielne zadania materializacji są przesyłane dla nakładających się i nienakładających się części interwału danych.

Testowanie lokalne

Teraz użyj środowiska programistycznego, aby przeszukać funkcje w sklepie materializacji online. Notatnik samouczka dołączony do Bezserwerowy Spark Compute stanowi środowisko programistyczne.

Ta komórka kodu analizuje listę funkcji z istniejącej specyfikacji pobierania funkcji.

# Parse the list of features from the existing feature retrieval specification.
feature_retrieval_spec_folder = root_dir + "/project/fraud_model/feature_retrieval_spec"

features = featurestore.resolve_feature_retrieval_spec(feature_retrieval_spec_folder)

features

Ten kod pobiera wartości cech z magazynu materializacji online.

from azureml.featurestore import init_online_lookup
import time

# Initialize the online store client.
init_online_lookup(features, AzureMLOnBehalfOfCredential())

Przygotuj dane obserwacji do testowania i użyj tych danych, aby wyszukać funkcje z magazynu materializacji online. Podczas wyszukiwania w trybie online klucze (accountID) zdefiniowane w przykładowych danych obserwacji mogą nie istnieć w usłudze Redis (z powodu TTL). W takim przypadku:

1. Otwieranie portalu Azure

2. Przejdź do wystąpienia usługi Redis

3. Otwórz konsolę dla instancji Redis i sprawdź istniejące klucze poleceniem KEYS *.

4. accountID Zastąp wartości w przykładowych danych obserwacji istniejącymi kluczami

   import pyarrow
   from azureml.featurestore import get_online_features
   
   # Prepare test observation data
   obs = pyarrow.Table.from_pydict(
       {"accountID": ["A985156952816816", "A1055521248929430", "A914800935560176"]}
   )
   
   # Online lookup:
   # It may happen that the keys defined in the observation sample data above does not exist in the Redis (due to TTL).
   # If this happens, go to Azure portal and navigate to the Redis instance, open its console and check for existing keys using command "KEYS *"
   # and replace the sample observation data with the existing keys.
   df = get_online_features(features, obs)
   df

Kroki te wyszukiwały funkcje w sklepie internetowym. W następnym kroku przetestujesz funkcje online, korzystając z zarządzanego przez Azure Machine Learning punktu końcowego online.

Testowanie funkcji online z zarządzanego online punktu końcowego Azure Machine Learning

Zarządzany punkt końcowy online wdraża i przetwarza modele wnioskowania w trybie online/czasu rzeczywistego. Możesz użyć dowolnej dostępnej technologii wnioskowania — na przykład Kubernetes.

Ten krok obejmuje następujące akcje:

1. Utwórz zarządzany punkt końcowy online usługi Azure Machine Learning.
2. Przyznaj wymagane uprawnienia kontroli dostępu opartej na rolach (RBAC).
3. Wdróż model, który został wytrenowany w samouczku 3 tej serii samouczków. Skrypt oceniania używany w tym kroku zawiera kod służący do wyszukiwania funkcji online.
4. Ocenianie modelu przy użyciu przykładowych danych.

Tworzenie zarządzanego przez Azure Machine Learning punktu końcowego online

Odwiedź ten zasób , aby dowiedzieć się więcej o zarządzanych punktach końcowych online. Za pomocą interfejsu API zarządzanego sklepu funkcji można również pobierać funkcje online z innych platform wnioskowania.

Ta komórka kodu definiuje fraud-model zarządzany punkt końcowy online.

from azure.ai.ml.entities import (
    ManagedOnlineDeployment,
    ManagedOnlineEndpoint,
    Model,
    CodeConfiguration,
    Environment,
)


endpoint_name = "<ENDPOINT_NAME>"

endpoint = ManagedOnlineEndpoint(name=endpoint_name, auth_mode="key")

Ta komórka kodu tworzy zarządzany punkt końcowy online zdefiniowany w poprzedniej komórce kodu.

ws_client.online_endpoints.begin_create_or_update(endpoint).result()

Nadawanie wymaganych uprawnień RBAC

W tym miejscu przyznajesz wymagane uprawnienia RBAC do zarządzanego punktu końcowego online na instancji Redis oraz w magazynie funkcji. Kod oceniania we wdrożeniu modelu wymaga tych uprawnień RBAC, aby pomyślnie wyszukiwać cechy w magazynie cech online przy użyciu interfejsu API zarządzanego magazynu cech.

Uzyskiwanie zarządzanej tożsamości dla zarządzanego punktu końcowego online

Ta komórka kodu pobiera tożsamość zarządzaną zarządzanego punktu końcowego online:

# Get managed identity of the managed online endpoint.
endpoint = ws_client.online_endpoints.get(endpoint_name)

model_endpoint_msi_principal_id = endpoint.identity.principal_id
model_endpoint_msi_principal_id

Nadaj rolę tożsamości zarządzanej dla punktu końcowego online na Azure Cache for Redis

Ta komórka kodu przyznaje Contributor rolę tożsamości zarządzanej punktu końcowego online w wystąpieniu usługi Redis. To uprawnienie RBAC jest potrzebne do materializowania danych w sklepie online Redis.

from azure.core.exceptions import ResourceExistsError
from azure.mgmt.msi import ManagedServiceIdentityClient
from azure.mgmt.msi.models import Identity
from azure.mgmt.authorization import AuthorizationManagementClient
from azure.mgmt.authorization.models import RoleAssignmentCreateParameters
from uuid import uuid4

auth_client = AuthorizationManagementClient(
    AzureMLOnBehalfOfCredential(), redis_subscription_id
)

scope = f"/subscriptions/{redis_subscription_id}/resourceGroups/{redis_resource_group_name}/providers/Microsoft.Cache/Redis/{redis_name}"


# The role definition ID for the "contributor" role on the redis cache
# You can find other built-in role definition IDs in the Azure documentation
role_definition_id = f"/subscriptions/{redis_subscription_id}/providers/Microsoft.Authorization/roleDefinitions/b24988ac-6180-42a0-ab88-20f7382dd24c"

# Generate a random UUID for the role assignment name
role_assignment_name = str(uuid4())

# Set up the role assignment creation parameters
role_assignment_params = RoleAssignmentCreateParameters(
    principal_id=model_endpoint_msi_principal_id,
    role_definition_id=role_definition_id,
    principal_type="ServicePrincipal",
)

# Create the role assignment
try:
    # Create the role assignment
    result = auth_client.role_assignments.create(
        scope, role_assignment_name, role_assignment_params
    )
    print(
        f"Redis RBAC granted to managed identity '{model_endpoint_msi_principal_id}'."
    )
except ResourceExistsError:
    print(
        f"Redis RBAC already exists for managed identity '{model_endpoint_msi_principal_id}'."
    )

Przyznaj rolę AzureML badacze dancyh tożsamości zarządzanej punktu końcowego online w sklepie funkcji

Ta komórka kodu przyznaje rolę AzureML badacze dancyh tożsamości zarządzanej punktu końcowego online w magazynie funkcji. To uprawnienie RBAC jest wymagane do pomyślnego wdrożenia modelu w punkcie końcowym online.

auth_client = AuthorizationManagementClient(
    AzureMLOnBehalfOfCredential(), featurestore_subscription_id
)

scope = f"/subscriptions/{featurestore_subscription_id}/resourceGroups/{featurestore_resource_group_name}/providers/Microsoft.MachineLearningServices/workspaces/{featurestore_name}"

# The role definition ID for the "AzureML Data Scientist" role.
# You can find other built-in role definition IDs in the Azure documentation.
role_definition_id = f"/subscriptions/{featurestore_subscription_id}/providers/Microsoft.Authorization/roleDefinitions/f6c7c914-8db3-469d-8ca1-694a8f32e121"

# Generate a random UUID for the role assignment name.
role_assignment_name = str(uuid4())

# Set up the role assignment creation parameters.
role_assignment_params = RoleAssignmentCreateParameters(
    principal_id=model_endpoint_msi_principal_id,
    role_definition_id=role_definition_id,
    principal_type="ServicePrincipal",
)

# Create the role assignment
try:
    # Create the role assignment
    result = auth_client.role_assignments.create(
        scope, role_assignment_name, role_assignment_params
    )
    print(
        f"Feature store RBAC granted to managed identity '{model_endpoint_msi_principal_id}'."
    )
except ResourceExistsError:
    print(
        f"Feature store RBAC already exists for managed identity '{model_endpoint_msi_principal_id}'."
    )

Umieść model w punkcie końcowym online

Przejrzyj skrypt oceniania project/fraud_model/online_inference/src/scoring.py. Skrypt oceniania

1. Ładuje metadane cech ze specyfikacji pobierania cech zawarte w modelu podczas szkolenia modelu. Trzecia część tej serii samouczków obejmowała to zadanie. Specyfikacja zawiera funkcje zarówno z zestawu funkcji transactions, jak i accounts.
2. Wyszukuje funkcje online, używając kluczy indeksu z żądania, po otrzymaniu żądania dedukcji wejściowej. W tym przypadku w przypadku obu zestawów funkcji kolumna indeksu to accountID.
3. Przekazuje funkcje do modelu w celu wykonania wnioskowania i zwraca odpowiedź. Odpowiedź jest wartością logiczną reprezentującą zmienną is_fraud.

Następnie wykonaj tę komórkę kodu, aby utworzyć zarządzaną definicję wdrożenia online na potrzeby wdrażania modelu.

deployment = ManagedOnlineDeployment(
    name="green",
    endpoint_name=endpoint_name,
    model="azureml:fraud_model:1",
    code_configuration=CodeConfiguration(
        code=root_dir + "/project/fraud_model/online_inference/src/",
        scoring_script="scoring.py",
    ),
    environment=Environment(
        conda_file=root_dir + "/project/fraud_model/online_inference/conda.yml",
        image="mcr.microsoft.com/azureml/openmpi4.1.0-ubuntu20.04",
    ),
    instance_type="Standard_DS3_v2",
    instance_count=1,
)

Wdróż model na punkt końcowy online za pomocą tej komórki kodu. Wdrożenie może wymagać od czterech do pięciu minut.

# Model deployment to online enpoint may take 4-5 minutes.
ws_client.online_deployments.begin_create_or_update(deployment).result()

Testowanie wdrożenia w trybie online przy użyciu pozornych danych

Wykonaj tę komórkę kodu, aby przetestować wdrożenie w trybie online za pomocą danych testowych. Komórka powinna wyświetlać 0 lub 1 jako swoje wyjście.

# Test the online deployment using the mock data.
sample_data = root_dir + "/project/fraud_model/online_inference/test.json"
ws_client.online_endpoints.invoke(
    endpoint_name=endpoint_name, request_file=sample_data, deployment_name="green"
)

Czyszczenie

Samouczek 5. Tworzenie zestawu funkcji za pomocą niestandardowego źródła opisuje sposób usuwania zasobów.

Następne kroki

• Samouczek 6. Izolacja sieciowa dla magazynu funkcji
• Azure Machine Learning funkcja przechowuje repozytorium przykładów