def plot_RHCRestarts(problem, problem_fit, max_attempts, maxIter, seed, min=False):
restarts = [0, 1, 5, 10, 50, 100]
plt.figure()
global start, times, evals, iter_total, rhc_curve, eval_count, algo_in
eval_count, iter_total, times, evals = 0, 0, [], []
for r in restarts:
print('restarts', r)
best_state, best_fitness, rhcfitness_curve = mlrose.random_hill_climb(problem_fit, curve=True,
max_attempts=max_attempts,
state_fitness_callback=callback_func,
callback_user_info=[], restarts=r,
random_state=seed, max_iters=maxIter)
if min:
rhcfitness_curve = np.array(rhcfitness_curve) * -1
plt.plot(rhcfitness_curve, label='restarts = ' + str(r))
plt.title(problem + " - RHC - Restarts")
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("Images\\" + problem + " - RHC - Restarts")
plt.show()
def rhc(opt):
global count
count = 0
rhc_loss_list = []
rhc_train_acc_list = []
rhc_test_acc_list = []
for num_restart in range(0, 101, 5):
best_state_spam, best_fitness_spam, _ = mlrose.random_hill_climb(
opt, restarts=num_restart, curve=False)
train_predict_hill = predict(best_state_spam, train_features_spam_norm)
test_predict_hill = predict(best_state_spam, test_features_spam_norm)
train_accuracy_hill = accuracy_score(train_labels_spam,
train_predict_hill)
test_accuracy_hill = accuracy_score(test_labels_spam,
test_predict_hill)
rhc_loss_list.append(best_fitness_spam)
rhc_train_acc_list.append(train_accuracy_hill)
rhc_test_acc_list.append(test_accuracy_hill)
plt.figure(figsize=(10, 6))
plt.subplot(121)
plt.plot(np.arange(0, 101, 5), rhc_loss_list, label='-1*loss')
plt.xlabel('random restart num')
plt.ylabel('minus of loss')
plt.title('loss versus restart num')
plt.legend(loc='lower right')
plt.subplot(122)
plt.plot(np.arange(0, 101, 5), rhc_train_acc_list, label='train')
plt.plot(np.arange(0, 101, 5), rhc_test_acc_list, label='test')
plt.xlabel('random restart num')
plt.ylabel('accuracy')
plt.title('accuracy versus restart num')
plt.legend(loc='lower right')
plt.show()
def call_mlrose_curve(algorith_keyword, problem, pop_size=200, mutation_prob=0.1, max_attempts=10, max_iters=np.inf, curve=False\
, random_state=None, schedule=mlrose.GeomDecay(), init_state=None, restarts=0, keep_pct=0.2, fast_mimic=True):
if algorith_keyword == 'RHC':
best_state, best_fitness, curve_output = mlrose.random_hill_climb(problem, max_attempts=max_attempts, max_iters=max_iters\
, restarts=restarts, init_state=init_state, curve=curve, random_state=random_state)
elif algorith_keyword == 'GA':
best_state, best_fitness, curve_output = mlrose.genetic_alg(problem, pop_size=pop_size, mutation_prob=mutation_prob\
, max_attempts=max_attempts, max_iters=max_iters, curve=curve, random_state=random_state)
elif algorith_keyword == 'SA':
best_state, best_fitness, curve_output = mlrose.simulated_annealing(problem, schedule=schedule, max_attempts=max_attempts\
,max_iters=max_iters, init_state=init_state, curve=curve, random_state=random_state)
elif algorith_keyword == 'MIMIC':
print("problem: ", problem, "\npop_size: ", pop_size, "\n",
"keep_pct: ", keep_pct)
print("max_attempts: ", max_attempts, "\nmax_iters: ", max_iters,
"\nrandom_state: ", random_state, "\nfast_mimic: ", fast_mimic)
best_state, best_fitness, curve_output = mlrose.mimic(problem, pop_size=pop_size, keep_pct=keep_pct\
, max_attempts=max_attempts, max_iters=max_iters, curve=curve, random_state=random_state)
print("best_fitness: ", best_fitness)
else:
print(
"\n\nIncorrect 'algorithm_keyword'. Please check the input to the 'call_mlrose' function.\n\n"
)
best_state, best_fitness, curve_output = 'incorrect key word', 'incorrect key word', 'incorrect key word'
return best_state, best_fitness, curve_output
def compare_methods(num_char):
global count
count=0
fitness_obj=mlrose.CustomFitness(heter_string_fn)
opt=mlrose.DiscreteOpt(num_char,fitness_obj,maximize=True,max_val=num_char)
best_state_climb,best_fitness_climb,fitness_curve_climb=mlrose.random_hill_climb(opt,curve=True)
print('---------------------random hill climb-------------------------')
print('hill climbing best state for heter-string problem:',best_state_climb)
print('hill climbing best fitness for heter-string problem:',best_fitness_climb)
print('hill climbing fitting curve for heter-string problem:',fitness_curve_climb)
print('number of fitness call used:',count)
count=0
print('-------------------simulated annealing-------------------------')
best_state_ann,best_fitness_ann,fitness_curve_ann=mlrose.simulated_annealing(opt,schedule=mlrose.ExpDecay(),curve=True)
print('simulated annealing best state for heter-string problem:',best_state_ann)
print('simulated annealing best fitness for heter-string problem:',best_fitness_ann)
print('simulated annealing fitting curve for heter-string problem:',fitness_curve_ann)
print('number of fitness call used:',count)
count=0
best_state_ga,best_fitness_ga,fitness_curve_ga=mlrose.genetic_alg(opt,pop_size=200, mutation_prob=0.5,curve=True)
print('---------------------genetic alg----------------------------')
print('genetic algorithm best state for heter-string problem:',best_state_ga)
print('genetic algorithm best fitnees for heter-string problem:',best_fitness_ga)
print('genetic algorithm fitness curve for heter-string problem:',fitness_curve_ga)
print('number of fitness call used:',count)
count=0
best_state_mimic,best_fitness_mimic,fitness_curve_mimic=mlrose.mimic(opt,pop_size=200,curve=True)
print('------------------------mimic-------------------------------')
print('mimic best state for heter-string problem:',best_state_mimic)
print('mimic best fitness value for heter-string problem:',best_fitness_mimic)
print('mimic curve for heter-string problem:',fitness_curve_mimic)
print('number of fitness call used:',count)
count=0
plt.figure(figsize=(10,10))
plt.subplot(221)
plt.plot(fitness_curve_climb)
plt.ylabel('fitness')
plt.xlabel('num_iter')
plt.ylim(20,50)
plt.title('random hill climb')
plt.subplot(222)
plt.plot(fitness_curve_ann)
plt.ylabel('fitness')
plt.xlabel('num_iter')
plt.ylim(20,50)
plt.title('simulated annealing')
plt.subplot(223)
plt.plot(fitness_curve_ga)
plt.ylim(20,50)
plt.ylabel('fitness')
plt.xlabel('num_iter')
plt.title('genetic algorithm')
plt.subplot(224)
plt.plot(fitness_curve_mimic)
plt.ylim(20,50)
plt.title('mimic')
plt.ylabel('fitness')
plt.xlabel('num_iter')
plt.show()
def random_hill_climb(problem_fit, vectorLength, data_dir, iterlist):
directory = "./" + data_dir + "/curves/"
if not os.path.exists(directory):
os.makedirs(directory)
path1 = './' + data_dir
path2 = "./" + data_dir + "/curves/"
restartl = []
beststate = []
bestfit = []
curve = []
time = []
iterlistn = []
for rs in (0, 5, 10, 15, 20, 25):
for iters in iterlist:
iterlistn.append(int(iters))
restartl.append(rs)
start = clock()
best_state, best_fitness, train_curve = mlrose.random_hill_climb(problem_fit, \
restarts=rs,\
max_iters=int(iters), curve=True, random_state=randomSeed)
end = clock()
time.append(end - start)
beststate.append(best_state)
bestfit.append(best_fitness)
curve.append(train_curve)
if (verbose == True):
print(rs)
print(int(iters))
print(best_state)
print(best_fitness)
ffrhc = pd.DataFrame({
'Restarts': restartl,
'Best Fitness': bestfit,
'Iterations': iterlistn,
'Time': time
})
rhcbeststatedf = pd.DataFrame(0.0,
index=range(1, vectorLength + 1),
columns=range(1,
len(beststate) + 1))
for i in range(1, len(beststate) + 1):
rhcbeststatedf.loc[:, i] = beststate[i - 1]
ffrhc.to_csv(os.path.join(path1, 'rhc.csv'))
rhcbeststatedf.to_csv(os.path.join(path1, 'rhcstates.csv'))
for i in range(len(curve)):
rhccurvedf = pd.DataFrame(curve[i])
rhccurvedf.to_csv(
os.path.join(path2,
'rhccurve{}_{}.csv'.format(restartl[i],
iterlistn[i])))
def n_queens_rhc(nq_problem,
initial_state,
max_iters=np.inf,
num_runs=20,
verbose=False):
hp_name = 'restarts'
hp_values = [10, 20, 30]
# run for each hp value and append results to list
fitness_dfs = []
runs = np.arange(num_runs)
for hp_value in hp_values:
restarts = hp_value # set varied HP at beginning of loop
run_times = np.zeros(num_runs)
fitness_data = pd.DataFrame()
for run in runs:
run_t0 = time()
best_state, best_fitness, fitness_curve = mlrose.random_hill_climb(
problem=nq_problem,
restarts=restarts,
max_attempts=10,
max_iters=max_iters,
init_state=initial_state,
curve=True,
)
run_time = time() - run_t0
run_times[run] = run_time
fitness_data = pd.concat(
[fitness_data, pd.DataFrame(fitness_curve)],
axis=1,
sort=False)
fitness_data.columns = runs
fitness_data = fitness_data.fillna(method='ffill')
fitness_dfs.append(fitness_data)
# calculate and print avg time per run
avg_run_time = np.average(run_times)
print("N-Queens - RHC avg run time,", hp_value, hp_name, ":",
avg_run_time)
# generate plots
plot_title = "N-Queens RHC: fitness vs. iterations"
plotting.plot_fitness_curves(
fitness_dfs=fitness_dfs,
hp_values=hp_values,
hp_name=hp_name,
title=plot_title,
)
plt.savefig('graphs/n_queens_rhc_fitness.png')
plt.clf()
return fitness_dfs
def rhc(problem, init_state, max_attempts, max_iters):
best_state, best_fitness, fitness_curve = mlrose_hiive.random_hill_climb(problem,
max_attempts = max_attempts, max_iters = max_iters, restarts = 100,
init_state = init_state, curve=True, random_state = 1)
print('random hill climbing')
print(best_state)
print(best_fitness)
# print(fitness_curve)
return best_state, best_fitness, fitness_curve
def compare_multi_round_k_color():
global count
count = 0
fitness_obj = mlrose.CustomFitness(k_color_fit)
opt = mlrose.DiscreteOpt(50, fitness_obj, maximize=True, max_val=8)
fitness_list_rhc = []
fitness_list_ann = []
fitness_list_genetic = []
fitness_list_mimic = []
num_sample_rhc = []
num_sample_ann = []
num_sample_genetic = []
num_sample_mimic = []
for i in range(20):
best_state_climb, best_fitness_climb, fitness_curve_climb = mlrose.random_hill_climb(
opt, curve=True)
fitness_list_rhc.append(best_fitness_climb)
num_sample_rhc.append(count)
count = 0
best_state_ann, best_fitness_ann, fitness_curve_ann = mlrose.simulated_annealing(
opt, schedule=mlrose.ExpDecay(), curve=True)
fitness_list_ann.append(best_fitness_ann)
num_sample_ann.append(count)
count = 0
best_state_ga, best_fitness_ga, fitness_curve_ga = mlrose.genetic_alg(
opt, pop_size=500, mutation_prob=0.5, curve=True)
fitness_list_genetic.append(best_fitness_ga)
num_sample_genetic.append(count)
count = 0
best_state_mimic, best_fitness_mimic, fitness_curve_mimic = mlrose.mimic(
opt, pop_size=500, curve=True)
fitness_list_mimic.append(best_fitness_mimic)
num_sample_mimic.append(count)
count = 0
plt.figure(figsize=(10, 6))
plt.subplot(121)
plt.plot(fitness_list_rhc, label='rhc')
plt.plot(fitness_list_ann, label='ann')
plt.plot(fitness_list_genetic, label='ga')
plt.plot(fitness_list_mimic, label='mimic')
plt.xlabel('rounds')
plt.ylabel('finess value')
plt.title('fitness value comparision')
plt.legend(loc='lower right')
plt.subplot(122)
plt.plot(num_sample_rhc, label='rhc')
plt.plot(num_sample_ann, label='ann')
plt.plot(num_sample_genetic, label='ga')
plt.plot(num_sample_mimic, label='mimic')
plt.xlabel('rounds')
plt.ylabel('fitness calls')
plt.title('fitness call number comparision')
plt.legend(loc='upper right')
plt.show()
def get_hill_climb(problem, restarts=30):
best_state, best_fitness, fitness_curve = mlrose.random_hill_climb(
problem,
max_attempts=100,
max_iters=np.inf,
restarts=restarts,
init_state=None,
curve=True,
random_state=23)
return best_state, best_fitness, fitness_curve
def rhc_optimization(size):
algo = 'rhc'
problem = get_problem(size)
# Gridsearch params
max_iters = 500
restarts_values = [10, 30, 50]
max_attempts_values = [10, 50, 100, 200]
n_runs = len(restarts_values) * len(max_attempts_values)
# Best vals
restarts, max_attempts = None, None
fitness, curves, n_invocations, time = float('-inf'), [], 0, 0
# Gridsearch
global eval_count
run_counter = 0
for run_restarts in restarts_values:
for run_max_attempts in max_attempts_values:
# Print status
run_counter += 1
print(
f'RUN {run_counter} of {n_runs} [restarts: {run_restarts}] [max_attempts: {run_max_attempts}]')
# Run problem
eval_count = 0
start = timer()
run_state, run_fitness, run_curves = mlrose_hiive.random_hill_climb(problem,
restarts=run_restarts,
max_attempts=run_max_attempts,
max_iters=max_iters,
random_state=42,
curve=True)
end = timer()
# Save curves and params
if run_fitness > fitness:
restarts = run_restarts
max_attempts = run_max_attempts
fitness = run_fitness
curves = run_curves
n_invocations = eval_count
time = end - start
df = pandas.DataFrame(curves, columns=['fitness'])
df['restarts'] = restarts
df['max_attempts'] = max_attempts
df['max_iters'] = max_iters
df['n_invocations'] = n_invocations
df['time'] = time
df.to_csv(f'{STATS_FOLDER}/{algo}_{size}_stats.csv', index=False)
print(f'{algo}_{size} run.')
def test_random_hill_climb_continuous_min():
"""Test random_hill_climb function for a continuous minimization
problem"""
problem = ContinuousOpt(5, OneMax(), maximize=False)
best_state, best_fitness, _ = random_hill_climb(problem,
max_attempts=10,
restarts=20)
x = np.array([0, 0, 0, 0, 0])
assert (np.array_equal(best_state, x) and best_fitness == 0)
def test_random_hill_climb_discrete_max():
"""Test random_hill_climb function for a discrete maximization
problem"""
problem = DiscreteOpt(5, OneMax(), maximize=True)
best_state, best_fitness, _ = random_hill_climb(problem,
max_attempts=10,
restarts=20)
x = np.array([1, 1, 1, 1, 1])
assert (np.array_equal(best_state, x) and best_fitness == 5)
def plot_optimization_problem_fitness(fitness_function, iterations, random_state, title):
start_rhc = timeit.default_timer()
rhc_best_state, rhc_best_fitness, rch_fitness_curve = mlrose.random_hill_climb(fitness_function, max_iters=iterations, random_state= random_state, restarts=10, curve=True)
rhc_elapsed = timeit.default_timer() - start_rhc
start_sa = timeit.default_timer()
sa_best_state, sa_best_fitness, sa_fitness_curve = mlrose.simulated_annealing(fitness_function, max_iters=iterations, random_state= random_state, curve=True)
sa_elapsed = timeit.default_timer() - start_sa
start_ga = timeit.default_timer()
ga_best_state, ga_best_fitness, ga_fitness_curve = mlrose.genetic_alg(fitness_function, max_iters=iterations, random_state= random_state, curve=True)
ga_elapsed = timeit.default_timer() - start_ga
start_mimic = timeit.default_timer()
mimic_best_state, mimic_best_fitness, mimic_fitness_curve = mlrose.mimic(fitness_function, max_iters=iterations, random_state= random_state, curve=True)
mimic_elapsed = timeit.default_timer() - start_mimic
# Fill in arrays.
rch_fitness_curve_bf = np.full(iterations, rhc_best_fitness)
rch_fitness_curve_bf[:rch_fitness_curve.shape[0]] = rch_fitness_curve
sa_fitness_curve_bf = np.full(iterations, sa_best_fitness)
sa_fitness_curve_bf[:sa_fitness_curve.shape[0]] = sa_fitness_curve
ga_fitness_curve_bf = np.full(iterations, ga_best_fitness)
ga_fitness_curve_bf[:ga_fitness_curve.shape[0]] = ga_fitness_curve
mimic_fitness_curve_bf = np.full(iterations, mimic_best_fitness)
mimic_fitness_curve_bf[:mimic_fitness_curve.shape[0]] = mimic_fitness_curve
# Plot the convergance times.
plot_ro_algo_times(rhc_elapsed, ga_elapsed, sa_elapsed, mimic_elapsed, title)
# Plot the fitness over iterations.
fig = plt.figure(figsize=(8,6))
plt.plot(rch_fitness_curve_bf, label="RHC")
plt.plot(sa_fitness_curve_bf, label="SA")
plt.plot(ga_fitness_curve_bf, label="GA")
plt.plot(mimic_fitness_curve_bf, label="MIMIC")
plt.xlabel("Number of Iterations")
plt.xticks(np.arange(0.0, iterations, step=iterations / 10))
plt.ylabel("Fitness Function")
plt.title(title)
plt.legend(prop={'size':13}, loc='lower right')
plt.savefig('Charts/OptimizationProblems/' + title + '.png')
plt.clf()
def test_random_hill_climb_max_iters():
"""Test random_hill_climb function with max_iters less than infinite"""
problem = DiscreteOpt(5, OneMax(), maximize=True)
x = np.array([0, 0, 0, 0, 0])
best_state, best_fitness, _ = random_hill_climb(problem,
max_attempts=1,
max_iters=1,
restarts=0,
init_state=x)
assert best_fitness == 1
def randomized_hill_climb(problem, init_state, max_attempts, max_iters):
start_time = time.time()
best_state, best_fitness, fitness_curve = mlr.random_hill_climb(
problem,
max_attempts,
max_iters,
restarts=10,
init_state=init_state,
curve=True,
random_state=RANDOM_STATE)
end_time = time.time()
total_time = end_time - start_time
print('Random Hill Climb')
print("Elapsed Time", total_time)
# print(best_state)
print(best_fitness)
# print(fitness_curve)
return best_state, best_fitness, fitness_curve, total_time
def run_RHC_3(problem, init_state, **kwargs):
fit_vals = []
fit_curves = []
times = []
fevals = []
# run multiple times to get average
for random_state in random_states:
start = time.time()
_, best_fit, fit_curve, evals = random_hill_climb(
problem,
random_state=random_state,
restarts=39,
**kwargs,
curve=True,
init_state=init_state,
fevals=True)
fit_vals.append(best_fit)
fit_curves.append(fit_curve)
times.append(time.time() - start)
fevals.append(sum(evals.values()))
# plot average fitness value
# now = datetime.now()
# dt_string = now.strftime("%Y-%m-%d-%H-%M-%S")
# hack for ease of naming
problem_name = str(problem.fitness_fn).split('.')[-1].split(' ')[0]
# chart_name = f"charts/rhc_{problem_name}_{len(init_state)}_{dt_string}"
# plt.plot(average_curves(fit_curves), label="rhc")
# plt.title(f"RHC {problem_name} ({len(init_state)})")
# plt.xlabel("step")
# plt.ylabel("fitness")
# plt.savefig(chart_name)
# plt.show()
avg_fit = np.average(fit_vals)
avg_time = round(np.mean(times), 2)
avg_evals = np.mean(fevals)
print(f"RHC {problem_name}: {avg_fit}: {avg_time}: {avg_evals}")
return avg_fit, avg_time, avg_evals
def RHC_tests(problem_fit, ma, maxIter=1000, seed=1, input_size=-1, restarts=0):
global eval_count, iter_total, algo_in, start, times, evals
start = time.time()
eval_count, iter_total, times, evals = 0, 0, [], []
algo_in = 'RHC'
best_state, best_fitness, rhcfitness_curve = mlrose.random_hill_climb(problem_fit, curve=True, max_attempts=ma,
state_fitness_callback=callback_func,
callback_user_info=[], restarts=restarts,
random_state=seed, max_iters=maxIter)
rhc_times = copy.deepcopy(times)
rhc_evals = copy.deepcopy(evals)
print('RHC', input_size,
restarts,
seed,
best_fitness,
np.where(rhcfitness_curve == best_fitness)[0][0], # iter of best fitness
iter_total, # total iters
np.where(rhcfitness_curve == best_fitness)[0][0], # num evals for best fitness
eval_count, # total evals
# round(rhc_times[np.where(rhcfitness_curve == best_fitness)[0][0]], 4), # time of best fitness
round(rhc_times[-1], 4) # total time
)
def rhc(problem, iterations, random_seed, graph_file, graph_title):
fitness = []
fit_time = []
fn_evals = []
global eval_count
for i in iterations:
eval_count = 0
start = datetime.datetime.now()
best_state, best_fitness, _ = mlrose_hiive.random_hill_climb(problem,
max_iters=i, random_state=random_seed)
finish = datetime.datetime.now()
fitness.append(best_fitness)
fit_time.append((finish - start).total_seconds())
fn_evals.append(eval_count)
plt.plot(iterations, fitness, label="Fitness score")
plt.legend(loc="best")
plt.grid()
generate_graph(graph_file + "rhc", graph_title + "Random Hill Climbing",
"Iterations", "Fitness")
print('Best score achieved: ', max(fitness))
index = fitness.index(max(fitness))
print('Time taken to achieve that: ', fit_time[index])
print('Function evaluations taken to achieve that: ', fn_evals[index])
def method_compare(opt, train_features_spam_norm, train_labels_spam,
test_features_spam_norm, test_labels_spam):
#best_state_spam,best_fitness_spam,fitness_curve=mlrose.simulated_annealing(opt,schedule=mlrose.ExpDecay(),curve=True)
#best_state_spam,best_fitness_spam,fitness_curve=mlrose.genetic_alg(opt,pop_size=2000,curve=True)
global count
count = 0
loss_list_rhc = []
loss_list_ann = []
loss_list_ga = []
train_acc_list_rhc = []
train_acc_list_ann = []
train_acc_list_ga = []
test_acc_list_rhc = []
test_acc_list_ann = []
test_acc_list_ga = []
fitness_call_list_rhc = []
fitness_call_list_ann = []
fitness_call_list_ga = []
# ten rounds of rhc
for i in range(10):
count = 0
best_state_spam, best_fitness_spam, fitness_curve = mlrose.random_hill_climb(
opt, restarts=70, curve=True)
loss_list_rhc.append(best_fitness_spam)
train_predict_rhc = predict(best_state_spam, train_features_spam_norm)
test_predict_rhc = predict(best_state_spam, test_features_spam_norm)
train_acc_list_rhc.append(
accuracy_score(train_labels_spam, train_predict_rhc))
test_acc_list_rhc.append(
accuracy_score(test_labels_spam, test_predict_rhc))
fitness_call_list_rhc.append(count)
#ten rounds of simulated annealing
for i in range(10):
count = 0
best_state_spam, best_fitness_spam, _ = mlrose.simulated_annealing(
opt, schedule=mlrose.ExpDecay(exp_const=0.003), curve=True)
loss_list_ann.append(best_fitness_spam)
train_predict_ann = predict(best_state_spam, train_features_spam_norm)
test_predict_ann = predict(best_state_spam, test_features_spam_norm)
train_acc_list_ann.append(
accuracy_score(train_labels_spam, train_predict_ann))
test_acc_list_ann.append(
accuracy_score(test_labels_spam, test_predict_ann))
fitness_call_list_ann.append(count)
#ten rounds of genetic algorithm
for i in range(10):
count = 0
best_state_spam, best_fitness_spam, _ = mlrose.genetic_alg(
opt, pop_size=1000, curve=True)
loss_list_ga.append(best_fitness_spam)
train_predict_ga = predict(best_state_spam, train_features_spam_norm)
test_predict_ga = predict(best_state_spam, test_features_spam_norm)
train_acc_list_ga.append(
accuracy_score(train_labels_spam, train_predict_ga))
test_acc_list_ga.append(
accuracy_score(test_labels_spam, test_predict_ga))
fitness_call_list_ga.append(count)
#plot loss curve
plt.figure(figsize=(6, 6))
plt.plot(np.arange(1, 11), loss_list_rhc, label='rhc')
plt.plot(np.arange(1, 11), loss_list_ann, label='s_ann')
plt.plot(np.arange(1, 11), loss_list_ga, label='ga')
plt.xlabel('rounds')
plt.ylabel('-1*losss')
plt.title('loss versus different algorithm')
plt.legend()
plt.show()
#plot acc curve
plt.figure(figsize=(15, 6))
plt.subplot(131)
plt.plot(np.arange(1, 11), train_acc_list_rhc, label='train')
plt.plot(np.arange(1, 11), test_acc_list_rhc, label='test')
plt.xlabel('rounds')
plt.ylabel('accuracy')
plt.title('rhc')
plt.legend()
plt.subplot(132)
plt.plot(np.arange(1, 11), train_acc_list_ann, label='train')
plt.plot(np.arange(1, 11), test_acc_list_ann, label='test')
plt.xlabel('rounds')
plt.ylabel('accuracy')
plt.title('simulated annealing')
plt.legend()
plt.subplot(133)
plt.plot(np.arange(1, 11), train_acc_list_ga, label='train')
plt.plot(np.arange(1, 11), test_acc_list_ga, label='test')
plt.xlabel('rounds')
plt.ylabel('accuracy')
plt.title('genetic algorithm')
plt.legend()
#plot fitness call
plt.figure(figsize=(6, 6))
plt.plot(np.arange(1, 11), fitness_call_list_rhc, label='rhc')
plt.plot(np.arange(1, 11), fitness_call_list_ann, label='s_ann')
plt.plot(np.arange(1, 11), fitness_call_list_ga, label='ga')
plt.xlabel('rounds')
plt.ylabel('fitness call number')
plt.title('fitness call num versus different algorithm')
plt.legend()
plt.show()
for i in test_range:
start = time.time()
init = np.random.choice(2**(i + 1), size=i, replace=False)
print(f"Running for subproblem size: {i}\n Initialization: {init}")
problem = mlr.DiscreteOpt(length=i,
fitness_fn=fitness_cust,
maximize=True,
max_val=2**(i + 1))
## Randomized Hill Climbing
sub_start = time.time()
best_rhc_state, best_rhc_fitness, rhc_curve = mlr.random_hill_climb(
problem,
max_attempts=attempts,
random_state=seed,
curve=True,
init_state=init,
restarts=500)
print(f" best RHC State: {best_rhc_state}")
sub_end = time.time()
rhc_fitnesses.append(best_rhc_fitness)
rhc_times.append(sub_end - sub_start)
## Simulated Annealing
sub_start = time.time()
best_sa_state, best_sa_fitness, sa_curve = mlr.simulated_annealing(
problem,
schedule=schedule,
max_attempts=attempts,
random_state=seed,
def Knapsack():
rs = 2 #random state
ma = 200 #max attempts
items = 40 # number of items
random.seed(6)
weights = []
values = []
for i in range(0, items):
weights.append((random.random() + 0.1) * 30)
#weights.append(random.randint(1,31))
#values.append(random.randint(1, 500))
values.append((random.random() + 0.1) * 500)
#weights=[9,13,153,50,15,68,27,39,23,52,11,32,24,48,73,42,43,22,7,18,4,30,153,50,15,68,68,27,27,39]
#values=[150,35,200,60,60,45,60,40,30,10,70,30,15,10,40,70,75,80,20,12,50,10,200,60,60,45,45,60,60,40]
#print(len(weights))
#print(weights)
max_weight_pct = 0.6
fitness = mlrose.Knapsack(weights, values, max_weight_pct)
problem_fit = mlrose.DiscreteOpt(length=len(weights),
fitness_fn=fitness,
maximize=True)
# Fitness curve
alltime = []
import time
start = time.time()
best_state, best_fitness, gafitness_curve = mlrose.genetic_alg(
problem_fit,
pop_size=300,
mutation_prob=0.7,
curve=True,
max_attempts=ma,
random_state=rs)
end = time.time()
alltime.append((end - start))
start = time.time()
best_state, best_fitness, rhcfitness_curve = mlrose.random_hill_climb(
problem_fit, curve=True, max_attempts=ma, random_state=rs)
end = time.time()
alltime.append((end - start))
start = time.time()
SA_schedule = mlrose.GeomDecay(init_temp=100000, decay=0.95, min_temp=1)
best_state, best_fitness, safitness_curve = mlrose.simulated_annealing(
problem_fit,
schedule=SA_schedule,
curve=True,
max_attempts=ma,
random_state=rs)
end = time.time()
alltime.append((end - start))
start = time.time()
best_state, best_fitness, mimicfitness_curve = mlrose.mimic(
problem_fit,
curve=True,
max_attempts=ma,
pop_size=400,
keep_pct=0.3,
random_state=rs)
end = time.time()
alltime.append((end - start))
# Plot time comparison
plt.figure()
algorithms = ['GA', 'RHC', 'SA', 'MIMIC']
plt.bar(algorithms, alltime)
plt.title("Running time for Knapsack problem (seconds)")
plt.ylabel('Time (s)')
plt.xlabel('Random search algorithms')
plt.tight_layout()
i = 0
for a in algorithms:
plt.text(a,
alltime[i] + 0.05,
'%.2f' % alltime[i],
ha='center',
va='bottom',
fontsize=11)
i += 1
plt.savefig("Running time for Knapsack problem")
plt.show()
plt.title("Knapsack problem fitness vs iterations")
plt.plot(gafitness_curve, label='GA', color='r')
plt.plot(rhcfitness_curve, label='RHC', color='b')
plt.plot(safitness_curve, label='SA', color='orange')
plt.plot(mimicfitness_curve, label='MIMIC', color='g')
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("Knapsack fitness curve")
plt.show()
# MIMIC Fitness vs Iterations as cpt changes
CPT = [0.1, 0.3, 0.5, 0.7, 0.9]
plt.figure()
for c in CPT:
best_state, best_fitness, mimicfitness_curve = mlrose.mimic(
problem_fit,
keep_pct=c,
curve=True,
max_attempts=ma,
random_state=rs)
plt.plot(mimicfitness_curve, label='pct = ' + str(c))
plt.title(
"Knapsack problem using MIMIC with different values of pct parameter")
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("Knapsack MIMIC parameter")
plt.show()
# GA Fitness vs Iterations as mutation prob changes
Mutate = [0.1, 0.3, 0.5, 0.7, 0.9]
plt.figure()
for m in Mutate:
best_state, best_fitness, gafitness_curve = mlrose.genetic_alg(
problem_fit,
mutation_prob=m,
curve=True,
max_attempts=ma,
random_state=rs)
plt.plot(gafitness_curve, label='mutation = ' + str(m))
plt.title(
"Knapsack problem using GA with different values of mutation probability"
)
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("Knapsack GA parameter")
plt.show()
# SA Fitness vs Iterations as schedule changes
# schedule = mlrose.GeomDecay(init_temp=10, decay=0.95, min_temp=1)
init_temp = 1.0
decay_r = [0.15, 0.35, 0.55, 0.75, 0.95]
plt.figure()
for d in decay_r:
SAschedule = mlrose.GeomDecay(init_temp=100000, decay=d, min_temp=1)
best_state, best_fitness, safitness_curve = mlrose.simulated_annealing(
problem_fit,
schedule=SAschedule,
curve=True,
max_attempts=ma,
random_state=rs)
plt.plot(safitness_curve, label='decay rate = ' + str(d))
plt.title("Knapsack problem using SA with different values of decay rate")
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("Knapsack SA parameter")
plt.show()
init_temp = 1.0
temps = [100000, 10000, 1000, 100, 10, 5]
plt.figure()
for t in temps:
SAschedule = mlrose.GeomDecay(init_temp=t, decay=0.95, min_temp=1)
best_state, best_fitness, safitness_curve = mlrose.simulated_annealing(
problem_fit,
schedule=SAschedule,
curve=True,
max_attempts=ma,
random_state=rs)
plt.plot(safitness_curve, label='Temperature = ' + str(t))
plt.title("Knapsack problem using SA with different values of temperature")
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("Knapsack SA temp")
plt.show()
Mutate = [0.1, 0.1, 0.1, 0.1, 0.1]
pop = [50, 100, 200, 300, 400]
Mutatepop = [(100, 0.2), (100, 0.5), (100, 0.7), (200, 0.2), (200, 0.5),
(200, 0.7), (300, 0.2), (300, 0.5), (300, 0.7)]
plt.figure()
for m in Mutatepop:
best_state, best_fitness, gafitness_curve = mlrose.genetic_alg(
problem_fit,
pop_size=m[0],
mutation_prob=m[1],
curve=True,
max_attempts=ma,
random_state=rs)
plt.plot(gafitness_curve,
label='pop size = ' + str(m[0]) + ', mutation = ' + str(m[1]))
plt.title("Knapsack using GA with different parameters")
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("Knapsack GA parameter mutate pop")
plt.show()
temps = [10000000, 1000000, 100000, 10000, 1000, 100, 10, 5]
plt.figure()
for t in temps:
SAschedule = mlrose.GeomDecay(init_temp=t, decay=0.95, min_temp=1)
best_state, best_fitness, safitness_curve = mlrose.simulated_annealing(
problem_fit,
schedule=SAschedule,
curve=True,
max_attempts=ma,
random_state=rs)
plt.plot(safitness_curve, label='Temperature = ' + str(t))
plt.title("Knapsack problem using SA with different values of temperature")
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("Knapsack SA temp")
plt.show()
CPT = [0.1, 0.3, 0.5, 0.9]
pp = [(100, 0.2), (100, 0.5), (100, 0.7), (100, 0.9), (200, 0.2),
(200, 0.5), (200, 0.7), (200, 0.9), (500, 0.2), (500, 0.5),
(500, 0.7), (500, 0.9)]
plt.figure()
Pop = [100, 200, 300, 400, 500]
for p in Pop:
best_state, best_fitness, mimicfitness_curve = mlrose.mimic(
problem_fit,
pop_size=p,
keep_pct=0.3,
curve=True,
max_attempts=ma,
random_state=rs)
plt.plot(mimicfitness_curve, label='pop size = ' + str(p))
plt.title("Knapsack problem using MIMIC with different parameters")
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("Knapsack MIMIC parameter pop pct")
plt.show()
max_attempts=200,
iteration_list=[2500],
restart_list=[20])
rhc_stats, rhc_curve = rhc.run()
columns = ['Time', 'Fitness', 'Restarts', 'current_restart']
df=pd.read_csv("./queen/queen_prob/rhc__queen_prob__run_stats_df.csv")
print(df[columns].sort_values(by=['Fitness'], ascending=False))
max_attempts = 500
max_iters = 2500
restarts = 20
eval_count = 0
best_state, best_fitness, rhc_curve = mlrh.random_hill_climb(prob,
max_attempts=max_attempts,
max_iters=max_iters,
random_state=random_state,
restarts=restarts,
curve=True)
print("Randomized Hill Climbing - Total Function Evaluations:", eval_count)
plot_fitness_iteration('fitness_iteration_rhc_queens.png',rhc_curve,
"Queens - Randomized Hill Climbing: restarts: {}".format(restarts))
# Fitness vs iterations (combined)
all_curves = {"MIMIC": mimic_curve, "Genetic Alg": gen_curve, "Simulated Annealing": sa_curve, "Random Hill Climb": rhc_curve}
np.array([len(x) for x in all_curves]).max()
plt.xlabel("Iterations")
plt.ylabel("Fitness")
plt.close()
print(df.max())
#%% Putting together
RANDOM_SEED = 21
curve_list = []
time_list = []
n_eval = []
algo_list = ["RHC", "SA", "GA", "MIMIC"]
# RHC
t1 = process_time()
_, _, curve = mlrose.random_hill_climb(
problem, max_attempts=MAX_ATTEMPTS, curve=True, random_state=RANDOM_SEED
)
t2 = process_time()
time_list.append((t2 - t1) / len(curve))
curve_list.append(curve)
n_eval.append(np.argmin(curve) + 1)
# SA
t1 = process_time()
_, _, curve = mlrose.simulated_annealing(
problem, max_attempts=MAX_ATTEMPTS, curve=True, random_state=RANDOM_SEED,
)
t2 = process_time()
time_list.append((t2 - t1) / len(curve))
curve_list.append(curve)
n_eval.append(np.argmin(curve) + 1)
def get_random_optimisation(problem,
optimisation,
problem_type,
seed=10,
state_fitness_callback=None):
best_state, best_fitness, fitness_curve = None, None, None
process_time = []
if optimisation == Optimisation.RHC:
start = time.time()
best_state, best_fitness, fitness_curve = mlrose.random_hill_climb(
problem,
max_attempts=__MAX_ATTEMPTS[problem_type],
max_iters=__MAX_ITERS,
curve=True,
random_state=seed,
state_fitness_callback=state_fitness_callback,
callback_user_info=['rhc'])
process_time.append(time.time() - start)
elif optimisation == Optimisation.SA:
start = time.time()
best_state, best_fitness, fitness_curve = mlrose.simulated_annealing(
problem,
schedule=mlrose.ExpDecay(exp_const=0.1),
max_attempts=__MAX_ATTEMPTS[problem_type],
max_iters=__MAX_ITERS,
curve=True,
random_state=seed,
state_fitness_callback=state_fitness_callback,
callback_user_info=['sa'])
process_time.append(time.time() - start)
elif optimisation == Optimisation.GA:
start = time.time()
best_state, best_fitness, fitness_curve = mlrose.genetic_alg(
problem,
pop_size=__POP_SIZE[problem_type],
mutation_prob=__MUTATION_PROBABILITY,
max_attempts=__MAX_ATTEMPTS[problem_type],
max_iters=__MAX_ITERS,
curve=True,
random_state=seed,
state_fitness_callback=state_fitness_callback,
callback_user_info=['ga'])
process_time.append(time.time() - start)
elif optimisation == Optimisation.MIMIC:
start = time.time()
best_state, best_fitness, fitness_curve = mlrose.mimic(
problem,
pop_size=__POP_SIZE[problem_type],
keep_pct=__KEEP_PCT,
max_iters=__MAX_ITERS,
max_attempts=__MAX_ATTEMPTS[problem_type],
curve=True,
random_state=seed,
state_fitness_callback=state_fitness_callback,
callback_user_info=['mimic'])
process_time.append(time.time() - start)
return best_state, best_fitness, np.array(fitness_curve), process_time
def run_complexity(self, fitness_fn, mode=None):
if mode == 1:
self.run_ga_hyper_params(fitness_fn)
elif mode == 2:
self.run_rhc_hyper_params(fitness_fn)
elif mode == 3:
self.run_sa_hyper_params(fitness_fn)
elif mode == 4:
self.run_mimic_hyper_params(fitness_fn)
elif not mode:
fitness_name = fitness_fn.__class__.__name__
print("Running %s" % fitness_name)
init_states = {}
knap_fitnesses = {}
tsp_fitnesses = {}
tries = 1
for x in 2**np.arange(3, 9):
n = int(x)
fitness_dists = mlrose.TravellingSales(distances=get_coords(n))
tsp_fitnesses[n] = fitness_dists
edges = []
for x in range(int(n * 0.75)):
a = r.randint(0, n - 1)
b = r.randint(0, n - 1)
while b == a:
b = r.randint(0, n - 1)
edges.append((a, b))
fitness_fn_knap = mlrose.MaxKColor(edges=edges)
init_states[n] = []
knap_fitnesses[n] = fitness_fn_knap
for y in range(tries):
init_states[n].append(get_init_state(n))
for n, init_states_list in init_states.items():
if fitness_name == 'MaxKColor':
fitness_fn = knap_fitnesses[n]
if fitness_name == 'TravellingSales':
fitness_fn = tsp_fitnesses[n]
print(n)
print('%s: i=%d' % ('random_hill_climb', n))
total_score = 0
total_iter = 0
start = time.time()
for init_state in init_states_list:
problem = mlrose.DiscreteOpt(length=len(init_state),
fitness_fn=fitness_fn,
maximize=True)
if fitness_name == 'TravellingSales':
problem = mlrose.TSPOpt(length=n,
fitness_fn=fitness_fn)
max_attempts = self.get_best_param(
problem=fitness_name,
algo='random_hill_climb',
param='max_attempts')
restarts = self.get_best_param(problem=fitness_name,
algo='random_hill_climb',
param='restarts')
best_state, best_fitness, curve = mlrose.random_hill_climb(
problem,
max_attempts=max_attempts,
max_iters=10000,
random_state=1,
curve=True,
restarts=restarts)
total_iter += len(curve)
total_score += np.mean(curve)
end = time.time()
print('The fitness at the best state is: ',
total_score / tries)
self.track(problem=fitness_name,
algo='random_hill_climb',
i=n,
score=total_score / tries,
training_time=(end - start) / tries,
max_iter=total_iter / tries)
for n, init_states_list in init_states.items():
if fitness_name == 'MaxKColor':
fitness_fn = knap_fitnesses[n]
if fitness_name == 'TravellingSales':
fitness_fn = tsp_fitnesses[n]
print(n)
print('%s: i=%d' % ('simulated_annealing', n))
total_score = 0
total_iter = 0
start = time.time()
for init_state in init_states_list:
problem = mlrose.DiscreteOpt(length=len(init_state),
fitness_fn=fitness_fn,
maximize=True)
if fitness_name == 'TravellingSales':
problem = mlrose.TSPOpt(length=n,
fitness_fn=fitness_fn)
max_attempts = self.get_best_param(
problem=fitness_name,
algo='simulated_annealing',
param='max_attempts')
best_state, best_fitness, curve = mlrose.simulated_annealing(
problem,
max_attempts=max_attempts,
max_iters=10000,
random_state=1,
curve=True)
total_score += np.mean(curve)
total_iter += len(curve)
end = time.time()
print('The fitness at the best state is: ',
total_score / tries)
self.track(problem=fitness_name,
algo='simulated_annealing',
i=n,
score=total_score / tries,
training_time=(end - start) / tries,
max_iter=total_iter / tries)
for n, init_states_list in init_states.items():
if fitness_name == 'MaxKColor':
fitness_fn = knap_fitnesses[n]
if fitness_name == 'TravellingSales':
fitness_fn = tsp_fitnesses[n]
print(n)
print('%s: i=%d' % ('genetic_alg', n))
total_score = 0
total_iter = 0
start = time.time()
for init_state in init_states_list:
problem = mlrose.DiscreteOpt(length=len(init_state),
fitness_fn=fitness_fn,
maximize=True)
if fitness_name == 'TravellingSales':
problem = mlrose.TSPOpt(length=n,
fitness_fn=fitness_fn)
mutation_prob = self.get_best_param(problem=fitness_name,
algo='genetic_alg',
param='mutation_prob')
pop_size = self.get_best_param(problem=fitness_name,
algo='genetic_alg',
param='pop_size')
best_state, best_fitness, curve = mlrose.genetic_alg(
problem,
pop_size=pop_size,
mutation_prob=mutation_prob,
max_iters=10000,
random_state=1,
curve=True)
total_score += np.mean(curve)
total_iter += len(curve)
end = time.time()
print('The fitness at the best state is: ',
total_score / tries)
self.track(problem=fitness_name,
algo='genetic_alg',
i=n,
score=total_score / tries,
training_time=(end - start) / tries,
max_iter=total_iter / tries)
for n, init_states_list in init_states.items():
if fitness_name == 'MaxKColor':
fitness_fn = knap_fitnesses[n]
if fitness_name == 'TravellingSales':
fitness_fn = tsp_fitnesses[n]
print('%s: i=%d' % ('mimic', n))
if n > 256:
break
total_score = 0
total_iter = 0
start = time.time()
for init_state in init_states_list:
problem = mlrose.DiscreteOpt(length=len(init_state),
fitness_fn=fitness_fn,
maximize=True)
if fitness_name == 'TravellingSales':
problem = mlrose.TSPOpt(length=n,
fitness_fn=fitness_fn)
keep_pct = self.get_best_param(problem=fitness_name,
algo='mimic',
param='keep_pct')
pop_size = self.get_best_param(problem=fitness_name,
algo='mimic',
param='pop_size')
best_state, best_fitness, curve = mlrose.mimic(
problem,
max_iters=10000,
random_state=1,
curve=True,
pop_size=pop_size,
keep_pct=keep_pct,
max_attempts=10)
total_score += np.mean(curve)
total_iter += len(curve)
end = time.time()
print('The fitness at the best state is: ',
total_score / tries)
self.track(problem=fitness_name,
algo='mimic',
i=n,
score=total_score / tries,
training_time=(end - start) / tries,
max_iter=total_iter / tries)
def run_rhc_hyper_params(self, fitness_fn):
fitness_name = fitness_fn.__class__.__name__
print("Running %s" % fitness_name)
init_states = {}
knap_fitnesses = {}
tsp_fitnesses = {}
tries = 1
for x in 2**np.arange(6, 7):
n = int(x)
fitness_dists = mlrose.TravellingSales(distances=get_coords(n))
tsp_fitnesses[n] = fitness_dists
edges = []
for x in range(int(n * 0.75)):
a = r.randint(0, n - 1)
b = r.randint(0, n - 1)
while b == a:
b = r.randint(0, n - 1)
edges.append((a, b))
fitness_fn_knap = mlrose.MaxKColor(edges=edges)
init_states[n] = []
knap_fitnesses[n] = fitness_fn_knap
for y in range(tries):
init_states[n].append(get_init_state(n))
for n, init_states_list in init_states.items():
if fitness_name == 'MaxKColor':
fitness_fn = knap_fitnesses[n]
if fitness_name == 'TravellingSales':
fitness_fn = tsp_fitnesses[n]
print(n)
print('%s: i=%d' % ('random_hill_climb', n))
for init_state in init_states_list:
problem = mlrose.DiscreteOpt(length=len(init_state),
fitness_fn=fitness_fn,
maximize=True)
if fitness_name == 'TravellingSales':
problem = mlrose.TSPOpt(length=n, fitness_fn=fitness_fn)
for max_attempts in range(10, 110, 10):
total_score = 0
total_iter = 0
best_state, best_fitness, curve = mlrose.random_hill_climb(
problem,
max_attempts=max_attempts,
max_iters=10000,
random_state=1,
curve=True,
restarts=10)
total_score += np.max(curve)
total_iter += len(curve)
print('The fitness at the best state is: ',
total_score / tries, '. Max Attempts: ',
max_attempts)
self.track_best_params(problem=fitness_name,
algo='random_hill_climb',
param='max_attempts',
score=total_score,
value=max_attempts)
max_attempts = self.get_best_param(problem=fitness_name,
algo='random_hill_climb',
param='max_attempts')
for restarts in range(10, 110, 10):
total_score = 0
total_iter = 0
best_state, best_fitness, curve = mlrose.random_hill_climb(
problem,
max_attempts=max_attempts,
max_iters=10000,
random_state=1,
curve=True,
restarts=restarts)
total_score += np.max(curve)
total_iter += len(curve)
print('The fitness at the best state is: ',
total_score / tries, '. restarts: ', restarts)
self.track_best_params(problem=fitness_name,
algo='random_hill_climb',
param='restarts',
score=total_score,
value=restarts)
def GenerateFitnessCurves(problem_fit, ma, sa_sched=None, gapop=200, gamut=0.5, mimpop=200, mimpct=0.2, maxIter=1000,
seed=1, min=False, input_size=-1, restarts=0):
global eval_count, iter_total, algo_in, start, times, evals
start = time.time()
eval_count, iter_total, times, evals = 0, 0, [], []
algo_in = 'RHC'
print('RHC')
best_state, best_fitness, rhcfitness_curve = mlrose.random_hill_climb(problem_fit, curve=True, max_attempts=ma,
state_fitness_callback=callback_func,
callback_user_info=[], restarts=restarts,
random_state=seed, max_iters=maxIter)
rhc_times = copy.deepcopy(times)
rhc_evals = copy.deepcopy(evals)
print('RHC',
input_size,
seed,
best_fitness,
np.where(rhcfitness_curve == best_fitness)[0][0], # iter of best fitness
iter_total, # total iters
np.where(rhcfitness_curve == best_fitness)[0][0], # num evals for best fitness
eval_count, # total evals
# round(rhc_times[np.where(rhcfitness_curve == best_fitness)[0][0]], 4), # time of best fitness
round(rhc_times[-1], 4) # total time
)
eval_count, iter_total, times, evals = 0, 0, [], []
algo_in = 'NOT_RHC'
print('SA')
if sa_sched:
best_state, best_fitness, safitness_curve = mlrose.simulated_annealing(problem_fit, schedule=sa_sched,
state_fitness_callback=callback_func,
callback_user_info=[],
curve=True, max_attempts=ma,
random_state=seed, max_iters=maxIter)
else:
best_state, best_fitness, safitness_curve = mlrose.simulated_annealing(problem_fit, # schedule=SA_schedule,
curve=True, max_attempts=ma,
state_fitness_callback=callback_func,
callback_user_info=[],
random_state=seed, max_iters=maxIter)
sa_times = copy.deepcopy(times)
sa_evals = copy.deepcopy(evals)
print('SA',
input_size,
seed,
best_fitness,
np.where(safitness_curve == best_fitness)[0][0], # iter of best fitness
len(safitness_curve), # total iters
evals[np.where(safitness_curve == best_fitness)[0][0]], # num evals for best fitness
eval_count, # total evals
round(sa_times[np.where(safitness_curve == best_fitness)[0][0]], 4), # time of best fitness
round(sa_times[-1], 4) # total time
)
eval_count, iter_total, times, evals = 0, 0, [], []
print('GA')
best_state, best_fitness, gafitness_curve = mlrose.genetic_alg(problem_fit, curve=True, pop_size=gapop,
mutation_prob=gamut, max_attempts=ma,
state_fitness_callback=callback_func,
callback_user_info=[],
random_state=seed, max_iters=maxIter)
ga_times = copy.deepcopy(times)
ga_evals = copy.deepcopy(evals)
print('GA', input_size,
seed,
best_fitness,
np.where(gafitness_curve == best_fitness)[0][0], # iter of best fitness
len(gafitness_curve), # total iters
evals[np.where(gafitness_curve == best_fitness)[0][0]], # num evals for best fitness
eval_count, # total evals
round(ga_times[np.where(gafitness_curve == best_fitness)[0][0]], 4), # time of best fitness
round(ga_times[-1], 4) # total time
)
eval_count, iter_total, times, evals = 0, 0, [], []
print('MIMIC')
best_state, best_fitness, mimicfitness_curve = mlrose.mimic(problem_fit, curve=True, max_attempts=ma,
pop_size=mimpop, keep_pct=mimpct,
state_fitness_callback=callback_func,
callback_user_info=[],
random_state=seed, max_iters=maxIter)
mim_times = copy.deepcopy(times)
mim_evals = copy.deepcopy(evals)
print('MIMIC', input_size,
seed,
best_fitness,
np.where(mimicfitness_curve == best_fitness)[0][0], # iter of best fitness
len(mimicfitness_curve), # total iters
evals[np.where(mimicfitness_curve == best_fitness)[0][0]], # num evals for best fitness
eval_count, # total evals
round(mim_times[np.where(mimicfitness_curve == best_fitness)[0][0]], 4), # time of best fitness
round(mim_times[-1], 4) # total time
)
if min:
# To Maximize TSP, need to make everything negative
gafitness_curve = np.array(gafitness_curve) * -1
rhcfitness_curve = np.array(rhcfitness_curve) * -1
safitness_curve = np.array(safitness_curve) * -1
mimicfitness_curve = np.array(mimicfitness_curve) * -1
return gafitness_curve, rhcfitness_curve, safitness_curve, mimicfitness_curve, ga_times, rhc_times, sa_times, mim_times, rhc_evals, sa_evals, ga_evals, mim_evals
else:
return gafitness_curve, rhcfitness_curve, safitness_curve, mimicfitness_curve, ga_times, rhc_times, sa_times, mim_times, rhc_evals, sa_evals, ga_evals, mim_evals
FITNESS_FUNCS = {
'fourpeaks': mlrose.FourPeaks(),
'onemax': mlrose.OneMax(),
# 'path': mlrose.CustomFitness(path, problem_type='discrete'),
'flipflop': mlrose.FlipFlop(),
# 'cliffs': mlrose.CustomFitness(cf1, problem_type='discrete'),
# 'cliffs': mlrose.CustomFitness(is_larger, problem_type='discrete'),
# 'max2color': mlrose.MaxKColorGenerator.generate(seed=42, number_of_nodes=PROBLEM_LENGTH, max_colors=2),
# 'mod': mlrose.CustomFitness(cf2, problem_type='discrete')
}
RANDOM_STATE = 42
DEFAULTS = {'random_state': RANDOM_STATE, 'curve': True, 'max_attempts': 10}
ALGORITHMS = {
'rhc': lambda p: mlrose.random_hill_climb(p, **DEFAULTS),
'sa': lambda p: mlrose.simulated_annealing(p, **DEFAULTS),
'ga': lambda p: mlrose.genetic_alg(p, **DEFAULTS),
'mimic': lambda p: mlrose.mimic(p, **DEFAULTS)
}
results = []
PART_1 = True
PART_2 = True
if PART_1:
for f_name, fitness in FITNESS_FUNCS.items():
evaluate_fitness(f_name, fitness, f_name == 'max2color')
alg2curve = {}
overall_best_fitness = -1
def main():
four_peaks_fitness = four_peaks.get_four_peaks()
four_peaks_list = four_peaks.get_four_peaks_tuning
#state = np.array([1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0])
problem = mlrose.DiscreteOpt(100, four_peaks_fitness, maximize=True, max_val=2)
problem_list = []
for item in four_peaks_list:
problem_list.append(mlrose.DiscreteOpt(100, item, maximize=True, max_val=2))
# Random hill climb
print('Random Hill Climb')
print(mlrose.random_hill_climb(problem, max_attempts=100, max_iters=1000, restarts=100, init_state=None, curve=True, random_state=27))
for item in range(len(four_peaks_list)):
experiment_name = 'rhc_tuning_' + str(item)
rhc = runners.RHCRunner(problem=problem,
experiment_name=experiment_name,
output_directory='./',
seed=27,
iteration_list=2 ** np.arange(10),
max_attempts=5000,
restart_list=[25],
max_iters=10)
# the two data frames will contain the results
df_run_stats, df_run_curves = rhc.run()
print(df_run_curves.loc[df_run_curves['Fitness'].idxmax()])
return
# the two data frames will contain the results
#df_run_stats, df_run_curves = sa.run()
# four peaks, knapsack and k-colors
#four_peaks_fitness = mlrose.FourPeaks(t_pct=0.15)
#state = np.array([1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0])
#fitness.evaluate(state)
# Knapsack
#weights = [10, 5, 2, 8, 15]
#weights = np.ones(100)
#values = [1, 2, 3, 4, 5]
# values = np.arange(1, 101)
# max_weight_pct = 0.6
# knapsack_fitness = mlrose.Knapsack(weights, values, max_weight_pct)
# state = np.array([1, 0, 2, 1, 0])
#fitness.evaluate(state)
# K-colors
# edges = [(0, 1), (0, 2), (0, 4), (1, 3), (2, 0), (2, 3), (3, 4)]
# k_color_fitness = mlrose.MaxKColor(edges)
# state = np.array([0, 1, 0, 1, 1])
#fitness.evaluate(state)
# Two aspects of optimization:
# - Performance
# - Runtime
# Make sure to have numbers and analysis for both these numbers for all parts
# For part 1 (requires lots of tuning again, yay)
# - grab some problems: Salesman, knapsack
# - Make sure to highlight (one algorithm outperforms all the others significantly) each of the 3
# - Lose major points if one is missing. Important part is highlighting here
# - Vary problem size/difficulties, some different stuff. Should change the behavior
# - If there is a change, see when one starts beating the others and explain why
# - People are having problems getting MIMIC to outperforms (K-coloring should work)
# - Play with hyper parameters if it doesnt outperform when should. Also TIMING >= Accuracy here
# - mlrose is bad for MIMIC, takes a lot of tuning, previous semesters people have re-written internal mlrose code
# - max iteration should be tuning independantly for each separate algorithm, some algorithms take way more iterations to converge
# - Dont retune for every different problem size, tune once for one size, find the results you want, use the same HPs for other sizes and show how it changes
# - For varying problem size, vary in smaller increments, some 10 -> 50 to see a difference, some 20 -> 30
# - Some are quadratic/exponential, watch out for enormous times for problem size varying.
# ALL THESE PLOTS HAVE TO BE IN THIS: (called this summary of whole assignment)
# 1. F-evals vs fitness on single plot with Iterations vs fitness
# 2. Hyper parameter tuning for both problem and algorithms
# 3. Complexity vs Fitness on single plot with Complexity vs fevals
# max iteration should be tuning independantly for each separate algorithm, some algorithms take way more iterations to converge
# For varying problem size, vary length (LEAVE MAX_VAL AS 2 SO THEY ARE BIT STRINGS)
#problem = mlrose.DiscreteOpt(100, four_peaks_fitness, maximize=True, max_val=2)
# Random hill climb
# print('Random Hill Climb')
# print(mlrose.random_hill_climb(problem, max_attempts=100, max_iters=1000, restarts=100, init_state=None, curve=True, random_state=27))
# # Simulated_annealing
# print('Simulated annealing')
# #print(mlrose.simulated_annealing(problem, schedule=mlrose.GeomDecay(), max_attempts=100, max_iters=1000, init_state=None, curve=True, random_state=27))
# experiment_name = 'example_experiment'
# sa = runners.SARunner(problem=problem,
# experiment_name=experiment_name,
# output_directory='./',
# seed=27,
# iteration_list=2 ** np.arange(14),
# max_attempts=5000,
# temperature_list=[1, 10, 50, 100, 250, 500, 1000, 2500, 5000, 10000])
# # the two data frames will contain the results
# df_run_stats, df_run_curves = sa.run()
# # Genetic algorithm (best with four peaks)
# print('Genetic Algorithm')
# print(mlrose.genetic_alg(problem, pop_size=200, mutation_prob=0.1, max_attempts=100, max_iters=1000, curve=True, random_state=27))
# # MIMIC
# print('MIMIC')
# print(mlrose.mimic(problem, pop_size=200, keep_pct=0.2, max_attempts=10, max_iters=10, curve=True, random_state=27))
def ContinuousPeaks():
rs = 2 # random_state
ma = 100 # max_attempts
#fitness = mlrose.FourPeaks(t_pct=0.15)
fitness = mlrose.ContinuousPeaks(t_pct=0.15)
problem_fit = mlrose.DiscreteOpt(length=50,
fitness_fn=fitness,
maximize=True,
max_val=2)
# Fitness curve
alltime = []
import time
start = time.time()
best_state, best_fitness, gafitness_curve = mlrose.genetic_alg(
problem_fit,
curve=True,
pop_size=200,
mutation_prob=0.5,
max_attempts=ma,
random_state=rs)
end = time.time()
alltime.append((end - start))
start = time.time()
best_state, best_fitness, rhcfitness_curve = mlrose.random_hill_climb(
problem_fit, curve=True, max_attempts=ma, random_state=rs)
end = time.time()
alltime.append((end - start))
start = time.time()
#SA_schedule = mlrose.ArithDecay()
best_state, best_fitness, safitness_curve = mlrose.simulated_annealing(
problem_fit, #schedule=SA_schedule,
curve=True,
max_attempts=ma,
random_state=rs)
end = time.time()
alltime.append((end - start))
start = time.time()
best_state, best_fitness, mimicfitness_curve = mlrose.mimic(
problem_fit, curve=True, max_attempts=ma, random_state=rs)
end = time.time()
alltime.append((end - start))
# Plot time comparison
plt.figure()
algorithms = ['GA', 'RHC', 'SA', 'MIMIC']
plt.bar(algorithms, alltime)
plt.title("Running time for CPP (seconds)")
plt.ylabel('Time (s)')
plt.xlabel('Random search algorithms')
plt.tight_layout()
i = 0
for a in algorithms:
plt.text(a,
alltime[i] + 0.05,
'%.2f' % alltime[i],
ha='center',
va='bottom',
fontsize=11)
i += 1
plt.savefig("Running time for CPP")
plt.show()
plt.figure()
plt.title("CPP fitness vs iterations")
plt.plot(gafitness_curve, label='GA', color='r')
plt.plot(rhcfitness_curve, label='RHC', color='b')
plt.plot(safitness_curve, label='SA', color='orange')
plt.plot(mimicfitness_curve, label='MIMIC', color='g')
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("CPP fitness curve")
plt.show()
# MIMIC Fitness vs Iterations as cpt changes
CPT = [0.1, 0.3, 0.5, 0.7, 0.9]
plt.figure()
for c in CPT:
best_state, best_fitness, mimicfitness_curve = mlrose.mimic(
problem_fit,
keep_pct=c,
curve=True,
max_attempts=ma,
random_state=rs)
plt.plot(mimicfitness_curve, label='pct = ' + str(c))
plt.title("CPP using MIMIC with different values of pct parameter")
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("CPP MIMIC parameter")
plt.show()
# GA Fitness vs Iterations as mutation prob changes
Mutate = [0.1, 0.3, 0.5, 0.7, 0.9]
plt.figure()
for m in Mutate:
best_state, best_fitness, gafitness_curve = mlrose.genetic_alg(
problem_fit,
mutation_prob=m,
curve=True,
max_attempts=ma,
random_state=rs)
plt.plot(gafitness_curve, label='mutate=' + str(m))
plt.title("CPP using GA with different values of mutation probability")
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("CPP GA parameter")
plt.show()
# SA Fitness vs Iterations as schedule changes
# schedule = mlrose.GeomDecay(init_temp=10, decay=0.95, min_temp=1)
init_temp = 1.0
decay_r = [0.15, 0.35, 0.55, 0.75, 0.95]
plt.figure()
for d in decay_r:
SAschedule = mlrose.GeomDecay(init_temp=10, decay=d, min_temp=1)
best_state, best_fitness, safitness_curve = mlrose.simulated_annealing(
problem_fit,
schedule=SAschedule,
curve=True,
max_attempts=ma,
random_state=rs)
plt.plot(safitness_curve, label='decay rate = ' + str(d))
plt.title("CPP using SA with different values of decay rate")
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("CPP SA parameter")
plt.show()
Mutate = [0.1, 0.1, 0.1, 0.1, 0.1]
pop = [50, 100, 200, 300, 400]
Mutatepop = [(100, 0.2), (100, 0.5), (100, 0.7), (200, 0.2), (200, 0.5),
(200, 0.7), (300, 0.2), (300, 0.5), (300, 0.7)]
plt.figure()
for m in Mutatepop:
best_state, best_fitness, gafitness_curve = mlrose.genetic_alg(
problem_fit,
pop_size=m[0],
mutation_prob=m[1],
curve=True,
max_attempts=ma,
random_state=rs)
plt.plot(gafitness_curve,
label='pop size = ' + str(m[0]) + ', mutation = ' + str(m[1]))
plt.title("CPP using GA with different parameters")
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("Knapsack GA parameter mutate pop")
plt.show()
temps = [10000000, 1000000, 100000, 10000, 1000, 100, 10, 5]
plt.figure()
for t in temps:
SAschedule = mlrose.GeomDecay(init_temp=t, decay=0.55, min_temp=1)
best_state, best_fitness, safitness_curve = mlrose.simulated_annealing(
problem_fit,
schedule=SAschedule,
curve=True,
max_attempts=ma,
random_state=rs)
plt.plot(safitness_curve, label='Temperature = ' + str(t))
plt.title("CPP using SA with different values of temperature")
plt.xlabel('Iterations')
plt.ylabel('Fitness')
plt.grid(True)
plt.legend()
plt.savefig("CPP SA temp")
plt.show()
