파인튜닝과 LoRA: 모델을 내 일에 맞추기

프롬프트와 RAG로 안 되는 일, 즉 말투와 형식과 작업 방식처럼 모델의 행동을 바꾸고 싶을 때 쓰는 파인튜닝을 다뤄요. 앞 강의의 미니 GPT에 LoRA를 직접 구현해 붙이고, 파라미터 7%만 학습해서 반말 모델에게 존댓말을 가르친 뒤 스위치 하나로 원래 모델로 되돌려 봐요. 계수 1로도 충분한 이유, 70억 파라미터 모델에 필요한 메모리 계산, 데이터 준비와 안전성 재검사까지 정리해요.

고급강의 6 / 9약 20분

RAG는 모델에게 새 지식을 건네줬어요. 그런데 지식이 아니라 행동을 바꾸고 싶을 때가 있어요. 늘 정해진 JSON 형식으로만 답하게 하거나, 우리 회사 상담원의 말투를 쓰게 하거나, 고객 문의를 우리만의 기준으로 분류하게 하는 것처럼요. 이럴 때 모델의 가중치 자체를 우리 데이터로 조금 더 학습시키는 것이 파인튜닝(미세 조정)이에요. 사전 학습과 정렬 강의에서 본 지시 학습(SFT)도 파인튜닝의 한 종류예요.

파인튜닝은 언제 할까

파인튜닝은 데이터를 모으고, 학습하고, 평가하고, 배포하는 비용이 들어요. 그래서 보통 이 순서로 시도해요.

  1. 프롬프트 다듬기: 지시를 구체적으로 쓰고 형식을 정해 줘요.
  2. 예시 넣기: 퓨샷 예시로 기준을 보여 줘요.
  3. RAG: 모델이 모르는 지식이 문제라면 자료를 찾아 넣어 줘요.
  4. 파인튜닝: 위의 방법으로도 행동이 안정적이지 않거나, 지시와 예시가 너무 길어 매번 비용이 클 때 해요.
문제먼저 해 볼 것
우리 회사 규정을 몰라요RAG
말투나 출력 형식이 자꾸 어긋나요프롬프트와 예시, 그래도 안 되면 파인튜닝
프롬프트가 너무 길어서 요청마다 비싸요파인튜닝으로 지시를 모델 안에 넣기
큰 모델은 비싸고 느려요큰 모델이 만든 좋은 답으로 작은 모델을 파인튜닝(증류)

사실을 가르치는 데는 파인튜닝이 잘 맞지 않아요. 2024년의 한 연구는 모델이 모르던 사실을 파인튜닝으로 가르치면 학습이 느리고, 그 사실들을 결국 배우고 나면 오히려 환각이 늘어나는 경향을 보고했어요. 사실은 RAG로 건네주고, 파인튜닝은 행동을 다듬는 데 쓰는 것이 기본 원칙이에요.

파인튜닝 데이터

데이터는 보통 지시와 모범 답의 쌍이에요. 대화형 모델이라면 대화 형식으로 만들어요.

{"messages": [
  {"role": "user", "content": "문의를 배송, 환불, 계정, 기타 중 하나로 분류해 줘: 비밀번호를 바꿨는데 로그인이 안 돼요."},
  {"role": "assistant", "content": "계정"}
]}

이런 예시를 수백, 수천 개 모아요. 모범 답에는 모델이 알 수 없는 사실(특정 주문의 배송 상황 같은 것)을 넣지 않아요. 그런 답을 배우면 모델은 모르는 것도 아는 척 지어내는 법을 배워요.

데이터를 준비할 때 챙길 것들이에요.

  • 양보다 질: 2023년의 LIMA 연구는 정성 들여 고른 예시 1,000개만으로 지시 학습을 해서 좋은 결과를 냈어요. 어설픈 예시 만 개보다 훌륭한 예시 천 개가 나아요. 모델은 예시의 실수까지 충실히 배워요.
  • 다양하게: 쉬운 경우만 넣지 말고, 애매한 경우와 거절해야 하는 경우도 넣어요.
  • 답 부분만 학습하기: 질문 부분까지 손실에 넣으면 모델이 "질문 쓰는 법"까지 배우느라 힘을 나눠 써요. 보통 질문 토큰은 손실에서 빼고 답 토큰만 학습해요.
  • 평가 세트 떼어 두기: 학습에 안 쓴 예시로 전후를 비교해요. 중복도 제거해요.
  • 개인 정보 지우기: 모델은 학습 데이터를 외웠다가 그대로 말할 수 있어요.

