Masa Depan Inferensi Serverless untuk Model Bahasa Besar

Kemajuan baru-baru ini dalam model bahasa besar (LLM) seperti GPT-4, PaLM telah mengarah pada kemampuan transformasional dalam tugas bahasa alami. LLM sedang diintegrasikan ke dalam berbagai aplikasi seperti chatbot, mesin pencari, dan asisten pemrograman. Namun, menyajikan LLM secara besar-besaran tetap menantang karena persyaratan GPU dan memori yang besar.

Pendekatan untuk mengatasi ini umumnya jatuh ke dalam dua kategori utama:

1. Teknik Kompresi Model

Teknik-teknik ini bertujuan untuk mengurangi ukuran model sambil mempertahankan akurasi. Pendekatan umum termasuk:

• Pengurangan – Menghapus parameter yang redundan atau kurang penting dari model. Ini menciptakan model yang rapat dengan parameter yang lebih sedikit.
• Kuantisasi – Menggunakan angka presisi yang lebih rendah seperti int8 atau bfloat16 untuk mewakili bobot bukan fp32 atau fp16. Ini mengurangi jejak memori.
• Penyulingan Pengetahuan – Melatih model “siswa” yang lebih kecil untuk meniru model “guru” yang besar. Model yang lebih kecil kemudian digunakan untuk inferensi.

2. Eksekusi Selektif

Bukannya model yang dikompresi, teknik-teknik ini secara selektif menjalankan hanya bagian-bagian tertentu dari model per inferensi:

• Aktivasi yang rapat – Menghilangkan komputasi pada aktivasi nol.
• Perhitungan Bersyarat – Menjalankan hanya lapisan tertentu yang diberi kondisi pada input.

Di sisi komplementer terkait dengan arsitektur perangkat lunak; untuk memungkinkan penerapan LLM yang lebih cepat, peneliti telah mengusulkan sistem inferensi serverless. Dalam arsitektur serverless, LLM dihosting pada klaster GPU yang dibagikan dan dialokasikan secara dinamis berdasarkan permintaan. Ini memungkinkan utilitas GPU yang efisien dan mengurangi biaya untuk pengembang. Implementasi yang menonjol termasuk Amazon (AMZN ) SageMaker, Microsoft Azure ML, dan opsi sumber terbuka seperti KServe.

Meskipun janji sistem LLM serverless, sistem yang ada menunjukkan overhead latensi yang tinggi yang merusak pengalaman pengguna dalam aplikasi interaktif:

1. Unduhan checkpoint yang mahal: LLM memiliki jejak memori yang besar, seringkali berukuran gigabyte hingga terabyte. Mengunduh checkpoint dari penyimpanan jarak jauh memakan waktu, bahkan dengan jaringan yang dioptimalkan.
2. Penggunaan checkpoint yang tidak efisien: Bahkan dengan penyimpanan SSD lokal, memuat checkpoint ke memori GPU memakan waktu puluhan detik karena faktor-faktor seperti deserialisasi tensor dan alokasi. Ini menambahkan penundaan yang signifikan di luar waktu startup wadah.

Untuk mengatasi masalah ini, peneliti di MIT CSAIL mengusulkan ServerlessLLM, sebuah sistem inovatif yang mencapai inferensi serverless dengan latensi rendah untuk LLM. ServerlessLLM meningkatkan lokalitas dengan mengeksploitasi kapasitas dan bandwidth yang melimpah namun kurang dimanfaatkan dalam penyimpanan server multi-tiers untuk penerapan LLM.

Gambaran sistem inferensi serverless LLM

Inovasi Kunci di ServerlessLLM ServerlessLLM menggabungkan beberapa desain baru untuk mengurangi waktu muat LLM di lingkungan serverless:

1. Penggunaan checkpoint yang dipercepat

• Format checkpoint yang dioptimalkan untuk memuat yang memungkinkan pembacaan berurutan yang cepat dan alamat tensor yang efisien di memori.
• Pipa muat checkpoint multi-tiers yang memaksimalkan utilitas bandwidth di seluruh jaringan, SSD, DRAM, dan memori GPU melalui teknik seperti I/O langsung, transfer memori yang dipasang, dan paralelisme.

2. Migrasi langsung untuk inferensi yang dipandu lokalitas

• Migrasi berbasis token yang hanya mengirim token prompt esensial melalui jaringan, menghindari transfer snapshot yang lambat.
• Migrasi dua fase yang memungkinkan inferensi tanpa gangguan dengan menghitung ulang status cache secara asinkron sebelum mengirim token akhir.

