def OptKnapsack():
fitness = mlrose.Knapsack(weights=[
10, 5, 2, 8, 15, 4, 3, 6, 7, 20, 21, 25, 22, 28, 25, 24, 23, 26, 27, 30
],
values=[
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
14, 15, 16, 17, 18, 19, 20
],
max_weight_pct=0.6)
validate(fitness, size, 'Knapsack')
def knapsack(n_items=5):
max_val = 5
weights = np.random.choice(range(1, 10), n_items)
values = np.random.choice(range(1, max_val), n_items)
fitness_fn = mlrose.Knapsack(weights, values)
problem = mlrose.DiscreteOpt(length=n_items,
fitness_fn=fitness_fn,
max_val=max_val)
return problem
def create_problem(self):
"""weights = [10, 5, 2, 8, 15, 4, 12, 9, 7]
values = [1, 2, 3, 4, 5, 6, 7, 8, 9]"""
weights = [10, 5, 2, 8, 15]
values = [1, 2, 3, 4, 5]
max_weight_pct = 0.6
fitness = mlrose.Knapsack(weights, values, max_weight_pct)
problem = mlrose.DiscreteOpt(length=5,
fitness_fn=fitness,
maximize=True,
max_val=6)
return problem
def Knapsack(self, length=10, max_weight_pct=0.2, verbose=False):
def gen_data(length):
weights = []
values = []
max_weight = 50
max_val = 50
for i in range(length):
weights.append(np.random.randint(1, max_weight))
values.append(np.random.randint(1, max_val))
return [weights, values]
self.problem = 'knapsack{l}'.format(l=length)
self.verbose = verbose
weights, values = gen_data(length)
fitness_fn = mlrose.Knapsack(weights, values, max_weight_pct)
# define optimization problem object
self.problem_fit = mlrose.DiscreteOpt(length=len(weights),
fitness_fn=fitness_fn,
maximize=True)
def fitness_function(f, bits, rs, verbose):
if verbose:
print('\n\n----------', f, ':', bits, 'bits ----------')
if f == 'Four Peaks':
fitness_fn = mlrose.FourPeaks(
t_pct=0.15
) # Note: T= np.ceil(t_pct * n), per source code for FourPeaks.evaluate
elif f == 'MaxKColor':
# fitness_fn = mlrose.MaxKColor(edges) # default mlrose fitness function
# edges = [(0, 1), (0, 2), (1, 3), (2, 3)] # 4 nodes, 2 by 2 grid, no diagonals
# edges = [(0, 1), (0, 2), (0, 4), (1, 3), (2, 0), (2, 3), (3, 4)]
edges = generate_graph(bits)
kwargs = {'edges': edges}
fitness_fn = mlrose.CustomFitness(
kcolors_max,
**kwargs) # custom fitness function for maximization problem
elif f == 'Knapsack':
# weights = [10, 5, 2, 8, 15]
# values = [1, 2, 3, 4, 5]
weights, values = generate_knapsack(bits, rs)
if verbose:
print('\nKnapsack\n', weights, values)
max_weight_pct = 0.6
fitness_fn = mlrose.Knapsack(weights, values, max_weight_pct)
elif f == 'FlipFlop':
fitness_fn = mlrose.FlipFlop()
# Check fitness for ad-hoc states
# test_state = np.array([1, 0, 1, 1, 0])
# print("Fitness for test_state", test_state, ":", fitness_fn.evaluate(test_state))
return fitness_fn
y = state[10] + 2 * state[11] + 4 * state[12] + 8 * state[13] + 16 * state[
14] + 32 * state[15] + 64 * state[16] + 128 * state[17] + 256 * state[
18] + 512 * state[19]
z = max(
0, 10 * np.sin(x / 20 + 2.3) + 4 * (x % 10) + 10 * np.sin(y / 25 + 1) +
4 * (y % 15) + 20)
return z
multipeak_fn = mlrose.CustomFitness(multipeak_eq)
# Knapsack
knapsack_weights = [5, 10, 15, 20, 25, 30, 35, 40, 45]
knapsack_values = np.arange(1, len(knapsack_weights) + 1)
knapsack_max_weight = 0.7
knapsack_fn = mlrose.Knapsack(knapsack_weights, knapsack_values,
knapsack_max_weight)
# K-colors
kcolor_edges = [(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (0, 6), (0, 7), (0, 8),
(0, 9), (1, 4), (1, 5), (1, 6), (1, 7), (2, 3), (2, 5), (2, 7),
(3, 5), (3, 6), (3, 7), (3, 9), (4, 5), (5, 6), (5, 7), (5, 8),
(6, 7), (7, 8), (8, 9)]
kcolor_edges = list({tuple(sorted(edge)) for edge in kcolor_edges})
kcolor_fn = mlrose.MaxKColor(kcolor_edges)
def multipeak_prob_wrapper():
return mlrose.DiscreteOpt(length=20, fitness_fn=multipeak_fn)
def knapsack_prob_wrapper():
print('Genetic Algorithm: ')
print("Accuracy: ", aveAccuracyScoreGA)
print(
'///////////////////////////////////////////////////////////////////////////////'
)
edges = [(0, 1), (1, 4), (1, 3), (2, 4), (3, 7), (4, 5), (4, 6), (5, 6),
(5, 7), (6, 7), (5, 3), (0, 3), (0, 2), (1, 7), (1, 6), (0, 4),
(1, 2), (3, 4), (8, 0), (8, 4), (8, 2), (8, 1)]
weights = [3, 4, 5, 7, 9, 6, 10, 11]
values = [1, 2, 3, 4, 5, 6, 7, 8]
maxWeightPct = 2
fitnessArray = [
mlrose.Queens(),
mlrose.MaxKColor(edges),
mlrose.Knapsack(weights, values, maxWeightPct)
]
titleArray = ['Queens', 'Max Color', 'Knapsack']
for x in range(len(fitnessArray)):
aveFitnessRHC = 0
aveFitnessSA = 0
aveFitnessGA = 0
aveFitnessM = 0
aveTimeRHC = 0
aveTimeSA = 0
aveTimeGA = 0
aveTimeM = 0
for y in range(0, 10):
print('Results for: ', titleArray[x])
bestFitnessRHC, timeRHC = radomHillClimb(fitnessArray[x], x)
bestFitnessSA, timeSA = simulatedAnnealing(fitnessArray[x], x)
import mlrose
import matplotlib.pyplot as plt
from matplotlib.legend_handler import HandlerLine2D
weights = [
10, 4, 3, 2, 7, 9, 6, 8, 12, 14, 15, 18, 43, 23, 67, 15, 27, 18, 14, 12,
27, 45, 20
]
values = [
500, 25, 45, 900, 345, 456, 768, 980, 234, 564, 432, 568, 43, 11, 10, 11,
34, 23, 459, 23, 65, 32, 6889
]
print(len(weights), len(values))
max_weight_pct = 0.5
fitness = mlrose.Knapsack(weights, values, max_weight_pct)
problem_fit = mlrose.DiscreteOpt(length=19,
fitness_fn=fitness,
maximize=True,
max_val=3)
schedule = mlrose.ExpDecay()
init_state = np.array(
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
fitness1 = mlrose.Knapsack(weights[0:4], values[0:4], max_weight_pct)
fitness2 = mlrose.Knapsack(weights[0:7], values[0:7], max_weight_pct)
fitness3 = mlrose.Knapsack(weights[0:9], values[0:9], max_weight_pct)
fitness4 = mlrose.Knapsack(weights[0:11], values[0:11], max_weight_pct)
fitness5 = mlrose.Knapsack(weights[0:13], values[0:13], max_weight_pct)
fitness6 = mlrose.Knapsack(weights[0:16], values[0:16], max_weight_pct)
fitness7 = mlrose.Knapsack(weights[0:19], values[0:19], max_weight_pct)
fitness8 = mlrose.Knapsack(weights[0:20], values[0:20], max_weight_pct)
import matplotlib.style as style
import random
import pandas as pd
lengths = [10, 20, 40, 60, 80, 100]
avgAcross = 10
length = 50
print("SOLVING KnapSack")
print("Get fitness for 100 iters on all algos")
itersList = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
problem = mlrose.DiscreteOpt(length=50,
maximize=True,
fitness_fn=mlrose.Knapsack(
weights=np.random.uniform(size=length),
values=np.arange(1, length + 1, 1),
max_weight_pct=0.6))
fitnessRHCAll = []
fitnessSAAll = []
fitnessGAAll = []
fitnessMIMICAll = []
fitnessRHCMean = []
fitnessSAMean = []
fitnessGAMean = []
fitnessMIMICMean = []
fitnessRHCFilter = []
fitnessSAFilter = []
fitnessGAFilter = []
import random
import time
sample_sizes = []
weights = []
values = []
fitness = []
for x in range(10):
random.seed(x)
tempw = random.sample(range(1, 61), (x*6)+6)
random.seed(x)
tempv = random.sample(range(2, 62), (x*6)+6)
weights.append(tempw)
values.append(tempv)
fitness.append(ml.Knapsack(weights=weights[x], values=values[x]))
main_best_fit_gene = []
main_execution_times_gene = []
main_total_iterations_gene = []
main_opt_iterations_gene = []
for y in range(10):
best_fit_gene = []
execution_times_gene = []
total_iterations_gene = []
ga_statistics_fn_evals = []
ga_statistics_time = []
ga_statistics_fitness = []
mimic_statistics = []
mimic_statistics_fn_evals = []
mimic_statistics_time = []
mimic_statistics_fitness = []
mimic_state = []
mimic_fitness = []
index = 0
#Random Hill Climbing
for each in problem_size:
fitness_fn = mlrose.Knapsack(weights_list[index], values_list[index],
max_weight_pct)
problem = mlrose.DiscreteOpt(length=each,
fitness_fn=fitness_fn,
maximize=True,
max_val=2)
best_state, best_fitness, statistics = mlrose.random_hill_climb(
problem=problem,
max_attempts=max_attempts,
max_iters=max_iters,
restarts=10,
return_statistics=True)
rhc_state.append(best_state)
rhc_fitness.append(best_fitness)
rhc_statistics_fn_evals.append(statistics['fitness_evals'])
rhc_statistics_time.append(statistics['time'])
rhc_statistics_fitness.append(best_fitness)
def main():
name_of_exp = "Knapsack"
weights = [10, 5, 2, 8, 15]
values = [1, 2, 3, 4, 5]
max_weight_pct = 0.6
fitness = mlrose.Knapsack(weights, values, max_weight_pct)
problem = mlrose.DiscreteOpt(length=5,
fitness_fn=fitness,
maximize=True,
max_val=5)
# Define initial state
init_state = np.zeros(5)
x_s = []
y_s = []
z_s = ['RHC', 'SA', 'GA', 'MIMIC']
w_s = []
max_val = 18.0
found_flag = False
for restarts in np.arange(0, 5):
if found_flag:
break
for max_iter_atts in np.arange(10, 1000, 10):
if found_flag:
break
# Solve problem using simulated annealing
best_state, best_fitness, learning_curve, timing_curve = mlrose.random_hill_climb(
problem,
max_attempts=int(max_iter_atts),
max_iters=int(max_iter_atts),
restarts=int(restarts),
init_state=init_state,
curve=True,
random_state=1)
if best_fitness >= max_val:
x_s.append(np.arange(0, len(learning_curve)))
y_s.append(learning_curve)
w_s.append(timing_curve)
print(best_state)
print(best_fitness)
print(max_iter_atts)
print(restarts)
found_flag = True
found_flag = False
for sched in [mlrose.ExpDecay(), mlrose.GeomDecay(), mlrose.ArithDecay()]:
if found_flag:
break
for max_iter_atts in np.arange(10, 1000, 10):
if found_flag:
break
best_state, best_fitness, learning_curve, timing_curve = mlrose.simulated_annealing(
problem,
max_attempts=int(max_iter_atts),
max_iters=int(max_iter_atts),
schedule=sched,
init_state=init_state,
curve=True,
random_state=1)
if best_fitness >= max_val:
x_s.append(np.arange(0, len(learning_curve)))
y_s.append(learning_curve)
w_s.append(timing_curve)
print(best_state)
print(best_fitness)
print(max_iter_atts)
print(sched)
found_flag = True
found_flag = False
for prob in np.arange(0.1, 1.1, 0.1):
if found_flag:
break
for pop_size in np.arange(100, 5000, 100):
if found_flag:
break
for max_iter_atts in np.arange(10, 1000, 10):
if found_flag:
break
best_state, best_fitness, learning_curve, timing_curve = mlrose.genetic_alg(
problem,
pop_size=int(pop_size),
mutation_prob=prob,
max_attempts=int(max_iter_atts),
max_iters=int(max_iter_atts),
curve=True,
random_state=1)
if best_fitness >= max_val:
x_s.append(np.arange(0, len(learning_curve)))
y_s.append(learning_curve)
w_s.append(timing_curve)
print(best_state)
print(best_fitness)
print(max_iter_atts)
print(prob)
print(pop_size)
found_flag = True
found_flag = False
for prob in np.arange(0.1, 1.1, 0.1):
if found_flag:
break
for pop_size in np.arange(100, 5000, 100):
if found_flag:
break
for max_iter_atts in np.arange(10, 1000, 10):
if found_flag:
break
best_state, best_fitness, learning_curve, timing_curve = mlrose.mimic(
problem,
pop_size=int(pop_size),
keep_pct=prob,
max_attempts=int(max_iter_atts),
max_iters=int(max_iter_atts),
curve=True,
random_state=1,
fast_mimic=True)
if best_fitness >= max_val:
x_s.append(np.arange(0, len(learning_curve)))
y_s.append(learning_curve)
w_s.append(timing_curve)
print(best_state)
print(best_fitness)
print(max_iter_atts)
print(prob)
print(pop_size)
found_flag = True
for x, y, z in zip(x_s, y_s, z_s):
plt.plot(x, y, label=z)
plt.legend()
plt.title(
'Randomized Optimization Iterations vs Fitness Function Value for {}'.
format(name_of_exp))
plt.xlabel('Function iteration count')
plt.ylabel('Fitness function value')
plt.show()
plt.clf()
for x, w, z in zip(x_s, w_s, z_s):
plt.plot(x, w, label=z)
plt.legend()
plt.title(
'Randomized Optimization Time vs Fitness Function Value for {}'.format(
name_of_exp))
plt.xlabel('Function iteration count')
plt.ylabel('Time in Seconds')
plt.show()
def optimizationFunction(n,iMin, iMax, iStep, jMin, jMax, jStep):
np.random.seed(100)
optScenarios = ['Knap Sack', 'Four Peaks', 'K - Colors']
for x in range(3):
if x == 0:
weights = np.random.randint(1,10,size=n)
#values = np.random.randint(1,50,size=n)
values = [i for i in range(1,n+1)]
max_weight_pct = 0.5
fitnessFunction = mlrose.Knapsack(weights, values, max_weight_pct)
optModel = mlrose.DiscreteOpt(len(values), fitness_fn = fitnessFunction, maximize=True)
elif x == 1:
inp = [0] * int(n/2) + [1]*int(n - int(n/2))
np.random.shuffle(inp)
fitnessFunction = mlrose.FourPeaks(t_pct = 0.15)
optModel = mlrose.DiscreteOpt(len(inp), fitness_fn = fitnessFunction, maximize =True)
elif x == 2:
edges = [(np.random.randint(0,n), np.random.randint(0,n)) for ab in range(n)]
fitnessFunction = mlrose.MaxKColor(edges)
optModel = mlrose.DiscreteOpt(len(edges), fitness_fn = fitnessFunction, maximize =True)
decay = mlrose.ExpDecay()
optResults = {'iterations':[],'attempts':[],'fitness':[],'time':[], 'optimization':[]}
for i in range(iMin,iMax,iStep):
for j in range(jMin,jMax,jStep):
start_time = timer()
best_state, best_fitness = mlrose.random_hill_climb(optModel, max_attempts = j, max_iters = i, random_state=100)
opt_time = timer() - start_time
optResults['iterations'].append(i)
optResults['attempts'].append(j)
optResults['fitness'].append(best_fitness)
optResults['time'].append(opt_time)
optResults['optimization'].append('Random Hill')
start_time = timer()
best_state, best_fitness = mlrose.simulated_annealing(optModel, schedule=decay, max_attempts = j,max_iters = i,random_state=1000)
opt_time = timer() - start_time
optResults['iterations'].append(i)
optResults['attempts'].append(j)
optResults['fitness'].append(best_fitness)
optResults['time'].append(opt_time)
optResults['optimization'].append('Simulated Annealing')
start_time = timer()
best_state, best_fitness = mlrose.genetic_alg(optModel, pop_size=200, mutation_prob = 0.25, max_attempts = j, max_iters = i, random_state=5000)
opt_time = timer() - start_time
optResults['iterations'].append(i)
optResults['attempts'].append(j)
optResults['fitness'].append(best_fitness)
optResults['time'].append(opt_time)
optResults['optimization'].append('Genetic Algorithm')
start_time = timer()
best_state, best_fitness = mlrose.mimic(optModel, pop_size = 200, keep_pct = 0.3, max_attempts = j, max_iters = i, random_state=150)
opt_time = timer() - start_time
optResults['iterations'].append(i)
optResults['attempts'].append(j)
optResults['fitness'].append(best_fitness)
optResults['time'].append(opt_time)
optResults['optimization'].append('MIMIC')
optResults = pd.DataFrame(optResults)
plotGraphs(optResults,optScenarios[x])
def TravelingSalesman():
# Create list of city coordinates
"""
coords_list = [(1, 1), (4, 2), (5, 2), (6, 4), (4, 4), (3, 6), (1, 5), (2, 3), (10, 10), (15, 22), (2, 7), (19, 15), (11, 13),
(33, 24), (12, 17), (29, 2), (2, 5), (5, 19), (11, 36), (21, 37), (57, 22), (36, 12), (19, 20), (13, 19), (13, 54), (0, 5),
(44, 14), (45, 45), (23, 20), (16, 2), (3, 29), (21, 59), (18, 29), (2, 2), (19, 17), (39, 14), (9, 9), (48, 14), (59, 59), (29, 1)]
"""
weights = [
10, 5, 2, 8, 15, 20, 5, 2, 1, 20, 8, 6, 14, 22, 50, 5, 10, 12, 12, 18,
26, 32, 4, 8, 10, 5, 22, 10, 5, 2, 8, 15, 20, 5, 2, 1, 20, 8, 6, 14,
22, 50, 5, 10, 12, 12, 18, 26, 32, 4, 8, 10, 5, 22, 10, 5, 2, 8, 15,
20, 5, 2, 1, 20, 8, 6, 14, 22, 50, 5, 10, 12, 12, 18, 26, 32, 4, 8, 10,
5, 22
]
values = [
1, 2, 3, 4, 5, 2, 5, 10, 1, 4, 10, 2, 2, 8, 100, 5, 15, 24, 8, 14, 36,
10, 5, 2, 120, 4, 8, 1, 2, 3, 4, 5, 2, 5, 10, 1, 4, 10, 2, 2, 8, 100,
5, 15, 24, 8, 14, 36, 10, 5, 2, 120, 4, 8, 1, 2, 3, 4, 5, 2, 5, 10, 1,
4, 10, 2, 2, 8, 100, 5, 15, 24, 8, 14, 36, 10, 5, 2, 120, 4, 8
]
max_weight_pct = 0.6
#n = len(coords_list)
n = len(weights)
# Initialize fitness function object using coords_list
#fitness_coords = mlrose.TravellingSales(coords = coords_list)
fitness = mlrose.Knapsack(weights, values, max_weight_pct)
# Define optimization problem object
problem = mlrose.DiscreteOpt(length=n, fitness_fn=fitness, maximize=True)
best_state, best_fitness, score_curves, runtime = algorithm(
problem=problem, max_attempts=500, max_iters=100)
def plot_solution(algorithm_type: str, solution: list) -> None:
"""Given a solution, plot it and save the result to disk."""
fig = plt.figure()
ax = fig.add_subplot(111, aspect='equal')
ax.set_xlim((0, n))
ax.set_ylim((0, n))
count = 0
for queen in solution:
ax.add_patch(patches.Rectangle((queen, count), 1, 1))
count += 1
fig.savefig(algorithm_type + '_' +
''.join([str(a) for a in solution]) + '.png',
dpi=150,
bbox_inches='tight')
plt.close(fig)
for key, value in best_state.items():
plot_solution(key, value)
def PlotData(x, y, x2, y2, x3, y3, x4, y4):
plt.figure()
plt.plot(x, y, 'r', x2, y2, 'g', x3, y3, 'b', x4, y4, 'c', alpha=0.5)
plt.xlabel('Iteration')
plt.ylabel('Fitness')
red_patch = patches.Patch(color='red', label='Genetic Algorithms')
green_patch = patches.Patch(color='green', label='Simulated Annealing')
blue_patch = patches.Patch(color='blue', label='MIMIC')
cyan_patch = patches.Patch(color='cyan', label='Randomized Hill Climb')
plt.legend(handles=[red_patch, green_patch, blue_patch, cyan_patch])
plt.show()
PlotData(list(range(len(score_curves['genetic algorithm']))),
score_curves['genetic algorithm'],
list(range(len(score_curves['simulated annealing']))),
score_curves['simulated annealing'],
list(range(len(score_curves['mimic']))), score_curves['mimic'],
list(range(len(score_curves['randomized hill climbing']))),
score_curves['randomized hill climbing'])
return best_state, best_fitness, score_curves, runtime
#best_state, best_fitness, curve = ml.mimic(opt, curve=True, random_state = 2)
print(curve)
plt.plot(curve)
plt.savefig("4pks.png")
print(best_state)
print(best_fitness)
weights = [10.0, 5.0, 2.0, 8.0, 15.0, 3.0, 11.0]
values = [1, 12, 3, 14, 5, 10, 12]
max_weight_pct = 0.35
fitness_two = ml.Knapsack(weights=weights, values=values, max_weight_pct=max_weight_pct)
opt_two = ml.DiscreteOpt(length=7, fitness_fn=fitness_two)
#state = np.array([0, 1, 1, 1, 0])
#sprint(fitness_two.evaluate(state))
best_state_two, best_fitness_two = ml.genetic_alg(opt_two, random_state = 2)
#best_state_two, best_fitness_two = ml.random_hill_climb(opt_two, random_state = 2)
best_state_two, best_fitness_two = ml.simulated_annealing(opt_two, max_iters=1, random_state = 2)
#best_state_two, best_fitness_two = ml.mimic(opt_two, max_iters=1, random_state = 2)
print(best_state_two)
# print(tsp_iterations)
# print(tsp_rhfit)
# print(tsp_smfit)
# print(tsp_gafit)
# print(tsp_mifit)
#knapsack
print("Travelling Knapsack")
max_weight_pct = 0.6
for items in range(5, 10, 5):
ks_weights = random.sample(range(1, items * 2), items)
ks_values = list(range(1, items + 1))
max_weight_pct = 0.6
weight_range = random.randint(2, int(items / 2) + 1)
init_state_ks = np.random.randint(weight_range, size=items)
fitness_ks = mlrose.Knapsack(ks_weights, ks_values, max_weight_pct)
problem_ks = mlrose.DiscreteOpt(length=init_state_ks.shape[0],
fitness_fn=fitness_ks,
maximize=False)
#ks_iterations = [10,20,50,75,100,125,200,250,300]
ks_iterations = [1]
max_attempts = 10
ks_rh_fitness = []
ks_sm_fitness = []
ks_ga_fitness = []
ks_mi_fitness = []
for ks_iter in ks_iterations:
#ks_rh_starttime = timeit.timeit()
#ks_rh_bestfit =randomHill(problem_ks,init_state_ks,max_attempts,ks_iter)
#ks_rh_endtime = timeit.timeit()
#print("RH Start Time")
#Knapsack Genetic
import mlrose
import mlrose
import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler, OneHotEncoder
from sklearn.metrics import accuracy_score
weights = [10, 5, 2, 8, 15]
values = [1, 2, 3, 4, 5]
max_weight_pct = 0.6
# Initialize fitness function object using pre-defined class
fitness = mlrose.Knapsack(weights, values, max_weight_pct)
# Define optimization problem object
problem = mlrose.DiscreteOpt(length = 5, fitness_fn = fitness, maximize=True, max_val=5)
# Define decay schedule
schedule = mlrose.ExpDecay()
# Solve using simulated annealing - attempt 1
init_state = np.array([0, 1, 2, 3, 4])
# Start Timer
from timeit import default_timer as timer
start = timer()
# Run Simulated Annealing
best_state, best_fitness,fit_curve = mlrose.genetic_alg(problem,max_attempts = 1000,
max_iters = 1000,
curve=True,random_state = 1)
# Stop Timer
elapsed_time = timer() - start # in seconds
'elite': 0.3,
'pop_size': ['5*problem_length'],
'mutation_prob': 0.1,
'max_attempts': 10
},
},
}
# for k, d in algorithms.items():
# d['problem'] = problem
# d['param_grid_problem'] = param_grid_problem
for algo_name, settings in algorithms.items():
results[algo_name] = []
for n_item in n_items:
fitness_fn = mlrose.Knapsack(weights[n_item], values[n_item],
maxWeight)
param_grid_problem = {
'fitness_fn': fitness_fn,
'max_val': 2,
'length': n_item,
}
thisSettings = copy.deepcopy(settings.copy())
thisSettings['problem'] = problem
thisSettings['param_grid_problem'] = param_grid_problem
print(f"Looping for {algo_name}, n_item={n_item}")
gs = mlrose.GridSearch(
algorithm=thisSettings['algorithm'],
param_grid_algorithm=thisSettings['param_grid_algorithm'],
problem=thisSettings['problem'],
mean_fitness_list.append(np.mean(fitness_score_MIMIC))
mean_time_list.append(np.mean(time_score_MIMIC))
fitness_list.append(fitness_score_MIMIC)
print("mimic out ")
# ===================================================================================
# ============================= PLOT THE FINAL CURVE ==============================================
# ==================================================================================
print("curve in")
algorithms = ["RHC", "GA", "SA", "MIMIC"]
algorithm_compare(fitness_list, algorithms, question, iterations)
mean_time_compare(mean_time_list, algorithms, question)
score_compare(mean_fitness_list, algorithms, question)
print("curve out")
if __name__ == "__main__":
print("Knap in")
seed = 12
w, v = get_data()
fitness = mlrose.Knapsack(weights=w, values=v)
problem = mlrose.DiscreteOpt(length=25, fitness_fn=fitness, maximize=True, max_val=2)
print('Created Problem')
find_best_param_ga_pop_size(seed, problem)
find_best_param_ga_mutation_prob(seed, problem)
find_best_param_sa_decay(seed, problem)
find_best_param_mimic_keep_cpt(seed, problem)
process_cp_with_four_algo(seed, problem)
print("continue_peaks OUT")
def run_knapsack():
if not os.path.exists('./output/Knapsack/'):
os.mkdir('./output/Knapsack/')
logger = logging.getLogger(__name__)
problem_size = 25
prob_size_int = int(problem_size)
weights = [
int(np.random.randint(1, prob_size_int / 2))
for _ in range(prob_size_int)
]
values = [
int(np.random.randint(1, prob_size_int / 2))
for _ in range(prob_size_int)
]
flip_fit = mlrose.Knapsack(weights, values)
flop_state_gen = lambda: np.random.randint(0, 1, size=prob_size_int)
init_state = flop_state_gen()
problem = mlrose.DiscreteOpt(length=prob_size_int,
fitness_fn=flip_fit,
maximize=True,
max_val=2)
all_results = {}
"""
print("Running simulated annealing montecarlos")
sa_results, sa_timing = sim_annealing_runner(problem)
sa_best_params=plot_montecarlo_sensitivity('Knapsack', 'sim_anneal', sa_results)
plot_montecarlo_sensitivity('Knapsack', 'sim_anneal_timing', sa_timing)
all_results['SA'] = [sa_results, sa_timing]
print("Running random hill montecarlos")
rhc_results, rhc_timing = rhc_runner(problem)
rhc_best_params = plot_montecarlo_sensitivity('Knapsack', 'rhc', rhc_results)
plot_montecarlo_sensitivity('Knapsack', 'rhc_timing', rhc_timing)
all_results['RHC'] = [rhc_results, rhc_timing]
print("Running genetic algorithm montecarlos")
ga_results, ga_timing = ga_runner(problem, init_state)
ga_best_params = plot_montecarlo_sensitivity('Knapsack', 'ga', ga_results)
plot_montecarlo_sensitivity('Knapsack', 'ga_timing', ga_timing)
all_results['GA'] = [ga_results, ga_timing]
print("Running MIMIC montecarlos")
mimic_results, mimic_timing = mimic_runner(problem, init_state)
MIMIC_best_params = plot_montecarlo_sensitivity('Knapsack', 'mimic', mimic_results)
plot_montecarlo_sensitivity('Knapsack', 'mimic_timing', mimic_timing)
all_results['MIMIC'] = [mimic_results, mimic_timing]
"""
with open('./output/Knapsack/flipflip_data.pickle', 'wb') as handle:
pickle.dump(all_results, handle, protocol=pickle.HIGHEST_PROTOCOL)
problem_size_space = np.linspace(5, 80, 10, dtype=int)
best_fit_dict = {}
best_fit_dict['Problem Size'] = problem_size_space
best_fit_dict['Random Hill Climbing'] = []
best_fit_dict['Simulated Annealing'] = []
best_fit_dict['Genetic Algorithm'] = []
best_fit_dict['MIMIC'] = []
times = {}
times['Problem Size'] = problem_size_space
times['Random Hill Climbing'] = []
times['Simulated Annealing'] = []
times['Genetic Algorithm'] = []
times['MIMIC'] = []
fits_per_iteration = {}
fits_per_iteration['Random Hill Climbing'] = []
fits_per_iteration['Simulated Annealing'] = []
fits_per_iteration['Genetic Algorithm'] = []
fits_per_iteration['MIMIC'] = []
for prob_size in problem_size_space:
logger.info("---- Problem size: " + str(prob_size) + " ----")
prob_size_int = int(prob_size)
weights = [
int(np.random.randint(1, prob_size / 2))
for _ in range(prob_size_int)
]
values = [
int(np.random.randint(1, prob_size / 2))
for _ in range(prob_size_int)
]
flip_fit = mlrose.Knapsack(weights, values, max_weight_pct=0.5)
flop_state_gen = lambda: np.random.randint(0, 1, size=prob_size_int)
init_state = flop_state_gen()
problem = mlrose.DiscreteOpt(length=prob_size_int,
fitness_fn=flip_fit,
maximize=True,
max_val=2)
start = datetime.now()
best_state_sa, best_fitness_sa, fitness_curve_sa = mlrose.simulated_annealing(
problem,
schedule=mlrose.ExpDecay(exp_const=.701,
init_temp=4.6,
min_temp=.401),
max_attempts=260,
max_iters=1100,
curve=True)
best_fit_dict['Simulated Annealing'].append(best_fitness_sa)
end = datetime.now()
times['Simulated Annealing'].append((end - start).total_seconds())
start = datetime.now()
best_state_rhc, best_fitness_rhc, fitness_curve_rhc = mlrose.random_hill_climb(
problem, max_attempts=260, max_iters=1100, restarts=40, curve=True)
best_fit_dict['Random Hill Climbing'].append(best_fitness_rhc)
end = datetime.now()
times['Random Hill Climbing'].append((end - start).total_seconds())
start = datetime.now()
best_state_ga, best_fitness_ga, fitness_curve_ga = mlrose.genetic_alg(
problem,
pop_size=99,
mutation_prob=.01,
max_attempts=410,
max_iters=1100,
curve=True)
best_fit_dict['Genetic Algorithm'].append(best_fitness_ga)
end = datetime.now()
times['Genetic Algorithm'].append((end - start).total_seconds())
start = datetime.now()
best_state_mimic, best_fitness_mimic, fitness_curve_mimic = mlrose.mimic(
problem,
pop_size=90,
keep_pct=.21,
max_attempts=10,
max_iters=1100,
curve=True)
best_fit_dict['MIMIC'].append(best_fitness_mimic)
end = datetime.now()
times['MIMIC'].append((end - start).total_seconds())
# For the last fit that occurs, save off the fit arrays that are generated. We will plot fitness/iteration.
fits_per_iteration['Random Hill Climbing'] = fitness_curve_rhc
fits_per_iteration['Simulated Annealing'] = fitness_curve_sa
fits_per_iteration['Genetic Algorithm'] = fitness_curve_ga
fits_per_iteration['MIMIC'] = fitness_curve_mimic
fit_frame = pd.DataFrame.from_dict(best_fit_dict,
orient='index').transpose()
# fit_frame.pop('Unnamed: 0') # idk why this shows up.
time_frame = pd.DataFrame.from_dict(times, orient='index').transpose()
# time_frame.pop('Unnamed: 0') # idk why this shows up.
fit_iteration_frame = pd.DataFrame.from_dict(fits_per_iteration,
orient='index').transpose()
fit_frame.to_csv('./output/Knapsack/problem_size_fit.csv')
time_frame.to_csv('./output/Knapsack/problem_size_time.csv')
fit_iteration_frame.to_csv('./output/Knapsack/fit_per_iteration.csv')
import mlrose
import numpy as np
weights=[11,15,3,4,5,6,10,13]
values=[5,7,1,2,1,3,4,11]
bweights=np.random.rand(30)
bvals=np.random.rand(30)
fitness=mlrose.Knapsack(weights,values,0.35)
init_state=np.zeros(len(weights))
problem = mlrose.DiscreteOpt(length = len(weights), fitness_fn = fitness,
maximize = True,max_val=2)
'''Simulated Annealing'''
schedule = mlrose.GeomDecay()
# Set random seed
np.random.seed(1)
# SA
opt_state, opt_fit = mlrose.simulated_annealing(problem, schedule = schedule,
max_attempts = 100000, max_iters = 1000000000000,
sys.modules['sklearn.externals.six'] = six
import mlrose
import numpy as np
import time
probSize = int(sys.argv[2])
thre = float(sys.argv[4])
popu = int(sys.argv[6])
mutP = float(sys.argv[8])
maxIter = int(sys.argv[10])
rseed = int(sys.argv[12])
np.random.seed(123)
weights = np.random.uniform(size=probSize)
values = np.random.uniform(size=probSize)
fitnessF = mlrose.Knapsack(weights=weights, values=values, max_weight_pct=thre)
problemFit = mlrose.DiscreteOpt(length=probSize,
fitness_fn=fitnessF,
maximize=True,
max_val=2)
# max_val: number of unique values each element in the state vector can take.
timeStart = time.time()
# Double checked. The new generation does not take in parent generation.
best_state, best_fitness, fitness_curve = mlrose.genetic_alg(
problemFit,
pop_size=popu,
mutation_prob=mutP,
max_attempts=int(1e9),
max_iters=maxIter,
curve=True,
def KnapSack(weights, values, sizeOrIterations):
max_pct = .6
fitness = mlrose.Knapsack(weights, values, max_pct)
total = 0
for item in weights:
total = total + item
print (total)
problem = mlrose.DiscreteOpt(length = len(weights), fitness_fn = fitness, maximize = True, max_val = 3)
rhcfitnessMatrix = []
safitnessMatrix = []
genalgfitnessMatrix = []
mimicfitnessMatrix = []
numIterations = 10000
dataPoints = 100
#rhc
print("Begin RHC")
startingTime = time()
for i in range(numIterations):
if i % dataPoints == 0 and not sizeOrIterations or i == 1000 and sizeOrIterations:
print("RHC I: " + str(i))
t0 = time()
best_state, best_fitness = mlrose.random_hill_climb(problem, max_attempts=100, max_iters=i,
init_state=None)
finish = time() - t0
currentTime = time() - startingTime
print("CurrentTime: " + str(currentTime))
rhcfitnessMatrix.append((i, best_fitness, finish))
finishtime = time() - startingTime
print("Finish Time: " + str(finishtime))
#simulated annealing
schedule = mlrose.ExpDecay()
startingTime = time()
for i in range(numIterations):
if i % dataPoints == 0 and not sizeOrIterations or i == 1000 and sizeOrIterations:
print("SA I: " + str(i))
t0 = time()
best_state, best_fitness = mlrose.simulated_annealing(problem, schedule = schedule,
max_attempts = 100, max_iters = i,
init_state = None)
finish = time() - t0
currentTime = time() - startingTime
print("CurrentTime: " + str(currentTime))
safitnessMatrix.append((i, best_fitness, finish))
finishtime = time() - startingTime
print("Finish Time: " + str(finishtime))
#genetic alg
startingTime = time()
for i in range(numIterations):
if i % dataPoints == 0 and not sizeOrIterations or i == 1000 and sizeOrIterations:
print("GA I: " + str(i))
t0 = time()
best_state, best_fitness = mlrose.genetic_alg(problem, pop_size=200, mutation_prob=0.1, max_attempts=100,
max_iters=i)
finish = time() - t0
currentTime = time() - startingTime
print("CurrentTime: " + str(currentTime))
genalgfitnessMatrix.append((i, best_fitness, finish))
finishtime = time() - startingTime
print("Finish Time: " + str(finishtime))
#mimic
startingTime = time()
for i in range(numIterations):
if i % dataPoints == 0 and not sizeOrIterations or i == 1000 and sizeOrIterations:
print("Mimic I: " + str(i))
t0 = time()
best_state, best_fitness = mlrose.mimic(problem, pop_size=200, keep_pct=0.3, max_attempts=100, max_iters=i)
finish = time() - t0
currentTime = time() - startingTime
print("CurrentTime: " + str(currentTime))
mimicfitnessMatrix.append((i, best_fitness, finish))
finishtime = time() - startingTime
print("Finish Time: " + str(finishtime))
if not sizeOrIterations:
writeToExcel.writeOptimzationProblem(rhcfitnessMatrix, safitnessMatrix, genalgfitnessMatrix, mimicfitnessMatrix, "KSIterations.xlsx")
return None
else:
return rhcfitnessMatrix, safitnessMatrix, genalgfitnessMatrix, mimicfitnessMatrix
