def knapsack():
# Random number generator */
random = Random()
random.setSeed(0)
NUM_ITEMS = 40 # The number of items
COPIES_EACH = 4 # The number of copies each
MAX_WEIGHT = 50 # The maximum weight for a single element
MAX_VOLUME = 50 # The maximum volume for a single element
KNAPSACK_VOLUME = MAX_VOLUME * NUM_ITEMS * COPIES_EACH * .4 # The volume of the knapsack
# 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()
rhc_generic("KnSrhc50", ef, odd, nf, 1.0, 10000, 10, 5)
sa_generic("KnSsa50", ef, odd, nf, 1.0, 10000, 10, 5,
([1E12, 1E6], [0.999, 0.99, 0.95]))
ga_generic("KnSga50", ef, odd, mf, cf, 50.0, 10000, 10, 1,
([2000, 200], [0.5, 0.25], [0.25, 0.1, 0.02]))
mimic_discrete("KnSmimic50", ef, odd, ranges, 300.0, 10000, 10, 1,
([200], [100], [0.1, 0.5, 0.9]))
print "KnS all done"
def run_all_2(N=40,fout=None):
maxEpochs = 10**5
maxTime = 300 #5 minutes
problem = 'knapsack'
# Random number generator */
random = Random()
# The number of items
NUM_ITEMS = N
# 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
# 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)
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) < 1.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 = .99
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)
def solveit(oaname, params):
iterations = 10000
tryi = 1
# Random number generator */
random = Random()
# 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
# 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 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':
iterations = 1000
oa = StandardGeneticAlgorithm(int(params[0]), int(params[1]),
int(params[2]), gap)
if oaname == 'MMC':
iterations = 1000
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 = int(timeit.default_timer() - starttime)
output.append([str(i), str(score), str(elapsed)])
print 'score: %.3f' % score
print 'train time: %d secs' % (int(timeit.default_timer() - starttime))
scsv = 'kn-%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 knapsackfunc(NUM_ITEMS, iterations):
rhcMult = 600
saMult = 600
gaMult = 4
mimicMult = 3
# Random number generator */
random = Random()
# 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
# 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)
optimalOut = []
timeOut = []
evalsOut = []
for niter in iterations:
iterOptimalOut = [NUM_ITEMS, niter]
iterTimeOut = [NUM_ITEMS, niter]
iterEvals = [NUM_ITEMS, 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(100, .95, 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, 150, 25, 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, 100, 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]
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)
def run_knapsack():
# Random number generator */
random = Random()
# 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
# 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)
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(100, .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, 150, 25, gap)
fit = FixedIterationTrainer(ga, i)
fit.train()
end = time.time()
ga_results.append(ef.value(sa.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, 100, 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('knapsack.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
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)
initial_distribution = DiscreteUniformDistribution(ranges)
nf = DiscreteChangeOneNeighbor(ranges)
mutation_function = DiscreteChangeOneMutation(ranges)
cf = SingleCrossOver()
df = DiscreteDependencyTree(.1, ranges)
hill_climbing_problem = GenericHillClimbingProblem(ef, initial_distribution, nf)
genetic_problem = GenericGeneticAlgorithmProblem(ef, initial_distribution, mutation_function, cf)
probablistic_optimization = GenericProbabilisticOptimizationProblem(ef, initial_distribution, df)
from time import time
f = open("experiments/results/knapsack_optimal2.txt", "w")
f.write("starting RHC\n")
fill = [COPIES_EACH] * N
copies = array('i', fill)
# create weights and volumes
fill = [0] * N
weights = array('d', fill)
volumes = array('d', fill)
for i in range(0, N):
weights[i] = random.nextDouble() * MAX_WEIGHT
volumes[i] = random.nextDouble() * MAX_VOLUME
# create range
fill = [COPIES_EACH + 1] * N
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)
# -- begin problem
t0 = time.time()
calls = []
results = []
for _ in range(runs):
def run_knapsack_experiments():
OUTPUT_DIRECTORY = './output'
# Random number generator */
random = Random()
# 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
# 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()
hcp = GenericHillClimbingProblem(ef, odd, nf)
gap = GenericGeneticAlgorithmProblem(ef, odd, mf, cf)
max_iter = 5000
outfile = OUTPUT_DIRECTORY + '/knapsack_{}_log.csv'
# Randomized Hill Climber
filename = outfile.format('rhc')
with open(filename, 'w') as f:
f.write('iterations,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(200, 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(
[200], [110, 120, 130, 140, 150], [2, 4, 6, 8]):
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([200], [100],
[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)
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(volumes, weights, 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)
# Store Metrics
rhc_times = []
rhc_acc = []
sa_times = []
sa_acc = []
ga_times = []
print("Repetion %d" % (repetition + 1))
current_iteration_count = MIN_ITERATION
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
fill = [COPIES_EACH + 1] * NUM_ITEMS
ranges = array('i', fill)
# Problem Definition
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)
# Algorithm declaration
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)
Commandline parameter(s):
none
"""
values = [10, 40, 50, 70]
weights = [1, 3, 4, 5]
W = 5
copiesPerElement = [1, 1, 1, 1]
N = 100
T = 29
maxIters = 5001
numTrials = 5
fill = [2] * N
ranges = array('i', fill)
outfile = OUTPUT_DIRECTORY + '/KNAP/KNAP_{}_{}_LOG.csv'
ef = KnapsackEvaluationFunction(values, weights, W, copiesPerElement)
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.format('RHC', str(t + 1))
with open(fname, 'w') as f:
f.write('iterations,fitness,time,fevals\n')
ef = KnapsackEvaluationFunction(values, weights, W, copiesPerElement)
def run_algorithm_test(weights, volumes, knapsack_volume, copies, 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 = 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)
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
def run_all():
problem = 'knapsack'
# Random number generator */
random = Random()
# 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
# 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)
maxEpochs = 400
columns = ['problem','label','score','epoch','time','avgTrainTime','iterations']
outFile = open(filename+'_all.csv','wb')
fout = csv.writer(outFile,delimiter=',')
fout.writerow(columns)
def run_algo(alg,fit,label,iters):
print(alg)
trainTimes = [0.]
trainTime = []
scores = [0]
deltaScores = []
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())
scores.append(score)
deltaScores.append(math.fabs(scores[-2] - scores[-1]))
# trialString = '{}-{}-{}-{}'.format(label,score,epoch,trainTimes[-1])
trialData = [problem,label,score,epoch,trainTimes[-1],avgTime,iters]
print(trialData)
fout.writerow(trialData)
iters = 10
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, iters)
run_algo(rhc,fit,'RHC',10)
startTemp = 1E11
coolingFactor = .95
sa = SimulatedAnnealing(startTemp, coolingFactor, hcp)
fit = FixedIterationTrainer(sa, iters)
run_algo(sa,fit,'HCP',10)
population = 300
mates = 100
mutations = 50
ga = StandardGeneticAlgorithm(population, mates, mutations, gap)
fit = FixedIterationTrainer(ga, iters)
run_algo(ga,fit,'GA',10)
samples = 200
keep = 20
mimic = MIMIC(samples, keep, pop)
fit = FixedIterationTrainer(mimic, iters)
run_algo(mimic,fit,'MIMIC',10)
outFile.close()
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 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)
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)
# -- begin problem
t0 = time.time()
calls = []
results = []
for _ in range(runs):
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)
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, 200000)
fit.train()
print "RHC: " + str(ef.value(rhc.getOptimal()))
sa = SimulatedAnnealing(100, .95, hcp)
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)
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, N)
start = time.time()
fit.train()
end = time.time()
training_time = end - start
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))
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
fill = [COPIES_EACH + 1] * NUM_ITEMS
ranges = array('i', fill)
ef = KnapsackEvaluationFunction(weights, volumes, KNAPSACK_VOLUME, copies)
odd = DiscreteUniformDistribution(ranges)
df = DiscreteDependencyTree(.1, ranges)
pop = GenericProbabilisticOptimizationProblem(ef, odd, df)
for MIMIC_TO_KEEP in MIMIC_TO_KEEP_pool:
mimic = MIMIC(MIMIC_SAMPLES, MIMIC_TO_KEEP, pop)
fit_mimic = FixedIterationTrainer(mimic, n_iteration)
print("calculating for MIMIC_TO_KEEP = %d" % MIMIC_TO_KEEP)
# Training
start_mimic = time.time()
fit_mimic.train()
end_mimic = time.time()
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)
rhc = RandomizedHillClimbing(hcp)
fit = FixedIterationTrainer(rhc, 2000000000)
fit.train()
print "RHC: " + str(ef.value(rhc.getOptimal()))
sys.exit()
sa = SimulatedAnnealing(100, .95, hcp)
maxiters_ga = [int(10**(0.25 * i)) for i in range(6, 26)] maxiters_mimic = [10 * i for i in range(1, 21)] SA_start_temp = 1E11 SA_temp_decay = 0.999 GA_popsize = 40 GA_toMate = 20 GA_mutationPercent = 0.5 GA_toMutate = int(GA_mutationPercent * GA_toMate) MIMIC_samples = 500 MIMIC_toKeep = 50 #======================== 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) """ #======================= # Random Hiil Climbing #======================= print "Starting Random Hill Climbing Seacrh..." rhc = RandomizedHillClimbing(hcp) rhc_iters = []
copies = array('i', fill)
# create weights and volumes
fill = [0] * NUM_ITEMS
weights = array('d', fill)
volumes = array('d', fill)
random.setSeed(1) # !!!!!
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) # value, volume, max_volume, the number of copies per element
odd = DiscreteUniformDistribution(ranges)
nf = DiscreteChangeOneNeighbor(ranges)
mf = DiscreteChangeOneMutation(ranges)
cf = UniformCrossOver()
df = DiscreteDependencyTree(.1, ranges)
# ---------------------------------------------------------------
N_ITERS = 100001
# MIMIC
start = time.time()
fit_hist = []
for n_samples in range(100, 1000, 200):
print n_samples
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)
start = time.time()
ga = StandardGeneticAlgorithm(200, 150, 25, gap)
fit = FixedIterationTrainer(ga, 1000)
fit.train()
end = time.time()
value = str(ef.value(ga.getOptimal()))
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)
nsample = 10
niters = [50, 100, 200, 500, 1000, 2000, 5000, 10000, 20000, 50000, 100000]
#-- R-Hill Climbing
rhc = RandomizedHillClimbing(hcp)
for iters in niters:
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)
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
def rhc_fac(args = {}):
