Masa Depan Inference Serverless untuk Model Bahasa Besar

Kemajuan baru-baru ini dalam model bahasa besar (LLM) seperti GPT-4, PaLM telah menghasilkan 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 substansial.

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:

• Pengguntingan – Menghapus parameter yang redundan atau kurang penting dari model. Ini menciptakan model yang jarang 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 “murid” yang lebih kecil untuk meniru model “guru” yang besar. Model yang lebih kecil kemudian digunakan untuk inferensi.

2. Eksekusi Selektif

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

• Aktivasi yang jarang – Menghindari komputasi pada aktivasi nol.
• Perhitungan Bersyarat – Menjalankan hanya lapisan tertentu yang dikondisikan pada input.

Di sisi komplementer untuk 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 utiliasi GPU yang efisien dan mengurangi biaya untuk pengembang. Implementasi yang menonjol termasuk Amazon SageMaker, Microsoft Azure ML, dan opsi sumber terbuka seperti KServe.

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

1. Unduhan checkpoint yang mahal: LLM memiliki jejak memori yang besar, sering kali berukuran gigabyte hingga terabyte. Mengunduh checkpoint dari penyimpanan jarak jauh memakan waktu, memakan waktu lebih dari 20 detik bahkan dengan jaringan yang dioptimalkan.
2. Pengisian 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 latency yang rendah untuk LLM. ServerlessLLM meningkatkan lokalisasi dengan memanfaatkan kapasitas dan bandwidth yang melimpah namun tidak termanfaatkan di penyimpanan server multi-tiers untuk penerapan LLM.

Gambaran sistem inferensi serverless LLM

Inovasi Kunci di ServerlessLLM ServerlessLLM mengintegrasikan beberapa desain baru untuk mengurangi waktu pemuatan LLM di lingkungan serverless:

1. Pengisian checkpoint yang cepat

• Format checkpoint yang dioptimalkan untuk pemuatan yang memungkinkan pembacaan berurutan yang cepat dan pengalamatan tensor yang efisien di memori.
• Pipa pemuatan checkpoint multi-tiers yang memaksimalkan utiliasi 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 lokalisasi

• 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 di server tujuan sebelum mengirim token akhir.

3. Alokasi server yang dioptimalkan untuk latency

• Model yang akurat untuk memperkirakan waktu pemuatan checkpoint dari setiap tier dan waktu migrasi untuk server.
• Penjadwal yang sadar lokalisasi yang memilih server yang meminimalkan latency startup yang diharapkan menggunakan model di atas.

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

Menggunakan Pengisian Checkpoint

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

Untuk memungkinkan pemuatan checkpoint yang cepat, ServerlessLLM memperkenalkan:

1. Format checkpoint yang dioptimalkan untuk pemuatan

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 seperti ini, ServerlessLLM mengubah checkpoint menjadi format dengan dua sifat 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 pemuatan 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 mengintegrasikan pipa multi-tahap untuk memaksimalkan utiliasi bandwidth di seluruh tier:

• 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 untuk menjenuhkan kapasitas bandwidth bahkan dari tier tercepat seperti NVMe RAID. Eksperimen menunjukkan bahwa ServerlessLLM mencapai pemuatan 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 Lokalisasi melalui Migrasi Langsung

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

ServerlessLLM memperkenalkan teknik novel – migrasi langsung inferensi LLM di seluruh server GPU. Ini memungkinkan untuk mentransfer eksekusi ke server dengan checkpoint lokal yang tersedia.

Pengaktif utama migrasi LLM langsung:

1. Migrasi berbasis token

Bukannya menyimpan snapshot seluruh keadaan model, ServerlessLLM hanya bermigrasi token prompt minimal melalui jaringan. Ini mentransfer jumlah data yang jauh lebih kecil daripada snapshot.

2. Migrasi dua fase

Server tujuan menghitung ulang status cache dari token prompt secara asinkron. Setelah siap, server sumber mentransfer 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 penundaan antrian saat mencapai alokasi yang dipandu lokalisasi.

Penjadwalan Model yang Dioptimalkan untuk Latency

Untuk meminimalkan latency akhir-ke-akhir, ServerlessLLM memperkuat penjadwal untuk mengoptimalkan pemilihan server dengan mempertimbangkan lokalisasi. Ini melibatkan:

1. Perkiraan waktu pemuatan yang halus

Model memperkirakan waktu pemuatan dari jaringan, cache SSD, dan memori untuk setiap server menggunakan metrik seperti penundaan 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 lokalisasi

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

Penjadwal juga mempertahankan antrian tugas server dan memanfaatkan toko yang konsisten untuk toleransi kesalahan. Bersama, inovasi ini mengurangi overhead penjadwalan sambil memaksimalkan manfaat lokalisasi.

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 pemuatan checkpoint sebesar 3,6-8,2X daripada PyTorch/TensorFlow. Ini sepenuhnya menjenuhkan bandwidth penyimpanan, bahkan untuk NVMe RAID yang canggih.
• Penjadwalan: ServerlessLLM mengurangi latency alokasi sebesar 4-12X dibandingkan dengan penjadwalan acak, menyoroti manfaat kesadaran lokalisasi. Migrasi langsung mencegah penundaan antrian.
• Pelayanan akhir-ke-akhir: Untuk model besar seperti OPT-30B, ServerlessLLM memperbaiki latency 99 persen sebesar 28-200X dibandingkan dengan 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 kekuatan LLM untuk layanan interaktif.

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

Menghadap Masa Depan: Tantangan yang Berlanjut

Meskipun merupakan lompatan besar, ServerlessLLM hanya merupakan 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 hit
• Mengskalakan algoritma penjadwalan dengan efisien untuk menangani cluster yang lebih besar
• Memastikan kesetaraan dalam alokasi sumber daya di seluruh model dan pengembang
• Menggeneralisasi inovasi seperti migrasi langsung ke beban kerja serverless lain

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 besar dan potensi bahaya dari model besar juga tetap menjadi prioritas yang mendesak.

ServerlessLLM menunjukkan bahwa ruang besar untuk inovasi ada di arsitektur serverless generasi berikutnya untuk beban kerja AI. Ketika LLM terus membengkak 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.