Abwanderungsvorhersage mit den in Amazon SageMaker integrierten tabellarischen Algorithmen LightGBM, CatBoost, TabTransformer und AutoGluon-Tabular

Amazon Sage Maker bietet eine Reihe von eingebaute Algorithmen, vorgefertigte Modelle und vorgefertigte Lösungsvorlagen um Datenwissenschaftler und Praktiker des maschinellen Lernens (ML) beim schnellen Einstieg in das Training und die Bereitstellung von ML-Modellen zu unterstützen. Diese Algorithmen und Modelle können sowohl für überwachtes als auch für unüberwachtes Lernen verwendet werden. Sie können verschiedene Arten von Eingabedaten verarbeiten, darunter Tabellen, Bilder und Text.

Kundenabwanderung ist ein Problem, mit dem viele Unternehmen konfrontiert sind, von der Telekommunikation bis zum Bankwesen, wo Kunden normalerweise an Wettbewerber verloren gehen. Es ist im besten Interesse eines Unternehmens, bestehende Kunden zu halten, anstatt neue Kunden zu gewinnen, da es in der Regel erheblich mehr kostet, neue Kunden zu gewinnen. Mobilfunkbetreiber haben historische Aufzeichnungen, in denen Kunden den Dienst weiter nutzten oder letztendlich abwanderten. Wir können diese historischen Informationen über die Abwanderung eines Mobilfunkbetreibers verwenden, um ein ML-Modell zu trainieren. Nach dem Training dieses Modells können wir die Profilinformationen eines beliebigen Kunden (die gleichen Profilinformationen, die wir zum Trainieren des Modells verwendet haben) an das Modell übergeben und vorhersagen lassen, ob dieser Kunde abwandern wird oder nicht.

In diesem Beitrag trainieren und implementieren wir vier kürzlich veröffentlichte SageMaker-Algorithmen– LightGBM, CatBoost, TabTransformer und AutoGluon-Tabular – auf einem Datensatz zur Abwanderungsvorhersage. Wir gebrauchen Automatisches SageMaker-Modelltuning (ein Tool zur Hyperparameter-Optimierung), um die besten Hyperparameter für jedes Modell zu finden und ihre Leistung mit einem Holdout-Testdatensatz zu vergleichen, um den optimalen auszuwählen.

Sie können diese Lösung auch als Vorlage verwenden, um eine Sammlung modernster tabellarischer Algorithmen zu durchsuchen und mithilfe der Hyperparameter-Optimierung das beste Gesamtmodell zu finden. Sie können den Beispieldatensatz einfach durch Ihren eigenen ersetzen, um echte Geschäftsprobleme zu lösen, an denen Sie interessiert sind. Wenn Sie direkt in den SageMaker SDK-Code springen möchten, den wir in diesem Beitrag behandeln, können Sie sich auf Folgendes beziehen Beispiel Jupyter Notebook.

Vorteile der in SageMaker integrierten Algorithmen

Bei der Auswahl eines Algorithmus für Ihre spezielle Art von Problem und Daten ist die Verwendung eines in SageMaker integrierten Algorithmus die einfachste Option, da dies die folgenden Hauptvorteile bietet:

• Niedrige Codierung – Die integrierten Algorithmen erfordern wenig Codierung, um Experimente auszuführen. Die einzigen Eingaben, die Sie bereitstellen müssen, sind die Daten, Hyperparameter und Rechenressourcen. Dadurch können Sie Experimente schneller ausführen, mit weniger Overhead für das Nachverfolgen von Ergebnissen und Codeänderungen.
• Effiziente und skalierbare Algorithmusimplementierungen – Die integrierten Algorithmen werden mit Parallelisierung über mehrere Recheninstanzen und GPU-Unterstützung für alle anwendbaren Algorithmen geliefert. Wenn Sie viele Daten zum Trainieren Ihres Modells haben, können die meisten integrierten Algorithmen problemlos skaliert werden, um den Bedarf zu decken. Selbst wenn Sie bereits über ein vortrainiertes Modell verfügen, ist es möglicherweise immer noch einfacher, dessen logische Entsprechung in SageMaker zu verwenden und die bereits bekannten Hyperparameter einzugeben, anstatt es zu portieren und selbst ein Trainingsskript zu schreiben.
• Transparenz – Sie sind Eigentümer der resultierenden Modellartefakte. Sie können dieses Modell nehmen und es auf SageMaker für mehrere verschiedene Inferenzmuster einsetzen (sehen Sie sich alle verfügbare Bereitstellungstypen) und einfache Endpunktskalierung und -verwaltung, oder Sie können es überall dort bereitstellen, wo Sie es benötigen.

Datenvisualisierung und Vorverarbeitung