3. Alokasi server yang dioptimalkan untuk latensi

• Model yang akurat untuk memperkirakan waktu muat checkpoint dari setiap tingkat dan waktu migrasi untuk server.
• Penjadwal yang sadar lokalitas yang memilih server yang meminimalkan latensi startup yang diharapkan menggunakan model di atas.

Optimasi ini memungkinkan ServerlessLLM untuk mengurangi waktu muat LLM hingga 4-8X dan waktu startup akhir hingga lebih dari 25X dibandingkan dengan sistem yang ada seperti PyTorch, TensorFlow, dan KServe.

Mari kita lihat lebih dalam bagaimana ServerlessLLM mencapai peningkatan kinerja yang signifikan.

Mengakselerasi Penggunaan Checkpoint

Hambatan utama pertama yang diatasi oleh ServerlessLLM adalah latensi yang tinggi dari memuat checkpoint LLM dari penyimpanan ke memori GPU.

Untuk memungkinkan penggunaan checkpoint yang cepat, ServerlessLLM memperkenalkan:

1. Format checkpoint yang dioptimalkan untuk memuat

Checkpoint standar yang digunakan oleh kerangka seperti PyTorch dirancang untuk pelatihan model dan debugging. Namun, untuk inferensi serverless, checkpoint hanya dibaca dan diakses berulang kali.

Untuk mengoptimalkan penggunaan intensif baca seperti itu, ServerlessLLM mengubah checkpoint menjadi format dengan dua properti kunci:

• Pembacaan chunk berurutan: Tensor dikelompokkan ke dalam file biner per-GPU, memfasilitasi pembacaan berurutan yang besar.
• Pengalamatan tensor yang efisien: Indeks memetakan nama tensor ke offset memori, memungkinkan pemulihan langsung di memori tanpa deserialisasi.

2. Pipa muat checkpoint multi-tiers

ServerlessLLM memanfaatkan arsitektur tiered dari server GPU, dengan media penyimpanan seperti SSD dan jaringan yang menghubungkan ke GPU melalui PCIe, NVMe, dll.

Sistem ini menggabungkan pipa multi-tahap untuk memaksimalkan utilitas bandwidth di seluruh semua tingkat:

• Chunk data di memori dialokasikan menggunakan memori yang dipasang untuk transfer GPU yang cepat.
• I/O langsung digunakan untuk membaca SSD yang efisien tanpa overhead caching.
• Beberapa thread membaca chunk penyimpanan yang berbeda secara paralel.
• Koordinasi antar-tahap terjadi melalui antrian tugas asinkron.

Bersama, ini memungkinkan memuaskan kapasitas bandwidth bahkan dari tingkat tercepat seperti NVMe RAID. Eksperimen menunjukkan bahwa ServerlessLLM mencapai muat yang 6-8X lebih cepat daripada PyTorch/TensorFlow, mengurangi waktu startup untuk LLM besar dari lebih dari satu menit menjadi kurang dari 10 detik.

Inferensi LLM yang Dipandu Lokalitas melalui Migrasi Langsung

Dengan muat yang dipercepat, ServerlessLLM menghadapi tantangan baru – bagaimana memanfaatkan checkpoint yang telah dimuat untuk lokalitas tanpa mengganggu inferensi yang sedang berlangsung di server sibuk?

ServerlessLLM memperkenalkan teknik baru – migrasi langsung inferensi LLM di seluruh server GPU. Ini memungkinkan transfer eksekusi yang mulus ke server dengan checkpoint lokal yang tersedia.

Pengaktif utama migrasi LLM langsung:

1. Migrasi berbasis token

Bukannya menyimpan seluruh keadaan model, ServerlessLLM hanya bermigrasi token prompt minimal melalui jaringan. Ini mengirimkan pesanan yang jauh lebih sedikit daripada snapshot.

2. Migrasi dua fase

Server tujuan secara asinkron menghitung ulang keadaan cache dari token prompt. Setelah siap, server sumber mengirim token akhir sebelum melepaskan sumber daya. Ini mencegah gangguan inferensi.

Eksperimen menunjukkan bahwa migrasi berbasis token mengurangi waktu migrasi dari puluhan detik menjadi kurang dari satu detik bahkan untuk urutan panjang. Migrasi langsung sangat penting untuk mencegah keterlambatan antrian saat mencapai alokasi yang dipandu lokalitas.

Penjadwalan Model yang Dioptimalkan untuk Latensi

