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 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_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 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 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 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
fit.train()
value += ef.value(sa.getOptimal())
end = time.time()
clock_time = (end - start) / nsample
value = round(value / nsample, 2)
print "SA " + str(value), iters, clock_time
#-- Genetic Algorithm
ga = StandardGeneticAlgorithm(200, 100, 10, gap)
for iters in niters:
start = time.time()
fit = FixedIterationTrainer(ga, iters)
value = 0
for isample in range(nsample):
fit.train()
value += ef.value(ga.getOptimal())
end = time.time()
clock_time = (end - start) / nsample
value = round(value / nsample, 2)
print "GA " + str(value), iters, clock_time
#-- MIMIC bla bla
mimic = MIMIC(200, 20, pop)
niters = [50, 200, 500, 800, 1000, 1200, 1500, 2000, 4000, 10000]
for iters in niters:
start = time.time()
fit = FixedIterationTrainer(mimic, iters)
value = 0
for isample in range(nsample):
fit.train()
value += ef.value(mimic.getOptimal())
ef = CountOnesEvaluationFunction()
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)
t0 = time.time()
calls = []
results = []
for _ in range(runs):
ga = StandardGeneticAlgorithm(ga_pop, ga_keep, ga_mut, gap)
fit = FixedIterationTrainer(ga, 150)
fitness = fit.train()
results.append(ef.value(ga.getOptimal()))
calls.append(ef.getTotalCalls())
ef.clearCount()
print "GA, average results , " + str(
sum(results) / float(runs)) + ", countones_ga_%d-%d-%d-%d-%d.txt" % (
N, ga_pop, co_type, ga_keep, ga_mut)
print "GA, average feval calls , " + str(
sum(calls) / float(runs)) + ", countones_ga_%d-%d-%d-%d-%d.txt" % (
N, ga_pop, co_type, ga_keep, ga_mut)
t1 = time.time() - t0
print "GA, average time , " + str(
t1 / float(runs)) + ", countones_ga_%d-%d-%d-%d-%d.txt" % (
N, ga_pop, co_type, ga_keep, ga_mut)
print " RHC test confusion matrix:", confusionMatrix(network_rhc, test) # learn weights with simulated annealing network_sa = factory.createClassificationNetwork([inputLayer, hiddenLayer, outputLayer]) nnop_sa = NeuralNetworkOptimizationProblem(set, network_sa, measure) sa = SimulatedAnnealing(1E11, 0.95, nnop_sa) fit = FixedIterationTrainer(sa, it_sa) fit.train() op = sa.getOptimal(); network_sa.setWeights(op.getData()) print "\nSA training error:", errorRate(network_sa, train) print "SA training confusion matrix:", confusionMatrix(network_sa, train) print " SA test error:", errorRate(network_sa, test) print " SA test confusion matrix:", confusionMatrix(network_sa, test) exit() # learn weights with generic algorithms network_ga = factory.createClassificationNetwork([inputLayer, hiddenLayer, outputLayer]) nnop_ga = NeuralNetworkOptimizationProblem(set, network_ga, measure) ga = StandardGeneticAlgorithm(200, 100, 10, nnop_ga) fit = FixedIterationTrainer(ga, it_ga) fit.train() op = ga.getOptimal(); network_ga.setWeights(op.getData()) print "\nGA training error:", errorRate(network_ga, train) print "GA training confusion matrix:", confusionMatrix(network_ga, train) print " GA test error:", errorRate(network_ga, test) print " GA test confusion matrix:", confusionMatrix(network_ga, test)
def main():
# 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
iterations = 20000
gaIters = 1000
mimicIters = 1000
gaPop = 200
gaMate = 150
gaMutate = 25
mimicSamples = 200
mimicToKeep = 100
saTemp = 100
saCooling = .95
alg = 'all'
run = 0
settings = []
try:
opts, args = getopt.getopt(sys.argv[1:], "ahrsgmn:N:c:w:v:i:", ["gaIters=", "mimicIters=","gaPop=", "gaMate=", "gaMutate=", "mimicSamples=", "mimicToKeep=", "saTemp=", "saCooling="])
except:
print 'knapsack.py -i <iterations> -n <NUM_ITEMS> -c <COPIES_EACH> -w <MAX_WEIGHT> -v <MAX_VOLUME>'
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print 'knapsack.py -i <iterations> -n <NUM_ITEMS> -c <COPIES_EACH> -w <MAX_WEIGHT> -v <MAX_VOLUME>'
sys.exit(1)
elif opt == '-i':
iterations = int(arg)
elif opt == '-N':
NUM_ITEMS = int(arg)
elif opt == '-c':
COPIES_EACH = int(arg)
elif opt == '-w':
MAX_WEIGHT = int(arg)
elif opt == '-v':
MAX_VOLUME = int(arg)
elif opt == '-n':
run = int(arg)
elif opt == '-r':
alg = 'RHC'
elif opt == '-s':
alg = 'SA'
elif opt == '-g':
alg = 'GA'
elif opt == '-m':
alg = 'MIMIC'
elif opt == '-a':
alg = 'all'
elif opt == '--gaPop':
gaPop = int(arg)
elif opt == '--gaMate':
gaMate = int(arg)
elif opt == '--gaMutate':
gaMutate = int(arg)
elif opt == '--mimicSamples':
mimicSamples = int(arg)
elif opt == '--mimicToKeep':
mimicToKeep = int(arg)
elif opt == '--saTemp':
saTemp = float(arg)
elif opt == '--saCooling':
saCooling = float(arg)
elif opt == '--gaIters':
gaIters = int(arg)
elif opt == '--mimicIters':
mimicIters = int(arg)
vars ={
'NUM_ITEMS' : NUM_ITEMS,
'COPIES_EACH' : COPIES_EACH,
'MAX_WEIGHT' : MAX_WEIGHT,
'MAX_VOLUME' : MAX_VOLUME,
'iterations' : iterations,
'gaIters' : gaIters,
'mimicIters' : mimicIters,
'gaPop' : gaPop,
'gaMate' : gaMate,
'gaMutate' : gaMutate,
'mimicSamples' : mimicSamples,
'mimicToKeep' : mimicToKeep,
'saTemp' : saTemp,
'saCooling' : saCooling,
'alg' : alg,
'run' : run
}
settings = getSettings(alg, settings, vars)
# Random number generator */
random = Random()
# The volume of the knapsack
KNAPSACK_VOLUME = MAX_VOLUME * NUM_ITEMS * COPIES_EACH * .4
# create copies
fill = [COPIES_EACH] * NUM_ITEMS
copies = array('i', fill)
# create weights and volumes
fill = [0] * NUM_ITEMS
weights = array('d', fill)
volumes = array('d', fill)
for i in range(0, NUM_ITEMS):
weights[i] = random.nextDouble() * MAX_WEIGHT
volumes[i] = random.nextDouble() * MAX_VOLUME
# create range
fill = [COPIES_EACH + 1] * NUM_ITEMS
ranges = array('i', fill)
ef = KnapsackEvaluationFunction(weights, volumes, KNAPSACK_VOLUME, copies)
odd = DiscreteUniformDistribution(ranges)
nf = DiscreteChangeOneNeighbor(ranges)
mf = DiscreteChangeOneMutation(ranges)
cf = UniformCrossOver()
df = DiscreteDependencyTree(.1, ranges)
hcp = GenericHillClimbingProblem(ef, odd, nf)
gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf)
pop = GenericProbabilisticOptimizationProblem(ef, odd, df)
if alg == 'RHC' or alg == 'all':
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, iterations)
fit.train()
print "RHC: " + str(ef.value(rhc.getOptimal()))
rows = []
row = []
row.append("Evaluation Function Value")
row.append(str(ef.value(rhc.getOptimal())))
rows.append(row)
output2('Knapsack', 'RHC', rows, settings)
rows = []
buildFooter("Knapsack", "RHC", rows, settings)
outputFooter("Knapsack", "RHC", rows , settings)
if alg == 'SA' or alg == 'all':
sa = SimulatedAnnealing(saTemp, saCooling, hcp)
fit = FixedIterationTrainer(sa, iterations)
fit.train()
rows = []
row = []
row.append("Evaluation Function Value")
row.append(ef.value(sa.getOptimal()))
rows.append(row)
print "SA: " + str(ef.value(sa.getOptimal()))
output2('Knapsack', 'SA', rows, settings)
rows = []
buildFooter("Knapsack", "SA", rows, settings)
outputFooter("Knapsack", "SA", rows, settings)
if alg == 'GA' or alg == 'all':
ga = StandardGeneticAlgorithm(gaPop, gaMate, gaMutate, gap)
fit = FixedIterationTrainer(ga, gaIters)
fit.train()
rows = []
row = []
row.append("Evaluation Function Value")
row.append(ef.value(ga.getOptimal()))
rows.append(row)
print "GA: " + str(ef.value(ga.getOptimal()))
output2('Knapsack', 'GA', rows, settings)
buildFooter("Knapsack", "GA", rows, settings)
outputFooter("Knapsack", "GA", rows , settings)
if alg == 'MIMIC' or alg == 'all':
mimic = MIMIC(mimicSamples, mimicToKeep, pop)
fit = FixedIterationTrainer(mimic, mimicIters)
fit.train()
print "MIMIC: " + str(ef.value(mimic.getOptimal()))
rows = []
row = []
row.append("Evaluation Function Value")
row.append(ef.value(mimic.getOptimal()))
rows.append(row)
output2('Knapsack', 'MIMIC', rows, settings)
rows = []
buildFooter("Knapsack", "MIMIC", rows, settings)
outputFooter("Knapsack", "MIMIC", rows , settings)
while iters < 80000:
score = sa.train()
f.write(str(iters) + "," + str(score) + "\n")
iters += 1
print "SA: " + str(ef.value(sa.getOptimal())), "time taken", time() - t0, "Iterations", iters
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")
start_mimic = time.time()
fit_mimic.train()
end_mimic = time.time()
# Result handling
last_train_time_rhc = end_rhc - start_rhc
rhc_train_time[repetition].append(last_train_time_rhc)
rhc_accuracy[repetition].append(ef.value(rhc.getOptimal()))
last_train_time_sa = end_sa - start_sa
sa_train_time[repetition].append(last_train_time_sa)
sa_accuracy[repetition].append(ef.value(sa.getOptimal()))
last_train_time_ga = end_ga - start_ga
ga_train_time[repetition].append(last_train_time_ga)
ga_accuracy[repetition].append(ef.value(ga.getOptimal()))
last_train_time_mimic = end_mimic - start_mimic
mimic_train_time[repetition].append(last_train_time_mimic)
mimic_accuracy[repetition].append(ef.value(mimic.getOptimal()))
while current_iteration_count <= MAX_ITERATION - ITERATION_STEP:
print("Computing for %d iterations" %
(current_iteration_count + ITERATION_STEP))
# Trainer declaration
fit_rhc = FixedIterationTrainer(rhc, ITERATION_STEP)
fit_sa = FixedIterationTrainer(sa, ITERATION_STEP)
fit_ga = FixedIterationTrainer(ga, ITERATION_STEP)
fit_mimic = FixedIterationTrainer(mimic, ITERATION_STEP)
# Fitting
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)
start = time.time()
ga = StandardGeneticAlgorithm(200, 150, 25, gap)
fit = FixedIterationTrainer(ga, 1000)
fit.train()
end = time.time()
value = str(ef.value(ga.getOptimal()))
# print "GA: " + value
# print "Time -->", end - start
results = {
'num_iterations': num_iterations,
'value': value,
'time': end - start
}
print 'GA', param, results
writer.writerow(results)
csv_file.close()
print '------'
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)
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)
start = time.time()
ga = StandardGeneticAlgorithm(param[0], param[1], param[2], gap)
fit = FixedIterationTrainer(ga, num_iterations)
fit.train()
value = str(ef.value(ga.getOptimal()))
print "GA Inverse of Distance: " + value
end = time.time()
print "Route:"
path = []
for x in range(0, N):
path.append(ga.getOptimal().getDiscrete(x))
print path
print "Time -->", end - start
results = {
'num_iterations': num_iterations,
'value': value,
'time': end - start
}
def main():
iterations = 200000
alg = 'all'
gaPop = 2000
gaMate = 1500
gaMutate = 250
mimicSamples = 500
mimicToKeep = 100
saTemp = 1E12
saCooling = .999
gaIters = 1000
mimicIters = 1000
run = 0
settings = []
try:
opts, args = getopt.getopt(sys.argv[1:], "ahrsgmn:i:", ["gaIters=", "mimicIters=", "gaPop=", "gaMate=", "gaMutate=", "mimicSamples=", "mimicToKeep=", "saTemp=", "saCooling="])
except:
print 'travelingsalesman.py -i <iterations>'
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print 'travelingsalesman.py -i <iterations>'
sys.exit(1)
elif opt == '-i':
if arg < 1:
print 'Iterations must be greater than 0'
sys.exit(2)
iterations = int(arg)
elif opt == '-a':
alg = 'all'
elif opt == '-r':
alg = 'RHC'
elif opt == '-s':
alg = 'SA'
elif opt == '-g':
alg = 'GA'
elif opt == '-m':
alg = 'MIMIC'
elif opt == '--gaPop':
if arg < 1:
print 'Population must be greater than 0'
sys.exit(2)
gaPop = int(arg)
elif opt == '--gaMate':
if arg < 1:
print 'Mating must be greater than 0'
sys.exit(2)
gaMate = int(arg)
elif opt == '--gaMutate':
if arg < 1:
print 'Mutators must be greater than 0'
sys.exit(2)
gaMutate = int(arg)
elif opt == '--mimicSamples':
if arg < 1:
print 'MIMIC samples must be greater than 0'
sys.exit(2)
mimicSamples = int(arg)
elif opt == '--mimicToKeep':
if arg < 1:
print 'MIMIC to keep must be greater than 0'
sys.exit(2)
mimicToKeep = int(arg)
elif opt == '--saTemp':
saTemp = float(arg)
elif opt == '--saCooling':
saCooling = float(arg)
elif opt == '-n':
run = int(arg)
elif opt == '--gaIters':
if arg < 1:
print 'GA Iterations must be greater than 0'
sys.exit(2)
gaIters = int(arg)
elif opt == '--mimicIters':
if arg < 1:
print 'MIMIC Iterations must be greater than 0'
sys.exit(2)
mimicIters = int(arg)
vars = {
'iterations' : iterations,
'alg' : alg,
'gaPop' : gaPop,
'gaMate' : gaMate,
'gaMutate' : gaMutate,
'mimicSamples' : mimicSamples,
'mimicToKeep' : mimicToKeep,
'saTemp' : saTemp,
'saCooling' : saCooling,
'gaIters' : gaIters,
'mimicIters' : mimicIters,
'run' : run
}
settings = getSettings(alg, settings, vars)
if gaPop < gaMate or gaPop < gaMutate or gaMate < gaMutate:
pebkac({gaPop: 'total population',gaMate : 'mating population', gaMutate : 'mutating population'}, alg, 'total population', settings)
if mimicSamples < mimicToKeep:
pebkac({mimicSamples: 'mimic samples', mimicToKeep : 'mimic to keep'}, alg, 'mimic samples', settings)
prob = 'Traveling Sales Problem'
invDist = {}
cities = CityList()
N = len(cities)
#random = Random()
points = [[0 for x in xrange(2)] for x in xrange(N)]
for i in range(0, len(points)):
coords = cities.getCoords(i)
points[i][0] = coords[0]
points[i][1] = coords[1]
ef = TravelingSalesmanRouteEvaluationFunction(points)
odd = DiscretePermutationDistribution(N)
nf = SwapNeighbor()
mf = SwapMutation()
cf = TravelingSalesmanCrossOver(ef)
hcp = GenericHillClimbingProblem(ef, odd, nf)
gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf)
rows = []
if alg == 'RHC' or alg == 'all':
print '\n----------------------------------'
print 'Using Random Hill Climbing'
for label, setting in settings:
print label + ":" + str(setting)
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, iterations)
fit.train()
path = []
for x in range(0,N):
path.append(rhc.getOptimal().getDiscrete(x))
output(prob, 'RHC', path, points, settings)
rows = []
row = []
row.append("Inverse of Distance")
row.append(ef.value(rhc.getOptimal()))
rows.append(row)
invDist['RHC'] = ef.value(rhc.getOptimal())
buildFooter(prob, 'RHC', rows, settings)
outputFooter(prob, 'RHC', rows, settings)
if alg == 'SA' or alg == 'all':
print 'Using Simulated Annealing'
for label, setting in settings:
print label + ":" + str(setting)
sa = SimulatedAnnealing(saTemp, saCooling, hcp)
fit = FixedIterationTrainer(sa, iterations)
fit.train()
path = []
for x in range(0,N):
path.append(sa.getOptimal().getDiscrete(x))
output(prob, 'SA', path, points, settings)
rows = []
row = []
row.append("Inverse of Distance")
row.append(ef.value(sa.getOptimal()))
rows.append(row)
invDist['SA'] = ef.value(sa.getOptimal())
buildFooter(prob, 'SA', rows, settings)
outputFooter(prob, 'SA', rows, settings)
if alg == 'GA' or alg == 'all':
print '\n----------------------------------'
print 'Using Genetic Algorithm'
for label, setting in settings:
print label + ":" + str(setting)
ga = StandardGeneticAlgorithm(gaPop, gaMate, gaMutate, gap)
fit = FixedIterationTrainer(ga, gaIters)
fit.train()
path = []
for x in range(0,N):
path.append(ga.getOptimal().getDiscrete(x))
output(prob, 'GA', path, points, settings)
rows = []
row = []
row.append("Inverse of Distance")
row.append(ef.value(ga.getOptimal()))
rows.append(row)
invDist['GA'] = ef.value(ga.getOptimal())
buildFooter(prob, 'GA', rows, settings)
outputFooter(prob, 'GA', rows, settings)
if alg == 'MIMIC' or alg == 'all':
print '\n----------------------------------'
print 'Using MIMIC'
for label, setting in settings:
print label + ":" + str(setting)
# 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(mimicSamples, mimicToKeep, pop)
fit = FixedIterationTrainer(mimic, mimicIters)
fit.train()
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)
output(prob, 'MIMIC', order, points, settings)
rows = []
row = []
row.append("Inverse of Distance")
row.append(ef.value(mimic.getOptimal()))
rows.append(row)
invDist['MIMIC'] = ef.value(mimic.getOptimal())
buildFooter(prob, 'MIMIC', rows, settings)
outputFooter(prob, 'MIMIC', rows, settings)
maxn = max(len(key) for key in invDist)
maxd = max(len(str(invDist[key])) for key in invDist)
print "Results"
for result in invDist:
print "%-*s %s %-*s" % (len('Best Alg') + 2, result, ':', maxd, invDist[result])
if alg == 'all':
print "%-*s %s %-*s" % (len('Best Alg') + 2, 'Best Alg', ':', maxd, max(invDist.iterkeys(), key=(lambda key: invDist[key])))
print '----------------------------------'
def fourpeaksfunc(N, iterations):
rhcMult = 200
saMult = 200
gaMult = 2
mimicMult = 1
optimalOut = []
timeOut = []
evalsOut = []
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)
for niter in iterations:
iterOptimalOut = [N, niter]
iterTimeOut = [N, niter]
iterEvals = [N, niter]
start = time.time()
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, niter * rhcMult)
fit.train()
end = time.time()
rhcOptimal = ef.value(rhc.getOptimal())
rhcTime = end - start
print "RHC optimum: " + str(rhcOptimal)
print "RHC time: " + str(rhcTime)
iterOptimalOut.append(rhcOptimal)
iterTimeOut.append(rhcTime)
functionEvals = ef.getNumEvals()
ef.zeroEvals()
iterEvals.append(functionEvals)
start = time.time()
sa = SimulatedAnnealing(1E20, .8, hcp)
fit = FixedIterationTrainer(sa, niter * saMult)
fit.train()
end = time.time()
saOptimal = ef.value(sa.getOptimal())
saTime = end - start
print "SA optimum: " + str(saOptimal)
print "SA time: " + str(saTime)
iterOptimalOut.append(saOptimal)
iterTimeOut.append(saTime)
functionEvals = ef.getNumEvals()
ef.zeroEvals()
iterEvals.append(functionEvals)
start = time.time()
ga = StandardGeneticAlgorithm(200, 100, 10, gap)
fit = FixedIterationTrainer(ga, niter * gaMult)
fit.train()
end = time.time()
gaOptimal = ef.value(ga.getOptimal())
gaTime = end - start
print "GA optimum: " + str(gaOptimal)
print "GA time: " + str(gaTime)
iterOptimalOut.append(gaOptimal)
iterTimeOut.append(gaTime)
functionEvals = ef.getNumEvals()
ef.zeroEvals()
iterEvals.append(functionEvals)
start = time.time()
mimic = MIMIC(200, 20, pop)
fit = FixedIterationTrainer(mimic, niter * mimicMult)
fit.train()
end = time.time()
mimicOptimal = ef.value(mimic.getOptimal())
mimicTime = end - start
print "MIMIC optimum: " + str(mimicOptimal)
print "MIMIC time: " + str(mimicTime)
iterOptimalOut.append(mimicOptimal)
iterTimeOut.append(mimicTime)
functionEvals = ef.getNumEvals()
ef.zeroEvals()
iterEvals.append(functionEvals)
optimalOut.append(iterOptimalOut)
timeOut.append(iterTimeOut)
evalsOut.append(iterEvals)
return [optimalOut, timeOut, evalsOut]
time_optimum = [total_time, max_fit]
annealing.append(time_optimum)
print("SA Optimum: " + str(ef.value(sa.getOptimal())))
# GENETIC ALGO
for i in range(trials):
ga = StandardGeneticAlgorithm(2000, 1500, 250, gap)
fit = FixedIterationTrainer(ga, 1000)
start = clock()
fit.train()
end = clock()
total_time = end - start
max_fit = ef.value(ga.getOptimal())
time_optimum = [total_time, max_fit]
genetic.append(time_optimum)
print("GA Optimum: " + str(ef.value(ga.getOptimal())))
# MIMIC
# for mimic we use a sort encoding
for i in range(trials):
ef = FlipFlopEvaluationFunction();
fill = [N] * N
ranges = array('i', fill)
odd = DiscreteUniformDistribution(ranges);
df = DiscreteDependencyTree(.1, ranges);
pop = GenericProbabilisticOptimizationProblem(ef, odd, df);
mimic = MIMIC(500, 100, pop)
sa = SimulatedAnnealing(1e12, 0.999, hcp)
fit = FixedIterationTrainer(sa, 200000)
fit.train()
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 = StandardGeneticAlgorithm(2000, 1500, 250, gap)
fit = FixedIterationTrainer(ga, 1000)
fit.train()
print "GA Inverse of Distance: " + str(ef.value(ga.getOptimal()))
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(0.1, ranges)
pop = GenericProbabilisticOptimizationProblem(ef, odd, df)
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)
# 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)
def run_count_ones_experiments():
OUTPUT_DIRECTORY = './output'
N = 80
fill = [2] * N
ranges = array('i', fill)
ef = CountOnesEvaluationFunction()
odd = DiscreteUniformDistribution(ranges)
nf = DiscreteChangeOneNeighbor(ranges)
mf = DiscreteChangeOneMutation(ranges)
cf = SingleCrossOver()
hcp = GenericHillClimbingProblem(ef, odd, nf)
gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf)
max_iter = 5000
outfile = OUTPUT_DIRECTORY + '/count_ones_{}_log.csv'
# Randomized Hill Climber
filename = outfile.format('rhc')
with open(filename, 'w') as f:
f.write('iteration,fitness,time\n')
for it in range(0, max_iter, 10):
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, it)
start_time = time.clock()
fit.train()
elapsed_time = time.clock() - start_time
# fevals = ef.fevals
score = ef.value(rhc.getOptimal())
data = '{},{},{}\n'.format(it, score, elapsed_time)
print(data)
with open(filename, 'a') as f:
f.write(data)
# Simulated Annealing
filename = outfile.format('sa')
with open(filename, 'w') as f:
f.write('iteration,cooling_value,fitness,time\n')
for cooling_value in (.19, .38, .76, .95):
for it in range(0, max_iter, 10):
sa = SimulatedAnnealing(100, cooling_value, hcp)
fit = FixedIterationTrainer(sa, it)
start_time = time.clock()
fit.train()
elapsed_time = time.clock() - start_time
# fevals = ef.fevals
score = ef.value(sa.getOptimal())
data = '{},{},{},{}\n'.format(it, cooling_value, score, elapsed_time)
print(data)
with open(filename, 'a') as f:
f.write(data)
# Genetic Algorithm
filename = outfile.format('ga')
with open(filename, 'w') as f:
f.write('iteration,population_size,to_mate,to_mutate,fitness,time\n')
for population_size, to_mate, to_mutate in itertools.product([20], [4, 8, 16, 20], [0, 2, 4, 6]):
for it in range(0, max_iter, 10):
ga = StandardGeneticAlgorithm(population_size, to_mate, to_mutate, gap)
fit = FixedIterationTrainer(ga, it)
start_time = time.clock()
fit.train()
elapsed_time = time.clock() - start_time
# fevals = ef.fevals
score = ef.value(ga.getOptimal())
data = '{},{},{},{},{},{}\n'.format(it, population_size, to_mate, to_mutate, score, elapsed_time)
print(data)
with open(filename, 'a') as f:
f.write(data)
# MIMIC
filename = outfile.format('mm')
with open(filename, 'w') as f:
f.write('iterations,samples,to_keep,m,fitness,time\n')
for samples, to_keep, m in itertools.product([50], [10], [0.1, 0.3, 0.5, 0.7, 0.9]):
for it in range(0, 500, 10):
df = DiscreteDependencyTree(m, ranges)
pop = GenericProbabilisticOptimizationProblem(ef, odd, df)
mm = MIMIC(samples, 20, pop)
fit = FixedIterationTrainer(mm, it)
start_time = time.clock()
fit.train()
elapsed_time = time.clock() - start_time
# fevals = ef.fevals
score = ef.value(mm.getOptimal())
data = '{},{},{},{},{},{}\n'.format(it, samples, to_keep, m, score, elapsed_time)
print(data)
with open(filename, 'a') as f:
f.write(data)
def run_four_peaks():
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, 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(1E11, .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, 100, 10, gap)
fit = FixedIterationTrainer(ga, i)
fit.train()
end = time.time()
ga_results.append(ef.value(ga.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, 20, 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('four_peaks.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
def main():
"""Run algorithms on the cancer dataset."""
instances = initialize_instances()
factory = BackPropagationNetworkFactory()
measure = SumOfSquaresError()
data_set = DataSet(instances)
max_iterations = TRAINING_ITERATIONS
hidden_layer_size = HIDDEN_LAYER
# for _hidden_layer in xrange(HIDDEN_LAYER):
# hidden_layer_size = _hidden_layer + 1
network = None # BackPropagationNetwork
nnop = None # NeuralNetworkOptimizationProblem
oa = None # OptimizationAlgorithm
results = ""
for population_size in [100, 200, 400]:
RandomOrderFilter().filter(data_set)
train_test_split = TestTrainSplitFilter(TRAIN_TEST_SPLIT)
train_test_split.filter(data_set)
train_set = train_test_split.getTrainingSet()
test_set = train_test_split.getTestingSet()
network = factory.createClassificationNetwork(
[INPUT_LAYER, hidden_layer_size, OUTPUT_LAYER])
nnop = NeuralNetworkOptimizationProblem(train_set, network, measure)
oa = StandardGeneticAlgorithm(population_size, GA_MATE_EACH_GEN,
GA_MUTATE_EACH_GEN, nnop)
start = time.time()
correct = 0
incorrect = 0
train(oa, network, "GA", train_set, test_set, measure, population_size)
end = time.time()
training_time = end - start
optimal_instance = oa.getOptimal()
network.setWeights(optimal_instance.getData())
start = time.time()
for instance in test_set.getInstances():
network.setInputValues(instance.getData())
network.run()
predicted = instance.getLabel().getContinuous()
actual = network.getOutputValues().get(0)
if abs(predicted - actual) < 0.5:
correct += 1
else:
incorrect += 1
end = time.time()
testing_time = end - start
_results = ""
_results += "\n[GA] population=%0.02f" % (population_size)
_results += "\nResults for GA: \nCorrectly classified %d instances." % (
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, )
with open('out/ga/population-%d.log' % (population_size), 'w') as f:
f.write(_results)
results += _results
print results
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()))
from time import time rhc = RandomizedHillClimbing(hcp) fit = FixedIterationTrainer(rhc, 600000) t0 = time() fit.train() print "RHC: " + str(ef.value(rhc.getOptimal())), "time taken", time() - t0 sa = SimulatedAnnealing(1E11, .95, hcp) fit = FixedIterationTrainer(sa, 600000) t0 = time() fit.train() print "SA: " + str(ef.value(sa.getOptimal())), "time taken", time() - t0 ga = StandardGeneticAlgorithm(200, 100, 10, gap) fit = FixedIterationTrainer(ga, 20000) t0 = time() fit.train() print "GA: " + str(ef.value(ga.getOptimal())), "time taken", time() - t0 mimic = MIMIC(50, 10, pop) fit = FixedIterationTrainer(mimic, 10000) t0 = time() fit.train() print "MIMIC: " + str(ef.value(mimic.getOptimal())), "time taken", time() - t0
mimic0 = MIMIC(200, 100, pop)
i = 0
while ( i< timeout/1000):
mimic0.train()
i += 1
max = ef.value(mimic0.getOptimal())
print "mimic0,", i,",", max
if (max > goal):
goal = max
gap0 = GenericGeneticAlgorithmProblem(ef, odd, mf, cf)
ga0 = StandardGeneticAlgorithm(200, 100, 25, gap0)
i = 0
while ( i< timeout/1000):
ga0.train()
i += 1
max = ef.value(ga0.getOptimal())
print "ga0,", i,",", max
if (max > goal):
goal = max
# run RHC
rhc = RandomizedHillClimbing(hcp)
max = 0
i = 0
while (max < goal and i < timeout):
rhc.train()
i += 1
max = ef.value(rhc.getOptimal())
#print "rhc,", i,",", max, ',', goal
print "rhc,", i,",", max, ',', goal
runs = 10
# N=200
T = N / 5
fill = [2] * N
ranges = array("i", fill)
ef = FourPeaksEvaluationFunction(T)
odd = DiscreteUniformDistribution(ranges)
mf = DiscreteChangeOneMutation(ranges)
# print "Ga settings:\npop:%d\ncrossovertype:%d\ncrossoverrate:%d\nmutationrate:%d\n\n" % (ga_pop,co_type,ga_keep,ga_mut_type)
gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf)
t0 = time.time()
calls = []
results = []
for _ in range(runs):
# ga_pop = N*5
ga = StandardGeneticAlgorithm(ga_pop, ga_keep, ga_mut, gap)
fit = FixedIterationTrainer(ga, 1000)
fitness = fit.train()
results.append(ef.value(ga.getOptimal()))
calls.append(ef.getTotalCalls())
ef.clearCount()
print "GA, average results , " + str(sum(results) / float(runs))
print "GA, average feval calls , " + str(sum(calls) / float(runs))
t1 = time.time() - t0
print "GA, average time , " + str(t1 / float(runs))
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)
# GENETIC ALGO
for i in range(trials):
ga = StandardGeneticAlgorithm(2000, 1500, 250, gap)
fit = FixedIterationTrainer(ga, 1000)
start = clock()
fit.train()
end = clock()
total_time = end - start
max_fit = ef.value(ga.getOptimal())
time_optimum = [total_time, max_fit]
genetic.append(time_optimum)
print("GA Inverse of Distance: " + str(ef.value(ga.getOptimal())))
print("Route:")
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)
sa = SimulatedAnnealing(1E11, .95, hcp)
fit = FixedIterationTrainer(sa, iteration)
start = time.time()
fit.train()
end = time.time()
sa_times.append(end - start)
sa_acc.append(ef.value(sa.getOptimal()))
print "SA: " + str(ef.value(sa.getOptimal()))
ga = StandardGeneticAlgorithm(200, 100, 10, gap)
fit = FixedIterationTrainer(ga, iteration)
start = time.time()
fit.train()
end = time.time()
ga_times.append(end - start)
ga_acc.append(ef.value(ga.getOptimal()))
print "GA: " + str(ef.value(ga.getOptimal()))
mimic = MIMIC(200, 20, pop)
fit = FixedIterationTrainer(mimic, iteration)
start = time.time()
fit.train()
end = time.time()
mimic_times.append(end - start)
mimic_acc.append(ef.value(mimic.getOptimal()))
print "MIMIC: " + str(ef.value(mimic.getOptimal()))
print "---------------"
else:
continue
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
def main():
N=200
tempDenom = 5
T=N/tempDenom
fill = [2] * N
ranges = array('i', fill)
iterations = 2000
gaIters = 1000
mimicIters = 1000
gaPop = 200
gaMate = 100
gaMutate = 10
mimicSamples = 200
mimicToKeep = 20
saTemp = 1E11
saCooling = .95
alg = 'all'
run = 0
settings = []
try:
opts, args = getopt.getopt(sys.argv[1:], "ahn:rsgN:m:t:i:", ["gaIters=", "mimicIters=","gaPop=", "gaMate=", "gaMutate=", "mimicSamples=", "mimicToKeep=", "saTemp=", "saCooling="])
except:
print 'knapsack.py -i <iterations> -n <NUM_ITEMS> -c <COPIES_EACH> -w <MAX_WEIGHT> -v <MAX_VOLUME>'
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print 'knapsack.py -i <iterations> -n <NUM_ITEMS> -c <COPIES_EACH> -w <MAX_WEIGHT> -v <MAX_VOLUME>'
sys.exit(1)
elif opt == '-i':
iterations = int(arg)
elif opt == '-N':
N = int(arg)
elif opt == '-t':
T = float(arg)
elif opt == '-d':
tempDenom = int(arg)
elif opt == '-r':
alg = 'RHC'
elif opt == '-a':
alg = 'all'
elif opt == '-s':
alg = 'SA'
elif opt == '-g':
alg = 'GA'
elif opt == '-m':
alg = 'MIMIC'
elif opt == '--gaPop':
gaPop = int(arg)
elif opt == '--gaMate':
gaMate = int(arg)
elif opt == '--gaMutate':
gaMutate = int(arg)
elif opt == '--mimicSamples':
mimicSamples = int(arg)
elif opt == '--mimicToKeep':
mimicToKeep = int(arg)
elif opt == '--saTemp':
saTemp = float(arg)
elif opt == '--saCooling':
saCooling = float(arg)
elif opt == '--gaIters':
gaIters = int(arg)
elif opt == '--mimicIters':
mimicIters = int(arg)
elif opt == '-n':
run = int(arg)
vars = {
'N':N,
'tempDenom':tempDenom,
'T':T,
'fill':fill,
'ranges':ranges,
'iterations' :iterations,
'gaIters':gaIters,
'mimicIters':mimicIters,
'gaPop' :gaPop,
'gaMate' :gaMate,
'gaMutate' :gaMutate,
'mimicSamples' : mimicSamples,
'mimicToKeep' : mimicToKeep,
'saTemp' : saTemp,
'saCooling' : saCooling,
'alg' : alg,
'run' : run
}
settings = getSettings(alg, settings, vars)
T=N/tempDenom
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)
if alg == 'RHC' or alg == 'all':
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, iterations)
fit.train()
rows = []
row = []
row.append("Evaluation Function Value")
row.append(ef.value(rhc.getOptimal()))
rows.append(row)
print "RHC: " + str(ef.value(rhc.getOptimal()))
output2('4Peaks', 'RHC', rows, settings)
rows = []
buildFooter("4Peaks", "RHC", rows, settings),
outputFooter("4Peaks", "RHC", rows, settings)
if alg == 'SA' or alg == 'all':
sa = SimulatedAnnealing(saTemp, saCooling, hcp)
fit = FixedIterationTrainer(sa, iterations)
fit.train()
rows = []
row = []
row.append("Evaluation Function Value")
row.append(ef.value(sa.getOptimal()))
rows.append(row)
print "SA: " + str(ef.value(sa.getOptimal()))
output2('4Peaks', 'SA', rows, settings)
rows = []
buildFooter("4Peaks", "SA", rows, settings)
outputFooter("4Peaks", "SA", rows, settings)
if alg == 'GA' or alg == 'all':
ga = StandardGeneticAlgorithm(gaPop, gaMate, gaMutate, gap)
fit = FixedIterationTrainer(ga, gaIters)
fit.train()
print "GA: " + str(ef.value(ga.getOptimal()))
rows = []
row = []
row.append("Evaluation Function Value")
row.append(ef.value(ga.getOptimal()))
rows.append(row)
output2('4Peaks', 'GA', rows, settings)
rows = []
buildFooter("4Peaks", "GA", rows, settings)
outputFooter("4Peaks", "GA", rows , settings)
if alg == 'MIMIC' or alg == 'all':
mimic = MIMIC(mimicSamples, mimicToKeep, pop)
fit = FixedIterationTrainer(mimic, mimicIters)
fit.train()
print "MIMIC: " + str(ef.value(mimic.getOptimal()))
rows = []
row = []
row.append("Evaluation Function Value")
row.append(ef.value(mimic.getOptimal()))
rows.append(row)
output2('4Peaks', 'MIMIC', rows, settings)
rows = []
buildFooter("4Peaks", "GA", rows, settings)
outputFooter("4Peaks", "MIMIC", rows, settings)
for GA_MUTATION in GA_MUTATION_pool:
ga = StandardGeneticAlgorithm(GA_POPULATION, GA_CROSSOVER, GA_MUTATION, gap)
fit_ga = FixedIterationTrainer(ga, n_iteration)
print("calculating for mutations = %d " % GA_MUTATION)
# Training
start_ga = time.time()
fit_ga.train()
end_ga = time.time()
# Result extracting
last_training_time_ga = end_ga - start_ga
ga_training_time[n].append(last_training_time_ga)
ga_fitness[n].append(ef.value(ga.getOptimal()))
overall_ga_training_time = list_avg(*ga_training_time)
overall_ga_fitness = list_avg(*ga_fitness)
with open(OUTPUT_FILE, "w") as outFile:
for i in range(1):
outFile.write(','.join([
"ga_mutations",
"ga_fitness",
"ga_training_time"]) + '\n')
for i in range(len(GA_MUTATION_pool)):
outFile.write(','.join([
str(GA_MUTATION_pool[i]),
str(overall_ga_fitness[i]),
str(overall_ga_training_time[i])]) + '\n')
fit = FixedIterationTrainer(sa, iterations)
fit.train()
print(str(ef.value(sa.getOptimal())))
end = time.time()
times += "\n%0.03f" % (end - start)
print(times)
times = ""
print "GA:"
for x in range(20):
start = time.time()
iterations = (x + 1) * 2500
ga = StandardGeneticAlgorithm(200, 100, 10, gap)
fit = FixedIterationTrainer(ga, iterations)
fit.train()
print(str(ef.value(ga.getOptimal())))
end = time.time()
times += "\n%0.03f" % (end - start)
print(times)
times = ""
print "MIMIC:"
for x in range(20):
start = time.time()
iterations = (x + 1) * 2500
mimic = MIMIC(200, 20, pop)
fit = FixedIterationTrainer(mimic, iterations)
fit.train()
print(str(ef.value(mimic.getOptimal())))
end = time.time()
times += "\n%0.03f" % (end - start)
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()))
start = time.time()
fit.train()
end = time.time()
training_time = end - start
print "SA: " + str(ef.value(sa.getOptimal()))
OUTFILE = "%s%s.csv" % (OUTFILE_BASE, "SA")
with open(OUTFILE, 'a+') as f:
f.write("%d,%f,%f\n" % (N, training_time, ef.value(sa.getOptimal())))
ga = StandardGeneticAlgorithm(200, 100, 10, gap)
fit = FixedIterationTrainer(ga, 10)
start = time.time()
fit.train()
end = time.time()
training_time = end - start
print "GA: " + str(ef.value(ga.getOptimal()))
OUTFILE = "%s%s.csv" % (OUTFILE_BASE, "GA")
with open(OUTFILE, 'a+') as f:
f.write("%d,%f,%f\n" % (N, training_time, ef.value(ga.getOptimal())))
# mimic = MIMIC(200, 20, pop)
# fit = FixedIterationTrainer(mimic, 10)
# start = time.time()
# fit.train()
# end = time.time()
# training_time = end - start
# print "MIMIC: " + str(ef.value(mimic.getOptimal()))
# OUTFILE = "%s%s.csv" % (OUTFILE_BASE, "MIMIC")
# with open(OUTFILE, 'a+') as f:
# f.write("%d,%f,%f\n" % (N, training_time, ef.value(mimic.getOptimal())))
expt = "expt_avg"
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, 200000)
score_RHC.append(train(rhc, "RHC", ef, 200000, "test", expt))
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: Board Position: "
# print(ef.boardPositions())
print("============================")
sa = SimulatedAnnealing(1E1, .1, hcp)
fit = FixedIterationTrainer(sa, 200000)
fit.train()
sa_opt = ef.value(sa.getOptimal())
print("SA: " + str(sa_opt))
# print("SA: Board Position: ")
# print(ef.boardPositions())
print("============================")
ga = StandardGeneticAlgorithm(200, 0, 10, gap)
fit = FixedIterationTrainer(ga, 1000)
fit.train()
ga_opt = ef.value(ga.getOptimal())
print("GA: " + str(ga_opt))
# print("GA: Board Position: ")
# print(ef.boardPositions())
print("============================")
mimic = MIMIC(200, 10, pop)
fit = FixedIterationTrainer(mimic, 1000)
fit.train()
mimic_opt = ef.value(mimic.getOptimal())
print("MIMIC: " + str(mimic_opt))
# print("MIMIC: Board Position: ")
# print(ef.boardPositions())
sa = SimulatedAnnealing(100, .95, hcp)
ga = StandardGeneticAlgorithm(20, 20, 0, gap)
mimic = MIMIC(50, 10, pop)
rhc_f = open('out/op/countones/rhc.csv', 'w')
sa_f = open('out/op/countones/sa.csv', 'w')
ga_f = open('out/op/countones/ga.csv', 'w')
mimic_f = open('out/op/countones/mimic.csv', 'w')
for i in range(ITERATIONS):
rhc.train()
rhc_fitness = ef.value(rhc.getOptimal())
rhc_f.write('{},{}\n'.format(i, rhc_fitness))
sa.train()
sa_fitness = ef.value(sa.getOptimal())
sa_f.write('{},{}\n'.format(i, sa_fitness))
ga.train()
ga_fitness = ef.value(ga.getOptimal())
ga_f.write('{},{}\n'.format(i, ga_fitness))
mimic.train()
mimic_fitness = ef.value(mimic.getOptimal())
mimic_f.write('{},{}\n'.format(i, mimic_fitness))
rhc_f.close()
sa_f.close()
ga_f.close()
mimic_f.close()
def travelingsalesmanfunc(N, iterations):
rhcMult = 1500
saMult = 1500
gaMult = 1
mimicMult = 3
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()
optimalOut = []
timeOut = []
evalsOut = []
for niter in iterations:
ef = TravelingSalesmanRouteEvaluationFunction(points)
odd = DiscretePermutationDistribution(N)
nf = SwapNeighbor()
mf = SwapMutation()
cf = TravelingSalesmanCrossOver(ef)
hcp = GenericHillClimbingProblem(ef, odd, nf)
gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf)
iterOptimalOut = [N, niter]
iterTimeOut = [N, niter]
iterEvals = [N, niter]
start = time.time()
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, niter * rhcMult)
fit.train()
end = time.time()
rhcOptimal = ef.value(rhc.getOptimal())
rhcTime = end - start
print "RHC Inverse of Distance: optimum: " + str(rhcOptimal)
print "RHC time: " + str(rhcTime)
#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
iterOptimalOut.append(rhcOptimal)
iterTimeOut.append(rhcTime)
functionEvals = ef.getNumEvals()
ef.zeroEvals()
iterEvals.append(functionEvals)
start = time.time()
sa = SimulatedAnnealing(1E12, .999, hcp)
fit = FixedIterationTrainer(sa, niter * saMult)
fit.train()
end = time.time()
saOptimal = ef.value(sa.getOptimal())
saTime = end - start
print "SA Inverse of Distance optimum: " + str(saOptimal)
print "SA time: " + str(saTime)
#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
iterOptimalOut.append(saOptimal)
iterTimeOut.append(saTime)
functionEvals = ef.getNumEvals()
ef.zeroEvals()
iterEvals.append(functionEvals)
start = time.time()
ga = StandardGeneticAlgorithm(2000, 1500, 250, gap)
fit = FixedIterationTrainer(ga, niter * gaMult)
fit.train()
end = time.time()
gaOptimal = ef.value(ga.getOptimal())
gaTime = end - start
print "GA Inverse of Distance optimum: " + str(gaOptimal)
print "GA time: " + str(gaTime)
#print "GA Inverse of Distance: " + str(ef.value(ga.getOptimal()))
print "Route:"
path = []
for x in range(0, N):
path.append(ga.getOptimal().getDiscrete(x))
print path
iterOptimalOut.append(gaOptimal)
iterTimeOut.append(gaTime)
functionEvals = ef.getNumEvals()
ef.zeroEvals()
iterEvals.append(functionEvals)
start = time.time()
# 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)
start = time.time()
mimic = MIMIC(500, 100, pop)
fit = FixedIterationTrainer(mimic, niter * mimicMult)
fit.train()
end = time.time()
mimicOptimal = ef.value(mimic.getOptimal())
mimicTime = end - start
print "MIMIC Inverse of Distance optimum: " + str(mimicOptimal)
print "MIMIC time: " + str(mimicTime)
#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
iterOptimalOut.append(mimicOptimal)
iterTimeOut.append(mimicTime)
functionEvals = ef.getNumEvals()
ef.zeroEvals()
iterEvals.append(functionEvals)
optimalOut.append(iterOptimalOut)
timeOut.append(iterTimeOut)
evalsOut.append(iterEvals)
return [optimalOut, timeOut, evalsOut]