Esercitazione 2: Sperimentare ed eseguire il training di modelli usando le funzionalità

Articolo
10/16/2024

Questa serie di esercitazioni illustra come le funzionalità integrano perfettamente tutte le fasi del ciclo di vita dell'apprendimento automatico: creazione di prototipi, training e operazionalizzazione.

La prima esercitazione ha illustrato come creare una specifica del set di funzionalità con trasformazioni personalizzate. Ha quindi illustrato come usare tale set di funzionalità per generare dati di training, abilitare la materializzazione ed eseguire un backfill. Questa esercitazione illustra come abilitare la materializzazione ed eseguire un backfill. Illustra anche come sperimentare con le funzionalità, come metodo per migliorare le prestazioni del modello.

In questa esercitazione apprenderai a:

Creare un prototipo di una nuova accounts specifica del set di funzionalità tramite l'uso di valori precomputati esistenti come funzionalità. Quindi, registrare la specifica del set di funzionalità locale come set di funzionalità nell'archivio delle funzionalità. Questo processo differisce dalla prima esercitazione, in cui è stato creato un set di funzionalità con trasformazioni personalizzate.
Selezionare le funzionalità per il modello dai set di funzionalità transactions e accounts e salvarle come specifica di recupero delle funzionalità.
Eseguire una pipeline di training che usa la specifica di recupero delle funzionalità per eseguire il training di un nuovo modello. Questa pipeline usa il componente di recupero delle funzionalità predefinito per generare i dati di training.

Prerequisiti

Prima di procedere con questa esercitazione, assicurarsi di completare la prima esercitazione della serie.

Impostazione

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 esistente denominato 2.Experiment-train-models-using-features.ipynb dalla directory featurestore_sample/notebooks. È possibile scegliere tra sdk_only e sdk_and_cli. Mantenere aperta questa esercitazione e farvi riferimento per i collegamenti alla documentazione e altre spiegazioni.
1. Nel menu in alto selezionare Ambiente di calcolo Spark serverless nell'elenco a discesa Ambiente di calcolo in Azure Machine Learning Serverless Spark.
2. Configurare la sessione:
  1. Quando la barra degli strumenti visualizza Configura sessione, selezionarla.
  2. Nella scheda Pacchetti Python, selezionare Carica file Conda.
  3. Caricare il file conda.yml caricato nella prima esercitazione.
  4. Come opzione, è possibile aumentare il timeout della sessione (tempo di inattività) per evitare frequenti riesecuzioni dei prerequisiti.

Avviare la sessione Spark.

# run this cell to start the spark session (any code block will start the session ). This can take around 10 mins.
print("start spark session")

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

Configurare l'interfaccia della riga di comando.
- Python SDK
- Interfaccia della riga di comando di Azure
Non applicabile.
1. Installare l'estensione di Azure Machine Learning.
```
!az extension add --name ml
```
2. Eseguire l'autenticazione.
```
!az login
```
3. Impostare la sottoscrizione predefinita da usare.
```
import os

subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]

!az account set -s $subscription_id
```

Inizializzare le variabili dell'area di lavoro del progetto.

Si tratta dell'area di lavoro corrente e il notebook dell'esercitazione viene eseguito in questa risorsa.

### Initialize the MLClient of this project workspace
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 le variabili dell'archivio delle funzionalità.

Assicurarsi di aggiornare i featurestore_name valori e featurestore_location per riflettere ciò che è stato creato nella prima esercitazione.

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 ml client
fs_client = MLClient(
    AzureMLOnBehalfOfCredential(),
    featurestore_subscription_id,
    featurestore_resource_group_name,
    featurestore_name,
)

Inizializzare il client di consumo dell'archivio delle funzionalità.

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

Creare un cluster di calcolo denominato cpu-cluster nell'area di lavoro del progetto.

Questo cluster di calcolo è necessario quando si eseguono i processi di inferenza di training/batch.

from azure.ai.ml.entities import AmlCompute

