Predicción de abandono con los algoritmos tabulares integrados de Amazon SageMaker LightGBM, CatBoost, TabTransformer y AutoGluon-Tabular

Amazon SageMaker proporciona un conjunto de algoritmos incorporados, modelos pre-entrenadosy plantillas de solución preconstruidas para ayudar a los científicos de datos y a los profesionales del aprendizaje automático (ML) a comenzar a entrenar e implementar modelos de ML rápidamente. Estos algoritmos y modelos se pueden utilizar tanto para el aprendizaje supervisado como para el no supervisado. Pueden procesar varios tipos de datos de entrada, incluidos tabulares, imágenes y texto.

La rotación de clientes es un problema al que se enfrentan una amplia gama de empresas, desde las telecomunicaciones hasta la banca, donde los clientes suelen perderse ante los competidores. Lo mejor para una empresa es retener a los clientes existentes en lugar de adquirir nuevos clientes porque, por lo general, cuesta significativamente más atraer nuevos clientes. Los operadores móviles tienen registros históricos en los que los clientes continuaron usando el servicio o finalmente terminaron abandonando. Podemos usar esta información histórica de la rotación de un operador móvil para entrenar un modelo ML. Después de entrenar este modelo, podemos pasar la información de perfil de un cliente arbitrario (la misma información de perfil que usamos para entrenar el modelo) al modelo y hacer que prediga si este cliente abandonará o no.

En esta publicación, entrenamos y desplegamos cuatro algoritmos de SageMaker lanzados recientemente—LightGBM, CatBoost, TabTransformer y AutoGluon-Tabular—en un conjunto de datos de predicción de rotación. Usamos Ajuste automático de modelos de SageMaker (una herramienta para la optimización de hiperparámetros) para encontrar los mejores hiperparámetros para cada modelo y comparar su rendimiento en un conjunto de datos de prueba de reserva para seleccionar el óptimo.

También puede utilizar esta solución como plantilla para buscar en una colección de algoritmos tabulares de última generación y utilizar la optimización de hiperparámetros para encontrar el mejor modelo general. Puede reemplazar fácilmente el conjunto de datos de ejemplo con el suyo propio para resolver problemas comerciales reales que le interesen. Si desea pasar directamente al código SDK de SageMaker que analizamos en esta publicación, puede consultar lo siguiente muestra de cuaderno Jupyter.

Beneficios de los algoritmos integrados de SageMaker

Al seleccionar un algoritmo para su tipo particular de problema y datos, usar un algoritmo integrado de SageMaker es la opción más fácil, ya que hacerlo tiene los siguientes beneficios principales:

• Codificación baja – Los algoritmos incorporados requieren poca codificación para comenzar a ejecutar experimentos. Las únicas entradas que debe proporcionar son los datos, los hiperparámetros y los recursos informáticos. Esto le permite ejecutar experimentos más rápidamente, con menos gastos generales para el seguimiento de los resultados y los cambios de código.
• Implementaciones de algoritmos eficientes y escalables – Los algoritmos incorporados vienen con paralelización en múltiples instancias de cómputo y compatibilidad con GPU desde el primer momento para todos los algoritmos aplicables. Si tiene una gran cantidad de datos con los que entrenar su modelo, la mayoría de los algoritmos integrados pueden escalar fácilmente para satisfacer la demanda. Incluso si ya tiene un modelo preentrenado, aún puede ser más fácil usar su corolario en SageMaker e ingresar los hiperparámetros que ya conoce en lugar de transferirlo y escribir un script de entrenamiento usted mismo.
• Transparencia – Eres el propietario de los artefactos del modelo resultante. Puede tomar ese modelo e implementarlo en SageMaker para varios patrones de inferencia diferentes (vea todos los tipos de implementación disponibles) y fácil escalado y administración de terminales, o puede implementarlo donde lo necesite.

Visualización y preprocesamiento de datos

