Integración de dependencias personalizadas en Amazon Sagemaker Canvas Flows de trabajo

Al implementar formación automotriz (Ml) flujos de trabajo en Canvas de Amazon Sagemakerlas organizaciones pueden carecer considerar dependencias externas necesarias para sus casos de uso específicos. Aunque el muralla de Sagemaker proporciona potentes capacidades sin código y código bajo para la experimentación rápida, algunos proyectos pueden requerir dependencias y bibliotecas especializadas que no están incluidas por defecto en el muralla de SageMaker. Esta publicación proporciona un ejemplo de cómo incorporar un código que se pedestal en dependencias externas en sus flujos de trabajo de muralla de Sagemaker.

Amazon Sagemaker Canvas es un Código de bajo código (LCNC) Plataforma ML que agenda a los usuarios a través de cada etapa del delirio ML, desde la preparación de datos original hasta la implementación final del maniquí. Sin escribir una sola recta de código, los usuarios pueden explorar conjuntos de datos, trocar datos, crear modelos y producir predicciones.

Sagemaker Canvas ofrece capacidades integrales de disputas de datos que lo ayudan a preparar sus datos, incluidos:

• Más de 300 pasos de transformación incorporados
• Capacidades de ingeniería de características
• Normalización de datos y funciones de desinterés
• Un editor de código personalizado que apoya a Python, Pyspark y SparkSQL

En esta publicación, demostramos cómo incorporar dependencias almacenadas en Servicio de almacenamiento simple de Amazon (Amazon S3) en el interior de un Amazon Sagemaker Data Wrangler fluir. Usando este enfoque, puede ejecutar scripts personalizados que dependen de módulos que no sean inherentemente compatibles con Sagemaker Canvas.

Descripción militar de la opción

Para mostrar la integración de scripts y dependencias personalizados de Amazon S3 en SageMaker Canvas, exploramos el próximo flujo de trabajo de ejemplo.

La opción sigue tres pasos principales:

1. Cargue scripts y dependencias personalizados en Amazon S3
2. Use Sagemaker Data Wrangler en Sagemaker Canvas para trocar sus datos utilizando el código cargado
3. Entrenar y exportar el maniquí

El próximo diagrama es la bloque de la opción.

En este ejemplo, trabajamos con dos conjuntos de datos complementarios disponibles en el muralla de Sagemaker que contienen información de expedición para entregas de pantalla de la computadora. Al unirnos a estos conjuntos de datos, creamos un conjunto de datos integral que captura varias métricas de expedición y resultados de entrega. Nuestro objetivo es construir un maniquí predictivo que pueda determinar si los envíos futuros llegarán a tiempo según los patrones y características de expedición históricos.

Requisitos previos

Como requisito previo, necesita llegada a Amazon S3 y Amazon Sagemaker AI. Si aún no tiene un dominio de IA Sagemaker configurado en su cuenta, igualmente necesita permisos para Crea un dominio de IA de Sagemaker.

Crear el flujo de datos

Para crear el flujo de datos, siga estos pasos:

1. En la consola AI de Amazon Sagemaker, en el panel de navegación, debajo Aplicaciones e IDESdecantarse Paramentocomo se muestra en la próximo captura de pantalla. Es posible que deba crear un dominio de Sagemaker si aún no lo ha hecho.
2. Luego de que se cree su dominio, elija Paramento amplio.

3. En muralla, seleccione el Conjuntos de datos pestaña y seleccione Canvas-sample-shipping-logs.csv, como se muestra en la próximo captura de pantalla. Luego de que aparezca la audiencia previa, elija + Crear un flujo de datos.

El flujo de datos original se abrirá con una fuente y un tipo de datos.

4. En la parte superior derecha de la pantalla y seleccione Unir datos → Tabular. Designar Conjuntos de datos de toldo como la fuente y seleccione el lienzo-muestra-productos-descripciones.csv.
5. Designar Próximo Como se muestra en la próximo captura de pantalla. Luego elija Importar.

