text: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  
  import os
  os.environ['TF_CPP_MIN_LOG_LEVEL'] = '1'
  os.environ["CUDA_VISIBLE_DEVICES"] = "4"
  
  import tensorflow as tf
  import numpy as np
  import argparse
  import facenet
  import lfw
  import sys
  from tensorflow.python.ops import data_flow_ops
  from sklearn import metrics
  from scipy.optimize import brentq
  from scipy import interpolate
  
  def main(args):
      with tf.Graph().as_default():
          with tf.Session() as sess:
              # Read the file containing the pairs used for testing
              pairs = lfw.read_pairs(os.path.expanduser(args.lfw_pairs))
  
              # Get the paths for the corresponding images
              paths, actual_issame = lfw.get_paths(os.path.expanduser(args.lfw_dir), pairs)
              
              image_paths_placeholder = tf.placeholder(tf.string, shape=(None,1), name='image_paths')
              labels_placeholder = tf.placeholder(tf.int32, shape=(None,1), name='labels')
              batch_size_placeholder = tf.placeholder(tf.int32, name='batch_size')
              control_placeholder = tf.placeholder(tf.int32, shape=(None,1), name='control')
              phase_train_placeholder = tf.placeholder(tf.bool, name='phase_train')
   
              nrof_preprocess_threads = 4
              image_size = (args.image_size, args.image_size)
              eval_input_queue = data_flow_ops.FIFOQueue(capacity=2000000,
                                          dtypes=[tf.string, tf.int32, tf.int32],
                                          shapes=[(1,), (1,), (1,)],
                                          shared_name=None, name=None)
              eval_enqueue_op = eval_input_queue.enqueue_many([image_paths_placeholder, labels_placeholder, control_placeholder], name='eval_enqueue_op')
              image_batch, label_batch = facenet.create_input_pipeline(eval_input_queue, image_size, nrof_preprocess_threads, batch_size_placeholder)
       
              # Load the model
              input_map = {'image_batch': image_batch, 'label_batch': label_batch, 'phase_train': phase_train_placeholder}
  			#加载模型文件，自动判断是属于checkpoint文件类型还是pb文件
              facenet.load_model(args.model, input_map=input_map)
  
              # Get output tensor
              embeddings = tf.get_default_graph().get_tensor_by_name("embeddings:0")
  #              
              coord = tf.train.Coordinator()
              tf.train.start_queue_runners(coord=coord, sess=sess)
  
              evaluate(sess, eval_enqueue_op, image_paths_placeholder, labels_placeholder, phase_train_placeholder, batch_size_placeholder, control_placeholder,
                  embeddings, label_batch, paths, actual_issame, args.lfw_batch_size, args.lfw_nrof_folds, args.distance_metric, args.subtract_mean,
                  args.use_flipped_images, args.use_fixed_image_standardization)
  
                
  def evaluate(sess, enqueue_op, image_paths_placeholder, labels_placeholder, phase_train_placeholder, batch_size_placeholder, control_placeholder,
          embeddings, labels, image_paths, actual_issame, batch_size, nrof_folds, distance_metric, subtract_mean, use_flipped_images, use_fixed_image_standardization):
      # Run forward pass to calculate embeddings
      print('Runnning forward pass on LFW images')
      
      # Enqueue one epoch of image paths and labels
      nrof_embeddings = len(actual_issame)*2  # nrof_pairs * nrof_images_per_pair
      nrof_flips = 2 if use_flipped_images else 1
      nrof_images = nrof_embeddings * nrof_flips
      labels_array = np.expand_dims(np.arange(0,nrof_images),1)
      image_paths_array = np.expand_dims(np.repeat(np.array(image_paths),nrof_flips),1)
      control_array = np.zeros_like(labels_array, np.int32)
      if use_fixed_image_standardization:
          control_array += np.ones_like(labels_array)*facenet.FIXED_STANDARDIZATION
      if use_flipped_images:
          # Flip every second image
          control_array += (labels_array % 2)*facenet.FLIP
      sess.run(enqueue_op, {image_paths_placeholder: image_paths_array, labels_placeholder: labels_array, control_placeholder: control_array})
      
      embedding_size = int(embeddings.get_shape()[1])
      assert nrof_images % batch_size == 0, 'The number of LFW images must be an integer multiple of the LFW batch size'
      nrof_batches = nrof_images // batch_size
      emb_array = np.zeros((nrof_images, embedding_size))
      lab_array = np.zeros((nrof_images,))
      for i in range(nrof_batches):
          feed_dict = {phase_train_placeholder:False, batch_size_placeholder:batch_size}
          emb, lab = sess.run([embeddings, labels], feed_dict=feed_dict)
          lab_array[lab] = lab
          emb_array[lab, :] = emb
          if i % 10 == 9:
              print('.', end='')
              sys.stdout.flush()
      print('')
      embeddings = np.zeros((nrof_embeddings, embedding_size*nrof_flips))
      if use_flipped_images:
          # Concatenate embeddings for flipped and non flipped version of the images
          embeddings[:,:embedding_size] = emb_array[0::2,:]
          embeddings[:,embedding_size:] = emb_array[1::2,:]
      else:
          embeddings = emb_array
  
      assert np.array_equal(lab_array, np.arange(nrof_images))==True, 'Wrong labels used for evaluation, possibly caused by training examples left in the input pipeline'
      tpr, fpr, accuracy, val, val_std, far = lfw.evaluate(embeddings, actual_issame, nrof_folds=nrof_folds, distance_metric=distance_metric, subtract_mean=subtract_mean)
      
      print('Accuracy: %2.5f+-%2.5f' % (np.mean(accuracy), np.std(accuracy)))
      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' % eer)
      
  def parse_arguments(argv):
      parser = argparse.ArgumentParser()
      
      parser.add_argument('lfw_dir', type=str,
          help='Path to the data directory containing aligned LFW face patches.')
      parser.add_argument('--lfw_batch_size', type=int,
          help='Number of images to process in a batch in the LFW test set.', default=10)
      parser.add_argument('model', type=str, 
          help='Could be either a directory containing the meta_file and ckpt_file or a model protobuf (.pb) file')
      parser.add_argument('--image_size', type=int,
          help='Image size (height, width) in pixels.', default=160)
      parser.add_argument('--lfw_pairs', type=str,
          help='The file containing the pairs to use for validation.', default='../data/pairs.txt')
      parser.add_argument('--lfw_nrof_folds', type=int,
          help='Number of folds to use for cross validation. Mainly used for testing.', default=10)
      parser.add_argument('--distance_metric', type=int,
          help='Distance metric  0:euclidian, 1:cosine similarity.', default=0)
      parser.add_argument('--use_flipped_images', 
          help='Concatenates embeddings for the image and its horizontally flipped counterpart.', action='store_true')
      parser.add_argument('--subtract_mean', 
          help='Subtract feature mean before calculating distance.', action='store_true')
      parser.add_argument('--use_fixed_image_standardization', 
          help='Performs fixed standardization of images.', action='store_true')
      return parser.parse_args(argv)
  
  if __name__ == '__main__':
      main(parse_arguments(sys.argv[1:]))
  