Churn-förutsägelse med Amazon SageMaker inbyggda tabellalgoritmer LightGBM, CatBoost, TabTransformer och AutoGluon-Tabular

Amazon SageMaker ger en svit av inbyggda algoritmer, förutbildade modelleroch färdigbyggda lösningsmallar för att hjälpa datavetare och utövare av maskininlärning (ML) komma igång med utbildning och implementering av ML-modeller snabbt. Dessa algoritmer och modeller kan användas för både övervakat och oövervakat lärande. De kan bearbeta olika typer av indata, inklusive tabell, bild och text.

Kundavgång är ett problem som ett brett spektrum av företag står inför, från telekommunikation till bank, där kunderna vanligtvis går förlorade till konkurrenter. Det ligger i ett företags bästa intresse att behålla befintliga kunder snarare än att skaffa nya kunder eftersom det vanligtvis kostar betydligt mer att attrahera nya kunder. Mobiloperatörer har historiska register där kunder fortsatte att använda tjänsten eller till slut slutade churning. Vi kan använda denna historiska information om en mobiloperatörs churn för att träna en ML-modell. Efter att ha tränat denna modell kan vi skicka profilinformationen för en godtycklig kund (samma profilinformation som vi använde för att träna modellen) till modellen och få den att förutsäga om denna kund kommer att churna eller inte.

I det här inlägget tränar och sätter vi in fyra nyligen släppta SageMaker-algoritmer—LightGBM, CatBoost, TabTransformer och AutoGluon-Tabular — på en datauppsättning för churnprediktion. Vi använder SageMaker Automatisk modellinställning (ett verktyg för hyperparameteroptimering) för att hitta de bästa hyperparametrarna för varje modell, och jämföra deras prestanda på en holdout-testdatauppsättning för att välja den optimala.

Du kan också använda den här lösningen som en mall för att söka i en samling av toppmoderna tabellalgoritmer och använda hyperparameteroptimering för att hitta den bästa övergripande modellen. Du kan enkelt ersätta exempeldatasetet med ditt eget för att lösa verkliga affärsproblem som du är intresserad av. Om du vill hoppa rakt in i SageMaker SDK-koden vi går igenom i det här inlägget kan du hänvisa till följande exempel på Jupyter-anteckningsbok.

Fördelar med SageMaker inbyggda algoritmer

När du väljer en algoritm för din speciella typ av problem och data är det enklaste alternativet att använda en SageMaker inbyggd algoritm, eftersom att göra det kommer med följande stora fördelar:

• Låg kodning – De inbyggda algoritmerna kräver lite kodning för att börja köra experiment. De enda indata du behöver tillhandahålla är data, hyperparametrar och beräkningsresurser. Detta gör att du kan köra experiment snabbare, med mindre omkostnader för att spåra resultat och kodändringar.
• Effektiva och skalbara algoritmimplementationer – De inbyggda algoritmerna kommer med parallellisering över flera beräkningsinstanser och GPU-stöd direkt från lådan för alla tillämpliga algoritmer. Om du har mycket data att träna din modell med kan de flesta inbyggda algoritmer enkelt skalas för att möta efterfrågan. Även om du redan har en förtränad modell, kan det fortfarande vara lättare att använda dess följd i SageMaker och mata in de hyperparametrar du redan känner till istället för att överföra den och skriva ett träningsskript själv.
• Öppenhet – Du är ägaren till de resulterande modellartefakterna. Du kan ta den modellen och distribuera den på SageMaker för flera olika slutledningsmönster (kolla in alla tillgängliga distributionstyper) och enkel slutpunktsskalning och hantering, eller så kan du distribuera den var du än behöver den.

Datavisualisering och förbearbetning

Först samlar vi in ​​vår datauppsättning för kundförlust. Det är en relativt liten datauppsättning med 5,000 21 poster, där varje post använder XNUMX attribut för att beskriva profilen för en kund hos en okänd amerikansk mobiloperatör. Attributen sträcker sig från den amerikanska delstaten där kunden är bosatt, till antalet samtal de har gjort till kundtjänst, till kostnaden de faktureras för samtal dagtid. Vi försöker förutsäga om kunden kommer att churna eller inte, vilket är ett binärt klassificeringsproblem. Följande är en delmängd av dessa funktioner ser ut, med etiketten som den sista kolumnen.

Följande är några insikter för varje kolumn, särskilt sammanfattande statistik och histogram för utvalda funktioner.

Vi förbehandlar sedan data, delar upp den i tränings-, validerings- och testset och laddar upp data till Amazon enkel lagringstjänst (Amazon S3).

Automatisk modellinställning av tabellalgoritmer

Hyperparametrar styr hur våra underliggande algoritmer fungerar och påverkar modellens prestanda. Dessa hyperparametrar kan vara antalet lager, inlärningshastighet, viktnedgångshastighet och bortfall för neurala nätverksbaserade modeller, eller antalet löv, iterationer och maximalt träddjup för trädensemblemodeller. För att välja den bästa modellen använder vi SageMaker automatisk modellinställning på var och en av de fyra tränade SageMaker tabellalgoritmerna. Du behöver bara välja hyperparametrarna att ställa in och ett intervall för varje parameter att utforska. För mer information om automatisk modellinställning, se Amazon SageMaker automatisk modellinställning: Använda maskininlärning för maskininlärning or Amazon SageMaker automatisk modellinställning: Skalbar gradientfri optimering.

Låt oss se hur detta fungerar i praktiken.