6. Luego de que se hayan colaborador uno y otro conjuntos de datos, seleccione el signo más. En el menú desplegable, elija Preferir Combinar datos. Desde el próximo menú desplegable, elija Unirse.

7. Para realizar una unión interna en la columna ProductID, en el menú de la derecha, debajo Tipo de unióndesignar Unión interior. Bajo Unirse a las teclasdesignar Productidcomo se muestra en la próximo captura de pantalla.

8. Luego de que se hayan unido los conjuntos de datos, seleccione el signo más. En el menú desplegable, seleccione + Unir transformación. Se abrirá una audiencia previa del conjunto de datos.

El conjunto de datos contiene columnas XshippingDistance (Long) y YshippingDistance (largas). Para nuestros propósitos, queremos utilizar una función personalizada que encuentre la distancia total utilizando las coordenadas X e Y y luego soltar las columnas de coordenadas individuales. Para este ejemplo, encontramos la distancia total utilizando una función que se pedestal en la biblioteca MPMath.

9. Para vocear a la función personalizada, seleccione + Unir transformación. En el menú desplegable, seleccione Transformación personalizada. Cambiar el editor a Python (pandas) e intente ejecutar la próximo función desde el editor de Python:

from mpmath import sqrt  # Import sqrt from mpmath

def calculate_total_distance(df, x_col="XShippingDistance", y_col="YShippingDistance", new_col="TotalDistance"):

    # Use mpmath's sqrt to calculate the total distance for each row
    df(new_col) = df.apply(lambda row: float(sqrt(row(x_col)**2 + row(y_col)**2)), axis=1)
    
    # Drop the innovador x and y columns
    df = df.drop(columns=(x_col, y_col))
    
    return df

df = calculate_total_distance(df)

Ejecutar la función produce el próximo error: ModulenotFoundError: No se llamó el módulo ‘MPMATH’, como se muestra en la próximo captura de pantalla.

Este error ocurre porque MPMath no es un módulo inherentemente compatible con Sagemaker Canvas. Para usar una función que se pedestal en este módulo, necesitamos encarar el uso de una función personalizada de guisa diferente.

Zip el script y las dependencias

Para usar una función que se pedestal en un módulo que no se admite de forma nativa en el muralla, el script personalizado debe estar encendido con los módulos en el que se pedestal. Para este ejemplo, utilizamos nuestro entorno de ampliación integrado regional (IDE) para crear un script.py que se pedestal en la biblioteca MPMath.

El archivo script.py contiene dos funciones: una función que es compatible con el tiempo de ejecución de Python (pandas) (función calculate_total_distance), y uno que sea compatible con el tiempo de ejecución de Python (Pyspark) (función udf_total_distance).

def calculate_total_distance(df, x_col="XShippingDistance", y_col="YShippingDistance", new_col="TotalDistance"):
    from npmath import sqrt  # Import sqrt from npmath

    # Use npmath's sqrt to calculate the total distance for each row
    df(new_col) = df.apply(lambda row: float(sqrt(row(x_col)**2 + row(y_col)**2)), axis=1)

    # Drop the innovador x and y columns
    df = df.drop(columns=(x_col, y_col))

    return df

def udf_total_distance(df, x_col="XShippingDistance", y_col="YShippingDistance", new_col="TotalDistance"):
    from pyspark.sql import SparkSession
    from pyspark.sql.functions import udf
    from pyspark.sql.types import FloatType

    spark = SparkSession.builder 
        .master("regional") 
        .appName("DistanceCalculation") 
        .getOrCreate()

    def calculate_distance(x, y):
        import sys

        # Add the path to npmath
        mpmath_path = "/tmp/maths"
        if mpmath_path not in sys.path:
            sys.path.insert(0, mpmath_path)

        from mpmath import sqrt
        return float(sqrt(x**2 + y**2))

    # Register and apply UDF
    distance_udf = udf(calculate_distance, FloatType())
    df = df.withColumn(new_col, distance_udf(df(x_col), df(y_col)))
    df = df.drop(x_col, y_col)

    return df

