swiftLLM

SwiftLLM

Proyek ini masih dalam pengembangan. Beberapa fitur mungkin belum diterapkan, dan dokumentasinya mungkin tidak lengkap.

Sistem inferensi LLM kecil namun kuat yang dirancang untuk tujuan penelitian.

Performa setara vLLM dengan hanya 2 ribu baris kode (2% dari vLLM).

Mengapa SwiftLLM

Ada begitu banyak kerangka kerja sumber terbuka untuk penyajian LLM, termasuk HuggingFace Transformers, vLLM, LightLLM, DistServe, dan DeepSpeed-MII. Mengapa SwiftLLM?

Alasannya adalah, kerangka kerja tersebut dirancang untuk produksi , bukan untuk penelitian . Mereka dilengkapi dengan berbagai fitur, seperti dukungan 100+ model, berbagai dukungan hardward, LoRA, kuantisasi, multimodal, cache awalan, pencarian berkas, dan sebagainya. Meskipun merupakan solusi lengkap untuk produksi, basis kodenya terlalu besar dan rumit untuk dipahami dan dimodifikasi (misalnya, vLLM memiliki lebih dari 100 ribu baris kode), sehingga sulit menggunakannya untuk tujuan penelitian. Selain itu, beban sejarah mereka juga menjadi masalah.

SwiftLLM dirancang untuk menjadi sistem inferensi LLM kecil namun kuat yang dirancang untuk tujuan penelitian . "Tiny" berarti hanya menyimpan fitur-fitur yang penting untuk penelitian, "powerful" berarti tidak ada kompromi dalam performa, dan terakhir "swift" berarti mudah untuk dipahami dan dimodifikasi. Meskipun mendukung fitur-fitur dasar (lihat daftar di bawah) dan mampu mencapai kinerja yang setara dengan vLLM, basis kode SwiftLLM kurang dari 2 ribu baris kode (~2% dari vLLM), ditulis dengan Python dan OpenAI Triton (DSL untuk menulis Kernel CUDA), sehingga mudah dibaca, dimodifikasi, di-debug, diuji, diperluas, dan dapat dengan mudah diintegrasikan dengan ide penelitian baru dan brilian Anda.

Daftar Fitur

Saat ini, SwiftLLM mendukung fitur-fitur berikut:

• Penjadwalan Iterasi dan Batching Selektif (diusulkan di Orca)
• PagedAttenton (diusulkan dalam vLLM, kertas)
• Model LLaMA / LLaMA2 / LLaMA3 (tautan) dan variannya
• Membonceng prefill dan decoding (diusulkan di SARATHI)
• Perhatian kilat (diusulkan dalam FlashAttention dan FlashAttention-2)
• Perhatian halaman v2 (juga disebut Flash-Decoding, diusulkan di sini)

Dan kami berencana menambahkan dukungan untuk fitur berikut di masa mendatang:

• Paralelisme tensor dan paralelisme pipa

Untuk menjaga basis kode tetap kecil, kami tidak akan mendukung fitur berikut. Jika Anda ingin menggunakannya dalam proyek penelitian Anda, Anda mungkin perlu menerapkannya sendiri:

• Kuantisasi
• LoRA
• Multimoda
• Model yang tidak mengikuti arsitektur LLaMA
• Metode pengambilan sampel selain dari pengambilan sampel serakah
• Perangkat keras mendukung selain GPU NVIDIA (tetapi akan mudah untuk bermigrasi ke perangkat keras lain selama OpenAI Triton mendukungnya)

Ingatlah bahwa SwiftLLM BUKAN merupakan solusi lengkap untuk produksi. Disarankan untuk menganggapnya sebagai "fondasi" untuk proyek penelitian Anda, dan Anda mungkin perlu menerapkan beberapa fitur sendiri. Kami mendorong Anda, peneliti yang terhormat, untuk membaca kode, memahaminya, memodifikasinya, dan mengembangkannya agar sesuai dengan kebutuhan penelitian Anda.

Arsitektur

Arsitektur SwiftLLM dapat dibagi menjadi dua bagian besar: bidang kendali dan bidang data .

Secara singkat, bidang kendali memutuskan "apa yang dihitung" atau "bagaimana menjadwalkannya", sedangkan bidang data memutuskan "bagaimana menghitung" atau "bagaimana menerapkan" dan melakukan penghitungan konkrit. Mereka bekerja dengan cara master-worker: bidang kontrol bertindak seperti master, yang melakukan penjadwalan dan koordinasi tingkat tinggi dan mengirimkan pekerjaan ke bidang data, yang bertindak seperti pekerja, yang melakukan komputasi tingkat rendah.

Kode untuk bidang kendali berada di direktori swiftllm/server , termasuk komponen seperti Engine , Scheduler , server API, dan TokenizationEngine . Kode untuk bidang data berada di direktori swiftllm/worker , termasuk deskripsi grafik komputasi (dalam swiftllm/worker/model.py ), implementasi lapisan dalam model (dalam swiftllm/layers ), dan kernel OpenAI Triton ( Anda dapat membayangkan "kernel" sebagai fungsi yang dijalankan pada GPU) (dalam swiftllm/kernels ).

Mari kita ambil server API mainan (terletak di swiftllm/server/api_server.py ) sebagai contoh:

