Penyetelan Halus Efisien Parameter dengan LoRA Menggunakan Data Kustom

Model Bahasa Besar telah mengubah cara kita membangun aplikasi, menulis konten, dan mengotomatisasi tugas sehari-hari. Namun, bahkan LLM yang paling canggih dilatih untuk menjadi sistem serba guna. Mereka tidak secara alami memahami dokumentasi internal Anda, suara merek Anda, atau dokumentasi perusahaan Anda. Rekayasa prompt dapat membantu sampai tingkat tertentu, tetapi prompt menjadi lebih panjang, rapuh, dan tidak konsisten seiring waktu.

Salah satu cara adalah dengan membangun model sendiri menggunakan data Anda sendiri, atau jalan pintas lainnya adalah penyetelan model. Penyetelan Model menawarkan solusi yang lebih kuat dengan memungkinkan model menyesuaikan perilakunya berdasarkan contoh. Di antara teknik penyetelan modern, LoRA muncul sebagai salah satu cara paling praktis dan hemat biaya untuk mengajarkan sesuatu yang baru kepada LLM.

Artikel ini menjelaskan LoRA, memperjelas apa sebenarnya yang dimaksud dengan fine-tuning LoRA, dan membahas implementasi lengkap menggunakan data kustom, termasuk kode dan panduan praktis.

Intisari Penting

LoRA memungkinkan penyetelan halus yang efisien secara parameter dengan membekukan model dasar dan melatih hanya sejumlah kecil bobot adaptor berperingkat rendah, secara signifikan mengurangi kebutuhan komputasi dan memori.
Pendekatan ini mempertahankan kemampuan penalaran umum dari model bahasa besar sambil mengubah perilaku, nada, dan struktur model ke domain tertentu.
Fine-tuning LoRA paling cocok untuk adaptasi perilaku dan tugas daripada untuk memasukkan sejumlah besar pengetahuan faktual baru.
Dataset yang berkualitas tinggi dan terstruktur dengan baik memiliki pengaruh lebih besar terhadap kinerja LoRA dibandingkan dengan sekadar ukuran dataset.
Adaptor LoRA ringan dan modular, sehingga memungkinkan untuk mempertahankan berbagai perilaku spesifik domain menggunakan satu model dasar.
LoRA terintegrasi dengan baik dengan teknik berbasis pengambilan, seperti RAG, sehingga memungkinkan sistem yang skalabel yang menggabungkan perilaku yang dipelajari dengan akses pengetahuan yang dinamis.
Biaya rendah dan siklus iterasi cepat dari LoRA membuatnya sangat cocok untuk eksperimen, pembuatan prototipe, dan penerapan produksi.

Memahami LoRA secara Lebih Mendalam

LoRA, yang merupakan singkatan dari Low-Rank Adaptation, adalah metode fine-tuning yang efisien dalam penggunaan parameter yang dirancang khusus untuk jaringan saraf besar seperti transformer. Fine-tuning tradisional memerlukan pembaruan semua bobot model, yang memakan banyak komputasi dan memori ketika menangani model yang memiliki miliaran parameter. LoRA menghindari hal ini dengan membekukan seluruh bobot model asli dan memperkenalkan sejumlah kecil parameter baru yang dapat dilatih untuk mempelajari cara menyesuaikan perilaku model.

Di dalam model transformer, sebagian besar kapasitas pembelajaran berasal dari perkalian matriks besar, terutama pada lapisan perhatian. LoRA bekerja dengan mendekati pembaruan pada matriks-matriks besar ini menggunakan dua matriks yang jauh lebih kecil yang hasil perkaliannya mewakili perubahan yang dibutuhkan untuk tugas tersebut.

Karena matriks-matriks ini memiliki peringkat rendah, jumlah parameter yang perlu dilatih berkurang secara drastis. Model dasar tetap tidak berubah, mempertahankan pengetahuan umumnya, sementara lapisan LoRA menyesuaikannya untuk tugas atau domain baru.

Sumber Gambar

