Tutorial 1: Desenvolver e registrar um conjunto de recursos

Nesta série de tutoriais, você aprenderá a usar o repositório de recursos gerenciado para descobrir, criar e operacionalizar Azure Machine Learning recursos. Os recursos integram perfeitamente as fases de protótipo, treinamento e operacionalização do ciclo de vida do aprendizado de máquina.

Na fase de criação de protótipos, você experimenta vários recursos. Na fase de operacionalização, você implanta modelos que usam etapas de inferência para pesquisar dados de recursos. Os recursos funcionam como o tecido conjuntivo no ciclo de vida.

Use um workspace de projeto Azure Machine Learning para treinar modelos de inferência usando recursos de repositórios de recursos. Vários workspaces do projeto podem compartilhar e reutilizar o mesmo repositório de recursos. Para obter mais informações sobre o repositório de recursos gerenciado, consulte o repositório de recursos gerenciado e entenda as entidades de nível superior no repositório de recursos gerenciado.

Pré-requisitos

• Um workspace do Azure Machine Learning. Para obter mais informações sobre a criação do workspace, consulte Início Rápido: Criar recursos de workspace.
• Função de proprietário no grupo de recursos em que você cria o repositório de recursos.

Trilhas de tutorial SDK + CLI ou Somente SDK

Esta série de tutoriais usa um bloco de anotações Azure Machine Learning Spark para desenvolvimento. Você pode escolher entre duas faixas para concluir a série de tutoriais, dependendo de suas necessidades.

• A faixa SDK + CLI usa o SDK Python para desenvolvimento e teste de conjunto de recursos e usa CLI do Azure para operações CRUD (criar, ler, atualizar e excluir). Essa faixa é útil para cenários de CI/CD (integração contínua e entrega contínua) ou GitOps que usam CLI e YAML.

• A faixa somente SDK usa apenas SDKs Python. Essa faixa oferece desenvolvimento e implantação puros baseados em Python.

Selecione uma faixa abrindo o bloco de anotações na pasta cli_and_sdk ou sdk_only do bloco de anotações clonado. Siga as instruções na guia correspondente nos tutoriais.

Desenvolver e registrar um conjunto de recursos

Este tutorial explica como criar uma especificação de conjunto de recursos com transformações personalizadas. Em seguida, use esse conjunto de recursos para gerar dados de treinamento, habilitar a materialização e executar um backfill. Você aprenderá como:

Clonar o notebook

1. Em Estúdio do Azure Machine Learning, selecione Notebooks no menu de navegação esquerdo e selecione a guia Samples na página Notebooks.

2. Expanda as pastas SDK v2>sdk>python, clique com o botão direito do mouse na pasta featurestore_sample e selecione Clonar.

   

3. No painel Selecionar diretório de destino, verifique se Users><your_username>>featurestore_sample aparece e selecione Clonar. O featurestore_sample é clonado no diretório de usuário do workspace.

4. Acesse o notebook clonado na guia Arquivos da página Notebook e expanda Usuários><your_username>>featurestore_sample>project>env.

5. Clique com o botão direito do mouse no arquivo conda.yml e selecione Baixar para baixá-lo no computador, para que você possa carregá-lo posteriormente no ambiente do servidor.

   

Preparar e iniciar o bloco de anotações

1. No painel à esquerda na guia Arquivos, expanda featurestore_sample>notebooks>sdk_and_cli ou sdk_only, dependendo da trilha que você deseja executar.

2. Abra o primeiro capítulo do tutorial selecionando-o.

3. Na área superior direita da página Notebook, selecione a seta suspensa ao lado de Computação e escolha Computação Spark sem servidor – Disponível. Pode levar alguns minutos para anexar a computação.

4. Na barra superior acima do arquivo de notebook, selecione Configurar sessão.

   

5. Na tela Configurar sessão, selecione Pacotes Python no painel esquerdo.

