Tutorial Fine-Tuning Qwen 2.5-Coder Pakai Unsloth di Google Colab

Problem Statement: Limitasi Prompt Engineering pada Sintaks Proprietary

Prompt engineering gagal saat tangani SDK proprietary, framework internal perusahaan, atau pustaka private. Model basis umum seperti Qwen 2.5-Coder, Llama 3, atau GPT-4 tidak pernah melihat kode internal dalam data pra-pelatihan. Memuat dokumentasi API internal ke dalam context window menimbulkan tiga masalah kritis:

• Konsumsi Token Pembengkak: Menyertakan ratusan baris sampel kode internal pada setiap panggilan API menghabiskan kuota context window dan tingkatkan biaya latensi.
• Halusinasi Sintaks: LLM cenderung menggabungkan pola dari library publik ke dalam SDK privat, akibatkan error runtime saat kompilasi.
• Risiko Keamanan Data: Mengirimkan potongan kode proprietary ke layanan API cloud publik berpotensi melanggar kebijakan privasi dan kepatuhan industri.

Solusi teknis: Fine-tuning model basis LLM coding. Modifikasi bobot model internal supaya paham fungsi, struktur argumen, tipe data, dan konvensi kode khusus tanpa perlu prompt konteks panjang.

Solusi Arsitektur: QLoRA dan Optimasi Unsloth

Fine-tuning penuh (full fine-tuning) model parameter 7B butuh VRAM GPU di atas 40GB (NVIDIA A100 atau H100). Konsumsi memori mahal dan tidak efisien untuk tim pengembang kecil.

Teknologi QLoRA (Quantized Low-Rank Adaptation) memotong konsumsi memori dengan cara:

• Kuantisasi 4-bit (NF4): Membekukan bobot basis model ke dalam format 4-bit NormalFloat tanpa kurangi presisi matematis secara signifikan.
• Low-Rank Adapters: Menambahkan matriks adapter berukuran kecil (rank r) pada layer terisolasi. Hanya bobot adapter ini yang diperbarui selama proses training.
• Double Quantization & Page Optimizer: Mengurangi overhead memori dari kalkulasi gradien dan quantiles.

Unsloth tingkatkan efisiensi QLoRA secara dramatis. Unsloth mengganti operasi PyTorch standar dengan kustom kernel Triton yang ditulis langsung dalam bahasa assembler GPU. Hasilnya: hemat VRAM hingga 60%, hilangkan alokasi memori sementara, dan percepat proses pelatihan 2x hingga 5x lipat. GPU gratisan Google Colab (NVIDIA T4 16GB VRAM) menjadi sangat cukup untuk melatih model Qwen 2.5-Coder 7B.

Langkah Teknis Fine-Tuning Qwen 2.5-Coder via Unsloth

1. Persiapan dan Kurasi Dataset JSONL

Kualitas fine-tuning bergantung pada kualitas dataset. Buat file dataset_syntax_internal.jsonl yang berisi pasangan instruksi dan respons kode internal yang valid. Format dataset harus konsisten dan bebas dari sintaksis lama (deprecated).

[
  {
    "instruction": "Buat fungsi koneksi database pakai InternalDB SDK v2.",
    "input": "",
    "output": "from internal_db import ClientConfig, SecureClient\n\ndef connect():\n    cfg = ClientConfig(env=\"prod\", timeout=30)\n    client = SecureClient(cfg)\n    return client.connect()"
  },
  {
    "instruction": "Inisialisasi middleware autentikasi token JWT dengan AuthInternal.",
    "input": "",
    "output": "from internal_auth import TokenValidator, AuthMiddleware\n\ndef setup_auth(app):\n    validator = TokenValidator(secret_key_env=\"JWT_SECRET\")\n    app.use_middleware(AuthMiddleware(validator))"
  }
]

2. Setup Environment Google Colab

Untuk menyiapkan lingkungan kerja di Google Colab, ikuti urutan langkah berikut secara cermat:

1. Buka Google Colab dan buat notebook baru.
2. Buka menu Runtime > Change runtime type.
3. Pilih T4 GPU pada opsi Hardware accelerator, lalu klik Save.
4. Jalankan perintah instalasi pustaka Unsloth dan dependensinya pada sel kode pertama:

!pip install --no-deps "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
!pip install --no-deps xformers trl peft accelerate bitsandbytes

3. Load Model dan Tokenizer

Muat model Qwen 2.5-Coder 7B Instruct terkuantisasi 4-bit bawaan Unsloth. Konfigurasi max_seq_length menentukan batas maksimum token konteks yang ditampung memori GPU.

from unsloth import FastLanguageModel
import torch

max_seq_length = 2048
dtype = None
load_in_4bit = True

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/Qwen2.5-Coder-7B-Instruct-bnb-4bit",
    max_seq_length = max_seq_length,
    dtype = dtype,
    load_in_4bit = load_in_4bit,
)

4. Konfigurasi LoRA Adapter

Terapkan target adapter ke layer perhatian (attention) dan MLP model. Menyertakan modul MLP (gate_proj, up_proj, down_proj) sangat penting agar model dapat merekam sintaks baru secara mendalam.

model = FastLanguageModel.get_peft_model(
    model,
    r = 16,
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    lora_alpha = 16,
    lora_dropout = 0,
    bias = "none",
    use_gradient_checkpointing = "unsloth",
    random_state = 3407,
)

5. Format Dataset ke Prompt Template Qwen ChatML

Format masukan teks harus mematuhi skema ChatML yang dikenali Qwen 2.5-Coder agar instruksi sistem dan respons asisten terpisah secara jelas.

