def solve(algorithm, path): startTime = time.time() bestState, bestCost, initPoint = None, None, None initPoint, capacity, graph, demand, optimalValue, ncars, problemName = getData( path) initState = createShuffledState(graph.keys()) if algorithm == 0: #SA alg = simulatedAnnealing(initState, graph, demand, capacity, initPoint, optimalValue, ncars, 2000, 2000000, 30) bestState, bestCost, initPoint, iteration = alg.simulate() elif algorithm == 1: #tabu alg = tabuSearch(initState, graph, demand, capacity, initPoint, optimalValue, ncars, 2000000, 100, 300, 30) bestState, bestCost, initPoint, iteration = alg.run() elif algorithm == 2: alg = ACO(graph, demand, capacity, initPoint, optimalValue, ncars, 100000, 70, 23) best, runtime, iteration = alg.runAnts() bestState, bestCost = best[0], best[1] elif algorithm == 3: bestState, bestCost, iteration = startGenetic(path) print("Total elapsed time: ", str(time.time() - startTime)) prinSolution(bestState, bestCost, graph, initPoint)
def runSimulatedAnnealingAlgorithm(cities, coolDownRate): print "Simulated Annealing..." resetCitiesToUnvisited(cities) title = "Simulated Annealing Algorithm" startTime = datetime.now() distance, orderedListOfCities = simulatedAnnealing(cities, coolDownRate) endTime = datetime.now() printResultsAndWriteOutput(distance, orderedListOfCities, startTime, endTime, title)
def benchSA(verbose, nsize): ''' Benchmarking variables Nmax = 100 Queens nincr = 5 Queens increment per round ''' nmax = 45 nqincr = 5 iterations = 30 alpha = 0.999 # very low decrease in temperature maxIter = 100000 initTemp = 100000 ''' Simulation Result Structure ''' simResStruct = namedtuple('simResStruct', "Queens ArchivedSolution averageIterations executionTime") print('Benchmarking Simulated Annealing N-Queens') results = [] sa = simulatedAnnealing(False) ''' Run the benchmarking for loop ''' #(x,y) = sa.simulatedAnnealing(steps, alpha, maxIter, initTemp) #s = sa.simulatedAnnealing(10, alpha, 10, initTemp) for steps in range(nqincr, nmax, nqincr): totalT = 0 averageIterations = 0 foundSolution = 0 for i in range(iterations): s = sa.simulatedAnnealing(steps, alpha, maxIter, initTemp) averageIterations += s[0] foundSolution += s[1] totalT += s[2] print(s) # add it foundSolution = foundSolution / iterations averageIterations = averageIterations / iterations totalT = totalT / iterations results.append(simResStruct(steps, foundSolution, averageIterations, totalT)) print(results)
def main(): fileName = input('Enter file name : ') # Used variables pawnAmountBW = {'WHITE': 0, 'BLACK': 0} # number of pawns for each side dataSplitted = [] readFile(fileName, dataSplitted) # parse user's input into array # Algorithms option print("Choose Algorithm By Input The Number :") print("1. Hill Climbing") print("2. Simulated Annealing") print("3. Genetic Algorithm") chosenAlgo = int(input("Choose : ")) while (chosenAlgo > 3 or chosenAlgo < 1): print("Choose The Correct Number Please...") chosenAlgo = int(input("Choose : ")) # Execute the chosen algorithm if (chosenAlgo == 1): state = parseState(dataSplitted, pawnAmountBW) # generate an initial state result = hillClimbing(state, pawnAmountBW) elif (chosenAlgo == 2): temperature = int(input('Temperature: ')) decreaseRate = int(input('Decrease Rate: ')) iteration = int(input('Maximum Iteration: ')) state = parseState(dataSplitted, pawnAmountBW) # generate an initial state result = simulatedAnnealing(state, pawnAmountBW, temperature, decreaseRate, iteration) elif (chosenAlgo == 3): populationAmount = int(input('Number Of Population: ')) limit = int(input('Maximum generation: ')) listOfStates = createListOfStates(dataSplitted, pawnAmountBW, populationAmount) result = geneticAlgorithm(listOfStates, pawnAmountBW, populationAmount, limit) # Print the result attackNum = countAtack( result) # Get the number of attack from the result state printBoard(result) print(attackNum['friend'], end='') print(' ', end='') print(attackNum['enemy'])
def inverseSchedule(t): if t > 100000: return 0 return 1 / (0.001 * t + 1) def reverseInverseSchedule(t): if t > 100000: return 0 return 1 - inverseSchedule(100000 - t) def stepSchedule(t): if t > 100000: return 0 return 1 - (t - t % 10000) / 100000 def sqrtSchedule(t): return sqrt(linearSchedule(t)) def reverseSqrtSchedule(t): if t > 100000: return 0 return 1 - sqrtSchedule(100000 - t) schedules = [linearSchedule, exponentialSchedule, inverseSchedule, reverseInverseSchedule, stepSchedule, sqrtSchedule, reverseSqrtSchedule] if __name__ == '__main__': problem = sa.Problem(11, taylorApproximation_c, taylorApproximation_scale, taylorApproximation, sqrtSchedule, 8) res = sa.simulatedAnnealing(problem) print(res)
visited_list = [] w = W for i in range(n, 0, -1): if res <= 0: break if res == K[i - 1][w]: continue else: visited_list.append(attractions[i - 1]) print(attractions[i - 1].name) res = res - val[i - 1] w = w - wt[i - 1] return visited_list def k_means(self, data, k=3): ''' Runs k means algorithm on data, and returns the clustered data ''' kmeans = KMeans(k) kmeans.fit(data) return kmeans.classification_names center = "40.7304, -73.9921" dataFilter = DataFilter() attractions = dataFilter.query_potential_locations("40.7304", "-73.9921") filtered_attractions = dataFilter.filter_by_popularity(center, attractions) clustered_attractions = dataFilter.cluster_attractions(filtered_attractions, 3) print(type(clustered_attractions[0][0])) print(clustered_attractions) print(simulatedAnnealing.simulatedAnnealing(clustered_attractions, center))
tries = 100; randomSearch.randomSearch(myMatrix, tries); ######################################################################################################################## # # # SIMULATED ANNEALING # # # ######################################################################################################################## #Change values of these variables here below as you want myMatrix = readFromFile("filesFlowShopPermutation/Doc5.txt") alpha = 0.9 L = 100 finalT = 0.001 bestAnnealing = simulatedAnnealing.simulatedAnnealing(alpha, L, finalT, myMatrix) localSearch.firstImprovement(myMatrix, bestAnnealing) ######################################################################################################################## # # # GENETICAL ALGORITHM # # # ######################################################################################################################## #Change values of these variables here below as you want myMatrix = readFromFile("filesFlowShopPermutation/Doc5.txt") #Problem to solve - Important: READ NOTE n = 50 #Size of my population nGen = 20 #Number of generations of my algorithm k = 30 #Size of the tournament
def SASolver(nsize, iterations, verbose): sa = simulatedAnnealing(True) sa.simulatedAnnealing(nsize, 0.999, iterations, iterations*10)
if default == 't': tester.populationBased() # # else: # print("Error, unknown input") ''' SIMULATED ANNEALING ''' if algorithm == '3': default = input("\n If you want to run the algorithm once with the default parameters, type 'd'.\n\n \ For custom parameters, type 'c'. \n\n \ For running the algorithm (with default parameters) on a test-set with 100 random genomes of length 25, type 't' \n\n") if default == 'd': print(simulatedAnnealing(data.mel, data.mir, 1000, score.scoreNeighbours)) elif default == 'c': print("\nDefine the score-function you would like to use.\n\nFor scoreNeighbours, type: 1\nFor scoreNeighboursModifier, type: 2\n") scoreF = input("Type in which score-funtion that you would like the algorithm to use: ") if scoreF == '1': print("\nDefine the interval with which the algorithm allows lesser mutations to pass.\n\nFor an interval of 1000, type: s\nFor an interval of 10.000, type: m\nFor an interval of 100.000, type l\n") failV = input("Type in which interval-size you would like the algorithm to use: ") if failV == 's': print(simulatedAnnealing(data.mel, data.mir, 1000, score.scoreNeighbours)) if failV == 'm': print(simulatedAnnealing(data.mel, data.mir, 10000, score.scoreNeighbours)) if failV == 'l':
if (len(sys.argv) != 3): printUsage() else: # Test InputFunction pathToInputFile = sys.argv[1] coolDownRate = 0.99995 if sys.argv[2] == 'fast': coolDownRate = 0.9995 elif sys.argv[2] == 'normal': coolDownRate = 0.99995 elif sys.argv[2] == 'slow': coolDownRate = 0.999995 else: printUsage() exit() cities = readInput(pathToInputFile) # Print results print "------------------------------------------" startTime = datetime.now() distance, orderedListOfCities = simulatedAnnealing(cities, coolDownRate) endTime = datetime.now() print "Total Running Time: ", str(endTime - startTime) print "Distance: ", distance print "------------------------------------------\n" extension = ".tour-SA-NN-" + sys.argv[2] writeOutput(pathToInputFile, distance, orderedListOfCities, extension)
def saJob(constraintFunc, scale, evalFunc, schedule, trial): problem = simulatedAnnealing.Problem(11, constraintFunc, scale, evalFunc, schedule, trial) simulatedAnnealing.simulatedAnnealing(problem)
from nQueens import queen from simulatedAnnealing import simulatedAnnealing import math def func(i): return 1/(1+i) # Solução para um valor de N de livre escolha, altere abaixo: N = 25 problem = queen(N) schedule = func solution = simulatedAnnealing(problem, schedule) print(solution) for i in range(problem.N): for j in range(problem.N): if j != solution[i]: print(". ", end="") else: print("Q ", end="") print("")
def execute(dcel_i, polygons_i, l, r, maxExecs, minR, maxR, relationship, method, coloursDistribution, static, path, it): dcel = dcel_i polygons = polygons_i #n n = len(dcel.faces) #initial symmetric difference sd = symmetricDifference.symDif(dcel.faces, polygons, dcel.box) #initial energy (global) #T inicial tIni = math.fabs(1 / math.log10(sd)) #T final tFin = tIni / (100 * math.log10(n)) ################################# SELECTOR ################################## #Execution switch if (relationship == "classic"): bestPSet, bestSD, bestsDs, sDs, temps, its, acceptance = simulatedAnnealing.simulatedAnnealing( dcel, r, tIni, tFin, l, n, minR, maxR) elif (relationship == "peers"): if (method == "and"): bestPSet, bestSD, bestsDs, sDs, temps, its, acceptance = simulatedAnnealingPeers.simulatedAnnealingPeers_AndMethod( dcel, r, tIni, tFin, l, n, minR, maxR) elif (method == "or"): bestPSet, bestSD, bestsDs, sDs, temps, its, acceptance = simulatedAnnealingPeers.simulatedAnnealingPeers_OrMethod( dcel, r, tIni, tFin, l, n, minR, maxR) elif (method == "numbers"): bestPSet, bestSD, bestsDs, sDs, temps, its, acceptance = simulatedAnnealingPeers.simulatedAnnealingPeers_NumbersMethod( dcel, r, tIni, tFin, l, n, minR, maxR) else: print("error_peers") elif (relationship == "groups"): if (method == "and"): bestPSet, bestSD, bestsDs, sDs, temps, its, acceptance = simulatedAnnealingGroups.simulatedAnnealingGroups_AndMethod( dcel, r, tIni, tFin, l, n, minR, maxR) elif (method == "or"): bestPSet, bestSD, bestsDs, sDs, temps, its, acceptance = simulatedAnnealingGroups.simulatedAnnealingGroups_OrMethod( dcel, r, tIni, tFin, l, n, minR, maxR) elif (method == "numbers"): bestPSet, bestSD, bestsDs, sDs, temps, its, acceptance = simulatedAnnealingGroups.simulatedAnnealingGroups_NumbersMethod( dcel, r, tIni, tFin, l, n, minR, maxR) else: print("error_groups") elif (relationship == "colours"): if (method == "and"): bestPSet, bestSD, bestsDs, sDs, temps, its, acceptance = simulatedAnnealingColours.simulatedAnnealingColours_AndMethod( dcel, r, tIni, tFin, l, n, minR, maxR, coloursDistribution, static) elif (method == "or"): bestPSet, bestSD, bestsDs, sDs, temps, its, acceptance = simulatedAnnealingColours.simulatedAnnealingColours_OrMethod( dcel, r, tIni, tFin, l, n, minR, maxR, coloursDistribution, static) elif (method == "numbers"): bestPSet, bestSD, bestsDs, sDs, temps, its, acceptance = simulatedAnnealingColours.simulatedAnnealingColours_NumbersMethod( dcel, r, tIni, tFin, l, n, minR, maxR, coloursDistribution, static) else: print("error_colours") else: print("error") #managing name change = "" if (relationship != ""): relationship = ' - ' + relationship if (method != ""): method = ' - ' + method if (coloursDistribution != ""): coloursDistribution = ' - ' + coloursDistribution if (static): change = "- static" else: change = "- dynamic" #Final plot plottingModule.plt.figure(6 + it) bestPVor = Voronoi(bestPSet) polygonsPBest = finiteVoronoi.vorFiniteDelPolygonsList(bestPVor, dcel.box) plottingModule.plotDcel(dcel, 'k') plottingModule.plt.suptitle('l: ' + repr(l) + ' - r: ' + repr(r)) plottingModule.plt.title('SA' + relationship + method + coloursDistribution + change + " - best SD: " + repr(bestSD)) plottingModule.plotPolys(polygonsPBest, 'g') plottingModule.plotPoints(bestPSet, '-ob') #plottingModule.plt.savefig(path + repr(bestSD) + '.jpg') return bestPSet, bestSD, bestsDs, sDs, temps, its, acceptance