v0.0.24 Refactor of agents signatures; multi-phase solving fix + example; replanning fix + example; some experiments

Author: CameleoGrey

examples/object_oriented/nqueens/persistence/DomainBuilderNQueens.py

@@ -35,7 +35,7 @@ def build_domain_from_scratch(self):
 
         return chess_field
 
-    def build_from_solution(self, solution):
+    def build_from_solution(self, solution, initial_domain=None):
         raise Exception("build_from_solution() not implemented for DomainBuilderNQueens")
 
     def build_from_domain(self, domain):

examples/object_oriented/nqueens/score/IncrementalScoreCalculatorNQueens.py

@@ -77,7 +77,7 @@ def all_different(self, planning_entity_dfs, problem_fact_dfs, delta_dfs):
         return scores"""
 
 @staticmethod
-@jit(nopython=True)
+@jit(nopython=True, cache=True)
 #@numba.cfunc("float64[:](int64[:], int64[:], int64, int64[:], int64[:], int64[:], int64)")
 def compute_score_values(
     native_column_ids, 

examples/object_oriented/nqueens/scripts/solve_nqueens.py

@@ -29,15 +29,15 @@
     #termination_strategy = TimeSpentLimit(time_seconds_limit=60)
     #termination_strategy = ScoreNoImprovement(time_seconds_limit=15)
     termination_strategy = ScoreLimit(score_to_compare=[0])
-    agent = TabuSearch(neighbours_count=128, tabu_entity_rate=0.0, 
+    agent = TabuSearch(neighbours_count=20, tabu_entity_rate=0.0, 
                        mutation_rate_multiplier=None, move_probas=[0, 1, 0, 0, 0, 0], 
-                       migration_frequency=1, termination_strategy=termination_strategy)
+                       compare_to_global=True, 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=1, tabu_entity_rate=0.0, 
                            mutation_rate_multiplier=None, move_probas=[0, 1, 0, 0, 0, 0], 
-                           migration_frequency=10, termination_strategy=termination_strategy)"""
+                           termination_strategy=termination_strategy)"""
 
     solver = Solver(domain_builder, cotwin_builder, agent, 
                     ParallelizationBackend.Multiprocessing, LoggingLevel.Info,

examples/object_oriented/tsp/persistence/DomainBuilder.py

@@ -47,7 +47,7 @@ def build_domain_from_scratch(self):
 
         return domain_model
 
-    def build_from_solution(self, solution):
+    def build_from_solution(self, solution, initial_domain=None):
 
         domain  = self.build_domain_from_scratch()
         path_stop_ids = []
@@ -69,7 +69,7 @@ def build_from_domain(self, domain):
     def _build_distance_matrix(self, locations_list):
 
         @staticmethod
-        @jit()
+        @jit(nopython=True, cache=True)
         def compute_distance_matrix(latitudes, longitudes, n_locations):
             distance_matrix = np.zeros( (n_locations, n_locations), dtype=np.int64 )
             for i in range(n_locations):

examples/object_oriented/tsp/score/IncrementalScoreCalculatorTSP.py

@@ -59,7 +59,7 @@ def all_in_one_constraint(self, planning_entity_dfs, problem_fact_dfs, delta_dfs
         return scores
 
 @staticmethod
-@jit(nopython=True)
+@jit(nopython=True, cache=True)
 def compute_penalties(changed_stops, current_df_row_ids, current_loc_ids, distance_matrix, last_id, target_stops_count):
     changed_stops[current_df_row_ids] = current_loc_ids
 

examples/object_oriented/tsp/score/PlainScoreCalculatorTSP.py

@@ -66,7 +66,7 @@ def no_duplicating_stops_constraint(self, planning_entity_dfs, problem_fact_dfs)
     # numba is perfect for writing small pieces of code (that difficult or imposible to express in Polars) with numpy objects
     # instead rewriting on Rust (to not increase complexity of project and still take huge performance boost)
     @staticmethod
-    @jit(nopython=True)
+    @jit(nopython=True, cache=True)
     def compute_path_distance(planning_stop_ids, distance_matrix):
         current_path_distance = 0
         current_path_distance += distance_matrix[0][planning_stop_ids[0]]
@@ -99,7 +99,7 @@ def minimize_distance(self, planning_entity_dfs, problem_fact_dfs):
     # numba is perfect for writing small pieces of code (that difficult or imposible to express in Polars) with numpy objects
     # instead rewriting on Rust (to not increase complexity of project and still take huge performance boost)
     @staticmethod
-    @jit(nopython=True)
+    @jit(nopython=True, cache=True)
     def compute_path_distances(data_matrix, distance_matrix):
 
         unique_sample_ids = np.unique(data_matrix[:, 0])

examples/object_oriented/tsp/scripts/solve_tsp.py

@@ -26,32 +26,32 @@
     #file_path = Path(data_dir_path, "cook", "air", "st70.tsp") # 682.57 - optimum
     #file_path = Path(data_dir_path, "belgium", "road-km", "belgium-road-km-n100.tsp") # 1727.262 - optimum, 2089 - first_fit
     #file_path = Path(data_dir_path, "tsplib", "a280.tsp") # 2579 - optimal
-    #file_path = Path(data_dir_path, "cook", "air", "pcb442.tsp") #optimum: 50778; first_fit: ~63k
+    file_path = Path(data_dir_path, "cook", "air", "pcb442.tsp") #optimum: 50778; first_fit: ~63k
     #file_path = Path(data_dir_path, "cook", "air", "lu980.tsp")
     #file_path = Path(data_dir_path, "other", "air", "usa_tx_2743.tsp") #optimum: ~282; first_fit: ~338
     #file_path = Path(data_dir_path, "belgium", "air", "belgium-n2750.tsp")
     #file_path = Path(data_dir_path, "tsplib", "fnl4461.tsp") #optimum: 182566; first_fit: ~230k
-    file_path = Path(data_dir_path, "cook", "air", "gr9882.tsp") #optimum: 300899; first_fit: ~400k
+    #file_path = Path(data_dir_path, "cook", "air", "gr9882.tsp") #optimum: 300899; first_fit: ~400k
 
     domain_builder = DomainBuilder(file_path)
     cotwin_builder = CotwinBuilder(use_incremental_score_calculator=True)
 
     #termination_strategy = StepsLimit(step_count_limit=1000)
-    termination_strategy = TimeSpentLimit(time_seconds_limit=60)
-    #termination_strategy = ScoreNoImprovement(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])
     agent = TabuSearch(neighbours_count=128, tabu_entity_rate=0.2, 
                        mutation_rate_multiplier=None, move_probas=[0.0, 0.2, 0.2, 0.2, 0.2, 0.2],
-                       migration_frequency=10, termination_strategy=termination_strategy)
+                       compare_to_global=False, 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)"""
     """agent = LateAcceptance(late_acceptance_size=64, tabu_entity_rate=0.2, 
                            mutation_rate_multiplier=None, move_probas=[0.0, 0.2, 0.2, 0.2, 0.2, 0.2], 
-                           migration_frequency=10000, termination_strategy=termination_strategy)"""
+                           termination_strategy=termination_strategy)"""
 
     solver = Solver(domain_builder, cotwin_builder, agent, 
-                    ParallelizationBackend.Multiprocessing, LoggingLevel.Info,
+                    ParallelizationBackend.Multiprocessing, LoggingLevel.FreshOnly,
                     n_jobs=10, score_precision=[0, 0])
     solution = solver.solve()
 

examples/object_oriented/vrp/cotwin/CotCustomer.py

@@ -1,9 +1,9 @@
 
 
 class CotCustomer():
-    def __init__(self, customer_matrix_id, demand, time_window_start, time_window_end, service_time):
+    def __init__(self, customer_vec_id, demand, time_window_start, time_window_end, service_time):
 
-        self.customer_matrix_id = customer_matrix_id
+        self.customer_vec_id = customer_vec_id
         self.demand = demand
         self.time_window_start = time_window_start
         self.time_window_end = time_window_end

examples/object_oriented/vrp/domain/Customer.py

@@ -4,7 +4,7 @@
 class Customer():
      def __init__(self, id, name, latitude, longitude, demand=None,
                   time_window_start=None, time_window_end=None, service_time=None,
-                  distances_to_other_customers_dict=None):
+                  distances_to_other_customers_dict=None, frozen=False):
 
          self.id = id
          self.name = name
@@ -15,6 +15,7 @@ def __init__(self, id, name, latitude, longitude, demand=None,
          self.time_window_end = time_window_end
          self.service_time = service_time
          self.distances_to_other_customers_dict = distances_to_other_customers_dict
+         self.frozen = frozen
 
          pass
 

examples/object_oriented/vrp/domain/Vehicle.py

@@ -2,10 +2,10 @@
 
 class Vehicle():
 
-    def __init__(self, depot, depot_matrix_id, work_day_start, work_day_end, capacity, customer_list, max_stops):
+    def __init__(self, depot, depot_vec_id, work_day_start, work_day_end, capacity, customer_list, max_stops):
 
         self.depot = depot
-        self.depot_matrix_id = depot_matrix_id
+        self.depot_vec_id = depot_vec_id
         self.work_day_start = work_day_start
         self.work_day_end = work_day_end
         self.capacity = capacity