Mencapai kinerja tinggi dalam skala besar untuk penyajian model menggunakan titik akhir multi-model Amazon SageMaker dengan GPU

Amazon SageMaker titik akhir multi-model (MME) menyediakan cara yang dapat diskalakan dan hemat biaya untuk menerapkan sejumlah besar model machine learning (ML). Ini memberi Anda kemampuan untuk menerapkan beberapa model ML dalam satu wadah penyajian di belakang satu titik akhir. Dari sana, SageMaker mengelola pemuatan dan pembongkaran model dan penskalaan sumber daya atas nama Anda berdasarkan pola lalu lintas Anda. Anda akan mendapat manfaat dari berbagi dan menggunakan kembali sumber daya hosting dan mengurangi beban operasional dalam mengelola model dalam jumlah besar.

Di 2022 November, MME menambahkan dukungan untuk GPUs, yang memungkinkan Anda menjalankan beberapa model pada satu perangkat GPU dan menskalakan instans GPU di belakang satu titik akhir. Ini memenuhi permintaan MME yang kuat untuk model deep neural network (DNN) yang mendapat manfaat dari komputasi yang dipercepat dengan GPU. Ini termasuk visi komputer (CV), pemrosesan bahasa alami (NLP), dan model AI generatif. Alasan permintaan tersebut antara lain sebagai berikut:

• Model DNN biasanya berukuran besar dan kompleks serta terus berkembang dengan pesat. Mengambil model NLP sebagai contoh, banyak di antaranya melebihi miliaran parameter, yang membutuhkan GPU untuk memenuhi persyaratan latensi rendah dan throughput tinggi.
• Kami telah mengamati peningkatan kebutuhan untuk menyesuaikan model ini untuk memberikan pengalaman yang sangat dipersonalisasi kepada pengguna individu. Seiring bertambahnya jumlah model ini, ada kebutuhan akan solusi yang lebih mudah untuk menyebarkan dan mengoperasionalkan banyak model dalam skala besar.
• Instans GPU mahal dan Anda ingin menggunakan kembali instans ini sebanyak mungkin untuk memaksimalkan pemanfaatan GPU dan mengurangi biaya pengoperasian.

Meskipun semua alasan ini mengarah ke MME dengan GPU sebagai opsi ideal untuk model DNN, disarankan untuk melakukan pengujian beban untuk menemukan konfigurasi titik akhir yang tepat yang memenuhi persyaratan kasus penggunaan Anda. Banyak faktor yang dapat memengaruhi hasil pengujian beban, seperti jenis instans, jumlah instans, ukuran model, dan arsitektur model. Selain itu, pengujian beban dapat membantu memandu strategi penskalaan otomatis menggunakan metrik yang tepat daripada metode coba-coba berulang.

Untuk alasan tersebut, kami menyusun postingan ini untuk membantu Anda melakukan pengujian beban yang tepat pada MME dengan GPU dan menemukan konfigurasi terbaik untuk kasus penggunaan ML Anda. Kami membagikan hasil pengujian beban kami untuk beberapa model DNN paling populer di NLP dan CV yang dihosting menggunakan MME pada berbagai jenis instans. Kami meringkas wawasan dan kesimpulan dari hasil pengujian kami untuk membantu Anda membuat keputusan yang tepat dalam mengonfigurasi penerapan Anda sendiri. Sepanjang jalan, kami juga membagikan pendekatan yang kami rekomendasikan untuk melakukan pengujian beban untuk MME di GPU. Alat dan teknik yang direkomendasikan menentukan jumlah optimal model yang dapat dimuat per jenis instans dan membantu Anda mencapai kinerja harga terbaik.

Ikhtisar solusi

Untuk pengenalan MME dan MME dengan GPU, lihat Buat Titik Akhir Multi-Model dan Jalankan beberapa model pembelajaran mendalam di GPU dengan titik akhir multi-model Amazon SageMaker. Untuk konteks pengujian beban di pos ini, Anda dapat mengunduh kode sampel kami dari GitHub repo untuk mereproduksi hasil atau menggunakannya sebagai template untuk membandingkan model Anda sendiri. Ada dua notebook yang disediakan dalam repo: satu untuk model CV pengujian beban dan satu lagi untuk NLP. Beberapa model dengan berbagai ukuran dan arsitektur dijadikan tolok ukur pada jenis instans GPU yang berbeda: ml.g4dn.2xlarge, ml.g5.2xlarge, dan ml.p3.2xlarge. Ini harus memberikan penampang kinerja yang masuk akal di seluruh metrik berikut untuk setiap instans dan jenis model:

