Desbloquea información sobre aprendizaje automático utilizando el Procesador de Funciones del Almacén de Características de Amazon SageMaker

Desbloquea información sobre aprendizaje automático con Amazon SageMaker Feature Store

Amazon SageMaker Feature Store proporciona una solución integral para automatizar la ingeniería de características para el aprendizaje automático (ML, por sus siglas en inglés). Para muchos casos de uso de ML, los datos en bruto como archivos de registro, lecturas de sensores o registros de transacciones deben transformarse en características significativas que estén optimizadas para el entrenamiento del modelo.

La calidad de las características es fundamental para garantizar un modelo de ML altamente preciso. A menudo es necesario transformar los datos en bruto en características mediante la agregación, codificación, normalización y otras operaciones, lo que puede requerir un esfuerzo significativo. Los ingenieros deben escribir manualmente lógica personalizada de preprocesamiento y agregación de datos en Python o Spark para cada caso de uso.

Esta labor pesada no diferenciada es engorrosa, repetitiva y propensa a errores. El Procesador de Características de SageMaker Feature Store reduce esta carga al transformar automáticamente los datos en bruto en características agregadas adecuadas para el entrenamiento por lotes de modelos de ML. Permite a los ingenieros proporcionar funciones simples de transformación de datos y luego se encarga de ejecutarlas a escala en Spark y de gestionar la infraestructura subyacente. Esto permite a los científicos de datos y a los ingenieros de datos centrarse en la lógica de la ingeniería de características en lugar de en los detalles de implementación.

En esta publicación, demostramos cómo una empresa de ventas de automóviles puede utilizar el Procesador de Características para transformar los datos brutos de transacciones de ventas en características en tres pasos:

  1. Ejecuciones locales de transformaciones de datos.
  2. Ejecuciones remotas a escala utilizando Spark.
  3. Operacionalización a través de canalizaciones.

Mostramos cómo SageMaker Feature Store ingiere los datos en bruto, ejecuta las transformaciones de características de forma remota utilizando Spark y carga las características agregadas resultantes en un grupo de características. Estas características ingenierizadas luego se pueden utilizar para entrenar modelos de ML.

Para este caso de uso, vemos cómo SageMaker Feature Store ayuda a convertir los datos brutos de ventas de automóviles en características estructuradas. Estas características se utilizan posteriormente para obtener conocimientos como:

  • Precio promedio y máximo de convertibles rojos a partir de 2010
  • Modelos con mejor rendimiento de combustible frente al precio
  • Tendencias de ventas de automóviles nuevos frente a usados a lo largo de los años
  • Diferencias en el precio promedio de venta al público recomendado por el fabricante (MSRP) en diferentes ubicaciones

También vemos cómo las canalizaciones de SageMaker Feature Store mantienen actualizadas las características a medida que llegan nuevos datos, lo que permite a la empresa obtener continuamente conocimientos a lo largo del tiempo.

Descripción general de la solución

Trabajamos con el conjunto de datos car_data.csv, que contiene especificaciones como modelo, año, estado, kilometraje, precio y MSRP (precio de venta al público recomendado por el fabricante) de automóviles nuevos y usados vendidos por la empresa. La siguiente captura de pantalla muestra un ejemplo del conjunto de datos.

El cuaderno de solución feature_processor.ipynb contiene los siguientes pasos principales, que explicamos en esta publicación:

  1. Crear dos grupos de características: uno llamado car-data para los registros de ventas de automóviles en bruto y otro llamado car-data-aggregated para los registros de ventas de automóviles agregados.
  2. Utilizar el decorador @feature_processor para cargar datos en el grupo de características car-data desde Amazon Simple Storage Service (Amazon S3).
  3. Ejecutar el código @feature_processor de forma remota como una aplicación de Spark para agregar los datos.
  4. Operacionalizar el procesador de características a través de canalizaciones de SageMaker y programar ejecuciones.
  5. Explorar las canalizaciones de procesamiento de características y la línea de linaje en Amazon SageMaker Studio.
  6. Utilizar características agregadas para entrenar un modelo de ML.

