def run(provided): alg_base = algorithm.Algorithm(clients_number=100, restaurants_number=50, mutation_probability=0.66, isDataProvided=provided) for i in range(5): alg1 = algorithm.Algorithm(clients_number=100, restaurants_number=50, mutation_probability=0.12) alg1.generate_workers(96) alg1.genetic_alg(50) mtop1.append(alg1.best[-1]) alg2 = algorithm.Algorithm(clients_number=100, restaurants_number=50, mutation_probability=0.3) alg2.generate_workers(96) alg2.genetic_alg(50) mtop2.append(alg2.best[-1]) alg3 = algorithm.Algorithm(clients_number=100, restaurants_number=50, mutation_probability=0.66) alg3.generate_workers(96) alg3.genetic_alg(50) mtop3.append(alg3.best[-1]) alg4 = algorithm.Algorithm(clients_number=100, restaurants_number=50, mutation_probability=0.9) alg4.generate_workers(96) alg4.genetic_alg(50) mtop4.append(alg4.best[-1]) plt.title("Prawdopodobieństwo mutacji = 0,66") plt.ylabel("koszty") plt.xlabel("losowe dane") plt.scatter(range(1, 6), mtop3) plt.show() plt.xticks(range(1, 6)) mmeans.append(numpy.mean(mtop1)) mmeans.append(numpy.mean(mtop2)) mmeans.append(numpy.mean(mtop3)) mmeans.append(numpy.mean(mtop4)) plt.title("Średnia dla rosnącego prawdopodobieństwa mutacji") plt.ylabel("koszty") plt.xlabel("prawdopodobieństwo mutacji") plt.scatter(mutation_count, mmeans) plt.xticks(mutation_count) plt.show()
def __init__(self, parent): Gtk.Box.__init__(self, False, 0) self.parent = parent try: current_locale, encoding = locale.getdefaultlocale() locale_path = os.path.join(os.path.abspath(os.path.dirname(__file__)), 'locale') translate = gettext.translation (cn.App.application_shortname, locale_path, [current_locale] ) _ = translate.gettext except FileNotFoundError: _ = str chart = ch.Chart() self.function = fn.Function() algo = al.Algorithm() self.algo_parameters = apm.AlgorithmParameters(self.function, algo, chart) self.func_parameters = fpm.FunctionParameters(self.function, algo, chart) self.result = rsl.Result(self.function, algo) hpaned = Gtk.Paned() hpaned.set_position(800) hpaned.add1(chart.sw) vbox = Gtk.VBox() vbox.add(self.algo_parameters.frame) vbox.add(self.func_parameters.frame) vbox.add(self.result.frame) hpaned.add2(vbox) self.pack_start(hpaned, True, True, 0)
def __init__(self, geneticGrid=None, chromosome=None): self.simulationRunning = True self.showStatistics = True self.currentLoop = 0 self.size = self.weight, self.height = config.screenWidth, config.screenHeight self.animationSpeed = config.animationStartSpeed self.pathNetwork = network.PathNetwork(config.drawGraph) if chromosome: self.chromosome = chromosome self.podFleet = podhandler.PodFleet(self.pathNetwork, self.chromosome) else: self.podFleet = podhandler.PodFleet(self.pathNetwork) if (geneticGrid): self.grid = geneticGrid else: self.grid = None self.algorithm = algorithm.Algorithm(self.podFleet) self.statistics = systemstatistics.SystemStatistics(self.podFleet) self.simulationTimeStep = config.simulationTimeStep self.FPS = None
def create_sub_frame(self): self.sub_frame1 = tk.Frame(self.master, width=1000, height=550, borderwidth=5, relief="groove") self.sub_frame3 = tk.Frame(self.master, width=1000, height=550, borderwidth=5, relief="groove") self.sub_frame4 = tk.Frame(self.master, width=1000, height=550, borderwidth=5, relief="groove") self.sub_frame2 = tk.Frame(self.master, width=1000, height=550, borderwidth=5, relief="groove") self.simulation_module = SimulationModule(self.sub_frame1) self.sub_frame1.pack(fill="both", expand=True) self.current_frame = self.sub_frame1 # self.turtle_screen = self.simulation_module.turtle_screen # self.setup_env = SetupENV(self.sub_frame3) self.setup_agent = SetupAgent(self.sub_frame4) self.setup_algorithm = al.Algorithm(self.sub_frame2, self.setup_agent) # self.setup_association = SetupAssociation(self.sub_frame3, self.setup_agent) self.control = Controlmodule(self.simulation_module, self.setup_agent, self.setup_algorithm)
def subProcess(): ''' get the image and send to algorithm to get result, then publish by mqtt publisher ''' global flg_start global frame global MQTT_TopicName cur_th = threading.currentThread() while getattr(cur_th, "do_algorithm", True): if (flg_start): start = time.time() flg_start = False ins_algorithm = algorithm.Algorithm(frame) result = int(ins_algorithm.run()) # get result from algorithm # publish client.publish(MQTT_TopicName, result) # fps end = time.time() t = end - start fps = 1 / t print("{} image process done, result: {:4}, procTime: {:4.2} ms". format(datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'), result, (t * 1000)))
def mapping(): global scan, scan_recieved, robot_ready nr = 4 pub = rospy.Publisher('map', matrix, queue_size=1) rospy.Subscriber("/PIONIER" + nr + "/RosAria/pose", Odometry, callback_pose, queue_size=1) rospy.Subscriber("/PIONIER"+nr+"/scan", LaserScan, callback_scan,queue_size=1) rospy.Subscriber("ready", Bool, callback_ready, queue_size=1) grid_map = Map() data = Parser(scan, POSE).global_coordinates x, y = list(map(list, zip(*data['coordinates']))) robot_position = (data['pose'][0], data['pose'][1]) a = algorithm.Algorithm(grid_map, (x, y), robot_position,WORLDWIDTH,CELLSIZE) while True: rospy.sleep(0.001) if scan_received && robot_ready: rospy.loginfo("Scan handling!") ## extract ranges from message data = Parser(scan, WORLDWIDTH/2,WORLDWIDTH/2,0).global_coordinates x, y = list(map(list, zip(*data['coordinates']))) robot_position = (data['pose'][0], data['pose'][1]) a.robot_position = (data['pose'][0],data['pose'][1]) a.hits = list(map(list, zip(*data['coordinates']))) a.run() a.grid_map.update() pub.publish(a.grid_map.return_map()) scan_received = False robot_ready = False
def evaluate_KT(data, model_dir, metric, stride=5): """ function to evaluate framewise matches """ # get training algorithm algo = algorithm.Algorithm() # restore the latest checkpoint of the trained model _, optimizer, _ = get_lr_opt_global_step() ckpt_manager, status, chekpoint = restore_ckpt(logdir=model_dir, optimizer=optimizer, **algo.model) if status.assert_existing_objects_matched(): print(ckpt_manager.latest_checkpoint) #input('CHEKPOINT RESTORED') # get model model = algo.model # initialize taus_all = np.zeros((len(CONFIG.DATASETS), ), dtype=np.float32) count = 0 for dataset_name in CONFIG.DATASETS: # extract emneddings embs_list, _, _, _, _ = extract_embeddings(data, dataset_name, model) num_seqs = len(embs_list) # get kendall's tau for dataset_name print(num_seqs) taus = np.zeros((num_seqs * (num_seqs - 1))) taus_cosine = np.zeros((num_seqs * (num_seqs - 1))) idx = 0 for i in range(num_seqs): query_feats = embs_list[i][::stride] print(query_feats.shape) for j in range(num_seqs): if i == j: continue candidate_feats = embs_list[j][::stride] dists = cdist(query_feats, candidate_feats, metric) #CONFIG.EVAL.KENDALLS_TAU_DISTANCE) dists_cosine = cdist( query_feats, candidate_feats, 'cosine') #CONFIG.EVAL.KENDALLS_TAU_DISTANCE) nns = np.argmin(dists, axis=1) nns_cosine = np.argmin(dists_cosine, axis=1) taus[idx] = kendalltau(np.arange(len(nns)), nns).correlation taus_cosine[idx] = kendalltau(np.arange(len(nns)), nns_cosine).correlation print('tau=%0.5f/ %0.5f' % (taus[idx], taus_cosine[idx])) idx += 1 taus = taus[~np.isnan(taus)] taus_cosine = taus_cosine[~np.isnan(taus_cosine)] print(dataset_name, taus.mean(), taus_cosine.mean()) del embs_list taus_all[count] = taus.mean() count += 1 # get kendall's tau for all visited classes tau = taus_all.mean() print(taus_all) print('datatset-wise tau=%0.5f' % tau)
def create_vis_labels(self, graph_number): """ Creates vis/neigh/unvis labels for graph. :return: The created labels. """ if graph_number == 1: nx_graph = self.nx_graph_1 backend_graph = self.backend_graph_1 elif graph_number == 2: nx_graph = self.nx_graph_2 backend_graph = self.backend_graph_2 else: return None algorithm = alg.Algorithm() node_ranking = algorithm.greatest_constraints_first(backend_graph.edge_count_list) # Set graph labels based off of associated ranking type. # Label all vis. if isinstance(node_ranking[0], graph.Node): nx_graph.nodes[node_ranking[0].identifier]['attr_dict']['node'].graph_label = 'vis' else: for visitor in node_ranking[0]: nx_graph.nodes[visitor.identifier]['attr_dict']['node'].graph_label = 'vis' # Label all neigh. try: if isinstance(node_ranking[1], graph.Node): nx_graph.nodes[node_ranking[1].identifier]['attr_dict']['node'].graph_label = 'neigh' else: for neighbor in node_ranking[1]: nx_graph.nodes[neighbor.identifier]['attr_dict']['node'].graph_label = 'neigh' except IndexError: pass # Label all unvis. try: if isinstance(node_ranking[2], graph.Node): nx_graph.nodes[node_ranking[2].identifier]['attr_dict']['node'].graph_label = 'unvis' else: for unvisited in node_ranking[2]: nx_graph.nodes[unvisited.identifier]['attr_dict']['node'].graph_label = 'unvis' except IndexError: pass # Actually set label dict based on data value. label_dict = {} backend_graph.edge_count_list[0].graph_label = 'root' for node in nx_graph.nodes().values(): # logger.info('Node Value: {0}'.format(node)) if node is not {}: label_dict[node['attr_dict']['node'].identifier] = node['attr_dict']['node'].graph_label return label_dict
def transcript_preprocess( self, transcript ): #pre-process the transcript files to extract the words self.stop_word_t = algorithm.Algorithm("SmartStoplist.txt", 4, 1, 3) self.transcript = open(transcript, 'r') self.t_text = self.transcript.read() self.t_keywords = self.stop_word_t.run( self.t_text) #first find the keywords self.t_keywords = sorted(self.t_keywords, key=lambda l: l[1], reverse=True) return self.t_keywords
def mapping(): global scan, scan_received, robot_ready nr = 4 rospy.init_node("mapping",anonymous = True) pub = rospy.Publisher('map', matrix, queue_size=1) pub_pose = rospy.Publisher('planning_time',cell,queue_size=1) rospy.Subscriber("/PIONIER4/RosAria/pose", Odometry, callback_pose, queue_size=1) rospy.Subscriber("/PIONIER4/scan", LaserScan, callback_scan,queue_size=1) rospy.Subscriber("ready", Bool, callback_ready, queue_size=1) grid_map = Map() while len(scan) == 0: print("I'm waiting") data = Parser(scan, WORLDWIDTH/2,WORLDWIDTH/2,0).global_coordinates print(data) x, y = list(map(list, zip(*data[0]['coordinates']))) robot_position = (data[0]['pose'][0], data[0]['pose'][1]) a = algorithm.Algorithm(grid_map, (x, y), robot_position,WORLDWIDTH,CELLSIZE) vec = [] mat = [] while True: rospy.sleep(0.001) if scan_received and robot_ready: rospy.loginfo("Scan handling!") ## extract ranges from message data = Parser(scan, POSE[0], POSE[1], POSE[2]).global_coordinates x, y = list(map(list, zip(*data[0]['coordinates']))) robot_position = (data[0]['pose'][0], data[0]['pose'][1]) a.robot_position = (data[0]['pose'][0],data[0]['pose'][1]) a.hits = list(map(list, zip(*data[0]['coordinates']))) a.run() a.grid_map.update() print(a.grid_map.return_map()) size_x = len(a.grid_map.return_map()) size_y = len(a.grid_map.return_map()[0]) for i in range(size_x): for j in range(size_y): vec.append(a.grid_map.return_map()[i][j]) vec1 = vector() vec1 = vec mat.append(vec1) vec = [] pub.publish(mat) pub_pose.publish(a.robot_positon) scan_received = False robot_ready = False
def main(self, *args, **kwargs): """ This brings together the etsy data and chooses the format for the data. """ help = kwargs.get("help_messages", True) etsyrequest = request.Requestor(self.api_key, help) for code in self.CODES: self.listings.extend(etsyrequest.get_listings(code)) word_processor = algorithm.Algorithm(self.listings, code) important_word = word_processor.process_data() self.word_list.append(important_word) html_path = kwargs.get("html_file_path", None) if html_path: out = outputformatter.HTMLOutput(self.word_list, html_path) out.output_html() if kwargs.get("json", None): out = outputformatter.JSONOutput(self.word_list) out.output_json()
def main(self): """ Call functions for selecting dataset and algorithm. :return: """ cached_stamp = 0 self.filename = 'watch/user_intention.json' stamp = os.stat(self.filename).st_mtime if stamp != cached_stamp: cached_stamp = stamp print("user intention file updated", file=sys.stderr) obj1 = attr.Attribute() self.learning_problem = obj1.determine_learning_problem() if self.learning_problem is 1: obj1.supervised_attribute_set() else: obj1.unsupervised_attribute_set() obj1.generate_attribute_set() obj2 = alg.Algorithm() obj2.generate_algorithm_info(output=self.learning_problem)
def main(): if len(sys.argv) < 2: print('Nie podano pliku') sys.exit(-1) data = Parser(sys.argv[1], WORLDWIDTH / 2, WORLDWIDTH / 2, 0).global_coordinates grid_map = Map(len_x=int(WORLDWIDTH / CELLSIZE), len_y=int(WORLDWIDTH / CELLSIZE)) #pdb.set_trace() print(data[0]['coordinates']) x, y = list(map(list, zip(*data[0]['coordinates']))) robot_position = (data[0]['pose'][0], data[0]['pose'][1]) a = algorithm.Algorithm(grid_map, (x, y), robot_position, WORLDWIDTH, CELLSIZE) for dat in data: a.robot_position = (dat['pose'][0], dat['pose'][1]) a.hits = list(map(list, zip(*dat['coordinates']))) # pdb.set_trace() a.run() a.grid_map.map_plot() input()
def experiment(): expResult = [] for i in range(40): print(i) rowResult = [] map = Map.Map(100, 100) mapData = map.createMap() initialX, initialY = Action.createIntialPoints(map) pointX, pointY, sensorReading, alpha = Action.generateConsecutivePoints( initialX, initialY, map, steps=100) Action.saveTraj(initialX, initialY, pointX, pointY, sensorReading, alpha) actions = [0 for i in range(100)] for i in range(len(alpha)): if alpha[i] == 'R': actions[i] = (0, 1) if alpha[i] == 'D': actions[i] = (1, 0) if alpha[i] == 'L': actions[i] = (0, -1) if alpha[i] == 'U': actions[i] = (-1, 0) observation = sensorReading al = algorithm.Algorithm(mapData, actions, observation) proMap, maxResult = al.start(True) for i in range(5, len(maxResult)): diff = abs(maxResult[i]["location"][0] - pointY[i]) + abs(maxResult[i]["location"][1] - pointX[i]) rowResult.append(diff) expResult.append(rowResult) avarage_result = [] for i in range(0, len(expResult[0])): total = 0.0 for row in expResult: total += row[i] avarage_result.append(total / len(expResult)) print(avarage_result)
def run(self): game = Game.TicTacToe() alg = Algorithm.Algorithm() print('Welcome to TicTacToe') while True: game.printGame() breaker = False while not breaker: moveStr = input( '\nMake your move! ex) "1 3" where 1 is row and 3 is column.\n' ) move = (int(moveStr[0]), int(moveStr[2])) print('You chose ({0}, {1})!'.format(move[0], move[1])) if game.makeMove(move): breaker = True else: print('Invalid move!') game.printGame() if game.gameOver(): break print('\nAI is thinking...') bestMove = alg.findBestMove(game.getGameState(), game.getIndex(), -1) print('AI chose ({0}, {1})!'.format(bestMove[0], bestMove[1])) game.makeMove(bestMove) if game.gameOver(): break if game.getWinner() == 1: print("You've won!") elif game.getWinner() == -1: print("You've lost!") else: print('Game tied!')
def draw_full_algorithm(): """ Full algorithm and comparison drawing test. """ random_grapher = randomized_grapher.RandomizedGrapher() algorithm = alg.Algorithm() # Create graph 1. graph_orig = random_grapher.create_graph(min_nodes=2, max_nodes=10, min_edges=1, max_edges=5) # Create graph 2. Done via copying graph one, with random nodes removed. graph_copy = random_grapher.copy_graph(graph_orig, remove_nodes=True) # # Extra values for graph 2. # a_node = graph_copy.get_node(0) # graph_copy.add_node(edges_in=[a_node, ]) # graph_copy.add_node() graph_orig.sort_node_edge_lists() graph_copy.sort_node_edge_lists() # Compute first half of algorithm. graph_orig_ranking = algorithm.greatest_constraints_first( graph_orig.edge_count_list) graph_copy_ranking = algorithm.greatest_constraints_first( graph_copy.edge_count_list) # Format list values. graph_orig_ranking = algorithm.condense_list(graph_orig_ranking) graph_copy_ranking = algorithm.condense_list(graph_copy_ranking) logger.info('Formatted Graph Orig Ranking: {0}'.format(graph_orig_ranking)) logger.info('Formatted Graph Copy Ranking: {0}'.format(graph_copy_ranking)) graph_1 = random_grapher.copy_graph(graph_orig) graph_2 = random_grapher.copy_graph(graph_copy) list_1 = list(graph_orig_ranking) list_2 = list(graph_copy_ranking) # Compute second half of algorithm with 'loose' edge matching. match_list = algorithm.matching(list_1, list_2, edge_strictness='loose') logger.info('Match List: {0}'.format(match_list)) # Draw data. mapper_1 = data_mapping.DataMapping(graph_1, graph_2) mapper_1.draw_side_by_side_color_maps(vis_labels=True, key=True) mapper_1.draw_matching_comparison(match_list) # Try again with 'strict' edge matching. logger.info('Formatted Graph Orig Ranking: {0}'.format(graph_orig_ranking)) logger.info('Formatted Graph Copy Ranking: {0}'.format(graph_copy_ranking)) match_list = algorithm.matching(graph_orig_ranking, graph_copy_ranking, edge_strictness='strict') logger.info('Match List: {0}'.format(match_list)) # Draw data again. mapper_2 = data_mapping.DataMapping(graph_orig, graph_copy) mapper_2.draw_side_by_side_color_maps(vis_labels=True, key=True) mapper_2.draw_matching_comparison(match_list)
import algorithm as h import output from datetime import datetime '''[Summary] this is a question which is slove N-queen question by Hill-Climbing ''' if __name__ == "__main__": num = input('pls in put queen number : ') print(str(datetime.now())) HC = h.Algorithm(int(num)) times = HC.hillSearch() print('do ...', times, ' times') print(str(datetime.now())) output.oupput2Txt(HC.pieceNode) print('--------------Another-------------') #SA = h.Algorithm(10) #times = SA.simulatedAnnleaing() #print('do ...', times, ' times')
def start(): orderVal.set('None') formulaVal.set('None') distanceVal.set('None') errorKeys = ('seq', 'curr', 'prev', 'cylinder') errors = {} seq = None cylinder = None head = None prev = None resetErrors() # Field validations if seqVal.get() == '': errors['seq'] = 'Sequences field is required!' elif seqVal.get().find(',') == -1: errors[ 'seq'] = 'Sequence field requires integers separated with commas.' else: try: seq = [int(i) for i in seqVal.get().strip().split(',')] except: errors[ 'seq'] = 'Sequence field requires multiple integer separated with commas.' if currVal.get() == '': errors['curr'] = 'Current field is required!' else: try: head = int(currVal.get()) except ValueError: errors['curr'] = 'Current field to be an integer.' if prevVal.get() == '': errors['prev'] = 'Previous field is required!' else: try: prev = int(prevVal.get()) except ValueError: errors['prev'] = 'Previous field has to be an integer.' if cylinderVal.get() == '': errors['cylinder'] = 'Cylinder field is required!' else: try: cylinder = int(cylinderVal.get()) except ValueError: errors['cylinder'] = 'Cylinder field has to be an integer.' # If any errors, display error message if any([x in errorKeys for x in errors]): if 'seq' in errors: seqErrorLbl.config(fg='red') seqError.set(errors['seq']) if 'curr' in errors: currError.set(errors['curr']) if 'prev' in errors: prevError.set(errors['prev']) if 'cylinder' in errors: cylinderError.set(errors['cylinder']) ax.clear() plot.title('Sequences') canvas.draw() else: # else attempt to start selected algorithm resetErrors() alg = algorithm.Algorithm(seq, cylinder, head, prev) results = alg.start(algVal.get()) if results: orderVal.set(', '.join(str(v) for v in results['sequence'])) formulaVal.set(results['formula']) distanceVal.set(results['distance']) # Plot graph y = results['sequence'] x = [i for i in range(len(results['sequence']))] ax.clear() plot.tight_layout() plot.title('Sequences') ax.plot(x, y, color='#78909C', marker='o', markerfacecolor='#00BCD4', markersize=10) # Assign plot label for i in range(len(results['sequence'])): ax.text(x[i] + 0.1, y[i] - 0.15, str(y[i])) canvas.draw()
def train(): """Trains model.""" # define path to log dir logdir = CONFIG.LOGDIR setup_train_dir(logdir) # Common code for multigpu and single gpu strategy = tf.distribute.MirroredStrategy() with strategy.scope(): # get training algorithm algo = train_algo.Algorithm() # Setup summary writer. summary_writer = tf.summary.create_file_writer(os.path.join( logdir, 'train_logs'), flush_millis=10000) # setup learning_rate schedule, optimizer ... learning_rate, optimizer, global_step = get_lr_opt_global_step() ckpt_manager, status, _ = restore_ckpt(logdir=logdir, optimizer=optimizer, **algo.model) global_step_value = global_step.numpy() lr_fn = get_lr_fn(CONFIG.OPTIMIZER) # Setup Dataset Iterators. batch_size_per_replica = CONFIG.TRAIN.BATCH_SIZE total_batch_size = batch_size_per_replica * strategy.num_replicas_in_sync # Setup train iterator train_ds = create_dataset(split='train', mode=CONFIG.MODE, batch_size=total_batch_size) train_iterator = strategy.make_dataset_iterator(train_ds) # define one training step def train_step(data): loss = algo.train_one_iter(data, global_step, optimizer) return loss # gathering loss across different GPUs def dist_train(it): total_loss = strategy.reduce(tf.distribute.ReduceOp.SUM, strategy.experimental_run( train_step, it), axis=None) return total_loss dist_train = tf.function(dist_train) stopwatch = Stopwatch() try: while global_step_value < CONFIG.TRAIN.MAX_ITERS: with summary_writer.as_default(): with tf.summary.record_if( global_step_value % CONFIG.LOGGING.REPORT_INTERVAL == 0): # training loss loss = dist_train(train_iterator) # Update learning rate based in lr_fn. learning_rate.assign(lr_fn(learning_rate, global_step)) tf.summary.scalar('loss', loss, step=global_step) tf.summary.scalar('learning_rate', learning_rate, step=global_step) # Save checkpoint. if global_step_value % CONFIG.CHECKPOINT.SAVE_INTERVAL == 0: ckpt_manager.save() logging.info('Checkpoint saved at iter %d.', global_step_value) # Update global step. global_step_value = global_step.numpy() time_per_iter = stopwatch.elapsed() tf.summary.scalar('timing/time_per_iter', time_per_iter, step=global_step) logging.info( 'Iter[{}/{}], {:.1f}s/iter, Loss: {:.3f}'.format( global_step_value, CONFIG.TRAIN.MAX_ITERS, time_per_iter, loss.numpy())) # Reset stopwatch after iter is complete. stopwatch.reset() except KeyboardInterrupt: logging.info( 'Caught keyboard interrupt. Saving model before quitting.') finally: # Save the final checkpoint. ckpt_manager.save() logging.info('Checkpoint saved at iter %d', global_step_value)
def MultifloorCheck(EndStartPositions, grid, startRoom, win, ROWS, width): """This file will handle multifloor requests Args: EndStartPositions (list): The positions of the start and end grid (list): The 2d list that stores all the spots in there row and column startRoom (int): The room number that the user is starting algorithm win (pygame surface): The surface to draw on the ROWS (int): The amount of rows in the grid that width (int): The width of each spot Returns: bool or list: False if not multifoor if multifloor returns the floor grid for the floor we move to next and the starting spot on that floor. """ # This dict stores the closest stair to each room. ClosestStair = { "34": "1", "p1": "1", "33": "2", "35": "2", "p2": "1", "31": "1", "32": "1", "1": "1", "2a": "3", "2": "3", "3": "3", "4": "3", "5": "3", "6": "3", "7": "4", "8": "4", "9": "4", "18": "4", "19": "4", "20": "2", "27": "4", "26": "2", "21": "2", "24": "2", "25": "2", "22": "2", "23": "2", "37": "5", "38": "5", "p3": "6", "39": "6", "40": "6", "41": "6", "10": "7", "10a": "7", "11": "8", "12": "8", "13": "8", "14": "8", "15": "8", "16": "8", "16a": "8", "17": "7" } # This dict stores each stairs locations and the location it comes out. StairLocations = { "1": "21 38 18 41", "2": "53 39 49 40", "3": "34 93 32 95", "4": "45 73 32 95", "5": "18 41 21 38", "6": "49 40 53 39", "7": "37 75 34 93", "8": "32 95 45 73" } # If the floor value of the starting and ending positions are different if EndStartPositions[2] != EndStartPositions[3]: start = EndStartPositions[0] end = StairLocations[ClosestStair[startRoom]] # Get the stair location end = end.split(" ") Endx = int(end[0]) Endy = int(end[1]) end = grid[Endx][Endy] end.make_end() for row in grid: for spot in row: # Update that spots neighbors spot.update_neighbors(grid) # Make the algorithm start algorithm.Algorithm(lambda: draw(win, grid, ROWS, width), grid, start, end) ScreenShot() # This section works out where the stair it led you to comes out. ofloorEnd = ClosestStair[startRoom] ofloorEnd = StairLocations[ofloorEnd] ofloorEnd = ofloorEnd.split(" ") # Remake the grid for the other floor grid = make_grid(ROWS, width) grid = make_barrier(grid, ROWS, EndStartPositions[3]) return [grid[int(ofloorEnd[2])][int(ofloorEnd[3])], grid] else: return False
def main(): if len(sys.argv) < 2: print('Nie podano pliku') sys.exit(-1) data = Parser(sys.argv[1], WORLDWIDTH / 2, WORLDWIDTH / 2, 0).global_coordinates grid_map = Map(len_x=int(WORLDWIDTH / CELLSIZE), len_y=int(WORLDWIDTH / CELLSIZE)) #pdb.set_trace() #print(data[0]['coordinates']) x, y = list(map(list, zip(*data[0]['coordinates']))) robot_position = (data[0]['pose'][0], data[0]['pose'][1]) a = algorithm.Algorithm(grid_map, (x, y), robot_position, WORLDWIDTH, CELLSIZE) for dat in data: a.robot_position = (dat['pose'][0], dat['pose'][1]) a.hits = list(map(list, zip(*dat['coordinates']))) # pdb.set_trace() a.run() a.grid_map.map_plot() occup_map = a.grid_map.return_map() kernel = np.ones((KERNEL, KERNEL), np.uint8) dilation = cv2.dilate(occup_map, kernel, iterations=1) plt.figure(4) plt.imshow(dilation, interpolation="nearest", cmap='Blues', origin='upper') plt.show() #print(occup_map) arr = wavefront_map(dilation, GOAL, ROBOT, THRESHOLD) arr1 = wavefront_map(occup_map, GOAL, ROBOT, THRESHOLD) #print(arr) plt.figure(5) plt.imshow(arr, interpolation="nearest", cmap='Blues', origin='upper') plt.colorbar() plt.plot(ROBOT[0], ROBOT[1], 'ro') plt.plot(GOAL[0], GOAL[1], 'rx') plt.show() path, moves_list = path_planning(arr, ROBOT) plt.figure(2) plt.imshow(occup_map, interpolation="nearest", cmap='Blues', origin='upper') plt.plot([i[1] for i in path], [i[0] for i in path], 'ro') plt.plot(ROBOT[0], ROBOT[1], 'bo') plt.plot(GOAL[0], GOAL[1], 'bx') plt.title("Ścieżka wyznaczona z zastosowaniem dylatacji") path1, moves_list1 = path_planning(arr1, ROBOT) # print(path) plt.figure(3) plt.imshow(occup_map, interpolation="nearest", cmap='Blues', origin='upper') plt.plot([i[1] for i in path1], [i[0] for i in path1], 'ro') plt.plot(ROBOT[0], ROBOT[1], 'bo') plt.plot(GOAL[0], GOAL[1], 'bx') plt.title("Ścieżka wyznaczona bez wykorzystania dylatacji") plt.show()
def main(StartRoom, EndRoom, win=WIN, width=WIDTH): """This is the main function were everything will be managed by Args: StartRoom (int): The room number of the start room EndRoom (int): The room number of the end room win (pygame surface):, optional): The pygame surface to draw one. Defaults to WIN. width (int, optional): The width of each spot. Defaults to WIDTH. Returns: list: A list of paths to the screenshots so the main file can send them """ ROWS = 100 # Make the grid grid = make_grid(ROWS, width) # Start and end position start = None end = None done = False run = True global ScreenshotList ScreenshotList = [] # The room coordinates the last didget is the floor number. RoomLocations = { "34": "32 35 0", "p1": "42 35 0", "33": "51 35 0", "35": "45 36 0", "p2": "37 36 0", "31": "25 48 0", "32": "25 55 0", "1": "25 67 0", "2a": "23 74 0", "2": "23 74 0", "3": "27 80 0", "4": "27 86 0", "5": "25 92 0", "6": "29 92 0", "7": "47 92 0", "8": "47 87 0", "9": "47 84 0", "18": "80 72 0", "19": "80 72 0", "20": "71 51 0", "27": "70 65 0", "26": "70 54 0", "21": "78 47 0", "24": "66 47 0", "25": "75 47 0", "22": "71 47 0", "23": "71 47 0", "37": "19 37 1", "38": "26 37 1", "p3": "33 37 1", "39": "42 37 1", "40": "44 38 1", "41": "36 38 1", "10": "26 82 1", "10a": "26 87 1", "11": "26 91 1", "12": "28 92 1", "13": "28 92 1", "14": "37 92 1", "15": "42 95 1", "16": "43 90 1", "16a": "43 86 1", "17": "43 81 1" } EndStartSpots = GetStartAndEndPosition( RoomLocations, StartRoom, EndRoom, grid) # Get the start and end spots. if isinstance( EndStartSpots, str ): # If file returned a string. In my case that means a exception happend. return EndStartSpots start = EndStartSpots[0] end = EndStartSpots[1] grid = make_barrier(grid, ROWS, EndStartSpots[2]) NewFloorData = MultifloorCheck(EndStartSpots, grid, StartRoom, WIN, ROWS, width) if NewFloorData: start = NewFloorData[0] start.make_start() grid = NewFloorData[1] end = grid[end.get_pos()[0]][end.get_pos()[1]] end.make_end() # Infinate loop while run: draw(win, grid, ROWS, width) # Loop through all event that have happend in this frame for event in pygame.event.get(): # If the event is a certain event if event.type == pygame.QUIT: # If pressed X exit infinate loop run = False # If left mouse clicked if pygame.mouse.get_pressed()[0]: # Get x and y coordinate of mouse pos = pygame.mouse.get_pos() # Translate mouse pos into row and col row, col = get_clicked_pos(pos, ROWS, width) # Get the spot you clicked spot = grid[row][col] # Update all neighbors of all of the spots # Loop through the rows of the grid for row in grid: for spot in row: # Update that spots neighbors spot.update_neighbors(grid) # Make the algorithm start if not done: algorithm.Algorithm(lambda: draw(win, grid, ROWS, width), grid, start, end) done = True ScreenShot() return ScreenshotList # When while loop breaks end game pygame.quit()
def run(provided=False): alg_base = algorithm.Algorithm(clients_number=100, restaurants_number=50, mutation_probability=0.66, isDataProvided=provided) for i in range(5): alg1 = copy.deepcopy(alg_base) alg1.generate_workers(96) alg1.genetic_alg(50) ctop1.append(alg1.best[-1]) alg2 = copy.deepcopy(alg_base) alg2.generate_workers(96) alg2.genetic_alg(100) ctop2.append(alg2.best[-1]) alg3 = copy.deepcopy(alg_base) alg3.generate_workers(96) alg3.genetic_alg(150) ctop3.append(alg3.best[-1]) alg4 = copy.deepcopy(alg_base) alg4.generate_workers(96) alg4.genetic_alg(200) ctop4.append(alg4.best[-1]) alg5 = copy.deepcopy(alg_base) alg5.generate_workers(96) alg5.genetic_alg(250) ctop5.append(alg5.best[-1]) alg6 = copy.deepcopy(alg_base) alg6.generate_workers(96) alg6.genetic_alg(300) ctop6.append(alg6.best[-1]) alg7 = copy.deepcopy(alg_base) alg7.generate_workers(96) alg7.genetic_alg(350) ctop7.append(alg7.best[-1]) alg8 = copy.deepcopy(alg_base) alg8.generate_workers(96) alg8.genetic_alg(400) ctop8.append(alg8.best[-1]) alg9 = copy.deepcopy(alg_base) alg9.generate_workers(96) alg9.genetic_alg(450) ctop9.append(alg9.best[-1]) alg10 = copy.deepcopy(alg_base) alg10.generate_workers(96) alg10.genetic_alg(500) ctop10.append(alg10.best[-1]) plt.title("Liczba cykli = 50") plt.ylabel("koszty") plt.xlabel("losowe dane") plt.scatter(range(1, 6), ctop1) plt.show() plt.xticks(range(1, 6)) cmeans.append(numpy.mean(ctop1)) cmeans.append(numpy.mean(ctop2)) cmeans.append(numpy.mean(ctop3)) cmeans.append(numpy.mean(ctop4)) cmeans.append(numpy.mean(ctop5)) cmeans.append(numpy.mean(ctop6)) cmeans.append(numpy.mean(ctop7)) cmeans.append(numpy.mean(ctop8)) cmeans.append(numpy.mean(ctop9)) cmeans.append(numpy.mean(ctop10)) plt.title("Średnia dla rosnącej liczby cykli") plt.ylabel("koszty") plt.xlabel("liczba cykli") plt.scatter(cycles_count, cmeans) plt.xticks(cycles_count) plt.show()
def run(provided=False): alg_base = algorithm.Algorithm(clients_number=100, restaurants_number=50, mutation_probability=0.66, isDataProvided=provided) for i in range(5): alg1 = copy.deepcopy(alg_base) alg1.generate_workers(workers_count[0]) alg1.genetic_alg(50) ptop1.append(alg1.best[-1]) alg2 = copy.deepcopy(alg_base) alg2.generate_workers(workers_count[1]) alg2.genetic_alg(50) ptop2.append(alg2.best[-1]) alg3 = copy.deepcopy(alg_base) alg3.generate_workers(workers_count[2]) alg3.genetic_alg(50) ptop3.append(alg3.best[-1]) alg4 = copy.deepcopy(alg_base) alg4.generate_workers(workers_count[3]) alg4.genetic_alg(50) ptop4.append(alg4.best[-1]) alg5 = copy.deepcopy(alg_base) alg5.generate_workers(workers_count[4]) alg5.genetic_alg(50) ptop5.append(alg5.best[-1]) alg6 = copy.deepcopy(alg_base) alg6.generate_workers(workers_count[5]) alg6.genetic_alg(50) ptop6.append(alg6.best[-1]) alg7 = copy.deepcopy(alg_base) alg7.generate_workers(workers_count[6]) alg7.genetic_alg(50) ptop7.append(alg7.best[-1]) alg8 = copy.deepcopy(alg_base) alg8.generate_workers(workers_count[7]) alg8.genetic_alg(50) ptop8.append(alg8.best[-1]) alg9 = copy.deepcopy(alg_base) alg9.generate_workers(workers_count[8]) alg9.genetic_alg(50) ptop9.append(alg9.best[-1]) alg10 = copy.deepcopy(alg_base) alg10.generate_workers(workers_count[9]) alg10.genetic_alg(50) ptop10.append(alg10.best[-1]) pmeans.append(numpy.mean(ptop1)) pmeans.append(numpy.mean(ptop2)) pmeans.append(numpy.mean(ptop3)) pmeans.append(numpy.mean(ptop4)) pmeans.append(numpy.mean(ptop5)) pmeans.append(numpy.mean(ptop6)) pmeans.append(numpy.mean(ptop7)) pmeans.append(numpy.mean(ptop8)) pmeans.append(numpy.mean(ptop9)) pmeans.append(numpy.mean(ptop10)) print("done") plt.title("Populacja = 96") plt.ylabel("koszty") plt.xlabel("losowe dane") plt.scatter(range(1, 6), ptop3) plt.show() plt.xticks(range(1, 6)) plt.title("Średnia dla rosnących populacji") plt.ylabel("koszty") plt.xlabel("zwiekszajaca sie populacja") plt.scatter(workers_count, pmeans) plt.xticks(workers_count) plt.show()
]) df = pandas.DataFrame(index=range(N_experiments), columns=pars.keys() + [ 'mean_var_R', ]) # get = scipy.load('q0.npz') # N_skip = get['q0'].shape[0]/pars['N'] # assert N_skip*pars['N'] == get['q0'].shape[0] # q0 = get['q0'][::N_skip] algs = (algorithm.AlgorithmOUConstraintsHamiltonian(pot, pars), \ algorithm.AlgorithmTaylor(pot, pars), \ algorithm.AlgorithmTaylorBAOAB(pot, pars), \ algorithm.Algorithm(pot, pars), \ algorithm.AlgorithmPseudospectralSemiImplicit(pot, pars), \ algorithm.AlgorithmOUConstraints(pot, pars), \ algorithm.AlgorithmQuasiPseudospectralSemiImplicit(pot, pars), \ algorithm.AlgorithmSemiImplicit(pot, pars),\ algorithm.AlgorithmInversePseudospectralSemiImplicit(pot, pars)) fig, axs = plt.subplots(1, 2) # for experiment in range(N_experiments): experiment = 0 for alg_i in [ 0, ]: alg = algs[alg_i] print experiment
def stop_word_removal(self): self.stop_word = algorithm.Algorithm( "SmartStoplist.txt", 4, 3, 3) #stop word removal using the smart stopword list
def run_algorithm_with_result_log(min_nodes=2, max_nodes=10, min_edges=1, max_edges=5, remove_nodes=False, min_percent_removal=10, max_percent_removal=90, edge_strictness='loose'): """ Actually runs iterations of algorithm and logs results. """ # Initialize necessary classes. random_grapher = randomized_grapher.RandomizedGrapher() algorithm = alg.Algorithm() # Do 100 iterations of current values. index = 0 while index < 100: # Start Timer start_time = time.time() # Create graphs and sort edge lists. # First graph. graph_orig = random_grapher.create_graph(min_nodes=min_nodes, max_nodes=max_nodes, min_edges=min_edges, max_edges=max_edges) first_graph_creation_time = time.time() node_count = len(graph_orig.nodes) # Second graph. graph_copy = random_grapher.copy_graph( graph_orig, remove_nodes=remove_nodes, min_percent_removal=min_percent_removal, max_percent_removal=max_percent_removal) second_graph_creation_time = time.time() # Sort graph edges for algorithm. graph_orig.sort_node_edge_lists() graph_copy.sort_node_edge_lists() graph_edge_sort_time = time.time() # Run first half of algorithm and format for second half. graph_orig_ranking = algorithm.greatest_constraints_first( graph_orig.edge_count_list) graph_copy_ranking = algorithm.greatest_constraints_first( graph_copy.edge_count_list) graph_orig_ranking = algorithm.condense_list(graph_orig_ranking) graph_copy_ranking = algorithm.condense_list(graph_copy_ranking) greatest_constraints_time = time.time() # Run second half of algorithm. match_list = algorithm.matching(graph_copy_ranking, graph_orig_ranking, edge_strictness=edge_strictness) matching_time = time.time() # Record info. # logger.info(match_list) algorithm_results = { 'node_count': node_count, 'start_time': start_time, 'first_graph_creation_time': first_graph_creation_time, 'second_graph_creation_time': second_graph_creation_time, 'graph_edge_sort_time': graph_edge_sort_time, 'greatest_constraints_time': greatest_constraints_time, 'matching_time': matching_time, 'number_of_matches': len(match_list), } logger.testresult(algorithm_results) index += 1
def main(): if os.path.exists("result"): os.remove("result") #clear and recreate the result file result_ = open("result", "w") args = parser.parse_args() alg = algorithm.Algorithm() if args.input_mode == "files_tsp225": #result_.write("Instance\tOPT\tFarthest\t3-opt\tCheapest\tchristofides\tNearest\tDT\n") data_path = "data/" TSP_START_LINE = 6 TSP_END_LINE = -1 TOUR_STAT_LINE = 5 TOUR_END_LINE = -2 node_list = [] route = [] name = "tsp225" tfile_name = data_path + name + ".tsp" sfile_name = data_path + name + ".opt.tour" tfile_ = open(tfile_name, "r") sfile_ = open(sfile_name, "r") tfile = tfile_.readlines() sfile = sfile_.readlines() result_dic = {} for j in tfile[TSP_START_LINE:TSP_END_LINE]: node_coord = j.lstrip().rstrip("\n").split(" ") node_list.append((float(node_coord[1]), float(node_coord[2]))) for j in sfile[TOUR_STAT_LINE:TOUR_END_LINE]: node_coord = j.rstrip("\n") route.append(int(node_coord) - 1) g1 = graph.Graph("input_point", input_data=node_list) result_.write(name + "\t") g1.route = route result_dic["opt"] = g1.cal() alg.farthest(g1) result_dic["farthest"] = g1.cal() alg.k_opt(3, g1) result_dic["k_opt"] = g1.cal() alg.cheapest(g1) result_dic["cheapest"] = g1.cal() alg.christofides(g1) result_dic["christofides"] = g1.cal() alg.nearest(g1) result_dic["nearest"] = g1.cal() alg.double_tree(g1) result_dic["DT"] = g1.cal() for i in result_dic: result_.write(i + "\t" + str(result_dic[i]) + "\t" + str(result_dic[i] / result_dic["opt"]) + "\n") tfile_.close() sfile_.close() elif args.input_mode == "input_weight": with open('2dmatrix.data') as f: array = [[float(x) for x in next(f).split()]] # read first line for line in f: # read rest of lines array.append([float(x) for x in line.split()]) k = len(array[-1]) nparray = np.zeros((k, k)) for i in range(k): for j in range(i): nparray[i, j] = array[i][j] g1 = graph.Graph("input_weight", input_data=nparray) result_dic = { "double_tree": 0, "christofides": 0, "greed": 0, "cheapest": 0, "nearest": 0, "farthest": 0, "k_opt": 0 } alg.double_tree(g1) result_dic["double_tree"] = g1.cal() alg.christofides(g1) result_dic["christofides"] = g1.cal() alg.greed(g1) result_dic["greed"] = g1.cal() alg.cheapest(g1) result_dic["cheapest"] = g1.cal() alg.nearest(g1) result_dic["nearest"] = g1.cal() alg.farthest(g1) result_dic["farthest"] = g1.cal() alg.k_opt(3, g1) result_dic["k_opt"] = g1.cal() for i in result_dic: result_.write(i + "\t" + str(result_dic[i]) + "\n") """ sfile_name="data/pa561.opt.tour" sfile_ = open(sfile_name, "r") sfile=sfile_.readlines() route = [] for j in sfile[5:-2]: node_coord=j.rstrip("\n") route.append(int(node_coord)-1) g1.route=route opt=g1.cal() for i in result_dic: result_.write(i+"\t"+str(result_dic[i])+"\t"+str(result_dic[i]/opt)+"\n") """ elif args.input_mode == "input_point": with open('coordinates.data') as f: array = [[float(x) for x in next(f).split()]] # read first line for line in f: # read rest of lines array.append([float(x) for x in line.split()]) g1 = graph.Graph("input_point", input_data=array) result_dic = { "double_tree": 0, "christofides": 0, "greed": 0, "cheapest": 0, "nearest": 0, "farthest": 0, "k_opt": 0 } alg.double_tree(g1) result_dic["double_tree"] = g1.cal() alg.christofides(g1) result_dic["christofides"] = g1.cal() alg.greed(g1) result_dic["greed"] = g1.cal() alg.cheapest(g1) result_dic["cheapest"] = g1.cal() alg.nearest(g1) result_dic["nearest"] = g1.cal() alg.farthest(g1) result_dic["farthest"] = g1.cal() alg.k_opt(3, g1) result_dic["k_opt"] = g1.cal() for i in result_dic: result_.write(i + "\t" + str(result_dic[i]) + "\n") elif args.input_mode == "random": #in random generating, there is only so-called approx ratio n_test = 40 cum_result_dic = { "double_tree": 0, "christofides": 0, "greed": 0, "cheapest": 0, "nearest": 0, "farthest": 0, "k_opt": 0 } for i in range(n_test): g1 = graph.Graph('random', args.node_min, args.node_max) alg.double_tree(g1) cum_result_dic["double_tree"] += g1.cal() alg.christofides(g1) cum_result_dic["christofides"] += g1.cal() alg.greed(g1) cum_result_dic["greed"] += g1.cal() alg.cheapest(g1) cum_result_dic["cheapest"] += g1.cal() alg.nearest(g1) cum_result_dic["nearest"] += g1.cal() alg.farthest(g1) cum_result_dic["farthest"] += g1.cal() alg.k_opt(3, g1) cum_result_dic["k_opt"] += g1.cal() for i in cum_result_dic: result_.write(i + "\t" + str(cum_result_dic[i] / n_test) + "\n") else: exit(0) result_.close()