Previsione dell'abbandono utilizzando gli algoritmi tabulari integrati di Amazon SageMaker LightGBM, CatBoost, TabTransformer e AutoGluon-Tabular

Amazon Sage Maker fornisce una suite di algoritmi incorporati, modelli pre-addestratie modelli di soluzioni predefiniti per aiutare i data scientist e i professionisti dell'apprendimento automatico (ML) a iniziare ad addestrare e distribuire rapidamente i modelli ML. Questi algoritmi e modelli possono essere utilizzati sia per l'apprendimento supervisionato che non supervisionato. Possono elaborare vari tipi di dati di input, inclusi tabulari, immagini e testo.

L'abbandono dei clienti è un problema affrontato da un'ampia gamma di aziende, dalle telecomunicazioni alle banche, dove i clienti sono generalmente persi rispetto alla concorrenza. È nell'interesse di un'azienda mantenere i clienti esistenti piuttosto che acquisirne di nuovi perché di solito costa molto di più per attirare nuovi clienti. Gli operatori di telefonia mobile hanno record storici in cui i clienti hanno continuato a utilizzare il servizio o alla fine hanno finito per agitarsi. Possiamo utilizzare queste informazioni storiche sull'abbandono di un operatore di telefonia mobile per addestrare un modello ML. Dopo aver addestrato questo modello, possiamo passare le informazioni del profilo di un cliente arbitrario (le stesse informazioni del profilo che abbiamo usato per addestrare il modello) al modello e fare in modo che preveda se questo cliente cambierà o meno.

In questo post, ci alleniamo e distribuiamo quattro algoritmi SageMaker rilasciati di recente—LightGBM, CatBoost, TabTransformer e AutoGluon-Tabular — su un set di dati di previsione dell'abbandono. Noi usiamo Sintonizzazione automatica del modello SageMaker (uno strumento per l'ottimizzazione degli iperparametri) per trovare i migliori iperparametri per ciascun modello e confrontare le loro prestazioni su un set di dati di test di resistenza per selezionare quello ottimale.

Puoi anche utilizzare questa soluzione come modello per eseguire ricerche in una raccolta di algoritmi tabulari all'avanguardia e utilizzare l'ottimizzazione degli iperparametri per trovare il miglior modello generale. Puoi facilmente sostituire il set di dati di esempio con il tuo per risolvere i problemi aziendali reali che ti interessano. Se vuoi passare direttamente al codice SageMaker SDK che esamineremo in questo post, puoi fare riferimento a quanto segue esempio di taccuino Jupyter.

Vantaggi degli algoritmi integrati di SageMaker

Quando si seleziona un algoritmo per il proprio tipo particolare di problema e dati, l'utilizzo di un algoritmo integrato di SageMaker è l'opzione più semplice, poiché ciò comporta i seguenti vantaggi principali:

• Codifica bassa – Gli algoritmi integrati richiedono poca codifica per iniziare a eseguire esperimenti. Gli unici input che devi fornire sono i dati, gli iperparametri e le risorse di calcolo. Ciò ti consente di eseguire esperimenti più rapidamente, con un sovraccarico minore per il monitoraggio dei risultati e delle modifiche al codice.
• Implementazioni di algoritmi efficienti e scalabili – Gli algoritmi integrati sono dotati di parallelizzazione su più istanze di calcolo e supporto GPU pronto all'uso per tutti gli algoritmi applicabili. Se hai molti dati con cui addestrare il tuo modello, la maggior parte degli algoritmi integrati può facilmente scalare per soddisfare la domanda. Anche se disponi già di un modello pre-addestrato, potrebbe essere comunque più semplice utilizzare il suo corollario in SageMaker e inserire gli iperparametri che già conosci piuttosto che trasferirlo e scrivere tu stesso uno script di addestramento.
• Trasparenza – Sei il proprietario degli artefatti del modello risultanti. Puoi prendere quel modello e distribuirlo su SageMaker per diversi modelli di inferenza (controlla tutti i tipi di distribuzione disponibili) e una facile scalabilità e gestione degli endpoint, oppure puoi distribuirlo ovunque ti serva.

Visualizzazione e preelaborazione dei dati

