Devlog 0: Menyesuaikan Mistral – Nyaris Berhasil

Selamat datang di Devlog 0! Dalam seri ini, saya akan mendokumentasikan perjalanan saya menyesuaikan model bahasa besar (LLM) open-source, khususnya Mistral 7B. Tujuan utama saya adalah meningkatkan kinerja model pada tugas-tugas spesifik sambil tetap menjaga efisiensi dan aksesibilitas. Devlog ini akan membahas tentang upaya pertama saya, tantangan yang dihadapi, dan pelajaran yang saya dapatkan. Bersiaplah untuk menyelami dunia penyesuaian LLM yang penuh lika-liku!

Mengapa Menyesuaikan Mistral?

Sebelum masuk ke detail teknis, mari kita bahas mengapa saya memilih Mistral dan mengapa saya memutuskan untuk menyesuaikannya.

• Open-Source dan Aksesibilitas: Mistral adalah model open-source, yang berarti saya memiliki akses penuh ke arsitektur dan bobot model. Ini penting karena memungkinkan saya untuk bereksperimen, memodifikasi, dan memahami model secara mendalam. Selain itu, sifat open-source mendorong kolaborasi dan inovasi di komunitas AI.
• Kinerja yang Menjanjikan: Mistral 7B telah menunjukkan kinerja yang mengesankan pada berbagai benchmark, bersaing dengan model yang jauh lebih besar. Ini menunjukkan potensi besar untuk dioptimalkan lebih lanjut untuk kasus penggunaan tertentu.
• Kebutuhan Khusus: LLM generik seringkali kurang optimal untuk tugas-tugas khusus. Menyesuaikan Mistral memungkinkan saya untuk mengadaptasi model ke domain dan tugas tertentu, menghasilkan kinerja yang lebih baik dan efisiensi yang lebih tinggi. Contohnya, saya tertarik untuk melihat seberapa baik model dapat beradaptasi dengan pembuatan kode atau penulisan kreatif dengan gaya tertentu.

Inspirasi dan Penelitian Awal

Sebelum memulai, saya melakukan riset ekstensif tentang penyesuaian LLM, strategi, dan alat yang tersedia. Beberapa sumber daya sangat membantu:

• Hugging Face: Hugging Face adalah pusat sumber daya untuk LLM, termasuk model, dataset, dan tutorial. Saya sangat mengandalkan Hugging Face Transformers library dan Hugging Face Hub untuk mengunduh model dan dataset.
• Artikel Penelitian: Saya membaca beberapa artikel penelitian tentang berbagai teknik penyesuaian LLM, seperti Fine-Tuning, LoRA (Low-Rank Adaptation), dan Quantization. Memahami teori di balik teknik-teknik ini sangat penting untuk membuat keputusan yang tepat selama proses penyesuaian.
• Tutorial dan Blog: Ada banyak tutorial dan posting blog online yang mendokumentasikan pengalaman orang lain dalam menyesuaikan LLM. Saya menemukan sumber daya ini sangat berguna untuk mempelajari praktik terbaik dan menghindari jebakan umum.

Rencana Awal: Tujuan dan Metrik

Sebelum memulai proses penyesuaian, penting untuk mendefinisikan tujuan yang jelas dan metrik evaluasi. Ini membantu untuk mengukur kemajuan dan memastikan bahwa upaya penyesuaian membuahkan hasil.

1. Tujuan: Meningkatkan kinerja Mistral 7B pada tugas pembuatan kode Python, khususnya dengan fokus pada keakuratan dan efisiensi.
2. Dataset: Saya memilih dataset “Leetcode Hard” dari Hugging Face Hub yang berisi solusi kode Python untuk masalah Leetcode Hard. Dataset ini relatif kecil (sekitar 5000 sampel), yang membuatnya ideal untuk eksperimen awal.
3. Metrik Evaluasi:
   • Keakuratan: Persentase kode yang dihasilkan yang benar dan menyelesaikan masalah Leetcode yang sesuai.
   • BLEU Score: BLEU (Bilingual Evaluation Understudy) adalah metrik untuk mengevaluasi kualitas teks yang dihasilkan oleh mesin. Saya akan menggunakan BLEU untuk mengukur kesamaan antara kode yang dihasilkan dan solusi referensi.
   • Waktu Inferensi: Waktu yang dibutuhkan model untuk menghasilkan kode untuk masalah Leetcode tertentu.

Persiapan Lingkungan dan Alat

Sebelum dapat memulai penyesuaian, saya perlu menyiapkan lingkungan dan alat yang diperlukan.

