Initial upload of Dualist Othello Game UI

app.py

@@ -0,0 +1,225 @@
+import gradio as gr
+import torch
+import numpy as np
+from model import OthelloNet
+from bitboard import get_bit, make_input_planes, bit_to_row_col
+from game import generate_moves, apply_move, get_initial_board, count_pieces
+
+# Load Dualist Model
+def load_model():
+    model = OthelloNet(num_res_blocks=10, num_channels=256)
+    try:
+        checkpoint = torch.load("dualist_model.pth", map_location="cpu")
+        if "model_state_dict" in checkpoint:
+            model.load_state_dict(checkpoint["model_state_dict"])
+        else:
+            model.load_state_dict(checkpoint)
+        model.eval()
+        return model
+    except Exception as e:
+        print(f"Error loading model: {e}")
+        return None
+
+DUALIST = load_model()
+
+# Game State Helpers
+def board_to_html(black_bb, white_bb, legal_moves_bb):
+    html = '<div class="board-container">'
+    for r in range(8):
+        html += '<div class="row">'
+        for c in range(8):
+            mask = get_bit(r, c)
+            cell_class = "cell"
+            content = ""
+            
+            if black_bb & mask:
+                cell_class += " black-piece"
+                content = '<div class="piece black"></div>'
+            elif white_bb & mask:
+                cell_class += " white-piece"
+                content = '<div class="piece white"></div>'
+            elif legal_moves_bb & mask:
+                cell_class += " legal-move"
+                # This makes cells clickable in Gradio (with some custom JS)
+                content = f'<div class="hint" onclick="window.makeMove({r}, {c})"></div>'
+            
+            html += f'<div class="{cell_class}" data-row="{r}" data-col="{c}">{content}</div>'
+        html += '</div>'
+    html += '</div>'
+    return html
+
+class OthelloGame:
+    def __init__(self):
+        self.black_bb, self.white_bb = get_initial_board()
+        self.current_player = 1 # 1 for Black, -1 for White
+        self.game_over = False
+        self.history = []
+
+    def get_state(self):
+        player_bb = self.black_bb if self.current_player == 1 else self.white_bb
+        opponent_bb = self.white_bb if self.current_player == 1 else self.black_bb
+        legal_moves = generate_moves(player_bb, opponent_bb)
+        return player_bb, opponent_bb, legal_moves
+
+    def step(self, row, col):
+        if self.game_over: return self.render()
+        
+        player_bb, opponent_bb, legal_moves = self.get_state()
+        move_mask = get_bit(row, col)
+        
+        if not (legal_moves & move_mask):
+            return self.render() # Invalid move
+
+        # 1. Apply Move
+        new_player, new_opponent = apply_move(player_bb, opponent_bb, move_mask)
+        
+        if self.current_player == 1:
+            self.black_bb, self.white_bb = new_player, new_opponent
+        else:
+            self.white_bb, self.black_bb = new_player, new_opponent
+
+        # 2. Switch Turn
+        self.current_player *= -1
+        self.check_skips()
+        
+        # 3. If it's AI's turn (White), move automatically
+        if not self.game_over and self.current_player == -1:
+            self.ai_move()
+            
+        return self.render()
+
+    def check_skips(self):
+        """Logic to handle passing turns if no moves are available."""
+        p_bb, o_bb, moves = self.get_state()
+        if moves == 0:
+            # Current player can't move, skip to next
+            self.current_player *= -1
+            p_bb, o_bb, next_moves = self.get_state()
+            if next_moves == 0:
+                self.game_over = True # Neither can move
+    
+    def ai_move(self):
+        if self.game_over or DUALIST is None: return
+        
+        p_bb, o_bb, moves = self.get_state()
+        if moves == 0:
+            self.current_player *= -1
+            return
+
+        # Inference
+        input_tensor = make_input_planes(p_bb, o_bb).to("cpu")
+        with torch.no_grad():
+            policy, _ = DUALIST(input_tensor)
+        
+        probs = torch.exp(policy).squeeze(0).cpu().numpy()
+        
+        best_idx = -1
+        max_p = -1
+        for i in range(64):
+            r, c = (63 - i) // 8, (63 - i) % 8
+            mask = get_bit(r, c)
+            if (moves & mask) and probs[i] > max_p:
+                max_p = probs[i]
+                best_idx = i
+        
+        if best_idx != -1:
+            r, c = (63 - best_idx) // 8, (63 - best_idx) % 8
+            new_p, new_o = apply_move(p_bb, o_bb, get_bit(r, c))
+            self.white_bb, self.black_bb = new_p, new_o
+            
+        self.current_player *= -1
+        self.check_skips()
+
+    def render(self):
+        p_bb, o_bb, moves = self.get_state()
+        board_html = board_to_html(self.black_bb, self.white_bb, moves)
+        b_count = bin(self.black_bb).count('1')
+        w_count = bin(self.white_bb).count('1')
+        
+        status = f"### Score: Black {b_count} - White {w_count}"
+        if self.game_over:
+            winner = "Black wins!" if b_count > w_count else "White wins!" if w_count > b_count else "Draw!"
+            status += f" 
+## GAME OVER: {winner}"
+        else:
+            turn = "Black's Turn" if self.current_player == 1 else "Dualist AI's Turn..."
+            status += f" 
+## {turn}"
+            
+        return board_html, status
+
+# Instantiate Game
+GAME = OthelloGame()
+
+# CSS for Dark Mode/Cyberpunk aesthetic
+custom_css = """
+body, .gradio-container { background-color: #0a0a0c !important; color: #e0e0e0 !important; }
+.board-container { 
+    display: inline-block; background: #1a1a1e; padding: 10px; border-radius: 8px;
+    box-shadow: 0 0 20px rgba(0, 255, 157, 0.1); border: 1px solid #333;
+}
+.row { display: flex; }
+.cell { 
+    width: 50px; height: 50px; background: #2c3e50; border: 1px solid #1a1a1a; 
+    display: flex; align-items: center; justify-content: center; position: relative;
+    cursor: default; transition: background 0.2s;
+}
+.cell:hover { background: #34495e; }
+.black-piece { background: #2c3e50; }
+.white-piece { background: #2c3e50; }
+.piece { width: 40px; height: 40px; border-radius: 50%; box-shadow: 2px 2px 5px rgba(0,0,0,0.5); }
+.black { background: #111; border: 2px solid #333; }
+.white { background: #eee; border: 2px solid #ccc; }
+.legal-move { cursor: pointer; }
+.hint { 
+    width: 12px; height: 12px; background: rgba(0, 255, 157, 0.4); 
+    border-radius: 50%; border: 1px solid #00ff9d;
+}
+.hint:hover { transform: scale(1.5); background: rgba(0, 255, 157, 0.8); }
+h1, h2, h3 { color: #00ff9d !important; text-shadow: 0 0 5px rgba(0,255,157,0.5); }
+"""
+
+def handle_click(evt: gr.SelectData):
+    # This captures board clicks from the HTML if we can map it
+    # But for Gradio we can use a simpler approach: Buttons or hidden state
+    pass
+
+def reset_game():
+    global GAME
+    GAME = OthelloGame()
+    return GAME.render()
+
+def make_move_direct(coord_str):
+    try:
+        r, c = map(int, coord_str.split(','))
+        return GAME.step(r, c)
+    except:
+        return GAME.render()
+
+with gr.Blocks(css=custom_css, title="Dualist Othello AI") as demo:
+    gr.Markdown("# 🌌 DUALIST OTHELLO AI")
+    gr.Markdown("Your first Neural Network opponent. Trained with Edax Grandmaster Teacher.")
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            board_display = gr.HTML(GAME.render()[0])
+        with gr.Column(scale=1):
+            status_display = gr.Markdown(GAME.render()[1])
+            reset_btn = gr.Button("Reset Game", variant="secondary")
+            
+            gr.Markdown("### How to play")
+            gr.Markdown("Click on the coordinates below to make your move (Black).")
+            # Gradio workaround for clickable HTML: Buttons for now
+            coords = []
+            for r in range(8):
+                for c in range(8):
+                    coords.append(f"{r},{c}")
+            
+            move_input = gr.Dropdown(label="Select Coordinates (Row, Col)", choices=coords, interactive=True)
+            submit_btn = gr.Button("Play Move", variant="primary")
+
+    submit_btn.click(make_move_direct, inputs=[move_input], outputs=[board_display, status_display])
+    reset_btn.click(reset_game, outputs=[board_display, status_display])
+
+if __name__ == "__main__":
+    demo.launch()