• Jumlah maksimal model yang dapat dimuat ke dalam memori GPU
• Latensi respons end-to-end diamati di sisi klien untuk setiap kueri inferensi
• Throughput maksimum kueri per detik yang dapat diproses titik akhir tanpa kesalahan
• Maksimalkan pengguna saat ini per instans sebelum permintaan yang gagal diamati

Tabel berikut mencantumkan model yang diuji.

Tabel berikut mencantumkan instans GPU yang diuji.

Seperti disebutkan sebelumnya, contoh kode dapat diadopsi ke model dan jenis instans lainnya.

Perhatikan bahwa MME saat ini hanya mendukung instans GPU tunggal. Untuk daftar jenis instans yang didukung, lihat Algoritme, framework, dan instance yang didukung.

Prosedur pembandingan terdiri dari langkah-langkah berikut:

1. Ambil model terlatih dari hub model.
2. Persiapkan artefak model untuk disajikan di MME SageMaker (lihat Jalankan beberapa model pembelajaran mendalam di GPU dengan titik akhir multi-model Amazon SageMaker untuk lebih jelasnya).
3. Terapkan MME SageMaker pada instans GPU.
4. Tentukan jumlah maksimum model yang dapat dimuat ke dalam memori GPU dalam batas yang ditentukan.
5. Gunakan Locust Load Testing Framework untuk mensimulasikan lalu lintas yang secara acak memanggil model yang dimuat pada instans.
6. Mengumpulkan data dan menganalisis hasilnya.
7. Secara opsional, ulangi Langkah 2–6 setelah mengompilasi model ke TensorRT.

Langkah 4 dan 5 menjamin pandangan yang lebih dalam. Model dalam MME GPU SageMaker dimuat ke dalam memori secara dinamis. Oleh karena itu, pada Langkah 4, kami mengunggah artefak model awal ke Layanan Penyimpanan Sederhana Amazon (Amazon S3) dan aktifkan model untuk memuatnya ke dalam memori. Setelah pemanggilan awal, kami mengukur jumlah memori GPU yang digunakan, membuat salinan model awal, memanggil salinan model untuk memuatnya ke dalam memori, dan sekali lagi mengukur jumlah total memori GPU yang digunakan. Proses ini diulangi hingga batas persen penggunaan memori GPU yang ditentukan tercapai. Untuk tolok ukur, kami menetapkan ambang batas ke 90% untuk menyediakan buffer memori yang wajar untuk inferensi pada batch yang lebih besar atau menyisakan ruang untuk memuat model lain yang jarang digunakan.

Simulasikan lalu lintas pengguna

Setelah kami menentukan jumlah model, kami dapat menjalankan uji beban menggunakan Kerangka Pengujian Beban Locust. Uji beban mensimulasikan permintaan pengguna ke model acak dan secara otomatis mengukur metrik seperti latensi respons dan throughput.

Locust mendukung bentuk uji beban khusus yang memungkinkan Anda menentukan pola lalu lintas khusus. Bentuk yang digunakan dalam tolok ukur ini ditunjukkan pada bagan berikut. Dalam 30 detik pertama, titik akhir dihangatkan dengan 10 pengguna bersamaan. Setelah 30 detik, pengguna baru muncul dengan kecepatan dua per detik, mencapai 20 pengguna bersamaan pada tanda 40 detik. Titik akhir kemudian diukur secara stabil dengan 20 pengguna bersamaan hingga tanda 60 detik, di mana Locust kembali mulai meningkatkan pengguna dengan kecepatan dua kali per detik hingga 40 pengguna bersamaan. Pola peningkatan dan pengujian stabil ini diulang hingga titik akhir ditingkatkan hingga 200 pengguna secara bersamaan. Bergantung pada kasus penggunaan Anda, Anda mungkin ingin menyesuaikan bentuk uji beban di locust_benchmark_sm.py untuk mencerminkan pola lalu lintas yang diharapkan secara lebih akurat. Misalnya, jika Anda ingin menghosting model bahasa yang lebih besar, uji beban dengan 200 pengguna bersamaan mungkin tidak layak untuk model yang dihosting pada satu instans, dan oleh karena itu Anda mungkin ingin mengurangi jumlah pengguna atau menambah jumlah instans. Anda mungkin juga ingin memperpanjang durasi uji beban untuk mengukur stabilitas titik akhir dengan lebih akurat dalam jangka waktu yang lebih lama.

