Predicția abandonului utilizând algoritmii tabulari încorporați Amazon SageMaker LightGBM, CatBoost, TabTransformer și AutoGluon-Tabular

Amazon SageMaker oferă o suită de algoritmi încorporați, modele pre-antrenate, și șabloane de soluții prefabricate pentru a ajuta oamenii de știință de date și practicanții de învățare automată (ML) să înceapă să formeze și să implementeze rapid modele de ML. Acești algoritmi și modele pot fi utilizați atât pentru învățarea supravegheată, cât și pentru învățarea nesupravegheată. Ele pot procesa diferite tipuri de date de intrare, inclusiv tabelare, imagini și text.

Retragerea clienților este o problemă cu care se confruntă o gamă largă de companii, de la telecomunicații la servicii bancare, unde clienții sunt de obicei pierduți în fața concurenților. Este în interesul unei companii să păstreze clienții existenți, mai degrabă decât să achiziționeze clienți noi, deoarece de obicei costă mult mai mult pentru a atrage clienți noi. Operatorii de telefonie mobilă au înregistrări istorice în care clienții au continuat să folosească serviciul sau, în cele din urmă, au ajuns să se producă. Putem folosi aceste informații istorice ale abandonului unui operator de telefonie mobilă pentru a antrena un model ML. După antrenarea acestui model, putem transmite informațiile de profil ale unui client arbitrar (aceeași informații de profil pe care le-am folosit pentru antrenamentul modelului) modelului și putem să-i prevadă dacă acest client va pierde sau nu.

În această postare, ne antrenăm și implementăm patru algoritmi SageMaker lansati recent—LightGBM, CatBoost, TabTransformer și AutoGluon-Tabular — pe un set de date de predicție a pierderii. Folosim Reglarea automată a modelului SageMaker (un instrument pentru optimizarea hiperparametrilor) pentru a găsi cei mai buni hiperparametri pentru fiecare model și a compara performanța acestora pe un set de date de testare pentru a-l selecta pe cel optim.

De asemenea, puteți utiliza această soluție ca șablon pentru a căuta într-o colecție de algoritmi tabulari de ultimă generație și pentru a utiliza optimizarea hiperparametrului pentru a găsi cel mai bun model general. Puteți înlocui cu ușurință setul de date exemplu cu al dvs. pentru a rezolva problemele reale de afaceri care vă interesează. Dacă doriți să treceți direct la codul SDK SageMaker pe care îl parcurgem în această postare, puteți consulta următoarele probă de caiet Jupyter.

Beneficiile algoritmilor încorporați SageMaker

Când selectați un algoritm pentru tipul dvs. particular de problemă și date, utilizarea unui algoritm încorporat SageMaker este cea mai ușoară opțiune, deoarece acest lucru vine cu următoarele beneficii majore:

• Codare scăzută – Algoritmii încorporați necesită puțină codare pentru a începe să ruleze experimente. Singurele intrări pe care trebuie să le furnizați sunt datele, hiperparametrii și resursele de calcul. Acest lucru vă permite să desfășurați experimente mai rapid, cu mai puține cheltuieli pentru urmărirea rezultatelor și modificările codului.
• Implementări eficiente și scalabile de algoritm – Algoritmii încorporați vin cu paralelizare în mai multe instanțe de calcul și suport pentru GPU imediat pentru toți algoritmii aplicabili. Dacă aveți o mulțime de date cu care să vă antrenați modelul, majoritatea algoritmilor încorporați se pot scala cu ușurință pentru a satisface cererea. Chiar dacă aveți deja un model pre-antrenat, poate fi totuși mai ușor să utilizați corolarul său în SageMaker și să introduceți hiperparametrii pe care îi cunoașteți deja, mai degrabă decât să-l transferați și să scrieți singur un script de antrenament.
• Transparență – Sunteți proprietarul artefactelor model rezultate. Puteți lua acel model și îl puteți implementa pe SageMaker pentru mai multe modele de inferență diferite (consultați toate modelele tipurile de implementare disponibile) și scalarea și gestionarea ușoară a punctelor finale, sau îl puteți implementa oriunde mai aveți nevoie.

