def main(): name_of_exp = "One Max" fitness = mlrose.OneMax() mimic = [] z_s = ['RHC', 'SA', 'GA', 'MIMIC'] for i in [100, 200, 300, 400, 500]: problem = mlrose.DiscreteOpt(length=15, fitness_fn=fitness, maximize=True, max_val=2) print("MIMC") max_atts = 10 best_state, best_fitness, learning_curve, timing_curve = mlrose.mimic( problem, pop_size=i, keep_pct=0.1, max_attempts=100, max_iters=100, curve=True, random_state=1, fast_mimic=True) mimic.append(learning_curve) print(i) print(best_fitness) print(max_atts) for x, z in zip([100, 200, 300, 400, 500], mimic): plt.plot(z, label=str(x)) plt.legend() plt.title( 'MIMIC Randomized Optimization PopSize vs Fitness Curve (OneMax)') plt.xlabel('Function iteration count') plt.ylabel('Fitness function value') plt.show()
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 gen_problem_onemax(problem_size): fitness = mlr.OneMax() maximize = True problem = mlr.DiscreteOpt(length=problem_size, fitness_fn=fitness, maximize=maximize) return problem, maximize
def one_max(bit_length=50): fitness_fn = mlrose.OneMax() problem = mlrose.DiscreteOpt(length=bit_length, fitness_fn=fitness_fn, max_val=2) return problem
def onemax(max_iter=500, early_stop=None, mimic_early_stop=100, n_runs=10, savedir=None): print('\n\n|========= One Max =========|\n') fitness = mlrose.OneMax() problem_size = [10, 100, 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': 1000, 'keep_pct': 0.3, '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.25, 'pop_breed_percent': 0.60, 'elite_dreg_ratio': 0.90, 'max_attempts': max_attempts } } 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('onemax', savedir, t, results, timings, problem_size) return t, results, timings
def OneMax(self, length=10, verbose=False): self.problem = 'onemax{l}'.format(l=length) self.verbose = verbose np.random.seed(0) problem_size = 1000 fitness = mlrose.OneMax() state = np.random.randint(2, size=problem_size) self.problem_fit = mlrose.DiscreteOpt(length=problem_size, fitness_fn=fitness, maximize=True)
def run(): # basePath = 'C:\\Users\\mwest\\Desktop\\ML\\source\\Machine-Learning-Local - Copy\\Graphs\\randomized\\One Max\\' basePath = None arrLen = 200 fitness = mlrose.FourPeaks(t_pct=0.15) fitness = mlrose.OneMax() problem = mlrose.DiscreteOpt(length=arrLen, fitness_fn=fitness) runHill(problem, basePath) runAnnealing(problem, basePath) runGenetic(problem, basePath) runMimic(problem, basePath) return
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 OptCounOnes(): fitness = mlrose.OneMax() validate(fitness, size, 'CounOnes')
def main(): name_of_exp = "One Max" fitness = mlrose.OneMax() rhc = [] sa = [] ga = [] mimic = [] z_s = ['RHC', 'SA', 'GA', 'MIMIC'] for i in [5, 10, 15]: problem = mlrose.DiscreteOpt(length=i, fitness_fn=fitness, maximize=True, max_val=2) # Define initial state init_state = np.zeros(i) # Solve problem using simulated annealing best_fitness = 0 learning_curve = [] max_atts = 10 print("RHC") while best_fitness != i: best_state, best_fitness, learning_curve, timing_curve = mlrose.random_hill_climb( problem, max_attempts=max_atts, max_iters=max_atts, restarts=1, init_state=init_state, curve=True, random_state=1) max_atts += 10 rhc.append(learning_curve) print(i) print(best_fitness) print(max_atts) print("SA") best_fitness = 0 learning_curve = [] max_atts = 10 while best_fitness != i: best_state, best_fitness, learning_curve, timing_curve = mlrose.simulated_annealing( problem, max_attempts=max_atts, max_iters=max_atts, schedule=mlrose.ExpDecay(), init_state=init_state, curve=True, random_state=1) max_atts += 10 sa.append(learning_curve) print(i) print(best_fitness) print(max_atts) print("GA") best_fitness = 0 learning_curve = [] max_atts = 10 while best_fitness != i: best_state, best_fitness, learning_curve, timing_curve = mlrose.genetic_alg( problem, pop_size=100, mutation_prob=0.1, max_attempts=max_atts, max_iters=max_atts, curve=True, random_state=1) max_atts += 10 ga.append(learning_curve) print(i) print(best_fitness) print(max_atts) print("MIMC") best_fitness = 0 learning_curve = [] max_atts = 10 while best_fitness != i: best_state, best_fitness, learning_curve, timing_curve = mlrose.mimic( problem, pop_size=300, keep_pct=0.1, max_attempts=max_atts, max_iters=max_atts, curve=True, random_state=1, fast_mimic=True) max_atts += 10 mimic.append(learning_curve) print(i) print(best_fitness) print(max_atts) f, axarr = plt.subplots(1, 4) f.set_figheight(3) f.set_figwidth(12) for y in rhc: for i in ['5', '10', '15']: axarr[0].plot(y, label='{}'.format(i)) axarr[0].set_title('RHC vs Input Size') for y in sa: for i in ['5', '10', '15']: axarr[1].plot(y, label='{}'.format(i)) axarr[1].set_title('SA vs Input Size') for y in ga: for i in ['5', '10', '15']: axarr[2].plot(y, label='{}'.format(i)) axarr[2].set_title('GA vs Input Size') for y in mimic: for i in ['5', '10', '15']: axarr[3].plot(y, label='{}'.format(i)) axarr[3].set_title('MIMC vs Input Size') # Fine-tune figure; hide x ticks for top plots and y ticks for right plots #plt.setp([a.get_xticklabels() for a in axarr[0]], visible=False) #plt.setp([a.get_yticklabels() for a in axarr[:, 1]], visible=False) plt.legend(handles=[ Line2D([0], [0], color='g', lw=4, label='5'), Line2D([0], [0], color='brown', lw=4, label='10'), Line2D([0], [0], color='y', lw=4, label='15') ]) #plt.title('Input size vs fitness curve One Max') # plt.xlabel('Function iteration count') #plt.ylabel('Fitness function value') plt.show()
def create_problem(): initial_state = numpy.random.randint(2, size=size) problem = mlrose.DiscreteOpt(size, mlrose.OneMax()) return initial_state, problem
import six import sys sys.modules['sklearn.externals.six'] = six import mlrose import numpy as np import time import matplotlib.pyplot as plt # Select Optimization Problems fitness = mlrose.OneMax() ProblemName = "One Max" #fitness = mlrose.FlipFlop() #ProblemName = "Flip Flop" #fitness = mlrose.FourPeaks(t_pct=0.15) #ProblemName = "Four Peaks" # Define optimization problem object [24 bits String] problem = mlrose.DiscreteOpt(length=24, fitness_fn=fitness, maximize=True, max_val=2) # Define Interation Parameter #iterator = [5, 10, 15, 20, 25, 50, 100, 150, 200, 250] iterator = range(5, 100, 5) print(iterator) # Solve using (1) simulated annealing [SA] fitness_score1 = [] fitness_time1 = []
import matplotlib.pyplot as plt import numpy as np import matplotlib.style as style import random import pandas as pd lengths = [10, 20, 40, 60, 80, 100] avgAcross = 10 print("SOLVING ContinuousPeaks") print("Get fitness for 100 iters on all algos") itersList = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100] problem = mlrose.DiscreteOpt(length=50, maximize=True, fitness_fn=mlrose.OneMax()) fitnessRHCAll = [] fitnessSAAll = [] fitnessGAAll = [] fitnessMIMICAll = [] fitnessRHCMean = [] fitnessSAMean = [] fitnessGAMean = [] fitnessMIMICMean = [] fitnessRHCFilter = [] fitnessSAFilter = [] fitnessGAFilter = [] fitnessMIMICFilter = []
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 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))
import sklearn as sk import mlrose as ml import numpy as np import matplotlib.pyplot as plt import random import time sample_sizes = [] fitness = ml.OneMax() main_best_fit_gene = [] main_execution_times_gene = [] main_total_iterations_gene = [] main_opt_iterations_gene = [] for y in range(10): best_fit_gene = [] execution_times_gene = [] total_iterations_gene = [] opt_iterations_gene = [] for x in range(5): start = time.time() opt = ml.DiscreteOpt((y * 6) + 6, fitness) #best_state, best_fitness, curve = ml.random_hill_climb(opt, max_iters=5, restarts = 0, curve=True, random_state = 2) best_state_gene, best_fitness_gene, curve_gene = ml.genetic_alg( opt, pop_size=(y * 6) + 6, max_attempts=100, curve=True, random_state=x)