Cara Menggunakan Hugging Face AutoTrain untuk Fine-tune LLM

Pendahuluan

Dalam beberapa tahun terakhir, Large Language Model (LLM) telah mengubah cara orang bekerja dan digunakan di banyak bidang, seperti pendidikan, pemasaran, penelitian, dan lain-lain. Dengan potensinya yang besar, LLM dapat ditingkatkan untuk memecahkan masalah bisnis dengan lebih baik. Inilah mengapa kita bisa melakukan fine-tuning LLM.

Kita ingin fine-tuning LLM karena beberapa alasan, diantaranya: mengadopsi kasus penggunaan domain tertentu, meningkatkan akurasi, privasi dan keamanan data, mengontrol bias model, dan masih banyak lagi. Dengan semua manfaat ini, penting untuk belajar cara fine-tuning LLM kita agar dapat digunakan dalam produksi.

Salah satu cara untuk melakukan fine-tuning LLM secara otomatis adalah dengan menggunakan AutoTrain dari Hugging Face. HF AutoTrain adalah platform tanpa kode dengan API Python untuk melatih model canggih untuk berbagai tugas seperti Computer Vision, Tabular, dan NLP. Kita dapat menggunakan kemampuan AutoTrain meskipun kita tidak begitu memahami proses fine-tuning LLM.

Jadi, bagaimana cara kerjanya? Mari kita jelajahi lebih lanjut.

Pengenalan AutoTrain

Meskipun HF AutoTrain menawarkan solusi tanpa kode, kita masih dapat mengembangkannya lebih lanjut menggunakan API Python dari AutoTrain. Karena platform tanpa kode belum stabil untuk pelatihan, kami akan lebih fokus pada pengembangan kode.

Namun, jika Anda tetap ingin menggunakan platform tanpa kode, Anda dapat membuat space AutoTrain menggunakan halaman berikut. Tampilan keseluruhan platform dapat dilihat pada gambar di bawah ini.

Untuk fine-tune LLM dengan API Python, kita perlu menginstal paket Python, yang dapat dijalankan menggunakan kode berikut.

pip install -U autotrain-advanced

Selain itu, kita akan menggunakan contoh dataset Alpaca dari HuggingFace, yang memerlukan paket datasets untuk diakuisisi.

pip install datasets

Kemudian, gunakan kode berikut untuk mendapatkan data yang kita butuhkan.

from datasets import load_dataset 

# Muat dataset
dataset = load_dataset("tatsu-lab/alpaca") 
train = dataset['train']

Selain itu, kita akan menyimpan data dalam format CSV karena kita membutuhkannya untuk fine-tuning.

train.to_csv('train.csv', index = False)

Dengan lingkungan dan dataset yang sudah siap, mari kita coba gunakan HuggingFace AutoTrain untuk melakukan fine-tuning pada LLM kita.

Prosedur Fine-tuning dan Evaluasi

Saya akan mengadaptasi proses fine-tuning dari sampel AutoTrain, yang dapat kita temukan di sini. Untuk memulai prosesnya, kita menaruh data yang akan digunakan untuk fine-tune dalam folder bernama data.

Untuk tutorial ini, saya mencoba mengambil sampel hanya dari 100 baris data sehingga proses training bisa lebih cepat. Setelah data kita siap, kita bisa menggunakan Jupyter Notebook untuk fine-tune model kita. Pastikan data berisi kolom text karena AutoTrain hanya akan membaca dari kolom itu saja.

Pertama, jalankan setup AutoTrain menggunakan perintah berikut.

!autotrain setup

Selanjutnya, kita akan memberikan informasi yang diperlukan untuk menjalankan AutoTrain. Informasi berikut adalah tentang nama proyek dan model pre-trained yang kita inginkan. Anda hanya dapat memilih model yang tersedia di HuggingFace.

project_name = 'my_autotrain_llm'
model_name = 'tiiuae/falcon-7b'

Kemudian kita akan menambahkan informasi HF, jika Anda ingin push model ke repositori atau menggunakan model private.

push_to_hub = False
hf_token = "YOUR HF TOKEN"
repo_id = "username/repo_name"

Terakhir, kita akan menginisiasi informasi parameter model dengan variabel di bawah ini. Anda dapat mengubahnya sesuai keinginan untuk melihat apakah hasilnya bagus atau tidak.

learning_rate = 2e-4
num_epochs = 4
batch_size = 1
block_size = 1024
trainer = "sft"
warmup_ratio = 0.1
weight_decay = 0.01
gradient_accumulation = 4
use_fp16 = True
use_peft = True
use_int4 = True
lora_r = 16
lora_alpha = 32
lora_dropout = 0.045

Dengan semua informasi yang telah siap, kita akan mengatur lingkungan untuk menerima semua informasi yang telah kita atur sebelumnya.

