Panduan Lengkap untuk Fine-Tuning Llama 3 atau Model Open-Source Lainnya

Fine-tuning model bahasa besar (LLM) seperti Llama 3 melibatkan penyesuaian model pra-dilatih untuk tugas spesifik menggunakan dataset domain-spesifik. Proses ini memanfaatkan pengetahuan pra-ada model, membuatnya efisien dan hemat biaya dibandingkan dengan pelatihan dari awal. Dalam panduan ini, kita akan membahas langkah-langkah untuk fine-tuning Llama 3 menggunakan QLoRA (Quantized LoRA), metode efisien parameter yang meminimalkan penggunaan memori dan biaya komputasi.

Overview of Fine-Tuning

Fine-tuning melibatkan beberapa langkah kunci:

1. Memilih Model Pra-Dilatih: Pilih model dasar yang sesuai dengan arsitektur yang diinginkan.
2. Mengumpulkan Dataset Relevan: Kumpulkan dan olah dataset yang spesifik untuk tugas.
3. Fine-Tuning: Sesuaikan model menggunakan dataset untuk meningkatkan kinerjanya pada tugas spesifik.
4. Evaluasi: Evaluasi model yang telah di-fine-tune menggunakan metrik kualitatif dan kuantitatif.

Konsep dan Teknik

Fine-tuning Large Language Models

Full Fine-Tuning

Full fine-tuning memperbarui semua parameter model, membuatnya spesifik untuk tugas baru. Metode ini memerlukan sumber daya komputasi yang signifikan dan seringkali tidak praktis untuk model yang sangat besar.

Parameter-Efficient Fine-Tuning (PEFT)

PEFT memperbarui hanya subset parameter model, mengurangi kebutuhan memori dan biaya komputasi. Teknik ini mencegah lupa kritis dan mempertahankan pengetahuan umum model.

Low-Rank Adaptation (LoRA) dan Quantized LoRA (QLoRA)

LoRA melakukan fine-tuning hanya beberapa matriks berperingkat rendah, sedangkan QLoRA mengkuantifikasi matriks-matriks ini untuk mengurangi jejak memori lebih lanjut.

Metode Fine-Tuning

1. Full Fine-Tuning: Ini melibatkan pelatihan semua parameter model pada dataset tugas-spesifik. Meskipun metode ini dapat sangat efektif, juga komputasi-mahal dan memerlukan memori yang signifikan.
2. Parameter Efficient Fine-Tuning (PEFT): PEFT memperbarui hanya subset parameter model, membuatnya lebih efisien memori. Teknik seperti Low-Rank Adaptation (LoRA) dan Quantized LoRA (QLoRA) termasuk dalam kategori ini.

Apa itu LoRA?

Comparing finetuning methods: QLORA enhances LoRA with 4-bit precision quantization and paged optimizers for memory spike management

LoRA adalah metode fine-tuning yang ditingkatkan di mana, alih-alih fine-tuning semua bobot model pra-dilatih, dua matriks yang lebih kecil yang mengapproximasi matriks yang lebih besar di-fine-tune. Matriks-matriks ini membentuk adapter LoRA. Adapter yang di-fine-tune ini kemudian dimuat ke dalam model pra-dilatih dan digunakan untuk inferensi.

Kelebihan Utama LoRA:

• Efisiensi Memori: LoRA mengurangi jejak memori dengan hanya fine-tuning matriks kecil bukan seluruh model.
• Penggunaan Kembali: Model asli tetap tidak berubah, dan beberapa adapter LoRA dapat digunakan dengannya, memfasilitasi penanganan beberapa tugas dengan kebutuhan memori yang lebih rendah.

Apa itu Quantized LoRA (QLoRA)?

QLoRA mengambil LoRA ke tingkat yang lebih tinggi dengan mengkuantifikasi bobot adapter LoRA ke presisi yang lebih rendah (misalnya, 4-bit bukan 8-bit). Ini lebih lanjut mengurangi penggunaan memori dan kebutuhan penyimpanan sambil mempertahankan tingkat efektivitas yang setara.

Kelebihan Utama QLoRA:

