Convolutional Neural Network-based Chess Engine: Learning Evaluation and Move Prediction from Real Game Data

This project is a practical case of deep learning in the field of chess, inspired by DeepChess and Leela Chess Zero. It uses convolutional neural networks (CNN) to learn position evaluation and move prediction from real game data, demonstrating the application potential of deep learning in traditional board games. The project aims to build a neural network engine that can understand chess positions, providing a foundation for related learning and research.

Chess is an important testbed for AI research. From early brute-force search to modern Monte Carlo Tree Search combined with neural networks, it has witnessed the evolution of machine learning. Recent breakthroughs in deep learning allow neural networks to automatically learn position patterns from a large number of human games without manual rules. This project draws inspiration from DeepChess (which used DNN for position evaluation in 2016) and Leela Chess Zero (an open-source reproduction of AlphaZero's self-play training), building a neural network engine based on the work of predecessors.

The project chooses CNN as the core architecture because the 2D grid structure of the chessboard naturally aligns with CNN's image processing capabilities—convolutional layers capture local patterns (piece combinations, attack relationships), while deep layers abstract high-level strategic concepts (king safety, pawn structure, etc.). It uses supervised learning, training on real game data accumulated by humans instead of starting from scratch with self-play. The network has dual outputs: position evaluation (a numerical value indicating the dominant side) and move prediction (probability distribution of legal moves), supporting alpha-beta search and Monte Carlo Tree Search.

The project uses a modular code structure: the Engine directory contains search algorithms and position management logic; the dataset directory handles data loading and preprocessing; the logic directory implements chess rules (move legality, special rules). The modular design separates responsibilities, facilitating development and debugging (e.g., independently testing the evaluation network, replacing the architecture). The project provides a pre-trained weight file (chessnet_weights.pth), allowing users to use it directly without training from scratch.

Training steps: 1. Data preprocessing: Convert PGN games into the network input format (the chessboard is encoded as binary planes, and evaluation targets and best move labels are extracted); 2. Network training: Use gradient descent to optimize the loss function (a weighted combination of mean squared error for evaluation errors and cross-entropy for policy errors), which requires GPU computing resources; 3. Inference application: Combine search algorithms (alpha-beta or MCTS), call the network to evaluate candidate moves and select the best one. Pre-trained weights allow users to directly experience the chess playing strength.

This project follows a supervised learning approach similar to DeepChess (using real games), which is different from Leela Chess Zero's reinforcement learning (self-play). Compared to traditional engines like Stockfish: its advantages are capturing abstract global patterns without manual heuristic rules; its weaknesses are high computational cost (network forward propagation is slower than arithmetic operations), and the playing strength depends on the balance between network quality and search efficiency.

As an open-source learning project, its playing strength is hard to compete with top engines like Stockfish, but its value lies in education and research (understanding the application of deep learning in chess, serving as a foundation for courses/research). Applicable scenarios: learning deep learning applications in chess, course projects/experimental foundations, opening book preparation/tactical problem generation components. Pre-trained weights lower the usage threshold, allowing users without GPU resources to experience it.

This project demonstrates the application of deep learning in a classic AI problem (chess), using CNN to learn evaluation and move prediction from real games, providing a runnable starting point for developers. Although it is not the strongest engine, it represents the democratization trend of deep learning: developers can use open-source tools and pre-trained models to build AI applications, promoting learning and exploration in related fields.