숫자로 끝까지 따라가는 Attention: 토큰 ID에서 다음 토큰까지

이 글이 답할 질문: 문장 하나가 모델에 들어가서 다음 토큰이 나올 때까지, 데이터는 어떤 모양으로 바뀌고 어떤 행렬이 어떤 계산을 하는가?

먼저 답하기

  • LLM이 하는 일은 하나다. 지금까지의 토큰을 보고 다음 토큰의 확률을 계산한다.
  • 각 토큰은 숫자 벡터로 바뀌고, 모든 토큰의 벡터를 쌓은 표 X가 층을 지날 때마다 갱신된다. 갱신 방식은 “덮어쓰기”가 아니라 “수정량 더하기”다.
  • Attention은 앞 토큰들(과 자기 자신)의 정보를 끌어와 수정량을 만들고, FFN은 각 토큰이 혼자 그 정보를 가공해 수정량을 하나 더 만든다.
  • 모든 weight 행렬은 학습으로 정해진 고정값이며 모든 토큰이 공유한다. 추론 중에는 읽기만 한다.
  • 이 글의 숫자는 설명용으로 임의로 정한 값이다. 실제 모델은 같은 계산을 훨씬 큰 행렬로 한다.

시작 전에: 표 읽는 법

① 행렬 = 숫자 표. 행(row)은 토큰 하나, 열(column)은 차원(dimension) 하나다. 이 글은 차원 4개를 d0, d1, d2, d3으로 부른다. “3×4 행렬”은 토큰 3개가 각자 숫자 4개를 가진 표다. 이 글에서 토큰은 항상 행이다.

② 두 종류의 표가 있다.

종류 이름 특징
데이터 X, Q, K, V, S, A, O 입력 문장에 따라 계산 중에 만들어진다
weight W로 시작하는 것 전부 학습으로 정해진 고정값. 모든 토큰이 같은 것을 공유한다

③ 이름표. Q, K, V와 W^Q, W^K, W^V, W^O는 원 논문(Attention Is All You Need)의 이름이다. S, A, O, H, ΔA, ΔF는 이 글이 설명하려고 붙인 이름이다.

기호 원어 뜻
X 입력, hidden state 층을 지나며 갱신되는 토큰 벡터들
Q query 이 토큰이 찾는 정보
K key 이 토큰이 가진 정보를 알리는 표시
V value 선택되면 실제로 넘겨줄 내용
S score Q와 K로 매긴 관련도 점수
A attention weight softmax로 바꾼 비율
O output attention의 출력
ΔA, ΔF Δ = 변화량 attention과 FFN이 만든 수정량
H hidden FFN의 중간값
W weight 학습된 고정 행렬

논문은 attention을 식 하나로 쓴다: Attention(Q, K, V) = softmax(Q·Kᵀ / √d_k) · V. 이 글은 그 식을 S(괄호 안), A(softmax 결과), O(최종 결과)로 쪼개서 따라간다.

④ 행렬곱 규칙. (3×4)·(4×2) = (3×2). 가운데 숫자가 같아야 곱할 수 있고, 결과 모양은 (왼쪽의 행 수 × 오른쪽의 열 수)다. 결과의 한 값 = 왼쪽 표의 행 하나와 오른쪽 표의 열 하나를 같은 위치끼리 곱해 모두 더한 값(내적, dot product).

⑤ weight의 모양 = (들어오는 차원 수 × 나가는 차원 수). 4차원을 2차원으로 바꾸는 weight는 4×2다. 이 weight의 “d0 행”은 입력의 d0 값과 곱해지는 행이다. weight 모양은 토큰 수와 상관이 없다.

⑥ 메인 표 X에는 번호를 붙인다. X₀(처음) → X₁(Attention 반영 후) → X₂(FFN 반영 후). 이 번호는 층 하나 안에서의 변화다.

전체 지도

Step 하는 일 입력 → 출력 모양
1 토큰화 문장 → 정수 3개
2 embedding 정수 3개 → X₀ (3×4)
3 Q, K, V 만들기 X₀ (3×4) → Q, K, V 각 (3×2)
4 관련도 점수 Q, K → S (3×3)
5 mask + softmax S → A (3×3)
6 정보 모으기 A, V → O (3×2)
7 차원 되돌리기 O (3×2) → ΔA (3×4)
8 residual 더하기 X₀ + ΔA → X₁ (3×4)
9 FFN X₁ → ΔF (3×4), X₁ + ΔF → X₂ (3×4)
10 층 반복 X₂가 다음 층의 입력
11 다음 토큰 선택 X₂의 마지막 행 (1×4) → 확률 6개
12 반복 생성과 KV cache 고른 토큰을 붙이고 다시

Step 3~8은 X₀를 그대로 두고, 옆에서 수정량 ΔA를 계산해 마지막에 더하는 과정이다.

Step 1. 토큰화

사전(vocabulary)에 단어가 6개 있다고 하자. 모델이 아는 단어는 이 6개가 전부다.

ID 0 1 2 3 4 5
토큰 고양이가 생선을 먹었다 배를 탔다 .

