def run_sa(t, CE): fname = outfile.format('SA{}'.format(CE), str(t + 1)) with open(fname, 'a+') as f: content = f.read() if "fitness" not in content: f.write('iterations,fitness,time,fevals\n') ef = FlipFlopEvaluationFunction() odd = DiscreteUniformDistribution(ranges) nf = DiscreteChangeOneNeighbor(ranges) hcp = GenericHillClimbingProblem(ef, odd, nf) sa = SimulatedAnnealing(1E10, CE, hcp) fit = FixedIterationTrainer(sa, 10) times = [0] for i in range(0, maxIters, 10): start = clock() fit.train() elapsed = time.clock() - start times.append(times[-1] + elapsed) fevals = ef.fevals score = ef.value(sa.getOptimal()) ef.fevals -= 1 st = '{},{},{},{}\n'.format(i, score, times[-1], fevals) # print st base.write_to_file(fname, st) return
def run_mimic(t, samples, keep, m): fname = outfile.format('MIMIC{}_{}_{}'.format(samples, keep, m), str(t + 1)) base.write_header(fname) ef = FlipFlopEvaluationFunction() odd = DiscreteUniformDistribution(ranges) nf = DiscreteChangeOneNeighbor(ranges) mf = DiscreteChangeOneMutation(ranges) cf = SingleCrossOver() gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf) df = DiscreteDependencyTree(m, ranges) pop = GenericProbabilisticOptimizationProblem(ef, odd, df) mimic = MIMIC(samples, keep, pop) fit = FixedIterationTrainer(mimic, 10) times = [0] for i in range(0, maxIters, 10): start = clock() fit.train() elapsed = time.clock() - start times.append(times[-1] + elapsed) fevals = ef.fevals score = ef.value(mimic.getOptimal()) ef.fevals -= 1 st = '{},{},{},{}\n'.format(i, score, times[-1], fevals) # print st base.write_to_file(fname, st) return
def run_ga(t, pop, mate, mutate): fname = outfile.format('GA{}_{}_{}'.format(pop, mate, mutate), str(t + 1)) with open(fname, 'a+') as f: content = f.read() if "fitness" not in content: f.write('iterations,fitness,time,fevals\n') ef = FlipFlopEvaluationFunction() odd = DiscreteUniformDistribution(ranges) nf = DiscreteChangeOneNeighbor(ranges) mf = DiscreteChangeOneMutation(ranges) cf = SingleCrossOver() gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf) ga = StandardGeneticAlgorithm(pop, mate, mutate, gap) fit = FixedIterationTrainer(ga, 10) times = [0] for i in range(0, maxIters, 10): start = clock() fit.train() elapsed = time.clock() - start times.append(times[-1] + elapsed) fevals = ef.fevals score = ef.value(ga.getOptimal()) ef.fevals -= 1 st = '{},{},{},{}\n'.format(i, score, times[-1], fevals) # print st base.write_to_file(fname, st) return
def run_rhc(t): fname = outfile.format('RHC', str(t + 1)) ef = FlipFlopEvaluationFunction() odd = DiscreteUniformDistribution(ranges) nf = DiscreteChangeOneNeighbor(ranges) hcp = GenericHillClimbingProblem(ef, odd, nf) rhc = RandomizedHillClimbing(hcp) fit = FixedIterationTrainer(rhc, 10) times = [0] for i in range(0, maxIters, 10): start = clock() fit.train() elapsed = time.clock() - start times.append(times[-1] + elapsed) fevals = ef.fevals score = ef.value(rhc.getOptimal()) ef.fevals -= 1 st = '{},{},{},{}\n'.format(i, score, times[-1], fevals) # print st base.write_to_file(fname, st) return
with open(fname, 'w') as f: f.write('iterations,fitness,time,fevals\n') ef = FlipFlopEvaluationFunction() odd = DiscreteUniformDistribution(ranges) nf = DiscreteChangeOneNeighbor(ranges) hcp = GenericHillClimbingProblem(ef, odd, nf) rhc = RandomizedHillClimbing(hcp) fit = FixedIterationTrainer(rhc, 10) times = [0] for i in range(0, maxIters, 10): start = clock() fit.train() elapsed = time.clock() - start times.append(times[-1] + elapsed) fevals = ef.fevals score = ef.value(rhc.getOptimal()) ef.fevals -= 1 st = '{},{},{},{}\n'.format(i, score, times[-1], fevals) print(st) with open(fname, 'a') as f: f.write(st) # SA for t in range(numTrials): for CE in [0.15, 0.35, 0.55, 0.75, 0.95]: fname = outfile.format('SA{}'.format(CE), str(t + 1)) with open(fname, 'w') as f: f.write('iterations,fitness,time,fevals\n') ef = FlipFlopEvaluationFunction() odd = DiscreteUniformDistribution(ranges) nf = DiscreteChangeOneNeighbor(ranges)
gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf) pop = GenericProbabilisticOptimizationProblem(ef, odd, df) rhc = RandomizedHillClimbing(hcp) sa = SimulatedAnnealing(1E11, .95, hcp) ga = StandardGeneticAlgorithm(200, 100, 10, gap) mimic = MIMIC(200, 20, pop) rhc_f = open('out/op/flipflop/rhc.csv', 'w') sa_f = open('out/op/flipflop/sa.csv', 'w') ga_f = open('out/op/flipflop/ga.csv', 'w') mimic_f = open('out/op/flipflop/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)) rhc_f.close()
# f.write(st) # MIMIC for t in range(numTrials): for samples, keep, m in product([100], [50], [0.7]): fname = outfile.format('MIMIC{}_{}_{}'.format(samples, keep, m), str(t + 1)) with open(fname, 'w') as f: f.write('iterations,fitness,time,fevals\n') ef = FlipFlopEvaluationFunction() odd = DiscreteUniformDistribution(ranges) nf = DiscreteChangeOneNeighbor(ranges) mf = DiscreteChangeOneMutation(ranges) cf = SingleCrossOver() gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf) df = DiscreteDependencyTree(m, ranges) pop = GenericProbabilisticOptimizationProblem(ef, odd, df) mimic = MIMIC(samples, keep, pop) fit = FixedIterationTrainer(mimic, 10) times = [0] for i in range(0, maxIters, 10): start = clock() fit.train() elapsed = time.clock() - start times.append(times[-1] + elapsed) # fevals = ef.fevals score = ef.value(mimic.getOptimal()) # ef.fevals -= 1 st = '{},{},{}\n'.format(i, score, times[-1]) print st with open(fname, 'a') as f: f.write(st)
print "Examining " + name + " trainer..." # if len(hypers.values()) > 0: for exper in itertools.product(*values): # here implement hyper params rep_times = [] for r in range(reps): # create a new trainer each time row = {} for key, value in zip(keys, exper): row[key] = value print(row) fit = factory(row) # have to reset func eval per run fff.func_evals = 0 for i in range(0, max_iterations, num_iterations): start = clock() fit.train() stop = clock() rep_times.append(stop - start) func_eval = fff.func_evals fitness = fff.value(fit.trainer.getOptimal()) # log line = [name, r, i, fitness, rep_times[-1], func_eval ] + list(exper) line = [str(x) for x in line] out.write(','.join(line) + os.linesep) print "Done " + name + " trainer..."
hill_climbing_output = "flipflop_hill_climbing.csv" annealing_output = "flipflop_annealing.csv" genetic_output = "flipflop_genetic.csv" mimic_output = "flipflop_mimic.csv" # HILL CLIMBING for i in range(trials): rhc = RandomizedHillClimbing(hcp) fit = FixedIterationTrainer(rhc, 200000) start = clock() fit.train() end = clock() total_time = end - start max_fit = ef.value(rhc.getOptimal()) time_optimum = [total_time, max_fit] hill_climbing.append(time_optimum) print "RHC Optimum: " + str(ef.value(rhc.getOptimal())) # # ANNEALING for i in range(trials): sa = SimulatedAnnealing(1E12, .999, hcp) fit = FixedIterationTrainer(sa, 200000) start = clock() fit.train() end = clock() total_time = end - start max_fit = ef.value(sa.getOptimal())
ranges = array('i', [2] * N) fitness = FlipFlopEvaluationFunction() discrete_dist = DiscreteUniformDistribution(ranges) discrete_neighbor = DiscreteChangeOneNeighbor(ranges) discrete_mutation = DiscreteChangeOneMutation(ranges) crossover = SCO() discrete_dependency = DiscreteDependencyTree(.1, ranges) hill_problem = GHC(fitness, discrete_dist, discrete_neighbor) start = time.clock() rhc_problem = RHC(hill_problem) fit = FixedIterationTrainer(rhc_problem, iteration) fit.train() end = time.clock() full_time = end - start rhc_total += fitness.value(rhc_problem.getOptimal()) rhc_time += full_time rhc_total_avg = rhc_total/runs rhc_time_avg = rhc_time/runs data = '{},{},{}\n'.format(iteration, rhc_total_avg, rhc_time_avg) print(data) with open(output_directory, 'a') as f: f.write(data) #SA output_directory = "Results/Small/FlipFlop_SA.csv" with open(output_directory, 'w') as f: f.write('iterations,fitness,time\n')
odd = DiscreteUniformDistribution(ranges) nf = DiscreteChangeOneNeighbor(ranges) hcp = GenericHillClimbingProblem(ef, odd, nf) rhc = RandomizedHillClimbing(hcp) fit = FixedIterationTrainer(rhc, 10) times = [0] for i in range(0, maxIters, 10): start = clock() fit.train() elapsed = time.clock() - start times.append(times[-1] + elapsed) print ef.fevals fevals = ef.fevals x = rhc.getOptimal() #print x score = ef.value(x) ef.fevals -= 1 st = '{},{},{},{}\n'.format(i, score, times[-1], fevals) print st with open(fname, 'a') as f: f.write(st) #sys.exit(1) # SA for t in range(numTrials): for CE in [0.15, 0.35, 0.55, 0.75, 0.95]: fname = outfile.format('SA{}'.format(CE), str(t + 1)) with open(fname, 'w') as f: f.write('iterations,fitness,time,fevals\n') ef = FlipFlopEvaluationFunction() odd = DiscreteUniformDistribution(ranges) nf = DiscreteChangeOneNeighbor(ranges)