v0.0.22 TSP, VRP examples with plain score calculator; sampling fix in mover; some refactor

Author: CameleoGrey

.gitignore

@@ -1,6 +1,7 @@
 
 /.vscode
 /greyjack/target
+/data
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

examples/object_oriented/nqueens/scripts/solve_nqueens.py

@@ -2,8 +2,7 @@
 import os
 import sys
 
-# To launch normally from console without setup.py greyjack (just for developing)
-# Inside console run from from project dir: >python ./{path_to_example_script.py}
+# To launch normally from console
 script_dir_path = Path(os.path.dirname(os.path.realpath(__file__)))
 project_dir_id = script_dir_path.parts.index("greyjack-solver-python")
 project_dir_path = Path(*script_dir_path.parts[:project_dir_id+1])
@@ -23,16 +22,16 @@
 if __name__ == "__main__":
 
     # build domain model
-    domain_builder = DomainBuilderNQueens(1024, random_seed=45)
+    domain_builder = DomainBuilderNQueens(256, random_seed=45)
     cotwin_builder = CotwinBuilderNQueens()
 
     #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=128, tabu_entity_rate=0.0, 
-                       mutation_rate_multiplier=None, move_probas=[0, 1, 0, 0, 0, 0], 
-                       migration_frequency=1, termination_strategy=termination_strategy)
+                       mutation_rate_multiplier=None, move_probas=None, 
+                       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)"""
@@ -41,7 +40,7 @@
                            migration_frequency=10, termination_strategy=termination_strategy)"""
 
     solver = Solver(domain_builder, cotwin_builder, agent, 
-                    ParallelizationBackend.Multiprocessing, LoggingLevel.FreshOnly,
+                    ParallelizationBackend.Multiprocessing, LoggingLevel.Info,
                     n_jobs=10, score_precision=[0])
     solution = solver.solve()
     #print( "Cotwin solution looks that: " )

examples/object_oriented/tsp/__init__.py

@@ -0,0 +1,9 @@
+
+
+class CotStop():
+    def __init__(self, stop_id, location_list_id):
+
+        self.stop_id = stop_id
+        self.location_list_id = location_list_id
+
+        pass

examples/object_oriented/tsp/cotwin/CotStop.py

@@ -0,0 +1,11 @@
+
+
+class EdgeDistance():
+
+    def __init__(self, from_stop, to_stop, distance):
+
+        self.from_stop = from_stop
+        self.to_stop = to_stop
+        self.distance = distance
+
+        pass

examples/object_oriented/tsp/cotwin/EdgeDistance.py

@@ -0,0 +1,10 @@
+
+from greyjack.cotwin.CotwinBase import CotwinBase
+
+class TSPCotwin( CotwinBase ):
+
+    def __init__(self):
+        super().__init__()
+
+        pass
+

examples/object_oriented/tsp/cotwin/TSPCotwin.py

@@ -0,0 +1,26 @@
+
+import math
+
+class Location():
+     def __init__(self, id, name, latitude, longitude, distances_to_other_locations_dict):
+
+         self.id = id
+         self.name = name
+         self.latitude = latitude
+         self.longitude = longitude
+         self.distances_to_other_locations_dict = None
+
+         pass
+
+     def __str__(self):
+         return "Location id: " + str(self.id) + " | " + self.name + ": " + "lat=" + str(self.latitude) + ", " + "lon=" + str(self.longitude)
+
+     def get_distance_to_other_location(self, other_location):
+
+         if self.distances_to_other_locations_dict is None:
+             distance = math.sqrt((other_location.latitude - self.latitude)**2 + (other_location.longitude - self.longitude)**2)
+         else:
+             distance = self.distances_to_other_locations_dict[ other_location.name ]
+
+         return distance
+

examples/object_oriented/tsp/cotwin/__init__.py

