add option to change when statistics are written

abouter · abouter · commit 4bb0383a2451 · 2024-12-13T18:55:46.000+01:00
diff --git a/gomea/discrete.pxd b/gomea/discrete.pxd
@@ -11,6 +11,7 @@ cdef extern from "gomea/src/discrete/Config.hpp" namespace "gomea::discrete":
         int maximumNumberOfGOMEAs, IMSsubgenerationFactor, basePopulationSize, maxArchiveSize, maximumNumberOfEvaluations, maximumNumberOfGenerations, AnalyzeFOS
         long long randomSeed
         bool fix_seed, generational_statistics, generational_solution, verbose
+        output_frequency_t output_frequency
         double maximumNumberOfSeconds
         string folder, problemInstancePath
         fitness_t[char] *fitness
@@ -26,3 +27,7 @@ cdef extern from "gomea/src/discrete/gomeaIMS.hpp" namespace "gomea::discrete":
         bool checkTermination() except +
         double getProgressUntilTermination() except +
         output_statistics_t output
+
+cdef extern from "src/common/gomea_defs.hpp" namespace "gomea":
+    ctypedef enum output_frequency_t:
+        GEN, IMS_GEN, NEW_ELITE
diff --git a/gomea/discrete.pyx b/gomea/discrete.pyx
@@ -39,6 +39,7 @@ cdef class DiscreteGOMEA:
         # Output settings (optional)
         generational_statistics = True,
         generational_solution = False,
+        output_frequency = 'GEN',
         verbose = False,
     ):
 
@@ -74,6 +75,14 @@ cdef class DiscreteGOMEA:
         self.c_config.generational_statistics = generational_statistics
         self.c_config.generational_solution = generational_solution
         self.c_config.verbose = verbose
+        if output_frequency.lower() == 'gen':
+            self.c_config.output_frequency = GEN
+        elif output_frequency.lower() == 'ims_gen':
+            self.c_config.output_frequency = IMS_GEN
+        elif output_frequency.lower() == 'new_elite':
+            self.c_config.output_frequency = NEW_ELITE
+        else:
+            raise ValueError("output_frequency must be one of 'GEN', 'IMS_GEN', 'NEW_ELITE'")
         self.c_config.fix_seed = False
         if random_seed != -1:
             self.c_config.randomSeed = random_seed
diff --git a/gomea/real_valued.pxd b/gomea/real_valued.pxd
@@ -11,6 +11,7 @@ cdef extern from "src/real_valued/Config.hpp" namespace "gomea::realvalued":
         int problem_index, maximum_no_improvement_stretch, maximum_number_of_populations, number_of_subgenerations_per_population_factor, base_population_size, maximum_number_of_generations 
         double lower_user_range, upper_user_range, tau, distribution_multiplier_decrease, st_dev_ratio_threshold, fitness_variance_tolerance, maximum_number_of_evaluations, maximum_number_of_seconds 
         bool fix_seed, use_vtr, generational_statistics, generational_solution, black_box_evaluations, selection_during_gom, update_elitist_during_gom, verbose, verbose, print_verbose_overview
+        output_frequency_t output_frequency
         long long random_seed
         linkage_config_t *linkage_config
         fitness_t[double] *fitness
@@ -24,3 +25,7 @@ cdef extern from "src/real_valued/rv-gomea.hpp" namespace "gomea::realvalued":
         void run() except +
         
         output_statistics_t output
+
+cdef extern from "src/common/gomea_defs.hpp" namespace "gomea":
+    ctypedef enum output_frequency_t:
+        GEN, IMS_GEN, NEW_ELITE
diff --git a/gomea/real_valued.pyx b/gomea/real_valued.pyx
@@ -39,6 +39,7 @@ cdef class RealValuedGOMEA:
         # Output settings (optional)
         generational_statistics = True,
         generational_solution = False,
+        #output_frequency = 'GEN',
         verbose = False,
     ):
         
@@ -76,6 +77,15 @@ cdef class RealValuedGOMEA:
         self.c_config.generational_solution = generational_solution
         self.c_config.verbose = verbose
         self.c_config.print_verbose_overview = False 
