Optimice los hiperparámetros con Amazon SageMaker Automatic Model Tuning

Los modelos de aprendizaje automático (ML) están conquistando el mundo. Su rendimiento depende del uso de los datos de entrenamiento correctos y de la elección del modelo y el algoritmo correctos. Pero no termina aquí. Por lo general, los algoritmos difieren algunas decisiones de diseño para que el profesional de ML las adopte para sus datos y tareas específicos. Estas decisiones de diseño diferidas se manifiestan como hiperparámetros.

¿Qué significa ese nombre? El resultado del entrenamiento de ML, el modelo, puede verse en gran medida como una colección de parámetros que se aprenden durante el entrenamiento. Por lo tanto, los parámetros que se usan para configurar el proceso de entrenamiento de ML se denominan hiperparámetros, parámetros que describen la creación de parámetros. En cualquier caso, son de uso muy práctico, como el número de épocas a entrenar, la tasa de aprendizaje, la profundidad máxima de un árbol de decisión, etc. Y les prestamos mucha atención porque tienen un gran impacto en el rendimiento final de su modelo.

Al igual que girar una perilla en un receptor de radio para encontrar la frecuencia correcta, cada hiperparámetro debe ajustarse cuidadosamente para optimizar el rendimiento. La búsqueda de los valores óptimos en el espacio de hiperparámetros se conoce como ajuste de hiperparámetros or optimización de hiperparámetros (HPO), y debería dar como resultado un modelo que proporcione predicciones precisas.

En esta publicación, configuramos y ejecutamos nuestro primer trabajo de HPO usando Ajuste automático de modelos de Amazon SageMaker (AMT). ¡Aprendemos sobre los métodos disponibles para explorar los resultados y creamos algunas visualizaciones perspicaces de nuestras pruebas de HPO y la exploración del espacio de hiperparámetros!

Ajuste automático de modelos de Amazon SageMaker

Como profesional de ML que usa AMT de SageMaker, puede concentrarse en lo siguiente:

• Proporcionar un trabajo de formación.
• Definición de la métrica objetiva correcta que coincida con su tarea
• Alcance del espacio de búsqueda de hiperparámetros

SageMaker AMT se encarga del resto y usted no necesita pensar en la infraestructura, organizar trabajos de capacitación y mejorar la selección de hiperparámetros.

Comencemos usando SageMaker AMT para nuestro primer trabajo simple de HPO, para entrenar y ajustar un algoritmo XGBoost. Queremos que su viaje AMT sea práctico y práctico, por lo que hemos compartido el ejemplo a continuación. Repositorio GitHub. Esta publicación cubre el 1_tuning_of_builtin_xgboost.ipynb cuaderno.

En una próxima publicación, ampliaremos la noción de simplemente encontrar los mejores hiperparámetros e incluiremos el aprendizaje sobre el espacio de búsqueda y a qué rangos de hiperparámetros es sensible un modelo. También mostraremos cómo convertir una actividad de ajuste de una sola vez en una conversación de varios pasos con el profesional de ML, para aprender juntos. ¡Estén atentos (nunca mejor dicho)!

Requisitos previos

Esta publicación es para cualquier persona interesada en aprender sobre HPO y no requiere conocimientos previos sobre el tema. Sin embargo, la familiaridad básica con los conceptos de ML y la programación de Python es útil. Para obtener la mejor experiencia de aprendizaje, recomendamos encarecidamente seguir los pasos de ejecutando cada paso en el cuaderno en paralelo a la lectura de este post. Y al final del cuaderno, también puede probar una visualización interactiva que hace que los resultados del ajuste cobren vida.

Resumen de la solución

Vamos a crear una configuración integral para ejecutar nuestro primer trabajo de HPO con SageMaker AMT. Cuando nuestro trabajo de ajuste está completo, observamos algunos de los métodos disponibles para explorar los resultados, tanto a través de la Consola de administración de AWS y mediante programación a través de los SDK y las API de AWS.

