Microsoft meluncurkan kerangka BitNet.cpp pada 17 Oktober 2024, sebuah kerangka inferensi yang dirancang untuk menjalankan Large Language Models (LLMs) 1-bit terkuantisasi. BitNet.cpp merupakan kemajuan signifikan dalam Gen AI, memungkinkan penyebaran LLMs 1-bit secara efisien pada CPU standar, tanpa memerlukan GPU mahal. Pengembangan ini memdemokratisasi akses ke LLMs, membuatnya tersedia pada berbagai perangkat dan memberikan kemungkinan baru dalam aplikasi AI di perangkat lokal.

Memahami Large Language Models 1-bit
LLMs secara tradisional memerlukan sumber daya komputasi yang signifikan karena penggunaan angka floating-point dengan presisi tinggi (biasanya FP16 atau BF16) untuk bobot model. Kebutuhan ini membuat penyebaran LLMs menjadi mahal dan menghabiskan energi.

Pada intinya, LLMs 1-bit menggunakan teknik kuantisasi ekstrim untuk merepresentasikan bobot model menggunakan hanya tiga nilai: -1, 0, dan 1, sehingga istilah "1.58-bit" (karena memerlukan sedikit lebih dari satu bit untuk mengkodekan tiga keadaan).

Sistem Bobot Ternary
Konsep
Kuantisasi 1-bit dalam BitNet.cpp adalah sistem bobot ternary. BitNet beroperasi dengan hanya tiga nilai yang mungkin untuk setiap parameter:
-1 (negatif)
0 (netral)
1 (positif)

Hal ini menghasilkan kebutuhan penyimpanan sekitar 1,58 bit per parameter, sehingga namanya BitNet b1.58. Reduksi drastis dalam lebar bit parameter ini mengarah pada pengurangan yang mengesankan dalam penggunaan memori dan kompleksitas komputasi, karena sebagian besar perkalian floating-point digantikan dengan penjumlahan dan pengurangan sederhana.

Dasar Matematika
Kuantisasi 1-bit melibatkan mentransformasikan bobot dan aktivasi ke representasi ternary mereka melalui langkah-langkah berikut:

1. Binarisasi Bobot
   Binarisasi bobot melibatkan sentralisasi mereka di sekitar rata-rata (α), menghasilkan representasi ternary. Transformasi ini diungkapkan secara matematis sebagai berikut:

   W = Sign(W – α)

   Dimana:
   W adalah matriks bobot asli.
   α adalah rata-rata bobot.
   Sign(x) mengembalikan +1 jika x > 0 dan -1 sebaliknya.

2. Kuantisasi Aktivasi
   Kuantisasi aktivasi memastikan bahwa input dibatasi ke lebar bit yang ditentukan:

   x^e = Quant(x) = Clip(γxQb, -Qb+ϵ, Qb-ϵ)

   Dimana:
   Qb = 2^(b-1) adalah level kuantisasi maksimum untuk lebar bit b.
   γ adalah nilai mutlak maksimum dari x.
   ε adalah angka kecil untuk mencegah overflow selama perhitungan.