“고양이가 생선을 먹었다” → [0, 1, 2]. 아직 정수 3개다.

Step 2. Embedding: 번호를 벡터로

Embedding 테이블 (weight, 6×4). 행 번호 = 토큰 ID.

ID 토큰 d0 d1 d2 d3
0 고양이가 1.0 0.2 0.0 0.5
1 생선을 0.1 1.0 0.3 0.0
2 먹었다 0.0 0.3 1.0 0.4
3 배를 0.5 0.5 0.2 0.1
4 탔다 0.2 0.0 0.8 0.9
5 . 0.0 0.0 0.0 0.1

0, 1, 2번 행을 복사해 쌓으면 메인 표 X₀가 된다. 곱셈은 없고 행 읽기(memory read)만 있다. 테이블 자체는 바뀌지 않는다.

X₀ (데이터, 3×4)

d0 d1 d2 d3
고양이가 1.0 0.2 0.0 0.5
생선을 0.1 1.0 0.3 0.0
먹었다 0.0 0.3 1.0 0.4

이 숫자에는 문맥이 없다. “배”가 신체든 선박이든 과일이든 ID가 같으면 벡터도 같다. 목표는 이 표를 문맥이 반영된 표로 갱신하는 것이다.

토큰마다 따로 있는 weight는 이 테이블의 행 하나뿐이다. “먹었다”만의 W_Q 같은 것은 없다. 뒤에 나오는 W_Q, W_K, W_V, W_O, FFN weight는 모든 토큰이 공유한다. 이 값들은 모두 학습에서 정해지고, 학습이 끝난 모델 안에서는 고정이다. 모델이 다르거나 추가 학습(fine-tuning)을 하면 값도 달라진다.

Step 3. Q, K, V 만들기

같은 X₀를 세 가지 용도로 변환한다. weight 3개(각 4×2)는 모든 토큰이 공유한다.

weight 행 W_Q W_K W_V
d0 행 0.2, 0.1 0.8, 0.1 1.0, 0.0
d1 행 0.1, 0.9 0.1, 0.9 0.0, 1.0
d2 행 0.9, 0.2 0.1, 0.1 0.5, 0.5
d3 행 0.3, 0.1 0.6, 0.2 0.2, 0.2
역할 의미
Q (query) 이 토큰이 찾는 정보
K (key) 이 토큰이 가진 정보를 알리는 표시
V (value) 선택되면 실제로 넘겨줄 내용

“먹었다”의 Q를 직접 계산해 보자. X₀의 각 값이 W_Q에서 자기 이름의 행을 그 값만큼 가져오고, 그 결과를 다 더한다.

입력 차원 값 × W_Q의 같은 이름 행 =
d0 0.0 d0 행 [0.2, 0.1] [0.00, 0.00]
d1 0.3 d1 행 [0.1, 0.9] [0.03, 0.27]
d2 1.0 d2 행 [0.9, 0.2] [0.90, 0.20]
d3 0.4 d3 행 [0.3, 0.1] [0.12, 0.04]
합 [1.05, 0.51]

W_Q의 d2 행 [0.9, 0.2]는 “먹었다”의 정보가 아니다. 어떤 토큰이든 그 토큰의 d2 값에 곱해져서 Q의 두 값에 더해지는 계수다.

모든 토큰에 같은 방식으로 계산하면:

토큰 Q (3×2) K (3×2) V (3×2)
고양이가 0.37, 0.33 1.12, 0.38 1.10, 0.30
생선을 0.39, 0.97 0.21, 0.94 0.25, 1.15
먹었다 1.05, 0.51 0.37, 0.45 0.58, 0.88
  • 토큰마다 Q가 다른 이유는 W_Q가 달라서가 아니라 입력 X₀의 행이 달라서다. W_Q는 하나다.
  • 결과 모양은 (X₀의 행 수 × W_Q의 열 수)다. 토큰이 1,000개면 X₀는 1000×4, W_Q는 그대로 4×2, Q는 1000×2다. 토큰이 늘면 데이터의 행 수만 늘고 weight 모양은 그대로다.
  • X₀는 건드리지 않았다.

Step 4. 관련도 점수

목적: 토큰 i의 Q(찾는 것)와 토큰 j의 K(가진 것)가 얼마나 비슷한지 숫자 하나로 잰다. 그 숫자로 i가 j의 정보를 얼마나 가져올지 정한다.

방법은 내적이다. “먹었다”가 “고양이가”를 얼마나 원하는가 = 1.05×1.12 + 0.51×0.38 = 1.37. 방향이 비슷한 벡터일수록 값이 크다.

모든 쌍을 한 번에 계산하면 행렬곱이 된다. S = Q·Kᵀ ÷ √2 → (3×2)·(2×3) = 3×3. Kᵀ는 K를 눕힌 것(transpose)이다. 눕히면 열이 토큰이 되어 “Q의 토큰 행 · K의 토큰 열”로 모든 쌍을 계산할 수 있다.

