[일반] (딸깍) 롱컨텍, 장기기억 연구가 어려운 이유

# Long-Context 모델을 이해하고 싶다고?

## (Mamba, Titans, Hope 의존성 지옥 가이드)

> "Attention이 O(n²)이라 느리대요. 그래서 대안을 찾아봤는데..." → 지옥문 오픈

---

## 0. 먼저 현실 체크

당신이 원하는 것:

```

"Mamba랑 Titans 같은 거 대충 어떻게 돌아가는지 알고 싶어요"

"Attention 대체한다는데 원리가 뭔지 궁금해요"

```

당신이 마주할 것:

```

Long-Context 모델

│

├── Mamba (State Space Model 계열)

│ ├── SSM 이론

│ │ ├── 제어이론

│ │ ├── 신호처리

│ │ └── 복소해석학

│ ├── 선택적 메커니즘

│ │ └── 정보이론

│ └── 하드웨어 최적화

│ └── CUDA 커널 프로그래밍

│ └── GPU 아키텍처

│ └── 컴퓨터 구조

│ └── (여기서부터 전자공학)

│

├── Titans (메모리 모듈 계열)

│ ├── Neural Memory

│ │ └── Hopfield Networks

│ │ └── 통계물리학

│ ├── Surprise Metric

│ │ └── 정보이론 (또 등장)

│ └── Test-Time Learning

│ └── Meta-Learning

│ └── 최적화 이론의 심연

│

└── Hope (자기수정 네트워크)

├── Nested Learning

│ └── Higher-Order Optimization

│ └── 암묵적 미분

│ └── 함수해석학

└── Causal Memory

└── 인과추론

└── 철학 (진지)

예상 소요 시간: 언제 끝나나요? (대답 거부)

```

---

## 1. 왜 이 지옥에 들어왔는가: Attention의 문제

### Attention이 뭐가 문제인데?

```

"Attention은 O(n²)이야"

│

└─→ "n이 뭔데?"

│

└─→ "시퀀스 길이"

│

└─→ "그래서 뭐가 문제인데?"

│

└─→ "길이가 2배면 비용이 4배"

│

└─→ "10만 토큰 넣으면?"

│

└─→ "100억 번 연산"

│

└─→ "GPU 메모리 폭발"

│

└─→ "그래서 대안을 찾아야 해"

│

└─→ 여기서 지옥 시작

```

### 대안들의 계보

```

"O(n²) 대신 O(n) 하고 싶어"

│

├─→ Sparse Attention (일부만 보자)

│ │

│ └─→ "어떤 걸 봐야 하는데?"

│ │

│ └─→ "그걸 알면 이미 Attention 안 해도 됨"

│ │

│ └─→ 【모순】

│ │

│ └─→ 그래도 휴리스틱으로 함 (도망)

│

├─→ Linear Attention (커널 트릭)

│ │

│ └─→ "Softmax를 근사하면..."

│ │

│ └─→ "왜 정확히 안 되는 건데?"

│ │

│ └─→ 【커널 방법론】

│ │

│ └─→ RKHS

│ │

│ └─→ 【함수해석학】

│ │

│ └─→ 여기서 한 학기

│

├─→ State Space Models (Mamba)

│ │

│ └─→ "순환 구조로 압축하자"

│ │

│ └─→ 아래에서 자세히 (공포)

│

└─→ Memory Systems (Titans, Hope)

│

└─→ "메모리에 저장하자"

│

└─→ 더 아래에서 (더 공포)

```

---

## 2. Mamba를 이해하고 싶다고?

### 전체 의존성 트리

