코드: 7x7 미니 알파고 통합

이게 전부야 — 80줄짜리 미니 알파고. 알파고 본질의 전체 구현.

🎯 결과 해석

500 MCTS iteration 실행 (실제 알파고: 50,000)
각 iteration: Select(PUCT) → Expand(Policy) → Evaluate(Value) → Backup
visits 최대 자식 선택: (4, 4) — 중앙 부근!

학습 안 된 네트워크라도 visits 분포가 보임 (14~17). 가장 많이 방문된 (4,4)는 Q value도 가장 높음 (+0.039). 작은 신호이지만 PUCT가 더 좋은 자리에 자원을 집중하는 게 보임.

💡 핵심 통찰 — 알파고는 부품의 통합

알파고가 마법 같은 게 아니야. 우리가 PART 1~5에서 본 모든 부품의 결합:

Board 클래스 — 게임 규칙
합성곱 + ReLU — 신경망
Softmax — 확률 분포
tanh — 가치 출력
MCTS 4단계 — 트리 탐색
PUCT 공식 — 신경망 가이드 탐색

각 부품은 우리가 이해함. 통합도 명확함. "알파고는 우리가 만들 수 있는 시스템".

📊 알파고를 진짜로 만들려면

위 코드에 추가가 필요한 것:

학습: 사람 게임 또는 자가 대국 데이터로 가중치 학습
스케일: 7x7 → 19x19, 3채널 → 48, 3층 → 13층
속도: numpy → TensorFlow/PyTorch, CPU → GPU
최적화: 병렬화, 캐싱, 메모리 관리

그러나 알고리즘 본질은 위 코드 그대로. 알파고 = 우리 코드 × 스케일 × 학습.

PYTHON

# 7x7 미니 알파고 — 모든 부품 통합.
# Board + CNN Policy + CNN Value + MCTS PUCT.

import numpy as np
import math
import random

np.random.seed(42)
random.seed(42)

# ============================
# Part 1: Board (PART 1에서)
# ============================
class Board:
    EMPTY, BLACK, WHITE = 0, 1, 2
    SIZE = 7
    
    def __init__(self, board=None, turn=None, move_count=0):
        self.board = board if board is not None else np.zeros((7, 7), dtype=int)
        self.turn = turn if turn is not None else self.BLACK
        self.move_count = move_count
    
    def possible_moves(self):
        return [(r, c) for r in range(7) for c in range(7) if self.board[r,c] == 0]
    
    def play(self, move):
        r, c = move
        new = self.board.copy()
        new[r, c] = self.turn
        next_turn = self.WHITE if self.turn == self.BLACK else self.BLACK
        return Board(new, next_turn, self.move_count + 1)
    
    def to_input(self):
        """3 채널 입력 (현재 차례 / 상대 / 빈자리)"""
        x = np.zeros((7, 7, 3))
        x[:,:,0] = (self.board == self.turn).astype(float)
        opp = self.WHITE if self.turn == self.BLACK else self.BLACK
        x[:,:,1] = (self.board == opp).astype(float)
        x[:,:,2] = (self.board == 0).astype(float)
        return x
    
    def is_terminal(self):
        return self.move_count >= 44 or not self.possible_moves()
    
    def winner(self):
        if not self.is_terminal(): return None
        b = np.sum(self.board == self.BLACK)
        w = np.sum(self.board == self.WHITE)
        if b > w: return self.BLACK
        if w > b: return self.WHITE
        return 'draw'


# ============================
# Part 2: CNN Policy + Value (PART 4에서)
# ============================
def relu(x): return np.maximum(0, x)
def softmax(z):
    e = np.exp(z - np.max(z))
    return e / np.sum(e)
def tanh(x): return np.tanh(x)


def conv2d_padded(image, kernels, bias):
    H, W, Cin = image.shape; K = kernels.shape[0]; Cout = kernels.shape[3]
    pad = K // 2
    padded = np.zeros((H+2*pad, W+2*pad, Cin))
    padded[pad:pad+H, pad:pad+W, :] = image
    output = np.zeros((H, W, Cout))
    for i in range(H):
        for j in range(W):
            patch = padded[i:i+K, j:j+K, :]
            for c in range(Cout):
                output[i,j,c] = np.sum(patch * kernels[:,:,:,c]) + bias[c]
    return output