+        output_frequency = 'GEN'
+        if output_frequency == 'GEN':
+            self.c_config.output_frequency = GEN
+        elif output_frequency == 'IMS_GEN':
+            self.c_config.output_frequency = IMS_GEN
+        elif output_frequency == 'NEW_ELITE':
+            self.c_config.output_frequency = NEW_ELITE
+        else:
+            raise ValueError("output_frequency must be one of 'GEN', 'IMS_GEN', 'NEW_ELITE'")
         self.c_config.fix_seed = 0
         if random_seed != -1:
             self.c_config.random_seed = random_seed
diff --git a/gomea/src/common/gomea_defs.hpp b/gomea/src/common/gomea_defs.hpp
@@ -25,5 +25,6 @@ template<class T>
 using vec_t = std::vector<T>;
 typedef std::variant<char, int, float, double> genotype_t;
 typedef std::map<int,std::set<int>> graph_t;
+typedef enum output_frequency_t { GEN, IMS_GEN, NEW_ELITE } output_frequency_t;
 
 }
diff --git a/gomea/src/common/output_statistics.hpp b/gomea/src/common/output_statistics.hpp
@@ -42,6 +42,7 @@ class output_statistics_t
         std::unordered_map<std::string, metric_t> final_metrics_map;
         std::set<int> generational_keys;
         solution_t<genotype_t> *elitist_solution;
+        int number_of_writes = 0;
 };
 
 }
diff --git a/gomea/src/discrete/Config.hpp b/gomea/src/discrete/Config.hpp
@@ -53,6 +53,7 @@ class Config
         FOSIndex = 0;
 	int GPUIndex = -1;
 	int maximumFOSSetSize = -1;
+    output_frequency_t output_frequency = output_frequency_t::GEN;
 
     std::string folder = "discrete_gomea_output";
     //std::string problemName,
