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

Detecção de fraudes com o bloco de anotações de exemplo do Feature Store

O código de exemplo nesta página se refere ao caderno de exemplo: Detecção de fraudes com a Amazon SageMaker Feature Store. Recomendamos que você execute esse notebook no Studio Classic, em instâncias de notebook ou no 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 SageMaker exemplo, navegue até o amazon-sagemaker-examples/sagemaker-featurestore diretório e abra o caderno de exemplo Fraud Detection with Amazon SageMaker Feature Store.

Etapa 1: configurar sua sessão da Feature Store

Para começar a usar a Feature Store, crie uma SageMaker sessão, uma sessão de Boto3 e uma sessão de Feature Store. Além disso, configure o bucket do Amazon S3 que deseja usar para seus atributos. Esse é seu armazenamento off-line. O código a seguir usa o bucket SageMaker padrão e adiciona um prefixo personalizado a ele.

import boto3
import sagemaker
from sagemaker.session import Session

sagemaker_session = sagemaker.Session()
region = sagemaker_session.boto_region_name
boto_session = boto3.Session(region_name=region)
role = sagemaker.get_execution_role()
default_bucket = sagemaker_session.default_bucket()
prefix = 'sagemaker-featurestore'
offline_feature_store_bucket = 's3://{}/{}'.format(default_bucket, prefix)

sagemaker_client = boto_session.client(service_name='sagemaker', region_name=region)
featurestore_runtime = boto_session.client(service_name='sagemaker-featurestore-runtime', region_name=region)

feature_store_session = Session(
    boto_session=boto_session,
    sagemaker_client=sagemaker_client,
    sagemaker_featurestore_runtime_client=featurestore_runtime
)

Etapa 2: carregar conjuntos de dados e particionar dados em grupos de atributos

Carregue seus dados em quadros de dados para cada um dos seus atributos. Você usa esses quadros de dados depois de configurar o grupo de atributos. No exemplo de detecção de fraudes, você pode ver essas etapas no código a seguir.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import io

s3_client = boto3.client(service_name='s3', region_name=region)

fraud_detection_bucket_name = 'sagemaker-featurestore-fraud-detection'
identity_file_key = 'sampled_identity.csv'
transaction_file_key = 'sampled_transactions.csv'

identity_data_object = s3_client.get_object(Bucket=fraud_detection_bucket_name, Key=identity_file_key)
transaction_data_object = s3_client.get_object(Bucket=fraud_detection_bucket_name, Key=transaction_file_key)

identity_data = pd.read_csv(io.BytesIO(identity_data_object['Body'].read()))
transaction_data = pd.read_csv(io.BytesIO(transaction_data_object['Body'].read()))

identity_data = identity_data.round(5)
transaction_data = transaction_data.round(5)

identity_data = identity_data.fillna(0)
transaction_data = transaction_data.fillna(0)

# Feature transformations for this dataset are applied before ingestion into FeatureStore.
# One hot encode card4, card6
encoded_card_bank = pd.get_dummies(transaction_data['card4'], prefix = 'card_bank')
encoded_card_type = pd.get_dummies(transaction_data['card6'], prefix = 'card_type')

transformed_transaction_data = pd.concat([transaction_data, encoded_card_type, encoded_card_bank], axis=1)
transformed_transaction_data = transformed_transaction_data.rename(columns={"card_bank_american express": "card_bank_american_express"})

Etapa 3: configurar grupos de atributos

Ao configurar seus grupos de atributos, você precisa personalizar os nomes dos atributos com um nome exclusivo e configurar cada grupo de atributos com a classe FeatureGroup.

from sagemaker.feature_store.feature_group import FeatureGroup
feature_group_name = "some string for a name"
feature_group = FeatureGroup(name=feature_group_name, sagemaker_session=feature_store_session)

Por exemplo, no exemplo de detecção de fraudes, os dois grupos de atributos são identity e transaction. No código a seguir, você pode ver como os nomes são personalizados com um carimbo de data/hora e, em seguida, cada grupo é configurado passando o nome e a sessão.

import time
from time import gmtime, strftime, sleep
from sagemaker.feature_store.feature_group import FeatureGroup

identity_feature_group_name = 'identity-feature-group-' + strftime('%d-%H-%M-%S', gmtime())
transaction_feature_group_name = 'transaction-feature-group-' + strftime('%d-%H-%M-%S', gmtime())

