Experimentos de Amazon SageMaker de próxima generación: organice, rastree y compare sus capacitaciones de aprendizaje automático a escala

Hoy, nos complace anunciar las actualizaciones de nuestro Experimentos de Amazon SageMaker capacidad de Amazon SageMaker que le permite organizar, rastrear, comparar y evaluar experimentos de aprendizaje automático (ML) y versiones de modelos desde cualquier entorno de desarrollo integrado (IDE) utilizando SageMaker Python SDK o boto3, incluidos Jupyter Notebooks locales.

El aprendizaje automático (ML) es un proceso iterativo. Al resolver un nuevo caso de uso, los científicos de datos y los ingenieros de ML iteran a través de varios parámetros para encontrar las mejores configuraciones de modelo (también conocidas como hiperparámetros) que se pueden usar en producción para resolver el desafío empresarial identificado. Con el tiempo, después de experimentar con múltiples modelos e hiperparámetros, se vuelve difícil para los equipos de ML administrar de manera eficiente las ejecuciones de modelos para encontrar el óptimo sin una herramienta para realizar un seguimiento de los diferentes experimentos. Los sistemas de seguimiento de experimentos agilizan los procesos para comparar diferentes iteraciones y ayudan a simplificar la colaboración y la comunicación en un equipo, lo que aumenta la productividad y ahorra tiempo. Esto se logra organizando y administrando experimentos de ML sin esfuerzo para sacar conclusiones de ellos, por ejemplo, encontrar la ejecución de entrenamiento con la mayor precisión.

Para resolver este desafío, SageMaker proporciona Experimentos de SageMaker, una capacidad de SageMaker completamente integrada. Brinda la flexibilidad de registrar las métricas, parámetros, archivos, artefactos de su modelo, trazar gráficos de las diferentes métricas, capturar varios metadatos, buscar a través de ellos y respaldar la reproducibilidad del modelo. Los científicos de datos pueden comparar rápidamente el rendimiento y los hiperparámetros para la evaluación del modelo a través de gráficos y tablas visuales. También pueden usar Experimentos de SageMaker para descargar los gráficos creados y compartir la evaluación del modelo con las partes interesadas.

Con las nuevas actualizaciones de SageMaker Experiments, ahora forma parte del SageMaker SDK, lo que simplifica el trabajo de los científicos de datos y elimina la necesidad de instalar una biblioteca adicional para administrar múltiples ejecuciones de modelos. Estamos introduciendo los siguientes nuevos conceptos básicos:

• Experimento: una colección de ejecuciones que se agrupan. Un experimento incluye ejecuciones para varios tipos que se pueden iniciar desde cualquier lugar mediante el SDK de Python de SageMaker.
• Ejecutar: Cada paso de ejecución de un proceso de entrenamiento de modelo. Una ejecución consta de todas las entradas, parámetros, configuraciones y resultados de una iteración del entrenamiento del modelo. Los parámetros personalizados y las métricas se pueden registrar mediante el log_parameter, log_parametersy log_metric funciones Las entradas y salidas personalizadas se pueden registrar usando el log_file función.

Los conceptos que se implementan como parte de un Run class están disponibles desde cualquier IDE donde esté instalado SageMaker Python SDK. Para SageMaker Capacitación, Procesamiento y

Transform Jobs, la ejecución del experimento de SageMaker se pasa automáticamente al trabajo si el trabajo se invoca dentro de un contexto de ejecución. Puede recuperar el objeto ejecutado usando load_run() de tu trabajo Finalmente, con la integración de las nuevas funcionalidades, los científicos de datos también pueden registrar automáticamente una matriz de confusión, gráficos de precisión y recuperación, y una curva ROC para casos de uso de clasificación utilizando el run.log_confusion_matrix, run.log_precision_recally run.log_roc_curve funciones, respectivamente.

En esta publicación de blog, proporcionaremos ejemplos de cómo usar las nuevas funcionalidades de Experimentos de SageMaker en un cuaderno Jupyter a través del SDK de SageMaker. Demostraremos estas capacidades usando un PyTorch ejemplo para entrenar un ejemplo de clasificación de dígitos escritos a mano del MNIST. El experimento se organizará de la siguiente manera:

