Esercitazione n. 1: sviluppo e registrazione di un set di funzionalità con l'archivio di funzionalità gestite (anteprima) - Azure ML Managed Feature Store - Nozioni di base (2023)

L'archivio di funzionalità gestite di Azure Machine Learning consente di individuare, creare e rendere operative le funzionalità. Il ciclo di vita dell'apprendimento automatico prevede la fase di prototipazione, in cui si sperimentano varie funzionalità. Coinvolge anche la fase di operazionalizzazione, in cui i modelli vengono distribuiti e l'inferenza cerca i dati delle funzionalità. Le funzionalità fungono da tessuto connettivo nel ciclo di vita del machine learning. Per informazioni sui concetti di base del feature store, vederecos'è il feature store gestitoEentità di primo livello nel feature store gestito.

Questo tutorial è la prima parte di una serie in quattro parti. In questo tutorial imparerai come:

• Crea una nuova risorsa minima dell'archivio di funzionalità
• Sviluppa e testa localmente un set di funzionalità con funzionalità di trasformazione delle funzionalità
• Registrare un'entità feature store con il feature store
• Registra il set di funzionalità che hai sviluppato con il feature store
• Genera un dataframe di addestramento di esempio utilizzando le funzionalità che hai creato

Prerequisiti

Prima di procedere con questo articolo, assicurati di coprire questi prerequisiti:

• Un'area di lavoro di Azure Machine Learning. Se non ne hai uno, vedi ilAvvio rapido: creare risorse dell'area di lavoroarticolo per crearne uno

• Per eseguire i passaggi in questo articolo, all'account utente deve essere assegnato il ruolo di proprietario o collaboratore a un gruppo di risorse in cui viene creato l'archivio delle funzionalità

(Facoltativo): se usi un nuovo gruppo di risorse per questo tutorial, puoi facilmente eliminare tutta la risorsa eliminando il gruppo di risorse

Impostare

Preparare l'ambiente notebook per lo sviluppo

Nota: questa esercitazione usa Azure Machine Learning Spark Notebook per lo sviluppo.

1. Clona il repository di esempi sul tuo computer locale: per eseguire il tutorial, clona prima il filerepository di esempi - (azureml-examples)con questo comando:

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

   See Also

   Glossario MLOps, monitoraggio ML e scienza dei datiMicrosoft Build porta gli strumenti di intelligenza artificiale in prima linea per gli sviluppatori: il blog ufficiale di MicrosoftCodici di errore per connessioni remote o VPN - Client WindowsLe migliori penne calligrafiche per principianti nel 2023

   Puoi anche scaricare un file zip dal filerepository di esempi (azureml-examples). In questa pagina, seleziona prima il filecodicemenu a discesa, quindi selezionareScarica CAP. Quindi, decomprimi il contenuto in una cartella sul tuo dispositivo locale.

2. Carica la directory degli esempi di feature store nell'area di lavoro del progetto.

   • Aprire l'interfaccia utente di Azure Machine Learning Studio dell'area di lavoro di Azure Machine Learning
   • SelezionareI Quaderninel menu di navigazione sinistro
   • Seleziona il tuo nome utente nell'elenco delle directory
   • Selezionarecartella di caricamento
   • Seleziona la cartella degli esempi di feature store dal percorso della directory clonata:azureml-examples/sdk/python/featurestore-sample

3. È possibile creare un nuovo taccuino e procedere ed eseguire le istruzioni in questo documento passo dopo passo. Puoi anche aprire il taccuino esistente denominato1. Sviluppare un set di funzionalità e registrarsi con funzionalità gestite store.ipynbed eseguire le sue singole celle passo dopo passo, una alla volta. I quaderni sono disponibili nella cartellafeaturestore_sample/notebooks/sdk_only. Tenere aperto questo documento e farvi riferimento per una spiegazione dettagliata dei passaggi.

4. SelezionareCalcolo AzureML Sparknel menu a discesa "Compute" del menu di navigazione superiore. Questa operazione potrebbe richiedere da uno a due minuti. Attendi che venga visualizzata una barra di stato in altoconfigurare la sessione.

