Przewidywanie rezygnacji przy użyciu wbudowanych algorytmów tabelarycznych Amazon SageMaker LightGBM, CatBoost, TabTransformer i AutoGluon-Tabular

Amazon Sage Maker zapewnia pakiet wbudowane algorytmy, wstępnie wytrenowane modele, gotowe szablony rozwiązań aby pomóc naukowcom danych i praktykom uczenia maszynowego (ML) rozpocząć szybkie szkolenie i wdrażanie modeli ML. Te algorytmy i modele mogą być wykorzystywane zarówno do uczenia nadzorowanego, jak i nienadzorowanego. Mogą przetwarzać różne typy danych wejściowych, w tym tabelaryczne, graficzne i tekstowe.

Odpływ klientów to problem, z którym boryka się wiele firm, od telekomunikacyjnych po bankowe, gdzie klienci są zazwyczaj traceni przez konkurencję. W najlepszym interesie firmy jest utrzymanie dotychczasowych klientów, a nie pozyskiwanie nowych, ponieważ zwykle przyciągnięcie nowych klientów kosztuje znacznie więcej. Operatorzy komórkowi posiadają historyczne zapisy, w których klienci nadal korzystali z usługi lub ostatecznie zakończyli odejście. Możemy wykorzystać te historyczne informacje o rezygnacji operatora komórkowego do trenowania modelu ML. Po przeszkoleniu tego modelu możemy przekazać informacje o profilu dowolnego klienta (te same informacje o profilu, których użyliśmy do trenowania modelu) do modelu i przewidzieć, czy ten klient zrezygnuje, czy nie.

W tym poście szkolimy i wdrażamy cztery niedawno wydane algorytmy SageMaker— LightGBM, CatBoost, TabTransformer i AutoGluon-Tabular — w zestawie danych przewidywania rezygnacji. Używamy Automatyczne strojenie modeli SageMaker (narzędzie do optymalizacji hiperparametrów), aby znaleźć najlepsze hiperparametry dla każdego modelu i porównać ich wydajność na zestawie danych testowych wstrzymania, aby wybrać optymalny.

Możesz również użyć tego rozwiązania jako szablonu do przeszukiwania kolekcji najnowocześniejszych algorytmów tabelarycznych i użyć optymalizacji hiperparametrów w celu znalezienia najlepszego ogólnego modelu. Możesz łatwo zastąpić przykładowy zestaw danych własnym, aby rozwiązać rzeczywiste problemy biznesowe, które Cię interesują. Jeśli chcesz przejść bezpośrednio do kodu SDK SageMaker, który omawiamy w tym poście, możesz zapoznać się z następującym przykładowy notatnik Jupyter.

Korzyści z wbudowanych algorytmów SageMaker

Podczas wybierania algorytmu dla konkretnego typu problemu i danych, najłatwiej jest użyć wbudowanego algorytmu programu SageMaker, ponieważ wiąże się to z następującymi głównymi korzyściami:

• Niskie kodowanie – Wbudowane algorytmy wymagają niewielkiego kodowania, aby rozpocząć przeprowadzanie eksperymentów. Jedyne dane wejściowe, które musisz podać, to dane, hiperparametry i zasoby obliczeniowe. Pozwala to na szybsze przeprowadzanie eksperymentów i mniejsze obciążenie związane ze śledzeniem wyników i zmianami w kodzie.
• Wydajne i skalowalne implementacje algorytmów – Wbudowane algorytmy zapewniają równoległość w wielu instancjach obliczeniowych oraz obsługę GPU od razu po wyjęciu z pudełka dla wszystkich odpowiednich algorytmów. Jeśli masz dużo danych do trenowania swojego modelu, większość wbudowanych algorytmów można łatwo skalować w celu zaspokojenia zapotrzebowania. Nawet jeśli masz już wstępnie wytrenowany model, nadal może być łatwiej użyć jego odpowiednika w programie SageMaker i wprowadzić hiperparametry, które już znasz, niż przenieść go i samodzielnie napisać skrypt szkoleniowy.
• Przezroczystość – Jesteś właścicielem powstałych artefaktów modelu. Możesz wziąć ten model i wdrożyć go w SageMaker dla kilku różnych wzorców wnioskowania (sprawdź wszystkie dostępne typy wdrożeń) oraz łatwe skalowanie i zarządzanie punktami końcowymi. Możesz też wdrożyć go w dowolnym innym miejscu.

