3장: 모델 최적화 - 양자화, 배칭, KV 캐시 전략

모델 메모리 사용량 계산 (파라미터 수 x 비트 / 8):
 
  Llama-3.1-8B:
    FP16: 8B x 2 bytes = 16 GB
    INT8: 8B x 1 byte  = 8 GB
    INT4: 8B x 0.5 byte = 4 GB
 
  Llama-3.1-70B:
    FP16: 70B x 2 bytes = 140 GB (A100 80GB 2장 필요)
    INT8: 70B x 1 byte  = 70 GB  (A100 80GB 1장 가능)
    INT4: 70B x 0.5 byte = 35 GB (A100 40GB 1장 가능)

from transformers import AutoModelForCausalLM, AutoTokenizer
from auto_gptq import AutoGPTQForCausalLM, BaseQuantizeConfig
 
model_id = "meta-llama/Llama-3.1-8B-Instruct"
quantize_config = BaseQuantizeConfig(
    bits=4,
    group_size=128,
    desc_act=True,
    damp_percent=0.1,
)
 
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoGPTQForCausalLM.from_pretrained(
    model_id,
    quantize_config=quantize_config,
)
 
# 보정 데이터셋 준비
calibration_data = [
    tokenizer(text, return_tensors="pt")
    for text in calibration_texts[:128]
]
 
# 양자화 실행
model.quantize(calibration_data)
 
# 저장
model.save_quantized("./llama-3.1-8b-gptq-4bit")

vllm serve ./llama-3.1-8b-gptq-4bit \
  --quantization gptq \
  --dtype float16 \
  --max-model-len 4096

from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer
 
model_id = "meta-llama/Llama-3.1-8B-Instruct"
 
model = AutoAWQForCausalLM.from_pretrained(model_id)
tokenizer = AutoTokenizer.from_pretrained(model_id)
 
quant_config = {
    "zero_point": True,
    "q_group_size": 128,
    "w_bit": 4,
    "version": "GEMM",
}
 
model.quantize(tokenizer, quant_config=quant_config)
model.save_quantized("./llama-3.1-8b-awq-4bit")

vllm serve ./llama-3.1-8b-awq-4bit \
  --quantization awq \
  --dtype float16 \
  --max-model-len 4096

vllm serve meta-llama/Llama-3.1-70B-Instruct \
  --quantization fp8 \
  --dtype float16 \
  --tensor-parallel-size 2 \
  --max-model-len 8192

양자화 기법 비교표:
 
기법     비트  품질 손실  양자화 속도  추론 속도  하드웨어 요구
------  ----  --------  ----------  --------  -----------
FP16    16    없음       해당 없음    기준선     모든 GPU
FP8     8     매우 적음  빠름        1.3-1.5x  H100+
GPTQ    4     적음       느림(시간)   1.5-2.0x  모든 GPU
AWQ     4     적음       보통(분)     1.5-2.0x  모든 GPU
GGUF    2-8   가변       빠름        가변       CPU/GPU
 
* 추론 속도는 FP16 대비 상대 속도입니다.

정적 배칭 예시 (배치 크기 4):
 