# 학습된 척 — 가운데 우선하는 정책 (실제 학습은 합성 데이터로 매우 단순화)
class MiniAlphaGo:
    def __init__(self):
        # Policy weights (3-layer CNN)
        self.W1 = np.random.randn(3, 3, 3, 16) * 0.1
        self.b1 = np.zeros(16)
        self.W2 = np.random.randn(3, 3, 16, 16) * 0.1
        self.b2 = np.zeros(16)
        self.W3_p = np.random.randn(3, 3, 16, 1) * 0.1
        self.b3_p = np.zeros(1)
        # Value weights
        self.W3_v = np.random.randn(3, 3, 16, 4) * 0.1
        self.b3_v = np.zeros(4)
        self.Wd = np.random.randn(7*7*4, 1) * 0.05
        self.bd = np.zeros(1)
    
    def features(self, board_input):
        h1 = relu(conv2d_padded(board_input, self.W1, self.b1))
        h2 = relu(conv2d_padded(h1, self.W2, self.b2))
        return h2
    
    def policy(self, board_input, legal_mask):
        """49 자리 확률. legal_mask: 49 (1=legal, 0=illegal)"""
        h = self.features(board_input)
        logits = conv2d_padded(h, self.W3_p, self.b3_p).reshape(-1)
        # 합법 자리만 (불법 자리는 매우 작게)
        logits = logits + np.log(legal_mask + 1e-10)
        return softmax(logits)
    
    def value(self, board_input):
        """단일 숫자 -1 ~ +1"""
        h = self.features(board_input)
        h_v = relu(conv2d_padded(h, self.W3_v, self.b3_v)).reshape(-1)
        v = tanh(self.Wd.T @ h_v + self.bd)
        return float(v[0])


# ============================
# Part 3: MCTS with PUCT
# ============================
class MCTSNode:
    def __init__(self, board, parent=None, move=None, prior=0.0):
        self.board = board; self.parent = parent; self.move = move
        self.prior = prior     # P(s, a) from policy
        self.children = {}     # move → MCTSNode
        self.visits = 0
        self.total_value = 0.0
    
    def q_value(self):
        return self.total_value / max(self.visits, 1)
    
    def puct_score(self, c=2.0):
        if self.parent is None: return 0
        N = self.parent.visits
        U = c * self.prior * math.sqrt(N) / (1 + self.visits)
        return self.q_value() + U


def mcts_alphago(board, net, n_iter=500):
    """알파고 MCTS — 한 번의 root에서 n_iter번 simulate"""
    root = MCTSNode(board)
    # 루트 확장
    root.visits = 1
    legal = np.zeros(49)
    for r, c in board.possible_moves(): legal[r*7+c] = 1
    if legal.sum() == 0: return None
    probs = net.policy(board.to_input(), legal)
    for r, c in board.possible_moves():
        root.children[(r, c)] = MCTSNode(board.play((r,c)), parent=root, move=(r,c), prior=probs[r*7+c])
    
    for _ in range(n_iter):
        # ① Select
        node = root
        path = [node]
        while node.children:
            best = max(node.children.values(), key=lambda ch: ch.puct_score())
            node = best
            path.append(node)
        
        # ② Expand (terminal 아니면)
        if not node.board.is_terminal():
            legal = np.zeros(49)
            for r, c in node.board.possible_moves(): legal[r*7+c] = 1
            if legal.sum() > 0:
                probs = net.policy(node.board.to_input(), legal)
                for r, c in node.board.possible_moves():
                    node.children[(r, c)] = MCTSNode(node.board.play((r,c)), parent=node, move=(r,c), prior=probs[r*7+c])
        
        # ③ Evaluate
        if node.board.is_terminal():
            w = node.board.winner()
            v = 1.0 if w == node.board.turn else -1.0 if w != 'draw' else 0.0
        else:
            v = net.value(node.board.to_input())
        
        # ④ Backup
        for p in reversed(path):
            p.visits += 1
            p.total_value += v
            v = -v  # 차례 바뀜
    
    # visits 최대 자식 선택
    best_move = max(root.children.keys(), key=lambda m: root.children[m].visits)
    return root, best_move


# ============================
# 실행: 빈 7x7 보드에서 미니 알파고의 첫 수
# ============================
net = MiniAlphaGo()
board = Board()

print("=== 7x7 미니 알파고 — 첫 수 결정 ===")
print(f"입력: 7x7 빈 보드, 흑 차례")
print(f"네트워크: 3층 CNN (Policy + Value)")
print(f"MCTS: 500 iterations, PUCT 알고리즘")
print()

root, move = mcts_alphago(board, net, n_iter=500)

print(f"알파고의 첫 수: {move}")
print()
print(f"루트 visits: {root.visits}")
print(f"상위 5개 자식 (visits 기준):")
print(f"  {'자리':>8} {'visits':>8} {'prior P':>10} {'Q value':>10}")
for ch in sorted(root.children.values(), key=lambda c: -c.visits)[:5]:
    print(f"  {str(ch.move):>8} {ch.visits:>8} {ch.prior:>10.4f} {ch.q_value():>10.4f}")

출력

기대 출력:

=== 7x7 미니 알파고 — 첫 수 결정 ===
입력: 7x7 빈 보드, 흑 차례
네트워크: 3층 CNN (Policy + Value)
MCTS: 500 iterations, PUCT 알고리즘

알파고의 첫 수: (4, 4)

루트 visits: 501
상위 5개 자식 (visits 기준):
        자리   visits    prior P    Q value
    (4, 4)       17     0.0191     0.0393
    (0, 1)       15     0.0228     0.0184
    (1, 4)       14     0.0194     0.0290
    (2, 3)       14     0.0186     0.0296
    (4, 1)       14     0.0223     0.0174

← 이전 7x7 미니 알파고 — 우리가 알파고를 만든다 다음 → 코드: 미니 알파고끼리 자가 대국