Struct NNUE

pub struct NNUE { /* private fields */ }

NNUE (Efficiently Updatable Neural Network) for chess position evaluation This implementation is designed to work alongside vector-based position analysis

The key innovation is that NNUE provides fast, accurate position evaluation while the vector-based system provides strategic pattern recognition and similarity matching. Together they create a hybrid system that’s both fast and strategically aware.

Implementations

impl NNUE

pub fn new(config: NNUEConfig) -> CandleResult<Self>

Create a new NNUE evaluator with vector integration

pub fn new_with_weights( config: NNUEConfig, weights: Option<HashMap<String, Tensor>>, ) -> CandleResult<Self>

Create NNUE with optional pre-loaded weights

pub fn evaluate(&mut self, board: &Board) -> CandleResult<f32>

Evaluate a position using NNUE

pub fn evaluate_hybrid( &mut self, board: &Board, vector_eval: Option<f32>, ) -> CandleResult<f32>

Hybrid evaluation combining NNUE with vector-based analysis

pub fn train_batch(&mut self, positions: &[(Board, f32)]) -> CandleResult<f32>

Train the NNUE network on position data

pub fn update_incrementally( &mut self, board: &Board, _chess_move: ChessMove, ) -> CandleResult<()>

Incremental update when a move is made (NNUE efficiency feature)

pub fn set_vector_weight(&mut self, weight: f32)

Set the vector evaluation blend weight

pub fn are_weights_loaded(&self) -> bool

Check if weights were loaded from file

pub fn quick_fix_training( &mut self, positions: &[(Board, f32)], ) -> CandleResult<f32>

Quick training to fix evaluation issues when weights weren’t properly applied

pub fn incremental_train( &mut self, positions: &[(Board, f32)], preserve_best: bool, ) -> CandleResult<f32>

Incremental training that preserves existing progress

pub fn set_vector_integration(&mut self, enabled: bool)

Enable or disable vector integration

pub fn get_config(&self) -> NNUEConfig

Get current configuration

pub fn save_model(&mut self, path: &str) -> Result<(), Box<dyn Error>>

Save the trained model to a file with full weight serialization

pub fn load_model(&mut self, path: &str) -> Result<(), Box<dyn Error>>

Load a trained model from a file with full weight restoration

pub fn recreate_with_loaded_weights( &mut self, weights: HashMap<String, Tensor>, ) -> CandleResult<()>

Recreate the NNUE with loaded weights (workaround for candle-nn limitations)

pub fn get_eval_stats(&mut self, positions: &[Board]) -> CandleResult<EvalStats>

Get evaluation statistics for analysis