Esercitazione 4: Abilitare la materializzazione online ed eseguire l'inferenza online

Un archivio di funzionalità gestito Azure Machine Learning consente di individuare, creare e rendere operative le funzionalità. Le funzionalità connettono il ciclo di vita di Machine Learning, a partire dalla fase di creazione di prototipi, in cui si sperimentano varie funzionalità. Il ciclo di vita continua alla fase di operazionalizzazione, in cui si distribuiscono i modelli e i passaggi di inferenza cercano i dati delle funzionalità. Per altre informazioni sull'archivio funzionalità gestite, vedere Che cos'è l'archivio delle funzionalità gestite?

Importante

La cache di Azure per Redis ha annunciato la sequenza temporale di ritiro per tutti gli SKU. È consigliabile spostare le istanze di cache di Azure per Redis esistenti in Azure Redis gestito non appena possibile.

Linee guida per la migrazione:

Per altre informazioni sul ritiro:

Disattivazione di cache di Azure per Redis: Cosa sapere e come prepararsi
Domande frequenti sul ritiro cache di Azure per Redis

L'esercitazione 1 ha illustrato come creare una specifica del set di funzionalità con trasformazioni personalizzate e quindi usare tale set di funzionalità per generare dati di training, abilitare la materializzazione ed eseguire un backfill. L'esercitazione 2 ha illustrato come sperimentare le funzionalità per migliorare le prestazioni del modello e quindi eseguire il training e registrare un modello che usa le funzionalità. L'esercitazione 3 ha illustrato come abilitare la materializzazione ricorrente per il transactions set di funzionalità ed eseguire una pipeline di inferenza batch.

In questo tutorial, tu

Configurare una cache di Azure per Redis
Collegare una cache a un archivio funzionalità come archivio di materializzazione online e concedere le autorizzazioni necessarie.
Materializzare una funzionalità impostata sul negozio online
Testare una distribuzione online con dati fittizi

Prerequisiti

Nota

Questa esercitazione usa un notebook Azure Machine Learning con Serverless Spark Compute.

Assicurarsi di completare le esercitazioni da 1 a 3 in questa serie. Questa esercitazione riutilizza l'archivio funzionalità e altre risorse create in queste esercitazioni precedenti.

Impostazione

Questo tutorial usa l'SDK principale dell'archivio di funzionalità di Python (azureml-featurestore). L'SDK di Python viene usato per operazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD) negli archivi funzionalità, nei set di funzionalità e nelle entità dell'archivio funzionalità.

Non è necessario installare in modo esplicito queste risorse per questa esercitazione, perché nelle istruzioni di configurazione illustrate di seguito, il file online.yml li copre.

Configurare il notebook Spark di Azure Machine Learning.

È possibile creare un nuovo notebook ed eseguire le istruzioni riportate in questa esercitazione in modo dettagliato. È anche possibile aprire ed eseguire il notebook featurestore_sample/notebooks/sdk_only/4.Enable-online-store-run-inference.ipynb esistente. Mantieni aperta questa esercitazione e fai riferimento ad essa per i collegamenti alla documentazione e ulteriori spiegazioni.
1. Nell'elenco a discesa Ambiente di calcolo nella barra di spostamento superiore, selezionare Ambiente di calcolo Spark serverless.
2. Configurare la sessione:
  1. Scaricare il file azureml-examples/sdk/python/featurestore-sample/project/env/online.yml nel computer locale
  2. In configura sessione nella barra di spostamento superiore, selezionare pacchetti Python
  3. Selezionare Carica file Conda
  4. Caricare il file online.yml dal computer locale usando gli stessi passaggi descritti in Caricare il file conda.yml nell'esercitazione 1.
  5. Facoltativamente, aumentare il timeout della sessione (tempo di inattività) per evitare frequenti riesecuzioni dei prerequisiti

Questa cella di codice avvia la sessione Spark. Sono necessari circa 10 minuti per installare tutte le dipendenze e avviare la sessione 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")

Configurare la directory radice per gli esempi

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

Inizializzare MLClient per l'area di lavoro del progetto in cui viene eseguito il notebook del tutorial. MLClient viene usato per le operazioni di creazione, lettura, aggiornamento ed eliminazione (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
)

Inizializzare MLClient per l'area di lavoro dell'archivio funzionalità, per le operazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD) su tale area di lavoro.
```
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,
)
```
Nota

