Optimalkan hyperparameter dengan Amazon SageMaker Automatic Model Tuning

Model pembelajaran mesin (ML) menggemparkan dunia. Performa mereka bergantung pada penggunaan data pelatihan yang tepat dan pemilihan model dan algoritme yang tepat. Tapi itu tidak berakhir di sini. Biasanya, algoritme menyerahkan beberapa keputusan desain kepada praktisi ML untuk diadopsi untuk data dan tugas spesifik mereka. Keputusan desain yang ditangguhkan ini memanifestasikan dirinya sebagai hiperparameter.

Apa arti nama itu? Hasil pelatihan ML, modelnya, sebagian besar dapat dilihat sebagai kumpulan parameter yang dipelajari selama pelatihan. Oleh karena itu, parameter yang digunakan untuk mengonfigurasi proses pelatihan ML kemudian disebut hyperparameter—parameter yang menjelaskan pembuatan parameter. Bagaimanapun, mereka sangat praktis digunakan, seperti jumlah zaman untuk dilatih, kecepatan pembelajaran, kedalaman maksimum pohon keputusan, dan sebagainya. Dan kami menaruh banyak perhatian pada mereka karena mereka memiliki dampak besar pada performa akhir model Anda.

Sama seperti memutar kenop penerima radio untuk menemukan frekuensi yang tepat, setiap hyperparameter harus disetel dengan hati-hati untuk mengoptimalkan kinerja. Mencari ruang hyperparameter untuk nilai optimal disebut sebagai penyetelan hyperparameter or pengoptimalan hyperparameter (HPO), dan harus menghasilkan model yang memberikan prediksi yang akurat.

Dalam posting ini, kami menyiapkan dan menjalankan pekerjaan HPO pertama kami menggunakan Penyetelan Model Otomatis Amazon SageMaker (AMT). Kami belajar tentang metode yang tersedia untuk menjelajahi hasil, dan membuat beberapa visualisasi mendalam dari uji coba HPO kami dan eksplorasi ruang hyperparameter!

Penyetelan Model Otomatis Amazon SageMaker

Sebagai praktisi ML menggunakan Pembuat Sage AMT, Anda dapat berfokus pada hal berikut:

• Memberikan pekerjaan pelatihan
• Menentukan metrik tujuan yang tepat yang cocok dengan tugas Anda
• Mencakup ruang pencarian hyperparameter

SageMaker AMT menangani sisanya, dan Anda tidak perlu memikirkan infrastruktur, mengatur tugas pelatihan, dan meningkatkan pemilihan hyperparameter.

Mari kita mulai dengan menggunakan SageMaker AMT untuk pekerjaan HPO sederhana pertama kita, untuk melatih dan menyetel algoritme XGBoost. Kami ingin perjalanan AMT Anda praktis dan praktis, jadi kami telah membagikan contohnya sebagai berikut Repositori GitHub. Posting ini mencakup 1_tuning_of_builtin_xgboost.ipynb buku catatan.

Dalam posting yang akan datang, kami akan memperluas gagasan untuk hanya menemukan hyperparameter terbaik dan menyertakan pembelajaran tentang ruang pencarian dan rentang hyperparameter mana yang sensitif bagi model. Kami juga akan menunjukkan cara mengubah aktivitas penyetelan sekali pakai menjadi percakapan multi-langkah dengan praktisi ML, untuk belajar bersama. Nantikan (permainan kata-kata)!

Prasyarat

Posting ini untuk siapa saja yang tertarik mempelajari tentang HPO dan tidak memerlukan pengetahuan sebelumnya tentang topik tersebut. Keakraban dasar dengan konsep ML dan pemrograman Python sangat membantu. Untuk pengalaman belajar terbaik, kami sangat menyarankan untuk mengikuti menjalankan setiap langkah di notebook paralel dengan membaca posting ini. Dan di akhir notebook, Anda juga dapat mencoba visualisasi interaktif yang membuat hasil penyetelan menjadi hidup.

Ikhtisar solusi

Kita akan membuat penyiapan end-to-end untuk menjalankan tugas HPO pertama kita menggunakan SageMaker AMT. Saat pekerjaan penyetelan kami selesai, kami melihat beberapa metode yang tersedia untuk menjelajahi hasilnya, baik melalui Konsol Manajemen AWS dan secara terprogram melalui AWS SDK dan API.

