def queens_problem(n=8): queens_max = lambda state: sum(np.arange(len(state))) - mlrose.Queens( ).evaluate(state) fitness_queens = mlrose.CustomFitness(queens_max) return mlrose.DiscreteOpt(length=n, fitness_fn=fitness_queens, maximize=True, max_val=n)
def run_sa_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' % ('simulated_annealing', 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.simulated_annealing( problem, max_attempts=max_attempts, max_iters=10000, random_state=1, curve=True) 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='simulated_annealing', param='max_attempts', score=total_score, value=max_attempts)
def get_problem(size=100, t_pct=0.06): global orig_fitness_func orig_fitness_func = mlrose_hiive.ContinuousPeaks(t_pct) fitness = mlrose_hiive.CustomFitness(fitness_func) problem = mlrose_hiive.DiscreteOpt(length=size, fitness_fn=fitness, maximize=True) return problem
def get_flip_flop(size): flip_flop = mlrose.FlipFlop() state = np.array([0,1,0,1,1,1,1]) flip_flop.evaluate(state) problem = mlrose.DiscreteOpt( length=size, fitness_fn=flip_flop, maximize=True, max_val=2 # makes it bit string ) return problem
def get_one_max(size): one_max = mlrose.OneMax() state = np.array([0, 1, 0, 1, 1, 1, 1]) one_max.evaluate(state) problem = mlrose.DiscreteOpt( length=size, fitness_fn=one_max, maximize=True, max_val=2 # makes it bit string ) return problem
def get_continuous_peaks(size): continuous_peaks = mlrose.ContinuousPeaks(t_pct=0.1) state = np.array([0,1,0,1,1,1,1]) continuous_peaks.evaluate(state) problem = mlrose.DiscreteOpt( length=size, fitness_fn=continuous_peaks, maximize=True, max_val=2 # makes it bit string ) return problem
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_four_peaks(size): four_peaks = mlrose.FourPeaks(t_pct=0.1) state = np.array([0, 1, 0, 1, 1, 1, 1]) four_peaks.evaluate(state) problem = mlrose.DiscreteOpt( length=size, fitness_fn=four_peaks, maximize=True, max_val=2 # makes it bit string ) return problem
def get_problem(name, n): if name == "queens": problem = queens_problem(n) elif name == "four_peaks": problem = mlrose.DiscreteOpt(length=n, fitness_fn=FourPeaks(), maximize=True, max_val=2) elif name == "flip_flop": problem = mlrose.DiscreteOpt(length=n, fitness_fn=FlipFlop(), maximize=True, max_val=2) elif name == "six_peaks": problem = mlrose.DiscreteOpt(length=n, fitness_fn=SixPeaks(), maximize=True, max_val=2) else: raise Exception("Invalid Problem Name!") problem.set_mimic_fast_mode(True) return problem
def get_knapsack(size): weights = [10, 5, 2, 8, 15] values = [1, 2, 3, 4, 5] max_weight_pct = 0.6 knapsack = mlrose.Knapsack(weights, values, max_weight_pct) state = np.array([1, 0, 2, 1, 0]) knapsack.evaluate(state) problem = mlrose.DiscreteOpt( length=size, fitness_fn=knapsack, maximize=True, max_val=2 # makes it bit string ) return problem
def main(): four_peaks_fitness = four_peaks.get_four_peaks() four_peaks_tuning_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(10, four_peaks_fitness, maximize=True, max_val=2) problem_size_list = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] #problem_size_list = [10, 20] best_fitness_list = [] for size in problem_size_list: problem = mlrose.DiscreteOpt(size, four_peaks_fitness, maximize=True, max_val=2) experiment_name = 'sa_tuning_size_' + str(size) sa = runners.SARunner(problem=problem, experiment_name=experiment_name, output_directory='./', seed=27, iteration_list=[10000], max_attempts=500, temperature_list=[1]) #decay_list=mlrose.GeomDecay(init_temp=1.1)) #temperature_list=[1, 10, 50, 100, 250, 500, 1000, 2500, 5000, 10000]) #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() #print(df_run_curves.loc[df_run_curves['Fitness'].idxmax()]) #curr_best_fitness = df_run_curves.loc[df_run_curves['Fitness'].idxmax()]['Fitness'] best_fitness_list.append( df_run_curves.loc[df_run_curves['Fitness'].idxmax()]) print(best_fitness_list)
def main(): verbose = True num_runs = 20 max_iters = 3000 # define Cont. Peaks fitness function to maximize fitness_fn = mlrose.ContinuousPeaks() # define optimization problem length = 100 cp_problem = mlrose.DiscreteOpt( length=length, fitness_fn=fitness_fn, maximize=True, ) cp_problem.set_mimic_fast_mode(True) # set initial state initial_state = np.random.randint(0, 2, size=length) # randomized hill climbing rhc_fitness_dfs = cont_peaks_rhc(cp_problem, initial_state, max_iters, num_runs, verbose) print('---') # simulated annealing sa_fitness_dfs = cont_peaks_sa(cp_problem, initial_state, max_iters, num_runs, verbose) print('---') # genetic algorithm ga_fitness_dfs = cont_peaks_ga(cp_problem, max_iters, num_runs, verbose) print('---') # MIMIC algorithm mimic_fitness_dfs = cont_peaks_mimic(cp_problem, max_iters, num_runs, verbose) print('---') # compare algorithm performance plotting.compare_algos( problem_name='cont_peaks', rhc_dfs=rhc_fitness_dfs, sa_dfs=sa_fitness_dfs, ga_dfs=ga_fitness_dfs, mimic_dfs=mimic_fitness_dfs, )
def scale_ann(train_features_spam_norm, train_labels_spam, test_features_spam_norm, test_labels_spam): global count train_acc_list = [] test_acc_list = [] fitness_call_list = [] loss_list = [] for i in range(400, 4001, 400): count = 0 train_features_sub = train_features_spam_norm[:i, :] train_labels_sub = train_labels_spam[:i] fitness_obj = mlrose.CustomFitness(spam_nn_fit, train_features=train_features_sub, train_labels=train_labels_sub) opt = mlrose.DiscreteOpt(237, fitness_obj, maximize=True, max_val=1001) best_state_spam, best_fitness_spam, _ = mlrose.simulated_annealing( opt, schedule=mlrose.ExpDecay(exp_const=0.003), curve=True) loss_list.append(best_fitness_spam) train_predict = predict(best_state_spam, train_features_sub) test_predict = predict(best_state_spam, test_features_spam_norm) fitness_call_list.append(count) train_acc_list.append(accuracy_score(train_labels_sub, train_predict)) test_acc_list.append(accuracy_score(test_labels_spam, test_predict)) plt.figure(figsize=(10, 6)) plt.subplot(121) plt.plot(np.arange(400, 4001, 400), loss_list, label='-1*loss') plt.xlabel('training size') plt.ylabel('-1*loss') plt.title('loss versus training size') plt.legend() plt.subplot(122) plt.plot(np.arange(400, 4001, 400), train_acc_list, label='train') plt.plot(np.arange(400, 4001, 400), test_acc_list, label='test') plt.xlabel('training size') plt.ylabel('accuracy') plt.title('accuracy versus training size') plt.legend() plt.show() # fitness calls versus training size plt.figure(figsize=(6, 6)) plt.plot(np.arange(400, 4001, 400), fitness_call_list, label='#.calls') plt.xlabel('training size') plt.ylabel('fitness calls') plt.legend() plt.show()
def get_problem(size=100): global orig_fitness_func seed = 42 number_of_items_types = size max_weight_per_item = 25 max_value_per_item = 10 max_weight_pct = 0.35 max_item_count = 10 multiply_by_max_item_count = True np.random.seed(seed) weights = 1 + np.random.randint(max_weight_per_item, size=number_of_items_types) values = 1 + np.random.randint(max_value_per_item, size=number_of_items_types) orig_fitness_func = mlrose_hiive.Knapsack(weights, values, max_weight_pct=max_weight_pct, max_item_count=max_item_count, multiply_by_max_item_count=multiply_by_max_item_count) fitness = mlrose_hiive.CustomFitness(fitness_func) problem = mlrose_hiive.DiscreteOpt(length=number_of_items_types, fitness_fn=fitness, maximize=True) return problem
def optimize(self): problem_size_space = self.problem_size # Initializing the problem init_state = np.random.randint(2, size=problem_size_space) fitness = mlrose.FourPeaks(t_pct=0.1) problem = mlrose.DiscreteOpt(length=problem_size_space, fitness_fn=fitness, maximize=True, max_val=2) # SA # super().gridSearchSA(problem,'4Peaks',problem_size_space,self.noOfiteration) # RHC # super().gridSearchRHC(problem,'4Peaks',problem_size_space,self.noOfiteration) #GA # super().gridSearchGA(problem,'4Peaks',problem_size_space,self.noOfiteration) #MIMIC super().gridSearchMIMIC(problem, '4Peaks', problem_size_space, self.noOfiteration)
def optimize(self): problem_size_space = self.problem_size # Initializing the problem init_state = [i for i in range(problem_size_space)] fitness = mlrose.Queens() problem = mlrose.DiscreteOpt(length=problem_size_space, fitness_fn=fitness, maximize=False, max_val=problem_size_space) # SA # super().gridSearchSA(problem,'NQueens',problem_size_space,self.noOfiteration) # RHC # super().gridSearchRHC(problem,'NQueens',problem_size_space,self.noOfiteration) #GA # super().gridSearchGA(problem,'NQueens',problem_size_space,self.noOfiteration) #MIMIC super().gridSearchMIMIC(problem, 'NQueens', problem_size_space, self.noOfiteration)
def plot_func_eval(optimisations): func_evals = [] print("\n plot_func_eval: ", end="") prob_type = Problem.FOUR_PEAKS input_size = [10, 20, 40, 60, 80, 100] k = 0 for i in input_size: fitness = mlrose.FourPeaks(t_pct=0.15) problem = mlrose.DiscreteOpt(length=i, fitness_fn=fitness, maximize=True, max_val=2) func_evals.append([]) for opt in optimisations: state, score, curve, process_time = get_random_optimisation( problem, opt, prob_type) if len(curve) < __MAX_ATTEMPTS[prob_type] or curve[-1][0] > curve[ -(__MAX_ATTEMPTS[prob_type])][0]: func_evals[k].append(curve[-1][1]) else: func_evals[k].append(curve[-(__MAX_ATTEMPTS[prob_type])][1]) print(".", end="") k += 1 func_evals = np.array(func_evals) plt.figure(400) plt.plot(func_evals[:, 0], label=str(optimisations[0])[13:], color='red') plt.plot(func_evals[:, 1], label=str(optimisations[1])[13:], color='blue') plt.plot(func_evals[:, 2], label=str(optimisations[2])[13:], color='green') plt.plot(func_evals[:, 3], label=str(optimisations[3])[13:], color='orange') plt.legend() plt.xticks(np.arange(len(input_size)), [str(z) for z in input_size]) plt.xlabel("input size") plt.ylabel("function evalutations") plt.title(str(prob_type)[8:]) plt.savefig("FITNESS_CURVES" + "/fneval_vs_ipsize_" + str(prob_type)[8:] + ".png")
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()
rhc_repeats = 1 ga_repeats = 200 sa_repeats = 1 mimic_repeats = 1 def fitness_counter(state): global eval_count fitness = mlrose.FourPeaks(t_pct=0.25) eval_count += 1 return fitness.evaluate(state) fitness = mlrose.CustomFitness(fitness_counter) problem = mlrose.DiscreteOpt(length=40, fitness_fn=fitness, maximize=True, max_val=2) ga_evals_list = [] df_ga_stats_list = [] df_ga_curves_list = [] for r in range(ga_repeats): ga = GARunner(problem=problem, experiment_name="ga_test", output_directory="./results/", seed=r, iteration_list=2 ** np.arange(18), max_attempts=50, population_sizes=[300], mutation_rates=[0.2])
plt.plot(np.arange(400, 4001, 400), train_acc_list, label='train') plt.plot(np.arange(400, 4001, 400), test_acc_list, label='test') plt.xlabel('training size') plt.ylabel('accuracy') plt.title('accuracy versus training size') plt.legend() plt.show() # fitness calls versus training size plt.figure(figsize=(6, 6)) plt.plot(np.arange(400, 4001, 400), fitness_call_list, label='#.calls') plt.xlabel('training size') plt.ylabel('fitness calls') plt.legend() plt.show() if __name__ == "__main__": train_features_spam_norm, train_labels_spam, test_features_spam_norm, test_labels_spam = split_train_test_spam( ) fitness_obj = mlrose.CustomFitness(spam_nn_fit, train_features=train_features_spam_norm, train_labels=train_labels_spam) opt = mlrose.DiscreteOpt(237, fitness_obj, maximize=True, max_val=1001) rhc(opt) s_ann(opt) gen_alg(opt) method_compare(opt, train_features_spam_norm, train_labels_spam, test_features_spam_norm, test_labels_spam) scale_ann(train_features_spam_norm, train_labels_spam, test_features_spam_norm, test_labels_spam)
print(f"Attempts: {attempts}") print(f"Max Iterations: {max_it}") print(f"Problem Sizes: {test_range}") print(f"Last Problem Size: {final_prob_len}\n\n") part2_time = 0.0 print(f"\n######### PART 2 #########\n") 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)
def main(): ## SET SOME PARAMS TO USE GLOBALLY max_iters_list = [50, 100, 1000] #,32,64,128,256,512,1024] max_iters_list_full = [2, 4, 8, 16, 32, 64, 128, 256, 512, 1024] rand_list = [1, 11, 22] #,44,55,66,77,88,99] rand_list_full = [0, 11, 22, 33, 44, 55, 66, 77, 88, 99] input_location = 'data/' output_location = 'outputs/' chart_output_location = 'charts/' prefix = '5th_' ## DEFINE PROBLEMS TO SOLVE # Traveling Salesman Problem (TSP) space_length = 1000 cities_cnt = 200 coords_list, x, y = create_TSP(space_length, cities_cnt, return_lists_too=True) plt.plot(x, y, 'o') plt.savefig(chart_output_location + 'TPS_visual' + '.png') fitness_coords = mlrose.TravellingSales(coords=coords_list) problem_TSP = mlrose.TSPOpt(length=len(coords_list), fitness_fn=fitness_coords, maximize=False) # 4 Peaks t_pct = 0.1 length = 200 fitness_4_peaks = mlrose.FourPeaks(t_pct=t_pct) problem_4P = mlrose.DiscreteOpt(length=length, fitness_fn=fitness_4_peaks, maximize=True, max_val=2) problem_4P_small = mlrose.DiscreteOpt(length=50, fitness_fn=fitness_4_peaks, maximize=True, max_val=2) problem_4P_big = mlrose.DiscreteOpt(length=1000, fitness_fn=fitness_4_peaks, maximize=True, max_val=2) # Continuous Peaks t_pct = 0.1 length = 200 fitness_cont_peaks = mlrose.ContinuousPeaks(t_pct=t_pct) problem_cont_peaks = mlrose.DiscreteOpt(length=length, fitness_fn=fitness_cont_peaks, maximize=True, max_val=2) # Flip Flop length = 200 fitness_FF = mlrose.FlipFlop() problem_FF = mlrose.DiscreteOpt(length=length, fitness_fn=fitness_FF, maximize=True, max_val=2) problem_FF_small = mlrose.DiscreteOpt(length=50, fitness_fn=fitness_FF, maximize=True, max_val=2) problem_FF_big = mlrose.DiscreteOpt(length=1000, fitness_fn=fitness_FF, maximize=True, max_val=2) # Knapsack length = 200 weights, values = create_Knapsack(length) weights_big, values_big = create_Knapsack(1000) weights_small, values_small = create_Knapsack(50) fitness_KS = mlrose.Knapsack(weights, values, max_weight_pct=0.65) fitness_KS_big = mlrose.Knapsack(weights_big, values_big, max_weight_pct=0.65) fitness_KS_small = mlrose.Knapsack(weights_small, values_small, max_weight_pct=0.65) problem_KS = mlrose.DiscreteOpt(length=length, fitness_fn=fitness_KS, maximize=True, max_val=2) problem_KS_big = mlrose.DiscreteOpt(length=1000, fitness_fn=fitness_KS_big, maximize=True, max_val=2) problem_KS_small = mlrose.DiscreteOpt(length=50, fitness_fn=fitness_KS_small, maximize=True, max_val=2) dict_of_param_dict = {} dict_of_param_dict['GA'] = { 'pop_size': [100, 200], #,1000], 'mutation_prob': [0.5, 0.1, 0.2], 'max_attempts': [5, 10, 30], 'max_iters': max_iters_list, 'random_state': rand_list } dict_of_param_dict['RHC'] = { 'max_attempts': [30, 50, 100], #[5,10,20,50] 'restarts': [5, 10, 20], #[0,1,2,5] 'max_iters': max_iters_list, 'random_state': rand_list } dict_of_param_dict['SA'] = { 'max_attempts': [10, 50, 100], 'init_temp': [1.0, 10.0, 0.5, 20, 100, 1000], 'decay': [0.99, 0.8, 0.5], 'max_iters': max_iters_list, 'random_state': rand_list } dict_of_param_dict['MIMIC'] = { 'pop_size': [100, 150], 'keep_pct': [0.5, 0.2], 'max_attempts': [10], 'max_iters': [100], 'random_state': rand_list } MIMIC_FF = { 'pop_size': 100, 'keep_pct': 0.5, 'max_attempts': 30, 'max_iters': [2, 4, 8, 16, 32, 64, 128], ## put full list here before uploading 'random_state': [0, 11, 22, 33, 44] } MIMIC_4P = { 'pop_size': 150, 'keep_pct': 0.2, 'max_attempts': 30, 'max_iters': [2, 4, 8, 16, 32, 64, 128], ## put full list here before uploading 'random_state': [0, 11, 22, 33, 44] } MIMIC_KS = { 'pop_size': 150, 'keep_pct': 0.5, 'max_attempts': 30, 'max_iters': [2, 4, 8, 16, 32, 64, 128], ## put full list here before uploading 'random_state': [0, 11, 22, 33, 44] } MIMIC_CP = { 'pop_size': 200, 'keep_pct': 0.2, 'max_attempts': 30, 'max_iters': [2, 4, 8, 16, 32, 64, 128], ## put full list here before uploading 'random_state': [0, 11, 22, 33, 44] } GA_FF = { 'pop_size': 200, #,1000], 'mutation_prob': 0.5, 'max_attempts': 30, 'max_iters': max_iters_list_full, 'random_state': rand_list_full } MIMIC_FF2 = { 'pop_size': [100], 'keep_pct': [0.5], 'max_attempts': [30, 50], 'max_iters': [64], 'random_state': [55] #,66,77,88,99] } print("starting MIMIC FF") # GETTING MIMIC FF RESULTS print("starting MIMIC FF...") ''' ## Started running at 3am results_df, curve_output_list = fitness_by_iter('MIMIC', problem_FF, MIMIC_FF['max_iters'], MIMIC_FF['random_state']\ , pop_size=MIMIC_FF['pop_size'], max_attempts=MIMIC_FF['max_attempts'], curve=True, keep_pct=MIMIC_FF['keep_pct']) results_df.to_csv(output_location + 'final_MIMIC_FF_attempt_3am.csv') results_df, curve_output_list = fitness_by_iter('MIMIC', problem_4P, MIMIC_4P['max_iters'], MIMIC_4P['random_state']\ , pop_size=MIMIC_4P['pop_size'], max_attempts=MIMIC_4P['max_attempts'], curve=True, keep_pct=MIMIC_4P['keep_pct']) results_df.to_csv(output_location + 'final_MIMIC_4P_attempt_3am.csv') results_df, curve_output_list = fitness_by_iter('MIMIC', problem_KS, MIMIC_KS['max_iters'], MIMIC_KS['random_state']\ , pop_size=MIMIC_KS['pop_size'], max_attempts=MIMIC_KS['max_attempts'], curve=True, keep_pct=MIMIC_KS['keep_pct']) results_df.to_csv(output_location + 'final_MIMIC_KS_attempt_3am.csv') results_df, curve_output_list = fitness_by_iter('MIMIC', problem_cont_peaks, MIMIC_CP['max_iters'], MIMIC_CP['random_state']\ , pop_size=MIMIC_CP['pop_size'], max_attempts=MIMIC_CP['max_attempts'], curve=True, keep_pct=MIMIC_CP['keep_pct']) results_df.to_csv(output_location + 'final_MIMIC_CP_attempt_3am.csv') ''' ## USED FOR GRID SEARCHING PARAMETERS FOR RO ON 3 PROBLEMS GA_params_dict = get_params_for_grid_search('GA', max_iters_list=[200]) print("Here are my GA params for grid search: ", GA_params_dict) SA_params_dict = get_params_for_grid_search('SA', max_iters_list=max_iters_list) print("Here are my SA params for grid search: ", SA_params_dict) RHC_params_dict = get_params_for_grid_search('RHC', max_iters_list=max_iters_list) print("Here are my RHC params for grid search: ", RHC_params_dict) MIMIC_params_dict = get_params_for_grid_search( 'MIMIC', max_iters_list=max_iters_list) print("Here are my MIMIC params for grid search: ", MIMIC_params_dict) #grid_search_MIMIC = MIMIC_best_params(problem_TPS, MIMIC_params_dict, inverse_fitness=False) #grid_search_MIMIC.to_csv(output_location + 'grid_search_MIMIC.csv') ''' grid_search_GA = GA_best_params(problem_FF, GA_params_dict, inverse_fitness=False) grid_search_GA.to_csv(output_location + prefix + 'grid_search_GA_FF_really.csv') print("finished GA") grid_search_MIMIC = MIMIC_best_params(problem_FF, MIMIC_params_dict, inverse_fitness=False) grid_search_MIMIC.to_csv(output_location + prefix + 'grid_search_MIMIC_FF_really.csv') ''' print("finished MIMIC FF") print("Doing GA rn") #results_df, curve_output_list = fitness_by_iter('GA', problem_FF, GA_FF['max_iters'], GA_FF['random_state']\ #, pop_size=GA_FF['pop_size'], max_attempts=GA_FF['max_attempts'], mutation_prob=GA_FF['mutation_prob'],curve=True) #results_df.to_csv(output_location + 'final_MIMIC_FF_attempt_1am.csv') print("finished GA") ''' GRID SEARCHING print("Starting grid search for RHC") grid_search_RHC = RHC_best_params(problem_TSP, RHC_params_dict, inverse_fitness=False) grid_search_RHC.to_csv(output_location + prefix +'grid_search_RHC_TSP.csv') grid_search_RHC = RHC_best_params(problem_FF, RHC_params_dict, inverse_fitness=False) grid_search_RHC.to_csv(output_location + prefix + 'grid_search_RHC_FF.csv') grid_search_RHC = RHC_best_params(problem_cont_peaks, RHC_params_dict, inverse_fitness=False) grid_search_RHC.to_csv(output_location + prefix + 'grid_search_RHC_cont_peaks.csv') grid_search_RHC = RHC_best_params(problem_4P, RHC_params_dict, inverse_fitness=False) grid_search_RHC.to_csv(output_location + prefix + 'grid_search_RHC_4P.csv') print("Starting grid search for SA") grid_search_SA = SA_best_params(problem_TSP, SA_params_dict, inverse_fitness=False) grid_search_SA.to_csv(output_location + prefix + 'grid_search_SA_TSP.csv') grid_search_SA = SA_best_params(problem_FF, SA_params_dict, inverse_fitness=False) grid_search_SA.to_csv(output_location + prefix + 'grid_search_SA_FF.csv') grid_search_SA = SA_best_params(problem_cont_peaks, SA_params_dict, inverse_fitness=False) grid_search_SA.to_csv(output_location + prefix + 'grid_search_SA_cont_peaks.csv') grid_search_SA = SA_best_params(problem_4P, SA_params_dict, inverse_fitness=False) grid_search_SA.to_csv(output_location + prefix + 'grid_search_SA_4P.csv') print("Starting grid search for GA") grid_search_GA = GA_best_params(problem_TSP, GA_params_dict, inverse_fitness=False) grid_search_GA.to_csv(output_location + prefix + 'grid_search_GA_TSP.csv') grid_search_GA = GA_best_params(problem_FF, GA_params_dict, inverse_fitness=False) grid_search_GA.to_csv(output_location + prefix + 'grid_search_GA_FF.csv') grid_search_GA = GA_best_params(problem_cont_peaks, GA_params_dict, inverse_fitness=False) grid_search_GA.to_csv(output_location + prefix + 'grid_search_GA_cont_peaks.csv') grid_search_GA = GA_best_params(problem_4P, GA_params_dict, inverse_fitness=False) grid_search_GA.to_csv(output_location + prefix + 'grid_search_GA_4P.csv') ''' ''' print("Starting grid search for MIMIC") grid_search_MIMIC = MIMIC_best_params(problem_FF, MIMIC_params_dict, inverse_fitness=False) grid_search_MIMIC.to_csv(output_location + prefix + 'grid_search_MIMIC_FF.csv') #grid_search_MIMIC = MIMIC_best_params(problem_cont_peaks, MIMIC_params_dict, inverse_fitness=False) #grid_search_MIMIC.to_csv(output_location + prefix + 'grid_search_MIMIC_cont_peaks.csv') grid_search_MIMIC = MIMIC_best_params(problem_4P, MIMIC_params_dict, inverse_fitness=False) grid_search_MIMIC.to_csv(output_location + prefix + 'grid_search_MIMIC_4P.csv') #grid_search_MIMIC = MIMIC_best_params(problem_TSP, MIMIC_params_dict, inverse_fitness=False) #grid_search_MIMIC.to_csv(output_location + 'grid_search_MIMIC_TSP.csv') print("Finished MIMIC grid searches") print("Starting grid search for Knapsack") #grid_search_MIMIC = MIMIC_best_params(problem_KS, MIMIC_params_dict, inverse_fitness=False) #grid_search_MIMIC.to_csv(output_location + prefix + 'grid_search_MIMIC_KS.csv') #grid_search_GA = GA_best_params(problem_KS, GA_params_dict, inverse_fitness=False) #grid_search_GA.to_csv(output_location + prefix + 'grid_search_GA_KS.csv') grid_search_SA = SA_best_params(problem_KS, SA_params_dict, inverse_fitness=False) grid_search_SA.to_csv(output_location + prefix + 'grid_search_SA_KS.csv') grid_search_RHC = RHC_best_params(problem_KS, RHC_params_dict, inverse_fitness=False) grid_search_RHC.to_csv(output_location + prefix + 'grid_search_RHC_KS.csv') ''' ## Fitting MIMIC separately and with fewer iterations for all except the FF as run time is so long for MIMIC max = 128 ''' MIMIC CURVE FOR CHARTS ##### Started (again) at 8am ###### print("Fitting for MIMIC using the 'curve=True' functionality") print("First for KS") start_time_fit = time.perf_counter() a,b,curve_output = mlrose.mimic(problem_KS, pop_size=100, keep_pct=0.5, max_attempts=10, max_iters=128, curve=True\ , random_state=0) end_time_fit = time.perf_counter() time_used = end_time_fit - start_time_fit df1, df2 = curve_to_df(curve_output, max) df2['time_to_128'] = time_used df1.to_csv(output_location+'MIMIC_KS_full_curve.csv') df2.to_csv(output_location+'MIMIC_KS_short_curve.csv') print("Finished KS") print("Next for 4 Peaks") start_time_fit = time.perf_counter() a,b,curve_output = mlrose.mimic(problem_4P, pop_size=150, keep_pct=0.2, max_attempts=10, max_iters=128, curve=True\ , random_state=0) end_time_fit = time.perf_counter() time_used = end_time_fit - start_time_fit df1, df2 = curve_to_df(curve_output, max) df2['time_to_128'] = time_used df1.to_csv(output_location+'MIMIC_4P_full_curve.csv') df2.to_csv(output_location+'MIMIC_4P_short_curve.csv') print("Finished 4 Peaks") print("Next for 4 Peaks with 100 and 0.5") start_time_fit = time.perf_counter() a,b,curve_output = mlrose.mimic(problem_4P, pop_size=100, keep_pct=0.5, max_attempts=10, max_iters=128, curve=True\ , random_state=0) end_time_fit = time.perf_counter() time_used = end_time_fit - start_time_fit df1, df2 = curve_to_df(curve_output, max) df2['time_to_128'] = time_used df1.to_csv(output_location+'MIMIC_4P_pop100_keep50_full_curve.csv') df2.to_csv(output_location+'MIMIC_4P_pop100_keep50_short_curve.csv') print("Finished 4 Peaks") print("Next for 4 Peaks with 100 and 0.2") start_time_fit = time.perf_counter() a,b,curve_output = mlrose.mimic(problem_4P, pop_size=100, keep_pct=0.2, max_attempts=10, max_iters=128, curve=True\ , random_state=0) end_time_fit = time.perf_counter() time_used = end_time_fit - start_time_fit df1, df2 = curve_to_df(curve_output, max) df2['time_to_128'] = time_used df1.to_csv(output_location+'MIMIC_4P_pop100_keep20_full_curve.csv') df2.to_csv(output_location+'MIMIC_4P_pop100_keep20_short_curve.csv') print("Finished 4 Peaks") print("Next for 4 Peaks with 150 and 0.5") start_time_fit = time.perf_counter() a,b,curve_output = mlrose.mimic(problem_4P, pop_size=100, keep_pct=0.2, max_attempts=10, max_iters=128, curve=True\ , random_state=0) end_time_fit = time.perf_counter() time_used = end_time_fit - start_time_fit df1, df2 = curve_to_df(curve_output, max) df2['time_to_128'] = time_used df1.to_csv(output_location+'MIMIC_4P_pop150_keep50_full_curve.csv') df2.to_csv(output_location+'MIMIC_4P_pop150_keep50_short_curve.csv') print("Finished 4 Peaks") print("Next for 4 Peaks Big") start_time_fit = time.perf_counter() a,b,curve_output = mlrose.mimic(problem_4P_big, pop_size=150, keep_pct=0.2, max_attempts=10, max_iters=128, curve=True\ , random_state=0) end_time_fit = time.perf_counter() time_used = end_time_fit - start_time_fit df1, df2 = curve_to_df(curve_output, max) df2['time_to_128'] = time_used df1.to_csv(output_location+'MIMIC_4P_big_full_curve.csv') df2.to_csv(output_location+'MIMIC_4P_big_short_curve.csv') print("Finished 4 Peaks Big") print("Next for KS Small") start_time_fit = time.perf_counter() a,b,curve_output = mlrose.mimic(problem_KS_small, pop_size=100, keep_pct=0.5, max_attempts=10, max_iters=128, curve=True\ , random_state=0) end_time_fit = time.perf_counter() time_used = end_time_fit - start_time_fit df1, df2 = curve_to_df(curve_output, max) df2['time_to_128'] = time_used df1.to_csv(output_location+'MIMIC_KS_small_full_curve.csv') df2.to_csv(output_location+'MIMIC_KS_small_short_curve.csv') print("Finished KS small") print("Next FF small") start_time_fit = time.perf_counter() a,b,curve_output = mlrose.mimic(problem_FF_small, pop_size=100, keep_pct=0.5, max_attempts=10, max_iters=128, curve=True\ , random_state=0) end_time_fit = time.perf_counter() time_used = end_time_fit - start_time_fit df1, df2 = curve_to_df(curve_output, max) df2['time_to_128'] = time_used df1.to_csv(output_location+'MIMIC_FF_small_full_curve.csv') df2.to_csv(output_location+'MIMIC_KS_small_short_curve.csv') print("Finished FF Small") print("Next for 4 Peaks Small") start_time_fit = time.perf_counter() a,b,curve_output = mlrose.mimic(problem_4P_small, pop_size=150, keep_pct=0.2, max_attempts=10, max_iters=128, curve=True\ , random_state=0) end_time_fit = time.perf_counter() time_used = end_time_fit - start_time_fit df1, df2 = curve_to_df(curve_output, max) df2['time_to_128'] = time_used df1.to_csv(output_location+'MIMIC_4P_small_full_curve.csv') df2.to_csv(output_location+'MIMIC_4P_small_short_curve.csv') print("Finished 4 Peaks Small") ''' ### Now GA GA_FF = { 'pop_size': 100, #,1000], 'mutation_prob': 0.1, 'max_attempts': 30, 'max_iters': max_iters_list_full, 'random_state': rand_list_full } GA_KS = { 'pop_size': 200, #,1000], 'mutation_prob': 0.2, 'max_attempts': 30, 'max_iters': max_iters_list_full, 'random_state': rand_list_full } GA_4P = { 'pop_size': 200, #,1000], 'mutation_prob': 0.5, 'max_attempts': 30, 'max_iters': max_iters_list_full, 'random_state': rand_list_full } ''' More fitness by iteration calculations #results_df, curve_output_list = fitness_by_iter('GA', problem_FF, GA_FF['max_iters'], GA_FF['random_state']\ #, pop_size=GA_FF['pop_size'], max_attempts=GA_FF['max_attempts'], curve=True, mutation_prob=GA_FF['mutation_prob']) #results_df.to_csv(output_location + 'final_GA_FF_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('GA', problem_FF_small, GA_FF['max_iters'], GA_FF['random_state']\ , pop_size=GA_FF['pop_size'], max_attempts=GA_FF['max_attempts'], curve=True, mutation_prob=GA_FF['mutation_prob']) results_df.to_csv(output_location + 'final_GA_FF_small_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('GA', problem_FF_big, GA_FF['max_iters'], GA_FF['random_state']\ , pop_size=GA_FF['pop_size'], max_attempts=GA_FF['max_attempts'], curve=True, mutation_prob=GA_FF['mutation_prob']) results_df.to_csv(output_location + 'final_GA_FF_big_attempt_8am.csv') #results_df, curve_output_list = fitness_by_iter('GA', problem_4P, GA_4P['max_iters'], GA_4P['random_state']\ #, pop_size=GA_4P['pop_size'], max_attempts=GA_4P['max_attempts'], curve=True, mutation_prob=GA_4P['mutation_prob']) #results_df.to_csv(output_location + 'final_GA_4P_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('GA', problem_4P_big, GA_4P['max_iters'], GA_4P['random_state']\ , pop_size=GA_4P['pop_size'], max_attempts=GA_4P['max_attempts'], curve=True, mutation_prob=GA_4P['mutation_prob']) results_df.to_csv(output_location + 'final_GA_4P_big_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('GA', problem_4P_small, GA_4P['max_iters'], GA_4P['random_state']\ , pop_size=GA_4P['pop_size'], max_attempts=GA_4P['max_attempts'], curve=True, mutation_prob=GA_4P['mutation_prob']) results_df.to_csv(output_location + 'final_GA_4P_small_attempt_8am.csv') #results_df, curve_output_list = fitness_by_iter('GA', problem_KS, GA_KS['max_iters'], GA_KS['random_state']\ #, pop_size=GA_KS['pop_size'], max_attempts=GA_KS['max_attempts'], curve=True, mutation_prob=GA_KS['mutation_prob']) #results_df.to_csv(output_location + 'final_GA_KS_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('GA', problem_KS_big, GA_KS['max_iters'], GA_KS['random_state']\ , pop_size=GA_KS['pop_size'], max_attempts=GA_KS['max_attempts'], curve=True, mutation_prob=GA_KS['mutation_prob']) results_df.to_csv(output_location + 'final_GA_KS_big_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('GA', problem_KS_small, GA_KS['max_iters'], GA_KS['random_state']\ , pop_size=GA_KS['pop_size'], max_attempts=GA_KS['max_attempts'], curve=True, mutation_prob=GA_KS['mutation_prob']) results_df.to_csv(output_location + 'final_GA_KS_small_attempt_8am.csv') ''' ########### SA print("now doing SA") SA_4P = { 'max_attempts': 10, 'schedule': mlrose.GeomDecay(init_temp=100, decay=0.8), 'max_iters': max_iters_list_full, 'random_state': rand_list_full } SA_FF = { 'max_attempts': 10, 'schedule': mlrose.GeomDecay(init_temp=100, decay=0.8), 'max_iters': max_iters_list_full, 'random_state': rand_list_full } results_df, curve_output_list = fitness_by_iter('SA', problem_4P, SA_4P['max_iters'], SA_4P['random_state']\ , schedule=SA_4P['schedule'], max_attempts=SA_4P['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_SA_4P_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('SA', problem_4P_big, SA_4P['max_iters'], SA_4P['random_state']\ , schedule=SA_4P['schedule'], max_attempts=SA_4P['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_SA_4P_big_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('SA', problem_4P, SA_4P['max_iters'], SA_4P['random_state']\ , schedule=SA_4P['schedule'], max_attempts=SA_4P['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_SA_4P_small_attempt_8am.csv') ''' more fitness by iteration calculations #results_df, curve_output_list = fitness_by_iter('SA', problem_FF, SA_FF['max_iters'], SA_FF['random_state']\ #, schedule=SA_FF['schedule'], max_attempts=SA_FF['max_attempts'], curve=True) #results_df.to_csv(output_location + 'final_SA_FF_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('SA', problem_FF_big, SA_FF['max_iters'], SA_FF['random_state']\ , schedule=SA_FF['schedule'], max_attempts=SA_FF['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_SA_FF_big_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('SA', problem_FF_small, SA_FF['max_iters'], SA_FF['random_state']\ , schedule=SA_FF['schedule'], max_attempts=SA_FF['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_SA_FF_small_attempt_8am.csv') SA_4P = { 'max_attempts':10, 'schedule':mlrose.GeomDecay(init_temp=100, decay=0.8), 'max_iters':max_iters_list_full, 'random_state':rand_list_full } results_df, curve_output_list = fitness_by_iter('KS', problem_4P, SA_4P['max_iters'], SA_4P['random_state']\ , schedule=SA_4P['schedule'], max_attempts=SA_4P['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_SA_4P_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('SA', problem_4P_big, SA_4P['max_iters'], SA_4P['random_state']\ , schedule=SA_4P['schedule'], max_attempts=SA_4P['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_SA_4P_big_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('SA', problem_4P, SA_4P['max_iters'], SA_4P['random_state']\ , schedule=SA_4P['schedule'], max_attempts=SA_4P['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_SA_4P_small_attempt_8am.csv') ''' print("picking up where I left off on making the final curves..") SA_KS = { 'max_attempts': 10, 'schedule': mlrose.GeomDecay(init_temp=1000, decay=0.99), 'max_iters': max_iters_list_full, 'random_state': rand_list_full } ''' more fitness by iteration calculations results_df, curve_output_list = fitness_by_iter('SA', problem_KS, SA_KS['max_iters'], SA_KS['random_state']\ , schedule=SA_KS['schedule'], max_attempts=SA_KS['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_SA_KS_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('SA', problem_KS_big, SA_KS['max_iters'], SA_KS['random_state']\ , schedule=SA_KS['schedule'], max_attempts=SA_KS['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_SA_KS_big_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('SA', problem_KS_small, SA_KS['max_iters'], SA_KS['random_state']\ , schedule=SA_KS['schedule'], max_attempts=SA_KS['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_SA_KS_small_attempt_8am.csv') ''' RHC_KS = { 'max_attempts': 50, 'restarts': 20, 'max_iters': max_iters_list_full, 'random_state': rand_list_full } ''' results_df, curve_output_list = fitness_by_iter('RHC', problem_KS, RHC_KS['max_iters'], RHC_KS['random_state']\ , restarts=RHC_KS['restarts'], max_attempts=RHC_KS['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_RHS_KS_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('RHC', problem_KS_big, RHC_KS['max_iters'], RHC_KS['random_state']\ , restarts=RHC_KS['restarts'], max_attempts=RHC_KS['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_RHS_KS_big_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('RHC', problem_KS_small, RHC_KS['max_iters'], RHC_KS['random_state']\ , restarts=RHC_KS['restarts'], max_attempts=RHC_KS['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_RHS_KS_small_attempt_8am.csv') ''' RHC_FF = { 'max_attempts': 50, 'restarts': 20, 'max_iters': max_iters_list_full, 'random_state': rand_list_full } ''' results_df, curve_output_list = fitness_by_iter('RHC', problem_FF, RHC_FF['max_iters'], RHC_FF['random_state']\ , restarts=RHC_FF['restarts'], max_attempts=RHC_FF['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_RHS_FF_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('RHC', problem_FF_big, RHC_FF['max_iters'], RHC_FF['random_state']\ , restarts=RHC_FF['restarts'], max_attempts=RHC_FF['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_RHS_FF_big_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('RHC', problem_FF_small, RHC_FF['max_iters'], RHC_FF['random_state']\ , restarts=RHC_FF['restarts'], max_attempts=RHC_FF['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_RHS_FF_small_attempt_8am.csv') ''' RHC_4P = { 'max_attempts': 50, 'restarts': 20, 'max_iters': max_iters_list_full, 'random_state': rand_list_full } ''' results_df, curve_output_list = fitness_by_iter('RHC', problem_4P, RHC_4P['max_iters'], RHC_4P['random_state']\ , restarts=RHC_4P['restarts'], max_attempts=RHC_4P['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_RHS_4P_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('RHC', problem_4P_small, RHC_4P['max_iters'], RHC_4P['random_state']\ , restarts=RHC_4P['restarts'], max_attempts=RHC_4P['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_RHS_4P_small_attempt_8am.csv') results_df, curve_output_list = fitness_by_iter('RHC', problem_4P_big, RHC_4P['max_iters'], RHC_4P['random_state']\ , restarts=RHC_4P['restarts'], max_attempts=RHC_4P['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_RHS_4P_big_attempt_8am.csv') ''' ## where it stopped print("I will now make the complexity curves for other algos") SA_4P_hacked = { 'max_attempts': 10, 'schedule': mlrose.GeomDecay(init_temp=100, decay=0.99), 'max_iters': max_iters_list_full, 'random_state': rand_list_full } ''' results_df, curve_output_list = fitness_by_iter('SA', problem_4P, SA_4P['max_iters'], SA_4P['random_state']\ , schedule=SA_4P_hacked['schedule'], max_attempts=SA_4P['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_SA_4P_decay_99.csv') results_df, curve_output_list = fitness_by_iter('SA', problem_4P, SA_4P['max_iters'], SA_4P['random_state']\ , schedule=mlrose.GeomDecay(init_temp=1, decay=0.8), max_attempts=SA_4P['max_attempts'], curve=True) results_df.to_csv(output_location + 'final_SA_4P_T_1_decay_80.csv') results_df, curve_output_list = fitness_by_iter('GA', problem_KS, GA_KS['max_iters'], GA_KS['random_state']\ , pop_size=GA_KS['pop_size'], max_attempts=GA_KS['max_attempts'], curve=True, mutation_prob=0.1) results_df.to_csv(output_location + 'final_GA_KS_mutation_01.csv') ''' results_df, curve_output_list = fitness_by_iter('GA', problem_KS, GA_KS['max_iters'], GA_KS['random_state']\ , pop_size=100, max_attempts=GA_KS['max_attempts'], curve=True, mutation_prob=0.2) results_df.to_csv(output_location + 'final_GA_KS_mutation_02_pop_100.csv') ## Need a few more MIMIC chart inputs #print("Need a few more MIMIC chart inputs, so I will now make those") #print("Next FF p=100 keep=0.2") ''' MIMIC inputs for charts
plt.ylabel(y) plt.title(title) length = len(curve) plt.plot(range(length), curve, label=y, lw=2) plt.legend(loc="best") plt.savefig(name) # Problem definition length = 35 eval_count = 0 # Initialize custom fitness function object q_fitness = mlrh.FourPeaks(t_pct=0.1) # q_fitness = mlrose.Queens() prob = mlrh.DiscreteOpt(length=40, fitness_fn=q_fitness, maximize=True) experiment_name = "queen_prob" output_directory = "queen" # SA sa = mlrh.SARunner(problem=prob, experiment_name=experiment_name, output_directory=output_directory, seed=random_state, max_attempts=200, iteration_list=[2000], temperature_list=[0.01, 0.1, 1, 10, 100, 1000], decay_list=[mlrh.GeomDecay, mlrh.ExpDecay, mlrh.ArithDecay]) sa_stats, sa_curve = sa.run() columns = ['Time', 'Fitness', 'Temperature', 'schedule_type']
def method_compare(): global count count = 0 fitness_obj = mlrose.CustomFitness(n_peak_fit) opt = mlrose.DiscreteOpt(1, fitness_obj, maximize=True, max_val=10000) 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 n-peak problem:', best_state_climb) print('hill climbing best fitness for n-peak problem:', best_fitness_climb) print('hill climbing fitting curve for n-peak 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 n-peak problem:', best_state_ann) print('simulated annealing best fitness for n-peak problem:', best_fitness_ann) print('simulated annealing fitting curve for n-peak 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=20, mutation_prob=0.5, curve=True) print('---------------------genetic alg----------------------------') print('genetic algorithm best state for n-peak problem:', best_state_ga) print('genetic algorithm best fitnees for n-peak problem:', best_fitness_ga) print('genetic algorithm fitness curve for n-peak 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=20, curve=True) print('------------------------mimic-------------------------------') print('mimic best state for n-peak problem:', best_state_mimic) print('mimic best fitness value for n-peak problem:', best_fitness_mimic) print('mimic curve for n-peak problem:', fitness_curve_mimic) print('number of fitness calls 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(0, 5) plt.title('random hill climb') plt.subplot(222) plt.plot(fitness_curve_ann) plt.ylabel('fitness') plt.xlabel('num_iter') plt.ylim(0, 5) plt.title('simulated annealing') plt.subplot(223) plt.plot(fitness_curve_ga) plt.ylim(0, 5) plt.ylabel('fitness') plt.xlabel('num_iter') plt.title('genetic algorithm') plt.subplot(224) plt.plot(fitness_curve_mimic) plt.ylim(0, 5) plt.title('mimic') plt.ylabel('fitness') plt.xlabel('num_iter') plt.show()
def one_max(): print('One Max') sa = [] rhc = [] ga = [] mim = [] input_sizes = [100] for i in input_sizes: state = np.array([np.random.randint(0, 2) for i in range(i)]) # state = np.zeros(i) fitness = mlr.OneMax() problem = mlr.DiscreteOpt(length=i, fitness_fn=fitness, maximize=True, max_val=2) best_state, best_fitness, fitness_curve, time = randomized_hill_climb( problem, state, 100, 600) rhc.append((best_fitness, fitness_curve, time)) best_state, best_fitness, fitness_curve, time = simulated_annealing( problem, state, 100, 600) sa.append((best_fitness, fitness_curve, time)) best_state, best_fitness, fitness_curve, time = genetic_algorithm( problem, state, 100, 600) ga.append((best_fitness, fitness_curve, time)) best_state, best_fitness, fitness_curve, time = mimic( problem, state, 100, 600) mim.append((best_fitness, fitness_curve, time)) plot_data([i + 1 for i in range(len(rhc[0][1]))], rhc[0][1], title="OneMax (Input Size = " + str(len(state)) + ")", x_label="Iterations", y_label="Fitness Score", color="blue", label='RHC') plot_data([i + 1 for i in range(len(sa[0][1]))], sa[0][1], title="OneMax (Input Size = " + str(len(state)) + ")", x_label="Iterations", y_label="Fitness Score", color="orange", label='SA') plot_data([i + 1 for i in range(len(ga[0][1]))], ga[0][1], title="OneMax (Input Size = " + str(len(state)) + ")", x_label="Iterations", y_label="Fitness Score", color="green", label='GA') plot_data([i + 1 for i in range(len(mim[0][1]))], mim[0][1], title="OneMax (Input Size = " + str(len(state)) + ")", x_label="Iterations", y_label="Fitness Score", color="red", label='MIMIC') title = 'One Max' plt.savefig('output/' + title + '.png') plt.close()
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) if __name__ == "__main__": # Initialize fitness function object using Custom function fitness_fn = mlrose_hiive.CustomFitness(ks_fitness_fn) # Define optimization problem object N = 10 problem = mlrose_hiive.DiscreteOpt(length=N, fitness_fn=fitness_fn, maximize=True, max_val=2) max_iters = 1500 iterations = range(0, max_iters, 50) random_seed = 1 graph_file = 'ks_' graph_title = 'Knapsack Problem - ' print('***************Knapsack Optimization Problem*****************') # Random hill climbing print('--------------Random Hill Climbing---------------') rhc(problem, iterations, random_seed, graph_file, graph_title) # simulate annealing print('--------------Simulated Annealing---------------') sa(problem, iterations, random_seed, graph_file, graph_title) # Genetic Algorithm print('--------------Genetic Algorithm---------------') ga(problem,iterations,random_seed, graph_file, graph_title)
# -*- coding: utf-8 -*- import mlrose_hiive as mlrose import matplotlib.pyplot as plt import pandas as pd import numpy as np from time import process_time print("Running OneMax...") fitness = mlrose.OneMax() problem = mlrose.DiscreteOpt(100, fitness) RANDOM_SEED = 42 MAX_ATTEMPTS = 100 #%% tuning for SA curve_list = [] decays = [0.999, 0.99, 0.9] for d in decays: schedule = mlrose.GeomDecay(decay=d) _, _, curve = mlrose.simulated_annealing( problem, schedule=schedule, max_attempts=MAX_ATTEMPTS, max_iters=500, curve=True, random_state=RANDOM_SEED, ) curve_list.append(curve)
gen_times=[] gen_scores=[] mimic_times=[] mimic_scores=[] for i in range(10, 51, 10): if i==0: continue ex = {"weights": [random.randint(1, 20) for i in range(i)], "values": [random.randint(1, 10) for i in range(i)], "state": np.array([random.randint(0, 2) for i in range(i)])} input_sizes.append(i) weights = ex['weights'] values = ex['values'] state = ex['state'] max_weight_pct = 0.6 fitness = mlrose_hiive.Knapsack(weights, values, max_weight_pct) fitness.evaluate(state) problem = mlrose_hiive.DiscreteOpt(length = len(state), fitness_fn = fitness, maximize = True, max_val = int(max(state))+1) times = [] best_scores = [] start_time = time.time() best_state, best_fitness, fitness_curve = sa(problem,state, 30, 1000) elapsed_time = time.time() - start_time print(elapsed_time) times.append(elapsed_time*1000) best_scores.append(best_fitness) sa_times.append(elapsed_time*1000) sa_scores.append(best_fitness) plt.close() plot_data([i+1 for i in range(len(fitness_curve))], fitness_curve, title="Evaluations Required to Maximize Knapsack (Input Size = "+str(len(state))+")", x_label="Evaluations", y_label="Fitness Score", color="blue", label='Simulated annealing')
def runPart1(savePath): fitness = mlrose.FourPeaks(t_pct=0.15) init_state = None fourPeaksProblem = mlrose.DiscreteOpt(length=12, fitness_fn=fitness, maximize=True, max_val=2) part1_1 = Part1(name='Four Peaks', fitness=fitness, problem=fourPeaksProblem, init_state=init_state) part1_1.runAll(savePath) fitness = mlrose.Queens() init_state = None eightQueensProblem = mlrose.DiscreteOpt(length=8, fitness_fn=fitness, maximize=False, max_val=8) part1_2 = Part1(name='Eight Queens', fitness=fitness, problem=eightQueensProblem, init_state=init_state) part1_2.runAll(savePath) fitness = mlrose.SixPeaks(t_pct=0.15) init_state = None sixPeaksProblem = mlrose.DiscreteOpt(length=11, fitness_fn=fitness, maximize=True, max_val=2) part1_4 = Part1(name='Six Peaks', fitness=fitness, problem=sixPeaksProblem, init_state=init_state) part1_4.runAll(savePath) fitness = mlrose.FlipFlop() init_state = None flipFlopProblem = mlrose.DiscreteOpt(length=7, fitness_fn=fitness, maximize=True, max_val=2) part1_5 = Part1(name='Flip Flop - 7', fitness=fitness, problem=flipFlopProblem, init_state=init_state) part1_5.runAll(savePath) fitness = mlrose.FlipFlop() init_state = None flipFlopProblem = mlrose.DiscreteOpt(length=100, fitness_fn=fitness, maximize=True, max_val=2) part1_5 = Part1(name='Flip Flop - 100', fitness=fitness, problem=flipFlopProblem, init_state=init_state) part1_5.runAll(savePath) fitness = mlrose.Queens() init_state = None eightQueensProblem = mlrose.DiscreteOpt(length=80, fitness_fn=fitness, maximize=False, max_val=8) part1_2 = Part1(name='Eighty Queens', fitness=fitness, problem=eightQueensProblem, init_state=init_state) part1_2.runAll(savePath) fitness = mlrose.FlipFlop() init_state = None flipFlopProblem = mlrose.DiscreteOpt(length=15, fitness_fn=fitness, maximize=True, max_val=2) part1_5 = Part1(name='Flip Flop - 15', fitness=fitness, problem=flipFlopProblem, init_state=init_state) part1_5.runAll(savePath) edges = [(0, 1), (0, 2), (0, 4), (1, 3), (2, 0), (2, 3), (3, 4)] fitness = mlrose.MaxKColor(edges) init_state = None maxKColorsProblem = mlrose.DiscreteOpt(length=7, fitness_fn=fitness, maximize=False, max_val=2) part1_3 = Part1(name='Max-K Color', fitness=fitness, problem=maxKColorsProblem, init_state=init_state) part1_3.runAll(savePath) # ============================================================= # Source - Tutorial from MLRose Docs # https://mlrose.readthedocs.io/en/stable/source/tutorial2.html # # ============================================================= # Create list of city coordinates coords_list = [(1, 1), (4, 2), (5, 2), (6, 4), (4, 4), (3, 6), (1, 5), (2, 3)] # Initialize fitness function object using coords_list fitness_coords = mlrose.TravellingSales(coords = coords_list) # Create list of distances between pairs of cities dist_list = [(0, 1, 3.1623), (0, 2, 4.1231), (0, 3, 5.8310), (0, 4, 4.2426), \ (0, 5, 5.3852), (0, 6, 4.0000), (0, 7, 2.2361), (1, 2, 1.0000), \ (1, 3, 2.8284), (1, 4, 2.0000), (1, 5, 4.1231), (1, 6, 4.2426), \ (1, 7, 2.2361), (2, 3, 2.2361), (2, 4, 2.2361), (2, 5, 4.4721), \ (2, 6, 5.0000), (2, 7, 3.1623), (3, 4, 2.0000), (3, 5, 3.6056), \ (3, 6, 5.0990), (3, 7, 4.1231), (4, 5, 2.2361), (4, 6, 3.1623), \ (4, 7, 2.2361), (5, 6, 2.2361), (5, 7, 3.1623), (6, 7, 2.2361)] # Initialize fitness function object using dist_list fitness_dists = mlrose.TravellingSales(distances = dist_list) # Define optimization problem object problem_fit = mlrose.TSPOpt(length = 8, fitness_fn = fitness_coords, maximize=False) coords_list = [(1, 1), (4, 2), (5, 2), (6, 4), (4, 4), (3, 6), (1, 5), (2, 3)] # Define optimization problem object problem_no_fit = mlrose.TSPOpt(length = 8, coords = coords_list, maximize=False) part1_6 = Part1(name='TSP', fitness=coords_list, problem=problem_no_fit, init_state=None) part1_6.runAll(savePath) # Knapsack weights = np.random.randint(2, high=20, size=50) values = np.random.randint(2, high=100, size=50) max_weight_pct = 0.8 fitness = mlrose.Knapsack(weights, values, max_weight_pct) knapsackProblem = mlrose.DiscreteOpt(length=50, fitness_fn=fitness, maximize=False, max_val=2) part1_7 = Part1(name='Knapsack', fitness=fitness, problem=knapsackProblem, init_state=None) part1_7.runAll(savePath)
#K color #TODO make Australia map N_K = 1 base_edges = [(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (2, 5), (3, 4), (4, 5)] #Australia edges = [] for au_idx in range(N_K): for edge in base_edges: edge = (edge[0] + 5 * au_idx, edge[1] + 5 * au_idx) edges.append(edge) fitness_k = mlrose_hiive.MaxKColor(edges) # init_state = np.array([0, 1, 0, 1, 1]) K_problem = mlrose_hiive.DiscreteOpt(length=max(max(edges)) + 1, fitness_fn=fitness_k, maximize=False, max_val=3) fitness_k.evaluate(K_problem.state) # Define decay schedule (sim annealing only) schedule = mlrose_hiive.ExpDecay() #8-Queens fitness_Q = mlrose_hiive.Queens() N_Q = 8 #OPti_object # Q_problem = mlrose_hiive.DiscreteOpt(length = 8, fitness_fn = fitness_Q, maximize=False, max_val=8) # timeit.timeit(fitness_Q.evaluate(Q_rand_state), number=100000)