Creación y entrenamiento de un modelo de machine learning de forma local

TUTORIAL

Información general

En este tutorial, aprenderá a crear y entrenar un modelo de machine learning (ML) de forma local dentro de un cuaderno de Amazon SageMaker Studio.

Amazon SageMaker Studio es un entorno de desarrollo integrado (IDE) para ML que proporciona una interfaz de cuaderno de Jupyter totalmente administrada en la que puede realizar tareas de ciclo de vida de ML de extremo a extremo. Con SageMaker Studio, puede crear y explorar conjuntos de datos, preparar datos de entrenamiento, crear y entrenar modelos e implementar modelos entrenados para la inferencia, todo en un solo lugar.

Explorar una muestra del conjunto de datos e iterar sobre múltiples configuraciones de parámetros y modelos antes de entrenar con el conjunto de datos completo es una práctica común en el desarrollo de ML. Para esta etapa de exploración, Amazon SageMaker proporciona el modo local, que le permite probar su lógica de entrenamiento, probar diferentes enfoques de modelado y medir el rendimiento del modelo antes de ejecutar trabajos de entrenamiento a gran escala.

Para este tutorial, utilizará un conjunto de datos de reclamaciones de seguros de automóviles generado de forma sintética. Las entradas son los conjuntos de datos de entrenamiento y prueba, cada uno de los cuales contiene detalles y características extraídas sobre reclamaciones y clientes junto con una columna de fraude que indica si una reclamación fue fraudulento o no. Utilizará el marco XGBoost de código abierto para crear un prototipo de un modelo de clasificación binaria en este conjunto de datos sintético a fin de predecir la probabilidad de que una reclamación sea fraudulenta.

Lo que logrará

En esta guía, aprenderá a hacer lo siguiente:

  • Ingerir datos de entrenamiento de Amazon S3 en Amazon SageMaker.
  • Crear y entrenar un modelo XGBoost de forma local.
  • Guardar el modelo y los artefactos entrenados en Amazon S3.

Requisitos previos

Antes de comenzar esta guía, necesitará lo siguiente:

 Experiencia en AWS

Principiante

 Tiempo de realización

15 minutos

 Costo de realización

Consulte los precios de SageMaker para estimar el costo de este tutorial.

 Requisitos

Debe iniciar sesión en una cuenta de AWS.

 Servicios utilizados

Amazon SageMaker Studio

 Última actualización

7 de julio de 2022

Implementación

Paso 1: configurar el dominio de Amazon SageMaker Studio

Con Amazon SageMaker, puede implementar un modelo de forma visual a través de la consola o mediante programación con el uso de SageMaker Studio o cuadernos de SageMaker. En este tutorial, implementará el modelo por programación mediante un cuaderno de SageMaker Studio, que requiere un dominio de SageMaker Studio.

Una cuenta de AWS solo puede tener un dominio de SageMaker Studio por región. Si ya tiene un dominio de SageMaker Studio en la región Este de EE. UU. (Norte de Virginia), siga la guía de configuración de SageMaker Studio para adjuntar las políticas de AWS IAM requeridas a su cuenta de SageMaker Studio; luego omita el paso 1 y continúe directamente con el paso 2. 

Si no tiene un dominio de SageMaker Studio existente, continúe con el paso 1 a fin de ejecutar una plantilla de AWS CloudFormation que cree un dominio de SageMaker Studio y agregue los permisos necesarios para el resto de este tutorial.

Elija el enlace de la pila de AWS CloudFormation. Este enlace abre la consola de AWS CloudFormation y crea su dominio de SageMaker Studio y un usuario denominado studio-user. También agrega los permisos necesarios a su cuenta de SageMaker Studio. En la consola de CloudFormation, confirme que Este de EE. UU. (Norte de Virginia) sea la región que se muestra en la esquina superior derecha. El nombre de la pila debe ser CFN-SM-IM-Lambda-Catalog y no debe cambiarse. Esta pila tarda unos 10 minutos en crear todos los recursos.

Esta pila asume que ya tiene una VPC pública configurada en su cuenta. Si no tiene una VPC pública, consulte VPC con una única subred pública para obtener información sobre cómo crear una VPC pública. 

Seleccione I acknowledge that AWS CloudFormation might create IAM resources (Acepto que AWS CloudFormation podría crear recursos de IAM) y luego elija Create stack (Crear pila).

