GA_fitness_curve = best_fitness_curve # print("----------------------------------") # print("Genetic algorithm") # print(best_state) # print(best_fitness) # print(fitness_curve) # print("----------------------------------") # MIMIC t_bef = time.time() best_state, best_fitness, best_fitness_curve = mlrose.mimic( problem, pop_size=800, keep_pct=0.2, max_attempts=10, max_iters=1000, curve=True, fast_mimic=True, random_state=RANDOM_STATE) t_aft = time.time() clock_time[3] = t_aft - t_bef MIMIC_fitness_curve = best_fitness_curve # print("----------------------------------") # print("MIMIC") # print(best_state) # print(best_fitness) # print(fitness_curve) # print("----------------------------------")
def process_cp_with_four_algo(seed, problem): question = "Continue Peaks" iterations = [1, 500, 1000, 1250, 1500, 1750, 2000, 2250, 2500, 2750, 3000, 3500, 4000] fitness_list = [] mean_fitness_list = [] mean_time_list = [] #=================================================================================== # ============================= R H C============================================== # ================================================================================== fitness_score_RHC = [] time_score_RHC = [] for iter in iterations: start_time = time.time() best_state, best_fitness = mlrose.random_hill_climb(problem, max_attempts=10, max_iters=iter, random_state=seed) end_time = time.time() time_total = end_time - start_time fitness_score_RHC.append(best_fitness) time_score_RHC.append(time_total) mean_fitness_list.append(np.mean(fitness_score_RHC)) mean_time_list.append(np.mean(time_score_RHC)) fitness_list.append(fitness_score_RHC) print("RHC Good") #=================================================================================== # ============================= G A ============================================== # ================================================================================== fitness_score_GA = [] time_score_GA = [] for iter in iterations: start_time = time.time() best_state, best_fitness = mlrose.genetic_alg(problem, max_attempts=10, max_iters=iter, random_state=seed, pop_size=80, mutation_prob=0.1) end_time = time.time() time_total = end_time - start_time fitness_score_GA.append(best_fitness) time_score_GA.append(time_total) mean_fitness_list.append(np.mean(fitness_score_GA)) mean_time_list.append(np.mean(time_score_GA)) fitness_list.append(fitness_score_GA) print("GA Good") # =================================================================================== # ============================= S A ============================================== # ================================================================================== fitness_score_SA = [] time_score_SA = [] for iter in iterations: start_time = time.time() schedule2 = mlrose.GeomDecay(init_temp=500, decay=0.99) best_state, best_fitness = mlrose.simulated_annealing(problem, max_attempts=10, max_iters=iter, random_state=seed, schedule=schedule2) print(iter) end_time = time.time() time_total = end_time - start_time fitness_score_SA.append(best_fitness) time_score_SA.append(time_total) print("SA GOOD") mean_fitness_list.append(np.mean(fitness_score_SA)) mean_time_list.append(np.mean(time_score_SA)) fitness_list.append(fitness_score_SA) # =================================================================================== # ============================= MIMIC ============================================== # ================================================================================== print("mimic in ") fitness_score_MIMIC = [] time_score_MIMIC = [] for iter in iterations: start_time = time.time() best_state, best_fitness = mlrose.mimic(problem, max_attempts=10, max_iters=iter, random_state=seed, pop_size=100, keep_pct=0.1) print(iter) end_time = time.time() time_total = end_time - start_time fitness_score_MIMIC.append(best_fitness) time_score_MIMIC.append(time_total) mean_fitness_list.append(np.mean(fitness_score_MIMIC)) mean_time_list.append(np.mean(time_score_MIMIC)) fitness_list.append(fitness_score_MIMIC) print("mimic out ") # =================================================================================== # ============================= PLOT THE FINAL CURVE ============================================== # ================================================================================== print("curve in") algorithms = ["RHC", "GA", "SA", "MIMIC"] algorithm_compare(fitness_list, algorithms, question, iterations) mean_time_compare(mean_time_list, algorithms, question) score_compare(mean_fitness_list, algorithms, question) print("curve out")
def __discrete_bit_size_problems(problem, algorithm, length, max_iter, max_attempt, init_state, edges=None, coords=None): if problem == 'fourpeaks': __fit = mlrose.FourPeaks() __problem = mlrose.DiscreteOpt(length=length, fitness_fn=__fit, maximize=True, max_val=2) elif problem == 'kcolor': __fit = mlrose.MaxKColor(edges=edges) __problem = mlrose.DiscreteOpt(length=length, fitness_fn=__fit, maximize=True) elif problem == 'flipflop': __fit = mlrose.OneMax() __problem = mlrose.DiscreteOpt(length=length, fitness_fn=__fit, maximize=True, max_val=2) elif problem == 'continouspeaks': __fit = mlrose.ContinuousPeaks() __problem = mlrose.DiscreteOpt(length=length, fitness_fn=__fit, maximize=True, max_val=2) elif problem == 'travellingsales': __fit = mlrose.TravellingSales(coords=coords) __problem = mlrose.TSPOpt(length=length, fitness_fn=__fit, maximize=False) if algorithm == 'random_hill_climb': start_time = time.time() best_state, best_fitness, best_curve = mlrose.random_hill_climb( __problem, max_iters=max_iter, max_attempts=max_attempt, init_state=init_state, curve=True) end_time = time.time() - start_time elif algorithm == 'simulated_annealing': start_time = time.time() best_state, best_fitness, best_curve = mlrose.simulated_annealing( __problem, max_iters=max_iter, max_attempts=max_attempt, init_state=init_state, curve=True) end_time = time.time() - start_time elif algorithm == 'genetic_alg': start_time = time.time() best_state, best_fitness, best_curve = mlrose.genetic_alg( __problem, max_iters=max_iter, max_attempts=max_attempt, curve=True) end_time = time.time() - start_time elif algorithm == 'mimic': start_time = time.time() best_state, best_fitness, best_curve = mlrose.mimic( __problem, max_iters=max_iter, max_attempts=max_attempt, curve=True) end_time = time.time() - start_time return best_fitness, end_time, best_curve
def process_tsp_with_four_algo(coor, seed, problem): iterations = [1, 10, 20, 30, 40, 50, 60, 70, 80, 90] iterations.extend([i for i in range(100, 3000, 50)]) fitness_list = [] mean_fitness_list = [] mean_time_list = [] #=================================================================================== # ============================= R H C============================================== # ================================================================================== fitness_score_RHC = [] time_score_RHC = [] for iter in iterations: start_time = time.time() best_state, best_fitness = mlrose.random_hill_climb(problem, max_attempts=10, max_iters=iter, random_state=seed) end_time = time.time() time_total = end_time - start_time fitness_score_RHC.append(best_fitness) time_score_RHC.append(time_total) mean_fitness_list.append(np.mean(fitness_score_RHC)) mean_time_list.append(np.mean(time_score_RHC)) fitness_list.append(fitness_score_RHC) #=================================================================================== # ============================= G A ============================================== # ================================================================================== fitness_score_GA = [] time_score_GA = [] for iter in iterations: start_time = time.time() best_state, best_fitness = mlrose.genetic_alg(problem, max_attempts=10, max_iters=iter, random_state=seed, pop_size=10, mutation_prob=0.1) end_time = time.time() time_total = end_time - start_time fitness_score_GA.append(best_fitness) time_score_GA.append(time_total) mean_fitness_list.append(np.mean(fitness_score_GA)) mean_time_list.append(np.mean(time_score_GA)) fitness_list.append(fitness_score_GA) # =================================================================================== # ============================= S A ============================================== # ================================================================================== fitness_score_SA = [] time_score_SA = [] for iter in iterations: start_time = time.time() schedule = mlrose.GeomDecay(init_temp=10, decay=0.5) best_state, best_fitness = mlrose.simulated_annealing( problem, max_attempts=10, max_iters=iter, random_state=seed, schedule=schedule) end_time = time.time() time_total = end_time - start_time fitness_score_SA.append(best_fitness) time_score_SA.append(time_total) mean_fitness_list.append(np.mean(fitness_score_SA)) mean_time_list.append(np.mean(time_score_SA)) fitness_list.append(fitness_score_SA) # =================================================================================== # ============================= MIMIC ============================================== # ================================================================================== fitness_score_MIMIC = [] time_score_MIMIC = [] for iter in iterations: start_time = time.time() best_state, best_fitness = mlrose.mimic(problem, max_attempts=10, max_iters=iter, random_state=seed, pop_size=10) end_time = time.time() time_total = end_time - start_time fitness_score_MIMIC.append(best_fitness) time_score_MIMIC.append(time_total) mean_fitness_list.append(np.mean(fitness_score_MIMIC)) mean_time_list.append(np.mean(time_score_MIMIC)) fitness_list.append(fitness_score_MIMIC) # =================================================================================== # ============================= PLOT THE FINAL CURVE ============================================== # ================================================================================== algorithms = ["RHC", "GA", "SA", "MIMIC"] algorithm_compare(fitness_list, algorithms, question, iterations) mean_time_compare(mean_time_list, algorithms, question) score_compare(mean_fitness_list, algorithms, question)
ideal_pop_size = mmc_df_run_stats[['Population Size']].iloc[mmc_df_run_stats[['Fitness']].idxmax()] # from the output of the experiment above return mmc_df_run_stats, mmc_df_run_curves, ideal_keep_prcnt, ideal_pop_size # Done on a complex example then hard coded optimized parameter value(s). # mmc_df_run_stats, mmc_df_run_curves, ideal_keep_prcnt, ideal_pop_size = opt_mimic_params() ideal_keep_prcnt = 0.5 # this came from the results of the experiment commented out, above. ideal_pop_size_mimic = 100 # this came from the results of the experiment commented out, above. mimic_best_state = [] mimic_best_fitness = [] mimic_convergence_time = [] for iter in iterations_range: start_time = timeit.default_timer() best_state, best_fitness, curve = mlrose.mimic(problem=problem, keep_pct=ideal_keep_prcnt, max_attempts=5000, max_iters=iter, pop_size=ideal_pop_size_mimic, curve=True) end_time = timeit.default_timer() convergence_time = (end_time - start_time) # seconds mimic_best_state.append(best_state) mimic_best_fitness.append(best_fitness) mimic_convergence_time.append(convergence_time) print('The fitness at the best state found using MIMIC is: ', max(mimic_best_fitness)) #======= Plots for all individual learners==========# # Random Hill Climbing fig1, ax1 = plt.subplots() ax1.title.set_text("%s Flipflop, Tuned Random Hill Climbing" %(num_bits)) ax2 = ax1.twinx() ax1.plot(iterations_range, rhc_best_fitness, 'r-')
run_result = (complexity, "GA", run_time, best_fitness, len(curve), func_calls) print(run_result) results_list.append(run_result) # MIMIC mimic_max_attempts = 500 mimic_max_iters = np.inf mimic_pop_size = 2000 mimic_keep_pct = 0.2 start_time = time.perf_counter() _, best_fitness, curve = mlrose.mimic(problem, pop_size=mimic_pop_size, keep_pct=mimic_keep_pct, max_attempts=mimic_max_attempts, max_iters=mimic_max_iters, curve=True, random_state=SEED, fast_mimic=True) run_time = time.perf_counter() - start_time func_calls = problem.get_function_calls() problem.reset_function_calls() # don't forget to reset before the next run run_result = (complexity, "MIMIC", run_time, best_fitness, len(curve), func_calls) print(run_result) results_list.append(run_result) # compile & save results df_results = pd.DataFrame.from_records(results_list, columns=labels) df_results.to_excel(os.path.join(OUTPUT_DIRECTORY, EXPERIMENT_NAME + '.xlsx'))
def run_knapsack(): if not os.path.exists('./output/Knapsack/'): os.mkdir('./output/Knapsack/') # TODO Write state regeneration functions as lamdas logger = logging.getLogger(__name__) problem_size = 25 prob_size_int = int(problem_size) weights = [int(np.random.randint(1, prob_size_int/2)) for _ in range(prob_size_int)] values = [int(np.random.randint(1, prob_size_int/2)) for _ in range(prob_size_int)] flip_fit = mlrose.Knapsack(weights, values) flop_state_gen = lambda: np.random.randint(0, 1, size=prob_size_int) init_state = flop_state_gen() problem = mlrose.DiscreteOpt(length=prob_size_int, fitness_fn=flip_fit, maximize=True, max_val=2) all_results = {} print("Running simulated annealing montecarlos") sa_results, sa_timing = sim_annealing_runner(problem, init_state, state_regenerator=flop_state_gen) plot_montecarlo_sensitivity('Knapsack', 'sim_anneal', sa_results) plot_montecarlo_sensitivity('Knapsack', 'sim_anneal_timing', sa_timing) all_results['SA'] = [sa_results, sa_timing] print("Running random hill montecarlos") rhc_results, rhc_timing = rhc_runner(problem, init_state, state_regenerator=flop_state_gen) plot_montecarlo_sensitivity('Knapsack', 'rhc', rhc_results) plot_montecarlo_sensitivity('Knapsack', 'rhc_timing', sa_timing) all_results['RHC'] = [rhc_results, rhc_timing] print("Running genetic algorithm montecarlos") ga_results, ga_timing = ga_runner(problem, init_state, state_regenerator=flop_state_gen) plot_montecarlo_sensitivity('Knapsack', 'ga', ga_results) plot_montecarlo_sensitivity('Knapsack', 'ga_timing', ga_timing) all_results['GA'] = [ga_results, ga_timing] print("Running MIMIC montecarlos") mimic_results, mimic_timing = mimic_runner(problem, init_state, state_regenerator=flop_state_gen) plot_montecarlo_sensitivity('Knapsack', 'mimic', mimic_results) plot_montecarlo_sensitivity('Knapsack', 'mimic_timing', mimic_timing) all_results['MIMIC'] = [mimic_results, mimic_timing] with open('./output/Knapsack/flipflip_data.pickle', 'wb') as handle: pickle.dump(all_results, handle, protocol=pickle.HIGHEST_PROTOCOL) problem_size_space = np.linspace(5, 80, 20, dtype=int) best_fit_dict = {} best_fit_dict['Problem Size'] = problem_size_space best_fit_dict['Random Hill Climbing'] = [] best_fit_dict['Simulated Annealing'] = [] best_fit_dict['Genetic Algorithm'] = [] best_fit_dict['MIMIC'] = [] times = {} times['Problem Size'] = problem_size_space times['Random Hill Climbing'] = [] times['Simulated Annealing'] = [] times['Genetic Algorithm'] = [] times['MIMIC'] = [] fits_per_iteration = {} fits_per_iteration['Random Hill Climbing'] = [] fits_per_iteration['Simulated Annealing'] = [] fits_per_iteration['Genetic Algorithm'] = [] fits_per_iteration['MIMIC'] = [] for prob_size in problem_size_space: logger.info("---- Problem size: " + str(prob_size) + " ----") prob_size_int = int(prob_size) weights = [int(np.random.randint(1, prob_size/2)) for _ in range(prob_size_int)] values = [int(np.random.randint(1, prob_size/2)) for _ in range(prob_size_int)] flip_fit = mlrose.Knapsack(weights, values, max_weight_pct=0.5) flop_state_gen = lambda: np.random.randint(0, 1, size=prob_size_int) init_state = flop_state_gen() problem = mlrose.DiscreteOpt(length=prob_size_int, fitness_fn=flip_fit, maximize=True, max_val=2) start = datetime.now() _, best_fitness_sa, fit_array_sa = mlrose.simulated_annealing(problem, schedule=mlrose.ExpDecay(exp_const=.0001, init_temp=5.), max_attempts=100, max_iters=10000, init_state=init_state, track_fits=True) best_fit_dict['Simulated Annealing'].append(best_fitness_sa) end = datetime.now() times['Simulated Annealing'].append((end-start).total_seconds()) start = datetime.now() _, best_fitness_rhc, fit_array_rhc = mlrose.random_hill_climb(problem, max_attempts=100, max_iters=10000, restarts=50, track_fits=True) best_fit_dict['Random Hill Climbing'].append(best_fitness_rhc) end = datetime.now() times['Random Hill Climbing'].append((end-start).total_seconds()) start = datetime.now() _, best_fitness_ga, fit_array_ga = mlrose.genetic_alg(problem, pop_size=prob_size_int*5, mutation_prob=.2, max_attempts=200, track_fits=True) best_fit_dict['Genetic Algorithm'].append(best_fitness_ga) end = datetime.now() times['Genetic Algorithm'].append((end-start).total_seconds()) start = datetime.now() _, best_fitness_mimic, fit_array_mimic = mlrose.mimic(problem, pop_size=prob_size_int*5, keep_pct=.1, max_attempts=200, track_fits=True) best_fit_dict['MIMIC'].append(best_fitness_mimic) end = datetime.now() times['MIMIC'].append((end-start).total_seconds()) # For the last fit that occurs, save off the fit arrays that are generated. We will plot fitness/iteration. fits_per_iteration['Random Hill Climbing'] = fit_array_rhc fits_per_iteration['Simulated Annealing'] = fit_array_sa fits_per_iteration['Genetic Algorithm'] = fit_array_ga fits_per_iteration['MIMIC'] = fit_array_mimic fit_frame = pd.DataFrame.from_dict(best_fit_dict, orient='index').transpose() # fit_frame.pop('Unnamed: 0') # idk why this shows up. time_frame = pd.DataFrame.from_dict(times, orient='index').transpose() # time_frame.pop('Unnamed: 0') # idk why this shows up. fit_iteration_frame = pd.DataFrame.from_dict(fits_per_iteration, orient='index').transpose() fit_frame.to_csv('./output/Knapsack/problem_size_fit.csv') time_frame.to_csv('./output/Knapsack/problem_size_time.csv') fit_iteration_frame.to_csv('./output/Knapsack/fit_per_iteration.csv')
def run_cpeaks(): # If the output/Cpeaks directory doesn't exist, create it. #if not os.path.exists('./output/CPeaks/'): # os.mkdir('./output/CPeaks/') problem_size = 50 peaks_fit = mlrose.ContinuousPeaks(t_pct=.1) cpeaks_state_gen = lambda: np.random.randint(2, size=problem_size) init_state = cpeaks_state_gen() problem = mlrose.DiscreteOpt(length=problem_size, fitness_fn=peaks_fit, maximize=True, max_val=2) all_results = {} """ print("Running simulated annealing montecarlos") sa_results, sa_timing = sim_annealing_runner(problem) sa_best_params = plot_montecarlo_sensitivity('CPeaks', 'sim_anneal', sa_results) plot_montecarlo_sensitivity('CPeaks', 'sim_anneal_timing', sa_timing) all_results['SA'] = [sa_results, sa_timing] print("Running random hill montecarlos") rhc_results, rhc_timing = rhc_runner(problem) rhc_best_params = plot_montecarlo_sensitivity('CPeaks', 'rhc', rhc_results) plot_montecarlo_sensitivity('CPeaks', 'rhc_timing', sa_timing) all_results['RHC'] = [rhc_results, rhc_timing] print("Running genetic algorithm montecarlos") ga_results, ga_timing = ga_runner(problem, init_state) ga_best_params = plot_montecarlo_sensitivity('CPeaks', 'ga', ga_results) plot_montecarlo_sensitivity('CPeaks', 'ga_timing', ga_timing) all_results['GA'] = [ga_results, ga_timing] print("Running MIMIC montecarlos") mimic_results, mimic_timing = mimic_runner(problem, init_state) MIMC_best_params = plot_montecarlo_sensitivity('CPeaks', 'mimic', mimic_results) plot_montecarlo_sensitivity('CPeaks', 'mimic_timing', mimic_timing) all_results['MIMIC'] = [mimic_results, mimic_timing] """ with open('./output/CPeaks/cpeaks_data.pickle', 'wb') as handle: pickle.dump(all_results, handle, protocol=pickle.HIGHEST_PROTOCOL) problem_size_space = np.linspace(10, 100, 20, dtype=int) best_fit_dict = {} best_fit_dict['Problem Size'] = problem_size_space best_fit_dict['Random Hill Climbing'] = [] best_fit_dict['Simulated Annealing'] = [] best_fit_dict['Genetic Algorithm'] = [] best_fit_dict['MIMIC'] = [] times = {} times['Problem Size'] = problem_size_space times['Random Hill Climbing'] = [] times['Simulated Annealing'] = [] times['Genetic Algorithm'] = [] times['MIMIC'] = [] for prob_size in problem_size_space: logger.info("---- Problem size: " + str(prob_size) + " ----") prob_size_int = int(prob_size) peaks_fit = mlrose.ContinuousPeaks(t_pct=.2) problem = mlrose.DiscreteOpt(length=prob_size_int, fitness_fn=peaks_fit, maximize=True, max_val=2) cpeaks_state_gen = lambda: np.random.randint(2, size=prob_size_int) init_state = cpeaks_state_gen() start = datetime.now() best_stats_sa, best_fitness_sa, fitness_curve_sa = mlrose.simulated_annealing( problem, schedule=mlrose.ExpDecay(exp_const=.201, init_temp=3.6, min_temp=.101), max_attempts=310, max_iters=1100, curve=True) best_fit_dict['Simulated Annealing'].append(best_fitness_sa) end = datetime.now() times['Simulated Annealing'].append((end - start).total_seconds()) start = datetime.now() best_state_rhc, best_fitness_rhc, fitness_curve_rhc = mlrose.random_hill_climb( problem, max_attempts=110, max_iters=1100, restarts=80, curve=True) best_fit_dict['Random Hill Climbing'].append(best_fitness_rhc) end = datetime.now() times['Random Hill Climbing'].append((end - start).total_seconds()) start = datetime.now() best_state_ga, best_fitness_ga, fitness_curve_ga = mlrose.genetic_alg( problem, pop_size=132, mutation_prob=.001, max_attempts=210, max_iters=1100, curve=True) best_fit_dict['Genetic Algorithm'].append(best_fitness_ga) end = datetime.now() times['Genetic Algorithm'].append((end - start).total_seconds()) start = datetime.now() best_state_mimc, best_fitness_mimic, fitness_curve_mimic = mlrose.mimic( problem, pop_size=187, keep_pct=.21, max_attempts=10, max_iters=1100, curve=True) best_fit_dict['MIMIC'].append(best_fitness_mimic) end = datetime.now() times['MIMIC'].append((end - start).total_seconds()) fits_per_iteration = {} fits_per_iteration['Random Hill Climbing'] = fitness_curve_rhc fits_per_iteration['Simulated Annealing'] = fitness_curve_sa fits_per_iteration['Genetic Algorithm'] = fitness_curve_ga fits_per_iteration['MIMIC'] = fitness_curve_mimic fit_frame = pd.DataFrame.from_dict(best_fit_dict, orient='index').transpose() # fit_frame.pop('Unnamed: 0') # idk why this shows up. time_frame = pd.DataFrame.from_dict(times, orient='index').transpose() # time_frame.pop('Unnamed: 0') # idk why this shows up. fit_iteration_frame = pd.DataFrame.from_dict(fits_per_iteration, orient='index').transpose() fit_frame.to_csv('./output/CPeaks/problem_size_fit.csv') time_frame.to_csv('./output/CPeaks/problem_size_time.csv') fit_iteration_frame.to_csv('./output/CPeaks/fit_per_iteration.csv')
def fit(K, length, fitness): problem = mlrose.DiscreteOpt(length=length, fitness_fn=fitness, maximize=False, max_val=K) iterations = [10, 50, 100, 200, 400, 800, 1600, 3200] RHC, SA, GA, MM = ([], [], [], []) time_RHC, time_SA, time_GA, time_MM = ([], [], [], []) for iter in iterations: print("max iterations = " + str(iter)) start_time = time.time() best_fitness = 0 for times in range(10): best_state, best_fitness = mlrose.random_hill_climb( problem, max_attempts=10, max_iters=iter, restarts=0, init_state=np.zeros((length, ), dtype=np.int)) best_fitness = min(best_fitness, best_fitness) #print(best_state) RHC.append(best_fitness) print(best_fitness) time_RHC.append((time.time() - start_time) / 10) start_time = time.time() best_fitness = 0 for times in range(10): best_state, best_fitness = mlrose.simulated_annealing( problem, schedule=mlrose.GeomDecay(), max_attempts=10, max_iters=iter, init_state=np.zeros((length, ), dtype=np.int)) best_fitness = min(best_fitness, best_fitness) #print(best_state) SA.append(best_fitness) print(best_fitness) time_SA.append((time.time() - start_time) / 10) start_time = time.time() best_fitness = 0 best_state, best_fitness = mlrose.genetic_alg(problem, pop_size=200, mutation_prob=0.1, max_attempts=10, max_iters=iter) #print(best_state) print(best_fitness) GA.append(best_fitness) time_GA.append((time.time() - start_time)) start_time = time.time() best_fitness = 0 best_state, best_fitness = mlrose.mimic(problem, pop_size=200, keep_pct=0.2, max_attempts=10, max_iters=iter) #print(best_state) print(best_fitness) MM.append(best_fitness) time_MM.append((time.time() - start_time)) plot(RHC, SA, GA, MM, time_RHC, time_SA, time_GA, time_MM, iterations, K) filewrite_array("iterations:", iterations) filewrite_array("Fitness(RHC):", RHC) filewrite_array("Fitness(SA):", SA) filewrite_array("Fitness(GA):", GA) filewrite_array("Fitness(MM):", MM) filewrite_array("Fitness(time_RHC):", time_RHC) filewrite_array("Fitness(time_SA):", time_SA) filewrite_array("Fitness(time_GA):", time_GA) filewrite_array("Fitness(time_MM):", time_MM)
def run_flipflop(): # If the output/FlipFlop directory doesn't exist, create it. if not os.path.exists('./output/FlipFlop/'): os.mkdir('./output/FlipFlop/') problem_size = 50 logger = logging.getLogger(__name__) flip_fit = mlrose.FlipFlop() flop_state_gen = lambda: np.random.randint(2, size=problem_size) init_state = flop_state_gen() problem = mlrose.DiscreteOpt(length=problem_size, fitness_fn=flip_fit) problem2 = mlrose.DiscreteOpt(length=problem_size, fitness_fn=flip_fit) problem3 = mlrose.DiscreteOpt(length=problem_size, fitness_fn=flip_fit) problem4 = mlrose.DiscreteOpt(length=problem_size, fitness_fn=flip_fit) all_results = {} """ print("Running random hill montecarlos") rhc_results, rhc_timing = rhc_runner(problem) rhc_best_params =plot_montecarlo_sensitivity('FlipFlop', 'rhc', rhc_results) plot_montecarlo_sensitivity('FlipFlop', 'rhc_timing', rhc_timing) all_results['RHC'] = [rhc_results, rhc_timing] print("Running simulated annealing montecarlos") sa_results, sa_timing = sim_annealing_runner(problem2) sa_best_param = plot_montecarlo_sensitivity('FlipFlop', 'sim_anneal', sa_results) plot_montecarlo_sensitivity('FlipFlop', 'sim_anneal_timing', sa_timing) all_results['SA'] = [sa_results, sa_timing] print("Running genetic algorithm montecarlos") ga_results, ga_timing = ga_runner(problem3, init_state) ga_best_param = plot_montecarlo_sensitivity('FlipFlop', 'ga', ga_results) plot_montecarlo_sensitivity('FlipFlop', 'ga_timing', ga_timing) all_results['GA'] = [ga_results, ga_timing] print("Running MIMIC montecarlos") mimic_results, mimic_timing = mimic_runner(problem4, init_state) MIMIC_best_param = plot_montecarlo_sensitivity('FlipFlop', 'mimic', mimic_results) plot_montecarlo_sensitivity('FlipFlop', 'mimic_timing', mimic_timing) all_results['MIMIC'] = [mimic_results, mimic_timing] """ with open('./output/FlipFlop/flipflip_data.pickle', 'wb') as handle: pickle.dump(all_results, handle, protocol=pickle.HIGHEST_PROTOCOL) problem_size_space = np.linspace(10, 125, 10, dtype=int) best_fit_dict = {} best_fit_dict['Problem Size'] = problem_size_space best_fit_dict['Random Hill Climbing'] = [] best_fit_dict['Simulated Annealing'] = [] best_fit_dict['Genetic Algorithm'] = [] best_fit_dict['MIMIC'] = [] times = {} times['Problem Size'] = problem_size_space times['Random Hill Climbing'] = [] times['Simulated Annealing'] = [] times['Genetic Algorithm'] = [] times['MIMIC'] = [] fits_per_iteration = {} fits_per_iteration['Random Hill Climbing'] = [] fits_per_iteration['Simulated Annealing'] = [] fits_per_iteration['Genetic Algorithm'] = [] fits_per_iteration['MIMIC'] = [] for prob_size in problem_size_space: logger.info("---- Problem size: " + str(prob_size) + " ----") prob_size_int = int(prob_size) flip_fit = mlrose.FlipFlop() flop_state_gen = lambda: np.random.randint(2, size=prob_size_int) init_state = flop_state_gen() problem = mlrose.DiscreteOpt(length=prob_size_int, fitness_fn=flip_fit, maximize=True, max_val=2) start = datetime.now() best_state_sa, best_fitness_sa, fitness_curve_sa = mlrose.simulated_annealing( problem, schedule=mlrose.ExpDecay(exp_const=.401, init_temp=0.6, min_temp=0.101), max_attempts=110, max_iters=1100, curve=True) best_fit_dict['Simulated Annealing'].append(best_fitness_sa) end = datetime.now() times['Simulated Annealing'].append((end - start).total_seconds()) start = datetime.now() best_state_rhc, best_fitness_rhc, fitness_curve_rhc = mlrose.random_hill_climb( problem, max_attempts=410, max_iters=1100, restarts=40, curve=True) best_fit_dict['Random Hill Climbing'].append(best_fitness_rhc) end = datetime.now() times['Random Hill Climbing'].append((end - start).total_seconds()) start = datetime.now() best_state_ga, best_fitness_ga, fitness_curve_ga = mlrose.genetic_alg( problem, pop_size=174, mutation_prob=.001, max_attempts=410, max_iters=1000, curve=True) best_fit_dict['Genetic Algorithm'].append(best_fitness_ga) end = datetime.now() times['Genetic Algorithm'].append((end - start).total_seconds()) start = datetime.now() best_state_mimic, best_fitness_mimic, fitness_curve_mimic = mlrose.mimic( problem, pop_size=252, keep_pct=.21, max_attempts=30, max_iters=1100, curve=True) best_fit_dict['MIMIC'].append(best_fitness_mimic) end = datetime.now() times['MIMIC'].append((end - start).total_seconds()) # For the last fit that occurs, save off the fit arrays that are generated. We will plot fitness/iteration. fits_per_iteration['Random Hill Climbing'] = fitness_curve_rhc fits_per_iteration['Simulated Annealing'] = fitness_curve_sa fits_per_iteration['Genetic Algorithm'] = fitness_curve_ga fits_per_iteration['MIMIC'] = fitness_curve_mimic fit_frame = pd.DataFrame.from_dict(best_fit_dict, orient='index').transpose() # fit_frame.pop('Unnamed: 0') # idk why this shows up. time_frame = pd.DataFrame.from_dict(times, orient='index').transpose() # time_frame.pop('Unnamed: 0') # idk why this shows up. fit_iteration_frame = pd.DataFrame.from_dict(fits_per_iteration, orient='index').transpose() fit_frame.to_csv('./output/FlipFlop/problem_size_fit.csv') time_frame.to_csv('./output/FlipFlop/problem_size_time.csv') fit_iteration_frame.to_csv('./output/FlipFlop/fit_per_iteration.csv')
def solve_problem(alg, prob, rs, b, attempts, verbose): if verbose: print('\n***', alg, '-', b, 'bits ***\n') t0 = time.time() if alg == 'Simulated Annealing': # Define decay schedule. https://mlrose.readthedocs.io/en/stable/source/decay.html # schedule = mlrose.GeomDecay(init_temp=1.0, decay=0.99, min_temp=0.001) # schedule = mlrose.ArithDecay(init_temp=1.0, decay=0.0001, min_temp=0.001) # schedule = mlrose.ExpDecay(init_temp=1.0, exp_const=0.005, min_temp=0.001) schedule = mlrose.ExpDecay() # init_state = np.array([0, 0, 0, 0, 1, 1, 1, 1]) # Define initial state state, fit, curve = mlrose.simulated_annealing(prob, schedule=schedule, max_attempts=attempts, max_iters=np.inf, init_state=None, curve=True, random_state=rs) elif alg == 'Genetic Algorithm': state, fit, curve = mlrose.genetic_alg(prob, pop_size=1000, mutation_prob=0.1, max_attempts=attempts, max_iters=np.inf, curve=True, random_state=rs) elif alg == 'Random Hill Climb': state, fit, curve = mlrose.random_hill_climb(prob, max_attempts=attempts, max_iters=np.inf, restarts=0, init_state=None, curve=True, random_state=rs) elif alg == 'MIMIC': state, fit, curve = mlrose.mimic(prob, pop_size=500, keep_pct=0.2, max_attempts=attempts, max_iters=np.inf, curve=True, random_state=rs) else: state, fit, curve = 0, 0, 0 t1 = time.time() runtime = t1 - t0 if verbose: # print("Best State:", state) print("Best Fitness:", fit) print("Number of fitness evaluations:", len(curve)) np.savetxt("fitness_curve.csv", curve, delimiter=",") print('Solve problem run time: %0.3fs' % runtime) return state, fit, curve, runtime
mutation_prob=0.2, max_attempts=100) t9 = time.time() - start start = time.time() best_state29, best_fitness29 = mlrose.genetic_alg(problem_fit10, mutation_prob=0.2, max_attempts=100) t10 = time.time() - start time1 = [t1, t2, t3, t4, t5, t6, t7, t8, t9, t10] #best_state10, best_fitness10 = mlrose.genetic_alg(problem_fit10, mutation_prob = 0.2, max_attempts = 100) start = time.time() best_state10, best_fitness10 = mlrose.mimic(problem_fit1, pop_size=200, keep_pct=0.3, max_attempts=10, max_iters=1000) t21 = time.time() - start start = time.time() best_state11, best_fitness11 = mlrose.mimic(problem_fit2, pop_size=200, keep_pct=0.3, max_attempts=10, max_iters=1000) t22 = time.time() - start start = time.time() best_state12, best_fitness12 = mlrose.mimic(problem_fit3, pop_size=200, keep_pct=0.3, max_attempts=10,
# Solve problem using simulated annealing start = clock() best_SA_state, best_SA_fitness, curve = mlrose.simulated_annealing(problem, max_attempts = 100, max_iters = iter, init_state = None,curve=True, random_state = 1) SA_timings.append(clock() - start) # genetic_alg(problem, pop_size=200, mutation_prob=0.1, max_attempts=10, max_iters=inf, curve=False, random_state=None) start = clock() best_GA_state, best_GA_fitness = mlrose.genetic_alg(problem, mutation_prob = 0.2, max_attempts = 10, max_iters = iter, random_state = 1) GA_timings.append(clock() - start) # MIMIC start = clock() best_Mimic_state, best_Mimic_fitness = mlrose.mimic(problem, pop_size=200, keep_pct=0.2, max_attempts=10, max_iters=iter, curve=False, random_state=None) MIMIC_timings.append(clock() - start) RHC_iterations.append(best_RHC_fitness) SA_iterations.append(best_SA_fitness) GA_iterations.append(best_GA_fitness) MIMIC_iterations.append(best_Mimic_fitness) plt.figure() ticks = range(len(iterations)) print(GA_iterations) print(MIMIC_iterations) print(best_Mimic_state) # Plot mean accuracy scores for training and test sets lw = 2
#sprint(fitness_two.evaluate(state)) best_state_two, best_fitness_two = ml.genetic_alg(opt_two, random_state = 2) #best_state_two, best_fitness_two = ml.random_hill_climb(opt_two, random_state = 2) best_state_two, best_fitness_two = ml.simulated_annealing(opt_two, max_iters=1, random_state = 2) #best_state_two, best_fitness_two = ml.mimic(opt_two, max_iters=1, random_state = 2) print(best_state_two) print(best_fitness_two) #plt.scatter([0,1,0,1,2,3],[1,2,2,3,3,4]) #plt.savefig("test.png") edges = [(0, 1), (0, 2), (0, 4), (1, 3), (2, 0), (2, 3), (3, 4)] fitness_three = ml.MaxKColor(edges) opt_three = ml.DiscreteOpt(length=5, fitness_fn=fitness_three, maximize=False) #best_state_three, best_fitness_three = ml.genetic_alg(opt_three, random_state = 2) #best_state_three, best_fitness_three = ml.random_hill_climb(opt_three, random_state = 2) best_state_three, best_fitness_three = ml.simulated_annealing(opt_three, random_state = 2) best_state_three, best_fitness_three = ml.mimic(opt_three, max_iters=1, random_state = 2) print(fitness_three.evaluate([1, 0, 0, 1, 0])) print(best_state_three) print(best_fitness_three)
def main(): np.random.seed(0) i_s = np.random.randint(2, size=50) fitness = mlrose.SixPeaks() problem = mlrose.DiscreteOpt(length=len(i_s), fitness_fn=fitness, maximize=True, max_val=2) # Define decay schedule schedule = mlrose.ExpDecay() # Define initial state init_state = i_s x_s = [] y_s = [] z_s = ['RHC', 'SA', 'GA', 'MIMIC'] w_s = [] print('begin hill climb') # Solve problem using simulated annealing best_state, best_fitness, learning_curve, timing_curve = mlrose.random_hill_climb( problem, max_attempts=10000, curve=True, random_state=1) print(best_state) print(best_fitness) x_s.append(np.arange(0, len(learning_curve))) y_s.append(learning_curve) w_s.append(timing_curve) print('begin SA') best_state, best_fitness, learning_curve, timing_curve = mlrose.simulated_annealing( problem, max_attempts=250, max_iters=250, schedule=schedule, init_state=init_state, curve=True, random_state=1) print(best_state) print(best_fitness) x_s.append(np.arange(0, len(learning_curve))) y_s.append(learning_curve) w_s.append(timing_curve) print('begin GA') best_state, best_fitness, learning_curve, timing_curve = mlrose.genetic_alg( problem, pop_size=200, mutation_prob=0.1, max_attempts=250, max_iters=250, curve=True, random_state=1) print(best_state) print(best_fitness) x_s.append(np.arange(0, len(learning_curve))) y_s.append(learning_curve) w_s.append(timing_curve) print('begin MIMIC') best_state, best_fitness, learning_curve, timing_curve = mlrose.mimic( problem, pop_size=250, keep_pct=0.2, max_attempts=250, max_iters=250, curve=True, random_state=1, fast_mimic=True) print(best_state) print(best_fitness) x_s.append(np.arange(0, len(learning_curve))) y_s.append(learning_curve) w_s.append(timing_curve) for x, y, z in zip(x_s, y_s, z_s): plt.plot(x, y, label=z) plt.legend() plt.title('Randomized Optimization Iterations vs Fitness Function Value') plt.xlabel('Function iteration count') plt.ylabel('Fitness function value') plt.show() plt.clf() for x, w, z in zip(x_s, w_s, z_s): plt.plot(x, w, label=z) plt.legend() plt.title('Randomized Optimization Time vs Fitness Function Value') plt.xlabel('Function iteration count') plt.ylabel('Time in Second') plt.show()
def optimizationFunction(n,iMin, iMax, iStep, jMin, jMax, jStep): np.random.seed(100) optScenarios = ['Knap Sack', 'Four Peaks', 'K - Colors'] for x in range(3): if x == 0: weights = np.random.randint(1,10,size=n) #values = np.random.randint(1,50,size=n) values = [i for i in range(1,n+1)] max_weight_pct = 0.5 fitnessFunction = mlrose.Knapsack(weights, values, max_weight_pct) optModel = mlrose.DiscreteOpt(len(values), fitness_fn = fitnessFunction, maximize=True) elif x == 1: inp = [0] * int(n/2) + [1]*int(n - int(n/2)) np.random.shuffle(inp) fitnessFunction = mlrose.FourPeaks(t_pct = 0.15) optModel = mlrose.DiscreteOpt(len(inp), fitness_fn = fitnessFunction, maximize =True) elif x == 2: edges = [(np.random.randint(0,n), np.random.randint(0,n)) for ab in range(n)] fitnessFunction = mlrose.MaxKColor(edges) optModel = mlrose.DiscreteOpt(len(edges), fitness_fn = fitnessFunction, maximize =True) decay = mlrose.ExpDecay() optResults = {'iterations':[],'attempts':[],'fitness':[],'time':[], 'optimization':[]} for i in range(iMin,iMax,iStep): for j in range(jMin,jMax,jStep): start_time = timer() best_state, best_fitness = mlrose.random_hill_climb(optModel, max_attempts = j, max_iters = i, random_state=100) opt_time = timer() - start_time optResults['iterations'].append(i) optResults['attempts'].append(j) optResults['fitness'].append(best_fitness) optResults['time'].append(opt_time) optResults['optimization'].append('Random Hill') start_time = timer() best_state, best_fitness = mlrose.simulated_annealing(optModel, schedule=decay, max_attempts = j,max_iters = i,random_state=1000) opt_time = timer() - start_time optResults['iterations'].append(i) optResults['attempts'].append(j) optResults['fitness'].append(best_fitness) optResults['time'].append(opt_time) optResults['optimization'].append('Simulated Annealing') start_time = timer() best_state, best_fitness = mlrose.genetic_alg(optModel, pop_size=200, mutation_prob = 0.25, max_attempts = j, max_iters = i, random_state=5000) opt_time = timer() - start_time optResults['iterations'].append(i) optResults['attempts'].append(j) optResults['fitness'].append(best_fitness) optResults['time'].append(opt_time) optResults['optimization'].append('Genetic Algorithm') start_time = timer() best_state, best_fitness = mlrose.mimic(optModel, pop_size = 200, keep_pct = 0.3, max_attempts = j, max_iters = i, random_state=150) opt_time = timer() - start_time optResults['iterations'].append(i) optResults['attempts'].append(j) optResults['fitness'].append(best_fitness) optResults['time'].append(opt_time) optResults['optimization'].append('MIMIC') optResults = pd.DataFrame(optResults) plotGraphs(optResults,optScenarios[x])
main_total_iterations_mimic = [] main_opt_iterations_mimic = [] for y in range(10): best_fit_mimic = [] execution_times_mimic = [] total_iterations_mimic = [] opt_iterations_mimic = [] for x in range(2): start = time.time() opt = ml.DiscreteOpt((y * 6) + 6, fitness) #best_state, best_fitness, curve = ml.random_mimic_climb(opt, pop_size=(y*10)+10, max_iters=5, restarts = 0, curve=True, random_state = 2) best_state_mimic, best_fitness_mimic, curve_mimic = ml.mimic( opt, pop_size=(y * 6) + 6, max_attempts=10, max_iters=900, curve=True, random_state=2) end = time.time() best_fit_mimic.append(best_fitness_mimic) total_iterations_mimic.append(len(curve_mimic)) opt_iterations_mimic.append(np.argmax(curve_mimic)) if (len(sample_sizes) < 10 and x == 0): sample_sizes.append((y * 6) + 6) execution_times_mimic.append(end - start) #print("x = " + x) #print("y = " + y) main_best_fit_mimic.append(np.mean(best_fit_mimic))
elif params["algo"] == 1: # SA # Define decay schedule schedule = mlrose.ExpDecay() # Solve problem using simulated annealing best_state, best_fitness = mlrose.simulated_annealing( problem, schedule=schedule, max_attempts=max_atp, max_iters=max_iter, init_state=init_state) elif params["algo"] == 2: #GA # genetic_alg(problem, pop_size=200, mutation_prob=0.1, max_attempts=10, max_iters=inf, curve=False, random_state=None) best_state, best_fitness = mlrose.genetic_alg(problem, pop_size=100, mutation_prob=0.1, max_attempts=max_atp, max_iters=max_iter) best_state = [int(i) for i in best_state] else: #MIMIC # mimic(problem, pop_size=200, keep_pct=0.2, max_attempts=10, max_iters=inf, curve=False, random_state=None) best_state, best_fitness = mlrose.mimic(problem, pop_size=200, keep_pct=0.2, max_attempts=max_atp, max_iters=max_iter) best_fit_value = params["number"] * (params["number"] - 1) / 2 print('The best state found is: ', best_state) print('The fitness at the best state is: ', best_fitness / (best_fit_value))
def main(): name_of_exp = "K-Color" edges = [(0, 1), (0, 2), (0, 4), (1, 3), (2, 0), (2, 3), (3, 4)] fitness = mlrose.MaxKColor(edges) init_state = np.zeros(5) problem = mlrose.DiscreteOpt(length=5, fitness_fn=fitness, maximize=False, max_val=2) # Define decay schedule schedule = mlrose.ExpDecay() x_s = [] y_s = [] z_s = ['RHC', 'SA', 'GA', 'MIMIC'] w_s = [] max_val = 3.0 found_flag = False for restarts in np.arange(0, 5): if found_flag: break for max_iter_atts in np.arange(10, 1000, 10): if found_flag: break # Solve problem using simulated annealing best_state, best_fitness, learning_curve, timing_curve = mlrose.random_hill_climb(problem, max_attempts=int( max_iter_atts), max_iters=int(max_iter_atts), restarts=int(restarts), init_state=init_state, curve=True, random_state=1) if best_fitness >= max_val: x_s.append(np.arange(0, len(learning_curve))) y_s.append(learning_curve) w_s.append(timing_curve) print(best_state) print(best_fitness) print(max_iter_atts) print(restarts) found_flag = True found_flag = False for sched in [mlrose.ExpDecay(), mlrose.GeomDecay(), mlrose.ArithDecay()]: if found_flag: break for max_iter_atts in np.arange(10, 1000, 10): if found_flag: break best_state, best_fitness, learning_curve, timing_curve = mlrose.simulated_annealing(problem, max_attempts=int( max_iter_atts), max_iters=int( max_iter_atts), schedule=sched, init_state=init_state, curve=True, random_state=1) if best_fitness >= max_val: x_s.append(np.arange(0, len(learning_curve))) y_s.append(learning_curve) w_s.append(timing_curve) print(best_state) print(best_fitness) print(max_iter_atts) print(sched) found_flag = True found_flag = False for prob in np.arange(0.1, 1.1, 0.1): if found_flag: break for pop_size in np.arange(100, 5000, 100): if found_flag: break for max_iter_atts in np.arange(10, 1000, 10): if found_flag: break best_state, best_fitness, learning_curve, timing_curve = mlrose.genetic_alg(problem, pop_size=int(pop_size), mutation_prob=prob, max_attempts=int( max_iter_atts), max_iters=int( max_iter_atts), curve=True, random_state=1) if best_fitness >= max_val: x_s.append(np.arange(0, len(learning_curve))) y_s.append(learning_curve) w_s.append(timing_curve) print(best_state) print(best_fitness) print(max_iter_atts) print(prob) print(pop_size) found_flag = True found_flag = False for prob in np.arange(0.1, 1.1, 0.1): if found_flag: break for pop_size in np.arange(100, 5000, 100): if found_flag: break for max_iter_atts in np.arange(10, 1000, 10): if found_flag: break best_state, best_fitness, learning_curve, timing_curve = mlrose.mimic(problem, pop_size=int(pop_size), keep_pct=prob, max_attempts=int(max_iter_atts), max_iters=int(max_iter_atts), curve=True, random_state=1, fast_mimic=True) if best_fitness >= max_val: x_s.append(np.arange(0, len(learning_curve))) y_s.append(learning_curve) w_s.append(timing_curve) print(best_state) print(best_fitness) print(max_iter_atts) print(prob) print(pop_size) found_flag = True for x, y, z in zip(x_s, y_s, z_s): plt.plot(x, y, label=z) plt.legend() plt.title('Randomized Optimization Iterations vs Fitness Function Value for {}'.format(name_of_exp)) plt.xlabel('Function iteration count') plt.ylabel('Fitness function value') plt.show() plt.clf() for x, w, z in zip(x_s, w_s, z_s): plt.plot(x, w, label=z) plt.legend() plt.title('Randomized Optimization Time vs Fitness Function Value for {}'.format(name_of_exp)) plt.xlabel('Function iteration count') plt.ylabel('Time in Seconds') plt.show()
schedule = mlrose.GeomDecay(init_temp=3.0, decay=0.99, min_temp=0.001) # Define initial state init_state = np.array([0,1,2,3,4,5,6,7]) # Solve problem using simulated annealing start_sa = time.time() best_state, best_fitness, sa_curve = mlrose.simulated_annealing(problem, schedule = schedule, max_attempts = 800, max_iters = 1000, init_state = init_state, random_state = 1, curve=True) end_sa = time.time() sa_total_time = end_sa - start_sa start_mimic = time.time() best_state_2, best_fitness_2, curve = mlrose.mimic(problem, pop_size=150, keep_pct=0.1, max_attempts = 800, max_iters = 1000, curve=True, random_state = None, fast_mimic=True) end_mimic = time.time() mimic_total_time = end_mimic - start_mimic start_ga = time.time() best_state_3, best_fitness_3, ga_curve = mlrose.genetic_alg(problem, random_state = 0,mutation_prob=0.8,curve=True, max_attempts=800, max_iters=1000) end_ga = time.time() ga_total_time = end_ga - start_ga start_rhc = time.time() best_state_4, best_fitness_4, rhc_curve = mlrose.random_hill_climb(problem, max_attempts=500, max_iters=1000, restarts=5,curve=True, init_state=init_state) end_rhc = time.time() rhc_total_time = end_rhc - start_rhc
start_time = time.time() best_state1, best_fitness1 = mlrose.random_hill_climb(problem_fit, max_attempts=100, max_iters=100) start_time2 = time.time() best_state2, best_fitness2 = mlrose.simulated_annealing( problem_fit, schedule=mlrose.GeomDecay(), max_attempts=100, max_iters=100) start_time3 = time.time() best_state3, best_fitness3 = mlrose.genetic_alg(problem_fit, pop_size=200, mutation_prob=0.1, max_attempts=100, max_iters=100) start_time4 = time.time() best_state4, best_fitness4 = mlrose.mimic(problem_fit, pop_size=200, keep_pct=0.2, max_attempts=10, max_iters=100) print("Random Hill Climb OneMax Fitness Score:", best_fitness1) print("--- %s RH training seconds ---" % (time.time() - start_time)) print("Simulated Annealing OneMax Fitness Score:", best_fitness2) print("--- %s SA training seconds ---" % (time.time() - start_time2)) print("Genetic Algorithm OneMax Fitness Score:", best_fitness3) print("--- %s GA training seconds ---" % (time.time() - start_time3)) print("MIMIC Algorithm OneMax Fitness Score:", best_fitness4) print("--- %s MIMIC training seconds ---" % (time.time() - start_time4))
def mimic_runner(problem, state, gen_plots=True, state_regenerator=None): """ Runs the simulated annealing experiment on a given problem. Free variables are: Initial temperature Final temperature Decay rate # of attempts # of iterations """ problem_size = len(state) attempts = np.arange(25, 25, 1).astype(int) pop_size = np.arange(problem_size//4, problem_size * 6, problem_size//4).astype(int) percents = np.arange(.005, .3, .01) scoring_dict = {} timing_dict = {} attempts_scores = [] attempt_timing = [] # print("Running attempt sweep") for i, att in enumerate(attempts): best_fits = [] times = [] for i in MC_RUNS: init_state = state_regenerator() print("Running attempt sweep " + str(att) + ": " + str(i)) start = datetime.now() _, best_fitness = mlrose.mimic(problem, pop_size=problem_size, keep_pct=.3, max_attempts=int(att)) end = datetime.now() best_fits.append(best_fitness) times.append((end-start).total_seconds()) attempt_timing.append(times) attempts_scores.append(best_fits) scoring_dict['NumberofAttempts'] = pd.DataFrame(attempts_scores, columns=MC_RUNS, index=attempts) timing_dict['NumberofAttempts'] = pd.DataFrame(attempt_timing, columns=MC_RUNS, index=attempts) population_scores = [] population_timing = [] print("Running population size sweep") for i, psize in enumerate(pop_size): times = [] best_fits = [] for i in MC_RUNS: init_state = state_regenerator() print("Running population size sweep " + str(psize) + ": " + str(i)) start = datetime.now() _, best_fitness = mlrose.mimic(problem, pop_size=int(psize), keep_pct=.3, max_attempts=10) end = datetime.now() best_fits.append(best_fitness) times.append((end-start).total_seconds()) population_scores.append(best_fits) population_timing.append(times) scoring_dict['PopulationSize'] = pd.DataFrame(population_scores, columns=MC_RUNS, index=pop_size) timing_dict['PopulationSize'] = pd.DataFrame(population_timing, columns=MC_RUNS, index=pop_size) mutation_scores = [] print("Running mutation rate sweep") for i, prcnt in enumerate(percents): best_fits = [] for i in MC_RUNS: init_state = state_regenerator() print("Running percentage kept sweep " + str(prcnt) + ": " + str(i)) _, best_fitness = mlrose.mimic(problem, pop_size=problem_size*2, keep_pct=prcnt, max_attempts=20) best_fits.append(best_fitness) mutation_scores.append(best_fits) scoring_dict['PercentageKept'] = pd.DataFrame(mutation_scores, columns=MC_RUNS, index=percents) return scoring_dict, timing_dict
np.random.seed(123) weights = np.random.uniform(size=probSize) values = np.random.uniform(size=probSize) fitnessF = mlrose.Knapsack(weights=weights, values=values, max_weight_pct=thre) problemFit = mlrose.DiscreteOpt(length=probSize, fitness_fn=fitnessF, maximize=True, max_val=2) # max_val: number of unique values each element in the state vector can take. timeStart = time.time() best_state, best_fitness, fitness_curve = mlrose.mimic(problemFit, pop_size=popu, keep_pct=kepp, max_attempts=int(1e9), max_iters=maxIter, curve=True, random_state=rseed, fast_mimic=True) timeEnd = time.time() timeCost = timeEnd - timeStart timeCost = str(timeCost) best_state = ",".join(map(str, best_state)) fitness_curve = ",".join(map(str, fitness_curve)) rst = [timeCost, best_fitness, best_state, fitness_curve] fileName = ("output/MM-psiz-" + str(probSize) + "-thre-" + str(thre) + "-popu-" + str(popu) + "-kepp-" + str(kepp) + "-mxit-" + str(maxIter) + "-seed-" + str(rseed) + '-.txt') with open(fileName, 'w') as f: for item in rst:
GA_best_fitness.append(GA_fitness) GA_time_avg.append(GA_time) MIMIC_best_fitness = [] MIMIC_time_avg = [] for j in range(0, 5): print(j) MIMIC_fitness = [] MIMIC_time = [] for i in array: print(i) start = time.time() best_state, best_fitness, fitness_curve = mlrose.mimic( problem, pop_size=1000, keep_pct=0.2, max_attempts=200, max_iters=i) end = time.time() MIMIC_fitness.append(fitness.evaluate(best_state)) MIMIC_time.append(end - start) print(end - start) MIMIC_best_fitness.append(MIMIC_fitness) MIMIC_time_avg.append(MIMIC_time) GA_best_fitness = [77, 94, 93, 94, 95, 94, 96, 96] MIMIC_best_fitness = [80, 92, 94, 95, 95, 96, 96, 96] plt.figure(figsize=(12, 6)) plt.plot(array,
state, opt = mlrose.simulated_annealing(problem=popt, max_attempts=20) s = time.clock() sat.append(s - t) sao.append(opt) t = time.clock() state, opt = mlrose.genetic_alg(pop_size=i * 20, problem=popt, max_attempts=20) s = time.clock() gat.append(s - t) gao.append(opt) t = time.clock() state, opt = mlrose.mimic(pop_size=i * 20, problem=popt, max_attempts=20) s = time.clock() mmt.append(s - t) mmo.append(opt) plt.plot(bits, rhct, bits, sat, bits, gat, bits, mmt) plt.title("Knapsack Problem") plt.xlabel("Bit State Length") plt.ylabel("Time") plt.legend(["rhc", "sa", "ga", "mimic"]) plt.show() plt.plot(bits, rhco, bits, sao, bits, gao, bits, mmo) plt.title("Knapsack Problem") plt.xlabel("Bit State Length")
def test_mimic(self, title, max_attempts_range=[100], pop_range=[200], keep_pct_range=[0.2]): pop_len = range(len(pop_range)) mut_len = range(len(keep_pct_range)) i_pop = 0 i_mut = 0 color = 0 colors = ['k', 'b', 'g', 'r', 'c'] fig = plt.figure(figsize=(8, 12)) ax1 = fig.add_subplot(2, 1, 1, projection='3d') ax2 = fig.add_subplot(2, 1, 2, projection='3d') fig.suptitle(title + " MIMIC Algorithm") print(title + " MIMIC Algo") best = [0, 0, 0, 0] for m in max_attempts_range: fitness_arr = np.zeros((len(keep_pct_range), len(pop_range))) time_arr = np.zeros((len(keep_pct_range), len(pop_range))) i_pop = 0 for p in pop_range: i_mut = 0 for kp in keep_pct_range: start = time.time() best_state, best_fitness, curve = mlrose.mimic( self.problem_fit, pop_size=p, keep_pct=kp, max_attempts=math.ceil(m), max_iters=np.inf, curve=True) fitness_arr[i_mut][i_pop] = (best_fitness) time_arr[i_mut][i_pop] = (round(time.time() - start, 2)) if best_fitness > best[3]: best[0] = m best[1] = p best[2] = kp best[3] = best_fitness i_mut += 1 i_pop += 1 X, Y = np.meshgrid(pop_len, mut_len) surf = ax1.plot_surface(X, Y, fitness_arr, lw=2, label=m, color=colors[color]) surf._facecolors2d = surf._facecolors3d surf._edgecolors2d = surf._edgecolors3d ax2.plot_surface(X, Y, time_arr, lw=2, color=colors[color]) color += 1 ax1.set(xlabel="Population", ylabel="Keep %", zlabel='Fitness') ax2.set(xlabel="Population", ylabel="Keep %", zlabel='Time (s)') ax1.set(xticks=range(len(pop_range)), xticklabels=pop_range, yticks=range(len(keep_pct_range)), yticklabels=keep_pct_range) fig.legend(loc='center right', title='Attempts') plt.tight_layout() print( title + " MIMIC max_attempts={a}, # population={b}, keep %={c}, best_fitness={d}" .format(a=best[0], b=best[1], c=best[2], d=best[3])) #ax1.text(x=0.05,y=0.95, s="max_attempts={a}\n# population={b}\nkeep %={c}\nbest_fitness={d}".format(a=best[0], b=best[1], c=best[2], d=best[3])) self.saveToNewDir(fig, "./", title + "_MIMIC.png") plt.clf()
def one_max(): problem = mlrose.DiscreteOpt(length=20, fitness_fn=mlrose.OneMax(), maximize=True, max_val=2) init_state = np.array([0] * 20) startTime = datetime.now() best_state, best_fitness, fitness_curve_rhc = mlrose.random_hill_climb( problem, max_attempts=1000, max_iters=2500, restarts=0, init_state=init_state, curve=True, random_state=1, state_fitness_callback=None, callback_user_info=None) totalTime = datetime.now() - startTime rhcTime = totalTime.total_seconds() print("RHC") print("Time: ", rhcTime) print("best_fitness: ", best_fitness) print("Iteration: %d " % len(fitness_curve_rhc)) ############################### startTime = datetime.now() best_statesa, best_fitnesssa, fitness_curve_sa = mlrose.simulated_annealing( problem, max_attempts=1000, max_iters=2500, init_state=init_state, curve=True, random_state=1, state_fitness_callback=None, callback_user_info=None) totalTime = datetime.now() - startTime saTime = totalTime.total_seconds() print("SA") print("Time: ", saTime) print("best_fitness: ", best_fitnesssa) print("Iteration: %d " % len(fitness_curve_sa)) ############################### startTime = datetime.now() best_statega, best_fitnessga, fitness_curve_ga = mlrose.genetic_alg( problem, max_attempts=1000, max_iters=2500, curve=True, random_state=1, state_fitness_callback=None, callback_user_info=None) totalTime = datetime.now() - startTime gaTime = totalTime.total_seconds() print("GA") print("Time: ", gaTime) print("best_fitness: ", best_fitnessga) print("Iteration: %d " % len(fitness_curve_ga)) ############################### startTime = datetime.now() best_statemm, best_fitnessmm, fitness_curve_mm = mlrose.mimic( problem, max_attempts=1000, max_iters=2500, curve=True, random_state=1, state_fitness_callback=None, callback_user_info=None) totalTime = datetime.now() - startTime mmTime = totalTime.total_seconds() print("MIMIC") print("Time: ", mmTime) print("best_fitness: ", best_fitnessmm) print("Iteration: %d " % len(fitness_curve_mm))
length_hc = list(range(1, c2.shape[0] + 1)) start_time = time.time() a3, b3, c3 = mlrose.simulated_annealing( problem_fit, random_state=2, curve=True, ) span_sa = time.time() - start_time fitness_sa = c3 length_sa = list(range(1, c3.shape[0] + 1)) start_time = time.time() a4, b4, c4 = mlrose.mimic( problem_fit, random_state=2, curve=True, ) span_mc = time.time() - start_time fitness_mc = c4 length_mc = list(range(1, c4.shape[0] + 1)) max = np.concatenate( (fitness_ga, fitness_hc, fitness_mc, fitness_sa)).max() + 5 x_max = np.concatenate((length_ga, length_hc, length_sa, length_mc)).max() plt.figure(figsize=(12, 8)) plt.plot(length_ga, fitness_ga, linewidth=6, label="genetic_alg") plt.plot(length_hc, fitness_hc + 2, linewidth=6, label="random_hill_climb") plt.plot(length_sa, fitness_sa, linewidth=6, label="simulated_annealing") plt.plot(length_mc, fitness_mc, linewidth=6, label="mimic") plt.title("Continuous Peaks Problem Fitness, SIZE = 50", fontsize=20)
init_state = init_state) print('The best state found is (SA): ',opt_state) print('The fitness at the best state is (SA): ', opt_fit) # Hill Climb opt_state, opt_fit = mlrose.random_hill_climb(problem, max_attempts = 5000, max_iters = 1000000000) print('The best state found is (RHC): ',opt_state) print('The fitness at the best state is (RHC): ', opt_fit)''' '''Genetic Alg''' # GA '''opt_state, opt_fit = mlrose.genetic_alg(problem,mutation_prob=0.005,pop_size=10000,max_attempts = 50, max_iters = 2500) print('The best state found is (GA): ',opt_state) print('The fitness at the best state is (GA): ', opt_fit)''' # Mimic opt_state, opt_fit = mlrose.mimic(problem, pop_size=1000, max_attempts=100, max_iters=300) print('The best state found is (mimic): ', opt_state) print('The fitness at the best state is (mimic): ', opt_fit)
_, best_fitness_ga, fit_array_ga = mlrose.genetic_alg( problem, pop_size=prob_size_int * 15, max_iters=10000, mutation_prob=.15, max_attempts=200, track_fits=True) best_fit_dict['Genetic Algorithm'].append(best_fitness_ga) end = datetime.now() times['Genetic Algorithm'].append((end - start).total_seconds()) start = datetime.now() _, best_fitness_mimic, fit_array_mimic = mlrose.mimic( problem, pop_size=prob_size_int * 10, max_iters=10000, keep_pct=.1, max_attempts=100, track_fits=True) best_fit_dict['MIMIC'].append(best_fitness_mimic) end = datetime.now() times['MIMIC'].append((end - start).total_seconds()) # For the last fit that occurs, save off the fit arrays that are generated. We will plot fitness/iteration. fits_per_iteration['Random Hill Climbing'] = fit_array_rhc fits_per_iteration['Simulated Annealing'] = fit_array_sa fits_per_iteration['Genetic Algorithm'] = fit_array_ga fits_per_iteration['MIMIC'] = fit_array_mimic fit_frame = pd.DataFrame.from_dict(best_fit_dict, orient='index').transpose()