5. Seleziona "configura sessione" dal menu di navigazione superiore (la visualizzazione potrebbe richiedere da uno a due minuti):

   1. Selezionareconfigurare la sessionenel menu di navigazione inferiore
   2. SelezionareCarica file conda
   3. Seleziona il fileazureml-examples/sdk/python/featurestore-sample/project/env/conda.ymlche si trova sul tuo dispositivo locale
   4. (Facoltativo) Aumentare il timeout della sessione (tempo di inattività) per ridurre il tempo di avvio del cluster Spark senza server.

Avvia la sessione Spark

# esegue questa cella per avviare la sessione spark (qualsiasi blocco di codice avvierà la sessione). Questo può richiedere circa 10 minuti.print("start spark session")

Imposta la directory principale per gli esempi

import os# Aggiorna il tuo alias belpw (o qualsiasi directory personalizzata in cui hai caricato gli esempi).# Puoi trovare il nome dalla struttura della directory a sinistra navroot_dir = "./Users//featurestore_sample"if os .path.isdir(root_dir): print("La cartella esiste.")else: print("La cartella non esiste. Crea o correggi il percorso")

Passaggio 1: crea un negozio di funzionalità minimo

Passaggio 1a: impostare i parametri del negozio di funzionalità

Imposta nome, posizione e altri valori per il feature store

# Usiamo l'abbonamento, il gruppo di risorse, la regione di questo spazio di lavoro del progetto attivo. = os.environ["AZUREML_ARM_SUBSCRIPTION"]featurestore_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]

Passaggio 1b: creare l'archivio delle funzionalità

da azure.ai.ml import MLClientda azure.ai.ml.entities import ( FeatureStore, FeatureStoreEntity, FeatureSet,)da azure.ai.ml.identity import AzureMLOnBehalfOfCredentialml_client = MLClient( AzureMLOnBehalfOfCredential(), subscription_id=featurestore_subscription_id, resource_group_name=featurestore_resource_group_name,) fs = FeatureStore(name=featurestore_name, location=featurestore_location)# aspetta la creazione di featurestorefs_poller = ml_client.feature_stores.begin_create(fs, update_dependent_resources=True)print(fs_poller.result())

Passaggio 1c: inizializzare il client dell'SDK di base dell'archivio di funzionalità di Azure Machine Learning

Come spiegato in precedenza in questo tutorial, il client SDK core dell'archivio funzionalità viene utilizzato per sviluppare e utilizzare le funzionalità

# feature store clientfrom azureml.featurestore import FeatureStoreClientfrom azure.ai.ml.identity import AzureMLOnBehalfOfCredentialfeaturestore = FeatureStoreClient( credential=AzureMLOnBehalfOfCredential(), subscription_id=featurestore_subscription_id, resource_group_name=featurestore_resource_group_name, name=featurestore_name,)

Passaggio 2: prototipazione e sviluppo di un set di funzionalità chiamatotransazioniche dispone di funzionalità basate su aggregazione a finestra continua

Passaggio 2a: esplorare i dati di origine delle transazioni

# Rimuovi il "." nel percorso della directory roor poiché dobbiamo generare il percorso assoluto da leggere da sparktransactions_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)display(transactions_src_df.head(5))# Nota: display(training_df.head(5)) visualizza la colonna timestamp in un formato diverso. Puoi chiamare Transactions_src_df.show() per vedere il valore formattato correttamente

Passaggio 2b: sviluppare localmente il set di funzionalità

Una specifica del set di funzionalità è una definizione di set di funzionalità autonoma che è possibile sviluppare e testare localmente.

In questo passaggio, creiamo queste funzionalità di aggregazione della finestra in sequenza:

• transazioni conteggio di tre giorni
• importo delle transazioni somma di tre giorni
• importo transazioni media tre giorni
• transazioni conteggio sette giorni
• le transazioni ammontano alla somma di sette giorni
• importo delle transazioni media di sette giorni

Azione:

• Esamina il file del codice di trasformazione delle funzionalità:featurestore/featuresets/transactions/transformation_code/transaction_transform.py. Si noti l'aggregazione mobile definita per le feature. Questo è un trasformatore a scintilla.

Vedereconcetti di negozio di funzionalitàEconcetti di trasformazioneper saperne di più sul set di funzionalità e sulle trasformazioni.