6. Selecione Carregar arquivo conda e, em Selecionar arquivo conda, navegue até o arquivo conda.yml que você baixou.

7. Opcionalmente, selecione Configurações no painel à esquerda e aumente o valor do Tempo limite da sessão para ajudar a impedir que o tempo de inicialização do Spark sem servidor atinja o tempo limite.

8. Escolha Aplicar.

   

Iniciar o notebook

Criar um repositório de recursos mínimo

1. Defina parâmetros de armazenamento de recursos, incluindo nome, local e outros valores. Forneça um <FEATURESTORE_NAME> e depois execute a célula.

   # We use the subscription, resource group, region of this active project workspace.
   # You can optionally replace them to create the resources in a different subsciprtion/resource group, or use existing resources.
   import os
   
   featurestore_name = "<FEATURESTORE_NAME>"
   featurestore_location = "eastus"
   featurestore_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
   featurestore_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]

2. Crie o repositório de recursos.

   • SDK + CLI
   • Somente SDK

   !az ml feature-store create --subscription $featurestore_subscription_id --resource-group $featurestore_resource_group_name --location $featurestore_location --name $featurestore_name

3. Inicialize um cliente do SDK central do feature store para Azure Machine Learning. Use o cliente para desenvolver e consumir 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,
   )

4. Conceda à sua identidade de usuário a função Cientista de Dados do AzureML no repositório de recursos. Obtenha o valor da ID do objeto Microsoft Entra do portal Azure conforme descrito em Encontre a ID do objeto de usuário.

5. Execute a próxima célula para atribuir a função AzureML Cientista de Dados à sua identidade de usuário, para que ela possa criar recursos no workspace do feature store. Substitua o espaço reservado <USER_AAD_OBJECTID> pela ID do objeto do Microsoft Entra. As permissões podem precisar de algum tempo para serem propagadas.

   your_aad_objectid = "<USER_AAD_OBJECTID>"
   
   !az role assignment create --role "AzureML Data Scientist" --assignee-object-id $your_aad_objectid --assignee-principal-type User --scope $feature_store_arm_id

   Para obter mais informações sobre o controle de acesso, consulte Gerenciar o controle de acesso para o repositório de recursos gerenciado.

Prototipar e desenvolver um conjunto de recursos

Esse notebook usa dados de exemplo hospedados em um contêiner de blob acessível publicamente. Você pode ler esses dados no Spark somente por meio de um wasbs driver. Se você criar conjuntos de recursos usando seus próprios dados de origem, hospede os dados em uma conta Azure Data Lake Storage e use um abfss driver no caminho de dados.

Explorar os dados de origem das transações

Crie um conjunto de recursos chamado transactions com recursos baseados em agregação de janela sem interrupção.

# remove the "." in the roor directory path as we need to generate absolute path to read from spark
transactions_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))
# Note: display(training_df.head(5)) displays the timestamp column in a different format. You can can call transactions_src_df.show() to see correctly formatted value

Desenvolver localmente o conjunto de recursos

Uma especificação do conjunto de recursos é uma definição de conjunto de recursos independente que você pode desenvolver e testar localmente. Crie os seguintes recursos de agregação de janela sem interrupção:

• transactions three-day count
• transactions amount three-day avg
• transactions amount three-day sum
• transactions seven-day count
• transactions amount seven-day avg
• transactions amount seven-day sum

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

transactions_featureset_code_path = (
    root_dir + "/featurestore/featuresets/transactions/transformation_code"
)

transactions_featureset_spec = create_feature_set_spec(
    source=ParquetFeatureSource(
        path="wasbs://data@azuremlexampledata.blob.core.windows.net/feature-store-prp/datasources/transactions-source/*.parquet",
        timestamp_column=TimestampColumn(name="timestamp"),
        source_delay=DateTimeOffset(days=0, hours=0, minutes=20),
    ),
    feature_transformation=TransformationCode(
        path=transactions_featureset_code_path,
        transformer_class="transaction_transform.TransactionFeatureTransformer",
    ),
    index_columns=[Column(name="accountID", type=ColumnType.string)],
    source_lookback=DateTimeOffset(days=7, hours=0, minutes=0),
    temporal_join_lookback=DateTimeOffset(days=1, hours=0, minutes=0),
    infer_schema=True,
)

