Prediksi churn menggunakan algoritme tabel bawaan Amazon SageMaker LightGBM, CatBoost, TabTransformer, dan AutoGluon-Tabular

Amazon SageMaker menyediakan serangkaian algoritme bawaan, model pra-terlatih, dan templat solusi yang dibuat sebelumnya untuk membantu ilmuwan data dan praktisi pembelajaran mesin (ML) memulai pelatihan dan menerapkan model ML dengan cepat. Algoritma dan model ini dapat digunakan untuk pembelajaran yang diawasi dan tidak diawasi. Mereka dapat memproses berbagai jenis data input, termasuk tabular, gambar, dan teks.

Churn pelanggan adalah masalah yang dihadapi oleh berbagai perusahaan, dari telekomunikasi hingga perbankan, di mana pelanggan biasanya kalah dari pesaing. Adalah kepentingan terbaik perusahaan untuk mempertahankan pelanggan yang sudah ada daripada memperoleh pelanggan baru karena biasanya biaya yang jauh lebih besar untuk menarik pelanggan baru. Operator seluler memiliki catatan sejarah di mana pelanggan terus menggunakan layanan atau akhirnya berhenti. Kami dapat menggunakan informasi historis churn operator seluler ini untuk melatih model ML. Setelah melatih model ini, kami dapat meneruskan informasi profil pelanggan yang berubah-ubah (informasi profil yang sama yang kami gunakan untuk melatih model) ke model, dan membuatnya memprediksi apakah pelanggan ini akan churn atau tidak.

Di pos ini, kami melatih dan menyebarkan empat algoritma SageMaker yang baru dirilis—LightGBM, CatBoost, TabTransformer, dan AutoGluon-Tabular—pada kumpulan data prediksi churn. Kita gunakan Penyetelan Model Otomatis SageMaker (alat untuk optimasi hyperparameter) untuk menemukan hyperparameter terbaik untuk setiap model, dan membandingkan kinerjanya pada dataset uji ketidaksepakatan untuk memilih yang optimal.

Anda juga dapat menggunakan solusi ini sebagai templat untuk mencari kumpulan algoritme tabel canggih dan menggunakan pengoptimalan hyperparameter untuk menemukan model keseluruhan terbaik. Anda dapat dengan mudah mengganti contoh dataset dengan milik Anda sendiri untuk memecahkan masalah bisnis nyata yang Anda minati. Jika Anda ingin langsung masuk ke kode SageMaker SDK yang kami lalui dalam posting ini, Anda dapat merujuk ke yang berikut ini contoh buku catatan Jupyter.

Manfaat algoritme bawaan SageMaker

Saat memilih algoritme untuk jenis masalah dan data khusus Anda, menggunakan algoritme bawaan SageMaker adalah opsi termudah, karena hal itu memberikan manfaat utama berikut:

• Pengkodean rendah – Algoritme bawaan memerlukan sedikit pengkodean untuk mulai menjalankan eksperimen. Satu-satunya input yang perlu Anda berikan adalah data, hyperparameter, dan sumber daya komputasi. Ini memungkinkan Anda menjalankan eksperimen lebih cepat, dengan lebih sedikit overhead untuk melacak hasil dan perubahan kode.
• Implementasi algoritma yang efisien dan terukur – Algoritme bawaan hadir dengan paralelisasi di beberapa instans komputasi dan dukungan GPU langsung dari kotak untuk semua algoritme yang berlaku. Jika Anda memiliki banyak data untuk melatih model Anda, sebagian besar algoritme bawaan dapat dengan mudah menskalakan untuk memenuhi permintaan. Bahkan jika Anda sudah memiliki model yang telah dilatih sebelumnya, mungkin masih lebih mudah untuk menggunakan konsekuensi wajarnya di SageMaker dan memasukkan hyperparameter yang sudah Anda ketahui daripada memindahkannya dan menulis skrip pelatihan sendiri.
• Transparansi – Anda adalah pemilik artefak model yang dihasilkan. Anda dapat mengambil model itu dan menerapkannya di SageMaker untuk beberapa pola inferensi yang berbeda (lihat semua jenis penyebaran yang tersedia) dan penskalaan dan pengelolaan titik akhir yang mudah, atau Anda dapat menerapkannya di mana pun Anda membutuhkannya.

Visualisasi data dan pra-pemrosesan

