v0.2.1 Rounding bug fix; incremental score calculation for MathModel (currently works slow, turned off by default, will try to improve later)

CameleoGrey · CameleoGrey · commit 8b358e93a253 · 2025-03-23T22:06:49.000+03:00
diff --git a/examples/object_oriented/vrp/scripts/solve_vrp.py b/examples/object_oriented/vrp/scripts/solve_vrp.py
@@ -33,9 +33,9 @@
     #file_path = Path(data_dir_path, data_dir_path, "belgium", "basic", "air", "belgium-n1000-k40.vrp") #optimum: ~57.7; first_fit: ~195.3; RoutingModel: from 67.3 to 74 (depends on time)
     # multi-depot with timewindows
     #file_path = Path(data_dir_path, "belgium", "multidepot-timewindowed", "air", "belgium-tw-d2-n50-k10.vrp") # optimum: ~15.98; first_fit: ~27.89
-    #file_path = Path(data_dir_path, "belgium", "multidepot-timewindowed", "air", "belgium-tw-d5-n500-k20.vrp") # optimum: ~43.3; first_fit: ~124.884
+    file_path = Path(data_dir_path, "belgium", "multidepot-timewindowed", "air", "belgium-tw-d5-n500-k20.vrp") # optimum: ~43.3; first_fit: ~124.884
     #file_path = Path(data_dir_path, "belgium", "multidepot-timewindowed", "air", "belgium-tw-d8-n1000-k40.vrp") # optimum: ~58.1; first_fit: ~154.565
-    file_path = Path(data_dir_path, "belgium", "multidepot-timewindowed", "air", "belgium-tw-d10-n2750-k55.vrp") # optimum: ~111; first_fit: ~380.9
+    #file_path = Path(data_dir_path, "belgium", "multidepot-timewindowed", "air", "belgium-tw-d10-n2750-k55.vrp") # optimum: ~111; first_fit: ~380.9
 
     domain_builder = DomainBuilder(file_path)
     cotwin_builder = CotwinBuilder(use_incremental_score_calculator=True, use_greed_init=True)