cluster_basic = AmlCompute(
    name="cpu-cluster-fs",
    type="amlcompute",
    size="STANDARD_F4S_V2",  # you can replace it with other supported VM SKUs
    location=ws_client.workspaces.get(ws_client.workspace_name).location,
    min_instances=0,
    max_instances=1,
    idle_time_before_scale_down=360,
)
ws_client.begin_create_or_update(cluster_basic).result()

Creare la funzionalità account impostata in un ambiente locale

Nella prima esercitazione è stato creato un set di funzionalità transactions con trasformazioni personalizzate. In questo caso si crea un set di funzionalità accounts che usa valori pre-calcolati.

Per eseguire l'onboarding delle funzionalità pre-calcolate, è possibile creare una specifica del set di funzionalità, senza scrivere codice di trasformazione. Si usa una specifica del set di funzionalità per sviluppare e testare un set di funzionalità in un ambiente di sviluppo completamente locale.

Non è necessario connettersi a un archivio delle funzionalità. In questa procedura viene creata la specifica del set di funzionalità in locale e quindi vengono campionati i valori. Per trarre vantaggio dalle funzionalità di archivio delle funzionalità gestite, è necessario usare una definizione di asset di funzionalità per registrare la specifica del set di funzionalità con un archivio funzionalità. I passaggi successivi di questa esercitazione forniscono altri dettagli.

Esplorare i dati di origine per gli account.

Nota

Questo notebook usa dati di esempio ospitati in un contenitore BLOB accessibile pubblicamente. Solo un driver wasbs può leggerlo in Spark. Quando si creano set di funzionalità tramite l'uso di dati di origine personalizzati, ospitare tali set di funzionalità in un account Azure Data Lake Storage Gen2 e usare un abfss driver nel percorso dati.
```
accounts_data_path = "wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/accounts-precalculated/*.parquet"
accounts_df = spark.read.parquet(accounts_data_path)

display(accounts_df.head(5))
```

Creare la specifica del set di funzionalità accounts in locale, da queste funzionalità pre-calcolate.

Non è necessario alcun codice di trasformazione perché si fa riferimento alle funzionalità pre-calcolate.

from azureml.featurestore import create_feature_set_spec, FeatureSetSpec
from azureml.featurestore.contracts import (
    DateTimeOffset,
    Column,
    ColumnType,
    SourceType,
    TimestampColumn,
)
from azureml.featurestore.feature_source import ParquetFeatureSource


accounts_featureset_spec = create_feature_set_spec(
    source=ParquetFeatureSource(
        path="wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/accounts-precalculated/*.parquet",
        timestamp_column=TimestampColumn(name="timestamp"),
    ),
    index_columns=[Column(name="accountID", type=ColumnType.string)],
    # account profiles in the source are updated once a year. set temporal_join_lookback to 365 days
    temporal_join_lookback=DateTimeOffset(days=365, hours=0, minutes=0),
    infer_schema=True,
)

Esportazione come specifica del set di funzionalità.

Per registrare la specifica del set di funzionalità con l'archivi delle funzionalità, è necessario salvare la specifica del set di funzionalità in un formato specifico.

Dopo aver eseguito la cella successiva, esaminare la specifica del set di funzionalità generata accounts. Per visualizzare la specifica, aprire il file featurestore/featuresets/accounts/spec/FeatureSetSpec.yaml dall'albero dei file.

La specifica ha questi elementi importanti:
- source: riferimento a una risorsa di archiviazione. In questo caso, si tratta di un file Parquet in una risorsa di archiviazione BLOB.
- features: elenco delle funzionalità e dei relativi tipi di dati. Con il codice di trasformazione fornito, il codice deve restituire un DataFrame mappato alle funzionalità e ai tipi di dati. Senza il codice di trasformazione fornito, il sistema compila la query per eseguire il mapping delle caratteristiche e dei tipi di dati all'origine. In questo caso, la specifica del set di funzionalità generata accounts non contiene codice di trasformazione, perché le funzionalità vengono pre-calcolate.
- index_columns: chiavi di join necessarie per accedere ai valori dal set di funzionalità.
Per altre informazioni, vedere Informazioni sulle entità di primo livello in archivio delle funzionalità gestite e sulle risorse dello schema YAML dell'interfaccia della riga di comando (v2).