En primer lugar, nos familiarizamos con el entorno y la capacitación de SageMaker mediante la ejecución de un trabajo de capacitación independiente, sin ningún ajuste por el momento. Usamos el algoritmo XGBoost, uno de los muchos algoritmos proporcionados como Algoritmo incorporado de SageMaker (¡No se requiere guión de entrenamiento!).

Vemos cómo funciona SageMaker Training de las siguientes maneras:

• Inicia y detiene una instancia.
• Aprovisiona el contenedor necesario
• Copia los datos de entrenamiento y validación en la instancia.
• ejecuta el entrenamiento
• Recopila métricas y registros
• Recopila y almacena el modelo entrenado

Luego pasamos a AMT y ejecutamos un trabajo de HPO:

• Configuramos y lanzamos nuestro trabajo de ajuste con AMT
• Nos sumergimos en los métodos disponibles para extraer métricas de rendimiento y metadatos detallados para cada trabajo de entrenamiento, lo que nos permite aprender más sobre los valores óptimos en nuestro espacio de hiperparámetros.
• Te mostramos cómo visualizar los resultados de los ensayos
• Le proporcionamos herramientas para visualizar datos en una serie de gráficos que revelan información valiosa sobre nuestro espacio de hiperparámetros

Entrene un algoritmo XGBoost integrado de SageMaker

Todo comienza con la formación de un modelo. Al hacerlo, tenemos una idea de cómo funciona SageMaker Training.

Queremos aprovechar la velocidad y facilidad de uso que ofrece SageMaker algoritmos incorporados. Todo lo que necesitamos son unos pocos pasos para comenzar con el entrenamiento:

1. Preparar y cargar los datos. – Descargamos y preparamos nuestro conjunto de datos como entrada para XGBoost y lo subimos a nuestro Servicio de almacenamiento simple de Amazon (Amazon S3) cubo.
2. Seleccione el URI de imagen de nuestro algoritmo incorporado – SageMaker usa este URI para obtener nuestro contenedor de capacitación, que en nuestro caso contiene un script de capacitación XGBoost listo para usar. Se admiten varias versiones de algoritmo.
3. Definir los hiperparámetros – SageMaker proporciona una interfaz para definir el hiperparámetros para nuestro algoritmo integrado. Estos son los mismos hiperparámetros que utiliza la versión de código abierto.
4. Construya el estimador – Definimos los parámetros de entrenamiento como tipo de instancia y número de instancias.
5. Llamar a la función fit() – Comenzamos nuestro trabajo de entrenamiento.

El siguiente diagrama muestra cómo estos pasos funcionan juntos.

proporcionar los datos

Para ejecutar el entrenamiento de ML, necesitamos proporcionar datos. Proporcionamos nuestros datos de capacitación y validación a SageMaker a través de Amazon S3.

En nuestro ejemplo, para simplificar, usamos el depósito predeterminado de SageMaker para almacenar nuestros datos. Pero siéntete libre de personalizar los siguientes valores según tus preferencias:

sm_sess = sagemaker.session.Session([..])

BUCKET = sm_sess.default_bucket()
PREFIX = 'amt-visualize-demo'
output_path = f's3://{BUCKET}/{PREFIX}/output'

En el cuaderno, usamos un conjunto de datos público y almacenamos los datos localmente en el data directorio. Luego subimos nuestros datos de capacitación y validación a Amazon S3. Posteriormente, también definimos punteros a estas ubicaciones para pasarlas a SageMaker Training.

# acquire and prepare the data (not shown here)
# store the data locally
[..]
train_data.to_csv('data/train.csv', index=False, header=False)
valid_data.to_csv('data/valid.csv', index=False, header=False)
[..]
# upload the local files to S3
boto_sess.resource('s3').Bucket(BUCKET).Object(os.path.join(PREFIX, 'data/train/train.csv')).upload_file('data/train.csv')
boto_sess.resource('s3').Bucket(BUCKET).Object(os.path.join(PREFIX, 'data/valid/valid.csv')).upload_file('data/valid.csv')

