Organice su viaje de aprendizaje automático con Amazon SageMaker Experiments y Amazon SageMaker Pipelines

El proceso de creación de un modelo de aprendizaje automático (ML) es iterativo hasta que encuentre el modelo candidato que funciona bien y está listo para implementarse. A medida que los científicos de datos iteran a través de ese proceso, necesitan un método confiable para rastrear fácilmente los experimentos para comprender cómo se construyó cada versión del modelo y cómo funcionó.

Amazon SageMaker permite que los equipos aprovechen una amplia gama de características para preparar, construir, entrenar, implementar y monitorear modelos ML rápidamente. Canalizaciones de Amazon SageMaker proporciona un proceso repetible para iterar a través de actividades de construcción de modelos, y está integrado con Experimentos de Amazon SageMaker. De forma predeterminada, cada canalización de SageMaker está asociada con un experimento y cada ejecución de esa canalización se rastrea como una prueba en ese experimento. Luego, sus iteraciones se rastrean automáticamente sin ningún paso adicional.

En esta publicación, analizamos más de cerca la motivación detrás de tener un proceso automatizado para rastrear experimentos con Experiments y las capacidades nativas integradas en Pipelines.

¿Por qué es importante mantener sus experimentos organizados?

Demos un paso atrás por un momento e intentemos entender por qué es importante tener experimentos organizados para el aprendizaje automático. Cuando los científicos de datos abordan un nuevo problema de ML, deben responder muchas preguntas diferentes, desde la disponibilidad de datos hasta cómo medirán el rendimiento del modelo.

Al principio, el proceso está lleno de incertidumbre y es altamente iterativo. Como resultado, esta fase de experimentación puede producir múltiples modelos, cada uno creado a partir de sus propias entradas (conjuntos de datos, scripts de entrenamiento e hiperparámetros) y produciendo sus propias salidas (artefactos de modelo y métricas de evaluación). El desafío entonces es hacer un seguimiento de todas estas entradas y salidas de cada iteración.

Los científicos de datos suelen entrenar muchas versiones de modelos diferentes hasta que encuentran la combinación de transformación de datos, algoritmo e hiperparámetros que da como resultado la versión de mejor rendimiento de un modelo. Cada una de estas combinaciones únicas es un solo experimento. Con un registro rastreable de las entradas, los algoritmos y los hiperparámetros que se utilizaron en esa prueba, el equipo de ciencia de datos puede encontrar fácil reproducir sus pasos.

Tener un proceso automatizado para realizar un seguimiento de los experimentos mejora la capacidad de reproducir e implementar versiones específicas del modelo que funcionan bien. La integración nativa de Pipelines con Experiments facilita el seguimiento y la administración automáticos de experimentos en ejecuciones de pipeline.

Beneficios de los experimentos de SageMaker

SageMaker Experiments permite a los científicos de datos organizar, rastrear, comparar y evaluar sus iteraciones de capacitación.

Comencemos primero con una descripción general de lo que puede hacer con los experimentos:

• Organizar experimentos - Experiments estructura la experimentación con una entidad de nivel superior llamada experimento que contiene un conjunto de ensayos. Cada ensayo contiene un conjunto de pasos llamados componentes de prueba. Cada componente de prueba es una combinación de conjuntos de datos, algoritmos y parámetros. Puede imaginar experimentos como la carpeta de nivel superior para organizar sus hipótesis, sus pruebas como las subcarpetas para cada ejecución de prueba grupal y sus componentes de prueba como sus archivos para cada instancia de una ejecución de prueba.
• Seguimiento de experimentos – Los experimentos permiten a los científicos de datos realizar un seguimiento de los experimentos. Ofrece la posibilidad de asignar automáticamente trabajos de SageMaker a una prueba a través de configuraciones simples y mediante los SDK de seguimiento.
• Comparar y evaluar experimentos – La integración de Experimentos con Estudio Amazon SageMaker facilita la producción de visualizaciones de datos y la comparación de diferentes ensayos. También puede acceder a los datos de prueba a través del SDK de Python para generar su propia visualización utilizando sus bibliotecas de trazado preferidas.

