'phase_train:0') embedding_size = embeddings.get_shape()[1] # Run a forward pass to calculate the image # vector embeddings. print('Calculating image features...') batch_size = 500 # 1000 image_size = 160 nrof_images = len(paths) nrof_batches_per_epoch = int(math.ceil(1.0 * nrof_images / batch_size)) embedding_arr = np.zeros((nrof_images, embedding_size)) for i in range(nrof_batches_per_epoch): start_index = i * batch_size end_index = min((i + 1) * batch_size, nrof_images) paths_batch = paths[start_index:end_index] images = facenet.load_data(paths_batch, False, False, image_size) feed_dict = { images_placeholder: images, phase_train_placeholder: False } embedding_arr[start_index:end_index, :] = sess.run( embeddings, feed_dict=feed_dict) # Setup the classifier for classifing new images # based on their embedding vector. classifier_filename = './my_classifier/SVC.pkl' classifier_filename_exp = os.path.expanduser(classifier_filename) # Train the classifier print('Training classifier...') model = SVC(kernel='linear', probability=True)
def main(): args = parse_args() align_command = 'python align_dataset_mtcnn.py ' + args.input_dir + args.align_dir + ' --image_size 182' + ' --margin 44' os.system(align_command) print("-------- Alignment Completed ----------") with tf.Graph().as_default(): with tf.Session() as sess: np.random.seed(666) datadir = args.align_dir embeddingdir = "data/new_person_embedding/" modeldir = args.model_path dataset = facenet.get_dataset(datadir) paths, labels = facenet.get_image_paths_and_labels(dataset) print(labels) # # Create a list of class names #class_names = [cls.name.replace('_', ' ') for cls in dataset] #label_name = [class_names[i] for i in labels] print('Number of classes: {}'.format(len(dataset))) print('Number of images: {}'.format(len(paths))) print('Loading feature extraction model') facenet.load_model(modeldir) images_placeholder = tf.get_default_graph().get_tensor_by_name( "input:0") embeddings = tf.get_default_graph().get_tensor_by_name( "embeddings:0") phase_train_placeholder = tf.get_default_graph( ).get_tensor_by_name("phase_train:0") embedding_size = embeddings.get_shape()[1] print(embedding_size) # Run forward pass to calculate embeddings print('Calculating features for images') batch_size = 200 image_size = 160 nrof_images = len(paths) nrof_batches_per_epoch = int( math.ceil(1.0 * nrof_images / batch_size)) emb_array = np.zeros((nrof_images, embedding_size)) for i in range(nrof_batches_per_epoch): print('{}/{}'.format(i, nrof_batches_per_epoch)) start_index = i * batch_size end_index = min((i + 1) * batch_size, nrof_images) paths_batch = paths[start_index:end_index] images = facenet.load_data(paths_batch, False, False, image_size) feed_dict = { images_placeholder: images, phase_train_placeholder: False } emb_array[start_index:end_index, :] = sess.run( embeddings, feed_dict=feed_dict) # store embedding and labels np.savetxt(embeddingdir + 'embedding.csv', emb_array, delimiter=",") with open(embeddingdir + 'label.csv', 'w') as f: writer = csv.writer(f) writer.writerows(zip(labels, paths)) # merge 2 embedding files merge_embedding_files("data/embedding/", embeddingdir, "embedding.csv") merge_label_files("data/embedding/", embeddingdir, "label.csv") # re-train the classifier start = time.time() fname = "data/embedding/label.csv" labels = pd.read_csv(fname, header=None).as_matrix()[:, 1] labels = map(itemgetter(1), map(os.path.split, map(os.path.dirname, labels))) # Get the directory. print(labels) print('list labels') labels = list(labels) print(labels) fname = "data/embedding/embedding.csv" embeddings = pd.read_csv(fname, header=None).as_matrix() le = LabelEncoder().fit(labels) class_names = list(le.classes_) class_names = [i.replace("_", " ") for i in class_names] labelsNum = le.transform(labels) #print(labelsNum) print(class_names) print(labelsNum) classifier_filename_exp = os.path.expanduser( args.classifier_filename) print('Start training classifier') if (args.classifier == 'SVM'): model = SVC(kernel='linear', probability=True) elif (args.classifier == 'KNN'): model = KNeighborsClassifier(n_neighbors=1) elif (args.classifier == 'LinearSVC'): model = LinearSVC(random_state=0, tol=1e-5) else: model = RandomForestClassifier(n_estimators=2000, max_depth=100, max_features='sqrt', n_jobs=-1) model.fit(embeddings, labelsNum) print( "Re-train the classifier took {} seconds.".format(time.time() - start)) print('End training classifier') print(le) # saving classifier model with open(classifier_filename_exp, 'wb') as outfile: pickle.dump((model, class_names), outfile) print('Saved classifier model to file "%s"' % classifier_filename_exp) print('Goodluck')
def main(): args = parse_args() with tf.Graph().as_default(): with tf.Session() as sess: np.random.seed(666) datadir = args.align_dir modeldir = args.model_path dataset = facenet.get_dataset(datadir) #f_map = "data/embedding/maps.csv" paths, labels = facenet.get_image_paths_and_labels(dataset) label1 = [] for i in paths: person_name = i.split('/')[-2] label1.append(person_name) #map_test = pd.read_csv(f_map, header=None) #labelnum = [] #for i in label1: #ID = int(map_test.loc[map_test[1]==i, 0].values) #labelnum.append(ID) label1 = [i.replace("_", " ") for i in label1] print('Number of classes: {}'.format(len(dataset))) print('Number of images: {}'.format(len(paths))) print('Loading feature extraction model') facenet.load_model(modeldir) images_placeholder = tf.get_default_graph().get_tensor_by_name( "input:0") embeddings = tf.get_default_graph().get_tensor_by_name( "embeddings:0") phase_train_placeholder = tf.get_default_graph( ).get_tensor_by_name("phase_train:0") embedding_size = embeddings.get_shape()[1] # Run forward pass to calculate embeddings print('Calculating features for images') batch_size = 200 image_size = 160 nrof_images = len(paths) nrof_batches_per_epoch = int( math.ceil(1.0 * nrof_images / batch_size)) emb_array = np.zeros((nrof_images, embedding_size)) for i in range(nrof_batches_per_epoch): print('{}/{}'.format(i, nrof_batches_per_epoch)) start_index = i * batch_size end_index = min((i + 1) * batch_size, nrof_images) paths_batch = paths[start_index:end_index] images = facenet.load_data(paths_batch, False, False, image_size) feed_dict = { images_placeholder: images, phase_train_placeholder: False } emb_array[start_index:end_index, :] = sess.run( embeddings, feed_dict=feed_dict) print('Testing classifier') classifier_filename_exp = os.path.expanduser( args.classifier_filename) with open(classifier_filename_exp, 'rb') as infile: (model, class_names) = pickle.load(infile) labelnum = [] for i in label1: num = class_names.index(i) labelnum.append(num) print('Loaded classifier model from file "%s"' % classifier_filename_exp) print(class_names) predictions = model.predict(emb_array) print(predictions) best_class_indices = predictions #best_class_probabilities = predictions[np.arange(len(best_class_indices)), best_class_indices] #for i in range(len(best_class_indices)): #print('%4d %s: %.3f' % (i, class_names[best_class_indices[i]], best_class_probabilities[i])) print(best_class_indices) print('labelnum') print(labelnum) report = precision_recall_fscore_support(labelnum, best_class_indices, average='weighted') print(report[2])
def main(args): os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_idx network = importlib.import_module(args.model_def) ckpt_model_path = args.ckpt_model_path save_pb_path = args.save_pb_path # eval from ckpt(fake_ckpt) create_inference_graph(network) g = tf.get_default_graph() tf.contrib.quantize.create_eval_graph(input_graph=g) all_vars = tf.global_variables() print("eval global vars: \n +++++++++++++++++++++\n") for var in all_vars: print(var.name) print("++++++++++++++++++++++++++") saver = tf.train.Saver(tf.global_variables()) sess = tf.Session() with sess.as_default(): saver.restore(sess, ckpt_model_path) input_saver_def = saver.as_saver_def() frozen_graph_def = freeze_graph.freeze_graph_with_def_protos( input_graph_def=tf.get_default_graph().as_graph_def(), input_saver_def=input_saver_def, input_checkpoint=ckpt_model_path, output_node_names='embeddings', restore_op_name='', filename_tensor_name='', clear_devices=True, output_graph='', initializer_nodes='') binary_graph = save_pb_path with tf.gfile.GFile(binary_graph, 'wb') as f: f.write(frozen_graph_def.SerializeToString()) # evaluate test pairs acc paths, actual_issame = get_test_path.get_paths(os.path.expanduser(args.my_data_dir)) path_all = {"paths": paths, "actual_issame": actual_issame, "type": "MY_DATA"} images_placeholder = tf.get_default_graph().get_tensor_by_name("input:0") embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0") image_size = args.image_size embedding_size = embeddings.get_shape()[1] paths = path_all["paths"] actual_issame = path_all["actual_issame"] batch_size = args.batch_size nrof_images = len(paths) nrof_batches = int(math.ceil(1.0 * nrof_images / batch_size)) emb_array = np.zeros((nrof_images, embedding_size)) # ipdb.set_trace() for i in range(nrof_batches): start_index = i * batch_size end_index = min((i + 1) * batch_size, nrof_images) print("get embedding,idx start %d,idx end %d" % (start_index, end_index)) paths_batch = paths[start_index:end_index] images = facenet.load_data( paths_batch, False, False, image_size) feed_dict = {images_placeholder: images} emb_array[start_index:end_index, :] = sess.run(embeddings, feed_dict=feed_dict) # ipdb.set_trace() tpr, fpr, accuracy, val, val_std, far, acc_dot, recall, fpr_dot, percision_dot, dot_product_all, fp_idxs, fn_idxs, recall_th, percision_th, acc_th = lfw.evaluate(emb_array, actual_issame) """ embeddings1 = emb_array[0::2] embeddings2 = emb_array[1::2] dot_product_all = np.sum(embeddings1 * embeddings2, 1) f = open("/data1/lishanlu/raw_data/dot_score.txt","w") f.write(str(dot_product_all)) f.close() """ print('Accuracy: %1.3f+-%1.3f' % (np.mean(accuracy), np.std(accuracy))) print('tpr: %1.3f+-%1.3f' % (np.mean(tpr), np.std(tpr))) print('fpr: %1.3f+-%1.3f' % (np.mean(fpr), np.std(fpr))) print('Validation rate: %2.5f+-%2.5f @ FAR=%2.5f' % (val, val_std, far)) print("\nacc_dot:%1.3f,recall:%1.3f,fpr_dot:%1.3f,percision_dot:%1.3f" % (acc_dot, recall, fpr_dot, percision_dot))
def main(args): with tf.Graph().as_default(): with tf.Session() as sess: np.random.seed(seed=args.seed) embeddingdir = "data/embedding/" if args.use_split_dataset: dataset_tmp = facenet.get_dataset(args.data_dir) train_set, test_set = split_dataset( dataset_tmp, args.min_nrof_images_per_class, args.nrof_train_images_per_class) if (args.mode == 'TRAIN'): dataset = train_set elif (args.mode == 'CLASSIFY'): dataset = test_set else: dataset = facenet.get_dataset(args.data_dir) # Check that there are at least one training image per class for cls in dataset: assert ( len(cls.image_paths) > 0, 'There must be at least one image for each class in the dataset' ) paths, labels = facenet.get_image_paths_and_labels(dataset) # Create a new label list containing names instead of numbers class_names = [cls.name.replace('_', ' ') for cls in dataset] label_name = [class_names[i] for i in labels] print('Number of classes: %d' % len(dataset)) print('Number of images: %d' % len(paths)) # Load the model print('Loading feature extraction model') facenet.load_model(args.model) # Get input and output tensors images_placeholder = tf.get_default_graph().get_tensor_by_name( "input:0") embeddings = tf.get_default_graph().get_tensor_by_name( "embeddings:0") phase_train_placeholder = tf.get_default_graph( ).get_tensor_by_name("phase_train:0") embedding_size = embeddings.get_shape()[1] print(embedding_size) # Run forward pass to calculate embeddings print('Calculating features for images') nrof_images = len(paths) nrof_batches_per_epoch = int( math.ceil(1.0 * nrof_images / args.batch_size)) emb_array = np.zeros((nrof_images, embedding_size)) for i in range(nrof_batches_per_epoch): start_index = i * args.batch_size end_index = min((i + 1) * args.batch_size, nrof_images) paths_batch = paths[start_index:end_index] images = facenet.load_data(paths_batch, False, False, args.image_size) feed_dict = { images_placeholder: images, phase_train_placeholder: False } emb_array[start_index:end_index, :] = sess.run( embeddings, feed_dict=feed_dict) # Store embedding and labels np.savetxt(embeddingdir + 'embedding.csv', emb_array, delimiter=",") with open(embeddingdir + 'label.csv', 'w') as f: writer = csv.writer(f) writer.writerows(zip(labels, paths)) classifier_filename_exp = os.path.expanduser( args.classifier_filename) if (args.mode == 'TRAIN'): # Train classifier print('Training classifier') if (args.classifier == 'SVM'): model = SVC(kernel='linear', probability=True) elif (args.classifier == 'KNN'): model = KNeighborsClassifier(n_neighbors=1) elif (args.classifier == 'Softmax'): model = LogisticRegression(random_state=0, solver='lbfgs', multi_class='multinomial') else: model = RandomForestClassifier(n_estimators=1000, max_leaf_nodes=100, n_jobs=-1) model.fit(emb_array, labels) # Create a list of class names class_names = [cls.name.replace('_', ' ') for cls in dataset] # Saving classifier model with open(classifier_filename_exp, 'wb') as outfile: pickle.dump((model, class_names), outfile) print('Saved classifier model to file "%s"' % classifier_filename_exp) elif (args.mode == 'CLASSIFY'): # Classify images print('Testing classifier') with open(classifier_filename_exp, 'rb') as infile: (model, class_names) = pickle.load(infile) print('Loaded classifier model from file "%s"' % classifier_filename_exp) predictions = model.predict_proba(emb_array) best_class_indices = np.argmax(predictions, axis=1) best_class_probabilities = predictions[ np.arange(len(best_class_indices)), best_class_indices] for i in range(len(best_class_indices)): print('%4d %s: %.3f' % (i, class_names[best_class_indices[i]], best_class_probabilities[i])) accuracy = np.mean(np.equal(best_class_indices, labels)) report = precision_recall_fscore_support(labels, best_class_indices, average='weighted') print(report[2]) print('Accuracy: %.3f' % accuracy)