Partilhar via

Tutorial 1: Desenvolver e registrar um conjunto de recursos com o repositório de recursos gerenciados

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.

Você pode usar o repositório de recursos gerenciados do Azure Machine Learning para descobrir, criar e operacionalizar recursos. O ciclo de vida do aprendizado de máquina inclui uma fase de prototipagem, onde você experimenta vários recursos. Também envolve uma fase de operacionalização, onde os modelos são implantados e as etapas de inferência consultam dados de características. As características servem como tecido conjuntivo no ciclo de vida da aprendizagem automática. Para saber mais sobre os conceitos básicos para o repositório de recursos gerenciados, visite O que é o repositório de recursos gerenciados? e Noções básicas sobre entidades de nível superior em recursos de repositório de recursos gerenciados.

Este tutorial descreve como criar uma especificação de conjunto de recursos com transformações personalizadas. Em seguida, ele usa esse conjunto de recursos para gerar dados de treinamento, habilitar a materialização e executar um backfill. A materialização calcula os valores das características para uma janela de características e, em seguida, armazena esses valores num armazenamento de materialização. Todas as consultas de características podem então usar esses valores do repositório de materialização.

Sem materialização, uma consulta de conjunto de recursos aplica as transformações à origem em tempo real, para calcular os recursos 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, recomendamos que você materialize os recursos, para maior confiabilidade e disponibilidade.

Este tutorial é a primeira parte da série de tutoriais do repositório de recursos gerenciados. Aqui, você aprende a:

  • Crie um novo recurso mínimo de feature store.
  • Desenvolva e teste localmente um conjunto de recursos com capacidade de transformação de recursos.
  • Registre uma entidade de repositório de recursos com o repositório de recursos.
  • Registre o conjunto de recursos que você desenvolveu com o repositório de recursos.
  • Gere um exemplo de treinamento DataFrame usando os recursos que você criou.
  • Habilite a materialização offline nos conjuntos de recursos e preencha os dados do recurso.

Esta série de tutoriais tem duas faixas:

  • A faixa somente SDK usa apenas SDKs do Python. Escolha este percurso para desenvolvimento e implementação exclusivamente em Python.
  • A trilha SDK e CLI usa o SDK do Python apenas para desenvolvimento e teste de conjuntos de recursos e usa a CLI para operações CRUD (criar, ler, atualizar e excluir). Esta faixa é útil em cenários de integração contínua e entrega contínua (CI/CD) ou GitOps, onde CLI/YAML é preferido.

Pré-requisitos

Antes de prosseguir com este tutorial, certifique-se de abordar estes pré-requisitos:

  • Uma área de trabalho do Azure Machine Learning. Para obter mais informações sobre a criação de espaços de trabalho, visite Guia de início rápido: criar recursos de espaço de trabalho.

  • Na sua conta de usuário, você precisa da função Proprietário para o grupo de recursos onde o repositório de recursos é criado.

    Se você optar por usar um novo grupo de recursos para este tutorial, poderá excluir facilmente todos os recursos excluindo o grupo de recursos.

Preparar o ambiente do bloco de notas