Pertama, kami membiasakan diri dengan lingkungan dan Pelatihan SageMaker dengan menjalankan tugas pelatihan mandiri, tanpa penyetelan apa pun untuk saat ini. Kami menggunakan algoritme XGBoost, salah satu dari banyak algoritme yang disediakan sebagai a Algoritme bawaan SageMaker (tidak perlu skrip pelatihan!).

Kami melihat bagaimana Pelatihan SageMaker beroperasi dengan cara berikut:

• Memulai dan menghentikan sebuah instance
• Menyediakan wadah yang diperlukan
• Menyalin data pelatihan dan validasi ke instance
• Menjalankan pelatihan
• Mengumpulkan metrik dan log
• Mengumpulkan dan menyimpan model terlatih

Kemudian kami pindah ke AMT dan menjalankan pekerjaan HPO:

• Kami menyiapkan dan meluncurkan tugas penyetelan kami dengan AMT
• Kami mendalami metode yang tersedia untuk mengekstrak metrik kinerja dan metadata mendetail untuk setiap tugas pelatihan, yang memungkinkan kami mempelajari lebih lanjut tentang nilai optimal di ruang hyperparameter kami
• Kami tunjukkan cara melihat hasil uji coba
• Kami memberi Anda alat untuk memvisualisasikan data dalam rangkaian bagan yang mengungkapkan wawasan berharga ke dalam ruang hyperparameter kami

Latih algoritme XGBoost bawaan SageMaker

Semuanya dimulai dengan melatih model. Dengan melakukan itu, kami memahami cara kerja Pelatihan SageMaker.

Kami ingin memanfaatkan kecepatan dan kemudahan penggunaan yang ditawarkan oleh SageMaker algoritme bawaan. Yang kami butuhkan hanyalah beberapa langkah untuk memulai pelatihan:

1. Mempersiapkan dan memuat data – Kami mengunduh dan menyiapkan kumpulan data kami sebagai masukan untuk XGBoost dan mengunggahnya ke Layanan Penyimpanan Sederhana Amazon (Amazon S3).
2. Pilih URI gambar algoritme bawaan kami – SageMaker menggunakan URI ini untuk mengambil wadah pelatihan kami, yang dalam kasus kami berisi skrip pelatihan XGBoost siap pakai. Beberapa versi algoritma didukung.
3. Tentukan hyperparameter – SageMaker menyediakan antarmuka untuk menentukan hiperparameter untuk algoritme bawaan kami. Ini adalah hyperparameter yang sama seperti yang digunakan oleh versi open-source.
4. Bangun estimator – Kami menentukan parameter pelatihan seperti jenis instans dan jumlah instans.
5. Panggil fungsi fit() – Kami memulai pekerjaan pelatihan kami.

Diagram berikut menunjukkan bagaimana langkah-langkah ini bekerja bersama.

Berikan datanya

Untuk menjalankan pelatihan ML, kami perlu menyediakan data. Kami menyediakan data pelatihan dan validasi kami ke SageMaker melalui Amazon S3.

Dalam contoh kami, untuk penyederhanaan, kami menggunakan bucket default SageMaker untuk menyimpan data kami. Namun jangan ragu untuk menyesuaikan nilai berikut dengan preferensi Anda:

sm_sess = sagemaker.session.Session([..])

BUCKET = sm_sess.default_bucket()
PREFIX = 'amt-visualize-demo'
output_path = f's3://{BUCKET}/{PREFIX}/output'

Di notebook, kami menggunakan kumpulan data publik dan menyimpan data secara lokal di data direktori. Kami kemudian mengunggah data pelatihan dan validasi kami ke Amazon S3. Nanti, kami juga menentukan petunjuk ke lokasi ini untuk meneruskannya ke Pelatihan SageMaker.

# acquire and prepare the data (not shown here)
# store the data locally
[..]
train_data.to_csv('data/train.csv', index=False, header=False)
valid_data.to_csv('data/valid.csv', index=False, header=False)
[..]
# upload the local files to S3
boto_sess.resource('s3').Bucket(BUCKET).Object(os.path.join(PREFIX, 'data/train/train.csv')).upload_file('data/train.csv')
boto_sess.resource('s3').Bucket(BUCKET).Object(os.path.join(PREFIX, 'data/valid/valid.csv')).upload_file('data/valid.csv')