Prerrequisitos

Para seguir este tutorial, necesitas lo siguiente:

  • Una cuenta de AWS.
  • Tener configurado SageMaker Studio.
  • Permisos de AWS Identity and Access Management (IAM). Al crear este rol de IAM, sigue la mejor práctica de otorgar acceso con los privilegios mínimos necesarios.

Para esta publicación, nos referimos al siguiente cuaderno, que muestra cómo empezar a utilizar el Procesador de Características utilizando el SDK de Python de SageMaker.

Crear grupos de características

Para crear los grupos de características, sigue estos pasos:

  1. Crea una definición de grupo de características para car-data de la siguiente manera:

    # Grupo de características - Ventas de automóviles
CAR_SALES_FG_NAME = "car-data"
CAR_SALES_FG_ARN = f"arn:aws:sagemaker:{region}:{aws_account_id}:feature-group/{CAR_SALES_FG_NAME}"
CAR_SALES_FG_ROLE_ARN = offline_store_role
CAR_SALES_FG_OFFLINE_STORE_S3_URI = f"s3://{s3_bucket}/{s3_offline_store_prefix}"
CAR_SALES_FG_FEATURE_DEFINITIONS = [
    FeatureDefinition(feature_name="id", feature_type=FeatureTypeEnum.STRING),
    FeatureDefinition(feature_name="model", feature_type=FeatureTypeEnum.STRING),
    FeatureDefinition(feature_name="model_year", feature_type=FeatureTypeEnum.STRING),
    FeatureDefinition(feature_name="status", feature_type=FeatureTypeEnum.STRING),
    FeatureDefinition(feature_name="mileage", feature_type=FeatureTypeEnum.STRING),
    FeatureDefinition(feature_name="price", feature_type=FeatureTypeEnum.STRING),
    FeatureDefinition(feature_name="msrp", feature_type=FeatureTypeEnum.STRING),
    FeatureDefinition(feature_name="ingest_time", feature_type=FeatureTypeEnum.FRACTIONAL),
]

Las características corresponden a cada columna en el conjunto de datos car_data.csv (Modelo, Año, Estado, Kilometraje, Precio y MSRP).

  1. Agrega el identificador del registro id y el tiempo del evento ingest_time al grupo de características:
CAR_SALES_FG_RECORD_IDENTIFIER_NAME = "id"
CAR_SALES_FG_EVENT_TIME_FEATURE_NAME = "ingest_time"
  1. Crea una definición de grupo de características para car-data-aggregated de la siguiente manera:
# Grupo de Características - Ventas de Autos AgregadasAGG_CAR_SALES_FG_NAME = "car-data-aggregated"
AGG_CAR_SALES_FG_ARN = (
    f"arn:aws:sagemaker:{region}:{aws_account_id}:feature-group/{AGG_CAR_SALES_FG_NAME}"
)
AGG_CAR_SALES_FG_ROLE_ARN = offline_store_role
AGG_CAR_SALES_FG_OFFLINE_STORE_S3_URI = f"s3://{s3_bucket}/{s3_offline_store_prefix}"
AGG_CAR_SALES_FG_FEATURE_DEFINITIONS = [
    FeatureDefinition(feature_name="modelo_año_estado", feature_type=FeatureTypeEnum.STRING),
    FeatureDefinition(feature_name="promedio_kilometraje", feature_type=FeatureTypeEnum.STRING),
    FeatureDefinition(feature_name="max_kilometraje", feature_type=FeatureTypeEnum.STRING),
    FeatureDefinition(feature_name="promedio_precio", feature_type=FeatureTypeEnum.STRING),
    FeatureDefinition(feature_name="max_precio", feature_type=FeatureTypeEnum.STRING),
    FeatureDefinition(feature_name="promedio_msrp", feature_type=FeatureTypeEnum.STRING),
    FeatureDefinition(feature_name="max_msrp", feature_type=FeatureTypeEnum.STRING),
    FeatureDefinition(feature_name="ingest_time", feature_type=FeatureTypeEnum.FRACTIONAL),
]

