Iniciando Machine Learning en Amazon SageMaker

Iniciando Sagemaker ML

En este tutorial te enseñare un poco de Sagemaker usando un ejemplo sencillo de Machine Learning.

GitHub del tutorial: https://github.com/elizabethfuentes12/Iniciando_SagemakerML

¿Que es Sagemaker?

Aprendizaje automático al alcance de cualquier científico de datos y desarrollador.

Amazon SageMaker ayuda a los científicos de datos y a los desarrolladores a preparar, crear, entrenar e implementar con rapidez modelos de aprendizaje automático de alta calidad al poner a disposición un amplio conjunto de capacidades especialmente creadas para el aprendizaje automático.

Video: Introduction to Amazon SageMaker

Casos de Uso

• Mantenimiento predictivo
• Visión artificial
• Conducción autónoma
• Detección de fraudes
• Predicción de riesgos crediticios
• Extracción y análisis de datos a partir de documentos
• Predicción de pérdida de clientes
• Previsión de demanda
• Recomendaciones personalizadas

Fuente y github con modelos: Casos de uso

Algoritmos integrados de AWS Sagemaker

Fuente: https://docs.aws.amazon.com/es_es/sagemaker/latest/dg/algos.html

AWS Sagemaker proporciona una serie de algoritmos integrados que ayuda a mejorar la preforma del aprendizaje automático.

Tutorial Crear, entrenar e implementar un modelo de Machine Learning con AWS Sagemaker

Fuente: https://aws.amazon.com/es/getting-started/hands-on/build-train-deploy-machine-learning-model-sagemaker/

Siguiendo los siguientes pasos aprenderá a utilizar Amazon SageMaker para crear, entrenar e implementar un modelo de aprendizaje automático (ML). Para este ejercicio, utilizaremos el conocido algoritmo de aprendizaje automático XGBoost el cual esta integrado en Sagemaker.

En este tutorial, asumirás el rol de un desarrollador de machine learning que trabaja en un banco. Se le solicita desarrollar un modelo de machine learning para predecir si los clientes se inscribirán para un certificado de depósito. El modelo se entrenará con el conjunto de datos de marketing que contiene la información demográfica de los clientes, sus respuestas a los eventos de marketing y los factores externos.

Los datos se etiquetaron para su conveniencia. Una columna en el conjunto de datos identifica si el cliente está inscrito para algún producto que ofrece el banco. Una versión de este conjunto de datos está disponible para el público en el repositorio de aprendizaje automático a cargo de la Universidad de California, Irvine. Este tutorial implementa un modelo de aprendizaje automático supervisado debido a que los datos están etiquetados. (El aprendizaje no supervisado tiene lugar cuando los conjuntos de datos no están etiquetados).

En este tutorial, hará lo siguiente:

1. Creará una instancia de bloc de notas
2. Preparará los datos
3. Entrenará el modelo para aprender de los datos
4. Implementará el modelo
5. Evaluará el rendimiento de su modelo de aprendizaje automático

Los recursos creados y utilizados en este tutorial se pueden utilizar en la capa gratuita de AWS. Recuerde completar el Paso 7 y terminar sus recursos. Si su cuenta ha estado activa con estos recursos por más de dos meses, se cobrará menos de 0,50 USD por ella.

A continuación un diagrama de lo que haremos.

Paso 0: ¿Que es XGBoost?

Es una implementación de código abierto popular y eficiente del algoritmo de árboles aumentados de gradientes. La potenciación de gradientes es un algoritmo de aprendizaje supervisado que intenta predecir de forma apropiada una variable de destino mediante la combinación de un conjunto de estimaciones a partir de un conjunto de modelos más simples y más débiles. Funciona bien en competiciones de aprendizaje automático debido a su manejo robusto de una variedad de tipos de datos, relaciones, distribuciones y la variedad de hiperparámetros que puede ajustar.

Puede usar XGBoost para problemas de regresión, de clasificación (binaria y multiclase) y de ranking.

Fuente: AWS XGBoost

Más sobre XGBoost --> Boosting - EXPLAINED!

Paso 1: Abra la consola de Amazon SageMaker

Diríjase a la consola de Amazon SageMaker.

Abra SageMaker

Paso 2: Cree una instancia de bloc de notas de Amazon SageMaker

En este paso, creará una instancia de bloc de notas de Amazon SageMaker.

