✍️ 필사 모드: LLM 추론 최적화 완전 가이드 2025: vLLM, TensorRT-LLM, KV Cache, Speculative Decoding

┌──────────────────────────────────────────────────────┐
│                  LLM 추론 파이프라인                    │
├──────────────────┬───────────────────────────────────┤
│   Prefill 단계    │         Decode 단계               │
│   (프롬프트 처리)  │      (토큰 생성)                   │
├──────────────────┼───────────────────────────────────┤
│ - 입력 토큰 병렬   │ - 토큰 1개씩 순차 생성              │
│ - Compute-Bound  │ - Memory-Bound                    │
│ - 높은 GPU 활용률  │ - 낮은 GPU 활용률 (보통 5-15%)      │
│ - 한 번 실행      │ - 출력 길이만큼 반복                 │
│ - KV Cache 생성   │ - KV Cache 읽기 + 추가              │
└──────────────────┴───────────────────────────────────┘

# KV Cache 없는 경우 (매 스텝 전체 재계산)
# 토큰 n개 생성 시 총 연산: O(n^2 * d)

# KV Cache 있는 경우 (이전 결과 재사용)
# 토큰 n개 생성 시 총 연산: O(n * d)
# 단, KV Cache 메모리: O(n * d) 추가 필요

KV Cache 크기 = 2 * num_layers * num_kv_heads * head_dim * seq_len * batch_size * dtype_size

예시: Llama-2 70B, seq_len=4096, batch_size=1, FP16
= 2 * 80 * 8 * 128 * 4096 * 1 * 2 bytes
= 1.34 GB (시퀀스 하나에!)

batch_size=32면: 1.34 * 32 = 42.9 GB

┌─────────────────────────────────────────────┐
│        기존 KV Cache 할당 방식               │
│                                             │
│  Request 1: [████████░░░░░░░░░░░░]  40% 사용 │
│  Request 2: [████████████░░░░░░░░]  60% 사용 │
│  Request 3: [██░░░░░░░░░░░░░░░░░░]  10% 사용 │
│              ^^^^^^^^ 낭비되는 메모리          │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│       PagedAttention KV Cache 할당           │
│                                             │
│  물리 블록: [B0][B1][B2][B3][B4][B5][B6][B7] │
│                                             │
│  Request 1 → 페이지 테이블: [B0, B3, B5]     │
│  Request 2 → 페이지 테이블: [B1, B4, B6, B7] │
│  Request 3 → 페이지 테이블: [B2]             │
│                                             │
│  ✅ 내부 단편화 거의 제로                     │
│  ✅ 비연속 메모리 블록 활용                    │
│  ✅ Copy-on-Write로 프롬프트 공유             │
└─────────────────────────────────────────────┘

# vLLM에서 Prefix Caching 활성화
from vllm import LLM

llm = LLM(
    model="meta-llama/Llama-3.1-70B-Instruct",
    enable_prefix_caching=True,  # Prefix Caching 활성화
    max_model_len=8192,
)

# 같은 시스템 프롬프트를 사용하는 요청들은
# 시스템 프롬프트 부분의 KV Cache를 공유합니다

┌──────────────────────────────────────────────┐
│          FlashAttention 핵심 아이디어          │
│                                              │
│  GPU 메모리 계층:                              │
│  ┌─────────┐  19 TB/s   ┌─────────────────┐ │
│  │  SRAM   │◄──────────►│  Compute Units   │ │
│  │ (20 MB) │            └─────────────────┘ │
│  └────┬────┘                                 │
│       │ 2-4.8 TB/s                           │
│  ┌────▼────────────────┐                     │
│  │    HBM (80-141 GB)  │                     │
│  └─────────────────────┘                     │
│                                              │
│  전략: Q,K,V를 타일(블록)로 나누어             │
│  SRAM에서 모든 계산을 수행하고                  │
│  최종 결과만 HBM에 기록                        │
└──────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────┐
│    Multi-Head Attention (MHA)                       │
│    Q heads: [H1][H2][H3][H4][H5][H6][H7][H8]      │
│    K heads: [H1][H2][H3][H4][H5][H6][H7][H8]      │
│    V heads: [H1][H2][H3][H4][H5][H6][H7][H8]      │
│    KV Cache: 8x                                     │
├─────────────────────────────────────────────────────┤
│    Multi-Query Attention (MQA)                      │
│    Q heads: [H1][H2][H3][H4][H5][H6][H7][H8]      │
│    K heads: [        H_shared         ]             │
│    V heads: [        H_shared         ]             │
│    KV Cache: 1x (8배 절감)                          │
├─────────────────────────────────────────────────────┤
│    Grouped-Query Attention (GQA, 2 groups)          │
│    Q heads: [H1][H2][H3][H4] | [H5][H6][H7][H8]   │
│    K heads: [   K_group1   ] | [   K_group2   ]    │
│    V heads: [   V_group1   ] | [   V_group2   ]    │
│    KV Cache: 2x (4배 절감)                          │
└─────────────────────────────────────────────────────┘