En esta publicación, nos concentramos en presentar HPO. A modo de ilustración, usamos un conjunto de datos y una tarea específicos, de modo que podamos obtener medidas de métricas objetivas que luego usamos para optimizar la selección de hiperparámetros. Sin embargo, para la publicación general, ni los datos ni la tarea importan. Para presentarle una imagen completa, describamos brevemente lo que hacemos: entrenamos un modelo XGBoost que debería clasificar los dígitos escritos a mano del
Conjunto de datos de reconocimiento óptico de dígitos escritos a mano [1] a través de Scikit-learn. XGBoost es un excelente algoritmo para datos estructurados e incluso se puede aplicar al conjunto de datos Digits. Los valores son imágenes de 8×8, como en el siguiente ejemplo que muestra un
0 a
5 y
4.

Seleccione el URI de la imagen XGBoost

Después de elegir nuestro algoritmo integrado (XGBoost), debemos recuperar el URI de la imagen y pasarlo a SageMaker para cargarlo en nuestra instancia de entrenamiento. Para este paso, revisamos el versiones disponibles. Aquí hemos decidido utilizar la versión 1.5.1, que ofrece la última versión del algoritmo. Según la tarea, los profesionales de ML pueden escribir su propio script de capacitación que, por ejemplo, incluye pasos de preparación de datos. Pero esto no es necesario en nuestro caso.

Si desea escribir su propio guión de capacitación, permanezca atento, ¡lo cubrimos en nuestra próxima publicación! Le mostraremos cómo ejecutar trabajos de capacitación de SageMaker con sus propios scripts de capacitación personalizados.

Por ahora, necesitamos el URI de imagen correcto especificando el algoritmo, la región de AWS y el número de versión:

xgboost_container = sagemaker.image_uris.retrieve('xgboost', region, '1.5-1')

Eso es todo. Ahora tenemos una referencia al algoritmo XGBoost.

Definir los hiperparámetros

Ahora definimos nuestros hiperparámetros. Estos valores configuran cómo se entrenará nuestro modelo y, finalmente, influyen en el rendimiento del modelo en comparación con la métrica objetiva con la que estamos midiendo, como la precisión en nuestro caso. Tenga en cuenta que nada en el siguiente bloque de código es específico de SageMaker. En realidad estamos usando el versión de código abierto de XGBoost, proporcionado y optimizado para SageMaker.

Aunque cada uno de estos hiperparámetros son configurables y ajustables, la métrica objetiva multi:softmax está determinado por nuestro conjunto de datos y el tipo de problema que estamos resolviendo. En nuestro caso, el conjunto de datos Dígitos contiene múltiples etiquetas (una observación de un dígito escrito a mano podría ser 0 or 1,2,3,4,5,6,7,8,9), lo que significa que es un problema de clasificación multiclase.

hyperparameters = {
    'num_class': 10,
    'max_depth': 5,
    'eta':0.2,
    'alpha': 0.2,
    'objective':'multi:softmax',
    'eval_metric':'accuracy',
    'num_round':200,
    'early_stopping_rounds': 5
}

Para obtener más información sobre los otros hiperparámetros, consulte Hiperparámetros XGBoost.

Construya el estimador

Configuramos el entrenamiento en un objeto estimador, que es una interfaz de alto nivel para SageMaker Training.

A continuación, definimos la cantidad de instancias en las que entrenar, el tipo de instancia (basada en CPU o basada en GPU) y el tamaño del almacenamiento adjunto:

estimator = sagemaker.estimator.Estimator(
    image_uri=xgboost_container, 
    hyperparameters=hyperparameters,
    role=role,
    instance_count=1, 
    instance_type='ml.m5.large', 
    volume_size=5, # 5 GB 
    output_path=output_path
)

Ahora tenemos la configuración de infraestructura que necesitamos para comenzar. SageMaker Training se encargará del resto.

Llamar a la función fit()

¿Recuerda los datos que subimos a Amazon S3 anteriormente? Ahora creamos referencias a él:

s3_input_train = TrainingInput(s3_data=f's3://{BUCKET}/{PREFIX}/data/train', content_type='csv')
s3_input_valid = TrainingInput(s3_data=f's3://{BUCKET}/{PREFIX}/data/valid', content_type='csv')

