WorldModels:Tutorial:13-ModernWorldModels
lastmod 2026-11-18created 2026-11-172 edits
현대 World Model 지형도는 World Model 튜토리얼의 13장이다. 12장까지 만든 재구성형 World Model(VAE, MDN-RNN, RSSM, Dreamer)을 기준점으로 삼아 2019년 이후의 계열인 MuZero, TD-MPC, Transformer World Model, 확산 World Model, JEPA, 대규모 비디오 World Model 을 한 장의 지도에 놓는다. 계열마다 무엇을 왜 바꿨고 대가가 무엇인지 정리하고, 핵심 식(n-스텝 목표, pUCT, MPPI 가중치, 직선 통과 추정기, 어텐션의 \(\sqrt{d}\), 확산의 닫힌 꼴과 ELBO, EMA)을 유도한 뒤, 진자의 미래를 예측하는 작은 확산 World Model 을 구현한다.
- 원문: 13. 현대 World Model 지형도
- 실습 코드:
code/ch13_numbers.py(본문 숫자 예제 확인, numpy 만 쓰고 1초 안에 끝난다),code/ch13_diffusion_toy.py(노트북 CPU 4스레드 약 2분,--quick은 약 10초) - 이전: 12. Dreamer / 다음: 14. 부록
필요한 배경은 2 · 3장(확률 · KL), 5장(벨만 방정식), 7장(CEM), 8장(VAE · ELBO), 12장(Dreamer)이다. 하나의 모델을 끝까지 구현하는 장이 아니라 계열마다 핵심 식 한두 개를 골라 유도하는 장이다.
기호 주의
여러 논문의 기호를 그대로 빌려 쓰기 때문에 같은 글자가 절마다 다른 것을 가리킨다.
| 기호 | 쓰임 |
| \(\tau\) | TD-MPC 절에서는 MPPI · SimNorm 의 온도, JEPA 절에서는 EMA 의 섞는 비율이다(5장의 궤적, 6장의 토크와도 다르다). |
| \(z_t\) | MuZero 절에서는 가치의 목표값(n-스텝 리턴), 그 뒤로는 다시 잠재 상태다. |
| \(c_1, c_2\) | MuZero 절에서는 pUCT 의 탐험 상수, TD-MPC 절에서는 손실 항의 가중치(\(c_1, c_2, c_3\))다. |
| \(\lambda\) | TD-MPC 절에서 먼 스텝의 손실을 줄이는 가중치 \(\lambda^{i-t}\) 다. 12장 λ-리턴의 \(\lambda\) 와 다른 값이다. |
| \(\alpha\), \(\beta\) | Transformer 절에서는 어텐션 가중치 \(\alpha_j\), 확산 절에서는 \(\alpha_t = 1 - \beta_t\) 다. 확산 절의 \(\beta_t\) 는 잡음의 양이며 8장 β-VAE, VQ-VAE 의 \(\beta\) 와 다르다. |
| \(k\) | MuZero 절에서는 상상으로 나아간 스텝 수, Transformer 절에서는 고른 코드의 번호와 열쇠(key) 벡터, 확산 절 끝에서는 잡음 단계다. |
기준점과 다섯 가지 질문
기준점: 재구성형 World Model
12장 Dreamer 의 World Model 은 네 부분이다.
- 인코더: 그림 \(o_t\) 를 보고 잠재 상태 \(z_t\) 를 추측한다.
- RSSM: 은닉 상태 \(h_t\) 와 행동 \(a_t\) 로 다음 잠재 상태를 예측한다.
- 디코더: 잠재 상태에서 그림을 재구성한다. 재구성 손실이 잠재 상태가 그림의 정보를 담도록 강제한다.
- 보상 · 가치 · 정책: 잠재 상태에서 보상을 예측하고 상상 속에서 액터-크리틱으로 행동을 배운다.
재구성 손실은 막대의 각도 같은 중요한 정보와 배경의 얼룩 · 조명처럼 행동과 상관없는 정보를 구별하지 않고 모두 맞히라고 요구한다. 진자를 세우는 데 64×64 픽셀을 전부 다시 그릴 필요가 있는가라는 질문에 서로 다른 답을 낸 결과가 현대 World Model 의 여러 계열이다.
다섯 가지 질문
| 질문 | 가능한 답 | 예 |
| 1. 무엇을 예측하나 | 픽셀 전체 / 학습한 표현 / 보상 · 가치만 | Dreamer · 확산 = 픽셀, JEPA · TD-MPC = 표현, MuZero = 보상 · 가치 |
| 2. 잠재는 어떤 모양인가 | 연속 가우시안 / 이산 범주 / 토큰 여러 개 || PlaNet = 가우시안, DreamerV2 = 범주, IRIS = 그림 한 장당 토큰 16개 | |
| 3. 시간을 무엇으로 잇나 | RNN(GRU · LSTM) / Transformer / 확산 모델 || Dreamer = GRU, IRIS · STORM = Transformer, DIAMOND = 확산 | |
| 4. 어떻게 쓰나 | 계획(MPC · MCTS) / 상상 속 정책 학습 / 사람 · 에이전트가 쓰는 시뮬레이터 | PlaNet · TD-MPC = 계획, Dreamer = 상상 학습, Genie 3 = 시뮬레이터 |
| 5. 얼마나 큰가 | 게임 2시간 분량 ~ 영상 수백만 시간 | Atari 100k(약 2시간) ~ Cosmos(약 2천만 시간) |
원문의 지도(그림 13-1)는 가로축을 "무엇을 맞히도록 학습하는가"(픽셀 → 학습한 표현 → 보상 · 가치만), 세로축을 데이터 · 모델 규모로 둔다. 위치는 대략적이며 한 모델이 여러 성격을 함께 가질 수 있다.
| 예측 대상 | 작은 규모 | 중간 규모 | 큰 규모 |
| 픽셀(재구성 · 생성) | Ha · PlaNet · Dreamer (VAE · RSSM, 8 ~ 12장), IRIS · STORM (토큰 + Transformer) | DIAMOND · GameNGen (확산 World Model), Dreamer 4 (오프라인 Minecraft) | Genie 1 ~ 4 · Sora · Cosmos · GAIA (대규모 비디오 · 상호작용 World Model) |
| 학습한 표현 | TD-MPC2 (디코더 없는 잠재) | V-JEPA 2 (표현 예측, 100만 시간 이상) | |
| 보상 · 가치만 | MuZero · EfficientZero (가치 등가 + MCTS) |
모든 World Model 은 "행동이 주어지면 미래가 어떻게 될지"를 예측한다는 점에서 같다. 계열을 가르는 것은 미래의 무엇을(픽셀 · 표현 · 가치), 어떤 도구로(RNN · Transformer · 확산), 어디에 쓰려고(계획 · 상상 학습 · 시뮬레이터) 예측하느냐다.
가치 등가 모델: MuZero
아이디어와 세 함수
MuZero(Schrittwieser et al., Nature 2020)는 그림을 다시 그리지 않고 잠재 상태에서 세 가지만 맞히도록 학습한다.
- 보상 \(r\): 이 행동을 하면 받는 보상.
- 가치 \(v\): 이 상태에서 앞으로 받을 할인된 보상의 합(5장의 가치 함수).
- 정책 \(p\): 이 상태에서 각 행동을 고를 확률.
"계획에 쓰이는 값들만 진짜 환경과 같으면 된다"는 생각을 가치 등가(value equivalence)라고 부른다. MuZero 논문의 용어가 아니고 뒤이은 Grimm et al.(2020) "The Value Equivalence Principle for Model-Based Reinforcement Learning" 이 붙인 이름이다. 잠재 상태가 진짜 상태와 닮았는지는 상관하지 않는다. 그래서 MuZero 는 바둑 · 체스 · 쇼기와 Atari 를 규칙(시뮬레이터)을 미리 알려 주지 않은 채 같은 알고리즘으로 다뤘다(앞선 AlphaZero 는 탐색할 때 게임 규칙을 그대로 썼다).
모델은 신경망 세 개다(논문 기호).
\(\begin{align} \text{표현(representation)}: &\quad s^0 = h_\theta(o_1, \dots, o_t) \\ \text{동역학(dynamics)}: &\quad r^k,\ s^k = g_\theta(s^{k-1}, a^k) \\ \text{예측(prediction)}: &\quad p^k,\ v^k = f_\theta(s^k) \end{align}\)
\(s^k\) 는 진짜 환경 상태가 아니라 모델 안의 은닉 상태이고, 위 첨자 \(k\) 는 현재 시각 \(t\) 에서 상상으로 \(k\) 스텝 나아갔다는 뜻이다. 출발점 \(s^0\) 만 관측에서 만들고 그 뒤로는 행동만 넣어 나아간다. \(g_\theta\) 가 RSSM 의 전이 부분에 해당하고 디코더가 없다. 여기서 \(h_\theta\) 는 논문의 이름일 뿐 RNN 은닉 상태 \(h_t\) 와 다르다.
학습 목표: K 스텝 펼친 손실
리플레이 버퍼에서 시각 \(t\) 를 고르고 그때 실제로 했던 행동 \(a_{t+1}, \dots, a_{t+K}\) 를 동역학 함수에 차례로 넣어 \(K\) 스텝 펼친다(MuZero 는 \(K = 5\)). 논문은 관측 \(o_t\) 다음에 하는 행동을 \(a_{t+1}\), 그 결과 받는 보상을 \(u_{t+1}\) 로 써서 5장 표기보다 번호가 하나씩 크다.
\(\ell_t(\theta) = \sum_{k=0}^{K} \Big[\, \ell^{r}\big(u_{t+k},\ r^k_t\big) + \ell^{v}\big(z_{t+k},\ v^k_t\big) + \ell^{p}\big(\pi_{t+k},\ p^k_t\big) \Big] + c\,\lVert \theta \rVert^2\)
- \(u_{t+k}\): 실제로 받은 보상이다(\(k = 0\) 에는 보상 예측이 없으므로 빼고 센다).
- \(z_{t+k}\): 가치의 목표값인 n-스텝 리턴이다.
- \(\pi_{t+k}\): 그 시각에 MCTS 가 내놓은 행동 분포다. 정책 \(p\) 는 탐색 결과를 흉내 내도록 배우고 \(\ell^p\) 는 교차 엔트로피다.
- \(c\lVert\theta\rVert^2\): 가중치 정규화 항이다.
n-스텝 가치 목표
에피소드 끝까지의 리턴은 분산이 크고, 한 스텝 TD 목표는 부정확한 가치 추정의 편향이 그대로 스며든다. MuZero 는 그 사이로 n 스텝만 실제 보상을 쓰고 나머지를 가치 추정으로 메운다. 5장 표기(\(r_t\) 는 \(s_t\) 에서 \(a_t\) 를 했을 때 받는 보상)로 유도한다.
\(\begin{align} G_t &= \sum_{i=0}^{\infty} \gamma^i r_{t+i} = r_t + \gamma\, G_{t+1} \\ &= r_t + \gamma r_{t+1} + \gamma^2 G_{t+2} \\ &= \sum_{i=0}^{n-1} \gamma^i r_{t+i} + \gamma^n G_{t+n} \end{align}\)
여기까지는 근사가 없다. 모르는 꼬리 \(G_{t+n}\) 을 그 기댓값의 추정치 \(v(s_{t+n})\) 으로 바꾸면 n-스텝 목표가 된다.
\(z_t\mathrel{:=} \sum_{i=0}^{n-1} \gamma^i r_{t+i} + \gamma^n\, v(s_{t+n})\)
MuZero 는 Atari 에서 \(n = 10\) 을 썼고 \(v\) 로는 그때 MCTS 가 계산한 값을 쓴다. 숫자 예: \(\gamma = 0.9\), \(n = 3\), 보상 \((1, 0, 2)\), \(v(s_{t+3}) = 5\) 이면 \(z_t = 1 + 0 + 0.81 \times 2 + 0.729 \times 5 = 6.265\) 다.
"실제 보상 몇 스텝 + 끝에서 가치로 메우기"는 TD-MPC 의 계획 목표와 12장 Dreamer 의 λ-리턴(여러 \(n\) 의 n-스텝 목표를 \(\lambda\) 비율로 섞은 평균)에도 같은 꼴로 나온다.
MCTS 와 pUCT
MuZero 는 학습한 모델로 몬테카를로 나무 탐색(Monte Carlo Tree Search, MCTS)을 한다. 7장의 CEM 이 행동열 여러 개를 통째로 뽑아 좋은 것을 고른다면, MCTS 는 유망한 가지를 한 스텝씩 더 깊이 판다. 탐색 한 번은 다음 세 단계를 수십 ~ 수백 번 되풀이한다.
- 선택: 뿌리(\(s^0\))에서 출발해 각 노드에서 pUCT 점수가 가장 큰 행동을 따라 내려간다.
- 확장 · 평가: 아직 펼치지 않은 노드에 닿으면 \(g_\theta\) 로 다음 은닉 상태와 보상을 만들고 \(f_\theta\) 로 정책 \(p\) 와 가치 \(v\) 를 얻는다.
- 되돌려 쓰기(backup): 지나온 길의 노드마다 방문 횟수 \(N\) 을 1 늘리고 받은 보상과 가치로 평균 가치 \(Q\) 를 고친다.
선택 단계의 점수는 다음과 같다(MuZero 논문의 pUCT 식).
\(a^\ast = \operatorname*{arg\,max}_a \left[\, Q(s,a) + P(s,a)\,\frac{\sqrt{\sum_b N(s,b)}}{1 + N(s,a)} \left( c_1 + \log \frac{\sum_b N(s,b) + c_2 + 1}{c_2} \right) \right]\)
- \(Q(s,a)\): 지금까지 이 행동을 해 봤을 때의 평균 가치다(이용, exploitation).
- \(P(s,a)\): 정책 신경망이 준 사전 확률이다.
- \(\sqrt{\sum_b N} / (1 + N(s,a))\): 이 행동을 적게 해 봤을수록 커진다(탐험, exploration). 전체 방문이 늘면 분자가 제곱근 속도로 커지고, 이 행동의 방문이 늘면 분모가 커진다.
- \(c_1 = 1.25\), \(c_2 = 19652\): 탐험의 세기를 정한다. \(\log\) 항은 방문 수가 아주 클 때만 조금 커지므로 탐험 계수는 사실상 \(c_1\) 이다.
숫자 예: 행동 A 는 \(Q = 0.5,\ P = 0.3,\ N = 6\), 행동 B 는 \(Q = 0.3,\ P = 0.7,\ N = 4\), \(\sum_b N = 10\) 이다. 탐험 계수는 \(1.25 + \log(19663/19652) = 1.25056\) 이다.
\(\begin{align} \text{A}: &\quad 0.5 + 0.3 \times \frac{\sqrt{10}}{7} \times 1.25056 = 0.5 + 0.16948 = 0.66948 \\ \text{B}: &\quad 0.3 + 0.7 \times \frac{\sqrt{10}}{5} \times 1.25056 = 0.3 + 0.55365 = 0.85365 \end{align}\)
평균 가치는 A 가 높지만 B 는 덜 가 봤고 사전 확률이 커서 탐험 가산점이 더 크므로 B 를 고른다. B 를 더 가 보고 \(Q\) 가 실제로 낮으면 그때 A 로 돌아간다.
탐색이 끝나면 뿌리에서 각 행동을 방문한 횟수의 비율 \(\pi(a) = N(s^0, a) / \sum_b N(s^0, b)\) 를 행동 분포로 쓴다. 이 분포는 정책 신경망 \(p\) 보다 한 수 더 생각한 결과이므로 \(p\) 가 \(\pi\) 를 따라가도록 학습시키면 정책이 좋아진다. 탐색으로 정책을 개선하고 개선된 정책을 다시 신경망에 담는 이 순환이 AlphaZero · MuZero 의 골격이다.
Atari 의 보상은 게임마다 크기가 수백 배 다르다. MuZero 는 가치와 보상을 \(h(x) = \operatorname{sign}(x)\big(\sqrt{\lvert x\rvert + 1} - 1\big) + \epsilon x\) 로 눌러 담은 뒤 범주 분포로 예측했다. 12장 DreamerV3 의 symlog 와 two-hot 이 같은 문제에 대한 답이다.
EfficientZero
EfficientZero(Ye et al., NeurIPS 2021)는 MuZero 에 세 가지를 더해 Atari 100k 벤치마크(게임마다 에이전트 10만 스텝, 사람으로 치면 약 2시간 분량)에서 사람 점수를 넘는 평균 성능을 처음으로 냈다(NeurIPS 게재본 · arXiv v2 기준 평균 194.3%, arXiv v1 은 190.4%).
- 자기 지도 일관성 손실: 디코더가 없으면 은닉 상태를 가르치는 신호가 보상 · 가치 · 정책뿐이라 보상이 드문 초반에 학습이 느리다. "동역학이 예측한 다음 은닉 상태"와 "다음 관측을 인코더에 넣어 얻은 은닉 상태"가 비슷해지도록 하는 손실을 더했다(목표 쪽은 기울기 차단). TD-MPC 의 잠재 일관성 손실, JEPA 의 표현 예측과 같은 생각이다.
- 가치 접두사(value prefix): 보상을 한 스텝씩 따로 맞히지 않고 몇 스텝의 보상 합을 LSTM 으로 한꺼번에 예측해 보상이 언제 들어오는지의 모호함을 줄였다.
- 오래된 데이터 보정: 리플레이 버퍼의 오래된 궤적일수록 n-스텝 목표의 \(n\) 을 줄이고 최신 모델로 가치를 다시 계산한다.
| 장점 | 단점 |
| 그림을 그리지 않으므로 계획에 필요 없는 세부에 용량을 쓰지 않는다. MCTS 와 결합해 바둑 · Atari 모두에서 최고 수준이다. | 보상이 드물면 은닉 상태를 가르칠 신호가 부족하다. 모델이 무엇을 상상하는지 눈으로 볼 수 없다. MCTS 는 이산 행동에 자연스럽고 연속 행동(진자 토크)에는 샘플링 등 추가 기법이 필요하다. |
디코더 없는 잠재 계획: TD-MPC 와 TD-MPC2
구성 요소와 학습 목표
TD-MPC(Hansen, Wang, Su, ICML 2022)와 TD-MPC2(Hansen, Su, Wang, ICLR 2024)는 7장의 MPC 를 잠재 공간에서 하되 MuZero 처럼 디코더를 두지 않는 연속 제어용 World Model 이다.
\(\begin{align} \text{인코더}: &\quad z_t = e_\theta(s_t) \\ \text{잠재 동역학}: &\quad z_{t+1} = d_\theta(z_t, a_t) \\ \text{보상}: &\quad \hat r_t = R_\theta(z_t, a_t) \\ \text{행동 가치}: &\quad \hat q_t = Q_\theta(z_t, a_t) \\ \text{정책(사전)}: &\quad \hat a_t = \pi_\theta(z_t) \end{align}\)
\(Q_\theta(z, a)\) 는 5장의 행동 가치 함수다. 논문은 인코더를 \(h_\theta\) 로 쓰지만 튜토리얼에서는 \(e_\theta\) 로 바꿔 쓴다. 리플레이 버퍼에서 길이 \(H\) 의 구간을 꺼내 첫 상태만 인코딩한 뒤 잠재 동역학으로 펼치며 손실을 더한다.
\(\mathcal{L}(\theta) = \sum_{i=t}^{t+H} \lambda^{\,i-t} \Big[\, c_1 \big\lVert R_\theta(z_i, a_i) - r_i \big\rVert^2 + c_2 \big\lVert Q_\theta(z_i, a_i) - y_i \big\rVert^2 + c_3 \big\lVert d_\theta(z_i, a_i) - \operatorname{sg}\!\big(e_{\bar\theta}(s_{i+1})\big) \big\rVert^2 \Big]\)
- 보상 항: 잠재 상태에서 보상을 맞힌다.
- TD 항: 목표 \(y_i = r_i + \gamma\, Q_{\bar\theta}\big(z_{i+1}, \pi_\theta(z_{i+1})\big)\) 를 맞힌다. 벨만 기대 방정식 \(Q(s, a) = \mathbb{E}\big[r + \gamma\, Q(s', a') \big]\) 에서 기댓값을 실제로 겪은 전이 한 번으로 바꾸고 다음 행동을 정책이 고른 것으로 놓은 것이다. \(\bar\theta\) 는 \(\theta\) 를 천천히 따라오는 목표 신경망의 매개변수(EMA)다.
- 잠재 일관성 항: 동역학이 예측한 다음 잠재가 실제 다음 상태를 목표 인코더에 넣은 값과 같아지게 한다. \(\operatorname{sg}\) 는 기울기 차단(stop-gradient)이다.
- \(\lambda^{i-t}\) (\(\lambda \lt 1\)): 펼친 스텝이 길수록 오차가 쌓이므로 먼 미래의 오차를 덜 중요하게 본다.
붕괴 문제
디코더가 없으면 잠재 상태가 그림의 정보를 담도록 강제하는 손실이 없다. 인코더가 어떤 상태든 같은 상수 벡터 \(\mathbf{c}\) 를 내고 동역학도 늘 \(\mathbf{c}\) 를 내면 일관성 손실은 \(\lVert \mathbf{c} - \mathbf{c} \rVert^2 = 0\) 으로 최소가 된다. 이것이 표현 붕괴(representation collapse)다. 그러나 붕괴한 잠재로는 \(R_\theta(\mathbf{c}, a)\) 가 상태를 구별할 수 없어 보상 · TD 손실이 커진다. TD-MPC 에서는 보상 · TD 항이 잠재 상태에 "보상과 가치를 구별하는 데 필요한 정보"를 담도록 강제한다. 디코더가 하던 일을 제어에 필요한 정보만 남기는 방식으로 대신하는 셈이다.
계획: 짧게 상상하고 끝은 Q 로 메우기
매 스텝 잠재 공간에서 행동열 \(a_{t:t+H}\) 를 최적화한다(\(H\) 는 5 정도).
\(J(a_{t:t+H}) = \sum_{i=0}^{H-1} \gamma^{i}\, R_\theta(z_{t+i}, a_{t+i}) + \gamma^{H}\, Q_\theta\big(z_{t+H}, a_{t+H}\big)\)
TD-MPC 원 논문의 식이다. 끝항의 \(a_{t+H}\) 는 뽑은 행동열의 마지막 행동인데, TD-MPC · TD-MPC2 의 공식 구현은 그 자리에 \(\pi_\theta(z_{t+H})\) 를 넣는다. n-스텝 목표와 꼴이 같다. 끝에 가치 함수가 없으면 상상 길이를 길게 잡아야 하지만(7장은 25 스텝) 가치 함수가 있으면 짧게 상상해도 먼 미래를 고려한다. 이름의 "TD"는 이 가치 함수를 TD 학습으로 배운다는 뜻이다.
행동열 탐색에는 CEM 과 비슷한 MPPI(Model Predictive Path Integral)를 쓴다. CEM 은 상위 \(K\) 개 정예를 똑같은 가중치로 평균 내고, MPPI 는 모든 후보를 \(w_i \propto \exp(J_i / \tau)\) 로 평균 낸다.
MPPI 가중치 유도
행동열 \(A\) 를 뽑는 분포 \(q(A)\) 를 고르는 문제로 본다. 지금까지 쓰던 분포를 \(p(A)\) 라 할 때 "점수의 기댓값은 크게, \(p\) 에서 너무 멀리 벗어나지는 않게"를 식으로 쓴다. \(\tau \gt 0\) 은 얼마나 벗어나도 되는지를 정하는 온도다.
\(\max_{q}\ \mathbb{E}_{A \sim q}\big[ J(A) \big] - \tau\, D_{\mathrm{KL}}\big(q \parallel p\big)\)
행동열이 유한 개 \(A_1, \dots, A_M\) 중 하나라 하고 \(q_i, p_i, J_i\) 로 쓴다. 합이 1 이라는 조건에 라그랑주 승수 \(\kappa\) 를 붙인다.
\(\begin{align} \mathcal{L}(q, \kappa) &= \sum_{i} q_i J_i - \tau \sum_i q_i \log \frac{q_i}{p_i} + \kappa \Big( \sum_i q_i - 1 \Big) \\ \frac{\partial \mathcal{L}}{\partial q_i} &= J_i - \tau \Big( \log \frac{q_i}{p_i} + 1 \Big) + \kappa = 0 \\ \log \frac{q_i}{p_i} &= \frac{J_i + \kappa - \tau}{\tau} \\ q_i &= p_i \, \exp\!\Big(\frac{J_i}{\tau}\Big)\, \exp\!\Big(\frac{\kappa - \tau}{\tau}\Big) \end{align}\)
\(q_i \log(q_i/p_i)\) 의 미분은 곱의 미분법으로 \(\log(q_i/p_i) + 1\) 이다. 마지막 인수는 \(i\) 와 상관없는 상수이므로 정규화 상수가 된다.
\(q_i^\ast = \frac{p_i\, \exp(J_i / \tau)}{\sum_j p_j\, \exp(J_j / \tau)}\)
원래 분포 \(p\) 에 점수의 지수를 곱해 다시 정규화한 것이 최적이다. 실제로는 행동열이 연속이므로 \(p\) 에서 후보 \(M\) 개를 뽑아 근사한다. 후보가 이미 \(p\) 에서 뽑혔으므로 \(p_i\) 는 뽑힌 횟수로 반영되어 있고 남는 가중치는 \(\exp(J_i/\tau)\) 뿐이다.
\(w_i = \frac{\exp(J_i / \tau)}{\sum_{j=1}^{M} \exp(J_j / \tau)}, \qquad \mu_{\text{새}} = \sum_{i=1}^{M} w_i\, A_i\)
새 평균은 가중치 있는 가우시안 최대우도 추정의 답이기도 하다.
\(\begin{align} \ell(\mu) &= \sum_i w_i \Big[ -\frac{(A_i - \mu)^2}{2\sigma^2} - \frac{1}{2}\log(2\pi\sigma^2) \Big] \\ \frac{d\ell}{d\mu} &= \frac{1}{\sigma^2} \sum_i w_i (A_i - \mu) = 0 \\ \mu &= \frac{\sum_i w_i A_i}{\sum_i w_i} = \sum_i w_i A_i \end{align}\)
CEM 은 정예에 \(w = 1/K\), 나머지에 \(w = 0\) 을 준 특수한 경우다. 같은 방법으로 분산도 \(\sigma^2 = \sum_i w_i (A_i - \mu)^2\) 이 된다.
숫자 예: \(J = (10, 8, 2)\), \(\tau = 1\) 이면 분자 · 분모를 \(e^{10}\) 으로 나눠 \((1,\ 0.1353,\ 0.000335)\), 합 \(1.13567\), 가중치 \((0.8805,\ 0.1192,\ 0.0003)\) 이다. 가장 큰 점수를 빼고 계산하면 가중치는 그대로이면서 넘침(overflow)이 생기지 않는다(9장 MDN 의 log-sum-exp 와 같은 요령).
# MPPI 가중치: w_i = exp(R_i / τ) / Σ_j exp(R_j / τ). 큰 값의 exp 가 넘치지 않도록 최댓값을 빼고 계산한다.
returns = np.array([10.0, 8.0, 2.0])
for tau in [1.0, 5.0, 0.1, 100.0]:
w = np.exp((returns - returns.max()) / tau)
w = w / w.sum()
print(f"[MPPI] τ = {tau:6.1f}: 가중치 = {w}")
# CEM(상위 2개, 같은 가중치)과 비교
print("[CEM ] 상위 2개 : 가중치 =", np.array([0.5, 0.5, 0.0]))
[MPPI] τ = 1.0: 가중치 = [0.8805 0.1192 0.0003]
[MPPI] τ = 5.0: 가중치 = [0.5341 0.358 0.1078]
[MPPI] τ = 0.1: 가중치 = [1. 0. 0.]
[MPPI] τ = 100.0: 가중치 = [0.3444 0.3376 0.318 ]
[CEM ] 상위 2개 : 가중치 = [0.5 0.5 0. ]
\(\tau\) 가 0 에 가까우면 가장 좋은 후보 하나만 남고(argmax), 아주 크면 모든 후보를 똑같이 평균 낸다. 온도 하나로 두 극단 사이를 연속으로 조절한다. TD-MPC 는 실제로 둘을 섞어, 상위 \(K\) 개 정예를 고른 뒤 정예 안에서 \(\exp(\tau' J)\) 가중치로 평균 낸다.
TD-MPC2
TD-MPC2 는 한 가지 하이퍼파라미터 설정으로 DMControl · Meta-World · ManiSkill2 · MyoSuite 의 104개 과제를 풀었고, 80개 과제를 한 모델로 배우는 다중 과제 에이전트를 3억 1천7백만(317M) 매개변수까지 키웠다. 주요 변경은 다음과 같다.
- SimNorm: 잠재 벡터를 길이 \(L\) 의 묶음 여러 개로 나누고 묶음마다 softmax 를 씌운다. 각 묶음이 확률 단체(simplex) 위에 놓이므로 잠재 값이 끝없이 커지지 않는다. \(\operatorname{SimNorm}(x)_j = e^{x_j / \tau} \big/ \sum_{l=1}^{L} e^{x_l/\tau}\) 이다.
- 이산 회귀: 보상과 가치를 숫자 하나로 회귀하지 않고 DreamerV3 처럼 구간(bin)에 대한 범주 분포로 예측해 교차 엔트로피로 학습한다.
- Q 앙상블: Q 함수를 여러 개 두고 목표값에는 그중 일부의 최솟값을 써서 가치의 과대평가를 줄인다.
- LayerNorm · Mish(ReLU 를 매끄럽게 만든 활성 함수) 등으로 학습을 안정화했다.
| 장점 | 단점 |
| 디코더가 없어 가볍고 빠르다. 짧은 계획 + 가치 함수로 긴 미래를 본다. 연속 제어 과제에서 강하고 설정을 거의 바꾸지 않고 많은 과제에 쓸 수 있다. | 잠재 상태를 눈으로 확인할 방법이 없다. 보상 신호에 의존하므로 보상이 없는 사전 학습(비디오만 보고 배우기)에는 맞지 않는다. 매 스텝 계획하므로 행동을 고르는 데 시간이 든다. |
토큰과 Transformer World Model
그림 한 장을 작은 정수 몇 개(토큰)로 바꿀 수 있으면 "그림 토큰, 행동 토큰, 그림 토큰, 행동 토큰, ..."으로 이어지는 열에서 다음 토큰을 맞히는 Transformer 가 곧 World Model 이 된다. 필요한 도구는 그림을 토큰으로 바꾸는 VQ-VAE 와 토큰열을 예측하는 Transformer 다.
VQ-VAE
VQ-VAE(Vector Quantized VAE, van den Oord et al., 2017)는 8장의 VAE 처럼 인코더 · 디코더로 되어 있지만 잠재 변수가 연속 가우시안이 아니라 코드북(codebook)이라는 유한한 벡터 목록 중 하나다.
- 인코더가 그림의 각 위치마다 벡터 \(z_e \in \mathbb{R}^D\) 를 낸다. 64×64 그림이면 예를 들어 4×4 = 16개 위치에서 벡터 16개가 나온다.
- 코드북 \(\{e_1, \dots, e_K\}\) 에서 가장 가까운 벡터를 고른다. \(k = \operatorname*{arg\,min}_j \lVert z_e - e_j \rVert^2\).
- \(z_q = e_k\) 를 디코더에 넣어 그림을 복원한다. 정수 \(k\) 가 그 위치의 토큰이다.
숫자 예: 코드북 \(e_1 = (0,0)\), \(e_2 = (1,1)\), \(e_3 = (2,0)\), 인코더 출력 \(z_e = (1.2,\ 0.7)\) 이면 거리 제곱이 \(1.93,\ 0.13,\ 1.13\) 이므로 \(e_2\) 를 고르고 토큰은 2 다.
직선 통과 추정기
\(\operatorname*{arg\,min}\) 은 미분할 수 없다. \(z_e\) 를 조금 움직여도 고른 코드가 바뀌지 않는 한 \(z_q\) 가 그대로이므로 \(\partial z_q / \partial z_e = 0\) 이고 디코더 손실에서 인코더로 기울기가 흐르지 않는다. 12장 DreamerV2 의 범주형 잠재와 같은 문제이고 답도 같은 직선 통과 추정기(straight-through estimator)다. 디코더에 \(z_q\) 대신 다음 \(\tilde z\) 를 넣는다.
\(\tilde z = z_e + \operatorname{sg}\big(z_q - z_e\big)\)
- 값(forward): \(\operatorname{sg}\) 는 값에 영향이 없으므로 \(\tilde z = z_e + (z_q - z_e) = z_q\) 다.
- 기울기(backward): \(\partial \tilde z / \partial z_e = I + 0 = I\) 이므로 \(\partial \mathcal{L} / \partial z_e = \partial \mathcal{L} / \partial \tilde z\) 다. 디코더 입력에서 받은 기울기가 그대로 \(z_e\) 로 복사된다.
- 코드로는
z_tilde = z_e + (z_q - z_e).detach()한 줄이다.
코드북 벡터는 손실의 나머지 두 항으로 배운다.
\(\mathcal{L} = \underbrace{-\log p(x \mid \tilde z)}_{\text{재구성}} + \underbrace{\big\lVert \operatorname{sg}(z_e) - e_k \big\rVert^2}_{\text{코드북 손실}} + \beta\, \underbrace{\big\lVert z_e - \operatorname{sg}(e_k) \big\rVert^2}_{\text{커밋 손실}}\)
- 코드북 손실: \(z_e\) 쪽 기울기를 막았으므로 \(e_k\) 만 움직여 \(z_e\) 쪽으로 당긴다. \(\partial / \partial e_k = -2(z_e - e_k)\) 이므로 경사 하강 한 스텝은 \(e_k \leftarrow e_k + 2\eta(z_e - e_k)\) 다.
- 커밋 손실: \(e_k\) 를 고정하고 인코더 출력이 고른 코드 근처에 머물게 한다. 이 항이 없으면 인코더 출력이 코드북보다 빨리 멀리 달아난다. 논문은 \(\beta = 0.25\) 를 썼다.
앞의 예에서 코드북 손실은 \(0.13\), 커밋 손실은 \(0.25 \times 0.13 = 0.0325\) 다. 학습률 \(\eta = 0.1\) 로 한 스텝 고치면 \(e_2 \leftarrow (1, 1) + 0.2 \times (0.2, -0.3) = (1.04,\ 0.94)\) 다.
자기회귀 분해
조건부 확률의 정의 \(p(a, b) = p(b)\, p(a \mid b)\) 를 되풀이해 쓰면 토큰열 전체의 확률이 "앞의 것들을 보고 다음 하나를 맞히는" 확률의 곱으로 정확히 나뉜다(연쇄 규칙).
\(p(x_{1:N}) = \prod_{i=1}^{N} p(x_i \mid x_{\lt i}), \qquad \log p(x_{1:N}) = \sum_{i=1}^{N} \log p(x_i \mid x_{\lt i})\)
근사가 없는 등식이다. 전체 로그 가능도의 최대화는 토큰마다 다음 토큰의 교차 엔트로피를 줄이는 것과 같다. World Model 에서는 열이 "그림 \(t\) 의 토큰 16개, 행동 \(a_t\), 그림 \(t+1\) 의 토큰 16개, 행동 \(a_{t+1}\), ..."이고, 다음 그림의 토큰을 하나씩 맞혀 디코더에 넣으면 상상한 다음 장면이 나온다.
어텐션과 √d
어텐션(attention)은 토큰마다 질의(query) \(q\), 열쇠(key) \(k\), 값(value) \(v\) 를 만들고, 한 토큰의 질의가 다른 토큰들의 열쇠와 맞는 정도(내적)에 따라 값을 섞는다.
\(\operatorname{Attention}(Q, K, V) = \operatorname{softmax}\!\Big( \frac{Q K^{\top}}{\sqrt{d}} \Big) V, \qquad \alpha_{j} = \frac{\exp\!\big(q \cdot k_j / \sqrt{d}\big)}{\sum_{l} \exp\!\big(q \cdot k_l / \sqrt{d}\big)}, \quad \text{출력} = \sum_j \alpha_j v_j\)
\(d\) 는 질의 · 열쇠 벡터의 차원이다. 성분 \(q_i, k_i\) 가 서로 독립이고 평균 0, 분산 1 이라고 가정하면(학습 초기 초기화에서 대략 맞는다) 다음이 성립한다.
\(\begin{align} \mathbb{E}[q_i k_i] &= \mathbb{E}[q_i]\, \mathbb{E}[k_i] = 0, \qquad \mathbb{E}[q_i^2] = \operatorname{Var}(q_i) + \big(\mathbb{E}[q_i]\big)^2 = 1 \\ \operatorname{Var}(q_i k_i) &= \mathbb{E}[q_i^2]\,\mathbb{E}[k_i^2] - \big(\mathbb{E}[q_i k_i]\big)^2 = 1 \\ \operatorname{Var}(q \cdot k) &= \sum_{i=1}^{d} \operatorname{Var}(q_i k_i) = d \\ \operatorname{Var}\!\Big( \frac{q \cdot k}{\sqrt{d}} \Big) &= \frac{1}{d}\, \operatorname{Var}(q \cdot k) = 1 \end{align}\)
내적의 표준편차가 \(\sqrt{d}\) 로 차원에 따라 커지므로 \(\sqrt{d}\) 로 나눠 분산을 1 로 맞춘다. 점수가 크면 softmax 가 한 곳에만 1 을 주는 꼴로 포화해 기울기가 사라진다. 두 점수의 softmax \(p_1 = e^{s_1}/(e^{s_1} + e^{s_2})\) 를 몫의 미분법으로 미분하면 다음과 같다.
\(\frac{\partial p_1}{\partial s_1} = \frac{e^{s_1}(e^{s_1} + e^{s_2}) - e^{s_1} \cdot e^{s_1}}{(e^{s_1} + e^{s_2})^2} = p_1 \cdot \frac{e^{s_2}}{e^{s_1} + e^{s_2}} = p_1 (1 - p_1)\)
\(d = 64\) 면 점수의 표준편차가 8 이므로 나누지 않으면 \((8, 0)\) 같은 점수 차가 흔하다. 이때 \(p_1 = 0.99966\), 기울기 \(0.00034\) 다. \(\sqrt{d} = 8\) 로 나눈 \((1, 0)\) 이면 \(p_1 = 0.731\), 기울기 \(0.197\) 로 약 590배 크다(\(0.19661 / 0.000335 \approx 587\)).
[어텐션] d = 4: Var(q·k) = 4.00, Var(q·k / sqrt(d)) = 0.999
[어텐션] d = 64: Var(q·k) = 63.82, Var(q·k / sqrt(d)) = 0.997
[어텐션] d = 512: Var(q·k) = 510.86, Var(q·k / sqrt(d)) = 0.998
[softmax] 점수 [8. 0.] → 확률 [0.9997 0.0003], 기울기 p(1-p) = 0.00034
[softmax] 점수 [1. 0.] → 확률 [0.7311 0.2689], 기울기 p(1-p) = 0.19661
다음 토큰을 맞힐 때 미래 토큰을 엿보면 안 되므로 인과 마스크(causal mask)를 쓴다. 위치 \(i\) 의 질의는 \(j \gt i\) 인 열쇠와의 점수를 \(-\infty\) 로 바꾸고, \(e^{-\infty} = 0\) 이므로 softmax 가중치가 정확히 0 이 된다. 길이 \(N\) 의 열 전체를 한 번에 넣고 \(N\) 개의 다음 토큰 예측을 동시에 학습할 수 있어 한 스텝씩 차례로 계산하는 RNN 보다 학습이 병렬적이다.
대표 모델: IRIS · TWM · STORM
Atari 100k 성적은 사람 기준 정규화 점수(human-normalized score, HNS)로 비교한다. 무작위 행동의 점수를 0, 사람의 점수를 1 로 맞춘다.
\(\text{HNS} = \frac{\text{에이전트 점수} - \text{무작위 점수}}{\text{사람 점수} - \text{무작위 점수}}, \qquad \text{예: } \frac{600 - 100}{1100 - 100} = 0.5\ (50\%)\)
- IRIS(Micheli, Alonso, Fleuret, ICLR 2023): 64×64 그림을 512가지 코드북의 토큰 16개(4×4)로 바꾸고, GPT 같은 Transformer(인과 마스크)가 "\(o_t\) 토큰 16, \(a_t\), \(o_{t+1}\) 토큰 16, \(a_{t+1}\), ..." 열에서 다음 그림의 토큰 · 보상 · 종료를 예측한다. 예측한 토큰을 디코더로 그림으로 되돌리고, 정책은 상상한 그림 · 보상으로 12장과 같은 액터-크리틱 학습을 한다. Atari 100k 평균 HNS 1.046(104.6%)으로 26개 게임 중 10개에서 사람을 넘었다.
- TWM(Robine et al., ICLR 2023): DreamerV2 식의 이산 잠재 상태를 만들고 시간 방향 연결만 GRU 대신 Transformer-XL 로 바꿨다.
- STORM(Zhang et al., NeurIPS 2023): 그림 한 장을 토큰 16개가 아니라 범주형 잠재 벡터 하나(한 토큰)로 만들어 열을 짧게 하고 그 위에 GPT 식 Transformer 를 얹었다. Atari 100k 평균 HNS 126.7% 를 보고했다.
| 장점 | 단점 |
| LLM 의 도구(학습 방법 · 하드웨어 최적화 · 규모 키우기)를 그대로 쓴다. 긴 과거를 직접 참조할 수 있어 기억이 좋다. 학습이 병렬적이다. | 토큰을 하나씩 만드는 생성은 느리다(그림 한 장에 토큰 16번). 어텐션 비용이 열 길이의 제곱으로 는다. VQ 토크나이저가 작은 세부를 잃을 수 있다. |
확산 World Model
확산 모델(DDPM: Ho et al., 2020)은 데이터에 잡음을 조금씩 섞어 순수한 가우시안 잡음으로 만드는 정방향 과정(정해진 규칙, 학습할 것이 없음)과, 잡음에서 시작해 잡음을 조금씩 걷어 내 데이터를 만드는 역방향 과정(신경망이 배움)으로 되어 있다. 유도에는 2장의 가우시안, 3장의 KL, 8장의 ELBO 만 쓴다. 1차원으로 유도하지만 벡터에서도 성분마다 똑같이 성립한다.
정방향 과정
\(\beta_t\) 는 스텝마다 섞는 잡음의 양(0.0001 ~ 0.02 같은 작은 수)이고 \(\alpha_t\mathrel{:=} 1 - \beta_t\) 다.
\(q(x_t \mid x_{t-1}) = \mathcal{N}\big(x_t;\ \sqrt{\alpha_t}\, x_{t-1},\ \beta_t\big) \quad\Longleftrightarrow\quad x_t = \sqrt{\alpha_t}\, x_{t-1} + \sqrt{\beta_t}\, \epsilon_t,\quad \epsilon_t \sim \mathcal{N}(0, 1)\)
\(x_{t-1}\) 에 \(\sqrt{\alpha_t}\) 를 곱하는 이유는 크기를 유지하기 위해서다. \(x_{t-1}\) 과 새 잡음이 독립이므로 \(\operatorname{Var}(x_t) = \alpha_t \operatorname{Var}(x_{t-1}) + \beta_t\) 이고, \(\operatorname{Var}(x_{t-1}) = 1\) 이면 \(\operatorname{Var}(x_t) = \alpha_t + \beta_t = 1\) 이다. 잡음을 더하기만 하면 분산이 \(1 + \beta_1 + \beta_2 + \cdots\) 로 계속 커진다.
\(\bar\alpha_t\mathrel{:=} \alpha_1 \alpha_2 \cdots \alpha_t\) 로 두면 \(x_0\) 에서 \(x_t\) 로 한 번에 갈 수 있다. 한 스텝 규칙을 두 번 쓰면 다음과 같다.
\(\begin{align} x_t &= \sqrt{\alpha_t}\Big( \sqrt{\alpha_{t-1}}\, x_{t-2} + \sqrt{1 - \alpha_{t-1}}\, \epsilon_{t-1} \Big) + \sqrt{1 - \alpha_t}\, \epsilon_t \\ &= \sqrt{\alpha_t \alpha_{t-1}}\, x_{t-2} + \sqrt{\alpha_t (1 - \alpha_{t-1})}\, \epsilon_{t-1} + \sqrt{1 - \alpha_t}\, \epsilon_t \\ &= \sqrt{\alpha_t \alpha_{t-1}}\, x_{t-2} + \sqrt{1 - \alpha_t\alpha_{t-1}}\; \bar\epsilon, \qquad \bar\epsilon \sim \mathcal{N}(0, 1) \end{align}\)
평균 0 인 독립 가우시안 두 개의 합은 다시 가우시안이고(증명 없이 받아들인다) 분산은 \(\alpha_t(1 - \alpha_{t-1}) + (1 - \alpha_t) = 1 - \alpha_t \alpha_{t-1}\) 이다. 같은 일을 \(x_0\) 까지 되풀이하면(수학적 귀납법) 닫힌 꼴이 된다.
\(x_t = \sqrt{\bar\alpha_t}\, x_0 + \sqrt{1 - \bar\alpha_t}\; \epsilon, \qquad q(x_t \mid x_0) = \mathcal{N}\big(x_t;\ \sqrt{\bar\alpha_t}\, x_0,\ 1 - \bar\alpha_t\big)\)
\(\bar\alpha_T\) 가 0 에 가까우면 \(x_T \approx \epsilon\), 즉 순수한 잡음이다. 숫자 예: \(x_0 = 2\), \(\beta_1 = \beta_2 = \beta_3 = 0.1\) 이면 \(\bar\alpha_3 = 0.729\), \(q(x_3 \mid x_0) = \mathcal{N}(1.7076,\ 0.271)\) 이다. 한 스텝씩 분산을 따라가도 \(0.1 \to 0.19 \to 0.271\) 로 같다. 표본 백만 개로 한 스텝씩 되풀이한 결과는 평균 1.7079, 분산 0.2706 이다.
역방향 과정의 정답 분포
\(q(x_{t-1} \mid x_t)\) 는 데이터 전체의 분포를 알아야 계산되므로 직접 구할 수 없다. 원래 데이터 \(x_0\) 까지 안다고 하면 정확히 계산되고 가우시안이 된다. 먼저 도구로, 같은 변수에 대한 가우시안 두 개의 곱은 가우시안이다. 지수를 전개해 \(x^2\) 항과 \(x\) 항을 모으고 제곱을 완성한다.
\(\begin{align} \mathcal{N}(x; a, A)\cdot \mathcal{N}(x; b, B) &\propto \exp\!\Big( -\frac{1}{2}\Big[ x^2\Big(\frac{1}{A} + \frac{1}{B}\Big) - 2x\Big(\frac{a}{A} + \frac{b}{B}\Big) + \text{상수} \Big] \Big) \\ &\propto \mathcal{N}\!\Big(x;\ \frac{aB + bA}{A + B},\ \frac{AB}{A + B}\Big) \end{align}\)
평균은 두 평균을 상대 분산으로 가중 평균한 값이고 분산은 둘보다 작아진다. 다음으로 정방향 한 스텝을 \(x_{t-1}\) 의 함수로 본다. \((x_t - \sqrt{\alpha_t}\, x_{t-1})^2 = \alpha_t ( x_{t-1} - x_t/\sqrt{\alpha_t} )^2\) 이므로
\(q(x_t \mid x_{t-1}) \propto \mathcal{N}\Big(x_{t-1};\ \frac{x_t}{\sqrt{\alpha_t}},\ \frac{\beta_t}{\alpha_t}\Big)\)
이다. 베이즈 정리와 마르코프 성질 \(q(x_t \mid x_{t-1}, x_0) = q(x_t \mid x_{t-1})\) 을 쓰면
\(q(x_{t-1} \mid x_t, x_0) = \frac{q(x_t \mid x_{t-1})\; q(x_{t-1} \mid x_0)}{q(x_t \mid x_0)} \propto \mathcal{N}\Big(x_{t-1};\ \frac{x_t}{\sqrt{\alpha_t}},\ \frac{\beta_t}{\alpha_t}\Big) \cdot \mathcal{N}\big(x_{t-1};\ \sqrt{\bar\alpha_{t-1}}\, x_0,\ 1 - \bar\alpha_{t-1}\big)\)
이다. 도구에 \(a = x_t/\sqrt{\alpha_t}\), \(A = \beta_t/\alpha_t\), \(b = \sqrt{\bar\alpha_{t-1}}\, x_0\), \(B = 1 - \bar\alpha_{t-1}\) 을 넣는다. \(A + B = (1 - \bar\alpha_t)/\alpha_t\) 이다(\(\beta_t + \alpha_t = 1\), \(\alpha_t \bar\alpha_{t-1} = \bar\alpha_t\)).
\(\begin{align} \tilde\beta_t &= \frac{AB}{A + B} = \frac{1 - \bar\alpha_{t-1}}{1 - \bar\alpha_t}\, \beta_t \\ \tilde\mu_t &= \frac{aB + bA}{A + B} = \frac{\sqrt{\alpha_t}\,(1 - \bar\alpha_{t-1})}{1 - \bar\alpha_t}\, x_t + \frac{\sqrt{\bar\alpha_{t-1}}\, \beta_t}{1 - \bar\alpha_t}\, x_0 \end{align}\)
정답 분포는 \(\mathcal{N}(\tilde\mu_t, \tilde\beta_t)\) 다. \(\bar\alpha_0\mathrel{:=} 1\) 로 약속하면 \(\tilde\beta_1 = 0\) 이다. 숫자 예: \(\beta = 0.1\) 일정, \(t = 2\) 에서 \(\tilde\beta_2 = \frac{0.1}{0.19}\times 0.1 = 0.0526\) 으로 한 스텝에 섞은 잡음 \(\beta_2 = 0.1\) 보다 작다. \(x_0\) 이라는 추가 정보가 있기 때문이다.
샘플을 만들 때는 \(x_0\) 을 모르므로 닫힌 꼴을 풀어 \(x_0 = \big(x_t - \sqrt{1 - \bar\alpha_t}\,\epsilon\big)/\sqrt{\bar\alpha_t}\) 를 넣는다. \(x_t\) 의 계수는 \(\frac{\alpha_t (1 - \bar\alpha_{t-1}) + \beta_t}{\sqrt{\alpha_t}(1 - \bar\alpha_t)} = \frac{1}{\sqrt{\alpha_t}}\), \(\epsilon\) 의 계수는 \(-\frac{\beta_t}{\sqrt{\alpha_t}\sqrt{1 - \bar\alpha_t}}\) 로 정리된다.
\(\tilde\mu_t = \frac{1}{\sqrt{\alpha_t}} \Big( x_t - \frac{\beta_t}{\sqrt{1 - \bar\alpha_t}}\, \epsilon \Big)\)
한 스텝 전으로 돌아가려면 \(x_t\) 에 섞인 잡음 \(\epsilon\) 만 알면 된다. 그래서 신경망은 \(\epsilon\) 을 맞히도록 배운다.
학습 목표: 확산의 ELBO
확산 모델은 잠재 변수가 \(x_1, \dots, x_T\) 인 VAE 로 볼 수 있다. 모델(역방향)은 \(p_\theta(x_{0:T}) = p(x_T) \prod_{t=1}^{T} p_\theta(x_{t-1} \mid x_t)\), \(p(x_T) = \mathcal{N}(0, 1)\) 이고, 인코더 자리에 고정된 정방향 \(q(x_{1:T} \mid x_0) = \prod_{t=1}^{T} q(x_t \mid x_{t-1})\) 이 들어간다.
\(\begin{align} \log p_\theta(x_0) &\ge \mathbb{E}_{q(x_{1:T} \mid x_0)}\Big[ \log \frac{p_\theta(x_{0:T})}{q(x_{1:T} \mid x_0)} \Big] =: \text{ELBO} \\ \log \frac{p_\theta(x_{0:T})}{q(x_{1:T} \mid x_0)} &= \log p(x_T) + \log \frac{p_\theta(x_0 \mid x_1)}{q(x_1 \mid x_0)} + \sum_{t=2}^{T} \log \frac{p_\theta(x_{t-1} \mid x_t)}{q(x_t \mid x_{t-1})} \end{align}\)
\(t \ge 2\) 인 항에 마르코프 성질과 베이즈 정리를 써서 정방향 확률을 역방향 정답으로 바꾼다.
\(q(x_t \mid x_{t-1}) = q(x_t \mid x_{t-1}, x_0) = \frac{q(x_{t-1} \mid x_t, x_0)\; q(x_t \mid x_0)}{q(x_{t-1} \mid x_0)}\)
대입하면 합이 둘로 갈라지고, 둘째 합은 망원경 합(telescoping sum)이다.
\(\sum_{t=2}^{T} \big[\log q(x_{t-1} \mid x_0) - \log q(x_t \mid x_0)\big] = \log q(x_1 \mid x_0) - \log q(x_T \mid x_0)\)
\(t = 1\) 항의 \(-\log q(x_1 \mid x_0)\) 과 지워지고 기댓값을 씌우면 다음이 된다.
\(\text{ELBO} = \underbrace{\mathbb{E}_q\big[\log p_\theta(x_0 \mid x_1)\big]}_{\text{재구성}} - \underbrace{D_{\mathrm{KL}}\big(q(x_T \mid x_0) \parallel p(x_T)\big)}_{\text{학습할 것 없음}} - \sum_{t=2}^{T} \mathbb{E}_{q(x_t \mid x_0)}\Big[ \underbrace{D_{\mathrm{KL}}\big(q(x_{t-1} \mid x_t, x_0) \parallel p_\theta(x_{t-1} \mid x_t)\big)}_{\text{스텝마다 정답을 따라 하기}} \Big]\)
가운데 항에는 \(\theta\) 가 없고 \(\bar\alpha_T \approx 0\) 이면 거의 0 이다. 학습은 스텝마다 모델의 역방향 분포가 정답 \(q(x_{t-1} \mid x_t, x_0)\) 을 따라 하게 하는 것이다. 모델의 역방향 한 스텝은 정답과 같은 꼴로 두고, 분산은 정해진 값 \(\sigma_t^2\)(보통 \(\beta_t\) 또는 \(\tilde\beta_t\)), 평균은 \(\epsilon\) 자리를 신경망으로 바꾼다.
\(p_\theta(x_{t-1} \mid x_t) = \mathcal{N}\big(x_{t-1};\ \mu_\theta(x_t, t),\ \sigma_t^2\big), \qquad \mu_\theta(x_t, t) = \frac{1}{\sqrt{\alpha_t}} \Big( x_t - \frac{\beta_t}{\sqrt{1 - \bar\alpha_t}}\, \epsilon_\theta(x_t, t) \Big)\)
분산이 같은 두 가우시안의 KL 은 \((\mu_1 - \mu_2)^2 / (2\sigma^2)\) 이다(분산이 다르면 \(\theta\) 와 상관없는 상수가 더 붙을 뿐이다). 두 평균은 \(\epsilon\) 자리만 다르므로
\(D_{\mathrm{KL},\,t} = \frac{\beta_t^2}{2\sigma_t^2\, \alpha_t\, (1 - \bar\alpha_t)}\; \big\lVert \epsilon - \epsilon_\theta(x_t, t) \big\rVert^2\)
이다. 예를 들어 \(\beta_t = \sigma_t^2 = 0.1\), \(\alpha_t = 0.9\), \(\bar\alpha_t = 0.81\) 이면 계수는 \(0.01 / 0.0342 = 0.292\) 다. \(x_t\) 를 닫힌 꼴로 바꿔 넣고 \(t\) 를 무작위로 고르며 앞의 계수를 떼면 단순 손실이 된다.
\(\mathcal{L}_{\text{simple}}(\theta) = \mathbb{E}_{t,\, x_0,\, \epsilon}\Big[ \big\lVert \epsilon - \epsilon_\theta\big( \sqrt{\bar\alpha_t}\, x_0 + \sqrt{1 - \bar\alpha_t}\, \epsilon,\ t \big) \big\rVert^2 \Big]\)
Ho et al.(2020)은 계수를 뗀 이 손실이 실제로 더 좋은 그림을 만든다는 것을 보였다. \(t = 1\) 의 재구성 항도 \(-\log p_\theta(x_0 \mid x_1) = \frac{(x_0 - \mu_\theta)^2}{2\sigma_1^2} + \text{상수}\) 이고 \(x_0 - \mu_\theta = \frac{\beta_1}{\sqrt{\alpha_1}\sqrt{1-\bar\alpha_1}}(\epsilon_\theta - \epsilon)\) 이라 역시 \(\lVert\epsilon - \epsilon_\theta\rVert^2\) 에 비례한다. 그래서 \(t = 1, \dots, T\) 를 구별 없이 뽑아도 된다.
확산 모델의 요약은 다음과 같다.
- 학습: 데이터 \(x_0\), 단계 \(t\), 잡음 \(\epsilon\) 을 뽑아 \(x_t = \sqrt{\bar\alpha_t}\, x_0 + \sqrt{1-\bar\alpha_t}\,\epsilon\) 을 만들고 \(\lVert \epsilon - \epsilon_\theta(x_t, t)\rVert^2\) 을 줄인다.
- 샘플링: \(x_T \sim \mathcal{N}(0, 1)\) 에서 시작해 \(t = T, \dots, 1\) 순서로 \(x_{t-1} = \frac{1}{\sqrt{\alpha_t}}\big(x_t - \frac{\beta_t}{\sqrt{1-\bar\alpha_t}}\epsilon_\theta(x_t, t)\big) + \sigma_t z\), \(z \sim \mathcal{N}(0,1)\) 을 계산한다(마지막 스텝은 \(z = 0\)).
- World Model 로 쓰려면 \(\epsilon_\theta\) 에 조건(지금 상태 · 과거 그림 · 행동)을 함께 넣는다.
실습: 진자의 미래를 그리는 작은 확산 World Model
진자가 지금 각도 \(\theta\), 각속도 \(\dot\theta\) 에 있고, 앞으로 1초(20 스텝) 동안 모르는 토크 \(u \in [-2, 2]\) 를 계속 건다. 1초 뒤 막대 끝의 위치를 예측한다. \(u\) 를 모르므로 답은 한 점이 아니라 분포다. 그림 대신 막대 끝 위치 \((x, y)\) 두 숫자만 예측하지만 "미래가 여러 갈래일 때 무엇을 예측해야 하는가"라는 질문은 그림을 예측하는 World Model 과 같다. 비교용으로 MSE 로 한 점을 예측하는 회귀 모델도 함께 학습한다.
데이터는 wm_envs.Pendulum 과 같은 물리를 numpy 벡터 연산으로 다시 써서 (지금 상태, 1초 뒤 막대 끝) 쌍 20만 개를 만든다. 스크립트는 시작할 때 simulate_batch 결과가 Pendulum.step 과 같은지 확인한다. 조건 cond 는 \([\cos\theta, \sin\theta, \dot\theta/3]\), 목표 target 은 \((\sin\theta', \cos\theta')\) 이다(위쪽이 \(+y\)).
def simulate_batch(th, thdot, u, steps):
"""여러 진자를 한꺼번에 굴린다 (wm_envs.Pendulum.step 과 같은 물리, numpy 벡터 연산).
th, thdot, u : (N,) 배열. u 는 steps 동안 그대로 유지하는 토크.
"""
P = Pendulum
u = np.clip(u, -P.max_torque, P.max_torque)
for _ in range(steps):
thdot = thdot + (3 * P.g / (2 * P.l) * np.sin(th) + 3.0 / (P.m * P.l**2) * u) * P.dt
thdot = np.clip(thdot, -P.max_speed, P.max_speed)
th = th + thdot * P.dt
return th, thdot
def make_dataset(n):
"""조건 c = [cos θ, sin θ, θ̇/3] (지금), 목표 x = 1초 뒤 막대 끝 위치 [sin θ', cos θ'] (위쪽이 +y)."""
th = rng.uniform(-np.pi, np.pi, n)
thdot = rng.uniform(-3.0, 3.0, n)
u = rng.uniform(-2.0, 2.0, n) # 모르는 미래의 토크 → 미래가 여러 갈래가 되는 까닭
th_f, _ = simulate_batch(th, thdot, u, HORIZON)
cond = np.stack([np.cos(th), np.sin(th), thdot / 3.0], axis=1) # θ̇ 는 대략 [-1, 1] 로 맞춘다
target = np.stack([np.sin(th_f), np.cos(th_f)], axis=1) # 막대 끝 (x, y)
return cond.astype(np.float32), target.astype(np.float32)
잡음 일정과 닫힌 꼴이다. \(\beta_1, \dots, \beta_{100}\) 을 0.0001 에서 0.15 까지 고르게 늘린다. 단계가 100개뿐이라 이미지 모델(보통 1000단계, 0.02까지)보다 크게 잡았다. \(\bar\alpha_{100} \approx 3.7 \times 10^{-4}\) 으로 마지막에는 거의 순수한 잡음이 된다. 코드의 t 는 0부터 세므로 수식의 \(t\) 보다 1 작다.
T = 100 # 잡음 단계 수
betas = torch.linspace(1e-4, 0.15, T) # β_1 … β_T : 단계마다 섞는 잡음의 양
alphas = 1.0 - betas # α_t = 1 - β_t
alpha_bars = torch.cumprod(alphas, dim=0) # ᾱ_t = α_1 · α_2 · … · α_t
def q_sample(x0, t, eps):
"""닫힌 꼴로 한 번에 x_t 를 만든다: x_t = sqrt(ᾱ_t) x_0 + sqrt(1 - ᾱ_t) ε."""
ab = alpha_bars.to(x0.device)[t].unsqueeze(1) # (B, 1)
return ab.sqrt() * x0 + (1 - ab).sqrt() * eps
신경망은 잡음 섞인 미래 \(x_t\), 단계 \(t\), 조건 \(c\) 를 받아 잡음 \(\epsilon\) 을 맞히는 MLP 다. 정수 \(t\) 는 time_embedding 이 여러 주파수의 \(\sin, \cos\) 값으로 바꿔 넣는다. 비교용 Regressor 는 조건만 보고 미래 위치를 바로 낸다.
def time_embedding(t, dim=32):
"""잡음 단계 t(정수)를 사인 · 코사인 벡터로 바꾼다 (Transformer 의 위치 임베딩과 같은 방법)."""
half = dim // 2
freqs = torch.exp(-math.log(1000.0) * torch.arange(half, device=t.device) / half)
angles = t.float().unsqueeze(1) * freqs.unsqueeze(0) # (B, half)
return torch.cat([angles.sin(), angles.cos()], dim=1) # (B, dim)
class Denoiser(nn.Module):
"""ε_θ(x_t, t, c): 잡음 섞인 미래 x_t, 단계 t, 조건 c(지금 상태)를 보고 섞인 잡음 ε 을 맞힌다."""
def __init__(self, x_dim=2, c_dim=3, hidden=256):
super().__init__()
self.net = nn.Sequential(
nn.Linear(x_dim + c_dim + 32, hidden), nn.SiLU(),
nn.Linear(hidden, hidden), nn.SiLU(),
nn.Linear(hidden, hidden), nn.SiLU(),
nn.Linear(hidden, x_dim),
)
def forward(self, x_t, t, c):
return self.net(torch.cat([x_t, c, time_embedding(t)], dim=1))
class Regressor(nn.Module):
"""비교용: 조건 c 만 보고 미래 x 를 한 점으로 예측하는 보통의 회귀 모델 (MSE 로 학습)."""
def __init__(self, x_dim=2, c_dim=3, hidden=256):
super().__init__()
self.net = nn.Sequential(
nn.Linear(c_dim, hidden), nn.SiLU(),
nn.Linear(hidden, hidden), nn.SiLU(),
nn.Linear(hidden, x_dim),
)
def forward(self, c):
return self.net(c)
학습 루프는 \(\mathcal{L}_{\text{simple}}\) 그대로다. 배치 1024, Adam 학습률 \(10^{-3}\), 8,000 스텝이고 확산 모델 쪽에만 코사인 학습률 일정을 쓴다.
def train(cond, target):
cond_t = torch.from_numpy(cond).to(device)
x_t0 = torch.from_numpy(target).to(device)
denoiser, regressor = Denoiser().to(device), Regressor().to(device)
opt_d = torch.optim.Adam(denoiser.parameters(), lr=1e-3)
opt_r = torch.optim.Adam(regressor.parameters(), lr=1e-3)
sched_d = torch.optim.lr_scheduler.CosineAnnealingLR(opt_d, TRAIN_STEPS)
losses = []
for step in range(1, TRAIN_STEPS + 1):
idx = torch.randint(0, len(cond_t), (1024,), device=device)
c, x0 = cond_t[idx], x_t0[idx]
# (1) 확산 모델: 단계 t 를 고르고, 잡음 ε 을 섞어 x_t 를 만든 뒤, ε 을 맞히게 한다.
t = torch.randint(0, T, (len(idx),), device=device)
eps = torch.randn_like(x0)
x_noisy = q_sample(x0, t, eps)
loss_d = ((denoiser(x_noisy, t, c) - eps) ** 2).mean() # ‖ε - ε_θ‖² 의 평균
opt_d.zero_grad()
loss_d.backward()
opt_d.step()
sched_d.step()
# (2) 회귀 모델: 미래 위치를 바로 맞히게 한다 (MSE).
loss_r = ((regressor(c) - x0) ** 2).mean()
opt_r.zero_grad()
loss_r.backward()
opt_r.step()
losses.append(loss_d.item())
if step % max(1, TRAIN_STEPS // 8) == 0:
print(f"step {step:5d} 확산 손실 {np.mean(losses[-200:]):.4f} 회귀 MSE {loss_r.item():.4f}")
return denoiser, regressor, losses
샘플링은 역방향 식 그대로다. b / math.sqrt(1 - ab) * eps_hat 이 \(\frac{\beta_t}{\sqrt{1-\bar\alpha_t}}\epsilon_\theta\), / math.sqrt(a) 가 \(\frac{1}{\sqrt{\alpha_t}}\), 마지막 줄이 \(+\sigma_t z\) (\(\sigma_t^2 = \beta_t\)) 다.
@torch.no_grad()
def sample(denoiser, c, n, keep=()):
"""역방향: x_T ~ N(0, I) 에서 시작해 t = T … 1 순서로 잡음을 걷어 낸다 (DDPM 샘플러).
x_{t-1} = (x_t - β_t / sqrt(1 - ᾱ_t) · ε_θ(x_t, t, c)) / sqrt(α_t) + σ_t z, σ_t² = β_t
"""
c = torch.as_tensor(c, dtype=torch.float32, device=device).expand(n, -1)
x = torch.randn(n, 2, device=device)
trace = []
for t in reversed(range(T)):
tt = torch.full((n,), t, device=device, dtype=torch.long)
eps_hat = denoiser(x, tt, c)
b, a, ab = betas[t].item(), alphas[t].item(), alpha_bars[t].item()
x = (x - b / math.sqrt(1 - ab) * eps_hat) / math.sqrt(a)
if t > 0:
x = x + math.sqrt(b) * torch.randn_like(x) # 마지막 단계에는 잡음을 더하지 않는다
if t in keep: # 보고 싶은 단계의 x_t 를 남겨 둔다 (그림용)
trace.append((t, x.cpu().numpy().copy()))
return x.cpu().numpy(), trace
물리 확인: simulate_batch 와 Pendulum.step 결과가 같습니다.
장치: cpu, ᾱ_T = 3.66e-04 (0 에 가까울수록 x_T 가 순수한 잡음)
데이터 200,000개 만들기: 0.2초
step 1000 확산 손실 0.2078 회귀 MSE 0.2710
step 2000 확산 손실 0.1627 회귀 MSE 0.2655
…
step 8000 확산 손실 0.1417 회귀 MSE 0.2688
학습: 130.8초
[near top, still] 회귀 예측 = (-0.237, -0.276), 원점에서 거리 0.363 | 확산 샘플의 원점 거리 평균 0.998
[hanging, still] 회귀 예측 = (-0.004, -0.939), 원점에서 거리 0.939 | 확산 샘플의 원점 거리 평균 1.000
[horizontal, moving] 회귀 예측 = (-0.745, +0.025), 원점에서 거리 0.746 | 확산 샘플의 원점 거리 평균 0.999
그림 저장: ch13-forward.png, ch13-futures.png, ch13-reverse.png
막대 끝은 늘 반지름 1 인 원 위에 있어야 한다. 확산 샘플은 원점 거리 평균이 0.998 ~ 1.000 으로 원 위에 놓이지만, 회귀 예측은 거리 0.36 ~ 0.94 로 원 안쪽, 즉 물리적으로 불가능한 곳을 가리킨다. 거의 서 있는 진자는 어느 쪽으로 얼마나 쓰러질지 몰라 미래가 원 둘레 전체로 퍼지고, 회귀는 그 평균인 원 안쪽 한 점을 낸다. 확산 샘플이 원 밖으로 조금 번지는 것은 작은 MLP 와 짧은 학습의 한계다.
- 그림: 정방향 과정. 원 위의 진짜 미래 위치들이 t = 100 에서 둥근 가우시안 잡음이 된다
- 그림: 세 가지 시작 상태에서 1초 뒤 막대 끝의 진짜 분포, 확산 샘플, MSE 회귀 예측 비교
- 그림: 역방향 과정. 잡음 덩어리가 마지막 몇 단계에서 빠르게 원 모양으로 모인다
MSE 를 최소화하는 예측은 가능한 미래들의 평균이다(\(\mathbb{E}[(X - c)^2]\) 를 \(c\) 로 미분하면 \(-2\mathbb{E}[X - c]\) 이고 0 으로 놓으면 \(c = \mathbb{E}[X]\)). 미래가 여러 갈래면 평균은 어느 갈래와도 닮지 않는다. 픽셀을 MSE 로 예측하는 World Model 에서는 이 평균이 여러 미래를 겹친 흐릿한 그림으로 나타난다. 확산 모델은 평균이 아니라 표본을 뽑으므로 미래가 불확실해도 또렷한 한 장면을 그린다. RSSM 이 잠재 변수를 확률적으로 둔 것도 같은 문제에 대한 다른 답이다.
DIAMOND 와 GameNGen
실제 확산 World Model 은 조건 자리에 최근 그림 몇 장과 행동들을 넣고 다음 그림 전체를 잡음에서 그려 낸다. \(k\) 는 잡음 단계, \(t\) 는 환경의 시각이다.
\(\epsilon_\theta\big( x^{(k)}_{t+1},\ k,\ o_{t-L+1}, \dots, o_t,\ a_{t-L+1}, \dots, a_t \big)\)
신경망이 맞히는 대상은 논문마다 다르다. GameNGen 은 잡음과 데이터를 섞은 "속도" \(v\) 를 맞히고(v-예측), DIAMOND 는 DDPM 대신 EDM(Karras et al., 2022) 방식으로 깨끗한 그림 쪽을 맞힌다. \(x_t\) 를 알면 \(\epsilon\), \(x_0\), \(v\) 는 서로 바꿔 쓸 수 있으므로 유도의 뼈대는 같다. DIAMOND 는 EDM 을 쓴 것이 적은 단계의 샘플링을 가능하게 했다고 보고한다.
DDPM 이후 대규모 World Model 에서 자주 보이는 이름 세 가지다.
- 흐름 맞추기(flow matching)(Lipman et al., 2022): 잡음과 데이터를 잇는 정해진 확률 경로를 따라 어느 방향으로 얼마나 움직일지를 나타내는 벡터장(속도)을 회귀로 맞힌다. v-예측과 가까운 생각이다.
- 확산 강제(diffusion forcing)(Chen et al., 2024): 시퀀스의 토큰(프레임)마다 서로 다른 잡음 수준을 독립적으로 주고 걷어 내도록 학습한다. 과거 프레임은 깨끗하게, 미래 프레임은 잡음에서 시작하는 식으로 "다음 프레임 예측"과 "시퀀스 전체 확산"을 한 모델로 잇는다.
- 지름길 모델(shortcut model)(Frans, Hafner, Levine, Abbeel, 2024): 신경망에 잡음 수준과 함께 한 번에 건너뛸 스텝 크기를 조건으로 주어, 따로 증류하지 않고 한 번 또는 몇 번의 샘플링으로 좋은 표본을 낸다. Dreamer 4 의 shortcut forcing 은 이 지름길 모델과 확산 강제를 이은 학습 목표다.
대표 모델은 다음과 같다.
- DIAMOND(Alonso et al., NeurIPS 2024 Spotlight): 확산 World Model 안에서 에이전트를 학습해 Atari 100k 평균 HNS 1.46(146%)을 보고했다(World Model 안에서만 학습한 에이전트로 당시 최고). 제목 "Visual Details Matter" 처럼 이산 토큰이나 흐린 재구성에서 사라지는 작은 시각 세부(예: 작은 총알)가 행동에 중요할 때 확산이 유리하다고 주장한다. 잡음 단계를 몇 단계만 쓰도록 설계를 다듬었고 같은 방법을 CS:GO 영상에도 키워 적용했다.
- GameNGen(Valevski et al., 2024, ICLR 2025): 강화학습 에이전트가 DOOM 을 하는 영상을 녹화하고 Stable Diffusion v1.4 를 고쳐 "지난 그림들 + 행동 → 다음 그림"을 예측하게 했다. TPU 한 장에서 초당 약 20프레임으로 게임을 신경망만으로 돌렸고, 사람 평가자들은 짧은 진짜 영상과 생성 영상을 우연보다 조금 나은 정도로만 구별했다.
드리프트 주의. 학습할 때는 조건으로 진짜 지난 그림을 넣지만 상상을 굴릴 때는 모델이 스스로 만든 그림이 다음 조건이 된다. 작은 오차가 다음 입력으로 들어가 커지는 것은 6장의 오차 누적과 같은 문제다. GameNGen 은 학습할 때 조건 그림에 일부러 가우시안 잡음을 섞어 조금 틀린 과거를 보고도 바로잡는 법을 배우게 했고, 이것이 긴 시간 화면을 안정시키는 데 결정적이었다고 보고한다.
| 장점 | 단점 |
| 여러 갈래의 미래를 또렷하게 그린다(흐려지지 않음). 작은 시각 세부를 잘 보존한다. 이미지 · 비디오 생성에서 검증된 기술 기반을 쓸 수 있다. | 그림 한 장에 잡음 제거를 여러 번 해야 해서 느리다(단계 수 × 프레임 수). 긴 시간 일관성이 어렵다(드리프트). 보상 · 가치는 따로 예측해야 한다. |
픽셀 대신 표현을 예측하기: JEPA
아이디어
바람에 흔들리는 나뭇잎의 위치나 물결의 모양 같은 세부는 본질적으로 예측할 수 없다. 픽셀을 맞히라고 하면 모델은 이런 세부에 용량을 낭비하거나 평균을 내 흐릿해진다. Yann LeCun 은 2022년 입장 논문 "A Path Towards Autonomous Machine Intelligence" 에서 JEPA(Joint-Embedding Predictive Architecture)를 제안했다. 입력 \(x\) 와 목표 \(y\) 를 각각 인코더로 표현 \(s_x, s_y\) 로 바꾸고 예측을 표현 공간에서 한다.
\(s_x = \text{Enc}_\theta(x), \qquad s_y = \text{Enc}_{\bar\theta}(y), \qquad \hat s_y = \text{Pred}_\theta(s_x,\ \text{조건}), \qquad E(x, y) = D\big(s_y,\ \hat s_y\big)\)
\(D\) 는 거리(예: L1 · L2)이고 \(E(x, y)\) 를 에너지(energy)라고 부른다. 잘 맞는 쌍은 에너지가 낮고 맞지 않는 쌍은 높도록 학습한다. World Model 로 쓸 때는 \(x\) = 지금 영상, 조건 = 행동, \(y\) = 미래 영상이다. 인코더가 예측할 수 없는 세부를 표현에서 뺄 수 있으므로 예측기는 물체의 위치 · 움직임 같은 예측 가능한 본질에 집중한다. 생성형(Dreamer · 확산)은 픽셀을 다시 만들어 픽셀끼리 비교하고, JEPA 는 두 인코더가 만든 표현끼리 비교한다. 목표 쪽 인코더는 EMA 목표이며 기울기를 차단한다.
붕괴와 방지 장치
두 인코더가 어떤 입력이든 같은 상수 벡터 \(\mathbf{c}\) 를 내고 예측기도 \(\mathbf{c}\) 를 내면 맞는 쌍이든 틀린 쌍이든 \(E(x, y) = D(\mathbf{c}, \mathbf{c}) = 0\) 이 된다. 아무것도 구별하지 못하는 모델이 손실을 가장 작게 만드는 표현 붕괴다. 재구성 손실이 있는 Dreamer 는 디코더가 \(\mathbf{c}\) 에서 서로 다른 그림을 복원할 수 없으므로 이 문제가 없다. 막는 방법은 다음과 같다.
- 대조 학습(contrastive): 맞지 않는 쌍(음성 표본)의 에너지를 일부러 올린다. 음성 표본이 많이 필요하다.
- EMA 목표 인코더 + 기울기 차단: 목표 쪽 인코더 \(\bar\theta\) 를 학습하지 않고 학습하는 인코더 \(\theta\) 의 지수 이동 평균(exponential moving average, EMA)으로 천천히 따라오게 한다. \(\bar\theta \leftarrow \tau\, \bar\theta + (1 - \tau)\, \theta\), \(\tau \approx 0.99 \sim 0.999\) 이다. BYOL 에서 시작해 I-JEPA, V-JEPA 가 쓴다.
- 분산 · 공분산 정규화: 표현의 각 성분이 표본들 사이에서 충분히 퍼져 있도록 벌점을 준다(VICReg).
- 등방성 가우시안 정규화: LeJEPA(Balestriero & LeCun, 2025년 11월)는 JEPA 의 표현이 따라야 할 가장 좋은 분포가 등방성 가우시안(모든 방향으로 같은 분산)이라는 이론을 내놓고, 표현을 그 분포 쪽으로 미는 정규화 항 SIGReg(sketched isotropic Gaussian regularization)를 제안했다. 표현이 한 점으로 뭉치면 가우시안에서 멀어져 벌점을 받는다. 기울기 차단도 교사-학생(EMA) 구조도 쓰지 않고 조절할 하이퍼파라미터도 하나뿐이라고 보고한다.
EMA 갱신 규칙을 끝까지 펼치면 과거 값들의 지수 가중 평균이다.
\(\begin{align} \bar\theta_n &= \tau\,\bar\theta_{n-1} + (1 - \tau)\,\theta_n \\ &= \tau^2 \bar\theta_{n-2} + (1-\tau)\big(\theta_n + \tau\,\theta_{n-1}\big) \\ &= (1 - \tau) \sum_{j=0}^{n-1} \tau^{j}\, \theta_{n-j} + \tau^{n}\, \bar\theta_0 \end{align}\)
최근 값일수록 큰 가중치를 받는다. 목표 인코더가 갑자기 변하지 않으므로 학습하는 쪽이 움직이는 과녁을 쫓다 같이 무너지는 일을 줄인다. 다만 왜 이것만으로 붕괴가 막히는지는 이론적으로 완전히 설명되지 않았다. \(\tau = 0.9\) 일 때 학습하는 쪽이 갑자기 1 에서 0 으로 바뀌면 목표는 \(0.9 \to 0.81 \to 0.729 \to 0.6561 \to 0.5905\) 로 천천히 따라간다.
VICReg 의 분산 항은 표현의 \(j\) 번째 성분의 배치 안 표준편차가 기준 \(\gamma\)(보통 1)보다 작으면 벌점을 준다.
\(v = \frac{1}{d}\sum_{j=1}^{d} \max\big(0,\ \gamma - \sqrt{\operatorname{Var}(s^{(j)}) + \varepsilon}\big)\)
붕괴하면 모든 성분의 분산이 0 이므로 벌점이 최대인 \(\gamma - \sqrt{\varepsilon} \approx 1\) 이 되어 붕괴 해가 최적이 아니게 된다.
I-JEPA · V-JEPA · V-JEPA 2 와 작은 모델들
- I-JEPA(Assran et al., CVPR 2023): 그림의 일부 블록을 가리고 보이는 부분의 표현으로 가린 블록들의 표현을 예측한다. 픽셀을 복원하지 않고 이미지 표현을 배운다.
- V-JEPA(Bardes et al., 2024): 같은 생각을 비디오로 넓혀 시공간에서 가린 부분의 표현을 예측한다.
- V-JEPA 2(Meta, 2025년 6월): 100만 시간이 넘는 인터넷 비디오로 약 10억 매개변수 규모의 인코더를 사전 학습한 뒤, 62시간이 안 되는 로봇 영상(DROID 데이터셋)으로 행동을 조건으로 받는 예측기 V-JEPA 2-AC 를 덧붙여 학습했다. 다른 두 실험실의 Franka 로봇 팔에서 그 환경의 데이터 없이(zero-shot) 목표 그림을 주고 물건을 집어 옮기는 계획에 성공했다고 보고했다.
- V-JEPA 2-AC 의 계획은 7장의 CEM 과 같은 방식이다. 행동열 후보를 뽑아 예측기로 미래 표현을 상상하고 목표 그림의 표현과의 거리(에너지)가 가장 작은 행동열을 고른다. 보상 함수가 없어도 목표 그림만으로 계획한다.
- DINO-WM(Zhou, Pan, LeCun, Pinto, 2024년 11월): 인코더를 새로 배우지 않고 미리 학습된 DINOv2 의 패치 특징을 그대로 가져와 오프라인 궤적에서 다음 패치 특징만 예측하도록 배운다. 그림을 재구성하지 않고 시험 때 행동열을 최적화해 목표 그림의 특징에 가까워지는 길을 찾는다(보상 모델 없이 zero-shot 계획).
- LeWorldModel(Maes, Le Lidec, Scieur, LeCun, Balestriero, 2026년 3월): 미리 학습된 인코더 없이 픽셀에서 끝까지 JEPA World Model 을 배운다. 손실은 "다음 임베딩 예측"과 "잠재를 가우시안 분포로 미는 정규화" 두 항뿐이고, 매개변수 약 1,500만 개 모델을 GPU 한 장에서 몇 시간에 학습하며, 미리 학습된 큰 모델에 기대는 World Model 보다 계획이 최대 48배 빠르다고 보고했다. 11장만 한 규모에서 JEPA 를 실험할 수 있다는 뜻이다.
| 장점 | 단점 |
| 예측할 수 없는 세부를 무시하므로 효율적이다. 보상 없는 대량의 비디오로 사전 학습할 수 있다. 목표 그림만으로 계획할 수 있다. | 붕괴를 막는 장치가 필요하다. 상상한 미래를 그림으로 볼 수 없어(디코더를 따로 붙여야 함) 디버깅이 어렵다. 표현이 행동에 필요한 정보를 담았는지 확인하기 어렵다. |
대규모 비디오 · 상호작용 World Model
2024년 무렵부터 "World Model"은 거대한 비디오 데이터로 학습해 사람이나 에이전트가 키보드 · 글로 조작하면 그에 맞는 세상을 실시간으로 그려 내는 생성 모델을 가리키는 말로도 널리 쓰인다. 튜토리얼의 World Model(에이전트를 위한 학습된 시뮬레이터)과 뿌리는 같지만 규모와 목적이 다르다.
무엇이 World Model 인가. 튜토리얼의 정의에서 World Model 은 행동을 받아 다음을 예측한다. 글 한 줄로 영상 한 편을 통째로 만드는 비디오 생성 모델은 행동 입력이 없으므로 그 자체로는 행동의 결과를 묻는 데 쓸 수 없다. 아래 모델들은 "행동(또는 조작)을 프레임마다 받는가"를 기준으로 보면 위치가 분명해진다.
Genie: 행동 라벨 없이 행동을 배우기
Genie(Bruce et al., ICML 2024)는 인터넷의 2D 플랫폼 게임 영상(약 3만 시간 분량으로 거른 것)으로 학습한 110억(11B) 매개변수의 "생성형 상호작용 환경"이다. 인터넷 영상에는 어떤 버튼을 눌렀는지가 기록되어 있지 않으므로 행동 자체를 영상에서 배운다.
- 비디오 토크나이저: 영상을 VQ 토큰으로 바꾼다.
- 잠재 행동 모델(LAM, latent action model): 지난 프레임들과 다음 프레임을 함께 보고 둘 사이의 변화를 설명하는 "행동" \(\tilde a_t\) 를 코드북 크기 8 인 VQ 로 뽑는다. 그리고 지난 프레임들과 \(\tilde a_t\) 만으로 다음 프레임을 복원하도록 학습한다.
- 동역학 모델: 지난 토큰들과 잠재 행동으로 다음 프레임의 토큰을 예측하는 Transformer 다.
잠재 행동이 행동다워지는 이유는 정보 병목이다. 코드 8개가 실어 나를 수 있는 정보의 최대량은 균등 분포일 때의 엔트로피다.
\(H(\tilde a) = -\sum_{i=1}^{8} p_i \log p_i \le \log 8 = 2.079\ \text{내트}, \qquad \log_2 8 = 3\ \text{비트}\)
프레임마다 3비트만 전할 수 있어 화면의 세부를 담기에는 부족하므로, 모델은 이 좁은 통로에 "왼쪽 · 오른쪽 · 점프"처럼 프레임 변화를 가장 많이 설명하는 정보, 즉 조작을 담게 된다.
동역학 모델은 계산을 줄이려고 시공간(ST) Transformer 를 쓴다. 프레임 \(T\) 장, 프레임마다 토큰 \(N\) 개일 때 모든 토큰끼리 어텐션하면 쌍의 수가 \((TN)^2\) 이지만, 같은 프레임 안끼리(공간)와 같은 위치의 다른 시각끼리(시간)로 나누면 \(T N^2 + N T^2\) 이다. \(T = 16\), \(N = 400\) 이면 \(40{,}960{,}000\) 대 \(2{,}662{,}400\) 으로 약 15배 적다.
Genie 2 · Genie 3 · Genie 4
- Genie 2(Google DeepMind, 2024년 12월): 그림 한 장에서 키보드 · 마우스로 조작할 수 있는 3D 세계를 만든다. DeepMind 는 자기회귀 잠재 확산 모델이라고 설명했고, 세계가 최대 1분 정도 일관되게 유지되며(대부분의 예시는 10 ~ 20초) 화면 밖으로 나갔던 부분을 기억했다가 다시 그린다고 소개했다.
- Genie 3(2025년 8월): 글로 묘사한 세계를 720p, 초당 24프레임으로 실시간 상호작용하며 몇 분 동안 일관되게 유지하고, 날씨 바꾸기 · 물체 넣기 같은 "세계 사건"을 글로 일으킬 수 있다고 발표했다. 2026년 1월에는 이를 바탕으로 한 실험적 서비스 Project Genie 가 미국의 일부 유료 구독자에게 열렸다.
- Genie 4(2026년 10월): 연구 미리보기로 공개되었다. 세계에 맞는 소리를 실시간으로 함께 만들고 세션 중에 글로 장면을 바꿀 수 있다고 소개되었다. 해상도 · 프레임률 같은 세부 수치는 공개되지 않았고 긴 세션에서는 세부가 흐트러질 수 있다는 한계도 함께 밝혔다.
Sora, Cosmos, 자율주행 World Model
- Sora(OpenAI, 2024년 2월): 기술 보고서 "Video generation models as world simulators" 에서 비디오 생성 모델을 크게 키우면 물리 세계의 시뮬레이터가 될 수 있다고 주장했다. 시공간 패치를 토큰으로 쓰는 확산 Transformer 다. 보고서는 유리가 깨지는 것 같은 기본적인 물리 상호작용을 정확히 흉내 내지 못하는 한계도 밝혔다. "규모만 키우면 물리를 이해하게 되는가"는 논쟁 중인 질문이다.
- NVIDIA Cosmos(2025년 1월): 로봇 · 자율주행 같은 물리 AI 개발용 World Foundation Model 모음이다. 확산 방식과 자기회귀(다음 토큰 예측) 방식의 모델, 비디오 토크나이저를 함께 공개했고 약 2천만 시간 분량의 비디오를 학습 데이터로 다뤘다고 발표했다. 개발자가 자기 로봇 · 차량 데이터로 미세 조정해 합성 데이터를 만드는 용도를 내세운다.
- GAIA-1 · GAIA-2(Wayve, 2023 · 2025): 자율주행용 생성 World Model 이다. GAIA-1 은 영상 · 글 · 행동을 토큰으로 바꿔 다음 토큰을 예측했고, GAIA-2 는 잠재 확산 방식으로 바꿔 자기 차량의 움직임 · 주변 차량 · 날씨 · 도로 배치를 조건으로 여러 카메라 시점의 영상을 함께 생성한다. 위험한 상황을 실제로 겪지 않고 만들어 시험하는 데 쓴다.
- UniSim(Yang et al., ICLR 2024 우수 논문상): "서랍을 열어" 같은 고수준 지시와 로봇의 저수준 조작 모두의 시각적 결과를 흉내 내는 실세계 시뮬레이터를 학습하고, 그 안에서만 학습한 정책이 실제 세계로 바로 옮겨 가는 것(zero-shot transfer)을 보였다.
에이전트 쪽의 흐름: DayDreamer · Dreamer 4 · World Action Model
- DayDreamer(Wu et al., CoRL 2022): 12장의 Dreamer 를 시뮬레이터 없이 실제 로봇에서 바로 학습시켰다. 4족 보행 로봇 A1 이 리셋 없이 약 1시간 만에 등을 대고 누운 자세에서 뒤집어 일어나 걷는 법을 배웠고, 로봇 팔은 카메라 영상과 드문 보상으로 물건 집어 옮기기를, 바퀴 로봇은 카메라 영상만으로 목표 찾아가기를 배웠다. World Model 의 표본 효율이 실제로 의미 있음을 보인 사례다.
- Dreamer 4(Hafner, Yan, Lillicrap, 2025년 9월): 확장 가능한 Transformer World Model 과 새 학습 목표 shortcut forcing(지름길 모델과 확산 강제를 이어 적은 샘플링 스텝으로 다음 프레임을 만들게 하는 목표)으로 GPU 한 장에서 실시간으로 상상을 굴릴 수 있게 했다. 환경과 전혀 상호작용하지 않은 채 오프라인 데이터만으로 Minecraft 에서 다이아몬드를 얻은 첫 에이전트라고 보고했다. 다이아몬드까지는 마우스 · 키보드 행동을 2만 번 넘게 이어야 한다.
- World Action Model: DreamZero(Ye et al., 2026년 2월): World Model 을 정책을 기르는 시뮬레이터로 쓰지 않고 World Model 자체를 정책으로 쓴다. 미리 학습된 비디오 확산 모델을 바탕으로 미래 영상과 로봇 행동을 함께 예측하도록 학습한다. 영상을 예측하려면 세상이 어떻게 움직이는지 알아야 하므로 그 지식이 행동 예측으로 옮겨 간다는 생각이다. 실제 로봇 실험에서 기존 VLA(vision-language-action) 모델보다 새 과제 · 새 환경으로의 일반화가 2배 넘게 좋아졌고, 매개변수 140억 개의 자기회귀 비디오 확산 모델로 초당 7번의 닫힌 고리 제어를 했다고 보고했다. 7장의 "모델로 상상해서 고른다"와 12장의 "정책을 따로 배운다" 사이의 경계가 흐려지는 지점이다.
계열 비교
| 계열 | 대표 | 무엇을 예측 | 잠재 · 표현 | 학습 목표 | 쓰는 법 | 데이터 규모(대략) |
| VAE + RNN | Ha & Schmidhuber (10장) | 픽셀 재구성 + 다음 잠재 | 가우시안 \(z\) + LSTM | VAE ELBO, MDN 가능도 | 꿈속 진화 전략 | 약 1만 에피소드(무작위 롤아웃 10,000개) |
| RSSM | PlaNet · Dreamer (11 · 12장) | 픽셀 재구성 · 보상 | 결정 \(h\) + 확률 \(z\) | 순차 ELBO | CEM 계획 / 상상 속 액터-크리틱 | 수십만 ~ 수백만 스텝 |
| 가치 등가 | MuZero · EfficientZero | 보상 · 가치 · 정책 | 은닉 상태(디코더 없음) | K 스텝 펼친 손실 | MCTS | Atari 100k ~ 수십억 프레임 |
| 디코더 없는 잠재 | TD-MPC2 | 보상 · Q · 다음 잠재 | SimNorm 잠재 | 보상 + TD + 잠재 일관성 | MPPI + Q | 과제당 수십만 ~ 수백만 스텝 |
| 토큰 + Transformer | IRIS · TWM · STORM | 다음 토큰 · 보상 | VQ 토큰 / 범주 잠재 | 교차 엔트로피 | 상상 속 액터-크리틱 | Atari 100k(약 2시간) |
| 확산 | DIAMOND · GameNGen | 다음 그림(픽셀) | 픽셀 그대로 또는 잠재 | 잡음 제거(ε · v · x₀ 예측) | 상상 학습 / 게임 엔진 대체 | Atari 100k ~ 대규모 게임 녹화 |
| 표현 예측 | V-JEPA 2 | 미래의 표현 | 자기 지도 표현 | 표현 거리 + 붕괴 방지 | 목표 그림으로 CEM 계획 | 비디오 100만 시간 이상, 로봇 62시간 미만 |
| 대규모 비디오 | Genie · Sora · Cosmos · GAIA | 다음 프레임 · 영상 | 비디오 토큰 · 잠재 | 다음 토큰 / 확산 | 사람 · 에이전트의 시뮬레이터, 합성 데이터 | 수만 ~ 수천만 시간 |
| World Action Model | DreamZero | 미래 영상 + 행동 | 비디오 확산 모델의 잠재 | 영상 · 행동을 함께 잡음 제거 | 모델이 곧 정책(예측한 행동을 실행) | 사전 학습된 비디오 모델 + 로봇 데이터 |
진자로 다시 보기
같은 진자 문제를 각 계열이 다루는 방식이다.
- Dreamer(12장): 64×64 그림을 RSSM 잠재로 바꾸고 그림을 재구성하며 배운다. 배경이 없는 단순한 그림이라 재구성 손실이 큰 낭비는 아니다.
- MuZero: 그림을 보지만 다시 그리지 않고 보상 · 가치 · 정책만 맞힌다. MCTS 는 이산 행동에 맞으므로 토크를 \(\{-2, -1, 0, 1, 2\}\) 처럼 나눠야 한다. 초반에는 거의 늘 큰 음의 보상을 받아 어느 상태가 더 좋은지의 신호가 약하므로 은닉 상태를 가르치기 어렵다(EfficientZero 의 일관성 손실이 도움이 된다).
- TD-MPC: 숫자 상태 \([\cos\theta, \sin\theta, \dot\theta]\) 든 그림이든 잠재로 바꾸고 5 스텝 정도만 상상한 뒤 나머지는 Q 로 메운다. 7장의 MPC 는 25 스텝을 상상했다.
- IRIS: 64×64 그림을 토큰 16개로 바꾼다. 막대는 몇 개의 토큰에만 걸치므로 각도의 작은 차이가 토큰으로 잘 구별되는지가 성패를 가른다.
- 확산: 이 장의 실습이 그 모습이다. 서 있는 진자가 어느 쪽으로 쓰러질지 모를 때도 흐린 평균 대신 또렷한 한 갈래의 미래를 그린다.
- JEPA: "막대가 똑바로 선 그림"을 목표로 주고 표현 공간에서 그 목표와의 거리를 줄이는 토크열을 CEM 으로 찾는다. 보상 함수를 따로 정의할 필요가 없다.
- Genie 식 학습: 토크 기록이 없는 진자 영상만 있어도 잠재 행동 모델이 "왼쪽으로 밀기 · 오른쪽으로 밀기 · 가만히" 같은 몇 가지 코드를 스스로 찾아낼 것이다.
아직 풀리지 않은 문제
- 긴 시간 일관성: 6장의 오차 누적은 거대한 모델에서도 사라지지 않는다. Genie 2 · 3 · 4 가 일관성 유지 시간을 "분" 단위로 늘린 것 자체가 큰 성과로 발표될 만큼 어렵다.
- 인과 · 물리의 이해: 그럴듯해 보이는 영상과 물리적으로 맞는 영상은 다르다(Sora 의 유리 예). 행동의 결과를 틀리게 예측하면 계획에 쓸 수 없다.
- 평가: 생성 품질 지표(픽셀 오차로 재는 PSNR, 영상 분포 사이의 거리로 재는 FVD 등)가 높다고 그 안에서 학습한 정책이 실제로 잘 움직인다는 보장은 없다. "보기 좋은가"와 "쓸모 있는가"를 함께 재는 방법이 부족하다.
- 모델 착취: 10장에서 본 것처럼 정책은 World Model 의 틈(실제와 다른 곳)을 찾아 꿈속에서만 통하는 꼼수를 배운다. 모델이 클수록 틈은 줄지만 사라지지 않는다.
- 계산 비용: 확산 모델의 여러 잡음 제거 단계, Transformer 의 긴 문맥은 실시간 상호작용과 상상 학습을 비싸게 만든다. 적은 단계로 생성하는 기법(Dreamer 4 의 shortcut 등)이 연구되고 있다.
- 안전과 실제 세계로의 이전: 로봇 · 자율주행에서는 World Model 이 틀린 곳에서의 실패가 실제 사고가 된다. 불확실성 추정(7장의 앙상블)과 보수적인 계획이 여전히 중요하다.
정리
- 현대 World Model 은 무엇을 예측하나 · 잠재의 모양 · 시간 연결 도구 · 쓰는 법 · 규모로 나눠 보면 정리된다.
- MuZero: 보상 · 가치 · 정책만 맞히는 가치 등가 모델 + MCTS 다. 가치 목표는 n-스텝 리턴 \(\sum_{i \lt n}\gamma^i r_{t+i} + \gamma^n v(s_{t+n})\) 이다.
- TD-MPC: 디코더 없이 보상 + TD + 잠재 일관성으로 학습하고 짧은 상상 + Q 로 계획한다. MPPI 가중치 \(\exp(J/\tau)\) 는 "기대 점수 − τ·KL" 최대화의 해다.
- Transformer World Model: VQ 로 그림을 토큰으로 바꾸고(직선 통과 추정기) 연쇄 규칙으로 다음 토큰을 예측한다. 어텐션 점수는 분산을 1 로 맞추려 \(\sqrt{d}\) 로 나눈다.
- 확산 World Model: \(x_t = \sqrt{\bar\alpha_t}x_0 + \sqrt{1-\bar\alpha_t}\epsilon\), 역방향 평균 \(\frac{1}{\sqrt{\alpha_t}}(x_t - \frac{\beta_t}{\sqrt{1-\bar\alpha_t}}\epsilon)\), 학습은 잡음 예측 MSE 다. 평균이 아니라 표본을 내므로 흐려지지 않는다.
- JEPA: 표현 공간에서 예측해 예측할 수 없는 세부를 버린다. 붕괴를 EMA 목표 · 분산 정규화로 막는다.
- 대규모 모델(Genie · Sora · Cosmos · GAIA)은 행동 · 조작을 프레임마다 받을 때 비로소 튜토리얼이 말하는 World Model 이 되고, 긴 일관성 · 물리 · 평가가 남은 과제다.
확인 문제
- 문제 1. \(\gamma = 0.5\), \(n = 2\), 보상 \(r_t = 4\), \(r_{t+1} = 2\), \(v(s_{t+2}) = 8\) 일 때 n-스텝 목표 \(z_t\) 는 얼마인가.
- \(z_t = 4 + 0.5 \times 2 + 0.5^2 \times 8 = 4 + 1 + 2 = 7\) 이다.
- 문제 2. 점수 \(J = (3, 1)\) 인 두 후보의 MPPI 가중치를 \(\tau = 1\), \(\tau \to 0\), \(\tau \to \infty\) 에서 구한다.
- \(\tau = 1\) 이면 \((1,\ e^{-2}) = (1,\ 0.1353)\) 을 합 \(1.1353\) 으로 나눠 \(w = (0.881,\ 0.119)\) 다. \(\tau \to 0\) 이면 \(\exp((J_i - J_{\max})/\tau)\) 에서 최고 점수가 아닌 후보의 지수가 \(-\infty\) 로 가서 \(w = (1, 0)\), 즉 argmax 다. \(\tau \to \infty\) 이면 지수가 모두 0 으로 가서 \(w = (0.5, 0.5)\), 즉 점수를 무시한 단순 평균이다.
- 문제 3.
z_tilde = z_e + (z_q - z_e).detach()의 순전파 값과z_e에 대한 기울기는 무엇이고,.detach()를 빼면 어떻게 되는가. - 값은 \(z_e + z_q - z_e = z_q\) 이고 기울기는 \(\partial \tilde z/\partial z_e = I\) 라서 디코더 쪽 기울기가 그대로 인코더로 간다.
.detach()를 빼면 \(\tilde z = z_q\) 가 되어 기울기가 \(\partial z_q / \partial z_e = 0\) 이므로 인코더가 학습되지 않는다. - 문제 4. 질의 · 열쇠의 성분이 평균 0, 분산 \(\sigma^2\) 인 독립 확률 변수라면 점수 \(q \cdot k\) 의 분산을 1 로 만들려면 무엇으로 나눠야 하는가.
- \(\operatorname{Var}(q_i k_i) = \mathbb{E}[q_i^2]\mathbb{E}[k_i^2] = \sigma^4\), 합의 분산은 \(d\sigma^4\) 이므로 \(\sigma^2\sqrt{d}\) 로 나눈다.
- 문제 5. \(\beta_1 = 0.2\), \(\beta_2 = 0.5\), \(x_0 = 1\) 일 때 \(q(x_2 \mid x_0)\) 의 평균과 분산을 구한다.
- \(\alpha_1 = 0.8\), \(\alpha_2 = 0.5\), \(\bar\alpha_2 = 0.4\) 이므로 평균 \(\sqrt{0.4} = 0.632\), 분산 \(0.6\) 이다. 한 스텝씩 따라가도 \(\operatorname{Var}(x_1) = 0.2\), \(\operatorname{Var}(x_2) = 0.5 \times 0.2 + 0.5 = 0.6\) 으로 같다.
- 문제 6. JEPA 에서 목표 인코더를 EMA 로 두지 않고 같은 매개변수를 쓰며 양쪽으로 기울기를 흘리면 어떤 문제가 생기고, 재구성형에는 왜 이 문제가 없는가.
- 두 인코더가 함께 움직이며 모든 입력을 같은 벡터로 보내는 붕괴 해(에너지가 모든 쌍에서 0)로 빠지기 쉽다. 재구성형은 잠재 상태에서 원래 그림을 복원해야 하므로 모든 입력을 같은 잠재로 보내면 재구성 손실이 커진다. 디코더가 붕괴를 막는다.
See also
- World Models:Tutorial
- World Models
- World Models:Tutorial:12 Dreamer
- World Models:Tutorial:14 부록
- Genie (world model)
- GameNGen
- Sora
- Waymo World Model
- Physical AI
- Diffusion model
- Transformer
- VAE
- Reinforcement learning
Favorite site
- 13. 현대 World Model 지형도
- MuZero: Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model (Schrittwieser et al.)
- EfficientZero: Mastering Atari Games with Limited Data (Ye et al.)
- TD-MPC (Hansen et al.)
- TD-MPC2
- VQ-VAE (van den Oord et al.)
- Transformer (Vaswani et al.)
- IRIS
- TWM
- STORM
- DDPM: Denoising Diffusion Probabilistic Models (Ho et al.)
- Flow matching (Lipman et al.)
- Diffusion forcing (Chen et al.)
- Shortcut model (Frans et al.)
- DIAMOND
- GameNGen
- A Path Towards Autonomous Machine Intelligence (LeCun)
- I-JEPA
- V-JEPA
- V-JEPA 2
- LeJEPA
- DINO-WM
- LeWorldModel
- Genie
- Genie 2 (DeepMind 블로그)
- Genie 3 (보도)
- Project Genie (보도)
- Genie 4 (Google 블로그)
- Genie (DeepMind 모델 페이지)
- Video generation models as world simulators (OpenAI)
- NVIDIA Cosmos
- GAIA-1
- GAIA-2
- UniSim
- DayDreamer
- Dreamer 4
- DreamZero: World Action Models are Zero-shot Policies (Ye et al.)