1. Creación de ejecuciones de experimentos y parámetros de registro: Primero crearemos un nuevo experimento, comenzaremos una nueva ejecución para este experimento y registraremos los parámetros en él.
2. Registro de métricas de rendimiento del modelo:Registraremos las métricas de rendimiento del modelo y trazaremos gráficos de métricas.
3. Comparación de ejecuciones de modelos:Compararemos diferentes ejecuciones de modelos de acuerdo con los hiperparámetros del modelo. Discutiremos cómo comparar esas ejecuciones y cómo usar los Experimentos de SageMaker para seleccionar el mejor modelo.
4. Ejecución de experimentos desde trabajos de SageMaker: También proporcionaremos un ejemplo de cómo compartir automáticamente el contexto de su experimento con un trabajo de procesamiento, capacitación o transformación por lotes de SageMaker. Esto le permite recuperar automáticamente su contexto de ejecución con el load_run función dentro de su trabajo.
5. Integración de informes de SageMaker Clarify: Demostraremos cómo ahora podemos integrar SageMaker aclarar informes de sesgo y explicabilidad en una sola vista con su modelo de informe entrenado.

Requisitos previos

Para esta publicación de blog, usaremos Estudio Amazon SageMaker para mostrar cómo registrar métricas desde un cuaderno de Studio usando las funcionalidades actualizadas de SageMaker Experiments. Para ejecutar los comandos presentados en nuestro ejemplo, necesita los siguientes requisitos previos:

• Dominio de SageMaker Studio
• Perfil de usuario de SageMaker Studio con acceso completo a SageMaker
• Una computadora portátil SageMaker Studio con al menos una ml.t3.medium tipo de instancia

Si no tiene un dominio de SageMaker y un perfil de usuario disponibles, puede crear uno usando este guía de configuración rápida.

Parámetros de registro

Para este ejercicio utilizaremos antorcha, un paquete de PyTorch que proporciona conjuntos de datos populares, arquitecturas de modelos y transformaciones de imágenes comunes para la visión artificial. SageMaker Studio proporciona un conjunto de Imágenes de Docker para casos de uso de ciencia de datos comunes que están disponibles en Amazon ECR. Para PyTorch, tiene la opción de seleccionar imágenes optimizadas para entrenamiento de CPU o GPU. Para este ejemplo, seleccionaremos la imagen PyTorch 1.12 Python 3.8 CPU Optimized y del Python 3 núcleo. Los ejemplos que se describen a continuación se centrarán en las funcionalidades de los Experimentos de SageMaker y no están completos en código.

Descarguemos los datos con el torchvision empaquete y rastree la cantidad de muestras de datos para los conjuntos de datos de prueba y entrenamiento como parámetros con SageMaker Experiments. Para este ejemplo, supongamos train_set y test_set como ya descargado torchvision conjuntos de datos

from sagemaker.session import Session
from sagemaker.experiments.run import Run
import os

# create an experiment and start a new run
experiment_name = "local-experiment-example"
run_name = "experiment-run"

with Run(experiment_name=experiment_name, sagemaker_session=Session(), run_name=run_name) as run:
    run.log_parameters({
        "num_train_samples": len(train_set.data),
        "num_test_samples": len(test_set.data)
    })
    for f in os.listdir(train_set.raw_folder):
        print("Logging", train_set.raw_folder+"/"+f)
        run.log_file(train_set.raw_folder+"/"+f, name=f, is_output=False)

En este ejemplo, usamos el run.log_parameters para registrar el número de muestras de datos de tren y prueba y run.log_file para cargar los conjuntos de datos sin procesar en Amazon S3 y registrarlos como entradas para nuestro experimento.

Entrenamiento de un modelo y registro de métricas del modelo

