def search(points, neighborhoods, maxNoImprove, maxNoImproveLocalSearch): t_end = time.time() + 60 # First construct the initial solution. We use a random permutation as the initial solution best = {} best["permutation"] = constructInitialSolution(points) best["cost"] = tourCost(best["permutation"]) noImproveCount = 0 while noImproveCount <= maxNoImprove and time.time() < t_end: candidate = {} candidate["permutation"] = best["permutation"] # for each neighborhood in neighborhoods for neighborhood in neighborhoods: #Calculate Neighborhood : Involves running stochastic two opt for neighbor times for index in range(0, neighborhood): # Get candidate solution from neighborhood candidate["permutation"] = stochasticTwoOpt( candidate["permutation"]) # Calculate the cost of the final neighborhood candidate["cost"] = tourCost(candidate["permutation"]) # Refine candidate solution using local search and neighborhood candidate = localSearch(candidate, maxNoImproveLocalSearch, neighborhood) #if the cost of the candidate is lesser than cost of current best then replace #best with current candidate if candidate["cost"] < best["cost"]: best, noImproveCount = candidate, 0 # We also restart the search when we find the local optima # break: this breaks out of the neighborhoods iteration break else: # increment the count as we did not find a local optima noImproveCount += 1 return best
def searchIteration(points,neighborhoods, maxNoImprove, maxNoImproveLocalSearch, timeLimit): t_end = time.time() + timeLimit best_list = [] # Permutação aleatória é usada para a construção da solução inicial. best ={} best["permutation"] = constructInitialSolution(points) best["cost"] = tourCost(best["permutation"]) noImproveCount =0 while noImproveCount<=maxNoImprove and time.time() < t_end: candidate ={} candidate["permutation"] = best["permutation"] # Para cada vizinhança em vizinhanças. for neighborhood in neighborhoods: # Calcular vizinhança: Envolve executar duas opções estocásticas por quantidade de vizinhanças. for index in range(0,neighborhood): # Obter solução canditada de vizinhança. candidate["permutation"] = stochasticTwoOpt(candidate["permutation"]) # Calcular o custo da vizinhança final. candidate["cost"] = tourCost(candidate["permutation"]) # Refinar a solução candidata final usando a busca local e a vizinhança. candidate = localSearch(candidate,maxNoImproveLocalSearch, neighborhood, t_end) # Se o custo da candidata é menor que o custo da melhor solução atual, então substitua a melhor pela candidata. if candidate["cost"] < best["cost"]: best, noImproveCount = candidate, 0 # Quando um ótimo local é encontrado a busca é reiniciada. best_list.append(best["cost"]) # Interrupção da iteração das vizinhanças. break else: # Incremento do contador para informar que um ótimo local não foi encontrado. best_list.append(best["cost"]) noImproveCount +=1 return best_list
def search(points, maxIterations, maxTabu, maxCandidates): t_end = time.time() + 60 # construct a random tour best = {} best["permutation"] = constructInitialSolution(points) best["cost"] = tourCost(best["permutation"]) tabuList = [] while maxIterations > 0 and time.time() < t_end: # Generate candidates using stocahstic 2-opt near current best candidate # Use Tabu list to not revisit previous rewired edges candidates = [] for index in range(0, maxCandidates): candidates.append(generateCandidates(best, tabuList, points)) # Locate the best candidate # sort the list of candidates by cost # since it is an involved sort, we write a function for getting the least cost candidate bestCandidate, bestCandidateEdges = locateBestCandidate(candidates) # compare with current best and update if necessary if bestCandidate["cost"] < best["cost"]: # set current to the best, so thatwe can continue iteration best = bestCandidate # update tabu list for edge in bestCandidateEdges: if len(tabuList) < maxTabu: tabuList.append(edge) maxIterations -= 1 return best
def searchIteration(points, maxIterations, maxTabu, maxCandidates, timeLimit): t_end = time.time() + timeLimit best_list = [] # constrói a solução inical best = {} best["permutation"] = constructInitialSolution(points) best["cost"] = tourCost(best["permutation"]) tabuList = [] while maxIterations > 0 and time.time() < t_end: # Gera candicdatos usando o algoritmo 2-opt de busca local # estocásticamente, perto do melhor candidato dessa iteração. # Usa a lista tabu para não visitar vértices mais de uma vez candidates = [] for index in range(0, maxCandidates): candidates.append(generateCandidates(best, tabuList, points, t_end)) # Procura o melhor candidasto # ordena a lista de cnadicados pelo custo bestCandidate, bestCandidateEdges = locateBestCandidate(candidates) # compara com o melhor candidato e o atualiza se necessário if bestCandidate["cost"] < best["cost"]: # define o candidato atual como melhor best = bestCandidate # atuliza a lista tabu for edge in bestCandidateEdges: if len(tabuList) < maxTabu: tabuList.append(edge) maxIterations -= 1 best_list.append(best["cost"]) return best_list
def generateCandidates(best, tabuList, points): permutation, edges, result = None, None, {} while permutation == None or isTabu(best["permutation"], tabuList): permutation, edges = stochasticTwoOptWithEdges(best["permutation"]) candidate = {} candidate["permutation"] = permutation candidate["cost"] = tourCost(candidate["permutation"]) result["candidate"] = candidate result["edges"] = edges return result
def localSearch(best, maxIter, timeLimit): count = 0 while count < maxIter and time.time() < timeLimit: candidate = {} candidate["permutation"] = stochasticTwoOpt(best["permutation"]) candidate["cost"] = tourCost(candidate["permutation"]) if candidate["cost"] < best["cost"]: best, count = candidate, 0 else: count += 1 return best
def localSearch(best, maxIter, neighborhood, timeLimit): count =0 while count < maxIter and time.time() < timeLimit: candidate ={} candidate["permutation"]=best["permutation"] for index in range(0,neighborhood):# Envolve executar duas opções estocásticas por quantidade de vizinhos. # Obter a solução candidata de vizinhança. candidate["permutation"] = stochasticTwoOpt(candidate["permutation"]) candidate["cost"] = tourCost(candidate["permutation"]) if candidate["cost"] < best["cost"]:# A busca é reiniciada quando um ótimo local é encontrado. best,count = candidate, 0 else: count +=1 return best
def localSearch(best, maxIter, neighborhood): count = 0 while count < maxIter: candidate = {} candidate["permutation"] = best["permutation"] for index in range( 0, neighborhood ): #Involves running stochastic two opt for neighbor times # Get candidate solution from neighborhood candidate["permutation"] = stochasticTwoOpt( candidate["permutation"]) candidate["cost"] = tourCost(candidate["permutation"]) if candidate["cost"] < best[ "cost"]: # We also restart the search when we find the local optima best, count = candidate, 0 else: count += 1 return best
def constructGreedySolution(perm, alpha): candidate = {} # Seleciona um ponto da lista aleatoriamente problemSize = len(perm) candidate["permutation"] = [perm[random.randrange(0, problemSize)]] # Enquanto o tamanho do candidato não for igual ao tamanho da permutação while len(candidate["permutation"]) < problemSize: # Pega todos os pontos, exceto os já presentes na solução candidata candidates = [ item for item in perm if item not in candidate["permutation"] ] # Calcula o custo de adicionar uma característica à solução # A 'feature' ou característica é definida por quão longe os outros pontos estão do último elemento da lista de candidatos costs = [] candidateSize = len(candidate["permutation"]) for item in candidates: costs.append( euclideanDistance(candidate["permutation"][candidateSize - 1], item)) # Determina o menor e o maior custo do determinado set rcl, maxCost, minCost = [], max(costs), min(costs) # Construimos o RCL da seguinte maneira: # Adicionamos o que for menor ou igual ao mínimo + o custo da característica pela fórmula da RCL # Quanto menor a distância aqui, menor o custo final do algoritmo # Custo de cada Feature: for index, cost in enumerate( costs): # Para conseguir o index e o item enquanto faz o loop # IF Fcurrent <= Fmin + alpha * (Fmax-Fmin) THEN if (cost <= minCost + alpha * (maxCost - minCost)): # Adiciona ao RCL rcl.append(candidates[index]) # Seleciona feature aleatório do RCL e adiciona à solução candidate["permutation"].append(rcl[random.randrange(0, len(rcl))]) # Calcula o custo final antes de retornar a solução candidata candidate["cost"] = tourCost(candidate["permutation"]) return candidate