Churn-forudsigelse ved hjælp af Amazon SageMaker indbyggede tabelformede algoritmer LightGBM, CatBoost, TabTransformer og AutoGluon-Tabular

Amazon SageMaker giver en suite af indbyggede algoritmer, fortrænede modellerog forudbyggede løsningsskabeloner at hjælpe dataforskere og maskinlæringsudøvere (ML) med at komme i gang med at træne og implementere ML-modeller hurtigt. Disse algoritmer og modeller kan bruges til både superviseret og uovervåget læring. De kan behandle forskellige typer inputdata, herunder tabel, billede og tekst.

Kundeafgang er et problem, som en lang række virksomheder står over for, lige fra telekommunikation til bank, hvor kunderne typisk går tabt til konkurrenter. Det er i en virksomheds bedste interesse at fastholde eksisterende kunder frem for at skaffe nye kunder, fordi det normalt koster betydeligt mere at tiltrække nye kunder. Mobiloperatører har historiske optegnelser, hvor kunderne fortsatte med at bruge tjenesten eller i sidste ende endte med at vælte. Vi kan bruge denne historiske information om en mobiloperatørs churn til at træne en ML-model. Efter træning af denne model kan vi videregive profiloplysningerne for en vilkårlig kunde (den samme profilinformation, som vi brugte til at træne modellen) til modellen, og få den til at forudsige, om denne kunde kommer til at churne eller ej.

I dette indlæg træner og implementerer vi fire nyligt udgivne SageMaker-algoritmer—LightGBM, CatBoost, TabTransformer og AutoGluon-Tabular — på et datasæt til churn-forudsigelse. Vi bruger SageMaker Automatisk Model Tuning (et værktøj til hyperparameteroptimering) for at finde de bedste hyperparametre for hver model og sammenligne deres ydeevne på et holdout-testdatasæt for at vælge det optimale.

Du kan også bruge denne løsning som en skabelon til at søge i en samling af avancerede tabelformede algoritmer og bruge hyperparameteroptimering til at finde den bedste overordnede model. Du kan nemt erstatte eksempeldatasættet med dit eget for at løse reelle forretningsproblemer, du er interesseret i. Hvis du vil springe direkte ind i SageMaker SDK-koden, vi gennemgår i dette indlæg, kan du henvise til følgende prøve Jupyter notesbog.

Fordele ved SageMaker indbyggede algoritmer

Når du vælger en algoritme til din særlige type problem og data, er brugen af ​​en SageMaker indbygget algoritme den nemmeste mulighed, fordi det kommer med følgende store fordele:

• Lav kodning – De indbyggede algoritmer kræver lidt kodning for at begynde at køre eksperimenter. De eneste input, du skal angive, er data, hyperparametre og computerressourcer. Dette giver dig mulighed for at køre eksperimenter hurtigere med mindre overhead til sporing af resultater og kodeændringer.
• Effektive og skalerbare algoritmeimplementeringer – De indbyggede algoritmer kommer med parallelisering på tværs af flere computerforekomster og GPU-understøttelse lige fra kassen til alle relevante algoritmer. Hvis du har mange data til at træne din model med, kan de fleste indbyggede algoritmer nemt skaleres for at imødekomme efterspørgslen. Selvom du allerede har en fortrænet model, kan det stadig være lettere at bruge dens følge i SageMaker og indtaste de hyperparametre, du allerede kender, i stedet for at overføre den og selv skrive et træningsscript.
• Gennemsigtighed – Du er ejeren af ​​de resulterende modelartefakter. Du kan tage den model og implementere den på SageMaker for flere forskellige slutningsmønstre (tjek alle tilgængelige implementeringstyper) og nem slutpunktsskalering og -administration, eller du kan implementere det, hvor du ellers har brug for det.

Datavisualisering og forbehandling

Først samler vi vores kundeafgang-datasæt. Det er et relativt lille datasæt med 5,000 poster, hvor hver post bruger 21 attributter til at beskrive profilen på en kunde hos en ukendt amerikansk mobiloperatør. Egenskaberne spænder fra den amerikanske stat, hvor kunden bor, til antallet af opkald, de foretager til kundeservice, til de omkostninger, de bliver faktureret for dagtimerne opkald. Vi forsøger at forudsige, om kunden vil churne eller ej, hvilket er et binært klassifikationsproblem. Følgende er en undergruppe af disse funktioner, der ser ud, med etiketten som den sidste kolonne.

Det følgende er nogle indsigter for hver kolonne, specifikt oversigtsstatistikken og histogrammet for udvalgte funktioner.

Vi forbehandler derefter dataene, deler dem op i trænings-, validerings- og testsæt og uploader dataene til Amazon Simple Storage Service (Amazon S3).

Automatisk modeljustering af tabelformede algoritmer

Hyperparametre styrer, hvordan vores underliggende algoritmer fungerer og påvirker modellens ydeevne. Disse hyperparametre kan være antallet af lag, indlæringshastighed, vægtnedbrydningshastighed og frafald for neurale netværksbaserede modeller eller antallet af blade, iterationer og maksimal trædybde for træensemblemodeller. For at vælge den bedste model anvender vi SageMaker automatisk modeljustering på hver af de fire trænede SageMaker tabelformede algoritmer. Du behøver kun at vælge de hyperparametre, der skal indstilles, og et interval for hver parameter, der skal udforskes. For mere information om automatisk modeljustering, se Amazon SageMaker Automatic Model Tuning: Brug af Machine Learning til Machine Learning or Amazon SageMaker automatisk modeljustering: Skalerbar gradientfri optimering.