```

"Mamba가 뭐야?"

│

├─→ "Selective State Space Model이야"

│ │

│ ├─→ "State Space Model이 뭔데?"

│ │ │

│ │ └─→ "연속 시스템을 이산화한 순환 모델이야"

│ │ │

│ │ ├─→ "연속 시스템?"

│ │ │ │

│ │ │ └─→ "dx/dt = Ax + Bu, y = Cx + Du"

│ │ │ │

│ │ │ └─→ "이게 뭔 소리야?"

│ │ │ │

│ │ │ └─→ 【제어이론】

│ │ │ │

│ │ │ ├─→ 상태 공간 표현

│ │ │ ├─→ 전달 함수

│ │ │ ├─→ 안정성 분석

│ │ │ └─→ 전자공학과 3학년 (반갑습니다)

│ │ │

│ │ ├─→ "이산화는 어떻게?"

│ │ │ │

│ │ │ └─→ "여러 방법이 있어"

│ │ │ │

│ │ │ ├─→ Zero-Order Hold (ZOH)

│ │ │ │ │

│ │ │ │ └─→ "적분해서 유도"

│ │ │ │ │

│ │ │ │ └─→ 【행렬 지수함수】

│ │ │ │ │

│ │ │ │ └─→ e^{At} = Σ(At)^n/n!

│ │ │ │ │

│ │ │ │ └─→ "무한급수가 수렴해?"

│ │ │ │ │

│ │ │ │ └─→ 【해석학】

│ │ │ │ │

│ │ │ │ └─→ 여기서 2주

│ │ │ │

│ │ │ ├─→ Bilinear Transform

│ │ │ │ │

│ │ │ │ └─→ "s = 2/Δ · (z-1)/(z+1)"

│ │ │ │ │

│ │ │ │ └─→ "z가 뭔데?"

│ │ │ │ │

│ │ │ │ └─→ 【Z-변환】

│ │ │ │ │

│ │ │ │ └─→ 【신호처리】

│ │ │ │ │

│ │ │ │ ├─→ 라플라스 변환

│ │ │ │ ├─→ 푸리에 변환

│ │ │ │ └─→ 전자공학과 2학년 (또 만났네요)

│ │ │ │

│ │ │ └─→ "어떤 걸 써야 해?"

│ │ │ │

│ │ │ └─→ "상황 봐서" (무책임한 답변)

│ │ │

│ │ └─→ "순환 구조가 왜 좋은 건데?"

│ │ │

│ │ └─→ "h_t = Āh_{t-1} + Bx_t 이니까"

│ │ │

│ │ └─→ "이게 왜 O(n)인데?"

│ │ │

│ │ └─→ "각 스텝이 이전 상태만 참조하니까"

│ │ │

│ │ └─→ "아 RNN이랑 비슷한 거?"

│ │ │

│ │ └─→ "개념은 비슷한데 병렬화가 됨"

│ │ │

│ │ └─→ "어떻게?"

│ │ │

│ │ └─→ 【Parallel Scan】

│ │ │

│ │ └─→ 아래에서 계속

│ │

│ └─→ "Selective가 뭔데?"

│ │

│ └─→ "입력에 따라 파라미터가 바뀌는 거야"

│ │

│ ├─→ "뭐가 바뀌는데?"

│ │ │

│ │ └─→ "B, C, Δ가 입력의 함수야"

│ │ │

│ │ └─→ "Δ가 뭔데?"

│ │ │

│ │ └─→ "이산화 스텝 크기"

│ │ │

│ │ └─→ "그게 왜 입력에 따라 바뀌어야 해?"

│ │ │

│ │ └─→ "중요한 건 천천히, 안 중요한 건 빨리 지나가려고"

│ │ │

│ │ └─→ "그게 되는 이유?"

│ │ │

│ │ └─→ "Δ가 크면 이전 상태 영향↓, 현재 입력 영향↑"

│ │ │

│ │ └─→ "수학적으로 보여줘"

│ │ │

│ │ └─→ Ā = exp(ΔA), 큰 Δ → Ā → 0

│ │ │

│ │ └─→ 【행렬 지수함수】 또 등장

│ │

│ └─→ "왜 이게 중요한데?"

│ │

│ └─→ "LTI vs LTV"

│ │

│ ├─→ "LTI (Linear Time-Invariant)"

│ │ │

│ │ └─→ "파라미터가 고정"

│ │ │

│ │ └─→ "컨볼루션으로 계산 가능"

│ │ │

│ │ └─→ "FFT로 O(n log n)"

│ │ │

│ │ └─→ 【푸리에 변환】

│ │ │

│ │ └─→ 드디어 익숙한 게 나왔다!!! (감동)

│ │ │

│ │ └─→ 근데 Mamba는 이거 안 씀

│ │ │

│ │ └─→ ??? (시간 낭비였나?)

│ │

│ └─→ "LTV (Linear Time-Varying)"

│ │

│ └─→ "파라미터가 시간에 따라 변함"

│ │

│ └─→ "컨볼루션 안 됨"

│ │

│ └─→ "그럼 어떻게 빠르게 계산해?"

│ │

│ └─→ 【Parallel Scan】 ← 여기가 핵심

│ │

│ └─→ 아래에서...

│

├─→ 【Parallel Scan (Selective Scan)】 ← Mamba의 진짜 비밀

│ │

│ └─→ "순환인데 병렬화가 된다?"

│ │

│ └─→ "Associative Operation이면 됨"

│ │

│ └─→ "Associative가 뭔데?"

│ │ │

│ │ └─→ "(a ⊕ b) ⊕ c = a ⊕ (b ⊕ c)"

│ │ │

│ │ └─→ 【대수학】 결합법칙

│ │ │

│ │ └─→ 드디어 고등학교 수학!!! (축하)

│ │

│ └─→ "SSM 업데이트가 Associative해?"

│ │

│ └─→ "행렬로 표현하면 됨"

│ │

│ └─→ [h_t] [Ā Bx_t] [h_{t-1}]

│ │ [1 ] = [0 1 ] [1 ]

│ │

│ └─→ "행렬곱은 Associative하니까"

│ │

│ └─→ "Prefix Sum처럼 병렬 계산 가능"

│ │

│ └─→ "work O(n), span O(log n)"

│ │

│ └─→ 【병렬 알고리즘】

│ │

│ └─→ GPU 프로그래밍

│ │

│ └─→ CUDA

│ │

│ └─→ 여기서 또 한 달

│

├─→ 【HiPPO】 장기 기억의 비밀

│ │

│ └─→ "SSM이 장기 기억을 잘 하는 이유?"

│ │

│ └─→ "A 행렬 초기화가 특별해"

│ │

│ └─→ "HiPPO 행렬이 뭔데?"

│ │

│ └─→ "과거를 직교 다항식으로 압축"

│ │

│ ├─→ "직교 다항식?"

│ │ │

│ │ └─→ 【함수해석학】

│ │ │

│ │ ├─→ 르장드르 다항식

│ │ ├─→ 라게르 다항식

│ │ ├─→ 체비셰프 다항식

│ │ └─→ 왜 이름이 다 프랑스어임?

│ │ │

│ │ └─→ (역사적 이유)

│ │

│ └─→ "왜 직교 다항식으로 압축하면 좋은데?"

│ │

│ └─→ "최적의 근사를 보장하거든"

│ │

│ └─→ 【근사이론】

│ │

│ └─→ 바이어슈트라스 정리

│ │

│ └─→ 연속함수는 다항식으로...

│ │

│ └─→ 여기서 2주 (최소)

│

└─→ 【하드웨어 최적화】 실제로 빠르게 만들기

│

└─→ "이론상 O(n)인데 실제로 빠른가?"

│

└─→ "커널 퓨전 필수"

│

└─→ "커널 퓨전이 뭔데?"

│

└─→ "여러 연산을 하나의 CUDA 커널로"

│

└─→ "왜 그래야 하는데?"

│

└─→ "메모리 대역폭 병목"

│

└─→ 【GPU 아키텍처】

│

├─→ SRAM vs HBM

├─→ Memory Hierarchy

├─→ Warp Scheduling

└─→ 여기서부터 하드웨어 엔지니어

│

└─→ (분야 변경?)

```