Come vantaggio aggiuntivo, il salvataggio permanente supporta il controllo del codice sorgente.

Non è necessario alcun codice di trasformazione perché si fa riferimento alle funzionalità pre-calcolate.
```
import os

# create a new folder to dump the feature set spec
accounts_featureset_spec_folder = root_dir + "/featurestore/featuresets/accounts/spec"

# check if the folder exists, create one if not
if not os.path.exists(accounts_featureset_spec_folder):
    os.makedirs(accounts_featureset_spec_folder)

accounts_featureset_spec.dump(accounts_featureset_spec_folder, overwrite=True)
```

Sperimentare localmente le funzionalità non registrate e registrarsi con l'archivio dele funzionalità quando si è pronti

Durante lo sviluppo di funzionalità, è consigliabile testarli e convalidarli in locale, prima di registrarli nell'archivio delle funzionalità o eseguire pipeline di training nel cloud. Una combinazione di un set di funzionalità locale non registrato (accounts) e un set di funzionalità registrato nell'archivio delle funzionalità (transactions) genera i dati di training per il modello di Machine Learning.

Selezionare le funzionalità per il modello.

# get the registered transactions feature set, version 1
transactions_featureset = featurestore.feature_sets.get("transactions", "1")
# Notice that account feature set spec is in your local dev environment (this notebook): not registered with feature store yet
features = [
    accounts_featureset_spec.get_feature("accountAge"),
    accounts_featureset_spec.get_feature("numPaymentRejects1dPerUser"),
    transactions_featureset.get_feature("transaction_amount_7d_sum"),
    transactions_featureset.get_feature("transaction_amount_3d_sum"),
    transactions_featureset.get_feature("transaction_amount_7d_avg"),
]

Generare dati di training in locale.

Questo passaggio genera dati di training per scopi illustrativi. Come opzione, è possibile eseguire il training locale dei modelli qui. I passaggi successivi di questa esercitazione illustrano come eseguire il training di un modello nel cloud.

from azureml.featurestore import get_offline_features

# Load the observation data. To understand observatio ndata, refer to part 1 of this tutorial
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"

# 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: display(training_df.head(5)) displays the timestamp column in a different format. You can can call training_df.show() to see correctly formatted value

Registrare il set di funzionalità accounts con l'archivio delle funzionalità.

Dopo aver sperimentato localmente le definizioni di funzionalità e, se sembrano ragionevoli, è possibile registrare una definizione di asset del set di funzionalità con l'archivio funzionalità.

from azure.ai.ml.entities import FeatureSet, FeatureSetSpecification

accounts_fset_config = FeatureSet(
    name="accounts",
    version="1",
    description="accounts featureset",
    entities=[f"azureml:account:1"],
    stage="Development",
    specification=FeatureSetSpecification(path=accounts_featureset_spec_folder),
    tags={"data_type": "nonPII"},
)

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

Ottenere il set di funzionalità registrato e testarlo.

# look up the featureset by providing name and version
accounts_featureset = featurestore.feature_sets.get("accounts", "1")

Eseguire un esperimento di training

In questi passaggi si seleziona un elenco di funzionalità, si esegue una pipeline di training e si registra il modello. È possibile ripetere questi passaggi fino a quando il modello non viene eseguito nel modo desiderato.

Facoltativamente, individuare le funzionalità dall'interfaccia utente dell'archivio delle funzionalità.