√d_k(여기서 d_k = 2, K의 차원 수)로 나누는 이유는 차원이 커질수록 내적 값이 커져서, 다음 단계의 softmax가 한 토큰에 거의 100%를 몰아주는 것을 막기 위해서다. 1.37 ÷ 1.41 = 0.97.

S의 (행 i, 열 j) = “토큰 i가 토큰 j를 얼마나 원하는가”.

S (3×3) → 고양이가 → 생선을 → 먹었다
고양이가 0.38 0.27 0.20
생선을 0.57 0.70 0.41
먹었다 0.97 0.49 0.44

S는 (토큰 수 × 토큰 수) 크기다. Q, K, V는 토큰 수에 비례해 커지지만 S는 토큰 수의 제곱으로 커진다.

Step 5. Mask + softmax

1. Causal mask: 문장을 앞에서부터 만들기 때문에 각 토큰은 자기보다 뒤의 토큰을 볼 수 없다. 자기 자신과 앞 토큰은 볼 수 있다. 가릴 위치의 점수를 −∞로 바꾼다.

2. Softmax: 각 행을 “음수가 없고 합이 1인 비율”로 바꾼다. 행의 각 점수에 eˣ를 씌우고, 행의 합으로 나눈다. e^(−∞) = 0이라서 가린 위치는 정확히 0이 된다.

“생선을” 행 고양이가 생선을 먹었다 합
점수 (mask 후) 0.57 0.70 −∞
e^점수 1.77 2.01 0 3.78
÷ 합 0.47 0.53 0 1.00
“먹었다” 행 고양이가 생선을 먹었다 합
점수 0.97 0.49 0.44
e^점수 2.64 1.63 1.55 5.82
÷ 합 0.45 0.28 0.27 1.00

그냥 합으로 나누지 않고 eˣ를 쓰는 이유: 점수는 음수일 수 있어서 그대로 나누면 비율이 음수가 된다. 또 eˣ는 차이를 키워서, 관련이 높은 토큰에 확실히 더 많이 배분한다.

A (3×3) 고양이가 생선을 먹었다
고양이가 1.00 0 0
생선을 0.47 0.53 0
먹었다 0.45 0.28 0.27

첫 토큰은 뒤 문맥이 바뀌어도 그대로다. “고양이가”는 앞에 볼 토큰이 없어서 자기 자신만 본다(1.00). 그래서 “고양이가 생선을 먹었다”든 “고양이가 배를 탔다”든 “고양이가” 행의 계산 결과는 같다. 문장에 따라 달라지는 것은 뒤 토큰들의 행이다. 이 성질이 Step 12의 KV cache로 이어진다.

Step 6. 정보 모으기

O = A·V → (3×3)·(3×2) = 3×2. A의 비율대로 V의 행들을 섞는다(가중평균).

토큰 섞는 V 개수 O 계산 O
고양이가 1개 1.00×[1.10, 0.30] [1.10, 0.30]
생선을 2개 0.47×[1.10, 0.30] + 0.53×[0.25, 1.15] [0.65, 0.75]
먹었다 3개 0.45×[1.10, 0.30] + 0.28×[0.25, 1.15] + 0.27×[0.58, 0.88] [0.72, 0.69]
  • “고양이가”의 O가 자기 V와 똑같은 이유: A의 첫 행이 [1, 0, 0]이라 자기 자신 100%로 섞었기 때문이다.
  • 뒤 토큰일수록 섞을 대상이 많다. mask 때문에 볼 수 있는 토큰 수만큼 섞는다.
  • attention은 자기 자신도 섞는 대상에 넣는다. “먹었다”의 O는 고양이가 45%, 생선을 28%, 먹었다 자신 27%다.

여기서 처음으로 원래 embedding에 없던 문맥 정보가 들어갔다. attention 한 번은 세 단계다: Q·K로 점수를 매기고(Step 4), softmax로 비율로 바꾸고(Step 5), 그 비율로 V를 섞는다(Step 6).

지금 상태: X₀(3×4)는 그대로 있고, 새로 모은 정보 O(3×2)는 차원 수가 달라 X₀에 바로 더할 수 없다.

Step 7. W_O: 2차원을 4차원으로

W_O도 학습으로 정해진 고정 weight이며 모든 토큰이 공유한다. W_Q가 4차원을 2차원으로 줄였으니 W_O는 2차원을 4차원으로 되돌린다. 그래서 모양이 2×4다. O의 두 값을 o0, o1이라고 부른다.

W_O (2×4) d0 d1 d2 d3
o0 행 0.5 0.0 0.2 0.1
o1 행 0.0 0.5 0.1 0.3

계산 방식은 Q를 만들 때와 같다. “먹었다”의 O = [0.72, 0.69]:

입력 값 × W_O의 같은 이름 행 =
o0 0.72 o0 행 [0.5, 0.0, 0.2, 0.1] [0.36, 0.00, 0.14, 0.07]
o1 0.69 o1 행 [0.0, 0.5, 0.1, 0.3] [0.00, 0.35, 0.07, 0.21]
합 [0.36, 0.35, 0.21, 0.28]

ΔA = O·W_O → (3×2)·(2×4) = 3×4.

