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 (シーケンス1つに!)

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]     │
│                                             │
│  Request 1 → ページテーブル: [B0, B3, B5]   │
│  Request 2 → ページテーブル: [B1, B4, B6]   │
│  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,
    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グループ)          │
│    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（大きく正確なモデル）           │
│  1回のforward passで4トークンを同時検証              │
│  [Paris OK] [, OK] [a NG→"known"] [city NG]       │
│                                                    │
│  結果: "Paris, known" (2個受理 + 1個修正)           │
│  従来: 3回のforward pass必要 → 今は1回              │
│  速度向上: 約2-3倍                                  │
└────────────────────────────────────────────────────┘

# 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 ── ...

ツリーのすべてのパスを1回の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アーキテクチャ             │
│                                          │
│  ┌─────────┐     ┌──────────────────┐   │
│  │ 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モデル │────►│チェックポイント│────►│ TRT-LLM  │────►│ Triton   │
│(元モデル)│     │  変換      │     │ 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 / シーケンス (Llama-2 70B, 4K)
# FP8 KV Cache:  0.67 GB / シーケンス (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  token/月    │
│                                                 │
│  損益分岐点: 約10Bトークン/月                      │
└─────────────────────────────────────────────────┘

# 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%の地点

┌──────────────────────────────────────────────────┐
│               本番アーキテクチャ                    │
│                                                  │
│  Client → Load Balancer → API Gateway            │
│                              │                   │
│                    ┌─────────┼─────────┐         │
│                    ▼         ▼         ▼         │
│              ┌─────────┐┌────────┐┌────────┐    │
│              │ vLLM    ││ vLLM   ││ vLLM   │    │
│              │ Pod 1   ││ Pod 2  ││ Pod 3  │    │
│              │ (4xH100)││(4xH100)││(4xH100)│    │
│              └────┬────┘└───┬────┘└───┬────┘    │
│                   │         │         │          │
│              ┌────▼─────────▼─────────▼────┐    │
│              │     Prometheus + Grafana     │    │
│              │    (メトリクス収集/可視化)     │    │
│              └─────────────────────────────┘    │
│                                                  │
│  オートスケーリング: キュー長/GPU活用率基準         │
│  ヘルスチェック: /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