text: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  from sklearn.manifold import TSNE
  
  import math
  import os
  import pickle
  import matplotlib.pyplot as plt
  import numpy as np
  import tensorflow as tf
  import time
  from sklearn.svm import SVC
  
  from packages import facenet
  
  
  class training:
      def __init__(self, datadir, modeldir,classifier_filename):
          self.datadir = datadir
          self.modeldir = modeldir
          self.classifier_filename = classifier_filename
  
      def main_train(self):
          with tf.Graph().as_default():
              with tf.Session() as sess:
                  img_data = facenet.get_dataset(self.datadir)
                  path, label = facenet.get_image_paths_and_labels(img_data)
                  print("label")
                  print(label)
                  print('Classes: %d' % len(img_data))
                  print('Images: %d' % len(path))
  
                  facenet.load_model(self.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('Extracting features of images for model')
                  batch_size = 1000
                  image_size = 160
                  nrof_images = len(path)
                  nrof_batches_per_epoch = int(math.ceil(1.0 * nrof_images / batch_size))
                  emb_array = np.zeros((nrof_images, embedding_size))
                  print(nrof_batches_per_epoch)
                  for i in range(nrof_batches_per_epoch):
                      start_index = i * batch_size
                      end_index = min((i + 1) * batch_size, nrof_images)
                      paths_batch = path[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)
  
                  class_names = [cls.name.replace('_', ' ') for cls in img_data]
                  classifier_file_name = os.path.expanduser(self.classifier_filename)
                  print('emb_array')
                  print(emb_array)
                  X_embedded = TSNE(n_components=2).fit_transform(emb_array)
                  print('X_embedded')
                  print(X_embedded)
                  faces_group = np.zeros((nrof_images, embedding_size))
                  for i in range(0, nrof_images-1):
                      print("i: ")
                      print(i)
                      j = label[i]
                      print("j: ")
                      print(j)
                      faces_group[j].append(X_embedded[i])
                      #plt.plot(X_embedded[i, 0], X_embedded[i, 1], label=name)#label=name)
                      #plt.scatter(X_embedded[i, 0], X_embedded[i, 1], label=name)
                  for i in enumerate(set(faces_group)):
                      name = class_names[i]
                      plt.scatter(faces_group[i, 0], faces_group[i, 1], label=name)
                  plt.legend(bbox_to_anchor=(1, 1))
                  #plt.axis([-50, 50, -50, 50])
                  plt.show()
                  #time.sleep(5)
                  #plt.imshow()
                  # Training Started
                  print('Training Started')
                  model = SVC(kernel='linear', probability=True)
                  model.fit(emb_array, label)
  
  
                  print(class_names)
                  # Saving model
                  with open(classifier_file_name, 'wb') as outfile:
                      pickle.dump((model, class_names), outfile)
                  return classifier_file_name
  