Un'area di lavoro dell'archivio delle funzionalità supporta il riutilizzo delle funzionalità tra i progetti. Un'area di lavoro del progetto, l'area di lavoro corrente in uso, sfrutta le funzionalità di un archivio delle funzionalità specifico per eseguire il training e l'inferenza dei modelli. Molte aree di lavoro del progetto possono condividere e riutilizzare la stessa area di lavoro dell'archivio delle funzionalità.
Come accennato in precedenza, questa esercitazione usa il core SDK del feature store Python (azureml-featurestore). Questo client SDK inizializzato viene usato per le operazioni di creazione, lettura, aggiornamento ed eliminazione (CRUD) negli archivi delle funzionalità, nei set di funzionalità e nelle entità dell'archivio funzionalità.
```
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,
)
```

Preparare Azure Cache per Redis

Questo tutorial usa cache di Azure per Redis come archivio di materializzazione dei dati online. È possibile creare una nuova istanza di Redis o riutilizzarne usa esistente.

Impostare i valori per la risorsa cache di Azure per Redis da usare come archivio di materializzazione online. In questa cella di codice definire il nome della risorsa cache di Azure per Redis da creare o riutilizzare. È possibile eseguire l'override di altre impostazioni predefinite.
```
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
```

È possibile creare una nuova istanza di Redis. Selezionare il livello cache Redis appropriato (Basic, Standard, Premium o Enterprise). Scegliere una famiglia di SKU disponibile per il livello di cache selezionato. Per altre informazioni sui livelli e sulle prestazioni della cache, visitare questa risorsa. Per altre informazioni sui livelli sku e sulle famiglie di cache Azure, visitare questa risorsa.

Eseguire questa cella di codice per creare un cache di Azure per Redis con il livello Premium, la famiglia di SKU P e la capacità della cache 2. La preparazione dell'istanza di Redis potrebbe richiedere tra 5 e 10 minuti.

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)

Facoltativamente, questa cella di codice riutilizza un'istanza Redis esistente con il nome definito in precedenza.

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

Collegare l'archivio di materializzazione online all'archivio delle funzionalità

L'archivio funzionalità richiede la cache Azure per Redis come risorsa associata, da usare come archivio di materializzazione online. Questa cella di codice gestisce tale passaggio.

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

Nota

Durante un aggiornamento dell'archivio funzionalità, l'impostazione grant_materiaization_permissions=True da sola non concederà le autorizzazioni di controllo degli accessi in base al ruolo (RBAC) necessarie per l'interfaccia utente. Le assegnazioni di ruolo a UAI verranno eseguite solo quando viene aggiornata una delle opzioni seguenti:

Identità di materializzazione
Destinazione del negozio offline
Obiettivo del negozio online

Per un esempio che illustra come effettuare questa operazione con l'SDK, visitare la risorsa Tutorial: Approcci diversi per il provisioning di un archivio funzionalità gestito.

Materializzare i dati dell'insieme di funzionalità `accounts` nel negozio online

Abilitare la materializzazione nel set di funzionalità `accounts`

In precedenza in questa serie di esercitazioni, non hai materializzato il set di funzionalità degli account, perché aveva funzionalità pre-calcolate e veniva utilizzato solo in scenari di inferenza batch. Questa cella di codice abilita la materializzazione online in modo che le funzionalità diventino disponibili nell'archivio online, con accesso a bassa latenza. Per coerenza, abilita anche la materializzazione offline. L'abilitazione della materializzazione offline è facoltativa.

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

Completare il set di funzionalità `account`

La funzione begin_backfill esegue il back-fill dei dati in tutti gli archivi di materializzazione abilitati per questo set di funzionalità. In questo caso, la materializzazione offline e online sono entrambe abilitate. Questa cella di codice esegue il back-fill dei dati in archivi di materializzazione online e 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)

Suggerimento

La granularità di feature_window_start_time e feature_window_end_time è limitata ai secondi. Qualsiasi valore di millisecondo specificato nell'oggetto datetime verrà ignorato.
Un processo di materializzazione verrà inviato solo se nella finestra delle funzionalità sono presenti dati che corrispondono a quelli definiti durante l'invio data_status del processo di backfill.

Questa cella di codice tiene traccia del completamento del processo di back-fill. Con l'cache di Azure per Redis livello Premium che è stato configurato in precedenza, il completamento di questo passaggio potrebbe richiedere circa 10 minuti.

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

Materializzare dati del set di funzionalità `transactions` all'archivio online

