def main(): name_of_exp = "Eight Queens" fitness = mlrose.CustomFitness(queens_max) problem = mlrose.DiscreteOpt(length=8, fitness_fn=fitness, maximize=True, max_val=8) # Define initial state mimic = [] init_state = np.array([0, 1, 2, 3, 4, 5, 6, 7]) for i in [mlrose.ExpDecay(), mlrose.GeomDecay(), mlrose.ArithDecay()]: best_state, best_fitness, learning_curve, timing_curve = mlrose.simulated_annealing( problem, init_state=init_state, schedule=i, max_attempts=1000, max_iters=1000, curve=True, random_state=1) mimic.append(learning_curve) print(i) print(best_fitness) for x, z in zip(['Exp', 'Geom', 'Arith'], mimic): plt.plot(z, label=str(x)) plt.legend() plt.title( 'SA Randomized Optimization DecaySchedule vs Fitness Curve (8-Queens)') plt.xlabel('Function iteration count') plt.ylabel('Fitness function value') plt.show()
def sa(self): print("Creating SA curve") problem, init_state = self.get_prob(t_pct=0.15) plt.close() plt.figure() for schedule, s_str in zip( [mlrose.GeomDecay(), mlrose.ArithDecay(), mlrose.ExpDecay()], ['GeomDecay', 'ArithDecay', 'ExpDecay']): _, _, fitness_curve = mlrose.simulated_annealing( problem, schedule=schedule, max_attempts=100, max_iters=5000, init_state=init_state, curve=True) plt.plot(fitness_curve, label="schedule={}".format(s_str)) plt.title("{}: Simulated Annealing".format(self.prob_name)) plt.legend(loc="best") plt.xlabel('Number of Iterations') plt.ylabel('Fitness') plt.savefig( os.path.join(self.output_path, "{}_SA Analysis.png".format(self.prob_name)))
def __init__(self, schedule=mlrose.GeomDecay(), max_attempts=250, max_iters=np.inf, init_state=None, curve=False, random_state=None): print("Initialized Simulated Annealing Optimizer") self.schedule = schedule self.max_attempts = max_attempts self.max_iters = max_iters self.init_state = init_state self.curve = curve self.random_state = random_state self.bestState = [] self.bestFitness = 0 self.parameters = { 'max_iters': np.arange(1, 251), 'schedule': [mlrose.GeomDecay(), mlrose.ArithDecay(), mlrose.ExpDecay()] } self.bestParameters = { 'max_iters': int(max(np.arange(1, 251))), 'schedule': mlrose.GeomDecay() }
def simulated_annealing_decay(problem, initial_state, decay): if decay == 'Geom': schedule = mlrose.GeomDecay() if decay == 'Exp': schedule = mlrose.ExpDecay() if decay == 'Arith': schedule = mlrose.ArithDecay() return mlrose.simulated_annealing(problem, init_state=initial_state, curve=False, schedule=schedule)
def create_nn_schedule(decay): if decay == 'Geom': schedule = mlrose.GeomDecay() if decay == 'Exp': schedule = mlrose.ExpDecay() if decay == 'Arith': schedule = mlrose.ArithDecay() return mlrose.NeuralNetwork(hidden_nodes=[10], algorithm='simulated_annealing', max_iters=1000, schedule=schedule, random_state=7106080)
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 sim_annealing(self, max_attempts=10, max_iters=np.inf, decay='geom'): decay_lookup = { 'geom': mlrose.GeomDecay(), 'exp': mlrose.ExpDecay(), 'arith': mlrose.ArithDecay() } start = time.time() best_state, best_fitness = simulated_annealing( self.problem_fit, max_attempts=max_attempts, max_iters=max_iters, schedule=decay_lookup[decay], random_state=111) end = time.time() time_elapsed = end - start return [best_fitness, time_elapsed]
def test_simulated_annealing(self, title, max_attempts_range=[100], decay_range=['geom']): decay_lookup = { 'geom': mlrose.GeomDecay(), 'exp': mlrose.ExpDecay(), 'arith': mlrose.ArithDecay() } fig, (ax1, ax2) = plt.subplots(2, figsize=(12, 8), dpi=80) fig.suptitle(title + " Simmulated Annealing") print(title + " Simulated Annealing Algo") best = [0, 0, 0] for m in max_attempts_range: fitness_arr = [] time_arr = [] for d in decay_range: start = time.time() # solve using simulated annealing best_state, best_fitness, curve = mlrose.simulated_annealing( self.problem_fit, schedule=decay_lookup[d], max_attempts=m, max_iters=np.inf, 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] = d best[2] = best_fitness ax1.plot(decay_range, fitness_arr, label=m, lw=2) ax2.plot(decay_range, time_arr, lw=2) ax1.set(xlabel="Decay Range", ylabel="Fitness") ax2.set(xlabel="Decay Range", ylabel="Time(s)") print(title + " SA max_attempts={a}, # decay={b}, best_fitness={c}".format( a=best[0], b=best[1], c=best[2])) fig.legend(loc='center right', title='Attempts') plt.tight_layout() self.saveToNewDir(fig, "./", title + "_Simulated_Annealing.png") plt.clf()
def runAnnealing(problem, basePath): iterations = 500 iterations = 1000 neighborhood = [10] neighborhood = [2, 4, 12, 36, 50, 75] neighborhood = [4] schedules = [('Exp', mlrose.ExpDecay()), ('Arith', mlrose.ArithDecay()), ('Geom', mlrose.GeomDecay())] schedules = [('Exp', mlrose.ExpDecay())] times = np.zeros((len(neighborhood), iterations)) nIndex = 0 schedule = mlrose.ExpDecay() fig, ax = plt.subplots() plt.title('Annealing') for neighbor in neighborhood: s = time() x = [] y = [] for i in range(1, iterations + 1): best_state, best_fitness = mlrose.simulated_annealing( problem, schedule=schedule, max_attempts=neighbor, max_iters=i, 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} - {1}'.format(neighbor, 'Exponential Decay')) plotTime(x, times, ax) showLegend(fig, ax) if basePath: plt.savefig('{0}\\{1}.png'.format(basePath, 'Annealing')) else: plt.show() return
mlrose.GeomDecay(init_temp=10.0, decay=0.9, min_temp=0.001) }, { "schedule": mlrose.GeomDecay(init_temp=10.0, decay=0.8, min_temp=0.001) }, { "schedule": mlrose.GeomDecay(init_temp=10.0, decay=0.7, min_temp=0.001) }, { "schedule": mlrose.GeomDecay(init_temp=10.0, decay=0.6, min_temp=0.001) }, { "schedule": mlrose.GeomDecay(init_temp=10.0, decay=0.5, min_temp=0.001) }, { "schedule": mlrose.ArithDecay(init_temp=10.0, decay=0.0001, min_temp=0.001) }, { "schedule": mlrose.ArithDecay(init_temp=10.0, decay=0.001, min_temp=0.001) }, { "schedule": mlrose.ArithDecay(init_temp=10.0, decay=0.01, min_temp=0.001) }], mlrose.genetic_alg: [{ "mutation_prob": .15 }, { "mutation_prob": .35 }, { "mutation_prob": .55 }, { "mutation_prob": .75
def main(): name_of_exp = "TSP" # Create list of city coordinates coords_list = [(1, 1), (4, 2), (5, 2), (6, 4), (4, 4), (3, 6), (1, 5), (2, 3)] # Initialize fitness function object using coords_list fitness_coords = mlrose.TravellingSales(coords=coords_list) problem = mlrose.TSPOpt(length=8, fitness_fn=fitness_coords, maximize=False) # Define initial state x_s = [] y_s = [] z_s = ['RHC', 'SA', 'GA', 'MIMIC'] w_s = [] max_val = 19.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), 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, 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, 1000, 100): if found_flag: break for max_iter_atts in np.arange(100, 1000, 100): 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, 0.5, 0.1): if found_flag: break for pop_size in np.arange(100, 1000, 100): if found_flag: break for max_iter_atts in np.arange(100, 1000, 100): 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()
def solve_sa(problem_fit): """ Solving using Simulated Annealing """ min_fitness = np.inf best_params_dict = {} # Parameter list initial_temp_list = [10, 100, 1000] min_temp_list = [1, 10, 100] decay_list = [0.001, 0.01, 0.1] # Solve for t0 in initial_temp_list: for t in min_temp_list: # Initial temp should be greater than Minimum temp if t0 < t: continue for d in decay_list: for c in range(2): if c == 0: schedule = mlrose.ExpDecay(init_temp=t0, exp_const=d, min_temp=t) else: schedule = mlrose.ArithDecay(init_temp=t0, decay=d, min_temp=t) # Start timer t_start = time.time() best_state, best_fitness, fitness_curve = mlrose.simulated_annealing( problem=problem_fit, schedule=schedule, max_attempts=500, max_iters=5000, random_state=np.random.seed(7), curve=True) # End timer t_end = time.time() # Storing the best result if best_fitness < min_fitness: min_fitness = best_fitness best_params_dict['Fitness'] = best_fitness best_params_dict['Solution'] = best_state best_params_dict['Initial_temp'] = t0 best_params_dict['Min_temp'] = t best_params_dict['Decay'] = d best_params_dict[ 'Schedule'] = "Exponential" if c == 0 else "Arithmetic" best_params_dict['Fitness_curve'] = fitness_curve best_params_dict['Time'] = round(t_end - t_start, 2) # Printing the best result print("-- Parameters --") print("\tCooling Schedule: ", best_params_dict['Schedule']) print("\tInitial Temperature: ", best_params_dict['Initial_temp']) print("\tMin Temperature: ", best_params_dict['Min_temp']) print("\tDecay rate: ", best_params_dict['Decay']) print("\tMax Attempts at each step: 100") print("\tStopping Criterion = Max Iterations of the algorithm: 10000") print("Results:") print("\tSolution (Order of city traversal by index): ", best_params_dict['Solution']) print("\tFitness: ", round(best_params_dict['Fitness'], 2)) print("Computational Time: ", best_params_dict['Time'], " seconds\n\n") # Plotting plt.plot(-(best_params_dict['Fitness_curve'])) plt.title("Convergence curve: TSP-Qatar using Simulated Annealing") plt.xlabel("Iterations") plt.ylabel("Fitness") plt.savefig("tsp_qatar_sa.png")
def optimize_sa(problem, trials=50): init_temps = np.linspace(1.0, 10.0, 10) decay_rates = np.linspace(0.1, 0.99, 10) for i in range(len(decay_rates)): decay_rates[i] = int(decay_rates[i] * 100) / 100 fitness_values = [[] for _ in range(len(decay_rates))] for i, decay_rate in enumerate(decay_rates): for init_temp in init_temps: samples = [] for _ in range(trials): decay = mlrose.GeomDecay(init_temp=init_temp, decay=decay_rate) _, fitness_value, _ = mlrose.simulated_annealing( problem, decay) samples.append(fitness_value) fitness_values[i].append(np.mean(samples)) display_cm( np.array(fitness_values), f'Simulated annealing tuning on ' f'{repr(problem.fitness_fn).split(".")[-1].split(" ")[0]}, length={problem.length}', 'Initial temperature', 'Decay rate', init_temps, decay_rates) fitness_values = [[] for _ in range(len(decay_rates))] for i, decay_rate in enumerate(decay_rates): for init_temp in init_temps: samples = [] for _ in range(trials): decay = mlrose.ArithDecay(init_temp=init_temp, decay=decay_rate) _, fitness_value, _ = mlrose.simulated_annealing( problem, decay) samples.append(fitness_value) fitness_values[i].append(np.mean(samples)) display_cm( np.array(fitness_values), f'Simulated annealing tuning on ' f'{repr(problem.fitness_fn).split(".")[-1].split(" ")[0]}, length={problem.length}', 'Initial temperature', 'Decay rate', init_temps, decay_rates) init_temps = np.linspace(1.0, 10.0, 10) exp_consts = np.linspace(0.0001, 0.003, 10) for i in range(len(exp_consts)): exp_consts[i] = int(exp_consts[i] * 10000) / 10000 fitness_values = [[] for _ in range(len(exp_consts))] for i, exp_const in enumerate(exp_consts): for init_temp in init_temps: samples = [] time_samples = [] for _ in range(trials): decay = mlrose.ExpDecay(init_temp=init_temp, exp_const=exp_const) start = time.time() _, fitness_value, _ = mlrose.simulated_annealing( problem, decay) time_samples.append(time.time() - start) samples.append(fitness_value) fitness_values[i].append(np.mean(samples)) display_cm( np.array(fitness_values), f'Simulated annealing tuning on ' f'{repr(problem.fitness_fn).split(".")[-1].split(" ")[0]}, length={problem.length}', 'Initial temperature', 'Exp const', init_temps, exp_consts)
for iterations in (10000, 50000): for attempts in (100, 300): for temp in (0.01, 0.1, 1, 10): start_time = time.perf_counter() nn_model1 = mlrose.NeuralNetwork( hidden_nodes=[5], activation='sigmoid', bias=False, is_classifier=True, learning_rate=0.1, early_stopping=True, random_state=SEED, algorithm='simulated_annealing', max_iters=iterations, max_attempts=attempts, schedule=mlrose.ArithDecay(init_temp=temp)) nn_model1.fit(X_train, y_train) run_time = time.perf_counter() - start_time # # predict & assess on training data # y_train_pred = nn_model1.predict(X_train) # y_train_error = 1.0 - accuracy_score(y_train, y_train_pred) # y_train_kappa = cohen_kappa_score(y_train, y_train_pred) # , labels=target_names) # y_train_confusion = confusion_matrix(y_train, y_train_pred) # , labels=target_names) # print("# TRAIN DATA:\nerror=", y_train_error, "\nkappa=", y_train_kappa, "\nconfusion matrix=\n", y_train_confusion) # predict & assess on test data y_test_pred = nn_model1.predict(X_test) y_test_error = 1.0 - accuracy_score(y_test, y_test_pred) y_test_kappa = cohen_kappa_score( y_test, y_test_pred) # , labels=target_names)
def train_sa_nn(train_x, train_y, test_x, test_y): activations = ['identity', 'relu', 'sigmoid', 'tanh'] markers = ['o', 'x', '^', 's'] colors = ['g', 'b', 'r', 'c'] legend_items = [ mlines.Line2D([], [], color='k', marker='o', markersize=5, linestyle='None', label='identity'), mlines.Line2D([], [], color='k', marker='x', markersize=5, linestyle='None', label='relu'), mlines.Line2D([], [], color='k', marker='^', markersize=5, linestyle='None', label='sigmoid'), mlines.Line2D([], [], color='k', marker='s', markersize=5, linestyle='None', label='tanh'), mlines.Line2D([0], [0], color='g', lw=2), mlines.Line2D([0], [0], color='b', lw=2), mlines.Line2D([0], [0], color='r', lw=2), mlines.Line2D([0], [0], color='c', lw=2) ] legend_labels = [ 'identity', 'relu', 'sigmoid', 'tanh', 'geom', 'arith', 'exp' ] schedules = [{ "title": "Geometric", "schedule": mlrose.GeomDecay(init_temp=10, decay=0.95, min_temp=1), "abbrev": "geom" }, { "title": "Arithmetic", "schedule": mlrose.ArithDecay(init_temp=10, decay=0.95, min_temp=1), "abbrev": "arith" }, { "title": "Exponential", "schedule": mlrose.ExpDecay(init_temp=10, exp_const=0.05, min_temp=1), "abbrev": "exp" }] for index, activation in enumerate(activations): for jindex, schedule in enumerate(schedules): nn_model = mlrose.NeuralNetwork(hidden_nodes=[8, 6, 5], activation=activation, algorithm='simulated_annealing', schedule=schedule['schedule'], max_iters=1000, bias=True, is_classifier=True, learning_rate=0.0001, early_stopping=True, clip_max=5, max_attempts=100, random_state=3) fitted_model = nn_model.fit(train_x, train_y) # Assess accuracy on test set y_test_pred = nn_model.predict(test_x) plt.plot(fitted_model.loss, accuracy_score(test_y, y_test_pred), linestyle='-', c=colors[jindex], label=activation, marker=markers[index]) plt.title("NN Training: SA \n Decay Schedules") plt.xlabel("Loss") plt.ylabel("Accuracy") plt.legend(legend_items, legend_labels, loc="lower right") plt.tight_layout() plt.savefig("nn_sa_by_schedule") plt.cla()
def NeuralNetOptimizeSA(ImportedData, Data): iterations = [25, 75, 225] # SA parameters decay = ['geom', 'exp', 'arith'] print("Optimizing SA") decay_lookup = { 'geom': mlrose.GeomDecay(), 'exp': mlrose.ExpDecay(), 'arith': mlrose.ArithDecay() } fig = plt.figure(figsize=(12, 8)) ax = fig.gca(projection='3d') fig.suptitle("Neural Nets SA") title = "SA" elapsed_arr = np.zeros((len(decay), len(iterations))) train_arr = np.zeros((len(decay), len(iterations))) test_arr = np.zeros((len(decay), len(iterations))) cv_arr = np.zeros((len(decay), len(iterations))) f1_arr = np.zeros((len(decay), len(iterations))) itr = 0 for i in iterations: rest = 0 for r in decay: nn = mlrose.NeuralNetwork(hidden_nodes=[20], algorithm='simulated_annealing', max_iters=i, schedule=decay_lookup[decay[rest]], curve=False) t0 = time.time() nn.fit(Data['xTrain'], Data['yTrain']) elapsed_arr[rest][itr] = time.time() - t0 yPred = nn.predict(Data["xTest"]) train_arr[rest][itr] = accuracy_score( Data['yTrain'], nn.predict(Data['xTrain'])) * 100 test_arr[rest][itr] = accuracy_score(Data['yTest'], yPred) * 100 cv_arr[rest][itr] = cross_val_score( nn, Data['xTrain'], Data['yTrain'], cv=5).mean() * 100 f1_arr[rest][itr] = f1_score( Data["yTest"], yPred, average='binary') * 100 rest += 1 itr += 1 X, Y = np.meshgrid(range(len(iterations)), range(len(decay))) ax.contour(X, Y, train_arr, zdir='x', offset=0, color='b') ax.contour(X, Y, train_arr, zdir='y', offset=len(decay) - 1, color='b') surf = ax.plot_surface(X, Y, train_arr, lw=2, label='train', color='b', alpha=0.3) surf._facecolors2d = surf._facecolors3d surf._edgecolors2d = surf._edgecolors3d ax.contour(X, Y, test_arr, zdir='x', offset=0, color='g') ax.contour(X, Y, test_arr, zdir='y', offset=len(decay) - 1, color='g') surf = ax.plot_surface(X, Y, test_arr, lw=2, label='test', color='g', alpha=0.3) surf._facecolors2d = surf._facecolors3d surf._edgecolors2d = surf._edgecolors3d ax.contour(X, Y, cv_arr, zdir='x', offset=0, color='r') ax.contour(X, Y, cv_arr, zdir='y', offset=len(decay) - 1, color='r') surf = ax.plot_surface(X, Y, cv_arr, lw=2, label='CV', color='r', alpha=0.3) surf._facecolors2d = surf._facecolors3d surf._edgecolors2d = surf._edgecolors3d ax.contour(X, Y, f1_arr, zdir='x', offset=0, color='c') ax.contour(X, Y, f1_arr, zdir='y', offset=len(decay) - 1, color='c') surf = ax.plot_surface(X, Y, f1_arr, lw=2, label='F1', color='c', alpha=0.3) surf._facecolors2d = surf._facecolors3d surf._edgecolors2d = surf._edgecolors3d ax.set(xlabel="Iterations", ylabel="Decay", zlabel='Accuracy') ax.set(xticks=range(len(iterations)), xticklabels=iterations, yticks=range(len(decay)), yticklabels=decay) fig.legend(loc='center right') plt.tight_layout() #plt.show() saveFigToNewDir(fig, "./", title + "_NeuralNet.png") plt.clf()
def cv_analysis(self): test_acc_sa_1 = [] for i in range(1000, 50000, 2000): print(i) nn_model_sa = self.sa(i, mlrose.GeomDecay()) nn_model_sa.fit(self.training_x, self.training_y) # Predict labels for test set and assess accuracy y_test_pred_sa = nn_model_sa.predict(self.testing_x) y_test_accuracy_sa = accuracy_score(self.testing_y, y_test_pred_sa) test_acc_sa_1.append(y_test_accuracy_sa) test_acc_sa_2 = [] for i in range(1000, 50000, 2000): nn_model_sa = self.sa(i, mlrose.ExpDecay()) nn_model_sa.fit(self.training_x, self.training_y) # Predict labels for test set and assess accuracy y_test_pred_sa = nn_model_sa.predict(self.testing_x) y_test_accuracy_sa = accuracy_score(self.testing_y, y_test_pred_sa) test_acc_sa_2.append(y_test_accuracy_sa) test_acc_sa_3 = [] for i in range(1000, 50000, 2000): nn_model_sa = self.sa(i, mlrose.ArithDecay()) nn_model_sa.fit(self.training_x, self.training_y) # Predict labels for test set and assess accuracy y_test_pred_sa = nn_model_sa.predict(self.testing_x) y_test_accuracy_sa = accuracy_score(self.testing_y, y_test_pred_sa) test_acc_sa_3.append(y_test_accuracy_sa) plt.close() plt.figure() plt.plot(np.arange(1000, 50000, 2000), np.array(test_acc_sa_1), label='Geometric Decay') plt.plot(np.arange(1000, 50000, 2000), np.array(test_acc_sa_2), label='Exponential Decay') plt.plot(np.arange(1000, 50000, 2000), np.array(test_acc_sa_3), label='Arithmetic Decay') plt.title('Neural Network SA Analysis') plt.legend(loc="best") plt.xlabel('Number of Iterations') plt.ylabel('Testing Accuracy') plt.savefig(os.path.join(self.output_path, 'NN_SA_analysis.png')) test_acc_ga_1 = [] for i in range(1000, 50000, 2000): print(i) nn_model_ga = self.ga(i, pop_size=100, mutation_prob=0.1) nn_model_ga.fit(self.training_x, self.training_y) # Predict labels for test set and assess accuracy y_test_pred_ga = nn_model_ga.predict(self.testing_x) y_test_accuracy_ga = accuracy_score(self.testing_y, y_test_pred_ga) test_acc_ga_1.append(y_test_accuracy_ga) test_acc_ga_2 = [] for i in range(1000, 50000, 2000): nn_model_ga = self.ga(i, pop_size=200, mutation_prob=0.1) nn_model_ga.fit(self.training_x, self.training_y) # Predict labels for test set and assess accuracy y_test_pred_ga = nn_model_ga.predict(self.testing_x) y_test_accuracy_ga = accuracy_score(self.testing_y, y_test_pred_ga) test_acc_ga_2.append(y_test_accuracy_ga) test_acc_ga_3 = [] for i in range(1000, 50000, 2000): nn_model_ga = self.ga(i, pop_size=500, mutation_prob=0.1) nn_model_ga.fit(self.training_x, self.training_y) # Predict labels for test set and assess accuracy y_test_pred_ga = nn_model_ga.predict(self.testing_x) y_test_accuracy_ga = accuracy_score(self.testing_y, y_test_pred_ga) test_acc_ga_3.append(y_test_accuracy_ga) test_acc_ga_4 = [] for i in range(1000, 50000, 2000): nn_model_ga = self.ga(i, pop_size=100, mutation_prob=0.5) nn_model_ga.fit(self.training_x, self.training_y) # Predict labels for test set and assess accuracy y_test_pred_ga = nn_model_ga.predict(self.testing_x) y_test_accuracy_ga = accuracy_score(self.testing_y, y_test_pred_ga) test_acc_ga_4.append(y_test_accuracy_ga) test_acc_ga_5 = [] for i in range(1000, 50000, 2000): nn_model_ga = self.ga(i, pop_size=200, mutation_prob=0.5) nn_model_ga.fit(self.training_x, self.training_y) # Predict labels for test set and assess accuracy y_test_pred_ga = nn_model_ga.predict(self.testing_x) y_test_accuracy_ga = accuracy_score(self.testing_y, y_test_pred_ga) test_acc_ga_5.append(y_test_accuracy_ga) test_acc_ga_6 = [] for i in range(1000, 50000, 2000): nn_model_ga = self.ga(i, pop_size=500, mutation_prob=0.5) nn_model_ga.fit(self.training_x, self.training_y) # Predict labels for test set and assess accuracy y_test_pred_ga = nn_model_ga.predict(self.testing_x) y_test_accuracy_ga = accuracy_score(self.testing_y, y_test_pred_ga) test_acc_ga_6.append(y_test_accuracy_ga) plt.close() plt.figure() plt.plot(np.arange(1000, 50000, 2000), np.array(test_acc_ga_1), label='0.1 and 100') plt.plot(np.arange(1000, 50000, 2000), np.array(test_acc_ga_2), label='0.1 and 200') plt.plot(np.arange(1000, 50000, 2000), np.array(test_acc_ga_3), label='0.1 and 500') plt.plot(np.arange(1000, 50000, 2000), np.array(test_acc_ga_4), label='0.5 and 100') plt.plot(np.arange(1000, 50000, 2000), np.array(test_acc_ga_5), label='0.5 and 200') plt.plot(np.arange(1000, 50000, 2000), np.array(test_acc_ga_6), label='0.5 and 500') plt.title('Neural Network GA Analysis') plt.legend(loc="best") plt.xlabel('Number of Iterations') plt.ylabel('Testing Accuracy') plt.savefig(os.path.join(self.output_path, 'NN_GA_analysis.png'))
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()
import six import sys sys.modules['sklearn.externals.six'] = six import mlrose from problem import fitnessFunction, showProducts fitness = mlrose.CustomFitness(fitnessFunction) problem = mlrose.DiscreteOpt(length=14, fitness_fn=fitness, maximize=True, max_val=2) bestSoluction, bestCost = mlrose.simulated_annealing( problem, schedule=mlrose.ArithDecay()) print('Soluction: ', bestSoluction) showProducts(bestSoluction)
test_pred = based_model.predict(X_test) #print(based_model.predicted_probs) print("testing data accuracy: "+str(accuracy_score(y_test, test_pred)*100)+"%") # RHC opti_model = mlrose.NeuralNetwork(hidden_nodes = [50, 20, 8, 2], activation = "relu", \ bias = True, is_classifier = True, early_stopping = True, \ algorithm=algos[1], \ max_iters=options["max_iter"], max_attempts=options["max_iter"]*0.1, \ learning_rate=options["lrate"]) if params["optimization_algo"] == 2: # SA schedule = mlrose.GeomDecay() if options["sched"] == 1: schedule = mlrose.ArithDecay() elif options["sched"] == 2: schedule = mlrose.ExpDecay() opti_model = mlrose.NeuralNetwork(hidden_nodes = [50, 20, 8, 2], activation = "relu", \ bias = True, is_classifier = True, early_stopping = True, \ algorithm=algos[2], \ max_iters=options["max_iter"], max_attempts=options["max_iter"]*0.1, \ learning_rate=options["lrate"], \ schedule=schedule) elif params["optimization_algo"] == 3: #GA opti_model = mlrose.NeuralNetwork(hidden_nodes = [50, 20, 8, 2], activation = "relu", \ bias = True, is_classifier = True, early_stopping = True, \ algorithm=algos[3], \ max_iters=options["max_iter"], max_attempts=options["max_iter"]*0.1, \
X = dataset[1:303, 0:12].astype(float) Y = dataset[1:303, 13].astype(int) X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=3) # Normalize feature data scaler = MinMaxScaler() X_train_scaled = scaler.fit_transform(X_train) X_test_scaled = scaler.transform(X_test) # One hot encode target values lr = [0.001, 0.01, 0.1] max_iters = [1000, 5000, 10000, 25000, 50000] decays = [mlrose.ArithDecay(), mlrose.GeomDecay(), mlrose.ExpDecay()] res = [] nn_model1 = mlrose.NeuralNetwork(hidden_nodes=[2, 7, 1], activation='relu', algorithm='simulated_annealing', schedule=decays[0], max_iters=70000, bias=True, is_classifier=True, learning_rate=0.01, early_stopping=False, clip_max=10, max_attempts=30) # Predict labels for train set and assess accuracy
rhc_best_state, rhc_best_fitness, rhc_curve = mlrose.random_hill_climb( problem, max_attempts=rhc_max_attempts, max_iters=rhc_max_iters, restarts=rhc_restarts, curve=True, random_state=SEED) rhc_time = time.perf_counter() - start_time print("RHC best fitness: {0:.0f} in {1:.4f} seconds and {2} iterations".format( rhc_best_fitness, rhc_time, len(rhc_curve))) # print('RHC best state:\n', rhc_best_state) # SA sa_max_attempts = 500 sa_max_iters = np.inf sa_schedule = mlrose.ArithDecay(init_temp=10) start_time = time.perf_counter() sa_best_state, sa_best_fitness, sa_curve = mlrose.simulated_annealing( problem, schedule=sa_schedule, max_attempts=sa_max_attempts, max_iters=sa_max_iters, curve=True, random_state=SEED) sa_time = time.perf_counter() - start_time print("SA best fitness: {0:.0f} in {1:.4f} seconds and {2} iterations".format( sa_best_fitness, sa_time, len(sa_curve))) # print('SA best state:\n', sa_best_state) # GA ga_max_attempts = 1
def optimizeNeuralNetworWeights(self, optimizer): self.NNmaxIter = np.arange(5, 1006, 100) if (optimizer == 'genetic_alg'): self.NNmaxIter = np.arange(5, 1006, 250) kFold = 5 kFoldGen = 1 iteration = 0 learner = [] legend = [] timeTraining = [] learnersTrainingScore = [] learnersTestingScore = [] learnersTrainingScoreStd = [] learnersTestingScoreStd = [] kFoldTrainingScore = [] kFoldTestingScore = [] learnersTime = [] learnersTimeStd = [] kFoldTime = [] for iter in self.NNmaxIter: learner.append([]) legend.append([]) if (optimizer == 'gradient_descent'): nn = mlrose.NeuralNetwork(hidden_nodes=[20], activation='relu', algorithm='gradient_descent', max_iters=int(iter), bias=True, is_classifier=True, learning_rate=0.001, early_stopping=False, clip_max=1e10, curve=False) learner[iteration].append(nn) legend[iteration].append('GA') elif (optimizer == 'simulated_annealing'): nn = mlrose.NeuralNetwork(hidden_nodes=[20], activation='relu', algorithm='simulated_annealing', max_iters=int(iter), bias=True, is_classifier=True, learning_rate=0.001, early_stopping=False, clip_max=1e10, schedule=mlrose.ExpDecay(), curve=False) learner[iteration].append(nn) legend[iteration].append('Exp') nn = mlrose.NeuralNetwork(hidden_nodes=[20], activation='relu', algorithm='simulated_annealing', max_iters=int(iter), bias=True, is_classifier=True, learning_rate=0.001, early_stopping=False, clip_max=1e10, schedule=mlrose.ArithDecay(), curve=False) learner[iteration].append(nn) legend[iteration].append('Arithmetic') nn = mlrose.NeuralNetwork(hidden_nodes=[20], activation='relu', algorithm='simulated_annealing', max_iters=int(iter), bias=True, is_classifier=True, learning_rate=0.001, early_stopping=False, clip_max=1e10, schedule=mlrose.GeomDecay(), curve=False) learner[iteration].append(nn) legend[iteration].append('Geometric') elif (optimizer == 'genetic_alg'): nn = mlrose.NeuralNetwork(hidden_nodes=[20], activation='relu', algorithm='genetic_alg', max_iters=int(iter), bias=True, is_classifier=True, learning_rate=0.001, early_stopping=False, clip_max=1e10, pop_size=300, mutation_prob=0.2, curve=False) learner[iteration].append(nn) legend[iteration].append('300') nn = mlrose.NeuralNetwork(hidden_nodes=[20], activation='relu', algorithm='genetic_alg', max_iters=int(iter), bias=True, is_classifier=True, learning_rate=0.001, early_stopping=False, clip_max=1e10, pop_size=200, mutation_prob=0.2, curve=False) learner[iteration].append(nn) legend[iteration].append('200') nn = mlrose.NeuralNetwork(hidden_nodes=[20], activation='relu', algorithm='genetic_alg', max_iters=int(iter), bias=True, is_classifier=True, learning_rate=0.001, early_stopping=False, clip_max=1e10, pop_size=100, mutation_prob=0.2, curve=False) learner[iteration].append(nn) legend[iteration].append('100') nn = mlrose.NeuralNetwork(hidden_nodes=[20], activation='relu', algorithm='genetic_alg', max_iters=int(iter), bias=True, is_classifier=True, learning_rate=0.001, early_stopping=False, clip_max=1e10, pop_size=200, mutation_prob=0.1, curve=False) learner[iteration].append(nn) legend[iteration].append('0.1') nn = mlrose.NeuralNetwork(hidden_nodes=[20], activation='relu', algorithm='genetic_alg', max_iters=int(iter), bias=True, is_classifier=True, learning_rate=0.001, early_stopping=False, clip_max=1e10, pop_size=200, mutation_prob=0.2, curve=False) learner[iteration].append(nn) legend[iteration].append('0.2') nn = mlrose.NeuralNetwork(hidden_nodes=[20], activation='relu', algorithm='genetic_alg', max_iters=int(iter), bias=True, is_classifier=True, learning_rate=0.001, early_stopping=False, clip_max=1e10, pop_size=200, mutation_prob=0.3, curve=False) learner[iteration].append(nn) legend[iteration].append('0.3') kFold = kFoldGen elif (optimizer == 'random_hill_climb'): nn = mlrose.NeuralNetwork(hidden_nodes=[20], activation='relu', algorithm='random_hill_climb', max_iters=int(iter), bias=True, is_classifier=True, learning_rate=0.001, early_stopping=False, clip_max=1e10, curve=False) learner[iteration].append(nn) legend[iteration].append('RHC') iteration += 1 for l in range(len(learner[0])): learnersTrainingScore.append([]) learnersTestingScore.append([]) learnersTrainingScoreStd.append([]) learnersTestingScoreStd.append([]) learnersTime.append([]) learnersTimeStd.append([]) for iter in range(len(self.NNmaxIter)): learnersTrainingScore[l].append(l) learnersTestingScore[l].append(l) learnersTrainingScoreStd[l].append(l) learnersTestingScoreStd[l].append(l) learnersTime[l].append(l) learnersTimeStd[l].append(l) kFoldTrainingScore = [] kFoldTestingScore = [] kFoldTime = [] for k in range(kFold): training_x, testing_x, training_y, testing_y = ms.train_test_split( self.dataset1.training_x, self.dataset1.training_y, test_size=0.2, random_state=self.dataset1.seed, stratify=self.dataset1.training_y) timeStart = time.time() learner[iter][l].fit(training_x, training_y) timeTraining = (time.time() - timeStart) trainingF1 = f1_score(learner[iter][l].predict(training_x), training_y, average='weighted') testingF1 = f1_score(learner[iter][l].predict(testing_x), testing_y, average='weighted') kFoldTrainingScore.append(trainingF1) kFoldTestingScore.append(testingF1) kFoldTime.append(timeTraining) learnersTrainingScore[l][iter] = (np.mean(kFoldTrainingScore)) learnersTestingScore[l][iter] = (np.mean(kFoldTestingScore)) learnersTrainingScoreStd[l][iter] = (np.std(kFoldTrainingScore)) learnersTestingScoreStd[l][iter] = (np.std(kFoldTestingScore)) learnersTime[l][iter] = (np.mean(kFoldTime)) learnersTimeStd[l][iter] = (np.std(kFoldTime)) learnersTrainingScore = np.array(learnersTrainingScore) learnersTestingScore = np.array(learnersTestingScore) learnersTrainingScoreStd = np.array(learnersTrainingScoreStd) learnersTestingScoreStd = np.array(learnersTestingScoreStd) learnersTime = np.array(learnersTime) learnersTimeStd = np.array(learnersTimeStd) learnerCount = 0 if (optimizer != 'genetic_alg'): plt.style.use('seaborn-whitegrid') for l in range(len(learnersTrainingScore)): plt.plot(self.NNmaxIter, learnersTrainingScore[l], label='Train for ' + legend[0][l]) plt.plot(self.NNmaxIter, learnersTestingScore[l], label='Valid. for ' + legend[0][l]) plt.ylabel('Score', fontsize=12) plt.xlabel('Number of Iterations', fontsize=12) plt.title('F1 Score for NN trained using ' + optimizer, fontsize=12, y=1.03) plt.legend() plt.savefig('Figures/' + optimizer + '-F1-Score.png') plt.close() else: plt.style.use('seaborn-whitegrid') splitParams = int(len(learnersTrainingScore) / 2) for l in range(splitParams): plt.plot(self.NNmaxIter, learnersTrainingScore[l], label='Train for ' + legend[0][l]) plt.plot(self.NNmaxIter, learnersTestingScore[l], label='Valid. for ' + legend[0][l]) plt.ylabel('Score', fontsize=12) plt.xlabel('Number of Iterations', fontsize=12) plt.title('F1 Score for NN trained using ' + optimizer, fontsize=12, y=1.03) plt.legend() plt.savefig('Figures/' + optimizer + '-F1-Score, 1.png') plt.close() plt.style.use('seaborn-whitegrid') for l in range(splitParams): plt.plot(self.NNmaxIter, learnersTrainingScore[l+splitParams], label='Train for ' + legend[0][l+splitParams]) plt.plot(self.NNmaxIter, learnersTestingScore[l+splitParams], label='Valid. for ' + legend[0][l+splitParams]) plt.ylabel('Score', fontsize=12) plt.xlabel('Number of Iterations', fontsize=12) plt.title('F1 Score for NN trained using ' + optimizer, fontsize=12, y=1.03) plt.legend() plt.savefig('Figures/' + optimizer + '-F1-Score, 2.png') plt.close() return learnersTrainingScore, learnersTrainingScoreStd, learnersTestingScore, learnersTestingScoreStd, learnersTime, learnersTimeStd