1. Perangkat Keras: Saya menggunakan GPU NVIDIA RTX 3090 dengan 24 GB VRAM. Meskipun mungkin untuk menyesuaikan LLM pada CPU, GPU secara signifikan mempercepat prosesnya.
2. Perangkat Lunak:
   • Python: Bahasa pemrograman utama.
   • PyTorch: Kerangka kerja pembelajaran mesin.
   • Hugging Face Transformers: Pustaka untuk bekerja dengan LLM.
   • Datasets: Pustaka untuk mengunduh dan memproses dataset.
   • Accelerate: Pustaka dari Hugging Face untuk mempermudah proses pelatihan di beberapa GPU atau TPU.
   • PEFT (Parameter-Efficient Fine-Tuning): Pustaka untuk menerapkan teknik penyesuaian LLM yang hemat memori, seperti LoRA.

Berikut adalah contoh kode untuk menginstal pustaka yang diperlukan:

pip install torch transformers datasets accelerate peft

Implementasi: Fine-Tuning dengan LoRA

Saya memutuskan untuk menggunakan LoRA (Low-Rank Adaptation) untuk menyesuaikan Mistral 7B. LoRA adalah teknik yang efektif dan efisien memori yang membekukan bobot model asli dan melatih sejumlah kecil parameter tambahan. Ini mengurangi biaya komputasi dan persyaratan memori penyesuaian secara signifikan.

1. Memuat Model dan Tokenizer:

   Langkah pertama adalah memuat model Mistral 7B dan tokenizer yang sesuai menggunakan Hugging Face Transformers.

   from transformers import AutoModelForCausalLM, AutoTokenizer
   
   model_name = "mistralai/Mistral-7B-v0.1"
   model = AutoModelForCausalLM.from_pretrained(model_name, device_map="auto")
   tokenizer = AutoTokenizer.from_pretrained(model_name)
   tokenizer.pad_token = tokenizer.eos_token # Penting untuk pembuatan kode
   

   Penting untuk mengatur tokenizer.pad_token ke tokenizer.eos_token. Ini memastikan bahwa token padding yang benar digunakan selama pelatihan.

2. Memuat dan Memproses Dataset:

   Selanjutnya, saya memuat dataset “Leetcode Hard” menggunakan Hugging Face Datasets dan memprosesnya untuk memenuhi kebutuhan model.

   from datasets import load_dataset
   
   dataset_name = "codeparrot/leetcode-hard"
   dataset = load_dataset(dataset_name, split="train")
   
   def tokenize_function(examples):
       return tokenizer(examples["content"], padding="max_length", truncation=True, max_length=512)
   
   tokenized_datasets = dataset.map(tokenize_function, batched=True)
   

   Fungsi tokenize_function memproses teks dalam dataset menggunakan tokenizer. Opsi padding="max_length" dan truncation=True memastikan bahwa semua urutan dipadatkan atau dipotong ke panjang maksimum yang sama (512 dalam contoh ini).

3. Konfigurasi LoRA:

   Saya mengonfigurasi LoRA dengan menentukan parameter seperti rank (r), alpha (lora_alpha), dan modul target.

   from peft import LoraConfig, get_peft_model
   
   lora_config = LoraConfig(
       r=8,
       lora_alpha=32,
       lora_dropout=0.05,
       bias="none",
       task_type="CAUSAL_LM"
   )
   
   model = get_peft_model(model, lora_config)
   model.print_trainable_parameters()
   

   Parameter r menentukan dimensi matriks rank rendah. Nilai yang lebih tinggi biasanya menghasilkan kinerja yang lebih baik tetapi juga membutuhkan lebih banyak memori. Parameter lora_alpha adalah faktor penskalaan yang digunakan untuk menyesuaikan bobot LoRA. lora_dropout adalah laju dropout untuk lapisan LoRA. task_type diatur ke CAUSAL_LM karena kita bekerja dengan model bahasa kausal.

4. Pelatihan Model:

   Saya menggunakan Hugging Face Trainer untuk melatih model. Saya mengonfigurasi parameter pelatihan seperti laju pembelajaran, ukuran batch, dan epoch.

   from transformers import Trainer, TrainingArguments
   
   training_args = TrainingArguments(
       output_dir="results",
       evaluation_strategy="epoch",
       learning_rate=2e-4,
       per_device_train_batch_size=4,
       per_device_eval_batch_size=4,
       num_train_epochs=3,
       weight_decay=0.01,
       logging_steps=10,
       save_strategy="epoch",
       fp16=True,  # Aktifkan pelatihan presisi campuran
   )
   
   trainer = Trainer(
       model=model,
       args=training_args,
       train_dataset=tokenized_datasets,
       eval_dataset=tokenized_datasets, # Menggunakan dataset pelatihan untuk evaluasi awal
       data_collator=lambda data: {'input_ids': torch.stack([f['input_ids'] for f in data]),
                                  'attention_mask': torch.stack([f['attention_mask'] for f in data]),
                                  'labels': torch.stack([f['input_ids'] for f in data])} # Tambah label
   )
   
   trainer.train()
   

   Penting untuk mengaktifkan pelatihan presisi campuran (fp16=True) untuk mengurangi penggunaan memori dan mempercepat pelatihan. data_collator harus didefinisikan untuk mengelompokkan sampel secara efektif dan menyediakan label untuk pelatihan.