### Mamba 요약 (여기까지 살아남았다면)

```

Mamba = SSM + Selection + Parallel Scan + HiPPO + CUDA 마법

= 제어이론 + 정보이론 + 병렬알고리즘 + 함수해석학 + GPU 프로그래밍

= ??? (혼란)

```

---

## 3. Titans를 이해하고 싶다고?

### 전체 의존성 트리

```

"Titans가 뭐야?"

│

├─→ "Attention + Neural Memory를 결합한 거야"

│ │

│ ├─→ "Neural Memory가 뭔데?"

│ │ │

│ │ └─→ "학습 가능한 메모리 모듈이야"

│ │ │

│ │ └─→ "그게 뭔 소리야?"

│ │ │

│ │ └─→ "테스트 타임에 메모리를 업데이트해"

│ │ │

│ │ ├─→ "테스트 타임에 학습을?"

│ │ │ │

│ │ │ └─→ "응, Test-Time Training이야"

│ │ │ │

│ │ │ └─→ 【Meta-Learning의 세계】 ← 여기서 분기

│ │ │ │

│ │ │ ├─→ MAML

│ │ │ │ │

│ │ │ │ └─→ "학습하는 법을 학습"

│ │ │ │ │

│ │ │ │ └─→ "이중 최적화"

│ │ │ │ │

│ │ │ │ └─→ 【Bilevel Optimization】

│ │ │ │ │

│ │ │ │ └─→ 여기서 한 달

│ │ │ │

│ │ │ └─→ In-Context Learning

│ │ │ │

│ │ │ └─→ "왜 되는지 아무도 모름 (진지)"

│ │ │ │

│ │ │ └─→ 【미해결 문제】

│ │ │

│ │ └─→ "메모리를 어떻게 업데이트해?"

│ │ │

│ │ └─→ "Gradient Descent로"

│ │ │

│ │ └─→ "추론 중에 Gradient를?"

│ │ │

│ │ └─→ "그래서 느리지 않냐고?"

│ │ │

│ │ └─→ "Mini-batch SGD 1스텝만"

│ │ │

│ │ └─→ "그래도 느린데?"

│ │ │

│ │ └─→ "그래서 효율적인 방법 찾아야..."

│ │ │

│ │ └─→ (연구 진행 중)

│ │

│ └─→ "왜 Attention이랑 같이 쓰는 건데?"

│ │

│ └─→ "Short-term은 Attention, Long-term은 Memory"

│ │

│ └─→ "왜 그렇게 나누는 게 좋은데?"

│ │

│ └─→ "인간 기억 시스템이랑 비슷하거든"

│ │

│ └─→ 【인지과학】 갑자기 등장

│ │

│ ├─→ Working Memory vs Long-term Memory

│ ├─→ Atkinson-Shiffrin Model

│ └─→ 심리학 개론 (반가워요)

│

├─→ 【Neural Memory 상세】 ← 핵심

│ │

│ └─→ "메모리가 정확히 뭐야?"

│ │

│ └─→ "학습 가능한 파라미터 M ∈ R^{d×k}"

│ │

│ ├─→ "어떻게 읽어?"

│ │ │

│ │ └─→ "Query로 Attention"

│ │ │

│ │ └─→ 여기서 Attention 다시 등장

│ │ │

│ │ └─→ 【무한 루프 시작】

│ │

│ ├─→ "어떻게 써?"

│ │ │

│ │ └─→ "Surprise 기반으로 업데이트"

│ │ │

│ │ └─→ "Surprise가 뭔데?"

│ │ │

│ │ └─→ "-log p(x), 정보량이야"

│ │ │

│ │ └─→ 【정보이론】 다시 등장

│ │ │

│ │ ├─→ Self-Information

│ │ ├─→ Entropy

│ │ └─→ KL Divergence

│ │ │

│ │ └─→ 여기서 2주

│ │

│ └─→ "왜 Surprise로 업데이트?"

│ │

│ └─→ "놀라운 건 기억해야 하니까"

│ │

│ └─→ "직관적이네"

│ │

│ └─→ 드디어 말이 되는 게 나왔다!!! (감동)

│

├─→ 【Modern Hopfield Networks 연결】

│ │

│ └─→ "Neural Memory가 Hopfield Network랑 관련 있어?"

│ │

│ └─→ "Associative Memory 관점에서 비슷해"

│ │

│ └─→ "Hopfield Network가 뭔데?"

│ │

│ └─→ "에너지 기반 연상 기억 모델이야"

│ │

│ └─→ 【통계물리학】 갑자기 등장

│ │

│ ├─→ 에너지 함수

│ │ │

│ │ └─→ E = -Σ w_ij s_i s_j

│ │ │

│ │ └─→ "이게 Ising Model 아냐?"

│ │ │

│ │ └─→ "맞아"

│ │ │

│ │ └─→ 【통계역학】

│ │ │

│ │ └─→ 물리학과 인사하세요

│ │

│ ├─→ Associative Memory

│ │ │

│ │ └─→ "패턴 저장하고 불러오기"

│ │ │

│ │ └─→ "몇 개나 저장 가능?"

│ │ │

│ │ └─→ "0.14N개 (Classic)"

│ │ │

│ │ └─→ "Modern Hopfield은 exp(N)개"

│ │ │

│ │ └─→ "어떻게?"

│ │ │

│ │ └─→ "에너지 함수 바꾸면"

│ │ │

│ │ └─→ 【Ramsauer et al. 2020】

│ │ │

│ │ └─→ "이게 Attention이랑 같다?"

│ │ │

│ │ └─→ "응"

│ │ │

│ │ └─→ 연결고리 발견!!! (감동)

│ │

│ └─→ 근데 Titans는 다른 방식 씀

│ │

│ └─→ (시간 낭비였나? 아니긴 한데...)

│

├─→ 【Memory Integration 방식】

│ │

│ └─→ "메모리를 어떻게 Transformer에 붙여?"

│ │

│ ├─→ "MAC (Memory as Context)"

│ │ │

│ │ └─→ "메모리 읽은 걸 컨텍스트에 붙여"

│ │ │

│ │ └─→ "그럼 시퀀스가 길어지잖아?"

│ │ │

│ │ └─→ "그래서 메모리 크기 제한 필요"

│ │ │

│ │ └─→ (trade-off)

│ │

│ ├─→ "MAG (Memory as Gate)"

│ │ │

│ │ └─→ "메모리로 Attention을 조절"

│ │ │

│ │ └─→ "Gating이 뭔데?"

│ │ │

│ │ └─→ "σ(x) ⊙ y 형태"

│ │ │

│ │ └─→ "LSTM의 Gate랑 비슷?"

│ │ │

│ │ └─→ "응"

│ │ │

│ │ └─→ 【LSTM】 다시 등장

│ │ │

│ │ └─→ 1997년 논문

│ │ │

│ │ └─→ 원조 장기 기억 (감동)

│ │

│ └─→ "MAL (Memory as Layer)"

│ │

│ └─→ "별도 레이어로 메모리 처리"

│ │

│ └─→ "가장 깔끔한 분리"

│ │

│ └─→ "성능은?"

│ │

│ └─→ "실험해봐야 함"

│ │

│ └─→ (또 실험)

│

└─→ 【Persistent Memory vs Contextual Memory】

│

└─→ "Task-level vs Instance-level 메모리 구분?"

│

└─→ "응, 두 가지를 분리해야 해"

│

├─→ "Persistent Memory"

│ │

│ └─→ "모든 시퀀스에서 공유"

│ │

│ └─→ "학습된 지식 저장"

│

└─→ "Contextual Memory"

│

└─→ "현재 시퀀스에만 해당"

│

└─→ "Test-time에 업데이트"

│

└─→ "이 구분이 왜 중요한데?"

│

└─→ "지식 vs 맥락 분리"

│

└─→ 【Episodic vs Semantic Memory】

│

└─→ 인지과학 또 등장

```