Para el grupo de características agregadas, las características son estado del año del modelo, kilometraje promedio, kilometraje máximo, precio promedio, precio máximo, MSRP promedio, MSRP máximo y tiempo de ingestión. Agregamos el identificador del registro modelo_año_estado y el tiempo del evento ingest_time a este grupo de características.

  1. Ahora, crea el grupo de características car-data:
# Crea el Grupo de Características - Registros de venta de autos.
car_sales_fg = FeatureGroup(
    name=CAR_SALES_FG_NAME,
    feature_definitions=CAR_SALES_FG_FEATURE_DEFINITIONS,
    sagemaker_session=sagemaker_session,
)

create_car_sales_fg_resp = car_sales_fg.create(
        record_identifier_name=CAR_SALES_FG_RECORD_IDENTIFIER_NAME,
        event_time_feature_name=CAR_SALES_FG_EVENT_TIME_FEATURE_NAME,
        s3_uri=CAR_SALES_FG_OFFLINE_STORE_S3_URI,
        enable_online_store=True,
        role_arn=CAR_SALES_FG_ROLE_ARN,
    )
  1. Crea el grupo de características car-data-aggregated:
# Crea el Grupo de Características - Registros de ventas de autos agregados.
agg_car_sales_fg = FeatureGroup(
    name=AGG_CAR_SALES_FG_NAME,
    feature_definitions=AGG_CAR_SALES_FG_FEATURE_DEFINITIONS,
    sagemaker_session=sagemaker_session,
)

create_agg_car_sales_fg_resp = agg_car_sales_fg.create(
      record_identifier_name=AGG_CAR_SALES_FG_RECORD_IDENTIFIER_NAME,  
        event_time_feature_name=AGG_CAR_SALES_FG_EVENT_TIME_FEATURE_NAME,
        s3_uri=AGG_CAR_SALES_FG_OFFLINE_STORE_S3_URI,
        enable_online_store=True,
        role_arn=AGG_CAR_SALES_FG_ROLE_ARN,
    )

Puedes navegar a la opción de Almacenamiento de Características de SageMaker en Datos en el menú principal de SageMaker Studio para ver los grupos de características.

Usa el decorador @feature_processor para cargar datos

En esta sección, transformamos localmente los datos de entrada en bruto (car_data.csv) desde Amazon S3 en el grupo de características car-data usando el Procesador de Características del Almacenamiento de Características. Esta ejecución local inicial nos permite desarrollar e iterar antes de ejecutar de forma remota, y se puede realizar en una muestra de los datos si se desea una iteración más rápida.

Con el decorador @feature_processor, tu función de transformación se ejecuta en un entorno de ejecución Spark donde los argumentos de entrada proporcionados a tu función y el valor de retorno son DataFrames de Spark.

  1. Instala el SDK del Procesador de Características desde el SDK de Python de SageMaker y sus extras usando el siguiente comando:
pip install sagemaker[feature-processor]

El número de parámetros de entrada en tu función de transformación debe coincidir con el número de entradas configuradas en el decorador @feature_processor. En este caso, el decorador @feature_processor tiene car-data.csv como entrada y el grupo de características car-data como salida, lo que indica que esta es una operación por lotes con el target_store como OfflineStore:

from sagemaker.feature_store.feature_processor import (
    feature_processor,
    FeatureGroupDataSource,
    CSVDataSource,
)

@feature_processor(
    inputs=[CSVDataSource(RAW_CAR_SALES_S3_URI)],
    output=CAR_SALES_FG_ARN,
    target_stores=["OfflineStore"],
)
  1. Define la función transform() para transformar los datos. Esta función realiza las siguientes acciones:
    • Convierte los nombres de las columnas en minúsculas.
    • Agrega el tiempo del evento a la columna ingest_time.
    • Elimina la puntuación y reemplaza los valores faltantes con NA.
