Tutorial 2: Experimentar e treinar modelos usando recursos

Artigo
10/27/2023

Esta série de tutoriais mostra como os recursos integram perfeitamente todas as fases do ciclo de vida do 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 e, em seguida, usar esse conjunto de recursos para gerar dados de treinamento, habilitar a materialização e executar um backfill. Este tutorial mostra como habilitar a materialização e executar um backfill. Ele também mostra como experimentar recursos, como uma maneira de melhorar o desempenho do modelo.

Neste tutorial, irá aprender a:

Crie protótipos de uma nova accounts especificação de conjunto de recursos, usando valores pré-computados existentes como recursos. Em seguida, registre a especificação do conjunto de recursos local como um conjunto de recursos no repositório de recursos. Esse processo difere do primeiro tutorial, onde você criou um conjunto de recursos com transformações personalizadas.
Selecione recursos para o modelo nos transactions conjuntos de recursos e accounts 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 este tutorial, certifique-se de concluir o primeiro tutorial da série.

Configurar

Configure o bloco de anotações do Azure Machine Learning Spark.

Você pode criar um novo bloco de anotações e executar as instruções neste tutorial passo a passo. Você também pode abrir e executar o bloco de anotações existente chamado 2.Experiment-train-models-using-features.ipynb no 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 Computação , selecione Computação sem servidor 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 Python, selecione Carregar arquivo Conda.
  3. Carregue o arquivo conda.yml que você carregou no primeiro tutorial.
  4. Opcionalmente, aumente o tempo limite da sessão (tempo ocioso) para evitar repetiçõ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 os exemplos.

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

Configure a CLI.

Python SDK
CLI do Azure

Não aplicável.

Instale a extensão do Azure Machine Learning.
```
!az extension add --name ml
```
Autenticar.
```
!az login
```

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 espaço de trabalho do projeto.

Este é o espaço de trabalho atual e o bloco de anotações 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.

Certifique-se de atualizar os featurestore_name valores 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 computação nomeado cpu-cluster no espaço de trabalho do projeto.

Você precisa desse cluster de computação quando executa os trabalhos de inferência de treinamento/lote.

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

No primeiro tutorial, você criou um conjunto de transactions recursos com transformações personalizadas. Aqui, você cria um conjunto de accounts recursos que usa valores pré-calculados.

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 de conjunto de recursos para desenvolver e testar um conjunto de recursos em um ambiente de desenvolvimento totalmente local.

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

Explore os dados de origem das contas.

Nota