Innanzitutto, raccogliamo il nostro set di dati sull'abbandono dei clienti. È un set di dati relativamente piccolo con 5,000 record, in cui ogni record utilizza 21 attributi per descrivere il profilo di un cliente di un operatore mobile statunitense sconosciuto. Gli attributi vanno dallo stato USA in cui risiede il cliente, al numero di chiamate che ha effettuato al servizio clienti, al costo addebitato per le chiamate diurne. Stiamo cercando di prevedere se il cliente si ritirerà o meno, il che è un problema di classificazione binaria. Di seguito è riportato un sottoinsieme di tali funzioni, con l'etichetta come ultima colonna.

Di seguito sono riportati alcuni approfondimenti per ciascuna colonna, in particolare le statistiche di riepilogo e l'istogramma delle funzionalità selezionate.

Quindi pre-elaboriamo i dati, li suddividiamo in set di addestramento, convalida e test e carichiamo i dati su Servizio di archiviazione semplice Amazon (Amazon S3).

Ottimizzazione automatica del modello di algoritmi tabulari

Gli iperparametri controllano il modo in cui operano i nostri algoritmi sottostanti e influenzano le prestazioni del modello. Questi iperparametri possono essere il numero di livelli, la velocità di apprendimento, la velocità di decadimento del peso e l'abbandono per i modelli basati su reti neurali, oppure il numero di foglie, le iterazioni e la profondità massima dell'albero per i modelli di complessi di alberi. Per selezionare il modello migliore, applichiamo l'ottimizzazione automatica del modello SageMaker a ciascuno dei quattro algoritmi tabulari SageMaker addestrati. Devi solo selezionare gli iperparametri da ottimizzare e un intervallo per ciascun parametro da esplorare. Per ulteriori informazioni sull'ottimizzazione automatica del modello, fare riferimento a Ottimizzazione automatica dei modelli di Amazon SageMaker: utilizzo dell'apprendimento automatico per l'apprendimento automatico or Ottimizzazione automatica del modello Amazon SageMaker: ottimizzazione scalabile senza gradienti.

Vediamo come funziona in pratica.

LuceGBM

Iniziamo eseguendo l'ottimizzazione automatica del modello con LightGBM e adattiamo tale processo agli altri algoritmi. Come spiegato nel post Modelli e algoritmi Amazon SageMaker JumpStart ora disponibili tramite API, sono necessari i seguenti artefatti per addestrare un algoritmo predefinito tramite SageMaker SDK:

• L'immagine del contenitore specifica del framework, contenente tutte le dipendenze necessarie per l'addestramento e l'inferenza
• Gli script di addestramento e inferenza per il modello o l'algoritmo selezionato

Per prima cosa recuperiamo questi artefatti, che dipendono dal model_id (lightgbm-classification-model in questo caso) e versione:

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)

Quindi otteniamo gli iperparametri predefiniti per LightGBM, ne impostiamo alcuni su valori fissi selezionati come il numero di cicli di potenziamento e la metrica di valutazione sui dati di convalida e definiamo gli intervalli di valori su cui vogliamo cercare altri. Usiamo i parametri SageMaker ContinuousParameter ed IntegerParameter per questo:

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

Infine, creiamo un Estimatore di SageMaker, inseriscilo in a Hyperarameter Tunere avviare il processo di ottimizzazione degli iperparametri con 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)

I max_jobs il parametro definisce quanti lavori totali verranno eseguiti nel lavoro di ottimizzazione del modello automatico e max_parallel_jobs definisce quanti lavori di formazione simultanei devono essere avviati. Definiamo anche l'obiettivo a “Maximize” l'AUC del modello (area sotto la curva). Per approfondire i parametri disponibili esposti da HyperParameterTuner, fare riferimento a Sintonizzatore iperparametri.

Guarda la taccuino di esempio per vedere come procedere per distribuire e valutare questo modello sul set di test.

Cat Boost

Il processo per l'ottimizzazione degli iperparametri sull'algoritmo CatBoost è lo stesso di prima, sebbene sia necessario recuperare gli artefatti del modello sotto l'ID catboost-classification-model e modificare la selezione dell'intervallo degli iperparametri:

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

