Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Introducción al cuaderno de ejemplo del almacén de características

El código de ejemplo de esta página hace referencia al cuaderno de ejemplo de introducción al almacén de características. Se recomienda ejecutar este bloc de notas en Studio Classic, por ejemplo, o JupyterLab porque el código de esta guía es conceptual y no es completamente funcional si se copia.

Utilice lo siguiente para clonar el amazon-sagemaker-examples GitHub repositorio aws/, que contiene el bloc de notas de ejemplo:

Ahora que tiene los cuadernos de ejemplo de SageMaker IA, navegue hasta el amazon-sagemaker-examples/sagemaker-featurestore directorio y abra el cuaderno de ejemplo Introduction to Feature Store.

Paso 1: Configura tu sesión de SageMaker IA

Para empezar a usar Feature Store, crea una sesión de SageMaker IA. A continuación, configure el bucket de Amazon Simple Storage Service (Amazon S3) que desea utilizar para sus características. El bucket de Amazon S3 es su almacenamiento sin conexión. El siguiente código usa el bucket predeterminado de SageMaker IA y le agrega un prefijo personalizado.

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

Paso 2: Inspeccionar los datos

En este ejemplo de bloc de notas, ingerimos datos sintéticos del GitHub repositorio que aloja el bloc de notas completo.

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

El siguiente diagrama ilustra los pasos que realizan los datos antes de que el Almacén de características los ingiera. En este cuaderno, ilustramos el caso de uso en el que tiene datos de varios orígenes y desea almacenarlos de forma independiente en un Almacén de características. El ejemplo considera los datos de un almacenamiento de datos (datos de clientes) y los datos de un servicio de transmisión en tiempo real (datos de pedidos).

Paso 3: Crear grupos de características

En primer lugar, cree nombres de grupo de características para customer_data y orders_data. A continuación, creamos dos grupos de características, uno para customer_data y otro para 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())

Instancie un objeto FeatureGroup para customers_data y 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"

Anexe una característica EventTime a su marco de datos. Este parámetro es obligatorio y marca la hora de cada punto de datos:

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

Cargue las definiciones de características en su grupo de características:

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

Lo siguiente llama a create para crear dos grupos de características, customers_feature_group y orders_feature_group, respectivamente:

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
)

Para confirmar que se creó su grupo de características, lo mostramos utilizando DescribeFeatureGroup y 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

Paso 4: Ingerir datos en un grupo de características

Una vez creados los grupos de características, podemos colocar datos en ellos. Si utilizas la SageMaker IA AWS SDK for Python (Boto3), utiliza la llamada a la ingest API. Si utiliza SDK para Python (Boto3), utilice la API PutRecord. Se tardará menos de un minuto en ingerir datos en estas dos opciones. En este ejemplo se utiliza el SDK de SageMaker IA para Python (Boto3), por lo que se utiliza la llamada a la 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
)

Se usa un identificador de registro de cliente arbitrario, 573291, y se usa get_record para comprobar que los datos se hayan incorporado al grupo de características.

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)

A continuación, se muestra cómo usar batch_get_record para obtener un lote de registros.

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)

Paso 5: Eliminar

Aquí eliminamos los grupos de características que hemos creado.

customers_feature_group.delete()
orders_feature_group.delete()

Paso 6: Siguientes pasos

En este cuaderno de ejemplo, aprendió a empezar a utilizar el Almacén de características, a crear grupos de características y a ingerir datos en ellos.

Para ver un ejemplo avanzado sobre cómo usar el Almacén de características para un caso práctico de detección de fraudes, consulte Fraud Detection with Feature Store.

Paso 7: ejemplos de código para programadores

En este cuaderno se utilizan una variedad de llamadas a la API diferentes. Se puede acceder a la mayoría de ellos a través del SDK de SageMaker Python, sin embargo, algunos solo existen en Boto3. Puedes invocar las llamadas a la API del SDK de SageMaker Python directamente en tus objetos de Feature Store, mientras que para invocar las llamadas a la API que existen en Boto3, primero debes acceder a un cliente de Boto3 a través de tus sesiones de Boto3 y AI: por ejemplo,. SageMaker sagemaker_session.boto_session.client()

La siguiente es una lista de llamadas a la API para este cuaderno. Estas llamadas existen dentro del SDK for Python y existen en Boto3, para su referencia:

Llamadas a la API de SDK para Python (Boto3)

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

Llamadas a la API de Boto3

list_feature_groups()
get_record()