bitboard.py

@@ -0,0 +1,81 @@
+import numpy as np
+
+
+# Bitboard Constants
+BOARD_SIZE = 8
+FULL_MASK = 0xFFFFFFFFFFFFFFFF
+
+def popcount(x):
+    """Counts set bits in a 64-bit integer."""
+    return bin(x).count('1')
+
+def bit_to_row_col(bit_mask):
+    """Converts a single bit mask to (row, col) coordinates."""
+    if bit_mask == 0:
+        return -1, -1
+    # Find the index of the set bit (0-63)
+    # Assumes only one bit is set
+    idx = bit_mask.bit_length() - 1
+    # Edax/Othello usually maps MSB to A1 (0,0) or LSB to H8 (7,7)
+    # Let's align with Edax: A1 is usually high bit.
+    # Standard: index 63 is A1, index 0 is H8.
+    # row = (63 - idx) // 8
+    # col = (63 - idx) % 8
+    # However, standard bit manipulation often uses LSB=0.
+    # Let's check Edax conventions later, but for now standard math:
+    row = (63 - idx) // 8
+    col = (63 - idx) % 8
+    return row, col
+
+def get_bit(row, col):
+    """Returns a bitmask with a single bit set at (row, col)."""
+    shift = 63 - (row * 8 + col)
+    return 1 << shift
+
+def make_input_planes(player_bb, opponent_bb):
+    """
+    Converts bitboards into a 3x8x8 input tensor for the Neural Network.
+    Plane 0: Player pieces (1 if present, 0 otherwise)
+    Plane 1: Opponent pieces (1 if present, 0 otherwise)
+    Plane 2: Constant 1 (indicating it's the player's turn, or generally providing board usage context)
+             Some implementations use 'Valid Moves' here instead.
+             Let's use a constant plane for now as per AlphaZero standard, 
+             or we can update to valid moves if we have them handy.
+    """
+    planes = np.zeros((3, 8, 8), dtype=np.float32)
+    
+    # Fill Plane 0 (Player)
+    for r in range(8):
+        for c in range(8):
+            mask = get_bit(r, c)
+            if player_bb & mask:
+                planes[0, r, c] = 1.0
+                
+    # Fill Plane 1 (Opponent)
+    for r in range(8):
+        for c in range(8):
+            mask = get_bit(r, c)
+            if opponent_bb & mask:
+                planes[1, r, c] = 1.0
+    
+    # Fill Plane 2 (Constant / Color)
+    # Often for single-network (canonical form), this might just be 1s.
+    planes[2, :, :] = 1.0
+    
+    import torch
+    return torch.tensor(planes).unsqueeze(0) # Add batch dimension: (1, 3, 8, 8)
+
+def print_board(black_bb, white_bb):
+    """Prints the board state using B/W symbols."""
+    print("  A B C D E F G H")
+    for r in range(8):
+        line = f"{r+1} "
+        for c in range(8):
+            mask = get_bit(r, c)
+            if black_bb & mask:
+                line += "B "
+            elif white_bb & mask:
+                line += "W "
+            else:
+                line += ". "
+        print(line)

