Upload folder using huggingface_hub

model_int8.onnx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e9978d354d36850b50e91f1efe65042c93aa9c34471e3e6044b4240d9592737
+size 473391

neural_engine/Cargo.toml

@@ -10,3 +10,4 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 rand = "0.8.5"
 rand_distr = "0.4.3"
+shakmaty-syzygy = "0.24.0"

neural_engine/src/main.rs

@@ -7,6 +7,10 @@ use shakmaty::zobrist::{Zobrist64, ZobristHash};
 use ort::session::Session;
 use ort::session::builder::GraphOptimizationLevel;
 use rand_distr::{Dirichlet, Distribution};
+use shakmaty_syzygy::{Tablebase, Wdl, AmbiguousWdl};
+
+mod polyglot;
+use polyglot::PolyglotBook;
 
 #[derive(Clone)]
 struct MCTSNode {
@@ -27,6 +31,27 @@ impl MCTSNode {
     }
 }
 
+fn extract_pv(node: &MCTSNode) -> Vec<String> {
+    let mut pv = Vec::new();
+    let mut current = node;
+    while !current.children.is_empty() {
+        let mut best_action = String::new();
+        let mut best_visits = -1;
+        for (action, child) in &current.children {
+            if (child.visit_count as i32) > best_visits {
+                best_visits = child.visit_count as i32;
+                best_action = action.clone();
+            }
+        }
+        if best_action.is_empty() || best_visits == 0 {
+            break;
+        }
+        pv.push(best_action.clone());
+        current = current.children.get(&best_action).unwrap();
+    }
+    pv
+}
+
 fn add_dirichlet_noise(node: &mut MCTSNode, alpha: f32, epsilon: f32) {
     if node.children.len() <= 1 { return; }
     let dirichlet = Dirichlet::new(&vec![alpha; node.children.len()]).unwrap();
@@ -56,6 +81,27 @@ fn material_difference(board: &Chess, color: shakmaty::Color) -> i32 {
     evaluate_material(board, color) - evaluate_material(board, other)
 }
 
+fn get_piece_value(role: shakmaty::Role) -> i32 {
+    match role {
+        shakmaty::Role::Pawn => 1,
+        shakmaty::Role::Knight => 3,
+        shakmaty::Role::Bishop => 3,
+        shakmaty::Role::Rook => 5,
+        shakmaty::Role::Queen => 9,
+        shakmaty::Role::King => 100,
+    }
+}
+
+fn score_move(m: &shakmaty::Move) -> i32 {
+    if m.is_capture() {
+        let victim = m.capture().map(|r| get_piece_value(r)).unwrap_or(0);
+        let attacker = get_piece_value(m.role());
+        1000 + victim * 10 - attacker
+    } else {
+        0
+    }
+}
+
 fn quiescence_search(board: &Chess, mut alpha: i32, beta: i32, depth: u8) -> i32 {
     let in_check = board.is_check();
     let stand_pat = material_difference(board, board.turn());
@@ -71,7 +117,9 @@ fn quiescence_search(board: &Chess, mut alpha: i32, beta: i32, depth: u8) -> i32
         }
     }
     