Static Batching (기존 방식):
시간 ──────────────────────────────────►

Req 1: [████████████████████████████████]  (긴 응답)
Req 2: [████████░░░░░░░░░░░░░░░░░░░░░░]  (짧은 응답)
Req 3: [██████████████░░░░░░░░░░░░░░░░]  (중간 응답)
Req 4: [WAIT WAIT WAIT WAIT WAIT WAIT ]  (대기 중)

░ = GPU 유휴 (패딩), WAIT = 배치 완료까지 대기
전체 배치가 끝나야 다음 배치 시작 → 처리량 매우 낮음

Continuous Batching:
시간 ──────────────────────────────────►

Req 1: [████████████████████████████████]
Req 2: [████████]
Req 3:          [██████████████]
Req 4:                  [████████████████]
Req 5:                          [████████]

완료된 요청 즉시 제거 → 새 요청 즉시 투입
GPU 유휴 시간 최소화 → 처리량 10-20배 향상

# vLLM chunked prefill 설정
from vllm import LLM, SamplingParams

llm = LLM(
    model="meta-llama/Llama-3.1-8B-Instruct",
    enable_chunked_prefill=True,
    max_num_batched_tokens=2048,  # 한 번에 처리할 최대 토큰 수
)

# 긴 프롬프트(예: 32K 토큰)를 2048 토큰 청크로 나누어 처리
# 청크 사이사이에 Decode 요청도 처리 가능
# TTFT는 약간 증가하지만, 전체 시스템 처리량과 ITL 개선

┌────────────────────────────────────────────────────┐
│              Speculative Decoding 흐름              │
│                                                    │
│  Step 1: Draft Model (작고 빠른 모델)               │
│  "The capital of France is" → [Paris][,][a][city]  │
│  4개 토큰을 매우 빠르게 예측 (4ms)                   │
│                                                    │
│  Step 2: Target Model (크고 정확한 모델)             │
│  한 번의 forward pass로 4개 토큰 동시 검증           │
│  [Paris ✅] [, ✅] [a ❌→ "known"] [city ❌]         │
│                                                    │
│  결과: "Paris, known" (2개 수락 + 1개 수정)          │
│  기존: 3 forward pass 필요 → 이제 1 forward pass    │
│  속도 향상: 약 2-3x                                 │
└────────────────────────────────────────────────────┘

# 1. 별도 Draft Model 사용
from vllm import LLM, SamplingParams

llm = LLM(
    model="meta-llama/Llama-3.1-70B-Instruct",
    speculative_model="meta-llama/Llama-3.1-8B-Instruct",
    num_speculative_tokens=5,
    use_v2_block_manager=True,
)

# 2. Medusa Heads (추가 MLP 헤드로 여러 위치 동시 예측)
# Draft 모델 없이 타겟 모델 자체에 경량 헤드를 추가
# 학습 필요하지만 메모리 오버헤드 최소

# 3. EAGLE (Extrapolation Algorithm for Greater Language-model Efficiency)
# 드래프트 모델이 타겟 모델의 hidden state를 재사용
# 별도 드래프트 모델보다 높은 수락률

토큰 위치:    1        2        3
            ┌── Paris ─┬── is ── ...
The ────────┤          └── was ── ...
            ├── Lyon ── is ── ...
            └── capital ── of ── ...

트리의 모든 경로를 한 번의 forward pass로 검증
→ 수락 확률 극대화, 처리량 향상

┌───────────────────────────────────────────────────────┐
│              양자화 기법 분류                            │
├─────────────────────┬─────────────────────────────────┤
│  Post-Training      │  Training-Aware                 │
│  Quantization(PTQ)  │  Quantization                   │
├─────────────────────┼─────────────────────────────────┤
│  - GPTQ (INT4)      │  - QLoRA + Merge                │
│  - AWQ (INT4)       │  - QAT (Quantization-Aware      │
│  - GGUF (다양한)     │    Training)                    │
│  - bitsandbytes     │                                 │
│  - SmoothQuant      │                                 │
│  - FP8 Dynamic      │                                 │
└─────────────────────┴─────────────────────────────────┘

