def main(): # Parse arguments args = parse_args() # Load tower model with CustomObjectScope({'_euclidean_distance': nn_model.Model._euclidean_distance}): model = load_model(args.model_path) model.compile(optimizer='adam', loss='mean_squared_error') # Model was previously not compiled X_shape, y_shape = utils.get_shapes(args.triplets_path, "train_anchors") # Build model to compute [A, P, N] => [abs(emb(A) - emb(P)), abs(emb(A) - emb(N))] pair_distance_model = build_pair_distance_model(model, X_shape[1:]) pair_distance_model.compile(optimizer="adam", loss="mean_squared_error") # Need to compile in order to predict # Load test data _, y_test_shape = utils.get_shapes(args.triplets_path, "test") n_users = y_test_shape[1] X_test_separated = [] for j in range(n_users): X_test_j = utils.load_X(args.triplets_path, "test_" + str(j)) X_test_separated.append(X_test_j) # If no svm model supplied, and no sweep: # Train a new model if args.load_model_path is None: # Load training triplets and validation triplets X_train_anchors, _ = utils.load_examples(args.triplets_path, "train_anchors") X_train_positives, _ = utils.load_examples(args.triplets_path, "train_positives") X_train_negatives, _ = utils.load_examples(args.triplets_path, "train_negatives") # Get abs(distance) of embeddings X_train_ap, X_train_an, X_train_pn = pair_distance_model.predict([X_train_anchors, X_train_positives, X_train_negatives]) # Stack positive and negative examples X_train = np.vstack((X_train_ap, X_train_an, X_train_pn)) y_train = np.hstack((np.ones(X_train_ap.shape[0], ), np.zeros(X_train_an.shape[0] + X_train_pn.shape[0],))) # Sign of distances should not matter -> Train on both X_train = np.vstack((X_train, -X_train)) y_train = np.hstack((y_train, y_train)) # Shuffle the data X_train, y_train = shuffle(X_train, y_train) # Train SVM svm_model = svm.SVC(C=C, gamma=GAMMA, kernel=KERNEL, class_weight=CLASS_WEIGHTS, verbose=True, probability=args.sweep) svm_model.fit(X_train[:20000, :], y_train[:20000]) else: # if svm model supplied with open(args.load_model_path, "rb") as svm_file: svm_model = pickle.load(svm_file) random.seed(1) accuracy, FAR, FRR = predict_and_evaluate(pair_distance_model, svm_model, X_test_separated, args.ensemble_size, args.ensemble_type, threshold=0.5, probability=False) print("\n---- Test Results ----") print("Accuracy = {}".format(accuracy)) print("FAR = {}".format(FAR)) print("FRR = {}".format(FRR)) if args.sweep: # Sweep the threshold FARs, FRRs = [], [] min_diff = float("inf") FAR_EER, FRR_EER = 1, 1 accuracy_EER = 0 threshold_EER = None for threshold in np.arange(0, 1, 0.01): # Predict and evaluate accuracy, FAR, FRR = predict_and_evaluate(pair_distance_model, svm_model, X_test_separated, args.ensemble_size, args.ensemble_type, threshold=threshold, probability=True) # Store results FARs.append(FAR) FRRs.append(FRR) if np.abs(FAR - FRR) < min_diff: FAR_EER = FAR FRR_EER = FRR accuracy_EER = accuracy threshold_EER = threshold min_diff = np.abs(FAR - FRR) # Report EER and corresponding accuracy print("\n ---- Test Results: EER ----") print("Accuracy = {}".format(accuracy_EER)) print("FAR = {}".format(FAR_EER)) print("FRR = {}".format(FRR_EER)) print("Threshold EER = {}".format(threshold_EER)) # Plot FRR vs FAR plt.figure() plt.scatter(FARs, FRRs) plt.xlabel("FAR") plt.ylabel("FRR") plt.savefig("FRR_FAR.pdf") else: # no sweep random.seed(1) accuracy, FAR, FRR = predict_and_evaluate(pair_distance_model, svm_model, X_test_separated, args.ensemble_size, args.ensemble_type, threshold=0.5, probability=False) print("\n---- Test Results ----") print("Accuracy = {}".format(accuracy)) print("FAR = {}".format(FAR)) print("FRR = {}".format(FRR)) # Save svm model if args.save_model_path is not None: with open(args.save_model_path + "svm_model.pkl", "wb") as svm_file: pickle.dump(svm_model, svm_file)
def main(): # Parse arguments parser = argparse.ArgumentParser() parser.add_argument(dest="data_path", metavar="DATA_PATH", help="Path to read examples from.") parser.add_argument("-sW", "--save_weights_path", metavar="SAVE_WEIGHTS_PATH", default=None, help="Path to save trained weights to. If no path is specified checkpoints are not saved.") parser.add_argument("-sM", "--save_model_path", metavar="SAVE_MODEL_PATH", default=None, help="Path to save trained model to.") parser.add_argument("-l", "--load_path", metavar="LOAD_PATH", default=None, help="Path to load trained model from. If no path is specified model is trained from scratch.") parser.add_argument("-m", "--metrics-path", metavar="METRICS_PATH", default=None, help="Path to save additional performance metrics to (for debugging purposes).") parser.add_argument("-b", "--read_batches", metavar="READ_BATCHES", default=False, help="If true, data is read incrementally in batches during training.") parser.add_argument("--PCA", metavar="PCA", default=False, help="If true, a PCA plot is saved.") parser.add_argument("--TSNE", metavar="TSNE", default=False, help="If true, a TSNE plot is saved.") parser.add_argument("--output_loss_threshold", metavar="OUTPUT_LOSS_THRESHOLD", default=None, help="Value between 0.0-1.0. Main function will return loss value of triplet at set percentage.") args = parser.parse_args() parse_args(args) X_shape, y_shape = utils.get_shapes(args.data_path, "train_anchors") # Build model input_shape = X_shape[1:] tower_model = build_tower_cnn_model(input_shape) # single input model triplet_model = build_triplet_model(input_shape, tower_model) # siamese model if args.load_path is not None: triplet_model.load_weights(args.load_path) # Setup callbacks for early stopping and model saving callback_list = setup_callbacks(args.save_weights_path) # Compile model adam = Adam(lr=LEARNING_RATE) triplet_model.compile(optimizer=adam, loss='mean_squared_error') if not args.read_batches: # Read all data at once # Load training triplets and validation triplets X_train_anchors, y_train_anchors = utils.load_examples(args.data_path, "train_anchors") X_train_positives, _ = utils.load_examples(args.data_path, "train_positives") X_train_negatives, _ = utils.load_examples(args.data_path, "train_negatives") X_valid_anchors, y_valid_anchors = utils.load_examples(args.data_path, "valid_anchors") X_valid_positives, _ = utils.load_examples(args.data_path, "valid_positives") X_valid_negatives, _ = utils.load_examples(args.data_path, "valid_negatives") # Create dummy y = 0 (since output of siamese model is triplet loss) y_train_dummy = np.zeros((X_shape[0],)) y_valid_dummy = np.zeros((X_valid_anchors.shape[0],)) # Train the model triplet_model.fit([X_train_anchors, X_train_positives, X_train_negatives], y_train_dummy, validation_data=([X_valid_anchors, X_valid_positives, X_valid_negatives], y_valid_dummy), epochs=EPOCHS, batch_size=BATCH_SIZE, callbacks=callback_list) global training_complete training_complete = True else: # Read data in batches training_batch_generator = utils.DataGenerator(args.data_path, "train", batch_size=1000) validation_batch_generator = utils.DataGenerator(args.data_path, "valid", batch_size=1000) triplet_model.fit_generator(generator=training_batch_generator, validation_data=validation_batch_generator, callbacks=callback_list, epochs=EPOCHS) # Save weights if args.save_weights_path is not None: triplet_model.save_weights(args.save_weights_path + "final_weights.hdf5") # Save model if args.save_model_path is not None: tower_model.save(args.save_model_path + "tower_model.hdf5") triplet_model.save(args.save_model_path + "triplet_model.hdf5") # Plot PCA/TSNE # For now, read all the valid anchors to do PCA # TODO: add function in util that reads a specified number of random samples from a dataset. if args.PCA is not False or args.TSNE is not False: X_valid_anchors, y_valid_anchors = utils.load_examples(args.data_path, "valid_anchors") X, Y = utils.shuffle_data(X_valid_anchors[:, :, :], y_valid_anchors[:, :], one_hot_labels=True) X = X[:5000, :, :] Y = Y[:5000, :] X = tower_model.predict(X) if args.PCA: utils.plot_with_PCA(X, Y) if args.TSNE: utils.plot_with_TSNE(X, Y) # Calculate loss value of triplet at a certain threshold if args.output_loss_threshold is not None: if not args.read_batches: # Read all data at once # Load training triplets and validation triplets X_train_anchors, _ = utils.load_examples(args.data_path, "train_anchors") X_train_positives, _ = utils.load_examples(args.data_path, "train_positives") X_train_negatives, _ = utils.load_examples(args.data_path, "train_negatives") # Get abs(distance) of embeddings X_train = triplet_model.predict([X_train_anchors, X_train_positives, X_train_negatives]) else: # Read data in batches training_batch_generator = utils.DataGenerator(args.data_path, "train", batch_size=100, stop_after_batch=10) # Get abs(distance) of embeddings (one batch at a time) X_train = triplet_model.predict_generator(generator=training_batch_generator, verbose=1) X_train = np.sort(X_train, axis=None) print(X_train[int(float(args.output_loss_threshold) * X_train.shape[0])])
def main(): # Parse arguments parser = argparse.ArgumentParser() parser.add_argument(dest="data_path", metavar="DATA_PATH", help="Path to read examples from.") parser.add_argument( "-sW", "--save_weights_path", metavar="SAVE_WEIGHTS_PATH", default=None, help= "Path to save trained weights to. If no path is specified checkpoints are not saved." ) parser.add_argument("-sM", "--save_model_path", metavar="SAVE_MODEL_PATH", default=None, help="Path to save trained model to.") parser.add_argument( "-l", "--load_path", metavar="LOAD_PATH", default=None, help= "Path to load trained model from. If no path is specified model is trained from scratch." ) args = parser.parse_args() parse_args(args) X_shape, y_shape = utils.get_shapes(args.data_path, "train") # Build model input_shape = X_shape[1:] model = nn_model.Model(input_shape, EMB_SIZE, ALPHA, REG_WEIGHT) if args.load_path is not None: model.triplet_model.load_weights(args.load_path) # Setup callbacks for early stopping and model saving callback_list = setup_callbacks(args.save_weights_path) # Compile model adam = Adam(lr=LEARNING_RATE) model.triplet_model.compile(optimizer=adam, loss=custom_loss) model.tower.predict(np.zeros( (1, ) + input_shape)) # predict on some random data to activate predict() # Initializate online triplet generators training_batch_generator = nn_tripletGeneration.OnlineTripletGenerator( args.data_path, "train", model.tower, batch_size=BATCH_SIZE, alpha=ALPHA) validation_batch_generator = utils.DataGenerator(args.data_path, "valid", batch_size=BATCH_SIZE) model.triplet_model.fit_generator( generator=training_batch_generator, validation_data=validation_batch_generator, callbacks=callback_list, epochs=EPOCHS) # Save weights if args.save_weights_path is not None: model.triplet_model.save_weights(args.save_weights_path + "final_weights.hdf5") # Save model if args.save_model_path is not None: model.tower.save(args.save_model_path + "tower_model.hdf5")
def main(): # Parse arguments parser = argparse.ArgumentParser() parser.add_argument(dest="data_path", metavar="DATA_PATH", help="Path to read examples from.") parser.add_argument( "-sW", "--save_weights_path", metavar="SAVE_WEIGHTS_PATH", default=None, help= "Path to save trained weights to. If no path is specified checkpoints are not saved." ) parser.add_argument("-sM", "--save_model_path", metavar="SAVE_MODEL_PATH", default=None, help="Path to save trained model to.") parser.add_argument( "-l", "--load_path", metavar="LOAD_PATH", default=None, help= "Path to load trained model from. If no path is specified model is trained from scratch." ) parser.add_argument("--PCA", metavar="PCA", default=False, help="If true, a PCA plot is saved.") parser.add_argument("--TSNE", metavar="TSNE", default=False, help="If true, a TSNE plot is saved.") args = parser.parse_args() parse_args(args) X_shape, y_shape = utils.get_shapes(args.data_path, "train") # Build model input_shape = X_shape[1:] tower_model = build_tower_cnn_model(input_shape) # single input model triplet_model = build_triplet_model(input_shape, tower_model) # siamese model if args.load_path is not None: triplet_model.load_weights(args.load_path) # Setup callbacks for early stopping and model saving callback_list = setup_callbacks(args.save_weights_path) # Compile model adam = Adam(lr=LEARNING_RATE) triplet_model.compile(optimizer=adam, loss=custom_loss) tower_model.predict(np.zeros( (1, ) + input_shape)) # predict on some random data to activate predict() # Initializate online triplet generators training_batch_generator = OnlineTripletGenerator(args.data_path, "train", tower_model, batch_size=BATCH_SIZE, triplet_mode="batch_all") validation_batch_generator = utils.DataGenerator(args.data_path, "valid", batch_size=BATCH_SIZE) triplet_model.fit_generator(generator=training_batch_generator, validation_data=validation_batch_generator, callbacks=callback_list, epochs=EPOCHS) # Save weights if args.save_weights_path is not None: triplet_model.save_weights(args.save_weights_path + "final_weights.hdf5") # Save model if args.save_model_path is not None: tower_model.save(args.save_model_path + "tower_model.hdf5") # Plot PCA/TSNE # TODO: add function in util that reads a specified number of random samples from a dataset. if args.PCA is not False or args.TSNE is not False: X_valid, y_valid = utils.load_examples(args.data_path, "train") X, Y = utils.shuffle_data(X_valid[:, :, :], y_valid[:, :], one_hot_labels=True) X = X[:5000, :, :] Y = Y[:5000, :] X = tower_model.predict(X) if args.PCA: utils.plot_with_PCA(X, Y) if args.TSNE: utils.plot_with_TSNE(X, Y)
def main(): # Parse arguments parser = argparse.ArgumentParser() parser.add_argument(dest="triplets_path", metavar="TRIPLETS_PATH", help="Path to read triplets from.") parser.add_argument(dest="model_path", metavar="MODEL_PATH", help="Path to read model from.") parser.add_argument( "-e", "--ensemble", metavar="ENSEMBLE", default=1, help="How many examples to ensemble when predicting. Default: 1") parser.add_argument( "-b", "--read_batches", metavar="READ_BATCHES", default=False, help="If true, data is read incrementally in batches during training.") args = parser.parse_args() parse_args(args) # Load model with CustomObjectScope({ '_euclidean_distance': cnn_siamese_online._euclidean_distance, 'ALPHA': cnn_siamese_online.ALPHA, "relu_clipped": cnn_siamese_online.relu_clipped }): tower_model = load_model(args.model_path) tower_model.compile( optimizer='adam', loss='mean_squared_error') # Model was previously not compiled X_shape, y_shape = utils.get_shapes(args.triplets_path, "train_anchors") # Build model to compute [A, P, N] => [abs(emb(A) - emb(P)), abs(emb(A) - emb(N))] pair_distance_model = build_pair_distance_model(tower_model, X_shape[1:]) pair_distance_model.compile( optimizer="adam", loss="mean_squared_error") # Need to compile in order to predict if not args.read_batches: # Read all data at once # Load training triplets X_train_anchors, _ = utils.load_examples(args.triplets_path, "train_anchors") X_train_positives, _ = utils.load_examples(args.triplets_path, "train_positives") X_train_negatives, _ = utils.load_examples(args.triplets_path, "train_negatives") # Get abs(distance) of embeddings X_train_1, X_train_0 = pair_distance_model.predict( [X_train_anchors, X_train_positives, X_train_negatives]) # Stack positive and negative examples X_train = np.vstack((X_train_1, X_train_0)) y_train = np.hstack( (np.ones(X_train_1.shape[0], ), np.zeros(X_train_0.shape[0], ))) # Shuffle the data X_train, y_train = shuffle(X_train, y_train) # Train SVM clf = svm.SVC(gamma='scale', verbose=True) clf.fit(X_train[:10000, :], y_train[:10000]) # Evaluate SVM y_pred = clf.predict(X_train) if args.ensemble > 1: accuracy, FAR, FRR = ensemble_accuracy_FAR_FRR(y_train, y_pred, args.ensemble) print("\n\n---- Validation Results. With ensembling = {}. ----".format( args.ensemble)) else: accuracy, FAR, FRR = accuracy_FAR_FRR(y_train, y_pred) print("\n\n---- Validation Results. No ensembling. ----") print("Accuracy = {}".format(accuracy)) print("FAR = {}".format(FAR)) print("FRR = {}".format(FRR))
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX) # Setup the termination criteria: either 10 iterations, # or move by less than 1 pixel term_crit = (cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 1) cpt = 1 while (1): ret, frame = cap.read() if ret == True: hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV) # Backproject the model histogram roi_hist onto the # current image hsv, i.e. dst(x,y) = roi_hist(hsv(0,x,y)) dst = cv2.calcBackProject([hsv], [0], roi_hist, [0, 180], 1) orientation, norm, mask = get_shapes(hsv[:, :, 2], False, True) matrix_th = np.zeros(shape=hsv.shape[:2]) for y in range(hsv.shape[0]): for x in range(hsv.shape[1]): if mask[y, x]: line = rtable[get_interval_number(orientation[y, x])] for (u, v) in line: try: matrix_th[y + v, x + u, ] += 1 except: continue # apply meanshift to dst to get the new location # Q5