---

## 4. Hope를 이해하고 싶다고?

### 전체 의존성 트리

```

"Hope가 뭐야?"

│

├─→ "Nested Learning으로 Self-Modifying 네트워크를 만드는 거야"

│ │

│ ├─→ "Nested Learning이 뭔데?"

│ │ │

│ │ └─→ "학습 안에 학습이 있는 구조야"

│ │ │

│ │ └─→ "Inner Loop / Outer Loop?"

│ │ │

│ │ └─→ "응, Bilevel Optimization이야"

│ │ │

│ │ └─→ 【Bilevel Optimization】

│ │ │

│ │ ├─→ "상위 문제가 하위 문제 최적해에 의존"

│ │ │ │

│ │ │ └─→ "수식으로 보여줘"

│ │ │ │

│ │ │ └─→ min_θ L(θ, φ*(θ))

│ │ │ where φ*(θ) = argmin_φ l(θ, φ)

│ │ │ │

│ │ │ └─→ "gradient 어떻게 계산해?"

│ │ │ │

│ │ │ └─→ 【Implicit Differentiation】

│ │ │ │

│ │ │ └─→ dφ*/dθ 계산해야 함

│ │ │ │

│ │ │ └─→ 【암묵적 함수 정리】

│ │ │ │

│ │ │ └─→ 【해석학】

│ │ │ │

│ │ │ └─→ 여기서 또 2주

│ │ │

│ │ └─→ "왜 이렇게 복잡한 걸 해?"

│ │ │

│ │ └─→ "빠른 적응을 위해서"

│ │ │

│ │ └─→ "Meta-Learning이랑 같은 거?"

│ │ │

│ │ └─→ "관련 있어"

│ │ │

│ │ └─→ MAML, Reptile, ...

│ │ │

│ │ └─→ 여기서 한 달

│ │

│ └─→ "Self-Modifying이 뭔데?"

│ │

│ └─→ "네트워크가 자기 파라미터를 수정해"

│ │

│ └─→ "Test-time에?"

│ │

│ └─→ "응"

│ │

│ └─→ "그게 가능해?"

│ │

│ └─→ "Hypernetwork 비슷한 개념이야"

│ │

│ └─→ 【Hypernetwork】

│ │

│ └─→ "네트워크가 다른 네트워크의 가중치 생성"

│ │

│ └─→ "Neural Turing Machine이랑 관련?"

│ │

│ └─→ 【Differentiable Computing】

│ │

│ └─→ 2014-2016년 DeepMind 시절

│ │

│ └─→ 역사 공부 (탈출)

│

├─→ 【Causal Memory [...]】 ← Hope의 핵심

│ │

│ └─→ "CMS가 뭔데?"

│ │

│ └─→ "인과적으로 메모리를 업데이트하는 시스템이야"

│ │

│ ├─→ "인과적이란 게 뭔 의미야?"

│ │ │

│ │ └─→ "과거가 미래에 영향, 미래는 과거에 영향 X"

│ │ │

│ │ └─→ "그거 당연한 거 아냐?"

│ │ │

│ │ └─→ "Attention은 양방향이거든"

│ │ │

│ │ └─→ "아 그래서 Causal Mask 쓰는 거구나"

│ │ │

│ │ └─→ "근데 메모리 시스템에서도 중요해"

│ │ │

│ │ └─→ "왜?"

│ │ │

│ │ └─→ "미래 정보 누출 방지"

│ │ │

│ │ └─→ 【인과추론】 갑자기

│ │ │

│ │ ├─→ Pearl의 인과 계층

│ │ ├─→ do-calculus

│ │ └─→ 여기서부터 철학 (진지)

│ │

│ └─→ "메모리 업데이트는 어떻게?"

│ │

│ └─→ "Gradient-based + Causal Masking"

│ │

│ └─→ "Surprise도 쓰나?"

│ │

│ └─→ "비슷한 개념이 있어"

│ │

│ └─→ Prediction Error

│ │

│ └─→ 【Predictive Coding】

│ │

│ └─→ 신경과학에서 온 이론

│ │

│ └─→ 뇌과학 등장 (어디까지 가는 거야)

│

├─→ 【TTT (Test-Time Training) Layer】

│ │

│ └─→ "Hope 이전에 TTT Layer 논문이 있어"

│ │

│ └─→ "어떤 관계야?"

│ │

│ └─→ "TTT: 선형 모델을 내부 상태로"

│ │

│ └─→ "Hope: 더 일반적인 프레임워크"

│ │

│ └─→ "TTT부터 이해해야 Hope가 이해됨?"

│ │

│ └─→ "추천"

│ │

│ └─→ 【TTT 논문 먼저】

│ │

│ └─→ Sun et al. 2024

│ │

│ └─→ (읽기 추가)

│

└─→ 【Nested Learning 상세】

│

└─→ "학습 안의 학습이 정확히 뭐야?"

│

└─→ "Outer: 전체 시퀀스 Loss"

│

└─→ "Inner: 로컬 예측 Loss"

│

└─→ "Inner에서 메모리 업데이트"

│

└─→ "Outer에서 전체 파라미터 업데이트"

│

└─→ "그럼 Backward가 두 번?"

│

└─→ "응, Gradient of Gradient"

│

└─→ 【Second-Order Optimization】

│

├─→ Hessian

│ │

│ └─→ O(n²) 파라미터

│ │

│ └─→ "계산 불가능"

│ │

│ └─→ "근사해야 함"

│ │

│ └─→ Hessian-Free Methods

│ │

│ └─→ 【수치 최적화】

│ │

│ └─→ 여기서 또 한 달

│

└─→ Truncated Backprop

│

└─→ "몇 스텝만 Unroll"

│

└─→ "Bias 생기지 않아?"

│

└─→ "생김"

│

└─→ "그래도 실용적이라 씀"

│

└─→ 일단 되니까 (도망)

```

