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 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 = ContinuousPeaksEvaluationFunction(T)
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_sa(t, CE):
fname = outfile.format('SA{}'.format(CE), str(t + 1))
with open(fname, 'a+') as f:
content = f.read()
if "fitness" not in content:
f.write('iterations,fitness,time,fevals\n')
ef = ContinuousPeaksEvaluationFunction(T)
odd = DiscreteUniformDistribution(ranges)
nf = DiscreteChangeOneNeighbor(ranges)
hcp = GenericHillClimbingProblem(ef, odd, nf)
sa = SimulatedAnnealing(1E10, CE, hcp)
fit = FixedIterationTrainer(sa, 10)
times = [0]
for i in range(0, maxIters, 10):
start = clock()
fit.train()
elapsed = time.clock() - start
times.append(times[-1] + elapsed)
fevals = ef.fevals
score = ef.value(sa.getOptimal())
ef.fevals -= 1
st = '{},{},{},{}\n'.format(i, score, times[-1], fevals)
# print st
base.write_to_file(fname, st)
return
def 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 get_ef(self):
"""Creates a new continuous peaks problem with the specified
parameters.
Returns:
ranges (array): Array of values as specified by N.
ef (ContinuousPeaksEvaluationFunction): Evaluation function.
"""
fill = [2] * self.N
ranges = array('i', fill)
return ranges, ContinuousPeaksEvaluationFunction(self.T)
def run_rhc(t):
fname = outfile.format('RHC', str(t + 1))
ef = ContinuousPeaksEvaluationFunction(T)
odd = DiscreteUniformDistribution(ranges)
nf = DiscreteChangeOneNeighbor(ranges)
hcp = GenericHillClimbingProblem(ef, odd, nf)
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, 10)
times = [0]
for i in range(0, maxIters, 10):
start = clock()
fit.train()
elapsed = time.clock() - start
times.append(times[-1] + elapsed)
fevals = ef.fevals
score = ef.value(rhc.getOptimal())
ef.fevals -= 1
st = '{},{},{},{}\n'.format(i, score, times[-1], fevals)
# print fname, st
base.write_to_file(fname, st)
return
T = N / 10
fill = [2] * N
ranges = array('i', fill)
maxIters = 2500
numTrials = 5
# module_path = os.path.dirname(os.path.realpath(__file__))
# output_path = os.path.join(module_path, 'output_file')
# outfile = module_path + '/CONTPEAKS/CONTPEAKS_{}_{}_LOG.csv'
# outfile = output_path + '\CONTPEAKS\CONTPEAKS_{}_{}_LOG.csv'
# outfile = 'C:\\Users\\gablanco\\gatech\\assignment2\\CONTPEAKS\\CONTPEAKS_{}_{}_LOG.csv'
outfile = 'CONTPEAKS_{}_{}_LOG.csv'
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()))
# RHC
from array import array
from time import clock
from itertools import product
"""
Commandline parameter(s):
none
"""
N = 100
T = 15
maxIters = 5001
numTrials = 5
fill = [2] * N
ranges = array('i', fill)
outfile = './CONTPEAKS/CONTPEAKS_T15_@ALG@_@N@_LOG.txt'
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
for t in range(numTrials):
fname = outfile.replace('@ALG@', 'RHC').replace('@N@', str(t + 1))
with open(fname, 'w') as f:
f.write('iterations,fitness,time,fevals\n')
ef = ContinuousPeaksEvaluationFunction(T)
# Random number generator */
N = 60
T = N / 10
fill = [2] * N
ranges = array('i', fill)
cycle = 1
n_iteration = 1000
sa_fitness = [[] for i in range(cycle)]
sa_training_time = [[] for i in range(cycle)]
for n in range(cycle):
print("the %d th cycle" % (n + 1))
ef = ContinuousPeaksEvaluationFunction(T)
odd = DiscreteUniformDistribution(ranges)
nf = DiscreteChangeOneNeighbor(ranges)
hcp = GenericHillClimbingProblem(ef, odd, nf)
for SA_COOLING_FACTOR in SA_COOLING_FACTOR_pool:
sa = SimulatedAnnealing(SA_TEMPERATURE, SA_COOLING_FACTOR, hcp)
fit_sa = FixedIterationTrainer(sa, n_iteration)
print("calculating for cooling rate = %f" % SA_COOLING_FACTOR)
# Training
start_sa = time.time()
fit_sa.train()
end_sa = time.time()
rhc_results = nested_dict()
sa_results = nested_dict()
ga_results = nested_dict()
mi_results = nested_dict()
# Two tasks: sweep params to figure out best settings, then run sweeps of iters, etc.
for trial_num in range(num_trials):
print "On trial num: ", trial_num, " of total of ", num_trials
for N in num_points:
print "\tUsing num_points: ", N
T = N / 10
fill = [2] * N
ranges = array('i', fill)
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)
if do_rhc:
rhc = RandomizedHillClimbing(hcp)
for iter in hc_iter:
score, call_count, runtime = helpers.eval_algo(ef, rhc, iter)
rhc_scores.append(score)
rhc_times.append(runtime)
BASE_PATH = os.getcwd() + "/"
OUTFILE_BASE = BASE_PATH + 'out/countinouspeaks/'
if not os.path.exists(OUTFILE_BASE):
os.makedirs(OUTFILE_BASE)
for algo in ["RHC", "MIMIC", "GA", "SA"]:
with open(OUTFILE_BASE + algo + ".csv", 'w') as f:
f.write("iterations,training_time,fitness\n")
for N in xrange(38000, 500000, 1000):
T = N / 10
fill = [2] * N
ranges = array('i', fill)
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, 100)
start = time.time()
fit.train()
end = time.time()
training_time = end - start
for param in params['RHC']:
output_filename = 'CP %s-%s.csv' % ('RHC', identifier['RHC'](param))
csv_file = open(output_filename, 'w')
fields = ['num_iterations', 'value', 'time']
writer = csv.DictWriter(csv_file, fieldnames=fields)
writer.writeheader()
for it_count in iterations:
N = 60
T = N / 10
fill = [2] * N
ranges = array('i', fill)
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)
start = time.time()
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, it_count)
fit.train()
end = time.time()
# print "Time -->", end - start
from array import array
from time import clock # use clock instead of typical time because better resolution
"""
Commandline parameter(s):
none
"""
N = 60
T = N / 10
fill = [2] * N
ranges = array('i', fill)
max_iterations = 3500
num_iterations = 10
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)
def merge_two_dicts(x, y):
z = x.copy() # start with x's keys and values
z.update(y) # modifies z with y's keys and values & returns None
return z
none
"""
# set N value. This is the number of points
N = 50
fill = [2] * N
random = Random()
ranges = array('i', fill)
T = 20
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 = 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)
# repeat a few times to get an average?
trials = 10 # more?
hill_climbing = []
annealing = []
genetic = []
mimic_data = []
rhc_fitness = [[] for i in range(cycle)]
rhc_training_time = [[] for i in range(cycle)]
sa_fitness = [[] for i in range(cycle)]
sa_training_time = [[] for i in range(cycle)]
ga_fitness = [[] for i in range(cycle)]
ga_training_time = [[] for i in range(cycle)]
mimic_fitness = [[] for i in range(cycle)]
mimic_training_time = [[] for i in range(cycle)]
for n in range(cycle):
print("the %d th cycle" % (n + 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)
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)
iteration_list = [10, 100, 500, 1000, 2500, 5000, 8000, 10000]
runs = 5
#RHC
output_directory = "Results/Small/Continuous_Peaks_RHC.csv"
with open(output_directory, 'w') as f:
f.write('iterations,fitness,time\n')
for i in range(len(iteration_list)):
iteration = iteration_list[i]
rhc_total = 0
rhc_time = 0
for x in range(runs):
ranges = array('i', [2] * N)
fitness = ContinuousPeaksEvaluationFunction(T)
discrete_dist = DiscreteUniformDistribution(ranges)
discrete_neighbor = DiscreteChangeOneNeighbor(ranges)
discrete_mutation = DiscreteChangeOneMutation(ranges)
crossover = SCO()
discrete_dependency = DiscreteDependencyTree(.1, ranges)
hill_problem = GHC(fitness, discrete_dist, discrete_neighbor)
start = time.clock()
rhc_problem = RHC(hill_problem)
fit = FixedIterationTrainer(rhc_problem, iteration)
fit.train()
end = time.clock()
full_time = end - start
rhc_total += fitness.value(rhc_problem.getOptimal())
rhc_time += full_time
import opt.prob.MIMIC as MIMIC
import opt.prob.ProbabilisticOptimizationProblem as ProbabilisticOptimizationProblem
import shared.FixedIterationTrainer as FixedIterationTrainer
import opt.example.ContinuousPeaksEvaluationFunction as ContinuousPeaksEvaluationFunction
from array import array
"""
Commandline parameter(s):
none
"""
N = 60
T = N / 10
fill = [2] * N
ranges = array('i', fill)
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)
Commandline parameter(s):
none
"""
print "About to run Vote Test. Yay."
vt = VoteTest()
vt.doIt()
N=60
T=N/10
fill = [2] * N
ranges = array('i', fill)
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)