@@ -0,0 +1,102 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+class TravelSchedule():
+    def __init__(self, name, vehicle, locations_list, distance_matrix):
+
+        self.name = name
+        self.vehicle = vehicle
+        self.locations_list = locations_list
+        self.distance_matrix = distance_matrix
+
+        pass
+
+    def get_unique_stops_count(self):
+        unique_stops = set(self.vehicle.trip_path)
+        unique_stops_count = len(unique_stops)
+        return unique_stops_count
+    
+    def get_travel_distance(self):
+
+        depot = self.vehicle.depot
+        trip_path = self.vehicle.trip_path
+        if trip_path is None or trip_path == []:
+            raise Exception("Vehicle trip_path is not initialized. Probably, a TSP task isn't solved yet or domain model isn't updated.")
+
+        depot_to_first_stop_distance = depot.get_distance_to_other_location( trip_path[0] )
+        last_stop_to_depot_distance = trip_path[-1].get_distance_to_other_location( depot )
+
+        interim_stops_distance = 0
+        for i in range(1, len(trip_path)):
+            stop_from = trip_path[i-1]
+            stop_to = trip_path[i]
+            current_distance = stop_from.get_distance_to_other_location( stop_to )
+            interim_stops_distance += current_distance
+
+        travel_distance = depot_to_first_stop_distance + interim_stops_distance + last_stop_to_depot_distance
+
+        return travel_distance
+
+    def print_metrics(self):
+        print("Solution distance: {}".format(self.get_travel_distance()))
+        print("Unique stops (excluding depot): {}".format(self.get_unique_stops_count()))
+
+    def print_path(self):
+        path_names_string = self.build_string_of_path_names()
+        path_ids_string = self.build_string_of_path_ids()
+
+        print( path_names_string )
+        print( path_ids_string )
+    
+    def build_string_of_path_names(self):
+        path_names_string = [str(self.vehicle.depot.name)]
+        for stop in self.vehicle.trip_path:
+            path_names_string.append( str(stop.name) )
+        path_names_string.append( str(self.vehicle.depot.name) )
+        path_names_string = " --> ".join( path_names_string )
+        return path_names_string
+    
+    def build_string_of_path_ids(self):
+        path_ids_string = [str(self.vehicle.depot.id)]
+        for stop in self.vehicle.trip_path:
+            path_ids_string.append( str(stop.id) )
+        path_ids_string.append( str(self.vehicle.depot.id) )
+        path_ids_string = " --> ".join( path_ids_string )
+        return path_ids_string
+
+
+    def plot_path(self, image_file_path=None, dpi=200):
+
+        x_coordinates = []
+        y_coordinates = []
+        labels = []
+        for location in self.locations_list:
+            x = location.latitude
+            y = location.longitude
+            label = location.name
+
+            x_coordinates.append( x )
+            y_coordinates.append( y )
+            labels.append( label )
+
+        plt.scatter( x=x_coordinates, y=y_coordinates, s=1)
+        for x, y, label in zip(x_coordinates, y_coordinates, labels):
+            plt.text( x, y, label, fontsize=8, fontfamily="calibri" )
+
+        edges_x = [self.vehicle.depot.latitude]
+        edges_y = [self.vehicle.depot.longitude]
+        trip_path = self.vehicle.trip_path
+        for stop_point in trip_path:
+            edges_x.append( stop_point.latitude )
+            edges_y.append( stop_point.longitude )
+
+        edges_x.append(self.vehicle.depot.latitude)
+        edges_y.append(self.vehicle.depot.longitude)
+
+        plt.plot( edges_x, edges_y, linewidth=0.5 )
+
+        if image_file_path is None:
+            plt.show()
+        else:
+            plt.savefig(image_file_path, dpi=dpi)
+            plt.close()

examples/object_oriented/tsp/domain/Location.py

@@ -0,0 +1,10 @@
+
+
+class Vehicle():
+
+    def __init__(self, depot, trip_path):
+
+        self.depot = depot
+        self.trip_path = trip_path
+
+        pass

examples/object_oriented/tsp/domain/TravelSchedule.py

@@ -0,0 +1,78 @@
+import random
+import numpy as np
+
+from examples.object_oriented.tsp.cotwin.CotStop import CotStop
+from examples.object_oriented.tsp.cotwin.EdgeDistance import EdgeDistance
+from examples.object_oriented.tsp.cotwin.TSPCotwin import TSPCotwin
+from examples.object_oriented.tsp.score.TSPPlainScoreCalculator import TSPPlainScoreCalculator
+
+from greyjack.persistence.CotwinBuilderBase import CotwinBuilderBase
+from greyjack.variables.GJInteger import GJInteger
+
+
+class CotwinBuilder(CotwinBuilderBase):
+
+    def __init__(self):
+
+        super().__init__()
+
+        pass
+
+    def build_cotwin(self, domain_model, is_already_initialized):
+
+        tsp_cotwin = TSPCotwin()
+
+        tsp_cotwin.add_planning_entities_list(self._build_planning_path_stops(domain_model), "path_stops")
+
+        # (!) better use distance matrix mapping than building and joining large distance dataframe!
+        #tsp_cotwin.add_problem_facts_list(self._build_edge_distances(domain_model), "edge_distances")
+
+        score_calculator = TSPPlainScoreCalculator()
+        score_calculator.utility_objects["distance_matrix"] = domain_model.distance_matrix
+        tsp_cotwin.set_score_calculator( score_calculator )
+
+        return tsp_cotwin
+
+    def _build_edge_distances(self, domain_model):
+
+        distance_matrix = domain_model.distance_matrix
+        n_stops = len(distance_matrix)
+
+        edge_distances = []
+        for i in range(n_stops):
+            for j in range(n_stops):
+                current_edge_distance = EdgeDistance( i, j, distance_matrix[i][j] )
+                edge_distances.append( current_edge_distance )
+
+        return edge_distances
+
+    def _build_planning_path_stops(self, domain_model):
+
+        planning_path_stops = []
+        locations_list = domain_model.locations_list
+        n_locations = len(locations_list)
+        n_stops = n_locations - 1 # excluding depot
+
+        # greed heuristic for initializing
+        initial_stop_ids = []
+        current_approx_stop = 0
+        for i in range(1, n_locations):
+            candidate_stops = domain_model.distance_matrix[current_approx_stop]
+            candidate_stops = np.argsort( candidate_stops )#[::-1]#[5:] #<-- for experiments
+            existing_stop_ids = set(initial_stop_ids)
+            for candidate_stop in candidate_stops:
+                if ((candidate_stop not in existing_stop_ids)
+                        and (candidate_stop != current_approx_stop)
+                        and (candidate_stop != 0)):
+                    initial_stop_ids.append( candidate_stop )
+                    current_approx_stop = candidate_stop
+                    break
+
+        for i in range(0, n_stops):
+            # initial_value=1+i for simulating situation, in which we don't 
+            # know good start solution or greed heuristic, but know, what solution must contain unique stops
+            # initial_stop_ids[i] for using greed heuristic
+            planning_stop = CotStop(stop_id=i, location_list_id=GJInteger(1, n_locations-1, False, initial_stop_ids[i]))
+            planning_path_stops.append(planning_stop)
+
+        return planning_path_stops