Tutorial 2: Experimentar e treinar modelos usando recursos

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.

Importante

Cache do Azure para Redis anunciou o seu cronograma de descontinuação para todos os SKUs. Recomendamos que mude as suas instâncias existentes do Cache do Azure para Redis para o Azure Managed Redis assim que possível.

Orientação sobre migração:

Migre os níveis Básico, Standard e Premium para Azure Managed Redis
Migrar o nível Enterprise para o Azure Redis Gerido

Para mais detalhes sobre a aposentadoria:

O primeiro tutorial mostrou como criar uma especificação de conjunto de recursos com transformações personalizadas. Em seguida, mostrou como 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:

Prototipar uma nova accounts especificação de conjunto de recursos, através do uso de 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 características para o modelo a partir dos conjuntos de características transactions e accounts e guarde-os como uma especificação de recuperação de características.
Execute um pipeline de treino que usa a especificação de recuperação de caraterísticas para treinar um novo modelo. Esse pipeline utiliza o componente interno de recuperação de características para gerar 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 notas 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 notebook existente chamado 2.Experiment-train-models-using-features.ipynb na pasta 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. No separador Python pacotes, selecione Carregar ficheiro 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 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 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 deste cluster computacional enquanto executa os trabalhos de treinamento ou de inferência em 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 beneficiar das capacidades do repositório de características gerido, deverá usar uma definição de características para registar a especificação do conjunto de características em um repositório de características. As etapas posteriores neste tutorial fornecem mais detalhes.

Explore os dados de origem das contas.

Nota

Este notebook usa dados de exemplo hospedados num contentor de blobs disponível publicamente. Apenas um wasbs motorista pode lê-lo no Spark. Quando crias conjuntos de funcionalidades usando os teus próprios dados de origem, aloja esses conjuntos de funcionalidades numa conta Azure Data Lake Storage Gen2 e usa um driver abfss no caminho dos 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 funcionalidades.

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 ficheiro Parquet num recurso de armazenamento de blobs.
- features: Uma lista de recursos e seus tipos de dados. Com o código de transformação fornecido, deve-se retornar um DataFrame que mapeia as características e os 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, visite Noções básicas sobre entidades de nível superior no repositório de recursos gerenciados e os recursos do 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

Registe o accounts conjunto de características no repositório de características.

Depois de experimentar localmente as definições de recursos, e se 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

Nessas etapas, 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 as funcionalidades a partir da interface do repositório de funcionalidades.

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. Vai à página de destino global 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. A agilidade no desdobramento do seu modelo aumenta se guardar as características selecionadas como uma especificação para recuperação de características e, em seguida, utilizar a especificação no fluxo de operações de machine learning (MLOps) ou de integração contínua e entrega contínua (CI/CD) para treino 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 extração de funcionalidades para procurar as características. 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 se a empacota 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 obtenção de funcionalidades no repositório de origem. Você pode registrar o modelo se for satisfatório.

Execute o pipeline de treinamento.

O processo de treinamento tem estas etapas:
1. Recuperação de funcionalidades: como entrada, este componente interno utiliza a especificação de recuperação de funcionalidades, os dados de observação e o nome da coluna de timestamp. Em seguida, ele gera os dados de treinamento como saída. O sistema executa essas etapas como um trabalho gerido 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, é um passo fictício 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 fluxo de trabalho de treinamento e o modelo.
  - Para exibir as etapas do pipeline, selecione o hiperlink para o pipeline de Exibição na Web e abra-o em uma nova janela.
Use a especificação de recuperação de funcionalidades 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 funcionalidades é embalada juntamente com o modelo. A etapa de registro do modelo no pipeline de treinamento realizou essa ação. Você criou a especificação de recuperação de características durante a experimentação. Agora faz parte da definição do modelo. No próximo tutorial, você verá como o processo de 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 o separador Conjuntos de recursos. Este separador mostra tanto os transactions conjuntos de recursos como os accounts conjuntos de recursos. Esse modelo depende desses conjuntos de recursos.
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 funcionalidades determinou esta lista quando o modelo foi registado.

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.

Comentários

Esta página foi útil?

Last updated on 2026-04-13