Prédiction de désabonnement à l'aide des algorithmes tabulaires intégrés d'Amazon SageMaker LightGBM, CatBoost, TabTransformer et AutoGluon-Tabular

Amazon Sage Maker offre une suite de algorithmes intégrés, modèles pré-entraînéset modèles de solutions prédéfinis pour aider les scientifiques des données et les praticiens de l'apprentissage automatique (ML) à démarrer rapidement la formation et le déploiement de modèles ML. Ces algorithmes et modèles peuvent être utilisés à la fois pour l'apprentissage supervisé et non supervisé. Ils peuvent traiter différents types de données d'entrée, notamment des tableaux, des images et du texte.

Le taux de désabonnement des clients est un problème auquel sont confrontés un large éventail d'entreprises, des télécommunications aux banques, où les clients sont généralement perdus au profit des concurrents. Il est dans l'intérêt d'une entreprise de fidéliser les clients existants plutôt que d'en acquérir de nouveaux, car il en coûte généralement beaucoup plus pour attirer de nouveaux clients. Les opérateurs de téléphonie mobile ont des enregistrements historiques dans lesquels les clients ont continué à utiliser le service ou ont finalement fini par abandonner. Nous pouvons utiliser ces informations historiques sur le taux de désabonnement d'un opérateur mobile pour former un modèle ML. Après avoir formé ce modèle, nous pouvons transmettre les informations de profil d'un client arbitraire (les mêmes informations de profil que nous avons utilisées pour former le modèle) au modèle, et lui faire prédire si ce client va se désabonner ou non.

