def get_confusion_matrix(directory, reference_images, test_images): if not os.path.exists(directory + 'confusion.npy'): correlations, offsets = confusion_matrix.confusion_matrix(reference_images, test_images) np.save(directory + 'confusion', correlations) np.save(directory + 'offsets', offsets) else: correlations = np.load(dir_test + 'confusion.npy') offsets = np.load(dir_test + 'offsets.npy') return correlations, offsets
def test(elm, x, y, type=''): sample_num = x.shape[0] print('predicting!') predict = elm.predict(x) counter = .0 print('-------------------------------------------\n testing') for r, t in zip(predict, y): if np.argmax(r) == np.argmax(t): counter += 1 print(type + ' right rate:', counter / sample_num) con_mat = confusion_matrix(predict, y) print(con_mat) np.save('./con_mat2.npy', con_mat)
def test_adapt_elm(X, Y): result = [] for k in range(K): elm = hpelm.HPELM(inputs=input_size, outputs=8) elm.add_neurons(hidden_num, 'sigm') elm.load('./data/adapt_elm' + str(K) + '/elm_' + str(k)) predict = elm.predict(X) * elm_weight[k] if k == 0: result = predict else: result = result + predict counter = 0.0 eachClassRight = [.0 for i in range(8)] for r, t in zip(result, Y): if np.argmax(r) == np.argmax(t): counter += 1 eachClassRight[np.argmax(r)] += 1 con_mat = confusion_matrix(result, Y) print(con_mat) np.save('./con_mat3.npy', con_mat) right_rate = counter / X.shape[0] print('adapt elm right rate:' + str(right_rate))
def test(test_loader, model_s, model_t, gpu, num_classes): model_s.eval() model_t.eval() sig = nn.Sigmoid() preds = [] labels = [] pickle_file_p = '' pickle_file_l = '' #pickle_file_p = 'preds.pkl' #pickle_file_l = 'labels.pkl' if pickle_file_p and pickle_file_l: pickle_file_p = open(pickle_file_p, 'rb') pickle_file_l = open(pickle_file_l, 'rb') preds = pickle.load(pickle_file_p) labels = pickle.load(pickle_file_l) else: example_count = 0 test_len = len(test_loader) for spatial, temporal, label in test_loader: example_count += 1 print(f'Clip #{example_count} / {test_len}') if gpu: spatial = spatial.cuda() temporal = temporal.cuda() with torch.no_grad(): s = model_s(spatial.squeeze().float()) t = model_t(temporal.squeeze().float()) s_num = s.shape[0] t_num = t.shape[0] s = s.sum(axis=0) t = t.sum(axis=0) s = s.div(s_num) t = t.div(t_num) pred = torch.add(s, t) pred = pred.div(2) pred = sig(pred) if gpu == True: pred = pred.cpu() label = label.squeeze() labels.append(label.numpy()) preds.append(pred.numpy()) preds = np.array(preds).astype(np.float64) labels = np.array(labels).astype(np.int32) pickle_file_p = open('preds.pkl', 'wb') pickle.dump(preds, pickle_file_p) pickle_file_p.close() pickle_file_l = open('labels.pkl', 'wb') pickle.dump(labels, pickle_file_l) pickle_file_l.close() print(preds.shape) print(labels.shape) c = confusion_matrix(num_classes) c.mAP(labels, preds)
jpg = os.path.join(image_path, os.path.basename(os.path.splitext(xml)[0]) + ".jpg") shutil.copy(jpg, classify_xml_path) # write auto_labeling info into csv ############################################################################### print(colorama.Fore.GREEN + "[INFO] write auto_labeling info into csv" + colorama.Fore.WHITE) csv_file_s = os.path.join(output_tif_608s, tif_name + "_s.csv") dict_to_csv(dict_pic_info, csv_file_s) csv_file_c = os.path.join(output_tif_608s, tif_name + "_c.csv") predictions_to_csv(dict_pic_info_all, classes_list, classes_all, csv_file_c) # generate confusion matrix ####################################################################################### print(colorama.Fore.GREEN + "[INFO] generate confusion matrix" + colorama.Fore.WHITE) matrix = confusion_matrix(classes_all, cell_numpy_index, predictions) xlsx = os.path.join(output_tif_608s, tif_name + ".xlsx") generate_xlsx(classes_all, matrix, xlsx) # generate asap_xml from labelimg_xmls print(colorama.Fore.GREEN + "[INFO] generate asap xml from labelimg xmls" + colorama.Fore.WHITE) xml_asap_segment = os.path.join(output_tif_608s, tif_name + "_segment.xml") gen_asap_xml(xml_asap_segment, segment_xml_path) xml_asap_classify = os.path.join(output_tif_608s, tif_name + "_classify.xml") gen_asap_xml(xml_asap_classify, classify_xml_path) # move current directories upwards ################################################################################ print(colorama.Fore.GREEN + "[INFO] move current directories upwards" + colorama.Fore.WHITE) save_path_i = os.path.join(save_path, tif_name)
def main(): n=int(input("Enter number of folds k : ")) confusion_matrix(n)
def plot_completeness(variable, bins, actual, predicted, num_bins, path_prefix, scale=False): accs = [] pres = [] recs = [] F1s = [] for l in range(num_bins): cm, acc, pre, rec, F1 = cf.confusion_matrix(actual[l], predicted[l]) accs.append(acc) pres.append(pre) recs.append(rec) F1s.append(F1) # plot accuracy plt.figure() plt.xlabel(variable) plt.ylabel('Accuracy') if scale: plt.plot([b for b in bins], accs, 'ko', rasterized=True) else: plt.plot([str(round(b, 2)) for b in bins], accs, 'ko', rasterized=True) filename = '{}_accuracy.pdf'.format(path_prefix, variable) plt.tight_layout() plt.savefig(filename) plt.close() #plot precision plt.figure() plt.xlabel(variable) plt.ylabel('Precision') if scale: plt.plot([b for b in bins], pres, 'ko', rasterized=True) else: plt.plot([str(round(b, 2)) for b in bins], pres, 'ko', rasterized=True) filename = '{}_precision.pdf'.format(path_prefix, variable) plt.tight_layout() plt.savefig(filename) plt.close() # plot recall plt.figure() plt.xlabel(variable) plt.ylabel('Recall') if scale: plt.plot([b for b in bins], recs, 'ko', rasterized=True) else: plt.plot([str(round(b, 2)) for b in bins], recs, 'ko', rasterized=True) filename = '{}_recall.pdf'.format(path_prefix, variable) plt.tight_layout() plt.savefig(filename) plt.close() # plot F1 plt.figure() plt.xlabel(variable) plt.ylabel('F1') if scale: plt.plot([b for b in bins], F1s, 'ko', rasterized=True) else: plt.plot([str(round(b, 2)) for b in bins], F1s, 'ko', rasterized=True) filename = '{}_F1.pdf'.format(path_prefix, variable) plt.tight_layout() plt.savefig(filename) plt.close()
def main(): train, test = load_data() prior = 1 / 3 # Num Classes c = train.shape[0] # Num Dimensions d = train[0].shape[1] means = np.empty((c, d)) covs = np.empty(((c, d, d))) ###### Part A ####### for i in range(c): means[i] = np.mean(train[i], axis=0) covs[i] = np.cov(train[i], rowvar=0) predicted = np.array([], dtype=int) flat_test, labels_test = flatten_data(test, c) disc_values = np.zeros((100, 3)) ####### Part B ###### for i, point in enumerate(flat_test): for j in range(c): m = discriminant(point, means[j], covs[j], d, prior) disc_values[i, j] = m predicted = np.argmax(disc_values, axis=1) ####### Part C ######### cm, acc = confusion_matrix(labels_test, predicted, c) print("Part C Covariance Matrix") print(cm) print(f"Error = {1 - acc}") ####### Part D ########## flat_train, labels_train = flatten_data(train, c) plot_data(flat_train.T[0], flat_train.T[1], labels_train, c) plot_data(flat_test.T[0], flat_test.T[1], labels_test, c) r_train, theta_train = cart2pol(flat_train) r_test, theta_test = cart2pol(flat_test) plot_data(r_train, theta_train, labels_train, c) plot_data(r_test, theta_test, labels_test, c) means = np.empty(c) covs = np.empty(c) posterior = np.zeros(c) disc_values = np.empty((r_test.shape[0], c)) for i in range(c): means[i], covs[i] = mu_estimate(r_train[labels_train == i], 0, 100, .25) for i, pt in enumerate(r_test): for j in range(c): disc_values[i, j] = discriminant(pt, means[j], covs[j], d, prior) predicted = np.argmax(disc_values, axis=1) cm, acc = confusion_matrix(labels_test, predicted, c) print("Part D Covariance Matrix") print(cm) print(f"Error = {1 - acc}")
print() if case == '1': Sigma = cases.case_1(covariance) elif case == '2': Sigma = cases.case_2(covariance) elif case == '3': Sigma = cases.case_3(covariance) elif case == '4': Sigma = cases.case_4(covariance) else: print("check the case & case number") # Generates all possible combination of 2 pairs = list(combinations([0, 1, 2], 2)) # Decision region plot for every pair of classes together with the training data superposed for combo in pairs: class_region.class_region(combo, train, mean, Sigma, probability) # Decision region plot for all the classes al_combo = [0, 1, 2] class_region.class_region(al_combo, train, mean, Sigma, probability) # Confusion matrix confusion_matrix.confusion_matrix(mean, Sigma, probability, test)
def nn_tests(): with tensorflow.device('/cpu:0'): dropout_arr = [0.1, 0.2, 0.3, 0.4, 0.5] for dropout in dropout_arr: #filters_arr = [4,8,16,32,64] #for filters in filters_arr: #print("\nNumber of Filters", filters) #print("Dropout:", dropout) starttime = datetime.now() # Load mnist dataset print("\nLoading MNIST dataset.") (x_train, y_train), (x_test, y_test) = mnist.load_data() # Compute the number of labels num_labels = len(np.unique(y_train)) # Convert to one-hot vectors y_train = to_categorical(y_train, num_labels) y_test = to_categorical(y_test, num_labels) # Get the image dimensions (assumed square) image_size = x_train.shape[1] input_size = image_size * image_size # Resize and normalize x_train = np.reshape(x_train, [-1, image_size, image_size, 1]) x_test = np.reshape(x_test, [-1, image_size, image_size, 1]) x_train = x_train.astype('float32') / 255 x_test = x_test.astype('float32') / 255 # Network parameters # image is processed as is (square grayscale) input_shape = (image_size, image_size, 1) batch_size = 128 kernel_size = 3 pool_size = 2 filters = 16 #dropout = 0.2 # model is a stack of CNN-ReLU-MaxPooling model = Sequential() model.add( Conv2D(filters=filters, kernel_size=kernel_size, activation='relu', input_shape=input_shape)) model.add(MaxPooling2D(pool_size)) model.add( Conv2D(filters=filters, kernel_size=kernel_size, activation='relu')) model.add(MaxPooling2D(pool_size)) model.add( Conv2D(filters=filters, kernel_size=kernel_size, activation='relu')) model.add(Flatten()) # dropout added as regularizer model.add(Dropout(dropout)) # output layer is 10-dim one-hot vector model.add(Dense(num_labels)) model.add(Activation('softmax')) # Print and plot model model.summary() plot_model(model, to_file='mp1_nn2.png', show_shapes=True) # loss function for one-hot vector # use of adam optimizer # accuracy is good metric for classification tasks model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # train the network model.fit(x_train, y_train, epochs=2, batch_size=batch_size) # Compute predictions (test mode) for training data y_pred = model.predict(x_train, batch_size=batch_size, verbose=0) # Convert one-hot tensors back to class labels (and make them numpy arrays) y_train_true_class = K.argmax(y_train).numpy() y_train_pred_class = K.argmax(y_pred).numpy() # Students, insert code here to create CM and print confusion matrix and stats cm_train, cm_train_acc = confusion_matrix(y_train_true_class, y_train_pred_class) print_confusion_matrix_stats(cm_train, 'Train') # Validate the model on test dataset to determine generalization y_pred = model.predict(x_test, batch_size=batch_size, verbose=0) # Convert one-hot tensors back to class labels (and make them numpy arrays) y_test_true_class = K.argmax(y_test).numpy() y_test_pred_class = K.argmax(y_pred).numpy() # Students, insert code here to create CM and print confusion matrix and stats cm_test, cm_test_acc = confusion_matrix(y_test_true_class, y_test_pred_class) print_confusion_matrix_stats(cm_test, 'Test') endtime = datetime.now() print("Elapsed time:", endtime - starttime) return
######################PLACEHOLDER 3 #end ######################### print("trainX.shape", trainX.shape, "\ntrainY.shape", trainY.shape, "\ntestX.shape", testX.shape, "\ntestY.shape", testY.shape, "\nyHat.shape", yHat.shape) # step 4: evaluation # compare predictions yHat and and true labels testy to calculate average error and standard deviation # sklearn way testYDiff = np.abs(yHat - testY) avgErr = np.mean(testYDiff) stdErr = np.std(testYDiff) (accuracy, positive_precision, negative_precision, positive_recall, negative_recall, conf_matrix) = confusion_matrix(yHat, testY) print('SK learn accuracy: {}'.format(accuracy)) print('SK learn true-positive precision: {}'.format(positive_precision)) print('SK learn true-negative precision: {}'.format(negative_precision)) print('SK learn true-positive recall: {}'.format(positive_recall)) print('SK learn true-negative recall: {}'.format(negative_recall)) print('SK learn confusion matrix:\n {}'.format(conf_matrix)) print('sklearn average error: {} ({})'.format(avgErr, stdErr)) print('score Sklearn: ', logReg.score(testX, testY), "\n") # GD way testYDiff2 = np.abs(prediction_Y - testY) avgErr2 = np.mean(testYDiff2) stdErr2 = np.std(testYDiff2) (GDaccuracy, GDpositive_precision, GDnegative_precision, GDpositive_recall, GDnegative_recall, GDconf_matrix) = confusion_matrix(prediction_Y, testY)
def change_hidden_units(): with tensorflow.device('/cpu:0'): for hidden_units in hidden_units_arr: print("\nNumber of Hidden Units", hidden_units) starttime = datetime.now() # Load mnist dataset print("\nLoading MNIST dataset.") (x_train, y_train), (x_test, y_test) = mnist.load_data() # Compute the number of labels num_labels = len(np.unique(y_train)) # Convert to one-hot vectors y_train = to_categorical(y_train) y_test = to_categorical(y_test) # Get the image dimensions (assumed square) image_size = x_train.shape[1] input_size = image_size * image_size # Resize and normalize x_train = np.reshape(x_train, [-1, input_size]) x_train = x_train.astype('float32') / 255 x_test = np.reshape(x_test, [-1, input_size]) x_test = x_test.astype('float32') / 255 # Setup the network parameters batch_size = 128 hidden_units = 256 dropout = 0.45 # model is a 3-layer MLP with ReLU and dropout after each layer model = Sequential() model.add(Dense(hidden_units, input_dim=input_size)) model.add(Activation('relu')) model.add(Dropout(dropout)) model.add(Dense(hidden_units)) model.add(Activation('relu')) model.add(Dropout(dropout)) model.add(Dense(num_labels)) # this is the output for one-hot vector model.add(Activation('softmax')) # Print model summary and save the network image to the file specified model.summary() plot_model(model, to_file='mp1_nn1.png', show_shapes=True) # loss function for one-hot vector # use of adam optimizer # accuracy is good metric for classification tasks model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy']) # Train the network model.fit(x_train, y_train, epochs=20, batch_size=batch_size) # Compute predictions (test mode) for training data y_pred = model.predict(x_train, batch_size=batch_size, verbose=0) # Convert one-hot tensors back to class labels (and make them numpy arrays) y_train_true_class = K.argmax(y_train).numpy() y_train_pred_class = K.argmax(y_pred).numpy() # Students, insert code here to create CM and print confusion matrix and stats cm_train, cm_train_acc = confusion_matrix(y_train_true_class, y_train_pred_class) print_confusion_matrix_stats(cm_train, 'Train') # Validate the model on test dataset to determine generalization y_pred = model.predict(x_test, batch_size=batch_size, verbose=0) # Convert one-hot tensors back to class labels (and make them numpy arrays) y_test_true_class = K.argmax(y_test).numpy() y_test_pred_class = K.argmax(y_pred).numpy() # Students, insert code here to create CM and print confusion matrix and stats cm_test, cm_test_acc = confusion_matrix(y_test_true_class, y_test_pred_class) print_confusion_matrix_stats(cm_test, 'Test') endtime = datetime.now() print("Elapsed time:", endtime - starttime) return
def main(): parser = argparse.ArgumentParser(description="Testing the HORCNN Model!") parser.add_argument("--bbmatfile", help="Path to the HICO-DET bounding box matfile", default='../Dataset/images/anno_bbox.mat', nargs='?') #parser.add_argument("train_path", help="Path to the file containing training images", default='../Dataset/images/train2015', nargs='?') parser.add_argument("--test_path", help="Path to the file containing Testing images", default='../Dataset/images/test2015', nargs='?') #parser.add_argument("det_prop_file", help="Path of the object detection proposals pickle file. This file should contian detected objects from the images. If none is specified this program will run the FastRCNN Object detector over the training images to create the file", # default='../Dataset/images/pkl_files/fullTrain.pkl', nargs='?') parser.add_argument( "--det_prop_file", help= "Path of the object detection proposals pickle file. This file should contian detected objects from the images. If none is specified this program will run the FastRCNN Object detector over the training images to create the file", default='../Dataset/images/pkl_files/full_test2015.pkl', nargs='?') parser.add_argument("--batch_size", help="batch_size for training", type=int, default=4, nargs='?') parser.add_argument("--gpu", help="Runninng on GPU?", type=bool, default=True, nargs='?') parser.add_argument("--model_path", help="Model Path To Evaluate", default='./saved_models/Final_Trained', nargs='?') parser.add_argument("--threshold", help="prediction threshold", default=0.001, nargs='?', type=float) args = parser.parse_args() bbox_mat = loadmat('../Dataset/images/anno_bbox.mat') test_data = HICODET_test(args.test_path, args.bbmatfile, props_file=args.det_prop_file, proposal_count=10) print('Length of Testing dataset: ' + str(len(test_data))) print('Num props ' + str(test_data.proposal_count)) test_data_loader = torch.utils.data.DataLoader(dataset=test_data, batch_size=4, shuffle=False) print('------------DATASET SETUP COMPLETE-------------') print('\n') print('------------Setting Up Models------------------') human_model = models.alexnet(pretrained=True) human_model.classifier[6] = nn.Linear(4096, 600) human_model = human_model.eval() object_model = models.alexnet(pretrained=True) object_model.classifier[6] = nn.Linear(4096, 600) object_model = object_model.eval() pairwise_model = HO_RCNN_Pair() pairwise_model = pairwise_model.eval() human_model.load_state_dict( torch.load(os.path.join(args.model_path, 'human.pth'))) object_model.load_state_dict( torch.load(os.path.join(args.model_path, 'object.pth'))) pairwise_model.load_state_dict( torch.load(os.path.join(args.model_path, 'pairwise.pth'))) if args.gpu == True: human_model.cuda() object_model.cuda() pairwise_model.cuda() criterion = nn.BCEWithLogitsLoss() print('--------------MODEL SETUP COMPLETE-------------') print('---------------TESTING MODEL-------------------') predictions = [] p_h = [] p_o = [] p_p = [] p_ho = [] p_hp = [] outs = [] batch_count = 0 losses = [] for human_crop, object_crop, int_pattern, outputs in test_data_loader: batch_count += 1 human_crop = torch.stack([j for i in human_crop for j in i]) object_crop = torch.stack([j for i in object_crop for j in i]) int_pattern = torch.stack([j for i in int_pattern for j in i]) outputs = torch.stack([j for i in outputs for j in i]) human_crop = human_crop.float().cuda() object_crop = object_crop.float().cuda() int_pattern = int_pattern.float().cuda() #human_crop = human_crop.float().cuda() #object_crop = object_crop.float().cuda() #int_pattern = int_pattern.float().cuda() with torch.no_grad(): human_pred = human_model(human_crop) object_pred = object_model(object_crop) pairwise_pred = pairwise_model(int_pattern) total_pred = torch.add(torch.add(human_pred, object_pred), pairwise_pred) #total_pred_cpu = total_pred.cpu() predictions.append(total_pred) p_h.append(human_pred) p_o.append(object_pred) p_p.append(pairwise_pred) p_ho.append(torch.add(human_pred, object_pred)) p_hp.append(torch.add(human_pred, pairwise_pred)) #predictions.append(total_pred) #outs.append(outputs.numpy().astype(int)) outs.append(outputs.cuda()) #outs.append(outputs.cuda()) #batch_loss = criterion(total_pred, outputs.unsqueeze(0).float().cuda()) #batch_loss = criterion(total_pred, outputs.float().cuda()) #losses.append(batch_loss.item()) if batch_count % 100 == 0: #print('EVAL : Batch #' + str(batch_count) + ': Loss = ' + str(batch_loss.item())) print('EVAL : Batch #' + str(batch_count)) #final_loss = sum(losses) / len(test_data) #print('<-------------------Final Validation Loss = '+str(final_loss) + '-------------------->') #outs = np.asarray(outs) sig = nn.Sigmoid() import sklearn.metrics as skm m_preds = [] m_labels = [] m_h = [] m_o = [] m_p = [] m_ho = [] m_hp = [] for i in range( len(predictions)): #<---- NUmber of batches passed to the network batch_pred = predictions[i] batch_labels = outs[i] b_h = p_h[i] b_o = p_o[i] b_p = p_p[i] b_ho = p_ho[i] b_hp = p_hp[i] for j in range(len(batch_pred)): #<------ Images per batch pred = batch_pred[j] pred = sig(pred) #pred = (pred>args.threshold).int() pred = pred.cpu().numpy() #------------------------- pr_h = b_h[j] pr_h = sig(pr_h) pr_h = pr_h.cpu().numpy() #------------------------- pr_o = b_o[j] pr_o = sig(pr_o) pr_o = pr_o.cpu().numpy() #------------------------- pr_p = b_p[j] pr_p = sig(pr_p) pr_p = pr_p.cpu().numpy() #------------------------- pr_ho = b_ho[j] pr_ho = sig(pr_ho) pr_ho = pr_ho.cpu().numpy() #------------------------- pr_hp = b_hp[j] pr_hp = sig(pr_hp) pr_hp = pr_hp.cpu().numpy() labels = batch_labels[j].cpu().numpy().astype(int) m_preds.append(pred) m_labels.append(labels) m_h.append(pr_h) m_o.append(pr_o) m_p.append(pr_p) m_ho.append(pr_ho) m_hp.append(pr_hp) # get rare categories: rare = [] with open('rare_list.txt', 'r') as f: for line in f: idx = line[:-1] rare.append(int(idx)) #rare = np.asarray(rare, dtype=np.int32) #Missing classes: l = np.zeros(600) p = np.random.uniform(low=0., high=0.6, size=(600)) for i in range(600): p[i] = 0.8 l[i] = 1 m_preds.append(p) m_labels.append(l) m_h.append(p) m_o.append(p) m_p.append(p) m_ho.append(p) m_hp.append(p) m_preds = np.stack(m_preds, axis=0).astype(np.float64) m_labels = np.stack(m_labels, axis=0).astype(np.int32) m_h = np.stack(m_h, axis=0).astype(np.float64) m_o = np.stack(m_o, axis=0).astype(np.float64) m_p = np.stack(m_p, axis=0).astype(np.float64) m_ho = np.stack(m_ho, axis=0).astype(np.float64) m_hp = np.stack(m_hp, axis=0).astype(np.float64) print("TOTAL PREDS:") c1 = confusion_matrix(600) c1.mAP(m_labels, m_preds, rare) del c1 print("HUMAN") c2 = confusion_matrix(600) c2.mAP(m_labels, m_h, rare) del c2 print("OBJECT") c3 = confusion_matrix(600) c3.mAP(m_labels, m_o, rare) del c3 print("PAIR") c4 = confusion_matrix(600) c4.mAP(m_labels, m_p, rare) del c4 print("HUMAN_OBJECT") c5 = confusion_matrix(600) c5.mAP(m_labels, m_ho, rare) del c5 print("HUMAN_PAIR") c6 = confusion_matrix(600) c6.mAP(m_labels, m_hp, rare)
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])): plt.text(x=j * 0.5 + 0.25 + k, y=i * 0.5 + 0.25, s=cm[i, j], horizontalalignment="center", verticalalignment="center", color="white" if cm[i, j] > thresh else "black") k = k * -1 plt.tight_layout() plt.ylabel('True label') plt.xlabel( 'Predicted label\n\n accuracy={:0.4f}\n Precision={:0.4f}\n Recall={:0.4f}\n F1={:0.4f} ' .format(Accuracy, Precision, Recall, f1)) plt.show() training_images = np.load('Features_data.npy') gender_labels = np.load('Gender_labels.npy') tr_X, te_X, tr_Y, te_Y = data_preprocessing(training_images, gender_labels) "param = hypeparameters_determination(tr_X, tr_Y)" "validation_curve_for_different_parameters_and_figures(tr_X, tr_Y)" "plot_learning_curve(tr_X, tr_Y)" pred, model = img_SVM(tr_X, tr_Y, te_X, te_Y) plot_confusion_matrix(confusion_matrix.confusion_matrix(te_Y, pred, [1, -1]), target_names=['male', 'female'], title="Confusion Matrix") img_SVM(tr_X, tr_Y, te_X, te_Y) "img_new_SVM(tr_X, tr_Y, te_X, te_Y)"
label = net.blobs['label'].data score = np.array([np.where(i==max(i))[0][0] for i in net.blobs['fc8'].data]).astype(np.float32) score = np.zeros((batch,2), dtype=np.float32) for item in range(2): score[:,item] = np.array([np.where(i==max(i))[0][0] for i in net.blobs['fc8_'+str(item+1)].data]) # score = np.array([np.where(i==max(i))[0][0] for i in net.blobs['fc8'].data]) label = net.blobs['label'].data[:,:,0,0] score = ((net.blobs['fc8'].data>0.5)*1.0).astype(np.float32) for n_img in range(batch): groundtruth.append(np.where(label[n_img]==1.0)[0].tolist()) prediction.append(np.where(score[n_img]==1.0)[0].tolist()) cm = confusion_matrix(prediction, groundtruth) """ print "label:\n%s"%(str(label[:20])) print "Prediction:\n%s"%(str((pred[:20]>0)*1.0)) #print "Prediction:\n%s"%(str(pred)) mean_value = [104, 116, 122]#Imagenet mean value for channel in range(img.shape[3]): img[:,:,:,channel] += mean_value[channel] for n in range(img.shape[0]): imshow(img[n],0) time.sleep(0.3) """