As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Introdução ao caderno de exemplo do Feature Store

O código de exemplo nesta página se refere ao caderno de exemplo Introdução à Feature Store. Recomendamos que você execute esse notebook no Studio Classic, em instâncias de notebook ou JupyterLab porque o código neste guia é conceitual e não é totalmente funcional se copiado.

Use o seguinte para clonar o amazon-sagemaker-examples GitHub repositório aws/, contendo o notebook de exemplo:

Agora que você tem os cadernos de exemplo de SageMaker IA, navegue até o amazon-sagemaker-examples/sagemaker-featurestore diretório e abra o caderno de exemplo de Introdução ao Feature Store.

Etapa 1: configurar sua sessão de SageMaker IA

Para começar a usar a Feature Store, crie uma sessão de SageMaker IA. Em seguida, configure o bucket do Amazon Simple Storage Service (Amazon S3) que deseja usar para seus atributos. O bucket do Amazon S3 é seu armazenamento offline. O código a seguir usa o bucket padrão do SageMaker AI e adiciona um prefixo personalizado a ele.

# SageMaker Python SDK version 2.x is required
import sagemaker
import sys

import boto3
import pandas as pd
import numpy as np
import io
from sagemaker.session import Session
from sagemaker import get_execution_role

prefix = 'sagemaker-featurestore-introduction'
role = get_execution_role()

sagemaker_session = sagemaker.Session()
region = sagemaker_session.boto_region_name
s3_bucket_name = sagemaker_session.default_bucket()

Etapa 2: inspecionar seus dados

Neste exemplo de notebook, ingerimos dados sintéticos do GitHub repositório que hospeda o notebook completo.

customer_data = pd.read_csv("data/feature_store_introduction_customer.csv")
orders_data = pd.read_csv("data/feature_store_introduction_orders.csv")

print(customer_data.head())
print(orders_data.head())

O diagrama a seguir ilustra as etapas pelas quais os dados passam antes de serem ingeridos no Feature Store. Neste caderno, ilustramos o caso de uso em que você tem dados de várias fontes e deseja armazená-los de forma independente em um Feature Store. Nosso exemplo considera dados de um data warehouse (dados do cliente) e dados de um serviço de streaming em tempo real (dados do pedido).

Etapa 3: criar grupos de atributos

Primeiro, começamos criando nomes de grupos de atributos para customer_data e orders_data. Depois disso, criamos dois grupos de atributos, um para customer_data e outro para orders_data.

import time
from time import strftime, gmtime
customers_feature_group_name = 'customers-feature-group-' + strftime('%d-%H-%M-%S', gmtime())
orders_feature_group_name = 'orders-feature-group-' + strftime('%d-%H-%M-%S', gmtime())

Instancie um objeto FeatureGroup para customers_data e orders_data:

from sagemaker.feature_store.feature_group import FeatureGroup

customers_feature_group = FeatureGroup(
    name=customers_feature_group_name, sagemaker_session=sagemaker_session
)
orders_feature_group = FeatureGroup(
    name=orders_feature_group_name, sagemaker_session=sagemaker_session
)

import time
current_time_sec = int(round(time.time()))
record_identifier_feature_name = "customer_id"

Anexe um atributo EventTime ao seu quadro de dados. Esse parâmetro é obrigatório e marca a data e hora de cada ponto de dados.

customer_data["EventTime"] = pd.Series([current_time_sec]*len(customer_data), dtype="float64")
orders_data["EventTime"] = pd.Series([current_time_sec]*len(orders_data), dtype="float64")

Carregue as definições dos atributos em seu grupo de atributos.

customers_feature_group.load_feature_definitions(data_frame=customer_data)
orders_feature_group.load_feature_definitions(data_frame=orders_data)

Abaixo, chamamos create para criar dois grupos de atributos, customers_feature_group e orders_feature_group, respectivamente:

customers_feature_group.create(
    s3_uri=f"s3://{s3_bucket_name}/{prefix}",
    record_identifier_name=record_identifier_feature_name,
    event_time_feature_name="EventTime",
    role_arn=role,
    enable_online_store=True
)