Pada postingan kali ini, kami berkonsentrasi untuk memperkenalkan HPO. Sebagai ilustrasi, kami menggunakan kumpulan data dan tugas tertentu, sehingga kami dapat memperoleh pengukuran metrik objektif yang kemudian kami gunakan untuk mengoptimalkan pemilihan hyperparameter. Namun, untuk posting keseluruhan, baik data maupun tugas tidak penting. Untuk memberikan gambaran lengkap kepada Anda, izinkan kami menjelaskan secara singkat apa yang kami lakukan: kami melatih model XGBoost yang akan mengklasifikasikan digit tulisan tangan dari
Pengenalan Optik Kumpulan Data Digit Tulisan Tangan [1] melalui Scikit-belajar. XGBoost adalah algoritme luar biasa untuk data terstruktur dan bahkan dapat diterapkan ke kumpulan data Digit. Nilainya adalah gambar 8×8, seperti contoh berikut yang menunjukkan a
0 a
5 dan
4.

Pilih URI gambar XGBoost

Setelah memilih algoritme bawaan (XGBoost), kita harus mengambil URI gambar dan meneruskannya ke SageMaker untuk dimuat ke instans pelatihan kita. Untuk langkah ini, kami meninjau versi yang tersedia. Di sini kami memutuskan untuk menggunakan versi 1.5.1, yang menawarkan versi terbaru dari algoritme. Bergantung pada tugasnya, praktisi ML dapat menulis skrip pelatihannya sendiri yang, misalnya, menyertakan langkah persiapan data. Tapi ini tidak perlu dalam kasus kami.

Jika Anda ingin menulis skrip pelatihan Anda sendiri, nantikan terus, kami akan membahasnya di pos berikutnya! Kami akan menunjukkan cara menjalankan tugas Pelatihan SageMaker dengan skrip pelatihan kustom Anda sendiri.

Untuk saat ini, kami memerlukan URI gambar yang benar dengan menentukan algoritme, Wilayah AWS, dan nomor versi:

xgboost_container = sagemaker.image_uris.retrieve('xgboost', region, '1.5-1')

Itu dia. Sekarang kami memiliki referensi ke algoritme XGBoost.

Tentukan hyperparameter

Sekarang kita mendefinisikan hyperparameter kita. Nilai-nilai ini mengonfigurasi cara model kita akan dilatih, dan pada akhirnya memengaruhi performa model terhadap metrik objektif yang kita ukur, seperti akurasi dalam kasus kita. Perhatikan bahwa blok kode berikut ini tidak khusus untuk SageMaker. Kami benar-benar menggunakan versi sumber terbuka dari XGBoost, hanya disediakan oleh dan dioptimalkan untuk SageMaker.

Meskipun masing-masing hyperparameter ini dapat dikonfigurasi dan disesuaikan, metrik objektif multi:softmax ditentukan oleh kumpulan data kami dan jenis masalah yang kami selesaikan. Dalam kasus kami, Digits dataset berisi banyak label (pengamatan digit tulisan tangan bisa jadi 0 or 1,2,3,4,5,6,7,8,9), artinya ini adalah masalah klasifikasi multi-kelas.

hyperparameters = {
    'num_class': 10,
    'max_depth': 5,
    'eta':0.2,
    'alpha': 0.2,
    'objective':'multi:softmax',
    'eval_metric':'accuracy',
    'num_round':200,
    'early_stopping_rounds': 5
}

Untuk informasi selengkapnya tentang hyperparameter lainnya, lihat Hyperparameter XGBoost.

Bangun estimator

Kami mengonfigurasi pelatihan pada objek estimator, yang merupakan antarmuka tingkat tinggi untuk Pelatihan SageMaker.

Selanjutnya, kami menentukan jumlah instans untuk dilatih, jenis instans (berbasis CPU atau berbasis GPU), dan ukuran penyimpanan yang terpasang:

estimator = sagemaker.estimator.Estimator(
    image_uri=xgboost_container, 
    hyperparameters=hyperparameters,
    role=role,
    instance_count=1, 
    instance_type='ml.m5.large', 
    volume_size=5, # 5 GB 
    output_path=output_path
)

Kami sekarang memiliki konfigurasi infrastruktur yang kami perlukan untuk memulai. Pelatihan SageMaker akan mengurus sisanya.

Panggil fungsi fit()

Ingat data yang kami unggah ke Amazon S3 sebelumnya? Sekarang kami membuat referensi untuk itu:

s3_input_train = TrainingInput(s3_data=f's3://{BUCKET}/{PREFIX}/data/train', content_type='csv')
s3_input_valid = TrainingInput(s3_data=f's3://{BUCKET}/{PREFIX}/data/valid', content_type='csv')

Panggilan untuk fit() meluncurkan pelatihan kami. Kami meneruskan referensi ke data pelatihan yang baru saja kami buat untuk mengarahkan Pelatihan SageMaker ke data pelatihan dan validasi kami:

estimator.fit({'train': s3_input_train, 'validation': s3_input_valid})

Perhatikan bahwa untuk menjalankan HPO nanti, kami sebenarnya tidak perlu menelepon fit() di sini. Kami hanya membutuhkan objek estimator nanti untuk HPO, dan bisa langsung membuat pekerjaan HPO kami. Namun karena kami ingin mempelajari Pelatihan SageMaker dan melihat cara menjalankan satu tugas pelatihan, kami menyebutnya di sini dan meninjau hasilnya.

Setelah pelatihan dimulai, kita mulai melihat output di bawah sel, seperti yang ditunjukkan pada tangkapan layar berikut. Keluaran tersedia di amazoncloudwatch begitu juga dengan notebook ini.

Teks hitam adalah keluaran log dari SageMaker itu sendiri, menunjukkan langkah-langkah yang terlibat dalam orkestrasi pelatihan, seperti memulai instans dan memuat gambar pelatihan. Teks biru dikeluarkan langsung dari instance pelatihan itu sendiri. Kami dapat mengamati proses pemuatan dan penguraian data pelatihan, dan secara visual melihat kemajuan pelatihan dan peningkatan metrik objektif langsung dari skrip pelatihan yang berjalan di instans.

Perhatikan juga bahwa di akhir tugas keluaran, durasi pelatihan dalam detik dan detik yang dapat ditagih ditampilkan.

Terakhir, kita melihat bahwa SageMaker mengunggah model pelatihan kita ke jalur keluaran S3 yang ditentukan pada objek estimator. Model siap digunakan untuk inferensi.

Di posting mendatang, kami akan membuat wadah pelatihan kami sendiri dan menentukan metrik pelatihan kami untuk dipancarkan. Anda akan melihat bagaimana SageMaker tidak mengetahui wadah apa yang Anda berikan untuk pelatihan. Ini sangat berguna ketika Anda ingin memulai dengan cepat dengan algoritme bawaan, tetapi kemudian memutuskan untuk meneruskan skrip pelatihan kustom Anda sendiri!

Periksa pekerjaan pelatihan saat ini dan sebelumnya

Sejauh ini, kami telah mengerjakan dari notebook kami dengan kode kami dan mengirimkan tugas pelatihan ke SageMaker. Mari beralih perspektif dan tinggalkan notebook sejenak untuk melihat tampilannya di konsol SageMaker.

SageMaker menyimpan catatan sejarah tentang tugas pelatihan yang dijalankannya, konfigurasinya seperti hyperparameter, algoritme, input data, waktu yang dapat ditagih, dan hasilnya. Dalam daftar di tangkapan layar sebelumnya, Anda melihat tugas pelatihan terbaru yang difilter untuk XGBoost. Pekerjaan pelatihan yang disorot adalah pekerjaan yang baru saja kita latih di notebook, yang keluarannya Anda lihat sebelumnya. Mari selami pekerjaan pelatihan individu ini untuk mendapatkan informasi lebih lanjut.

Tangkapan layar berikut menunjukkan tampilan konsol dari tugas pelatihan kami.

Kami dapat meninjau informasi yang kami terima sebagai keluaran sel ke fit() berfungsi dalam tugas pelatihan individu dalam konsol SageMaker, bersama dengan parameter dan metadata yang kami tentukan di estimator kami.

Ingat output log dari contoh pelatihan yang kita lihat sebelumnya. Kami juga dapat mengakses log tugas pelatihan kami di sini, dengan menggulir ke Memantau bagian dan memilih Lihat log.

Ini menunjukkan kepada kita log instan di dalam CloudWatch.

Ingat juga hyperparameter yang kami tentukan di notebook kami untuk tugas pelatihan. Kami melihat mereka di sini di UI yang sama dari pekerjaan pelatihan juga.

Faktanya, detail dan metadata yang kami tentukan sebelumnya untuk tugas pelatihan dan estimator kami dapat ditemukan di halaman ini di konsol SageMaker. Kami memiliki catatan berguna tentang pengaturan yang digunakan untuk pelatihan, seperti wadah pelatihan yang digunakan dan lokasi pelatihan serta dataset validasi.

Anda mungkin bertanya pada titik ini, mengapa ini relevan untuk pengoptimalan hyperparameter? Itu karena Anda dapat mencari, memeriksa, dan menyelami lebih dalam uji coba HPO yang kami minati. Mungkin uji coba dengan hasil terbaik, atau uji coba yang menunjukkan perilaku menarik. Kami akan menyerahkan kepada Anda apa yang Anda definisikan sebagai "menarik". Ini memberi kami antarmuka umum untuk memeriksa tugas pelatihan kami, dan Anda dapat menggunakannya dengan Pencarian SageMaker.

