Churn-prediksjon ved hjelp av Amazon SageMaker innebygde tabellalgoritmer LightGBM, CatBoost, TabTransformer og AutoGluon-Tabular

Amazon SageMaker gir en suite av innebygde algoritmer, ferdig trente modellerog forhåndsbygde løsningsmaler for å hjelpe dataforskere og maskinlæringsutøvere (ML) med å komme raskt i gang med opplæring og distribusjon av ML-modeller. Disse algoritmene og modellene kan brukes til både overvåket og uovervåket læring. De kan behandle ulike typer inndata, inkludert tabeller, bilder og tekst.

Kundeavgang er et problem for et bredt spekter av selskaper, fra telekommunikasjon til bank, hvor kundene vanligvis går tapt for konkurrenter. Det er i en bedrifts beste interesse å beholde eksisterende kunder i stedet for å skaffe nye kunder fordi det vanligvis koster betydelig mer å tiltrekke seg nye kunder. Mobiloperatører har historiske opptegnelser der kunder fortsatte å bruke tjenesten eller til slutt endte opp med å kaste seg ut. Vi kan bruke denne historiske informasjonen om en mobiloperatørs churn til å trene en ML-modell. Etter å ha trent denne modellen, kan vi sende profilinformasjonen til en vilkårlig kunde (den samme profilinformasjonen som vi brukte til å trene modellen) til modellen, og få den til å forutsi om denne kunden kommer til å churne eller ikke.

I dette innlegget trener og distribuerer vi fire nylig utgitte SageMaker-algoritmer—LightGBM, CatBoost, TabTransformer og AutoGluon-Tabular — på et churn-prediksjonsdatasett. Vi bruker SageMaker Automatisk modellinnstilling (et verktøy for hyperparameteroptimalisering) for å finne de beste hyperparametrene for hver modell, og sammenligne ytelsen deres på et holdout-testdatasett for å velge den optimale.

Du kan også bruke denne løsningen som en mal for å søke i en samling av toppmoderne tabellalgoritmer og bruke hyperparameteroptimalisering for å finne den beste generelle modellen. Du kan enkelt erstatte eksempeldatasettet med ditt eget for å løse reelle forretningsproblemer du er interessert i. Hvis du vil hoppe rett inn i SageMaker SDK-koden vi går gjennom i dette innlegget, kan du referere til følgende prøve Jupyter-notatbok.

Fordeler med SageMaker innebygde algoritmer

Når du velger en algoritme for din spesielle type problem og data, er bruk av en SageMaker innebygd algoritme det enkleste alternativet, fordi å gjøre det har følgende store fordeler:

• Lav koding – De innebygde algoritmene krever lite koding for å begynne å kjøre eksperimenter. De eneste inngangene du trenger å gi er data, hyperparametre og dataressurser. Dette lar deg kjøre eksperimenter raskere, med mindre overhead for sporing av resultater og kodeendringer.
• Effektive og skalerbare algoritmeimplementeringer – De innebygde algoritmene kommer med parallellisering på tvers av flere databehandlingsforekomster og GPU-støtte rett ut av esken for alle aktuelle algoritmer. Hvis du har mye data du kan trene modellen din med, kan de fleste innebygde algoritmer enkelt skaleres for å møte etterspørselen. Selv om du allerede har en forhåndsopplært modell, kan det fortsatt være enklere å bruke konsekvensen i SageMaker og legge inn hyperparametrene du allerede kjenner i stedet for å overføre den og skrive et treningsskript selv.
• Åpenhet – Du er eieren av de resulterende modellartefaktene. Du kan ta den modellen og distribuere den på SageMaker for flere forskjellige slutningsmønstre (sjekk ut alle tilgjengelige distribusjonstyper) og enkel endepunktskalering og -administrasjon, eller du kan distribuere den hvor du ellers trenger den.

Datavisualisering og forbehandling

Først samler vi vårt kundeavgang-datasett. Det er et relativt lite datasett med 5,000 poster, der hver post bruker 21 attributter for å beskrive profilen til en kunde hos en ukjent amerikansk mobiloperatør. Attributtene spenner fra den amerikanske delstaten der kunden er bosatt, til antall samtaler de har foretatt til kundeservice, til kostnadene de blir fakturert for samtaler på dagtid. Vi prøver å forutsi om kunden vil churne eller ikke, som er et binært klassifiseringsproblem. Følgende er en undergruppe av disse funksjonene ser ut, med etiketten som den siste kolonnen.

Følgende er noen innsikter for hver kolonne, spesielt sammendragsstatistikken og histogrammet for utvalgte funksjoner.

Vi forhåndsbehandler dataene, deler dem opp i opplærings-, validerings- og testsett, og laster opp dataene til Amazon enkel lagringstjeneste (Amazon S3).

Automatisk modellinnstilling av tabellalgoritmer

Hyperparametere kontrollerer hvordan våre underliggende algoritmer fungerer og påvirker ytelsen til modellen. Disse hyperparametrene kan være antall lag, læringshastighet, vektreduksjonshastighet og frafall for nevrale nettverksbaserte modeller, eller antall blader, iterasjoner og maksimal tredybde for treensemblemodeller. For å velge den beste modellen bruker vi SageMaker automatisk modellinnstilling på hver av de fire trente SageMaker-tabellalgoritmene. Du trenger bare å velge hyperparametrene som skal justeres og et område for hver parameter å utforske. For mer informasjon om automatisk modellinnstilling, se Amazon SageMaker Automatic Model Tuning: Use Machine Learning for Machine Learning or Amazon SageMaker automatisk modellinnstilling: Skalerbar gradientfri optimalisering.