Ahora que hemos descargado nuestro conjunto de datos MNIST, entrenemos un modelo CNN para reconocer los dígitos. Mientras entrenamos el modelo, queremos cargar nuestra ejecución de experimento existente, registrar nuevos parámetros y realizar un seguimiento del rendimiento del modelo mediante el registro de métricas del modelo.

Podemos usar el load_run función para cargar nuestra ejecución anterior y usarla para registrar nuestro modelo de entrenamiento

with load_run(experiment_name=experiment_name, run_name=run_name, sagemaker_session=Session()) as run:
    train_model(
        run=run,
        train_set=train_set,
        test_set=test_set,
        epochs=10,
        hidden_channels=5,
        optimizer="adam"
    )

Entonces podemos usar run.log_parameter y run.log_parameters para registrar uno o varios parámetros del modelo en nuestra ejecución.

# log the parameters of your model
run.log_parameter("device", "cpu")
run.log_parameters({
    "data_dir": data_dir,
    "optimizer": optimizer,
    "epochs": epochs,
    "hidden_channels": hidden_channels
})

Y podemos usar run.log_metric para registrar métricas de rendimiento en nuestro experimento.

run.log_metric(name=metric_type+":loss", value=loss, step=epoch)
run.log_metric(name=metric_type+":accuracy", value=accuracy, step=epoch)

Para los modelos de clasificación, también puede utilizar run.log_confusion_matrix, run.log_precision_recally run.log_roc_curve, para trazar automáticamente la matriz de confusión, el gráfico de recuperación de precisión y la curva ROC de su modelo. Dado que nuestro modelo resuelve un problema de clasificación multiclase, registraremos solo la matriz de confusión para él.

# log confusion matrix
with torch.no_grad():
    for data, target in test_loader:
        data, target = data.to(device), target.to(device)
        output = model(data)
        pred = output.max(1, keepdim=True)[1] 
        run.log_confusion_matrix(target, pred, "Confusion-Matrix-Test-Data")

Al mirar los detalles de nuestra ejecución, ahora podemos ver las métricas generadas como se muestra en la siguiente captura de pantalla:

La página de detalles de la ejecución proporciona más información sobre las métricas.

Y los parámetros del nuevo modelo se rastrean en la página de resumen de parámetros.

También puede analizar el rendimiento de su modelo por clase usando la matriz de confusión trazada automáticamente, que también se puede descargar y usar para diferentes informes. Y puede trazar gráficos adicionales para analizar el rendimiento de su modelo en función de las métricas registradas.

Comparación de múltiples parámetros del modelo

Como científico de datos, desea encontrar el mejor modelo posible. Eso incluye entrenar un modelo varias veces con diferentes hiperparámetros y comparar el rendimiento del modelo con esos hiperparámetros. Para ello, SageMaker Experiments nos permite crear múltiples ejecuciones en el mismo experimento. Exploremos este concepto entrenando nuestro modelo con diferentes num_hidden_channels y optimizers.

# define the list of parameters to train the model with
num_hidden_channel_param = [5, 10, 20]
optimizer_param = ["adam", "sgd"]
run_id = 0
# train the model using SageMaker Experiments to track the model parameters, 
# metrics and performance
sm_session = Session()
for i, num_hidden_channel in enumerate(num_hidden_channel_param):
    for k, optimizer in enumerate(optimizer_param):
        run_id += 1
        run_name = "experiment-run-"+str(run_id)
        print(run_name)
        print(f"Training model with: {num_hidden_channel} hidden channels and {optimizer} as optimizer")
        # Defining an experiment run for each model training run
        with Run(experiment_name=experiment_name, run_name=run_name, sagemaker_session=sm_session) as run:
            train_model(
                run=run, 
                train_set=train_set,
                test_set=test_set,
                epochs=10, 
                hidden_channels=num_hidden_channel,
                optimizer=optimizer
            )

Ahora estamos creando seis nuevas ejecuciones para nuestro experimento. Cada uno registrará los parámetros del modelo, las métricas y la matriz de confusión. Luego podemos comparar las ejecuciones para seleccionar el modelo de mejor rendimiento para el problema. Al analizar las carreras, podemos trazar los gráficos de métricas para las diferentes carreras como un solo gráfico, comparando el rendimiento de las carreras en los diferentes pasos de entrenamiento (o épocas).

