Churn-voorspelling met behulp van de ingebouwde tabelalgoritmen van Amazon SageMaker LightGBM, CatBoost, TabTransformer en AutoGluon-Tabular

Amazon Sage Maker biedt een suite van ingebouwde algoritmen, voorgetrainde modellen en vooraf gebouwde oplossingssjablonen om datawetenschappers en machine learning (ML)-beoefenaars te helpen snel aan de slag te gaan met het trainen en implementeren van ML-modellen. Deze algoritmen en modellen kunnen worden gebruikt voor zowel begeleid als niet-gesuperviseerd leren. Ze kunnen verschillende soorten invoergegevens verwerken, waaronder tabellen, afbeeldingen en tekst.

Klantverloop is een probleem waarmee een groot aantal bedrijven wordt geconfronteerd, van telecommunicatie tot bankieren, waar klanten doorgaans verloren gaan aan concurrenten. Het is in het belang van een bedrijf om bestaande klanten te behouden in plaats van nieuwe klanten te werven, omdat het gewoonlijk aanzienlijk meer kost om nieuwe klanten aan te trekken. Mobiele operators hebben historische records waarin klanten de service bleven gebruiken of uiteindelijk karnen. We kunnen deze historische informatie van het verloop van een mobiele operator gebruiken om een ​​ML-model te trainen. Na het trainen van dit model kunnen we de profielinformatie van een willekeurige klant (dezelfde profielinformatie die we hebben gebruikt om het model te trainen) aan het model doorgeven en het laten voorspellen of deze klant gaat churnen of niet.

In dit bericht trainen en implementeren we vier recent uitgebrachte SageMaker-algoritmen—LightGBM, CatBoost, TabTransformer en AutoGluon-Tabular—op een dataset voor het voorspellen van verloop. We gebruiken SageMaker automatische modelafstemming (een hulpmiddel voor hyperparameteroptimalisatie) om de beste hyperparameters voor elk model te vinden en hun prestaties te vergelijken op een holdout-testgegevensset om de optimale te selecteren.

U kunt deze oplossing ook gebruiken als een sjabloon om een ​​verzameling geavanceerde algoritmen in tabelvorm te doorzoeken en hyperparameteroptimalisatie te gebruiken om het beste algemene model te vinden. U kunt de voorbeelddataset eenvoudig vervangen door uw eigen dataset om echte zakelijke problemen op te lossen waarin u geïnteresseerd bent. Als u direct in de SageMaker SDK-code wilt springen die we in dit bericht doornemen, kunt u naar het volgende verwijzen voorbeeld Jupyter notebook.

Voordelen van ingebouwde algoritmen van SageMaker

Wanneer u een algoritme selecteert voor uw specifieke type probleem en gegevens, is het gebruik van een ingebouwd SageMaker-algoritme de gemakkelijkste optie, omdat dit de volgende grote voordelen met zich meebrengt:

• Lage codering – De ingebouwde algoritmen vereisen weinig codering om experimenten uit te voeren. De enige invoer die u hoeft op te geven, zijn de gegevens, hyperparameters en rekenresources. Hierdoor kunt u experimenten sneller uitvoeren, met minder overhead voor het bijhouden van resultaten en codewijzigingen.
• Efficiënte en schaalbare algoritme-implementaties – De ingebouwde algoritmen worden geleverd met parallellisatie over meerdere rekeninstances en GPU-ondersteuning direct uit de doos voor alle toepasselijke algoritmen. Als u veel gegevens heeft om uw model mee te trainen, kunnen de meeste ingebouwde algoritmen eenvoudig worden geschaald om aan de vraag te voldoen. Zelfs als je al een voorgetraind model hebt, kan het nog steeds gemakkelijker zijn om het uitvloeisel ervan in SageMaker te gebruiken en de hyperparameters die je al kent in te voeren in plaats van het over te dragen en zelf een trainingsscript te schrijven.
• Transparantie – U bent de eigenaar van de resulterende modelartefacten. Je kunt dat model nemen en het op SageMaker inzetten voor verschillende inferentiepatronen (bekijk alle beschikbare implementatietypes) en eenvoudig schalen en beheren van eindpunten, of u kunt het implementeren waar u het ook maar nodig hebt.