Revise o arquivo de código de transformação de características: featurestore/featuresets/transactions/transformation_code/transaction_transform.py. Observe a agregação contínua definida para os recursos. Este arquivo é um transformador Spark. Para obter mais informações sobre o conjunto de recursos e transformações, consulte O que é o repositório de recursos gerenciado?

Exportar como especificação de conjunto de funcionalidades

Para registrar a especificação do conjunto de recursos com o repositório de recursos, salve a especificação em um local e formato que dê suporte ao controle do código-fonte.

import os

# Create a new folder to dump the feature set specification.
transactions_featureset_spec_folder = (
    root_dir + "/featurestore/featuresets/transactions/spec"
)

# Check if the folder exists, create one if it does not exist.
if not os.path.exists(transactions_featureset_spec_folder):
    os.makedirs(transactions_featureset_spec_folder)

transactions_featureset_spec.dump(transactions_featureset_spec_folder, overwrite=True)

Para ver a especificação featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml, abra a especificação gerada do conjunto de recursos a partir da árvore de arquivos transactions. A especificação contém estes elementos:

• source: uma referência a um recurso de armazenamento. Nesse caso, é um arquivo parquet em um recurso de armazenamento de blobs.
• features: uma lista de funcionalidades e seus tipos de dados. Se você fornecer o código de transformação, o código deve retornar um DataFrame que mapeia os recursos e tipos de dados.
• index_columns: as chaves de junção necessárias para acessar os valores do conjunto de recursos.

Registrar uma entidade de armazenamento de recursos

As entidades ajudam a impor a melhor prática de usar a mesma definição de chave de junção entre conjuntos de recursos que usam as mesmas entidades lógicas. Exemplos de entidades incluem accounts e customers. Normalmente, você cria entidades uma vez e as reutiliza entre conjuntos de recursos. Para obter mais informações, consulte Noções básicas sobre entidades de nível superior no repositório de recursos gerenciado.

account_entity_path = root_dir + "/featurestore/entities/account.yaml"
!az ml feature-store-entity create --file $account_entity_path --resource-group $featurestore_resource_group_name --feature-store-name $featurestore_name

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

O código a seguir registra um ativo do conjunto de recursos com o repositório de recursos. Em seguida, você pode reutilizar esse ativo e compartilhá-lo facilmente. O registro de um ativo de conjunto de recursos oferece recursos gerenciados, incluindo controle de versão e materialização. Os tutoriais posteriores nesta série abrangem recursos gerenciados.

account_featureset_path = (
    root_dir + "/featurestore/featuresets/transactions/featureset_asset.yaml"
)
!az ml feature-set create --file $account_featureset_path --resource-group $featurestore_resource_group_name --feature-store-name $featurestore_name

from azure.ai.ml.entities import FeatureSetSpecification

transaction_fset_config = FeatureSet(
    name="transactions",
    version="1",
    description="7-day and 3-day rolling aggregation of transactions featureset",
    entities=[f"azureml:account:1"],
    stage="Development",
    specification=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())

Explore a interface do usuário da loja de recursos

Você pode criar e atualizar ativos do repositório de recursos apenas por meio do SDK e da CLI. Use a interface do usuário Machine Learning para pesquisar ou navegar pelo repositório de recursos.

1. Abra a página inicial global do Azure Machine Learning.
2. Selecione repositórios de recursos no painel esquerdo.
3. Na lista de repositórios de recursos acessíveis, selecione o repositório de recursos que você criou anteriormente neste tutorial.

