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()