Dans ce poste, nous formons et déployons quatre algorithmes SageMaker récemment publiés—LightGBM, CatBoost, TabTransformer et AutoGluon-Tabular—sur un ensemble de données de prédiction de désabonnement. Nous utilisons Réglage automatique du modèle SageMaker (un outil d'optimisation des hyperparamètres) pour trouver les meilleurs hyperparamètres pour chaque modèle et comparer leurs performances sur un jeu de données de test retenu pour sélectionner celui qui est optimal.

Vous pouvez également utiliser cette solution comme modèle pour rechercher dans une collection d'algorithmes tabulaires de pointe et utiliser l'optimisation des hyperparamètres pour trouver le meilleur modèle global. Vous pouvez facilement remplacer l'exemple de jeu de données par le vôtre pour résoudre les vrais problèmes commerciaux qui vous intéressent. exemple de cahier Jupyter.

Avantages des algorithmes intégrés de SageMaker

Lors de la sélection d'un algorithme pour votre type particulier de problème et de données, l'utilisation d'un algorithme intégré SageMaker est l'option la plus simple, car cela présente les principaux avantages suivants :

• Faible codage – Les algorithmes intégrés nécessitent peu de codage pour commencer à exécuter des expériences. Les seules entrées que vous devez fournir sont les données, les hyperparamètres et les ressources de calcul. Cela vous permet d'exécuter des expériences plus rapidement, avec moins de surcharge pour le suivi des résultats et des modifications de code.
• Implémentations d'algorithmes efficaces et évolutives – Les algorithmes intégrés sont livrés avec une parallélisation sur plusieurs instances de calcul et une prise en charge GPU prête à l'emploi pour tous les algorithmes applicables. Si vous avez beaucoup de données avec lesquelles former votre modèle, la plupart des algorithmes intégrés peuvent facilement évoluer pour répondre à la demande. Même si vous disposez déjà d'un modèle pré-formé, il peut toujours être plus facile d'utiliser son corollaire dans SageMaker et de saisir les hyperparamètres que vous connaissez déjà plutôt que de le transférer et d'écrire vous-même un script de formation.
• Transparence – Vous êtes le propriétaire des artefacts de modèle résultants. Vous pouvez prendre ce modèle et le déployer sur SageMaker pour plusieurs modèles d'inférence différents (consultez tous les types de déploiement disponibles) et une mise à l'échelle et une gestion faciles des terminaux, ou vous pouvez le déployer partout où vous en avez besoin.

Visualisation et prétraitement des données

Tout d'abord, nous recueillons notre ensemble de données sur le taux de désabonnement des clients. Il s'agit d'un ensemble de données relativement petit avec 5,000 21 enregistrements, où chaque enregistrement utilise XNUMX attributs pour décrire le profil d'un client d'un opérateur de téléphonie mobile américain inconnu. Les attributs vont de l'État américain où réside le client au nombre d'appels qu'il a passés au service client, en passant par le coût qui lui est facturé pour les appels de jour. Nous essayons de prédire si le client va se désabonner ou non, ce qui est un problème de classification binaire. Voici un sous-ensemble de ces fonctionnalités, avec l'étiquette comme dernière colonne.

Voici quelques informations pour chaque colonne, en particulier les statistiques récapitulatives et l'histogramme des fonctionnalités sélectionnées.

Nous prétraitons ensuite les données, les divisons en ensembles de formation, de validation et de test, et téléchargeons les données sur Service de stockage simple Amazon (Amazon S3).

Réglage automatique du modèle des algorithmes tabulaires

Les hyperparamètres contrôlent le fonctionnement de nos algorithmes sous-jacents et influencent les performances du modèle. Ces hyperparamètres peuvent être le nombre de couches, le taux d'apprentissage, le taux de décroissance du poids et l'abandon pour les modèles basés sur des réseaux de neurones, ou le nombre de feuilles, d'itérations et la profondeur maximale de l'arbre pour les modèles d'ensemble d'arbres. Pour sélectionner le meilleur modèle, nous appliquons le réglage automatique du modèle SageMaker à chacun des quatre algorithmes tabulaires SageMaker entraînés. Il vous suffit de sélectionner les hyperparamètres à régler et une plage pour chaque paramètre à explorer. Pour plus d'informations sur le réglage automatique du modèle, reportez-vous à Amazon SageMaker Automatic Model Tuning: Utilisation du Machine Learning pour le Machine Learning or Réglage automatique du modèle Amazon SageMaker : optimisation évolutive sans gradient.

Voyons comment cela fonctionne dans la pratique.

LumièreGBM

Nous commençons par exécuter le réglage automatique du modèle avec LightGBM et adaptons ce processus aux autres algorithmes. Comme expliqué dans le post Modèles et algorithmes Amazon SageMaker JumpStart désormais disponibles via l'API, les artefacts suivants sont requis pour entraîner un algorithme prédéfini via le SDK SageMaker :

• Son image de conteneur spécifique au framework, contenant toutes les dépendances requises pour la formation et l'inférence
• Les scripts d'entraînement et d'inférence pour le modèle ou l'algorithme sélectionné

Nous récupérons d'abord ces artefacts, qui dépendent de la model_id (lightgbm-classification-model dans ce cas) et version :

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)

Nous obtenons ensuite les hyperparamètres par défaut pour LightGBM, définissons certains d'entre eux sur des valeurs fixes sélectionnées telles que le nombre de tours de boost et la métrique d'évaluation sur les données de validation, et définissons les plages de valeurs que nous voulons rechercher pour les autres. Nous utilisons les paramètres SageMaker ContinuousParameter ainsi que IntegerParameter pour ça:

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),
}

Enfin, nous créons un Estimateur SageMaker, introduisez-le dans un HyperarameterTuner, et démarrez la tâche de réglage des hyperparamètres avec 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)

La max_jobs Le paramètre définit le nombre total de tâches qui seront exécutées dans la tâche de réglage automatique du modèle, et max_parallel_jobs définit le nombre de tâches de formation simultanées à démarrer. Nous définissons également l'objectif de “Maximize” l'AUC (aire sous la courbe) du modèle. Pour approfondir les paramètres disponibles exposés par HyperParameterTuner, faire référence à HyperparameterTuner.

Jetez un coup d'œil au exemple de cahier pour voir comment nous procédons pour déployer et évaluer ce modèle sur le jeu de test.

ChatBoost

Le processus de réglage des hyperparamètres sur l'algorithme CatBoost est le même qu'auparavant, bien que nous devions récupérer les artefacts du modèle sous l'ID catboost-classification-model et modifiez la sélection de plage d'hyperparamètres :

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"),
}