Atribuir a função Leitor de Dados de Blob de Armazenamento

Atribua a função Leitor de Dados de Blob de Armazenamento à sua conta de usuário para garantir que você possa ler dados de recursos materializados do repositório de materialização offline.

Obtenha informações sobre o repositório de materialização offline na página Visão geral da IU do repositório de recursos. Os valores da conta de armazenamento <SUBSCRIPTION_ID>, conta de armazenamento <RESOURCE_GROUP> e <STORAGE_ACCOUNT_NAME> para o repositório de materialização offline estão localizados no cartão Repositório de materialização offline.

storage_subscription_id = "<SUBSCRIPTION_ID>"
storage_resource_group_name = "<RESOURCE_GROUP>"
storage_account_name = "<STORAGE_ACCOUNT_NAME>"

# Set the ADLS Gen2 storage account ARM ID
gen2_storage_arm_id = "/subscriptions/{sub_id}/resourceGroups/{rg}/providers/Microsoft.Storage/storageAccounts/{account}".format(
    sub_id=storage_subscription_id,
    rg=storage_resource_group_name,
    account=storage_account_name,
)

print(gen2_storage_arm_id)

!az role assignment create --role "Storage Blob Data Reader" --assignee-object-id $your_aad_objectid --assignee-principal-type User --scope $gen2_storage_arm_id

Para obter mais informações sobre o controle de acesso, consulte Gerenciar o controle de acesso para o repositório de recursos gerenciado.

Gerar um DataFrame de dados de treinamento

Gere um DataFrame de dados de treinamento usando o conjunto de recursos registrado.

1. Carregue os dados de observação capturados durante o evento em si.

   Os dados de observação normalmente envolvem os dados principais usados para treinamento e inferência, que se juntam aos dados de características para criar o conjunto completo de dados de treinamento. Os dados a seguir têm dados de transação principais, incluindo ID da transação, ID da conta e valores de valor da transação. Como você usa os dados para treinamento, ele também tem uma variável is_fraudde destino acrescentada.

   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)
   # Note: the timestamp column is displayed in a different format. Optionally, you can can call training_df.show() to see correctly formatted value

2. Obtenha o conjunto de funcionalidades registrado e liste suas funcionalidades.

   # Look up the featureset by providing a name and a version.
   transactions_featureset = featurestore.feature_sets.get("transactions", "1")
   # List its features.
   transactions_featureset.features

   # Print sample values.
   display(transactions_featureset.to_spark_dataframe().head(5))

3. Selecione os recursos para fazer parte dos dados de treinamento e use o SDK do repositório de recursos para gerar os próprios dados de treinamento. Uma junção de ponto no tempo acrescenta os recursos aos dados de treinamento.

   from azureml.featurestore import get_offline_features
   
   # You can select features in pythonic way.
   features = [
       transactions_featureset.get_feature("transaction_amount_7d_sum"),
       transactions_featureset.get_feature("transaction_amount_7d_avg"),
   ]
   
   # You can also specify features in string form: featureset:version:feature.
   more_features = [
       f"transactions:1:transaction_3d_count",
       f"transactions:1:transaction_amount_3d_avg",
   ]
   
   more_features = featurestore.resolve_feature_uri(more_features)
   features.extend(more_features)
   
   # 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 subsequent part of the tutorial.
   display(training_df)
   # Note: the timestamp column is displayed in a different format. Optionally, you can can call training_df.show() to see correctly formatted value

Habilitar a materialização offline

A materialização calcula os valores dos recursos de uma janela de recursos e armazena esses valores em um repositório de materialização. Todas as consultas de recursos podem então usar esses valores do armazenamento de materialização.

Sem materialização, uma consulta de conjunto de características aplica transformações à origem dinamicamente e calcula as características antes de retornar os valores. Este processo funciona bem para a fase de prototipagem. No entanto, para operações de treinamento e inferência em um ambiente de produção, materializar os recursos fornece maior confiabilidade e disponibilidade.

