Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Introduzione al notebook di esempio Feature Store

Il codice esemplificativo in questa pagina si riferisce al notebook di esempio Introduzione al Feature Store. Si consiglia di eseguire questo notebook in Studio Classic, nelle istanze di notebook o JupyterLab perché il codice contenuto in questa guida è concettuale e non completamente funzionale se copiato.

Usa quanto segue per clonare il amazon-sagemaker-examples GitHub repository aws/, contenente il notebook di esempio:

Ora che hai i notebook di esempio SageMaker AI, vai alla amazon-sagemaker-examples/sagemaker-featurestore directory e apri il notebook di esempio Introduction to Feature Store.

Passaggio 1: configura la tua sessione di intelligenza artificiale SageMaker

Per iniziare a utilizzare Feature Store, crea una sessione SageMaker AI. Quindi, configura il bucket Amazon Simple Storage Service (Amazon S3) da utilizzare per le funzionalità. Il bucket Amazon S3 è rappresentato dall’archivio offline. Il codice seguente utilizza il bucket SageMaker AI predefinito e vi aggiunge un prefisso personalizzato.

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

Fase 2: verifica dei dati

In questo esempio di notebook, inseriamo dati sintetici dal GitHub repository che ospita l'intero notebook.

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

Il diagramma seguente illustra le fasi eseguite sui dati prima di poterli inserire nell’archivio delle caratteristiche. Nel caso d’uso descritto in questo notebook, disponi di dati provenienti da più origini che vuoi archiviare in modo indipendente in un archivio delle caratteristiche. L’esempio considera i dati di un data warehouse (dati dei clienti) e i dati di un servizio di streaming in tempo reale (dati degli ordini).

Fase 3: creazione di gruppi di funzionalità

Per iniziare, vengono creati i nomi dei gruppi di funzionalità per customer_data e orders_data. Successivamente, crea due gruppi di funzionalità, uno per customer_data e l’altro per 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())

Crea un’istanza di un oggetto FeatureGroup per customers_data e 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"

Aggiungi funzionalità EventTime al data frame. Questo parametro è obbligatorio e inserisce un timestamp di ogni punto dati:

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")

Carica le definizioni delle funzionalità nel tuo gruppo di funzionalità:

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

Il codice seguente chiama create per creare due gruppi di funzionalità, rispettivamente customers_feature_group e orders_feature_group:

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
)

Per confermare che il tuo gruppo di funzionalità è stato creato, lo visualizziamo utilizzando DescribeFeatureGroup e: 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

Fase 4: inserimento di dati in un gruppo di funzionalità

Dopo aver creato i gruppi di funzionalità, puoi inserirvi dati. Se utilizzi l' SageMaker intelligenza artificialeAWS SDK per Python (Boto3), usa la chiamata ingest API. Se stai utilizzando SDK per Python (Boto3), utilizza l’API PutRecord. Occorre meno di 1 minuto per inserire i dati in entrambe le opzioni. Questo esempio utilizza l' SageMaker AI SDK for Python (Boto3), quindi utilizza la chiamata 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
)

Con un ID record cliente arbitrario, 573291, si usa get_record per verificare che i dati siano stati inseriti nel gruppo di funzionalità.

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)

Di seguito viene illustrato come utilizzare batch_get_record per ottenere un batch di record.

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)

Fase 5: rimozione

In questa fase, vengono rimossi i gruppi di funzionalità creati.

customers_feature_group.delete()
orders_feature_group.delete()

Fase 6: fasi successive

In questo notebook di esempio, hai appreso come iniziare a utilizzare l’archivio delle caratteristiche, creare gruppi di funzionalità e inserirvi dati.

Per un esempio avanzato su come utilizzare Feature Store per un caso d’uso relativo al rilevamento delle frodi, consulta la pagina che spiega come rilevare le frodi con Feature Store.

Fase 7. Esempi di codice per programmatori

In questo notebook è stata utilizzata un’ampia varietà di chiamate API. La maggior parte di essi è accessibile tramite SageMaker Python SDK, tuttavia alcuni esistono solo all'interno di Boto3. Puoi richiamare le chiamate API SageMaker Python SDK direttamente sugli oggetti del Feature Store, mentre per richiamare le chiamate API esistenti all'interno di Boto3, devi prima accedere a un client Boto3 tramite le tue sessioni Boto3 e AI: ad esempio,. SageMaker sagemaker_session.boto_session.client()

Di seguito è riportato un elenco di chiamate API per questo notebook. Queste chiamate sono disponibili all’interno dell’SDK for Python e in Boto3:

Chiamate API per l’SDK per Python (Boto3)

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

Chiamate API boto3

list_feature_groups()
get_record()