stages = [
{"duration": 30, "users": 10, "spawn_rate": 5},
{"duration": 60, "users": 20, "spawn_rate": 1},
{"duration": 90, "users": 40, "spawn_rate": 2},
…
]

Perhatikan bahwa kami hanya membandingkan titik akhir dengan model homogen yang semuanya berjalan pada basis penyajian yang konsisten menggunakan PyTorch atau TensorRT. Ini karena MME paling cocok untuk menghosting banyak model dengan karakteristik serupa, seperti konsumsi memori dan waktu respons. Template pembandingan yang disediakan di GitHub repo masih dapat digunakan untuk menentukan apakah melayani model heterogen pada MME akan menghasilkan performa dan stabilitas yang diinginkan.

Hasil benchmark untuk model CV

Gunakan notebook cv-benchmark.ipynb untuk menjalankan pengujian beban untuk model visi komputer. Anda dapat menyesuaikan nama model terlatih dan parameter jenis instans ke pengujian beban kinerja pada kombinasi model dan tipe instans yang berbeda. Kami sengaja menguji tiga model CV dalam rentang ukuran yang berbeda dari yang terkecil hingga yang terbesar: resnet50 (25 jt), convnext_base (88M), dan vit_large_patch16_224 (304M). Anda mungkin perlu menyesuaikan kode jika memilih model di luar daftar ini. selain itu, notebook menyetel bentuk gambar input ke tensor gambar 224x224x3 secara default. Ingatlah untuk menyesuaikan bentuk masukan yang sesuai jika Anda perlu membandingkan model yang mengambil gambar dengan ukuran berbeda.

Setelah menjalankan seluruh notebook, Anda akan mendapatkan beberapa visualisasi analisis kinerja. Dua yang pertama merinci kinerja model sehubungan dengan peningkatan pengguna secara bersamaan. Gambar berikut adalah contoh visualisasi yang dihasilkan untuk ResNet50 model berjalan di ml.g4dn.2xlarge, membandingkan PyTorch (kiri) vs. TensorRT (kanan). Grafik garis atas menunjukkan latensi model dan throughput pada sumbu y dengan meningkatnya jumlah pekerja klien bersamaan yang tercermin pada sumbu x. Bagan batang bawah menunjukkan jumlah permintaan yang berhasil dan gagal.

Melihat semua model visi komputer yang kami uji, kami menemukan hal berikut:

• Latensi (dalam milidetik) lebih tinggi, dan throughput (permintaan per detik) lebih rendah untuk model yang lebih besar (resnet50 > convnext_base > vit_large_patch16_224).
• Peningkatan latensi sebanding dengan jumlah pengguna karena lebih banyak permintaan yang diantrekan di server inferensi.
• Model besar mengonsumsi lebih banyak sumber daya komputasi dan dapat mencapai batas throughput maksimumnya dengan lebih sedikit pengguna daripada model yang lebih kecil. Hal ini diamati dengan vit_large_patch16_224 model, yang mencatat permintaan gagal pertama pada 140 pengguna bersamaan. Menjadi jauh lebih besar daripada dua model lain yang diuji, itu memiliki permintaan gagal paling banyak secara keseluruhan pada konkurensi yang lebih tinggi juga. Ini adalah sinyal yang jelas bahwa titik akhir perlu menskalakan lebih dari satu instans jika tujuannya adalah untuk mendukung lebih dari 140 pengguna secara bersamaan.

