Tutorial 2: Experimentar e treinar modelos usando os recursos

Artigo
09/30/2024

Essa série de tutoriais mostra como os recursos integram perfeitamente todas as fases do ciclo de vida de aprendizado de máquina: prototipagem, treinamento e operacionalização.

O primeiro tutorial mostrou como criar uma especificação de conjunto de recursos com transformações personalizadas. Depois, ele mostrou como usar esse conjunto de recursos para gerar dados de treinamento, habilitar a materialização e executar um provisionamento. O segundo tutorial mostrou como habilitar a materialização e executar um provisionamento. Ele também mostra como experimentar recursos para melhorar o desempenho do modelo.

Neste tutorial, você aprenderá a:

Fazer o protótipo de uma nova especificação de conjunto de recursos accounts, usando valores pré-computados existentes como recursos. Depois, registrar a especificação do conjunto de recursos local como um conjunto de recursos no repositório de recursos. Esse processo é diferente da primeira parte do tutorial, em que criamos um conjunto de recursos que tinha transformações personalizadas.
Selecione os recursos para o modelo nos conjuntos de recursos de transactions e accounts e salve-os como uma especificação de recuperação de recursos.
Execute um pipeline de treinamento que usa a especificação de recuperação de recursos para treinar um novo modelo. Esse pipeline usa o componente interno de recuperação de recursos para gerar os dados de treinamento.

Pré-requisitos

Antes de prosseguir com esse tutorial, conclua o primeiro tutorial da série.

Configuração

Configurar o notebook do Spark do Azure Machine Learning.

Você pode criar um novo notebook e executar as instruções deste documento, passo a passo. Você também pode abrir e executar o notebook existente denominado 2.Experiment-train-models-using-features.ipynb do diretório featurestore_sample/notebooks. Você pode escolher sdk_only ou sdk_and_cli. Mantenha este tutorial aberto e consulte-o para obter links de documentação e mais explicações.
1. No menu superior, na lista suspensa Compute, selecione Serverless Spark Compute em Azure Machine Learning Serverless Spark.
2. Configure a sessão:
  1. Quando a barra de ferramentas exibir Configurar sessão, selecione-a.
  2. Na guia Pacotes do Python, selecione Carregar arquivo Conda.
  3. Carregue o arquivo conda.yml que você carregou no primeiro tutorial.
  4. Como opção, você pode aumentar o tempo limite da sessão (tempo ocioso) para evitar execuções frequentes de pré-requisitos.

Inicie a sessão do 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")

Configure o diretório raiz para as amostras.

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

Configurar a CLI.
- SDK do Python
- CLI do Azure
Não aplicável.
1. Instale a extensão do Azure Machine Learning.
```
!az extension add --name ml
```
2. Autenticar.
```
!az login
```
3. Defina a assinatura padrão.
```
import os

subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]

!az account set -s $subscription_id
```

Inicialize as variáveis do workspace do projeto.

Esse é o workspace atual e o notebook do tutorial é executado neste recurso.

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

Inicialize as variáveis do repositório de recursos.

Atualize os valores featurestore_name e featurestore_location para refletir o que você criou no primeiro tutorial.

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

Inicialize o cliente de consumo do repositório de recursos.

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

Crie um cluster de cálculo chamado cpu-cluster no workspace do projeto.

Você precisa desse cluster de cálculo ao executar os trabalhos de inferência de lote/treinamento.

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

Criar o conjunto de recursos de contas em um ambiente local

Na primeira parte do tutorial, você criou um conjunto de recursos de transactions que tinha transformações personalizadas. Aqui, você criou um conjunto de recursos de accounts que usa valores pré-computados.

Para integrar recursos pré-computados, você pode criar uma especificação de conjunto de recursos sem escrever nenhum código de transformação. Você usa uma especificação para desenvolver e testar um conjunto de recursos em um ambiente de desenvolvimento totalmente local.

Você não precisa se conectar a um repositório de recursos. Nesse procedimento, você cria a especificação do conjunto de recursos localmente e, em seguida, faz a amostra dos valores dele. Para se beneficiar com as funcionalidades do repositório de recursos gerenciados, você deve usar uma definição de ativo de recurso para registrar a especificação do conjunto de recursos com um repositório de recursos. As etapas posteriores neste tutorial fornecem mais detalhes.

Explorar os dados de origem para contas.

Observação