# GPTQ: 레이어별 최적 양자화 (OBQ 기반)
# 장점: INT4에서도 좋은 품질, GPU 추론 최적화
# 단점: 캘리브레이션 데이터 필요, 양자화 시간 오래 걸림

from transformers import AutoModelForCausalLM, GPTQConfig

gptq_config = GPTQConfig(
    bits=4,
    group_size=128,
    dataset="c4",
    desc_act=True,
)
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-70B-Instruct",
    quantization_config=gptq_config,
    device_map="auto",
)

# AWQ: Activation-aware Weight Quantization
# 핵심: 중요한 가중치 채널을 찾아 보호 (활성화 크기 기준)
# GPTQ보다 빠른 양자화, 비슷한 품질

from awq import AutoAWQForCausalLM

model = AutoAWQForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-70B-Instruct"
)
quant_config = {
    "zero_point": True,
    "q_group_size": 128,
    "w_bit": 4,
    "version": "GEMM"
}
model.quantize(tokenizer, quant_config=quant_config)

# bitsandbytes: 간편한 INT8/NF4 양자화
from transformers import BitsAndBytesConfig

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype="bfloat16",
    bnb_4bit_use_double_quant=True,
)
model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B-Instruct",
    quantization_config=bnb_config,
)

┌──────────────────────────────────────────┐
│              vLLM Architecture            │
│                                          │
│  ┌─────────┐     ┌──────────────────┐   │
│  │ FastAPI  │────►│   LLM Engine     │   │
│  │ Server   │     │                  │   │
│  └─────────┘     │  ┌────────────┐  │   │
│                  │  │ Scheduler   │  │   │
│  ┌─────────┐    │  │ (요청 배치)  │  │   │
│  │ OpenAI  │────►│  └─────┬──────┘  │   │
│  │ compat  │     │        │         │   │
│  └─────────┘     │  ┌─────▼──────┐  │   │
│                  │  │ Block Mgr   │  │   │
│                  │  │ (PagedAttn) │  │   │
│                  │  └─────┬──────┘  │   │
│                  │        │         │   │
│                  │  ┌─────▼──────┐  │   │
│                  │  │  Worker(s)  │  │   │
│                  │  │  (GPU 실행) │  │   │
│                  │  └────────────┘  │   │
│                  └──────────────────┘   │
└──────────────────────────────────────────┘

# vLLM 서버 시작 (OpenAI API 호환)
# vllm serve meta-llama/Llama-3.1-70B-Instruct \
#     --tensor-parallel-size 4 \
#     --max-model-len 32768 \
#     --gpu-memory-utilization 0.90 \
#     --enable-prefix-caching \
#     --enable-chunked-prefill \
#     --max-num-batched-tokens 4096 \
#     --port 8000

# Python으로 API 호출
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="token-abc123",
)

response = client.chat.completions.create(
    model="meta-llama/Llama-3.1-70B-Instruct",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Explain quantum computing"},
    ],
    max_tokens=512,
    temperature=0.7,
)

# vllm serve meta-llama/Llama-3.1-8B-Instruct \
#     --enable-lora \
#     --lora-modules \
#         sql-lora=./adapters/sql-lora \
#         code-lora=./adapters/code-lora \
#         chat-lora=./adapters/chat-lora \
#     --max-loras 3 \
#     --max-lora-rank 64

# API 호출 시 모델 이름으로 LoRA 어댑터 선택
response = client.chat.completions.create(
    model="sql-lora",  # LoRA 어댑터 이름
    messages=[{"role": "user", "content": "SELECT ..."}],
)

# 멀티모달 모델 서빙
# vllm serve Qwen/Qwen2-VL-7B-Instruct \
#     --max-model-len 8192 \
#     --limit-mm-per-prompt image=4

from openai import OpenAI
import base64

client = OpenAI(base_url="http://localhost:8000/v1", api_key="key")

response = client.chat.completions.create(
    model="Qwen/Qwen2-VL-7B-Instruct",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What is in this image?"},
            {"type": "image_url", "image_url": {"url": "data:image/png;base64,..."}}
        ]
    }],
)

┌────────┐     ┌───────────┐     ┌──────────┐     ┌──────────┐
│HF Model│────►│ Convert   │────►│ TRT-LLM  │────►│ Triton   │
│(원본)   │     │ Checkpoint│     │ Engine   │     │ 서빙     │
└────────┘     └───────────┘     └──────────┘     └──────────┘
                 양자화 적용       컴파일 최적화      API 서버