Primero, recopilamos nuestro conjunto de datos de abandono de clientes. Es un conjunto de datos relativamente pequeño con 5,000 registros, donde cada registro usa 21 atributos para describir el perfil de un cliente de un operador móvil estadounidense desconocido. Los atributos van desde el estado de EE. UU. donde reside el cliente hasta la cantidad de llamadas que realizó al servicio de atención al cliente y el costo que se le factura por las llamadas durante el día. Estamos tratando de predecir si el cliente abandonará o no, lo cual es un problema de clasificación binaria. El siguiente es un subconjunto de esas características, con la etiqueta como la última columna.

Las siguientes son algunas ideas para cada columna, específicamente las estadísticas de resumen y el histograma de las características seleccionadas.

Luego preprocesamos los datos, los dividimos en conjuntos de entrenamiento, validación y prueba, y subimos los datos a Servicio de almacenamiento simple de Amazon (Amazon S3).

Ajuste automático de modelos de algoritmos tabulares

Los hiperparámetros controlan cómo funcionan nuestros algoritmos subyacentes e influyen en el rendimiento del modelo. Esos hiperparámetros pueden ser el número de capas, la tasa de aprendizaje, la tasa de disminución del peso y la deserción para modelos basados ​​en redes neuronales, o el número de hojas, iteraciones y profundidad máxima del árbol para modelos de conjuntos de árboles. Para seleccionar el mejor modelo, aplicamos el ajuste automático del modelo de SageMaker a cada uno de los cuatro algoritmos tabulares entrenados de SageMaker. Solo necesita seleccionar los hiperparámetros para ajustar y un rango para cada parámetro para explorar. Para obtener más información sobre el ajuste automático del modelo, consulte Ajuste automático del modelo de Amazon SageMaker: uso del aprendizaje automático para el aprendizaje automático or Ajuste automático de modelos de Amazon SageMaker: optimización escalable sin gradientes.

Veamos cómo funciona esto en la práctica.

LuzGBM

Comenzamos ejecutando el ajuste automático del modelo con LightGBM y adaptamos ese proceso a los otros algoritmos. Como esta explicado en la publicacion Los modelos y algoritmos de Amazon SageMaker JumpStart ahora están disponibles a través de la API, se requieren los siguientes artefactos para entrenar un algoritmo preconstruido a través del SDK de SageMaker:

• Su imagen de contenedor específica del marco, que contiene todas las dependencias necesarias para el entrenamiento y la inferencia.
• Los scripts de entrenamiento e inferencia para el modelo o algoritmo seleccionado

Primero recuperamos estos artefactos, que dependen de la model_id (lightgbm-classification-model en este caso) y versión:

from sagemaker import image_uris, model_uris, script_uris
train_model_id, train_model_version, train_scope = "lightgbm-classification-model", "*", "training"
training_instance_type = "ml.m5.4xlarge"

# Retrieve the docker image
train_image_uri = image_uris.retrieve(region=None,
                                      framework=None,
                                      model_id=train_model_id,
                                      model_version=train_model_version,
                                      image_scope=train_scope,
                                      instance_type=training_instance_type,
                                      )                                      
# Retrieve the training script
train_source_uri = script_uris.retrieve(model_id=train_model_id,
                                        model_version=train_model_version,
                                        script_scope=train_scope
                                        )
# Retrieve the pre-trained model tarball (in the case of tabular modeling, it is a dummy file)
train_model_uri = model_uris.retrieve(model_id=train_model_id,
                                      model_version=train_model_version,
                                      model_scope=train_scope)

Luego obtenemos los hiperparámetros predeterminados para LightGBM, establecemos algunos de ellos en valores fijos seleccionados, como el número de rondas de impulso y la métrica de evaluación en los datos de validación, y definimos los rangos de valores en los que queremos buscar otros. Usamos los parámetros de SageMaker ContinuousParameter y IntegerParameter para esto:

from sagemaker import hyperparameters
from sagemaker.tuner import ContinuousParameter, IntegerParameter, HyperparameterTuner

# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(model_id=train_model_id,
                                                   model_version=train_model_version
                                                   )
# [Optional] Override default hyperparameters with custom values
hyperparameters["num_boost_round"] = "500"
hyperparameters["metric"] = "auc"

