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

examples/object_oriented/vrp/domain/VehicleRoutingPlan.py

@@ -2,14 +2,14 @@
 import matplotlib.pyplot as plt
 
 class VehicleRoutingPlan():
-    def __init__(self, name, vehicles, customers_dict, depot_dict, distance_matrix, customers_id_to_matrix_id_map, time_windowed):
+    def __init__(self, name, vehicles, customers_dict, depot_dict, distance_matrix, customers_id_to_vec_id_map, time_windowed):
 
         self.name = name
         self.vehicles = vehicles
         self.customers_dict = customers_dict
         self.depot_dict = depot_dict
         self.distance_matrix = distance_matrix
-        self.customers_id_to_matrix_id_map = customers_id_to_matrix_id_map
+        self.customers_id_to_vec_id_map = customers_id_to_vec_id_map
         self.time_windowed = time_windowed
 
         pass

examples/object_oriented/vrp/persistence/CotwinBuilder.py

@@ -14,15 +14,16 @@
 
 class CotwinBuilder(CotwinBuilderBase):
 
-    def __init__(self, use_incremental_score_calculator):
+    def __init__(self, use_incremental_score_calculator, use_greed_init):
         self.use_incremental_score_calculator = use_incremental_score_calculator
+        self.use_greed_init = use_greed_init
         pass
 
     def build_cotwin(self, domain, is_already_initialized):
 
         vrp_cotwin = VRPCotwin()
 
-        vrp_cotwin.add_planning_entities_list(self._build_planning_stops(domain), "planning_stops")
+        vrp_cotwin.add_planning_entities_list(self._build_planning_stops(domain, is_already_initialized), "planning_stops")
         vrp_cotwin.add_problem_facts_list(self._build_problem_fact_vehicles(domain), "vehicles")
         vrp_cotwin.add_problem_facts_list(self._build_problem_fact_customers(domain), "customers")
 
@@ -46,11 +47,11 @@ def _build_problem_fact_vehicles(self, domain):
         problem_fact_vehicles = []
         for i, domain_vehicle in enumerate(domain.vehicles):
             vehicle_id = i
-            depot_matrix_id = domain_vehicle.depot_matrix_id
+            depot_vec_id = domain_vehicle.depot_vec_id
             capacity = domain_vehicle.capacity
             work_day_start = domain_vehicle.work_day_start
             work_day_end = domain_vehicle.work_day_end
-            cot_vehicle = CotVehicle( vehicle_id, capacity, depot_matrix_id, work_day_start, work_day_end)
+            cot_vehicle = CotVehicle( vehicle_id, capacity, depot_vec_id, work_day_start, work_day_end)
             problem_fact_vehicles.append( cot_vehicle )
 
         return problem_fact_vehicles
@@ -72,29 +73,42 @@ def _build_problem_fact_customers(self, domain):
 
         return problem_fact_customers
 
-    def _build_planning_stops(self, domain):
+    def _build_planning_stops(self, domain, is_already_initialized):
 
         planning_stops = []
         customers_dict = domain.customers_dict
         n_depots = len(domain.depot_dict)
         n_customers = len(customers_dict)
         k_vehicles = len(domain.vehicles)
 
-        initial_vehicle_ids, initial_customer_ids = self.build_greed_initial_ids(domain)
+        initial_vehicle_ids = [None for k in range(n_customers - n_depots)]
+        initial_customer_ids = [None for i in range(n_customers - n_depots)]
+        is_frozen = [False for i in range(n_customers - n_depots)]
+        if is_already_initialized:
+            i = 0
+            for k in range(k_vehicles):
+                vehicle_k = domain.vehicles[k]
+                for customer in vehicle_k.customer_list:
+                    initial_vehicle_ids[i] = k
+                    initial_customer_ids[i] = domain.customers_id_to_vec_id_map[customer.id]
+                    is_frozen[i] = customer.frozen
+                    i += 1
+        elif self.use_greed_init:
+            initial_vehicle_ids, initial_customer_ids = self.build_greed_initial_ids(domain)
 
         for i in range(n_depots, n_customers):
 
             #initial_value=None
             #initial_value=i % (k_vehicles-1)
             #initial_value=initial_vehicle_ids[i - n_depots]
             #semantic_groups=["vehicle_assignment", "common"]
-            planning_vehicle_id = GJInteger(0, k_vehicles-1, False, initial_vehicle_ids[i - n_depots], semantic_groups=["vehicle_assignment", "common"])
+            planning_vehicle_id = GJInteger(0, k_vehicles-1, is_frozen[i - n_depots], initial_vehicle_ids[i - n_depots], semantic_groups=["vehicle_assignment", "common"])
 
             #initial_value=None
             #initial_value=i
             #initial_value=initial_customer_ids[i - n_depots]
             #semantic_groups=["customer_assignment", "common"]
-            planning_customer_id = GJInteger(n_depots, n_customers-1, False, initial_customer_ids[i - n_depots], semantic_groups=["customer_assignment", "common"])
+            planning_customer_id = GJInteger(n_depots, n_customers-1, is_frozen[i - n_depots], initial_customer_ids[i - n_depots], semantic_groups=["customer_assignment", "common"])
 
             planning_stop = CotStop(planning_vehicle_id, planning_customer_id)
             planning_stops.append(planning_stop)
@@ -120,7 +134,7 @@ def build_greed_initial_ids(self, domain):
             if len(remaining_customers) <= 0:
                 break
 
-            vehicle_depot_id = vehicle.depot_matrix_id
+            vehicle_depot_id = vehicle.depot_vec_id
             vehicle_capacity = vehicle.capacity
             collected_demand = 0
             vehicle_stops = []
@@ -191,7 +205,7 @@ def add_incremental_utilities(self, domain, score_calculator):
         depot_ids = np.zeros((k_vehicles, ), dtype=np.int64)
         capacities = np.zeros((k_vehicles, ), dtype=np.int64)
         for k in range(k_vehicles):
-            depot_ids[k] = domain.vehicles[k].depot_matrix_id
+            depot_ids[k] = domain.vehicles[k].depot_vec_id
             capacities[k] = domain.vehicles[k].capacity
         score_calculator.utility_objects["depot_ids"] = depot_ids
         score_calculator.utility_objects["vehicle_capacities"] = capacities