Una llamada a fit() lanza nuestra formación. Pasamos las referencias a los datos de entrenamiento que acabamos de crear para señalar SageMaker Training a nuestros datos de entrenamiento y validación:

estimator.fit({'train': s3_input_train, 'validation': s3_input_valid})

Tenga en cuenta que para ejecutar HPO más adelante, en realidad no necesitamos llamar fit() aquí. Solo necesitamos el objeto estimador más adelante para HPO, y podríamos pasar a crear nuestro trabajo de HPO. Pero como queremos obtener información sobre SageMaker Training y ver cómo ejecutar un solo trabajo de capacitación, lo llamamos aquí y revisamos el resultado.

Una vez que comienza el entrenamiento, comenzamos a ver el resultado debajo de las celdas, como se muestra en la siguiente captura de pantalla. La salida está disponible en Reloj en la nube de Amazon así como en este cuaderno.

El texto negro es la salida de registro del mismo SageMaker, que muestra los pasos involucrados en la orquestación de entrenamiento, como iniciar la instancia y cargar la imagen de entrenamiento. El texto azul se emite directamente desde la propia instancia de entrenamiento. Podemos observar el proceso de carga y análisis de los datos de entrenamiento, y ver visualmente el progreso del entrenamiento y la mejora en la métrica objetiva directamente desde el script de entrenamiento que se ejecuta en la instancia.

También tenga en cuenta que al final del trabajo de salida, se muestran la duración del entrenamiento en segundos y los segundos facturables.

Finalmente, vemos que SageMaker carga nuestro modelo de entrenamiento en la ruta de salida de S3 definida en el objeto estimador. El modelo está listo para implementarse para la inferencia.

En una publicación futura, crearemos nuestro propio contenedor de capacitación y definiremos nuestras métricas de capacitación para emitir. Verá cómo SageMaker es independiente del contenedor que le pasa para el entrenamiento. Esto es muy útil para cuando desea comenzar rápidamente con un algoritmo integrado, ¡pero luego decide pasar su propio script de entrenamiento personalizado!

Inspeccionar trabajos de capacitación actuales y anteriores

Hasta ahora, hemos trabajado desde nuestro cuaderno con nuestro código y enviado trabajos de capacitación a SageMaker. Cambiemos de perspectiva y dejemos el cuaderno por un momento para ver cómo se ve esto en la consola de SageMaker.

SageMaker mantiene un registro histórico de los trabajos de capacitación que ejecutó, sus configuraciones, como hiperparámetros, algoritmos, entrada de datos, el tiempo facturable y los resultados. En la lista de la captura de pantalla anterior, verá los trabajos de capacitación más recientes filtrados para XGBoost. El trabajo de entrenamiento resaltado es el trabajo que acabamos de entrenar en el cuaderno, cuyo resultado viste antes. Profundicemos en este trabajo de capacitación individual para obtener más información.

La siguiente captura de pantalla muestra la vista de consola de nuestro trabajo de entrenamiento.

Podemos revisar la información que recibimos como salida de celda a nuestro fit() función en el trabajo de entrenamiento individual dentro de la consola de SageMaker, junto con los parámetros y metadatos que definimos en nuestro estimador.

Recuerde la salida del registro de la instancia de entrenamiento que vimos anteriormente. Aquí también podemos acceder a los registros de nuestro trabajo de entrenamiento, desplazándonos hasta el Monitorear sección y elección Ver los registros.

Esto nos muestra los registros de la instancia dentro de CloudWatch.

Recuerde también los hiperparámetros que especificamos en nuestro cuaderno para el trabajo de entrenamiento. Los vemos aquí en la misma interfaz de usuario del trabajo de entrenamiento también.

De hecho, los detalles y metadatos que especificamos anteriormente para nuestro trabajo de capacitación y estimador se pueden encontrar en esta página en la consola de SageMaker. Tenemos un registro útil de la configuración utilizada para la capacitación, como qué contenedor de capacitación se usó y las ubicaciones de los conjuntos de datos de capacitación y validación.

