def classifier_dataset(self, data_path, modelName): init_value.init_value.init(self) with tf.Graph().as_default(): with tf.Session() as sess: dataset = facenet.get_dataset(data_path) paths, labels = facenet.get_image_paths_and_labels(dataset) print('Number of classes: %d' % len(dataset)) print('Number of images: %d' % len(paths)) print('Loading feature extraction model') # get Model Path facenet.get_pre_model_path(self.pre_model_url, self.pre_model_zip, self.model_path, self.pre_model_name) facenet.load_model(self.pre_model_name) 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 nrof_images = len(paths) nrof_batches_per_epoch = int( math.ceil(1.0 * nrof_images / self.batch_size)) emb_array = np.zeros((nrof_images, embedding_size)) print('Calculating features for images:(' + str(len(range(nrof_batches_per_epoch))) + ')') for i in range(nrof_batches_per_epoch): print('features :' + str(i)) start_index = i * self.batch_size end_index = min((i + 1) * self.batch_size, nrof_images) paths_batch = paths[start_index:end_index] images = facenet.load_data(paths_batch, False, False, self.image_size) feed_dict = { images_placeholder: images, phase_train_placeholder: False } emb_array[start_index:end_index, :] = sess.run( embeddings, feed_dict=feed_dict) classifier_filename = modelName classifier_filename_exp = os.path.expanduser( classifier_filename) # Train classifier print('Training classifier') model = SVC(kernel='linear', probability=True) 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)
def roc(self, data_path, modelName, eval_path): init_value.init_value.init(self) with tf.Graph().as_default(): with tf.Session() as sess: dataset = facenet.get_dataset(data_path) paths, labels = facenet.get_image_paths_and_labels(dataset) print('Number of classes: %d' % len(dataset)) print('Number of images: %d' % len(paths)) eval_dataset = facenet.get_dataset(eval_path) eval_paths, eval_labels = facenet.get_image_paths_and_labels( eval_dataset) print('Number of classes: %d' % len(eval_dataset)) print('Number of images: %d' % len(eval_paths)) eval_labels = np.asarray(eval_labels) classes = [] for i in range(len(dataset)): classes.append(i) eval_labels = label_binarize(eval_labels, classes=classes) print('Loading feature extraction model') # get Model Path facenet.get_pre_model_path(self.pre_model_url, self.pre_model_zip, self.model_path, self.pre_model_name) facenet.load_model(self.pre_model_name) 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 nrof_images = len(paths) nrof_batches_per_epoch = int( math.ceil(1.0 * nrof_images / self.batch_size)) emb_array = np.zeros((nrof_images, embedding_size)) print('Calculating features for images:(' + str(len(range(nrof_batches_per_epoch))) + ')') for i in range(nrof_batches_per_epoch): print('features :' + str(i)) start_index = i * self.batch_size end_index = min((i + 1) * self.batch_size, nrof_images) paths_batch = paths[start_index:end_index] images = facenet.load_data(paths_batch, False, False, self.image_size) feed_dict = { images_placeholder: images, phase_train_placeholder: False } emb_array[start_index:end_index, :] = sess.run( embeddings, feed_dict=feed_dict) # eval_nrof_images = len(eval_paths) # eval_nrof_batches_per_epoch = int(math.ceil(1.0 * eval_nrof_images / self.batch_size)) # eval_emb_array = np.zeros((eval_nrof_images, embedding_size)) # print('Calculating features for images:(' + str(len(range(eval_nrof_batches_per_epoch))) + ')') # for i in range(eval_nrof_batches_per_epoch): # print('features :' + str(i)) # start_index = i * self.batch_size # end_index = min((i + 1) * self.batch_size, eval_nrof_images) # paths_batch = eval_paths[start_index:end_index] # images = facenet.load_data(paths_batch, False, False, self.image_size) # feed_dict = {images_placeholder: images, phase_train_placeholder: False} # eval_emb_array[start_index:end_index, :] = sess.run(embeddings, feed_dict=feed_dict) classifier_filename = modelName classifier_filename_exp = os.path.expanduser( classifier_filename) # Train classifier print('Training classifier') model = SVC(kernel='linear', probability=True) model.fit(emb_array, labels) # Learn to predict each class against the other random_state = np.random.RandomState(0) classifier = OneVsRestClassifier( svm.SVC(kernel='linear', probability=True, random_state=random_state)) #y_score = classifier.fit(emb_array, labels).decision_function(eval_emb_array) y_score = classifier.fit(emb_array, labels).decision_function(emb_array) # Compute ROC curve and ROC area for each class fpr = dict() tpr = dict() roc_auc = dict() #for i in range(n_classes): fpr[len(dataset) - 1], tpr[len(dataset) - 1], _ = roc_curve( eval_labels[:, len(dataset) - 1], y_score[:, len(dataset) - 1]) roc_auc[len(dataset) - 1] = auc(fpr[len(dataset) - 1], tpr[len(dataset) - 1]) # Compute micro-average ROC curve and ROC area fpr["micro"], tpr["micro"], _ = roc_curve( eval_labels.ravel(), y_score.ravel()) roc_auc["micro"] = auc(fpr["micro"], tpr["micro"]) plt.figure() lw = 2 plt.plot(fpr[len(dataset) - 1], tpr[len(dataset) - 1], color='darkorange', lw=lw, label='ROC curve (area = %0.2f)' % roc_auc[len(dataset) - 1]) 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()
def realtime_run(self, modelName, detectType=None, evalType=None): ''' :param modelName: 사용할 자신의 Classifier Model self.model_name_detect : detect만 사용한 모델이다. self.model_name_rotdet : Rotate->Detect를 사용한 모델이다. :param detectType: 예측할 영상의 이미지 전처리 선택 detect : 예측 영상의 얼굴 Detect만 한다. rotdet : 예측 영상의 얼굴 Rotate->Detect를 한다. :param evalType: 출력을 어떻게 지정할 지 선택을 해준다. eval : eval_data에 있는 전체 데이터를 가져와 평가를 수행한다. test : eval_data에 있는 폴더별 첫번째 데이터만 예측하여 보여준다. real : 실제 영상을 예측하여 보여준다. :return: ''' self.detectType = detectType self.evalType = evalType with tf.Graph().as_default(): gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=0.6) sess = tf.Session(config=tf.ConfigProto( gpu_options=gpu_options, log_device_placement=False)) with sess.as_default(): self.pnet, self.rnet, self.onet = detect_face.create_mtcnn( sess, self.dets_path) # get Model Path facenet.get_pre_model_path(self.pre_model_url, self.pre_model_zip, self.model_path, self.pre_model_name) facenet.load_model(self.pre_model_name) self.images_placeholder = tf.get_default_graph( ).get_tensor_by_name("input:0") self.embeddings = tf.get_default_graph().get_tensor_by_name( "embeddings:0") self.embedding_size = self.embeddings.get_shape()[1] self.phase_train_placeholder = tf.get_default_graph( ).get_tensor_by_name("phase_train:0") classifier_filename = modelName classifier_filename_exp = os.path.expanduser( classifier_filename) with open(classifier_filename_exp, 'rb') as infile: (self.model, class_names) = pickle.load(infile) print('load classifier file-> %s' % classifier_filename_exp) print('') # Sort를 해주는 이유는 기존에 Sequnce를 위해 앞에 붙여둔 것을 제거 하기 위함이다.(L00001_) self.HumanNamesSort = sorted(os.listdir(self.train_data_path)) self.HumanNames = [] for h in self.HumanNamesSort: h_split = h.split('_') self.HumanNames.append(h_split[1]) self.predictor, self.detector = AlignDatasetRotation( ).face_rotation_predictor_download() if evalType == "eval": self.facenet_eval(sess) else: self.facenet_capture(sess)