Este tutorial usa um bloco de anotações do Azure Machine Learning Spark para desenvolvimento.

  1. No ambiente do estúdio do Azure Machine Learning, selecione Notebooks no painel esquerdo e, em seguida, selecione o separador Exemplos.

  2. Navegue até ao diretório featurestore_sample (selecione >) e, em seguida, selecione Clone.

    Captura de tela que mostra a seleção do diretório de exemplo no estúdio do Azure Machine Learning.

  3. O painel Selecionar diretório de destino abre-se. Selecione o diretório Usuários e, em seguida, selecione seu nome de usuário e, finalmente, selecione Clonar.

    Captura de tela mostrando a seleção do local do diretório de destino no estúdio do Azure Machine Learning para o recurso de exemplo.

  4. Para configurar o ambiente do bloco de anotações, você deve carregar o arquivo conda.yml :

    1. Selecione Blocos de Anotações no painel esquerdo e, em seguida, selecione a guia Arquivos .
    2. Navegue até o diretório env (selecione >featurestore_sample>project>env) e, em seguida, selecione o >
    3. Selecione Transferir.

    Captura de tela que mostra a seleção do arquivo YAML Conda no estúdio do Azure Machine Learning.

    1. Selecione Serverless Spark Compute na lista suspensa Compute da navegação superior. Esta operação pode demorar um a dois minutos. Aguarde até que uma barra de status na parte superior exiba Configurar sessão.
    2. Selecione Configurar sessão na barra de status superior.
    3. Selecione pacotes Python.
    4. Selecione Upload conda files.
    5. Selecione o conda.yml arquivo que você baixou em seu dispositivo local.
    6. (Opcional) Aumente o tempo limite da sessão (tempo ocioso em minutos) para reduzir o tempo de inicialização do cluster de faísca sem servidor.

  5. No ambiente do Azure Machine Learning, abra o bloco de anotações e selecione Configurar sessão.

    Captura de ecrã que mostra seleções para configurar uma sessão para um bloco de notas.

  6. No painel Configurar sessão, selecione Pacotes Python.

  7. Carregue o arquivo Conda:

    1. Na guia Pacotes Python, selecione Carregar arquivo Conda.
    2. Navegue até o diretório que hospeda o arquivo Conda.
    3. Selecione conda.yml e, em seguida, selecione Abrir.

    Captura de tela que mostra o diretório que hospeda o arquivo Conda.

  8. Selecione Aplicar.

    Captura de tela que mostra o upload do arquivo Conda.

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

Configurar o diretório raiz para os exemplos

import os

# Please update <your_user_alias> below (or any custom directory you uploaded the samples to).
# You can find the name from the directory structure in the left navigation panel.
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

Não aplicável.

Nota

Você usa um repositório de recursos para reutilizar recursos em projetos. Você usa um espaço de trabalho de projeto (um espaço de trabalho do Azure Machine Learning) para treinar modelos de inferência, aproveitando os recursos dos repositórios de recursos. Muitos espaços de trabalho de projeto podem compartilhar e reutilizar o mesmo repositório de recursos.

Este tutorial usa dois SDKs:

  • SDK CRUD de armazenamento de recursos

    Você utiliza o mesmo SDK MLClient (nome do pacote azure-ai-ml) que emprega no espaço de trabalho do Azure Machine Learning. Um repositório de recursos é implementado como um tipo de espaço de trabalho. Como resultado, esse SDK é usado para operações CRUD para repositórios de recursos, conjuntos de recursos e entidades de armazenamento de recursos.

  • SDK principal do repositório de recursos

    Este SDK (azureml-featurestore) destina-se ao desenvolvimento e consumo de conjuntos de recursos. As etapas posteriores neste tutorial descrevem essas operações:

    • Desenvolva uma especificação de conjunto de recursos.
    • Recupere dados da funcionalidade.
    • Liste ou obtenha um conjunto de funcionalidades registado.
    • Gere e resolva especificações de recuperação de funcionalidades.
    • Gere dados de treino e inferência usando junções temporais.

Este tutorial não requer a instalação explícita desses SDKs, porque as instruções de conda.yml anteriores abrangem esta etapa.

Criar um repositório mínimo de recursos

  1. Defina parâmetros de armazenamento de recursos, incluindo nome, local e outros valores.

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

    from azure.ai.ml import MLClient
from azure.ai.ml.entities import (
    FeatureStore,
    FeatureStoreEntity,
    FeatureSet,
)
from azure.ai.ml.identity import AzureMLOnBehalfOfCredential

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


fs = FeatureStore(name=featurestore_name, location=featurestore_location)
# wait for feature store creation
fs_poller = ml_client.feature_stores.begin_create(fs)
print(fs_poller.result())

  3. Inicialize um cliente SDK principal do repositório de recursos para o Azure Machine Learning.

    Conforme explicado anteriormente neste tutorial, o cliente SDK principal do repositório de recursos é usado 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 a função "Cientista de Dados do Azure Machine Learning" no repositório de recursos à sua identidade de usuário. Obtenha seu valor de ID de objeto do Microsoft Entra no portal do Azure, conforme descrito em Localizar a ID do objeto do usuário.

    Atribua a função Cientista de Dados do AzureML à sua identidade de utilizador, para que possa criar recursos no espaço de trabalho do repositório de recursos. As permissões podem precisar de algum tempo para se propagar.

    Para obter mais informações sobre controle de acesso, visite o recurso "Gerir controle de acesso para loja de características gerida".

    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