Es posible que se pregunte en este punto, ¿por qué exactamente esto es relevante para la optimización de hiperparámetros? Es porque puede buscar, inspeccionar y profundizar en los ensayos de HPO que nos interesan. Tal vez los que tienen los mejores resultados o los que muestran un comportamiento interesante. Te dejamos a ti lo que defines como “interesante”. Nos brinda una interfaz común para inspeccionar nuestros trabajos de capacitación y puede usarla con SageMaker Search.

Si bien SageMaker AMT organiza los trabajos de HPO, todas las pruebas de HPO se inician como trabajos de capacitación de SageMaker individuales y se puede acceder a ellos como tales.

Con el entrenamiento cubierto, ¡vamos a sintonizar!

Entrene y ajuste un algoritmo XGBoost incorporado de SageMaker

Para ajustar nuestro modelo XGBoost, vamos a reutilizar nuestros hiperparámetros existentes y definir rangos de valores que queremos explorar para ellos. Piense en esto como una extensión de las fronteras de exploración dentro de nuestro espacio de búsqueda de hiperparámetros. Nuestro trabajo de ajuste tomará muestras del espacio de búsqueda y ejecutará trabajos de entrenamiento para nuevas combinaciones de valores. El siguiente código muestra cómo especificar los rangos de hiperparámetros de los que debe tomar muestras SageMaker AMT:

from sagemaker.tuner import IntegerParameter, ContinuousParameter, HyperparameterTuner

hpt_ranges = {
    'alpha': ContinuousParameter(0.01, .5),
    'eta': ContinuousParameter(0.1, .5),
    'min_child_weight': ContinuousParameter(0., 2.),
    'max_depth': IntegerParameter(1, 10)
}

Los rangos para un hiperparámetro individual se especifican por su tipo, como Parámetro continuo. Para obtener más información y sugerencias sobre cómo elegir estos rangos de parámetros, consulte Sintonice un modelo XGBoost.

Todavía no hemos realizado ningún experimento, por lo que no conocemos los rangos de buenos valores para nuestros hiperparámetros. Por lo tanto, comenzamos con una conjetura fundamentada, utilizando nuestro conocimiento de los algoritmos y nuestra documentación de los hiperparámetros para los algoritmos integrados. Esto define un punto de partida para definir el espacio de búsqueda.

Luego ejecutamos un trabajo de ajuste que muestra los hiperparámetros en los rangos definidos. Como resultado, podemos ver qué rangos de hiperparámetros dan buenos resultados. Con este conocimiento, podemos refinar los límites del espacio de búsqueda estrechando o ampliando los rangos de hiperparámetros a utilizar. Demostramos cómo aprender de los ensayos en la siguiente y última sección, donde investigamos y visualizamos los resultados.

En nuestra próxima publicación, continuaremos nuestro viaje y profundizaremos más. Además, aprenderemos que hay varias estrategias que podemos usar para explorar nuestro espacio de búsqueda. Ejecutaremos trabajos posteriores de HPO para encontrar valores aún más eficaces para nuestros hiperparámetros, mientras comparamos estas diferentes estrategias. También veremos cómo ejecutar un comienzo en caliente con SageMaker AMT para usar el conocimiento obtenido de los espacios de búsqueda explorados previamente en nuestra exploración más allá de esos límites iniciales.

Para esta publicación, nos enfocamos en cómo analizar y visualizar los resultados de un solo trabajo de HPO utilizando la estrategia de búsqueda bayesiana, que probablemente sea un buen punto de partida.

Si sigue el cuaderno vinculado, tenga en cuenta que pasamos el mismo estimador que usamos para nuestro único trabajo de entrenamiento integrado de XGBoost. Este objeto estimador actúa como una plantilla para los nuevos trabajos de capacitación que crea AMT. AMT luego variará los hiperparámetros dentro de los rangos que definimos.

Al especificar que queremos maximizar nuestra métrica objetivo, validation:accuracy, le indicamos a SageMaker AMT que busque estas métricas en los registros de instancias de capacitación y elija valores de hiperparámetros que crea que maximizarán la métrica de precisión en nuestros datos de validación. Elegimos un apropiado métrica objetiva para XGBoost de nuestra documentación.