Meskipun SageMaker AMT mengatur tugas HPO, semua uji coba HPO diluncurkan sebagai tugas Pelatihan SageMaker individual dan dapat diakses seperti itu.

Dengan pelatihan tertutup, mari kita menyetel!

Latih dan sesuaikan algoritme XGBoost bawaan SageMaker

Untuk menyetel model XGBoost kami, kami akan menggunakan kembali hyperparameter yang ada dan menentukan rentang nilai yang ingin kami jelajahi untuknya. Anggap ini sebagai memperluas batas eksplorasi dalam ruang pencarian hyperparameter kami. Tugas penyetelan kami akan mengambil sampel dari ruang pencarian dan menjalankan tugas pelatihan untuk kombinasi nilai baru. Kode berikut menunjukkan cara menentukan rentang hyperparameter yang harus dijadikan sampel oleh SageMaker AMT:

from sagemaker.tuner import IntegerParameter, ContinuousParameter, HyperparameterTuner

hpt_ranges = {
    'alpha': ContinuousParameter(0.01, .5),
    'eta': ContinuousParameter(0.1, .5),
    'min_child_weight': ContinuousParameter(0., 2.),
    'max_depth': IntegerParameter(1, 10)
}

Rentang untuk masing-masing hyperparameter ditentukan oleh jenisnya, seperti Parameter Berkelanjutan. Untuk informasi lebih lanjut dan tips memilih rentang parameter ini, lihat Tune Model XGBoost.

Kami belum menjalankan eksperimen apa pun, jadi kami tidak mengetahui rentang nilai bagus untuk hyperparameter kami. Oleh karena itu, kami mulai dengan tebakan terpelajar, menggunakan pengetahuan kami tentang algoritme dan dokumentasi hiperparameter kami untuk algoritme bawaan. Ini mendefinisikan titik awal untuk menentukan ruang pencarian.

Kemudian kami menjalankan sampling pekerjaan penyetelan dari hyperparameter dalam rentang yang ditentukan. Hasilnya, kita dapat melihat rentang hyperparameter mana yang memberikan hasil yang baik. Dengan pengetahuan ini, kita dapat menyempurnakan batas ruang pencarian dengan mempersempit atau memperluas rentang hyperparameter mana yang akan digunakan. Kami mendemonstrasikan cara belajar dari uji coba di bagian berikutnya dan terakhir, di mana kami menyelidiki dan memvisualisasikan hasilnya.

Di posting kami berikutnya, kami akan melanjutkan perjalanan kami dan menyelam lebih dalam. Selain itu, kita akan belajar bahwa ada beberapa strategi yang dapat kita gunakan untuk menjelajahi ruang pencarian kita. Kami akan menjalankan tugas HPO berikutnya untuk menemukan lebih banyak lagi nilai performa untuk hyperparameter kami, sambil membandingkan berbagai strategi ini. Kita juga akan melihat cara memulai awal yang hangat dengan SageMaker AMT untuk menggunakan pengetahuan yang diperoleh dari ruang pencarian yang dijelajahi sebelumnya dalam eksplorasi kita di luar batas awal tersebut.

Untuk posting ini, kami fokus pada bagaimana menganalisis dan memvisualisasikan hasil dari satu pekerjaan HPO menggunakan strategi pencarian Bayesian, yang mungkin menjadi titik awal yang baik.

Jika Anda mengikuti di buku catatan yang ditautkan, perhatikan bahwa kami memberikan estimator yang sama dengan yang kami gunakan untuk tugas pelatihan XGBoost bawaan tunggal kami. Objek estimator ini berfungsi sebagai template untuk tugas pelatihan baru yang dibuat oleh AMT. AMT kemudian akan memvariasikan hyperparameter di dalam rentang yang kami tentukan.

Dengan menentukan bahwa kami ingin memaksimalkan metrik tujuan kami, validation:accuracy, kami memberi tahu SageMaker AMT untuk mencari metrik ini di log instans pelatihan dan memilih nilai hyperparameter yang diyakini akan memaksimalkan metrik akurasi pada data validasi kami. Kami memilih yang sesuai metrik objektif untuk XGBoost dari dokumentasi kami.