La prima esercitazione ha illustrato questo passaggio, quando è stato registrato il set di funzionalità transactions. Poiché è disponibile anche un set di funzionalità accounts, è possibile esplorare le funzionalità disponibili:
1. Passare alla pagina di destinazione globale di Azure Machine Learning.
2. Nel riquadro a sinistra, selezionare Archivi delle funzionalità.
3. Nell'elenco degli archivi delle funzionalità, selezionare l'archivio funzionalità creato in precedenza.
L'interfaccia utente mostra i set di funzionalità e l'entità creati. Selezionare i set di funzionalità per esplorare le definizioni delle funzionalità. È possibile usare la casella di ricerca globale per cercare set di funzionalità in archivi delle funzionalità.

Facoltativamente, individuare le funzionalità dell'SDK.

# List available feature sets
all_featuresets = featurestore.feature_sets.list()
for fs in all_featuresets:
    print(fs)

# List of versions for transactions feature set
all_transactions_featureset_versions = featurestore.feature_sets.list(
    name="transactions"
)
for fs in all_transactions_featureset_versions:
    print(fs)

# See properties of the transactions featureset including list of features
featurestore.feature_sets.get(name="transactions", version="1").features

Selezionare le funzionalità per il modello ed esportarlo come specifica di recupero delle funzionalità.

Nei passaggi precedenti sono state selezionate funzionalità da una combinazione di set di funzionalità registrati e non registrati per la sperimentazione e il test locali. È ora possibile sperimentare nel cloud. L'agilità di distribuzione del modello aumenta se si salvano le funzionalità selezionate come specifica di recupero delle funzionalità e quindi si usa la specifica nelle operazioni di Machine Learning (MLOps) o nel flusso di integrazione continua e recapito continuo (CI/CD) per il training e l'inferenza.
1. Selezionare le funzionalità per il modello.
```
# you can select features in pythonic way
features = [
    accounts_featureset.get_feature("accountAge"),
    transactions_featureset.get_feature("transaction_amount_7d_sum"),
    transactions_featureset.get_feature("transaction_amount_3d_sum"),
]

# you can also specify features in string form: featurestore:featureset:version:feature
more_features = [
    f"accounts:1:numPaymentRejects1dPerUser",
    f"transactions:1:transaction_amount_7d_avg",
]

more_features = featurestore.resolve_feature_uri(more_features)

features.extend(more_features)
```
2. Esportare le funzionalità selezionate come specifica di recupero delle funzionalità.
  
  Una specifica di recupero delle funzionalità è una definizione portabile dell'elenco di funzionalità associato a un modello. Consente di semplificare lo sviluppo e l'operazionalizzazione di un modello di Machine Learning. Diventa un input per la pipeline di training che genera i dati di training. Viene quindi creato un pacchetto con il modello.
  
  La fase di inferenza usa il recupero delle funzionalità per cercare le funzionalità. Integra tutte le fasi del ciclo di vita di Machine Learning. Le modifiche apportate alla pipeline di training/inferenza possono stare al minimo durante l'esperimento e la distribuzione.
  
  L'uso della specifica di recupero delle funzionalità e del componente di recupero delle funzionalità predefinito è facoltativo. È possibile usare direttamente l'API get_offline_features(), come illustrato in precedenza. Il nome della specifica deve essere feature_retrieval_spec.yaml quando viene creato un pacchetto con il modello. In questo modo, il sistema può riconoscerlo.
```
# Create feature retrieval spec
feature_retrieval_spec_folder = root_dir + "/project/fraud_model/feature_retrieval_spec"

# check if the folder exists, create one if not
if not os.path.exists(feature_retrieval_spec_folder):
    os.makedirs(feature_retrieval_spec_folder)

featurestore.generate_feature_retrieval_spec(feature_retrieval_spec_folder, features)
```

Eseguire il training nel cloud con le pipeline e registrare il modello

In questa procedura si attiva manualmente la pipeline di training. In uno scenario di produzione, una pipeline CI/CD potrebbe attivarla, in base alle modifiche apportate alla specifica di recupero delle funzionalità nel repository di origine. Se è soddisfacente, è possibile registrare il modello.

