def n_queens_sa(nq_problem,
initial_state,
max_iters=np.inf,
num_runs=20,
verbose=False):
hp_name = 'schedule'
hp_values = [mlrose.ArithDecay(), mlrose.GeomDecay(), mlrose.ExpDecay()]
hp_values_strings = [
val.get_info__()['schedule_type'] for val in hp_values
]
# run for each hp value and append results to list
fitness_dfs = []
runs = np.arange(num_runs)
for hp_value, hp_value_string in zip(hp_values, hp_values_strings):
schedule = hp_value # set varied HP at beginning of loop
run_times = np.zeros(num_runs)
fitness_data = pd.DataFrame()
for run in runs:
run_t0 = time()
best_state, best_fitness, fitness_curve = mlrose.simulated_annealing(
problem=nq_problem,
schedule=schedule,
max_attempts=10,
max_iters=max_iters,
curve=True,
)
run_time = time() - run_t0
run_times[run] = run_time
fitness_data = pd.concat(
[fitness_data, pd.DataFrame(fitness_curve)],
axis=1,
sort=False)
fitness_data.columns = runs
fitness_data = fitness_data.fillna(method='ffill')
fitness_dfs.append(fitness_data)
# calculate and print avg time per run
avg_run_time = np.average(run_times)
print("N-Queens - SA avg run time,", hp_value_string, hp_name, ":",
avg_run_time)
# generate plots
plot_title = "N-Queens SA: fitness vs. iterations"
plotting.plot_fitness_curves(
fitness_dfs=fitness_dfs,
hp_values=hp_values_strings,
hp_name=hp_name,
title=plot_title,
)
plt.savefig('graphs/n_queens_sa_fitness.png')
plt.clf()
return fitness_dfs
def compare_multi_round_k_color():
global count
count = 0
fitness_obj = mlrose.CustomFitness(k_color_fit)
opt = mlrose.DiscreteOpt(50, fitness_obj, maximize=True, max_val=8)
fitness_list_rhc = []
fitness_list_ann = []
fitness_list_genetic = []
fitness_list_mimic = []
num_sample_rhc = []
num_sample_ann = []
num_sample_genetic = []
num_sample_mimic = []
for i in range(20):
best_state_climb, best_fitness_climb, fitness_curve_climb = mlrose.random_hill_climb(
opt, curve=True)
fitness_list_rhc.append(best_fitness_climb)
num_sample_rhc.append(count)
count = 0
best_state_ann, best_fitness_ann, fitness_curve_ann = mlrose.simulated_annealing(
opt, schedule=mlrose.ExpDecay(), curve=True)
fitness_list_ann.append(best_fitness_ann)
num_sample_ann.append(count)
count = 0
best_state_ga, best_fitness_ga, fitness_curve_ga = mlrose.genetic_alg(
opt, pop_size=500, mutation_prob=0.5, curve=True)
fitness_list_genetic.append(best_fitness_ga)
num_sample_genetic.append(count)
count = 0
best_state_mimic, best_fitness_mimic, fitness_curve_mimic = mlrose.mimic(
opt, pop_size=500, curve=True)
fitness_list_mimic.append(best_fitness_mimic)
num_sample_mimic.append(count)
count = 0
plt.figure(figsize=(10, 6))
plt.subplot(121)
plt.plot(fitness_list_rhc, label='rhc')
plt.plot(fitness_list_ann, label='ann')
plt.plot(fitness_list_genetic, label='ga')
plt.plot(fitness_list_mimic, label='mimic')
plt.xlabel('rounds')
plt.ylabel('finess value')
plt.title('fitness value comparision')
plt.legend(loc='lower right')
plt.subplot(122)
plt.plot(num_sample_rhc, label='rhc')
plt.plot(num_sample_ann, label='ann')
plt.plot(num_sample_genetic, label='ga')
plt.plot(num_sample_mimic, label='mimic')
plt.xlabel('rounds')
plt.ylabel('fitness calls')
plt.title('fitness call number comparision')
plt.legend(loc='upper right')
plt.show()
def sa(problem, init_state, max_attempts, max_iters):
# Define decay schedule
schedule = mlrose_hiive.ExpDecay()
# Define initial state
# init_state = np.array([0, 1, 2, 3, 4, 5, 6, 7])
# Solve problem using simulated annealing
best_state, best_fitness, fitness_curve = mlrose_hiive.simulated_annealing(problem, schedule = schedule,
max_attempts = max_attempts, max_iters = max_iters,init_state = init_state, curve=True, random_state = 1)
print('simulated annealing')
print(best_state)
print(best_fitness)
# print(fitness_curve)
return best_state, best_fitness, fitness_curve
def scale_ann(train_features_spam_norm, train_labels_spam,
test_features_spam_norm, test_labels_spam):
global count
train_acc_list = []
test_acc_list = []
fitness_call_list = []
loss_list = []
for i in range(400, 4001, 400):
count = 0
train_features_sub = train_features_spam_norm[:i, :]
train_labels_sub = train_labels_spam[:i]
fitness_obj = mlrose.CustomFitness(spam_nn_fit,
train_features=train_features_sub,
train_labels=train_labels_sub)
opt = mlrose.DiscreteOpt(237, fitness_obj, maximize=True, max_val=1001)
best_state_spam, best_fitness_spam, _ = mlrose.simulated_annealing(
opt, schedule=mlrose.ExpDecay(exp_const=0.003), curve=True)
loss_list.append(best_fitness_spam)
train_predict = predict(best_state_spam, train_features_sub)
test_predict = predict(best_state_spam, test_features_spam_norm)
fitness_call_list.append(count)
train_acc_list.append(accuracy_score(train_labels_sub, train_predict))
test_acc_list.append(accuracy_score(test_labels_spam, test_predict))
plt.figure(figsize=(10, 6))
plt.subplot(121)
plt.plot(np.arange(400, 4001, 400), loss_list, label='-1*loss')
plt.xlabel('training size')
plt.ylabel('-1*loss')
plt.title('loss versus training size')
plt.legend()
plt.subplot(122)
plt.plot(np.arange(400, 4001, 400), train_acc_list, label='train')
plt.plot(np.arange(400, 4001, 400), test_acc_list, label='test')
plt.xlabel('training size')
plt.ylabel('accuracy')
plt.title('accuracy versus training size')
plt.legend()
plt.show()
# fitness calls versus training size
plt.figure(figsize=(6, 6))
plt.plot(np.arange(400, 4001, 400), fitness_call_list, label='#.calls')
plt.xlabel('training size')
plt.ylabel('fitness calls')
plt.legend()
plt.show()
def generate_nn_model(alg_name, hidden_nodes=[30, 20], seed=None):
nn_model = None
## RHC
if (alg_name == 'rhc'):
nn_model = mlrose_hiive.NeuralNetwork(hidden_nodes=hidden_nodes, activation='relu',
algorithm='random_hill_climb',
restarts=50,
bias=True, is_classifier=True,
early_stopping=True, clip_max=5,
random_state=seed,
max_iters=1000,
learning_rate=0.001,
max_attempts=100)
## SA
elif (alg_name == 'sa'):
nn_model = mlrose_hiive.NeuralNetwork(hidden_nodes=hidden_nodes, activation='relu',
algorithm='simulated_annealing',
schedule=mlrose_hiive.ExpDecay(),
bias=True, is_classifier=True,
early_stopping=True, clip_max=5,
random_state=seed,
max_iters=1000,
learning_rate=0.0001,
max_attempts=100)
## GA
elif (alg_name == 'ga'):
nn_model = mlrose_hiive.NeuralNetwork(hidden_nodes=hidden_nodes, activation='relu',
algorithm='genetic_alg',
pop_size = 200,
mutation_prob = 0.25,
bias=True, is_classifier=True,
early_stopping=True, clip_max=5,
random_state=seed,
max_iters=1000,
learning_rate=0.0001,
max_attempts=100)
else:
print('Algorithm Name Error')
return nn_model
def runSA(self):
default = {
'problem': self.problem,
'schedule': self.schedule,
'max_attempts': 10,
'max_iters': 1000,
'init_state': self.init_state,
'curve': True,
'random_state': 1
}
maxAttempts = [5, 10, 20]
schedules = [mlrose.GeomDecay(), mlrose.ExpDecay(),
mlrose.ArithDecay()]
bestFitness = None
(bestState, bestCurve, bestParams) = None, None, None
for i in maxAttempts:
for j in schedules:
params = _.assign(
{}, default, {'max_attempts': i, 'schedule': j})
scores = []
for r in range(5):
randomSeed = np.random.randint(0, 1000)
params = _.assign(
{}, params, {'random_state': randomSeed})
state, fitness, curve = self._run(
mlrose.simulated_annealing, name='%s' % i, **params)
scores.append(fitness)
avgFitness = np.mean(scores)
if bestFitness == None or (self.isMaximize and avgFitness > bestFitness) or (not self.isMaximize and avgFitness < bestFitness):
bestFitness = avgFitness
(bestState, bestCurve, bestParams) = state, curve, params
# if fitness == 0:
# break
print('SA - Params: %s' % bestParams)
log.info('\tSA - Best fitness found: %s\n\t\tmaxAttempts: %s \n\t\tschedule: %s' %
(bestFitness, bestParams['max_attempts'], type(bestParams['schedule']).__name__))
return bestCurve
def simulated_annealing(problem, init_state, max_attempts, max_iters):
schedule = mlr.ExpDecay() # Tune this?
start_time = time.time()
best_state, best_fitness, fitness_curve = mlr.simulated_annealing(
problem,
schedule=schedule,
max_attempts=max_attempts,
max_iters=max_iters,
init_state=init_state,
curve=True,
random_state=RANDOM_STATE)
end_time = time.time()
total_time = end_time - start_time
print('Simulated Annealing')
print("Elapsed Time", total_time)
#print(best_state)
print(best_fitness)
# print(fitness_curve)
return best_state, best_fitness, fitness_curve, total_time
def s_ann(opt):
global count
count = 0
ann_loss_list = []
ann_train_acc_list = []
ann_test_acc_list = []
for exp_value in np.arange(0.0005, 0.0101, 0.0005):
best_state_spam, best_fitness_spam, _ = mlrose.simulated_annealing(
opt, schedule=mlrose.ExpDecay(exp_const=exp_value), curve=True)
train_predict_gen = predict(best_state_spam, train_features_spam_norm)
test_predict_gen = predict(best_state_spam, test_features_spam_norm)
train_accuracy_hill = accuracy_score(train_labels_spam,
train_predict_gen)
test_accuracy_hill = accuracy_score(test_labels_spam, test_predict_gen)
ann_loss_list.append(best_fitness_spam)
ann_train_acc_list.append(train_accuracy_hill)
ann_test_acc_list.append(test_accuracy_hill)
plt.figure(figsize=(10, 6))
plt.subplot(121)
plt.plot(np.arange(0.0005, 0.0101, 0.0005), ann_loss_list, label='-1*loss')
plt.xlabel('exp_const value')
plt.ylabel('minus of loss')
plt.title('loss versus exp_const value')
plt.legend(loc='lower right')
plt.subplot(122)
plt.plot(np.arange(0.0005, 0.0101, 0.0005),
ann_train_acc_list,
label='train')
plt.plot(np.arange(0.0005, 0.0101, 0.0005),
ann_test_acc_list,
label='test')
plt.xlabel('exp_const value')
plt.ylabel('accuracy')
plt.title('accuracy versus exp_const value')
plt.legend(loc='lower right')
plt.show()
#transform data using StandardScaler
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
hidden_layers = [12, 6, 4, 2]
models = {}
algos = {
'SA': {
'algorithm': ['simulated_annealing'],
'schedule': [
mlrose.GeomDecay(init_temp=1, decay=0.99),
mlrose.GeomDecay(init_temp=100, decay=0.99),
mlrose.GeomDecay(init_temp=1000, decay=0.99),
mlrose.ExpDecay(init_temp=1, exp_const=0.05),
mlrose.ExpDecay(init_temp=100, exp_const=0.05),
mlrose.ExpDecay(init_temp=1000, exp_const=0.05),
],
'max_iters': [3000],
'learning_rate': [0.5],
'activation': ['relu', 'sigmoid', 'tanh'],
'clip_max': [10.0]
},
'GA': {
'algorithm': ['genetic_alg'],
'pop_size': [100, 500],
'mutation_prob': [0.3, 0.5],
'max_iters': [3000],
'learning_rate': [0.5],
'activation': ['relu', 'sigmoid', 'tanh'],
def method_compare(opt, train_features_spam_norm, train_labels_spam,
test_features_spam_norm, test_labels_spam):
#best_state_spam,best_fitness_spam,fitness_curve=mlrose.simulated_annealing(opt,schedule=mlrose.ExpDecay(),curve=True)
#best_state_spam,best_fitness_spam,fitness_curve=mlrose.genetic_alg(opt,pop_size=2000,curve=True)
global count
count = 0
loss_list_rhc = []
loss_list_ann = []
loss_list_ga = []
train_acc_list_rhc = []
train_acc_list_ann = []
train_acc_list_ga = []
test_acc_list_rhc = []
test_acc_list_ann = []
test_acc_list_ga = []
fitness_call_list_rhc = []
fitness_call_list_ann = []
fitness_call_list_ga = []
# ten rounds of rhc
for i in range(10):
count = 0
best_state_spam, best_fitness_spam, fitness_curve = mlrose.random_hill_climb(
opt, restarts=70, curve=True)
loss_list_rhc.append(best_fitness_spam)
train_predict_rhc = predict(best_state_spam, train_features_spam_norm)
test_predict_rhc = predict(best_state_spam, test_features_spam_norm)
train_acc_list_rhc.append(
accuracy_score(train_labels_spam, train_predict_rhc))
test_acc_list_rhc.append(
accuracy_score(test_labels_spam, test_predict_rhc))
fitness_call_list_rhc.append(count)
#ten rounds of simulated annealing
for i in range(10):
count = 0
best_state_spam, best_fitness_spam, _ = mlrose.simulated_annealing(
opt, schedule=mlrose.ExpDecay(exp_const=0.003), curve=True)
loss_list_ann.append(best_fitness_spam)
train_predict_ann = predict(best_state_spam, train_features_spam_norm)
test_predict_ann = predict(best_state_spam, test_features_spam_norm)
train_acc_list_ann.append(
accuracy_score(train_labels_spam, train_predict_ann))
test_acc_list_ann.append(
accuracy_score(test_labels_spam, test_predict_ann))
fitness_call_list_ann.append(count)
#ten rounds of genetic algorithm
for i in range(10):
count = 0
best_state_spam, best_fitness_spam, _ = mlrose.genetic_alg(
opt, pop_size=1000, curve=True)
loss_list_ga.append(best_fitness_spam)
train_predict_ga = predict(best_state_spam, train_features_spam_norm)
test_predict_ga = predict(best_state_spam, test_features_spam_norm)
train_acc_list_ga.append(
accuracy_score(train_labels_spam, train_predict_ga))
test_acc_list_ga.append(
accuracy_score(test_labels_spam, test_predict_ga))
fitness_call_list_ga.append(count)
#plot loss curve
plt.figure(figsize=(6, 6))
plt.plot(np.arange(1, 11), loss_list_rhc, label='rhc')
plt.plot(np.arange(1, 11), loss_list_ann, label='s_ann')
plt.plot(np.arange(1, 11), loss_list_ga, label='ga')
plt.xlabel('rounds')
plt.ylabel('-1*losss')
plt.title('loss versus different algorithm')
plt.legend()
plt.show()
#plot acc curve
plt.figure(figsize=(15, 6))
plt.subplot(131)
plt.plot(np.arange(1, 11), train_acc_list_rhc, label='train')
plt.plot(np.arange(1, 11), test_acc_list_rhc, label='test')
plt.xlabel('rounds')
plt.ylabel('accuracy')
plt.title('rhc')
plt.legend()
plt.subplot(132)
plt.plot(np.arange(1, 11), train_acc_list_ann, label='train')
plt.plot(np.arange(1, 11), test_acc_list_ann, label='test')
plt.xlabel('rounds')
plt.ylabel('accuracy')
plt.title('simulated annealing')
plt.legend()
plt.subplot(133)
plt.plot(np.arange(1, 11), train_acc_list_ga, label='train')
plt.plot(np.arange(1, 11), test_acc_list_ga, label='test')
plt.xlabel('rounds')
plt.ylabel('accuracy')
plt.title('genetic algorithm')
plt.legend()
#plot fitness call
plt.figure(figsize=(6, 6))
plt.plot(np.arange(1, 11), fitness_call_list_rhc, label='rhc')
plt.plot(np.arange(1, 11), fitness_call_list_ann, label='s_ann')
plt.plot(np.arange(1, 11), fitness_call_list_ga, label='ga')
plt.xlabel('rounds')
plt.ylabel('fitness call number')
plt.title('fitness call num versus different algorithm')
plt.legend()
plt.show()
def method_compare():
global count
count = 0
fitness_obj = mlrose.CustomFitness(n_peak_fit)
opt = mlrose.DiscreteOpt(1, fitness_obj, maximize=True, max_val=10000)
best_state_climb, best_fitness_climb, fitness_curve_climb = mlrose.random_hill_climb(
opt, curve=True)
print('---------------------random hill climb-------------------------')
print('hill climbing best state for n-peak problem:', best_state_climb)
print('hill climbing best fitness for n-peak problem:', best_fitness_climb)
print('hill climbing fitting curve for n-peak problem:',
fitness_curve_climb)
print('number of fitness call used:', count)
count = 0
print('-------------------simulated annealing-------------------------')
best_state_ann, best_fitness_ann, fitness_curve_ann = mlrose.simulated_annealing(
opt, schedule=mlrose.ExpDecay(), curve=True)
print('simulated annealing best state for n-peak problem:', best_state_ann)
print('simulated annealing best fitness for n-peak problem:',
best_fitness_ann)
print('simulated annealing fitting curve for n-peak problem:',
fitness_curve_ann)
print('number of fitness call used:', count)
count = 0
best_state_ga, best_fitness_ga, fitness_curve_ga = mlrose.genetic_alg(
opt, pop_size=20, mutation_prob=0.5, curve=True)
print('---------------------genetic alg----------------------------')
print('genetic algorithm best state for n-peak problem:', best_state_ga)
print('genetic algorithm best fitnees for n-peak problem:',
best_fitness_ga)
print('genetic algorithm fitness curve for n-peak problem:',
fitness_curve_ga)
print('number of fitness call used:', count)
count = 0
best_state_mimic, best_fitness_mimic, fitness_curve_mimic = mlrose.mimic(
opt, pop_size=20, curve=True)
print('------------------------mimic-------------------------------')
print('mimic best state for n-peak problem:', best_state_mimic)
print('mimic best fitness value for n-peak problem:', best_fitness_mimic)
print('mimic curve for n-peak problem:', fitness_curve_mimic)
print('number of fitness calls used:', count)
count = 0
plt.figure(figsize=(10, 10))
plt.subplot(221)
plt.plot(fitness_curve_climb)
plt.ylabel('fitness')
plt.xlabel('num_iter')
plt.ylim(0, 5)
plt.title('random hill climb')
plt.subplot(222)
plt.plot(fitness_curve_ann)
plt.ylabel('fitness')
plt.xlabel('num_iter')
plt.ylim(0, 5)
plt.title('simulated annealing')
plt.subplot(223)
plt.plot(fitness_curve_ga)
plt.ylim(0, 5)
plt.ylabel('fitness')
plt.xlabel('num_iter')
plt.title('genetic algorithm')
plt.subplot(224)
plt.plot(fitness_curve_mimic)
plt.ylim(0, 5)
plt.title('mimic')
plt.ylabel('fitness')
plt.xlabel('num_iter')
plt.show()
def nn_impl():
#iris_data = fetch_openml('iris')
#X_whole, y_whole = iris_data['data'], iris_data['target']
sklearn_data = datasets.load_breast_cancer()
x, y = sklearn_data.data, sklearn_data.target
#x = preprocessing.scale(x)
# Split the initial data
xtrain, xtest, ytrain, ytest = train_test_split(x,
y,
test_size=0.4,
random_state=42)
### Analysis for RHC ###
train_accuracy_scores = []
test_accuracy_scores = []
time_per_iteration_rhc = []
for i in range(1, 3000, 50):
print(i)
rhc_nn = mlrose_hiive.NeuralNetwork(hidden_nodes=[2],
activation='identity',
algorithm='random_hill_climb',
bias=False,
is_classifier=True,
learning_rate=0.6,
clip_max=1,
max_attempts=1000,
max_iters=i)
start = time.time()
rhc_nn.fit(xtrain, ytrain)
# Train set analysis
predictions_train = rhc_nn.predict(xtrain)
accuracy_score_train = accuracy_score(ytrain, predictions_train)
train_accuracy_scores.append(accuracy_score_train)
# Test set analysis
predictions_test = rhc_nn.predict(xtest)
accuracy_score_test = accuracy_score(ytest, predictions_test)
test_accuracy_scores.append(accuracy_score_test)
time_per_iteration_rhc.append(time.time() - start)
plt.figure()
plt.plot(np.arange(1, 3000, 50),
np.array(train_accuracy_scores),
label='Train Accuracy')
plt.plot(np.arange(1, 3000, 50),
np.array(test_accuracy_scores),
label='Test Accuracy')
plt.xlabel('Iterations')
plt.ylabel('Accuracy')
plt.title('Accuracy vs. Iterations (RHC)')
plt.legend()
plt.savefig('testacc_iter_rhc.png')
print("Finished RHC")
### Analysis for Simulated Annealing ###
train_accuracy_scores = []
test_accuracy_scores = []
time_per_iteration_sa = []
for i in range(1, 3000, 50):
print(i)
sa_nn = mlrose_hiive.NeuralNetwork(hidden_nodes=[2],
activation='identity',
algorithm='simulated_annealing',
bias=False,
is_classifier=True,
learning_rate=0.6,
clip_max=1,
max_attempts=1000,
max_iters=i)
start = time.time()
sa_nn.fit(xtrain, ytrain)
# Train set analysis
predictions_train = sa_nn.predict(xtrain)
accuracy_score_train = accuracy_score(ytrain, predictions_train)
train_accuracy_scores.append(accuracy_score_train)
# Test set analysis
predictions_test = sa_nn.predict(xtest)
accuracy_score_test = accuracy_score(ytest, predictions_test)
test_accuracy_scores.append(accuracy_score_test)
time_per_iteration_sa.append(time.time() - start)
plt.figure()
plt.plot(np.arange(1, 3000, 50),
np.array(train_accuracy_scores),
label='Train Accuracy')
plt.plot(np.arange(1, 3000, 50),
np.array(test_accuracy_scores),
label='Test Accuracy')
plt.xlabel('Iterations')
plt.ylabel('Accuracy')
plt.title('Accuracy vs. Iterations (SA)')
plt.legend()
plt.savefig('testacc_iter_SA.png')
print("Finished SA")
### Analysis for Genetic Algorithms ###
train_accuracy_scores = []
test_accuracy_scores = []
time_per_iteration_ga = []
for i in range(1, 3000, 50):
print(i)
ga_nn = mlrose_hiive.NeuralNetwork(hidden_nodes=[2],
activation='identity',
algorithm='genetic_alg',
bias=False,
is_classifier=True,
learning_rate=0.6,
clip_max=1,
max_attempts=1000,
max_iters=i)
start = time.time()
ga_nn.fit(xtrain, ytrain)
# Train set analysis
predictions_train = ga_nn.predict(xtrain)
accuracy_score_train = accuracy_score(ytrain, predictions_train)
train_accuracy_scores.append(accuracy_score_train)
# Test set analysis
predictions_test = ga_nn.predict(xtest)
accuracy_score_test = accuracy_score(ytest, predictions_test)
test_accuracy_scores.append(accuracy_score_test)
time_per_iteration_ga.append(time.time() - start)
plt.figure()
plt.plot(np.arange(1, 3000, 50),
np.array(train_accuracy_scores),
label='Train Accuracy')
plt.plot(np.arange(1, 3000, 50),
np.array(test_accuracy_scores),
label='Test Accuracy')
plt.xlabel('Iterations')
plt.ylabel('Accuracy')
plt.title('Accuracy vs. Iterations (GA)')
plt.legend()
plt.savefig('testacc_iter_GA.png')
print("Finished GA")
### Backpropogation (for comparison) ###
train_accuracy_scores = []
test_accuracy_scores = []
time_per_iteration_bp = []
print("backprop start")
for i in range(1, 3000, 50):
print(i)
bp_nn = MLPClassifier(hidden_layer_sizes=(50, ),
activation='logistic',
max_iter=i)
# bp_nn = mlrose_hiive.NeuralNetwork(hidden_nodes=[2], activation='identity',
# algorithm='gradient_descent',
# bias=False, is_classifier=True,
# learning_rate = 0.6, clip_max=1,
# max_attempts=1000, max_iters = i)
start = time.time()
bp_nn.fit(xtrain, ytrain)
# Train set analysis
predictions_train = bp_nn.predict(xtrain)
accuracy_score_train = accuracy_score(ytrain, predictions_train)
train_accuracy_scores.append(accuracy_score_train)
# Test set analysis
predictions_test = bp_nn.predict(xtest)
accuracy_score_test = accuracy_score(ytest, predictions_test)
test_accuracy_scores.append(accuracy_score_test)
time_per_iteration_bp.append(time.time() - start)
plt.figure()
plt.plot(np.arange(1, 3000, 50),
np.array(train_accuracy_scores),
label='Train Accuracy')
plt.plot(np.arange(1, 3000, 50),
np.array(test_accuracy_scores),
label='Test Accuracy')
plt.xlabel('Iterations')
plt.ylabel('Accuracy')
plt.title('Accuracy vs. Iterations (Backpropogation)')
plt.legend()
plt.savefig('testacc_iter_bp.png')
print("Finished Backprop")
### Plot runtimes for above ###
plt.figure()
plt.plot(np.arange(1, 3000, 50),
np.array(time_per_iteration_rhc),
label='RHC')
plt.plot(np.arange(1, 3000, 50),
np.array(time_per_iteration_sa),
label='SA')
plt.plot(np.arange(1, 3000, 50),
np.array(time_per_iteration_ga),
label='GA')
plt.plot(np.arange(1, 3000, 50),
np.array(time_per_iteration_ga),
label='BP')
plt.xlabel('Iterations')
plt.ylabel('Training Time')
plt.title('Training Time vs Iterations')
plt.legend()
plt.savefig('time_vs_iter.png')
#### Hyperparameter Tuning - RHC ####
## Adjusting the number of random restarts ##
train_accuracy_scores = []
test_accuracy_scores = []
for i in range(0, 500, 25):
print(i)
rhc_nn = mlrose_hiive.NeuralNetwork(hidden_nodes=[2],
activation='identity',
algorithm='random_hill_climb',
bias=False,
is_classifier=True,
learning_rate=0.6,
clip_max=1,
max_attempts=1000,
restarts=i)
rhc_nn.fit(xtrain, ytrain)
# Train set analysis
predictions_train = rhc_nn.predict(xtrain)
accuracy_score_train = accuracy_score(ytrain, predictions_train)
train_accuracy_scores.append(accuracy_score_train)
# Test set analysis
predictions_test = rhc_nn.predict(xtest)
accuracy_score_test = accuracy_score(ytest, predictions_test)
test_accuracy_scores.append(accuracy_score_test)
plt.figure()
plt.plot(np.arange(0, 500, 25),
np.array(train_accuracy_scores),
label='Train Accuracy')
plt.plot(np.arange(0, 500, 25),
np.array(test_accuracy_scores),
label='Test Accuracy')
plt.xlabel('Restarts')
plt.ylabel('Accuracy')
plt.title('Accuracy vs. Number of Restarts (RHC)')
plt.legend()
plt.savefig('rhc_restarts.png')
print("Finished RHC HP Tuning")
#### Hyperparameter Tuning - SA ####
## Adjusting the type of scheduling ##
train_accuracy_scores = []
test_accuracy_scores = []
# Referending sectiion 2.2 'Decay Schedules' here:
# https://readthedocs.org/projects/mlrose/downloads/pdf/stable/
schedule_types = [
mlrose_hiive.ExpDecay(),
mlrose_hiive.ArithDecay(),
mlrose_hiive.GeomDecay()
]
for st in schedule_types:
print(st)
sa_nn = mlrose_hiive.NeuralNetwork(hidden_nodes=[2],
activation='identity',
algorithm='simulated_annealing',
bias=False,
is_classifier=True,
learning_rate=0.6,
clip_max=1,
max_attempts=1000,
schedule=st)
sa_nn.fit(xtrain, ytrain)
# Train set analysis
predictions_train = sa_nn.predict(xtrain)
accuracy_score_train = accuracy_score(ytrain, predictions_train)
train_accuracy_scores.append(accuracy_score_train)
# Test set analysis
predictions_test = sa_nn.predict(xtest)
accuracy_score_test = accuracy_score(ytest, predictions_test)
test_accuracy_scores.append(accuracy_score_test)
plt.figure()
plt.plot(['ExpDecay', 'ArithDecay', 'GeomDecay'],
np.array(train_accuracy_scores),
label='Train Accuracy')
plt.plot(['ExpDecay', 'ArithDecay', 'GeomDecay'],
np.array(test_accuracy_scores),
label='Test Accuracy')
plt.xlabel('Schedule Type')
plt.ylabel('Accuracy')
plt.title('Accuracy vs. Schedule Type (SA)')
plt.legend()
plt.savefig('sa_schedule_type.png')
print("Finished SA HP Tuning")
#### Hyperparameter Tuning - GA ####
## Adjusting the amount of mutation
## Used api as referenced in https://readthedocs.org/projects/mlrose/downloads/pdf/stable/
train_accuracy_scores = []
test_accuracy_scores = []
mutation_prob_array = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]
for i in mutation_prob_array:
ga_nn = mlrose_hiive.NeuralNetwork(hidden_nodes=[2],
activation='relu',
algorithm='genetic_alg',
bias=False,
is_classifier=True,
learning_rate=0.6,
clip_max=1,
max_attempts=1000,
mutation_prob=i)
ga_nn.fit(xtrain, ytrain)
# Train set analysis
predictions_train = ga_nn.predict(xtrain)
accuracy_score_train = accuracy_score(ytrain, predictions_train)
train_accuracy_scores.append(accuracy_score_train)
# Test set analysis
predictions_test = ga_nn.predict(xtest)
accuracy_score_test = accuracy_score(ytest, predictions_test)
test_accuracy_scores.append(accuracy_score_test)
plt.figure()
plt.plot(mutation_prob_array,
np.array(train_accuracy_scores),
label='Train Accuracy')
plt.plot(mutation_prob_array,
np.array(test_accuracy_scores),
label='Test Accuracy')
plt.xlabel('mutation_prob')
plt.ylabel('Accuracy')
plt.title('Accuracy vs. Iterations (GA - mutation_prob experimentation)')
plt.legend()
plt.savefig('ga_mutation.png')
print("Finished GA mutation experimentation")
## Adjusting the population size
## Used api as referenced in https://readthedocs.org/projects/mlrose/downloads/pdf/stable/
train_accuracy_scores = []
test_accuracy_scores = []
pop_size_array = [100, 200, 300, 400, 500]
for i in pop_size_array:
ga_nn = mlrose_hiive.NeuralNetwork(hidden_nodes=[2],
activation='relu',
algorithm='genetic_alg',
bias=False,
is_classifier=True,
learning_rate=0.6,
clip_max=1,
max_attempts=1000,
pop_size=i)
ga_nn.fit(xtrain, ytrain)
# Train set analysis
predictions_train = ga_nn.predict(xtrain)
accuracy_score_train = accuracy_score(ytrain, predictions_train)
train_accuracy_scores.append(accuracy_score_train)
# Test set analysis
predictions_test = ga_nn.predict(xtest)
accuracy_score_test = accuracy_score(ytest, predictions_test)
test_accuracy_scores.append(accuracy_score_test)
plt.figure()
plt.plot(pop_size_array,
np.array(train_accuracy_scores),
label='Train Accuracy')
plt.plot(pop_size_array,
np.array(test_accuracy_scores),
label='Test Accuracy')
plt.xlabel('pop_size')
plt.ylabel('Accuracy')
plt.title('Accuracy vs. Iterations (GA - pop_size experimentation)')
plt.legend()
plt.savefig('ga_popsize.png')
print("Finished GA pop_size experimentation")
edges = []
for au_idx in range(N_K):
for edge in base_edges:
edge = (edge[0] + 5 * au_idx, edge[1] + 5 * au_idx)
edges.append(edge)
fitness_k = mlrose_hiive.MaxKColor(edges)
# init_state = np.array([0, 1, 0, 1, 1])
K_problem = mlrose_hiive.DiscreteOpt(length=max(max(edges)) + 1,
fitness_fn=fitness_k,
maximize=False,
max_val=3)
fitness_k.evaluate(K_problem.state)
# Define decay schedule (sim annealing only)
schedule = mlrose_hiive.ExpDecay()
#8-Queens
fitness_Q = mlrose_hiive.Queens()
N_Q = 8
#OPti_object
# Q_problem = mlrose_hiive.DiscreteOpt(length = 8, fitness_fn = fitness_Q, maximize=False, max_val=8)
# timeit.timeit(fitness_Q.evaluate(Q_rand_state), number=100000)
class var_input_size():
def __init__(self, N_Q=8, N_P=7, N_K=1):
self.N_Q = N_Q
self.N_K = N_K
self.N_P = N_P
max_attempts=200,
iteration_list=[2000],
temperature_list=[0.01, 0.1, 1, 10, 100, 1000],
decay_list=[mlrh.GeomDecay, mlrh.ExpDecay, mlrh.ArithDecay])
sa_stats, sa_curve = sa.run()
columns = ['Time', 'Fitness', 'Temperature', 'schedule_type']
df=pd.read_csv("./queen/queen_prob/sa__queen_prob__run_stats_df.csv")
print(df[columns].sort_values(by=['Fitness'], ascending=False))
max_attempts = 200
max_iters = 2000
init_temp = 0.01
schedule = mlrh.ExpDecay(init_temp)
eval_count = 0
best_state, best_fitness, sa_curve = mlrh.simulated_annealing(prob,
max_attempts=max_attempts,
max_iters=max_iters,
random_state=random_state,
schedule=schedule,
curve=True)
print("Simulated Annealing - Total Function Evaluations:", eval_count)
plot_fitness_iteration('fitness_iteration_sa_queens.png', sa_curve,
"Queens - Simulated Annealing: schedule: {}, init_temp: {}".format(schedule.__class__.__name__, init_temp))
# GA
ga = mlrh.GARunner(problem=prob,
experiment_name=experiment_name,
output_directory=output_directory,
def sa_optimization(size):
algo = 'sa'
problem = get_problem(size)
# Gridsearch params
init_temp = 1
decay = 0.9
min_temp = 0.1
schedule_values = [
mlrose_hiive.GeomDecay(init_temp=init_temp,
decay=decay,
min_temp=min_temp),
mlrose_hiive.ArithDecay(init_temp=init_temp,
decay=decay,
min_temp=min_temp),
mlrose_hiive.ExpDecay(init_temp=init_temp, min_temp=min_temp)
]
max_attempts_values = [10, 50, 100, 200, 1000, 5000]
n_runs = len(schedule_values) * len(max_attempts_values)
# Best vals
schedule, max_attempts = None, None
fitness, curves, n_invocations, time = float('-inf'), [], 0, 0
# Gridsearch
global eval_count
run_counter = 0
for run_schedule in schedule_values:
for run_max_attempts in max_attempts_values:
# Print status
run_counter += 1
print(
f'RUN {run_counter} of {n_runs} [schedule: {run_schedule.__class__.__name__}] [max_attempts: {run_max_attempts}]'
)
# Run problem
eval_count = 0
start = timer()
run_state, run_fitness, run_curves = mlrose_hiive.simulated_annealing(
problem, max_iters=MAX_ITERS, random_state=SEED, curve=True)
end = timer()
# Save curves and params
if run_fitness > fitness:
schedule = run_schedule.__class__.__name__
max_attempts = run_max_attempts
fitness = run_fitness
curves = run_curves
n_invocations = eval_count
time = end - start
df = pandas.DataFrame(curves, columns=['fitness'])
df['schedule'] = schedule
df['max_attempts'] = max_attempts
df['max_iters'] = MAX_ITERS
df['n_invocations'] = n_invocations
df['time'] = time
df.to_csv(f'{STATS_FOLDER}/{algo}_{size}_stats.csv', index=False)
print(f'{algo}_{size} run.')
def main():
# ds1 = pd.read_csv('../assignment1/data/adult.data',
# names=['age', 'workclass', 'fnlwgt', 'education', 'education-num', 'marital-status', 'occupation',
# 'relationship', 'race', 'sex', 'capital-gain', 'capital-loss', 'hours-per-week',
# 'native-country', '<=50k'])
# ds1.dropna()
# ds1.drop_duplicates()
# ds1 = ds1[ds1['workclass'] != '?']
# ds1 = ds1[ds1['occupation'] != '?']
# ds1 = ds1[ds1['education'] != '?']
# ds1 = ds1[ds1['marital-status'] != '?']
# ds1 = ds1[ds1['relationship'] != '?']
# ds1 = ds1[ds1['race'] != '?']
# ds1 = ds1[ds1['sex'] != '?']
# ds1 = ds1[ds1['native-country'] != '?']
# ds1_dummies = pd.get_dummies(ds1, columns=['workclass', 'education', 'marital-status', 'occupation', 'relationship',
# 'race', 'sex', 'native-country'])
# ds1_dummies.dropna()
# ds1_dummies['<=50k'].value_counts()
# ds1_dummies['<=50k'] = ds1_dummies['<=50k'].map({'<=50K': 1, '>50K': 0})
# ds1_labels = ds1_dummies['<=50k']
# ds1_dummies = ds1_dummies.drop(['<=50k'], axis=1)
ds2 = pd.read_csv('../assignment1/data/bank-additional-full.csv',
delimiter=';')
ds2.dropna()
ds2.drop_duplicates()
ds2_dummies = pd.get_dummies(ds2,
columns=[
'job', 'marital', 'education', 'default',
'housing', 'loan', 'contact', 'month',
'day_of_week', 'poutcome'
])
ds2_dummies.dropna()
ds2_dummies['y'].value_counts()
ds2_dummies['y'] = ds2_dummies['y'].map({'yes': 1, 'no': 0})
ds2_labels = ds2_dummies['y']
ds2_dummies = ds2_dummies.drop(['y'], axis=1)
scaler = StandardScaler()
scaled_ds1_dummies = scaler.fit_transform(ds2_dummies, y=ds2_labels)
X_train, X_test, y_train, y_test = train_test_split(scaled_ds1_dummies,
ds2_labels,
test_size=0.20,
stratify=ds2_labels)
v = {
"X_train": X_train,
"X_test": X_test,
"y_train": y_train,
"y_test": y_test
}
print("Random Hill Climbing")
v['algo'] = 'rhc'
rhc, rhc_t = run_something(v, 0)
print(rhc)
print("SA")
v['algo'] = 'sa'
sa, sa_t = run_something(v, 0, mlrose.ExpDecay(), 0.1)
print(sa)
print("GA")
v['algo'] = 'ga'
ga, ga_t = run_something(v, 0, mlrose.ExpDecay(), 0.1, 100)
print(ga)
for x, y in zip([rhc, sa, ga], ['RHC', 'SA', 'GA']):
plt.plot(x, label=y)
plt.legend()
plt.title(
'Randomized Optimization Fitness Curve for NN Weight Optimization')
plt.xlabel('Function iteration count')
plt.ylabel('Fitness function value')
plt.show()
plt.clf()
for x, y in zip([rhc_t, sa_t, ga_t], ['RHC', 'SA', 'GA']):
plt.plot(x, label=y)
plt.legend()
plt.title(
'Randomized Optimization Timing Curve for NN Weight Optimization')
plt.xlabel('Function iteration count')
plt.ylabel('Time in Seconds')
plt.show()
def main():
# ds1 = pd.read_csv('../assignment1/data/adult.data',
# names=['age', 'workclass', 'fnlwgt', 'education', 'education-num', 'marital-status', 'occupation',
# 'relationship', 'race', 'sex', 'capital-gain', 'capital-loss', 'hours-per-week',
# 'native-country', '<=50k'])
# ds1.dropna()
# ds1.drop_duplicates()
# ds1 = ds1[ds1['workclass'] != '?']
# ds1 = ds1[ds1['occupation'] != '?']
# ds1 = ds1[ds1['education'] != '?']
# ds1 = ds1[ds1['marital-status'] != '?']
# ds1 = ds1[ds1['relationship'] != '?']
# ds1 = ds1[ds1['race'] != '?']
# ds1 = ds1[ds1['sex'] != '?']
# ds1 = ds1[ds1['native-country'] != '?']
# ds1_dummies = pd.get_dummies(ds1, columns=['workclass', 'education', 'marital-status', 'occupation', 'relationship',
# 'race', 'sex', 'native-country'])
# ds1_dummies.dropna()
# ds1_dummies['<=50k'].value_counts()
# ds1_dummies['<=50k'] = ds1_dummies['<=50k'].map({'<=50K': 1, '>50K': 0})
# ds1_labels = ds1_dummies['<=50k']
# ds1_dummies = ds1_dummies.drop(['<=50k'], axis=1)
ds2 = pd.read_csv('../assignment1/data/bank-additional-full.csv',
delimiter=';')
ds2.dropna()
ds2.drop_duplicates()
ds2_dummies = pd.get_dummies(ds2,
columns=[
'job', 'marital', 'education', 'default',
'housing', 'loan', 'contact', 'month',
'day_of_week', 'poutcome'
])
ds2_dummies.dropna()
ds2_dummies['y'].value_counts()
ds2_dummies['y'] = ds2_dummies['y'].map({'yes': 1, 'no': 0})
ds2_labels = ds2_dummies['y']
ds2_dummies = ds2_dummies.drop(['y'], axis=1)
scaler = StandardScaler()
scaled_ds1_dummies = scaler.fit_transform(ds2_dummies, y=ds2_labels)
X_train, X_test, y_train, y_test = train_test_split(scaled_ds1_dummies,
ds2_labels,
test_size=0.20,
stratify=ds2_labels)
v = {
"X_train": X_train,
"X_test": X_test,
"y_train": y_train,
"y_test": y_test
}
print("Random Hill Climbing")
v['algo'] = 'rhc'
rhc = run_something(v, 0)
print(rhc)
print("SA")
v['algo'] = 'sa'
sa = run_something(v, 0, mlrose.ExpDecay(), 0.1)
print(sa)
print("GA")
v['algo'] = 'ga'
ga = run_something(v, 0, mlrose.ExpDecay(), 0.1, 100)
f, axarr = plt.subplots(1, 3)
f.set_figheight(3)
f.set_figwidth(9)
for y, i in zip(rhc, ['r', 'b', 'g', 'y']):
axarr[0].plot(y, color=i)
axarr[0].set_title('RHC vs Activation Function')
for y, i in zip(sa, ['r', 'b', 'g', 'y']):
axarr[1].plot(y, color=i)
axarr[1].set_title('SA vs Activation Function')
for y, i in zip(ga, ['r', 'b', 'g', 'y']):
axarr[2].plot(y, color=i)
axarr[2].set_title('GA vs Activation Function')
# 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='r', lw=4, label='identity'),
Line2D([0], [0], color='b', lw=4, label='relu'),
Line2D([0], [0], color='g', lw=4, label='sigmoid'),
Line2D([0], [0], color='y', lw=4, label='tanh')
])
# plt.title('Input size vs fitness curve One Max')
# plt.xlabel('Function iteration count')
# plt.ylabel('Fitness function value')
plt.show()
def run(self):
temperatures = [mlrose_hiive.ExpDecay(init_temp=t, exp_const=decay) for t in self.temperature_list for decay in self.decay_list]
return super().run_experiment_(algorithm=mlrose_hiive.simulated_annealing,
schedule=('Temperature', temperatures))
def get_random_optimisation(problem,
optimisation,
problem_type,
seed=10,
state_fitness_callback=None):
best_state, best_fitness, fitness_curve = None, None, None
process_time = []
if optimisation == Optimisation.RHC:
start = time.time()
best_state, best_fitness, fitness_curve = mlrose.random_hill_climb(
problem,
max_attempts=__MAX_ATTEMPTS[problem_type],
max_iters=__MAX_ITERS,
curve=True,
random_state=seed,
state_fitness_callback=state_fitness_callback,
callback_user_info=['rhc'])
process_time.append(time.time() - start)
elif optimisation == Optimisation.SA:
start = time.time()
best_state, best_fitness, fitness_curve = mlrose.simulated_annealing(
problem,
schedule=mlrose.ExpDecay(exp_const=0.1),
max_attempts=__MAX_ATTEMPTS[problem_type],
max_iters=__MAX_ITERS,
curve=True,
random_state=seed,
state_fitness_callback=state_fitness_callback,
callback_user_info=['sa'])
process_time.append(time.time() - start)
elif optimisation == Optimisation.GA:
start = time.time()
best_state, best_fitness, fitness_curve = mlrose.genetic_alg(
problem,
pop_size=__POP_SIZE[problem_type],
mutation_prob=__MUTATION_PROBABILITY,
max_attempts=__MAX_ATTEMPTS[problem_type],
max_iters=__MAX_ITERS,
curve=True,
random_state=seed,
state_fitness_callback=state_fitness_callback,
callback_user_info=['ga'])
process_time.append(time.time() - start)
elif optimisation == Optimisation.MIMIC:
start = time.time()
best_state, best_fitness, fitness_curve = mlrose.mimic(
problem,
pop_size=__POP_SIZE[problem_type],
keep_pct=__KEEP_PCT,
max_iters=__MAX_ITERS,
max_attempts=__MAX_ATTEMPTS[problem_type],
curve=True,
random_state=seed,
state_fitness_callback=state_fitness_callback,
callback_user_info=['mimic'])
process_time.append(time.time() - start)
return best_state, best_fitness, np.array(fitness_curve), process_time
def plot_sa_graph(prob_type):
try:
os.mkdir("./SA")
except FileExistsError:
pass
except OSError as error:
print("Error creating directory results.")
print('\n plot_sa_graph - Progress: ', end="")
fitness, problem = get_fitness_function(prob_type)
process_time = []
fitness_score = []
for j in range(3):
process_time.append([])
fitness_score.append([])
if j != 2:
decay_const = [
0.005, 0.01, 0.05, 0.1, 0.15, 0.25, 0.5, 0.75, 0.9, 0.99
]
else:
decay_const = [
0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 0.9, 0.99
]
for i in decay_const:
print('.', end="")
if j == 0:
decay = mlrose.GeomDecay(decay=i)
elif j == 1:
decay = mlrose.ExpDecay(exp_const=i)
else:
decay = mlrose.ArithDecay(decay=i)
start = time.time()
best_state, best_fitness, fitness_curve = mlrose.simulated_annealing(
problem,
schedule=decay,
max_attempts=1000,
max_iters=100,
random_state=10)
fitness_score[j].append(best_fitness)
process_time[j].append(time.time() - start)
plt.figure(100)
plt.plot([0.005, 0.01, 0.05, 0.1, 0.15, 0.25, 0.5, 0.75, 0.9, 0.99],
fitness_score[0],
'r',
label='GeomDecay')
plt.plot([0.005, 0.01, 0.05, 0.1, 0.15, 0.25, 0.5, 0.75, 0.9, 0.99],
fitness_score[1],
'b',
label='ExpDecay')
plt.plot([0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 0.9, 0.99],
fitness_score[2],
'g',
label='ArithDecay')
plt.xlim(0.0001, 0.2)
plt.legend()
plt.xlabel("decay constant")
plt.ylabel("fitness score")
plt.title('Simulated Annealing')
plt.savefig("SA/" + "Fitness.png")
plt.figure(101)
plt.plot([0.005, 0.01, 0.05, 0.1, 0.15, 0.25, 0.5, 0.75, 0.9, 0.99],
process_time[0],
'r',
label='GeomDecay')
plt.plot([0.005, 0.01, 0.05, 0.1, 0.15, 0.25, 0.5, 0.75, 0.9, 0.99],
process_time[1],
'b',
label='ExpDecay')
plt.plot([0.0001, 0.0005, 0.001, 0.005, 0.01, 0.05, 0.1, 0.5, 0.9, 0.99],
process_time[2],
'g',
label='ArithDecay')
plt.xlim(0.0001, 0.2)
plt.legend()
plt.xlabel("decay constant")
plt.ylabel("process time")
plt.title('Simulated Annealing')
plt.savefig("SA/" + "Time.png")
fit_is_recalls = []
fit_os_recalls = []
fit_iters = []
fit_losses = []
fit_curves = []
candidates = [mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.001, schedule=mlr.GeomDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed),\
mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.0001, schedule=mlr.GeomDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed),\
mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.00001, schedule=mlr.GeomDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed),\
mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.000001, schedule=mlr.GeomDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed),\
mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.0000001, schedule=mlr.GeomDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed), \
mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.001, schedule=mlr.ArithDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed),\
mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.0001, schedule=mlr.ArithDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed),\
mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.00001, schedule=mlr.ArithDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed),\
mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.000001, schedule=mlr.ArithDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed),\
mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.0000001, schedule=mlr.ArithDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed),\
mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.001, schedule=mlr.ExpDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed),\
mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.0001, schedule=mlr.ExpDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed),\
mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.00001, schedule=mlr.ExpDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed),\
mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.000001, schedule=mlr.ExpDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed),\
mlr.NeuralNetwork(hidden_nodes=[13,10,7,5,1], activation='relu', algorithm = 'random_hill_climb', max_iters=1000, bias=True, is_classifier=True, learning_rate=0.0000001, schedule=mlr.ExpDecay(), early_stopping=False, curve=True, max_attempts = 100, random_state = seed)]
for i in range(len(candidates)):
init_weights = np.random.uniform(-0.5,0.5,423)
bp = candidates[i]
start_time = time.time()
bp.fit(X_train_sc_1000, y_train_1000, init_weights=init_weights)
end_time = time.time()
fit_times.append(end_time-start_time)
y_in = pd.Series(bp.predict(X_train_sc_1000).flatten())
y_out = pd.Series(bp.predict(X_test_sc_1000).flatten())
model_loss = bp.loss
fit_losses.append(model_loss)
y_test_hot = oh.transform(y_test.reshape(-1, 1)).todense().astype(int)
# lrs = [0.002] # 6
# lrs = [0.002, 0.004, 0.02, 0.06, 0.2, 0.8] # 6
lrs = [0.003, 0.05, 0.7] # 6
# mil = [100] # 4
# mil = [100, 500, 1000, 2500] # 4
mil = [145, 435, 1300] # 4
# acti = ['tanh']
acti = ['relu', 'sigmoid', 'tanh']
NNparams = np.array(np.meshgrid(lrs,mil,acti),dtype=object).T.reshape(-1,3)
# rsts = [10]
rsts = [7, 12]
# rsts = [5, 10, 15]
# schs = [mlr.ArithDecay(15)]
schs = [mlr.ArithDecay(25), mlr.ExpDecay(25), mlr.GeomDecay(25)]
# schs = [mlr.ArithDecay(15), mlr.ExpDecay(15), mlr.GeomDecay(15),
# mlr.ArithDecay(175), mlr.ExpDecay(175), mlr.GeomDecay(175)]
# pops = [225]
pops = [150, 225]
# pops = [75, 150, 225]
# muts = [0.25]
muts = [0.33, 0.66]
# muts = [0.25, 0.5, 0.75]
gaParams = np.array(np.meshgrid(pops, muts)).T.reshape(-1,2)
experiments = []
for lr, mi, act in NNparams:
for rst in rsts:
experiments.append(mlr.NeuralNetwork(hidden_nodes=[7,5],
activation=act,
input_sizes = [25, 50, 75, 100, 150, 200, 300]
opt_probs = [
(get_one_max, 'one max'),
(get_four_peaks, 'four peaks'),
(get_six_peaks, 'six peaks'),
(get_continuous_peaks, 'continuous peaks'),
(get_flip_flop, 'flip flop'),
]
sim_ann = get_sim_ann
options = [(mlrose.GeomDecay(), 'geometric'),
(mlrose.ArithDecay(), 'arithmetic'),
(mlrose.ExpDecay(), 'exponential')]
metric_dict = {prob[1]: {} for prob in opt_probs}
for size in input_sizes:
print('####################################### New input size ', size,
' ##############################################')
for prob in opt_probs:
problem_name = prob[1]
problem = prob[0](size)
print('----------------------------------New Problem ', problem_name,
' ------------------------------------------')
for opt in options:
option_name = opt[1]
opt_val = opt[0]
print('___________New Option_____________')
x_test = scaler.transform(x_test)
for algo in algos:
print('--------------New Algo ', algo, '----------------------')
nn_model = mlrose.NeuralNetwork(hidden_nodes=[3],
activation='relu',
algorithm=algo,
max_iters=100,
bias=True,
is_classifier=True,
learning_rate=0.0001,
early_stopping=False,
clip_max=1,
restarts=30,
schedule=mlrose.ExpDecay(1),
pop_size=300,
mutation_prob=0.4,
max_attempts=10,
random_state=4,
curve=False)
print('Fitting model...')
nn_model.fit(x_train, y_train)
y_train_pred = nn_model.predict(x_train)
print('Training Score: ', accuracy_score(y_train, y_train_pred))
y_test_pred = nn_model.predict(x_test)
def simulated_annealing_experiment(optimization_problem, hparams,
output_fn_base):
metrics = {}
logs = []
print("----Running Simulated Annealing Experiment-----")
print("Hyperparameters Used: ")
print(hparams)
schedule = None
if (hparams["decay"] == "Geometric"):
schedule = mlrose.GeomDecay(init_temp=hparams["initial_temp"])
elif (hparams["decay"] == "Arithmetic"):
schedule = mlrose.ArithDecay(init_temp=hparams["initial_temp"])
else:
schedule = mlrose.ExpDecay(init_temp=hparams["initial_temp"])
best_state, best_fitness, _ = mlrose.simulated_annealing(
optimization_problem, schedule, hparams["max_attempts"],
hparams["max_iters"])
# Iterations and runtime
fitness_scores = []
runtimes = []
iteration_count = range(1, hparams["max_iters"])
for iter in iteration_count:
start_time = time.time()
best_state, best_fitness, _ = mlrose.simulated_annealing(
optimization_problem, schedule, hparams["max_attempts"], iter)
end_time = time.time()
runtimes.append(end_time - start_time)
fitness_scores.append(-best_fitness if optimization_problem.
prob_type == 'tsp' else best_fitness)
plot_single(fitness_scores,
"%s/Annealing/annealing_fitness_iterations" % output_fn_base,
xvals=iteration_count)
plot_runtimes(runtimes,
"%s/Annealing/annealing_runtime_iterations" % output_fn_base)
metrics["runtimes"] = runtimes
metrics["fitness"] = fitness_scores
# intial temp
fitness_scores_geo = []
fitness_scores_arith = []
fitness_scores_exp = []
temps = range(1, 100)
for temp in temps:
decays = [
mlrose.GeomDecay(init_temp=temp),
mlrose.ArithDecay(init_temp=temp),
mlrose.ExpDecay(init_temp=temp)
]
for i in range(0, len(decays)):
best_state, best_fitness, _ = mlrose.simulated_annealing(
optimization_problem, decays[i], hparams["max_attempts"], 400)
if (i == 0):
fitness_scores_geo.append(
-best_fitness if optimization_problem.prob_type ==
'tsp' else best_fitness)
elif (i == 1):
fitness_scores_arith.append(
-best_fitness if optimization_problem.prob_type ==
'tsp' else best_fitness)
else:
fitness_scores_exp.append(
-best_fitness if optimization_problem.prob_type ==
'tsp' else best_fitness)
# Iterations and runtime
decays = [
mlrose.GeomDecay(init_temp=temp),
mlrose.ArithDecay(init_temp=temp),
mlrose.ExpDecay(init_temp=temp)
]
fitness_scores_geo2 = []
fitness_scores_arith2 = []
fitness_scores_exp2 = []
for i in range(0, len(decays)):
if (i == 0):
iteration_count2 = range(1, 2 * hparams["max_iters"])
for iter in iteration_count2:
best_state, best_fitness, _ = mlrose.simulated_annealing(
optimization_problem, decays[i], hparams["max_attempts"],
iter)
fitness_scores_geo2.append(
-best_fitness if optimization_problem.prob_type ==
'tsp' else best_fitness)
elif (i == 1):
iteration_count2 = range(1, 2 * hparams["max_iters"])
for iter in iteration_count2:
best_state, best_fitness, _ = mlrose.simulated_annealing(
optimization_problem, decays[i], hparams["max_attempts"],
iter)
fitness_scores_arith2.append(
-best_fitness if optimization_problem.prob_type ==
'tsp' else best_fitness)
else:
iteration_count2 = range(1, 2 * hparams["max_iters"])
for iter in iteration_count2:
best_state, best_fitness, _ = mlrose.simulated_annealing(
optimization_problem, decays[i], hparams["max_attempts"],
iter)
fitness_scores_exp2.append(
-best_fitness if optimization_problem.prob_type ==
'tsp' else best_fitness)
plot_single(fitness_scores,
"%s/Annealing/annealing_fitness_iterations" % output_fn_base,
xvals=iteration_count)
plot_runtimes(runtimes,
"%s/Annealing/annealing_runtime_iterations" % output_fn_base)
metrics["runtimes"] = runtimes
metrics["fitness"] = fitness_scores
plot_multiple(
[fitness_scores_geo2, fitness_scores_arith2, fitness_scores_exp2], [
"Geometric Decay Fitness", "Arithmetic Decay Fitness",
"Exponential Decay Fitness"
],
"%s/Annealing/sa_fitness_decay_iterations" % output_fn_base,
title="SA Fitness Scores Over Iterations - %s" %
get_name_of_experiment(output_fn_base),
xlab="Iterations")
plot_multiple(
[fitness_scores_geo, fitness_scores_arith, fitness_scores_exp], [
"Geometric Decay Fitness", "Arithmetic Decay Fitness",
"Exponential Decay Fitness"
],
"%s/Annealing/sa_fitness_decay" % output_fn_base,
title="SA Fitness Scores Over Various Temps - %s" %
get_name_of_experiment(output_fn_base),
xlab="Initial Temperature")
plot_multiple(
[fitness_scores_geo], ["Geometric Decay Fitness"],
"%s/Annealing/sa_fitness_decay_geo" % output_fn_base,
title="SA Fitness Over Various Temps - Geometric Decay - %s" %
get_name_of_experiment(output_fn_base),
xlab="Initial Temperature")
plot_multiple(
[fitness_scores_arith], ["Arithmetic Decay Fitness"],
"%s/Annealing/sa_fitness_decay_arith" % output_fn_base,
title="SA Fitness Over Various Temps - Arithmetic Decay - %s" %
get_name_of_experiment(output_fn_base),
xlab="Initial Temperature")
plot_multiple(
[fitness_scores_exp], ["Exponential Decay Fitness"],
"%s/Annealing/sa_fitness_decay_exp" % output_fn_base,
title="SA Fitness Over Various Temps - Exponential Decay - %s" %
get_name_of_experiment(output_fn_base),
xlab="Initial Temperature")
plot_multiple(
[
pd.Series(fitness_scores_geo).rolling(window=10).mean(),
pd.Series(fitness_scores_arith).rolling(window=10).mean(),
pd.Series(fitness_scores_exp).rolling(window=10).mean()
], [
"Geometric Decay Fitness", "Arithmetic Decay Fitness",
"Exponential Decay Fitness"
],
"%s/Annealing/sa_fitness_decay_sma" % output_fn_base,
title="SA Fitness Scores Over Various Temps - Rolling Mean - %s" %
get_name_of_experiment(output_fn_base),
xlab="Initial Temperature")
logs.append("\tHyperparameters: \n")
logs.append("\t%s" % str(hparams))
logs.append("\n\n\tBest State: \n\t\t")
logs.append(str(list(best_state)))
logs.append("\n\tBest Fitness: \n\t\t")
logs.append(str(best_fitness))
return logs, metrics
