LLM 파인튜닝 실전 — LoRA, QLoRA, PEFT로 나만의 모델 만들기

원본 W (4096 × 4096) = 16M 파라미터 [freeze]

LoRA:
A (r × 4096) + B (4096 × r) = r × 8192 파라미터
r=8일 경우: 65,536 파라미터 (0.4%)

from peft import LoraConfig, get_peft_model, TaskType
from transformers import AutoModelForCausalLM, AutoTokenizer

# 1. 기본 모델 로드
model_name = "meta-llama/Llama-3.1-8B"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_name)

# 2. LoRA 설정
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,                          # 랭크
    lora_alpha=32,                 # 스케일링 (보통 r의 2배)
    lora_dropout=0.05,             # 드롭아웃
    target_modules=[               # LoRA를 적용할 모듈
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj"
    ],
    bias="none"
)

# 3. PEFT 모델 생성
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: 41,943,040 || all params: 8,072,204,288 || trainable%: 0.5194

# 모델의 모든 Linear 레이어 확인
for name, module in model.named_modules():
    if isinstance(module, torch.nn.Linear):
        print(name, module.in_features, module.out_features)

# 일반적인 선택:
# - Attention만: ["q_proj", "v_proj"] — 최소 VRAM
# - Attention 전체: ["q_proj", "k_proj", "v_proj", "o_proj"] — 권장
# - MLP 포함: 위 + ["gate_proj", "up_proj", "down_proj"] — 최대 성능

from transformers import BitsAndBytesConfig
import torch

# 4-bit 양자화 설정
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",           # NormalFloat4
    bnb_4bit_compute_dtype=torch.bfloat16, # 연산은 bf16으로
    bnb_4bit_use_double_quant=True,        # Double Quantization
)

# 양자화된 모델 로드
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B",
    quantization_config=bnb_config,
    device_map="auto"
)

# LoRA 적용 (QLoRA = 4bit 양자화 모델 + LoRA)
model = get_peft_model(model, lora_config)

from datasets import load_dataset

# Alpaca 스타일 데이터셋
dataset = load_dataset("json", data_files="train_data.json")

# 데이터 예시
# {
#   "instruction": "다음 텍스트를 요약해주세요.",
#   "input": "Kubernetes는 컨테이너화된 워크로드와 서비스를...",
#   "output": "Kubernetes는 컨테이너 오케스트레이션 플랫폼입니다."
# }

# 프롬프트 템플릿 적용
def format_instruction(sample):
    if sample["input"]:
        text = f"""### Instruction:
{sample["instruction"]}

### Input:
{sample["input"]}

### Response:
{sample["output"]}"""
    else:
        text = f"""### Instruction:
{sample["instruction"]}

### Response:
{sample["output"]}"""
    return {"text": text}

dataset = dataset.map(format_instruction)

from trl import SFTTrainer, SFTConfig

training_args = SFTConfig(
    output_dir="./output",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,    # 효과적 배치 = 4 × 4 = 16
    learning_rate=2e-4,
    lr_scheduler_type="cosine",
    warmup_ratio=0.03,
    max_seq_length=2048,
    bf16=True,
    logging_steps=10,
    save_strategy="epoch",
    optim="paged_adamw_8bit",         # QLoRA용 페이징 옵티마이저
    gradient_checkpointing=True,      # VRAM 추가 절감
)

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset["train"],
    args=training_args,
)

trainer.train()

# LoRA 어댑터만 저장 (수십 MB)
model.save_pretrained("./lora-adapter")

# 나중에 어댑터 로드
from peft import PeftModel
base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-3.1-8B")
model = PeftModel.from_pretrained(base_model, "./lora-adapter")

# 원본 모델과 어댑터 병합 (배포용)
merged_model = model.merge_and_unload()
merged_model.save_pretrained("./merged-model")

# 랭크별 특성
# r=4:   가장 적은 파라미터, 간단한 도메인 적응에 적합
# r=8:   일반적인 시작점
# r=16:  좋은 균형 (추천)
# r=32:  복잡한 태스크, 더 많은 VRAM
# r=64+: Full Fine-tuning에 가까운 성능, 그만큼 비효율

# 실험적으로, r=16 + alpha=32가 대부분의 경우에 잘 작동

# LoRA/QLoRA 학습률은 Full FT보다 높게 설정
# Full FT: 1e-5 ~ 5e-5
# LoRA:    1e-4 ~ 3e-4
# QLoRA:   2e-4 (일반적)

lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "v_proj"],
    use_dora=True,   # DoRA 활성화
)

from peft import PeftModel

# 기본 모델에 여러 어댑터 로드
model = PeftModel.from_pretrained(base_model, "./adapter-korean")
model.load_adapter("./adapter-code", adapter_name="code")

# 어댑터 전환
model.set_adapter("code")

# 또는 어댑터 가중치 조합
model.add_weighted_adapter(
    adapters=["default", "code"],
    weights=[0.7, 0.3],
    adapter_name="merged"
)