Wizualizacja i wstępne przetwarzanie danych

Najpierw zbieramy nasz zbiór danych o odejściu klientów. Jest to stosunkowo mały zbiór danych zawierający 5,000 rekordów, gdzie każdy rekord wykorzystuje 21 atrybutów do opisania profilu klienta nieznanego amerykańskiego operatora telefonii komórkowej. Atrybuty wahają się od stanu USA, w którym mieszka klient, przez liczbę połączeń, które wykonał do obsługi klienta, po koszt, jaki są naliczane za połączenia w ciągu dnia. Staramy się przewidzieć, czy klient odejdzie, czy nie, co jest problemem klasyfikacji binarnej. Poniżej znajduje się podzbiór tych funkcji, które wyglądają, z etykietą w ostatniej kolumnie.

Poniżej przedstawiono niektóre informacje dla każdej kolumny, w szczególności statystyki podsumowujące i histogram wybranych funkcji.

Następnie wstępnie przetwarzamy dane, dzielimy je na zestawy treningowe, walidacyjne i testowe, a następnie przesyłamy dane do Usługa Amazon Simple Storage (Amazonka S3).

Automatyczne strojenie modeli algorytmów tabelarycznych

Hiperparametry kontrolują sposób działania naszych podstawowych algorytmów i wpływają na wydajność modelu. Tymi hiperparametrami mogą być liczba warstw, szybkość uczenia się, szybkość zanikania wagi i porzucanie w przypadku modeli opartych na sieciach neuronowych lub liczba liści, iteracje i maksymalna głębokość drzewa w przypadku modeli zespołów drzew. Aby wybrać najlepszy model, stosujemy automatyczne dostrajanie modelu SageMaker do każdego z czterech wytrenowanych algorytmów tabelarycznych SageMaker. Musisz tylko wybrać hiperparametry do dostrojenia i zakres dla każdego parametru do zbadania. Aby uzyskać więcej informacji na temat automatycznego dostrajania modeli, zobacz Amazon SageMaker Automatyczne dostrajanie modelu: korzystanie z uczenia maszynowego do uczenia maszynowego or Automatyczne dostrajanie modeli Amazon SageMaker: Skalowalna optymalizacja bez gradientów.

Zobaczmy, jak to działa w praktyce.

LekkiGBM

Zaczynamy od uruchomienia automatycznego dostrajania modeli za pomocą LightGBM i dostosowania tego procesu do innych algorytmów. Jak wyjaśniono w poście Modele i algorytmy Amazon SageMaker JumpStart są teraz dostępne przez API, do wytrenowania gotowego algorytmu za pomocą pakietu SageMaker SDK wymagane są następujące artefakty:

• Jego obraz kontenera specyficzny dla platformy, zawierający wszystkie wymagane zależności do trenowania i wnioskowania
• Skrypty uczące i wnioskowania dla wybranego modelu lub algorytmu

Najpierw pobieramy te artefakty, które zależą od model_id (lightgbm-classification-model w tym przypadku) i wersji:

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)

Następnie otrzymujemy domyślne hiperparametry dla LightGBM, ustawiamy niektóre z nich na wybrane stałe wartości, takie jak liczba rund wzmacniających i metryka oceny na danych walidacyjnych, i definiujemy zakresy wartości, które chcemy przeszukać dla innych. Używamy parametrów SageMaker ContinuousParameter i IntegerParameter dla tego:

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

Wreszcie tworzymy Estymator SageMakera, wrzuć go do HyperarametrTuneri rozpocznij zadanie dostrajania hiperparametrów za pomocą 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)

Połączenia max_jobs parametr określa, ile łącznie zadań zostanie uruchomionych w zadaniu automatycznego dostrajania modelu, oraz max_parallel_jobs określa, ile jednoczesnych zadań szkoleniowych należy rozpocząć. Definiujemy również cel, aby “Maximize” AUC modelu (pole pod krzywą). Aby głębiej zagłębić się w dostępne parametry wyeksponowane przez HyperParameterTuner, odnosić się do HyperparametrTuner.

Zapoznaj się z przykładowy notatnik aby zobaczyć, jak przystępujemy do wdrażania i oceny tego modelu na zestawie testowym.

KotBoost

Proces dostrajania hiperparametrów w algorytmie CatBoost jest taki sam jak poprzednio, chociaż musimy pobrać artefakty modelu pod ID catboost-classification-model i zmień wybór zakresu hiperparametrów:

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