Hasil dan Evaluasi Awal

Setelah menyelesaikan pelatihan, saya mengevaluasi model yang telah disesuaikan menggunakan metrik yang ditentukan sebelumnya.

1. Keakuratan: Keakuratan kode yang dihasilkan agak meningkat dibandingkan dengan model yang tidak disesuaikan. Namun, keakuratannya masih relatif rendah (sekitar 10%). Ini menunjukkan bahwa model masih kesulitan menghasilkan kode yang benar untuk masalah Leetcode yang sulit.
2. BLEU Score: BLEU Score juga meningkat setelah penyesuaian. Namun, skornya masih relatif rendah (sekitar 0.2). Ini menunjukkan bahwa kode yang dihasilkan mirip dengan solusi referensi, tetapi ada ruang untuk perbaikan.
3. Waktu Inferensi: Waktu inferensi sedikit meningkat setelah penyesuaian. Ini diharapkan karena LoRA memperkenalkan parameter tambahan ke dalam model.

Secara keseluruhan, hasil awal mengecewakan. Meskipun penyesuaian meningkatkan kinerja model, peningkatannya tidak signifikan. Ini menunjukkan bahwa ada masalah dengan proses penyesuaian atau dataset yang digunakan.

Analisis Masalah dan Pelajaran yang Didapat

Setelah menganalisis hasil, saya mengidentifikasi beberapa potensi masalah dan pelajaran yang saya dapatkan:

1. Kualitas Dataset: Kualitas dataset “Leetcode Hard” mungkin tidak ideal untuk penyesuaian. Dataset mungkin mengandung kesalahan atau inkonsistensi yang mempengaruhi kinerja model. Mungkin lebih baik menggunakan dataset yang lebih besar dan bersih.
2. Ukuran Dataset: Ukuran dataset (sekitar 5000 sampel) relatif kecil. Ukuran dataset yang lebih besar kemungkinan akan menghasilkan kinerja yang lebih baik.
3. Konfigurasi LoRA: Konfigurasi LoRA (rank, alpha, dropout) mungkin tidak optimal. Bereksperimen dengan konfigurasi yang berbeda mungkin meningkatkan kinerja model.
4. Parameter Pelatihan: Parameter pelatihan (laju pembelajaran, ukuran batch, epoch) mungkin tidak optimal. Fine-tuning parameter ini dapat menghasilkan kinerja yang lebih baik.
5. Kurangnya Validasi: Saya menggunakan dataset pelatihan untuk evaluasi, yang dapat menyebabkan overfitting. Memisahkan dataset validasi akan memberikan evaluasi yang lebih akurat tentang kinerja model.

Langkah Selanjutnya

Berdasarkan analisis dan pelajaran yang didapat, saya berencana untuk mengambil langkah-langkah berikut di Devlog berikutnya:

1. Mengumpulkan Dataset yang Lebih Baik: Saya akan mencari dataset pembuatan kode yang lebih besar dan bersih. Saya mungkin mempertimbangkan untuk menggabungkan beberapa dataset dari berbagai sumber.
2. Menyesuaikan Parameter LoRA: Saya akan bereksperimen dengan konfigurasi LoRA yang berbeda untuk menemukan pengaturan optimal.
3. Menyesuaikan Parameter Pelatihan: Saya akan fine-tune parameter pelatihan untuk meningkatkan kinerja model. Ini mungkin melibatkan penggunaan jadwal laju pembelajaran atau teknik optimasi lainnya.
4. Menambahkan Dataset Validasi: Saya akan memisahkan dataset validasi untuk mengevaluasi kinerja model secara akurat dan mencegah overfitting.
5. Eksperimen dengan Teknik Penyesuaian yang Berbeda: Saya mungkin mempertimbangkan untuk bereksperimen dengan teknik penyesuaian yang berbeda, seperti QLoRA (Quantized LoRA) atau full fine-tuning.

Kesimpulan

Devlog 0 ini mendokumentasikan upaya pertama saya untuk menyesuaikan Mistral 7B untuk pembuatan kode. Meskipun hasilnya tidak ideal, saya telah belajar banyak tentang proses penyesuaian LLM dan tantangan yang terkait dengannya. Saya yakin dengan melakukan perbaikan dan bereksperimen dengan teknik yang berbeda, saya dapat mencapai kinerja yang lebih baik di Devlog berikutnya. Terima kasih telah bergabung dengan saya dalam perjalanan ini! Tetaplah disini untuk Devlog 1!