Jelajahi teknik tingkat lanjut untuk pengoptimalan hyperparameter dengan Amazon SageMaker Automatic Model Tuning | Layanan Web Amazon

Membuat solusi pembelajaran mesin (ML) berkinerja tinggi bergantung pada eksplorasi dan pengoptimalan parameter pelatihan, yang juga dikenal sebagai hyperparameter. Hyperparameter adalah tombol dan tuas yang kami gunakan untuk menyesuaikan proses pelatihan, seperti kecepatan pembelajaran, ukuran batch, kekuatan regularisasi, dan lainnya, bergantung pada model dan tugas spesifik yang ada. Menjelajahi hyperparameter melibatkan memvariasikan nilai setiap parameter secara sistematis dan mengamati dampaknya terhadap performa model. Meskipun proses ini memerlukan upaya tambahan, manfaatnya sangat besar. Pengoptimalan hyperparameter (HPO) dapat menghasilkan waktu pelatihan yang lebih cepat, akurasi model yang lebih baik, dan generalisasi yang lebih baik pada data baru.

Kami melanjutkan perjalanan dari pos Optimalkan hyperparameter dengan Amazon SageMaker Automatic Model Tuning. Kami sebelumnya menjelajahi pengoptimalan pekerjaan tunggal, memvisualisasikan hasil algoritma bawaan SageMaker, dan mempelajari dampak nilai hyperparameter tertentu. Selain menggunakan HPO sebagai pengoptimalan satu kali di akhir siklus pembuatan model, kita juga dapat menggunakannya di beberapa langkah dalam bentuk percakapan. Setiap tugas penyetelan membantu kami mendekati performa yang baik, namun selain itu, kami juga mempelajari seberapa sensitif model terhadap hyperparameter tertentu dan dapat menggunakan pemahaman ini untuk menginformasikan tugas penyetelan berikutnya. Kami dapat merevisi hyperparameter dan rentang nilainya berdasarkan apa yang kami pelajari dan oleh karena itu mengubah upaya pengoptimalan ini menjadi sebuah percakapan. Dan dengan cara yang sama seperti kita sebagai praktisi ML mengumpulkan pengetahuan tentang proses ini, Penyetelan Model Otomatis (AMT) Amazon SageMaker dengan permulaan yang hangat dapat mempertahankan pengetahuan yang diperoleh dalam pekerjaan penyetelan sebelumnya untuk pekerjaan penyetelan berikutnya juga.

Dalam postingan ini, kami menjalankan beberapa pekerjaan HPO dengan algoritme pelatihan khusus dan strategi HPO berbeda seperti pengoptimalan Bayesian dan pencarian acak. Kami juga menerapkan langkah awal yang baik dan membandingkan uji coba kami secara visual untuk menyempurnakan eksplorasi ruang angkasa hyperparameter.

Konsep lanjutan SageMaker AMT

Di bagian berikutnya, kita melihat lebih dekat setiap topik berikut dan menunjukkan bagaimana SageMaker AMT dapat membantu Anda menerapkannya dalam proyek ML Anda:

• Gunakan kode pelatihan khusus dan kerangka ML populer Scikit-learn di Pelatihan SageMaker
• Tentukan metrik evaluasi khusus berdasarkan log untuk evaluasi dan pengoptimalan
• Lakukan HPO dengan menggunakan strategi yang tepat
• Gunakan awal yang hangat untuk mengubah pencarian hyperparameter tunggal menjadi dialog dengan model kita
• Gunakan teknik visualisasi tingkat lanjut menggunakan perpustakaan solusi kami untuk membandingkan dua strategi HPO dan menyesuaikan hasil pekerjaan

Baik Anda menggunakan algoritme bawaan yang digunakan di postingan pertama kami atau kode pelatihan Anda sendiri, SageMaker AMT menawarkan pengalaman pengguna yang lancar untuk mengoptimalkan model ML. Ini menyediakan fungsionalitas utama yang memungkinkan Anda fokus pada masalah ML yang ada sambil secara otomatis melacak uji coba dan hasilnya. Pada saat yang sama, secara otomatis mengelola infrastruktur dasar untuk Anda.

Dalam postingan ini, kami beralih dari algoritme bawaan SageMaker dan menggunakan kode khusus. Kami menggunakan Random Forest dari SkBelajar. Namun kami tetap menggunakan tugas dan kumpulan data ML yang sama seperti di kami Pos pertama, yang mendeteksi angka tulisan tangan. Kami meliput konten notebook Jupyter 2_penyetelan_lanjutan_dengan_pelatihan_kustom_dan_visualisasi.ipynb dan mengundang Anda untuk memanggil kode secara berdampingan untuk membaca lebih lanjut.

Mari selami lebih dalam dan temukan bagaimana kita dapat menggunakan kode pelatihan khusus, menerapkannya, dan menjalankannya, sambil menjelajahi ruang pencarian hyperparameter untuk mengoptimalkan hasil kita.

Cara membuat model ML dan melakukan optimasi hyperparameter

Seperti apa proses umum dalam membangun solusi ML? Meskipun ada banyak kemungkinan kasus penggunaan dan beragam tugas ML di luar sana, kami menyarankan model mental berikut untuk pendekatan bertahap:

1. Pahami skenario ML Anda dan pilih algoritme berdasarkan persyaratan. Misalnya, Anda mungkin ingin menyelesaikan tugas pengenalan gambar menggunakan algoritma pembelajaran yang diawasi. Dalam postingan ini, kami terus menggunakan skenario pengenalan gambar tulisan tangan dan kumpulan data yang sama seperti pada postingan pertama kami.
2. Putuskan implementasi algoritme mana dalam Pelatihan SageMaker yang ingin Anda gunakan. Ada berbagai pilihan, di dalam SageMaker atau eksternal. Selain itu, Anda perlu menentukan metrik dasar mana yang paling sesuai untuk tugas Anda dan ingin Anda optimalkan (seperti akurasi, skor F1, atau ROC). SageMaker mendukung empat opsi tergantung pada kebutuhan dan sumber daya Anda:
   • Gunakan model terlatih melalui Mulai Lompatan Amazon SageMaker, yang dapat Anda gunakan langsung atau sekadar menyempurnakannya.
   • Gunakan salah satu algoritme bawaan untuk pelatihan dan penyetelan, seperti XGBoost, seperti yang kami lakukan di postingan sebelumnya.
   • Latih dan sesuaikan model kustom berdasarkan salah satu framework utama seperti Scikit-learn, TensorFlow, atau PyTorch. AWS menyediakan pilihan image Docker yang telah dibuat sebelumnya untuk tujuan ini. Untuk postingan ini, kami menggunakan opsi ini, yang memungkinkan Anda bereksperimen dengan cepat dengan menjalankan kode Anda sendiri di atas gambar container yang sudah dibuat sebelumnya.
   • Bawalah image Docker kustom Anda sendiri jika Anda ingin menggunakan kerangka kerja atau perangkat lunak yang tidak didukung. Opsi ini memerlukan upaya paling besar, namun juga memberikan tingkat fleksibilitas dan kontrol tertinggi.
3. Latih model dengan data Anda. Bergantung pada penerapan algoritme dari langkah sebelumnya, tindakan ini bisa sesederhana mereferensikan data pelatihan Anda dan menjalankan tugas pelatihan atau dengan memberikan tambahan kode khusus untuk pelatihan. Dalam kasus kami, kami menggunakan beberapa kode pelatihan khusus dengan Python berdasarkan Scikit-learn.
4. Terapkan pengoptimalan hyperparameter (sebagai "percakapan" dengan model ML Anda). Setelah pelatihan, Anda biasanya ingin mengoptimalkan performa model dengan menemukan kombinasi nilai yang paling menjanjikan untuk hyperparameter algoritme Anda.

Bergantung pada algoritme ML dan ukuran model Anda, langkah terakhir pengoptimalan hyperparameter mungkin menjadi tantangan yang lebih besar dari yang diperkirakan. Pertanyaan-pertanyaan berikut merupakan pertanyaan umum bagi praktisi ML pada tahap ini dan mungkin terdengar familier bagi Anda:

• Hyperparameter seperti apa yang berdampak pada masalah ML saya?
• Bagaimana cara mencari ruang hyperparameter yang besar secara efektif untuk menemukan nilai dengan performa terbaik?
• Bagaimana kombinasi nilai hyperparameter tertentu memengaruhi metrik performa saya?
• Biaya penting; bagaimana saya bisa menggunakan sumber daya saya secara efisien?
• Eksperimen penyetelan seperti apa yang bermanfaat, dan bagaimana cara membandingkannya?

Tidak mudah untuk menjawab pertanyaan-pertanyaan ini, namun ada kabar baik. SageMaker AMT mengambil beban berat dari Anda, dan memungkinkan Anda berkonsentrasi dalam memilih strategi HPO yang tepat dan rentang nilai yang ingin Anda jelajahi. Selain itu, solusi visualisasi kami memfasilitasi proses analisis dan eksperimen berulang untuk menemukan nilai hyperparameter yang berperforma baik secara efisien.

Di bagian selanjutnya, kami membuat model pengenalan digit dari awal menggunakan Scikit-learn dan menunjukkan semua konsep ini dalam praktiknya.

Ikhtisar solusi

SageMaker menawarkan beberapa fitur yang sangat berguna untuk melatih, mengevaluasi, dan menyempurnakan model kami. Ini mencakup semua fungsi siklus hidup ML end-to-end, jadi kita bahkan tidak perlu meninggalkan notebook Jupyter kita.

Pada postingan pertama kami, kami menggunakan algoritma bawaan SageMaker XGBoost. Untuk tujuan demonstrasi, kali ini kami beralih ke pengklasifikasi Random Forest karena kami kemudian dapat menunjukkan cara memberikan kode pelatihan Anda sendiri. Kami memilih untuk menyediakan skrip Python kami sendiri dan menggunakan Scikit-learn sebagai kerangka kerja kami. Sekarang, bagaimana kita menyatakan bahwa kita ingin menggunakan framework ML tertentu? Seperti yang akan kita lihat, SageMaker menggunakan layanan AWS lain di latar belakang untuk mengambil image container Docker yang telah dibuat sebelumnya untuk pelatihan—Registry Kontainer Elastis Amazon (ECR Amazon).

Kami membahas langkah-langkah berikut secara mendetail, termasuk cuplikan kode dan diagram untuk menghubungkan titik-titik. Seperti disebutkan sebelumnya, jika Anda memiliki kesempatan, buka buku catatan dan jalankan sel kode langkah demi langkah untuk membuat artefak di lingkungan AWS Anda. Tidak ada cara yang lebih baik untuk belajar aktif.

