def read_tsp_network(path): network = {} graph = tsp.load_problem(path).get_graph() network["number_of_cities"] = len(graph.nodes()) network["matrix"] = nx.to_numpy_matrix(graph) return network
def branchandbound(filename, tlim): problem = tsplib95.load_problem("benchmarks/" + filename) print("-------------------") print("Group : Devys, Dugeon, Guyard, Hourman, Prejean") print("Problem :", problem.comment) print("-------------------") ( status, optimal_value, optimal_path, solving_time, nodes_explored, relax_solved, ) = solve(problem, tlim) print("-------------------") print("Problem :", problem.comment) print("Number of cities :", len(list(problem.get_nodes()))) print("Method : Branch and Bound") print("Status :", status) if status == "Optimal": print("Optimal value :", round(optimal_value)) print("Optimal tour :", optimal_path) print("Solving time :", solving_time) print("Nodes explored :", nodes_explored) print("Resolved relaxations :", relax_solved) print("-------------------")
def __init__(self, problem_path, prng_type=LEHMER_0): # Problem instance self.problem = tsplib95.load_problem(problem_path) # Graph of nodes G = self.problem.get_graph() # Cost (distance/duration) matrix self.M = np.array(nx.to_numpy_matrix(G)) # Depot index if len(self.problem.depots) > 1: raise Exception( "This solver can only work with one depot problems. Please make sure that the problem only has one depot." ) self.DI = self.problem.depots[0] - 1 # Capacity constraint of vehicles self.CAPACITY = self.problem.capacity # Demands of jobs self.DEMANDS = [v for k, v in self.problem.demands.items()] # The savings list S = self._construct_savings_list(self.M) # Sorted saving list self.S = S[(-S[:, 2]).argsort()] # Random number generator type self.prng_type = prng_type
def __init__(self, **kwargs): """Initializes a new instance of the `ACOProblem` class. Arguments: \r `ant_number` -- Number of ants used for solving Keyword arguments: \r `tsp_file` -- Path of the tsp file that shall be loaded \r `rho` -- Evaporation rate (default 0.5) \r `alpha` -- Relative importance of the pheromone (default 0.5) \r `beta` -- Relative importance of the heuristic information (default 0.5) \r `q` -- Constant Q. Used to calculate the pheromone, laid down on an edge (default 1) \r `iterations` -- Number of iterations to execute (default 10) \r `plot_interval` -- Plot intermediate result after this amount of iterations (default 10) \r `two_opt` -- Additionally use 2-opt local search after each iteration (default true) """ self.__ant_number = kwargs['ant_number'] # Number of ants tsp_file = kwargs.get('tsp_file', path.join(path.abspath(path.dirname(inspect.getfile(inspect.currentframe()))), 'resources/burma14.tsp')) self.__graph = Graph(tsplib95.load_problem(tsp_file)) LOGGER.info('Loaded tsp problem="%s"', tsp_file) self.__rho = kwargs.get('rho', 0.5) # evaporation rate self.__alpha = kwargs.get('alpha', 0.5) # used for edge detection self.__beta = kwargs.get('beta', 0.5) # used for edge detection self.__Q = kwargs.get('q', 1) # Hyperparameter Q self.__num_iterations = kwargs.get('iteration_number', 10) # Number of iterations self.__use_2_opt = kwargs.get('two_opt', False) self.__visualizer = Visualizer(**kwargs)
def __init__(self, problem_path, prng_type=LEHMER_0): # Problem instance self.problem = tsplib95.load_problem(problem_path) # Graph of nodes self.G = self.problem.get_graph() # Cost (distance/duration) matrix self.M = np.array(nx.to_numpy_matrix(self.G)) # Depot index self.DI = self.problem.depots[0] - 1 # Capacity constraint of vehicles self.CAPACITY = self.problem.capacity # Demands of jobs self.DEMANDS = [v for k, v in self.problem.demands.items()] # The saving list S = self.get_saving_list(self.M) # Sorted saving list self.S = S[(-S[:, 2]).argsort()] # Random number generator type self.prng_type = prng_type
def tsp(genome): tsp_path = 'TSP/bays29.tsp' tsp_problem = tsplib95.load_problem(tsp_path) count = 0 for i in range(len(genome) - 1): count += tsp_problem.wfunc(genome[i] + 1, genome[i + 1] + 1) return count + tsp_problem.wfunc(genome[-1] + 1, genome[0] + 1)
def solveTSPLib(fname, exact=True, logFile=None): """ Solve a TSPLIB instance stored in file "fname" by means of Concorde's TSP solver. Parameters: fname : str Name (including) the path to the data file (format TSPLIB). exact : bool If true (default) it is tried to solve the instance exactly by means of Concorde's branch-and-cut solver; otherwise Concorde only applies the Lin-Kernighan heuristic. logFile : str If not None, it need to be the name of file, where to redirect output from Concorde. Returns: routeLen : int Length of the route (routeLen). route : list of int Computed route (route[0] is the depot and route[-1] is the last customer). """ if __CC_Lib is None: print("Concorde Library not loaded!") return 0, [] else: # We first create a pointer to an integer array problem = load_problem(fname) tour = np.zeros(problem.dimension, dtype=ctypes.c_int) iptr = ctypes.POINTER(ctypes.c_int) ptour = tour.ctypes.data_as(iptr) # Redirect output from Concorde? if logFile is None: logPtr = ctypes.c_char_p(0) else: logPtr = ctypes.c_char_p(logFile.encode('utf-8')) old_out = sys.stdout # Initialize other parameters of c-function solve_TSLPlib seed = ctypes.c_int(int(time.time())) status = ctypes.c_int(0) tiLim = ctypes.c_double(0.0) n = ctypes.c_int(0) fnmeptr = ctypes.c_char_p(fname.encode('utf-8')) LKonly = ctypes.c_char(1 - int(exact)) __CC_Lib.solve_TSPlib.restype = ctypes.c_double tLen = __CC_Lib.solve_TSPlib( LKonly, fnmeptr, seed, tiLim,\ logPtr, ptour, ctypes.byref(status) ) routeLen = tLen nodeLst = [node for node in problem.get_nodes()] route = [nodeLst[i] for i in tour] # Following is safer when on Windows if not logFile is None: sys.stdout = old_out return routeLen, route
def read_tsp_file(file_name_input): tsp_problem = tsp.load_problem(file_name_input) G = tsp_problem.get_graph() n = len(G.nodes()) network = {} network['number_of_nodes'] = n matrix = nx.to_numpy_matrix(G) network['matrix'] = matrix return network
def readTSP(file_name_input): tsp_problem = tsp.load_problem(file_name_input) G = tsp_problem.get_graph() n = len(G.nodes()) net = {} net['noNodes'] = n matrix = nx.to_numpy_matrix(G) net['mat'] = matrix return net
def WczytajProblem(sciezkaDoPliku): import tsplib95 import numpy as np problem = tsplib95.load_problem(sciezkaDoPliku) lista = list(problem.get_edges()) #problem.wfunc(1,2) tab = [] for x, y in lista: tab.append(problem.wfunc(x, y)) tab2 = np.array(tab) return tab2.reshape(x, y)
def solve_aco_tsp(resPath): print(resPath) solver = acopy.Solver(rho=.03, q=.5) colony = acopy.Colony(alpha=1, beta=3) problem = tsplib95.load_problem(resPath) G = problem.get_graph() tour = solver.solve(G, colony, limit=100) return tour
def __readData(self): data = tsplib95.load_problem(self.__filename) #networkx graph graph = data.get_graph() noNodes = graph.number_of_nodes() #numpy distance matrix matrix = networkx.to_numpy_matrix(graph) params = {} params["noNodes"] = noNodes params["matrix"] = matrix return params
def load_instance(self, name: str) -> None: problem: Problem = load_problem(Instance.PATH.format(name)) coords: OrderedDict = problem.node_coords d = problem.dimension self.adjacency_matrix = np.zeros(shape=(d, d), dtype=np.int) for i in range(d): for j in range(d): self.adjacency_matrix[i, j] = euclidean(coords[i + 1], coords[j + 1]) self.city_coords: np.ndarray = np.array(list(coords.values()))
def load_instance_tsplib(path): problem = load_problem(path) coords = problem.node_coords d = problem.dimension dimension_matrix = np.zeros(shape=(d, d), dtype=np.int) for i in range(d): for j in range(d): dimension_matrix[i, j] = int( round(euclidean(coords[i + 1], coords[j + 1]))) final_coords = np.array(list(coords.values())) return final_coords, dimension_matrix
def init(): global problem global dimension # 载入TSP问题数据(load_problem 需要指定一个 distance function) problem = tsplib95.load_problem("../tc/d198.tsp", special=cal_distance) # 初始化变量 dimension = problem.dimension generate_matrix() init_popu() print("初始路径长度:{0}".format(distances)) # 打开交互模式,非阻塞画图 plt.figure(figsize=(8, 6), dpi=80) plt.ion()
def run(memetic): # Set the seed random.seed(seed) # Receive the problem problem = tsplib95.load_problem("data/" + instance) nr_of_nodes = len(list(problem.get_nodes())) # Create the problem in DEAP creator.create("FitnessMin", base.Fitness, weights=(-1.0, )) creator.create("Individual", list, fitness=creator.FitnessMin) toolbox = base.Toolbox() toolbox.register("indices", random.sample, range(nr_of_nodes), nr_of_nodes) toolbox.register("individual", tools.initIterate, creator.Individual, toolbox.indices) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("evaluate", path_length, data=problem) toolbox.register("mate", tools.cxOrdered) toolbox.register("mutate", reverse_sequence_mutation, memetic=memetic, data=problem, icls=creator.Individual) toolbox.register("select", tools.selTournament, tournsize=2) stats = tools.Statistics(lambda ind: ind.fitness.values) stats.register("avg", numpy.mean) stats.register("min", numpy.min) pop = toolbox.population(n=300) start_time = time.time() pop, out = algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=1, ngen=100, stats=stats) print("Memetic: %r" % memetic) print("Execution time: %s seconds" % (time.time() - start_time)) return out
def main(): def euclidean_float(a, b): x1, y1 = a x2, y2 = b dist = math.sqrt((x1 - x2)**2 + (y1 - y2)**2) return dist Q = 1 rho = 0.8 alfa = 1 beta = 4 n_iter_max = 50 best_ant = Ant(None, alfa, beta) best_ant.path_dist = 99999999 n_exec = 0 n_exec_max = 1 problem = tsplib95.load_problem('st70.tsp', special=euclidean_float) while (n_exec < n_exec_max): print("Execution number: ", n_exec) graph = problem.get_graph() n_ants = graph.number_of_nodes() for e in graph.edges: graph[e[0]][e[1]]['feromonio'] = 1 n_iter = 0 while (n_iter < n_iter_max): ants_list = [Ant(graph, alfa, beta) for x in range(n_ants)] for a in ants_list: a.find_path(graph) for e in graph.edges: graph[e[0]][e[1]]['feromonio'] *= (1 - rho) for a in ants_list: for e in a.edges: graph[e[0]][e[1]]['feromonio'] += Q / a.path_dist best_ant_aux = sorted(ants_list, key=lambda a: a.path_dist)[0] if (best_ant_aux.path_dist < best_ant.path_dist): best_ant = best_ant_aux print("Improved") n_iter = n_iter + 1 n_exec += 1 print("Best result: ", best_ant)
def readFileHard(filename): network = {} tsp_file = tsp.load_problem(filename) g = tsp_file.get_graph() nrCities = len(g.nodes()) network['nrCities'] = nrCities matrix = nx.to_numpy_matrix(g) graph = [] for i in range(nrCities): graph.append([]) for j in range(nrCities): value = matrix.item((i, j)) if value == 0: value += 1 graph[i].append(value) print(nrCities) print(graph) network['mat'] = graph return network
def __init__(self, tsp_file, ant_number, rho=0.5, alpha=0.5, beta=0.5, q=1, iterations=100, plot_interval=10, two_opt=True): """Initializes a new instance of the `ACOProblem` class. Arguments: \r `tsp_file` -- Path of the tsp file that shall be loaded \r `ant_number` -- Number of ants used for solving Keyword arguments: \r `rho` -- Evaporation rate (default 0.5) \r `alpha` -- Relative importance of the pheromone (default 0.5) \r `beta` -- Relative importance of the heuristic information (default 0.5) \r `q` -- Constant Q. Used to calculate the pheromone, laid down on an edge (default 1) \r `iterations` -- Number of iterations to execute (default 100) \r `plot_interval` -- Plot intermediate result after this amount of iterations (default 10) \r `two_opt` -- Additionally use 2-opt local search after each iteration (default true) """ self.__graph = Graph(tsplib95.load_problem(tsp_file)) LOGGER.info('Loaded tsp problem="%s"', tsp_file) self.rho = rho # evaporation rate self.alpha = alpha # used for edge detection self.beta = beta # used for edge detection self.Q = q # Hyperparameter Q self.ant_number = ant_number # Number of ants self.num_iterations = iterations # Number of iterations self.plot_iter = plot_interval # plot intervall self.__stop_event = Event() # Event used to stop the plotting thread self.__result_queue = Queue() self.__last_result = None self.best_path = None self.shortest_distance = None self.__use_2_opt = two_opt
def cuttingplanes(filename, tlim): problem = tsplib95.load_problem("benchmarks/" + filename) print("-------------------") print("Group : Devys, Dugeon, Guyard, Hourman, Prejean") print("Problem :", problem.comment) print("-------------------") status, optimal_value, optimal_path, solving_time, cuts_added = solve( problem, tlim) print("-------------------") print("Problem :", problem.comment) print("Number of cities :", len(list(problem.get_nodes()))) print("Method : Cutting planes") print("Status :", status) if status == "Optimal": print("Optimal value :", round(optimal_value)) print("Optimal tour :", optimal_path[0]) print("Solving time :", solving_time) print("Cuts added :", cuts_added) print("-------------------")
return path(graph, nodes_visited, edges_visited, path_nodes + [i]) # ------------------------------------------------------------------------------------------------- # Loading a TSP problem #------------------------------------------------------------------------------------------------------- # Work on berlin52: #---------------------------------------------------------------------------------------------------- # problem = tsplib95.load_problem('./TSPData/berlin52.tsp') #---------------------------------------------------------------------------------------------------- # Work on berlin10: #---------------------------------------------------------------------------------------------------- problem = tsplib95.load_problem('./TSPData/berlin10.tsp') #---------------------------------------------------------------------------------------------------- # Work on a280 : #---------------------------------------------------------------------------------------------------- # problem = tsplib95.load_problem('./TSPData/a280.tsp') #----------------------------------------------------------------------------------------------------- # Solution TSP #------------------------------------------------------------------------------------------------------ orig_graph = TSPlib_to_networkx(problem) tsp_solution, edges_d = TSP_from_MST(orig_graph) print(problem.name) print(problem.type)
import os from logging import getLogger, StreamHandler, DEBUG import acopy import kiacopy import tsplib95 from kiacopy.parameter import Parameter logger = getLogger() logger.addHandler(StreamHandler()) logger.setLevel(DEBUG) graph_name: str = 'gr17.tsp' problem = tsplib95.load_problem(graph_name) G = problem.get_graph() solver = acopy.Solver() colony = acopy.Colony() solver.solve(G, colony, limit=300) config_path = os.path.join(os.path.dirname(__file__), 'config', 'normal.yaml') parameter: Parameter = Parameter.create(config_path) solver = kiacopy.Solver(parameter=parameter) recorder = kiacopy.plugins.StatsRecorder('results') plotter = kiacopy.utils.plot.Plotter(stats=recorder.stats) # drawer = kiacopy.plugins.DrawGraph(problem=problem, is_each=True, is_label=True, is_consecutive=True) converter = kiacopy.plugins.ConvertStateToJson(save_path='results') solver.add_plugins(recorder, converter)
import mysql.connector import tsplib95 import tsp import sys connection = mysql.connector.connect(host='mysql.ict.griffith.edu.au', user='******', password='******', database='s5057468db') mycursor = connection.cursor() prob = tsplib95.load_problem(sys.argv[1] + ".tsp") if sys.argv[2] == "ADD": dim = prob.dimension print(dim) tour = list(range(0, dim + 1)) #print(prob.get_display(tour[0])[i]) sql = "INSERT IGNORE INTO problem (name, dimention, description) VALUES (%s, %s, %s)" #WHERE NOT EXISTS (SELECT name FROM problem WHERE name = %s) val = (sys.argv[1], dim, "NULL") try: mycursor.execute(sql, val) except: print("error occured") #add all cities to city table for i in range(1, dim + 1):
#! /usr/bin/env python # -*- coding: utf-8 -*- # vim:fenc=utf-8 # # Copyright © 2019 haroldo <haroldo@viper> # # Distributed under terms of the MIT license. from sys import argv from os.path import basename import tsplib95 as tsp_data P = tsp_data.load_problem(argv[1]) iname = basename(argv[1]) if iname.endswith('.tsp'): iname = iname.split('.tsp')[0] N = set([i for i in P.get_nodes()]) fo = open('%s.dist' % iname, 'w') for i in N: for j in N: fo.write('%d\n' % P.wfunc(i, j)) fo.close()
def read_tsp_file(self): tsp_problem = tsp.load_problem(self.__filename + ".txt") G = tsp_problem.get_graph() n = len(G.nodes()) matrix = nx.to_numpy_matrix(G) return (n, matrix)
cut = xsum(1.0 * v for v, fm in arcsInS) <= len(S) - 1 cp.add(cut) if len(cp.cuts) > 256: for cut in cp.cuts: model.add_cut(cut) return for cut in cp.cuts: model.add_cut(cut) return if len(argv) <= 1: print('enter instance name.') exit(1) inst = tsplib95.load_problem(argv[1]) N = [n for n in inst.get_nodes()] n = len(N) A = dict() for (i, j) in inst.get_edges(): if i != j: A[(i, j)] = inst.wfunc(i, j) # set of edges leaving a node OUT = defaultdict(set) # set of edges entering a node IN = defaultdict(set) # an arbitrary initial point n0 = min(i for i in N)
import tsplib95 from functions import distance_on_unit_sphere from plotSprawko import plot problem = tsplib95.load_problem('./data/ulysses16.tsp', distance_on_unit_sphere) problem.special = distance_on_unit_sphere G = problem.get_graph() points: list = [] for i in range(1, G.number_of_nodes() + 1): points.append(G.nodes[i].get('coord')) path = [3, 2, 4, 8, 1, 16, 14, 13, 12, 7, 6, 15, 5, 11, 9, 10] plot(points, path) ############################################################ problem = tsplib95.load_problem('./data/att48.tsp') G = problem.get_graph() points: list = [] for i in range(1, G.number_of_nodes() + 1): points.append(G.nodes[i].get('coord')) path = [ 17, 19, 37, 6, 27, 43, 30, 28, 7, 18, 36, 44, 31, 38, 9, 1, 8, 40, 15, 33, 46, 12, 11, 23, 13, 25, 14, 34, 3, 22, 16, 41, 29, 2, 26, 4, 35, 45, 24, 10, 42, 48, 5, 39, 32, 21, 47, 20
def load_problem(self): if self._problem is None: self._problem = tsp.load_problem(self.inp_abs_path) return self._problem
def load_instance(path): """ :param path: :return: """ return load_problem(path)
#plt.figure(figsize=figsize) plt.title(title) plt.savefig(savename) plt.cla() if __name__ == "__main__": DATA_PATH = Path("data") assert DATA_PATH.exists() NAME = "berlin52" NAME = "ulysses16" PROBLEM_PATH = DATA_PATH / f"{NAME}.tsp" SOLUTION_PATH = DATA_PATH / f"{NAME}.opt.tour" p = tsp.load_problem(PROBLEM_PATH) s = tsp.load_solution(SOLUTION_PATH) print(f"Optimal tour: {s.tours}") print(f"Optimal tour: {p.trace_tours(s)}") g = p.get_graph() draw(g, s.tours[0]) #def get_colors( # graph, edges, default='b', highlight='r', #): # c = np.full(len(graph.edges), default) # w = np.ones(len(graph.edges)) # # for i, edge in enumerate(graph.edges): # if edge in edges:
def read_tsplib95(path): problem = tsplib95.load_problem(path) return problem.get_graph()