Selain itu, kita dapat memanfaatkan paralelisasi dengan max_parallel_jobs. Ini bisa menjadi alat yang ampuh, terutama untuk strategi yang uji cobanya dipilih secara independen, tanpa mempertimbangkan (belajar dari) hasil uji coba sebelumnya. Kami akan mengeksplorasi strategi dan parameter lain ini lebih lanjut di posting kami berikutnya. Untuk posting ini, kami menggunakan Bayesian, yang merupakan strategi default yang sangat baik.

Kami juga mendefinisikan max_jobs untuk menentukan berapa banyak uji coba yang akan dijalankan secara total. Jangan ragu untuk menyimpang dari contoh kami dan gunakan angka yang lebih kecil untuk menghemat uang.

n_jobs = 50
n_parallel_jobs = 3

tuner_parameters = {
    'estimator': estimator, # The same estimator object we defined above
    'base_tuning_job_name': 'bayesian',
    'objective_metric_name': 'validation:accuracy',
    'objective_type': 'Maximize',
    'hyperparameter_ranges': hpt_ranges,
    'strategy': 'Bayesian',
    'max_jobs': n_jobs,
    'max_parallel_jobs': n_parallel_jobs
}

Kami sekali lagi menelepon fit(), sama seperti saat kami meluncurkan satu tugas pelatihan di postingan sebelumnya. Namun kali ini pada objek tuner, bukan pada objek estimator. Ini memulai pekerjaan penyetelan, dan pada gilirannya AMT memulai pekerjaan pelatihan.

tuner = HyperparameterTuner(**tuner_parameters)
tuner.fit({'train': s3_input_train, 'validation': s3_input_valid}, wait=False)
tuner_name = tuner.describe()['HyperParameterTuningJobName']
print(f'tuning job submitted: {tuner_name}.')

Diagram berikut memperluas arsitektur kami sebelumnya dengan menyertakan HPO dengan SageMaker AMT.

Kami melihat bahwa pekerjaan HPO kami telah diserahkan. Bergantung pada jumlah percobaan, ditentukan oleh n_jobs dan tingkat paralelisasi, ini mungkin memakan waktu. Sebagai contoh kami, mungkin diperlukan waktu hingga 30 menit untuk 50 percobaan dengan hanya level paralelisasi 3.

tuning job submitted: bayesian-221102-2053.

Saat tugas penyetelan ini selesai, mari jelajahi informasi yang tersedia untuk kita di konsol SageMaker.

Selidiki pekerjaan AMT di konsol

Mari temukan pekerjaan penyetelan kita di konsol SageMaker dengan memilih Pelatihan di panel navigasi lalu Pekerjaan penyetelan hyperparameter. Ini memberi kami daftar pekerjaan AMT kami, seperti yang ditunjukkan pada tangkapan layar berikut. Di sini kami menemukan milik kami bayesian-221102-2053 tuning pekerjaan dan menemukan bahwa itu sekarang selesai.

Mari kita lihat lebih dekat hasil dari pekerjaan HPO ini.

Kami telah menjelajahi penggalian hasil secara terprogram di buku catatan. Pertama melalui SDK Python SageMaker, yang merupakan pustaka Python sumber terbuka tingkat tinggi, menyediakan API khusus untuk SageMaker. Kemudian melalui bot3, yang memberi kami API tingkat rendah ke SageMaker dan layanan AWS lainnya.

Dengan menggunakan SageMaker Python SDK, kita dapat memperoleh hasil dari pekerjaan HPO kita:

sagemaker.HyperparameterTuningJobAnalytics(tuner_name).dataframe()[:10]

Ini memungkinkan kami untuk menganalisis hasil dari setiap uji coba kami dalam Pandas DataFrame, seperti yang terlihat pada tangkapan layar berikut.

Sekarang mari beralih perspektif lagi dan lihat seperti apa hasilnya di konsol SageMaker. Kemudian kita akan melihat visualisasi khusus kita.

Di halaman yang sama, memilih kami bayesian-221102-2053 pekerjaan penyetelan memberi kami daftar uji coba yang dijalankan untuk pekerjaan penyetelan kami. Setiap percobaan HPO di sini adalah pekerjaan Pelatihan SageMaker. Ingat sebelumnya ketika kami melatih model XGBoost tunggal kami dan menyelidiki tugas pelatihan di konsol SageMaker. Kita dapat melakukan hal yang sama untuk uji coba kita di sini.

Saat kami menyelidiki uji coba kami, kami melihatnya bayesian-221102-2053-048-b59ec7b4 menciptakan model dengan kinerja terbaik, dengan akurasi validasi sekitar 89.815%. Mari jelajahi hyperparameter apa yang menyebabkan kinerja ini dengan memilih Pekerjaan pelatihan terbaik Tab.