En el panel de CloudFormation, elija Stacks (Pilas). La pila tarda unos 10 minutos en crearse. Cuando se crea la pila, su estado cambia de CREATE_IN_PROGRESS a CREATE_COMPLETE

Paso 2: configurar un cuaderno de SageMaker Studio

En este paso, lanzará un nuevo cuaderno de SageMaker Studio, instalará las bibliotecas de código abierto necesarias y configurará las variables de SageMaker requeridas para interactuar con otros servicios, incluido Amazon Simple Storage Service (Amazon S3).

Ingrese SageMaker Studio en la barra de búsqueda de la consola y luego seleccione SageMaker Studio.

Elija US East (N. Virginia) (Este de EE. UU. [Norte de Virginia]) de la lista desplegable Region (Región) en la esquina superior derecha de la consola de SageMaker. En Launch app (Lanzar aplicación), seleccione Studio para abrir SageMaker Studio con el perfil studio-user.

Abra la interfaz de SageMaker Studio. En la barra de navegación, seleccione File (Archivo), New (Nuevo), Notebook (Cuaderno). 

En el cuadro de diálogo Set up notebook environment (Configurar entorno de cuaderno), en Image (Imagen), seleccione Data Science (Ciencia de datos). El kernel de Python 3 se selecciona automáticamente. Elija Select (Seleccionar). 

El kernel en la esquina superior derecha del cuaderno ahora debería mostrar Python 3 (Data Science) (Python 3 [Ciencia de datos]).

Copie y pegue el siguiente fragmento de código en una celda del cuaderno y presione Shift+Enter (Mayús+Intro) a fin de ejecutar la celda actual y actualizar la biblioteca aiobotocore, que es una API para interactuar con muchos de los servicios de AWS, e instale la biblioteca de XGBoost. Ignore cualquier advertencia para reiniciar el kernel o cualquier error de conflicto de dependencia.

%pip install --upgrade -q aiobotocore
%pip install -q  xgboost==1.3.1

También debe crear una instancia del objeto de cliente de S3 y definir las ubicaciones dentro de su bucket de S3 predeterminado donde se carga contenido como métricas y artefactos del modelo. Para hacer esto, copie y pegue el siguiente bloque de código y ejecute la celda. Tenga en cuenta que el nombre del bucket de escritura se deriva del objeto de sesión de SageMaker. Su bucket predeterminado tiene el nombre sagemaker-<your-Region>-<your-account-id>. Este bucket es donde se cargan todos los artefactos de entrenamiento. Los conjuntos de datos que utiliza para el entrenamiento existen en un bucket público de S3 llamado sagemaker-sample-files, que se especificó como el bucket de lectura. La ubicación en el bucket se especifica a través del prefijo de lectura.

import pandas as pd
import boto3
import sagemaker
import json
import joblib
import xgboost as xgb
from sklearn.metrics import roc_auc_score

# Set SageMaker and S3 client variables
sess = sagemaker.Session()

region = sess.boto_region_name
s3_client = boto3.client("s3", region_name=region)

sagemaker_role = sagemaker.get_execution_role()

# Set read and write S3 buckets and locations
write_bucket = sess.default_bucket()
write_prefix = "fraud-detect-demo"

read_bucket = "sagemaker-sample-files"
read_prefix = "datasets/tabular/synthetic_automobile_claims" 

train_data_key = f"{read_prefix}/train.csv"
test_data_key = f"{read_prefix}/test.csv"
model_key = f"{write_prefix}/model"
output_key = f"{write_prefix}/output"

train_data_uri = f"s3://{read_bucket}/{train_data_key}"
test_data_uri = f"s3://{read_bucket}/{test_data_key}"

Paso 3: entrenar un modelo XGBoost

En este paso, configurará y entrenará un modelo de clasificación binaria XGBoost en el conjunto de datos sintético de reclamaciones de seguros de automóviles y evaluará el rendimiento del modelo. Se utiliza la columna denominada fraude como la columna de destino. El objetivo es entrenar un clasificador binario XGBoost que pueda diferenciar las reclamaciones fraudulentas de las legítimas y medir el rendimiento del modelo de referencia.