# Define search ranges for other hyperparameters
hyperparameter_ranges_lgb = {
    "learning_rate": ContinuousParameter(1e-4, 1, scaling_type="Logarithmic"),
    "num_boost_round": IntegerParameter(2, 30),
    "num_leaves": IntegerParameter(10, 50),
    "feature_fraction": ContinuousParameter(0, 1),
    "bagging_fraction": ContinuousParameter(0, 1),
    "bagging_freq": IntegerParameter(1, 10),
    "max_depth": IntegerParameter(5, 30),
    "min_data_in_leaf": IntegerParameter(5, 50),
}

Finalmente, creamos un Estimador de SageMaker, introdúzcalo en un HiperarámetroSintonizadory comience el trabajo de ajuste de hiperparámetros con tuner.fit():

from sagemaker.estimator import Estimator
from sagemaker.tuner import HyperParameterTuner

# Create SageMaker Estimator instance
tabular_estimator = Estimator(
    role=aws_role,
    image_uri=train_image_uri,
    source_dir=train_source_uri,
    model_uri=train_model_uri,
    entry_point="transfer_learning.py",
    instance_count=1,
    instance_type=training_instance_type,
    max_run=360000,
    hyperparameters=hyperparameters,
)

tuner = HyperparameterTuner(
            tabular_estimator,
            "auc",
            hyperparameter_ranges_lgb,
            [{"Name": "auc", "Regex": "auc: ([0-9.]+)"}],
            max_jobs=10,
            max_parallel_jobs=5,
            objective_type="Maximize",
            base_tuning_job_name="some_name",
        )

tuner.fit({"training": training_dataset_s3_path}, logs=True)

El max_jobs El parámetro define cuántos trabajos totales se ejecutarán en el trabajo de ajuste automático del modelo, y max_parallel_jobs define cuántos trabajos de entrenamiento simultáneos deben iniciarse. También definimos el objetivo de “Maximize” el AUC (área bajo la curva) del modelo. Para profundizar en los parámetros disponibles expuestos por HyperParameterTuner, Referirse a Sintonizador de hiperparámetros.

Primero eche un vistazo al sitio web de la página cuaderno de muestra para ver cómo procedemos a implementar y evaluar este modelo en el conjunto de prueba.

gatoboost

El proceso de ajuste de hiperparámetros en el algoritmo CatBoost es el mismo que antes, aunque necesitamos recuperar los artefactos del modelo bajo el ID catboost-classification-model y cambiar la selección de rango de hiperparámetros:

from sagemaker import hyperparameters

# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(
    model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters["iterations"] = "500"
hyperparameters["eval_metric"] = "AUC"

# Define search ranges for other hyperparameters
hyperparameter_ranges_cat = {
    "learning_rate": ContinuousParameter(0.00001, 0.1, scaling_type="Logarithmic"),
    "iterations": IntegerParameter(50, 1000),
    "depth": IntegerParameter(1, 10),
    "l2_leaf_reg": IntegerParameter(1, 10),
    "random_strength": ContinuousParameter(0.01, 10, scaling_type="Logarithmic"),
}

Transformador de pestañas

El proceso de ajuste de hiperparámetros en el modelo TabTransformer es el mismo que antes, aunque necesitamos recuperar los artefactos del modelo bajo el ID. pytorch-tabtransformerclassification-model y cambiar la selección de rango de hiperparámetros.

También cambiamos el entrenamiento instance_type a ml.p3.2xlarge. TabTransformer es un modelo derivado recientemente de la investigación de Amazon, que brinda el poder del aprendizaje profundo a los datos tabulares utilizando modelos de Transformer. Para entrenar este modelo de manera eficiente, necesitamos una instancia respaldada por GPU. Para obtener más información, consulte Llevando el poder del aprendizaje profundo a los datos en las tablas.

from sagemaker import hyperparameters
from sagemaker.tuner import CategoricalParameter

# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(
    model_id=train_model_id, model_version=train_model_version
)
# [Optional] Override default hyperparameters with custom values
hyperparameters["n_epochs"] = 40  # The same hyperparameter is named as "iterations" for CatBoost
hyperparameters["patience"] = 10

