def call_mlrose_curve(algorith_keyword, problem, pop_size=200, mutation_prob=0.1, max_attempts=10, max_iters=np.inf, curve=False\ , random_state=None, schedule=mlrose.GeomDecay(), init_state=None, restarts=0, keep_pct=0.2, fast_mimic=True): if algorith_keyword == 'RHC': best_state, best_fitness, curve_output = mlrose.random_hill_climb(problem, max_attempts=max_attempts, max_iters=max_iters\ , restarts=restarts, init_state=init_state, curve=curve, random_state=random_state) elif algorith_keyword == 'GA': best_state, best_fitness, curve_output = mlrose.genetic_alg(problem, pop_size=pop_size, mutation_prob=mutation_prob\ , max_attempts=max_attempts, max_iters=max_iters, curve=curve, random_state=random_state) elif algorith_keyword == 'SA': best_state, best_fitness, curve_output = mlrose.simulated_annealing(problem, schedule=schedule, max_attempts=max_attempts\ ,max_iters=max_iters, init_state=init_state, curve=curve, random_state=random_state) elif algorith_keyword == 'MIMIC': print("problem: ", problem, "\npop_size: ", pop_size, "\n", "keep_pct: ", keep_pct) print("max_attempts: ", max_attempts, "\nmax_iters: ", max_iters, "\nrandom_state: ", random_state, "\nfast_mimic: ", fast_mimic) best_state, best_fitness, curve_output = mlrose.mimic(problem, pop_size=pop_size, keep_pct=keep_pct\ , max_attempts=max_attempts, max_iters=max_iters, curve=curve, random_state=random_state) print("best_fitness: ", best_fitness) else: print( "\n\nIncorrect 'algorithm_keyword'. Please check the input to the 'call_mlrose' function.\n\n" ) best_state, best_fitness, curve_output = 'incorrect key word', 'incorrect key word', 'incorrect key word' return best_state, best_fitness, curve_output
def n_queens_sa(nq_problem, initial_state, max_iters=np.inf, num_runs=20, verbose=False): hp_name = 'schedule' hp_values = [mlrose.ArithDecay(), mlrose.GeomDecay(), mlrose.ExpDecay()] hp_values_strings = [ val.get_info__()['schedule_type'] for val in hp_values ] # run for each hp value and append results to list fitness_dfs = [] runs = np.arange(num_runs) for hp_value, hp_value_string in zip(hp_values, hp_values_strings): schedule = hp_value # set varied HP at beginning of loop run_times = np.zeros(num_runs) fitness_data = pd.DataFrame() for run in runs: run_t0 = time() best_state, best_fitness, fitness_curve = mlrose.simulated_annealing( problem=nq_problem, schedule=schedule, max_attempts=10, max_iters=max_iters, curve=True, ) run_time = time() - run_t0 run_times[run] = run_time fitness_data = pd.concat( [fitness_data, pd.DataFrame(fitness_curve)], axis=1, sort=False) fitness_data.columns = runs fitness_data = fitness_data.fillna(method='ffill') fitness_dfs.append(fitness_data) # calculate and print avg time per run avg_run_time = np.average(run_times) print("N-Queens - SA avg run time,", hp_value_string, hp_name, ":", avg_run_time) # generate plots plot_title = "N-Queens SA: fitness vs. iterations" plotting.plot_fitness_curves( fitness_dfs=fitness_dfs, hp_values=hp_values_strings, hp_name=hp_name, title=plot_title, ) plt.savefig('graphs/n_queens_sa_fitness.png') plt.clf() return fitness_dfs
def compare_methods(num_char): global count count=0 fitness_obj=mlrose.CustomFitness(heter_string_fn) opt=mlrose.DiscreteOpt(num_char,fitness_obj,maximize=True,max_val=num_char) best_state_climb,best_fitness_climb,fitness_curve_climb=mlrose.random_hill_climb(opt,curve=True) print('---------------------random hill climb-------------------------') print('hill climbing best state for heter-string problem:',best_state_climb) print('hill climbing best fitness for heter-string problem:',best_fitness_climb) print('hill climbing fitting curve for heter-string problem:',fitness_curve_climb) print('number of fitness call used:',count) count=0 print('-------------------simulated annealing-------------------------') best_state_ann,best_fitness_ann,fitness_curve_ann=mlrose.simulated_annealing(opt,schedule=mlrose.ExpDecay(),curve=True) print('simulated annealing best state for heter-string problem:',best_state_ann) print('simulated annealing best fitness for heter-string problem:',best_fitness_ann) print('simulated annealing fitting curve for heter-string problem:',fitness_curve_ann) print('number of fitness call used:',count) count=0 best_state_ga,best_fitness_ga,fitness_curve_ga=mlrose.genetic_alg(opt,pop_size=200, mutation_prob=0.5,curve=True) print('---------------------genetic alg----------------------------') print('genetic algorithm best state for heter-string problem:',best_state_ga) print('genetic algorithm best fitnees for heter-string problem:',best_fitness_ga) print('genetic algorithm fitness curve for heter-string problem:',fitness_curve_ga) print('number of fitness call used:',count) count=0 best_state_mimic,best_fitness_mimic,fitness_curve_mimic=mlrose.mimic(opt,pop_size=200,curve=True) print('------------------------mimic-------------------------------') print('mimic best state for heter-string problem:',best_state_mimic) print('mimic best fitness value for heter-string problem:',best_fitness_mimic) print('mimic curve for heter-string problem:',fitness_curve_mimic) print('number of fitness call used:',count) count=0 plt.figure(figsize=(10,10)) plt.subplot(221) plt.plot(fitness_curve_climb) plt.ylabel('fitness') plt.xlabel('num_iter') plt.ylim(20,50) plt.title('random hill climb') plt.subplot(222) plt.plot(fitness_curve_ann) plt.ylabel('fitness') plt.xlabel('num_iter') plt.ylim(20,50) plt.title('simulated annealing') plt.subplot(223) plt.plot(fitness_curve_ga) plt.ylim(20,50) plt.ylabel('fitness') plt.xlabel('num_iter') plt.title('genetic algorithm') plt.subplot(224) plt.plot(fitness_curve_mimic) plt.ylim(20,50) plt.title('mimic') plt.ylabel('fitness') plt.xlabel('num_iter') plt.show()
def 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 test_simulated_annealing_continuous_min(): """Test simulated_annealing function for a continuous minimization problem""" problem = ContinuousOpt(5, OneMax(), maximize=False) best_state, best_fitness, _ = simulated_annealing(problem, max_attempts=50) x = np.array([0, 0, 0, 0, 0]) assert (np.array_equal(best_state, x) and best_fitness == 0)
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 simulated_annealing(problem_fit, vectorLength, data_dir, iterlist): directory = "./" + data_dir + "/curves/" if not os.path.exists(directory): os.makedirs(directory) path1 = './' + data_dir path2 = "./" + data_dir + "/curves/" beststate = [] bestfit = [] curve = [] time = [] iterlistn = [] CEl = [] for iters in iterlist: for CE in [0.20, 0.40, 0.60, 0.80, 1.0]: CEl.append(CE) start = clock() best_state, best_fitness, train_curve = mlrose.simulated_annealing(problem_fit,\ max_iters=int(iters),\ curve=True, \ schedule=mlrose.GeomDecay(init_temp=CE), random_state=randomSeed) end = clock() time.append(end - start) beststate.append(best_state) bestfit.append(best_fitness) curve.append(train_curve) iterlistn.append(int(iters)) if (verbose == True): print(CE) print(int(iters)) print(best_state) print(best_fitness) ffsa = pd.DataFrame({ 'Best Fitness': bestfit, 'Iterations': iterlistn, 'Time': time, 'CE': CEl }) beststatedf = pd.DataFrame(0.0, index=range(1, vectorLength + 1), columns=range(len(beststate))) for i in range(len(curve)): pd.DataFrame(curve[i]).to_csv( os.path.join(path2, 'sacurve_{}_{}.csv'.format(iterlistn[i], CEl[i]))) for i in range(1, len(beststate) + 1): beststatedf.loc[:, i] = beststate[i - 1] ffsa.to_csv(os.path.join(path1, 'sa.csv')) beststatedf.to_csv(os.path.join(path1, 'sastates.csv'))
def test_simulated_annealing_discrete_max(): """Test simulated_annealing function for a discrete maximization problem""" problem = DiscreteOpt(5, OneMax(), maximize=True) best_state, best_fitness, _ = simulated_annealing(problem, max_attempts=50) x = np.array([1, 1, 1, 1, 1]) assert (np.array_equal(best_state, x) and best_fitness == 5)
def get_sim_ann(problem, schedule=mlrose.GeomDecay()): best_state, best_fitness, fitness_curve = mlrose.simulated_annealing( problem, schedule=schedule, max_attempts=100, max_iters=np.inf, init_state=None, curve=True, random_state=2) return best_state, best_fitness, fitness_curve
def sa_optimization(size): algo = 'sa' problem = get_problem(size) # Gridsearch params max_iters = 500 schedule_values = [mlrose_hiive.GeomDecay(), mlrose_hiive.ArithDecay(), mlrose_hiive.algorithms.decay.ExpDecay()] max_attempts_values = [10, 50, 100, 200] n_runs = len(schedule_values) * len(max_attempts_values) # Best vals schedule, max_attempts = None, None fitness, curves, n_invocations, time = float('-inf'), [], 0, 0 # Gridsearch global eval_count run_counter = 0 for run_schedule in schedule_values: for run_max_attempts in max_attempts_values: # Print status run_counter += 1 print(f'RUN {run_counter} of {n_runs} [schedule: {run_schedule.__class__.__name__}] [max_attempts: {run_max_attempts}]') # Run problem eval_count = 0 start = timer() run_state, run_fitness, run_curves = mlrose_hiive.simulated_annealing(problem, schedule=run_schedule, max_attempts=run_max_attempts, max_iters=max_iters, random_state=42, curve=True) end = timer() # Save curves and params if run_fitness > fitness: schedule = run_schedule.__class__.__name__ max_attempts = run_max_attempts fitness = run_fitness curves = run_curves n_invocations = eval_count time = end - start df = pandas.DataFrame(curves, columns=['fitness']) df['schedule'] = schedule df['max_attempts'] = max_attempts df['max_iters'] = max_iters df['n_invocations'] = n_invocations df['time'] = time df.to_csv(f'{STATS_FOLDER}/{algo}_{size}_stats.csv', index=False) print(f'{algo}_{size} run.')
def plot_optimization_problem_fitness(fitness_function, iterations, random_state, title): start_rhc = timeit.default_timer() rhc_best_state, rhc_best_fitness, rch_fitness_curve = mlrose.random_hill_climb(fitness_function, max_iters=iterations, random_state= random_state, restarts=10, curve=True) rhc_elapsed = timeit.default_timer() - start_rhc start_sa = timeit.default_timer() sa_best_state, sa_best_fitness, sa_fitness_curve = mlrose.simulated_annealing(fitness_function, max_iters=iterations, random_state= random_state, curve=True) sa_elapsed = timeit.default_timer() - start_sa start_ga = timeit.default_timer() ga_best_state, ga_best_fitness, ga_fitness_curve = mlrose.genetic_alg(fitness_function, max_iters=iterations, random_state= random_state, curve=True) ga_elapsed = timeit.default_timer() - start_ga start_mimic = timeit.default_timer() mimic_best_state, mimic_best_fitness, mimic_fitness_curve = mlrose.mimic(fitness_function, max_iters=iterations, random_state= random_state, curve=True) mimic_elapsed = timeit.default_timer() - start_mimic # Fill in arrays. rch_fitness_curve_bf = np.full(iterations, rhc_best_fitness) rch_fitness_curve_bf[:rch_fitness_curve.shape[0]] = rch_fitness_curve sa_fitness_curve_bf = np.full(iterations, sa_best_fitness) sa_fitness_curve_bf[:sa_fitness_curve.shape[0]] = sa_fitness_curve ga_fitness_curve_bf = np.full(iterations, ga_best_fitness) ga_fitness_curve_bf[:ga_fitness_curve.shape[0]] = ga_fitness_curve mimic_fitness_curve_bf = np.full(iterations, mimic_best_fitness) mimic_fitness_curve_bf[:mimic_fitness_curve.shape[0]] = mimic_fitness_curve # Plot the convergance times. plot_ro_algo_times(rhc_elapsed, ga_elapsed, sa_elapsed, mimic_elapsed, title) # Plot the fitness over iterations. fig = plt.figure(figsize=(8,6)) plt.plot(rch_fitness_curve_bf, label="RHC") plt.plot(sa_fitness_curve_bf, label="SA") plt.plot(ga_fitness_curve_bf, label="GA") plt.plot(mimic_fitness_curve_bf, label="MIMIC") plt.xlabel("Number of Iterations") plt.xticks(np.arange(0.0, iterations, step=iterations / 10)) plt.ylabel("Fitness Function") plt.title(title) plt.legend(prop={'size':13}, loc='lower right') plt.savefig('Charts/OptimizationProblems/' + title + '.png') plt.clf()
def test_simulated_annealing_max_iters(): """Test simulated_annealing function with max_iters less than infinite""" problem = DiscreteOpt(5, OneMax(), maximize=True) x = np.array([0, 0, 0, 0, 0]) best_state, best_fitness, _ = simulated_annealing(problem, max_attempts=1, max_iters=1, init_state=x) assert best_fitness == 1
def sa(problem, init_state, max_attempts, max_iters): # Define decay schedule schedule = mlrose_hiive.ExpDecay() # Define initial state # init_state = np.array([0, 1, 2, 3, 4, 5, 6, 7]) # Solve problem using simulated annealing best_state, best_fitness, fitness_curve = mlrose_hiive.simulated_annealing(problem, schedule = schedule, max_attempts = max_attempts, max_iters = max_iters,init_state = init_state, curve=True, random_state = 1) print('simulated annealing') print(best_state) print(best_fitness) # print(fitness_curve) return best_state, best_fitness, fitness_curve
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 run_SA_3(problem, init_state, **kwargs): start = time.time() fit_vals = [] fit_curves = [] times = [] fevals = [] # run multiple times to get average for random_state in random_states: start = time.time() _, best_fit, fit_curve, evals = simulated_annealing( problem, random_state=random_state, schedule=GeomDecay(decay=0.94), **kwargs, curve=True, init_state=init_state, fevals=True) fit_vals.append(best_fit) fit_curves.append(fit_curve) times.append(time.time() - start) fevals.append(sum(evals.values())) # plot average fitness value # now = datetime.now() # dt_string = now.strftime("%Y-%m-%d-%H-%M-%S") # hack for ease of naming problem_name = str(problem.fitness_fn).split('.')[-1].split(' ')[0] # chart_name = f"charts/sa_{problem_name}_{len(init_state)}_{dt_string}" # plt.plot(average_curves(fit_curves), label="sa") # plt.title(f"SA {problem_name} ({len(init_state)})") # plt.xlabel("step") # plt.ylabel("fitness") # plt.savefig(chart_name) # plt.show() avg_fit = np.average(fit_vals) avg_time = round(np.mean(times), 2) avg_evals = np.mean(fevals) print(f"SA {problem_name}: {avg_fit}: {avg_time}: {avg_evals}") return avg_fit, avg_time, avg_evals
def plot_SAdecay(problem, problem_fit, max_attempts, init_temp, maxIter, seed, min=False): decay_r = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.95] plt.figure() for d in decay_r: SAschedule = mlrose.GeomDecay(init_temp=init_temp, decay=d, min_temp=0.01) best_state, best_fitness, safitness_curve = mlrose.simulated_annealing(problem_fit, schedule=SAschedule, curve=True, max_attempts=max_attempts, random_state=seed, max_iters=maxIter) if min: safitness_curve = np.array(safitness_curve) * -1 plt.plot(safitness_curve, label='decay rate = ' + str(d)) plt.title(problem + " - SA - Decay Rates") plt.xlabel('Iterations') plt.ylabel('Fitness') plt.grid(True) plt.legend() plt.savefig("Images\\" + problem + " - SA - Decay Rates") plt.show()
def plot_SATemps(problem, problem_fit, max_attempts, decay, maxIter, seed, min=False): temps = [10000000, 1000000, 100000, 10000, 1000, 100, 10, 1, 0.1] plt.figure() for t in temps: SAschedule = mlrose.GeomDecay(init_temp=t, decay=decay, min_temp=0.01) best_state, best_fitness, safitness_curve = mlrose.simulated_annealing(problem_fit, schedule=SAschedule, curve=True, max_attempts=max_attempts, random_state=seed, max_iters=maxIter) if min: safitness_curve = np.array(safitness_curve) * -1 plt.plot(safitness_curve, label='Temperature = ' + str(t)) plt.title(problem + " - SA - Initial Temperature") plt.xlabel('Iterations') plt.ylabel('Fitness') plt.grid(True) plt.legend() plt.savefig("Images\\" + problem + " - SA - Initial Temperature") plt.show()
def simulated_annealing(problem, init_state, max_attempts, max_iters): schedule = mlr.ExpDecay() # Tune this? start_time = time.time() best_state, best_fitness, fitness_curve = mlr.simulated_annealing( problem, schedule=schedule, max_attempts=max_attempts, max_iters=max_iters, init_state=init_state, curve=True, random_state=RANDOM_STATE) end_time = time.time() total_time = end_time - start_time print('Simulated Annealing') print("Elapsed Time", total_time) #print(best_state) print(best_fitness) # print(fitness_curve) return best_state, best_fitness, fitness_curve, total_time
def s_ann(opt): global count count = 0 ann_loss_list = [] ann_train_acc_list = [] ann_test_acc_list = [] for exp_value in np.arange(0.0005, 0.0101, 0.0005): best_state_spam, best_fitness_spam, _ = mlrose.simulated_annealing( opt, schedule=mlrose.ExpDecay(exp_const=exp_value), curve=True) train_predict_gen = predict(best_state_spam, train_features_spam_norm) test_predict_gen = predict(best_state_spam, test_features_spam_norm) train_accuracy_hill = accuracy_score(train_labels_spam, train_predict_gen) test_accuracy_hill = accuracy_score(test_labels_spam, test_predict_gen) ann_loss_list.append(best_fitness_spam) ann_train_acc_list.append(train_accuracy_hill) ann_test_acc_list.append(test_accuracy_hill) plt.figure(figsize=(10, 6)) plt.subplot(121) plt.plot(np.arange(0.0005, 0.0101, 0.0005), ann_loss_list, label='-1*loss') plt.xlabel('exp_const value') plt.ylabel('minus of loss') plt.title('loss versus exp_const value') plt.legend(loc='lower right') plt.subplot(122) plt.plot(np.arange(0.0005, 0.0101, 0.0005), ann_train_acc_list, label='train') plt.plot(np.arange(0.0005, 0.0101, 0.0005), ann_test_acc_list, label='test') plt.xlabel('exp_const value') plt.ylabel('accuracy') plt.title('accuracy versus exp_const value') plt.legend(loc='lower right') plt.show()
def method_compare(opt, train_features_spam_norm, train_labels_spam, test_features_spam_norm, test_labels_spam): #best_state_spam,best_fitness_spam,fitness_curve=mlrose.simulated_annealing(opt,schedule=mlrose.ExpDecay(),curve=True) #best_state_spam,best_fitness_spam,fitness_curve=mlrose.genetic_alg(opt,pop_size=2000,curve=True) global count count = 0 loss_list_rhc = [] loss_list_ann = [] loss_list_ga = [] train_acc_list_rhc = [] train_acc_list_ann = [] train_acc_list_ga = [] test_acc_list_rhc = [] test_acc_list_ann = [] test_acc_list_ga = [] fitness_call_list_rhc = [] fitness_call_list_ann = [] fitness_call_list_ga = [] # ten rounds of rhc for i in range(10): count = 0 best_state_spam, best_fitness_spam, fitness_curve = mlrose.random_hill_climb( opt, restarts=70, curve=True) loss_list_rhc.append(best_fitness_spam) train_predict_rhc = predict(best_state_spam, train_features_spam_norm) test_predict_rhc = predict(best_state_spam, test_features_spam_norm) train_acc_list_rhc.append( accuracy_score(train_labels_spam, train_predict_rhc)) test_acc_list_rhc.append( accuracy_score(test_labels_spam, test_predict_rhc)) fitness_call_list_rhc.append(count) #ten rounds of simulated annealing for i in range(10): count = 0 best_state_spam, best_fitness_spam, _ = mlrose.simulated_annealing( opt, schedule=mlrose.ExpDecay(exp_const=0.003), curve=True) loss_list_ann.append(best_fitness_spam) train_predict_ann = predict(best_state_spam, train_features_spam_norm) test_predict_ann = predict(best_state_spam, test_features_spam_norm) train_acc_list_ann.append( accuracy_score(train_labels_spam, train_predict_ann)) test_acc_list_ann.append( accuracy_score(test_labels_spam, test_predict_ann)) fitness_call_list_ann.append(count) #ten rounds of genetic algorithm for i in range(10): count = 0 best_state_spam, best_fitness_spam, _ = mlrose.genetic_alg( opt, pop_size=1000, curve=True) loss_list_ga.append(best_fitness_spam) train_predict_ga = predict(best_state_spam, train_features_spam_norm) test_predict_ga = predict(best_state_spam, test_features_spam_norm) train_acc_list_ga.append( accuracy_score(train_labels_spam, train_predict_ga)) test_acc_list_ga.append( accuracy_score(test_labels_spam, test_predict_ga)) fitness_call_list_ga.append(count) #plot loss curve plt.figure(figsize=(6, 6)) plt.plot(np.arange(1, 11), loss_list_rhc, label='rhc') plt.plot(np.arange(1, 11), loss_list_ann, label='s_ann') plt.plot(np.arange(1, 11), loss_list_ga, label='ga') plt.xlabel('rounds') plt.ylabel('-1*losss') plt.title('loss versus different algorithm') plt.legend() plt.show() #plot acc curve plt.figure(figsize=(15, 6)) plt.subplot(131) plt.plot(np.arange(1, 11), train_acc_list_rhc, label='train') plt.plot(np.arange(1, 11), test_acc_list_rhc, label='test') plt.xlabel('rounds') plt.ylabel('accuracy') plt.title('rhc') plt.legend() plt.subplot(132) plt.plot(np.arange(1, 11), train_acc_list_ann, label='train') plt.plot(np.arange(1, 11), test_acc_list_ann, label='test') plt.xlabel('rounds') plt.ylabel('accuracy') plt.title('simulated annealing') plt.legend() plt.subplot(133) plt.plot(np.arange(1, 11), train_acc_list_ga, label='train') plt.plot(np.arange(1, 11), test_acc_list_ga, label='test') plt.xlabel('rounds') plt.ylabel('accuracy') plt.title('genetic algorithm') plt.legend() #plot fitness call plt.figure(figsize=(6, 6)) plt.plot(np.arange(1, 11), fitness_call_list_rhc, label='rhc') plt.plot(np.arange(1, 11), fitness_call_list_ann, label='s_ann') plt.plot(np.arange(1, 11), fitness_call_list_ga, label='ga') plt.xlabel('rounds') plt.ylabel('fitness call number') plt.title('fitness call num versus different algorithm') plt.legend() plt.show()
max_attempts=attempts, random_state=seed, curve=True, init_state=init, restarts=500) print(f" best RHC State: {best_rhc_state}") sub_end = time.time() rhc_fitnesses.append(best_rhc_fitness) rhc_times.append(sub_end - sub_start) ## Simulated Annealing sub_start = time.time() best_sa_state, best_sa_fitness, sa_curve = mlr.simulated_annealing( problem, schedule=schedule, max_attempts=attempts, random_state=seed, curve=True, init_state=init) print(f" best SA State: {best_sa_state}") sub_end = time.time() sa_fitnesses.append(best_sa_fitness) sa_times.append(sub_end - sub_start) ## Genetic Algorithm sub_start = time.time() best_ga_state, best_ga_fitness, ga_curve = mlr.genetic_alg( problem, pop_size=200, max_attempts=attempts, random_state=seed,
# Define optimization problem object problem = mlrose.DiscreteOpt(length=8, fitness_fn=fitness, maximize=False, max_val=8) # Define decay schedule schedule = mlrose.ExpDecay() # Solve using simulated annealing - attempt 1 print('Example 1 - Attempt 1') init_state = np.array([0, 1, 2, 3, 4, 5, 6, 7]) best_state, best_fitness, fitness_curve = mlrose.simulated_annealing( problem, schedule=schedule, max_attempts=10, max_iters=1000, init_state=init_state, random_state=1) print(best_state) print(best_fitness) # Solve using simulated annealing - attempt 2 best_state, best_fitness, fitness_curve = mlrose.simulated_annealing( problem, schedule=schedule, max_attempts=100, max_iters=1000, init_state=init_state, random_state=1) print('Example 1 - Attempt 2')
def sa(problem, iterations, random_seed, graph_file, graph_title): decays = [0.001, 0.002, 0.003, 0.004, 0.005] best_score = [] time_taken = [] fn_evals_taken = [] # fig1, ax1 = plt.subplots() # fig2, ax2 = plt.subplots() global eval_count for decay in decays: schedule = mlrose_hiive.ArithDecay(init_temp=1.0, decay=decay) fitness = [] fit_time = [] fn_evals = [] for i in iterations: eval_count = 0 start = datetime.datetime.now() # Solve using simulated annealing - attempt 1 best_state, best_fitness, _ = mlrose_hiive.simulated_annealing(problem, schedule=schedule, max_iters=i, random_state=random_seed) finish = datetime.datetime.now() fn_evals.append(eval_count) fitness.append(best_fitness) fit_time.append((finish - start).total_seconds()) # print('iteration: ',i) # print('best_state:', best_state) # print('best_fitness: ', best_fitness) best_score.append(max(fitness)) index = fitness.index(max(fitness)) time_taken.append(fit_time[index]) fn_evals_taken.append(fn_evals[index]) # print('index: ', index) # print('time for that: ', fit_time[index]) plt.plot(iterations, fitness, label="Cooling = " + str(decay)) # ax2.plot(fn_evals, fitness, label="Cooling = " + str(decay)) plt.legend(loc="best") plt.grid() generate_graph(graph_file + "sa_iter", graph_title + "Simulated Annealing", "Iterations", "Fitness") """ ax2.legend(loc="best") ax2.grid() generate_graph("cp_sa_evals", "Continuous Peaks - Simulated Annealing", "Function evaluations", "Fitness") """ # Decays best_score and time_taken plt.plot(decays, best_score) plt.grid() generate_graph(graph_file + "sa_decays", graph_title + "Simulated Annealing", "Cooling Component", "Best Score Achieved") plt.plot(decays, time_taken) plt.grid() generate_graph(graph_file + "sa_decay_time", graph_title + "Simulated Annealing", "Cooling Component", "Time taken to achieve that") plt.scatter(time_taken, best_score) for i, txt in enumerate(decays): plt.annotate(s=str(txt), xy=(time_taken[i], best_score[i])) plt.legend(loc='best', title='Cooling Component') plt.grid() generate_graph(graph_file + "sa_scatter", graph_title + "Simulated Annealing", "Time Taken", "Best Score achieved") print('decays: ', decays) print('Best scores reached: ', best_score) print('Time taken to do that: ', time_taken) print('Function evaluations taken: ', fn_evals_taken)
coords_list.append(np.random.rand(2)) fitness = mlrose.TravellingSales(coords=coords_list) problem = mlrose.TSPOpt(prob_length, fitness) RANDOM_SEED = 42 MAX_ATTEMPTS = 200 #%% 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=3000, curve=True, random_state=RANDOM_SEED, ) curve_list.append(curve) df = 1 / pd.DataFrame(curve_list).transpose() df.columns = decays df.plot() plt.xlabel("Iteration") plt.ylabel("Fitness") plt.title("TSP: Fitness curve vs decay rate in SA") plt.savefig("output/tsp_sa_decay.png") plt.close() print(df.max())
sa_stats, sa_curve = sa.run() columns = ['Time', 'Fitness', 'Temperature', 'schedule_type'] df=pd.read_csv("./queen/queen_prob/sa__queen_prob__run_stats_df.csv") print(df[columns].sort_values(by=['Fitness'], ascending=False)) max_attempts = 200 max_iters = 2000 init_temp = 0.01 schedule = mlrh.ExpDecay(init_temp) eval_count = 0 best_state, best_fitness, sa_curve = mlrh.simulated_annealing(prob, max_attempts=max_attempts, max_iters=max_iters, random_state=random_state, schedule=schedule, curve=True) print("Simulated Annealing - Total Function Evaluations:", eval_count) plot_fitness_iteration('fitness_iteration_sa_queens.png', sa_curve, "Queens - Simulated Annealing: schedule: {}, init_temp: {}".format(schedule.__class__.__name__, init_temp)) # GA ga = mlrh.GARunner(problem=prob, experiment_name=experiment_name, output_directory=output_directory, seed=random_state, max_attempts=20, iteration_list=[100], population_sizes=[10, 100, 200, 300], mutation_rates=[0.1, 0.25, 0.5, 0.75, 1.0])
def get_random_optimisation(problem, optimisation, problem_type, seed=10, state_fitness_callback=None): best_state, best_fitness, fitness_curve = None, None, None process_time = [] if optimisation == Optimisation.RHC: start = time.time() best_state, best_fitness, fitness_curve = mlrose.random_hill_climb( problem, max_attempts=__MAX_ATTEMPTS[problem_type], max_iters=__MAX_ITERS, curve=True, random_state=seed, state_fitness_callback=state_fitness_callback, callback_user_info=['rhc']) process_time.append(time.time() - start) elif optimisation == Optimisation.SA: start = time.time() best_state, best_fitness, fitness_curve = mlrose.simulated_annealing( problem, schedule=mlrose.ExpDecay(exp_const=0.1), max_attempts=__MAX_ATTEMPTS[problem_type], max_iters=__MAX_ITERS, curve=True, random_state=seed, state_fitness_callback=state_fitness_callback, callback_user_info=['sa']) process_time.append(time.time() - start) elif optimisation == Optimisation.GA: start = time.time() best_state, best_fitness, fitness_curve = mlrose.genetic_alg( problem, pop_size=__POP_SIZE[problem_type], mutation_prob=__MUTATION_PROBABILITY, max_attempts=__MAX_ATTEMPTS[problem_type], max_iters=__MAX_ITERS, curve=True, random_state=seed, state_fitness_callback=state_fitness_callback, callback_user_info=['ga']) process_time.append(time.time() - start) elif optimisation == Optimisation.MIMIC: start = time.time() best_state, best_fitness, fitness_curve = mlrose.mimic( problem, pop_size=__POP_SIZE[problem_type], keep_pct=__KEEP_PCT, max_iters=__MAX_ITERS, max_attempts=__MAX_ATTEMPTS[problem_type], curve=True, random_state=seed, state_fitness_callback=state_fitness_callback, callback_user_info=['mimic']) process_time.append(time.time() - start) return best_state, best_fitness, np.array(fitness_curve), process_time
def GenerateFitnessCurves(problem_fit, ma, sa_sched=None, gapop=200, gamut=0.5, mimpop=200, mimpct=0.2, maxIter=1000, seed=1, min=False, input_size=-1, restarts=0): global eval_count, iter_total, algo_in, start, times, evals start = time.time() eval_count, iter_total, times, evals = 0, 0, [], [] algo_in = 'RHC' print('RHC') best_state, best_fitness, rhcfitness_curve = mlrose.random_hill_climb(problem_fit, curve=True, max_attempts=ma, state_fitness_callback=callback_func, callback_user_info=[], restarts=restarts, random_state=seed, max_iters=maxIter) rhc_times = copy.deepcopy(times) rhc_evals = copy.deepcopy(evals) print('RHC', input_size, seed, best_fitness, np.where(rhcfitness_curve == best_fitness)[0][0], # iter of best fitness iter_total, # total iters np.where(rhcfitness_curve == best_fitness)[0][0], # num evals for best fitness eval_count, # total evals # round(rhc_times[np.where(rhcfitness_curve == best_fitness)[0][0]], 4), # time of best fitness round(rhc_times[-1], 4) # total time ) eval_count, iter_total, times, evals = 0, 0, [], [] algo_in = 'NOT_RHC' print('SA') if sa_sched: best_state, best_fitness, safitness_curve = mlrose.simulated_annealing(problem_fit, schedule=sa_sched, state_fitness_callback=callback_func, callback_user_info=[], curve=True, max_attempts=ma, random_state=seed, max_iters=maxIter) else: best_state, best_fitness, safitness_curve = mlrose.simulated_annealing(problem_fit, # schedule=SA_schedule, curve=True, max_attempts=ma, state_fitness_callback=callback_func, callback_user_info=[], random_state=seed, max_iters=maxIter) sa_times = copy.deepcopy(times) sa_evals = copy.deepcopy(evals) print('SA', input_size, seed, best_fitness, np.where(safitness_curve == best_fitness)[0][0], # iter of best fitness len(safitness_curve), # total iters evals[np.where(safitness_curve == best_fitness)[0][0]], # num evals for best fitness eval_count, # total evals round(sa_times[np.where(safitness_curve == best_fitness)[0][0]], 4), # time of best fitness round(sa_times[-1], 4) # total time ) eval_count, iter_total, times, evals = 0, 0, [], [] print('GA') best_state, best_fitness, gafitness_curve = mlrose.genetic_alg(problem_fit, curve=True, pop_size=gapop, mutation_prob=gamut, max_attempts=ma, state_fitness_callback=callback_func, callback_user_info=[], random_state=seed, max_iters=maxIter) ga_times = copy.deepcopy(times) ga_evals = copy.deepcopy(evals) print('GA', input_size, seed, best_fitness, np.where(gafitness_curve == best_fitness)[0][0], # iter of best fitness len(gafitness_curve), # total iters evals[np.where(gafitness_curve == best_fitness)[0][0]], # num evals for best fitness eval_count, # total evals round(ga_times[np.where(gafitness_curve == best_fitness)[0][0]], 4), # time of best fitness round(ga_times[-1], 4) # total time ) eval_count, iter_total, times, evals = 0, 0, [], [] print('MIMIC') best_state, best_fitness, mimicfitness_curve = mlrose.mimic(problem_fit, curve=True, max_attempts=ma, pop_size=mimpop, keep_pct=mimpct, state_fitness_callback=callback_func, callback_user_info=[], random_state=seed, max_iters=maxIter) mim_times = copy.deepcopy(times) mim_evals = copy.deepcopy(evals) print('MIMIC', input_size, seed, best_fitness, np.where(mimicfitness_curve == best_fitness)[0][0], # iter of best fitness len(mimicfitness_curve), # total iters evals[np.where(mimicfitness_curve == best_fitness)[0][0]], # num evals for best fitness eval_count, # total evals round(mim_times[np.where(mimicfitness_curve == best_fitness)[0][0]], 4), # time of best fitness round(mim_times[-1], 4) # total time ) if min: # To Maximize TSP, need to make everything negative gafitness_curve = np.array(gafitness_curve) * -1 rhcfitness_curve = np.array(rhcfitness_curve) * -1 safitness_curve = np.array(safitness_curve) * -1 mimicfitness_curve = np.array(mimicfitness_curve) * -1 return gafitness_curve, rhcfitness_curve, safitness_curve, mimicfitness_curve, ga_times, rhc_times, sa_times, mim_times, rhc_evals, sa_evals, ga_evals, mim_evals else: return gafitness_curve, rhcfitness_curve, safitness_curve, mimicfitness_curve, ga_times, rhc_times, sa_times, mim_times, rhc_evals, sa_evals, ga_evals, mim_evals
def plot_sa_graph(prob_type): try: os.mkdir("./SA") except FileExistsError: pass except OSError as error: print("Error creating directory results.") print('\n plot_sa_graph - Progress: ', end="") fitness, problem = get_fitness_function(prob_type) process_time = [] fitness_score = [] for j in range(3): process_time.append([]) fitness_score.append([]) if j != 2: decay_const = [ 0.005, 0.01, 0.05, 0.1, 0.15, 0.25, 0.5, 0.75, 0.9, 0.99 ] else: decay_const = [ 0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 0.9, 0.99 ] for i in decay_const: print('.', end="") if j == 0: decay = mlrose.GeomDecay(decay=i) elif j == 1: decay = mlrose.ExpDecay(exp_const=i) else: decay = mlrose.ArithDecay(decay=i) start = time.time() best_state, best_fitness, fitness_curve = mlrose.simulated_annealing( problem, schedule=decay, max_attempts=1000, max_iters=100, random_state=10) fitness_score[j].append(best_fitness) process_time[j].append(time.time() - start) plt.figure(100) plt.plot([0.005, 0.01, 0.05, 0.1, 0.15, 0.25, 0.5, 0.75, 0.9, 0.99], fitness_score[0], 'r', label='GeomDecay') plt.plot([0.005, 0.01, 0.05, 0.1, 0.15, 0.25, 0.5, 0.75, 0.9, 0.99], fitness_score[1], 'b', label='ExpDecay') plt.plot([0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 0.9, 0.99], fitness_score[2], 'g', label='ArithDecay') plt.xlim(0.0001, 0.2) plt.legend() plt.xlabel("decay constant") plt.ylabel("fitness score") plt.title('Simulated Annealing') plt.savefig("SA/" + "Fitness.png") plt.figure(101) plt.plot([0.005, 0.01, 0.05, 0.1, 0.15, 0.25, 0.5, 0.75, 0.9, 0.99], process_time[0], 'r', label='GeomDecay') plt.plot([0.005, 0.01, 0.05, 0.1, 0.15, 0.25, 0.5, 0.75, 0.9, 0.99], process_time[1], 'b', label='ExpDecay') plt.plot([0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 0.9, 0.99], process_time[2], 'g', label='ArithDecay') plt.xlim(0.0001, 0.2) plt.legend() plt.xlabel("decay constant") plt.ylabel("process time") plt.title('Simulated Annealing') plt.savefig("SA/" + "Time.png")
'fourpeaks': mlrose.FourPeaks(), 'onemax': mlrose.OneMax(), # 'path': mlrose.CustomFitness(path, problem_type='discrete'), 'flipflop': mlrose.FlipFlop(), # 'cliffs': mlrose.CustomFitness(cf1, problem_type='discrete'), # 'cliffs': mlrose.CustomFitness(is_larger, problem_type='discrete'), # 'max2color': mlrose.MaxKColorGenerator.generate(seed=42, number_of_nodes=PROBLEM_LENGTH, max_colors=2), # 'mod': mlrose.CustomFitness(cf2, problem_type='discrete') } RANDOM_STATE = 42 DEFAULTS = {'random_state': RANDOM_STATE, 'curve': True, 'max_attempts': 10} ALGORITHMS = { 'rhc': lambda p: mlrose.random_hill_climb(p, **DEFAULTS), 'sa': lambda p: mlrose.simulated_annealing(p, **DEFAULTS), 'ga': lambda p: mlrose.genetic_alg(p, **DEFAULTS), 'mimic': lambda p: mlrose.mimic(p, **DEFAULTS) } results = [] PART_1 = True PART_2 = True if PART_1: for f_name, fitness in FITNESS_FUNCS.items(): evaluate_fitness(f_name, fitness, f_name == 'max2color') alg2curve = {} overall_best_fitness = -1 for alg_name, alg in ALGORITHMS.items():
def run_complexity(self, fitness_fn, mode=None): if mode == 1: self.run_ga_hyper_params(fitness_fn) elif mode == 2: self.run_rhc_hyper_params(fitness_fn) elif mode == 3: self.run_sa_hyper_params(fitness_fn) elif mode == 4: self.run_mimic_hyper_params(fitness_fn) elif not mode: fitness_name = fitness_fn.__class__.__name__ print("Running %s" % fitness_name) init_states = {} knap_fitnesses = {} tsp_fitnesses = {} tries = 1 for x in 2**np.arange(3, 9): n = int(x) fitness_dists = mlrose.TravellingSales(distances=get_coords(n)) tsp_fitnesses[n] = fitness_dists edges = [] for x in range(int(n * 0.75)): a = r.randint(0, n - 1) b = r.randint(0, n - 1) while b == a: b = r.randint(0, n - 1) edges.append((a, b)) fitness_fn_knap = mlrose.MaxKColor(edges=edges) init_states[n] = [] knap_fitnesses[n] = fitness_fn_knap for y in range(tries): init_states[n].append(get_init_state(n)) for n, init_states_list in init_states.items(): if fitness_name == 'MaxKColor': fitness_fn = knap_fitnesses[n] if fitness_name == 'TravellingSales': fitness_fn = tsp_fitnesses[n] print(n) print('%s: i=%d' % ('random_hill_climb', n)) total_score = 0 total_iter = 0 start = time.time() for init_state in init_states_list: problem = mlrose.DiscreteOpt(length=len(init_state), fitness_fn=fitness_fn, maximize=True) if fitness_name == 'TravellingSales': problem = mlrose.TSPOpt(length=n, fitness_fn=fitness_fn) max_attempts = self.get_best_param( problem=fitness_name, algo='random_hill_climb', param='max_attempts') restarts = self.get_best_param(problem=fitness_name, algo='random_hill_climb', param='restarts') best_state, best_fitness, curve = mlrose.random_hill_climb( problem, max_attempts=max_attempts, max_iters=10000, random_state=1, curve=True, restarts=restarts) total_iter += len(curve) total_score += np.mean(curve) end = time.time() print('The fitness at the best state is: ', total_score / tries) self.track(problem=fitness_name, algo='random_hill_climb', i=n, score=total_score / tries, training_time=(end - start) / tries, max_iter=total_iter / tries) for n, init_states_list in init_states.items(): if fitness_name == 'MaxKColor': fitness_fn = knap_fitnesses[n] if fitness_name == 'TravellingSales': fitness_fn = tsp_fitnesses[n] print(n) print('%s: i=%d' % ('simulated_annealing', n)) total_score = 0 total_iter = 0 start = time.time() for init_state in init_states_list: problem = mlrose.DiscreteOpt(length=len(init_state), fitness_fn=fitness_fn, maximize=True) if fitness_name == 'TravellingSales': problem = mlrose.TSPOpt(length=n, fitness_fn=fitness_fn) max_attempts = self.get_best_param( problem=fitness_name, algo='simulated_annealing', param='max_attempts') best_state, best_fitness, curve = mlrose.simulated_annealing( problem, max_attempts=max_attempts, max_iters=10000, random_state=1, curve=True) total_score += np.mean(curve) total_iter += len(curve) end = time.time() print('The fitness at the best state is: ', total_score / tries) self.track(problem=fitness_name, algo='simulated_annealing', i=n, score=total_score / tries, training_time=(end - start) / tries, max_iter=total_iter / tries) for n, init_states_list in init_states.items(): if fitness_name == 'MaxKColor': fitness_fn = knap_fitnesses[n] if fitness_name == 'TravellingSales': fitness_fn = tsp_fitnesses[n] print(n) print('%s: i=%d' % ('genetic_alg', n)) total_score = 0 total_iter = 0 start = time.time() for init_state in init_states_list: problem = mlrose.DiscreteOpt(length=len(init_state), fitness_fn=fitness_fn, maximize=True) if fitness_name == 'TravellingSales': problem = mlrose.TSPOpt(length=n, fitness_fn=fitness_fn) mutation_prob = self.get_best_param(problem=fitness_name, algo='genetic_alg', param='mutation_prob') pop_size = self.get_best_param(problem=fitness_name, algo='genetic_alg', param='pop_size') best_state, best_fitness, curve = mlrose.genetic_alg( problem, pop_size=pop_size, mutation_prob=mutation_prob, max_iters=10000, random_state=1, curve=True) total_score += np.mean(curve) total_iter += len(curve) end = time.time() print('The fitness at the best state is: ', total_score / tries) self.track(problem=fitness_name, algo='genetic_alg', i=n, score=total_score / tries, training_time=(end - start) / tries, max_iter=total_iter / tries) for n, init_states_list in init_states.items(): if fitness_name == 'MaxKColor': fitness_fn = knap_fitnesses[n] if fitness_name == 'TravellingSales': fitness_fn = tsp_fitnesses[n] print('%s: i=%d' % ('mimic', n)) if n > 256: break total_score = 0 total_iter = 0 start = time.time() for init_state in init_states_list: problem = mlrose.DiscreteOpt(length=len(init_state), fitness_fn=fitness_fn, maximize=True) if fitness_name == 'TravellingSales': problem = mlrose.TSPOpt(length=n, fitness_fn=fitness_fn) keep_pct = self.get_best_param(problem=fitness_name, algo='mimic', param='keep_pct') pop_size = self.get_best_param(problem=fitness_name, algo='mimic', param='pop_size') best_state, best_fitness, curve = mlrose.mimic( problem, max_iters=10000, random_state=1, curve=True, pop_size=pop_size, keep_pct=keep_pct, max_attempts=10) total_score += np.mean(curve) total_iter += len(curve) end = time.time() print('The fitness at the best state is: ', total_score / tries) self.track(problem=fitness_name, algo='mimic', i=n, score=total_score / tries, training_time=(end - start) / tries, max_iter=total_iter / tries)