def solve_vrp(nodes, vehicles): def real_distance_time(a, b: NODE) -> (float, float): if not a.db_uid or not b.db_uid: return float('inf'), float('inf') else: return local_db['matrix'][a.db_uid][b.db_uid]['distance'], local_db['matrix'][a.db_uid][b.db_uid]['time'] world = pants.World(nodes, real_distance_time) solver = pants.Solver(ant_capacity=sum([ant.capacity for ant in vehicles]) / len(vehicles), iterations=100, ant_count=15) vrp_solution = [] unreachable_clients = [] nodes_left = world.real_nodes() total_nodes = len(nodes_left) while len(nodes_left) != 1: logging.info('%s done' % (100 - (len(nodes_left) / total_nodes))) # print(len(world.real_nodes()) - 1) solution = solver.solve(world) # nodes_left = solution.remaining_moves() if len(solution.visited) == 1: # Nothing was visited # TODO: use saved unreachable clients somehow unreachable_clients.append(solution.unvisited) break vrp_solution.append(solution.clone()) nodes_left = [v for i, v in enumerate(nodes_left) if i not in frozenset(solution.visited[1:])] del world world = pants.World(nodes_left, real_distance_time) # print(solution.distance) return vrp_solution, unreachable_clients
def main(): nodes = [1, 2, 3, 4, 5, 6, 7] world = pants.World(nodes, length_function) solver = pants.Solver() solution = solver.solve(world) print(solution.distance) print(solution.tour) # Nodes visited in order
def optimize(self, route): # exclude one HQ (otherwise there will be 2 HQs in the path) nodes = route.path[:len(route.path)-1] world = pants.World(nodes, self.maps.get_distance) solver = pants.Solver() return solver.solve(world)
def click_res(event, x, y, flags, params): if event == cv2.EVENT_LBUTTONDOWN: #print(x, y) points.append((x,y)) nodes.append((x, y)) cv2.circle(img, (x, y), 2, [0, 0, 255], 2) draw_lines((x, y)) cv2.imshow('ACO', img) if event == cv2.EVENT_RBUTTONDOWN: print("Right click") world = pants.World(nodes, distance) solver = pants.Solver(rho=0.5, q=1, t0=0.01, limit=50, ant_count=10) solutions = solver.solutions(world) best = float("inf") for solution in solutions: print(solution.distance) if solution.distance < best: best = solution.distance c = solution print(best) print(c.tour) c=c.tour for i in range(len(c)-1): cv2.line(img, c[i], c[i+1], [150, 0, 0], 3) cv2.line(img, c[0], c[len(c)-1], [150, 0, 0], 3) cv2.imshow('ACO', img)
def main(): try: readCSV() world = pants.World() solver = pants.Solver() displaySolution(solver, world) except Exception as ex: print("main : " + format(ex))
def plan_aco(self): import pants world = pants.World(self.points, self.two_points_cost) solver = pants.Solver() solution = solver.solve(world) return solution, solution.distance
def solve(self): world = pants.World(self.nodes, self.distMetric) ants = [Ant().initialize(world, world.nodes[0]) for i in range(10)] solver = pants.Solver() # solution = solver.solve(world) # solutions = solver.solutions(world) solver.find_solutions(ants) ants = sorted(ants) for i in range(1, len(ants)): assert ants[i - 1].distance <= ants[i].distance return (ants[0].distance, ants[0].tour)
def main(): nodes = [1, 2, 3, 4, 5, 6] world = pants.World(nodes, length_function) tiempo_inicial = time() solver = pants.Solver() solution = solver.solve(world) tiempo_final = time() tiempo_ejecucion = tiempo_final - tiempo_inicial print ('El tiempo de ejecucion fue:',tiempo_ejecucion) #En segundos print(solution.distance) print(solution.tour) # Nodes visited in order
def findOptimalSolutions(self): nodes = list(self.timeDf.columns) world = pants.World(nodes, self.calculateLength) solver = pants.Solver() sol = solver.solve(world) sols = solver.solutions(world) print("****************") print(sol.distance) print("****************") print(self.beautifyLatLon(sol.tour)) print("****************") print(sol.path) print("***********\n**********\n########") for s in sols: print(s.distance) processTrail(self.beautifyLatLon(sol.tour))
def aco(self): '''ACO is a simulated approach wherein it is assumed that ants are exploring possible routes on the graph. Using a probabilistic approach which considers both the cost and the amount of pheromone deposited each ant chooses the next city to visit. Until each opf the ants complets a tour, they explore, depositing pheromone on each edge that they cross. The Ant which completes with tour with the lowest cost wins. The amount of pheromone deposited is inversely proportional to the tour length: the shorter the tour, the more it deposits. Time Comlexity: http://ls2-www.cs.tu-dortmund.de/~sudholt/chapterACO09.pdf''' nodes = list(range(len(self.dist))) world = pants.World(nodes, lambda a, b: self.dist[a][b]) solver = pants.Solver() solution = solver.solve(world) path = self.minimal_subset_path(solution.tour) return path
def MiniAco(nodes): world = pants.World(nodes, Cost) solver = pants.Solver() solution = solver.solve(world) # or solutions = solver.solutions(world) # print('distance',solution.distance) # print('tour',solution.tour) # Nodes visited in order # print('path',solution.path) # Edges taken in order # or best = float("inf") bestT = 0 for solution in solutions: assert solution.distance < best best = solution.distance bestT = solution.tour # bestT.insert(0,centru) # bestT.append(centru) return bestT
def runACO(nodes, numberOfPubsToLookAt): world = pants.World(nodes, distance) solver_setting_report_format = "\n".join([ "Solver settings:", "limit={w.limit}", "rho={w.rho}, Q={w.q}", "alpha={w.alpha}, beta={w.beta}", "elite={w.elite}" ]) print(solver_setting_report_format.format(w=solver)) columns = "{!s:<25}\t{:<25}" divider = "-" * (25 + 25) header = columns.format("Time Elapsed", "Distance") columns = columns.replace('<', '>', 1) print() print(header) print(divider) fastest = None start_time = time.time() for i, ant in enumerate(solver.solutions(world)): fastest = ant fastest_time = timedelta(seconds=(time.time() - start_time)) print(columns.format(fastest_time, ant.distance)) total_time = timedelta(seconds=(time.time() - start_time)) print(divider) print("Best solution:") for i, n in zip(fastest.visited, fastest.tour): print(" {:>8} = {}".format(i, n)) print("Solution length: {}".format(fastest.distance)) print('Shortest way between the first ' + str(numberOfPubsToLookAt) + ' English Pubs (easting/northings) :') print(fastest.distance) print("Found at {} out of {} seconds.".format(fastest_time, total_time))
x = (b[1] - a[1]) * math.cos(0.5 * (b[0] + a[0])) y = b[0] - a[0] # Calcul de distance d = R * math.sqrt(x * x + y * y) return d # On vient diviser la liste pour limiter les données for i in range(iter): pop = noeuds[i * nbBars:(i + 1) * nbBars] # On enlève les doublons pop = set(pop) pop = list(pop) G.clear() monde = pants.World(pop, distance) solver = pants.Solver() solution = solver.solve(monde) print("Distance", i, "=", solution.distance) distances.append(solution.distance) # On ajoute les noeuds au graph G.add_edges_from([(edge.start, edge.end) for edge in solution.path]) plt.clf() nx.draw(G) plt.pause(1) # Enregistrement fichier plt.title("distance = %s" % solution.distance) plt.savefig("./images/d_%s.png" % i, bbox_inches="tight") plt.show()
def trevize(G, s, t, v1, verbose, first_pairs=[]): """Find path. input: graph, s, t, v1 process: BFS & check path when completed. - using deque for a first implementation - sort edges before adding to deque as a stack output: valid path list `valid_paths` """ def init_globals(s, t, v1): """Init preds, succs of first layer. store as vertex: {depth: {end_vertex: [list of paths]}} vertices in preds: v in v1 and t. vertices in succs: v in v1 and s.""" # init s, t succs[s] = {1: {}} preds[t] = {1: {}} for v_pred in G.predecessors_iter(t): preds[t][1][v_pred] = [[v_pred, t]] for v_succ in G.successors_iter(s): succs[s][1][v_succ] = [[s, v_succ]] # init v in v1 for v in v1: preds[v] = {1: {}} succs[v] = {1: {}} for v_pred in G.predecessors_iter(v): preds[v][1][v_pred] = [[v_pred, v]] for v_succ in G.successors_iter(v): succs[v][1][v_succ] = [[v, v_succ]] def add_link_to_links(p_out, p_in): """Add link to links_in, links_out.""" v_out = p_out[0] v_in = p_in[-1] new_link_path = p_out + p_in if (v_out, v_in) not in links_in[v_in]: links_in[v_in][(v_out, v_in)] = [new_link_path] links_out[v_out][(v_out, v_in)] = [new_link_path] elif new_link_path not in links_in[v_in][(v_out, v_in)]: links_in[v_in][(v_out, v_in)] += [new_link_path] links_out[v_out][(v_out, v_in)] += [new_link_path] def iter_layer(v, depth, direction='in'): """Iterate one more layer of predecessors/successors BFS. add one more vertex to begin/end of paths.""" if direction is 'in': if v not in preds: # init first layer preds[v] = {} preds[v][1] = {} for v_pred in G.predecessors_iter(v): if v_pred in set_sv1: add_link_to_links([v_pred], [v]) else: preds[v][1][v_pred] = [[v_pred, v]] return elif depth in preds[v]: # if calculated, return return else: preds[v][depth] = {} # else, init new layer for end_vertex in preds[v][depth - 1]: for end_path in preds[v][depth - 1][end_vertex]: for v_pred in G.predecessors_iter(end_vertex): if v_pred not in end_path: # no cycle if v_pred in set_sv1: # link: add to links add_link_to_links([v_pred], end_path) continue # not in v1, add to preds/succs for iteration if v_pred not in preds[v][depth]: preds[v][depth][v_pred] =\ [[v_pred] + end_path] else: preds[v][depth][v_pred] +=\ [[v_pred] + end_path] elif direction is 'out': # out, successors if v not in succs: # init first layer succs[v] = {} succs[v][1] = {} for v_succ in G.successors_iter(v): if v_succ in set_v1t: add_link_to_links([v], [v_succ]) else: succs[v][1][v_succ] = [[v, v_succ]] return elif depth in succs[v]: # if calculated, return return else: succs[v][depth] = {} # else, init new layer for end_vertex in succs[v][depth - 1]: # from every end_vertex, add one layer for end_path in succs[v][depth - 1][end_vertex]: for v_succ in G.successors_iter(end_vertex): if v_succ not in end_path: if v_succ in set_v1t: # link: add to links add_link_to_links(end_path, [v_succ]) continue # not in v1, add to preds/succs for iteration elif v_succ not in succs[v][depth]: succs[v][depth][v_succ] =\ [end_path + [v_succ]] else: succs[v][depth][v_succ] +=\ [end_path + [v_succ]] else: return 1 def get_v_layer(v, depth, direction): """Wrapper to get demanded layer of in/out BFS. - direction: 'in', 'out' """ if direction is 'in': global_dict = preds elif direction is 'out': global_dict = succs else: # wrong direction return False for i_depth in range(depth, 0, -1): if v not in global_dict: iter_layer(v, 1, direction) if i_depth in global_dict[v]: layers_to_cal = list(range(i_depth + 1, depth + 1)) for layer in layers_to_cal: iter_layer(v, layer, direction) if global_dict[v][depth]: return True else: return False def merge_dicts(x, y): """Given two dicts, merge them into a new dict as a shallow copy.""" z = x.copy() z.update(y) return z # for py < 3.5 # return {**x, **y} def check_path(path): """Check if path con tains all vertices in v1.""" if set_v1 <= set(path[1:-1]): if path not in valid_paths: return True else: return False def sort_path(vertex, next_list): """Sort next vertex list by V' first, then by weight.""" weight_list = {} if len(next_list) is 1: return list(next_list) for next_v in next_list: # generate value list: add large num to vertices not in v1 LARGE_NUM = 20 if next_v is t: weight_list[next_v] = 0 if next_v in dict_v1: weight_list[next_v] = next_list[next_v]['weight'] if iter_depth is 0: nn_v_list = G[next_v] if nn_v_list: nn_weight = sort_path(next_v, nn_v_list, 1)[0] # least weight from nn_v_list weight_list[next_v] = (next_list[next_v]['weight'] + nn_weight) else: weight_list[next_v] = (next_list[next_v]['weight']) else: weight_list[next_v] = (next_list[next_v]['weight'] + LARGE_NUM) return sorted(weight_list, key=weight_list.get) def find_least_pair(links, pair_to_find=False): """Find least merge pair.""" # links: {link:(outdegree+indegree), outdegree, indegree, length, path} if pair_to_find: print(pair_to_find) path_pair = links_out[pair_to_find[0]][tuple(pair_to_find)][0] return path_pair least = (100, 100, 100, 600, 0) for v in path_set_sv1: if v not in links_out: # a vertex is not in links_out print('no way for vertex:', v) print(path_set_sv1) pprint(links_out) return 0 for v in path_set_sv1: for pair in links_out[v]: # iterate all link in links_out v_in = pair[1] outdegree = sv1_outdegree[v] # print(links_out[v]) # print(pair) indegree = v1t_indegree[v_in] length = len(links_out[v][pair][0]) # MVP: shortest path links[pair] = (outdegree+indegree, outdegree, indegree, length, links_out[v][pair]) # print(links[pair]) # print(least) if outdegree < least[1] and indegree < least[2]: least = links[pair] elif outdegree + indegree < least[0]: least = links[pair] elif outdegree + indegree == least[0]: if length < least[3]: # least[length] least = links[pair] elif ((least[1] > 1 and least[2] > 1) and (outdegree is 1 or indegree is 1)): # in and out > 1, but new one is (1,n) least = links[pair] # pprint(links) # pprint(least) return least[4] # all paths in pair def del_v1_pair(v, direction): """Delete v1 pair from out or in.""" if direction is 'out': path_set_sv1.remove(v) del sv1_outdegree[v] if v in links_out: del links_out[v] for v_in in links_in: for key in links_in[v_in]: if key[0] == v and key in links_in[v_in]: del links_in[v_in][key] break # update v_outdegree else: path_set_v1t.remove(v) del v1t_indegree[v] if v in links_in: del links_in[v] for v_out in links_out: for key in links_out[v_out]: if key[1] == v and key in links_out[v_out]: del links_out[v_out][key] break def del_v1v2_pair(v_out, v_in): """Del v1v2 pair. if (2,3) is the new merged pair, then 3->2 is not valid.""" if v_out in links_out: if (v_out, v_in) in links_out[v_out]: del links_out[v_out][(v_out, v_in)] if v_in in links_in: if (v_out, v_in) in links_in[v_in]: del links_in[v_in][(v_out, v_in)] def merge_path(final_path, new_link): """Merge paths.""" global used start, end = new_link[0], new_link[-1] if len(new_link) > 2: # add v not in v1 to used used += new_link[1:-1] # print(final_path, new_link) for i in range(len(final_path)): if final_path[i][-1] == start: del_start = final_path[i] if final_path[i][0] == end: del_end = final_path[i] new_ele = del_start + new_link[1:-1] + del_end final_path.remove(del_start) final_path.remove(del_end) final_path.append(new_ele) new_out = new_ele[-1] new_in = new_ele[0] # print(final_path) return final_path, new_out, new_in def one_move(final_path, first_pairs): if first_pairs: best_path = find_least_pair(links, first_pairs[0]) del first_pairs[0] else: least_paths = find_least_pair(links) # print('least_paths', least_paths) if not least_paths: # no paths return False for best_path in least_paths: if len(best_path) > 2: # if new v not in V' is added to path new_used_v = set(best_path[1:-1]) if verbose: print('new added to v:', new_used_v) for v in new_used_v: del_v_between(v) if not (new_used_v & set(used)): break else: break else: print(least_paths) first_pairs0.append([best_path[0], best_path[-1]]) print(first_pairs0) print('No right path.\n') return False v_out, v_in = best_path[0], best_path[-1] if verbose: print("new merge:", best_path) final_path, new_out, new_in = merge_path(final_path, best_path) del_v1_pair(v_out, 'out') del_v1_pair(v_in, 'in') del_v1v2_pair(new_out, new_in) for v in path_set_sv1: if v in links_out: sv1_outdegree[v] = len(links_out[v]) for v in path_set_v1t: if v in links_in: v1t_indegree[v] = len(links_in[v]) if verbose: print(final_path) input('pause') return True def del_v_between(v): """Delete all paths contains certain vertex. Delete from links_out and links_in. links_out[v_out][(v_out, v_in)] = [new_link_path] """ # pprint(links_out) # print('del v:', v) for v_out in links_out: for link in links_out[v_out]: for path in links_out[v_out][link]: # iterate all available paths if v in path: # print(path, v) links_out[v_out][link].remove(path) for v_in in links_in: for link in links_in[v_in]: for path in links_in[v_in][link]: # iterate all available paths if v in path: # print(path, v) links_in[v_in][link].remove(path) # pprint(links_out) clean_in_out() # pprint(links_out) def clean_in_out(): """Clean links_in and links_out after delete some v.""" for v in links_out: for link in list(links_out[v].keys()): # list(dict.keys()) to safely iterate dict and del keys if not links_out[v][link]: del links_out[v][link] for v in list(links_out.keys()): if not links_out[v]: del links_out[v] for v in links_in: for link in list(links_in[v].keys()): if not links_in[v][link]: del links_in[v][link] for v in list(links_in.keys()): if not links_in[v]: del links_in[v] def generate_seq(v1): """Generate sequence of V'.""" import random v1_copy = v1[:] random.shuffle(v1_copy) return v1_copy # print(generate_seq(v1)) # conten_path(v1) # print(generate_seq(v1)) # print(generate_seq(v1)) # print(generate_seq(v1)) def conten_path(seq_v1): """Generate path(possibly with cycle).""" seq_path = [s] + seq_v1 + [t] seq_path2 = [s] + seq_v1 + [t] seq_v1 = [] path = [s] weight = 0 while len(seq_path) > 1: pair = (seq_path[0], seq_path[1]) try: new_conten = links_out[seq_path[0]][pair][0][1:] except KeyError: new_conten = [-1, seq_path[1]] seq_v1.append([seq_path[0], -1, seq_path[1]]) weight += 10000 # punish no edge else: seq_v1.append([seq_path[0]] + new_conten) weight += cal_path_weight([seq_path[0]] + new_conten) finally: path += new_conten del seq_path[0] # print(new_conten) # print(path) return path, seq_path2, weight def cal_v1_weight(seq_v1): """Generate path(possibly with cycle).""" weight = 0 for i in range(len(seq_v1)-1): weight += distance_v1(seq_v1[i], seq_v1[i+1]) # print(weight) # print(seq_v1, weight) return weight def cal_path_weight(path): """Calculate path weight. - input: path node list. - output: path weight. """ weight = 0 for i in range(len(path) - 1): # as used i+1 weight += G[path[i]][path[i+1]]['weight'] return weight def distance_v1(a, b): """Calculate distance of vi and vj.""" if a == t: if b == s: return 0 else: return 100000 # test for big elif a == s and b == t: return 100000 else: try: new_conten = links_out[a][(a,b)][0][:] except KeyError: return 10000 # punish no path else: return cal_path_weight(new_conten) from pprint import pprint set_v1 = set(v1) set_sv1 = set([s] + v1) # out set_v1t = set(v1 + [t]) # in valid_paths = [] preds = {} # two dict to store values succs = {} links = {} # (vi, vj): [path1, path2, ...] links_out = {} links_in = {} for v in set_sv1: links_out[v] = {} for v in set_v1t: links_in[v] = {} global num_paths, max_weight num_paths = 0 BIG_WEIGHT = 4800 max_weight = BIG_WEIGHT global i_searched # num of paths searched i_searched = 0 print("s:", s, "t:", t, "V':", v1) # printout for debugging INIT_DEPTH = 9 # init depth: 5 works for std case 1, 2, 4 for v in set_sv1: depth = 1 while (not links_out[v]) or (depth < INIT_DEPTH): if get_v_layer(v, depth, 'out'): depth += 1 else: break for v in set_v1t: depth = 1 while (not links_in[v]) or (depth < INIT_DEPTH): if get_v_layer(v, depth, 'in'): depth += 1 else: break sv1_outdegree = {} v1t_indegree = {} for v in set_sv1: sv1_outdegree[v] = len(links_out[v]) # print(v, 'out', len(links_out[v])) for v in set_v1t: v1t_indegree[v] = len(links_in[v]) # print(v, 'in', len(links_in[v])) path_set_sv1 = set_sv1.copy() path_set_v1t = set_v1t.copy() global final_path final_path = [[s], [t]] + [[v] for v in v1] global used used = [] global first_pairs0 first_pairs0 = [] for i in first_pairs: first_pairs0.append(i[:]) pij = {} for v in set_sv1: for v2 in set_v1t: if v2 != v: pair = (v, v2) pij[(v,v2)] = distance_v1(v, v2) # pprint(pij) nodes = [] node_dict = {} for v in [s,t] + v1: nodes.append(v) node_dict[len(nodes)] = v # print(node_dict) world = pants.World(nodes, distance_v1) solver = pants.Solver(start=s, alpha=1, beta=3, limit=100, links_out=links_out) solution = solver.solve(world) # solutions = solver.solutions(world) # print('distance: {}'.format(solution.distance)) # print('tour: {}'.format(solution.tour)) i = 0 def local_DFS(seq, depth=6): """local DFS to reduce weight. 1. generate sequence for local DFS. 2. DFS to find least local weight.""" for i in range(len(seq) - 1): if distance_v1(seq[i], seq[i+1]) >= 10000: # no path between # print(seq[i]) begin = max(0, i-depth) end = min(i+depth, len(seq)) # print('begin {}, end{}'.format(begin,end)) # print(seq[begin:end]) weight0 = cal_v1_weight(seq[begin:end]) # init weight for DFS DFS(seq[begin:end], weight0) def DFS(seq, begin_weight=1000000): print(seq, begin_weight) weight0 = begin_weight best_path = [] stack = deque() stack.append([[seq[0]], 0]) while stack: # is not blank # print(stack) # input() t = stack.popleft() # print(t) path, weight = t[0], t[1] if weight >= weight0: continue if len(path) == len(seq): # come to end print(weight0, weight) weight0 = weight best_path = path for i in seq: # seq of random sequence if i not in path: stack.appendleft((path+[i], weight + distance_v1(path[-1], i))) print(begin_weight, weight0) return best_path def MC_DFS(seq, begin_weight=1000000): print(seq, begin_weight) weight0 = begin_weight best_path = [] stack = deque() stack.append([[seq[0]], 0]) # MC for first layer sequence t = stack.popleft() path, weight = t[0], t[1] if weight >= weight0: continue if len(path) == len(seq): # come to end print(weight0, weight) weight0 = weight best_path = path num_coins = 500 seq = MC_path(seq, num_coins) for i in seq: if i not in path: stack.appendleft((path+[i], weight + distance_v1(path[-1], i))) while stack: t = stack.pop() path, weight = t[0], t[1] if weight >= weight0: continue if len(path) == len(seq): # come to end print(weight0, weight) weight0 = weight best_path = path for i in seq: if i not in path: stack.append((path+[i], weight + distance_v1(path[-1], i))) print(begin_weight, weight0) return best_path def MC_path(seq, num_coins): """MC方法排序DFS, 启发式决定DFS栈中元素的先后顺序.""" paths_for_MC = [] # path 列表, 注意控制总量 weight_paths = [] # weight 列表 for node1 in seq: if distance_v1(s, node1) <= 100000: paths_for_MC.append([s,node1]) weight_paths.append(0) # 初始化, 加入s附近的路径 # print('len of MC ', len(paths_for_MC)) coin_path = num_coins / len(paths_for_MC) # 每个路径的MC次数 for path in paths_for_MC: for i in range(int(coin_path)): try_path = generate_seq(list(set(v1)-set([node1]))) weight = cal_v1_weight(path + try_path + [t]) # 加入pseudo-weight计算 # should add cycle weight in later version # print(path+try_path +[t]) # print(weight) weight_paths[paths_for_MC.index(path)] += weight / int(coin_path) for i in range(len(paths_for_MC)): print(paths_for_MC[i], weight_paths[i]) sorted_paths = [] sorted_index = sorted(weight_paths) for i in range(len(paths_for_MC)): sorted_paths.append(paths_for_MC[weight_paths.index(sorted_index[i])]) # print(sorted_paths) return sorted_paths MC_path(v1, 5000) input() while True: i += 1 seq_v1 = solution.tour j = seq_v1.index(s) seq_v1 = seq_v1[j:] + seq_v1[:j] print('seq of v1:', seq_v1) path, seq, weight = conten_path(seq_v1[1:-1]) print(path, 'weight', weight) if path: if -1 not in path and len(path) == len(set(path)): print('valid path.') return path else: print('not valid') print(path) print(seq) print('gaps:', len(path)-len(set(path))) local_DFS(seq) input() if verbose: # verbose printout print("added route:", i_searched) print("num of paths: {}".format(num_paths)) pprint(valid_paths) if valid_paths: # output return valid_paths, G else: if verbose: print('no path') return "NA"
continue print(pubNodes) # Selection of the first 100 ads on the list maximum = 100 pubNodes2 = pubNodes[0:maximum] # Sorts duplicates pubCoordinate = list(set(pubNodes2)) # Calculating distance with latitude and longitude with gpxpy function def distancePub(a, b): dist = gpxpy.geo.haversine_distance(a[0], b[0], a[1], b[1]) # Solver and World Instanciation world = pants.World(pubCoordinate, distancePub) solver = pants.Solver() # Solution solution = solver.solve(world) # Distance and tour print('Distance = ', solution.distance, 'km') print(solution.tour) # Initialization of the graphical coordinates X = [] Y = [] # Graph function for node in solution.tour:
# In[371]: import pants import math import random # In[372]: def euclidean(a, b): return math.sqrt(pow(a[1] - b[1], 2) + pow(a[0] - b[0], 2)) # In[394]: world = pants.World(l, euclidean, N=150, L=150, A=2, B=3) # In[395]: solver = pants.Solver() # In[396]: solution = solver.solve(world) # or solutions = solver.solutions(world) # In[397]: print(solution.distance)
'LE-PELLERIN Rue du Huit Mai', weight='poids')) def fonction(a, b): dst = math.sqrt(math.pow(a[1] - b[1], 2) + pow(a[0] - b[0], 2)) return dst # création du monde avec les coordonnées des nodes du graph aco-pants nodes = [] for rue in pos: nodes.append((pos[rue][0], pos[rue][1])) monde = pants.World(nodes, fonction) #solutions aco-pants solver = pants.Solver() ########################################## solution = solver.solve(monde) print(solution.distance) print(solution.tour) # Nodes visited in order print(solution.path) # Edges taken in order ###########################################
#Affichage du nombres d'erreurs if invalid_lines >= 1: print("CSV Contains " + str(invalid_lines) + " invalid line(s)") nodes = list(set(nodes)) print('Pubs: ', len(nodes)) def distance(a, b): # get distance in kilometers distance = math.sqrt(pow(a[1] - b[1], 2) + pow(a[0] - b[0], 2)) / 1000 return distance if args.parse_only != True: world = pants.World(nodes, distance) solver = pants.Solver() solutions = solver.solutions(world) bestDistance = -1 for solution in solutions: if (solution.distance < bestDistance or bestDistance < 0): bestDistance = solution.distance bestTour = solution.tour print('Distance parcourue : ' + str(bestDistance) + 'km') xArray = [] yArray = [] for node in bestTour: # split nodes in 2 arrays for matplotlib xArray.append(node[0])
import pants import math import random nodes = [] for _ in range(20): x = random.uniform(-10, 10) y = random.uniform(-10, 10) nodes.append((x, y)) def euclidean(a, b): return math.sqrt(pow(a[1] - b[1], 2) + pow(a[0] - b[0], 2)) world = pants.World(nodes, euclidean) solver = pants.Solver() solution = solver.solve(world) solutions = solver.solutions(world) print(solution.distance) print(solution.tour) # Nodes visited in order print(solution.path) # Edges taken in order # or best = float("inf") for solution in solutions: assert solution.distance < best best = solution.distance
print("Solution length: {}".format(fastest.distance)) print('Shortest way between the first ' + str(numberOfPubsToLookAt) + ' English Pubs (easting/northings) :') print(fastest.distance) print("Found at {} out of {} seconds.".format(fastest_time, total_time)) ### Datas Retrieval from the csv file with open('open_pubs.csv') as csvfile: file = csv.DictReader(csvfile) for row in file: nodesArrayFillUp(row['easting'], row['northing']) # Limit of the dataset for testing and to respect memory limit nodesArray = nodesArray[0:numberOfPubsToLookAt] G.add_nodes_from(nodesArray) ### Solver and World Instanciation world = pants.World(nodesArray, distance) solver = pants.Solver() ### Solution definition solution = solver.solve(world) ##### Solution ##### runACO(nodesArray, numberOfPubsToLookAt) ### Display Graph nx.draw_networkx(G) plt.show()
# criando um grafo direcionado G = nx.DiGraph() # pegando as arestas do dataset edges = data.nova_luz2 for start, end, length in edges: # adicionando as arestas no grafo G.add_edge(start, end, length=length) # pegando uma lista de arestas do grafo edges = list(G.edges) # criando o "mundo" onde serao adicionadas as formigas e solucionando o problema world = pants.World(edges, distancia) solver = pants.Solver() solution = solver.solve(world) # ali na solucao ja temos a sequencia de arestas agora vamos ver exatamente os vertices que serao visitados caminho = list() for edge in solution.path: short = nx.shortest_path(G, edge.start[0], edge.end[0], weight='length') for i in short: if len(caminho) == 0: caminho.append(str(i)) else: if caminho[-1] != str(i): caminho.append(str(i)) print(f'Caminho: {" -> ".join(caminho)}')
with open('open_pubs.csv') as csvfile: reader = csv.DictReader(csvfile) for row in reader: nodes.append((float(row['easting']), float(row['northing']))) nodes = nodes[0:max] #Calcule des distances les plus courtes avec la méthode euclidienne def distance(x, y): dist = math.sqrt(pow(x[1] - y[1], 2) + pow(x[0] - y[0], 2)) return dist #Création du monde monde = pants.World(nodes, distance) solver = pants.Solver() #Résolution du monde solution = solver.solve(monde) columns = "{!s:<25}\t{:<25}" divider = "-" * (25 + 25) header = columns.format("Temps passé", "Distance") columns = columns.replace('<', '>', 1) print() print(header) print(divider) fastest = None
def createWorld(): return pants.World(nodes, calculateDistance)
def main(): # Arguments # parser = argparse.ArgumentParser( description='Pengtai Instagram RNN LSTM Model') parser.add_argument( '-t', '--type', type=str, help="run type Options: 'n' for new | 'o' for overwrite", default='o', nargs='+') # parser.add_argument('-d', '--dest_dir', type=str, help='CSV data file') parser.add_argument('-i', '--input_dir', type=str, help='Input Raw CSV directory') parser.add_argument('-u', '--user_id', type=str, help='Instagram User ID') parser.add_argument('-v', '--version', help='current version', action='store_true') args = parser.parse_args() # End Argparse # # VERSION CONTROL # if args.version: with open(settings.VERSION_JSON, "r") as jsonFile: data = json.load(jsonFile) return print(data['version']) if args.type: if args.type[0] == 'n' and args.type[1]: with open(settings.VERSION_JSON, "r") as jsonFile: data = json.load(jsonFile) data["version"] = args.type[1] with open(settings.VERSION_JSON, "w") as jsonFile: json.dump(data, jsonFile) VERSION = args.type[1] elif args.type[0] == 'o': with open(settings.VERSION_JSON, "r") as jsonFile: data = json.load(jsonFile) VERSION = data["version"] # End VERSION CONTROL # with open('./dic/polarity.csv', 'r', encoding='UTF-8') as file: csvreader = csv.DictReader(file) kosac = [row for row in csvreader] total_arr = [] rowI = 0 rowDict = {} # File List in the directory from the arguments for filename in glob.glob(os.path.join(args.input_dir, '*.csv')): # i = ['id', 'img', 'text', 'has_tag', 'write_date', 'reg_date'] with open(filename, 'r', encoding='UTF-8') as f: csvreader = csv.DictReader(f) # csvreader = csv.reader(f) for row in csvreader: if rowI == 0: rowDict = {"user_id": row['user_id'], "posts": []} else: # print(user_id, row['user_id'], rowDict) if rowDict['user_id'] != row['user_id']: total_arr.append(rowDict) rowDict = {"user_id": row['user_id'], "posts": []} # text preprocess text = re.sub(r'@\w+', '', row['text']) text = re.sub( 'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\(\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', '', text) text = re.sub(r'[\[]|[\]]', '', text) text = re.sub(r'[\r]|[\n]', ' ', text) text = re.sub(r'[.]|[ㆍ]', '', text) text = re.sub(r'#', ' ', text) rowDict['posts'].append({ "datetime": row['write_date'], "text": text }) rowI = rowI + 1 # print(total_arr) trg_res = [item for item in total_arr if item["user_id"] == args.user_id] temp = [] kkma = Kkma() t = Twitter() for post in trg_res[0]['posts']: date = datetime.datetime(int(post['datetime'][0:4]), int(post['datetime'][5:7]), int(post['datetime'][8:10]), int(post['datetime'][11:13]), int(post['datetime'][14:16]), int(post['datetime'][17:19])) text = post['text'] temp.append((date, text)) temp = sorted(temp, key=lambda t: t[0], reverse=False) sentArr = [] newArr = [] tokens_ko = [] index = 0 nounsArr = [] for data in temp: sentPosArr = kkma.pos(data[1]) # sentNouns = kkma.nouns(data[1]) inArr = [] for outA in sentPosArr: # for inA in outA: inArr.append("/".join(outA)) morph_arr = t.morphs(data[1]) morphWords = [word for word in morph_arr if not word in tokens_ko] for word in morphWords: if not word in nounsArr: nounsArr.append(word) tokens_ko.extend(morphWords) newArr.append({"sentence": "", "words": morph_arr, "score": 0}) index = index + 1 sentArr.append(";".join(inArr)) index = 0 for eaSent in sentArr: sentiScore = 0 for corp in kosac: if eaSent.find(corp['ngram']) > -1: if corp['max.value'] == 'NEG': sentiScore = sentiScore - float(corp['max.prop']) elif corp['max.value'] == 'POS': sentiScore = sentiScore + float(corp['max.prop']) newArr[index]["sentence"] = eaSent newArr[index]["score"] = sentiScore index = index + 1 # ACO 알고리즘 # doc_ko = " ".join([row[1] for row in temp]) # text_arr = [row[1] for row in temp] # for text in text_arr: # morph_arr = t.morphs(text) # temp = [word for word in morph_arr if not word in tokens_ko] # tokens_ko.extend(temp) print(tokens_ko) ko = nltk.Text(tokens_ko) # For Python 2, input `name` as u'유니코드' # # print(len(set(ko.tokens))) # returns number of unique tokens vocab = dict([(item[0], index + 1) for index, item in enumerate(ko.vocab().items())]) # pprint(vocab) # returns number of tokens (document length) minTimeVal = int(temp[0][0].timestamp()) maxTimeVal = int(temp[len(temp) - 1][0].timestamp() - minTimeVal) tenPow = len(str(int(temp[len(temp) - 1][0].timestamp() - minTimeVal))) tenPow = pow(10, tenPow) index = 0 nodes = [] for data in temp: # print(data[0].utctimetuple) # print(data[0].time()) diffTimeVal = int(data[0].timestamp() - minTimeVal) opt1 = float(diffTimeVal / tenPow) opt2 = float(diffTimeVal / maxTimeVal) print(diffTimeVal, opt1, opt2) nodes.append((opt2, newArr[index]["words"])) index = index + 1 # print(nounsArr) nodes2 = [] for noun in nounsArr: for corp in kosac: hts = "%s/NNG" % (noun) if hts.find(corp['ngram']) > -1: if corp['max.value'] == 'NEG': nodes2.append({ "noun": noun, "score": -float(corp['max.prop']) }) elif corp['max.value'] == 'POS': nodes2.append({ "noun": noun, "score": float(corp['max.prop']) }) print() antCount = len(newArr) rhoVal = 0.3 # ACO 알고리즘 예시 # nodes = [] # for _ in range(20): # x = random.uniform(-10, 10) # y = random.uniform(-10, 10) # nodes.append((x, y)) # def euclidean(a, b): return math.sqrt(pow(a[1] - b[1], 2) + pow(a[0] - b[0], 2)) # world = pants.World(nodes, euclidean) # solver = pants.Solver(rho=rhoVal, )
def idx(x): for i in range(len(nodes)): if (nodes[i][0] == x): return (nodes[i][4], -nodes[i][5]) # In[694]: dep1 = [] #dep1.append(cordinates(117)) for i in range(len(arr1)): dep1.append(cordinates(arr1[i])) #Using AOC pants world = pants.World(dep1, euclidean) solver = pants.Solver() solution = solver.solve(world) #print(solution.distance) depA1 = solution.tour # Nodes visited in order #print(solution.path) # Edges taken in order #print(cordinates(117)) #print(depA1) idx(depA1[0][0]) cap.clear() cap.append(117) for i in range(len(depA1)): cap.append(idx(depA1[i][0])) cap.append(117)
tab_nom = network.get_edge_attributes( Graph, 'label') #On récupère les labels des arêtes for x in tab_nom: print(tab_nom[x], tab_poids[x] ) #On affiche le nom et le poids de chaque rue network.draw_networkx_edges(Graph, pos) # On récupère les traits du schéma network.draw_networkx_labels(Graph, pos) #On récupère les noms network.draw_networkx_edge_labels(Graph, pos) #On récupère les noms sur les arêtes network.draw_networkx_nodes(Graph, pos) #On récupère les points rouge pyp.show() noeuds = [] choix = r.randint(1, 10) for i in range(choix): x = r.uniform(0, 10) y = r.uniform(0, 10) noeuds.append([x, y]) ensemble = p.World(noeuds, function) solver = p.Solver() solutions = solver.solutions(ensemble) for solution in solutions: print(solution.distance) print(noeuds)
:return: la distance entre les coordonées :rtype: int """ def calcul_distance(a, b): rayon = 6378 x = (b[1] - a[1]) * math.cos(0.5 * (b[0] + a[0])) y = b[0] - a[0] distance = rayon * math.sqrt(x * x + y * y) return distance G = networkx.Graph() monde = pants.World(pop, calcul_distance) solver = pants.Solver() solution = solver.solve(monde) """ Limitation des données """ for i in range(iteration): pop = noeuds[i * nombre_bars:(i + 1) * nombre_bars] pop = set(pop) pop = list(pop) G.clear() distances.append(solution.calcul_distance) G.add_edges_from([(edge.start, edge.end) for edge in solution.path]) plt.clf() plt.pause(1)
position = '' #ITERRATING csv rows with open('./nantes-street.csv', 'rt') as csvfile: file = csv.reader(csvfile, delimiter=',', quotechar='|') for row in file: biMin = clearString(row[8]) biMax = clearString(row[10]) bpMin = clearString(row[9]) bpMax = clearString(row[11]) tenant = clearString(row[6]) aboutissant = clearString(row[7]) label = clearString(row[1]) if biMin != '' and biMax != '' and bpMin != '' and bpMax != '' and tenant != '' and aboutissant != '' and label != '': biWeight = getWeight(biMax, biMin) bpWeight = getWeight(biMax, biMin) weight = getGlobalWeight(biWeight, bpWeight) graph.add_edge(tenant, aboutissant, weight=weight, label=label) position = networkx.spring_layout(graph) points = getPoints(position) #CREATING pants env (world, solver) to finally get the shortest path pantsWorld = pants.World(points, evalFunction) pantsSol = pants.Solver() res = pantsSol.solutions(pantsWorld) shortest = getShortest(res) print('Resultat :') print(shortest)
import pants import math import random nodes = [] for i in range(0, 100): nodes.append((random.uniform(0, 100), random.uniform(0, 100))) print(nodes) def fn(a, b): return math.sqrt(pow(a[1] - b[1], 2) + pow(a[0] - b[0], 2)) monde = pants.World(nodes, fn) solver = pants.Solver() sol = solver.solve(monde)
) # If we find the temporary file, we load it in the nodes list with open('./data/clean.csv', 'r') as csvfile: reader = csv.reader(csvfile, doublequote=True, skipinitialspace=True) for row in reader: vals = (float(row[0]), float(row[1])) nodes.append(vals) nodes = [ node for i, node in enumerate(nodes) if NUMBER_NODES <= 0 or i < NUMBER_NODES ] # We apply the filter ( no need to check for doubles, as this file is generated by the script print("Temp file load finished") #Calculation print("Creating world") world = pants.World( nodes, calcul_distance) # We create the environement for the ant system print("Finished creating world") print("Creating solver") solver = pants.Solver() # We create the solver print("Finished creating solver") print("Starting solving world") solutions = solver.solutions(world) # We generate our solutions best = float("inf") bestSolution = None for currSolution in solutions: # We try to find wich solution has the lower distance in total if currSolution.distance < best: best = currSolution.distance solution = currSolution # We keep the solution