💡 왼쪽 원문을 읽으면서 오른쪽에 따라 써보세요. Tab 키로 힌트를 받을 수 있습니다.

원문 렌더가 준비되기 전까지 텍스트 가이드로 표시합니다.

はじめに

대규모 언어 모델(LLM)의 성능을 높이는 가장 직관적인 방법은 파라미터 수를 늘리는 것이다. 그러나 Dense 모델에서 파라미터 수를 두 배로 늘리면 학습과 추론에 필요한 연산량도 거의 두 배로 증가한다. **Mixture of Experts(MoE)** 아키텍처는 이 문제에 대한 우아한 해법을 제시한다. 모델의 총 파라미터 수는 크게 늘리되, 각 입력 토큰에 대해 전체 파라미터 중 일부만 활성화하여 연산 비용을 일정하게 유지하는 것이다.

이 아이디어는 1991년 Jacobs 등이 제안한 원래 MoE 논문으로 거슬러 올라가지만, 최근 몇 년간 급격한 발전을 이루었다. Google의 **Switch Transformer**(2021)는 단일 전문가 라우팅으로 MoE의 복잡성을 획기적으로 줄였고, Mistral AI의 **Mixtral 8x7B**(2024)는 Top-2 라우팅으로 오픈소스 LLM의 새로운 기준을 세웠으며, **DeepSeek-MoE**(2024)는 세밀한 전문가 분할로 전문가 특화를 극대화했다. 그리고 **DeepSeek-V3**(2024)는 671B 파라미터에 37B만 활성화하는 구조로 최고 수준의 효율을 달성했다.

이 글에서는 MoE 아키텍처의 기본 원리부터 주요 모델들의 설계 차이, 라우팅 메커니즘 비교, 학습/추론 최적화 전략, 운영 시 주의사항, 장애 사례와 프로덕션 체크리스트까지 종합적으로 다룬다.

MoE 아키텍처 기본 원리

게이팅 메커니즘

MoE 레이어의 핵심은 **게이팅 네트워크(Gating Network)** 이다. 입력 토큰 x가 주어지면 게이팅 네트워크는 각 전문가에 대한 확률 분포를 출력한다.

G(x) = \text{softmax}(W_g \cdot x)

여기서 `W_g`는 학습 가능한 게이팅 가중치 행렬이다. 출력 벡터 `G(x)`의 각 요소는 해당 전문가의 선택 확률을 나타낸다.

class GatingNetwork(nn.Module):

"""MoE 기본 게이팅 네트워크"""

def __init__(self, d_model, num_experts, top_k=2):

super().__init__()

self.top_k = top_k

self.gate = nn.Linear(d_model, num_experts, bias=False)

def forward(self, x):

x: (batch_size, seq_len, d_model)

logits = self.gate(x) # (batch_size, seq_len, num_experts)

Top-k 전문가 선택

top_k_logits, top_k_indices = torch.topk(logits, self.top_k, dim=-1)

top_k_gates = F.softmax(top_k_logits, dim=-1)

return top_k_gates, top_k_indices

Sparse Activation

Dense 모델에서는 모든 파라미터가 매 입력마다 활성화되지만, **Sparse MoE**에서는 Top-k 전문가만 활성화된다. N개의 전문가 중 k개만 연산에 참여하므로, 모델 용량은 N배로 늘리면서 연산량은 k배 수준으로 유지할 수 있다.

MoE 레이어의 출력은 선택된 전문가들의 가중 합으로 계산된다.

y = \sum_{i \in \text{Top-k}} G(x)_i \cdot E_i(x)

여기서 `E_i(x)`는 i번째 전문가 네트워크의 출력이다.

class MoELayer(nn.Module):

"""기본 Sparse MoE 레이어"""

def __init__(self, d_model, d_ff, num_experts, top_k=2):

super().__init__()

self.num_experts = num_experts

self.top_k = top_k

self.gate = GatingNetwork(d_model, num_experts, top_k)

각 전문가는 독립적인 FFN

self.experts = nn.ModuleList([

nn.Sequential(

nn.Linear(d_model, d_ff),

nn.GELU(),

nn.Linear(d_ff, d_model)

)

for _ in range(num_experts)

])