Esse notebook usa dados de exemplo hospedados em um contêiner de blob acessível publicamente. Somente um driver wasbs pode ler esses dados no Spark. Ao criar conjuntos de recursos por meio do uso dos seus próprios dados de origem, hospede-os em uma conta do Azure Data Lake Storage Gen2 e use um driver abfss no caminho de dados.
```
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))
```

Ciar uma especificação de conjunto de recursos de accounts no local a partir desses recursos pré-computados.

Você não precisa de nenhum código de transformação aqui, pois referencia recursos pré-computados.

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

Exportar como uma especificação do conjunto de recursos.

Para registrar a especificação do conjunto de recursos no repositório de recursos, você deve salvá-la em um formato específico.

Depois de executar a próxima célula, inspecione a especificação do conjunto de recursos de accounts gerados. Para ver a especificação, abra o arquivo: featurestore/featuresets/accounts/spec/FeatureSetSpec.yaml da árvore de arquivos.

A especificação contém estes elementos importantes:
- source: uma referência a um recurso de armazenamento. Nesse caso, trata-se de um arquivo Parquet em um recurso de armazenamento de blobs.
- features: uma lista de recursos e seus tipos de dados. Com o código de transformação fornecido, o código deve retornar um DataFrame que mapeia os recursos e tipos de dados. Sem o código de transformação fornecido, o sistema cria a consulta para mapear os recursos e tipos de dados para a origem. Nesse caso, a especificação do conjunto de recursos accounts gerado não contém o código de transformação, pois os recursos são pré-computados.
- index_columns: as chaves de junção necessárias para acessar valores do conjunto de recursos.
Para saber mais, acesse as Noções básicas sobre entidades de nível superior no repositório de recursos gerenciados e os recursos do esquema YAML da especificação do conjunto de recursos da CLI (v2).

Como um benefício extra, persistir dar suporte ao controle do código-fonte.

Você não precisa de nenhum código de transformação aqui, pois referencia recursos pré-computados.
```
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)
```

Experimente localmente os recursos não registrados e registre-se no repositório de recursos quando estiver pronto

Ao desenvolver recursos, talvez você queira testá-los e validá-los localmente, antes de registrá-los no repositório de recursos ou executar pipelines de treinamento na nuvem. Uma combinação de um conjunto de recursos locais não registrados (accounts) e um conjunto de recursos registrados no repositório de recursos (transactions) gera dados de treinamento para o modelo de machine learning.

Selecionar recursos para o modelo.

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

Gerar dados de treinamento localmente.

Esta etapa gera dados de treinamento para fins ilustrativos. Como opção, você pode treinar modelos localmente aqui. Etapas posteriores neste tutorial explicam como treinar um modelo na nuvem.

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

Registrar o conjunto de recursos de accounts com o repositório de recursos.

Depois de experimentar localmente diferentes definições de recursos, e se elas parecerem razoáveis, você poderá registrar uma definição de ativo do conjunto de recursos com o repositório de recursos.

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

Obter o conjunto de recursos registrado e testá-lo.

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

Executar um teste de treinamento

Nestas etapas, você seleciona uma lista de recursos, executa um pipeline de treinamento e registra o modelo. Você pode repetir essa etapa até que o modelo seja executado conforme desejado.

Opcionalmente, descobrir recursos da interface do usuário do repositório de recursos.

O primeiro tutorial abordou essa etapa, quando você registrou o conjunto de recursos de transactions. Como você também tem um conjunto de recursos de accounts, você pode procurar os recursos disponíveis:
1. Acesse a página de aterrissagem global do Azure Machine Learning.
2. No painel esquerdo, selecione Repositórios de recursos.
3. Na lista de repositórios de recursos, selecione o repositório de recursos que você criou anteriormente.
A interface do usuário mostra os conjuntos de recursos e a entidade que criou. Selecione os conjuntos de recursos para procurar através das definições de recurso. Você também pode usar a caixa pesquisa global para pesquisar conjuntos de recursos entre os repositórios de recursos.

Opcionalmente, descobrir recursos do 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

Selecionar recursos para o modelo e exportá-lo como uma especificação de recuperação de recursos.