Karta Transformator

Proces dostrajania hiperparametrów w modelu TabTransformer jest taki sam jak wcześniej, chociaż musimy pobrać artefakty modelu pod ID pytorch-tabtransformerclassification-model i zmień wybór zakresu hiperparametrów.

Zmieniamy też szkolenie instance_type do ml.p3.2xlarge. TabTransformer to model wywodzący się niedawno z badań Amazon, który wnosi moc głębokiego uczenia do danych tabelarycznych za pomocą modeli Transformer. Aby efektywnie trenować ten model, potrzebujemy wystąpienia wspieranego przez GPU. Aby uzyskać więcej informacji, zobacz Wprowadzanie mocy głębokiego uczenia do danych w tabelach.

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

W przypadku AutoGluona nie prowadzimy dostrajania hiperparametrów. Jest to zgodne z projektem, ponieważ AutoGluon koncentruje się na łączeniu wielu modeli z rozsądnym wyborem hiperparametrów i układaniu ich w wielu warstwach. W rezultacie jest to bardziej wydajne niż trenowanie jednego modelu z doskonałym wyborem hiperparametrów, a także jest tańsze obliczeniowo. Aby uzyskać szczegółowe informacje, sprawdź AutoGluon-Tabular: Solidny i dokładny AutoML dla danych strukturalnych.

Dlatego przełączamy model_id do autogluon-classification-ensemblei ustaw hiperparametr metryki oceny tylko na żądany wynik 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"

Zamiast dzwonić tuner.fit(), nazywamy estimator.fit() rozpocząć pojedynczą pracę szkoleniową.

Benchmarking wyszkolonych modeli

Po wdrożeniu wszystkich czterech modeli wysyłamy pełny zestaw testowy do każdego punktu końcowego w celu przewidywania i obliczania dokładności, metryk F1 i AUC dla każdego z nich (patrz kod w przykładowy notatnik). Wyniki przedstawiamy w poniższej tabeli, z ważnym zastrzeżeniem: wyniki i względna wydajność między tymi modelami będą zależeć od zestawu danych używanego do szkolenia. Wyniki te są reprezentatywne i chociaż tendencja do osiągania lepszych wyników przez niektóre algorytmy jest oparta na odpowiednich czynnikach (na przykład AutoGluon inteligentnie zestawia prognozy zarówno modeli LightGBM, jak i CatBoost za kulisami), równowaga wydajności może się zmienić, biorąc pod uwagę inne dystrybucja danych.

Wnioski

W tym poście przeszkoliliśmy cztery różne wbudowane algorytmy SageMaker, aby rozwiązać problem przewidywania rezygnacji klientów przy niskim nakładzie pracy w zakresie kodowania. Wykorzystaliśmy automatyczne dostrajanie modelu SageMaker, aby znaleźć najlepsze hiperparametry do trenowania tych algorytmów i porównaliśmy ich wydajność na wybranym zestawie danych przewidywania rezygnacji. Możesz użyć powiązanego przykładowy notatnik jako szablon, zastępując zestaw danych własnym, aby rozwiązać żądany problem oparty na danych tabelarycznych.

Wypróbuj te algorytmy w programie SageMaker i zapoznaj się z przykładowymi notatnikami, jak korzystać z innych wbudowanych algorytmów dostępnych w GitHub.

O autorach

Dr Xin Huang jest naukowcem w zakresie wbudowanych algorytmów Amazon SageMaker JumpStart i Amazon SageMaker. Koncentruje się na tworzeniu skalowalnych algorytmów uczenia maszynowego. Jego zainteresowania badawcze dotyczą przetwarzania języka naturalnego, wyjaśnialnego głębokiego uczenia się na danych tabelarycznych oraz solidnej analizy nieparametrycznego klastrowania przestrzenno-czasowego. Opublikował wiele artykułów na konferencjach ACL, ICDM, KDD oraz Royal Statistical Society: Series A.

Joao Moura jest specjalistą ds. rozwiązań AI/ML w Amazon Web Services. Koncentruje się głównie na przypadkach użycia NLP i pomaga klientom zoptymalizować szkolenie i wdrażanie modelu Deep Learning. Jest również aktywnym zwolennikiem rozwiązań ML typu low-code oraz sprzętu wyspecjalizowanego w ML.