Salah satu aspek paling kuat dari LoRA adalah bahwa adaptasi ini bersifat modular. Satu model dasar bisa mendukung beberapa adapter LoRA, masing-masing dilatih untuk tujuan yang berbeda, dan mereka dapat dipasang dan dilepas tanpa perlu melatih ulang atau menerapkan kembali seluruh model.

Apa Sebenarnya Arti Fine-Tuning LoRA

Fine-tuning LoRA mengacu pada proses melatih hanya lapisan adaptor LoRA pada dataset khusus sambil menjaga model bahasa dasar tetap membeku. Alih-alih mengajarkan model segala sesuatu dari awal, Anda membimbingnya ke perilaku tertentu dengan menyesuaikan cara pemrosesan informasi di lapisan kunci. Pendekatan ini sangat efektif ketika tujuannya adalah memodifikasi gaya penulisan, struktur respons, nada, atau pemahaman domain daripada memasukkan sejumlah besar pengetahuan faktual baru.

Ketika Anda melakukan fine-tune dengan LoRA, model mempelajari pola dari contoh-contoh Anda dan menginternalisasikannya dalam bobot adapter. Saat inferensi, model menggabungkan pengetahuan aslinya dengan adaptasi yang telah dipelajari, menghasilkan keluaran yang terasa alami di domain Anda sambil tetap mempertahankan kemampuan penalaran umum.

Ini secara fundamental berbeda dari pendekatan berbasis pengambilan seperti RAG, di mana dokumen eksternal diambil saat runtime. Fine-tuning LoRA mengubah cara model berperilaku, sedangkan RAG mengubah apa yang dapat diakses oleh model.

Mempersiapkan Data Kustom untuk Fine-Tuning LoRA

Kualitas model yang telah disesuaikan dengan LoRA sebagian besar ditentukan oleh kualitas data pelatihan. Karena LoRA bergantung pada lebih sedikit parameter, model ini sangat sensitif terhadap ketidakkonsistenan, kebisingan, dan contoh yang disusun dengan buruk. Dataset yang paling efektif diformat sebagai pasangan instruksi-respons atau percakapan chat yang sangat mirip dengan cara model akan digunakan dalam produksi.

Setiap contoh harus jelas menunjukkan perilaku yang ingin Anda model pelajari. Jika tugasnya melibatkan ringkasan, penjelasan, atau penulisan khusus domain, output harus konsisten dalam nada, panjang, dan struktur. Contoh yang berulang atau bertentangan harus dihindari karena dapat membingungkan adapter dan mengurangi kemampuan generalisasi.

Pelatihan Praktis LoRA Fine-Tuning Qwen pada Dataset Kustom

Dalam bagian ini, kita akan menyempurnakan model instruksi Qwen menggunakan LoRA untuk mengajarkannya pengetahuan khusus tentang Linux-Console.net. Tujuannya adalah untuk mengajarkan model tentang Linux-Console.net sehingga dapat dengan percaya diri menjawab pertanyaan ala dukungan pelanggan mengenai GPU Droplets, akses SSH, dan alur kerja VS Code, tanpa harus melatih ulang seluruh model.

Kami menggunakan dataset JSON yang ringan dan melatih hanya sejumlah kecil parameter menggunakan LoRA, sehingga pendekatan ini efisien bahkan pada satu GPU Droplet.

Tentukan Format Dataset

Qwen bekerja dengan baik pada format pemodelan bahasa kausal sederhana di mana setiap contoh terdiri dari sebuah prompt diikuti oleh penyelesaian yang diharapkan. Setiap sampel pelatihan harus berisi tepat dua kunci: prompt dan completion.

Berikut adalah contoh dataset kustom yang disimpan sebagai digitalocean.json:

{
  "prompt": "What is a Linux-Console.net GPU Droplet?",
  "completion": "A Linux-Console.net GPU Droplet is a cloud virtual machine equipped with NVIDIA GPUs, designed for compute-intensive workloads such as machine learning training, deep learning inference, and large-scale data processing."
}

Contoh lain mungkin terlihat seperti ini:

{
  "prompt": "Why can't I connect to my GPU Droplet using SSH?",
  "completion": "SSH connection issues usually occur due to incorrect usernames, missing SSH keys, or firewall rules blocking port 22. Verifying the Droplet status and SSH configuration typically resolves the issue."
}

Format ini memungkinkan model untuk belajar bagaimana merespons pertanyaan pengguna secara alami, yang sangat ideal untuk asisten bergaya dukungan pelanggan.

Muat Dataset

Setelah dataset siap, kita memuatnya menggunakan pustaka Hugging Face datasets.

from datasets import load_dataset

dataset = load_dataset(
    "json",
    data_files="digitalocean.json"
)

print(dataset["train"][0])

Pada tahap ini, setiap entri masih berupa teks mentah dan harus ditokenisasi sebelum pelatihan.

Tokenisasi dan Prapemrosesan

Model Qwen mengharapkan input yang telah ditokenisasi di mana model memprediksi token berikutnya dalam sebuah urutan. Untuk mencapainya, kami menggabungkan prompt dan penyelesaian menjadi satu string pelatihan dan menggunakan token yang sama sebagai label.

from transformers import AutoTokenizer

model_name = "Qwen/Qwen2.5-3B-Instruct"
tokenizer = AutoTokenizer.from_pretrained(model_name)

def preprocess(example):
    combined_text = example["prompt"] + "\n" + example["completion"]
    
    tokens = tokenizer(
        combined_text,
        max_length=256,
        padding="max_length",
        truncation=True
    )
    
    tokens["labels"] = tokens["input_ids"].copy()
    return tokens

tokenized_data = dataset.map(preprocess)

Dengan menetapkan label sama dengan ID input, kita melatih model dalam pengaturan pemodelan bahasa kausal, di mana model belajar menghasilkan kelanjutan berdasarkan prompt.

Muat Model Qwen Dasar

Selanjutnya, kami memuat model Qwen dasar dengan presisi setengah untuk mengurangi penggunaan memori GPU. Ini sangat penting saat dijalankan pada satu GPU Droplet.

import torch
from transformers import AutoModelForCausalLM

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

Pada saat ini, model masih sepenuhnya dibekukan dan belum disesuaikan dengan pengetahuan khusus Linux-Console.net atau dengan data kustom.

Lampirkan Adapter LoRA

Alih-alih menyetel semua parameter model, kami menambahkan adaptor LoRA pada lapisan perhatian. Adaptor ini akan menjadi satu-satunya komponen yang dapat dilatih selama pelatihan.

from peft import LoraConfig, get_peft_model, TaskType

lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=8,
    lora_alpha=16,
    lora_dropout=0.05,
    target_modules=["q_proj", "k_proj", "v_proj"]
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

Langkah ini biasanya mengurangi jumlah parameter yang dapat dilatih menjadi jauh di bawah satu persen dari ukuran model asli.

Latih Adapter LoRA

Dengan dataset yang sudah disiapkan dan LoRA yang dikonfigurasi, kita dapat melanjutkan dengan pelatihan. Konfigurasi pelatihan di bawah ini sengaja dibuat sederhana dan bekerja dengan baik untuk dataset berukuran kecil hingga menengah.

from transformers import TrainingArguments, Trainer

training_args = TrainingArguments(
    output_dir="./qwen-do-lora",
    num_train_epochs=8,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    learning_rate=2e-4,
    logging_steps=20,
    fp16=True,
    save_strategy="epoch",
    report_to="none"
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_data["train"]
)

trainer.train()

Pelatihan biasanya selesai dalam beberapa menit pada GPU dengan 16 GB VRAM, tergantung pada ukuran dataset dan panjang urutan.

Simpan Adapter yang Telah Disesuaikan

Setelah pelatihan selesai, kami hanya menyimpan adaptor LoRA dan tokenizer. Ini membuat hasilnya ringan dan mudah untuk digunakan.

model.save_pretrained("./qwen-do-lora")
tokenizer.save_pretrained("./qwen-do-lora")

