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