2.a

Abra notebook instances

y seleccione Create notebook Instance en la parte superior derecha

2b.

En la página Crear instancia de bloc de notas, escriba un nombre en el campo Nombre de la instancia de bloc de notas. Este tutorial utiliza MySageMakerInstance como nombre de la instancia, pero puede elegir un nombre diferente si lo desea.

Para este tutorial, puede mantener el Tipo de instancia de bloc de notas predeterminado ml.t2.medium.

Para permitir que la instancia de bloc de notas acceda a Amazon S3 y pueda cargar datos de manera segura en este servicio, se debe especificar un rol de IAM. En el campo Rol de IAM, elija Crear un nuevo rol para que Amazon SageMaker cree un rol con los permisos necesarios y lo asigne a su instancia. De forma alternativa, puede elegir un rol de IAM existente en su cuenta para este fin.

2c.

En el cuadro Crear un rol de IAM, seleccione Cualquier bucket de S3. Esto permite que su instancia de Amazon SageMaker acceda a todos los buckets de S3 de su cuenta. Más adelante en este tutorial, creará un nuevo bucket de S3. Sin embargo, si ya cuenta con un bucket que desea utilizar, seleccione Buckets de S3 específicos e indique el nombre del bucket.

Elija Crear rol.

2d.

Tenga en cuenta que Amazon SageMaker creó para usted un rol denominado AmazonSageMaker-ExecutionRole-***.

Para este tutorial, utilizaremos los valores predeterminados en los demás campos. Elija Crear instancia de bloc de
notas.

2e.

En la página Instancias de bloc de notas, debería ver su nueva instancia de bloc de notas MySageMakerInstance con el estado Pendiente.

Su instancia de bloc de notas debería pasar del estado Pendiente al estado En servicio en menos de dos minutos.

2f

Para este paso debes detener la instancia en Acciones --> Detener

Evita que la instancia de SageMaker se quede activa cuando no la estés usando y así no incurrir en gastos innecesarios, para eso debes agregar la Configuración del ciclo de vida.

Esto lo puedes realizar al momento de crear la maquina o luego de crearla editando la configuración.

Entra a la configuración de la instancia dando click sobre su nombre:

Presiona editar, arriba a la derecha, en Configuración adicional selecciona Crear una nueva configuración de ciclo de vida, en la ventana emergente nombralo como prefieras y abre la lista de scripts para iniciar:

El link te llevara al GitHub amazon-sagemaker-notebook-instance-lifecycle-config-samples , entra a la carpeta scripts --> auto-stop-idle y copia el codigo en on-start.sh

Pega el codigo en la ventana emergente y avanza con Crear una configuración

2e

Agrega un repositorio Git a tu instancia.

En la misma edición del paso anterior, ve al fondo donde dice Repositorios Git - opcional, selecciona Clone un repositorio Git público en esta instancia de bloc de notas solamente y copia el repositorio creado para este ejemplo Iniciando_SagemakerML

Finaliza con Actualizar instancia del bloc de notas

Paso 3: Prepare los datos

En este paso, utilizará su bloc de notas de Amazon SageMaker a fin de procesar previamente los datos que necesita para entrenar su modelo de aprendizaje automático.

3a.

En la página Instancias de bloc de notas, aguarde hasta que la instancia MySageMakerInstance haya pasado del estado Pendiente al estado En servicio.

Después de que el estado cambie a En servicio, seleccione la instancia MySageMakerInstance y ábrala a través del menú desplegable Acciones o elija la opción Abrir JupyterLab, que aparece junto al estado En servicio.

3b.

Después de que Jupyter se abra, en la pestaña Archivos, elija Nuevo, Notebook y, luego, conda_python3.

3c.

Para preparar los datos, entrenar el modelo de aprendizaje automático e implementarlo, deberá importar algunas bibliotecas y definir algunas variables del entorno en su entorno de bloc de notas de Jupyter. Copie el siguiente código o ejecutelo directamente de la carpeta codigo en el GitHub creado para este tutorial en la celda de código de su instancia y seleccione Ejecutar o las teclas Shift+Enter.

# import libraries
import boto3, re, sys, math, json, os, sagemaker, urllib.request
from sagemaker import get_execution_role
import numpy as np                                
import pandas as pd                               
import matplotlib.pyplot as plt                   
from IPython.display import Image                 
from IPython.display import display               
from time import gmtime, strftime                 
from sagemaker.predictor import csv_serializer   
import sagemaker


