Exemple de bloc-notes Détection de fraude avec Feature Store

Important

Les IAM politiques personnalisées qui autorisent Amazon SageMaker Studio ou Amazon SageMaker Studio Classic à créer des SageMaker ressources Amazon doivent également accorder des autorisations pour ajouter des balises à ces ressources. L'autorisation d'ajouter des balises aux ressources est requise car Studio et Studio Classic balisent automatiquement toutes les ressources qu'ils créent. Si une IAM politique autorise Studio et Studio Classic à créer des ressources mais n'autorise pas le balisage, des erreurs « AccessDenied » peuvent se produire lors de la tentative de création de ressources. Pour de plus amples informations, veuillez consulter Fournir des autorisations pour le balisage des ressources SageMaker.

AWS Politiques gérées pour Amazon SageMakerqui donnent des autorisations pour créer des SageMaker ressources incluent déjà des autorisations pour ajouter des balises lors de la création de ces ressources.

L'exemple de code présenté sur cette page fait référence à l'exemple de bloc-notes : Fraud Detection with Amazon SageMaker Feature Store. Nous vous recommandons d'exécuter ce bloc-notes dans Studio Classic, dans des instances de bloc-notes ou dans JupyterLab car le code de ce guide est conceptuel et n'est pas entièrement fonctionnel s'il est copié.

Utilisez ce qui suit pour cloner le amazon-sagemaker-examples GitHub référentiel aws/ contenant l'exemple de bloc-notes.

• Pour Studio Classic

  Lancez d'abord Studio Classic. Vous pouvez ouvrir Studio Classic si Studio ou Studio Classic est activé comme expérience par défaut. Pour ouvrir Studio Classic, voirLancez Studio Classic à l'aide de la SageMaker console Amazon.

  Clonez le amazon-sagemaker-examples GitHub référentiel aws/ dans Studio Classic en suivant les étapes décrites dansCloner un dépôt Git dans SageMaker Studio Classic.

• Pour les instances d'Amazon SageMaker Notebook

  Lancez d'abord l'instance de SageMaker bloc-notes en suivant les instructions deAccès aux instances de bloc-notes.

  Vérifiez si les exemples se trouvent déjà dans vos blocs-notes en suivant les instructions figurant dansAccédez à des exemples de blocs-notes. Si ce n'est pas le cas, suivez les instructions figurant dansAjoutez un dépôt Git à votre SageMaker compte Amazon.

Maintenant que vous disposez des SageMaker exemples de blocs-notes, accédez au amazon-sagemaker-examples/sagemaker-featurestore répertoire et ouvrez le bloc-notes d'exemple sur la détection des fraudes avec Amazon SageMaker Feature Store.

Étape 1 : configurer votre session Feature Store

Pour commencer à utiliser Feature Store, créez une SageMaker session, une session Boto3 et une session Feature Store. Configurez également le compartiment Amazon S3 que vous voulez utiliser pour vos fonctionnalités. Ceci est votre boutique hors ligne. Le code suivant utilise le bucket SageMaker par défaut et y ajoute un préfixe personnalisé.

Note

Le rôle que vous utilisez pour exécuter le bloc-notes doit disposer des politiques gérées suivantes attachées : AmazonSageMakerFullAccess et AmazonSageMakerFeatureStoreAccess. Pour plus d'informations sur l'ajout de politiques à votre IAM rôle, consultezAjouter des politiques à votre IAM rôle.

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
)

Étape 2 : Charger les jeux de données et les données de partition dans des groupes de fonctionnalités

Chargez vos données dans des blocs de données pour chacune de vos fonctions. Vous utilisez ces blocs de données après avoir configuré le groupe de fonctions. Dans l'exemple de détection de fraude, vous pouvez voir ces étapes dans le code suivant.

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

Étape 3 : Configurer les groupes de fonctionnalités

Lorsque vous configurez vos groupes de fonctions, vous devez personnaliser le nom des fonctions avec un nom unique et configurer chaque groupe de fonctions à l'aide de la 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)

Par exemple, dans l'exemple de détection de fraude, les deux groupes de fonctions sont identity et transaction. Dans le code suivant, vous pouvez voir comment les noms sont personnalisés avec un horodatage, puis comment chaque groupe est configuré en transmettant le nom et la session.

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)

Étape 4 : Configurer les fonctionnalités d'identificateur d'enregistrement et d'heure d'événement

Dans cette étape, vous spécifiez un nom d'identificateur d'enregistrement et un nom de fonction d'instant d'événement. Ce nom correspond à la colonne des fonctions correspondantes dans vos données. Par exemple, dans l'exemple de détection de fraude, la colonne d'intérêt estTransactionID. En l'absence d'horodatage, EventTime peut être ajouté à vos données. Dans le code suivant, vous pouvez voir comment ces variables sont définies, puis comment EventTime est ajouté aux données des deux fonctions.

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

Étape 5 : Charger les définitions de fonctionnalités