dtypes.py

@@ -0,0 +1,23 @@
+from typing import NamedTuple
+import numpy as np
+
+class Experience(NamedTuple):
+    """
+    Represents a single training example from self-play.
+    
+    Attributes:
+        state (np.ndarray): The board state (canonical form), typically 3x8x8 (Player, Opponent, Valid/Turn).
+        policy (np.ndarray): The MCTS visit counts or probability distribution (size 65).
+        value (float): The final game outcome from the perspective of the player (1 for win, -1 for loss, 0 for draw).
+    """
+    state: np.ndarray
+    policy: np.ndarray
+    value: float
+
+class GameResult(NamedTuple):
+    """
+    Represents the final outcome of a game.
+    """
+    final_board: np.ndarray
+    winner: int # 1 for Black, -1 for White, 0 for Draw
+    score_diff: int # Black score - White score

dualist_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f2b4cfc68e08a211dbe1c95841d3cca181e0f66f1b80e9f7dc06ebc3e9bdaa3
+size 47452382

game.py

@@ -0,0 +1,88 @@
+import numpy as np
+from src.bitboard import get_bit, bit_to_row_col, popcount
+
+class OthelloGame:
+    def __init__(self):
+        # Initial Board Setup (A1 = MSB, H8 = LSB)
+        # Black pieces: D5 (35), E4 (28) -> 0x0000000810000000
+        # White pieces: D4 (36), E5 (27) -> 0x0000001008000000
+        self.player_bb = 0x0000000810000000 # Black starts
+        self.opponent_bb = 0x0000001008000000
+        self.turn = 1 # 1: Black, -1: White
+
+    def get_valid_moves(self, player, opponent):
+        """Calculates valid moves for 'player' against 'opponent'."""
+        empty = ~(player | opponent) & 0xFFFFFFFFFFFFFFFF
+        
+        # Consistent with MSB=A1:
+        # North: << 8. South: >> 8.
+        # West: << 1 (mask A). East: >> 1 (mask H).
+        mask_h = 0x0101010101010101
+        mask_a = 0x8080808080808080
+        
+        # Directions
+        shifts = [
+             (lambda x: (x & ~mask_h) >> 1), # East
+             (lambda x: (x & ~mask_a) << 1), # West
+             (lambda x: (x << 8) & 0xFFFFFFFFFFFFFFFF), # North
+             (lambda x: (x >> 8) & 0xFFFFFFFFFFFFFFFF), # South
+             (lambda x: (x & ~mask_h) << 7), # NE (N+E -> <<8 + >>1 = <<7)
+             (lambda x: (x & ~mask_a) << 9), # NW (N+W -> <<8 + <<1 = <<9)
+             (lambda x: (x & ~mask_h) >> 9), # SE (S+E -> >>8 + >>1 = >>9)
+             (lambda x: (x & ~mask_a) >> 7)  # SW (S+W -> >>8 + <<1 = >>7)
+        ]
+        
+        valid_moves = 0
+        for shift_func in shifts:
+            candidates = shift_func(player) & opponent
+            for _ in range(6): # Max 6 opponent pieces can be in between
+                candidates |= shift_func(candidates) & opponent
+            valid_moves |= shift_func(candidates) & empty
+            
+        return valid_moves
+
+    def apply_move(self, player, opponent, move_bit):
+        """Calculates new boards after move_bit."""
+        if move_bit == 0:
+            return player, opponent
+            
+        flipped = 0
+        mask_h = 0x0101010101010101
+        mask_a = 0x8080808080808080
+        
+        shifts = [
+             (lambda x: (x & ~mask_h) >> 1), # East
+             (lambda x: (x & ~mask_a) << 1), # West
+             (lambda x: (x << 8) & 0xFFFFFFFFFFFFFFFF), # North
+             (lambda x: (x >> 8) & 0xFFFFFFFFFFFFFFFF), # South
+             (lambda x: (x & ~mask_h) << 7), # NE
+             (lambda x: (x & ~mask_a) << 9), # NW
+             (lambda x: (x & ~mask_h) >> 9), # SE
+             (lambda x: (x & ~mask_a) >> 7)  # SW
+        ]
+        
+        for shift_func in shifts:
+            mask = shift_func(move_bit)
+            potential_flips = 0
+            while mask & opponent:
+                potential_flips |= mask
+                mask = shift_func(mask)
+            if mask & player:
+                flipped |= potential_flips
+                
+        new_player = player | move_bit | flipped
+        new_opponent = opponent & ~flipped
+        return new_player, new_opponent
+
+    def play_move(self, move_bit):
+        if move_bit != 0:
+            self.player_bb, self.opponent_bb = self.apply_move(self.player_bb, self.opponent_bb, move_bit)
+        
+        # Turn always swaps (even on pass)
+        self.player_bb, self.opponent_bb = self.opponent_bb, self.player_bb
+        self.turn *= -1
+
+    def is_terminal(self):
+        p_moves = self.get_valid_moves(self.player_bb, self.opponent_bb)
+        o_moves = self.get_valid_moves(self.opponent_bb, self.player_bb)
+        return (p_moves == 0) and (o_moves == 0)