-    let legals = board.legal_moves();
+    let mut legals: Vec<_> = board.legal_moves().into_iter().collect();
+    legals.sort_by_cached_key(|m| -score_move(m));
+    
     for m in &legals {
         if m.is_capture() || in_check {
             let mut next_board = board.clone();
@@ -88,6 +136,51 @@ fn quiescence_search(board: &Chess, mut alpha: i32, beta: i32, depth: u8) -> i32
     alpha
 }
 
+fn tactical_search(board: &Chess, mut alpha: i32, beta: i32, depth: u8, qs_depth: u8) -> i32 {
+    if depth == 0 {
+        return quiescence_search(board, alpha, beta, qs_depth);
+    }
+    
+    if board.is_game_over() {
+        if board.is_checkmate() { return -9999; }
+        return 0;
+    }
+    
+    let mut legals: Vec<_> = board.legal_moves().into_iter().collect();
+    legals.sort_by_cached_key(|m| -score_move(m));
+    
+    let mut best_score = -99999;
+    let mut first = true;
+    
+    for m in &legals {
+        let mut next_board = board.clone();
+        next_board.play_unchecked(m);
+        
+        let score = if first {
+            -tactical_search(&next_board, -beta, -alpha, depth - 1, qs_depth)
+        } else {
+            let mut val = -tactical_search(&next_board, -alpha - 1, -alpha, depth - 1, qs_depth);
+            if val > alpha && val < beta {
+                val = -tactical_search(&next_board, -beta, -alpha, depth - 1, qs_depth);
+            }
+            val
+        };
+        
+        first = false;
+        if score > best_score {
+            best_score = score;
+        }
+        if best_score > alpha {
+            alpha = best_score;
+        }
+        if alpha >= beta {
+            break;
+        }
+    }
+    best_score
+}
+
+
 fn load_vocab() -> (HashMap<String, i64>, HashMap<i64, String>) {
     let data = fs::read_to_string("vocab.json").expect("Unable to read vocab.json. Please run build_engine.bat first to generate it!");
     let vocab: HashMap<String, i64> = serde_json::from_str(&data).expect("JSON format error");
@@ -161,6 +254,7 @@ fn mcts_simulate(
     vocab: &HashMap<String, i64>,
     inv_vocab: &HashMap<i64, String>,
     nn_cache: &mut HashMap<u64, (HashMap<String, f32>, f32)>,
+    tablebases: &mut Tablebase<Chess>,
 ) -> f32 {
     if board.is_game_over() {
         if board.is_checkmate() {
@@ -169,6 +263,18 @@ fn mcts_simulate(
         return 0.0; // Draw
     }
     
+    // Probe Syzygy Endgame Tablebases for positions with <= 7 pieces
+    if board.board().occupied().count() <= 7 {
+        if let Ok(wdl) = tablebases.probe_wdl(&board) {
+            let tb_value = match wdl {
+                AmbiguousWdl::Win | AmbiguousWdl::CursedWin | AmbiguousWdl::MaybeWin => 0.99,
+                AmbiguousWdl::Loss | AmbiguousWdl::BlessedLoss | AmbiguousWdl::MaybeLoss => -0.99,
+                AmbiguousWdl::Draw => 0.0,
+            };
+            return tb_value;
+        }
+    }
+    
     if node.children.is_empty() {
         // Expand
         let legals = board.legal_moves();
@@ -250,7 +356,7 @@ fn mcts_simulate(
     history.push(best_action.clone());
     
     let child_node = node.children.get_mut(&best_action).unwrap();
-    let val = mcts_simulate(child_node, next_board, history, session, vocab, inv_vocab, nn_cache);
+    let val = mcts_simulate(child_node, next_board, history, session, vocab, inv_vocab, nn_cache, tablebases);
     
     history.pop();
     
@@ -269,15 +375,21 @@ fn main() {
     // Ensure ONNX library is set up implicitly by ort
     let _ = ort::init().with_name("neural_engine").commit();
     
-    let mut session = if Path::new("model.onnx").exists() {
+    let mut session = if Path::new("model_int8.onnx").exists() {
         Some(Session::builder().unwrap()
             .with_optimization_level(GraphOptimizationLevel::Level3).unwrap()
             .with_intra_threads(4).unwrap()
-            .commit_from_file("model.onnx").unwrap())
+            .commit_from_file("model_int8.onnx").unwrap())
     } else {
         None
     };
     
+    let mut tablebases = Tablebase::<Chess>::new();
+    let _ = tablebases.add_directory("syzygy");
+    
+    // Load polyglot opening book if available
+    let polyglot_book = PolyglotBook::new("book.bin").ok();
+    
     let (vocab, inv_vocab) = load_vocab();
 
     let mut nn_cache: HashMap<u64, (HashMap<String, f32>, f32)> = HashMap::new();
@@ -397,61 +509,139 @@ fn main() {
                     movetime_ms = 100;
                 }
 
+                // --- 1. Polyglot Opening Book Check ---
+                if let Some(book) = &polyglot_book {
+                    let hash = board.zobrist_hash::<Zobrist64>(shakmaty::EnPassantMode::Legal).0;
+                    if let Some(book_move) = book.lookup(hash) {
+                        println!("bestmove {}", book_move);
+                        continue; // Skip MCTS completely
+                    }
+                }
+
                 if let Some(ref mut sess) = session {
                     let start_time = std::time::Instant::now();
                     // Leave a small buffer (5% or minimum 50ms) to ensure we reply in time
                     let buffer = (movetime_ms as f64 * 0.05) as u128;
-                    let safe_movetime = if movetime_ms > buffer { movetime_ms - buffer } else { movetime_ms };
-                    let limit = std::time::Duration::from_millis(safe_movetime as u64);
-                    
+                    let mut safe_movetime = if movetime_ms > buffer { movetime_ms - buffer } else { movetime_ms };
                     if global_root.children.is_empty() {
-                        mcts_simulate(&mut global_root, board.clone(), &mut history_moves, sess, &vocab, &inv_vocab, &mut nn_cache);
+                        mcts_simulate(&mut global_root, board.clone(), &mut history_moves, sess, &vocab, &inv_vocab, &mut nn_cache, &mut tablebases);
                     }
                     add_dirichlet_noise(&mut global_root, 0.3, 0.25);
                     
                     let mut iter_count = 0;
                     
                     // Loop continuously until time expires
-                    while start_time.elapsed() < limit {
-                        mcts_simulate(&mut global_root, board.clone(), &mut history_moves, sess, &vocab, &inv_vocab, &mut nn_cache);
+                    let mut extended = false;
+                    
+                    while (start_time.elapsed().as_millis() as u128) < safe_movetime {
+                        mcts_simulate(&mut global_root, board.clone(), &mut history_moves, sess, &vocab, &inv_vocab, &mut nn_cache, &mut tablebases);
                         iter_count += 1;
                         
-                        // Stream UCI info every 100 iterations so !eval works
+                        // Stream UCI info and check Dynamic Time Allocation every 100 iterations
                         if iter_count % 100 == 0 {
                             let mut best_eval = 0.0;
                             let mut best_visits = -1;
+                            let mut second_best_visits = -1;
                             let mut best_action = String::new();
+                            
                             for (action, child) in &global_root.children {
-                                if (child.visit_count as i32) > best_visits {
-                                    best_visits = child.visit_count as i32;
+                                let v = child.visit_count as i32;
+                                if v > best_visits {
+                                    second_best_visits = best_visits;
+                                    best_visits = v;
                                     best_action = action.clone();
                                     if child.visit_count > 0 {
                                         best_eval = child.value_sum / (child.visit_count as f32);
                                     }
+                                } else if v > second_best_visits {
+                                    second_best_visits = v;
                                 }
                             }
-                            let cp = (best_eval * 1000.0) as i32;
+                            
                             let time_ms = start_time.elapsed().as_millis();
-                            // We mock depth as 10 since MCTS doesn't use iterative deepening
-                            println!("info depth 10 nodes {} score cp {} time {} pv {}", iter_count, cp, time_ms, best_action);
+                            let cp = (best_eval * 1000.0) as i32;
+                            
+                            // --- 2. Dynamic Time Management ---
+                            if time_ms as f64 > (safe_movetime as f64 * 0.15) && best_visits > 500 {
+                                // Early Stopping: Move is overwhelmingly obvious
+                                if second_best_visits > 0 && best_visits > 10 * second_best_visits {
+                                    println!("info string Early stopping: move is obvious.");
+                                    break;
+                                }
+                            }
+                            
+                            if !extended && time_ms as f64 > (safe_movetime as f64 * 0.8) {
+                                // Time Extension: Position is critical and unsure
+                                if second_best_visits > 0 && best_visits < (second_best_visits as f64 * 1.2) as i32 {
+                                    let extra_time = (safe_movetime as f64 * 0.5) as u128;
+                                    let max_allowed = wtime / 10; // Avoid flagging
+                                    
+                                    if wtime == 0 || (safe_movetime + extra_time < max_allowed) {
+                                        safe_movetime += extra_time;
+                                        println!("info string Extending search time for critical position. New limit: {}ms", safe_movetime);
+                                        extended = true;
+                                    }
+                                }
+                            }
+                            let pv_moves = extract_pv(&global_root);
+                            let pv_str = pv_moves.join(" ");
+                            let depth = std::cmp::max(1, pv_moves.len());
+                            let nps = if time_ms > 0 { (iter_count as u128 * 1000) / time_ms } else { 0 };
+                            println!("info depth {} nodes {} nps {} score cp {} time {} pv {}", depth, iter_count, nps, cp, time_ms, pv_str);
                         }
                     }
                     
+                    // TACTICAL SAFETY NET
+                    let mut candidates: Vec<(&String, &MCTSNode)> = global_root.children.iter().collect();
+                    // Sort candidates by visit_count descending
+                    candidates.sort_by(|a, b| b.1.visit_count.cmp(&a.1.visit_count));
+                    
+                    let current_mat = material_difference(&board, board.turn());
+                    
                     let mut best_action = String::new();
-                    let mut best_visits = -1;
                     let mut best_eval = 0.0;
-                    for (action, child) in &global_root.children {
-                        if (child.visit_count as i32) > best_visits {
-                            best_visits = child.visit_count as i32;
-                            best_action = action.clone();
-                            if child.visit_count > 0 {
-                                best_eval = child.value_sum / (child.visit_count as f32);
+                    
+                    for (action, child) in candidates {
+                        let m_res = shakmaty::uci::Uci::from_ascii(action.as_bytes()).unwrap().to_move(&board);
+                        if let Ok(m) = m_res {
+                            let mut next_board = board.clone();
+                            next_board.play_unchecked(&m);
+                            
+                            // 3 plies of full search, then 4 plies of quiescence (starting from depth 0)
+                            let tact_score = -tactical_search(&next_board, -9999, 9999, 3, 0);
+                            
+                            // If it doesn't unconditionally drop >= 2 points of material, ACCEPT IT
+                            if tact_score > current_mat - 2 {
+                                best_action = action.clone();
+                                if child.visit_count > 0 {
+                                    best_eval = child.value_sum / (child.visit_count as f32);
+                                }
+                                break;
+                            }
+                        }
+                    }
+                    
+                    // Fallback to highest visited move if ALL top moves drop material (e.g. inevitable capture)
+                    if best_action.is_empty() {
+                        let mut best_visits = -1;
+                        for (action, child) in &global_root.children {
+                            if (child.visit_count as i32) > best_visits {
+                                best_visits = child.visit_count as i32;
+                                best_action = action.clone();
+                                if child.visit_count > 0 {
+                                    best_eval = child.value_sum / (child.visit_count as f32);
+                                }
                             }
                         }
                     }
                     if !best_action.is_empty() {
                         let cp = (best_eval * 1000.0) as i32;
-                        println!("info score cp {}", cp);
+                        let time_ms = start_time.elapsed().as_millis();
+                        let pv_moves = extract_pv(&global_root);
+                        let pv_str = pv_moves.join(" ");
+                        let depth = std::cmp::max(1, pv_moves.len());
+                        let nps = if time_ms > 0 { (iter_count as u128 * 1000) / time_ms } else { 0 };
+                        println!("info depth {} nodes {} nps {} score cp {} time {} pv {}", depth, iter_count, nps, cp, time_ms, pv_str);
                         println!("bestmove {}", best_action);
                     } else {
                         println!("bestmove 0000"); // fallback

neural_engine/src/polyglot.rs

@@ -0,0 +1,117 @@
+use std::fs::File;
+use std::io::{self, Read, Seek, SeekFrom};
+use rand::Rng;
+
+#[derive(Debug, Clone, Copy)]
+pub struct PolyglotEntry {
+    pub key: u64,
+    pub mov: u16,
+    pub weight: u16,
+    pub learn: u32,
+}
+
+pub struct PolyglotBook {
+    entries: Vec<PolyglotEntry>,
+}
+
+impl PolyglotBook {
+    pub fn new(path: &str) -> io::Result<Self> {
+        let mut file = File::open(path)?;
+        let mut buffer = Vec::new();
+        file.read_to_end(&mut buffer)?;
+        
+        let mut entries = Vec::with_capacity(buffer.len() / 16);
+        for chunk in buffer.chunks_exact(16) {
+            let key = u64::from_be_bytes(chunk[0..8].try_into().unwrap());
+            let mov = u16::from_be_bytes(chunk[8..10].try_into().unwrap());
+            let weight = u16::from_be_bytes(chunk[10..12].try_into().unwrap());
+            let learn = u32::from_be_bytes(chunk[12..16].try_into().unwrap());
+            
+            entries.push(PolyglotEntry { key, mov, weight, learn });
+        }
+        
+        Ok(PolyglotBook { entries })
+    }
+    
+    pub fn lookup(&self, key: u64) -> Option<String> {
+        // Binary search the entries for the first match
+        let start_idx = self.entries.binary_search_by_key(&key, |e| e.key).ok()?;
+        
+        // The binary search might hit any entry in a block of identical keys.
+        // Find the start of the block.
+        let mut first = start_idx;
+        while first > 0 && self.entries[first - 1].key == key {
+            first -= 1;
+        }
+        
+        // Find all moves for this key
+        let mut valid_moves = Vec::new();
+        let mut i = first;
+        while i < self.entries.len() && self.entries[i].key == key {
+            if self.entries[i].weight > 0 {
+                valid_moves.push(self.entries[i]);
+            }
+            i += 1;
+        }
+        
+        if valid_moves.is_empty() {
+            return None;
+        }
+        
+        // Weighted random choice
+        let total_weight: u32 = valid_moves.iter().map(|e| e.weight as u32).sum();
+        if total_weight == 0 {
+            // Fallback to random if all weights are somehow 0 (already handled above but just in case)
+            let chosen = valid_moves[rand::thread_rng().gen_range(0..valid_moves.len())];
+            return Some(polyglot_to_uci(chosen.mov));
+        }
+        
+        let mut rng = rand::thread_rng();
+        let mut random_weight = rng.gen_range(0..total_weight);
+        
+        for entry in valid_moves {
+            if random_weight < entry.weight as u32 {
+                return Some(polyglot_to_uci(entry.mov));
+            }
+            random_weight -= entry.weight as u32;
+        }
+        
+        None
+    }
+}
+
+pub fn polyglot_to_uci(mov: u16) -> String {
+    let to_file = mov & 7;
+    let to_rank = (mov >> 3) & 7;
+    let from_file = (mov >> 6) & 7;
+    let from_rank = (mov >> 9) & 7;
+    let promotion = (mov >> 12) & 7;
+    
+    let from_sq = format!("{}{}", (b'a' + from_file as u8) as char, (b'1' + from_rank as u8) as char);
+    let to_sq = format!("{}{}", (b'a' + to_file as u8) as char, (b'1' + to_rank as u8) as char);
+    
+    let prom_str = match promotion {
+        1 => "n",
+        2 => "b",
+        3 => "r",
+        4 => "q",
+        _ => "",
+    };
+    
+    // Polyglot encodes castling as King captures Rook.
+    // e1h1 becomes O-O, which in standard UCI is e1g1.
+    // Let's normalize it to standard UCI.
+    let is_castling = match (from_sq.as_str(), to_sq.as_str()) {
+        ("e1", "h1") => Some("e1g1"),
+        ("e1", "a1") => Some("e1c1"),
+        ("e8", "h8") => Some("e8g8"),
+        ("e8", "a8") => Some("e8c8"),
+        _ => None,
+    };
+    
+    if let Some(castling_move) = is_castling {
+        castling_move.to_string()
+    } else {
+        format!("{}{}{}", from_sq, to_sq, prom_str)
+    }
+}