Add max_generations next to max_stale_generations as ending condition (both blocked by valid_fitness_score), just for completeness

Author: basvanwesting

src/strategy.rs

@@ -52,6 +52,7 @@
 //!     .with_target_fitness_score(0)                           // (E,H) ending condition if 0 times true in the best chromosome
 //!     .with_valid_fitness_score(1)                            // (E,H) block ending conditions until at most a 1 times true in the best chromosome
 //!     .with_max_stale_generations(100)                        // (E,H) stop searching if there is no improvement in fitness score for 100 generations
+//!     .with_max_generations(1_000_000)                        // (E,H) optional, stop searching after 1M generations
 //!     .with_max_chromosome_age(10)                            // (E) kill chromosomes after 10 generations
 //!     .with_reporter(StrategyReporterSimple::new(usize::MAX)) // (E,H,P) optional builder step, report on new best chromsomes only
 //!     .with_replace_on_equal_fitness(true)                    // (E,H,P) optional, defaults to false, maybe useful to avoid repeatedly seeding with the same best chromosomes after mass extinction events

src/strategy/builder.rs

@@ -33,6 +33,7 @@ pub struct Builder<
     pub fitness_cache: Option<FitnessCache>,
     pub max_chromosome_age: Option<usize>,
     pub max_stale_generations: Option<usize>,
+    pub max_generations: Option<usize>,
     pub mutate: Option<M>,
     pub par_fitness: bool,
     pub replace_on_equal_fitness: bool,
@@ -58,6 +59,7 @@ impl<
             variant: None,
             target_population_size: 0,
             max_stale_generations: None,
+            max_generations: None,
             max_chromosome_age: None,
             target_fitness_score: None,
             valid_fitness_score: None,
@@ -122,6 +124,14 @@ impl<
         self.max_stale_generations = max_stale_generations_option;
         self
     }
