def get_fitness_function(problem_type): fitness, problem = None, None if problem_type == Problem.KNAPSACK: fitness = mlrose.Knapsack(weights=[ 70, 73, 77, 80, 82, 87, 90, 94, 98, 106, 110, 113, 115, 118, 120 ], values=[ 1.35, 1.39, 1.49, 1.50, 1.56, 1.63, 1.73, 1.84, 1.92, 2.01, 2.10, 2.14, 2.21, 2.29, 2.40 ], max_weight_pct=0.52) problem = mlrose.DiscreteOpt(length=15, fitness_fn=fitness, maximize=True, max_val=2) elif problem_type == Problem.NQUEEN: fitness = mlrose.Queens() problem = mlrose.DiscreteOpt(length=8, fitness_fn=fitness, maximize=False, max_val=8) elif problem_type == Problem.FOUR_PEAKS: fitness = mlrose.FourPeaks(t_pct=0.15) problem = mlrose.DiscreteOpt(length=100, fitness_fn=fitness, maximize=True, max_val=2) return fitness, problem
def get_fitness_functions(): df = pd.read_csv("./houston2008_order.csv") coord_list = list(df[['lat', 'long']].apply(tuple, axis=1)) coord_list = coord_list[0:30] fitness_tsp = mlrose.TravellingSales(coords=coord_list) problem_tsp = mlrose.TSPOpt(length=len(coord_list), fitness_fn=fitness_tsp, maximize=False) fitness_fourpeak = mlrose.FourPeaks(t_pct=.3) problem_fourpeak = mlrose.DiscreteOpt(length=20, fitness_fn=fitness_fourpeak) fitness_flipflop = mlrose.FlipFlop() problem_flipflop = mlrose.DiscreteOpt(length=30, fitness_fn=fitness_flipflop) fitness_one_max = mlrose.OneMax() problem_one_max = mlrose.DiscreteOpt( length=35, fitness_fn=fitness_one_max, ) weights = [10, 5, 2, 8, 15] values = [1, 2, 3, 4, 5] max_weight_pct = 0.6 fitness_knapsack = mlrose.Knapsack(weights, values, max_weight_pct) problem_knapsack = mlrose.DiscreteOpt(length=5, fitness_fn=fitness_knapsack) return { "tsp": problem_tsp, "four_peaks": problem_fourpeak, "one_max": problem_one_max, }
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 init_optis(self, K=False): self.Q_rand_state = np.random.randint(0, self.N_Q + 1, self.N_Q) self.fitness_Q = mlrose_hiive.Queens() self.P_rand_state = np.random.randint(0, 2, self.N_P) self.fitness_P = mlrose_hiive.FourPeaks(t_pct=0.15) self.eval_cnt = 1 if K: 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) self.K_rand_state = np.random.randint(0, 4, max(max(edges)) + 1) self.fitness_K = mlrose_hiive.MaxKColor(edges)
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 get_optimal_values(name, n): if name == "queens": return np.arange(n).sum() elif name == "four_peaks": fitness = mlrose.FourPeaks() state = np.zeros(n, dtype=int) t = int(np.ceil(fitness.t_pct * n)) state[0:t + 1] = 1 return fitness.evaluate(state) elif name == "flip_flop": return n - 1 elif name == "six_peaks": fitness = mlrose.SixPeaks() state = np.zeros(n, dtype=int) t = int(np.ceil(fitness.t_pct * n)) state[0:t + 1] = 1 return fitness.evaluate(state) else: raise Exception("Invalid Problem Name!")
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 fitness_counter(state): global eval_count fitness = mlrose.FourPeaks(t_pct=0.25) eval_count += 1 return fitness.evaluate(state)
def four_peaks(): print('Four Peaks') 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(100) fitness = mlr.FourPeaks(0.15) 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, 1000) rhc.append((best_fitness, fitness_curve, time)) best_state, best_fitness, fitness_curve, time = simulated_annealing( problem, state, 100, 1000) sa.append((best_fitness, fitness_curve, time)) best_state, best_fitness, fitness_curve, time = genetic_algorithm( problem, state, 100, 1000) ga.append((best_fitness, fitness_curve, time)) best_state, best_fitness, fitness_curve, time = mimic( problem, state, 100, 1000) mim.append((best_fitness, fitness_curve, time)) plot_data([i + 1 for i in range(len(rhc[0][1]))], rhc[0][1], title="FourPeaks (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="FourPeaks (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="FourPeaks (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="FourPeaks (Input Size = " + str(len(state)) + ")", x_label="Iterations", y_label="Fitness Score", color="red", label='MIMIC') title = 'Four Peaks' plt.savefig('output/' + title + '.png') plt.close()
plt.figure() plt.xlabel(x) 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()
def main(task): if 'tune_problem' in task: # FOUR PEAKS GOOD FOR GENETIC # Tune Four Peaks problem t_pct_list = np.arange(0.1, 1, 0.05) problem_size = 50 four_peaks_tuning_fitness = [] four_peaks_tuning_time = [] four_peaks_tuning_fevals = [] for t_pct in t_pct_list: fitness = mlrose.FourPeaks(t_pct=t_pct) problem = mlrose.DiscreteOpt(problem_size, fitness, maximize=True, max_val=2) experiment_name = 'four_peaks_tuning_t_pct_' + str(t_pct) population_sizes_list = 200, mutation_rates_list = np.arange(0.1, 1, 0.1) ga = runners.GARunner(problem=problem, experiment_name=experiment_name, output_directory='k_colors', seed=27, iteration_list=[5000], population_sizes=population_sizes_list, mutation_rates=mutation_rates_list, max_attempts=250) # the two data frames will contain the results ga_run_stats, ga_run_curves = ga.run() four_peaks_tuning_fitness.append(ga_run_curves.loc[ ga_run_curves['Fitness'].idxmax()]['Fitness']) four_peaks_tuning_time.append( ga_run_curves.loc[ga_run_curves['Time'].idxmax()]['Time']) four_peaks_tuning_fevals.append( population_sizes_list[0] * ga_run_curves.loc[ ga_run_curves['Iteration'].idxmax()]['Iteration']) plt.rc("font", size=8) plt.rc("axes", titlesize=14) plt.rc("axes", labelsize=10) plt.rc("xtick", labelsize=8) plt.rc("ytick", labelsize=8) plt.rc("legend", fontsize=11) plt.rc("figure", titlesize=11) #fig, ax = plt.subplots(2, 1, dpi=100, sharex=True, figsize=(5,4)) fig, ax = plt.subplots(1, 3, figsize=(10, 3.5)) fig.suptitle('Four Peaks Tuning w/ Genetic Algorithm Optimizer') ax[0].scatter(t_pct_list, four_peaks_tuning_fitness, c='r', marker='x', s=10) ax[0].set(xlabel='Threshold Parameter', ylabel='Max Fitness') ax[1].scatter(t_pct_list, four_peaks_tuning_time, c='g', marker='o', s=10) ax[1].set(xlabel='Threshold Parameter', ylabel='Max Runtime (s)') ax[2].scatter(t_pct_list, four_peaks_tuning_fevals, c='b', marker='+') ax[2].set(xlabel='Threshold Parameter', ylabel='Max Function Evaluations') ax[2].yaxis.tick_right() plt.show() return if 'tuning_plots' in task: # Tune Algorithms problem_size = 50 # Four Peaks four_peaks_fitness = mlrose.FourPeaks(t_pct=0.25) problem = mlrose.DiscreteOpt(problem_size, four_peaks_fitness, maximize=True, max_val=2) problem_size = 50 rhc_fitness_tuning_list = [] rhc_param_tuning_list = [] time_tuning_list = [] rhc_feval_tuning_list = [] asdf_list = [] fdsa_list = [] experiment_name = 'rhc_four_peaks_tuning_size_' + str(problem_size) #restart_list = [5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95, 100] restart_list = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100] rhc = runners.RHCRunner(problem=problem, experiment_name=experiment_name, output_directory='four_peaks', seed=27, iteration_list=[5000], max_attempts=50, restart_list=restart_list) # the two data frames will contain the results rhc_run_stats, rhc_run_curves = rhc.run() for restart in restart_list: this_temp_df = rhc_run_curves.loc[rhc_run_curves['Restarts'] == restart] this_temp_df[ 'Iteration'] = this_temp_df['Iteration'] - this_temp_df.loc[ this_temp_df['Iteration'].idxmin()]['Iteration'] + 1 rhc_fitness_tuning_list.append( this_temp_df.loc[this_temp_df['Fitness'].idxmax()]['Fitness']) rhc_param_tuning_list.append(restart) rhc_feval_tuning_list.append(3 * this_temp_df.loc[ this_temp_df['Iteration'].idxmax()]['Iteration']) time_tuning_list.append( this_temp_df.loc[this_temp_df['Time'].idxmax()]['Time']) asdf_list.append(this_temp_df['Fitness']) fdsa_list.append(this_temp_df['Iteration']) # plt.rc("font", size=8) # plt.rc("axes", titlesize=12) # plt.rc("axes", labelsize=10) # plt.rc("xtick", labelsize=8) # plt.rc("ytick", labelsize=8) # plt.rc("legend", fontsize=8) # plt.rc("figure", titlesize=11) # #fig, ax = plt.subplots(2, 1, dpi=100, sharex=True, figsize=(5,4)) # fig, ax = plt.subplots(1,3,figsize=(12,3.5)) # fig.suptitle('RHC Restarts Tuning, problem_size = ' + str(problem_size)) # ax[0].scatter(param_tuning_list, time_tuning_list, c='r', marker='x', s=10) # ax[0].set(xlabel='Restarts', ylabel = 'Time') # ax[1].scatter(param_tuning_list, fitness_tuning_list, c='g', marker='o', s=10) # ax[1].set(xlabel='Restarts', ylabel = 'Fitness') # ax[2].scatter(param_tuning_list, feval_tuning_list, c='g', marker='o', s=10) # ax[2].set(xlabel='Restarts', ylabel = 'Function Evaluations') # ax[2].yaxis.tick_right() # plt.show() # fig, ax = plt.subplots() # ax.scatter(fdsa_list[7], asdf_list[7]) # ax.set(xlabel='Iteration', ylabel = 'Fitness') # plt.show() # problem_size = 50 sa_fitness_tuning_list = [] sa_param_tuning_list = [] time_tuning_list = [] sa_feval_tuning_list = [] asdf_list = [] fdsa_list = [] experiment_name = 'sa_four_peaks_tuning_size_' + str(problem_size) temperature_list = np.arange(1, 50, 0.5) sa = runners.SARunner(problem=problem, experiment_name=experiment_name, output_directory='four_peaks', seed=27, iteration_list=[1000], max_attempts=100, temperature_list=temperature_list) #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() df_run_curves['Temperature'] = pd.to_numeric( df_run_curves['Temperature'].astype(str).astype(float)) for temp in temperature_list: this_temp_df = df_run_curves.loc[df_run_curves['Temperature'] == temp] this_temp_df[ 'Iteration'] = this_temp_df['Iteration'] - this_temp_df.loc[ this_temp_df['Iteration'].idxmin()]['Iteration'] + 1 sa_fitness_tuning_list.append( this_temp_df.loc[this_temp_df['Fitness'].idxmax()]['Fitness']) sa_param_tuning_list.append(temp) sa_feval_tuning_list.append(2 * this_temp_df.loc[ this_temp_df['Iteration'].idxmax()]['Iteration']) time_tuning_list.append( this_temp_df.loc[this_temp_df['Time'].idxmax()]['Time']) asdf_list.append(this_temp_df['Fitness']) fdsa_list.append(this_temp_df['Iteration']) # plt.rc("font", size=8) # plt.rc("axes", titlesize=12) # plt.rc("axes", labelsize=10) # plt.rc("xtick", labelsize=8) # plt.rc("ytick", labelsize=8) # plt.rc("legend", fontsize=8) # plt.rc("figure", titlesize=11) # #fig, ax = plt.subplots(2, 1, dpi=100, sharex=True, figsize=(5,4)) # fig, ax = plt.subplots(1,3,figsize=(12,3.5)) # fig.suptitle('SA Temperature Tuning, problem_size = ' + str(problem_size)) # ax[0].scatter(param_tuning_list, time_tuning_list, c='r', marker='x', s=10) # ax[0].set(xlabel='Temperature', ylabel = 'Time') # ax[1].scatter(param_tuning_list, fitness_tuning_list, c='g', marker='o', s=10) # ax[1].set(xlabel='Temperature', ylabel = 'Fitness') # ax[2].scatter(param_tuning_list, feval_tuning_list, c='g', marker='o', s=10) # ax[2].set(xlabel='Temperature', ylabel = 'Function Evaluations') # ax[2].yaxis.tick_right() # plt.show() # fig, ax = plt.subplots() # ax.scatter(fdsa_list[17], asdf_list[17]) # ax.set(xlabel='Iteration', ylabel = 'Fitness') # plt.show() # fitness_tuning_list = [] # param_tuning_list = [] # time_tuning_list = [] # feval_tuning_list = [] # asdf_list = [] # fdsa_list = [] # experiment_name = 'ga_four_peaks_tuning_size_' + str(problem_size) # population_sizes_list=300, # mutation_rates_list=np.arange(0.05, 1.0, 0.05) # ga = runners.GARunner(problem=problem, # experiment_name=experiment_name, # output_directory='four_peaks', # seed=27, # iteration_list=[5000], # population_sizes=population_sizes_list, # mutation_rates=mutation_rates_list, # max_attempts=100) # # the two data frames will contain the results # df_run_stats, df_run_curves = ga.run() # for rate in mutation_rates_list: # this_temp_df = df_run_curves.loc[df_run_curves['Mutation Rate'] == rate] # this_temp_df['Iteration'] = this_temp_df['Iteration'] - this_temp_df.loc[this_temp_df['Iteration'].idxmin()]['Iteration'] + 1 # fitness_tuning_list.append(this_temp_df.loc[this_temp_df['Fitness'].idxmax()]['Fitness']) # param_tuning_list.append(rate) # feval_tuning_list.append(population_sizes_list[0] * this_temp_df.loc[this_temp_df['Iteration'].idxmax()]['Iteration']) # time_tuning_list.append(this_temp_df.loc[this_temp_df['Time'].idxmax()]['Time']) # asdf_list.append(this_temp_df['Fitness']) # fdsa_list.append(this_temp_df['Iteration']) # print(time_tuning_list) # plt.rc("font", size=8) # plt.rc("axes", titlesize=12) # plt.rc("axes", labelsize=10) # plt.rc("xtick", labelsize=8) # plt.rc("ytick", labelsize=8) # plt.rc("legend", fontsize=8) # plt.rc("figure", titlesize=11) # #fig, ax = plt.subplots(2, 1, dpi=100, sharex=True, figsize=(5,4)) # fig, ax = plt.subplots(1,3,figsize=(12,3.5)) # fig.suptitle('GA Mutation Rate Tuning, problem_size = ' + str(problem_size)) # ax[0].scatter(param_tuning_list, time_tuning_list, c='r', marker='x', s=10) # ax[0].set(xlabel='Mutation Rate', ylabel = 'Time (s)') # ax[1].scatter(param_tuning_list, fitness_tuning_list, c='g', marker='o', s=10) # ax[1].set(xlabel='Mutation Rate', ylabel = 'Fitness') # ax[2].scatter(param_tuning_list, feval_tuning_list, c='g', marker='o', s=10) # ax[2].set(xlabel='Mutation Rate', ylabel = 'Function Evaluations') # ax[2].yaxis.tick_right() # plt.show() # fig, ax = plt.subplots() # ax.scatter(fdsa_list[17], asdf_list[17]) # ax.set(xlabel='Iteration', ylabel = 'Fitness') # plt.show() # Tune population size ga_population_tuning_fitness = [] ga_population_tuning_time = [] ga_population_tuning_feval = [] population_sizes_list = np.arange(10, 500, 10) for population_size in population_sizes_list: experiment_name = 'ga_four_peaks_tuning_population_size_' + str( problem_size) mutation_rates_list = [0.15] ga = runners.GARunner(problem=problem, experiment_name=experiment_name, output_directory='four_peaks', seed=27, iteration_list=[5000], population_sizes=[int(population_size)], mutation_rates=mutation_rates_list, max_attempts=50) # the two data frames will contain the results ga_run_stats, ga_run_curves = ga.run() ga_population_tuning_fitness.append(ga_run_curves.loc[ ga_run_curves['Fitness'].idxmax()]['Fitness']) ga_population_tuning_time.append( ga_run_curves.loc[ga_run_curves['Time'].idxmax()]['Time']) ga_population_tuning_feval.append( population_size * ga_run_curves.loc[ ga_run_curves['Iteration'].idxmax()]['Iteration']) # plt.rc("font", size=8) # plt.rc("axes", titlesize=12) # plt.rc("axes", labelsize=10) # plt.rc("xtick", labelsize=8) # plt.rc("ytick", labelsize=8) # plt.rc("legend", fontsize=8) # plt.rc("figure", titlesize=11) # #fig, ax = plt.subplots(2, 1, dpi=100, sharex=True, figsize=(5,4)) # fig, ax = plt.subplots(1,3,figsize=(12,3.5)) # fig.suptitle('GA Population Size Tuning, problem_size = ' + str(problem_size)) # ax[0].scatter(population_sizes_list, ga_population_tuning_time, c='r', marker='x', s=10) # ax[0].set(xlabel='Population Size', ylabel = 'Time') # ax[1].scatter(population_sizes_list, ga_population_tuning_fitness, c='g', marker='x', s=10) # ax[1].set(xlabel='Population Size', ylabel = 'Fitness') # ax[2].scatter(param_tuning_list, ga_population_tuning_feval, c='g', marker='o', s=10) # ax[2].set(xlabel='Population Size', ylabel = 'Function Evaluations') # ax[2].yaxis.tick_right() # plt.show() # fitness_tuning_list = [] # param_tuning_list = [] # time_tuning_list = [] # feval_tuning_list - [] # asdf_list = [] # fdsa_list = [] # experiment_name = 'mimic_four_peaks_tuning_size_' + str(problem_size) # population_sizes_list=280, # keep_percent_list=np.arange(0.05, 1.0, 0.05) # mimic = runners.MIMICRunner(problem=problem, # experiment_name=experiment_name, # output_directory='four_peaks', # seed=27, # iteration_list=[100], # population_sizes=population_sizes_list, # keep_percent_list=keep_percent_list, # max_attempts=10) # # the two data frames will contain the results # df_run_stats, df_run_curves = mimic.run() # # print(df_run_curves.dtypes) # # print(df_run_curves) # # #df_run_curves['Temperature'] = pd.to_numeric(df_run_curves['Temperature'].astype(str).astype(float)) # # print(df_run_curves) # for percent in keep_percent_list: # this_temp_df = df_run_curves.loc[df_run_curves['Keep Percent'] == percent] # this_temp_df['Iteration'] = this_temp_df['Iteration'] - this_temp_df.loc[this_temp_df['Iteration'].idxmin()]['Iteration'] + 1 # fitness_tuning_list.append(this_temp_df.loc[this_temp_df['Fitness'].idxmax()]['Fitness']) # param_tuning_list.append(percent) # feval_tuning_list.append(population_sizes_list[0] * this_temp_df.loc[this_temp_df['Iteration'].idxmax()]['Iteration']) # time_tuning_list.append(this_temp_df.loc[this_temp_df['Time'].idxmax()]['Time']) # asdf_list.append(this_temp_df['Fitness']) # fdsa_list.append(this_temp_df['Iteration']) # plt.rc("font", size=8) # plt.rc("axes", titlesize=12) # plt.rc("axes", labelsize=10) # plt.rc("xtick", labelsize=8) # plt.rc("ytick", labelsize=8) # plt.rc("legend", fontsize=8) # plt.rc("figure", titlesize=11) # #fig, ax = plt.subplots(2, 1, dpi=100, sharex=True, figsize=(5,4)) # fig, ax = plt.subplots(1,3,figsize=(12,3.5)) # fig.suptitle('MIMIC Keep Percent Tuning, problem_size = ' + str(problem_size)) # ax[0].scatter(param_tuning_list, time_tuning_list, c='r', marker='x', s=10) # ax[0].set(xlabel='Keep Percent (decimal)', ylabel = 'Time (s)') # ax[1].scatter(param_tuning_list, fitness_tuning_list, c='g', marker='o', s=10) # ax[1].set(xlabel='Keep Percent (decimal)', ylabel = 'Fitness') # ax[2].scatter(param_tuning_list, feval_tuning_list, c='g', marker='o', s=10) # ax[2].set(xlabel='Keep Percent (decimal)', ylabel = 'Function Evaluations') # ax[2].yaxis.tick_right() # plt.show() # fig, ax = plt.subplots() # ax.scatter(fdsa_list[17], asdf_list[17]) # ax.set(xlabel='Iteration', ylabel = 'Fitness') # plt.show() # Tune population size mimic_population_tuning_fitness = [] mimic_population_tuning_time = [] mimic_population_tuning_feval = [] population_sizes_list = np.arange(10, 500, 10) for population_size in population_sizes_list: experiment_name = 'mimic_four_peaks_tuning_population_size_' + str( problem_size) keep_percent_list = [0.25] mimic = runners.MIMICRunner( problem=problem, experiment_name=experiment_name, output_directory='four_peaks', seed=27, iteration_list=[100], population_sizes=[int(population_size)], keep_percent_list=keep_percent_list, max_attempts=5, use_fast_mimic=True) # the two data frames will contain the results mimic_run_stats, mimic_run_curves = mimic.run() mimic_population_tuning_fitness.append(mimic_run_curves.loc[ mimic_run_curves['Fitness'].idxmax()]['Fitness']) mimic_population_tuning_time.append(mimic_run_curves.loc[ mimic_run_curves['Time'].idxmax()]['Time']) mimic_population_tuning_feval.append( population_size * mimic_run_curves.loc[ mimic_run_curves['Iteration'].idxmax()]['Iteration']) plt.rc("font", size=8) plt.rc("axes", titlesize=14) plt.rc("axes", labelsize=10) plt.rc("xtick", labelsize=8) plt.rc("ytick", labelsize=8) plt.rc("legend", fontsize=11) plt.rc("figure", titlesize=11) fig, ax = plt.subplots(2, 4, figsize=(12, 7)) fig.suptitle('Four Peaks Algorithm Tuning, problem size = ' + str(problem_size)) ax[0, 0].scatter(rhc_param_tuning_list, rhc_fitness_tuning_list, c='r', marker='x', s=10) ax[0, 0].set(xlabel='Restarts', ylabel='Fitness', title='RHC Restarts') ax[0, 1].scatter(sa_param_tuning_list, sa_fitness_tuning_list, c='g', marker='o', s=10) ax[0, 1].set(xlabel='Temperature', title='SA Temperature') ax[0, 2].scatter(population_sizes_list, ga_population_tuning_fitness, c='g', marker='o', s=10) ax[0, 2].set(xlabel='Population Size', title='GA Population Size') ax[0, 2].yaxis.tick_right() ax[0, 3].scatter(population_sizes_list, mimic_population_tuning_fitness, c='g', marker='o', s=10) ax[0, 3].set(xlabel='Population Size', title='MIMIC Population Size') ax[0, 3].yaxis.tick_right() ax[1, 0].scatter(rhc_param_tuning_list, rhc_feval_tuning_list, c='r', marker='x', s=10) ax[1, 0].set(xlabel='Restarts', ylabel='Function Evaluations') ax[1, 1].scatter(sa_param_tuning_list, sa_feval_tuning_list, c='g', marker='o', s=10) ax[1, 1].set(xlabel='Temperature') ax[1, 2].scatter(population_sizes_list, ga_population_tuning_feval, c='g', marker='o', s=10) ax[1, 2].set(xlabel='Population Size') ax[1, 2].yaxis.tick_right() ax[1, 3].scatter(population_sizes_list, mimic_population_tuning_feval, c='g', marker='o', s=10) ax[1, 3].set(xlabel='Population Size') ax[1, 3].yaxis.tick_right() plt.show() if 'complexity_graph' in task: problem_size_list = np.arange(5, 85, 5) sa_time_list = [] sa_fitness_list = [] sa_feval_list = [] rhc_time_list = [] rhc_fitness_list = [] rhc_feval_list = [] ga_time_list = [] ga_fitness_list = [] ga_feval_list = [] mimic_time_list = [] mimic_fitness_list = [] mimic_feval_list = [] for problem_size in problem_size_list: # Four Peaks four_peaks_fitness = mlrose.FourPeaks(t_pct=0.15) best_fitness_list = [] problem = mlrose.DiscreteOpt(int(problem_size), four_peaks_fitness, maximize=True, max_val=2) # RHC experiment_name = 'rhc_four_peaks_complexity_size_' + str( problem_size) restart_list = [50] rhc = runners.RHCRunner(problem=problem, experiment_name=experiment_name, output_directory='four_peaks', seed=27, iteration_list=[5000], max_attempts=50, restart_list=restart_list) # the two data frames will contain the results rhc_run_stats, rhc_run_curves = rhc.run() rhc_time = rhc_run_curves['Time'] rhc_fitness = rhc_run_curves['Fitness'] rhc_iteration = rhc_run_curves['Iteration'] rhc_fitness_list.append(rhc_run_curves.loc[ rhc_run_curves['Fitness'].idxmax()]['Fitness']) rhc_time_list.append( rhc_run_curves.loc[rhc_run_curves['Time'].idxmax()]['Time']) rhc_feval_list.append(3 * rhc_run_curves.loc[ rhc_run_curves['Iteration'].idxmax()]['Iteration']) # SA experiment_name = 'sa_four_peaks_complexity_size_' + str( problem_size) temperature_list = [4] sa = runners.SARunner(problem=problem, experiment_name=experiment_name, output_directory='four_peaks', seed=27, iteration_list=[10000], max_attempts=500, temperature_list=temperature_list) # the two data frames will contain the results sa_run_stats, sa_run_curves = sa.run() # print(sa_run_curves.dtypes) # print(sa_run_curves) sa_run_curves['Temperature'] = pd.to_numeric( sa_run_curves['Temperature'].astype(str).astype(float)) # print(df_run_curves) sa_time = sa_run_curves['Time'] sa_fitness = sa_run_curves['Fitness'] sa_iteration = sa_run_curves['Iteration'] sa_fitness_list.append(sa_run_curves.loc[ sa_run_curves['Fitness'].idxmax()]['Fitness']) sa_time_list.append( sa_run_curves.loc[sa_run_curves['Time'].idxmax()]['Time']) sa_feval_list.append(2 * sa_run_curves.loc[ sa_run_curves['Iteration'].idxmax()]['Iteration']) # GA experiment_name = 'ga_four_peaks_complexity_size_' + str( problem_size) population_sizes_list = 200, mutation_rates_list = [0.2] ga = runners.GARunner(problem=problem, experiment_name=experiment_name, output_directory='four_peaks', seed=27, iteration_list=[1000], population_sizes=population_sizes_list, mutation_rates=mutation_rates_list, max_attempts=100) # the two data frames will contain the results ga_run_stats, ga_run_curves = ga.run() # print(ga_run_curves.dtypes) # print(ga_run_curves) # print(df_run_curves) ga_time = ga_run_curves['Time'] ga_fitness = ga_run_curves['Fitness'] ga_iteration = ga_run_curves['Iteration'] ga_fitness_list.append(ga_run_curves.loc[ ga_run_curves['Fitness'].idxmax()]['Fitness']) ga_time_list.append( ga_run_curves.loc[ga_run_curves['Time'].idxmax()]['Time']) ga_feval_list.append(population_sizes_list[0] * ga_run_curves.loc[ ga_run_curves['Iteration'].idxmax()]['Iteration']) # MIMC experiment_name = 'mimic_four_peaks_complexity_size_' + str( problem_size) population_sizes_list = 370, keep_percent_list = [0.35] mimic = runners.MIMICRunner(problem=problem, experiment_name=experiment_name, output_directory='four_peaks', seed=27, iteration_list=[100], population_sizes=population_sizes_list, keep_percent_list=keep_percent_list, max_attempts=10, use_fast_mimic=True) # the two data frames will contain the results mimic_run_stats, mimic_run_curves = mimic.run() # print(mimic_run_curves.dtypes) # print(mimic_run_curves) # print(df_run_curves) mimic_time = mimic_run_curves['Time'] mimic_fitness = mimic_run_curves['Fitness'] mimic_iteration = mimic_run_curves['Iteration'] mimic_fitness_list.append(mimic_run_curves.loc[ mimic_run_curves['Fitness'].idxmax()]['Fitness']) mimic_time_list.append(mimic_run_curves.loc[ mimic_run_curves['Time'].idxmax()]['Time']) mimic_feval_list.append( population_sizes_list[0] * mimic_run_curves.loc[ mimic_run_curves['Iteration'].idxmax()]['Iteration']) plt.rc("font", size=8) plt.rc("axes", titlesize=12) plt.rc("axes", labelsize=10) plt.rc("xtick", labelsize=8) plt.rc("ytick", labelsize=8) plt.rc("legend", fontsize=8) plt.rc("figure", titlesize=11) #fig, ax = plt.subplots(2, 1, dpi=100, sharex=True, figsize=(5,4)) fig, ax = plt.subplots(1, 3, figsize=(12, 3.5)) fig.suptitle('Four Peaks Complexity Analysis', fontsize=14) # ax[0].plot(problem_size_list, sa_fitness_list, 'b-', label='Simulated Annealing', linewidth=1) # ax[0].plot(problem_size_list, ga_fitness_list, 'g:', label='Genetic', linewidth=1) w = 1 ax[0].bar(problem_size_list - w, sa_fitness_list, width=w, color='blue', label='Simulated Annealing') ax[0].bar(problem_size_list, ga_fitness_list, width=w, color='green', label='Genetic') ax[0].bar(problem_size_list - 2 * w, rhc_fitness_list, width=w, color='red', label='Random Hill Climb') ax[0].bar(problem_size_list + w, mimic_fitness_list, width=w, color='orange', label='MIMIC') ax[0].set(xlabel='Four Peaks Size', ylabel='Fitness') ax[0].legend() ax[1].plot(problem_size_list, sa_time_list, 'b-', label='Simulated Annealing', linewidth=1) ax[1].plot(problem_size_list, ga_time_list, 'g:', label='Genetic', linewidth=1) ax[1].plot(problem_size_list, rhc_time_list, 'r--', label='Random Hill Climb', linewidth=1) ax[1].plot(problem_size_list, mimic_time_list, '-.', color='orange', label='MIMIC', linewidth=1) ax[1].set(xlabel='Four Peaks Size', ylabel='Time (s)') ax[1].legend() ax[2].plot(problem_size_list, sa_feval_list, 'b-', label='Simulated Annealing', linewidth=1) ax[2].plot(problem_size_list, ga_feval_list, 'g:', label='Genetic', linewidth=1) ax[2].plot(problem_size_list, rhc_feval_list, 'r--', label='Random Hill Climb', linewidth=1) ax[2].plot(problem_size_list, mimic_feval_list, '-.', color='orange', label='MIMIC', linewidth=1) ax[2].set(xlabel='Four Peaks Size', ylabel='Function Evaluations') ax[2].yaxis.tick_right() plt.show() if 'performance_graph' in task: problem_size = 80 # Four Peaks four_peaks_fitness = mlrose.FourPeaks(t_pct=0.15) best_fitness_list = [] problem = mlrose.DiscreteOpt(int(problem_size), four_peaks_fitness, maximize=True, max_val=2) # RHC experiment_name = 'rhc_four_peaks_performance_size_' + str( problem_size) restart_list = [50] rhc = runners.RHCRunner(problem=problem, experiment_name=experiment_name, output_directory='four_peaks', seed=27, iteration_list=[5000], max_attempts=50, restart_list=restart_list) # the two data frames will contain the results rhc_run_stats, rhc_run_curves = rhc.run() # print(rhc_run_curves.dtypes) # print(rhc_run_curves) # print(df_run_curves) rhc_time = rhc_run_curves['Time'] rhc_fitness = rhc_run_curves['Fitness'] rhc_iteration = rhc_run_curves['Iteration'] rhc_feval = rhc_run_curves['Iteration'] * 2 # SA experiment_name = 'sa_four_peaks_performance_size_' + str(problem_size) temperature_list = [4] sa = runners.SARunner(problem=problem, experiment_name=experiment_name, output_directory='four_peaks', seed=27, iteration_list=[10000], max_attempts=500, temperature_list=temperature_list) # the two data frames will contain the results sa_run_stats, sa_run_curves = sa.run() # print(sa_run_curves.dtypes) # print(sa_run_curves) sa_run_curves['Temperature'] = pd.to_numeric( sa_run_curves['Temperature'].astype(str).astype(float)) # print(df_run_curves) sa_time = sa_run_curves['Time'] sa_fitness = sa_run_curves['Fitness'] sa_iteration = sa_run_curves['Iteration'] sa_feval = sa_run_curves['Iteration'] * 2 # GA experiment_name = 'ga_four_peaks_performance_size_' + str(problem_size) population_sizes_list = 200, mutation_rates_list = [0.2] ga = runners.GARunner(problem=problem, experiment_name=experiment_name, output_directory='four_peaks', seed=27, iteration_list=[1000], population_sizes=population_sizes_list, mutation_rates=mutation_rates_list, max_attempts=50) # the two data frames will contain the results ga_run_stats, ga_run_curves = ga.run() # print(ga_run_curves.dtypes) # print(ga_run_curves) # print(df_run_curves) ga_time = ga_run_curves['Time'] ga_fitness = ga_run_curves['Fitness'] ga_iteration = ga_run_curves['Iteration'] ga_feval = ga_run_curves['Iteration'] * population_sizes_list # MIMC experiment_name = 'mimic_four_peaks_performance_size_' + str( problem_size) population_sizes_list = 370, keep_percent_list = [0.35] mimic = runners.MIMICRunner(problem=problem, experiment_name=experiment_name, output_directory='four_peaks', seed=27, iteration_list=[100], population_sizes=population_sizes_list, keep_percent_list=keep_percent_list, max_attempts=10, use_fast_mimic=True) # the two data frames will contain the results mimic_run_stats, mimic_run_curves = mimic.run() # print(mimic_run_curves.dtypes) # print(mimic_run_curves) # print(df_run_curves) mimic_time = mimic_run_curves['Time'] mimic_fitness = mimic_run_curves['Fitness'] mimic_iteration = mimic_run_curves['Iteration'] mimic_feval = mimic_run_curves['Iteration'] * population_sizes_list plt.rc("font", size=8) plt.rc("axes", titlesize=12) plt.rc("axes", labelsize=10) plt.rc("xtick", labelsize=8) plt.rc("ytick", labelsize=8) plt.rc("legend", fontsize=8) plt.rc("figure", titlesize=11) #fig, ax = plt.subplots(2, 1, dpi=100, sharex=True, figsize=(5,4)) fig, ax = plt.subplots(1, 3, figsize=(12, 3.5)) fig.suptitle( 'Four Peaks Algorithm Performance Analysis, problem size = ' + str(problem_size), fontsize=14) # ax[0].plot(problem_size_list, sa_fitness_list, 'b-', label='Simulated Annealing', linewidth=1) # ax[0].plot(problem_size_list, ga_fitness_list, 'g:', label='Genetic', linewidth=1) w = 1 ax[0].plot(rhc_iteration, rhc_fitness, 'r--', label='Random Hill Climb', linewidth=1) ax[0].plot(sa_iteration, sa_fitness, 'b:', label='Simulated Annealing', linewidth=1) ax[0].plot(ga_iteration, ga_fitness, 'g-', label='Genetic', linewidth=1) ax[0].plot(mimic_iteration, mimic_fitness, '-.', color='orange', label='MIMIC', linewidth=1) ax[0].set(xlabel='Iteration', ylabel='Fitness') ax[0].legend() #ax[0].set_title('Fitness vs. Iteration') ax[1].plot(rhc_time, rhc_fitness, 'r--', label='Random Hill Climb', linewidth=1) ax[1].plot(sa_time, sa_fitness, 'b:', label='Simulated Annealing', linewidth=1) ax[1].plot(ga_time, ga_fitness, 'g-', label='Genetic', linewidth=1) ax[1].plot(mimic_time, mimic_fitness, '-.', color='orange', label='MIMIC', linewidth=1) ax[1].set(xlabel='Time (s)') #ax[1].set_title('Fitness vs. Runtime') ax[2].plot(rhc_feval, rhc_fitness, 'r--', label='Random Hill Climb', linewidth=1) ax[2].plot(sa_feval, sa_fitness, 'b:', label='Simulated Annealing', linewidth=1) ax[2].plot(ga_feval, ga_fitness, 'g-', label='Genetic', linewidth=1) ax[2].plot(mimic_feval, mimic_fitness, '-.', color='orange', label='MIMIC', linewidth=1) ax[2].set(xlabel='Function Evaluations') plt.show() return
import mlrose_hiive import numpy as np import time from matplotlib import pyplot as plt #get time and randomize # 4 PEAKS N_P = 7 P_rand_state = np.random.randint(0, 2, N_P) fitness_P = mlrose_hiive.FourPeaks(t_pct=0.15) fitness_P.evaluate(P_rand_state) # P_problem = mlrose_hiive.DiscreteOpt(length = len(init_state), fitness_fn = fitness_P, maximize=True,max_val=2) #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)
import mlrose_hiive as mlrose_hiive import numpy as np import itertools import matplotlib.pyplot as plt fitness = mlrose_hiive.FourPeaks(t_pct=(2 / 7)) test_state = np.array([1, 1, 1, 0, 1, 0]) GM_1 = np.array([1, 1, 1, 0, 0, 0, 0]) GM_2 = np.array([0, 0, 0, 1, 1, 1, 1]) LM_1 = np.ones(7) LM_2 = np.zeros(7) #TODO finish this n = 7 #https://stackoverflow.com/questions/14931769/how-to-get-all-combination-of-n-binary-value state_space = np.array([list(i) for i in itertools.product([0, 1], repeat=n)]) fitness_space = np.array([fitness.evaluate(s) for s in state_space]) np.random.shuffle(fitness_space) plt.scatter(range(len(fitness_space)), fitness_space, s=2.5, color='black', marker='x') plt.title("Fitness Function\n State Space N = 7 T = 2", fontsize=20) plt.xlabel("State Space Vectors", fontsize=18) plt.ylabel("Fitness", fontsize=18) plt.xticks([], labels=None) plt.show() imarker = 1
def four_peaks(length=50): return mlrose.FourPeaks(), length * 2
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)
run_rh = (args.rh == 'y') run_mi = (args.mi == 'y') run_plots = (args.plot == 'y') vLength = 50 iterlist = [i for i in range(vLength * 2)] galist = [i for i in range(vLength * 2)] mimiciterlist = [i for i in range(int(vLength))] max_one = mlrose.OneMax() run_toy_data(max_one, vLength, "max_one", run_ga, run_sa, run_rh, run_mi, iterlist, galist, mimiciterlist) four_peaks = mlrose.FourPeaks(t_pct=.2) run_toy_data(four_peaks, vLength, "four_peaks", run_ga, run_sa, run_rh, run_mi, iterlist, galist, mimiciterlist) weights = [random.randint(5, 30) for i in range(vLength)] values = [random.randint(1, 5) for i in range(vLength)] max_weight_pct = 0.6 knapsack = mlrose.Knapsack(weights, values, max_weight_pct) run_toy_data(knapsack, vLength, "knapsack", run_ga, run_sa, run_rh, run_mi, iterlist, galist, mimiciterlist) if run_plots == True: plot_fitness_time("max_one", "Max Ones") plot_fitness_time("four_peaks", "Four Peaks") plot_fitness_time("knapsack", "Knapsack")
# Andrew Nowotarski # anowotarski3 # CS 7641 ML Spring 2020 # Assignment 2: Randomized Optimization # Packages for matrix manipulation. import mlrose_hiive as mlrose import numpy as np # Packages for metrics and plotting. import plotting fitness = mlrose.FourPeaks(t_pct=0.15) problem_fit = mlrose.DiscreteOpt(length=35, fitness_fn=fitness) # Solve the problem with genetic algorithm plotting.plot_optimization_problem_fitness(problem_fit, 100, 2, 'Four Peaks')
def run_FourPeaks(self, mode=None): fitness_fn = mlrose.FourPeaks(t_pct=0.15) self.run_complexity(fitness_fn, mode)
def path(state): if foo(state) > (2**(len(state) - 1)): return 100 return 0 def cf2(state): score = 0 for i in range(len(state)): score += (state[i] * (i + 1) % 7) return score FITNESS_FUNCS = { 'fourpeaks': mlrose.FourPeaks(), 'onemax': mlrose.OneMax(), # 'path': mlrose.CustomFitness(path, problem_type='discrete'), 'flipflop': mlrose.FlipFlop(), # 'cliffs': mlrose.CustomFitness(cf1, problem_type='discrete'), # 'cliffs': mlrose.CustomFitness(is_larger, problem_type='discrete'), # 'max2color': mlrose.MaxKColorGenerator.generate(seed=42, number_of_nodes=PROBLEM_LENGTH, max_colors=2), # 'mod': mlrose.CustomFitness(cf2, problem_type='discrete') } RANDOM_STATE = 42 DEFAULTS = {'random_state': RANDOM_STATE, 'curve': True, 'max_attempts': 10} ALGORITHMS = { 'rhc': lambda p: mlrose.random_hill_climb(p, **DEFAULTS), 'sa': lambda p: mlrose.simulated_annealing(p, **DEFAULTS),
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
from timeit import default_timer as timer import pandas import mlrose_hiive PROBLEM_NAME = 'four_peaks' STATS_FOLDER = 'stats' eval_count = 0 orig_fitness_func = mlrose_hiive.FourPeaks(t_pct=0.15) SIZE_VALUES = [5, 10, 20, 50] def fitness_func(state): global eval_count eval_count += 1 return orig_fitness_func.evaluate(state) def get_problem(size=50): fitness = mlrose_hiive.CustomFitness(fitness_func) problem = mlrose_hiive.DiscreteOpt(length=size, fitness_fn=fitness, maximize=True) return problem def rhc_optimization(size): algo = 'rhc' problem = get_problem(size) # Gridsearch params max_iters = 500