들어가며: 언어 모델은 왜 비효율적일까?
여러분이 **"알렉산더 대왕"**이라는 단어를 처음 본다고 상상해보세요. 우리 뇌는 즉시 이 정보를 인식하고 관련 지식을 떠올립니다.
하지만 현재의 대규모 언어 모델(LLM)은 이런 간단한 작업을 위해 여러 레이어의 복잡한 계산을 거쳐야 합니다.
💡 비유: 전화번호부에서 번호를 찾는 대신, 매번 숫자를 하나씩 계산해서 맞춰보는 것과 같습니다.
DeepSeek-AI의 최신 연구 Engram은 바로 이 문제를 해결합니다.
논문 정보
- 제목: Conditional Memory via Scalable Lookup: A New Axis of Sparsity for Large Language Models
- 기관: DeepSeek-AI & Peking University
- 발표: 2025년
- 코드: GitHub
GitHub - deepseek-ai/Engram: Conditional Memory via Scalable Lookup: A New Axis of Sparsity for Large Language Models
Conditional Memory via Scalable Lookup: A New Axis of Sparsity for Large Language Models - deepseek-ai/Engram
github.com
핵심 아이디어: 계산과 기억의 분리
언어 모델의 두 가지 임무
언어를 이해하고 생성하는 작업은 크게 두 가지로 나뉩니다:
| 작업 유형 | 예시 | 요구사항 |
| 동적 추론 | "만약 A이고 B라면, C일 것이다" | 복잡한 계산 |
| 정적 지식 | "대한민국의 수도는 서울이다" | 빠른 검색 |
기존 Transformer 모델은 이 두 가지를 모두 계산으로 처리했습니다.
❓ 질문: 정적 지식까지 매번 계산으로 "재구성"하는 건 낭비가 아닐까요?
Engram의 해법: 조건부 메모리
graph LR
A[기존 Transformer] --> B[모든 것을 계산으로 해결]
C[MoE] --> D[조건부 계산<br/>필요한 전문가만 활성화]
E[Engram] --> F[조건부 메모리<br/>정적 지식은 직접 검색]
style E fill:#4CAF50
style F fill:#8BC34A
**MoE(Mixture-of-Experts)**가 "조건부 계산"으로 모델 용량을 확장했다면, Engram은 "조건부 메모리"라는 새로운 축을 추가합니다.
Engram의 작동 원리
1) N-gram 기반 해싱 룩업
Engram은 고전적인 N-gram 모델의 현대화 버전입니다:
# 입력 시퀀스
input_text = "알렉산더 대왕"
# N-gram 추출
bigrams = ["알렉산더", "대왕"]
trigrams = ["알렉산더 대왕"]
# 해시 함수로 인덱스 계산
indices = [hash_function(ngram) for ngram in bigrams + trigrams]
# O(1) 시간에 임베딩 테이블에서 검색
embeddings = [embedding_table[idx] for idx in indices]
# 결합하여 메모리 벡터 생성
memory_vector = concatenate(embeddings)핵심: O(1) 룩업 - 테이블 크기와 관계없이 일정한 시간에 검색 가능!
2) 똑똑한 토크나이저 압축
일반 토크나이저의 문제:
- Apple ≠ apple ≠ ␣apple ≠ APPLE
- 의미는 같지만 다른 토큰으로 취급
Engram의 해결책:
# 정규화 함수 (NFKC + 소문자화)
def normalize_token(token):
token = token.lower()
token = remove_whitespace(token)
token = normalize_unicode(token)
return token
# 압축 맵핑
compression_map = {
'Apple': 'apple',
'␣apple': 'apple',
'APPLE': 'apple',
'ápple': 'apple' # 악센트 제거
}
결과:
- 어휘 크기 23% 감소
- 메모리 활용 효율성 증대
- 의미 밀도 향상
3) 컨텍스트 인식 게이팅
검색된 메모리가 항상 유용한 건 아닙니다. 해시 충돌이나 다의어 문제가 있을 수 있죠.
# 어텐션 기반 게이팅 메커니즘
def context_aware_gating(hidden_state, retrieved_memory):
# Query: 현재 문맥 이해 상태
query = RMSNorm(hidden_state)
# Key/Value: 검색된 메모리
key = W_K @ RMSNorm(retrieved_memory)
value = W_V @ retrieved_memory
# 유사도 계산
similarity = (query @ key.T) / sqrt(d_model)
gate_score = sigmoid(similarity) # 0~1 사이 값
# 문맥과 맞지 않으면 게이트를 닫음
output = gate_score * value
return output동작 방식:
- gate_score ≈ 1: 메모리가 문맥과 잘 맞음 → 활용
- gate_score ≈ 0: 메모리가 문맥과 안 맞음 → 억제
4) 전체 아키텍처
┌─────────────────────────────────────────┐
│ Input: "Alexander the Great" │
└─────────────┬───────────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ Vocabulary Embedding (표준) │
└─────────────┬───────────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ Transformer Block 1 (Attention + MoE) │
└─────────────┬───────────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ Transformer Block 2 + Engram ✨ │
│ ┌─────────────────────────────────┐ │
│ │ 1. N-gram 추출 & 해싱 │ │
│ │ 2. 임베딩 테이블 룩업 │ │
│ │ 3. 컨텍스트 게이팅 │ │
│ │ 4. 백본과 융합 │ │
│ └─────────────────────────────────┘ │
└─────────────┬───────────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ Transformer Blocks 3-14 │
└─────────────┬───────────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ Transformer Block 15 + Engram ✨ │
└─────────────┬───────────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ Transformer Blocks 16-30 │
└─────────────┬───────────────────────────┘
│
▼
┌─────────────────────────────────────────┐
│ Output Logits │
└─────────────────────────────────────────┘놀라운 실험 결과
공정한 비교를 위한 설정
| 모델 | 총 파라미터 | 활성 파라미터 | 전문가 수 | Engram |
| Dense-4B | 4.1B | 3.8B | - | - |
| MoE-27B | 26.7B | 3.8B | 72 | - |
| Engram-27B | 26.7B | 3.8B | 55 | 5.7B |
| Engram-40B | 39.5B | 3.8B | 55 | 18.5B |
중요: 모두 동일한 계산 비용 (3.8B 활성 파라미터, 262B 토큰)!
결과 1: 지식 검색 (예상된 향상)
메모리 모듈이니 당연히 지식 태스크에서 강할 거라 예상했습니다:
| 벤치마크 | MoE-27B | Engram-27B | 향상 |
| MMLU | 57.4 | 60.4 | +3.0 ✅ |
| CMMLU | 57.9 | 61.9 | +4.0 ✅ |
| MMLU-Pro | 28.3 | 30.1 | +1.8 ✅ |
| TriviaQA | 48.8 | 50.7 | +1.9 ✅ |
결과 2: 추론 능력
놀랍게도 추론 태스크에서 훨씬 더 큰 향상을 보였습니다:
| 벤치마크 | MoE-27B | Engram-27B | 향상 |
| BBH | 50.9 | 55.9 | +5.0 🔥 |
| ARC-Challenge | 70.1 | 73.8 | +3.7 🔥 |
| DROP | 55.7 | 59.0 | +3.3 🔥 |
코드/수학도 마찬가지
| 벤치마크 | MoE-27B | Engram-27B | 향상 |
| HumanEval | 37.8 | 40.8 | +3.0 🔥 |
| MATH | 28.3 | 30.7 | +2.4 🔥 |
| GSM8K | 58.4 | 60.6 | +2.2 🔥 |
🤔 의문: 왜 단순한 "메모리"가 복잡한 추론 능력까지 향상시킬까?
결과 3: 긴 컨텍스트 처리 (압도적!)
| 태스크 | MoE-27B | Engram-27B | 향상 |
| Multi-Query NIAH | 84.2 | 97.0 | +12.8 💥 |
| Variable Tracking | 77.0 | 89.0 | +12.0 💥 |
| Common Words Extraction | 73.0 | 99.6 | +26.6 💥 |
학습 곡선 비교
Validation Loss
│
1.81│ ╱╲
│ ╱ ╲ Dense-4B
│ ╱ ╲
1.76│ ╱ ╲___________________
│ ╱ MoE-27B
│╱ ╲
1.71│ ╲____________
│ Engram-27B ✨
1.66│ ╲________
│ Engram-40B ✨
└─────────────────────────────────▶
0 50k 100k 150k 200k 262k
Training Tokens
비밀의 메커니즘: "효과적인 깊이 증가"
연구팀은 LogitLens와 CKA(Centered Kernel Alignment) 분석을 통해 Engram의 작동 원리를 파헤쳤습니다.
발견 1: 빠른 예측 수렴
LogitLens 분석: 각 레이어의 출력을 LM Head로 투영하여 최종 예측과의 차이를 측정
KL Divergence (작을수록 좋음)
│
10 │ MoE ●─────●
│ ╲ ╲
8 │ ● ●
│ ╲ ╲
6 │ ● ●───●
│ ╲ ╲
4 │ ● ●─●
│ Engram ╲ ╲
2 │ ✨──●────●───● ●
│ ╲ ╲ ╲ ╲
0 │ ●────●───●───●───●
└─────────────────────────────▶
0 5 10 15 20 25 30
Layer Index의미: Engram 모델은 초기 레이어에서 KL divergence가 훨씬 빠르게 감소 → 더 빠르게 확신 있는 표현을 생성
발견 2: 레이어 정렬의 이동
CKA 분석: 서로 다른 모델의 레이어 간 표현 유사도 측정
MoE Layers
↑
30 │ ░░░░░░░░░░░░░░░░░░░░░░░░
│ ░░░░░░░░░░░░░░░░░░░░░░░░
25 │ ░░░░░░░░░░░░░░░░░░░░░░░░
│ ░░░░░░░░░░▓▓▓▓▓▓░░░░░░░
20 │ ░░░░░░░▓▓▓▓▓▓▓▓▓▓░░░░░
│ ░░░░▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░
15 │ ░░▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░ ← 대각선이 위로 이동!
│ ▓▓▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░
10 │ ▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░░░
│ ▓▓▓▓▓▓░░░░░░░░░░░░░░░░
5 │ ▓▓░░░░░░░░░░░░░░░░░░░░
│ ░░░░░░░░░░░░░░░░░░░░░░
0 └─────────────────────────▶
0 5 10 15 20 25 30
Engram Layers
▓ = 높은 유사도 ░ = 낮은 유사도
핵심 발견:
Engram Layer 5 ≈ MoE Layer 12
Engram Layer 10 ≈ MoE Layer 18
Engram Layer 15 ≈ MoE Layer 22→ Engram이 "더 깊은" 네트워크처럼 작동!
왜 이런 일이 발생할까?
기존 LLM의 문제점
Input: "Diana, Princess of Wales"
Layer 1-2: "Diana" 토큰 인식
↓ (계산 소비)
Layer 3: "Princess" 추가
↓ (계산 소비)
Layer 4: "Princess of Wales" 조합
↓ (계산 소비)
Layer 5: "of Wales" 정제
↓ (계산 소비)
Layer 6: 최종적으로 "Diana, Princess of Wales" 엔티티 완성
↓
... 이제 진짜 추론 시작 가능문제: 귀중한 레이어를 단순 패턴 조합에 소비 → 추론에 쓸 “유효 깊이”가 줄어듦
Engram의 해결책
Input: "Diana, Princess of Wales"
Layer 1: 표준 어텐션
↓
Layer 2 + Engram:
├─ 백본: 기본 처리
└─ Engram: "Diana, Princess of Wales" 직접 룩업! ⚡
→ 즉시 엔티티 인식 완료
↓
Layer 3-30: 전부 진짜 추론에 사용 가능! 🎯결과
- 초기 레이어 해방
- 모든 깊이를 진짜 추론에 투입
- 효과적인 네트워크 깊이” 증가
💡 핵심 통찰: 이것이 추론 능력이 더 크게 향상된 이유!
어텐션 용량 해방
로컬 의존성을 Engram이 처리하니까:
기존 Attention:
├─ 로컬 패턴 (30%) → "the", "of", "in" 같은 연결
├─ 중거리 의존성 (40%)
└─ 전역 컨텍스트 (30%)
Engram + Attention:
├─ 로컬 패턴 (0%) → Engram이 처리! ✨
├─ 중거리 의존성 (40%)
└─ 전역 컨텍스트 (60%) ← 2배 증가! 🚀그래서 긴 컨텍스트 태스크에서 성능이 압도적으로 상승.
U자형 스케일링 법칙
연구팀의 질문:
💬 “고정된 파라미터 예산이 있을 때, MoE와 Engram에 각각 얼마나 할당해야 할까?”
할당 비율 실험
할당 비율 ρ 정의:
- ρ = 100%: 순수 MoE (모든 비활성 파라미터를 전문가로)
- ρ = 0%: 순수 Engram (모든 비활성 파라미터를 메모리로)
결과: U자형 곡선!
Validation Loss
│
1.745 │ ╱─────╲
│ ╱ ╲
1.735 │ ╱ ╲ Pure MoE (ρ=100%)
│ ╱ ╲
1.725 │ ╱ ╲
│ │ │
1.715 │ │ 최적점 ⭐ │
│ │ ρ≈75-80% │
1.705 │ │ │
│ ╱ ╲
1.695 │ ╱ ╲
└────────────────────────────▶
0% 20 40 60 80 100%
Engram ← ρ → MoE
━━━ 2e20 FLOPs
─ ─ 6e20 FLOPs| 할당 비율 | 특징 | 문제점 |
| ρ = 100% (순수 MoE) | 최대 계산 능력 / 동적 추론 강함 | ❌ 정적 지식을 비효율적으로 계산으로 재구성 |
| ρ = 0% (순수 Engram) | 최대 메모리 용량 / 지식 검색 강함 | ❌ 동적 추론 능력 부족 (메모리로 계산 대체 불가) |
| ρ ≈ 75–80% (최적 혼합) ⭐ | MoE 75% + Engram 25% | ✅ 최적 성능 |
의미: 두 메커니즘이 구조적으로 상호보완적이라는 증거. 단순 합이 아니라 비선형 시너지.
# 수식으로 표현하면
Performance = f(Computation, Memory)
# 단순 합이 아니라 시너지!
Performance != alpha * MoE + beta * Engram
Performance = synergy(MoE, Engram) # 비선형 관계
무한 메모리 실험
두 번째 질문: “계산 비용은 고정하고 메모리만 늘리면?”
실험 설정
- 고정: 3B MoE 백본, 100B 토큰 학습
- 변수: Engram 슬롯 수 (258K → 10M)
결과: 로그-선형 스케일링
Validation Loss
│
1.81 │ ●
│ ╲
1.80 │ ●
│ ╲ OverEncoding (기존 방법)
1.79 │ ●
│ ╲
1.78 │ ●─────●
│ ╲
1.77 │ Engram ✨╲
│ ●
1.76 │ ╲
│ ●
1.75 │ ╲
│ ●
1.74 │ ╲
│ ●
└──────────────────────────▶
10⁵ 10⁶ 10⁷ 10⁸
Embedding Slots (로그 스케일)Loss = a - b × log(Memory_Size)
a ≈ 1.81 (상한)
b ≈ 0.01 (스케일링 계수)
의미
- 예측 가능한 스케일링
- 추가 계산 불필요(FLOPs 고정)
- 같은 메모리로 OverEncoding보다 효율적
시스템 효율성: 현실 세계 배포
⚠️ 이론적으로 좋아도 실전에서 느리면 무용지물.
문제: GPU 메모리 제약
예시: 100B 파라미터 임베딩 테이블
= 100B × 2 bytes (FP16) = 200GB
NVIDIA H100 GPU HBM = 80GB
→ 테이블이 GPU에 안 들어감! 💥
해결책: 결정론적 프리페칭
MoE vs Engram의 근본 차이:
| 단계 | MoE | Engram |
| 1. 입력 | 토큰 시퀀스 | 토큰 시퀀스 |
| 2. 처리 | 여러 레이어 계산 필요 ⏳ | 즉시 N-gram 추출 ⚡ |
| 3. 인덱스 | 은닉 상태 기반 라우팅 → 런타임에만 결정 ❌ | 해시 함수로 인덱스 계산 → 사전 결정 ✅ |
| 4. 로드 | 동적 로드(예측 불가) | 프리페칭 가능 🚀 |
구현 전략
학습 시 (Training)
┌──────────┐ ┌──────────┐ ┌──────────┐
│ GPU 0 │ │ GPU 1 │ │ GPU 2 │
│ │ │ │ │ │
│ Table │ │ Table │ │ Table │
│ Shard 0 │ │ Shard 1 │ │ Shard 2 │
└────┬─────┘ └────┬─────┘ └────┬─────┘
│ │ │
└──────────────┼──────────────┘
│
All-to-All 통신
│
┌─────────▼─────────┐
│ 필요한 임베딩만 │
│ 각 GPU로 수집 │
└───────────────────┘
추론 시 (Inference)
┌─────────────────────────────────────┐
│ Host Memory (DRAM) │
│ 100B Parameter Table (200GB) │
│ │
│ ┌──────────┐ ┌──────────┐ │
│ │ Frequent │ │ Rare │ │
│ │Embeddings│ │Embeddings│ │
│ └─────┬────┘ └────┬─────┘ │
└─────────┼────────────┼─────────────┘
│ │
PCIe │ Async │ PCIe
Fast │ Prefetch │ Slow
│ │
┌─────────▼────────────▼─────────────┐
│ GPU (HBM 80GB) │
│ │
│ Time: T=0 │
│ ┌──────────────┐ │
│ │ Block 1 │ ← 계산 중 │
│ └──────────────┘ │
│ │
│ ┌──────────────┐ │
│ │ Block 2 │ ← 다음 블록 │
│ │ + Engram │ ← 임베딩 프리페치! │
│ └──────────────┘ │
│ │
│ Time: T=1 │
│ ┌──────────────┐ │
│ │ Block 2 │ ← 계산 중 │
│ │ + Engram │ ← 이미 준비됨! ✅ │
│ └──────────────┘ │
└─────────────────────────────────────┘
핵심: Block 1 계산 동안 Block 2 임베딩을 미리 가져옴!실험 결과 (오프로드 + 처리량)
100B 파라미터 테이블을 호스트 DRAM에 오프로드
| 모델 | 기준 처리량 (tok/s) | +Engram 처리량 (tok/s) | 오버헤드 |
| Dense-4B | 9,031.62 | 8,858.28 | 1.9% ✅ |
| Dense-8B | 6,315.52 | 6,140.02 | 2.8% ✅ |
🎉 결론: 100B 파라미터를 추가해도 처리량 감소가 3% 미만
다층 캐시 계층 (Multi-Level Cache)
N-gram은 자연스럽게 Zipfian 분포를 따릅니다:
Frequency
│
10⁶ │ ●
│ ●
10⁵ │ ●●
│ ●●●
10⁴ │ ●●●●
│ ●●●●●●
10³ │ ●●●●●●●●
│ ●●●●●●●●●●●●
10² │ ●●●●●●●●●●●●●●●●●
│ ●●●●●●●●●●●●●●●●●●●●●
10¹ │ ●●●●●●●●●●●●●●●●●●●●●●●●●●●
└─────────────────────────────────▶
1 10 100 1K 10K 100K
N-gram Rank
80%의 접근이 상위 20%의 N-gram에 집중!class MultiLevelCache:
def __init__(self):
self.l1_cache = GPUCache(size="1GB", speed="fast")
self.l2_cache = DRAMCache(size="100GB", speed="medium")
self.l3_storage = SSDStorage(size="1TB", speed="slow")
def get_embedding(self, ngram_id):
# L1 체크 (GPU HBM)
if ngram_id in self.l1_cache:
return self.l1_cache[ngram_id] # ~10ns
# L2 체크 (Host DRAM)
if ngram_id in self.l2_cache:
emb = self.l2_cache[ngram_id] # ~100ns
self.l1_cache.put(ngram_id, emb)
return emb
# L3 로드 (SSD)
emb = self.l3_storage[ngram_id] # ~10μs
self.l2_cache.put(ngram_id, emb)
self.l1_cache.put(ngram_id, emb)
return emb
구조 분석과 설계 선택
어디에 Engram을 넣을까?
레이어 1~12 sweep 실험 결과:
Validation Loss
│
1.83 │●
│ ╲
1.81 │ ●
│ ╲
1.79 │ ●
│ ╲
1.77 │ ╲___⭐ Layer 2 (최적!)
│ ●──●
1.75 │ ╲
│ ●──●
1.73 │ ╲
│ ●──●
└────────────────────────────▶
1 2 3 4 5 6 7 8 9 10 11 12
Layer Index
| 레이어 | 장점 | 단점 |
| Layer 1 (너무 이르게) | 초기에 로컬 패턴 처리 깊이 절약 최대 |
❌ 게이팅 문맥 부족 ❌ 브랜치 분화 미흡 |
| Layer 2 (최적) ⭐ | ✅ 1회 어텐션으로 충분한 문맥 ✅ 여전히 조기 개입 |
- |
| Layer 10+ (너무 늦게) | 풍부한 문맥 정교한 게이팅 |
❌ 이미 깊이를 낭비 ❌ 효과 감소 |
다층 배치의 이점
- 단일 레이어(1.6B 메모리를 Layer 2에만): Loss = 1.770
- 다층 배치(1.6B를 Layer 2 + 6에 분산): Loss = 1.768 (더 좋음)
이유
- Layer 2: 조기 개입 + 로컬 패턴
- Layer 6: 풍부한 문맥 + 정교한 게이팅
추가로 시스템 관점에서 프리페치 윈도우도 확보됨.
중요한 컴포넌트 (Ablation)
Component │ Loss without it │ Impact
────────────────────────┼──────────────────┼────────
Reference (full) │ 1.768 │ -
────────────────────────┼──────────────────┼────────
❌ Multi-branch │ 1.773 (+0.005) │ 🔥 High
❌ Context gating │ 1.778 (+0.010) │ 🔥 High
❌ Token compression │ 1.775 (+0.007) │ 🔥 High
────────────────────────┼──────────────────┼────────
❌ Short conv │ 1.769 (+0.001) │ 💚 Low
❌ 4-gram (add) │ 1.770 (+0.002) │ 💚 Low# ❌ 단일 게이팅
output = gate(hidden) * memory
# ✅ 브랜치별 게이팅
for branch in branches:
output[branch] = gate[branch](hidden[branch]) * memory# ❌ 단순 평균
output = (hidden + memory) / 2
# ✅ 어텐션 기반 게이팅 (개념 표현)
output = attention(hidden, memory) * memory
실제 사례: 게이팅 시각화
영어 예시 1
<bos> Only Alexander the Great could tame the horse Bucephalus.
게이팅 활성화 (빨간색 = 강함):
████ ███ █████
<bos> Only Alexander the Great could tame the horse Bucephalus.
- Alexander + the + Great 조합에서 강하게 활성화
- Engram이 “Alexander the Great” 엔티티를 구문 단위로 인식
영어 예시 2
<bos> By the way, I am a fan of the Milky Way.
게이팅 활성화:
███ ███ ███ █████ ███
<bos> By the way, I am a fan of the Milky Way.
- “By the way” (관용 표현) 강하게 활성화
- “the Milky Way” (엔티티) 강하게 활성화
- 같은 “the Way”라도 문맥에 따라 반응이 달라짐
중국어 예시 1
<bos> 中国四大发明包括：造纸术、指南针、火药和印刷术。
게이팅 활성화:
████████
<bos> 中国四大发明包括：造纸术、指南针、火药和印刷术。
(Four Great Inventions)
중국어 예시 2
<bos> 东汉末年名医张仲景，因其卓越的贡献被后世尊称为'医圣'...
게이팅 활성화:
██████
<bos> 东汉末年名医张仲景，因其卓越的贡献被后世尊称为'医圣'...
(Zhang Zhongjing)
게이팅 점수 분포
Gate Score Distribution
│
100%│ ▁▂
│ ▃▅▇███████▅▃
80%│ ▂▅███████████████▅▂
│ ▃▅██████████████████████▃
60%│ ▂▅██████████████████████████▅▂
│ ▅███████████████████████████████▅
40%│▃███████████████████████████████████▃
│████████████████████████████████████
20%│████████████████████████████████████
│████████████████████████████████████
0%│████████████████████████████████████
└───────────────────────────────────▶
Common Function Entities Idioms
Words Words
낮음 ← Gate Activation → 높음
더 깊은 분석: 민감도 실험
🧪 “Engram을 완전히 꺼버리면 어떻게 될까?”
실험 설정 (Post-hoc Ablation)
- 학습: Engram 포함 정상 학습
- 추론: Engram_output = 0
- 평가: 각 태스크 성능 측정
주의: 학습-추론 불일치로 노이즈 가능 → 극단적인 태스크 중심으로 해석
결과: 기능적 이분법
Retained Performance (%)
│
100%│ 93% 89% 84% 81%
│██ ██ ██ ██ ██
80%│██ ██ ██ ██ ██ 76% 72%
│██ ██ ██ ██ ██ ██ ██
60%│██ ██ ██ ██ ██ ██ ██ 58%
│██ ██ ██ ██ ██ ██ ██ ██
40%│██ ██ ██ ██ ██ ██ ██ ██ 44% 44% 29%
│██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
20%│██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
│██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██
0%└──┴───┴────┴────┴────┴────┴────┴────┴────┴────┴─────────
C3 RACE DROP ARC- Hella BBH MMLU Human MATH Trivia PopQA
Mid Chal Swag Eval QA
독해 상식추론 지식추론 코드/수학 사실지식
────────────────────────────────────────────────▶
높은 보존 낮은 보존
| 태스크 유형 | 보존율 | 해석 |
| 독해 (C3, RACE) | 81–93% ✅ | 문맥이 주어져 백본 어텐션으로 충분, Engram은 보조 |
| 상식 추론 (HellaSwag, ARC) | 75–85% | 일부 상식 필요, Engram이 추가 향상 |
| 지식 추론 (BBH, MMLU) | 58–78% ⚠️ | 지식+추론 혼합, Engram 역할 증가 |
| 코드/수학 (HumanEval, MATH) | 62–76% ⚠️ | 공식/패턴 기억에 기여, 논리는 백본도 수행 |
| 사실 지식 (TriviaQA, PopQA) | 29–44% ❌ | Engram이 주 저장소, 백본만으론 부족 |
핵심 통찰: Engram의 이중 역할
- 주 저장소(Primary Storage): 사실 지식 질문은 Engram 의존도 매우 큼
- 보조 증폭기(Auxiliary Amplifier): 독해/추론은 백본이 충분하되 Engram이 추가 향상
실무 적용 가이드
언제 Engram을 사용해야 할까? (권장)
| 상황 | 이유 | 예상 효과 |
| 지식 집약 도메인(의료/법률/과학) | 사실 지식 저장 필요 | MMLU +3~4점 |
| 긴 컨텍스트(32k+ 토큰) | 어텐션 용량 해방 | NIAH +13점 수준 |
| 제한된 GPU + 풍부한 호스트 메모리 | 오프로딩 효율 | 오버헤드 <3% |
| 프로덕션(낮은 지연 중요) | 결정론적 프리페칭 가능 | 예측 가능한 성능 |
| 다국어 모델 | 언어별 패턴 저장 | 언어 전반 개선 |
주의 상황
| 상황 | 이유 | 대안 |
| 극소형 모델(<1B) | 오버헤드가 상대적으로 큼 | 순수 Dense/MoE |
| 느린 메모리(네트워크 저장소) | 지연 증가 | 로컬 DRAM/SSD 필요 |
| 즉시 배포(추가 학습 불가) | 처음부터 학습 필요 | 사전학습 모델 사용 |
| 실시간 업데이트가 핵심 | 정적 메모리 한계 | 비파라메트릭 메모리(RAG류) |
구현 체크리스트
단계 1: 아키텍처 설계
# 1. 백본 선택
backbone = "MoE" # 또는 Dense
num_experts = 72
active_experts = 6
# 2. 할당 비율 결정
allocation_ratio = 0.75 # MoE 75%, Engram 25%
# 3. Engram 크기 계산 (개념 예시)
total_params = 27e9
active_params = 3.8e9
sparse_params = total_params - active_params
moe_params = sparse_params * allocation_ratio
engram_params = sparse_params * (1 - allocation_ratio)
print(f"MoE experts: {int(num_experts * allocation_ratio)}")
print(f"Engram params: {engram_params / 1e9:.1f}B")
예시 출력:
MoE experts: 54
Engram params: 5.7B
단계 2: Engram 설정
engram_config = {
# N-gram 설정
"ngram_orders": [2, 3], # 2-gram, 3-gram
"num_heads": 8, # 멀티헤드 해싱
# 임베딩 설정
"embedding_dim": 1280, # 백본 dim의 50%
"vocab_compression": True, # 토크나이저 압축
# 레이어 배치
"layers": [2, 15], # 조기 + 중기
# 통합 방식
"integration": "multi_branch", # mHC
"conv_kernel": 4,
"conv_dilation": 3,
# 학습 설정
"optimizer": "adam", # 임베딩은 Adam
"lr_multiplier": 5.0, # 백본의 5배 LR
"weight_decay": 0.0 # 임베딩 decay 없음
}
단계 3: 시스템 최적화
# 학습 시
training_config = {
"sharding": "expert_parallel + engram_parallel",
"communication": "all_to_all",
"gradient_accumulation": True
}
# 추론 시
inference_config = {
"offloading": {
"enabled": True,
"target": "host_memory",
"prefetch_layers": 1 # 1레이어 앞서 프리페치
},
"caching": {
"l1_gpu": "1GB",
"l2_dram": "100GB",
"l3_ssd": "1TB"
},
"batch_optimization": {
"batch_size": 32,
"sequence_length": 4096
}
}
성능 벤치마킹(측정 항목)
metrics = {
# 모델 품질
"perplexity": measure_ppl(model, test_data),
"downstream_tasks": evaluate_benchmarks(model),
# 시스템 효율
"throughput_tokens_per_sec": measure_throughput(model),
"latency_p50_ms": measure_latency(model, percentile=50),
"latency_p99_ms": measure_latency(model, percentile=99),
# 메모리
"gpu_memory_peak_gb": measure_peak_memory(model),
"host_memory_used_gb": measure_host_memory(model),
# 통신
"prefetch_hit_rate": measure_cache_hits(model),
"communication_overhead_pct": measure_comm_overhead(model)
}
목표 벤치마크
Target Performance:
✅ Perplexity: ≤ MoE baseline
✅ MMLU: +2~4 points
✅ BBH: +3~5 points
✅ Throughput degradation: <5%
✅ P99 latency increase: <10%
✅ Prefetch hit rate: >90%
일반적인 문제 해결
문제 1: 성능 향상 미미
# 체크리스트
checks = {
"할당 비율": "ρ가 최적값(75-80%)인가?",
"레이어 배치": "너무 깊거나 얕지 않은가?",
"학습률": "임베딩 LR이 충분히 높은가? (5x)",
"토크나이저": "압축이 활성화되었는가?",
"게이팅": "Context-aware 게이팅 사용하는가?"
}
# 예시 해결
if allocation_ratio > 0.9:
allocation_ratio = 0.75 # MoE 과다
layers = [2, 15] # 너무 깊으면 조정 (예시)
문제 2: 추론 속도 느림
# 예시 해결
config.prefetch = True
config.prefetch_layers = 1
l1_cache_size = "1GB"
batch_size = 32
문제 3: 메모리 부족 (CUDA OOM)
# 예시 해결
offloading_enabled = True
offload_target = "host_memory"
precision = "fp16" # 또는 fp8
gradient_accumulation_steps = 4결론: 패러다임의 전환
Engram은 단순 “성능 개선 트릭”이 아니라, 모델링 패러다임의 축을 하나 더 여는 접근처럼 보입니다.
핵심 통찰
1) 구조적 분리의 힘
Language Modeling
│
├─ 동적 추론 → MoE (조건부 계산)
│ • 논리적 사고
│ • 맥락 이해
│ • 창의적 생성
│
└─ 정적 지식 → Engram (조건부 메모리) ✨
• 사실 기억
• 패턴 인식
• 엔티티 검색
2) 예상 밖의 시너지
기대: Engram → 지식 +3점
현실: Engram → 지식 +3점, 추론 +5점! 🤯
정적 지식 오프로드
↓
초기 레이어 해방
↓
효과적인 깊이 증가
↓
추론 능력 향상
3) 스케일링 법칙
- U자형 최적 배분: MoE 75–80% / Engram 20–25%
- 로그-선형 메모리 확장: 메모리 증가가 예측 가능한 성능 향상으로 이어짐
4) 시스템 설계의 중요성
- 프리페칭, 오프로딩, 다층 캐시가 있어야 “좋은 아이디어”가 “빠른 제품”이 됨
공식 리소스
'AI > LLM' 카테고리의 다른 글
| 대규모 코드베이스를 정복하는 AI 코딩 에이전트: Confucius Code Agent 깊이 파헤치기 (0) | 2026.01.13 |
|---|---|
| NVIDIA Nemotron Speech Streaming ASR (0) | 2026.01.12 |
| Effective harnesses for long-running agents (0) | 2025.12.03 |
| Apollo-1: The Neuro-Symbolic Foundation Model that Solves Task-Oriented Conversational AI (2) | 2025.11.12 |
| LLM도 '브레인 롯(Brain Rot)'에 걸릴 수 있을까? (0) | 2025.10.20 |