• Efisiensi Memori yang Lebih Besar: Dengan mengkuantifikasi bobot, QLoRA secara signifikan mengurangi kebutuhan memori dan penyimpanan model.
• Mempertahankan Kinerja: Meskipun presisi yang lebih rendah, QLoRA mempertahankan tingkat kinerja yang dekat dengan model presisi penuh.

Adaptasi Tugas-Spesifik

Selama fine-tuning, parameter model disesuaikan berdasarkan dataset baru, membantu model memahami dan menghasilkan konten yang relevan dengan tugas spesifik. Proses ini mempertahankan pengetahuan bahasa umum yang diperoleh selama pra-pelatihan sambil menyesuaikan model dengan nuansa domain target.

Fine-Tuning dalam Praktik

Full Fine-Tuning vs. PEFT

• Full Fine-Tuning: Melibatkan pelatihan seluruh model, yang dapat komputasi-mahal dan memerlukan memori yang signifikan.
• PEFT (LoRA dan QLoRA): Fine-tuning hanya subset parameter, mengurangi kebutuhan memori dan mencegah lupa kritis, membuatnya alternatif yang lebih efisien.

Langkah Implementasi

1. Setup Lingkungan: Instal perpustakaan yang diperlukan dan atur lingkungan komputasi.
2. Muat dan Olah Dataset: Muat dataset dan olah menjadi format yang sesuai untuk model.
3. Muat Model Pra-Dilatih: Muat model dasar dengan konfigurasi kuantisasi jika menggunakan QLoRA.
4. Tokenisasi: Tokenisasi dataset untuk mempersiapkannya untuk pelatihan.
5. Pelatihan: Lakukan fine-tuning model menggunakan dataset yang telah dipersiapkan.
6. Evaluasi: Evaluasi kinerja model pada tugas spesifik menggunakan metrik kualitatif dan kuantitatif.

Panduan Langkah demi Langkah untuk Fine-Tune LLM

Mengatur Lingkungan

Kita akan menggunakan Jupyter notebook untuk tutorial ini. Platform seperti Kaggle, yang menawarkan penggunaan GPU gratis, atau Google Colab ideal untuk menjalankan eksperimen ini.

1. Instal Perpustakaan yang Diperlukan

Pastikan Anda memiliki perpustakaan yang diperlukan terinstal:

!pip install -qqq -U bitsandbytes transformers peft accelerate datasets scipy einops evaluate trl rouge_score

2. Impor Perpustakaan dan Atur Lingkungan

import os
import torch
from datasets import load_dataset
from transformers import (
AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig, TrainingArguments,
pipeline, HfArgumentParser
)
from trl import ORPOConfig, ORPOTrainer, setup_chat_format, SFTTrainer
from tqdm import tqdm
import gc
import pandas as pd
import numpy as np
from huggingface_hub import interpreter_login

# Nonaktifkan logging Weights and Biases
os.environ['WANDB_DISABLED'] = "true"
interpreter_login()

3. Muat Dataset

Kita akan menggunakan dataset DialogSum untuk tutorial ini:

dataset_name = "neil-code/dialogsum-test"
dataset = load_dataset(dataset_name)

4. Buat Konfigurasi BitsAndBytes

Untuk memuat model dalam format 4-bit:

compute_dtype = getattr(torch, "float16")
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type='nf4',
bnb_4bit_compute_dtype=compute_dtype,
bnb_4bit_use_double_quant=False,
)

5. Muat Model Pra-Dilatih

Menggunakan model Phi-2 Microsoft (MSFT ) untuk tutorial ini:

model_name = 'microsoft/phi-2'
device_map = {"": 0}
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

6. Tokenisasi

Konfigurasikan tokenizer:

tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
padding_side="left",
add_eos_token=True,
add_bos_token=True,
use_fast=False
)
tokenizer.pad_token = tokenizer.eos_token

Fine-Tuning Llama 3 atau Model Lainnya

Ketika fine-tuning model seperti Llama 3 atau model open-source lainnya, ada pertimbangan dan penyesuaian yang diperlukan untuk memastikan kinerja optimal. Berikut adalah langkah-langkah terperinci dan wawasan tentang cara mendekati ini untuk model yang berbeda, termasuk Llama 3, GPT-3, dan Mistral.