Di akhir proses notebook, Anda juga mendapatkan ringkasan perbandingan model PyTorch vs. TensorRT untuk masing-masing dari empat metrik utama. Dari pengujian benchmark kami, semua model CV melihat peningkatan performa model setelah kompilasi TensorRT. Mengambil kami ResNet50 model sebagai contoh lagi, latensi menurun sebesar 32% sementara throughput meningkat sebesar 18%. Meskipun jumlah maksimum pengguna bersamaan tetap sama ResNet50, dua model lainnya mengalami peningkatan sebesar 14% dalam jumlah pengguna bersamaan yang dapat mereka dukung. Peningkatan kinerja TensorRT, bagaimanapun, datang dengan mengorbankan penggunaan memori yang lebih tinggi, menghasilkan lebih sedikit model yang dimuat oleh MME. Dampaknya lebih untuk model yang menggunakan convolutional neural network (CNN). Faktanya, model ResNet50 kami menghabiskan kira-kira dua kali memori GPU dari PyTorch ke TensorRT, menghasilkan 50% lebih sedikit model yang dimuat (46 vs. 23). Kami mendiagnosa perilaku ini lebih lanjut di bagian berikut.

Hasil benchmark untuk model NLP

Untuk model NLP, gunakan notebook nlp-benchmark.ipynb untuk menjalankan uji beban. Penyiapan notebook akan terlihat sangat mirip. Kami menguji dua model NLP: bert-base-uncased (109M) dan roberta-large (335M). Model terlatih dan tokenizer keduanya diunduh dari hub Hugging Face, dan muatan uji dihasilkan dari tokenizer menggunakan string sampel. Panjang urutan maksimum ditetapkan secara default pada 128. Jika Anda perlu menguji string yang lebih panjang, ingatlah untuk menyesuaikan parameter tersebut. Menjalankan melalui notebook NLP menghasilkan rangkaian visualisasi yang sama: Pytorch (kiri) vs TensorRT (kanan).

Dari sini, kami mengamati lebih banyak manfaat kinerja TensorRT untuk model NLP. Mengambil roberta-large model pada instans ml.g4dn.2xlarge misalnya, latensi inferensi menurun drastis dari 180 milidetik menjadi 56 milidetik (peningkatan 70%), sedangkan throughput meningkat sebesar 406% dari 33 permintaan per detik menjadi 167. Selain itu, jumlah maksimum permintaan bersamaan pengguna meningkat sebesar 50%; permintaan yang gagal tidak diamati hingga kami mencapai 180 pengguna bersamaan, dibandingkan dengan 120 untuk model PyTorch asli. Dalam hal pemanfaatan memori, kami melihat satu model lebih sedikit dimuat untuk TensorRT (dari sembilan model menjadi delapan). Namun, dampak negatifnya jauh lebih kecil dibandingkan dengan apa yang kami amati dengan model berbasis CNN.

Analisis penggunaan memori

Tabel berikut menunjukkan analisis lengkap tentang dampak penggunaan memori dari PyTorch ke TensorRT. Kami telah menyebutkan sebelumnya bahwa model berbasis CNN terkena dampak yang lebih negatif. Itu ResNet50 model memiliki pengurangan lebih dari 50% dalam jumlah model yang dimuat di ketiga jenis instans GPU. Convnext_base memiliki pengurangan yang lebih besar sekitar 70% di seluruh papan. Di sisi lain, dampak pada model trafo kecil atau campuran. vit_large_patch16_224 dan roberta-large memiliki pengurangan rata-rata masing-masing sekitar 20% dan 3%. bert-base-uncased mengalami peningkatan sekitar 40%.

Melihat semua poin data secara keseluruhan sehubungan dengan performa superior dalam latensi, throughput, dan keandalan, serta dampak kecil pada jumlah maksimum model yang dimuat, kami merekomendasikan model TensorRT untuk arsitektur model berbasis transformer. Untuk CNN, kami yakin analisis kinerja biaya lebih lanjut diperlukan untuk memastikan manfaat kinerja melebihi biaya infrastruktur hosting tambahan.

Tabel berikut mencantumkan hasil tolok ukur lengkap kami untuk semua metrik di ketiga jenis instans GPU.

Tabel berikut meringkas hasil di semua jenis instans. Instans ml.g5.2xlarge memberikan kinerja terbaik, sedangkan instans ml.p3.2xlarge umumnya berperforma buruk meskipun merupakan yang paling mahal dari ketiganya. Instans g5 dan g4dn menunjukkan nilai terbaik untuk beban kerja inferensi.

