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_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 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 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
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)
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
