Cara Menjalankan Alpaca-LoRA di Perangkat Anda

Seiring AI generatif semakin populer, pengembang di seluruh dunia berlomba memanfaatkan peluang untuk membangun aplikasi menarik dengan bahasa alami. Satu alat khususnya mendapat banyak sorotan belakangan ini: ChatGPT.

ChatGPT adalah model bahasa yang dikembangkan oleh OpenAI. Tujuannya adalah menjadi chatbot bertenaga AI yang mampu berdialog layaknya manusia. Meskipun sangat bermanfaat, alat ini bukan tanpa masalah. ChatGPT bukan sumber terbuka, artinya kode sumbernya tidak dapat diakses dan tidak dapat dimodifikasi. Selain itu, ia sangat boros sumber daya, sehingga membangun implementasi sendiri bukanlah solusi yang baik.

Masalah-masalah tersebut melahirkan serangkaian alternatif ChatGPT, seperti Alpaca-LoRA, yang mampu berfungsi seperti ChatGPT tetapi dengan lisensi sumber terbuka dan kebutuhan sumber daya yang lebih rendah.

Dalam tutorial ini, kita akan fokus khusus pada Alpaca-LoRA. Kita akan membahas apa itu, prasyarat untuk menjalankannya di perangkat Anda, dan langkah-langkah untuk mengeksekusinya.

Apa itu Alpaca LoRA?

Pada awal Maret 2023, Eric J. Wang merilis proyek Alpaca-LoRA. Ini adalah proyek yang berisi kode untuk mereproduksi hasil Standford Alpaca menggunakan Parameter-Efficient Fine-Tuning (PEFT); ini adalah pustaka yang memungkinkan pengembang melakukan fine-tuning pada model berbasis transformer menggunakan LoRA.

Memahami LoRA

Low-Rank Adaptation pada Large Language Models (LoRA) adalah metode untuk mempercepat proses pelatihan model besar sambil menggunakan lebih sedikit memori.

Begini cara kerjanya:

• Membekukan bobot yang ada. Bayangkan model sebagai jaring kompleks dari node yang saling terhubung (ini adalah "bobot"). Biasanya, Anda akan menyesuaikan semua node ini selama pelatihan untuk meningkatkan model. LoRA berkata, "Jangan sentuh yang ini; biarkan tetap seperti adanya."
• Menambahkan bobot baru. LoRA kemudian menambahkan beberapa koneksi baru yang lebih sederhana (bobot baru) ke jaring ini.
• Melatih hanya bobot baru. Alih-alih menyesuaikan seluruh jaring yang kompleks, Anda hanya fokus memperbaiki koneksi baru yang lebih sederhana ini.

Dengan cara ini, Anda menghemat waktu dan memori komputer sambil tetap membuat model Anda lebih baik dalam menjalankan tugasnya.

Keunggulan LoRA

Keunggulan LoRA meliputi:

• Portabilitas - Matriks bobot dekomposisi-rank memiliki jauh lebih sedikit parameter yang dapat dilatih dibandingkan model asli; karena itu, bobot LoRA yang telah dilatih mudah dipindahkan dan dapat dijalankan di Rasberry Pi.
• Aksesibilitas – Dibandingkan dengan fine-tuning konvensional, LoRa terbukti secara signifikan mengurangi penggunaan memori GPU; ini memungkinkan fine-tuning dilakukan pada GPU konsumen seperti Tesla T4, RTX 3080, atau bahkan RTX 2080 Ti.

Alpaca: Model Sumber Terbuka

Sementara itu, Alpaca adalah model bahasa AI sumber terbuka yang di-finetune untuk instruksi, berbasis Large Language Model Meta AI (LLaMA). Model ini dikembangkan oleh tim peneliti di Stanford University dengan tujuan membuat model bahasa besar (LLM) lebih mudah diakses.

Dan inilah yang membawa kita ke Alpaca-LoRA.

Model Alpaca-LoRA adalah versi Stanford Alpaca yang lebih hemat sumber daya, yang memanfaatkan LoRA untuk mempercepat proses pelatihan sambil menggunakan lebih sedikit memori.

Prasyarat Alpaca-LoRA

Untuk menjalankan model Alpaca-LoRA secara lokal, Anda harus memiliki GPU. Bisa GPU spesifikasi rendah seperti NVIDIA T4 atau GPU konsumen seperti 4090. Menurut Eric J. Wang, pembuat proyek ini, model tersebut "berjalan dalam hitungan jam pada satu RTX 4090."

Catatan: instruksi dalam artikel ini mengikuti yang disediakan di repositori Alpaca-LoRA oleh Eric J. Wang.

Cara Menjalankan Alpaca-LoRA dalam 4 Langkah

Langkah 1: Buat virtual environment (Opsional)