def forward(self, x):

B, T, D = x.shape

gates, indices = self.gate(x) # gates: (B,T,k), indices: (B,T,k)

출력 초기화

output = torch.zeros_like(x)

각 전문가별로 배치 처리

for i in range(self.num_experts):

i번째 전문가에 할당된 토큰 마스크

expert_mask = (indices == i).any(dim=-1) # (B, T)

if not expert_mask.any():

continue

해당 토큰 추출 및 전문가 연산

expert_input = x[expert_mask]

expert_output = self.experts[i](expert_input)

게이트 가중치 적용

gate_values = gates[indices == i]

output[expert_mask] += gate_values.unsqueeze(-1) * expert_output

return output

Capacity Factor

각 전문가가 처리할 수 있는 토큰 수의 상한을 **Capacity Factor(CF)** 로 제어한다. 이상적으로 균등 분배 시 각 전문가는 `T / N`개의 토큰을 처리하며, CF를 곱해서 실제 용량을 결정한다.

\text{Expert Capacity} = \text{CF} \times \frac{T}{N}

CF가 1.0이면 완벽한 균등 분배를 가정하고, 실제로는 1.25~1.5를 사용한다. CF가 너무 낮으면 토큰이 드롭(overflow)되고, 너무 높으면 메모리가 낭비된다.

Switch Transformer 분석

단일 전문가 라우팅의 혁신

Google Brain의 **Switch Transformer**(Fedus et al., 2021)는 기존 MoE의 상식을 깨뜨렸다. 기존에는 Top-2 이상의 전문가를 활성화해야 안정적인 학습이 가능하다고 여겨졌으나, Switch Transformer는 **Top-1(단일 전문가)** 라우팅으로도 우수한 성능을 달성할 수 있음을 보였다.

단일 전문가 라우팅의 장점은 세 가지이다.

1. **라우터 연산 감소**: 하나의 전문가만 선택하므로 게이팅 연산이 단순화된다

2. **전문가 용량 효율화**: 각 토큰이 하나의 전문가에만 배정되므로, 동일 Capacity Factor에서 배치 크기를 두 배로 늘릴 수 있다

3. **통신 비용 절감**: 분산 학습 시 토큰을 하나의 전문가 디바이스로만 전송하면 된다

class SwitchRouter(nn.Module):

"""Switch Transformer 라우터 (Top-1)"""

def __init__(self, d_model, num_experts, capacity_factor=1.25):

super().__init__()

self.num_experts = num_experts

self.capacity_factor = capacity_factor

self.gate = nn.Linear(d_model, num_experts, bias=False)

def forward(self, x):

B, T, D = x.shape

게이팅 로짓

logits = self.gate(x) # (B, T, num_experts)

probs = F.softmax(logits, dim=-1)

Top-1 선택

gate_values, expert_indices = probs.max(dim=-1) # (B, T)

전문가 용량 계산

capacity = int(self.capacity_factor * T / self.num_experts)

용량 초과 토큰 드롭 처리

dispatch_mask = torch.zeros(B, T, self.num_experts, dtype=torch.bool)

for i in range(self.num_experts):

expert_mask = (expert_indices == i)

용량 초과 시 초과분 드롭

positions = expert_mask.nonzero(as_tuple=True)

if len(positions[1]) > capacity:

drop_indices = positions[1][capacity:]

expert_mask[positions[0][capacity:], drop_indices] = False

dispatch_mask[:, :, i] = expert_mask

return gate_values, expert_indices, dispatch_mask

로드 밸런싱 손실

Switch Transformer는 전문가 간 부하 불균형을 방지하기 위해 보조 손실(Auxiliary Loss)을 도입한다. 각 전문가에 배정된 토큰의 비율(`f_i`)과 해당 전문가의 평균 라우팅 확률(`P_i`)의 내적으로 정의된다.

L_{\text{balance}} = \alpha \cdot N \sum_{i=1}^{N} f_i \cdot P_i

def load_balancing_loss(gates, expert_indices, num_experts, alpha=0.01):