Lad os se, hvordan det fungerer i praksis.

LightGBM

Vi starter med at køre automatisk modeltuning med LightGBM, og tilpasser den proces til de andre algoritmer. Som det er forklaret i indlægget Amazon SageMaker JumpStart-modeller og algoritmer er nu tilgængelige via API, kræves følgende artefakter for at træne en forudbygget algoritme via SageMaker SDK:

• Dets rammespecifikke containerbillede, der indeholder alle de nødvendige afhængigheder til træning og inferens
• Trænings- og inferensscripts for den valgte model eller algoritme

Vi henter først disse artefakter, som afhænger af model_id (lightgbm-classification-model i dette tilfælde) og 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)

Vi får derefter standardhyperparametrene for LightGBM, indstiller nogle af dem til udvalgte faste værdier såsom antal boostingsrunder og evalueringsmetrik på valideringsdataene og definerer de værdiområder, vi ønsker at søge over for andre. Vi bruger SageMaker-parametrene ContinuousParameter , IntegerParameter for det:

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

Til sidst skaber vi en SageMaker Estimator, fodre den ind i en HyperarameterTuner, og start hyperparameterindstillingsjobbet med 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)

max_jobs parameter definerer, hvor mange samlede job der vil blive kørt i det automatiske model tuning job, og max_parallel_jobs definerer, hvor mange samtidige træningsjob der skal startes. Vi definerer også målet til “Maximize” modellens AUC (areal under kurven). At dykke dybere ned i de tilgængelige parametre udsat af HyperParameterTuner, henvise til HyperparameterTuner.

Tjek den eksempel notesbog for at se, hvordan vi går videre med at implementere og evaluere denne model på testsættet.

CatBoost

Processen til justering af hyperparameter på CatBoost-algoritmen er den samme som før, selvom vi er nødt til at hente modelartefakter under ID'et catboost-classification-model og ændre rækkevidden af ​​hyperparametre:

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

TabTransformer

Processen for hyperparameterjustering på TabTransformer-modellen er den samme som før, selvom vi skal hente modelartefakter under ID'et pytorch-tabtransformerclassification-model og ændre rækkevidden af ​​hyperparametre.

Vi ændrer også træningen instance_type til ml.p3.2xlarge. TabTransformer er en model, der for nylig er afledt af Amazon-forskning, som bringer kraften ved dyb læring til tabeldata ved hjælp af Transformer-modeller. For at træne denne model på en effektiv måde har vi brug for en GPU-understøttet instans. For mere information, se At bringe kraften ved dyb læring til data i tabeller.

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

I tilfælde af AutoGluon kører vi ikke hyperparameterjustering. Dette er designet, fordi AutoGluon fokuserer på at samle flere modeller med fornuftige valg af hyperparametre og stable dem i flere lag. Dette ender med at være mere effektivt end at træne én model med det perfekte udvalg af hyperparametre og er også beregningsmæssigt billigere. For detaljer, tjek ud AutoGluon-tabel: Robust og nøjagtig AutoML til strukturerede data.

Derfor skifter vi model_id til autogluon-classification-ensemble, og fikser kun den evalueringsmetriske hyperparameter til vores ønskede 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"

I stedet for at ringe tuner.fit(), vi ringer estimator.fit() at påbegynde et enkelt træningsjob.

Benchmarking af de trænede modeller

Når vi har implementeret alle fire modeller, sender vi det fulde testsæt til hvert endepunkt til forudsigelse og beregner nøjagtighed, F1 og AUC-metrikker for hver (se koden i eksempel notesbog). Vi præsenterer resultaterne i følgende tabel med en vigtig ansvarsfraskrivelse: Resultater og relativ ydeevne mellem disse modeller vil afhænge af det datasæt, du bruger til træning. Disse resultater er repræsentative, og selvom tendensen til, at visse algoritmer yder bedre er baseret på relevante faktorer (f.eks. samler AutoGluon intelligent forudsigelserne af både LightGBM- og CatBoost-modeller bag kulisserne), kan balancen i ydeevne ændre sig, hvis en anden data distribution.

Konklusion

I dette indlæg trænede vi fire forskellige SageMaker indbyggede algoritmer til at løse problemet med forudsigelse af kundeafgang med lav kodningsindsats. Vi brugte SageMaker automatisk modeltuning til at finde de bedste hyperparametre til at træne disse algoritmer med, og sammenlignede deres ydeevne på et udvalgt churn-forudsigelsesdatasæt. Du kan bruge den relaterede eksempel notesbog som en skabelon, udskiftning af datasættet med dit eget for at løse dit ønskede tabeldatabaserede problem.

Sørg for at prøve disse algoritmer på SageMaker, og se eksempler på notesbøger om, hvordan du bruger andre indbyggede algoritmer, der er tilgængelige på GitHub.

Om forfatterne

Dr. Xin Huang er en Applied Scientist for Amazon SageMaker JumpStart og Amazon SageMaker indbyggede algoritmer. Han fokuserer på at udvikle skalerbare maskinlæringsalgoritmer. Hans forskningsinteresser er inden for området naturlig sprogbehandling, forklarlig dyb læring på tabeldata og robust analyse af ikke-parametrisk rum-tid-klynger. Han har publiceret mange artikler i ACL, ICDM, KDD-konferencer og Royal Statistical Society: Series A journal.

João Moura er AI/ML Specialist Solutions Architect hos Amazon Web Services. Han er mest fokuseret på NLP use-cases og hjælper kunder med at optimere Deep Learning modeltræning og implementering. Han er også en aktiv fortaler for lavkode ML-løsninger og ML-specialiseret hardware.