1. Pertama, muat dan siapkan data. Kita gunakan Layanan Penyimpanan Sederhana Amazon (Amazon S3) untuk mengunggah file yang berisi data angka tulisan tangan kami.
2. Selanjutnya, siapkan skrip pelatihan dan dependensi framework. Kami menyediakan kode pelatihan khusus dengan Python, mereferensikan beberapa perpustakaan dependen, dan melakukan uji coba.
3. Untuk menentukan metrik tujuan khusus, SageMaker memungkinkan kita menentukan ekspresi reguler untuk mengekstrak metrik yang kita perlukan dari file log kontainer.
4. Latih model menggunakan kerangka scikit-learn. Dengan mereferensikan gambar kontainer yang sudah dibuat sebelumnya, kami membuat objek Estimator yang sesuai dan meneruskan skrip pelatihan khusus kami.
5. AMT memungkinkan kami untuk mencoba berbagai strategi HPO. Kami berkonsentrasi pada dua di antaranya untuk posting ini: pencarian acak dan pencarian Bayesian.
6. Pilih antara strategi SageMaker HPO.
7. Visualisasikan, analisis, dan bandingkan hasil penyetelan. Paket visualisasi kami memungkinkan kami menemukan strategi mana yang berkinerja lebih baik dan nilai hyperparameter mana yang memberikan kinerja terbaik berdasarkan metrik kami.
8. Lanjutkan eksplorasi ruang hyperparameter dan mulai pekerjaan HPO.

AMT menangani penskalaan dan pengelolaan infrastruktur komputasi yang mendasarinya untuk menjalankan berbagai pekerjaan penyetelan Cloud komputasi elastis Amazon (Amazon EC2) instans. Dengan cara ini, Anda tidak perlu membebani diri sendiri untuk menyediakan instans, menangani masalah sistem operasi dan perangkat keras apa pun, atau mengumpulkan file log sendiri. Gambar kerangka ML diambil dari Amazon ECR dan artefak model termasuk hasil penyetelan disimpan di Amazon S3. Semua log dan metrik dikumpulkan amazoncloudwatch untuk akses mudah dan analisis lebih lanjut jika diperlukan.

Prasyarat

Karena ini merupakan kelanjutan dari sebuah seri, disarankan, namun belum tentu wajib, untuk dibaca postingan pertama kami tentang SageMaker AMT dan HPO. Selain itu, pemahaman dasar tentang konsep ML dan pemrograman Python juga sangat membantu. Kami juga merekomendasikan untuk mengikuti setiap langkah dalam notebook terlampir dari repositori GitHub kami saat membaca posting ini. Notebook dapat dijalankan secara independen dari yang pertama, tetapi memerlukan beberapa kode dari subfolder. Pastikan untuk mengkloning repositori lengkap di lingkungan Anda seperti yang dijelaskan dalam file README.

Bereksperimen dengan kode dan menggunakan opsi visualisasi interaktif akan sangat meningkatkan pengalaman belajar Anda. Jadi, silakan periksa.

Memuat dan menyiapkan data

Sebagai langkah pertama, kami pastikan sudah diunduh data digit yang kami perlukan untuk pelatihan dapat diakses oleh SageMaker. Amazon S3 memungkinkan kami melakukan hal ini dengan cara yang aman dan terukur. Lihat buku catatan untuk mengetahui kode sumber selengkapnya dan jangan ragu untuk menyesuaikannya dengan data Anda sendiri.

sm_sess = sagemaker.session.Session(boto_session=boto_sess, sagemaker_client=sm)
BUCKET = sm_sess.default_bucket()
PREFIX = 'amt-visualize-demo'
s3_data_url = f's3://{BUCKET}/{PREFIX}/data'
digits = datasets.load_digits()
digits_df = pd.DataFrame(digits.data)
digits_df['y'] = digits.target
digits_df.to_csv('data/digits.csv', index=False)
!aws s3 sync data/ {s3_data_url} —exclude '*' —include 'digits.csv'

Grafik digits.csv file berisi data fitur dan label. Setiap digit diwakili oleh nilai piksel pada gambar berukuran 8×8, seperti yang digambarkan pada gambar berikut untuk digit 4.

Siapkan skrip pelatihan dan dependensi kerangka kerja

Sekarang data disimpan di bucket S3, kita dapat menentukan skrip pelatihan khusus berdasarkan Scikit-belajar dengan Python. SageMaker memberi kita opsi untuk mereferensikan file Python nanti untuk pelatihan. Dependensi apa pun seperti pustaka Scikit-learn atau pandas dapat disediakan dengan dua cara:

• Mereka dapat ditentukan secara eksplisit dalam a requirements.txt fillet
• Mereka sudah diinstal sebelumnya di image container ML yang mendasarinya, yang disediakan oleh SageMaker atau dibuat khusus

Kedua opsi tersebut umumnya dianggap sebagai cara standar untuk manajemen ketergantungan, jadi Anda mungkin sudah familiar dengannya. SageMaker mendukung berbagai kerangka kerja ML dalam lingkungan terkelola yang siap digunakan. Ini mencakup banyak kerangka ilmu data dan ML paling populer seperti PyTorch, TensorFlow, atau Scikit-learn, seperti dalam kasus kami. Kami tidak menggunakan tambahan requirements.txt file, tetapi jangan ragu untuk menambahkan beberapa perpustakaan untuk mencobanya.

Kode implementasi kami berisi metode yang disebut fit(), yang membuat pengklasifikasi baru untuk tugas pengenalan digit dan melatihnya. Berbeda dengan posting pertama kami di mana kami menggunakan algoritma XGBoost bawaan SageMaker, kami sekarang menggunakan a RandomForestClassifier disediakan oleh perpustakaan ML sklearn. Panggilan dari fit() metode pada objek pengklasifikasi memulai proses pelatihan menggunakan subset (80%) data CSV kami:

def fit(train_dir, n_estimators, max_depth, min_samples_leaf, max_features, min_weight_fraction_leaf): digits = pd.read_csv(Path(train_dir)/'digits.csv') Xtrain, Xtest, ytrain, ytest = train_test_split(digits.iloc[:, :-1], digits.iloc[:, -1], test_size=.2) m = RandomForestClassifier(n_estimators=n_estimators, max_depth=max_depth, min_samples_leaf=min_samples_leaf, max_features=max_features, min_weight_fraction_leaf=min_weight_fraction_leaf) m.fit(Xtrain, ytrain) predicted = m.predict(Xtest) pre, rec, f1, _ = precision_recall_fscore_support(ytest, predicted, pos_label=1, average='weighted') print(f'pre: {pre:5.3f} rec: {rec:5.3f} f1: {f1:5.3}') return m

Lihat skrip lengkapnya di buku catatan Jupyter kami di GitHub.

Sebelum Anda menjalankan sumber daya kontainer untuk proses pelatihan penuh, apakah Anda mencoba menjalankan skrip secara langsung? Ini adalah praktik yang baik untuk segera memastikan kode tidak memiliki kesalahan sintaksis, memeriksa dimensi struktur data Anda yang cocok, dan beberapa kesalahan lainnya sejak dini.

Ada dua cara untuk menjalankan kode Anda secara lokal. Pertama, Anda bisa langsung menjalankannya di notebook, yang juga memungkinkan Anda menggunakan Python Debugger pdb:

# Running the code from within the notebook. It would then be possible to use the Python Debugger, pdb.
from train import fit
fit('data', 100, 10, 1, 'auto', 0.01)

Alternatifnya, jalankan skrip kereta dari baris perintah dengan cara yang sama seperti Anda ingin menggunakannya dalam kontainer. Ini juga mendukung pengaturan berbagai parameter dan menimpa nilai default sesuai kebutuhan, misalnya:

!cd src && python train.py --train ../data/ --model-dir /tmp/ --n-estimators 100

Sebagai output, Anda dapat melihat hasil pertama untuk performa model berdasarkan presisi metrik objektif, perolehan, dan skor F1. Misalnya, pre: 0.970 rec: 0.969 f1: 0.969.

Lumayan untuk latihan secepat itu. Namun dari mana angka-angka ini berasal dan apa yang kita lakukan terhadapnya?

Tentukan metrik tujuan khusus

Ingat, tujuan kita adalah melatih dan menyempurnakan model kita sepenuhnya berdasarkan metrik objektif yang kita anggap relevan untuk tugas kita. Karena kami menggunakan skrip pelatihan khusus, kami perlu mendefinisikan metrik tersebut untuk SageMaker secara eksplisit.

Skrip kami memancarkan presisi metrik, perolehan, dan skor F1 selama pelatihan hanya dengan menggunakan print fungsi:

print(f'pre: {pre:5.3f} rec: {rec:5.3f} f1: {f1:5.3}')

Output standar ditangkap oleh SageMaker dan dikirim ke CloudWatch sebagai aliran log. Untuk mengambil nilai metrik dan menggunakannya nanti di SageMaker AMT, kita perlu memberikan beberapa informasi tentang cara mengurai output tersebut. Kita dapat mencapai hal ini dengan mendefinisikan pernyataan ekspresi reguler (untuk informasi lebih lanjut, lihat Pantau dan Analisis Pekerjaan Pelatihan Menggunakan Metrik Amazon CloudWatch):

metric_definitions = [ {'Name': 'valid-precision', 'Regex': r'pre:s+(-?[0-9.]+)'}, {'Name': 'valid-recall', 'Regex': r'rec:s+(-?[0-9.]+)'}, {'Name': 'valid-f1', 'Regex': r'f1:s+(-?[0-9.]+)'}] 

Mari kita telusuri definisi metrik pertama pada kode sebelumnya bersama-sama. SageMaker akan mencari keluaran di log yang dimulai dengan pre: dan diikuti oleh satu atau lebih spasi dan kemudian angka yang ingin kita ekstrak, itulah sebabnya kita menggunakan tanda kurung bulat. Setiap kali SageMaker menemukan nilai seperti itu, SageMaker mengubahnya menjadi metrik CloudWatch dengan namanya valid-precision.

Latih model menggunakan kerangka Scikit-learn

Setelah kami membuat skrip pelatihan kami train.py dan menginstruksikan SageMaker tentang cara memantau metrik dalam CloudWatch, kami mendefinisikan a Pengukur SageMaker obyek. Ini memulai tugas pelatihan dan menggunakan tipe instans yang kami tentukan. Namun bagaimana tipe instance ini berbeda dari yang Anda jalankan Studio Amazon SageMaker notebook aktif, dan mengapa? SageMaker Studio menjalankan pekerjaan pelatihan (dan inferensi) Anda pada instans komputasi yang terpisah dari notebook Anda. Hal ini memungkinkan Anda untuk terus bekerja di buku catatan Anda saat pekerjaan berjalan di latar belakang.

Parameter framework_version mengacu pada versi Scikit-learn yang kami gunakan untuk tugas pelatihan kami. Alternatifnya, kita bisa lewat image_uri ke estimator. Anda dapat memeriksa apakah framework atau pustaka ML favorit Anda tersedia sebagai image SageMaker Docker yang sudah dibuat sebelumnya dan menggunakannya sebagaimana adanya atau dengan ekstensi.

Selain itu, kita dapat menjalankan tugas pelatihan SageMaker pada Instans Spot EC2 dengan mengatur use_spot_instances untuk True. Ini adalah contoh kapasitas cadangan yang bisa menghemat hingga 90% biaya. Instans ini memberikan fleksibilitas kapan tugas pelatihan dijalankan.

