미니 MCTS를 직접 실행

이론은 충분하니 직접 돌려보자.

🎯 코드가 구현하는 것

Ch 3에서 본 h, g, f 세 신경망 (랜덤 가중치 — 학습은 안 했지만 인터페이스는 정확)
Node 클래스 — 트리의 노드
PUCT 기반 Select
Expand + Evaluate (g, f 한 번씩 호출)
Backup (보상 누적 + 할인)
30번 시뮬레이션 후 결과 출력

코드 길이가 좀 있지만 위에서 본 모든 개념이 그대로 코드로 옮겨졌을 뿐이다.

PYTHON

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

# === MuZero-style 신경망 (Ch 3과 동일, 랜덤 가중치) ===
HIDDEN_DIM = 8
N_ACTIONS  = 4
OBS_DIM    = 16

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

def h(obs):
    return np.tanh(obs @ W_h)

def g(s, a_idx):
    a = np.zeros(N_ACTIONS); a[a_idx] = 1.0
    sa = np.concatenate([s, a])
    return np.tanh(sa @ W_g_s), float((sa @ W_g_r).item())

def f(s):
    logits = s @ W_f_p
    p = np.exp(logits) / np.exp(logits).sum()
    v = float((s @ W_f_v).item())
    return p, v

# === MCTS 노드 ===
class Node:
    def __init__(self, prior=0.0):
        self.prior = prior
        self.visit_count = 0
        self.value_sum = 0.0
        self.reward = 0.0
        self.children = {}
        self.state = None
    def expanded(self):
        return len(self.children) > 0
    def value(self):
        return self.value_sum / self.visit_count if self.visit_count > 0 else 0.0

C_PUCT = 1.25

def select_child(node):
    best_score, best_a, best_child = -1e9, -1, None
    for a, child in node.children.items():
        u = C_PUCT * child.prior * np.sqrt(node.visit_count) / (1 + child.visit_count)
        score = child.value() + u
        if score > best_score:
            best_score, best_a, best_child = score, a, child
    return best_a, best_child

def expand(node, state, policy):
    node.state = state
    for a in range(N_ACTIONS):
        node.children[a] = Node(prior=float(policy[a]))

def backup(path, value, gamma=0.99):
    for node in reversed(path):
        node.value_sum += value
        node.visit_count += 1
        value = node.reward + gamma * value

def simulate(root, num_sims=30):
    for _ in range(num_sims):
        path = [root]
        node = root
        # Select — leaf까지 내려간다
        while node.expanded():
            a, child = select_child(node)
            path.append(child)
            node = child
        # Expand + Evaluate — g와 f 한 번씩
        parent = path[-2]
        a_taken = [a for a, c in parent.children.items() if c is node][0]
        s_next, r = g(parent.state, a_taken)
        node.reward = r
        p, v = f(s_next)
        expand(node, s_next, p)
        # Backup
        backup(path, v)

# === 실행 ===
obs = np.random.randn(OBS_DIM)
s0 = h(obs)
root = Node()
p0, v0 = f(s0)
expand(root, s0, p0)
root.visit_count = 1

simulate(root, num_sims=30)

print("MCTS 30회 시뮬레이션 후 루트의 자식들:")
print(f"{'행동':>5}  {'방문':>4}  {'평균가치':>10}  {'사전확률':>10}")
for a, child in root.children.items():
    print(f"  a={a}  {child.visit_count:>4}  {child.value():>10.3f}  {child.prior:>10.3f}")

best_a = max(root.children, key=lambda a: root.children[a].visit_count)
print(f"\n선택된 행동: a={best_a} (방문 횟수 최다)")
print("← 사전확률(p)이 아닌 '방문 횟수'로 행동을 결정하는 게 MCTS의 본질.")

출력

기대 출력:

MCTS 30회 시뮬레이션 후 루트의 자식들:
   행동    방문        평균가치        사전확률
  a=0     5       0.018       0.234
  a=1     7       0.067       0.256
  a=2    13       0.172       0.267
  a=3     5       0.020       0.243

선택된 행동: a=2 (방문 횟수 최다)
← 사전확률(p)이 아닌 '방문 횟수'로 행동을 결정하는 게 MCTS의 본질.

← 이전 한 시뮬레이션 통째 추적 (6 단계) 다음 → 왜 이게 작동하는가 — 잠재 공간의 자유도