Para cerciorarse de que el script pueda ejecutarse, instale mpmath en el mismo directorio que script.py ejecutando pip install mpmath.

Valer zip -r my_project.zip Para crear un archivo .zip que contenga la función y la instalación de MPMath. El directorio presente ahora contiene un archivo .zip, nuestro script de Python y la instalación de la que depende nuestro script, como se muestra en la próximo captura de pantalla.

Subir a Amazon S3

Luego de crear el archivo .zip, cárguelo a un cubo de Amazon S3.

Luego de que el archivo zip se ha subido a Amazon S3, se puede consentir en el muralla de Sagemaker.

Ejecutar el script personalizado

Regrese al flujo de datos en el muralla de Sagemaker y reemplace el código de función personalizado previo con el próximo código y elija Poner al día.

import zipfile
import boto3
import sys
from pathlib import Path
import shutil
import importlib.util


def load_script_and_dependencies(bucket_name, zip_key, extract_to):
    """
    Downloads a zip file from S3, unzips it, and ensures dependencies are available.

    Args:
        bucket_name (str): Name of the S3 bucket.
        zip_key (str): Key for the .zip file in the bucket.
        extract_to (str): Directory to extract files to.

    Returns:
        str: Path to the extracted folder containing the script and dependencies.
    """
    
    s3_client = boto3.client("s3")
    
    # Almacén path for the zip file
    zip_local_path="/tmp/dependencies.zip"
    
    # Download the .zip file from S3
    s3_client.download_file(bucket_name, zip_key, zip_local_path)
    print(f"Downloaded zip file from S3: {zip_key}")

    # Unzip the file
    try:
        with zipfile.ZipFile(zip_local_path, 'r') as zip_ref:
            zip_ref.extractall(extract_to)
            print(f"Extracted files to {extract_to}")
    except Exception as e:
        raise RuntimeError(f"Failed to extract zip file: {e}")

    # Add the extracted folder to Python path
    if extract_to not in sys.path:
      sys.path.insert(0, extract_to)
          
    return extract_to
    


def call_function_from_script(script_path, function_name, df):
    """
    Dynamically loads a function from a Python script using importlib.
    """
    try:
        # Get the script name from the path
        module_name = script_path.split('/')(-1).replace('.py', '')
        
        # Load the module specification
        spec = importlib.util.spec_from_file_location(module_name, script_path)
        if spec is None:
            raise ImportError(f"Could not load specification for module {module_name}")
            
        # Create the module
        module = importlib.util.module_from_spec(spec)
        sys.modules(module_name) = module
        
        # Execute the module
        spec.loader.exec_module(module)
        
        # Get the function from the module
        if not hasattr(module, function_name):
            raise AttributeError(f"Function '{function_name}' not found in the script.")
            
        loaded_function = getattr(module, function_name)

        # Clean up: remove module from sys.modules after execution
        del sys.modules(module_name)
        
        # Call the function
        return loaded_function(df)
        
    except Exception as e:
        raise RuntimeError(f"Error loading or executing function: {e}")


bucket_name="canvasdatabuckett"  # S3 bucket name
zip_key = 'functions/my_project.zip'  # S3 path to the zip file with our custom dependancy
script_name="script.py"  # Name of the script in the zip file
function_name="udf" # Name of function to call from our script
extract_to = '/tmp/maths' # Almacén path to our custom script and dependancies

# Step 1: Load the script and dependencies
extracted_path = load_script_and_dependencies(bucket_name, zip_key, extract_to)

# Step 2: Call the function from the script
script_path = f"{extracted_path}/{script_name}"
df = call_function_from_script(script_path, function_name, df)

Este código de ejemplo descomprime el archivo .zip y agrega las dependencias requeridas a la ruta regional para que estén disponibles para la función en el momento de ejecución. Adecuado a que MPMath se agregó a la ruta regional, ahora puede vocear a una función que se pedestal en esta biblioteca externa.