import os
os.environ["PROJECT_NAME"] = project_name
os.environ["MODEL_NAME"] = model_name
os.environ["PUSH_TO_HUB"] = str(push_to_hub)
os.environ["HF_TOKEN"] = hf_token
os.environ["REPO_ID"] = repo_id
os.environ["LEARNING_RATE"] = str(learning_rate)
os.environ["NUM_EPOCHS"] = str(num_epochs)
os.environ["BATCH_SIZE"] = str(batch_size)
os.environ["BLOCK_SIZE"] = str(block_size)
os.environ["WARMUP_RATIO"] = str(warmup_ratio)
os.environ["WEIGHT_DECAY"] = str(weight_decay)
os.environ["GRADIENT_ACCUMULATION"] = str(gradient_accumulation)
os.environ["USE_FP16"] = str(use_fp16)
os.environ["USE_PEFT"] = str(use_peft)
os.environ["USE_INT4"] = str(use_int4)
os.environ["LORA_R"] = str(lora_r)
os.environ["LORA_ALPHA"] = str(lora_alpha)
os.environ["LORA_DROPOUT"] = str(lora_dropout)

Untuk menjalankan AutoTrain di notebook kita, gunakan perintah berikut.

!autotrain llm \
--train \
--model ${MODEL_NAME} \
--project-name ${PROJECT_NAME} \
--data-path data/ \
--text-column text \
--lr ${LEARNING_RATE} \
--batch-size ${BATCH_SIZE} \
--epochs ${NUM_EPOCHS} \
--block-size ${BLOCK_SIZE} \
--warmup-ratio ${WARMUP_RATIO} \
--lora-r ${LORA_R} \
--lora-alpha ${LORA_ALPHA} \
--lora-dropout ${LORA_DROPOUT} \
--weight-decay ${WEIGHT_DECAY} \
--gradient-accumulation ${GRADIENT_ACCUMULATION} \
$( [[ "$USE_FP16" == "True" ]] && echo "--fp16" ) \
$( [[ "$USE_PEFT" == "True" ]] && echo "--use-peft" ) \
$( [[ "$USE_INT4" == "True" ]] && echo "--use-int4" ) \
$( [[ "$PUSH_TO_HUB" == "True" ]] && echo "--push-to-hub --token ${HF_TOKEN} --repo-id ${REPO_ID}" )

Jika Anda menjalankan AutoTrain dengan benar, Anda akan menemukan folder berikut di direktori Anda dengan semua model dan tokenizer yang diproduksi oleh AutoTrain.

Untuk menguji model, kita akan menggunakan paket transformers dari HuggingFace dengan kode berikut.

from transformers import AutoModelForCausalLM, AutoTokenizer

model_path = "my_autotrain_llm"
tokenizer = AutoTokenizer.from_pretrained(model_path)
model = AutoModelForCausalLM.from_pretrained(model_path)

Kemudian, kita dapat mencoba mengevaluasi model kita berdasarkan input training yang telah kita berikan. Misalnya, kita menggunakan “Health benefits of regular exercise” sebagai input.

input_text = "Health benefits of regular exercise"
input_ids = tokenizer.encode(input_text, return_tensors="pt")
output = model.generate(input_ids)
predicted_text = tokenizer.decode(output[0], skip_special_tokens=False)
print(predicted_text)

Hasilnya tentu masih bisa lebih baik, tetapi setidaknya sudah mendekati data sampel yang telah kita berikan. Kita bisa mencoba bermain-main dengan model pre-trained dan parameter untuk meningkatkan fine-tuning.

Tips untuk Fine-tuning yang Sukses

Ada beberapa best practices yang mungkin ingin Anda ketahui untuk meningkatkan proses fine-tuning, termasuk:

1. Persiapkan dataset dengan kualitas yang sesuai dengan tugas representatif,

2. Mempelajari model pre-trained yang kita gunakan,

3. Menggunakan teknik regularisasi yang tepat untuk menghindari overfitting,

4. Mencoba learning rate dari yang kecil dan secara bertahap menjadi lebih besar,

5. Menggunakan epoch lebih sedikit karena pelatihan LLM biasanya belajar data baru dengan cukup cepat,

6. Tidak mengabaikan biaya komputasi, karena akan menjadi lebih mahal dengan data, parameter, dan model yang lebih besar,

7. Pastikan Anda mengikuti pertimbangan etis terkait data yang Anda gunakan.

8. 
   

Kesimpulan

Fine-tuning Large Language Model bermanfaat bagi proses bisnis kita, terutama jika ada persyaratan tertentu yang kita butuhkan. Dengan HuggingFace AutoTrain, kita dapat mempercepat proses training dan dengan mudah menggunakan model pre-trained yang tersedia untuk menyempurnakan model.