토큰과 임베딩: 언어를 숫자로 바꾸는 법
글자, 바이트, 단어 대신 자주 쓰는 조각으로 글을 자르는 BPE를 직접 구현해, 처음 보는 단어도 아는 조각으로 쪼개지는 원리를 확인해요. 토큰 수가 비용과 맥락 창을 정하는 이유를 짚고, 단어가 함께 나오는 패턴만으로 뜻이 담긴 벡터를 만들어 고양이 옆에 강아지가, 김치 옆에 라면이 놓이는 것을 확인한 뒤, 임베딩 층과 의미 검색으로 이어져요.
신경망은 숫자만 먹어요. 그런데 "오늘 날씨 어때?"는 숫자가 아니죠. 언어 모델이 글을 다루려면 두 단계가 필요해요. 먼저 글을 토큰이라는 조각으로 자르고 번호를 붙여요. 그다음 번호마다 뜻이 담긴 숫자 벡터, 임베딩을 붙여요. 이번 강의에서는 이 두 단계를 직접 만들어 봐요. 앞 강의의 "토큰", "맥락 창"이라는 말이 무슨 뜻인지 손에 잡히게 될 거예요.
무엇을 단위로 자를까
컴퓨터 안에서 글은 결국 바이트예요. UTF-8로 저장하면 영어 한 글자는 1바이트, 한글 한 글자는 3바이트, 이모지는 4바이트예요.
import re
from collections import Counter
import numpy as np
for s in ["cat", "고양이", "😺"]:
b = s.encode("utf-8")
print(s, len(s), "글자", len(b), "바이트", list(b))
# cat 3 글자 3 바이트 [99, 97, 116]
# 고양이 3 글자 9 바이트 [234, 179, 160, 236, 150, 145, 236, 157, 180]
# 😺 1 글자 4 바이트 [240, 159, 152, 186]
글을 자르는 단위에는 세 가지 선택지가 있어요.
| 단위 | 장점 | 단점 |
|---|---|---|
| 글자(또는 바이트) | 종류가 적고, 처음 보는 단어가 없어요 | 순서가 너무 길어져서 계산이 비싸고, 뜻을 배우기 어려워요 |
| 단어 | 뜻 단위라 짧아요 | 종류가 수백만 개이고, 처음 보는 단어(신조어, 오타)를 다루지 못해요 |
| 자주 쓰는 조각 | 둘의 장점을 섞어요 | 자르는 규칙을 데이터에서 배워야 해요 |
지금의 언어 모델은 거의 모두 세 번째, 부분 단어 토큰을 써요. 자주 나오는 단어는 통째로 하나, 드문 단어는 아는 조각 여러 개로 나눠요.
BPE: 자주 붙어 다니는 짝을 합치기
가장 널리 쓰는 방법이 BPE(바이트 쌍 인코딩)예요. 원리는 아주 단순해요.
- 모든 단어를 글자 단위로 쪼개요.
- 말뭉치 전체에서 가장 자주 나란히 나오는 두 조각을 찾아 하나로 합쳐요.
- 원하는 개수만큼 2를 반복해요.
작은 영어 말뭉치로 직접 해 볼게요. 단어 끝에는 </w> 표시를 붙여 "단어 끝의 조각"을 구분해요.
corpus = ("low lower lowest newer newest wider widest " * 3 + "low low low lower newest newest " * 5).split()
vocab = {tuple(w) + ("</w>",): c for w, c in Counter(corpus).items()}
def pair_counts(vocab):
pairs = Counter()
for sym, c in vocab.items():
for a, b in zip(sym, sym[1:]):
pairs[(a, b)] += c
return pairs
def merge(vocab, pair):
out = {}
for sym, c in vocab.items():
s, i = [], 0
while i < len(sym):
if i < len(sym) - 1 and (sym[i], sym[i + 1]) == pair:
s.append(sym[i] + sym[i + 1])
i += 2
else:
s.append(sym[i])
i += 1
out[tuple(s)] = c
return out
merges = []
for step in range(10):
pairs = pair_counts(vocab)
best = max(pairs, key=pairs.get) # 가장 자주 붙어 나오는 짝
merges.append(best)
vocab = merge(vocab, best)
print(step + 1, best, pairs[best])
| 순서 | 합친 짝 | 나온 횟수 |
|---|---|---|
| 1 | l + o | 29 |
| 2 | lo + w | 29 |
| 3 | e + s | 19 |
| 4 | es + t | 19 |
| 5 | est + </w> | 19 |
| 6 | low + </w> | 18 |
| 7 | n + e | 16 |
| 8 | ne + w | 16 |
| 9 | e + r | 14 |
| 10 | er + </w> | 14 |
열 번 합치고 나니 "low", "new", "est", "er" 같은 조각이 생겼어요. 사람이 영어 문법을 알려 주지 않았는데도 어근과 접미사 비슷한 것이 저절로 나타났어요. 이제 이 규칙으로 새 단어를 잘라 볼게요.
def encode(word, merges):
sym = list(word) + ["</w>"]
for a, b in merges: # 배운 순서대로 합치기를 적용해요
i, s = 0, []
while i < len(sym):
if i < len(sym) - 1 and sym[i] == a and sym[i + 1] == b:
s.append(a + b)
i += 2
else:
s.append(sym[i])
i += 1
sym = s
return sym
for w in ["lowest", "newer", "slower", "lowly"]:
print(w, encode(w, merges))
# lowest ['low', 'est</w>']
# newer ['new', 'er</w>']
# slower ['s', 'low', 'er</w>']
# lowly ['low', 'l', 'y', '</w>']
"slower"와 "lowly"는 말뭉치에 없던 단어인데도, 아는 조각("low", "er")과 글자 몇 개로 표현돼요. 처음 보는 단어가 없다는 것이 부분 단어 토큰의 가장 큰 장점이에요. 실제 언어 모델은 바이트 단위에서 출발해 이런 합치기를 수만에서 수십만 번 해서, 수만에서 수십만 개짜리 토큰 사전을 만들어요.
토큰 수가 중요한 이유
언어 모델 서비스에서 토큰은 화폐 단위예요.
- 비용: 대부분의 API는 넣은 토큰과 나온 토큰 수로 요금을 매겨요.
- 맥락 창: 모델이 한 번에 볼 수 있는 양도 토큰으로 정해져요.
- 속도: 답은 토큰을 하나씩 만들어 내니, 긴 답일수록 오래 걸려요.
토큰 사전을 만들 때 쓴 말뭉치에 어떤 언어가 많았느냐에 따라, 같은 내용이라도 언어마다 토큰 수가 달라져요. 예전 모델들은 영어 위주로 사전을 만들어서 한국어 문장이 같은 뜻의 영어 문장보다 토큰이 훨씬 많이 들었어요. 최근 모델들은 여러 언어를 고르게 넣어 이 차이를 많이 줄였어요. 내가 쓰는 모델에서 한국어 글이 몇 토큰인지 한 번 세어 보면 비용 감이 잡혀요.
번호에서 벡터로: 임베딩
토큰을 번호로 바꿨으니, 이제 번호마다 벡터를 붙여요. 왜 번호를 그대로 쓰지 않을까요? 번호 15와 16은 숫자로는 가깝지만, "고양이"와 "기차"처럼 뜻은 전혀 관계없을 수 있어요. 특징 공학 강의에서 범주에 번호를 매기면 안 된다고 한 것과 같은 이유예요.
원핫 벡터(사전 크기만큼 길고 한 칸만 1)는 모든 단어가 서로 똑같이 멀어요. 우리는 뜻이 비슷한 단어는 가까운 벡터를 원해요. 그런 벡터를 어떻게 얻을까요?
"어울리는 친구를 보면 그 사람을 안다"
언어학자 퍼스(J. R. Firth)의 말로 유명한 생각이 있어요. 단어의 뜻은 함께 쓰이는 단어들로 알 수 있다는 거예요. "사료를 준다", "꼬리를 흔든다"와 함께 나오는 단어는 아마 동물이겠죠. 이 생각을 그대로 계산해 볼게요. 동물, 음식, 도시가 나오는 문장 600개를 만들어 쓸게요.
rng = np.random.default_rng(0)
animals = ["고양이", "강아지", "토끼", "햄스터"]
foods = ["김치", "라면", "떡볶이", "비빔밥"]
cities = ["서울", "부산", "대구", "광주"]
t_animal = ["{}가 귀엽게 잔다", "{}에게 사료를 준다", "{}를 산책시킨다", "{}가 꼬리를 흔든다", "우리 집 {}는 털이 많다"]
t_food = ["{}를 맛있게 먹었다", "{}는 맵고 짜다", "저녁으로 {}를 끓였다", "{} 한 그릇을 비웠다", "{}에 김을 올렸다"]
t_city = ["{}에 출장을 갔다", "{}는 인구가 많다", "{}까지 기차를 탔다", "{}의 날씨가 맑다", "{} 지하철이 붐빈다"]
sents = []
for _ in range(600):
group, temps = [(animals, t_animal), (foods, t_food), (cities, t_city)][rng.integers(3)]
sents.append(rng.choice(temps).format(rng.choice(group)))
targets = animals + foods + cities
def norm(w): # 조사를 떼서 '고양이가' → '고양이'
for t in targets:
if w.startswith(t):
return t
return w
toks = [[norm(w) for w in re.findall(r"[가-힣]+", s)] for s in sents]
이제 같은 문장에 함께 나온 횟수를 세고, 우연보다 얼마나 자주 함께 나오는지를 재는 PPMI(양의 점별 상호 정보)로 바꾼 뒤, 선형대수 트랙의 SVD로 8차원으로 압축해요. PPMI는 정보 이론 강의의 상호 정보를 단어 쌍 하나하나에 적용한 거예요.
words = sorted({w for ws in toks for w in ws})
idx = {w: i for i, w in enumerate(words)}
C = np.zeros((len(words), len(words)))
for ws in toks: # 같은 문장에 함께 나온 횟수
for i, a in enumerate(ws):
for j, b in enumerate(ws):
if i != j:
C[idx[a], idx[b]] += 1
total = C.sum()
pw = C.sum(1) / total
ppmi = np.maximum(np.log((C / total + 1e-12) / (pw[:, None] * pw[None, :] + 1e-12)), 0)
U, S, Vt = np.linalg.svd(ppmi)
E = U[:, :8] * S[:8] # 단어마다 8차원 벡터
E = E / np.linalg.norm(E, axis=1, keepdims=True)
def neighbors(w, k=3):
sims = E @ E[idx[w]] # 코사인 유사도
order = np.argsort(-sims)
return [(words[j], round(float(sims[j]), 2)) for j in order if words[j] != w and words[j] in targets][:k]
for w in ["고양이", "김치", "부산"]:
print(w, neighbors(w))
print(round(float(E[idx["고양이"]] @ E[idx["강아지"]]), 2), round(float(E[idx["고양이"]] @ E[idx["서울"]]), 2)) # 0.99 0.01
| 단어 | 가장 가까운 단어 (코사인 유사도) |
|---|---|
| 고양이 | 토끼 1.00, 강아지 0.99, 햄스터 0.99 |
| 김치 | 라면 0.92, 비빔밥 0.92, 떡볶이 0.90 |
| 부산 | 대구 1.00, 서울 1.00, 광주 0.99 |
고양이와 강아지의 유사도는 0.99, 고양이와 서울은 0.01이에요. "고양이는 동물"이라고 알려 준 적이 없는데, 함께 쓰이는 단어가 비슷하다는 것만으로 동물끼리, 음식끼리, 도시끼리 가까운 벡터가 만들어졌어요. 일부러 깔끔하게 만든 예제라 유사도가 아주 높게 나왔지만, 실제 글 수십억 문장에서도 같은 원리가 작동해요. 2013년의 word2vec 같은 방법이 이 아이디어를 신경망으로 효율적으로 구현했어요.
언어 모델 안의 임베딩
언어 모델의 첫 층은 임베딩 층이에요. 토큰 번호를 받아 그 번호의 행을 꺼내 오는 표예요. 수학적으로는 원핫 벡터에 행렬을 곱한 것과 같아요.
import torch
emb = torch.nn.Embedding(5, 3) # 토큰 5종, 벡터 3차원
ids = torch.tensor([2, 0])
onehot = torch.nn.functional.one_hot(ids, 5).float()
print(torch.allclose(emb(ids), onehot @ emb.weight)) # True: 표에서 행 꺼내기 = 원핫 × 행렬
언어 모델은 이 표를 다음 토큰 맞히기를 하면서 함께 배워요. 우리가 PPMI로 한 것보다 훨씬 풍부한 관계를 담게 되죠. 그리고 트랜스포머의 층을 지나면서 같은 단어도 문맥에 따라 다른 벡터가 돼요. "은행에서 돈을 찾았다"의 은행과 "강가 은행나무"의 은행은 첫 층에서는 같은 벡터지만, 어텐션을 거치며 서로 다른 뜻의 벡터로 바뀌어요.
문장 임베딩과 의미 검색
단어뿐 아니라 문장이나 문서 전체를 벡터 하나로 바꾸는 임베딩 모델도 있어요. 뜻이 비슷한 문장은 가까운 벡터가 되게 학습한 모델이에요. 이걸로 할 수 있는 일이 많아요.
- 의미 검색: "환불 받고 싶어요"로 검색해도 "반품 절차 안내" 문서를 찾아요. 단어가 겹치지 않아도 뜻이 가까우니까요.
- 비슷한 것 찾기: 비슷한 상품, 중복 문의, 비슷한 판례
- 군집과 분류: 머신러닝 트랙의 k-평균이나 로지스틱 회귀에 임베딩을 특징으로 넣어요
문서가 수백만 개면 매번 전부와 유사도를 계산할 수 없으니, 가까운 벡터를 빠르게 찾아 주는 벡터 데이터베이스를 써요. 이 조합이 다섯째 강의 RAG의 핵심 부품이에요.
실습
- BPE 예제에서 합치기 횟수를 20번으로 늘려 보세요. 어떤 조각이 새로 생기나요? "widest"는 어떻게 잘리나요?
- 한국어 문장 몇 개로 같은 BPE를 돌려 보세요. 글자 단위로 시작하면 어떤 조각부터 합쳐지나요?
- 임베딩 예제에 새 그룹(예: 색깔과 "빨간색 옷을 입었다" 같은 문장)을 추가하고, 새 그룹끼리 가까워지는지 확인하세요.
- SVD로 남기는 차원을 2, 4, 16으로 바꿔 이웃 단어가 어떻게 달라지는지 보세요.
자주 하는 실수
- 글자 수와 토큰 수를 같다고 생각하기. 비용과 맥락 창은 토큰으로 계산돼요.
- 토큰 번호를 크기가 있는 숫자로 다루기. 번호는 이름표일 뿐이에요. 임베딩으로 바꿔 써요.
- 다른 임베딩 모델로 만든 벡터끼리 비교하기. 모델마다 공간이 달라서 비교할 수 없어요.
- 임베딩 유사도를 정답처럼 믿기. "가까움"은 학습 데이터의 쓰임새를 반영해서, 편견까지 담을 수 있어요.
점검 문제
- 단어 단위 토큰의 가장 큰 약점은?
- BPE는 어떤 짝을 먼저 합치나요?
- 처음 보는 단어 "slower"를 BPE가 다룰 수 있었던 이유는?
- 토큰 번호를 그대로 신경망 입력으로 쓰면 안 되는 이유는?
- 함께 나오는 단어만 보고 뜻이 비슷한 단어를 찾을 수 있는 이유는?
정답
- 종류가 너무 많고, 학습 때 없던 단어(신조어, 오타, 고유 명사)를 다룰 수 없어요.
- 말뭉치 전체에서 가장 자주 나란히 나오는 두 조각이에요.
- 이미 배운 조각("low", "er")과 글자로 쪼개서 표현할 수 있었기 때문이에요.
- 번호의 크기 차이가 뜻의 차이를 나타내지 않는데, 신경망은 숫자 크기를 의미 있는 것으로 다루기 때문이에요.
- 뜻이 비슷한 단어는 비슷한 문맥(함께 쓰이는 단어)에 나오는 경향이 있기 때문이에요.
다음 강의
토큰과 임베딩으로 글을 숫자로 바꿨어요. 다음 강의에서는 이 숫자를 받아 다음 토큰을 예측하는 트랜스포머 언어 모델을 PyTorch로 직접 작게 만들어 학습시키고, 온도와 샘플링 방법에 따라 생성되는 글이 어떻게 달라지는지 실험해요.