diff --git a/gomea/src/discrete/Population.cpp b/gomea/src/discrete/Population.cpp
@@ -3,8 +3,9 @@
 namespace gomea{
 namespace discrete{
 
-Population::Population(Config *config_, fitness_t<char> *problemInstance_, sharedInformation *sharedInformationPointer_, size_t GOMEAIndex_, size_t populationSize_, linkage_model_pt FOSInstance_ ): 
-        config(config_), 
+Population::Population(Config *config_, output_statistics_t *output_, fitness_t<char> *problemInstance_, sharedInformation *sharedInformationPointer_, size_t GOMEAIndex_, size_t populationSize_, linkage_model_pt FOSInstance_ ): 
+        config(config_),
+        output(output_),
         problemInstance(problemInstance_),
         sharedInformationPointer(sharedInformationPointer_),
         GOMEAIndex(GOMEAIndex_), 
@@ -292,6 +293,8 @@ bool Population::GOM(size_t offspringIndex)
                 //evaluateSolution(offspringPopulation[offspringIndex], backup, touchedGenes, backup->getObjectiveValue());
                 //problemInstance->evaluatePartialSolution(offspringPopulation[offspringIndex], partial_offspring, FOSInstance->getDependentSubfunctions(ind) );
                 problemInstance->evaluatePartialSolution(offspringPopulation[offspringIndex], partial_offspring );
+                if( problemInstance->output_frequency == NEW_ELITE && !problemInstance->elitist_was_written )
+                    writeStatistics();
 
                 // accept the change if this solution is not the elitist and the fitness is at least equally good (allows random walk in neutral fitness landscape)
                 // however, if this is the elitist solution, only accept strict improvements, to avoid convergence problems
@@ -344,6 +347,8 @@ bool Population::FI(size_t offspringIndex)
         if (!donorEqualToOffspring)
         {
             problemInstance->evaluatePartialSolution(offspringPopulation[offspringIndex], partial_offspring );
+            if( problemInstance->output_frequency == NEW_ELITE && !problemInstance->elitist_was_written )
+                writeStatistics();
 
             if (partial_offspring->getObjectiveValue() > offspringPopulation[offspringIndex]->getObjectiveValue() ) 
             {
@@ -405,5 +410,42 @@ void Population::updateElitistAndCheckVTR(solution_t<char> *solution)
     sharedInformationPointer->firstEvaluationEver = false;
 }
 
+void Population::writeStatistics( bool is_final )
+{
+    assert( sharedInformationPointer != NULL );
+	int key = output->number_of_writes;
+    double evals = problemInstance->number_of_evaluations;
+	double elapsed_time = utils::getElapsedTimeSinceStartSeconds();
+	double eval_time = utils::getTimer("eval_time");
+    //double elitist_evals = sharedInformationPointer->elitistSolutionHittingTimeEvaluations;
+    //double time_s = sharedInformationPointer->elitistSolutionHittingTimeMilliseconds/1000.0;
+	//double best_fitness = sharedInformationPointer->elitistFitness;
+    output->addGenerationalMetricValue("generation",key,(int)numberOfGenerations);
+    output->addGenerationalMetricValue("evaluations",key,evals);
+    //output->addMetricValue("elitist_hitting_evaluations",key,elitist_evals);
+    output->addGenerationalMetricValue("time",key,elapsed_time);
+    output->addGenerationalMetricValue("eval_time",key,eval_time);
+    output->addGenerationalMetricValue("population_index",key,(int)GOMEAIndex);
+    output->addGenerationalMetricValue("population_size",key,(int)populationSize);
+    output->addGenerationalMetricValue("best_obj_val",key,problemInstance->elitist_objective_value);
+    output->addGenerationalMetricValue("best_cons_val",key,problemInstance->elitist_constraint_value);
+	if( config->generational_solution )
+		output->addGenerationalMetricValue("best_solution",key,sharedInformationPointer->elitist.variablesToString());
+    //output->addMetricValue("obj_val_avg",key,population_objective_avg);
+    //output->addMetricValue("obj_val_var",key,population_objective_var);
+
+	if( is_final ){
+		output->addFinalMetricValue("evaluations",evals);
+		output->addFinalMetricValue("time",elapsed_time);
+		output->addFinalMetricValue("eval_time",eval_time);
+		output->addFinalMetricValue("best_solution",sharedInformationPointer->elitist.variablesToString());
+		output->addFinalMetricValue("best_obj_val",problemInstance->elitist_objective_value);
+		output->addFinalMetricValue("best_cons_val",problemInstance->elitist_constraint_value);
+	}
+
+    problemInstance->elitist_was_written = true;
+	output->number_of_writes++;
+}
+
 
 }}
diff --git a/gomea/src/discrete/Population.hpp b/gomea/src/discrete/Population.hpp
@@ -11,6 +11,7 @@
 #include "gomea/src/common/solution.hpp"
 #include "gomea/src/common/partial_solution.hpp"
 #include "gomea/src/common/linkage_model.hpp"
+#include "gomea/src/common/output_statistics.hpp"
 
 namespace gomea{
 namespace discrete{
@@ -21,6 +22,7 @@ class Population
     Config *config;
     fitness_t<char> *problemInstance;
     sharedInformation *sharedInformationPointer;
+    output_statistics_t *output;
     size_t GOMEAIndex;
     size_t populationSize;
 
@@ -34,7 +36,7 @@ class Population
     
     linkage_model_pt FOSInstance = NULL;
 
-    Population(Config *config_, fitness_t<char> *problemInstance_, sharedInformation *sharedInformationPointer_, size_t GOMEAIndex_, size_t populationSize_, linkage_model_pt FOSInstance_ = NULL );
+    Population(Config *config_, output_statistics_t *output_, fitness_t<char> *problemInstance_, sharedInformation *sharedInformationPointer_, size_t GOMEAIndex_, size_t populationSize_, linkage_model_pt FOSInstance_ = NULL );
     ~Population();
 
     friend std::ostream & operator << (std::ostream &out, const Population &populationInstance);
@@ -56,6 +58,7 @@ class Population
     bool FI(size_t offspringIndex);
     void updateElitistAndCheckVTR(solution_t<char> *solution);
     void checkTimeLimit();
+    void writeStatistics( bool is_final = false );
 };
 
 }}