---

## 5. 그래서 이 셋의 관계는?

### 비교 정리

```

Mamba Titans Hope

─────────────────────────────────────────────────────────────

핵심 아이디어 SSM + Selection Neural Memory Nested Learning

복잡도 O(n) O(n) + α O(n) + αα

장기 기억 상태 압축 명시적 메모리 자기수정 메모리

이론적 기반 제어이론 정보이론 최적화 이론

구현 난이도 CUDA 지옥 중간 높음

읽어야 할 것 물리+공학 인지과학+ML 최적화+ML

─────────────────────────────────────────────────────────────

```

### 선택 가이드

```

"나는 뭘 공부해야 해?"

│

├─→ 실용적 구현 원하면

│ │

│ └─→ Mamba (구현체 많음)

│ │

│ └─→ 근데 CUDA 커널 이해 필요 (어려움)

│

├─→ 이론적 이해 원하면

│ │

│ └─→ Titans (개념이 직관적)

│ │

│ └─→ 근데 Test-time 학습 이해 필요

│

└─→ 최신 연구 따라가려면

│

└─→ Hope (2024년 말 논문)

│

└─→ 근데 이전 것들 다 알아야 함

│

└─→ 【무한 루프】

```

---

## 6. 이거 다 알아야 해?

### 정직한 답변