"""Switch Transformer 로드 밸런싱 보조 손실"""

B, T = expert_indices.shape

f_i: 각 전문가에 배정된 토큰 비율

f = torch.zeros(num_experts, device=gates.device)

for i in range(num_experts):

f[i] = (expert_indices == i).float().sum() / (B * T)

P_i: 각 전문가의 평균 라우팅 확률

probs = F.softmax(gates, dim=-1) # 전체 전문가에 대한 확률

P = probs.mean(dim=[0, 1]) # (num_experts,)

밸런싱 손실

loss = alpha * num_experts * (f * P).sum()

return loss

성능 결과

Switch Transformer는 T5-Base와 동일한 연산량으로 **7배 빠른 사전학습 속도**를 달성했다. 1.6조(1.6T) 파라미터까지 스케일링하면서도 학습 안정성을 유지했으며, 이는 bfloat16 학습과 라우터 z-loss의 도입 덕분이었다.

Mixtral 8x7B 아키텍처

구조 설계

Mistral AI의 **Mixtral 8x7B**(2024)는 오픈소스 MoE 모델의 대표 사례이다. Mistral 7B와 동일한 Transformer 아키텍처를 기반으로, 각 레이어의 FFN 블록을 8개의 전문가로 교체하고 Top-2 라우팅을 적용했다.

핵심 사양은 다음과 같다.

- **총 파라미터**: 46.7B (전문가 파라미터 포함)

- **활성 파라미터**: 12.9B (토큰당 실제 연산에 참여하는 파라미터)

- **전문가 수**: 8개 (각 레이어마다)

- **활성 전문가**: 2개 (Top-2 라우팅)

- **어텐션**: Grouped Query Attention(GQA) 사용

- **컨텍스트 길이**: 32K (Sliding Window Attention 적용)

class MixtralMoELayer(nn.Module):

"""Mixtral 8x7B 스타일 MoE 레이어"""

def __init__(self, d_model=4096, d_ff=14336, num_experts=8, top_k=2):

super().__init__()

self.num_experts = num_experts

self.top_k = top_k

라우터: 선형 게이팅

self.gate = nn.Linear(d_model, num_experts, bias=False)

8개의 독립적인 SwiGLU FFN 전문가

self.experts = nn.ModuleList([

SwiGLUExpert(d_model, d_ff) for _ in range(num_experts)

])

def forward(self, x):

B, T, D = x.shape

x_flat = x.view(-1, D) # (B*T, D)

라우팅 확률 계산

logits = self.gate(x_flat) # (B*T, 8)

weights, indices = torch.topk(logits, self.top_k, dim=-1)

weights = F.softmax(weights, dim=-1) # Top-k 내 정규화

전문가 출력 가중 합산

output = torch.zeros_like(x_flat)

for i in range(self.top_k):

expert_idx = indices[:, i] # (B*T,)

gate_weight = weights[:, i] # (B*T,)

for j in range(self.num_experts):

mask = (expert_idx == j)

if mask.any():

expert_out = self.experts[j](x_flat[mask])

output[mask] += gate_weight[mask].unsqueeze(-1) * expert_out

return output.view(B, T, D)

class SwiGLUExpert(nn.Module):

"""Mixtral에서 사용하는 SwiGLU 기반 FFN 전문가"""

def __init__(self, d_model, d_ff):

super().__init__()

self.w1 = nn.Linear(d_model, d_ff, bias=False)

self.w2 = nn.Linear(d_ff, d_model, bias=False)

self.w3 = nn.Linear(d_model, d_ff, bias=False)

def forward(self, x):

return self.w2(F.silu(self.w1(x)) * self.w3(x))

Top-2 라우팅의 이점

Mixtral이 Top-2를 채택한 이유는 다음과 같다.

- **안정적 학습**: 두 전문가의 출력을 결합하여 gradient가 더 안정적으로 흐른다

- **전문가 활용도**: 단일 전문가 대비 다양한 전문가가 활성화되어 전문가 붕괴 위험이 감소한다

- **성능-효율 균형**: 12.9B 활성 파라미터로 Llama 2 70B 수준의 성능을 달성하면서 추론 속도는 6배 빠르다