ΔA (3×4) d0 d1 d2 d3
고양이가 0.55 0.15 0.25 0.20
생선을 0.32 0.38 0.20 0.29
먹었다 0.36 0.35 0.21 0.28

이 예시에서는 줄였다가 다시 늘리는 것이 이상해 보인다. 실제 모델에서는 attention을 여러 개 동시에 돌리고 W_O가 그 결과를 하나로 모으는 역할도 한다. 이 부분은 글 끝의 “참고: 실제 모델의 multi-head”에 따로 정리했다.

Step 8. Residual 더하기: X₀ + ΔA = X₁

토큰 X₀ + ΔA = X₁
고양이가 1.0, 0.2, 0.0, 0.5 0.55, 0.15, 0.25, 0.20 1.55, 0.35, 0.25, 0.70
생선을 0.1, 1.0, 0.3, 0.0 0.32, 0.38, 0.20, 0.29 0.42, 1.38, 0.50, 0.29
먹었다 0.0, 0.3, 1.0, 0.4 0.36, 0.35, 0.21, 0.28 0.36, 0.65, 1.21, 0.68

X₁의 “먹었다” 행에는 두 출처의 정보가 들어 있다.

출처 내용
X₀(먹었다) “먹었다”라는 단어 자체의 embedding
ΔA(먹었다) 고양이가 45% + 생선을 28% + 먹었다 자신 27%로 섞은 V를 W_O로 바꾼 것

덮어쓰지 않고 더하는 이유: 덮어쓰면 단어 자체의 정보가 사라진다. 더하면 원래 의미에 문맥이 얹힌다. 이를 residual connection이라고 한다. 층을 깊게 쌓아도 학습 신호가 아래층까지 잘 전달되게 하는 역할도 한다.

메모리 관점에서 보면, 토큰마다 고정 크기의 버퍼가 하나 있고 각 블록이 “읽기 → 계산 → 더하기”를 하는 구조다. 버퍼 크기가 바뀌지 않으므로 층을 계속 쌓을 수 있다.

여기까지가 Attention 파트다. X₀ → (Q, K, V) → S → A → O → ΔA → X₁.

Step 9. FFN: 각 행을 혼자 가공

Attention FFN
토큰끼리 섞나 섞는다. A로 다른 토큰의 V를 가져온다 안 섞는다. 행마다 같은 계산을 따로 한다
하는 일 문맥 정보를 모은다 모은 정보를 가공한다

FFN(feed-forward network, MLP라고도 부른다)의 순서는 넓히기 → 거르기 → 줄이기 → 더하기다.

① 넓히기: X₁ (3×4) · W_up (4×6) = H (3×6). 넓힌 6개 값(h1~h6)은 각각 “이 패턴이 있나?“를 검사하는 감지기처럼 동작한다.

W_up (4×6) h1 h2 h3 h4 h5 h6
d0 행 1 -1 0 0 0.5 0
d1 행 0 1 -1 0 0 0.5
d2 행 0 0 1 -1 0.5 0
d3 행 -1 0 0 1 0 0.5

② 거르기 (ReLU): 음수는 0으로 만든다. 반응한 감지기만 남는다.

토큰 H (거르기 전) H (거른 후)
고양이가 0.85, -1.20, -0.10, 0.45, 0.90, 0.53 0.85, 0, 0, 0.45, 0.90, 0.53
생선을 0.13, 0.95, -0.87, -0.21, 0.46, 0.83 0.13, 0.95, 0, 0, 0.46, 0.83
먹었다 -0.32, 0.29, 0.57, -0.53, 0.79, 0.66 0, 0.29, 0.57, 0, 0.79, 0.66

③ 줄이기: H (3×6) · W_down (6×4) = ΔF (3×4)

W_down (6×4) d0 d1 d2 d3
h1 행 0.2 0 0 0
h2 행 0 0.2 0 0
h3 행 0 0 0.2 0
h4 행 0 0 0 0.2
h5 행 0.1 0 0.1 0
h6 행 0 0.1 0 0.1

④ 더하기: X₁ + ΔF = X₂

토큰 X₁ + ΔF = X₂
고양이가 1.55, 0.35, 0.25, 0.70 0.26, 0.05, 0.09, 0.14 1.81, 0.40, 0.34, 0.84
생선을 0.42, 1.38, 0.50, 0.29 0.07, 0.27, 0.05, 0.08 0.50, 1.65, 0.55, 0.37
먹었다 0.36, 0.65, 1.21, 0.68 0.08, 0.12, 0.19, 0.07 0.44, 0.77, 1.41, 0.75

FFN은 weight가 크다. 이 예시의 weight 개수를 세어 보면 이미 FFN이 attention보다 많다. FFN은 차원을 넓히기 때문이다.

부분 weight 개수
Attention W_Q, W_K, W_V (각 4×2) + W_O (2×4) 32
FFN W_up (4×6) + W_down (6×4) 48

예시는 4 → 6으로 1.5배 넓혔다. Llama-3-70B는 8,192 → 28,672로 3.5배 넓혀서 차이가 훨씬 크다(아래 “실제 크기” 참고).