identity_feature_group = FeatureGroup(name=identity_feature_group_name, sagemaker_session=feature_store_session)
transaction_feature_group = FeatureGroup(name=transaction_feature_group_name, sagemaker_session=feature_store_session)

Etapa 4: configurar atributos de identificador de registro e horário do evento

Nesta etapa, você especifica um nome de identificador de registro e um nome de atributo de horário do evento. Esse nome é mapeado para a coluna dos atributos correspondentes em seus dados. Por exemplo, no exemplo de detecção de fraudes, a coluna de interesse éTransactionID. EventTime pode ser anexado aos seus dados quando nenhum carimbo de data/hora estiver disponível. No código a seguir, você pode ver como essas variáveis são definidas e, em seguida, EventTime é anexado aos dados de ambos os atributos.

record_identifier_name = "TransactionID"
event_time_feature_name = "EventTime"
current_time_sec = int(round(time.time()))
identity_data[event_time_feature_name] = pd.Series([current_time_sec]*len(identity_data), dtype="float64")
transformed_transaction_data[event_time_feature_name] = pd.Series([current_time_sec]*len(transaction_data), dtype="float64")

Etapa 5: carregar definições dos atributos

Agora você pode carregar as definições dos atributos passando um quadro de dados contendo os dados do atributo. No código a seguir para o exemplo de detecção de fraudes, o atributo de identidade e o atributo de transação são carregados usando load_feature_definitions, e essa função detecta automaticamente o tipo de dados de cada coluna de dados. Para desenvolvedores que usam um esquema em vez de detecção automática, consulte o exemplo de Exportar grupos de atributos do Data Wrangler para obter um código que mostra como carregar o esquema, mapeá-lo e adicioná-lo como uma FeatureDefinition que você pode usar para criar o FeatureGroup. Este exemplo também aborda uma AWS SDK for Python (Boto3) implementação, que você pode usar em vez do SageMaker PythonSDK.

identity_feature_group.load_feature_definitions(data_frame=identity_data); # output is suppressed
transaction_feature_group.load_feature_definitions(data_frame=transformed_transaction_data); # output is suppressed

Etapa 6: criar um grupo de atributos

Nesta etapa, você usa a função create para criar o grupo de atributos. O código a seguir mostra os parâmetros disponíveis. O armazenamento on-line não é criado por padrão, então você deve configurá-lo como True se quiser habilitá-lo. O s3_uri é o local do bucket do S3 do seu armazenamento offline.

# create a FeatureGroup
feature_group.create(
    description = "Some info about the feature group",
    feature_group_name = feature_group_name,
    record_identifier_name = record_identifier_name,
    event_time_feature_name = event_time_feature_name,
    feature_definitions = feature_definitions,
    role_arn = role,
    s3_uri = offline_feature_store_bucket,
    enable_online_store = True,
    online_store_kms_key_id = None,
    offline_store_kms_key_id = None,
    disable_glue_table_creation = False,
    data_catalog_config = None,
    tags = ["tag1","tag2"])

O código a seguir do exemplo de detecção de fraudes mostra uma create chamada mínima para cada um dos dois grupos de atributos que estão sendo criados.

identity_feature_group.create(
    s3_uri=offline_feature_store_bucket,
    record_identifier_name=record_identifier_name,
    event_time_feature_name=event_time_feature_name,
    role_arn=role,
    enable_online_store=True
)

transaction_feature_group.create(
    s3_uri=offline_feature_store_bucket,
    record_identifier_name=record_identifier_name,
    event_time_feature_name=event_time_feature_name,
    role_arn=role,
    enable_online_store=True
)

Quando você cria um grupo de atributos, leva tempo para carregar os dados e você precisa esperar até que o grupo de atributos seja criado antes de poder usá-lo. É possível verificar o status usando o método a seguir.

status = feature_group.describe().get("FeatureGroupStatus")

Enquanto o grupo de atributos está sendo criado, você recebe Creating como resposta. Quando essa etapa for concluída com êxito, a resposta será Created. Outros status possíveis são CreateFailed, Deleting, ou DeleteFailed.

Etapa 7: trabalhar com grupos de atributos

Agora que você configurou seu grupo de recursos, pode realizar qualquer uma das seguintes tarefas:

Descrever um grupo de atributos