Uso de experimentos de SageMaker con trabajos de transformación por lotes, procesamiento y capacitación de SageMaker

En el ejemplo anterior, usamos Experimentos de SageMaker para registrar el rendimiento del modelo desde un cuaderno de SageMaker Studio donde el modelo se entrenó localmente en el cuaderno. Podemos hacer lo mismo para registrar el rendimiento del modelo de los trabajos de procesamiento, capacitación y transformación por lotes de SageMaker. Con las nuevas capacidades de transferencia automática de contexto, no es necesario compartir específicamente la configuración del experimento con el trabajo de SageMaker, ya que se capturará automáticamente.

El siguiente ejemplo se centrará en las funcionalidades de los Experimentos de SageMaker y no es un código completo.

from sagemaker.pytorch import PyTorch
from sagemaker.experiments.run import Run
from sagemaker.session import Session
from sagemaker import get_execution_role
role = get_execution_role()

# set new experiment configuration
exp_name = "training-job-experiment-example"
run_name = "experiment-run-example"

# Start training job with experiment setting
with Run(experiment_name=exp_name, run_name=run_name, sagemaker_session=Session()) as run:
    est = PyTorch(
        entry_point="",
        dependencies=[""],
        role=role,
        model_dir=False,
        framework_version="1.12",
        py_version="py38",
        instance_type='ml.c5.xlarge',
        instance_count=1,
            hyperparameters={
            "epochs": 10,
            "hidden_channels":5,
            "optimizer": "adam",
        },
        keep_alive_period_in_seconds=3600
    )
    
    est.fit()

En nuestro archivo de script modelo, podemos obtener el contexto de ejecución usando load_run(). En los trabajos de procesamiento y capacitación de SageMaker, no es necesario proporcionar la configuración del experimento para cargar la configuración. Para los trabajos de transformación por lotes, debemos proporcionar experiment_name y run_name para cargar la configuración del experimento.

with load_run() as run:
    run.log_parameters({...})
    train_model(run, ...)

Además de la información que obtenemos cuando ejecutamos Experimentos de SageMaker desde un script de notebook, la ejecución desde un trabajo de SageMaker completará automáticamente los parámetros y resultados del trabajo.

El nuevo SDK de experimentos de SageMaker también garantiza la compatibilidad con versiones anteriores utilizando los conceptos de pruebas y componentes de prueba. Cualquier experimento activado con la versión anterior de Experimentos de SageMaker estará disponible automáticamente en la nueva interfaz de usuario para analizar los experimentos.

Integración de SageMaker Clarify y modelos de informes de capacitación

SageMaker Clarify ayuda a mejorar nuestros modelos de aprendizaje automático al detectar sesgo potencial y ayudando explicar cómo estos modelos hacen predicciones. Clarify proporciona contenedores preconstruidos que se ejecutan como trabajos de procesamiento de SageMaker después de que su modelo haya sido entrenado, utilizando información sobre sus datos (configuración de datos), modelo (configuración del modelo) y las columnas de datos confidenciales que queremos analizar para detectar posibles sesgos (sesgo). configuración). Hasta ahora, los Experimentos de SageMaker mostraban nuestro entrenamiento de modelos y los informes de Clarify como componentes de prueba individuales que se conectaban a través de una prueba.

Con los nuevos Experimentos de SageMaker, también podemos integrar los informes de SageMaker Clarify con nuestro entrenamiento de modelos con una fuente de verdad que nos permite comprender mejor nuestro modelo. Para un informe integrado, todo lo que necesitamos hacer es tener el mismo nombre de ejecución para nuestros trabajos de capacitación y Clarificar. El siguiente ejemplo demuestra cómo podemos integrar los informes utilizando un Modelo XGBoost para predecir los ingresos de los adultos en los Estados Unidos. El modelo utiliza el Conjunto de datos de adultos UCI. Para este ejercicio, asumimos que el modelo ya fue entrenado y que ya calculamos las configuraciones de datos, modelo y sesgo.

