LLM Fine-tuning 실전 가이드: LoRA, QLoRA, PEFT로 효율적 모델 적응

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

# 베이스 모델 로드
model_name = "meta-llama/Llama-2-7b-hf"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# LoRA 설정
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,                          # 랭크: 일반적으로 8-64 사이
    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",                   # bias 학습 여부
)

# PEFT 모델 생성
peft_model = get_peft_model(model, lora_config)

# 학습 가능한 파라미터 확인
peft_model.print_trainable_parameters()
# 출력 예시: trainable params: 33,554,432 || all params: 6,771,970,048
# || trainable%: 0.4956

from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    TrainingArguments,
)
from peft import LoraConfig, prepare_model_for_kbit_training, get_peft_model
from trl import SFTTrainer
import torch

# 4비트 양자화 설정
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",           # NormalFloat4 양자화
    bnb_4bit_compute_dtype=torch.bfloat16, # 연산 시 bfloat16 사용
    bnb_4bit_use_double_quant=True,       # Double Quantization 활성화
)

# 4비트 양자화 모델 로드
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    quantization_config=bnb_config,
    device_map="auto",
    trust_remote_code=True,
)

# k-bit 학습 준비 (gradient checkpointing 등)
model = prepare_model_for_kbit_training(model)

# LoRA 설정
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)

# 학습 인자 설정
training_args = TrainingArguments(
    output_dir="./qlora-output",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    weight_decay=0.01,
    warmup_ratio=0.03,
    lr_scheduler_type="cosine",
    logging_steps=10,
    save_strategy="steps",
    save_steps=100,
    fp16=False,
    bf16=True,
    optim="paged_adamw_8bit",            # Paged Optimizer 사용
    gradient_checkpointing=True,
    max_grad_norm=0.3,
    report_to="wandb",
)

# SFTTrainer로 학습
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-hf")
tokenizer.pad_token = tokenizer.eos_token

trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    tokenizer=tokenizer,
    max_seq_length=2048,
)

trainer.train()

# PEFT 설치
# pip install peft transformers accelerate bitsandbytes trl

# 다양한 PEFT 기법을 동일한 인터페이스로 사용
from peft import (
    LoraConfig,
    PrefixTuningConfig,
    PromptTuningConfig,
    IA3Config,
    get_peft_model,
)

# LoRA
lora_config = LoraConfig(r=16, lora_alpha=32, task_type="CAUSAL_LM")

# Prefix Tuning
prefix_config = PrefixTuningConfig(
    task_type="CAUSAL_LM",
    num_virtual_tokens=20,
)

# Prompt Tuning
prompt_config = PromptTuningConfig(
    task_type="CAUSAL_LM",
    num_virtual_tokens=20,
    prompt_tuning_init="TEXT",
    prompt_tuning_init_text="Classify the following text:",
    tokenizer_name_or_path="meta-llama/Llama-2-7b-hf",
)

# IA3 (Infused Adapter by Inhibiting and Amplifying Inner Activations)
ia3_config = IA3Config(
    task_type="CAUSAL_LM",
    target_modules=["k_proj", "v_proj", "down_proj"],
    feedforward_modules=["down_proj"],
)

from peft import PeftModel, PeftConfig

# 어댑터 저장 (약 30-100MB)
peft_model.save_pretrained("./my-lora-adapter")

# 어댑터 로드: 베이스 모델 + 어댑터 결합
base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-2-7b-hf",
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
model = PeftModel.from_pretrained(base_model, "./my-lora-adapter")

# 추론 최적화: LoRA 가중치를 베이스 모델에 병합
model = model.merge_and_unload()

# 병합된 모델 저장 (추론 시 오버헤드 제거)
model.save_pretrained("./merged-model")
tokenizer.save_pretrained("./merged-model")

from datasets import Dataset

# Alpaca 형식 데이터셋 구성
def format_instruction(sample):
    """Alpaca 스타일의 프롬프트 템플릿"""
    if sample.get("input"):
        return f"""### Instruction:
{sample['instruction']}

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

### Response:
{sample['output']}"""
    else:
        return f"""### Instruction:
{sample['instruction']}

### Response:
{sample['output']}"""

# 데이터셋 예시
raw_data = [
    {
        "instruction": "다음 텍스트의 감정을 분석하세요.",
        "input": "이 제품 정말 훌륭합니다. 배송도 빠르고 품질도 최고예요!",
        "output": "긍정적 감정입니다. 제품 품질과 배송 속도에 대한 만족감을 표현하고 있습니다.",
    },
    {
        "instruction": "주어진 SQL 쿼리를 최적화하세요.",
        "input": "SELECT * FROM users WHERE created_at > '2024-01-01' ORDER BY name",
        "output": "SELECT id, name, email FROM users WHERE created_at > '2024-01-01' ORDER BY name LIMIT 100;\n\n최적화 포인트:\n1. SELECT *를 필요한 컬럼만 선택하도록 변경\n2. LIMIT 추가로 결과셋 제한\n3. created_at과 name에 복합 인덱스 생성 권장",
    },
]

dataset = Dataset.from_list(raw_data)
formatted = dataset.map(lambda x: {"text": format_instruction(x)})

# Weights and Biases를 활용한 학습 모니터링
import wandb

wandb.init(
    project="llm-finetuning",
    config={
        "model": "Llama-2-7b",
        "method": "QLoRA",
        "r": 16,
        "alpha": 32,
        "lr": 2e-4,
        "epochs": 3,
    },
)

# 주요 모니터링 지표
# 1. Training Loss: 꾸준히 감소해야 함. 급격한 감소 후 정체는 과적합 신호
# 2. Validation Loss: training loss와 gap이 벌어지면 과적합
# 3. Learning Rate: 스케줄러가 의도대로 동작하는지 확인
# 4. Gradient Norm: 급격한 스파이크는 학습 불안정 신호
# 5. GPU Memory: OOM 방지를 위한 메모리 사용량 추적