Pertama, kami mengumpulkan dataset churn pelanggan kami. Ini adalah kumpulan data yang relatif kecil dengan 5,000 catatan, di mana setiap catatan menggunakan 21 atribut untuk menggambarkan profil pelanggan dari operator seluler AS yang tidak dikenal. Atribut berkisar dari negara bagian AS tempat pelanggan tinggal, hingga jumlah panggilan yang mereka lakukan ke layanan pelanggan, hingga biaya yang ditagihkan untuk panggilan siang hari. Kami mencoba memprediksi apakah pelanggan akan churn atau tidak, yang merupakan masalah klasifikasi biner. Berikut ini adalah subset dari fitur tersebut, dengan label sebagai kolom terakhir.

Berikut ini adalah beberapa wawasan untuk setiap kolom, khususnya ringkasan statistik dan histogram fitur yang dipilih.

Kami kemudian memproses data sebelumnya, membaginya menjadi pelatihan, validasi, dan set pengujian, dan mengunggah data ke Layanan Penyimpanan Sederhana Amazon (Amazon S3).

Penyetelan model otomatis dari algoritma tabel

Hyperparameters mengontrol bagaimana algoritma yang mendasari kami beroperasi dan mempengaruhi kinerja model. Hyperparameter tersebut dapat berupa jumlah layer, learning rate, weight decay rate, dan dropout untuk model berbasis jaringan saraf, atau jumlah daun, iterasi, dan kedalaman pohon maksimum untuk model ensemble pohon. Untuk memilih model terbaik, kami menerapkan penyetelan model otomatis SageMaker ke masing-masing dari empat algoritme tabel SageMaker yang terlatih. Anda hanya perlu memilih hyperparameters untuk disetel dan rentang untuk setiap parameter untuk dijelajahi. Untuk informasi lebih lanjut tentang penyetelan model otomatis, lihat Tuning Model Otomatis Amazon SageMaker: Menggunakan Pembelajaran Mesin untuk Pembelajaran Mesin or Penyetelan model otomatis Amazon SageMaker: Pengoptimalan bebas gradien yang dapat diskalakan.

Mari kita lihat bagaimana ini bekerja dalam praktiknya.

CahayaGBM

Kami mulai dengan menjalankan penyetelan model otomatis dengan LightGBM, dan mengadaptasi proses itu ke algoritme lain. Seperti yang dijelaskan dalam posting Model dan algoritma JumpStart Amazon SageMaker sekarang tersedia melalui API, artefak berikut diperlukan untuk melatih algoritme yang dibuat sebelumnya melalui SageMaker SDK:

• Gambar wadah khusus kerangka kerja, berisi semua dependensi yang diperlukan untuk pelatihan dan inferensi
• Skrip pelatihan dan inferensi untuk model atau algoritme yang dipilih

Kami pertama-tama mengambil artefak ini, yang bergantung pada model_id (lightgbm-classification-model dalam hal ini) dan versi:

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)

Kami kemudian mendapatkan hyperparameter default untuk LightGBM, mengatur beberapa di antaranya ke nilai tetap yang dipilih seperti jumlah putaran peningkatan dan metrik evaluasi pada data validasi, dan menentukan rentang nilai yang ingin kami cari untuk yang lain. Kami menggunakan parameter SageMaker ContinuousParameter dan IntegerParameter untuk ini:

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

Akhirnya, kami membuat Pengukur SageMaker, masukkan ke dalam a Hyperarameter Tuner, dan mulai pekerjaan penyetelan hyperparameter dengan 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)

Grafik max_jobs parameter menentukan berapa banyak pekerjaan total yang akan dijalankan dalam pekerjaan penyetelan model otomatis, dan max_parallel_jobs mendefinisikan berapa banyak pekerjaan pelatihan bersamaan yang harus dimulai. Kami juga mendefinisikan tujuan untuk “Maximize” AUC model (area di bawah kurva). Untuk menyelam lebih dalam ke parameter yang tersedia yang diekspos oleh HyperParameterTuner, mengacu pada Hyperparameter Tuner.

Check out buku catatan sampel untuk melihat bagaimana kami melanjutkan untuk menerapkan dan mengevaluasi model ini pada set pengujian.

KucingMeningkatkan

