def solveit(oaname, params): N = 60 T = N / 10 fill = [2] * N ranges = array('i', fill) iterations = 10000 tryi = 1 ef = ContinuousPeaksEvaluationFunction(T) odd = DiscreteUniformDistribution(ranges) nf = DiscreteChangeOneNeighbor(ranges) mf = DiscreteChangeOneMutation(ranges) cf = SingleCrossOver() df = DiscreteDependencyTree(.1, ranges) hcp = GenericHillClimbingProblem(ef, odd, nf) gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf) pop = GenericProbabilisticOptimizationProblem(ef, odd, df) # fit = FixedIterationTrainer(rhc, 200000) # fit.train() if oaname == 'RHC': iterations = int(params[0]) tryi = int(params[1]) oa = RandomizedHillClimbing(hcp) if oaname == 'SA': oa = SimulatedAnnealing(float(params[0]), float(params[1]), hcp) if oaname == 'GA': oa = StandardGeneticAlgorithm(int(params[0]), int(params[1]), int(params[2]), gap) if oaname == 'MMC': oa = MIMIC(int(params[0]), int(params[1]), pop) print "Running %s using %s for %d iterations, try %d" % ( oaname, ','.join(params), iterations, tryi) print "=" * 20 starttime = timeit.default_timer() output = [] for i in range(iterations): oa.train() if i % 10 == 0: optimal = oa.getOptimal() score = ef.value(optimal) elapsed = float(timeit.default_timer() - starttime) output.append([str(i), str(score), str(elapsed)]) print 'score: %.3f' % score print 'train time: %.3f secs' % (int(timeit.default_timer() - starttime)) scsv = 'cp-%s-%s.csv' % (oaname, '-'.join(params)) print "Saving to %s" % (scsv), with open(scsv, 'w') as csvf: writer = csv.writer(csvf) for row in output: writer.writerow(row) print "saved." print "=" * 20
def solveit(oaname, params): # set N value. This is the number of points N = 50 iterations = 1000 tryi = 1 random = Random() points = [[0 for x in xrange(2)] for x in xrange(N)] for i in range(0, len(points)): points[i][0] = random.nextDouble() points[i][1] = random.nextDouble() ef = TravelingSalesmanRouteEvaluationFunction(points) odd = DiscretePermutationDistribution(N) nf = SwapNeighbor() mf = SwapMutation() cf = TravelingSalesmanCrossOver(ef) hcp = GenericHillClimbingProblem(ef, odd, nf) gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf) if oaname == "RHC": iterations = int(params[0]) tryi = int(params[1]) oa = RandomizedHillClimbing(hcp) if oaname == "SA": oa = SimulatedAnnealing(float(params[0]), float(params[1]), hcp) if oaname == "GA": iterations=1000 oa = StandardGeneticAlgorithm(int(params[0]), int(params[1]), int(params[2]), gap) if oaname == "MMC": iterations=1000 # for mimic we use a sort encoding ef = TravelingSalesmanSortEvaluationFunction(points) fill = [N] * N ranges = array('i', fill) odd = DiscreteUniformDistribution(ranges) df = DiscreteDependencyTree(.1, ranges) pop = GenericProbabilisticOptimizationProblem(ef, odd, df) oa = MIMIC(int(params[0]), int(params[1]), pop) print "Running %s using %s for %d iterations, try %d" % (oaname, ','.join(params), iterations, tryi) print "="*20 starttime = timeit.default_timer() output = [] for i in range(iterations): oa.train() if i%10 == 0: optimal = oa.getOptimal() score = ef.value(optimal) elapsed = int(timeit.default_timer()-starttime) output.append([str(i), str(score), str(elapsed)]) print 'Inverse of Distance [score]: %.3f' % score print 'train time: %d secs' % (int(timeit.default_timer()-starttime)) scsv = 'tsp-%s-%s.csv' % (oaname, '-'.join(params)) print "Saving to %s" % (scsv), with open(scsv, 'w') as csvf: writer = csv.writer(csvf) for row in output: writer.writerow(row) print "saved." print "="*20 print "Route:" if oaname == 'MMC': optimal = oa.getOptimal() fill = [0] * optimal.size() ddata = array('d', fill) for i in range(0,len(ddata)): ddata[i] = optimal.getContinuous(i) order = ABAGAILArrays.indices(optimal.size()) ABAGAILArrays.quicksort(ddata, order) print order else: path = [] for x in range(0,N): path.append(oa.getOptimal().getDiscrete(x)) print path
df = DiscreteDependencyTree(.1, ranges) hill_climbing_problem = GenericHillClimbingProblem(ef, initial_distribution, nf) genetic_problem = GenericGeneticAlgorithmProblem(ef, initial_distribution, mutation_function, cf) probablistic_optimization = GenericProbabilisticOptimizationProblem(ef, initial_distribution, df) from time import time f = open("experiments/results/knapsack_optimal2.txt", "w") f.write("starting RHC\n") rhc = RandomizedHillClimbing(hill_climbing_problem) score = 0 iters = 0 t0 = time() while iters < 80000: score = rhc.train() f.write(str(iters) + "," + str(score) +"\n") iters += 1 print "RHC: " + str(ef.value(rhc.getOptimal())), "time taken", time() - t0, "Iterations:", iters f.write("starting SA\n") sa = SimulatedAnnealing(1E13, .95, hill_climbing_problem) t0 = time() iters = 0 score = 0 while iters < 80000: score = sa.train() f.write(str(iters) + "," + str(score) + "\n")
hcp = GenericHillClimbingProblem(ef, odd, nf) gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf) pop = GenericProbabilisticOptimizationProblem(ef, odd, df) rhc = RandomizedHillClimbing(hcp) sa = SimulatedAnnealing(100, .95, hcp) ga = StandardGeneticAlgorithm(20, 20, 0, gap) mimic = MIMIC(50, 10, pop) rhc_f = open('out/op/countones/rhc.csv', 'w') sa_f = open('out/op/countones/sa.csv', 'w') ga_f = open('out/op/countones/ga.csv', 'w') mimic_f = open('out/op/countones/mimic.csv', 'w') for i in range(ITERATIONS): rhc.train() rhc_fitness = ef.value(rhc.getOptimal()) rhc_f.write('{},{}\n'.format(i, rhc_fitness)) sa.train() sa_fitness = ef.value(sa.getOptimal()) sa_f.write('{},{}\n'.format(i, sa_fitness)) ga.train() ga_fitness = ef.value(ga.getOptimal()) ga_f.write('{},{}\n'.format(i, ga_fitness)) mimic.train() mimic_fitness = ef.value(mimic.getOptimal()) mimic_f.write('{},{}\n'.format(i, mimic_fitness))
def solveit(oaname, params): iterations = 10000 tryi = 1 # Random number generator */ random = Random() # The number of items NUM_ITEMS = 40 # The number of copies each COPIES_EACH = 4 # The maximum weight for a single element MAX_WEIGHT = 50 # The maximum volume for a single element MAX_VOLUME = 50 # The volume of the knapsack KNAPSACK_VOLUME = MAX_VOLUME * NUM_ITEMS * COPIES_EACH * .4 # create copies fill = [COPIES_EACH] * NUM_ITEMS copies = array('i', fill) # create weights and volumes fill = [0] * NUM_ITEMS weights = array('d', fill) volumes = array('d', fill) for i in range(0, NUM_ITEMS): weights[i] = random.nextDouble() * MAX_WEIGHT volumes[i] = random.nextDouble() * MAX_VOLUME # create range fill = [COPIES_EACH + 1] * NUM_ITEMS ranges = array('i', fill) ef = KnapsackEvaluationFunction(weights, volumes, KNAPSACK_VOLUME, copies) odd = DiscreteUniformDistribution(ranges) nf = DiscreteChangeOneNeighbor(ranges) mf = DiscreteChangeOneMutation(ranges) cf = UniformCrossOver() df = DiscreteDependencyTree(.1, ranges) hcp = GenericHillClimbingProblem(ef, odd, nf) gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf) pop = GenericProbabilisticOptimizationProblem(ef, odd, df) if oaname == 'RHC': iterations = int(params[0]) tryi = int(params[1]) oa = RandomizedHillClimbing(hcp) if oaname == 'SA': oa = SimulatedAnnealing(float(params[0]), float(params[1]), hcp) if oaname == 'GA': iterations = 1000 oa = StandardGeneticAlgorithm(int(params[0]), int(params[1]), int(params[2]), gap) if oaname == 'MMC': iterations = 1000 oa = MIMIC(int(params[0]), int(params[1]), pop) print "Running %s using %s for %d iterations, try %d" % ( oaname, ','.join(params), iterations, tryi) print "=" * 20 starttime = timeit.default_timer() output = [] for i in range(iterations): oa.train() if i % 10 == 0: optimal = oa.getOptimal() score = ef.value(optimal) elapsed = int(timeit.default_timer() - starttime) output.append([str(i), str(score), str(elapsed)]) print 'score: %.3f' % score print 'train time: %d secs' % (int(timeit.default_timer() - starttime)) scsv = 'kn-%s-%s.csv' % (oaname, '-'.join(params)) print "Saving to %s" % (scsv), with open(scsv, 'w') as csvf: writer = csv.writer(csvf) for row in output: writer.writerow(row) print "saved." print "=" * 20
mf = DiscreteChangeOneMutation(ranges) cf = UniformCrossOver() df = DiscreteDependencyTree(.1, ranges) hcp = GenericHillClimbingProblem(ef, odd, nf) gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf) pop = GenericProbabilisticOptimizationProblem(ef, odd, df) timeout = 1E6 # first find the global optimum by running for a long time hcp0 = GenericHillClimbingProblem(ef, odd, nf) rhc0 = RandomizedHillClimbing(hcp0) i = 0 max = 0 while (i < timeout/10): rhc0.train() i += 1 max = ef.value(rhc0.getOptimal()) print "rhc0,", i,",", max goal = max pop0 = GenericProbabilisticOptimizationProblem(ef, odd, df) mimic0 = MIMIC(200, 100, pop) i = 0 while ( i< timeout/1000): mimic0.train() i += 1 max = ef.value(mimic0.getOptimal()) print "mimic0,", i,",", max if (max > goal): goal = max gap0 = GenericGeneticAlgorithmProblem(ef, odd, mf, cf)