O repositório de blobs padrão para o repositório de recursos é um contêiner do Azure Data Lake Storage (ADLS). Um repositório de recursos é sempre criado com um repositório de materialização offline e uma identidade gerenciada atribuída pelo usuário (UAI).

Se você criar um repositório de recursos com valores offline_store=None padrão de parâmetro e materialization_identity=Noneo sistema executar a seguinte configuração:

1. Cria um contêiner do ADLS como o repositório offline.
2. Cria uma UAI e a atribui ao repositório de recursos como a identidade de materialização.
3. Atribui permissões de RBAC (controle de acesso baseado em função) obrigatórias à UAI no repositório offline.

Opcionalmente, você pode usar um contêiner do ADLS existente como o repositório offline definindo o offline_store parâmetro. Somente contêineres do ADLS têm suporte para repositórios de materialização offline.

Opcionalmente, você pode fornecer um UAI existente definindo um materialization_identity parâmetro. As permissões RBAC necessárias são atribuídas ao UAI no armazenamento offline durante a criação do armazenamento de recursos.

O exemplo de código a seguir mostra a criação de um repositório de recursos com offline_store e parâmetros materialization_identity definidos pelo usuário.

   import os
   from azure.ai.ml import MLClient
   from azure.ai.ml.identity import AzureMLOnBehalfOfCredential
   from azure.ai.ml.entities import (
      ManagedIdentityConfiguration,
      FeatureStore,
      MaterializationStore,
   )
   from azure.mgmt.msi import ManagedServiceIdentityClient

   # Get an existing offline store
   storage_subscription_id = "<OFFLINE_STORAGE_SUBSCRIPTION_ID>"
   storage_resource_group_name = "<OFFLINE_STORAGE_RESOURCE_GROUP>"
   storage_account_name = "<OFFLINE_STORAGE_ACCOUNT_NAME>"
   storage_file_system_name = "<OFFLINE_STORAGE_CONTAINER_NAME>"

   # Get ADLS container ARM ID
   gen2_container_arm_id = "/subscriptions/{sub_id}/resourceGroups/{rg}/providers/Microsoft.Storage/storageAccounts/{account}/blobServices/default/containers/{container}".format(
      sub_id=storage_subscription_id,
      rg=storage_resource_group_name,
      account=storage_account_name,
      container=storage_file_system_name,
   )

   offline_store = MaterializationStore(
      type="azure_data_lake_gen2",
      target=gen2_container_arm_id,
   )

   # Get an existing UAI
   uai_subscription_id = "<UAI_SUBSCRIPTION_ID>"
   uai_resource_group_name = "<UAI_RESOURCE_GROUP>"
   uai_name = "<FEATURE_STORE_UAI_NAME>"

   msi_client = ManagedServiceIdentityClient(
      AzureMLOnBehalfOfCredential(), uai_subscription_id
   )

   managed_identity = msi_client.user_assigned_identities.get(
      uai_resource_group_name, uai_name
   )

   # Get UAI information
   uai_principal_id = managed_identity.principal_id
   uai_client_id = managed_identity.client_id
   uai_arm_id = managed_identity.id

   materialization_identity1 = ManagedIdentityConfiguration(
      client_id=uai_client_id, principal_id=uai_principal_id, resource_id=uai_arm_id
   )

   # Create a feature store
   featurestore_name = "<FEATURE_STORE_NAME>"
   featurestore_location = "<AZURE_REGION>"
   featurestore_subscription_id = os.environ["AZUREML_ARM_SUBSCRIPTION"]
   featurestore_resource_group_name = os.environ["AZUREML_ARM_RESOURCEGROUP"]

   ml_client = MLClient(
      AzureMLOnBehalfOfCredential(),
      subscription_id=featurestore_subscription_id,
      resource_group_name=featurestore_resource_group_name,
   )

   # Use existing ADLS Gen2 container and UAI
   fs = FeatureStore(
      name=featurestore_name,
      location=featurestore_location,
      offline_store=offline_store,
      materialization_identity=materialization_identity1,
   )

   fs_poller = ml_client.feature_stores.begin_update(fs)

   print(fs_poller.result()) 

