def evaluate(self, conf, carray, issame, nrof_folds=5, tta=False): self.backbone.eval() self.idprehead.eval() idx = 0 embeddings = np.zeros([len(carray), conf.embedding_size]) with torch.no_grad(): while idx + conf.batch_size <= len(carray): batch = torch.tensor(carray[idx:idx + conf.batch_size]) if tta: fliped = hflip_batch(batch) emb_batch = self.idprehead( self.backbone(batch.to(conf.device))) + self.idprehead( self.backbone(fliped.to(conf.device))) embeddings[idx:idx + conf.batch_size] = l2_norm(emb_batch) else: embeddings[idx:idx + conf.batch_size] = self.idprehead( self.backbone(batch.to(conf.device))).cpu() idx += conf.batch_size if idx < len(carray): batch = torch.tensor(carray[idx:]) if tta: fliped = hflip_batch(batch) emb_batch = self.idprehead( self.backbone(batch.to(conf.device))) + self.idprehead( self.backbone(fliped.to(conf.device))) embeddings[idx:] = l2_norm(emb_batch) else: embeddings[idx:] = self.idprehead( self.backbone(batch.to(conf.device))).cpu() tpr, fpr, accuracy, best_thresholds = evaluate(embeddings, issame, nrof_folds) buf = gen_plot(fpr, tpr) roc_curve = Image.open(buf) roc_curve_tensor = trans.ToTensor()(roc_curve) return accuracy.mean(), best_thresholds.mean(), roc_curve_tensor
def perform_val(dataLoader, length, embedding_size, backbone, issame, nrof_folds=10, tta=True): idx = 0 embeddings = np.zeros([length, embedding_size]) #prefetcher = DataPrefetcher(dataLoader) with torch.no_grad(): begin = 0 for i, (imgs, labels) in enumerate(tqdm(dataLoader)): imgs = imgs.permute(0, 3, 1, 2).float().cuda() embedding = backbone(imgs) if tta: flipImgs = hflip_batch(imgs) embedding += backbone(flipImgs) embeddings[begin:begin + imgs.shape[0]] = np.copy( l2_norm(embedding).cpu().data.numpy()) begin = begin + imgs.shape[0] tpr, fpr, accuracy, best_thresholds = evaluate(embeddings, issame, nrof_folds) return float(accuracy.mean())
def on_batch_end(self, batch, logs=None): if batch >= 0 and batch % self.period == 0: acc_list = [] for i in range(len(self.valid_list)): embeddings = test(self.valid_list[i], self.extractor, self.batch_size, 10) # get embedding _, _, accuracy, val, val_std, far = verification.evaluate(embeddings, self.valid_name_list, nrof_folds=fold) acc, std = np.mean(accuracy), np.std(accuracy) return acc, std, _xnorm, embeddings_list print('[%s][%d]XNorm: %f' % (self.valid_name_list[i], self.batch_size, x_norm)) print('[%s][%d]Accuracy-Flip: %1.5f+-%1.5f' % (self.valid_name_list[i], self.batch_size, acc, std)) acc_list.append(acc) self.save_step += 1 is_highest = False if len(acc_list) > 0: score = sum(acc_list) if acc_list[-1] >= self.highest_acc[-1]: if acc_list[-1] > self.highest_acc[-1]: is_highest = True else: if score >= self.highest_acc[0]: is_highest = True self.highest_acc[0] = score self.highest_acc[-1] = acc_list[-1] if is_highest: print('saving', self.save_step) filepath = self.filepath.format(epoch=epoch + 1, **logs) self.model.save_weights(filepath, overwrite=True) print('[%d]Accuracy-Highest: %1.5f' % (mbatch, self.highest_acc[-1]))
def tflite_model_test(model_dir): model = FACENET_TFLITE(model_dir) img_size = 112 valid_dir = VALID_DIR datadirs = os.listdir(valid_dir) embedding_size = 512 result = pt.PrettyTable( ["data set", "AUC", "ACC" ,"VR @ FAR ", "dist max", "dist min"]) val_all = [] auc_all = [] acc_all = [] dist_all = [] for i in range(len(datadirs)) : path = valid_dir + "/" + datadirs[i] embeddings, issamelab = predict_evaluate_data_TFLITE(path, [img_size,img_size], model, embedding_size) embeddings1 = embeddings[0::2] embeddings2 = embeddings[1::2] diff = np.subtract(embeddings1, embeddings2) dist = np.sum(np.square(diff), 1) del embeddings1,embeddings2 fpr, tpr,ths = roc_curve(np.asarray(issamelab).astype('int'),dist, pos_label=0 ) auc_score = auc(fpr, tpr) if 0: plt.figure() lw = 2 plt.plot(fpr, tpr, color='darkorange', lw=lw, label='ROC curve (area = %0.2f)' % auc_score) plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--') plt.xlim([0.0, 1.0]) plt.ylim([0.0, 1.05]) plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Receiver operating characteristic example') plt.legend(loc="lower right") # plt.show() plt.savefig("roc.png") # print('-----10 folds------') tpr, fpr, accuracy, val, val_std, far = evaluate(embeddings, issamelab) del embeddings,issamelab gc.collect() result.add_row([datadirs[i] , round(auc_score,2), "%1.3f+-%1.3f" % (np.mean(accuracy), np.std(accuracy)), "%2.5f+-%2.5f @ FAR=%2.5f" % (val, val_std, far), round(np.max(dist),2), round(np.min(dist),2), ]) val_all.append(val) acc_all.append(accuracy) auc_all.append(auc_score) dist_all.append([np.max(dist),np.min(dist)]) print(result)
def on_batch_end(self, batch, logs=None): # t = time.time() # print('time:', t - self.t) # self.t = t global_step = self.epoch * self.steps_per_epoch + batch if global_step > 0 and global_step % self.period == 0: acc_list = [] logs = logs or {} for key in self.valid_list: print('Test on valid set:', key) bins, is_same_list = self.valid_list[key] dataset = tf.data.Dataset.from_tensor_slices(bins) \ .map(data_input.get_valid_parse_function(False), num_parallel_calls=tf.data.experimental.AUTOTUNE) \ .batch(256) dataset_flip = tf.data.Dataset.from_tensor_slices(bins) \ .map(data_input.get_valid_parse_function(True), num_parallel_calls=tf.data.experimental.AUTOTUNE) \ .batch(256) batch_num = len(bins) // 256 if len(bins) % 256 != 0: batch_num += 1 print('predicting...') embeddings = self.extractor.predict(dataset, steps=batch_num, verbose=0) embeddings_flip = self.extractor.predict(dataset_flip, steps=batch_num, verbose=0) embeddings_parts = [embeddings, embeddings_flip] x_norm = 0.0 x_norm_cnt = 0 for part in embeddings_parts: for i in range(part.shape[0]): embedding = part[i] norm = np.linalg.norm(embedding) x_norm += norm x_norm_cnt += 1 x_norm /= x_norm_cnt embeddings = embeddings_parts[0] + embeddings_parts[1] embeddings = sklearn.preprocessing.normalize(embeddings) print(embeddings.shape) _, _, accuracy, val, val_std, far = verification.evaluate( embeddings, is_same_list, folds=10) acc, std = np.mean(accuracy), np.std(accuracy) print('[%s][%d]XNorm: %f' % (key, batch, x_norm)) print('[%s][%d]Accuracy-Flip: %1.5f+-%1.5f' % (key, batch, acc, std)) acc_list.append(acc) logs['score'] = sum(acc_list) if self.verbose > 0: print('\nScore of step %05d: %0.5f' % (global_step, logs['score']))
def main(args): with tf.Graph().as_default(): with tf.Session() as sess: # prepare validate datasets ver_list = [] ver_name_list = [] for db in args.eval_datasets: print('begin db %s convert.' % db) data_set = load_data(db, args.image_size, args) ver_list.append(data_set) ver_name_list.append(db) # Load the model load_model(args.model) # Get input and output tensors, ignore phase_train_placeholder for it have default value. inputs_placeholder = tf.get_default_graph().get_tensor_by_name("input:0") embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0") # image_size = images_placeholder.get_shape()[1] # For some reason this doesn't work for frozen graphs embedding_size = embeddings.get_shape()[1] for db_index in range(len(ver_list)): # Run forward pass to calculate embeddings print('\nRunnning forward pass on {} images'.format(ver_name_list[db_index])) start_time = time.time() data_sets, issame_list = ver_list[db_index] if data_sets.shape[0] % args.test_batch_size ==0: nrof_batches = data_sets.shape[0] // args.test_batch_size else: nrof_batches = data_sets.shape[0] // args.test_batch_size +1 emb_array = np.zeros((data_sets.shape[0], embedding_size)) for index in range(nrof_batches): start_index = index * args.test_batch_size end_index = min((index + 1) * args.test_batch_size, data_sets.shape[0]) feed_dict = {inputs_placeholder: data_sets[start_index:end_index, ...]} emb_array[start_index:end_index, :] = sess.run(embeddings, feed_dict=feed_dict) tpr, fpr, accuracy, val, val_std, far = evaluate(emb_array, issame_list, nrof_folds=args.eval_nrof_folds) duration = time.time() - start_time print("total time %.3fs to evaluate %d images of %s" % (duration, data_sets.shape[0], ver_name_list[db_index])) print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy))) print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far)) print('fpr and tpr: %1.3f %1.3f' % (np.mean(fpr, 0), np.mean(tpr, 0))) auc = metrics.auc(fpr, tpr) print('Area Under Curve (AUC): %1.3f' % auc) eer = brentq(lambda x: 1. - x - interpolate.interp1d(fpr, tpr)(x), 0., 1.) print('Equal Error Rate (EER): %1.3f' % eer)
nrof_batches = data_sets.shape[0] // args.test_batch_size for index in range(nrof_batches ): # actual is same multiply 2, test data total start_index = index * args.test_batch_size end_index = min((index + 1) * args.test_batch_size, data_sets.shape[0]) feed_dict = { inputs: data_sets[start_index:end_index, ...], phase_train_placeholder: False } emb_array[start_index:end_index, :] = sess.run( embeddings, feed_dict=feed_dict) duration = time.time() - start_time tpr, fpr, accuracy, val, val_std, far = evaluate( emb_array, issame_list, nrof_folds=args.eval_nrof_folds) print("total time %.3f to evaluate %d images of %s" % (duration, data_sets.shape[0], ver_name_list[ver_step])) print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy))) print('fpr and tpr: %1.3f %1.3f' % (np.mean(fpr, 0), np.mean(tpr, 0))) print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far)) auc = metrics.auc(fpr, tpr) print('Area Under Curve (AUC): %1.3f' % auc) eer = brentq(lambda x: 1. - x - interpolate.interp1d(fpr, tpr)(x), 0., 1.) print('Equal Error Rate (EER): %1.3f\n' % eer)
def train_net(args): data_dir = config.dataset_path image_size = config.image_shape[0:2] assert len(image_size) == 2 assert image_size[0] == image_size[1] print('image_size', image_size) print('num_classes', config.num_classes) training_path = os.path.join(data_dir, "train.tfrecords") print('Called with argument:', args, config) train_dataset, batches_per_epoch = data_input.training_dataset( training_path, default.per_batch_size) extractor, classifier = build_model((image_size[0], image_size[1], 3), args) global_step = 0 ckpt_path = os.path.join( args.models_root, '%s-%s-%s' % (args.network, args.loss, args.dataset), 'model-{step:04d}.ckpt') ckpt_dir = os.path.dirname(ckpt_path) print('ckpt_path', ckpt_path) if not os.path.exists(ckpt_dir): os.makedirs(ckpt_dir) if len(args.pretrained) == 0: latest = tf.train.latest_checkpoint(ckpt_dir) if latest: global_step = int(latest.split('-')[-1].split('.')[0]) classifier.load_weights(latest) else: print('loading', args.pretrained, args.pretrained_epoch) load_path = os.path.join(args.pretrained, '-', args.pretrained_epoch, '.ckpt') classifier.load_weights(load_path) initial_epoch = global_step // batches_per_epoch rest_batches = global_step % batches_per_epoch lr_decay_steps = [(int(x), args.lr * np.power(0.1, i + 1)) for i, x in enumerate(args.lr_steps.split(','))] print('lr_steps', lr_decay_steps) valid_datasets = data_input.load_valid_set(data_dir, config.val_targets) classifier.compile( optimizer=keras.optimizers.SGD(lr=args.lr, momentum=args.mom), loss=keras.losses.CategoricalCrossentropy(from_logits=True), metrics=[keras.metrics.SparseCategoricalAccuracy()]) classifier.summary() tensor_board = keras.callbacks.TensorBoard(ckpt_dir) tensor_board.set_model(classifier) train_names = ['train_loss', 'train_acc'] train_results = [] highest_score = 0 for epoch in range(initial_epoch, default.end_epoch): for batch in range(rest_batches, batches_per_epoch + 1): utils.update_learning_rate(classifier, lr_decay_steps, global_step) train_results = classifier.train_on_batch(train_dataset, reset_metrics=False) global_step += 1 if global_step % 1000 == 0: print('lr-batch-epoch:', float(K.get_value(classifier.optimizer.lr)), batch, epoch) if global_step >= 0 and global_step % args.verbose == 0: acc_list = [] for key in valid_datasets: data_set, data_set_flip, is_same_list = valid_datasets[key] embeddings = extractor.predict(data_set) embeddings_flip = extractor.predict(data_set_flip) embeddings_parts = [embeddings, embeddings_flip] x_norm = 0.0 x_norm_cnt = 0 for part in embeddings_parts: for i in range(part.shape[0]): embedding = part[i] norm = np.linalg.norm(embedding) x_norm += norm x_norm_cnt += 1 x_norm /= x_norm_cnt embeddings = embeddings_parts[0] + embeddings_parts[1] embeddings = sklearn.preprocessing.normalize(embeddings) print(embeddings.shape) _, _, accuracy, val, val_std, far = verification.evaluate( embeddings, is_same_list, folds=10) acc, std = np.mean(accuracy), np.std(accuracy) print('[%s][%d]XNorm: %f' % (key, batch, x_norm)) print('[%s][%d]Accuracy-Flip: %1.5f+-%1.5f' % (key, batch, acc, std)) acc_list.append(acc) if len(acc_list) > 0: score = sum(acc_list) if highest_score == 0: highest_score = score elif highest_score >= score: print('\nStep %05d: score did not improve from %0.5f' % (global_step, highest_score)) else: path = ckpt_path.format(step=global_step) print( '\nStep %05d: score improved from %0.5f to %0.5f,' ' saving model to %s' % (global_step, highest_score, score, path)) highest_score = score classifier.save_weights(path) utils.write_log(tensor_board, train_names, train_results, epoch) classifier.reset_metrics()
def custom_insightface_evaluation(args): tf.reset_default_graph() # Read the directory containing images pairs = read_pairs(args.insightface_pair) image_list, issame_list = get_paths_with_pairs( args.insightface_dataset_dir, pairs) # Evaluate custom dataset with facenet pre-trained model print("Getting embeddings with facenet pre-trained model") # Getting batched images by TF dataset tf_dataset = facenet.tf_gen_dataset( image_list=image_list, label_list=None, nrof_preprocess_threads=args.nrof_preprocess_threads, image_size=args.insightface_dataset_dir, method='cache_slices', BATCH_SIZE=args.batch_size, repeat_count=1, to_float32=True, shuffle=False) # tf_dataset = facenet.tf_gen_dataset(image_list, label_list, args.nrof_preprocess_threads, args.facenet_image_size, method='cache_slices', # BATCH_SIZE=args.batch_size, repeat_count=1, shuffle=False) tf_dataset_iterator = tf_dataset.make_initializable_iterator() tf_dataset_next_element = tf_dataset_iterator.get_next() images = tf.placeholder(name='img_inputs', shape=[ None, args.insightface_image_size, args.insightface_image_size, 3 ], dtype=tf.float32) labels = tf.placeholder(name='img_labels', shape=[ None, ], dtype=tf.int64) dropout_rate = tf.placeholder(name='dropout_rate', dtype=tf.float32) w_init_method = tf.contrib.layers.xavier_initializer(uniform=False) net = L_Resnet_E_IR_fix_issue9.get_resnet(images, args.net_depth, type='ir', w_init=w_init_method, trainable=False, keep_rate=dropout_rate) embeddings = net.outputs # mv_mean = tl.layers.get_variables_with_name('resnet_v1_50/bn0/moving_mean', False, True)[0] # 3.2 get arcface loss logit = arcface_loss(embedding=net.outputs, labels=labels, w_init=w_init_method, out_num=args.num_output) sess = tf.Session() saver = tf.train.Saver() feed_dict = {} feed_dict_flip = {} path = args.ckpt_file + args.ckpt_index_list[0] saver.restore(sess, path) print('ckpt file %s restored!' % args.ckpt_index_list[0]) feed_dict.update(tl.utils.dict_to_one(net.all_drop)) feed_dict_flip.update(tl.utils.dict_to_one(net.all_drop)) feed_dict[dropout_rate] = 1.0 feed_dict_flip[dropout_rate] = 1.0 batch_size = args.batch_size input_placeholder = images sess.run(tf_dataset_iterator.initializer) print('getting embeddings..') total_time = 0 batch_number = 0 embeddings_array = None embeddings_array_flip = None while True: try: images = sess.run(tf_dataset_next_element) data_tmp = images.copy() # fix issues #4 for i in range(data_tmp.shape[0]): data_tmp[i, ...] -= 127.5 data_tmp[i, ...] *= 0.0078125 data_tmp[i, ...] = cv2.cvtColor(data_tmp[i, ...], cv2.COLOR_RGB2BGR) # Getting flip to left_right batched images by TF dataset data_tmp_flip = images.copy() # fix issues #4 for i in range(data_tmp_flip.shape[0]): data_tmp_flip[i, ...] = np.fliplr(data_tmp_flip[i, ...]) data_tmp_flip[i, ...] -= 127.5 data_tmp_flip[i, ...] *= 0.0078125 data_tmp_flip[i, ...] = cv2.cvtColor(data_tmp_flip[i, ...], cv2.COLOR_RGB2BGR) start_time = time.time() feed_dict[input_placeholder] = data_tmp _embeddings = sess.run(embeddings, feed_dict) feed_dict_flip[input_placeholder] = data_tmp_flip _embeddings_flip = sess.run(embeddings, feed_dict_flip) if embeddings_array is None: embeddings_array = np.zeros( (len(image_list), _embeddings.shape[1])) embeddings_array_flip = np.zeros( (len(image_list), _embeddings_flip.shape[1])) try: embeddings_array[batch_number * batch_size:min((batch_number + 1) * batch_size, len(image_list)), ...] = _embeddings embeddings_array_flip[batch_number * batch_size:min( (batch_number + 1) * batch_size, len(image_list)), ...] = _embeddings_flip # print('try: ', batch_number * batch_size, min((batch_number + 1) * batch_size, len(image_list)), ...) except ValueError: print( 'batch_number*batch_size value is %d min((batch_number+1)*batch_size, len(image_list)) %d,' ' batch_size %d, data.shape[0] %d' % (batch_number * batch_size, min((batch_number + 1) * batch_size, len(image_list)), batch_size, images.shape[0])) print('except: ', batch_number * batch_size, min((batch_number + 1) * batch_size, images.shape[0]), ...) duration = time.time() - start_time batch_number += 1 total_time += duration except tf.errors.OutOfRangeError: print( 'tf.errors.OutOfRangeError, Reinitialize tf_dataset_iterator') sess.run(tf_dataset_iterator.initializer) break print(f"total_time: {total_time}") _xnorm = 0.0 _xnorm_cnt = 0 for embed in [embeddings_array, embeddings_array_flip]: for i in range(embed.shape[0]): _em = embed[i] _norm = np.linalg.norm(_em) # print(_em.shape, _norm) _xnorm += _norm _xnorm_cnt += 1 _xnorm /= _xnorm_cnt final_embeddings_output = embeddings_array + embeddings_array_flip final_embeddings_output = sklearn.preprocessing.normalize( final_embeddings_output) print(final_embeddings_output.shape) tpr, fpr, accuracy, val, val_std, far = verification.evaluate( final_embeddings_output, issame_list, nrof_folds=10) acc2, std2 = np.mean(accuracy), np.std(accuracy) auc = metrics.auc(fpr, tpr) print('XNorm: %f' % (_xnorm)) print('Accuracy-Flip: %1.5f+-%1.5f' % (acc2, std2)) print('TPR: ', np.mean(tpr), 'FPR: ', np.mean(fpr)) print('Area Under Curve (AUC): %1.3f' % auc) tpr_lfw, fpr_lfw, accuracy_lfw, val_lfw, val_std_lfw, far_lfw = lfw.evaluate( final_embeddings_output, issame_list, nrof_folds=10, distance_metric=0, subtract_mean=False) print('accuracy_lfw: %2.5f+-%2.5f' % (np.mean(accuracy_lfw), np.std(accuracy_lfw))) print( f"val_lfw: {val_lfw}, val_std_lfw: {val_std_lfw}, far_lfw: {far_lfw}") print('val_lfw rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val_lfw, val_std_lfw, far_lfw)) auc_lfw = metrics.auc(fpr_lfw, tpr_lfw) print('TPR_LFW:', np.mean(tpr_lfw), 'FPR_LFW: ', np.mean(fpr_lfw)) print('Area Under Curve LFW (AUC): %1.3f' % auc_lfw) sess.close() return acc2, std2, _xnorm, [embeddings_array, embeddings_array_flip]
def custom_facenet_evaluation(args): tf.reset_default_graph() # Read the directory containing images pairs = read_pairs(args.insightface_pair) image_list, issame_list = get_paths_with_pairs(args.facenet_dataset_dir, pairs) # Evaluate custom dataset with facenet pre-trained model print("Getting embeddings with facenet pre-trained model") with tf.Graph().as_default(): # Getting batched images by TF dataset # image_list = path_list tf_dataset = facenet.tf_gen_dataset( image_list=image_list, label_list=None, nrof_preprocess_threads=args.nrof_preprocess_threads, image_size=args.facenet_image_size, method='cache_slices', BATCH_SIZE=args.batch_size, repeat_count=1, to_float32=True, shuffle=False) tf_dataset_iterator = tf_dataset.make_initializable_iterator() tf_dataset_next_element = tf_dataset_iterator.get_next() with tf.Session() as sess: sess.run(tf_dataset_iterator.initializer) phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train') image_batch = tf.placeholder(name='img_inputs', shape=[ None, args.facenet_image_size, args.facenet_image_size, 3 ], dtype=tf.float32) label_batch = tf.placeholder(name='img_labels', shape=[ None, ], dtype=tf.int32) # Load the model input_map = { 'image_batch': image_batch, 'label_batch': label_batch, 'phase_train': phase_train_placeholder } facenet.load_model(args.facenet_model, input_map=input_map) # Get output tensor embeddings = tf.get_default_graph().get_tensor_by_name( "embeddings:0") batch_size = args.batch_size input_placeholder = image_batch print('getting embeddings..') total_time = 0 batch_number = 0 embeddings_array = None embeddings_array_flip = None while True: try: images = sess.run(tf_dataset_next_element) data_tmp = images.copy() # fix issues #4 for i in range(data_tmp.shape[0]): data_tmp[i, ...] -= 127.5 data_tmp[i, ...] *= 0.0078125 data_tmp[i, ...] = cv2.cvtColor(data_tmp[i, ...], cv2.COLOR_RGB2BGR) # Getting flip to left_right batched images by TF dataset data_tmp_flip = images.copy() # fix issues #4 for i in range(data_tmp_flip.shape[0]): data_tmp_flip[i, ...] = np.fliplr(data_tmp_flip[i, ...]) data_tmp_flip[i, ...] -= 127.5 data_tmp_flip[i, ...] *= 0.0078125 data_tmp_flip[i, ...] = cv2.cvtColor( data_tmp_flip[i, ...], cv2.COLOR_RGB2BGR) start_time = time.time() mr_feed_dict = { input_placeholder: data_tmp, phase_train_placeholder: False } mr_feed_dict_flip = { input_placeholder: data_tmp_flip, phase_train_placeholder: False } _embeddings = sess.run(embeddings, mr_feed_dict) _embeddings_flip = sess.run(embeddings, mr_feed_dict_flip) if embeddings_array is None: embeddings_array = np.zeros( (len(image_list), _embeddings.shape[1])) embeddings_array_flip = np.zeros( (len(image_list), _embeddings_flip.shape[1])) try: embeddings_array[batch_number * batch_size:min( (batch_number + 1) * batch_size, len(image_list)), ...] = _embeddings embeddings_array_flip[batch_number * batch_size:min( (batch_number + 1) * batch_size, len(image_list)), ...] = _embeddings_flip # print('try: ', batch_number * batch_size, min((batch_number + 1) * batch_size, len(image_list)), ...) except ValueError: print( 'batch_number*batch_size value is %d min((batch_number+1)*batch_size, len(image_list)) %d,' ' batch_size %d, data.shape[0] %d' % (batch_number * batch_size, min((batch_number + 1) * batch_size, len(image_list)), batch_size, images.shape[0])) print( 'except: ', batch_number * batch_size, min((batch_number + 1) * batch_size, images.shape[0]), ...) duration = time.time() - start_time batch_number += 1 total_time += duration except tf.errors.OutOfRangeError: print( 'tf.errors.OutOfRangeError, Reinitialize tf_dataset_iterator' ) sess.run(tf_dataset_iterator.initializer) break print(f"total_time: {total_time}") _xnorm = 0.0 _xnorm_cnt = 0 for embed in [embeddings_array, embeddings_array_flip]: for i in range(embed.shape[0]): _em = embed[i] _norm = np.linalg.norm(_em) # print(_em.shape, _norm) _xnorm += _norm _xnorm_cnt += 1 _xnorm /= _xnorm_cnt final_embeddings_output = embeddings_array + embeddings_array_flip final_embeddings_output = sklearn.preprocessing.normalize( final_embeddings_output) print(final_embeddings_output.shape) tpr, fpr, accuracy, val, val_std, far = verification.evaluate( final_embeddings_output, issame_list, nrof_folds=10) acc2, std2 = np.mean(accuracy), np.std(accuracy) auc = metrics.auc(fpr, tpr) print('XNorm: %f' % (_xnorm)) print('Accuracy-Flip: %1.5f+-%1.5f' % (acc2, std2)) print('TPR: ', np.mean(tpr), 'FPR: ', np.mean(fpr)) print('Area Under Curve (AUC): %1.3f' % auc) tpr_lfw, fpr_lfw, accuracy_lfw, val_lfw, val_std_lfw, far_lfw = lfw.evaluate( final_embeddings_output, issame_list, nrof_folds=10, distance_metric=0, subtract_mean=False) print('accuracy_lfw: %2.5f+-%2.5f' % (np.mean(accuracy_lfw), np.std(accuracy_lfw))) print( f"val_lfw: {val_lfw}, val_std_lfw: {val_std_lfw}, far_lfw: {far_lfw}") print('val_lfw rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val_lfw, val_std_lfw, far_lfw)) auc_lfw = metrics.auc(fpr_lfw, tpr_lfw) print('TPR_LFW:', np.mean(tpr_lfw), 'FPR_LFW: ', np.mean(fpr_lfw)) print('Area Under Curve LFW (AUC): %1.3f' % auc_lfw) return acc2, std2, _xnorm, [embeddings_array, embeddings_array_flip]
def perform_val(multi_gpu, device, embedding_size, batch_size, backbone, carray, issame, nrof_folds=10, tta=True, mask=0, save_tag=False, part=None, size=25, batch_same=True, masknet=None): if multi_gpu: backbone = backbone.module # unpackage model from DataParallel backbone = backbone.to(device) else: backbone = backbone.to(device) backbone.eval() # switch to evaluation mode if masknet is not None: if multi_gpu: masknet = masknet.module # unpackage model from DataParallel masknet = masknet.to(device) else: masknet = masknet.to(device) masknet.eval() # switch to evaluation mode idx = 0 embeddings = np.zeros([len(carray), embedding_size]) with torch.no_grad(): while idx + batch_size <= len(carray): batch = torch.tensor(carray[idx:idx + batch_size][:, [2, 1, 0], :, :]) if save_tag is True: if mask == 1: batch = random_mask(batch, batch_same=batch_same) elif mask == 2: batch = random_mask(batch, part, size) imgs = depre_batch(batch) for i, img in enumerate(imgs): if part is not None: img.save('./data/lfw_occlusion/' + part + '/' + str(idx + i) + '.jpg') else: img.save('./data/lfw_noocclusion/' + str(idx + i) + '.jpg') if tta: ccropped = ccrop_batch(batch) fliped = hflip_batch(ccropped) if masknet is not None: if mask == 1: ccropped, ccropped_mask = random_mask( ccropped, batch_same=batch_same, mask_return=True) fliped, fliped_mask = random_mask( fliped, batch_same=batch_same, mask_return=True) elif mask == 2: ccropped, ccropped_mask = random_mask(ccropped, part, size, mask_return=True) fliped, fliped_mask = random_mask(fliped, part, size, mask_return=True) emb_batch = add_mask( ccropped[0::2], ccropped[1::2], ccropped_mask[0::2], ccropped_mask[1::2], masknet, device, backbone, embedding_size, batch_size) + add_mask( fliped[0::2], fliped[1::2], fliped_mask[0::2], fliped_mask[1::2], masknet, device, backbone, embedding_size, batch_size) embeddings[idx:idx + batch_size] = l2_norm(emb_batch.cpu()) else: if mask == 1: ccropped = random_mask(ccropped, batch_same=batch_same) fliped = random_mask(fliped, batch_same=batch_same) elif mask == 2: ccropped = random_mask(ccropped, part, size) fliped = random_mask(fliped, part, size) emb_batch = backbone(ccropped.to(device)).cpu() + backbone( fliped.to(device)).cpu() embeddings[idx:idx + batch_size] = l2_norm(emb_batch) else: ccropped = ccrop_batch(batch) if masknet is not None: if mask == 1: ccropped, ccropped_mask = random_mask( ccropped, batch_same=batch_same, mask_return=True) elif mask == 2: ccropped, ccropped_mask = random_mask(ccropped, part, size, mask_return=True) emb_batch = add_mask(ccropped[0::2], ccropped[1::2], ccropped_mask[0::2], ccropped_mask[1::2], masknet, device, backbone, embedding_size, batch_size) embeddings[idx:idx + batch_size] = l2_norm(emb_batch.cpu()) else: if mask == 1: ccropped = random_mask(ccropped, batch_same=batch_same) elif mask == 2: ccropped = random_mask(ccropped, part, size) embeddings[idx:idx + batch_size] = l2_norm( backbone(ccropped.to(device))).cpu() idx += batch_size if idx < len(carray): batch = torch.tensor(carray[idx:]) if save_tag is True: if mask == 1: batch = random_mask(batch, batch_same=batch_same) elif mask == 2: batch = random_mask(batch, part, size) imgs = depre_batch(batch) for i, img in enumerate(imgs): if part is not None: img.save('./data/lfw_occlusion/' + part + '/' + str(idx + i) + '.jpg') else: img.save('./data/lfw_noocclusion/' + str(idx + i) + '.jpg') if tta: ccropped = ccrop_batch(batch) fliped = hflip_batch(ccropped) if masknet is not None: if mask == 1: ccropped, ccropped_mask = random_mask( ccropped, batch_same=batch_same, mask_return=True) fliped, fliped_mask = random_mask( fliped, batch_same=batch_same, mask_return=True) elif mask == 2: ccropped, ccropped_mask = random_mask(ccropped, part, size, mask_return=True) fliped, fliped_mask = random_mask(fliped, part, size, mask_return=True) emb_batch = add_mask( ccropped[0::2], ccropped[1::2], ccropped_mask[0::2], ccropped_mask[1::2], masknet, device, backbone, embedding_size, len(carray) - idx) + add_mask( fliped[0::2], fliped[1::2], fliped_mask[0::2], fliped_mask[1::2], masknet, device, backbone, embedding_size, len(carray) - idx) embeddings[idx:] = l2_norm(emb_batch.cpu()) else: if mask == 1: ccropped = random_mask(ccropped, batch_same=batch_same) fliped = random_mask(fliped, batch_same=batch_same) elif mask == 2: ccropped = random_mask(ccropped, part, size) fliped = random_mask(fliped, part, size) emb_batch = backbone(ccropped.to(device)).cpu() + backbone( fliped.to(device)).cpu() embeddings[idx:] = l2_norm(emb_batch) else: ccropped = ccrop_batch(batch) if masknet is not None: if mask == 1: ccropped, ccropped_mask = random_mask( ccropped, batch_same=batch_same, mask_return=True) elif mask == 2: ccropped, ccropped_mask = random_mask(ccropped, part, size, mask_return=True) emb_batch = add_mask(ccropped[0::2], ccropped[1::2], ccropped_mask[0::2], ccropped_mask[1::2], masknet, device, backbone, embedding_size, len(carray) - idx) embeddings[idx:] = l2_norm(emb_batch.cpu()) else: if mask == 1: ccropped = random_mask(ccropped, batch_same=batch_same) elif mask == 2: ccropped = random_mask(ccropped, part, size) embeddings[idx:] = l2_norm(backbone( ccropped.to(device))).cpu() tpr, fpr, accuracy, best_thresholds = evaluate(embeddings, issame, nrof_folds) buf = gen_plot(fpr, tpr) roc_curve = Image.open(buf) roc_curve_tensor = transforms.ToTensor()(roc_curve) return accuracy.mean(), best_thresholds.mean(), roc_curve_tensor
def on_epoch_end(self, epoch, logs=None): result = pt.PrettyTable( ["data set", "AUC", "ACC", "VR @ FAR ", "dist max", "dist min"]) val_all = [] auc_all = [] acc_all = [] dist_all = [] for i in range(len(self.datadirs)): path = FLAGS.valid_dir + "/" + self.datadirs[i] embeddings, issamelab = predict_evaluate_data( path, [FLAGS.img_size, FLAGS.img_size], self.model, FLAGS.embedding_size) embeddings1 = embeddings[0::2] embeddings2 = embeddings[1::2] diff = np.subtract(embeddings1, embeddings2) dist = np.sum(np.square(diff), 1) del embeddings1, embeddings2 fpr, tpr, ths = roc_curve(np.asarray(issamelab).astype('int'), dist, pos_label=0) auc_score = auc(fpr, tpr) # print('\ndataset:',self.datadirs[i]) # print('embed:',np.max(embeddings),np.min(embeddings)) # print("dist:",np.max(dist),np.min(dist)) if 0: plt.figure() lw = 2 plt.plot(fpr, tpr, color='darkorange', lw=lw, label='ROC curve (area = %0.2f)' % auc_score) plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--') plt.xlim([0.0, 1.0]) plt.ylim([0.0, 1.05]) plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Receiver operating characteristic example') plt.legend(loc="lower right") # plt.show() plt.savefig("roc.png") # print('-----10 folds------') tpr, fpr, accuracy, val, val_std, far = evaluate( embeddings, issamelab) del embeddings, issamelab gc.collect() result.add_row([ self.datadirs[i], round(auc_score, 2), "%1.3f+-%1.3f" % (np.mean(accuracy), np.std(accuracy)), "%2.5f+-%2.5f @ FAR=%2.5f" % (val, val_std, far), round(np.max(dist), 2), round(np.min(dist), 2), ]) val_all.append(val) acc_all.append(accuracy) auc_all.append(auc_score) dist_all.append([np.max(dist), np.min(dist)]) logs['predict_labels_validacc'] = np.mean(np.array(val_all)) logs['max_dis'] = np.mean(np.array(dist_all), 0)[0] logs['min_dis'] = np.mean(np.array(dist_all), 0)[1] logs['auc'] = np.mean(np.array(auc_all)) print(result)
#Preprocesing the data to obtain mfcc or spectrogram for input to the network ppr.preprocess_data( cfg.audio_dir, cfg.dev_set_path, cfg.train_data_path, cfg.session ) # Have to do the seapration into train and validation sets manually ppr.preprocess_data(cfg.audio_dir, cfg.val_set_path, cfg.val_data_path, cfg.session) vs.train(cfg.audio_dir, cfg.train_data_path, cfg.val_data_path) # Evaluating the model elif cfg.session == 'evaluate': print("EVALUATION SESSION...") ppr.preprocess_data(cfg.audio_dir, cfg.enroll_set_path, cfg.enroll_data_path, 'enroll') ppr.preprocess_data(cfg.audio_dir, cfg.eval_set_path, cfg.eval_data_path, cfg.session) vs.evaluate(cfg.audio_dir, cfg.eval_data_path, cfg.enroll_data_path) # Enrolling the speakers elif cfg.session == 'enroll': print("ENROLLMENT SESSION...") reply = enr.yes_or_no( 'Do you want to give input through microphone?(y/n): ') if (reply): enr.get_audio() ppr.preprocess_data(cfg.audio_dir, cfg.RT_enroll_set_path, cfg.RT_enroll_data_path, cfg.session) vs.enroll(cfg.audio_dir, cfg.RT_enroll_data_path, cfg.session) else: ppr.preprocess_data(cfg.audio_dir, cfg.enroll_set_path, cfg.enroll_data_path, cfg.session) vs.enroll(cfg.audio_dir, cfg.enroll_data_path, cfg.session)
def main(): cur_time = datetime.strftime(datetime.now(), '%Y%m%d-%H%M%S') print(f'\n\n\n***TRAINING SESSION START AT {cur_time}***\n\n\n') with tf.Graph().as_default(): os.environ["CUDA_VISIBLE_DEVICES"] = "0" args = get_parser() # define global params global_step = tf.Variable(name='global_step', initial_value=0, trainable=False) epoch_step = tf.Variable(name='epoch_step', initial_value=0, trainable=False) epoch = tf.Variable(name='epoch', initial_value=0, trainable=False) # def placeholders print(f'***Input of size: {args.image_size}') print( f'***Perform evaluation after each {args.validate_interval} on datasets: {args.eval_datasets}' ) inputs = tf.placeholder(name='img_inputs', shape=[None, *args.image_size, 3], dtype=tf.float32) labels = tf.placeholder(name='img_labels', shape=[ None, ], dtype=tf.int64) phase_train_placeholder = tf.placeholder_with_default( tf.constant(False, dtype=tf.bool), shape=None, name='phase_train') # prepare train dataset # the image is substracted 127.5 and multiplied 1/128. # random flip left right tfrecords_f = os.path.join(args.tfrecords_file_path, 'train.tfrecords') dataset = tf.data.TFRecordDataset(tfrecords_f) dataset = dataset.map(parse_function) # dataset = dataset.shuffle(buffer_size=args.buffer_size) dataset = dataset.batch(args.train_batch_size) iterator = dataset.make_initializable_iterator() next_element = iterator.get_next() # identity the input, for inference inputs = tf.identity(inputs, 'input') prelogits, net_points = inference( inputs, bottleneck_layer_size=args.embedding_size, phase_train=phase_train_placeholder, weight_decay=args.weight_decay) # record the network architecture hd = open("./arch/txt/MobileFaceNet_architecture.txt", 'w') for key in net_points.keys(): info = '{}:{}\n'.format(key, net_points[key].get_shape().as_list()) hd.write(info) hd.close() embeddings = tf.nn.l2_normalize(prelogits, 1, 1e-10, name='embeddings') # Norm for the prelogits eps = 1e-5 prelogits_norm = tf.reduce_mean( tf.norm(tf.abs(prelogits) + eps, ord=args.prelogits_norm_p, axis=1)) tf.add_to_collection(tf.GraphKeys.REGULARIZATION_LOSSES, prelogits_norm * args.prelogits_norm_loss_factor) # inference_loss, logit = cos_loss(prelogits, labels, args.class_number) w_init_method = slim.initializers.xavier_initializer() if args.loss_type == 'insightface': print( f'INSIGHTFACE LOSS WITH s={args.margin_s}, m={args.margin_m}') inference_loss, logit = insightface_loss(embeddings, labels, args.class_number, w_init_method, s=args.margin_s, m=args.margin_m) elif args.loss_type == 'cosine': inference_loss, logit = cosineface_loss(embeddings, labels, args.class_number, w_init_method) elif args.loss_type == 'combine': inference_loss, logit = combine_loss(embeddings, labels, args.train_batch_size, args.class_number, w_init_method) else: assert 0, 'loss type error, choice item just one of [insightface, cosine, combine], please check!' tf.add_to_collection('losses', inference_loss) # total losses regularization_losses = tf.get_collection( tf.GraphKeys.REGULARIZATION_LOSSES) total_loss = tf.add_n([inference_loss] + regularization_losses, name='total_loss') # define the learning rate schedule learning_rate = tf.train.piecewise_constant( epoch, boundaries=args.lr_schedule, values=[0.1, 0.01, 0.001, 0.0001, 0.00001], name='lr_schedule') # define sess gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.9) config = tf.ConfigProto(allow_soft_placement=True, log_device_placement=args.log_device_mapping, gpu_options=gpu_options) config.gpu_options.allow_growth = True sess = tf.Session(config=config) # calculate accuracy op pred = tf.nn.softmax(logit) correct_prediction = tf.cast( tf.equal(tf.argmax(pred, 1), tf.cast(labels, tf.int64)), tf.float32) Accuracy_Op = tf.reduce_mean(correct_prediction) # summary writer summary = tf.summary.FileWriter(args.summary_path, sess.graph) summaries = [] # add train info to tensorboard summary summaries.append(tf.summary.scalar('inference_loss', inference_loss)) summaries.append(tf.summary.scalar('total_loss', total_loss)) summaries.append(tf.summary.scalar('learning_rate', learning_rate)) summaries.append(tf.summary.scalar('training_acc', Accuracy_Op)) summary_op = tf.summary.merge(summaries) # train op train_op = train(total_loss, global_step, args.optimizer, learning_rate, args.moving_average_decay, tf.global_variables(), summaries, args.log_histograms) inc_global_step_op = tf.assign_add(global_step, 1, name='increment_global_step') inc_epoch_step_op = tf.assign_add(epoch_step, 1, name='increment_epoch_step') reset_epoch_step_op = tf.assign(epoch_step, 0, name='reset_epoch_step') inc_epoch_op = tf.assign_add(epoch, 1, name='increment_epoch') # record trainable variable hd = open("./arch/txt/trainable_var.txt", "w") for var in tf.trainable_variables(): hd.write(str(var)) hd.write('\n') hd.close() # init all variables sess.run(tf.global_variables_initializer()) sess.run(tf.local_variables_initializer()) # RELOAD CHECKPOINT FOR PRETRAINED MODEL # pretrained model path pretrained_model = None if args.pretrained_model: pretrained_model = os.path.expanduser(args.pretrained_model) print('***Pre-trained model: %s' % pretrained_model) if pretrained_model is None: # saver to load pretrained model or save model saver = tf.train.Saver(tf.trainable_variables() + [epoch, epoch_step, global_step], max_to_keep=args.saver_maxkeep) else: saver = tf.train.Saver(tf.trainable_variables(), max_to_keep=args.saver_maxkeep) # lask checkpoint path checkpoint_path = None if args.ckpt_path: ckpts = os.listdir(args.ckpt_path) if 'checkpoint' in ckpts: ckpts.remove('checkpoint') ckpts_prefix = [x.split('_')[0] for x in ckpts] ckpts_prefix.sort(key=lambda x: int(x), reverse=True) # Get last checkpoint if len(ckpts_prefix) > 0: last_ckpt = f"{ckpts_prefix[0]}_MobileFaceNet.ckpt" checkpoint_path = os.path.expanduser( os.path.join(args.ckpt_path, last_ckpt)) print('***Last checkpoint: %s' % checkpoint_path) # load checkpoint model if checkpoint_path is not None: print('***Restoring checkpoint: %s' % checkpoint_path) saver.restore(sess, checkpoint_path) # load pretrained model elif pretrained_model: print('***Restoring pretrained model: %s' % pretrained_model) # ckpt = tf.train.get_checkpoint_state(pretrained_model) # print(ckpt) saver.restore(sess, pretrained_model) else: print('***No checkpoint or pretrained model found.') print('***Training from scratch') # output file path if not os.path.exists(args.log_file_path): os.makedirs(args.log_file_path) if not os.path.exists(args.ckpt_best_path): os.makedirs(args.ckpt_best_path) # prepare validate datasets ver_list = [] ver_name_list = [] print('***LOADING VALIDATION DATABASES..') for db in args.eval_datasets: print('\t- Loading database: %s' % db) data_set = load_data(db, args.image_size, args) ver_list.append(data_set) ver_name_list.append(db) cur_epoch, cur_global_step, cur_epoch_step = sess.run( [epoch, global_step, epoch_step]) print('****************************************') print( f'Continuous training on EPOCH={cur_epoch}, GLOBAL_STEP={cur_global_step}, EPOCH_STEP={cur_epoch_step}' ) print('****************************************') total_losses_per_summary = [] inference_losses_per_summary = [] train_acc_per_summary = [] avg_total_loss_per_summary = 0 avg_inference_loss_per_summary = 0 avg_train_acc_per_summary = 0 for i in range(cur_epoch, args.max_epoch + 1): sess.run(iterator.initializer) # Trained steps are ignored print(f'Skipping {cur_epoch_step} trained step..') start = time.time() for _j in range(cur_epoch_step): images_train, labels_train = sess.run(next_element) if _j % 1000 == 0: end = time.time() iter_time = end - start start = time.time() print(f'{_j}, time: {iter_time} seconds') print('***Traing started***') while True: try: start = time.time() images_train, labels_train = sess.run(next_element) feed_dict = { inputs: images_train, labels: labels_train, phase_train_placeholder: True } _, total_loss_val, inference_loss_val, reg_loss_val, _, acc_val = \ sess.run([train_op, total_loss, inference_loss, regularization_losses, inc_epoch_step_op, Accuracy_Op], feed_dict=feed_dict) end = time.time() pre_sec = args.train_batch_size / (end - start) cur_global_step += 1 cur_epoch_step += 1 total_losses_per_summary.append(total_loss_val) inference_losses_per_summary.append(inference_loss_val) train_acc_per_summary.append(acc_val) # print training information if cur_global_step > 0 and cur_global_step % args.show_info_interval == 0: print( 'epoch %d, total_step %d, epoch_step %d, total loss %.2f , inference loss %.2f, reg_loss %.2f, training accuracy %.6f, rate %.3f samples/sec' % (i, cur_global_step, cur_epoch_step, total_loss_val, inference_loss_val, np.sum(reg_loss_val), acc_val, pre_sec)) # save summary if cur_global_step > 0 and cur_global_step % args.summary_interval == 0: feed_dict = { inputs: images_train, labels: labels_train, phase_train_placeholder: True } summary_op_val = sess.run(summary_op, feed_dict=feed_dict) summary.add_summary(summary_op_val, cur_global_step) avg_total_loss_per_summary = sum( total_losses_per_summary) / len( total_losses_per_summary) total_losses_per_summary = [] avg_inference_loss_per_summary = sum( inference_losses_per_summary) / len( inference_losses_per_summary) inference_losses_per_summary = [] avg_train_acc_per_summary = sum( train_acc_per_summary) / len(train_acc_per_summary) train_acc_per_summary = [] # Create a new Summary object with your measure summary2 = tf.Summary() summary2.value.add( tag='avg_total_loss', simple_value=avg_total_loss_per_summary) summary2.value.add( tag='avg_inference_loss', simple_value=avg_inference_loss_per_summary) summary2.value.add( tag='avg_train_acc', simple_value=avg_train_acc_per_summary) # Add it to the Tensorboard summary writer # Make sure to specify a step parameter to get nice graphs over time summary.add_summary(summary2, cur_global_step) # save ckpt files if cur_global_step > 0 and cur_global_step % args.ckpt_interval == 0: filename = '{:d}_MobileFaceNet'.format( cur_global_step) + '.ckpt' filename = os.path.join(args.ckpt_path, filename) saver.save(sess, filename) # validate if cur_global_step > 0 and cur_global_step % args.validate_interval == 0: print( '-------------------------------------------------' ) print('\nIteration', cur_global_step, 'validating...') for db_index in range(len(ver_list)): start_time = time.time() data_sets, issame_list = ver_list[db_index] emb_array = np.zeros( (data_sets.shape[0], args.embedding_size)) if data_sets.shape[0] % args.test_batch_size == 0: nrof_batches = data_sets.shape[ 0] // args.test_batch_size else: nrof_batches = data_sets.shape[ 0] // args.test_batch_size + 1 for index in range( nrof_batches ): # actual is same multiply 2, test data total start_index = index * args.test_batch_size end_index = min( (index + 1) * args.test_batch_size, data_sets.shape[0]) feed_dict = { inputs: data_sets[start_index:end_index, ...], phase_train_placeholder: False } emb_array[start_index:end_index, :] = sess.run( embeddings, feed_dict=feed_dict) tpr, fpr, accuracy, val, val_std, far = evaluate( emb_array, issame_list, nrof_folds=args.eval_nrof_folds) duration = time.time() - start_time print( "---Total time %.3fs to evaluate %d images of %s" % (duration, data_sets.shape[0], ver_name_list[db_index])) print('\t- Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy))) print( '\t- Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far)) print('\t- FPR and TPR: %1.3f %1.3f' % (np.mean(fpr, 0), np.mean(tpr, 0))) auc = metrics.auc(fpr, tpr) print('\t- Area Under Curve (AUC): %1.3f' % auc) # eer = brentq(lambda x: 1. - x - interpolate.interp1d(fpr, tpr)(x), 0., 1.) # print('Equal Error Rate (EER): %1.3f\n' % eer) with open( os.path.join( args.log_file_path, '{}_result.txt'.format( ver_name_list[db_index])), 'at') as f: f.write('%d\t%.5f\t%.5f\t%.5f\t%.5f\t%.5f\n' % (cur_global_step, np.mean(accuracy), val, val_std, far, auc)) if ver_name_list[db_index] == 'lfw' and np.mean( accuracy) > 0.994: print('High accuracy: %.5f' % np.mean(accuracy)) filename = 'MobileFaceNet_iter_best_{:d}'.format( cur_global_step) + '.ckpt' filename = os.path.join( args.ckpt_best_path, filename) saver.save(sess, filename) print( '---------------------------------------------------' ) except tf.errors.OutOfRangeError: _, _ = sess.run([inc_epoch_op, reset_epoch_step_op]) # Save checkpoint filename = '{:d}_MobileFaceNet'.format( cur_global_step) + '.ckpt' filename = os.path.join(args.ckpt_path, filename) saver.save(sess, filename) cur_epoch_step = 0 print("\n\n-------End of epoch %d\n\n" % i) break