Para obtener más información sobre las API y los SDK de Experiments, recomendamos la siguiente documentación: CrearExperimento y Amazon SageMaker experimenta con el SDK de Python.

Si quieres profundizar más, te recomendamos que busques en el amazon-sagemaker-examples/sagemaker-experiments Repositorio de GitHub para más ejemplos.

Integración entre canalizaciones y experimentos

Las canalizaciones de creación de modelos que forman parte de Pipelines están diseñadas específicamente para ML y le permiten organizar sus tareas de creación de modelos mediante una herramienta de canalización que incluye integraciones nativas con otras funciones de SageMaker, así como la flexibilidad para ampliar su canalización con pasos que se ejecutan fuera de SageMaker. . Cada paso define una acción que realiza la canalización. Las dependencias entre los pasos se definen mediante un gráfico acíclico directo (DAG) creado con Pipelines Python SDK. Puede crear una canalización de SageMaker mediante programación a través del mismo SDK. Después de implementar una canalización, puede visualizar opcionalmente su flujo de trabajo dentro de Studio.

Pipelines se integra automáticamente con Experiments al crear automáticamente un experimento y una prueba para cada ejecución. Las canalizaciones crean automáticamente un experimento y una prueba para cada ejecución de la canalización antes de ejecutar los pasos, a menos que se especifique una o ambas entradas. Mientras se ejecuta el trabajo de SageMaker de la canalización, la canalización asocia la prueba con el experimento y asocia a la prueba cada componente de prueba creado por el trabajo. Especificar su propio experimento o prueba programáticamente le permite ajustar cómo organizar sus experimentos.

El flujo de trabajo que presentamos en este ejemplo consta de una serie de pasos: un paso de preprocesamiento para dividir nuestro conjunto de datos de entrada en conjuntos de datos de entrenamiento, prueba y validación; un paso de ajuste para ajustar nuestros hiperparámetros e iniciar trabajos de entrenamiento para entrenar un modelo usando el Algoritmo integrado XGBoost; y, por último, un paso de modelo para crear un modelo de SageMaker a partir del artefacto de modelo mejor entrenado. Pipelines también ofrece varios soportes nativos tipos de pasos fuera de lo que se discute en este post. También ilustramos cómo puede realizar un seguimiento del flujo de trabajo de su tubería y generar métricas y gráficos de comparación. Además, mostramos cómo asociar la nueva prueba generada a un experimento existente que podría haberse creado antes de que se definiera la canalización.

Código de canalizaciones de SageMaker

Puede revisar y descargar el cuaderno desde el Repositorio GitHub asociado a esta publicación. Miramos el código específico de Pipelines para entenderlo mejor.

Pipelines le permite pasar parámetros en tiempo de ejecución. Aquí definimos los tipos de instancias de procesamiento y entrenamiento y los conteos en tiempo de ejecución con valores predeterminados preestablecidos:

base_job_prefix = "pipeline-experiment-sample"
model_package_group_name = "pipeline-experiment-model-package"

processing_instance_count = ParameterInteger(
  name="ProcessingInstanceCount", default_value=1
)

training_instance_count = ParameterInteger(
  name="TrainingInstanceCount", default_value=1
)

processing_instance_type = ParameterString(
  name="ProcessingInstanceType", default_value="ml.m5.xlarge"
)
training_instance_type = ParameterString(
  name="TrainingInstanceType", default_value="ml.m5.xlarge"
)

A continuación, configuramos un script de procesamiento que descarga y divide el conjunto de datos de entrada en partes de entrenamiento, prueba y validación. Usamos SKLearnProcessor para ejecutar este paso de preprocesamiento. Para ello, definimos un objeto procesador con el tipo de instancia y el recuento necesario para ejecutar el trabajo de procesamiento.

