def plot_mimic_graph(prob_type, flag=0): try: os.mkdir("./MIMIC") except FileExistsError: pass except OSError as error: print("Error creating directory results.") print('\n plot_mimic_graph - Progress: ', end="") fitness, problem = get_fitness_function(prob_type) process_time = [] fitness_score = [] if flag == 0: population = [100, 200, 300, 500, 700, 1000, 1500] else: population = [0.1, 0.15, 0.175, 0.2, 0.25, 0.3, 0.5] for i in population: print(".", end="") start = time.time() if flag == 0: best_state, best_fitness, fitness_curve = mlrose.mimic( problem, pop_size=i, keep_pct=__KEEP_PCT, max_iters=__MAX_ITERS, max_attempts=__MAX_ATTEMPTS[prob_type], random_state=10) else: best_state, best_fitness, fitness_curve = mlrose.mimic( problem, pop_size=__POP_SIZE[prob_type], keep_pct=i, max_iters=__MAX_ITERS, max_attempts=__MAX_ATTEMPTS[prob_type], random_state=10) fitness_score.append(best_fitness) process_time.append(time.time() - start) plt.figure(200 + flag) plt.plot(fitness_score) plt.xticks(np.arange(len(population)), [str(p) for p in population]) plt.xlabel("pop_size constant" if flag == 0 else "keep_pct constant") plt.ylabel("fitness score") plt.title('MIMIC') plt.savefig("MIMIC/" + str(flag) + "Fitness.png") plt.figure(210 + flag) plt.plot(process_time) plt.xticks(np.arange(len(population)), [str(p) for p in population]) plt.xlabel("pop_size constant" if flag == 0 else "keep_pct constant") plt.ylabel("time") plt.title('MIMIC') plt.savefig("MIMIC/" + str(flag) + "Time.png")
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 n_queens_mimic(nq_problem, max_iters=np.inf, num_runs=20, verbose=False): # HP to vary hp_name = 'keep_pct' hp_values = [0.2, 0.4, 0.6] # other hyperparameters for genetic algorithm population_size = 200 # run for each hp value and append results to list fitness_dfs = [] runs = np.arange(num_runs) for hp_value in hp_values: keep_pct = 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.mimic( problem=nq_problem, pop_size=population_size, keep_pct=keep_pct, max_attempts=10, max_iters=max_iters, 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 - MIMIC avg run time,", hp_value, hp_name, ":", avg_run_time) # generate plots plot_title = "N-Queens MIMIC - " \ + str(population_size) + " pop, " \ + ": fit vs iter" plotting.plot_fitness_curves( fitness_dfs=fitness_dfs, hp_values=hp_values, hp_name=hp_name, title=plot_title, ) plt.savefig('graphs/n_queens_mimic_fitness.png') plt.clf() return fitness_dfs
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 mimic(problem, init_state, max_attempts, max_iters): best_state, best_fitness, fitness_curve = mlrose_hiive.mimic(problem, pop_size=200, keep_pct=0.2, max_attempts = max_attempts, max_iters = max_iters, curve=True, random_state = 1) print('mimic') print(best_state) print(best_fitness) # print(fitness_curve) return best_state, best_fitness, fitness_curve
def mimic(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/" kpl = [] beststate = [] bestfit = [] curve = [] time = [] iterlistn = [] for kp in np.linspace(0.1, .5, 3): for iters in iterlist: iterlistn.append(int(iters)) start = clock() best_state, best_fitness, train_curve = mlrose.mimic(problem_fit, \ keep_pct=kp,\ max_attempts=5,\ max_iters=int(iters), curve=True, random_state=randomSeed) end = clock() time.append(end - start) beststate.append(best_state) bestfit.append(best_fitness) kpl.append(kp) curve.append(train_curve) if (verbose == True): print(int(iters)) print(kp) print(best_state) print(best_fitness) ffmi = pd.DataFrame({ 'Keep percentage': kpl, 'Best Fitness': bestfit, 'Iterations': iterlistn, 'Time': time }) mibeststatedf = pd.DataFrame(0.0, index=range(1, vectorLength + 1), columns=range(1, len(beststate) + 1)) for i in range(1, len(beststate) + 1): mibeststatedf.loc[:, i] = beststate[i - 1] ffmi.to_csv(os.path.join(path1, 'mi.csv')) mibeststatedf.to_csv(os.path.join(path1, 'mistates.csv')) for i in range(len(curve)): micurvedf = pd.DataFrame(curve[i]) micurvedf.to_csv( os.path.join(path2, 'micurve{}_{}.csv'.format(kpl[i], iterlistn[i])))
def mimic_optimization(size): algo = 'mimic' problem = get_problem(size) problem.set_mimic_fast_mode(True) # Gridsearch params max_iters = 500 pop_size_values = [50, 100, 150, 200] keep_pct_values = [0.2, 0.3] max_attempts_values = [10, 50, 100, 200] n_runs = len(max_attempts_values) * len(pop_size_values) * len(keep_pct_values) # Best vals pop_size, keep_pct, max_attempts = None, None, None fitness, curves, n_invocations, time = float('-inf'), [], 0, 0 # Gridsearch global eval_count run_counter = 0 for run_pop_size in pop_size_values: for run_keep_pct in keep_pct_values: for run_max_attempts in max_attempts_values: # Print status run_counter += 1 print(f'RUN {run_counter} of {n_runs} [pop_size: {run_pop_size}] [run_keep_pct: {run_keep_pct}] [max_attempts: {run_max_attempts}]') # Run problem eval_count = 0 start = timer() run_state, run_fitness, run_curves = mlrose_hiive.mimic(problem, pop_size=run_pop_size, keep_pct=run_keep_pct, max_attempts=run_max_attempts, max_iters=max_iters, random_state=42, curve=True) end = timer() # Save curves and params if run_fitness > fitness: pop_size = run_pop_size keep_pct = run_keep_pct 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['pop_size'] = pop_size df['keep_pct'] = keep_pct 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_mimic_discrete_min(): """Test mimic function for a discrete minimization problem""" problem = DiscreteOpt(5, OneMax(), maximize=False) best_state, best_fitness, _ = mimic(problem, max_attempts=50) x = np.array([0, 0, 0, 0, 0]) assert (np.array_equal(best_state, x) and best_fitness == 0)
def mimic(problem, iterations, random_seed, graph_file, graph_title): keep_pct = [0.1, 0.25, 0.50] best_score = [] time_taken = [] fn_evals_taken = [] global eval_count for k in keep_pct: fitness = [] fit_time = [] fn_evals = [] for i in iterations: eval_count = 0 start = datetime.datetime.now() best_state, best_fitness, _ = mlrose_hiive.mimic(problem, keep_pct=k, 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) # Find the best score achieved in that mutation prob best_score.append(max(fitness)) index = fitness.index(max(fitness)) # find the time that was taken to achieve that time_taken.append(fit_time[index]) fn_evals_taken.append(fn_evals[index]) plt.plot(iterations, fitness, label="keep_pct = " + str(k)) plt.legend(loc="best", title='Proportion of samples kept') plt.grid() generate_graph(graph_file + "mimic", graph_title + "MIMIC: ", "Iterations", "Fitness") # Decays best_score and time_taken plt.plot(keep_pct, best_score) plt.grid() generate_graph(graph_file + "mimic_pct", graph_title + "MIMIC", "Proportion of samples kept", "Best Score Achieved") """ plt.plot(mutation_prob, time_taken) plt.grid() generate_graph("cp_sa_decay_time", "Continuous Peaks - Genetic Algorithm", "Mutation Probability", "Time taken to achieve that") """ plt.scatter(time_taken, best_score) for i, txt in enumerate(keep_pct): plt.annotate(s=str(txt), xy=(time_taken[i], best_score[i])) plt.legend(loc='best', title='Proportion of samples kept') plt.grid() generate_graph(graph_file + "mimic_scatter", graph_title + "MIMIC", "Time Taken", "Best Score achieved") print('Proportion of samples kept: ', keep_pct) print('Best scores reached: ', best_score) print('Time taken to do that: ', time_taken) print('Function evaluations taken: ', fn_evals_taken)
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 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 get_mimic(problem, keep_pct=0.25): best_state, best_fitness, fitness_curve = mlrose.mimic( problem, pop_size=200, keep_pct=keep_pct, max_attempts=10, max_iters=np.inf, curve=True, random_state=23, ) return best_state, best_fitness, fitness_curve
def mimic(problem, init_state, max_attempts, max_iters): start_time = time.time() best_state, best_fitness, fitness_curve = mlr.mimic( problem, pop_size=200, keep_pct=0.2, max_attempts=max_attempts, max_iters=max_iters, curve=True, random_state=RANDOM_STATE) end_time = time.time() total_time = end_time - start_time print('MIMIC') 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_MIMIC_2(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 = mimic(problem, random_state=random_state, pop_size=300, keep_pct=0.2, **kwargs, fevals=True, curve=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/mimic_{problem_name}_{len(init_state)}_{dt_string}" # plt.plot(average_curves(fit_curves), label="mimic") # plt.title(f"MIMIC {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"MIMIC {problem_name}: {avg_fit}: {avg_time}: {avg_evals}") return avg_fit, avg_time, avg_evals
def plot_MIMICpct(problem, problem_fit, max_attempts, mimpop, maxIter, seed, min=False): PCT = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9] plt.figure() for p in PCT: print(p) best_state, best_fitness, mimicfitness_curve = mlrose.mimic(problem_fit, keep_pct=p, curve=True, pop_size=mimpop, max_attempts=max_attempts, max_iters=maxIter, random_state=seed) print(p, best_fitness) if min: mimicfitness_curve = np.array(mimicfitness_curve) * -1 plt.plot(mimicfitness_curve, label='pct = ' + str(p)) plt.title(problem + " - MIMIC - Keep Percent") plt.xlabel('Iterations') plt.ylabel('Fitness') plt.grid(True) plt.legend() plt.savefig("Images\\" + problem + " - MIMIC - Keep Percent") plt.show()
def plot_MIMpop(problem, problem_fit, max_attempts, mimpct, maxIter, seed, min=False): plt.figure() pop = [100, 200, 300, 400, 500, 600, 700, 800, 900, 1000] for p in pop: print(p) best_state, best_fitness, mimicfitness_curve = mlrose.mimic(problem_fit, pop_size=p, keep_pct=mimpct, curve=True, max_attempts=max_attempts, max_iters=maxIter, random_state=seed) print(p, best_fitness) if min: mimicfitness_curve = np.array(mimicfitness_curve) * -1 plt.plot(mimicfitness_curve, label='pop size = ' + str(p)) plt.title(problem + " - MIMIC - Population Size") plt.xlabel('Iterations') plt.ylabel('Fitness') plt.grid(True) plt.legend() plt.savefig("Images\\" + problem + " - MIMIC - Population Size") plt.show()
def compare_gen_mimic(): fitness_obj = mlrose.CustomFitness(n_peak_fit) opt = mlrose.DiscreteOpt(1, fitness_obj, maximize=True, max_val=10000) global count count = 0 iter_num_counter_ga = [] fitness_list_ga = [] iter_num_counter_mimic = [] fitness_list_mimic = [] for i in range(20): best_state_ga, best_fitness_ga, fitness_curve_ga = mlrose.genetic_alg( opt, pop_size=20, mutation_prob=0.5, curve=True) iter_num_counter_ga.append(count) fitness_list_ga.append(best_fitness_ga) count = 0 best_state_mimic, best_fitness_mimic, fitness_curve_mimic = mlrose.mimic( opt, pop_size=20, curve=True) iter_num_counter_mimic.append(count) fitness_list_mimic.append(best_fitness_mimic) count = 0 plt.figure(figsize=(8, 6)) plt.subplot(121) plt.plot(fitness_list_ga, 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(iter_num_counter_ga, label='ga') plt.plot(iter_num_counter_mimic, label='mimic') plt.xlabel('rounds') plt.ylabel('fitness call no.') plt.title('fitness call number comparision') plt.legend(loc='upper right') plt.show()
pop_size=200, max_attempts=attempts, random_state=seed, curve=True, elite_dreg_ratio=0.5, mutation_prob=0.4) print(f" best GA State: {best_ga_state}") sub_end = time.time() ga_fitnesses.append(best_ga_fitness) ga_times.append(sub_end - sub_start) ## MIMIC sub_start = time.time() best_m_state, best_m_fitness, m_curve = mlr.mimic(problem, pop_size=200, max_attempts=attempts, random_state=seed, curve=True) print(f" best MIMIC State: {best_m_state}") sub_end = time.time() m_fitnesses.append(best_m_fitness) m_times.append(sub_end - sub_start) end = time.time() part2_time += end - start print(f" Iteration Time Elapsed: {end-start}\n") print(f"\n\nPart 2 Time Elapsed: {part2_time}\n") print(f"######### PART 1 #########\n")
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)
_, _, curve = mlrose.genetic_alg( problem, max_attempts=MAX_ATTEMPTS, elite_dreg_ratio=1, 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) * 200) # MIMIC t1 = process_time() _, _, curve = mlrose.mimic( 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) * 200) df = 1 / pd.DataFrame(curve_list).transpose() df.columns = algo_list df.plot() plt.xlabel("Iteration") plt.ylabel("Fitness") plt.title("TSP: Fitness curve vs algorithms") plt.savefig("output/tsp_algo.png") plt.close()
use_fast_mimic=True) mim_stats, mim_curve = mim.run() columns = ['Time', 'Fitness', 'Population Size', 'Keep Percent'] df=pd.read_csv("./queen/queen_prob/mimic__queen_prob__run_stats_df.csv") print(df[columns].sort_values(by=['Fitness'], ascending=False)) max_attempts = 10 max_iters = 25 keep_pct=0.25 pop_size = 200 eval_count = 0 best_state, best_fitness, mimic_curve = mlrh.mimic(prob, max_attempts=max_attempts, max_iters=max_iters, random_state=random_state, pop_size=pop_size, keep_pct=keep_pct, curve=True) print("MIMIC - Total Function Evaluations:", eval_count) plot_fitness_iteration('fitness_iteration_mimic_queens.png',mimic_curve, "Queens - Mimic: Population Size: {}, Keep Percent: {}".format(pop_size, keep_pct)) # RHC rhc = mlrh.RHCRunner(problem=prob, experiment_name=experiment_name, output_directory=output_directory, seed=random_state, max_attempts=200, iteration_list=[2500],
# '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 for alg_name, alg in ALGORITHMS.items(): if f_name == 'max2color': problem = fitness
def run_mimic_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' % ('mimic', 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 pop_size in range(100, 1000, 100): total_score = 0 total_iter = 0 best_state, best_fitness, curve = mlrose.mimic( problem, pop_size=pop_size, keep_pct=0.1, max_iters=10000, random_state=1, curve=True, max_attempts=10) total_score += np.max(curve) total_iter += len(curve) print('The fitness at the best state is: ', total_score / tries, '. Pop size: ', pop_size) self.track_best_params(problem=fitness_name, algo='mimic', param='pop_size', score=total_score, value=pop_size) pop_size = self.get_best_param(problem=fitness_name, algo='mimic', param='pop_size') for keep_pct in range(0, 10, 1): total_score = 0 total_iter = 0 best_state, best_fitness, curve = mlrose.mimic( problem, pop_size=pop_size, keep_pct=1.0 * keep_pct / 10, max_iters=10000, random_state=1, curve=True, max_attempts=10) total_score += np.max(curve) total_iter += len(curve) print('The fitness at the best state is: ', total_score / tries, '. keep_pct: ', 1.0 * keep_pct / 10) self.track_best_params(problem=fitness_name, algo='mimic', param='keep_pct', score=total_score, value=1.0 * keep_pct / 10)
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
df.plot() plt.xlabel("Iteration") plt.ylabel("Fitness") plt.title("OneMax: Fitness curve vs population size in GA") plt.savefig("output/onemax_ga_pop.png") plt.close() #%% tuning for MIMIC curve_list = [] pop_sizes = [50, 100, 200] for p in pop_sizes: _, _, curve = mlrose.mimic( problem, max_attempts=MAX_ATTEMPTS, max_iters=50, pop_size=p, curve=True, random_state=RANDOM_SEED, ) curve_list.append(curve) df = pd.DataFrame(curve_list).transpose() df.columns = pop_sizes df.plot() plt.xlabel("Iteration") plt.ylabel("Fitness") plt.title("OneMax: Fitness curve vs population size in MIMIC") plt.savefig("output/onemax_mimic_pop.png") plt.close() #%% Putting together
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()
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()
plt.ylabel("Fitness") plt.title("FlipFlop: Fitness curve vs population size in GA") plt.savefig("output/flipflop_ga_pop.png") plt.close() print(df.max()) #%% tuning for MIMIC curve_list = [] nth_pct = [0.2, 0.4] for p in nth_pct: _, _, curve = mlrose.mimic( problem, max_attempts=MAX_ATTEMPTS, max_iters=50, keep_pct=p, curve=True, random_state=RANDOM_SEED, ) curve_list.append(curve) df = pd.DataFrame(curve_list).transpose() df.columns = nth_pct df.plot() plt.xlabel("Iteration") plt.ylabel("Fitness") plt.title("FlipFlop: Fitness curve vs nth percentile in MIMIC") plt.savefig("output/flipflop_mimic_nth.png") plt.close() print(df.max())
def run_problem_config(config, OUTPUT_FOLDER="output"): if not os.path.exists(OUTPUT_FOLDER): os.makedirs(OUTPUT_FOLDER) if config['name'] == "nn": run_nn_problem_config(config, OUTPUT_FOLDER) return rhc_run_stats, rhc_run_curves, sa_run_stats, sa_run_curves, ga_run_stats, ga_run_curves, mimic_run_stats, mimic_run_curves = np.full( 8, None) problem = get_problem(config['name'], config['size']) name = config['name'] size = config['size'] rhc_runner = RHCRunner(problem, experiment_name=f"{size}-{name}-rhc", seed=RS, **config['rhc']) sa_runner = SARunner(problem, experiment_name=f"{size}-{name}-sa", seed=RS, decay_list=[GeomDecay], **config['sa']) ga_runner = GARunner(problem, experiment_name=f'{size}-{name}-ga', seed=RS, **config['ga']) mimic_runner = MIMICRunner(problem=problem, experiment_name=f"{size}-{name}-mimic", seed=RS, use_fast_mimic=True, **config['mimic']) problem_size_results = { "optimal": [get_optimal_values(name, n) for n in config['sizes']] } times_results = {} if not config['rhc']['skip']: print(f"generating rhc results for {size}-{name}...") rhc_run_stats, rhc_run_curves = rhc_runner.run() rrs = rhc_run_stats[rhc_run_stats['Iteration'] != 0] best_restarts = [ rrs[rrs['Restarts'].eq(i)]['Fitness'].idxmax() for i in config['rhc']['restart_list'] ] rrs = rrs[rrs.index.isin(best_restarts)] rrs.reset_index(inplace=True, drop=True) rhc_run_stats = rrs best_run = rrs.query('Fitness == Fitness.max()').query( 'Restarts == Restarts.max()').iloc[0] best_restarts = int(best_run['Restarts']) rhc_run_curves = rhc_run_curves.query( f"(current_restart == {best_run['current_restart']}) & (Restarts == {best_run['Restarts']})" ) rhc_run_curves.reset_index(inplace=True, drop=True) times_results['RHC'] = best_run['Time'] print( f"best restarts: {best_restarts}\tTime: {best_run['Time']}\tIterations:{rhc_run_curves['Iteration'].iloc[-1]}\n" ) fig, axes = plt.subplots(nrows=1, ncols=2) rhc_run_curves.plot(title="RHC Convergence", xlabel="Iterations", ylabel="Fitness", ax=axes[0], x="Iteration", y="Fitness") rhc_run_stats.plot(title="RHC Restarts", x="Restarts", y="Fitness", ax=axes[1], marker='o', linestyle='--', xlabel="Number of Restarts", ylabel="Fitness") fig.suptitle(f"{size}-{name} RHC") fig.tight_layout() plt.savefig(f"{OUTPUT_FOLDER}/{size}-{name}-rhc_charts.png") max_iters = max(config['rhc']['iteration_list']) max_attempts = config['rhc']['max_attempts'] rhc_problem_results = np.zeros(len(config['sizes'])) for i in range(len(config['sizes'])): n = config['sizes'][i] start_time = time.time() rhc_problem_results[i] = rhc(get_problem(config['name'], n), max_attempts=max_attempts, max_iters=max_iters, random_state=RS, restarts=best_restarts)[1] running_time = time.time() - start_time print( f"Completed for size {n}\ttime: {running_time}\tFitness: {rhc_problem_results[i]}" ) problem_size_results["RHC"] = rhc_problem_results print() if not config['sa']['skip']: print(f"generating sa results for {size}-{name}...") sa_run_stats, sa_run_curves = sa_runner.run() sars = sa_run_stats[sa_run_stats['Iteration'] != 0] sars.reset_index(inplace=True, drop=True) sa_run_stats = sars best_run = sars.query('Fitness == Fitness.max()').iloc[0] best_temp = best_run['Temperature'] sa_run_curves = sa_run_curves[sa_run_curves['Temperature'] == best_run['Temperature']] sa_run_curves.reset_index(inplace=True, drop=True) times_results['SA'] = best_run['Time'] print( f"best Temperature: {best_temp}\tTime: {best_run['Time']}\tIterations:{sa_run_curves['Iteration'].iloc[-1]}\n" ) fig, axes = plt.subplots(nrows=1, ncols=2) sa_run_curves.plot(title="SA Convergence", xlabel="Iterations", ylabel="Fitness", ax=axes[0], x="Iteration", y="Fitness") sa_run_stats.plot(title="SA Initial Temperature", x="schedule_init_temp", y="Fitness", ax=axes[1], marker='o', linestyle='--', xlabel="Temperature", ylabel="Fitness") fig.suptitle(f"{size}-{name} SA") fig.tight_layout() plt.savefig(f"{OUTPUT_FOLDER}/{size}-{name}-sa_charts.png") max_iters = max(config['sa']['iteration_list']) max_attempts = config['sa']['max_attempts'] sa_problem_results = np.zeros(len(config['sizes'])) for i in range(len(config['sizes'])): n = config['sizes'][i] start_time = time.time() sa_problem_results[i] = sa( get_problem(config['name'], n), max_attempts=max_attempts, max_iters=max_iters, random_state=RS, schedule=GeomDecay(init_temp=best_temp.init_temp))[1] running_time = time.time() - start_time print( f"Completed for size {n}\ttime: {running_time}\tFitness: {sa_problem_results[i]}" ) problem_size_results["SA"] = sa_problem_results print() if not config['ga']['skip']: print(f"generating ga results for {size}-{name}...") ga_run_stats, ga_run_curves = ga_runner.run() ga_run_stats = ga_run_stats[ga_run_stats['Iteration'] != 0] pop_size_results = ga_run_stats.groupby( 'Population Size')['Fitness'].max() mut_rate_results = ga_run_stats.groupby( 'Mutation Rate')['Fitness'].max() ga_groups = ga_run_stats.groupby(['Mutation Rate', 'Population Size']).max()['Fitness'] best_mut_rate, best_pop_size = ga_groups.idxmax() ga_run_curves = ga_run_curves.query( f"(`Mutation Rate` == {best_mut_rate}) & (`Population Size` == {best_pop_size})" ) ga_run_stats.reset_index(inplace=True, drop=True) ga_run_curves.reset_index(inplace=True, drop=True) best_time = ga_run_curves.iloc[-1]['Time'] print( f'best Mutation Rate: {best_mut_rate}\tbest Population Size: {best_pop_size}\tTime: {best_time}\tIterations:{ga_run_curves["Iteration"].iloc[-1]}\n' ) fig, axes = plt.subplots(nrows=1, ncols=3) pop_size_results = ga_run_stats.groupby( 'Population Size')['Fitness'].max() mut_rate_results = ga_run_stats.groupby( 'Mutation Rate')['Fitness'].max() ga_run_curves.plot(title="GA Convergence", xlabel="Iterations", ylabel="Fitness", ax=axes[0], x="Iteration", y="Fitness") pop_size_results.plot(title="GA Population Sizes", ax=axes[1], marker='o', linestyle='--', xlabel="Population Size", ylabel="Fitness") mut_rate_results.plot(title="GA Mutation Rates", ax=axes[2], marker='o', linestyle='--', xlabel="Mutation Rate", ylabel="Fitness") fig.suptitle(f"{size}-{name} GA") fig.tight_layout() plt.savefig(f"{OUTPUT_FOLDER}/{size}-{name}-ga_charts.png") max_iters = max(config['ga']['iteration_list']) max_attempts = config['ga']['max_attempts'] ga_problem_results = np.zeros(len(config['sizes'])) for i in range(len(config['sizes'])): n = config['sizes'][i] start_time = time.time() ga_problem_results[i] = ga(get_problem(config['name'], n), max_attempts=max_attempts, max_iters=max_iters, random_state=RS, pop_size=int(best_pop_size), mutation_prob=best_mut_rate)[1] running_time = time.time() - start_time print( f"Completed for size {n}\ttime: {running_time}\tFitness: {ga_problem_results[i]}" ) problem_size_results["GA"] = ga_problem_results print() if not config['mimic']['skip']: print(f"generating mimic results for {size}-{name}...") mimic_run_stats, mimic_run_curves = mimic_runner.run() mimic_run_stats = mimic_run_stats[mimic_run_stats['Iteration'] != 0] pop_size_results = mimic_run_stats.groupby( 'Population Size')['Fitness'].max() keep_percent_results = mimic_run_stats.groupby( 'Keep Percent')['Fitness'].max() mimic_groups = mimic_run_stats.groupby( ['Keep Percent', 'Population Size']).max()['Fitness'] best_keep_percent, best_pop_size = mimic_groups.idxmax() mimic_run_curves = mimic_run_curves.query( f"(`Keep Percent` == {best_keep_percent}) & (`Population Size` == {best_pop_size})" ) mimic_run_stats.reset_index(inplace=True, drop=True) mimic_run_curves.reset_index(inplace=True, drop=True) best_time = mimic_run_curves.iloc[-1]['Time'] times_results['MIMIC'] = best_time print( f'best Keep Percentage: {best_keep_percent}\tbest Population Size: {best_pop_size}\tTime: {best_time}\tIterations:{mimic_run_curves["Iteration"].iloc[-1]}\n' ) fig, axes = plt.subplots(nrows=1, ncols=3) pop_size_results = mimic_run_stats.groupby( 'Population Size')['Fitness'].max() keep_percent_results = mimic_run_stats.groupby( 'Keep Percent')['Fitness'].max() mimic_run_curves.plot(title="MIMIC Convergence", xlabel="Iterations", ylabel="Fitness", ax=axes[0], x="Iteration", y="Fitness") pop_size_results.plot(title="MIMIC Population Sizes", ax=axes[1], marker='o', linestyle='--', xlabel="Population Size", ylabel="Fitness") keep_percent_results.plot(title="MIMIC Keep Percent", ax=axes[2], marker='o', linestyle='--', xlabel="Keep Percent", ylabel="Fitness") fig.suptitle(f"{size}-{name} MIMIC") fig.tight_layout() plt.savefig(f"{OUTPUT_FOLDER}/{size}-{name}-mimic_charts.png") max_iters = max(config['mimic']['iteration_list']) max_attempts = config['mimic']['max_attempts'] mimic_problem_results = np.zeros(len(config['sizes'])) for i in range(len(config['sizes'])): n = config['sizes'][i] start_time = time.time() mimic_problem_results[i] = mimic(get_problem(config['name'], n), max_attempts=max_attempts, max_iters=max_iters, random_state=RS, pop_size=int(best_pop_size), keep_pct=best_keep_percent)[1] running_time = time.time() - start_time print( f"Completed for size {n}\ttime: {running_time}\tFitness: {mimic_problem_results[i]}" ) problem_size_results["MIMIC"] = mimic_problem_results print() fig, axes = plt.subplots(nrows=1, ncols=1) problem_size_results = pd.DataFrame(problem_size_results, index=config['sizes']) problem_size_results.index.rename('Problem Size', inplace=True) problem_size_results.plot(ax=axes, title=f"{name} Problem Size Results", marker='o', linestyle='--', xlabel="Problem Size", ylabel="Fitness") fig.tight_layout() plt.savefig(f"{OUTPUT_FOLDER}/{name}-problem_sizes.png") html = problem_size_results.to_html(index=True) with open(f"{OUTPUT_FOLDER}/{name}-problem_sizes.html", 'w') as fp: fp.write(html) times_results = pd.Series(times_results).to_frame() times_results.columns = ['Time (s)'] html = times_results.to_html(index=True) with open(f"{OUTPUT_FOLDER}/{size}-{name}-times-results.html", 'w') as fp: fp.write(html) print("Completed running algorithms.\n") return rhc_run_stats, rhc_run_curves, sa_run_stats, sa_run_curves, ga_run_stats, ga_run_curves, mimic_run_stats, mimic_run_curves