Apple Silicon에서 LLM 서빙하기: M4/M5 칩의 비밀과 한계

전통적인 PC 아키텍처:
┌─────────────────────┐   PCIe x16 (~32 GB/s)   ┌──────────────────────────┐
│ CPU                 │◄──────────────────────►  │ GPU                      │
│ Intel/AMD           │                           │ NVIDIA RTX 4090          │
│ DDR5 64GB           │                           │ GDDR6X 24GB              │
│ 89 GB/s bandwidth   │                           │ 1008 GB/s bandwidth      │
│                     │                           │                          │
│ 추론 중인 모델 조각  │   데이터 복사 필요!        │ 추론 중인 모델 조각        │
└─────────────────────┘                           └──────────────────────────┘

문제점:
- LLM 추론 시 weight는 GPU VRAM에, KV cache는 부분적으로 CPU RAM에 → 복사 오버헤드
- PCIe 대역폭 32 GB/s는 GPU의 VRAM 1TB/s 대비 30배 이상 느림
- 70B 파라미터 모델 (FP16) = ~140GB → 24GB VRAM에 아예 올라가지 않음!

Apple M4 Max (유니파이드 메모리):
┌─────────────────────────────────────────────────────────────────┐
│                    128GB Unified Memory Pool                    │
│                      546 GB/s bandwidth                         │
│                                                                 │
│   ┌────────────┐   ┌──────────────┐   ┌──────────────────────┐ │
│   │   CPU      │   │     GPU      │   │   Neural Engine      │ │
│   │ 14 cores   │   │  40 GPU cores│   │   38 TOPS            │ │
│   │ (4P + 10E) │   │              │   │   INT8/FP16 전용     │ │
│   └────────────┘   └──────────────┘   └──────────────────────┘ │
│                                                                 │
│   모든 프로세서가 동일한 물리적 메모리에 직접 접근!              │
│   복사 없음, 지연 없음, 동기화 오버헤드 없음                    │
└─────────────────────────────────────────────────────────────────┘

모델 크기별 FP16 메모리 요구량:
Llama 3.2 3B   → ~6GB   (M4 Pro 24GB에 쉽게 올라감)
Llama 3.1 8B   → ~16GB  (M4 Pro 24GB에 올라감)
Llama 3.1 70B  → ~140GB (M4 Max 128GB에 Q4 양자화 필요, ~40GB)
Llama 3.1 405B → ~810GB (M4 Ultra 192GB에도 불가, 양자화 필수)

Apple M4 프로세서 내 컴포넌트 역할:
┌────────────────────────────────────────────────────────────────┐
│                       Apple M4 Max                             │
│                                                                │
│  CPU (4P + 10E cores)                                          │
│  - 범용 연산, OS, 애플리케이션 로직                              │
│  - Prefill phase에서 tokenization 담당                          │
│                                                                │
│  GPU (40 cores)                                                │
│  - Metal API로 프로그래밍 가능                                   │
│  - LLM의 행렬 곱, attention 연산 처리                           │
│  - llama.cpp, MLX가 주로 사용                                   │
│                                                                │
│  Neural Engine (38 TOPS)                                       │
│  - CoreML 모델 전용 가속                                         │
│  - INT8/FP16 systolic array MAC 유닛                            │
│  - 직접 프로그래밍 불가! (CUDA 같은 범용 API 없음)               │
│  - Whisper, Face ID, Siri 처리에 사용                           │
│                                                                │
└────────────────────────────────────────────────────────────────┘

Systolic Array (간략화):
입력 행렬 →  [MAC][MAC][MAC][MAC]  → 출력
              ↓    ↓    ↓    ↓
입력 행렬 →  [MAC][MAC][MAC][MAC]
              ↓    ↓    ↓    ↓
입력 행렬 →  [MAC][MAC][MAC][MAC]

각 MAC 유닛: multiply + accumulate를 동시 실행
데이터가 좌→우로 흐르고, weight가 위→아래로 흐르는 패턴

# CoreML로 LLM 변환 (개념적 예시)
import coremltools as ct
import torch

# PyTorch 모델 → CoreML 변환
model = load_llm_model()
traced_model = torch.jit.trace(model, example_input)

# CoreML 변환 시 compute_units 지정
mlmodel = ct.convert(
    traced_model,
    compute_units=ct.ComputeUnit.ALL,  # CPU + GPU + ANE 모두 사용
    # 또는 ct.ComputeUnit.CPU_AND_NE  # CPU + ANE만
    minimum_deployment_target=ct.target.macOS14,
)
mlmodel.save("llm_model.mlpackage")

# PyTorch MPS 백엔드 사용
import torch