def transform(raw_s3_data_as_df):
    """Carga los datos desde S3, realiza ingeniería de características básica y los almacena en un Grupo de Características"""
    from pyspark.sql.functions import regexp_replace
    from pyspark.sql.functions import lit
    import time

    transformed_df = (
        raw_s3_data_as_df.withColumn("Price", regexp_replace("Price", "\$", ""))
        # Renombrar Columnas
        .withColumnRenamed("Id", "id")
        .withColumnRenamed("Model", "model")
        .withColumnRenamed("Year", "model_year")
        .withColumnRenamed("Status", "status")
        .withColumnRenamed("Mileage", "mileage")
        .withColumnRenamed("Price", "price")
        .withColumnRenamed("MSRP", "msrp")
        # Agregar tiempo del evento
        .withColumn("ingest_time", lit(int(time.time())))
        # Eliminar puntuación y datos irrelevantes; reemplazar con NA
        .withColumn("mileage", regexp_replace("mileage", "(,)|(mi\.)", ""))
        .withColumn("mileage", regexp_replace("mileage", "Not available", "NA"))
        .withColumn("price", regexp_replace("price", ",", ""))
        .withColumn("msrp", regexp_replace("msrp", "(^MSRP\s\\$)|(,)", ""))
        .withColumn("msrp", regexp_replace("msrp", "Not specified", "NA"))
        .withColumn("msrp", regexp_replace("msrp", "\\$\d+[a-zA-Z\s]+", "NA"))
        .withColumn("model", regexp_replace("model", "^\d\d\d\d\s", ""))
    )
  1. Llama a la función transform() para almacenar los datos en el grupo de características car-data:
# Ejecuta el Procesador de Características
transform()

La salida muestra que los datos se ingieren correctamente en el grupo de características car-data.

La salida de la función transform_df.show() es la siguiente:

INFO:sagemaker:Ingesting transformed data to arn:aws:sagemaker:us-west-2:416578662734:feature-group/car-data with target_stores: ['OfflineStore']

+---+--------------------+----------+------+-------+--------+-----+-----------+
| id|               model|model_year|status|mileage|   price| msrp|ingest_time|
+---+--------------------+----------+------+-------+--------+-----+-----------+
|  0|    Acura TLX A-Spec|      2022|   New|     NA|49445.00|49445| 1686627154|
|  1|    Acura RDX A-Spec|      2023|   New|     NA|50895.00|   NA| 1686627154|
|  2|    Acura TLX Type S|      2023|   New|     NA|57745.00|   NA| 1686627154|
|  3|    Acura TLX Type S|      2023|   New|     NA|57545.00|   NA| 1686627154|
|  4|Acura MDX Sport H...|      2019|  Used| 32675 |40990.00|   NA| 1686627154|
|  5|    Acura TLX A-Spec|      2023|   New|     NA|50195.00|50195| 1686627154|
|  6|    Acura TLX A-Spec|      2023|   New|     NA|50195.00|50195| 1686627154|
|  7|    Acura TLX Type S|      2023|   New|     NA|57745.00|   NA| 1686627154|
|  8|    Acura TLX A-Spec|      2023|   New|     NA|47995.00|   NA| 1686627154|
|  9|    Acura TLX A-Spec|      2022|   New|     NA|49545.00|   NA| 1686627154|
| 10|Acura Integra w/A...|      2023|   New|     NA|36895.00|36895| 1686627154|
| 11|    Acura TLX A-Spec|      2023|   New|     NA|48395.00|48395| 1686627154|
| 12|Acura MDX Type S ...|      2023|   New|     NA|75590.00|   NA| 1686627154|
| 13|Acura RDX A-Spec ...|      2023|   New|     NA|55345.00|   NA| 1686627154|
| 14|    Acura TLX A-Spec|      2023|   New|     NA|50195.00|50195| 1686627154|
| 15|Acura RDX A-Spec ...|      2023|   New|     NA|55045.00|   NA| 1686627154|
| 16|    Acura TLX Type S|      2023|   New|     NA|56445.00|   NA| 1686627154|
| 17|    Acura TLX A-Spec|      2023|   New|     NA|47495.00|47495| 1686627154|
| 18|   Acura TLX Advance|      2023|   New|     NA|52245.00|52245| 1686627154|
| 19|    Acura TLX A-Spec|      2023|   New|     NA|50595.00|50595| 1686627154|
+---+--------------------+----------+------+-------+--------+-----+-----------+
solo se muestran los primeros 20 registros

