def __run_with_rhc(self, init_weights, num_nodes, problem): fitness_curve = [] fitted_weights = [] loss = np.inf # Can't use restart feature of random_hill_climb function, since # want to keep initial weights in the range -1 to 1. for _ in range(self.restarts + 1): if init_weights is None: init_weights = np.random.uniform(-1, 1, num_nodes) if self.curve: current_weights, current_loss, fitness_curve = \ random_hill_climb(problem, max_attempts=self.max_attempts if self.early_stopping else self.max_iters, max_iters=self.max_iters, restarts=0, init_state=init_weights, curve=self.curve) else: current_weights, current_loss, _ = random_hill_climb( problem, max_attempts=self.max_attempts if self.early_stopping else self.max_iters, max_iters=self.max_iters, restarts=0, init_state=init_weights, curve=self.curve) if current_loss < loss: fitted_weights = current_weights loss = current_loss return fitness_curve, fitted_weights, loss
def rhc_runner(problem): attempts = np.arange(10, 500, 50).astype(int) iterations = np.arange(10, 500, 50).astype(int) restarts = np.arange(0, 100, 20) scoring_dict = {} timing_dict = {} attempts_scores = [] for i, att in enumerate(attempts): best_fits = [] for i in MC_RUNS: _, best_fitness = mlrose.random_hill_climb(problem, max_attempts=int(att), max_iters=500) best_fits.append(best_fitness) attempts_scores.append(best_fits) scoring_dict['Number of Attempts'] = pd.DataFrame(attempts_scores, columns=MC_RUNS, index=attempts) iteration_scores = [] for i, iteration in enumerate(iterations): best_fits = [] for i in MC_RUNS: _, best_fitness = mlrose.random_hill_climb( problem, max_attempts=100, max_iters=int(iteration)) best_fits.append(best_fitness) iteration_scores.append(best_fits) scoring_dict['Max Iterations'] = pd.DataFrame(iteration_scores, columns=MC_RUNS, index=iterations) iteration_scores = [] iteration_timing = [] for i, rst in enumerate(restarts): best_fits = [] times = [] for i in MC_RUNS: start = datetime.now() _, best_fitness = mlrose.random_hill_climb(problem, max_attempts=100, max_iters=500, restarts=int(rst)) end = datetime.now() best_fits.append(best_fitness) times.append((end - start).total_seconds()) iteration_scores.append(best_fits) iteration_timing.append(times) scoring_dict['Random Restarts'] = pd.DataFrame(iteration_scores, columns=MC_RUNS, index=restarts) timing_dict['Random Restarts'] = pd.DataFrame(iteration_timing, columns=MC_RUNS, index=restarts) return scoring_dict, timing_dict
def run_rhc(prob, value_range, num_runs): avgs = [] times = [] for value in value_range: problem = prob(value) print("\t\tValue: " + str(value)) run_vals = [] run_times = [] for run in range(0, num_runs): print("\t\t\tRun " + str(run)) start = timeit.default_timer() best_state, best_fitness = mlrose.random_hill_climb(problem, restarts=10) stop = timeit.default_timer() total_time = stop - start run_vals.append(best_fitness) run_times.append(total_time) avgs.append(np.mean(run_vals)) times.append(np.mean(run_times)) return avgs, times
def random_hill_climb_max_attempts(problem, initial_state, attempts_percentage): attempts = int(problem.length * attempts_percentage) return mlrose.random_hill_climb(problem, init_state=initial_state, curve=False, max_attempts=attempts)
def runComplexityHill(pType, problem): if pType == 'One Max': neighbor = 20 iterations = 400 elif pType == 'Flip Flop': neighbor = 36 iterations = 200 else: neighbor = 75 iterations = 400 s = time() best_state, best_fitness = mlrose.random_hill_climb(problem, max_attempts=neighbor, max_iters=iterations, curve=False, random_state=1) # best_state, best_fitness, c = mlrose.random_hill_climb(problem, # max_attempts=neighbor, # max_iters=iterations, # curve=False, # random_state=1) timeTaken = time() - s return best_fitness, timeTaken
def run_random_hill_climbing(init_state_problem): initial_state, problem = init_state_problem return mlrose.random_hill_climb(problem, init_state=initial_state, max_attempts=problem.length, restarts=5, curve=True)
def hill_climb(prob, **kwargs): start = time.time() _, best_score, curve, fit_evals = mlrose.random_hill_climb(prob(), curve=True, **kwargs) end = time.time() return np.array([best_score, len(curve), fit_evals, end - start])
def RandomHillClimbing(self): start = time.time() KSbest_state, KSbest_fitness, KScurve = random_hill_climb( self.knapsack, curve=True) rhKST = time.time() - start start = time.time() FPbest_state, FPbest_fitness, FPcurve = random_hill_climb( self.fourpeaks, curve=True) rhFPT = time.time() - start start = time.time() CObest_state, CObest_fitness, COcurve = random_hill_climb( self.countones, curve=True) rhCOT = time.time() - start return KSbest_fitness, FPbest_fitness, CObest_fitness, rhKST, rhFPT, rhCOT, KScurve, FPcurve, COcurve
def randomHill(problem, init_state, max_attempts, iterations): rh_best_state, rh_best_fitness = mlrose.random_hill_climb( problem, max_attempts=max_attempts, max_iters=iterations, restarts=0, init_state=init_state, random_state=1) return rh_best_fitness
def optimize_rhc(problem, trials=100): fitness_values = [] fitness_values_std = [] times = [] times_std = [] restarts = range(0, 3001, 500) for restart in restarts: samples = [] time_samples = [] for _ in range(trials): start = time.time() _, fitness_value, _ = mlrose.random_hill_climb(problem, restarts=restart) time_samples.append(time.time() - start) samples.append(fitness_value) fitness_values.append(np.mean(samples)) fitness_values_std.append(np.std(samples)) times.append(np.mean(time_samples)) times_std.append(np.std(time_samples)) fitness_values = np.array(fitness_values) fitness_values_std = np.array(fitness_values_std) times = np.array(times) times_std = np.array(times_std) with plot.style.context('seaborn-darkgrid'): fig, ax1 = plot.subplots() plot.title(f'Influence of the number of restarts on RHC') ax1.set_xlabel('Number of restarts') ax1.set_ylabel('Fitness') ax1.tick_params(axis='y') ax1.fill_between(restarts, fitness_values + fitness_values_std / 2, fitness_values - fitness_values_std / 2, alpha=0.5) ax1.plot(restarts, fitness_values, 'o-') with plot.style.context('default'): ax2 = ax1.twinx() ax2.set_ylabel('Computing time (s)') ax2.fill_between(restarts, times + times_std / 2, times - times_std / 2, alpha=0.5, color='darkorange') ax2.plot(restarts, times, color='darkorange') ax2.tick_params(axis='y') fig.tight_layout() plot.show()
def fit(length, fitness): problem = mlrose.DiscreteOpt(length = length, fitness_fn = fitness, maximize = True, max_val = 2) 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.random.randint(2, size=(length,))) best_fitness = max(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.random.randint(2, size=(length,))) best_fitness = max(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) GA.append(best_fitness) print(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) MM.append(best_fitness) print(best_fitness) time_MM.append((time.time() - start_time)) plot(RHC, SA, GA, MM, time_RHC, time_SA, time_GA, time_MM, iterations) 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 test_random_hill_climb_discrete_max(): """Test random_hill_climb function for a discrete maximization problem""" problem = DiscreteOpt(5, OneMax(), maximize=True) _, _, curve = random_hill_climb(problem, max_attempts=10, restarts=20, timing=True) assert (curve.shape[1] == 2)
def test_random_hill_climb_curve_length_max_iters(): """Test random_hill_climb function such that when curve is True for ma_iters the length of all fitness scores should be equal to max_iters""" problem = DiscreteOpt(5, OneMax(), maximize=True) x = np.array([0, 0, 0, 0, 0]) max_iters = 300 best_state, best_fitness, all_fitness = random_hill_climb( problem, max_iters=max_iters, restarts=0, init_state=x, curve=True) assert len(all_fitness) == max_iters
def rhc(self, max_attempts=10, max_iters=500, restarts=100): start = time.time() best_state, best_fitness, curve = random_hill_climb( self.problem_fit, max_attempts=max_attempts, max_iters=max_iters, restarts=restarts, curve=True, random_state=111) end = time.time() time_elapsed = end - start return [best_fitness, time_elapsed, curve]
def optimization(problem): df_optim = pd.DataFrame(columns=algos) df_iter = pd.DataFrame(columns=algos) df_time = pd.DataFrame(columns=algos) for rs in random_states: # RHC tic = time.process_time() best_state_rhc, best_fitness_rhc, curve_rhc = \ mlrose.random_hill_climb(problem, max_attempts=20, max_iters=100000, restarts=0, init_state=None, curve=True, random_state=rs) toc = time.process_time() time_rhc = toc - tic # SA tic = time.process_time() best_state_sa, best_fitness_sa, curve_sa = \ mlrose.simulated_annealing(problem, schedule=mlrose.ExpDecay(init_temp=1.0, exp_const=0.005, min_temp=0.001), max_attempts = 20, max_iters = 100000, init_state = None, curve = True, random_state = rs) toc = time.process_time() time_sa = toc - tic # GA tic = time.process_time() best_state_ga, best_fitness_ga, curve_ga = \ mlrose.genetic_alg(problem, pop_size=200, mutation_prob=0.1, max_attempts=20, max_iters=100000, curve=True, random_state=rs) toc = time.process_time() time_ga = toc - tic # MIMIC tic = time.process_time() best_state_m, best_fitness_m, curve_m = \ mlrose.mimic(problem, pop_size=20, keep_pct=0.2, max_attempts=20, max_iters=100000, curve=True, random_state=rs, fast_mimic=False) toc = time.process_time() time_m = toc - tic # df df_optim.loc[len(df_optim)] = [ best_fitness_rhc, best_fitness_sa, best_fitness_ga, best_fitness_m ] df_iter.loc[len(df_iter)] = [ len(curve_rhc), len(curve_sa), len(curve_ga), len(curve_m) ] df_time.loc[len(df_time)] = [time_rhc, time_sa, time_ga, time_m] print(rs) return (df_optim.mean(axis=0), df_iter.mean(axis=0), df_time.mean(axis=0))
def test_random_hill_climb_discrete_max(): """Test random_hill_climb function for a discrete maximization problem""" problem = DiscreteOpt(5, OneMax(), maximize=True) best_state, best_fitness, _ = random_hill_climb(problem, max_attempts=10, restarts=20) x = np.array([1, 1, 1, 1, 1]) assert (np.array_equal(best_state, x) and best_fitness == 5)
def maxKColor(edges, nodes, colors): fitness = mlrose.MaxKColor(edges) problem = mlrose.DiscreteOpt(length = nodes, fitness_fn = fitness, maximize = False, max_val = colors) t0 = time() best_state, best_fitness = mlrose.random_hill_climb(problem, max_attempts=100, max_iters=np.inf, init_state=None) finish = time() - t0 print(best_state) print(best_fitness) print(finish)
def test_random_hill_climb_continuous_min(): """Test random_hill_climb function for a continuous minimization problem""" problem = ContinuousOpt(5, OneMax(), maximize=False) best_state, best_fitness, _ = random_hill_climb(problem, max_attempts=10, restarts=20) x = np.array([0, 0, 0, 0, 0]) assert (np.array_equal(best_state, x) and best_fitness == 0)
def final_test(problem, ga, sa, rhc, mimic, trials=50): ga_samples = [] sa_samples = [] rhc_samples = [] mimic_samples = [] ga_time_samples = [] sa_time_samples = [] rhc_time_samples = [] mimic_time_samples = [] for _ in range(trials): start = time.time() _, ga_fitness, _ = mlrose.genetic_alg(problem, pop_size=ga[0], mutation_prob=ga[1]) ga_time_samples.append(time.time() - start) start = time.time() _, sa_fitness, _ = mlrose.simulated_annealing(problem, sa) sa_time_samples.append(time.time() - start) start = time.time() _, rhc_fitness, _ = mlrose.random_hill_climb(problem, rhc) rhc_time_samples.append(time.time() - start) start = time.time() _, mimic_fitness, _ = mlrose.mimic(problem, pop_size=mimic[0], keep_pct=mimic[1]) mimic_time_samples.append(time.time() - start) ga_samples.append(ga_fitness) sa_samples.append(sa_fitness) rhc_samples.append(rhc_fitness) mimic_samples.append(mimic_fitness) fitness_name = repr(problem.fitness_fn).split('.')[-1].split(' ')[0] if fitness_name == 'CustomFitness': fitness_name = 'Saw' print(f'Final results on {fitness_name}') print() print(f'GA max: {np.max(ga_samples)}') print(f'SA max: {np.max(sa_samples)}') print(f'RHC max: {np.max(rhc_samples)}') print(f'MIMIC max: {np.max(mimic_samples)}') print() print(f'GA mean: {np.mean(ga_samples)}') print(f'SA mean: {np.mean(sa_samples)}') print(f'RHC mean: {np.mean(rhc_samples)}') print(f'MIMIC mean: {np.mean(mimic_samples)}') print() print(f'GA mean execution time: {np.mean(ga_time_samples)}') print(f'SA mean execution time: {np.mean(sa_time_samples)}') print(f'RHC mean execution time: {np.mean(rhc_time_samples)}') print(f'MIMIC mean execution time: {np.mean(mimic_time_samples)}')
def test_random_hill_climb_max_iters(): """Test random_hill_climb 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, _ = random_hill_climb(problem, max_attempts=1, max_iters=1, restarts=0, init_state=x) assert best_fitness == 1
def optimize(self): best_state, best_fitness, fitness_curve = mlrose.random_hill_climb( self.problem, max_attempts=self.max_attempts, max_iters=self.max_iters, restarts=self.restarts, init_state=None, #self.init_state, curve=True, random_state=self.random_state) #print('best_state '+ str(best_state)) #print('best_fitness '+ str(best_fitness)) #print('fitness_curve '+ str(fitness_curve)) return best_state, best_fitness
def radomHillClimb(fitness, x): # This code was originally taken and modified from https://mlrose.readthedocs.io/en/stable/source/intro.html start = time.time() # Initialize fitness function object using pre-defined class #fitness = mlrose.Queens() # Define optimization problem object if (x == 0): problem = mlrose.DiscreteOpt(length=12, fitness_fn=fitness, maximize=False, max_val=12) elif (x == 1): problem = mlrose.DiscreteOpt(length=9, fitness_fn=fitness, maximize=False, max_val=3) else: problem = mlrose.DiscreteOpt(length=8, fitness_fn=fitness, maximize=True, max_val=8) # Solve using random hill climb if (x == 0): init_state = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) elif (x == 1): init_state = np.array([0, 1, 2, 0, 1, 2, 0, 1, 1]) else: init_state = np.array([0, 1, 2, 3, 4, 5, 6, 7]) best_state, best_fitness, fitness_curve = mlrose.random_hill_climb( problem, restarts=10, init_state=init_state, max_iters=1000, random_state=1, curve=True) end = time.time() print("Random Hill Climb:") print('The best state found is: ', best_state) print('The fitness at the best state is: ', best_fitness) print("Time: " + str(end - start)) return best_fitness, end - start
def random_hill_climb(problem, starting_cell): """ Random Hill climbing implementation to minimize TSP Inputs: problem --> optimization problem object required by mlrose starting_cell --> starting cell number, index starting from 1 Outputs: optimized_cells --> cells to visit """ # mlrose requires indices start from zero # mlrose also requires init_state to be a 1D np array #init_cell = np.array([starting_cell-1]) #init_cell = np.array([0,2,3,4,5,6,7,8,9,10,11,12,1]) optimized_cells, _ = mlrose.random_hill_climb(problem) # Add 1 to all cells since in our case, cell numbers start from one not zero! #optimized_cells += 1 return optimized_cells
def run(self, n=1): """ n : the number of runs to do returns best_fitnesses (list), learning_curves (list) """ best_fitnesses = [] learning_curves = [] for i in np.arange(n): _, _, learning_curve = mlrose.random_hill_climb( self.problem, max_attempts=self.max_attempts, max_iters=self.max_iters, restarts=self.restarts, random_state=None, curve=True) best_fitness = np.max(learning_curve) best_fitnesses.append(best_fitness) learning_curves.append(learning_curve) return best_fitnesses, learning_curves
def iteration_curve(self): print("Creating iteration curve") problem, init_state = self.get_prob(t_pct=0.15) best_state_rhc, best_fitness_rhc, fitness_curve_rhc = mlrose.random_hill_climb( problem, max_attempts=1000, max_iters=5000, init_state=init_state, curve=True) best_state_sa, best_fitness_sa, fitness_curve_sa = mlrose.simulated_annealing( problem, max_attempts=10000, max_iters=5000, init_state=init_state, curve=True) problem, init_state = self.get_prob(t_pct=0.15) best_state_ga, best_fitness_ga, fitness_curve_ga = mlrose.genetic_alg( problem, max_attempts=1000, max_iters=5000, curve=True) problem, init_state = self.get_prob(t_pct=0.15) best_state_mimic, best_fitness_mimic, fitness_curve_mimic = mlrose.mimic( problem, pop_size=self.pop_size, max_attempts=100, max_iters=5000, curve=True) plt.figure() plt.plot(fitness_curve_rhc, label='RHC') plt.plot(fitness_curve_sa, label='SA') plt.plot(fitness_curve_ga, label='GA') plt.plot(fitness_curve_mimic, label='MIMIC') plt.legend(loc="best") plt.ylabel('Fitness') plt.xlabel('Number of Iterations') plt.title("{}: Fitness vs. Number of Iterations".format( self.prob_name)) # ax = plt.gca() # ax.set_xscale('log') plt.savefig( os.path.join(self.output_path, "{}_iterations.png".format(self.prob_name)))
def runHill(problem, basePath): iterations = 1000 restart = 0 neighborhood = [2, 4, 12, 36] neighborhood = [20] neighborhood = [2, 4, 12, 36, 50, 75] neighborhood = [2, 75] fig, ax = plt.subplots() plt.title('Random Hill') # fig.tight_layout() times = np.zeros((len(neighborhood), iterations)) nIndex = 0 for neighbor in neighborhood: s = time() x = [] y = [] for i in range(1, iterations + 1): best_state, best_fitness = mlrose.random_hill_climb( problem, max_attempts=neighbor, restarts=restart, max_iters=i, curve=False, random_state=1) x.append(i) y.append(best_fitness) e = time() timeTaken = e - s times[nIndex, i - 1] = timeTaken print('Itt: {0} - Time:{1}'.format(i, timeTaken)) nIndex += 1 plotLine(x, y, ax, 'Neighbors: {0}'.format(neighbor)) plotTime(x, times, ax) showLegend(fig, ax) if basePath: plt.savefig('{0}\\{1}.png'.format(basePath, 'Hill')) else: plt.show() return
def rhc(self): print("Creating RHC curve") problem, init_state = self.get_prob(t_pct=0.15) plt.close() plt.figure() for restarts in range(0, 11, 2): _, _, fitness_curve = mlrose.random_hill_climb( problem, restarts=restarts, max_attempts=100, max_iters=1000, init_state=init_state, curve=True) plt.plot(fitness_curve, label="restarts={}".format(restarts)) plt.title("{}: Randomized Hill Climbing".format(self.prob_name)) plt.legend(loc="best") plt.xlabel('Number of Iterations') plt.ylabel('Fitness') plt.savefig( os.path.join(self.output_path, "{}_RHC Analysis.png".format(self.prob_name)))
def test_random_hill(self, title, max_attempts_range=[100], random_restarts_range=[0]): print(title + " Random Hill Climbing Algorithm") So is there fig.suptitle(title + " Random Hill Climb") best = [0, 0, 0] for m in max_attempts_range: fitness_arr = [] time_arr = [] for r in random_restarts_range: start = time.time() best_state, best_fitness, curve = mlrose.random_hill_climb( self.problem_fit, max_attempts=m, max_iters=np.inf, restarts=r, curve=True) fitness_arr.append(best_fitness) time_arr.append(round(time.time() - start, 2)) if best_fitness > best[2]: best[0] = m best[1] = r best[2] = best_fitness ax1.plot(random_restarts_range, fitness_arr, label=m, lw=2) ax2.plot(random_restarts_range, time_arr, lw=2) ax1.set(xlabel="# Restarts", ylabel="Fitness") ax2.set(xlabel="# Restarts", ylabel="Time(s)") fig.legend(loc='center right', title='Attempts') print(title + " RHC max_attempts={a}, # restarts={b}, best_fitness={c}".format( a=best[0], b=best[1], c=best[2])) #ax1.text(x=0.05, y=0.95,s="max_attempts={a}\n# restarts={b}\nbest_fitness={c}".format(a=best[0], b=best[1], c=best[2])) plt.tight_layout() self.saveToNewDir(fig, "./", title + "_Random_Hill_Climb.png") plt.clf()
def runalgos(problem, max_attempts, iterations): #Define decay schedule schedule = mlrose.ExpDecay() #Solve problem using Random Hill Climbing rh_best_state, rh_best_fitness = mlrose.random_hill_climb( problem, max_attempts=max_attempts, max_iters=iterations, restarts=1, init_state=init_state, random_state=1) #Solve problem using Simulated Annealing sm_best_state, sm_best_fitness = mlrose.simulated_annealing( problem, schedule=schedule, max_attempts=max_attempts, max_iters=iterations, curve=False, random_state=1) #Solve problem using Gentic Algorithm genA_best_state, genA_best_fitness = mlrose.genetic_alg( problem, pop_size=200, mutation_prob=0.1, max_attempts=max_attempts, max_iters=iterations, curve=False, random_state=1) #Solve problem using MIMIC mimic_best_state, mimic_best_fitness = mlrose.mimic( problem, pop_size=200, keep_pct=0.2, max_attempts=max_attempts, max_iters=iterations, curve=False, random_state=1) #return rh_best_state,rh_best_fitness,sm_best_state,sm_best_fitness,genA_best_state,genA_best_fitness,mimic_best_state,mimic_best_fitness return rh_best_fitness, sm_best_fitness, genA_best_fitness, mimic_best_fitness
]].idxmin()] # from the output of the experiment above return rhc_df_run_stats, rhc_df_run_curves, ideal_rs # # Done on a complex example then hard coded optimized parameter value(s). # rhc_df_run_stats, rhc_df_run_curves, ideal_rs = opt_rhc_params() ideal_rs = 50 # this came from the results of the experiment commented out, above. rhc_best_state = [] rhc_best_fitness = [] rhc_convergence_time = [] for iter in iterations_range: start_time = timeit.default_timer() best_state, best_fitness, curve = mlrose.random_hill_climb( problem=problem, max_iters=iter, max_attempts=500, restarts=ideal_rs, curve=True) end_time = timeit.default_timer() convergence_time = (end_time - start_time) # seconds rhc_best_state.append(best_state) rhc_best_fitness.append(best_fitness) rhc_convergence_time.append(convergence_time) print('The fitness at the best state found using Random Hill Climbing is: ', min(rhc_best_fitness)) #========== Genetic Algorithms ==========# time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M") print("Starting Genetic Algorithms at: " + time)