qwen_prompt = """<|im_start|>system
Kamu adalah asisten AI coding internal yang ahli.<|im_end|>
<|im_start|>user
{}<|im_end|>
<|im_start|>assistant
{}<|im_end|>"""

def format_prompts(examples):
    texts = []
    for inst, out in zip(examples["instruction"], examples["output"]):
        text = qwen_prompt.format(inst, out) + "<|im_end|>"
        texts.append(text)
    return {"text": texts}

from datasets import load_dataset
dataset = load_dataset("json", data_files="dataset_syntax_internal.jsonl", split="train")
dataset = dataset.map(format_prompts, batched=True)

6. Eksekusi Training dengan SFTTrainer

Konfigurasikan SFTTrainer dari pustaka trl. Penggunaan pengoptimal adamw_8bit menurunkan alokasi VRAM pada status optimizer.

from trl import SFTTrainer
from transformers import TrainingArguments

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset,
    dataset_text_field = "text",
    max_seq_length = max_seq_length,
    dataset_num_proc = 2,
    packing = False,
    args = TrainingArguments(
        per_device_train_batch_size = 2,
        gradient_accumulation_steps = 4,
        warmup_steps = 5,
        max_steps = 60,
        learning_rate = 2e-4,
        fp16 = not torch.cuda.is_bf16_supported(),
        bf16 = torch.cuda.is_bf16_supported(),
        logging_steps = 1,
        optim = "adamw_8bit",
        weight_decay = 0.01,
        lr_scheduler_type = "linear",
        seed = 3407,
        output_dir = "outputs",
    ),
)

trainer_stats = trainer.train()

7. Ekspor Model ke Format GGUF

Konversi bobot hasil training langsung ke format GGUF 4-bit (q4_k_m) untuk eksekusi lokal tanpa kehilangan performa inferensi secara signifikan.

model.save_pretrained_gguf("qwen2.5-coder-custom", tokenizer, quantization_method = "q4_k_m")

Troubleshooting dan Best Practice

Penanganan CUDA Out of Memory (OOM)

Jika memori GPU T4 meledak saat proses pelatihan, lakukan penyesuaian parameter berikut secara hierarkis:

• Turunkan per_device_train_batch_size dari 2 ke 1.
• Naikkan gradient_accumulation_steps ke 8 atau 16 untuk menjaga akumulasi ukuran batch efektif tetap setara.
• Batasi max_seq_length ke 1024 jika fungsi kode pada dataset tidak membutuhkan konteks sangat panjang.
• Pastikan opsi use_gradient_checkpointing = "unsloth" aktif untuk melepaskan memori aktivasi intermediate.

Tuning LoRA Hyperparameter

• Rank (r): Nilai 16 merupakan titik seimbang optimal untuk mengajarkan sintaks domain khusus. Gunakan 32 atau 64 hanya jika menambahkan logika pemrosesan yang kompleks.
• Target Modules: Wajib menyertakan modul MLP (gate_proj, up_proj, down_proj) bersama modul attention agar model dapat menghafal pemetaan nama fungsi dan sintaks baru secara stabil.
• Learning Rate: Tingkat pembelajaran 2e-4 ideal untuk QLoRA. Jika kurva loss tidak mengalami penurunan, turunkan ke 1e-4. Hindari memilih learning rate di atas 5e-4 karena berisiko memicu catastrophic forgetting pada pengetahuan umum model.

Integrasi Model Custom ke Ollama dan VS Code

Untuk mendistribusikan model hasil fine-tuning ke lingkungan pengembang lokal, ikuti prosedur registrasi dan konfigurasi berikut:

1. Import File GGUF ke Ollama Lokal

Unduh file qwen2.5-coder-custom-Q4_K_M.gguf dari Google Colab ke komputer lokal. Buat file bernama Modelfile di dalam direktori penyimpanan file GGUF tersebut:

FROM ./qwen2.5-coder-custom-Q4_K_M.gguf
PARAMETER stop "<|im_end|>"
TEMPLATE """<|im_start|>system
Kamu adalah asisten AI coding internal yang ahli.<|im_end|>
<|im_start|>user
{{ .Prompt }}<|im_end|>
<|im_start|>assistant
"""

Buka terminal atau command prompt lokal, lalu jalankan perintah berikut untuk mencatatkan model ke dalam repositori lokal Ollama:

ollama create qwen2.5-internal -f ./Modelfile
ollama run qwen2.5-internal

2. Sambungkan ke Ekstensi VS Code (Continue)

Integrasikan model yang berjalan di Ollama dengan ekstensi IDE VS Code untuk mendapatkan fitur autocomplete dan perbincangan kode langsung:

1. Buka VS Code dan pasang ekstensi Continue dari Marketplace.
2. Buka file konfigurasi Continue yang terletak di ~/.continue/config.json (Linux/macOS) atau %USERPROFILE%\.continue\config.json (Windows).
3. Tambahkan blok konfigurasi model Ollama berikut ke dalam array models:

{
  "models": [
    {
      "title": "Qwen 2.5 Coder Internal",
      "provider": "ollama",
      "model": "qwen2.5-internal",
      "apiBase": "http://localhost:11434"
    }
  ]
}

Kesimpulan

Fine-tuning Qwen 2.5-Coder menggunakan Unsloth terbukti mampu mengatasi keterbatasan memori VRAM GPU dan memangkas durasi pelatihan secara signifikan. Kombinasi metode QLoRA 4-bit, konversi bobot ke format GGUF, serta integrasi via Ollama dan VS Code menghasilkan sistem asisten AI coding internal yang responsif, terisolasi secara privat, dan bebas dari dependensi biaya API pihak ketiga.