Upload folder using huggingface_hub

Dockerfile

@@ -41,8 +41,8 @@ RUN mkdir -p Neurex_Engine && \
     cp model.onnx Neurex_Engine/ || true && \
     cp vocab.json Neurex_Engine/ || true
 
-# Download the massive model.onnx.data from our model repository directly into the root folder (where model.onnx is)
-RUN curl -L -o ./model.onnx.data https://huggingface.co/dpv007/Neurex-Weights/resolve/main/model.onnx.data
+# Download the massive model_int8.onnx.data from our model repository directly into the root folder (where model_int8.onnx is)
+RUN curl -L -o ./model_int8.onnx.data https://huggingface.co/dpv007/Neurex-Weights/resolve/main/model_int8.onnx.data
 
 # Make engines executable
 RUN chmod +x Neurex_Engine/Neurex && \

model_int8.onnx

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

neural_engine/src/main.rs

@@ -246,10 +246,40 @@ fn evaluate_onnx(
     (policy_map, value)
 }
 
+fn endgame_heuristic(board: &Chess) -> f32 {
+    let mut score = 0.0;
+    let turn = board.turn();
+    
+    // 1. King Centralization
+    if let Some(my_king) = board.board().king_of(turn) {
+        let file = my_king.file() as i8;
+        let rank = my_king.rank() as i8;
+        
+        let dist_f = (file - 3).abs().min((file - 4).abs());
+        let dist_r = (rank - 3).abs().min((rank - 4).abs());
+        let manhattan = dist_f + dist_r;
+        
+        score += (6.0 - manhattan as f32) * 0.05;
+    }
+    
+    // 2. Passed Pawns (advanced pawns bonus)
+    let my_pawns = board.board().pawns() & board.board().by_color(turn);
+    for sq in my_pawns {
+        let r = sq.rank() as i8;
+        let relative_rank = if turn == shakmaty::Color::White { r } else { 7 - r };
+        if relative_rank >= 4 { // 5th rank or higher
+            score += (relative_rank as f32 - 3.0) * 0.05;
+        }
+    }
+    
+    score
+}
+
 fn mcts_simulate(
     node: &mut MCTSNode,
     board: Chess,
     history: &mut Vec<String>,
+    history_hashes: &mut Vec<u64>,
     session: &mut Session,
     vocab: &HashMap<String, i64>,
     inv_vocab: &HashMap<i64, String>,
@@ -263,6 +293,19 @@ fn mcts_simulate(
         return 0.0; // Draw
     }
     
+    // Draw Avoidance by 3-fold Repetition
+    let current_hash = board.zobrist_hash::<Zobrist64>(shakmaty::EnPassantMode::Legal).0;
+    let mut hash_count = 0;
+    for &h in history_hashes.iter() {
+        if h == current_hash {
+            hash_count += 1;
+        }
+    }
+    // If the hash appears at least twice in the history path before this node, it's a 3-fold draw!
+    if hash_count >= 2 {
+        return 0.0;
+    }
+    
     // Probe Syzygy Endgame Tablebases for positions with <= 7 pieces
     if board.board().occupied().count() <= 7 {
         if let Ok(wdl) = tablebases.probe_wdl(&board) {
@@ -314,6 +357,12 @@ fn mcts_simulate(
             value = -0.95; // They are losing
         }
         
+        // Phase 3: Endgame Knowledge Heuristics (8-10 pieces)
+        if board.board().occupied().count() <= 10 {
+            value += endgame_heuristic(&board);
+            value = value.clamp(-0.99, 0.99);
+        }
+        
         for m in &legals {
             let uci = m.to_uci(CastlingMode::Standard).to_string();
             let p = policy.get(&uci).copied().unwrap_or(0.0);
@@ -355,10 +404,14 @@ fn mcts_simulate(
     next_board.play_unchecked(&m);
     history.push(best_action.clone());
     
+    let next_hash = next_board.zobrist_hash::<Zobrist64>(shakmaty::EnPassantMode::Legal).0;
+    history_hashes.push(next_hash);
+    
     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, tablebases);
+    let val = mcts_simulate(child_node, next_board, history, history_hashes, session, vocab, inv_vocab, nn_cache, tablebases);
     
     history.pop();
+    history_hashes.pop();
     
     node.visit_count += 1;
     node.value_sum += val;
@@ -371,6 +424,7 @@ fn main() {
     let stdin = io::stdin();
     let mut board = Chess::default();
     let mut history_moves = vec!["<bos>".to_string()];
+    let mut history_hashes = Vec::new();
     
     // Ensure ONNX library is set up implicitly by ort
     let _ = ort::init().with_name("neural_engine").commit();
@@ -415,6 +469,8 @@ fn main() {
                 let old_history = history_moves.clone();
                 history_moves.clear();
                 history_moves.push("<bos>".to_string());
+                history_hashes.clear();
+                history_hashes.push(board.zobrist_hash::<Zobrist64>(shakmaty::EnPassantMode::Legal).0);
                 
                 if tokens.contains(&"moves") {
                     let moves_idx = tokens.iter().position(|&r| r == "moves").unwrap();
@@ -423,6 +479,7 @@ fn main() {
                             if let Ok(m) = uci_move.to_move(&board) {
                                 board.play_unchecked(&m);
                                 history_moves.push(m_str.to_string());
+                                history_hashes.push(board.zobrist_hash::<Zobrist64>(shakmaty::EnPassantMode::Legal).0);
                             }
                         }
                     }
@@ -524,7 +581,7 @@ fn main() {
                     let buffer = (movetime_ms as f64 * 0.05) as u128;
                     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, &mut tablebases);
+                        mcts_simulate(&mut global_root, board.clone(), &mut history_moves, &mut history_hashes, sess, &vocab, &inv_vocab, &mut nn_cache, &mut tablebases);
                     }
                     add_dirichlet_noise(&mut global_root, 0.3, 0.25);
                     
@@ -534,7 +591,7 @@ fn main() {
                     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);
+                        mcts_simulate(&mut global_root, board.clone(), &mut history_moves, &mut history_hashes, sess, &vocab, &inv_vocab, &mut nn_cache, &mut tablebases);
                         iter_count += 1;
                         
                         // Stream UCI info and check Dynamic Time Allocation every 100 iterations