diff --git a/gomea/src/discrete/gomeaIMS.cpp b/gomea/src/discrete/gomeaIMS.cpp
@@ -21,6 +21,7 @@ gomeaIMS::gomeaIMS(Config *config_)
 	problemInstance 		= config->fitness;
     problemInstance->maximum_number_of_evaluations = config->maximumNumberOfEvaluations;
     problemInstance->maximum_number_of_seconds = config->maximumNumberOfSeconds;
+	problemInstance->output_frequency = config->output_frequency;
 	if( config->fix_seed )
 		utils::initializeRandomNumberGenerator(config->randomSeed);
 	else
@@ -132,7 +133,8 @@ void gomeaIMS::runGeneration( int GOMEAIndex )
 
 	GOMEAs[GOMEAIndex]->numberOfGenerations++;
 		
-	writeStatistics( GOMEAIndex );
+	if( config->output_frequency == GEN )
+		writeStatistics( GOMEAIndex );
 }
 
 bool gomeaIMS::checkTermination()
@@ -216,12 +218,13 @@ void gomeaIMS::initializeNewGOMEA()
     Population *newPopulation = NULL;
 
     if (numberOfGOMEAs == 0)
-        newPopulation = new Population(config, problemInstance, sharedInformationInstance, numberOfGOMEAs, basePopulationSize);
+        newPopulation = new Population(config, &output, problemInstance, sharedInformationInstance, numberOfGOMEAs, basePopulationSize);
     else
-        newPopulation = new Population(config, problemInstance, sharedInformationInstance, numberOfGOMEAs, 2 * GOMEAs[numberOfGOMEAs-1]->populationSize, GOMEAs[0]->FOSInstance );
-    
+        newPopulation = new Population(config, &output, problemInstance, sharedInformationInstance, numberOfGOMEAs, 2 * GOMEAs[numberOfGOMEAs-1]->populationSize, GOMEAs[0]->FOSInstance );
     GOMEAs.push_back(newPopulation);
     numberOfGOMEAs++;
+
+	writeStatistics( numberOfGOMEAs-1 );
 }
 
 void gomeaIMS::generationalStepAllGOMEAs()
@@ -261,6 +264,9 @@ void gomeaIMS::GOMEAGenerationalStepAllGOMEAsRecursiveFold(int GOMEAIndexSmalles
         for(GOMEAIndex = GOMEAIndexSmallest; GOMEAIndex < GOMEAIndexBiggest; GOMEAIndex++)
             GOMEAGenerationalStepAllGOMEAsRecursiveFold(GOMEAIndexSmallest, GOMEAIndex);
     }
+
+	if( config->output_frequency == IMS_GEN )
+		writeStatistics( GOMEAIndex );
 }
 
 bool gomeaIMS::checkTerminationGOMEA(int GOMEAIndex)
@@ -308,39 +314,7 @@ void gomeaIMS::writeStatistics( int population_index, bool is_final )
 		// GOMEA in question has terminated already - no statistics available to save.
 		return;
 	}
