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.

AWS politiques gérées pour Amazon SageMaker AIqui 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 console Amazon SageMaker AI.

  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 compte Amazon SageMaker AI.

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 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 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 plus d'informations sur l'ajout de politiques à votre rôle IAM, consultezAjout de politiques à votre rôle IAM.

# 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és, customers_feature_group etorders_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 fonctionnalités créés, nous pouvons y insérer des données. Si vous utilisez l' SageMaker IA AWS SDK for Python (Boto3), utilisez l'appel ingest d'API. Si vous utilisez le 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 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 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 au sein du SDK for Python et existent dans Boto3, pour votre référence :

SDK pour les appels d'API au SDK (Boto3)

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

Appels d'API Boto3

list_feature_groups()
get_record()