fix: properly scaling eval and perspective (pr #65)

bench: 1583604

Author: DeveloperPaul123

src/bin/hce-tuner/epd_parser.rs

@@ -5,7 +5,7 @@ use std::{
 
 use anyhow::{Result, anyhow};
 use chess::{bitboard_helpers, board::Board, pieces::Piece, side::Side};
-use engine::psqt::GAMEPHASE_INC;
+use engine::{hce_values::GAME_PHASE_MAX, psqt::GAMEPHASE_INC};
 
 use crate::{offsets::Offsets, tuning_position::TuningPosition};
 
@@ -77,25 +77,20 @@ fn parse_epd_line(line: &str) -> Result<TuningPosition> {
         }
     }
 
-    let stm = match board.side_to_move() {
-        Side::White => 1f64,
-        Side::Black => -1f64,
-        Side::Both => panic!("Side to move cannot be both."),
-    };
+    let is_white_relative = matches!(game_result, 0.0 | 0.5 | 1.0);
 
-    let result = match game_result {
-        // if we have an exact result, this indicates that we parsed a "book" file
-        // not an epd with centipawn evaluation
-        0.0 | 0.5 | 1.0 => game_result,
-        // otherwise, adjust based on the side to move
-        _ => match board.side_to_move() {
+    let result = if is_white_relative {
+        game_result
+    } else {
+        match board.side_to_move() {
             Side::White => game_result,
             Side::Black => 1.0 - game_result,
             Side::Both => panic!("Side to move cannot be both."),
-        },
+        }
     };
 
-    let tuning_pos = TuningPosition::new(w_indexes, b_indexes, phase, result, stm);
+    let scaled_phase = phase as f64 / (GAME_PHASE_MAX as f64);
+    let tuning_pos = TuningPosition::new(w_indexes, b_indexes, scaled_phase, result);
 
     Ok(tuning_pos)
 }
@@ -148,7 +143,7 @@ fn get_game_result(part: &str) -> Result<f64> {
 #[cfg(test)]
 mod tests {
     use chess::{board::Board, side::Side};
-    use engine::{evaluation::ByteKnightEvaluation, traits::Eval};
+    use engine::{evaluation::ByteKnightEvaluation, hce_values::GAME_PHASE_MAX, traits::Eval};
 
     use crate::{
         epd_parser::{get_game_result, process_epd_line},
@@ -208,20 +203,31 @@ mod tests {
             "r2q1rk1/ppp1npbp/4b1p1/1P3nN1/2Pp4/3P4/PB1NBPPP/R2QR1K1 b - - 0 1 [0.0]",
         ];
 
-        const EXPECTED_GAME_PHASES: [usize; 10] = [7, 18, 12, 10, 10, 8, 17, 20, 5, 24];
+        let mut expected_game_phases: [f64; 10] = [7., 18., 12., 10., 10., 8., 17., 20., 5., 24.];
+        for phase in &mut expected_game_phases {
+            *phase /= GAME_PHASE_MAX as f64;
+        }
+
         const EXPECTED_GAME_RESULTS: [f64; 10] = [0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0];
         let eval = ByteKnightEvaluation::default();
         let params = Parameters::create_from_engine_values();
 
         let parsed_results = test_epd_lines(&epd_lines);
 
         for (i, (position, board, result)) in parsed_results.iter().enumerate() {
-            assert_eq!(position.phase, EXPECTED_GAME_PHASES[i]);
+            assert_eq!(position.phase, expected_game_phases[i]);
             assert_eq!(position.game_result, EXPECTED_GAME_RESULTS[i]);
             assert_eq!(*result, EXPECTED_GAME_RESULTS[i]);
             // also verify that the evaluation matches
             let expected_value = eval.eval(board);
-            let val = position.evaluate(&params);
+
+            // tuning position evaluation is always from white's perspective
+            let val = match board.side_to_move() {
+                Side::White => position.evaluate(&params),
+                Side::Black => -position.evaluate(&params),
+                Side::Both => panic!("Side to move cannot be both."),
+            };
+
             println!("{} // {}", expected_value, val);
             assert!((expected_value.0 as f64 - val).abs().round() <= 1.0)
         }
@@ -265,7 +271,13 @@ mod tests {
             assert_eq!(position.game_result, expected_game_result);
             assert_eq!(*result, EXPECTED_PARSED_GAME_RESULTS[i]);
             let expected_value = eval.eval(board);
-            let val = position.evaluate(&params);
+
+            // tuning position evaluation is always from white's perspective
+            let val = match board.side_to_move() {
+                Side::White => position.evaluate(&params),
+                Side::Black => -position.evaluate(&params),
+                Side::Both => panic!("Side to move cannot be both."),
+            };
             println!("{} // {}", expected_value, val);
             assert!((expected_value.0 as f64 - val).abs().round() <= 1.0)
         }
@@ -299,7 +311,12 @@ mod tests {
             assert_eq!(position.game_result, EXPECTED_PARSED_GAME_RESULTS[i]);
             assert_eq!(*result, EXPECTED_PARSED_GAME_RESULTS[i]);
             let expected_value = eval.eval(board);
-            let val = position.evaluate(&params);
+            // tuning position evaluation is always from white's perspective
+            let val = match board.side_to_move() {
+                Side::White => position.evaluate(&params),
+                Side::Black => -position.evaluate(&params),
+                Side::Both => panic!("Side to move cannot be both."),
+            };
             println!("{} // {}", expected_value, val);
             assert!((expected_value.0 as f64 - val).abs().round() <= 1.0)
         }

src/bin/hce-tuner/main.rs

@@ -1,16 +1,15 @@
-use std::process::exit;
-
 use chess::{
     definitions::NumberOf,
     pieces::{ALL_PIECES, PIECE_NAMES},
 };
-use clap::Parser;
+use clap::{Parser, Subcommand, ValueEnum};
 use indicatif::ParallelProgressIterator;
 use parameters::Parameters;
 use rayon::iter::{IndexedParallelIterator, IntoParallelIterator, ParallelIterator};
 use textplots::{Chart, Plot, Shape};
 use tuner::Tuner;
 use tuner_score::TuningScore;
+use tuning_position::TuningPosition;
 mod epd_parser;
 mod math;
 mod offsets;
@@ -22,17 +21,42 @@ mod tuning_position;
 #[derive(Parser, Debug)]
 #[command(version, about="Texel tuner for HCE in byte-knight", long_about=None)]
 struct Options {
-    #[clap(short, long, help = "Filterd, marked EPD input data.")]
-    input_data: String,
-    #[clap(short, long, help = "Number of epochs to run.")]
-    epochs: Option<usize>,
-    #[clap(
-        long,
-        action,
-        default_value_t = false,
-        help = "Plot k versus error for the given dataset"
-    )]
-    plot_k: bool,
+    #[command(subcommand)]
+    command: Command,
+}
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum, Debug)]
+enum ParameterStartType {
+    Zero,
+    EngineValues,
+    PieceValues,
+}
+
+const INPUT_DATA_HELP: &str = "Filtered, marked EPD or 'book' input data.";
+#[derive(Subcommand, Debug)]
+enum Command {
+    Tune {
+        #[clap(short, long, help = INPUT_DATA_HELP)]
+        input_data: String,
+        #[clap(short, long, help = "Number of epochs to run.")]
+        epochs: Option<usize>,
+        #[arg(value_enum, short, long, help = "How to start the parameters", default_value_t = ParameterStartType::Zero)]
+        param_start_type: ParameterStartType,
+    },
+    PlotK {
+        #[clap(short, long, help = INPUT_DATA_HELP)]
+        input_data: String,
+    },
+    ComputeError {
+        #[clap(short, long, help = INPUT_DATA_HELP)]
+        input_data: String,
+        #[clap(
+            short,
+            long,
+            help = "k value to compute error for (0.009)",
+            default_value_t = 0.009
+        )]
+        k: f64,
+    },
 }
 
 fn print_table(indent: usize, table: &[TuningScore]) {
@@ -69,8 +93,8 @@ fn print_params(params: &Parameters) {
 
 fn plot_k(tuner: &Tuner) {
     let mut points = Vec::new();
-    let data_point_count = 10_000;
-    let k_min = -0.1;
+    let data_point_count = 1_000;
+    let k_min = 0.;
     let k_max = 0.1;
     (0..data_point_count)
         .into_par_iter()
@@ -84,26 +108,52 @@ fn plot_k(tuner: &Tuner) {
 
     Chart::new(180, 60, k_min as f32, k_max as f32)
         .lineplot(&Shape::Points(points.as_slice()))
-        .display();
+        .nice();
 }
 
-fn main() {
-    let options = Options::parse();
-    println!("Reading data from: {}", options.input_data);
-    let positions = epd_parser::parse_epd_file(options.input_data.as_str());
+fn parse_data(input_data: &str) -> Vec<TuningPosition> {
+    println!("Reading data from: {}", input_data);
+    let positions = epd_parser::parse_epd_file(input_data);
     // let positions = get_positions();
     println!("Read {} positions", positions.len());
+    positions
+}
 
-    let epochs = options.epochs.unwrap_or(10_000);
-    let parameters = Parameters::create_from_engine_values();
-    let mut tuner = tuner::Tuner::new(parameters, &positions, epochs);
-
-    if options.plot_k {
-        plot_k(&tuner);
-        exit(0);
+fn main() {
+    let options = Options::parse();
+    match options.command {
+        Command::Tune {
+            input_data,
+            epochs,
+            param_start_type,
+        } => {
+            let positions = parse_data(&input_data);
+            let parameters = match param_start_type {
+                ParameterStartType::Zero => Parameters::default(),
+                ParameterStartType::EngineValues => Parameters::create_from_engine_values(),
+                ParameterStartType::PieceValues => Parameters::create_from_piece_values(),
+            };
+            let epchs = epochs.unwrap_or(10_000);
+            println!(
+                "Tuning parameters from {:?} for {} epochs",
+                param_start_type, epchs
+            );
+            let mut tuner = tuner::Tuner::new(parameters, &positions, epchs);
+            let tuned_results = tuner.tune();
+            print_params(tuned_results);
+        }
+        Command::PlotK { input_data } => {
+            let positions = parse_data(&input_data);
+            let parameters = Parameters::create_from_engine_values();
+            let tuner = tuner::Tuner::new(parameters, &positions, 10_000);
+            plot_k(&tuner);
+        }
+        Command::ComputeError { input_data, k } => {
+            let positions = parse_data(&input_data);
+            let parameters = Parameters::create_from_engine_values();
+            let tuner = tuner::Tuner::new(parameters, &positions, 10_000);
+            let error = tuner.mean_square_error(k);
+            println!("Error for k {:.8}: {:.8}", k, error);
+        }
     }
-
-    let tuned_result = tuner.tune();
-
-    print_params(tuned_result);
 }

src/bin/hce-tuner/parameters.rs

@@ -69,8 +69,7 @@ impl Parameters {
             let sigmoid_result = math::sigmoid(k * point.evaluate(self));
             let term =
                 (point.game_result - sigmoid_result) * (1. - sigmoid_result) * sigmoid_result;
-            let phase_adjustment =
-                term * TuningScore::new(point.phase as f64, 1f64 - point.phase as f64);
+            let phase_adjustment = term * TuningScore::new(point.phase, 1. - point.phase);
 
             for idx in &point.parameter_indexes[Side::White as usize] {
                 gradient[*idx] += phase_adjustment;

src/bin/hce-tuner/tuner.rs

@@ -32,7 +32,7 @@ impl<'a> Tuner<'a> {
     pub(crate) fn tune(&mut self) -> &Parameters {
         println!("Computing optimal K value...");
         let computed_k: f64 = self.compute_k();
-        println!("Optimal K value: {}", computed_k);
+        println!("Optimal K value: {:.8}", computed_k);
         println!("Using {} positions", self.positions.len());
 
         for epoch in 1..=self.max_epochs {
@@ -102,7 +102,7 @@ impl<'a> Tuner<'a> {
 
     /// Computes the optimal K value to minimize the error of the initial parameters.
     /// Taken from https://github.com/jw1912/hce-tuner/
-    fn compute_k(&self) -> f64 {
+    pub(crate) fn compute_k(&self) -> f64 {
         let mut k = 0.009;
         let delta = 0.00001;
         let goal = 0.000001;

src/bin/hce-tuner/tuner_score.rs

@@ -29,10 +29,15 @@ impl TuningScore {
         Self::new(self.mg().sqrt(), self.eg().sqrt())
     }
 
-    pub fn taper(&self, phase: f64, max_phase: f64) -> f64 {
-        let mg_phase = phase.min(max_phase);
-        let eg_phase = max_phase - mg_phase;
-        (self.mg() * mg_phase + self.eg() * eg_phase) / max_phase
+    /// Taper the score based on the phase of the game.
+    ///
+    /// # Arguments
+    /// * `phase` - The current phase of the game. This should already be scaled to the range [0, max_phase].
+    ///
+    /// # Returns
+    /// The tapered score.
+    pub fn taper(&self, phase: f64) -> f64 {
+        self.mg() * phase + self.eg() * (1. - phase)
     }
 }
 

src/bin/hce-tuner/tuning_position.rs

@@ -1,33 +1,34 @@
 use chess::{definitions::NumberOf, side::Side};
-use engine::hce_values::GAME_PHASE_MAX;
 
 use crate::{math, parameters::Parameters, tuner_score::TuningScore};
 
 pub(crate) struct TuningPosition {
     pub(crate) parameter_indexes: [Vec<usize>; NumberOf::SIDES],
-    pub(crate) phase: usize,
+    pub(crate) phase: f64,
     pub(crate) game_result: f64,
-    pub(crate) side_to_move: f64,
 }
 
 impl TuningPosition {
     pub(crate) fn new(
         white_indexes: Vec<usize>,
         black_indexes: Vec<usize>,
-        phase: usize,
+        phase: f64,
         game_result: f64,
-        side_to_move: f64,
     ) -> Self {
         // Side::White == 0, Side::Black == 1
         let parameter_indexes = [white_indexes, black_indexes];
         Self {
             parameter_indexes,
             phase,
             game_result,
-            side_to_move,
         }
     }
 
+    /// Evaluate the tuning position based on the given parameters from white's perspective.
+    /// # Arguments
+    /// * `parameters` - The parameters to evaluate.
+    /// # Returns
+    /// The evaluated score from white's perspective.
     pub(crate) fn evaluate(&self, parameters: &Parameters) -> f64 {
         let mut score: TuningScore = Default::default();
 
@@ -39,7 +40,7 @@ impl TuningPosition {
             score -= parameters[idx];
         }
 
-        score.taper(self.phase as f64, GAME_PHASE_MAX as f64) * self.side_to_move
+        score.taper(self.phase)
     }
 
     pub(crate) fn error(&self, k: f64, params: &Parameters) -> f64 {