Predvidevanje odliva z vgrajenimi tabelarnimi algoritmi Amazon SageMaker LightGBM, CatBoost, TabTransformer in AutoGluon-Tabular

Amazon SageMaker ponuja zbirko vgrajeni algoritmi, predhodno usposobljeni modeliin vnaprej izdelane predloge rešitev za pomoč podatkovnim znanstvenikom in izvajalcem strojnega učenja (ML), da hitro začnejo z usposabljanjem in uvajanjem modelov ML. Ti algoritmi in modeli se lahko uporabljajo za nadzorovano in nenadzorovano učenje. Obdelujejo lahko različne vrste vhodnih podatkov, vključno s tabelarnimi, slikovnimi in besedilnimi.

Odliv strank je težava, s katero se sooča široka paleta podjetij, od telekomunikacij do bančništva, kjer se stranke običajno izgubijo zaradi konkurence. V interesu podjetja je, da obdrži obstoječe stranke in ne pridobi novih strank, saj privabljanje novih strank običajno stane bistveno več. Mobilni operaterji imajo zgodovinske zapise, v katerih so stranke še naprej uporabljale storitev ali pa so se na koncu odpovedale. Te zgodovinske informacije o odlivu mobilnega operaterja lahko uporabimo za usposabljanje modela ML. Po usposabljanju tega modela lahko podatke o profilu poljubne stranke (isti podatki o profilu, ki smo jih uporabili za usposabljanje modela) posredujemo modelu in ta napove, ali bo ta stranka odpadla ali ne.

V tej objavi usposabljamo in uvajamo štirje nedavno izdani algoritmi SageMaker—LightGBM, CatBoost, TabTransformer in AutoGluon-Tabular—na naboru podatkov o napovedi odliva. Uporabljamo Samodejno prilagajanje modela SageMaker (orodje za optimizacijo hiperparametrov), da poiščete najboljše hiperparametre za vsak model in primerjate njihovo delovanje na naboru podatkov o zadrževalnem testu, da izberete optimalnega.

To rešitev lahko uporabite tudi kot predlogo za iskanje po zbirki najsodobnejših tabelarnih algoritmov in uporabite optimizacijo hiperparametrov, da poiščete najboljši splošni model. Primerni nabor podatkov lahko enostavno zamenjate s svojim, da rešite resnične poslovne težave, ki vas zanimajo. Če želite skočiti naravnost v kodo SDK SageMaker, ki jo obravnavamo v tej objavi, si lahko ogledate naslednje vzorec zvezka Jupyter.

Prednosti vgrajenih algoritmov SageMaker

Ko izbirate algoritem za svojo posebno vrsto problema in podatkov, je uporaba vgrajenega algoritma SageMaker najpreprostejša možnost, saj ima to naslednje glavne prednosti:

• Nizko kodiranje – Vgrajeni algoritmi zahtevajo malo kodiranja za začetek izvajanja poskusov. Edini vhodni podatki, ki jih morate zagotoviti, so podatki, hiperparametri in računalniški viri. To vam omogoča hitrejše izvajanje poskusov z manj stroškov za sledenje rezultatom in spremembam kode.
• Učinkovite in razširljive implementacije algoritmov – Vgrajeni algoritmi so opremljeni s paralelizacijo v več računalniških instancah in podporo GPU takoj po izdelavi za vse uporabne algoritme. Če imate veliko podatkov, s katerimi lahko usposobite svoj model, lahko večino vgrajenih algoritmov zlahka prilagodite povpraševanju. Tudi če že imate predhodno usposobljen model, bo morda vseeno lažje uporabiti njegovo posledico v SageMakerju in vnesti hiperparametre, ki jih že poznate, namesto da bi ga prenesli in sami napisali skript za usposabljanje.
• Preglednost – Ste lastnik nastalih artefaktov modela. Ta model lahko vzamete in ga namestite na SageMaker za več različnih vzorcev sklepanja (preglejte vse razpoložljive vrste uvajanja) ter enostavno prilagajanje in upravljanje končne točke ali pa ga namestite kjerkoli drugje, kjer ga potrebujete.

