def run(): # basePath = 'C:\\Users\\mwest\\Desktop\\ML\\source\\Machine-Learning-Local - Copy\\Graphs\\randomized\\Complexity\\One Max\\' basePath = None # lengths = range(1, 501, 25) # lengths = range(1, 101, 50) lengths = [10, 100, 200, 300, 400, 500] lengths = [10, 50, 100, 150, 200] lengths = [ 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150 ] # lengths = [5, 10] fitness = mlrose.OneMax() runComplexity('One Max', fitness, lengths) fitness = mlrose.FourPeaks(t_pct=0.10) runComplexity('Four Peaks', fitness, lengths) fitness = mlrose.FlipFlop() runComplexity('Flip Flop', fitness, lengths) # runComplexity('TSP', None, lengths) # fitness = mlrose.Queens() # runComplexity('Queens', fitness, lengths) return
def FlipFlop(self, length=8, verbose=False): self.problem = 'flipflop{l}'.format(l=length) self.verbose = verbose fitness_fn = mlrose.FlipFlop() self.problem_fit = mlrose.DiscreteOpt(length=length, fitness_fn=fitness_fn, maximize=True)
def create_problem(self): fitness = mlrose.FlipFlop() problem = mlrose.DiscreteOpt(length=self.length, fitness_fn=fitness, maximize=True, max_val=2) return problem
def create_problem(self): edges = [(0, 1), (0, 2), (0, 4), (1, 3), (2, 0), (2, 3), (3, 4)] fitness = mlrose.FlipFlop() problem = mlrose.DiscreteOpt(length=self.length, fitness_fn=fitness, maximize=True, max_val=2) return problem
def flipflop(max_iter=500, early_stop=None, mimic_early_stop=100, n_runs=10, savedir=None): print('\n\n|========= Flip Flop =========|\n') fitness = mlrose.FlipFlop() problem_size = [500] max_attempts = max_iter * 2 if early_stop is None else early_stop mimic_early_stop = max_attempts if mimic_early_stop is None else mimic_early_stop hyperparams = { 'rhc': { 'restarts': 0, 'max_attempts': max_attempts }, 'mimic': { 'pop_size': 500, 'keep_pct': 0.2, 'max_attempts': mimic_early_stop, 'fast_mimic': True }, 'sa': { 'schedule': mlrose.GeomDecay(), 'init_state': None, 'max_attempts': max_attempts }, 'ga': { 'pop_size': 1000, 'mutation_prob': 0.2, 'pop_breed_percent': 0.75, 'elite_dreg_ratio': 0.95, 'max_attempts': mimic_early_stop } } print('Hyperparameters: ', hyperparams) results = [] runtimes = [] timings = {} for ps in problem_size: problem = mlrose.DiscreteOpt(ps, fitness, max_val=2, maximize=True) print('Running with input size', ps) print('-----------------------------') r, t, wt = util.optimize_iters(problem, max_iter, hyperparams, n_runs) results.append(r) runtimes.append(t) timings['ps{}'.format(ps)] = wt print('final runtimes') t = pd.DataFrame(runtimes, index=problem_size) print(t) if savedir: util.save_output('flipflop', savedir, t, results, timings, problem_size) return t, results, timings
def get_prob(self, t_pct=None, p_length=None): if self.prob_name == 'Four Peaks': fitness = mlrose.FourPeaks(t_pct) p_len = 100 self.schedule = mlrose.ExpDecay() self.restarts = 0 self.mutation_prob = 0.1 self.keep_pct = 0.1 self.pop_size = 500 elif self.prob_name == "Continuous Peaks": fitness = mlrose.ContinuousPeaks(t_pct) p_len = 100 self.schedule = mlrose.GeomDecay() self.restarts = 0 self.mutation_prob = 0.1 self.keep_pct = 0.2 self.pop_size = 200 elif self.prob_name == "Max K Color": fitness = mlrose.MaxKColor(self.COLOREDGE) p_len = 100 self.schedule = mlrose.ExpDecay() self.restarts = 0 self.mutation_prob = 0.2 self.keep_pct = 0.2 self.pop_size = 200 elif self.prob_name == "Flip Flop": fitness = mlrose.FlipFlop() p_len = 100 self.schedule = mlrose.ArithDecay() self.restarts = 0 self.mutation_prob = 0.2 self.keep_pct = 0.5 self.pop_size = 500 elif self.prob_name == "One Max": fitness = mlrose.OneMax() p_len = 100 self.schedule = mlrose.GeomDecay() self.restarts = 0 self.mutation_prob = 0.2 self.keep_pct = 0.1 self.pop_size = 100 else: fitness = None p_len = 0 if p_length is None: p_length = p_len problem = mlrose.DiscreteOpt(length=p_length, fitness_fn=fitness) init_state = np.random.randint(2, size=p_length) return problem, init_state
def fitness_function(f, bits, rs, verbose): if verbose: print('\n\n----------', f, ':', bits, 'bits ----------') if f == 'Four Peaks': fitness_fn = mlrose.FourPeaks( t_pct=0.15 ) # Note: T= np.ceil(t_pct * n), per source code for FourPeaks.evaluate elif f == 'MaxKColor': # fitness_fn = mlrose.MaxKColor(edges) # default mlrose fitness function # edges = [(0, 1), (0, 2), (1, 3), (2, 3)] # 4 nodes, 2 by 2 grid, no diagonals # edges = [(0, 1), (0, 2), (0, 4), (1, 3), (2, 0), (2, 3), (3, 4)] edges = generate_graph(bits) kwargs = {'edges': edges} fitness_fn = mlrose.CustomFitness( kcolors_max, **kwargs) # custom fitness function for maximization problem elif f == 'Knapsack': # weights = [10, 5, 2, 8, 15] # values = [1, 2, 3, 4, 5] weights, values = generate_knapsack(bits, rs) if verbose: print('\nKnapsack\n', weights, values) max_weight_pct = 0.6 fitness_fn = mlrose.Knapsack(weights, values, max_weight_pct) elif f == 'FlipFlop': fitness_fn = mlrose.FlipFlop() # Check fitness for ad-hoc states # test_state = np.array([1, 0, 1, 1, 0]) # print("Fitness for test_state", test_state, ":", fitness_fn.evaluate(test_state)) return fitness_fn
import time as tt import numpy as np import mlrose as mlrose import pandas as pd ps = [8,32,64,128] for p in ps: fitness = mlrose.FlipFlop() istate = np.array(np.zeros(p), dtype=int) problem = mlrose.DiscreteOpt(length=p, fitness_fn=fitness, maximize=True, max_val=2) schedule = mlrose.ExpDecay(init_temp=0.5, exp_const=0.005, min_temp=0.001) start_fit_time = tt.time() best_state, best_fitness,fitness_curve = mlrose.random_hill_climb(problem,max_attempts = 500, max_iters = 500,restarts=0,init_state = istate, random_state = 1,curve=True) end_fit_time = tt.time() it = len(fitness_curve) time = end_fit_time - start_fit_time tpi = time/it print('SA') print(f'sa, input size: {p},time={time}, iterations={it}, time per iteration={tpi}')
def create_problem(size): initial_state = numpy.random.randint(2, size=size) problem = mlrose.DiscreteOpt(size, mlrose.FlipFlop()) return initial_state, problem
max_val=2, fitness_fn=saw_fitness) base_test(saw_fitness, theoretical_best_fitness=lambda x: x, lengths=range(200, 701, 100)) # 2476s optimize_ga(saw_problem) # 7255s optimize_sa(saw_problem) # 8730s optimize_rhc(saw_problem) # 103s optimize_mimic(saw_problem) # 2192s final_test(saw_problem, [600, 0.001], mlrose.ExpDecay(5, 0.0007), 1500, [500, 0.075]) # 14808 # FLIP FLOP flipflop = mlrose.FlipFlop() flipflop_problem = mlrose.DiscreteOpt(length=60, maximize=True, max_val=2, fitness_fn=flipflop) base_test(flipflop, theoretical_best_fitness=lambda x: x - 1, lengths=range(50, 111, 10)) # 364s optimize_ga(flipflop_problem) # 1782s optimize_sa(flipflop_problem) # 4173s optimize_rhc(flipflop_problem) # 3839s optimize_mimic(flipflop_problem) # 5750s final_test(flipflop_problem, [100, 0.1], mlrose.ExpDecay(1, 0.003), 1500, [500, 0.1]) # 1065s
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 main(): name_of_exp = "Flip-Flop" fitness = mlrose.FlipFlop() problem = mlrose.DiscreteOpt(length=8, fitness_fn=fitness, maximize=True, max_val=2) # Define initial state init_state = np.zeros(8) x_s = [] y_s = [] z_s = ['RHC', 'SA', 'GA', 'MIMIC'] w_s = [] max_val = 7.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()
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Fri Mar 1 20:30:20 2019 @author: kalyantulabandu """ import mlrose import numpy as np fitness_fn = mlrose.FlipFlop() problem_size = [10,20,50,100,200,300,500,600] input_space = [] for each in problem_size: input = np.random.randint(0,2,size=each) init_state = np.array(input) input_space.append(init_state) print(input_space) max_attempts = 50 max_iters = 1500 rhc_state = [] rhc_fitness = [] rhc_statistics = [] rhc_statistics_fn_evals = [] rhc_statistics_time = []