def load_base(path='', column_names=None, type=None):
path = get_project_root() + '/mlfwk/datasets/' + path
if type == 'csv':
base_result = read_csv(path, names=column_names)
return base_result
if type == 'arff':
base_result = arff.loadarff(path)
base_result = DataFrame(base_result[0])
else:
base_result = None
return base_result
# utilizando o x_test e o y_test da ultima realização
for c in [0, 1, 2]:
plot_dict['classes'].update({
c: {
'X': x[where(y == c)[0]],
'point': point[c],
'marker': marker[c]
}
})
# #FFAAAA red
# #AAAAFF blue
coloring(plot_dict, ListedColormap(['#87CEFA', '#228B22', "#FF00FF"]), xlabel='SepalLengthCm',
ylabel='SepalWidthCm',
title='mapa de cores com Rede Perceptron - ACC: ' + str(metric_results['ACCURACY'].round(2)), xlim=[-0.1, 1.1], ylim=[-0.1, 1.1],
path=get_project_root() + '/run/TR-04/IRIS/results/' + 'color_map_sepal_test.jpg', save=True)
# print('dataset shape %s' % Counter(base[:, 2]))
# ------------------ All points -------------------------------------------------------------------
x = array(base[:, :2])
y = array(out_of_c_to_label(base[:, 2:]))
xx, yy = generate_space(x)
space = c_[xx.ravel(), yy.ravel()]
point = {
0: 'bo',
1: 'go',
2: 'mo'
results['realization'].append(realization)
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
results[type].append(metric_results[type])
results['cf'].sort(key=lambda x: x[0], reverse=True)
final_result['best_cf'].append(results['cf'][0][1])
best_acc_clf = results['cf'][0][2]
best_acc = results['cf'][0][0]
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
print(DataFrame(final_result))
DataFrame(final_result).to_csv(get_project_root() +
'/run/TR-00/ARTIFICIAL/results/' +
'result_knn.csv')
for i in range(len(final_result['best_cf'])):
plt.figure(figsize=(10, 7))
df_cm = DataFrame(final_result['best_cf'][i],
index=[i for i in range(2)],
columns=[i for i in range(2)])
sn.heatmap(df_cm, annot=True)
plt.title('Matriz de connfusão do KNN com acurácia de ' +
str(best_acc * 100) + "%")
plt.xlabel('Valor Esperado')
plt.ylabel('Valor Encontrado')
results['realization'].append(realization)
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
results[type].append(metric_results[type])
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
results['cf'].sort(key=lambda x: x[0], reverse=True)
final_result['best_cf'].append(results['cf'][0][1])
best_acc_clf = results['cf'][0][2]
best_acc = results['cf'][0][0]
df_cm = DataFrame(results['cf'][0][1],
index=[i for i in range(C)],
columns=[i for i in range(C)])
sn.heatmap(df_cm, annot=True)
plt.title('Matriz de connfusão do DMC com acurácia de ' +
str(round(best_acc, 2) * 100) + "%")
plt.xlabel('Valor Esperado')
plt.ylabel('Valor Encontrado')
path = get_project_root() + '/run/ML-00/COLUNA_3C/results/'
plt.savefig(path + one_versus_others + "-conf_result_dmc.jpg")
plt.show()
print(DataFrame(final_result))
DataFrame(final_result).to_csv(get_project_root() +
'/run/ML-00/COLUNA_3C/results/' +
one_versus_others + '_result_dmc.csv')
final_result['alphas'].append(mean(results['alphas']))
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
# ------------------------ PLOT -------------------------------------------------
for i in range(len(final_result['best_cf'])):
plt.figure(figsize=(10, 7))
df_cm = DataFrame(final_result['best_cf'][i],
index=[i for i in range(C)],
columns=[i for i in range(C)])
sn.heatmap(df_cm, annot=True)
plt.title('Matriz de connfusão dermatologia com raio de abertura: ' +
str(best_alpha) + ' e número de neurônios: ' +
str(best_number_centers))
plt.xlabel('Valor Esperado')
plt.ylabel('Valor Encontrado')
path = get_project_root() + '/run/TR-06/COLUNA_3C/results/'
plt.savefig(path + "mat_confsuison_rbf.jpg")
plt.show()
print(pd.DataFrame(final_result))
del final_result['best_cf']
pd.DataFrame(final_result).to_csv(get_project_root() +
'/run/TR-06/COLUNA_3C/results/' +
'result_rbf.csv')
# normalizar a base
base[['x1', 'x2']] = normalization(base[['x1', 'x2']], type='min-max')
x = array(base[['x1', 'x2']])
y = array(base[['y']])
classe0 = x[np.where(y == 0)[0]]
classe1 = x[np.where(y == 1)[0]]
classe2 = x[np.where(y == 2)[0]]
plt.plot(classe0[:, 0], classe0[:, 1], 'b^')
plt.plot(classe1[:, 0], classe1[:, 1], 'go')
plt.plot(classe2[:, 0], classe2[:, 1], 'm*')
plt.xlabel("X1")
plt.ylabel("X2")
plt.savefig(get_project_root() + '/run/TR-03/ARTIFICIAL/results/' +
'dataset_artificial.png')
plt.show()
y_out_of_c = pd.get_dummies(base['y'])
base = base.drop(['y'], axis=1)
base = concatenate([base[['x1', 'x2']], y_out_of_c], axis=1)
for realization in range(20):
train, test = split_random(base, train_percentage=.8)
train, train_val = split_random(train, train_percentage=.8)
x_train = train[:, :2]
y_train = train[:, 2:]
base = pd.DataFrame(load_mock(type='LOGICAL_XOR'),
columns=['x1', 'x2', 'y'])
base[['x1', 'x2']] = normalization(base[['x1', 'x2']], type='min-max')
x = array(base[['x1', 'x2']])
y = array(base[['y']])
classe0 = x[np.where(y == 0)[0]]
classe1 = x[np.where(y == 1)[0]]
plt.plot(classe0[:, 0], classe0[:, 1], 'b^')
plt.plot(classe1[:, 0], classe1[:, 1], 'go')
plt.xlabel("X1")
plt.ylabel("X2")
plt.savefig(get_project_root() + '/run/TR-05/XOR/results/' +
'dataset_xor_artificial.png')
plt.show()
# ----------------------- one - hot ---------------------------------------------------
N, M = base.shape
C = len(base['y'].unique())
y_out_of_c = pd.get_dummies(base['y'])
base = concatenate([base[['x1', 'x2']], y_out_of_c], axis=1)
# --------------------------------------------------------------------------------------
for realization in range(20):
train, test = split_random(base, train_percentage=.8)
train, train_val = split_random(train, train_percentage=.8)
train, test = split_random(base, train_percentage=.8)
train = train.to_numpy()
test = test.to_numpy()
x_train = train[:, :len(features)]
y_train = train[:, len(features):]
x_test = test[:, :len(features)]
y_test = test[:, len(features):]
classifier_dmc = dmc(x_train, y_train)
y_out_dmc = classifier_dmc.predict(x_test, [0, 1])
metrics_calculator = metric(list(y_test.reshape(y_test.shape[0])), y_out_dmc,
types=['ACCURACY', 'AUC', 'precision',
'recall', 'f1_score'])
metric_results = metrics_calculator.calculate(average='micro')
results['realization'].append(realization)
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
results[type].append(metric_results[type])
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
print(DataFrame(final_result))
DataFrame(final_result).to_csv(get_project_root() + '/run/ML-00/COLUNA_2C/results/' + 'result_dmc.csv')
final_result['best_cf'].append(results['cf'][0][1])
final_result['ErrosxEpocohs'].append(results['erros'][0][1])
final_result['versus'].append(one_versus_others)
final_result['alphas'].append(mean(results['alphas']))
for type in ['ACCURACY', 'AUC', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
for i in range(len(final_result['best_cf'])):
plt.figure(figsize=(10, 7))
df_cm = DataFrame(final_result['best_cf'][i], index=[i for i in "01"],
columns=[i for i in "01"])
sn.heatmap(df_cm, annot=True)
path = get_project_root() + '/run/TR-035/IRIS/results/'
plt.savefig(path + 'mat_confsuison_hyper' + final_result['versus'][i] + ".jpg")
plt.show()
# for i in range(len(final_result['ErrosxEpocohs'])):
# plt.plot(list(range(len(final_result['ErrosxEpocohs'][i]))), final_result['ErrosxEpocohs'][i],
# label='Error')
# plt.xlabel('Epocas')
# plt.ylabel('Error')
# plt.legend(loc='upper right')
#
# path = get_project_root() + '/run/TR-01/IRIS/results/'
# plt.savefig(path + 'EpochsXError ' + final_result['versus'][i] + ".jpg")
# plt.show()
#
#
results['error_per_epoch'].append(
(simple_net.train_epochs_error, metric_results['RMSE']))
results['alphas'].append(simple_net.lr)
results['realization'].append(realization)
for type in ['MSE', 'RMSE', 'R2']:
results[type].append(metric_results[type])
results['error_per_epoch'].sort(key=lambda x: x[1], reverse=False)
final_result['best_error_per_epoch'] = results['error_per_epoch'][0][0]
final_result['alphas'].append(mean(results['alphas']))
for type in ['MSE', 'RMSE', 'R2']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
# print(pd.DataFrame(final_result))
plt.plot(list(range(epochs)), final_result['best_error_per_epoch'], '*')
plt.xlabel('epochs')
plt.ylabel('RMSE')
path = get_project_root() + '/run/TR-05/ABALONE/results/'
plt.savefig(path + "error_epochs.jpg")
plt.show()
del final_result['best_error_per_epoch']
print(pd.DataFrame(final_result))
pd.DataFrame(final_result).to_csv(get_project_root() +
'/run/TR-05/ABALONE/results/' +
'result_simple_net.csv')
# ------------------------------------------------------------------------------------
simple_net = ExtremeLearningMachines(number_of_neurons=12, N_Classes=1, case='regression')
simple_net.fit(x_train, y_train, x_train_val=x_train_val, y_train_val=y_train_val,
hidden=number_of_neurons)
y_out = simple_net.predict(x_test, bias=True)
metrics_calculator = metric(y_test, y_out, types=['MSE', 'RMSE', 'R2'])
metric_results = metrics_calculator.calculate()
print(metric_results)
results['realization'].append(realization)
for type in ['MSE', 'RMSE', 'R2']:
results[type].append(metric_results[type])
for type in ['MSE', 'RMSE', 'R2']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
print(pd.DataFrame(final_result))
pd.DataFrame(final_result).to_csv(
get_project_root() + '/run/TR-06/ABALONE/results/' + 'result_elm.csv')
# ------------------------------------------------------------------------------------
best_number_centers = results['cf'][0][3]
final_result['alphas'].append(mean(results['alphas']))
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
# ------------------------ PLOT -------------------------------------------------
for i in range(len(final_result['best_cf'])):
plt.figure(figsize=(10, 7))
df_cm = DataFrame(final_result['best_cf'][i], index=[i for i in [0, 1, 2]],
columns=[i for i in [0, 1, 2]])
sn.heatmap(df_cm, annot=True)
plt.title(
'Matriz de connfusão dermatologia com raio de abertura: ' + str(
best_alpha) + ' e numero de neurônios: ' + str(best_number_centers))
plt.xlabel('Valor Esperado')
plt.ylabel('Valor Encontrado')
path = get_project_root() + '/run/TR-06/IRIS/results/'
plt.savefig(path + "mat_confsuison_iris_rbf.jpg")
plt.show()
print(pd.DataFrame(final_result))
del final_result['best_cf']
pd.DataFrame(final_result).to_csv(get_project_root() + '/run/TR-06/IRIS/results/' + 'result_rbf.csv')
}
marker = {
0: '^',
1: 'o',
}
# O clasificador da vigesima realização
plot_dict = {
'xx': xx,
'yy': yy,
'Z': classifier_perceptron.predict(space),
'classes': {}
}
# utilizando o x_test e o y_test da ultima realização
for c in [0, 1]:
plot_dict['classes'].update({
c: {
'X': x[where(y == c)[0]],
'point': point[c],
'marker': marker[c]
}
})
path = get_project_root() + '/run/TR-035/IRIS/results/' + 'color_map_' + str(combination) + str(one_versus_others) + '.jpg'
coloring(plot_dict, ListedColormap(['#87CEFA', '#228B22']), xlabel=combination[0],
ylabel=combination[1], title='mapa de cores com Rede Perceptron' + str(one_versus_others),
xlim=[-0.1, 1.1], ylim=[-0.1, 1.1],
path=path,
save=True)
# normalizar a base
base[['x1', 'x2']] = normalization(base[['x1', 'x2']], type='min-max')
x = array(base[['x1', 'x2']])
y = array(base[['y']])
classe0 = x[np.where(y == 0)[0]]
classe1 = x[np.where(y == 1)[0]]
classe2 = x[np.where(y == 2)[0]]
plt.plot(classe0[:, 0], classe0[:, 1], 'b^')
plt.plot(classe1[:, 0], classe1[:, 1], 'go')
plt.plot(classe2[:, 0], classe2[:, 1], 'm*')
plt.xlabel("X1")
plt.ylabel("X2")
plt.savefig(get_project_root() + '/run/TR-03/ARTIFICIAL/results/' + 'dataset_artificial.png')
plt.show()
y_out_of_c = pd.get_dummies(base['y'])
base = base.drop(['y'], axis=1)
base = concatenate([base[['x1', 'x2']], y_out_of_c], axis=1)
for realization in range(20):
train, test = split_random(base, train_percentage=.8)
train, train_val = split_random(train, train_percentage=.8)
x_train = train[:, :2]
y_train = train[:, 2:]
results['cf'].sort(key=lambda x: x[0], reverse=True)
final_result['best_cf'].append(results['cf'][0][1])
best_number_neurons = results['cf'][0][2]
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
# ------------------------ PLOT -------------------------------------------------
#
for i in range(len(final_result['best_cf'])):
plt.figure(figsize=(10, 7))
df_cm = DataFrame(final_result['best_cf'][i], index=[i for i in range(C)],
columns=[i for i in range(C)])
sn.heatmap(df_cm, annot=True)
plt.title('Matriz de connfusão dermatologia com número de neurônios: ' + str(best_number_neurons))
plt.xlabel('Valor Esperado')
plt.ylabel('Valor Encontrado')
path = get_project_root() + '/run/TR-06/CANCER/results/'
plt.savefig(path + "mat_confsuison_elm.jpg")
plt.show()
print(pd.DataFrame(final_result))
# del final_result['best_cf']
pd.DataFrame(final_result).to_csv(get_project_root() + '/run/TR-06/CANCER/results/' + 'result_elm.csv')
2: '*'
}
# O clasificador da vigesima realização
plot_dict = {
'xx': xx,
'yy': yy,
'Z': out_of_c_to_label(simple_net.predict(space)),
'classes': {}
}
# utilizando o x_test e o y_test da ultima realização
for c in [0, 1, 2]:
plot_dict['classes'].update({
c: {
'X': x[where(y == c)[0]],
'point': point[c],
'marker': marker[c]
}
})
# #FFAAAA red
# #AAAAFF blue
coloring(plot_dict, ListedColormap(['#87CEFA', '#228B22', "#FF00FF"]), xlabel='SepalLengthCm', ylabel='SepalWidthCm',
title='mapa de cores com Rede Perceptron', xlim=[-0.1, 1.1], ylim=[-0.1, 1.1],
path=get_project_root() + '/run/TR-03/IRIS/results/' + 'color_map_sepal.jpg', save=True)
# print('dataset shape %s' % Counter(base[:, 2]))
alphas=validation_alphas,
hidden=hidden,
validation=False)
y_out = simple_net.predict(x_test, bias=True)
metrics_calculator = metric(y_test, y_out, types=['MSE', 'RMSE'])
metric_results = metrics_calculator.calculate()
print(metric_results)
results['alphas'].append(simple_net.lr)
results['realization'].append(realization)
for type in ['MSE', 'RMSE']:
results[type].append(metric_results[type])
final_result['alphas'].append(mean(results['alphas']))
for type in ['MSE', 'RMSE']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
print(pd.DataFrame(final_result))
pd.DataFrame(final_result).to_csv(
get_project_root() + '/run/TR-05/ELETRIC_MOTOR_TEMPERATURE/results/' + 'result_mlp_' + different_target + '.csv')
# ------------------------------------------------------------------------------------
base = pd.DataFrame(load_mock(type='LOGICAL_XOR'),
columns=['x1', 'x2', 'y'])
base[['x1', 'x2']] = normalization(base[['x1', 'x2']], type='min-max')
x = array(base[['x1', 'x2']])
y = array(base[['y']])
classe0 = x[np.where(y == 0)[0]]
classe1 = x[np.where(y == 1)[0]]
plt.plot(classe0[:, 0], classe0[:, 1], 'b^')
plt.plot(classe1[:, 0], classe1[:, 1], 'go')
plt.xlabel("X1")
plt.ylabel("X2")
plt.savefig(get_project_root() + '/run/TR-05/XOR/results/' +
'dataset_xor_artificial.png')
plt.show()
# ----------------------- one - hot ---------------------------------------------------
N, M = base.shape
C = len(base['y'].unique())
y_out_of_c = pd.get_dummies(base['y'])
base = base.to_numpy()
# --------------------------------------------------------------------------------------
for realization in range(1):
train, test = split_random(base, train_percentage=.8)
best_number_centers = results['cf'][0][3]
final_result['alphas'].append(mean(results['alphas']))
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
# ------------------------ PLOT -------------------------------------------------
for i in range(len(final_result['best_cf'])):
plt.figure(figsize=(10, 7))
df_cm = DataFrame(final_result['best_cf'][i], index=[i for i in range(C)],
columns=[i for i in range(C)])
sn.heatmap(df_cm, annot=True)
plt.title(
'Matriz de connfusão dermatologia com raio de abertura: ' + str(best_alpha) + ' e número de neurônios: ' + str(
best_number_centers))
plt.xlabel('Valor Esperado')
plt.ylabel('Valor Encontrado')
path = get_project_root() + '/run/TR-06/COLUNA_2C/results/'
plt.savefig(path + "mat_confsuison_rbf.jpg")
plt.show()
print(pd.DataFrame(final_result))
del final_result['best_cf']
pd.DataFrame(final_result).to_csv(get_project_root() + '/run/TR-06/COLUNA_2C/results/' + 'result_rbf_net.csv')
best_number_neurons = results['cf'][0][2]
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
# ------------------------ PLOT -------------------------------------------------
for i in range(len(final_result['best_cf'])):
plt.figure(figsize=(10, 7))
df_cm = DataFrame(final_result['best_cf'][i],
index=[i for i in range(C)],
columns=[i for i in range(C)])
sn.heatmap(df_cm, annot=True)
plt.title(
'Matriz de connfusão dermatologia com número de neurônios: ' +
str(best_number_neurons))
plt.xlabel('Valor Esperado')
plt.ylabel('Valor Encontrado')
path = get_project_root() + '/run/TR-06/DERMATOLOGIA/results/'
plt.savefig(path + "mat_confsuison_elm.jpg")
plt.show()
print(pd.DataFrame(final_result))
del final_result['best_cf']
pd.DataFrame(final_result).to_csv(get_project_root() +
'/run/TR-06/DERMATOLOGIA/results/' +
'result_elm.csv')
results[type].append(metric_results[type])
final_result['versus'].append(one_versus_others)
final_result['K'].append(3)
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
results['cf'].sort(key=lambda x: x[0], reverse=True)
final_result['best_cf'].append(results['cf'][0][1])
best_acc_clf = results['cf'][0][2]
best_acc = results['cf'][0][0]
df_cm = DataFrame(results['cf'][0][1],
index=[i for i in range(C)],
columns=[i for i in range(C)])
sns.heatmap(df_cm, annot=True)
plt.title('Matriz de connfusão do KNN com acurácia de ' +
str(round(best_acc, 2) * 100) + "%")
plt.xlabel('Valor Esperado')
plt.ylabel('Valor Encontrado')
path = get_project_root() + '/run/TR-00/IRIS/results/'
plt.savefig(path + one_versus_others + "-conf_result_knn.jpg")
plt.show()
DataFrame(final_result).to_csv(get_project_root() +
'/run/TR-00/IRIS/results/' +
'result_knn.csv')
print(DataFrame(final_result))
y_train,
x_train_val=x_train_val,
y_train_val=y_train_val,
alphas=validation_alphas,
hidden=hidden,
validation=False)
y_out = simple_net.predict(x_test, bias=True)
metrics_calculator = metric(y_test,
y_out,
types=['MSE', 'RMSE', 'R2'])
metric_results = metrics_calculator.calculate()
print(metric_results)
results['realization'].append(realization)
for type in ['MSE', 'RMSE', 'R2']:
results[type].append(metric_results[type])
for type in ['MSE', 'RMSE', 'R2']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
print(pd.DataFrame(final_result))
pd.DataFrame(final_result).to_csv(
get_project_root() +
'/run/TR-06/ELETRIC_MOTOR_TEMPERATURE/results/' + 'result_rbf_' +
different_target + '.csv')
# ------------------------------------------------------------------------------------
print(metric_results)
results['alphas'].append(simple_net.learning_rate)
results['realization'].append(realization)
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
results[type].append(metric_results[type])
final_result['alphas'].append(mean(results['alphas']))
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
# ------------------------ PLOT -------------------------------------------------
# for i in range(len(final_result['best_cf'])):
# plt.figure(figsize=(10, 7))
#
# df_cm = DataFrame(final_result['best_cf'][i], index=[i for i in "012"],
# columns=[i for i in "012"])
# sn.heatmap(df_cm, annot=True)
#
# path = get_project_root() + '/run/TR-03/ARTIFICIAL/results/'
# plt.savefig(path + "mat_confsuison_triangle.jpg")
# plt.show()
print(pd.DataFrame(final_result))
# del final_result['best_cf']
pd.DataFrame(final_result).to_csv(get_project_root() +
'/run/TR-03/COLUNA_3C/results/' +
'result_simple_net.csv')
'MSE': [],
'RMSE': [],
'erros': [],
'alphas': []
}
F, x1, x2 = load_mock(type='2D_REGRESSOR')
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(x1, x2, F, color='k')
ax.set_title("y = ax1 + bx2 + c")
ax.set_xlabel("x1")
ax.set_ylabel("x2")
ax.set_zlabel("y")
plt.savefig(get_project_root() + '/run/TR-02/ARTIFICIAL/results/' +
'adaline_fig_2.jpg')
plt.show()
base = concatenate(
[array(x1, ndmin=2),
array(x2, ndmin=2),
array(F, ndmin=2)], axis=0).T
validation_alphas = linspace(0.015, 0.1, 20)
for realization in range(20):
print("Realization" + str(realization))
train, test = split_random(base, train_percentage=.8)
train, train_val = split_random(train, train_percentage=0.7)
x_train = train[:, :2]
print(metric_results)
results['alphas'].append(simple_net.learning_rate)
results['realization'].append(realization)
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
results[type].append(metric_results[type])
final_result['alphas'].append(mean(results['alphas']))
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
# ------------------------ PLOT -------------------------------------------------
# for i in range(len(final_result['best_cf'])):
# plt.figure(figsize=(10, 7))
#
# df_cm = DataFrame(final_result['best_cf'][i], index=[i for i in ['']],
# columns=[i for i in ['']])
# sn.heatmap(df_cm, annot=True)
#
# path = get_project_root() + '/run/TR-03/IRIS/results/'
# plt.savefig(path + "mat_confsuison_iris.jpg")
# plt.show()
print(pd.DataFrame(final_result))
# del final_result['best_cf']
pd.DataFrame(final_result).to_csv(get_project_root() + '/run/TR-03/IRIS/results/' + 'result_simple_net.csv')
results['cf'].sort(key=lambda x: x[0], reverse=True)
final_result['best_cf'].append(results['cf'][0][1])
best_number_neurons = results['cf'][0][2]
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
# ------------------------ PLOT -------------------------------------------------
for i in range(len(final_result['best_cf'])):
plt.figure(figsize=(10, 7))
df_cm = DataFrame(final_result['best_cf'][i],
index=[i for i in range(C)],
columns=[i for i in range(C)])
sn.heatmap(df_cm, annot=True)
plt.title(
'Matriz de connfusão dermatologia com número de neurônios: ' +
str(best_number_neurons))
plt.xlabel('Valor Esperado')
plt.ylabel('Valor Encontrado')
path = get_project_root() + '/run/TR-06/COLUNA_3C/results/'
plt.savefig(path + "mat_confsuison_elm.jpg")
plt.show()
# del final_result['best_cf']
# print(pd.DataFrame(final_result))
# pd.DataFrame(final_result).to_csv(get_project_root() + '/run/TR-06/COLUNA_3C/results/' + 'result_elm.csv')
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
results['cf'].sort(key=lambda x: x[0], reverse=True)
final_result['best_cf'].append(results['cf'][0][1])
best_acc_clf = results['cf'][0][2]
best_acc = results['cf'][0][0]
df_cm = DataFrame(results['cf'][0][1], index=[i for i in range(C)],
columns=[i for i in range(C)])
sn.heatmap(df_cm, annot=True)
plt.title('Matriz de connfusão do KNN com acurácia de ' + str(round(best_acc, 2) * 100) + "%")
plt.xlabel('Valor Esperado')
plt.ylabel('Valor Encontrado')
path = get_project_root() + '/run/ML-00/COLUNA_3C/results/'
plt.savefig(path + one_versus_others + "-conf_result_knn.jpg")
plt.show()
print(DataFrame(final_result))
DataFrame(final_result).to_csv(get_project_root() + '/run/ML-00/COLUNA_3C/results/' + one_versus_others + '_result_knn.csv')
xx, yy = generate_space(x_test)
space = c_[xx.ravel(), yy.ravel()]
point = {
0: 'ro',
1: 'bo'
}
marker = {
0: 's',
results['alphas'].append(simple_net.learning_rate)
results['realization'].append(realization)
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
results[type].append(metric_results[type])
results['cf'].sort(key=lambda x: x[0], reverse=True)
final_result['best_cf'].append(results['cf'][0][1])
final_result['alphas'].append(mean(results['alphas']))
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
# ------------------------ PLOT -------------------------------------------------
for i in range(len(final_result['best_cf'])):
plt.figure(figsize=(10, 7))
df_cm = DataFrame(final_result['best_cf'][i],
index=[i for i in range(C)],
columns=[i for i in range(C)])
sn.heatmap(df_cm, annot=True)
path = get_project_root() + '/run/TR-05/DERMATOLOGIA/results/'
plt.savefig(path + "mat_confsuison.jpg")
plt.show()
# print(pd.DataFrame(final_result))
# del final_result['best_cf']
# pd.DataFrame(final_result).to_csv(get_project_root() + '/run/TR-05/DERMATOLOGIA/results/' + 'result_mlp.csv')
results['realization'].append(realization)
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
results[type].append(metric_results[type])
results['cf'].sort(key=lambda x: x[0], reverse=True)
final_result['best_cf'].append(results['cf'][0][1])
final_result['alphas'].append(mean(results['alphas']))
for type in ['ACCURACY', 'precision', 'recall', 'f1_score']:
final_result[type].append(mean(results[type]))
final_result['std ' + type].append(std(results[type]))
# ------------------------ PLOT -------------------------------------------------
for i in range(len(final_result['best_cf'])):
plt.figure(figsize=(10, 7))
df_cm = DataFrame(final_result['best_cf'][i], index=[i for i in [0,1,2]],
columns=[i for i in [0,1,2]])
sn.heatmap(df_cm, annot=True)
path = get_project_root() + '/run/TR-05/IRIS/results/'
plt.savefig(path + "mat_confsuison_iris.jpg")
plt.show()
print(pd.DataFrame(final_result))
# del final_result['best_cf']
# pd.DataFrame(final_result).to_csv(get_project_root() + '/run/TR-05/IRIS/results/' + 'result_mlp.csv')
'std RMSE': [],
'R2': [],
'std R2': []
}
results = {'realization': [], 'MSE': [], 'RMSE': [], 'R2': []}
base = load_mock(type='MOCK_SENO')
# normalizar a base
base[['x1']] = normalization(base[['x1']], type='min-max')
sn.set_style('whitegrid')
sn.scatterplot(data=base, x="x1", y="y", color='c')
plt.xlabel("X1")
plt.ylabel("Y")
plt.savefig(get_project_root() +
'/run/TR-05/ARTIFICIAL_REGRESSAO/results/' +
'dataset_seno_artificial.png')
plt.show()
x = array(base[['x1']])
y = array(base[['y']])
N, M = base.shape
C = 1 # Problema de regressão
epochs = 2000
for realization in range(20):
train, test = split_random(base, train_percentage=.8)
train, train_val = split_random(train, train_percentage=.8)