전체 파인튜닝의 부담

모든 가중치를 학습하는 전체 파인튜닝은 두 가지가 부담이에요.

  • 메모리: 아담 옵티마이저로 학습하면 파라미터 하나마다 가중치, 기울기, 아담의 상태 두 개를 들고 있어야 해요. 흔히 쓰는 혼합 정밀도 학습에서는 파라미터당 약 16바이트예요(16비트 가중치 2, 16비트 기울기 2, 32비트 가중치 사본 4, 아담 상태 4와 4). 70억 파라미터면 100GB가 넘어요. 중간 계산값을 위한 메모리는 따로예요.
  • 저장: 작업마다 모델 전체를 하나씩 저장해야 해요. 고객사 10곳에 맞춘 모델 10개를 서비스하려면 모델 10벌이 필요해요.

LoRA: 변화량만 작게 배우기

LoRA(Low-Rank Adaptation, 2021)의 생각은 이래요. 원래 가중치 WW는 얼려 두고, 바뀌는 양 ΔW\Delta W만 학습해요. 그런데 ΔW\Delta W를 원래 크기 그대로 배우지 않고, 계수가 낮은 두 행렬의 곱으로 만들어요.

W′=W+αrBA,B:dout×r,A:r×dinW' = W + \frac{\alpha}{r} B A, \qquad B: d_{\text{out}} \times r, \quad A: r \times d_{\text{in}}

rr은 계수(랭크)예요. 선형대수 트랙의 SVD 강의에서 본 것처럼, 계수 rr짜리 행렬은 "패턴 rr장"을 겹친 것이에요. 4096×40964096 \times 4096 가중치라면 원래는 1,677만 개를 배워야 하지만, r=8r = 8이면 8×(4096+4096)=65,5368 \times (4096 + 4096) = 65{,}536개, 0.39%만 배우면 돼요.

몇 가지 세부 장치가 있어요.

  • BB를 0으로 시작해요. 그러면 학습 첫 순간의 모델은 원래 모델과 똑같고, 거기서부터 조금씩 움직여요.
  • α/r\alpha / r은 크기 조절용이에요. rr을 바꿔도 학습률을 다시 맞추지 않아도 되게 해 줘요.
  • 학습이 끝나면 W+αrBAW + \frac{\alpha}{r} BA를 계산해 행렬 하나로 합칠 수 있어요. 그러면 추론 속도는 원래 모델과 같아요.

LoRA 논문은 GPT-3(1,750억 파라미터)에서 학습할 파라미터를 1만 분의 1로, GPU 메모리를 3분의 1로 줄이면서 전체 파인튜닝에 견줄 만한 성능을 냈다고 보고했어요. 낮은 계수로 충분한 이유는, 이미 많은 것을 아는 모델을 새 작업에 맞추는 데 필요한 변화가 몇 개의 방향에 몰려 있기 때문이라고 설명해요. 직접 확인해 볼게요.

실습: 반말 모델에게 존댓말 가르치기

트랜스포머 강의의 미니 GPT를 다시 써요. 사전 학습 데이터는 대부분 반말이고 3%만 존댓말이에요. 존댓말을 본 적은 있지만 거의 쓰지 않는 기반 모델인 셈이에요. 그다음 존댓말 문장 200개로 파인튜닝해요.

import copy
import math
import numpy as np
import torch
from torch import nn
import torch.nn.functional as F

rng = np.random.default_rng(0)
who = ["고양이", "강아지", "토끼", "아기", "할머니", "친구", "선생님", "동생"]
place = ["집", "공원", "학교", "바다", "시장", "도서관"]
when = ["아침에", "저녁에", "주말에", "오늘", "어제"]
plain = ["밥을 먹었다", "책을 읽었다", "노래를 불렀다", "잠을 잤다", "산책을 했다", "그림을 그렸다"]
polite = ["밥을 먹었어요", "책을 읽었어요", "노래를 불렀어요", "잠을 잤어요", "산책을 했어요", "그림을 그렸어요"]