Además, podemos aprovechar la paralelización con max_parallel_jobs. Esta puede ser una herramienta poderosa, especialmente para estrategias cuyas pruebas se seleccionan de forma independiente, sin considerar (aprender de) los resultados de pruebas anteriores. Exploraremos estas otras estrategias y parámetros más a fondo en nuestra próxima publicación. Para esta publicación, usamos Bayesian, que es una excelente estrategia predeterminada.

También definimos max_jobs para definir cuántos ensayos ejecutar en total. Siéntase libre de desviarse de nuestro ejemplo y usar un número más pequeño para ahorrar dinero.

n_jobs = 50
n_parallel_jobs = 3

tuner_parameters = {
    'estimator': estimator, # The same estimator object we defined above
    'base_tuning_job_name': 'bayesian',
    'objective_metric_name': 'validation:accuracy',
    'objective_type': 'Maximize',
    'hyperparameter_ranges': hpt_ranges,
    'strategy': 'Bayesian',
    'max_jobs': n_jobs,
    'max_parallel_jobs': n_parallel_jobs
}

Volvemos a llamar fit(), de la misma manera que cuando lanzamos un solo trabajo de capacitación anteriormente en la publicación. Pero esta vez en el objeto sintonizador, no en el objeto estimador. Esto inicia el trabajo de ajuste y, a su vez, AMT comienza los trabajos de entrenamiento.

tuner = HyperparameterTuner(**tuner_parameters)
tuner.fit({'train': s3_input_train, 'validation': s3_input_valid}, wait=False)
tuner_name = tuner.describe()['HyperParameterTuningJobName']
print(f'tuning job submitted: {tuner_name}.')

El siguiente diagrama amplía nuestra arquitectura anterior al incluir HPO con SageMaker AMT.

Vemos que nuestro trabajo HPO ha sido enviado. Dependiendo del número de intentos, definido por n_jobs y el nivel de paralelización, esto puede llevar algún tiempo. Para nuestro ejemplo, puede tomar hasta 30 minutos para 50 pruebas con solo un nivel de paralelización de 3.

tuning job submitted: bayesian-221102-2053.

Cuando finalice este trabajo de ajuste, exploremos la información disponible en la consola de SageMaker.

Investigue los trabajos de AMT en la consola

Busquemos nuestro trabajo de ajuste en la consola de SageMaker eligiendo Formación en el panel de navegación y luego Trabajos de ajuste de hiperparámetros. Esto nos da una lista de nuestros trabajos de AMT, como se muestra en la siguiente captura de pantalla. Aquí ubicamos nuestro bayesian-221102-2053 ajuste el trabajo y descubra que ahora está completo.

Echemos un vistazo más de cerca a los resultados de este trabajo de HPO.

Hemos explorado extraer los resultados programáticamente en el cuaderno. Primero a través de la SDK de SageMaker Python, que es una biblioteca Python de código abierto de nivel superior que proporciona una API dedicada a SageMaker. Luego a través boto3, que nos proporciona API de nivel inferior para SageMaker y otros servicios de AWS.

Utilizando el SDK de Python de SageMaker, podemos obtener los resultados de nuestro trabajo de HPO:

sagemaker.HyperparameterTuningJobAnalytics(tuner_name).dataframe()[:10]

Esto nos permitió analizar los resultados de cada una de nuestras pruebas en un Pandas DataFrame, como se ve en la siguiente captura de pantalla.

Ahora cambiemos de perspectiva nuevamente y veamos cómo se ven los resultados en la consola de SageMaker. Luego veremos nuestras visualizaciones personalizadas.

En la misma página, eligiendo nuestro bayesian-221102-2053 el trabajo de ajuste nos proporciona una lista de las pruebas que se ejecutaron para nuestro trabajo de ajuste. Cada prueba de HPO aquí es un trabajo de capacitación de SageMaker. Recuerde anteriormente cuando entrenamos nuestro único modelo XGBoost e investigamos el trabajo de entrenamiento en la consola de SageMaker. Podemos hacer lo mismo para nuestras pruebas aquí.

