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 Introduction à 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 sur cette page fait référence à l’exemple de bloc-notes [Introduction à Feature Store](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-featurestore/feature_store_introduction.html). Nous vous recommandons d'exécuter ce bloc-notes dans Studio Classic, dans des instances de bloc-notes, ou JupyterLab parce que le code de ce guide est conceptuel et ne fonctionnera pas entièrement s'il est copié.
Utilisez ce qui suit pour cloner le amazon-sagemaker-examples GitHub dépôt [aws/](https://github.com/aws/amazon-sagemaker-examples) contenant l'exemple de bloc-notes :
+ **Pour Studio Classic**
Lancez Studio Classic. Vous pouvez ouvrir Studio Classic si vous avez activé Studio ou Studio Classic comme expérience par défaut. Pour obtenir des instructions sur la façon d’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 l'instance de SageMaker bloc-notes en suivant les instructions de[Accès aux instances de bloc-notes](howitworks-access-ws.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 [Introduction to Feature Store](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-featurestore/feature_store_introduction.html).
## Étape 1 : Configurez votre session SageMaker AI
Pour commencer à utiliser Feature Store, créez une session SageMaker AI. Configurez ensuite le compartiment Amazon Simple Storage Service (Amazon S3) que vous souhaitez utiliser pour vos caractéristiques. Le compartiment Amazon S3 est votre magasin hors connexion. 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 : `AmazonS3FullAccess` 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).
```
# 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()
```
## Étape 2 : inspection de vos données
Dans cet exemple de bloc-notes, nous ingérons des données synthétiques provenant du [GitHub référentiel](https://github.com/aws/amazon-sagemaker-examples/tree/master/sagemaker-featurestore/data) qui héberge le bloc-notes complet.
```
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())
```
Le diagramme suivant illustre les étapes suivies par les données avant leur ingestion dans Feature Store. Ce bloc-notes illustre le cas d’utilisation dans lequel vous disposez de données provenant de plusieurs sources et vous voulez les stocker de façon indépendante dans un magasin de caractéristiques. Notre exemple prend en compte des données provenant d’un entrepôt de données (données client) et des données provenant d’un service de streaming en temps réel (données de commande).
## Étape 3 : création de groupes de fonctions
Nous commençons par créer des noms de groupes de fonctions pour customer\_data et orders\_data. Après cela, nous créons deux groupes de caractéristiques, un pour `customer_data` et l’autre pour `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())
```
Instanciez un objet `FeatureGroup` pour `customers_data` et `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"
```
Ajoutez la fonction `EventTime` à votre bloc de données. Ce paramètre est obligatoire et permet d’horodater chaque point de données :
```
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")
```
Chargez les définitions des caractéristiques dans votre groupe de caractéristiques :
```
customers_feature_group.load_feature_definitions(data_frame=customer_data)
orders_feature_group.load_feature_definitions(data_frame=orders_data)
```
Le code suivant appelle `create` pour créer deux groupes de caractéristiques, `customers_feature_group` et `orders_feature_group`, respectivement :
```
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
)
```
Pour confirmer que votre groupe de fonctionnalités a été créé, nous l'affichons en utilisant `DescribeFeatureGroup` et `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
```
## Étape 4 : intégration de données dans un groupe de fonctions
Une fois les groupes de caractéristiques créés, nous pouvons y placer des données. Si vous utilisez l' SageMaker IA AWS SDK pour Python (Boto3), utilisez l'appel `ingest` d'API. Si vous utilisez le kit SDK pour Python (Boto3), utilisez l’API `PutRecord`. L’ingestion des données dans ces deux options prend moins d’une minute. Cet exemple utilise le SDK SageMaker AI pour Python (Boto3). Il utilise donc l'appel d'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
)
```
À l’aide d’un identifiant d’enregistrement client arbitraire, 573291, nous utilisons `get_record` pour vérifier que les données ont bien été ingérées dans le groupe de caractéristiques.
```
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)
```
Le code suivant montre comment utiliser `batch_get_record` pour obtenir un lot d’enregistrements.
```
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)
```
## Étape 5 : nettoyer
Ici, nous supprimons les groupes de caractéristiques que nous avons créés.
```
customers_feature_group.delete()
orders_feature_group.delete()
```
## Étape 6 : étapes suivantes
Dans cet exemple de bloc-notes, vous avez appris à vous familiariser avec Feature Store, à créer des groupes de caractéristiques et à y ingérer des données.
Pour obtenir un exemple avancé sur la manière d’utiliser Feature Store pour un cas d’utilisation de détection de fraude, consultez [Fraud Detection with Feature Store](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-featurestore/sagemaker_featurestore_fraud_detection_python_sdk.html).
## Étape 7 : Exemples de code pour les programmeurs
Dans ce bloc-notes, nous avons utilisé plusieurs appels d’API différents. La plupart d'entre eux sont accessibles via le SDK SageMaker Python, mais certains n'existent que dans Boto3. Vous pouvez appeler les appels d'API du SDK SageMaker Python directement sur vos objets Feature Store, alors que pour appeler des appels d'API qui existent dans Boto3, vous devez d'abord accéder à un client Boto3 via vos sessions Boto3 et SageMaker AI : par exemple,. `sagemaker_session.boto_session.client()`
Voici une liste des appels d’API pour ce bloc-notes. Ces appels existent dans le kit SDK for Python et dans Boto3, à titre de référence :
**Appels d’API du kit SDK pour Python (Boto3)**
```
describe()
ingest()
delete()
create()
load_feature_definitions()
```
**Appels d’API Boto3**
```
list_feature_groups()
get_record()
```