Membersihkan

Setelah Anda menyelesaikan uji beban, bersihkan sumber daya yang dihasilkan untuk menghindari biaya tambahan. Sumber daya utamanya adalah titik akhir SageMaker dan file artefak model di Amazon S3. Untuk memudahkan Anda, file buku catatan memiliki kode pembersihan berikut untuk membantu Anda menghapusnya:

delete_endpoint(sm_client, sm_model_name, endpoint_config_name, endpoint_name) ! aws s3 rm --recursive {trt_mme_path}

Kesimpulan

Dalam postingan ini, kami membagikan hasil pengujian dan analisis kami untuk berbagai model jaringan neural dalam yang berjalan pada titik akhir multimodel SageMaker dengan GPU. Hasil dan wawasan yang kami bagikan harus memberikan penampang kinerja yang wajar di berbagai metrik dan jenis instans. Dalam prosesnya, kami juga memperkenalkan pendekatan yang kami rekomendasikan untuk menjalankan pengujian benchmark untuk MME SageMaker dengan GPU. Alat dan contoh kode yang kami berikan dapat membantu Anda mempercepat pengujian tolok ukur dan membuat keputusan yang lebih tepat tentang cara menghosting ratusan model DNN dengan biaya yang efektif pada perangkat keras komputasi yang dipercepat. Untuk memulai pembandingan model Anda sendiri dengan dukungan MME untuk GPU, lihat Algoritme, framework, dan instance yang didukung dan GitHub repo untuk contoh dan dokumentasi tambahan.

Tentang penulis

James Wu adalah Arsitek Solusi Spesialis AI/ML Senior di AWS. membantu pelanggan merancang dan membangun solusi AI/ML. Pekerjaan James mencakup berbagai kasus penggunaan ML, dengan minat utama pada visi komputer, pembelajaran mendalam, dan penskalaan ML di seluruh perusahaan. Sebelum bergabung dengan AWS, James adalah seorang arsitek, pengembang, dan pemimpin teknologi selama lebih dari 10 tahun, termasuk 6 tahun di bidang teknik dan 4 tahun di industri pemasaran & periklanan.

Vikram Elango adalah Arsitek Solusi Spesialis AI/ML di Amazon Web Services, yang berbasis di Virginia USA. Vikram membantu pelanggan industri keuangan dan asuransi dengan desain, kepemimpinan pemikiran untuk membangun dan menerapkan aplikasi pembelajaran mesin dalam skala besar. Dia saat ini fokus pada pemrosesan bahasa alami, AI yang bertanggung jawab, pengoptimalan inferensi, dan penskalaan ML di seluruh perusahaan. Di waktu luangnya, ia menikmati perjalanan, hiking, memasak dan berkemah bersama keluarganya.

Simon Zamarin adalah Arsitek Solusi AI / ML yang fokus utamanya membantu pelanggan mengekstrak nilai dari aset data mereka. Di waktu luangnya, Simon menikmati menghabiskan waktu bersama keluarga, membaca fiksi ilmiah, dan mengerjakan berbagai proyek rumah DIY.

Saurabh Trikande adalah Manajer Produk Senior untuk Inferensi Amazon SageMaker. Dia bersemangat bekerja dengan pelanggan dan termotivasi oleh tujuan mendemokratisasi pembelajaran mesin. Dia berfokus pada tantangan inti yang terkait dengan penerapan aplikasi ML yang kompleks, model ML multi-penyewa, pengoptimalan biaya, dan membuat penerapan model pembelajaran mendalam lebih mudah diakses. Di waktu luangnya, Saurabh menikmati hiking, belajar tentang teknologi inovatif, mengikuti TechCrunch, dan menghabiskan waktu bersama keluarganya.

• Konten Bertenaga SEO & Distribusi PR. Dapatkan Amplifikasi Hari Ini.
• Platoblockchain. Intelijen Metaverse Web3. Pengetahuan Diperkuat. Akses Di Sini.
• Sumber: https://aws.amazon.com/blogs/machine-learning/achieve-high-performance-at-scale-for-model-serving-using-amazon-sagemaker-multi-model-endpoints-with-gpu/