Nas etapas anteriores, você selecionou recursos a partir de uma combinação de conjuntos de recursos registrados e não registrados para experimentação e teste locais. Agora você pode experimentar na nuvem. A agilidade de envio de modelos aumentará se você salvar os recursos selecionados como uma especificação de recuperação de recursos e usar a especificação no fluxo de operações MLOps (machine learning) ou CI/CD (integração contínua e entrega contínua) para treinamento e inferência.
1. Selecionar recursos para o modelo.
```
# 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. Exporte os recursos selecionados como uma especificação de recuperação de recursos.
  
  Uma especificação de recuperação de recurso é uma definição portátil de uma lista de recursos associados a um modelo. Ele pode ajudar a simplificar o desenvolvimento e a operacionalização de um modelo de machine learning. Ela se torna uma entrada para o pipeline de treinamento que gera os dados de treinamento. Depois, ela é empacotada com o modelo.
  
  A fase de inferência usa a recuperação de recurso para pesquisar os recursos. Ela integra todas as fases do ciclo de vida do aprendizado de máquina. As alterações no pipeline de treinamento/inferência podem permanecer no mínimo à medida que você experimenta e implanta.
  
  O uso da especificação de recuperação de recursos e do componente de recuperação de recursos interno é opcional. Você pode usar diretamente a API get_offline_features(), conforme mostrado anteriormente. O nome da especificação deve ser feature_retrieval_spec.yaml quando você empacotar com o modelo. Dessa forma, o sistema pode reconhecê-la.
```
# 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)
```

Treinar na nuvem com pipelines e registrar o modelo

Nesse procedimento, você dispara manualmente o pipeline de treinamento. Um pipeline de CI/CD pode disparar o pipeline de treinamento em um cenário de produção com base em alterações na especificação de recuperação de recursos no repositório de origem. Você pode registrar o modelo se ele for satisfatório.

Executar o pipeline de treinamento.

O pipeline de treinamento tem estas etapas:
1. Recuperação de recursos: como entrada, esse componente interno usa a especificação de recuperação de recursos, os dados de observação e o nome da coluna de carimbo de data/hora. Depois, ele gera os dados de treinamento como saída. Ele executa essas etapas como um trabalho gerenciado do Spark.
2. Treinamento: essa etapa treina o modelo com base nos dados de treinamento e gera um modelo (ainda não registrado).
3. Avaliação: essa etapa valida se o desempenho do modelo e a qualidade estão dentro do limite. (Nesse tutorial, é uma etapa de espaço reservado para fins de ilustração.)
4. Registrar o modelo: essa etapa registra o modelo.
  
  Observação
  
  Na segunda parte do tutorial, você executou um trabalho de provisionamento para materializar dados para um conjunto de recursos de transactions. A etapa de recuperação de recursos lê valores de recurso de um repositório offline para esse conjunto de recursos. O comportamento será o mesmo se você usar a 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. Inspecionar o pipeline de treinamento e o modelo.
  - Para exibir as etapas do pipeline, selecione o hiperlink para o pipeline do Visualizador Web e abra-o em uma nova janela.
Usar a especificação de recuperação de recursos nos artefatos do modelo:
1. No painel esquerdo do workspace atual, selecione Modelos com o botão direito do mouse.
2. Selecione Abrir em uma nova guia ou janela.
3. Selecione fraud_model.
4. Selecione Artefatos.
A especificação de recuperação de recursos é empacotada junto com o modelo. A etapa de registro do modelo no pipeline de treinamento lidou com essa etapa. Você criou a especificação de recuperação de recursos durante a experimentação. Agora ela faz parte da definição do modelo. No próximo tutorial, você verá como o processo de inferência a usa.

Exibir o conjunto de recursos e as dependências do modelo

Exibir a lista de conjuntos de recursos associados ao modelo.

Na mesma página Modelos, selecione a guia Conjuntos de recursos. Essa guia mostra os conjuntos de recursos transactions e accounts. Esse modelo depende desses conjuntos de recursos.
Exibir a lista de modelos usando os conjuntos de recursos:
1. Abra a interface do usuário do repositório de recursos (descrita anteriormente nesse tutorial).
2. No painel esquerdo, selecione Repositórios de recursos.
3. Selecione um conjunto de recursos.
4. Selecione a guia Modelo.
A especificação de recuperação de recursos determinou essa lista quando o modelo foi registrado.

Limpar

O quinto tutorial da série descreve como excluir os recursos.

Próximas etapas

Vá para o próximo tutorial da série: Habilitar a materialização recorrente e executar a inferência em lote.
Saiba mais sobre conceitos de repositório de recursos e entidades de nível superior no repositório de recursos gerenciados.
Saiba mais sobre controle de identidade e acesso para armazenamento de recursos gerenciados.
Veja o guia de solução de problemas para armazenamento de recursos gerenciados.
Veja a referência YAML.

Compartilhar via