Hemos transformado con éxito los datos de entrada y los hemos ingestado en el grupo de características car-data.

Ejecutar el código @feature_processor de forma remota

En esta sección, demostraremos cómo ejecutar el código de procesamiento de características de forma remota como una aplicación Spark utilizando el decorador @remote descrito anteriormente. Ejecutamos el procesamiento de características de forma remota utilizando Spark para escalar a conjuntos de datos grandes. Spark proporciona procesamiento distribuido en clústeres para manejar datos que son demasiado grandes para una sola máquina. El decorador @remote ejecuta el código Python local como un trabajo de entrenamiento de SageMaker de un solo nodo o de varios nodos.

  1. Utilice el decorador @remote junto con el decorador @feature_processor de la siguiente manera:
@remote(spark_config=SparkConfig(), instance_type = "ml.m5.xlarge", ...)
@feature_processor(inputs=[FeatureGroupDataSource(CAR_SALES_FG_ARN)],
                   output=AGG_CAR_SALES_FG_ARN, target_stores=["OfflineStore"], enable_ingestion=False )

El parámetro spark_config indica que se ejecuta como una aplicación Spark. La instancia de SparkConfig configura la configuración y las dependencias de Spark.

  1. Defina la función aggregate() para agregar los datos utilizando PySpark SQL y funciones definidas por el usuario (UDFs). Esta función realiza las siguientes acciones:
    • Concatenar model, year y status para crear model_year_status.
    • Tomar el promedio de price para crear avg_price.
    • Tomar el valor máximo de price para crear max_price.
    • Tomar el promedio de mileage para crear avg_mileage.
    • Tomar el valor máximo de mileage para crear max_mileage.
    • Tomar el promedio de msrp para crear avg_msrp.
    • Tomar el valor máximo de msrp para crear max_msrp.
    • Agrupar por model_year_status.
def aggregate(source_feature_group, spark):
    """
    Agrega los datos utilizando una consulta SQL y UDF.
    """
    import time
    from pyspark.sql.types import StringType
    from pyspark.sql.functions import udf

    @udf(returnType=StringType())
    def custom_concat(*cols, delimeter: str = ""):
        return delimeter.join(cols)

    spark.udf.register("custom_concat", custom_concat)

    # Ejecuta la cadena SQL.
    source_feature_group.createOrReplaceTempView("car_data")
    aggregated_car_data = spark.sql(
        f"""
        SELECT
            custom_concat(model, "_", model_year, "_", status) as model_year_status,
            AVG(price) as avg_price,
            MAX(price) as max_price,
            AVG(mileage) as avg_mileage,
            MAX(mileage) as max_mileage,
            AVG(msrp) as avg_msrp,
            MAX(msrp) as max_msrp,
            "{int(time.time())}" as ingest_time
        FROM car_data
        GROUP BY model_year_status
        """
    )

    aggregated_car_data.show()

    return aggregated_car_data
  1. Ejecute la función aggregate(), que crea un trabajo de entrenamiento de SageMaker para ejecutar la aplicación Spark:
# Ejecuta la función aggregate
aggregate()

Como resultado, SageMaker crea un trabajo de entrenamiento para la aplicación Spark definida anteriormente. Creará un entorno de ejecución de Spark utilizando la imagen sagemaker-spark-processing.

