추론 최적화: 양자화, 배치, 캐시
학습은 한 번이지만 추론은 요청마다 계속돼요. 70억 파라미터 모델의 가중치와 KV 캐시가 차지하는 메모리, 한 토큰씩 생성할 때 속도를 묶는 메모리 대역폭을 계산하고, 이상값 하나가 양자화를 망치는 이유와 묶음별 양자화, 숫자 분류기가 4비트까지 버티고 2비트에서 무너지는 모습을 확인해요. 배치로 요청당 시간이 수십 배 줄어드는 원리, KV 캐시가 결과를 바꾸지 않고 계산을 줄이는 원리, 작은 모델이 먼저 쓰고 큰 모델이 검사하는 추측 디코딩까지 직접 재 봐요.
모델 학습은 한 번 하면 끝나지만, 추론(학습된 모델로 답을 만드는 일)은 요청이 올 때마다 계속돼요. 사용자가 많은 서비스에서는 평생 쓰는 추론 비용이 학습 비용을 금세 넘어서요. 그래서 같은 모델을 더 빠르게, 더 싸게, 더 적은 메모리로 돌리는 기술이 중요해요.
추론 성능은 보통 이런 숫자로 재요.
- 첫 토큰까지의 시간: 요청을 보내고 첫 글자가 나올 때까지예요. 사용자가 "느리다"고 느끼는 첫인상이에요.
- 토큰당 시간: 첫 토큰 뒤에 한 토큰씩 나오는 간격이에요.
- 처리량: 모든 사용자를 합쳐 초당 몇 토큰을 만드는가예요. 서버 비용을 정해요.
- 메모리: 한 GPU에 모델이 들어가는가, 동시에 몇 명을 받을 수 있는가를 정해요.
1. 메모리는 어디에 쓰일까
메모리를 차지하는 건 크게 두 가지예요. 가중치와 KV 캐시예요. KV 캐시는 5절에서 자세히 보지만, 간단히 말해 앞에서 계산한 토큰들의 키와 값을 저장해 둔 거예요. 파인튜닝 강의에서 본 70억 파라미터 모델 구조로 계산해 볼게요.
import math
import time
import copy
import numpy as np
import torch
from torch import nn
import torch.nn.functional as F
params, layers, d, heads = 6.74e9, 32, 4096, 32
for name, nbytes in (("32비트", 4), ("16비트", 2), ("8비트", 1), ("4비트", 0.5)):
print(f"가중치 {name}: {params * nbytes / 1e9:.1f}GB")
head_dim = d // heads
per_token = 2 * layers * heads * head_dim * 2 # 키와 값, 층마다, 16비트(2바이트)
per_token_gqa = 2 * layers * 8 * head_dim * 2 # 키·값 머리를 8개로 줄인 모델
print(f"KV 캐시 토큰 하나: {per_token:,}바이트, 4,096토큰이면 {per_token * 4096 / 1e9:.2f}GB")
print(f"키·값 머리 8개: {per_token_gqa:,}바이트, 4,096토큰이면 {per_token_gqa * 4096 / 1e9:.2f}GB")
bandwidth = 1e12 # 초당 1TB를 읽는 GPU라고 가정
for name, nbytes in (("16비트", 2), ("4비트", 0.5)):
print(f"{name} 한 명에게 생성할 때 최대 속도: 초당 {bandwidth / (params * nbytes):.0f}토큰")
가중치 32비트: 27.0GB
가중치 16비트: 13.5GB
가중치 8비트: 6.7GB
가중치 4비트: 3.4GB
KV 캐시 토큰 하나: 524,288바이트, 4,096토큰이면 2.15GB
키·값 머리 8개: 131,072바이트, 4,096토큰이면 0.54GB
16비트 한 명에게 생성할 때 최대 속도: 초당 74토큰
4비트 한 명에게 생성할 때 최대 속도: 초당 297토큰
세 가지가 보여요.
- KV 캐시가 가중치만큼 커질 수 있어요. 4,096토큰짜리 대화 하나가 2.15GB예요. 이런 대화를 동시에 8개만 받아도 17GB로, 16비트 가중치(13.5GB)보다 커요. 그래서 여러 질문 머리가 키와 값을 나눠 쓰게 해서 KV 캐시를 4분의 1로 줄이는 방식(그룹 질의 어텐션)을 쓰는 모델이 많아요.
- 비트 수가 메모리를 바로 정해요. 32비트에서 4비트로 가면 8분의 1이에요.
- 한 토큰씩 생성할 때는 메모리 읽기 속도가 한계예요. 다음 절에서 설명할게요.
2. 왜 한 토큰씩 만드는 게 느릴까
언어 모델은 토큰을 하나 만들 때마다 가중치 전체를 메모리에서 한 번씩 읽어요. 한 사용자에게 생성할 때는 읽어 온 가중치 하나로 곱셈 몇 번만 하고 버려요. 계산 장치는 대부분 놀고, 메모리에서 숫자를 날라 오는 속도가 전체 속도를 정해요. 이런 상태를 메모리 대역폭에 묶였다고 해요.
초당 1TB를 읽는 GPU에서 13.5GB 모델은 한 사람에게 초당 74토큰이 한계예요. 그래서 이런 방향의 최적화가 나와요.
- 읽을 양 줄이기: 가중치를 4비트로 줄이면 한계가 초당 297토큰으로 올라가요(3절 양자화).
- 한 번 읽어 여러 번 쓰기: 여러 사용자의 요청을 묶어 한꺼번에 계산해요(4절 배치).
- 한 번에 여러 토큰 확정하기: 작은 모델의 초안을 큰 모델이 한 번에 검사해요(6절 추측 디코딩).
3. 양자화: 숫자를 거칠게 저장하기
양자화는 32비트나 16비트 실수인 가중치를 8비트, 4비트 정수로 바꿔 저장하는 거예요. 가장 단순한 방법은 가장 큰 절댓값을 정수의 끝에 맞추는 거예요.
이면 정수는 -127에서 127까지, 면 -7에서 7까지예요. 저장은 정수 와 배율 로 하고, 계산할 때 로 되살려요. 그런데 배율을 무엇마다 하나씩 둘지가 중요해요. 실제 LLM의 가중치와 활성값에는 다른 값보다 수십 배 큰 이상값이 드물게 있어서, 하나 때문에 배율 전체가 망가질 수 있거든요. 가중치 하나만 이상값으로 바꾼 행렬로 실험해 볼게요.
rng = np.random.default_rng(0)
W = rng.normal(0, 0.02, (256, 1024)).astype(np.float32)
W[3, 7] = 1.5 # 다른 값보다 75배 큰 이상값 하나
x = rng.normal(0, 1, (1024, 64)).astype(np.float32)
def quant_tensor(w, bits): # 행렬 전체에 배율 하나
qmax = 2 ** (bits - 1) - 1
s = np.abs(w).max() / qmax
return np.clip(np.round(w / s), -qmax, qmax) * s
def quant_rows(w, bits): # 행마다 배율 하나
qmax = 2 ** (bits - 1) - 1
s = np.abs(w).max(1, keepdims=True) / qmax
return np.clip(np.round(w / s), -qmax, qmax) * s
def quant_groups(w, bits, g=64): # 행 안에서도 g개씩 묶어 배율 하나
qmax = 2 ** (bits - 1) - 1
wg = w.reshape(w.shape[0], -1, g)
s = np.abs(wg).max(2, keepdims=True) / qmax
return (np.clip(np.round(wg / s), -qmax, qmax) * s).reshape(w.shape)
ref = W @ x
for name, fn, bits in [("8비트, 전체 배율 하나", quant_tensor, 8), ("8비트, 행마다", quant_rows, 8),
("4비트, 행마다", quant_rows, 4), ("4비트, 64개 묶음마다", quant_groups, 4)]:
wq = fn(W, bits)
err = np.linalg.norm(wq @ x - ref) / np.linalg.norm(ref)
print(f"{name}: 출력 오차 {err:.1%}, 0이 돼 버린 가중치 {np.mean(wq == 0):.1%}")
8비트, 전체 배율 하나: 출력 오차 16.9%, 0이 돼 버린 가중치 23.1%
8비트, 행마다: 출력 오차 1.3%, 0이 돼 버린 가중치 1.1%
4비트, 행마다: 출력 오차 15.5%, 0이 돼 버린 가중치 19.7%
4비트, 64개 묶음마다: 출력 오차 10.8%, 0이 돼 버린 가중치 14.7%
- 배율 하나를 전체에 쓰면 이상값 1.5에 맞춰 눈금이 너무 넓어져서, 보통 크기의 가중치 23%가 0으로 뭉개져요. 8비트인데도 출력 오차가 17%예요.
- 행마다 배율을 두면 이상값의 피해가 그 행 하나에 갇혀서 오차가 1.3%로 줄어요.
- 4비트는 눈금이 15개뿐이라 행마다 배율을 둬도 오차가 커요. 64개씩 묶어 배율을 두면 묶음 안의 최댓값이 작아져 눈금이 촘촘해지고 오차가 줄어요. 실제 4비트 양자화는 이런 묶음 방식에, 보정 데이터로 반올림 오차를 줄이는 기법(2022년의 GPTQ, 2023년의 AWQ 같은 것)을 더해요. 2022년의 한 연구는 모델이 커지면 이런 이상값이 체계적으로 나타나서, 이상값만 16비트로 따로 계산하는 방법을 제안하기도 했어요.
행렬의 오차가 실제 모델의 성능에는 얼마나 영향을 줄까요? 손글씨 숫자를 분류하는 작은 신경망을 학습시키고 가중치만 양자화해 볼게요.
from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
X, y = load_digits(return_X_y=True) # 8×8 손글씨 숫자 1,797장
Xtr, Xte, ytr, yte = train_test_split(X / 16.0, y, test_size=0.3, random_state=0, stratify=y)
Xtr, Xte = torch.tensor(Xtr, dtype=torch.float32), torch.tensor(Xte, dtype=torch.float32)
ytr, yte = torch.tensor(ytr), torch.tensor(yte)
torch.manual_seed(0)
net = nn.Sequential(nn.Linear(64, 128), nn.ReLU(), nn.Linear(128, 128), nn.ReLU(), nn.Linear(128, 10))
opt = torch.optim.Adam(net.parameters(), lr=1e-3)
for epoch in range(60):
perm = torch.randperm(len(Xtr), generator=torch.Generator().manual_seed(epoch))
for i in range(0, len(Xtr), 64):
idx = perm[i:i + 64]
loss = F.cross_entropy(net(Xtr[idx]), ytr[idx])
opt.zero_grad()
loss.backward()
opt.step()
def accuracy(m):
with torch.no_grad():
return (m(Xte).argmax(1) == yte).float().mean().item()
print(f"32비트 원본: {accuracy(net):.2%}")
for name, fn, bits in [("8비트", quant_rows, 8), ("4비트", quant_rows, 4),
("4비트, 16개 묶음", lambda w, b: quant_groups(w, b, 16), 4),
("3비트", quant_rows, 3), ("2비트", quant_rows, 2)]:
m = copy.deepcopy(net)
with torch.no_grad():
for layer in m:
if isinstance(layer, nn.Linear):
layer.weight.copy_(torch.tensor(fn(layer.weight.numpy(), bits)))
print(f"{name}: {accuracy(m):.2%}")
32비트 원본: 97.78%
8비트: 97.59%
4비트: 97.41%
4비트, 16개 묶음: 97.96%
3비트: 96.30%
2비트: 63.89%
8비트와 4비트는 거의 공짜예요. 4비트 묶음 방식이 원본보다 조금 높게 나온 건 우연한 흔들림이에요(시험 데이터 540장에서 한 장 차이가 0.19%p예요). 3비트부터 눈에 띄게 떨어지고, 2비트에서 무너져요. 신경망은 생각보다 거친 숫자를 잘 견디지만, 어딘가에 절벽이 있어요. 실제 LLM에서도 8비트는 거의 손실이 없고, 4비트는 좋은 방법을 쓰면 대부분의 작업에서 버틸 만하다는 것이 일반적인 경험이에요. 다만 작업에 따라 다르니, 양자화한 모델도 평가 세트로 확인해요.
4. 배치: 한 번 읽어서 여러 명에게 쓰기
2절에서 본 것처럼, 한 사용자에게 생성할 때는 가중치를 읽어 와서 곱셈 조금 하고 버려요. 여러 사용자의 요청을 묶어서 계산하면 한 번 읽은 가중치로 여러 요청을 처리할 수 있어요. 4096×4096 행렬 곱으로 재 볼게요.
torch.manual_seed(0)
Wt = torch.randn(4096, 4096)
for bs in (1, 8, 64, 256):
xb = torch.randn(bs, 4096)
for _ in range(3):
Wt @ xb.T # 몸풀기
t0 = time.perf_counter()
for _ in range(20):
Wt @ xb.T
dt = (time.perf_counter() - t0) / 20
print(f"배치 {bs}: 한 번에 {dt * 1000:.2f}ms, 요청 하나당 {dt / bs * 1000:.3f}ms")
시간은 컴퓨터마다 다르지만, 이 강의를 만든 컴퓨터(CPU)에서는 요청 하나당 시간이 배치 1일 때 약 4ms에서 배치 256일 때 약 0.13ms로 30배쯤 줄었어요. 배치를 키워도 한 번 계산하는 시간은 그만큼 늘지 않으니까요. 배치가 아주 커지면 결국 계산 장치가 꽉 차서(계산에 묶여서) 더는 줄지 않아요.
배치에는 대가도 있어요.
- 기다림: 요청을 모으려고 기다리면 첫 토큰이 늦어져요. 그래서 요즘 서버들은 연속 배치를 써요. 생성은 한 토큰씩 진행되니, 걸음마다 끝난 요청은 빼고 새 요청은 끼워 넣어서 배치를 늘 꽉 채워요.
- KV 캐시 메모리: 동시에 처리하는 요청마다 KV 캐시가 필요해서, 1절의 계산대로 메모리가 배치 크기를 제한해요. 2023년에 나온 vLLM은 KV 캐시를 운영체제의 가상 메모리처럼 작은 페이지로 나눠 관리해서(PagedAttention), 빈자리 낭비를 줄이고 더 많은 요청을 동시에 받았어요.
5. KV 캐시: 계산한 것은 다시 하지 않기
트랜스포머 강의의 생성 코드는 토큰을 하나 만들 때마다 지금까지의 글 전체를 모델에 다시 넣었어요. 그런데 인과적 어텐션에서는 앞 토큰들이 뒤 토큰을 보지 않으니, 앞 토큰들의 키와 값은 새 토큰이 와도 변하지 않아요. 그러니 한 번 계산한 키와 값을 저장해 두고, 새 토큰의 질의·키·값만 계산하면 돼요. 이것이 KV 캐시예요. 결과가 정말 같은지 어텐션 층 하나로 확인해 볼게요.
torch.manual_seed(0)
D = 64
Wq, Wk, Wv = (torch.randn(D, D) / 8 for _ in range(3))
tokens = torch.randn(50, D) # 토큰 50개의 임베딩
def attention_from_scratch(xs): # 매번 처음부터 전부 계산
q, k, v = xs @ Wq, xs @ Wk, xs @ Wv
mask = torch.triu(torch.ones(len(xs), len(xs), dtype=torch.bool), 1)
s = (q @ k.T / math.sqrt(D)).masked_fill(mask, float("-inf"))
return F.softmax(s, -1) @ v
full = attention_from_scratch(tokens)[-1] # 마지막 토큰의 출력
K, V = [], [] # KV 캐시
for t in range(len(tokens)):
xt = tokens[t:t + 1]
K.append(xt @ Wk) # 새 토큰의 키와 값만 계산해서 쌓아요
V.append(xt @ Wv)
q = xt @ Wq
out = F.softmax(q @ torch.cat(K).T / math.sqrt(D), -1) @ torch.cat(V)
print("결과가 같은가:", torch.allclose(out[0], full, atol=1e-5))
for n in (100, 1000, 4000):
print(f"{n}토큰 생성: 캐시 없이 {n * (n + 1) // 2:,}번, 캐시로 {n:,}번 토큰을 신경망에 통과")
결과가 같은가: True
100토큰 생성: 캐시 없이 5,050번, 캐시로 100번 토큰을 신경망에 통과
1000토큰 생성: 캐시 없이 500,500번, 캐시로 1,000번 토큰을 신경망에 통과
4000토큰 생성: 캐시 없이 8,002,000번, 캐시로 4,000번 토큰을 신경망에 통과
결과는 똑같고, 1,000토큰을 생성할 때 신경망을 통과하는 토큰 수가 50만 번에서 1,000번으로 줄어요. 새 토큰은 여전히 앞의 모든 키와 어텐션을 계산해야 하지만, 앞 토큰들을 층마다 다시 통과시키는 일은 사라져요. 대신 1절에서 본 만큼의 메모리를 써요. 계산을 메모리와 맞바꾼 거예요.
자동화 강의의 프롬프트 캐시도 같은 원리예요. 여러 요청의 앞부분이 같으면 그 부분의 KV 캐시를 저장해 뒀다가 다시 써요. 계산을 안 하니 첫 토큰이 빨리 나오고, 그래서 제공사가 더 싸게 받는 거예요.
6. 추측 디코딩: 작은 모델이 쓰고 큰 모델이 검사하기
큰 모델은 토큰을 하나씩만 만들 수 있지만, 이미 쓰인 글을 검사하는 건 한 번에 여러 토큰을 할 수 있어요. 학습할 때 모든 위치의 다음 토큰을 한꺼번에 예측했던 것처럼요. 이 점을 이용한 게 추측 디코딩(2023년)이에요.
- 작고 빠른 초안 모델이 다음 토큰 개를 먼저 써요.
- 큰 모델이 그 개를 한 번에 검사해요.
- 앞에서부터 큰 모델도 동의하는 토큰까지 받아들이고, 처음 어긋난 자리에는 큰 모델이 고른 토큰을 써요.
초안 토큰 하나가 받아들여질 확률을 라고 하면, 큰 모델이 한 번 계산할 때 확정되는 토큰 수의 기댓값은 이래요.
def expected_tokens(alpha, k):
return (1 - alpha ** (k + 1)) / (1 - alpha)
for a in (0.6, 0.8, 0.9):
print(f"받아들일 확률 {a}:", [round(expected_tokens(a, k), 2) for k in (2, 4, 8)])
rng = np.random.default_rng(0) # 시뮬레이션으로 공식 확인 (α=0.8, k=4)
sim = []
for _ in range(100000):
n = 0
while n < 4 and rng.random() < 0.8: # 앞에서부터 받아들여지는 동안
n += 1
sim.append(n + 1) # 큰 모델이 한 토큰을 더해요
print(round(float(np.mean(sim)), 3), round(expected_tokens(0.8, 4), 3))
받아들일 확률 0.6: [1.96, 2.31, 2.47]
받아들일 확률 0.8: [2.44, 3.36, 4.33]
받아들일 확률 0.9: [2.71, 4.1, 6.13]
3.369 3.362
초안이 80% 확률로 맞고 4개씩 쓰면, 큰 모델 한 번에 평균 3.36토큰이 확정돼요. 큰 모델을 부르는 횟수가 3분의 1 아래로 줄어드는 거예요. 초안 모델을 돌리는 비용이 있으니 실제 속도 향상은 그보다 작고, 초안이 잘 맞는 글(코드처럼 뻔한 부분이 많은 글)일수록 효과가 커요. 중요한 성질은, 받아들이는 규칙을 제대로 정하면 결과의 분포가 큰 모델 혼자 만든 것과 똑같다는 거예요. 품질을 잃지 않고 빨라지는 방법이에요.
7. 그 밖의 방법들
- 작은 모델로 바꾸기: 파인튜닝 강의의 증류처럼, 큰 모델의 답으로 작은 모델을 학습시켜요. 쉬운 요청은 작은 모델로, 어려운 요청만 큰 모델로 보내는 라우팅도 있어요.
- 플래시 어텐션(2022년): 어텐션 계산 결과는 그대로 두고, GPU의 빠른 작은 메모리를 잘 쓰도록 계산 순서를 바꿔서 빠르고 메모리도 적게 써요. 최적화가 꼭 근사일 필요는 없다는 좋은 예예요.
- 가지치기: 중요하지 않은 가중치를 0으로 만들어 없애요.
- 출력 줄이기: 출력 토큰은 하나씩 만들어야 해서 비싸요. 필요한 만큼만 길게 쓰게 하는 것도 최적화예요.
어떤 방법이든 원칙은 같아요. 재고, 바꾸고, 다시 재요. 속도만 보지 말고, 평가 세트로 품질이 지켜졌는지 함께 확인해요.
실습
- 1절의 계산에서 대화 길이를 32,000토큰으로 늘리면 KV 캐시는 얼마가 되나요? 키·값 머리 8개인 모델은요?
- 이상값 실험에서 이상값을 하나 더(다른 행에) 넣으면 "행마다" 방식의 오차는 어떻게 되나요?
- 숫자 분류기에서 첫 층만 2비트로, 나머지는 8비트로 두면 정확도는 어떻게 되나요? 층마다 민감도가 다를까요?
- 배치 실험을 행렬 크기 1024×1024로 바꿔 보세요. 배치의 효과가 커지나요, 작아지나요?
- 추측 디코딩에서 초안 모델의 계산 비용이 큰 모델의 10%라면, α=0.8일 때 를 몇으로 하는 게 가장 좋을까요? 한 번의 큰 모델 계산과 번의 초안 계산을 더한 비용으로 나눠 보세요.
자주 하는 실수
- 가중치 메모리만 계산하기. 긴 대화와 많은 동시 요청에서는 KV 캐시가 가중치보다 커질 수 있어요.
- 양자화를 배율 하나로 하기. 이상값 하나가 전체를 망쳐요. 행이나 묶음마다 배율을 둬요.
- 양자화한 뒤 평가하지 않기. 작업에 따라 손실이 다르고, 어딘가에 절벽이 있어요.
- 처리량만 보고 배치 키우기. 첫 토큰까지의 시간이 늘어 사용자는 더 느리다고 느낄 수 있어요.
- 추측 디코딩을 품질을 버리는 근사라고 생각하기. 받아들이는 규칙을 제대로 쓰면 결과의 분포가 같아요.
- 재 보지 않고 최적화하기. 어디가 병목인지(메모리인지, 계산인지, 네트워크인지) 먼저 재요.
점검 문제
- 70억 파라미터 모델의 16비트 가중치와 4비트 가중치는 각각 대략 몇 GB인가요?
- 한 사용자에게 토큰을 생성할 때 속도를 주로 묶는 것은 무엇이고, 왜 그런가요?
- 양자화에서 이상값 하나가 전체 오차를 키우는 이유와, 막는 방법은?
- 배치가 요청당 시간을 줄이는 원리는?
- KV 캐시를 써도 결과가 달라지지 않는 이유는?
- 추측 디코딩에서 α=0.8, k=4일 때 큰 모델 한 번에 확정되는 토큰 수의 기댓값은?
- 프롬프트 캐시가 첫 토큰을 빠르게 하고 비용을 줄이는 이유는?
정답
- 16비트는 GB, 4비트는 약 3.4GB예요.
- 메모리 대역폭이에요. 토큰 하나를 만들 때마다 가중치 전체를 메모리에서 읽어야 하는데, 읽어 온 숫자로 하는 계산은 아주 적어서 읽는 속도가 전체 속도를 정해요.
- 가장 큰 절댓값에 맞춰 배율을 정하니, 이상값 때문에 눈금이 넓어져 보통 크기의 가중치들이 0이나 몇 개의 값으로 뭉개지기 때문이에요. 행이나 작은 묶음마다 배율을 두면 피해가 그 안에 갇혀요.
- 가중치를 한 번 읽어 와서 여러 요청에 함께 쓰기 때문이에요. 읽는 비용이 요청 수만큼 나눠져요.
- 인과적 어텐션에서는 앞 토큰이 뒤 토큰을 보지 않아서, 앞 토큰들의 키와 값이 새 토큰이 와도 변하지 않기 때문이에요.
- 개예요.
- 앞부분이 같은 요청이면 그 부분의 KV 캐시를 저장해 뒀다가 다시 써서, 그만큼의 계산을 건너뛰기 때문이에요.
다음 강의
AI 엔지니어링 트랙의 마지막 강의예요. 이 분야는 몇 달마다 새 방법이 나와요. 다음 강의에서는 AI 논문을 겁내지 않고 읽는 순서, 숫자와 주장을 의심하며 확인하는 법, 그리고 쏟아지는 소식 속에서 진짜 중요한 것을 골라 따라가는 습관을 다뤄요.