Model dasar tetap tidak berubah dan dapat digunakan kembali untuk adaptor lainnya.

Muat Model yang Disesuaikan untuk Inferensi

Untuk menggunakan model yang telah di-tuning, kami memuat ulang model dasar dan memasang adaptor LoRA yang telah dilatih.

from peft import PeftModel, PeftConfig

adapter_path = "./qwen-do-lora"

config = PeftConfig.from_pretrained(adapter_path)
base_model = AutoModelForCausalLM.from_pretrained(
    config.base_model_name_or_path,
    torch_dtype=torch.float16,
    device_map="auto"
)

model = PeftModel.from_pretrained(base_model, adapter_path)
tokenizer = AutoTokenizer.from_pretrained(adapter_path)

Tanyakan Pertanyaan kepada Model yang Disesuaikan

Sekarang model dapat menjawab pertanyaan berdasarkan dataset kustom Anda yang tidak secara eksplisit dilatih selama pra-pelatihan.

inputs = tokenizer(
    "How does VS Code connect to a Linux-Console.net GPU Droplet?",
    return_tensors="pt"
).to(model.device)

outputs = model.generate(
    input_ids=inputs["input_ids"],
    attention_mask=inputs["attention_mask"],
    max_new_tokens=150
)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

VS Code connects to a Linux-Console.net GPU Droplet using SSH through the Remote SSH extension.
After installing the extension, you configure an SSH host that points to your Droplet’s public IP address and authentication key.
Once connected, VS Code runs commands directly on the remote machine, allowing you to edit files, run training scripts, and monitor GPU workloads as if the environment were local.

Respons akan mencerminkan nada, kejelasan, dan fokus teknis yang dipelajari dari dataset Linux-Console.net Anda.

LoRA, atau fine-tuning adaptasi low-rank, bekerja paling baik ketika dataset disinkronkan dengan penggunaan nyata. Jika data pelatihan terlalu kecil, tidak konsisten, atau salah, model mungkin mengalami overfit atau menghasilkan output yang tidak stabil. Kualitas data pelatihan Anda secara langsung menentukan apa yang dipelajari model dan seberapa baik kinerjanya.

Menyesuaikan peringkat, laju pembelajaran, dan jumlah epoch dapat secara signifikan meningkatkan hasil, tetapi perubahan ini harus selalu divalidasi menggunakan contoh test. Di banyak sistem produksi, LoRA digabungkan dengan RAG untuk menyeimbangkan adaptasi perilaku dengan ketepatan fakta yang terkini.

Pertanyaan yang Sering Diajukan

Apakah fine-tuning LoRA sama dengan fine-tuning penuh?

Tidak, fine-tuning LoRA secara fundamental berbeda dari full fine-tuning. Full fine-tuning memperbarui semua parameter model, yang mahal dan seringkali tidak diperlukan. Namun, fine-tuning LoRA membekukan model dasar dan hanya melatih sejumlah kecil parameter tambahan, membuatnya lebih cepat, lebih murah, dan lebih stabil sambil tetap mencapai adaptasi domain yang kuat.

Berapa banyak data yang saya butuhkan untuk fine-tuning LoRA?

LoRA dapat menghasilkan hasil yang bermakna dengan dataset yang relatif kecil, sering kali hanya beberapa ratus contoh berkualitas tinggi. Faktor kuncinya bukan volume tetapi konsistensi dan relevansi. Contoh yang dikurasi dengan baik dan mencerminkan pola penggunaan nyata jauh lebih efektif daripada dataset besar yang berisik.

Apakah LoRA dapat menambahkan pengetahuan faktual baru ke dalam sebuah model?

LoRA tidak ideal untuk menyuntikkan sejumlah besar informasi faktual baru. LoRA lebih cocok untuk mengajarkan gaya, nada, struktur tugas, dan penalaran khusus domain. Untuk dataset faktual yang sering berubah atau besar, generasi yang ditingkatkan dengan pengambilan data merupakan solusi yang lebih baik.

Model mana yang bekerja terbaik dengan LoRA?

