first commit

README.md

@@ -0,0 +1,100 @@
+# Politicians_FaceRecongnise
+
+## Introduction
+This is a project to realise 55 Chinese politicians face recongnise. refernce the repository ([facenet](https://github.com/davidsandberg/facenet.git)).
+## Pre-trained models
+| Model name      | LFW accuracy | Training dataset | Architecture |
+|-----------------|--------------|------------------|-------------|
+| [20170511-185253(models/policy/embeding.pb)](https://drive.google.com/file/d/0B5MzpY9kBtDVOTVnU3NIaUdySFE) | 0.987        | CASIA-WebFace    | [Inception ResNet v1](https://github.com/davidsandberg/facenet/blob/master/src/models/inception_resnet_v1.py) |
+
+
+# About the code,I run it in python
+## Dependencies
+The code is tested using Tensorflow 0.12 under Ubuntu 16.04 with Python3.6 and Python3.5
+* tensorflow>0.12
+* sklearn
+* matpl
+* numpy
+* scipy
+* pickle
+* cv2
+* matplotlib
+
+if you want to change the pictures ,in order to use your own data,also if someone is interested to use my dataset about 55 Chinese politicians,you can email to me ,I am glad to share you my dataset. 
+1. put your images that haven't be aligned into the directory align/images/,like:
+   ```
+   align/images/policy/
+         people1/
+               1.jpg
+               2.jpg
+         people2/
+               1.jpg
+               2.jpg
+   ```
+
+2. you can change the input or output directory 
+    ```
+    parser.add_argument('--input_dir', type=str, help='Directory with unaligned images.',default='images/policy/')
+    parser.add_argument('--output_dir', type=str, help='Directory with aligned face thumbnails.',default='images/aligned_policy/')
+    ```
+
+then run the code
+
+    ```
+    python align_dataset_mtcnn.py
+    ```
+
+after run this code ,you will get the anigned_pictures,you can change the parameters to choose if you want to detect_multiple_faces,the result like:
+
+    ```
+    align/images/aligned_policy/
+        people1/
+               1.jpg
+               2.jpg
+               2_2.jpg
+        people2/
+               1.jpg
+               1_1.jpg
+               2.jpg
+    ```
+
+3. copy the files align/images/aligned_policy into images/ 
+
+if you want to use my model directly,and run my project and see the result, you can
+
+1. show the politician pictures and see the prediction or show the other people which is not the politicican one by one:
+    ```
+    python calacc_plt.py
+    python calerror_plt.py
+    ```
+
+2. I alse provide the multi thread python code to calculate the accuracy.
+    ```
+    python multiThread_process.py
+    ```
+
+# Results
+1. can recongnise profile 
+
+![Figure_1](/result/Figure_1.png)
+
+2. alse has some error
+
+![Figure_1-1](/result/Figure_1-1.png)
+
+3. can recongise sepcial part face
+
+![Figure_1-2](/result/Figure_1-2.png)
+
+4. can recongise sepcial part face
+
+![Figure_1-3](/result/Figure_1-3.png)
+
+5. as for the others
+
+![Figure_1-5](/result/Figure_1-5.png)
+
+6. as for the others
+
+![Figure_1-6](/result/Figure_1-6.png)
+

align/align_dataset_mtcnn.py

@@ -0,0 +1,159 @@
+"""Performs face alignment and stores face thumbnails in the output directory."""
+# MIT License
+# 
+# Copyright (c) 2016 David Sandberg
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+
+from scipy import misc
+import sys
+import os
+import argparse
+import tensorflow as tf
+import numpy as np
+import facenet
+import detect_face
+import random
+from time import sleep
+
+def main(args):
+    sleep(random.random())
+    output_dir = os.path.expanduser(args.output_dir)
+    if not os.path.exists(output_dir):
+        os.makedirs(output_dir)
+    # Store some git revision info in a text file in the log directory
+    src_path,_ = os.path.split(os.path.realpath(__file__))
+    facenet.store_revision_info(src_path, output_dir, ' '.join(sys.argv))
+    dataset = facenet.get_dataset(args.input_dir)
+
+    print('Creating networks and loading parameters')
+
+    with tf.Graph().as_default():
+        gpu_options = tf.GPUOptions(per_process_gpu_memory_fraction=args.gpu_memory_fraction)
+        sess = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options, log_device_placement=False))
+        with sess.as_default():
+            pnet, rnet, onet = detect_face.create_mtcnn(sess, None)
+
+    minsize = 20 # minimum size of face
+    threshold = [ 0.6, 0.7, 0.7 ]  # three steps's threshold
+    factor = 0.709 # scale factor
+
+    # Add a random key to the filename to allow alignment using multiple processes
+    random_key = np.random.randint(0, high=99999)
+    bounding_boxes_filename = os.path.join(output_dir, 'bounding_boxes_%05d.txt' % random_key)
+
+    with open(bounding_boxes_filename, "w") as text_file:
+        nrof_images_total = 0
+        nrof_successfully_aligned = 0
+        if args.random_order:
+            random.shuffle(dataset)
+        for cls in dataset:
+            output_class_dir = os.path.join(output_dir, cls.name)
+            if not os.path.exists(output_class_dir):
+                os.makedirs(output_class_dir)
+                if args.random_order:
+                    random.shuffle(cls.image_paths)
+            for image_path in cls.image_paths:
+                nrof_images_total += 1
+                filename = os.path.splitext(os.path.split(image_path)[1])[0]
+                output_filename = os.path.join(output_class_dir, filename+'.png')
+                print(image_path)
+                if not os.path.exists(output_filename):
+                    try:
+                        img = misc.imread(image_path)
+                    except (IOError, ValueError, IndexError) as e:
+                        errorMessage = '{}: {}'.format(image_path, e)
+                        print(errorMessage)
+                    else:
+                        if img.ndim<2:
+                            print('Unable to align "%s"' % image_path)
+                            text_file.write('%s\n' % (output_filename))
+                            continue
+                        if img.ndim == 2:
+                            img = facenet.to_rgb(img)
+                        img = img[:,:,0:3]
+
+                        bounding_boxes, _ = detect_face.detect_face(img, minsize, pnet, rnet, onet, threshold, factor)
+                        nrof_faces = bounding_boxes.shape[0]
+                        if nrof_faces>0:
+                            det = bounding_boxes[:,0:4]
+                            det_arr = []
+                            img_size = np.asarray(img.shape)[0:2]
+                            if nrof_faces>1:
+                                if args.detect_multiple_faces:
+                                    for i in range(nrof_faces):
+                                        det_arr.append(np.squeeze(det[i]))
+                                else:
+                                    bounding_box_size = (det[:,2]-det[:,0])*(det[:,3]-det[:,1])
+                                    img_center = img_size / 2
+                                    offsets = np.vstack([ (det[:,0]+det[:,2])/2-img_center[1], (det[:,1]+det[:,3])/2-img_center[0] ])
+                                    offset_dist_squared = np.sum(np.power(offsets,2.0),0)
+                                    index = np.argmax(bounding_box_size-offset_dist_squared*2.0) # some extra weight on the centering
+                                    det_arr.append(det[index,:])
+                            else:
+                                det_arr.append(np.squeeze(det))
+
+                            for i, det in enumerate(det_arr):
+                                det = np.squeeze(det)
+                                bb = np.zeros(4, dtype=np.int32)
+                                bb[0] = np.maximum(det[0]-4/2, 0)
+                                bb[1] = np.maximum(det[1]-4/2, 0)
+                                bb[2] = np.minimum(det[2]+4/2, img_size[1])
+                                bb[3] = np.minimum(det[3]+4/2, img_size[0])
+                                cropped = img[bb[1]:bb[3],bb[0]:bb[2],:]
+                                scaled = misc.imresize(cropped, (args.image_size, args.image_size), interp='bilinear')
+                                nrof_successfully_aligned += 1
+                                filename_base, file_extension = os.path.splitext(output_filename)
+                                if args.detect_multiple_faces:
+                                    output_filename_n = "{}_{}{}".format(filename_base, i, file_extension)
+                                else:
+                                    output_filename_n = "{}{}".format(filename_base, file_extension)
+                                misc.imsave(output_filename_n, scaled)
+                                text_file.write('%s %d %d %d %d\n' % (output_filename_n, bb[0], bb[1], bb[2], bb[3]))
+                        else:
+                            print('Unable to align "%s"' % image_path)
+                            text_file.write('%s\n' % (output_filename))
+
+    print('Total number of images: %d' % nrof_images_total)
+    print('Number of successfully aligned images: %d' % nrof_successfully_aligned)
+
+
+def parse_arguments(argv):
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument('--input_dir', type=str, help='Directory with unaligned images.',default='images/policy/')
+    parser.add_argument('--output_dir', type=str, help='Directory with aligned face thumbnails.',default='images/aligned_policy/')
+    parser.add_argument('--image_size', type=int,
+        help='Image size (height, width) in pixels.', default=182)
+    parser.add_argument('--margin', type=int,
+        help='Margin for the crop around the bounding box (height, width) in pixels.', default=44)
+    parser.add_argument('--random_order', 
+        help='Shuffles the order of images to enable alignment using multiple processes.', action='store_true')
+    parser.add_argument('--gpu_memory_fraction', type=float,
+        help='Upper bound on the amount of GPU memory that will be used by the process.', default=1.0)
+    parser.add_argument('--detect_multiple_faces', type=bool,
+                        help='Detect and align multiple faces per image.', default=True)
+    return parser.parse_args(argv)
+
+if __name__ == '__main__':
+    main(parse_arguments(sys.argv[1:]))