Eseguire la pipeline di training.

La pipeline di training prevede questi passaggi:
1. Recupero delle funzionalità: per l'input, questo componente predefinito accetta la specifica di recupero delle funzionalità, i dati di osservazione e il nome della colonna timestamp . Genera quindi i dati di training come output. Esegue questi passaggi come processo Spark gestito.
2. Training: in base ai dati di training, questo passaggio esegue il training del modello e quindi genera un modello (non ancora registrato).
3. Valutazione: questo passaggio convalida se le prestazioni e la qualità del modello rientrano in una soglia. (In questa esercitazione, si tratta di un passaggio segnaposto a scopo illustrativo.)
4. Registrare il modello: questo passaggio registra il modello.
  
  Nota
  
  Nella seconda esercitazione è stato eseguito un processo di back-fill per materializzare i dati per il set di funzionalità transactions. Il passaggio di recupero delle funzionalità legge i valori delle funzionalità dall'archivio offline per questo set di funzionalità. Il comportamento è lo stesso, anche se si usa l'API get_offline_features().
```
from azure.ai.ml import load_job  # will be used later

training_pipeline_path = (
    root_dir + "/project/fraud_model/pipelines/training_pipeline.yaml"
)
training_pipeline_definition = load_job(source=training_pipeline_path)
training_pipeline_job = ws_client.jobs.create_or_update(training_pipeline_definition)
ws_client.jobs.stream(training_pipeline_job.name)
# Note: First time it runs, each step in pipeline can take ~ 15 mins. However subsequent runs can be faster (assuming spark pool is warm - default timeout is 30 mins)
```
5. Esaminare la pipeline di training e il modello.
  - Per visualizzare i passaggi della pipeline, selezionare il collegamento ipertestuale per la pipeline di visualizzazione Web e aprirlo in una nuova finestra.
Usare la specifica di recupero delle funzionalità negli artefatti del modello:
1. Nel riquadro sinistro dell'area di lavoro corrente, selezionare Modelli con il pulsante destro del mouse.
2. Selezionare Apri in una nuova scheda o finestra.
3. Selezionare fraud_model.
4. Selezionare Elementi.
La specifica di recupero delle funzionalità viene inserita in un pacchetto insieme al modello. Il passaggio di registrazione del modello nella pipeline di training ha gestito questo passaggio. È stata creata la specifica di recupero delle funzionalità durante la sperimentazione. Ora fa parte della definizione del modello. Nell'esercitazione successiva si vedrà come viene usato dal processo di inferenza.

Visualizzare il set di funzionalità e le dipendenze del modello

Visualizzare l'elenco dei set di funzionalità associati al modello.

Nella stessa pagina Modelli selezionare la scheda Set di funzionalità. Questa scheda mostra entrambi i set di transactions funzionalità e accounts . Questo modello dipende da questi set di funzionalità.
Visualizzare l'elenco dei modelli che usano i set di funzionalità:
1. Aprire l'interfaccia utente dell'archivio funzionalità (illustrata in precedenza in questa esercitazione).
2. Nel riquadro sinistro selezionare Set di funzionalità.
3. Selezionare un set di funzionalità.
4. Selezionare la scheda Modelli.
La specifica di recupero delle funzionalità ha determinato questo elenco quando il modello è stato registrato.

Eseguire la pulizia

La quinta esercitazione della serie descrive come eliminare le risorse.

Passaggi successivi

Passare all'esercitazione successiva: Abilitare la materializzazione ricorrente ed eseguire l'inferenza batch.
Informazioni sui concetti relativi all'archivio delle funzionalità e sulle entità di primo livello nell'archivio delle funzionalità gestite.
Vedere informazioni sull'identità e sul controllo di accesso per l'archivio delle funzionalità gestite.
Visualizzare la guida alla risoluzione dei problemi per l'archivio delle funzionalità gestite.
Visualizzare il riferimento YAML.

Condividi tramite