Zuerst sammeln wir unseren Kundenabwanderungsdatensatz. Es ist ein relativ kleiner Datensatz mit 5,000 Datensätzen, wobei jeder Datensatz 21 Attribute verwendet, um das Profil eines Kunden eines unbekannten US-Mobilfunkanbieters zu beschreiben. Die Attribute reichen vom US-Bundesstaat, in dem der Kunde wohnt, über die Anzahl der Anrufe, die er beim Kundendienst getätigt hat, bis hin zu den Kosten, die ihm für Tagesanrufe in Rechnung gestellt werden. Wir versuchen vorherzusagen, ob der Kunde abwandern wird oder nicht, was ein binäres Klassifizierungsproblem ist. Im Folgenden sehen Sie eine Teilmenge dieser Funktionen, mit der Bezeichnung als letzte Spalte.

Im Folgenden finden Sie einige Einblicke für jede Spalte, insbesondere die zusammenfassenden Statistiken und das Histogramm ausgewählter Features.

Anschließend verarbeiten wir die Daten vor, teilen sie in Trainings-, Validierungs- und Testsätze auf und laden die Daten auf hoch Amazon Simple Storage-Service (Amazon S3).

Automatische Modelloptimierung tabellarischer Algorithmen

Hyperparameter steuern, wie unsere zugrunde liegenden Algorithmen funktionieren, und beeinflussen die Leistung des Modells. Bei diesen Hyperparametern kann es sich um die Anzahl der Schichten, die Lernrate, die Gewichtsabnahmerate und den Ausfall für neuronale netzwerkbasierte Modelle oder die Anzahl der Blätter, Iterationen und die maximale Baumtiefe für Baumensemblemodelle handeln. Um das beste Modell auszuwählen, wenden wir die automatische SageMaker-Modelloptimierung auf jeden der vier trainierten tabellarischen SageMaker-Algorithmen an. Sie müssen nur die abzustimmenden Hyperparameter und einen Bereich für jeden zu untersuchenden Parameter auswählen. Weitere Informationen zur automatischen Modelloptimierung finden Sie unter Automatische Modelloptimierung von Amazon SageMaker: Verwenden von maschinellem Lernen für maschinelles Lernen or Amazon SageMaker Automatic Model Tuning: Skalierbare, gradientenfreie Optimierung.

Mal sehen, wie das in der Praxis funktioniert.

LichtGBM

Wir beginnen mit der automatischen Modelloptimierung mit LightGBM und passen diesen Prozess an die anderen Algorithmen an. Wie im Beitrag erklärt Amazon SageMaker JumpStart-Modelle und -Algorithmen jetzt über API verfügbar, sind die folgenden Artefakte erforderlich, um einen vorgefertigten Algorithmus über das SageMaker SDK zu trainieren:

• Sein Framework-spezifisches Container-Image, das alle erforderlichen Abhängigkeiten für Training und Inferenz enthält
• Die Trainings- und Inferenzskripte für das ausgewählte Modell oder den ausgewählten Algorithmus

Wir rufen zuerst diese Artefakte ab, die von der abhängen model_id (lightgbm-classification-model in diesem Fall) und 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)

Wir erhalten dann die Standard-Hyperparameter für LightGBM, setzen einige davon auf ausgewählte feste Werte wie die Anzahl der Boosting-Runden und die Bewertungsmetrik für die Validierungsdaten und definieren die Wertebereiche, die wir nach anderen durchsuchen möchten. Wir verwenden die SageMaker-Parameter ContinuousParameter und IntegerParameter dafür:

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

Zum Schluss erstellen wir eine SageMaker-Schätzer, füttern Sie es in a HyperparameterTuner, und starten Sie mit den Hyperparameter-Tuning-Job 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)

Das max_jobs Der Parameter definiert, wie viele Jobs insgesamt im Job zur automatischen Modelloptimierung ausgeführt werden, und max_parallel_jobs legt fest, wie viele gleichzeitige Trainingsjobs gestartet werden sollen. Wir definieren auch das Ziel zu “Maximize” die AUC (Fläche unter der Kurve) des Modells. Um tiefer in die verfügbaren Parameter einzutauchen HyperParameterTuner, beziehen auf HyperparameterTuner.

Probieren Sie auch die Beispiel Notizbuch um zu sehen, wie wir dieses Modell auf dem Testset bereitstellen und evaluieren.

CatBoost

Der Prozess für die Hyperparameter-Abstimmung auf dem CatBoost-Algorithmus ist derselbe wie zuvor, obwohl wir Modellartefakte unter der ID abrufen müssen catboost-classification-model und ändern Sie die Bereichsauswahl von Hyperparametern:

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