5.1 Menggunakan Llama 3

Pemilihan Model:

• Pastikan Anda memiliki identifikasi model yang benar dari model hub Hugging Face. Untuk model Llama 3, mungkin diidentifikasi sebagai meta-llama/Meta-Llama-3-8B di Hugging Face.
• Pastikan untuk meminta akses dan masuk ke akun Hugging Face jika diperlukan untuk model seperti Llama 3.

Tokenisasi:

• Gunakan tokenizer yang sesuai untuk Llama 3, memastikan kompatibilitas dengan model dan mendukung fitur yang diperlukan seperti padding dan token spesial.

Memori dan Komputasi:

• Fine-tuning model besar seperti Llama 3 memerlukan sumber daya komputasi yang signifikan. Pastikan lingkungan Anda, seperti setup GPU yang kuat, dapat menangani kebutuhan memori dan pemrosesan.

Contoh:

model_name = 'meta-llama/Meta-Llama-3-8B'
device_map = {"": 0}
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.float16,
bnb_4bit_use_double_quant=True,
)
original_model = AutoModelForCausalLM.from_pretrained(
model_name,
device_map=device_map,
quantization_config=bnb_config,
trust_remote_code=True,
use_auth_token=True
)

5.2 Menggunakan Model Populer Lainnya (misalnya, GPT-3, Mistral)

Pemilihan Model:

• Untuk model seperti GPT-3 dan Mistral, pastikan Anda menggunakan nama model dan identifikasi yang benar dari model hub Hugging Face atau sumber lain.

Tokenisasi:

• Serupa dengan Llama 3, pastikan tokenizer disetup dengan benar dan kompatibel dengan model.

Memori dan Komputasi:

• Setiap model mungkin memiliki kebutuhan memori yang berbeda. Atur lingkungan Anda sesuai dengan kebutuhan.

7. Uji Model dengan Inferensi Zero-Shot

Evaluasi model dasar dengan input sampel:

from transformers import set_seed

set_seed(42)
index = 10
prompt = dataset['test'][index]['dialogue']
formatted_prompt = f"Instruct: Summarize the following conversation.\n{prompt}\nOutput:\n"

# Generate output
def gen(model, prompt, max_length):
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_length=max_length)
return tokenizer.batch_decode(outputs, skip_special_tokens=True)

res = gen(original_model, formatted_prompt, 100)
output = res[0].split('Output:\n')[1]

print(f'INPUT PROMPT:\n{formatted_prompt}')
print(f'MODEL GENERATION - ZERO SHOT:\n{output}')

8. Praproses Dataset

Konversi pasangan dialog-ringkasan menjadi prompt:

def create_prompt_formats(sample):
blurb = "Below is an instruction that describes a task. Write a response that appropriately completes the request."
instruction = "### Instruct: Summarize the below conversation."
input_context = sample['dialogue']
response = f"### Output:\n{sample['summary']}"
end = "### End"

parts = [blurb, instruction, input_context, response, end]
formatted_prompt = "\n\n".join(parts)
sample["text"] = formatted_prompt
return sample

dataset = dataset.map(create_prompt_formats)

Tokenisasi dataset yang diformat:

def preprocess_batch(batch, tokenizer, max_length):
return tokenizer(batch["text"], max_length=max_length, truncation=True)

max_length = 1024
train_dataset = dataset["train"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)
eval_dataset = dataset["validation"].map(lambda batch: preprocess_batch(batch, tokenizer, max_length), batched=True)

Hyperparameter dan Dampaknya

Hyperparameter memainkan peran kunci dalam mengoptimalkan kinerja model. Berikut adalah beberapa hyperparameter kunci untuk dipertimbangkan:

1. Learning Rate: Mengontrol kecepatan pembaruan parameter model. Tingkat pembelajaran yang tinggi mungkin mengarah pada konvergensi yang lebih cepat tetapi dapat melebihi solusi optimal. Tingkat pembelajaran yang rendah memastikan konvergensi yang stabil tetapi mungkin memerlukan lebih banyak epoch.
2. Ukuran Batch: Jumlah sampel yang diproses sebelum model memperbarui parameter. Ukuran batch yang lebih besar dapat meningkatkan stabilitas tetapi memerlukan lebih banyak memori. Ukuran batch yang lebih kecil mungkin mengarah pada proses pelatihan yang lebih berisik.
3. Langkah Akumulasi Gradien: Parameter ini membantu mensimulasikan ukuran batch yang lebih besar dengan mengakumulasikan gradien selama beberapa langkah sebelum melakukan pembaruan parameter.
4. Jumlah Epoch: Jumlah kali dataset seluruhnya dilewatkan melalui model. Lebih banyak epoch dapat meningkatkan kinerja tetapi mungkin mengarah pada overfitting jika tidak dikelola dengan baik.
5. Penurunan Berat: Teknik regulasi untuk mencegah overfitting dengan menghukum bobot yang besar.
6. Jadwal Pembelajaran: Menyesuaikan tingkat pembelajaran selama pelatihan untuk meningkatkan kinerja dan konvergensi.

Sesuaikan konfigurasi pelatihan dengan menyesuaikan hyperparameter seperti tingkat pembelajaran, ukuran batch, dan langkah akumulasi gradien berdasarkan kebutuhan model dan tugas spesifik. Misalnya, model Llama 3 mungkin memerlukan tingkat pembelajaran yang berbeda dibandingkan dengan model yang lebih kecil.

Contoh Konfigurasi Pelatihan

orpo_args = ORPOConfig(
learning_rate=8e-6,
lr_scheduler_type="linear",max_length=1024,max_prompt_length=512,
beta=0.1,per_device_train_batch_size=2,per_device_eval_batch_size=2,
gradient_accumulation_steps=4,optim="paged_adamw_8bit",num_train_epochs=1,
evaluation_strategy="steps",eval_steps=0.2,logging_steps=1,warmup_steps=10,
report_to="wandb",output_dir="./results/",
)

10. Pelatihan Model

Atur pelatih dan mulai pelatihan:

trainer = ORPOTrainer(
model=original_model,
args=orpo_args,
train_dataset=train_dataset,
eval_dataset=eval_dataset,
tokenizer=tokenizer,
)
trainer.train()
trainer.save_model("fine-tuned-llama-3")

Mengevaluasi Model yang Di-Fine-Tune

Setelah pelatihan, evaluasi kinerja model menggunakan metode kualitatif dan kuantitatif.

1. Evaluasi Manusia

Bandikan ringkasan yang dihasilkan dengan ringkasan yang ditulis oleh manusia untuk menilai kualitas.

2. Evaluasi Kuantitatif

Gunakan metrik seperti ROUGE untuk menilai kinerja:

from rouge_score import rouge_scorer

scorer = rouge_scorer.RougeScorer(['rouge1', 'rouge2', 'rougeL'], use_stemmer=True)
scores = scorer.score(reference_summary, generated_summary)
print(scores)

Tantangan Umum dan Solusi

1. Keterbatasan Memori

Menggunakan QLoRA membantu mengatasi masalah memori dengan mengkuantifikasi bobot model ke 4-bit. Pastikan Anda memiliki cukup memori GPU untuk menangani ukuran batch dan ukuran model.

2. Overfitting

Monitor metrik validasi untuk mencegah overfitting. Gunakan teknik seperti penghentian awal dan penurunan berat.

3. Pelatihan yang Lambat

Optimalkan kecepatan pelatihan dengan menyesuaikan ukuran batch, tingkat pembelajaran, dan menggunakan akumulasi gradien.

4. Kualitas Data

Pastikan dataset Anda bersih dan diproses dengan baik. Kualitas data yang buruk dapat secara signifikan mempengaruhi kinerja model.

Kesimpulan

Fine-tuning LLM menggunakan QLoRA adalah cara yang efisien untuk menyesuaikan model pra-dilatih besar untuk tugas spesifik dengan biaya komputasi yang berkurang. Dengan mengikuti panduan ini, Anda dapat fine-tune PHI, Llama 3 atau model open-source lainnya untuk mencapai kinerja tinggi pada tugas spesifik.