3. Operasi BitLinear
   Lapisan BitLinear menggantikan perkalian matriks tradisional dengan operasi yang disederhanakan:

   y = Wf^ex^e

   Dimana:
   β adalah faktor penskalaan yang digunakan untuk meminimalkan kesalahan aproksimasi.
   γ menskalakan aktivasi.
   Q_b adalah faktor kuantisasi.

   Transformasi ini memungkinkan komputasi yang efisien sambil mempertahankan kinerja model.

   Dampak Kinerja
   Efisiensi Memori
   Sistem bobot ternary secara signifikan mengurangi persyaratan memori:

   • LLMs tradisional: 16 bit per bobot
   • BitNet.cpp: 1,58 bit per bobot

     Pengurangan ini berarti penghematan memori sekitar 90% dibandingkan dengan model 16-bit tradisional, memungkinkan model yang lebih besar untuk muat dalam batasan perangkat keras yang sama.

     Kecepatan Inferensi: Lebih Cepat pada Kedua CPU
     Kecepatan inferensi diwakili sebagai jumlah token yang diproses per detik. Berikut adalah pembagian pengamatan:

   • Pada Apple M2 Ultra: BitNet.cpp mencapai hingga 5,07x percepatan untuk model yang lebih besar (30B) dibandingkan dengan Llama.cpp, dengan kecepatan puncak 593,43 token per detik untuk model 125M, yang merupakan 1,37x percepatan. Untuk model yang lebih besar seperti 3,8B dan 7B, BitNet.cpp mempertahankan kecepatan di atas 84,77 token per detik, menunjukkan efisiensinya di berbagai skala.
   • Pada Intel i7-13700H: BitNet.cpp mencapai peningkatan kecepatan yang lebih dramatis. Pada ukuran model 7B, BitNet.cpp memberikan percepatan 5,68x dibandingkan dengan Llama.cpp. Untuk model yang lebih kecil seperti 125M, ia memproses 389,08 token per detik, yang 2,37x lebih cepat dari Llama.cpp.

     Efisiensi Energi: Perubahan Game-Changer untuk Perangkat Edge
     Grafik yang disediakan juga termasuk perbandingan biaya energi, yang menunjukkan pengurangan yang signifikan dalam konsumsi energi per token yang diproses:

   • Pada Apple M2 Ultra: Penghematan energi BitNet.cpp sangat besar. Untuk model 700M, ia mengkonsumsi 55,4% energi yang lebih sedikit per token dibandingkan dengan Llama.cpp, turun dari 0,314 menjadi 0,140. Trend ini berlanjut untuk model yang lebih besar, dengan model 70B menunjukkan pengurangan konsumsi energi 70,0%.
   • Pada Intel i7-13700H: BitNet.cpp memberikan penghematan energi 71,9% untuk model 700M, dengan konsumsi turun dari 1,367 menjadi 0,384. Meskipun data energi untuk model 70B dalam Llama.cpp tidak tersedia, BitNet.cpp tetap efisien, dengan konsumsi energi sebesar 17,33 untuk model 70B.

     Melampaui Batas Kecepatan Membaca Manusia
     Salah satu wawasan paling menarik dari grafik ini adalah referensi ke kecepatan membaca manusia, ditandai pada 5-7 token per detik. Garis merah ini menunjukkan bahwa kedua implementasi, terutama BitNet.cpp, dapat dengan nyaman melampaui kecepatan membaca manusia bahkan untuk model terbesar:

   • Pada Apple M2 Ultra, BitNet.cpp melampaui kecepatan membaca manusia untuk semua ukuran model, dengan kecepatan terendah adalah 8,67 token per detik untuk model 70B.
   • Pada Intel i7-13700H, model 100B masih mencapai 1,70 token per detik, hampir menyentuh rentang bawah kecepatan membaca manusia, sementara semua model yang lebih kecil melampaui batas ini.

     Melatih Pertimbangan
     Estimator Langsung (STE)
     Karena kuantisasi 1-bit memperkenalkan fungsi yang tidak dapat dibedakan, pelatihan melibatkan teknik khusus yang dikenal sebagai Estimator Langsung (STE). Dalam pendekatan ini, gradien mengalir tanpa diubah melalui titik-titik yang tidak dapat dibedakan. Berikut adalah implementasi yang disederhanakan dalam Python:

     class StraightThroughEstimator(Function):
     @staticmethod
     def forward(ctx, input):
     return input.sign()
     @staticmethod
     def backward(ctx, grad_output):
     return grad_output

     Pelatihan Mixed Precision
     Untuk menjaga stabilitas selama pelatihan, mixed precision digunakan:

   • Bobot dan Aktivasi: Dikuantisasi ke presisi 1-bit.
   • Gradien dan Status Optimizer: Disimpan dalam presisi yang lebih tinggi.
   • Bobot Laten: Dijaga dalam presisi tinggi untuk memfasilitasi pembaruan yang akurat selama pelatihan.

     Strategi Learning Rate Besar
     Tantangan unik dengan model 1-bit adalah bahwa pembaruan kecil mungkin tidak mempengaruhi bobot yang dibiarkan biner. Untuk mengurangi hal ini, learning rate ditingkatkan, memastikan konvergensi yang lebih cepat dan optimisasi yang lebih baik dibandingkan dengan pendekatan tradisional.

     Group Quantization dan Normalisasi
     BitNet.cpp memperkenalkan Group Quantization dan Normalization untuk meningkatkan paralelisme model. Alih-alih menghitung parameter untuk seluruh matriks bobot, BitNet membagi bobot dan aktivasi ke dalam beberapa grup (G).

     Pengelompokan ini memungkinkan pemrosesan paralel yang efisien tanpa komunikasi antar grup tambahan, memungkinkan pelatihan dan inferensi model skala besar.

     Catatan Implementasi dan Optimisasi
     Optimisasi CPU
     BitNet.cpp memanfaatkan beberapa optimisasi tingkat rendah untuk mencapai kinerja CPU puncak:

   • Operasi Vectorized: Memanfaatkan instruksi SIMD untuk melakukan manipulasi bit secara efisien.
   • Akses Memori yang Ramah Cache: Menyusun data untuk meminimalkan cache misses.
   • Pemrosesan Paralel: Mendistribusikan beban kerja secara efektif di beberapa inti CPU.

     Berikut adalah contoh fungsi kunci yang mengimplementasikan kuantisasi dan inferensi dalam BitNet:

     def bitlinear_forward(input, weight, scale):

     Kuantisasi input menggunakan kuantisasi absmax
     

     input_q = quantize(input)

     Melakukan perkalian matriks biner
     

     output = binary_matmul(input_q, weight)

     Skala output untuk cocok dengan presisi asli
     

     return output * scale
     def quantize(x):

     Melakukan kuantisasi absmax
     

     scale = torch.max(torch.abs(x))
     return torch.clamp(x / scale, -1, 1) * scale

     Model yang Didukung
     Rilis terbaru BitNet.cpp mendukung LLMs 1-bit berikut yang tersedia di Hugging Face:

   • bitnet_b1_58-large (0.7B parameter)
   • bitnet_b1_58-3B (3.3B parameter)
   • Llama3-8B-1.58-100B-tokens (8.0B parameter)

     Model-model ini tersedia secara publik untuk menunjukkan kemampuan inferensi kerangka. Meskipun tidak secara resmi dilatih atau dirilis oleh Microsoft, mereka mengilustrasikan fleksibilitas kerangka.

     Panduan Instalasi
     Untuk memulai dengan BitNet.cpp, ikuti langkah-langkah di bawah ini:

     Persyaratan

   • Python >= 3.9
   • CMake >= 3.22
   • Clang >= 18
   • Conda (disarankan)

     Untuk pengguna Windows, Visual Studio harus diinstal dengan komponen-komponen berikut diaktifkan:

   • Desktop Development with C++
   • C++-CMake Tools for Windows
   • Git for Windows
   • C++-Clang Compiler for Windows
   • MS-Build Support for LLVM Toolset (Clang)

     Untuk pengguna Debian/Ubuntu, skrip instalasi otomatis tersedia.

     Langkah-langkah Instalasi

