♟️ GambitFlow Nexus-core (CE)
-green){kind=icon}
📖 Model Overview
Nexus-core CE (Core Edition) is the primary engine of the GambitFlow project. It is a deep Residual Neural Network designed to evaluate chess positions with high-level human-like intuition. Unlike traditional engines that use manual "if-then" logic, Nexus-core learned chess strategy by analyzing over 5 million positions played by elite grandmaster-level players.
It serves as the static evaluation function (the "Brain") for the GambitFlow search algorithm, providing a numeric advantage score for any given board state.
🧠 Technical Architecture
The model is built using a Residual Neural Network (ResNet) architecture, inspired by the AlphaZero research but highly optimized for efficient inference in web browsers and low-power devices.
Specification Table
| Component | Specification | Description |
|---|---|---|
| Input Layer | (1, 12, 8, 8) |
12-channel bitboard representation (6 for White, 6 for Black pieces). |
| Convolutional Stem | 128 Filters, 3x3 | Initial spatial feature extraction from the 8x8 grid. |
| Residual Tower | 10 Blocks | A stack of 10 ResBlocks using Skip-Connections to prevent gradient vanishing and capture deep strategy. |
| Value Head | Dense / Tanh | Compresses 8192 high-level features into a single scalar evaluation. |
| Output Range | [-1.0, 1.0] |
Positive favors White, negative favors Black. |
| Params | ~3.5 Million | Balanced for high depth-to-speed ratio. |
📊 Training Methodology
Nexus-core was trained using a professional-grade pipeline designed for robustness and strategic depth.
1. The Elite Dataset
We utilized the gambitflow-elite-data corpus:
- Filtering: Only games where both players had ELO > 2000.
- Stage: Focused on the first 20 moves to master opening and middlegame transition.
- Volume: ~5,000,000 unique positions.
2. Training Protocol
- Mixed Precision: Trained using
torch.amp(FP16) for 2x faster convergence and memory efficiency. - Optimizer: AdamW with a weight decay of
1e-4to prevent overfitting. - Loss: MSE (Mean Squared Error) between the predicted value and the actual game result.
3. ONNX Optimization
- Exported with Opset 17.
- Constant Folding and Graph Optimization enabled to reduce latency during real-time play.
💻 Implementation (JavaScript)
Designed for seamless integration with onnxruntime-web.
import * as ort from 'onnxruntime-web';
// 1. Load the Brain
const session = await ort.InferenceSession.create('./chess_model_v2.onnx');
// 2. Prepare 12x8x8 Tensor (Encoded from FEN)
const inputTensor = new ort.Tensor('float32', boardData, [1, 12, 8, 8]);
// 3. Get Evaluation
const results = await session.run({ board_state: inputTensor });
const score = results.evaluation.data[0];
console.log("Nexus-core Evaluation:", score);
🛡️ License & Ethics
This model is shared under the Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0) license.
- Attribution: You must give credit to the GambitFlow project.
- Non-Commercial: This model cannot be used for commercial purposes without an explicit agreement.
- Innovation: We encourage researchers to fork and improve this model for non-commercial game-AI research.
Developed by Rafsan @ GambitFlow Labs