class Controller:
def __init__(self, filename):
self.__problem = Problem(filename)
self.__x = self.__problem.getX()
self.__y = self.__problem.getY()
self.__nn = ArtificialNeuralNetwork(self.__x, self.__y, 2)
def solve(self):
self.__nn.loss=[]
iterations =[]
for i in range(4000):
self.__nn.feedforward()
learning_rate = 0.5
self.__nn.backpropagation(learning_rate)
iterations.append(i)
print(self.__nn.output)
mpl.pyplot.plot(iterations, self.__nn.loss, label='loss value vs iteration')
mpl.pyplot.xlabel('Iterations')
mpl.pyplot.ylabel('loss function')
mpl.pyplot.legend()
mpl.pyplot.show()
def main():
data_path = './Datasets/part2_train_data.csv'
if len(sys.argv) > 1:
data_path = sys.argv[1]
data = pd.read_csv(data_path)
X = data.loc[:, [col for col in data.columns if col not in ['y1', 'y2']]].to_numpy().T
labels = data.loc[:, ['y1', 'y2']].to_numpy().T
dimensions = [len(X), 2, 2]
res_matrix = []
writer = pd.ExcelWriter('./Networks/Parte2/errors.xlsx', engine='openpyxl')
for i in range(20):
print(f"--------Network {i+1}-----------------------------------------------------------------------------")
ann = ArtificialNeuralNetwork(dimensions, name=f"Parte2-Network{i+1}")
results = ann.trainNetwork(X, labels, max_epochs=100, output_type="Other")
res_df = pd.DataFrame(results)
res_df.to_excel(excel_writer=writer, sheet_name=f'Network{i+1}')
res_matrix.append(np.array(results['train_mse']))
ann.printNetwork()
ann.saveAsJSON(path=f'./Networks/Parte2/JSON/Network-{ann.name}.json')
ann.saveAsExcel(path=f'./Networks/Parte2/Excel/{ann.name}.xlsx')
writer.save()
writer.close()
print("Training and validation errors saved in './Networks/Parte2/errors.xlsx'")
lowest_mse = np.amin(res_matrix, axis=0)
highest_mse = np.amax(res_matrix, axis=0)
avg_mse = np.sum(res_matrix, axis=0) / len(res_matrix)
plt.figure(figsize=(10, 7))
plt.title("MSE per Epoch - Neural Network", fontsize=24)
plt.plot(lowest_mse, label="Lowest MSE p/ Epoch", lw=3, ls=":")
plt.plot(highest_mse, label="Highest MSE p/ Epoch", lw=3, ls="--")
plt.plot(avg_mse, label="Average MSE p/ Epoch", lw=3)
plt.xlabel("Epoch", fontsize=20)
plt.ylabel("MSE", fontsize=20)
plt.legend(fontsize=13)
plt.show()
def train(topology, inputValues, targetValues):
net = ArtificialNeuralNetwork(topology)
count = 0
# list of stats recording when it reached 95%, 98%, 99%, and 99.5%
thresholds = [None, None, None, None]
# When we expect the neural network to learn at earliest
padding = 500
while count < CYCLE:
index = count % len(listInputValues)
# propagate forward
print ("Input: {}".format(listInputValues[index]))
net.forward_prop(listInputValues[index])
# get result
result = net.get_results()
print ("Result: {}".format(result))
# back propagation
print ("Target: {}".format(listTargetValues[index]))
net.back_prop(listTargetValues[index])
print ("Recent Average Error: {}".format(net.recentAverageError))
print ("---------------\n")
# record the stats
recordStats(count, thresholds, net.recentAverageError, padding)
count += 1
print (textwrap.dedent("""\
Stats:
Reached 95% accuracy at: {0}
Reached 98% accuracy at: {1}
Reached 99% accuracy at: {2}
Reached 99.5% accuracy at: {3}
""".format(thresholds[0], thresholds[1], thresholds[2], thresholds[3])))
userInput(net, topology[0])
def main():
training_path = './Datasets/part4_pokemon_go_train.csv'
if len(sys.argv) > 1:
training_path = sys.argv[1]
val_path = './Datasets/part4_pokemon_go_validation.csv'
if len(sys.argv) > 2:
val_path = sys.argv[2]
test_path = './Datasets/part4_pokemon_go_test.csv'
if len(sys.argv) > 3:
test_path = sys.argv[3]
training_data = pd.read_csv(training_path)
training_data.drop(['nombre'], axis=1, inplace=True)
preX_train = training_data.loc[:, training_data.columns != 'PC']
train_label = training_data['PC'].to_numpy().T
train_label = np.reshape(train_label, (1, len(train_label)))
val_data = pd.read_csv(val_path)
val_data.drop(['nombre'], axis=1, inplace=True)
preX_val = val_data.loc[:, val_data.columns != 'PC']
val_label = val_data['PC'].to_numpy().T
val_label = np.reshape(val_label, (1, len(val_label)))
testing_data = pd.read_csv(test_path)
testing_data.drop(['nombre'], axis=1, inplace=True)
preX_test = testing_data.loc[:, testing_data.columns != 'PC']
test_label = testing_data['PC'].to_numpy().T
test_label = np.reshape(test_label, (1, len(test_label)))
X_train = preprocess(preX_train).to_numpy().T
X_val = preprocess(preX_val).to_numpy().T
X_test = preprocess(preX_test).to_numpy().T
entries_number = X_train.shape[0]
networks = [[entries_number, 16, 1], [entries_number, 32, 1],
[entries_number, 16, 16, 1], [entries_number, 32, 32, 1],
[entries_number, 64, 1], [entries_number, 128, 1],
[entries_number, 256, 1]]
learning_rate = [
0.00003, 0.00003, 0.000001, 0.000001, 0.0001, 0.0001, 0.0001, 0.0001
]
batch_size = [1, 1, 500, 500, 1, 1, 1, 1]
netnames = ['16', '32', '16-16', '32-32', '64', '128', '256', '512']
res_dict = {'hidden_layers': [], 'test_mse': []}
writer = pd.ExcelWriter('./Networks/Parte4/errors.xlsx', engine='openpyxl')
for i, network in enumerate(networks):
print(
f"--------Network {i + 1}-----------------------------------------------------------------------------"
)
ann = ArtificialNeuralNetwork(network,
name=f"Network{netnames[i]}",
output_funct="Linear")
results = ann.trainNetwork(training_data=X_train,
training_labels=train_label,
max_epochs=50,
val_data=X_val,
val_labels=val_label,
max_nondecreasing=10,
epsilon=0.001,
alpha=learning_rate[i],
output_type="Regression",
error_metric="MSE",
batch_size=batch_size[i])
res_df = pd.DataFrame(results)
res_df.to_excel(excel_writer=writer, sheet_name=f'Network{i + 1}')
plotResults(results['train_mse'],
results['val_mse'],
title=f"MSE per Epoch - {netnames[i]}",
x_label="Epoch",
y_label="MSE")
ann.printNetwork()
ann.saveAsJSON(path=f'./Networks/Parte4/JSON/Network-{ann.name}.json')
ann.saveAsExcel(path=f'./Networks/Parte4/Excel/{ann.name}.xlsx')
test_mse = testResults(X_test, test_label, ann)
res_dict['hidden_layers'].append(netnames[i])
res_dict['test_mse'].append(test_mse)
res_df = pd.DataFrame(data=res_dict)
print(res_df.head(10))
res_df.to_excel('./Networks/Parte4/tests.xlsx')
print("Test errors saved in './Networks/Parte3/tests.xlsx'")
writer.save()
writer.close()
print(
"Training and validation errors saved in './Networks/Parte3/errors.xlsx'"
)
def main():
data = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
json_path = './Datasets/part1_red_prueba.json'
if len(sys.argv) > 1:
json_path = sys.argv[1]
print("-----Randomly Initialized" + "-" * 60)
# Resultados usando pesos aleatorios
ann = ArtificialNeuralNetwork(dimensions=[2, 2, 2],
name="Parte1-FeedForward")
ann.saveAsJSON(path=f'./Networks/Parte1/JSON/Network-{ann.name}.json')
ann.saveAsExcel(path=f'./Networks/Parte1/Excel/{ann.name}.xlsx')
ann.printNetwork()
print("-----Feed Forward Results-----")
for entries in data:
print(f"Entry Data=> X0:{entries[0]}, X1:{entries[1]}")
outputs = ann.feedForward(np.reshape(entries, (len(entries), 1)))
print(f"Output: Output0:{outputs[0][0]}, Output1:{outputs[1][0]}")
print("\n-----JSON Initialized" + "-" * 60)
# Resultados usando los pesos provistos en “part1_red_prueba.json”
json_ann = ArtificialNeuralNetwork(jsonPath=json_path)
json_ann.printNetwork()
print("-----Feed Forward Results-----")
for entries in data:
print(f"Entry Data=> X0:{entries[0]}, X1:{entries[1]}")
outputs = json_ann.feedForward(np.reshape(entries, (len(entries), 1)))
print(f"Output: Output0:{outputs[0][0]}, Output1:{outputs[1][0]}")
def __init__(self, filename):
self.__problem = Problem(filename)
self.__x = self.__problem.getX()
self.__y = self.__problem.getY()
self.__nn = ArtificialNeuralNetwork(self.__x, self.__y, 2)
import numpy as np
import pandas as pd
from ArtificialNeuralNetwork import ArtificialNeuralNetwork
data = pd.read_csv('./Datasets/part3_data_train.csv')
dimensions = np.array([len(data.columns) - 1, 10, 5])
X = data.loc[:, data.columns != "clase"].to_numpy().T
labels = pd.get_dummies(data["clase"]).to_numpy().T
nn = ArtificialNeuralNetwork(dimensions, name="Shamu")
nn.printNetwork()
nn.saveAsJSON()
nn.trainNetwork(X, labels, alpha=0.01, max_epochs=100)
nn.printNetwork()
nn.saveAsExcel()
val = pd.read_csv('./Datasets/part3_data_val.csv')
val_x = val.loc[:, val.columns != 'clase'].to_numpy()
val_y = pd.get_dummies(val["clase"]).to_numpy()
nn.test(val_x.T, val_y.T)
nn.test(X.T, labels.T)
nn = ArtificialNeuralNetwork(jsonPath='./Datasets/part1_red_prueba.json')
nn.printNetwork()
def main():
training_path = './Datasets/part3_data_train.csv'
if len(sys.argv) > 1:
training_path = sys.argv[1]
val_path = './Datasets/part3_data_val.csv'
if len(sys.argv) > 2:
val_path = sys.argv[2]
test_path = './Datasets/part3_data_test.csv'
if len(sys.argv) > 3:
test_path = sys.argv[3]
training_data = pd.read_csv(training_path)
preX_train = training_data.loc[:, training_data.columns != 'clase']
train_label = pd.get_dummies(training_data['clase']).to_numpy().T
val_data = pd.read_csv(val_path)
preX_val = val_data.loc[:, val_data.columns != 'clase']
val_label = pd.get_dummies(val_data['clase']).to_numpy().T
testing_data = pd.read_csv(test_path)
preX_test = testing_data.loc[:, testing_data.columns != 'clase']
test_label = pd.get_dummies(testing_data['clase']).to_numpy().T
le = LabelEncoder()
le.fit(training_data['clase'].values)
labels = le.classes_
X_train = preprocess(preX_train).to_numpy().T
X_val = preprocess(preX_val).to_numpy().T
X_test = preprocess(preX_test).to_numpy().T
entries_number = X_train.shape[0]
networks = [[entries_number, 4, 5], [entries_number, 16, 5],
[entries_number, 32, 5], [entries_number, 64, 5],
[entries_number, 56, 5]]
res_dict = {
'l0_neurons': [],
'test_acc': [],
'avgtest_f1': [],
'test_f1_C1': [],
'test_f1_C2': [],
'test_f1_C3': [],
'test_f1_C4': [],
'test_f1_C5': []
}
writer = pd.ExcelWriter('./Networks/Parte3/errors.xlsx', engine='openpyxl')
for i, network in enumerate(networks):
print(
f"--------Network {i+1}-----------------------------------------------------------------------------"
)
netName = networks[i][1]
ann = ArtificialNeuralNetwork(network, name=f"Network{netName}")
results = ann.trainNetwork(training_data=X_train,
training_labels=train_label,
max_epochs=50,
val_data=X_val,
val_labels=val_label,
max_nondecreasing=3,
epsilon=0.001,
output_type="Classification",
error_metric="CrossEntropy")
res_df = pd.DataFrame(results)
res_df.to_excel(excel_writer=writer, sheet_name=f'Network{i+1}')
plotResults(results['train_mse'],
results['val_mse'],
title=f"MSE per Epoch - {netName}",
x_label="Epoch",
y_label="MSE")
ann.printNetwork()
ann.saveAsJSON(path=f'./Networks/Parte3/JSON/Network-{ann.name}.json')
ann.saveAsExcel(path=f'./Networks/Parte3/Excel/{ann.name}.xlsx')
test_acc, test_f1, f1_per_class = testResults(X_test, test_label, ann,
labels)
res_dict['l0_neurons'].append(netName)
res_dict['test_acc'].append(test_acc)
res_dict['avgtest_f1'].append(test_f1)
for j in range(5):
res_dict[f'test_f1_C{j+1}'].append(f1_per_class[j])
res_df = pd.DataFrame(data=res_dict)
print(res_df.head(10))
res_df.to_excel('./Networks/Parte3/tests.xlsx')
print("Test errors saved in './Networks/Parte3/tests.xlsx'")
writer.save()
writer.close()
print(
"Training and validation errors saved in './Networks/Parte3/errors.xlsx'"
)