코드: 자가 대국 한 게임

한 자가 대국 게임 실행. 결과:

게임 길이: 20수 (5x5 보드, move_count 한계까지)
학습 데이터: 20개 (보드, π, z) 쌍
각 데이터의 π: MCTS 30 iter의 visits 분포 (25 자리)
각 데이터의 z: 그 차례 입장에서의 최종 결과 — 이번엔 무승부(z=0)

🎯 코드 핵심 흐름

play_one_game: 한 게임 끝까지 진행, (s, π, turn) 저장
각 수에서 mcts_visits 호출 → visits 분포 π_t
π_t에서 sampling → 실제 둔 수
게임 끝나면 final_z 계산
각 상태의 차례에 따라 z 부호 조정 → (s, π, z) 데이터

💡 결과 해석

학습 전 신경망이라 π가 거의 균등 (1/25 ≈ 0.04). 첫 수의 최대 확률은 0.095 정도. 게임 후반에 0.265까지 증가 — 가능한 수가 줄어들면서 자연히 확률 집중.

z = 0.0 (무승부) — 학습 안 된 신경망끼리 두는 무작위 게임은 자주 무승부. 학습이 진행되면 강한 쪽이 명확해져 z가 ±1 빈번해짐.

다음 페이지에서 학습 한 단계.

PYTHON

# 자가 대국 한 게임 시뮬. 학습 데이터 (s, π, z) 생성.

import numpy as np
import math

np.random.seed(42)


# === 5x5 Board ===
class Board:
    EMPTY, BLACK, WHITE = 0, 1, 2
    SIZE = 5
    def __init__(self, board=None, turn=None, move_count=0):
        self.board = board if board is not None else np.zeros((5, 5), 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(5) for c in range(5) if self.board[r,c] == 0]
    def play(self, move):
        new = self.board.copy(); new[move] = 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((5, 5, 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 >= 20 or not self.possible_moves()
    def winner_value(self):
        """현재 차례 입장에서의 결과: +1 이김, -1 짐, 0 무승부"""
        if not self.is_terminal(): return 0
        b = np.sum(self.board == self.BLACK); w = np.sum(self.board == self.WHITE)
        if b == w: return 0
        winner = self.BLACK if b > w else self.WHITE
        return 1.0 if winner == self.turn else -1.0


# === 작은 통합 신경망 (Policy + Value head) ===
class NetworkZero:
    def __init__(self):
        self.W1 = np.random.randn(3, 3, 3, 8) * 0.1; self.b1 = np.zeros(8)
        self.W2 = np.random.randn(3, 3, 8, 8) * 0.1; self.b2 = np.zeros(8)
        # Policy head
        self.Wp = np.random.randn(3, 3, 8, 1) * 0.1; self.bp = np.zeros(1)
        # Value head
        self.Wv = np.random.randn(25*8, 1) * 0.05; self.bv = np.zeros(1)
    
    def forward(self, board_input):
        """공통 본체 + 두 head → (policy logits 25, value scalar)"""
        # 공통 본체
        h1 = np.maximum(0, self._conv(board_input, self.W1, self.b1))
        h2 = np.maximum(0, self._conv(h1, self.W2, self.b2))
        # Policy head
        p_logits = self._conv(h2, self.Wp, self.bp).reshape(-1)
        # Value head (flatten h2)
        v = np.tanh(self.Wv.T @ h2.flatten() + self.bv)
        return p_logits, float(v[0])
    
    def _conv(self, x, W, b):
        H, Wd, Cin = x.shape; K = W.shape[0]; Cout = W.shape[3]
        pad = K // 2
        padded = np.zeros((H+2*pad, Wd+2*pad, Cin))
        padded[pad:pad+H, pad:pad+Wd, :] = x
        out = np.zeros((H, Wd, Cout))
        for i in range(H):
            for j in range(Wd):
                patch = padded[i:i+K, j:j+K, :]
                for c in range(Cout):
                    out[i,j,c] = np.sum(patch * W[:,:,:,c]) + b[c]
        return out


# === MCTS 매우 단순화 (10 iter) ===
def softmax(z):
    e = np.exp(z - np.max(z)); return e / np.sum(e)

def mcts_visits(board, net, n_iter=30):
    """간단한 시뮬레이션 — visits 분포 반환 (5x5=25)"""
    legal = np.zeros(25)
    for r, c in board.possible_moves(): legal[r*5+c] = 1
    p_logits, v = net.forward(board.to_input())
    p_logits = p_logits + np.log(legal + 1e-10)
    prior = softmax(p_logits)
    
    visits = np.zeros(25)
    for _ in range(n_iter):
        # 간단화: prior에서 sampling + value로 평가
        move_idx = np.random.choice(25, p=prior)
        if legal[move_idx]:
            visits[move_idx] += 1
    
    visits = visits + 0.1 * legal  # 모든 합법 자리 약간씩
    return visits / visits.sum()


# === 한 게임 자가 대국 ===
def play_one_game(net):
    board = Board()
    history = []  # (board_input, π, current_turn)
    
    while not board.is_terminal():
        pi = mcts_visits(board, net, n_iter=30)
        history.append((board.to_input(), pi, board.turn))
        # τ=1 sampling
        move_idx = np.random.choice(25, p=pi)
        move = (move_idx // 5, move_idx % 5)
        board = board.play(move)
    
    # 최종 z (각 상태별로 그 차례 입장에서의 결과)
    final_z = board.winner_value()
    final_turn = board.turn
    data = []
    for bi, pi, turn in history:
        z = final_z if turn == final_turn else -final_z
        data.append((bi, pi, z))
    return data, board.move_count


# === 실행 ===
net = NetworkZero()
print("=== 자가 대국 1 게임 (5x5, 학습 전) ===\n")
data, n_moves = play_one_game(net)
print(f"게임 길이: {n_moves}수")
print(f"학습 데이터 수: {len(data)}")
print()
print(f"첫 데이터:")
bi, pi, z = data[0]
print(f"  입력 shape: {bi.shape}")
print(f"  π (visits 분포): 가장 큰 자리 {pi.argmax()}, 확률 {pi.max():.4f}")
print(f"  z (결과): {z:+.1f}")
print()
print(f"마지막 데이터:")
bi, pi, z = data[-1]
print(f"  π 최대 자리: {pi.argmax()}, 확률 {pi.max():.4f}")
print(f"  z: {z:+.1f}")

출력

기대 출력:

=== 자가 대국 1 게임 (5x5, 학습 전) ===

게임 길이: 20수
학습 데이터 수: 20

첫 데이터:
  입력 shape: (5, 5, 3)
  π (visits 분포): 가장 큰 자리 4, 확률 0.0954
  z (결과): +0.0

마지막 데이터:
  π 최대 자리: 5, 확률 0.2647
  z: +0.0

← 이전 7x7 학습 파이프라인 — 진짜 학습 코드 다음 → 코드: 학습 한 단계 — 신경망 갱신