El marco XGBoost de código abierto expone múltiples hiperparámetros que se pueden usar para controlar el rendimiento del modelo. A los fines de este tutorial, se establecen algunos de los hiperparámetros importantes y se elige el área bajo la curva de características operativas del receptor (ROC-AUC) como la métrica de evaluación. Copie y pegue el siguiente bloque de código en una celda y ejecútelo para realizar una validación cruzada y entrenar un modelo XGBoost. 

hyperparams = {
                "max_depth": 3,
                "eta": 0.2,
                "objective": "binary:logistic",
                "subsample" : 0.8,
                "colsample_bytree" : 0.8,
                "min_child_weight" : 3
              }

num_boost_round = 100
nfold = 3
early_stopping_rounds = 10



# Set up data input
label_col = "fraud"
data = pd.read_csv(train_data_uri)

# Read training data and target
train_features = data.drop(label_col, axis=1)
train_label = pd.DataFrame(data[label_col])
dtrain = xgb.DMatrix(train_features, label=train_label)

# Cross-validate on training data
cv_results = xgb.cv(
    params=hyperparams,
    dtrain=dtrain,
    num_boost_round=num_boost_round,
    nfold=nfold,
    early_stopping_rounds=early_stopping_rounds,
    metrics=["auc"],
    seed=10,
)


metrics_data = {
    "binary_classification_metrics": {
        "validation:auc": {
            "value": cv_results.iloc[-1]["test-auc-mean"],
            "standard_deviation": cv_results.iloc[-1]["test-auc-std"]
        },
        "train:auc": {
            "value": cv_results.iloc[-1]["train-auc-mean"],
            "standard_deviation": cv_results.iloc[-1]["train-auc-std"]
        },
    }
}


print(f"Cross-validated train-auc:{cv_results.iloc[-1]['train-auc-mean']:.2f}")
print(f"Cross-validated validation-auc:{cv_results.iloc[-1]['test-auc-mean']:.2f}")

Los valores del AUC de validación y entrenamiento con validación cruzada se muestran después de ejecutar la celda. Sus valores pueden ser ligeramente diferentes debido a la naturaleza estocástica del proceso de creación de modelos. Sin embargo, la diferencia en el rendimiento del entrenamiento y la prueba indica que lo más probable es que el modelo esté sobreajustando el conjunto de datos de entrenamiento dadas las combinaciones de hiperparámetros elegidas. Como científico de datos, puede usar esta información para refinar el modelo antes del entrenamiento a gran escala.

Una vez que haya medido el rendimiento de validación cruzada, en lugar de dividir el conjunto de datos de entrenamiento en varios pliegues, puede volver a entrenar el modelo en el conjunto de datos de entrenamiento completo mientras usa el conjunto de prueba para la detención anticipada. La detención anticipada ayuda a controlar la complejidad del modelo y reduce el sobreajuste. Copie y pegue el siguiente bloque de código para volver a entrenar y evaluar en los conjuntos de datos de prueba y entrenamiento. Tenga en cuenta que volver a entrenar en modo local significa que el conjunto de datos se extrae de Amazon S3 al entorno de la instancia local de SageMaker Studio. La instancia de SageMaker Studio debe tener suficiente espacio para almacenar datos de forma local.

data = pd.read_csv(test_data_uri)
test_features = data.drop(label_col, axis=1)
test_label = pd.DataFrame(data[label_col])
dtest = xgb.DMatrix(test_features, label=test_label)

model = (xgb.train(params=hyperparams, dtrain=dtrain, evals = [(dtrain,'train'), (dtest,'eval')], num_boost_round=num_boost_round, 
                  early_stopping_rounds=early_stopping_rounds, verbose_eval = 0)
        )

# Test model performance on train and test sets
test_pred = model.predict(dtest)
train_pred = model.predict(dtrain)

test_auc = roc_auc_score(test_label, test_pred)
train_auc = roc_auc_score(train_label, train_pred)

print(f"Train-auc:{train_auc:.2f}, Test-auc:{test_auc:.2f}")

Esto completa el entrenamiento y la evaluación de un modelo de clasificación binaria en el conjunto de datos de reclamaciones de seguros de automóviles. Copie y pegue el siguiente bloque de código para guardar las métricas de evaluación como un archivo JSON y el modelo entrenado como un archivo pickle. El código se guarda tanto en el directorio local dentro de SageMaker Studio como en su bucket de S3 predeterminado.