LoRA bekerja dengan baik pada sebagian besar model bahasa kausal berbasis transformer, termasuk Qwen, LLaMA, Mistral, dan DeepSeek. Model dengan lapisan proyeksi perhatian yang jelas sangat mudah diadaptasi menggunakan LoRA, karena lapisan-lapisan ini biasanya menjadi target untuk adapter berperingkat rendah.

Apakah LoRA mempengaruhi kecepatan inferensi?

LoRA menambahkan beban minimal selama inferensi. Karena adapter kecil dan hanya memodifikasi sebagian perhitungan, dampak kinerjanya biasanya dapat diabaikan dibandingkan dengan model dasar. Dalam banyak kasus, kecepatan inferensi tetap hampir sama.

Bisakah saya menggunakan beberapa adaptor LoRA dengan satu model dasar?

Ya. Salah satu kekuatan LoRA adalah modularitas. Anda dapat menjaga beberapa adaptor untuk berbagai domain atau tugas dan memuatnya secara dinamis di atas model dasar yang sama, sehingga tidak perlu menyimpan atau menyebarkan beberapa checkpoint model penuh.

Bagaimana cara saya menilai apakah fine-tuning LoRA berhasil?

Evaluasi sebaiknya fokus pada hasil tugas spesifik daripada tolok ukur umum. Membandingkan respons sebelum dan sesudah penyetelan, menguji pada contoh yang belum digunakan, dan memvalidasi konsistensi perilaku seringkali lebih informatif daripada metrik akurasi mentah.

Apakah LoRA cocok untuk sistem produksi?

Ya, LoRA sangat cocok untuk digunakan dalam produksi. Jejak memorinya yang rendah, waktu pelatihan yang cepat, dan model penyebaran modular membuatnya lebih mudah untuk versi, memantau, dan memperbarui dibandingkan dengan model yang di-fine-tune sepenuhnya.

Kesimpulan

Fine-tuning LoRA adalah salah satu cara paling mudah dan hemat biaya untuk membuat model Anda memahami data khusus Anda. Alih-alih menganggap fine-tuning sebagai operasi yang mahal dan berisiko tinggi, LoRA menanggapinya sebagai proses yang ringan dan dapat diulang yang cocok secara alami dalam alur kerja pengembangan modern. Dengan menjaga model dasar tetap utuh dan hanya mempelajari apa yang diperlukan, LoRA membuat kustomisasi terasa lebih mudah dijangkau daripada membebani.

Yang benar-benar menonjol adalah betapa fleksibelnya pendekatan ini. Anda tidak memerlukan model baru untuk setiap kasus penggunaan. Satu model dasar yang kuat dapat mendukung banyak perilaku berbeda melalui adaptor kecil yang dapat dipertukarkan. Ini membuatnya jauh lebih mudah untuk mengembangkan sistem seiring waktu, menanggapi kebutuhan baru, dan menjaga biaya tetap terkendali tanpa mengorbankan kualitas.

Pada dasarnya, LoRA bukan tentang memaksa model untuk mempelajari lebih banyak data, melainkan tentang mengajarkan mereka bagaimana bersikap dengan cara yang benar. Dengan contoh yang tepat dan tujuan yang jelas, Anda dapat membimbing model untuk berbicara dalam bahasa domain Anda, mengikuti struktur Anda, dan mendukung pengguna nyata dengan lebih efektif.

Referensi

Cara Menyempurnakan LLM menggunakan LoRA
Mengimplementasikan LoRA dari Awal untuk Fine-tuning LLM
Tips Praktis untuk Menyempurnakan LLM dengan LoRA (Adaptasi Rank Rendah)
Menyetel Model Bahasa dengan Pengetahuan Kustom
LoRA: Penjelasan Adaptasi Peringkat Rendah pada Model Bahasa Besar
Menyetel Ulang LLM dengan Anggaran Terbatas: Menggunakan Droplet GPU Linux-Console.net
Penyetelan LLM: Panduan untuk Model Khusus Domain

Terima kasih telah belajar bersama Komunitas Linux-Console.net.