# Step 1: 체크포인트 변환 + FP8 양자화
python convert_checkpoint.py \
    --model_dir meta-llama/Llama-3.1-70B-Instruct \
    --output_dir ./checkpoint_fp8 \
    --dtype bfloat16 \
    --tp_size 4 \
    --pp_size 1 \
    --use_fp8

# Step 2: TensorRT 엔진 빌드
trtllm-build \
    --checkpoint_dir ./checkpoint_fp8 \
    --output_dir ./engine_fp8 \
    --gemm_plugin auto \
    --max_batch_size 64 \
    --max_input_len 4096 \
    --max_seq_len 8192 \
    --paged_kv_cache enable \
    --use_paged_context_fmha enable \
    --workers 4

# Triton Inference Server + TensorRT-LLM 백엔드
# model_config.pbtxt 설정
"""
backend: "tensorrtllm"
max_batch_size: 64

model_transaction_policy {
  decoupled: True    # 스트리밍 응답 지원
}

parameters: {
  key: "batching_type"
  value: {string_value: "inflight"}  # Inflight Batching 활성화
}

parameters: {
  key: "max_tokens_in_paged_kv_cache"
  value: {string_value: "131072"}   # KV Cache 토큰 수 제한
}
"""

Tensor Parallelism (TP=4):

         레이어 N의 가중치 행렬 W
    ┌──────┬──────┬──────┬──────┐
    │ W_1  │ W_2  │ W_3  │ W_4  │
    │GPU 0 │GPU 1 │GPU 2 │GPU 3 │
    └──┬───┴──┬───┴──┬───┴──┬───┘
       │      │      │      │
       ▼      ▼      ▼      ▼
    [부분1] [부분2] [부분3] [부분4]
       │      │      │      │
       └──────┴──────┴──────┘
              All-Reduce
              (결과 합산)

장점: 레이턴시 감소 (모든 GPU 동시 계산)
단점: GPU 간 통신 필요 (NVLink 권장)
적합: 같은 노드 내 GPU (낮은 레이턴시 필요)

Pipeline Parallelism (PP=4, 80 layers):

GPU 0: [Layer 0-19]  → GPU 1: [Layer 20-39]
                              → GPU 2: [Layer 40-59]
                                       → GPU 3: [Layer 60-79]

장점: GPU 간 통신 최소 (한 방향)
단점: 파이프라인 버블 (GPU 유휴 시간)
적합: 노드 간 분산 (높은 레이턴시 허용)

Expert Parallelism (Mixtral 8x7B, EP=4):

GPU 0: Expert 0, 1 + Shared Layers
GPU 1: Expert 2, 3 + Shared Layers
GPU 2: Expert 4, 5 + Shared Layers
GPU 3: Expert 6, 7 + Shared Layers

토큰 라우팅: 각 토큰은 Top-2 Expert로 전송
→ GPU 간 All-to-All 통신 필요

# Llama-3.1 405B 서빙 (8x H100 80GB)
# 모델 크기: ~810 GB (FP16) → FP8로 ~405 GB

# 옵션 1: TP=8 (모든 GPU에 모든 레이어 분할)
vllm serve meta-llama/Llama-3.1-405B-Instruct-FP8 \
    --tensor-parallel-size 8 \
    --max-model-len 16384

# 옵션 2: TP=4, PP=2 (4 GPU씩 2 파이프라인 스테이지)
vllm serve meta-llama/Llama-3.1-405B-Instruct-FP8 \
    --tensor-parallel-size 4 \
    --pipeline-parallel-size 2 \
    --max-model-len 16384

# vLLM에서 KV Cache FP8 양자화
vllm serve meta-llama/Llama-3.1-70B-Instruct \
    --tensor-parallel-size 4 \
    --kv-cache-dtype fp8 \
    --quantization fp8

# KV Cache 메모리 절감 효과
# FP16 KV Cache: 1.34 GB / sequence (Llama-2 70B, 4K)
# FP8 KV Cache:  0.67 GB / sequence (50% 절감)
# 같은 GPU에서 2배 많은 동시 요청 처리 가능

GPU 메모리 분배 (A100 80GB, Llama-3.1 70B FP16):

┌─────────────────────────────────┐
│  모델 가중치: ~35 GB (TP=2)      │  43.75%
├─────────────────────────────────┤
│  KV Cache: ~35 GB               │  43.75%
│  (gpu_memory_utilization=0.90)  │
├─────────────────────────────────┤
│  활성화 메모리: ~2 GB            │  2.5%
├─────────────────────────────────┤
│  시스템 예약: ~8 GB              │  10%
└─────────────────────────────────┘