Virtual environment adalah kontainer terisolasi untuk menyimpan dependensi terkait Python yang dibutuhkan proyek tertentu. Ini membantu menjaga dependensi untuk proyek berbeda tetap terpisah, sehingga memudahkan berbagi proyek dan mengurangi konflik dependensi.

Tidak wajib menggunakannya untuk menjalankan model Alpaca-LoRA, tetapi dianjurkan.

Untuk membuat virtual environment menggunakan command prompt di sistem operasi Windows, jalankan perintah berikut:

py -m venv venv

Ini akan membuat virtual environment bernama venv di direktori kerja Anda saat ini.

Catatan: Anda dapat menggunakan nama apa pun untuk virtual environment dengan mengganti venv kedua dengan nama pilihan Anda.

Sebelum menginstal dependensi apa pun, Anda harus mengaktifkan virtual environment. Jalankan perintah berikut untuk mengaktifkannya:

venv\Scripts\activate.bat

Saat Anda tidak lagi menggunakan virtual environment, jalankan perintah berikut untuk menonaktifkannya:

deactivate

Sekarang Anda siap mulai menjalankan Alpaca-LoRA.

Langkah 2: Penyiapan

Langkah pertama untuk menjalankan model Alpaca-LoRA adalah mengkloning repositori dari GitHub dan menginstal dependensi yang diperlukan untuk eksekusi.

Gunakan perintah berikut untuk menginstal repositori GitHub:

git clone https://github.com/tloen/alpaca-lora.git

Lalu navigasikan ke repositori alpaca-lora yang baru saja Anda instal dengan:

cd alpaca-lora

Dan jalankan perintah berikut untuk menginstal dependensi:

pip install -r requirements.txt

Langkah 3: Fine-Tuning Model (Opsional)

Repositori alpaca-lora berisi berkas bernama finetune.py. finetune.py memuat penerapan sederhana Parameter-Efficient Fine-Tuning (PEFT) pada model LLaMA, di antara hal lainnya.

Inilah berkas yang harus Anda eksekusi jika ingin menyetel hyperparameter model, namun tidak wajib. Menurut penulis repositori, “Tanpa penyetelan hyperparameter, model LoRA menghasilkan keluaran yang sebanding dengan model Stanford Alpaca. Penyetelan lebih lanjut mungkin dapat mencapai kinerja yang lebih baik [...].”

Berikut contoh cara menggunakan berkas finetune.py:

python -m finetune.py \
    --base_model 'decapoda-research/llama-7b-hf' \
    --data_path 'yahma/alpaca-cleaned' \
    --output_dir './lora-alpaca' \
    --batch_size 128 \
    --micro_batch_size 4 \
    --num_epochs 3 \
    --learning_rate 1e-4 \
    --cutoff_len 512 \
    --val_set_size 2000 \
    --lora_r 8 \
    --lora_alpha 16 \
    --lora_dropout 0.05 \
    --lora_target_modules '[q_proj,v_proj]' \
    --train_on_inputs \
    --group_by_length

Langkah 4: Menjalankan model / Inferensi

Di repositori alpaca-lora juga ada berkas bernama generate.py. Menjalankan generate.py akan melakukan hal-hal berikut:

• Membaca model dasar dari Hugging Face model hub
• Membaca bobot model dari tloen/alpaca-lora-7b
• Menjalankan antarmuka Gradio tempat inferensi dilakukan pada input yang ditentukan.

Pada saat penulisan, adapter Alpaca-LoRA terbaru yang digunakan untuk melatih model adalah alpaca-lora-7b. Ini dilakukan pada 26 Maret 2023 dengan perintah berikut:

python finetune.py \
    --base_model='decapoda-research/llama-7b-hf' \
    --num_epochs=10 \
    --cutoff_len=512 \
    --group_by_length \
    --output_dir='./lora-alpaca' \
    --lora_target_modules='[q_proj,k_proj,v_proj,o_proj]' \
    --lora_r=16 \
    --micro_batch_size=8

Jika Anda ingin menggunakan adaptor lain, Anda dapat melakukannya dengan menjalankan berkas generate.py dengan tautan ke tujuan adaptor pilihan Anda.

python generate.py \
    --load_8bit \
    --base_model 'decapoda-research/llama-7b-hf' \
    --lora_weights 'tloen/alpaca-lora-7b'

Penutup

Alpaca-LoRA adalah versi Stanford Alpaca yang lebih hemat sumber daya. Tujuan ini dicapai dengan memanfaatkan low-rank adaptation pada large language models (LoRA), yang mempercepat proses pelatihan sambil menggunakan jauh lebih sedikit memori dibandingkan model Alpaca asli.

Pelajari lebih lanjut tentang large language models (LLM) dan AI generatif melalui tutorial berikut:

• Pengantar Meta AI LLaMA
• Cara melatih LLM dengan PyTorch: Panduan langkah demi langkah