with Run(
    experiment_name='clarify-experiment',
    run_name="joint-run",
    sagemaker_session=sagemaker_session,
) as run:
    xgb.fit({"train": train_input}, logs=False)
    clarify_processor.run_bias(
        data_config=bias_data_config,
        bias_config=bias_config,
        model_config=model_config,
        model_predicted_label_config=predictions_config,
        pre_training_methods="all",
        post_training_methods="all",
    )
    clarify_processor.run_explainability(
        data_config=explainability_data_config,
        model_config=model_config,
        explainability_config=shap_config,
    )

Con esta configuración, obtenemos una vista combinada que incluye las métricas del modelo, las entradas y salidas conjuntas y los informes de Clarify para el sesgo estadístico y la explicabilidad del modelo.

Conclusión

En esta publicación, exploramos la nueva generación de experimentos de SageMaker, una parte integrada de SageMaker SDK. Demostramos cómo registrar sus flujos de trabajo de ML desde cualquier lugar con la nueva clase Run. Presentamos la nueva interfaz de usuario de Experimentos que le permite realizar un seguimiento de sus experimentos y trazar gráficos para una sola métrica de ejecución, así como comparar múltiples ejecuciones con la nueva capacidad de análisis. Brindamos ejemplos de experimentos de registro de un cuaderno de SageMaker Studio y de un trabajo de capacitación de SageMaker Studio. Finalmente, mostramos cómo integrar la capacitación de modelos y los informes de SageMaker Clarify en una vista unificada, lo que le permite comprender mejor su modelo.

Le animamos a que pruebe las nuevas funcionalidades de Experimentos y se conecte con el Comunidad de inteligencia artificial y aprendizaje automático si tiene alguna pregunta o comentario!

Acerca de los autores

Maira Ladeira Tanke es especialista en aprendizaje automático en AWS. Con experiencia en ciencia de datos, tiene 9 años de experiencia en la arquitectura y creación de aplicaciones ML con clientes de todas las industrias. Como líder técnica, ayuda a los clientes a acelerar su logro de valor comercial a través de tecnologías emergentes y soluciones innovadoras. En su tiempo libre, a Maira le gusta viajar y pasar tiempo con su familia en un lugar cálido.

Mani Januja es Especialista en Inteligencia Artificial y Aprendizaje Automático SA en Amazon Web Services (AWS). Ella ayuda a los clientes a usar el aprendizaje automático para resolver sus desafíos comerciales usando AWS. Pasa la mayor parte de su tiempo profundizando y enseñando a los clientes sobre proyectos de IA/ML relacionados con la visión artificial, el procesamiento del lenguaje natural, la previsión, el ML en el perímetro y más. Le apasiona el aprendizaje automático en el borde, por lo que ha creado su propio laboratorio con un kit autónomo y una línea de producción de fabricación de prototipos, donde pasa gran parte de su tiempo libre.

Qi Dewen es ingeniero de desarrollo de software en AWS. Actualmente participa en la creación de una colección de herramientas y servicios de plataforma en AWS SageMaker para ayudar a los clientes a lograr que sus proyectos de aprendizaje automático sean exitosos. También le apasiona llevar el concepto de MLOps a un público más amplio. Fuera del trabajo, a Dewen le gusta practicar violonchelo.

Abhishek Agarwal es gerente sénior de productos de Amazon SageMaker. Le apasiona trabajar con clientes y hacer que el aprendizaje automático sea más accesible. En su tiempo libre, a Abhishek le gusta pintar, andar en bicicleta y aprender sobre tecnologías innovadoras.

dana benson es un ingeniero de software que trabaja en el equipo de experimentos, linaje y búsqueda de Amazon SageMaker. Antes de unirse a AWS, Dana dedicó un tiempo a habilitar la funcionalidad de hogar inteligente en Alexa y los pedidos móviles en Starbucks.