```

"다 알아야 하나요?"

│

├─→ 논문 쓰려면: 해당 분야는 깊게, 나머지는 개념만

├─→ 구현하려면: Mamba 위주 + 라이브러리 활용

├─→ 비교하려면: 각각의 핵심 아이디어만

└─→ 사용만 하려면:

from mamba_ssm import Mamba

model = Mamba(d_model=512)

# 끝

```

### 현실적 학습 시간

| 목표 | 소요 시간 | 실제 의미 |

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

| API 사용 | 1일 | 없음 |

| 파인튜닝 | 1-2주 | 설정 파일 수정 |

| 아키텍처 이해 | 1-3개월 | 트리의 1단계들 |

| 논문 이해 | 6개월-1년 | 트리의 2단계들 |

| 개선 제안 | 1-2년 | 트리 대부분 |

| 새 아키텍처 제안 | 3년+ | 트리 전체 + 직관 |

| 완전 이해 | ??? | 저자도 모르는 것 있음 (진지) |

### 분야별 필요 지식

```

【공통 필수】

├── 선형대수: 행렬, 고유값, SVD

├── 미적분: 편미분, 연쇄법칙

├── 확률론: 기초 통계

└── 딥러닝: Transformer 기본

【Mamba 특화】

├── 제어이론: 상태 공간, 안정성

├── 신호처리: Z-변환, 이산화

├── 병렬 알고리즘: Scan operations

└── GPU 프로그래밍: CUDA (선택적)

【Titans 특화】

├── 정보이론: 엔트로피, Surprise

├── 인지과학: 기억 시스템 (개념만)

├── Meta-Learning: MAML 등 (개념만)

└── Hopfield Networks: 에너지 기반 모델

【Hope 특화】

├── 최적화 이론: Bilevel, Implicit Diff

├── Meta-Learning: 심화

├── 인과추론: 기초 개념

└── Second-order 방법: Hessian 근사

【실제로 쓰는 것】

└── model.forward(x)

```

