v0.1.3 Wrapped a part of score calculation; Comparing with global refactor

Author: CameleoGrey

examples/object_oriented/nqueens/scripts/solve_nqueens.py

@@ -20,25 +20,25 @@
 if __name__ == "__main__":
 
     # build domain model
-    domain_builder = DomainBuilderNQueens(10000, random_seed=45)
+    domain_builder = DomainBuilderNQueens(1024, random_seed=45)
     cotwin_builder = CotwinBuilderNQueens(use_incremental_score_calculator=True)
 
     #termination_strategy = StepsLimit(step_count_limit=1000)
-    termination_strategy = TimeSpentLimit(time_seconds_limit=60)
+    #termination_strategy = TimeSpentLimit(time_seconds_limit=60)
     #termination_strategy = ScoreNoImprovement(time_seconds_limit=15)
-    #termination_strategy = ScoreLimit(score_to_compare=[0])
+    termination_strategy = ScoreLimit(score_to_compare=[0])
     agent = TabuSearch(neighbours_count=20, tabu_entity_rate=0.0, 
                        mutation_rate_multiplier=None, move_probas=[0, 1, 0, 0, 0, 0], 
-                       compare_to_global=True, migration_frequency=10, termination_strategy=termination_strategy)
+                       migration_frequency=10, termination_strategy=termination_strategy)
     """agent = GeneticAlgorithm(population_size=128, crossover_probability=0.5, p_best_rate=0.05,
                              tabu_entity_rate=0.0, mutation_rate_multiplier=1.0, move_probas=[0, 1, 0, 0, 0, 0],
                              migration_rate=0.00001, migration_frequency=1, termination_strategy=termination_strategy)"""
     """agent = LateAcceptance(late_acceptance_size=10, tabu_entity_rate=0.0, 
                            mutation_rate_multiplier=None, move_probas=[0, 1, 0, 0, 0, 0], 
-                           termination_strategy=termination_strategy)"""
+                           compare_to_global_frequency=1, termination_strategy=termination_strategy)"""
     """agent = SimulatedAnnealing(initial_temperature=[1.0], cooling_rate=0.9999, tabu_entity_rate=0.0, 
                                mutation_rate_multiplier=None, move_probas=[0, 1, 0, 0, 0, 0], 
-                               compare_to_global=True, migration_frequency=10, termination_strategy=termination_strategy)"""
+                               migration_frequency=10, compare_to_global_frequency=10, termination_strategy=termination_strategy)"""
 
     solver = Solver(domain_builder, cotwin_builder, agent, 
                     ParallelizationBackend.Multiprocessing, LoggingLevel.FreshOnly,

examples/object_oriented/tsp/scripts/solve_tsp.py

@@ -42,7 +42,7 @@
     #termination_strategy = ScoreLimit(score_to_compare=[0])
     agent = TabuSearch(neighbours_count=128, tabu_entity_rate=0.5, 
                        mutation_rate_multiplier=None, move_probas=[0.0, 0.2, 0.2, 0.2, 0.2, 0.2],
-                       compare_to_global=False, migration_frequency=10, termination_strategy=termination_strategy)
+                       migration_frequency=10, termination_strategy=termination_strategy)
     """agent = GeneticAlgorithm(population_size=128, crossover_probability=0.5, p_best_rate=0.05,
                              tabu_entity_rate=0.2, mutation_rate_multiplier=1.0, move_probas=[0.0, 0.2, 0.2, 0.2, 0.2, 0.2],
                              migration_rate=0.00001, migration_frequency=10, termination_strategy=termination_strategy)"""
@@ -51,7 +51,7 @@
                            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, 0.2, 0.2, 0.2, 0.2, 0.2], 
-                               compare_to_global=True, migration_frequency=10, termination_strategy=termination_strategy)"""
+                               migration_frequency=10, termination_strategy=termination_strategy)"""
 
     solver = Solver(domain_builder, cotwin_builder, agent, 
                     ParallelizationBackend.Multiprocessing, LoggingLevel.Info,
@@ -61,6 +61,6 @@
     domain = domain_builder.build_from_solution(solution)
     domain.print_metrics()
     domain.print_path()
-    domain.plot_path()
+    #domain.plot_path()
 
     print("done")

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)
@@ -46,16 +46,16 @@
     #termination_strategy = ScoreLimit(score_to_compare=[0])
     agent = TabuSearch(neighbours_count=128, tabu_entity_rate=0.8, 
                        mutation_rate_multiplier=None, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0],