Vizualizarea și preprocesarea datelor

În primul rând, colectăm setul de date privind retragerea clienților. Este un set de date relativ mic, cu 5,000 de înregistrări, în care fiecare înregistrare utilizează 21 de atribute pentru a descrie profilul unui client al unui operator de telefonie mobilă din SUA necunoscut. Atributele variază de la statul SUA în care locuiește clientul, până la numărul de apeluri pe care le-au efectuat către serviciul clienți, până la costul pentru care sunt facturați pentru apelurile de zi. Încercăm să anticipăm dacă clientul va renunța sau nu, ceea ce este o problemă de clasificare binară. Următorul este un subset al acestor caracteristici, cu eticheta ca ultima coloană.

Următoarele sunt câteva informații pentru fiecare coloană, în special rezumatul statisticilor și histograma caracteristicilor selectate.

Apoi preprocesăm datele, le împărțim în seturi de instruire, validare și testare și încărcăm datele în Serviciul Amazon de stocare simplă (Amazon S3).

Reglarea automată a modelelor de algoritmi tabulari

Hiperparametrii controlează modul în care funcționează algoritmii noștri de bază și influențează performanța modelului. Acești hiperparametri pot fi numărul de straturi, rata de învățare, rata de decădere a greutății și abandonul pentru modelele bazate pe rețele neuronale sau numărul de frunze, iterații și adâncimea maximă a arborelui pentru modelele de ansamblu de arbori. Pentru a selecta cel mai bun model, aplicăm reglarea automată a modelului SageMaker fiecăruia dintre cei patru algoritmi tabulari SageMaker antrenați. Trebuie doar să selectați hiperparametrii de reglat și un interval pentru fiecare parametru de explorat. Pentru mai multe informații despre reglarea automată a modelului, consultați Reglarea automată a modelelor Amazon SageMaker: Utilizarea Machine Learning pentru Machine Learning or Ajustarea automată a modelului Amazon SageMaker: optimizare scalabilă fără gradient.

Să vedem cum funcționează acest lucru în practică.

LightGBM

Începem prin a rula reglarea automată a modelului cu LightGBM și adaptăm acel proces la ceilalți algoritmi. După cum se explică în postare Modelele și algoritmii Amazon SageMaker JumpStart sunt acum disponibile prin API, sunt necesare următoarele artefacte pentru a antrena un algoritm predefinit prin intermediul SDK-ului SageMaker:

• Imaginea containerului specific cadrului său, care conține toate dependențele necesare pentru instruire și inferență
• Scripturile de antrenament și de inferență pentru modelul sau algoritmul selectat

Mai întâi recuperăm aceste artefacte, care depind de model_id (lightgbm-classification-model în acest caz) și versiunea:

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)

Obținem apoi hiperparametrii impliciti pentru LightGBM, setăm unii dintre ei la valori fixe selectate, cum ar fi numărul de runde de stimulare și metrica de evaluare a datelor de validare și definim intervalele de valori pe care dorim să le căutăm pentru altele. Folosim parametrii SageMaker ContinuousParameter și IntegerParameter pentru aceasta:

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

În cele din urmă, creăm un SageMaker Estimator, hrăniți-l într-un HyperarameterTuner, și începeți lucrarea de reglare a hiperparametrului cu 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 parametrul definește câte joburi totale vor fi executate în jobul de reglare automată a modelului și max_parallel_jobs definește câte locuri de muncă concurente de formare ar trebui începute. De asemenea, definim obiectivul pentru “Maximize” AUC-ul modelului (aria de sub curbă). Pentru a vă scufunda mai adânc în parametrii disponibili expuși de HyperParameterTuner, a se referi la HyperparameterTuner.

Check out caiet de probă pentru a vedea cum procedăm la implementarea și evaluarea acestui model pe setul de testare.

CatBoost