---

## 7. 의존성 지옥 탈출 가이드

### 옵션 A: 전략적 포기

```python

# Mamba 쓰기

from mamba_ssm import Mamba

layer = Mamba(d_model=512, d_state=16, d_conv=4)

# 또는 Transformer 쓰기 (여전히 좋음)

from transformers import AutoModel

model = AutoModel.from_pretrained("...")

# 솔직히 Attention 충분히 빠름 (현실)

```

### 옵션 B: 필요할 때 파기

```

1. 일단 논문 Abstract + Figure 1만 봄

2. 코드 돌려봄

3. 이상하면 해당 부분만 파기

4. 반복

5. 어느새 알게 됨 (마법)

```

### 옵션 C: 정통파 (비추천)

```

선형대수 (3개월)

↓

미적분 + 해석학 (3개월)

↓

확률론 (2개월)

↓

신호처리 (2개월)

↓

제어이론 (3개월)

↓

최적화 이론 (3개월)

↓

딥러닝 기초 (3개월)

↓

Transformer (2개월)

↓

SSM 이론 (2개월)

↓

Meta-Learning (2개월)

↓

Mamba/Titans/Hope (3개월)

↓

총 소요: 2.5-3년

그 사이에 또 새로운 아키텍처 등장

(Attention Is All You Need → No It Isn't → Actually Maybe)

(망)

```