-                       compare_to_global=True, migration_frequency=10, termination_strategy=termination_strategy)
+                       migration_frequency=10, termination_strategy=termination_strategy)
     """agent = GeneticAlgorithm(population_size=512, crossover_probability=0.5, p_best_rate=0.2,
                              tabu_entity_rate=0.0, mutation_rate_multiplier=None, 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=32, tabu_entity_rate=0.8, 
                            mutation_rate_multiplier=None, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0], 
-                           termination_strategy=termination_strategy)"""
+                           compare_to_global_frequency=10, termination_strategy=termination_strategy)"""
     """agent = SimulatedAnnealing(initial_temperature=[1.0, 1.0, 1.0], cooling_rate=0.9999, tabu_entity_rate=0.0, 
                                mutation_rate_multiplier=None, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0], 
-                               compare_to_global=True, migration_frequency=10, termination_strategy=termination_strategy)"""
+                               migration_frequency=10, termination_strategy=termination_strategy)"""
 
     solver = Solver(domain_builder, cotwin_builder, agent, 
                     ParallelizationBackend.Multiprocessing, LoggingLevel.FreshOnly,
@@ -65,7 +65,7 @@
     domain = domain_builder.build_from_solution(solution)
     domain.print_metrics()
     domain.print_paths()
-    domain.plot_paths()
+    #domain.plot_paths()
 
 
     """
@@ -99,7 +99,7 @@
     termination_strategy = ScoreNoImprovement(time_seconds_limit=15)
     agent = TabuSearch(neighbours_count=128, tabu_entity_rate=0.0, 
                        mutation_rate_multiplier=None, move_probas=[0.5, 0.5, 0.0, 0.0, 0.0, 0.0],
-                       compare_to_global=True, migration_frequency=10, termination_strategy=termination_strategy)
+                       migration_frequency=10, termination_strategy=termination_strategy)
     solver = Solver(domain_builder, cotwin_builder, agent, 
                     ParallelizationBackend.Multiprocessing, LoggingLevel.FreshOnly,
                     n_jobs=10, score_precision=[0, 0, 0], 

greyjack/Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "greyjack"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2024"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -22,8 +22,8 @@ polars = { version = "0.46.0", features = ["lazy", "ndarray", "serde", "abs"] }
 # if you build lib from source code
 # uncomment to gain max performance (increases calculation speed about 5-10%, 
 # but also increases build time ~20x times)
-#[profile.release]
-#lto = true
-#codegen-units = 1
-#debug = true
-#opt-level = 3
+[profile.release]
+lto = true
+codegen-units = 1
+debug = true
+opt-level = 3

greyjack/Cargo.toml

@@ -11,7 +11,7 @@ def __init__(
         migration_rate=0.00001, migration_frequency=10, termination_strategy=None,
     ):
 
-        super().__init__(migration_rate, migration_frequency, termination_strategy)
+        super().__init__(migration_rate, migration_frequency, termination_strategy, compare_to_global_frequency=1)
 
         self.population_size = population_size
         self.crossover_probability = crossover_probability

greyjack/greyjack/agents/GeneticAlgorithm.py

@@ -11,10 +11,11 @@ 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
         termination_strategy=None,
     ):
 
-        super().__init__(1.0, migration_frequency, termination_strategy)
+        super().__init__(1.0, migration_frequency, termination_strategy, compare_to_global_frequency)
 
         self.population_size = 1
         self.late_acceptance_size = late_acceptance_size

greyjack/greyjack/agents/LateAcceptance.py

@@ -12,12 +12,12 @@ def __init__(
         tabu_entity_rate,
         mutation_rate_multiplier=None,
         move_probas=None,
-        compare_to_global=False,
         migration_frequency=None,
+        compare_to_global_frequency=10, # too often comparing significally decreases common performance for fast-stepping metaheuristics
         termination_strategy=None,
     ):  
 
-        super().__init__(1.0, migration_frequency, termination_strategy)
+        super().__init__(1.0, migration_frequency, termination_strategy, compare_to_global_frequency)
 
         self.population_size = 1
         self.initial_temperature = initial_temperature
@@ -28,7 +28,7 @@ def __init__(
 
         # If true - stucks more often in local minimums, but converges much faster
         # may be useful in multiple stages solving
-        self.is_win_from_comparing_with_global = compare_to_global
+        self.is_win_from_comparing_with_global = True
 
     def _build_metaheuristic_base(self):
         self.score_requester = OOPScoreRequester(self.cotwin)

greyjack/greyjack/agents/SimulatedAnnealing.py

@@ -10,12 +10,12 @@ def __init__(
         tabu_entity_rate,
         mutation_rate_multiplier=None,
         move_probas=None,
-        compare_to_global=False,
         migration_frequency=None,
+        compare_to_global_frequency=1, # Tabu is usually not too fast-stepping due to high neighbours_count
         termination_strategy=None,
     ):
 
-        super().__init__(1.0, migration_frequency, termination_strategy)
+        super().__init__(1.0, migration_frequency, termination_strategy, compare_to_global_frequency)
 
         self.population_size = 1
         self.neighbours_count = neighbours_count
@@ -25,7 +25,7 @@ def __init__(
 
         # If true - stucks more often in local minimums, but converges much faster
         # may be useful in multiple stages solving
-        self.is_win_from_comparing_with_global = compare_to_global
+        self.is_win_from_comparing_with_global = True
 
     def _build_metaheuristic_base(self):
         self.score_requester = OOPScoreRequester(self.cotwin)

greyjack/greyjack/agents/TabuSearch.py

@@ -17,7 +17,7 @@
 
 class Agent():
 
-    def __init__(self, migration_rate, migration_frequency, termination_strategy):
+    def __init__(self, migration_rate, migration_frequency, termination_strategy, compare_to_global_frequency):
 
         if termination_strategy is None:
             raise Exception("Agent's termination_strategy is None.")
@@ -40,6 +40,8 @@ def __init__(self, migration_rate, migration_frequency, termination_strategy):
         self.migration_rate = migration_rate
         self.migration_frequency = migration_frequency
         self.steps_to_send_updates = migration_frequency
+        self.compare_to_global_frequency = compare_to_global_frequency
+        self.steps_to_compare_with_global = compare_to_global_frequency
         self.agent_status = "alive"
         self.is_last_message_shown = False
         self.round_robin_status_dict = {}
@@ -182,12 +184,15 @@ def solve(self):
                         self.logger.warning(f"Agent: {self.agent_id:4} has successfully terminated work. Now it's just transmitting updates between its neighbours until at least one agent is alive.")
                         self.is_last_message_shown = True
 
-                self._send_candidate_to_master(step_id)
+                self.steps_to_compare_with_global -= 1
+                if self.steps_to_compare_with_global <= 0:
+                    self._send_candidate_to_master(step_id)
 
-                if self.is_win_from_comparing_with_global or (not self.is_master_received_variables_info):
-                    self._check_global_updates()
-                    if self.is_end:
-                        return
+                    if self.is_win_from_comparing_with_global or (not self.is_master_received_variables_info):
+                        self._check_global_updates()
+                        if self.is_end:
+                            return
+                    self.steps_to_compare_with_global = self.compare_to_global_frequency
             except Exception as e:
                 print(e)
                 exit(-1)

greyjack/greyjack/agents/base/Agent.py

@@ -6,6 +6,7 @@
 from greyjack.agents.base.individuals.IndividualSimple import IndividualSimple
 from greyjack.agents.base.individuals.IndividualHardSoft import IndividualHardSoft
 from greyjack.agents.base.individuals.IndividualHardMediumSoft import IndividualHardMediumSoft
+from greyjack.greyjack import sum_simple_scores, sum_hard_soft_scores, sum_hard_medium_soft_scores
 
 class IncrementalScoreCalculator:
     def __init__(self):
@@ -17,6 +18,8 @@ def __init__(self):
         self.score_type = None
         self.score_variant = None
         self.is_incremental = True
+        self.constraints_names_list = None
+        self.scores_summation_function = None
 
     def add_constraint(self, constraint_name, constraint_function):
         self.constraints[constraint_name] = constraint_function
@@ -51,27 +54,21 @@ def get_score(self, planning_entity_dfs, problem_fact_dfs, delta_dfs):
         else:
             if self.score_variant == ScoreVariants.SimpleScore:
                 self.score_type = SimpleScore
+                self.scores_summation_function = sum_simple_scores
             if self.score_variant == ScoreVariants.HardSoftScore:
                 self.score_type = HardSoftScore
+                self.scores_summation_function = sum_hard_soft_scores
             if self.score_variant == ScoreVariants.HardMediumSoftScore:
                 self.score_type = HardMediumSoftScore
+                self.scores_summation_function = sum_hard_medium_soft_scores
 
         for prescoring_function in self.prescoring_functions.values():
-            prescoring_function(planning_entity_dfs, problem_fact_dfs, delta_dfs)
+            prescoring_function(planning_entity_dfs, problem_fact_dfs)
 
-        constraints_names_list = list(self.constraints.keys())
-        scores_vec = [self.constraints[name](planning_entity_dfs, problem_fact_dfs, delta_dfs) for name in constraints_names_list]
-
-        constraints_count = len(scores_vec)
-        samples_count = len(scores_vec[0]) if scores_vec else 0
-        scores = []
-
-        for j in range(samples_count):
-            sample_sum_score = self.score_type.get_null_score()
-            for i in range(constraints_count):
-                constraint_weight = self.constraint_weights[constraints_names_list[i]]
-                weighted_score = scores_vec[i][j].mul(constraint_weight)
-                sample_sum_score = sample_sum_score + weighted_score
-            scores.append(sample_sum_score)
+        if self.constraints_names_list is None:
+            self.constraints_names_list = list(self.constraints.keys())
+            
+        scores_vec = [self.constraints[name](planning_entity_dfs, problem_fact_dfs, delta_dfs) for name in self.constraints_names_list]
+        scores = self.scores_summation_function(scores_vec, self.constraint_weights, self.constraints_names_list)
 
         return scores

greyjack/greyjack/score_calculation/score_calculators/IncrementalScoreCalculator.py

@@ -6,6 +6,7 @@
 from greyjack.agents.base.individuals.IndividualSimple import IndividualSimple
 from greyjack.agents.base.individuals.IndividualHardSoft import IndividualHardSoft
 from greyjack.agents.base.individuals.IndividualHardMediumSoft import IndividualHardMediumSoft
+from greyjack.greyjack import sum_simple_scores, sum_hard_soft_scores, sum_hard_medium_soft_scores
 
 class PlainScoreCalculator:
     def __init__(self):
@@ -17,6 +18,8 @@ def __init__(self):
         self.score_type = None
         self.score_variant = None
         self.is_incremental = False
+        self.constraints_names_list = None
+        self.scores_summation_function = None
 
     def add_constraint(self, constraint_name, constraint_function):
         self.constraints[constraint_name] = constraint_function
@@ -51,27 +54,21 @@ def get_score(self, planning_entity_dfs, problem_fact_dfs):
         else:
             if self.score_variant == ScoreVariants.SimpleScore:
                 self.score_type = SimpleScore
+                self.scores_summation_function = sum_simple_scores
             if self.score_variant == ScoreVariants.HardSoftScore:
                 self.score_type = HardSoftScore
+                self.scores_summation_function = sum_hard_soft_scores
             if self.score_variant == ScoreVariants.HardMediumSoftScore:
                 self.score_type = HardMediumSoftScore
+                self.scores_summation_function = sum_hard_medium_soft_scores
 
         for prescoring_function in self.prescoring_functions.values():
             prescoring_function(planning_entity_dfs, problem_fact_dfs)
 
-        constraints_names_list = list(self.constraints.keys())
-        scores_vec = [self.constraints[name](planning_entity_dfs, problem_fact_dfs) for name in constraints_names_list]
-
-        constraints_count = len(scores_vec)
-        samples_count = len(scores_vec[0])
-        scores = []
-
-        for j in range(samples_count):
-            sample_sum_score = self.score_type.get_null_score()
-            for i in range(constraints_count):
-                constraint_weight = self.constraint_weights[constraints_names_list[i]]
-                weighted_score = scores_vec[i][j].mul(constraint_weight)
-                sample_sum_score = sample_sum_score + weighted_score
-            scores.append(sample_sum_score)
+        if self.constraints_names_list is None:
+            self.constraints_names_list = list(self.constraints.keys())
+            
+        scores_vec = [self.constraints[name](planning_entity_dfs, problem_fact_dfs) for name in self.constraints_names_list]
+        scores = self.scores_summation_function(scores_vec, self.constraint_weights, self.constraints_names_list)
 
         return scores

greyjack/greyjack/score_calculation/score_calculators/PlainScoreCalculator.py

@@ -7,7 +7,7 @@ features = ["pyo3/extension-module"]
 
 [project]
 name = "greyjack"
-version = "0.1.2"
+version = "0.1.3"
 requires-python = ">=3.9"
 dependencies = [
 	"dill",