estimator = SKLearn( 'train.py', source_dir='src', role=get_execution_role(), instance_type= 'ml.m5.large', instance_count=1, framework_version='0.23-1', metric_definitions=metric_definitions, # Uncomment the following three lines to use Managed Spot Training # use_spot_instances= True, # max_run= 60 * 60 * 24, # max_wait= 60 * 60 * 24, hyperparameters = {'n-estimators': 100, 'max-depth': 10, 'min-samples-leaf': 1, 'max-features': 'auto', 'min-weight-fraction-leaf': 0.1}
)

Setelah objek Estimator disiapkan, kita memulai pelatihan dengan memanggil fit() fungsi, menyediakan jalur ke dataset pelatihan di Amazon S3. Kita dapat menggunakan metode yang sama untuk memberikan validasi dan pengujian data. Kami mengatur wait parameter untuk True sehingga kita dapat menggunakan model yang dilatih di sel kode berikutnya.

estimator.fit({'train': s3_data_url}, wait=True)

Tentukan hyperparameter dan jalankan tugas penyetelan

Sejauh ini, kami telah melatih model dengan satu set nilai hyperparameter. Namun apakah nilai-nilai tersebut baik? Atau bisakah kita mencari yang lebih baik? Ayo gunakan Kelas HyperparameterTuner untuk menjalankan pencarian sistematis pada ruang hyperparameter. Bagaimana kita mencari ruang ini dengan tuner? Parameter yang diperlukan adalah nama metrik tujuan dan jenis tujuan yang akan memandu pengoptimalan. Strategi optimasi adalah argumen kunci lainnya bagi tuner karena strategi ini lebih mendefinisikan ruang pencarian. Berikut ini adalah empat strategi berbeda yang dapat dipilih:

• Pencarian kotak
• Pencarian acak
• Pengoptimalan Bayesian (default)
• hiperband

Kami menjelaskan lebih lanjut strategi ini dan membekali Anda dengan beberapa panduan untuk memilih salah satunya nanti di postingan ini.

Sebelum kita mendefinisikan dan menjalankan objek tuner, mari kita rekap pemahaman kita dari perspektif arsitektur. Kami membahas ikhtisar arsitektur SageMaker AMT di postingan terakhir kami dan mereproduksi kutipannya di sini untuk kenyamanan.

Kita dapat memilih hyperparameter apa yang ingin kita sesuaikan atau biarkan statis. Untuk hyperparameter dinamis, kami menyediakan hyperparameter_ranges yang dapat digunakan untuk mengoptimalkan hyperparameter yang dapat disetel. Karena kami menggunakan pengklasifikasi Random Forest, kami telah memanfaatkan hyperparameter dari Scikit-pelajari dokumentasi Random Forest.

Kami juga membatasi sumber daya dengan jumlah maksimum tugas pelatihan dan tugas pelatihan paralel yang dapat digunakan tuner. Kita akan melihat bagaimana batasan ini membantu kita membandingkan hasil dari berbagai strategi satu sama lain.

