Large Language Models (LLM) adalah komponen utama aplikasi kecerdasan buatan modern, khususnya untuk pemrosesan bahasa alami. Model ini mampu memproses dan memahami bahasa manusia secara efisien, dengan aplikasi mulai dari asisten virtual dan penerjemahan mesin hingga peringkasan teks dan tanya jawab.
Pustaka seperti LangChain memudahkan penerapan aplikasi AI end-to-end seperti yang disebutkan di atas. Tutorial kami Pengenalan LangChain untuk Data Engineering & Aplikasi Data memberikan gambaran umum tentang apa yang dapat Anda lakukan dengan LangChain, termasuk masalah yang diselesaikan LangChain, beserta contoh kasus penggunaan data.
Artikel ini akan menjelaskan seluruh proses pelatihan large language model, mulai dari menyiapkan workspace hingga implementasi akhir menggunakan Pytorch 2.0.1, sebuah kerangka deep learning yang dinamis dan fleksibel yang memungkinkan implementasi model dengan mudah dan jelas.
Prasyarat
Agar mendapatkan manfaat maksimal dari konten ini, penting untuk Anda nyaman dengan pemrograman Python, memiliki pemahaman dasar tentang konsep deep learning dan transformer, serta akrab dengan kerangka Pytorch. Kode sumber lengkap tersedia di GitHub.
Sebelum masuk ke implementasi inti, kita perlu memasang dan mengimpor pustaka yang relevan. Selain itu, penting untuk dicatat bahwa skrip pelatihan terinspirasi dari repositori ini dari Hugging Face.
Instalasi pustaka
Proses instalasi dijelaskan di bawah ini:
Pertama, kita menggunakan pernyataan %%bash untuk menjalankan perintah instalasi dalam satu sel sebagai perintah bash di Jupyter Notebook.
- Trl: digunakan untuk melatih model bahasa berbasis transformer dengan reinforcement learning.
- Peft menggunakan metode parameter-efficient fine-tuning (PEFT) untuk memungkinkan adaptasi model pra-latih secara efisien.
- Torch: pustaka machine learning open-source yang banyak digunakan.
- Datasets: digunakan untuk membantu mengunduh dan memuat banyak dataset machine learning yang umum.
Transformers: pustaka yang dikembangkan oleh Hugging Face dan menyertakan ribuan model pra-latih untuk berbagai tugas berbasis teks seperti klasifikasi, peringkasan, dan penerjemahan.
%%bash
pip -q install trl
pip -q install peft
pip -q install torch
pip -q install datasets
pip -q install transformers
Sekarang, modul-modul tersebut dapat diimpor sebagai berikut:
import torch
from trl import SFTTrainer
from datasets import load_dataset
from peft import LoraConfig, get_peft_model, prepare_model_for_int8_training
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArgumentsPemuatan dan Persiapan Data
Dataset alpaca, yang tersedia gratis di Hugging Face, akan digunakan untuk ilustrasi ini. Dataset ini memiliki tiga kolom utama: instructions, input, dan output. Kolom-kolom tersebut digabungkan untuk menghasilkan kolom teks final.
Instruksi untuk memuat dataset diberikan di bawah ini dengan menyediakan nama dataset yang diinginkan, yaitu tatsu-lab/alpaca:
train_dataset = load_dataset("tatsu-lab/alpaca", split="train")
print(train_dataset)Kita dapat melihat bahwa data yang dihasilkan berbentuk dictionary dengan dua kunci:
- Features: berisi kolom-kolom utama data
- Num_rows: menunjukkan total jumlah baris dalam data
Struktur train_dataset
Lima baris pertama dapat ditampilkan dengan instruksi berikut. Pertama, ubah dictionary menjadi dataframe pandas, lalu tampilkan baris-barisnya.
pandas_format = train_dataset.to_pandas()
display(pandas_format.head())
Lima baris pertama train_dataset
Untuk visualisasi yang lebih baik, mari cetak informasi tentang tiga baris pertama, tetapi sebelum itu, kita perlu memasang pustaka textwrap untuk mengatur jumlah maksimum kata per baris menjadi 50. Pernyataan print pertama memisahkan setiap blok dengan 15 tanda hubung.
import textwrap
for index in range(3):
print("---"*15)
print("Instruction:
{}".format(textwrap.fill(pandas_format.iloc[index]["instruction"],
width=50)))
print("Output:
{}".format(textwrap.fill(pandas_format.iloc[index]["output"],
width=50)))
print("Text:
{}".format(textwrap.fill(pandas_format.iloc[index]["text"],
width=50)))
Rincian tiga baris pertama
Pelatihan Model
Sebelum melanjutkan untuk melatih model, kita perlu menyiapkan beberapa prasyarat:
- Model Pra-latih: Kita akan menggunakan model pra-latih Salesforce/xgen-7b-8k-base, yang tersedia di Hugging Face. Salesforce melatih serangkaian LLM 7B bernama XGen-7B dengan dense attention standar pada urutan hingga 8K untuk hingga 1,5T token.
- Tokenizer: Ini diperlukan untuk tugas tokenisasi pada data pelatihan. Kode untuk memuat model pra-latih dan tokenizer adalah sebagai berikut:
pretrained_model_name = "Salesforce/xgen-7b-8k-base"
model = AutoModelForCausalLM.from_pretrained(pretrained_model_name, torch_dtype=torch.bfloat16)
tokenizer = AutoTokenizer.from_pretrained(pretrained_model_name, trust_remote_code=True)Konfigurasi pelatihan
Pelatihan memerlukan sejumlah argumen dan konfigurasi, dan dua objek konfigurasi penting didefinisikan di bawah ini, sebuah instance TrainingArguments, sebuah instance model LoraConfig, dan terakhir model SFTTrainer.
TrainingArguments
Ini digunakan untuk mendefinisikan parameter pelatihan model.
Dalam skenario ini, kita mulai dengan mendefinisikan tujuan penyimpanan model terlatih menggunakan atribut output_dir sebelum mendefinisikan hyperparameter tambahan, seperti metode optimisasi, learning rate, jumlah epoch, dan lainnya.
model_training_args = TrainingArguments(
output_dir="xgen-7b-8k-base-fine-tuned",
per_device_train_batch_size=4,
optim="adamw_torch",
logging_steps=80,
learning_rate=2e-4,
warmup_ratio=0.1,
lr_scheduler_type="linear",
num_train_epochs=1,
save_strategy="epoch"
)LoRAConfig
Argumen utama yang digunakan untuk skenario ini adalah rank dari matriks transformasi low-rank di LoRA, yang ditetapkan ke 16. Kemudian, faktor penskalaan untuk parameter tambahan di LoRA ditetapkan ke 32.
Selain itu, rasio dropout adalah 0,05, yang berarti 5% unit input akan diabaikan selama pelatihan. Terakhir, karena kita menangani causal language modeling, tugasnya diinisialisasi dengan atribut CAUSAL_LM.
SFTTrainer
Tujuannya adalah melatih model menggunakan data pelatihan, tokenizer, dan informasi tambahan seperti model di atas.
Karena kita menggunakan field text dari data pelatihan, penting untuk melihat distribusinya guna membantu menetapkan jumlah maksimum token dalam suatu urutan.
import matplotlib.pyplot as plt
pandas_format['text_length'] = pandas_format['text'].apply(len)
plt.figure(figsize=(10,6))
plt.hist(pandas_format['text_length'], bins=50, alpha=0.5, color='g')
plt.title('Distribution of Length of Text')
plt.xlabel('Length of Text')
plt.ylabel('Frequency')
plt.grid(True)
plt.show()
Distribusi panjang kolom teks
Berdasarkan pengamatan di atas, kita dapat melihat bahwa mayoritas teks memiliki panjang antara 0 dan 1000. Selain itu, terlihat di bawah bahwa hanya 4,5% dokumen teks yang memiliki panjang lebih dari 1024.
mask = pandas_format['text_length'] > 1024
percentage = (mask.sum() / pandas_format['text_length'].count()) * 100
print(f"The percentage of text documents with a length greater than 1024 is: {percentage}%")
Kemudian kita menetapkan jumlah maksimum token dalam urutan menjadi 1024 sehingga teks yang lebih panjang dari itu akan dipotong.
SFT_trainer = SFTTrainer(
model=model,
train_dataset=train_dataset,
dataset_text_field="text",
max_seq_length=1024,
tokenizer=tokenizer,
args=model_training_args,
packing=True,
peft_config=lora_peft_config,
)Eksekusi pelatihan
Dengan semua prasyarat siap, kita sekarang dapat menjalankan proses pelatihan model sebagai berikut:
tokenizer.pad_token = tokenizer.eos_token
model.resize_token_embeddings(len(tokenizer))
model = prepare_model_for_int8_training(model)
model = get_peft_model(model, lora_peft_config)
training_args = model_training_args
trainer = SFT_trainer
trainer.train()Penting untuk disebutkan bahwa pelatihan ini dilakukan di lingkungan cloud dengan GPU, yang membuat keseluruhan proses pelatihan lebih cepat. Namun, pelatihan di komputer lokal akan membutuhkan waktu lebih lama untuk diselesaikan.
Blog kami, Kelebihan dan Kekurangan Menggunakan LLM di Cloud vs Menjalankan LLM Secara Lokal, memberikan pertimbangan utama untuk memilih strategi penerapan LLM yang optimal
Mari pahami apa yang terjadi pada cuplikan kode di atas:
- tokenizer.pad_token = tokenizer.eos_token: Menetapkan token padding sama dengan token akhir kalimat.
- model.resize_token_embeddings(len(tokenizer)): Mengubah ukuran layer embedding token pada model agar sesuai dengan panjang kosakata tokenizer.
- model = prepare_model_for_int8_training(model): Mempersiapkan model untuk pelatihan dengan presisi INT8, kemungkinan dengan melakukan kuantisasi.
- model = get_peft_model(model, lora_peft_config): Menyesuaikan model sesuai konfigurasi PEFT yang diberikan.
- training_args = model_training_args: Menetapkan argumen pelatihan yang telah didefinisikan ke training_args.
- trainer = SFT_trainer: Menetapkan instance SFTTrainer ke variabel trainer.
- trainer.train(): Memicu proses pelatihan model sesuai spesifikasi yang diberikan.
Kesimpulan
Artikel ini memberikan panduan jelas untuk melatih large language model menggunakan PyTorch. Dimulai dari penyiapan dataset, dilanjutkan dengan langkah-langkah menyiapkan prasyarat, menyusun trainer, dan akhirnya menjalankan proses pelatihan.
Meskipun menggunakan dataset dan model pra-latih tertentu, prosesnya pada dasarnya sama untuk opsi kompatibel lainnya. Sekarang setelah Anda memahami cara melatih LLM, Anda dapat memanfaatkan pengetahuan ini untuk melatih model canggih lainnya untuk berbagai tugas NLP.
Lihat panduan kami tentang cara membangun aplikasi LLM dengan LangChain untuk mengeksplorasi lebih jauh kekuatan large language model. Atau, jika Anda masih perlu mempelajari konsep large language model, lihat kursus kami untuk memperdalam pembelajaran Anda.