여기까지가 Transformer 층 1개다. 메인 표의 모양은 처음부터 끝까지 3×4로 유지되고 내용만 X₀ → X₁ → X₂로 갱신됐다. (실제 모델은 각 블록 앞에 숫자 크기를 맞추는 normalization이 있고, Llama는 ReLU 대신 SwiGLU라는 방식을 써서 FFN weight가 3개다.)

Step 10. 층 반복

X₂를 다음 층의 입력으로 넣고 Step 3~9를 반복한다. 이 예시는 1층으로 끝낸다.

층 수와 토큰 수는 서로 다른 축이다.

무엇을 정하나 예시 Llama-3-70B
토큰 수 표의 행 수 3 문장마다 다름
층 수 Step 3~9를 반복하는 횟수 1 80, 모델 설계로 고정

토큰이 3개라고 층이 3개인 것이 아니다. 토큰이 1,000개여도 층은 80개다. 토큰 수는 표를 키우고, 층 수는 그 표를 몇 번 처리할지 정한다.

weight는 층마다 다르다. 층마다 W_Q, W_K, W_V, W_O, W_up, W_down이 따로 있다. 1층의 W_K와 30층의 W_K는 서로 다른 고정 행렬이다.

층마다 다른가 고정인가
W_K, W_V 같은 weight 다르다 고정. 학습 후 바뀌지 않는다
K, V 같은 데이터 다르다 아니다. 문장마다 새로 계산한다

층 사이로 넘어가는 것은 X뿐이다. 층 l에 들어오는 X는 embedding이 아니라 앞의 층들을 거쳐 갱신된 값이다. 그래서 같은 토큰이라도 층마다 K, V가 다르다.

Step 11. 다음 토큰 선택

① 마지막 토큰의 행만 쓴다. X₂의 “먹었다” 행 = [0.44, 0.77, 1.41, 0.75]. causal mask 때문에 마지막 토큰만 앞의 모든 토큰을 본 상태라서, 이 행을 문장 전체의 요약으로 쓴다.

② 사전의 모든 단어에 점수를 매긴다. 다음 단어가 무엇일지 모르므로, 모델은 Step 1의 사전 6개 단어를 전부 후보로 놓고 하나씩 채점한다. 문장에 없던 “배를”, “탔다”, “.“도 사전에 있으므로 후보다.

③ 채점 방법은 내적이다. 사전의 단어마다 학습으로 정해진 단어 벡터(숫자 4개)가 있다. 마지막 토큰 벡터와 각 단어 벡터를 내적한 값이 그 단어의 점수다. Step 4의 Q·K가 “이 토큰이 저 토큰을 얼마나 원하나”를 쟀다면, 여기서는 “지금 문맥에 이 단어가 얼마나 맞나”를 잰다.

④ W_out = 단어 벡터 6개를 열로 나란히 놓은 weight (4×6). 행 4개는 차원 d0~d3, 열 6개는 사전의 단어 6개다.

W_out (4×6) 고양이가 생선을 먹었다 배를 탔다 .
d0 행 0.9 0.1 0.0 0.3 0.1 0.1
d1 행 0.1 0.8 0.1 0.3 0.0 0.3
d2 행 0.0 0.2 0.3 0.1 0.4 0.9
d3 행 0.4 0.0 0.2 0.0 0.5 0.8
모양 하는 일
Embedding 테이블 (Step 2) 6×4, 단어마다 행 하나 단어 → 벡터 (입구)
W_out (Step 11) 4×6, 단어마다 열 하나 벡터 → 단어별 점수 (출구)

⑤ 두 단어의 점수를 나란히 풀어 보자.

차원 X₂(먹었다) “.” 열 곱 “배를” 열 곱
d0 0.44 0.1 0.04 0.3 0.13
d1 0.77 0.3 0.23 0.3 0.23
d2 1.41 0.9 1.27 0.1 0.14
d3 0.75 0.8 0.60 0.0 0.00
점수 2.14 0.50

문맥 벡터는 d2, d3이 크다. “.” 열도 d2, d3이 커서 큰 값끼리 만나 점수가 높다. “배를” 열은 그 차원이 작아서 점수가 낮다.

⑥ 점수 벡터(logits)와 확률. 6개 열에 모두 이렇게 하면 단어별 점수 6개가 벡터 하나로 나온다. 이것을 점수 벡터, 보통 logits라고 부른다. 모양은 (1×4)·(4×6) = (1×6)이다. Step 5와 같은 softmax로 확률로 바꾼다.

고양이가 생선을 먹었다 배를 탔다 .
점수 0.77 0.94 0.65 0.50 0.98 2.14
확률 11.1% 13.2% 9.8% 8.5% 13.7% 43.6%

→ 다음 토큰은 “.” (반올림 때문에 확률의 합이 99.9%로 보인다.) 예시 숫자는 “.“이 이기도록 임의로 정한 값이다.