Gegevensvisualisatie en voorbewerking

Eerst verzamelen we onze dataset over klantverloop. Het is een relatief kleine dataset met 5,000 records, waarbij elk record 21 attributen gebruikt om het profiel van een klant van een onbekende Amerikaanse mobiele operator te beschrijven. De kenmerken variëren van de Amerikaanse staat waar de klant woont, tot het aantal oproepen dat ze naar de klantenservice hebben geplaatst, tot de kosten die ze in rekening worden gebracht voor oproepen overdag. We proberen te voorspellen of de klant zal churnen of niet, wat een binair classificatieprobleem is. Het volgende is een subset van die functies, met het label als de laatste kolom.

Hieronder volgen enkele inzichten voor elke kolom, met name de overzichtsstatistieken en het histogram van geselecteerde kenmerken.

We verwerken de gegevens vervolgens voor, splitsen deze op in trainings-, validatie- en testsets en uploaden de gegevens naar Amazon eenvoudige opslagservice (Amazone S3).

Automatische modelafstemming van algoritmen in tabelvorm

Hyperparameters bepalen hoe onze onderliggende algoritmen werken en beïnvloeden de prestaties van het model. Die hyperparameters kunnen het aantal lagen, leersnelheid, gewichtsafnamesnelheid en uitval zijn voor op neurale netwerken gebaseerde modellen, of het aantal bladeren, iteraties en maximale boomdiepte voor boomensemble-modellen. Om het beste model te selecteren, passen we automatische modelafstemming van SageMaker toe op elk van de vier getrainde SageMaker-algoritmen in tabelvorm. U hoeft alleen de hyperparameters te selecteren om af te stemmen en een bereik voor elke parameter om te verkennen. Voor meer informatie over het automatisch afstemmen van modellen, zie: Amazon SageMaker Automatic Model Tuning: Machine Learning gebruiken voor Machine Learning or Amazon SageMaker automatische modelafstemming: schaalbare gradiëntvrije optimalisatie.

Laten we eens kijken hoe dit in de praktijk werkt.

LichtGBM

We beginnen met het automatisch afstemmen van modellen met LightGBM en passen dat proces aan de andere algoritmen aan. Zoals uitgelegd in de post Amazon SageMaker JumpStart-modellen en algoritmen nu beschikbaar via API, zijn de volgende artefacten vereist om een ​​vooraf gebouwd algoritme te trainen via de SageMaker SDK:

• De framework-specifieke container-image, die alle vereiste afhankelijkheden bevat voor training en inferentie
• De trainings- en inferentiescripts voor het geselecteerde model of algoritme

We halen eerst deze artefacten op, die afhankelijk zijn van de model_id (lightgbm-classification-model in dit geval) en versie:

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)

We krijgen dan de standaard hyperparameters voor LightGBM, stellen sommige ervan in op geselecteerde vaste waarden, zoals het aantal boost-rondes en evaluatiestatistieken op de validatiegegevens, en definiëren de waardebereiken die we willen doorzoeken voor anderen. We gebruiken de SageMaker-parameters ContinuousParameter en IntegerParameter voor deze:

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

Tot slot maken we een SageMaker-schatter, voer het in een HyperarameterTuner, en start de taak voor het afstemmen van hyperparameters met 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)

De max_jobs parameter definieert hoeveel taken in totaal worden uitgevoerd in de automatische modelafstemmingstaak, en max_parallel_jobs bepaalt hoeveel gelijktijdige trainingstaken moeten worden gestart. We definiëren ook de doelstelling om: “Maximize” de AUC van het model (gebied onder de curve). Om dieper in te gaan op de beschikbare parameters die worden blootgelegd door: HyperParameterTuner, verwijzen naar HyperparameterTuner.

Check out de voorbeeld notebook om te zien hoe we dit model gaan implementeren en evalueren op de testset.

KatBoost

Het proces voor het afstemmen van hyperparameters op het CatBoost-algoritme is hetzelfde als voorheen, hoewel we modelartefacten onder de ID moeten ophalen catboost-classification-model en verander de bereikselectie van hyperparameters:

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

