class TestLocalSearch(unittest.TestCase): def setUp(self): self.flow = [ [0, 1, 2], [4, 0, 5], [7, 2, 0]] self.distance = [ [0, 5, 2], [1, 0, 1], [6, 2, 0]] self.i = Instance(None, self.distance, self.flow) self.ls_steepest = LocalSearch() self.ls_greedy = LocalSearch(greedy=True) self.startpoint = Solution((0, 1, 2)) def test_solve_steepest_with_startpoint(self): expected = (2, 1, 0) actual = self.ls_steepest.solve(self.i, self.startpoint).sequence self.assertEqual(expected, actual) def test_solve_greedy_with_startpoint(self): expected = (2, 1, 0) actual = self.ls_greedy.solve(self.i, self.startpoint).sequence self.assertEqual(expected, actual)
def run_local_search(seconds): print('Running Local Search algoritm for ' + str(seconds) + ' seconds...') print() ls = LocalSearch(states, seconds, inc_support, dec_support) ls.run() print('Found optimal route with value of ' + str(ls.best_solution.value) + '.') print( str(ls.best_solution.calculate_real_value()) + ' electoral votes were collected.') ls.best_solution.print() print()
def setUp(self): self.flow = [ [0, 1, 2], [4, 0, 5], [7, 2, 0]] self.distance = [ [0, 5, 2], [1, 0, 1], [6, 2, 0]] self.i = Instance(None, self.distance, self.flow) self.ls_steepest = LocalSearch() self.ls_greedy = LocalSearch(greedy=True) self.startpoint = Solution((0, 1, 2))
def parse_cmd(self): parser = argparse.ArgumentParser() parser.add_argument( '-ST', default=0, help= 'Search type: 0 for backward or forward search and 2 for local search.' ) parser.add_argument( '-AT', default=0, help= 'Algorithm type: 0 for backtracking, 1 for back jumping, 2 for forward checking, ' '3 for arc consistency.') parser.add_argument( '-LS', default=0, help= 'Local search: 0 for feasibility, 1 for KEMPE chains and 2 for hybrid.' ) args = parser.parse_args() try: search_type = int(args.ST) if search_type != 0 and search_type != 1: print("Search type can only be 0 or 1.") sys.exit() except ValueError: print("Search type can only be 0 or 1.") sys.exit() self.search_type = SearchType(search_type) try: algorithm_type = int(args.AT) if algorithm_type != 0 and algorithm_type != 1 and algorithm_type != 2 and algorithm_type != 3: print("Algorithm type can only be 0, 1, 2 or 3.") sys.exit() except ValueError: print("Algorithm type can only be 0, 1, 2 or 3.") sys.exit() self.algorithm_type = AlgorithmType(algorithm_type) try: local_search = int(args.LS) if local_search != 0 and local_search != 1 and local_search != 2: print("Local search can only be 0, 1 or 2.") sys.exit() except ValueError: print("Local search can only be 0, 1 or 2.") sys.exit() self.local_search = LocalSearch(local_search)
def benchmark(): REPEATS = 10 SECONDS = [5, 10, 30, 60, 300, 1200] for seconds in SECONDS: v = 0 time_s = datetime.now() for k in range(REPEATS): rs = RandomSearch(states, seconds, inc_support, dec_support) rs.run() v += rs.best_solution.value time_e = datetime.now() tt = (time_e - time_s).total_seconds() print_csv('Random Search', str(seconds), str(v / REPEATS), str(tt / REPEATS)) for seconds in SECONDS: v = 0 time_s = datetime.now() for k in range(REPEATS): ls = LocalSearch(states, seconds, inc_support, dec_support) ls.run() v += ls.best_solution.value time_e = datetime.now() tt = (time_e - time_s).total_seconds() print_csv('Local Search', str(seconds), str(v / REPEATS), str(tt / REPEATS)) for seconds in SECONDS: for initial_cadence in [10, 25, 50]: for critical_event in [10, 25, 50]: v = 0 time_s = datetime.now() for k in range(REPEATS): ts = TabuSearch(states, seconds, initial_cadence, critical_event, inc_support, dec_support) ts.run() v += ts.best_solution.value time_e = datetime.now() tt = (time_e - time_s).total_seconds() print_csv('Tabu Search', str(seconds), str(initial_cadence), str(critical_event), str(v / REPEATS), str(tt / REPEATS)) for crossover in ['pmx', 'ox']: for mutate in ['transposition', 'insertion', 'inversion']: for seconds in SECONDS: for population_size in [10, 25, 50]: v = 0 time_s = datetime.now() for k in range(REPEATS): ga = GeneticAlgorithm(states, seconds, population_size, crossover, mutate, inc_support, dec_support) ga.run() v += ga.best_solution.value time_e = datetime.now() tt = (time_e - time_s).total_seconds() print_csv('Genetic Algorithm ' + crossover + ' ' + mutate, str(seconds), str(population_size), str(v / REPEATS), str(tt / REPEATS)) for initial_temperature in [100, 500, 1000]: for cooling_coefficient in [0.9, 0.99, 0.999, 0.9999]: for minimal_temperature in [ initial_temperature * 0.25, initial_temperature * 0.5, initial_temperature * 0.75 ]: v = 0 time_s = datetime.now() for k in range(REPEATS): sa = SimulatedAnnealing(states, initial_temperature, cooling_coefficient, minimal_temperature, inc_support, dec_support) sa.run() v += sa.best_solution.value time_e = datetime.now() tt = (time_e - time_s).total_seconds() print_csv('Simulated Annealing', str(initial_temperature), str(cooling_coefficient), str(minimal_temperature), str(v / REPEATS), str(tt / REPEATS))
def performance_testing(): # Heuristics h_alg = [solverNN.algorithm, solverCHH.algorithm] h_alg_name = ["solverNN.algorithm", "solverCHH.algorithm"] ls_alg_name = [ "SolverLS_close_index_route_swap", "SolverLS_all_combination_route_swap", "TwoOPT" ] try: for (idx, algo) in enumerate(h_alg): with open('../results/' + h_alg_name[idx] + '.dat', "a") as filehandle: filehandle.write("{} {} {}\n".format("Instance", "Cost", "Time")) for path, subdirs, files in os.walk('../data'): for name in files: if fnmatch.fnmatch(name, "*.xml"): t0 = time.clock() instance = data.Data(os.path.join(path, name)) ch = ConstructionHeuristics(instance, algo) sol = ch.construct(60 - t0) splitted_name = re.compile("^[a-zA-Z]+").findall( name) filehandle.write("{} {} {}".format( splitted_name[0], sol.cost(), round(t0, 2))) filehandle.write("\n") ls_alg = [ SolverLS(sol).run_first, SolverLS(sol).run_second, TwoOPT(sol).run ] for (ls_idx, l_alg) in enumerate(ls_alg): with open( '../results/' + ls_alg_name[ls_idx] + '_' + h_alg_name[idx] + '.dat', "a") as ls_fh: if os.stat('../results/' + ls_alg_name[ls_idx] + '_' + h_alg_name[idx] + '.dat').st_size == 0: ls_fh.write("{} {} {}\n".format( "Instance", "Cost", "Time")) t0 = time.clock() ls = LocalSearch(solution=sol, alg=l_alg) try: sol = ls.construct(60 - t0) except TimeOutExeption as e: print("timeout") sol = e.solution ls_fh.write("{} {} {}".format( splitted_name[0], sol.cost(), round(t0, 2))) ls_fh.write("\n") ls_fh.close() filehandle.close() boxplotter('../results/' + h_alg_name[idx]) for ls_idx in range(len(ls_alg_name)): boxplotter('../results/' + ls_alg_name[ls_idx] + '_' + h_alg_name[idx]) except TimeOutExeption as e: print("timeout") sol = e.solution
def Meme_IM(args): Candidate = args['Candidate'] MaximumGeneration = args['maxgen'] PopulationSize = args['pop_size'] MatingPoolSize = args['pool'] TournamentSize = args['tour'] CrossoverProbability = args['pc'] MutationProbability = args['pm'] SpreadProbability = args['p'] SeedSize = args['k'] TheCandidateNodesPool = args['Candidate'] TheConnectionMatrix = args['A'] NumberOfGenerations = args['NumberOfGenerations'] gmat = args['gmat'] pop_x = args['pop_size'] pop_y = SeedSize ### should be removed only for test # 1:Step 1) Initialization # 3: Step 1.2) Best individual initialization: Pbest = xi ; population = PopulationInitialization(args) population = np.reshape(population, (pop_x,pop_y)) fitnesses = cal_fitnesses(population, args) fitnesses = np.reshape(fitnesses, (pop_x)) population, fitnesses = sortpopulation(population, fitnesses, args) Pbest,_ = BestIndividualInitialization(population, fitnesses, args) # 4: Step 2) Set t = 0; // the number of generations # 5: Step 3) Repeat # 6: Step 3.1) Select parental chromosomes for mating; # Pparent ! Selection(P, pool, tour); # 7: Step 3.2) Perform genetic operators: # Pchild ! GeneticOperation(Pparent , pc, pm); # 8: Step 3.3) Perform local search: # Pnew ! LocalSearch(Pchild ); # 9: Step 3.4) Update population: # P ! UpdatePopulation(P, Pnew ); # 10: Step 3.5) Update the best individual Pbest ; # 11: Step 4) Stopping criterion: If t < maxgen, then # t = t +1 and go to Step 3), otherwise, stop the # algorithm and output. for t in range(MaximumGeneration): #print("generation = ", t) Pparent = Selection(population,fitnesses, TournamentSize, args) Pparent, fit = LocalSearch(Pparent, Candidate, args) cross_child1, cross_child2, mute_child1,mute_child2 = GeneticOperation(Pbest, Pparent, Candidate, args) # cross_child1, fitc1 = LocalSearch(cross_child1, Candidate, args) # cross_child2, fitc2 = LocalSearch(cross_child2, Candidate, args) # mute_child1, fitm1 = LocalSearch(mute_child1, Candidate, args) # mute_child2, fitm2 = LocalSearch(mute_child2, Candidate, args) # fitc1 = fitness(cross_child1, gmat) fitc2 = fitness(cross_child2, gmat) fitm1 = fitness(mute_child1, gmat) #fitm2 = fitness(mute_child2, gmat) #print(cross_child1, cross_child2,mute_child1,mute_child2) population,fitnesses = list(population), list(fitnesses) population.append(cross_child1) fitnesses.append(fitc1) population.append(cross_child2) fitnesses.append(fitc2) population.append(mute_child1) fitnesses.append(fitm1) #population.append(mute_child2) #fitnesses.append(fitm2) population, fitnesses = np.asarray(population), np.asarray(fitnesses) population, fitnesses = sortpopulation(population, fitnesses, args) Pbest,_ = BestIndividualInitialization(population, fitnesses, args) #print("fitnesses",fitnesses) print("Generation:",t," best fitnesses", fitnesses[0]) return population[0], fitnesses[0]
def bPSO(args): MaxIter = args['MaxIter'] PopSize = args['PopSize'] c1 = args['c1'] c2 = args['c2'] w = args['w'] wdamp = args['wdamp'] problem = args['problem'] Candidate = args['Candidate'] # Empty Particle Template empty_particle = { 'position': None, 'velocity': None, 'cost': None, 'best_position': None, 'best_cost': None, } # Extract Problem Info CostFunction = problem['CostFunction'] VarMin = problem['VarMin'] VarMax = problem['VarMax'] nVar = problem['nVar'] # Initialize Global Best gbest = {'position': None, 'cost': np.inf} # Create Initial Population pop = [] for i in range(0, PopSize): pop.append(empty_particle.copy()) pop[i]['position'] = np.random.uniform(VarMin, VarMax, nVar) # convert to binary pop[i]['position'] = convert_to_binary(pop[i]['position']) pop[i]['velocity'] = np.zeros(nVar) pop[i]['cost'] = CostFunction(pop[i]['position'], args) pop[i]['best_position'] = pop[i]['position'].copy() pop[i]['best_cost'] = pop[i]['cost'] if pop[i]['best_cost'] < gbest['cost']: gbest['position'] = pop[i]['best_position'].copy() gbest['cost'] = pop[i]['best_cost'] # PSO Loop for it in range(0, MaxIter): for i in range(0, PopSize): pop[i]['velocity'] = w*pop[i]['velocity'] \ + c1*np.random.rand(nVar)*(pop[i]['best_position'] - pop[i]['position']) \ + c2*np.random.rand(nVar)*(gbest['position'] - pop[i]['position']) pop[i]['position'] += pop[i]['velocity'] # convert to binary #pop[i]['position'] = convert_to_binary(pop[i]['position']) pop[i]['position'] = np.maximum(pop[i]['position'], VarMin) pop[i]['position'] = np.minimum(pop[i]['position'], VarMax) pop[i]['cost'] = CostFunction( convert_to_binary(pop[i]['position']), args) local_n, fit_local = LocalSearch(pop[i]['position'], Candidate, args) if fit_local < pop[i]['cost']: count = 0 for itm in local_n: bin_item = decimal_to_binary(itm, args['len_var']) pop[i]['position'][count:count + args['len_var']] = [ int(x) for x in bin_item ] #print("L", pop[i]['position'][count:count+args['len_var']]) count += args['len_var'] pop[i]['cost'] = fit_local if pop[i]['cost'] < pop[i]['best_cost']: pop[i]['best_position'] = pop[i]['position'].copy() pop[i]['best_cost'] = pop[i]['cost'] if pop[i]['best_cost'] < gbest['cost']: gbest['position'] = pop[i]['best_position'].copy() gbest['cost'] = pop[i]['best_cost'] w *= wdamp print('Iteration {}: Best Cost = {}'.format(it, -gbest['cost'])) return gbest, pop