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 SA(): SA_iters = 10 correctCount = 0 t = 0 totalTime = 0 totalIters = 0 global sa sa = SimulatedAnnealing(1e11, .85, hcp) while correctCount < NUM_RIGHT: start = time.time() fit = FixedIterationTrainer(sa, SA_iters) fitness = fit.train() t = time.time() - start totalTime += t totalIters += SA_iters myWriter.addValue(fitness, "SA_fitness", runNum) myWriter.addValue(t, "SA_searchTimes", runNum) v = ef.value(sa.getOptimal()) if v == N: correctCount += 1 else: correctCount = 0 #SA_iters += 1 myWriter.addValue(t, "SA_times", 0) myWriter.addValue(int(SA_iters), "SA_iters", 0) print str(N) + ": SA: " + str(ef.value(sa.getOptimal())) + " took " + str( totalIters) + " seconds and " + str(totalIters) + " iterations"
def run_mimic(t, samples, keep, m): fill = [N] * N ranges = array('i', fill) ef = TravelingSalesmanRouteEvaluationFunction(points) odd = DiscreteUniformDistribution(ranges) fname = outfile.format('MIMIC{}_{}_{}'.format(samples, keep, m), str(t + 1)) base.write_header(fname) df = DiscreteDependencyTree(m, ranges) ef = TravelingSalesmanRouteEvaluationFunction(points) 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 sa_generic(name, ef, odd, nf, iter_time, iters_total, iters_step, n_trials, params): for i_trial in range(n_trials): for t_param, cooling in itertools.product(*params): hcp = GenericHillClimbingProblem(ef, odd, nf) sa_instance = SimulatedAnnealing(t_param, cooling, hcp) sa_trainer = FixedIterationTrainer(sa_instance, iters_step) sa_state = {'problem': sa_instance, 'trainer': sa_trainer} wrapper_sa = AlgoWrapper(sa_state, lambda state: state['trainer'].train(), lambda state: ef.value(state['problem'].getOptimal()), lambda state: ef.value(state['problem'].getOptimal()) ) # create name and invalidate if super empty decorated_name = "" if name is not None and name != "": decorated_name = name + "_t_" + str(t_param) + "_cooling_" + str(cooling) timed_trainer = TimedTrainer(decorated_name, wrapper_sa, iter_time, iters_total, iters_step, _param_dict={'name':name, 'temperature':t_param, 'coolFactor':cooling} ) timed_trainer.run()
def sa_network(name, network, measure, train_set, test_set, acc_func, iter_time, iters_total, iters_step, n_trials, params): for i_trial in range(n_trials): for t_param, cooling in itertools.product(*params): network_optimizer = NeuralNetworkOptimizationProblem(train_set, network, measure) sa_instance = SimulatedAnnealing(t_param, cooling, network_optimizer) sa_trainer = FixedIterationTrainer(sa_instance, iters_step) nn_state = {'network': network, 'trainer': sa_trainer} wrapper_sa = AlgoWrapper(nn_state, lambda state: state['trainer'].train(), lambda state: acc_func(train_set, state['network'], measure), lambda state: acc_func(test_set, state['network'], measure) ) # create name and invalidate if super empty decorated_name = "" if name is not None and name != "": decorated_name = name + "_t_" + str(t_param) + "_cooling_" + str(cooling) timed_trainer = TimedTrainer(decorated_name, wrapper_sa, iter_time, iters_total, iters_step, _param_dict={'name':name, 'temperature':t_param, 'coolFactor':cooling} ) timed_trainer.run()
def ga_network(name, network, measure, train_set, test_set, acc_func, iter_time, iters_total, iters_step, n_trials, params): for i_trial in range(n_trials): for popsize, toMate, toMutate in itertools.product(*params): network_optimizer = NeuralNetworkOptimizationProblem(train_set, network, measure) ga_instance = StandardGeneticAlgorithm(popsize, int(popsize * toMate), int(popsize * toMutate), network_optimizer) ga_trainer = FixedIterationTrainer(ga_instance, iters_step) nn_state = {'network': network, 'trainer': ga_trainer} wrapper_ga = AlgoWrapper(nn_state, lambda state: state['trainer'].train(), lambda state: acc_func(train_set, state['network'], measure), lambda state: acc_func(test_set, state['network'], measure) ) # create name and invalidate if super empty decorated_name = "" if name is not None and name != "": decorated_name = name + "_popSize_" + str(popsize) + "_toMate_" + str(toMate) + "_toMutate_" + str(toMutate) timed_trainer = TimedTrainer(decorated_name, wrapper_ga, iter_time, iters_total, iters_step, _param_dict={'name':name, 'popSize':popsize, 'toMate':toMate, 'toMutate':toMutate} ) timed_trainer.run()
def mimic_discrete(name, ef, odd, ranges, iter_time, iters_total, iters_step, n_trials, params): for i_trial in range(n_trials): for samples, keep, m in itertools.product(*params): df = DiscreteDependencyTree(m, ranges) pop = GenericProbabilisticOptimizationProblem(ef, odd, df) mimic_instance = MIMIC(samples, keep, pop) mimic_trainer = FixedIterationTrainer(mimic_instance, iters_step) mimic_state = {'problem': mimic_instance, 'trainer': mimic_trainer} # wrap into class etc... wrapper_mimic = AlgoWrapper(mimic_state, lambda state: state['trainer'].train(), lambda state: ef.value(state['problem'].getOptimal()), lambda state: ef.value(state['problem'].getOptimal()) ) # create name and invalidate if super empty decorated_name = "" if name is not None and name != "": decorated_name = name + "_samples_" + str(samples) + "_keep_" + str(keep) + "_m_" + str(m) timed_trainer = TimedTrainer(decorated_name, wrapper_mimic, iter_time, iters_total, iters_step, _param_dict={'name':name, 'samples':samples, 'keep':keep, 'm':m} ) timed_trainer.run()
def ga_generic(name, ef, odd, mf, cf, iter_time, iters_total, iters_step, n_trials, params): for i_trial in range(n_trials): for popsize, toMate, toMutate in itertools.product(*params): gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf) ga_instance = StandardGeneticAlgorithm(popsize, int(popsize * toMate), int(popsize * toMutate), gap) ga_trainer = FixedIterationTrainer(ga_instance, iters_step) ga_state = {'problem': ga_instance, 'trainer': ga_trainer} wrapper_ga = AlgoWrapper(ga_state, lambda state: state['trainer'].train(), lambda state: ef.value(state['problem'].getOptimal()), lambda state: ef.value(state['problem'].getOptimal()) ) # create name and invalidate if super empty decorated_name = "" if name is not None and name != "": decorated_name = name + "_popSize_" + str(popsize) + "_toMate_" + str(toMate) + "_toMutate_" + str(toMutate) timed_trainer = TimedTrainer(decorated_name, wrapper_ga, iter_time, iters_total, iters_step, _param_dict={'name':name, 'popSize':popsize, 'toMate':toMate, 'toMutate':toMutate} ) timed_trainer.run()
def run_rhc(t): fname = outfile.format('RHC', 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 = ContinuousPeaksEvaluationFunction(T) 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 fname, 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)) ef = ContinuousPeaksEvaluationFunction(T) 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 RHC(): correctCount = 0 RHC_iters = 10 t = 0 totalTime = 0 totalIters = 0 global rhc rhc = RandomizedHillClimbing(hcp) while correctCount < NUM_RIGHT: # print str(correctCount)+ " / 20 correct in RHC w/ iters " + str(RHC_iters) fit = FixedIterationTrainer(rhc, RHC_iters) start = time.time() fitness = fit.train() t = time.time() - start totalIters += RHC_iters totalTime += t myWriter.addValue(fitness, "RHC_fitness", runNum) myWriter.addValue(t, "RHC_searchTimes", runNum) v = ef.value(rhc.getOptimal()) if v == N: correctCount += 1 else: correctCount = 0 #RHC_iters += 1 myWriter.addValue(totalTime, "RHC_times", runNum) myWriter.addValue(totalIters, "RHC_iters", runNum) print str(N) + ": RHC: " + str(ef.value( rhc.getOptimal())) + " took " + str(totalTime) + " seconds and " + str( totalIters) + " iterations"
def MIMICtest(): correctCount = 0 MIMIC_iters = 10 MIMIC_samples = 5 * N #max(1,int(N/10)) MIMIC_keep = int(.1 * MIMIC_samples) t = 0 while correctCount < NUM_RIGHT and MIMIC_iters <= 500: MIMIC_keep = int(max(.1 * MIMIC_samples, 1)) mimic = MIMIC(int(MIMIC_samples), int(MIMIC_keep), pop) start = time.time() fit = FixedIterationTrainer(mimic, int(MIMIC_iters)) fitness = fit.train() t = time.time() - start v = ef.value(mimic.getOptimal()) myWriter.addValue(fitness, "MIMIC_fitness", runNum) myWriter.addValue(t, "MIMIC_searchTimes", runNum) if v == N: correctCount += 1 else: correctCount = 0 MIMIC_iters *= 1.1 MIMIC_samples *= 1.1 myWriter.addValue(t, "MIMIC_times", 0) myWriter.addValue(int(MIMIC_iters), "MIMIC_iters", 0) myWriter.addValue(int(MIMIC_samples), "MIMIC_samples", 0) myWriter.addValue(int(MIMIC_keep), "MIMIC_keep", 0) print( str(N) + ": MIMIC: " + str(ef.value(mimic.getOptimal())) + " took " + str(t) + " seconds and " + str(int(MIMIC_iters)) + " iterations and " + str(int(MIMIC_samples)) + " samples with keep " + str(int(MIMIC_keep)))
def test_iter(algorithm, arguments, no_loops, no_iter): results = [] for loop in range(no_loops): algo_init = algorithm(*arguments) fit = FixedIterationTrainer(algo_init, no_iter) fit.train() results += [ef.value(algo_init.getOptimal())] return results
def mimic_fac(args={}): constant_params = {'op': pop} params = merge_two_dicts(args, constant_params) mimic = MIMIC(50, 10, pop) mimic = MIMIC(args['samples'], int(args['samples'] * args['tokeep']), pop) mfit = FixedIterationTrainer(mimic, num_iterations) return mfit
def ga_fac(args={}): constant_params = {'hcp': hcp} params = merge_two_dicts(args, constant_params) ga = StandardGeneticAlgorithm( args['populationSize'], int(args['populationSize'] * args['toMate']), int(args['populationSize'] * args['toMutate']), gap) gfit = FixedIterationTrainer(ga, num_iterations) return gfit
def run_mimic(pop, ef, iterations=1000): mimic = MIMIC(200, 20, pop) fit = FixedIterationTrainer(mimic, iterations) fit.train() optimal_result = str(ef.value(mimic.getOptimal())) print "MIMIC: " + optimal_result return optimal_result, iterations
def run_ga(gap, ef, iterations=1000): ga = StandardGeneticAlgorithm(200, 100, 10, gap) fit = FixedIterationTrainer(ga, iterations) fit.train() optimal_result = str(ef.value(ga.getOptimal())) print "GA: " + optimal_result return optimal_result, iterations
def run_sa(hcp, ef, iterations=200000): sa = SimulatedAnnealing(1E11, .95, hcp) fit = FixedIterationTrainer(sa, iterations) fit.train() optimal_result = str(ef.value(sa.getOptimal())) print "SA: " + optimal_result return optimal_result, iterations
def sa_fac(args={}): constant_params = {'hcp': hcp} params = merge_two_dicts(args, constant_params) sa = SimulatedAnnealing(args['t'], args['cooling'], hcp) # sa = SimulatedAnnealing(**params) sfit = FixedIterationTrainer(sa, num_iterations) return sfit
def eval_algo(ef, algo, fixed_iter): fit = FixedIterationTrainer(algo, fixed_iter) start = time.time() fit.train() end = time.time() score = ef.value(algo.getOptimal()) runtime = end - start call_count = 0 return score, call_count, runtime
def run_rhc(hcp, ef, iterations=200000): rhc = RandomizedHillClimbing(hcp) fit = FixedIterationTrainer(rhc, iterations) fit.train() optimal_result = str(ef.value(rhc.getOptimal())) print "RHC: " + optimal_result return optimal_result, iterations
def run_four_peaks_exploringSA(): N=200 T=N/5 fill = [2] * N ranges = array('i', fill) ef = FourPeaksEvaluationFunction(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) iters = [50, 100, 250, 500, 1000, 2500, 5000, 10000, 25000, 30000, 35000, 40000, 45000, 50000] num_repeats = 5 all_sa_results = [] all_sa_times = [] coolings = [0.15, 0.35, 0.55, 0.75, 0.95] for cooling in coolings: sa_results = [] sa_times = [] for i in iters: print(i) for j in range(num_repeats): start = time.time() sa = SimulatedAnnealing(1E11, cooling, hcp) fit = FixedIterationTrainer(sa, i) fit.train() end = time.time() sa_results.append(ef.value(sa.getOptimal())) sa_times.append(end - start) print "SA cooling " + str(cooling) + ": " + str(ef.value(sa.getOptimal())) all_sa_results.append(sa_results) all_sa_results.append(sa_times) with open('four_peaks_exploringSA.csv', 'w') as csvfile: writer = csv.writer(csvfile) for sa_results in all_sa_results: writer.writerow(sa_results) for sa_times in all_sa_times: writer.writerow(sa_times) return all_sa_results, all_sa_times
def run_experiment(self, opName): """Run a genetic algorithms optimization experiment for a given optimization problem. Args: ef (AbstractEvaluationFunction): Evaluation function. ranges (array): Search space ranges. op (str): Name of optimization problem. """ outdir = 'results/OPT/{}'.format(opName) # get results directory outfile = 'GA_{}_{}_{}_results.csv'.format(self.p, self.ma, self.mu) fname = get_abspath(outfile, outdir) # get output filename # delete existing results file, if it already exists try: os.remove(fname) except Exception as e: print e pass with open(fname, 'w') as f: f.write('iterations,fitness,time,fevals,trial\n') # start experiment for t in range(self.numTrials): # initialize optimization problem and training functions ranges, ef = self.op.get_ef() mf = None cf = None if opName == 'TSP': mf = SwapMutation() cf = TravelingSalesmanCrossOver(ef) else: mf = DiscreteChangeOneMutation(ranges) cf = SingleCrossOver() odd = DiscreteUniformDistribution(ranges) gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf) ga = StandardGeneticAlgorithm(self.p, self.ma, self.mu, gap) fit = FixedIterationTrainer(ga, 10) # run experiment and train evaluation function start = time.clock() for i in range(0, self.maxIters, 10): fit.train() elapsed = time.clock() - start fe = ef.valueCallCount score = ef.value(ga.getOptimal()) ef.valueCallCount -= 1 # write results to output file s = '{},{},{},{},{}\n'.format(i + 10, score, elapsed, fe, t) with open(fname, 'a+') as f: f.write(s)
def perform(alg, fname): fit = FixedIterationTrainer(alg, 10) times = [0] for i in range(0, maxIters, 10): start = clock() fit.train() elapsed = time.clock() - start times.append(times[-1] + elapsed) score = ef.value(alg.getOptimal()) st = '{},{},{}\n'.format(i, score, times[-1]) # print st with open(fname, 'a') as f: f.write(st)
def run_experiment(self, opName): """Run a simulated annealing optimization experiment for a given optimization problem. Args: ef (AbstractEvaluationFunction): Evaluation function. ranges (array): Search space ranges. op (str): Name of optimization problem. """ outdir = 'results/OPT/{}'.format(opName) # get results directory outfile = 'SA_{}_results.csv'.format(self.cr) fname = get_abspath(outfile, outdir) # get output filename # delete existing results file, if it already exists try: os.remove(fname) except Exception as e: print e pass with open(fname, 'w') as f: f.write('iterations,fitness,time,fevals,trial\n') # start experiment for t in range(self.numTrials): # initialize optimization problem and training functions ranges, ef = self.op.get_ef() nf = None if opName == 'TSP': nf = SwapNeighbor() else: nf = DiscreteChangeOneNeighbor(ranges) odd = DiscreteUniformDistribution(ranges) hcp = GenericHillClimbingProblem(ef, odd, nf) sa = SimulatedAnnealing(1E10, self.cr, hcp) fit = FixedIterationTrainer(sa, 10) # run experiment and train evaluation function start = time.clock() for i in range(0, self.maxIters, 10): fit.train() elapsed = time.clock() - start fe = ef.valueCallCount score = ef.value(sa.getOptimal()) ef.valueCallCount -= 1 # write results to output file s = '{},{},{},{},{}\n'.format(i + 10, score, elapsed, fe, t) with open(fname, 'a+') as f: f.write(s)
def IterRangeExperiment(name, experiment, points, paramRange, mat, row): totalSoFar = 0 fitVec = [] timeVec = [] for idx, i in enumerate(paramRange): num = i - totalSoFar fit = FixedIterationTrainer(experiment, num) totalSoFar += num frow = row * len(paramRange) + idx fitness, time = TrainAndSave(experiment, points, fit, mat, name, frow) fitVec.append(fitness) timeVec.append(time) saveFit(name + "_fitness", fitVec, row, mat) saveFit(name + "_iterations", paramRange, row, mat) return fitVec
def run_experiment(self, opName): """Run a MIMIC optimization experiment for a given optimization problem. Args: ef (AbstractEvaluationFunction): Evaluation function. ranges (array): Search space ranges. op (str): Name of optimization problem. """ outdir = 'results/OPT/{}'.format(opName) # get results directory outfile = 'MIMIC_{}_{}_{}_results.csv'.format(self.s, self.k, self.m) fname = get_abspath(outfile, outdir) # get output filename # delete existing results file, if it already exists try: os.remove(fname) except Exception as e: print e pass with open(fname, 'w') as f: f.write('iterations,fitness,time,fevals,trial\n') # start experiment for t in range(self.numTrials): # initialize optimization problem and training functions ranges, ef = self.op.get_ef() mimic = None df = DiscreteDependencyTree(self.m, ranges) odd = DiscreteUniformDistribution(ranges) pop = GenericProbabilisticOptimizationProblem(ef, odd, df) mimic = MIMIC(self.s, self.k, pop) fit = FixedIterationTrainer(mimic, 10) # run experiment and train evaluation function start = time.clock() for i in range(0, self.maxIters, 10): fit.train() elapsed = time.clock() - start fe = ef.valueCallCount score = ef.value(mimic.getOptimal()) ef.valueCallCount -= 1 # write results to output file s = '{},{},{},{},{}\n'.format(i + 10, score, elapsed, fe, t) with open(fname, 'a+') as f: f.write(s)
def mimicGATest(): popBegin = 1 popEnd = 101 keepBegin = 1 keepEnd = 90 mutBegin = 1 mutEnd = 90 itersBegin = 1 itersEnd = 200 samples = 10 keep = 2 problemSize = N mimicRange = (problemSize) iters = 1 paramRanges = Vector(8) paramRanges.addElement(popBegin) paramRanges.addElement(popEnd) paramRanges.addElement(keepBegin) paramRanges.addElement(keepEnd) paramRanges.addElement(mutBegin) paramRanges.addElement(mutEnd) paramRanges.addElement(itersBegin) paramRanges.addElement(itersEnd) totalParamSize1 = (popEnd - popBegin + 1) + (keepEnd - keepBegin + 1) + ( mutEnd - mutBegin + 1) + (itersEnd - itersBegin + 1) allParamValues = range(popBegin, popEnd + 1) + range( keepBegin, keepEnd + 1) + range(mutBegin, mutEnd + 1) + range( itersBegin, itersEnd + 1) totalParamSize = len(allParamValues) metaFun = RamysEvalMetafunc(ranges) discreteDist = RamysMimicDistribution( paramRanges) #DiscreteUniformDistribution(problemSize) distFunc = DiscreteDependencyTree(.1, allParamValues) findGA = GenericProbabilisticOptimizationProblem(metaFun, discreteDist, distFunc) mimic = MIMIC(samples, keep, findGA) fit = FixedIterationTrainer(mimic, iters) fit.train() print str(N) + ": MIMIC finds GA : " + str(ef.value(mimic.getOptimal()))
def run_rhc(t): fname = outfile.format('RHC', str(t + 1)) ef = TravelingSalesmanRouteEvaluationFunction(points) 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