def particle(w):                                     # 받침이 있으면 '이', 없으면 '가'
    return w + ("이" if (ord(w[-1]) - 0xAC00) % 28 else "가")

def sentence(style):
    end = (polite if style == "polite" else plain)[rng.integers(6)]
    return f"{rng.choice(when)} {particle(rng.choice(who))} {rng.choice(place)}에서 {end}."

pre_lines = [sentence("polite" if rng.random() < 0.03 else "plain") for _ in range(3000)]
ft_lines = [sentence("polite") for _ in range(200)]   # 파인튜닝 데이터: 전부 존댓말
plain_val = [sentence("plain") for _ in range(300)]   # 반말 실력 확인용
pre_text = "\n".join(pre_lines) + "\n"
ft_text = "\n".join(ft_lines) + "\n"
chars = sorted(set(pre_text + ft_text))
stoi = {c: i for i, c in enumerate(chars)}
itos = {i: c for c, i in stoi.items()}
print(len(chars), sum(s.endswith("요.") for s in pre_lines))
63 100

어휘는 63글자이고, 사전 학습 문장 3,000개 중 100개가 존댓말이에요. 모델 코드는 트랜스포머 강의와 같아요. 결과를 한 줄로 보여 주는 report 함수를 더했어요. 문장 140개쯤을 생성해서 존댓말 비율, 주어 조사가 틀린 횟수, 그리고 반말 문장에 대한 손실을 재요.

block = 48

def encode(text):
    return torch.tensor([stoi[c] for c in text])

def batch(data, bs, g):
    ix = torch.randint(len(data) - block - 1, (bs,), generator=g)
    x = torch.stack([data[i:i + block] for i in ix])
    y = torch.stack([data[i + 1:i + block + 1] for i in ix])
    return x, y