KV Cache가 처리 가능한 최대 동시 요청 수를 결정합니다.

월간 토큰 사용량별 비용 비교 (Llama-3.1 70B급):

┌─────────────────────────────────────────────────┐
│ 비용                                             │
│ ($)                                             │
│ 5000│                                    /API   │
│     │                                  /        │
│ 3000│                    ────────── Self-Hosted  │
│     │              /  (H100x4 월 고정비)          │
│ 1000│      / API                                │
│     │   /                                       │
│    0├──┬────┬────┬────┬────┬────┬────►          │
│     0  2B   5B  10B  20B  50B 100B  토큰/월      │
│                                                 │
│  손익분기점: 약 10B tokens/month                   │
└─────────────────────────────────────────────────┘

# vLLM 내장 벤치마크 (추천)
# python -m vllm.entrypoints.openai.api_server 실행 후:

# python benchmarks/benchmark_serving.py \
#     --backend vllm \
#     --model meta-llama/Llama-3.1-8B-Instruct \
#     --dataset-name sharegpt \
#     --dataset-path ShareGPT_V3_unfiltered.json \
#     --num-prompts 1000 \
#     --request-rate 10 \
#     --endpoint /v1/completions

# 결과 예시:
# Successful requests:                     1000
# Benchmark duration (s):                  105.23
# Total input tokens:                      215000
# Total generated tokens:                  180000
# Request throughput (req/s):              9.50
# Output token throughput (tok/s):         1710.5
# Mean TTFT (ms):                          48.2
# Median TTFT (ms):                        42.1
# P99 TTFT (ms):                           125.3
# Mean ITL (ms):                           11.8
# Median ITL (ms):                         10.2
# P99 ITL (ms):                            35.7

처리량과 레이턴시의 관계 (concurrency 증가 시):

처리량                          레이턴시
(tok/s)                        (ms)
  │        ┌──────────           │              /
  │       /                      │            /
  │      /                       │          /
  │     /                        │        /
  │    /                         │      /
  │   /                          │    /
  │  /                           │  /
  │ /                            │/
  ├──────────────► concurrency   ├──────────────► concurrency

  최적 운영점: 처리량이 포화되기 직전 (Knee point)
  보통 GPU 활용률 70-80% 지점

┌──────────────────────────────────────────────────┐
│                Production Architecture            │
│                                                  │
│  Client → Load Balancer → API Gateway            │
│                              │                   │
│                    ┌─────────┼─────────┐         │
│                    ▼         ▼         ▼         │
│              ┌─────────┐┌────────┐┌────────┐    │
│              │ vLLM    ││ vLLM   ││ vLLM   │    │
│              │ Pod 1   ││ Pod 2  ││ Pod 3  │    │
│              │ (4xH100)││(4xH100)││(4xH100)│    │
│              └────┬────┘└───┬────┘└───┬────┘    │
│                   │         │         │          │
│              ┌────▼─────────▼─────────▼────┐    │
│              │     Prometheus + Grafana     │    │
│              │     (메트릭 수집/시각화)       │    │
│              └─────────────────────────────┘    │
│                                                  │
│  Autoscaling: 큐 길이/GPU 활용률 기반             │
│  Health Check: /health 엔드포인트                 │
│  Graceful Shutdown: 진행 중인 요청 완료 후 종료    │
└──────────────────────────────────────────────────┘

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-llama3-70b
spec:
  replicas: 3
  selector:
    matchLabels:
      app: vllm-llama3
  template:
    metadata:
      labels:
        app: vllm-llama3
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        command: ["python", "-m", "vllm.entrypoints.openai.api_server"]
        args:
          - "--model=meta-llama/Llama-3.1-70B-Instruct"
          - "--tensor-parallel-size=4"
          - "--max-model-len=16384"
          - "--gpu-memory-utilization=0.90"
          - "--enable-prefix-caching"
          - "--enable-chunked-prefill"
        resources:
          limits:
            nvidia.com/gpu: "4"
            memory: "64Gi"
          requests:
            nvidia.com/gpu: "4"
            memory: "32Gi"
        ports:
        - containerPort: 8000
        readinessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 120
          periodSeconds: 10
        livenessProbe:
          httpGet:
            path: /health
            port: 8000
          initialDelaySeconds: 180
          periodSeconds: 30
      nodeSelector:
        gpu-type: h100
      tolerations:
      - key: nvidia.com/gpu
        operator: Exists
        effect: NoSchedule