-
-	assert( sharedInformationInstance != NULL );
-	int key = numberOfStatisticsWrites;
-    double evals = problemInstance->number_of_evaluations;
-	double elapsed_time = utils::getElapsedTimeSinceStartSeconds();
-	double eval_time = utils::getTimer("eval_time");
-    //double elitist_evals = sharedInformationInstance->elitistSolutionHittingTimeEvaluations;
-    //double time_s = sharedInformationInstance->elitistSolutionHittingTimeMilliseconds/1000.0;
-	double best_fitness = sharedInformationInstance->elitistFitness;
-    output.addGenerationalMetricValue("generation",key,(int)GOMEAs[population_index]->numberOfGenerations);
-    output.addGenerationalMetricValue("evaluations",key,evals);
-    //output.addMetricValue("elitist_hitting_evaluations",key,elitist_evals);
-    output.addGenerationalMetricValue("time",key,elapsed_time);
-    output.addGenerationalMetricValue("eval_time",key,eval_time);
-    output.addGenerationalMetricValue("population_index",key,population_index);
-    output.addGenerationalMetricValue("population_size",key,(int)GOMEAs[population_index]->populationSize);
-    output.addGenerationalMetricValue("best_obj_val",key,sharedInformationInstance->elitistFitness);
-    output.addGenerationalMetricValue("best_cons_val",key,sharedInformationInstance->elitistConstraintValue);
-	if( config->generational_solution )
-		output.addGenerationalMetricValue("best_solution",key,sharedInformationInstance->elitist.variablesToString());
-    //output.addMetricValue("obj_val_avg",key,population_objective_avg);
-    //output.addMetricValue("obj_val_var",key,population_objective_var);
-
-	if( is_final ){
-		output.addFinalMetricValue("evaluations",evals);
-		output.addFinalMetricValue("time",elapsed_time);
-		output.addFinalMetricValue("eval_time",eval_time);
-		output.addFinalMetricValue("best_solution",sharedInformationInstance->elitist.variablesToString());
-		output.addFinalMetricValue("best_obj_val",sharedInformationInstance->elitistFitness);
-		output.addFinalMetricValue("best_cons_val",sharedInformationInstance->elitistConstraintValue);
-	}
-
-	numberOfStatisticsWrites++;
+	GOMEAs[population_index]->writeStatistics(is_final);
 }
 
 
diff --git a/gomea/src/fitness/fitness.cpp b/gomea/src/fitness/fitness.cpp
@@ -97,17 +97,19 @@ void fitness_t<T>::evaluate( solution_t<T> *solution )
 	evaluationFunction( solution );
 	utils::addToTimer("eval_time",t);
 
-	if( use_vtr && !vtr_hit_status && solution->getConstraintValue() == 0 && solution->getObjectiveValue() <= vtr  )
+	if( use_vtr && !vtr_hit_status && betterFitness(solution->getObjectiveValue(), solution->getConstraintValue(), vtr, 0.0)  )
 	{
 		vtr_hit_status = true;
 		elitist_objective_value = solution->getObjectiveValue();
 		elitist_constraint_value = solution->getConstraintValue();
+		elitist_was_written = false;
 	}
 
 	if( !vtr_hit_status && betterFitness(solution->getObjectiveValue(), solution->getConstraintValue(), elitist_objective_value, elitist_constraint_value) )
 	{
 		elitist_objective_value = solution->getObjectiveValue();
 		elitist_constraint_value = solution->getConstraintValue();
+		elitist_was_written = false;
 	}
 }
 