Vizualizacija in predprocesiranje podatkov

Najprej zberemo nabor podatkov o odlivu strank. Gre za relativno majhen nabor podatkov s 5,000 zapisi, kjer vsak zapis uporablja 21 atributov za opis profila stranke neznanega mobilnega operaterja v ZDA. Atributi segajo od zvezne države ZDA, kjer stranka prebiva, do števila klicev, ki jih je opravila služba za stranke, do stroškov, ki se ji zaračunajo za dnevne klice. Poskušamo predvideti, ali bo stranka odpadla ali ne, kar je problem binarne klasifikacije. Sledi podmnožica teh funkcij, ki izgledajo, z oznako kot zadnjim stolpcem.

Sledi nekaj vpogledov za vsak stolpec, zlasti statistika povzetka in histogram izbranih funkcij.

Podatke nato predhodno obdelamo, jih razdelimo na nize za usposabljanje, validacijo in teste ter podatke naložimo v Preprosta storitev shranjevanja Amazon (Amazon S3).

Samodejna prilagoditev modela tabelarnih algoritmov

Hiperparametri nadzirajo delovanje naših osnovnih algoritmov in vplivajo na delovanje modela. Ti hiperparametri so lahko število plasti, stopnja učenja, stopnja upada teže in osip za modele, ki temeljijo na nevronskih mrežah, ali število listov, ponovitev in največja globina drevesa za modele drevesnega ansambla. Za izbiro najboljšega modela uporabimo samodejno nastavitev modela SageMaker za vsakega od štirih usposobljenih tabelarnih algoritmov SageMaker. Izbrati morate le hiperparametre, ki jih želite prilagoditi, in obseg za vsak parameter, ki ga želite raziskati. Za več informacij o samodejni nastavitvi modela glejte Samodejno prilagajanje modela Amazon SageMaker: uporaba strojnega učenja za strojno učenje or Samodejno prilagajanje modela Amazon SageMaker: Prilagodljiva optimizacija brez gradientov.

Poglejmo, kako to deluje v praksi.

LightGBM

Začnemo z izvajanjem samodejnega prilagajanja modela z LightGBM in ta postopek prilagodimo drugim algoritmom. Kot je razloženo v objavi Modeli in algoritmi Amazon SageMaker JumpStart so zdaj na voljo prek API-ja, so potrebni naslednji artefakti za usposabljanje vnaprej izdelanega algoritma prek SDK-ja SageMaker:

• Njegova slika vsebnika, specifična za okvir, ki vsebuje vse zahtevane odvisnosti za usposabljanje in sklepanje
• Skripte za usposabljanje in sklepanje za izbrani model ali algoritem

Najprej pridobimo te artefakte, ki so odvisni od model_id (lightgbm-classification-model v tem primeru) in različica:

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)

Nato pridobimo privzete hiperparametre za LightGBM, nekatere od njih nastavimo na izbrane fiksne vrednosti, kot sta število krogov povečanja in metrika ocenjevanja na validacijskih podatkih, in definiramo obsege vrednosti, po katerih želimo iskati druge. Uporabljamo parametre SageMaker ContinuousParameter in IntegerParameter za to:

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

Na koncu ustvarimo a Ocenjevalnik SageMaker, ga vstavite v a HyperarameterTunerin zaženite opravilo nastavitve hiperparametrov z 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)

O max_jobs parameter določa, koliko skupnih opravil se bo izvajalo v opravilu samodejnega prilagajanja modela in max_parallel_jobs določa, koliko sočasnih izobraževalnih del naj se začne. Določimo tudi cilj “Maximize” AUC modela (površina pod krivuljo). Če se želite poglobiti v razpoložljive parametre, ki jih izpostavi HyperParameterTuner, nanašati se na HyperparameterTuner.

Odjaviti vzorec zvezka da vidimo, kako nadaljujemo z uvajanjem in ovrednotenjem tega modela na testnem nizu.

CatBoost