시간 -->
요청1: [####]________________  (4 토큰 생성 후 완료, 16 토큰 동안 대기)
요청2: [############]________  (12 토큰 생성 후 완료, 8 토큰 동안 대기)
요청3: [####################] (20 토큰 생성, 전체 시간 사용)
요청4: [########]____________  (8 토큰 생성 후 완료, 12 토큰 동안 대기)
 
GPU 활용률: (4+12+20+8) / (20*4) = 55%

연속 배칭 예시:
 
시간 -->
슬롯1: [요청1####][요청5######][요청8##########]
슬롯2: [요청2############][요청6########]______
슬롯3: [요청3####################]______________
슬롯4: [요청4########][요청7##############]_____
 
GPU 활용률: 약 85-95%

프리필 vs 디코딩 특성:
 
프리필:
  - 입력 토큰 전체를 병렬 처리
  - GPU 연산 유닛을 집중 사용
  - 배치 크기 증가 시 처리량 선형 증가
 
디코딩:
  - 한 번에 1 토큰 생성
  - KV 캐시 읽기/쓰기가 병목
  - 배치 크기 증가 시 메모리 대역폭이 병목

KV 캐시 메모리 = 2 x 레이어 수 x 헤드 수 x 헤드 차원 x 시퀀스 길이 x 배치 크기 x 바이트
 
Llama-3.1-8B (FP16, 시퀀스 4096, 배치 32):
  = 2 x 32 x 8 x 128 x 4096 x 32 x 2 bytes
  = 약 17 GB
 
Llama-3.1-70B (FP16, 시퀀스 4096, 배치 32):
  = 2 x 80 x 8 x 128 x 4096 x 32 x 2 bytes
  = 약 42 GB

# 보수적 설정 (안정성 우선)
vllm serve model-name --gpu-memory-utilization 0.85
 
# 공격적 설정 (처리량 우선)
vllm serve model-name --gpu-memory-utilization 0.95
 
# 기본값
vllm serve model-name --gpu-memory-utilization 0.90

vllm serve meta-llama/Llama-3.1-8B-Instruct \
  --enable-prefix-caching \
  --max-model-len 8192

프리픽스 캐싱 효과 예시:
 
시스템 프롬프트 1000 토큰인 서비스:
  캐싱 미적용: 프리필 1000 + 사용자 입력 200 = 1200 토큰 처리
  캐싱 적용:   프리필 200 토큰만 처리 (시스템 프롬프트는 캐시 히트)
  TTFT 개선: 약 80% 단축

# 모델 최대 128K이지만, 서비스에서는 8K면 충분한 경우
vllm serve meta-llama/Llama-3.1-8B-Instruct \
  --max-model-len 8192
 
# 메모리 여유를 확보하여 더 많은 동시 요청 처리 가능

python -m vllm.entrypoints.openai.api_server \
  --model meta-llama/Llama-3.1-8B-Instruct &
 
# 벤치마크 실행
python benchmarks/benchmark_serving.py \
  --backend vllm \
  --model meta-llama/Llama-3.1-8B-Instruct \
  --num-prompts 1000 \
  --request-rate 10 \
  --max-concurrency 64

import asyncio
import time
from openai import AsyncOpenAI
 
client = AsyncOpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed",
)
 
async def send_request(prompt, max_tokens=256):
    start = time.perf_counter()
    tokens = []
    first_token_time = None
 
    response = await client.chat.completions.create(
        model="meta-llama/Llama-3.1-8B-Instruct",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=max_tokens,
        stream=True,
    )
 
    async for chunk in response:
        if chunk.choices[0].delta.content:
            if first_token_time is None:
                first_token_time = time.perf_counter() - start
            tokens.append(chunk.choices[0].delta.content)
 
    total_time = time.perf_counter() - start
    return {
        "ttft": first_token_time,
        "total_time": total_time,
        "tokens": len(tokens),
        "tpot": (total_time - first_token_time) / max(len(tokens) - 1, 1),
    }
 
async def benchmark(num_requests=100, concurrency=16):
    prompts = ["Kubernetes의 주요 구성 요소를 설명해주세요."] * num_requests
    semaphore = asyncio.Semaphore(concurrency)
 
    async def limited_request(prompt):
        async with semaphore:
            return await send_request(prompt)
 
    results = await asyncio.gather(
        *[limited_request(p) for p in prompts]
    )
 
    avg_ttft = sum(r["ttft"] for r in results) / len(results)
    avg_tpot = sum(r["tpot"] for r in results) / len(results)
    total_tokens = sum(r["tokens"] for r in results)
    total_time = max(r["total_time"] for r in results)
 
    print(f"평균 TTFT: {avg_ttft*1000:.1f}ms")
    print(f"평균 TPOT: {avg_tpot*1000:.1f}ms")
    print(f"처리량: {total_tokens/total_time:.1f} tokens/s")
 
asyncio.run(benchmark())