# Define IAM role
role = get_execution_role()
prefix = 'sagemaker/DEMO-xgboost-dm'
containers = {'us-west-2': '433757028032.dkr.ecr.us-west-2.amazonaws.com/xgboost:latest',
              'us-east-1': '811284229777.dkr.ecr.us-east-1.amazonaws.com/xgboost:latest',
              'us-east-2': '825641698319.dkr.ecr.us-east-2.amazonaws.com/xgboost:latest',
              'eu-west-1': '685385470294.dkr.ecr.eu-west-1.amazonaws.com/xgboost:latest'} # each region has its XGBoost container
my_region = boto3.session.Session().region_name # set the region of the instance
print("Success - the MySageMakerInstance is in the " + my_region + " region. You will use the " + containers[my_region] + " container for your SageMaker endpoint.")

Al finalizar debe verse como la imagen a continuación:

3d.

En este paso, creará un bucket de S3 que almacenará sus datos para este tutorial.

Copie el siguiente código en la próxima celda de código de su bloc de notas y cambie el nombre del bucket de S3 para que sea único. Los nombres de los buckets de S3 deben ser únicos a nivel mundial y, además, deben contar con algunas restricciones y limitaciones.

Seleccione Ejecutar. Si no recibe un mensaje de finalización exitosa, cambie el nombre del bucket y vuelva a intentarlo.

bucket_name = 'your-s3-bucket-name' # <--- CHANGE THIS VARIABLE TO A UNIQUE NAME FOR YOUR BUCKET
s3 = boto3.resource('s3')
try:
    if  my_region == 'us-east-1':
      s3.create_bucket(Bucket=bucket_name)
    else: 
      s3.create_bucket(Bucket=bucket_name, CreateBucketConfiguration={ 'LocationConstraint': my_region })
    print('S3 bucket created successfully')
except Exception as e:
    print('S3 error: ',e)

3e.

A continuación, debe descargar los datos en su instancia de Amazon SageMaker y cargarlos en un marco de datos. Copie y Ejecute el siguiente código:

try:
  urllib.request.urlretrieve ("https://d1.awsstatic.com/tmt/build-train-deploy-machine-learning-model-sagemaker/bank_clean.27f01fbbdf43271788427f3682996ae29ceca05d.csv", "bank_clean.csv")
  print('Success: downloaded bank_clean.csv.')
except Exception as e:
  print('Data load error: ',e)

try:
  model_data = pd.read_csv('./bank_clean.csv',index_col=0)
  print('Success: Data loaded into dataframe.')
except Exception as e:
    print('Data load error: ',e)

Si la descarga es exitosa debe ver el siguiente mensaje:

Y el siguiente archivo aparecera en su instancia:

Con las siguientes columnas y datos binarios en ellas:

3f.

Ahora, mezclaremos los datos y los dividiremos en datos de entrenamiento y de prueba.

Los datos de entrenamiento (el 70 % de los clientes) se utilizarán durante el ciclo de entrenamiento del modelo. Utilizaremos la optimización basada en gradientes para refinar de forma iterativa los parámetros del modelo. La optimización basada en gradientes es una forma de encontrar valores de parámetros del modelo que minimicen sus errores, mediante el uso de gradientes de la función de pérdida del modelo.

Los datos de prueba (el 30 % restante de los clientes) se utilizarán para evaluar el rendimiento del modelo y para medir el nivel de generalización de los datos nuevos del modelo entrenado.

Copie el siguiente código en una nueva celda de código y seleccione Ejecutar para mezclar y dividir los datos:

train_data, test_data = np.split(model_data.sample(frac=1, random_state=1729), [int(0.7 * len(model_data))])
print(train_data.shape, test_data.shape)

Paso 4: Entrene el modelo con los datos

En este paso, entrenará su modelo de aprendizaje automático con el conjunto de datos de entrenamiento.

4a.

Para utilizar un modelo XGBoost prediseñado de Amazon SageMaker, deberá cambiar el formato del encabezado y la primera columna de los datos de entrenamiento y cargar los datos desde el bucket de S3.

Copie el siguiente código en una nueva celda de código y seleccione Ejecutar para cambiar el formato y cargar los datos:

(pd.concat([train_data['y_yes'], train_data.drop(['y_no', 'y_yes'], axis=1)], axis=1)
 .to_csv('train.csv', index=False, header=False))

(boto3.Session().resource('s3')
 .Bucket(bucket_name).Object(os.path.join(prefix, 'train/train.csv'))
 .upload_file('train.csv'))

from sagemaker.inputs import TrainingInput

s3_input_train = TrainingInput(s3_data='s3://{}/{}/train'.format(bucket_name, prefix), content_type='csv')

Crea el siguiente archivo:

4b.

A continuación, deberá configurar la sesión de Amazon SageMaker, crear una instancia del modelo XGBoost (un estimador) y definir los hiperparámetros del modelo. Copie el siguiente código en una nueva celda de código y seleccione Ejecutar:

sess = sagemaker.Session()
xgb = sagemaker.estimator.Estimator(containers[my_region],
                                    role, instance_count=1, 
                                    instance_type='ml.m4.xlarge',
                                    output_path='s3://{}/{}/output'.format(bucket_name, prefix),sagemaker_session=sess)
xgb.set_hyperparameters(max_depth=5,eta=0.2,gamma=4,min_child_weight=6,subsample=0.8,silent=0,objective='binary:logistic',num_round=100))

4c.

Con los datos cargados y el estimador XGBoost configurado, entrene el modelo a través de la optimización basada en gradientes en una instancia ml.m4.xlarge; copie el siguiente código en la próxima celda de código y seleccione Ejecutar.

xgb.fit({'train': s3_input_train})

Luego de algunos minutos, debería comenzar a ver los registros de entrenamiento que se generen.

Inicia:

Finaliza:

En la imagen anterior podemos ver que el entrenamiento duro 47 segundos, que es lo que se cobrara por la maquina usada en el contenedor.

Paso 5: Implemente el modelo

En este paso, implementará el modelo entrenado en un punto de enlace, cambiará el formato y cargará los datos CSV. Luego, ejecutará el modelo para crear predicciones.

5a.

Para implementar el modelo en un servidor y crear un punto de enlace al que pueda acceder, copie el siguiente código en la próxima celda de código y seleccione Ejecutar:

xgb_predictor = xgb.deploy(initial_instance_count=1,instance_type='ml.m4.xlarge')

Al finalizar debe verse asi:

Tambien lo puedes visualizar en Interferencia --> Puntos de enlace

5b.

Para predecir si los clientes de los datos de prueba se inscribieron o no en el producto del banco, copie el siguiente código en la próxima celda de código y seleccione Ejecutar:

from sagemaker.serializers import CSVSerializer

test_data_array = test_data.drop(['y_no', 'y_yes'], axis=1).values #load the data into an array

#xgb_predictor.content_type = 'text/csv' # set the data type for an inference
xgb_predictor.ContentType = 'text/csv' # set the data type for an inference
xgb_predictor.serializer = CSVSerializer() # set the serializer type
predictions = xgb_predictor.predict(test_data_array).decode('utf-8') # predict!
predictions_array = np.fromstring(predictions[1:], sep=',') # and turn the prediction into an array
print(predictions_array.shape)

Paso 6. Evalúe el rendimiento del modelo

En este paso, evaluará el rendimiento y la precisión del modelo de aprendizaje automático.

6a.

Copie y pegue el siguiente código y seleccione Ejecutar para comparar los valores reales con los valores predichos en una tabla denominada matriz de confusión.