@@ -58,7 +58,7 @@
                                migration_frequency=10, termination_strategy=termination_strategy)"""
 
     solver = SolverOOP(domain_builder, cotwin_builder, agent, 
-                    ParallelizationBackend.Multiprocessing, LoggingLevel.Info,
+                    ParallelizationBackend.Multiprocessing, LoggingLevel.FreshOnly,
                     n_jobs=10, score_precision=[0, 0, 0])
     solution = solver.solve()
 
diff --git a/examples/pure_math/minlp/solve_minlp_gj.py b/examples/pure_math/minlp/solve_minlp_gj.py
@@ -17,28 +17,28 @@
 from greyjack.agents.base.LoggingLevel import LoggingLevel
 from greyjack.agents.termination_strategies import *
 
-from examples.pure_math.minlp.gj_files.ann_compressor import *
+from examples.pure_math.minlp.gj_files.rsyn0840m import *
 
 if __name__ == "__main__":
 
     math_model = build_math_model()
 
     #termination_strategy = StepsLimit(step_count_limit=1000)
-    #termination_strategy = TimeSpentLimit(time_seconds_limit=10)
+    #termination_strategy = TimeSpentLimit(time_seconds_limit=60)
     termination_strategy = ScoreNoImprovement(time_seconds_limit=15)
     #termination_strategy = ScoreLimit(score_to_compare=[0, 0])
-    """agent = TabuSearch(neighbours_count=1000, tabu_entity_rate=0.2, 
+    """agent = TabuSearch(neighbours_count=1000, tabu_entity_rate=0.8, 
                        mutation_rate_multiplier=1.0, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0], 
-                       migration_frequency=10, compare_to_global_frequency=1, termination_strategy=termination_strategy)"""
-    """agent = GeneticAlgorithm(population_size=512, crossover_probability=0.8, p_best_rate=0.2,
-                             tabu_entity_rate=0.0, mutation_rate_multiplier=1.0, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0],
-                             migration_rate=0.00001, migration_frequency=10, termination_strategy=termination_strategy)"""
-    agent = LateAcceptance(late_acceptance_size=200, tabu_entity_rate=0.0, 
+                       compare_to_global_frequency=10, termination_strategy=termination_strategy)"""
+    agent = GeneticAlgorithm(population_size=256, crossover_probability=0.8, p_best_rate=0.5,
+                             tabu_entity_rate=0.8, mutation_rate_multiplier=1.0, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0],
+                             migration_rate=0.00001, migration_frequency=10, termination_strategy=termination_strategy)
+    """agent = LateAcceptance(late_acceptance_size=200, tabu_entity_rate=0.8, 
                            mutation_rate_multiplier=1.0, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0], 
-                           compare_to_global_frequency=1000, termination_strategy=termination_strategy)
-    """agent = SimulatedAnnealing(initial_temperature=[1.0, 1.0], cooling_rate=0.9999, tabu_entity_rate=0.2, 
-                               mutation_rate_multiplier=None, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0], 
-                               compare_to_global_frequency=10000, termination_strategy=termination_strategy)"""
+                           compare_to_global_frequency=10000, termination_strategy=termination_strategy)"""
+    """agent = SimulatedAnnealing(initial_temperature=[1.0, 1.0], cooling_rate=0.9999, tabu_entity_rate=0.8, 
+                               mutation_rate_multiplier=1.0, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0], 
+                               compare_to_global_frequency=1000, termination_strategy=termination_strategy)"""
     
     solver = SolverPureMath(math_model, agent,
                             ParallelizationBackend.Multiprocessing, LoggingLevel.FreshOnly,
diff --git a/examples/pure_math/nqueens/access_benchmark.py b/examples/pure_math/nqueens/access_benchmark.py
diff --git a/greyjack/Cargo.lock b/greyjack/Cargo.lock
diff --git a/greyjack/Cargo.toml b/greyjack/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "greyjack"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
diff --git a/greyjack/greyjack/agents/LateAcceptance.py b/greyjack/greyjack/agents/LateAcceptance.py
@@ -14,7 +14,7 @@ def __init__(
         mutation_rate_multiplier=None,
         move_probas=None,
         migration_frequency=999_999_999_999, # probably, better use only comparing with global. Need more researching.
-        compare_to_global_frequency=10, # too often comparing significally decreases common performance for fast-stepping metaheuristics
+        compare_to_global_frequency=1000, # too often comparing significally decreases common performance for fast-stepping metaheuristics
         termination_strategy=None,
     ):
         
@@ -36,7 +36,7 @@ def _build_metaheuristic_base(self):
         elif isinstance(self.cotwin, MathModel):
             self.score_requester = PureMathScoreRequester(self.cotwin)
             score_variant = self.cotwin.score_variant
-            self.cotwin.score_calculator.is_incremental = False #TODO: change to True when I implement incremental score calculation for MathModel
+            self.cotwin.score_calculator.is_incremental = False # if True, currently works badder. Will try improve later
         else:
             raise Exception("Cotwin must be either subclass of CotwinBase, either be instance of MathModel")
         semantic_groups_dict = self.score_requester.variables_manager.semantic_groups_map.copy()
diff --git a/greyjack/greyjack/agents/SimulatedAnnealing.py b/greyjack/greyjack/agents/SimulatedAnnealing.py
@@ -16,7 +16,7 @@ def __init__(
         mutation_rate_multiplier=None,
         move_probas=None,
         migration_frequency=999_999_999,
-        compare_to_global_frequency=10, # too often comparing significally decreases common performance for fast-stepping metaheuristics
+        compare_to_global_frequency=1000, # too often comparing significally decreases common performance for fast-stepping metaheuristics
         termination_strategy=None,
     ):  
         
@@ -42,7 +42,7 @@ def _build_metaheuristic_base(self):
         elif isinstance(self.cotwin, MathModel):
             self.score_requester = PureMathScoreRequester(self.cotwin)
             score_variant = self.cotwin.score_variant
-            self.cotwin.score_calculator.is_incremental = False #TODO: change to True when I implement incremental score calculation for MathModel
+            self.cotwin.score_calculator.is_incremental = False # if True, currently works badder. Will try improve later
         else:
             raise Exception("Cotwin must be either subclass of CotwinBase, either be instance of MathModel")
         semantic_groups_dict = self.score_requester.variables_manager.semantic_groups_map.copy()
diff --git a/greyjack/greyjack/agents/TabuSearch.py b/greyjack/greyjack/agents/TabuSearch.py
@@ -13,7 +13,7 @@ def __init__(
         tabu_entity_rate,
         mutation_rate_multiplier=None,
         move_probas=None,
-        migration_frequency=None,
+        migration_frequency=999_999_999,
         compare_to_global_frequency=1, # Tabu is usually not too fast-stepping due to high neighbours_count
         termination_strategy=None,
     ):
@@ -39,7 +39,7 @@ def _build_metaheuristic_base(self):
         elif isinstance(self.cotwin, MathModel):
             self.score_requester = PureMathScoreRequester(self.cotwin)
             score_variant = self.cotwin.score_variant
-            self.cotwin.score_calculator.is_incremental = False #TODO: change to True when I implement incremental score calculation for MathModel
+            self.cotwin.score_calculator.is_incremental = False # if True, currently works badder. Will try improve later
         else:
             raise Exception("Cotwin must be either subclass of CotwinBase, either be instance of MathModel")
 
diff --git a/greyjack/greyjack/agents/base/GJSolution.py b/greyjack/greyjack/agents/base/GJSolution.py
@@ -6,7 +6,7 @@ def __init__(self, variable_names, discrete_ids, variable_values, score_list, sc
 
         if discrete_ids is not None:
             for discrete_id in discrete_ids:
-                variable_values[discrete_id] = int(variable_values[discrete_id])
+                variable_values[discrete_id] = int(np.rint(variable_values[discrete_id]))
         
         if score_precision is not None:
             for i in range(len(score_list)):
diff --git a/greyjack/greyjack/pure_math/MathModel.py b/greyjack/greyjack/pure_math/MathModel.py
@@ -1,6 +1,8 @@
 
 from pprint import pprint
 from greyjack.score_calculation.scores.ScoreVariants import ScoreVariants
+import random
+import numpy as np
 
 class MathModel():
 
@@ -16,6 +18,7 @@ def __init__(self):
         self.score_variant = ScoreVariants.HardSoftScore
         self.score_type = None
         self.score_calculator = ScoreCalculatorStub()
+        self.variable_to_constraint_index = None
 
     def get_individual_hard_scores(self, absolute):
 
@@ -64,7 +67,48 @@ def get_sum_soft_score(self, is_fitting):
 
         return sum_soft_score
     
-    #def update_model_by_solution(self, gj_solution):
+    def _build_variable_to_constraint_index(self, variables_manager, var_name_to_arr_id_map, discrete_var_names):
+
+        min_trials_count = 100
+        variable_to_constraint_index = {}
+        for var_name in self.variables.keys():
+            
+            variable_to_constraint_index[var_name] = set()
+
+            value_before = self.variables[var_name]
+            already_checked_values = set()
+            current_trials_count = 0
+            different_value_checked = False
+            while current_trials_count < min_trials_count or not different_value_checked:
+                
+                value_after = variables_manager.get_column_random_value(var_name_to_arr_id_map[var_name])
+                if var_name in discrete_var_names:
+                    value_after = int(np.rint(value_after))
+                if value_after == value_before:
+                    continue
+                else:
+                    different_value_checked = True
+
+                if value_after in already_checked_values:
+                    current_trials_count += 1
+                    continue
+                else:
+                    already_checked_values.add(value_after)
+
+                for constraint_name in self.constraints.keys():
+                    penalty_before = self.constraints[constraint_name].get_hard_score(self.variables, self.utility)
+                    self.variables[var_name] = value_after
+                    penalty_after = self.constraints[constraint_name].get_hard_score(self.variables, self.utility)
+                    self.variables[var_name] = value_before
+
+                    if abs(penalty_before) - abs(penalty_after) != 0.0:
+                        variable_to_constraint_index[var_name].add(constraint_name)
+
+                current_trials_count += 1
+
+        return variable_to_constraint_index
+
+
 
 
     def explain_solution(self, gj_solution):
@@ -94,6 +138,8 @@ def explain_solution(self, gj_solution):
 
         pass
 
+
+
 # filthy way to not rewrite core OOP Agent code
 class ScoreCalculatorStub():
     def __init__(self):
diff --git a/greyjack/greyjack/score_calculation/score_requesters/PureMathScoreRequester.py b/greyjack/greyjack/score_calculation/score_requesters/PureMathScoreRequester.py
@@ -9,6 +9,7 @@
 from greyjack.variables.GJFloat import GJFloat
 from greyjack.variables.GJInteger import GJInteger
 from greyjack.variables.GJBinary import GJBinary
+import numpy as np
 
 class PureMathScoreRequester():
 
@@ -44,17 +45,21 @@ def __init__(self, math_model: MathModel):
             variables_list.append( current_variable )
         self.variables_manager = VariablesManagerPy(variables_list)
         self.n_variables = len(variables_list)
-        self.discrte_ids = self.variables_manager.discrete_ids
+        self.discrete_ids = self.variables_manager.discrete_ids
+        self.discrete_var_names = set()
+        if self.discrete_ids is not None:
+            for discrete_id in self.discrete_ids:
+                self.discrete_var_names.add(self.arr_id_to_var_name_map[discrete_id])
 
     def request_score_plain(self, samples):
 
         score_batch = []
 
         for sample in samples:
 
-            if self.discrte_ids is not None:
-                for i in self.discrte_ids:
-                    sample[i] = int(sample[i])
+            if self.discrete_ids is not None:
+                for i in self.discrete_ids:
+                    sample[i] = int(np.rint(sample[i]))
 
             for i in range(self.n_variables):
                 self.math_model.variables[self.arr_id_to_var_name_map[i]] = sample[i]
@@ -68,4 +73,47 @@ def request_score_plain(self, samples):
         return score_batch
     
     def request_score_incremental(self, sample, deltas):
-        raise Exception("request_score_incremental() not implemented for PureMathScoreRequester")
+
+        score_batch = []
+
+        if self.discrete_ids is not None:
+            for i in self.discrete_ids:
+                sample[i] = int(np.rint(sample[i]))
+        for i in range(self.n_variables):
+            self.math_model.variables[self.arr_id_to_var_name_map[i]] = sample[i]
+        
+        if self.math_model.variable_to_constraint_index is None:
+            self.math_model.variable_to_contstraint_index = self.math_model._build_variable_to_constraint_index(self.variables_manager, self.var_name_to_arr_id_map, self.discrete_var_names)
+
+        hard_score_values_before = self.math_model.get_individual_hard_scores(absolute=True)
+        sum_hard_score_before = sum(hard_score_values_before.values())
+        #soft_score_value_before = self.math_model.get_sum_soft_score(is_fitting=True)
+
+        score_batch = []
+        for sample_deltas in deltas:
+            var_names = []
+            values_before = []
+            touched_constraints = []
+            for (i, new_value) in sample_deltas:
+                var_name = self.arr_id_to_var_name_map[i]
+                var_names.append(var_name)
+                values_before.append( self.math_model.variables[var_name] )
+                self.math_model.variables[var_name] = new_value
+                touched_constraints.append(self.math_model.variable_to_contstraint_index[var_name])
+            touched_constraints = set.union(*touched_constraints)
+            
+            sample_hard_score = sum_hard_score_before
+            for constraint_name in touched_constraints:
+                sample_hard_score -= hard_score_values_before[constraint_name]
+                sample_hard_score += abs(self.math_model.constraints[constraint_name].get_hard_score(self.math_model.variables, self.math_model.utility))
+            sample_soft_score = self.math_model.get_sum_soft_score(is_fitting=True)
+
+            score_batch.append(HardSoftScore(sample_hard_score, sample_soft_score))
+
+            for i in range(len(var_names)):
+                self.math_model.variables[var_names[i]] = values_before[i]
+        
+        return score_batch
+            
+
+
diff --git a/greyjack/pyproject.toml b/greyjack/pyproject.toml
@@ -7,7 +7,7 @@ features = ["pyo3/extension-module"]
 
 [project]
 name = "greyjack"
-version = "0.2.0"
+version = "0.2.1"
 requires-python = ">=3.9"
 dependencies = [
 	"dill",
diff --git a/greyjack/src/score_calculation/score_requesters/variables_manager_py.rs b/greyjack/src/score_calculation/score_requesters/variables_manager_py.rs
@@ -109,7 +109,7 @@ impl VariablesManagerPy {
         let group_ids = self.semantic_groups_map.get(group_name).unwrap();
         return (group_ids, group_name);
     }
-
+    
     pub fn get_column_random_value(&self, column_id: usize) -> f64{
         Uniform::new(self.lower_bounds[column_id], self.upper_bounds[column_id]).sample(&mut StdRng::from_entropy())
     }