Trasformatore di schede

Il processo per l'ottimizzazione degli iperparametri sul modello TabTransformer è lo stesso di prima, sebbene sia necessario recuperare gli artefatti del modello sotto l'ID pytorch-tabtransformerclassification-model e modificare la selezione dell'intervallo degli iperparametri.

Cambiamo anche la formazione instance_type a ml.p3.2xlarge. TabTransformer è un modello recentemente derivato dalla ricerca Amazon, che porta la potenza del deep learning ai dati tabulari utilizzando i modelli Transformer. Per addestrare questo modello in modo efficiente, abbiamo bisogno di un'istanza supportata da GPU. Per ulteriori informazioni, fare riferimento a Portare la potenza del deep learning ai dati nelle tabelle.

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

Nel caso di AutoGluon, non eseguiamo l'ottimizzazione degli iperparametri. Questo è in base alla progettazione, perché AutoGluon si concentra sull'assemblare più modelli con scelte sane di iperparametri e impilarli in più livelli. Questo finisce per essere più performante rispetto all'addestramento di un modello con la perfetta selezione di iperparametri ed è anche computazionalmente più economico. Per i dettagli, controlla AutoGluon-Tabular: AutoML robusto e accurato per dati strutturati.

Pertanto, cambiamo il model_id a autogluon-classification-ensemblee correggi l'iperparametro della metrica di valutazione solo sul punteggio AUC desiderato:

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"

Invece di chiamare tuner.fit(), Noi chiamiamo estimator.fit() per avviare un unico lavoro di formazione.

Analisi comparativa dei modelli addestrati

Dopo aver distribuito tutti e quattro i modelli, inviamo il set di test completo a ciascun endpoint per la previsione e il calcolo dell'accuratezza, delle metriche F1 e AUC per ciascuno (vedere il codice nella taccuino di esempio). Presentiamo i risultati nella tabella seguente, con un'importante dichiarazione di non responsabilità: i risultati e le prestazioni relative tra questi modelli dipenderanno dal set di dati utilizzato per l'addestramento. Questi risultati sono rappresentativi e, anche se la tendenza di alcuni algoritmi a funzionare meglio si basa su fattori rilevanti (ad esempio, AutoGluon raggruppa in modo intelligente le previsioni di entrambi i modelli LightGBM e CatBoost dietro le quinte), l'equilibrio delle prestazioni potrebbe cambiare dato un diverso distribuzione dei dati.

Conclusione

In questo post, abbiamo addestrato quattro diversi algoritmi integrati di SageMaker per risolvere il problema della previsione dell'abbandono dei clienti con uno sforzo di codifica ridotto. Abbiamo utilizzato l'ottimizzazione automatica del modello SageMaker per trovare i migliori iperparametri con cui addestrare questi algoritmi e confrontarne le prestazioni su un set di dati di previsione dell'abbandono selezionato. Puoi usare il relativo taccuino di esempio come modello, sostituendo il set di dati con il tuo per risolvere il problema basato sui dati tabulari desiderato.

Assicurati di provare questi algoritmi su SageMaker e dai un'occhiata a quaderni di esempio su come utilizzare altri algoritmi integrati disponibili su GitHub.

Circa gli autori

Dott. Xin Huang è uno scienziato applicato per gli algoritmi integrati Amazon SageMaker JumpStart e Amazon SageMaker. Si concentra sullo sviluppo di algoritmi di apprendimento automatico scalabili. I suoi interessi di ricerca sono nell'area dell'elaborazione del linguaggio naturale, del deep learning spiegabile su dati tabulari e dell'analisi robusta del clustering spazio-temporale non parametrico. Ha pubblicato molti articoli su ACL, ICDM, conferenze KDD e Royal Statistical Society: rivista di serie A.

João Moura è un architetto specializzato in soluzioni AI/ML presso Amazon Web Services. Si concentra principalmente sui casi d'uso della NLP e aiuta i clienti a ottimizzare la formazione e l'implementazione del modello di Deep Learning. È anche un attivo sostenitore di soluzioni ML a basso codice e hardware specializzato in ML.