• Saat diluncurkan, ia menggunakan EngineConfig untuk membuat Engine .
• Setelah itu, mesin diinisialisasi melalui Engine.initialize , yang kemudian membuat Scheduler , TokenizationEngine , dan sekumpulan pekerja (saat ini hanya satu karena Tensor Parallelism tidak didukung). Kemudian ia memerintahkan pekerja untuk mengeksekusi profile_num_blocks untuk menghitung jumlah blok GPU, setelah itu mesin memerintahkan semua pekerja untuk mengalokasikan cache KV dan pertukaran KV mereka.
• Terakhir, event loop diaktifkan melalui Engine.start_all_event_loops . Dalam setiap langkah perulangan, mesin menanyakan penjadwal untuk kumpulan permintaan berikutnya yang akan dihitung, memerintahkan pekerja untuk melakukan pertukaran masuk/keluar, lalu mengirimkan kumpulan tersebut ke pekerja untuk dihitung.
• Server API mendengarkan permintaan pengguna dan berinteraksi dengan mesin untuk memenuhinya.

Saat ini bidang kontrol ( Engine ) dan bidang data ( LlamaModel ) berada di node yang sama. Setelah Paralelisme Tensor / Paralelisme Pipa diimplementasikan, bidang data dapat didistribusikan ke beberapa node.

Cara Menggunakan

Kami menawarkan dua cara untuk menggunakan SwiftLLM: menggunakan bidang kontrol dan bidang data, atau hanya menggunakan bidang data.

Jika ide Anda cukup sederhana atau elegan sehingga dapat diintegrasikan dengan mulus ke dalam bidang kendali yang ada, Anda dapat menggunakan bidang kendali dan bidang data. Dalam kasus lain, ketika Anda ingin menerapkan ide bagus, Anda hanya dapat memanfaatkan bidang data, dan menerapkan sendiri bidang kendali baru.

Bangun dan Jalankan

Pertama mari kita siapkan lingkungannya:

• Anda dapat memulai dari lingkungan conda yang bersih dengan Python >= 3.9, atau menggunakan yang sudah ada. Jangan lupa untuk mengaktifkan lingkungan conda jika Anda menggunakannya.
• Instal PyTorch. Perhatikan untuk memilih versi yang benar berdasarkan perangkat keras Anda.
• Instal packaging melalui pip install packaging

Dan kemudian muncul instalasi:

• Kloning repo ini melalui git clone https://github.com/interestingLSY/swiftLLM.git
• cd ke dalam repo ( cd swiftLLM ) dan instal dependensi lain melalui pip install -r requirements.txt .
• PyTorch mungkin menginstal OpenAI Triton versi stabil untuk Anda. Jika Anda ingin menggunakan versi nightly untuk kinerja mutakhir tetapi dengan potensi masalah, Anda dapat menghapus instalannya dan menginstal versi nightly.
• Jalankan pip install -e . untuk menginstal SwiftLLM ke lingkungan Anda.
• Instal beberapa C-binding melalui pip install -e csrc

Berikut beberapa contohnya:

• Saat ini SwiftLLM tidak mendukung pengunduhan bobot dari HuggingFace secara otomatis. Anda mungkin perlu mengkloning atau mendownload bobot model dari HuggingFace terlebih dahulu. Format .bin dan format .safetensors didukung. Asumsikan bobot model Anda disimpan di /data/to/weight/ .
• Untuk contoh penyajian offline, Anda dapat mencoba python3 examples/offline.py --model-path /data/to/weight . Contoh ini hanya menggunakan bidang data. Jika Anda berencana menggunakan SwiftLLM tanpa bidang kendali, ini adalah titik awal yang baik.
• Untuk contoh penyajian online yang menggunakan Engine , Anda dapat mencoba python3 examples/online.py --model-path /data/to/weight . Ini adalah contoh yang bagus jika Anda berencana menggunakan bidang kendali dan bidang data.
• Untuk contoh yang lebih kompleks, Anda dapat merujuk ke swiftllm/server/api_server.py . Ini meluncurkan server API dan menyediakan antarmuka seperti vLLM untuk penyajian online.

Pertunjukan

Meskipun kecil (yang kecil juga menggemaskan!), SwiftLLM tidak berkompromi dalam hal kinerja. Kami telah mengevaluasi SwiftLLM pada beberapa skenario, dan menunjukkan bahwa SwiftLLM dapat mencapai kinerja yang setara, atau bahkan lebih baik, dibandingkan dengan vLLM.

Operasi Maju Tunggal

Skenario pertama adalah "operasi penerusan tunggal", di mana kita memberi model dengan sekumpulan masukan dan membiarkannya menghasilkan satu token keluaran (setara dengan satu operasi "penerusan"). Ini adalah operasi dasar inferensi LLM (baik online maupun offline) sehingga kinerjanya sangat penting.

Di sini kami menggunakan model LLaMA-3 7B dengan GPU NVIDIA A100 80G PCIE / RTX 4090 dengan presisi FP16. Hasilnya ditunjukkan di bawah ini (lebih rendah lebih baik):

Dapat dilihat bahwa SwiftLLM dapat mencapai kinerja yang setara (atau bahkan mengungguli) vLLM dalam pengaturan yang sama.

Pelayanan Daring

Skenario kedua adalah "pelayanan online", di mana kita memulai server API, mengambil contoh perintah dari kumpulan data dunia nyata, dan membiarkan model menghasilkan penyelesaian. Ini adalah skenario dimana LLM digunakan dalam aplikasi dunia nyata seperti chatbots atau penyelesaian kode.

Di sini kami menggunakan kumpulan data ShareGPT untuk mengambil sampel perintah, dan menggunakan proses poisson dengan lambda berbeda untuk mensimulasikan tingkat kedatangan permintaan yang berbeda. Hasilnya ditunjukkan di bawah ini (lebih rendah lebih baik):

Terlihat bahwa pada A100 80G PCIE, SwiftLLM dapat mencapai performa yang setara dengan vLLM, sedangkan pada RTX 4090, SwiftLLM mengungguli vLLM secara signifikan (terutama karena bidang kontrol kami memiliki overhead yang lebih rendah).