def test_load_heuristics_from_disk_run_sstar(self): # change heuristic setting cfg.Algorithm.sstar_heuristic_type = "custom" # bind custom_heuristics function Common.custom_heuristics = self.my_cust_h_func # create context handler and run S*-mm context = Context(graph, T) # profiler enable profiler.enable() # Now run context.run("S*-MM") # disable profiler profiler.disable() # store results results = context.return_solutions() stats = pstats.Stats(profiler).sort_stats('cumtime') stats.print_stats() print(results)
def test_load_heuristics_from_disk_run_sstar(self): # load preprocessed heuristic from disk GenerateHeuristics.load_results(further_save_file) # change heuristic setting cfg.Algorithm.sstar_heuristic_type = "preprocess" # create context handler and run S*-mm context = Context(graph, T) # profiler enable profiler.enable() # Now run context.run("S*-MM") # disable profiler profiler.disable() # store results results = context.return_solutions() stats = pstats.Stats(profiler).sort_stats('cumtime') stats.print_stats() print(results)
def get_kruskal_info(self, terminal_instance): context = Context(self.graph, terminal_instance) # context.run('Kruskal', file_to_read=self.cache_filepath, heuristic_for_recon=self.heuristic_type, RECON_PATH=self.reconstruct_path_ornot) context.run('Kruskal', file_to_read=self.cachefiles, heuristic_for_recon=self.heuristic_type, RECON_PATH=self.reconstruct_path_ornot) # lock.acquire() # kruskal_results_proxy.append(context.return_solutions()) # lock.release() return context.return_solutions()
def run_individual_algs(self, inputs): job_id, data = inputs # print("starting job id: ", job_id) terminals, alg = data context = Context(self.graph, terminals) context.run(alg) # print("finished job id: ", job_id) # Try mutex locking to avoid race conditions # lock.acquire() # proxy_dict[alg].append(context.return_solutions()) # lock.release() return alg, context.return_solutions()
def test_kruskal_with_depots(self): # Spec out our squareGrid minX = -15 # [m] maxX = 15 minY = -15 maxY = 15 grid = None # pre-existing 2d numpy array? grid_size = 1 # grid fineness[m] grid_dim = [minX, maxX, minY, maxY] n_type = 8 # neighbor type # neighbor type # Define some depots # depots = [(-8,-4), (1,-11), (12,-10)] # depots = [(-15,-15), (-15,15)] # depots = [(27, 11), (45, 22), (62, 31), (13, 26), (35, 41)] depots = [(-8, -4), (12, -3), (-11, 12), (1, -11), (-4, 6)] # Create a squareGridDepot using GraphFactory graph = GraphFactory.create_graph("SquareGridDepot", grid=grid, grid_dim=grid_dim, grid_size=grid_size, n_type=n_type, depots=depots) # Define some terminals # terminals = [(-10, -12), (-3, 10), (10, -7), (13, 6), (0, 3)] # terminals = [(-15,-15), (-15,15), (15,15), (15,-15)] terminals = [(-8, -4), (0, -13), (1, -5), (-15, 2), (-1, -7), (-11, 12), (11, 5), (-10, -5), (7, 6), (0, 4), (-8, 11), (12, -10), (1, 1), (-6, 1), (-1, 11), (-3, 1), (-12, -13), (-14, -1), (-13, -12), (14, 2), (15, -10), (2, 11), (5, -8), (12, 8), (15, -8), (13, 13), (0, 14), (3, 11), (-12, 0), (8, 9), (-4, 6), (1, -11), (-1, 1), (0, -12), (-1, -2), (12, -3), (-6, 13)] # terminals = [(62, 15), (63, 14), (3, 52), (35, 41), (59, 36), (7, 42), (28, 26), (45, 22), (62, 31), (28, 46), (23, 44), (5, 60), (10, 35), (61, 60), (36, 50), (57, 59), (19, 60), (59, 46), (53, 23), (63, 44), (44, 36), (59, 4), (33, 9), (44, 55), (63, 10), (45, 54), (49, 51), (13, 26), (43, 29), (0, 49), (35, 51), (27, 11), (25, 47), (38, 44), (49, 36), (23, 63), (55, 49), (11, 31), (28, 42), (50, 46), (46, 13), (55, 34), (34, 26), (19, 17), (44, 57), (17, 1), (31, 17), (4, 58), (31, 14), (21, 55), (7, 4), (39, 51), (4, 44), (62, 25), (2, 29), (59, 18), (11, 14), (55, 13), (29, 39), (7, 33), (23, 17), (6, 62), (23, 15), (27, 32), (13, 28), (25, 52), (53, 12), (60, 31), (43, 49), (35, 2), (60, 10), (7, 13), (49, 18), (38, 36), (57, 10), (27, 52), (14, 30), (28, 55), (35, 18), (17, 3), (38, 13), (9, 37), (41, 19), (43, 37), (34, 1), (30, 28), (53, 63), (60, 1), (18, 60), (54, 35), (52, 26), (61, 51), (34, 40), (7, 45), (26, 63), (45, 29), (50, 31), (35, 42), (60, 34), (54, 29)] # Use context to run kruskal context = Context(graph, terminals) self.assertTrue(context.run('Kruskal')) results = context.return_solutions() # test comps type self.assertIsInstance(results, dict)
def test_simple_parser_mapf(self): # Some online_data options # mapf # define filename to use # filename = "results/online_data/mapf/Berlin_1_256.map" # filename = "results/online_data/mapf/maze-32-32-2.map" filename = os.path.join(cfg.data_dir, "mapf", "maze-32-32-2.map") # Get package file location # cwd = os.path.dirname(os.path.realpath(steinerpy.__file__))+"/../" filepath = os.path.join(cwd, filename) # Return edge dictionary and terminal list # obs, height, width = DataParser.parse(filepath, dataset_type="mapf") graph = DataParser.parse(filepath, dataset_type="mapf") minX, maxX, minY, maxY = graph.grid_dim obs = graph.obstacles # # dims # minX, maxX = 0, width - 1 # minY, maxY = 0, height - 1 # grid_size = 1 # grid fineness[m] # grid_dim = [minX, maxX, minY, maxY] # n_type = 8 # neighbor type # # Create a squareGrid using GraphFactory # graph = GraphFactory.create_graph(type_="SquareGrid", grid_dim=grid_dim, grid_size=grid_size, n_type= n_type, obstacles=obs) # graph.show_grid() # generate random terminals T = [] while len(T) < 5: x = random.randint(minX, maxX) y = random.randint(minY, maxY) if (x, y) not in obs: T.append((x, y)) # Create context, run and store results context = Context(graph, T) context.run('Kruskal') results1 = context.return_solutions() context.run('S*-HS') results2 = context.return_solutions() # assert results eps = 1e-6 self.assertTrue( abs(sum(results1['dist']) - sum(results2['dist']) <= eps))
def run_func(self): """ Queries Kruskal's algorithm for each run instance for baseline results Results are saved to file Raises: FileExistsError: If output (baseline) file already exists Todo: * Consider using timeit for more accurate results https://stackoverflow.com/questions/7370801/how-to-measure-elapsed-time-in-python """ #start time t0 = timer() # Get path and check for existance. Don't overwrite files! # directory = os.path.dirname(os.path.realpath(__file__)) if os.path.exists(os.path.join(self.save_directory, self.filename)): raise FileExistsError('{} already exists!'.format(self.filename)) # Create n-terminals for m-instances if self._terminals is None: # self._terminals = [[list(i) for i in self.create_terminals()][0] for j in range(self.m_instances)] self._terminals = self.create_terminals() obstacles = self.graph.obstacles # Run Kruskals on each and save results solution = [] for ndx, t in enumerate(self._terminals): MyLogger.add_message("Running terminals: {}".format(t), __name__, "INFO") # ko = Kruskal(self.graph, t) # ko.run_algorithm() # solution.append(ko.return_solutions()) # Ensure every terminal is reachable! keepRunning = True while keepRunning: try: context = Context(self.graph, t) context.run('Kruskal') solution.append(context.return_solutions()) keepRunning = False except: MyLogger.add_message( "one or more terminals is landlocked! In ndx {}, with terminals: {}" .format(ndx, t), __name__, "CRITICAL") # Generate new terminals and replace the ones we have right now t = [list(i) for i in self.create_terminals()][0] self._terminals[ndx] = t print(ndx, '\n') # end time t1 = timer() - t0 # dump instances and solution to file # directory = os.getcwd() if self.save_to_file: with open(os.path.join(self.save_directory, self.filename), 'wb') as f: pickle.dump( { 'terminals': self._terminals, 'solution': solution, 'obstacles': obstacles }, f) print("Finished! Wrote baseline file! Now generate results! {}".format( t1)) if cfg.Misc.sound_alert == True: os.system( 'spd-say "Finished! Wrote baseline file! Now generate results!"' ) return { 'terminals': self._terminals, 'solution': solution, 'obstacles': obstacles }
def test_alg_baseline(self): # Spec out our squareGrid minX = -15 # [m] maxX = 15 minY = -15 maxY = 15 grid = None # pre-existing 2d numpy array? grid_size = 1 # grid fineness[m] grid_dim = [minX, maxX, minY, maxY] n_type = 8 # neighbor type # Create a squareGrid using GraphFactory try: graph = GraphFactory.create_graph("SquareGrid", grid=grid, grid_dim=grid_dim, grid_size=grid_size, n_type=n_type) self.assertTrue(True) except Exception as _e: raise _e # Load Kruskal Baseline data directory = os.path.dirname(os.path.realpath(__file__)) with open(os.path.join(directory, 'baseline_test_single.pkl'), 'rb') as f: data = pickle.load(f) '''data={ 'solution': [{'sol':[], 'path':[], 'dist':[]}, {...}, ..., {}] 'terminals':[ [(x,y),...,(xn,yn)],[...],[...],....,[] ] } ''' # Use contextualizer to run algorithms (make sure debug visualizer is off) results = { 'S*-unmerged': [], 'S*-HS': [], 'S*-HS0': [], } # Fill 'Kruskal' results from baseline file for ndx, t in enumerate(data['terminals']): # Create context context = Context(graph, t) #formerly dijkstra context.run('S*-HS0') results['S*-HS0'].append(context.return_solutions()) # astar unmerged context.run('S*-unmerged') results['S*-unmerged'].append(context.return_solutions()) # formerly bi-directional astar context.run('S*-HS') results['S*-HS'].append(context.return_solutions()) #We already have kruskals as base line # Save results! directory = os.path.dirname(os.path.realpath(__file__)) with open(os.path.join(directory, 'results_test_single.pkl'), 'wb') as f: pickle.dump(results, f)
from steinerpy.library.graphs.graph import GraphFactory from steinerpy.context import Context # Spec out our `SquareGrid` type graph object using `GraphFactory` minX = -15 # [m] maxX = 15 minY = -15 maxY = 15 grid = None # pre-existing 2d numpy array? grid_size = 1 # grid fineness[m] grid_dim = [minX, maxX, minY, maxY] n_type = 8 # neighbor type # Create a squareGrid using GraphFactory graph = GraphFactory.create_graph("SquareGrid", grid=grid, grid_dim=grid_dim, grid_size=grid_size, n_type= n_type) terminals = [(-10, -12), (-3, 10), (10, -7), (13, 6), (0, 3)] # Create context context = Context(graph, terminals) # run and store results for astar context.run('S*-HS') results = context.return_solutions()
def run_func(self, algorithms_to_run=None): """Run each of our algorithms using a context class The context class takes a 'graph' and an instance of 't' terminals, then executes each algorithm on a given instance. Results are appended to the appropriate location in the 'results' attribute. Finally, output files have a 'results_' string prepended in the current directory for processing Returns: results (dict): Contains results for the algorithms ran """ t0 = timer() # Use contextualizer to run algorithms (make sure debug visualizer is off for speed) if algorithms_to_run is None: results = {'S*-HS':[], 'S*-BS': [], 'S*-unmerged':[], \ 'S*-MM':[]} algorithms_to_run = list(results) else: results = {alg: [] for alg in algorithms_to_run} # results = {'Astar':[], 'SstarAstar':[], 'SstarDijkstra': [], 'SstarPrimalDual': []} for ndx, t in enumerate(self.data['terminals']): if self.run_instance is not None and ndx != self.run_instance: # Skip everything except user-specified run continue # Add obstacles to graph? if 'obstacles' in self.data and self.data[ 'obstacles'] and self.graph.obstacles is not None: # self.graph.set_obstacles(self.data['obstacles'][ndx]) self.graph.set_obstacles(self.data['obstacles']) # Log terminals MyLogger.add_message("terminals: {}".format(t), __name__, "INFO") # Create context context = Context(self.graph, t) # context.run('Astar') # results['Astar'].append(context.return_solutions()) for alg in algorithms_to_run: context.run(alg) results[alg].append(context.return_solutions()) # context.run('SstarMM') # results['SstarMM'].append(context.return_solutions()) # context.run('SstarAstar') # results['SstarAstar'].append(context.return_solutions()) # context.run('SstarPrimalDual') # results['SstarPrimalDual'].append(context.return_solutions()) #We already have kruskals as base line print('finished with instance {} \n'.format(ndx)) t1 = timer() - t0 # Save results! if self.save_to_file: # directory = os.path.dirname(os.path.realpath(__file__)) with open(os.path.join(self.save_directory, self.results_filename), 'wb') as f: pickle.dump(results, f) print( "Wrote results to file! Now process them! {} secs".format(t1)) if cfg.Misc.sound_alert is True: os.system( 'spd-say "Finished! Wrote results to file! Now process them!"' ) return results