Al investigar nuestras pruebas, vemos que bayesian-221102-2053-048-b59ec7b4 creó el modelo de mejor desempeño, con una precisión de validación de aproximadamente 89.815%. Exploremos qué hiperparámetros condujeron a este rendimiento eligiendo el Mejor trabajo de entrenamiento .

Podemos ver una vista detallada de los mejores hiperparámetros evaluados.

Podemos ver de inmediato qué valores de hiperparámetro llevaron a este rendimiento superior. Sin embargo, queremos saber más. ¿Puedes adivinar qué? Vemos eso alpha toma un valor aproximado de 0.052456 y, asimismo, eta se establece en 0.433495. Esto nos dice que estos valores funcionaron bien, pero nos dice poco sobre el propio espacio de hiperparámetros. Por ejemplo, podríamos preguntarnos si 0.433495 para eta fue el valor más alto probado, o si hay espacio para el crecimiento y la mejora del modelo al seleccionar valores más altos.

Para eso, necesitamos alejarnos y tener una vista mucho más amplia para ver cómo se desempeñaron otros valores para nuestros hiperparámetros. Una forma de ver una gran cantidad de datos a la vez es trazar nuestros valores de hiperparámetros de nuestras pruebas de HPO en un gráfico. De esa manera vemos cómo estos valores se comportaron relativamente. En la siguiente sección, extraemos estos datos de SageMaker y los visualizamos.

Visualiza nuestras pruebas

El SDK de SageMaker nos proporciona los datos para nuestra exploración, y los cuadernos le dan un vistazo a eso. Pero hay muchas formas de utilizarlo y visualizarlo. En esta publicación, compartimos una muestra usando el Altair biblioteca de visualización estadística, que utilizamos para producir una descripción más visual de nuestros ensayos. Estos se encuentran en el amtviz paquete, que proporcionamos como parte de la muestra:

from amtviz import visualize_tuning_job
visualize_tuning_job(tuner, trials_only=True)

El poder de estas visualizaciones se hace evidente de inmediato al trazar la precisión de validación de nuestros ensayos (eje y) a lo largo del tiempo (eje x). El siguiente gráfico de la izquierda muestra la precisión de la validación a lo largo del tiempo. Podemos ver claramente que el rendimiento del modelo mejora a medida que realizamos más pruebas con el tiempo. Este es un resultado directo y esperado de ejecutar HPO con una estrategia bayesiana. En nuestra próxima publicación, vemos cómo se compara esto con otras estrategias y observamos que no es necesario que sea así para todas las estrategias.

Después de revisar el progreso general a lo largo del tiempo, ahora veamos nuestro espacio de hiperparámetros.

Los siguientes gráficos muestran la precisión de la validación en el eje y, y cada gráfico muestra max_depth, alpha, etay min_child_weight en el eje x, respectivamente. Hemos trazado todo nuestro trabajo de HPO en cada gráfico. Cada punto es una sola prueba y cada gráfico contiene las 50 pruebas, pero separadas para cada hiperparámetro. Esto significa que nuestra prueba de mejor rendimiento, la n.º 48, está representada exactamente por un punto azul en cada uno de estos gráficos (que hemos resaltado para usted en la siguiente figura). Podemos comparar visualmente su desempeño dentro del contexto de los otros 49 ensayos. Entonces, echemos un vistazo de cerca.

¡Fascinante! ¡Vemos de inmediato qué regiones de nuestros rangos definidos en nuestro espacio de hiperparámetros tienen el mejor rendimiento! Pensando en nuestro eta valor, ahora está claro que los valores de muestreo más cercanos a 0 arrojaron un peor rendimiento, mientras que moverse más cerca de nuestro límite, 0.5, produce mejores resultados. Lo contrario parece ser cierto para alphay max_depth parece tener un conjunto más limitado de valores preferidos. Mirando a max_depth, también puede ver cómo el uso de una estrategia bayesiana le indica a SageMaker AMT que pruebe con más frecuencia los valores que aprendió que funcionaron bien en el pasado.