사전에 단어가 하나 늘어 7개가 되면 W_out은 4×7, 점수 벡터는 1×7, embedding 테이블은 7×4가 된다. 사전 크기는 입구와 출구에만 영향을 주고, 중간의 W_Q, W_K, W_V, W_O, FFN 모양은 그대로다.

Step 12. 반복 생성과 KV cache

“고양이가 생선을 먹었다 .“를 다시 넣어 그다음 토큰을 고르고, 문장이 끝날 때까지 반복한다.

과거 토큰의 K, V는 변하지 않는다. Step 5에서 본 것처럼 앞 토큰은 뒤를 보지 않는다. 그래서 “고양이가, 생선을, 먹었다”의 K, V는 새 토큰이 붙어도 그대로다. 이를 저장해 두고 새 토큰의 것만 계산하는 것이 KV cache다.

아래 그림은 “먹었다”가 새 토큰으로 들어오는 순간이다. “고양이가, 생선을”의 K, V는 이미 캐시에 있고, “먹었다”는 자기 q, k, v 한 행씩만 새로 계산한다. 숫자는 Step 3~6과 같다.

① 점수: q · Kᵀ ÷ √2 q (먹었다, 1×2) 1.05 0.51 · K (3×2) 고양이가 1.12 0.38 생선을 0.21 0.94 먹었다 0.37 0.45 점수 (1×3) 고양이가 생선을 먹었다 0.97 0.49 0.44 q를 K의 행마다 내적한다. 예) 고양이가: (1.05×1.12 + 0.51×0.38) ÷ 1.41 = 0.97 ② 섞기: softmax(점수) · V A (1×3) 고양이가 생선을 먹었다 0.45 0.28 0.27 · V (3×2) 고양이가 1.10 0.30 생선을 0.25 1.15 먹었다 0.58 0.88 O (먹었다, 1×2) 0.72 0.69 0.45×[1.10, 0.30] + 0.28×[0.25, 1.15] + 0.27×[0.58, 0.88] = [0.72, 0.69] KV cache에서 읽음 (이전 토큰) 이번 토큰에서 새로 계산
새 토큰은 q, k, v를 한 행씩만 새로 만든다. K, V의 나머지 행은 캐시에서 읽는다.

“이전”에는 두 방향이 있다. KV cache가 저장하는 것은 토큰 방향이다.

방향 질문 답
층 방향 (1층 → 80층) 2층이 1층의 K, V를 쓰나? 아니다. 2층은 X를 받아 자기 W_K, W_V로 새로 만든다
토큰 방향 (고양이가 → 생선을 → 먹었다 → .) 새 토큰이 이전 토큰의 K, V를 쓰나? 쓴다. 직전 하나가 아니라 앞의 토큰 전부를 쓴다

그래서 KV cache는 층마다 K 행렬 1개와 V 행렬 1개를 가진다. 80층 모델이면 행렬이 160개이고, 각 행렬의 행 수는 지금까지의 토큰 수다. 새 토큰 하나를 만들 때마다 160개 행렬 각각에 행이 1개씩 추가된다. 그리고 각 층에서 그 층의 K, V 행렬을 처음부터 끝까지 읽는다. 100번째 토큰을 만들 때 30층에서는 30층의 K, V 행렬에 있는 앞선 99개 토큰의 행을 전부 읽는다.

캐시가 없으면 무엇을 다시 계산해야 하나. 과거 토큰의 K를 다시 만들려면 그 토큰의 층 l 입력 X가 필요하다. 그런데 층 l의 입력은 embedding이 아니라 앞의 l−1개 층을 거친 값이다. 결국 과거 토큰 전부를 1층부터 다시 통과시켜야 하고, 이는 새 토큰마다 지금까지의 문장 전체를 모델에 다시 넣는 것과 같다. KV cache는 이 반복 계산을 메모리 저장으로 바꾼 것이다. 대가는 문장 길이에 비례해 커지는 메모리다.

예시 크기와 실제 크기 (Llama-3-70B)

계산 방식은 예시와 같고 숫자만 커진다.

표 종류 예시 실제
Embedding 테이블 weight 6×4 128,256 × 8,192
X₀, X₁, X₂ 데이터 3×4 토큰 수 × 8,192
W_Q / W_K / W_V weight 4×2 8,192×8,192 / 8,192×1,024 / 8,192×1,024
S, A 데이터 3×3 토큰 수 × 토큰 수
W_O weight 2×4 8,192 × 8,192
FFN weight 4×6, 6×4 gate·up 8,192×28,672, down 28,672×8,192
W_out weight 4×6 8,192 × 128,256
층 수 — 1 80

W_Q와 W_K, W_V의 열 수가 다른 이유는 아래 “참고: 실제 모델의 multi-head”에 있다.

파라미터 수로 나누면 weight의 대부분은 FFN에 있다.

부분 계산 개수 비중
Embedding 128,256 × 8,192 1.05B 1.5%
Attention (80층) (67.1M×2 + 8.4M×2) × 80 12.1B 17%
FFN (80층) 3 × 8,192 × 28,672 × 80 56.4B 80%
출력 행렬 8,192 × 128,256 1.05B 1.5%
합계 약 70.6B