+    pub fn with_max_generations(mut self, max_generations: usize) -> Self {
+        self.max_generations = Some(max_generations);
+        self
+    }
+    pub fn with_max_generations_option(mut self, max_generations_option: Option<usize>) -> Self {
+        self.max_generations = max_generations_option;
+        self
+    }
     pub fn with_max_chromosome_age(mut self, max_chromosome_age: usize) -> Self {
         self.max_chromosome_age = Some(max_chromosome_age);
         self
@@ -199,6 +209,7 @@ impl<
             variant: self.variant,
             target_population_size: self.target_population_size,
             max_stale_generations: self.max_stale_generations,
+            max_generations: self.max_generations,
             max_chromosome_age: self.max_chromosome_age,
             target_fitness_score: self.target_fitness_score,
             valid_fitness_score: self.valid_fitness_score,
@@ -224,6 +235,7 @@ impl<
             variant: self.variant,
             target_population_size: self.target_population_size,
             max_stale_generations: self.max_stale_generations,
+            max_generations: self.max_generations,
             max_chromosome_age: self.max_chromosome_age,
             target_fitness_score: self.target_fitness_score,
             valid_fitness_score: self.valid_fitness_score,
@@ -291,6 +303,7 @@ impl<
             genotype: self.genotype,
             target_population_size: self.target_population_size,
             max_stale_generations: self.max_stale_generations,
+            max_generations: self.max_generations,
             max_chromosome_age: self.max_chromosome_age,
             target_fitness_score: self.target_fitness_score,
             valid_fitness_score: self.valid_fitness_score,
@@ -312,6 +325,7 @@ impl<
             genotype: self.genotype,
             variant: None,
             max_stale_generations: self.max_stale_generations,
+            max_generations: self.max_generations,
             target_fitness_score: self.target_fitness_score,
             valid_fitness_score: self.valid_fitness_score,
             fitness_ordering: self.fitness_ordering,

src/strategy/evolve.rs

@@ -52,6 +52,7 @@ pub enum EvolveVariant {
 /// * target_fitness_score: when the ultimate goal in terms of fitness score is known and reached
 /// * max_stale_generations: when the ultimate goal in terms of fitness score is unknown and one depends on some convergion
 ///   threshold, or one wants a duration limitation next to the target_fitness_score
+/// * max_generations: when the ultimate goal in terms of fitness score is unknown and there is a effort constraint
 ///
 /// General Hyper-parameters:
 /// * `replacement_rate` (selection): the target fraction of the population which exists of
@@ -156,7 +157,8 @@ pub enum EvolveVariant {
 ///     .with_target_population_size(100)                       // evolve with 100 chromosomes
 ///     .with_target_fitness_score(0)                           // ending condition if 0 times true in the best chromosome
 ///     .with_valid_fitness_score(10)                           // block ending conditions until at most a 10 times true in the best chromosome
-///     .with_max_stale_generations(1000)                       // stop searching if there is no improvement in fitness score for 1000 generations
+///     .with_max_stale_generations(1000)                       // stop searching if there is no improvement in fitness score for 1000 generations (per scaled_range)
+///     .with_max_generations(1_000_000)                        // optional, stop searching after 1M generations
 ///     .with_max_chromosome_age(10)                            // kill chromosomes after 10 generations
 ///     .with_reporter(EvolveReporterSimple::new(100))          // optional builder step, report every 100 generations
 ///     .with_replace_on_equal_fitness(true)                    // optional, defaults to false, maybe useful to avoid repeatedly seeding with the same best chromosomes after mass extinction events
@@ -202,6 +204,7 @@ pub struct EvolveConfig {
 
     pub target_fitness_score: Option<FitnessValue>,
     pub max_stale_generations: Option<usize>,
+    pub max_generations: Option<usize>,
     pub valid_fitness_score: Option<FitnessValue>,
     pub fitness_cache: Option<FitnessCache>,
 
@@ -410,6 +413,7 @@ impl<
     fn is_finished(&self) -> bool {
         self.allow_finished_by_valid_fitness_score()
             && (self.is_finished_by_max_stale_generations()
+                || self.is_finished_by_max_generations()
                 || self.is_finished_by_target_fitness_score())
     }
 
@@ -421,6 +425,14 @@ impl<
         }
     }
 
+    fn is_finished_by_max_generations(&self) -> bool {
+        if let Some(max_generations) = self.config.max_generations {
+            self.state.current_generation >= max_generations
+        } else {
+            false
+        }
+    }
+
     fn is_finished_by_target_fitness_score(&self) -> bool {
         if let Some(target_fitness_score) = self.config.target_fitness_score {
             if let Some(fitness_score) = self.best_fitness_score() {
@@ -653,10 +665,12 @@ impl<
             Err(TryFromEvolveBuilderError(
                 "Evolve requires a target_population_size > 0",
             ))
-        } else if builder.max_stale_generations.is_none() && builder.target_fitness_score.is_none()
+        } else if builder.max_stale_generations.is_none()
+            && builder.max_generations.is_none()
+            && builder.target_fitness_score.is_none()
         {
             Err(TryFromEvolveBuilderError(
-                "Evolve requires at least a max_stale_generations or target_fitness_score ending condition",
+                "Evolve requires at least a max_stale_generations, max_generations or target_fitness_score ending condition",
             ))
         } else {
             let rng = builder.rng();
@@ -676,6 +690,7 @@ impl<
                 config: EvolveConfig {
                     target_population_size,
                     max_stale_generations: builder.max_stale_generations,
+                    max_generations: builder.max_generations,
                     max_chromosome_age: builder.max_chromosome_age,
                     target_fitness_score: builder.target_fitness_score,
                     valid_fitness_score: builder.valid_fitness_score,
@@ -699,6 +714,7 @@ impl Default for EvolveConfig {
             variant: Default::default(),
             target_population_size: 0,
             max_stale_generations: None,
+            max_generations: None,
             max_chromosome_age: None,
             target_fitness_score: None,
             valid_fitness_score: None,
@@ -785,6 +801,7 @@ impl fmt::Display for EvolveConfig {
             "  max_stale_generations: {:?}",
             self.max_stale_generations
         )?;
+        writeln!(f, "  max_generations: {:?}", self.max_generations)?;
         writeln!(f, "  max_chromosome_age: {:?}", self.max_chromosome_age)?;
         writeln!(f, "  valid_fitness_score: {:?}", self.valid_fitness_score)?;
         writeln!(f, "  target_fitness_score: {:?}", self.target_fitness_score)?;

src/strategy/evolve/builder.rs

@@ -26,6 +26,7 @@ pub struct Builder<
     pub genotype: Option<G>,
     pub target_population_size: usize,
     pub max_stale_generations: Option<usize>,
+    pub max_generations: Option<usize>,
     pub max_chromosome_age: Option<usize>,
     pub target_fitness_score: Option<FitnessValue>,
     pub valid_fitness_score: Option<FitnessValue>,
@@ -50,6 +51,7 @@ impl<G: EvolveGenotype, M: Mutate, F: Fitness<Genotype = G>, S: Crossover, C: Se
             genotype: None,
             target_population_size: 0,
             max_stale_generations: None,
+            max_generations: None,
             max_chromosome_age: None,
             target_fitness_score: None,
             valid_fitness_score: None,
@@ -109,6 +111,14 @@ impl<
         self.max_stale_generations = max_stale_generations_option;
         self
     }
+    pub fn with_max_generations(mut self, max_generations: usize) -> Self {
+        self.max_generations = Some(max_generations);
+        self
+    }
+    pub fn with_max_generations_option(mut self, max_generations_option: Option<usize>) -> Self {
+        self.max_generations = max_generations_option;
+        self
+    }
     pub fn with_max_chromosome_age(mut self, max_chromosome_age: usize) -> Self {
         self.max_chromosome_age = Some(max_chromosome_age);
         self
@@ -185,6 +195,7 @@ impl<
             genotype: self.genotype,
             target_population_size: self.target_population_size,
             max_stale_generations: self.max_stale_generations,
+            max_generations: self.max_generations,
             max_chromosome_age: self.max_chromosome_age,
             target_fitness_score: self.target_fitness_score,
             valid_fitness_score: self.valid_fitness_score,
@@ -209,6 +220,7 @@ impl<
             genotype: self.genotype,
             target_population_size: self.target_population_size,
             max_stale_generations: self.max_stale_generations,
+            max_generations: self.max_generations,
             max_chromosome_age: self.max_chromosome_age,
             target_fitness_score: self.target_fitness_score,
             valid_fitness_score: self.valid_fitness_score,

src/strategy/hill_climb.rs

@@ -53,6 +53,7 @@ pub enum HillClimbVariant {
 ///   * set to a low value for [HillClimbVariant::SteepestAscent], preferably even `1`, unless
 ///   there is a replace_on_equal_fitness consideration or some remaining randomness in the neighbouring population (see RangeGenotype
 ///   below)
+/// * max_generations: when the ultimate goal in terms of fitness score is unknown and there is a effort constraint
 ///
 /// There are optional mutation distance limitations for
 /// [RangeGenotype](crate::genotype::RangeGenotype) and
@@ -131,7 +132,8 @@ pub enum HillClimbVariant {
 ///     .with_par_fitness(true)                           // optional, defaults to false, use parallel fitness calculation
 ///     .with_target_fitness_score(0)                     // ending condition if sum of genes is <= 0.00001 in the best chromosome
 ///     .with_valid_fitness_score(100)                    // block ending conditions until at least the sum of genes <= 0.00100 is reached in the best chromosome
-///     .with_max_stale_generations(1000)                 // stop searching if there is no improvement in fitness score for 1000 generations
+///     .with_max_stale_generations(1000)                 // stop searching if there is no improvement in fitness score for 1000 generations (per scaled_range)
+///     .with_max_generations(1_000_000)                  // optional, stop searching after 1M generations
 ///     .with_replace_on_equal_fitness(true)              // optional, defaults to true, crucial for some type of problems with discrete fitness steps like nqueens
 ///     .with_reporter(HillClimbReporterSimple::new(100)) // optional, report every 100 generations
 ///     .with_rng_seed_from_u64(0)                        // for testing with deterministic results
@@ -164,6 +166,7 @@ pub struct HillClimbConfig {
 
     pub target_fitness_score: Option<FitnessValue>,
     pub max_stale_generations: Option<usize>,
+    pub max_generations: Option<usize>,
     pub valid_fitness_score: Option<FitnessValue>,
     pub fitness_cache: Option<FitnessCache>,
 }
@@ -340,6 +343,7 @@ impl<G: HillClimbGenotype, F: Fitness<Genotype = G>, SR: StrategyReporter<Genoty
     fn is_finished(&self) -> bool {
         self.allow_finished_by_valid_fitness_score()
             && (self.is_finished_by_max_stale_generations()
+                || self.is_finished_by_max_generations()
                 || self.is_finished_by_target_fitness_score())
     }
 
@@ -351,6 +355,14 @@ impl<G: HillClimbGenotype, F: Fitness<Genotype = G>, SR: StrategyReporter<Genoty
         }
     }
 
+    fn is_finished_by_max_generations(&self) -> bool {
+        if let Some(max_generations) = self.config.max_generations {
+            self.state.current_generation >= max_generations
+        } else {
+            false
+        }
+    }
+
     fn is_finished_by_target_fitness_score(&self) -> bool {
         if let Some(target_fitness_score) = self.config.target_fitness_score {
             if let Some(fitness_score) = self.best_fitness_score() {
@@ -549,10 +561,12 @@ impl<G: HillClimbGenotype, F: Fitness<Genotype = G>, SR: StrategyReporter<Genoty
             ))
         } else if builder.fitness.is_none() {
             Err(TryFromHillClimbBuilderError("HillClimb requires a Fitness"))
-        } else if builder.max_stale_generations.is_none() && builder.target_fitness_score.is_none()
+        } else if builder.max_stale_generations.is_none()
+            && builder.max_generations.is_none()
+            && builder.target_fitness_score.is_none()
         {
             Err(TryFromHillClimbBuilderError(
-                "HillClimb requires at least a max_stale_generations or target_fitness_score ending condition",
+                "HillClimb requires at least a max_stale_generations, max_generations or target_fitness_score ending condition",
             ))
         } else {
             let rng = builder.rng();
@@ -568,6 +582,7 @@ impl<G: HillClimbGenotype, F: Fitness<Genotype = G>, SR: StrategyReporter<Genoty
                     fitness_cache: builder.fitness_cache,
                     par_fitness: builder.par_fitness,
                     max_stale_generations: builder.max_stale_generations,
+                    max_generations: builder.max_generations,
                     target_fitness_score: builder.target_fitness_score,
                     valid_fitness_score: builder.valid_fitness_score,
                     replace_on_equal_fitness: builder.replace_on_equal_fitness,
@@ -588,6 +603,7 @@ impl Default for HillClimbConfig {
             fitness_cache: None,
             par_fitness: false,
             max_stale_generations: None,
+            max_generations: None,
             target_fitness_score: None,
             valid_fitness_score: None,
             replace_on_equal_fitness: false,
@@ -648,6 +664,7 @@ impl fmt::Display for HillClimbConfig {
             "  max_stale_generations: {:?}",
             self.max_stale_generations
         )?;
+        writeln!(f, "  max_generations: {:?}", self.max_generations)?;
         writeln!(f, "  valid_fitness_score: {:?}", self.valid_fitness_score)?;
         writeln!(f, "  target_fitness_score: {:?}", self.target_fitness_score)?;
         writeln!(f, "  fitness_ordering: {:?}", self.fitness_ordering)?;

src/strategy/hill_climb/builder.rs

@@ -23,6 +23,7 @@ pub struct Builder<
     pub fitness_cache: Option<FitnessCache>,
     pub par_fitness: bool,
     pub max_stale_generations: Option<usize>,
+    pub max_generations: Option<usize>,
     pub target_fitness_score: Option<FitnessValue>,
     pub valid_fitness_score: Option<FitnessValue>,
     pub replace_on_equal_fitness: bool,
@@ -42,6 +43,7 @@ impl<G: HillClimbGenotype, F: Fitness<Genotype = G>> Default
             fitness_cache: None,
             par_fitness: false,
             max_stale_generations: None,
+            max_generations: None,
             target_fitness_score: None,
             valid_fitness_score: None,
             replace_on_equal_fitness: true,
@@ -103,6 +105,14 @@ impl<G: HillClimbGenotype, F: Fitness<Genotype = G>, SR: StrategyReporter<Genoty
         self.max_stale_generations = max_stale_generations_option;
         self
     }
+    pub fn with_max_generations(mut self, max_generations: usize) -> Self {
+        self.max_generations = Some(max_generations);
+        self
+    }
+    pub fn with_max_generations_option(mut self, max_generations_option: Option<usize>) -> Self {
+        self.max_generations = max_generations_option;
+        self
+    }
     pub fn with_target_fitness_score(mut self, target_fitness_score: FitnessValue) -> Self {
         self.target_fitness_score = Some(target_fitness_score);
         self
@@ -141,6 +151,7 @@ impl<G: HillClimbGenotype, F: Fitness<Genotype = G>, SR: StrategyReporter<Genoty
             fitness_cache: self.fitness_cache,
             par_fitness: self.par_fitness,
             max_stale_generations: self.max_stale_generations,
+            max_generations: self.max_generations,
             target_fitness_score: self.target_fitness_score,
             valid_fitness_score: self.valid_fitness_score,
             replace_on_equal_fitness: self.replace_on_equal_fitness,

tests/strategy/evolve_test.rs

@@ -26,7 +26,7 @@ fn build_invalid_missing_ending_condition() {
     assert_eq!(
         evolve.err(),
         Some(TryFromEvolveBuilderError(
-            "Evolve requires at least a max_stale_generations or target_fitness_score ending condition"
+            "Evolve requires at least a max_stale_generations, max_generations or target_fitness_score ending condition"
         ))
     );
 }
@@ -141,6 +141,34 @@ fn call_binary_max_stale_generations_minimize() {
     );
 }
 
+#[test]
+fn call_binary_max_generations_maximize() {
+    let genotype = BinaryGenotype::builder()
+        .with_genes_size(10)
+        .build()
+        .unwrap();
+    let evolve = Evolve::builder()
+        .with_genotype(genotype)
+        .with_target_population_size(100)
+        .with_max_generations(50)
+        .with_mutate(MutateSingleGene::new(0.1))
+        .with_fitness(CountTrue)
+        .with_crossover(CrossoverSingleGene::new(0.7, 0.8))
+        .with_select(SelectTournament::new(0.5, 0.02, 4))
+        .with_extension(ExtensionNoop::new())
+        .with_reporter(StrategyReporterNoop::new())
+        .with_rng_seed_from_u64(0)
+        .call()
+        .unwrap();
+
+    println!("{:#?}", evolve.best_genes());
+    assert_eq!(evolve.best_fitness_score(), Some(10));
+    assert_eq!(
+        evolve.best_genes().unwrap(),
+        vec![true, true, true, true, true, true, true, true, true, true]
+    );
+}
+
 #[test]
 fn call_binary_max_stale_generations_and_valid_fitness_score_maximize() {
     let genotype = BinaryGenotype::builder()