TabTransformateur

Le processus de réglage des hyperparamètres sur le modèle TabTransformer est le même qu'auparavant, bien que nous devions récupérer les artefacts du modèle sous l'ID pytorch-tabtransformerclassification-model et modifier la sélection de plage d'hyperparamètres.

Nous changeons aussi la formation instance_type à ml.p3.2xlarge. TabTransformer est un modèle récemment dérivé de la recherche Amazon, qui apporte la puissance de l'apprentissage en profondeur aux données tabulaires à l'aide de modèles Transformer. Pour former ce modèle de manière efficace, nous avons besoin d'une instance basée sur GPU. Pour plus d'informations, reportez-vous à Apporter la puissance de l'apprentissage en profondeur aux données dans les tableaux.

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-Tableau

Dans le cas d'AutoGluon, nous n'exécutons pas de réglage d'hyperparamètres. C'est par conception, car AutoGluon se concentre sur l'assemblage de plusieurs modèles avec des choix sains d'hyperparamètres et sur leur empilement en plusieurs couches. Cela finit par être plus performant que la formation d'un modèle avec la sélection parfaite d'hyperparamètres et est également moins coûteux en termes de calcul. Pour plus de détails, consultez AutoGluon-Tabular : AutoML robuste et précis pour les données structurées.

Par conséquent, nous changeons le model_id à autogluon-classification-ensemble, et fixez uniquement l'hyperparamètre de la métrique d'évaluation à notre score AUC souhaité :

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"

Au lieu d'appeler tuner.fit(), nous appelons estimator.fit() pour commencer un travail de formation unique.

Benchmarking des modèles formés

Après avoir déployé les quatre modèles, nous envoyons l'ensemble de tests complet à chaque point de terminaison pour la prédiction et calculons la précision, les mesures F1 et AUC pour chacun (voir le code dans le exemple de cahier). Nous présentons les résultats dans le tableau suivant, avec une clause de non-responsabilité importante : les résultats et les performances relatives entre ces modèles dépendront de l'ensemble de données que vous utilisez pour la formation. Ces résultats sont représentatifs, et même si la tendance de certains algorithmes à être plus performants est basée sur des facteurs pertinents (par exemple, AutoGluon associe intelligemment les prédictions des modèles LightGBM et CatBoost dans les coulisses), l'équilibre des performances peut changer en fonction d'un autre diffusion des données.

Conclusion

Dans cet article, nous avons formé quatre algorithmes intégrés SageMaker différents pour résoudre le problème de prédiction de l'attrition client avec un faible effort de codage. Nous avons utilisé le réglage automatique du modèle SageMaker pour trouver les meilleurs hyperparamètres avec lesquels entraîner ces algorithmes et comparé leurs performances sur un ensemble de données de prédiction de désabonnement sélectionné. Vous pouvez utiliser les exemple de cahier en tant que modèle, en remplaçant l'ensemble de données par le vôtre pour résoudre le problème tabulaire souhaité basé sur les données.

Assurez-vous d'essayer ces algorithmes sur SageMaker et consultez des exemples de blocs-notes sur la façon d'utiliser d'autres algorithmes intégrés disponibles sur GitHub.

À propos des auteurs

Dr Xin Huang est un scientifique appliqué pour Amazon SageMaker JumpStart et les algorithmes intégrés d'Amazon SageMaker. Il se concentre sur le développement d'algorithmes d'apprentissage automatique évolutifs. Ses intérêts de recherche portent sur le traitement du langage naturel, l'apprentissage en profondeur explicable sur des données tabulaires et l'analyse robuste du clustering spatio-temporel non paramétrique. Il a publié de nombreux articles dans les conférences ACL, ICDM, KDD et Royal Statistical Society: Series A journal.

Joao Moura est architecte de solutions spécialisées en IA/ML chez Amazon Web Services. Il se concentre principalement sur les cas d'utilisation du NLP et aide les clients à optimiser la formation et le déploiement des modèles de Deep Learning. Il est également un partisan actif des solutions ML low-code et du matériel spécialisé ML.