숫자 하나는 몇 바이트인가: 데이터 타입

weight가 메모리를 얼마나 차지하는지는 weight 개수 × 숫자 하나의 바이트 수다. 숫자 하나를 몇 비트로 저장할지 정한 규칙이 데이터 타입이다.

부동소수점(floating point)은 비트를 세 부분으로 나눠 쓴다. 지수 비트가 많으면 아주 크거나 작은 수까지 표현할 수 있고(범위), 가수 비트가 많으면 소수점 아래를 더 정확하게 표현한다(정밀도).

형식 크기 비트 구성 (부호 / 지수 / 가수) 특징
FP32 4바이트 1 / 8 / 23 일반적인 float. 학습에서 기준이 되는 정밀도
FP16 2바이트 1 / 5 / 10 half precision. 지수가 5비트라 범위가 좁다
BF16 2바이트 1 / 8 / 7 지수를 FP32와 같은 8비트로 두고 정밀도를 줄였다
FP8 1바이트 E4M3: 1 / 4 / 3, E5M2: 1 / 5 / 2 추론과 학습을 가볍게 할 때
INT8 1바이트 정수 양자화된 추론
INT4 0.5바이트 정수 더 공격적인 양자화

FP8, INT8, INT4처럼 비트 수를 줄여 저장하는 것을 양자화(quantization)라고 한다. Meta의 Llama 3 공개 코드는 GPU가 지원하면 BF16, 아니면 FP16으로 weight를 올린다. 둘 다 2바이트다.

weight 크기 = 706억 × 바이트 수

형식 weight 크기
FP32 약 282GB
FP16 / BF16 약 141GB
FP8 / INT8 약 71GB
INT4 약 35GB

KV cache 크기 = 층 수 × (K, V) 2개 × 한 행의 길이 × 바이트 수 × 토큰 수. Llama-3-70B에서 K, V 한 행의 길이는 1,024다.

문장 길이 KV cache (BF16, 사용자 1명)
1 토큰 80 × 2 × 1,024 × 2바이트 = 327,680바이트 (약 0.33MB)
4,096 토큰 약 1.3GB
131,072 토큰 약 43GB

weight는 사용자 수와 상관없이 고정이지만, KV cache는 문장 길이 × 동시 사용자 수에 비례해 커진다.

왜 메모리 대역폭에 묶이나

토큰 하나를 생성할 때마다 새 토큰 벡터 한 행이 80개 층을 모두 통과한다. 각 층에서 그 층의 weight를 전부 한 번씩 곱하고, 그 층의 KV cache를 전부 읽는다. 즉 토큰 하나마다 weight 전체(BF16 약 141GB)와 KV cache를 메모리에서 읽는다. 그런데 계산하는 것은 벡터 한 행뿐이다. 읽어 온 숫자 하나당 계산이 아주 적어서, 연산보다 메모리에서 데이터를 가져오는 속도가 먼저 한계에 닿는다. 이것이 LLM 추론이 메모리 대역폭에 묶이는(memory-bound) 출발점이다.

계산 예. 메모리 대역폭이 1 TB/s인 시스템이 있다고 하자. KV cache와 계산 시간은 무시한다.

weight 형식 토큰 하나당 읽기 초당 최대 토큰
BF16 (141GB) 0.14초 약 7개
INT4 (35GB) 0.035초 약 28개

읽을 바이트 수를 절반으로 줄이면 속도가 2배가 된다. 양자화가 추론 속도와 직결되는 이유다.

참고: 실제 모델의 multi-head

본문은 이해를 위해 attention을 하나만 돌렸다. 실제 모델은 여러 개(head)를 동시에 돌린다.

  • head 하나의 차원은 본문 예시에서 Q, K, V의 길이 2에 해당하는 값이다. Llama-3-70B는 128이다.
  • Llama-3-70B의 Q head는 64개다. 각 head가 128차원 Q를 만들고, 이를 한 행렬에 나란히 붙인 것이 W_Q다. 그래서 W_Q의 열 수는 64 × 128 = 8,192다. 본문 예시를 head 2개로 늘리면 W_Q는 4×4가 된다.
  • K, V head는 8개뿐이다. 그래서 W_K, W_V의 열 수는 8 × 128 = 1,024다. Q head 8개가 K, V head 1개를 함께 쓰는 방식이고, GQA(Grouped-Query Attention)라고 부른다. KV cache 한 행의 길이가 8,192가 아니라 1,024인 이유다.
  • W_O(8,192 × 8,192)는 64개 head의 출력(각 128차원)을 이어 붙인 8,192차원을 X에 더할 수 있게 모은다. W_O의 행을 128개씩 64묶음으로 나누면 묶음 하나(128 × 8,192)가 head 하나의 몫이다. W_Q는 열을 나눠 head들에 보내고, W_O는 행을 나눠 head들의 결과를 모은다.

자주 나올 질문과 답변

Q. W_Q, W_K, W_V는 토큰마다 따로 있나?