Prototipar e desenvolver um conjunto de recursos

Nestas etapas, você cria um conjunto de recursos chamado transactions que tem recursos baseados em agregação de janela contínua:

  1. Explore os dados de origem transactions.

    Este caderno usa dados de exemplo hospedados num contentor de blobs acessível publicamente. Ele pode ser lido no Spark apenas através de um wasbs driver. Ao criar conjuntos de recursos usando seus próprios dados de origem, hospede-os em uma conta do Azure Data Lake Storage Gen2 e use um abfss driver no caminho de dados.

    # 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

  2. Desenvolva localmente o conjunto de recursos.

    Uma especificação de conjunto de recursos é uma definição independente de um conjunto de recursos que você pode desenvolver e testar localmente. Aqui, você cria estas características agregadas de janela móvel.

    • 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

    Verifique o ficheiro de código de transformação de funcionalidades: featurestore/featuresets/transactions/transformation_code/transaction_transform.py. Observe a agregação contínua definida para as funcionalidades. Este é um transformador Spark.

    Para saber mais sobre o conjunto de recursos e as transformações, visite o recurso O que é o repositório de recursos gerenciados?

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

  3. 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 essa especificação em um formato específico.

    Reveja a especificação do conjunto de funcionalidades gerado transactions. Abra este ficheiro na árvore de arquivos para ver a especificação featurestore/featuresets/accounts/spec/FeaturesetSpec.yaml.

    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 Blob storage.
    • features: Uma lista de recursos e seus tipos de dados. Caso forneça código de transformação, o código deverá retornar um DataFrame que mapeia para as características e tipos de dados.
    • index_columns: As chaves de junção necessárias para acessar valores do conjunto de recursos.

    Para saber mais sobre a especificação, visite os recursos Noções sobre entidades de nível superior no repositório gerido e Esquema YAML do conjunto de funcionalidades CLI (v2).

    Persistir a especificação do conjunto de recursos oferece outro benefício: a especificação do conjunto de recursos suporta o 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)

Registrar uma entidade de armazenamento de recursos

Como prática recomendada, as entidades ajudam a impor o uso da mesma definição de chave de junção, em conjuntos de recursos que usam as mesmas entidades lógicas. Exemplos de entidades incluem contas e clientes. Normalmente, as entidades são criadas uma vez e, em seguida, reutilizadas em conjuntos de recursos. Para saber mais, visite Noções básicas sobre entidades de nível superior no repositório de recursos gerenciados.

  1. Inicialize o cliente CRUD do repositório de recursos.

    Conforme explicado anteriormente neste tutorial, MLClient é usado para criar, ler, atualizar e apagar um ativo de armazenamento de funcionalidades. O exemplo de célula de código do notebook mostrado aqui pesquisa o repositório de funcionalidades que você criou numa etapa anterior. Aqui, você não pode reutilizar o mesmo ml_client valor usado anteriormente neste tutorial, porque esse valor tem escopo no nível do grupo de recursos. O escopo adequado é um pré-requisito para a criação de uma feature store.

    Neste exemplo de código, o cliente está definido ao nível do feature store.

    # MLClient for feature store.
fs_client = MLClient(
    AzureMLOnBehalfOfCredential(),
    featurestore_subscription_id,
    featurestore_resource_group_name,
    featurestore_name,
)

  2. Registre a account entidade no repositório de recursos.

    Crie uma account entidade que tenha a chave accountID de junção do tipo string.

    from azure.ai.ml.entities import DataColumn, DataColumnType