In precedenza, in questa serie di esercitazioni sono stati materializzati i dati del set di funzionalità transactions nell'archivio di materializzazione offline.

Questa cella di codice abilita la materializzazione online del set di funzionalità 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())

Questa cella di codice esegue il back-fill dei dati sia nell'archivio di materializzazione online che offline, per assicurarsi che entrambi gli archivi abbiano i dati più recenti. Il processo di materializzazione ricorrente, configurato nel Tutorial 3 di questa serie, ora materializza i dati in archivi di materializzazione online e 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)

Questa cella di codice tiene traccia del completamento del processo di back-fill. Per utilizzare il livello Premium di cache di Azure per Redis, di cui è stato eseguito il provisioning in precedenza, questo passaggio potrebbe richiedere circa cinque minuti per essere completato.

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

Esplorare ulteriormente la materializzazione delle funzionalità online

È possibile esplorare lo stato di materializzazione delle funzionalità per un set di funzionalità dall'interfaccia utente dei processi di materializzazione.

Aprire la pagina di destinazione globale Azure Machine Learning
Selezionare Feature stores nel riquadro sinistro
Nell'elenco degli archivi funzionalità accessibili selezionare l'archivio funzionalità per il quale è stato eseguito il riempimento
Selezionare la scheda Processi di materializzazione

Lo stato del processo di materializzazione dei dati può essere
- Completo (verde)
- Incompleto (rosso)
- In sospeso (blu)
- Nessuno (grigio)
Un intervallo di dati rappresenta una parte contigua di dati con lo stesso stato di materializzazione. Ad esempio, lo snapshot precedente ha 16 intervalli di dati nell'archivio di materializzazione offline.
I dati possono avere un massimo di 2.000 intervalli di dati. Se i dati contengono più di 2.000 intervalli di dati, creare una nuova versione del set di funzionalità.
È possibile fornire un elenco di più stati dei dati (ad esempio, ["None", "Incomplete"]) in un singolo processo di back-fill.
Durante il back-fill, viene inviato un nuovo processo di materializzazione per ogni intervallo di dati che rientra nella finestra delle funzionalità definita.
Un nuovo processo non viene inviato per un intervallo di dati se un processo di materializzazione è già in sospeso o se è in esecuzione per un intervallo di dati che non è ancora stato riempito.

Aggiornamento dell'archivio di materializzazione online

Per aggiornare un archivio di materializzazione online a livello di archivio funzionalità, tutti i set di funzionalità nell'archivio funzionalità devono avere la materializzazione online disabilitata.
Se la materializzazione online è disabilitata in un set di funzionalità, lo stato di materializzazione dei dati già materializzati nell'archivio di materializzazione online viene reimpostato. In questo modo, i dati già materializzati non sono utilizzabili. È necessario inviare di nuovo i processi di materializzazione una volta che la materializzazione online è stata abilitata.
Se solo la materializzazione offline è stata inizialmente abilitata per un set di funzionalità e la materializzazione online viene abilitata in un secondo momento:
- Lo stato di materializzazione predefinito dei dati presenti nell'archivio online sarà None.
- Quando viene inviato il primo processo di materializzazione online, i dati già materializzati nell'archivio offline, se disponibile, vengono usati per calcolare le funzionalità online.
- Se l'intervallo di dati per la materializzazione online si sovrappone parzialmente all'intervallo di dati già materializzati che si trovano nell'archivio offline, vengono inviati processi di materializzazione separati per le parti sovrapposte e non sovrapposte dell'intervallo di dati.

Testa localmente

A questo punto, è necessario usare l'ambiente di sviluppo per consultare le funzionalità dall'archivio di materializzazione online. Il notebook del tutorial allegato a ambiente di calcolo Spark senza server funge da ambiente di sviluppo.

Questa cella di codice analizza l'elenco delle funzionalità dalla specifica di recupero delle funzionalità esistente.

# 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

Questo codice recupera i valori delle funzionalità dall'archivio di materializzazione online.

from azureml.featurestore import init_online_lookup
import time

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

Preparare alcuni dati di osservazione per i test e usarli per cercare le funzionalità dall'archivio di materializzazione online. Durante la ricerca online, le chiavi (accountID) definite nei dati del campione di osservazione potrebbero non esistere in Redis (a causa di TTL). In questo caso:

Aprire il portale di Azure
Passare all'istanza di Redis
Aprire la console per l'istanza di Redis e verificare la presenza di chiavi esistenti con il KEYS * comando