class Block(nn.Module):
    def __init__(self, d, heads):
        super().__init__()
        self.ln1, self.ln2 = nn.LayerNorm(d), nn.LayerNorm(d)
        self.qkv = nn.Linear(d, 3 * d)
        self.proj = nn.Linear(d, d)
        self.mlp = nn.Sequential(nn.Linear(d, 4 * d), nn.GELU(), nn.Linear(4 * d, d))
        self.heads = heads
    def forward(self, x):
        B, T, D = x.shape
        q, k, v = self.qkv(self.ln1(x)).split(D, dim=2)
        q, k, v = [t.view(B, T, self.heads, D // self.heads).transpose(1, 2) for t in (q, k, v)]
        a = F.scaled_dot_product_attention(q, k, v, is_causal=True)
        x = x + self.proj(a.transpose(1, 2).reshape(B, T, D))
        return x + self.mlp(self.ln2(x))

class TinyGPT(nn.Module):
    def __init__(self, vocab, d=64, heads=4, layers=2):
        super().__init__()
        self.tok = nn.Embedding(vocab, d)
        self.pos = nn.Embedding(block, d)
        self.blocks = nn.Sequential(*[Block(d, heads) for _ in range(layers)])
        self.ln = nn.LayerNorm(d)
        self.head = nn.Linear(d, vocab)
    def forward(self, idx):
        x = self.tok(idx) + self.pos(torch.arange(idx.shape[1]))
        return self.head(self.ln(self.blocks(x)))

@torch.no_grad()
def generate(model, start, n, temperature=1.0, seed=0):
    model.eval()
    g = torch.Generator().manual_seed(seed)
    idx = encode(start)[None]
    for _ in range(n):
        logits = model(idx[:, -block:])[:, -1] / temperature
        idx = torch.cat([idx, torch.multinomial(F.softmax(logits, -1), 1, generator=g)], 1)
    return "".join(itos[i] for i in idx[0].tolist())

def train(model, text, steps, lr, seed=0):
    data = encode(text)
    opt = torch.optim.AdamW([p for p in model.parameters() if p.requires_grad], lr=lr)
    g = torch.Generator().manual_seed(seed)
    for _ in range(steps):
        model.train()
        x, y = batch(data, 64, g)
        loss = F.cross_entropy(model(x).flatten(0, 1), y.flatten())
        opt.zero_grad()
        loss.backward()
        opt.step()
    return round(loss.item(), 3)

@torch.no_grad()
def plain_loss(model):                               # 반말 문장을 얼마나 잘 예측하나
    model.eval()
    data = encode("\n".join(plain_val) + "\n")
    x, y = data[:-1].unfold(0, block, block), data[1:].unfold(0, block, block)
    return round(F.cross_entropy(model(x).flatten(0, 1), y.flatten()).item(), 3)

def report(model, seed=3):
    lines = [s for s in generate(model, "\n", 3000, 1.0, seed).split("\n")[1:-1] if s.endswith(".")]
    n_polite = sum(s.endswith("요.") for s in lines)
    wrong = 0
    for s in lines:                                  # 주어의 조사가 받침과 맞는지
        words = s.split()
        if len(words) > 1 and len(words[1]) > 1:
            w = words[1]
            wrong += (w[-1] == "이") != ((ord(w[-2]) - 0xAC00) % 28 != 0)
    return f"존댓말 {n_polite}/{len(lines)}, 조사 틀림 {wrong}, 반말 손실 {plain_loss(model)}"

먼저 사전 학습을 해서 기반 모델을 만들어요. 컴퓨터에 따라 1분 정도 걸려요.

torch.manual_seed(0)
base = TinyGPT(len(chars))
print(sum(p.numel() for p in base.parameters()))
print(train(base, pre_text, 1500, 3e-3))
print(report(base))
111295
0.352
존댓말 3/142, 조사 틀림 1, 반말 손실 0.361

기반 모델은 문장 142개 중 3개(2%)만 존댓말로 썼어요. 데이터의 3%와 비슷하게, 존댓말을 알긴 하지만 거의 쓰지 않아요.

LoRA 직접 만들기

nn.Linear를 감싸서, 원래 층의 출력에 αrBAx\frac{\alpha}{r} BAx를 더하는 층을 만들어요. 원래 가중치는 전부 얼리고, 트랜스포머 블록 안의 선형 층 네 종류에 LoRA를 붙여요.

class LoRALinear(nn.Module):
    def __init__(self, base_layer, r=4, alpha=8):
        super().__init__()
        self.base = base_layer                       # 원래 층 (얼려 둠)
        d_in, d_out = base_layer.in_features, base_layer.out_features
        self.A = nn.Parameter(torch.randn(r, d_in) / math.sqrt(d_in))
        self.B = nn.Parameter(torch.zeros(d_out, r))  # 0에서 시작: 처음엔 원래 모델과 똑같아요
        self.scale = alpha / r
        self.enabled = True
    def forward(self, x):
        y = self.base(x)
        if self.enabled:
            y = y + (x @ self.A.T @ self.B.T) * self.scale
        return y

def add_lora(model, r=4, alpha=8):
    for p in model.parameters():
        p.requires_grad = False                      # 원래 가중치는 전부 얼리고
    for blk in model.blocks:                         # 선형 층마다 LoRA를 덧붙여요
        blk.qkv = LoRALinear(blk.qkv, r, alpha)
        blk.proj = LoRALinear(blk.proj, r, alpha)
        blk.mlp[0] = LoRALinear(blk.mlp[0], r, alpha)
        blk.mlp[2] = LoRALinear(blk.mlp[2], r, alpha)
    return model

def set_lora(model, on):
    for m in model.modules():
        if isinstance(m, LoRALinear):
            m.enabled = on

torch.manual_seed(1)
lora = add_lora(copy.deepcopy(base))
print(sum(p.numel() for p in lora.parameters() if p.requires_grad))
8192

학습할 파라미터는 8,192개로 전체 111,295개의 7.4%예요. 우리 모델은 폭이 64로 아주 좁아서 비율이 큰 편이에요. 폭이 4,096인 실제 모델에서는 같은 계수로 1% 아래로 내려가요.

전체 파인튜닝과 비교하기

같은 존댓말 데이터로 300걸음씩 학습해요. LoRA는 학습하는 양이 적어서 보통 더 큰 학습률을 써요.

full = copy.deepcopy(base)                           # 비교용: 전부 학습
print("전체 파인튜닝", train(full, ft_text, 300, 1e-3, seed=1), report(full))
print("LoRA", train(lora, ft_text, 300, 3e-3, seed=1), report(lora))
전체 파인튜닝 0.293 존댓말 135/136, 조사 틀림 4, 반말 손실 0.765
LoRA 0.337 존댓말 133/135, 조사 틀림 0, 반말 손실 0.582
학습 파라미터존댓말 비율조사 틀림반말 손실
기반 모델3/14210.361
전체 파인튜닝111,295135/13640.765
LoRA (r=4r = 4)8,192133/13500.582

둘 다 거의 모든 문장을 존댓말로 쓰게 됐어요. 받침에 맞춰 이/가를 고르는 문법도 그대로 지켰어요. 사전 학습 때 배운 문법은 건드리지 않고 말투만 바꾼 거예요.

반말 손실은 둘 다 올랐어요. 이건 자연스러워요. 이제 모델은 문장 끝에 "요"가 올 거라고 기대하니까 반말 문장이 덜 그럴듯해 보이는 거예요. 다만 전체 파인튜닝이 더 많이 올랐어요(0.765와 0.582). 모든 가중치를 움직이니 원래 모델에서 더 멀리 간 거예요. 2024년의 한 연구는 이 현상을 논문 제목으로 요약했어요. "LoRA는 덜 배우고, 덜 잊는다." 조사 실수도 전체 파인튜닝이 4번으로 가장 많았는데, 숫자가 작아서 이것만으로 단정하긴 어려워요.

스위치 하나로 되돌리기

LoRA의 진짜 매력은 원래 가중치를 건드리지 않았다는 데 있어요. 덧붙인 부분만 끄면 어떻게 될까요?

set_lora(lora, False)
print("LoRA 끔", report(lora))
print(repr(generate(lora, "\n", 70, 0.8, seed=6)))
set_lora(lora, True)
print(repr(generate(lora, "\n", 70, 0.8, seed=6)))
LoRA 끔 존댓말 3/142, 조사 틀림 1, 반말 손실 0.361
'\n주말에 할머니가 도서관에서 잠을 잤다.\n아침에 토끼가 바다에서 밥을 먹었다.\n저녁에 친구가 도서관에서 책을 읽었다.\n주말에 아'
'\n주말에 할머니가 도서관에서 잠을 잤어요.\n어제 토끼가 바다에서 밥을 먹었어요.\n오늘 친구가 도서관에서 책을 읽었어요.\n아침에 '

끄면 기반 모델과 숫자 하나 다르지 않게 돌아오고, 켜면 존댓말을 써요. 같은 씨앗으로 생성하니 할머니가 도서관에서 잠을 잔 이야기가 말투만 바뀌어 나와요. 실무에서는 이 성질 덕분에 기반 모델 하나에 작은 어댑터 여러 개를 두고, 요청마다 고객사나 작업에 맞는 어댑터를 골라 끼워요. 70억 파라미터 모델은 16비트로 13GB가 넘지만, 어댑터 하나는 수 MB에서 수십 MB예요.

어댑터를 따로 둘 필요가 없다면 행렬 하나로 합쳐요.

layer = lora.blocks[0].qkv
x = torch.randn(5, 64)
with torch.no_grad():
    merged = layer.base.weight + layer.scale * layer.B @ layer.A   # 행렬 하나로 합치기
    diff = (layer(x) - (x @ merged.T + layer.base.bias)).abs().max()
print(merged.shape, float(diff) < 1e-5)
torch.Size([192, 64]) True

합친 행렬은 원래 층과 크기가 같고 결과도 같아요(차이는 부동소수점 반올림 수준). 추론할 때 추가 비용이 전혀 없어요.

계수는 얼마나 필요할까

for r in (1, 4, 16):
    torch.manual_seed(1)
    m = add_lora(copy.deepcopy(base), r=r, alpha=2 * r)
    n = sum(p.numel() for p in m.parameters() if p.requires_grad)
    print(r, n, train(m, ft_text, 300, 3e-3, seed=1), report(m))
1 2048 0.346 존댓말 133/134, 조사 틀림 0, 반말 손실 0.571
4 8192 0.337 존댓말 133/135, 조사 틀림 0, 반말 손실 0.582
16 32768 0.312 존댓말 136/136, 조사 틀림 1, 반말 손실 0.605

계수 1, 학습 파라미터 2,048개(모델의 1.8%)로도 존댓말을 완전히 배웠어요. 층마다 "패턴 한 장"만 더한 건데요. 말투 바꾸기는 모델이 이미 아는 능력의 방향을 살짝 트는 일이라 단순한 변화로 충분해요. 2023년의 LIMA 연구가 주장한 것과 같은 그림이에요. 지식과 능력은 거의 다 사전 학습에서 생기고, 파인튜닝은 그걸 어떻게 꺼내 쓸지를 가르친다는 거예요.

계수를 키우면 파인튜닝 데이터의 손실은 더 낮아지지만(0.346에서 0.312) 반말 손실은 올라가요(0.571에서 0.605). 더 많이 바꿀수록 원래 모델에서 멀어져요. 새 언어나 어려운 전문 분야처럼 큰 변화가 필요한 작업이라면 계수를 키워야 해요. 실무에서는 흔히 8에서 64 사이에서 시작해 평가로 정해요.

실제 크기의 모델이라면

공개된 70억 파라미터 모델들의 흔한 구조(층 32개, 은닉 차원 4,096, MLP 차원 11,008, 어휘 3만 2천)로 계산해 볼게요.

layers, d, d_mlp = 32, 4096, 11008
attn = 4 * d * d                                     # q, k, v, o
mlp = 3 * d * d_mlp                                  # gate, up, down
total = layers * (attn + mlp) + 2 * 32000 * d        # 입력 임베딩과 출력층(어휘 3만 2천)
print(f"전체 {total / 1e9:.2f}B")
r = 8
lora_qv = layers * 2 * r * (d + d)                   # q, v에만 계수 8
r = 16
lora_all = layers * (4 * r * (d + d) + 3 * r * (d + d_mlp))   # 모든 선형 층에 계수 16
print(f"{lora_qv:,} {lora_qv / total:.2%}  {lora_all:,} {lora_all / total:.2%}")
print(f"전체 파인튜닝 약 {total * 16 / 1e9:.0f}GB, 16비트 가중치 {total * 2 / 1e9:.1f}GB, 4비트 {total * 0.5 / 1e9:.1f}GB")
전체 6.74B
4,194,304 0.06%  39,976,960 0.59%
전체 파인튜닝 약 108GB, 16비트 가중치 13.5GB, 4비트 3.4GB
방식학습 파라미터메모리 어림 (중간 계산값 제외)
전체 파인튜닝67억 개 (100%)약 108GB
LoRA, q와 v에만 r=8r = 8419만 개 (0.06%)가중치 13.5GB + 조금
LoRA, 모든 선형 층에 r=16r = 164,000만 개 (0.59%)가중치 13.5GB + 조금
QLoRA (4비트 가중치 + LoRA)위와 같음가중치 3.4GB + 조금

QLoRA(2023)는 얼려 둔 원래 가중치를 4비트로 압축해 저장하고, 계산할 때만 풀어서 써요. 학습하는 LoRA 부분은 16비트로 두고요. 이 방법으로 650억 파라미터 모델을 48GB GPU 한 장에서 파인튜닝할 수 있게 됐어요. 양자화는 AI 엔지니어링 트랙의 추론 최적화 강의에서 자세히 다뤄요.

실무 감각

  • 학습률과 횟수: LoRA는 전체 파인튜닝보다 큰 학습률을 써요. 데이터를 1에서 3번 정도 돌며 검증 손실을 지켜보고, 학습 손실만 내려가고 검증 손실이 오르기 시작하면 멈춰요.
  • 전후 평가: 목표 작업만 보지 말고, 원래 잘하던 일(일반 능력)이 망가지지 않았는지도 함께 재요. 위 실험의 반말 손실이 그런 역할이에요.
  • 잊어버림 줄이기: 파인튜닝 데이터에 원래 성격의 데이터를 조금 섞으면 덜 잊어요.
  • 안전성 다시 검사하기: 2023년의 한 연구는 안전하게 정렬된 모델도 해로운 예시 10개로 파인튜닝하자 안전장치가 무너졌고, 평범한 데이터로 파인튜닝해도 안전성이 약해질 수 있다고 보고했어요. 파인튜닝 뒤에는 거절해야 할 요청을 여전히 거절하는지 꼭 다시 확인해요.
  • 증류와 약관: 큰 모델의 답으로 작은 모델을 학습시킬 때는, 그 모델 제공자의 이용 약관이 출력물을 학습에 쓰는 걸 허용하는지 먼저 확인해요.
  • 도구: 공개 모델은 LoRA 같은 기법을 모아 둔 라이브러리(허깅페이스의 PEFT 등)로 몇 줄이면 붙일 수 있어요. 일부 AI 회사는 데이터를 올리면 대신 파인튜닝해 주는 서비스도 제공해요.

실습

  1. 파인튜닝 데이터를 200문장에서 20문장으로 줄이면 존댓말 비율과 조사 실수가 어떻게 변하나요?
  2. LoRA를 qkv에만 붙이고 나머지 층은 그대로 두면 어떻게 되나요?
  3. 파인튜닝 걸음 수를 30, 100으로 줄여 존댓말 비율이 언제 바뀌기 시작하는지 보세요.
  4. 파인튜닝 데이터에 반말 문장을 20% 섞으면 반말 손실이 덜 오르나요? 존댓말 비율은 어떻게 되나요?
  5. 계수 1 LoRA의 BABA 행렬을 torch.linalg.svdvals로 분해해서, 0이 아닌 특이값이 정말 1개인지 확인해 보세요.

자주 하는 실수

  • 프롬프트로 될 일을 파인튜닝부터 하기. 데이터와 평가 비용이 훨씬 커요.
  • 사실을 가르치려고 파인튜닝하기. 바뀌는 사실은 RAG가 맞아요.
  • 평가 세트 없이 학습하기. 좋아졌는지 나빠졌는지 알 수 없어요.
  • 질문까지 손실에 넣기. 답 토큰만 학습해요.
  • 목표 작업만 평가하기. 일반 능력과 안전성이 망가졌을 수 있어요.
  • 계수를 키울수록 좋다고 믿기. 위 실험처럼 더 많이 바꾸면 원래 모델에서 더 멀어져요.

점검 문제

  1. RAG와 파인튜닝은 각각 모델의 무엇을 바꾸나요?
  2. 4096×40964096 \times 4096 가중치에 계수 8 LoRA를 붙이면 학습할 파라미터는 몇 개인가요?
  3. LoRA의 BB 행렬을 0으로 시작하는 이유는?
  4. 실험에서 LoRA를 끄자 숫자가 기반 모델과 정확히 같아진 이유는?
  5. 70억 파라미터 모델을 전체 파인튜닝하는 데 100GB가 넘는 메모리가 드는 이유는?
  6. 파인튜닝 뒤에 안전성을 다시 검사해야 하는 이유는?

정답

  1. RAG는 프롬프트에 넣는 자료를 바꿔서 모델이 아는 지식을 넓혀요. 파인튜닝은 가중치를 바꿔서 모델의 행동(말투, 형식, 작업 방식)을 바꿔요.
  2. 8×(4096+4096)=65,5368 \times (4096 + 4096) = 65{,}536개예요. 원래 1,677만 개의 0.39%예요.
  3. 학습을 시작하는 순간 BA=0BA = 0이라 모델이 원래 모델과 똑같이 출발해요. 이미 잘 학습된 모델을 망가뜨리지 않고 거기서부터 조금씩 바꿀 수 있어요.
  4. 원래 가중치는 얼려 둬서 전혀 바뀌지 않았고, 덧붙인 BABA 부분만 학습했기 때문이에요. 덧붙인 부분을 빼면 원래 모델 그대로예요.
  5. 아담으로 학습하면 파라미터마다 가중치, 기울기, 아담 상태 두 개, 32비트 사본을 들고 있어서 약 16바이트가 들어요. 6.74×109×16≈1086.74 \times 10^9 \times 16 \approx 108GB예요.
  6. 평범한 데이터로 파인튜닝해도 정렬로 다듬은 안전한 행동이 약해질 수 있다는 연구 결과가 있기 때문이에요.

다음 강의

지금까지는 모델이 글을 읽고 쓰는 데서 끝났어요. 다음 강의에서는 모델이 계산기, 검색, 코드 실행 같은 도구를 골라 쓰고, 결과를 보고 다음 행동을 정하는 AI 에이전트를 직접 만들어 봐요. 에이전트가 어디서 실수하고, 왜 사람의 확인이 필요한지도 함께 다뤄요.