Procesul de reglare a hiperparametrului pe algoritmul CatBoost este același ca înainte, deși trebuie să recuperăm artefactele modelului sub ID. catboost-classification-model și modificați selecția intervalului de hiperparametri:

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

Procesul de reglare a hiperparametrului pe modelul TabTransformer este același ca înainte, deși trebuie să recuperăm artefactele modelului sub ID. pytorch-tabtransformerclassification-model și modificați selecția intervalului de hiperparametri.

Schimbăm și antrenamentul instance_type la ml.p3.2xlarge. TabTransformer este un model derivat recent din cercetarea Amazon, care aduce puterea învățării profunde datelor tabulare folosind modele Transformer. Pentru a antrena acest model într-un mod eficient, avem nevoie de o instanță susținută de GPU. Pentru mai multe informații, consultați Aducerea puterii învățării profunde în datele din tabele.

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

În cazul AutoGluon, nu rulăm reglarea hiperparametrului. Acest lucru este prin proiectare, deoarece AutoGluon se concentrează pe asamblarea mai multor modele cu alegeri corecte de hiperparametri și stivuirea lor în mai multe straturi. Acest lucru ajunge să fie mai performant decât antrenarea unui model cu selecția perfectă de hiperparametri și este, de asemenea, mai ieftin din punct de vedere computațional. Pentru detalii, verificați AutoGluon-Tabular: AutoML robust și precis pentru date structurate.

Prin urmare, schimbăm model_id la autogluon-classification-ensembleși remediați numai hiperparametrul metricii de evaluare la scorul nostru AUC dorit:

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"

În loc să sune tuner.fit(), noi sunam estimator.fit() pentru a începe un singur loc de muncă de formare.

Evaluarea comparativă a modelelor instruite

După ce implementăm toate cele patru modele, trimitem setul complet de testare la fiecare punct final pentru predicție și calculăm acuratețea, valorile F1 și AUC pentru fiecare (vezi codul din caiet de probă). Prezentăm rezultatele în următorul tabel, cu o declinare importantă: rezultatele și performanța relativă dintre aceste modele vor depinde de setul de date pe care îl utilizați pentru antrenament. Aceste rezultate sunt reprezentative și, chiar dacă tendința anumitor algoritmi de a performa mai bine se bazează pe factori relevanți (de exemplu, AutoGluon ansamblă în mod inteligent predicțiile atât ale modelelor LightGBM, cât și ale modelelor CatBoost în culise), echilibrul în performanță s-ar putea schimba, având în vedere o schimbare diferită. distribuția datelor.

Concluzie

În această postare, am antrenat patru algoritmi încorporați SageMaker diferiți pentru a rezolva problema de predicție a abandonului clientului cu un efort redus de codare. Am folosit reglarea automată a modelului SageMaker pentru a găsi cei mai buni hiperparametri cu care să antrenăm acești algoritmi și am comparat performanța acestora pe un set de date de predicție de abandon selectat. Puteți folosi cele aferente caiet de probă ca șablon, înlocuind setul de date cu al dvs. pentru a rezolva problema dorită bazată pe date tabelare.

Asigurați-vă că încercați acești algoritmi pe SageMaker și consultați exemple de blocnotes despre cum să utilizați alți algoritmi încorporați disponibili pe GitHub.

Despre autori

Dr. Xin Huang este un om de știință aplicat pentru algoritmii încorporați Amazon SageMaker JumpStart și Amazon SageMaker. El se concentrează pe dezvoltarea de algoritmi scalabili de învățare automată. Interesele sale de cercetare sunt în domeniul procesării limbajului natural, al învățării profunde explicabile pe date tabulare și al analizei robuste a grupării neparametrice spațiu-timp. A publicat multe lucrări în ACL, ICDM, conferințe KDD și Royal Statistical Society: Series A journal.

João Moura este arhitect specializat în soluții AI/ML la Amazon Web Services. El se concentrează în principal pe cazuri de utilizare a NLP și ajută clienții să optimizeze instruirea și implementarea modelului Deep Learning. El este, de asemenea, un susținător activ al soluțiilor ML low-code și al hardware-ului specializat în ML.