Pipelines nos permite lograr el control de versiones de datos de forma programática mediante el uso de variables específicas de ejecución como ExecutionVariables.PIPELINE_EXECUTION_ID, que es el ID único de una ejecución de canalización. Podemos, por ejemplo, crear una clave única para almacenar los conjuntos de datos de salida en Servicio de almacenamiento simple de Amazon (Amazon S3) que los vincula a una ejecución de canalización específica. Para obtener la lista completa de variables, consulte Variables de ejecución.

framework_version = "0.23-1"

sklearn_processor = SKLearnProcessor(
    framework_version=framework_version,
    instance_type=processing_instance_type,
    instance_count=processing_instance_count,
    base_job_name="sklearn-ca-housing",
    role=role,
)

process_step = ProcessingStep(
    name="ca-housing-preprocessing",
    processor=sklearn_processor,
    outputs=[
        ProcessingOutput(
            output_name="train",
            source="/opt/ml/processing/train",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "train",
                ],
            ),
        ),
        ProcessingOutput(
            output_name="validation",
            source="/opt/ml/processing/validation",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "validation",
                ],
            )
        ),
        ProcessingOutput(
            output_name="test",
            source="/opt/ml/processing/test",
            destination=Join(
                on="/",
                values=[
                    "s3://{}".format(bucket),
                    prefix,
                    ExecutionVariables.PIPELINE_EXECUTION_ID,
                    "test",
                ],
            )
        ),
    ],
    code="california-housing-preprocessing.py",
)

Luego pasamos a crear un objeto estimador para entrenar un modelo XGBoost. Establecemos algunos hiperparámetros estáticos que se usan comúnmente con XGBoost:

model_path = f"s3://{default_bucket}/{base_job_prefix}/ca-housing-experiment-pipeline"

image_uri = sagemaker.image_uris.retrieve(
    framework="xgboost",
    region=region,
    version="1.2-2",
    py_version="py3",
    instance_type=training_instance_type,
)

xgb_train = Estimator(
    image_uri=image_uri,
    instance_type=training_instance_type,
    instance_count=training_instance_count,
    output_path=model_path,
    base_job_name=f"{base_job_prefix}/ca-housing-train",
    sagemaker_session=sagemaker_session,
    role=role,
)

xgb_train.set_hyperparameters(
    eval_metric="rmse",
    objective="reg:squarederror",  # Define the object metric for the training job
    num_round=50,
    max_depth=5,
    eta=0.2,
    gamma=4,
    min_child_weight=6,
    subsample=0.7
)

Realizamos ajustes de hiperparámetros de los modelos que creamos utilizando un ContinuousParameter rango para lambda. Elegir una métrica para que sea la métrica objetiva le dice al sintonizador (la instancia que ejecuta los trabajos de ajuste de hiperparámetros) que evaluará el trabajo de entrenamiento en función de esta métrica específica. El sintonizador devuelve la mejor combinación basada en el mejor valor para esta métrica objetiva, es decir, la mejor combinación que minimiza el mejor error cuadrático medio (RMSE).

objective_metric_name = "validation:rmse"

hyperparameter_ranges = {
    "lambda": ContinuousParameter(0.01, 10, scaling_type="Logarithmic")
}

tuner = HyperparameterTuner(estimator,
                            objective_metric_name,
                            hyperparameter_ranges,
                            objective_type=objective_type,
                            strategy="Bayesian",
                            max_jobs=10,
                            max_parallel_jobs=3)

