같은 MCTS 코드로 두 환경 처리하기

"같은 알고리즘"이라는 주장을 코드로 보자. 동일한 mcts() 함수가 행동 수도 다르고 보상 구조도 다른 두 환경을 처리한다.

🎯 코드가 보여주는 것

한 도메인 명세({'name', 'n_actions', 'gamma'})만 바꾸면 같은 코드가 작동
Chess-like: 행동 20개, γ=1.0 (할인 없음, 보드 게임 스타일)
Atari-like: 행동 4개, γ=0.99 (할인 있음, 픽셀 게임 스타일)
가중치는 랜덤이라 결과 자체에 의미는 없지만, 동일한 알고리즘이 두 다른 명세에 작동한다는 게 핵심

PYTHON

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

# === 두 도메인 명세만 다름 — 같은 MCTS 코드로 처리 ===
DOMAINS = [
    {'name': 'Chess-like (보드)',  'n_actions': 20, 'gamma': 1.00},
    {'name': 'Atari-like (픽셀)',  'n_actions': 4,  'gamma': 0.99},
]

OBS_DIM = 16
HIDDEN  = 8

def make_nets(n_actions, seed=42):
    """행동 수에 맞게 신경망 가중치 만들기 (학습 안 한 랜덤)"""
    rs = np.random.RandomState(seed)
    return {
        'W_h':   rs.randn(OBS_DIM, HIDDEN) * 0.1,
        'W_g_s': rs.randn(HIDDEN + n_actions, HIDDEN) * 0.1,
        'W_g_r': rs.randn(HIDDEN + n_actions, 1) * 0.1,
        'W_f_p': rs.randn(HIDDEN, n_actions) * 0.1,
        'W_f_v': rs.randn(HIDDEN, 1) * 0.1,
        'A': n_actions,
    }

def h(N, obs):
    return np.tanh(obs @ N['W_h'])

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

def f(N, s):
    logits = s @ N['W_f_p']
    return (np.exp(logits) / np.exp(logits).sum(),
            float((s @ N['W_f_v']).item()))

class Node:
    def __init__(self, p=0.0):
        self.prior, self.N, self.W, self.r = p, 0, 0.0, 0.0
        self.kids, self.s = {}, None
    def expanded(self): return bool(self.kids)
    def Q(self): return self.W / self.N if self.N else 0.0

def mcts(N, obs, num_sims, gamma):
    """이 함수가 환경에 무관 — 두 도메인에 같은 코드로 작동"""
    s0 = h(N, obs)
    root = Node(); root.s = s0
    p0, _ = f(N, s0)
    for a in range(N['A']):
        root.kids[a] = Node(p=float(p0[a]))
    root.N = 1

    for _ in range(num_sims):
        path = [root]; node = root
        while node.expanded():
            best, best_a, child = -1e9, -1, None
            for a, c in node.kids.items():
                u = 1.25 * c.prior * np.sqrt(node.N) / (1 + c.N)
                if c.Q() + u > best:
                    best, best_a, child = c.Q() + u, a, c
            path.append(child); node = child
        parent = path[-2]
        a_taken = [a for a, c in parent.kids.items() if c is node][0]
        s_next, r = g(N, parent.s, a_taken)
        node.r = r; node.s = s_next
        p, v = f(N, s_next)
        for a in range(N['A']):
            node.kids[a] = Node(p=float(p[a]))
        value = v
        for nd in reversed(path):
            nd.W += value; nd.N += 1
            value = nd.r + gamma * value
    return root

# === 같은 mcts() 호출, 명세만 다름 ===
for D in DOMAINS:
    N = make_nets(D['n_actions'])
    obs = np.random.RandomState(7).randn(OBS_DIM)
    root = mcts(N, obs, num_sims=30, gamma=D['gamma'])

    visits = sorted(root.kids.items(), key=lambda kv: -kv[1].N)
    best = max(root.kids, key=lambda a: root.kids[a].N)
    print(f"\n=== {D['name']}  (행동수={D['n_actions']}, γ={D['gamma']}) ===")
    print(f"상위 3개 행동:")
    for a, c in visits[:3]:
        print(f"  a={a:<3} 방문={c.N:>3}  Q={c.Q():+.3f}  prior={c.prior:.3f}")
    print(f"→ 선택: a={best} (방문 횟수 최다)")

print("\n← 같은 MCTS 코드가 두 환경(행동수 5배 차이, 보상구조 다름) 모두 처리.")
print("   '하나의 알고리즘이 여러 도메인을 푼다'는 말의 진짜 의미.")

출력

기대 출력:

=== Chess-like (보드)  (행동수=20, γ=1.0) ===
상위 3개 행동:
  a=10  방문=  3  Q=+0.092  prior=0.059
  a=0   방문=  2  Q=+0.009  prior=0.044
  a=1   방문=  2  Q=+0.003  prior=0.055
→ 선택: a=10 (방문 횟수 최다)

=== Atari-like (픽셀)  (행동수=4, γ=0.99) ===
상위 3개 행동:
  a=2   방문= 11  Q=+0.190  prior=0.223
  a=1   방문=  8  Q=+0.142  prior=0.259
  a=3   방문=  6  Q=+0.018  prior=0.262
→ 선택: a=2 (방문 횟수 최다)

← 같은 MCTS 코드가 두 환경(행동수 5배 차이, 보상구조 다름) 모두 처리.
   '하나의 알고리즘이 여러 도메인을 푼다'는 말의 진짜 의미.

← 이전 환경별로 미세하게 조정한 부분들 다음 → 이게 왜 큰 사건인가 — Bitter Lesson과의 연결