Depois de habilitar a materialização do conjunto de recursos no conjunto de recursos de transações, você pode executar um provisionamento. Você também pode agendar trabalhos de materialização recorrentes. Para obter mais informações, consulte o Tutorial 3: Habilitar a materialização recorrente e executar a inferência em lote.

Definir spark.sql.shuffle.partitions no arquivo YAML

A configuração spark.sql.shuffle.partitions do Spark é um parâmetro opcional que pode afetar o número de arquivos Parquet gerados por dia quando o conjunto de recursos é materializado no repositório offline. O valor padrão desse parâmetro é 200.

Como prática recomendada, evite gerar muitos arquivos parquet pequenos. Se a recuperação de recursos offline ficar lenta após a materialização do conjunto de recursos, abra a pasta correspondente no repositório offline. Verifique se o problema envolve muitos arquivos Parquet pequenos por dia e ajuste o valor desse parâmetro de acordo com o tamanho dos dados dos recursos.

transaction_asset_mat_yaml = (
    root_dir
    + "/featurestore/featuresets/transactions/featureset_asset_offline_enabled.yaml"
)

!az ml feature-set update --file $transaction_asset_mat_yaml --resource-group $featurestore_resource_group_name --feature-store-name $featurestore_name

from azure.ai.ml.entities import (
    MaterializationSettings,
    MaterializationComputeResource,
)

transactions_fset_config = fs_client._featuresets.get(name="transactions", version="1")

transactions_fset_config.materialization_settings = MaterializationSettings(
    offline_enabled=True,
    resource=MaterializationComputeResource(instance_type="standard_e8s_v3"),
    spark_configuration={
        "spark.driver.cores": 4,
        "spark.driver.memory": "36g",
        "spark.executor.cores": 4,
        "spark.executor.memory": "36g",
        "spark.executor.instances": 2,
        "spark.sql.shuffle.partitions": 1,
    },
    schedule=None,
)

fs_poller = fs_client.feature_sets.begin_create_or_update(transactions_fset_config)
print(fs_poller.result())

## uncomment to run
transactions_fset_config.dump(
    root_dir
    + "/featurestore/featuresets/transactions/featureset_asset_offline_enabled.yaml"
)

Dados de provisionamento para o conjunto de recursos de transações

A materialização calcula os valores de recursos de uma janela de recursos e armazena esses valores computados em um repositório de materialização. A materialização de recursos aumenta a confiabilidade e a disponibilidade dos valores computados. Todas as consultas de recursos agora usam os valores do armazenamento de materialização. Essa etapa executa um preenchimento único para uma janela de recurso de 18 meses.

A célula de código a seguir materializa os dados por status atual None ou Incomplete para a janela de recursos definida. Você pode fornecer uma lista de mais de um status de dados, como ["None", "Incomplete"], em um único trabalho de backfill.

feature_window_start_time = "2022-01-01T00:00.000Z"
feature_window_end_time = "2023-06-30T00:00.000Z"

!az ml feature-set backfill --name transactions --version 1 --by-data-status "['None', 'Incomplete']" --feature-window-start-time $feature_window_start_time --feature-window-end-time $feature_window_end_time --feature-store-name $featurestore_name --resource-group $featurestore_resource_group_name

from datetime import datetime
from azure.ai.ml.entities import DataAvailabilityStatus

st = datetime(2022, 1, 1, 0, 0, 0, 0)
et = datetime(2023, 6, 30, 0, 0, 0, 0)