cm = pd.crosstab(index=test_data['y_yes'], columns=np.round(predictions_array), rownames=['Observed'], colnames=['Predicted'])
tn = cm.iloc[0,0]; fn = cm.iloc[1,0]; tp = cm.iloc[1,1]; fp = cm.iloc[0,1]; p = (tp+tn)/(tp+tn+fp+fn)*100
print("\n{0:<20}{1:<4.1f}%\n".format("Tasa de clasificación general: ", p))
print("{0:<15}{1:<15}{2:>8}".format("Predictor", "No Inscritos", "Inscritos"))
print("Observed")
print("{0:<15}{1:<2.0f}% ({2:<}){3:>6.0f}% ({4:<})".format("No Inscritos", tn/(tn+fn)*100,tn, fp/(tp+fp)*100, fp))
print("{0:<16}{1:<1.0f}% ({2:<}){3:>7.0f}% ({4:<}) \n".format("Inscritos", fn/(tn+fn)*

El resultado del comando anterior es algo parecido a esto:

En función de las predicciones, podemos concluir que se predijo que el 89.5% de los clientes se inscribiría para un certificado de depósito, con una precisión del 65 % (278/429) para los inscritos y del 90 % (10 785/11 928) para los no inscritos.

6b.

Este modelo es bueno para predecir los clientes no inscritos, pero no para los inscritos.

El desempeño del modelo depende de la métrica y del objetivo que tenga, por ejemplo el modelo que predice SPAM lo que interesa es que no pasen los correos validos a spam, no importa recibir uno que otro spam en el inbox. Eso significa que puedo sacrificar un poco de falsos negativos (spam en el inbox) para minimizar los falsos positivos (correos validos a spam).

Para optimizar y llegar el desempeño óptimo debemos iterar el modelo, en una primera instancia cambiando los hiperparámetros para ver si otras combinaciones permiten entrenar un modelo que entregue mejores predicciones.

Los hiperparámetros ajustables del modelo XGBoost son los siguientes:

Los hiperparámetros que tienen el mayor efecto en la optimización de las métricas de evaluación de XGBoost son: alpha, min_child_weight, subsample eta, y num_round.

Sagemaker cuenta con una herramienta que permite automatizar todas estas entrenamientos de distintas combinaciones de HP el Trabajo de Ajuste de HP (HP Tunning JOB). Lo que hace es realizar un entrenamiento por cada combinación de HP que le digamos y nos entrega la mejor combinación de HP (que tiene la mejor métrica que le hayamos indicado)

Adicional

Para desplegar un endpoint a partir de un modelo entrenado por un trabajo en entrenamiento de SageMaker:

#Para instanciar el modelo
model_from_job = sagemaker.estimator.Estimator.attach(
    "xgboost-2021-04-21-02-30-09-428",
    sagemaker_session=sagemaker.Session())

Para lanzar el modelo en el contenedor. Al igual que el paso 5a y puedes continuar con el resto de los pasos.

model_from_job.deploy(initial_instance_count=1,instance_type='ml.m4.xlarge')

Para importar tu propio modelo entrenado a SageMaker

Primero lo debes subir a S3

from sagemaker.mxnet.model import MXNetModel

sagemaker_model = MXNetModel(model_data='s3://path/to/model.tar.gz',
                             role='arn:aws:iam::accid:sagemaker-role',
                             entry_point='entry_point.py')

Paso 7: Termine los recursos

En este paso, terminará los recursos relacionados con Amazon SageMaker.

Importante: Terminar los recursos que no se utilizan de forma activa reduce los costos, y es una práctica recomendada. No terminar sus recursos generará cargos.

7a.

Para eliminar el punto de enlace de Amazon SageMaker y los objetos de su bucket de S3, copie, pegue y Ejecute el siguiente código:

sagemaker.Session().delete_endpoint(xgb_predictor.endpoint)
bucket_to_delete = boto3.resource('s3').Bucket(bucket_name)
bucket_to_delete.objects.all().delete()

Para finalizar debes detener la instancia para evitar cargos adicionales, y si no la vas a utilizar más la puedes eliminar.

¡Felicitaciones!

Ha aprendido a utilizar Amazon SageMaker para preparar, entrenar, implementar y evaluar un modelo aprendizaje automático. Amazon SageMaker facilita la creación de modelos de aprendizaje automático y le proporciona todo lo necesario para conectarse rápidamente con los datos de entrenamiento y para seleccionar el mejor algoritmo y marco de trabajo para su aplicación, mientras administra la infraestructura subyacente completa, de manera que pueda entrenar modelos a escala de petabytes.

Ejemplos AWS Sagemaker

Para que continues aprendiendo te dejo un link con varios ejemplos para practicar:

https://github.com/aws/amazon-sagemaker-examples

Tip

La fuente original de este tutorial esta en una verion 1.X de XGBoost por lo que saltan algunos errores como el de la imagen:

Para corregirlos debes revisar la documentación de la version 2 de XGBoost

Esto lo puedes aplicar en errores similares en ejemplos de otros algoritmos.

¡Gracias!

Te dejo mis redes para que me sigas:
Dev.to
Linkedin
AWS Girls Chile