def optimizeGap(self, maxiteration, OPT): startTime = time.time() lastBest = -1 lastImp = 0 for ite in range(0, maxiteration): for k in range(0, self.parameter_K): tmpSol = Solution(self.graph) start = SOURCE while (len(tmpSol.not_visited) != 0): nextNode = self.get_next_city(tmpSol) tmpSol.add_edge(start, nextNode) start = nextNode self.local_update(tmpSol) if tmpSol.cost < self.best.cost: self.best = tmpSol self.heuristic2opt(self.best) self.global_update(self.best) if (ite + 1) == 1 or (ite + 1) % 100 == 0: print("iteration: " + str(ite + 1)) gapBest = (self.best.cost - OPT) / OPT print("gapBest: " + str(gapBest)) print("without Imp: " + str(ite - lastImp)) curTime = time.time() print("CPU Time: " + str(curTime - startTime)) if self.best.cost != lastBest: lastBest = self.best.cost lastImp = ite
def main(): g = Graph("N10.data") Kruskal.kruskal = Kruskal.Kruskal(g) heap = Q.PriorityQueue() sol = Solution(g) root = Node(SOURCE, sol) heap.put(root) while heap.qsize() > 0: node = heap.get() print("curCost: %d" % node.solution.cost) if len(node.solution.not_visited) == 0: if SOURCE in node.solution.visited: node.solution.printf() return else: child_sol = Solution(node.solution) child_sol.add_edge(node.v, SOURCE) child_node = Node(SOURCE, child_sol) heap.put(child_node) else: node.explore_node(heap)
def explore_node(self, heap): for nVisited in self.solution.not_visited: if nVisited == 0 and len(self.solution.not_visited) > 1: continue solution = Solution(self.solution) solution.add_edge(self.v, nVisited) node = Node(nVisited, solution) heap.put(node)
def explore_node(self, heap): for v in self.solution.not_visited: child_sol = Solution(self.solution) child_sol.add_edge(self.v, v) #child_node = Node(v, child_sol) child_node = Node(v, child_sol, Kruskal.kruskal.getMSTCost(child_sol, SOURCE)) heap.put(child_node)
def explore_node(self, heap): for not_visited in self.solution.not_visited: if not_visited == SOURCE and len(self.solution.not_visited) > 1: continue else: new_solution = Solution(self.solution) new_solution.add_edge(self.v, not_visited) new_node = Node(not_visited, new_solution, heuristic_cost=0) heap.put((new_node.solution.cost, new_node))
def explore_node(self, heap): global NUMBER_NODE_EXPLORED NUMBER_NODE_EXPLORED = NUMBER_NODE_EXPLORED + 1 for node in self.solution.not_visited: if len(self.solution.not_visited) == 1 or node != SOURCE: Sol = Solution(self.solution) v = self.v Sol.add_edge(v, node) nodeToAdd = Node(node, Sol) heap.put(nodeToAdd)
def test_heuristic2opt(): print("testing heuristic 2opt...") aco = ACO(0, 0, 0, 0, 0, 'test') s = Solution(aco.graph) s.add_edge(0, 2) s.add_edge(2, 3) s.add_edge(3, 1) s.add_edge(1, 0) aco.heuristic2opt(s) assert s.cost == 6 print('ok')
def test_heuristic2opt(): print("testing heuristic 2opt...") aco = ACO(0, 0, 0, 0, 0, 'test') s = Solution(aco.graph) s.add_edge(0, 2) s.add_edge(2, 3) s.add_edge(3, 1) s.add_edge(1, 0) s=aco.heuristic2opt(s) #<------------------Changement (s=) # print("Voila le resultat : ",s.cost) assert s.cost == 6 print('ok')
def explore_node(self, heap): for not_visited in self.solution.not_visited: if not_visited == SOURCE and len(self.solution.not_visited) > 1: continue else: new_solution = Solution(self.solution) new_solution.add_edge(self.v, not_visited) import Kruskal Kruskal.kruskal = Kruskal.Kruskal(new_solution.g) heuristic_cost = Kruskal.kruskal.getMSTCost( new_solution, SOURCE) new_node = Node(not_visited, new_solution, heuristic_cost) heap.put((new_node.solution.cost + new_node.heuristic_cost, new_node))
def runACO(self, maxiteration): # Initialiser la meilleure solution globalement trouvee overall_best = Solution(self.graph) overall_best.cost = 9999999999999.0 for iter in range(maxiteration): # Pour chaque iteration # Initialiser la meilleure solution pour cette iteration iter_best = Solution(self.graph) iter_best.cost = 9999999999999.0 # Pour chacune des K fourmis for k in range(self.parameter_K): sk = Solution( self.graph ) # construction de la solution de chaque fourmis # Execution de la recherche locale for step in range( self.graph.N ): # Boucle chaque ville a visiter (il y en a N) current_city = sk.visited[-1] next_city = self.get_next_city( sk) # Trouver la prochaine ville sk.add_edge(current_city, next_city) # Mise a jour locale des pheromones self.local_update(sk) # Mise a jour de la meilleure solution pour cette iteration (iter): if sk.cost < iter_best.cost: iter_best = sk # Ameliorer la meilleure solution a l'aide de 2-Opt self.heuristic2opt(iter_best) # mise a jour globale de la pheromone self.global_update(iter_best) # Mise a jour de la meilleure solution trouvee a date (sur plusieurs iterations) if iter_best.cost < overall_best.cost: overall_best = iter_best #print('*** Meilleure Solution trouvee au cout de : ', overall_best.cost) #print(overall_best.visited) self.best = overall_best return overall_best
def runACO(self, maxiteration): startTime = time.time() for ite in range(0, maxiteration): for k in range(0, self.parameter_K): tmpSol = Solution(self.graph) start = SOURCE while (len(tmpSol.not_visited) != 0): nextNode = self.get_next_city(tmpSol) tmpSol.add_edge(start, nextNode) start = nextNode self.local_update(tmpSol) if tmpSol.cost < self.best.cost: self.best = tmpSol self.heuristic2opt(self.best) self.global_update(self.best) endTime = time.time() return (endTime - startTime)
def test_local_update(): print("testing local update...") phi = 0.5 aco = ACO(0, 0, 0, phi, 0, 'test') s = Solution(aco.graph) aco.pheromone[:, :] = 1 c = copy.copy(aco.pheromone) s.add_edge(0, 2) s.add_edge(2, 3) s.add_edge(3, 1) s.add_edge(1, 0) aco.local_update(s) assert (c != aco.pheromone).sum() == 8 assert abs(aco.pheromone[0, 1] - 0.833) < 1e-3 assert abs(aco.pheromone[0, 2] - 0.833) < 1e-3 assert abs(aco.pheromone[3, 1] - 0.833) < 1e-3 assert abs(aco.pheromone[3, 2] - 0.833) < 1e-3 print('ok')
def test_global_update(): print('testing global update...') rho = 0.1 aco = ACO(0, 0, rho, 0, 0, 'test') s = Solution(aco.graph) s.add_edge(0, 2) s.add_edge(2, 3) s.add_edge(3, 1) s.add_edge(1, 0) aco.pheromone[:, :] = 1 aco.global_update(s) print(aco.pheromone) assert abs(aco.pheromone[0, 3] - 0.9) < 1e-3 assert abs(aco.pheromone[1, 2] - 0.9) < 1e-3 assert abs(aco.pheromone[0, 2] - 0.91) < 1e-3 assert abs(aco.pheromone[2, 3] - 0.91) < 1e-3 assert abs(aco.pheromone[3, 1] - 0.91) < 1e-3 assert abs(aco.pheromone[1, 0] - 0.91) < 1e-3 print('ok')
def explore_node(self, heap, *kruskal): if len(self.solution.not_visited)>1: for n in self.solution.not_visited: if n==SOURCE: continue # il reste encore des sommets à visiter avant de retourner à la source s=Solution(self.solution) s.add_edge(self.v,n) node = Node(n,s) node.heuristic_cost = heuristic(kruskal,node) heap.put(node) else: # il ne reste plus que le noeud source : on l'ajoute avec une heuristique de 0: on a complété la boucle n=self.solution.not_visited[0] s=Solution(self.solution) s.add_edge(self.v,n) node = Node(n, s) node.heuristic_cost = 0 heap.put(node)
def build_sol(self): s = Solution(self.graph) s.not_visited.remove(SOURCE) while (len(s.not_visited) > 0): if (len(s.visited) == 0): actualCity = SOURCE else: actualCity = s.visited[len(s.visited) - 1] # Loop act as a do-while #while True: cityToVisit = self.get_next_city(s) # if cityToVisit != origin or len(s.not_visited) == 1 : # break s.add_edge(int(actualCity), int(cityToVisit)) s.not_visited.append(SOURCE) s.add_edge(int(s.visited[len(s.visited) - 1]), SOURCE) return s
def main(): # Initialisation and input data g = Graph('N17.data') #Graph opt_val = 0 max_iter = 1000 #Max iterations allowed iter = 0 #Iteration indicator tabu = [] town = 0 no_update = 0 heap = Q.PriorityQueue() history = [] # Initial solution: current_sol = Solution(g) for i in range(g.N)[0:-1]: current_sol.add_edge(i, i + 1) current_sol.cost += g.get_edge(g.N - 1, 0).cost best_solution = Solution(current_sol) print("Solution initale: ", current_sol.visited, " Cout = ", current_sol.cost, ' f_Cout = ', eval_sol(current_sol)) # -----Local search loop-------- while current_sol.cost > opt_val and iter <= max_iter: #Find position of current switching town print(' ') print("Solution Courante: ", current_sol.visited, " Cout = ", current_sol.cost) position = current_sol.visited.index(town) print('Ville a changer: ', town, ' A la position = ', position) # Explore and evaluate current solution neighbors del heap heap = Q.PriorityQueue() print('Q vide? : ', heap.empty()) for i in range(len(current_sol.visited)): v = current_sol.visited[i] if v != town and v not in tabu: # explore all possible neighbors neighbor = Solution(current_sol) neighbor.visited = [] for j in range(len(current_sol.visited)): if j != i and j != position: neighbor.visited.append(current_sol.visited[j]) else: if j == position: neighbor.visited.append(v) else: neighbor.visited.append(town) # Evaluate neighbor neighbor.cost = eval_sol(neighbor) heap.put((neighbor.cost, neighbor)) # Add neighbor to the priority queue print(' Neighnor ', i, ' : ', neighbor.visited, ' cost = ', neighbor.cost) # Get best neighbor best_neighbor = heap.get()[1] print(' Meilleur Voisin: ', best_neighbor.visited, ' cost = ', best_neighbor.cost) #Update new current solution if best_neighbor.cost < current_sol.cost: current_sol = Solution(best_neighbor) no_update = 0 if best_neighbor.cost < best_solution.cost: best_solution = Solution(best_neighbor) history.append([time.clock(), iter]) print('NEW BEST SOLUTION !! ', best_solution.visited, 'COST = ', best_solution.cost) else: if no_update < g.N: no_update += 1 print(' No update = ', no_update) else: current_sol = Solution(best_neighbor) no_update = 0 tabu = [town] print('Degradation: ', best_solution.cost, 'TABOU = ', tabu) # Update iteration counter town = (town + 1) % g.N # new switching town iter += 1 # PRINT print(' ') print('---- TERMINÉ ----') print('Meilleure Solution Trouvee: ', best_solution.visited, ' COUT = ', best_solution.cost) print('CPU Time (sec): ', time.clock(), ' Nb Iterations = ', iter) print('Meilleur trouvé à CPU Time (sec): ', history[-1][0], ' Et à nb Iterations = ', history[-1][1])