Kita dapat melihat tampilan detail dari hyperparameter terbaik yang dievaluasi.

Kami dapat segera melihat nilai hyperparameter apa yang menyebabkan kinerja yang unggul ini. Namun, kami ingin tahu lebih banyak. Bisakah Anda menebak apa? Kami melihat itu alpha mengambil nilai perkiraan 0.052456 dan, demikian juga, eta diatur ke 0.433495. Ini memberi tahu kita bahwa nilai-nilai ini bekerja dengan baik, tetapi hanya sedikit yang memberi tahu kita tentang ruang hyperparameter itu sendiri. Misalnya, kita mungkin bertanya-tanya apakah 0.433495 untuk eta adalah nilai tertinggi yang diuji, atau apakah ada ruang untuk pertumbuhan dan peningkatan model dengan memilih nilai yang lebih tinggi.

Untuk itu, kita perlu memperkecil, dan mengambil tampilan yang lebih luas untuk melihat bagaimana nilai lain untuk hyperparameter kita bekerja. Salah satu cara untuk melihat banyak data sekaligus adalah dengan memplot nilai hyperparameter kami dari uji coba HPO kami pada bagan. Dengan begitu kita melihat bagaimana nilai-nilai ini bekerja secara relatif. Di bagian selanjutnya, kami menarik data ini dari SageMaker dan memvisualisasikannya.

Visualisasikan pencobaan kita

SDK SageMaker memberi kami data untuk eksplorasi kami, dan buku catatan memberi Anda gambaran tentang itu. Tetapi ada banyak cara untuk memanfaatkan dan memvisualisasikannya. Pada postingan kali ini, kami membagikan sample menggunakan Altair perpustakaan visualisasi statistik, yang kami gunakan untuk menghasilkan ikhtisar yang lebih visual dari uji coba kami. Ini ditemukan di amtviz paket, yang kami sediakan sebagai bagian dari sampel:

from amtviz import visualize_tuning_job
visualize_tuning_job(tuner, trials_only=True)

Kekuatan visualisasi ini segera terlihat saat memplot akurasi validasi uji coba kami (sumbu y) dari waktu ke waktu (sumbu x). Bagan berikut di sebelah kiri menunjukkan akurasi validasi dari waktu ke waktu. Kami dapat dengan jelas melihat peningkatan kinerja model saat kami menjalankan lebih banyak uji coba dari waktu ke waktu. Ini adalah hasil langsung dan diharapkan dari menjalankan HPO dengan strategi Bayesian. Dalam posting kami berikutnya, kami melihat bagaimana ini dibandingkan dengan strategi lain dan mengamati bahwa ini tidak perlu terjadi pada semua strategi.

Setelah meninjau kemajuan keseluruhan dari waktu ke waktu, sekarang mari kita lihat ruang hyperparameter kita.

Bagan berikut menunjukkan akurasi validasi pada sumbu y, dengan setiap bagan ditampilkan max_depth, alpha, eta, dan min_child_weight pada sumbu x, masing-masing. Kami telah memplot seluruh pekerjaan HPO kami ke dalam setiap bagan. Setiap titik adalah percobaan tunggal, dan setiap bagan berisi semua 50 percobaan, tetapi dipisahkan untuk setiap hyperparameter. Ini berarti uji coba kami yang berkinerja terbaik, #48, diwakili oleh tepat satu titik biru di setiap bagan ini (yang telah kami soroti untuk Anda dalam gambar berikut). Kami dapat membandingkan kinerjanya secara visual dalam konteks 49 uji coba lainnya. Jadi, mari kita lihat lebih dekat.

Memukau! Kami segera melihat wilayah mana dari rentang yang kami tentukan di ruang hyperparameter kami yang paling berkinerja! Berpikir kembali ke kita eta nilai, jelas sekarang bahwa nilai pengambilan sampel lebih dekat ke 0 menghasilkan kinerja yang lebih buruk, sedangkan bergerak lebih dekat ke batas kami, 0.5, menghasilkan hasil yang lebih baik. Kebalikannya tampaknya benar untuk alpha, dan max_depth tampaknya memiliki kumpulan nilai pilihan yang lebih terbatas. Melihat ke max_depth, Anda juga dapat melihat bagaimana penggunaan strategi Bayesian menginstruksikan SageMaker AMT untuk lebih sering mengambil sampel nilai yang telah dipelajari dan berhasil dengan baik di masa lalu.

