Infrastruktur Fine-Tuning: LoRA, QLoRA, dan PEFT dalam Skala Besar

Diperbarui 11 Desember 2025

Pembaruan Desember 2025: Full fine-tuning model 7B membutuhkan 100-120GB VRAM (~$50K H100). QLoRA memungkinkan fine-tuning yang sama pada RTX 4090 seharga $1.500. Metode PEFT mengurangi memori 10-20x sambil mempertahankan 90-95% kualitas. Adapter LoRA tidak menambah latensi inference dengan menggabungkannya ke weight dasar. QLoRA mengkombinasikan kuantisasi 4-bit dengan LoRA untuk efisiensi memori maksimal.

Full fine-tuning model dengan 7 miliar parameter membutuhkan 100-120 GB VRAM—sekitar $50.000 senilai GPU H100 untuk satu kali training.¹ Model yang sama dapat di-fine-tune pada RTX 4090 seharga $1.500 menggunakan QLoRA, selesai dalam hitungan jam bukan hari dengan biaya yang jauh lebih rendah. Metode parameter-efficient fine-tuning (PEFT) telah mentransformasi AI enterprise dari kapabilitas eksklusif hyperscaler menjadi infrastruktur yang dapat diakses dan muat dalam sebuah workstation.

Organisasi kini menghadapi tantangan yang berbeda: memilih di antara puluhan metode PEFT, mengkonfigurasi infrastruktur untuk operasi fine-tuning skala produksi, dan membangun pipeline yang mengubah model kustom menjadi layanan yang ter-deploy. Memahami kebutuhan infrastruktur, trade-off biaya, dan pola operasional untuk setiap pendekatan memungkinkan enterprise membangun kapabilitas fine-tuning yang sesuai dengan kebutuhan spesifik mereka.

Lanskap PEFT

Parameter-efficient fine-tuning bekerja dengan membekukan sebagian besar parameter model pretrained sambil melatih komponen tambahan yang kecil. Pendekatan ini mengurangi kebutuhan memori 10-20x dibandingkan full fine-tuning sambil mempertahankan 90-95% kualitas.²

LoRA (Low-Rank Adaptation)

LoRA menambahkan matriks low-rank yang dapat dilatih bersama weight model yang dibekukan. Selama inference, matriks adapter digabung dengan weight dasar, tidak menambah latensi dibandingkan model asli.

Cara kerjanya: Untuk matriks weight pretrained W, LoRA menambahkan BA di mana B dan A adalah matriks kecil dengan rank r (biasanya 8-64). Alih-alih memperbarui jutaan parameter W, training hanya memperbarui ribuan parameter di A dan B.

Penghematan memori: Model 7B yang membutuhkan 14GB untuk weight memerlukan sekitar 28GB total untuk fine-tuning LoRA (weight + gradient + optimizer state hanya untuk adapter), versus 100+ GB untuk full fine-tuning.³

Kualitas: LoRA memulihkan 90-95% kualitas full fine-tuning pada sebagian besar task. Gap ini menyempit dengan nilai rank yang lebih tinggi dengan biaya lebih banyak parameter yang dapat dilatih.

QLoRA (Quantized LoRA)

QLoRA mengkombinasikan LoRA dengan kuantisasi model dasar yang agresif, memungkinkan fine-tuning model yang seharusnya tidak muat di memori:⁴

Kuantisasi 4-bit: Weight model dasar dikompres ke format 4-bit NormalFloat (NF4), mengurangi memori sebesar 75% versus 16-bit.

Double quantization: Konstanta kuantisasi itu sendiri dikuantisasi, menghemat memori tambahan.

Paged optimizer: Optimizer state dipindahkan ke memori CPU selama lonjakan memori, mencegah crash out-of-memory.

Dampak memori: QLoRA memungkinkan fine-tuning model 70B pada hardware yang seharusnya kesulitan dengan model 7B menggunakan full fine-tuning. Satu A100 80GB dapat menangani model yang seharusnya membutuhkan 4-8 GPU.

Trade-off kualitas: QLoRA mencapai 80-90% kualitas full fine-tuning. Noise kuantisasi tambahan mempengaruhi beberapa task lebih dari yang lain; evaluasi pada task target menentukan penerimaan.

Metode PEFT lainnya

Adapter: Modul neural kecil yang disisipkan di antara layer transformer. Parameter lebih banyak dari LoRA tetapi terkadang performa lebih baik pada task tertentu.

Prefix tuning: Menambahkan "token virtual" yang dapat dilatih di awal input. Bekerja baik untuk task generasi tetapi kurang fleksibel dibanding LoRA.

