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 main(P, mate, mutate): """Run this experiment""" training_ints = initialize_instances('./../data/x_train_val.csv') testing_ints = initialize_instances('./../data/x_test.csv') factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_ints) acti = HyperbolicTangentSigmoid() rule = RPROPUpdateRule() oa_name = "GA_{}_{}_{}".format(P, mate, mutate) FILE = OUTFILE.replace('XXX', oa_name) with open(FILE, 'w') as f: f.write('{},{},{},{},{},{},{},{},{}\n'.format('iteration', 'MSE_trg', 'MSE_tst', 'acc_trg', 'acc_tst', 'f1_trg', 'f1_tst', 'train_time', 'pred_time')) classification_network = factory.createClassificationNetwork([ INPUT_LAYER, HIDDEN_LAYER1, HIDDEN_LAYER2, HIDDEN_LAYER3, HIDDEN_LAYER4, OUTPUT_LAYER ], acti) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) oa = StandardGeneticAlgorithm(P, mate, mutate, nnop) train(oa, classification_network, oa_name, training_ints, testing_ints, measure, TRAINING_ITERATIONS, FILE)
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 main(P, mate, mutate): oa_name = "GA_{}_{}_{}".format(P, mate, mutate) with open(OUTFILE.replace('XXX', oa_name), 'w') as f: f.write('{},{},{},{},{},{}\n'.format('iteration', 'MSE_train', 'MSE_test', 'acc_train', 'acc_tst', 'elapsed')) training_data = initialize_instances('../data/Pima-train.csv') testing_data = initialize_instances('../data/Pima-test.csv') print(len(training_data)) #testing_ints = initialize_instances('m_test.csv') #validation_ints = initialize_instances('m_val.csv') factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_data) relu = RELU() rule = RPROPUpdateRule() classification_network = factory.createClassificationNetwork( [INPUT_LAYER, HIDDEN_LAYER1, HIDDEN_LAYER2, OUTPUT_LAYER], relu) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) oa = StandardGeneticAlgorithm(P, mate, mutate, nnop) train(oa, classification_network, oa_name, training_data, testing_data, measure)
def main(output_filename): """Run this experiment""" training_ints = initialize_instances('out_digits_train.csv') testing_ints = initialize_instances('out_digits_test.csv') validation_ints = initialize_instances('out_digits_test.csv') factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_ints) relu = RELU() rule = RPROPUpdateRule() with open(output_filename,'w') as f: f.write('{},{},{},{},{},{},{},{}\n'.format('iteration','MSE_trg','MSE_val','MSE_tst','acc_trg','acc_val','acc_tst','elapsed')) classification_network = factory.createClassificationNetwork([INPUT_LAYER, HIDDEN_LAYER1,HIDDEN_LAYER2,HIDDEN_LAYER3, OUTPUT_LAYER],relu) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) # oa = SimulatedAnnealing(1E10, 0.95, nnop) # oa = RandomizedHillClimbing(nnop) P = 50 mate = 20 mutate = 20 oa = StandardGeneticAlgorithm(P, mate, mutate, nnop) train(oa, classification_network, output_filename, training_ints,validation_ints,testing_ints, measure)
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 ga(): for popu, mate, mutate in product([50], [30, 20, 10], [20, 10]): fname = outfile.replace('XXX', 'GA{}_{}_{}'.format(popu, mate, mutate)) with open(fname, 'w') as f: f.write('iterations,fitness,time,fevals\n') ga = StandardGeneticAlgorithm(popu, mate, mutate, gap) perform(ga, fname)
def main(P, mate, mutate): """Run this experiment""" training_ints = initialize_instances( '/Users/Sean/School/GeorgiaTech/CS7641/Assignment2/s_trg.csv') testing_ints = initialize_instances( '/Users/Sean/School/GeorgiaTech/CS7641/Assignment2/s_test.csv') validation_ints = initialize_instances( '/Users/Sean/School/GeorgiaTech/CS7641/Assignment2/s_val.csv') factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_ints) sig = LogisticSigmoid() rule = RPROPUpdateRule() oa_name = "GA_%s_%s_%s" % (P, mate, mutate) with open(OUTFILE.replace('XXX', oa_name), 'w') as f: f.write('%s,%s,%s,%s,%s,%s,%s,%s\n' % ('iteration', 'MSE_trg', 'MSE_val', 'MSE_tst', 'acc_trg', 'acc_val', 'acc_tst', 'elapsed')) classification_network = factory.createClassificationNetwork([ INPUT_LAYER, HIDDEN_LAYER1, HIDDEN_LAYER2, HIDDEN_LAYER3, OUTPUT_LAYER ], sig) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) for trial in xrange(TRIALS): oa = StandardGeneticAlgorithm(P, mate, mutate, nnop) train(oa, classification_network, oa_name, training_ints, validation_ints, testing_ints, measure)
def main(P, mate, mutate): #training_ints = initialize_instances('bCancer_trg.csv') #testing_ints = initialize_instances('bCancer_test.csv') #validation_ints = initialize_instances('bCancer_val.csv') training_ints = initialize_instances('winequality_trg.csv') testing_ints = initialize_instances('winequality_test.csv') validation_ints = initialize_instances('winequality_val.csv') factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_ints) hts = HyperbolicTangentSigmoid() rule = RPROPUpdateRule() oa_name = "GA_{}_{}_{}".format(P, mate, mutate) with open(OUTFILE.replace('XXX', oa_name), 'w') as f: f.write('{},{},{},{},{},{},{},{}\n'.format('iteration', 'MSE_trg', 'MSE_val', 'MSE_tst', 'acc_trg', 'acc_val', 'acc_tst', 'elapsed')) classification_network = factory.createClassificationNetwork( [INPUT_LAYER, HIDDEN_LAYER1, OUTPUT_LAYER], hts) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) oa = StandardGeneticAlgorithm(P, mate, mutate, nnop) train(oa, classification_network, oa_name, training_ints, validation_ints, testing_ints, measure)
def main(P, mate, mutate): """Run this experiment""" training_ints = initialize_instances('s_trg.csv') testing_ints = initialize_instances('s_test.csv') validation_ints = initialize_instances('s_val.csv') factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_ints) relu = RELU() rule = RPROPUpdateRule() oa_name = "GA_{}_{}_{}".format(P, mate, mutate) with open(OUTFILE.replace('XXX', oa_name), 'w') as f: f.write('{},{},{},{},{},{},{},{}\n'.format('iteration', 'MSE_trg', 'MSE_val', 'MSE_tst', 'acc_trg', 'acc_val', 'acc_tst', 'elapsed')) classification_network = factory.createClassificationNetwork([ INPUT_LAYER, HIDDEN_LAYER1, HIDDEN_LAYER2, HIDDEN_LAYER3, OUTPUT_LAYER ], relu) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) for trial in xrange(TRIALS): oa = StandardGeneticAlgorithm(P, mate, mutate, nnop) train(oa, classification_network, oa_name, training_ints, validation_ints, testing_ints, measure)
def main(P, mate, mutate, layers, training_iterations, test_data_file, train_data_file, validate_data_file): """Run this experiment""" training_ints = base.initialize_instances(train_data_file) testing_ints = base.initialize_instances(test_data_file) validation_ints = base.initialize_instances(validate_data_file) factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_ints) # relu = RELU() relu = LogisticSigmoid() # 50 and 0.000001 are the defaults from RPROPUpdateRule.java rule = RPROPUpdateRule(0.064, 50, 0.000001) oa_name = "GA_{}_{}_{}".format(P, mate, mutate) with open(OUTFILE.format(oa_name), 'w') as f: f.write('{},{},{},{},{},{},{},{},{},{},{}\n'.format('iteration', 'MSE_trg', 'MSE_val', 'MSE_tst', 'acc_trg', 'acc_val', 'acc_tst', 'f1_trg', 'f1_val', 'f1_tst', 'elapsed')) classification_network = factory.createClassificationNetwork( layers, relu) nnop = NeuralNetworkOptimizationProblem( data_set, classification_network, measure) oa = StandardGeneticAlgorithm(P, mate, mutate, nnop) base.train(oa, classification_network, oa_name, training_ints, validation_ints, testing_ints, measure, training_iterations, OUTFILE.format(oa_name)) return
def main(P, mate, mutate): """Run this experiment""" training_ints = initialize_instances(TRAIN_DATA_FILE) testing_ints = initialize_instances(TEST_DATA_FILE) validation_ints = initialize_instances(VALIDATE_DATA_FILE) factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_ints) relu = RELU() # 50 and 0.000001 are the defaults from RPROPUpdateRule.java rule = RPROPUpdateRule(0.064, 50, 0.000001) oa_name = "GA_{}_{}_{}".format(P, mate, mutate) with open(OUTFILE.format(oa_name), 'w') as f: f.write('{},{},{},{},{},{},{},{},{},{},{},{},{},{}\n'.format( 'iteration', 'MSE_trg', 'MSE_val', 'MSE_tst', 'acc_trg', 'acc_val', 'acc_tst', 'f1_trg', 'f1_val', 'f1_tst', 'bal_trg', 'bal_val', 'bal_tst', 'elapsed')) classification_network = factory.createClassificationNetwork( [INPUT_LAYER, HIDDEN_LAYER1, HIDDEN_LAYER2, OUTPUT_LAYER], relu) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) oa = StandardGeneticAlgorithm(P, mate, mutate, nnop) train(oa, classification_network, oa_name, training_ints, validation_ints, testing_ints, measure, TRAINING_ITERATIONS, OUTFILE.format(oa_name))
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 ga(): for popu, mate, mutate in product([50, 60, 70, 80, 90], [40, 30, 20, 10], [30, 20, 10, 5]): fname = outfile.replace('XXX','GA{}_{}_{}'.format(popu,mate,mutate)) with open(fname,'w') as f: f.write('iterations,fitness,time,fevals\n') gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf) ga = StandardGeneticAlgorithm(popu, mate, mutate, gap) perform(ga,fname)
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 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 main(): training_ints = initialize_instances('data/bank_train.csv') testing_ints = initialize_instances('data/bank_test.csv') factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_ints) acti = LogisticSigmoid() rule = RPROPUpdateRule() ######################### back prop ##################### classification_network = factory.createClassificationNetwork([INPUT_LAYER, HIDDEN_LAYER1, OUTPUT_LAYER],acti) train(BatchBackPropagationTrainer(data_set,classification_network,measure,rule,), classification_network, 'Backprop', training_ints,testing_ints, measure, './ANN/BP/BACKPROP_LOG.csv', 2000) ######################### simulated annealing ################# for CE in [0.15,0.35,0.55,0.75,0.95]: for T in [1e8,1e10,1e12]: classification_network = factory.createClassificationNetwork([INPUT_LAYER, HIDDEN_LAYER1, OUTPUT_LAYER],acti) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) oFile = "./ANN/SA/%s_%s_LOG.csv"%(CE,T) train(SimulatedAnnealing(T, CE, nnop), classification_network, 'simulated annealing', training_ints, testing_ints, measure, oFile, 2000) ######################### random hill climbing ################# classification_network = factory.createClassificationNetwork([INPUT_LAYER, HIDDEN_LAYER1, OUTPUT_LAYER],acti) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) train(RandomizedHillClimbing(nnop), classification_network, 'RHC', training_ints, testing_ints, measure, './ANN/RHC/RHC_LOG.csv', 2000) ######################### genetic algorithm ################# for P in [100]: for mate in [5, 15, 30]: for mutate in [5,15,30]: classification_network = factory.createClassificationNetwork([INPUT_LAYER, HIDDEN_LAYER1, OUTPUT_LAYER],acti) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) oFile = "./ANN/GA/%s_%s_%s_LOG.csv"%(P, mate, mutate) train(StandardGeneticAlgorithm(P, mate, mutate, nnop), classification_network, 'GA', training_ints, testing_ints, measure, oFile, 2000)
def main(): """Run algorithms on the abalone dataset.""" instances = initialize_instances() factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(instances) networks = [] # BackPropagationNetwork nnop = [] # NeuralNetworkOptimizationProblem oa = [] # OptimizationAlgorithm oa_names = ["RHC", "SA", "GA"] results = "" for name in oa_names: classification_network = factory.createClassificationNetwork([INPUT_LAYER, HIDDEN_LAYER, OUTPUT_LAYER]) networks.append(classification_network) nnop.append(NeuralNetworkOptimizationProblem(data_set, classification_network, measure)) oa.append(RandomizedHillClimbing(nnop[0])) oa.append(SimulatedAnnealing(1E11, .95, nnop[1])) oa.append(StandardGeneticAlgorithm(200, 100, 10, nnop[2])) for i, name in enumerate(oa_names): start = time.time() correct = 0 incorrect = 0 train(oa[i], networks[i], oa_names[i], instances, measure) end = time.time() training_time = end - start optimal_instance = oa[i].getOptimal() networks[i].setWeights(optimal_instance.getData()) start = time.time() for instance in instances: networks[i].setInputValues(instance.getData()) networks[i].run() predicted = instance.getLabel().getContinuous() actual = networks[i].getOutputValues().get(0) if abs(predicted - actual) < 0.5: correct += 1 else: incorrect += 1 end = time.time() testing_time = end - start results += "\nResults for %s: \nCorrectly classified %d instances." % (name, correct) results += "\nIncorrectly classified %d instances.\nPercent correctly classified: %0.03f%%" % (incorrect, float(correct)/(correct+incorrect)*100.0) results += "\nTraining time: %0.03f seconds" % (training_time,) results += "\nTesting time: %0.03f seconds\n" % (testing_time,) print results
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 main(): """Run algorithms on the adult dataset.""" train_instances = initialize_instances(trainX) test_instances = initialize_instances(testX) factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(train_instances) networks = [] # BackPropagationNetwork nnop = [] # NeuralNetworkOptimizationProblem oa = [] # OptimizationAlgorithm oa_names = ["RHC", "SA", "GA", "BP"] print(sys.argv) if len(sys.argv) > 1: oa_names = [sys.argv[1]] set_num = sys.argv[2] # results = "" for name in oa_names: classification_network = factory.createClassificationNetwork( [INPUT_LAYER, HIDDEN_LAYER, OUTPUT_LAYER], RELU()) networks.append(classification_network) if name != "BP": nnop.append( NeuralNetworkOptimizationProblem(data_set, classification_network, measure)) else: print("adding backprop") rule = RPROPUpdateRule() nnop.append( BatchBackPropagationTrainer(data_set, classification_network, measure, rule)) if "RHC" in oa_names: rhc_index = oa_names.index("RHC") oa.append(RandomizedHillClimbing(nnop[rhc_index])) if "SA" in oa_names: sa_index = oa_names.index("SA") oa.append(SimulatedAnnealing(1E11, .95, nnop[sa_index])) if "GA" in oa_names: ga_index = oa_names.index("GA") oa.append(StandardGeneticAlgorithm(100, 50, 10, nnop[ga_index])) if "BP" in oa_names: rule = RPROPUpdateRule() bp_index = oa_names.index("BP") oa.append(nnop[bp_index]) for i, name in enumerate(oa_names): train(oa[i], networks[i], oa_names[i], train_instances, test_instances, measure)
def GA(): correctCount = 0 t = 0 totalTime = 0 #GA_iters=1 attempts = 0 threshold = .1 iters = 0 NUM_ITERS = 10 global ga, GA_keep, GA_mut ga = StandardGeneticAlgorithm(int(GA_pop), GA_keep, GA_mut, gap) while correctCount < 1 and attempts <= 50000: attempts += 1 start = time.time() fit = ConvergenceTrainer( ga, threshold, NUM_ITERS) #FixedIterationTrainer(ga, int(GA_iters)) fitness = fit.train() t = time.time() - start totalTime += t iters += fit.getIterations() myWriter.addValue(fitness, "GA_fitness", runNum) myWriter.addValue(t, "GA_searchTimes", runNum) v = ef.value(ga.getOptimal()) if v == N: correctCount += 1 #print "GA correct with v " + str(v) +" correctCount = "+ str (correctCount) else: if fit.getIterations( ) < NUM_ITERS: #it hit its iters and still got it wrong, so the threshold was too low threshold /= 10 correctCount = 0 #GA_pop += N #5*N#*=1.2 #GA_iters *= 1.5 # GA_mut = int(GA_pop * .25) #GA_keep = int(GA_pop * .80) myWriter.addValue(totalTime, "GA_times", 0) myWriter.addValue(iters, "GA_iters", 0) myWriter.addValue(int(GA_pop), "GA_pop", 0) myWriter.addValue(int(GA_mut), "GA_mut", 0) myWriter.addValue(int(GA_keep), "GA_keep", 0) myWriter.addValue(threshold, "GA_threshold", 0) print( str(N) + ": GA: " + str(ef.value(ga.getOptimal())) + " took " + str(totalTime) + " seconds and " + str(iters) + " iters w/ pop " + str(GA_pop) + " mut " + str(GA_mut) + " keep " + str(GA_keep) + " for fitness " + str(fitness) + " in " + str(attempts) + " attempts " + " thresh " + str(threshold))
def PopulationRangeExperiment(name, points, popRange, mateRange, mutRange, iterRange, mat): lastRow = -1 for idx,i in enumerate(popRange): for jdx, j in enumerate(mateRange): print('.') for kdx, k in enumerate(mutRange): row = idx * len(mateRange)*len(mutRange) + jdx*len(mutRange)+ kdx if row < lastRow: print "ERROR in ROW CALC!" lastRow = row if j > i or k > i: #print "skipping bad values for i,j,k " continue ga = StandardGeneticAlgorithm(i, j, k, gap) helpers.IterRangeExperiment(name, ga, points, iterRange, mat, row)
def run_experiment(self, train, test, validation): """Run experiment Args: train (list): List of training instances. test (list): List of test instances. validation (list): List of validation instances. """ factory = BackPropagationNetworkFactory() # instantiate main NN class params = [ self.input_layer, self.hidden_layer_one, self.hidden_layer_two, self.output_layer ] self.network = factory.createClassificationNetwork(params) dataset = DataSet(train) # setup training instances dataset nnop = NeuralNetworkOptimizationProblem(dataset, self.network, self.measure) oa = None # get output file name outpath = 'results/NN' filename = None # options for different optimization algorithms if self.oaName == 'BP': filename = '{}/results.csv'.format(self.oaName) rule = RPROPUpdateRule() oa = BatchBackPropagationTrainer(dataset, self.network, self.measure, rule) elif self.oaName == 'RHC': filename = '{}/results.csv'.format(self.oaName) oa = RandomizedHillClimbing(nnop) elif self.oaName == 'SA': filename = '{}/results_{}_{}.csv'.format(self.oaName, self.SA_T, self.SA_C) oa = SimulatedAnnealing(self.SA_T, self.SA_C, nnop) elif self.oaName == 'GA': filename = '{}/results_{}_{}_{}.csv'.format( self.oaName, self.GA_P, self.GA_MA, self.GA_MU) oa = StandardGeneticAlgorithm(self.GA_P, self.GA_MA, self.GA_MU, nnop) # train network filepath = get_abspath(filename, outpath) self.train(oa, train, test, validation, filepath)
def main(P, mate, mutate): """Run this experiment""" training_ints = initialize_instances('./clean_data/adult_train.txt') testing_ints = initialize_instances('./clean_data/adult_test.txt') factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(training_ints) logunit = LogisticSigmoid() rule = RPROPUpdateRule() oa_name = "\nGA_tuning: %d , %d, %d\n" % (P, mate, mutate) classification_network = factory.createClassificationNetwork( [INPUT_LAYER, HIDDEN_LAYER, OUTPUT_LAYER]) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) oa = StandardGeneticAlgorithm(P, mate, mutate, nnop) train(oa, classification_network, oa_name, training_ints, testing_ints, measure)
def initialize_networks_and_optimization(networks, nnop, oa, instances, factory=BackPropagationNetworkFactory(), measure = SumOfSquaresError()): del networks[:] del nnop[:] del oa[:] data_set = DataSet(instances) for _ in OA_NAMES: classification_network = factory.createClassificationNetwork([ INPUT_LAYER, HIDDEN_LAYER, OUTPUT_LAYER], LogisticSigmoid()) networks.append(classification_network) nnop.append(NeuralNetworkOptimizationProblem(data_set, classification_network, measure)) oa.append(RandomizedHillClimbing(nnop[0])) oa.append(SimulatedAnnealing(1E11, .95, nnop[1])) oa.append(StandardGeneticAlgorithm(200, 100, 10, nnop[2]))
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() classification_network = factory.createClassificationNetwork( [INPUT_LAYER, HIDDEN_LAYER1, OUTPUT_LAYER], logistic_sigmoid) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) oa = StandardGeneticAlgorithm(data_set_size, int(0.5 * data_set_size), int(0.1 * data_set_size), nnop) train(oa, classification_network, 'GA', training_ints, validation_ints, testing_ints, measure)
def main(): """Run algorithms on the abalone dataset.""" train_instances = initialize_instances(TRAIN_FILE) test_instances = initialize_instances(TEST_FILE) factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(train_instances) networks = [] # BackPropagationNetwork nnop = [] # NeuralNetworkOptimizationProblem oa = [] # OptimizationAlgorithm params = [(200, 100, 25), (200, 100, 50)] oa_names = [','.join(map(str, item)) for item in params] results = "" for name in oa_names: classification_network = factory.createClassificationNetwork([INPUT_LAYER, HIDDEN_LAYER_1, HIDDEN_LAYER_1, OUTPUT_LAYER]) networks.append(classification_network) nnop.append(NeuralNetworkOptimizationProblem(data_set, classification_network, measure)) for num, params in enumerate(params): oa.append(StandardGeneticAlgorithm(params[0], params[1], params[2], nnop[num])) result_file = open(WRITE_DIR, "w") for i, name in enumerate(oa_names): start = time.time() train(oa[i], networks[i], oa_names[i], train_instances, measure, result_file) end = time.time() training_time = end - start optimal_instance = oa[i].getOptimal() networks[i].setWeights(optimal_instance.getData()) test(test_instances, networks[i], name, result_file) print "finished training, " + name print results
def run_ga(t, pop, mate, mutate): fname = outfile.format('GA{}_{}_{}'.format(pop, mate, mutate), str(t + 1)) ef = TravelingSalesmanRouteEvaluationFunction(points) 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 Genetic_algorithm(out_path, train_inst, test_inst, P, mate, mutate, training_iterations): """Run this experiment""" factory = BackPropagationNetworkFactory() measure = SumOfSquaresError() data_set = DataSet(train_inst) # acti = LogisticSigmoid() acti = HyperbolicTangentSigmoid() rule = RPROPUpdateRule() oa_name = "GA_P{}_mate{}_mut{}".format(P, mate, mutate) with open(out_path.replace('GA_', oa_name), 'w') as f: f.write('{},{},{},{},{},{}\n'.format('iteration', 'MSE_trg', 'MSE_tst', 'acc_trg', 'acc_tst', 'elapsed')) classification_network = factory.createClassificationNetwork( [INPUT_LAYER, HIDDEN_LAYER1, HIDDEN_LAYER2, OUTPUT_LAYER], acti) nnop = NeuralNetworkOptimizationProblem(data_set, classification_network, measure) oa = StandardGeneticAlgorithm(P, mate, mutate, nnop) train(oa, classification_network, oa_name, train_inst, test_inst, measure, training_iterations, out_path.replace('GA_', oa_name))
f.write(st) # GA for t in range(numTrials): for pop, mate, mutate in product([100], [50, 30, 10], [50, 30, 10]): fname = outfile.format('GA{}_{}_{}'.format(pop, mate, mutate), 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) 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) with open(fname, 'a') as f: f.write(st)