DeepSeek-MoE: 세분화된 전문가 분할

핵심 전략

**DeepSeek-MoE**(2024)는 두 가지 핵심 전략으로 전문가 특화를 극대화했다.

**전략 1: 세분화된 전문가 분할(Fine-grained Expert Segmentation)**

기존 MoE가 16개의 대형 전문가에서 Top-2를 선택한다면, DeepSeek-MoE는 같은 총 파라미터를 64개의 소형 전문가로 분할하고 Top-8을 선택한다. 각 전문가의 FFN 중간 차원을 1/4로 줄이고 4배 많은 전문가를 두어, 가능한 전문가 조합의 수를 극적으로 늘린다.

- 16개 중 2개 선택: C(16,2) = 120가지 조합

- 64개 중 8개 선택: C(64,8) = 약 44억 가지 조합

class DeepSeekMoELayer(nn.Module):

"""DeepSeek-MoE 스타일 레이어: 세분화된 전문가 + 공유 전문가"""

def __init__(

self,

d_model=2048,

d_ff=10944,

num_routed_experts=64,

num_shared_experts=2,

top_k=6,

super().__init__()

self.top_k = top_k

세분화된 라우팅 전문가 (작은 FFN)

expert_d_ff = d_ff // 4 # 기존 대비 1/4 크기

self.routed_experts = nn.ModuleList([

SwiGLUExpert(d_model, expert_d_ff)

for _ in range(num_routed_experts)

])

공유 전문가 (항상 활성화)

self.shared_experts = nn.ModuleList([

SwiGLUExpert(d_model, d_ff)

for _ in range(num_shared_experts)

])

라우터

self.gate = nn.Linear(d_model, num_routed_experts, bias=False)

def forward(self, x):

B, T, D = x.shape

x_flat = x.view(-1, D)

공유 전문가 출력 (항상 활성)

shared_out = sum(expert(x_flat) for expert in self.shared_experts)

라우팅 전문가 출력

logits = self.gate(x_flat)

weights, indices = torch.topk(logits, self.top_k, dim=-1)

weights = F.softmax(weights, dim=-1)

routed_out = torch.zeros_like(x_flat)

for i in range(self.top_k):

expert_idx = indices[:, i]

gate_weight = weights[:, i]

for j in range(len(self.routed_experts)):

mask = (expert_idx == j)

if mask.any():

out = self.routed_experts[j](x_flat[mask])

routed_out[mask] += gate_weight[mask].unsqueeze(-1) * out

return (shared_out + routed_out).view(B, T, D)

**전략 2: 공유 전문가 분리(Shared Expert Isolation)**

일부 전문가를 **공유 전문가(Shared Experts)** 로 지정하여 모든 토큰에 대해 항상 활성화한다. 공유 전문가가 공통 지식(일반적 언어 패턴, 구문 구조 등)을 담당하고, 라우팅 전문가는 특화된 지식에 집중할 수 있게 한다. 이로써 라우팅 전문가 간 지식 중복이 줄어들고 전문화 수준이 높아진다.

성능

DeepSeek-MoE 16B는 약 40%의 연산량만으로 Dense 모델인 DeepSeek 7B와 동등한 성능을 달성했다. DeepSeek-MoE 2B는 1.5배 많은 전문가 파라미터와 연산량을 사용하는 GShard 2.9B와 동등한 성능을 보였다.

라우팅 메커니즘 비교

Top-k 라우팅

가장 일반적인 방식으로, 게이팅 네트워크의 상위 k개 전문가를 선택한다.

- **Top-1** (Switch Transformer): 최소 연산, 최대 효율, 학습 불안정 위험

- **Top-2** (Mixtral, GShard): 안정성과 효율의 균형

- **Top-k** (DeepSeek-MoE, k=6~8): 세분화된 전문가와 함께 사용 시 높은 유연성

Expert Choice 라우팅

Google Research(2022)가 제안한 **Expert Choice** 방식은 토큰이 전문가를 선택하는 대신, **전문가가 자신이 처리할 토큰을 선택**한다. 각 전문가가 Top-k 토큰을 고르므로 완벽한 로드 밸런싱이 보장된다.

class ExpertChoiceRouter(nn.Module):

"""Expert Choice 라우팅: 전문가가 토큰을 선택"""

def __init__(self, d_model, num_experts, capacity_factor=1.0):

super().__init__()

self.num_experts = num_experts

self.capacity_factor = capacity_factor

self.gate = nn.Linear(d_model, num_experts, bias=False)

def forward(self, x):

B, T, D = x.shape

x_flat = x.view(-1, D) # (N, D) where N = B*T

N = x_flat.shape[0]

logits = self.gate(x_flat) # (N, num_experts)

scores = F.softmax(logits, dim=0) # 토큰 차원으로 softmax

각 전문가가 처리할 토큰 수

k = int(self.capacity_factor * N / self.num_experts)

전문가별 Top-k 토큰 선택

top_k_scores, top_k_indices = torch.topk(

scores.t(), k, dim=-1

) # (num_experts, k)

return top_k_scores, top_k_indices

Hash 라우팅

학습 가능한 게이팅 대신 **해시 함수**로 토큰을 전문가에 배정하는 방식이다. 라우팅 연산이 없으므로 오버헤드가 제로에 가깝고, 라우팅 불안정 문제가 원천적으로 사라진다. 다만 입력 특성에 맞는 최적 배정이 불가능하므로 성능은 다소 낮다.

MoE 모델 비교표

| ------------- | -------------------- | ----------------------------- | -------------------------- | ------------------- |

| 발표 시점 | 2021.01 | 2024.01 | 2024.01 | 2024.12 |

| 총 파라미터 | 1.6T (최대) | 46.7B | 16.4B | 671B |

| 활성 파라미터 | 가변 | 12.9B | 2.8B | 37B |

| 활성 전문가 | 1 (Top-1) | 2 (Top-2) | 6 (Top-6) | 8 (Top-8) |

| 공유 전문가 | 없음 | 없음 | 있음 (2개) | 있음 (1개) |

학습과 추론 최적화

Expert Parallelism

MoE 모델의 분산 학습에서는 **Expert Parallelism(EP)** 이 핵심이다. 각 전문가를 서로 다른 GPU에 배치하고, All-to-All 통신으로 토큰을 해당 전문가에게 전송한다.

DeepSpeed MoE 설정 예시

deepspeed_config = {

"train_batch_size": 256,

"fp16": {"enabled": True},

"zero_optimization": {"stage": 2},

"moe": {

"enabled": True,

"ep_size": 8, # Expert Parallelism: 8개 GPU에 전문가 분산

"num_experts": 64,

"top_k": 2,

"capacity_factor": 1.25,

"min_capacity": 4,

"use_residual": True, # 잔차 MoE

"moe_param_group": True # 전문가 파라미터 별도 그룹

}

일반적으로 EP와 Data Parallelism(DP)을 결합한다. 예를 들어 64개 GPU에서 EP=8, DP=8로 구성하면, 8개 GPU가 하나의 전문가 그룹을 담당하고 8개 복제본이 데이터를 병렬 처리한다.

로드 밸런싱 전략

학습 안정성을 위한 로드 밸런싱 기법들을 정리한다.

**1. Auxiliary Loss (Switch Transformer)**

기본적인 보조 손실로, 전문가 배정 비율과 라우팅 확률의 곱을 최소화한다. 계수 `alpha`는 0.01~0.1 범위에서 튜닝한다.

**2. Router z-loss (ST-MoE)**

게이팅 로짓의 크기를 페널티화하여 학습 안정성을 높인다. 라우터에 들어가는 큰 로짓 값을 억제하여 부동소수점 반올림 오류를 줄인다.

L_z = \frac{1}{BT} \sum_{b,t} \left(\log \sum_{i=1}^{N} e^{g_{b,t,i}}\right)^2

**3. Auxiliary-Loss-Free (DeepSeek-V3)**

보조 손실을 완전히 제거하고, 각 전문가에 학습 가능한 바이어스 항을 추가하여 라우팅 확률을 동적으로 조정한다. 보조 손실이 모델 성능에 미치는 부정적 영향을 원천적으로 제거한다.

추론 최적화

MoE 모델의 추론에서 가장 큰 도전은 **메모리 사용량**이다. 모든 전문가를 GPU 메모리에 적재해야 하므로, 실제 연산에 참여하지 않는 전문가도 메모리를 차지한다.

주요 최적화 기법들은 다음과 같다.

- **Expert Offloading**: 비활성 전문가를 CPU/NVMe로 이동하고, 필요 시 GPU로 로드한다. 레이턴시가 증가하므로 예측 기반 프리페칭과 결합한다.

- **Expert Quantization**: 비활성 전문가를 INT4/INT8로 양자화하여 메모리 사용량을 줄인다.

- **Expert Pruning**: 사용 빈도가 낮은 전문가를 제거하여 모델 크기를 줄인다.

- **Speculative Expert Loading**: 다음 레이어에서 활성화될 전문가를 예측하여 미리 로드한다.

運用上の注意事項

메모리 관리

MoE 모델은 활성 파라미터 대비 총 파라미터가 훨씬 크므로 메모리 계획에 주의해야 한다. Mixtral 8x7B의 경우 활성 파라미터는 12.9B이지만 전체 46.7B를 GPU에 적재해야 한다. FP16 기준 약 93GB의 GPU 메모리가 필요하며, 이는 단일 A100 80GB로는 부족하다.

Expert Collapse

**Expert Collapse(전문가 붕괴)** 는 MoE 학습에서 가장 흔한 문제이다. 소수의 전문가에 대부분의 토큰이 집중되고 나머지 전문가는 사실상 사용되지 않는 현상이다. 원인과 대책은 다음과 같다.

- **원인**: 초기 학습에서 특정 전문가가 우연히 좋은 성능을 보이면 더 많은 토큰이 배정되고, 더 많은 학습 기회를 얻어 더 강해지는 양의 피드백 루프

- **대책**: 로드 밸런싱 손실 강화, 라우터에 노이즈 추가, Expert Choice 라우팅 사용

라우팅 불안정성

학습 초기에 라우팅 결정이 급격히 변하는 **Routing Instability**가 발생할 수 있다. 이를 방지하기 위해 다음 기법을 사용한다.

- 라우터 학습률을 메인 모델보다 낮게 설정 (보통 0.1배)

- bfloat16을 사용하여 수치적 안정성 확보 (fp16 대비 범위가 넓음)

- Router z-loss를 통한 로짓 크기 제한

- 학습 초기 워밍업 기간 중 라우팅을 균등 분배로 고정

장애 사례와 해결 방안

사례 1: 추론 시 특정 전문가 OOM

**증상**: 특정 배치에서 하나의 전문가에 토큰이 과도하게 집중되어 해당 GPU에서 OOM 발생

**원인**: 입력 데이터의 분포가 학습 데이터와 크게 다를 때, 라우터가 특정 전문가에 편향된 결정을 내림

**해결 방안**:

- Capacity Factor를 설정하여 전문가당 최대 토큰 수 제한

- 추론 시에도 간단한 로드 밸런싱 로직 적용

- 토큰 오버플로 시 드롭 대신 잔차 연결(residual)로 우회

사례 2: 학습 중 Loss 발산

**증상**: 학습 초기 수천 스텝 이후 갑자기 Loss가 발산

**원인**: 라우터의 로짓 값이 지나치게 커져서 softmax 출력이 0 또는 1에 가까워지고, gradient가 폭발

**해결 방안**:

- Router z-loss 적용 (계수 0.001~0.01)

- bfloat16 사용 (fp16 대비 수치 범위가 넓어 오버플로 방지)

- 라우터 가중치 초기화를 작은 값으로 설정

- Gradient clipping 적용 (max norm 1.0)

사례 3: Expert Parallelism 통신 병목

**증상**: GPU 활용률이 낮고 All-to-All 통신에 대부분의 시간 소비

**원인**: 전문가 수 대비 GPU 수가 많아 통신 오버헤드가 연산 시간을 초과

**해결 방안**:

- EP 크기와 전문가 수의 비율 최적화 (전문가 수 / EP 크기 >= 2 권장)

- 통신과 연산 오버랩 기법 사용

- NVLink/NVSwitch가 있는 노드 내에서 EP 구성

プロダクションチェックリスト

MoE 모델을 프로덕션에 배포할 때 확인해야 할 항목들이다.

**메모리 및 인프라**

- 총 파라미터 기준 GPU 메모리 산정 (활성 파라미터가 아닌 전체 모델 크기)

- Expert Parallelism 구성 시 GPU 간 통신 대역폭 확인 (NVLink 필수)

- Capacity Factor 설정 및 토큰 드롭 비율 모니터링

- KV Cache와 전문가 파라미터의 메모리 합산 검증

**학습 안정성**

- 로드 밸런싱 손실 계수 튜닝 (너무 크면 성능 저하, 너무 작으면 붕괴)

- Router z-loss 활성화 여부 확인

- bfloat16 학습 사용 (fp16 대비 학습 안정성 우수)

- 전문가별 토큰 배분 비율 모니터링 대시보드 구성

**추론 최적화**

- Expert Offloading 적용 시 레이턴시 벤치마크

- 배치 크기별 전문가 활성화 패턴 프로파일링

- 특정 전문가 과부하 시 폴백 전략 (드롭 vs 잔차)

- 양자화(INT8/INT4) 적용 후 정확도 검증

**모니터링**

- 전문가별 활성화 빈도 추적 (Expert Collapse 조기 감지)

- 라우팅 엔트로피 모니터링 (낮으면 붕괴, 높으면 랜덤 라우팅)

- GPU별 메모리 사용량 및 연산 부하 불균형 추적

- All-to-All 통신 시간 대 연산 시간 비율 모니터링

参考資料

- Fedus, W., Zoph, B., and Shazeer, N. "Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity." JMLR 23, 2022.

- Jiang, A. Q. et al. "Mixtral of Experts." Mistral AI, 2024.

- Dai, D. et al. "DeepSeekMoE: Towards Ultimate Expert Specialization in Mixture-of-Experts Language Models." ACL, 2024.

- DeepSeek-AI. "DeepSeek-V3 Technical Report." 2024.

- Zhou, Y. et al. "Mixture-of-Experts with Expert Choice Routing." NeurIPS, 2022.

- Zoph, B. et al. "ST-MoE: Designing Stable and Transferable Sparse Expert Models." 2022.

- Shazeer, N. et al. "Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer." ICLR, 2017.

- Jacobs, R. A. et al. "Adaptive Mixtures of Local Experts." Neural Computation, 1991.

おわりに

MoE 아키텍처는 "더 큰 모델을 더 적은 비용으로"라는 LLM 스케일링의 핵심 과제에 대한 가장 실용적인 해법이다. Switch Transformer가 단일 전문가 라우팅의 가능성을 열었고, Mixtral이 오픈소스 생태계에서 MoE의 실용성을 입증했으며, DeepSeek-MoE/V3가 세분화된 전문가 전략으로 효율성의 새로운 기준을 제시했다.

그러나 MoE는 여전히 도전 과제가 남아 있다. 전문가 붕괴와 라우팅 불안정성은 학습 시 지속적인 관리가 필요하고, 총 파라미터 대비 높은 메모리 요구량은 배포 비용을 증가시킨다. Expert Choice 라우팅, Auxiliary-Loss-Free 밸런싱 등의 최신 기법들이 이런 문제를 점진적으로 해결하고 있지만, 완벽한 해답은 아직 나오지 않았다.

향후 MoE의 발전 방향은 다음과 같이 전망된다. 전문가의 동적 생성과 제거, 멀티모달 전문가 특화, 추론 시 적응적 전문가 수 조절, 그리고 하드웨어와 밀접하게 co-design된 MoE 아키텍처가 등장할 것이다. DeepSeek-V3와 같은 모델이 보여준 것처럼, MoE는 이미 최전선 AI 모델의 핵심 구성 요소가 되었으며, 이 추세는 앞으로 더 가속될 것이다.