WorldModels:Tutorial:05-ReinforcementLearning
lastmod 2026-11-18created 2026-11-172 edits
강화학습 기초는 World Model 튜토리얼의 5장이다. World Model 은 언제나 "어떻게 행동해야 보상을 많이 받는가"를 푸는 에이전트 곁에서 쓰이므로, 그 문제를 수학으로 쓰는 틀인 강화학습을 MDP, 리턴과 할인, 가치 함수, 벨만 방정식 순서로 유도한다. 격자 세계에서 가치 반복을 돌리고 정책 경사(REINFORCE)를 유도해 학습시킨 뒤, 진자 문제를 강화학습으로 정식화해 6 · 7장의 World Model 이 넘어야 할 기준 점수를 구한다.
- 원문: 05. 강화학습 기초
- 실습 코드:
code/ch05_rl_basics.py(numpy · matplotlib 만 쓴다.wm_envs.py와 같은 폴더에서python ch05_rl_basics.py로 전체 약 5~10초,--quick은 축소판. 그림은figures/에 저장된다) - 이전: 04. 딥러닝과 PyTorch 기초 / 다음: 06. 첫 번째 World Model
에이전트와 환경
강화학습(reinforcement learning, RL)은 시행착오로 배우는 법을 다룬다. 행동을 고르는 에이전트(agent)와 그 행동에 반응하는 환경(environment)이 시간 \(t = 0, 1, 2, \dots\) 마다 같은 고리를 되풀이한다. 에이전트는 상태 \(s_t\) 를 보고 정책 \(\pi(a \mid s)\) 로 행동 \(a_t\) 를 고르고, 환경은 규칙 \(p(s' \mid s, a)\) 와 보상 함수에 따라 다음 상태 \(s_{t+1}\) 과 보상 \(r_t\) 를 돌려준다.
| 용어 | 뜻 | 진자에서는 |
| 상태(state) \(s_t\) | 지금 세상의 모든 사정 | 각도와 각속도 \((\theta, \dot\theta)\) |
| 행동(action) \(a_t\) | 에이전트가 고르는 것 | 토크 \(u \in [-2, 2]\) |
| 보상(reward) \(r_t\) | 그 행동이 얼마나 좋았는지 나타내는 숫자 하나 | \(-(\theta^2 + 0.1\dot\theta^2 + 0.001u^2)\) |
| 정책(policy) \(\pi\) | 상태에서 행동으로 가는 규칙 | 예: "기울어진 반대쪽으로 민다" |
| 에피소드(episode) | 시작부터 끝까지 한 판 | 200 스텝(10초) |
| 궤적(trajectory) \(\tau\) | 한 판의 기록 \((s_0, a_0, r_0, s_1, a_1, r_1, \dots)\) | |
정책에는 두 종류가 있다. 결정적 정책 \(a = \mu(s)\) 는 같은 상태에서 늘 같은 행동을 내고, 확률적 정책 \(a \sim \pi(a \mid s)\) 는 행동을 확률로 뽑는다. 탐험이 필요하고 미분하기도 편해서 학습에는 주로 확률적 정책을 쓴다. 예를 들어 \(\pi(a \mid s) = \mathcal{N}(a;\ \mu_\psi(s), \sigma^2)\) 는 신경망이 정한 평균 근처에서 행동을 뽑는 정책이다.
정답 행동을 알려 주는 선생은 없고 보상이라는 점수만 받으며, 그 점수는 늦게 온다. 진자를 세우려면 처음에는 보상이 나빠지더라도 반대로 흔들어야 한다. 강화학습의 목표는 당장의 보상이 아니라 앞으로 받을 보상의 합을 최대로 하는 정책을 찾는 것이다.
마르코프 성질과 MDP
다음에 일어날 일이 현재만으로 정해지고 과거의 경로와 무관하다는 성질을 마르코프 성질(Markov property)이라 한다.
\(p(s_{t+1} \mid s_t, a_t, s_{t-1}, a_{t-1}, \dots, s_0) = p(s_{t+1} \mid s_t, a_t)\)
진자에서 \((\theta, \dot\theta)\) 를 알면 다음 순간은 물리 법칙으로 정해지므로 이것은 마르코프 상태다. 각도 \(\theta\) 만으로는 도는 방향을 알 수 없어 마르코프가 아니다. 이 구별이 뒤의 부분 관측 문제와 9 · 11장의 "기억"으로 이어진다.
마르코프 성질을 만족하는 의사결정 문제가 마르코프 결정 과정(Markov decision process, MDP)이고 다섯 가지로 정의한다.
\(\text{MDP} = (\mathcal{S},\ \mathcal{A},\ p,\ r,\ \gamma)\)
- \(\mathcal{S}\) 는 가능한 상태의 집합, \(\mathcal{A}\) 는 가능한 행동의 집합이다.
- \(p(s' \mid s, a)\) 는 전이 확률이다. 세상의 규칙에 해당하며 World Model 이 배우려는 대상이다.
- \(r(s, a)\) (또는 \(r(s, a, s')\))는 보상 함수다.
- \(\gamma \in [0, 1)\) 는 할인율이다.
궤적의 확률 분해
시작 상태 분포 \(\rho_0(s_0)\) 를 더하면 정책 \(\pi\) 를 따를 때 궤적 하나가 나올 확률을 쓸 수 있다. 결합 확률에 곱셈 법칙을 시간 순서대로 되풀이한 뒤(연쇄 법칙), 정책은 현재 상태만 보고 환경은 현재 상태와 행동만 본다는 점으로 긴 조건을 줄인다.
\(\begin{align} p(\tau) &= p(s_0)\, p(a_0 \mid s_0)\, p(s_1 \mid s_0, a_0)\, p(a_1 \mid s_0, a_0, s_1) \cdots \\ p_\pi(\tau) &= \rho_0(s_0)\prod_{t=0}^{T-1} \pi(a_t \mid s_t)\; p(s_{t+1} \mid s_t, a_t) \end{align}\)
궤적 확률은 시작 확률에 (정책 확률 × 전이 확률)을 곱한 것이다. 이 식이 정책 경사 유도의 재료가 된다.
리턴과 할인
시각 \(t\) 부터 앞으로 받을 보상의 할인된 합을 리턴(return) \(G_t\) 라고 한다.
\(G_t = r_t + \gamma r_{t+1} + \gamma^2 r_{t+2} + \cdots = \sum_{k=0}^{\infty} \gamma^k\, r_{t+k}\)
할인율(discount factor) \(\gamma\) 는 미래의 보상을 지금 가치로 얼마나 깎을지를 정한다. \(\gamma = 0.9\) 면 한 스텝 뒤의 보상 1 은 지금의 0.9, 두 스텝 뒤는 0.81 이다. 할인하는 이유는 세 가지다.
- 수학: 끝없이 이어지는 문제에서도 합이 유한해진다.
- 불확실성: 먼 미래일수록 예측이 부정확하다. \(\gamma\) 를 매 스텝 살아남을 확률로 볼 수도 있다.
- 선호: 같은 보상이면 빨리 받는 쪽이 낫다. 격자 세계에서 지름길을 고르게 만든다.
등비급수와 유효 지평
\(S_n = 1 + \gamma + \cdots + \gamma^{n-1}\) 에 \(\gamma\) 를 곱해 빼면 가운데 항이 모두 지워진다.
\(\begin{align} S_n - \gamma S_n &= 1 - \gamma^n \quad\Rightarrow\quad S_n = \frac{1 - \gamma^n}{1 - \gamma} \\ \sum_{k=0}^{\infty}\gamma^k &= \lim_{n\to\infty}\frac{1-\gamma^n}{1-\gamma} = \frac{1}{1-\gamma} \qquad (0 \le \gamma \lt 1) \end{align}\)
\(\gamma = 0.9\) 면 10, \(\gamma = 0.99\) 면 100 이다. 보상이 늘 \(\vert r \vert \le R_{\max}\) 이면 \(\vert G_t \vert \le \frac{R_{\max}}{1-\gamma}\) 로 리턴이 유한하다.
\(k\) 스텝 뒤 보상의 가중치 \(\gamma^k\) 가 \(e^{-1} \approx 0.37\) 로 줄어드는 \(k\) 를 유효 지평이라 부른다. \(\gamma^k = e^{k\log\gamma}\) 이고 \(\gamma\) 가 1 에 가까우면 1차 테일러 근사 \(\log(1-x) \approx -x\) 로 \(\log\gamma \approx -(1-\gamma)\) 이므로 다음이 나온다.
\(\gamma^k \approx e^{-k(1-\gamma)} = e^{-1} \quad\Longleftrightarrow\quad k \approx \frac{1}{1-\gamma}\)
\(\gamma = 0.99\) 면 약 100 스텝이다(\(0.99^{100} = 0.366\), \(e^{-1} = 0.368\)). 0.05초 간격의 진자에서는 약 5초 앞까지 본다는 뜻이다.
리턴의 재귀식
둘째 항부터 \(\gamma\) 하나를 묶으면 괄호 안이 \(t+1\) 부터의 리턴이 된다.
\(G_t = r_t + \gamma\big(r_{t+1} + \gamma r_{t+2} + \gamma^2 r_{t+3} + \cdots\big) = r_t + \gamma\, G_{t+1}\)
이 식이 벨만 방정식, TD 학습, 12장 λ-리턴의 출발점이다. 재귀식 덕분에 리턴을 뒤에서부터 한 번에 계산할 수 있다. 보상 \((1, 0, 0, 5)\), \(\gamma = 0.9\) 이면 \(G_3 = 5\), \(G_2 = 4.5\), \(G_1 = 4.05\), \(G_0 = 1 + 0.9 \times 4.05 = 4.645\) 이고, 직접 더한 \(1 + 0.9^3 \times 5 = 4.645\) 와 같다.
def discounted_returns(rewards, gamma):
"""G_t = r_t + γ·G_{t+1} 를 뒤에서부터 계산한다. 결과는 rewards 와 길이가 같다."""
G = np.zeros(len(rewards))
running = 0.0 # 에피소드가 끝난 뒤의 리턴은 0
for t in reversed(range(len(rewards))):
running = rewards[t] + gamma * running
G[t] = running
return G
보상 : [1.0, 0.0, 0.0, 5.0]
리턴 G_t : [4.645, 4.05, 4.5, 5.0]
G_0 직접 계산: 4.6450000000000005
γ=0.9: 보상 1 을 5000번 받은 리턴 = 10.0000, 1/(1−γ) = 10.0000
γ=0.99: 보상 1 을 5000번 받은 리턴 = 100.0000, 1/(1−γ) = 100.0000
4.6450000000000005 의 끝자리는 0.9 를 2진 실수로 정확히 표현하지 못해 생기는 오차다.
가치 함수
리턴은 정책과 환경의 우연에 따라 판마다 다르므로 그 기댓값으로 상태의 좋고 나쁨을 잰다.
\(\begin{align} V^\pi(s) &= \mathbb{E}_\pi\big[\,G_t \mid s_t = s\,\big] \\ Q^\pi(s, a) &= \mathbb{E}_\pi\big[\,G_t \mid s_t = s,\ a_t = a\,\big] \end{align}\)
상태 가치 \(V^\pi(s)\) 는 \(s\) 에서 시작해 \(\pi\) 를 따를 때의 평균 리턴이고, 행동 가치 \(Q^\pi(s, a)\) 는 \(s\) 에서 일단 \(a\) 를 하고 그 뒤로 \(\pi\) 를 따를 때의 평균 리턴이다. 진자에서 거의 서 있고 천천히 움직이는 상태는 \(V\) 가 0 에 가깝고, 아래로 매달려 빠르게 도는 상태는 큰 음수다. 첫 행동으로 경우를 나누는 전체 기댓값의 법칙(law of total expectation)을 쓰면 둘의 관계가 나온다.
\(V^\pi(s) = \sum_a p(a_t = a \mid s_t = s)\;\mathbb{E}[G_t \mid s_t = s, a_t = a] = \sum_a \pi(a \mid s)\, Q^\pi(s, a)\)
상태 가치는 행동 가치의 정책 가중 평균이다.
벨만 기대 방정식
가치 함수의 정의에 리턴의 재귀식을 넣으면 무한한 미래의 평균이 한 스텝만 보는 방정식으로 바뀐다. 이것이 벨만 방정식(Bellman equation)이다. 유도에 쓰는 성질은 기댓값의 선형성, 전체 기댓값의 법칙, 마르코프 성질 세 가지다.
\(\begin{align} V^\pi(s) &= \mathbb{E}_\pi\big[\, r_t + \gamma G_{t+1} \mid s_t = s \,\big] \\ &= \mathbb{E}_\pi[\, r_t \mid s_t = s\,] + \gamma\,\mathbb{E}_\pi[\, G_{t+1} \mid s_t = s\,] \\ &= \sum_a \pi(a\mid s)\sum_{s'} p(s'\mid s, a)\,\Big( r(s,a,s') + \gamma\,\mathbb{E}_\pi[\,G_{t+1} \mid s_t = s, a_t = a, s_{t+1} = s'\,]\Big) \end{align}\)
둘째 줄은 선형성 \(\mathbb{E}[X + cY] = \mathbb{E}[X] + c\,\mathbb{E}[Y]\), 셋째 줄은 첫 행동 \(a\) 와 다음 상태 \(s'\) 로 경우를 나눈 것이다. 마르코프 성질에 따라 \(s_{t+1} = s'\) 를 알면 그 이후는 그 전의 상태 · 행동과 무관하고, 정책도 시간에 따라 바뀌지 않으므로 안쪽 기댓값은 \(s'\) 의 가치다.
\(\mathbb{E}_\pi[\,G_{t+1} \mid s_t = s, a_t = a, s_{t+1} = s'\,] = \mathbb{E}_\pi[\,G_{t+1} \mid s_{t+1} = s'\,] = V^\pi(s')\)
\(V^\pi(s) = \sum_a \pi(a \mid s)\sum_{s'} p(s' \mid s, a)\,\big[\, r(s, a, s') + \gamma\, V^\pi(s')\,\big]\)
지금 상태의 가치는 (지금 보상 + 할인된 다음 상태의 가치)의 평균이다. \(Q\) 는 첫 행동이 정해져 있으므로 바깥의 \(\pi(a \mid s)\) 평균이 없다.
\(Q^\pi(s, a) = \sum_{s'} p(s' \mid s, a)\,\big[\, r(s, a, s') + \gamma\, V^\pi(s')\,\big] = \sum_{s'} p(s'\mid s,a)\Big[\, r + \gamma\sum_{a'}\pi(a'\mid s')\,Q^\pi(s', a')\Big]\)
2×3 격자로 확인
위 줄 A, B, G 와 아래 줄 C, D, E 로 된 격자에서 G 가 목표다. 행동은 위 · 아래 · 왼쪽 · 오른쪽이고 벽으로 가면 제자리에 머문다. G 로 들어가면 보상 +1 을 받고 끝나며 다른 이동의 보상은 0, \(\gamma = 0.9\), 이동은 결정적이다. 정책을 "A · B · C · D 에서는 오른쪽, E 에서는 위"로 두면 합이 모두 항 하나로 줄어든다.
\(\begin{align} V^\pi(B) &= r(B, \rightarrow, G) + \gamma V^\pi(G) = 1 + 0.9 \times 0 = 1, \qquad V^\pi(E) = 1 \\ V^\pi(A) &= 0 + 0.9\, V^\pi(B) = 0.9, \qquad V^\pi(D) = 0 + 0.9\, V^\pi(E) = 0.9 \\ V^\pi(C) &= 0 + 0.9\, V^\pi(D) = 0.81 \end{align}\)
G 는 끝 상태라 가치가 0 이고, 목표에서 멀수록 \(\gamma\) 가 한 번씩 더 곱해진다. 이 값은 아래에서 구하는 최적 가치와 같다.
벨만 최적 방정식과 가치 반복
가장 좋은 정책 \(\pi^\ast\) 를 따를 때의 가치가 최적 가치 \(V^\ast(s) = \max_\pi V^\pi(s)\), \(Q^\ast(s,a) = \max_\pi Q^\pi(s,a)\) 다. 최적 정책은 매 순간 가장 좋은 행동을 고르므로 벨만 기대 방정식의 정책 평균이 \(\max\) 로 바뀐다. 이것이 벨만 최적 방정식(Bellman optimality equation)이다.
\(\begin{align} V^\ast(s) &= \max_a \sum_{s'} p(s' \mid s, a)\,\big[\, r(s,a,s') + \gamma\, V^\ast(s')\,\big] \\ Q^\ast(s, a) &= \sum_{s'} p(s' \mid s, a)\,\big[\, r(s,a,s') + \gamma \max_{a'} Q^\ast(s', a')\,\big] \end{align}\)
\(V^\ast\) 를 알면 \(\sum_{s'} p(s'\mid s,a)[r + \gamma V^\ast(s')]\) 가 가장 큰 행동을 고르는 것이 최적 정책이다. 단, 이 계산에는 전이 확률 \(p(s'\mid s, a)\) 가 필요하다.
가치 반복
가치 반복(value iteration)은 벨만 최적 방정식의 오른쪽을 계산해 왼쪽에 덮어쓰기를 되풀이한다.
\(V_{k+1}(s) \leftarrow \max_a \sum_{s'} p(s' \mid s, a)\,\big[\, r(s,a,s') + \gamma\, V_k(s')\,\big], \qquad V_0(s) = 0\)
2×3 격자(\(\gamma = 0.9\))에서 손으로 돌리면 다음과 같다. 순서는 \((A, B, C, D, E)\) 이고 G 는 늘 0 이다.
| 반복 | \((A, B, C, D, E)\) | 바뀐 이유 |
| \(V_0\) | \((0,\ 0,\ 0,\ 0,\ 0)\) | 초기값 |
| \(V_1\) | \((0,\ 1,\ 0,\ 0,\ 1)\) | B 는 오른쪽, E 는 위로 가면 G 라 \(1 + 0.9 \cdot 0 = 1\). 나머지는 보상도 \(V_0\) 도 0 이다. |
| \(V_2\) | \((0.9,\ 1,\ 0,\ 0.9,\ 1)\) | A 는 오른쪽(B), D 는 위(B)나 오른쪽(E)으로 \(0.9 \times 1\). C 의 이웃 A, D 는 \(V_1\) 에서 아직 0 이다. |
| \(V_3\) | \((0.9,\ 1,\ 0.81,\ 0.9,\ 1)\) | \(V_3(C) = \max\{0.9 V_2(A),\ 0.9 V_2(D)\} = 0.81\) |
| \(V_4\) | \(V_4 = V_3 = V^\ast\) | 더 바뀌지 않아 수렴했다. |
정보가 한 반복에 한 칸씩 퍼져 나간다. 최적 정책은 A · B 는 오른쪽, C · D · E 는 위(또는 같은 값의 다른 길)다. 코드에서는 GridWorld.transitions(s, a) 가 환경의 규칙 \(p(s', r \mid s, a)\) 를 [(확률, 다음 상태, 보상), ...] 목록으로 돌려준다(ch05_rl_basics.py 의 region grid).
def value_iteration(env, gamma, n_iters=1000, tol=1e-8, labels=None):
"""V_{k+1}(s) = max_a Σ_{s'} p(s'|s,a)·[r + γ·V_k(s')] 를 값이 더 바뀌지 않을 때까지 되풀이한다."""
V = {s: 0.0 for s in env.states} # V_0 = 0
for k in range(n_iters):
V_new = {}
for s in env.states:
if env.is_terminal(s):
V_new[s] = 0.0 # 끝 칸 뒤에는 아무 보상도 없다
continue
q_values = [sum(p * (r + gamma * V[s2]) for p, s2, r in env.transitions(s, a)) for a in ACTIONS]
V_new[s] = max(q_values) # 가장 좋은 행동의 값
delta = max(abs(V_new[s] - V[s]) for s in env.states)
V = V_new
if labels: # 칸 이름을 주면 반복마다 값을 찍는다
print(f" 반복 {k + 1}: " + " ".join(f"{labels[s]}={V[s]:.3f}" for s in env.states))
if delta < tol:
break
# 탐욕 정책: 각 칸에서 가장 큰 Q 를 주는 행동
policy = {}
for s in env.states:
if not env.is_terminal(s):
q = {a: sum(p * (r + gamma * V[s2]) for p, s2, r in env.transitions(s, a)) for a in ACTIONS}
policy[s] = max(q, key=q.get)
return V, policy, k + 1
코드 출력은 손계산과 같고 탐욕 정책은 {'A': '→', 'B': '→', 'C': '↑', 'D': '↑', 'E': '↑'} 다.
5×5 미끄러운 격자
벽(#), 목표 G(+1), 구덩이 P(−1)가 있는 5×5 격자로 키운다. 20% 확률로 의도와 직각 방향으로 미끄러지고(양옆 10%씩, 전이가 확률적), 이동마다 \(-0.02\) 의 벌점이 있으며 \(\gamma = 0.95\) 다. 배치는 ["....G", ".##.P", ".....", ".#.#.", "....."], slip=0.2, step_reward=-0.02 다.
5×5 미끄러운 격자: 38번 반복 만에 수렴
+0.707 +0.788 +0.866 +0.950 G
+0.638 ## ## +0.667 P
+0.567 +0.508 +0.501 +0.567 +0.341
+0.508 ## +0.445 ## +0.295
+0.445 +0.393 +0.388 +0.339 +0.294
구덩이 바로 아래 칸은 왼쪽으로 빠져나가는 길을 고른다. 그래도 10% 확률로 위로 미끄러져 구덩이에 빠지므로 이 칸의 가치(0.34)는 왼쪽 이웃(0.57)보다 훨씬 낮다. 오른쪽 아래 구석 칸이 이 칸 쪽으로 올라가지 않고 아랫줄로 돌아가는 것도 미끄러질 위험을 계산에 넣은 결과다.
가치 반복이 수렴하는 이유
한 번 반복할 때마다 정답과의 오차가 \(\gamma\) 배 이하로 줄어든다(수축). 먼저 도움 정리 \(\big\vert\max_a f(a) - \max_a g(a)\big\vert \le \max_a \vert f(a) - g(a)\vert\) 가 필요하다. \(a^\ast = \operatorname*{arg\,max}_a f(a)\) 로 두면 \(\max_a g \ge g(a^\ast)\) 이므로
\(\max_a f - \max_a g = f(a^\ast) - \max_a g \le f(a^\ast) - g(a^\ast) \le \vert f(a^\ast) - g(a^\ast)\vert \le \max_a \vert f(a) - g(a)\vert\)
이고, \(f\) 와 \(g\) 를 바꾸면 반대쪽 부등식도 나와 절댓값으로 묶인다. 이제 \(V_{k+1}\) 의 정의와 벨만 최적 방정식을 빼면 보상 \(r\) 이 지워진다.
\(\begin{align} \vert V_{k+1}(s) - V^\ast(s)\vert &= \Big\vert\max_a \sum_{s'} p\,[r + \gamma V_k(s')] - \max_a \sum_{s'} p\,[r + \gamma V^\ast(s')]\Big\vert \\ &\le \max_a \Big\vert\sum_{s'} p(s'\mid s,a)\,\gamma\,\big(V_k(s') - V^\ast(s')\big)\Big\vert \\ &\le \gamma \max_a \sum_{s'} p(s'\mid s,a)\,\big\vert V_k(s') - V^\ast(s')\big\vert \\ &\le \gamma \max_a \sum_{s'} p(s'\mid s,a)\, \|V_k - V^\ast\|_\infty = \gamma\, \|V_k - V^\ast\|_\infty \end{align}\)
둘째 줄은 도움 정리, 셋째 줄은 삼각 부등식, 넷째 줄은 각 오차를 최대 오차 \(\|V_k - V^\ast\|_\infty = \max_{s'}\vert V_k(s') - V^\ast(s')\vert\) 로 키우고 \(\sum_{s'} p(s'\mid s,a) = 1\) 을 쓴 것이다. 모든 \(s\) 에서 성립하므로 다음이 나온다.
\(\|V_{k+1} - V^\ast\|_\infty \le \gamma\, \|V_k - V^\ast\|_\infty \quad\Rightarrow\quad \|V_k - V^\ast\|_\infty \le \gamma^k\, \|V_0 - V^\ast\|_\infty\)
\(\gamma \lt 1\) 이면 \(\gamma^k \to 0\) 이라 어디서 시작하든 \(V^\ast\) 에 수렴한다.
가치 반복은 데이터를 한 번도 모으지 않고 환경의 규칙 \(p(s'\mid s,a)\) 와 보상 \(r\) 만으로 최적 행동을 계산했다. 모델을 써서 행동을 정하는 것을 계획(planning)이라 한다. 현실에서는 규칙을 모르고, 그 규칙을 데이터로 배우는 것이 World Model 이다. 6장과 7장은 진자의 규칙을 배워 그 안에서 계획한다.
정책 경사: REINFORCE
반대 접근은 규칙을 모르는 채 정책 자체를 신경망 \(\pi_\psi\) 로 두고 리턴이 커지는 쪽으로 \(\psi\) 를 직접 고치는 것이다. 목표는 리턴의 기댓값이다.
\(J(\psi) = \mathbb{E}_{\tau \sim p_\psi}\big[ R(\tau) \big], \qquad R(\tau) = \sum_{t=0}^{T-1}\gamma^t r_t\)
키우는 문제이므로 경사 상승 \(\psi \leftarrow \psi + \eta\nabla_\psi J\) 를 쓴다. \(J\) 는 환경을 실제로 돌려야 나오는 값이고 환경은 미분할 수 없는 블랙박스인데, 로그 미분 트릭(log-derivative trick)으로 기울기를 구한다.
\(\nabla_\psi \log p_\psi(\tau) = \frac{\nabla_\psi p_\psi(\tau)}{p_\psi(\tau)} \quad\Longleftrightarrow\quad \nabla_\psi p_\psi(\tau) = p_\psi(\tau)\,\nabla_\psi\log p_\psi(\tau)\)
궤적이 정해지면 \(R(\tau)\) 는 \(\psi\) 와 무관하므로 미분은 확률에만 걸리고, 트릭을 넣으면 다시 기댓값 꼴이 된다. 기댓값은 궤적을 뽑아 평균 내어 추정할 수 있다.
\(\begin{align} \nabla_\psi J &= \nabla_\psi \sum_\tau p_\psi(\tau)\,R(\tau) = \sum_\tau \nabla_\psi p_\psi(\tau)\,R(\tau) \\ &= \sum_\tau p_\psi(\tau)\,\nabla_\psi\log p_\psi(\tau)\,R(\tau) = \mathbb{E}_{\tau\sim p_\psi}\big[\, R(\tau)\,\nabla_\psi \log p_\psi(\tau)\,\big] \end{align}\)
궤적 확률 분해에 로그를 취하면 세 항으로 나뉘고, 시작 분포 \(\rho_0\) 와 환경의 규칙 \(p\) 는 \(\psi\) 와 무관해서 미분하면 0 이다.
\(\begin{align} \log p_\psi(\tau) &= \log\rho_0(s_0) + \sum_{t}\log\pi_\psi(a_t\mid s_t) + \sum_t \log p(s_{t+1}\mid s_t, a_t) \\ \nabla_\psi \log p_\psi(\tau) &= 0 + \sum_t \nabla_\psi\log\pi_\psi(a_t\mid s_t) + 0 \end{align}\)
환경 항이 사라지고 정책 경사 정리가 남는다.
\(\nabla_\psi J = \mathbb{E}_{\tau\sim p_\psi}\Big[\, R(\tau)\sum_{t=0}^{T-1}\nabla_\psi \log\pi_\psi(a_t\mid s_t)\,\Big]\)
필요한 것은 실제로 돌려 본 궤적과 정책의 로그 확률의 기울기뿐이다. 환경의 규칙을 몰라도 되므로 모델 프리다. 뜻은 "리턴이 컸던 궤적에서 했던 행동들의 확률을 높여라"다.
기준선: 분산 줄이기
위 추정은 편향이 없지만 잡음이 매우 크다. 잡음을 줄이는 도구는 점수 함수(score function) \(\nabla\log\pi\) 의 기댓값이 0 이라는 성질이다.
\(\mathbb{E}_{a\sim\pi_\psi(\cdot\mid s)}\big[\nabla_\psi\log\pi_\psi(a\mid s)\big] = \sum_a \pi_\psi(a\mid s)\,\frac{\nabla_\psi \pi_\psi(a\mid s)}{\pi_\psi(a\mid s)} = \nabla_\psi \sum_a \pi_\psi(a\mid s) = \nabla_\psi\, 1 = 0\)
그래서 리턴에서 행동 \(a_t\) 와 무관한 값 \(b(s_t)\), 곧 기준선(baseline)을 빼도 기울기의 기댓값이 그대로다.
\(\mathbb{E}[(G - b(s))\nabla\log\pi] = \mathbb{E}[G\,\nabla\log\pi] - b(s)\cdot\mathbb{E}[\nabla\log\pi] = \mathbb{E}[G\,\nabla\log\pi] - 0\)
같은 논리로 시각 \(t\) 의 행동은 그 이전의 보상에 영향을 줄 수 없으므로 \(R(\tau)\) 대신 그때부터의 리턴 \(G_t\) 를 써도 된다. 실제로 쓰는 REINFORCE 는 다음과 같다(\(\gamma^t\) 배의 차이는 실무에서 보통 무시한다).
\(\nabla_\psi J \approx \frac{1}{N}\sum_{\text{궤적}}\ \sum_{t}\big(G_t - b(s_t)\big)\,\nabla_\psi\log\pi_\psi(a_t \mid s_t)\)
기준선의 좋은 선택은 그 상태의 평균 리턴 \(V^\pi(s_t)\) 다. 그러면 \(G_t - b(s_t)\) 는 "평소보다 얼마나 잘했나"가 되어 평소보다 잘한 행동만 올리고 못한 행동은 내린다.
소프트맥스 정책의 점수 함수
행동이 몇 개뿐이면 상태마다 로짓 \(\psi_{s,a}\) 를 두고 소프트맥스로 정책을 만든다. 4장의 교차 엔트로피 기울기와 같은 계산이고 부호만 반대다.
\(\begin{align} \log\pi(a\mid s) &= \psi_{s,a} - \log\sum_{b'} e^{\psi_{s,b'}} \\ \frac{\partial}{\partial\psi_{s,b}}\log\pi(a\mid s) &= \mathbf{1}[b = a] - \frac{e^{\psi_{s,b}}}{\sum_{b'}e^{\psi_{s,b'}}} = \mathbf{1}[b=a] - \pi(b\mid s) \end{align}\)
고른 행동의 로짓은 \((1 - \pi)\) 만큼 올리고 다른 행동은 자기 확률만큼 내린다. 코드의 grad_log_pi 가 이 식이다.
실습: 복도
칸 0~4 의 1차원 복도에서 칸 0 에서 출발해 칸 4 에 닿으면 +1 을 받는다(15 스텝 안에 못 닿으면 0). 행동은 왼쪽 · 오른쪽 둘이고 \(\gamma = 0.9\), 학습률 0.1, 400 에피소드, 시드 30개다. 최적은 오른쪽으로만 네 번 가서 리턴 \(0.9^3 = 0.729\) 를 받는 것이다. 환경은 region corridor 에 있다.
def run_episode(env, logits, rng):
"""정책 π(a|s) = softmax(logits[s]) 로 에피소드 하나를 돈다."""
s, done = env.reset(), False
states, actions, rewards = [], [], []
while not done:
a = rng.choice(2, p=softmax(logits[s]))
s2, r, done = env.step(a)
states.append(s), actions.append(a), rewards.append(r)
s = s2
return states, actions, rewards
def grad_log_pi(logits, s, a):
"""∇_logits log π(a|s). 소프트맥스 정책이면 (원-핫(a) − π(·|s)) 가 s 행에만 생긴다."""
g = np.zeros_like(logits)
g[s] = -softmax(logits[s])
g[s, a] += 1.0
return g
def reinforce(n_episodes, gamma, lr, use_baseline, seed):
rng = np.random.default_rng(seed)
env = Corridor(rng)
logits = np.zeros((env.n_states, env.n_actions)) # 처음엔 왼쪽 · 오른쪽 반반
V = np.zeros(env.n_states) # 기준선 b(s): 상태별 리턴의 이동 평균
returns = []
for _ in range(n_episodes):
states, actions, rewards = run_episode(env, logits, rng)
G = discounted_returns(rewards, gamma) # 각 시각의 리턴 G_t
grad = np.zeros_like(logits)
for s, a, g_t in zip(states, actions, G):
b = V[s] if use_baseline else 0.0
grad += (g_t - b) * grad_log_pi(logits, s, a) # (G_t − b)·∇log π(a_t|s_t)
if use_baseline:
V[s] += 0.1 * (g_t - V[s]) # 기준선도 조금씩 리턴 쪽으로
logits += lr * grad # 경사 '상승': 리턴을 키우는 방향
returns.append(G[0])
return np.array(returns), logits
grad += (g_t - b) * grad_log_pi(...) 가 \(\sum_t (G_t - b(s_t))\nabla\log\pi\) 이고 logits += lr * grad 가 경사 상승이다. 코드는 간단히 하려고 에피소드 도중에 기준선 V[s] 를 고친다. 엄밀하게는 에피소드가 끝난 뒤에 고쳐야 기준선이 그 에피소드의 행동과 완전히 무관해진다.
기준선이 평균은 그대로 두고 잡음만 줄이는지는 처음 정책(반반)에서 에피소드 4000개를 뽑아 기울기 추정의 평균과 분산을 비교해 확인한다(region variance. 기준선은 상태별 리턴의 몬테카를로 평균).
실습: 밴딧
팔이 두 개인 슬롯머신(밴딧, bandit)에서 팔 0 은 평균 10, 팔 1 은 평균 11 의 보상을 준다(표준편차 1). 모든 보상에 10 이라는 큰 공통 값이 섞여 있어서, 기준선이 없으면 어느 팔을 당기든 그 팔의 확률을 크게 올려 버린다. 1000 스텝, 학습률 0.05, 시드 50개로 돌린다.
def bandit_reinforce(steps, lr, use_baseline, seed, means=(10.0, 11.0)):
"""팔 두 개짜리 밴딧. 보상 ~ N(10, 1) 또는 N(11, 1). 모든 보상에 큰 공통 값(약 10)이 섞여 있다."""
rng = np.random.default_rng(seed)
logits = np.zeros(2)
b = None # 기준선: 받은 보상의 이동 평균
history = []
for _ in range(steps):
p = softmax(logits)
a = rng.choice(2, p=p)
r = rng.normal(means[a], 1.0)
if b is None:
b = r
g = -p
g[a] += 1.0 # ∇ log π(a)
logits += lr * (r - (b if use_baseline else 0.0)) * g
b += 0.05 * (r - b)
history.append(softmax(logits)[1]) # 좋은 팔(1)을 고를 확률
return np.array(history)
결과
| 실험 | 기준선 없음 | 기준선 있음 |
| 복도 기울기 평균(칸 0, 오른쪽) | +0.0825 | +0.0806 |
| 복도 기울기 분산 합 | 0.5944 | 0.3862 |
| 복도 마지막 50 에피소드 평균 리턴(최적 0.729) | 0.690 | 0.695 |
| 밴딧 1000 스텝 뒤 \(\pi(\text{좋은 팔})\) 평균 | 0.758 | 0.989 |
| 밴딧에서 나쁜 팔로 굳은 시드 | 22% | 0% |
복도에서 기준선을 쓰고 학습한 뒤의 \(\pi(\text{오른쪽} \mid s)\) 는 칸 0~3 에서 [0.872, 0.949, 0.957, 0.948] 이다. 기울기의 평균은 표본 잡음 범위에서 같고 분산은 35% 줄었다. 복도처럼 보상이 0 과 1 뿐인 문제에서는 학습 곡선의 차이가 작지만, 밴딧처럼 보상에 큰 공통 값이 있으면 기준선 없이는 처음 우연히 당긴 팔로 굳어 버리기 쉽다. 진자의 보상은 늘 약 \(-16.3\) ~ \(0\) 의 음수라서 이 경우에 해당한다.
액터-크리틱, 이점, TD 오차
기준선으로 \(V^\pi(s)\) 를 쓰려면 그 값을 알아야 하므로 가치 함수도 신경망 \(v_\xi(s)\) 로 두고 함께 배운다. 정책 \(\pi_\psi\) 를 액터(actor), 가치 함수 \(v_\xi\) 를 크리틱(critic)이라 부르고 이 구조를 액터-크리틱이라 한다. 12장 Dreamer 가 상상 속에서 배우는 것이 이 액터와 크리틱이다.
- 액터 \(\pi_\psi(a \mid s)\) 가 행동 \(a\) 를 환경에 보낸다.
- 환경이 보상 \(r\) 과 다음 상태 \(s'\) 를 돌려준다.
- 크리틱이 \(v(s)\), \(v(s')\) 를 내어 TD 오차 \(\delta = r + \gamma v(s') - v(s)\) 를 만든다.
- 액터는 \(\delta\) 로 행동 확률을 고치고(\(\propto \delta\, \nabla \log \pi\)), 크리틱은 \(\delta^2\) 을 줄이도록 가치 예측을 고친다.
\(Q^\pi(s,a) - V^\pi(s)\) 를 이점(advantage) \(A^\pi(s, a)\) 라고 한다. 이 행동이 이 상태의 평균보다 얼마나 나은가를 뜻하며 \(G_t - V(s_t)\) 는 그 추정이다. 한 스텝만 보고 추정한 것이 TD 오차(temporal difference error)다.
\(\delta_t = r_t + \gamma V^\pi(s_{t+1}) - V^\pi(s_t)\)
\(\begin{align} \mathbb{E}[\delta_t \mid s_t, a_t] &= \mathbb{E}[\, r_t + \gamma V^\pi(s_{t+1}) \mid s_t, a_t\,] - V^\pi(s_t) \\ &= \sum_{s'}p(s'\mid s_t,a_t)\,[\,r + \gamma V^\pi(s')\,] - V^\pi(s_t) \\ &= Q^\pi(s_t, a_t) - V^\pi(s_t) = A^\pi(s_t, a_t) \end{align}\)
TD 오차 하나하나에는 잡음이 있지만 평균은 이점과 같다. 긴 미래의 우연이 모두 섞인 실제 리턴 \(G_t\) 대신 한 스텝 보상과 크리틱의 추측을 쓰므로 분산이 작고, 대신 크리틱이 틀리면 그만큼 편향이 생긴다. 이 둘을 섞는 방법이 12장의 λ-리턴이다.
크리틱은 목표값 \(y_t = r_t + \gamma\,v_\xi(s_{t+1})\) 에 가까워지도록 MSE \(\big(y_t - v_\xi(s_t)\big)^2\) 로 배운다. 목표가 따라 움직이면 불안정해지므로 목표값 쪽으로는 기울기를 흘리지 않는다. 이것이 기울기 차단(stop-gradient)이고 \(\operatorname{sg}(y_t)\) 라고 쓴다.
그래도 목표값은 크리틱 자신이 만들기 때문에 크리틱을 고칠 때마다 목표도 함께 움직인다("움직이는 과녁"). 이를 줄이려고 크리틱의 복사본을 만들어 가끔씩만(또는 아주 천천히) 본래 크리틱을 따라오게 하고, 목표값 \(y_t\) 는 이 느린 복사본으로 계산한다. 이것이 목표 신경망(target network)이며 DQN(Mnih et al., 2015)이 학습을 안정시키려고 쓴 장치다. 12장의 "느린 크리틱"이 같은 생각이다.
재매개변수화 경사
REINFORCE 는 환경을 블랙박스로 보기 때문에 "토크를 조금 더 주면 보상이 얼마나 오르나"라는 미분 정보를 쓰지 못한다. World Model 은 신경망이라 미분할 수 있으므로 더 정확한 기울기를 얻는다. 가장 단순한 예로 행동 \(a \sim \mathcal{N}(\mu, 1)\) 을 뽑고 보상 \(f(a) = a^2\) 을 받는다고 하면 \(J(\mu) = \mathbb{E}[a^2] = \mu^2 + 1\) 이고 참 기울기는 \(\nabla_\mu J = 2\mu\) 다. 이것을 표본으로 추정하는 방법이 둘 있다.
- 점수 함수(REINFORCE) 추정량
- \(\nabla_\mu \log\mathcal{N}(a;\mu,1) = \nabla_\mu\Big(-\tfrac{(a-\mu)^2}{2} - \tfrac{1}{2}\log 2\pi\Big) = a - \mu\) 이므로 \(\hat{g}_{\text{SF}} = f(a)\,(a - \mu) = a^2(a-\mu)\) 다. \(f\) 를 미분하지 않는다.
- 재매개변수화 추정량
- \(a = \mu + \epsilon,\ \epsilon\sim\mathcal{N}(0,1)\) 로 무작위성을 \(\mu\) 와 무관한 \(\epsilon\) 으로 옮기면 \(a\) 가 \(\mu\) 의 미분 가능한 함수가 된다. \(\hat{g}_{\text{RP}} = \frac{\partial f(\mu+\epsilon)}{\partial \mu} = 2(\mu + \epsilon) = 2a\) 다. 8장 VAE 의 핵심 기법이다.
둘 다 편향이 없다(\(\mathbb{E}[\epsilon] = \mathbb{E}[\epsilon^3] = 0\), \(\mathbb{E}[\epsilon^2] = 1\)).
\(\mathbb{E}[\hat{g}_{\text{RP}}] = 2\mu,\qquad \mathbb{E}[\hat{g}_{\text{SF}}] = \mathbb{E}[(\mu+\epsilon)^2\epsilon] = \mathbb{E}[\mu^2\epsilon + 2\mu\epsilon^2 + \epsilon^3] = 0 + 2\mu + 0 = 2\mu\)
차이는 분산이다. \(\mu = 1\) 에서 \((1+\epsilon)^4\epsilon^2 = \epsilon^2 + 4\epsilon^3 + 6\epsilon^4 + 4\epsilon^5 + \epsilon^6\) 이고 표준 정규 분포의 짝수 차 모멘트 \(\mathbb{E}[\epsilon^{2k}] = (2k-1)(2k-3)\cdots 1\) 로 \(\mathbb{E}[\epsilon^4] = 3\), \(\mathbb{E}[\epsilon^6] = 15\) 이므로 기댓값은 \(1 + 0 + 18 + 0 + 15 = 34\) 다.
\(\operatorname{Var}[\hat{g}_{\text{RP}}] = 4\operatorname{Var}[\epsilon] = 4,\qquad \operatorname{Var}[\hat{g}_{\text{SF}}] = \mathbb{E}[(1+\epsilon)^4\epsilon^2] - 2^2 = 34 - 4 = 30\)
재매개변수화 쪽의 분산이 7.5배 작아서 같은 정확도를 내는 데 표본이 7.5배 덜 든다.
import numpy as np
rng = np.random.default_rng(0)
mu, n = 1.0, 1_000_000
eps = rng.standard_normal(n)
a = mu + eps # a ~ N(μ, 1)
score = a**2 * (a - mu) # f(a) · ∇_μ log N(a; μ, 1)
pathwise = 2 * a # ∇_a f(a) · ∂a/∂μ
print("참값 2μ :", 2 * mu)
print("점수 함수 : 평균 %.3f, 분산 %.2f" % (score.mean(), score.var()))
print("재매개변수화 : 평균 %.3f, 분산 %.2f" % (pathwise.mean(), pathwise.var()))
진짜 환경은 거슬러 미분할 수 없어서 점수 함수 추정이나 따로 학습한 가치 함수에 기대야 한다. 학습된 World Model 안에서 상상하면 상태 → 행동 → 다음 상태 → 보상이 모두 신경망이라 리턴을 정책 매개변수로 곧바로 미분할 수 있다. Dreamer 가 연속 행동에서 상상 속 행동 학습에 쓰는 것이 이 재매개변수화 경사다.
부분 관측: POMDP 와 믿음 상태
8장부터 에이전트는 진짜 상태가 아니라 64×64 그림 \(o_t\) 만 본다. 그림에는 각도는 보이지만 각속도는 보이지 않는다. 관측이 상태의 일부만 보여 주는 문제가 부분 관측 마르코프 결정 과정(partially observable MDP, POMDP)이다.
\(\text{POMDP} = (\mathcal{S}, \mathcal{A}, p, r, \gamma,\ \mathcal{O},\ p(o \mid s))\)
MDP 에 관측의 집합 \(\mathcal{O}\) 와 관측 모델 \(p(o \mid s)\) 를 더한 것이다. 상태를 모르므로 지금까지의 관측과 행동으로 만든 "지금 상태에 대한 확률 분포"를 들고 다녀야 하고, 이것이 믿음 상태(belief state) \(b_t(s) = p(s_t = s \mid o_{1:t}, a_{1:t-1})\) 다. 믿음은 새 관측이 올 때마다 베이즈 정리로 고친다(베이즈 필터).
\(b_{t+1}(s') = \frac{p(o_{t+1} \mid s_{t+1}=s', o_{1:t}, a_{1:t})\; p(s_{t+1}=s' \mid o_{1:t}, a_{1:t})}{p(o_{t+1} \mid o_{1:t}, a_{1:t})}\)
관측은 그 순간의 상태만으로 정해지므로 분자의 첫 항은 \(p(o_{t+1} \mid s')\) 로 줄어든다. 둘째 항은 지금 상태 \(s\) 로 주변화한다. 다음 상태는 지금 상태와 행동만으로 정해지고, 행동 \(a_t\) 는 기록을 보고 고른 것이라 지금 상태에 대한 믿음을 바꾸지 않는다.
\(p(s_{t+1}=s' \mid o_{1:t}, a_{1:t}) = \sum_s p(s' \mid s, a_t)\; p(s_t = s \mid o_{1:t}, a_{1:t-1}) = \sum_s p(s' \mid s, a_t)\, b_t(s)\)
분모는 \(s'\) 와 무관한 상수이므로 비례식으로 쓴다.
\(b_{t+1}(s') \propto \underbrace{p(o_{t+1}\mid s')}_{\text{관측으로 바로잡기}}\ \underbrace{\sum_s p(s'\mid s, a_t)\, b_t(s)}_{\text{모델로 예측하기}}\)
두 단계는 전이 모델로 다음 상태를 예측하기, 새 관측과 맞는 상태의 믿음을 키우기다. 진자에서는 그림 두 장의 각도 변화로 속도를 추정할 수 있고(\(\dot\theta \approx (\theta_t - \theta_{t-1})/\Delta t\)), 믿음 갱신은 이것을 확률적으로 여러 장에 걸쳐 일반화한 것이다. 실제 문제에서는 상태 공간이 너무 커서 이 합을 정확히 계산할 수 없으므로 World Model 은 신경망으로 된 요약을 대신 쓴다. 9장 MDN-RNN 의 은닉 상태 \(h_t\), 11장 RSSM 의 잠재 상태 \((h_t, z_t)\) 가 학습된 믿음 상태이고, RSSM 의 구조는 "예측 → 바로잡기" 두 단계를 그대로 닮았다.
모델 프리와 모델 기반, Dyna
| 모델 프리(model-free) | 모델 기반(model-based) | |
| 무엇을 배우나 | 정책 · 가치를 경험에서 직접 배운다. | 먼저 환경의 모델 \(p_\theta(s'\mid s,a)\), \(r_\theta\) (= World Model)를 배우고 그 안에서 계획하거나 정책을 배운다. |
| 예 | REINFORCE, 액터-크리틱, DQN, PPO, SAC | 가치 반복(모델을 알 때), Dyna, PETS(7장), World Models(10장), PlaNet(11장), Dreamer(12장), MuZero(13장) |
| 장점 | 모델 오차의 영향이 없다. 구현이 단순하다. | 데이터 효율: 실제 경험 하나로 모델을 고치고 모델 안에서 상상 경험을 무한히 만들 수 있다. 계획과 새 목표에의 재사용이 된다. |
| 단점 | 환경과 아주 많이 상호작용해야 한다(수백만 스텝). | 모델 오차: 오차가 쌓이고(6장), 모델이 틀린 곳을 정책이 파고드는 모델 착취가 생길 수 있다(7 · 10장). 구현이 복잡하다. |
두 갈래를 잇는 고전적인 생각이 서튼(Richard Sutton)의 Dyna(Dyna architecture, Sutton, 1990–1991)다. 실제 경험으로 모델과 가치 함수를 함께 고치고, 모델이 만든 가상의 경험으로 가치 함수를 여러 번 더 고친다.
되풀이:
1. 실제 환경에서 행동 a 를 하고 (s, a, r, s') 를 얻는다
2. 이 실제 경험으로 가치 함수(또는 정책)를 고친다 ← 모델 프리 학습
3. 이 경험으로 모델 p_θ(s'|s,a), r_θ 를 고친다 ← World Model 학습
4. n 번 되풀이: ← 상상(계획)
지금까지 본 상태 s 와 행동 a 를 하나 고르고
모델로 가상의 (r̂, ŝ') 를 만들어
그 가상 경험으로 가치 함수를 고친다
3 번이 World Model 학습, 4 번이 꿈속에서 연습하기다. 튜토리얼의 나머지는 이 뼈대를 키워 가는 과정으로 볼 수 있다. 6장이 3 번(모델 학습)을, 7장이 4 번을 계획(MPC)으로, 10 · 12장이 4 번을 정책 학습으로 구현한다.
진자를 강화학습 문제로
| 요소 | 진자 환경 ( |
| 상태 \(s\) | \((\theta, \dot\theta)\). 마르코프 상태다. |
| 관측 \(o\) | 6 · 7장: \([\cos\theta, \sin\theta, \dot\theta]\) (상태와 정보가 같아 MDP). 8장부터: 64×64 그림(속도가 안 보여 POMDP). |
| 행동 \(a\) | 토크 \(u \in [-2, 2]\) (연속 행동) |
| 전이 \(p\) | 결정적 물리 법칙 \(\ddot\theta = \frac{3g}{2l}\sin\theta + \frac{3}{ml^2}u\) (6장에서 유도), 오일러 적분 \(\Delta t = 0.05\), 각속도는 \(\pm 8\) 에서 자른다. |
| 시작 상태 | \(\theta\) 는 \([-\pi, \pi]\), \(\dot\theta\) 는 \([-1, 1]\) 에서 고르게 무작위 |
| 보상 \(r\) | \(-(\theta^2 + 0.1\dot\theta^2 + 0.001u^2)\) (\(\theta\) 는 \([-\pi, \pi)\) 로 접은 값). 범위 약 \([-16.3,\ 0]\): 가장 나쁜 경우가 \(\pi^2 + 0.1\cdot 8^2 + 0.001\cdot 2^2 \approx 16.27\) |
| 에피소드 | 200 스텝에서 끊는다(종료 상태는 없다). 평가 점수는 할인 없는 200 스텝 보상의 합이다. |
| 할인율 | 학습할 때 보통 \(\gamma = 0.99\) (유효 지평 약 100 스텝 = 5초) |
wm_envs.Pendulum 은 Gym Pendulum-v1 과 같은 물리를 numpy 로 직접 구현한 것이다(\(m = l = 1\), \(g = 10\)). 보상은 움직이기 전 상태로 계산하고, 속도를 먼저 갱신한 뒤 새 속도로 각도를 갱신한다(semi-implicit Euler). 인터페이스는 obs = env.reset(), obs, reward, done = env.step(action) 이다. 토크 한계 2 가 중력이 막대를 돌리는 토크의 최댓값 \(mgl/2 = 5\) 보다 약해서 한 번에 들어 올릴 수 없고, 앞뒤로 흔들어 에너지를 모은 뒤 위에서 균형을 잡아야 한다.
손으로 만든 정책: 에너지 펌핑 + PD 제어
비교 기준으로 물리를 아는 사람이 쓸 수 있는 정책을 하나 만든다. 핵심은 토크를 도는 방향으로 주면 에너지가 늘어난다는 것이다. 물리 법칙의 양변에 막대의 회전 관성 \(I = \frac{ml^2}{3}\) 을 곱하고, 에너지를 시간으로 미분한다.
\(\begin{align} I\ddot\theta &= \frac{mgl}{2}\sin\theta + u \\ E &= \tfrac{1}{2}I\dot\theta^2 + \tfrac{mgl}{2}\cos\theta \\ \frac{dE}{dt} &= I\dot\theta\,\ddot\theta - \frac{mgl}{2}\sin\theta\,\dot\theta = \dot\theta\,\Big(I\ddot\theta - \frac{mgl}{2}\sin\theta\Big) = \dot\theta\, u \end{align}\)
\(E\) 는 회전 운동 에너지와 위치 에너지(무게중심 높이 \(\frac{l}{2}\cos\theta\), \(\theta = 0\) 이 맨 위)의 합이다. 위에 멈춰 서 있으면 \(E = \frac{mgl}{2} = 5\), 아래에 멈춰 있으면 \(-5\) 다. \(\dot\theta u \gt 0\) 이면 에너지가 늘어난다.
정책은 둘로 나뉜다. 맨 위 근처(\(\cos\theta \gt 0.9\), 약 ±25°)가 아니면 목표 에너지 5 와의 차이만큼 도는 방향으로 밀고(에너지 펌핑), 위 근처에서는 PD 제어 \(u = -K_p\theta - K_d\dot\theta\) (\(K_p = 10\), \(K_d = 2\))로 균형을 잡는다. 위 근처에서 \(\sin\theta \approx \theta\) 로 근사하면
\(\ddot\theta \approx 15\theta + 3u = 15\theta - 30\theta - 6\dot\theta = -15\theta - 6\dot\theta\)
가 되어 용수철(복원력 \(-15\theta\))과 마찰(\(-6\dot\theta\))이 있는 안정된 운동이 된다. 토크가 ±2 로 잘리므로 이 식은 \(\vert 10\theta + 2\dot\theta \vert \le 2\) 인 좁은 범위에서만 정확하고, 그 밖에서는 에너지 펌핑이 알맞은 속도로 올려 보내 준 덕분에 균형이 잡힌다.
def random_policy(obs, rng):
return rng.uniform(-2.0, 2.0, size=1)
def zero_policy(obs, rng):
return np.zeros(1)
def energy_pd_policy(obs, rng=None, k_energy=1.0, kp=10.0, kd=2.0, switch_cos=0.9):
"""손으로 만든 정책: 아래에서는 에너지를 펌프질하고, 위 근처에서는 PD 제어로 균형을 잡는다."""
cos_th, sin_th, thdot = obs
th = np.arctan2(sin_th, cos_th) # [-π, π], 0 = 똑바로 선 자세
if cos_th > switch_cos: # 위에서 약 ±25° 안: PD 제어
u = -kp * th - kd * thdot # 기울어진 반대쪽으로, 도는 반대쪽으로 민다
else: # 그 밖: 에너지 펌핑
inertia = 1.0 / 3.0 # I = m l² / 3 (m = l = 1)
energy = 0.5 * inertia * thdot**2 + 5.0 * np.cos(th) # E = ½Iθ̇² + (mgl/2)·cos θ
direction = 1.0 if thdot >= 0 else -1.0 # 도는 방향으로 밀면 에너지가 늘어난다 (dE/dt = θ̇·u)
u = k_energy * (5.0 - energy) * direction # 목표 에너지 mgl/2 = 5 와의 차이만큼
return np.clip(np.array([u]), -2.0, 2.0)
기준 점수
무작위 시작 100 에피소드에서 할인 없는 200 스텝 보상 합을 잰다(region evaluate).
| 정책 | 평균 | 표준편차 | 최소 | 최대 |
| random | −1233.7 | 298.4 | −1867.0 | −754.2 |
| zero torque | −1239.6 | 367.3 | −1898.6 | −494.8 |
| energy + PD | −182.5 | 106.3 | −368.2 | −0.0 |
아래에 매달린 상태에서 시작하면 손으로 만든 정책은 앞뒤로 두 번 흔들어 에너지를 모은 뒤 약 3.5초에 막대를 세우고 끝까지 유지한다. 무작위 정책과 가만히 있는 정책은 바닥 근처에 머문다.
무작위 정책이 약 −1234, 물리를 아는 사람이 만든 정책이 약 −183 이다. 손으로 만든 정책은 에너지 식을 알아야 쓸 수 있었다. 6 · 7장의 목표는 물리 법칙을 모른 채 무작위로 모은 데이터만으로 World Model 을 배우고 그 안에서 계획해 이 점수(−200 안팎)에 다가가는 것이다.
정리
- MDP \((\mathcal{S}, \mathcal{A}, p, r, \gamma)\) 에서는 마르코프 성질 덕분에 궤적 확률이 \(\rho_0\prod_t \pi(a_t\mid s_t)\,p(s_{t+1}\mid s_t,a_t)\) 로 분해된다.
- 리턴은 \(G_t = \sum_k \gamma^k r_{t+k} = r_t + \gamma G_{t+1}\) 이다. \(\sum\gamma^k = \frac{1}{1-\gamma}\) 이고 유효 지평은 \(\approx \frac{1}{1-\gamma}\) 이다.
- 벨만 기대 방정식 \(V^\pi(s) = \sum_a\pi\sum_{s'}p\,[r + \gamma V^\pi(s')]\) 은 선형성, 전체 기댓값, 마르코프 성질로 유도된다. 최적이면 평균 대신 \(\max\) 를 쓴다.
- 가치 반복은 오차를 매번 \(\gamma\) 배 이하로 줄여 수렴한다. 단, 전이 확률 \(p\) (= 모델)가 필요하다.
- 정책 경사 \(\nabla J = \mathbb{E}[\sum_t (G_t - b)\nabla\log\pi]\) 에서는 로그 미분 트릭으로 환경 항이 사라진다. 기준선은 평균을 바꾸지 않고 분산을 줄인다.
- TD 오차 \(\delta = r + \gamma V(s') - V(s)\) 의 기댓값은 이점이다. 액터-크리틱은 이것으로 정책과 가치를 함께 배운다.
- 미분 가능한 World Model 안에서는 재매개변수화 경사로 분산이 훨씬 작은 기울기를 얻는다(12장).
- 그림만 보면 POMDP 다. 믿음 갱신은 모델로 예측한 뒤 관측으로 바로잡는 것이고, RNN · RSSM 은 이를 학습된 요약으로 대신한다.
- 진자 기준 점수는 무작위 −1234, 손으로 만든 정책 −183 이다.
확인 문제
- 1. \(\gamma = 0.5\), 보상 \((2, 0, 4)\) 일 때 \(G_0, G_1, G_2\)
- \(G_2 = 4\), \(G_1 = 0 + 0.5 \times 4 = 2\), \(G_0 = 2 + 0.5 \times 2 = 3\) 이다. 검산은 \(2 + 0.5^2 \times 4 = 3\) 이다.
- 2. 매 스텝 보상이 \(-1\) 이고 끝없이 이어질 때 \(\gamma = 0.95\) 의 리턴과 유효 지평
- 리턴은 \(-1 \times \frac{1}{1 - 0.95} = -20\) 이고 유효 지평은 \(\frac{1}{0.05} = 20\) 스텝이다(\(0.95^{20} \approx 0.358\)).
- 3. 2×3 격자에서 \(\gamma = 0.5\) 로 바꿨을 때 \(V^\ast(C)\)
- C 에서 목표까지 최소 3번 이동하고(예: C → A → B → G) 마지막 이동에서 +1 을 받으므로 \(V^\ast(C) = \gamma^2 \times 1 = 0.25\) 이다.
- 4. REINFORCE 의 기울기 식에 전이 확률 \(p(s'\mid s,a)\) 가 나타나지 않는 이유
- 궤적 확률의 로그가 \(\log\rho_0 + \sum\log\pi_\psi + \sum\log p\) 로 나뉘고 \(\rho_0\) 와 \(p\) 는 \(\psi\) 와 무관해서 미분하면 0 이 된다. 환경은 궤적을 뽑아 주는 데만 쓰인다.
- 5. 기준선 \(b(s)\) 를 빼도 기댓값이 바뀌지 않는 이유와, 기준선이 행동에 따라 달라져도 되는지
- \(\mathbb{E}_{a\sim\pi}[\nabla\log\pi(a\mid s)] = \nabla\sum_a\pi = \nabla 1 = 0\) 이라 \(b(s)\) 를 곱한 항의 기댓값이 0 이다. \(b\) 가 \(a\) 에 따라 달라지면 기댓값 밖으로 꺼낼 수 없어 이 논리가 깨지고 일반적으로 편향이 생긴다.
- 6. 진자 그림 한 장만 보는 에이전트가 도는 방향을 알려면 필요한 정보
- 이전 관측(최소 한 장 더)과 행동의 기록이 필요하다. 관측이 상태의 일부만 보여 주는 POMDP 이므로 기록을 요약한 믿음 상태(또는 RNN 의 은닉 상태)를 들고 다녀야 한다.
See also
- World Models:Tutorial
- World Models
- Reinforcement learning
- Markov decision process
- Policy
- Q-learning
- Softmax
- Bayes' theorem
Favorite site
- WorldModels:Tutorial
- WorldModels:Tutorial:01-WhatIsWorldModel
- WorldModels:Tutorial:02-Probability
- WorldModels:Tutorial:04-DeepLearningBasics
- WorldModels:Tutorial:06-FirstWorldModel
- WorldModels:Tutorial:08-VAE
- WorldModels:Tutorial:09-MDN-RNN
- WorldModels:Tutorial:10-HaWorldModels
- WorldModels:Tutorial:12-Dreamer