A. 아니다. 한 층 안에서 모든 토큰이 같은 W_Q 하나를 공유한다. 토큰마다 Q가 다른 이유는 입력 X₀의 행이 다르기 때문이다. 층이 다르면 W_Q도 다르다.

Q. 그럼 “먹었다”만의 weight는 어디서 오나?

A. 토큰마다 따로 있는 weight는 embedding 테이블의 행 하나뿐이다(“먹었다” = 2번 행). 행렬의 모양은 사람이 설계하고 값은 학습이 정한다. 랜덤으로 시작해 “다음 토큰 맞히기”를 아주 많은 문장에 걸쳐 반복하며, 틀린 정도(loss)를 줄이는 방향으로 조금씩 수정된다(gradient descent). 학습이 끝나면 고정이고 추론 중에는 읽기만 한다.

Q. weight의 “d0 행”은 무슨 뜻인가?

A. weight의 0번째 행이다. 입력 벡터의 d0 값과 곱해지는 행이며, “d0이 출력의 각 값에 얼마나 기여하는가”를 정한다. 특정 토큰의 정보가 아니다.

Q. W_O는 왜 2×4인가?

A. weight 모양은 (들어오는 차원 수 × 나가는 차원 수)다. O는 2차원이고 X₀에 더하려면 4차원이어야 하므로 2×4다.

Q. X₁이 되면 embedding 테이블이 바뀐 것인가?

A. 아니다. embedding 테이블은 weight라서 바뀌지 않는다. X₀는 그 행들을 복사한 사본이고, 갱신되는 것은 이 사본이다. X₁이 만들어진 뒤 X₀는 다시 쓰이지 않지만, X₀에서 만든 K, V는 KV cache로 저장된다.

Q. 두 문장에서 첫 토큰 “고양이가”의 결과는 다른가?

A. 같다. “고양이가”는 첫 토큰이라 causal mask 때문에 자기 자신만 본다. 뒤에 무엇이 오든 그 행의 계산은 바뀌지 않는다. 달라지는 것은 뒤 토큰들의 행이다.

Q. 층 수는 토큰 수로 정해지나?

A. 아니다. 층 수는 모델 설계로 정해진 고정값이다(Llama-3-70B는 80). 토큰 수는 표의 행 수이고, 층 수는 그 표를 몇 번 처리할지다.

Q. K, V는 층마다 다른데, 왜 직전 것만이 아니라 전부 저장하나?

A. 층 방향으로는 직전 층의 K, V를 쓰지 않는다. 하지만 토큰 방향으로는 새 토큰의 q가 각 층에서 앞선 토큰 전부의 K와 내적하고 V 전부를 섞는다. 그래서 모든 층 × 모든 과거 토큰의 K, V가 필요하다. 과거 토큰의 K, V는 변하지 않으므로 저장해 두고 다시 쓴다.

정리

  • 오늘 확실히 알게 된 것: 메인 표 X는 모양을 유지한 채 Attention 수정량과 FFN 수정량이 차례로 더해지며 갱신된다. weight는 층마다 다르지만 고정이고 모든 토큰이 공유한다. 토큰마다 따로 있는 것은 embedding 행과, 문장마다 새로 계산되는 데이터(X, Q, K, V)다.
  • 적용할 때 확인할 조건: 실제 모델은 multi-head, normalization, GQA, SwiGLU가 들어가 행렬 모양이 예시와 다르다.
  • 다음 글에서 답할 질문: KV cache는 사용자 수와 문장 길이에 따라 얼마나 커지고, prefill과 decode는 메모리를 어떻게 다르게 쓰는가?

참고 자료와 Claim ledger

주장 구분 출처 확인 메모
Attention(Q,K,V) = softmax(QKᵀ/√d_k)V, multi-head, residual, FFN 구조 fact Attention Is All You Need
Llama-3-70B: 80층, 차원 8,192, FFN 28,672, Q head 64, KV head 8 fact The Llama 3 Herd of Models, Table 3
사전 128,256 = 기본 토큰 128,000 + 예약 특수 토큰 256 fact 위 논문(128K) + meta-llama/llama3 tokenizer.py (num_reserved_special_tokens = 256)
Llama 3 공개 코드는 GPU가 지원하면 BF16, 아니면 FP16으로 weight를 올린다 fact meta-llama/llama3 generation.py
FP32 1/8/23, FP16 1/5/10 비트 구성 fact IEEE 754 (binary32, binary16)
BF16 1/8/7 비트 구성 fact Google Cloud: bfloat16
FP8 E4M3, E5M2 형식 fact FP8 Formats for Deep Learning
weight의 약 80%가 FFN, 합계 약 70.6B interpretation 위 하이퍼파라미터로 직접 계산 계산식은 본문 표
KV cache 토큰당 327,680바이트(BF16) interpretation 80 × 2 × 8 × 128 × 2바이트로 직접 계산
1 TB/s에서 초당 약 7토큰 illustrative 가정한 대역폭으로 계산한 상한 실제 시스템은 여러 GPU에 나눠 돌리며 값이 다르다
본문 예시의 모든 숫자 illustrative 설명용 임의 값 실제 모델 값 아님