Você pode recuperar informações sobre seu grupo de atributos com a função describe.

feature_group.describe()

Listar grupos de atributos

Você pode listar todos os seus grupos de atributos com a função list_feature_groups.

sagemaker_client.list_feature_groups()

Colocar um registro em um grupo de atributos

Você pode usar a função ingest para carregar os dados do seu atributo. Você passa um quadro de dados de dados do atributo, define o número de workers e opta por esperar que ele retorne ou não. O exemplo a seguir demonstra o uso da função ingest.

feature_group.ingest(
    data_frame=feature_data, max_workers=3, wait=True
)

Para cada grupo de atributos que você tem, execute a função ingest nos dados do atributo que você deseja carregar.

Obter registros de um grupo de atributos

Você pode usar a função get_record para recuperar os dados de um atributo específico por meio de seu identificador de registro. O exemplo a seguir usa um identificador de exemplo para recuperar o registro.

record_identifier_value = str(2990130)
featurestore_runtime.get_record(FeatureGroupName=transaction_feature_group_name, RecordIdentifierValueAsString=record_identifier_value)

Exemplo de resposta do exemplo de detecção de fraudes:

...
'Record': [{'FeatureName': 'TransactionID', 'ValueAsString': '2990130'},
  {'FeatureName': 'isFraud', 'ValueAsString': '0'},
  {'FeatureName': 'TransactionDT', 'ValueAsString': '152647'},
  {'FeatureName': 'TransactionAmt', 'ValueAsString': '75.0'},
  {'FeatureName': 'ProductCD', 'ValueAsString': 'H'},
  {'FeatureName': 'card1', 'ValueAsString': '4577'},
...

Gere comandos de colmeia DDL

A FeatureStore classe SDK do SageMaker Python também fornece a funcionalidade de gerar comandos do HiveDDL. O esquema da tabela é gerado com base nas definições do atributo. As colunas são nomeadas de acordo com o nome do atributo e o tipo de dado é inferido com base no tipo de atributo.

print(feature_group.as_hive_ddl())

Resultado do exemplo:

CREATE EXTERNAL TABLE IF NOT EXISTS sagemaker_featurestore.identity-feature-group-27-19-33-00 (
  TransactionID INT
  id_01 FLOAT
  id_02 FLOAT
  id_03 FLOAT
  id_04 FLOAT
 ...

Criar um conjunto de dados de treinamento

O Feature Store cria automaticamente um catálogo de AWS Glue dados quando você cria grupos de recursos e você pode desativá-lo se quiser. A seguir, descrevemos como criar um único conjunto de dados de treinamento com valores de atributos dos grupos de atributos de identidade e transação criados anteriormente neste tópico. Além disso, o texto a seguir descreve como executar uma consulta do Amazon Athena para juntar dados armazenados no armazenamento off-line de grupos de atributos de identidade e de transação.

Para começar, crie uma consulta Athena usando athena_query() tanto para grupos de recursos de identidade como de transação. O `table_name` é a AWS Glue tabela que é gerada automaticamente pela Feature Store.

identity_query = identity_feature_group.athena_query()
transaction_query = transaction_feature_group.athena_query()

identity_table = identity_query.table_name
transaction_table = transaction_query.table_name

Gravar e executar uma consulta Athena

Você escreve sua consulta usando esses grupos de recursos e, SQL em seguida, executa a consulta com o .run() comando e especifica a localização do bucket do Amazon S3 para que o conjunto de dados seja salvo lá.

# Athena query
query_string = 'SELECT * FROM "'+transaction_table+'" LEFT JOIN "'+identity_table+'" ON "'+transaction_table+'".transactionid = "'+identity_table+'".transactionid'

# run Athena query. The output is loaded to a Pandas dataframe.
dataset = pd.DataFrame()
identity_query.run(query_string=query_string, output_location='s3://'+default_s3_bucket_name+'/query_results/')
identity_query.wait()
dataset = identity_query.as_dataframe()

A partir daqui, você pode treinar um modelo usando esse conjunto de dados e depois realizar a inferência.

Excluir um grupo de atributos

Você pode excluir um grupo de atributos com a função delete.

feature_group.delete()

O exemplo de código a seguir é do exemplo de detecção de fraudes.

identity_feature_group.delete()
transaction_feature_group.delete()

Para obter mais informações, consulte Excluir um grupo de recursos API.