# MPS 사용 가능 여부 확인
print(torch.backends.mps.is_available())   # True on Apple Silicon
print(torch.backends.mps.is_built())       # True if compiled with MPS

device = torch.device("mps")

# 모델을 MPS로 이동
model = YourTransformerModel()
model = model.to(device)

# 텐서 연산도 MPS에서 실행
x = torch.randn(1, 512, device=device)
output = model(x)

# 내부적으로 일어나는 일:
# PyTorch → MPS 백엔드 → Metal API → GPU 커널 실행
# CUDA와 달리 커널 코드를 MSL(Metal Shading Language)로 작성

import mlx.core as mx
import mlx.nn as nn

# MLX의 핵심: 지연 평가 (Lazy Evaluation)
a = mx.array([[1.0, 2.0], [3.0, 4.0]])
b = mx.array([[1.0, 0.0], [0.0, 1.0]])

# 이 시점에서는 아직 계산이 일어나지 않음!
c = a @ b        # 계산 그래프만 구성
d = mx.exp(c)    # 추가 연산 그래프 추가
e = d.sum()      # 또 추가

# mx.eval() 호출 시 전체 그래프를 한 번에 최적화하여 실행
mx.eval(e)       # 이 때 실제 GPU 연산이 일어남

print(e)  # [[2.71828...]]

# MLX로 간단한 Transformer attention 구현
import mlx.core as mx
import mlx.nn as nn
import math

class MultiHeadAttention(nn.Module):
    def __init__(self, d_model: int, num_heads: int):
        super().__init__()
        self.num_heads = num_heads
        self.d_head = d_model // num_heads
        self.scale = math.sqrt(self.d_head)

        self.q_proj = nn.Linear(d_model, d_model)
        self.k_proj = nn.Linear(d_model, d_model)
        self.v_proj = nn.Linear(d_model, d_model)
        self.out_proj = nn.Linear(d_model, d_model)

    def __call__(self, x: mx.array, mask=None):
        B, T, C = x.shape

        q = self.q_proj(x).reshape(B, T, self.num_heads, self.d_head).transpose(0, 2, 1, 3)
        k = self.k_proj(x).reshape(B, T, self.num_heads, self.d_head).transpose(0, 2, 1, 3)
        v = self.v_proj(x).reshape(B, T, self.num_heads, self.d_head).transpose(0, 2, 1, 3)

        # Scaled dot-product attention
        scores = (q @ k.transpose(0, 1, 3, 2)) / self.scale

        if mask is not None:
            scores = scores + mask

        weights = mx.softmax(scores, axis=-1)
        out = (weights @ v).transpose(0, 2, 1, 3).reshape(B, T, C)
        return self.out_proj(out)

# llama.cpp 빌드 (Metal 지원)
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
cmake -B build -DLLAMA_METAL=ON
cmake --build build --config Release -j

# M4 Pro에서 Llama 3.1 8B 실행
./build/bin/llama-cli \
  -m models/llama-3.1-8b-q4_k_m.gguf \
  -p "Explain transformer architecture" \
  -n 200 \
  --n-gpu-layers 999  # 모든 레이어를 GPU(Metal)로 오프로드
# 예상 출력: ~45-50 tok/s (M4 Pro 48GB)

# Metal 디버그 정보 확인
GGML_METAL_LOG_LEVEL=1 ./build/bin/llama-cli -m model.gguf ...

# Ollama 설치 및 사용
brew install ollama
ollama serve  # 백그라운드 서버 시작

# 모델별 성능 (M4 Pro 48GB 기준 실측값)
ollama run llama3.2         # 3B, Q4_K_M: ~80-85 tok/s
ollama run llama3.1:8b      # 8B, Q4_K_M: ~45-50 tok/s
ollama run llama3.1:70b     # 70B, Q4_K_M: 메모리 부족 (48GB VRAM 기준)
# llama3.1:70b Q4_K_M = ~40GB → M4 Pro 48GB에서 간신히 가능, ~6-8 tok/s

# M4 Max 128GB에서
ollama run llama3.1:70b     # ~8-10 tok/s
ollama run llama3.3:70b     # ~8-10 tok/s (최신 70B)

# Python에서 Ollama API 사용
import ollama

response = ollama.chat(
    model='llama3.1:8b',
    messages=[{'role': 'user', 'content': 'Hello, explain RLHF'}]
)
print(response['message']['content'])

# Q4_K_M 양자화 과정 (간략화)
import torch