tune_step = TuningStep(
    name="HPTuning",
    tuner=tuner_log,
    inputs={
        "train": TrainingInput(
            s3_data=process_step.properties.ProcessingOutputConfig.Outputs[
                "train"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
        "validation": TrainingInput(
            s3_data=process_step.properties.ProcessingOutputConfig.Outputs[
                "validation"
            ].S3Output.S3Uri,
            content_type="text/csv",
        ),
    } 
)

El paso de ajuste ejecuta múltiples pruebas con el objetivo de determinar el mejor modelo entre los rangos de parámetros probados. con el metodo get_top_model_s3_uri, clasificamos las 50 versiones con mejor rendimiento del URI de S3 del artefacto del modelo y solo extraemos la versión con mejor rendimiento (especificamos k=0 para el mejor) para crear un modelo de SageMaker.

model_bucket_key = f"{default_bucket}/{base_job_prefix}/ca-housing-experiment-pipeline"
model_candidate = Model(
    image_uri=image_uri,
    model_data=tune_step.get_top_model_s3_uri(top_k=0, s3_bucket=model_bucket_key),
    sagemaker_session=sagemaker_session,
    role=role,
    predictor_cls=XGBoostPredictor,
)

create_model_step = CreateModelStep(
    name="CreateTopModel",
    model=model_candidate,
    inputs=sagemaker.inputs.CreateModelInput(instance_type="ml.m4.large"),
)

Cuando se ejecuta la canalización, crea componentes de prueba para cada trabajo de ajuste de hiperparámetros y cada trabajo de SageMaker creado por los pasos de la canalización.

Puede configurar aún más la integración de canalizaciones con experimentos creando un PipelineExperimentConfig y páselo al objeto de canalización. Los dos parámetros definen el nombre del experimento que se creará y la prueba que se referirá a la ejecución completa de la canalización.

Si desea asociar una ejecución de canalización a un experimento existente, puede pasar su nombre y Pipelines le asociará la nueva prueba. Puede evitar la creación de un experimento y una prueba para la ejecución de una canalización configurando pipeline_experiment_config a None.

#Pipeline experiment config
ca_housing_experiment_config = PipelineExperimentConfig(
    experiment_name,
    Join(
        on="-",
        values=[
            "pipeline-execution",
            ExecutionVariables.PIPELINE_EXECUTION_ID
        ],
    )
)

Pasamos los tipos de instancia y los recuentos como parámetros, y encadenamos los pasos anteriores en orden de la siguiente manera. El flujo de trabajo de canalización está implícitamente definido por las salidas de un paso que son las entradas de otro paso.

pipeline_name = f"CAHousingExperimentsPipeline"

pipeline = Pipeline(
    name=pipeline_name,
    pipeline_experiment_config=ca_housing_experiment_config,
    parameters=[
        processing_instance_count,
        processing_instance_type,
        training_instance_count,
        training_instance_type
    ],
    steps=[process_step,tune_step,create_model_step],
)

La canalización completa ahora está creada y lista para funcionar. Agregamos un rol de ejecución a la canalización y lo iniciamos. Desde aquí, podemos ir a la consola SageMaker Studio Pipelines y realizar un seguimiento visual de cada paso. También puede acceder a los registros vinculados desde la consola para depurar una canalización.

pipeline.upsert(role_arn=sagemaker.get_execution_role())
execution = pipeline.start()

La captura de pantalla anterior muestra en verde una canalización ejecutada correctamente. Obtenemos las métricas de una prueba de una ejecución de la canalización con el siguiente código:

# SM Pipeline injects the Execution ID into trial component names
execution_id = execution.describe()['PipelineExecutionArn'].split('/')[-1]
source_arn_filter = Filter(
    name="TrialComponentName", operator=Operator.CONTAINS, value=execution_id
)

source_type_filter = Filter(
    name="Source.SourceType", operator=Operator.EQUALS, value="SageMakerTrainingJob"
)

search_expression = SearchExpression(
    filters=[source_arn_filter, source_type_filter]
)

trial_component_analytics = ExperimentAnalytics(
    sagemaker_session=sagemaker_session,
    experiment_name=experiment_name,
    search_expression=search_expression.to_boto()
)

analytic_table = trial_component_analytics.dataframe()
analytic_table.head()

Compare las métricas de cada componente de prueba

Puede trazar los resultados del ajuste de hiperparámetros en Studio o a través de otras bibliotecas de trazado de Python. Mostramos ambas formas de hacerlo.

Explore las métricas de capacitación y evaluación en Studio

Studio proporciona una interfaz de usuario interactiva en la que puede generar gráficos interactivos. Los pasos son los siguientes:

1. Elige Experimentos y Ensayos del desplegable Recursos de SageMaker icono en la barra lateral izquierda.
2. Elija su experimento para abrirlo.
3. Elija (haga clic con el botón derecho) la prueba de interés.
4. Elige Abrir en la lista de componentes de prueba.
5. Prensa Shift para seleccionar los componentes de prueba que representan los trabajos de entrenamiento.
6. Elige Agregar gráfico.
7. Elige Nuevo gráfico y personalícelo para trazar las métricas recopiladas que desea analizar. Para nuestro caso de uso, elija lo siguiente:
   1. Tipo de datosSeleccione Resumen estadístico.
   2. tipo de gráficoSeleccione Gráfico de dispersión.
   3. Eje X, escoger lambda.
   4. Eje Y, escoger validation:rmse_last.

El nuevo gráfico aparece en la parte inferior de la ventana, etiquetado como '8'.

Puedes incluir más o menos trabajos de formación pulsando Shift y elegir el ícono del ojo para una experiencia más interactiva.

Análisis con experimentos de SageMaker

Cuando se completa la ejecución de la canalización, podemos visualizar rápidamente cómo se comparan las diferentes variaciones del modelo en términos de las métricas recopiladas durante el entrenamiento. Anteriormente, exportamos todas las métricas de prueba a un pandas DataFrame usando ExperimentAnalytics. Podemos reproducir el gráfico obtenido en Studio utilizando la biblioteca Matplotlib.

analytic_table.plot.scatter("lambda", "validation:rmse - Last", grid=True)

Conclusión

La integración nativa entre SageMaker Pipelines y SageMaker Experiments permite que los científicos de datos organicen, rastreen y visualicen automáticamente los experimentos durante las actividades de desarrollo de modelos. Puede crear experimentos para organizar todo su trabajo de desarrollo de modelos, como los siguientes:

• Un caso de uso comercial que está abordando, como crear un experimento para predecir la rotación de clientes
• Un experimento propiedad del equipo de ciencia de datos sobre análisis de marketing, por ejemplo
• Un proyecto específico de ciencia de datos y ML

En esta publicación, nos sumergimos en Pipelines para mostrar cómo puede usarlo junto con Experiments para organizar un flujo de trabajo de extremo a extremo completamente automatizado.

Como siguiente paso, puede usar estas tres funciones de SageMaker (Studio, Experiments y Pipelines) para su próximo proyecto de ML.

Lecturas sugeridas

Sobre los autores

paolo di francesco es arquitecto de soluciones en AWS. Tiene experiencia en telecomunicaciones e ingeniería de software. Le apasiona el aprendizaje automático y actualmente se está enfocando en usar su experiencia para ayudar a los clientes a alcanzar sus objetivos en AWS, en particular en discusiones sobre MLOps. Fuera del trabajo, le gusta jugar al fútbol y leer.

Mario Bourgoin es Arquitecto sénior de soluciones de socios para AWS, especialista en IA/ML y líder tecnológico global para MLOps. Trabaja con clientes y socios empresariales que implementan soluciones de IA en la nube. Tiene más de 30 años de experiencia en aprendizaje automático e inteligencia artificial en nuevas empresas y empresas, comenzando con la creación de uno de los primeros sistemas comerciales de aprendizaje automático para big data. Mario pasa su tiempo libre jugando con sus tres Tervuren belgas, preparando la cena para su familia y aprendiendo sobre matemáticas y cosmología.

Ganapati Krishnamoorthi es arquitecto sénior de soluciones de aprendizaje automático en AWS. Ganapathi brinda orientación prescriptiva a clientes empresariales y de inicio, ayudándolos a diseñar e implementar aplicaciones en la nube a escala. Está especializado en aprendizaje automático y se enfoca en ayudar a los clientes a aprovechar AI/ML para sus resultados comerciales. Cuando no está en el trabajo, le gusta explorar al aire libre y escuchar música.

Valerie Soundhakith es arquitecto de soluciones para AWS, trabaja en la industria del juego y con socios que implementan soluciones de IA. Su objetivo es construir su carrera en torno a Computer Vision. Durante su tiempo libre, Valerie lo dedica a viajar, descubrir nuevos lugares para comer y cambiar los interiores de su casa.