Reduce usage of more precise best_unique_chromosome_indices in

ExtensionMassExtinction and ExtensionMassDegeneration, as uniqueness
limits the amount of selected elites, which seems unwanted behaviour

Author: basvanwesting

src/extension.rs

@@ -33,17 +33,17 @@ pub trait Extension: Clone + Send + Sync + std::fmt::Debug {
         rng: &mut R,
     );
 
-    fn extract_unique_elite_chromosomes<G: EvolveGenotype>(
+    fn extract_elite_chromosomes<G: EvolveGenotype>(
         &self,
         _genotype: &mut G,
         state: &mut EvolveState<G>,
         config: &EvolveConfig,
         elitism_size: usize,
     ) -> Vec<G::Chromosome> {
-        let mut elite_chromosomes: Vec<G::Chromosome> = Vec::with_capacity(elitism_size);
+        let mut elite_chromosomes: Vec<G::Chromosome> = Vec::new();
         for index in state
             .population
-            .best_unique_chromosome_indices(elitism_size, config.fitness_ordering)
+            .best_chromosome_indices(elitism_size, config.fitness_ordering)
             .into_iter()
             .rev()
         {
@@ -53,6 +53,26 @@ pub trait Extension: Clone + Send + Sync + std::fmt::Debug {
         elite_chromosomes
     }
 
+    fn extract_unique_elite_chromosomes<G: EvolveGenotype>(
+        &self,
+        _genotype: &mut G,
+        state: &mut EvolveState<G>,
+        config: &EvolveConfig,
+        elitism_size: usize,
+    ) -> Vec<G::Chromosome> {
+        let mut unique_elite_chromosomes: Vec<G::Chromosome> = Vec::new();
+        for index in state
+            .population
+            .best_unique_chromosome_indices(elitism_size, config.fitness_ordering)
+            .into_iter()
+            .rev()
+        {
+            let chromosome = state.population.chromosomes.swap_remove(index);
+            unique_elite_chromosomes.push(chromosome);
+        }
+        unique_elite_chromosomes
+    }
+
     fn extract_unique_chromosomes<G: EvolveGenotype>(
         &self,
         _genotype: &mut G,

src/extension/mass_degeneration.rs

@@ -8,8 +8,9 @@ use std::time::Instant;
 /// Simulates a cambrian explosion. The controlling metric is population cardinality in the
 /// population after selection. When this cardinality drops to the threshold, the population is
 /// mutated the provided number of times, where the [Genotype](crate::genotype::Genotype)
-/// determines whether this is random, relative or scaled.
-/// The elitism_rate ensures the passing of the best chromosomes before mutations are applied.
+/// determines whether this is random, relative or scaled. The elitism_rate ensures the passing of
+/// the best chromosomes before mutations are applied (doesn't care about best chromosome
+/// uniqueness).
 ///
 /// Duplicate mutations of the same gene are allowed. There is no change in population size.
 #[derive(Debug, Clone)]
@@ -43,12 +44,8 @@ impl Extension for MassDegeneration {
                     let elitism_size = ((population_size as f32 * self.elitism_rate).ceil()
                         as usize)
                         .min(population_size);
-                    let mut elite_chromosomes = self.extract_unique_elite_chromosomes(
-                        genotype,
-                        state,
-                        config,
-                        elitism_size,
-                    );
+                    let mut elite_chromosomes =
+                        self.extract_elite_chromosomes(genotype, state, config, elitism_size);
                     let elitism_size = elite_chromosomes.len();
 
                     for chromosome in state.population.chromosomes.iter_mut() {

src/extension/mass_extinction.rs

@@ -7,8 +7,9 @@ use std::time::Instant;
 
 /// Simulates a cambrian explosion. The controlling metric is population cardinality in the
 /// population after selection. When this cardinality drops to the threshold, the population is
-/// randomly reduced regardless of fitness using the survival_rate (fraction of population).
-/// The elitism_rate ensures the passing of the best chromosomes before random reduction starts.
+/// randomly reduced regardless of fitness using the survival_rate (fraction of population). The
+/// elitism_rate ensures the passing of the best chromosomes before random reduction starts
+/// (doesn't care about best chromosome uniqueness).
 ///
 /// Population will recover in the following generations
 #[derive(Debug, Clone)]
@@ -42,12 +43,8 @@ impl Extension for MassExtinction {
                     let elitism_size = ((population_size as f32 * self.elitism_rate).ceil()
                         as usize)
                         .min(population_size);
-                    let mut elite_chromosomes = self.extract_unique_elite_chromosomes(
-                        genotype,
-                        state,
-                        config,
-                        elitism_size,
-                    );
+                    let mut elite_chromosomes =
+                        self.extract_elite_chromosomes(genotype, state, config, elitism_size);
                     let elitism_size = elite_chromosomes.len();
 
                     let remaining_size: usize = ((population_size as f32 * self.survival_rate)

src/extension/mass_genesis.rs

@@ -6,8 +6,10 @@ use crate::strategy::{StrategyAction, StrategyState};
 use rand::Rng;
 use std::time::Instant;
 
-/// A version of [MassExtinction](crate::extension::ExtensionMassExtinction), where only an adam
-/// and eve of current best chromosomes survive
+/// A version of [MassExtinction](crate::extension::ExtensionMassExtinction), where only an Adam
+/// and Eve of current best chromosomes survive. Tries to select distinct Adem and Eve when
+/// genes_hash is stored on chromosome, otherwise it will just take 2 of the best (possibly
+/// dupicates).
 ///
 /// Population will recover in the following generations
 #[derive(Debug, Clone)]
@@ -35,11 +37,14 @@ impl Extension for MassGenesis {
                         config,
                     );
 
-                    let mut elite_chromosomes =
-                        self.extract_unique_elite_chromosomes(genotype, state, config, 2);
+                    let mut elite_chromosomes = if genotype.genes_hashing() {
+                        self.extract_unique_elite_chromosomes(genotype, state, config, 2)
+                    } else {
+                        self.extract_elite_chromosomes(genotype, state, config, 2)
+                    };
                     let elitism_size = elite_chromosomes.len();
-
                     let remaining_size = 2usize.saturating_sub(elitism_size);
+
                     genotype.chromosome_destructor_truncate(
                         &mut state.population.chromosomes,
                         remaining_size,

src/population.rs

@@ -65,8 +65,9 @@ impl<C: Chromosome> Population<C> {
         }
     }
 
-    // In summary a bit quirky, but fast and doesn't require genes_hashing.
-    // Doesn't matter the amount should be much less than the population size.
+    // In summary a bit quirky, but fast and doesn't require genes_hashing,
+    // which doesn't matter as the amount should be much less than the population size (usage in elitism_rate)
+    //
     // Returns one less than total size with known fitness due to implementation constraints.
     // Does not care about uniqueness of the genes_hash.
     pub fn best_chromosome_indices(
@@ -115,8 +116,7 @@ impl<C: Chromosome> Population<C> {
     }
 
     // Only works when genes_hash is stored on chromosome, as this is the uniqueness key.
-    // Assume chromosomes sorted by fitness, takes the first index occurence of a genes_hash
-    // Returns indices in ascending order (irrespective of fitness)
+    // Takes the first index occurence of a genes_hash. Returns indices in ascending order (irrespective of fitness)
     pub fn best_unique_chromosome_indices(
         &self,
         amount: usize,

src/strategy.rs

@@ -33,7 +33,7 @@
 //! // the search space
 //! let genotype = BinaryGenotype::builder()
 //!     .with_genes_size(10)
-//!     .with_genes_hashing(true) // store genes_hash on chromosome (required for fitness_cache, optional for better population cardinality estimation)
+//!     .with_genes_hashing(true) // store genes_hash on chromosome (required for fitness_cache and deduplication extension, optional for better population cardinality estimation)
 //!     .build()
 //!     .unwrap();
 //!

src/strategy/evolve.rs

@@ -138,7 +138,7 @@ pub enum EvolveVariant {
 /// // the search space
 /// let genotype = BinaryGenotype::builder() // boolean alleles
 ///     .with_genes_size(100)                // 100 genes per chromosome
-///     .with_genes_hashing(true)            // store genes_hash on chromosome (required for fitness_cache, optional for better population cardinality estimation)
+///     .with_genes_hashing(true)            // store genes_hash on chromosome (required for fitness_cache and deduplication extension, optional for better population cardinality estimation)
 ///     .build()
 ///     .unwrap();
 ///
@@ -147,7 +147,7 @@ pub enum EvolveVariant {
 ///     .with_genotype(genotype)
 ///
 ///     .with_select(SelectElite::new(0.5, 0.02))               // sort the chromosomes by fitness to determine crossover order. Strive to replace 50% of the population with offspring. Allow 2% through the non-generational best chromosomes gate before selection and replacement
-///     .with_extension(ExtensionMassExtinction::new(10, 0.1, 0.02))  // optional builder step, simulate cambrian explosion by mass extinction, when population cardinality drops to 10 after the selection, trim to 10% of population
+///     .with_extension(ExtensionMassExtinction::new(10, 0.1, 0.02)) // optional builder step, simulate cambrian explosion by mass extinction, when population cardinality drops to 10 after the selection, trim to 10% of population
 ///     .with_crossover(CrossoverUniform::new(0.7, 0.8))        // crossover all individual genes between 2 chromosomes for offspring with 70% parent selection (30% do not produce offspring) and 80% chance of crossover (20% of parents just clone)
 ///     .with_mutate(MutateSingleGene::new(0.2))                // mutate offspring for a single gene with a 20% probability per chromosome
 ///     .with_fitness(CountTrue)                                // count the number of true values in the chromosomes

src/strategy/hill_climb.rs

@@ -111,7 +111,7 @@ pub enum HillClimbVariant {
 /// // the search space
 /// let genotype = RangeGenotype::builder()     // f32 alleles
 ///     .with_genes_size(16)                    // 16 genes
-///     .with_genes_hashing(true)               // store genes_hash on chromosome (required for fitness_cache)
+///     .with_genes_hashing(true)               // store genes_hash on chromosome (required for fitness_cache and deduplication extension)
 ///     .with_allele_range(0.0..=1.0)           // allow gene values between 0.0 and 1.0
 ///     .with_allele_mutation_range(-0.1..=0.1) // neighbouring step size randomly sampled from range
 ///     .with_allele_mutation_scaled_range(vec![

tests/extension/mass_deduplication_test.rs

@@ -104,10 +104,9 @@ fn never_leaves_less_than_two() {
 }
 
 #[test]
-fn never_removes_all_if_no_genes_hash() {
+fn skips_execution_if_no_genes_hash() {
     let mut genotype = BinaryGenotype::builder()
         .with_genes_size(3)
-        .with_genes_hashing(true)
         .build()
         .unwrap();
 
@@ -125,8 +124,8 @@ fn never_removes_all_if_no_genes_hash() {
     assert_eq!(population.chromosomes.capacity(), 10);
 
     let mut state = EvolveState::new(&genotype);
-    assert_eq!(population.genes_cardinality(), None); // trigger, because no cardinality if no genes hashes
-    state.population_cardinality = population.genes_cardinality();
+    assert_eq!(population.genes_cardinality(), None);
+    state.population_cardinality = Some(2); // hard trigger, because no cardinality if no genes hashes
     state.population = population;
     let config = EvolveConfig::new();
     let mut reporter = StrategyReporterNoop::new();

tests/extension/mass_degeneration_test.rs

@@ -40,7 +40,7 @@ fn degenerates_randomly() {
     let config = EvolveConfig::new();
     let mut reporter = StrategyReporterNoop::new();
     let mut rng = SmallRng::seed_from_u64(0);
-    ExtensionMassDegeneration::new(3, 2, 0.25).call(
+    ExtensionMassDegeneration::new(3, 2, 0.33).call(
         &mut genotype,
         &mut state,
         &config,
@@ -54,13 +54,13 @@ fn degenerates_randomly() {
             // elite
             (vec![true, true, false], Some(1)),
             (vec![true, false, false], Some(2)),
-            // others
-            (vec![true, true, false], None),
+            (vec![true, false, false], Some(2)),
+            // normal
             (vec![true, true, true], None),
             (vec![true, false, true], None),
-            (vec![false, false, true], None),
-            (vec![true, false, false], None),
-            (vec![true, true, true], None)
+            (vec![true, true, true], None),
+            (vec![true, false, true], None),
+            (vec![true, true, true], None),
         ]
     );
     assert_eq!(state.population.chromosomes.capacity(), 10);