### 옵션 D: 하이브리드 (추천)

```

1. 이 문서로 큰 그림 파악 (1일)

2. Lilian Weng 블로그로 직관 형성 (1주)

3. 코드로 실습 (1-2주)

4. 궁금한 부분만 깊이 파기 (ongoing)

5. 수학은 막힐 때 그때그때

6. 논문은 Method 섹션 위주로

핵심: 모든 걸 다 알 필요 없음

필요한 것만 알면 됨

(이게 제일 어려움)

```

---

## 8. FAQ

### "Attention 안 쓰면 성능 떨어지지 않나요?"

```

├─→ 일반적인 경우: 비슷하거나 살짝 낮음

├─→ 긴 시퀀스: 오히려 좋을 수 있음

├─→ 결론: 상황 봐서 (무책임한 답변)

└─→ 추가: Hybrid가 대세

```

### "수학 몰라도 돼요?"

```

├─→ 사용만: 됨

├─→ 파인튜닝: 됨

├─→ 구현: 힘듦

├─→ 논문 이해: 안 됨

├─→ 연구: 절대 안 됨

└─→ 근데 필요한 것만 그때그때 하면 됨

```

### "어디서 시작해요?"

```

[일반] (딸깍) 롱컨텍, 장기기억 연구가 어려운 이유

댓글 7

다른 게시글