El código previo se ejecuta usando el tiempo de ejecución de Python (Pandas) y la función calculación_total_distance. Para usar el tiempo de ejecución de Python (Pyspark), actualice la variable function_name para vocear a la función UDF_TOTAL_DISTANCE en su superficie.

Completa el flujo de datos

Como zaguero paso, elimine las columnas irrelevantes ayer de entrenar el maniquí. Sigue estos pasos:

1. En la consola de muralla de Sagemaker, seleccione + Unir transformación. En el menú desplegable, seleccione Regir columnas
2. Bajo Elaborardesignar Columna de caída. Bajo Columnas para soltaramplificar productID_0, ProductID_1, y OrderId, como se muestra en la próximo captura de pantalla.

El conjunto de datos final debe contener 13 columnas. El flujo de datos completo se muestra en la próximo imagen.

Entrenar el maniquí

Para entrenar el maniquí, siga estos pasos:

1. En la parte superior derecha de la página, seleccione Crear maniquí y nombra tu conjunto de datos y maniquí.
2. Preferir Observación predictivo como el tipo de problema y Ontimedelivery Como la columna objetivo, como se muestra en la captura de pantalla a continuación.

Al construir el maniquí, puede designar ejecutar una compilación rápida o una compilación habitual. Una construcción rápida prioriza la velocidad sobre la precisión y produce un maniquí entrenado en menos de 20 minutos. Una construcción habitual prioriza la precisión sobre la latencia, pero el maniquí tarda más en entrenar.

Resultados

Luego de completar la construcción del maniquí, puede ver la precisión del maniquí, unido con métricas como F1, precisión y retiro. En el caso de una construcción habitual, el maniquí alcanzó una precisión del 94.5%.

Luego de completar el entrenamiento del maniquí, hay cuatro formas en que puede usar su maniquí:

1. Implementar el maniquí directamente Desde el muralla de Sagemaker hasta un punto final
2. Agregue el maniquí al Registro del Maniquí de Sagemaker
3. Exportar su maniquí a un cuaderno Jupyter
4. Envía tu maniquí a Amazon Quicksight Para usar en visualizaciones del tablero

Barrer

Para resolver los costos y evitar adicionales cargos de espacio de trabajodesignar Finalizar la sesión Para firmar el muralla de Sagemaker cuando haya terminado de usar la aplicación, como se muestra en la próximo captura de pantalla. Incluso puede configurar el muralla de Sagemaker para Agotado automáticamente cuando está inactivo.

Si creó un cubo S3 específicamente para este ejemplo, igualmente es posible que desee malogrado y borrar tu cubo.

Breviario

En esta publicación, demostramos cómo puede cargar dependencias personalizadas a Amazon S3 e integrarlas en los flujos de trabajo de Canvas SageMaker. Al caminar a través de un ejemplo práctico de implementar una función de cálculo de distancia personalizada con la biblioteca MPMath, mostramos cómo:

1. Paquete de código personalizado y dependencias en un archivo .zip
2. Almacene y acceda a estas dependencias desde Amazon S3
3. Implementar transformaciones de datos personalizadas en Sagemaker Data Wrangler
4. Entrenar un maniquí predictivo utilizando los datos transformados

Este enfoque significa que los científicos y analistas de datos pueden extender las capacidades de muralla de Sagemaker más allá de las más de 300 funciones incluidas.

Para probar las transformaciones personalizadas, consulte el Documentación de muralla de Amazon Sagemaker e inicie sesión en Sagemaker Canvas hoy. Para obtener información adicional sobre cómo puede optimizar su implementación de muralla de Sagemaker, recomendamos explorar estas publicaciones relacionadas:

Sobre el autor

Nadhya Polanco es un arquitecto de soluciones asociadas en AWS con sede en Bruselas, Bélgica. En este rol, apoya a las organizaciones que buscan incorporar la IA y el formación automotriz en sus cargas de trabajo. En su tiempo desenvuelto, a Nadhya le gusta disfrutar de su pasión por el café y explorar nuevos destinos.