Exemple de bloc-notes Introduction à 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 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 :

• Pour Studio Classic

  Lancez Studio Classic. Vous pouvez ouvrir Studio Classic si Studio ou Studio Classic est activé comme expérience par défaut. Pour obtenir des instructions sur l'ouverture de Studio Classic, consultezLancez 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 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 Introduction to Feature Store.

Étape 1 : Configurez votre SageMaker session

Pour commencer à utiliser Feature Store, créez une SageMaker session. Configurez ensuite le bucket Amazon Simple Storage Service (Amazon S3) que vous souhaitez utiliser pour vos fonctionnalités. Le compartiment Amazon S3 est votre magasin hors connexion. 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 : AmazonS3FullAccess et AmazonSageMakerFeatureStoreAccess. Pour plus d'informations sur l'ajout de politiques à votre IAM rôle, consultezAjouter des politiques à votre IAM rôle.

# 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 schéma suivant illustre les étapes que suivent les données avant que Feature Store ne les ingère. Dans ce bloc-notes, nous illustrons le cas d'utilisation dans lequel vous disposez de données provenant de sources multiples et souhaitez les stocker indépendamment dans un Feature Store. Notre exemple prend en compte des données provenant d'un entrepôt des 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. Ensuite, nous créons deux groupes de fonctionnalités, l'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 FeatureGroup objet 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 horodate 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 de fonctionnalités dans votre groupe de fonctionnalités :

customers_feature_group.load_feature_definitions(data_frame=customer_data)
orders_feature_group.load_feature_definitions(data_frame=orders_data)

Les appels suivants create pour créer deux groupes de fonctionnalitésorders_feature_group, customers_feature_group et 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 fonctionnalités créés, nous pouvons y insérer des données. Si vous utilisez le SageMaker AWS SDK for Python (Boto3), utilisez l'ingestAPIappel. Si vous utilisez SDK pour Python (Boto3), utilisez le. PutRecord API L'ingestion des données dans ces deux options prend moins d'une minute. Cet exemple utilise le SageMaker SDK for Python (Boto3), il utilise donc l'ingestAPIappel :

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 de dossier client arbitraire, le 573291, nous l'utilisons get_record pour vérifier que les données ont été ingérées dans le groupe de fonctionnalités.

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)

Ce qui suit montre comment utiliser le 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 fonctionnalités 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 à démarrer avec Feature Store, à créer des groupes de fonctionnalités et à y intégrer des données.

Pour un exemple avancé sur la façon d'utiliser Feature Store dans le cadre d'un cas d'utilisation de détection de fraude, voir Détection de fraude avec Feature Store.

Étape 7 : Exemples de code pour les programmeurs

Dans ce carnet, nous avons utilisé une variété d'APIappels différents. La plupart d'entre eux sont accessibles via SageMaker PythonSDK, mais certains n'existent que dans Boto3. Vous pouvez appeler les SDK API appels SageMaker Python directement sur vos objets Feature Store, alors que pour appeler des API appels qui existent dans Boto3, vous devez d'abord accéder à un client Boto3 via votre Boto3 et SageMaker vos sessions : par exemple,. sagemaker_session.boto_session.client()

Voici une liste des API appels pour ce bloc-notes. Ces appels existent dans le SDK for Python et existent dans Boto3, pour votre référence :

SDKpour les appels Python (Boto3) API

describe()
ingest()
delete()
create()
load_feature_definitions()

Appels Boto3 API

list_feature_groups()
get_record()