IA3 (Infused Adapter by Inhibiting and Amplifying Inner Activations): Adaptasi multiplikatif dengan parameter bahkan lebih sedikit dari LoRA. Opsi yang berkembang untuk lingkungan yang sangat terbatas.

Kebutuhan GPU berdasarkan ukuran model

Model 7B (Llama 3.1-8B, Mistral 7B)

Full fine-tuning: - Minimum: 2x A100 40GB atau 1x A100 80GB - Direkomendasikan: 1x H100 80GB - Kebutuhan memori: 100-120GB total

Fine-tuning LoRA: - Minimum: RTX 4090 24GB - Direkomendasikan: L40S 48GB atau A100 40GB - Kebutuhan memori: 24-32GB

Fine-tuning QLoRA: - Minimum: RTX 3090 24GB atau RTX 4080 16GB - Direkomendasikan: RTX 4090 24GB - Kebutuhan memori: 12-20GB⁵

Model 13B-35B (varian Llama 3.1-70B, Code Llama 34B)

Fine-tuning LoRA: - Minimum: A100 80GB - Direkomendasikan: H100 80GB - Opsi multi-GPU: 2x RTX 4090 dengan model parallelism

Fine-tuning QLoRA: - Minimum: RTX 4090 24GB (ketat, batch size kecil) - Direkomendasikan: A100 40GB atau L40S 48GB - Kebutuhan memori: 20-40GB

Model 70B+ (Llama 3.1-70B, DeepSeek 67B)

Fine-tuning LoRA: - Minimum: 2x A100 80GB atau 2x H100 80GB - Direkomendasikan: 4x H100 80GB - Alternatif: 2x RTX PRO 6000 Blackwell (masing-masing 96GB)⁶

Fine-tuning QLoRA: - Minimum: A100 80GB (sangat terbatas) - Direkomendasikan: 2x A100 80GB atau 1x H200 141GB - Kebutuhan memori: 60-100GB

Model 140B+

Fine-tuning QLoRA: - Minimum: 2x H100 80GB dengan NVLink - Direkomendasikan: 4x H100 80GB atau 4x RTX PRO 6000 Blackwell - Alternatif: pod 5x H200 141GB⁷

Arsitektur infrastruktur

Pengembangan GPU tunggal

Sebagian besar organisasi memulai eksplorasi fine-tuning pada GPU tunggal:

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model

# Konfigurasi QLoRA
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

# Load model dasar terkuantisasi
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B",
    quantization_config=bnb_config,
    device_map="auto",
)

# Konfigurasi adapter LoRA
lora_config = LoraConfig(
    r=16,                    # Rank
    lora_alpha=32,           # Faktor scaling
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)

Pengembangan GPU tunggal cocok untuk: - Eksperimen awal dan pencarian hyperparameter - Dataset kecil (< 100K contoh) - Proyek dengan anggaran terbatas - Siklus iterasi cepat

Scaling multi-GPU

Fine-tuning produksi biasanya membutuhkan beberapa GPU untuk waktu training yang wajar:

Data parallelism: Mereplikasi model di seluruh GPU, masing-masing memproses batch data yang berbeda. Bekerja ketika model muat dalam memori GPU tunggal.

# DeepSpeed ZeRO Stage 2 untuk data parallelism yang efisien
accelerate launch --config_file ds_config.yaml train.py

Model parallelism: Membagi layer model di seluruh GPU. Diperlukan ketika model melebihi memori GPU tunggal.

FSDP (Fully Sharded Data Parallelism): Distributed training native PyTorch yang membagi model, gradient, dan optimizer state di seluruh GPU. Menyeimbangkan efisiensi memori dengan overhead komunikasi.

from accelerate import Accelerator

accelerator = Accelerator(
    mixed_precision="bf16",
    gradient_accumulation_steps=4,
)

Cloud vs on-premises

Keuntungan cloud: - Tidak ada investasi modal - Scaling instan untuk beban kerja burst - Akses ke hardware terbaru - Infrastruktur terkelola (networking, storage)

Biaya cloud (2025): - H100 80GB: $2,50-4,00/jam - A100 80GB: $1,50-2,50/jam - RTX 4090: $0,40-0,80/jam

Keuntungan on-premises: - Biaya lebih rendah pada utilisasi tinggi (>60% bulanan) - Kedaulatan data dan kontrol keamanan - Tidak ada biaya egress cloud untuk dataset besar - Kapasitas yang dapat diprediksi

Analisis break-even: Fine-tuning cloud biasanya lebih murah sampai organisasi menjalankan >40 jam/minggu secara konsisten. Di atas ambang batas tersebut, infrastruktur milik sendiri memberikan ekonomi yang lebih baik.