Proses penyetelan hyperparameter pada algoritme CatBoost sama seperti sebelumnya, meskipun kita perlu mengambil artefak model di bawah ID catboost-classification-model dan ubah pilihan rentang hyperparameter:

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

TabTransformator

Proses penyetelan hyperparameter pada model TabTransformer sama seperti sebelumnya, meskipun kita perlu mengambil artefak model di bawah ID pytorch-tabtransformerclassification-model dan ubah pilihan rentang hyperparameters.

Kami juga mengubah pelatihan instance_type untuk ml.p3.2xlarge. TabTransformer adalah model yang baru-baru ini diturunkan dari penelitian Amazon, yang menghadirkan kekuatan pembelajaran mendalam ke data tabular menggunakan model Transformer. Untuk melatih model ini secara efisien, kami memerlukan instans yang didukung GPU. Untuk informasi lebih lanjut, lihat Membawa kekuatan deep learning ke data dalam tabel.

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

Dalam kasus AutoGluon, kami tidak menjalankan penyetelan hyperparameter. Ini dirancang, karena AutoGluon berfokus pada menggabungkan beberapa model dengan pilihan hiperparameter yang waras dan menumpuknya dalam beberapa lapisan. Ini akhirnya menjadi lebih berperforma daripada melatih satu model dengan pilihan hyperparameter yang sempurna dan juga lebih murah secara komputasi. Untuk detailnya, lihat AutoGluon-Tabular: AutoML yang Kuat dan Akurat untuk Data Terstruktur.

Oleh karena itu, kami mengganti model_id untuk autogluon-classification-ensemble, dan hanya perbaiki hyperparameter metrik evaluasi ke skor AUC yang kami inginkan:

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"

Alih-alih menelepon tuner.fit(), Kami memanggil estimator.fit() untuk memulai satu pekerjaan pelatihan.

Membandingkan model yang terlatih

Setelah kami menerapkan keempat model, kami mengirim set pengujian lengkap ke setiap titik akhir untuk prediksi dan menghitung akurasi, metrik F1, dan AUC untuk masing-masing (lihat kode di buku catatan sampel). Kami menyajikan hasil dalam tabel berikut, dengan penafian penting: hasil dan kinerja relatif antara model-model ini akan bergantung pada kumpulan data yang Anda gunakan untuk pelatihan. Hasil ini representatif, dan meskipun kecenderungan algoritme tertentu untuk berkinerja lebih baik didasarkan pada faktor-faktor yang relevan (misalnya, AutoGluon dengan cerdas menggabungkan prediksi model LightGBM dan CatBoost di belakang layar), keseimbangan kinerja mungkin berubah karena perbedaan distribusi data.

Kesimpulan

Dalam posting ini, kami melatih empat algoritme bawaan SageMaker yang berbeda untuk memecahkan masalah prediksi churn pelanggan dengan upaya pengkodean yang rendah. Kami menggunakan penyetelan model otomatis SageMaker untuk menemukan hyperparameter terbaik untuk melatih algoritme ini, dan membandingkan kinerjanya pada kumpulan data prediksi churn yang dipilih. Anda dapat menggunakan yang terkait buku catatan sampel sebagai template, mengganti dataset dengan milik Anda untuk memecahkan masalah berbasis data tabular yang Anda inginkan.

Pastikan untuk mencoba algoritme ini di SageMaker, dan lihat contoh buku catatan tentang cara menggunakan algoritme bawaan lain yang tersedia di GitHub.

Tentang penulis

Dr Xin Huang adalah Ilmuwan Terapan untuk Amazon SageMaker JumpStart dan algoritma bawaan Amazon SageMaker. Dia berfokus pada pengembangan algoritme pembelajaran mesin yang dapat diskalakan. Minat penelitiannya adalah di bidang pemrosesan bahasa alami, pembelajaran mendalam yang dapat dijelaskan pada data tabular, dan analisis yang kuat dari pengelompokan ruang-waktu non-parametrik. Dia telah menerbitkan banyak makalah di ACL, ICDM, konferensi KDD, dan jurnal Royal Statistical Society: Series A.

João Moura adalah Arsitek Solusi Spesialis AI/ML di Amazon Web Services. Dia sebagian besar berfokus pada kasus penggunaan NLP dan membantu pelanggan mengoptimalkan pelatihan dan penerapan model Deep Learning. Dia juga merupakan pendukung aktif solusi ML kode rendah dan perangkat keras khusus ML.