model.py

@@ -0,0 +1,72 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+class ResidualBlock(nn.Module):
+    def __init__(self, channels):
+        super(ResidualBlock, self).__init__()
+        self.conv1 = nn.Conv2d(channels, channels, kernel_size=3, padding=1, bias=False)
+        self.bn1 = nn.BatchNorm2d(channels)
+        self.conv2 = nn.Conv2d(channels, channels, kernel_size=3, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm2d(channels)
+
+    def forward(self, x):
+        residual = x
+        out = F.relu(self.bn1(self.conv1(x)))
+        out = self.bn2(self.conv2(out))
+        out += residual
+        out = F.relu(out)
+        return out
+
+class OthelloNet(nn.Module):
+    def __init__(self, num_res_blocks=10, num_channels=256):
+        super(OthelloNet, self).__init__()
+        
+        # Input: 3 channels (Player pieces, Opponent pieces, Legal moves/Constant plane)
+        self.conv_input = nn.Conv2d(3, num_channels, kernel_size=3, padding=1, bias=False)
+        self.bn_input = nn.BatchNorm2d(num_channels)
+        
+        # Residual Tower
+        self.res_blocks = nn.ModuleList([
+            ResidualBlock(num_channels) for _ in range(num_res_blocks)
+        ])
+        
+        # Policy Head
+        self.policy_conv = nn.Conv2d(num_channels, 2, kernel_size=1, bias=False)
+        self.policy_bn = nn.BatchNorm2d(2)
+        # 2 channels * 8 * 8 = 128
+        self.policy_fc = nn.Linear(128, 65) # 64 squares + pass
+
+        # Value Head
+        self.value_conv = nn.Conv2d(num_channels, 1, kernel_size=1, bias=False)
+        self.value_bn = nn.BatchNorm2d(1)
+        # 1 channel * 8 * 8 = 64
+        self.value_fc1 = nn.Linear(64, 256)
+        self.value_fc2 = nn.Linear(256, 1)
+
+    def forward(self, x):
+        # Input Convolution
+        x = F.relu(self.bn_input(self.conv_input(x)))
+        
+        # Residual Tower
+        for block in self.res_blocks:
+            x = block(x)
+            
+        # Policy Head
+        p = F.relu(self.policy_bn(self.policy_conv(x)))
+        p = p.view(p.size(0), -1) # Flatten
+        p = self.policy_fc(p)
+        # We return logits (unnormalized), let loss function handle softma separation
+        # Or return log_softmax for NLLLoss if needed.
+        # Often for alpha zero implementations, returning log_softmax for training stability is good
+        # But here let's stick to returning raw logits (or log_softmax)
+        # Let's return log_softmax as it is numerically stable for KLDivLoss
+        p = F.log_softmax(p, dim=1)
+
+        # Value Head
+        v = F.relu(self.value_bn(self.value_conv(x)))
+        v = v.view(v.size(0), -1) # Flatten
+        v = F.relu(self.value_fc1(v))
+        v = torch.tanh(self.value_fc2(v))
+
+        return p, v

requirements.txt

@@ -0,0 +1,3 @@
+gradio
+torch
+numpy