Postopek za uravnavanje hiperparametrov v algoritmu CatBoost je enak kot prej, čeprav moramo pridobiti artefakte modela pod ID-jem catboost-classification-model in spremenite izbiro obsega hiperparametrov:

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

Postopek za nastavitev hiperparametrov na modelu TabTransformer je enak kot prej, čeprav moramo pridobiti artefakte modela pod ID-jem pytorch-tabtransformerclassification-model in spremenite izbiro obsega hiperparametrov.

Spreminjamo tudi trening instance_type do ml.p3.2xlarge. TabTransformer je model, ki je bil nedavno izpeljan iz Amazonove raziskave in prinaša moč poglobljenega učenja v tabelarične podatke z uporabo modelov Transformer. Za učinkovito usposabljanje tega modela potrebujemo instanco, ki podpira GPU. Za več informacij glejte Prenos moči poglobljenega učenja v podatke v tabelah.

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

V primeru AutoGluona ne izvajamo prilagajanja hiperparametrov. To je po zasnovi, ker se AutoGluon osredotoča na združevanje več modelov z razumnimi izbirami hiperparametrov in njihovo zlaganje v več plasti. To je na koncu bolj zmogljivo kot usposabljanje enega modela s popolno izbiro hiperparametrov in je tudi računsko cenejše. Za podrobnosti preverite AutoGluon-Tabular: robusten in natančen AutoML za strukturirane podatke.

Zato zamenjamo model_id do autogluon-classification-ensemble, in samo hiperparameter metrike vrednotenja popravimo na želeno oceno AUC:

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"

Namesto klica tuner.fit(), mi kličemo estimator.fit() začeti eno samo usposabljanje.

Primerjalna analiza usposobljenih modelov

Ko uvedemo vse štiri modele, pošljemo celoten preskusni niz na vsako končno točko za predvidevanje in izračunamo meritve natančnosti, F1 in AUC za vsako (glejte kodo v vzorec zvezka). Rezultate predstavljamo v naslednji tabeli s pomembno izjavo o omejitvi odgovornosti: rezultati in relativna zmogljivost med temi modeli bodo odvisni od nabora podatkov, ki ga uporabljate za usposabljanje. Ti rezultati so reprezentativni in čeprav težnja, da nekateri algoritmi delujejo bolje, temelji na ustreznih dejavnikih (na primer AutoGluon v zakulisju inteligentno združuje napovedi obeh modelov LightGBM in CatBoost), se lahko ravnotežje v zmogljivosti spremeni glede na drugačno distribucija podatkov.

zaključek

V tej objavi smo usposobili štiri različne algoritme, vgrajene v SageMaker, da bi rešili problem napovedovanja odliva strank z nizkim naporom kodiranja. Uporabili smo samodejno uravnavanje modela SageMaker, da bi našli najboljše hiperparametre za usposabljanje teh algoritmov, in primerjali njihovo delovanje na izbranem naboru podatkov o napovedi odliva. Lahko uporabite povezane vzorec zvezka kot predlogo, pri čemer nabor podatkov zamenjate s svojim, da rešite želeno težavo na podlagi tabelarnih podatkov.

Preizkusite te algoritme na SageMakerju in si oglejte vzorčne zvezke o uporabi drugih vgrajenih algoritmov, ki so na voljo na GitHub.

O avtorjih

dr. Xin Huang je uporabni znanstvenik za vgrajene algoritme Amazon SageMaker JumpStart in Amazon SageMaker. Osredotoča se na razvoj razširljivih algoritmov strojnega učenja. Njegovi raziskovalni interesi so na področju obdelave naravnega jezika, razložljivega globokega učenja na tabelarnih podatkih in robustne analize neparametričnega prostorsko-časovnega združevanja. Objavil je številne prispevke na konferencah ACL, ICDM, KDD in v reviji Royal Statistical Society: Series A.

João Moura je specialist za rešitve AI/ML pri Amazon Web Services. Večinoma se osredotoča na primere uporabe NLP in pomaga strankam pri optimizaciji usposabljanja in uvajanja modela globokega učenja. Je tudi aktiven zagovornik rešitev ML z nizko kodo in strojne opreme, specializirane za ML.