Melihat kami eta nilai, kita mungkin bertanya-tanya apakah perlu ditelusuri lebih ke kanan, mungkin di atas 0.45? Apakah itu terus menurun ke akurasi yang lebih rendah, atau apakah kita memerlukan lebih banyak data di sini? Keheranan ini adalah bagian dari tujuan menjalankan pekerjaan HPO pertama kami. Ini memberi kita wawasan tentang area ruang hyperparameter mana yang harus kita jelajahi lebih jauh.

Jika Anda ingin tahu lebih banyak, dan sama bersemangatnya dengan kami dengan pengenalan topik ini, maka nantikan posting kami berikutnya, di mana kami akan berbicara lebih banyak tentang strategi HPO yang berbeda, membandingkannya satu sama lain, dan berlatih pelatihan dengan skrip Python kita sendiri.

Membersihkan

Untuk menghindari timbulnya biaya yang tidak diinginkan saat Anda selesai bereksperimen dengan HPO, Anda harus menghapus semua file di bucket S3 Anda dengan awalan amt-visualize-demo dan juga matikan sumber daya Studio.

Jalankan kode berikut di notebook Anda untuk menghapus semua file S3 dari postingan ini.

!aws s3 rm s3://{BUCKET}/amt-visualize-demo --recursive

Jika Anda ingin menyimpan kumpulan data atau artefak model, Anda dapat mengubah awalan dalam kode menjadi amt-visualize-demo/data untuk hanya menghapus data atau amt-visualize-demo/output untuk hanya menghapus artefak model.

Kesimpulan

Dalam postingan ini, kami melatih dan menyetel model menggunakan versi bawaan SageMaker dari algoritme XGBoost. Dengan menggunakan HPO dengan SageMaker AMT, kami mempelajari tentang hyperparameter yang bekerja dengan baik untuk algoritme dan kumpulan data khusus ini.

Kami melihat beberapa cara untuk meninjau hasil pekerjaan penyetelan hyperparameter kami. Dimulai dengan mengekstraksi hyperparameter dari uji coba terbaik, kami juga mempelajari cara mendapatkan pemahaman yang lebih mendalam tentang kemajuan uji coba kami dari waktu ke waktu dan nilai hyperparameter apa yang berdampak.

Dengan menggunakan konsol SageMaker, kami juga melihat cara menyelami lebih dalam proses pelatihan individual dan meninjau log mereka.

Kami kemudian memperkecil untuk melihat semua uji coba kami bersama-sama, dan meninjau kinerjanya dalam kaitannya dengan uji coba dan hyperparameter lainnya.

Kami belajar bahwa berdasarkan pengamatan dari setiap percobaan, kami dapat menavigasi ruang hyperparameter untuk melihat bahwa perubahan kecil pada nilai hyperparameter kami dapat berdampak besar pada kinerja model kami. Dengan SageMaker AMT, kami dapat menjalankan pengoptimalan hyperparameter untuk menemukan nilai hyperparameter yang baik secara efisien dan memaksimalkan kinerja model.

Di masa mendatang, kami akan melihat berbagai strategi HPO yang ditawarkan oleh SageMaker AMT dan cara menggunakan kode pelatihan kustom kami sendiri. Beri tahu kami di komentar jika Anda memiliki pertanyaan atau ingin menyarankan area yang harus kami bahas di posting mendatang.

Sampai saat itu, kami berharap Anda dan model Anda senang belajar dan menyetel!

Referensi

Kutipan:

[1] Dua, D. dan Graff, C. (2019). Repositori Pembelajaran Mesin UCI [http://archive.ics.uci.edu/ml]. Irvine, CA: University of California, Sekolah Informasi dan Ilmu Komputer.

Tentang penulis

Andrew Elul adalah Arsitek Solusi dengan Amazon Web Services. Dia bekerja dengan bisnis kecil dan menengah di Jerman. Di luar pekerjaan, Andrew senang menjelajahi alam dengan berjalan kaki atau bersepeda.

Elina Lesyk adalah Arsitek Solusi yang berlokasi di Munich. Fokusnya adalah pada pelanggan perusahaan dari Industri Jasa Keuangan. Di waktu luangnya, Elina suka belajar teori gitar dalam bahasa Spanyol untuk belajar silang dan berlari.

Kamp Mariano adalah Arsitek Solusi Utama dengan Amazon Web Services. Dia bekerja dengan pelanggan layanan keuangan di Jerman dalam pembelajaran mesin. Di waktu luangnya, Mariano menikmati hiking bersama istrinya.