Utilizamos trabajos de entrenamiento de SageMaker aquí para ejecutar nuestra aplicación de procesamiento de características de Spark. Con SageMaker Training, puede reducir los tiempos de inicio a 1 minuto o menos utilizando el agrupamiento en caliente, que no está disponible en SageMaker Processing. Esto hace que SageMaker Training esté mejor optimizado para trabajos por lotes cortos como el procesamiento de características donde el tiempo de inicio es importante.

  1. Para ver los detalles, en la consola de SageMaker, elija Trabajos de entrenamiento en Entrenamiento en el panel de navegación, luego elija el trabajo con el nombre aggregate-<timestamp>.

La salida de la función aggregate() genera código de telemetría. Dentro de la salida, verá los datos agregados de la siguiente manera:

+--------------------+------------------+---------+------------------+-----------+--------+--------+-----------+
|   model_year_status|         avg_price|max_price|       avg_mileage|max_mileage|avg_msrp|max_msrp|ingest_time|
+--------------------+------------------+---------+------------------+-----------+--------+--------+-----------+
|Acura CL 3.0_1997...|            7950.0|  7950.00|          100934.0|    100934 |    null|      NA| 1686634807|
|Acura CL 3.2 Type...|            6795.0|  7591.00|          118692.5|    135760 |    null|      NA| 1686634807|
|Acura CL 3_1998_Used|            9899.0|  9899.00|           63000.0|     63000 |    null|      NA| 1686634807|
|Acura ILX 2.0L Te...|         14014.125| 18995.00|         95534.875|     89103 |    null|      NA| 1686634807|
|Acura ILX 2.0L Te...|           15008.2| 16998.00|           94935.0|     88449 |    null|      NA| 1686634807|
|Acura ILX 2.0L Te...|           16394.6| 19985.00|           97719.4|     80000 |    null|      NA| 1686634807|
|Acura ILX 2.0L w/...|14567.181818181818| 16999.00| 96624.72727272728|     98919 |    null|      NA| 1686634807|
|Acura ILX 2.0L w/...|           16673.4| 18995.00|           84848.6|     96637 |    null|      NA| 1686634807|
|Acura ILX 2.0L w/...|12580.333333333334| 14546.00|100207.33333333333|     95782 |    null|      NA| 1686634807|
|Acura ILX 2.0L_20...|         14565.375| 17590.00|         92941.125|     81842 |    null|      NA| 1686634807|
|Acura ILX 2.0L_20...|           14877.9|  9995.00|           99739.5|     89252 |    null|      NA| 1686634807|
|Acura ILX 2.0L_20...|           15659.5| 15660.00|           82136.0|     89942 |    null|      NA| 1686634807|
|Acura ILX 2.0L_20...|17121.785714285714| 20990.00| 78278.14285714286|     96067 |    null|      NA| 1686634807|
|Acura ILX 2.4L (A...|           17846.0| 21995.00|          101558.0|     85974 |    null|      NA| 1686634807|
|Acura ILX 2.4L Pr...|           16327.0| 16995.00|           85238.0|     95356 |    null|      NA| 1686634807|
|Acura ILX 2.4L w/...|           12846.0| 12846.00|           75209.0|     75209 |    null|      NA| 1686634807|
|Acura ILX 2.4L_20...|           18998.0| 18998.00|           51002.0|     51002 |    null|      NA| 1686634807|
|Acura ILX 2.4L_20...|17908.615384615383| 19316.00| 74325.38461538461|     89116 |    null|      NA| 1686634807|
|Acura ILX 4DR SDN...|           18995.0| 18995.00|           37017.0|     37017 |    null|      NA| 1686634807|
|Acura ILX 8-SPD_2...|           24995.0| 24995.00|           22334.0|     22334 |    null|      NA| 1686634807|
+--------------------+------------------+---------+------------------+-----------+--------+--------+-----------+
solo se muestran las primeras 20 filas

Cuando el trabajo de entrenamiento esté completo, deberías ver la siguiente salida:

06-13 05:40 smspark-submit INFO     La presentación de Spark fue exitosa. El nodo principal está saliendo.
Segundos de entrenamiento: 153
Segundos facturables: 153

Operacionalizar el procesador de características mediante SageMaker pipelines

En esta sección, demostraremos cómo operacionalizar el procesador de características promoviéndolo a una pipeline de SageMaker y programando ejecuciones.

  1. Primero, carga el archivo transformation_code.py que contiene la lógica de procesamiento de características en Amazon S3:
car_data_s3_uri = s3_path_join("s3://", sagemaker_session.default_bucket(),
                               'transformation_code', 'car-data-ingestion.py')
S3Uploader.upload(local_path='car-data-ingestion.py', desired_s3_uri=car_data_s3_uri)
print(car_data_s3_uri)
  1. A continuación, crea una pipeline de Procesador de Características llamada car_data_pipeline utilizando la función .to_pipeline():
car_data_pipeline_name = f"{CAR_SALES_FG_NAME}-ingestion-pipeline"
car_data_pipeline_arn = fp.to_pipeline(pipeline_name=car_data_pipeline_name,
                                      step=transform,
                                      transformation_code=TransformationCode(s3_uri=car_data_s3_uri) )
print(f"Se ha creado la Pipeline de SageMaker: {car_data_pipeline_arn}.")
  1. Para ejecutar la pipeline, utiliza el siguiente código:
car_data_pipeline_execution_arn = fp.execute(pipeline_name=car_data_pipeline_name)
print(f"Se ha iniciado una ejecución con el arn de ejecución: {car_data_pipeline_execution_arn}")
  1. De manera similar, puedes crear una pipeline para características agregadas llamada car_data_aggregated_pipeline y comenzar una ejecución.
  2. Programa la ejecución de car_data_aggregated_pipeline cada 24 horas:
fp.schedule(pipeline_name=car_data_aggregated_pipeline_name,
           schedule_expression="rate(24 hours)", state="ENABLED")
print(f"Se ha creado una programación.")

En la sección de salida, verás el ARN de la pipeline y el rol de ejecución de la pipeline, así como los detalles de la programación:

{'pipeline_arn': 'arn:aws:sagemaker:us-west-2:416578662734:pipeline/car-data-aggregated-ingestion-pipeline',
 'pipeline_execution_role_arn': 'arn:aws:iam::416578662734:role/service-role/AmazonSageMaker-ExecutionRole-20230612T120731',
 'schedule_arn': 'arn:aws:scheduler:us-west-2:416578662734:schedule/default/car-data-aggregated-ingestion-pipeline',
 'schedule_expression': 'rate(24 hours)',
 'schedule_state': 'ENABLED',
 'schedule_start_date': '2023-06-13T06:05:17Z',
 'schedule_role': 'arn:aws:iam::416578662734:role/service-role/AmazonSageMaker-ExecutionRole-20230612T120731'}
  1. Para obtener todas las pipelines de Procesador de Características en esta cuenta, utiliza la función list_pipelines() del Procesador de Características:
fp.list_pipelines()

La salida será la siguiente:

[{'pipeline_name': 'car-data-aggregated-ingestion-pipeline'},
 {'pipeline_name': 'car-data-ingestion-pipeline'}]

Hemos creado exitosamente pipelines de Procesador de Características de SageMaker.

Explora las pipelines de procesamiento de características y la línea de tiempo de ML

En SageMaker Studio, realiza los siguientes pasos:

  1. En la consola de SageMaker Studio, en el menú Inicio, elige Pipelines.

Deberías ver dos pipelines creadas: car-data-ingestion-pipeline y car-data-aggregated-ingestion-pipeline.

  1. Elige la car-data-ingestion-pipeline.

Muestra los detalles de ejecución en la pestaña Ejecuciones.

  1. Para ver el grupo de características poblado por la pipeline, elige Almacén de características bajo Datos y elige car-data.

Verás los dos grupos de características que creamos en los pasos anteriores.

  1. Elige el grupo de características car-data.

Verás los detalles de las características en la pestaña Características.

Ver ejecuciones de la pipeline

Para ver las ejecuciones de la pipeline, completa los siguientes pasos:

  1. En la pestaña Ejecuciones de la pipeline, selecciona car-data-ingestion-pipeline.

Esto mostrará todas las ejecuciones.

  1. Elige uno de los enlaces para ver los detalles de la ejecución.

  1. Para ver la línea de tiempo, elige Línea de tiempo.

La línea de tiempo completa para car-data muestra la fuente de datos de entrada car_data.csv y las entidades ascendentes. La línea de tiempo para car-data-aggregated muestra el grupo de características de entrada car-data.

  1. Elige Cargar características y luego elige Consultar línea de tiempo ascendente en car-data y car-data-ingestion-pipeline para ver todas las entidades ascendentes.

La línea completa para el grupo de características car-data debería verse como en la siguiente captura de pantalla.

De manera similar, la línea para el grupo de características car-aggregated-data debería verse como en la siguiente captura de pantalla.

SageMaker Studio proporciona un único entorno para realizar un seguimiento de los pipelines programados, ver ejecuciones, explorar la línea de ancestros y ver el código de procesamiento de características.

Las características agregadas, como el precio promedio, el precio máximo, el kilometraje promedio y más en el grupo de características car-data-aggregated, proporcionan información sobre la naturaleza de los datos. También puedes utilizar estas características como conjunto de datos para entrenar un modelo que prediga los precios de los automóviles, u otras operaciones. Sin embargo, el entrenamiento del modelo está fuera del alcance de esta publicación, que se centra en demostrar las capacidades de SageMaker Feature Store para la ingeniería de características.

Limpieza

No olvides limpiar los recursos creados como parte de esta publicación para evitar incurrir en cargos continuos.

  1. Deshabilita el pipeline programado mediante el método fp.schedule() con el parámetro de estado como Disabled:
# Deshabilita el pipeline programado
fp.schedule(
pipeline_name=car_data_aggregated_pipeline_name,
schedule_expression="rate(24 hours)",
state="DISABLED",
)
  1. Elimina ambos grupos de características:
# Elimina los grupos de características
car_sales_fg.delete()
agg_car_sales_fg.delete()

Los datos almacenados en el bucket de S3 y en el almacenamiento de características sin conexión pueden generar costos, por lo que debes eliminarlos para evitar cualquier cargo.

  1. Elimina los objetos de S3.
  2. Elimina los registros del almacenamiento de características.

Conclusión

En esta publicación, demostramos cómo una empresa de ventas de automóviles utilizó SageMaker Feature Store Feature Processor para obtener información valiosa de sus datos de ventas sin procesar mediante:

  • Ingesta y transformación de datos por lotes a gran escala utilizando Spark
  • Operacionalización de flujos de trabajo de ingeniería de características a través de pipelines de SageMaker
  • Seguimiento de la línea de ancestros y un entorno único para monitorear pipelines y explorar características
  • Preparación de características agregadas optimizadas para el entrenamiento de modelos de ML

Siguiendo estos pasos, la empresa pudo transformar datos previamente inutilizables en características estructuradas que luego se pudieron utilizar para entrenar un modelo que predijera los precios de los automóviles. SageMaker Feature Store les permitió centrarse en la ingeniería de características en lugar de la infraestructura subyacente.

¡Esperamos que esta publicación te ayude a obtener información valiosa de ML a partir de tus propios datos utilizando SageMaker Feature Store Feature Processor!

Para obtener más información al respecto, consulta el Procesamiento de características y el ejemplo de SageMaker en Amazon SageMaker Feature Store: Introducción al Feature Processor.

Estudio descifra el sorprendente enfoque qu...
15 Formas de Utilizar ChatGPT para Marketing
Comprendiendo la Afinación Fina de LLM Adap...
3 Formas en las que la IA puede ayudar a lo...
¡No te lo pierdas! Inscríbete en cursos GRA...
Mitigación de sesgos en la IA generativa
IA

IA

Explora el mundo de la Inteligencia Artificial y su potencial transformador