Vous pouvez maintenant charger les définitions de fonctions en transmettant un bloc de données contenant les données de fonctions. Dans le code suivant de l'exemple de détection de fraude, la fonction d'identité et la fonction de transaction sont chargées à l'aide de load_feature_definitions, et cette fonction détecte automatiquement le type de données de chaque colonne de données. Nous recommandons aux développeurs qui utilisent un schéma plutôt que la détection automatique de consulter l'exemple de code Export Feature Groups from Data Wrangler (Exporter des groupes de fonctions à partir de Data Wrangler), qui montre comment charger le schéma, le mapper et l'ajouter en tant que FeatureDefinition pour créer le FeatureGroup. Cet exemple couvre également une AWS SDK for Python (Boto3) implémentation que vous pouvez utiliser à la place du 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

Étape 6 : Créer un groupe de fonctionnalités

Dans cette étape, vous utilisez la fonction create pour créer le groupe de fonctions. L'exemple de code suivant montre l'ensemble des paramètres disponibles. La boutique en ligne n'est pas créée par défaut. Vous devez donc la définir à True si vous voulez l'activer. L's3_uri désigne l'emplacement du compartiment S3 de votre boutique hors ligne.

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

Le code suivant de l'exemple de détection de fraude affiche un appel create minimal pour chacun des deux groupes de fonctions en cours de création.

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
)

Lorsque vous créez un groupe de fonctions, le chargement des données prend du temps. Vous devez donc attendre que le groupe de fonctions soit créé avant de pouvoir l'utiliser. Vous pouvez utiliser la méthode suivante pour afficher l'état.

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

Pendant la création du groupe de fonctions, vous recevez la réponse Creating. Lorsque cette étape est terminée avec succès, la réponse est Created. Les autres états possibles sont les suivants :CreateFailed, Deleting ouDeleteFailed.

Étape 7 : Utiliser les groupes de fonctionnalités

Après avoir configuré votre groupe de fonctions, vous pouvez effectuer l'une des tâches suivantes :

Description d'un groupe de fonctionnalités

Vous pouvez récupérer des informations sur votre groupe de fonctions à l'aide de la fonction describe.

feature_group.describe()

Énumération des groupes de fonctionnalités

Vous pouvez répertorier tous vos groupes de fonctions à l'aide de la fonction list_feature_groups.

sagemaker_client.list_feature_groups()

Placement d'enregistrements dans un groupe de fonctionnalités

Vous pouvez utiliser la fonction ingest pour charger vos données de fonctions. Vous transmettez un bloc de données de données de fonctions, définissez le nombre d'employés et choisissez d'attendre qu'il revienne ou non. L'exemple suivant illustre l'utilisation de la fonction ingest.

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

Pour chaque groupe de fonctions dont vous disposez, exécutez la fonction ingest sur les données de fonctions que vous voulez charger.

Obtention d'enregistrements à partir d'un groupe de fonctionnalités

Vous pouvez utiliser la fonction get_record pour récupérer les données d'une fonction spécifique par son identificateur d'enregistrement. L'exemple suivant utilise un identificateur pour récupérer l'enregistrement.

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

Exemple de réponse pour l'exemple de détection de fraude :

...
'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'},
...

Générer des commandes Hive DDL

La FeatureStore classe SageMaker Python SDK fournit également les fonctionnalités permettant de générer des DDL commandes Hive. La table est structurée en fonction des définitions de fonctions. Les colonnes sont nommées d'après le nom de la fonction et le type de données est déduit du type de fonction.

print(feature_group.as_hive_ddl())

Exemple de sortie :

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

Création d'un jeu de données d'entraînement

Feature Store crée automatiquement un catalogue de AWS Glue données lorsque vous créez des groupes d'entités et vous pouvez le désactiver si vous le souhaitez. La section suivante décrit la création d'un jeu de données d'entraînement unique avec des valeurs de fonctions issues de groupes de fonctions d'identité et de transaction précédemment créés dans cette rubrique. En outre, la section suivante décrit l'exécution d'une requête Amazon Athena pour joindre des données stockées dans la boutique hors ligne et issues de groupes de fonctions d'identité et de transaction.

Pour commencer, créez une requête Athena en utilisant athena_query() pour les groupes de fonctions d'identité et de transaction. Le `table_name` est la AWS Glue table générée automatiquement par 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

Écriture et exécution d'une requête Athena

Vous écrivez votre requête à l'aide SQL de ces groupes de fonctionnalités, puis vous l'exécutez avec la .run() commande et vous spécifiez l'emplacement de votre compartiment Amazon S3 pour que l'ensemble de données y soit enregistré.

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

Vous pouvez alors entraîner un modèle à l'aide de ce jeu de données, puis effectuer une inférence.

Suppression d'un groupe de fonctionnalités

Vous pouvez supprimer un groupe de fonctions à l'aide de la fonction delete.

feature_group.delete()

L'exemple de code suivant est tiré de l'exemple de détection de fraude.

identity_feature_group.delete()
transaction_feature_group.delete()

Pour plus d'informations, consultez la section Supprimer un groupe de fonctionnalités API.