4. Klone Repository
5. Instal Dependensi
6. Bangun dan Persiapkan Proyek

   Anda dapat mengunduh model langsung dari Hugging Face dan mengonversinya ke format terkuantisasi:
   Atau, unduh dan konversikan model secara manual.

   Menjalankan Inferensi dengan BitNet.cpp
   Untuk menjalankan inferensi menggunakan kerangka, gunakan perintah berikut:

   Penjelasan:

   • -m menentukan jalur file model.
   • -p mendefinisikan teks permintaan.
   • -n menetapkan jumlah token yang diprediksi.
   • -temp menyesuaikan keacakan sampling (suhu) selama inferensi.

     Contoh Output

     Detail Teknis BitNet.cpp
     Lapisan BitLinear
     BitNet.cpp mengimplementasikan arsitektur Transformer yang dimodifikasi, menggantikan perkalian matriks standar dengan operasi BitLinear. Pendekatan ini memusatkan bobot ke nol sebelum kuantisasi dan menskalakannya untuk mengurangi kesalahan aproksimasi. Fungsi transformasi kunci terlihat seperti ini:

     Fungsi binarisasi untuk bobot 1-bit
     

     def binarize_weights(W):
     alpha = W.mean()
     W_binarized = np.sign(W – alpha)
     return W_binarized

     Kombinasi bobot yang terpusat dan penskalaan memastikan bahwa kesalahan kuantisasi tetap minimal, sehingga mempertahankan kinerja.

     Dampak Industri
     BitNet.cpp bisa memiliki dampak yang luas pada penyebaran LLMs:

   • Aksesibilitas: Memungkinkan LLMs berjalan pada perangkat standar, memdemokratisasi akses ke kecerdasan buatan yang kuat.
   • Efisiensi Biaya: Mengurangi kebutuhan akan GPU mahal, menurunkan hambatan untuk adopsi.
   • Efisiensi Energi: Menghemat energi dengan memanfaatkan inferensi berbasis CPU standar.
   • Inovasi: Membuka kemungkinan baru untuk AI di perangkat, seperti terjemahan bahasa real-time, asisten suara, dan aplikasi berfokus privasi tanpa ketergantungan awan.

     Tantangan dan Arah Masa Depan
     Meskipun LLMs 1-bit menjanjikan, masih ada beberapa tantangan. Ini termasuk pengembangan model 1-bit yang kokoh untuk tugas-tugas yang beragam, mengoptimalkan perangkat keras untuk komputasi 1-bit, dan mendorong pengembang untuk mengadopsi paradigma baru ini. Selain itu, menjelajahi kuantisasi 1-bit untuk tugas-tugas visi komputer atau audio merupakan arah masa depan yang menarik.

     Kesimpulan
     Peluncuran BitNet.cpp oleh Microsoft adalah kemajuan yang signifikan. Dengan memungkinkan inferensi 1-bit yang efisien pada CPU standar, BitNet.cpp menciptakan aksesibilitas dan keberlanjutan AI. Kerangka ini menyiapkan panggung untuk LLMs yang lebih portabel dan hemat biaya, mendorong batas kemungkinan dengan AI di perangkat lokal.