def compare_methods(num_char): global count count=0 fitness_obj=mlrose.CustomFitness(heter_string_fn) opt=mlrose.DiscreteOpt(num_char,fitness_obj,maximize=True,max_val=num_char) best_state_climb,best_fitness_climb,fitness_curve_climb=mlrose.random_hill_climb(opt,curve=True) print('---------------------random hill climb-------------------------') print('hill climbing best state for heter-string problem:',best_state_climb) print('hill climbing best fitness for heter-string problem:',best_fitness_climb) print('hill climbing fitting curve for heter-string problem:',fitness_curve_climb) print('number of fitness call used:',count) count=0 print('-------------------simulated annealing-------------------------') best_state_ann,best_fitness_ann,fitness_curve_ann=mlrose.simulated_annealing(opt,schedule=mlrose.ExpDecay(),curve=True) print('simulated annealing best state for heter-string problem:',best_state_ann) print('simulated annealing best fitness for heter-string problem:',best_fitness_ann) print('simulated annealing fitting curve for heter-string problem:',fitness_curve_ann) print('number of fitness call used:',count) count=0 best_state_ga,best_fitness_ga,fitness_curve_ga=mlrose.genetic_alg(opt,pop_size=200, mutation_prob=0.5,curve=True) print('---------------------genetic alg----------------------------') print('genetic algorithm best state for heter-string problem:',best_state_ga) print('genetic algorithm best fitnees for heter-string problem:',best_fitness_ga) print('genetic algorithm fitness curve for heter-string problem:',fitness_curve_ga) print('number of fitness call used:',count) count=0 best_state_mimic,best_fitness_mimic,fitness_curve_mimic=mlrose.mimic(opt,pop_size=200,curve=True) print('------------------------mimic-------------------------------') print('mimic best state for heter-string problem:',best_state_mimic) print('mimic best fitness value for heter-string problem:',best_fitness_mimic) print('mimic curve for heter-string problem:',fitness_curve_mimic) print('number of fitness call used:',count) count=0 plt.figure(figsize=(10,10)) plt.subplot(221) plt.plot(fitness_curve_climb) plt.ylabel('fitness') plt.xlabel('num_iter') plt.ylim(20,50) plt.title('random hill climb') plt.subplot(222) plt.plot(fitness_curve_ann) plt.ylabel('fitness') plt.xlabel('num_iter') plt.ylim(20,50) plt.title('simulated annealing') plt.subplot(223) plt.plot(fitness_curve_ga) plt.ylim(20,50) plt.ylabel('fitness') plt.xlabel('num_iter') plt.title('genetic algorithm') plt.subplot(224) plt.plot(fitness_curve_mimic) plt.ylim(20,50) plt.title('mimic') plt.ylabel('fitness') plt.xlabel('num_iter') plt.show()
def 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 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 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 main(): verbose = True num_runs = 20 max_iters = 500 # define custom fitness function to maximize instead of minimize fitness_fn = mlrose.CustomFitness(queens_max) # define optimization problem length = 16 nq_problem = mlrose.QueensOpt( length=length, fitness_fn=fitness_fn, maximize=True, ) nq_problem.set_mimic_fast_mode(True) # set initial state initial_state = np.random.randint(0, length, size=length) # randomized hill climbing rhc_fitness_dfs = n_queens_rhc(nq_problem, initial_state, max_iters, num_runs, verbose) print('---') # simulated annealing sa_fitness_dfs = n_queens_sa(nq_problem, initial_state, max_iters, num_runs, verbose) print('---') # genetic algorithm ga_fitness_dfs = n_queens_ga(nq_problem, max_iters, num_runs, verbose) print('---') # MIMIC algorithm mimic_fitness_dfs = n_queens_mimic(nq_problem, max_iters, num_runs, verbose) print('---') # compare algorithm performance plotting.compare_algos( problem_name='n_queens', 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 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()
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)
max_it = 5000 attempts = max_it * 3 / 4 rhc_fitnesses = [] sa_fitnesses = [] ga_fitnesses = [] m_fitnesses = [] rhc_times = [] sa_times = [] ga_times = [] m_times = [] test_range = [3, 4, 5, 6] final_prob_len = 7 fitness_cust = mlr.CustomFitness(mults_of_2) schedule = mlr.GeomDecay(init_temp=10, decay=0.95, min_temp=0.01) 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}")
plt.scatter(time_taken, best_score) for i, txt in enumerate(keep_pct): plt.annotate(s=str(txt), xy=(time_taken[i], best_score[i])) plt.legend(loc='best', title='Proportion of samples kept') plt.grid() generate_graph(graph_file + "mimic_scatter", graph_title + "MIMIC", "Time Taken", "Best Score achieved") print('Proportion of samples kept: ', keep_pct) print('Best scores reached: ', best_score) print('Time taken to do that: ', time_taken) print('Function evaluations taken: ', fn_evals_taken) 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)
for i in cN: color = colorGen.generate(RANDOM_STATE, number_of_nodes=i, max_connections_per_node=r, max_colors=k) problems_list.append((color, f'color_{i}')) # N-Queens - Custom fitness to maximize # qN = 8 # queens_Prob = mlr.QueensOpt(length=qN) def QMaxFit(state): fitness_cnt = 0 for i in range(len(state) - 1): for j in range(i + 1, len(state)): if (state[j] != state[i]) and (state[j] != state[i] + (j - i)) and (state[j] != state[i] - (j - i)): fitness_cnt += 1 return fitness_cnt QMF_cust = mlr.CustomFitness(QMaxFit) # max val is len(list(itertools.combinations(range(len(state)), 2))) qN = [20, 35, 50, 65, 80, 95] for i in qN: problems_list.append((mlr.QueensOpt(length=i, fitness_fn=QMF_cust, maximize=True), f'queens_{i}')) # Continuous Peaks # pN = 12 t_pct = 0.15 peaksGen = mlr.ContinuousPeaksGenerator() pN = [5, 10, 15, 30, 55, 100] for i in pN: problems_list.append((peaksGen.generate(RANDOM_STATE, i, t_pct), f'peaks_{i}')) print('Building experiments...') ## Algorithms
# For all pairs of queens for i in range(len(state) - 1): for j in range(i + 1, len(state)): # Check for horizontal, diagonal-up and diagonal-down attacks if (state[j] != state[i]) \ and (state[j] != state[i] + (j - i)) \ and (state[j] != state[i] - (j - i)): # If no attacks, then increment counter fitness_cnt += 1 return fitness_cnt # Initialize custom fitness function object q_fitness = mlrh.CustomFitness(queens_max) # q_fitness = mlrose.Queens() prob = mlrh.QueensOpt(length=length, 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],
and (state[j] != state[i] - (j - i)): # If no attacks, then increment counter fitness += 1 return fitness # Check function is working correctly state = np.array([1, 4, 1, 3, 5, 5, 2, 7]) # The fitness of this state should be 22 queens_max(state) # Initialize custom fitness function object fitness_cust = mlrose.CustomFitness(queens_max) # Define optimization problem object problem_cust = mlrose.DiscreteOpt(length=8, fitness_fn=fitness_cust, maximize=True, max_val=8) # Solve using simulated annealing - attempt 1 best_state, best_fitness, fitness_curve = mlrose.simulated_annealing( problem_cust, schedule=schedule, max_attempts=10, max_iters=1000, init_state=init_state, random_state=1) print('Example 2 - Attempt 1')
util.plot_MIMpop(algo, problem_fit, max_attempts, mimpct, maxIter, seed, min) # MIMIC - Keep Percent util.plot_MIMICpct(algo, problem_fit, max_attempts, mimpop, maxIter, seed) if __name__ == "__main__": print('Continuous Peaks - SA best') seed = 1 random.seed(seed) bit_length = 100 SAschedule = mlrose.GeomDecay(init_temp=10000, decay=0.95, min_temp=0.01) # fitness = mlrose.ContinuousPeaks(t_pct=0.02) fitness = mlrose.CustomFitness( util.fit_eval_count(mlrose.ContinuousPeaks, t_pct=0.02)) problem_fit = mlrose.DiscreteOpt(length=bit_length, fitness_fn=fitness, maximize=True, max_val=2) run_ro_algos('CP-testingran', problem_fit, sa_sched=SAschedule, init_temp=1, gapop=900, gamut=0.7, mimpop=800, mimpct=0.3, seed=seed, restarts=100,
max_it = 2000 attempts = max_it / 2 rhc_fitnesses = [] sa_fitnesses = [] ga_fitnesses = [] m_fitnesses = [] rhc_times = [] sa_times = [] ga_times = [] m_times = [] test_range = [4, 6, 8, 10, 15, 20, 30] final_prob_len = 60 fitness_cust = mlr.CustomFitness(orderedmax) schedule = mlr.ArithDecay() 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") print(f"\n######### PART 2 #########\n") part2_time = 0.0 for i in test_range: start = time.time() print(f"Running for subproblem size: {i}")
problem_fit = mlrose.DiscreteOpt(length = 15, fitness_fn= fitness) # Solve the problem with genetic algorithm plotting.plot_optimization_problem_fitness(problem_fit, 100, 2, 'N-Queens') # CODE SOURCED FROM # https://mlrose.readthedocs.io/en/stable/source/tutorial1.html # Define alternative N-Queens fitness function for maximization problem. def queens_max(state): # Initialize counter fitness_cnt = 0 # For all pairs of queens for i in range(len(state) - 1): for j in range(i + 1, len(state)): # Check for horizontal, diagonal-up and diagonal-down attacks if (state[j] != state[i]) \ and (state[j] != state[i] + (j - i)) \ and (state[j] != state[i] - (j - i)): # If no attacks, then increment counter fitness_cnt += 1 return fitness_cnt # Initialize custom fitness function object. cust_fitness = mlrose.CustomFitness(queens_max)
eval_count = 0 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,
def get_problem(size=50): fitness = mlrose_hiive.CustomFitness(fitness_func) problem = mlrose_hiive.DiscreteOpt(length=size, fitness_fn=fitness, maximize=True) return problem