Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Exemple de bloc-notes Détection de fraude avec Feature Store
**Important**
Les politiques IAM personnalisées qui permettent à Amazon SageMaker Studio ou Amazon SageMaker Studio Classic de 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 politique IAM 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 d' SageMaker IA](security_iam_id-based-policy-examples.md#grant-tagging-permissions).
[AWS politiques gérées pour Amazon SageMaker AI](security-iam-awsmanpol.md)qui 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](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-featurestore/sagemaker_featurestore_fraud_detection_python_sdk.html). Nous vous recommandons d’exécuter ce bloc-notes dans Studio Classic, les instances de bloc-notes ou JupyterLab, car le code fourni dans ce guide est conceptuel et ne fonctionne pas entièrement s’il est copié.
Utilisez ce qui suit pour cloner le amazon-sagemaker-examples GitHub référentiel [aws/](https://github.com/aws/amazon-sagemaker-examples) contenant l'exemple de bloc-notes.
+ **Pour Studio Classic**
Commencez par lancer Studio Classic. Vous pouvez ouvrir Studio Classic si vous avez activé Studio ou Studio Classic comme expérience par défaut. Pour ouvrir Studio Classic, consultez [Lancez Amazon SageMaker Studio Classic à l'aide de la console Amazon SageMaker AI](studio-launch.md#studio-launch-console).
Clonez le amazon-sagemaker-examples GitHub référentiel [aws/](https://github.com/aws/amazon-sagemaker-examples) dans Studio Classic en suivant les étapes décrites dans[Cloner un dépôt Git dans Amazon SageMaker Studio Classic](studio-tasks-git.md).
+ **Pour les instances d'Amazon SageMaker Notebook**
Lancez d'abord l'instance de SageMaker bloc-notes en suivant les instructions de[Accès aux instances de bloc-notes](howitworks-access-ws.md).
Ensuite, suivez les instructions fournies dans [Ajoutez un dépôt Git à votre compte Amazon SageMaker AI](nbi-git-resource.md).
Maintenant que vous disposez des exemples de blocs-notes SageMaker AI, accédez au `amazon-sagemaker-examples/sagemaker-featurestore` répertoire et ouvrez le bloc-notes d'exemple [Fraud Detection with Amazon SageMaker Feature Store](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-featurestore/sagemaker_featurestore_fraud_detection_python_sdk.html).
## Étape 1 : Configuration de votre session Feature Store
Pour commencer à utiliser Feature Store, créez une session SageMaker AI, 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 magasin hors ligne. Le code suivant utilise le bucket par défaut SageMaker AI 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 en savoir plus sur l’ajout de politiques à votre rôle IAM, consultez [Ajout de politiques à votre rôle IAM](feature-store-adding-policies.md).
```
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 est`TransactionID`. 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 [Exporter des groupes de caractéristiques à partir de Data Wrangler](https://docs.aws.amazon.com/sagemaker/latest/dg/data-wrangler-data-export.html#data-wrangler-data-export-feature-store), 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 pour Python (Boto3) implémentation que vous pouvez utiliser à la place du SDK SageMaker Python.
```
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` ou`DeleteFailed`.
## É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 :
**Topics**
+ [Description d'un groupe de fonctionnalités](#feature-store-describe-feature-groups)
+ [Énumération des groupes de fonctionnalités](#feature-store-list-feature-groups)
+ [Placement d'enregistrements dans un groupe de fonctionnalités](#feature-store-put-records-feature-group)
+ [Obtention d'enregistrements à partir d'un groupe de fonctionnalités](#feature-store-get-records-feature-group)
+ [Génération de commandes DDL Hive](#feature-store-generate-hive-ddl-commands-feature-group)
+ [Création d'un jeu de données d'entraînement](#feature-store-build-training-dataset)
+ [Écriture et exécution d'une requête Athena](#feature-store-write-athena-query)
+ [Suppression d'un groupe de fonctionnalités](#feature-store-delete-feature-group)
### 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ération de commandes DDL Hive
La `FeatureStore` classe du SDK SageMaker Python fournit également les fonctionnalités permettant de générer des commandes Hive DDL. 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\$1name` 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 en SQL sur ces groupes de fonctionnalités, puis vous l'exécutez avec la commande `.run()` et vous spécifiez l'emplacement de votre compartiment S3 pour y enregistrer le jeu de données.
```
# 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 [Suppression d’une API de groupe de caractéristiques](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DeleteFeatureGroup.html).