def best_permutation(spectrogram, norm=1):
similarities = get_relative_similarities(spectrogram, norm)
TSPpb = TSP.TSP(points=spectrogram, distances=-similarities)
solution, _ = TSP_MIP_solving.solveIterativeSubtourEliminationGurobi(TSPpb)
permutation = []
#for i in range(len(solution)) :
#print(solution[i])
for j in range(len(solution[0])):
if solution[0][j] == 1:
permutation.append(j)
break
while len(permutation) < len(solution):
#print(permutation)
i = permutation[-1]
for j in range(len(solution[i])):
if solution[i][j] == 1:
permutation.append(j)
break
best_starting_point = permutation[0]
worst_similarity = similarities[permutation[-1]][permutation[0]]
for i in range(len(permutation) - 1):
if similarities[permutation[i]][permutation[i + 1]] < worst_similarity:
best_starting_point = i + 1
worst_similarity = similarities[permutation[i]][permutation[i + 1]]
permutation = permutation[
best_starting_point:] + permutation[:best_starting_point]
return permutation
def __calculate_fitness(self, route_class, generation):
individual_number = route_class.number
route = route_class.route
t = tsp.TSP(route, individual_number, generation)
result = t.cal_total_distanse()
return result
def main():
filePath = os.path.join(os.getcwd(), "hard.txt")
data = Datas.fileData(filePath)
popSize = 100
generations = 500
tsp = TSP.TSP(data, popSize)
tsp.createPop()
globalC = None
localC = None
generatonCount = 1
while generatonCount < generations:
generatonCount += 1
tsp.newGeneration()
localC = tsp.best()
if globalC is None:
globalC = localC
elif globalC.fitness > localC.fitness:
globalC = localC
print("<------------------->")
print(generatonCount)
print(globalC.fitness)
print(localC.fitness)
Datas.save(globalC)
def findShortestPath(markers, robotID):
tsp = TSP()
# <-- Write a function for calculating the shortest path using the TSP library.
# Use the robotID given to the function to determine which point is the start
# of the path
return path
def generate_path(cluster, algorithm='greedy', it=100, lifeCount=20):
t = TSP()
t.cluster = cluster
t.it = it
t.lifeCount = lifeCount
path, diss = t.cal_cluster_path(algorithm=algorithm)
path_position = []
for i in range(len(cluster)):
path_position.append(cluster[path[i]])
return path, path_position, diss
def __init__(self, gamma=0.99):
super(TSPSolver_SA, self).__init__()
self.tsp = TSP.TSP()
self.cur_state = None # state = [1,3,5,2,4], that is the traveling node order.
self.cur_score = None
self.temperature = 1.0
self.stop_temperature = 0.0001
self.gamma = gamma
self.iter_per_temp = 100
return
def main():
tsp = TSP.TSP()
# Creat a list of cities
cities = [
City.City("1", "20833.3333", "17100.0000"),
City.City("2", "20900.0000", "17066.6667"),
City.City("3", "21300.0000", "13016.6667")
]
tsp.plot_cities(cities)
pdb.set_trace()
def main():
print("hello home")
tsp = TSP(0)
tsp.readFromFile()
globalBest = 5000
globalAvg = 0
N = 10
M = 50
for i in range(10):
best, avg = tsp.run(N, M)
if (best < globalBest):
globalBest = best
globalAvg = globalAvg + avg
print("results: ", globalBest, " ", globalAvg / 10)
def main():
'''
Definicao inicial de um vetor de heuristicas
Definicao das matrizes [vizinhos] [distancia]--> uma para cada cidade
Definicao de um vetor com os nomes das cidades
'''
cityNames,heuristicValues,cityANeighbors,cityBNeighbors,cityCNeighbors= configureValues()
cityArray=[]
counter=0
for i in range(4):
counter=0
city= None
if i == 0:
city=createCity(cityNames[i],cityANeighbors,heuristicValues[i])
elif i==1:
city=createCity(cityNames[i], cityBNeighbors, heuristicValues[i])
elif i==2:
city=createCity(cityNames[i], cityCNeighbors, heuristicValues[i])
elif i==3:
city=createCity(cityNames[i], [], heuristicValues[i])
else:
counter=1
if counter==0:
cityArray.append(city)
for i in range(4):
print(cityArray[i])
'''
Criacao do meu objeto TSP--> representante do problema em questao, agregando as cidades existentes
'''
problema=TSP.TSP(cityArray)
'''
Implementacao do método do Trepa Colinas
'''
hillClimb=HillClimbing.HillClimbing(problema)
bestCost,percurso=hillClimb.hillClimbing('A')
print(bestCost,percurso)
def main():
parser = argparse.ArgumentParser(description="run a genetic algorithm to solve the travelling salesman problem")
req = parser.add_argument_group("required arguments")
req.add_argument("-i", "--input_file", help="the input .tsp file", required=True)
parser.add_argument("-o", "--output_file", help="optional output file for the bests and averages", default=None)
parser.add_argument("-mx", "--max_gen", help="the maximum number of generations to run for (default=1000)",
type=int, default=1000)
parser.add_argument("-ps", "--pop_size", help="the population size (default=50)", default=50, type=int)
parser.add_argument("-cr", "--cross_rate", help="the crossover rate (default=1.0)", type=float, default=1.0)
parser.add_argument("-mr", "--mut_rate", help="the mutation rate (default=0.1)", type=float, default=0.1)
parser.add_argument("-cm", "--cross_mode", help="the mode of crossover, 0 for uox, 1 for pmx (default=0)",
choices=[0, 1], type=int, default=0)
args = parser.parse_args()
try:
fh = GraphHandler(args.input_file)
except IOError as err:
print(err)
sys.exit(0)
tsp = TSP(fh, args.output_file, args.max_gen, args.pop_size, args.cross_rate, args.mut_rate, args.cross_mode)
tsp.genetic_algorithm()
import TSP
from Algorithms import SwitchTwo, EHBSA, EDA_2OPT_LS
import visualization
import time
# Start timer
# startTime = time.time()
# Get TSP instance
TSPInstance = TSP.TSP()
TSPInstance = TSPInstance.loadProblem("TSP_instances/ulysses22.txt")
# Optmize using EHBSA
# bestSolution, bestDistance = EDA_2OPT_LS.optimize(TSPInstance, 1000, 6, startTime)
# print("Best solution:",bestSolution)
# print("Best distance:",bestDistance)
# # End timer
# endTime = time.time()
# print("Total time:",(time.time()-startTime)//60,":",(time.time()-startTime)%60)
# # Visualize
# visualization.visualize(TSPInstance,bestSolution,bestDistance)
# opt_sol = [x-1 for x in [1,14,13,12,7,6,15,5,11,9,10,19,20,21,16,3,2,17,22,4,18,8]]
# print(opt_sol)
# opt_dist = TSPInstance.tourLength(opt_sol)
# visualization.visualize(TSPInstance,opt_sol,opt_dist)
# # Plot time taken to find best solution as function of number of individuals in population
import matplotlib.pyplot as plt
# -*- coding: utf-8 -*-
import node
import MultiTaskingGA as mul
import sys
sys.path.append(
'C:\\Users\\Laptop NamPhong\\python file\\laboratory\\situation2_wrsn_mfea\\task'
)
import Situation2 as sit
import TSP as tsp
set_of_city = []
f = open("data.txt")
for i in range(21):
b = f.readline()
b = list(b.split("\n"))
c = [float(i) for i in list(b[0].split(" "))]
city = node.Node(c[0], c[1], c[2], c[3], c[4])
set_of_city.append(city)
task1 = sit.Situation2(21)
task2 = tsp.TSP(20, set_of_city)
tasks = []
tasks.append(task1)
tasks.append(task2)
mfea = mul.MultiTasking(tasks, 100, 0.5, 50)
mfea.run(100, set_of_city)
import numpy as np
import random
from TSP import *
from Solution import *
if __name__ == '__main__':
tsp = TSP(10,1,20)
print(tsp.getCouts())
sol = tsp.glouton1()
print(sol.getChemin())
print(sol.getFct())
def __init__(self, newGene):
self.tsp = TSP.TSP("tsp.csv")
self.gene = newGene
self.cost = self.calculateCost(newGene)
import sys import os sys.path.append(os.path.pardir) sys.path.append(os.path.join(os.path.pardir, 'Instances')) import TSP as TSP from Neighborhood import Neighborhoods, varClusterFromMPS from VMNDproc import solver from Cuts import Cut from ConComp import getSubsets ##### The loading of the model and creation of the mps file ##### # The instance is loaded from the MPS File nodes = 60 tspInst = TSP.TSP(nodes) # The model is created and written as a mps file in the folder MIPLIB tspInst.exportMPS() """ The variables are set as x_i_j with i < j, for this is an undirected formulation of TSP. """ # We save the path of the mps file pathTSPInst = tspInst.pathMPS # We shall see ..\MIPLIB\randomTSP60nodes.mps #print(pathTSP) ##### The creation of the Neighborhoods #####
Route_list = [[i for i in range(20)] for j in range(N)]
random.shuffle(Route_list)
for l in Route_list: random.shuffle(l)# シャッフル
# 初期RouteのN個を基に集団生成
population = [Person(Route) for Route in Route_list]# 初期の集団作成
fitness_list = []# min適応度リスト for figure
min_fitness = 10000# 適応度が最も良いもの
fig_num = 0#図の数，名前用
for num_gen in range(max_generation):
print('generation {}'.format(num_gen))
person_num = 0
#個体ごとに適応度計算
for person in population:
if person_num % 6 == 0:
fitness = TSP.TSP(person.Route, True, num_gen, person_num, fig_num, 'graph')
else:
fitness = TSP.TSP(person.Route, False, num_gen, person_num, fig_num, 'graph')
person.fitness = fitness
if min_fitness > fitness:
min_fitness = fitness
min_Route = person.Route
min_num_gen = num_gen
min_person_num = person_num
if person_num % 6 == 0:
# fitness = TSP.TSP(person.Route, True, min_num_gen, person_num, fig_num)
TSP.TSP(min_Route, True, min_num_gen, min_person_num, fig_num, 'graph_best')
fig_num += 1
person_num += 1
f"--Result--\nFitness\nAverage: {ave_fitness}\nMinimum: {min_fitness}"
)
# 次のpopulationを作る
# 選択
new_route_list = []
for i in range(self.N):
new_route_list.append(self.__selection())
self.__set_route(new_route_list) # 新しいRouteオブジェクト生成
self.__crossover() # 巡回路の交叉
self.__mutation() # 突然変異
print()
return route_class_min_fitness.route
if __name__ == '__main__':
n_node = 20 # ノードの数
population_size = 35
max_generation = 5000
GA = GeneticAlgorithm(n_node, population_size, max_generation)
best_route = GA.run_evolve()
# 最終結果 表示
print(best_route)
t = tsp.TSP(best_route, 0, 0)
print(t.cal_total_distanse())
t.plot_route()
import numpy as np
import random
from TSP import *
from Solution import *
import time
if __name__ == '__main__':
tsp = TSP(280, 1, 100)
# print(tsp.getCouts())
# print("*******glouton**********")
# start_time10 = time.time()
# sol = tsp.glouton1(2)
# # print(sol.getChemin())
# print(sol.getFct())
# print("glouton : " + str(time.time() - start_time10))
# print("*******descente*********")
# start_time11 = time.time()
# desc = tsp.descente(2)
# # print(desc.getChemin())
# print(desc.getFct())
# print("descente : " + str(time.time() - start_time11))
# print("******recuit************")
# start_time13 = time.time()
# rec = tsp.recuit(2)
# # print(rec.getChemin())
# print(rec.getFct())
# print("recuit : " + str(time.time() - start_time13))
# print("*******tabouOPT*******")
# start_time1 = time.time()
# tabOPT = tsp.optimizedTabou(2,2)
import numpy as np
import random
from TSP import *
from Solution import *
if __name__ == '__main__':
tsp = TSP(10, 1, 100)
# print(tsp.getCouts())
print()
print("*******glouton**********")
print()
sol = tsp.glouton1(2)
print(sol.getChemin())
print(sol.getFct())
print()
print("*******descente*********")
print()
desc = tsp.descente(2)
print(desc.getChemin())
print(desc.getFct())
print()
print("******recuit************")
print()
rec = tsp.recuitSimule(2, 1000)
print(rec.getChemin())
print(rec.getFct())
print()
print("**********************")
print(tsp.getCouts())
import csv import time from TSP import * num_of_points = 10 MaxIterations = 100 C = 1e-2 M = 10 list_of_coords = [[4, 0], [2, 2], [5, 3], [5, 6], [1, 6], [4, 9], [9, 5]] problem_ = TSP(list_of_coords, num_of_points, MaxIterations, C, M) min_d, fun_evals, probs, dists = problem_.best_tour_SA()