Mirando nuestro eta valor, podríamos preguntarnos si vale la pena explorar más a la derecha, ¿quizás más allá de 0.45? ¿Continúa perdiendo precisión o necesitamos más datos aquí? Esta pregunta es parte del propósito de ejecutar nuestro primer trabajo de HPO. Nos proporciona información sobre qué áreas del espacio de hiperparámetros debemos explorar más a fondo.

Si está interesado en saber más y está tan entusiasmado como nosotros con esta introducción al tema, permanezca atento a nuestra próxima publicación, donde hablaremos más sobre las diferentes estrategias de HPO, las compararemos entre sí y practique el entrenamiento con nuestro propio script de Python.

Limpiar

Para evitar incurrir en costos no deseados cuando termine de experimentar con HPO, debe eliminar todos los archivos en su depósito S3 con el prefijo amt-visualize-demo y también cerrar los recursos de Studio.

Ejecute el siguiente código en su computadora portátil para eliminar todos los archivos S3 de esta publicación.

!aws s3 rm s3://{BUCKET}/amt-visualize-demo --recursive

Si desea conservar los conjuntos de datos o los artefactos del modelo, puede modificar el prefijo en el código para amt-visualize-demo/data solo borrar los datos o amt-visualize-demo/output para eliminar solo los artefactos del modelo.

Conclusión

En esta publicación, entrenamos y ajustamos un modelo usando la versión integrada de SageMaker del algoritmo XGBoost. Al usar HPO con SageMaker AMT, aprendimos sobre los hiperparámetros que funcionan bien para este algoritmo y conjunto de datos en particular.

Vimos varias formas de revisar los resultados de nuestro trabajo de ajuste de hiperparámetros. Comenzando con la extracción de los hiperparámetros de la mejor prueba, también aprendimos cómo obtener una comprensión más profunda de cómo habían progresado nuestras pruebas con el tiempo y qué valores de hiperparámetro son impactantes.

Usando la consola de SageMaker, también vimos cómo profundizar en las ejecuciones de entrenamiento individuales y revisar sus registros.

Luego nos alejamos para ver todos nuestros ensayos juntos y revisamos su desempeño en relación con otros ensayos e hiperparámetros.

Aprendimos que, según las observaciones de cada prueba, pudimos navegar por el espacio de hiperparámetros para ver que pequeños cambios en nuestros valores de hiperparámetros pueden tener un gran impacto en el rendimiento de nuestro modelo. Con SageMaker AMT, podemos ejecutar la optimización de hiperparámetros para encontrar buenos valores de hiperparámetros de manera eficiente y maximizar el rendimiento del modelo.

En el futuro, analizaremos las diferentes estrategias de HPO que ofrece SageMaker AMT y cómo usar nuestro propio código de capacitación personalizado. Háganos saber en los comentarios si tiene alguna pregunta o desea sugerir un área que deberíamos cubrir en las próximas publicaciones.

Hasta entonces, ¡les deseamos a usted y a sus modelos un feliz aprendizaje y ajuste!

Referencias

Citaciones:

[1] Dua, D. y Graff, C. (2019). Depósito de aprendizaje automático de UCI [http://archive.ics.uci.edu/ml]. Irvine, CA: Universidad de California, Escuela de Información e Informática.

Sobre los autores

andres ellul es un Arquitecto de Soluciones con Amazon Web Services. Trabaja con pequeñas y medianas empresas en Alemania. Fuera del trabajo, a Andrew le gusta explorar la naturaleza a pie o en bicicleta.

elina lesyk es un arquitecto de soluciones ubicado en Munich. Su atención se centra en los clientes empresariales de la industria de servicios financieros. En su tiempo libre, a Elina le gusta aprender teoría de la guitarra en español para intercalar y salir a correr.

Mariano Campo es Arquitecto Principal de Soluciones en Amazon Web Services. Trabaja con clientes de servicios financieros en Alemania en aprendizaje automático. En su tiempo libre, Mariano disfruta de caminatas con su esposa.