da azureml.featurestore import create_feature_set_spec, FeatureSetSpec da 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="wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/transactions-source/*.parquet", timestamp_column=TimestampColumn( name="timestamp"), source_delay=DateTimeOffset(giorni=0, ore=0, minuti=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(giorni=7, ore=0, minuti=0), temporal_join_lookback=DateTimeOffset(giorni=1, ore=0, minuti=0), infer_schema=True ,)# Genera un dataframe spark dalla specifica del set di funzionalitàtransactions_fset_df = Transactions_featureset_spec.to_spark_dataframe()# mostra pochi recorddisplay(transactions_fset_df.head(5))

Passaggio 2c: esportazione come specifica del set di funzionalità

Per registrare la specifica del set di funzionalità con l'archivio delle funzionalità, tale specifica deve essere salvata in un formato specifico.

import os# crea una nuova cartella per eseguire il dump del set di funzionalità spectransactions_featureset_spec_folder = (root_dir + "/featurestore/featuresets/transactions/spec")# controlla se la cartella esiste, creane una in caso contrario os.path.exists(transactions_featureset_spec_folder): os .makedirs(transactions_featureset_spec_folder)transactions_featureset_spec.dump(transactions_featureset_spec_folder)

Azione:Ispezionare il generatotransazioniSpecifiche del set di funzionalità: apri questo file dall'albero dei file per vedere le specifiche:featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml

La specifica contiene questi elementi importanti:

1. fonte: un riferimento a una risorsa di archiviazione. In questo caso, si tratta di un file parquet in una risorsa di archiviazione BLOB.
2. caratteristiche: un elenco di caratteristiche e dei loro tipi di dati. Se fornisci il codice di trasformazione (vedi la sezione Giorno 2), il codice deve restituire un dataframe mappato alle funzionalità e ai tipi di dati.
3. colonne_indice: le chiavi di join richieste per accedere ai valori dal set di funzionalità

Scopri di più sulle specifiche neldocumento delle entità del negozio di funzionalità di livello superioree ilriferimento yaml delle specifiche del set di funzionalità.

La persistenza della specifica del set di funzionalità offre un altro vantaggio: la specifica del set di funzionalità può essere controllata dall'origine.

Passaggio 3: registrare un'entità feature-store

Come best practice, le entità aiutano a imporre l'uso della stessa definizione di chiave di join tra i set di funzionalità che usano le stesse entità logiche. Esempi di entità possono includere account, clienti e così via. Le entità vengono in genere create una volta e quindi riutilizzate tra i set di funzionalità. Per informazioni, cfrconcetti di negozio di funzionalità.

Passaggio 3a: inizializzare il client CRUD di Feature Store

Come spiegato in precedenza in questo tutorial, MLClient viene usato per CRUD delle risorse del feature store. Il codice seguente cerca il feature store creato in un passaggio precedente. In questo caso non è possibile riutilizzare lo stesso ml_client utilizzato in precedenza in questa esercitazione, perché il precedente ml_client ha un ambito a livello di gruppo di risorse. Questo è un prerequisito per la creazione del feature store. Nell'esempio di codice successivo, l'ambito del client è a livello di feature store.

# mlclient su feature storefs_client = MLClient( AzureMLOnBehalfOfCredential(), featurestore_subscription_id, featurestore_resource_group_name, featurestore_name,)

Passaggio 3b: registrare il fileaccountentità con il feature store

Crea un'entità account con la chiave di joinAccount ID, di tipo stringa.

da azure.ai.ml.entities import DataColumn, DataColumnTypeaccount_entity_config = FeatureStoreEntity( name="account", version="1", index_columns=[DataColumn(name="accountID", type=DataColumnType.STRING)], description="This l'entità rappresenta l'accountID chiave dell'indice dell'account utente.", tags={"data_typ": "nonPII"},)poller = fs_client.feature_store_entities.begin_create_or_update(account_entity_config)print(poller.result())

Passaggio 4: registrare il set di funzionalità della transazione con l'archivio delle funzionalità

È possibile registrare una risorsa del set di funzionalità con l'archivio delle funzionalità. In questo modo, puoi condividere e riutilizzare quella risorsa con altri. La registrazione dell'asset del set di funzionalità offre funzionalità gestite, come il controllo delle versioni e la materializzazione (impareremo di più sulle funzionalità gestite in questa serie di esercitazioni).

