def run_k_fold(multi_data, X, Y, CLASSES, MODEL, BATCH_SIZE, num_folds):
VALIDATION_ACCURACY = []
VALIDATION_LOSS = []
HISTORY = []
MODEL_NAME = MODEL
FOLDS = num_folds
EPOCHS = 0
save_dir = os.path.join(os.getcwd(), 'models/')
VERBOSE = 1
skf = StratifiedKFold(n_splits=FOLDS, random_state=7, shuffle=True)
fold_var = 1
for train_index, val_index in skf.split(X, Y):
print("=======EPOCHS ", EPOCHS, " Start--k: ", fold_var)
validation_data = multi_data.iloc[val_index]
print(validation_data.shape)
directory_mover(validation_data,"validation_data_"+MODEL_NAME+str(BATCH_SIZE)+'_'+str(EPOCHS)+'_'+str(fold_var))
# tfrecord
#valid_data_generator = transform_image_to_tfrecord_image_path(os.path.join(os.getcwd(),"new\working\\","validation_data_"+MODEL_NAME+str(BATCH_SIZE)+'_'+str(EPOCHS)+'_'+str(fold_var)), BATCH_SIZE)
valid_data_generator = dataTrainAugmentation().flow_from_directory(
# training_data,
directory=os.path.join(os.getcwd(), 'new/working/validation_data_'+MODEL_NAME+str(BATCH_SIZE)+'_'+str(EPOCHS)+'_'+str(fold_var)+'/'),
target_size=(250, 250),
# x_col = "image_path", y_col = "name",
batch_size=1,
class_mode="categorical",
#subset="validation",
shuffle=False)
model = get_model(MODEL, CLASSES)
sgd = optimizers.SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd, loss='categorical_crossentropy', metrics=['acc'])
model.load_weights("model_TFrecordDeepFace_1_60.h5")
results = model.evaluate(valid_data_generator)
# results = model.evaluate_generator(valid_data_generator)
predict = model.predict_generator(valid_data_generator)
print('predict 1')
print(predict)
print(np.argmax(predict, axis=-1))
classes1 = np.argmax(predict, axis=-1)
print('results 1')
print(results)
results = dict(zip(model.metrics_names, results))
y_pred = np.argmax(predict, axis=1)
print(y_pred)
print(valid_data_generator.classes)
nomes_classes = []
for i in pd.DataFrame(Y.groupby('name')['name'].nunique().reset_index(name="unique"))[
'name']:
nomes_classes.append(str(i))
write_cm_report(Y, valid_data_generator.classes, y_pred, 'model1_'+get_current_time_str() + 'main1_k_fold_' + str(CLASSES) + '_' + MODEL_NAME + '_' + str(EPOCHS) + '_' + str(
BATCH_SIZE)+'.txt')
cm = confusion_matrix(valid_data_generator.classes, y_pred)
plot_confusion_matrix(cm, classes=nomes_classes, CLASSES=CLASSES, MODEL_NAME=MODEL_NAME, EPOCHS=EPOCHS, BATCH_SIZE=BATCH_SIZE, title='Matriz de Confusão')
model2 = model
model2.load_weights("model_TFrecordDeepFace_2_60.h5")
predict2 = model2.predict(valid_data_generator)
print('predict 2')
print(predict2)
print(np.argmax(predict2, axis=-1))
classes2 = np.argmax(predict2, axis=-1)
results2 = model2.evaluate(valid_data_generator)
print('results 2')
print(results2)
model3 = model
model3.load_weights("model_TFrecordDeepFace_3_60.h5")
predict3 = model3.predict(valid_data_generator)
print('predict 3')
print(predict3)
print(np.argmax(predict3, axis=-1))
classes3 = np.argmax(predict3, axis=-1)
results3 = model3.evaluate(valid_data_generator)
print('results 3')
print(results3)
print("MEAN ====================")
final_mean = (predict + predict2 + predict3)/3
print(final_mean.shape)
print(final_mean)
print(np.argmax(final_mean, axis=-1))
pred_ensemble_media = np.argmax(final_mean, axis=-1)
write_cm_report(Y, valid_data_generator.classes, pred_ensemble_media, 'ensemble_media_'+get_current_time_str() + 'main1_k_fold_' + str(CLASSES) + '_' + MODEL_NAME + '_' + str(EPOCHS) + '_' + str(
BATCH_SIZE)+'.txt')
cm2 = confusion_matrix(valid_data_generator.classes, pred_ensemble_media)
plot_confusion_matrix(cm2, classes=nomes_classes, CLASSES=CLASSES, MODEL_NAME=MODEL_NAME, EPOCHS=EPOCHS, BATCH_SIZE=BATCH_SIZE, title='Matriz de Confusão')
print("Voto marjoritario ====================")
'''
final_max = np.array([])
for i in range(0,validation_data.shape[0]):
predict[i]
final_max = np.append(final_max, np.maximum(predict[i], predict2[i],predict3[i]))
print(final_max)
print(np.argmax(final_max, axis=-1))
'''
final_pred_mode = np.array([])
#final_pred_mode = []
print(validation_data.shape[0])
for i in range(0,validation_data.shape[0]):
print(classes1[i])
print(classes2[i])
print(classes3[i])
print(mode([classes1[i], classes2[i], classes3[i]]))
final_pred_mode = np.append(final_pred_mode, mode([classes1[i], classes2[i], classes3[i]])[0][0])
#final_pred_mode.append(statistics.mode([predict[i], predict2[i], predict3[i]]))
print('final_pred_mode')
print(len(final_pred_mode))
print(final_pred_mode)
print(final_pred_mode.astype(int))
print(type(final_pred_mode[0]))
print(final_pred_mode[0])
print(np.argmax(final_pred_mode, axis=-1))
pred_ensemble_mode = np.argmax(final_pred_mode, axis=-1)
write_cm_report(Y, valid_data_generator.classes, final_pred_mode.astype(int), 'ensemble_marjoritario_'+get_current_time_str() + 'main1_k_fold_' + str(CLASSES) + '_' + MODEL_NAME + '_' + str(EPOCHS) + '_' + str(
BATCH_SIZE)+'.txt')
cm3 = confusion_matrix(valid_data_generator.classes, final_pred_mode.astype(int))
plot_confusion_matrix(cm3, classes=nomes_classes, CLASSES=CLASSES, MODEL_NAME=MODEL_NAME, EPOCHS=EPOCHS, BATCH_SIZE=BATCH_SIZE, title='Matriz de Confusão')
"""
[0.1 0.2 0.7] modelo1
[0.3333 0.333 0.333300001] modelo2
[0.7 0.3 0.00001] modelo3
===================
media
"""
#labels_ds = valid_data_generator.map(lambda image, label: label).unbatch()
#print('labels_ds') #_UnbatchDataset
#print(labels_ds) #_UnbatchDataset
#print(dir(labels_ds)) #_UnbatchDataset
#all_labels = []
#all_labels.append(next(iter(labels_ds.batch(validation_data.shape[0]))).numpy())
#print('all_labels')
#print(all_labels)
#print(len(all_labels))
#cm_correct_labels = np.concatenate(all_labels)
#print(cm_correct_labels)
#print(cm_correct_labels.shape)
#for i in cm_correct_labels:
# print(i)
#label2 = []
#label2.append(np.argmax(cm_correct_labels, axis=-1))
#print('label2')
#print(len(label2))
#print(label2)
#transform
#label_transf = np.concatenate(label2)
#print('label_transf')
#print(len(label_transf))
#print(label_transf)
#3for i in cm_correct_labels:
# 3 print(i) cada imagem tem um array de 34 onde a posição True indica qual o label
#predict = model.predict()
'''
print('predict')
print(predict.shape)
print(predict)
all_pred = []
all_pred.append( np.argmax(predict, axis=-1) )
print('all_pred')
print(all_pred)
print(len(all_pred))
cm_predictions = np.concatenate(all_pred)
print('cm_predictions')
print(cm_predictions.shape)
print(cm_predictions)
# results = model.evaluate_generator(valid_data_generator)
results = dict(zip(model.metrics_names, results))
print('results 2')
print(results)
print('quem nunca eh classificado')
print(set(valid_data_generator.classes) - set(cm_predictions))
cmat = confusion_matrix(valid_data_generator.classes, cm_predictions)
print(cmat)
score = f1_score(valid_data_generator.classes, cm_predictions, average='macro')
precision = precision_score(valid_data_generator.classes, cm_predictions, average='macro')
recall = recall_score(valid_data_generator.classes, cm_predictions, average='macro')
#display_confusion_matrix(cmat, score, precision, recall)
print('f1 score: {:.3f}, precision: {:.3f}, recall: {:.3f}'.format(score, precision, recall))
print('CLASSES_NAMES GLOBAL')
print(valid_data_generator.labels)
print(valid_data_generator.labels.shape)
#VALIDATION_ACCURACY.append(1)
#VALIDATION_LOSS.append(2)
print(classification_report(valid_data_generator.classes, cm_predictions, target_names=valid_data_generator.labels))
'''
###plot_confusion_matrix(cm, classes=nomes_classes, title='Matriz de Confusão')
'''
'''
'''
score = f1_score(valid_data_generator.classes, cm_predictions, average='macro')
precision = precision_score(valid_data_generator.classes, cm_predictions, average='macro')
recall = recall_score(valid_data_generator.classes, cm_predictions, average='macro')
#display_confusion_matrix(cmat, score, precision, recall)
print('f1 score: {:.3f}, precision: {:.3f}, recall: {:.3f}'.format(score, precision, recall))
print('CLASSES_NAMES GLOBAL')
print(valid_data_generator.labels)
print(valid_data_generator.labels.shape)
#VALIDATION_ACCURACY.append(1)
#VALIDATION_LOSS.append(2)
plot_confusion_matrix(cmat, classes=valid_data_generator.labels, title='Matriz de Confusão')
print(classification_report(valid_data_generator.classes, cm_predictions, target_names=valid_data_generator.labels))
'''
del model
#del history
tf.keras.backend.clear_session()
gc.collect()
tf.compat.v1.reset_default_graph()
fold_var += 1
else:
y_pred=np.load(y_pred_export_path)
'''
y_prob=model.predict(X,batch_size=128)
y_pred = np.argmax(y_prob, axis=1)
print('y_true shape: {}'.format(y.shape))
print('y_pred shape: {}'.format(y_pred.shape))
#print(y_prob.shape) # (num_samples,2)
#print(y_prob[:5])
cm=confusion_matrix(y,y_pred)
print('confusion matrix: {}'.format(cm))
plot_confusion_matrix(cm)
# f1 score
f1=f1_score(y,y_pred)
print('f1 score: {}'.format(f1))
# precision
p=precision_score(y,y_pred)
print('precision: {}'.format(p))
# recall
r=recall_score(y,y_pred)
print('recall: {}'.format(r))
# auc
#y_prob=np.load(y_prob_export_path)
save_path = '/data0/gkb_dataset/meta_multi_task_db_ext/result_jpg/'
file_dict = {
'MTLReptileFCT1-200-concat_Avg-T-': [
'/data0/gkb_dataset/meta_multi_task_db_ext/new_idea_task_result/',
'-WA-1st-mat.npy', 'MTLReptile.pdf'
],
'Non-multi2-200-concat_Avg-T-': [
'/data0/gkb_dataset/meta_multi_task_db_ext/new_idea_task_result/',
'-WA-1st-mat.npy', 'Multitask.pdf'
],
'200-concat_Avg-T-': [
'/data0/gkb_dataset/old_idea/new_single_task_result/',
'-F1-1st-mat.npy', 'baseline.pdf'
]
}
file_name = file_dict.keys()
for each in file_name:
prefix, suffix, photo_name = file_dict.get(each)
mat_name = prefix + each + suffix
mat = np.load(mat_name)
mat = mat.T
plot_confusion_matrix(cm=mat,
target_names=['neu', 'ang', 'hap', 'sad'],
title='Confusion matrix',
cmap=None,
normalize=True,
save_path=save_path,
save_name=photo_name)
file=text_file)
y_pred = bst_model.predict(X_test)
print("Tseting Accuracy : " + str(accuracy_score(y_test, y_pred)),
file=text_file)
cnf_matrix = confusion_matrix(y_test, y_pred)
print("Classification Report: ", file=text_file)
print(classification_report(y_test, y_pred), file=text_file)
return cnf_matrix
if __name__ == "__main__":
df = pd.read_csv("dataSet_business.csv")
text_file = open("./result/model_result.txt", "a+")
text_file.write("\n")
text_file.write(".This is Logistic Regression model")
text_file.write("\n")
X_train, X_test, y_train, y_test = data_processing()
cnf_matrix = train(X_train, X_test, y_train, y_test, text_file)
print("Confusion matrix", file=text_file)
print(cnf_matrix, file=text_file)
text_file.close()
class_names = ["bad", "good"]
plot_confusion_matrix(cnf_matrix,
classes=class_names,
title='Confusion matrix__Logistic Regression')
for i in range(0,train_size):
classId = y_train[i] - 1
noOfOccurences[classId] = noOfOccurences[classId] + X_train[i]
prior[classId] = prior[classId] + 1
elapsed = time.time() - start_time
classWordCounts = np.sum(noOfOccurences, axis=1).reshape((noOfClasses,1))
likelihood = np.zeros((noOfClasses,codebook_size))
likelihood = np.log(np.divide(noOfOccurences,classWordCounts))
prior = prior/train_size
#End of train
#Test
out = np.matmul(X_test, np.transpose(likelihood)) + np.transpose(np.log(prior))
#Get predictions
predict = np.argmax(out,axis=1)
#Calculate confusion matrix
cm = confusion_matrix(y_test-1, predict)
#Find accuracy
acc = np.sum(np.diag(cm))/np.sum(np.sum(cm))
plot_confusion_matrix(cm,'Confusion Matrix for Naive Bayes')
y_test_total.extend(y_test.tolist())
model = clf.fit(X_train, y_train)
y_pred = model.predict(X_test)
y_pred_total.extend(y_pred.tolist())
p,r,f,s = precision_recall_fscore_support(y_test, y_pred, average='weighted')
#print(accuracy_score(y_test, y_pred))
a_score.append(accuracy_score(y_test, y_pred))
precision.append(p)
recall.append(r)
fscore.append(f)
plot_learning_curve(clf, "Learning Curves", X, Y, ylim=None, cv=skf, n_jobs=1, train_sizes=np.linspace(.1, 1.0, 5))
plt.savefig('images/RF-LearningCurve.png')
return pd.Series(y_test_total), pd.Series(y_pred_total), np.mean(precision),np.mean(recall),np.mean(fscore), np.mean(a_score)
classes = ['building float','building non float','vehicle float','containers','tableware','headlamps']
iterations = [i for i in range(0, 25)]
y_test, y_pred, precision, recall, fscore, accuracy = crossValidation()
cnf_matrix = confusion_matrix(y_test, y_pred)
np.set_printoptions(precision=2)
plt.figure()
plot_confusion_matrix(cnf_matrix, classes=classes, title='Confusion Matrix')
print("\nHere is the Classification Report:")
print(classification_report(y_test, y_pred, target_names=classes))
print("prfa:",precision, recall, fscore, accuracy)
plt.tight_layout()
plt.savefig("images/RF-ConfusionMatrix.png")
plt.figure()
plt.plot(iterations, a_score)
plt.xlabel('Iterations', fontsize=12)
plt.ylabel('Accuracy', fontsize=12)
plt.savefig("images/RF-IterationsVsAccuracy.png")
from sklearn.preprocessing import FunctionTransformer
from copy import copy
exported_pipeline = make_pipeline(
make_union(FunctionTransformer(copy), FunctionTransformer(copy)),
GradientBoostingClassifier(learning_rate=0.5,
max_depth=6,
max_features=0.9000000000000001,
min_samples_leaf=1,
min_samples_split=13,
n_estimators=100,
subsample=0.6000000000000001))
training_features, training_target = xc_t, yt
exported_pipeline.fit(training_features, training_target)
results = exported_pipeline.predict(xc_v)
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(yv, results)
#np.set_printoptions(precision=2)
#cm_normalized = cm.astype('float')/cm.sum(axis=1)[:, np.newaxis]
#print(cm_normalized)
from plot_cm import plot_confusion_matrix
plot_confusion_matrix(cm,
normalize=False,
target_names=['po', 'n', 'ng'],
title="Confusion Matrix")
y_pred = bst_model.predict(X_test)
print("Tseting Accuracy : " + str(accuracy_score(y_test, y_pred)),
file=text_file)
print("Classification Report: ", file=text_file)
print(classification_report(y_test, y_pred), file=text_file)
cnf_matrix = confusion_matrix(y_test, y_pred)
return cnf_matrix
if __name__ == "__main__":
df = pd.read_csv("dataSet_business.csv")
text_file = open("./result/model_result.txt", "a+")
text_file.write("\n")
text_file.write(".This is Linear SVC model")
text_file.write("\n")
X_train, X_test, y_train, y_test = data_processing()
cnf_matrix = train(X_train, X_test, y_train, y_test, text_file)
print("Confusion matrix", file=text_file)
print(cnf_matrix, file=text_file)
text_file.close()
class_names = ["bad", "good"]
plot_confusion_matrix(cnf_matrix,
classes=class_names,
title='Confusion matrix__LinearSVC')
y_pred = bst_model.predict(X_test)
print("Classification Report: ", file=text_file)
print(classification_report(y_test, y_pred), file=text_file)
print("Tseting Accuracy : " + str(accuracy_score(y_test, y_pred)),
file=text_file)
cnf_matrix = confusion_matrix(y_test, y_pred)
return cnf_matrix
if __name__ == "__main__":
df = pd.read_csv("dataSet_business.csv")
text_file = open("./result/model_result.txt", "a+")
text_file.write("\n")
text_file.write(".This is RandomForest Classifier model")
text_file.write("\n")
X_train, X_test, y_train, y_test = data_processing()
cnf_matrix = train(X_train, X_test, y_train, y_test, text_file)
print("Confusion matrix", file=text_file)
print(cnf_matrix, file=text_file)
text_file.close()
class_names = ["bad", "good"]
plot_confusion_matrix(cnf_matrix,
classes=class_names,
title='Confusion matrix__RandomForest Classifier')
#Combine features from chiSq and word2Vec
combinedFeatures = np.hstack([chisqDtm,wordVecs])
iterations = [i for i in range(0, 15)]
y_test, y_pred, precision, recall, fscore, accuracy = crossValidate(chisqDtm,labels,15)
cnf_matrix = confusion_matrix(y_test, y_pred)
np.set_printoptions(precision=2)
plt.figure()
class_names = ['INFOCOM', 'ISCAS', 'SIGGRAPH', 'VLDB', 'WWW']
plot_confusion_matrix(cnf_matrix, classes=class_names, title='Confusion Matrix - SVM')
print "\nHere is the Classification Report:"
print classification_report(y_test, y_pred, target_names=class_names)
print "ChiSq Features:",precision, recall, fscore, accuracy
plt.tight_layout()
plt.savefig("imga.png")
plt.figure()
plt.plot(iterations, a_score)
plt.xlabel('Iterations', fontsize=12)
plt.ylabel('Accuracy', fontsize=12)
import numpy as np
import matplotlib.pyplot as plt
import pickle
from plot_cm import plot_confusion_matrix
from options import *
activities = [
"A-Checking", "A-Moving", "A-Preparing", "A-Sitting", "A-Standing",
"A-Taking-Dropping", "A-Transporting", "C-Compacting", "C-Leveling",
"C-Placing", "C-Transporting", "F-Machining", "F-Placing-Fixing",
"F-Transporting", "R-Machining", "R-Placing-Fixing", "R-Transporting"
]
cf = pickle.load(
open(os.path.join(param_fdp_results, "results_{}_{}_cm.p".format(8, 0)),
"rb"))
# Plot normalized confusion matrix
plt.figure(figsize=(8, 6))
plot_confusion_matrix(
cf,
classes=range(1,
len(activities) + 1),
normalize=True,
title='Normalized confusion matrix, average accuracy: 98.77%')
# plt.show()
plt.gcf().savefig('confusion.png', dpi=300, bbox_inches='tight', pad_inches=0)
#Train Parameters
batch_size = 75
iteration_size = 50
#one hot encoding for labels
d = np.zeros((M, cl))
for i in range(M):
print(i)
d[i, od[i]] = 1
#Construct regression object
model = LogisticRegression(lr, w, d, cl)
#Train the model
model.train(x, d, batch_size, iteration_size, y_test, X_test)
#Predict
test_pred = model.predict(X_test)
#Confusion Matrix for Test
cm = confusion_matrix(y_test, test_pred)
#Accuracy
acc = np.sum(np.diag(cm)) / np.sum(np.sum(cm))
#Plot confusion matrix
plot_confusion_matrix(
cm,
'Confusion Matrix for Logistic Regression - K = 2000, Batch Size = 75, Iteration = 50'
)
print("Tseting Accuracy : " + str(accuracy_score(y_test, y_pred)),file= text_file)
print("\n", file=text_file)
print("Classification Report: ", file=text_file)
print(classification_report(y_test, y_pred), file=text_file)
# print("\n",file=text_file)
cnf_matrix = confusion_matrix(y_test, y_pred)
return cnf_matrix
if __name__ == "__main__":
df = pd.read_csv("dataSet_business.csv")
text_file = open("./result/model_result.txt", "a+")
text_file.write("\n")
text_file.write(".This is GussianNB model")
text_file.write("\n")
X_train, X_test, y_train, y_test = data_processing()
cnf_matrix = train(X_train, X_test, y_train, y_test,text_file)
print("Confusion matrix", file=text_file)
print(cnf_matrix,file=text_file)
text_file.close()
class_names = ["bad", "good"]
plot_confusion_matrix(cnf_matrix, classes=class_names,
title='Confusion matrix__GussianNB')
y_pred = bst_model.predict(X_test)
print("Classification Report: ", file=text_file)
print(classification_report(y_test, y_pred), file=text_file)
print("Tseting Accuracy : " + str(accuracy_score(y_test, y_pred)),
file=text_file)
cnf_matrix = confusion_matrix(y_test, y_pred)
return cnf_matrix
if __name__ == "__main__":
df = pd.read_csv("dataSet_business.csv")
text_file = open("./result/model_result.txt", "a+")
text_file.write("\n")
text_file.write(".This is KNN model")
text_file.write("\n")
X_train, X_test, y_train, y_test = data_processing()
cnf_matrix = train(X_train, X_test, y_train, y_test, text_file)
print("Confusion matrix", file=text_file)
print(cnf_matrix, file=text_file)
text_file.close()
class_names = ["bad", "good"]
plot_confusion_matrix(cnf_matrix,
classes=class_names,
title='Confusion matrix__KNN Classifier')
axs[5].plot(np.arange(12), neutralP, '.',linestyle='-')
axs[5].set_title('Neutral')
#setting the x label
for ax in axs.flat:
ax.set(xlabel='Expected emotion per 30 sec. video')
plt.xticks(np.arange(12), pred[12*j:12*j+12], rotation=45)
#hide x labels for top plots
for ax in axs.flat:
ax.label_outer()
#setting height between plots
plt.subplots_adjust(hspace=2)
#setting the y label to be in the middle and not too close to the y values
fig.text(0.06, 0.5, 'Calibrated observation\n\n\n\n\n\n', ha='center', va='center', rotation='vertical')
plt.show()
#saving with the command below will not save the full plot
#plt.savefig('Exp.1-Test subject no. {:d}.png'.format(j+1))
#plotting the confusion matrix using the imported function
array = confusion_matrix(actual, pred, labels=["Angry", "Fear", "Happy", "Sad", "Surprise", "Neutral"])
plot_confusion_matrix(cm = array, normalize = False, target_names = ["Angry", "Fear", "Happy", "Sad", "Surprise", "Neutral"])
def run_k_fold(multi_data, X, Y, CLASSES, MODEL, BATCH_SIZE, num_folds,
nomes_classes):
VALIDATION_ACCURACY = []
VALIDATION_LOSS = []
HISTORY = []
MODEL_NAME = MODEL
FOLDS = num_folds
EPOCHS = 0
save_dir = os.path.join(os.getcwd(), 'models/')
VERBOSE = 1
#calfw_directory_mover(multi_data,"validation_data_"+MODEL_NAME+str(BATCH_SIZE)+'_'+str(EPOCHS)+'_'+str('fold_var'))
train_datagen = tf.keras.preprocessing.image.ImageDataGenerator(
#rescale=1. / 255,
#shear_range=0.2,
#zoom_range=0.2,
#horizontal_flip=True
validation_split=0.5)
print(train_datagen)
train_generator = train_datagen.flow_from_directory(
directory=os.path.join(
os.getcwd(),
'new_calfw/working/validation_data_DeepFace60_0_fold_var'),
target_size=(250, 250),
batch_size=60,
class_mode='binary',
subset='training') # set as training data
print(train_generator)
validation_generator = train_datagen.flow_from_directory(
directory=os.path.join(
os.getcwd(),
'new_calfw/working/validation_data_DeepFace60_0_fold_var'
), # same directory as training data
target_size=(250, 250),
batch_size=60,
class_mode='binary',
subset='validation') # set as validation data
print(validation_generator)
model = get_model(MODEL, CLASSES)
sgd = optimizers.SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['acc'])
model.load_weights("model_TFrecordDeepFace_1_60.h5")
checkpoint = tf.keras.callbacks.ModelCheckpoint(
save_dir + get_model_name(MODEL_NAME, 'fold_var', 'BATCH_SIZE'),
monitor='val_acc',
verbose=VERBOSE,
save_best_only=True,
mode='max')
earlystopping = tf.keras.callbacks.EarlyStopping(monitor='val_loss',
mode='min',
verbose=VERBOSE,
patience=200)
callbacks_list = [checkpoint, earlystopping]
history = model.fit(
train_generator,
epochs=5,
steps_per_epoch=train_generator.n // train_generator.batch_size,
callbacks=callbacks_list,
validation_data=validation_generator,
validation_steps=validation_generator.n //
validation_generator.batch_size,
verbose=1
#GPU Test luisss
#max_queue_size=BATCH_SIZE, # maximum size for the generator queue
#workers=12, # maximum number of processes to spin up when using process-based threading
#use_multiprocessing=False
)
results = model.evaluate(validation_generator)
# results = model.evaluate_generator(validation_generator)
predict = model.predict_generator(validation_generator)
print('predict 1')
print(predict)
print(np.argmax(predict, axis=-1))
classes1 = np.argmax(predict, axis=-1)
print('results 1')
print(results)
results = dict(zip(model.metrics_names, results))
y_pred = np.argmax(predict, axis=1)
print(y_pred)
print(valid_data_generator.classes)
write_cm_report(
Y, valid_data_generator.classes, y_pred, 'calfw_model1_' +
get_current_time_str() + 'main1_k_fold_' + str(CLASSES) + '_' +
MODEL_NAME + '_' + str(EPOCHS) + '_' + str(BATCH_SIZE) + '.txt')
cm = confusion_matrix(valid_data_generator.classes, y_pred)
plot_confusion_matrix(cm,
classes=nomes_classes,
CLASSES=CLASSES,
MODEL_NAME=MODEL_NAME,
EPOCHS=EPOCHS,
BATCH_SIZE=BATCH_SIZE,
title='Matriz de Confusão CALFW')
model_vgg = get_model("VGGFace", CLASSES)
sgd = optimizers.SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model_vgg.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['acc'])
model2 = model_vgg
model2.load_weights("ac90_model_VGGFace_5_30.h5")
predict2 = model2.predict(valid_data_generator)
print('predict 2')
print(predict2)
print(np.argmax(predict2, axis=-1))
classes2 = np.argmax(predict2, axis=-1)
results2 = model2.evaluate(valid_data_generator)
print('results 2')
print(results2)
model3 = model
model3.load_weights("model_TFrecordDeepFace_3_60.h5")
predict3 = model3.predict(valid_data_generator)
print('predict 3')
print(predict3)
print(np.argmax(predict3, axis=-1))
classes3 = np.argmax(predict3, axis=-1)
results3 = model3.evaluate(valid_data_generator)
print('results 3')
print(results3)
print("MEAN ====================")
final_mean = (predict + predict2 + predict3) / 3
print(final_mean.shape)
print(final_mean)
print(np.argmax(final_mean, axis=-1))
pred_ensemble_media = np.argmax(final_mean, axis=-1)
write_cm_report(
Y, valid_data_generator.classes, pred_ensemble_media,
'ensemble_media_' + get_current_time_str() + 'main1_k_fold_' +
str(CLASSES) + '_' + MODEL_NAME + '_' + str(EPOCHS) + '_' +
str(BATCH_SIZE) + '.txt')
cm2 = confusion_matrix(valid_data_generator.classes, pred_ensemble_media)
plot_confusion_matrix(cm2,
classes=nomes_classes,
CLASSES=CLASSES,
MODEL_NAME=MODEL_NAME,
EPOCHS=EPOCHS,
BATCH_SIZE=BATCH_SIZE,
title='Matriz de Confusão')
print("Voto marjoritario ====================")
final_pred_mode = np.array([])
#final_pred_mode = []
print(multi_data.shape[0])
print(len(valid_data_generator.classes))
for i in range(0, len(valid_data_generator.classes)):
print(classes1[i])
print(classes2[i])
print(classes3[i])
print(mode([classes1[i], classes2[i], classes3[i]]))
final_pred_mode = np.append(
final_pred_mode,
mode([classes1[i], classes2[i], classes3[i]])[0][0])
#final_pred_mode.append(statistics.mode([predict[i], predict2[i], predict3[i]]))
print('final_pred_mode')
print(len(final_pred_mode))
print(final_pred_mode)
print(final_pred_mode.astype(int))
print(type(final_pred_mode[0]))
print(final_pred_mode[0])
print(np.argmax(final_pred_mode, axis=-1))
pred_ensemble_mode = np.argmax(final_pred_mode, axis=-1)
write_cm_report(
Y, valid_data_generator.classes, final_pred_mode.astype(int),
'ensemble_marjoritario_' + get_current_time_str() + 'main1_k_fold_' +
str(CLASSES) + '_' + MODEL_NAME + '_' + str(EPOCHS) + '_' +
str(BATCH_SIZE) + '.txt')
cm3 = confusion_matrix(valid_data_generator.classes,
final_pred_mode.astype(int))
plot_confusion_matrix(cm3,
classes=nomes_classes,
CLASSES=CLASSES,
MODEL_NAME=MODEL_NAME,
EPOCHS=EPOCHS,
BATCH_SIZE=BATCH_SIZE,
title='Matriz de Confusão')
del model
#del history
tf.keras.backend.clear_session()
gc.collect()
tf.compat.v1.reset_default_graph()
def run_k_fold(multi_data, X, Y, CLASSES, MODEL, BATCH_SIZE, num_folds,
nomes_classes):
VALIDATION_ACCURACY = []
VALIDATION_LOSS = []
HISTORY = []
MODEL_NAME = MODEL
FOLDS = num_folds
EPOCHS = 0
save_dir = os.path.join(os.getcwd(), 'models/')
VERBOSE = 1
#calfw_directory_mover(multi_data,"validation_data_"+MODEL_NAME+str(BATCH_SIZE)+'_'+str(EPOCHS)+'_'+str('fold_var'))
valid_data_generator = dataTrainAugmentation().flow_from_directory(
# training_data,
directory=os.path.join(
os.getcwd(), 'new_calfw/working/validation_data_' + MODEL_NAME +
str(BATCH_SIZE) + '_' + str(EPOCHS) + '_' + str('fold_var') + '/'),
target_size=(250, 250),
# x_col = "image_path", y_col = "name",
batch_size=1,
class_mode="categorical",
#subset="validation",
shuffle=False)
model = get_model(MODEL, CLASSES)
sgd = optimizers.SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['acc'])
model.load_weights("model_TFrecordDeepFace_1_60.h5")
results = model.evaluate(valid_data_generator)
# results = model.evaluate_generator(valid_data_generator)
predict = model.predict_generator(valid_data_generator)
print('predict 1')
print(predict)
print(np.argmax(predict, axis=-1))
classes1 = np.argmax(predict, axis=-1)
print('results 1')
print(results)
results = dict(zip(model.metrics_names, results))
y_pred = np.argmax(predict, axis=1)
print(y_pred)
print(valid_data_generator.classes)
write_cm_report(
Y, valid_data_generator.classes, y_pred, 'calfw_model1_' +
get_current_time_str() + 'main1_k_fold_' + str(CLASSES) + '_' +
MODEL_NAME + '_' + str(EPOCHS) + '_' + str(BATCH_SIZE) + '.txt')
cm = confusion_matrix(valid_data_generator.classes, y_pred)
plot_confusion_matrix(cm,
classes=nomes_classes,
CLASSES=CLASSES,
MODEL_NAME=MODEL_NAME,
EPOCHS=EPOCHS,
BATCH_SIZE=BATCH_SIZE,
title='Matriz de Confusão CALFW')
model_vgg = get_model("VGGFace", CLASSES)
sgd = optimizers.SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model_vgg.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['acc'])
model2 = model_vgg
model2.load_weights("ac90_model_VGGFace_5_30.h5")
predict2 = model2.predict(valid_data_generator)
print('predict 2')
print(predict2)
print(np.argmax(predict2, axis=-1))
classes2 = np.argmax(predict2, axis=-1)
results2 = model2.evaluate(valid_data_generator)
print('results 2')
print(results2)
model3 = model
model3.load_weights("model_TFrecordDeepFace_3_60.h5")
predict3 = model3.predict(valid_data_generator)
print('predict 3')
print(predict3)
print(np.argmax(predict3, axis=-1))
classes3 = np.argmax(predict3, axis=-1)
results3 = model3.evaluate(valid_data_generator)
print('results 3')
print(results3)
print("MEAN ====================")
final_mean = (predict + predict2 + predict3) / 3
print(final_mean.shape)
print(final_mean)
print(np.argmax(final_mean, axis=-1))
pred_ensemble_media = np.argmax(final_mean, axis=-1)
write_cm_report(
Y, valid_data_generator.classes, pred_ensemble_media,
'ensemble_media_' + get_current_time_str() + 'main1_k_fold_' +
str(CLASSES) + '_' + MODEL_NAME + '_' + str(EPOCHS) + '_' +
str(BATCH_SIZE) + '.txt')
cm2 = confusion_matrix(valid_data_generator.classes, pred_ensemble_media)
plot_confusion_matrix(cm2,
classes=nomes_classes,
CLASSES=CLASSES,
MODEL_NAME=MODEL_NAME,
EPOCHS=EPOCHS,
BATCH_SIZE=BATCH_SIZE,
title='Matriz de Confusão')
print("Voto marjoritario ====================")
final_pred_mode = np.array([])
#final_pred_mode = []
print(multi_data.shape[0])
print(len(valid_data_generator.classes))
for i in range(0, len(valid_data_generator.classes)):
print(classes1[i])
print(classes2[i])
print(classes3[i])
print(mode([classes1[i], classes2[i], classes3[i]]))
final_pred_mode = np.append(
final_pred_mode,
mode([classes1[i], classes2[i], classes3[i]])[0][0])
#final_pred_mode.append(statistics.mode([predict[i], predict2[i], predict3[i]]))
print('final_pred_mode')
print(len(final_pred_mode))
print(final_pred_mode)
print(final_pred_mode.astype(int))
print(type(final_pred_mode[0]))
print(final_pred_mode[0])
print(np.argmax(final_pred_mode, axis=-1))
pred_ensemble_mode = np.argmax(final_pred_mode, axis=-1)
write_cm_report(
Y, valid_data_generator.classes, final_pred_mode.astype(int),
'ensemble_marjoritario_' + get_current_time_str() + 'main1_k_fold_' +
str(CLASSES) + '_' + MODEL_NAME + '_' + str(EPOCHS) + '_' +
str(BATCH_SIZE) + '.txt')
cm3 = confusion_matrix(valid_data_generator.classes,
final_pred_mode.astype(int))
plot_confusion_matrix(cm3,
classes=nomes_classes,
CLASSES=CLASSES,
MODEL_NAME=MODEL_NAME,
EPOCHS=EPOCHS,
BATCH_SIZE=BATCH_SIZE,
title='Matriz de Confusão')
del model
#del history
tf.keras.backend.clear_session()
gc.collect()
tf.compat.v1.reset_default_graph()
