코드: 미니 알파고끼리 자가 대국

실행 결과 — 한 게임이 정상적으로 진행됨! 학습 안 된 네트워크인데도 각 수가 다른 자리에 들어가고 모양이 형성됨.

🎯 결과 분석

15수 진행 — 각 수가 다른 자리 (중복 없음)
흑 8돌, 백 7돌 — 균형 잡힌 진행
좌상귀(1행)와 중앙(2~4행)에 모양 형성
MCTS의 PUCT가 다양한 자리를 탐색 — possible_moves가 빈 자리만 반환하기 때문

학습 안 된 네트워크 = 무작위에 가까운 수. 그래도 알고리즘 구조는 정상 동작.

💡 진짜 학습된 알파고에서는

화점/별점에 더 집중 (Policy 학습 결과)
영역 형성을 위한 일관된 전략
강한 상대의 침투에 대한 응수 패턴

알고리즘은 우리 코드 그대로. 학습된 가중치만 다름. "코드는 알파고와 같음".

📊 진짜 알파고에서

이세돌 대국에서 알파고 vs 알파고 자가 대국:

약 250수 진행 (정상적 바둑 길이)
매 수가 강한 프로 수준
대국 마다 다른 모양
흑/백 승률 거의 동등

우리 미니 알파고는 가능성을 보여주는 코드. 진짜 강한 알파고는 학습이 추가되어야.

PYTHON

# 미니 알파고끼리 한 게임. 진짜 대국이 어떻게 진행되는지.

import numpy as np
import math
import random

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


# ===== 부품 (이전 페이지와 동일) =====
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
        return Board(new, self.WHITE if self.turn == self.BLACK else self.BLACK, self.move_count + 1)
    def to_input(self):
        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 >= 30 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'
    def show(self):
        sym = {0:'.', 1:'X', 2:'O'}
        for row in self.board:
            print(' '.join(sym[v] for v in row))


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):
        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)
        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, x):
        h1 = relu(conv2d_padded(x, self.W1, self.b1))
        return relu(conv2d_padded(h1, self.W2, self.b2))
    def policy(self, x, legal_mask):
        h = self.features(x)
        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, x):
        h = self.features(x)
        h_v = relu(conv2d_padded(h, self.W3_v, self.b3_v)).reshape(-1)
        return float(tanh(self.Wd.T @ h_v + self.bd)[0])


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; self.children = {}
        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
        return self.q_value() + c * self.prior * math.sqrt(N) / (1 + self.visits)


def mcts_move(board, net, n_iter=200):
    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):
        node = root; path = [node]
        while node.children:
            node = max(node.children.values(), key=lambda ch: ch.puct_score())
            path.append(node)
        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])
        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())
        for p in reversed(path):
            p.visits += 1; p.total_value += v; v = -v
    return max(root.children.keys(), key=lambda m: root.children[m].visits)


# === 자가 대국 ===
net = MiniAlphaGo()
board = Board()
print("=== 미니 알파고 자가 대국 (200 MCTS iter/move) ===")
print()

for move_num in range(1, 16):
    if board.is_terminal(): break
    move = mcts_move(board, net, n_iter=200)
    color = "흑" if board.turn == Board.BLACK else "백"
    print(f"  수 {move_num:>2} ({color}): {move}")
    board = board.play(move)

print()
print("=== 최종 보드 ===")
board.show()

print()
b_count = np.sum(board.board == Board.BLACK)
w_count = np.sum(board.board == Board.WHITE)
print(f"흑 돌: {b_count}, 백 돌: {w_count}")
print(f"진행 수: {board.move_count}")

출력

기대 출력:

=== 미니 알파고 자가 대국 (200 MCTS iter/move) ===

  수  1 (흑): (0, 0)
  수  2 (백): (2, 1)
  수  3 (흑): (0, 1)
  수  4 (백): (4, 4)
  수  5 (흑): (2, 3)
  수  6 (백): (1, 3)
  수  7 (흑): (1, 1)
  수  8 (백): (3, 2)
  수  9 (흑): (0, 3)
  수 10 (백): (2, 4)
  수 11 (흑): (2, 6)
  수 12 (백): (1, 4)
  수 13 (흑): (3, 4)
  수 14 (백): (2, 2)
  수 15 (흑): (3, 1)

=== 최종 보드 ===
X X . X . . .
. X . O O . .
. O O X O . X
. X O . X . .
. . . . O . .
. . . . . . .
. . . . . . .

흑 돌: 8, 백 돌: 7
진행 수: 15

← 이전 코드: 7x7 미니 알파고 통합 다음 → 시즌 1 회고 — 우리가 만든 것