트랜스포머와 대형 언어 모델의 원리
PyTorch로 파라미터 11만 개짜리 글자 단위 GPT를 직접 만들어 40초 만에 학습시켜요. 학습 전 손실이 이론값과 맞는지 확인하고, 1,500걸음 만에 받침에 맞춰 이/가를 고르는 문법과 학습 데이터에 없던 새 문장을 만들어 내는 것, 손실이 0이 될 수 없는 정보 이론적 바닥, 온도에 따라 되풀이하거나 깨지는 생성을 실험하고, GPT-3 같은 실제 모델로 규모를 키우면 무엇이 달라지는지 정리해요.
ChatGPT, Claude, Gemini 같은 대형 언어 모델(LLM)은 구조만 보면 놀랄 만큼 단순해요. 딥러닝 트랙의 마지막 강의에서 본 트랜스포머 블록을 여러 층 쌓고, 다음 토큰을 맞히도록 학습한 것이에요. 이번 강의에서는 그 구조를 PyTorch로 직접 만들어요. 파라미터 11만 개짜리 장난감이지만, 진짜 LLM과 같은 원리로 움직여요. 직접 만들어 보면 "다음 토큰 예측"이라는 단순한 목표에서 문법 같은 규칙이 어떻게 생겨나는지 눈으로 볼 수 있어요.
학습할 글 준비하기
규칙이 있는 짧은 문장 3,000개를 만들어 쓸게요. "언제, 누가, 어디서, 무엇을 했다" 구조예요. 주어 뒤에는 받침이 있으면 "이", 없으면 "가"가 붙어요. 이 문법 규칙을 모델이 스스로 배울 수 있을지가 관전 포인트예요.
import math
import re
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 = ["아침에", "저녁에", "주말에", "오늘", "어제"]
act = ["밥을 먹었다", "책을 읽었다", "노래를 불렀다", "잠을 잤다", "산책을 했다", "그림을 그렸다"]
def particle(w): # 받침이 있으면 '이', 없으면 '가'
return w + ("이" if (ord(w[-1]) - 0xAC00) % 28 else "가")
lines = [f"{rng.choice(when)} {particle(rng.choice(who))} {rng.choice(place)}에서 {rng.choice(act)}." for _ in range(3000)]
text = "\n".join(lines) + "\n"
chars = sorted(set(text))
stoi = {c: i for i, c in enumerate(chars)} # 글자 → 번호
itos = {i: c for c, i in stoi.items()} # 번호 → 글자
data = torch.tensor([stoi[c] for c in text])
print(lines[:2]) # ['어제 친구가 바다에서 책을 읽었다.', '저녁에 고양이가 집에서 밥을 먹었다.']
print(len(text), len(chars)) # 63835 62
토큰은 글자 단위로 했어요. 토큰 강의의 BPE를 써도 되지만, 글자 단위가 원리를 보기에 가장 단순해요. 서로 다른 글자 62개가 이 모델의 어휘예요.
모델: 트랜스포머 블록 쌓기
구조는 딥러닝 트랙에서 본 부품들의 조립이에요.
- 토큰 임베딩 + 위치 임베딩: 글자 번호를 벡터로 바꾸고, 몇 번째 자리인지 더해요.
- 블록 × 2: 층 정규화 → 인과 마스크를 씌운 멀티헤드 셀프 어텐션 → 잔차 연결 → 층 정규화 → 작은 신경망(MLP) → 잔차 연결
- 마지막 층 정규화와 출력층: 자리마다 어휘 62개에 대한 점수(로짓)를 내요.
block = 48 # 한 번에 보는 글자 수 (맥락 창)
def batch(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.manual_seed(0)
model = TinyGPT(len(chars))
print(sum(p.numel() for p in model.parameters())) # 111166
batch 함수가 핵심이에요. 48글자를 잘라 입력으로, 한 칸 밀린 48글자를 정답으로 써요. 인과 마스크 덕분에 각 자리는 자기 앞의 글자만 보고 다음 글자를 맞히니, 48글자 조각 하나가 다음 글자 맞히기 문제 48개가 돼요. 딥러닝 트랙에서 본 인과 마스크가 학습을 이렇게 효율적으로 만들어요.
학습 전 점검과 생성 함수
학습 기술 강의의 습관대로, 학습 전 손실이 이론값()과 비슷한지부터 확인해요. 그리고 글을 만들어 내는 함수를 준비해요. 마지막 자리의 점수를 온도로 나누고, 소프트맥스로 확률을 만든 뒤, 그 확률대로 다음 글자를 하나 뽑아 붙이기를 반복해요.
@torch.no_grad()
def generate(model, start, n, temperature=1.0, g=None):
model.eval()
idx = torch.tensor([[stoi[c] for c in start]])
for _ in range(n):
logits = model(idx[:, -block:])[:, -1] / max(temperature, 1e-6)
if temperature == 0:
nxt = logits.argmax(-1, keepdim=True) # 온도 0: 늘 1등만
else:
nxt = torch.multinomial(F.softmax(logits, -1), 1, generator=g)
idx = torch.cat([idx, nxt], 1) # 뽑은 글자를 붙여 다시 입력으로
return "".join(itos[i] for i in idx[0].tolist())
g = torch.Generator().manual_seed(0)
x, y = batch(64, g)
with torch.no_grad():
print(round(F.cross_entropy(model(x).flatten(0, 1), y.flatten()).item(), 3), round(math.log(len(chars)), 3)) # 4.253 4.127
print(repr(generate(model, "오늘 ", 30, 1.0, torch.Generator().manual_seed(1))))
처음 손실 4.253은 과 가까워요. 아무거나 고르는 수준에서 시작한다는 뜻이니 정상이에요. 학습 전 모델이 만든 글은 이래요.
오늘 \n다이가렸서교그노머양었양공구공니이잤도었잤관을녁다시책저에
말뭉치에 있는 글자들이 아무렇게나 섞여 나와요.
학습: 40초면 충분해요
opt = torch.optim.AdamW(model.parameters(), lr=3e-3)
for step in range(1, 1501):
model.train()
x, y = batch(64, g)
loss = F.cross_entropy(model(x).flatten(0, 1), y.flatten())
opt.zero_grad()
loss.backward()
opt.step()
if step in (100, 500, 1500):
print(step, round(loss.item(), 3), repr(generate(model, "오늘 ", 30, 0.8, torch.Generator().manual_seed(1))))
| 걸음 | 손실 | 만든 글 ("오늘 "으로 시작) |
|---|---|---|
| 100 | 0.395 | 오늘 고양이가 공원에서 책을 읽었다. / 저녁에 강아지가 공원에 |
| 500 | 0.360 | 오늘 고양이가 집에서 책을 읽었다. / 오늘 동생이 학교에서 그 |
| 1,500 | 0.352 | 오늘 고양이가 공원에서 책을 읽었다. / 저녁에 강아지가 바다에 |
100걸음 만에 손실이 4.25에서 0.40으로 떨어지고, 문장 구조가 완성돼요. CPU에서 1,500걸음이 40초쯤 걸려요.
손실은 왜 0이 되지 않을까
학습을 더 해도 손실은 0.35 근처에서 멈춰요. 모델이 부족해서가 아니에요. 문장마다 "언제(5가지), 누가(8가지), 어디서(6가지), 무엇을(6가지)"는 무작위로 골랐으니, 그 선택은 원리적으로 맞힐 수 없어요. 정보 이론 강의로 계산해 보면, 문장 하나에 담긴 무작위성은 냇이고, 문장 하나는 평균 21.28글자(줄바꿈 포함)라서 글자당 약 0.342냇이 이론적인 바닥이에요. 우리 모델의 0.352는 바닥에 거의 닿았어요. 남은 손실은 데이터 자체의 엔트로피예요. 진짜 언어 모델의 손실도 이렇게 "언어에 원래 있는 예측 불가능성" 아래로는 내려갈 수 없어요.
무엇을 배웠을까
모델이 만든 글 2,000자를 줄 단위로 나눠 살펴볼게요.
gen = generate(model, "\n", 2000, 0.8, torch.Generator().manual_seed(3)).split("\n")
gen = [s for s in gen[1:-1] if s]
pattern = re.compile(r"^(아침에|저녁에|주말에|오늘|어제) [가-힣]+(이|가) [가-힣]+에서 [가-힣]+(을|를) [가-힣]+\.$")
ok = [s for s in gen if pattern.match(s)]
novel = [s for s in ok if s not in set(lines)]
wrong = [s for s in ok if (s.split()[1][-1] == "가") != ((ord(s.split()[1][-2]) - 0xAC00) % 28 == 0)]
print(len(gen), len(ok), len(novel), len(wrong)) # 93 92 9 0
print(novel[:3])
- 93문장 중 92문장이 정해진 문장 구조를 지켰어요.
- 받침에 맞춰 이/가를 고르는 규칙은 한 번도 틀리지 않았어요. "고양이가", "선생님이", "동생이". 문법을 가르친 적이 없는데, 다음 글자를 맞히다 보니 저절로 익혔어요.
- 92문장 중 9문장은 학습 데이터에 없던 문장이에요. "아침에 강아지가 공원에서 잠을 잤다.", "아침에 아기가 바다에서 밥을 먹었다." 같은 문장이요. 1,440가지 조합 중 3,000번 뽑은 학습 데이터에 우연히 빠진 조합들인데, 모델은 외운 문장만 되풀이하지 않고 배운 규칙으로 새 문장을 조합했어요.
규모만 다를 뿐, 대형 언어 모델이 문법과 지식, 추론 패턴을 익히는 방식도 이와 같아요. 다음 토큰을 잘 맞히려면 결국 글 뒤에 숨은 규칙을 배워야 하거든요.
온도: 되풀이에서 횡설수설까지
같은 모델로 온도만 바꿔 "주말에 "로 시작하는 글을 만들어 볼게요.
for temp in [0, 0.5, 1.0, 2.0]:
print(temp, repr(generate(model, "주말에 ", 80, temp, torch.Generator().manual_seed(2))))
| 온도 | 만든 글 (일부) |
|---|---|
| 0 | 주말에 강아지가 시장에서 산책을 했다. / 아침에 고양이가 공원에서 그림을 그렸다. / 아침에 고양이가 공원에서 그림을 그렸다. / 아침에 고양이가 공원에서 그림 |
| 0.5 | 주말에 친구가 바다에서 노래를 불렀다. / 아침에 토끼가 공원에서 노래를 불렀다. / 어제 선생님이 학교에서 밥을 먹었다. |
| 1.0 | 주말에 친구가 바다에서 노래를 불렀다. / 아침에 토끼가 공원에서 노래를 불렀다. / 어제 선생님이 학교에서 밥을 먹었다. |
| 2.0 | 주말에 친구가 바다에서 노에서 그렸다. / 아침에 토끼가 공원에서 노래렀다 노래를 불렀다. / 아침에 친구가 집에서지님이 밥을 먹었다. |
- 온도 0은 늘 확률 1등만 골라요. 결정적이라 좋아 보이지만, 같은 문장을 끝없이 되풀이하는 함정에 빠져요. 1등만 고르면 한 번 들어선 길에서 빠져나오지 못하거든요.
- 0.5에서 1.0은 다양하면서도 문법에 맞아요.
- 2.0은 분포를 너무 평평하게 만들어서, 원래라면 거의 고르지 않을 글자까지 뽑혀 문장이 깨져요.
실제 서비스에서는 온도와 함께 top-k(확률 상위 k개 안에서만 뽑기)나 top-p(확률을 높은 순으로 더해 p가 될 때까지의 후보 안에서만 뽑기)를 써서, 엉뚱한 꼬리 후보를 아예 잘라 내요. 프롬프트 강의에서 정확해야 하는 일은 온도를 낮게 쓰라고 한 이유가 이 표에 있어요.
규모를 키우면
| 우리 모델 | GPT-2 (가장 작은 것, 2019) | GPT-3 (2020) | |
|---|---|---|---|
| 층 수 | 2 | 12 | 96 |
| 벡터 차원 | 64 | 768 | 12,288 |
| 어텐션 헤드 | 4 | 12 | 96 |
| 맥락 창 | 48글자 | 1,024토큰 | 2,048토큰 |
| 파라미터 | 11만 | 1억 2천만 | 1,750억 |
GPT-3는 우리 모델보다 약 157만 배 커요. 구조는 거의 같아요. 블록을 더 쌓고, 벡터를 더 넓히고, 맥락 창을 늘리고, 훨씬 많은 글(수천억 토큰)로 학습했을 뿐이에요. 그런데 이렇게 키우자 번역, 요약, 코딩, 추론 같은 능력이 나타났어요. 다음 강의에서 이 규모의 법칙을 다뤄요. 지금의 모델들은 맥락 창이 수십만 토큰을 넘고, 효율을 위한 여러 개선(위치 정보를 다루는 방법, 어텐션 계산 최적화 등)이 더해졌지만, 뼈대는 오늘 만든 것과 같아요.
생성을 빠르게: KV 캐시
우리 generate 함수는 글자 하나를 만들 때마다 앞의 모든 글자를 처음부터 다시 계산해요. 그런데 앞 글자들의 열쇠와 값은 새 글자가 붙어도 변하지 않아요(인과 마스크 덕분에 앞 자리는 뒤를 보지 않으니까요). 그래서 실제 모델은 계산해 둔 열쇠와 값을 저장해 두고(KV 캐시), 새 글자 하나 몫만 계산해요. 대신 맥락이 길수록 캐시가 메모리를 많이 차지해서, 긴 대화가 비싸지는 이유가 돼요.
실습
- 층 수를 1, 2, 4로 바꿔 1,500걸음 뒤 손실과 새 문장 비율을 비교해 보세요.
particle함수를 지우고 모든 주어에 "가"를 붙인 데이터로 학습하면 손실 바닥은 어떻게 변할까요? 예상한 뒤 확인하세요.generate함수에 top-k 샘플링을 추가해(로짓에서 상위 k개만 남기고 나머지는 ) 온도 2.0에서도 문장이 덜 깨지는지 확인하세요.- 맥락 창(
block)을 8로 줄이면 무엇을 못 배우게 될까요? 학습해서 만든 글을 보세요.
자주 하는 실수
- 정답을 한 칸 밀지 않기. 입력과 같은 글자를 정답으로 주면 모델은 자기 입력을 베끼는 법만 배워요.
- 인과 마스크 빼먹기. 학습 손실은 0에 가깝게 떨어지지만, 생성하면 엉망이 돼요. 미래를 보고 맞혔기 때문이에요.
- 손실이 0이 되기를 기대하기. 데이터에 원래 있는 무작위성이 바닥을 정해요.
- 온도 0이면 가장 좋은 글이 나온다고 생각하기. 되풀이 함정에 빠지기 쉬워요.
점검 문제
- 48글자 조각 하나로 다음 글자 맞히기 문제를 몇 개 만들 수 있나요? 그게 가능한 이유는?
- 어휘가 62개인 모델의 학습 전 손실은 대략 얼마여야 하나요?
- 학습을 오래 해도 손실이 0.34 아래로 내려가지 않은 이유는?
- 온도 0으로 생성하면 생기기 쉬운 문제는?
- KV 캐시는 무엇을 저장하고, 왜 그게 가능한가요?
정답
- 48개예요. 인과 마스크 덕분에 각 자리가 자기 앞의 글자만 보고 다음 글자를 맞히는 독립된 문제가 되기 때문이에요.
- 이에요.
- 문장의 단어 선택이 무작위라서 원리적으로 맞힐 수 없는 부분이 있기 때문이에요. 그 엔트로피가 글자당 약 0.342냇이에요.
- 확률 1등만 고르다 같은 문장이나 구절을 끝없이 되풀이하기 쉬워요.
- 이미 처리한 토큰들의 열쇠와 값을 저장해요. 인과 마스크 때문에 앞 토큰의 계산은 뒤에 토큰이 붙어도 변하지 않기 때문에 다시 계산할 필요가 없어요.
다음 강의
장난감 모델을 수십만 배 키우면 무엇이 달라질까요? 다음 강의에서는 인터넷 규모의 글로 하는 사전 학습, 크기와 데이터와 계산량 사이의 스케일링 법칙, 그리고 다음 토큰 예측기를 "도움이 되는 대화 상대"로 바꾸는 정렬(지시 학습과 사람 피드백 강화 학습)을 배워요.