account_entity_config = FeatureStoreEntity(
    name="account",
    version="1",
    index_columns=[DataColumn(name="accountID", type=DataColumnType.STRING)],
    stage="Development",
    description="This entity represents user account index key accountID.",
    tags={"data_typ": "nonPII"},
)

poller = fs_client.feature_store_entities.begin_create_or_update(account_entity_config)
print(poller.result())

Registrar o conjunto de recursos de transação no repositório de recursos

Use esse código para registrar um ativo de conjunto de recursos no repositório de recursos. Você pode então reutilizar esse ativo e compartilhá-lo facilmente. O registro de um ativo de conjunto de recursos oferece recursos gerenciados, incluindo versionamento e materialização. As etapas posteriores desta série de tutoriais abrangem os recursos gerenciados.

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 utilizador do repositório de recursos

A criação e as atualizações de ativos do repositório de recursos podem acontecer somente por meio do SDK e da CLI. Você pode usar a interface do usuário para pesquisar ou navegar pelo repositório de recursos:

  1. Abra a página global inicial 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.

Conceda à função Leitor de Dados de Blob de Armazenamento acesso à sua conta de usuário no repositório offline

A função Leitor de Dados de Blob de Armazenamento deve ser atribuída à sua conta de usuário no repositório offline. Isto garante que a conta de utilizador possa ler dados de funcionalidades materializados a partir do repositório de materialização offline.

  1. Obtenha seu valor de ID de objeto do Microsoft Entra no portal do Azure, conforme descrito em Localizar a ID do objeto do usuário.

  2. Obtenha informações sobre o repositório de materialização offline na página Visão geral na interface do usuário do Feature Store. Você pode encontrar os valores para o ID de assinatura da conta de armazenamento, o nome do grupo de recursos da conta de armazenamento e o nome da conta de armazenamento na loja de materialização offline no cartão Loja de Materialização Offline.

    Captura de tela que mostra as informações da conta da loja offline na página Visão geral da loja de funcionalidades.

    Para obter mais informações sobre controle de acesso, visite o recurso Gerenciar controle de acesso para armazenamento de recursos gerenciados.

    Execute esta célula de código para atribuição de função. As permissões podem precisar de algum tempo para se propagar.

    # This utility function is created for ease of use in the docs tutorials. It uses standard azure API's.
# You can optionally inspect it `featurestore/setup/setup_storage_uai.py`.
import sys

sys.path.insert(0, root_dir + "/featurestore/setup")
from setup_storage_uai import grant_user_aad_storage_data_reader_role

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

grant_user_aad_storage_data_reader_role(
    AzureMLOnBehalfOfCredential(),
    your_aad_objectid,
    storage_subscription_id,
    storage_resource_group_name,
    storage_account_name,
)

Gerar um DataFrame de dados de treinamento usando o conjunto de recursos registrados

  1. Carregar dados de observação.

    Os dados de observação normalmente envolvem os principais dados usados para treinamento e inferência. Estes dados são combinados com os dados das características para criar o conjunto completo de dados de treino.

    Os dados de observação são dados capturados durante o próprio evento. Aqui, ele tem os principais dados de transação, incluindo ID da transação, ID da conta e valores do valor da transação. Como você o usa para treinamento, ele também tem uma variável de destino anexada (is_fraud).

    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 registado e liste as 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 que se tornam parte dos dados de treinamento. Em seguida, use o SDK do repositório de recursos para gerar os próprios 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

    Uma junção de um momento específico acrescenta as características aos dados de treino.

Habilitar a materialização offline no transactions conjunto de recursos

Depois que a materialização do conjunto de funcionalidades estiver ativada, pode-se executar um preenchimento retroativo. Você também pode agendar tarefas recorrentes de materialização. Para obter mais informações, visite o terceiro tutorial no recurso da série .

Defina spark.sql.shuffle.partitions no arquivo yaml de acordo com o tamanho dos dados do recurso