from azure.ai.ml.entities import FeatureSetSpecificationtransaction_fset_config = FeatureSet( name="transactions", version="1", description="7 giorni e 3 giorni di aggregazione a rotazione del set di funzionalità delle transazioni", entity=["azureml:account: 1"], stage="Development", specific=FeatureSetSpecification(path=transactions_featureset_spec_folder), tags={"data_type": "nonPII"},)poller = fs_client.feature_sets.begin_create_or_update(transaction_fset_config)print(poller.result())

Esplora l'interfaccia utente del negozio di funzionalità

• Apri ilPagina di destinazione globale di Azure Machine Learning.
• SelezionareNegozi di funzionalitànel menu di navigazione sinistro
• Prendere nota dell'elenco degli archivi di funzionalità accessibili. Seleziona nel feature store che hai creato in precedenza in questo tutorial.

L'elenco mostra il set di funzionalità e l'entità che hai creato.

Passaggio 5: generare un dataframe di dati di addestramento utilizzando il set di funzionalità registrato

Passaggio 5a: caricare i dati di osservazione

Innanzitutto, esploriamo i dati di osservazione. I dati di osservazione in genere coinvolgono i dati fondamentali utilizzati nell'addestramento e nell'inferenza. Quindi, questi dati si uniscono ai dati delle funzionalità per creare i dati di addestramento completi. I dati di osservazione sono i dati acquisiti durante il periodo dell'evento. Qui, ha i dati di transazione di base tra cui ID transazione, ID account e importo della transazione. Dal momento che lo usiamo per l'addestramento, ha anche la variabile target aggiunta (è_frode).

observation_data_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/observation_data/train/*.parquet"observation_data_df = spark.read.parquet(observation_data_path)obs_data_timestamp_column = "timestamp"display( observation_data_df)# Nota: la colonna timestamp viene visualizzata in un formato diverso. Facoltativamente, puoi chiamare training_df.show() per vedere il valore formattato correttamente

Passaggio 5b: ottenere il set di funzionalità registrato ed elencarne le funzionalità

# cerca il set di funzionalità fornendo nome e versionetransactions_featureset = featurestore.feature_sets.get("transactions", "1")# elenca le sue caratteristichetransactions_featureset.features

# visualizza valori di esempio di stampa (transactions_featureset.to_spark_dataframe().head(5))

Passaggio 5c: seleziona le funzionalità e genera i dati di addestramento

Qui selezioniamo le funzionalità che diventano parte dei dati di addestramento e utilizziamo l'sdk del negozio di funzionalità per generare i dati di addestramento.

Un join point-in-time aggiunge le funzionalità ai dati di addestramento.

da azureml.featurestore import get_offline_features# puoi selezionare le funzionalità in modo pythonicfeatures = [transaction_featureset.get_feature("transaction_amount_7d_sum"), Transactions_featureset.get_feature("transaction_amount_7d_avg"),]# puoi anche specificare le funzionalità in forma di stringa: featurestore:featureset:version :featuremore_features = [ "transactions:1:transaction_3d_count", "transactions:1:transaction_amount_3d_avg",]more_features = featurestore.resolve_feature_uri(more_features)features.extend(more_features)# genera frame di dati di training utilizzando i dati delle feature e i dati di osservazionetraining_df = get_offline_features( features =features,observation_data=observation_data_df, timestamp_column=obs_data_timestamp_column,)# Ignora il messaggio che dice che il set di funzionalità non è materializzato (la materializzazione è facoltativa). Abiliteremo la materializzazione nella parte successiva del tutorial.display(training_df)# Nota: la colonna timestamp viene visualizzata in un formato diverso. Facoltativamente, puoi chiamare training_df.show() per vedere il valore formattato correttamente

Questo tutorial ha creato i dati di training con le funzionalità del feature store. Facoltativamente: puoi salvarlo nell'archiviazione per un uso successivo oppure puoi eseguire direttamente l'addestramento del modello su di esso.

Ripulire

Parte 4di questo tutorial descrive come eliminare le risorse

Prossimi passi

• Parte 2: abilitare la materializzazione e i dati delle funzionalità di riempimento
• Comprendere i concetti:concetti di negozio di funzionalità,entità di primo livello nel feature store gestito
• Comprendi il controllo dell'identità e degli accessi per l'archivio delle funzionalità
• Visualizza la guida alla risoluzione dei problemi del negozio di funzionalità
• Riferimento:Riferimento YAML