docs(10_Wiki): Topic_Business/General/Graphic/Programming을 Topics/ 하위로 이동

최상위 10_Wiki/Topic_*였던 4개 카테고리 폴더를 10_Wiki/Topics/Topic_* 로 재배치.
콘텐츠 변경 없음(순수 폴더 이동) — Topics/ 하위 나머지 폴더는 이미 지난 커밋에서
전부 정리된 상태(잔존 항목은 에이전트 운영 상태 및 사용자가 보존을 요청한
업데이트0615/무제 3.canvas 뿐).
This commit is contained in:
Antigravity Agent
2026-07-05 00:44:01 +09:00
parent e9cbf23ab5
commit 9a135bd19d
6127 changed files with 0 additions and 0 deletions
@@ -0,0 +1,231 @@
---
id: wiki-2026-0508-key-value-kv-cache
title: Key-Value (KV) Cache
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [KV cache, key-value cache, paged attention, vLLM, prefix caching]
duplicate_of: none
source_trust_level: A
confidence_score: 0.96
verification_status: applied
tags: [llm, kv-cache, inference, paged-attention, vllm, optimization]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
language: Python / CUDA
framework: vLLM / TensorRT-LLM / SGLang
---
# Key-Value (KV) Cache
## 매 한 줄
> **"매 transformer inference 의 의 의 의 의 K, V 의 store"**. 매 매 token generate 의 매 quadratic → 매 linear 의 의 의 의 의 enable. 매 modern: 매 paged attention (vLLM Kwon 2023), 매 prefix cache, 매 quantized KV.
## 매 핵심
### 매 motivation
- **Without cache**: 매 매 step 의 의 의 의 모든 prev token 의 attention 의 recompute → O(N²).
- **With cache**: 매 매 K, V 의 store → 매 single new token 의 attention → O(N).
- **Memory cost**: 매 batch × seq × layers × kv_heads × head_dim × 2 (K + V) × dtype.
### 매 응용
1. Inference acceleration.
2. Long-context generation.
3. Streaming response.
4. Multi-turn chat.
### 매 modern technique
- **Paged Attention** (vLLM 2023): 매 OS-style page.
- **Prefix caching**: 매 same prefix 의 의 reuse.
- **GQA + KV** (Llama): 매 cache size ↓.
- **MLA** (DeepSeek-V2): 매 latent compression.
- **Quantized KV** (FP8, INT4).
- **Sliding window** (Mistral): 매 truncate.
## 💻 패턴
### Basic KV cache (educational)
```python
import torch
class CachedAttention:
def __init__(self):
self.k_cache = [] # 매 list of [batch, n_heads, head_dim]
self.v_cache = []
def forward(self, q_new, k_new, v_new):
# 매 append new
self.k_cache.append(k_new)
self.v_cache.append(v_new)
# 매 stack
k_all = torch.stack(self.k_cache, dim=2) # 매 [B, H, T, D]
v_all = torch.stack(self.v_cache, dim=2)
# 매 attention with new q only (1 token)
attn = (q_new @ k_all.transpose(-1, -2) / k_all.size(-1) ** 0.5).softmax(-1)
return attn @ v_all
```
### Memory size calculation
```python
def kv_cache_bytes(batch, seq, layers, kv_heads, head_dim, dtype_bytes=2):
return batch * seq * layers * kv_heads * head_dim * 2 * dtype_bytes
# 매 Llama 70B GQA: 80 layers, 8 KV heads, 128 head_dim
# 매 batch=1, seq=4096, bf16
size_gb = kv_cache_bytes(1, 4096, 80, 8, 128, 2) / 1e9
# 매 ≈ 1.34 GB
```
### vLLM (production)
```python
from vllm import LLM, SamplingParams
llm = LLM(model='meta-llama/Llama-3.1-70B-Instruct', max_num_seqs=64)
sampling = SamplingParams(temperature=0.7, max_tokens=512)
outputs = llm.generate(prompts, sampling)
# 매 internally: paged attention + dynamic batching
```
### Prefix cache (vLLM)
```python
# 매 same system prompt 의 의 의 cache 의 reuse
# 매 vLLM 의 enable_prefix_caching=True
llm = LLM(model='...', enable_prefix_caching=True)
```
### Anthropic prompt caching
```python
from anthropic import Anthropic
client = Anthropic()
response = client.messages.create(
model='claude-opus-4-7',
max_tokens=1024,
system=[
{'type': 'text', 'text': 'You are an expert.', 'cache_control': {'type': 'ephemeral'}},
{'type': 'text', 'text': long_book_content, 'cache_control': {'type': 'ephemeral'}},
],
messages=[{'role': 'user', 'content': question}],
)
# 매 second call with same prefix = 매 90% cost ↓
```
### Sliding window (Mistral-style)
```python
def sliding_window_kv(k_cache, v_cache, window=4096):
if k_cache.size(2) > window:
k_cache = k_cache[:, :, -window:]
v_cache = v_cache[:, :, -window:]
return k_cache, v_cache
```
### GQA-aware cache
```python
def gqa_kv_cache_size(batch, seq, layers, n_q_heads, n_kv_heads, head_dim):
"""매 GQA: 매 KV heads < Q heads → 매 cache size ↓."""
return batch * seq * layers * n_kv_heads * head_dim * 2
# 매 Llama 70B: 매 8 KV vs 64 Q = 매 8x ↓ cache
```
### MLA (DeepSeek)
```python
class MLA:
"""매 매 K, V 의 의 의 의 의 of low-rank latent."""
def __init__(self, d_model, d_latent=512):
self.W_dkv = nn.Linear(d_model, d_latent) # 매 cache 매 latent only
self.W_uk = nn.Linear(d_latent, d_model) # 매 reconstruct K
self.W_uv = nn.Linear(d_latent, d_model) # 매 reconstruct V
def forward(self, x, kv_cache):
c = self.W_dkv(x)
kv_cache.append(c) # 매 small
# 매 reconstruct on-the-fly
```
### KV quantization
```python
def quantize_kv(k, v, bits=8):
"""매 K, V 의 의 의 INT8 / FP8 의 의 의 store."""
k_int8 = (k * 127 / k.abs().max()).to(torch.int8)
v_int8 = (v * 127 / v.abs().max()).to(torch.int8)
return k_int8, v_int8, k.abs().max(), v.abs().max() # scale factors
```
### Streaming generation
```python
def stream_generate(model, prompt, max_tokens=200):
input_ids = tokenize(prompt)
kv_cache = None
# 매 prefill
out, kv_cache = model.forward(input_ids, kv_cache=None)
for _ in range(max_tokens):
next_token = sample(out[:, -1])
yield next_token
# 매 매 single token forward
out, kv_cache = model.forward(next_token.unsqueeze(0), kv_cache=kv_cache)
```
### Continuous batching (vLLM)
```python
# 매 매 request 의 different stage 의 같이 batch
# 매 vLLM 의 매 (Yu 2022 Orca)
# 매 prefill + decode 의 mix
class ContinuousBatcher:
def step(self, requests):
# 매 prefill new + decode existing
return run_iteration(requests)
```
### Memory profile (debug)
```python
def profile_kv_cache(model, seq_lens):
for seq in seq_lens:
torch.cuda.reset_peak_memory_stats()
out = model.generate(input_ids[:1, :seq])
peak = torch.cuda.max_memory_allocated() / 1e9
print(f'seq={seq}: peak {peak:.2f} GB')
```
## 매 결정 기준
| 상황 | Approach |
|---|---|
| Production serving | vLLM (paged) |
| Long context | GQA + MLA |
| Multi-turn chat | Prefix caching |
| Memory tight | Quantized KV |
| Very long | Sliding window (Mistral) |
| API | Anthropic prompt cache |
**기본값**: 매 vLLM + 매 GQA + 매 prefix caching + 매 dynamic batching. 매 long context = quantized KV / MLA.
## 🔗 Graph
- 부모: [[Transformer]]
- 변형: [[PagedAttention]]
- 응용: [[LLM_Optimization_and_Deployment_Strategies|vLLM]]
- Adjacent: [[Flash Attention]] · [[Grouped-Query Attention (GQA)]] · [[Foundation-Models]]
## 🤖 LLM 활용
**언제**: 매 inference. 매 모든 production LLM serving.
**언제 X**: 매 single-shot research only.
## ❌ 안티패턴
- **No KV cache**: 매 quadratic — unusable for long.
- **Static batching**: 매 GPU underutil.
- **Full-precision KV at scale**: 매 memory waste.
- **Recompute prefix every call**: 매 cost ↑.
## 🧪 검증 / 중복
- Verified (Vaswani 2017, Kwon vLLM 2023, Yu Orca 2022, DeepSeek-V2 MLA).
- 신뢰도 A.
## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — KV cache + 매 vLLM / prefix / MLA / sliding / quantize code |