@@ -147,6 +149,20 @@ void fitness_t<T>::evaluatePartialSolutionBlackBox( solution_t<T> *parent, parti
 	delete[] var_backup;
 	
 	utils::addToTimer("eval_time",t);
+	if( use_vtr && !vtr_hit_status && betterFitness(solution->getObjectiveValue(), solution->getConstraintValue(), vtr, 0.0)  )
+	{
+		vtr_hit_status = true;
+		elitist_objective_value = solution->getObjectiveValue();
+		elitist_constraint_value = solution->getConstraintValue();
+		elitist_was_written = false;
+	}
+
+	if( !vtr_hit_status && betterFitness(solution->getObjectiveValue(), solution->getConstraintValue(), elitist_objective_value, elitist_constraint_value) )
+	{
+		elitist_objective_value = solution->getObjectiveValue();
+		elitist_constraint_value = solution->getConstraintValue();
+		elitist_was_written = false;
+	}
 }
 
 /*template<class T>
@@ -194,14 +210,15 @@ void fitness_t<T>::evaluatePartialSolution( solution_t<T> *parent, partial_solut
 		number_of_evaluations--;
 #endif
 
-		if( use_vtr && !vtr_hit_status && solution->getConstraintValue() == 0 && solution->getObjectiveValue() <= vtr  )
+		if( use_vtr && !vtr_hit_status && betterFitness(solution->getObjectiveValue(), solution->getConstraintValue(), vtr, 0.0)  )
 		{
 			evaluatePartialSolutionBlackBox( parent, solution );
-			if( solution->getConstraintValue() == 0 && solution->getObjectiveValue() <= vtr  )
+			if( betterFitness(solution->getObjectiveValue(), solution->getConstraintValue(), vtr, 0.0)  )
 			{
 				vtr_hit_status = true;
 				elitist_objective_value = solution->getObjectiveValue();
 				elitist_constraint_value = solution->getConstraintValue();
+				elitist_was_written = false;
 			}
 		}
 	}
@@ -210,6 +227,7 @@ void fitness_t<T>::evaluatePartialSolution( solution_t<T> *parent, partial_solut
 	{
 		elitist_objective_value = solution->getObjectiveValue();
 		elitist_constraint_value = solution->getConstraintValue();
+		elitist_was_written = false;
 	}
 }
 
@@ -232,8 +250,11 @@ void fitness_t<T>::initializeRun()
 {
 	number_of_evaluations = 0.0;	// discounted in GBO
 	full_number_of_evaluations = 0; // not discounted in GBO
-	elitist_objective_value = 1e308;
-	elitist_constraint_value = 1e308;
+	if( opt_mode::MIN == optimization_mode )
+		elitist_objective_value = INFINITY;
+	else
+		elitist_objective_value = -INFINITY;
+	elitist_constraint_value = INFINITY;
 	vtr_hit_status = false;
 }
 
diff --git a/gomea/src/fitness/fitness.hpp b/gomea/src/fitness/fitness.hpp
@@ -3,6 +3,7 @@
 #include "gomea/src/common/gomea_defs.hpp"
 #include "gomea/src/common/solution.hpp"
 #include "gomea/src/common/partial_solution.hpp"
+#include "gomea/src/common/output_statistics.hpp"
 #include "gomea/src/utils/tools.hpp"
 #include "gomea/src/utils/time.hpp"
 #include <map>
@@ -59,6 +60,8 @@ class fitness_t : public fitness_generic_t
 		double vtr = 0.0; // value-to-reach
 		bool black_box_optimization = false;
 		bool use_vtr = false;
+		output_frequency_t output_frequency = output_frequency_t::GEN;
+		bool elitist_was_written = true;
 		
 		// Optimization progress
 		double number_of_evaluations; // discounted in GBO
diff --git a/gomea/src/real_valued/Config.hpp b/gomea/src/real_valued/Config.hpp
diff --git a/gomea/src/real_valued/population.cpp b/gomea/src/real_valued/population.cpp
diff --git a/gomea/src/real_valued/population.hpp b/gomea/src/real_valued/population.hpp
diff --git a/gomea/src/real_valued/rv-gomea.cpp b/gomea/src/real_valued/rv-gomea.cpp
diff --git a/gomea/src/real_valued/rv-gomea.hpp b/gomea/src/real_valued/rv-gomea.hpp
diff --git a/pyproject.toml b/pyproject.toml

Original file line number	Diff line number	Diff line change
`@@ -25,5 +25,6 @@ template<class T>`
`25`	`25`	`using vec_t = std::vector<T>;`
`26`	`26`	`typedef std::variant<char, int, float, double> genotype_t;`
`27`	`27`	`typedef std::map<int,std::set<int>> graph_t;`
	`28`	`+typedef enum output_frequency_t { GEN, IMS_GEN, NEW_ELITE } output_frequency_t;`
`28`	`29`
`29`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -42,6 +42,7 @@ class output_statistics_t`
`42`	`42`	`std::unordered_map<std::string, metric_t> final_metrics_map;`
`43`	`43`	`std::set<int> generational_keys;`
`44`	`44`	`solution_t<genotype_t> *elitist_solution;`
	`45`	`+ int number_of_writes = 0;`
`45`	`46`	`};`
`46`	`47`
`47`	`48`	`}`