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, des instances de bloc-notes, ou JupyterLab parce que le code de ce guide est conceptuel et ne fonctionne pas entièrement s'il est copié.

Utilisez ce qui suit pour cloner le GitHub référentiel aws/amazon -sagemaker-examples, qui contient 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 l'exemple de bloc-notes Introduction to Feature Store.

Étape 1 : configurez votre session d' SageMaker IA

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 compartiment par défaut de l' SageMaker IA et y ajoute un préfixe personnalisé.

# SageMaker Python SDK version 3.x is required
import sagemaker
import sys

import boto3
import pandas as pd
import numpy as np
import io
from sagemaker.core.helper.session_helper import Session
from sagemaker.core.helper.session_helper import get_execution_role

prefix = 'sagemaker-featurestore-introduction'
role = get_execution_role()

sagemaker_session = 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 depuis le 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())

Dans la version V3, FeatureGroup.create() il existe une méthode de classe qui crée et renvoie directement le groupe de fonctionnalités. Aucune étape d'instanciation distincte n'est donc nécessaire.

from sagemaker.mlops.feature_store import FeatureGroup

# No separate instantiation needed in v3; FeatureGroup.create() is called directly below

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 :

from sagemaker.mlops.feature_store import load_feature_definitions_from_dataframe

customer_feature_defs = load_feature_definitions_from_dataframe(customer_data)
order_feature_defs = load_feature_definitions_from_dataframe(orders_data)

Le code suivant appelle create pour créer deux groupes de caractéristiques, customers_feature_group et orders_feature_group, respectivement :

from sagemaker.mlops.feature_store import OnlineStoreConfig, OfflineStoreConfig, S3StorageConfig

FeatureGroup.create(
    feature_group_name=customers_feature_group_name,
    feature_definitions=customer_feature_defs,
    record_identifier_feature_name=record_identifier_feature_name,
    event_time_feature_name="EventTime",
    role_arn=role,
    online_store_config=OnlineStoreConfig(enable_online_store=True),
    offline_store_config=OfflineStoreConfig(
        s3_storage_config=S3StorageConfig(s3_uri=f"s3://{s3_bucket_name}/{prefix}")
    ),
)

FeatureGroup.create(
    feature_group_name=orders_feature_group_name,
    feature_definitions=order_feature_defs,
    record_identifier_feature_name=record_identifier_feature_name,
    event_time_feature_name="EventTime",
    role_arn=role,
    online_store_config=OnlineStoreConfig(enable_online_store=True),
    offline_store_config=OfflineStoreConfig(
        s3_storage_config=S3StorageConfig(s3_uri=f"s3://{s3_bucket_name}/{prefix}")
    ),
)

Pour confirmer que votre groupe de caractéristiques a été créé, nous l’affichons à l’aide des API DescribeFeatureGroup et ListFeatureGroups :

customers_fg = FeatureGroup.get(feature_group_name=customers_feature_group_name)

orders_fg = FeatureGroup.get(feature_group_name=orders_feature_group_name)

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 for 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'ingestappel d'API :

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)

from sagemaker.mlops.feature_store import ingest_dataframe

ingest_dataframe(
    feature_group_name=customers_feature_group_name, data_frame=customer_data, max_workers=3, wait=True
)

ingest_dataframe(
    feature_group_name=orders_feature_group_name, 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.

FeatureGroup(feature_group_name=customers_feature_group_name).delete()
FeatureGroup(feature_group_name=orders_feature_group_name).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 invoquer les appels d'API du SDK SageMaker Python directement sur les objets de votre Feature Store, tandis que pour invoquer des appels d'API existants dans Boto3, vous devez d'abord accéder à un client Boto3 via vos sessions Boto3 et AI : par exemple,. SageMaker 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()