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 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_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 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 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 MIMICAllRangeExperiment(name, points, problem, sampleRange, keepRange, iterRange, mat): currmax = -1 bestSampleSize = -1 bestKeep = -1 bestPath = [] lastRow = -1 for jdx, j in enumerate(sampleRange): iVec = [] jVec = [] for idx, i in enumerate(keepRange): #percentage to keep fitVec = [] row = idx * len(sampleRange) + jdx keep = int(ceil(j * i)) #i is the percentage print "samples " + str(j) + " keep " + str(keep) if keep < j: #TODO: no longer needed now that using % keep isntead of absolute mimic = MIMIC(j, keep, problem) if (row == lastRow): print "Error! lastRow == row! " else: lastRow = row fitVec = IterRangeExperiment(name, mimic, points, iterRange, mat, row) else: print "i <= j, skipping row " + str(row) iVec.append(i) jVec.append(j) saveFit(name + "_keep", iVec, idx * len(sampleRange) + jdx, mat) saveFit(name + "_sampleSize", jVec, idx * len(sampleRange) + jdx, mat)
def mimic(): for samples, keep, m in product([80], [40], [0.15, 0.35, 0.55, 0.75, 0.95]): fname = outfile.replace('XXX', 'MIMIC{}_{}_{}'.format(samples, keep, m)) with open(fname, 'w') as f: f.write('iterations,fitness,time,fevals\n') mimic = MIMIC(samples, keep, pop) perform(mimic, fname)
def MIMICKeepRangeExperiment(name, points, problem, keepRange, iterRange, mat): for idx, i in enumerate(keepRange): mimic = MIMIC(1000, i, problem) fitVec = IterRangeExperiment(name, mimic, points, iterRange, mat, idx * len(iterRange)) row = idx saveFit(name + "_fitness", fitVec, idx, mat) saveFit(name + "_iterations", iterRange, idx, mat) saveFit(name + "_numSamples", keepRange, 0, mat)
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 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 mimic(): for samples, keep, m in product([80], [40], [0.15, 0.35, 0.55, 0.75, 0.95]): fname = outfile.replace('XXX','MIMIC{}_{}_{}'.format(samples,keep,m)) df = DiscreteDependencyTree(m, ranges) with open(fname,'w') as f: f.write('iterations,fitness,time,fevals\n') pop = GenericProbabilisticOptimizationProblem(ef, odd, df) mimic = MIMIC(samples, keep, pop) perform(mimic, fname)
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 main(): """Run this experiment""" training_ints = initialize_instances('m_trg.csv') testing_ints = initialize_instances('m_test.csv') validation_ints = initialize_instances('m_val.csv') factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_ints) relu = RELU() rule = RPROPUpdateRule() oa_names = ["MIMIC"] classification_network = factory.createClassificationNetwork([ INPUT_LAYER, HIDDEN_LAYER1, HIDDEN_LAYER2, HIDDEN_LAYER3, OUTPUT_LAYER ], relu) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) oa = MIMIC(200, 100, nnop) train(oa, classification_network, 'MIMIC', training_ints, validation_ints, testing_ints, measure)
def main(): """Run this experiment""" training_ints = initialize_instances(PATH + "X_train.csv") testing_ints = initialize_instances(PATH + "X_test.csv") validation_ints = initialize_instances(PATH + "y_train.csv") factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() logistic_sigmoid = LogisticSigmoid() data_set = DataSet(training_ints) data_set_size = data_set.size() print(data_set_size) print(type(data_set_size)) odd = DiscreteUniformDistribution([data_set_size]) df = DiscreteDependencyTree(.1, [data_set_size]) classification_network = factory.createClassificationNetwork( [INPUT_LAYER, HIDDEN_LAYER1, OUTPUT_LAYER], logistic_sigmoid) evaluation = NeuralNetworkEvaluationFunction(classification_network, data_set, measure) pop = GenericProbabilisticOptimizationProblem(evaluation, odd, df) oa = MIMIC(data_set_size, int(0.1 * data_set_size), pop) train(oa, classification_network, 'GA', training_ints, validation_ints, testing_ints, measure)
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
odd = DiscreteUniformDistribution(ranges) nf = DiscreteChangeOneNeighbor(ranges) mf = DiscreteChangeOneMutation(ranges) cf = UniformCrossOver() df = DiscreteDependencyTree(.1, ranges) # --------------------------------------------------------------- N_ITERS = 100001 # MIMIC start = time.time() fit_hist = [] for n_samples in range(100, 1000, 200): print n_samples pop = GenericProbabilisticOptimizationProblem(ef, odd, df) mimic = MIMIC(n_samples, 20, pop) fh = FixedIterTrainer(ef, mimic, N_ITERS) fit_hist.append(fh) write_hist_csv(fit_hist, 'fitness_mimic_n_samples') print time.time() - start, 'seconds' # # 1553 secs start = time.time() fit_hist = [] for theta in [0.05, 0.10, 0.2, 0.3, 0.5]: print theta pop = GenericProbabilisticOptimizationProblem(ef, odd, df) mimic = MIMIC(200, int(200 * theta), pop)
# MIMIC for t in range(numTrials): for samples, keep, m in product([100], [50], [0.1, 0.3, 0.5, 0.7, 0.9]): 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 = 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.getFunctionEvaluations() score = ef.value(mimic.getOptimal()) fevals -= 1 st = '{},{},{},{}\n'.format(i, score, times[-1], fevals) print st with open(fname, 'a') as f: f.write(st)
sa = SimulatedAnnealing(temp, 0.85, hcp) for iters in iters_list: fit = FixedIterationTrainer(sa, iters) start = time.time() fit.train() dur = time.time() - start print "Iters: " + str(iters) + ", Fitness: " + str( ef.value(sa.getOptimal())) + ", Dur: " + str(dur) print "Genetic Algorithm" ga = StandardGeneticAlgorithm(2 * N, 300, 100, gap) for iters in iters_list: fit = FixedIterationTrainer(ga, iters) start = time.time() fit.train() dur = time.time() - start print "Iters: " + str(iters) + ", Fitness: " + str( ef.value(ga.getOptimal())) + ", Dur: " + str(dur) print "MIMIC" # the number of samples to take each iteration # The number of samples to keep mimic = MIMIC(250, 25, pop) for iters in iters_list: fit = FixedIterationTrainer(mimic, iters) start = time.time() fit.train() dur = time.time() - start print "Iters: " + str(iters) + ", Fitness: " + str( ef.value(mimic.getOptimal())) + ", Dur: " + str(dur)
# MIMIC for t in range(numTrials): for samples, keep, m in product([100], [50], [0.1, 0.3, 0.5, 0.7, 0.9]): 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], fevals) print(st) with open(fname, 'a') as f: f.write(st)
hcp = GenericHillClimbingProblem(ef, odd, nf) gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf) ef2 = TravelingSalesmanSortEvaluationFunction(points) fill = [N] * N ranges = array('i', fill) odd2 = DiscreteUniformDistribution(ranges) df = DiscreteDependencyTree(.1, ranges) pop = GenericProbabilisticOptimizationProblem(ef2, odd2, df) # Algorithm declaration rhc = RandomizedHillClimbing(hcp) sa = SimulatedAnnealing(SA_TEMPERATURE, SA_COOLING_FACTOR, hcp) ga = StandardGeneticAlgorithm(GA_POPULATION, GA_CROSSOVER, GA_MUTATION, gap) mimic = MIMIC(MIMIC_SAMPLES, MIMIC_TO_KEEP, pop) # Trainer declaration fit_rhc = FixedIterationTrainer(rhc, current_iteration_count) fit_sa = FixedIterationTrainer(sa, current_iteration_count) fit_ga = FixedIterationTrainer(ga, current_iteration_count) fit_mimic = FixedIterationTrainer(mimic, current_iteration_count) print("Computing for %d iterations" % current_iteration_count) # Fitting start_rhc = time.time() fit_rhc.train() end_rhc = time.time() start_sa = time.time()
train(sa, exp_name, "SA", "13", ef, 200000) sa = SimulatedAnnealing(1E12, .90, hcp) fit = FixedIterationTrainer(sa, 200000) train(sa, exp_name, "SA", "14", ef, 200000) sa = SimulatedAnnealing(1E12, .80, hcp) fit = FixedIterationTrainer(sa, 200000) train(sa, exp_name, "SA", "15", ef, 200000) #### Experienet 2 - Tuning Algo Prams for Mimic #### if True: exp_name = "exp02" mimic = MIMIC(500, 25, pop) fit = FixedIterationTrainer(mimic, 1000) train(mimic, exp_name, "MIMIC", "0", ef, 2000) mimic = MIMIC(500, 50, pop) fit = FixedIterationTrainer(mimic, 1000) train(mimic, exp_name, "MIMIC", "1", ef, 2000) mimic = MIMIC(500, 100, pop) fit = FixedIterationTrainer(mimic, 1000) train(mimic, exp_name, "MIMIC", "2", ef, 2000) mimic = MIMIC(200, 10, pop) fit = FixedIterationTrainer(mimic, 1000) train(mimic, exp_name, "MIMIC", "3", ef, 2000)
def run_knapsack(): # 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) iters = [50, 100, 250, 500, 1000, 2500, 5000, 10000, 25000, 50000, 100000] num_repeats = 5 rhc_results = [] rhc_times = [] for i in iters: print(i) for j in range(num_repeats): start = time.time() rhc = RandomizedHillClimbing(hcp) fit = FixedIterationTrainer(rhc, i) fit.train() end = time.time() rhc_results.append(ef.value(rhc.getOptimal())) rhc_times.append(end - start) #print "RHC: " + str(ef.value(rhc.getOptimal())) sa_results = [] sa_times = [] for i in iters: print(i) for j in range(num_repeats): start = time.time() sa = SimulatedAnnealing(100, .95, hcp) fit = FixedIterationTrainer(sa, i) fit.train() end = time.time() sa_results.append(ef.value(sa.getOptimal())) sa_times.append(end - start) #print "SA: " + str(ef.value(sa.getOptimal())) ga_results = [] ga_times = [] for i in iters: print(i) for j in range(num_repeats): start = time.time() ga = StandardGeneticAlgorithm(200, 150, 25, gap) fit = FixedIterationTrainer(ga, i) fit.train() end = time.time() ga_results.append(ef.value(sa.getOptimal())) ga_times.append(end - start) #print "GA: " + str(ef.value(ga.getOptimal())) mimic_results = [] mimic_times = [] for i in iters[0:6]: print(i) for j in range(num_repeats): start = time.time() mimic = MIMIC(200, 100, pop) fit = FixedIterationTrainer(mimic, i) fit.train() end = time.time() mimic_results.append(ef.value(mimic.getOptimal())) mimic_times.append(end - start) #print "MIMIC: " + str(ef.value(mimic.getOptimal())) with open('knapsack.csv', 'w') as csvfile: writer = csv.writer(csvfile) writer.writerow(rhc_results) writer.writerow(rhc_times) writer.writerow(sa_results) writer.writerow(sa_times) writer.writerow(ga_results) writer.writerow(ga_times) writer.writerow(mimic_results) writer.writerow(mimic_times) return rhc_results, rhc_times, sa_results, sa_times, ga_results, ga_times, mimic_results, mimic_times
ga = StandardGeneticAlgorithm(200, 100, 10, genetic_problem) t0 = time() iters = 0 score = 0 f.write("starting GA\n") while iters < 5000: ga.train() score = ef.value(ga.getOptimal()) f.write(str(iters) + "," + str(score) +"\n") iters += 1 print "GA: " + str(ef.value(ga.getOptimal())), "time taken", time() - t0, "Iterations", iters mimic = MIMIC(200, 100, probablistic_optimization) score = 0 t0 = time() iters = 0 f.write("starting MIMIC\n") while iters < 1000: mimic.train() score = ef.value(mimic.getOptimal()) f.write(str(iters) + "," + str(score) +"\n") iters += 1 print "MIMIC: " + str(ef.value(mimic.getOptimal())), "time taken", time() - t0, "Iterations", iters
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) rhc = RandomizedHillClimbing(hcp) fit = FixedIterationTrainer(rhc, 200000) fit.train() print "RHC: " + str(ef.value(rhc.getOptimal())) sa = SimulatedAnnealing(1E11, .95, hcp) fit = FixedIterationTrainer(sa, 200000) fit.train() print "SA: " + str(ef.value(sa.getOptimal())) ga = StandardGeneticAlgorithm(200, 100, 10, gap) fit = FixedIterationTrainer(ga, 1000) fit.train() print "GA: " + str(ef.value(ga.getOptimal())) mimic = MIMIC(200, 20, pop) fit = FixedIterationTrainer(mimic, 1000) fit.train() print "MIMIC: " + str(ef.value(mimic.getOptimal()))
path = [] for x in range(0, N): path.append(ga.getOptimal().getDiscrete(x)) print(path) # MIMIC # for mimic we use a sort encoding for i in range(trials): ef = TravelingSalesmanSortEvaluationFunction(points) fill = [N] * N ranges = array('i', fill) odd = DiscreteUniformDistribution(ranges) df = DiscreteDependencyTree(.1, ranges) pop = GenericProbabilisticOptimizationProblem(ef, odd, df) mimic = MIMIC(500, 100, pop) fit = FixedIterationTrainer(mimic, 1000) start = clock() fit.train() end = clock() total_time = end - start max_fit = ef.value(mimic.getOptimal()) time_optimum = [total_time, max_fit] mimic_data.append(time_optimum) print "MIMIC Inverse of Distance: " + str(ef.value(mimic.getOptimal())) print "Route:" path = [] optimal = mimic.getOptimal() fill = [0] * optimal.size() ddata = array('d', fill) for i in range(0, len(ddata)):
print "RHC Inverse of Distance: " + str(ef.value(rhc.getOptimal())) sa = SimulatedAnnealing(1E9, .98, hcp) fit = FixedIterationTrainer(sa, 200000) score_SA.append(train(sa, "SA", ef, 200000, "test", expt)) print "SA Inverse of Distance: " + str(ef.value(sa.getOptimal())) ga = StandardGeneticAlgorithm(225, 40, 5, gap) fit = FixedIterationTrainer(ga, 1000) score_GA.append(train(ga, "GA", ef, 40000, "test", expt)) print "GA Inverse of Distance: " + str(ef.value(ga.getOptimal())) # 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) mimic = MIMIC(150, 20, pop) fit = FixedIterationTrainer(mimic, 1000) score_MIMIC.append(train(mimic, "MIMIC", ef, 4000, "test", expt)) print "MIMIC Inverse of Distance: " + str(ef.value(mimic.getOptimal())) print("Final averaged results") print("RHC= " + str(sum(score_RHC) / len(score_RHC))) print("SA= " + str(sum(score_SA) / len(score_SA))) print("GA= " + str(sum(score_GA) / len(score_GA))) print("MIMIC= " + str(sum(score_MIMIC) / len(score_MIMIC)))
def run_traveling_salesman(): # set N value. This is the number of points N = 50 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) iters = [50, 100, 250, 500, 1000, 2500, 5000, 10000, 25000, 50000, 100000] num_repeats = 5 rhc_results = [] rhc_times = [] for i in iters: print(i) for j in range(num_repeats): start = time.time() rhc = RandomizedHillClimbing(hcp) fit = FixedIterationTrainer(rhc, i) fit.train() end = time.time() rhc_results.append(ef.value(rhc.getOptimal())) rhc_times.append(end - start) print "RHC Inverse of Distance: " + str(ef.value(rhc.getOptimal())) # print "Route:" # path = [] # for x in range(0,N): # path.append(rhc.getOptimal().getDiscrete(x)) # print path sa_results = [] sa_times = [] for i in iters: print(i) for j in range(num_repeats): start = time.time() sa = SimulatedAnnealing(1E12, .999, hcp) fit = FixedIterationTrainer(sa, i) fit.train() sa_results.append(ef.value(sa.getOptimal())) sa_times.append(end - start) print "SA Inverse of Distance: " + str(ef.value(sa.getOptimal())) # print "Route:" # path = [] # for x in range(0,N): # path.append(sa.getOptimal().getDiscrete(x)) # print path ga_results = [] ga_times = [] for i in iters: print(i) for j in range(num_repeats): start = time.time() ga = StandardGeneticAlgorithm(2000, 1500, 250, gap) fit = FixedIterationTrainer(ga, i) fit.train() end = time.time() ga_results.append(ef.value(ga.getOptimal())) print "GA Inverse of Distance: " + str(ef.value(ga.getOptimal())) ga_times.append(end - start) # print "Route:" # path = [] # for x in range(0,N): # path.append(ga.getOptimal().getDiscrete(x)) # print path # 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) mimic_results = [] mimic_times = [] for i in iters[0:6]: print(i) for j in range(num_repeats): start = time.time() mimic = MIMIC(500, 100, pop) fit = FixedIterationTrainer(mimic, i) fit.train() end = time.time() mimic_results.append(ef.value(mimic.getOptimal())) print "MIMIC Inverse of Distance: " + str( ef.value(mimic.getOptimal())) # print "Route:" # path = [] # optimal = mimic.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 mimic_times.append(end - start) with open('travelingsalesman.csv', 'w') as csvfile: writer = csv.writer(csvfile) writer.writerow(rhc_results) writer.writerow(rhc_times) writer.writerow(sa_results) writer.writerow(sa_times) writer.writerow(ga_results) writer.writerow(ga_times) writer.writerow(mimic_results) writer.writerow(mimic_times) return rhc_results, rhc_times, sa_results, sa_times, ga_results, ga_times, mimic_results, mimic_times
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) rhc = RandomizedHillClimbing(hcp) fit = FixedIterationTrainer(rhc, 2000000000) fit.train() print "RHC: " + str(ef.value(rhc.getOptimal())) sys.exit() sa = SimulatedAnnealing(100, .95, hcp) fit = FixedIterationTrainer(sa, 200000) fit.train() print "SA: " + str(ef.value(sa.getOptimal())) ga = StandardGeneticAlgorithm(200, 150, 25, gap) fit = FixedIterationTrainer(ga, 1000) fit.train() print "GA: " + str(ef.value(ga.getOptimal())) mimic = MIMIC(200, 100, pop) fit = FixedIterationTrainer(mimic, 1000) fit.train() print "MIMIC: " + str(ef.value(mimic.getOptimal()))
train(ga, exp_name, "GA", "6", ef, 40000) ga = StandardGeneticAlgorithm(200, 50, 5, gap) train(ga, exp_name, "GA", "7", ef, 40000) ga = StandardGeneticAlgorithm(100, 25, 3, gap) train(ga, exp_name, "GA", "8", ef, 40000) ga = StandardGeneticAlgorithm(50, 12, 2, gap) train(ga, exp_name, "GA", "9", ef, 40000) #### Experienet 3 - Tuning Algo Prams for MIMIC #### if True: exp_name = "exp03" mimic = MIMIC(300, 150, pop) train(mimic, exp_name, "MIMIC", "0", ef, 2000) mimic = MIMIC(300, 100, pop) train(mimic, exp_name, "MIMIC", "1", ef, 2000) mimic = MIMIC(200, 100, pop) train(mimic, exp_name, "MIMIC", "2", ef, 2000) mimic = MIMIC(200, 50, pop) train(mimic, exp_name, "MIMIC", "3", ef, 2000) mimic = MIMIC(100, 50, pop) train(mimic, exp_name, "MIMIC", "4", ef, 2000) mimic = MIMIC(100, 25, pop)