LightGBM

Vi börjar med att köra automatisk modellinställning med LightGBM, och anpassar den processen till de andra algoritmerna. Som förklaras i inlägget Amazon SageMaker JumpStart-modeller och algoritmer är nu tillgängliga via API, krävs följande artefakter för att träna en förbyggd algoritm via SageMaker SDK:

• Dess ramspecifika containerbild, som innehåller alla nödvändiga beroenden för träning och slutledning
• Utbildnings- och slutledningsskripten för den valda modellen eller algoritmen

Vi hämtar först dessa artefakter, som beror på model_id (lightgbm-classification-model i detta fall) och 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 sedan standardhyperparametrarna för LightGBM, ställer in några av dem på utvalda fasta värden som antal boostningsrundor och utvärderingsmått på valideringsdata, och definierar värdeintervallen vi vill söka över för andra. Vi använder SageMaker-parametrarna ContinuousParameter och IntegerParameter för detta:

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

Slutligen skapar vi en SageMaker Estimator, mata in den i en HyperarameterTuner, och starta hyperparameterjusteringsjobbet 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)

Smakämnen max_jobs parametern definierar hur många totala jobb som kommer att köras i det automatiska modellinställningsjobbet, och max_parallel_jobs definierar hur många samtidiga utbildningsjobb som ska påbörjas. Vi definierar också målet att “Maximize” modellens AUC (area under kurvan). För att dyka djupare in i de tillgängliga parametrarna som exponeras av HyperParameterTuner, hänvisa till HyperparameterTuner.

Kolla in prov anteckningsbok för att se hur vi går vidare för att distribuera och utvärdera denna modell på testsetet.

CatBoost

Processen för hyperparameterinställning på CatBoost-algoritmen är densamma som tidigare, även om vi måste hämta modellartefakter under ID:t catboost-classification-model och ändra intervallvalet av hyperparametrar:

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 för hyperparameterjustering på TabTransformer-modellen är densamma som tidigare, även om vi måste hämta modellartefakter under ID:t pytorch-tabtransformerclassification-model och ändra intervallvalet av hyperparametrar.

Vi ändrar också träningen instance_type till ml.p3.2xlarge. TabTransformer är en modell som nyligen härstammar från Amazons forskning, som ger kraften i djupinlärning till tabelldata med hjälp av Transformer-modeller. För att träna denna modell på ett effektivt sätt behöver vi en GPU-stödd instans. För mer information, se Att föra kraften med djupinlärning till 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

I fallet med AutoGluon kör vi inte hyperparameterinställning. Detta är designat, eftersom AutoGluon fokuserar på att skapa flera modeller med förnuftiga val av hyperparametrar och stapla dem i flera lager. Detta slutar med att bli mer presterande än att träna en modell med det perfekta urvalet av hyperparametrar och är också beräkningsmässigt billigare. För detaljer, kolla in AutoGluon-tabell: Robust och exakt AutoML för strukturerad data.

Därför byter vi model_id till autogluon-classification-ensemble, och fixa endast den utvärderingsmetriska hyperparametern till vårt önskade AUC-poäng:

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"

Istället för att ringa tuner.fit(), vi ringer estimator.fit() att påbörja ett enda träningsjobb.

Benchmarking av utbildade modeller

När vi har implementerat alla fyra modellerna skickar vi hela testsetet till varje slutpunkt för förutsägelse och beräknar noggrannhet, F1 och AUC-mått för var och en (se koden i prov anteckningsbok). Vi presenterar resultaten i följande tabell, med en viktig ansvarsfriskrivning: resultat och relativ prestanda mellan dessa modeller beror på den datauppsättning du använder för träning. Dessa resultat är representativa, och även om tendensen för vissa algoritmer att prestera bättre är baserad på relevanta faktorer (till exempel, AutoGluon sammanställer intelligenta förutsägelser av både LightGBM- och CatBoost-modeller bakom kulisserna), kan balansen i prestanda förändras med en annan datadistribution.

Slutsats

I det här inlägget tränade vi fyra olika SageMaker inbyggda algoritmer för att lösa problemet med förutsägelse av kundavgång med låg kodningsansträngning. Vi använde SageMaker automatisk modellinställning för att hitta de bästa hyperparametrarna att träna dessa algoritmer med och jämförde deras prestanda på en utvald datauppsättning för churnprediktion. Du kan använda relaterade prov anteckningsbok som en mall, ersätt datauppsättningen med din egen för att lösa önskat tabelldatabaserat problem.

Se till att prova dessa algoritmer på SageMaker, och kolla in exempel på anteckningsböcker om hur du använder andra inbyggda algoritmer som finns på GitHub.

Om författarna

Dr Xin Huang är en tillämpad forskare för Amazon SageMaker JumpStart och Amazon SageMaker inbyggda algoritmer. Han fokuserar på att utveckla skalbara maskininlärningsalgoritmer. Hans forskningsintressen är inom området naturlig språkbehandling, förklarlig djupinlärning på tabelldata och robust analys av icke-parametrisk rum-tid-klustring. Han har publicerat många artiklar i ACL, ICDM, KDD-konferenser och Royal Statistical Society: Series A journal.

João Moura är en AI/ML Specialist Solutions Architect på Amazon Web Services. Han är mest fokuserad på NLP-användningsfall och att hjälpa kunder att optimera utbildning och implementering av Deep Learning-modeller. Han är också en aktiv förespråkare för ML-lösningar med låg kod och ML-specialiserad hårdvara.