프로젝트 1 — r 값에 따른 LoRA 크기 비교

# Qwen2.5-0.5B 의 층 크기(5차시 print(model) 에서 본 값)
HIDDEN = 896     # 토큰 성격표의 칸 수(hidden_size)
KV_OUT = 128     # k_proj·v_proj 의 출력 칸 수(Key·Value 머리 2개 × 64)
FFN = 4864       # FFN 가운데 칸 수(intermediate_size)
LAYERS = 24      # 층 수

# (층 이름, 입력 칸, 출력 칸): 실습 1의 LORA_TARGETS 일곱 곳
LAYER_SHAPES = [
    ("q_proj", HIDDEN, HIDDEN), ("k_proj", HIDDEN, KV_OUT), ("v_proj", HIDDEN, KV_OUT),
    ("o_proj", HIDDEN, HIDDEN), ("gate_proj", HIDDEN, FFN), ("up_proj", HIDDEN, FFN),
    ("down_proj", FFN, HIDDEN),
]
R_VALUES = [4, 8, 16, 32]   # 비교할 랭크(필름 두께)


def lora_count_by_hand(r):
    # 한 층: 일곱 곳의 r × (입력 + 출력)을 더한다
    per_layer = sum(r * (d_in + d_out) for _, d_in, d_out in LAYER_SHAPES)
    # 24층을 곱한다
    return per_layer * LAYERS


for r in R_VALUES:
    n = lora_count_by_hand(r)
    # 예상 크기: LoRA 는 FP32(4바이트)로 저장된다
    print(f"r={r:>2}: {n:>12,}개  예상 {n * 4 / 1024**2:6.2f} MB")
# 결과: r=4 는 2,199,552개 8.39 MB, r=16 은 8,798,208개 33.56 MB

import gc
import os
import shutil

import torch
# AutoModelForCausalLM = 다음 낱말 맞히기(causal language model)용 모델을 불러오는 도구
from transformers import AutoModelForCausalLM
from peft import LoraConfig, get_peft_model

torch.manual_seed(42)   # LoRA 의 A 를 무작위로 채우므로 씨앗을 준다(크기에는 영향 없음)
MODEL_NAME = "Qwen/Qwen2.5-0.5B-Instruct"
# from_pretrained = 이미 학습된 가중치에서 불러오기. dtype=BF16(숫자 하나에 2바이트)
# device 를 정하지 않으면 CPU 에 올라간다
model = AutoModelForCausalLM.from_pretrained(MODEL_NAME, dtype=torch.bfloat16)
# numel() = number of elements(원소 수)
base_params = sum(p.numel() for p in model.parameters())
# 결과: 기반 모델 파라미터: 494,032,768개, 장치: cpu
print(f"기반 모델 파라미터: {base_params:,}개, 장치: {model.device}")

LORA_TARGETS = ["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"]
rows = []   # r 마다 결과를 사전으로 모은다(나중에 DataFrame 의 행)

for r in R_VALUES:
    # alpha 는 2 * r 로 두어 배율(alpha ÷ r)을 2 로 맞춘다
    config = LoraConfig(r=r, lora_alpha=2 * r, lora_dropout=0.05,
                        target_modules=LORA_TARGETS, task_type="CAUSAL_LM")
    peft_model = get_peft_model(model, config)          # 필름 붙이기
    # (학습 파라미터 수, 전체 파라미터 수)
    trainable, total = peft_model.get_nb_trainable_parameters()

    # 어댑터를 저장해 실제 파일 크기를 잰 뒤, 폴더는 지운다
    save_dir = f"out_ch08_adapter_r{r}"
    peft_model.save_pretrained(save_dir)
    file_mb = os.path.getsize(os.path.join(save_dir, "adapter_model.safetensors")) / 1024**2
    shutil.rmtree(save_dir)

    rows.append({"r": r, "학습 파라미터": trainable, "전체 파라미터": total,
                 "비율(%)": round(trainable / total * 100, 4), "실제 파일(MB)": round(file_mb, 2)})
    print(f"r={r:>2}: 학습 {trainable:,}개 / 전체 {total:,}개, 파일 {file_mb:.2f} MB")

    model = peft_model.unload()   # 필름을 떼고 원래 모델로 되돌린다(다음 r 을 위해)
    del peft_model
# 결과: r=16 에서 학습 8,798,208개 / 전체 502,830,976개, 파일 33.60 MB (실습 4와 같은 크기)

import pandas as pd

sizes = pd.DataFrame(rows)
# 1단계의 손계산 값과 예상 MB 를 열로 붙인다
sizes["손계산"] = sizes["r"].apply(lora_count_by_hand)
sizes["일치"] = sizes["학습 파라미터"] == sizes["손계산"]
sizes["예상(MB)"] = (sizes["손계산"] * 4 / 1024**2).round(2)
# r=16 을 기준(1.0)으로 몇 배인지
sizes["r=16 대비"] = sizes["학습 파라미터"] / sizes.loc[sizes["r"] == 16, "학습 파라미터"].iloc[0]

cols = ["r", "학습 파라미터", "손계산", "일치", "비율(%)", "예상(MB)", "실제 파일(MB)", "r=16 대비"]
print(sizes[cols].to_string(index=False))
# utf-8-sig: 엑셀에서 열어도 한글이 깨지지 않게 저장
sizes[cols].to_csv("out_ch08_lora_sizes.csv", index=False, encoding="utf-8-sig")
print("저장: out_ch08_lora_sizes.csv")
# 결과: 네 행 모두 일치 True, r=16 대비 0.25, 0.5, 1.0, 2.0

del model                 # 모델을 가리키는 이름을 지운다
gc.collect()              # 이름이 없어진 객체의 메모리를 돌려받는다
print("모델을 내렸습니다.")