Panduan Tunggal yang Anda Butuhkan untuk Fine-Tuning Llama 3 atau Model Open Source Lainnya

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

Ringkasan Fine-Tuning

Fine-tuning melibatkan beberapa langkah kunci:

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

Konsep dan Teknik

Fine-tuning Model Bahasa Besar

Full Fine-Tuning

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

Parameter-Efisien 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 mengkuantisasi 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 yang mahal dan memerlukan memori yang signifikan.
2. Parameter Efisien 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?

Membandingkan metode fine-tuning: QLORA meningkatkan LoRA dengan kuantisasi presisi 4-bit dan pengoptimal paged untuk manajemen lonjakan memori

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

Kelebihan Utama LoRA:

• Efisiensi Memori: LoRA mengurangi jejak memori dengan melakukan fine-tuning hanya 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 satu langkah lebih lanjut dengan mengkuantisasi bobot adapter LoRA ke presisi yang lebih rendah (misalnya, 4-bit bukan 8-bit). Ini lebih mengurangi penggunaan memori dan kebutuhan penyimpanan sambil mempertahankan tingkat efektivitas yang setara.

Kelebihan Utama QLoRA:

• Lebih Efisien Memori: Dengan mengkuantisasi 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, membantunya 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 yang 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: Pasang perpustakaan yang diperlukan dan siapkan lingkungan komputasi.
2. Muat dan Olah Dataset: Muat dataset dan olah menjadi format yang sesuai untuk model.
3. Muat Model Pra-Latih: 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

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

1. Pasang Perpustakaan yang Diperlukan

Pastikan Anda memiliki perpustakaan yang diperlukan terpasang:

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

2. Impor Perpustakaan dan Siapkan 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

Kami akan menggunakan dataset DialogSum untuk tutorial ini:

Olah dataset sesuai dengan kebutuhan model, termasuk menerapkan template yang sesuai dan memastikan format data sesuai untuk fine-tuning​ (Hugging Face)​​ (DataCamp)​.

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

Periksa struktur dataset:

print(dataset['test'][0])

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-Latih

Menggunakan model Phi-2 dari Microsoft 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 Lain

Ketika fine-tuning model seperti Llama 3 atau model LLM lainnya yang canggih dan open-source, ada pertimbangan dan penyesuaian tertentu 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 identifier model yang benar dari hub model Hugging Face. Misalnya, 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​ (Hugging Face)​​

Tokenisasi:

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

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. Pastikan lingkungan dapat menangani kebutuhan memori, yang dapat dimitigasi dengan menggunakan teknik seperti QLoRA untuk mengurangi jejak memori​ (Hugging Face Forums)

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
)

Tokenisasi:

Tergantung pada kasus penggunaan dan kebutuhan model yang spesifik, pastikan konfigurasi tokenizer yang benar tanpa pengaturan yang berlebihan. Misalnya, use_fast=True direkomendasikan untuk kinerja yang lebih baik​ (Hugging Face)​​ (GitHub)​.

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

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

Pemilihan Model:

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

Tokenisasi:

• Serupa dengan Llama 3, pastikan tokenizer yang digunakan kompatibel dengan model.

Memori dan Komputasi:

• Setiap model mungkin memiliki kebutuhan memori yang berbeda. Sesuaikan setup lingkungan Anda sesuai dengan itu.

Contoh untuk GPT-3:

model_name = 'openai/gpt-3'
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
)

Contoh untuk Mistral:

model_name = 'mistral-7B'
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
)

Pertimbangan Tokenisasi: Setiap model mungkin memiliki kebutuhan tokenisasi yang unik. Pastikan tokenizer sesuai dengan model dan dikonfigurasi dengan benar.

Contoh Tokenizer Llama 3:

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

Contoh Tokenizer GPT-3 dan Mistral:

tokenizer = AutoTokenizer.from_pretrained(
model_name,
use_fast=True
)

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. Olah 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)

Siapkan model untuk fine-tuning parameter-efisien:

original_model = prepare_model_for_kbit_training(original_model)

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

1. Learning Rate: Mengontrol kecepatan di mana model memperbarui parameter. Learning rate yang tinggi mungkin mengarah pada konvergensi yang lebih cepat tetapi dapat melebihi solusi optimal. Learning rate 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 lebih banyak noise dalam proses pelatihan.
3. Langkah Akumulasi Gradien: Parameter ini membantu dalam mensimulasikan ukuran batch yang lebih besar dengan mengakumulasi gradien selama beberapa langkah sebelum melakukan pembaruan parameter.
4. Jumlah Epoch: Jumlah kali seluruh dataset 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 Learning Rate: Menyesuaikan learning rate selama pelatihan untuk meningkatkan kinerja dan konvergensi.

Sesuaikan konfigurasi pelatihan dengan menyesuaikan hyperparameter seperti learning rate, ukuran batch, dan langkah akumulasi gradien berdasarkan kebutuhan model dan tugas yang spesifik. Misalnya, model Llama 3 mungkin memerlukan learning rate yang berbeda dibandingkan dengan model yang lebih kecil​ (Weights & Biases)​​ (GitHub)​

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. Latih 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-tuning

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

1. Evaluasi Manusia

Bandikan ringkasan yang dihasilkan dengan ringkasan yang ditulis 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 mengkuantisasi 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 early stopping dan penurunan berat.

3. Pelatihan yang Lambat

Optimalkan kecepatan pelatihan dengan menyesuaikan ukuran batch, learning rate, dan menggunakan langkah akumulasi gradien.

4. Kualitas Data

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

Kesimpulan

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