def run_algorithm_test(ranges, algorithms, output_file_name, trial_number, iterations=False):
with open(output_file_name,'w') as f:
f.write('algorithm,optimal_result,iterations,time,trial\n')
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)
for trial in range(trial_number):
if iterations is False:
for item in algorithms:
start_time = time.time()
if item in ['rhc']:
optimal_result, run_iters = run_rhc(hcp, ef)
elif item in ['sa']:
optimal_result, run_iters = run_sa(hcp, ef)
elif item in ['ga']:
optimal_result, run_iters = run_ga(gap, ef)
elif item in ['mimic']:
optimal_result, run_iters = run_mimic(pop, ef)
else:
print "The algorithm type {} is not supported.".format(item)
end_time = time.time()
time_elapsed = end_time - start_time
run_output = '{},{},{},{},{}\n'.format(item, optimal_result, run_iters, time_elapsed, trial)
with open(output_file_name,'a') as f:
f.write(run_output)
else:
for iter in iterations:
for item in algorithms:
start_time = time.time()
if item in ['rhc']:
optimal_result, run_iters = run_rhc(hcp, ef, iter)
elif item in ['sa']:
optimal_result, run_iters = run_sa(hcp, ef, iter)
elif item in ['ga']:
optimal_result, run_iters = run_ga(gap, ef, iter)
elif item in ['mimic']:
optimal_result, run_iters = run_mimic(pop, ef, iter)
else:
print "The algorithm type {} is not supported.".format(item)
end_time = time.time()
time_elapsed = end_time - start_time
run_output = '{},{},{},{},{}\n'.format(item, optimal_result, run_iters, time_elapsed, trial)
with open(output_file_name,'a') as f:
f.write(run_output)
print "time elapsed is {}".format(time_elapsed)
return
import opt.example.CountOnesEvaluationFunction as CountOnesEvaluationFunction
from array import array
"""
Commandline parameter(s):
none
"""
N = 80
fill = [2] * N
ranges = array('i', fill)
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)
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, 200)
fit.train()
print "RHC: " + str(ef.value(rhc.getOptimal()))
sa = SimulatedAnnealing(100, .95, hcp)
fit = FixedIterationTrainer(sa, 200)
fit.train()
print "SA: " + str(ef.value(sa.getOptimal()))
def run_all_2(N=200, T=40, fout=None):
problem = 'fourpeaks'
# N=200
# T=N/10
maxEpochs = 10**6
maxTime = 300 #5 minutes
fill = [2] * N
ranges = array('i', fill)
ef = FourPeaksEvaluationFunction(T)
odd = DiscreteUniformDistribution(ranges)
nf = DiscreteChangeOneNeighbor(ranges)
mf = DiscreteChangeOneMutation(ranges)
# mf = SwapMutation()
cf = SingleCrossOver()
df = DiscreteDependencyTree(.1, ranges)
hcp = GenericHillClimbingProblem(ef, odd, nf)
gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf)
pop = GenericProbabilisticOptimizationProblem(ef, odd, df)
def run_algo(alg, fit, label, difficulty, iters):
trainTimes = [0.]
trainTime = []
scoreChange = [0.]
stuckCount = 10**3
prev = 0.
for epoch in range(0, maxEpochs, 1):
st = time.clock()
fit.train()
et = time.clock()
trainTimes.append(trainTimes[-1] + (et - st))
trainTime.append((et - st))
rollingMean = 10
avgTime = (math.fsum(trainTime[-rollingMean:]) /
float(rollingMean))
score = ef.value(alg.getOptimal())
# trialString = '{}-{}-{}-{}'.format(label,score,epoch,trainTimes[-1])
trialData = [
problem, difficulty, label, score, epoch, trainTimes[-1],
avgTime, iters
]
# print(trialData)
# fout.writerow(trialData)
# print(trialData)
print(trialData, max(scoreChange))
# print(max(scoreChange))
optimum = (difficulty - 1 - T) + difficulty
if score >= optimum: break
scoreChange.append(abs(score - prev))
prev = score
scoreChange = scoreChange[-stuckCount:]
# print(scoreChange)
if max(scoreChange) == 0: break
if trainTimes[-1] > maxTime: break
# print(trialData)
fout.writerow(trialData)
iters = 1000
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, iters)
run_algo(rhc, fit, 'RHC', N, iters)
iters = 1000
startTemp = 1E10
coolingFactor = .95
sa = SimulatedAnnealing(startTemp, coolingFactor, hcp)
fit = FixedIterationTrainer(sa, iters)
run_algo(sa, fit, 'SA', N, iters)
iters = 10
population = 300
mates = 100
mutations = 50
ga = StandardGeneticAlgorithm(population, mates, mutations, gap)
fit = FixedIterationTrainer(ga, iters)
run_algo(ga, fit, 'GA', N, iters)
iters = 10
samples = 200
keep = 20
mimic = MIMIC(samples, keep, pop)
fit = FixedIterationTrainer(mimic, iters)
run_algo(mimic, fit, 'MIMIC', N, iters)