La oss se hvordan dette fungerer i praksis.

LightGBM

Vi starter med å kjøre automatisk modellinnstilling med LightGBM, og tilpasser den prosessen til de andre algoritmene. Som forklart i innlegget Amazon SageMaker JumpStart-modeller og algoritmer er nå tilgjengelig via API, kreves følgende artefakter for å trene en forhåndsbygd algoritme via SageMaker SDK:

• Dens rammespesifikke beholderbilde, som inneholder alle nødvendige avhengigheter for trening og slutninger
• Trenings- og slutningsskriptene for den valgte modellen eller algoritmen

Vi henter først disse artefaktene, som avhenger av model_id (lightgbm-classification-model i dette tilfellet) og versjon:

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 deretter standard hyperparametrene for LightGBM, setter noen av dem til utvalgte faste verdier som antall boostingsrunder og evalueringsmetrikk på valideringsdataene, og definerer verdiområdene vi ønsker å søke over for andre. Vi bruker SageMaker-parametrene ContinuousParameter og IntegerParameter for dette:

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 slutt lager vi en SageMaker Estimator, mate den inn i en HyperarameterTuner, og start hyperparameterinnstillingsjobben 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)

De max_jobs parameter definerer hvor mange totale jobber som skal kjøres i den automatiske modellinnstillingsjobben, og max_parallel_jobs definerer hvor mange samtidige opplæringsjobber som skal startes. Vi definerer også målet til “Maximize” modellens AUC (areal under kurven). For å dykke dypere inn i de tilgjengelige parameterne eksponert av HyperParameterTuner, referere til HyperparameterTuner.

Sjekk ut prøve notatbok for å se hvordan vi går frem for å distribuere og evaluere denne modellen på testsettet.

CatBoost

Prosessen for hyperparameterinnstilling på CatBoost-algoritmen er den samme som før, selv om vi må hente modellartefakter under ID-en catboost-classification-model og endre utvalg av 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

Prosessen for hyperparameterinnstilling på TabTransformer-modellen er den samme som før, selv om vi må hente modellartefakter under ID-en pytorch-tabtransformerclassification-model og endre utvalg av hyperparametre.

Vi endrer også treningen instance_type til ml.p3.2xlarge. TabTransformer er en modell som nylig er hentet fra Amazon-forskning, som bringer kraften til dyp læring til tabelldata ved hjelp av Transformer-modeller. For å trene denne modellen på en effektiv måte trenger vi en GPU-støttet instans. For mer informasjon, se Bringe kraften til dyp 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-tabell

Når det gjelder AutoGluon, kjører vi ikke hyperparameterinnstilling. Dette er ved design, fordi AutoGluon fokuserer på å sette sammen flere modeller med fornuftige valg av hyperparametre og stable dem i flere lag. Dette ender opp med å være mer ytelsesdyktig enn å trene én modell med det perfekte utvalget av hyperparametre og er også beregningsmessig billigere. For detaljer, sjekk ut AutoGluon-tabell: Robust og nøyaktig AutoML for strukturerte data.

Derfor bytter vi model_id til autogluon-classification-ensemble, og bare fikser den evalueringsmetriske hyperparameteren til ønsket AUC-poengsum:

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 å ringe tuner.fit(), vi ringer estimator.fit() å starte en enkelt treningsjobb.

Benchmarking av de trente modellene

Etter at vi har implementert alle fire modellene, sender vi hele testsettet til hvert endepunkt for prediksjon og beregner nøyaktighet, F1 og AUC-beregninger for hver (se kode i prøve notatbok). Vi presenterer resultatene i følgende tabell, med en viktig ansvarsfraskrivelse: resultater og relativ ytelse mellom disse modellene vil avhenge av datasettet du bruker til trening. Disse resultatene er representative, og selv om tendensen til at visse algoritmer gir bedre resultater er basert på relevante faktorer (for eksempel samler AutoGluon intelligent sammen spådommene til både LightGBM- og CatBoost-modeller bak kulissene), kan balansen i ytelse endres gitt en annen datadistribusjon.

konklusjonen

I dette innlegget trente vi fire forskjellige SageMaker innebygde algoritmer for å løse prediksjonsproblemet for kundeavgang med lav kodeinnsats. Vi brukte SageMaker automatisk modellinnstilling for å finne de beste hyperparametrene å trene disse algoritmene med, og sammenlignet ytelsen deres på et utvalgt churn-prediksjonsdatasett. Du kan bruke den relaterte prøve notatbok som en mal, erstatte datasettet med ditt eget for å løse ønsket tabelldatabasert problem.

Sørg for å prøve disse algoritmene på SageMaker, og sjekk ut eksempelnotatbøker om hvordan du bruker andre innebygde algoritmer tilgjengelig på GitHub.

Om forfatterne

Dr. Xin Huang er en Applied Scientist for Amazon SageMaker JumpStart og Amazon SageMaker innebygde algoritmer. Han fokuserer på å utvikle skalerbare maskinlæringsalgoritmer. Hans forskningsinteresser er innen naturlig språkbehandling, forklarbar dyp læring på tabelldata og robust analyse av ikke-parametrisk rom-tid-klynger. Han har publisert mange artikler i ACL, ICDM, KDD-konferanser og Royal Statistical Society: Series A journal.

João Moura er en AI/ML-spesialistløsningsarkitekt hos Amazon Web Services. Han er mest fokusert på NLP-brukssaker og å hjelpe kunder med å optimalisere Deep Learning-modellopplæring og distribusjon. Han er også en aktiv talsmann for lavkode ML-løsninger og ML-spesialisert maskinvare.