A configuração spark.sql.shuffle.partitions do Spark é um parâmetro OPCIONAL que pode influenciar o número de arquivos Parquet gerados (por dia) quando o conjunto de funcionalidades é materializado na loja offline. O valor padrão desse parâmetro é 200. Como melhor prática, evite a geração de muitos pequenos ficheiros Parquet. Se a recuperação de funcionalidades offline se tornar lenta após a materialização do conjunto de funcionalidades, vá para o diretório correspondente no repositório offline para verificar se o problema está relacionado com muitos ficheiros pequenos em formato parquet (por dia) e ajuste o valor do parâmetro em conformidade.

Nota

Os dados de exemplo usados neste bloco de anotações são pequenos. Portanto, esse parâmetro é definido como 1 no arquivo featureset_asset_offline_enabled.yaml.

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

Você também pode salvar o ativo do conjunto de características como um recurso YAML.

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

Dados de preenchimento para o transactions conjunto de recursos

Como explicado anteriormente, a materialização calcula os valores de recurso para uma janela de recurso e armazena esses valores computados em um repositório de materialização. A concretização de funcionalidades aumenta a fiabilidade e a disponibilidade dos valores calculados. Todas as consultas de recursos agora usam os valores do repositório de materialização. Esta etapa executa um preenchimento retroativo único para uma janela de funcionalidade de 18 meses.

Nota

Talvez precise determinar o valor para a janela de preenchimento de dados. A janela deve corresponder à janela dos seus dados de formação. Por exemplo, para usar 18 meses de dados para formação, deve-se recuperar características para 18 meses. Isso significa que deverá cobrir um período de 18 meses.

Esta célula de código materializa os dados por status atual Nenhum ou Incompleto para a janela de recurso definida.

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

Gorjeta

  • A timestamp coluna deve seguir o yyyy-MM-ddTHH:mm:ss.fffZ formato.
  • A feature_window_start_time e feature_window_end_time granularidade é limitada a segundos. Qualquer milissegundo fornecido no datetime objeto será ignorado.
  • Um trabalho de materialização só será enviado se os dados na janela de funcionalidades corresponderem ao data_status que foi definido durante o envio do trabalho de preenchimento.

Imprima dados de amostra do conjunto de funcionalidades. As informações de saída mostram que os dados foram recuperados do armazenamento de materialização. O get_offline_features() método recuperou os dados de treinamento e inferência. Ele também usa a loja 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))

Aprofunde ainda mais a materialização de funcionalidades off-line

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

  1. Abra a página global inicial 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.

    Captura de tela que mostra a interface de utilizador dos trabalhos de materialização do conjunto de funcionalidades.

  • O estado de materialização dos 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 repositório 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.

  • Você pode fornecer uma lista de mais de um status de dados (por exemplo, ["None", "Incomplete"]) em um único trabalho de preenchimento.

  • Durante o backfill, um novo trabalho de materialização é enviado para cada intervalo de dados que se enquadra na janela de características definida.

  • Se um trabalho de materialização estiver pendente ou estiver em execução para um intervalo de dados que ainda não foi preenchido, um novo trabalho não será enviado para esse intervalo de dados.

  • Você pode tentar novamente um trabalho de materialização com falha.

    Nota

    Para obter o identificador de um trabalho de materialização que falhou:

    • Navegue até a interface de utilizador da funcionalidade trabalhos de materialização.
    • Selecione o Nome de exibição de um trabalho específico com Estado de Falhou.
    • Localize o ID da tarefa na propriedade Nome encontrada na página Visão geral. Começa com Featurestore-Materialization-.

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

Atualização do armazém de materialização offline

  • Se um repositório de materialização offline precisar ser atualizado no nível do repositório de recursos, todos os conjuntos de recursos no repositório de recursos deverão ter a materialização offline desabilitada.
  • Se a materialização offline estiver desativada em um conjunto de recursos, o status de materialização dos dados já materializados no repositório de materialização offline será redefinido. A redefinição torna os dados que já estão materializados inutilizáveis. Você deve reenviar as tarefas de materialização depois de ativar a materialização offline.

Este tutorial criou os dados de treinamento com recursos do repositório de recursos, habilitou a materialização para o armazenamento de recursos offline e executou um backfill. Em seguida, você executará o treinamento de modelo usando esses recursos.

Limpeza

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

Próximos passos

  • Last updated on