poller = fs_client.feature_sets.begin_backfill(
    name="transactions",
    version="1",
    feature_window_start_time=st,
    feature_window_end_time=et,
    data_status=[DataAvailabilityStatus.NONE],
)
print(poller.result().job_ids)

# Get the job URL, and stream the job logs.
fs_client.jobs.stream(poller.result().job_ids[0])

Imprima dados de amostra do conjunto de recursos. As informações de saída mostram que os dados foram recuperados do armazenamento de materialização. O get_offline_features() método recupera os dados de treinamento e inferência e também usa o repositório de materialização por padrão.

# Look up the feature set by providing a name and a version and display few records.
transactions_featureset = featurestore.feature_sets.get("transactions", "1")
display(transactions_featureset.to_spark_dataframe().head(5))

Explore mais a fundo a materialização de recursos offline

Você pode explorar o status de materialização de recursos para um conjunto de recursos na interface do usuário Trabalhos de materialização.

1. Abra a página inicial global do Azure Machine Learning.

2. Selecione repositórios de recursos no painel esquerdo.

3. Na lista de repositórios de recursos acessíveis, selecione o repositório de recursos para o qual você executou o backfill.

4. Selecione a guia Trabalhos de Materialização .

   

O status de materialização de dados pode ser:

• Completo (verde)
• Incompleto (vermelho)
• Pendente (azul)
• Nenhum (cinza)

Um intervalo de dados representa uma parte contígua de dados com o mesmo status de materialização de dados. Por exemplo, o instantâneo anterior tem 16 intervalos de dados no armazenamento de materialização offline. Os dados podem ter um máximo de 2.000 intervalos de dados. Se os dados contiverem mais de 2.000 intervalos de dados, crie uma nova versão do conjunto de recursos.

Durante o backfill, o sistema envia um novo trabalho de materialização para cada intervalo de dados que se enquadra na janela de recursos definida. O sistema não enviará um trabalho se um trabalho de materialização já estiver pendente ou em execução para um intervalo de dados que não seja preenchido novamente.

Você pode tentar novamente uma tarefa de materialização com falha.

az ml feature-set backfill --by-job-id <JOB_ID_OF_FAILED_MATERIALIZATION_JOB> --name <FEATURE_SET_NAME> --version <VERSION>  --feature-store-name <FEATURE_STORE_NAME> --resource-group <RESOURCE_GROUP>

poller = fs_client.feature_sets.begin_backfill(
    name="transactions",
    version=version,
    job_id="<JOB_ID_OF_FAILED_MATERIALIZATION_JOB>",
)
print(poller.result().job_ids)

Atualizar um repositório de materialização offline

Para atualizar um repositório de materialização offline no nível do repositório de recursos, desabilite a materialização offline para todos os conjuntos de recursos no repositório de recursos.

Quando você desabilitar a materialização offline em um conjunto de recursos, o status de materialização é redefinido para os dados já materializados no repositório de materialização offline. O status de redefinição torna os dados já materializados inutilizáveis. Você deve reenviar os trabalhos de materialização depois de habilitar a materialização offline.

Limpar

Tutorial 5: Desenvolver um conjunto de recursos com uma fonte personalizada descreve como excluir os recursos.

Próximas Etapas 

Esse tutorial criou os dados de treinamento com recursos do repositório de recursos, habilitou a materialização no repositório de recursos offline e executou um preenchimento.

O próximo tutorial da série, Experimentar e treinar modelos usando recursos, mostra como executar o treinamento de modelo usando esses recursos. O próximo tutorial da série, Tutorial 2: Experimentar e treinar modelos usando recursos, mostra como executar o treinamento de modelo usando esses recursos.

Conteúdo relacionado

• O que é o repositório de recursos gerenciados?
• Entender as entidades de nível superior no repositório de recursos gerenciados.
• Gerenciar o controle de acesso para o repositório de recursos gerenciado.
• Solucionar problemas do repositório de recursos gerenciados.
• Esquemas YAML da CLI (v2)