Pipeline fine-tuning produksi

Persiapan data

Data training berkualitas lebih penting dari kuantitas untuk fine-tuning:

Kurasi dataset: - Filter untuk contoh berkualitas tinggi yang relevan dengan task target - Hapus duplikat dan near-duplicate - Seimbangkan distribusi kelas jika berlaku - Validasi konsistensi format data

Pipeline preprocessing:

from datasets import load_dataset

dataset = load_dataset("json", data_files="training_data.jsonl")

def preprocess(example):
    # Format untuk instruction fine-tuning
    return {
        "text": f"### Instruction:\n{example['instruction']}\n\n"
                f"### Response:\n{example['output']}"
    }

dataset = dataset.map(preprocess)

Ukuran dataset: - Minimum viable: 1.000-5.000 contoh berkualitas tinggi - Baseline produksi: 10.000-50.000 contoh - Penangkapan keahlian domain: 50.000-500.000 contoh

Orkestrasi training

Sistem produksi membutuhkan orkestrasi di luar eksekusi skrip manual:

Axolotl: Fine-tuning yang disederhanakan dengan konfigurasi YAML. Sangat baik untuk eksperimentasi cepat dan workflow yang terstandarisasi.⁸

# axolotl_config.yaml
base_model: meta-llama/Llama-3.1-8B
model_type: LlamaForCausalLM
load_in_4bit: true
adapter: qlora
lora_r: 16
lora_alpha: 32
datasets:
  - path: ./training_data.jsonl
    type: sharegpt
sequence_len: 4096
micro_batch_size: 2
gradient_accumulation_steps: 4

LLaMA-Factory: Toolkit komprehensif yang mendukung berbagai keluarga model dan metode training. Komunitas dan dokumentasi yang kuat.

Hugging Face PEFT + Transformers: Kontrol dan fleksibilitas maksimal untuk kebutuhan kustom. Production-grade untuk organisasi dengan kapasitas ML engineering.

Experiment tracking

Lacak eksperimen secara sistematis untuk memungkinkan reproducibility dan optimisasi:

Weights & Biases:

import wandb

wandb.init(project="llm-fine-tuning", config={
    "model": "Llama-3.1-8B",
    "method": "qlora",
    "rank": 16,
    "learning_rate": 2e-4,
})

MLflow: Alternatif open-source dengan kapabilitas model registry.

Yang dilacak: - Hyperparameter (rank, alpha, learning rate, batch size) - Metrik training (kurva loss, gradient norm) - Metrik evaluasi pada holdout set - Utilisasi resource (memori GPU, waktu training)

Manajemen adapter

LoRA menghasilkan file checkpoint kecil (~10-100MB) yang ditumpuk dengan model dasar:

Penyimpanan adapter: - Version control adapter di Git atau artifact store - Asosiasikan dengan konfigurasi training dan hasil evaluasi - Memungkinkan switching cepat antar model terspesialisasi

Serving adapter:

from peft import PeftModel

# Load model dasar sekali
base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")

# Swap adapter secara dinamis
model = PeftModel.from_pretrained(base_model, "adapters/customer-support-v2")
# Nanti...
model.load_adapter("adapters/code-generation-v1")

Penggabungan adapter: Untuk inference produksi, gabungkan weight adapter ke model dasar untuk menghilangkan overhead adapter:

merged_model = model.merge_and_unload()
merged_model.save_pretrained("./merged_model")

Strategi optimisasi biaya

Right-sizing hardware

Sesuaikan GPU dengan kebutuhan aktual:

Optimisasi batch size

Batch size yang lebih besar meningkatkan efisiensi training tetapi membutuhkan lebih banyak memori:

# Gradient accumulation mensimulasikan batch yang lebih besar
training_args = TrainingArguments(
    per_device_train_batch_size=2,      # Muat di memori
    gradient_accumulation_steps=8,       # Effective batch: 16
    ...
)

Training mixed precision

Training BF16 mengurangi memori 50% versus FP32 dengan dampak kualitas minimal:

training_args = TrainingArguments(
    bf16=True,          # Gunakan BF16 pada Ampere+
    tf32=True,          # Aktifkan TF32 untuk matmul
    ...
)

Instance spot/preemptible

Instance spot cloud menawarkan diskon 60-80% untuk beban kerja yang dapat diinterupsi. Implementasikan checkpointing untuk fault tolerance:

training_args = TrainingArguments(
    save_strategy="steps",
    save_steps=100,
    save_total_limit=3,
    resume_from_checkpoint=True,
    ...
)

Deployment enterprise

[Konten dipotong untuk terjemahan]