tuner_parameters = { 'estimator': estimator, 'base_tuning_job_name': 'random', 'metric_definitions': metric_definitions, 'objective_metric_name': 'valid-f1', 'objective_type': 'Maximize', 'hyperparameter_ranges': hpt_ranges, 'strategy': 'Random', 'max_jobs': n, # 50 'max_parallel_jobs': k # 2 } 

Mirip dengan Estimator fit fungsi, kami memulai pekerjaan penyetelan dengan memanggil tuner fit:

random_tuner = HyperparameterTuner(**tuner_parameters)
random_tuner.fit({'train': s3_data_url}, wait=False)

Hanya ini yang harus kita lakukan agar SageMaker menjalankan tugas pelatihan (n=50) di latar belakang, masing-masing menggunakan kumpulan hyperparameter yang berbeda. Kami mengeksplorasi hasilnya nanti di posting ini. Namun sebelum itu, mari kita mulai melakukan penyesuaian lainnya, kali ini dengan menerapkan strategi pengoptimalan Bayesian. Kami akan membandingkan kedua strategi secara visual setelah selesai.

tuner_parameters['strategy'] = 'Bayesian'
tuner_parameters['base_tuning_job_name'] = 'bayesian'
bayesian_tuner = HyperparameterTuner(**tuner_parameters)
bayesian_tuner.fit({'train': s3_data_url}, wait=False)

Perhatikan bahwa kedua pekerjaan tuner dapat berjalan secara paralel karena SageMaker mengatur instans komputasi yang diperlukan secara independen satu sama lain. Hal ini cukup membantu bagi praktisi yang bereksperimen dengan pendekatan berbeda pada saat yang sama, seperti yang kami lakukan di sini.

Pilih antara strategi SageMaker HPO

Dalam hal strategi penyetelan, Anda memiliki beberapa opsi dengan SageMaker AMT: pencarian grid, pencarian acak, optimasi Bayesian, dan Hyperband. Strategi ini menentukan bagaimana algoritme penyetelan otomatis mengeksplorasi rentang hyperparameter tertentu.

Pencarian acak cukup mudah. Ini secara acak memilih kombinasi nilai dari rentang yang ditentukan dan dapat dijalankan secara berurutan atau paralel. Ini seperti melempar anak panah dengan mata tertutup, berharap mengenai sasaran. Kami telah memulai dengan strategi ini, namun apakah hasilnya akan membaik dengan strategi yang lain?

Pengoptimalan Bayesian menggunakan pendekatan yang berbeda dari penelusuran acak. Ini mempertimbangkan sejarah pilihan sebelumnya dan memilih nilai yang mungkin memberikan hasil terbaik. Jika Anda ingin belajar dari eksplorasi sebelumnya, Anda dapat mencapainya hanya dengan menjalankan tugas penyetelan baru setelah eksplorasi sebelumnya. Masuk akal, bukan? Dengan cara ini, optimasi Bayesian bergantung pada proses sebelumnya. Namun apakah Anda melihat strategi HPO apa yang memungkinkan paralelisasi lebih tinggi?

hiperband adalah salah satu yang menarik! Ini menggunakan strategi multi-fidelity, yang berarti secara dinamis mengalokasikan sumber daya ke pekerjaan pelatihan yang paling menjanjikan dan menghentikan pekerjaan yang kinerjanya buruk. Oleh karena itu, Hyperband efisien secara komputasi dengan sumber daya, belajar dari tugas pelatihan sebelumnya. Setelah menghentikan konfigurasi yang berkinerja buruk, konfigurasi baru akan dimulai, dan nilainya dipilih secara acak.

Bergantung pada kebutuhan dan sifat model Anda, Anda dapat memilih antara pencarian acak, pengoptimalan Bayesian, atau Hyperband sebagai strategi penyesuaian Anda. Masing-masing memiliki pendekatan dan kelebihannya masing-masing, jadi penting untuk mempertimbangkan mana yang paling cocok untuk eksplorasi ML Anda. Kabar baiknya bagi praktisi ML adalah Anda dapat memilih strategi HPO terbaik dengan membandingkan secara visual dampak setiap uji coba pada metrik objektif. Di bagian berikutnya, kita melihat cara mengidentifikasi dampak berbagai strategi secara visual.

Visualisasikan, analisis, dan bandingkan hasil penyetelan

Ketika pekerjaan penyetelan kami selesai, itu menjadi menyenangkan. Hasil apa yang mereka berikan? Peningkatan seperti apa yang dapat Anda harapkan pada metrik kami dibandingkan dengan model dasar Anda? Hyperparameter apa yang berperforma terbaik untuk kasus penggunaan kita?

Cara cepat dan mudah untuk melihat hasil HPO adalah dengan mengunjungi konsol SageMaker. Di bawah Pekerjaan penyetelan hyperparameter, kami dapat melihat (per tugas penyetelan) kombinasi nilai hyperparameter yang telah diuji dan menghasilkan performa terbaik yang diukur dengan metrik objektif kami (valid-f1).

Apakah hanya itu yang Anda butuhkan? Sebagai seorang praktisi ML, Anda mungkin tidak hanya tertarik pada nilai-nilai tersebut, namun tentunya ingin mempelajari lebih lanjut cara kerja model Anda untuk mengeksplorasi potensi penuhnya dan memperkuat intuisi Anda dengan masukan empiris.

Alat visualisasi yang baik dapat sangat membantu Anda memahami peningkatan HPO dari waktu ke waktu dan mendapatkan masukan empiris mengenai keputusan desain model ML Anda. Ini menunjukkan dampak setiap hyperparameter pada metrik tujuan Anda dan memberikan panduan untuk lebih mengoptimalkan hasil penyesuaian Anda.

Kami menggunakan amtviz paket visualisasi khusus untuk memvisualisasikan dan menganalisis pekerjaan penyetelan. Mudah digunakan dan menyediakan fitur bermanfaat. Kami mendemonstrasikan manfaatnya dengan menafsirkan beberapa grafik individual, dan akhirnya membandingkan pencarian acak secara berdampingan dengan optimasi Bayesian.

Pertama, mari buat visualisasi untuk pencarian acak. Kita dapat melakukan ini dengan menelepon visualize_tuning_job() dari amtviz dan meneruskan objek tuner pertama kita sebagai argumen:

from amtviz import visualize_tuning_job
visualize_tuning_job(random_tuner, advanced=True, trials_only=True)

Anda akan melihat beberapa grafik, tapi mari kita lihat langkah demi langkah. Plot sebar pertama dari keluaran terlihat seperti berikut dan sudah memberi kita beberapa petunjuk visual yang tidak akan kita kenali di tabel mana pun.

Setiap titik mewakili kinerja pekerjaan pelatihan individu (tujuan kami valid-f1 pada sumbu y) berdasarkan waktu mulainya (sumbu x), yang dihasilkan oleh sekumpulan hyperparameter tertentu. Oleh karena itu, kami melihat performa model kami seiring perkembangannya selama durasi tugas penyetelan.

Garis putus-putus menyoroti hasil terbaik yang ditemukan sejauh ini dan menunjukkan peningkatan dari waktu ke waktu. Dua pekerjaan pelatihan terbaik mencapai skor F1 sekitar 0.91.

Selain garis putus-putus yang menunjukkan kemajuan kumulatif, apakah Anda melihat tren pada grafik?

Mungkin tidak. Dan hal ini sudah diduga, karena kita sedang melihat hasil dari strategi HPO acak. Setiap tugas pelatihan dijalankan menggunakan kumpulan hyperparameter yang berbeda namun dipilih secara acak. Jika kami melanjutkan pekerjaan penyetelan kami (atau menjalankan pekerjaan penyetelan lainnya dengan pengaturan yang sama), kami mungkin akan melihat hasil yang lebih baik seiring berjalannya waktu, namun kami tidak dapat memastikannya. Keacakan adalah hal yang rumit.

Bagan berikutnya membantu Anda mengukur pengaruh hyperparameter terhadap performa secara keseluruhan. Semua hyperparameter divisualisasikan, namun agar singkatnya, kami fokus pada dua di antaranya: n-estimators dan max-depth.

Dua pekerjaan pelatihan teratas kami menggunakan n-estimators sekitar 20 dan 80, dan max-depth masing-masing sekitar 10 dan 18. Nilai hyperparameter yang tepat ditampilkan melalui tooltip untuk setiap titik (pekerjaan pelatihan). Mereka bahkan disorot secara dinamis di seluruh grafik dan memberi Anda tampilan multidimensi! Apakah kamu melihat itu? Setiap hyperparameter diplot terhadap metrik objektif, sebagai diagram terpisah.

Sekarang, wawasan seperti apa yang kita peroleh n-estimators?

Berdasarkan grafik di sebelah kiri, nampaknya rentang nilai yang sangat rendah (di bawah 10) lebih sering memberikan hasil yang buruk dibandingkan dengan nilai yang lebih tinggi. Oleh karena itu, nilai yang lebih tinggi dapat membantu model Anda berperforma lebih baik—menarik.

Sebaliknya, korelasi max-depth hyperparameter ke metrik tujuan kami agak rendah. Kami tidak dapat membedakan dengan jelas rentang nilai mana yang berkinerja lebih baik dari sudut pandang umum.

Singkatnya, penelusuran acak dapat membantu Anda menemukan kumpulan hyperparameter yang berperforma baik bahkan dalam waktu yang relatif singkat. Selain itu, ini tidak bias terhadap solusi yang baik namun memberikan pandangan yang seimbang tentang ruang pencarian. Namun pemanfaatan sumber daya Anda mungkin tidak terlalu efisien. Ia terus menjalankan tugas pelatihan dengan hyperparameter dalam rentang nilai yang diketahui memberikan hasil yang buruk.

Mari kita periksa hasil pekerjaan penyetelan kedua menggunakan optimasi Bayesian. Kita bisa gunakan amtviz untuk memvisualisasikan hasilnya dengan cara yang sama seperti yang kami lakukan sejauh ini untuk penyetel penelusuran acak. Atau, yang lebih baik lagi, kita dapat menggunakan kemampuan fungsi tersebut untuk membandingkan kedua pekerjaan penyetelan dalam satu kumpulan bagan. Cukup berguna!

visualize_tuning_job([random_tuner, bayesian_tuner], advanced=True, trials_only=True)

Kini terdapat lebih banyak titik karena kami memvisualisasikan hasil semua tugas pelatihan untuk penelusuran acak (titik oranye) dan pengoptimalan Bayesian (titik biru). Di sisi kanan, Anda dapat melihat grafik kepadatan yang memvisualisasikan distribusi semua skor F1. Mayoritas pekerjaan pelatihan mencapai hasil di bagian atas skala F1 (lebih dari 0.6)—itu bagus!

Apa intisarinya di sini? Plot sebar dengan jelas menunjukkan manfaat optimasi Bayesian. Ini memberikan hasil yang lebih baik dari waktu ke waktu karena dapat belajar dari proses sebelumnya. Itu sebabnya kami mencapai hasil yang jauh lebih baik menggunakan Bayesian dibandingkan dengan acak (0.967 vs. 0.919) dengan jumlah pekerjaan pelatihan yang sama.

Masih banyak lagi yang dapat Anda lakukan amtviz. Mari kita telusuri.

Jika Anda memberikan SageMaker AMT instruksi untuk menjalankan lebih banyak pekerjaan penyetelan, melihat banyak uji coba sekaligus dapat menjadi berantakan. Itulah salah satu alasan mengapa kami membuat grafik ini interaktif. Anda dapat mengklik dan menyeret setiap plot sebar hyperparameter untuk memperbesar rentang nilai tertentu dan menyempurnakan interpretasi visual Anda terhadap hasilnya. Semua grafik lainnya diperbarui secara otomatis. Itu cukup membantu, bukan? Lihat grafik berikutnya sebagai contoh dan cobalah sendiri di buku catatan Anda!

Sebagai seorang maksimalis penyetelan, Anda juga dapat memutuskan bahwa menjalankan tugas penyetelan hyperparameter lainnya dapat lebih meningkatkan performa model Anda. Namun kali ini, rentang nilai hyperparameter yang lebih spesifik dapat dieksplorasi karena Anda sudah mengetahui (secara kasar) di mana Anda dapat mengharapkan hasil yang lebih baik. Misalnya, Anda dapat memilih untuk fokus pada nilai antara 100–200 n-estimators, seperti yang ditunjukkan pada grafik. Hal ini memungkinkan AMT fokus pada pekerjaan pelatihan yang paling menjanjikan dan meningkatkan efisiensi penyetelan Anda.

Singkatnya, amtviz memberi Anda serangkaian kemampuan visualisasi yang memungkinkan Anda lebih memahami dampak hyperparameter model Anda terhadap performa dan memungkinkan keputusan yang lebih cerdas dalam aktivitas penyesuaian Anda.

Lanjutkan eksplorasi ruang hyperparameter dan mulai pekerjaan HPO

Kita telah melihat bahwa AMT membantu kita menjelajahi ruang pencarian hyperparameter secara efisien. Namun bagaimana jika kita memerlukan beberapa putaran penyesuaian untuk meningkatkan hasil secara berulang? Seperti disebutkan di awal, kami ingin membangun siklus umpan balik pengoptimalan—“percakapan” kami dengan model. Apakah kita perlu memulai dari awal setiap saat?

Mari kita lihat konsep menjalankan a memulai pekerjaan penyetelan hyperparameter dengan hangat. Ia tidak memulai pekerjaan penyetelan baru dari awal, ia menggunakan kembali apa yang telah dipelajari dalam proses HPO sebelumnya. Hal ini membantu kami menjadi lebih efisien dalam waktu penyesuaian dan sumber daya komputasi. Kami selanjutnya dapat mengulangi hasil kami sebelumnya. Untuk menggunakan permulaan hangat, kita membuat a WarmStartConfig dan tentukan warm_start_type as IDENTICAL_DATA_AND_ALGORITHM. Artinya kita mengubah nilai hyperparameter tetapi kita tidak mengubah data atau algoritmanya. Kami meminta AMT untuk mentransfer pengetahuan sebelumnya ke pekerjaan penyetelan baru kami.

Dengan mengacu pada optimasi Bayesian kami sebelumnya dan pekerjaan penyetelan pencarian acak sebagai parents, kita bisa menggunakan keduanya untuk awal yang hangat:

warm_start_config = WarmStartConfig(warm_start_type=WarmStartTypes.IDENTICAL_DATA_AND_ALGORITHM, parents=[bayesian_tuner_name, random_tuner_name])
tuner_parameters['warm_start_config'] = warm_start_config

Untuk melihat manfaat penggunaan start hangat, lihat tabel berikut. Ini dihasilkan oleh amtviz dengan cara yang sama seperti yang kami lakukan sebelumnya, namun kali ini kami telah menambahkan pekerjaan penyetelan lain berdasarkan awal yang hangat.

Pada bagan sebelah kiri, kita dapat mengamati bahwa tugas penyetelan baru sebagian besar terletak di sudut kanan atas grafik metrik kinerja (lihat titik yang ditandai dengan warna oranye). Awal yang hangat memang menggunakan kembali hasil sebelumnya, itulah sebabnya poin data tersebut berada di hasil teratas untuk skor F1. Peningkatan ini juga tercermin pada grafik kepadatan di sebelah kanan.

Dengan kata lain, AMT secara otomatis memilih kumpulan nilai hyperparameter yang menjanjikan berdasarkan pengetahuannya dari uji coba sebelumnya. Hal ini ditunjukkan pada grafik berikutnya. Misalnya, algoritme akan menguji nilai yang rendah n-estimators lebih jarang karena hal ini diketahui menghasilkan skor F1 yang buruk. Kami tidak menyia-nyiakan sumber daya apa pun untuk hal itu, berkat permulaan yang hangat.

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 SageMaker Studio.

Jalankan kode berikut di buku catatan 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

Kita telah mempelajari bagaimana seni membangun solusi ML melibatkan eksplorasi dan pengoptimalan hyperparameter. Menyesuaikan tombol dan tuas tersebut merupakan proses yang menuntut namun bermanfaat yang menghasilkan waktu pelatihan lebih cepat, akurasi model yang lebih baik, dan solusi ML yang lebih baik secara keseluruhan. Fungsionalitas SageMaker AMT membantu kami menjalankan beberapa pekerjaan penyetelan dan memulainya dengan hangat, serta menyediakan titik data untuk peninjauan lebih lanjut, perbandingan visual, dan analisis.

Dalam postingan ini, kami melihat strategi HPO yang kami gunakan dengan SageMaker AMT. Kami memulai dengan penelusuran acak, sebuah strategi yang lugas namun efektif di mana hyperparameter diambil sampelnya secara acak dari ruang penelusuran. Selanjutnya, kami membandingkan hasilnya dengan optimasi Bayesian, yang menggunakan model probabilistik untuk memandu pencarian hyperparameter yang optimal. Setelah kami mengidentifikasi strategi HPO yang sesuai dan rentang nilai hyperparameter yang baik melalui uji coba awal, kami menunjukkan cara menggunakan awal yang hangat untuk menyederhanakan pekerjaan HPO di masa depan.

Anda dapat menjelajahi ruang pencarian hyperparameter dengan membandingkan hasil kuantitatif. Kami telah menyarankan perbandingan visual berdampingan dan menyediakan paket yang diperlukan untuk eksplorasi interaktif. Beri tahu kami di komentar betapa bermanfaatnya hal ini bagi Anda dalam perjalanan penyetelan hyperparameter Anda!

Tentang penulis

Dengar Yoldas adalah Arsitek Solusi Senior di Amazon Web Services. Dia bekerja dengan pelanggan perusahaan di berbagai industri di Jerman. Dia terdorong untuk menerjemahkan konsep AI ke dalam solusi dunia nyata. Di luar pekerjaan, dia menikmati waktu bersama keluarga, menikmati makanan enak, dan mengejar kebugaran.

Elina Lesyk adalah Arsitek Solusi yang berlokasi di Munich. Dia fokus pada pelanggan perusahaan dari industri jasa keuangan. Di waktu luangnya, Anda dapat menemukan Elina membuat aplikasi dengan AI generatif di beberapa pertemuan TI, mendorong ide baru untuk memperbaiki perubahan iklim dengan cepat, atau berlari di hutan untuk mempersiapkan setengah maraton yang biasanya menyimpang dari jadwal yang direncanakan.

Kamp Mariano adalah Arsitek Solusi Utama di Amazon Web Services. Dia bekerja dengan bank dan perusahaan asuransi di Jerman dalam pembelajaran mesin. Di waktu luangnya, Mariano menikmati hiking bersama istrinya.

• Konten Bertenaga SEO & Distribusi PR. Dapatkan Amplifikasi Hari Ini.
• PlatoData.Jaringan Vertikal Generatif Ai. Berdayakan Diri Anda. Akses Di Sini.
• PlatoAiStream. Intelijen Web3. Pengetahuan Diperkuat. Akses Di Sini.
• PlatoESG. Karbon, teknologi bersih, energi, Lingkungan Hidup, Tenaga surya, Penanganan limbah. Akses Di Sini.
• PlatoHealth. Kecerdasan Uji Coba Biotek dan Klinis. Akses Di Sini.
• Sumber: https://aws.amazon.com/blogs/machine-learning/explore-advanced-techniques-for-hyperparameter-optimization-with-amazon-sagemaker-automatic-model-tuning/