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

L’exemple de code sur cette page fait référence à l’exemple de bloc-notes Introduction à Feature Store. 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/ contenant l'exemple de bloc-notes :

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.

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

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

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