세 신경망의 인터페이스를 코드로

본격 학습은 다음 챕터(Ch 4)에서 다루고, 여기서는 세 신경망의 모양만 정확히 확인하자.

가중치는 랜덤이라 결과 자체에 의미는 없지만, 입력/출력의 형태와 호출 순서는 정확히 MuZero와 동일하다.

PYTHON

import numpy as np
np.random.seed(42)

# MuZero의 세 신경망 — 형태만 확인 (랜덤 가중치)
HIDDEN_DIM = 8   # 잠재 상태 차원
N_ACTIONS  = 4   # 행동 개수
OBS_DIM    = 16  # 관측 차원 (예: 압축된 게임 화면)

# 1) 가중치 초기화 (실제 MuZero에서는 학습으로 얻는다)
W_h   = np.random.randn(OBS_DIM, HIDDEN_DIM) * 0.1
W_g_s = np.random.randn(HIDDEN_DIM + N_ACTIONS, HIDDEN_DIM) * 0.1
W_g_r = np.random.randn(HIDDEN_DIM + N_ACTIONS, 1) * 0.1
W_f_p = np.random.randn(HIDDEN_DIM, N_ACTIONS) * 0.1
W_f_v = np.random.randn(HIDDEN_DIM, 1) * 0.1

# 2) 세 신경망 정의
def h(obs):
    """h: 관측 → 잠재 상태"""
    return np.tanh(obs @ W_h)

def g(s, a_onehot):
    """g: (잠재 상태, 행동) → (다음 잠재 상태, 보상)"""
    sa = np.concatenate([s, a_onehot])
    s_next = np.tanh(sa @ W_g_s)
    r = float((sa @ W_g_r).item())
    return s_next, r

def f(s):
    """f: 잠재 상태 → (정책, 가치)"""
    logits = s @ W_f_p
    policy = np.exp(logits) / np.exp(logits).sum()
    value = float((s @ W_f_v).item())
    return policy, value

# 3) 한 번의 시뮬레이션 — 두 스텝 앞을 미리 본다
obs = np.random.randn(OBS_DIM)
s0 = h(obs)
print(f"루트 잠재 s0:  {s0.round(3)}")

p0, v0 = f(s0)
print(f"\n루트 정책 p0:  {p0.round(3)}")
print(f"루트 가치 v0:  {v0:.3f}")

# 행동 0을 선택했다고 치고 한 스텝 전진
a0 = np.array([1, 0, 0, 0])
s1, r1 = g(s0, a0)
print(f"\n행동 0 후 잠재 s1:  {s1.round(3)}")
print(f"행동 0 후 보상 r1:  {r1:.3f}")

p1, v1 = f(s1)
print(f"\ns1 정책 p1:  {p1.round(3)}")
print(f"s1 가치 v1:  {v1:.3f}")

print("\n← 한 스텝 시뮬레이션 동안 픽셀을 다시 만들지 않았다.")
print("   잠재 공간 안에서만 계산했다 — 이게 MuZero의 핵심 트릭.")

출력

기대 출력:

루트 잠재 s0:  [ 0.371 -0.287  0.369 -0.018 -0.18  -0.012  0.516  0.741]

루트 정책 p0:  [0.234 0.256 0.267 0.243]
루트 가치 v0:  -0.002

행동 0 후 잠재 s1:  [ 0.06   0.009 -0.108  0.178 -0.165 -0.157 -0.074  0.003]
행동 0 후 보상 r1:  -0.049

s1 정책 p1:  [0.243 0.249 0.253 0.255]
s1 가치 v1:  -0.055

← 한 스텝 시뮬레이션 동안 픽셀을 다시 만들지 않았다.
   잠재 공간 안에서만 계산했다 — 이게 MuZero의 핵심 트릭.

← 이전 세 신경망이 함께 움직이는 그림 다음 → 확인 퀴즈