orders_feature_group.create(
    s3_uri=f"s3://{s3_bucket_name}/{prefix}",
    record_identifier_name=record_identifier_feature_name,
    event_time_feature_name="EventTime",
    role_arn=role,
    enable_online_store=True
)

Para confirmar que seu grupo de recursos foi criado, nós o exibimos usando DescribeFeatureGroup e ListFeatureGroups APIs:

customers_feature_group.describe()

orders_feature_group.describe()

sagemaker_session.boto_session.client('sagemaker', region_name=region).list_feature_groups() # We use the boto client to list FeatureGroups

Etapa 4: ingerir dados em um grupo de atributos

Depois que os grupos de atributos forem criados, podemos colocar dados neles. Se você estiver usando a SageMaker IA AWS SDK for Python (Boto3), use a chamada ingest da API. Se você estiver usando o SDK para Python (Boto3), use a API PutRecord. Levará menos de 1 minuto para ingerir dados em ambas as opções. Este exemplo usa o SDK de SageMaker IA para Python (Boto3), então ele usa a chamada de API: ingest

def check_feature_group_status(feature_group):
    status = feature_group.describe().get("FeatureGroupStatus")
    while status == "Creating":
        print("Waiting for Feature Group to be Created")
        time.sleep(5)
        status = feature_group.describe().get("FeatureGroupStatus")
    print(f"FeatureGroup {feature_group.name} successfully created.")

check_feature_group_status(customers_feature_group)
check_feature_group_status(orders_feature_group)

customers_feature_group.ingest(
    data_frame=customer_data, max_workers=3, wait=True
)

orders_feature_group.ingest(
    data_frame=orders_data, max_workers=3, wait=True
)

Usando um ID de registro de cliente arbitrário, 573291, usamos get_record para verificar se os dados foram ingeridos no grupo de atributos.

customer_id = 573291
sample_record = sagemaker_session.boto_session.client('sagemaker-featurestore-runtime', region_name=region).get_record(FeatureGroupName=customers_feature_group_name, RecordIdentifierValueAsString=str(customer_id))

print(sample_record)

A seguir consta uma demonstração de como usar o batch_get_record para obter um lote de registros.

all_records = sagemaker_session.boto_session.client(
    "sagemaker-featurestore-runtime", region_name=region
).batch_get_record(
    Identifiers=[
        {
            "FeatureGroupName": customers_feature_group_name,
            "RecordIdentifiersValueAsString": ["573291", "109382", "828400", "124013"],
        },
        {
            "FeatureGroupName": orders_feature_group_name,
            "RecordIdentifiersValueAsString": ["573291", "109382", "828400", "124013"],
        },
    ]
)

print(all_records)

Etapa 5: limpar

Aqui, removemos os grupos de atributos que criamos.

customers_feature_group.delete()
orders_feature_group.delete()

Etapa 6: próximas etapas

Neste caderno de exemplo, você aprendeu como começar rapidamente com o Feature Store, criar grupos de atributos e ingerir dados neles.

Para obter um exemplo avançado de como usar o Feature Store para um caso de uso de detecção de fraudes, consulte Detecção de fraudes com o Feature Store.

Etapa 7: exemplos de código para programadores

Neste caderno, usamos uma variedade de chamadas de API diferentes. A maioria deles é acessível por meio do SDK do SageMaker Python, mas alguns só existem no Boto3. Você pode invocar as chamadas da API do SDK do SageMaker Python diretamente nos objetos da Feature Store, enquanto para invocar as chamadas de API que existem no Boto3, você deve primeiro acessar um cliente do Boto3 por meio de suas sessões de Boto3 e IA: por exemplo,. SageMaker sagemaker_session.boto_session.client()

Veja a seguir uma lista de chamadas de API para esse caderno. Essas chamadas existem dentro do SDK for Python e exista no Boto3, para sua referência:

Chamadas de API do SDK para Python (Boto3)

describe()
ingest()
delete()
create()
load_feature_definitions()

Chamadas da API do Boto3

list_feature_groups()
get_record()