Create engine/evaluate.py

engine/evaluate.py

@@ -0,0 +1,236 @@
+"""
+Position Evaluation Module
+Combines neural network evaluation with classical heuristics
+
+Research References:
+- AlphaZero (Silver et al., 2017) - Pure neural evaluation
+- Stockfish NNUE (2020) - Hybrid neural-classical approach
+- Leela Chess Zero - MCTS with neural evaluation
+"""
+
+import onnxruntime as ort
+import numpy as np
+import chess
+import logging
+from pathlib import Path
+from typing import Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class NeuralEvaluator:
+    """
+    Synapse-Base neural network evaluator
+    119-channel input, hybrid CNN-Transformer architecture
+    """
+    
+    # Piece values for material balance (Stockfish values)
+    PIECE_VALUES = {
+        chess.PAWN: 100,
+        chess.KNIGHT: 320,
+        chess.BISHOP: 330,
+        chess.ROOK: 500,
+        chess.QUEEN: 900,
+        chess.KING: 0
+    }
+    
+    # Piece-Square Tables (simplified Stockfish PST)
+    PST_PAWN = np.array([
+        [0,  0,  0,  0,  0,  0,  0,  0],
+        [50, 50, 50, 50, 50, 50, 50, 50],
+        [10, 10, 20, 30, 30, 20, 10, 10],
+        [5,  5, 10, 25, 25, 10,  5,  5],
+        [0,  0,  0, 20, 20,  0,  0,  0],
+        [5, -5,-10,  0,  0,-10, -5,  5],
+        [5, 10, 10,-20,-20, 10, 10,  5],
+        [0,  0,  0,  0,  0,  0,  0,  0]
+    ], dtype=np.float32)
+    
+    PST_KNIGHT = np.array([
+        [-50,-40,-30,-30,-30,-30,-40,-50],
+        [-40,-20,  0,  0,  0,  0,-20,-40],
+        [-30,  0, 10, 15, 15, 10,  0,-30],
+        [-30,  5, 15, 20, 20, 15,  5,-30],
+        [-30,  0, 15, 20, 20, 15,  0,-30],
+        [-30,  5, 10, 15, 15, 10,  5,-30],
+        [-40,-20,  0,  5,  5,  0,-20,-40],
+        [-50,-40,-30,-30,-30,-30,-40,-50]
+    ], dtype=np.float32)
+    
+    PST_KING_MG = np.array([
+        [-30,-40,-40,-50,-50,-40,-40,-30],
+        [-30,-40,-40,-50,-50,-40,-40,-30],
+        [-30,-40,-40,-50,-50,-40,-40,-30],
+        [-30,-40,-40,-50,-50,-40,-40,-30],
+        [-20,-30,-30,-40,-40,-30,-30,-20],
+        [-10,-20,-20,-20,-20,-20,-20,-10],
+        [ 20, 20,  0,  0,  0,  0, 20, 20],
+        [ 20, 30, 10,  0,  0, 10, 30, 20]
+    ], dtype=np.float32)
+    
+    def __init__(self, model_path: str, num_threads: int = 2):
+        """Initialize neural evaluator"""
+        
+        self.model_path = Path(model_path)
+        if not self.model_path.exists():
+            raise FileNotFoundError(f"Model not found: {model_path}")
+        
+        # ONNX Runtime session (CPU optimized)
+        sess_options = ort.SessionOptions()
+        sess_options.intra_op_num_threads = num_threads
+        sess_options.inter_op_num_threads = num_threads
+        sess_options.execution_mode = ort.ExecutionMode.ORT_SEQUENTIAL
+        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        
+        logger.info(f"Loading Synapse-Base model from {model_path}...")
+        self.session = ort.InferenceSession(
+            str(self.model_path),
+            sess_options=sess_options,
+            providers=['CPUExecutionProvider']
+        )
+        
+        self.input_name = self.session.get_inputs()[0].name
+        self.output_names = [output.name for output in self.session.get_outputs()]
+        
+        logger.info(f"✅ Model loaded: {self.input_name} -> {self.output_names}")
+    
+    def _build_119_channel_tensor(self, board: chess.Board) -> np.ndarray:
+        """
+        Convert board to 119-channel tensor
+        Based on Synapse-Base input specification
+        """
+        tensor = np.zeros((1, 119, 8, 8), dtype=np.float32)
+        
+        # === CHANNELS 0-11: Piece Positions ===
+        piece_map = board.piece_map()
+        piece_to_channel = {
+            chess.PAWN: 0, chess.KNIGHT: 1, chess.BISHOP: 2,
+            chess.ROOK: 3, chess.QUEEN: 4, chess.KING: 5
+        }
+        
+        for square, piece in piece_map.items():
+            rank, file = divmod(square, 8)
+            channel = piece_to_channel[piece.piece_type]
+            if piece.color == chess.BLACK:
+                channel += 6
+            tensor[0, channel, rank, file] = 1.0
+        
+        # === CHANNELS 12-26: Metadata ===
+        tensor[0, 12, :, :] = float(board.turn == chess.WHITE)
+        tensor[0, 13, :, :] = float(board.has_kingside_castling_rights(chess.WHITE))
+        tensor[0, 14, :, :] = float(board.has_queenside_castling_rights(chess.WHITE))
+        tensor[0, 15, :, :] = float(board.has_kingside_castling_rights(chess.BLACK))
+        tensor[0, 16, :, :] = float(board.has_queenside_castling_rights(chess.BLACK))
+        
+        if board.ep_square is not None:
+            ep_rank, ep_file = divmod(board.ep_square, 8)
+            tensor[0, 17, ep_rank, ep_file] = 1.0
+        
+        tensor[0, 18, :, :] = min(board.halfmove_clock / 100.0, 1.0)
+        tensor[0, 19, :, :] = min(board.fullmove_number / 100.0, 1.0)
+        tensor[0, 20, :, :] = float(board.is_check() and board.turn == chess.WHITE)
+        tensor[0, 21, :, :] = float(board.is_check() and board.turn == chess.BLACK)
+        
+        # Material counts
+        for i, piece_type in enumerate([chess.PAWN, chess.KNIGHT, chess.BISHOP, chess.ROOK, chess.QUEEN]):
+            white_count = len(board.pieces(piece_type, chess.WHITE))
+            black_count = len(board.pieces(piece_type, chess.BLACK))
+            max_count = 8 if piece_type == chess.PAWN else 2
+            tensor[0, 22 + i*2, :, :] = white_count / max_count
+            tensor[0, 23 + i*2, :, :] = black_count / max_count
+        
+        # === CHANNELS 27-50: Attack Maps ===
+        for square in chess.SQUARES:
+            rank, file = divmod(square, 8)
+            if board.is_attacked_by(chess.WHITE, square):
+                tensor[0, 27, rank, file] = 1.0
+            if board.is_attacked_by(chess.BLACK, square):
+                tensor[0, 28, rank, file] = 1.0
+        
+        # Mobility (number of legal moves)
+        white_mobility = len(list(board.legal_moves)) if board.turn == chess.WHITE else 0
+        black_mobility = len(list(board.legal_moves)) if board.turn == chess.BLACK else 0
+        tensor[0, 29, :, :] = min(white_mobility / 50.0, 1.0)
+        tensor[0, 30, :, :] = min(black_mobility / 50.0, 1.0)
+        
+        # === CHANNELS 51-66: Coordinate Encoding ===
+        for rank in range(8):
+            tensor[0, 51 + rank, rank, :] = 1.0
+        for file in range(8):
+            tensor[0, 59 + file, :, file] = 1.0
+        
+        # === CHANNELS 67-118: Positional Features ===
+        # Center control
+        center = [chess.D4, chess.D5, chess.E4, chess.E5]
+        for sq in center:
+            r, f = divmod(sq, 8)
+            tensor[0, 67, r, f] = 0.5
+        
+        # King safety zones
+        for color, offset in [(chess.WHITE, 68), (chess.BLACK, 69)]:
+            king_sq = board.king(color)
+            if king_sq is not None:
+                kr, kf = divmod(king_sq, 8)
+                for dr in [-1, 0, 1]:
+                    for df in [-1, 0, 1]:
+                        r, f = kr + dr, kf + df
+                        if 0 <= r < 8 and 0 <= f < 8:
+                            tensor[0, offset, r, f] = 1.0
+        
+        # Piece-square table values
+        for square, piece in piece_map.items():
+            rank, file = divmod(square, 8)
+            if piece.piece_type == chess.PAWN:
+                pst_value = self.PST_PAWN[rank, file] / 50.0
+                tensor[0, 70, rank, file] = pst_value if piece.color == chess.WHITE else -pst_value
+            elif piece.piece_type == chess.KNIGHT:
+                pst_value = self.PST_KNIGHT[rank, file] / 30.0
+                tensor[0, 71, rank, file] = pst_value if piece.color == chess.WHITE else -pst_value
+        
+        return tensor
+    
+    def evaluate_neural(self, board: chess.Board) -> float:
+        """
+        Neural network evaluation
+        Returns score from white's perspective
+        """
+        input_tensor = self._build_119_channel_tensor(board)
+        outputs = self.session.run(self.output_names, {self.input_name: input_tensor})
+        
+        # Value head output (tanh normalized to [-1, 1])
+        raw_eval = float(outputs[0][0][0])
+        
+        # Convert to centipawns (multiply by 4 for scaling)
+        return raw_eval * 400.0
+    
+    def evaluate_material(self, board: chess.Board) -> int:
+        """Classical material evaluation"""
+        material = 0
+        for piece_type in [chess.PAWN, chess.KNIGHT, chess.BISHOP, chess.ROOK, chess.QUEEN]:
+            material += len(board.pieces(piece_type, chess.WHITE)) * self.PIECE_VALUES[piece_type]
+            material -= len(board.pieces(piece_type, chess.BLACK)) * self.PIECE_VALUES[piece_type]
+        return material
+    
+    def evaluate_hybrid(self, board: chess.Board) -> float:
+        """
+        Hybrid evaluation combining neural and classical
+        Research: Stockfish NNUE approach
+        """
+        # Neural evaluation (primary)
+        neural_eval = self.evaluate_neural(board)
+        
+        # Classical material balance (safety check)
+        material_eval = self.evaluate_material(board)
+        
+        # Blend: 95% neural, 5% material (for stability)
+        hybrid_eval = 0.95 * neural_eval + 0.05 * material_eval
+        
+        # Perspective flip for black
+        if board.turn == chess.BLACK:
+            hybrid_eval = -hybrid_eval
+        
+        return hybrid_eval
+    
+    def get_model_size_mb(self) -> float:
+        """Get model size in MB"""
+        return self.model_path.stat().st_size / (1024 * 1024)