Este bloco de anotações usa dados de exemplo hospedados em um contêiner de blob acessível publicamente. Apenas um wasbs motorista pode lê-lo no Spark. Ao criar conjuntos de recursos usando seus próprios dados de origem, hospede esses conjuntos de recursos em uma conta do Azure Data Lake Storage Gen2 e use um abfss driver 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))
```

Crie a especificação do accounts conjunto de recursos localmente, a partir desses recursos pré-computados.

Você não precisa de nenhum código de transformação aqui, porque faz referência a 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 de conjunto de recursos.

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

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

A especificação tem estes elementos importantes:
- source: Uma referência a um recurso de armazenamento. Nesse caso, é um arquivo Parquet em um recurso de armazenamento de blob.
- 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 para 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 gerado accounts não contém código de transformação, porque os recursos são pré-calculados.
- index_columns: As chaves de junção necessárias para acessar valores do conjunto de recursos.
Para saber mais, consulte Noções básicas sobre entidades de nível superior no repositório de recursos gerenciados e o esquema YAML de especificação do conjunto de recursos da CLI (v2).

Como benefício extra, a persistência suporta o controle do código-fonte.

Você não precisa de nenhum código de transformação aqui, porque faz referência a 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 recursos não registrados e registre-se no repositório de recursos quando estiver pronto

À medida que desenvolve recursos, convém 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 local não registrado (accounts) e um conjunto de recursos registrado no repositório de recursos (transactions) gera dados de treinamento para o modelo de aprendizado de máquina.

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

Gere localmente dados de treinamento.

Esta etapa gera dados de treinamento para fins ilustrativos. Como opção, você pode treinar modelos localmente aqui. As etapas posteriores deste 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

Registre o accounts conjunto de recursos no repositório de recursos.

Depois de experimentar localmente as definições de recursos, e elas parecerem razoáveis, você poderá registrar uma definição de ativo de 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())

Obtenha o conjunto de recursos registrado e teste-o.

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

Executar uma experiência de formação

Nas etapas a seguir, você seleciona uma lista de recursos, executa um pipeline de treinamento e registra o modelo. Você pode repetir essas etapas até que o modelo tenha o desempenho desejado.

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

O primeiro tutorial abordou esta etapa, quando você registrou o transactions conjunto de recursos. Como você também tem um conjunto de accounts recursos, pode navegar pelos recursos disponíveis:
1. Vá para a página inicial 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 você criou. Selecione os conjuntos de recursos para navegar pelas definições de recursos. Você pode usar a caixa de pesquisa global para pesquisar conjuntos de recursos em repositórios de recursos.

Opcionalmente, descubra os 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

Selecione recursos para o modelo e exporte-o como uma especificação de recuperação de recursos.

Nas etapas anteriores, você selecionou recursos 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. Sua agilidade de envio de modelos aumenta se você salvar os recursos selecionados como uma especificação de recuperação de recursos e, em seguida, usar a especificação no fluxo de operações de aprendizado de máquina (MLOps) ou integração contínua e entrega contínua (CI/CD) para treinamento e inferência.
1. Selecione 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 recursos é uma definição portátil da lista de recursos associada a um modelo. Ele pode ajudar a agilizar o desenvolvimento e a operacionalização de um modelo de aprendizado de máquina. Ele se torna uma entrada para o pipeline de treinamento que gera os dados de treinamento. Em seguida, é embalado com o modelo.
  
  A fase de inferência usa a recuperação de recursos para procurar os recursos. Ele 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 integrado é opcional. Você pode usar diretamente a get_offline_features() API, como mostrado anteriormente. O nome da especificação deve ser feature_retrieval_spec.yaml quando for empacotada com o modelo. Desta forma, o sistema pode reconhecê-lo.
```
# 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)
```

Treine na nuvem com pipelines e registre o modelo

Neste procedimento, você aciona manualmente o pipeline de treinamento. Em um cenário de produção, um pipeline de CI/CD pode acioná-lo, com base em alterações na especificação de recuperação de recursos no repositório de origem. Você pode registrar o modelo se for satisfatório.

Execute o pipeline de treinamento.

O pipeline de treinamento tem estas etapas:
1. Recuperação de recursos: para sua 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. Em seguida, ele gera os dados de treinamento como saída. Ele executa essas etapas como um trabalho gerenciado do Spark.
2. Treinamento: Com base nos dados de treinamento, esta etapa treina o modelo e, em seguida, gera um modelo (ainda não registrado).
3. Avaliação: Esta etapa valida se o desempenho e a qualidade do modelo estão dentro de um limite. (Neste tutorial, é uma etapa de espaço reservado para fins de ilustração.)
4. Registrar o modelo: Esta etapa registra o modelo.
  
  Nota
  
  No segundo tutorial, você executou um trabalho de preenchimento para materializar dados para o transactions conjunto de recursos. A etapa de recuperação de recursos lê os valores de recursos do repositório offline para esse conjunto de recursos. O comportamento é o mesmo, mesmo se você usar a get_offline_features() API.
```
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. Inspecione o pipeline de treinamento e o modelo.
  - Para exibir as etapas do pipeline, selecione o hiperlink para o pipeline de Exibição da Web e abra-o em uma nova janela.
Use a especificação de recuperação de recursos nos artefatos do modelo:
1. No painel esquerdo do espaço de trabalho atual, selecione Modelos com o botão direito do mouse.
2. Selecione Abrir num novo separador 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 faz parte da definição do modelo. No próximo tutorial, você verá como a inferência o usa.

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

Exiba a lista de conjuntos de recursos associados ao modelo.

Na mesma página Modelos , selecione a guia Conjuntos de recursos. Esta guia mostra os transactions conjuntos de recursos e accounts os dos quais esse modelo depende.
Veja a lista de modelos que utilizam os conjuntos de funcionalidades:
1. Abra a interface do usuário do repositório de recursos (explicado anteriormente neste tutorial).
2. No painel esquerdo, selecione Conjuntos de recursos.
3. Selecione um conjunto de recursos.
4. Selecione a guia Modelos .
A especificação de recuperação de recursos determinou essa lista quando o modelo foi registrado.

Limpeza

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

Próximos passos

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

Partilhar via