Untuk meminimalkan latensi akhir-ke-akhir, ServerlessLLM meningkatkan penjadwal untuk mengoptimalkan pemilihan server dengan mempertimbangkan lokalitas. Ini melibatkan:

1. Perkiraan waktu muat yang halus

Model memprediksi waktu muat dari jaringan, cache SSD, dan memori untuk setiap server menggunakan metrik seperti keterlambatan antrian, ukuran model, dan bandwidth yang diukur.

2. Prediktor waktu migrasi yang akurat

Penjadwal memperkirakan waktu migrasi untuk server menggunakan jumlah token prompt dan output. Ini melacak kemajuan inferensi secara asinkron untuk menghindari overhead.

3. Alokasi yang sadar lokalitas

Untuk setiap permintaan inferensi, penjadwal mengevaluasi waktu muat dan migrasi yang diharapkan di seluruh server. Ini memilih server yang meminimalkan latensi startup yang diharapkan.

Penjadwal juga memelihara antrian tugas server dan memanfaatkan toko yang konsisten untuk ketahanan kesalahan. Bersama, inovasi ini mengurangi overhead penjadwalan sambil memaksimalkan manfaat lokalitas.

Mengevaluasi Kinerja ServerlessLLM

Eksperimen komprehensif membandingkan efektivitas akhir-ke-akhir dari ServerlessLLM terhadap sistem yang ada menggunakan model dunia nyata seperti OPT-175B dan beban kerja yang dimodelkan setelah jejak Azure.

Hasil kunci:

• Mikrobenchmark: ServerlessLLM mempercepat muat checkpoint 3,6-8,2X lebih cepat daripada PyTorch/TensorFlow. Ini sepenuhnya memuaskan bandwidth penyimpanan, bahkan untuk NVMe RAID yang canggih.
• Penjadwalan: ServerlessLLM mengurangi latensi alokasi 4-12X dibandingkan dengan penjadwalan acak, menyoroti manfaat kesadaran lokalitas. Migrasi langsung mencegah keterlambatan antrian.
• Pelayanan akhir-ke-akhir: Untuk model besar seperti OPT-30B, ServerlessLLM memperbaiki latensi persentil ke-99 hingga 28-200X lebih baik daripada sistem seperti KServe dan Ray Serve. Ini juga meningkatkan efisiensi sumber daya.

Pengurangan yang signifikan ini menunjukkan kemampuan ServerlessLLM untuk mengatasi hambatan dalam implementasi serverless yang ada dan membuka kunci kekuatan LLM untuk layanan interaktif.

Optimasi yang diperkenalkan dalam ServerlessLLM, seperti muat multi-tiers, migrasi langsung, dan penjadwalan yang dipandu latensi, dapat membantu memandu desain arsitektur serverless di masa depan. Kemampuan sistem untuk mengurangi waktu muat dan startup memungkinkan penerapan LLM yang besar-besaran untuk aplikasi praktis.

Menghadap ke Depan: Tantangan yang Sedang Berlangsung

Meskipun lompatan signifikan, ServerlessLLM hanya mewakili langkah pertama dalam mengoptimalkan inferensi serverless untuk LLM besar. Beberapa masalah terbuka masih ada, termasuk:

• Memprediksi permintaan model waktu nyata untuk memandu penyediaan dan pemuatan sebelumnya
• Menempatkan checkpoint secara cerdas di seluruh server untuk memaksimalkan cache hits
• Menskalakan algoritma penjadwalan secara efisien untuk menangani klaster yang lebih besar
• Memastikan keadilan dalam alokasi sumber daya di seluruh model dan pengembang
• Menggeneralisasi inovasi seperti migrasi langsung ke beban kerja serverless lainnya

Mengatasi area ini dapat membantu membangun pada janji LLM serverless dan membuat kemampuan mereka lebih dapat diakses. Di luar optimasi sistem, mengurangi jejak karbon yang mencolok dan potensi bahaya dari model besar juga tetap menjadi prioritas yang mendesak.

ServerlessLLM menunjukkan bahwa ruang yang sangat besar ada untuk inovasi dalam arsitektur serverless generasi berikutnya untuk beban kerja AI. Ketika LLM terus tumbuh dalam ukuran dan popularitas, solusi seperti ServerlessLLM yang membuka skalabilitas mereka akan tumbuh semakin berdampak. Konvergensi penelitian sistem dan mesin pembelajaran dapat memperkenalkan paradigma baru dalam menyajikan, berbagi, dan menskalakan model AI dengan aman dan berkelanjutan.