def quantize_q4_k(weight_tensor, block_size=32):
    """
    K-Quants: 블록 단위로 scale과 min 값을 FP16으로 저장
    실제 weight는 4bit integer로 저장
    """
    B, N = weight_tensor.shape
    num_blocks = N // block_size

    quantized_blocks = []
    scales = []
    mins = []

    for i in range(num_blocks):
        block = weight_tensor[:, i*block_size:(i+1)*block_size]

        # 블록별 최솟값과 최댓값 계산
        block_min = block.min(dim=-1, keepdim=True).values
        block_max = block.max(dim=-1, keepdim=True).values

        # 0-15 범위로 정규화 (4bit = 16개 레벨)
        scale = (block_max - block_min) / 15.0
        zero_point = -block_min / scale

        # 4bit 정수로 변환
        q = torch.round((block - block_min) / scale).clamp(0, 15).to(torch.uint8)

        quantized_blocks.append(q)
        scales.append(scale.to(torch.float16))
        mins.append(block_min.to(torch.float16))

    return quantized_blocks, scales, mins

# 역양자화 (추론 시)
def dequantize_q4_k(quantized, scales, mins):
    """4bit integer를 FP16으로 복원"""
    return quantized.float() * scales + mins

# 메모리 절약 계산:
# FP16 70B 모델: 70B * 2 bytes = 140 GB
# Q4_K_M 70B 모델: 70B * 0.5 bytes (approx) + overhead = ~40 GB
# 절약량: ~71%

# llama.cpp 양자화 타입 비교 (M4 Max 128GB, Llama 3.1 70B)
# Q2_K   : ~18GB, 품질 손실 큼, ~12 tok/s
# Q4_0   : ~35GB, 적당한 품질, ~8 tok/s
# Q4_K_M : ~42GB, 좋은 품질, ~8 tok/s (권장)
# Q5_K_M : ~52GB, 매우 좋은 품질, ~6 tok/s
# Q8_0   : ~70GB, 거의 FP16 수준, ~4 tok/s
# FP16   : ~140GB (128GB에 안 올라감!)

# 결론: Q4_K_M이 품질과 속도의 최적 균형점

M4:           10 CPU cores (4P+6E), 10 GPU cores, 38 TOPS ANE, 16-32GB
M4 Pro:       14 CPU cores (10P+4E), 20 GPU cores, 38 TOPS ANE, 24-64GB
M4 Max:       14 CPU cores (10P+4E), 40 GPU cores, 38 TOPS ANE, 48-128GB
M4 Ultra:     28 CPU cores, 80 GPU cores, 76 TOPS ANE, 192GB (M4 Max * 2)
Memory BW:    M4=120GB/s, M4 Pro=273GB/s, M4 Max=546GB/s, M4 Ultra=819GB/s

예상 M5 스펙 (N3P 공정, 2025 후반):
- TSMC 3nm N3P 공정 (M4 N3E 대비 ~15-20% 전력 효율 향상)
- CPU: M5 Pro 기준 20 cores (12P + 8E) 예상
- GPU: M5 Max 기준 50 GPU cores 예상
- Neural Engine: 50+ TOPS 예상
- 메모리: M5 Max 최대 192GB (현재 M4 Max 128GB에서 증가)
- 메모리 대역폭: M5 Max 기준 700+ GB/s 예상 (M4 Max 546 대비 ~30% 증가)

Apple Intelligence 아키텍처 (추측):
User Request
     ↓
On-Device 모델 (3B, ANE 실행)
     ↓ (복잡한 요청만)
Private Cloud Compute (더 큰 모델, Apple Silicon 서버)

# mlx-lm 설치
pip install mlx-lm

# Hugging Face 모델을 MLX 형식으로 변환 후 실행
python -m mlx_lm.convert \
  --hf-path meta-llama/Llama-3.1-8B-Instruct \
  --mlx-path mlx_models/llama-3.1-8b \
  --quantize \
  --q-bits 4  # 4-bit 양자화

# 변환된 MLX 모델 실행
python -m mlx_lm.generate \
  --model mlx_models/llama-3.1-8b \
  --prompt "Explain attention mechanism" \
  --max-tokens 500

# Python에서 MLX-LM 직접 사용
from mlx_lm import load, generate

model, tokenizer = load("mlx-community/Llama-3.1-8B-Instruct-4bit")

prompt = "You are a helpful assistant. Explain what makes Apple Silicon unique for AI inference."

response = generate(
    model,
    tokenizer,
    prompt=prompt,
    max_tokens=500,
    verbose=True,     # 토큰 생성 속도 출력
)

# Apple Silicon 메모리 및 GPU 사용량 확인
# Activity Monitor > Memory 탭 열기, 또는:

# powermetrics로 GPU 활용률 확인 (root 필요)
sudo powermetrics --samplers gpu_power -i 500 -n 5

# asitop (써드파티 툴, pip install asitop)
sudo asitop
# CPU/GPU/ANE 활용률, 메모리 대역폭, 전력 소비를 실시간으로 확인 가능