Sostituire i accountID valori nei dati di osservazione di esempio con le chiavi esistenti

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

Questi passaggi servono a consultare le funzionalità nel negozio online. Nel passaggio successivo verranno testate le funzionalità online con un endpoint online gestito Azure Machine Learning.

Testare le funzionalità online dall'endpoint online gestito di Azure Machine Learning

Un endpoint online gestito distribuisce e assegna punteggi ai modelli per l'inferenza online/in tempo reale. È possibile usare qualsiasi tecnologia di inferenza disponibile, ad esempio Kubernetes.

Questo passaggio prevede le seguenti azioni:

Creare un endpoint online gestito Azure Machine Learning.
Concedere le autorizzazioni di controllo degli accessi in base al ruolo (RBAC) necessarie.
Distribuire il modello sottoposto a training nel tutorial 3 di questa serie di tutorial. Lo script di assegnazione dei punteggi usato in questo passaggio include il codice per cercare le funzionalità online.
Assegnare un punteggio al modello con dati di esempio.

Creare endpoint gestito online di Azure Machine Learning

Visitare questa risorsa per altre informazioni sugli endpoint online gestiti. Con l'API dell'archivio di funzionalità gestite, è anche possibile cercare funzionalità online da altre piattaforme di inferenza.

Questa cella di codice definisce l'endpoint online gestito fraud-model.

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


endpoint_name = "<ENDPOINT_NAME>"

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

Questa cella di codice crea l'endpoint online gestito definito nella cella di codice precedente.

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

Concedere le autorizzazioni RBAC necessarie

In questo caso, si concedono le autorizzazioni RBAC necessarie all'endpoint online gestito sull'istanza di Redis e al feature store. Il codice di assegnazione dei punteggi nella distribuzione del modello richiede queste autorizzazioni RBAC per cercare correttamente le funzionalità nell'archivio online, con l'API dell'archivio funzionalità gestita.

Ottenere l'identità gestita dell'endpoint online gestito

Questa cella di codice recupera l'identità gestita dell'endpoint online gestito:

# 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

Concedere il ruolo `Contributor` all'identità gestita dell'endpoint online nella cache Azure per Redis

Questa cella di codice concede il ruolo Contributor all'identità gestita dell'endpoint online nell'istanza di Redis. Questa autorizzazione RBAC è necessaria per materializzare i dati nell'archivio 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}'."
    )

Concedere il ruolo `AzureML Scienziato dei dati` all'identità gestita dell'endpoint online nell'archivio funzionalità

Questa cella di codice concede il ruolo AzureML Scienziato dei dati all'identità gestita dell'endpoint online nell'archivio funzionalità. Questa autorizzazione RBAC è necessaria per la corretta distribuzione del modello nell'endpoint 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}'."
    )

Distribuire il modello nell'endpoint online

Revisionare lo script di assegnazione dei punteggi project/fraud_model/online_inference/src/scoring.py. Lo script di assegnazione dei punteggi

Carica i metadati delle funzionalità dalla specifica di recupero delle funzionalità inserita nel pacchetto con il modello durante il training sul modello. L'esercitazione 3 di questa serie di esercitazioni ha illustrato come svolgere questa attività. La specifica include funzionalità dai set di funzionalità transactions e accounts.
Cerca le funzionalità online usando le chiavi di indice dalla richiesta, quando viene ricevuta una richiesta di inferenza di input. In questo caso, per entrambi i set di funzionalità, la colonna dell'indice è accountID.
Passa le funzionalità al modello per eseguire l'inferenza e restituisce la risposta. La risposta è un valore booleano che rappresenta la variabile is_fraud.

Eseguire quindi questa cella di codice per creare una definizione di distribuzione online gestita per la distribuzione del modello.

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

Distribuire il modello nell'endpoint online con questa cella di codice. La distribuzione potrebbe richiedere da quattro a cinque minuti.

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

Testare la distribuzione online con dati fittizi

Eseguire questa cella di codice per testare la distribuzione online con i dati fittizi. La cella dovrebbe mostrare 0 o 1 come output.

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

Eseguire la pulizia

Esercitazione 5: Sviluppare un set di funzionalità con un'origine personalizzata descrive come eliminare le risorse.

Passaggi successivi

Commenti e suggerimenti

Questa pagina è stata utile?

Ultimo aggiornamento: 2026-07-31