# Define search ranges for other hyperparameters
hyperparameter_ranges_tab = {
    "learning_rate": ContinuousParameter(0.001, 0.01, scaling_type="Auto"),
    "batch_size": CategoricalParameter([64, 128, 256, 512]),
    "attn_dropout": ContinuousParameter(0.0, 0.8, scaling_type="Auto"),
    "mlp_dropout": ContinuousParameter(0.0, 0.8, scaling_type="Auto"),
    "input_dim": CategoricalParameter(["16", "32", "64", "128", "256"]),
    "frac_shared_embed": ContinuousParameter(0.0, 0.5, scaling_type="Auto"),
}

AutoGluon-tabular

En el caso de AutoGluon, no ejecutamos el ajuste de hiperparámetros. Esto es por diseño, porque AutoGluon se enfoca en ensamblar múltiples modelos con opciones sensatas de hiperparámetros y apilarlos en múltiples capas. Esto termina siendo más eficaz que entrenar un modelo con la selección perfecta de hiperparámetros y también es computacionalmente más económico. Para más detalles, echa un vistazo AutoGluon-Tabular: AutoML robusto y preciso para datos estructurados.

Por lo tanto, cambiamos el model_id a autogluon-classification-ensemble, y solo corrija el hiperparámetro de la métrica de evaluación a nuestra puntuación AUC deseada:

from sagemaker import hyperparameters

# Retrieve the default hyper-parameters for fine-tuning the model
hyperparameters = hyperparameters.retrieve_default(
    model_id=train_model_id, model_version=train_model_version
)

hyperparameters["eval_metric"] = "roc_auc"

En lugar de llamar tuner.fit(), nosotros llamamos estimator.fit() para iniciar un solo trabajo de formación.

Evaluación comparativa de los modelos entrenados

Después de implementar los cuatro modelos, enviamos el conjunto de prueba completo a cada punto final para predecir y calcular la precisión, F1 y las métricas AUC para cada uno (consulte el código en el cuaderno de muestra). Presentamos los resultados en la siguiente tabla, con un descargo de responsabilidad importante: los resultados y el rendimiento relativo entre estos modelos dependerán del conjunto de datos que utilice para el entrenamiento. Estos resultados son representativos y, aunque la tendencia de ciertos algoritmos a funcionar mejor se basa en factores relevantes (por ejemplo, AutoGluon combina de manera inteligente las predicciones de los modelos LightGBM y CatBoost detrás de escena), el equilibrio en el rendimiento podría cambiar dado un cambio diferente. distribución de datos.

Conclusión

En esta publicación, entrenamos cuatro algoritmos integrados diferentes de SageMaker para resolver el problema de predicción de abandono de clientes con poco esfuerzo de codificación. Utilizamos el ajuste automático del modelo de SageMaker para encontrar los mejores hiperparámetros con los que entrenar estos algoritmos y comparamos su rendimiento en un conjunto de datos de predicción de abandono seleccionado. Puede utilizar los relacionados cuaderno de muestra como plantilla, reemplazando el conjunto de datos con el suyo propio para resolver su problema deseado basado en datos tabulares.

Asegúrese de probar estos algoritmos en SageMaker y consulte los cuadernos de muestra sobre cómo usar otros algoritmos integrados disponibles en GitHub.

Sobre los autores

Dra. Xin Huang es un científico aplicado para los algoritmos integrados de Amazon SageMaker JumpStart y Amazon SageMaker. Se centra en el desarrollo de algoritmos escalables de aprendizaje automático. Sus intereses de investigación se encuentran en el área del procesamiento del lenguaje natural, el aprendizaje profundo explicable en datos tabulares y el análisis sólido de la agrupación de espacio-tiempo no paramétrica. Ha publicado muchos artículos en conferencias ACL, ICDM, KDD y la revista Royal Statistical Society: Serie A.

joão moura es un arquitecto de soluciones especializado en IA/ML en Amazon Web Services. Se centra principalmente en los casos de uso de NLP y en ayudar a los clientes a optimizar el entrenamiento y la implementación del modelo de aprendizaje profundo. También es un defensor activo de las soluciones de aprendizaje automático de código bajo y el hardware especializado en aprendizaje automático.