README.md

metadata

license: cc-by-nc-4.0
library_name: onnx
tags:
  - chess
  - deep-learning
  - pytorch
  - onnx
  - resnet
  - strategy
  - game-ai
  - gambitflow
datasets:
  - Rafs-an09002/gambitflow-elite-data
language:
  - en
pipeline_tag: reinforcement-learning
metrics:
  - mse
model-index:
  - name: GambitFlow Nexus-core (CE)
    results: []

♟️ GambitFlow Nexus-core (CE)

Live Engine Demo • Dataset Card

📖 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-4 to 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