Tab Transformator

Het proces voor het afstemmen van hyperparameters op het TabTransformer-model is hetzelfde als voorheen, hoewel we modelartefacten onder de ID moeten ophalen pytorch-tabtransformerclassification-model en verander de bereikselectie van hyperparameters.

We veranderen ook de training instance_type naar ml.p3.2xlarge. TabTransformer is een recentelijk afgeleid model van Amazon-onderzoek, dat de kracht van deep learning naar tabelgegevens brengt met behulp van Transformer-modellen. Om dit model op een efficiënte manier te trainen, hebben we een GPU-backed instance nodig. Voor meer informatie, zie: De kracht van deep learning naar gegevens in tabellen brengen.

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

In het geval van AutoGluon voeren we geen hyperparameter-afstemming uit. Dit is zo ontworpen, omdat AutoGluon zich richt op het samenvoegen van meerdere modellen met verstandige keuzes van hyperparameters en deze in meerdere lagen te stapelen. Dit levert uiteindelijk meer prestaties op dan het trainen van één model met de perfecte selectie van hyperparameters en is ook rekenkundig goedkoper. Voor details, check out AutoGluon-Tabular: robuuste en nauwkeurige AutoML voor gestructureerde gegevens.

Daarom schakelen we de model_id naar autogluon-classification-ensemble, en pas de evaluatiemetrische hyperparameter alleen aan onze gewenste AUC-score:

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"

In plaats van te bellen tuner.fit(), wij bellen estimator.fit() om een ​​enkele opleidingsopdracht te starten.

Benchmarking van de getrainde modellen

Nadat we alle vier de modellen hebben geïmplementeerd, sturen we de volledige testset naar elk eindpunt voor voorspelling en het berekenen van de nauwkeurigheid, F1- en AUC-statistieken voor elk (zie code in de voorbeeld notebook). We presenteren de resultaten in de volgende tabel, met een belangrijke disclaimer: resultaten en relatieve prestaties tussen deze modellen zijn afhankelijk van de dataset die u voor training gebruikt. Deze resultaten zijn representatief, en hoewel de neiging van bepaalde algoritmen om beter te presteren gebaseerd is op relevante factoren (AutoGluon combineert bijvoorbeeld intelligent de voorspellingen van zowel LightGBM- als CatBoost-modellen achter de schermen), kan de balans in prestaties veranderen bij een andere gegevens distributie.

Conclusie

In dit bericht hebben we vier verschillende ingebouwde algoritmen van SageMaker getraind om het voorspellingsprobleem van klantverloop op te lossen met weinig codeerinspanning. We gebruikten SageMaker automatische modelafstemming om de beste hyperparameters te vinden om deze algoritmen mee te trainen, en vergeleken hun prestaties op een geselecteerde dataset voor churn-voorspelling. U kunt de gerelateerde voorbeeld notebook als een sjabloon, waarbij u de dataset vervangt door uw eigen dataset om het gewenste op tabellen gebaseerde probleem op te lossen.

Zorg ervoor dat u deze algoritmen op SageMaker probeert en bekijk voorbeeldnotitieboekjes over het gebruik van andere ingebouwde algoritmen die beschikbaar zijn op GitHub.

Over de auteurs

Dr Xin Huang is een toegepast wetenschapper voor de ingebouwde algoritmen van Amazon SageMaker JumpStart en Amazon SageMaker. Hij richt zich op het ontwikkelen van schaalbare algoritmen voor machine learning. Zijn onderzoeksinteresses liggen op het gebied van natuurlijke taalverwerking, verklaarbaar diep leren op tabelgegevens en robuuste analyse van niet-parametrische ruimte-tijdclustering. Hij heeft veel artikelen gepubliceerd in ACL, ICDM, KDD-conferenties en het tijdschrift Royal Statistical Society: Series A.

Joao Moura is een AI/ML Specialist Solutions Architect bij Amazon Web Services. Hij is vooral gericht op NLP-use-cases en helpt klanten bij het optimaliseren van de training en implementatie van Deep Learning-modellen. Hij is ook een actief voorstander van low-code ML-oplossingen en ML-gespecialiseerde hardware.