Der Prozess für die Hyperparameter-Abstimmung auf dem TabTransformer-Modell ist derselbe wie zuvor, obwohl wir Modellartefakte unter der ID abrufen müssen pytorch-tabtransformerclassification-model und die Bereichsauswahl von Hyperparametern ändern.

Wir stellen auch das Training um instance_type zu ml.p3.2xlarge. TabTransformer ist ein kürzlich aus der Amazon-Forschung abgeleitetes Modell, das mithilfe von Transformer-Modellen die Leistungsfähigkeit von Deep Learning auf tabellarische Daten überträgt. Um dieses Modell effizient zu trainieren, benötigen wir eine GPU-unterstützte Instanz. Weitere Informationen finden Sie unter Die Leistungsfähigkeit von Deep Learning für Daten in Tabellen nutzen.

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

Bei AutoGluon führen wir kein Hyperparameter-Tuning durch. Dies ist beabsichtigt, da sich AutoGluon darauf konzentriert, mehrere Modelle mit einer vernünftigen Auswahl von Hyperparametern zu vereinen und sie in mehreren Schichten zu stapeln. Dies ist am Ende performanter als das Trainieren eines Modells mit der perfekten Auswahl an Hyperparametern und auch rechnerisch günstiger. Weitere Informationen finden Sie unter AutoGluon-Tabular: Robustes und genaues AutoML für strukturierte Daten.

Deshalb wechseln wir die model_id zu autogluon-classification-ensemble, und fixieren Sie nur den Bewertungsmetrik-Hyperparameter auf unseren gewünschten AUC-Score:

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"

Anstatt anzurufen tuner.fit(), wir nennen estimator.fit() eine einzelne Ausbildungsstelle zu beginnen.

Benchmarking der trainierten Modelle

Nachdem wir alle vier Modelle bereitgestellt haben, senden wir den vollständigen Testsatz zur Vorhersage an jeden Endpunkt und berechnen für jeden die Metriken Genauigkeit, F1 und AUC (siehe Code in der Beispiel Notizbuch). Wir präsentieren die Ergebnisse in der folgenden Tabelle mit einem wichtigen Haftungsausschluss: Die Ergebnisse und die relative Leistung zwischen diesen Modellen hängen von dem Datensatz ab, den Sie für das Training verwenden. Diese Ergebnisse sind repräsentativ, und obwohl die Tendenz, dass bestimmte Algorithmen besser abschneiden, auf relevanten Faktoren basiert (z. B. kombiniert AutoGluon die Vorhersagen sowohl der LightGBM- als auch der CatBoost-Modelle hinter den Kulissen auf intelligente Weise), könnte sich das Leistungsgleichgewicht bei einem anderen ändern Datenverteilung.

Zusammenfassung

In diesem Beitrag haben wir vier verschiedene in SageMaker integrierte Algorithmen trainiert, um das Problem der Kundenabwanderung mit geringem Programmieraufwand zu lösen. Wir haben die automatische Modelloptimierung von SageMaker verwendet, um die besten Hyperparameter zum Trainieren dieser Algorithmen zu finden, und ihre Leistung mit einem ausgewählten Datensatz zur Abwanderungsvorhersage verglichen. Sie können die verwandten verwenden Beispiel Notizbuch als Vorlage, ersetzen Sie den Datensatz durch Ihren eigenen, um Ihr gewünschtes tabellarisches datenbasiertes Problem zu lösen.

Probieren Sie diese Algorithmen auf jeden Fall in SageMaker aus und sehen Sie sich Beispiel-Notebooks zur Verwendung anderer integrierter Algorithmen an, die auf verfügbar sind GitHub.

Über die Autoren

Xin Huang ist ein angewandter Wissenschaftler für Amazon SageMaker JumpStart und die integrierten Algorithmen von Amazon SageMaker. Er konzentriert sich auf die Entwicklung skalierbarer Algorithmen für maschinelles Lernen. Seine Forschungsinteressen liegen im Bereich der Verarbeitung natürlicher Sprache, erklärbares Deep Learning auf tabellarischen Daten und robuste Analyse von nichtparametrischem Raum-Zeit-Clustering. Er hat viele Artikel in ACL-, ICDM-, KDD-Konferenzen und in der Zeitschrift Royal Statistical Society: Series A veröffentlicht.

Joao Moura ist AI/ML Specialist Solutions Architect bei Amazon Web Services. Er konzentriert sich hauptsächlich auf NLP-Anwendungsfälle und hilft Kunden, das Training und die Bereitstellung von Deep-Learning-Modellen zu optimieren. Er ist auch ein aktiver Befürworter von Low-Code-ML-Lösungen und ML-spezialisierter Hardware.