# Save model and performance metrics locally

with open("./metrics.json", "w") as f:
    json.dump(metrics_data, f)

with open("./xgboost-model", "wb") as f:
    joblib.dump(model, f)    
    
# Upload model and performance metrics to S3

metrics_location = output_key + "/metrics.json"
model_location = model_key + "/xgboost-model"

s3_client.upload_file(Filename="./metrics.json", Bucket=write_bucket, Key=metrics_location)
s3_client.upload_file(Filename="./xgboost-model", Bucket=write_bucket, Key=model_location)

Paso 4: eliminar los recursos

Una práctica recomendada es eliminar los recursos que ya no se utilizan para no incurrir en cargos no deseados.

Para eliminar el bucket de S3, haga lo siguiente: 

  • Abra la consola de Amazon S3. En la barra de navegación, elija Buckets, sagemaker-<your-Region>-<your-account-id> y, a continuación, marque la casilla de verificación junto a fraud-detect-demo. Luego, seleccione Delete (Eliminar). 
  • En el cuadro de diálogo Delete objects (Eliminar objetos), verifique que haya seleccionado el objeto apropiado para eliminar e ingrese permanently delete (eliminar de forma permanente) en la casilla de confirmación Permanently delete objects (Eliminar objetos de forma permanente). 
  • Una vez que haya finalizado esto y el bucket esté vacío, puede eliminar el bucket sagemaker-<your-Region>-<your-account-id> siguiendo el mismo procedimiento nuevamente.

El kernel de ciencia de datos utilizado para ejecutar la imagen del cuaderno en este tutorial acumulará cargos hasta que lo detenga o realice los siguientes pasos para eliminar las aplicaciones. Para obtener más información, consulte Apagar recursos en la Guía para desarrolladores de Amazon SageMaker.

Para eliminar las aplicaciones de SageMaker Studio, haga lo siguiente: en la consola de SageMaker Studio, elija studio-user y, a continuación, elimine todas las aplicaciones que aparecen en Apps (Aplicaciones) al seleccionar Delete app (Eliminar aplicación). Espere hasta que el Status (Estado) cambie a Deleted (Eliminado).

Si usó un dominio existente de SageMaker Studio en el paso 1, omita el resto del paso 4 y vaya directamente a la sección de conclusión. 

Si ejecutó la plantilla de CloudFormation en el paso 1 para crear un dominio de SageMaker Studio nuevo, continúe con los siguientes pasos a fin de eliminar el dominio, el usuario y los recursos creados por la plantilla de CloudFormation.  

Para abrir la consola de CloudFormation, ingrese CloudFormation en la barra de búsqueda de la consola de AWS y elija CloudFormation en los resultados de búsqueda.

En el panel de CloudFormation, elija Stacks (Pilas). En la lista desplegable de estado, seleccione Active (Activo). En Stack name (Nombre de la pila), elija CFN-SM-IM-Lambda-catalog para abrir la página de detalles de la pila.

En la página de detalles de la pila CFN-SM-IM-Lambda-catalog, elija Delete (Eliminar) para eliminar la pila junto con los recursos que creó en el paso 1.

Conclusión

¡Felicitaciones! Ha finalizado el tutorial Creación y entrenamiento de un modelo de machine learning de forma local

En este tutorial, utilizó Amazon SageMaker Studio para crear de forma local un modelo de clasificación binaria mediante la biblioteca de código abierto XGBoost y guardó los artefactos y los resultados del modelo en Amazon S3. Como se muestra en este tutorial, con la creación rápida de prototipos en SageMaker Studio, puede evaluar el rendimiento del modelo y los posibles problemas de sobreajuste antes de entrenar el modelo de producción con el conjunto de datos completo.

Puede continuar su viaje de científico de datos con Amazon SageMaker en la siguiente sección de pasos.

¿Le resultó útil esta página?

Siguientes pasos

Crear un modelo de ML automáticamente

Aprenda a usar AutoML para desarrollar modelos de ML sin escribir código.
Siguiente »

Implementar un modelo entrenado

Aprenda a implementar un modelo de ML entrenado para la inferencia.
Siguiente »

Encontrar más tutoriales prácticos

Explore otros tutoriales de machine learning para profundizar más.
Siguiente »